WHILEY_SRC_DIR
directory.
*/
- protected void runTest(String name) {
+ protected void runTest(String testName) throws IOException {
// this will need to turn on verification at some point.
- name = WHILEY_SRC_DIR + File.separatorChar + name + ".whiley";
+ String whileyFilename = WHILEY_SRC_DIR + File.separatorChar + testName
+ + ".whiley";
Pair bytecodes,
// First, check whether there is a label to insert
Codes.Label label = labels.get(offset++);
if (label != null) { bytecodes.add(i++, label); }
-
+
// Second, check whether we have a nested block which needs to be
// explored.
if (bytecode instanceof Code.Compound) {
@@ -503,20 +503,20 @@ private int insertLabels(int offset, ArrayList bytecodes,
bytecodes.set(i,updateBytecodes(block,blkBytecodes));
}
}
-
+
// Finally, check whether or not there is a label at the end of this
// block.
Codes.Label label = labels.get(offset);
if (label != null) { bytecodes.add(bytecodes.size(), label); }
-
+
// Done
return offset;
}
-
+
/**
* This method reconstructs a given compound bytecode with a new list of
* bytecodes representing its body.
- *
+ *
* @param compound
* The compound bytecode being updated.
* @param bytecodes
@@ -536,12 +536,12 @@ private Code.Compound updateBytecodes(Code.Compound compound, ArrayList by
} else if(compound instanceof Codes.Loop) {
Codes.Loop l = (Codes.Loop) compound;
return Codes.Loop(l.modifiedOperands, bytecodes);
+ } else if(compound instanceof Codes.Invariant) {
+ return Codes.Invariant(bytecodes);
} else if(compound instanceof Codes.Assert) {
return Codes.Assert(bytecodes);
} else if(compound instanceof Codes.Assume) {
return Codes.Assume(bytecodes);
- } else if(compound instanceof Codes.Invariant) {
- return Codes.Invariant(bytecodes);
} else {
throw new IllegalArgumentException("Unknown compound bytecode encountered: " + compound.getClass().getName());
}
@@ -549,7 +549,7 @@ private Code.Compound updateBytecodes(Code.Compound compound, ArrayList by
/**
* Read all bytecodes between two given offsets.
- *
+ *
* @param offset
* Starting offset to read from
* @param count
@@ -574,7 +574,7 @@ public ArrayList readCodeBlock(int offset, int count,
* format corresponds to exactly one in the object representation. However,
* in the case of compound bytecodes (e.g. loop, forall, etc) then it
* represents one plus the number contained within the block itself.
- *
+ *
* @param code
* @return
*/
@@ -777,7 +777,7 @@ private Code readUnaryAssign(int opcode, boolean wideBase, boolean wideRest)
throw new RuntimeException("expected tuple type");
}
int index = readRest(wideRest);
- return Codes.TupleLoad((Type.Tuple) type, target, operand, index);
+ return Codes.TupleLoad((Type.EffectiveTuple) type, target, operand, index);
}
}
@@ -831,7 +831,7 @@ private Code readBinaryAssign(int opcode, boolean wideBase, boolean wideRest)
- Code.OPCODE_append];
return Codes.ListOperator((Type.EffectiveList) type, target,
leftOperand, rightOperand, kind);
- }
+ }
case Code.OPCODE_indexof: {
if (!(type instanceof Type.EffectiveIndexible)) {
throw new RuntimeException("expecting indexible type");
@@ -1021,7 +1021,7 @@ private Code readNaryAssign(int opcode, boolean wideBase, boolean wideRest)
}
return Codes.SubList((Type.EffectiveList) type, target,
operands[0], operands[1], operands[2]);
- }
+ }
}
throw new RuntimeException("unknown opcode encountered (" + opcode
+ ")");
@@ -1052,17 +1052,17 @@ private Code readOther(int opcode, boolean wideBase, boolean wideRest,
}
case Code.OPCODE_assertblock: {
int count = readRest(wideRest);
- ArrayList bytecodes = readCodeBlock(offset + 1, count, labels);
+ ArrayList bytecodes = readCodeBlock(offset + 1, count, labels);
return Codes.Assert(bytecodes);
}
case Code.OPCODE_assumeblock: {
int count = readRest(wideRest);
- ArrayList bytecodes = readCodeBlock(offset + 1, count, labels);
+ ArrayList bytecodes = readCodeBlock(offset + 1, count, labels);
return Codes.Assume(bytecodes);
}
case Code.OPCODE_invariantblock: {
int count = readRest(wideRest);
- ArrayList bytecodes = readCodeBlock(offset + 1, count, labels);
+ ArrayList bytecodes = readCodeBlock(offset + 1, count, labels);
return Codes.Invariant(bytecodes);
}
}
diff --git a/modules/wyil/src/wyil/io/WyilFileWriter.java b/modules/wyil/src/wyil/io/WyilFileWriter.java
index 5c2d64e152..36e47caba7 100644
--- a/modules/wyil/src/wyil/io/WyilFileWriter.java
+++ b/modules/wyil/src/wyil/io/WyilFileWriter.java
@@ -136,7 +136,7 @@ private void writeBlock(int kind, Object data, BinaryOutputStream output)
break;
case BLOCK_Method:
bytes = generateFunctionOrMethodBlock((WyilFile.FunctionOrMethod) data);
- break;
+ break;
case BLOCK_Body:
case BLOCK_Precondition:
case BLOCK_Postcondition:
@@ -398,13 +398,13 @@ private byte[] generateFunctionOrMethodBlock(WyilFile.FunctionOrMethod md) throw
output.write_uv(stringCache.get(md.name()));
output.write_uv(generateModifiers(md.modifiers()));
output.write_uv(typeCache.get(md.type()));
-
+
output.pad_u8(); // pad out to next byte boundary
-
+
int bodyCount = md.body() == null ? 0 : 1;
output.write_uv(md.precondition().size() + md.postcondition().size() + bodyCount);
-
+
for(CodeBlock requires : md.precondition()) {
writeBlock(BLOCK_Precondition,requires,output);
}
@@ -415,7 +415,7 @@ private byte[] generateFunctionOrMethodBlock(WyilFile.FunctionOrMethod md) throw
writeBlock(BLOCK_Body,md.body(),output);
}
// TODO: write annotations
-
+
output.close();
return bytes.toByteArray();
}
@@ -487,7 +487,7 @@ private void writeCodeBlock(boolean wide, CodeBlock block, int offset,
writeCode(code, offset, labels, output);
offset += WyilFileReader.sizeof(code);
}
- }
+ }
}
private void writeCode(Code code, int offset,
@@ -610,7 +610,7 @@ private void writeBase(boolean wide, Code code,
for(int i=0;i!=operands.length;++i) {
writeBase(wide,operands[i],output);
}
- }
+ }
}
/**
@@ -688,7 +688,7 @@ private void writeRest(boolean wide, Code code, int offset,
writeCodeBlock(wide,f,offset+1,labels,output);
} else if(code instanceof Codes.IfIs) {
Codes.IfIs c = (Codes.IfIs) code;
- int target = labels.get(c.target) - offset;
+ int target = labels.get(c.target);
writeRest(wide,typeCache.get(c.rightOperand),output);
writeTarget(wide,offset,target,output);
} else if(code instanceof Codes.If) {
@@ -719,7 +719,7 @@ private void writeRest(boolean wide, Code code, int offset,
} else if(code instanceof Codes.Switch) {
Codes.Switch c = (Codes.Switch) code;
List> branches = c.branches;
- int target = labels.get(c.defaultTarget) - offset;
+ int target = labels.get(c.defaultTarget);
writeTarget(wide,offset,target,output);
writeRest(wide,branches.size(),output);
for(Pair b : branches) {
@@ -1047,7 +1047,7 @@ private void buildPools(Code code) {
for(Pair b : s.branches) {
addConstantItem(b.first());
}
- }
+ }
// Second, deal with standard cases
if(code instanceof Code.AbstractUnaryOp) {
@@ -1294,7 +1294,7 @@ public NAME_Item(/*NAME_Kind kind, */int pathIndex, int nameIndex) {
public final static int MODIFIER_PROTECTION_MASK = 3;
public final static int MODIFIER_Private = 0;
public final static int MODIFIER_Public = 1;
- // public final static int MODIFIER_Protected = 2; // for later
+ // public final static int MODIFIER_Protected = 2; // for later
// public final static int MODIFIER_Package = 3;
// public final static int MODIFIER_Module = 4;
diff --git a/modules/wyil/src/wyil/lang/Constant.java b/modules/wyil/src/wyil/lang/Constant.java
index 674a0be5c6..dec6875c02 100755
--- a/modules/wyil/src/wyil/lang/Constant.java
+++ b/modules/wyil/src/wyil/lang/Constant.java
@@ -51,6 +51,10 @@ public static Decimal V_DECIMAL(BigDecimal value) {
return get(new Decimal(value));
}
+ public static Rational V_RATIONAL(BigRational value) {
+ return get(new Rational(value));
+ }
+
public static Integer V_INTEGER(BigInteger value) {
return get(new Integer(value));
}
@@ -85,10 +89,11 @@ public static Tuple V_TUPLE(Collection values) {
}
public static Lambda V_LAMBDA(NameID name,
- wyil.lang.Type.FunctionOrMethod type) {
- return get(new Lambda(name, type));
+ wyil.lang.Type.FunctionOrMethod type, Constant... arguments) {
+ return get(new Lambda(name, type, arguments));
}
+
public static final class Null extends Constant {
public wyil.lang.Type type() {
return wyil.lang.Type.T_NULL;
@@ -197,7 +202,7 @@ public String toString() {
return r;
}
}
-
+
public static final class Integer extends Constant {
public final BigInteger value;
private Integer(BigInteger value) {
@@ -244,6 +249,9 @@ public Constant.Integer divide(Constant.Integer val) {
public Constant.Integer remainder(Constant.Integer val) {
return Constant.V_INTEGER(value.remainder(val.value));
}
+ public Constant.Integer negate() {
+ return Constant.V_INTEGER(value.negate());
+ }
}
public static final class Decimal extends Constant {
@@ -305,6 +313,70 @@ public Constant.Decimal multiply(Constant.Decimal val) {
public Constant.Decimal divide(Constant.Decimal val) {
return Constant.V_DECIMAL(value.divide(val.value));
}
+
+ public Constant.Decimal negate() {
+ return Constant.V_DECIMAL(value.negate());
+ }
+ }
+
+ public static final class Rational extends Constant {
+ public final BigRational value;
+
+ private Rational(BigRational value) {
+ this.value = value;
+ }
+
+ public wyil.lang.Type type() {
+ return wyil.lang.Type.T_REAL;
+ }
+
+ public int hashCode() {
+ return value.hashCode();
+ }
+
+ public boolean equals(Object o) {
+ if (o instanceof Rational) {
+ Rational i = (Rational) o;
+ return value.equals(i.value);
+ }
+ return false;
+ }
+
+ public int compareTo(Constant v) {
+ if (v instanceof Rational) {
+ Rational i = (Rational) v;
+ return value.compareTo(i.value);
+ } else if (v instanceof Null || v instanceof Bool
+ || v instanceof Byte || v instanceof Integer
+ || v instanceof Decimal) {
+ return 1;
+ }
+ return -1;
+ }
+
+ public String toString() {
+ return value.toString();
+ }
+
+ public Constant.Rational add(Constant.Rational val) {
+ return Constant.V_RATIONAL(value.add(val.value));
+ }
+
+ public Constant.Rational subtract(Constant.Rational val) {
+ return Constant.V_RATIONAL(value.subtract(val.value));
+ }
+
+ public Constant.Rational multiply(Constant.Rational val) {
+ return Constant.V_RATIONAL(value.multiply(val.value));
+ }
+
+ public Constant.Rational divide(Constant.Rational val) {
+ return Constant.V_RATIONAL(value.divide(val.value));
+ }
+
+ public Constant.Rational negate() {
+ return Constant.V_RATIONAL(value.negate());
+ }
}
public static final class List extends Constant {
@@ -346,7 +418,8 @@ public int compareTo(Constant v) {
return 0;
}
} else if (v instanceof Null || v instanceof Bool
- || v instanceof Decimal || v instanceof Byte || v instanceof Integer) {
+ || v instanceof Byte || v instanceof Integer
+ || v instanceof Decimal || v instanceof Rational) {
return 1;
}
return -1;
@@ -413,9 +486,9 @@ public int compareTo(Constant v) {
return 0;
}
} else if (v instanceof Null || v instanceof Bool
- || v instanceof Decimal || v instanceof Byte
- || v instanceof Integer || v instanceof List
- || v instanceof Tuple) {
+ || v instanceof Decimal || v instanceof Rational
+ || v instanceof Byte || v instanceof Integer
+ || v instanceof List || v instanceof Tuple) {
return 1;
}
return -1;
@@ -519,9 +592,10 @@ public int compareTo(Constant v) {
return 0;
}
} else if (v instanceof Null || v instanceof Bool
- || v instanceof Decimal || v instanceof Byte
- || v instanceof Integer || v instanceof Set
- || v instanceof List || v instanceof Tuple) {
+ || v instanceof Decimal || v instanceof Rational
+ || v instanceof Byte || v instanceof Integer
+ || v instanceof Set || v instanceof List
+ || v instanceof Tuple) {
return 1;
}
return -1;
@@ -597,10 +671,10 @@ public int compareTo(Constant v) {
return 0;
}
} else if (v instanceof Null || v instanceof Bool
- || v instanceof Decimal || v instanceof Byte
- || v instanceof Integer || v instanceof Set
- || v instanceof List || v instanceof Tuple
- || v instanceof Record) {
+ || v instanceof Decimal || v instanceof Rational
+ || v instanceof Byte || v instanceof Integer
+ || v instanceof Set || v instanceof List
+ || v instanceof Tuple || v instanceof Record) {
return 1;
}
return -1;
@@ -666,12 +740,23 @@ public String toString() {
public static final class Lambda extends Constant {
public final NameID name;
public final wyil.lang.Type.FunctionOrMethod type;
-
- private Lambda(NameID name, wyil.lang.Type.FunctionOrMethod type) {
+ public final ArrayList arguments;
+
+ private Lambda(NameID name, wyil.lang.Type.FunctionOrMethod type, Constant... arguments) {
this.name = name;
this.type = type;
+ this.arguments = new ArrayList();
+ for(int i=0;i!=arguments.length;++i) {
+ this.arguments.add(arguments[i]);
+ }
}
+ private Lambda(NameID name, wyil.lang.Type.FunctionOrMethod type, Collection arguments) {
+ this.name = name;
+ this.type = type;
+ this.arguments = new ArrayList(arguments);
+ }
+
public wyil.lang.Type.FunctionOrMethod type() {
if (type == null) {
return wyil.lang.Type.Function(wyil.lang.Type.T_ANY,
@@ -682,7 +767,7 @@ public wyil.lang.Type.FunctionOrMethod type() {
}
public int hashCode() {
if(type != null) {
- return type.hashCode() + name.hashCode();
+ return type.hashCode() + name.hashCode() + arguments.hashCode();
} else {
return name.hashCode();
}
@@ -692,7 +777,7 @@ public boolean equals(Object o) {
Lambda i = (Lambda) o;
return name.equals(i.name)
&& (type == i.type || (type != null && type
- .equals(i.type)));
+ .equals(i.type))) && arguments.equals(i.arguments);
}
return false;
}
@@ -705,8 +790,22 @@ public int compareTo(Constant v) {
return 1; // everything is above a type constant
}
}
- public String toString() {
- return "&" + name.toString() + ":" + type.toString();
+ public String toString() {
+ String args = "";
+ boolean firstTime=true;
+ for(Constant arg : arguments) {
+ if(!firstTime) {
+ args += ",";
+ }
+ firstTime=false;
+ if(arg == null) {
+ args += "_";
+ } else {
+ args += arg.toString();
+ }
+
+ }
+ return "&" + name.toString() + "(" + args + "):" + type.toString();
}
}
@@ -752,9 +851,9 @@ public int compareTo(Constant v) {
return 0;
}
} else if (v instanceof Null || v instanceof Bool
- || v instanceof Decimal || v instanceof Byte
- || v instanceof Integer || v instanceof Set
- || v instanceof List) {
+ || v instanceof Decimal || v instanceof Rational
+ || v instanceof Byte || v instanceof Integer
+ || v instanceof Set || v instanceof List) {
return 1;
}
return -1;
diff --git a/modules/wyil/src/wyil/util/Interpreter.java b/modules/wyil/src/wyil/util/Interpreter.java
new file mode 100644
index 0000000000..1518536db2
--- /dev/null
+++ b/modules/wyil/src/wyil/util/Interpreter.java
@@ -0,0 +1,1867 @@
+package wyil.util;
+
+import java.io.IOException;
+import java.io.PrintStream;
+import java.math.BigInteger;
+import java.util.*;
+
+import wyautl.util.BigRational;
+import wybs.lang.Build;
+import wycc.lang.NameID;
+import wycc.util.Pair;
+import wycc.util.ResolveError;
+import wyfs.lang.Path;
+import wyil.lang.*;
+
+/**
+ *
+ * A simple interpreter for WyIL bytecodes. The purpose of this interpreter is
+ * to provide a reference implementation for the semantics of WyIL bytecodes.
+ *
+ *
+ * The interpreter is not intended to be time or space efficient. It also assume
+ * the underlying WyIL bytecodes are well formed and does not attempt to check
+ * them. Thus, malformed bytecodes can reuslt in the interpreter executing in an
+ * unpredictable fashion.
+ *
+ *
+ * @author David J. Pearce
+ *
+ */
+public class Interpreter {
+ /**
+ * The build project provides access to compiled WyIL files.
+ */
+ private final Build.Project project;
+
+ /**
+ * Responsible for expanding types to determine their underlying type and
+ * constraints.
+ */
+ private final TypeExpander expander;
+
+ /**
+ * The debug stream provides an I/O stream through which debug bytecodes can
+ * write their messages.
+ */
+ private final PrintStream debug;
+
+ public Interpreter(Build.Project project, PrintStream debug) {
+ this.project = project;
+ this.debug = debug;
+ this.expander = new TypeExpander(project);
+ }
+
+ /**
+ * Execute a function or method identified by a name and type signature with
+ * the given arguments, producing a return value or null (if none). If the
+ * function or method cannot be found, or the number of arguments is
+ * incorrect then an exception is thrown.
+ *
+ * @param nid
+ * The fully qualified identifier of the function or method
+ * @param sig
+ * The exact type signature identifying the method.
+ * @param args
+ * The supplied arguments
+ * @return
+ */
+ public Constant execute(NameID nid, Type.FunctionOrMethod sig,
+ Constant... args) {
+ // First, find the enclosing WyilFile
+ try {
+ Path.Entry entry = project.get(nid.module(),
+ WyilFile.ContentType);
+ if (entry == null) {
+ throw new IllegalArgumentException("no WyIL file found: "
+ + nid.module());
+ }
+ // Second, find the given function or method
+ WyilFile wyilFile = entry.read();
+ WyilFile.FunctionOrMethod fm = wyilFile.functionOrMethod(
+ nid.name(), sig);
+ if (fm == null) {
+ throw new IllegalArgumentException(
+ "no function or method found: " + nid + ", " + sig);
+ } else if (sig.params().size() != args.length) {
+ throw new IllegalArgumentException(
+ "incorrect number of arguments: " + nid + ", " + sig);
+ }
+ // Third, get and check the function or method body
+ AttributedCodeBlock body = fm.body();
+ if (body == null) {
+ // FIXME: add support for native functions or methods
+ throw new IllegalArgumentException(
+ "no function or method body found: " + nid + ", " + sig);
+ }
+ // Fourth, construct the stack frame for execution
+ ArrayList sig_params = sig.params();
+ Constant[] frame = new Constant[Math.max(sig_params.size(),
+ body.numSlots())];
+ for (int i = 0; i != sig_params.size(); ++i) {
+ frame[i] = args[i];
+ }
+ // Finally, let's do it!
+ return (Constant) executeAllWithin(frame, new Context(null, body));
+ } catch (IOException e) {
+ throw new RuntimeException(e.getMessage(), e);
+ }
+ }
+
+ /**
+ * Execute a given block of bytecodes starting from the beginning
+ *
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecode instructions are executed
+ * @return
+ */
+ private Object executeAllWithin(Constant[] frame, Context context) {
+ AttributedCodeBlock block = context.block;
+ CodeBlock.Index parent = context.pc;
+ CodeBlock.Index pc = parent == null ? new CodeBlock.Index(null, 0)
+ : parent.firstWithin();
+
+ do {
+ Object r = execute(frame, new Context(pc, block));
+ // Now, see whether we are continuing or not
+ if (r instanceof CodeBlock.Index) {
+ pc = (CodeBlock.Index) r;
+ } else {
+ return r;
+ }
+ } while (pc.isWithin(parent) && block.contains(pc));
+ if (!pc.isWithin(parent)) {
+ // non-local exit
+ return pc;
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Execute an Assign bytecode instruction at a given point in the function
+ * or method body
+ *
+ * @param pc
+ * --- The position of the instruction to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Constant[] frame, Context context) {
+ Code bytecode = context.block.get(context.pc);
+ // FIXME: turn this into a switch statement?
+ if (bytecode instanceof Codes.Invariant) {
+ return execute((Codes.Invariant) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.AssertOrAssume) {
+ return execute((Codes.AssertOrAssume) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Assign) {
+ return execute((Codes.Assign) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.BinaryOperator) {
+ return execute((Codes.BinaryOperator) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Const) {
+ return execute((Codes.Const) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Convert) {
+ return execute((Codes.Convert) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Debug) {
+ return execute((Codes.Debug) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Dereference) {
+ return execute((Codes.Dereference) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Fail) {
+ return execute((Codes.Fail) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.FieldLoad) {
+ return execute((Codes.FieldLoad) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.ForAll) {
+ return execute((Codes.ForAll) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Goto) {
+ return execute((Codes.Goto) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.If) {
+ return execute((Codes.If) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.IfIs) {
+ return execute((Codes.IfIs) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.IndexOf) {
+ return execute((Codes.IndexOf) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.IndirectInvoke) {
+ return execute((Codes.IndirectInvoke) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Invert) {
+ return execute((Codes.Invert) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Invoke) {
+ return execute((Codes.Invoke) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Label) {
+ // essentially do nout
+ return context.pc.next();
+ } else if (bytecode instanceof Codes.Lambda) {
+ return execute((Codes.Lambda) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.LengthOf) {
+ return execute((Codes.LengthOf) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.ListOperator) {
+ return execute((Codes.ListOperator) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Loop) {
+ return execute((Codes.Loop) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Move) {
+ return execute((Codes.Move) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.NewList) {
+ return execute((Codes.NewList) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.NewMap) {
+ return execute((Codes.NewMap) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.NewObject) {
+ return execute((Codes.NewObject) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.NewRecord) {
+ return execute((Codes.NewRecord) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.NewSet) {
+ return execute((Codes.NewSet) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.NewTuple) {
+ return execute((Codes.NewTuple) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Nop) {
+ return execute((Codes.Nop) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Quantify) {
+ return execute((Codes.Quantify) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Return) {
+ return execute((Codes.Return) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.SetOperator) {
+ return execute((Codes.SetOperator) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.SubList) {
+ return execute((Codes.SubList) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Switch) {
+ return execute((Codes.Switch) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.TupleLoad) {
+ return execute((Codes.TupleLoad) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.UnaryOperator) {
+ return execute((Codes.UnaryOperator) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Update) {
+ return execute((Codes.Update) bytecode, frame, context);
+ } else if (bytecode instanceof Codes.Void) {
+ return execute((Codes.Void) bytecode, frame, context);
+ } else {
+ throw new IllegalArgumentException("Unknown bytecode encountered: "
+ + bytecode);
+ }
+ }
+
+ /**
+ * Execute an assert or assume bytecode.
+ *
+ * @param pc
+ * --- The position of the instruction to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.AssertOrAssume bytecode, Constant[] frame,
+ Context context) {
+ //
+ Object r = executeAllWithin(frame, context);
+ //
+ if (r == null) {
+ // Body of assert fell through to next
+ return context.pc.next();
+ } else {
+ return r;
+ }
+ }
+
+ /**
+ * Execute an Assign bytecode instruction at a given point in the function
+ * or method body
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.Assign bytecode, Constant[] frame,
+ Context context) {
+ frame[bytecode.target()] = frame[bytecode.operand(0)];
+ return context.pc.next();
+ }
+
+ /**
+ * Execute a binary operator instruction at a given point in the function or
+ * method body. This will check operands match their expected types.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.BinaryOperator bytecode, Constant[] frame,
+ Context context) {
+ Constant op1 = frame[bytecode.operand(0)];
+ Constant op2 = frame[bytecode.operand(1)];
+
+ // Compute result
+ Constant result;
+ if (op1 instanceof Constant.Integer) {
+ checkType(op2, context, Constant.Integer.class);
+ result = execute(bytecode.kind, (Constant.Integer) op1,
+ (Constant.Integer) op2, context);
+ } else if (op1 instanceof Constant.Rational) {
+ checkType(op2, context, Constant.Rational.class);
+ result = execute(bytecode.kind, (Constant.Rational) op1,
+ (Constant.Rational) op2, context);
+ } else if (op1 instanceof Constant.Byte) {
+ checkType(op2, context, Constant.Byte.class, Constant.Integer.class);
+ result = execute(bytecode.kind, (Constant.Byte) op1, op2, context);
+ } else {
+ return deadCode(context); // dead because of above checks
+ }
+
+ // Write result to target
+ frame[bytecode.target()] = result;
+ return context.pc.next();
+ }
+
+ /**
+ * Execute an integer binary operator
+ *
+ * @param kind
+ * --- operator kind
+ * @param i1
+ * --- left operand
+ * @param i2
+ * --- right operand
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant execute(Codes.BinaryOperatorKind kind,
+ Constant.Integer i1, Constant.Integer i2, Context context) {
+ switch (kind) {
+ case ADD:
+ return i1.add(i2);
+ case SUB:
+ return i1.subtract(i2);
+ case MUL:
+ return i1.multiply(i2);
+ case DIV:
+ return i1.divide(i2);
+ case REM:
+ return i1.remainder(i2);
+ case RANGE:
+ ArrayList values = new ArrayList();
+ int start = i1.value.intValue();
+ int end = i2.value.intValue();
+ for (int i = start; i < end; ++i) {
+ values.add(Constant.V_INTEGER(BigInteger.valueOf(i)));
+ }
+ return Constant.V_LIST(values);
+ }
+ deadCode(context);
+ return null;
+ }
+
+ /**
+ * Execute a rational binary operator
+ *
+ * @param kind
+ * --- operator kind
+ * @param i1
+ * --- left operand
+ * @param i2
+ * --- right operand
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant execute(Codes.BinaryOperatorKind kind,
+ Constant.Rational r1, Constant.Rational r2, Context context) {
+ switch (kind) {
+ case ADD:
+ return r1.add(r2);
+ case SUB:
+ return r1.subtract(r2);
+ case MUL:
+ return r1.multiply(r2);
+ case DIV:
+ return r1.divide(r2);
+ }
+ deadCode(context);
+ return null;
+ }
+
+ /**
+ * Execute an bitwise binary operator
+ *
+ * @param kind
+ * --- operator kind
+ * @param i1
+ * --- left operand
+ * @param i2
+ * --- right operand
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant execute(Codes.BinaryOperatorKind kind, Constant.Byte i1,
+ Constant i2, Context context) {
+ int result;
+ switch (kind) {
+ case BITWISEAND:
+ checkType(i2, context, Constant.Byte.class);
+ result = i1.value & ((Constant.Byte) i2).value;
+ break;
+ case BITWISEOR:
+ checkType(i2, context, Constant.Byte.class);
+ result = i1.value | ((Constant.Byte) i2).value;
+ break;
+ case BITWISEXOR:
+ checkType(i2, context, Constant.Byte.class);
+ result = i1.value ^ ((Constant.Byte) i2).value;
+ break;
+ case LEFTSHIFT:
+ checkType(i2, context, Constant.Integer.class);
+ result = i1.value << ((Constant.Integer) i2).value.intValue();
+ break;
+ case RIGHTSHIFT:
+ checkType(i2, context, Constant.Integer.class);
+ result = i1.value >> ((Constant.Integer) i2).value.intValue();
+ break;
+ default:
+ deadCode(context);
+ return null;
+ }
+ return Constant.V_BYTE((byte) result);
+ }
+
+ /**
+ * Execute a Const bytecode instruction at a given point in the function or
+ * method body
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.Const bytecode, Constant[] frame,
+ Context context) {
+ Constant c = cleanse(bytecode.constant, context);
+ frame[bytecode.target()] = c;
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.Convert bytecode, Constant[] frame,
+ Context context) {
+ try {
+ Constant operand = frame[bytecode.operand(0)];
+ Type target = expander.getUnderlyingType(bytecode.result);
+ frame[bytecode.target()] = convert(operand, target, context);
+ return context.pc.next();
+ } catch (IOException e) {
+ return error(e.getMessage(), context);
+ } catch (ResolveError e) {
+ return error(e.getMessage(), context);
+ }
+ }
+
+ /**
+ * Convert a given value of one into a value of a different type. For
+ * example, converting a int value into a real value.
+ *
+ * @param from
+ * @param value
+ * @param to
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant convert(Constant value, Type to, Context context) {
+ Type type = value.type();
+ if (Type.isSubtype(to, type)) {
+ // In this case, we don't need to do anything because the value is
+ // already of the correct type.
+ return value;
+ } else if (to instanceof Type.Real) {
+ return convert(value, (Type.Real) to, context);
+ } else if (to instanceof Type.Record) {
+ return convert(value, (Type.Record) to, context);
+ } else if (to instanceof Type.List) {
+ return convert(value, (Type.List) to, context);
+ } else if (to instanceof Type.Set) {
+ return convert(value, (Type.Set) to, context);
+ } else if (to instanceof Type.Map) {
+ return convert(value, (Type.Map) to, context);
+ } else if (to instanceof Type.Tuple) {
+ return convert(value, (Type.Tuple) to, context);
+ } else if (to instanceof Type.Union) {
+ return convert(value, (Type.Union) to, context);
+ } else if (to instanceof Type.FunctionOrMethod) {
+ return convert(value, (Type.FunctionOrMethod) to, context);
+ }
+ deadCode(context);
+ return null;
+ }
+
+ /**
+ * Convert a value into an real type. The value must be of integer type for
+ * this to make sense.
+ *
+ * @param value
+ * @param to
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant convert(Constant value, Type.Real to, Context context) {
+ checkType(value, context, Constant.Integer.class);
+ // int -> real
+ Constant.Integer iv = (Constant.Integer) value;
+ return Constant.V_RATIONAL(new BigRational(iv.value));
+ }
+
+ /**
+ * Convert a value into a record type. The value must be of record type for
+ * this to make sense and must either have the same fields or, in the case
+ * of an open record, have a superset of fields.
+ *
+ * @param value
+ * @param to
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant convert(Constant value, Type.Record to, Context context) {
+ checkType(value, context, Constant.Record.class);
+ Constant.Record rv = (Constant.Record) value;
+ HashSet rv_fields = new HashSet(rv.values.keySet());
+ // Check fields in value are subset of those in target type
+ if (!rv_fields.containsAll(to.keys())) {
+ error("cannot convert between records with differing fields",
+ context);
+ return null; // deadcode
+ } else {
+ HashMap nValues = new HashMap();
+ for (String field : to.keys()) {
+ Constant nValue = convert(rv.values.get(field),
+ to.field(field), context);
+ nValues.put(field, nValue);
+ }
+ return Constant.V_RECORD(nValues);
+ }
+ }
+
+ /**
+ * Convert a value into a list type. The value must be of list type for this
+ * to make sense.
+ *
+ * @param value
+ * @param to
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant convert(Constant value, Type.List to, Context context) {
+ checkType(value, context, Constant.List.class);
+ Constant.List lv = (Constant.List) value;
+ ArrayList values = new ArrayList(lv.values);
+ for (int i = 0; i != values.size(); ++i) {
+ values.set(i, convert(values.get(i), to.element(), context));
+ }
+ return Constant.V_LIST(values);
+ }
+
+ /**
+ * Convert a value into a set type. The value must be of set type for this
+ * to make sense.
+ *
+ * @param value
+ * @param to
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant convert(Constant value, Type.Set to, Context context) {
+ checkType(value, context, Constant.Set.class, Constant.List.class);
+ Collection lv_values;
+ if (value instanceof Constant.Set) {
+ Constant.Set lv = (Constant.Set) value;
+ lv_values = lv.values;
+ } else {
+ Constant.List lv = (Constant.List) value;
+ lv_values = lv.values;
+ }
+ ArrayList values = new ArrayList(lv_values);
+ for (int i = 0; i != values.size(); ++i) {
+ values.set(i, convert(values.get(i), to.element(), context));
+ }
+ return Constant.V_SET(values);
+ }
+
+ /**
+ * Convert a value into a map type. The value must be of map type for this
+ * to make sense.
+ *
+ * @param value
+ * @param to
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant convert(Constant value, Type.Map to, Context context) {
+ checkType(value, context, Constant.Map.class, Constant.List.class);
+ HashMap nValues = new HashMap();
+ if (value instanceof Constant.Map) {
+ Constant.Map lv = (Constant.Map) value;
+ HashMap lv_values = lv.values;
+ for (Map.Entry e : lv_values.entrySet()) {
+ Constant key = convert(e.getKey(), to.key(), context);
+ Constant val = convert(e.getValue(), to.value(), context);
+ nValues.put(key, val);
+ }
+ } else {
+ Constant.List lv = (Constant.List) value;
+ ArrayList lv_values = lv.values;
+ for (int i = 0; i != lv_values.size(); ++i) {
+ Constant key = Constant.V_INTEGER(BigInteger.valueOf(i));
+ Constant val = convert(lv_values.get(i), to.value(), context);
+ nValues.put(key, val);
+ }
+ }
+ return Constant.V_MAP(nValues);
+ }
+
+ /**
+ * Convert a value into a tuple type. The value must be of tuple type for
+ * this to make sense.
+ *
+ * @param value
+ * @param to
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant convert(Constant value, Type.Tuple to, Context context) {
+ checkType(value, context, Constant.Tuple.class);
+ Constant.Tuple lv = (Constant.Tuple) value;
+ List to_elements = to.elements();
+ ArrayList lv_values = lv.values;
+ // Check we have matching fields
+ if (lv_values.size() != to_elements.size()) {
+ error("cannot convert between tuples with differing sizes", context);
+ return null; // deadcode
+ } else {
+ ArrayList nValues = new ArrayList();
+ for (int i = 0; i != lv_values.size(); ++i) {
+ Constant nValue = convert(lv_values.get(i), to_elements.get(i),
+ context);
+ nValues.add(nValue);
+ }
+ return Constant.V_TUPLE(nValues);
+ }
+ }
+
+ /**
+ * Convert a value into a union type. In this case, we must find an
+ * appropriate bound for the type in question. If no such type can be found,
+ * then this is ambiguous or otherwise invalid.
+ *
+ * @param value
+ * @param to
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant convert(Constant value, Type.Union to, Context context) {
+ Type type = value.type();
+ for (Type bound : to.bounds()) {
+ if (Type.isExplicitCoerciveSubtype(bound, type)) {
+ return convert(value, bound, context);
+ }
+ }
+ deadCode(context);
+ return null;
+ }
+
+ /**
+ * Convert a value into a function type. In this case, we actually do
+ * nothing for now.
+ *
+ * @param value
+ * @param to
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Constant convert(Constant value, Type.FunctionOrMethod to, Context context) {
+ return value;
+ }
+
+ /**
+ * Execute a Debug bytecode instruction at a given point in the function or
+ * method body. This will write the provided string out to the debug stream.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.Debug bytecode, Constant[] frame,
+ Context context) {
+ //
+ Constant.List list = (Constant.List) frame[bytecode.operand];
+ for (Constant item : list.values) {
+ BigInteger b = ((Constant.Integer) item).value;
+ char c = (char) b.intValue();
+ debug.print(c);
+ }
+ //
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.Dereference bytecode, Constant[] frame,
+ Context context) {
+ Constant operand = frame[bytecode.operand(0)];
+ checkType(operand, context, ConstantObject.class);
+ ConstantObject ref = (ConstantObject) operand;
+ frame[bytecode.target()] = ref.read();
+ return context.pc.next();
+ }
+
+ /**
+ * Execute a fail bytecode instruction at a given point in the function or
+ * method body. This will generate a runtime fault.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.Fail bytecode, Constant[] frame,
+ Context context) {
+ throw new Error("Runtime fault occurred");
+ }
+
+ private Object execute(Codes.FieldLoad bytecode, Constant[] frame,
+ Context context) {
+ Constant.Record rec = (Constant.Record) frame[bytecode.operand(0)];
+ frame[bytecode.target()] = rec.values.get(bytecode.field);
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.ForAll bytecode, Constant[] frame,
+ Context context) {
+ Constant operand = frame[bytecode.sourceOperand];
+ checkType(operand, context, Constant.Set.class, Constant.Map.class,
+ Constant.List.class);
+ Collection values;
+ if (operand instanceof Constant.Set) {
+ Constant.Set set = (Constant.Set) operand;
+ values = set.values;
+ } else if (operand instanceof Constant.Map) {
+ Constant.Map map = (Constant.Map) operand;
+ values = map.values.values();
+ } else {
+ Constant.List list = (Constant.List) operand;
+ values = list.values;
+ }
+ for (Constant value : values) {
+ // Assign the index variable
+ frame[bytecode.indexOperand] = value;
+ // Execute loop body for one iteration
+ Object r = executeAllWithin(frame, context);
+ // Now, check whether we fell through to the end or not. If not,
+ // then we must have exited somehow so return to signal that.
+ if (r != null) {
+ return r;
+ }
+ }
+
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.Goto bytecode, Constant[] frame,
+ Context context) {
+ return context.getLabel(bytecode.target);
+ }
+
+ private Object execute(Codes.If bytecode, Constant[] frame, Context context) {
+ Constant op1 = frame[bytecode.leftOperand];
+ Constant op2 = frame[bytecode.rightOperand];
+ boolean result;
+ switch (bytecode.op) {
+ // Handle cases which apply to all values
+ case EQ:
+ result = op1.equals(op2);
+ break;
+ case NEQ:
+ result = !op1.equals(op2);
+ break;
+ // Handle arithmetic cases
+ case LT:
+ result = lessThan(op1, op2, true, context);
+ break;
+ case LTEQ:
+ result = lessThan(op1, op2, false, context);
+ break;
+ case GT:
+ result = lessThan(op2, op1, true, context);
+ break;
+ case GTEQ:
+ result = lessThan(op2, op1, false, context);
+ break;
+ case IN:
+ result = elementOf(op1, op2, context);
+ break;
+ case SUBSET:
+ result = subset(op1, op2, true, context);
+ break;
+ case SUBSETEQ:
+ result = subset(op1, op2, false, context);
+ break;
+ default:
+ return deadCode(context);
+ }
+
+ if (result) {
+ // branch taken, so jump to destination label
+ return context.getLabel(bytecode.target);
+ } else {
+ // branch not taken, so fall through to next bytecode.
+ return context.pc.next();
+ }
+ }
+
+ private boolean subset(Constant op1, Constant op2, boolean isStrict,
+ Context context) {
+ checkType(op1, context, Constant.Set.class);
+ checkType(op2, context, Constant.Set.class);
+ Constant.Set lhs = (Constant.Set) op1;
+ Constant.Set rhs = (Constant.Set) op2;
+ if (rhs.values.containsAll(lhs.values)) {
+ return !isStrict || !lhs.equals(rhs);
+ } else {
+ return false;
+ }
+ }
+
+ private boolean elementOf(Constant lhs, Constant rhs, Context context) {
+ checkType(rhs, context, Constant.Set.class, Constant.Map.class,
+ Constant.List.class);
+ Collection values;
+ if (rhs instanceof Constant.Set) {
+ Constant.Set set = (Constant.Set) rhs;
+ values = set.values;
+ } else if (rhs instanceof Constant.Map) {
+ Constant.Map map = (Constant.Map) rhs;
+ values = map.values.values();
+ } else {
+ Constant.List list = (Constant.List) rhs;
+ values = list.values;
+ }
+ return values.contains(lhs);
+ }
+
+ private boolean lessThan(Constant lhs, Constant rhs, boolean isStrict,
+ Context context) {
+ checkType(lhs, context, Constant.Integer.class, Constant.Rational.class);
+ checkType(rhs, context, lhs.getClass());
+ int result;
+ if (lhs instanceof Constant.Integer) {
+ Constant.Integer lhs_i = (Constant.Integer) lhs;
+ Constant.Integer rhs_i = (Constant.Integer) rhs;
+ result = lhs_i.compareTo(rhs_i);
+ } else {
+ Constant.Rational lhs_i = (Constant.Rational) lhs;
+ Constant.Rational rhs_i = (Constant.Rational) rhs;
+ result = lhs_i.compareTo(rhs_i);
+ }
+ // In the strict case, the lhs must be strictly below the rhs. In the
+ // non-strict case, they can be equal.
+ if (isStrict) {
+ return result < 0;
+ } else {
+ return result <= 0;
+ }
+ }
+
+ private Object execute(Codes.IfIs bytecode, Constant[] frame,
+ Context context) {
+ Type typeOperand = bytecode.rightOperand;
+ Constant op = frame[bytecode.operand];
+ if (isMemberOfType(op, typeOperand, context)) {
+ return context.getLabel(bytecode.target);
+ }
+ // No, it doesn't so fall through to next instruction
+ return context.pc.next();
+
+ }
+
+ /**
+ * Determine whether a given value is a member of a given type. In the case
+ * of a nominal type, then we must also check that any invariant(s) for that
+ * type hold true as well.
+ *
+ * @param value
+ * @param type
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ public boolean isMemberOfType(Constant value, Type type, Context context) {
+ if (type instanceof Type.Any) {
+ return true;
+ } else if (type instanceof Type.Void) {
+ return false;
+ } else if (type instanceof Type.Null) {
+ return value instanceof Constant.Null;
+ } else if (type instanceof Type.Bool) {
+ return value instanceof Constant.Bool;
+ } else if (type instanceof Type.Byte) {
+ return value instanceof Constant.Byte;
+ } else if (type instanceof Type.Int) {
+ return value instanceof Constant.Integer;
+ } else if (type instanceof Type.Real) {
+ return value instanceof Constant.Rational;
+ } else if (type instanceof Type.Reference) {
+ if (value instanceof ConstantObject) {
+ ConstantObject obj = (ConstantObject) value;
+ Type.Reference rt = (Type.Reference) type;
+ return isMemberOfType(obj.value, rt.element(), context);
+ }
+ return false;
+ } else if (type instanceof Type.Set) {
+ if (value instanceof Constant.Set) {
+ Constant.Set t = (Constant.Set) value;
+ Type element = ((Type.Set) type).element();
+ boolean r = true;
+ for (Constant val : t.values) {
+ r &= isMemberOfType(val, element, context);
+ }
+ return r;
+ }
+ return false;
+ } else if (type instanceof Type.List) {
+ if (value instanceof Constant.List) {
+ Constant.List t = (Constant.List) value;
+ Type element = ((Type.List) type).element();
+ boolean r = true;
+ for (Constant val : t.values) {
+ r &= isMemberOfType(val, element, context);
+ }
+ return r;
+ }
+ return false;
+ } else if (type instanceof Type.Map) {
+ if (value instanceof Constant.Map) {
+ Constant.Map t = (Constant.Map) value;
+ Type key = ((Type.Map) type).key();
+ Type val = ((Type.Map) type).value();
+ boolean r = true;
+ for (Map.Entry e : t.values.entrySet()) {
+ r &= isMemberOfType(e.getKey(), key, context);
+ r &= isMemberOfType(e.getValue(), val, context);
+ }
+ return r;
+ }
+ return false;
+ } else if (type instanceof Type.Tuple) {
+ if (value instanceof Constant.Tuple) {
+ Constant.Tuple t = (Constant.Tuple) value;
+ Type.Tuple tt = (Type.Tuple) type;
+ List t_values = t.values;
+ List tt_elements = tt.elements();
+ if (t_values.size() != tt_elements.size()) {
+ return false;
+ } else {
+ boolean r = true;
+ for (int i = 0; i != t_values.size(); ++i) {
+ r &= isMemberOfType(t_values.get(i),
+ tt_elements.get(i), context);
+ }
+ return r;
+ }
+ }
+ return false;
+ } else if (type instanceof Type.Record) {
+ if (value instanceof Constant.Record) {
+ Type.Record rt = (Type.Record) type;
+ Constant.Record t = (Constant.Record) value;
+ Set fields = t.values.keySet();
+ if (!fields.containsAll(rt.keys())
+ || (!rt.keys().containsAll(fields) && !rt.isOpen())) {
+ // In this case, the set of fields does not match properly
+ return false;
+ }
+ boolean r = true;
+ for (String field : fields) {
+ r &= isMemberOfType(t.values.get(field), rt.field(field),
+ context);
+ }
+ return r;
+ }
+ return false;
+ } else if (type instanceof Type.Union) {
+ Type.Union t = (Type.Union) type;
+ for (Type element : t.bounds()) {
+ if (isMemberOfType(value, element, context)) {
+ return true;
+ }
+ }
+ return false;
+ } else if (type instanceof Type.Negation) {
+ Type.Negation t = (Type.Negation) type;
+ return !isMemberOfType(value, t.element(), context);
+ } else if (type instanceof Type.Nominal) {
+ Type.Nominal nt = (Type.Nominal) type;
+ NameID nid = nt.name();
+ try {
+ Path.Entry entry = project.get(nid.module(),
+ WyilFile.ContentType);
+ if (entry == null) {
+ throw new IllegalArgumentException("no WyIL file found: "
+ + nid.module());
+ }
+ // Second, find the given function or method
+ WyilFile wyilFile = entry.read();
+ WyilFile.Type td = wyilFile.type(nid.name());
+ if (td == null) {
+ error("undefined nominal type encountered: " + nid, context);
+ } else if (!isMemberOfType(value, td.type(), context)) {
+ return false;
+ }
+ // Check any invariant associated with this type
+ AttributedCodeBlock invariant = td.invariant();
+ if (invariant != null) {
+ Constant[] frame = new Constant[invariant.numSlots()];
+ frame[0] = value;
+ executeAllWithin(frame, new Context(null, invariant));
+ }
+ // Done
+ return true;
+ } catch (IOException e) {
+ error(e.getMessage(), context);
+ } catch (Error e) {
+ // This signals that a runtime fault occurred in the body of the
+ // type invariant.
+ return false;
+ }
+ }
+
+ deadCode(context);
+ return false; // deadcode
+ }
+
+ /**
+ * Execute an IndexOf bytecode instruction at a given point in the function
+ * or method body. This checks the first operand is a list value, and the
+ * second operand is an integer value. It also checks that the integer index
+ * is within bounds and, if not, raises a runtime fault.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.IndexOf bytecode, Constant[] frame,
+ Context context) {
+ Constant operand_0 = frame[bytecode.operand(0)];
+ Constant operand_1 = frame[bytecode.operand(1)];
+ // Check we have a list and an integer index
+ checkType(operand_0, context, Constant.List.class, Constant.Map.class);
+ // Yes, now check that this is in bounds
+ if (operand_0 instanceof Constant.List) {
+ checkType(operand_1, context, Constant.Integer.class);
+ Constant.List list = (Constant.List) operand_0;
+ Constant.Integer index = (Constant.Integer) operand_1;
+ int i = index.value.intValue();
+ if (i < 0 || i >= list.values.size()) {
+ error("index-out-of-bounds", context);
+ }
+ // Ok, get the element at that index
+ frame[bytecode.target()] = list.values.get(index.value.intValue());
+ // Done
+ } else {
+ Constant.Map map = (Constant.Map) operand_0;
+ // Ok, get the element at that index
+ frame[bytecode.target()] = map.values.get(operand_1);
+ // Done
+ }
+ return context.pc.next();
+ }
+
+ /**
+ * Execute an IndirectInvoke bytecode instruction at a given point in the
+ * function or method body. This first checks the operand is a function
+ * reference, and then generates a recursive call to execute the given
+ * function. If the function does not exist, or is provided with the wrong
+ * number of arguments, then a runtime fault will occur.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.IndirectInvoke bytecode, Constant[] frame,
+ Context context) {
+ Constant operand = frame[bytecode.operand(0)];
+ // Check that we have a function reference
+ checkType(operand, context, Constant.Lambda.class);
+ // Yes we do; now construct the arguments. This requires merging the
+ // constant arguments provided in the lambda itself along with those
+ // operands provided for the "holes".
+ Constant.Lambda func = (Constant.Lambda) operand;
+ int[] operands = bytecode.operands();
+ Constant[] arguments = new Constant[Math.max(func.arguments.size(),
+ operands.length - 1)];
+ int operandIndex = 1;
+ for (int i = 0; i != arguments.length; ++i) {
+ if (i >= func.arguments.size() || func.arguments.get(i) == null) {
+ arguments[i] = frame[operands[operandIndex]];
+ operandIndex = operandIndex + 1;
+ } else {
+ arguments[i] = func.arguments.get(i);
+ }
+ }
+ // Make the actual call
+ Constant result = execute(func.name, func.type(), arguments);
+ // Coerce the result (may not be actually necessary)
+ result = convert(result,bytecode.type().ret(),context);
+ // Check whether a return value was expected or not
+ if (bytecode.target() != Codes.NULL_REG) {
+ frame[bytecode.target()] = result;
+ }
+ // Done
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.Invariant bytecode, Constant[] frame,
+ Context context) {
+ // FIXME: currently implemented as a NOP because of #480
+ return context.pc.next();
+ }
+
+ /**
+ * Execute an Invert bytecode instruction at a given point in the function
+ * or method body. This checks the operand is a byte value.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.Invert bytecode, Constant[] frame,
+ Context context) {
+ Constant operand = frame[bytecode.operand(0)];
+ // Check that we have a byte operand
+ checkType(operand, context, Constant.Byte.class);
+ // Write back the inverted value
+ Constant.Byte b = (Constant.Byte) operand;
+ frame[bytecode.target()] = Constant.V_BYTE((byte) ~b.value);
+ // Done
+ return context.pc.next();
+ }
+
+ /**
+ * Execute an Invoke bytecode instruction at a given point in the function
+ * or method body. This generates a recursive call to execute the given
+ * function. If the function does not exist, or is provided with the wrong
+ * number of arguments, then a runtime fault will occur.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.Invoke bytecode, Constant[] frame,
+ Context context) {
+ int[] operands = bytecode.operands();
+ Constant[] arguments = new Constant[operands.length];
+ for (int i = 0; i != arguments.length; ++i) {
+ arguments[i] = frame[operands[i]];
+ }
+ Constant result = execute(bytecode.name, bytecode.type(), arguments);
+ if (bytecode.target() != Codes.NULL_REG) {
+ frame[bytecode.target()] = result;
+ }
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.Lambda bytecode, Constant[] frame,
+ Context context) {
+
+ int[] operands = bytecode.operands();
+ Constant[] arguments = new Constant[operands.length];
+ for (int i = 0; i != arguments.length; ++i) {
+ int reg = operands[i];
+ if (reg != Codes.NULL_REG) {
+ arguments[i] = frame[reg];
+ }
+ }
+ // FIXME: need to do something with the operands here.
+ frame[bytecode.target()] = Constant.V_LAMBDA(bytecode.name,
+ bytecode.type(), arguments);
+ //
+ return context.pc.next();
+ }
+
+ /**
+ * Execute a LengthOf bytecode instruction at a given point in the function
+ * or method body. This simply returns the length of the list at the given
+ * position.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.LengthOf bytecode, Constant[] frame,
+ Context context) {
+ Constant _source = frame[bytecode.operand(0)];
+ checkType(_source, context, Constant.List.class, Constant.Map.class,
+ Constant.Set.class);
+ BigInteger length;
+ if (_source instanceof Constant.List) {
+ Constant.List list = (Constant.List) _source;
+ length = BigInteger.valueOf(list.values.size());
+ } else if (_source instanceof Constant.Map) {
+ Constant.Map list = (Constant.Map) _source;
+ length = BigInteger.valueOf(list.values.size());
+ } else {
+ Constant.Set list = (Constant.Set) _source;
+ length = BigInteger.valueOf(list.values.size());
+ }
+ frame[bytecode.target()] = Constant.V_INTEGER(length);
+ return context.pc.next();
+ }
+
+ /**
+ * Execute the list append bytecode instruction at a given point in the
+ * function or method body. This simply assigns the appended list to the
+ * target register.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.ListOperator bytecode, Constant[] frame,
+ Context context) {
+ Constant lhs = frame[bytecode.operand(0)];
+ Constant rhs = frame[bytecode.operand(1)];
+ // Check that we have a function reference
+ checkType(lhs, context, Constant.List.class);
+ checkType(rhs, context, Constant.List.class);
+ // Now, perform the append
+ Constant.List l1 = (Constant.List) lhs;
+ Constant.List l2 = (Constant.List) rhs;
+ ArrayList values = new ArrayList();
+ values.addAll(l1.values);
+ values.addAll(l2.values);
+ frame[bytecode.target()] = Constant.V_LIST(values);
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.Loop bytecode, Constant[] frame,
+ Context context) {
+ Object r;
+ do {
+ // Keep executing the loop body until we exit it somehow.
+ r = executeAllWithin(frame, context);
+ } while (r == null);
+
+ // If we get here, then we have exited the loop body without falling
+ // through to the next bytecode.
+ return r;
+ }
+
+ /**
+ * Execute a move bytecode instruction at a given point in the function or
+ * method body. This moves the operand value into the target register, and
+ * voids the operand.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.Move bytecode, Constant[] frame,
+ Context context) {
+ frame[bytecode.target()] = frame[bytecode.operand(0)];
+ frame[bytecode.operand(0)] = null;
+ return context.pc.next();
+ }
+
+ /**
+ * Execute a Record bytecode instruction at a given point in the function or
+ * method body. This constructs a new list.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.NewList bytecode, Constant[] frame,
+ Context context) {
+ ArrayList values = new ArrayList();
+ for (int operand : bytecode.operands()) {
+ values.add((Constant) frame[operand]);
+ }
+ frame[bytecode.target()] = Constant.V_LIST(values);
+ return context.pc.next();
+ }
+
+ /**
+ * Execute a Map constructor bytecode instruction at a given point in the
+ * function or method body. This constructs a new map.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.NewMap bytecode, Constant[] frame,
+ Context context) {
+ HashSet> values = new HashSet>();
+ int[] operands = bytecode.operands();
+ for (int i = 0; i != operands.length; i = i + 2) {
+ Constant key = frame[operands[i]];
+ Constant value = frame[operands[i + 1]];
+ values.add(new Pair(key, value));
+ }
+ frame[bytecode.target()] = Constant.V_MAP(values);
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.NewObject bytecode, Constant[] frame,
+ Context context) {
+ Constant operand = frame[bytecode.operand(0)];
+ ConstantObject o = new ConstantObject(operand);
+ frame[bytecode.target()] = o;
+ return context.pc.next();
+ }
+
+ /**
+ * Execute a Record bytecode instruction at a given point in the function or
+ * method body. This constructs a new record.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.NewRecord bytecode, Constant[] frame,
+ Context context) {
+ HashMap values = new HashMap();
+ ArrayList fields = new ArrayList(bytecode.type()
+ .fields().keySet());
+ Collections.sort(fields);
+ int[] operands = bytecode.operands();
+ for (int i = 0; i != operands.length; ++i) {
+ values.put(fields.get(i), (Constant) frame[operands[i]]);
+ }
+ frame[bytecode.target()] = Constant.V_RECORD(values);
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.NewSet bytecode, Constant[] frame,
+ Context context) {
+ HashSet values = new HashSet();
+ int[] operands = bytecode.operands();
+ for (int i = 0; i != operands.length; i = i + 1) {
+ values.add(frame[operands[i]]);
+ }
+ frame[bytecode.target()] = Constant.V_SET(values);
+ return context.pc.next();
+ }
+
+ /**
+ * Execute a Tuple bytecode instruction at a given point in the function or
+ * method body. This constructs a new tuple.
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.NewTuple bytecode, Constant[] frame,
+ Context context) {
+ ArrayList values = new ArrayList();
+ for (int operand : bytecode.operands()) {
+ values.add((Constant) frame[operand]);
+ }
+ frame[bytecode.target()] = Constant.V_TUPLE(values);
+ return context.pc.next();
+ }
+
+ /**
+ * Execute a Nop bytecode instruction at a given point in the function or
+ * method body. This basically doesn't do anything!
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.Nop bytecode, Constant[] frame, Context context) {
+ return context.pc.next();
+ }
+
+ /**
+ * Execute a Return bytecode instruction at a given point in the function or
+ * method body
+ *
+ * @param bytecode
+ * --- The bytecode to execute
+ * @param frame
+ * --- The current stack frame
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @return
+ */
+ private Object execute(Codes.Return bytecode, Constant[] frame,
+ Context context) {
+ if (bytecode.operand == Codes.NULL_REG) {
+ // This is a void return
+ return null;
+ } else {
+ return frame[bytecode.operand];
+ }
+ }
+
+ private Object execute(Codes.SetOperator bytecode, Constant[] frame,
+ Context context) {
+ Constant operand_0 = frame[bytecode.operand(0)];
+ Constant operand_1 = frame[bytecode.operand(1)];
+ checkType(operand_0, context, Constant.Set.class);
+ checkType(operand_1, context, Constant.Set.class);
+ Constant.Set lhs = (Constant.Set) operand_0;
+ Constant.Set rhs = (Constant.Set) operand_1;
+ Constant result;
+ switch (bytecode.kind) {
+ case UNION:
+ result = lhs.union(rhs);
+ break;
+ case INTERSECTION:
+ result = lhs.intersect(rhs);
+ break;
+ case DIFFERENCE:
+ result = lhs.difference(rhs);
+ break;
+ default:
+ return deadCode(context);
+ }
+ frame[bytecode.target()] = result;
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.SubList bytecode, Constant[] frame,
+ Context context) {
+ Constant _source = frame[bytecode.operand(0)];
+ Constant _fromIndex = frame[bytecode.operand(1)];
+ Constant _toIndex = frame[bytecode.operand(2)];
+ // Check that we have a function reference
+ checkType(_source, context, Constant.List.class);
+ checkType(_fromIndex, context, Constant.Integer.class);
+ checkType(_toIndex, context, Constant.Integer.class);
+ // Now, perform the append
+ Constant.List source = (Constant.List) _source;
+ Constant.Integer fromIndex = (Constant.Integer) _fromIndex;
+ Constant.Integer toIndex = (Constant.Integer) _toIndex;
+
+ frame[bytecode.target()] = Constant.V_LIST(source.values.subList(
+ fromIndex.value.intValue(), toIndex.value.intValue()));
+
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.Switch bytecode, Constant[] frame,
+ Context context) {
+ //
+ Constant operand = frame[bytecode.operand];
+ for (Pair branch : bytecode.branches) {
+ Constant caseOperand = cleanse(branch.first(), context);
+ if (caseOperand.equals(operand)) {
+ return context.getLabel(branch.second());
+ }
+ }
+ return context.getLabel(bytecode.defaultTarget);
+ }
+
+ private Object execute(Codes.TupleLoad bytecode, Constant[] frame,
+ Context context) {
+ //
+ Constant _source = frame[bytecode.operand(0)];
+ // Check that we have a tuple
+ checkType(_source, context, Constant.Tuple.class);
+ Constant.Tuple source = (Constant.Tuple) _source;
+ // Assign tuple element to target register
+ frame[bytecode.target()] = source.values.get(bytecode.index);
+ // Fall through to next bytecode
+ return context.pc.next();
+ }
+
+ private Object execute(Codes.UnaryOperator bytecode, Constant[] frame,
+ Context context) {
+ Constant _operand = frame[bytecode.operand(0)];
+ Constant result;
+ //
+ switch (bytecode.kind) {
+ case NEG:
+ checkType(_operand, context, Constant.Integer.class,
+ Constant.Rational.class);
+ if (_operand instanceof Constant.Integer) {
+ Constant.Integer operand = (Constant.Integer) _operand;
+ result = operand.negate();
+ } else {
+ Constant.Rational operand = (Constant.Rational) _operand;
+ result = operand.negate();
+ }
+ break;
+ case DENOMINATOR: {
+ checkType(_operand, context, Constant.Rational.class);
+ Constant.Rational operand = (Constant.Rational) _operand;
+ result = Constant.V_INTEGER(operand.value.denominator());
+ break;
+ }
+ case NUMERATOR: {
+ checkType(_operand, context, Constant.Rational.class);
+ Constant.Rational operand = (Constant.Rational) _operand;
+ result = Constant.V_INTEGER(operand.value.numerator());
+ break;
+ }
+ default:
+ return deadCode(context);
+ }
+ // Assign result to target register
+ frame[bytecode.target()] = result;
+ // Fall through to next bytecode
+ return context.pc.next();
+
+ }
+
+ private Object execute(Codes.Update bytecode, Constant[] frame,
+ Context context) {
+ Constant rhs = frame[bytecode.result()];
+ Constant lhs = frame[bytecode.target()];
+ frame[bytecode.target()] = update(lhs, bytecode.iterator(), rhs, frame,
+ context);
+ return context.pc.next();
+ }
+
+ /**
+ * Manages the process of updating an LVal. Here, the left-hand side (lhs)
+ * value is passed in along with a descriptor describing the shape of the
+ * lhs. The right-hand side value is that being assigned by the bytecode to
+ * a component of the left-hand side.
+ *
+ * @param lhs
+ * The left-hand side component being updated
+ * @param descriptor
+ * A descriptor describing the shape of the left-hand side
+ * component.
+ * @param rhs
+ * The right-hand side value being assigned to the inner-most
+ * component of the left-hand side.
+ * @param frame
+ * The current stack frame
+ * @param context
+ * Context in which bytecodes are executed
+ *
+ * @return The left-hand side updated with the new value assigned
+ */
+ private Constant update(Constant lhs, Iterator descriptor,
+ Constant rhs, Constant[] frame, Context context) {
+ if (descriptor.hasNext()) {
+ Codes.LVal lval = descriptor.next();
+ // Check what shape the left-hand side is
+ if (lval instanceof Codes.ListLVal) {
+ // List
+ Codes.ListLVal lv = (Codes.ListLVal) lval;
+ Constant operand = frame[lv.indexOperand];
+ checkType(operand, context, Constant.Integer.class);
+ checkType(lhs, context, Constant.List.class);
+ Constant.List list = (Constant.List) lhs;
+ int index = ((Constant.Integer) operand).value.intValue();
+ ArrayList values = new ArrayList(
+ list.values);
+ rhs = update(values.get(index), descriptor, rhs, frame, context);
+ values.set(index, rhs);
+ return Constant.V_LIST(values);
+ } else if (lval instanceof Codes.MapLVal) {
+ // List
+ Codes.MapLVal lv = (Codes.MapLVal) lval;
+ Constant key = frame[lv.keyOperand];
+ checkType(lhs, context, Constant.Map.class);
+ Constant.Map map = (Constant.Map) lhs;
+ HashMap values = new HashMap(
+ map.values);
+ rhs = update(values.get(key), descriptor, rhs, frame, context);
+ values.put(key, rhs);
+ return Constant.V_MAP(values);
+ } else if (lval instanceof Codes.RecordLVal) {
+ // Record
+ Codes.RecordLVal lv = (Codes.RecordLVal) lval;
+ checkType(lhs, context, Constant.Record.class);
+ Constant.Record record = (Constant.Record) lhs;
+ HashMap values = new HashMap(
+ record.values);
+ rhs = update(values.get(lv.field), descriptor, rhs, frame,
+ context);
+ values.put(lv.field, rhs);
+ return Constant.V_RECORD(values);
+ } else {
+ // Reference
+ Codes.ReferenceLVal lv = (Codes.ReferenceLVal) lval;
+ checkType(lhs, context, ConstantObject.class);
+ ConstantObject object = (ConstantObject) lhs;
+ rhs = update(object.read(), descriptor, rhs, frame, context);
+ object.write(rhs);
+ return object;
+ }
+ } else {
+ // Base case --- we've reached the inner most component. Therefore,
+ // we effectively replace the lhs with the rhs.
+ return rhs;
+ }
+ }
+
+ private Object execute(Codes.Void bytecode, Constant[] frame,
+ Context context) {
+ // This bytecode just voids out all of its operands.
+ for (int operand : bytecode.operands()) {
+ frame[operand] = null;
+ }
+ return context.pc.next();
+ }
+
+ /**
+ * Check that a given operand value matches an expected type.
+ *
+ * @param operand
+ * --- bytecode operand to be checked
+ * @param context
+ * --- Context in which bytecodes are executed
+ * @param types
+ * --- Types to be checked against
+ */
+ private void checkType(Constant operand, Context context,
+ Class extends Constant>... types) {
+ // Got through each type in turn checking for a match
+ for (int i = 0; i != types.length; ++i) {
+ if (types[i].isInstance(operand)) {
+ // Matched!
+ return;
+ }
+ }
+ // No match, therefore through an error
+ error("invalid operand", context);
+ }
+
+ /**
+ * Cleanse all instances of Constant.Decimal from the given constant and
+ * replace them with Constant.Rational.
+ *
+ * @param constant
+ * @return
+ */
+ private Constant cleanse(Constant constant, Context context) {
+ // See #494 for more on why this method exists, and whether or not we
+ // can get rid of it.
+ if (constant instanceof Constant.Null
+ || constant instanceof Constant.Byte
+ || constant instanceof Constant.Bool
+ || constant instanceof Constant.Integer
+ || constant instanceof Constant.Lambda
+ || constant instanceof Constant.Type) {
+ return constant;
+ } else if (constant instanceof Constant.Decimal) {
+ Constant.Decimal dec = (Constant.Decimal) constant;
+ return Constant.V_RATIONAL(new BigRational(dec.value));
+ } else if (constant instanceof Constant.Tuple) {
+ Constant.Tuple ct = (Constant.Tuple) constant;
+ ArrayList values = new ArrayList(ct.values);
+ for (int i = 0; i != values.size(); ++i) {
+ values.set(i, cleanse(values.get(i), context));
+ }
+ return Constant.V_TUPLE(values);
+ } else if (constant instanceof Constant.Set) {
+ Constant.Set ct = (Constant.Set) constant;
+ ArrayList values = new ArrayList(ct.values);
+ for (int i = 0; i != values.size(); ++i) {
+ values.set(i, cleanse(values.get(i), context));
+ }
+ return Constant.V_SET(values);
+ } else if (constant instanceof Constant.List) {
+ Constant.List ct = (Constant.List) constant;
+ ArrayList values = new ArrayList(ct.values);
+ for (int i = 0; i != values.size(); ++i) {
+ values.set(i, cleanse(values.get(i), context));
+ }
+ return Constant.V_LIST(values);
+ } else if (constant instanceof Constant.Map) {
+ Constant.Map mt = (Constant.Map) constant;
+ HashMap values = mt.values;
+ HashMap nValues = new HashMap();
+ for (Map.Entry e : values.entrySet()) {
+ Constant key = cleanse(e.getKey(), context);
+ Constant value = cleanse(e.getValue(), context);
+ nValues.put(key, value);
+ }
+ return Constant.V_MAP(nValues);
+ } else if (constant instanceof Constant.Record) {
+ Constant.Record mt = (Constant.Record) constant;
+ HashMap fields = mt.values;
+ HashMap nFields = new HashMap();
+ for (Map.Entry e : fields.entrySet()) {
+ Constant value = cleanse(e.getValue(), context);
+ nFields.put(e.getKey(), value);
+ }
+ return Constant.V_RECORD(nFields);
+ } else {
+ deadCode(context);
+ return null;
+ }
+ }
+
+ /**
+ * This method is provided as a generic mechanism for reporting runtime
+ * errors within the interpreter.
+ *
+ * @param msg
+ * --- Message to be printed when error arises.
+ * @param context
+ * --- Context in which bytecodes are executed
+ */
+ private Object error(String msg, Context context) {
+ // FIXME: do more here
+ throw new RuntimeException(msg);
+ }
+
+ /**
+ * This method is provided to properly handled positions which should be
+ * dead code.
+ *
+ * @param context
+ * --- Context in which bytecodes are executed
+ */
+ private Object deadCode(Context context) {
+ // FIXME: do more here
+ throw new RuntimeException("internal failure --- dead code reached");
+ }
+
+ /**
+ * A class for grouping two related items together. In essence, the context
+ * represents a position within a given bytecode block. This is useful for
+ * better error reporting.
+ *
+ * @author David J. Pearce
+ *
+ */
+ public static class Context {
+ public final CodeBlock.Index pc;
+ public final AttributedCodeBlock block;
+ private Map labels;
+
+ public Context(CodeBlock.Index pc, AttributedCodeBlock block) {
+ this.pc = pc;
+ this.block = block;
+ }
+
+ public CodeBlock.Index getLabel(String label) {
+ if (labels == null) {
+ labels = CodeUtils.buildLabelMap(block);
+ }
+ return labels.get(label);
+ }
+ }
+
+ /**
+ * Represents an object allocated on the heap.
+ *
+ * @author David J. Pearce
+ *
+ */
+ private class ConstantObject extends Constant {
+ private Constant value;
+
+ public ConstantObject(Constant value) {
+ this.value = value;
+ }
+
+ public Constant read() {
+ return value;
+ }
+
+ public void write(Constant newValue) {
+ value = newValue;
+ }
+
+ public boolean equals(Object o) {
+ return o == this;
+ }
+
+ public int hashCode() {
+ return value.hashCode();
+ }
+
+ @Override
+ public int compareTo(Constant o) {
+ // This method cannot be implmened because it does not make sense to
+ // compare a reference with another reference.
+ throw new UnsupportedOperationException(
+ "ConstantObject.compare() cannot be implemented");
+ }
+
+ @Override
+ public wyil.lang.Type type() {
+ return wyil.lang.Type.Reference(value.type());
+ }
+
+ }
+}
diff --git a/modules/wyjc/src/wyjc/Wyil2JavaBuilder.java b/modules/wyjc/src/wyjc/Wyil2JavaBuilder.java
index 1755217bc5..19c73413e9 100755
--- a/modules/wyjc/src/wyjc/Wyil2JavaBuilder.java
+++ b/modules/wyjc/src/wyjc/Wyil2JavaBuilder.java
@@ -697,7 +697,8 @@ private void translate(CodeBlock.Index index, Codes.AssertOrAssume c,
Codes.Assert ca = (Codes.Assert) c;
translate(index, (CodeBlock) c, freeSlot, bytecodes);
} else {
- // essentially a no-op for now
+ Codes.Assume ca = (Codes.Assume) c;
+ translate(index, (CodeBlock) c, freeSlot, bytecodes);
}
}
diff --git a/modules/wyjc/src/wyjc/testing/RuntimeValidTests.java b/modules/wyjc/src/wyjc/testing/RuntimeValidTests.java
index 4215e155ba..64398131d5 100755
--- a/modules/wyjc/src/wyjc/testing/RuntimeValidTests.java
+++ b/modules/wyjc/src/wyjc/testing/RuntimeValidTests.java
@@ -28,14 +28,13 @@
import static org.junit.Assert.fail;
import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
import org.junit.*;
import wyc.WycMain;
import wyc.testing.TestUtils;
-import wyc.util.WycBuildTask;
import wyjc.WyjcMain;
import wyjc.util.WyjcBuildTask;
@@ -127,17 +126,40 @@ protected void runTest(String name) {
String CLASSPATH = CLASSPATH(WHILEY_SRC_DIR, WYJC_CLASS_DIR,
WYRL_CLASS_DIR, WYBS_CLASS_DIR);
- // Second, execute the generated JavaScript Program.
- String output = TestUtils.exec(CLASSPATH,WHILEY_SRC_DIR,name);
-
- // The name of the file which contains the output for this test
- String sampleOutputFile = WHILEY_SRC_DIR + File.separatorChar + name
- + ".sysout";
-
- // Third, compare the output!
- TestUtils.compare(output,sampleOutputFile);
+ // Second, execute the generated Java Program.
+ String output = TestUtils.execClass(CLASSPATH,WHILEY_SRC_DIR,"wyjc.testing.RuntimeValidTests",name);
+ if(!output.equals("")) {
+ System.out.println(output);
+ fail("unexpected output!");
+ }
}
+ /**
+ * This is the entry point for each test. The argument provided is the name
+ * of the test class. The special method "test" is then invoked on this
+ * class with no arguments provided. The method should execute without
+ * producing output (success), or report some kind of runtime fault
+ * (failure).
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ String testClassName = args[0];
+ try {
+ Class testClass = Class.forName(testClassName);
+ Method testMethod = testClass.getMethod("test");
+ testMethod.invoke(null);
+ } catch(ClassNotFoundException e) {
+ e.printStackTrace(System.out);
+ } catch(NoSuchMethodException e) {
+ e.printStackTrace(System.out);
+ } catch(InvocationTargetException e) {
+ e.printStackTrace(System.out);
+ } catch (IllegalAccessException e) {
+ e.printStackTrace(System.out);
+ }
+ }
+
/**
* Run the Whiley Compiler with the given list of arguments.
*
@@ -431,16 +453,6 @@ public void Complex_Valid_8() {
runTest("Complex_Valid_8");
}
- @Ignore("#311") @Test
- public void Constant_Valid_1() {
- runTest("Constant_Valid_1");
- }
-
- @Ignore("#311") @Test
- public void Constant_Valid_2() {
- runTest("Constant_Valid_2");
- }
-
@Test
public void Constant_Valid_3() {
runTest("Constant_Valid_3");
@@ -481,7 +493,7 @@ public void ConstrainedInt_Valid_14() {
runTest("ConstrainedInt_Valid_14");
}
- @Ignore("???") @Test
+ @Test
public void ConstrainedInt_Valid_15() {
runTest("ConstrainedInt_Valid_15");
}
@@ -631,7 +643,7 @@ public void ConstrainedList_Valid_22() {
runTest("ConstrainedList_Valid_22");
}
- @Ignore("???") @Test
+ @Test
public void ConstrainedList_Valid_23() {
runTest("ConstrainedList_Valid_23");
}
@@ -1285,12 +1297,12 @@ public void Import_Valid_3() {
runTest("Import_Valid_3");
}
- @Test
+ @Ignore("#492") @Test
public void Import_Valid_4() {
runTest("Import_Valid_4");
}
- @Test
+ @Ignore("#492") @Test
public void Import_Valid_5() {
runTest("Import_Valid_5");
}
@@ -1669,7 +1681,7 @@ public void MessageRef_Valid_1() {
runTest("MessageRef_Valid_1");
}
- @Ignore("???") @Test
+ @Test
public void MessageRef_Valid_2() {
runTest("MessageRef_Valid_2");
}
@@ -1714,7 +1726,7 @@ public void MethodCall_Valid_3() {
runTest("MethodCall_Valid_3");
}
- @Ignore("???") @Test
+ @Test
public void MethodCall_Valid_4() {
runTest("MethodCall_Valid_4");
}
@@ -1814,11 +1826,6 @@ public void OpenRecord_Valid_9() {
runTest("OpenRecord_Valid_9");
}
- @Test
- public void Print_Valid_1() {
- runTest("Print_Valid_1");
- }
-
@Test
public void ProcessAccess_Valid_1() {
runTest("ProcessAccess_Valid_1");
@@ -1849,16 +1856,6 @@ public void Process_Valid_12() {
runTest("Process_Valid_12");
}
- @Test
- public void Process_Valid_13() {
- runTest("Process_Valid_13");
- }
-
- @Test
- public void Process_Valid_14() {
- runTest("Process_Valid_14");
- }
-
@Test
public void Process_Valid_2() {
runTest("Process_Valid_2");
@@ -2089,7 +2086,7 @@ public void RecursiveType_Valid_11() {
runTest("RecursiveType_Valid_11");
}
- @Ignore("???") @Test
+ @Test
public void RecursiveType_Valid_12() {
runTest("RecursiveType_Valid_12");
}
@@ -2144,7 +2141,7 @@ public void RecursiveType_Valid_21() {
runTest("RecursiveType_Valid_21");
}
- @Ignore("???") @Test
+ @Test
public void RecursiveType_Valid_22() {
runTest("RecursiveType_Valid_22");
}
@@ -2369,7 +2366,7 @@ public void SetIntersection_Valid_6() {
runTest("SetIntersection_Valid_6");
}
- @Ignore("???") @Test
+ @Test
public void SetIntersection_Valid_7() {
runTest("SetIntersection_Valid_7");
}
@@ -2839,7 +2836,7 @@ public void TypeEquals_Valid_29() {
runTest("TypeEquals_Valid_29");
}
- @Ignore("issue ???") @Test
+ @Test
public void TypeEquals_Valid_3() {
runTest("TypeEquals_Valid_3");
}
@@ -3079,7 +3076,7 @@ public void Update_Valid_1() {
runTest("Update_Valid_1");
}
- @Ignore("Issue ???") @Test
+ @Test
public void Update_Valid_2() {
runTest("Update_Valid_2");
}
@@ -3199,7 +3196,7 @@ public void While_Valid_27() {
runTest("While_Valid_27");
}
- @Ignore("???") @Test
+ @Test
public void While_Valid_28() {
runTest("While_Valid_28");
}
diff --git a/modules/wyopcl/README b/modules/wyopcl/README
deleted file mode 100644
index b2083bcea5..0000000000
--- a/modules/wyopcl/README
+++ /dev/null
@@ -1,18 +0,0 @@
-======================================================================
-Package Summary
-======================================================================
-src/wyopcl --- The main entry point.
-
-src/wyopcl/util --- The interpreter reads the Whiley
- Intermediate Language (WyIL) code and
- dispatches each byte-code to an individual
- interpreter in accordance with byte-code
- type.
-
-src/wyopcl/util/interpreter --- The WyIL bytecode interpreter reads one
- kind of bytecode, execute the contents
- and output the results to register table
- or console.
-
-test/wyopcl/testing/interpreter --- The unit tests for interpreter.
-
\ No newline at end of file
diff --git a/modules/wyopcl/build.xml b/modules/wyopcl/build.xml
deleted file mode 100644
index c9667e0288..0000000000
--- a/modules/wyopcl/build.xml
+++ /dev/null
@@ -1,90 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/modules/wyopcl/src/wyopcl/WyopclAntTask.java b/modules/wyopcl/src/wyopcl/WyopclAntTask.java
deleted file mode 100644
index 3beb65339d..0000000000
--- a/modules/wyopcl/src/wyopcl/WyopclAntTask.java
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) 2011, David J. Pearce (djp@ecs.vuw.ac.nz)
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-// * Neither the name of the nor the
-// names of its contributors may be used to endorse or promote products
-// derived from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL DAVID J. PEARCE BE LIABLE FOR ANY
-// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package wyopcl;
-
-import java.io.*;
-import wyc.util.WycAntTask;
-
-/**
- * An AntTask for compiling JVM Class files from Whiley source files or Wyil
- * binary files. The following illustrates how this task can be used in a
- * build.xml
file:
- *
- *
- *
- *
- *
- *
- *
- * The first line defines the new task, and requires the src/
- * directory (which contains this class) to be on the classpath; The second
- * invokes the task to compile all wyil files rooted in the stdlib/
- * directory which are in the whiley/
package.
- *
- *
- * @author David J. Pearce
- *
- */
-public class WyopclAntTask extends WycAntTask {
- private final WyopclBuildTask myBuilder;
-
- public WyopclAntTask() {
- super(new WyopclBuildTask());
- this.myBuilder = (WyopclBuildTask) builder;
- }
-}
diff --git a/modules/wyopcl/src/wyopcl/WyopclBuildTask.java b/modules/wyopcl/src/wyopcl/WyopclBuildTask.java
deleted file mode 100644
index f0d6307f74..0000000000
--- a/modules/wyopcl/src/wyopcl/WyopclBuildTask.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package wyopcl;
-
-import static wycc.lang.SyntaxError.internalFailure;
-import wybs.lang.Builder;
-import wybs.util.StdBuildRule;
-import wybs.util.StdProject;
-import wycc.util.Logger;
-import wyopcl.util.Interpreter;
-import wyopcl.util.InterpreterConfiguration;
-
-public class WyopclBuildTask extends wyc.util.WycBuildTask {
- //runtime
- protected String[] arguments;
- //'range' option
- private String range= null;
-
- public void setRange(String range) {
- this.range = range;
- }
-
- public void setArguments(String[] arguments) {
- this.arguments = arguments;
- }
-
- public WyopclBuildTask() {
- super();
- }
-
- @Override
- protected void addBuildRules(StdProject project) {
- // Add default build rule for converting whiley files into wyil files.
- super.addBuildRules(project);
- Builder builder = null;
- //Check the first argument to determine whether to run the analyzer.
- if(range != null){
- /*//Create a config object to store the properties
- AnalyzerConfiguration config = new AnalyzerConfiguration(project);
- config.setProperty("invoked", true);
- if(range!=null){
- switch(range){
- case "naive":
- config.setProperty("widen", WidenStrategy.NAIVE);
- break;
- case "gradual":
- config.setProperty("widen", WidenStrategy.GRADUAL);
- }
- }
-
- if (verbose) {
- config.setProperty("logger", new Logger.Default(System.err));
- config.setProperty("verbose", true);
- }
- config.setProperty("argument", arguments);
- builder = new BoundAnalyzer(config);*/
- }else{
- // Now, add build rule for interpreting the wyil files by using
- // the WyilInterpreter.
- InterpreterConfiguration config = new InterpreterConfiguration(project);
- if (verbose) {
- config.setProperty("logger", new Logger.Default(System.err));
- config.setProperty("verbose", true);
- }
- config.setProperty("arguments", this.arguments);
- builder = new Interpreter(config);
- }
-
- project.add(new StdBuildRule(builder, wyilDir, wyilIncludes,
- wyilExcludes, null));
-
-
- }
-
-
-
-
-}
-
diff --git a/modules/wyopcl/src/wyopcl/WyopclMain.java b/modules/wyopcl/src/wyopcl/WyopclMain.java
deleted file mode 100644
index 61af81871a..0000000000
--- a/modules/wyopcl/src/wyopcl/WyopclMain.java
+++ /dev/null
@@ -1,132 +0,0 @@
-package wyopcl;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Map;
-
-import wyc.WycMain;
-import wyc.util.WycBuildTask;
-import wycc.lang.SyntaxError;
-import wycc.lang.SyntaxError.InternalFailure;
-import wycc.util.OptArg;
-
-public class WyopclMain extends WycMain{
- private boolean verbose = false;
- public static final OptArg[] EXTRA_OPTIONS = {
- //Add the 'range' option
- new OptArg("range", null, OptArg.STRING, "Run bound analysis on whiley program with a specific widening strategy:\n"
- + "\t\t\t [naive]\tWidening the bounds to infinity.\n"
- + "\t\t\t [gradual]\tWidening the bounds to Int16, Int32, Int64 and infinity.")
- };
-
- public static OptArg[] DEFAULT_OPTIONS;
-
- static {
- // first append options
- OptArg[] options = new OptArg[WycMain.DEFAULT_OPTIONS.length
- + EXTRA_OPTIONS.length];
- System.arraycopy(WycMain.DEFAULT_OPTIONS, 0, options, 0,
- WycMain.DEFAULT_OPTIONS.length);
- System.arraycopy(EXTRA_OPTIONS, 0, options,
- WycMain.DEFAULT_OPTIONS.length, EXTRA_OPTIONS.length);
- WyopclMain.DEFAULT_OPTIONS = options;
- }
-
- public WyopclMain(WycBuildTask builder, OptArg[] options) {
- super(builder, options);
- }
-
-
-
- @Override
- public void configure(Map values) throws IOException {
- super.configure(values);
- verbose = values.containsKey("verbose");
- builder.setVerbose(verbose);
- if(values.containsKey("range")){
- String range = (String)values.get("range");
- ((WyopclBuildTask) builder).setRange(range);
- }
- }
-
-
- @Override
- public int run(String[] _args) {
- try {
- // =====================================================================
- // Process Options
- // =====================================================================
-
- ArrayList args = new ArrayList(Arrays.asList(_args));
- Map values = OptArg.parseOptions(args, options);
-
- // Second, check if we're printing version
- if (values.containsKey("version")) {
- version();
- return SUCCESS;
- }
-
- // Otherwise, if no files to compile specified, then print usage
- if (args.isEmpty() || values.containsKey("help")) {
- usage();
- return SUCCESS;
- }
-
- configure(values);
-
- ArrayList delta = new ArrayList();
- //Additional arguments
- ArrayList arguments = new ArrayList();
- for (String arg : args) {
- if(arg.contains(".whiley")){
- File f = new File(arg);
- if(f.exists()){
- delta.add(f);
- }else{
- throw new RuntimeException("Could not find "+arg);
- }
- }else{
- arguments.add(arg);
- }
- }
-
- ((WyopclBuildTask) builder).setArguments(arguments.toArray(new String[arguments.size()]));
-
- // =====================================================================
- // Run Build Task
- // =====================================================================
- builder.build(delta);
-
- } catch (InternalFailure e) {
- e.outputSourceError(stderr,false);
- if (verbose) {
- e.printStackTrace(stderr);
- }
- return INTERNAL_FAILURE;
- } catch (SyntaxError e) {
- e.outputSourceError(stderr,false);
- if (verbose) {
- e.printStackTrace(stderr);
- }
- return SYNTAX_ERROR;
- } catch (Throwable e) {
- stderr.println("" + e.getMessage() + "");
- if (verbose) {
- e.printStackTrace(stderr);
- }
- return INTERNAL_FAILURE;
- }
-
- return SUCCESS;
- }
-
-
-
- public static void main(String[] args) {
- // run WyopclBuildTask
- System.exit(new WyopclMain(new WyopclBuildTask(), DEFAULT_OPTIONS).run(args));
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/Closure.java b/modules/wyopcl/src/wyopcl/util/Closure.java
deleted file mode 100644
index 607209d843..0000000000
--- a/modules/wyopcl/src/wyopcl/util/Closure.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package wyopcl.util;
-
-import wyil.lang.Constant;
-/**
- * This class stores all the information about Lambda function
- * @author mw169
- *
- */
-public final class Closure extends Constant {
- public final Constant.Lambda lambda;
- public final Constant.Tuple params;
- public final Constant.Type type;
-
- public static Closure V_Closure(Constant.Lambda lambda, Constant.Tuple params, Constant.Type type) {
- return new Closure(lambda, params, type);
- }
-
- private Closure(Constant.Lambda lambda, Constant.Tuple parameters, Constant.Type returntype){
- this.lambda = lambda;
- this.params = parameters;
- this.type = returntype;
- }
-
- public Constant.Tuple parameters(){
- return params;
- }
-
- public Constant.Lambda lambda(){
- return lambda;
- }
-
- @Override
- public String toString() {
- return "Closure [lambda=" + lambda + ", parameters=" + params + ", returntype=" + type + "]";
- }
-
-
- @Override
- public int compareTo(Constant o) {
- // TODO Auto-generated method stub
- return 0;
- }
-
-
- @Override
- public wyil.lang.Type type() {
- // TODO Auto-generated method stub
- return null;
- }
-}
diff --git a/modules/wyopcl/src/wyopcl/util/DecimalFraction.java b/modules/wyopcl/src/wyopcl/util/DecimalFraction.java
deleted file mode 100644
index cf5d1030b0..0000000000
--- a/modules/wyopcl/src/wyopcl/util/DecimalFraction.java
+++ /dev/null
@@ -1,111 +0,0 @@
-package wyopcl.util;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import wyil.lang.Constant;
-/**
- * This class converts the division of two Constant.Decimals or a Constant.Decimal
- * to a fraction (numerator/denominator)
- * @author Min-Hsien Weng
- *
- */
-public final class DecimalFraction extends Constant {
-
- private Constant.Integer numerator, denominator;
- /**
- * Private constructor
- */
- private DecimalFraction(){
- numerator = null;
- denominator = null;
- }
-
- /**
- * Reduces the fraction to lowest terms using the common divisor
- * @param num the numerator
- * @param denum the denominator
- */
- private void reduceFraction(BigInteger num, BigInteger denum){
- BigInteger gcd = denum.gcd(num);
- this.numerator = Constant.V_INTEGER(num.divide(gcd));
- this.denominator = Constant.V_INTEGER(denum.divide(gcd));
- }
- /**
- * Constructor with integral number and integral denominator
- * @param num
- * @param denum
- * @return
- */
- public static DecimalFraction V_DecimalFraction(Constant.Integer num, Constant.Integer denum){
- DecimalFraction frac = new DecimalFraction();
- frac.reduceFraction(num.value, denum.value);
- return frac;
- }
-
-
- /**
- * Constructor with real number and real denominator
- * @param num the numerator
- * @param denum the denominator
- * @return an instance of DecimalFraction
- */
- public static DecimalFraction V_DecimalFraction(Constant.Decimal num, Constant.Decimal denum){
- DecimalFraction fraction = new DecimalFraction();
- int scale = Math.max(num.value.scale(), denum.value.scale());
- fraction.reduceFraction(num.value.multiply(BigDecimal.TEN.pow(scale)).toBigInteger(),
- denum.value.multiply(BigDecimal.TEN.pow(scale)).toBigInteger());
- return fraction;
- }
-
- /**
- * Constructor with a Constant.Decimal
- * @param decimal the decimal
- * @return an instance of DecimalFraction
- */
- public static DecimalFraction V_DecimalFraction(Constant.Decimal quotient){
- DecimalFraction fraction = new DecimalFraction();
- BigDecimal denum = BigDecimal.TEN.pow(quotient.value.scale());
- BigDecimal num = quotient.value.multiply(denum);
- fraction.reduceFraction(num.toBigInteger(), denum.toBigInteger());
- return fraction;
- }
-
- public Constant.Integer getDenominator() {
- return denominator;
- }
-
- public Constant.Integer getNumerator() {
- return numerator;
- }
-
- @Override
- public String toString() {
- //Check if denominator is 1. If so, then return numerator.
- if(this.denominator.value.equals(BigInteger.ONE)){
- return this.numerator+".0";
- }
- return "("+this.numerator+"/"+this.denominator+")";
- }
-
- @Override
- public int compareTo(Constant arg0) {
- if(arg0 instanceof DecimalFraction) {
- DecimalFraction frac = (DecimalFraction)arg0;
- int compareTo = this.numerator.compareTo(frac.numerator);
- if(compareTo==0){
- return this.denominator.compareTo(frac.denominator);
- }
- return compareTo;
- }
- return -1; // for other types.
-
- }
-
- @Override
- public wyil.lang.Type type() {
- // TODO Auto-generated method stub
- return null;
- }
-
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/Interpreter.java b/modules/wyopcl/src/wyopcl/util/Interpreter.java
deleted file mode 100644
index 978a0104e2..0000000000
--- a/modules/wyopcl/src/wyopcl/util/Interpreter.java
+++ /dev/null
@@ -1,398 +0,0 @@
-package wyopcl.util;
-
-import static wycc.lang.SyntaxError.internalFailure;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.Stack;
-
-import wybs.lang.Build.Project;
-import wybs.lang.Builder;
-import wycc.lang.SyntaxError;
-import wycc.util.Logger;
-import wycc.util.Pair;
-import wyfs.lang.Path;
-import wyfs.lang.Path.Root;
-import wyil.lang.Code;
-import wyil.lang.Code.Block;
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyil.lang.Type;
-import wyil.lang.Type.FunctionOrMethod;
-import wyil.lang.WyilFile;
-import wyil.lang.WyilFile.Case;
-import wyil.lang.WyilFile.FunctionOrMethodDeclaration;
-import wyopcl.util.interpreter.AssertOrAssumeInterpreter;
-import wyopcl.util.interpreter.AssignInterpreter;
-import wyopcl.util.interpreter.BinaryOperatorInterpreter;
-import wyopcl.util.interpreter.ConstantInterpreter;
-import wyopcl.util.interpreter.ConvertInterpreter;
-import wyopcl.util.interpreter.DebugInterpreter;
-import wyopcl.util.interpreter.DereferenceInterpreter;
-import wyopcl.util.interpreter.FailInterpreter;
-import wyopcl.util.interpreter.FieldLoadInterpreter;
-import wyopcl.util.interpreter.ForAllInterpreter;
-import wyopcl.util.interpreter.GotoInterpreter;
-import wyopcl.util.interpreter.IfInterpreter;
-import wyopcl.util.interpreter.IfIsInterpreter;
-import wyopcl.util.interpreter.IndexOfInterpreter;
-import wyopcl.util.interpreter.IndirectInvokeInterpreter;
-import wyopcl.util.interpreter.InvertInterpreter;
-import wyopcl.util.interpreter.InvokeInterpreter;
-import wyopcl.util.interpreter.LabelInterpreter;
-import wyopcl.util.interpreter.LambdaInterpreter;
-import wyopcl.util.interpreter.LengthOfInterpreter;
-import wyopcl.util.interpreter.ListOperatorInterpreter;
-import wyopcl.util.interpreter.LoopEndInterpreter;
-import wyopcl.util.interpreter.LoopInterpreter;
-import wyopcl.util.interpreter.NewListInterpreter;
-import wyopcl.util.interpreter.NewMapInterpreter;
-import wyopcl.util.interpreter.NewObjectInterpreter;
-import wyopcl.util.interpreter.NewRecordInterpreter;
-import wyopcl.util.interpreter.NewSetInterpreter;
-import wyopcl.util.interpreter.NewTupleInterpreter;
-import wyopcl.util.interpreter.NopInterpreter;
-import wyopcl.util.interpreter.ReturnInterpreter;
-import wyopcl.util.interpreter.SetOperatorInterpreter;
-import wyopcl.util.interpreter.StringOperatorInterpreter;
-import wyopcl.util.interpreter.SubListInterpreter;
-import wyopcl.util.interpreter.SubStringInterpreter;
-import wyopcl.util.interpreter.SwitchInterpreter;
-import wyopcl.util.interpreter.ThrowInterpreter;
-import wyopcl.util.interpreter.TryCatchInterpreter;
-import wyopcl.util.interpreter.TupleLoadInterpreter;
-import wyopcl.util.interpreter.UnaryOperatorInterpreter;
-import wyopcl.util.interpreter.UpdateInterpreter;
-
-/*Declare the abstract Interpreter class, methods and variables. */
-/**
- * Entry point of WyIL intepreter to iterate over bytecode, build control flow graph,
- * and infer bounds.
- * @author Min-Hsien Weng
- *
- */
-public class Interpreter implements Builder {
- //Store a hashmap inside a hashmap.
- protected static HashMap> blocktable = new HashMap>();
- protected static Stack blockstack = new Stack();
- protected static SymbolTable symboltable = new SymbolTable();
- protected static InterpreterConfiguration config;
-
- public Interpreter(){
-
- }
-
- public Interpreter(InterpreterConfiguration config){
- Interpreter.config = config;
- }
-
- public boolean isVerbose() {
- return (boolean) config.getProperty("verbose");
- }
-
-
- @Override
- public Project project() {
- return (Project) config.getProperty("project");
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public Set> build(
- Collection, Root>> delta)
- throws IOException {
- Runtime runtime = Runtime.getRuntime();
- long start = System.currentTimeMillis();
- long memory = runtime.freeMemory();
-
- HashSet> generatedFiles = new HashSet>();
- for(Pair,Path.Root> p : delta) {
- //Path.Root dst = p.second();
- Path.Entry sf = (Path.Entry) p.first();
- WyilFile module = sf.read();
- config.setProperty("module", module);
- config.setProperty("filename", module.filename());
- this.preprocessor(module);
- //Get started with the main method.
- this.interpret(module);
- }
-
- long endTime = System.currentTimeMillis();
- Logger logger = (Logger) config.getProperty("logger");
- logger.logTimedMessage("Wyil interpreter completed.\nFile:" + config.getProperty("filename"),
- (endTime - start), memory - runtime.freeMemory());
- return generatedFiles;
- }
-
-
-
- private void scanLabelsinBlock(Block blk){
- //Pre-scan the code block and keep the symbol label map.
- for(int pos = 0; pos "+pos);
- }
- }
- }
-
- /*Scans the methods*/
- protected void preprocessor(WyilFile module){
- String id = module.id().toString();
- for(WyilFile.FunctionOrMethodDeclaration method : module.functionOrMethods()) {
- String name = id+":"+method.name();
- HashMap blocks = blocktable.get(name);
- if(blocks == null){
- blocks = new HashMap();
- }
- for(Case mcase : method.cases()){
- List entries = new ArrayList();
- //Add the entries in the precondition.
- List pre_list = mcase.precondition();
- if(pre_list != null){
- for(Block pre : pre_list){
- entries.addAll(pre);
- }
- }
- //Add the entries in the body block.
- entries.addAll(mcase.body());
-
- //Add the entries in the postcondition.
- List post_list = mcase.postcondition();
- if(post_list != null){
- for(Block post: post_list){
- entries.addAll(post);
- }
- }
-
- Block block = new Block(mcase.body().numInputs(), entries);
- blocks.put(method.type(), block);
- scanLabelsinBlock(block);
- }
-
- blocktable.put(name, blocks);
- }
-
- }
-
-
- /**
- * Get the function block by name plus type (if provided)
- * @param name the name of method or function
- * @param functionOrMethod the method or function types
- * @return the function block that contains a list of bytecode.
- */
- public static Block getFuncBlockByName(String name, FunctionOrMethod... functionOrMethod){
- //Get the Hashmap of function block by name
- //Get the Block for the corresponding function/method.
- if(blocktable.containsKey(name)){
- HashMap hashMap = blocktable.get(name);
- if (functionOrMethod == null || functionOrMethod.length == 0){
- return (Block) hashMap.values().toArray()[0];
- }else{
- return hashMap.get(functionOrMethod[0]);
- }
- }
- return null;
- }
- /**
- * Passes the command-line arguments and interprets each bytecode of the main function.
- * @param module in-memory WyIL bytecode
- */
- protected void interpret(WyilFile module){
- //Get the main method
- FunctionOrMethodDeclaration main_method= module.functionOrMethod("main").get(0);
- for(Case mcase:main_method.cases()){
- StackFrame mainframe = new StackFrame(1, mcase.body(), 0, main_method.name(), -1);
- //Put a Constant.Record to the register 0.
- int index = 0;
- for(wyil.lang.Type param : main_method.type().params()){
- //The values are used to create the Constant.Record.
- HashMap values = new HashMap();
- //put 'args' and 'out' fields into values.
- for(Entry entry : ((Type.Record)param).fields().entrySet()){
- values.put(entry.getKey(), Constant.V_TYPE(entry.getValue()));
- }
- //Create a List of Constant objects.
- ArrayList arguments = new ArrayList();
- for(String arg: (String[]) config.getProperty("arguments")){
- arguments.add(Constant.V_STRING(arg));
- }
- //Replace the value of args with the argument list.
- values.put("args", Constant.V_LIST(arguments));
- mainframe.setRegister(index, Constant.V_RECORD(values));
- index++;
- }
- blockstack.push(mainframe);
- }
-
-
- while(!blockstack.isEmpty()){
- StackFrame stackframe = blockstack.peek();
- Block block = stackframe.getBlock();
- int linenumber = stackframe.getLine();
- if(linenumber < block.size()){
- Block.Entry entry = block.get(linenumber);
- this.dispatch(entry, stackframe);
- }else{
- //Finish this block and pop it up from the stack.
- blockstack.pop();
- }
- }
- }
-
- /**
- * Dispatch each bytecode along with the active stack frame to an individual interpreter of bytecode type.
- *
- * @param entry the bytecode.
- * @param stackframe the active stack frame.
- */
- private void dispatch(Block.Entry entry, StackFrame stackframe) {
- Code code = entry.code;
- try{
- if (code instanceof Codes.AssertOrAssume) {
- AssertOrAssumeInterpreter.getInstance().interpret((Codes.AssertOrAssume)code, stackframe);
- } else if (code instanceof Codes.Assign) {
- AssignInterpreter.getInstance().interpret((Codes.Assign)code, stackframe);
- } else if (code instanceof Codes.BinaryOperator) {
- BinaryOperatorInterpreter.getInstance().interpret((Codes.BinaryOperator)code, stackframe);
- } else if (code instanceof Codes.ListOperator) {
- ListOperatorInterpreter.getInstance().interpret((Codes.ListOperator)code, stackframe);
- } else if (code instanceof Codes.StringOperator) {
- StringOperatorInterpreter.getInstance().interpret((Codes.StringOperator)code, stackframe);
- } else if (code instanceof Codes.Convert) {
- ConvertInterpreter.getInstance().interpret((Codes.Convert)code, stackframe);
- } else if (code instanceof Codes.Const) {
- ConstantInterpreter.getInstance().interpret((Codes.Const)code, stackframe);
- } else if (code instanceof Codes.Debug) {
- DebugInterpreter.getInstance().interpret((Codes.Debug)code, stackframe);
- } else if (code instanceof Codes.Dereference) {
- DereferenceInterpreter.getInstance().interpret((Codes.Dereference)code, stackframe);
- } else if (code instanceof Codes.Fail) {
- FailInterpreter.getInstance().interpret((Codes.Fail)code, stackframe);
- } else if (code instanceof Codes.FieldLoad) {
- FieldLoadInterpreter.getInstance().interpret((Codes.FieldLoad)code, stackframe);
- } else if (code instanceof Codes.ForAll) {
- ForAllInterpreter.getInstance().interpret((Codes.ForAll)code, stackframe);
- } else if (code instanceof Codes.Goto) {
- GotoInterpreter.getInstance().interpret((Codes.Goto)code, stackframe);
- } else if (code instanceof Codes.If) {
- IfInterpreter.getInstance().interpret((Codes.If)code, stackframe);
- } else if (code instanceof Codes.IfIs) {
- IfIsInterpreter.getInstance().interpret((Codes.IfIs)code, stackframe);
- } else if (code instanceof Codes.IndirectInvoke) {
- IndirectInvokeInterpreter.getInstance().interpret((Codes.IndirectInvoke)code, stackframe);
- } else if (code instanceof Codes.Invoke) {
- InvokeInterpreter.getInstance().interpret((Codes.Invoke)code, stackframe);
- } else if (code instanceof Codes.Invert) {
- InvertInterpreter.getInstance().interpret((Codes.Invert)code, stackframe);
- } else if (code instanceof Codes.LoopEnd) {
- LoopEndInterpreter.getInstance().interpret((Codes.LoopEnd)code, stackframe);
- } else if (code instanceof Codes.Label) {
- LabelInterpreter.getInstance().interpret((Codes.Label)code, stackframe);
- } else if (code instanceof Codes.Lambda) {
- LambdaInterpreter.getInstance().interpret((Codes.Lambda)code, stackframe);
- } else if (code instanceof Codes.LengthOf) {
- LengthOfInterpreter.getInstance().interpret((Codes.LengthOf)code, stackframe);
- } else if (code instanceof Codes.IndexOf) {
- IndexOfInterpreter.getInstance().interpret((Codes.IndexOf)code, stackframe);
- } else if (code instanceof Codes.Loop) {
- LoopInterpreter.getInstance().interpret((Codes.Loop)code, stackframe);
- } else if (code instanceof Codes.Move) {
- internalFailure("Not implemented!", (String)config.getProperty("filename"), entry);
- } else if (code instanceof Codes.NewMap) {
- NewMapInterpreter.getInstance().interpret((Codes.NewMap)code, stackframe);
- } else if (code instanceof Codes.NewList) {
- NewListInterpreter.getInstance().interpret((Codes.NewList)code, stackframe);
- } else if (code instanceof Codes.NewRecord) {
- NewRecordInterpreter.getInstance().interpret((Codes.NewRecord)code, stackframe);
- } else if (code instanceof Codes.NewSet) {
- NewSetInterpreter.getInstance().interpret((Codes.NewSet)code, stackframe);
- } else if (code instanceof Codes.NewTuple) {
- NewTupleInterpreter.getInstance().interpret((Codes.NewTuple)code, stackframe);
- } else if (code instanceof Codes.Return) {
- ReturnInterpreter.getInstance().interpret((Codes.Return)code, stackframe);
- } else if (code instanceof Codes.NewObject) {
- NewObjectInterpreter.getInstance().interpret((Codes.NewObject)code, stackframe);
- } else if (code instanceof Codes.Nop) {
- NopInterpreter.getInstance().interpret((Codes.Nop)code, stackframe);
- } else if (code instanceof Codes.SetOperator){
- SetOperatorInterpreter.getInstance().interpret((Codes.SetOperator)code, stackframe);
- } else if (code instanceof Codes.SubList) {
- SubListInterpreter.getInstance().interpret((Codes.SubList)code, stackframe);
- } else if (code instanceof Codes.SubString) {
- SubStringInterpreter.getInstance().interpret((Codes.SubString)code, stackframe);
- } else if (code instanceof Codes.Switch) {
- SwitchInterpreter.getInstance().interpret((Codes.Switch)code, stackframe);
- } else if (code instanceof Codes.Throw) {
- ThrowInterpreter.getInstance().interpret((Codes.Throw)code, stackframe);
- } else if (code instanceof Codes.TryCatch) {
- TryCatchInterpreter.getInstance().interpret((Codes.TryCatch)code, stackframe);
- } else if (code instanceof Codes.TupleLoad) {
- TupleLoadInterpreter.getInstance().interpret((Codes.TupleLoad)code, stackframe);
- } else if (code instanceof Codes.UnaryOperator){
- UnaryOperatorInterpreter.getInstance().interpret((Codes.UnaryOperator)code, stackframe);
- } else if (code instanceof Codes.Update) {
- UpdateInterpreter.getInstance().interpret((Codes.Update)code, stackframe);
- } else {
- internalFailure("unknown wyil code encountered (" + code + ")", (String)config.getProperty("filename"), entry);
- }
- } catch (SyntaxError ex) {
- throw ex;
- } catch (Exception ex) {
- internalFailure(ex.getMessage(), (String)config.getProperty("filename"), entry, ex);
- }
-
- }
-
- /**
- * prints out the interpretation for each line of bytecode.
- * @param stackframe the active stack frame
- * @param input the
- * @param output
- */
- public void printMessage(StackFrame stackframe, String input, String output){
- if(isVerbose()){
- System.out.println(stackframe.getDepth()+" "+stackframe.getName()+"."+stackframe.getLine()
- +" ["+input+"] "+output+"\n");
- }
-
- }
-
- public void printVerificationMessage(StackFrame stackframe, String input, String output){
- System.err.println(stackframe.getDepth()+" "+stackframe.getName()+"."+stackframe.getLine()
- +" ["+input+"] "+output+"\n");
- System.exit(-1);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/InterpreterConfiguration.java b/modules/wyopcl/src/wyopcl/util/InterpreterConfiguration.java
deleted file mode 100644
index d06ff432cd..0000000000
--- a/modules/wyopcl/src/wyopcl/util/InterpreterConfiguration.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package wyopcl.util;
-
-import java.util.Collections;
-import java.util.Properties;
-import wybs.lang.Build;
-import wycc.util.Logger;
-
-public class InterpreterConfiguration {
- private Properties properties;
-
- public InterpreterConfiguration(Build.Project project){
- this.properties = new Properties();
- this.properties.put("verbose", false);
- this.properties.put("logger", Logger.NULL);
- this.properties.put("filename", "");
- this.properties.put("project", project);
- this.properties.put("arguments", Collections.emptyList());
- }
-
- public Object getProperty(String key){
- if(!this.properties.containsKey(key)){
- throw new RuntimeException("Unknown property:" +key);
- }
- return this.properties.get(key);
- }
-
- public void setProperty(String key, Object value){
- this.properties.put(key, value);
- }
-}
diff --git a/modules/wyopcl/src/wyopcl/util/StackFrame.java b/modules/wyopcl/src/wyopcl/util/StackFrame.java
deleted file mode 100644
index b0fab003fc..0000000000
--- a/modules/wyopcl/src/wyopcl/util/StackFrame.java
+++ /dev/null
@@ -1,100 +0,0 @@
-package wyopcl.util;
-
-import java.util.Arrays;
-import java.util.HashMap;
-
-import wyil.lang.Code.Block;
-import wyil.lang.Constant;
-
-public class StackFrame {
- private final Block block;
- private String name;
- private int line;
- private int return_reg;
- private HashMap loop_index = new HashMap();
- private int depth;
- private Constant[] registers = new Constant[0];
-
- public StackFrame(int depth, Block block, int line,
- String name, int return_reg){
- this.depth = depth;
- this.block = block;
- this.name = name;
- this.line = line;
- this.return_reg = return_reg;
- }
-
- public int getLine() {
- return line;
- }
-
- public void setLine(int line){
- this.line = line;
- }
-
- public Block getBlock(){
- return block;
- }
-
- public void setReturn_reg(int return_reg) {
- this.return_reg = return_reg;
- }
-
- public int getReturn_reg() {
- return return_reg;
- }
-
- public String getName() {
- return name;
- }
-
- public Constant getRegister(int reg){
- if(reg>=registers.length || reg < 0){
- return null;
- }
-
- return registers[reg];
- }
-
- public void setRegister(int reg, Constant constant){
- if(reg>=registers.length){
- //Expand the array.
- registers = Arrays.copyOf(registers, reg+1);
- }
-
- registers[reg] = constant;
- }
-
-
- public int getRegisterLength(){
- return registers.length;
- }
-
- @Override
- public String toString() {
- return "Block:"+block.hashCode()+" Line:"+line;
- }
-
- public int getDepth() {
- return depth;
- }
-
- public void setDepth(int depth) {
- this.depth = depth;
- }
-
- public int getLoop_index(String label) {
- if(this.loop_index.containsKey(label)){
- return this.loop_index.get(label);
- }else{
- //If the loop index is not found, then return -1.
- this.loop_index.put(label, -1);
- return -1;
- }
- }
-
- public void setLoop_index(String label, int loop_index) {
- this.loop_index.put(label, loop_index);
- }
-
-}
\ No newline at end of file
diff --git a/modules/wyopcl/src/wyopcl/util/SymbolTable.java b/modules/wyopcl/src/wyopcl/util/SymbolTable.java
deleted file mode 100644
index aea100f86a..0000000000
--- a/modules/wyopcl/src/wyopcl/util/SymbolTable.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package wyopcl.util;
-
-import java.util.HashMap;
-
-import wyil.lang.Code.Block;
-import wyil.lang.Codes;
-
-/**
- * Stores the symbol information where each label relates to its line number in a block.
- * It also can map a block and a label name to the corresponding line number. The table is
- * implemented with a nested HashMap.
- * @author Min-Hsien Weng
- *
- */
-public class SymbolTable{
-
- private HashMap> labelLocMap;
- private String catchlabel = "";
-
- public SymbolTable(){
- labelLocMap = new HashMap>();
- }
- /**
- * Adds the label name in a block associated with its line number.
- * @param blk the block
- * @param label the name of label
- * @param line the line number
- */
- public void addLabelLoc(Block blk, String label, int line){
- HashMap map;
- if(labelLocMap.containsKey(blk)){
- map = labelLocMap.get(blk);
- }else{
- map = new HashMap();
- }
-
- map.put(label, line);
- labelLocMap.put(blk, map);
- }
-
- public int getBlockPosByLabel(Block blk, String label){
- if(labelLocMap.containsKey(blk)){
- HashMap map = labelLocMap.get(blk);
- if(map.containsKey(label)){
- return map.get(label);
- }
- }
-
- return -1;
- }
-
- public void addTryCatchLoc(Codes.TryCatch trycatch, int line){
- catchlabel = trycatch.catches.get(0).second();
- }
-
- public int getCatchPos(Block blk){
- return getBlockPosByLabel(blk, catchlabel);
- }
-
-}
\ No newline at end of file
diff --git a/modules/wyopcl/src/wyopcl/util/Utility.java b/modules/wyopcl/src/wyopcl/util/Utility.java
deleted file mode 100644
index c80994fc3b..0000000000
--- a/modules/wyopcl/src/wyopcl/util/Utility.java
+++ /dev/null
@@ -1,384 +0,0 @@
-package wyopcl.util;
-
-import static wycc.lang.SyntaxError.internalFailure;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.TreeSet;
-
-import wyil.lang.Constant;
-import wyil.lang.Type;
-import wyil.lang.Code.Block;
-import wyil.lang.Type.FunctionOrMethod;
-import wyjc.runtime.WyList;
-import wyjc.runtime.WyRat;
-
-public final class Utility {
-
- private Utility(){
- //Utility class has the private constructor.
- }
-
- private static String constantToString(Constant.Map map, Class> paramType) {
- String r = "{";
- if (map.values.isEmpty()) {
- r = r + "=>";
- } else {
- boolean firstTime = true;
- ArrayList keystr = new ArrayList();
- HashMap keymap = new HashMap();
- for (Constant key : map.values.keySet()) {
- keystr.add(key.toString());
- keymap.put(key.toString(), key);
- }
- Collections.sort(keystr);
- for (String key : keystr) {
- if (!firstTime) {
- r += ", ";
- }
- firstTime = false;
- Constant k = keymap.get(key);
- r += k + "=>" + convertConstantToJavaObject(map.values.get(k), paramType);
- }
- }
- r += "}";
- return r.replaceAll("\"", "");
- }
- /**
- * Returns a string of a sorted Constant.Set, using tree set.
- * @param set the Constant Set
- * @param paramType the given type
- * @return
- */
- private static String constantToString(Constant.Set set, Class> paramType) {
- // Sort the elements in a set, using the tree set.
- TreeSet sorted = new TreeSet(set.values);
- String r = "{";
- boolean firstTime = true;
- for (Constant constant: sorted) {
- if (!firstTime) {
- r += ", ";
- }
- firstTime = false;
- if(constant instanceof Constant.Char){
- r += "'"+convertConstantToJavaObject(constant, paramType)+"'";
- }else{
- r += convertConstantToJavaObject(constant, paramType);
- }
-
- }
- r += "}";
- return r.replaceAll("\"", "");
- }
-
- private static String constantToString(Constant.List list, Class> paramType) {
- String r = "[";
- boolean firstTime = true;
- for (Constant elem : list.values) {
- if (!firstTime) {
- r += ", ";
- }
- firstTime = false;
- // Check if the elem is a list
- if (elem instanceof Constant.List || elem instanceof Constant.Record) {
- r += convertConstantToJavaObject(elem, paramType);
- } else {
- r += elem;
- }
- }
- r += "]";
- return r.replaceAll("\"", "");
- }
-
- private static String constantToString(Constant.Record record, Class> paramType) {
- String r = "{";
- boolean firstTime = true;
- ArrayList keys = new ArrayList(record.values.keySet());
- Collections.sort(keys);
- for (String key : keys) {
- if (!firstTime) {
- r += ",";
- }
- firstTime = false;
- Constant next = record.values.get(key);
- if (next instanceof Constant.Record || next instanceof Constant.List) {
- // Convert the key record into a string
- r += key + ":" + convertConstantToJavaObject(next, paramType);
- } else {
- r += key + ":" + next;
- }
-
- }
- r += "}";
- return r;
- //return r.replaceAll("\"", "");
- }
-
- private static String constantToString(Constant.Tuple tuple, Class> paramType) {
- String r = "(";
- boolean firstTime = true;
- for (Constant constant : tuple.values) {
- if (!firstTime) {
- r += ",";
- }
- firstTime = false;
- r += convertConstantToJavaObject(constant, paramType);
- }
- r += ")";
-
- return r.replaceAll("\"", "");
- }
-
- /**
- * Convert the Constant object to the Java Object of given type.
- *
- * @param constant the Constant
- * @param paramType the given Java type
- * @return the Java object
- */
- @SuppressWarnings("unchecked")
- public static Object convertConstantToJavaObject(Constant constant, Class> paramType) {
-
- if (constant == null || constant instanceof Constant.Null) {
- return null;
- }
-
- if (constant instanceof Constant.Bool) {
- return ((Constant.Bool) constant).value;
- }
-
- if (constant instanceof Constant.Char) {
- return ((Constant.Char) constant).value;
- }
-
- if (constant instanceof Constant.Strung) {
- //Add the double quotas to the return string.
- return ((Constant.Strung) constant).value;
- }
-
- if (constant instanceof Constant.Byte) {
- if (paramType.equals(BigInteger.class)) {
- return ((Constant.Byte) constant).value;
- } else if (paramType.equals(WyList.class)) {
- // Cast byte to char...too complicated....
- WyList wyList = new WyList();
- wyList.add(((Constant.Byte) constant).value);
- return wyList;
- } else {
- return ((Constant.Byte) constant).value;
- }
- }
-
-
- if (constant instanceof Constant.Decimal) {
- //Check if the returned type is WyRat
- if(paramType.equals(WyRat.class)){
- return new WyRat(((Constant.Decimal)constant).value);
- }
- return (Constant.Decimal) constant;
- }
-
- if (constant instanceof DecimalFraction){
- //return the string of a DecimalFraction.
- return ((DecimalFraction)constant).toString();
- }
-
- if (constant instanceof Constant.Integer) {
- //Check if the returned type is WyRat
- if(paramType.equals(WyRat.class)){
- return new WyRat(((Constant.Integer)constant).value);
- }
- return ((Constant.Integer) constant).value;
- }
-
- if (constant instanceof Constant.List) {
- if (paramType.equals(WyList.class)) {
- WyList wylist = new WyList();
- for(Constant value: ((Constant.List) constant).values){
- wylist.add(((Constant.Byte)value).value);
- }
- return wylist;
- }else{
- return constantToString((Constant.List) constant, paramType);
- }
- }
-
- if (constant instanceof Constant.Map) {
- return constantToString((Constant.Map) constant, paramType);
- }
-
- if (constant instanceof Constant.Record) {
- return constantToString((Constant.Record) constant, paramType);
- }
-
- if (constant instanceof Constant.Set) {
- return constantToString((Constant.Set) constant, paramType);
- }
-
- if (constant instanceof Constant.Tuple) {
- return constantToString((Constant.Tuple) constant, paramType);
- }
-
- internalFailure("Not implemented!", "Converter.java", null);
- return null;
- }
-
- public static Class> convertToClass(Type paramType) {
- if (paramType instanceof Type.Any) {
- return Object.class;
- } else if (paramType instanceof Type.Strung) {
- return String.class;
- } else if (paramType instanceof Type.Int) {
- return Integer.class;
- } else {
- internalFailure("Not implemented!", "Converter.java", null);
- }
- return null;
-
- }
-
- /**
- * Copy and return the Constant object
- *
- * @param constant
- * @return
- */
- public static Constant copyConstant(Constant constant) {
- if(constant == null || constant instanceof Constant.Null){
- return Constant.V_NULL;
- }
-
- if (constant instanceof Constant.Integer) {
- return Constant.V_INTEGER(((Constant.Integer) constant).value);
- } else if (constant instanceof Constant.List) {
- ArrayList values = ((Constant.List) constant).values;
- return Constant.V_LIST(new ArrayList(values));
- } else if (constant instanceof Constant.Record) {
- return Constant.V_RECORD(((Constant.Record) constant).values);
- } else if (constant instanceof Constant.Strung) {
- return Constant.V_STRING(((Constant.Strung) constant).value);
- } else if (constant instanceof Constant.Set) {
- return Constant.V_SET(((Constant.Set) constant).values);
- } else if (constant instanceof Constant.Type) {
- return Constant.V_TYPE(((Constant.Type) constant).type);
- } else if (constant instanceof Constant.Bool) {
- return Constant.V_BOOL(((Constant.Bool) constant).value);
- } else if (constant instanceof Constant.Map) {
- return Constant.V_MAP(((Constant.Map) constant).values);
- } else if (constant instanceof Constant.Byte) {
- return Constant.V_BYTE(((Constant.Byte) constant).value);
- } else if (constant instanceof Constant.Char) {
- return Constant.V_CHAR(((Constant.Char) constant).value);
- } else if (constant instanceof Constant.Decimal) {
- return Constant.V_DECIMAL(((Constant.Decimal) constant).value);
- } else if (constant instanceof Constant.Tuple) {
- return Constant.V_TUPLE(((Constant.Tuple) constant).values);
- } else if (constant instanceof Closure){
- Closure closure = (Closure)constant;
- return Closure.V_Closure(closure.lambda, closure.params, closure.type);
- } else {
- internalFailure("Not implemented!", "Utility.java", null);
- return null;
- }
- }
-
- /**
- * Invokes the function
- * @param name
- * @param return_reg
- * @return
- */
- public static StackFrame invokeFunction(Block blk, int depth, String name, List params, int return_reg){
- StackFrame stackframe = new StackFrame(depth+1, blk, 0, name, return_reg);
-
- //Pass the input parameters.
- int index = 0;
- for(Constant param: params){
- //Constant constant = stackframe.getRegister(operand);
- stackframe.setRegister(index, param);
- index++;
- }
-
- return stackframe;
- }
-
-
-
- /**
- * Invokes Java print or println method.
- * @param name the nae of called function
- * @param paramTypes the list of input parameter types
- * @param values the list of input parameter values
- */
- public static void invokeJavaPrintFunction(String name, ArrayList paramTypes, List values){
- java.lang.reflect.Method method = null;
- try {
- Class> systemClass = Class.forName("java.lang.System");
- Field outField = systemClass.getDeclaredField("out");
- Class> printClass = outField.getType();
- Class>[] parameterTypes = new Class[paramTypes.size()];
- // Iterate the parameter types
- for (int i = 0; i < paramTypes.size(); i++) {
- parameterTypes[i] = convertToClass(paramTypes.get(i));
- }
- method = printClass.getMethod(name, parameterTypes);
-
- ArrayList
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Goto
- *
- */
-public class GotoInterpreter extends Interpreter {
- private static GotoInterpreter instance;
- private GotoInterpreter(){ }
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static GotoInterpreter getInstance(){
- if (instance == null){
- instance = new GotoInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.Goto code, StackFrame stackframe){
- int linenumber = stackframe.getLine();
-
- Block block = stackframe.getBlock();
- linenumber = symboltable.getBlockPosByLabel(block, code.target);
- stackframe.setLine(linenumber);
-
- printMessage(stackframe, code.toString(),
- code.target + "("+linenumber+")");
-
- }
-
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/IfInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/IfInterpreter.java
deleted file mode 100644
index a6a83c8dec..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/IfInterpreter.java
+++ /dev/null
@@ -1,125 +0,0 @@
-package wyopcl.util.interpreter;
-
-import java.util.Iterator;
-
-import wyil.lang.Codes;
-import wyil.lang.Code.Block;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.If
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.If
- *
- */
-public class IfInterpreter extends Interpreter {
- private static IfInterpreter instance;
- private IfInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static IfInterpreter getInstance(){
- if (instance == null){
- instance = new IfInterpreter();
- }
- return instance;
- }
-
-
- private boolean compare(Codes.Comparator op, Constant left, Constant right){
- Constant.Set leftSet, rightSet;
-
- boolean satisfiable = false;
- switch (op) {
- case EQ:
- if (left.compareTo(right) == 0){
- satisfiable = true;
- }
- break;
- case NEQ:
- if (left.compareTo(right) != 0) {
- satisfiable = true;
- }
- break;
- case LT:
- if (left.compareTo(right) < 0) {
- satisfiable = true;
- }
- break;
- case LTEQ:
- if (left.compareTo(right) <= 0) {
- satisfiable = true;
- }
- break;
- case GT:
- if (left.compareTo(right) > 0) {
- satisfiable = true;
- }
- break;
- case GTEQ:
- if (left.compareTo(right) >= 0) {
- satisfiable = true;
- }
- break;
- case IN:
- if(right instanceof Constant.Set){
- rightSet = (Constant.Set)right;
- if(rightSet.values.contains(left)){
- satisfiable = true;
- }
- }else if (right instanceof Constant.List){
- Constant.List list = (Constant.List)right;
- if(list.values.contains(left)){
- satisfiable = true;
- }
- }
- break;
- case SUBSET:
- leftSet = (Constant.Set)left;
- rightSet = (Constant.Set)right;
- //Check if two sets are identical.
- if(leftSet.equals(rightSet)){
- return false;
- }
- //Check if every element in leftSet is also an element in rightSet
- Iterator iterator = leftSet.values.iterator();
- while(iterator.hasNext()){
- Constant constant = iterator.next();
- if(!rightSet.values.contains(constant)){
- return false;
- }
- }
- return true;
- case SUBSETEQ:
- leftSet = (Constant.Set)left;
- rightSet = (Constant.Set)right;
- satisfiable = rightSet.values.containsAll(leftSet.values);
- break;
- default:
- satisfiable = true;
- throw new RuntimeException("unknown comparator encountered:"+op);
- }
-
- return satisfiable;
- }
-
- public void interpret(Codes.If code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- Constant left = stackframe.getRegister(code.leftOperand);
- Constant right = stackframe.getRegister(code.rightOperand);
- boolean satisfiable = false;
- satisfiable = compare(code.op, left, right);
-
- if(satisfiable){
- //Go to the if branch
- Block block = stackframe.getBlock();
- linenumber = symboltable.getBlockPosByLabel(block, code.target);
- }else{
- linenumber++;
- }
- printMessage(stackframe, code.toString(), "(" +satisfiable+")");
- stackframe.setLine(linenumber);
-
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/IfIsInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/IfIsInterpreter.java
deleted file mode 100644
index 5f1586626a..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/IfIsInterpreter.java
+++ /dev/null
@@ -1,313 +0,0 @@
-package wyopcl.util.interpreter;
-
-import static wycc.lang.SyntaxError.internalFailure;
-
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map.Entry;
-
-import wyil.lang.Code.Block;
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyil.lang.Type;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.IfIsInterpreter
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.IfIsInterpreter
- *
- */
-public class IfIsInterpreter extends Interpreter {
- private static IfIsInterpreter instance;
-
- private IfIsInterpreter() { }
-
- /* Implement the Singleton pattern to ensure this class has one instance. */
- public static IfIsInterpreter getInstance() {
- if (instance == null) {
- instance = new IfIsInterpreter();
- }
- return instance;
- }
- /**
- * Check the constant if its fields are matched with the given Record type.
- * @param constant the constant
- * @param type the given type
- * @return
- */
- private boolean checkType(Constant constant, Type.Record type) {
- try{
- Constant.Record record = (Constant.Record)constant;
- HashMap fields = ((Type.Record) type).fields();
- // Check the number of field values with the number of field types.
- if (record.values.size() != fields.size()) {
- return false;
- }
-
- // Iterate over the record
- for (Entry entry : record.values.entrySet()) {
- String field = entry.getKey();
- Constant fieldvalue = entry.getValue();
- // Check if the type contains the field. If so, get and compare the
- // field type with the record field.
- if (fields.containsKey(field)) {
- Type fieldType = fields.get(field);
- if (!checkType(fieldvalue, fieldType)) {
- return false;
- }
- } else {
- // Return false for lacking of the field type;
- return false;
- }
- }
-
- return true;
- }catch(ClassCastException ex){
- //Catch the type casting exception, meaning that the constant is not a instance of Constant.List subtype.
- return false;
- }catch(Exception ex){
- internalFailure("Error!!", "InterpreterIfIs.java", null);
- return false;
- }
-
-
- }
-
- private boolean checkType(Constant constant, Type.List type) {
- try{
- Constant.List list = (Constant.List)constant;
- Type elementType = type.element();
- Iterator iterator = list.values.iterator();
- while (iterator.hasNext()) {
- Constant element = iterator.next();
- if(!checkType(element, elementType)){
- return false;
- }
- }
- return true;
- }catch(ClassCastException ex){
- //Catch the type casting exception, meaning that the constant is not a instance of Constant.List subtype.
- return false;
- }catch(Exception ex){
- internalFailure("Error!!", "InterpreterIfIs.java", null);
- }
- return false;
- }
-
- private boolean checkType(Constant constant, Type.Set type) {
- try{
- Constant.Set set = (Constant.Set)constant;
- Type elementType = type.element();
- // Check if the element in the list is the specific subtype of element
- // type.
- Iterator iterator = set.values.iterator();
- while (iterator.hasNext()) {
- Constant next = iterator.next();
- if(!checkType(next, elementType)){
- return false;
- }
- }
- return true;
- }catch(ClassCastException ex){
- //Catch the type casting exception, meaning that the constant is not a instance of Constant.Set subtype.
- return false;
- }catch(Exception ex){
- //Catch other excpetions.
- internalFailure("Error!!", "InterpreterIfIs.java", null);
- return false;
- }
-
- }
-
- private boolean checkType(Constant constant, Type.Tuple type) {
- try{
- Constant.Tuple tuple = (Constant.Tuple)constant;
- Iterator iterator = tuple.values.iterator();
- int index = 0;
- while (iterator.hasNext()) {
- Constant next = iterator.next();
- Type elementType = type.element(index++);
- if (!checkType(next, elementType)) {
- return false;
- }
- }
- return true;
- }catch(ClassCastException ex){
- //Catch the type casting exception, meaning that the constant is not a instance of Constant.Tuple subtype.
- return false;
- }catch(Exception ex){
- //Catch other excpetions.
- internalFailure("Error!!", "InterpreterIfIs.java", null);
- return false;
- }
-
- }
-
- private boolean checkType(Constant constant, Type.Map type) {
- try{
- Constant.Map map = (Constant.Map)constant;
- Iterator> iterator = map.values.entrySet().iterator();
- while (iterator.hasNext()) {
- Entry entry = iterator.next();
- if (!checkType(entry.getKey(), type.key()) || !checkType(entry.getValue(), type.value())) {
- return false;
- }
- }
- return true;
- }catch(ClassCastException ex){
- //Catch the type casting exception, meaning that the constant is not a instance of Constant.Map subtype.
- return false;
- }catch(Exception ex){
- internalFailure("Error!!", "InterpreterIfIs.java", null);
- return false;
- }
-
-
- }
-
- private boolean checkType(Constant constant, Type.Union type) {
- Iterator iterator = type.bounds().iterator();
- while (iterator.hasNext()) {
- Type subtype = iterator.next();
- if (checkType(constant, subtype)) {
- return true;
- }
- }
-
- return false;
- }
-
- private boolean checkType(Constant constant, Type.Negation type) {
- // The result for negation type should be inverted (i.e. negated the
- // result of type checking)
- // Check the value is subtype of the test type.
- Type elementType = ((Type.Negation) type).element();
- // On the true branch, its type is matched with type test.
- return !checkType(constant, elementType);
- }
- /**
- * Check constant
is an instance of the specific type
- * @param constant constant object
- * @param type Constant.Type
- * @return true if the constant is of type. Otherwise, return false.
- */
- private boolean checkType(Constant constant, Type type) {
- try{
-
- if(type instanceof Type.Any){
- return true;// No checking.
- }
-
- if (type instanceof Type.Null) {
- if(constant instanceof Constant.Null){
- return true;
- }
- return false;
- }
-
- if(type instanceof Type.Bool){
- if(constant instanceof Constant.Bool){
- return true;
- }
- return false;
- }
-
- if (type instanceof Type.Char) {
- if(constant instanceof Constant.Char){
- return true;
- }
- return false;
- }
-
- if (type instanceof Type.Int) {
- if(constant instanceof Constant.Integer){
- return true;
- }
- return false;
- }
-
- if (type instanceof Type.Strung) {
- if(constant instanceof Constant.Strung){
- return true;
- }
- return false;
- }
-
- if (type instanceof Type.Real) {
- if(constant instanceof Constant.Decimal){
- return true;
- }
- return false;
- }
-
- if (type instanceof Type.Negation) {
- return checkType(constant, (Type.Negation)type);
- }
-
- if (type instanceof Type.Map) {
- return checkType(constant, (Type.Map) type);
- }
- if (type instanceof Type.Record) {
- // Check if the constant is of Constant.Record type.
- return checkType(constant, (Type.Record)type);
- }
-
- if (type instanceof Type.List) {
- return checkType(constant, (Type.List) type);
- }
-
- if (type instanceof Type.Set) {
- return checkType(constant, (Type.Set) type);
- }
-
- if (type instanceof Type.Union) {
- return checkType(constant, (Type.Union) type);
- }
-
- if(type instanceof Type.Tuple){
- return checkType(constant, (Type.Tuple)type);
- }
-
-
- }catch(ClassCastException ex){
- //Catch the type casting exception, meaning that the constant is not a instance of Constant.Map subtype.
- return false;
- }catch(Exception ex){
- internalFailure("Error!!", "InterpreterIfIs.java", null);
- return false;
- }
-
- //If type is not any of the above types, then it is a new type.
- internalFailure("Not implemented!", "InterpreterIfIs.java", null);
- return false;
-
- }
-
- /**
- * Check whether the constant value from operand register is a specific
- * subtype.
- *
- * @param code
- * @param stackframe
- */
- public void interpret(Codes.IfIs code, StackFrame stackframe) {
- // Read the value from the operand register.
- Constant constant = stackframe.getRegister(code.operand);
- Type type = code.rightOperand;
- if (checkType(constant, type)) {
- //Go to the line of target label.
- String label = code.target;
- Block block = stackframe.getBlock();
- printMessage(stackframe, code.toString(), code.target + "");
- int linenumber = symboltable.getBlockPosByLabel(block, label);
- stackframe.setLine(++linenumber);
- } else {
- //Go to the next line.
- int linenumber = stackframe.getLine();
- printMessage(stackframe, code.toString(), "");
- stackframe.setLine(++linenumber);
- }
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/IndexOfInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/IndexOfInterpreter.java
deleted file mode 100644
index 4fb30e6db0..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/IndexOfInterpreter.java
+++ /dev/null
@@ -1,122 +0,0 @@
-package wyopcl.util.interpreter;
-
-import static wycc.lang.SyntaxError.internalFailure;
-
-import java.util.Iterator;
-import java.util.Map.Entry;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.IndexOf
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.IndexOf
- *
- */
-public class IndexOfInterpreter extends Interpreter {
- private static IndexOfInterpreter instance;
- private IndexOfInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static IndexOfInterpreter getInstance(){
- if (instance == null){
- instance = new IndexOfInterpreter();
- }
- return instance;
- }
-
- private Constant getValuefromList(Constant.List list, Constant key){
- Constant value = null;
- //Get the value associated with the key.
- if(key instanceof Constant.Integer){
- value = list.values.get(((Constant.Integer)key).value.intValue());
- }else if (key instanceof Constant.Char){
- value = list.values.get(((Constant.Char)key).value);
- }else{
- internalFailure("Not implemented!", "InterpreterIndexOf.java", null);
- }
-
- return value;
- }
-
- private Constant getValuefromRecord(Constant.Record record, Constant key){
- Constant value = null;
- //Get the value associated with the key.
- if(key instanceof Constant.Integer){
- value = record.values.get(((Constant.Integer)key).value.intValue());
- }else if (key instanceof Constant.Char){
- value = record.values.get(((Constant.Char)key).value);
- }else{
- internalFailure("Not implemented!", "InterpreterIndexOf.java", null);
- }
-
- return value;
- }
- /**
- * Gets the char of a string at the given index
- * @param strung the string
- * @param index the index
- * @return the char
- */
- private Constant getValuefromStrung(Constant.Strung strung, Constant index){
- //Get the value associated with the key.
- if(index instanceof Constant.Integer){
- //Get the char at 'keyvalue' index and returns the Constant.Char object.
- char c = strung.value.charAt(((Constant.Integer)index).value.intValue());
- return Constant.V_CHAR(c);
- }
- internalFailure("Not implemented!", "InterpreterIndexOf.java", null);
- return null;
- }
-
- private Constant getValuefromMap(Constant.Map map, Constant key){
- //Get the value associated with the key.
- if(map.values.containsKey(key)){
- return map.values.get(key);
- }
-
- //Comparing two Constatn.Decimal requires using compareTo method.
- Iterator> iterator = map.values.entrySet().iterator();
- while(iterator.hasNext()){
- Entry entry = iterator.next();
- Constant entryKey = entry.getKey();
- if(entryKey.compareTo(key)==0){
- return entry.getValue();
- }
- }
-
-
- internalFailure("Not implemented!", "InterpreterIndexOf.java", null);
- return null;
- }
- /**
- * Gets the ith element from the composite set (i.e. List, Record,
- * Strung, Map)
- * @param code
- * @param stackframe
- */
- public void interpret(Codes.IndexOf code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- //Read the list from the leftOperand register.
- Constant constant = stackframe.getRegister(code.operand(0));
- Constant key = stackframe.getRegister(code.operand(1));
- Constant value = null;
- if(constant instanceof Constant.List){
- value = getValuefromList((Constant.List)constant, key);
- }else if(constant instanceof Constant.Record){
- value = getValuefromRecord((Constant.Record)constant, key);
- }else if(constant instanceof Constant.Strung){
- value = getValuefromStrung((Constant.Strung)constant, key);
- }else if (constant instanceof Constant.Map){
- value = getValuefromMap((Constant.Map) constant, key);
- }else{
- internalFailure("Not implemented!", "InterpreterIndexOf.java", null);
- }
- stackframe.setRegister(code.target(), value);
- printMessage(stackframe, code.toString(), "%"+ code.target() + "("+value+")");
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/IndirectInvokeInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/IndirectInvokeInterpreter.java
deleted file mode 100644
index b617b57bd9..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/IndirectInvokeInterpreter.java
+++ /dev/null
@@ -1,114 +0,0 @@
-package wyopcl.util.interpreter;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import wyil.lang.Code.Block;
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Closure;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-import wyopcl.util.Utility;
-/**
- * Interprets Codes.IndirectInvoke
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.IndirectInvoke
- *
- */
-public class IndirectInvokeInterpreter extends Interpreter {
-
- private static IndirectInvokeInterpreter instance;
-
- private IndirectInvokeInterpreter() {}
-
- /* Implement the Singleton pattern to ensure this class has one instance. */
- public static IndirectInvokeInterpreter getInstance() {
- if (instance == null) {
- instance = new IndirectInvokeInterpreter();
- }
- return instance;
- }
- /**
- * Invokes the function
- * @param code
- * @param stackframe
- */
- private void invokeRuntimeFunction(Codes.IndirectInvoke code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- Constant.Lambda lambda = (Constant.Lambda) stackframe.getRegister(code.reference());
- String name = lambda.name.name();
-
- // Create a list of parameters.
- List params = new ArrayList();
- for (int param: code.parameters()) {
- params.add(stackframe.getRegister(param));
- }
-
- String str ="";
- if (name.equalsIgnoreCase("println") || name.equalsIgnoreCase("print")) {
- // Invoke the function
- Utility.invokeJavaPrintFunction(name, code.type().params(), params);
- printMessage(stackframe, code.toString(), str);
- stackframe.setLine(++linenumber);
- params = null;
- } else {
- Block blk = Interpreter.getFuncBlockByName(lambda.name.toString(), code.type());
- StackFrame newStackFrame = Utility.invokeFunction(blk,
- stackframe.getDepth(),
- lambda.name.toString(),
- params,
- code.target());
- // Start invoking a new block.
- blockstack.push(newStackFrame);
- printMessage(stackframe, code.toString(), str);
- }
- }
-
- /**
- * Invokes anonymous function, pass the known and unknown parameters
- * @param code
- * @param stackframe the activated stack frame
- */
- private void invokeAnonymousFunction(Codes.IndirectInvoke code, StackFrame stackframe) {
- // Get the depth
- Closure closure = (Closure) stackframe.getRegister(code.reference());
- String name = closure.lambda.name.module() +":" + closure.lambda.name.name();
- Block blk = Interpreter.getFuncBlockByName(name);
- // Create a new StackFrame
- StackFrame newStackFrame = new StackFrame(stackframe.getDepth() + 1, blk, 0, closure.lambda.name.toString(), code.target());
- // Pass the input parameters.
- int index = 0, unknownParams = 0;
- for (Constant value : closure.params.values) {
- if (value == null) {
- // unknown parameter, so get it from the current stack frame
- newStackFrame.setRegister(index, stackframe.getRegister(code.parameter(unknownParams)));
- unknownParams++;
- } else {
- // known parameter, so copy it into the new stack frame
- newStackFrame.setRegister(index, value);
- }
- index++;
- }
-
- // Pushes the stack frame of anonymous function to the stack.
- blockstack.push(newStackFrame);
- printMessage(stackframe, code.toString(),
- "%" + code.target() + "(" + stackframe.getRegister(code.target()) + ")\n");
- }
-
- /**
- * Invokes anonymous or runtime function.
- * @param code
- * @param stackframe
- */
- public void interpret(Codes.IndirectInvoke code, StackFrame stackframe) {
- Constant func = stackframe.getRegister(code.reference());
- if (func instanceof Closure) {
- invokeAnonymousFunction(code, stackframe);
- } else {
- invokeRuntimeFunction(code, stackframe);
- }
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/InvertInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/InvertInterpreter.java
deleted file mode 100644
index fa4e871819..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/InvertInterpreter.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package wyopcl.util.interpreter;
-
-import static wycc.lang.SyntaxError.internalFailure;
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.Invert
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Invert
- */
-public class InvertInterpreter extends Interpreter {
- private static InvertInterpreter instance;
-
- private InvertInterpreter() {}
-
- /* Implement the Singleton pattern to ensure this class has one instance. */
- public static InvertInterpreter getInstance() {
- if (instance == null) {
- instance = new InvertInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.Invert code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- Constant constant = stackframe.getRegister(code.operand(0));
- Constant result = null;
- if(constant instanceof Constant.Byte){
- //perform bitwise not operation.
- byte inv =(byte) ~((Constant.Byte)constant).value;
- result = Constant.V_BYTE(inv);
-
- }else{
- internalFailure("Not implemented!", "InvertInterpreter.java", null);
- return;
- }
- stackframe.setRegister(code.target(), result);;
-
- printMessage(stackframe, code.toString(), "%"+code.target()+"("+result+")");
- stackframe.setLine(++linenumber);
- }
-
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/InvokeInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/InvokeInterpreter.java
deleted file mode 100644
index c3e34e8603..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/InvokeInterpreter.java
+++ /dev/null
@@ -1,182 +0,0 @@
-package wyopcl.util.interpreter;
-
-import static wycc.lang.SyntaxError.internalFailure;
-
-import java.lang.reflect.Method;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import wycc.lang.NameID;
-import wyil.lang.Code.Block;
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyil.lang.Type;
-import wyjc.runtime.WyList;
-import wyjc.runtime.WyRat;
-import wyjc.runtime.WyRecord;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-import wyopcl.util.Utility;
-/**
- * Interprets Codes.Invoke
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Invoke
- *
- */
-public class InvokeInterpreter extends Interpreter {
-
- private static InvokeInterpreter instance;
- private InvokeInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static InvokeInterpreter getInstance(){
- if (instance == null){
- instance = new InvokeInterpreter();
- }
- return instance;
- }
-
- /***
- * Convert the Java object to the object of given Constant type.
- * @param obj an Java object
- * @param toType the given Constant type
- * @return the Constant object of the specified type.
- */
- private Constant convertJavaObjectToConstant(NameID nameID, Object obj, wyil.lang.Type toType) {
- if (toType instanceof Type.Strung) {
- if (obj instanceof BigDecimal) {
- return Constant.V_STRING(((BigDecimal) obj).toPlainString());
- }
- //trim the beginning and ending quotes.
- return Constant.V_STRING(obj.toString().replaceAll("^\"|\"$", ""));
- }
-
- if (toType instanceof Type.Int) {
- if(obj instanceof WyRat){
- return Constant.V_INTEGER(((WyRat)obj).numerator());
- }
- return Constant.V_INTEGER((BigInteger) obj);
- }
-
- if (toType instanceof Type.Bool){
- return Constant.V_BOOL((Boolean)obj);
- }
-
- if (toType instanceof Type.Byte) {
- if(obj instanceof WyList){
- return Constant.V_BYTE(new Byte((Byte) ((WyList) obj).get(0)));
- }
- return Constant.V_BYTE(new Byte((Byte) obj));
- }
-
- if (toType instanceof Type.List){
- Collection values = new ArrayList();
- WyList wylist = (WyList)obj;
- for(Object wyObj : wylist){
- Type elemType = ((Type.List)toType).element();
- values.add(convertJavaObjectToConstant(nameID, wyObj, elemType));
- }
- return Constant.V_LIST(values);
- }
-
- if(toType instanceof Type.Record){
- Type.Record recordType = (Type.Record)toType;
- WyRecord wyrecord = (WyRecord)obj;
- Map values = new HashMap();
- for(String field: wyrecord.keySet()){
- Type fieldType = recordType.field(field);
- Object value = wyrecord.get(field);
- values.put(field, convertJavaObjectToConstant(nameID, value, fieldType));
- }
- return Constant.V_RECORD(values);
- }
-
- //Convert a Java obj to a constant method.
- //But Constant class does not have the constructor for method.
- //This method is not yet complete and essential for executing 001_avg benchmark program.
- if(toType instanceof Type.Method){
- Type.Method methodType = (Type.Method)toType;
- return Constant.V_LAMBDA(nameID, methodType);
- }
-
- internalFailure("Not implemented!", "InvokeInterpreter.java", null);
- return null;
-
- }
-
-
- /**
- * Directly invoke the function/method from Whiley runtime library
- * @param code
- * @param stackframe
- */
- private void invokeRuntimeFunction(Codes.Invoke code, StackFrame stackframe, List params){
- int linenumber = stackframe.getLine();
-
-
- //Directly invoke the function/method.
- try {
- //Load the Class
- Object obj = Utility.invokeWhileyRuntimeFucntion(this.getClass().getClassLoader(),
- code.name.module().toString().replace('/', '.'),
- code.name.name(),
- code.type().params(),
- params);
- // returned_obj into Constant.
- Constant result = convertJavaObjectToConstant(code.name, obj, code.assignedType());
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(),"%"+code.target()+"("+result+")");
- stackframe.setLine(++linenumber);
- } catch (Exception e) {
- //Pop up the current block
- if(blockstack.size() > 1){
- blockstack.pop();
- }
- //Return to the caller
- StackFrame caller = blockstack.peek();
- linenumber = symboltable.getCatchPos(caller.getBlock());
- caller.setLine(linenumber);
- }
-
-
- }
-
-
-
- /**
- * Invokes either the function or the Whiley runtime function.
- * @param code
- * @param stackframe
- */
- public void interpret(Codes.Invoke code, StackFrame stackframe) {
-
- //Find the right block
- Block blk = Interpreter.getFuncBlockByName(code.name.toString(), code.type());
- // Create a list of parameters.
- List params = new ArrayList();
- for (int operand: code.operands()) {
- params.add(stackframe.getRegister(operand));
- }
-
- if (blk != null){
- StackFrame newStackFrame = Utility.invokeFunction(blk,
- stackframe.getDepth(),
- code.name.name(),
- params,
- code.target());
- //Push the function block to the stack
- blockstack.push(newStackFrame);
- printMessage(stackframe, code.toString(),"");
- }else{
- invokeRuntimeFunction(code, stackframe, params);
- }
-
- params = null;
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/LabelInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/LabelInterpreter.java
deleted file mode 100644
index 528c741f77..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/LabelInterpreter.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package wyopcl.util.interpreter;
-
-import wyil.lang.Codes;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.Label
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Label
- *
- */
-public class LabelInterpreter extends Interpreter {
- private static LabelInterpreter instance;
- private LabelInterpreter(){ }
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static LabelInterpreter getInstance(){
- if (instance == null){
- instance = new LabelInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.Label code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- printMessage(stackframe, code.toString(), "("+code.label+")");
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/LambdaInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/LambdaInterpreter.java
deleted file mode 100644
index cbe22c4a86..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/LambdaInterpreter.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package wyopcl.util.interpreter;
-
-import java.util.ArrayList;
-import java.util.Collection;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Closure;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.Lambda
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Lambda
- *
- */
-public class LambdaInterpreter extends Interpreter {
- private static LambdaInterpreter instance;
-
- private LambdaInterpreter() {}
-
- /* Implement the Singleton pattern to ensure this class has one instance. */
- public static LambdaInterpreter getInstance() {
- if (instance == null) {
- instance = new LambdaInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.Lambda code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- //Create a list of parameters.
- Collection parameters = new ArrayList();
- for(int operand: code.operands()){
- if(operand <0){
- parameters.add(null);
- }else{
- parameters.add(stackframe.getRegister(operand));
- }
- }
- //Check if the extra local parameters need adding.
- int size = parameters.size();
- if(code.type().params() != null){
- int params_size = code.type().params().size();
- while (sizeCodes.LengthOf
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.LengthOf
- *
- */
-public class LengthOfInterpreter extends Interpreter{
- private static LengthOfInterpreter instance;
- private LengthOfInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static LengthOfInterpreter getInstance(){
- if (instance == null){
- instance = new LengthOfInterpreter();
- }
- return instance;
- }
-
-
- public void interpret(Codes.LengthOf code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
-
- //Read a effective collection (list, set or map) from the operand register.
- Constant collection = stackframe.getRegister(code.operand(0));
- int length = 0;
- Constant result = null;
- if(collection instanceof Constant.List){
- //Cast the collection to a List.
- length = ((Constant.List)collection).values.size();
- result = Constant.V_INTEGER(BigInteger.valueOf(length));
- }else if (collection instanceof Constant.Record){
- length = ((Constant.Record)collection).values.size();
- result = Constant.V_INTEGER(BigInteger.valueOf(length));
- }else if (collection instanceof Constant.Strung){
- length = ((Constant.Strung)collection).value.length();
- result = Constant.V_INTEGER(BigInteger.valueOf(length));
- }else if(collection instanceof Constant.Set){
- length = ((Constant.Set)collection).values.size();
- result = Constant.V_INTEGER(BigInteger.valueOf(length));
- }else if(collection instanceof Constant.Map){
- length = ((Constant.Map)collection).values.size();
- result = Constant.V_INTEGER(BigInteger.valueOf(length));
- }else if (collection instanceof Constant.Null){
- result = collection;
- } else{
- internalFailure("Not implemented!", "InterpreterLengthOf.java", null);
- }
-
- //Write the length to register.
- //Constant result = Constant.V_INTEGER(BigInteger.valueOf(length));
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(), "%"+ code.target() + "("+result+")");
- stackframe.setLine(++linenumber);
- }
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/ListOperatorInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/ListOperatorInterpreter.java
deleted file mode 100644
index d5a023efbf..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/ListOperatorInterpreter.java
+++ /dev/null
@@ -1,90 +0,0 @@
-package wyopcl.util.interpreter;
-
-import static wycc.lang.SyntaxError.internalFailure;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyil.lang.Constant.List;
-import wyil.lang.Type;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.ListOperator
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.ListOperator
- *
- */
-public class ListOperatorInterpreter extends Interpreter{
- private static ListOperatorInterpreter instance;
- private ListOperatorInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static ListOperatorInterpreter getInstance(){
- if (instance == null){
- instance = new ListOperatorInterpreter();
- }
- return instance;
- }
- /**
- * Recursively check if a Constant.List contains any element.
- * @param list
- * @param type
- * @return false if the list contains elements. Return true if the list has no elements.
- */
- private boolean checkEmpty(Constant.List list){
- for(Constant elem: list.values){
- if(elem instanceof Constant.List){
- return checkEmpty((Constant.List)elem);
- }
- }
-
- if(!list.values.isEmpty()){
- return false;
- }
-
- return true;
- }
-
-
-
- public void interpret(Codes.ListOperator code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- //Read the list from two operands.
- Constant.List left = (Constant.List) stackframe.getRegister(code.operand(0));
- Constant.List right = (Constant.List) stackframe.getRegister(code.operand(1));
- //Perform the list operation (e.g. append two lists)
- Constant.List result = null;
- switch(code.kind){
- case APPEND:
- //Create a new array list to append the left and right list.
- ArrayList values = new ArrayList();
- //Type elementType = code.type().element();
- //Check the left is empty. If so, then do not add to the new list.
- if(!checkEmpty(left)){
- values.addAll(left.values);
- }
- values.addAll(right.values);
- result = Constant.V_LIST(values);
- break;
- case LEFT_APPEND:
- left.values.addAll(right.values);
- result = Constant.V_LIST(left.values);
- break;
- case RIGHT_APPEND:
- right.values.addAll(left.values);
- result = Constant.V_LIST(right.values);
- break;
- default:
- internalFailure("Not implemented!", "ListOperatorInterpreter.java", null);
- break;
- }
- //Set the result to the target register.
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(), "%"+ code.target() + "("+result+")\n");
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/LoopEndInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/LoopEndInterpreter.java
deleted file mode 100644
index bf94350c07..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/LoopEndInterpreter.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package wyopcl.util.interpreter;
-import wyil.lang.Code;
-import wyil.lang.Codes;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-
-/**
- * Interprets Codes.LoopEnd
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.LoopEnd
- *
- */
-public class LoopEndInterpreter extends Interpreter {
- private static LoopEndInterpreter instance;
- private LoopEndInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static LoopEndInterpreter getInstance(){
- if (instance == null){
- instance = new LoopEndInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.LoopEnd code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- printMessage(stackframe, code.toString(), "("+code.label+")");
- Code.Block block = stackframe.getBlock();
- linenumber = symboltable.getBlockPosByLabel(block, code.label);
- stackframe.setLine(linenumber);
- }
-
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/LoopInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/LoopInterpreter.java
deleted file mode 100644
index 2db436a841..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/LoopInterpreter.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package wyopcl.util.interpreter;
-
-import wyil.lang.Codes;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.Loop
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Loop
- *
- */
-public class LoopInterpreter extends Interpreter {
- private static LoopInterpreter instance;
- private LoopInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static LoopInterpreter getInstance(){
- if (instance == null){
- instance = new LoopInterpreter();
- }
- return instance;
- }
-
- /**
- * Prints out the bytecode without any further action.
- * @param code
- * @param stackframe
- */
- public void interpret(Codes.Loop code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- printMessage(stackframe, code.toString(), "("+code.target+")");
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/NewListInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/NewListInterpreter.java
deleted file mode 100644
index 1ab601b1c5..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/NewListInterpreter.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package wyopcl.util.interpreter;
-
-import java.util.ArrayList;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.NewList
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.NewList
- *
- */
-public class NewListInterpreter extends Interpreter {
- private static NewListInterpreter instance;
- private NewListInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static NewListInterpreter getInstance(){
- if (instance == null){
- instance = new NewListInterpreter();
- }
- return instance;
- }
-
-
- public void interpret(Codes.NewList code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- ArrayList values = new ArrayList();
- for (int operand : code.operands()) {
- Constant elem = stackframe.getRegister(operand);
- values.add(elem);
- }
- Constant.List result = Constant.V_LIST(values);
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(), "%"+ code.target() + "("+result+")");
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/NewMapInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/NewMapInterpreter.java
deleted file mode 100644
index f6958cc9ae..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/NewMapInterpreter.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package wyopcl.util.interpreter;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.NewMap
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.NewMap
- *
- */
-public class NewMapInterpreter extends Interpreter {
- private static NewMapInterpreter instance;
- private NewMapInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static NewMapInterpreter getInstance(){
- if (instance == null){
- instance = new NewMapInterpreter();
- }
- return instance;
- }
-
- /**
- * Creates a new Constant Map using the operands from Codes.NewMap
code.
- * @param code the Codes.NewMap
- * @param stackframe the activated stack frame.
- */
- public void interpret(Codes.NewMap code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- //Create a Hashmap with the key and values from operand registers.
- Map values = new HashMap();
- for(int i = 0; i< code.operands().length; i+=2){
- Constant key = stackframe.getRegister(code.operand(i));
- Constant value = stackframe.getRegister(code.operand(i+1));
- values.put(key, value);
- }
- Constant.Map result = Constant.V_MAP(values);
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(), "%"+ code.target() + "("+result+")");
- stackframe.setLine(++linenumber);
-
- }
-
-
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/NewObjectInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/NewObjectInterpreter.java
deleted file mode 100644
index b914ae8e46..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/NewObjectInterpreter.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package wyopcl.util.interpreter;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.NewObject
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.NewObject
- *
- */
-public class NewObjectInterpreter extends Interpreter {
- private static NewObjectInterpreter instance;
- private NewObjectInterpreter(){ }
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static NewObjectInterpreter getInstance(){
- if (instance == null){
- instance = new NewObjectInterpreter();
- }
- return instance;
- }
-
-
- public void interpret(Codes.NewObject code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- //Reference type = code.type();
- //Get the value from the operand register.
- Constant value = stackframe.getRegister(code.operand(0));
- //Create a reference to the value.
- Constant result = value;
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(),"%"+code.target()+"("+result+")");
- stackframe.setLine(++linenumber);
- }
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/NewRecordInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/NewRecordInterpreter.java
deleted file mode 100644
index 74894d8520..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/NewRecordInterpreter.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package wyopcl.util.interpreter;
-
-import java.util.Iterator;
-import java.util.Map;
-import java.util.TreeMap;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyil.lang.Type;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.NewRecord
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.NewRecord
- *
- */
-public class NewRecordInterpreter extends Interpreter{
-
- private static NewRecordInterpreter instance;
- private NewRecordInterpreter(){ }
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static NewRecordInterpreter getInstance(){
- if (instance == null){
- instance = new NewRecordInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.NewRecord code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- //Use the LinkedHashMap to create the records.
- Map values = new TreeMap();
- //Get the field names and types.
- Map fields = new TreeMap(code.type().fields());
- Iterator iterator = fields.keySet().iterator();
- int index = 0;
- //Assign the field value in accordance with the sequence of field names.
- while(iterator.hasNext()){
- String key = iterator.next();
- Constant value = stackframe.getRegister(code.operand(index));
- values.put(key, value);
- index++;
- }
- //Construct the Record value
- Constant.Record result = Constant.V_RECORD(values);
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(),"%"+code.target()+"("+result+")");
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/NewSetInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/NewSetInterpreter.java
deleted file mode 100644
index 5bbead12b4..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/NewSetInterpreter.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package wyopcl.util.interpreter;
-
-import java.util.LinkedHashSet;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.NewSet
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.NewSet
- *
- */
-public class NewSetInterpreter extends Interpreter {
- private static NewSetInterpreter instance;
- private NewSetInterpreter(){ }
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static NewSetInterpreter getInstance(){
- if (instance == null){
- instance = new NewSetInterpreter();
- }
- return instance;
- }
-
-
- public void interpret(Codes.NewSet code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- LinkedHashSet values = new LinkedHashSet();
-
- for(int operand:code.operands()){
- Constant value = stackframe.getRegister(operand);
- values.add(value);
- }
- //The ordering is not preserved.
- Constant.Set result = Constant.V_SET(values);
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(),"%"+code.target()+"("+result+")");
- stackframe.setLine(++linenumber);
- }
-
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/NewTupleInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/NewTupleInterpreter.java
deleted file mode 100644
index 5ee0ea8e2c..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/NewTupleInterpreter.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package wyopcl.util.interpreter;
-
-import java.util.ArrayList;
-import java.util.Collection;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyil.lang.Constant.Tuple;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.NewTuple
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.NewTuple
- *
- */
-public class NewTupleInterpreter extends Interpreter{
- private static NewTupleInterpreter instance;
- private NewTupleInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static NewTupleInterpreter getInstance(){
- if (instance == null){
- instance = new NewTupleInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.NewTuple code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- //Construct a new tuple from one or more operand registers.
- Collection values = new ArrayList();
- for(int oprand : code.operands()){
- values.add(stackframe.getRegister(oprand));
- }
- //Write the tuple to the target register.
- Tuple result = Constant.V_TUPLE(values);
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(),"%"+code.target()+"="+result);
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/NopInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/NopInterpreter.java
deleted file mode 100644
index 464c7d5bf0..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/NopInterpreter.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package wyopcl.util.interpreter;
-
-import wyil.lang.Codes;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.Nop
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Nop
- *
- */
-public class NopInterpreter extends Interpreter {
- private static NopInterpreter instance;
- private NopInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static NopInterpreter getInstance(){
- if (instance == null){
- instance = new NopInterpreter();
- }
- return instance;
- }
-
-
- public void interpret(Codes.Nop code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- printMessage(stackframe, code.toString(),"");
- stackframe.setLine(++linenumber);
- }
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/ReturnInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/ReturnInterpreter.java
deleted file mode 100644
index af5200713a..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/ReturnInterpreter.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package wyopcl.util.interpreter;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyil.lang.Type;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.Return
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Return
- *
- */
-public class ReturnInterpreter extends Interpreter {
- private static ReturnInterpreter instance;
- private ReturnInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static ReturnInterpreter getInstance(){
- if (instance == null){
- instance = new ReturnInterpreter();
- }
- return instance;
- }
-
-
- public void interpret(Codes.Return code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- int return_reg = stackframe.getReturn_reg();
- blockstack.pop();
- //Get the previous block
-
- if(!blockstack.isEmpty()){
- StackFrame caller = blockstack.peek();
- linenumber = caller.getLine();
- //Check if the results are returned.
- if (code.type != Type.T_VOID) {
- //Read the values from the operand register.
- Constant return_value = stackframe.getRegister(code.operand);
- printMessage(stackframe, code.toString(),
- "%"+return_reg + "("+return_value+")");
- //Return the result by updating the register.
- caller.setRegister(return_reg, return_value);
- }else{
- printMessage(caller, code.toString(), "");
- }
- caller.setLine(++linenumber);
- }else{
- //Do nothing since the code is completed.
- }
-
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/SetOperatorInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/SetOperatorInterpreter.java
deleted file mode 100644
index 5138c18b25..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/SetOperatorInterpreter.java
+++ /dev/null
@@ -1,76 +0,0 @@
-package wyopcl.util.interpreter;
-
-import static wycc.lang.SyntaxError.internalFailure;
-
-import java.util.Collection;
-import java.util.LinkedHashSet;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.SetOperator
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.SetOperator
- *
- */
-public class SetOperatorInterpreter extends Interpreter{
- private static SetOperatorInterpreter instance;
- private SetOperatorInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static SetOperatorInterpreter getInstance(){
- if (instance == null){
- instance = new SetOperatorInterpreter();
- }
- return instance;
- }
-
-
- public void interpret(Codes.SetOperator code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
-
- //Read two set values
- Constant left = stackframe.getRegister(code.operand(0));
- Constant right = stackframe.getRegister(code.operand(1));
-
- //Perform the operation
- Constant result = null;
- Constant.Set lhs = null, rhs=null;
- switch(code.kind){
- case UNION:
- lhs = (Constant.Set)left;
- rhs = (Constant.Set)right;
- result = lhs.union(rhs);
- break;
- case LEFT_UNION:
- lhs = (Constant.Set)left;
- Collection list = new LinkedHashSet();
- list.add(right);
- result = lhs.union(Constant.V_SET(list));
- break;
- case RIGHT_UNION:
- internalFailure("Not implemented!", "InterpreterSetOperator.java", null);
- break;
- case INTERSECTION:
- lhs = (Constant.Set)left;
- rhs = (Constant.Set)right;
- result = lhs.intersect(rhs);
- break;
- case DIFFERENCE:
- lhs = (Constant.Set)left;
- rhs = (Constant.Set)right;
- result = lhs.difference(rhs);
- break;
- default:
- internalFailure("Not implemented!", "InterpreterSetOperator.java", null);
- break;
- }
- //Write the result to target register.
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(),"%"+code.target()+"("+result+")");
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/StringOperatorInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/StringOperatorInterpreter.java
deleted file mode 100644
index 81ff95a177..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/StringOperatorInterpreter.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package wyopcl.util.interpreter;
-
-import static wycc.lang.SyntaxError.internalFailure;
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.StringOperator
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.StringOperator
- *
- */
-public class StringOperatorInterpreter extends Interpreter {
- private static StringOperatorInterpreter instance;
- private StringOperatorInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static StringOperatorInterpreter getInstance(){
- if (instance == null){
- instance = new StringOperatorInterpreter();
- }
- return instance;
- }
- /**
- * Appends a given char or string to the existing string.
- *
- * @param op the type of appending
- * @param left the existing string
- * @param right the given char or string
- * @return the padded string
- */
- private Constant.Strung performStringOperation(Codes.StringOperatorKind op, Constant.Strung left, Constant right){
- //Check the operator
- switch (op){
- case APPEND:
- //Check the type of right operand before appending those two operands.
- if (right instanceof Constant.Strung){
- return Constant.V_STRING(left.value + ((Constant.Strung)right).value);
- }
- break;
- case LEFT_APPEND:
- if(right instanceof Constant.Char){
- return Constant.V_STRING(left.value + ((Constant.Char)right).value);
- }
- break;
- case RIGHT_APPEND:
- if(right instanceof Constant.Char){
- return Constant.V_STRING(((Constant.Char)right).value + left.value);
- }
- default:
- break;
- }
- internalFailure("Not implemented!", "InterpreterStringOperator.java", null);
- return null;
- }
-
- /**
- * Appends a string or char to the existing string.
- * @param code
- * @param stackframe
- */
- public void interpret(Codes.StringOperator code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- //Read two string from the operands
- Constant.Strung result =
- performStringOperation(code.kind,
- (Constant.Strung)stackframe.getRegister(code.operand(0)),
- stackframe.getRegister(code.operand(1)));
- //Write the result to the target register.
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(),"%"+code.target()+"("+result+")");
- stackframe.setLine(++linenumber);
- }
-
-
-
-
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/SubListInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/SubListInterpreter.java
deleted file mode 100644
index 4721766f1a..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/SubListInterpreter.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package wyopcl.util.interpreter;
-
-import java.util.List;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.SubList
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.SubList
- *
- */
-public class SubListInterpreter extends Interpreter{
- private static SubListInterpreter instance;
- private SubListInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static SubListInterpreter getInstance(){
- if (instance == null){
- instance = new SubListInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.SubList code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
-
- //Get the list from the operand register (index=0).
- Constant.List list = (Constant.List)stackframe.getRegister(code.operand(0));
- //Get two index operands (index=1 or index=2).
- Constant.Integer fromIndex = (Constant.Integer)stackframe.getRegister(code.operand(1));
- Constant.Integer toIndex = (Constant.Integer)stackframe.getRegister(code.operand(2));
- //Computes the sublist from index1 to index2.
- List sublist = list.values.subList(fromIndex.value.intValue(), toIndex.value.intValue());
- //Write the result to the target register.
- Constant result = Constant.V_LIST(sublist);
- stackframe.setRegister(code.target(), result);
-
- printMessage(stackframe, code.toString(),
- "%"+code.target() + "("+result+")");
-
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/SubStringInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/SubStringInterpreter.java
deleted file mode 100644
index 57f9079db6..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/SubStringInterpreter.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package wyopcl.util.interpreter;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.SubString
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.SubString
- *
- */
-public class SubStringInterpreter extends Interpreter {
- private static SubStringInterpreter instance;
- private SubStringInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static SubStringInterpreter getInstance(){
- if (instance == null){
- instance = new SubStringInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.SubString code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- Constant result = null;
- Constant.Strung source = (Constant.Strung)stackframe.getRegister(code.operand(0));
- Constant.Integer beginIndex = (Constant.Integer)stackframe.getRegister(code.operand(1));
- Constant.Integer endIndex = (Constant.Integer)stackframe.getRegister(code.operand(2));
-
- String substring = source.value.substring(beginIndex.value.intValue(), endIndex.value.intValue());
- result = Constant.V_STRING(substring);
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(), "%"+code.target() + "("+result+")");
- stackframe.setLine(++linenumber);
- }
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/SwitchInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/SwitchInterpreter.java
deleted file mode 100644
index bcc4a21e77..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/SwitchInterpreter.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package wyopcl.util.interpreter;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-
-import wycc.util.Pair;
-import wyil.lang.Code.Block;
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.Switch
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Switch
- *
- */
-public class SwitchInterpreter extends Interpreter {
- private static SwitchInterpreter instance;
-
- private SwitchInterpreter() {}
-
- /* Implement the Singleton pattern to ensure this class has one instance. */
- public static SwitchInterpreter getInstance() {
- if (instance == null) {
- instance = new SwitchInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.Switch code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- Block block = stackframe.getBlock();
- Constant value = stackframe.getRegister(code.operand);
- ArrayList> branches = code.branches;
- Iterator> iterator = branches.iterator();
- boolean isMatched = false;
- while(iterator.hasNext()){
- Pair next = iterator.next();
- //Check if the value matches the key
- if(next.first().equals(value)){
- //Go to the label
- String label = next.second();
- linenumber = symboltable.getBlockPosByLabel(block, label);
- isMatched = true;
- break;
- }
- }
-
- //If not matched, go to default
- if(!isMatched){
- linenumber = symboltable.getBlockPosByLabel(block, code.defaultTarget);
- }
-
- printMessage(stackframe, code.toString(), "%" + code.operand + "(" + value + ")");
- stackframe.setLine(linenumber);
-
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/ThrowInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/ThrowInterpreter.java
deleted file mode 100644
index e1a021a151..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/ThrowInterpreter.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package wyopcl.util.interpreter;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.Throw
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Throw
- *
- */
-public class ThrowInterpreter extends Interpreter {
- private static ThrowInterpreter instance;
- private ThrowInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static ThrowInterpreter getInstance(){
- if (instance == null){
- instance = new ThrowInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.Throw code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- Constant result = stackframe.getRegister(code.operand);
- //Pop up the current block
- if(blockstack.size() > 1){
- blockstack.pop();
- }
- //Return to the caller
- StackFrame caller = blockstack.peek();
- //Put the result to the caller's register table at index of 1.
- caller.setRegister(1, result);
- linenumber = symboltable.getCatchPos(caller.getBlock());
- caller.setLine(linenumber);
- printMessage(stackframe, code.toString(),"%"+code.operand+"="+result);
- }
-
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/TryCatchInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/TryCatchInterpreter.java
deleted file mode 100644
index 630a3d77e8..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/TryCatchInterpreter.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package wyopcl.util.interpreter;
-
-import wyil.lang.Codes;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.TryCatch
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.TryCatch
- *
- */
-public class TryCatchInterpreter extends Interpreter{
- private static TryCatchInterpreter instance;
- public TryCatchInterpreter(){
- }
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static TryCatchInterpreter getInstance(){
- if (instance == null){
- instance = new TryCatchInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.TryCatch code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- printMessage(stackframe, code.toString(),"");
- stackframe.setLine(++linenumber);
-
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/TupleLoadInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/TupleLoadInterpreter.java
deleted file mode 100644
index ecbfda9a09..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/TupleLoadInterpreter.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package wyopcl.util.interpreter;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-/**
- * Interprets Codes.TupleLoad
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.TupleLoad
- *
- */
-public class TupleLoadInterpreter extends Interpreter{
- private static TupleLoadInterpreter instance;
- private TupleLoadInterpreter(){ }
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static TupleLoadInterpreter getInstance(){
- if (instance == null){
- instance = new TupleLoadInterpreter();
- }
- return instance;
- }
-
- public void interpret(Codes.TupleLoad code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- //Read the tuple from the operand register.
- Constant.Tuple tuple = (Constant.Tuple)stackframe.getRegister(code.operand(0));
- //Write the tuple
- Constant result = tuple.values.get(code.index);
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(), "%"+code.target()+"="+result);
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/UnaryOperatorInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/UnaryOperatorInterpreter.java
deleted file mode 100644
index 5f1d81af28..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/UnaryOperatorInterpreter.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package wyopcl.util.interpreter;
-
-import static wycc.lang.SyntaxError.internalFailure;
-import wyil.lang.Codes;
-import wyil.lang.Codes.UnaryOperatorKind;
-import wyil.lang.Constant;
-import wyopcl.util.DecimalFraction;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-
-/**
- * Interprets Codes.UnaryOperator
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.UnaryOperator
- *
- */
-public class UnaryOperatorInterpreter extends Interpreter {
- private static UnaryOperatorInterpreter instance;
- private UnaryOperatorInterpreter(){}
-
- /*Implement the Singleton pattern to ensure this class has one instance.*/
- public static UnaryOperatorInterpreter getInstance(){
- if (instance == null){
- instance = new UnaryOperatorInterpreter();
- }
- return instance;
- }
-
- private Constant performArithmetic(UnaryOperatorKind kind, Constant number){
- if(number instanceof Constant.Integer){
- Constant.Integer integer = (Constant.Integer)number;
- switch(kind){
- case NEG:
- return Constant.V_INTEGER(integer.value.negate());
- case NUMERATOR:
- internalFailure("Not implemented!", "UnaryOperatorInterpreter.java", null);
- return null;
- case DENOMINATOR:
- internalFailure("Not implemented!", "UnaryOperatorInterpreter.java", null);
- return null;
- default:
- internalFailure("Not implemented!", "UnaryOperatorInterpreter.java", null);
- return null;
- }
- }else if(number instanceof Constant.Decimal){
- Constant.Decimal decimal = (Constant.Decimal)number;
- switch(kind){
- case NEG:
- return Constant.V_DECIMAL(decimal.value.negate());
- case NUMERATOR:
- return DecimalFraction.V_DecimalFraction(decimal).getNumerator();
- case DENOMINATOR:
- return DecimalFraction.V_DecimalFraction(decimal).getDenominator();
- default:
- internalFailure("Not implemented!", "UnaryOperatorInterpreter.java", null);
- return null;
- }
-
- }else{
- internalFailure("Not implemented!", "UnaryOperatorInterpreter.java", null);
- return null;
- }
- }
-
- public void interpret(Codes.UnaryOperator code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- Constant result = null;
- Constant number = stackframe.getRegister(code.operand(0));
- result = performArithmetic(code.kind, number);
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(), "%"+code.target() + "("+result+")");
- stackframe.setLine(++linenumber);
-
-
- }
-
-}
diff --git a/modules/wyopcl/src/wyopcl/util/interpreter/UpdateInterpreter.java b/modules/wyopcl/src/wyopcl/util/interpreter/UpdateInterpreter.java
deleted file mode 100644
index 24cb7b50b2..0000000000
--- a/modules/wyopcl/src/wyopcl/util/interpreter/UpdateInterpreter.java
+++ /dev/null
@@ -1,226 +0,0 @@
-package wyopcl.util.interpreter;
-
-import static wycc.lang.SyntaxError.internalFailure;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-
-import wyil.lang.Codes;
-import wyil.lang.Constant;
-import wyil.lang.Type;
-import wyopcl.util.Interpreter;
-import wyopcl.util.StackFrame;
-import wyopcl.util.Utility;
-/**
- * Interprets Codes.Update
bytecode.
- * @author Min-Hsien Weng
- * @see wyil.lang.Codes.Update
- *
- */
-public class UpdateInterpreter extends Interpreter {
- private static UpdateInterpreter instance;
-
- private UpdateInterpreter() {}
-
- /* Implement the Singleton pattern to ensure this class has one instance. */
- public static UpdateInterpreter getInstance() {
- if (instance == null) {
- instance = new UpdateInterpreter();
- }
- return instance;
- }
-
- private Constant.List update(Constant.List list, Constant givenValue, int updateIndex) {
- // Deeply copy and clone the values in the original Constant.List.
- ArrayList values = new ArrayList(list.values.size());
- Iterator iterator = list.values.iterator();
- while(iterator.hasNext()){
- Constant constant = iterator.next();
- values.add(Utility.copyConstant(constant));
- }
-
- if (values.size() <=updateIndex) {
- values.add(givenValue);
- } else {
- values.set(updateIndex, givenValue);
- }
-
- return Constant.V_LIST(values);
-
- }
-
- private Constant.Record update(Constant.Record record, Constant givenValue, String field){
- HashMap values = new HashMap(record.values);
- values.put(field, givenValue);
- return Constant.V_RECORD(values);
- }
-
- private Constant.Map update(Constant.Map map, Constant key, Constant Value){
- HashMap values = new HashMap(map.values);
- values.put(key, Value);
- return Constant.V_MAP(values);
- }
- /**
- * Gets the given value and updates the list with given value at the given position.
- * If the element is a list or record, then update its sublist w
- *
- * @param code
- * @param stackframe
- * @param list the list
- * @param givenValue the given value
- * @return the updated list
- */
- private Constant.List updateList(StackFrame stackframe, Constant.List list, Constant givenValue, int[] keys, String... field) {
- // Get the index
- int index = ((Constant.Integer) stackframe.getRegister(keys[0])).value.intValue();
- Constant element = list.values.get(index);
- //Check if the element is a compound data set.
- if (element instanceof Constant.List) {
- if(keys.length==2){
- //Get the subIndex
- int subindex = ((Constant.Integer) stackframe.getRegister(keys[1])).value.intValue();
- givenValue = update((Constant.List)element, givenValue, subindex);
- }
- }
-
- if(element instanceof Constant.Record){
- //Update the record with given value at the given field.
- givenValue = update((Constant.Record)element, givenValue, field[0]);
- }
-
- //Update the list with the given value at the index position.
- return update(list, givenValue, index);
- }
- /**
- * Gets
- * @param code
- * @param stackframe
- * @return
- */
- private Constant.Record updateRecord(Codes.Update code, StackFrame stackframe, Constant.Record record, Constant givenValue) {
- HashMap values = new HashMap(record.values);
- String[] fields = code.fields.toArray(new String[code.fields.size()]);
- //String field = fields[0];
-
- // Get the field value
- Constant fieldValue = values.get(fields[0]);
- if (fieldValue instanceof Constant.List) {
- Constant.List list = (Constant.List) fieldValue;
- //int index = 0;
- //Check if the list is empty. If so, then get the updated index.
- /*Constant key = stackframe.getRegister(code.key(0));
- if(key instanceof Constant.Integer){
- int index = ((Constant.Integer) key).value.intValue();
- //Update the list with the given value.
- givenValue = update(list, givenValue, index);
- }*/
- }
-
- if (fieldValue instanceof Constant.Record && fields.length == 2){
- //Check if there is another field that requires to update the given value.
- //Do the update for the nested record.
- givenValue = update((Constant.Record)fieldValue, givenValue, fields[1]);
- }
- return update(record, givenValue, fields[0]);
- }
-
- private Constant.Strung updateStrung(Codes.Update code, StackFrame stackframe) {
- Constant.Strung strung = (Constant.Strung) stackframe.getRegister(code.target());
- Constant.Char updatedValue = (Constant.Char) stackframe.getRegister(code.result());
- // Get the index
- Constant.Integer updateIndex = (Constant.Integer) stackframe.getRegister(code.operand(0));
-
- // Replace a char in the strung at the index.
- StringBuilder newStrung = new StringBuilder(strung.value);
- newStrung.setCharAt(updateIndex.value.intValue(), updatedValue.value);
- return Constant.V_STRING(newStrung.toString());
- }
-
-
-
- private Constant.Map updateMap(Codes.Update code, StackFrame stackframe) {
- Constant.Map map = (Constant.Map) stackframe.getRegister(code.target());
- Constant givenValue = stackframe.getRegister(code.result());
- // Get the key
- int[] operands = code.operands();
- Constant key = stackframe.getRegister(operands[0]);
- // Get the existing value
- Constant value = map.values.get(key);
-
- if (value != null && value instanceof Constant.List) {
- //Update the element
- int index = ((Constant.Integer) stackframe.getRegister(operands[1])).value.intValue();
- givenValue = update((Constant.List)value, givenValue, index);
- }
- // Update the map
- return update(map, key, givenValue);
- }
-
- private Constant updateReference(Codes.Update code, StackFrame stackframe) {
- Constant reference = stackframe.getRegister(code.target());
- Constant updatedValue = null;
- Constant givenValue = stackframe.getRegister(code.result());
- if (reference instanceof Constant.Record) {
- Constant.Record record = (Constant.Record)reference;
- HashMap values = record.values;
- String[] fields = code.fields.toArray(new String[code.fields.size()]);
- // Get the field value
- Constant fieldValue = values.get(fields[0]);
- //Update the value
- if(fieldValue != null){
- values.put(fields[0], givenValue);
- }else{
- internalFailure("Not implemented!", "UpdateInterpreter.java", null);
- return null;
- }
- return reference;
- }
-
- if(reference instanceof Constant.Integer){
- updatedValue = (Constant.Integer)reference;
- return updatedValue;
- }
-
- internalFailure("Not implemented!", "UpdateInterpreter.java", null);
- return null;
- }
- /**
- * Update the constant with the given constant.
- * @param code
- * @param stackframe
- */
- public void interpret(Codes.Update code, StackFrame stackframe) {
- int linenumber = stackframe.getLine();
- Constant result = null;
- // Popup the compound type (lists, dictionaries, strings, records and
- // references
- Type afterType = code.afterType;
- Constant givenValue = stackframe.getRegister(code.result());
- if (afterType instanceof Type.List) {
- Constant.List list = (Constant.List) stackframe.getRegister(code.target());
- //Check if there is any given field.
- if(code.fields!=null&& code.fields.size()==1){
- result = updateList(stackframe, list, givenValue, code.keys(), code.fields.get(0));
- }else{
- result = updateList(stackframe, list, givenValue, code.keys());
- }
- } else if (afterType instanceof Type.Record) {
- Constant.Record record = (Constant.Record) stackframe.getRegister(code.target());
- result = updateRecord(code, stackframe, record, givenValue);
- } else if (afterType instanceof Type.Strung) {
- result = updateStrung(code, stackframe);
- } else if (afterType instanceof Type.Map) {
- result = updateMap(code, stackframe);
- } else if (afterType instanceof Type.Reference) {
- result = updateReference(code, stackframe);
- } else {
- internalFailure("Not implemented!", "UpdateInterpreter.java", null);
- }
-
- stackframe.setRegister(code.target(), result);
- printMessage(stackframe, code.toString(), "%" + code.target() + "(" + result + ")");
- stackframe.setLine(++linenumber);
- }
-
-}
diff --git a/modules/wyopcl/test/wyopcl/testing/interpreter/AllInvalidTestCase.java b/modules/wyopcl/test/wyopcl/testing/interpreter/AllInvalidTestCase.java
deleted file mode 100644
index 04d7101539..0000000000
--- a/modules/wyopcl/test/wyopcl/testing/interpreter/AllInvalidTestCase.java
+++ /dev/null
@@ -1,1497 +0,0 @@
-package wyopcl.testing.interpreter;
-
-import static org.junit.Assert.*;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TestRule;
-import org.junit.rules.Timeout;
-
-public class AllInvalidTestCase {
- @Rule
- public TestRule timeout = new Timeout(5000);
- private BaseTestUtil util;
-
- @Before
- public void setUp() throws Exception {
- util = new BaseTestUtil();
- }
-
- @After
- public void tearDown() throws Exception {
- util.terminate();
- util = null;
- }
-
- @Test
- public void test_Assert_Invalid_1() {
- util.exec("Assert_Invalid_1");
- }
-
- @Test
- public void test_Assert_Invalid_2() {
- util.exec("Assert_Invalid_2");
- }
- @Test
- public void test_Assign_Invalid_1() {
- util.exec("Assign_Invalid_1");
- }
-
- @Test
- public void test_Assign_Invalid_2() {
- util.exec("Assign_Invalid_2");
- }
-
- @Test
- public void test_Assign_Invalid_3() {
- util.exec("Assign_Invalid_3");
- }
-
- @Test
- public void test_Assign_Invalid_4() {
- util.exec("Assign_Invalid_4");
- }
- @Test
- public void test_Assign_Invalid_5() {
- util.exec("Assign_Invalid_5");
- }
-
- @Test
- public void test_Assign_Invalid_6() {
- util.exec("Assign_Invalid_6");
- }
-
- @Test
- public void test_Assign_Invalid_7() {
- util.exec("Assign_Invalid_7");
- }
-
- @Test
- public void test_Assign_Invalid_8() {
- util.exec("Assign_Invalid_8");
- }
-
- @Test
- public void test_Assign_Invalid_9() {
- util.exec("Assign_Invalid_9");
- }
-
- @Test
- public void test_Byte_Invalid_1() {
- util.exec("Byte_Invalid_1");
- }
-
-
- @Test
- public void test_Cast_Invalid_1() {
- util.exec("Cast_Invalid_1");
- }
-
- @Test
- public void test_Cast_Invalid_2() {
- util.exec("Cast_Invalid_2");
- }
-
- @Test
- public void test_Cast_Invalid_3() {
- util.exec("Cast_Invalid_3");
- }
-
- @Test
- public void test_Cast_Invalid_4() {
- util.exec("Cast_Invalid_4");
- }
- @Test
- public void test_Char_Invalid_1() {
- util.exec("Char_Invalid_1");
- }
-
-
- @Test
- public void test_Coercion_InInvalid_1() {
- util.exec("Coercion_Invalid_1");
- }
-
- @Test
- public void test_Coercion_Invalid_2() {
- util.exec("Coercion_Invalid_2");
- }
-
- @Test
- @Ignore("unclassified")
- public void test_Constant_Invalid_1() {
- util.exec("Constant_Invalid_1");
- }
-
- @Test
- public void test_Constant_Invalid_2() {
- util.exec("Constant_Invalid_2");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_ConstrainedDictionary_Invalid_1() {
- util.exec("ConstrainedDictionary_Invalid_1");
- }
-
- @Test
- public void test_ConstrainedInt_Invalid_1() {
- util.exec("ConstrainedInt_Invalid_1");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_ConstrainedInt_Invalid_10() {
- util.exec("ConstrainedInt_Invalid_10");
- }
-
- @Ignore("Missing 'ConstrainedInt_Invalid_12.sysout'")
- @Test
- public void test_ConstrainedInt_Invalid_12() {
- util.exec("ConstrainedInt_Invalid_12");
- }
-
-
- @Test
- public void test_ConstrainedInt_Invalid_2() {
- util.exec("ConstrainedInt_Invalid_2");
- }
-
- @Test
- public void test_ConstrainedInt_Invalid_3() {
- util.exec("ConstrainedInt_Invalid_3");
- }
-
- @Test
- public void test_ConstrainedInt_Invalid_4() {
- util.exec("ConstrainedInt_Invalid_4");
- }
-
- @Test
- public void test_ConstrainedInt_Invalid_5() {
- util.exec("ConstrainedInt_Invalid_5");
- }
-
- @Test
- public void test_ConstrainedInt_Invalid_6() {
- util.exec("ConstrainedInt_Invalid_6");
- }
-
- @Test
- public void test_ConstrainedInt_Invalid_8() {
- util.exec("ConstrainedInt_Invalid_8");
- }
-
- @Test
- @Ignore("Timeout")
- public void test_ConstrainedInt_Invalid_9() {
- util.exec("ConstrainedInt_Invalid_9");
- }
-
- @Test
- public void test_ConstrainedList_Invalid_1() {
- util.exec("ConstrainedList_Invalid_1");
- }
-
- @Test
- public void test_ConstrainedList_Invalid_2() {
- util.exec("ConstrainedList_Invalid_2");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_ConstrainedList_Invalid_3() {
- util.exec("ConstrainedList_Invalid_3");
- }
-
-
- @Test
- public void test_ConstrainedSet_Invalid_1() {
- util.exec("ConstrainedSet_Invalid_1");
- }
-
- @Test
- public void test_ConstrainedSet_Invalid_2() {
- util.exec("ConstrainedSet_Invalid_2");
- }
-
- @Test
- public void test_ConstrainedSet_Invalid_3() {
- util.exec("ConstrainedSet_Invalid_3");
- }
-
- @Test
- public void test_ConstrainedTuple_Invalid_1() {
- util.exec("ConstrainedTuple_Invalid_1");
- }
-
- @Test
- public void test_Contractive_Invalid_1() {
- util.exec("Contractive_Invalid_1");
- }
-
- @Test
- public void test_Contractive_Invalid_2() {
- util.exec("Contractive_Invalid_2");
- }
-
- @Ignore("Missing DefineAssign_Invalid_1.sysout")
- @Test
- public void test_DefineAssign_Invalid_1() {
- util.exec("DefineAssign_Invalid_1");
- }
- @Ignore("Missing DefineAssign_Invalid_2.sysout")
- @Test
- public void test_DefineAssign_Invalid_2() {
- util.exec("DefineAssign_Invalid_2");
- }
- @Ignore("Missing DefineAssign_Invalid_3.sysout")
- @Test
- public void test_DefineAssign_Invalid_3() {
- util.exec("DefineAssign_Invalid_3");
- }
- @Ignore("Missing DefineAssign_Invalid_4.sysout")
- @Test
- public void test_DefineAssign_Invalid_4() {
- util.exec("DefineAssign_Invalid_4");
- }
-
- @Test
- public void test_EndOfFile_Invalid_1() {
- util.exec("EndOfFile_Invalid_1");
- }
-
- @Test
- public void test_Ensures_Invalid_1() {
- util.exec("Ensures_Invalid_1");
- }
-
- @Test
- public void test_Ensures_Invalid_2() {
- util.exec("Ensures_Invalid_2");
- }
-
- @Test
- public void test_Ensures_Invalid_3() {
- util.exec("Ensures_Invalid_3");
- }
-
- @Test
- @Ignore("unclassified")
- public void test_Export_Invalid_1() {
- util.exec("Export_Invalid_1");
- }
-
- @Test
- public void test_For_Invalid_1() {
- util.exec("For_Invalid_1");
- }
-
-
- @Test
- public void test_For_Invalid_5() {
- util.exec("For_Invalid_5");
- }
-
- @Test
- public void test_For_Invalid_6() {
- util.exec("For_Invalid_6");
- }
-
- @Test
- public void test_For_Invalid_7() {
- util.exec("For_Invalid_7");
- }
-
- @Test
- public void test_For_Invalid_8() {
- util.exec("For_Invalid_8");
- }
-
- @Ignore("Issue #409")
- @Test
- public void test_For_Invalid_9() {
- util.exec("For_Invalid_9");
- }
-
-
- @Test
- public void test_FunctionRef_Invalid_1() {
- util.exec("FunctionRef_Invalid_1");
- }
-
- @Test
- public void test_FunctionRef_Invalid_2() {
- util.exec("FunctionRef_Invalid_2");
- }
-
- @Test
- public void test_FunctionRef_Invalid_3() {
- util.exec("FunctionRef_Invalid_3");
- }
-
- @Test
- public void test_FunctionRef_Invalid_4() {
- util.exec("FunctionRef_Invalid_4");
- }
-
- @Test
- public void test_FunctionRef_Invalid_5() {
- util.exec("FunctionRef_Invalid_5");
- }
-
- @Test
- public void test_FunctionRef_Invalid_6() {
- util.exec("FunctionRef_Invalid_6");
- }
-
- @Test
- public void test_FunctionRef_Invalid_7() {
- util.exec("FunctionRef_Invalid_7");
- }
- @Ignore("Missing FunctionRef_Invalid_9.sysout")
- @Test
- public void test_FunctionRef_Invalid_9() {
- util.exec("FunctionRef_Invalid_9");
- }
-
- @Test
- public void test_Function_Invalid_1() {
- util.exec("Function_Invalid_1");
- }
-
- @Test
- public void test_Function_Invalid_10() {
- util.exec("Function_Invalid_10");
- }
-
- @Ignore("Internal Failure")
- @Test
- public void test_Function_Invalid_2() {
- util.exec("Function_Invalid_2");
- }
-
- @Test
- public void test_Function_Invalid_3() {
- util.exec("Function_Invalid_3");
- }
-
- @Test
- public void test_Function_Invalid_4() {
- util.exec("Function_Invalid_4");
- }
- @Ignore("unclassified")
- @Test
- public void test_Function_Invalid_9() {
- util.exec("Function_Invalid_9");
- }
-
- @Test
- public void test_If_Invalid_1() {
- util.exec("If_Invalid_1");
- }
-
- @Test
- public void test_If_Invalid_2() {
- util.exec("If_Invalid_2");
- }
-
- @Test
- public void test_If_Invalid_3() {
- util.exec("If_Invalid_3");
- }
-
- @Test
- public void test_If_Invalid_4() {
- util.exec("If_Invalid_4");
- }
-
- @Test
- public void test_If_Invalid_5() {
- util.exec("If_Invalid_5");
- }
-
- @Test
- public void test_Import_Invalid_1() {
- util.exec("Import_Invalid_1");
- }
- @Ignore("unclassified")
- @Test
- public void test_Intersection_Invalid_1() {
- util.exec("Intersection_Invalid_1");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_Intersection_Invalid_2() {
- util.exec("Intersection_Invalid_2");
- }
-
- @Test
- public void test_IntDiv_Invalid_1() {
- util.exec("IntDiv_Invalid_1");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_Lambda_Invalid_3() {
- util.exec("Lambda_Invalid_3");
- }
-
- @Test
- public void test_ListAccess_Invalid_1() {
- util.exec("ListAccess_Invalid_1");
- }
-
- @Test
- public void test_ListAccess_Invalid_3() {
- util.exec("ListAccess_Invalid_3");
- }
-
- @Test
- public void test_ListAccess_Invalid_5() {
- util.exec("ListAccess_Invalid_5");
- }
-
- @Test
- public void test_ListAppend_Invalid_1() {
- util.exec("ListAppend_Invalid_1");
- }
-
- @Test
- public void test_ListAppend_Invalid_2() {
- util.exec("ListAppend_Invalid_2");
- }
-
- @Ignore("Unknown Issue")
- @Test
- public void test_ListAppend_Invalid_3() {
- util.exec("ListAppend_Invalid_3");
- }
-
- @Ignore("Internal Failure")
- @Test
- public void test_ListAppend_Invalid_4() {
- util.exec("ListAppend_Invalid_4");
- }
-
- @Ignore("Internal Failure")
- @Test
- public void test_ListAppend_Invalid_5() {
- util.exec("ListAppend_Invalid_5");
- }
-
-
- @Test
- public void test_ListAssign_Invalid_1() {
- util.exec("ListAssign_Invalid_1");
- }
-
- @Ignore("Infinite Loop?")
- @Test
- public void test_ListAssign_Invalid_2() {
- util.exec("ListAssign_Invalid_2");
- }
-
- @Ignore("Infinite Loop?")
- @Test
- public void test_ListAssign_Invalid_3() {
- util.exec("ListAssign_Invalid_3");
- }
-
-
- @Test
- public void test_ListConversion_Invalid_1() {
- util.exec("ListConversion_Invalid_1");
- }
-
- @Test
- public void test_ListElemOf_Invalid_1() {
- util.exec("ListElemOf_Invalid_1");
- }
-
- @Test
- public void test_ListElemOf_Invalid_2() {
- util.exec("ListElemOf_Invalid_2");
- }
-
- @Test
- public void test_ListEmpty_Invalid_1() {
- util.exec("ListEmpty_Invalid_1");
- }
-
- @Test
- public void test_ListEmpty_Invalid_2() {
- util.exec("ListEmpty_Invalid_2");
- }
-
- @Test
- public void test_ListEquals_Invalid_1() {
- util.exec("ListEquals_Invalid_1");
- }
-
- @Test
- public void test_ListLength_Invalid_1() {
- util.exec("ListLength_Invalid_1");
- }
-
- @Test
- public void test_ListLength_Invalid_2() {
- util.exec("ListLength_Invalid_2");
- }
-
- @Test
- public void test_ListLength_Invalid_3() {
- util.exec("ListLength_Invalid_3");
- }
-
- @Test
- public void test_ListSublist_Invalid_1() {
- util.exec("ListSublist_Invalid_1");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_ListSublist_Invalid_2() {
- util.exec("ListSublist_Invalid_2");
- }
-
- @Test
- public void test_ListSublist_Invalid_3() {
- util.exec("ListSublist_Invalid_3");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_ListUpdate_Invalid_1() {
- util.exec("ListUpdate_Invalid_1");
- }
-
- @Test
- public void test_List_Invalid_1() {
- util.exec("List_Invalid_1");
- }
-
- @Test
- public void test_List_Invalid_2() {
- util.exec("List_Invalid_2");
- }
-
- @Test
- public void test_List_Invalid_3() {
- util.exec("List_Invalid_3");
- }
-
- @Test
- public void test_List_Invalid_4() {
- util.exec("List_Invalid_4");
- }
-
-
- @Test
- public void test_List_Invalid_5() {
- util.exec("List_Invalid_5");
- }
-
- @Test
- public void test_List_Invalid_6() {
- util.exec("List_Invalid_6");
- }
-
- @Test
- public void test_List_Invalid_7() {
- util.exec("List_Invalid_7");
- }
-
- @Test
- public void test_MethodCall_Invalid_1() {
- util.exec("MethodCall_Invalid_1");
- }
-
- @Test
- public void test_MethodCall_Invalid_2() {
- util.exec("MethodCall_Invalid_2");
- }
-
- @Test
- public void test_MethodCall_Invalid_3() {
- util.exec("MethodCall_Invalid_3");
- }
-
- @Test
- public void test_MethodCall_Invalid_4() {
- util.exec("MethodCall_Invalid_4");
- }
-
- @Test
- public void test_MethodCall_Invalid_5() {
- util.exec("MethodCall_Invalid_5");
- }
-
- @Test
- public void test_MethodCall_Invalid_6() {
- util.exec("MethodCall_Invalid_6");
- }
-
- @Test
- public void test_MethodCall_Invalid_7() {
- util.exec("MethodCall_Invalid_7");
- }
-
- @Test
- public void test_MethodCall_Invalid_8() {
- util.exec("MethodCall_Invalid_8");
- }
- @Ignore("unclassified")
- @Test
- public void test_MethodRef_Invalid_1() {
- util.exec("MethodRef_Invalid_1");
- }
- @Ignore("Internal Failure")
- @Test
- public void test_MethodRef_Invalid_2() {
- util.exec("MethodRef_Invalid_2");
- }
- @Ignore("unclassified")
- @Test
- public void test_MethodRef_Invalid_3() {
- util.exec("MethodRef_Invalid_3");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_Native_Invalid_1() {
- util.exec("Native_Invalid_1");
- }
-
- @Test
- public void test_NegationType_Invalid_1() {
- util.exec("NegationType_Invalid_1");
- }
- @Ignore("unclassified")
- @Test
- public void test_NegationType_Invalid_2() {
- util.exec("NegationType_Invalid_2");
- }
-
- @Test
- public void test_NegationType_Invalid_3() {
- util.exec("NegationType_Invalid_3");
- }
-
- @Test
- public void test_OpenRecord_Invalid_1() {
- util.exec("OpenRecord_Invalid_1");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_OpenRecord_Invalid_2() {
- util.exec("OpenRecord_Invalid_2");
- }
-
- @Test
- public void test_OpenRecord_Invalid_3() {
- util.exec("OpenRecord_Invalid_3");
- }
-
- @Test
- public void test_OpenRecord_Invalid_4() {
- util.exec("OpenRecord_Invalid_4");
- }
-
- @Test
- public void test_OpenRecord_Invalid_5() {
- util.exec("OpenRecord_Invalid_5");
- }
-
- @Test
- public void test_OpenRecord_Invalid_6() {
- util.exec("OpenRecord_Invalid_6");
- }
-
- @Test
- public void test_OpenRecord_Invalid_7() {
- util.exec("OpenRecord_Invalid_7");
- }
-
- @Test
- public void test_Parameter_Invalid_1() {
- util.exec("Parameter_Invalid_1");
- }
-
- @Test
- public void test_Parameter_Invalid_2() {
- util.exec("Parameter_Invalid_2");
- }
-
- @Test
- public void test_ProcessAccess_Invalid_1() {
- util.exec("ProcessAccess_Invalid_1");
- }
-
- @Test
- public void test_ProcessAccess_Invalid_2() {
- util.exec("ProcessAccess_Invalid_2");
- }
-
- @Test
- public void test_ProcessAccess_Invalid_3() {
- util.exec("ProcessAccess_Invalid_3");
- }
-
-
- @Test
- public void test_Process_Invalid_1() {
- util.exec("Process_Invalid_1");
- }
-
- @Test
- public void test_Process_Invalid_2() {
- util.exec("Process_Invalid_2");
- }
-
- @Test
- public void test_Process_Invalid_3() {
- util.exec("Process_Invalid_3");
- }
-
- @Test
- public void test_Quantifiers_Invalid_1() {
- util.exec("Quantifiers_Invalid_1");
- }
-
- @Test
- public void test_Quantifiers_Invalid_2() {
- util.exec("Quantifiers_Invalid_2");
- }
-
- @Test
- public void test_Quantifiers_Invalid_3() {
- util.exec("Quantifiers_Invalid_3");
- }
-
- @Test
- public void test_Quantifiers_Invalid_4() {
- util.exec("Quantifiers_Invalid_4");
- }
-
- @Test
- public void test_Quantifiers_Invalid_5() {
- util.exec("Quantifiers_Invalid_5");
- }
-
- @Test
- public void test_Quantifiers_Invalid_6() {
- util.exec("Quantifiers_Invalid_6");
- }
-
- @Test
- public void test_Quantifiers_Invalid_7() {
- util.exec("Quantifiers_Invalid_7");
- }
-
- @Test
- public void test_Quantifiers_Invalid_8() {
- util.exec("Quantifiers_Invalid_8");
- }
-
- @Test
- public void test_Rational_Invalid_1() {
- util.exec("Rational_Invalid_1");
- }
-
- @Test
- public void test_Rational_Invalid_2() {
- util.exec("Rational_Invalid_2");
- }
-
- @Test
- public void test_RealAdd_Invalid_1() {
- util.exec("RealAdd_Invalid_1");
- }
-
- @Test
- public void test_RealConvert_Invalid_1() {
- util.exec("RealConvert_Invalid_1");
- }
-
- @Test
- public void test_RealConvert_Invalid_2() {
- util.exec("RealConvert_Invalid_2");
- }
-
- @Test
- public void test_RealDiv_Invalid_1() {
- util.exec("RealDiv_Invalid_1");
- }
-
- @Test
- public void test_RealDiv_Invalid_2() {
- util.exec("RealDiv_Invalid_2");
- }
- @Ignore("Internal Failure")
- @Test
- public void test_RealMul_Invalid_1() {
- util.exec("RealMul_Invalid_1");
- }
-
- @Test
- public void test_Record_Invalid_1() {
- util.exec("Record_Invalid_1");
- }
-
- @Test
- public void test_Record_Invalid_2() {
- util.exec("Record_Invalid_2");
- }
-
- @Test
- public void test_Record_Invalid_3() {
- util.exec("Record_Invalid_3");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_RecursiveType_Invalid_1() {
- util.exec("RecursiveType_Invalid_1");
- }
- @Ignore("unclassified")
- @Test
- public void test_RecursiveType_Invalid_10() {
- util.exec("RecursiveType_Invalid_10");
- }
- @Ignore("unclassified")
- @Test
- public void test_RecursiveType_Invalid_2() {
- util.exec("RecursiveType_Invalid_2");
- }
-
- @Test
- public void test_RecursiveType_Invalid_3() {
- util.exec("RecursiveType_Invalid_3");
- }
- @Ignore("unclassified")
- @Test
- public void test_RecursiveType_Invalid_4() {
- util.exec("RecursiveType_Invalid_4");
- }
-
- @Test
- public void test_RecursiveType_Invalid_5() {
- util.exec("RecursiveType_Invalid_5");
- }
-
- @Ignore("unclassified")
- @Test
- public void test_RecursiveType_Invalid_7() {
- util.exec("RecursiveType_Invalid_7");
- }
- @Ignore("unclassified")
- @Test
- public void test_RecursiveType_Invalid_8() {
- util.exec("RecursiveType_Invalid_8");
- }
- @Ignore("unclassified")
- @Test
- public void test_RecursiveType_Invalid_9() {
- util.exec("RecursiveType_Invalid_9");
- }
-
- @Test
- public void test_Remainder_Invalid_1() {
- util.exec("Remainder_Invalid_1");
- }
-
- @Test
- public void test_Remainder_Invalid_2() {
- util.exec("Remainder_Invalid_2");
- }
-
- @Test
- public void test_Remainder_Invalid_3() {
- util.exec("Remainder_Invalid_3");
- }
-
- @Test
- public void test_Requires_Invalid_1() {
- util.exec("Requires_Invalid_1");
- }
-
- @Test
- public void test_Return_Invalid_1() {
- util.exec("Return_Invalid_1");
- }
- @Ignore("Missing Return_Invalid_10.sysout")
- @Test
- public void test_Return_Invalid_10() {
- util.exec("Return_Invalid_10");
- }
- @Ignore("Missing Return_Invalid_11.sysout")
- @Test
- public void test_Return_Invalid_11() {
- util.exec("Return_Invalid_11");
- }
-
- @Test
- public void test_Return_Invalid_2() {
- util.exec("Return_Invalid_2");
- }
-
-
- @Test
- public void test_Return_Invalid_3() {
- util.exec("Return_Invalid_3");
- }
-
- @Test
- public void test_Return_Invalid_4() {
- util.exec("Return_Invalid_4");
- }
-
- @Test
- public void test_Return_Invalid_5() {
- util.exec("Return_Invalid_5");
- }
-
- @Test
- public void test_Return_Invalid_6() {
- util.exec("Return_Invalid_6");
- }
-
- @Test
- public void test_Return_Invalid_7() {
- util.exec("Return_Invalid_7");
- }
-
- @Test
- public void test_Return_Invalid_8() {
- util.exec("Return_Invalid_8");
- }
-
- @Test
- public void test_Return_Invalid_9() {
- util.exec("Return_Invalid_9");
- }
-
- @Test
- public void test_SetAssign_Invalid_1() {
- util.exec("SetAssign_Invalid_1");
- }
-
- @Test
- public void test_SetComprehension_Invalid_1() {
- util.exec("SetComprehension_Invalid_1");
- }
-
- @Test
- public void test_SetComprehension_Invalid_2() {
- util.exec("SetComprehension_Invalid_2");
- }
-
- @Test
- public void test_SetComprehension_Invalid_3() {
- util.exec("SetComprehension_Invalid_3");
- }
-
- @Test
- public void test_SetComprehension_Invalid_4() {
- util.exec("SetComprehension_Invalid_4");
- }
-
- @Test
- public void test_SetComprehension_Invalid_5() {
- util.exec("SetComprehension_Invalid_5");
- }
-
- @Test
- public void test_SetComprehension_Invalid_6() {
- util.exec("SetComprehension_Invalid_6");
- }
-
- @Test
- public void test_SetConversion_Invalid_1() {
- util.exec("SetConversion_Invalid_1");
- }
-
-
- @Test
- public void test_SetDefine_Invalid_1() {
- util.exec("SetDefine_Invalid_1");
- }
-
- @Test
- public void test_SetDefine_Invalid_2() {
- util.exec("SetDefine_Invalid_2");
- }
-
- @Test
- public void test_SetElemOf_Invalid_1() {
- util.exec("SetElemOf_Invalid_1");
- }
-
- @Test
- public void test_SetEmpty_Invalid_1() {
- util.exec("SetEmpty_Invalid_1");
- }
-
- @Test
- public void test_SetEmpty_Invalid_2() {
- util.exec("SetEmpty_Invalid_2");
- }
-
- @Test
- public void test_SetIntersect_Invalid_1() {
- util.exec("SetIntersect_Invalid_1");
- }
- @Ignore("Missing SetIntersect_Invalid_2.sysout")
- @Test
- public void test_SetIntersect_Invalid_2() {
- util.exec("SetIntersect_Invalid_2");
- }
- @Ignore("Missing SetIntersection_Invalid_1.sysout")
- @Test
- public void test_SetIntersection_Invalid_1() {
- util.exec("SetIntersection_Invalid_1");
- }
-
- @Test
- public void test_SetIntersection_Invalid_2() {
- util.exec("SetIntersection_Invalid_2");
- }
-
- @Test
- public void test_SetSubset_Invalid_1() {
- util.exec("SetSubset_Invalid_1");
- }
- @Ignore("Missing SetSubset_Invalid_10.sysout")
- @Test
- public void test_SetSubset_Invalid_10() {
- util.exec("SetSubset_Invalid_10");
- }
- @Ignore("Missing SetSubset_Invalid_11.sysout")
- @Test
- public void test_SetSubset_Invalid_11() {
- util.exec("SetSubset_Invalid_11");
- }
- @Ignore("Missing SetSubset_Invalid_2.sysout")
- @Test
- public void test_SetSubset_Invalid_2() {
- util.exec("SetSubset_Invalid_2");
- }
-
- @Test
- public void test_SetSubset_Invalid_3() {
- util.exec("SetSubset_Invalid_3");
- }
- @Ignore("Missing SetSubset_Invalid_4.sysout")
- @Test
- public void test_SetSubset_Invalid_4() {
- util.exec("SetSubset_Invalid_4");
- }
-
- @Test
- public void test_SetSubset_Invalid_5() {
- util.exec("SetSubset_Invalid_5");
- }
-
- @Test
- public void test_SetSubset_Invalid_6() {
- util.exec("SetSubset_Invalid_6");
- }
-
- @Test
- public void test_SetSubset_Invalid_7() {
- util.exec("SetSubset_Invalid_7");
- }
-
- @Test
- public void test_SetSubset_Invalid_8() {
- util.exec("SetSubset_Invalid_8");
- }
-
- @Test
- public void test_SetSubset_Invalid_9() {
- util.exec("SetSubset_Invalid_9");
- }
-
- @Test
- public void test_SetUnion_Invalid_1() {
- util.exec("SetUnion_Invalid_1");
- }
-
- @Test
- public void test_SetUnion_Invalid_2() {
- util.exec("SetUnion_Invalid_2");
- }
-
- @Test
- public void test_SetUnion_Invalid_3() {
- util.exec("SetUnion_Invalid_3");
- }
-
- @Test
- public void test_SetUnion_Invalid_4() {
- util.exec("SetUnion_Invalid_4");
- }
-
- @Test
- public void test_SingleLineComment_Valid_1() {
- util.exec("SingleLineComment_Valid_1");
- }
-
- @Test
- public void test_String_Invalid_3() {
- util.exec("String_Invalid_3");
- }
-
- @Test
- public void test_Subtype_Invalid_1() {
- util.exec("Subtype_Invalid_1");
- }
-
- @Test
- public void test_Subtype_Invalid_2() {
- util.exec("Subtype_Invalid_2");
- }
-
- @Test
- public void test_Subtype_Invalid_3() {
- util.exec("Subtype_Invalid_3");
- }
-
- @Test
- public void test_Subtype_Invalid_4() {
- util.exec("Subtype_Invalid_4");
- }
-
- @Test
- public void test_Subtype_Invalid_5() {
- util.exec("Subtype_Invalid_5");
- }
-
- @Test
- public void test_Subtype_Invalid_6() {
- util.exec("Subtype_Invalid_6");
- }
-
- @Test
- public void test_Subtype_Invalid_7() {
- util.exec("Subtype_Invalid_7");
- }
-
- @Test
- public void test_Subtype_Invalid_8() {
- util.exec("Subtype_Invalid_8");
- }
-
- @Test
- public void test_Subtype_Invalid_9() {
- util.exec("Subtype_Invalid_9");
- }
-
- @Test
- public void test_Switch_Invalid_1() {
- util.exec("Switch_Invalid_1");
- }
-
- @Test
- public void test_Switch_Invalid_2() {
- util.exec("Switch_Invalid_2");
- }
-
- @Test
- public void test_Switch_Invalid_3() {
- util.exec("Switch_Invalid_3");
- }
-
- @Test
- public void test_Switch_Invalid_4() {
- util.exec("Switch_Invalid_4");
- }
-
- @Test
- public void test_Switch_Invalid_5() {
- util.exec("Switch_Invalid_5");
- }
- @Ignore("Missing Switch_Invalid_6.sysout")
- @Test
- public void test_Switch_Invalid_6() {
- util.exec("Switch_Invalid_6");
- }
-
- @Test
- public void test_Switch_Invalid_7() {
- util.exec("Switch_Invalid_7");
- }
-
- @Test
- public void test_Throws_Invalid_1() {
- util.exec("Throws_Invalid_1");
- }
-
- @Test
- public void test_Throws_Invalid_2() {
- util.exec("Throws_Invalid_2");
- }
- @Test
- public void test_TryCatch_Invalid_1() {
- util.exec("TryCatch_Invalid_1");
- }
-
- @Test
- public void test_TryCatch_Invalid_2() {
- util.exec("TryCatch_Invalid_2");
- }
-
- @Test
- public void test_TryCatch_Invalid_3() {
- util.exec("TryCatch_Invalid_3");
- }
-
- @Test
- public void test_TryCatch_Invalid_4() {
- util.exec("TryCatch_Invalid_4");
- }
-
- @Test
- public void test_TryCatch_Invalid_5() {
- util.exec("TryCatch_Invalid_5");
- }
-
- @Ignore("Missing TupleAssgn_Invalid_1")
- @Test
- public void test_TupleAssgn_Invalid_1() {
- util.exec("TupleAssgn_Invalid_1");
- }
- @Ignore("Missing TupleAssgn_Invalid_2")
- @Test
- public void test_TupleAssgn_Invalid_2() {
- util.exec("TupleAssgn_Invalid_2");
- }
- @Ignore("Missing TupleAssgn_Invalid_3")
- @Test
- public void test_TupleAssgn_Invalid_3() {
- util.exec("TupleAssgn_Invalid_3");
- }
-
- @Test
- public void test_TupleDefine_Invalid_1() {
- util.exec("TupleDefine_Invalid_1");
- }
-
- @Test
- public void test_TupleDefine_Invalid_2() {
- util.exec("TupleDefine_Invalid_2");
- }
-
- @Test
- public void test_Tuple_Invalid_1() {
- util.exec("Tuple_Invalid_1");
- }
- @Ignore("Missing Tuple_Invalid_2")
- @Test
- public void test_Tuple_Invalid_2() {
- util.exec("Tuple_Invalid_2");
- }
-
- @Test
- public void test_Tuple_Invalid_3() {
- util.exec("Tuple_Invalid_3");
- }
-
- @Test
- public void test_Tuple_Invalid_4() {
- util.exec("Tuple_Invalid_4");
- }
-
- @Test
- public void test_Tuple_Invalid_5() {
- util.exec("Tuple_Invalid_5");
- }
-
- @Test
- public void test_Tuple_Invalid_6() {
- util.exec("Tuple_Invalid_6");
- }
-
- @Test
- public void test_Tuple_Invalid_7() {
- util.exec("Tuple_Invalid_7");
- }
- @Ignore("Missing Tuple_Invalid_8")
- @Test
- public void test_Tuple_Invalid_8() {
- util.exec("Tuple_Invalid_8");
- }
-
- @Test
- public void test_TypeEquals_Invalid_1() {
- util.exec("TypeEquals_Invalid_1");
- }
-
- @Test
- public void test_TypeEquals_Invalid_2() {
- util.exec("TypeEquals_Invalid_2");
- }
-
- @Ignore("Missing TypeEquals_Invalid_5.sysout")
- @Test
- public void test_TypeEquals_Invalid_5() {
- util.exec("TypeEquals_Invalid_5");
- }
-
- @Test
- public void test_TypeEquals_Invalid_6() {
- util.exec("TypeEquals_Invalid_6");
- }
-
- @Test
- public void test_UnionType_Invalid_1() {
- util.exec("UnionType_Invalid_1");
- }
- @Ignore("Missing UnionType_Invalid_10")
- @Test
- public void test_UnionType_Invalid_10() {
- util.exec("UnionType_Invalid_10");
- }
-
- @Test
- public void test_UnionType_Invalid_2() {
- util.exec("UnionType_Invalid_2");
- }
-
- @Test
- public void test_UnionType_Invalid_3() {
- util.exec("UnionType_Invalid_3");
- }
-
- @Test
- public void test_UnionType_Invalid_4() {
- util.exec("UnionType_Invalid_4");
- }
-
- @Test
- public void test_UnionType_Invalid_5() {
- util.exec("UnionType_Invalid_5");
- }
-
- @Test
- public void test_UnionType_Invalid_6() {
- util.exec("UnionType_Invalid_6");
- }
-
- @Test
- public void test_UnionType_Invalid_7() {
- util.exec("UnionType_Invalid_7");
- }
- @Ignore("Missing UnionType_Invalid_8")
- @Test
- public void test_UnionType_Invalid_8() {
- util.exec("UnionType_Invalid_8");
- }
- @Ignore("Missing UnionType_Invalid_9")
- @Test
- public void test_UnionType_Invalid_9() {
- util.exec("UnionType_Invalid_9");
- }
-
- @Test
- public void test_VarDecl_Invalid_1() {
- util.exec("VarDecl_Invalid_1");
- }
-
- @Test
- public void test_VarDecl_Invalid_2() {
- util.exec("VarDecl_Invalid_2");
- }
-
- @Test
- public void test_VarDecl_Invalid_3() {
- util.exec("VarDecl_Invalid_3");
- }
-
-
- @Ignore("Missing Void_Invalid_1.sysout")
- @Test
- public void test_Void_Invalid_1() {
- util.exec("Void_Invalid_1");
- }
- @Ignore("Missing Void_Invalid_2.sysout")
- @Test
- public void test_Void_Invalid_2() {
- util.exec("Void_Invalid_2");
- }
- @Ignore("Missing Void_Invalid_3.sysout")
- @Test
- public void test_Void_Invalid_3() {
- util.exec("Void_Invalid_3");
- }
-
- @Test
- public void test_While_Invalid_1() {
- util.exec("While_Invalid_1");
- }
- @Ignore("Missing While_Invalid_10.sysout")
- @Test
- public void test_While_Invalid_10() {
- util.exec("While_Invalid_10");
- }
- @Ignore("Missing While_Invalid_11.sysout")
- @Test
- public void test_While_Invalid_11() {
- util.exec("While_Invalid_11");
- }
- @Ignore("Missing While_Invalid_12.sysout")
- @Test
- public void test_While_Invalid_12() {
- util.exec("While_Invalid_12");
- }
- @Ignore("Missing While_Invalid_13.sysout")
- @Test
- public void test_While_Invalid_13() {
- util.exec("While_Invalid_13");
- }
-
- @Test
- public void test_While_Invalid_2() {
- util.exec("While_Invalid_2");
- }
-
- @Test
- public void test_While_Invalid_3() {
- util.exec("While_Invalid_3");
- }
-
- @Test
- public void test_While_Invalid_4() {
- util.exec("While_Invalid_4");
- }
- @Test
- public void test_While_Invalid_5() {
- util.exec("While_Invalid_5");
- }
- @Test
- public void test_While_Invalid_6() {
- util.exec("While_Invalid_6");
- }
- @Test
- public void test_While_Invalid_7() {
- util.exec("While_Invalid_7");
- }
-
- @Test
- public void test_While_Invalid_8() {
- util.exec("While_Invalid_8");
- }
-
- @Test
- public void test_While_Invalid_9() {
- util.exec("While_Invalid_9");
- }
-
-
-}
diff --git a/modules/wyopcl/test/wyopcl/testing/interpreter/AllValidTestCase.java b/modules/wyopcl/test/wyopcl/testing/interpreter/AllValidTestCase.java
deleted file mode 100644
index 087600b7b9..0000000000
--- a/modules/wyopcl/test/wyopcl/testing/interpreter/AllValidTestCase.java
+++ /dev/null
@@ -1,4077 +0,0 @@
-package wyopcl.testing.interpreter;
-
-import static org.junit.Assert.*;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TestRule;
-import org.junit.rules.Timeout;
-
-public class AllValidTestCase {
- @Rule
- public TestRule timeout = new Timeout(25000);
- private BaseTestUtil util;
-
- @Before
- public void setUp() throws Exception {
- util = new BaseTestUtil();
- }
-
- @After
- public void tearDown() throws Exception {
- util.terminate();
- util = null;
- }
-
- @Test
- public void test_Access_Valid_1() {
- util.exec("Access_Valid_1");
- }
-
- @Test
- public void test_Access_Valid_2() {
- util.exec("Access_Valid_2");
- }
-
- @Test
- public void test_Assume_Valid_1() {
- util.exec("Assume_Valid_1");
- }
-
- @Test
- public void test_Assume_Valid_2() {
- util.exec("Assume_Valid_2");
- }
-
- @Test
- public void test_BoolAssign_Valid_1() {
- util.exec("BoolAssign_Valid_1");
- }
-
- @Test
- public void test_BoolAssign_Valid_2() {
- util.exec("BoolAssign_Valid_2");
- }
-
- @Test
- public void test_BoolAssign_Valid_3() {
- util.exec("BoolAssign_Valid_3");
- }
-
- @Test
- public void test_BoolAssign_Valid_4() {
- util.exec("BoolAssign_Valid_4");
- }
-
- @Test
- public void test_BoolAssign_Valid_5() {
- util.exec("BoolAssign_Valid_5");
- }
-
- @Test
- public void test_BoolAssign_Valid_6() {
- util.exec("BoolAssign_Valid_6");
- }
-
- @Test
- public void test_BoolFun_Valid_1() {
- util.exec("BoolFun_Valid_1");
- }
-
- @Test
- public void test_BoolIfElse_Valid_1() {
- util.exec("BoolIfElse_Valid_1");
- }
-
- @Test
- public void test_BoolIfElse_Valid_2() {
- util.exec("BoolIfElse_Valid_2");
- }
-
- @Test
- public void test_BoolList_Valid_1() {
- util.exec("BoolList_Valid_1");
- }
-
- @Test
- public void test_BoolList_Valid_2() {
- util.exec("BoolList_Valid_2");
- }
-
- @Test
- public void test_BoolList_Valid_3() {
- util.exec("BoolList_Valid_3");
- }
-
- @Test
- public void test_BoolRecord_Valid_1() {
- util.exec("BoolRecord_Valid_1");
- }
-
- @Test
- public void test_BoolRecord_Valid_2() {
- util.exec("BoolRecord_Valid_2");
- }
-
- @Test
- public void test_BoolRequires_Valid_1() {
- util.exec("BoolRequires_Valid_1");
- }
-
- @Test
- public void test_BoolReturn_Valid_1() {
- util.exec("BoolReturn_Valid_1");
- }
-
- @Test
- public void test_Byte_Valid_1() {
- util.exec("Byte_Valid_1");
- }
-
- @Test
- public void test_Byte_Valid_2() {
- util.exec("Byte_Valid_2");
- }
-
- @Test
- public void test_Byte_Valid_3() {
- util.exec("Byte_Valid_3");
- }
-
- @Test
- public void test_Byte_Valid_4() {
- util.exec("Byte_Valid_4");
- }
-
- @Test
- public void test_Byte_Valid_5() {
- util.exec("Byte_Valid_5");
- }
-
- @Test
- public void test_Byte_Valid_6() {
- util.exec("Byte_Valid_6");
- }
-
- @Test
- public void test_Byte_Valid_7() {
- util.exec("Byte_Valid_7");
- }
-
- @Test
- public void test_Byte_Valid_8() {
- util.exec("Byte_Valid_8");
- }
-
- @Test
- public void test_Byte_Valid_9() {
- util.exec("Byte_Valid_9");
- }
-
- @Test
- public void test_Cast_Valid_1() {
- util.exec("Cast_Valid_1");
- }
-
- @Test
- public void test_Cast_Valid_2() {
- util.exec("Cast_Valid_2");
- }
-
- @Test
- public void test_Cast_Valid_3() {
- util.exec("Cast_Valid_3");
- }
-
- @Test
- public void test_Cast_Valid_4() {
- util.exec("Cast_Valid_4");
- }
-
- @Test
- public void test_Cast_Valid_5() {
- util.exec("Cast_Valid_5");
- }
-
- @Test
- public void test_Cast_Valid_6() {
- util.exec("Cast_Valid_6");
- }
-
- @Test
- public void test_Char_Valid_1() {
- util.exec("Char_Valid_1");
- }
-
- @Test
- public void test_Char_Valid_2() {
- util.exec("Char_Valid_2");
- }
-
- @Test
- public void test_Char_Valid_3() {
- util.exec("Char_Valid_3");
- }
-
- @Test
- public void test_Char_Valid_4() {
- util.exec("Char_Valid_4");
- }
-
- @Test
- public void test_Char_Valid_5() {
- util.exec("Char_Valid_5");
- }
-
- @Test
- public void test_Char_Valid_6() {
- util.exec("Char_Valid_6");
- }
-
- @Test
- public void test_Char_Valid_7() {
- util.exec("Char_Valid_7");
- }
-
- @Test
- public void test_Coercion_Valid_1() {
- util.exec("Coercion_Valid_1");
- }
-
- @Test
- public void test_Coercion_Valid_2() {
- util.exec("Coercion_Valid_2");
- }
-
- @Test
- public void test_Coercion_Valid_3() {
- util.exec("Coercion_Valid_3");
- }
-
- @Test
- public void test_Coercion_Valid_4() {
- util.exec("Coercion_Valid_4");
- }
-
- @Test
- public void test_Coercion_Valid_6() {
- util.exec("Coercion_Valid_6");
- }
-
- @Test
- public void test_Coercion_Valid_7() {
- util.exec("Coercion_Valid_7");
- }
-
- /**
- .\Coercion_Valid_8.whiley:7: expected type real, found int
- return |x|
- ^^^
-wycc.lang.SyntaxError: expected type real, found int
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.builder.FlowTypeChecker.checkIsSubtype(FlowTypeChecker.java:4060)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:799)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:327)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:766)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Test
- @Ignore("Issue #406\n"
- + ".\\Coercion_Valid_8.whiley:7: expected type real, found int\r\n" +
- " return |x|\r\n" +
- " ^^^\r\n" +
- "wycc.lang.SyntaxError: expected type real, found int\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)")
- public void test_Coercion_Valid_8() {
- util.exec("Coercion_Valid_8");
- }
-
- @Test
- public void test_Coercion_Valid_9() {
- util.exec("Coercion_Valid_9");
- }
-
- @Test
- public void test_Complex_Valid_1() {
- util.exec("Complex_Valid_1");
- }
-
- @Test
- public void test_Complex_Valid_2() {
- util.exec("Complex_Valid_2");
- }
- /**
- * .\Complex_Valid_3.whiley:9: record required, got: X
- (tree != null && tree.left != null ==> tree.left.item < tree.item) &&
- ^^^^^^^^^^^^^^
-wycc.lang.SyntaxError: record required, got: X
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2327)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1674)
- at wyc.builder.FlowTypeChecker.resolveLeafCondition(FlowTypeChecker.java:1458)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1356)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.resolveNonLeafCondition(FlowTypeChecker.java:1422)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1345)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.resolveNonLeafCondition(FlowTypeChecker.java:1398)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1345)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.resolveNonLeafCondition(FlowTypeChecker.java:1396)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1345)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1750)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1660)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:196)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:147)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Test
- @Ignore("Issue ???\n"
- + ".\\Complex_Valid_3.whiley:9: record required, got: X\r\n" +
- " (tree != null && tree.left != null ==> tree.left.item < tree.item) &&\r\n" +
- " ^^^^^^^^^^^^^^\r\n" +
- "wycc.lang.SyntaxError: record required, got: X\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)")
- public void test_Complex_Valid_3() {
- util.exec("Complex_Valid_3");
- }
-
- @Test
- public void test_Complex_Valid_4() {
- util.exec("Complex_Valid_4");
- }
-
- @Test
- public void test_Complex_Valid_5() {
- util.exec("Complex_Valid_5");
- }
-
- @Test
- public void test_Complex_Valid_6() {
- util.exec("Complex_Valid_6");
- }
-
-
- @Test
- public void test_Complex_Valid_7() {
- util.exec("Complex_Valid_7");
- }
-
- @Test
- public void test_Complex_Valid_8() {
- util.exec("Complex_Valid_8");
- }
-
- /**
- Parsed 1 source file(s). ....................................................... [60ms+1mb]
-.\Constant_Valid_1.whiley:5: internal failure
-constant CONSTANT is {V1 is TYPE, V2 is TYPE}
- ^^^^
-wycc.lang.SyntaxError$InternalFailure: internal failure
- at wycc.lang.SyntaxError.internalFailure(SyntaxError.java:312)
- at wyc.lang.WhileyFile.internalFailure(WhileyFile.java:635)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3190)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3078)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3023)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2382)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1712)
- at wyc.builder.FlowTypeChecker.resolveLeafCondition(FlowTypeChecker.java:1459)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1356)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1750)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1660)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2199)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1698)
- at wyc.builder.FlowTypeChecker.resolveAsConstant(FlowTypeChecker.java:3469)
- at wyc.builder.FlowTypeChecker.resolveAsConstant(FlowTypeChecker.java:3407)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3282)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3182)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3116)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3325)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3182)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3078)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3024)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2382)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1712)
- at wyc.builder.FlowTypeChecker.resolveLeafCondition(FlowTypeChecker.java:1459)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1356)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1750)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1660)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2199)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1698)
- at wyc.builder.FlowTypeChecker.resolveAsConstant(FlowTypeChecker.java:3469)
- at wyc.builder.FlowTypeChecker.resolveAsConstant(FlowTypeChecker.java:3407)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3282)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3182)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3116)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3325)
- at wyc.builder.FlowTypeC
- */
- @Ignore("Issue #311\n"
- + ".\\Constant_Valid_1.whiley:5: internal failure\r\n" +
- "constant CONSTANT is {V1 is TYPE, V2 is TYPE}\r\n" +
- " ^^^^\r\n" +
- "wycc.lang.SyntaxError$InternalFailure: internal failure\r\n" +
- " at wycc.lang.SyntaxError.internalFailure(SyntaxError.java:312)\r\n" +
- " at wyc.lang.WhileyFile.internalFailure(WhileyFile.java:635)")
- @Test
- public void test_Constant_Valid_1() {
- util.exec("Constant_Valid_1");
- }
-
- /**
- .\Constant_Valid_2.whiley:4: type not found: Constant_Valid_2:ZLIB
-type CompressionMethod is {ZLIB}
- ^^^^
-wycc.lang.SyntaxError: type not found: Constant_Valid_2:ZLIB
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:253)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:625)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3185)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3123)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3078)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3024)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:179)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:147)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-Caused by: wycc.util.ResolveError: type not found: Constant_Valid_2:ZLIB
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3296)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3182)
- ... 13 more
-
- */
- @Ignore("Issue #311\n"
- + ".\\Constant_Valid_2.whiley:4: type not found: Constant_Valid_2:ZLIB\r\n" +
- "type CompressionMethod is {ZLIB}\r\n" +
- " ^^^^\r\n" +
- "wycc.lang.SyntaxError: type not found: Constant_Valid_2:ZLIB\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:253)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:625)")
- @Test
- public void test_Constant_Valid_2() {
- util.exec("Constant_Valid_2");
- }
-
- @Test
- public void test_Constant_Valid_3() {
- util.exec("Constant_Valid_3");
- }
-
- @Test
- public void test_ConstrainedDictionary_Valid_1() {
- util.exec("ConstrainedDictionary_Valid_1");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_1() {
- util.exec("ConstrainedInt_Valid_1");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_10() {
- util.exec("ConstrainedInt_Valid_10");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_12() {
- util.exec("ConstrainedInt_Valid_12");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_13() {
- util.exec("ConstrainedInt_Valid_13");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_14() {
- util.exec("ConstrainedInt_Valid_14");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_15() {
- util.exec("ConstrainedInt_Valid_15");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_16() {
- util.exec("ConstrainedInt_Valid_16");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_17() {
- util.exec("ConstrainedInt_Valid_17");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_18() {
- util.exec("ConstrainedInt_Valid_18");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_19() {
- util.exec("ConstrainedInt_Valid_19");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_2() {
- util.exec("ConstrainedInt_Valid_2");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_20() {
- util.exec("ConstrainedInt_Valid_20");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_21() {
- util.exec("ConstrainedInt_Valid_21");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_22() {
- util.exec("ConstrainedInt_Valid_22");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_23() {
- util.exec("ConstrainedInt_Valid_23");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_3() {
- util.exec("ConstrainedInt_Valid_3");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_4() {
- util.exec("ConstrainedInt_Valid_4");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_5() {
- util.exec("ConstrainedInt_Valid_5");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_6() {
- util.exec("ConstrainedInt_Valid_6");
- }
-
- @Test
- public void test_ConstrainedInt_Valid_8() {
- util.exec("ConstrainedInt_Valid_8");
- }
-
- @Test
- public void test_ConstrainedList_Valid_1() {
- util.exec("ConstrainedList_Valid_1");
- }
-
- @Test
- public void test_ConstrainedList_Valid_11() {
- util.exec("ConstrainedList_Valid_11");
- }
-
- @Test
- public void test_ConstrainedList_Valid_12() {
- util.exec("ConstrainedList_Valid_12");
- }
-
- @Test
- public void test_ConstrainedList_Valid_14() {
- util.exec("ConstrainedList_Valid_14");
- }
-
- @Test
- public void test_ConstrainedList_Valid_15() {
- util.exec("ConstrainedList_Valid_15");
- }
-
- @Test
- public void test_ConstrainedList_Valid_16() {
- util.exec("ConstrainedList_Valid_16");
- }
-
- @Test
- public void test_ConstrainedList_Valid_17() {
- util.exec("ConstrainedList_Valid_17");
- }
-
- @Test
- public void test_ConstrainedList_Valid_18() {
- util.exec("ConstrainedList_Valid_18");
- }
-
- @Test
- public void test_ConstrainedList_Valid_19() {
- util.exec("ConstrainedList_Valid_19");
- }
-
- @Test
- public void test_ConstrainedList_Valid_2() {
- util.exec("ConstrainedList_Valid_2");
- }
-
- @Test
- public void test_ConstrainedList_Valid_20() {
- util.exec("ConstrainedList_Valid_20");
- }
-
- @Test
- public void test_ConstrainedList_Valid_21() {
- util.exec("ConstrainedList_Valid_21");
- }
-
- @Test
- public void test_ConstrainedList_Valid_22() {
- util.exec("ConstrainedList_Valid_22");
- }
-
- /**
- * The expected result is different from executed one.
- * Expected: :[[19, 43], [22, 50]]
- * Actual: :[[19, [22], [43], 50]]
- */
- @Test
- public void test_ConstrainedList_Valid_23() {
- util.exec("ConstrainedList_Valid_23");
- }
-
- @Test
- public void test_ConstrainedList_Valid_24() {
- util.exec("ConstrainedList_Valid_24");
- }
-
- @Test
- public void test_ConstrainedList_Valid_25() {
- util.exec("ConstrainedList_Valid_25");
- }
-
- @Test
- public void test_ConstrainedList_Valid_26() {
- util.exec("ConstrainedList_Valid_26");
- }
-
- @Test
- public void test_ConstrainedList_Valid_3() {
- util.exec("ConstrainedList_Valid_3");
- }
-
- @Test
- public void test_ConstrainedList_Valid_4() {
- util.exec("ConstrainedList_Valid_4");
- }
-
- @Test
- public void test_ConstrainedList_Valid_5() {
- util.exec("ConstrainedList_Valid_5");
- }
-
- @Test
- public void test_ConstrainedList_Valid_6() {
- util.exec("ConstrainedList_Valid_6");
- }
-
- @Test
- public void test_ConstrainedList_Valid_7() {
- util.exec("ConstrainedList_Valid_7");
- }
-
- @Test
- public void test_ConstrainedList_Valid_8() {
- util.exec("ConstrainedList_Valid_8");
- }
-
- @Test
- public void test_ConstrainedList_Valid_9() {
- util.exec("ConstrainedList_Valid_9");
- }
-
- /**
- .\ConstrainedNegation_Valid_1.whiley:9: incomparable operands: !int and int
- if x is int:
- ^^^^^^^^
-wycc.lang.SyntaxError: incomparable operands: !int and int
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)
- at wyc.builder.FlowTypeChecker.resolveLeafCondition(FlowTypeChecker.java:1510)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1356)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:755)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Test
- @Ignore("Issue ???\n"
- + ".\\ConstrainedNegation_Valid_1.whiley:9: incomparable operands: !int and int\r\n" +
- " if x is int:\r\n" +
- " ^^^^^^^^\r\n" +
- "wycc.lang.SyntaxError: incomparable operands: !int and int\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)"
- )
- public void test_ConstrainedNegation_Valid_1() {
- util.exec("ConstrainedNegation_Valid_1");
- }
-
- @Test
- public void test_ConstrainedRecord_Valid_1() {
- util.exec("ConstrainedRecord_Valid_1");
- }
-
- @Test
- public void test_ConstrainedRecord_Valid_2() {
- util.exec("ConstrainedRecord_Valid_2");
- }
-
- @Test
- public void test_ConstrainedRecord_Valid_3() {
- util.exec("ConstrainedRecord_Valid_3");
- }
-
- @Test
- public void test_ConstrainedRecord_Valid_4() {
- util.exec("ConstrainedRecord_Valid_4");
- }
-
- @Test
- public void test_ConstrainedRecord_Valid_5() {
- util.exec("ConstrainedRecord_Valid_5");
- }
-
- @Test
- public void test_ConstrainedRecord_Valid_6() {
- util.exec("ConstrainedRecord_Valid_6");
- }
-
- @Test
- public void test_ConstrainedRecord_Valid_8() {
- util.exec("ConstrainedRecord_Valid_8");
- }
-
- @Test
- public void test_ConstrainedRecord_Valid_9() {
- util.exec("ConstrainedRecord_Valid_9");
- }
-
- @Test
- public void test_ConstrainedSet_Valid_1() {
- util.exec("ConstrainedSet_Valid_1");
- }
-
- @Test
- public void test_ConstrainedSet_Valid_2() {
- util.exec("ConstrainedSet_Valid_2");
- }
-
- @Test
- public void test_ConstrainedSet_Valid_3() {
- util.exec("ConstrainedSet_Valid_3");
- }
-
- @Test
- public void test_ConstrainedSet_Valid_4() {
- util.exec("ConstrainedSet_Valid_4");
- }
-
- @Test
- public void test_ConstrainedSet_Valid_5() {
- util.exec("ConstrainedSet_Valid_5");
- }
-
- @Test
- public void test_ConstrainedSet_Valid_6() {
- util.exec("ConstrainedSet_Valid_6");
- }
-
- @Test
- public void test_ConstrainedSet_Valid_7() {
- util.exec("ConstrainedSet_Valid_7");
- }
-
- @Test
- public void test_ConstrainedSet_Valid_8() {
- util.exec("ConstrainedSet_Valid_8");
- }
-
- @Test
- public void test_ConstrainedTuple_Valid_1() {
- util.exec("ConstrainedTuple_Valid_1");
- }
-
- /**
- .\Contractive_Valid_1.whiley:5: contractive type encountered
-function f(Contractive x) => Contractive:
- ^^^^^^^^^^^
-wycc.lang.SyntaxError: contractive type encountered
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:2972)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:256)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Ignore("Issue ???\n"
- + ".\\Contractive_Valid_1.whiley:5: contractive type encountered\r\n" +
- "function f(Contractive x) => Contractive:\r\n" +
- " ^^^^^^^^^^^\r\n" +
- "wycc.lang.SyntaxError: contractive type encountered\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)")
- @Test
- public void test_Contractive_Valid_1() {
- util.exec("Contractive_Valid_1");
- }
-
- @Test
- public void test_Contractive_Valid_2() {
- util.exec("Contractive_Valid_2");
- }
-
- @Test
- public void test_DecimalAssignment_Valid_1() {
- util.exec("DecimalAssignment_Valid_1");
- }
-
- @Test
- public void test_Define_Valid_1() {
- util.exec("Define_Valid_1");
- }
-
- @Test
- public void test_Define_Valid_2() {
- util.exec("Define_Valid_2");
- }
-
- @Test
- public void test_Define_Valid_3() {
- util.exec("Define_Valid_3");
- }
-
- @Test
- public void test_Define_Valid_4() {
- util.exec("Define_Valid_4");
- }
-
- @Test
- public void test_Dictionary_Valid_1() {
- util.exec("Dictionary_Valid_1");
- }
-
- @Test
- public void test_Dictionary_Valid_10() {
- util.exec("Dictionary_Valid_10");
- }
-
- @Test
- public void test_Dictionary_Valid_11() {
- util.exec("Dictionary_Valid_11");
- }
-
- @Test
- public void test_Dictionary_Valid_12() {
- util.exec("Dictionary_Valid_12");
- }
-
- @Test
- public void test_Dictionary_Valid_13() {
- util.exec("Dictionary_Valid_13");
- }
-
- @Test
- public void test_Dictionary_Valid_14() {
- util.exec("Dictionary_Valid_14");
- }
-
- @Test
- public void test_Dictionary_Valid_15() {
- util.exec("Dictionary_Valid_15");
- }
-
- @Test
- public void test_Dictionary_Valid_16() {
- util.exec("Dictionary_Valid_16");
- }
-
- @Test
- public void test_Dictionary_Valid_2() {
- util.exec("Dictionary_Valid_2");
- }
-
- @Test
- public void test_Dictionary_Valid_3() {
- util.exec("Dictionary_Valid_3");
- }
-
- @Test
- public void test_Dictionary_Valid_4() {
- util.exec("Dictionary_Valid_4");
- }
-
- @Test
- public void test_Dictionary_Valid_5() {
- util.exec("Dictionary_Valid_5");
- }
-
- @Test
- public void test_Dictionary_Valid_6() {
- util.exec("Dictionary_Valid_6");
- }
-
- @Test
- public void test_Dictionary_Valid_7() {
- util.exec("Dictionary_Valid_7");
- }
-
- @Test
- public void test_Dictionary_Valid_8() {
- util.exec("Dictionary_Valid_8");
- }
-
- @Test
- public void test_Dictionary_Valid_9() {
- util.exec("Dictionary_Valid_9");
- }
-
- @Test
- public void test_DoWhile_Valid_1() {
- util.exec("DoWhile_Valid_1");
- }
-
- @Test
- public void test_DoWhile_Valid_2() {
- util.exec("DoWhile_Valid_2");
- }
-
- @Test
- public void test_DoWhile_Valid_3() {
- util.exec("DoWhile_Valid_3");
- }
-
- @Test
- public void test_DoWhile_Valid_4() {
- util.exec("DoWhile_Valid_4");
- }
-
- @Test
- public void test_DoWhile_Valid_5() {
- util.exec("DoWhile_Valid_5");
- }
-
- @Test
- public void test_EffectiveList_Valid_1() {
- util.exec("EffectiveList_Valid_1");
- }
-
- @Test
- public void test_Ensures_Valid_1() {
- util.exec("Ensures_Valid_1");
- }
-
- @Test
- public void test_Ensures_Valid_2() {
- util.exec("Ensures_Valid_2");
- }
-
- @Test
- public void test_Ensures_Valid_3() {
- util.exec("Ensures_Valid_3");
- }
-
- @Test
- public void test_Ensures_Valid_4() {
- util.exec("Ensures_Valid_4");
- }
-
- @Test
- public void test_Ensures_Valid_5() {
- util.exec("Ensures_Valid_5");
- }
-
- @Test
- public void test_Ensures_Valid_6() {
- util.exec("Ensures_Valid_6");
- }
-
- @Test
- public void test_Ensures_Valid_7() {
- util.exec("Ensures_Valid_7");
- }
-
- @Test
- public void test_For_Valid_1() {
- util.exec("For_Valid_1");
- }
-
- @Test
- public void test_For_Valid_10() {
- util.exec("For_Valid_10");
- }
-
- @Test
- public void test_For_Valid_11() {
- util.exec("For_Valid_11");
- }
-
- @Test
- public void test_For_Valid_12() {
- util.exec("For_Valid_12");
- }
-
- @Test
- public void test_For_Valid_13() {
- util.exec("For_Valid_13");
- }
-
- @Test
- public void test_For_Valid_14() {
- util.exec("For_Valid_14");
- }
-
- @Test
- public void test_For_Valid_15() {
- util.exec("For_Valid_15");
- }
-
- @Test
- public void test_For_Valid_16() {
- util.exec("For_Valid_16");
- }
-
- @Test
- public void test_For_Valid_17() {
- util.exec("For_Valid_17");
- }
-
- @Test
- public void test_For_Valid_18() {
- util.exec("For_Valid_18");
- }
-
- @Test
- public void test_For_Valid_2() {
- util.exec("For_Valid_2");
- }
-
- @Test
- public void test_For_Valid_3() {
- util.exec("For_Valid_3");
- }
-
- @Test
- public void test_For_Valid_4() {
- util.exec("For_Valid_4");
- }
-
- /**
- * .\For_Valid_5.whiley:4: variable may be uninitialised for i, r in xs:
- * ^^^^^^^^^^^^^^^ wycc.lang.SyntaxError: variable may be uninitialised at
- * wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:675) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:333) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135) at
- * wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181) at
- * wybs.util.StdBuildRule.apply(StdBuildRule.java:109) at
- * wybs.util.StdProject.build(StdProject.java:256) at
- * wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503) at
- * wyc.util.WycBuildTask.build(WycBuildTask.java:471) at
- * wyopcl.WyopclMain.run(WyopclMain.java:119) at
- * wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Ignore("Issue ???\n"
- + ".\\For_Valid_5.whiley:4: variable may be uninitialised for i, r in xs:\r\n" +
- " ^^^^^^^^^^^^^^^ wycc.lang.SyntaxError: variable may be uninitialised at\r\n" +
- " wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238) at")
- @Test
- public void test_For_Valid_5() {
- util.exec("For_Valid_5");
- }
-/**
- *
- [.\For_Valid_6.whiley] failed on definite assignment check (internal failure, internal failure) [0ms]
-.\For_Valid_6.whiley:9: internal failure, internal failure
- for x in xs:
- ^^^^^^^^^^^^
-wycc.lang.SyntaxError$InternalFailure: internal failure, internal failure
- at wycc.lang.SyntaxError.internalFailure(SyntaxError.java:312)
- at wyil.util.dfa.ForwardFlowAnalysis.propagate(ForwardFlowAnalysis.java:208)
- at wyil.util.dfa.ForwardFlowAnalysis.propagate(ForwardFlowAnalysis.java:94)
- at wyil.util.dfa.ForwardFlowAnalysis.propagate(ForwardFlowAnalysis.java:83)
- at wyil.util.dfa.ForwardFlowAnalysis.apply(ForwardFlowAnalysis.java:64)
- at wyil.checks.DefiniteAssignmentCheck.apply(DefiniteAssignmentCheck.java:1)
- at wyc.builder.WhileyBuilder.process(WhileyBuilder.java:360)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:224)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-Caused by: java.lang.NullPointerException
- at wyil.checks.DefiniteAssignmentCheck.join(DefiniteAssignmentCheck.java:164)
- at wyil.checks.DefiniteAssignmentCheck.propagate(DefiniteAssignmentCheck.java:157)
- at wyil.checks.DefiniteAssignmentCheck.propagate(DefiniteAssignmentCheck.java:1)
- at wyil.util.dfa.ForwardFlowAnalysis.propagate(ForwardFlowAnalysis.java:138)
- ... 12 more
- */
- @Ignore("Issue ???"
- + ".\\For_Valid_6.whiley:9: internal failure, internal failure\r\n" +
- " for x in xs:\r\n" +
- " ^^^^^^^^^^^^\r\n" +
- "wycc.lang.SyntaxError$InternalFailure: internal failure, internal failure\r\n" +
- " at wycc.lang.SyntaxError.internalFailure(SyntaxError.java:312)")
- @Test
- public void test_For_Valid_6() {
- util.exec("For_Valid_6");
- }
-
- @Test
- public void test_For_Valid_7() {
- util.exec("For_Valid_7");
- }
-
- @Test
- public void test_For_Valid_8() {
- util.exec("For_Valid_8");
- }
-
- @Test
- public void test_For_Valid_9() {
- util.exec("For_Valid_9");
- }
- @Test
- public void test_FunctionRef_Valid_1() {
- util.exec("FunctionRef_Valid_1");
- }
-
- /**
- * Parsed 1 source file(s).
- * ....................................................... [62ms+1mb]
- * .\FunctionRef_Valid_2.whiley:4: incomparable operands: real and int
- * return x + 1 ^^^^^ wycc.lang.SyntaxError: incomparable operands: real and
- * int at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1889) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1660) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:797) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:327) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145) at
- * wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135) at
- * wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181) at
- * wybs.util.StdBuildRule.apply(StdBuildRule.java:109) at
- * wybs.util.StdProject.build(StdProject.java:256) at
- * wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503) at
- * wyc.util.WycBuildTask.build(WycBuildTask.java:471) at
- * wyopcl.WyopclMain.run(WyopclMain.java:119) at
- * wyopcl.WyopclMain.main(WyopclMain.java:148)
- **/
- @Ignore("Issue ???\n"
- + ".\\FunctionRef_Valid_2.whiley:4: incomparable operands: real and int\r\n" +
- " return x + 1 ^^^^^ wycc.lang.SyntaxError: incomparable operands: real and\r\n" +
- " int at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238) at")
- @Test
- public void test_FunctionRef_Valid_2() {
- util.exec("FunctionRef_Valid_2");
- }
-
- @Test
- public void test_FunctionRef_Valid_3() {
- util.exec("FunctionRef_Valid_3");
- }
-
- @Test
- public void test_FunctionRef_Valid_4() {
- util.exec("FunctionRef_Valid_4");
- }
-
- @Test
- public void test_FunctionRef_Valid_5() {
- util.exec("FunctionRef_Valid_5");
- }
-
- @Test
- public void test_FunctionRef_Valid_6() {
- util.exec("FunctionRef_Valid_6");
- }
-
- @Test
- public void test_FunctionRef_Valid_7() {
- util.exec("FunctionRef_Valid_7");
- }
-
- @Test
- public void test_FunctionRef_Valid_8() {
- util.exec("FunctionRef_Valid_8");
- }
-
- @Test
- public void test_FunctionRef_Valid_9() {
- util.exec("FunctionRef_Valid_9");
- }
-
- @Test
- public void test_Function_Valid_1() {
- util.exec("Function_Valid_1");
- }
-
- @Test
- public void test_Function_Valid_10() {
- util.exec("Function_Valid_10");
- }
-
- @Test
- public void test_Function_Valid_12() {
- util.exec("Function_Valid_12");
- }
-
- @Test
- public void test_Function_Valid_13() {
- util.exec("Function_Valid_13");
- }
-
- @Test
- public void test_Function_Valid_14() {
- util.exec("Function_Valid_14");
- }
-
- @Test
- public void test_Function_Valid_16() {
- util.exec("Function_Valid_16");
- }
-
- @Test
- public void test_Function_Valid_17() {
- util.exec("Function_Valid_17");
- }
-
- @Test
- public void test_Function_Valid_18() {
- util.exec("Function_Valid_18");
- }
-
- @Test
- public void test_Function_Valid_19() {
- util.exec("Function_Valid_19");
- }
-
- @Test
- public void test_Function_Valid_2() {
- util.exec("Function_Valid_2");
- }
-
- @Test
- public void test_Function_Valid_20() {
- util.exec("Function_Valid_20");
- }
-
- @Test
- public void test_Function_Valid_21() {
- util.exec("Function_Valid_21");
- }
-
- @Test
- public void test_Function_Valid_3() {
- util.exec("Function_Valid_3");
- }
-
- @Test
- public void test_Function_Valid_4() {
- util.exec("Function_Valid_4");
- }
-
- @Test
- public void test_Function_Valid_5() {
- util.exec("Function_Valid_5");
- }
-
- @Test
- public void test_Function_Valid_6() {
- util.exec("Function_Valid_6");
- }
-
- @Test
- public void test_Function_Valid_7() {
- util.exec("Function_Valid_7");
- }
-
- @Test
- public void test_Function_Valid_8() {
- util.exec("Function_Valid_8");
- }
-
- @Test
- public void test_Function_Valid_9() {
- util.exec("Function_Valid_9");
- }
-
- @Test
- public void test_HexAssign_Valid_1() {
- util.exec("HexAssign_Valid_1");
- }
-
- @Test
- public void test_IfElse_Valid_1() {
- util.exec("IfElse_Valid_1");
- }
-
- @Test
- public void test_IfElse_Valid_2() {
- util.exec("IfElse_Valid_2");
- }
-
- @Test
- public void test_IfElse_Valid_3() {
- util.exec("IfElse_Valid_3");
- }
-
- @Test
- public void test_IfElse_Valid_4() {
- util.exec("IfElse_Valid_4");
- }
-
- @Test
- public void test_IfElse_Valid_5() {
- util.exec("IfElse_Valid_5");
- }
-
- @Test
- public void test_Import_Valid_1() {
- util.exec("Import_Valid_1");
- }
-
- @Test
- public void test_Import_Valid_2() {
- util.exec("Import_Valid_2");
- }
-
- @Test
- public void test_Import_Valid_3() {
- util.exec("Import_Valid_3");
- }
-
- @Test
- public void test_Import_Valid_4() {
- util.exec("Import_Valid_4");
- }
-
- @Test
- public void test_Import_Valid_5() {
- util.exec("Import_Valid_5");
- }
-
- @Test
- public void test_Import_Valid_6() {
- util.exec("Import_Valid_6");
- }
-
- @Test
- public void test_Import_Valid_7() {
- util.exec("Import_Valid_7");
- }
-
- /**
- * .\Intersection_Valid_1.whiley:3: internal failure, intersection types not supported yet
-type EmptyList is [int] & [real]
- ^^^^^^^^^^^^^^^
-wycc.lang.SyntaxError$InternalFailure: internal failure, intersection types not supported yet
- at wycc.lang.SyntaxError.internalFailure(SyntaxError.java:297)
- at wyc.lang.WhileyFile.internalFailure(WhileyFile.java:630)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3210)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3078)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3023)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:179)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:147)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Ignore("Issue ???\n"
- + ".\\Intersection_Valid_1.whiley:3: internal failure, intersection types not supported yet\r\n" +
- "type EmptyList is [int] & [real]\r\n" +
- " ^^^^^^^^^^^^^^^\r\n" +
- "wycc.lang.SyntaxError$InternalFailure: internal failure, intersection types not supported yet\r\n" +
- " at wycc.lang.SyntaxError.internalFailure(SyntaxError.java:297)\r\n" +
- " at wyc.lang.WhileyFile.internalFailure(WhileyFile.java:630)")
- @Test
- public void test_Intersection_Valid_1() {
- util.exec("Intersection_Valid_1");
- }
- /**
- * .\Intersection_Valid_2.whiley:7: internal failure, intersection types not supported yet
-type InterList is UnitList & LinkedList
- ^^^^^^^^^^^^^^^^^^^^^^
-wycc.lang.SyntaxError$InternalFailure: internal failure, intersection types not supported yet
- at wycc.lang.SyntaxError.internalFailure(SyntaxError.java:297)
- at wyc.lang.WhileyFile.internalFailure(WhileyFile.java:630)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3210)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3078)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3023)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:179)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:147)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Ignore("Issue ???\n"
- + " .\\Intersection_Valid_2.whiley:7: internal failure, intersection types not supported yet\r\n" +
- "type InterList is UnitList & LinkedList\r\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^\r\n" +
- "wycc.lang.SyntaxError$InternalFailure: internal failure, intersection types not supported yet\r\n" +
- " at wycc.lang.SyntaxError.internalFailure(SyntaxError.java:297)\r\n" +
- " at wyc.lang.WhileyFile.internalFailure(WhileyFile.java:630)")
- @Test
- public void test_Intersection_Valid_2() {
- util.exec("Intersection_Valid_2");
- }
-
- @Test
- public void test_IntConst_Valid_1() {
- util.exec("IntConst_Valid_1");
- }
-
- @Test
- public void test_IntDefine_Valid_1() {
- util.exec("IntDefine_Valid_1");
- }
-
- @Test
- public void test_IntDefine_Valid_2() {
- util.exec("IntDefine_Valid_2");
- }
-
- @Test
- public void test_IntDiv_Valid_1() {
- util.exec("IntDiv_Valid_1");
- }
-
- @Test
- public void test_IntDiv_Valid_3() {
- util.exec("IntDiv_Valid_3");
- }
-
- @Test
- public void test_IntDiv_Valid_4() {
- util.exec("IntDiv_Valid_4");
- }
-
- @Test
- public void test_IntDiv_Valid_5() {
- util.exec("IntDiv_Valid_5");
- }
-
- @Test
- public void test_IntEquals_Valid_1() {
- util.exec("IntEquals_Valid_1");
- }
-
- @Test
- public void test_IntMul_Valid_1() {
- util.exec("IntMul_Valid_1");
- }
-
- @Test
- public void test_IntMul_Valid_2() {
- util.exec("IntMul_Valid_2");
- }
-
- @Test
- public void test_IntOp_Valid_1() {
- util.exec("IntOp_Valid_1");
- }
-
- @Test
- public void test_Lambda_Valid_1() {
- util.exec("Lambda_Valid_1");
- }
-
- @Test
- public void test_Lambda_Valid_2() {
- util.exec("Lambda_Valid_2");
- }
-
- @Test
- public void test_Lambda_Valid_3() {
- util.exec("Lambda_Valid_3");
- }
-
- @Test
- public void test_Lambda_Valid_4() {
- util.exec("Lambda_Valid_4");
- }
-
- @Test
- public void test_Lambda_Valid_5() {
- util.exec("Lambda_Valid_5");
- }
-
- @Test
- public void test_Lambda_Valid_6() {
- util.exec("Lambda_Valid_6");
- }
-
- @Test
- public void test_Lambda_Valid_7() {
- util.exec("Lambda_Valid_7");
- }
-
- @Test
- public void test_Lambda_Valid_8() {
- util.exec("Lambda_Valid_8");
- }
-
- @Test
- public void test_Lambda_Valid_9() {
- util.exec("Lambda_Valid_9");
- }
-
- @Test
- public void test_LengthOf_Valid_1() {
- util.exec("LengthOf_Valid_1");
- }
-
- @Test
- public void test_LengthOf_Valid_2() {
- util.exec("LengthOf_Valid_2");
- }
-
- @Test
- public void test_LengthOf_Valid_3() {
- util.exec("LengthOf_Valid_3");
- }
-
- @Test
- public void test_LengthOf_Valid_4() {
- util.exec("LengthOf_Valid_4");
- }
-
- @Test
- public void test_LengthOf_Valid_5() {
- util.exec("LengthOf_Valid_5");
- }
-
- @Test
- public void test_ListAccess_Valid_1() {
- util.exec("ListAccess_Valid_1");
- }
-
- @Test
- public void test_ListAccess_Valid_3() {
- util.exec("ListAccess_Valid_3");
- }
-
- @Test
- public void test_ListAccess_Valid_5() {
- util.exec("ListAccess_Valid_5");
- }
- /**
- * .\ListAccess_Valid_6.whiley:9: invalid set or list expression
- r = r ++ [r[0]]
- ^
-wycc.lang.SyntaxError: invalid set or list expression
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2149)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1687)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2216)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1696)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1754)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1660)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:463)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:325)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:767)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.computeFixedPoint(FlowTypeChecker.java:2471)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:692)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:333)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Ignore("Issue ???\n"
- + ".\\ListAccess_Valid_6.whiley:9: invalid set or list expression\r\n" +
- " r = r ++ [r[0]]\r\n" +
- " ^\r\n" +
- "wycc.lang.SyntaxError: invalid set or list expression\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)")
- @Test
- public void test_ListAccess_Valid_6() {
- util.exec("ListAccess_Valid_6");
- }
- /**
- * .\ListAccess_Valid_7.whiley:6: incomparable operands: [void] and null
- if r == null:
- ^^^^^^^^^
-wycc.lang.SyntaxError: incomparable operands: [void] and null
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)
- at wyc.builder.FlowTypeChecker.resolveLeafCondition(FlowTypeChecker.java:1606)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1356)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:755)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.computeFixedPoint(FlowTypeChecker.java:2471)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:692)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:333)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-
- */
- @Ignore("Issue ???\n"
- + ".\\ListAccess_Valid_7.whiley:6: incomparable operands: [void] and null\r\n" +
- " if r == null:\r\n" +
- " ^^^^^^^^^\r\n" +
- "wycc.lang.SyntaxError: incomparable operands: [void] and null\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)")
- @Test
- public void test_ListAccess_Valid_7() {
- util.exec("ListAccess_Valid_7");
- }
-
- @Test
- public void test_ListAccess_Valid_8() {
- util.exec("ListAccess_Valid_8");
- }
-
- @Test
- public void test_ListAppend_Valid_1() {
- util.exec("ListAppend_Valid_1");
- }
-
- @Test
- public void test_ListAppend_Valid_11() {
- util.exec("ListAppend_Valid_11");
- }
-
- @Test
- public void test_ListAppend_Valid_13() {
- util.exec("ListAppend_Valid_13");
- }
-
- @Test
- public void test_ListAppend_Valid_14() {
- util.exec("ListAppend_Valid_14");
- }
-
- @Test
- public void test_ListAppend_Valid_2() {
- util.exec("ListAppend_Valid_2");
- }
-
- @Test
- public void test_ListAppend_Valid_3() {
- util.exec("ListAppend_Valid_3");
- }
-
- @Test
- public void test_ListAppend_Valid_4() {
- util.exec("ListAppend_Valid_4");
- }
-
- @Test
- public void test_ListAppend_Valid_5() {
- util.exec("ListAppend_Valid_5");
- }
-
- @Test
- public void test_ListAppend_Valid_6() {
- util.exec("ListAppend_Valid_6");
- }
-
- @Test
- public void test_ListAppend_Valid_7() {
- util.exec("ListAppend_Valid_7");
- }
-
- @Test
- public void test_ListAppend_Valid_8() {
- util.exec("ListAppend_Valid_8");
- }
-
- @Test
- public void test_ListAppend_Valid_9() {
- util.exec("ListAppend_Valid_9");
- }
-
- @Test
- public void test_ListAssign_Valid_1() {
- util.exec("ListAssign_Valid_1");
- }
-
- @Test
- public void test_ListAssign_Valid_11() {
- util.exec("ListAssign_Valid_11");
- }
-
- @Test
- public void test_ListAssign_Valid_2() {
- util.exec("ListAssign_Valid_2");
- }
-
- @Test
- public void test_ListAssign_Valid_3() {
- util.exec("ListAssign_Valid_3");
- }
-
- @Test
- public void test_ListAssign_Valid_4() {
- util.exec("ListAssign_Valid_4");
- }
-
- @Test
- public void test_ListAssign_Valid_5() {
- util.exec("ListAssign_Valid_5");
- }
-
- @Test
- public void test_ListAssign_Valid_6() {
- util.exec("ListAssign_Valid_6");
- }
-
- @Test
- public void test_ListAssign_Valid_7() {
- util.exec("ListAssign_Valid_7");
- }
-
- @Test
- public void test_ListAssign_Valid_8() {
- util.exec("ListAssign_Valid_8");
- }
-
- @Test
- public void test_ListAssign_Valid_9() {
- util.exec("ListAssign_Valid_9");
- }
-
- @Test
- public void test_ListConversion_Valid_1() {
- util.exec("ListConversion_Valid_1");
- }
-
- @Test
- public void test_ListElemOf_Valid_1() {
- util.exec("ListElemOf_Valid_1");
- }
-
- @Test
- public void test_ListEmpty_Valid_1() {
- util.exec("ListEmpty_Valid_1");
- }
-
- @Test
- public void test_ListEquals_Valid_1() {
- util.exec("ListEquals_Valid_1");
- }
-
- @Test
- public void test_ListGenerator_Valid_1() {
- util.exec("ListGenerator_Valid_1");
- }
-
- @Test
- public void test_ListGenerator_Valid_2() {
- util.exec("ListGenerator_Valid_2");
- }
-
- @Test
- public void test_ListGenerator_Valid_3() {
- util.exec("ListGenerator_Valid_3");
- }
-
- @Test
- public void test_ListGenerator_Valid_5() {
- util.exec("ListGenerator_Valid_5");
- }
-
- @Test
- public void test_ListLength_Valid_1() {
- util.exec("ListLength_Valid_1");
- }
-
- @Test
- public void test_ListLength_Valid_2() {
- util.exec("ListLength_Valid_2");
- }
-
- @Test
- public void test_ListLength_Valid_3() {
- util.exec("ListLength_Valid_3");
- }
-
- @Test
- public void test_ListRange_Valid_1() {
- util.exec("ListRange_Valid_1");
- }
-
- @Test
- public void test_ListSublist_Valid_1() {
- util.exec("ListSublist_Valid_1");
- }
-
- @Test
- public void test_ListSublist_Valid_2() {
- util.exec("ListSublist_Valid_2");
- }
-
- @Test
- public void test_ListSublist_Valid_3() {
- util.exec("ListSublist_Valid_3");
- }
-
- @Test
- public void test_ListSublist_Valid_4() {
- util.exec("ListSublist_Valid_4");
- }
-
- @Test
- public void test_ListSublist_Valid_5() {
- util.exec("ListSublist_Valid_5");
- }
-
- @Test
- public void test_MessageRef_Valid_1() {
- util.exec("MessageRef_Valid_1");
- }
-
- /**
- * The expected result is different from executed one.
- * Expected: 128
- * Actual: 124
- */
- @Test
- public void test_MessageRef_Valid_2() {
- util.exec("MessageRef_Valid_2");
- }
-
- @Test
- public void test_MessageSend_Valid_1() {
- util.exec("MessageSend_Valid_1");
- }
-
- @Test
- public void test_MessageSend_Valid_2() {
- util.exec("MessageSend_Valid_2");
- }
-
- @Test
- public void test_MessageSend_Valid_3() {
- util.exec("MessageSend_Valid_3");
- }
-
- @Test
- public void test_MessageSend_Valid_4() {
- util.exec("MessageSend_Valid_4");
- }
-
- @Test
- public void test_MessageSend_Valid_5() {
- util.exec("MessageSend_Valid_5");
- }
-
- @Test
- public void test_MethodCall_Valid_1() {
- util.exec("MethodCall_Valid_1");
- }
-
- @Test
- public void test_MethodCall_Valid_2() {
- util.exec("MethodCall_Valid_2");
- }
-
- @Test
- public void test_MethodCall_Valid_3() {
- util.exec("MethodCall_Valid_3");
- }
-
- /**
- * The expected result is different from the actual one.
- * Expected:
- 123
- * Actual:
- SUM: 228
- SUM: 228
- *
- */
- @Test
- public void test_MethodCall_Valid_4() {
- util.exec("MethodCall_Valid_4");
- }
-
- @Test
- public void test_MethodRef_Valid_1() {
- util.exec("MethodRef_Valid_1");
- }
-
- @Test
- public void test_MethodRef_Valid_2() {
- util.exec("MethodRef_Valid_2");
- }
-
- @Test
- public void test_Method_Valid_1() {
- util.exec("Method_Valid_1");
- }
-
- @Test
- public void test_MultiLineComment_Valid_1() {
- util.exec("MultiLineComment_Valid_1");
- }
-
- @Test
- public void test_MultiLineComment_Valid_2() {
- util.exec("MultiLineComment_Valid_2");
- }
-
- @Test
- public void test_NegationType_Valid_1() {
- util.exec("NegationType_Valid_1");
- }
-
- @Test
- public void test_NegationType_Valid_2() {
- util.exec("NegationType_Valid_2");
- }
- /**
- * .\NegationType_Valid_3.whiley:3: internal failure, intersection types not supported yet
-function f(string x) => !null & !int:
- ^^^^^^^^^^^
-wycc.lang.SyntaxError$InternalFailure: internal failure, intersection types not supported yet
- at wycc.lang.SyntaxError.internalFailure(SyntaxError.java:297)
- at wyc.lang.WhileyFile.internalFailure(WhileyFile.java:630)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3210)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3197)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3078)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:3023)
- at wyc.builder.FlowTypeChecker.resolveAsType(FlowTypeChecker.java:2975)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:256)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-
- */
- @Ignore("Issue ???\n"
- + " .\\NegationType_Valid_3.whiley:3: internal failure, intersection types not supported yet\r\n" +
- "function f(string x) => !null & !int:\r\n" +
- " ^^^^^^^^^^^\r\n" +
- "wycc.lang.SyntaxError$InternalFailure: internal failure, intersection types not supported yet\r\n" +
- " at wycc.lang.SyntaxError.internalFailure(SyntaxError.java:297)\r\n" +
- " at wyc.lang.WhileyFile.internalFailure(WhileyFile.java:630)")
- @Test
- public void test_NegationType_Valid_3() {
- util.exec("NegationType_Valid_3");
- }
-
- @Test
- public void test_NegationType_Valid_4() {
- util.exec("NegationType_Valid_4");
- }
-
- @Test
- public void test_OpenRecord_Valid_1() {
- util.exec("OpenRecord_Valid_1");
- }
-
- @Test
- public void test_OpenRecord_Valid_10() {
- util.exec("OpenRecord_Valid_10");
- }
-
- @Test
- public void test_OpenRecord_Valid_2() {
- util.exec("OpenRecord_Valid_2");
- }
-
- @Test
- @Ignore("Issue ???")
- public void test_OpenRecord_Valid_3() {
- util.exec("OpenRecord_Valid_3");
- }
-
- @Test
- public void test_OpenRecord_Valid_4() {
- util.exec("OpenRecord_Valid_4");
- }
-
- @Test
- public void test_OpenRecord_Valid_5() {
- util.exec("OpenRecord_Valid_5");
- }
-
- @Test
- public void test_OpenRecord_Valid_6() {
- util.exec("OpenRecord_Valid_6");
- }
-
- @Test
- public void test_OpenRecord_Valid_7() {
- util.exec("OpenRecord_Valid_7");
- }
-
- @Test
- public void test_OpenRecord_Valid_8() {
- util.exec("OpenRecord_Valid_8");
- }
-
- @Test
- public void test_OpenRecord_Valid_9() {
- util.exec("OpenRecord_Valid_9");
- }
-
- @Test
- public void test_Print_Valid_1() {
- util.exec("Print_Valid_1");
- }
-
- @Test
- public void test_ProcessAccess_Valid_1() {
- util.exec("ProcessAccess_Valid_1");
- }
-
- @Test
- public void test_ProcessAccess_Valid_2() {
- util.exec("ProcessAccess_Valid_2");
- }
-
- @Test
- public void test_Process_Valid_1() {
- util.exec("Process_Valid_1");
- }
-
- @Test
- public void test_Process_Valid_10() {
- util.exec("Process_Valid_10");
- }
-
- @Test
- public void test_Process_Valid_11() {
- util.exec("Process_Valid_11");
- }
-
- @Test
- public void test_Process_Valid_12() {
- util.exec("Process_Valid_12");
- }
-
- @Test
- public void test_Process_Valid_13() {
- util.exec("Process_Valid_13");
- }
-
- @Test
- public void test_Process_Valid_14() {
- util.exec("Process_Valid_14");
- }
-
- @Test
- public void test_Process_Valid_2() {
- util.exec("Process_Valid_2");
- }
-
- @Test
- public void test_Process_Valid_3() {
- util.exec("Process_Valid_3");
- }
-
- @Test
- public void test_Process_Valid_4() {
- util.exec("Process_Valid_4");
- }
-
- @Test
- public void test_Process_Valid_5() {
- util.exec("Process_Valid_5");
- }
-
- @Test
- public void test_Process_Valid_6() {
- util.exec("Process_Valid_6");
- }
-
- @Test
- public void test_Process_Valid_7() {
- util.exec("Process_Valid_7");
- }
-
- @Test
- public void test_Process_Valid_8() {
- util.exec("Process_Valid_8");
- }
-
- @Test
- public void test_Process_Valid_9() {
- util.exec("Process_Valid_9");
- }
-
- @Test
- public void test_Quantifiers_Valid_1() {
- util.exec("Quantifiers_Valid_1");
- }
-
- @Test
- public void test_Range_Valid_1() {
- util.exec("Range_Valid_1");
- }
-
- @Test
- public void test_RealConst_Valid_1() {
- util.exec("RealConst_Valid_1");
- }
-
- @Test
- public void test_RealDiv_Valid_1() {
- util.exec("RealDiv_Valid_1");
- }
-
- @Test
- public void test_RealDiv_Valid_2() {
- util.exec("RealDiv_Valid_2");
- }
-
- @Test
- public void test_RealDiv_Valid_3() {
- util.exec("RealDiv_Valid_3");
- }
-
- @Test
- public void test_RealDiv_Valid_4() {
- util.exec("RealDiv_Valid_4");
- }
-
- @Test
- public void test_RealDiv_Valid_5() {
- util.exec("RealDiv_Valid_5");
- }
-
- @Test
- public void test_RealDiv_Valid_6() {
- util.exec("RealDiv_Valid_6");
- }
-
- @Test
- public void test_RealDiv_Valid_7() {
- util.exec("RealDiv_Valid_7");
- }
-
- @Test
- public void test_RealNeg_Valid_1() {
- util.exec("RealNeg_Valid_1");
- }
-
- @Test
- public void test_RealNeg_Valid_2() {
- util.exec("RealNeg_Valid_2");
- }
-
- @Test
- public void test_RealSplit_Valid_1() {
- util.exec("RealSplit_Valid_1");
- }
-
- @Test
- public void test_RealSub_Valid_1() {
- util.exec("RealSub_Valid_1");
- }
-
- @Test
- public void test_RealSub_Valid_2() {
- util.exec("RealSub_Valid_2");
- }
-
- @Test
- public void test_RealSub_Valid_3() {
- util.exec("RealSub_Valid_3");
- }
-
- @Test
- public void test_Real_Valid_1() {
- util.exec("Real_Valid_1");
- }
-
- @Test
- public void test_RecordAccess_Valid_1() {
- util.exec("RecordAccess_Valid_1");
- }
-
- @Test
- public void test_RecordAccess_Valid_2() {
- util.exec("RecordAccess_Valid_2");
- }
-
- @Test
- public void test_RecordAssign_Valid_1() {
- util.exec("RecordAssign_Valid_1");
- }
-
- @Test
- public void test_RecordAssign_Valid_10() {
- util.exec("RecordAssign_Valid_10");
- }
-
- @Test
- public void test_RecordAssign_Valid_2() {
- util.exec("RecordAssign_Valid_2");
- }
-
- @Test
- public void test_RecordAssign_Valid_3() {
- util.exec("RecordAssign_Valid_3");
- }
-
- @Test
- public void test_RecordAssign_Valid_4() {
- util.exec("RecordAssign_Valid_4");
- }
-
- @Test
- public void test_RecordAssign_Valid_5() {
- util.exec("RecordAssign_Valid_5");
- }
-
- @Test
- public void test_RecordAssign_Valid_6() {
- util.exec("RecordAssign_Valid_6");
- }
-
- @Test
- public void test_RecordAssign_Valid_7() {
- util.exec("RecordAssign_Valid_7");
- }
-
- @Test
- public void test_RecordAssign_Valid_8() {
- util.exec("RecordAssign_Valid_8");
- }
-
- @Test
- public void test_RecordAssign_Valid_9() {
- util.exec("RecordAssign_Valid_9");
- }
-
- @Test
- public void test_RecordCoercion_Valid_1() {
- util.exec("RecordCoercion_Valid_1");
- }
-
- @Test
- public void test_RecordConversion_Valid_1() {
- util.exec("RecordConversion_Valid_1");
- }
-
- @Test
- public void test_RecordDefine_Valid_1() {
- util.exec("RecordDefine_Valid_1");
- }
-
- @Test
- public void test_RecordDefine_Valid_2() {
- util.exec("RecordDefine_Valid_2");
- }
- /**
- * .\RecordSubtype_Valid_1.whiley:12: expected type {null x}|{int x}, found {null|int x}
- return x
- ^
-wycc.lang.SyntaxError: expected type {null x}|{int x}, found {null|int x}
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.builder.FlowTypeChecker.checkIsSubtype(FlowTypeChecker.java:4060)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:799)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:327)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-
- */
- @Ignore("Issue ???\n"
- + "\\RecordSubtype_Valid_1.whiley:12: expected type {null x}|{int x}, found {null|int x}\r\n" +
- " return x\r\n" +
- " ^\r\n" +
- "wycc.lang.SyntaxError: expected type {null x}|{int x}, found {null|int x}\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.builder.FlowTypeChecker.checkIsSubtype(FlowTypeChecker.java:4060)")
- @Test
- public void test_RecordSubtype_Valid_1() {
- util.exec("RecordSubtype_Valid_1");
- }
- /**
- * .\RecordSubtype_Valid_2.whiley:12: expected type {null data,X next}|{int data,X next}, found X<{null|int data,X|null next}>
- return r
- ^
-wycc.lang.SyntaxError: expected type {null data,X next}|{int data,X next}, found X<{null|int data,X|null next}>
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.builder.FlowTypeChecker.checkIsSubtype(FlowTypeChecker.java:4060)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:799)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:327)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Ignore("Issue ???\n"
- + " .\\RecordSubtype_Valid_2.whiley:12: expected type {null data,X next}|{int data,X next}, found X<{null|int data,X|null next}>\r\n" +
- " return r\r\n" +
- " ^\r\n" +
- "wycc.lang.SyntaxError: expected type {null data,X next}|{int data,X next}, found X<{null|int data,X|null next}>\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)")
- @Test
- public void test_RecordSubtype_Valid_2() {
- util.exec("RecordSubtype_Valid_2");
- }
-
- @Test
- public void test_RecursiveType_Valid_1() {
- util.exec("RecursiveType_Valid_1");
- }
-
- @Test
- public void test_RecursiveType_Valid_10() {
- util.exec("RecursiveType_Valid_10");
- }
-
- @Test
- public void test_RecursiveType_Valid_11() {
- util.exec("RecursiveType_Valid_11");
- }
-
- @Test
- public void test_RecursiveType_Valid_12() {
- util.exec("RecursiveType_Valid_12");
- }
-
- @Test
- public void test_RecursiveType_Valid_13() {
- util.exec("RecursiveType_Valid_13");
- }
-
- @Test
- public void test_RecursiveType_Valid_14() {
- util.exec("RecursiveType_Valid_14");
- }
-
- @Test
- public void test_RecursiveType_Valid_15() {
- util.exec("RecursiveType_Valid_15");
- }
-
- @Test
- public void test_RecursiveType_Valid_16() {
- util.exec("RecursiveType_Valid_16");
- }
-
- @Test
- public void test_RecursiveType_Valid_17() {
- util.exec("RecursiveType_Valid_17");
- }
-
- @Test
- public void test_RecursiveType_Valid_18() {
- util.exec("RecursiveType_Valid_18");
- }
-
- @Test
- public void test_RecursiveType_Valid_19() {
- util.exec("RecursiveType_Valid_19");
- }
-
- @Test
- public void test_RecursiveType_Valid_2() {
- util.exec("RecursiveType_Valid_2");
- }
-
- @Test
- public void test_RecursiveType_Valid_20() {
- util.exec("RecursiveType_Valid_20");
- }
-
- @Test
- public void test_RecursiveType_Valid_21() {
- util.exec("RecursiveType_Valid_21");
- }
-
-
- @Test
- public void test_RecursiveType_Valid_22() {
- util.exec("RecursiveType_Valid_22");
- }
-
- @Test
- public void test_RecursiveType_Valid_23() {
- util.exec("RecursiveType_Valid_23");
- }
-
- @Test
- public void test_RecursiveType_Valid_24() {
- util.exec("RecursiveType_Valid_24");
- }
-
- @Test
- public void test_RecursiveType_Valid_25() {
- util.exec("RecursiveType_Valid_25");
- }
-
- @Test
- public void test_RecursiveType_Valid_26() {
- util.exec("RecursiveType_Valid_26");
- }
-
- @Test
- public void test_RecursiveType_Valid_27() {
- util.exec("RecursiveType_Valid_27");
- }
-
- /**
- .\RecursiveType_Valid_28.whiley:27: unable to resolve name (no match for get(X,int)
- found: RecursiveType_Valid_28:get : function(RecursiveType_Valid_28:Link,int) => int)
- return get(ls.next,i+1)
- ^^^^^^^^^^^^^^^^
-wycc.lang.SyntaxError: unable to resolve name (no match for get(X,int)
- found: RecursiveType_Valid_28:get : function(RecursiveType_Valid_28:Link,int) => int)
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:253)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:625)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1715)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:797)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:327)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:767)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-Caused by: wycc.util.ResolveError: no match for get(X,int)
- found: RecursiveType_Valid_28:get : function(RecursiveType_Valid_28:Link,int) => int
- at wyc.builder.FlowTypeChecker.selectCandidateFunctionOrMethod(FlowTypeChecker.java:2681)
- at wyc.builder.FlowTypeChecker.resolveAsFunctionOrMethod(FlowTypeChecker.java:2509)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2126)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1681)
- ... 16 more
- */
- @Test
- @Ignore("Issue #364\n"
- + " .\\RecursiveType_Valid_28.whiley:27: unable to resolve name (no match for get(X,int)\r\n" +
- " found: RecursiveType_Valid_28:get : function(RecursiveType_Valid_28:Link,int) => int)\r\n" +
- " return get(ls.next,i+1)\r\n" +
- " ^^^^^^^^^^^^^^^^\r\n" +
- "wycc.lang.SyntaxError: unable to resolve name (no match for get(X,int)\r\n" +
- " found: RecursiveType_Valid_28:get : function(RecursiveType_Valid_28:Link,int) => int)\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:253)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:625)")
- public void test_RecursiveType_Valid_28() {
- util.exec("RecursiveType_Valid_28");
- }
-
- public void test_RecursiveType_Valid_29() {
- util.exec("RecursiveType_Valid_29");
- }
-
-
- /**
- .\RecursiveType_Valid_3.whiley:19: record required, got: X<[Y src}|{Z<{Z index,Z src}|int|real|[Z]> index,Y src}>+]>|{Z<{Z index,Z src}|int|real|[Z]> index,Z<{Z index,Z src}|int|real|[Z]> src}
- Value src = evaluate(e.src)
- ^^^^^
-wycc.lang.SyntaxError: record required, got: X<[Y src}|{Z<{Z index,Z src}|int|real|[Z]> index,Y src}>+]>|{Z<{Z index,Z src}|int|real|[Z]> index,Z<{Z index,Z src}|int|real|[Z]> src}
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2327)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1674)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2108)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1681)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:428)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:323)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:767)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:767)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-
- */
- @Test
- @Ignore("Issue #406\n"
- + ".\\RecursiveType_Valid_3.whiley:19: record required, got: X<[Y src}|{Z<{Z index,Z src}|int|real|[Z]> index,Y src}>+]>|{Z<{Z index,Z src}|int|real|[Z]> index,Z<{Z index,Z src}|int|real|[Z]> src}\r\n" +
- " Value src = evaluate(e.src)\r\n" +
- " ^^^^^\r\n" +
- "wycc.lang.SyntaxError: record required, got: X<[Y src}|{Z<{Z index,Z src}|int|real|[Z]> index,Y src}>+]>|{Z<{Z index,Z src}|int|real|[Z]> index,Z<{Z index,Z src}|int|real|[Z]> src}\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)")
- public void test_RecursiveType_Valid_3() {
- util.exec("RecursiveType_Valid_3");
- }
-
- public void test_RecursiveType_Valid_30() {
- util.exec("RecursiveType_Valid_30");
- }
-
- public void test_RecursiveType_Valid_31() {
- util.exec("RecursiveType_Valid_31");
- }
-
- /**
- .\RecursiveType_Valid_4.whiley:23: record required, got: X<[Y src}|{Z<{Z index,Z src}|int|real|[Z]> index,Y src}>+]>|{Z<{Z index,Z src}|int|real|[Z]> index,Z<{Z index,Z src}|int|real|[Z]> src}
- null|Value src = evaluate(e.src)
- ^^^^^
-wycc.lang.SyntaxError: record required, got: X<[Y src}|{Z<{Z index,Z src}|int|real|[Z]> index,Y src}>+]>|{Z<{Z index,Z src}|int|real|[Z]> index,Z<{Z index,Z src}|int|real|[Z]> src}
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2327)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1674)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2108)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1681)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:428)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:323)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:767)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:767)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Test
- @Ignore("Issue #406\n"
- + ".\\RecursiveType_Valid_4.whiley:23: record required, got: X<[Y src}|{Z<{Z index,Z src}|int|real|[Z]> index,Y src}>+]>|{Z<{Z index,Z src}|int|real|[Z]> index,Z<{Z index,Z src}|int|real|[Z]> src}\r\n" +
- " null|Value src = evaluate(e.src)\r\n" +
- " ^^^^^\r\n" +
- "wycc.lang.SyntaxError: record required, got: X<[Y src}|{Z<{Z index,Z src}|int|real|[Z]> index,Y src}>+]>|{Z<{Z index,Z src}|int|real|[Z]> index,Z<{Z index,Z src}|int|real|[Z]> src}\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)")
- public void test_RecursiveType_Valid_4() {
- util.exec("RecursiveType_Valid_4");
- }
- /**
- * .\RecursiveType_Valid_5.whiley:6: expected type X<{[int] items,X|null next}>, found null
- Link start = null
- ^^^^
-wycc.lang.SyntaxError: expected type X<{[int] items,X|null next}>, found null
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.builder.FlowTypeChecker.checkIsSubtype(FlowTypeChecker.java:4070)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:429)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:323)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-
- */
- @Ignore("Issue #18\n"
- + " .\\RecursiveType_Valid_5.whiley:6: expected type X<{[int] items,X|null next}>, found null\r\n" +
- " Link start = null\r\n" +
- " ^^^^\r\n" +
- "wycc.lang.SyntaxError: expected type X<{[int] items,X|null next}>, found null\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.builder.FlowTypeChecker.checkIsSubtype(FlowTypeChecker.java:4070)")
- @Test
- public void test_RecursiveType_Valid_5() {
- util.exec("RecursiveType_Valid_5");
- }
-
- @Test
- public void test_RecursiveType_Valid_6() {
- util.exec("RecursiveType_Valid_6");
- }
-
- @Test
- public void test_RecursiveType_Valid_7() {
- util.exec("RecursiveType_Valid_7");
- }
-
- @Test
- public void test_RecursiveType_Valid_8() {
- util.exec("RecursiveType_Valid_8");
- }
-
- @Test
- public void test_RecursiveType_Valid_9() {
- util.exec("RecursiveType_Valid_9");
- }
-
- @Test
- public void test_Reference_Valid_1() {
- util.exec("Reference_Valid_1");
- }
-
- @Test
- public void test_Reference_Valid_2() {
- util.exec("Reference_Valid_2");
- }
-
- @Test
- public void test_Reference_Valid_3() {
- util.exec("Reference_Valid_3");
- }
-
-
- @Test
- public void test_Reference_Valid_4() {
- util.exec("Reference_Valid_4");
- }
-
- @Test
- public void test_Reference_Valid_5() {
- util.exec("Reference_Valid_5");
- }
-
- @Test
- public void test_Remainder_Valid_1() {
- util.exec("Remainder_Valid_1");
- }
-
- @Test
- public void test_Requires_Valid_1() {
- util.exec("Requires_Valid_1");
- }
-
- @Test
- public void test_Resolution_Valid_1() {
- util.exec("Resolution_Valid_1");
- }
-
- @Test
- public void test_SetAssign_Valid_1() {
- util.exec("SetAssign_Valid_1");
- }
-
- @Test
- public void test_SetAssign_Valid_2() {
- util.exec("SetAssign_Valid_2");
- }
-
- @Test
- public void test_SetAssign_Valid_3() {
- util.exec("SetAssign_Valid_3");
- }
-
- @Test
- public void test_SetComprehension_Valid_1() {
- util.exec("SetComprehension_Valid_1");
- }
-
- @Test
- public void test_SetComprehension_Valid_10() {
- util.exec("SetComprehension_Valid_10");
- }
-
- @Test
- public void test_SetComprehension_Valid_11() {
- util.exec("SetComprehension_Valid_11");
- }
-
- @Test
- public void test_SetComprehension_Valid_12() {
- util.exec("SetComprehension_Valid_12");
- }
-
- @Test
- public void test_SetComprehension_Valid_2() {
- util.exec("SetComprehension_Valid_2");
- }
-
- @Test
- public void test_SetComprehension_Valid_3() {
- util.exec("SetComprehension_Valid_3");
- }
-
- @Test
- public void test_SetComprehension_Valid_4() {
- util.exec("SetComprehension_Valid_4");
- }
-
- @Test
- public void test_SetComprehension_Valid_5() {
- util.exec("SetComprehension_Valid_5");
- }
-
- @Test
- public void test_SetComprehension_Valid_6() {
- util.exec("SetComprehension_Valid_6");
- }
-
- @Test
- public void test_SetComprehension_Valid_7() {
- util.exec("SetComprehension_Valid_7");
- }
-
- @Test
- public void test_SetComprehension_Valid_8() {
- util.exec("SetComprehension_Valid_8");
- }
-
- @Test
- public void test_SetComprehension_Valid_9() {
- util.exec("SetComprehension_Valid_9");
- }
-
- @Test
- public void test_SetConversion_Valid_1() {
- util.exec("SetConversion_Valid_1");
- }
-
- @Test
- public void test_SetDefine_Valid_1() {
- util.exec("SetDefine_Valid_1");
- }
-
- @Test
- public void test_SetDefine_Valid_2() {
- util.exec("SetDefine_Valid_2");
- }
-
- @Test
- public void test_SetDefine_Valid_3() {
- util.exec("SetDefine_Valid_3");
- }
-
- @Test
- public void test_SetDifference_Valid_1() {
- util.exec("SetDifference_Valid_1");
- }
-
- @Test
- public void test_SetElemOf_Valid_1() {
- util.exec("SetElemOf_Valid_1");
- }
-
- @Test
- public void test_SetEmpty_Valid_1() {
- util.exec("SetEmpty_Valid_1");
- }
-
- @Test
- public void test_SetEquals_Valid_1() {
- util.exec("SetEquals_Valid_1");
- }
-
- @Test
- public void test_SetGenerator_Valid_1() {
- util.exec("SetGenerator_Valid_1");
- }
-
- @Test
- public void test_SetIntersect_Valid_1() {
- util.exec("SetIntersect_Valid_1");
- }
-
- @Test
- public void test_SetIntersect_Valid_2() {
- util.exec("SetIntersect_Valid_2");
- }
-
- @Test
- public void test_SetIntersection_Valid_1() {
- util.exec("SetIntersection_Valid_1");
- }
-
- @Test
- public void test_SetIntersection_Valid_2() {
- util.exec("SetIntersection_Valid_2");
- }
-
- @Test
- public void test_SetIntersection_Valid_3() {
- util.exec("SetIntersection_Valid_3");
- }
-
- @Test
- public void test_SetIntersection_Valid_4() {
- util.exec("SetIntersection_Valid_4");
- }
-
- @Test
- public void test_SetIntersection_Valid_5() {
- util.exec("SetIntersection_Valid_5");
- }
-
- @Test
- public void test_SetIntersection_Valid_6() {
- util.exec("SetIntersection_Valid_6");
- }
-
- @Test
- public void test_SetIntersection_Valid_7() {
- util.exec("SetIntersection_Valid_7");
- }
-
- @Test
- public void test_SetLength_Valid_1() {
- util.exec("SetLength_Valid_1");
- }
-
- @Test
- public void test_SetNull_Valid_1() {
- util.exec("SetNull_Valid_1");
- }
-
- @Test
- public void test_SetSubset_Valid_1() {
- util.exec("SetSubset_Valid_1");
- }
-
- @Test
- public void test_SetSubset_Valid_10() {
- util.exec("SetSubset_Valid_10");
- }
-
- @Test
- public void test_SetSubset_Valid_11() {
- util.exec("SetSubset_Valid_11");
- }
-
- @Test
- public void test_SetSubset_Valid_12() {
- util.exec("SetSubset_Valid_12");
- }
-
- @Test
- public void test_SetSubset_Valid_2() {
- util.exec("SetSubset_Valid_2");
- }
-
- @Test
- public void test_SetSubset_Valid_3() {
- util.exec("SetSubset_Valid_3");
- }
-
- @Test
- public void test_SetSubset_Valid_4() {
- util.exec("SetSubset_Valid_4");
- }
-
- @Test
- public void test_SetSubset_Valid_5() {
- util.exec("SetSubset_Valid_5");
- }
-
- @Test
- public void test_SetSubset_Valid_6() {
- util.exec("SetSubset_Valid_6");
- }
-
- @Test
- public void test_SetSubset_Valid_7() {
- util.exec("SetSubset_Valid_7");
- }
-
- @Test
- public void test_SetSubset_Valid_8() {
- util.exec("SetSubset_Valid_8");
- }
-
- @Test
- public void test_SetSubset_Valid_9() {
- util.exec("SetSubset_Valid_9");
- }
-
- @Test
- public void test_SetUnion_Valid_1() {
- util.exec("SetUnion_Valid_1");
- }
-
- @Test
- public void test_SetUnion_Valid_10() {
- util.exec("SetUnion_Valid_10");
- }
-
- @Test
- public void test_SetUnion_Valid_11() {
- util.exec("SetUnion_Valid_11");
- }
-
- @Test
- public void test_SetUnion_Valid_2() {
- util.exec("SetUnion_Valid_2");
- }
-
- @Test
- public void test_SetUnion_Valid_3() {
- util.exec("SetUnion_Valid_3");
- }
-
- @Test
- public void test_SetUnion_Valid_4() {
- util.exec("SetUnion_Valid_4");
- }
-
- @Test
- public void test_SetUnion_Valid_5() {
- util.exec("SetUnion_Valid_5");
- }
-
- @Test
- public void test_SetUnion_Valid_6() {
- util.exec("SetUnion_Valid_6");
- }
-
- @Test
- public void test_SetUnion_Valid_7() {
- util.exec("SetUnion_Valid_7");
- }
-
- @Test
- public void test_SetUnion_Valid_8() {
- util.exec("SetUnion_Valid_8");
- }
-
- @Test
- public void test_SetUnion_Valid_9() {
- util.exec("SetUnion_Valid_9");
- }
-
- @Test
- public void test_Skip_Valid_1() {
- util.exec("Skip_Valid_1");
- }
-
- @Test
- public void test_String_Valid_1() {
- util.exec("String_Valid_1");
- }
-
- @Test
- public void test_String_Valid_2() {
- util.exec("String_Valid_2");
- }
-
- @Test
- public void test_String_Valid_3() {
- util.exec("String_Valid_3");
- }
-
- @Test
- public void test_String_Valid_4() {
- util.exec("String_Valid_4");
- }
-
- @Test
- public void test_String_Valid_5() {
- util.exec("String_Valid_5");
- }
-
- @Test
- public void test_String_Valid_6() {
- util.exec("String_Valid_6");
- }
-
- @Test
- public void test_String_Valid_7() {
- util.exec("String_Valid_7");
- }
-
- @Test
- public void test_String_Valid_8() {
- util.exec("String_Valid_8");
- }
-
- @Test
- public void test_Subtype_Valid_1() {
- util.exec("Subtype_Valid_1");
- }
-
- @Test
- public void test_Subtype_Valid_10() {
- util.exec("Subtype_Valid_10");
- }
-
- @Test
- public void test_Subtype_Valid_11() {
- util.exec("Subtype_Valid_11");
- }
-
- @Test
- public void test_Subtype_Valid_12() {
- util.exec("Subtype_Valid_12");
- }
-
- @Test
- public void test_Subtype_Valid_13() {
- util.exec("Subtype_Valid_13");
- }
-
- @Test
- public void test_Subtype_Valid_14() {
- util.exec("Subtype_Valid_14");
- }
-
- @Test
- public void test_Subtype_Valid_2() {
- util.exec("Subtype_Valid_2");
- }
-
- @Test
- public void test_Subtype_Valid_3() {
- util.exec("Subtype_Valid_3");
- }
-
- @Test
- public void test_Subtype_Valid_4() {
- util.exec("Subtype_Valid_4");
- }
-
- @Test
- public void test_Subtype_Valid_5() {
- util.exec("Subtype_Valid_5");
- }
-
- @Test
- public void test_Subtype_Valid_6() {
- util.exec("Subtype_Valid_6");
- }
-
- @Test
- public void test_Subtype_Valid_7() {
- util.exec("Subtype_Valid_7");
- }
-
- @Test
- public void test_Subtype_Valid_8() {
- util.exec("Subtype_Valid_8");
- }
-
- @Test
- public void test_Subtype_Valid_9() {
- util.exec("Subtype_Valid_9");
- }
-
- @Test
- public void test_Switch_Valid_1() {
- util.exec("Switch_Valid_1");
- }
-
- @Test
- public void test_Switch_Valid_10() {
- util.exec("Switch_Valid_10");
- }
-
- @Test
- public void test_Switch_Valid_11() {
- util.exec("Switch_Valid_11");
- }
-
- @Test
- public void test_Switch_Valid_12() {
- util.exec("Switch_Valid_12");
- }
-
- @Test
- public void test_Switch_Valid_13() {
- util.exec("Switch_Valid_13");
- }
-
- @Test
- public void test_Switch_Valid_2() {
- util.exec("Switch_Valid_2");
- }
-
- @Test
- public void test_Switch_Valid_3() {
- util.exec("Switch_Valid_3");
- }
-
- @Test
- public void test_Switch_Valid_4() {
- util.exec("Switch_Valid_4");
- }
-
- @Test
- public void test_Switch_Valid_5() {
- util.exec("Switch_Valid_5");
- }
-
- @Test
- public void test_Switch_Valid_6() {
- util.exec("Switch_Valid_6");
- }
-
- @Test
- public void test_Switch_Valid_7() {
- util.exec("Switch_Valid_7");
- }
-
- @Test
- public void test_Switch_Valid_8() {
- util.exec("Switch_Valid_8");
- }
-
- @Test
- public void test_Switch_Valid_9() {
- util.exec("Switch_Valid_9");
- }
-
- @Test
- public void test_Syntax_Valid_1() {
- util.exec("Syntax_Valid_1");
- }
-
- @Test
- public void test_TryCatch_Valid_1() {
- util.exec("TryCatch_Valid_1");
- }
-
- @Test
- public void test_TryCatch_Valid_2() {
- util.exec("TryCatch_Valid_2");
- }
-
- @Test
- public void test_TryCatch_Valid_3() {
- util.exec("TryCatch_Valid_3");
- }
-
- @Test
- public void test_TryCatch_Valid_4() {
- util.exec("TryCatch_Valid_4");
- }
-
- @Test
- public void test_TupleType_Valid_1() {
- util.exec("TupleType_Valid_1");
- }
-
- @Test
- public void test_TupleType_Valid_2() {
- util.exec("TupleType_Valid_2");
- }
-
- @Test
- public void test_TupleType_Valid_3() {
- util.exec("TupleType_Valid_3");
- }
-
- @Test
- public void test_TupleType_Valid_4() {
- util.exec("TupleType_Valid_4");
- }
-
- @Test
- public void test_TupleType_Valid_5() {
- util.exec("TupleType_Valid_5");
- }
-
- @Test
- public void test_TupleType_Valid_6() {
- util.exec("TupleType_Valid_6");
- }
-
- @Test
- public void test_TupleType_Valid_7() {
- util.exec("TupleType_Valid_7");
- }
-
- @Test
- public void test_TupleType_Valid_8() {
- util.exec("TupleType_Valid_8");
- }
-
- @Test
- public void test_TypeEquals_Valid_1() {
- util.exec("TypeEquals_Valid_1");
- }
-
- @Test
- public void test_TypeEquals_Valid_10() {
- util.exec("TypeEquals_Valid_10");
- }
-
- @Test
- public void test_TypeEquals_Valid_11() {
- util.exec("TypeEquals_Valid_11");
- }
-
- @Test
- public void test_TypeEquals_Valid_12() {
- util.exec("TypeEquals_Valid_12");
- }
-
- @Test
- public void test_TypeEquals_Valid_13() {
- util.exec("TypeEquals_Valid_13");
- }
-
- @Test
- public void test_TypeEquals_Valid_14() {
- util.exec("TypeEquals_Valid_14");
- }
-
- @Test
- public void test_TypeEquals_Valid_15() {
- util.exec("TypeEquals_Valid_15");
- }
-
- @Test
- public void test_TypeEquals_Valid_16() {
- util.exec("TypeEquals_Valid_16");
- }
-
- @Test
- public void test_TypeEquals_Valid_17() {
- util.exec("TypeEquals_Valid_17");
- }
-
- @Test
- public void test_TypeEquals_Valid_18() {
- util.exec("TypeEquals_Valid_18");
- }
-
- @Test
- public void test_TypeEquals_Valid_19() {
- util.exec("TypeEquals_Valid_19");
- }
-
- @Test
- public void test_TypeEquals_Valid_2() {
- util.exec("TypeEquals_Valid_2");
- }
-
- @Test
- public void test_TypeEquals_Valid_20() {
- util.exec("TypeEquals_Valid_20");
- }
-
- @Test
- public void test_TypeEquals_Valid_21() {
- util.exec("TypeEquals_Valid_21");
- }
-
- @Test
- public void test_TypeEquals_Valid_22() {
- util.exec("TypeEquals_Valid_22");
- }
-
- /**
- * .\TypeEquals_Valid_23.whiley:11: expecting int or real or char, found TypeEquals_Valid_23:expr
- return e + 1
- ^
-wycc.lang.SyntaxError: expecting int or real or char, found TypeEquals_Valid_23:expr
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)
- at wyc.builder.FlowTypeChecker.checkSuptypes(FlowTypeChecker.java:4133)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1883)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1660)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:797)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:327)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:767)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-
- */
- @Ignore("Issue ???\n"
- + ".\\TypeEquals_Valid_23.whiley:11: expecting int or real or char, found TypeEquals_Valid_23:expr\r\n" +
- " return e + 1\r\n" +
- " ^\r\n" +
- "wycc.lang.SyntaxError: expecting int or real or char, found TypeEquals_Valid_23:expr\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)\r\n" +
- " at wyc.builder.FlowTypeChecker.checkSuptypes(FlowTypeChecker.java:4133)")
- @Test
- public void test_TypeEquals_Valid_23() {
- util.exec("TypeEquals_Valid_23");
- }
-
- @Test
- public void test_TypeEquals_Valid_24() {
- util.exec("TypeEquals_Valid_24");
- }
-
- @Test
- public void test_TypeEquals_Valid_25() {
- util.exec("TypeEquals_Valid_25");
- }
-
- @Test
- public void test_TypeEquals_Valid_26() {
- util.exec("TypeEquals_Valid_26");
- }
-
- @Test
- public void test_TypeEquals_Valid_27() {
- util.exec("TypeEquals_Valid_27");
- }
-
- @Test
- public void test_TypeEquals_Valid_28() {
- util.exec("TypeEquals_Valid_28");
- }
-
- @Test
- public void test_TypeEquals_Valid_29() {
- util.exec("TypeEquals_Valid_29");
- }
-/**
- * .\TypeEquals_Valid_3.whiley:6: unknown variable
- r = []
- ^
-wycc.lang.SyntaxError: unknown variable
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1021)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:462)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:325)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-
- */
- @Ignore("Issue ???\n"
- + ".\\TypeEquals_Valid_3.whiley:6: unknown variable\r\n" +
- " r = []\r\n" +
- " ^\r\n" +
- "wycc.lang.SyntaxError: unknown variable\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)")
- @Test
- public void test_TypeEquals_Valid_3() {
- util.exec("TypeEquals_Valid_3");
- }
-
- @Test
- public void test_TypeEquals_Valid_30() {
- util.exec("TypeEquals_Valid_30");
- }
-
- @Test
- public void test_TypeEquals_Valid_31() {
- util.exec("TypeEquals_Valid_31");
- }
-
- @Test
- public void test_TypeEquals_Valid_32() {
- util.exec("TypeEquals_Valid_32");
- }
-
- @Test
- public void test_TypeEquals_Valid_33() {
- util.exec("TypeEquals_Valid_33");
- }
-
- @Test
- public void test_TypeEquals_Valid_34() {
- util.exec("TypeEquals_Valid_34");
- }
-
- @Test
- public void test_TypeEquals_Valid_35() {
- util.exec("TypeEquals_Valid_35");
- }
-/**
- * .\TypeEquals_Valid_36.whiley:10: found int|[int], expected string, set, list or dictionary.
- if (t.lhs is plist) && ((|t.lhs| > 0) && (t.lhs[0] == 0)):
- ^^^^^
-wycc.lang.SyntaxError: found int|[int], expected string, set, list or dictionary.
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2173)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1691)
- at wyc.builder.FlowTypeChecker.resolveLeafCondition(FlowTypeChecker.java:1458)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1356)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.resolveNonLeafCondition(FlowTypeChecker.java:1396)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1345)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.resolveNonLeafCondition(FlowTypeChecker.java:1398)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1345)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:755)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Ignore("Issue ???\n"
- + ".\\TypeEquals_Valid_36.whiley:10: found int|[int], expected string, set, list or dictionary.\r\n" +
- " if (t.lhs is plist) && ((|t.lhs| > 0) && (t.lhs[0] == 0)):\r\n" +
- " ^^^^^\r\n" +
- "wycc.lang.SyntaxError: found int|[int], expected string, set, list or dictionary.\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)")
- @Test
- public void test_TypeEquals_Valid_36() {
- util.exec("TypeEquals_Valid_36");
- }
-/**
- * .\TypeEquals_Valid_37.whiley:10: found int|[int], expected string, set, list or dictionary.
- if (t.lhs is plist) && ((|t.lhs| > 0) && (t.lhs[0] == 0)):
- ^^^^^
-wycc.lang.SyntaxError: found int|[int], expected string, set, list or dictionary.
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2173)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1691)
- at wyc.builder.FlowTypeChecker.resolveLeafCondition(FlowTypeChecker.java:1458)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1356)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.resolveNonLeafCondition(FlowTypeChecker.java:1396)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1345)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.resolveNonLeafCondition(FlowTypeChecker.java:1398)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1345)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:755)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-
- */
- @Ignore("Issue ???\n"
- + ".\\TypeEquals_Valid_37.whiley:10: found int|[int], expected string, set, list or dictionary.\r\n" +
- " if (t.lhs is plist) && ((|t.lhs| > 0) && (t.lhs[0] == 0)):\r\n" +
- " ^^^^^\r\n" +
- "wycc.lang.SyntaxError: found int|[int], expected string, set, list or dictionary.\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)")
- @Test
- public void test_TypeEquals_Valid_37() {
- util.exec("TypeEquals_Valid_37");
- }
-
- /***
- * .\TypeEquals_Valid_38.whiley:8: found int|[int], expected string, set, list or dictionary.
- if (t.lhs is [int]) && ((|t.lhs| > 0) && (t.lhs[0] == 0)):
- ^^^^^
-wycc.lang.SyntaxError: found int|[int], expected string, set, list or dictionary.
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:2173)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:1691)
- at wyc.builder.FlowTypeChecker.resolveLeafCondition(FlowTypeChecker.java:1458)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1356)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.resolveNonLeafCondition(FlowTypeChecker.java:1396)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1345)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.resolveNonLeafCondition(FlowTypeChecker.java:1398)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1345)
- at wyc.builder.FlowTypeChecker.propagateCondition(FlowTypeChecker.java:1263)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:755)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
- */
- @Ignore("Issue ???\n"
- + ".\\TypeEquals_Valid_38.whiley:8: found int|[int], expected string, set, list or dictionary.\r\n" +
- " if (t.lhs is [int]) && ((|t.lhs| > 0) && (t.lhs[0] == 0)):\r\n" +
- " ^^^^^\r\n" +
- "wycc.lang.SyntaxError: found int|[int], expected string, set, list or dictionary.\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.lang.WhileyFile.syntaxError(WhileyFile.java:620)")
- @Test
- public void test_TypeEquals_Valid_38() {
- util.exec("TypeEquals_Valid_38");
- }
-
- @Test
- public void test_TypeEquals_Valid_39() {
- util.exec("TypeEquals_Valid_39");
- }
-
- @Test
- public void test_TypeEquals_Valid_40() {
- util.exec("TypeEquals_Valid_40");
- }
-/**
- * .\TypeEquals_Valid_41.whiley:11: expected type int, found TypeEquals_Valid_41:expr
- return e
- ^
-wycc.lang.SyntaxError: expected type int, found TypeEquals_Valid_41:expr
- at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)
- at wyc.builder.FlowTypeChecker.checkIsSubtype(FlowTypeChecker.java:4060)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:799)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:327)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:767)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:329)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:298)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:264)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:145)
- at wyc.builder.FlowTypeChecker.propagate(FlowTypeChecker.java:135)
- at wyc.builder.WhileyBuilder.build(WhileyBuilder.java:181)
- at wybs.util.StdBuildRule.apply(StdBuildRule.java:109)
- at wybs.util.StdProject.build(StdProject.java:256)
- at wyc.util.WycBuildTask.buildEntries(WycBuildTask.java:503)
- at wyc.util.WycBuildTask.build(WycBuildTask.java:471)
- at wyopcl.WyopclMain.run(WyopclMain.java:119)
- at wyopcl.WyopclMain.main(WyopclMain.java:148)
-
- */
- @Ignore("Issue ???\n"
- + ".\\TypeEquals_Valid_41.whiley:11: expected type int, found TypeEquals_Valid_41:expr\r\n" +
- " return e\r\n" +
- " ^\r\n" +
- "wycc.lang.SyntaxError: expected type int, found TypeEquals_Valid_41:expr\r\n" +
- " at wycc.lang.SyntaxError.syntaxError(SyntaxError.java:238)\r\n" +
- " at wyc.builder.FlowTypeChecker.checkIsSubtype(FlowTypeChecker.java:4060)")
- @Test
- public void test_TypeEquals_Valid_41() {
- util.exec("TypeEquals_Valid_41");
- }
-
- @Test
- public void test_TypeEquals_Valid_42() {
- util.exec("TypeEquals_Valid_42");
- }
-
- @Test
- public void test_TypeEquals_Valid_43() {
- util.exec("TypeEquals_Valid_43");
- }
-
- @Test
- public void test_TypeEquals_Valid_44() {
- util.exec("TypeEquals_Valid_44");
- }
-
- @Test
- public void test_TypeEquals_Valid_45() {
- util.exec("TypeEquals_Valid_45");
- }
-
- @Test
- public void test_TypeEquals_Valid_46() {
- util.exec("TypeEquals_Valid_46");
- }
-
- @Test
- public void test_TypeEquals_Valid_47() {
- util.exec("TypeEquals_Valid_47");
- }
-
- @Test
- public void test_TypeEquals_Valid_5() {
- util.exec("TypeEquals_Valid_5");
- }
-
- @Test
- public void test_TypeEquals_Valid_6() {
- util.exec("TypeEquals_Valid_6");
- }
-
- @Test
- public void test_TypeEquals_Valid_7() {
- util.exec("TypeEquals_Valid_7");
- }
-
- @Test
- public void test_TypeEquals_Valid_8() {
- util.exec("TypeEquals_Valid_8");
- }
-
- @Test
- public void test_TypeEquals_Valid_9() {
- util.exec("TypeEquals_Valid_9");
- }
-
- @Test
- public void test_UnionType_Valid_1() {
- util.exec("UnionType_Valid_1");
- }
-
- @Test
- public void test_UnionType_Valid_10() {
- util.exec("UnionType_Valid_10");
- }
-
- @Test
- public void test_UnionType_Valid_11() {
- util.exec("UnionType_Valid_11");
- }
-
- @Test
- public void test_UnionType_Valid_12() {
- util.exec("UnionType_Valid_12");
- }
-
- @Test
- public void test_UnionType_Valid_13() {
- util.exec("UnionType_Valid_13");
- }
-
- @Test
- public void test_UnionType_Valid_14() {
- util.exec("UnionType_Valid_14");
- }
-
- @Test
- public void test_UnionType_Valid_15() {
- util.exec("UnionType_Valid_15");
- }
-
- @Test
- public void test_UnionType_Valid_16() {
- util.exec("UnionType_Valid_16");
- }
-
- @Test
- @Ignore("Issue ???")
- public void test_UnionType_Valid_17() {
- util.exec("UnionType_Valid_17");
- }
-
- @Test
- public void test_UnionType_Valid_18() {
- util.exec("UnionType_Valid_18");
- }
-
- @Test
- public void test_UnionType_Valid_19() {
- util.exec("UnionType_Valid_19");
- }
-
- @Test
- public void test_UnionType_Valid_2() {
- util.exec("UnionType_Valid_2");
- }
-
- @Test
- public void test_UnionType_Valid_20() {
- util.exec("UnionType_Valid_20");
- }
-
- @Test
- public void test_UnionType_Valid_21() {
- util.exec("UnionType_Valid_21");
- }
-
- @Test
- public void test_UnionType_Valid_22() {
- util.exec("UnionType_Valid_22");
- }
-
- @Test
- public void test_UnionType_Valid_23() {
- util.exec("UnionType_Valid_23");
- }
-
- @Test
- public void test_UnionType_Valid_3() {
- util.exec("UnionType_Valid_3");
- }
-
- @Test
- public void test_UnionType_Valid_4() {
- util.exec("UnionType_Valid_4");
- }
-
- @Test
- public void test_UnionType_Valid_5() {
- util.exec("UnionType_Valid_5");
- }
-
- @Test
- public void test_UnionType_Valid_6() {
- util.exec("UnionType_Valid_6");
- }
-
- @Test
- public void test_UnionType_Valid_7() {
- util.exec("UnionType_Valid_7");
- }
-
- @Test
- public void test_UnionType_Valid_8() {
- util.exec("UnionType_Valid_8");
- }
-
- @Test
- public void test_UnionType_Valid_9() {
- util.exec("UnionType_Valid_9");
- }
-
- @Ignore("Issue ???")
- @Test
- public void test_Update_Valid_1() {
- util.exec("Update_Valid_1");
- }
- @Ignore("Issue ???")
- @Test
- public void test_Update_Valid_2() {
- util.exec("Update_Valid_2");
- }
-
- @Test
- public void test_VarDecl_Valid_1() {
- util.exec("VarDecl_Valid_1");
- }
-
- @Test
- public void test_VarDecl_Valid_2() {
- util.exec("VarDecl_Valid_2");
- }
-
- @Test
- public void test_VarDecl_Valid_3() {
- util.exec("VarDecl_Valid_3");
- }
-
- @Test
- public void test_VarDecl_Valid_4() {
- util.exec("VarDecl_Valid_4");
- }
-
- @Test
- public void test_While_Valid_1() {
- util.exec("While_Valid_1");
- }
-
- @Test
- public void test_While_Valid_10() {
- util.exec("While_Valid_10");
- }
-
- @Test
- public void test_While_Valid_11() {
- util.exec("While_Valid_11");
- }
-
- @Test
- public void test_While_Valid_12() {
- util.exec("While_Valid_12");
- }
-
- @Test
- public void test_While_Valid_14() {
- util.exec("While_Valid_14");
- }
-
- @Test
- public void test_While_Valid_15() {
- util.exec("While_Valid_15");
- }
-
- @Test
- public void test_While_Valid_16() {
- util.exec("While_Valid_16");
- }
-
- @Test
- public void test_While_Valid_17() {
- util.exec("While_Valid_17");
- }
-
- @Test
- public void test_While_Valid_18() {
- util.exec("While_Valid_18");
- }
-
- @Test
- public void test_While_Valid_19() {
- util.exec("While_Valid_19");
- }
-
- @Test
- public void test_While_Valid_2() {
- util.exec("While_Valid_2");
- }
-
- @Test
- public void test_While_Valid_20() {
- util.exec("While_Valid_20");
- }
-
- @Test
- public void test_While_Valid_21() {
- util.exec("While_Valid_21");
- }
-
- @Test
- public void test_While_Valid_22() {
- util.exec("While_Valid_22");
- }
-
- @Test
- public void test_While_Valid_23() {
- util.exec("While_Valid_23");
- }
-
- @Test
- public void test_While_Valid_24() {
- util.exec("While_Valid_24");
- }
-
- @Test
- public void test_While_Valid_25() {
- util.exec("While_Valid_25");
- }
-
- @Test
- public void test_While_Valid_26() {
- util.exec("While_Valid_26");
- }
-
- @Test
- public void test_While_Valid_27() {
- util.exec("While_Valid_27");
- }
-
- @Test
- public void test_While_Valid_28() {
- util.exec("While_Valid_28");
- }
-
- @Test
- public void test_While_Valid_29() {
- util.exec("While_Valid_29");
- }
-
- @Test
- public void test_While_Valid_3() {
- util.exec("While_Valid_3");
- }
-
- @Test
- public void test_While_Valid_30() {
- util.exec("While_Valid_30");
- }
-
- @Test
- public void test_While_Valid_31() {
- util.exec("While_Valid_31");
- }
-
- @Test
- public void test_While_Valid_32() {
- util.exec("While_Valid_32");
- }
-
- @Test
- public void test_While_Valid_33() {
- util.exec("While_Valid_33");
- }
-
- @Test
- public void test_While_Valid_34() {
- util.exec("While_Valid_34");
- }
-
- @Test
- public void test_While_Valid_35() {
- util.exec("While_Valid_35");
- }
-
- @Test
- public void test_While_Valid_36() {
- util.exec("While_Valid_36");
- }
-
- @Test
- public void test_While_Valid_37() {
- util.exec("While_Valid_37");
- }
-
- @Test
- public void test_While_Valid_38() {
- util.exec("While_Valid_38");
- }
-
- @Test
- public void test_While_Valid_39() {
- util.exec("While_Valid_39");
- }
-
- @Test
- public void test_While_Valid_40() {
- util.exec("While_Valid_40");
- }
-
- @Test
- public void test_While_Valid_41() {
- util.exec("While_Valid_41");
- }
-
- @Test
- public void test_While_Valid_42() {
- util.exec("While_Valid_42");
- }
-
- @Test
- public void test_While_Valid_43() {
- util.exec("While_Valid_43");
- }
-
- public void test_While_Valid_5() {
- util.exec("While_Valid_5");
- }
-
- public void test_While_Valid_7() {
- util.exec("While_Valid_7");
- }
-
- @Test
- public void test_While_Valid_9() {
- util.exec("While_Valid_9");
- }
-
-}
\ No newline at end of file
diff --git a/modules/wyopcl/test/wyopcl/testing/interpreter/BaseTestUtil.java b/modules/wyopcl/test/wyopcl/testing/interpreter/BaseTestUtil.java
deleted file mode 100644
index 213387925a..0000000000
--- a/modules/wyopcl/test/wyopcl/testing/interpreter/BaseTestUtil.java
+++ /dev/null
@@ -1,142 +0,0 @@
-package wyopcl.testing.interpreter;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.nio.charset.Charset;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.util.Iterator;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-import wyc.testing.TestUtils;
-import junit.framework.AssertionFailedError;
-import static org.junit.Assert.*;
-
-public final class BaseTestUtil {
- private final String version = "v0.3.31";
- // user.dir is the current directory.
- private final String WHILEY_BASE_DIR = "../../".replace("/",File.separator);
- private final String WHILEY_LIB_DIR = WHILEY_BASE_DIR + "lib"+ File.separator;
-
- private final String classpath = WHILEY_LIB_DIR + "wyjc-" + version + ".jar" + File.pathSeparator
- + WHILEY_LIB_DIR + "wyopcl-" + version + ".jar" + File.pathSeparator
- + WHILEY_LIB_DIR + "wyrl-" + version + ".jar" + File.pathSeparator
- + WHILEY_LIB_DIR + "wycs-" + version + ".jar" + File.pathSeparator
- + WHILEY_LIB_DIR + "wybs-"+ version + ".jar" + File.pathSeparator
- + WHILEY_LIB_DIR + "wyil-" + version + ".jar" + File.pathSeparator
- + WHILEY_LIB_DIR + "wyc-" + version + ".jar" + File.pathSeparator;
- final String runtime = WHILEY_LIB_DIR + "wyrt-" + version + ".jar";
-
- final String valid_path = WHILEY_BASE_DIR + "tests" + File.separator + "valid" + File.separator;
- final String invalid_path = WHILEY_BASE_DIR + "tests" + File.separator + "invalid" + File.separator;
-
- private ProcessBuilder pb;
- private Process p;
-
- public BaseTestUtil() {
-
- }
-
- public void exec(String file_name) {
- if (file_name.matches(".*_Invalid_*.")) {
- exec_invalid(file_name);
- } else {
- exec_valid(file_name);
- }
-
- }
-
- private void exec_valid(String file_name) {
- try {
-
- // Run the whiley program with interpreter.
- String path_whiley = file_name + ".whiley";
- // Set the working directory.
- pb = new ProcessBuilder("java", "-cp", classpath, "wyopcl.WyopclMain", "-bp", runtime, path_whiley);
- pb.directory(new File(valid_path));
-
- String output = TestUtils.exec(classpath,valid_path,"wyopcl.WyopclMain", "-bp", runtime, path_whiley);
-
- // The name of the file which contains the output for this test
- String sampleOutputFile = valid_path + File.separatorChar
- + file_name + ".sysout";
-
- // Third, compare the output!
- TestUtils.compare(output,sampleOutputFile);
-
- } catch (Exception e) {
- terminate();
- throw new RuntimeException("Test file: " + file_name, e);
- }
- }
-
- private void exec_invalid(String file_name) {
- try {
-
- // Run the whiley program with interpreter.
- String path_whiley = file_name + ".whiley";
- // Set the working directory.
- pb = new ProcessBuilder("java", "-cp", classpath, "wyopcl.WyopclMain", "-bp", runtime, path_whiley, "-verify");
- pb.directory(new File(invalid_path));
-
- // System.out.println("" + pb.directory());
- p = pb.start();
-
- // Get the error stream because the result should be an error.
- BufferedReader reader = new BufferedReader(new InputStreamReader(p.getErrorStream(),
- Charset.forName("UTF-8")));
-
- // Load the output file (*.sysout).
- String path_sysout = invalid_path + file_name + ".sysout";
-
- Iterator iterator = Files.readAllLines(Paths.get(path_sysout), Charset.defaultCharset()).iterator();
- String output = null;
- while ((output = reader.readLine()) != null) {
- String expected = iterator.next();
- //System.out.println(output);
- // Check if the output matches the regular expression for file path, e.g.
- // .\List_Invalid_1.whiley:5: unknown variable
- if (output.matches(".*" + path_whiley + ":\\d+:.*.")) {
- String[] out_array = output.split(":");
- String[] expected_array = expected.split(":");
- assertEquals(expected_array[1], out_array[1]);
- //Split the second substring to get the cause of error, e.g.
- // internal failure, precondition not satisfied
- if(out_array[2].contains("internal failure,")){
- String res = out_array[2].split("internal failure,")[1];
- assertEquals(expected_array[2], res);
- }else{
- assertEquals(expected_array[2], out_array[2]);
- }
-
- } else {
- assertEquals(expected, output);
- }
-
- }
-
- // Ensure no records is left in the list.
- if (iterator.hasNext()) {
- throw new Exception("Test file: " + file_name);
- }
-
- } catch (Exception e) {
- terminate();
- throw new RuntimeException("Test file: " + file_name, e);
- }
- }
-
- public void terminate() {
- while (p != null) {
- p.destroy();
- p = null;
- }
-
- pb = null;
- }
-
-}
diff --git a/tests/invalid/Assert_Invalid_1.sysout b/tests/invalid/Assert_Invalid_1.sysout
index 254b5ee34e..00657d1877 100644
--- a/tests/invalid/Assert_Invalid_1.sysout
+++ b/tests/invalid/Assert_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Assert_Invalid_1.whiley:4: expected type bool, found int
+../../tests/invalid/Assert_Invalid_1.whiley:2: expected type bool, found int
assert z
^
diff --git a/tests/invalid/Assert_Invalid_1.whiley b/tests/invalid/Assert_Invalid_1.whiley
index 82f6d703e6..7954206572 100644
--- a/tests/invalid/Assert_Invalid_1.whiley
+++ b/tests/invalid/Assert_Invalid_1.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function f(int z) -> int:
assert z
return 0
diff --git a/tests/invalid/Assign_Invalid_1.sysout b/tests/invalid/Assign_Invalid_1.sysout
index e4aee75170..4fe51fe0ed 100644
--- a/tests/invalid/Assign_Invalid_1.sysout
+++ b/tests/invalid/Assign_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Assign_Invalid_1.whiley:4: expected type int, found bool
+../../tests/invalid/Assign_Invalid_1.whiley:2: expected type int, found bool
return true
^^^^
diff --git a/tests/invalid/Assign_Invalid_1.whiley b/tests/invalid/Assign_Invalid_1.whiley
index b475edbda3..984c281b98 100644
--- a/tests/invalid/Assign_Invalid_1.whiley
+++ b/tests/invalid/Assign_Invalid_1.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f() -> int:
return true
diff --git a/tests/invalid/Assign_Invalid_2.sysout b/tests/invalid/Assign_Invalid_2.sysout
index dbb14d4144..0694c58b1d 100644
--- a/tests/invalid/Assign_Invalid_2.sysout
+++ b/tests/invalid/Assign_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Assign_Invalid_2.whiley:4: expected type bool, found int
+../../tests/invalid/Assign_Invalid_2.whiley:2: expected type bool, found int
return x
^
diff --git a/tests/invalid/Assign_Invalid_2.whiley b/tests/invalid/Assign_Invalid_2.whiley
index 428f799575..ee7c9feb1d 100644
--- a/tests/invalid/Assign_Invalid_2.whiley
+++ b/tests/invalid/Assign_Invalid_2.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(int x) -> bool:
return x
diff --git a/tests/invalid/Assign_Invalid_3.sysout b/tests/invalid/Assign_Invalid_3.sysout
index 0dccffdd78..b72ec4d8fc 100644
--- a/tests/invalid/Assign_Invalid_3.sysout
+++ b/tests/invalid/Assign_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Assign_Invalid_3.whiley:4: expected type bool, found int
+../../tests/invalid/Assign_Invalid_3.whiley:2: expected type bool, found int
return x + y
^^^^^
diff --git a/tests/invalid/Assign_Invalid_3.whiley b/tests/invalid/Assign_Invalid_3.whiley
index 0000aa71b1..e2a6efeb1d 100644
--- a/tests/invalid/Assign_Invalid_3.whiley
+++ b/tests/invalid/Assign_Invalid_3.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(int x, int y) -> bool:
return x + y
diff --git a/tests/invalid/Assign_Invalid_4.sysout b/tests/invalid/Assign_Invalid_4.sysout
index 062dd92fc8..e59a8218a8 100644
--- a/tests/invalid/Assign_Invalid_4.sysout
+++ b/tests/invalid/Assign_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Assign_Invalid_4.whiley:4: expected type int, found bool
+../../tests/invalid/Assign_Invalid_4.whiley:2: expected type int, found bool
return true
^^^^
diff --git a/tests/invalid/Assign_Invalid_4.whiley b/tests/invalid/Assign_Invalid_4.whiley
index b475edbda3..984c281b98 100644
--- a/tests/invalid/Assign_Invalid_4.whiley
+++ b/tests/invalid/Assign_Invalid_4.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f() -> int:
return true
diff --git a/tests/invalid/Assign_Invalid_5.sysout b/tests/invalid/Assign_Invalid_5.sysout
index 3fe46e14f9..e74bcdc69a 100644
--- a/tests/invalid/Assign_Invalid_5.sysout
+++ b/tests/invalid/Assign_Invalid_5.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Assign_Invalid_5.whiley:4: expected type int, found bool
+../../tests/invalid/Assign_Invalid_5.whiley:2: expected type int, found bool
return x
^
diff --git a/tests/invalid/Assign_Invalid_5.whiley b/tests/invalid/Assign_Invalid_5.whiley
index 1823c24d51..7529bfd2ce 100644
--- a/tests/invalid/Assign_Invalid_5.whiley
+++ b/tests/invalid/Assign_Invalid_5.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(bool x) -> int:
return x
diff --git a/tests/invalid/Assign_Invalid_6.sysout b/tests/invalid/Assign_Invalid_6.sysout
index 96ac77c0f3..b118c7e6ea 100644
--- a/tests/invalid/Assign_Invalid_6.sysout
+++ b/tests/invalid/Assign_Invalid_6.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Assign_Invalid_6.whiley:4: expected type int, found bool
+../../tests/invalid/Assign_Invalid_6.whiley:2: expected type int, found bool
return !x
^^
diff --git a/tests/invalid/Assign_Invalid_6.whiley b/tests/invalid/Assign_Invalid_6.whiley
index c59036616f..c695b655ee 100644
--- a/tests/invalid/Assign_Invalid_6.whiley
+++ b/tests/invalid/Assign_Invalid_6.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(bool x) -> int:
return !x
diff --git a/tests/invalid/Assign_Invalid_7.sysout b/tests/invalid/Assign_Invalid_7.sysout
index 334b10c90a..a73bce1901 100644
--- a/tests/invalid/Assign_Invalid_7.sysout
+++ b/tests/invalid/Assign_Invalid_7.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Assign_Invalid_7.whiley:4: expected type int, found bool
+../../tests/invalid/Assign_Invalid_7.whiley:2: expected type int, found bool
return x < y
^^^^^
diff --git a/tests/invalid/Assign_Invalid_7.whiley b/tests/invalid/Assign_Invalid_7.whiley
index d05fc8962d..9e5f509608 100644
--- a/tests/invalid/Assign_Invalid_7.whiley
+++ b/tests/invalid/Assign_Invalid_7.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(int x, int y) -> int:
return x < y
diff --git a/tests/invalid/Byte_Invalid_1.sysout b/tests/invalid/Byte_Invalid_1.sysout
index f54350474b..6363c57e04 100644
--- a/tests/invalid/Byte_Invalid_1.sysout
+++ b/tests/invalid/Byte_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Byte_Invalid_1.whiley:5: expecting int or real, found byte
+../../tests/invalid/Byte_Invalid_1.whiley:3: expecting int or real, found byte
int i = b * 2
^
diff --git a/tests/invalid/Byte_Invalid_1.whiley b/tests/invalid/Byte_Invalid_1.whiley
index a117b7afed..339479527b 100644
--- a/tests/invalid/Byte_Invalid_1.whiley
+++ b/tests/invalid/Byte_Invalid_1.whiley
@@ -1,6 +1,4 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> void:
byte b = 00000001b
int i = b * 2
- sys.out.println(Any.toString(i))
+ assert i != 0
diff --git a/tests/invalid/Cast_Invalid_1.sysout b/tests/invalid/Cast_Invalid_1.sysout
index f831a2e173..2dde20ded4 100644
--- a/tests/invalid/Cast_Invalid_1.sysout
+++ b/tests/invalid/Cast_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Cast_Invalid_1.whiley:6: expected type int, found real
+../../tests/invalid/Cast_Invalid_1.whiley:4: expected type int, found real
return (int) i
^^^^^^^
diff --git a/tests/invalid/Cast_Invalid_1.whiley b/tests/invalid/Cast_Invalid_1.whiley
index c8b9d61ca5..78aa9bcf58 100644
--- a/tests/invalid/Cast_Invalid_1.whiley
+++ b/tests/invalid/Cast_Invalid_1.whiley
@@ -1,9 +1,4 @@
-import * from whiley.lang.*
-
type R1 is {real x}
function f(real i) -> int:
return (int) i
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(1.01)))
diff --git a/tests/invalid/Cast_Invalid_2.sysout b/tests/invalid/Cast_Invalid_2.sysout
index 6ac0b28a47..71a358772c 100644
--- a/tests/invalid/Cast_Invalid_2.sysout
+++ b/tests/invalid/Cast_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Cast_Invalid_2.whiley:6: expected type [int], found [real]
- return ([real]) xs
- ^^^^^^^^^^^
+../../tests/invalid/Cast_Invalid_2.whiley:4: expected type [int], found [real]
+ return ([int]) xs
+ ^^^^^^^^^^
diff --git a/tests/invalid/Cast_Invalid_2.whiley b/tests/invalid/Cast_Invalid_2.whiley
index 9b5c8c2604..481ccdf949 100644
--- a/tests/invalid/Cast_Invalid_2.whiley
+++ b/tests/invalid/Cast_Invalid_2.whiley
@@ -1,9 +1,4 @@
-import * from whiley.lang.*
-
type R1 is {real x}
function f([real] xs) -> [int]:
- return ([real]) xs
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f([1.0, 2.0, 3.0])))
+ return ([int]) xs
diff --git a/tests/invalid/Cast_Invalid_3.sysout b/tests/invalid/Cast_Invalid_3.sysout
index e4966a4d6d..3236f74661 100644
--- a/tests/invalid/Cast_Invalid_3.sysout
+++ b/tests/invalid/Cast_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Cast_Invalid_3.whiley:8: expected type {int x}, found {real x}
+../../tests/invalid/Cast_Invalid_3.whiley:6: expected type {int x}, found {real x}
return (R1) i
^^^^^^
diff --git a/tests/invalid/Cast_Invalid_3.whiley b/tests/invalid/Cast_Invalid_3.whiley
index 2fdd84904e..5458b9fa5c 100644
--- a/tests/invalid/Cast_Invalid_3.whiley
+++ b/tests/invalid/Cast_Invalid_3.whiley
@@ -1,11 +1,6 @@
-import * from whiley.lang.*
-
type R2 is {real x}
type R1 is {int x}
function f(R2 i) -> R1:
return (R1) i
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f({x: 123542.12})))
diff --git a/tests/invalid/Cast_Invalid_4.sysout b/tests/invalid/Cast_Invalid_4.sysout
index b5d043d7f1..de54d8bfc4 100644
--- a/tests/invalid/Cast_Invalid_4.sysout
+++ b/tests/invalid/Cast_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Cast_Invalid_4.whiley:10: expected type {int x,int y}, found {int x,real y}|{real x,int y}
+../../tests/invalid/Cast_Invalid_4.whiley:8: expected type {int x,int y}, found {int x,real y}|{real x,int y}
return (R3) i
^^^^^^
diff --git a/tests/invalid/Cast_Invalid_4.whiley b/tests/invalid/Cast_Invalid_4.whiley
index 2029e95d50..5a94000dca 100644
--- a/tests/invalid/Cast_Invalid_4.whiley
+++ b/tests/invalid/Cast_Invalid_4.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type R1 is {int y, real x}
type R2 is {real y, int x}
@@ -8,6 +6,3 @@ type R3 is {int y, int x}
function f(R1 | R2 i) -> R3:
return (R3) i
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f({y: 123, x: 123542.0})))
diff --git a/tests/invalid/Coercion_Invalid_1.sysout b/tests/invalid/Coercion_Invalid_1.sysout
index 75a23f4fee..c3cf051399 100644
--- a/tests/invalid/Coercion_Invalid_1.sysout
+++ b/tests/invalid/Coercion_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Coercion_Invalid_1.whiley:17: ambiguous coercion ({int x,int y} => {int x,real y}|{real x,int y}
- int ans = f( (uRec1Rec2) rec)
- ^^^^^^^^^^^^^^^
+../../tests/invalid/Coercion_Invalid_1.whiley:15: ambiguous coercion ({int x,int y} => {int x,real y}|{real x,int y}
+ return f( (uRec1Rec2) rec)
+ ^^^^^^^^^^^^^^^
diff --git a/tests/invalid/Coercion_Invalid_1.whiley b/tests/invalid/Coercion_Invalid_1.whiley
index 6eb6d12a10..364b06da2c 100644
--- a/tests/invalid/Coercion_Invalid_1.whiley
+++ b/tests/invalid/Coercion_Invalid_1.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type Rec1 is {int y, real x}
type Rec2 is {real y, int x}
@@ -12,7 +10,6 @@ function f(uRec1Rec2 r) -> int:
else:
return r.x
-method main(System.Console sys) -> void:
+function g() -> int:
{int x, int y} rec = {y: 1, x: 1}
- int ans = f( (uRec1Rec2) rec)
- sys.out.println(Any.toString(ans))
+ return f( (uRec1Rec2) rec)
diff --git a/tests/invalid/Coercion_Invalid_2.sysout b/tests/invalid/Coercion_Invalid_2.sysout
index 209a79d5f7..42e82c9f2a 100644
--- a/tests/invalid/Coercion_Invalid_2.sysout
+++ b/tests/invalid/Coercion_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Coercion_Invalid_2.whiley:12: expected type Coercion_Invalid_2:List4, found Coercion_Invalid_2:List1
+../../tests/invalid/Coercion_Invalid_2.whiley:10: expected type Coercion_Invalid_2:List4, found Coercion_Invalid_2:List1
return r
^
diff --git a/tests/invalid/Coercion_Invalid_2.whiley b/tests/invalid/Coercion_Invalid_2.whiley
index def3f22dbc..51efbca6f5 100644
--- a/tests/invalid/Coercion_Invalid_2.whiley
+++ b/tests/invalid/Coercion_Invalid_2.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type List1 is {null | List1 next, int | null data}
type List2 is {null | List2 next, int data}
@@ -10,9 +8,3 @@ type List4 is List3 | List2
function f(List1 r) -> List4:
return r
-
-method main(System.Console sys) -> void:
- list = {next: null, data: 1}
- list = {next: list, data: null}
- ans = f(list)
- sys.out.println(Any.toString(ans))
diff --git a/tests/invalid/Constant_Invalid_2.sysout b/tests/invalid/Constant_Invalid_2.sysout
index 78025947bf..0b6ddaf39c 100644
--- a/tests/invalid/Constant_Invalid_2.sysout
+++ b/tests/invalid/Constant_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Constant_Invalid_2.whiley:4: unknown variable
+../../tests/invalid/Constant_Invalid_2.whiley:2: unknown variable
int a = Constants[5]
^^^^^^^^^
diff --git a/tests/invalid/Constant_Invalid_2.whiley b/tests/invalid/Constant_Invalid_2.whiley
index 2ae4454c1c..4737428bf4 100644
--- a/tests/invalid/Constant_Invalid_2.whiley
+++ b/tests/invalid/Constant_Invalid_2.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main():
int a = Constants[5]
diff --git a/tests/invalid/ConstrainedDictionary_Invalid_1.whiley b/tests/invalid/ConstrainedDictionary_Invalid_1.whiley
index 8b00b23aa1..555f257ce1 100644
--- a/tests/invalid/ConstrainedDictionary_Invalid_1.whiley
+++ b/tests/invalid/ConstrainedDictionary_Invalid_1.whiley
@@ -1,16 +1,10 @@
-import * from whiley.lang.*
-
-type nat is int x where x >= 0
+type nat is (int x) where x >= 0
type dict is {int=>nat}
function f(int key, dict d) -> int:
return d[key]
-public method main(System.Console sys) -> void:
- d = {-2=>20, -1=>-1, 0=>0, 1=>10, 2=>20}
- sys.out.println(f(-2, d))
- sys.out.println(f(-1, d))
- sys.out.println(f(-0, d))
- sys.out.println(f(1, d))
- sys.out.println(f(2, d))
+public method g() -> int:
+ dict d = {-2=>20, -1=>-1, 0=>0, 1=>10, 2=>20}
+ return f(0,d)
\ No newline at end of file
diff --git a/tests/invalid/ConstrainedInt_Invalid_10.whiley b/tests/invalid/ConstrainedInt_Invalid_10.whiley
index f27d16fea0..9804592391 100644
--- a/tests/invalid/ConstrainedInt_Invalid_10.whiley
+++ b/tests/invalid/ConstrainedInt_Invalid_10.whiley
@@ -3,13 +3,10 @@ constant num is {1, 2, 3, 4}
constant bignum is {1, 2, 3, 4, 5, 6, 7}
-function f(num x) -> void:
+function f(num x) -> int:
y = x
- debug Any.toString(y)
+ return y
-function g({bignum} zs, int z) -> void
+function g({bignum} zs, int z) -> int
requires z in { x | x in zs, x < 6 }:
- f(z)
-
-method main(System.Console sys) -> void:
- g({1, 2, 3, 5}, 5)
+ return f(z)
diff --git a/tests/invalid/ConstrainedInt_Invalid_9.whiley b/tests/invalid/ConstrainedInt_Invalid_9.whiley
index 1514e02d8e..461c685f47 100644
--- a/tests/invalid/ConstrainedInt_Invalid_9.whiley
+++ b/tests/invalid/ConstrainedInt_Invalid_9.whiley
@@ -1,13 +1,10 @@
type num is (int x) where x in {1, 2, 3, 4}
-function f(num x) -> void:
+function f(num x) -> int:
num y = x
- debug Any.toString(y)
+ return y
-function g(int x, int z) -> void
+function g(int x, int z) -> int
requires ((x == 0) || (x == 1)) && (z in {1, 2, 3, x}):
- f(z)
-
-method main(System.Console sys) -> void:
- g(0, 0)
+ return f(z)
diff --git a/tests/invalid/ConstrainedList_Invalid_3.whiley b/tests/invalid/ConstrainedList_Invalid_3.whiley
index cf207bcab4..fecf6d3df4 100644
--- a/tests/invalid/ConstrainedList_Invalid_3.whiley
+++ b/tests/invalid/ConstrainedList_Invalid_3.whiley
@@ -1,12 +1,9 @@
+type char is (int x) where x >= 0 && x <= 255
+type string is [char]
public function update(string str) -> [char]:
- return [(char) -1]
+ return [-1]
-public function f(char c) -> void:
- debug "" ++ c
-
-public method main(System.Console sys) -> void:
- s1 = "Hello World"
- s1 = update(s1)
- if |s1| > 0:
- f(s1[0])
+public method main() -> string:
+ string s1 = "Hello World"
+ return update(s1)
diff --git a/tests/invalid/Contractive_Invalid_2.sysout b/tests/invalid/Contractive_Invalid_2.sysout
index 76b3f50e68..06d349832b 100644
--- a/tests/invalid/Contractive_Invalid_2.sysout
+++ b/tests/invalid/Contractive_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Contractive_Invalid_2.whiley:1: contractive type defined
-type Point is {
-^^^^^^^^^^^^^^^^^^
+../../tests/invalid/Contractive_Invalid_2.whiley:6: expected type Contractive_Invalid_2:Point, found null
+ return null
+ ^^^^
diff --git a/tests/invalid/DefiniteAssign_Invalid_1.sysout b/tests/invalid/DefiniteAssign_Invalid_1.sysout
index c8b2b8bebe..f1141241c7 100644
--- a/tests/invalid/DefiniteAssign_Invalid_1.sysout
+++ b/tests/invalid/DefiniteAssign_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/DefiniteAssign_Invalid_1.whiley:8: unknown variable
+../../tests/invalid/DefiniteAssign_Invalid_1.whiley:6: unknown variable
g(z)
^
diff --git a/tests/invalid/DefiniteAssign_Invalid_1.whiley b/tests/invalid/DefiniteAssign_Invalid_1.whiley
index 49bb1f62a3..cc49feef7a 100644
--- a/tests/invalid/DefiniteAssign_Invalid_1.whiley
+++ b/tests/invalid/DefiniteAssign_Invalid_1.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function g(int x) -> void:
return
diff --git a/tests/invalid/DefiniteAssign_Invalid_2.sysout b/tests/invalid/DefiniteAssign_Invalid_2.sysout
index b2755cc179..68ef80a3d8 100644
--- a/tests/invalid/DefiniteAssign_Invalid_2.sysout
+++ b/tests/invalid/DefiniteAssign_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/DefiniteAssign_Invalid_2.whiley:6: unknown variable
- z = 1
- ^
+../../tests/invalid/DefiniteAssign_Invalid_2.whiley:6: variable may be uninitialised
+ return z
+ ^^^^^^^^
diff --git a/tests/invalid/DefiniteAssign_Invalid_2.whiley b/tests/invalid/DefiniteAssign_Invalid_2.whiley
index e4e0721543..259353328f 100644
--- a/tests/invalid/DefiniteAssign_Invalid_2.whiley
+++ b/tests/invalid/DefiniteAssign_Invalid_2.whiley
@@ -1,7 +1,6 @@
-import * from whiley.lang.*
-
function f(int x, int y) -> int
requires (x >= 0) && (y > 0):
+ int z
if x < y:
z = 1
return z
diff --git a/tests/invalid/DefiniteAssign_Invalid_3.sysout b/tests/invalid/DefiniteAssign_Invalid_3.sysout
index 67f482d8a9..232c3dec17 100644
--- a/tests/invalid/DefiniteAssign_Invalid_3.sysout
+++ b/tests/invalid/DefiniteAssign_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/DefiniteAssign_Invalid_3.whiley:4: unknown variable
+../../tests/invalid/DefiniteAssign_Invalid_3.whiley:2: unknown variable
requires (x >= 0) && (y > 0):
^
diff --git a/tests/invalid/DefiniteAssign_Invalid_3.whiley b/tests/invalid/DefiniteAssign_Invalid_3.whiley
index c83bed257f..c71e3a7da5 100644
--- a/tests/invalid/DefiniteAssign_Invalid_3.whiley
+++ b/tests/invalid/DefiniteAssign_Invalid_3.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function f(int x) -> int
requires (x >= 0) && (y > 0):
return x
diff --git a/tests/invalid/DefiniteAssign_Invalid_4.sysout b/tests/invalid/DefiniteAssign_Invalid_4.sysout
index c0172d4ba1..01884e94e9 100644
--- a/tests/invalid/DefiniteAssign_Invalid_4.sysout
+++ b/tests/invalid/DefiniteAssign_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/DefiniteAssign_Invalid_4.whiley:8: unknown variable
- f(x,"WORLD")
- ^
+../../tests/invalid/DefiniteAssign_Invalid_4.whiley:2: unknown variable
+ debug a
+ ^
diff --git a/tests/invalid/DefiniteAssign_Invalid_4.whiley b/tests/invalid/DefiniteAssign_Invalid_4.whiley
index 922fe1fd86..0caaa8ca3e 100644
--- a/tests/invalid/DefiniteAssign_Invalid_4.whiley
+++ b/tests/invalid/DefiniteAssign_Invalid_4.whiley
@@ -1,8 +1,5 @@
-import * from whiley.lang.*
-
-method f(any this, string a) -> void:
+method f(any this) -> void:
debug a
-method main(System.Console sys) -> void:
- sys.out.println("HELLO")
- f(x,"WORLD")
+method g() -> void:
+ f(x)
diff --git a/tests/invalid/EndOfFile_Invalid_1.sysout b/tests/invalid/EndOfFile_Invalid_1.sysout
index 96c92a187b..5a326b1e09 100644
--- a/tests/invalid/EndOfFile_Invalid_1.sysout
+++ b/tests/invalid/EndOfFile_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/EndOfFile_Invalid_1.whiley:5: unexpected end-of-file
+../../tests/invalid/EndOfFile_Invalid_1.whiley:3: unexpected end-of-file
i++
^
diff --git a/tests/invalid/EndOfFile_Invalid_1.whiley b/tests/invalid/EndOfFile_Invalid_1.whiley
index e08481d86b..f0840589a2 100644
--- a/tests/invalid/EndOfFile_Invalid_1.whiley
+++ b/tests/invalid/EndOfFile_Invalid_1.whiley
@@ -1,5 +1,3 @@
-import whiley.lang.System
-
-method main(System.Console console):
+method main():
int i = 1
i++
diff --git a/tests/invalid/For_Invalid_1.sysout b/tests/invalid/For_Invalid_1.sysout
index a16a406073..f3c1a730d2 100644
--- a/tests/invalid/For_Invalid_1.sysout
+++ b/tests/invalid/For_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/For_Invalid_1.whiley:5: unknown variable
- for st in args:
- ^^^^
+../../tests/invalid/For_Invalid_1.whiley:3: variable i already defined
+ for i in args:
+ ^^^^^^^^^^^^^^
diff --git a/tests/invalid/For_Invalid_1.whiley b/tests/invalid/For_Invalid_1.whiley
index 07e0beb5ee..27552de178 100644
--- a/tests/invalid/For_Invalid_1.whiley
+++ b/tests/invalid/For_Invalid_1.whiley
@@ -1,6 +1,5 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
- string st = "Hello World"
- for st in args:
- sys.out.println(st)
+method f([int] args) -> int:
+ int i = 1
+ for i in args:
+ r = r + i
+ return i
diff --git a/tests/invalid/FunctionRef_Invalid_1.sysout b/tests/invalid/FunctionRef_Invalid_1.sysout
index 120cc4da6c..922618d781 100644
--- a/tests/invalid/FunctionRef_Invalid_1.sysout
+++ b/tests/invalid/FunctionRef_Invalid_1.sysout
@@ -1,4 +1,3 @@
-../../tests/invalid/FunctionRef_Invalid_1.whiley:10: unable to resolve name (no match for g(function(int) -> int)
- found: FunctionRef_Invalid_1:g : function(function(int) -> void) -> int)
- sys.out.println(Any.toString(g(&f)))
- ^^^^^
+../../tests/invalid/FunctionRef_Invalid_1.whiley:8: expecting ":" here
+ return g(&f)
+ ^^^^^^
diff --git a/tests/invalid/FunctionRef_Invalid_1.whiley b/tests/invalid/FunctionRef_Invalid_1.whiley
index 2672306ee5..582eb32574 100644
--- a/tests/invalid/FunctionRef_Invalid_1.whiley
+++ b/tests/invalid/FunctionRef_Invalid_1.whiley
@@ -1,10 +1,8 @@
-import * from whiley.lang.*
-
function f(int x) -> int:
return x + 1
function g(function func(int)->void) -> int:
return func(1)
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(g(&f)))
+method h() -> int
+ return g(&f)
diff --git a/tests/invalid/FunctionRef_Invalid_2.sysout b/tests/invalid/FunctionRef_Invalid_2.sysout
index 4fea7fb4cf..c8f62eb536 100644
--- a/tests/invalid/FunctionRef_Invalid_2.sysout
+++ b/tests/invalid/FunctionRef_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/FunctionRef_Invalid_2.whiley:7: expected type int, found real
- return func(1)
- ^^^^^^^
+../../tests/invalid/FunctionRef_Invalid_2.whiley:8: expecting ":" here
+ return g(&f)
+ ^^^^^^
diff --git a/tests/invalid/FunctionRef_Invalid_2.whiley b/tests/invalid/FunctionRef_Invalid_2.whiley
index c9150f0340..bf040f0517 100644
--- a/tests/invalid/FunctionRef_Invalid_2.whiley
+++ b/tests/invalid/FunctionRef_Invalid_2.whiley
@@ -1,10 +1,8 @@
-import * from whiley.lang.*
-
function f(int x) -> int:
return x + 1
function g(function func(int)->real) -> int:
return func(1)
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(g(&f)))
+method h() -> int
+ return g(&f)
diff --git a/tests/invalid/FunctionRef_Invalid_3.sysout b/tests/invalid/FunctionRef_Invalid_3.sysout
index b8217271c5..5c747b1f85 100644
--- a/tests/invalid/FunctionRef_Invalid_3.sysout
+++ b/tests/invalid/FunctionRef_Invalid_3.sysout
@@ -1,4 +1,3 @@
-../../tests/invalid/FunctionRef_Invalid_3.whiley:10: unable to resolve name (no match for g(function(int) -> int)
- found: FunctionRef_Invalid_3:g : function(function(real) -> int) -> int)
- sys.out.println(Any.toString(g(&f)))
- ^^^^^
+../../tests/invalid/FunctionRef_Invalid_3.whiley:8: expecting ":" here
+ return g(&f)
+ ^^^^^^
diff --git a/tests/invalid/FunctionRef_Invalid_3.whiley b/tests/invalid/FunctionRef_Invalid_3.whiley
index 39a1dc3c82..c3dedcecd9 100644
--- a/tests/invalid/FunctionRef_Invalid_3.whiley
+++ b/tests/invalid/FunctionRef_Invalid_3.whiley
@@ -1,10 +1,8 @@
-import * from whiley.lang.*
-
function f(int x) -> int:
return x + 1
function g(function func(real)->int) -> int:
return func(1.2345)
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(g(&f)))
+method h() -> int
+ return g(&f)
diff --git a/tests/invalid/FunctionRef_Invalid_4.sysout b/tests/invalid/FunctionRef_Invalid_4.sysout
index 3a6cc8d1e2..c5a143b227 100644
--- a/tests/invalid/FunctionRef_Invalid_4.sysout
+++ b/tests/invalid/FunctionRef_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/FunctionRef_Invalid_4.whiley:14: expected type FunctionRef_Invalid_4:func_t, found null|(function(int) -> int)
+../../tests/invalid/FunctionRef_Invalid_4.whiley:12: expected type FunctionRef_Invalid_4:func_t, found null|(function(int) -> int)
func_t y = table[d]
^^^^^^^^
diff --git a/tests/invalid/FunctionRef_Invalid_4.whiley b/tests/invalid/FunctionRef_Invalid_4.whiley
index fab3bc324e..7ed144bc9a 100644
--- a/tests/invalid/FunctionRef_Invalid_4.whiley
+++ b/tests/invalid/FunctionRef_Invalid_4.whiley
@@ -1,7 +1,5 @@
-import * from whiley.lang.*
-import whiley.io.*
-
constant table is [&f1, &f2, null]
+
type func_t is function(int)->int
function f1(int x) -> int:
@@ -13,6 +11,3 @@ function f2(int x) -> int:
function g(int d) -> int:
func_t y = table[d]
return y(123)
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(g(3)))
diff --git a/tests/invalid/FunctionRef_Invalid_5.sysout b/tests/invalid/FunctionRef_Invalid_5.sysout
index 182ecd852b..ef14ad5547 100644
--- a/tests/invalid/FunctionRef_Invalid_5.sysout
+++ b/tests/invalid/FunctionRef_Invalid_5.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/FunctionRef_Invalid_5.whiley:16: record has no field named read
+../../tests/invalid/FunctionRef_Invalid_5.whiley:14: record has no field named read
return f.read(arg)
^^^^^^^^^^^
diff --git a/tests/invalid/FunctionRef_Invalid_5.whiley b/tests/invalid/FunctionRef_Invalid_5.whiley
index 5d294ab7b9..d79c0f0ff6 100644
--- a/tests/invalid/FunctionRef_Invalid_5.whiley
+++ b/tests/invalid/FunctionRef_Invalid_5.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type Proc is &{int data}
method read(Proc this, int x) -> int:
@@ -14,11 +12,3 @@ function id(int x) -> int:
function test(Func f, int arg) -> int:
return f.read(arg)
-
-method main(System.Console sys) -> void:
- x = test({read: &id}, 123)
- sys.out.println("GOT: " ++ Any.toString(x))
- x = test({read: &id}, 12545)
- sys.out.println("GOT: " ++ Any.toString(x))
- x = test({read: &id}, -11)
- sys.out.println("GOT: " ++ Any.toString(x))
diff --git a/tests/invalid/FunctionRef_Invalid_6.sysout b/tests/invalid/FunctionRef_Invalid_6.sysout
index 578379a305..472213e51e 100644
--- a/tests/invalid/FunctionRef_Invalid_6.sysout
+++ b/tests/invalid/FunctionRef_Invalid_6.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/FunctionRef_Invalid_6.whiley:10: expected type int, found real
+../../tests/invalid/FunctionRef_Invalid_6.whiley:8: expected type int, found real
return read(arg)
^^^
diff --git a/tests/invalid/FunctionRef_Invalid_6.whiley b/tests/invalid/FunctionRef_Invalid_6.whiley
index 19051b86c6..7f1ebc264b 100644
--- a/tests/invalid/FunctionRef_Invalid_6.whiley
+++ b/tests/invalid/FunctionRef_Invalid_6.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function read(real a) -> real:
return -a
@@ -8,11 +6,3 @@ function id(int x) -> int:
function test(function read(int)->int, real arg) -> real:
return read(arg)
-
-method main(System.Console sys) -> void:
- x = test(&id, 1)
- sys.out.println(Any.toString(x))
- x = test(&id, 123)
- sys.out.println(Any.toString(x))
- x = test(&id, 223)
- sys.out.println(Any.toString(x))
diff --git a/tests/invalid/FunctionRef_Invalid_7.sysout b/tests/invalid/FunctionRef_Invalid_7.sysout
index abbdf4679b..0ac8eb7ded 100644
--- a/tests/invalid/FunctionRef_Invalid_7.sysout
+++ b/tests/invalid/FunctionRef_Invalid_7.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/FunctionRef_Invalid_7.whiley:11: record required, got: &{function(real) -> real func}
- return this.func(arg)
- ^^^^^^^^^^^^^^
+../../tests/invalid/FunctionRef_Invalid_7.whiley:6: insufficient arguments for function or method invocation
+ return this->func(arg)
+ ^^^^^^^^^^^^^^^
diff --git a/tests/invalid/FunctionRef_Invalid_7.whiley b/tests/invalid/FunctionRef_Invalid_7.whiley
index cc18fc31a8..cbe1e72f2e 100644
--- a/tests/invalid/FunctionRef_Invalid_7.whiley
+++ b/tests/invalid/FunctionRef_Invalid_7.whiley
@@ -1,23 +1,6 @@
-import * from whiley.lang.*
-
type Proc is &{
- function func(real)->real
+ function func(real,int)->real
}
-method func(Proc this, int x) -> int:
- return x + 1
-
method test(Proc this, real arg) -> real:
- return this.func(arg)
-
-function id(real x) -> real:
- return x
-
-method main(System.Console sys) -> void:
- p = new {func: &id}
- x = p.test(123)
- sys.out.println("GOT: " ++ Any.toString(x))
- x = p.test(12545)
- sys.out.println("GOT: " ++ Any.toString(x))
- x = p.test(-11)
- sys.out.println("GOT: " ++ Any.toString(x))
+ return this->func(arg)
diff --git a/tests/invalid/Function_Invalid_1.sysout b/tests/invalid/Function_Invalid_1.sysout
index e4a6ecb322..118c5ba240 100644
--- a/tests/invalid/Function_Invalid_1.sysout
+++ b/tests/invalid/Function_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Function_Invalid_1.whiley:4: unable to resolve name (name not found: asdkljkljg)
+../../tests/invalid/Function_Invalid_1.whiley:2: unable to resolve name (name not found: asdkljkljg)
asdkljkljg(x)
^^^^^^^^^^^^^
diff --git a/tests/invalid/Function_Invalid_1.whiley b/tests/invalid/Function_Invalid_1.whiley
index e76d2b7205..24092ccc0a 100644
--- a/tests/invalid/Function_Invalid_1.whiley
+++ b/tests/invalid/Function_Invalid_1.whiley
@@ -1,7 +1,2 @@
-import * from whiley.lang.*
-
function f(int x) -> void:
asdkljkljg(x)
-
-method main(System.Console sys) -> void:
- f(1)
diff --git a/tests/invalid/Function_Invalid_2.whiley b/tests/invalid/Function_Invalid_2.whiley
index a69bfd07ce..8612b7c7ed 100644
--- a/tests/invalid/Function_Invalid_2.whiley
+++ b/tests/invalid/Function_Invalid_2.whiley
@@ -1,10 +1,5 @@
-import * from whiley.lang.*
+function f(int x) -> int:
+ return 1
-function f(System.Console sys, int x) -> void:
- sys.out.println("FIRST")
-
-function f(System.Console sys, int x) -> void:
- sys.out.println("SECOND")
-
-method main(System.Console sys) -> void:
- sys.out.println("NOUT")
+function f(int x) -> int:
+ return 2
diff --git a/tests/invalid/Function_Invalid_3.sysout b/tests/invalid/Function_Invalid_3.sysout
index b18ec9c3d3..b5f53fa168 100644
--- a/tests/invalid/Function_Invalid_3.sysout
+++ b/tests/invalid/Function_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Function_Invalid_3.whiley:7: unable to resolve name (no match for f(int))
- f(1)
- ^^^^
+../../tests/invalid/Function_Invalid_3.whiley:5: unable to resolve name (no match for f(int))
+ return f(1)
+ ^^^^
diff --git a/tests/invalid/Function_Invalid_3.whiley b/tests/invalid/Function_Invalid_3.whiley
index c924007271..45b58f0018 100644
--- a/tests/invalid/Function_Invalid_3.whiley
+++ b/tests/invalid/Function_Invalid_3.whiley
@@ -1,7 +1,5 @@
-import * from whiley.lang.*
+method f(int x, int y) -> int:
+ return x + y
-method f(System.Console sys, int x) -> void:
- sys.out.println(Any.toString(x))
-
-method main(System.Console sys) -> void:
- f(1)
+method g() -> int:
+ return f(1)
diff --git a/tests/invalid/Function_Invalid_4.sysout b/tests/invalid/Function_Invalid_4.sysout
index 25c8b64db5..353faf7639 100644
--- a/tests/invalid/Function_Invalid_4.sysout
+++ b/tests/invalid/Function_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Function_Invalid_4.whiley:4: unable to resolve name (module not found: out)
- sys.out.println(Any.toString(x))
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+../../tests/invalid/Function_Invalid_4.whiley:5: method invocation not permitted in function
+ return g(x)
+ ^^^^
diff --git a/tests/invalid/Function_Invalid_4.whiley b/tests/invalid/Function_Invalid_4.whiley
index 9de9a4f1e2..d4de7c0c30 100644
--- a/tests/invalid/Function_Invalid_4.whiley
+++ b/tests/invalid/Function_Invalid_4.whiley
@@ -1,7 +1,5 @@
-import * from whiley.lang.*
+method g(int x) -> int:
+ return x
function f(int x) -> int:
- sys.out.println(Any.toString(x))
-
-method main(System.Console sys) -> void:
- f(1)
+ return g(x)
diff --git a/tests/invalid/Function_Invalid_9.whiley b/tests/invalid/Function_Invalid_9.whiley
index 569a44207c..3d6f2ae239 100644
--- a/tests/invalid/Function_Invalid_9.whiley
+++ b/tests/invalid/Function_Invalid_9.whiley
@@ -6,6 +6,3 @@ requires x >= 0:
function f(int x) -> int
requires x >= 0:
return x
-
-method main(System.Console sys) -> void:
- debug Any.toString(f(1))
diff --git a/tests/invalid/If_Invalid_1.sysout b/tests/invalid/If_Invalid_1.sysout
index f695d52eb1..27c138e9c8 100644
--- a/tests/invalid/If_Invalid_1.sysout
+++ b/tests/invalid/If_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/If_Invalid_1.whiley:4: expected type bool, found int
+../../tests/invalid/If_Invalid_1.whiley:2: expected type bool, found int
if z:
^
diff --git a/tests/invalid/If_Invalid_1.whiley b/tests/invalid/If_Invalid_1.whiley
index a4f5ac3a50..af873da655 100644
--- a/tests/invalid/If_Invalid_1.whiley
+++ b/tests/invalid/If_Invalid_1.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function f(int z) -> int:
if z:
return 1
diff --git a/tests/invalid/If_Invalid_2.sysout b/tests/invalid/If_Invalid_2.sysout
index 6646ffb245..7e5045ddfa 100644
--- a/tests/invalid/If_Invalid_2.sysout
+++ b/tests/invalid/If_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/If_Invalid_2.whiley:7: expected type bool, found int
+../../tests/invalid/If_Invalid_2.whiley:5: expected type bool, found int
return 0
^
diff --git a/tests/invalid/If_Invalid_2.whiley b/tests/invalid/If_Invalid_2.whiley
index 9456ccbe01..5f2b9d4bb4 100644
--- a/tests/invalid/If_Invalid_2.whiley
+++ b/tests/invalid/If_Invalid_2.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function f(bool z) -> bool:
if z:
return true
diff --git a/tests/invalid/If_Invalid_3.whiley b/tests/invalid/If_Invalid_3.whiley
index baba12bb6a..747f51e2b5 100644
--- a/tests/invalid/If_Invalid_3.whiley
+++ b/tests/invalid/If_Invalid_3.whiley
@@ -1,6 +1,8 @@
-import * from whiley.lang.*
-
-function f(bool z) -> void:
- if z:
+function f(bool z) -> int:
+ int r = 0
+ //
+ if z:
for z in [1, 2, 3]:
- sys.out.println(Any.toString(z))
+ r = r + 1
+ //
+ return r
\ No newline at end of file
diff --git a/tests/invalid/If_Invalid_4.sysout b/tests/invalid/If_Invalid_4.sysout
index 4833c8b739..b7270dabf3 100644
--- a/tests/invalid/If_Invalid_4.sysout
+++ b/tests/invalid/If_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/If_Invalid_4.whiley:3: missing return statement
+../../tests/invalid/If_Invalid_4.whiley:1: missing return statement
function f(int x) -> int:
^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/invalid/If_Invalid_4.whiley b/tests/invalid/If_Invalid_4.whiley
index d6663b733c..09e1370ad0 100644
--- a/tests/invalid/If_Invalid_4.whiley
+++ b/tests/invalid/If_Invalid_4.whiley
@@ -1,15 +1,6 @@
-import * from whiley.lang.*
-
function f(int x) -> int:
if x < 10:
return 1
else:
if x > 10:
return 2
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(1)))
- sys.out.println(Any.toString(f(10)))
- sys.out.println(Any.toString(f(11)))
- sys.out.println(Any.toString(f(1212)))
- sys.out.println(Any.toString(f(-1212)))
diff --git a/tests/invalid/Import_Invalid_1.whiley b/tests/invalid/Import_Invalid_1.whiley
index 7d4cacf593..ba13324805 100644
--- a/tests/invalid/Import_Invalid_1.whiley
+++ b/tests/invalid/Import_Invalid_1.whiley
@@ -6,7 +6,3 @@ import toString from whiley.lang.Any
function g(real x) -> [int]:
return toString(x)
-
-public method main(System.Console sys) -> void:
- sys.out.println("FIRST: " ++ f(1))
- sys.out.println("SECOND: " ++ g(1.2344))
diff --git a/tests/invalid/Intersection_Invalid_1.whiley b/tests/invalid/Intersection_Invalid_1.whiley
index 1f629ff6c8..0752ec12f3 100644
--- a/tests/invalid/Intersection_Invalid_1.whiley
+++ b/tests/invalid/Intersection_Invalid_1.whiley
@@ -1,10 +1,7 @@
-import * from whiley.lang.*
-
type EmptyList is [int] & [real]
function size(EmptyList l) -> int:
return |l|
-method main(System.Console sys) -> void:
- list = [1]
- sys.out.println(Any.toString(size(list)))
+function f([int] x) -> int:
+ return size(x)
diff --git a/tests/invalid/Intersection_Invalid_2.whiley b/tests/invalid/Intersection_Invalid_2.whiley
index 9cb6bc5210..45187c3da7 100644
--- a/tests/invalid/Intersection_Invalid_2.whiley
+++ b/tests/invalid/Intersection_Invalid_2.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type LinkedList is null | {LinkedList next, int data}
type UnitList is {null next, int data}
@@ -9,8 +7,8 @@ type InterList is UnitList & LinkedList
function f(InterList l) -> int:
return l.data
-method main(System.Console sys) -> void:
- list = {next: null, data: 1234}
+method g() -> int:
+ LinkedList list = {next: null, data: 1234}
list = {next: list, data: 2234}
- d = f(list)
- sys.out.println("GOT: " ++ Any.toString(d))
+ return f(list)
+
diff --git a/tests/invalid/Lambda_Invalid_3.whiley b/tests/invalid/Lambda_Invalid_3.whiley
index 0be0e52207..5220042473 100644
--- a/tests/invalid/Lambda_Invalid_3.whiley
+++ b/tests/invalid/Lambda_Invalid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+type func_t is function(int)->int
function f(int x) -> int
requires x > 1:
@@ -6,9 +6,5 @@ requires x > 1:
function g(int p) -> int
requires p >= 0:
- func = &(int x -> f(x + 1))
+ func_t func = &(int x -> f(x + 1))
return func(p)
-
-method main(System.Console sys) -> void:
- x = g(5)
- sys.out.println(x)
diff --git a/tests/invalid/ListAccess_Invalid_1.sysout b/tests/invalid/ListAccess_Invalid_1.sysout
index 541a8efd57..a1779dcea8 100644
--- a/tests/invalid/ListAccess_Invalid_1.sysout
+++ b/tests/invalid/ListAccess_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/ListAccess_Invalid_1.whiley:4: expected type int, found real
+../../tests/invalid/ListAccess_Invalid_1.whiley:2: expected type int, found real
return xs[y]
^
diff --git a/tests/invalid/ListAccess_Invalid_1.whiley b/tests/invalid/ListAccess_Invalid_1.whiley
index 9d1c8067f2..b0ac631482 100644
--- a/tests/invalid/ListAccess_Invalid_1.whiley
+++ b/tests/invalid/ListAccess_Invalid_1.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f([int] xs, real y) -> int:
return xs[y]
diff --git a/tests/invalid/ListAccess_Invalid_3.sysout b/tests/invalid/ListAccess_Invalid_3.sysout
index 8435b552c1..93fa5e2474 100644
--- a/tests/invalid/ListAccess_Invalid_3.sysout
+++ b/tests/invalid/ListAccess_Invalid_3.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/ListAccess_Invalid_3.whiley:13: unable to resolve name (no match for f([{int data,int mode}|{[int] data,int mode}])
+../../tests/invalid/ListAccess_Invalid_3.whiley:11: unable to resolve name (no match for f([{int data,int mode}|{[int] data,int mode}])
found: ListAccess_Invalid_3:f : function([{int data,int mode}]) -> [{int data,int mode}])
- tups = f(tups)
+ return f(tups)
^^^^^^^
diff --git a/tests/invalid/ListAccess_Invalid_3.whiley b/tests/invalid/ListAccess_Invalid_3.whiley
index 66609e77ba..3619cb888d 100644
--- a/tests/invalid/ListAccess_Invalid_3.whiley
+++ b/tests/invalid/ListAccess_Invalid_3.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type intList is int | [int]
type tup is {intList data, int mode}
@@ -7,8 +5,7 @@ type tup is {intList data, int mode}
function f([{int data, int mode}] x) -> [{int data, int mode}]:
return x
-method main(System.Console sys) -> void:
+method g() -> [{int data, int mode}]:
[tup] tups = [{data: 1, mode: 0}, {data: [1, 2, 3], mode: 1}]
tups[0].data = 1
- tups = f(tups)
- sys.out.println(Any.toString(tups))
+ return f(tups)
diff --git a/tests/invalid/ListAppend_Invalid_1.sysout b/tests/invalid/ListAppend_Invalid_1.sysout
index 0c82d89850..fdc7f3afc8 100644
--- a/tests/invalid/ListAppend_Invalid_1.sysout
+++ b/tests/invalid/ListAppend_Invalid_1.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/ListAppend_Invalid_1.whiley:8: unable to resolve name (no match for f([int|[int]])
- found: ListAppend_Invalid_1:f : function([whiley/lang/ASCII:string]) -> int)
- f(r)
- ^^^^
+../../tests/invalid/ListAppend_Invalid_1.whiley:6: unable to resolve name (no match for f([int|real])
+ found: ListAppend_Invalid_1:f : function([int]) -> int)
+ return f(r)
+ ^^^^
diff --git a/tests/invalid/ListAppend_Invalid_1.whiley b/tests/invalid/ListAppend_Invalid_1.whiley
index 7df7e28231..ec0bccff4c 100644
--- a/tests/invalid/ListAppend_Invalid_1.whiley
+++ b/tests/invalid/ListAppend_Invalid_1.whiley
@@ -1,9 +1,7 @@
-import * from whiley.lang.*
-
-function f([string] r) -> int:
+function f([int] r) -> int:
return |r|
-method main(System.Console sys) -> void:
- [string|int] r = sys.args ++ [1]
- f(r)
- sys.out.println(Any.toString(r))
+method g([real] args) -> int:
+ [real|int] r = args ++ [1]
+ return f(r)
+
diff --git a/tests/invalid/ListAppend_Invalid_2.sysout b/tests/invalid/ListAppend_Invalid_2.sysout
index 39a96dff64..a77c190d13 100644
--- a/tests/invalid/ListAppend_Invalid_2.sysout
+++ b/tests/invalid/ListAppend_Invalid_2.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/ListAppend_Invalid_2.whiley:9: unable to resolve name (no match for f([int|[int]])
- found: ListAppend_Invalid_2:f : function([whiley/lang/ASCII:string]) -> [whiley/lang/ASCII:string])
- f(r)
- ^^^^
+../../tests/invalid/ListAppend_Invalid_2.whiley:7: unable to resolve name (no match for f([int|real])
+ found: ListAppend_Invalid_2:f : function([real]) -> [real])
+ return f(r)
+ ^^^^
diff --git a/tests/invalid/ListAppend_Invalid_2.whiley b/tests/invalid/ListAppend_Invalid_2.whiley
index 9a20c73bde..04742d9d8b 100644
--- a/tests/invalid/ListAppend_Invalid_2.whiley
+++ b/tests/invalid/ListAppend_Invalid_2.whiley
@@ -1,10 +1,7 @@
-import * from whiley.lang.*
-
-function f([string] args) -> [string]:
+function f([real] args) -> [real]:
return args
-method main(System.Console sys) -> void:
+method g([real] args) -> [real]:
[int] l = [1, 2, 3]
- [string|int] r = sys.args ++ l
- f(r)
- sys.out.println(Any.toString(r))
+ [real|int] r = args ++ l
+ return f(r)
diff --git a/tests/invalid/ListAppend_Invalid_3.whiley b/tests/invalid/ListAppend_Invalid_3.whiley
index f9f37dc370..0b3ef6b894 100644
--- a/tests/invalid/ListAppend_Invalid_3.whiley
+++ b/tests/invalid/ListAppend_Invalid_3.whiley
@@ -3,15 +3,13 @@ function f([int] xs) -> int
requires no { x in xs | x < 0 }:
return |xs|
-method main(System.Console sys) -> void:
+method main(bool flag) -> int:
[int] left
[int] right = [-1, 0, 1]
//
- if |sys.args| > 1:
+ if flag:
left = [2, 3, 4]
else:
left = [1, 2, 3]
//
- int r = f(left ++ right)
- //
- debug Any.toString(r)
+ return f(left ++ right)
diff --git a/tests/invalid/ListAppend_Invalid_4.whiley b/tests/invalid/ListAppend_Invalid_4.whiley
index 982b8bf873..bd2238114b 100644
--- a/tests/invalid/ListAppend_Invalid_4.whiley
+++ b/tests/invalid/ListAppend_Invalid_4.whiley
@@ -6,7 +6,3 @@ function f(plistv6 xs) -> int:
function g(plistv6 left, [int] right) -> int:
return f(left ++ right)
-
-method main(System.Console sys) -> void:
- int r = g([1, 2, 3], [-1, 7, 8])
- debug Any.toString(r)
diff --git a/tests/invalid/ListAppend_Invalid_5.whiley b/tests/invalid/ListAppend_Invalid_5.whiley
index 27485cc1f5..9f7004e26d 100644
--- a/tests/invalid/ListAppend_Invalid_5.whiley
+++ b/tests/invalid/ListAppend_Invalid_5.whiley
@@ -6,7 +6,3 @@ function f(plistv6 xs) -> int:
function g([int] left, plistv6 right) -> int:
return f(left ++ right)
-
-method main(System.Console sys) -> void:
- int r = g([1, 2, -1], [6, 7, 8])
- debug Any.toString(r)
diff --git a/tests/invalid/ListAssign_Invalid_1.sysout b/tests/invalid/ListAssign_Invalid_1.sysout
index 004b4fd17d..54e62711f6 100644
--- a/tests/invalid/ListAssign_Invalid_1.sysout
+++ b/tests/invalid/ListAssign_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/ListAssign_Invalid_1.whiley:8: expected type [int], found [int|real]
+../../tests/invalid/ListAssign_Invalid_1.whiley:6: expected type [int], found [int|real]
xs[0] = 1.23
^^
diff --git a/tests/invalid/ListAssign_Invalid_1.whiley b/tests/invalid/ListAssign_Invalid_1.whiley
index 0f47336b0a..5eb4f0ee59 100644
--- a/tests/invalid/ListAssign_Invalid_1.whiley
+++ b/tests/invalid/ListAssign_Invalid_1.whiley
@@ -1,9 +1,7 @@
-import * from whiley.lang.*
-
function f([int] ls) -> [int]:
return ls
-method main(System.Console sys) -> void:
+method main():
[int] xs = [1, 2]
xs[0] = 1.23
f(xs)
diff --git a/tests/invalid/ListAssign_Invalid_2.whiley b/tests/invalid/ListAssign_Invalid_2.whiley
index 70c2d92bee..334ff5965f 100644
--- a/tests/invalid/ListAssign_Invalid_2.whiley
+++ b/tests/invalid/ListAssign_Invalid_2.whiley
@@ -1,8 +1,6 @@
-method main(System.Console sys) -> void:
+method main() -> void:
[int] arr1 = [1, 2, 3]
[int] arr2 = arr1
arr2[2] = 2
assert arr2[2] == |arr1|
- debug Any.toString(arr1)
- debug Any.toString(arr2)
diff --git a/tests/invalid/ListAssign_Invalid_3.whiley b/tests/invalid/ListAssign_Invalid_3.whiley
index 54fb8bd7d5..0145626c68 100644
--- a/tests/invalid/ListAssign_Invalid_3.whiley
+++ b/tests/invalid/ListAssign_Invalid_3.whiley
@@ -1,8 +1,6 @@
-method main(System.Console sys) -> void:
+method main() -> void:
[int] arr1 = [1, 2, 4]
[int] arr2 = arr1
arr2[2] = 3
assert arr2[2] != |arr1|
- debug Any.toString(arr1)
- debug Any.toString(arr2)
diff --git a/tests/invalid/ListConversion_Invalid_1.sysout b/tests/invalid/ListConversion_Invalid_1.sysout
index 52e19d9bb1..d315428132 100644
--- a/tests/invalid/ListConversion_Invalid_1.sysout
+++ b/tests/invalid/ListConversion_Invalid_1.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/ListConversion_Invalid_1.whiley:7: unable to resolve name (no match for f([int|[void]])
- found: ListConversion_Invalid_1:f : function([real]) -> void)
+../../tests/invalid/ListConversion_Invalid_1.whiley:5: unable to resolve name (no match for f([int|[void]])
+ found: ListConversion_Invalid_1:f : function([real]) -> int)
f([1, 2, 3, []])
^^^^^^^^^^^^^^^^
diff --git a/tests/invalid/ListConversion_Invalid_1.whiley b/tests/invalid/ListConversion_Invalid_1.whiley
index a8271fc0c0..baf7f10814 100644
--- a/tests/invalid/ListConversion_Invalid_1.whiley
+++ b/tests/invalid/ListConversion_Invalid_1.whiley
@@ -1,7 +1,5 @@
-import * from whiley.lang.*
+function f([real] ls) -> int:
+ return 0
-function f([real] ls) -> void:
- debug Any.toString(ls)
-
-method main(System.Console sys) -> void:
+method main():
f([1, 2, 3, []])
diff --git a/tests/invalid/ListElemOf_Invalid_1.sysout b/tests/invalid/ListElemOf_Invalid_1.sysout
index cbcab4b72b..f4d1beebe2 100644
--- a/tests/invalid/ListElemOf_Invalid_1.sysout
+++ b/tests/invalid/ListElemOf_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/ListElemOf_Invalid_1.whiley:5: incomparable operands: real and int
+../../tests/invalid/ListElemOf_Invalid_1.whiley:3: incomparable operands: real and int
if 1.23 in xs:
^^^^^^^^^^
diff --git a/tests/invalid/ListElemOf_Invalid_1.whiley b/tests/invalid/ListElemOf_Invalid_1.whiley
index 3b8edc3851..4be9e47c51 100644
--- a/tests/invalid/ListElemOf_Invalid_1.whiley
+++ b/tests/invalid/ListElemOf_Invalid_1.whiley
@@ -1,6 +1,4 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method g() -> void:
[int] xs = [1, 2, 3]
if 1.23 in xs:
- sys.out.println(Any.toString(1))
+ debug "GOT HERE"
diff --git a/tests/invalid/ListEmpty_Invalid_1.sysout b/tests/invalid/ListEmpty_Invalid_1.sysout
index 51967d05d3..b7727dd940 100644
--- a/tests/invalid/ListEmpty_Invalid_1.sysout
+++ b/tests/invalid/ListEmpty_Invalid_1.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/ListEmpty_Invalid_1.whiley:7: unable to resolve name (no match for f([void])
- found: ListEmpty_Invalid_1:f : function(int) -> void)
+../../tests/invalid/ListEmpty_Invalid_1.whiley:5: unable to resolve name (no match for f([void])
+ found: ListEmpty_Invalid_1:f : function(int) -> int)
f([])
^^^^^
diff --git a/tests/invalid/ListEmpty_Invalid_1.whiley b/tests/invalid/ListEmpty_Invalid_1.whiley
index dd2f78d1a8..cdab1e0564 100644
--- a/tests/invalid/ListEmpty_Invalid_1.whiley
+++ b/tests/invalid/ListEmpty_Invalid_1.whiley
@@ -1,7 +1,5 @@
-import * from whiley.lang.*
+function f(int x) -> int:
+ return 1
-function f(int x) -> void:
- debug Any.toString(x)
-
-method main(System.Console sys) -> void:
+method main():
f([])
diff --git a/tests/invalid/ListLength_Invalid_2.whiley b/tests/invalid/ListLength_Invalid_2.whiley
index c9173d84e3..5b08b27642 100644
--- a/tests/invalid/ListLength_Invalid_2.whiley
+++ b/tests/invalid/ListLength_Invalid_2.whiley
@@ -1,5 +1,5 @@
-method main(System.Console sys) -> void:
+method main() -> void:
[int] arr
//
if |sys.args| > 0:
@@ -9,4 +9,3 @@ method main(System.Console sys) -> void:
assert arr[0] < |arr|
assert arr[1] < |arr|
assert arr[2] != |arr|
- debug Any.toString(arr[0])
diff --git a/tests/invalid/ListSublist_Invalid_1.sysout b/tests/invalid/ListSublist_Invalid_1.sysout
index 25e9384674..d91957faab 100644
--- a/tests/invalid/ListSublist_Invalid_1.sysout
+++ b/tests/invalid/ListSublist_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/ListSublist_Invalid_1.whiley:6: expected type int, found real
- [int] sublist = list[-1..end]
- ^^^
+../../tests/invalid/ListSublist_Invalid_1.whiley:4: expected type int, found real
+ return list[-1..end]
+ ^^^
diff --git a/tests/invalid/ListSublist_Invalid_1.whiley b/tests/invalid/ListSublist_Invalid_1.whiley
index e351b17bfd..7710134563 100644
--- a/tests/invalid/ListSublist_Invalid_1.whiley
+++ b/tests/invalid/ListSublist_Invalid_1.whiley
@@ -1,8 +1,4 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> [int]:
real end = 1.2344
[int] list = [1, 2, 3]
- [int] sublist = list[-1..end]
- sys.out.println(Any.toString(list))
- sys.out.println(Any.toString(sublist))
+ return list[-1..end]
diff --git a/tests/invalid/ListSublist_Invalid_2.whiley b/tests/invalid/ListSublist_Invalid_2.whiley
index 6d3e5e14ab..aa3f46145c 100644
--- a/tests/invalid/ListSublist_Invalid_2.whiley
+++ b/tests/invalid/ListSublist_Invalid_2.whiley
@@ -1,6 +1,4 @@
-method main(System.Console sys) -> void:
- list = [1, 2, 3]
- sublist = list[1..4]
- debug Any.toString(list)
- debug Any.toString(sublist)
+method main() -> [int]:
+ [int] list = [1, 2, 3]
+ return list[1..4]
diff --git a/tests/invalid/ListSublist_Invalid_3.sysout b/tests/invalid/ListSublist_Invalid_3.sysout
index 7ea3414023..997bb7cd2c 100644
--- a/tests/invalid/ListSublist_Invalid_3.sysout
+++ b/tests/invalid/ListSublist_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/ListSublist_Invalid_3.whiley:5: unknown variable
- [int] sublist = list[2..x]
- ^
+../../tests/invalid/ListSublist_Invalid_3.whiley:3: unknown variable
+ return list[2..x]
+ ^
diff --git a/tests/invalid/ListSublist_Invalid_3.whiley b/tests/invalid/ListSublist_Invalid_3.whiley
index 4d03f08ecf..09402c0287 100644
--- a/tests/invalid/ListSublist_Invalid_3.whiley
+++ b/tests/invalid/ListSublist_Invalid_3.whiley
@@ -1,7 +1,3 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> [int]:
[int] list = [1, 2, 3]
- [int] sublist = list[2..x]
- sys.out.println(Any.toString(list))
- sys.out.println(Any.toString(sublist))
+ return list[2..x]
diff --git a/tests/invalid/ListUpdate_Invalid_1.whiley b/tests/invalid/ListUpdate_Invalid_1.whiley
index 75413cb24d..21585fa8fa 100644
--- a/tests/invalid/ListUpdate_Invalid_1.whiley
+++ b/tests/invalid/ListUpdate_Invalid_1.whiley
@@ -1,9 +1,3 @@
-import whiley.lang.System
-
function f([int] xs) -> [int]:
xs[0] = 1
return xs
-
-method main(System.Console sys) -> void:
- rs = f([])
- sys.out.println(Any.toString(rs))
diff --git a/tests/invalid/List_Invalid_1.sysout b/tests/invalid/List_Invalid_1.sysout
index f157cecf2c..383508bde7 100644
--- a/tests/invalid/List_Invalid_1.sysout
+++ b/tests/invalid/List_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/List_Invalid_1.whiley:5: unknown variable
+../../tests/invalid/List_Invalid_1.whiley:4: variable may be uninitialised
a2[0] = x
- ^^
+ ^^^^^^^^^
diff --git a/tests/invalid/List_Invalid_1.whiley b/tests/invalid/List_Invalid_1.whiley
index 78a7d2d253..04060ca80f 100644
--- a/tests/invalid/List_Invalid_1.whiley
+++ b/tests/invalid/List_Invalid_1.whiley
@@ -1,5 +1,4 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> void:
+ [int] a2
int x = 1
a2[0] = x
diff --git a/tests/invalid/List_Invalid_2.sysout b/tests/invalid/List_Invalid_2.sysout
index f2ec7c6920..8eea1d46bb 100644
--- a/tests/invalid/List_Invalid_2.sysout
+++ b/tests/invalid/List_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/List_Invalid_2.whiley:4: unknown variable
+../../tests/invalid/List_Invalid_2.whiley:2: unknown variable
int x = a2[0]
^^
diff --git a/tests/invalid/List_Invalid_2.whiley b/tests/invalid/List_Invalid_2.whiley
index 7f4373af64..549a884181 100644
--- a/tests/invalid/List_Invalid_2.whiley
+++ b/tests/invalid/List_Invalid_2.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> void:
int x = a2[0]
diff --git a/tests/invalid/List_Invalid_3.sysout b/tests/invalid/List_Invalid_3.sysout
index 3b6080ab98..a059bfc952 100644
--- a/tests/invalid/List_Invalid_3.sysout
+++ b/tests/invalid/List_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/List_Invalid_3.whiley:5: unknown variable
+../../tests/invalid/List_Invalid_3.whiley:3: unknown variable
int y = a2[x]
^
diff --git a/tests/invalid/List_Invalid_3.whiley b/tests/invalid/List_Invalid_3.whiley
index 2fc9669f8f..a22735ec6a 100644
--- a/tests/invalid/List_Invalid_3.whiley
+++ b/tests/invalid/List_Invalid_3.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> void:
[int] a2 = [1, 2, 3]
int y = a2[x]
diff --git a/tests/invalid/List_Invalid_4.sysout b/tests/invalid/List_Invalid_4.sysout
index 9a74ab7243..0b15376d4d 100644
--- a/tests/invalid/List_Invalid_4.sysout
+++ b/tests/invalid/List_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/List_Invalid_4.whiley:5: invalid set or list expression
+../../tests/invalid/List_Invalid_4.whiley:3: invalid set or list expression
int y = x[0]
^
diff --git a/tests/invalid/List_Invalid_4.whiley b/tests/invalid/List_Invalid_4.whiley
index bfc1424351..4bbfab7974 100644
--- a/tests/invalid/List_Invalid_4.whiley
+++ b/tests/invalid/List_Invalid_4.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main():
int x = 1
int y = x[0]
diff --git a/tests/invalid/List_Invalid_5.sysout b/tests/invalid/List_Invalid_5.sysout
index a803e52db0..91bdee4bbc 100644
--- a/tests/invalid/List_Invalid_5.sysout
+++ b/tests/invalid/List_Invalid_5.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/List_Invalid_5.whiley:4: expected type [int], found int
+../../tests/invalid/List_Invalid_5.whiley:2: expected type [int], found int
return 1
^
diff --git a/tests/invalid/List_Invalid_5.whiley b/tests/invalid/List_Invalid_5.whiley
index 8d686fc15d..6d8b8a3800 100644
--- a/tests/invalid/List_Invalid_5.whiley
+++ b/tests/invalid/List_Invalid_5.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f() -> [int]:
return 1
diff --git a/tests/invalid/List_Invalid_6.sysout b/tests/invalid/List_Invalid_6.sysout
index 87ee047be1..4d5a085523 100644
--- a/tests/invalid/List_Invalid_6.sysout
+++ b/tests/invalid/List_Invalid_6.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/List_Invalid_6.whiley:4: expected type int, found [int]
+../../tests/invalid/List_Invalid_6.whiley:2: expected type int, found [int]
return a
^
diff --git a/tests/invalid/List_Invalid_6.whiley b/tests/invalid/List_Invalid_6.whiley
index 0d93485ef4..5b717008d8 100644
--- a/tests/invalid/List_Invalid_6.whiley
+++ b/tests/invalid/List_Invalid_6.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f([int] a) -> int:
return a
diff --git a/tests/invalid/MethodCall_Invalid_1.sysout b/tests/invalid/MethodCall_Invalid_1.sysout
index 7c1ada1381..ee15fa7964 100644
--- a/tests/invalid/MethodCall_Invalid_1.sysout
+++ b/tests/invalid/MethodCall_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/MethodCall_Invalid_1.whiley:7: unable to resolve name (no match for f(whiley/lang/System:Console,int))
- f(sys, 1)
- ^^^^^^^^^
+../../tests/invalid/MethodCall_Invalid_1.whiley:5: unable to resolve name (no match for f(&int,int))
+ f(this, 1)
+ ^^^^^^^^^^
diff --git a/tests/invalid/MethodCall_Invalid_1.whiley b/tests/invalid/MethodCall_Invalid_1.whiley
index 5a78c91891..2548ebd4c5 100644
--- a/tests/invalid/MethodCall_Invalid_1.whiley
+++ b/tests/invalid/MethodCall_Invalid_1.whiley
@@ -1,7 +1,5 @@
-import * from whiley.lang.*
+method f(int x) -> int:
+ return 1
-function f(int x) -> void:
- debug Any.toString(x)
-
-method main(System.Console sys) -> void:
- f(sys, 1)
+method main(&int this):
+ f(this, 1)
diff --git a/tests/invalid/MethodCall_Invalid_2.sysout b/tests/invalid/MethodCall_Invalid_2.sysout
index 47fb017b5a..7b10def859 100644
--- a/tests/invalid/MethodCall_Invalid_2.sysout
+++ b/tests/invalid/MethodCall_Invalid_2.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/MethodCall_Invalid_2.whiley:9: unable to resolve name (no match for f(whiley/lang/System:Console,int)
- found: MethodCall_Invalid_2:f : method(MethodCall_Invalid_2:dummy,int) -> void)
- f(sys, 1)
- ^^^^^^^^^
+../../tests/invalid/MethodCall_Invalid_2.whiley:7: unable to resolve name (no match for f(&int,int)
+ found: MethodCall_Invalid_2:f : method(MethodCall_Invalid_2:dummy,int) -> int)
+ f(this, 1)
+ ^^^^^^^^^^
diff --git a/tests/invalid/MethodCall_Invalid_2.whiley b/tests/invalid/MethodCall_Invalid_2.whiley
index 25c449701f..0696d3e39d 100644
--- a/tests/invalid/MethodCall_Invalid_2.whiley
+++ b/tests/invalid/MethodCall_Invalid_2.whiley
@@ -1,9 +1,7 @@
-import * from whiley.lang.*
-
type dummy is &{int x}
-method f(dummy this, int x) -> void:
- debug Any.toString(x)
+method f(dummy this, int x) -> int:
+ return 1
-method main(System.Console sys) -> void:
- f(sys, 1)
+method main(&int this) -> void:
+ f(this, 1)
diff --git a/tests/invalid/MethodCall_Invalid_3.sysout b/tests/invalid/MethodCall_Invalid_3.sysout
index 82dd14e0e7..25837c5d46 100644
--- a/tests/invalid/MethodCall_Invalid_3.sysout
+++ b/tests/invalid/MethodCall_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/MethodCall_Invalid_3.whiley:4: record required, got: [[int]]
+../../tests/invalid/MethodCall_Invalid_3.whiley:2: record required, got: [int]
this.f(1)
^^^^^^^^^
diff --git a/tests/invalid/MethodCall_Invalid_3.whiley b/tests/invalid/MethodCall_Invalid_3.whiley
index d67acc0b60..5d7ce0df46 100644
--- a/tests/invalid/MethodCall_Invalid_3.whiley
+++ b/tests/invalid/MethodCall_Invalid_3.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
-method main(System.Console sys, [string] this) -> void:
+method main([int] this) -> void:
this.f(1)
diff --git a/tests/invalid/MethodCall_Invalid_4.sysout b/tests/invalid/MethodCall_Invalid_4.sysout
index 4dfac9d252..4fcb3cdc15 100644
--- a/tests/invalid/MethodCall_Invalid_4.sysout
+++ b/tests/invalid/MethodCall_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/MethodCall_Invalid_4.whiley:4: record has no field named get
- return x.get()
- ^^^^^^^
+../../tests/invalid/MethodCall_Invalid_4.whiley:2: method invocation not permitted in function
+ return get(y)
+ ^^^^^^
diff --git a/tests/invalid/MethodCall_Invalid_4.whiley b/tests/invalid/MethodCall_Invalid_4.whiley
index c88bd0260c..c44d68ce5b 100644
--- a/tests/invalid/MethodCall_Invalid_4.whiley
+++ b/tests/invalid/MethodCall_Invalid_4.whiley
@@ -1,10 +1,5 @@
-import * from whiley.lang.*
+function f(int y) -> int:
+ return get(y)
-function f(System.Console x, int y) -> int:
- return x.get()
-
-method get(System this) -> int:
- return 1
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(this, 1)))
+method get(int z) -> int:
+ return z
diff --git a/tests/invalid/MethodCall_Invalid_5.sysout b/tests/invalid/MethodCall_Invalid_5.sysout
index 8a19bb5788..fc3b4c086d 100644
--- a/tests/invalid/MethodCall_Invalid_5.sysout
+++ b/tests/invalid/MethodCall_Invalid_5.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/MethodCall_Invalid_5.whiley:4: method invocation not permitted in function
- return [1, 2, 3, get(x)]
- ^^^^^^
+../../tests/invalid/MethodCall_Invalid_5.whiley:2: method invocation not permitted in function
+ return [1, 2, 3, get()]
+ ^^^^^
diff --git a/tests/invalid/MethodCall_Invalid_5.whiley b/tests/invalid/MethodCall_Invalid_5.whiley
index 887743d04d..d45d91ec3f 100644
--- a/tests/invalid/MethodCall_Invalid_5.whiley
+++ b/tests/invalid/MethodCall_Invalid_5.whiley
@@ -1,10 +1,5 @@
-import * from whiley.lang.*
+function f(int y) -> [int]:
+ return [1, 2, 3, get()]
-function f(System.Console x, int y) -> [int]:
- return [1, 2, 3, get(x)]
-
-method get(System.Console this) -> int:
+method get() -> int:
return 1
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(sys, 1)))
diff --git a/tests/invalid/MethodCall_Invalid_6.sysout b/tests/invalid/MethodCall_Invalid_6.sysout
index e18029d094..672e365e63 100644
--- a/tests/invalid/MethodCall_Invalid_6.sysout
+++ b/tests/invalid/MethodCall_Invalid_6.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/MethodCall_Invalid_6.whiley:6: method invocation not permitted in function
- return {y: get(x), x: 1}
- ^^^^^^
+../../tests/invalid/MethodCall_Invalid_6.whiley:4: method invocation not permitted in function
+ return {y: get(), x: 1}
+ ^^^^^
diff --git a/tests/invalid/MethodCall_Invalid_6.whiley b/tests/invalid/MethodCall_Invalid_6.whiley
index 325e9dd146..6d4ba79367 100644
--- a/tests/invalid/MethodCall_Invalid_6.whiley
+++ b/tests/invalid/MethodCall_Invalid_6.whiley
@@ -1,12 +1,7 @@
-import * from whiley.lang.*
-
type wmccf6tup is {int y, int x}
-function f(System.Console x, int y) -> wmccf6tup:
- return {y: get(x), x: 1}
+function f(int y) -> wmccf6tup:
+ return {y: get(), x: 1}
-method get(System.Console this) -> int:
+method get() -> int:
return 1
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(sys, 1)))
diff --git a/tests/invalid/MethodCall_Invalid_7.sysout b/tests/invalid/MethodCall_Invalid_7.sysout
index 7121b26dc3..c4f5d4c0c1 100644
--- a/tests/invalid/MethodCall_Invalid_7.sysout
+++ b/tests/invalid/MethodCall_Invalid_7.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/MethodCall_Invalid_7.whiley:6: method invocation not permitted in function
- return {y: get(x), x: 1}
- ^^^^^^
+../../tests/invalid/MethodCall_Invalid_7.whiley:4: method invocation not permitted in function
+ return {y: get(), x: 1}
+ ^^^^^
diff --git a/tests/invalid/MethodCall_Invalid_7.whiley b/tests/invalid/MethodCall_Invalid_7.whiley
index fa70bbf442..400c379e74 100644
--- a/tests/invalid/MethodCall_Invalid_7.whiley
+++ b/tests/invalid/MethodCall_Invalid_7.whiley
@@ -1,12 +1,7 @@
-import * from whiley.lang.*
-
type wmccf7tup is {int y, int x}
-function f(System.Console x, int y) -> wmccf7tup:
- return {y: get(x), x: 1}
+function f(int y) -> wmccf7tup:
+ return {y: get(), x: 1}
-method get(System.Console this) -> int:
+method get() -> int:
return 1
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(sys, 1)))
diff --git a/tests/invalid/MethodCall_Invalid_8.sysout b/tests/invalid/MethodCall_Invalid_8.sysout
index 252a40937e..a99cc87bd4 100644
--- a/tests/invalid/MethodCall_Invalid_8.sysout
+++ b/tests/invalid/MethodCall_Invalid_8.sysout
@@ -1,3 +1,3 @@
../../tests/invalid/MethodCall_Invalid_8.whiley:1: object creation not permitted in function
-import * from whiley.lang.*
+function f() -> int:
diff --git a/tests/invalid/MethodCall_Invalid_8.whiley b/tests/invalid/MethodCall_Invalid_8.whiley
index ff2fd55f98..25e131000b 100644
--- a/tests/invalid/MethodCall_Invalid_8.whiley
+++ b/tests/invalid/MethodCall_Invalid_8.whiley
@@ -1,9 +1,3 @@
-import * from whiley.lang.*
-
function f() -> int:
&int x = new 1
return 1
-
-method main(System.Console sys) -> void:
- int x = f()
- sys.out.println(Any.toString(x))
diff --git a/tests/invalid/MethodRef_Invalid_1.whiley b/tests/invalid/MethodRef_Invalid_1.whiley
index 14171d2641..fd9cc4fb69 100644
--- a/tests/invalid/MethodRef_Invalid_1.whiley
+++ b/tests/invalid/MethodRef_Invalid_1.whiley
@@ -1,5 +1,8 @@
-import * from whiley.lang.*
-
type FileReader is {int position, [byte] data}
-type Reader is {int ::(FileReader, int) read}
+type Reader is {
+ method(FileReader, int)->int read
+}
+
+function f(Reader r) -> int:
+ return 1
\ No newline at end of file
diff --git a/tests/invalid/MethodRef_Invalid_2.whiley b/tests/invalid/MethodRef_Invalid_2.whiley
index 4d47d204ca..ef7d31d2d5 100644
--- a/tests/invalid/MethodRef_Invalid_2.whiley
+++ b/tests/invalid/MethodRef_Invalid_2.whiley
@@ -1,13 +1,11 @@
-import * from whiley.lang.*
-
type MyMeth is method(int) -> int
method read(int x) -> int:
return x + 123
method test(MyMeth m) -> int:
- return m(1)
+ return m(1.2)
-method main(System.Console sys) -> void:
- int r = test(&read)
- sys.out.println(Any.toString(r))
+method main() -> int:
+ return test(&read)
+
diff --git a/tests/invalid/MethodRef_Invalid_3.whiley b/tests/invalid/MethodRef_Invalid_3.whiley
index 552c43225a..0c8c0aa01c 100644
--- a/tests/invalid/MethodRef_Invalid_3.whiley
+++ b/tests/invalid/MethodRef_Invalid_3.whiley
@@ -1,13 +1,7 @@
-import * from whiley.lang.*
-
-type MyMeth is int ::(int)
+type MyMeth is method(int)->int
method read(int x) -> int:
return x + 123
function test(MyMeth m) -> int:
return m(1)
-
-method main(System.Console sys) -> void:
- r = test(&read)
- sys.out.println(Any.toString(r))
diff --git a/tests/invalid/NegationType_Invalid_2.whiley b/tests/invalid/NegationType_Invalid_2.whiley
index 73cdabe678..3022e237cb 100644
--- a/tests/invalid/NegationType_Invalid_2.whiley
+++ b/tests/invalid/NegationType_Invalid_2.whiley
@@ -1,7 +1,2 @@
-import * from whiley.lang.*
-
function f(int x) -> !null & !int:
return x
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f("Hello World")))
diff --git a/tests/invalid/NegationType_Invalid_3.sysout b/tests/invalid/NegationType_Invalid_3.sysout
index 488639def5..42ae2f9f79 100644
--- a/tests/invalid/NegationType_Invalid_3.sysout
+++ b/tests/invalid/NegationType_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/NegationType_Invalid_3.whiley:6: expected type !(null|int), found NegationType_Invalid_3:LinkedList
+../../tests/invalid/NegationType_Invalid_3.whiley:4: expected type !(null|int), found NegationType_Invalid_3:LinkedList
return x
^
diff --git a/tests/invalid/NegationType_Invalid_3.whiley b/tests/invalid/NegationType_Invalid_3.whiley
index 6977cd099b..b5401ffc83 100644
--- a/tests/invalid/NegationType_Invalid_3.whiley
+++ b/tests/invalid/NegationType_Invalid_3.whiley
@@ -1,9 +1,4 @@
-import * from whiley.lang.*
-
type LinkedList is null | {LinkedList next, int data}
function f(LinkedList x) -> !null | int:
return x
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f("Hello World")))
diff --git a/tests/invalid/OpenRecord_Invalid_1.sysout b/tests/invalid/OpenRecord_Invalid_1.sysout
index e85d1f74d0..8fb0719bfb 100644
--- a/tests/invalid/OpenRecord_Invalid_1.sysout
+++ b/tests/invalid/OpenRecord_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/OpenRecord_Invalid_1.whiley:13: expected type OpenRecord_Invalid_1:OpenRecord, found {int x,int y}
- r = {y: 2, x: 1}
- ^
+../../tests/invalid/OpenRecord_Invalid_1.whiley:7: expecting ":" here
+ OpenRecord r = {y: 2, x: 1}
+ ^
diff --git a/tests/invalid/OpenRecord_Invalid_1.whiley b/tests/invalid/OpenRecord_Invalid_1.whiley
index cdd1119706..9397f45f2c 100644
--- a/tests/invalid/OpenRecord_Invalid_1.whiley
+++ b/tests/invalid/OpenRecord_Invalid_1.whiley
@@ -1,14 +1,8 @@
-import * from whiley.lang.*
-
type OpenRecord is {int field, ...}
function getField(OpenRecord r) -> int:
return r.field
-method main(System.Console sys) -> void:
- OpenRecord r = {field: 1}
- sys.out.println(getField(r))
- r = {field: 2, x: "hello"}
- sys.out.println(getField(r))
- r = {y: 2, x: 1}
- sys.out.println(getField(r))
+method g() -> int
+ OpenRecord r = {y: 2, x: 1}
+ return getField(r)
diff --git a/tests/invalid/OpenRecord_Invalid_2.whiley b/tests/invalid/OpenRecord_Invalid_2.whiley
index 52bc961a82..5b778eb10c 100644
--- a/tests/invalid/OpenRecord_Invalid_2.whiley
+++ b/tests/invalid/OpenRecord_Invalid_2.whiley
@@ -1,22 +1,10 @@
-import * from whiley.lang.*
-
type OpenRecord is {int x, ...}
-function getField(OpenRecord r) -> string:
+function getField(OpenRecord r) -> int:
if r is {int x}:
- return "(1 field): " ++ r.x
+ return 0
else:
if r is {int z, int y}:
- return (("(2 fields): " ++ r.x) ++ ", ") + r.y
+ return 1
else:
- return ("(? fields): " ++ r.x) ++ ", ..."
-
-method main(System.Console sys) -> void:
- r = {x: 1}
- sys.out.println(getField(r))
- r = {y: "hello", x: 2}
- sys.out.println(getField(r))
- r = {y: 1, x: 3}
- sys.out.println(getField(r))
- r = {z: 1, y: 1, x: 3}
- sys.out.println(getField(r))
+ return 2
diff --git a/tests/invalid/OpenRecord_Invalid_3.sysout b/tests/invalid/OpenRecord_Invalid_3.sysout
index 11c00f9cbf..492abcf5ff 100644
--- a/tests/invalid/OpenRecord_Invalid_3.sysout
+++ b/tests/invalid/OpenRecord_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/OpenRecord_Invalid_3.whiley:8: expected type OpenRecord_Invalid_3:OpenRecord2, found OpenRecord_Invalid_3:OpenRecord1
+../../tests/invalid/OpenRecord_Invalid_3.whiley:6: expected type OpenRecord_Invalid_3:OpenRecord2, found OpenRecord_Invalid_3:OpenRecord1
return r
^
diff --git a/tests/invalid/OpenRecord_Invalid_3.whiley b/tests/invalid/OpenRecord_Invalid_3.whiley
index cb578c2a7f..96a5092890 100644
--- a/tests/invalid/OpenRecord_Invalid_3.whiley
+++ b/tests/invalid/OpenRecord_Invalid_3.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type OpenRecord1 is {int field, ...}
type OpenRecord2 is {int x, ...}
diff --git a/tests/invalid/OpenRecord_Invalid_4.sysout b/tests/invalid/OpenRecord_Invalid_4.sysout
index c6ae592228..6b14e00d39 100644
--- a/tests/invalid/OpenRecord_Invalid_4.sysout
+++ b/tests/invalid/OpenRecord_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/OpenRecord_Invalid_4.whiley:8: expected type OpenRecord_Invalid_4:OpenRecord2, found OpenRecord_Invalid_4:OpenRecord1
+../../tests/invalid/OpenRecord_Invalid_4.whiley:6: expected type OpenRecord_Invalid_4:OpenRecord2, found OpenRecord_Invalid_4:OpenRecord1
return r
^
diff --git a/tests/invalid/OpenRecord_Invalid_4.whiley b/tests/invalid/OpenRecord_Invalid_4.whiley
index 3c8f60c4cb..a99e175e3e 100644
--- a/tests/invalid/OpenRecord_Invalid_4.whiley
+++ b/tests/invalid/OpenRecord_Invalid_4.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type OpenRecord1 is {int field, ...}
type OpenRecord2 is {int field, int x, ...}
diff --git a/tests/invalid/OpenRecord_Invalid_5.sysout b/tests/invalid/OpenRecord_Invalid_5.sysout
index 6a4e67a2a8..3615922ca0 100644
--- a/tests/invalid/OpenRecord_Invalid_5.sysout
+++ b/tests/invalid/OpenRecord_Invalid_5.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/OpenRecord_Invalid_5.whiley:8: expected type OpenRecord_Invalid_5:OpenRecord2, found OpenRecord_Invalid_5:OpenRecord1
+../../tests/invalid/OpenRecord_Invalid_5.whiley:6: expected type OpenRecord_Invalid_5:OpenRecord2, found OpenRecord_Invalid_5:OpenRecord1
return r
^
diff --git a/tests/invalid/OpenRecord_Invalid_5.whiley b/tests/invalid/OpenRecord_Invalid_5.whiley
index 05e4e6a26b..e3b095b6d9 100644
--- a/tests/invalid/OpenRecord_Invalid_5.whiley
+++ b/tests/invalid/OpenRecord_Invalid_5.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type OpenRecord1 is {int field, ...}
type OpenRecord2 is {int field}
diff --git a/tests/invalid/OpenRecord_Invalid_6.sysout b/tests/invalid/OpenRecord_Invalid_6.sysout
index 364cf06656..8ef45b2335 100644
--- a/tests/invalid/OpenRecord_Invalid_6.sysout
+++ b/tests/invalid/OpenRecord_Invalid_6.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/OpenRecord_Invalid_6.whiley:8: expected type OpenRecord_Invalid_6:OpenRecord2, found OpenRecord_Invalid_6:OpenRecord1
+../../tests/invalid/OpenRecord_Invalid_6.whiley:6: expected type OpenRecord_Invalid_6:OpenRecord2, found OpenRecord_Invalid_6:OpenRecord1
return r
^
diff --git a/tests/invalid/OpenRecord_Invalid_6.whiley b/tests/invalid/OpenRecord_Invalid_6.whiley
index b341ff3bcf..7da28c3e39 100644
--- a/tests/invalid/OpenRecord_Invalid_6.whiley
+++ b/tests/invalid/OpenRecord_Invalid_6.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type OpenRecord1 is {int field, ...}
type OpenRecord2 is {int field, int otherField}
diff --git a/tests/invalid/OpenRecord_Invalid_7.sysout b/tests/invalid/OpenRecord_Invalid_7.sysout
index 67ab78b86c..4a526fe135 100644
--- a/tests/invalid/OpenRecord_Invalid_7.sysout
+++ b/tests/invalid/OpenRecord_Invalid_7.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/OpenRecord_Invalid_7.whiley:8: expected type OpenRecord_Invalid_7:OpenRecord2, found OpenRecord_Invalid_7:OpenRecord1
+../../tests/invalid/OpenRecord_Invalid_7.whiley:6: expected type OpenRecord_Invalid_7:OpenRecord2, found OpenRecord_Invalid_7:OpenRecord1
return r
^
diff --git a/tests/invalid/OpenRecord_Invalid_7.whiley b/tests/invalid/OpenRecord_Invalid_7.whiley
index cea4e9abf7..e672c454b6 100644
--- a/tests/invalid/OpenRecord_Invalid_7.whiley
+++ b/tests/invalid/OpenRecord_Invalid_7.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type OpenRecord1 is {int field, ...}
type OpenRecord2 is {int field, int aField}
diff --git a/tests/invalid/ProcessAccess_Invalid_1.sysout b/tests/invalid/ProcessAccess_Invalid_1.sysout
index dbb951f535..55c29b5292 100644
--- a/tests/invalid/ProcessAccess_Invalid_1.sysout
+++ b/tests/invalid/ProcessAccess_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/ProcessAccess_Invalid_1.whiley:8: invalid assignment expression
+../../tests/invalid/ProcessAccess_Invalid_1.whiley:6: invalid assignment expression
this.op = 1
^^
diff --git a/tests/invalid/ProcessAccess_Invalid_1.whiley b/tests/invalid/ProcessAccess_Invalid_1.whiley
index f040fd457c..64c106eb04 100644
--- a/tests/invalid/ProcessAccess_Invalid_1.whiley
+++ b/tests/invalid/ProcessAccess_Invalid_1.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type etype is {int mode, ...}
type Ptype is &etype
@@ -7,6 +5,3 @@ type Ptype is &etype
method get(Ptype this) -> int:
this.op = 1
return this.mode
-
-method main(System.Console sys) -> void:
- sys.out.println("OK")
diff --git a/tests/invalid/ProcessAccess_Invalid_2.sysout b/tests/invalid/ProcessAccess_Invalid_2.sysout
index eb01881074..c2528fe7f0 100644
--- a/tests/invalid/ProcessAccess_Invalid_2.sysout
+++ b/tests/invalid/ProcessAccess_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/ProcessAccess_Invalid_2.whiley:12: unable to resolve name (no match for toString())
- sys.out.println(Any.toString() * p)
- ^^^^^^^^^^^^^^
+../../tests/invalid/ProcessAccess_Invalid_2.whiley:6: expected type ProcessAccess_Invalid_2:pState, found &{int x,int z}
+ this = new {z: 4, x: 3}
+ ^^^^
diff --git a/tests/invalid/ProcessAccess_Invalid_2.whiley b/tests/invalid/ProcessAccess_Invalid_2.whiley
index 13b61d5f53..2b20ce2242 100644
--- a/tests/invalid/ProcessAccess_Invalid_2.whiley
+++ b/tests/invalid/ProcessAccess_Invalid_2.whiley
@@ -1,14 +1,6 @@
-import * from whiley.lang.*
-
type state is {int y, int x}
type pState is &state
method f(pState this) -> void:
- this = new {y: 4, x: 3}
-
-method main(System.Console sys) -> void:
- pState p = new {y: 2, x: 1}
- sys.out.println(Any.toString() * p)
- p.f()
- sys.out.println(Any.toString() * p)
+ this = new {z: 4, x: 3}
diff --git a/tests/invalid/ProcessAccess_Invalid_3.sysout b/tests/invalid/ProcessAccess_Invalid_3.sysout
index c9f6befef4..f7aacd7599 100644
--- a/tests/invalid/ProcessAccess_Invalid_3.sysout
+++ b/tests/invalid/ProcessAccess_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/ProcessAccess_Invalid_3.whiley:6: invalid assignment expression
+../../tests/invalid/ProcessAccess_Invalid_3.whiley:4: invalid assignment expression
p.data = this.data
^^^^
diff --git a/tests/invalid/ProcessAccess_Invalid_3.whiley b/tests/invalid/ProcessAccess_Invalid_3.whiley
index de3bb90af3..9ae03a8aa2 100644
--- a/tests/invalid/ProcessAccess_Invalid_3.whiley
+++ b/tests/invalid/ProcessAccess_Invalid_3.whiley
@@ -1,19 +1,12 @@
-import * from whiley.lang.*
-
type MyProc is &{int data}
-method copy(MyProc this, MyProc p) -> int:
+method copy(MyProc this, MyProc p):
p.data = this.data
-method get(MyProc this) -> int:
- return this.data
-
-method create(System this, int data) -> MyProc:
+method create(int data) -> MyProc:
return new {data: data}
-method main(System.Console sys) -> void:
- p1 = this.create(1)
- p2 = this.create(2)
- p1.copy(p2)
- sys.out.println(Any.toString(p1.get()))
- sys.out.println(Any.toString(p2.get()))
+method main() -> void:
+ MyProc p1 = create(1)
+ MyProc p2 = create(2)
+ copy(p1,p2)
diff --git a/tests/invalid/Process_Invalid_1.sysout b/tests/invalid/Process_Invalid_1.sysout
index 2e1cf64870..c10852e1a5 100644
--- a/tests/invalid/Process_Invalid_1.sysout
+++ b/tests/invalid/Process_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Process_Invalid_1.whiley:8: invalid assignment expression
+../../tests/invalid/Process_Invalid_1.whiley:5: invalid assignment expression
this.data = d
^^^^
diff --git a/tests/invalid/Process_Invalid_1.whiley b/tests/invalid/Process_Invalid_1.whiley
index 2778d2fd26..7920542d97 100644
--- a/tests/invalid/Process_Invalid_1.whiley
+++ b/tests/invalid/Process_Invalid_1.whiley
@@ -1,7 +1,4 @@
-import * from whiley.lang.*
-
type MyProc1 is &{int data}
-
type MyProc2 is &{any data}
method set(MyProc2 this, any d) -> void:
@@ -10,10 +7,10 @@ method set(MyProc2 this, any d) -> void:
method get(MyProc1 this) -> int:
return this.data
-method create(System this, int data) -> MyProc1:
+method create(int data) -> MyProc1:
return new {data: data}
-method main(System.Console sys) -> void:
- p2 = this.create(1)
- p2.set(1.23)
- sys.out.println(Any.toString(p2.get()))
+method main() -> int:
+ MyProc2 p = create(1)
+ p.set(1.23)
+ return get(p)
diff --git a/tests/invalid/Process_Invalid_2.sysout b/tests/invalid/Process_Invalid_2.sysout
index de3f455797..0534d97175 100644
--- a/tests/invalid/Process_Invalid_2.sysout
+++ b/tests/invalid/Process_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Process_Invalid_2.whiley:9: record required, got: &{[int] items}
- int item = this.items[0]
- ^^^^^^^^^^
+../../tests/invalid/Process_Invalid_2.whiley:6: index out of bounds (not less than length)
+ int item = this->items[0]
+ ^^^^^^^^^^^^^^
diff --git a/tests/invalid/Process_Invalid_2.whiley b/tests/invalid/Process_Invalid_2.whiley
index 0463a315d5..6c9a71d98e 100644
--- a/tests/invalid/Process_Invalid_2.whiley
+++ b/tests/invalid/Process_Invalid_2.whiley
@@ -1,20 +1,17 @@
-import * from whiley.lang.*
-import * from whiley.lang.*
-
type EmptyQueue is &{[void] items}
type Queue is &{[int] items}
method get(Queue this) -> int:
- int item = this.items[0]
- this.items = this.items[1..|this.items|]
+ int item = this->items[0]
+ this->items = this->items[1..|this->items|]
return item
method put(Queue this, int item) -> void:
- this.items = this.items ++ [item]
+ this->items = this->items ++ [item]
method isEmpty(Queue this) -> bool:
- return |this.items| == 0
+ return |this->items| == 0
method EmptyQueue() -> EmptyQueue:
return new {items: []}
diff --git a/tests/invalid/Process_Invalid_3.sysout b/tests/invalid/Process_Invalid_3.sysout
index 1dca2c5fcd..67dbec7929 100644
--- a/tests/invalid/Process_Invalid_3.sysout
+++ b/tests/invalid/Process_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Process_Invalid_3.whiley:9: record required, got: &{[int] items}
- int item = this.items[0]
- ^^^^^^^^^^
+../../tests/invalid/Process_Invalid_3.whiley:6: index out of bounds (not less than length)
+ int item = this->items[0]
+ ^^^^^^^^^^^^^^
diff --git a/tests/invalid/Process_Invalid_3.whiley b/tests/invalid/Process_Invalid_3.whiley
index 54d35fd844..0d32cff61f 100644
--- a/tests/invalid/Process_Invalid_3.whiley
+++ b/tests/invalid/Process_Invalid_3.whiley
@@ -1,20 +1,17 @@
-import * from whiley.lang.*
-import * from whiley.lang.*
-
type EmptyQueue is &{[void] items}
type Queue is &{[int] items}
method get(Queue this) -> int:
- int item = this.items[0]
- this.items = this.items[1..|this.items|]
+ int item = this->items[0]
+ this->items = this->items[1..|this->items|]
return item
method put(Queue this, int item) -> void:
- this.items = this.items ++ [item]
+ this->items = this->items ++ [item]
method isEmpty(Queue this) -> bool:
- return |this.items| == 0
+ return |this->items| == 0
method EmptyQueue() -> EmptyQueue:
return new {items: []}
diff --git a/tests/invalid/Quantifiers_Invalid_3.sysout b/tests/invalid/Quantifiers_Invalid_3.sysout
index 4ae9cd933d..0eecd532bb 100644
--- a/tests/invalid/Quantifiers_Invalid_3.sysout
+++ b/tests/invalid/Quantifiers_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Quantifiers_Invalid_3.whiley:7: precondition not satisfied
+../../tests/invalid/Quantifiers_Invalid_3.whiley:6: precondition not satisfied
f([-1, 0, 1, 2, 3])
^^^^^^^^^^^^^^^^^^^
diff --git a/tests/invalid/Quantifiers_Invalid_3.whiley b/tests/invalid/Quantifiers_Invalid_3.whiley
index 3ce48cb9bc..7188268dd5 100644
--- a/tests/invalid/Quantifiers_Invalid_3.whiley
+++ b/tests/invalid/Quantifiers_Invalid_3.whiley
@@ -1,4 +1,3 @@
-
function f([int] ls) -> bool
requires no { i in {0, 1, 2, 3, 4} | (i >= 0) && ((i < |ls|) && (ls[i] < 0)) }:
return true
diff --git a/tests/invalid/RealAdd_Invalid_1.sysout b/tests/invalid/RealAdd_Invalid_1.sysout
index 447404fbbc..6716ecbf97 100644
--- a/tests/invalid/RealAdd_Invalid_1.sysout
+++ b/tests/invalid/RealAdd_Invalid_1.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/RealAdd_Invalid_1.whiley:8: unable to resolve name (no match for f(real)
+../../tests/invalid/RealAdd_Invalid_1.whiley:6: unable to resolve name (no match for f(real)
found: RealAdd_Invalid_1:f : function(int) -> int)
x = f(2.3 + (real) x)
^^^^^^^^^^^^^^^^^
diff --git a/tests/invalid/RealAdd_Invalid_1.whiley b/tests/invalid/RealAdd_Invalid_1.whiley
index c42242ec32..f18e810538 100644
--- a/tests/invalid/RealAdd_Invalid_1.whiley
+++ b/tests/invalid/RealAdd_Invalid_1.whiley
@@ -1,8 +1,6 @@
-import * from whiley.lang.*
-
function f(int x) -> int:
return x
-method main(System.Console sys) -> void:
+method main():
int x = 1
x = f(2.3 + (real) x)
diff --git a/tests/invalid/RealConvert_Invalid_2.whiley b/tests/invalid/RealConvert_Invalid_2.whiley
index b499ac5040..2cc3357812 100644
--- a/tests/invalid/RealConvert_Invalid_2.whiley
+++ b/tests/invalid/RealConvert_Invalid_2.whiley
@@ -2,7 +2,3 @@
function f(real x, int y) -> real
requires x >= y:
return 0.0
-
-method main(System.Console sys) -> void:
- real x = f(1.0, 1)
- f(x, 1)
diff --git a/tests/invalid/RealDiv_Invalid_1.sysout b/tests/invalid/RealDiv_Invalid_1.sysout
index 652eed1a9c..15536f0b13 100644
--- a/tests/invalid/RealDiv_Invalid_1.sysout
+++ b/tests/invalid/RealDiv_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/RealDiv_Invalid_1.whiley:6: expected type int, found real
- sys.out.println(Any.toString(ls)[x])
- ^
+../../tests/invalid/RealDiv_Invalid_1.whiley:4: expected type int, found real
+ return ls[x]
+ ^
diff --git a/tests/invalid/RealDiv_Invalid_1.whiley b/tests/invalid/RealDiv_Invalid_1.whiley
index 5a5688aff2..175a532a91 100644
--- a/tests/invalid/RealDiv_Invalid_1.whiley
+++ b/tests/invalid/RealDiv_Invalid_1.whiley
@@ -1,6 +1,4 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> int:
[int] ls = [1, 2, 3]
real x = 2.0 / 1.0
- sys.out.println(Any.toString(ls)[x])
+ return ls[x]
diff --git a/tests/invalid/RealMul_Invalid_1.whiley b/tests/invalid/RealMul_Invalid_1.whiley
index fe8ee5374f..724dc17b64 100644
--- a/tests/invalid/RealMul_Invalid_1.whiley
+++ b/tests/invalid/RealMul_Invalid_1.whiley
@@ -4,6 +4,3 @@ requires (x >= 0.5) && (y >= 0.3)
ensures y > 0.65:
//
return 0.5 + (x * y)
-
-method main(System.Console sys) -> void:
- debug Any.toString(f(0.5, 0.3))
diff --git a/tests/invalid/Record_Invalid_1.sysout b/tests/invalid/Record_Invalid_1.sysout
index 6e7c32378b..9b6077f343 100644
--- a/tests/invalid/Record_Invalid_1.sysout
+++ b/tests/invalid/Record_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Record_Invalid_1.whiley:8: incomparable operands: {int x} and {int x,int y}
+../../tests/invalid/Record_Invalid_1.whiley:5: incomparable operands: {int x} and {int x,int y}
return r1 == r2
^^^^^^^^
diff --git a/tests/invalid/Record_Invalid_1.whiley b/tests/invalid/Record_Invalid_1.whiley
index 1a19ff1ffd..19e091bdbd 100644
--- a/tests/invalid/Record_Invalid_1.whiley
+++ b/tests/invalid/Record_Invalid_1.whiley
@@ -1,13 +1,10 @@
-import * from whiley.lang.*
-
type R1 is {int x}
-
type R2 is {int y, int x}
function f(R1 r1, R2 r2) -> bool:
return r1 == r2
-method main(System.Console sys) -> void:
- r1 = {x: 1}
- r2 = {y: 2, x: 1}
- sys.out.println(Any.toString(f(r1, r2)))
+method main() -> bool:
+ R1 r1 = {x: 1}
+ R2 r2 = {y: 2, x: 1}
+ return f(r1,r2)
diff --git a/tests/invalid/RecursiveType_Invalid_1.whiley b/tests/invalid/RecursiveType_Invalid_1.whiley
index d5580e387c..c43b8842fc 100644
--- a/tests/invalid/RecursiveType_Invalid_1.whiley
+++ b/tests/invalid/RecursiveType_Invalid_1.whiley
@@ -12,9 +12,3 @@ function sum(LinkedList list) -> nat:
return 0
else:
return list.data + sum(list.next)
-
-method main(System.Console sys) -> void:
- l = {next: 1, data: 1}
- debug Any.toString(sum(l))
- l = {next: l, data: -2}
- debug Any.toString(sum(l))
diff --git a/tests/invalid/RecursiveType_Invalid_10.whiley b/tests/invalid/RecursiveType_Invalid_10.whiley
index ffaa72e22e..7c686ecb75 100644
--- a/tests/invalid/RecursiveType_Invalid_10.whiley
+++ b/tests/invalid/RecursiveType_Invalid_10.whiley
@@ -9,7 +9,3 @@ type posList is int | posLink
function f(LinkedList list) -> posList:
return list
-
-method main(System.Console sys) -> void:
- l = {next: {next: 1, data: -1}, data: 1}
- debug Any.toString(f(l))
diff --git a/tests/invalid/RecursiveType_Invalid_2.whiley b/tests/invalid/RecursiveType_Invalid_2.whiley
index 3a479132d5..a20b2ea6c5 100644
--- a/tests/invalid/RecursiveType_Invalid_2.whiley
+++ b/tests/invalid/RecursiveType_Invalid_2.whiley
@@ -6,6 +6,5 @@ type expr is nat | {int op, expr left, expr right}
function f(expr e) -> expr:
return e
-method main(System.Console sys) -> void:
- e = -1
- debug Any.toString(f(e))
+method main() -> expr:
+ return f(-1)
diff --git a/tests/invalid/RecursiveType_Invalid_3.sysout b/tests/invalid/RecursiveType_Invalid_3.sysout
index 87c3e4d979..93639e6100 100644
--- a/tests/invalid/RecursiveType_Invalid_3.sysout
+++ b/tests/invalid/RecursiveType_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/RecursiveType_Invalid_3.whiley:9: expected type RecursiveType_Invalid_3:expr, found {[int+] left,int op,int right}
+../../tests/invalid/RecursiveType_Invalid_3.whiley:7: expected type RecursiveType_Invalid_3:expr, found {[int+] left,int op,int right}
expr e = {op: 1, left: "HELLO", right: 2}
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/invalid/RecursiveType_Invalid_3.whiley b/tests/invalid/RecursiveType_Invalid_3.whiley
index 412cb9a480..eb0de76862 100644
--- a/tests/invalid/RecursiveType_Invalid_3.whiley
+++ b/tests/invalid/RecursiveType_Invalid_3.whiley
@@ -1,10 +1,8 @@
-import * from whiley.lang.*
-
type expr is int | {int op, expr left, expr right}
function f(expr e) -> expr:
return e
-method main(System.Console sys) -> void:
+method main() -> expr:
expr e = {op: 1, left: "HELLO", right: 2}
- sys.out.println(Any.toString(f(e)))
+ return f(e)
diff --git a/tests/invalid/RecursiveType_Invalid_4.whiley b/tests/invalid/RecursiveType_Invalid_4.whiley
index b838815124..d2fe3dbb96 100644
--- a/tests/invalid/RecursiveType_Invalid_4.whiley
+++ b/tests/invalid/RecursiveType_Invalid_4.whiley
@@ -14,6 +14,6 @@ type expr is int | binop
function f(expr e) -> expr:
return e
-method main(System.Console sys) -> void:
- e1 = {op: 0, left: {op: MUL, left: 2, right: 2}, right: 2}
- debug Any.toString(f(e1))
+method main() -> expr:
+ expr e1 = {op: 0, left: {op: MUL, left: 2, right: 2}, right: 2}
+ return f(e1)
diff --git a/tests/invalid/RecursiveType_Invalid_5.sysout b/tests/invalid/RecursiveType_Invalid_5.sysout
index 530e9d7bb8..7e4a681f5c 100644
--- a/tests/invalid/RecursiveType_Invalid_5.sysout
+++ b/tests/invalid/RecursiveType_Invalid_5.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/RecursiveType_Invalid_5.whiley:20: expected type RecursiveType_Invalid_5:SExpr, found {RecursiveType_Invalid_5:SExpr lhs,RecursiveType_Invalid_5:SExpr rhs}
- return {rhs: sbuild(i + 1), lhs: sbuild(i + 10)}
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+../../tests/invalid/RecursiveType_Invalid_5.whiley:5: name not found: string
+type Var is {string id}
+ ^^^^^^
diff --git a/tests/invalid/RecursiveType_Invalid_5.whiley b/tests/invalid/RecursiveType_Invalid_5.whiley
index 9ffa29ef23..bfe74cc945 100644
--- a/tests/invalid/RecursiveType_Invalid_5.whiley
+++ b/tests/invalid/RecursiveType_Invalid_5.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type Expr is real | Var | BinOp
type BinOp is {Expr rhs, Expr lhs}
@@ -24,22 +22,3 @@ function sbuild(int i) -> SExpr:
return {err: "error"}
else:
return build(i)
-
-function evaluate(Expr e) -> real:
- if e is real:
- return e
- if e is {[int] id}:
- return |e.id|
- else:
- return evaluate(e.lhs) + evaluate(e.rhs)
-
-public method main(System.Console sys) -> void:
- i = -5
- while i < 10:
- e = sbuild(i)
- if e is {[int] err}:
- sys.out.println("syntax error: " ++ e.err)
- else:
- e = evaluate(e)
- sys.out.println(Any.toString(e))
- i = i + 1
diff --git a/tests/invalid/RecursiveType_Invalid_7.whiley b/tests/invalid/RecursiveType_Invalid_7.whiley
index 9ec6c12a60..d98cb5b19d 100644
--- a/tests/invalid/RecursiveType_Invalid_7.whiley
+++ b/tests/invalid/RecursiveType_Invalid_7.whiley
@@ -14,6 +14,6 @@ type expr is int | binop
function f(expr e) -> expr:
return e
-method main(System.Console sys) -> void:
- e1 = {op: ADD, left: {op: 0, left: 2, right: 2}, right: 2}
- debug Any.toString(f(e1))
+method main() -> expr:
+ expr e1 = {op: ADD, left: {op: 0, left: 2, right: 2}, right: 2}
+ return f(e1)
diff --git a/tests/invalid/RecursiveType_Invalid_8.whiley b/tests/invalid/RecursiveType_Invalid_8.whiley
index d3e2218596..7acbb91898 100644
--- a/tests/invalid/RecursiveType_Invalid_8.whiley
+++ b/tests/invalid/RecursiveType_Invalid_8.whiley
@@ -18,6 +18,6 @@ type asexpr is int | asbinop
function f(asexpr e) -> asexpr:
return e
-method main(System.Console sys) -> void:
- e1 = {op: MUL, left: 1, right: 2}
- f(e1)
+method main() -> expr:
+ expr e1 = {op: MUL, left: 1, right: 2}
+ return f(e1)
diff --git a/tests/invalid/RecursiveType_Invalid_9.whiley b/tests/invalid/RecursiveType_Invalid_9.whiley
index 88be75f712..4eb5fdd1a4 100644
--- a/tests/invalid/RecursiveType_Invalid_9.whiley
+++ b/tests/invalid/RecursiveType_Invalid_9.whiley
@@ -9,7 +9,3 @@ type exp2 is pos | {exp2 rest}
function f(exp1 e1) -> exp2:
return e1
-
-method main(System.Console sys) -> void:
- x = f(-1)
- debug Any.toString(x)
diff --git a/tests/invalid/Remainder_Invalid_1.sysout b/tests/invalid/Remainder_Invalid_1.sysout
index f28579f162..1d28473b39 100644
--- a/tests/invalid/Remainder_Invalid_1.sysout
+++ b/tests/invalid/Remainder_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Remainder_Invalid_1.whiley:4: expected type int, found real
+../../tests/invalid/Remainder_Invalid_1.whiley:2: expected type int, found real
return x % y
^
diff --git a/tests/invalid/Remainder_Invalid_1.whiley b/tests/invalid/Remainder_Invalid_1.whiley
index b40e925423..3c56dee0ae 100644
--- a/tests/invalid/Remainder_Invalid_1.whiley
+++ b/tests/invalid/Remainder_Invalid_1.whiley
@@ -1,22 +1,2 @@
-import * from whiley.lang.*
-
function f(real x, int y) -> int:
return x % y
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(10.23, 5)))
- sys.out.println(Any.toString(f(10.23, 4)))
- sys.out.println(Any.toString(f(1, 4)))
- sys.out.println(Any.toString(f(10.233, 2)))
- sys.out.println(Any.toString(f(-10.23, 5)))
- sys.out.println(Any.toString(f(-10.23, 4)))
- sys.out.println(Any.toString(f(-1, 4)))
- sys.out.println(Any.toString(f(-10.233, 2)))
- sys.out.println(Any.toString(f(-10.23, -5)))
- sys.out.println(Any.toString(f(-10.23, -4)))
- sys.out.println(Any.toString(f(-1, -4)))
- sys.out.println(Any.toString(f(-10.233, -2)))
- sys.out.println(Any.toString(f(10.23, -5)))
- sys.out.println(Any.toString(f(10.23, -4)))
- sys.out.println(Any.toString(f(1, -4)))
- sys.out.println(Any.toString(f(10.233, -2)))
diff --git a/tests/invalid/Remainder_Invalid_2.sysout b/tests/invalid/Remainder_Invalid_2.sysout
index 728291c47f..e1da19de9a 100644
--- a/tests/invalid/Remainder_Invalid_2.sysout
+++ b/tests/invalid/Remainder_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Remainder_Invalid_2.whiley:4: expected type int, found real
+../../tests/invalid/Remainder_Invalid_2.whiley:2: expected type int, found real
return x % y
^
diff --git a/tests/invalid/Remainder_Invalid_2.whiley b/tests/invalid/Remainder_Invalid_2.whiley
index 62438d9e8e..ba0551079f 100644
--- a/tests/invalid/Remainder_Invalid_2.whiley
+++ b/tests/invalid/Remainder_Invalid_2.whiley
@@ -1,22 +1,2 @@
-import * from whiley.lang.*
-
function f(int x, real y) -> int:
return x % y
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(10, 5.23)))
- sys.out.println(Any.toString(f(10, 4)))
- sys.out.println(Any.toString(f(1, 4)))
- sys.out.println(Any.toString(f(103, 2)))
- sys.out.println(Any.toString(f(-10, 5.23)))
- sys.out.println(Any.toString(f(-10, 4)))
- sys.out.println(Any.toString(f(-1, 4)))
- sys.out.println(Any.toString(f(-103, 2)))
- sys.out.println(Any.toString(f(-10, -5.23)))
- sys.out.println(Any.toString(f(-10, -4)))
- sys.out.println(Any.toString(f(-1, -4)))
- sys.out.println(Any.toString(f(-103, -2)))
- sys.out.println(Any.toString(f(10, -5.23)))
- sys.out.println(Any.toString(f(10, -4)))
- sys.out.println(Any.toString(f(1, -4)))
- sys.out.println(Any.toString(f(103, -2)))
diff --git a/tests/invalid/Remainder_Invalid_3.sysout b/tests/invalid/Remainder_Invalid_3.sysout
index 93484d0d20..66a84d61ad 100644
--- a/tests/invalid/Remainder_Invalid_3.sysout
+++ b/tests/invalid/Remainder_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Remainder_Invalid_3.whiley:4: expected type int, found real
+../../tests/invalid/Remainder_Invalid_3.whiley:2: expected type int, found real
return x % y
^
diff --git a/tests/invalid/Remainder_Invalid_3.whiley b/tests/invalid/Remainder_Invalid_3.whiley
index 142d4afd7d..cc3657aebb 100644
--- a/tests/invalid/Remainder_Invalid_3.whiley
+++ b/tests/invalid/Remainder_Invalid_3.whiley
@@ -1,22 +1,2 @@
-import * from whiley.lang.*
-
function f(real x, real y) -> int:
return x % y
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(10.5343, 5.2354)))
- sys.out.println(Any.toString(f(10.5343, 4.2345)))
- sys.out.println(Any.toString(f(1, 4.2345)))
- sys.out.println(Any.toString(f(10.53433, 2)))
- sys.out.println(Any.toString(f(-10.5343, 5.2354)))
- sys.out.println(Any.toString(f(-10.5343, 4.2345)))
- sys.out.println(Any.toString(f(-1, 4.2345)))
- sys.out.println(Any.toString(f(-10.53433, 2)))
- sys.out.println(Any.toString(f(-10.5343, -5)))
- sys.out.println(Any.toString(f(-10.5343, -4)))
- sys.out.println(Any.toString(f(-1, -4)))
- sys.out.println(Any.toString(f(-10.53433, -2)))
- sys.out.println(Any.toString(f(10.5343, -5)))
- sys.out.println(Any.toString(f(10.5343, -4)))
- sys.out.println(Any.toString(f(1, -4)))
- sys.out.println(Any.toString(f(10.53433, -2)))
diff --git a/tests/invalid/Return_Invalid_1.sysout b/tests/invalid/Return_Invalid_1.sysout
index d25ac98062..b00c8598a8 100644
--- a/tests/invalid/Return_Invalid_1.sysout
+++ b/tests/invalid/Return_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_1.whiley:4: expected type bool, found int
+../../tests/invalid/Return_Invalid_1.whiley:2: expected type bool, found int
return 1
^
diff --git a/tests/invalid/Return_Invalid_1.whiley b/tests/invalid/Return_Invalid_1.whiley
index 9202acc964..df210f59a4 100644
--- a/tests/invalid/Return_Invalid_1.whiley
+++ b/tests/invalid/Return_Invalid_1.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f() -> bool:
return 1
diff --git a/tests/invalid/Return_Invalid_10.sysout b/tests/invalid/Return_Invalid_10.sysout
index d85aad6ae0..ac0e04f527 100644
--- a/tests/invalid/Return_Invalid_10.sysout
+++ b/tests/invalid/Return_Invalid_10.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_10.whiley:4: expected type void, found int
+../../tests/invalid/Return_Invalid_10.whiley:2: expected type void, found int
return 1
^
diff --git a/tests/invalid/Return_Invalid_10.whiley b/tests/invalid/Return_Invalid_10.whiley
index 1f5bd2bd92..22d5bfd095 100644
--- a/tests/invalid/Return_Invalid_10.whiley
+++ b/tests/invalid/Return_Invalid_10.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f() -> void:
return 1
diff --git a/tests/invalid/Return_Invalid_11.sysout b/tests/invalid/Return_Invalid_11.sysout
index 94d6c4a0fb..6f0beda251 100644
--- a/tests/invalid/Return_Invalid_11.sysout
+++ b/tests/invalid/Return_Invalid_11.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_11.whiley:4: expected type void, found int
+../../tests/invalid/Return_Invalid_11.whiley:2: expected type void, found int
return x
^
diff --git a/tests/invalid/Return_Invalid_11.whiley b/tests/invalid/Return_Invalid_11.whiley
index 8bcfcbca58..d7c0ed55ba 100644
--- a/tests/invalid/Return_Invalid_11.whiley
+++ b/tests/invalid/Return_Invalid_11.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(int x) -> void:
return x
diff --git a/tests/invalid/Return_Invalid_2.sysout b/tests/invalid/Return_Invalid_2.sysout
index 73fd48a4dc..cd142bbfea 100644
--- a/tests/invalid/Return_Invalid_2.sysout
+++ b/tests/invalid/Return_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_2.whiley:4: expected type void, found bool
+../../tests/invalid/Return_Invalid_2.whiley:2: expected type void, found bool
return true
^^^^
diff --git a/tests/invalid/Return_Invalid_2.whiley b/tests/invalid/Return_Invalid_2.whiley
index 0b94147122..87e0bc8ad8 100644
--- a/tests/invalid/Return_Invalid_2.whiley
+++ b/tests/invalid/Return_Invalid_2.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f() -> void:
return true
diff --git a/tests/invalid/Return_Invalid_3.sysout b/tests/invalid/Return_Invalid_3.sysout
index e6f7e12467..1dc39bac5a 100644
--- a/tests/invalid/Return_Invalid_3.sysout
+++ b/tests/invalid/Return_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_3.whiley:4: expected type void, found bool
+../../tests/invalid/Return_Invalid_3.whiley:2: expected type void, found bool
return z
^
diff --git a/tests/invalid/Return_Invalid_3.whiley b/tests/invalid/Return_Invalid_3.whiley
index 45c854b152..378f7761c3 100644
--- a/tests/invalid/Return_Invalid_3.whiley
+++ b/tests/invalid/Return_Invalid_3.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(bool z) -> void:
return z
diff --git a/tests/invalid/Return_Invalid_4.sysout b/tests/invalid/Return_Invalid_4.sysout
index d08b5bc584..7158ac57d5 100644
--- a/tests/invalid/Return_Invalid_4.sysout
+++ b/tests/invalid/Return_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_4.whiley:4: expected type bool, found int
+../../tests/invalid/Return_Invalid_4.whiley:2: expected type bool, found int
return x
^
diff --git a/tests/invalid/Return_Invalid_4.whiley b/tests/invalid/Return_Invalid_4.whiley
index 428f799575..ee7c9feb1d 100644
--- a/tests/invalid/Return_Invalid_4.whiley
+++ b/tests/invalid/Return_Invalid_4.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(int x) -> bool:
return x
diff --git a/tests/invalid/Return_Invalid_5.sysout b/tests/invalid/Return_Invalid_5.sysout
index 2a4c2d06f8..8c8db8800c 100644
--- a/tests/invalid/Return_Invalid_5.sysout
+++ b/tests/invalid/Return_Invalid_5.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_5.whiley:4: expected type bool, found int
+../../tests/invalid/Return_Invalid_5.whiley:2: expected type bool, found int
return x + y
^^^^^
diff --git a/tests/invalid/Return_Invalid_5.whiley b/tests/invalid/Return_Invalid_5.whiley
index 0000aa71b1..e2a6efeb1d 100644
--- a/tests/invalid/Return_Invalid_5.whiley
+++ b/tests/invalid/Return_Invalid_5.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(int x, int y) -> bool:
return x + y
diff --git a/tests/invalid/Return_Invalid_6.sysout b/tests/invalid/Return_Invalid_6.sysout
index fd123e1f9f..bf066f60dc 100644
--- a/tests/invalid/Return_Invalid_6.sysout
+++ b/tests/invalid/Return_Invalid_6.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_6.whiley:4: expected type int, found bool
+../../tests/invalid/Return_Invalid_6.whiley:2: expected type int, found bool
return y
^
diff --git a/tests/invalid/Return_Invalid_6.whiley b/tests/invalid/Return_Invalid_6.whiley
index bc46c46a99..39c9863f11 100644
--- a/tests/invalid/Return_Invalid_6.whiley
+++ b/tests/invalid/Return_Invalid_6.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(bool y) -> int:
return y
diff --git a/tests/invalid/Return_Invalid_7.sysout b/tests/invalid/Return_Invalid_7.sysout
index f1144c3344..d91172b197 100644
--- a/tests/invalid/Return_Invalid_7.sysout
+++ b/tests/invalid/Return_Invalid_7.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_7.whiley:4: expected type int, found bool
+../../tests/invalid/Return_Invalid_7.whiley:2: expected type int, found bool
return !y
^^
diff --git a/tests/invalid/Return_Invalid_7.whiley b/tests/invalid/Return_Invalid_7.whiley
index 6adf09329c..5da3b3b2ba 100644
--- a/tests/invalid/Return_Invalid_7.whiley
+++ b/tests/invalid/Return_Invalid_7.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(bool y) -> int:
return !y
diff --git a/tests/invalid/Return_Invalid_8.sysout b/tests/invalid/Return_Invalid_8.sysout
index 543a210155..c9d945c70f 100644
--- a/tests/invalid/Return_Invalid_8.sysout
+++ b/tests/invalid/Return_Invalid_8.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_8.whiley:4: expected type int, found bool
+../../tests/invalid/Return_Invalid_8.whiley:2: expected type int, found bool
return x && !y
^^^^^^^
diff --git a/tests/invalid/Return_Invalid_8.whiley b/tests/invalid/Return_Invalid_8.whiley
index 6e7d795a5e..8f54f86e00 100644
--- a/tests/invalid/Return_Invalid_8.whiley
+++ b/tests/invalid/Return_Invalid_8.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(bool x, bool y) -> int:
return x && !y
diff --git a/tests/invalid/Return_Invalid_9.sysout b/tests/invalid/Return_Invalid_9.sysout
index 01a7d978a9..b0b2a10706 100644
--- a/tests/invalid/Return_Invalid_9.sysout
+++ b/tests/invalid/Return_Invalid_9.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Return_Invalid_9.whiley:4: expected type int, found bool
+../../tests/invalid/Return_Invalid_9.whiley:2: expected type int, found bool
return x || (y <= (z + 1))
^^^^^^^^^^^^^^^^^^^
diff --git a/tests/invalid/Return_Invalid_9.whiley b/tests/invalid/Return_Invalid_9.whiley
index 4319b42d70..ce76c339a2 100644
--- a/tests/invalid/Return_Invalid_9.whiley
+++ b/tests/invalid/Return_Invalid_9.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(bool x, int y, int z) -> int:
return x || (y <= (z + 1))
diff --git a/tests/invalid/SetConversion_Invalid_1.sysout b/tests/invalid/SetConversion_Invalid_1.sysout
index 508ba4fc15..a629c0f815 100644
--- a/tests/invalid/SetConversion_Invalid_1.sysout
+++ b/tests/invalid/SetConversion_Invalid_1.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/SetConversion_Invalid_1.whiley:7: unable to resolve name (no match for f({int|{void}})
- found: SetConversion_Invalid_1:f : function({real}) -> void)
+../../tests/invalid/SetConversion_Invalid_1.whiley:5: unable to resolve name (no match for f({int|{void}})
+ found: SetConversion_Invalid_1:f : function({real}) -> int)
f({1, 2, 3, {}})
^^^^^^^^^^^^^^^^
diff --git a/tests/invalid/SetConversion_Invalid_1.whiley b/tests/invalid/SetConversion_Invalid_1.whiley
index 00481d3087..a6e5d054e2 100644
--- a/tests/invalid/SetConversion_Invalid_1.whiley
+++ b/tests/invalid/SetConversion_Invalid_1.whiley
@@ -1,7 +1,5 @@
-import * from whiley.lang.*
+function f({real} ls) -> int:
+ return |ls|
-function f({real} ls) -> void:
- debug Any.toString(ls)
-
-method main(System.Console sys) -> void:
+method main():
f({1, 2, 3, {}})
diff --git a/tests/invalid/SetDefine_Invalid_1.sysout b/tests/invalid/SetDefine_Invalid_1.sysout
index 5d6880a72b..403517ccd4 100644
--- a/tests/invalid/SetDefine_Invalid_1.sysout
+++ b/tests/invalid/SetDefine_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/SetDefine_Invalid_1.whiley:8: invalid set or list expression
- sys.out.println(il[0])
- ^^
+../../tests/invalid/SetDefine_Invalid_1.whiley:5: invalid set or list expression
+ return il[0]
+ ^^
diff --git a/tests/invalid/SetDefine_Invalid_1.whiley b/tests/invalid/SetDefine_Invalid_1.whiley
index 53afa316de..2850152d37 100644
--- a/tests/invalid/SetDefine_Invalid_1.whiley
+++ b/tests/invalid/SetDefine_Invalid_1.whiley
@@ -1,8 +1,5 @@
-import * from whiley.lang.*
-
type intlist is {int}
-method main(System.Console sys) -> void:
+method main() -> int:
intlist il = {1, 2, 3}
- sys.out.println(|il|)
- sys.out.println(il[0])
+ return il[0]
diff --git a/tests/invalid/SetDefine_Invalid_2.sysout b/tests/invalid/SetDefine_Invalid_2.sysout
index f82668818c..92b5978313 100644
--- a/tests/invalid/SetDefine_Invalid_2.sysout
+++ b/tests/invalid/SetDefine_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/SetDefine_Invalid_2.whiley:7: unknown variable
+../../tests/invalid/SetDefine_Invalid_2.whiley:5: unknown variable
constant numbers is {THIRTYTWO, TWELV}
^^^^^
diff --git a/tests/invalid/SetDefine_Invalid_2.whiley b/tests/invalid/SetDefine_Invalid_2.whiley
index e471e8a288..185f0fa76c 100644
--- a/tests/invalid/SetDefine_Invalid_2.whiley
+++ b/tests/invalid/SetDefine_Invalid_2.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
constant THIRTYTWO is 32
constant TWELVE is 12
diff --git a/tests/invalid/SetElemOf_Invalid_1.sysout b/tests/invalid/SetElemOf_Invalid_1.sysout
index 7d38586815..ae645ca278 100644
--- a/tests/invalid/SetElemOf_Invalid_1.sysout
+++ b/tests/invalid/SetElemOf_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/SetElemOf_Invalid_1.whiley:5: incomparable operands: real and int
+../../tests/invalid/SetElemOf_Invalid_1.whiley:3: incomparable operands: real and int
if 1.23 in xs:
^^^^^^^^^^
diff --git a/tests/invalid/SetElemOf_Invalid_1.whiley b/tests/invalid/SetElemOf_Invalid_1.whiley
index 2d4b257770..d711747066 100644
--- a/tests/invalid/SetElemOf_Invalid_1.whiley
+++ b/tests/invalid/SetElemOf_Invalid_1.whiley
@@ -1,6 +1,6 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> bool:
{int} xs = {1, 2, 3}
if 1.23 in xs:
- sys.out.println(Any.toString(1))
+ return true
+ else:
+ return false
diff --git a/tests/invalid/SetEmpty_Invalid_1.sysout b/tests/invalid/SetEmpty_Invalid_1.sysout
index f835aeeffc..518f987e24 100644
--- a/tests/invalid/SetEmpty_Invalid_1.sysout
+++ b/tests/invalid/SetEmpty_Invalid_1.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/SetEmpty_Invalid_1.whiley:7: unable to resolve name (no match for f({void})
- found: SetEmpty_Invalid_1:f : function(int) -> void)
- f({})
- ^^^^^
+../../tests/invalid/SetEmpty_Invalid_1.whiley:5: unable to resolve name (no match for f({void})
+ found: SetEmpty_Invalid_1:f : function(int) -> int)
+ return f({})
+ ^^^^^
diff --git a/tests/invalid/SetEmpty_Invalid_1.whiley b/tests/invalid/SetEmpty_Invalid_1.whiley
index 15f8d84be6..0a5304078d 100644
--- a/tests/invalid/SetEmpty_Invalid_1.whiley
+++ b/tests/invalid/SetEmpty_Invalid_1.whiley
@@ -1,7 +1,5 @@
-import * from whiley.lang.*
+function f(int x) -> int:
+ return x
-function f(int x) -> void:
- debug Any.toString(x)
-
-method main(System.Console sys) -> void:
- f({})
+method main() -> int:
+ return f({})
diff --git a/tests/invalid/SetIntersect_Invalid_1.sysout b/tests/invalid/SetIntersect_Invalid_1.sysout
index 3998612bf5..570ccb171f 100644
--- a/tests/invalid/SetIntersect_Invalid_1.sysout
+++ b/tests/invalid/SetIntersect_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/SetIntersect_Invalid_1.whiley:5: expected type byte, found real
- bool b = 1.0 & xs
- ^^^
+../../tests/invalid/SetIntersect_Invalid_1.whiley:3: expected type byte, found real
+ return 1.0 & xs
+ ^^^
diff --git a/tests/invalid/SetIntersect_Invalid_1.whiley b/tests/invalid/SetIntersect_Invalid_1.whiley
index 9ba2950ff5..911586df12 100644
--- a/tests/invalid/SetIntersect_Invalid_1.whiley
+++ b/tests/invalid/SetIntersect_Invalid_1.whiley
@@ -1,7 +1,3 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> bool:
{int} xs = {1, 2, 3}
- bool b = 1.0 & xs
- if b:
- sys.out.println(Any.toString(1))
+ return 1.0 & xs
diff --git a/tests/invalid/SetIntersect_Invalid_2.whiley b/tests/invalid/SetIntersect_Invalid_2.whiley
index 4e2673d13e..c179fb517c 100644
--- a/tests/invalid/SetIntersect_Invalid_2.whiley
+++ b/tests/invalid/SetIntersect_Invalid_2.whiley
@@ -1,10 +1,4 @@
-import * from whiley.lang.*
-
-function f({real} xs) -> int:
- return |xs|
-
-method main(System.Console sys) -> void:
- ys = {{1, 2}, {1}}
- xs = {1, 2, 3, 4}
- x = f(xs & ys)
- sys.out.println(Any.toString(x))
+method main() -> {int}:
+ {{int}} ys = {{1, 2}, {1}}
+ {int} xs = {1, 2, 3, 4}
+ return f(xs & ys)
diff --git a/tests/invalid/SetIntersection_Invalid_1.whiley b/tests/invalid/SetIntersection_Invalid_1.whiley
index 5932a3e192..c1f422f461 100644
--- a/tests/invalid/SetIntersection_Invalid_1.whiley
+++ b/tests/invalid/SetIntersection_Invalid_1.whiley
@@ -1,12 +1,7 @@
-function f({int} xs) -> void
+function f({int} xs) -> int
requires xs ⊆ {1, 2, 3}:
- debug Any.toString(xs)
+ return |xs|
-function g({int} ys) -> void:
- f(ys & {1, 2, 3, 4})
-
-method main(System.Console sys) -> void:
- g({1, 2, 3, 4})
- g({2})
- g({})
+function g({int} ys) -> int:
+ return f(ys & {1, 2, 3, 4})
diff --git a/tests/invalid/SetSubset_Invalid_4.whiley b/tests/invalid/SetSubset_Invalid_4.whiley
index e2d75ab1b8..4a9fbf9c35 100644
--- a/tests/invalid/SetSubset_Invalid_4.whiley
+++ b/tests/invalid/SetSubset_Invalid_4.whiley
@@ -3,6 +3,6 @@ function f({real} x, {int} ys) -> void
requires x ⊂ ys:
debug "X IS A SUBSET"
-method main(System.Console sys) -> void:
+method main():
f({1.0, 2.0}, {1, 2, 3})
f({1.0, 4.0}, {1, 2, 3})
diff --git a/tests/invalid/SetSubset_Invalid_5.sysout b/tests/invalid/SetSubset_Invalid_5.sysout
index fc28a0656f..1f0779fcaa 100644
--- a/tests/invalid/SetSubset_Invalid_5.sysout
+++ b/tests/invalid/SetSubset_Invalid_5.sysout
@@ -1,3 +1,3 @@
../../tests/invalid/SetSubset_Invalid_5.whiley:7: precondition not satisfied
f(ys, xs)
- ^^^^^^^^^
\ No newline at end of file
+ ^^^^^^^^^
diff --git a/tests/invalid/SetUnion_Invalid_1.sysout b/tests/invalid/SetUnion_Invalid_1.sysout
index d646be7f78..38446a15bc 100644
--- a/tests/invalid/SetUnion_Invalid_1.sysout
+++ b/tests/invalid/SetUnion_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/SetUnion_Invalid_1.whiley:6: expecting int or real, found {int}
- xs = xs + y
- ^^
+../../tests/invalid/SetUnion_Invalid_1.whiley:4: expecting int or real, found {int}
+ return xs + y
+ ^^
diff --git a/tests/invalid/SetUnion_Invalid_1.whiley b/tests/invalid/SetUnion_Invalid_1.whiley
index a1086fba4d..4c4e5e744c 100644
--- a/tests/invalid/SetUnion_Invalid_1.whiley
+++ b/tests/invalid/SetUnion_Invalid_1.whiley
@@ -1,7 +1,4 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> {int}:
real y = 1.0234234
{int} xs = {1, 2, 3, 4}
- xs = xs + y
- sys.out.println(Any.toString(xs))
+ return xs + y
diff --git a/tests/invalid/SetUnion_Invalid_2.sysout b/tests/invalid/SetUnion_Invalid_2.sysout
index 990b7c5cb0..f5de086872 100644
--- a/tests/invalid/SetUnion_Invalid_2.sysout
+++ b/tests/invalid/SetUnion_Invalid_2.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/SetUnion_Invalid_2.whiley:9: unable to resolve name (no match for f({int|real})
+../../tests/invalid/SetUnion_Invalid_2.whiley:7: unable to resolve name (no match for f({int|real})
found: SetUnion_Invalid_2:f : function({int}) -> int)
- f(xs + ys)
- ^^^^^^^^^^
+ return f(xs + ys)
+ ^^^^^^^^^^
diff --git a/tests/invalid/SetUnion_Invalid_2.whiley b/tests/invalid/SetUnion_Invalid_2.whiley
index e799b877eb..c82e64003e 100644
--- a/tests/invalid/SetUnion_Invalid_2.whiley
+++ b/tests/invalid/SetUnion_Invalid_2.whiley
@@ -1,10 +1,7 @@
-import * from whiley.lang.*
-
function f({int} xs) -> int:
return |xs|
-method main(System.Console sys) -> void:
+method main() -> int:
{real} ys = {1.0234234, 1.12}
{int} xs = {1, 2, 3, 4}
- f(xs + ys)
- sys.out.println(Any.toString(xs))
+ return f(xs + ys)
diff --git a/tests/invalid/Switch_Invalid_1.sysout b/tests/invalid/Switch_Invalid_1.sysout
index fed194f56a..8e575a196b 100644
--- a/tests/invalid/Switch_Invalid_1.sysout
+++ b/tests/invalid/Switch_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Switch_Invalid_1.whiley:7: duplicate case label
+../../tests/invalid/Switch_Invalid_1.whiley:5: duplicate case label
case 1:
^^^^^^^^^^^^^^^
diff --git a/tests/invalid/Switch_Invalid_1.whiley b/tests/invalid/Switch_Invalid_1.whiley
index d786b68b6b..6c5f9d2379 100644
--- a/tests/invalid/Switch_Invalid_1.whiley
+++ b/tests/invalid/Switch_Invalid_1.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function f(int x) -> int:
switch x:
case 1:
@@ -7,9 +5,3 @@ function f(int x) -> int:
case 1:
return -1
return 10
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(1)))
- sys.out.println(Any.toString(f(2)))
- sys.out.println(Any.toString(f(3)))
- sys.out.println(Any.toString(f(-1)))
diff --git a/tests/invalid/Switch_Invalid_2.sysout b/tests/invalid/Switch_Invalid_2.sysout
index 5a76bc65e5..149d8254d4 100644
--- a/tests/invalid/Switch_Invalid_2.sysout
+++ b/tests/invalid/Switch_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Switch_Invalid_2.whiley:7: unreachable code encountered (i.e. execution can never reach this statement)
+../../tests/invalid/Switch_Invalid_2.whiley:5: unreachable code encountered (i.e. execution can never reach this statement)
case 1:
^^^^^^^^^^^^^^^
diff --git a/tests/invalid/Switch_Invalid_2.whiley b/tests/invalid/Switch_Invalid_2.whiley
index 8e2bcd266b..6b4c1e34d0 100644
--- a/tests/invalid/Switch_Invalid_2.whiley
+++ b/tests/invalid/Switch_Invalid_2.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function f(int x) -> int:
switch x:
default:
@@ -7,9 +5,3 @@ function f(int x) -> int:
case 1:
return -1
return 10
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(1)))
- sys.out.println(Any.toString(f(2)))
- sys.out.println(Any.toString(f(3)))
- sys.out.println(Any.toString(f(-1)))
diff --git a/tests/invalid/Switch_Invalid_3.sysout b/tests/invalid/Switch_Invalid_3.sysout
index 932e345e67..47d7b0e2af 100644
--- a/tests/invalid/Switch_Invalid_3.sysout
+++ b/tests/invalid/Switch_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Switch_Invalid_3.whiley:7: duplicate default label
+../../tests/invalid/Switch_Invalid_3.whiley:5: duplicate default label
default:
^^^^^^^^^^^^^^^^
diff --git a/tests/invalid/Switch_Invalid_3.whiley b/tests/invalid/Switch_Invalid_3.whiley
index fce82bc112..807d62effc 100644
--- a/tests/invalid/Switch_Invalid_3.whiley
+++ b/tests/invalid/Switch_Invalid_3.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function f(int x) -> int:
switch x:
default:
@@ -7,9 +5,3 @@ function f(int x) -> int:
default:
return 1
return 10
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(1)))
- sys.out.println(Any.toString(f(2)))
- sys.out.println(Any.toString(f(3)))
- sys.out.println(Any.toString(f(-1)))
diff --git a/tests/invalid/Switch_Invalid_4.sysout b/tests/invalid/Switch_Invalid_4.sysout
index 3862e5b071..1cf75f180a 100644
--- a/tests/invalid/Switch_Invalid_4.sysout
+++ b/tests/invalid/Switch_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Switch_Invalid_4.whiley:7: duplicate case label
+../../tests/invalid/Switch_Invalid_4.whiley:5: duplicate case label
case 1:
^^^^^^^^^^^^^^^
diff --git a/tests/invalid/Switch_Invalid_4.whiley b/tests/invalid/Switch_Invalid_4.whiley
index 25f4aba7ae..464dea1315 100644
--- a/tests/invalid/Switch_Invalid_4.whiley
+++ b/tests/invalid/Switch_Invalid_4.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function f(int x) -> int:
switch x:
case 1:
@@ -9,9 +7,3 @@ function f(int x) -> int:
default:
return 0
return 10
-
-method main(System.Console sys) -> void:
- sys.out.println(Any.toString(f(1)))
- sys.out.println(Any.toString(f(2)))
- sys.out.println(Any.toString(f(3)))
- sys.out.println(Any.toString(f(-1)))
diff --git a/tests/invalid/Switch_Invalid_5.sysout b/tests/invalid/Switch_Invalid_5.sysout
index 37327a067a..c14328fc98 100644
--- a/tests/invalid/Switch_Invalid_5.sysout
+++ b/tests/invalid/Switch_Invalid_5.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Switch_Invalid_5.whiley:5: break outside switch or loop
+../../tests/invalid/Switch_Invalid_5.whiley:3: break outside switch or loop
break
^^^^^
diff --git a/tests/invalid/Switch_Invalid_5.whiley b/tests/invalid/Switch_Invalid_5.whiley
index 6fd7297554..66fc9e0590 100644
--- a/tests/invalid/Switch_Invalid_5.whiley
+++ b/tests/invalid/Switch_Invalid_5.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function f(int x) -> int:
if x > 0:
break
diff --git a/tests/invalid/Switch_Invalid_6.whiley b/tests/invalid/Switch_Invalid_6.whiley
index 4f156dd2c5..6c1054527e 100644
--- a/tests/invalid/Switch_Invalid_6.whiley
+++ b/tests/invalid/Switch_Invalid_6.whiley
@@ -1,7 +1,4 @@
-import * from whiley.lang.System
-import Error from whiley.lang.Errors
-
-function f(int x) -> int throws Error:
+function f(int x) -> int:
switch x:
case 0:
case 1:
@@ -9,12 +6,4 @@ function f(int x) -> int throws Error:
case 2:
return x + 12
default:
- throw Error("INVALID VALUE FOR X")
-
-public method main(System.Console sys) -> void:
- try:
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(3))
- catch(Error e):
- sys.out.println(e.msg)
+ //
diff --git a/tests/invalid/Switch_Invalid_7.sysout b/tests/invalid/Switch_Invalid_7.sysout
index 32b4ae525d..2db57ae822 100644
--- a/tests/invalid/Switch_Invalid_7.sysout
+++ b/tests/invalid/Switch_Invalid_7.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Switch_Invalid_7.whiley:3: unrecognised term
+../../tests/invalid/Switch_Invalid_7.whiley:2: unrecognised term
method = data[pos]
^^^^^^
diff --git a/tests/invalid/Switch_Invalid_7.whiley b/tests/invalid/Switch_Invalid_7.whiley
index 3076296493..83ce125259 100644
--- a/tests/invalid/Switch_Invalid_7.whiley
+++ b/tests/invalid/Switch_Invalid_7.whiley
@@ -1,4 +1,3 @@
-
function f([byte] data, int pos) -> int:
method = data[pos]
pos = pos + 1
diff --git a/tests/invalid/Throws_Invalid_1.sysout b/tests/invalid/Throws_Invalid_1.sysout
deleted file mode 100644
index affc8958d1..0000000000
--- a/tests/invalid/Throws_Invalid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-../../tests/invalid/Throws_Invalid_1.whiley:7: exception may be thrown which is not declared
- throw {msg: "error"}
- ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/invalid/Throws_Invalid_1.whiley b/tests/invalid/Throws_Invalid_1.whiley
deleted file mode 100644
index 2d1d8b7117..0000000000
--- a/tests/invalid/Throws_Invalid_1.whiley
+++ /dev/null
@@ -1,8 +0,0 @@
-import * from whiley.lang.*
-
-type Error is {string msg}
-
-function f(int x) -> int:
- if x < 0:
- throw {msg: "error"}
- return 1
diff --git a/tests/invalid/Throws_Invalid_2.sysout b/tests/invalid/Throws_Invalid_2.sysout
deleted file mode 100644
index f6e3733939..0000000000
--- a/tests/invalid/Throws_Invalid_2.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-../../tests/invalid/Throws_Invalid_2.whiley:9: exception may be thrown which is not declared
- throw {msg: "error"}
- ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/invalid/Throws_Invalid_2.whiley b/tests/invalid/Throws_Invalid_2.whiley
deleted file mode 100644
index dcfbfe0289..0000000000
--- a/tests/invalid/Throws_Invalid_2.whiley
+++ /dev/null
@@ -1,10 +0,0 @@
-import * from whiley.lang.*
-
-type Error is {string msg}
-
-type WrongError is {int msg}
-
-function f(int x) -> int throws WrongError:
- if x < 0:
- throw {msg: "error"}
- return 1
diff --git a/tests/invalid/TryCatch_Invalid_1.sysout b/tests/invalid/TryCatch_Invalid_1.sysout
deleted file mode 100644
index e88494ea10..0000000000
--- a/tests/invalid/TryCatch_Invalid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-../../tests/invalid/TryCatch_Invalid_1.whiley:19: variable may be uninitialised
- sys.out.println("CAUGHT EXCEPTION: " ++ x)
- ^
diff --git a/tests/invalid/TryCatch_Invalid_1.whiley b/tests/invalid/TryCatch_Invalid_1.whiley
deleted file mode 100644
index 2ea4ab8e17..0000000000
--- a/tests/invalid/TryCatch_Invalid_1.whiley
+++ /dev/null
@@ -1,20 +0,0 @@
-import * from whiley.lang.*
-
-function f(real x) -> int throws string:
- if x >= 0.0:
- return 1
- else:
- throw "error"
-
-method main(System.Console sys) -> void:
- int x
- //
- if |sys.args| > 0:
- x = 1
- try:
- sys.out.println(Any.toString(f(1.0)))
- sys.out.println(Any.toString(f(0.0)))
- sys.out.println(Any.toString(f(-1.0)))
- catch(string e):
- sys.out.println("CAUGHT EXCEPTION: " ++ x)
- sys.out.println("DONE")
diff --git a/tests/invalid/TryCatch_Invalid_2.sysout b/tests/invalid/TryCatch_Invalid_2.sysout
deleted file mode 100644
index b8c0dbf230..0000000000
--- a/tests/invalid/TryCatch_Invalid_2.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-../../tests/invalid/TryCatch_Invalid_2.whiley:18: variable may be uninitialised
- sys.out.println("CAUGHT EXCEPTION: " ++ x)
- ^
diff --git a/tests/invalid/TryCatch_Invalid_2.whiley b/tests/invalid/TryCatch_Invalid_2.whiley
deleted file mode 100644
index a42ab8685e..0000000000
--- a/tests/invalid/TryCatch_Invalid_2.whiley
+++ /dev/null
@@ -1,19 +0,0 @@
-import * from whiley.lang.*
-
-function f(real x) -> int throws string:
- if x >= 0.0:
- return 1
- else:
- throw x
-
-method main(System.Console sys) -> void:
- int x
- if |sys.args| > 0:
- x = 1
- try:
- sys.out.println(Any.toString(f(1.0)))
- sys.out.println(Any.toString(f(0.0)))
- sys.out.println(Any.toString(f(-1.0)))
- catch(string e):
- sys.out.println("CAUGHT EXCEPTION: " ++ x)
- sys.out.println("DONE")
diff --git a/tests/invalid/TryCatch_Invalid_3.sysout b/tests/invalid/TryCatch_Invalid_3.sysout
deleted file mode 100644
index 4e105b2f70..0000000000
--- a/tests/invalid/TryCatch_Invalid_3.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-../../tests/invalid/TryCatch_Invalid_3.whiley:18: variable may be uninitialised
- sys.out.println("CAUGHT EXCEPTION: " ++ x)
- ^
diff --git a/tests/invalid/TryCatch_Invalid_3.whiley b/tests/invalid/TryCatch_Invalid_3.whiley
deleted file mode 100644
index 06e3be1e94..0000000000
--- a/tests/invalid/TryCatch_Invalid_3.whiley
+++ /dev/null
@@ -1,19 +0,0 @@
-import * from whiley.lang.*
-
-function f(real x) -> int throws string:
- if x >= 0.0:
- return 1
- else:
- throw "error"
-
-method main(System.Console sys) -> void:
- int x
- if |sys.args| > 0:
- x = 1
- try:
- sys.out.println(Any.toString(f(1.0)))
- sys.out.println(Any.toString(f(0.0)))
- sys.out.println(Any.toString(f(-1.0)))
- catch(int e):
- sys.out.println("CAUGHT EXCEPTION: " ++ x)
- sys.out.println("DONE")
diff --git a/tests/invalid/TryCatch_Invalid_4.sysout b/tests/invalid/TryCatch_Invalid_4.sysout
deleted file mode 100644
index 7428d11818..0000000000
--- a/tests/invalid/TryCatch_Invalid_4.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-../../tests/invalid/TryCatch_Invalid_4.whiley:0: unreachable code encountered (i.e. execution can never reach this statement)
-
-^
diff --git a/tests/invalid/TryCatch_Invalid_4.whiley b/tests/invalid/TryCatch_Invalid_4.whiley
deleted file mode 100644
index 086748f7bc..0000000000
--- a/tests/invalid/TryCatch_Invalid_4.whiley
+++ /dev/null
@@ -1,14 +0,0 @@
-import * from whiley.lang.*
-
-function f(int x) -> int:
- return x
-
-method main(System.Console sys) -> void:
- int x = 1
- try:
- sys.out.println(Any.toString(f(1)))
- sys.out.println(Any.toString(f(0)))
- sys.out.println(Any.toString(f(-1)))
- catch(int e):
- sys.out.println("CAUGHT EXCEPTION: " ++ x)
- sys.out.println("DONE")
diff --git a/tests/invalid/TryCatch_Invalid_5.sysout b/tests/invalid/TryCatch_Invalid_5.sysout
deleted file mode 100644
index bde57578ea..0000000000
--- a/tests/invalid/TryCatch_Invalid_5.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-../../tests/invalid/TryCatch_Invalid_5.whiley:16: exception may be thrown which is not declared
- sys.out.println(Any.toString(f(1)))
- ^^^^
diff --git a/tests/invalid/TryCatch_Invalid_5.whiley b/tests/invalid/TryCatch_Invalid_5.whiley
deleted file mode 100644
index 71d7e7d893..0000000000
--- a/tests/invalid/TryCatch_Invalid_5.whiley
+++ /dev/null
@@ -1,22 +0,0 @@
-import * from whiley.lang.*
-
-function f(int x) -> int throws string:
- if x >= 0:
- return 1
- else:
- throw "error"
-
-function g(int x) -> int:
- return x
-
-method main(System.Console sys) -> void:
- int|real x = 1
- //
- try:
- sys.out.println(Any.toString(f(1)))
- x = 1.02
- sys.out.println(Any.toString(f(0)))
- sys.out.println(Any.toString(f(-1)))
- catch(int e):
- sys.out.println("CAUGHT EXCEPTION: " ++ g(x))
- sys.out.println("DONE")
diff --git a/tests/invalid/TupleDefine_Invalid_1.sysout b/tests/invalid/TupleDefine_Invalid_1.sysout
index 6dfdb60298..c8a20c8c80 100644
--- a/tests/invalid/TupleDefine_Invalid_1.sysout
+++ b/tests/invalid/TupleDefine_Invalid_1.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/TupleDefine_Invalid_1.whiley:10: unable to resolve name (no match for f(real)
+../../tests/invalid/TupleDefine_Invalid_1.whiley:8: unable to resolve name (no match for f(real)
found: TupleDefine_Invalid_1:f : function(int) -> int)
- int x = f(p.y)
- ^^^^^^
+ return f(p.y)
+ ^^^^^^
diff --git a/tests/invalid/TupleDefine_Invalid_1.whiley b/tests/invalid/TupleDefine_Invalid_1.whiley
index ef1aee8a24..d545e772e0 100644
--- a/tests/invalid/TupleDefine_Invalid_1.whiley
+++ b/tests/invalid/TupleDefine_Invalid_1.whiley
@@ -1,11 +1,8 @@
-import * from whiley.lang.*
-
type point is {real y, real x}
function f(int x) -> int:
return x
-method main(System.Console sys) -> void:
+method main() -> int:
point p = {y: 2.23, x: 1.0}
- int x = f(p.y)
- sys.out.println(Any.toString(x))
+ return f(p.y)
diff --git a/tests/invalid/Tuple_Invalid_1.sysout b/tests/invalid/Tuple_Invalid_1.sysout
index 0d1de2fe39..93bb97f360 100644
--- a/tests/invalid/Tuple_Invalid_1.sysout
+++ b/tests/invalid/Tuple_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Tuple_Invalid_1.whiley:8: unknown variable
- (x, y) = p
- ^
+../../tests/invalid/Tuple_Invalid_1.whiley:14: type invariant not satisfied (argument 0)
+ int x = min(p)
+ ^^^^^^
diff --git a/tests/invalid/Tuple_Invalid_1.whiley b/tests/invalid/Tuple_Invalid_1.whiley
index 63ab04a8a7..25f88f84a6 100644
--- a/tests/invalid/Tuple_Invalid_1.whiley
+++ b/tests/invalid/Tuple_Invalid_1.whiley
@@ -1,16 +1,14 @@
-import * from whiley.lang.System
-
type nat is (int x) where x >= 0
type natpair is (nat, nat)
function min(natpair p) -> int:
- (x, y) = p
+ int x, int y = p
if x > y:
return y
else:
return x
-method main(System.Console sys) -> void:
- p = (0, -1)
- x = min(p)
+method main() -> void:
+ (int,int) p = (0, -1)
+ int x = min(p)
diff --git a/tests/invalid/Tuple_Invalid_3.sysout b/tests/invalid/Tuple_Invalid_3.sysout
index f80c1bff90..03652949ba 100644
--- a/tests/invalid/Tuple_Invalid_3.sysout
+++ b/tests/invalid/Tuple_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Tuple_Invalid_3.whiley:8: unknown variable
- (x, y) = p
- ^
+../../tests/invalid/Tuple_Invalid_3.whiley:14: type invariant not satisfied (argument 0)
+ return min(p)
+ ^^^^^^
diff --git a/tests/invalid/Tuple_Invalid_3.whiley b/tests/invalid/Tuple_Invalid_3.whiley
index 38fdf89520..4c79ccfe48 100644
--- a/tests/invalid/Tuple_Invalid_3.whiley
+++ b/tests/invalid/Tuple_Invalid_3.whiley
@@ -1,16 +1,14 @@
-import * from whiley.lang.System
-
type nat is (int n) where n >= 0
type natpair is (nat, nat)
function min(natpair p) -> int:
- (x, y) = p
+ int x, int y = p
if x > y:
return y
else:
return x
-method main(System.Console sys) -> void:
- p = (-1, 0)
- x = min(p)
+method main() -> int:
+ (int,int) p = (-1, 0)
+ return min(p)
diff --git a/tests/invalid/Tuple_Invalid_4.sysout b/tests/invalid/Tuple_Invalid_4.sysout
index b33a798826..669828acc6 100644
--- a/tests/invalid/Tuple_Invalid_4.sysout
+++ b/tests/invalid/Tuple_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Tuple_Invalid_4.whiley:8: unknown variable
- (x, y) = p
- ^
+../../tests/invalid/Tuple_Invalid_4.whiley:14: type invariant not satisfied (argument 0)
+ return min(p)
+ ^^^^^^
diff --git a/tests/invalid/Tuple_Invalid_4.whiley b/tests/invalid/Tuple_Invalid_4.whiley
index 59835ae8dc..ac0037194b 100644
--- a/tests/invalid/Tuple_Invalid_4.whiley
+++ b/tests/invalid/Tuple_Invalid_4.whiley
@@ -1,16 +1,14 @@
-import * from whiley.lang.System
-
type nat is (int n) where n >= 0
type natpair is (int, nat)
function min(natpair p) -> int:
- (x, y) = p
+ int x, int y = p
if x > y:
return y
else:
return x
-method main(System.Console sys) -> void:
- p = (0, -1)
- x = min(p)
+method main() -> int:
+ (int,int) p = (0, -1)
+ return min(p)
diff --git a/tests/invalid/Tuple_Invalid_5.sysout b/tests/invalid/Tuple_Invalid_5.sysout
index 4fc2628f3f..d83ece77e2 100644
--- a/tests/invalid/Tuple_Invalid_5.sysout
+++ b/tests/invalid/Tuple_Invalid_5.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/Tuple_Invalid_5.whiley:8: unknown variable
- (x, y) = p
- ^
+../../tests/invalid/Tuple_Invalid_5.whiley:14: type invariant not satisfied (argument 0)
+ return min(p)
+ ^^^^^^
diff --git a/tests/invalid/Tuple_Invalid_5.whiley b/tests/invalid/Tuple_Invalid_5.whiley
index 5810d6c0af..e423fcb9d4 100644
--- a/tests/invalid/Tuple_Invalid_5.whiley
+++ b/tests/invalid/Tuple_Invalid_5.whiley
@@ -1,16 +1,14 @@
-import * from whiley.lang.System
-
type nat is (int n) where n >= 0
type natpair is (nat, int)
function min(natpair p) -> int:
- (x, y) = p
+ int x, int y = p
if x > y:
return y
else:
return x
-method main(System.Console sys) -> void:
- p = (-1, 0)
- x = min(p)
+method main() -> int:
+ (int,int) p = (-1, 0)
+ return min(p)
diff --git a/tests/invalid/TypeEquals_Invalid_1.sysout b/tests/invalid/TypeEquals_Invalid_1.sysout
index 0c2e67a2af..e6ce7ff6ca 100644
--- a/tests/invalid/TypeEquals_Invalid_1.sysout
+++ b/tests/invalid/TypeEquals_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/TypeEquals_Invalid_1.whiley:9: branch always taken
+../../tests/invalid/TypeEquals_Invalid_1.whiley:7: branch always taken
if e is int:
^^^^^^^^
diff --git a/tests/invalid/TypeEquals_Invalid_1.whiley b/tests/invalid/TypeEquals_Invalid_1.whiley
index 0784d9b210..8a9249ee70 100644
--- a/tests/invalid/TypeEquals_Invalid_1.whiley
+++ b/tests/invalid/TypeEquals_Invalid_1.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
type expr is [int] | int
method f(expr e) -> void:
@@ -10,9 +8,3 @@ method f(expr e) -> void:
debug ("GOT INT")
else:
debug ("GOT SOMETHING ELSE?")
-
-method main(System.Console sys) -> void:
- e = 1
- f(e)
- e = {y: 2, x: 1}
- f(e)
diff --git a/tests/invalid/TypeEquals_Invalid_2.sysout b/tests/invalid/TypeEquals_Invalid_2.sysout
index 92eb952ee7..f22e3c5a30 100644
--- a/tests/invalid/TypeEquals_Invalid_2.sysout
+++ b/tests/invalid/TypeEquals_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/TypeEquals_Invalid_2.whiley:6: branch always taken
+../../tests/invalid/TypeEquals_Invalid_2.whiley:2: branch always taken
if e is real:
^^^^^^^^^
diff --git a/tests/invalid/TypeEquals_Invalid_2.whiley b/tests/invalid/TypeEquals_Invalid_2.whiley
index b4614ef319..dd0b530b97 100644
--- a/tests/invalid/TypeEquals_Invalid_2.whiley
+++ b/tests/invalid/TypeEquals_Invalid_2.whiley
@@ -1,8 +1,4 @@
-import * from whiley.lang.*
-
-type ilist is real | [int]
-
-function f(real e) -> string:
+function f(real e) -> [int]:
if e is real:
return "real"
else:
@@ -10,6 +6,3 @@ function f(real e) -> string:
return "int"
else:
return "[int]"
-
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
diff --git a/tests/invalid/TypeEquals_Invalid_5.whiley b/tests/invalid/TypeEquals_Invalid_5.whiley
index f99896c228..e9ef418a25 100644
--- a/tests/invalid/TypeEquals_Invalid_5.whiley
+++ b/tests/invalid/TypeEquals_Invalid_5.whiley
@@ -1,5 +1,3 @@
-import whiley.lang.*
-
type pos is (int p) where p > 0
type rec1 is {any f1, pos f2}
@@ -11,10 +9,8 @@ type rec12 is rec1 | rec2
function f(rec12 x) -> int:
return 1
-public method main(System.Console console) -> void:
- r1 = {f1: "hello", f2: 2}
- r2 = {f1: 1, f2: 0}
- r3 = {f1: "hello", f2: 0}
- console.out.println(f(r1))
- console.out.println(f(r2))
- console.out.println(f(r3))
+method main() -> int:
+ rec1 r1 = {f1: "hello", f2: 2}
+ rec2 r2 = {f1: 1, f2: 0}
+ rec12 r3 = {f1: "hello", f2: 0}
+ return f(r1) + f(r2) + f(r3)
\ No newline at end of file
diff --git a/tests/invalid/UnionType_Invalid_1.sysout b/tests/invalid/UnionType_Invalid_1.sysout
index 518658259b..c39f3b51ed 100644
--- a/tests/invalid/UnionType_Invalid_1.sysout
+++ b/tests/invalid/UnionType_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/UnionType_Invalid_1.whiley:12: expected type int, found real
- x = 1.23
- ^
+../../tests/invalid/UnionType_Invalid_1.whiley:4: expected type int, found UnionType_Invalid_1:IntReal
+ return x
+ ^
diff --git a/tests/invalid/UnionType_Invalid_1.whiley b/tests/invalid/UnionType_Invalid_1.whiley
index 2c1d8a7404..754719eba3 100644
--- a/tests/invalid/UnionType_Invalid_1.whiley
+++ b/tests/invalid/UnionType_Invalid_1.whiley
@@ -1,16 +1,4 @@
-import * from whiley.lang.*
-
type IntReal is int | real
-function f(int x) -> int:
+function f(IntReal x) -> int:
return x
-
-method main(System.Console sys) -> void:
- int x
- //
- if |sys.args| > 0:
- x = 1.23
- else:
- x = 1
- sys.out.println(Any.toString(x))
- f(x)
diff --git a/tests/invalid/UnionType_Invalid_10.whiley b/tests/invalid/UnionType_Invalid_10.whiley
index 565dac4d3a..56a5ff170f 100644
--- a/tests/invalid/UnionType_Invalid_10.whiley
+++ b/tests/invalid/UnionType_Invalid_10.whiley
@@ -1,6 +1,4 @@
-
type nat is (int n) where n >= 0
-
type natlist is [nat]
type nlt is nat | natlist
diff --git a/tests/invalid/UnionType_Invalid_2.sysout b/tests/invalid/UnionType_Invalid_2.sysout
index 5067085853..774f3ea2af 100644
--- a/tests/invalid/UnionType_Invalid_2.sysout
+++ b/tests/invalid/UnionType_Invalid_2.sysout
@@ -1,3 +1,4 @@
-../../tests/invalid/UnionType_Invalid_2.whiley:13: expected type int, found real
- x = 1.234
- ^
+../../tests/invalid/UnionType_Invalid_2.whiley:12: unable to resolve name (no match for f(real)
+ found: UnionType_Invalid_2:f : function(int) -> int)
+ f(x)
+ ^^^^
diff --git a/tests/invalid/UnionType_Invalid_2.whiley b/tests/invalid/UnionType_Invalid_2.whiley
index a21273a951..b8b76c5a07 100644
--- a/tests/invalid/UnionType_Invalid_2.whiley
+++ b/tests/invalid/UnionType_Invalid_2.whiley
@@ -1,12 +1,10 @@
-import * from whiley.lang.*
-
type IntReal is int | real
-function f(int y) -> void:
- debug Any.toString(y)
+function f(int y) -> int:
+ return y
-method main(System.Console sys) -> void:
- int x
+method main():
+ IntReal x
//
x = 123
f(x)
diff --git a/tests/invalid/UnionType_Invalid_3.sysout b/tests/invalid/UnionType_Invalid_3.sysout
index 23941da60d..74138ccf34 100644
--- a/tests/invalid/UnionType_Invalid_3.sysout
+++ b/tests/invalid/UnionType_Invalid_3.sysout
@@ -1,3 +1,4 @@
-../../tests/invalid/UnionType_Invalid_3.whiley:16: expected type int, found [int]
- x = [1, 2, 3]
- ^
+../../tests/invalid/UnionType_Invalid_3.whiley:7: unable to resolve name (no match for f(UnionType_Invalid_3:IntList)
+ found: UnionType_Invalid_3:f : function([int]) -> int)
+ return f(xs)
+ ^^^^^
diff --git a/tests/invalid/UnionType_Invalid_3.whiley b/tests/invalid/UnionType_Invalid_3.whiley
index 99d964cbe2..9d61a55e8b 100644
--- a/tests/invalid/UnionType_Invalid_3.whiley
+++ b/tests/invalid/UnionType_Invalid_3.whiley
@@ -1,20 +1,7 @@
-import * from whiley.lang.*
-
type IntList is int | [int]
function f([int] xs) -> int:
return |xs|
-method main(System.Console sys) -> void:
- int x
- int y
- //
- if |sys.args| == 0:
- x = 1
- y = x
- else:
- x = [1, 2, 3]
- y = x
- //
- int z = f(y)
- sys.out.println(Any.toString(z))
+function g(IntList xs) -> int:
+ return f(xs)
diff --git a/tests/invalid/UnionType_Invalid_4.sysout b/tests/invalid/UnionType_Invalid_4.sysout
index 0aca0cce20..c9fb1bf131 100644
--- a/tests/invalid/UnionType_Invalid_4.sysout
+++ b/tests/invalid/UnionType_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/UnionType_Invalid_4.whiley:12: expected type [int], found [int|real]
+../../tests/invalid/UnionType_Invalid_4.whiley:8: expected type UnionType_Invalid_4:IntRealList, found [int|real]
x[0] = 1.23
^
diff --git a/tests/invalid/UnionType_Invalid_4.whiley b/tests/invalid/UnionType_Invalid_4.whiley
index f29e0c0749..e2243cdac4 100644
--- a/tests/invalid/UnionType_Invalid_4.whiley
+++ b/tests/invalid/UnionType_Invalid_4.whiley
@@ -1,14 +1,9 @@
-import * from whiley.lang.*
-
type IntRealList is [int] | [real]
function f([int] xs) -> [int]:
return xs
-method main(System.Console sys) -> void:
- [int] x = [1, 2, 3]
- [int] ys = x
- sys.out.println(Any.toString(ys))
+method main() -> [int]:
+ IntRealList x = [1, 2, 3]
x[0] = 1.23
- [int] zs = f(x)
- sys.out.println(Any.toString(zs))
+ return f(x)
diff --git a/tests/invalid/UnionType_Invalid_5.sysout b/tests/invalid/UnionType_Invalid_5.sysout
index ab9692d914..5f701d7774 100644
--- a/tests/invalid/UnionType_Invalid_5.sysout
+++ b/tests/invalid/UnionType_Invalid_5.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/UnionType_Invalid_5.whiley:10: expected type UnionType_Invalid_5:IntList, found {[int] op,[real] rest}
+../../tests/invalid/UnionType_Invalid_5.whiley:8: expected type UnionType_Invalid_5:IntList, found {[int] op,[real] rest}
x.op = [1, 2, 3]
^
diff --git a/tests/invalid/UnionType_Invalid_5.whiley b/tests/invalid/UnionType_Invalid_5.whiley
index 3d4bcf048a..fe9753e80d 100644
--- a/tests/invalid/UnionType_Invalid_5.whiley
+++ b/tests/invalid/UnionType_Invalid_5.whiley
@@ -1,11 +1,9 @@
-import * from whiley.lang.*
-
type IntList is {int op, [real] rest} | {[int] op, int mode}
function f(IntList x) -> IntList:
return x
-method main(System.Console sys) -> void:
+method main() -> void:
IntList x = {op: 1, rest: [1.23]}
x.op = [1, 2, 3]
f(x)
diff --git a/tests/invalid/UnionType_Invalid_6.sysout b/tests/invalid/UnionType_Invalid_6.sysout
index d1412c42a2..2a7f0e14d1 100644
--- a/tests/invalid/UnionType_Invalid_6.sysout
+++ b/tests/invalid/UnionType_Invalid_6.sysout
@@ -1,4 +1,4 @@
-../../tests/invalid/UnionType_Invalid_6.whiley:12: unable to resolve name (no match for f({[int] op})
+../../tests/invalid/UnionType_Invalid_6.whiley:10: unable to resolve name (no match for f({[int] op})
found: UnionType_Invalid_6:f : function({int op}) -> int)
f(x)
^^^^
diff --git a/tests/invalid/UnionType_Invalid_6.whiley b/tests/invalid/UnionType_Invalid_6.whiley
index 909d6715d4..5901300908 100644
--- a/tests/invalid/UnionType_Invalid_6.whiley
+++ b/tests/invalid/UnionType_Invalid_6.whiley
@@ -1,11 +1,9 @@
-import * from whiley.lang.*
-
type IntList is {int | [int] op}
function f({int op} x) -> int:
return x.op
-method main(System.Console sys) -> void:
+method main():
IntList x = {op: 1}
x.op = 2
x.op = [1, 2, 3]
diff --git a/tests/invalid/UnionType_Invalid_8.whiley b/tests/invalid/UnionType_Invalid_8.whiley
index dbd9fc1cba..d738fb2a77 100644
--- a/tests/invalid/UnionType_Invalid_8.whiley
+++ b/tests/invalid/UnionType_Invalid_8.whiley
@@ -5,12 +5,8 @@ type turf1nat is (int x) where x > 10
type wurf1nat is urf1nat | turf1nat
-function f(wurf1nat x) -> void:
- debug Any.toString(x)
+function f(wurf1nat x) -> int:
+ return x
-function g(int x) -> void:
- f(x)
-
-method main(System.Console sys) -> void:
- g(1)
- g(-1)
+function g(int x) -> int:
+ return f(x)
diff --git a/tests/invalid/UnionType_Invalid_9.whiley b/tests/invalid/UnionType_Invalid_9.whiley
index 636292a415..6ab4648f61 100644
--- a/tests/invalid/UnionType_Invalid_9.whiley
+++ b/tests/invalid/UnionType_Invalid_9.whiley
@@ -18,6 +18,3 @@ requires y >= 0:
function f(int x) -> plt
requires x >= 0:
return g(x)
-
-method main(System.Console sys) -> void:
- debug Any.toString(f(0))
diff --git a/tests/invalid/VarDecl_Invalid_1.sysout b/tests/invalid/VarDecl_Invalid_1.sysout
index 4acca923ab..ace9f8919d 100644
--- a/tests/invalid/VarDecl_Invalid_1.sysout
+++ b/tests/invalid/VarDecl_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/VarDecl_Invalid_1.whiley:4: unknown variable
+../../tests/invalid/VarDecl_Invalid_1.whiley:2: unknown variable
int x = y
^
diff --git a/tests/invalid/VarDecl_Invalid_1.whiley b/tests/invalid/VarDecl_Invalid_1.whiley
index e3b1688b3e..53fcb15f4e 100644
--- a/tests/invalid/VarDecl_Invalid_1.whiley
+++ b/tests/invalid/VarDecl_Invalid_1.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> int:
int x = y
- sys.out.println(Any.toString(x))
+ return x
diff --git a/tests/invalid/Void_Invalid_1.whiley b/tests/invalid/Void_Invalid_1.whiley
index 584e3503b5..983b4e844c 100644
--- a/tests/invalid/Void_Invalid_1.whiley
+++ b/tests/invalid/Void_Invalid_1.whiley
@@ -1,3 +1 @@
-import * from whiley.lang.*
-
function f(void z) -> void:
diff --git a/tests/invalid/Void_Invalid_2.whiley b/tests/invalid/Void_Invalid_2.whiley
index 516ceae29f..20ca5a283f 100644
--- a/tests/invalid/Void_Invalid_2.whiley
+++ b/tests/invalid/Void_Invalid_2.whiley
@@ -1,4 +1,2 @@
-import * from whiley.lang.*
-
function f(int x, void z) -> void:
return
diff --git a/tests/invalid/Void_Invalid_3.whiley b/tests/invalid/Void_Invalid_3.whiley
index 6c3e205a02..16a0cab14f 100644
--- a/tests/invalid/Void_Invalid_3.whiley
+++ b/tests/invalid/Void_Invalid_3.whiley
@@ -1,7 +1,5 @@
-import * from whiley.lang.*
-
method method() -> void:
b = 1
-method main(System.Console sys) -> void:
+method main() -> void:
a = method()
diff --git a/tests/invalid/While_Invalid_1.sysout b/tests/invalid/While_Invalid_1.sysout
index 01815086fe..9ccf3fb4e7 100644
--- a/tests/invalid/While_Invalid_1.sysout
+++ b/tests/invalid/While_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/While_Invalid_1.whiley:10: variable may be uninitialised
+../../tests/invalid/While_Invalid_1.whiley:8: variable may be uninitialised
return i
- ^
+ ^^^^^^^^
diff --git a/tests/invalid/While_Invalid_1.whiley b/tests/invalid/While_Invalid_1.whiley
index b015718d9b..d900a2c7e8 100644
--- a/tests/invalid/While_Invalid_1.whiley
+++ b/tests/invalid/While_Invalid_1.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
method main() -> int:
int j = 0
int i
diff --git a/tests/invalid/While_Invalid_2.sysout b/tests/invalid/While_Invalid_2.sysout
index c983d851d7..c3fe56b283 100644
--- a/tests/invalid/While_Invalid_2.sysout
+++ b/tests/invalid/While_Invalid_2.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/While_Invalid_2.whiley:7: unknown variable
- while i < |sys.args| where j > 0:
- ^
+../../tests/invalid/While_Invalid_2.whiley:5: unknown variable
+ while i < |args| where j > 0:
+ ^
diff --git a/tests/invalid/While_Invalid_2.whiley b/tests/invalid/While_Invalid_2.whiley
index 8137ec0f5b..b50248683d 100644
--- a/tests/invalid/While_Invalid_2.whiley
+++ b/tests/invalid/While_Invalid_2.whiley
@@ -1,10 +1,8 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main([[int]] args) -> int:
int i = 0
int r = 0
//
- while i < |sys.args| where j > 0:
- r = r + |sys.args[i]|
+ while i < |args| where j > 0:
+ r = r + |args[i]|
//
- debug Any.toString(r)
+ return r
diff --git a/tests/invalid/While_Invalid_3.sysout b/tests/invalid/While_Invalid_3.sysout
index d569d34f7d..eeda8b2aae 100644
--- a/tests/invalid/While_Invalid_3.sysout
+++ b/tests/invalid/While_Invalid_3.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/While_Invalid_3.whiley:8: variable may be uninitialised
+../../tests/invalid/While_Invalid_3.whiley:6: variable may be uninitialised
r = r + i
- ^
+ ^^^^^
diff --git a/tests/invalid/While_Invalid_3.whiley b/tests/invalid/While_Invalid_3.whiley
index a4b5d96506..3cd63f95d3 100644
--- a/tests/invalid/While_Invalid_3.whiley
+++ b/tests/invalid/While_Invalid_3.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
method main() -> int:
int i = 0
int r
diff --git a/tests/invalid/While_Invalid_4.sysout b/tests/invalid/While_Invalid_4.sysout
index 1d534a5868..6469eee164 100644
--- a/tests/invalid/While_Invalid_4.sysout
+++ b/tests/invalid/While_Invalid_4.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/While_Invalid_4.whiley:8: expected type [any], found int
+../../tests/invalid/While_Invalid_4.whiley:6: expected type [any], found int
r = r ++ [ls[i]]
^
diff --git a/tests/invalid/While_Invalid_4.whiley b/tests/invalid/While_Invalid_4.whiley
index 8c1e4fb141..f1958f83b7 100644
--- a/tests/invalid/While_Invalid_4.whiley
+++ b/tests/invalid/While_Invalid_4.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function sum([int] ls) -> int:
int i = 0
int r = 0
@@ -10,7 +8,3 @@ function sum([int] ls) -> int:
i = i + 1
//
return r
-
-method main(System.Console sys) -> void:
- rs = sum([-2, -3, 1, 2, -23, 3, 2345, 4, 5])
- debug Any.toString(rs)
diff --git a/tests/invalid/While_Invalid_5.whiley b/tests/invalid/While_Invalid_5.whiley
index 1dccd95a1b..77540362c5 100644
--- a/tests/invalid/While_Invalid_5.whiley
+++ b/tests/invalid/While_Invalid_5.whiley
@@ -8,7 +8,3 @@ function extract([int] ls) -> [int]:
i = i + 1
//
return r
-
-method main(System.Console sys) -> void:
- rs = extract([-2, -3, 1, 2, -23, 3, 2345, 4, 5])
- debug Any.toString(rs)
diff --git a/tests/invalid/While_Invalid_6.sysout b/tests/invalid/While_Invalid_6.sysout
index 2ff16c87ba..dc84fed157 100644
--- a/tests/invalid/While_Invalid_6.sysout
+++ b/tests/invalid/While_Invalid_6.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/While_Invalid_6.whiley:5: expected type int, found [int]
+../../tests/invalid/While_Invalid_6.whiley:3: expected type int, found [int]
int r = [1]
^^^
diff --git a/tests/invalid/While_Invalid_6.whiley b/tests/invalid/While_Invalid_6.whiley
index 703d995867..bcf6fd4793 100644
--- a/tests/invalid/While_Invalid_6.whiley
+++ b/tests/invalid/While_Invalid_6.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function extract([int] ls) -> [void]:
int i = 0
int r = [1]
diff --git a/tests/invalid/While_Invalid_9.whiley b/tests/invalid/While_Invalid_9.whiley
index 38d564db57..202aee023d 100644
--- a/tests/invalid/While_Invalid_9.whiley
+++ b/tests/invalid/While_Invalid_9.whiley
@@ -8,9 +8,3 @@ function extract([int] ls, [int] rs) -> [int]:
i = i + 1
//
return r
-
-method main(System.Console sys) -> void:
- [int] rs
- //
- rs = extract([-2, -3, 1, 2, -23, 3, 2345, 4, 5], [])
- debug Any.toString(rs)
diff --git a/tests/invalid/XOR_Invalid_1.sysout b/tests/invalid/XOR_Invalid_1.sysout
index 02954b303f..38aa5010e5 100644
--- a/tests/invalid/XOR_Invalid_1.sysout
+++ b/tests/invalid/XOR_Invalid_1.sysout
@@ -1,3 +1,3 @@
-../../tests/invalid/XOR_Invalid_1.whiley:5: expected type byte, found int
- crc = crc ^ 11010101b
- ^^^
+../../tests/invalid/XOR_Invalid_1.whiley:3: expected type byte, found int
+ return crc ^ 11010101b
+ ^^^
diff --git a/tests/invalid/XOR_Invalid_1.whiley b/tests/invalid/XOR_Invalid_1.whiley
index 3c80bd8a66..82ffc23a42 100644
--- a/tests/invalid/XOR_Invalid_1.whiley
+++ b/tests/invalid/XOR_Invalid_1.whiley
@@ -1,7 +1,3 @@
-import * from whiley.lang.*
-
-method main(System.Console sys) -> void:
+method main() -> int:
int crc = 4294967295
- crc = crc ^ 11010101b
- sys.out.println(crc)
- crc = crc ^ 11010101b
+ return crc ^ 11010101b
diff --git a/tests/valid/Access_Valid_1.sysout b/tests/valid/Access_Valid_1.sysout
deleted file mode 100644
index 0772e5b9fb..0000000000
--- a/tests/valid/Access_Valid_1.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-2
-3
-[99, 114, 117, 101, 108]
-[119, 111, 114, 108, 100]
\ No newline at end of file
diff --git a/tests/valid/Access_Valid_1.whiley b/tests/valid/Access_Valid_1.whiley
index 84ce864b22..034ea668fe 100644
--- a/tests/valid/Access_Valid_1.whiley
+++ b/tests/valid/Access_Valid_1.whiley
@@ -1,14 +1,16 @@
-import whiley.lang.*
+
type listdict is [int] | {int=>[int]}
function index(listdict l, int index) -> any:
return l[index]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] l = [1, 2, 3]
- sys.out.println(index(l, 1))
- sys.out.println(index(l, 2))
+ assume index(l,0) == 1
+ assume index(l,1) == 2
+ assume index(l,2) == 3
{int=>[int]} m = {1=>"hello", 2=>"cruel", 3=>"world"}
- sys.out.println(index(m, 2))
- sys.out.println(index(m, 3))
+ assume index(m,1) == "hello"
+ assume index(m,2) == "cruel"
+ assume index(m,3) == "world"
diff --git a/tests/valid/Access_Valid_2.sysout b/tests/valid/Access_Valid_2.sysout
deleted file mode 100644
index 05fb720d19..0000000000
--- a/tests/valid/Access_Valid_2.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-2
-3
-72
-108
diff --git a/tests/valid/Access_Valid_2.whiley b/tests/valid/Access_Valid_2.whiley
index 42c79cde1a..f840340ff6 100644
--- a/tests/valid/Access_Valid_2.whiley
+++ b/tests/valid/Access_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type liststr is [int] | [int]
@@ -7,10 +7,12 @@ function index(liststr l, int index) -> any
//
return l[index]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] l = [1, 2, 3]
- sys.out.println(index(l, 1))
- sys.out.println(index(l, 2))
+ assume index(l, 0) == 1
+ assume index(l, 1) == 2
+ assume index(l, 2) == 3
[int] s = "Hello World"
- sys.out.println(index(s, 0))
- sys.out.println(index(s, 2))
+ assume index(s, 0) == 'H'
+ assume index(s, 1) == 'e'
+ assume index(s, 2) == 'l'
diff --git a/tests/valid/Assume_Valid_1.sysout b/tests/valid/Assume_Valid_1.sysout
deleted file mode 100644
index 1e8b314962..0000000000
--- a/tests/valid/Assume_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-6
diff --git a/tests/valid/Assume_Valid_1.whiley b/tests/valid/Assume_Valid_1.whiley
index b4e3b4ab97..97d445a976 100644
--- a/tests/valid/Assume_Valid_1.whiley
+++ b/tests/valid/Assume_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -9,6 +9,6 @@ function sum([nat] list) -> nat:
r = r + l
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
nat rs = sum([0, 1, 2, 3])
- sys.out.println(rs)
+ assert rs == 6
diff --git a/tests/valid/Assume_Valid_2.sysout b/tests/valid/Assume_Valid_2.sysout
deleted file mode 100644
index 9ff31a74b3..0000000000
--- a/tests/valid/Assume_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-ASSUMPTION PASSED!
diff --git a/tests/valid/Assume_Valid_2.whiley b/tests/valid/Assume_Valid_2.whiley
index 121855d7c0..314186a1a2 100644
--- a/tests/valid/Assume_Valid_2.whiley
+++ b/tests/valid/Assume_Valid_2.whiley
@@ -1,5 +1,5 @@
-import whiley.lang.*
-method main(System.Console console) -> void:
+
+public export method test() -> void:
assert 1 == 1
- console.out.println_s("ASSUMPTION PASSED!")
+
diff --git a/tests/valid/BoolAssign_Valid_1.sysout b/tests/valid/BoolAssign_Valid_1.sysout
deleted file mode 100755
index da29283aaa..0000000000
--- a/tests/valid/BoolAssign_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
diff --git a/tests/valid/BoolAssign_Valid_1.whiley b/tests/valid/BoolAssign_Valid_1.whiley
index d0067210b5..78060fd568 100644
--- a/tests/valid/BoolAssign_Valid_1.whiley
+++ b/tests/valid/BoolAssign_Valid_1.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
bool x = true
- sys.out.println(x)
+ assert x == true
x = false
- sys.out.println(x)
+ assert x == false
diff --git a/tests/valid/BoolAssign_Valid_2.sysout b/tests/valid/BoolAssign_Valid_2.sysout
deleted file mode 100755
index 4b9aa5d3a8..0000000000
--- a/tests/valid/BoolAssign_Valid_2.sysout
+++ /dev/null
@@ -1,6 +0,0 @@
-true
-false
-AND
-false
-NOT
-true
diff --git a/tests/valid/BoolAssign_Valid_2.whiley b/tests/valid/BoolAssign_Valid_2.whiley
index d24fcc04c2..70d4b28291 100644
--- a/tests/valid/BoolAssign_Valid_2.whiley
+++ b/tests/valid/BoolAssign_Valid_2.whiley
@@ -1,12 +1,11 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
bool x = true
bool y = false
- sys.out.println(x)
- sys.out.println(y)
- sys.out.println_s("AND")
- x = x && y
- sys.out.println(x)
- sys.out.println_s("NOT")
- sys.out.println(!x)
+ assert (x && x) == true
+ assert (x && y) == false
+ assert (y && x) == false
+ assert (y && y) == false
+ assert !y
+ assert !!x
diff --git a/tests/valid/BoolAssign_Valid_3.sysout b/tests/valid/BoolAssign_Valid_3.sysout
deleted file mode 100755
index 3bb6785c82..0000000000
--- a/tests/valid/BoolAssign_Valid_3.sysout
+++ /dev/null
@@ -1,6 +0,0 @@
-1
-1
-349
-1
-1
-349
diff --git a/tests/valid/BoolAssign_Valid_3.whiley b/tests/valid/BoolAssign_Valid_3.whiley
index 7329fd3a98..2d568b94e8 100644
--- a/tests/valid/BoolAssign_Valid_3.whiley
+++ b/tests/valid/BoolAssign_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x, int y) -> (int r)
requires (x >= 0) && (y >= 0)
@@ -20,10 +20,10 @@ ensures r > 0:
else:
return 1
-method main(System.Console sys) -> void:
- sys.out.println(f(1, 1))
- sys.out.println(f(0, 0))
- sys.out.println(f(4, 345))
- sys.out.println(g(1, 1))
- sys.out.println(g(0, 0))
- sys.out.println(g(4, 345))
+public export method test() -> void:
+ assume f(1, 1) == 1
+ assume f(0, 0) == 1
+ assume f(4, 345) == 349
+ assume g(1, 1) == 1
+ assume g(0, 0) == 1
+ assume g(4, 345) == 349
diff --git a/tests/valid/BoolAssign_Valid_4.sysout b/tests/valid/BoolAssign_Valid_4.sysout
deleted file mode 100755
index 3bb6785c82..0000000000
--- a/tests/valid/BoolAssign_Valid_4.sysout
+++ /dev/null
@@ -1,6 +0,0 @@
-1
-1
-349
-1
-1
-349
diff --git a/tests/valid/BoolAssign_Valid_4.whiley b/tests/valid/BoolAssign_Valid_4.whiley
index 5c0c32331b..3029b83f4a 100644
--- a/tests/valid/BoolAssign_Valid_4.whiley
+++ b/tests/valid/BoolAssign_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x, int y) -> int:
bool a = x == y
@@ -14,10 +14,10 @@ function g(int x, int y) -> int:
else:
return 1
-method main(System.Console sys) -> void:
- sys.out.println(f(1, 1))
- sys.out.println(f(0, 0))
- sys.out.println(f(4, 345))
- sys.out.println(g(1, 1))
- sys.out.println(g(0, 0))
- sys.out.println(g(4, 345))
+public export method test() -> void:
+ assume f(1, 1) == 1
+ assume f(0, 0) == 1
+ assume f(4, 345) == 349
+ assume g(1, 1) == 1
+ assume g(0, 0) == 1
+ assume g(4, 345) == 349
diff --git a/tests/valid/BoolAssign_Valid_5.sysout b/tests/valid/BoolAssign_Valid_5.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/BoolAssign_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/BoolAssign_Valid_5.whiley b/tests/valid/BoolAssign_Valid_5.whiley
index 0953beeadf..76d492c366 100644
--- a/tests/valid/BoolAssign_Valid_5.whiley
+++ b/tests/valid/BoolAssign_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x, int y) -> (int r)
requires (x >= 0) && (y >= 0)
@@ -12,5 +12,7 @@ ensures r > 0:
else:
return 123
-method main(System.Console sys) -> void:
- sys.out.println(1)
+public export method test() -> void:
+ assume f(1,1) == 123
+ assume f(2,1) == 123
+ assume f(1,2) == 3
diff --git a/tests/valid/BoolAssign_Valid_6.sysout b/tests/valid/BoolAssign_Valid_6.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/BoolAssign_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/BoolAssign_Valid_6.whiley b/tests/valid/BoolAssign_Valid_6.whiley
index f56a145b51..fc6f8ea1ec 100644
--- a/tests/valid/BoolAssign_Valid_6.whiley
+++ b/tests/valid/BoolAssign_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x, int y) -> int:
bool a = true
@@ -9,5 +9,7 @@ function f(int x, int y) -> int:
else:
return 123
-method main(System.Console sys) -> void:
- sys.out.println(1)
+public export method test() -> void:
+ assume f(1,1) == 123
+ assume f(2,1) == 123
+ assume f(1,2) == 3
diff --git a/tests/valid/BoolFun_Valid_1.sysout b/tests/valid/BoolFun_Valid_1.sysout
deleted file mode 100755
index da29283aaa..0000000000
--- a/tests/valid/BoolFun_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
diff --git a/tests/valid/BoolFun_Valid_1.whiley b/tests/valid/BoolFun_Valid_1.whiley
index 27f663c79e..8e7b4f8363 100644
--- a/tests/valid/BoolFun_Valid_1.whiley
+++ b/tests/valid/BoolFun_Valid_1.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
function f(bool b) -> bool:
return b
-method main(System.Console sys) -> void:
+public export method test() -> void:
bool x = true
- sys.out.println(f(x))
+ assume f(x)
x = false
- sys.out.println(f(x))
+ assume !f(x)
diff --git a/tests/valid/BoolIfElse_Valid_1.sysout b/tests/valid/BoolIfElse_Valid_1.sysout
deleted file mode 100755
index da29283aaa..0000000000
--- a/tests/valid/BoolIfElse_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
diff --git a/tests/valid/BoolIfElse_Valid_1.whiley b/tests/valid/BoolIfElse_Valid_1.whiley
index c95b9e802c..f8ed6a5d83 100644
--- a/tests/valid/BoolIfElse_Valid_1.whiley
+++ b/tests/valid/BoolIfElse_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(bool b) -> bool:
if b:
@@ -6,6 +6,6 @@ function f(bool b) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f(true))
- sys.out.println(f(false))
+public export method test() -> void:
+ assume f(true)
+ assume !f(false)
diff --git a/tests/valid/BoolIfElse_Valid_2.sysout b/tests/valid/BoolIfElse_Valid_2.sysout
deleted file mode 100644
index 166c0578b9..0000000000
--- a/tests/valid/BoolIfElse_Valid_2.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-0
\ No newline at end of file
diff --git a/tests/valid/BoolIfElse_Valid_2.whiley b/tests/valid/BoolIfElse_Valid_2.whiley
index e7ad7ea8fb..764a6c3d68 100644
--- a/tests/valid/BoolIfElse_Valid_2.whiley
+++ b/tests/valid/BoolIfElse_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(bool b) -> int:
if b:
@@ -6,6 +6,6 @@ function f(bool b) -> int:
else:
return 0
-method main(System.Console sys) -> void:
- sys.out.println(f(true))
- sys.out.println(f(false))
+public export method test() -> void:
+ assume f(true) == 1
+ assume f(false) == 0
diff --git a/tests/valid/BoolList_Valid_1.sysout b/tests/valid/BoolList_Valid_1.sysout
deleted file mode 100755
index 6d644b554c..0000000000
--- a/tests/valid/BoolList_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[true, false, true]
-true
-[false, false, true]
diff --git a/tests/valid/BoolList_Valid_1.whiley b/tests/valid/BoolList_Valid_1.whiley
index 27ac578e0d..820eced6ef 100644
--- a/tests/valid/BoolList_Valid_1.whiley
+++ b/tests/valid/BoolList_Valid_1.whiley
@@ -1,9 +1,12 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[bool] ls = [true, false, true]
- sys.out.println(ls)
- bool x = ls[0]
- sys.out.println(x)
+ assert ls == [true, false, true]
+ assert ls[0] == true
+ assert ls[1] == false
+ assert ls[2] == true
ls[0] = false
- sys.out.println(ls)
+ assert ls[0] == false
+ assert ls[1] == false
+ assert ls[2] == true
diff --git a/tests/valid/BoolList_Valid_2.sysout b/tests/valid/BoolList_Valid_2.sysout
deleted file mode 100644
index c858aaae96..0000000000
--- a/tests/valid/BoolList_Valid_2.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-[true, true, true, true, true, true, true]
-[false, true, true, true, true, true, false]
-[false, false, true, true, true, false, false]
-[false, false, false, true, false, false, false]
-[false, false, false, false, false, false, false]
diff --git a/tests/valid/BoolList_Valid_2.whiley b/tests/valid/BoolList_Valid_2.whiley
index 4d46742334..b6afebb14c 100644
--- a/tests/valid/BoolList_Valid_2.whiley
+++ b/tests/valid/BoolList_Valid_2.whiley
@@ -1,5 +1,3 @@
-import * from whiley.lang.*
-
function play([bool] board) -> [bool]:
[bool] nboard = board
for i in 0 .. |board|:
@@ -15,8 +13,14 @@ function isAlive(int i, [bool] board) -> bool:
else:
return false
-method main(System.Console console) -> void:
+public export method test() -> void:
[bool] xs = [true, true, true, true, true, true, true]
- for i in 0 .. 5:
- console.out.println(xs)
- xs = play(xs)
+ assume xs == [true, true, true, true, true, true, true]
+ xs = play(xs)
+ assume xs == [false, true, true, true, true, true, false]
+ xs = play(xs)
+ assume xs == [false, false, true, true, true, false, false]
+ xs = play(xs)
+ assume xs == [false, false, false, true, false, false, false]
+ xs = play(xs)
+ assume xs == [false, false, false, false, false, false, false]
diff --git a/tests/valid/BoolList_Valid_3.sysout b/tests/valid/BoolList_Valid_3.sysout
deleted file mode 100644
index 8af15ca784..0000000000
--- a/tests/valid/BoolList_Valid_3.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[[false, true, false], [false, true, false], [false, true, false]]
-[[false, false, false], [false, true, false], [false, false, false]]
diff --git a/tests/valid/BoolList_Valid_3.whiley b/tests/valid/BoolList_Valid_3.whiley
index a377a0c656..839a77cf1f 100644
--- a/tests/valid/BoolList_Valid_3.whiley
+++ b/tests/valid/BoolList_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Board is [[bool]]
@@ -37,8 +37,8 @@ function isAlive(Board board, int row, int col) -> int:
else:
return 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
[[bool]] board = [[false, true, false], [false, true, false], [false, true, false]]
[[bool]] nboard = update(board)
- sys.out.println(board)
- sys.out.println(nboard)
+ assume board == [[false, true, false], [false, true, false], [false, true, false]]
+ assume nboard == [[false, false, false], [false, true, false], [false, false, false]]
diff --git a/tests/valid/BoolRecord_Valid_1.sysout b/tests/valid/BoolRecord_Valid_1.sysout
deleted file mode 100755
index 7a285ac0c7..0000000000
--- a/tests/valid/BoolRecord_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{code:0,flag:true}
-{code:0,flag:false}
diff --git a/tests/valid/BoolRecord_Valid_1.whiley b/tests/valid/BoolRecord_Valid_1.whiley
index 22f463acc8..7e03f86842 100644
--- a/tests/valid/BoolRecord_Valid_1.whiley
+++ b/tests/valid/BoolRecord_Valid_1.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{bool flag, int code} x = {flag: true, code: 0}
- sys.out.println(x)
+ assert x == {flag: true, code: 0}
x.flag = false
- sys.out.println(x)
+ assert x == {flag: false, code: 0}
diff --git a/tests/valid/BoolRecord_Valid_2.sysout b/tests/valid/BoolRecord_Valid_2.sysout
deleted file mode 100755
index 071ed6ba84..0000000000
--- a/tests/valid/BoolRecord_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-GOT HERE
diff --git a/tests/valid/BoolRecord_Valid_2.whiley b/tests/valid/BoolRecord_Valid_2.whiley
index 8dc4a05a77..33b0fdc55a 100644
--- a/tests/valid/BoolRecord_Valid_2.whiley
+++ b/tests/valid/BoolRecord_Valid_2.whiley
@@ -1,6 +1,8 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{bool flag, int code} x = {flag: true, code: 0}
if x.flag:
- sys.out.println_s("GOT HERE")
+ assert true
+ else:
+ assert false
diff --git a/tests/valid/BoolRequires_Valid_1.sysout b/tests/valid/BoolRequires_Valid_1.sysout
deleted file mode 100755
index 06944e7ed0..0000000000
--- a/tests/valid/BoolRequires_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[true]
-[true, false]
-[true, false, true]
diff --git a/tests/valid/BoolRequires_Valid_1.whiley b/tests/valid/BoolRequires_Valid_1.whiley
index 7e6150beb4..5711ed8f94 100644
--- a/tests/valid/BoolRequires_Valid_1.whiley
+++ b/tests/valid/BoolRequires_Valid_1.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
function f([bool] x) -> [bool]
requires (|x| > 0) && x[0]:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f([true]))
- sys.out.println(f([true, false]))
- sys.out.println(f([true, false, true]))
+public export method test() -> void:
+ assume f([true]) == [true]
+ assume f([true, false]) == [true, false]
+ assume f([true, false, true]) == [true, false, true]
diff --git a/tests/valid/BoolReturn_Valid_1.sysout b/tests/valid/BoolReturn_Valid_1.sysout
deleted file mode 100755
index c508d5366f..0000000000
--- a/tests/valid/BoolReturn_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-false
diff --git a/tests/valid/BoolReturn_Valid_1.whiley b/tests/valid/BoolReturn_Valid_1.whiley
index ee8b5afa45..08d6f73cf4 100644
--- a/tests/valid/BoolReturn_Valid_1.whiley
+++ b/tests/valid/BoolReturn_Valid_1.whiley
@@ -1,7 +1,8 @@
-import whiley.lang.*
+
function pred() -> bool:
return false
-method main(System.Console sys) -> void:
- sys.out.println(pred())
+public export method test() -> void:
+ assume !pred()
+
diff --git a/tests/valid/Byte_Valid_1.sysout b/tests/valid/Byte_Valid_1.sysout
deleted file mode 100644
index 98c51cadb4..0000000000
--- a/tests/valid/Byte_Valid_1.sysout
+++ /dev/null
@@ -1,255 +0,0 @@
-10000000b
-10000001b
-10000010b
-10000011b
-10000100b
-10000101b
-10000110b
-10000111b
-10001000b
-10001001b
-10001010b
-10001011b
-10001100b
-10001101b
-10001110b
-10001111b
-10010000b
-10010001b
-10010010b
-10010011b
-10010100b
-10010101b
-10010110b
-10010111b
-10011000b
-10011001b
-10011010b
-10011011b
-10011100b
-10011101b
-10011110b
-10011111b
-10100000b
-10100001b
-10100010b
-10100011b
-10100100b
-10100101b
-10100110b
-10100111b
-10101000b
-10101001b
-10101010b
-10101011b
-10101100b
-10101101b
-10101110b
-10101111b
-10110000b
-10110001b
-10110010b
-10110011b
-10110100b
-10110101b
-10110110b
-10110111b
-10111000b
-10111001b
-10111010b
-10111011b
-10111100b
-10111101b
-10111110b
-10111111b
-11000000b
-11000001b
-11000010b
-11000011b
-11000100b
-11000101b
-11000110b
-11000111b
-11001000b
-11001001b
-11001010b
-11001011b
-11001100b
-11001101b
-11001110b
-11001111b
-11010000b
-11010001b
-11010010b
-11010011b
-11010100b
-11010101b
-11010110b
-11010111b
-11011000b
-11011001b
-11011010b
-11011011b
-11011100b
-11011101b
-11011110b
-11011111b
-11100000b
-11100001b
-11100010b
-11100011b
-11100100b
-11100101b
-11100110b
-11100111b
-11101000b
-11101001b
-11101010b
-11101011b
-11101100b
-11101101b
-11101110b
-11101111b
-11110000b
-11110001b
-11110010b
-11110011b
-11110100b
-11110101b
-11110110b
-11110111b
-11111000b
-11111001b
-11111010b
-11111011b
-11111100b
-11111101b
-11111110b
-11111111b
-00000000b
-00000001b
-00000010b
-00000011b
-00000100b
-00000101b
-00000110b
-00000111b
-00001000b
-00001001b
-00001010b
-00001011b
-00001100b
-00001101b
-00001110b
-00001111b
-00010000b
-00010001b
-00010010b
-00010011b
-00010100b
-00010101b
-00010110b
-00010111b
-00011000b
-00011001b
-00011010b
-00011011b
-00011100b
-00011101b
-00011110b
-00011111b
-00100000b
-00100001b
-00100010b
-00100011b
-00100100b
-00100101b
-00100110b
-00100111b
-00101000b
-00101001b
-00101010b
-00101011b
-00101100b
-00101101b
-00101110b
-00101111b
-00110000b
-00110001b
-00110010b
-00110011b
-00110100b
-00110101b
-00110110b
-00110111b
-00111000b
-00111001b
-00111010b
-00111011b
-00111100b
-00111101b
-00111110b
-00111111b
-01000000b
-01000001b
-01000010b
-01000011b
-01000100b
-01000101b
-01000110b
-01000111b
-01001000b
-01001001b
-01001010b
-01001011b
-01001100b
-01001101b
-01001110b
-01001111b
-01010000b
-01010001b
-01010010b
-01010011b
-01010100b
-01010101b
-01010110b
-01010111b
-01011000b
-01011001b
-01011010b
-01011011b
-01011100b
-01011101b
-01011110b
-01011111b
-01100000b
-01100001b
-01100010b
-01100011b
-01100100b
-01100101b
-01100110b
-01100111b
-01101000b
-01101001b
-01101010b
-01101011b
-01101100b
-01101101b
-01101110b
-01101111b
-01110000b
-01110001b
-01110010b
-01110011b
-01110100b
-01110101b
-01110110b
-01110111b
-01111000b
-01111001b
-01111010b
-01111011b
-01111100b
-01111101b
-01111110b
diff --git a/tests/valid/Byte_Valid_1.whiley b/tests/valid/Byte_Valid_1.whiley
index 15425f8fbb..729ad418d0 100644
--- a/tests/valid/Byte_Valid_1.whiley
+++ b/tests/valid/Byte_Valid_1.whiley
@@ -1,7 +1,24 @@
-import whiley.lang.*
-constant constants is [10000000b, 10000001b, 10000010b, 10000011b, 10000100b, 10000101b, 10000110b, 10000111b, 10001000b, 10001001b, 10001010b, 10001011b, 10001100b, 10001101b, 10001110b, 10001111b, 10010000b, 10010001b, 10010010b, 10010011b, 10010100b, 10010101b, 10010110b, 10010111b, 10011000b, 10011001b, 10011010b, 10011011b, 10011100b, 10011101b, 10011110b, 10011111b, 10100000b, 10100001b, 10100010b, 10100011b, 10100100b, 10100101b, 10100110b, 10100111b, 10101000b, 10101001b, 10101010b, 10101011b, 10101100b, 10101101b, 10101110b, 10101111b, 10110000b, 10110001b, 10110010b, 10110011b, 10110100b, 10110101b, 10110110b, 10110111b, 10111000b, 10111001b, 10111010b, 10111011b, 10111100b, 10111101b, 10111110b, 10111111b, 11000000b, 11000001b, 11000010b, 11000011b, 11000100b, 11000101b, 11000110b, 11000111b, 11001000b, 11001001b, 11001010b, 11001011b, 11001100b, 11001101b, 11001110b, 11001111b, 11010000b, 11010001b, 11010010b, 11010011b, 11010100b, 11010101b, 11010110b, 11010111b, 11011000b, 11011001b, 11011010b, 11011011b, 11011100b, 11011101b, 11011110b, 11011111b, 11100000b, 11100001b, 11100010b, 11100011b, 11100100b, 11100101b, 11100110b, 11100111b, 11101000b, 11101001b, 11101010b, 11101011b, 11101100b, 11101101b, 11101110b, 11101111b, 11110000b, 11110001b, 11110010b, 11110011b, 11110100b, 11110101b, 11110110b, 11110111b, 11111000b, 11111001b, 11111010b, 11111011b, 11111100b, 11111101b, 11111110b, 11111111b, 00000000b, 00000001b, 00000010b, 00000011b, 00000100b, 00000101b, 00000110b, 00000111b, 00001000b, 00001001b, 00001010b, 00001011b, 00001100b, 00001101b, 00001110b, 00001111b, 00010000b, 00010001b, 00010010b, 00010011b, 00010100b, 00010101b, 00010110b, 00010111b, 00011000b, 00011001b, 00011010b, 00011011b, 00011100b, 00011101b, 00011110b, 00011111b, 00100000b, 00100001b, 00100010b, 00100011b, 00100100b, 00100101b, 00100110b, 00100111b, 00101000b, 00101001b, 00101010b, 00101011b, 00101100b, 00101101b, 00101110b, 00101111b, 00110000b, 00110001b, 00110010b, 00110011b, 00110100b, 00110101b, 00110110b, 00110111b, 00111000b, 00111001b, 00111010b, 00111011b, 00111100b, 00111101b, 00111110b, 00111111b, 01000000b, 01000001b, 01000010b, 01000011b, 01000100b, 01000101b, 01000110b, 01000111b, 01001000b, 01001001b, 01001010b, 01001011b, 01001100b, 01001101b, 01001110b, 01001111b, 01010000b, 01010001b, 01010010b, 01010011b, 01010100b, 01010101b, 01010110b, 01010111b, 01011000b, 01011001b, 01011010b, 01011011b, 01011100b, 01011101b, 01011110b, 01011111b, 01100000b, 01100001b, 01100010b, 01100011b, 01100100b, 01100101b, 01100110b, 01100111b, 01101000b, 01101001b, 01101010b, 01101011b, 01101100b, 01101101b, 01101110b, 01101111b, 01110000b, 01110001b, 01110010b, 01110011b, 01110100b, 01110101b, 01110110b, 01110111b, 01111000b, 01111001b, 01111010b, 01111011b, 01111100b, 01111101b, 01111110b]
-public method main(System.Console sys) -> void:
- for b in constants:
- sys.out.println(b)
+constant constants is [00000000b, 00000001b, 00000010b, 00000011b, 00000100b, 00000101b, 00000110b, 00000111b, 00001000b, 00001001b, 00001010b, 00001011b, 00001100b, 00001101b, 00001110b, 00001111b, 00010000b, 00010001b, 00010010b, 00010011b, 00010100b, 00010101b, 00010110b, 00010111b, 00011000b, 00011001b, 00011010b, 00011011b, 00011100b, 00011101b, 00011110b, 00011111b, 00100000b, 00100001b, 00100010b, 00100011b, 00100100b, 00100101b, 00100110b, 00100111b, 00101000b, 00101001b, 00101010b, 00101011b, 00101100b, 00101101b, 00101110b, 00101111b, 00110000b, 00110001b, 00110010b, 00110011b, 00110100b, 00110101b, 00110110b, 00110111b, 00111000b, 00111001b, 00111010b, 00111011b, 00111100b, 00111101b, 00111110b, 00111111b, 01000000b, 01000001b, 01000010b, 01000011b, 01000100b, 01000101b, 01000110b, 01000111b, 01001000b, 01001001b, 01001010b, 01001011b, 01001100b, 01001101b, 01001110b, 01001111b, 01010000b, 01010001b, 01010010b, 01010011b, 01010100b, 01010101b, 01010110b, 01010111b, 01011000b, 01011001b, 01011010b, 01011011b, 01011100b, 01011101b, 01011110b, 01011111b, 01100000b, 01100001b, 01100010b, 01100011b, 01100100b, 01100101b, 01100110b, 01100111b, 01101000b, 01101001b, 01101010b, 01101011b, 01101100b, 01101101b, 01101110b, 01101111b, 01110000b, 01110001b, 01110010b, 01110011b, 01110100b, 01110101b, 01110110b, 01110111b, 01111000b, 01111001b, 01111010b, 01111011b, 01111100b, 01111101b, 01111110b, 01111111b, 10000000b, 10000001b, 10000010b, 10000011b, 10000100b, 10000101b, 10000110b, 10000111b, 10001000b, 10001001b, 10001010b, 10001011b, 10001100b, 10001101b, 10001110b, 10001111b, 10010000b, 10010001b, 10010010b, 10010011b, 10010100b, 10010101b, 10010110b, 10010111b, 10011000b, 10011001b, 10011010b, 10011011b, 10011100b, 10011101b, 10011110b, 10011111b, 10100000b, 10100001b, 10100010b, 10100011b, 10100100b, 10100101b, 10100110b, 10100111b, 10101000b, 10101001b, 10101010b, 10101011b, 10101100b, 10101101b, 10101110b, 10101111b, 10110000b, 10110001b, 10110010b, 10110011b, 10110100b, 10110101b, 10110110b, 10110111b, 10111000b, 10111001b, 10111010b, 10111011b, 10111100b, 10111101b, 10111110b, 10111111b, 11000000b, 11000001b, 11000010b, 11000011b, 11000100b, 11000101b, 11000110b, 11000111b, 11001000b, 11001001b, 11001010b, 11001011b, 11001100b, 11001101b, 11001110b, 11001111b, 11010000b, 11010001b, 11010010b, 11010011b, 11010100b, 11010101b, 11010110b, 11010111b, 11011000b, 11011001b, 11011010b, 11011011b, 11011100b, 11011101b, 11011110b, 11011111b, 11100000b, 11100001b, 11100010b, 11100011b, 11100100b, 11100101b, 11100110b, 11100111b, 11101000b, 11101001b, 11101010b, 11101011b, 11101100b, 11101101b, 11101110b, 11101111b, 11110000b, 11110001b, 11110010b, 11110011b, 11110100b, 11110101b, 11110110b, 11110111b, 11111000b, 11111001b, 11111010b, 11111011b, 11111100b, 11111101b, 11111110b, 11111111b]
+
+function inc(byte b) -> byte:
+ //
+ int i = 0
+ byte mask = 1b
+ while i < 8 && ((b&mask) == mask):
+ i = i + 1
+ b = b & ~mask
+ mask = mask << 1
+ //
+ return b | mask
+
+
+public export method test() -> void:
+ byte r = 0b
+ int i = 0
+ while i < |constants|:
+ assume r == constants[i]
+ r = inc(r)
+ i = i + 1
+ // done
diff --git a/tests/valid/Byte_Valid_2.sysout b/tests/valid/Byte_Valid_2.sysout
deleted file mode 100644
index 988fae8d2b..0000000000
--- a/tests/valid/Byte_Valid_2.sysout
+++ /dev/null
@@ -1,65025 +0,0 @@
-10000000b & 10000000b = 10000000b
-10000000b & 10000001b = 10000000b
-10000000b & 10000010b = 10000000b
-10000000b & 10000011b = 10000000b
-10000000b & 10000100b = 10000000b
-10000000b & 10000101b = 10000000b
-10000000b & 10000110b = 10000000b
-10000000b & 10000111b = 10000000b
-10000000b & 10001000b = 10000000b
-10000000b & 10001001b = 10000000b
-10000000b & 10001010b = 10000000b
-10000000b & 10001011b = 10000000b
-10000000b & 10001100b = 10000000b
-10000000b & 10001101b = 10000000b
-10000000b & 10001110b = 10000000b
-10000000b & 10001111b = 10000000b
-10000000b & 10010000b = 10000000b
-10000000b & 10010001b = 10000000b
-10000000b & 10010010b = 10000000b
-10000000b & 10010011b = 10000000b
-10000000b & 10010100b = 10000000b
-10000000b & 10010101b = 10000000b
-10000000b & 10010110b = 10000000b
-10000000b & 10010111b = 10000000b
-10000000b & 10011000b = 10000000b
-10000000b & 10011001b = 10000000b
-10000000b & 10011010b = 10000000b
-10000000b & 10011011b = 10000000b
-10000000b & 10011100b = 10000000b
-10000000b & 10011101b = 10000000b
-10000000b & 10011110b = 10000000b
-10000000b & 10011111b = 10000000b
-10000000b & 10100000b = 10000000b
-10000000b & 10100001b = 10000000b
-10000000b & 10100010b = 10000000b
-10000000b & 10100011b = 10000000b
-10000000b & 10100100b = 10000000b
-10000000b & 10100101b = 10000000b
-10000000b & 10100110b = 10000000b
-10000000b & 10100111b = 10000000b
-10000000b & 10101000b = 10000000b
-10000000b & 10101001b = 10000000b
-10000000b & 10101010b = 10000000b
-10000000b & 10101011b = 10000000b
-10000000b & 10101100b = 10000000b
-10000000b & 10101101b = 10000000b
-10000000b & 10101110b = 10000000b
-10000000b & 10101111b = 10000000b
-10000000b & 10110000b = 10000000b
-10000000b & 10110001b = 10000000b
-10000000b & 10110010b = 10000000b
-10000000b & 10110011b = 10000000b
-10000000b & 10110100b = 10000000b
-10000000b & 10110101b = 10000000b
-10000000b & 10110110b = 10000000b
-10000000b & 10110111b = 10000000b
-10000000b & 10111000b = 10000000b
-10000000b & 10111001b = 10000000b
-10000000b & 10111010b = 10000000b
-10000000b & 10111011b = 10000000b
-10000000b & 10111100b = 10000000b
-10000000b & 10111101b = 10000000b
-10000000b & 10111110b = 10000000b
-10000000b & 10111111b = 10000000b
-10000000b & 11000000b = 10000000b
-10000000b & 11000001b = 10000000b
-10000000b & 11000010b = 10000000b
-10000000b & 11000011b = 10000000b
-10000000b & 11000100b = 10000000b
-10000000b & 11000101b = 10000000b
-10000000b & 11000110b = 10000000b
-10000000b & 11000111b = 10000000b
-10000000b & 11001000b = 10000000b
-10000000b & 11001001b = 10000000b
-10000000b & 11001010b = 10000000b
-10000000b & 11001011b = 10000000b
-10000000b & 11001100b = 10000000b
-10000000b & 11001101b = 10000000b
-10000000b & 11001110b = 10000000b
-10000000b & 11001111b = 10000000b
-10000000b & 11010000b = 10000000b
-10000000b & 11010001b = 10000000b
-10000000b & 11010010b = 10000000b
-10000000b & 11010011b = 10000000b
-10000000b & 11010100b = 10000000b
-10000000b & 11010101b = 10000000b
-10000000b & 11010110b = 10000000b
-10000000b & 11010111b = 10000000b
-10000000b & 11011000b = 10000000b
-10000000b & 11011001b = 10000000b
-10000000b & 11011010b = 10000000b
-10000000b & 11011011b = 10000000b
-10000000b & 11011100b = 10000000b
-10000000b & 11011101b = 10000000b
-10000000b & 11011110b = 10000000b
-10000000b & 11011111b = 10000000b
-10000000b & 11100000b = 10000000b
-10000000b & 11100001b = 10000000b
-10000000b & 11100010b = 10000000b
-10000000b & 11100011b = 10000000b
-10000000b & 11100100b = 10000000b
-10000000b & 11100101b = 10000000b
-10000000b & 11100110b = 10000000b
-10000000b & 11100111b = 10000000b
-10000000b & 11101000b = 10000000b
-10000000b & 11101001b = 10000000b
-10000000b & 11101010b = 10000000b
-10000000b & 11101011b = 10000000b
-10000000b & 11101100b = 10000000b
-10000000b & 11101101b = 10000000b
-10000000b & 11101110b = 10000000b
-10000000b & 11101111b = 10000000b
-10000000b & 11110000b = 10000000b
-10000000b & 11110001b = 10000000b
-10000000b & 11110010b = 10000000b
-10000000b & 11110011b = 10000000b
-10000000b & 11110100b = 10000000b
-10000000b & 11110101b = 10000000b
-10000000b & 11110110b = 10000000b
-10000000b & 11110111b = 10000000b
-10000000b & 11111000b = 10000000b
-10000000b & 11111001b = 10000000b
-10000000b & 11111010b = 10000000b
-10000000b & 11111011b = 10000000b
-10000000b & 11111100b = 10000000b
-10000000b & 11111101b = 10000000b
-10000000b & 11111110b = 10000000b
-10000000b & 11111111b = 10000000b
-10000000b & 00000000b = 00000000b
-10000000b & 00000001b = 00000000b
-10000000b & 00000010b = 00000000b
-10000000b & 00000011b = 00000000b
-10000000b & 00000100b = 00000000b
-10000000b & 00000101b = 00000000b
-10000000b & 00000110b = 00000000b
-10000000b & 00000111b = 00000000b
-10000000b & 00001000b = 00000000b
-10000000b & 00001001b = 00000000b
-10000000b & 00001010b = 00000000b
-10000000b & 00001011b = 00000000b
-10000000b & 00001100b = 00000000b
-10000000b & 00001101b = 00000000b
-10000000b & 00001110b = 00000000b
-10000000b & 00001111b = 00000000b
-10000000b & 00010000b = 00000000b
-10000000b & 00010001b = 00000000b
-10000000b & 00010010b = 00000000b
-10000000b & 00010011b = 00000000b
-10000000b & 00010100b = 00000000b
-10000000b & 00010101b = 00000000b
-10000000b & 00010110b = 00000000b
-10000000b & 00010111b = 00000000b
-10000000b & 00011000b = 00000000b
-10000000b & 00011001b = 00000000b
-10000000b & 00011010b = 00000000b
-10000000b & 00011011b = 00000000b
-10000000b & 00011100b = 00000000b
-10000000b & 00011101b = 00000000b
-10000000b & 00011110b = 00000000b
-10000000b & 00011111b = 00000000b
-10000000b & 00100000b = 00000000b
-10000000b & 00100001b = 00000000b
-10000000b & 00100010b = 00000000b
-10000000b & 00100011b = 00000000b
-10000000b & 00100100b = 00000000b
-10000000b & 00100101b = 00000000b
-10000000b & 00100110b = 00000000b
-10000000b & 00100111b = 00000000b
-10000000b & 00101000b = 00000000b
-10000000b & 00101001b = 00000000b
-10000000b & 00101010b = 00000000b
-10000000b & 00101011b = 00000000b
-10000000b & 00101100b = 00000000b
-10000000b & 00101101b = 00000000b
-10000000b & 00101110b = 00000000b
-10000000b & 00101111b = 00000000b
-10000000b & 00110000b = 00000000b
-10000000b & 00110001b = 00000000b
-10000000b & 00110010b = 00000000b
-10000000b & 00110011b = 00000000b
-10000000b & 00110100b = 00000000b
-10000000b & 00110101b = 00000000b
-10000000b & 00110110b = 00000000b
-10000000b & 00110111b = 00000000b
-10000000b & 00111000b = 00000000b
-10000000b & 00111001b = 00000000b
-10000000b & 00111010b = 00000000b
-10000000b & 00111011b = 00000000b
-10000000b & 00111100b = 00000000b
-10000000b & 00111101b = 00000000b
-10000000b & 00111110b = 00000000b
-10000000b & 00111111b = 00000000b
-10000000b & 01000000b = 00000000b
-10000000b & 01000001b = 00000000b
-10000000b & 01000010b = 00000000b
-10000000b & 01000011b = 00000000b
-10000000b & 01000100b = 00000000b
-10000000b & 01000101b = 00000000b
-10000000b & 01000110b = 00000000b
-10000000b & 01000111b = 00000000b
-10000000b & 01001000b = 00000000b
-10000000b & 01001001b = 00000000b
-10000000b & 01001010b = 00000000b
-10000000b & 01001011b = 00000000b
-10000000b & 01001100b = 00000000b
-10000000b & 01001101b = 00000000b
-10000000b & 01001110b = 00000000b
-10000000b & 01001111b = 00000000b
-10000000b & 01010000b = 00000000b
-10000000b & 01010001b = 00000000b
-10000000b & 01010010b = 00000000b
-10000000b & 01010011b = 00000000b
-10000000b & 01010100b = 00000000b
-10000000b & 01010101b = 00000000b
-10000000b & 01010110b = 00000000b
-10000000b & 01010111b = 00000000b
-10000000b & 01011000b = 00000000b
-10000000b & 01011001b = 00000000b
-10000000b & 01011010b = 00000000b
-10000000b & 01011011b = 00000000b
-10000000b & 01011100b = 00000000b
-10000000b & 01011101b = 00000000b
-10000000b & 01011110b = 00000000b
-10000000b & 01011111b = 00000000b
-10000000b & 01100000b = 00000000b
-10000000b & 01100001b = 00000000b
-10000000b & 01100010b = 00000000b
-10000000b & 01100011b = 00000000b
-10000000b & 01100100b = 00000000b
-10000000b & 01100101b = 00000000b
-10000000b & 01100110b = 00000000b
-10000000b & 01100111b = 00000000b
-10000000b & 01101000b = 00000000b
-10000000b & 01101001b = 00000000b
-10000000b & 01101010b = 00000000b
-10000000b & 01101011b = 00000000b
-10000000b & 01101100b = 00000000b
-10000000b & 01101101b = 00000000b
-10000000b & 01101110b = 00000000b
-10000000b & 01101111b = 00000000b
-10000000b & 01110000b = 00000000b
-10000000b & 01110001b = 00000000b
-10000000b & 01110010b = 00000000b
-10000000b & 01110011b = 00000000b
-10000000b & 01110100b = 00000000b
-10000000b & 01110101b = 00000000b
-10000000b & 01110110b = 00000000b
-10000000b & 01110111b = 00000000b
-10000000b & 01111000b = 00000000b
-10000000b & 01111001b = 00000000b
-10000000b & 01111010b = 00000000b
-10000000b & 01111011b = 00000000b
-10000000b & 01111100b = 00000000b
-10000000b & 01111101b = 00000000b
-10000000b & 01111110b = 00000000b
-10000001b & 10000000b = 10000000b
-10000001b & 10000001b = 10000001b
-10000001b & 10000010b = 10000000b
-10000001b & 10000011b = 10000001b
-10000001b & 10000100b = 10000000b
-10000001b & 10000101b = 10000001b
-10000001b & 10000110b = 10000000b
-10000001b & 10000111b = 10000001b
-10000001b & 10001000b = 10000000b
-10000001b & 10001001b = 10000001b
-10000001b & 10001010b = 10000000b
-10000001b & 10001011b = 10000001b
-10000001b & 10001100b = 10000000b
-10000001b & 10001101b = 10000001b
-10000001b & 10001110b = 10000000b
-10000001b & 10001111b = 10000001b
-10000001b & 10010000b = 10000000b
-10000001b & 10010001b = 10000001b
-10000001b & 10010010b = 10000000b
-10000001b & 10010011b = 10000001b
-10000001b & 10010100b = 10000000b
-10000001b & 10010101b = 10000001b
-10000001b & 10010110b = 10000000b
-10000001b & 10010111b = 10000001b
-10000001b & 10011000b = 10000000b
-10000001b & 10011001b = 10000001b
-10000001b & 10011010b = 10000000b
-10000001b & 10011011b = 10000001b
-10000001b & 10011100b = 10000000b
-10000001b & 10011101b = 10000001b
-10000001b & 10011110b = 10000000b
-10000001b & 10011111b = 10000001b
-10000001b & 10100000b = 10000000b
-10000001b & 10100001b = 10000001b
-10000001b & 10100010b = 10000000b
-10000001b & 10100011b = 10000001b
-10000001b & 10100100b = 10000000b
-10000001b & 10100101b = 10000001b
-10000001b & 10100110b = 10000000b
-10000001b & 10100111b = 10000001b
-10000001b & 10101000b = 10000000b
-10000001b & 10101001b = 10000001b
-10000001b & 10101010b = 10000000b
-10000001b & 10101011b = 10000001b
-10000001b & 10101100b = 10000000b
-10000001b & 10101101b = 10000001b
-10000001b & 10101110b = 10000000b
-10000001b & 10101111b = 10000001b
-10000001b & 10110000b = 10000000b
-10000001b & 10110001b = 10000001b
-10000001b & 10110010b = 10000000b
-10000001b & 10110011b = 10000001b
-10000001b & 10110100b = 10000000b
-10000001b & 10110101b = 10000001b
-10000001b & 10110110b = 10000000b
-10000001b & 10110111b = 10000001b
-10000001b & 10111000b = 10000000b
-10000001b & 10111001b = 10000001b
-10000001b & 10111010b = 10000000b
-10000001b & 10111011b = 10000001b
-10000001b & 10111100b = 10000000b
-10000001b & 10111101b = 10000001b
-10000001b & 10111110b = 10000000b
-10000001b & 10111111b = 10000001b
-10000001b & 11000000b = 10000000b
-10000001b & 11000001b = 10000001b
-10000001b & 11000010b = 10000000b
-10000001b & 11000011b = 10000001b
-10000001b & 11000100b = 10000000b
-10000001b & 11000101b = 10000001b
-10000001b & 11000110b = 10000000b
-10000001b & 11000111b = 10000001b
-10000001b & 11001000b = 10000000b
-10000001b & 11001001b = 10000001b
-10000001b & 11001010b = 10000000b
-10000001b & 11001011b = 10000001b
-10000001b & 11001100b = 10000000b
-10000001b & 11001101b = 10000001b
-10000001b & 11001110b = 10000000b
-10000001b & 11001111b = 10000001b
-10000001b & 11010000b = 10000000b
-10000001b & 11010001b = 10000001b
-10000001b & 11010010b = 10000000b
-10000001b & 11010011b = 10000001b
-10000001b & 11010100b = 10000000b
-10000001b & 11010101b = 10000001b
-10000001b & 11010110b = 10000000b
-10000001b & 11010111b = 10000001b
-10000001b & 11011000b = 10000000b
-10000001b & 11011001b = 10000001b
-10000001b & 11011010b = 10000000b
-10000001b & 11011011b = 10000001b
-10000001b & 11011100b = 10000000b
-10000001b & 11011101b = 10000001b
-10000001b & 11011110b = 10000000b
-10000001b & 11011111b = 10000001b
-10000001b & 11100000b = 10000000b
-10000001b & 11100001b = 10000001b
-10000001b & 11100010b = 10000000b
-10000001b & 11100011b = 10000001b
-10000001b & 11100100b = 10000000b
-10000001b & 11100101b = 10000001b
-10000001b & 11100110b = 10000000b
-10000001b & 11100111b = 10000001b
-10000001b & 11101000b = 10000000b
-10000001b & 11101001b = 10000001b
-10000001b & 11101010b = 10000000b
-10000001b & 11101011b = 10000001b
-10000001b & 11101100b = 10000000b
-10000001b & 11101101b = 10000001b
-10000001b & 11101110b = 10000000b
-10000001b & 11101111b = 10000001b
-10000001b & 11110000b = 10000000b
-10000001b & 11110001b = 10000001b
-10000001b & 11110010b = 10000000b
-10000001b & 11110011b = 10000001b
-10000001b & 11110100b = 10000000b
-10000001b & 11110101b = 10000001b
-10000001b & 11110110b = 10000000b
-10000001b & 11110111b = 10000001b
-10000001b & 11111000b = 10000000b
-10000001b & 11111001b = 10000001b
-10000001b & 11111010b = 10000000b
-10000001b & 11111011b = 10000001b
-10000001b & 11111100b = 10000000b
-10000001b & 11111101b = 10000001b
-10000001b & 11111110b = 10000000b
-10000001b & 11111111b = 10000001b
-10000001b & 00000000b = 00000000b
-10000001b & 00000001b = 00000001b
-10000001b & 00000010b = 00000000b
-10000001b & 00000011b = 00000001b
-10000001b & 00000100b = 00000000b
-10000001b & 00000101b = 00000001b
-10000001b & 00000110b = 00000000b
-10000001b & 00000111b = 00000001b
-10000001b & 00001000b = 00000000b
-10000001b & 00001001b = 00000001b
-10000001b & 00001010b = 00000000b
-10000001b & 00001011b = 00000001b
-10000001b & 00001100b = 00000000b
-10000001b & 00001101b = 00000001b
-10000001b & 00001110b = 00000000b
-10000001b & 00001111b = 00000001b
-10000001b & 00010000b = 00000000b
-10000001b & 00010001b = 00000001b
-10000001b & 00010010b = 00000000b
-10000001b & 00010011b = 00000001b
-10000001b & 00010100b = 00000000b
-10000001b & 00010101b = 00000001b
-10000001b & 00010110b = 00000000b
-10000001b & 00010111b = 00000001b
-10000001b & 00011000b = 00000000b
-10000001b & 00011001b = 00000001b
-10000001b & 00011010b = 00000000b
-10000001b & 00011011b = 00000001b
-10000001b & 00011100b = 00000000b
-10000001b & 00011101b = 00000001b
-10000001b & 00011110b = 00000000b
-10000001b & 00011111b = 00000001b
-10000001b & 00100000b = 00000000b
-10000001b & 00100001b = 00000001b
-10000001b & 00100010b = 00000000b
-10000001b & 00100011b = 00000001b
-10000001b & 00100100b = 00000000b
-10000001b & 00100101b = 00000001b
-10000001b & 00100110b = 00000000b
-10000001b & 00100111b = 00000001b
-10000001b & 00101000b = 00000000b
-10000001b & 00101001b = 00000001b
-10000001b & 00101010b = 00000000b
-10000001b & 00101011b = 00000001b
-10000001b & 00101100b = 00000000b
-10000001b & 00101101b = 00000001b
-10000001b & 00101110b = 00000000b
-10000001b & 00101111b = 00000001b
-10000001b & 00110000b = 00000000b
-10000001b & 00110001b = 00000001b
-10000001b & 00110010b = 00000000b
-10000001b & 00110011b = 00000001b
-10000001b & 00110100b = 00000000b
-10000001b & 00110101b = 00000001b
-10000001b & 00110110b = 00000000b
-10000001b & 00110111b = 00000001b
-10000001b & 00111000b = 00000000b
-10000001b & 00111001b = 00000001b
-10000001b & 00111010b = 00000000b
-10000001b & 00111011b = 00000001b
-10000001b & 00111100b = 00000000b
-10000001b & 00111101b = 00000001b
-10000001b & 00111110b = 00000000b
-10000001b & 00111111b = 00000001b
-10000001b & 01000000b = 00000000b
-10000001b & 01000001b = 00000001b
-10000001b & 01000010b = 00000000b
-10000001b & 01000011b = 00000001b
-10000001b & 01000100b = 00000000b
-10000001b & 01000101b = 00000001b
-10000001b & 01000110b = 00000000b
-10000001b & 01000111b = 00000001b
-10000001b & 01001000b = 00000000b
-10000001b & 01001001b = 00000001b
-10000001b & 01001010b = 00000000b
-10000001b & 01001011b = 00000001b
-10000001b & 01001100b = 00000000b
-10000001b & 01001101b = 00000001b
-10000001b & 01001110b = 00000000b
-10000001b & 01001111b = 00000001b
-10000001b & 01010000b = 00000000b
-10000001b & 01010001b = 00000001b
-10000001b & 01010010b = 00000000b
-10000001b & 01010011b = 00000001b
-10000001b & 01010100b = 00000000b
-10000001b & 01010101b = 00000001b
-10000001b & 01010110b = 00000000b
-10000001b & 01010111b = 00000001b
-10000001b & 01011000b = 00000000b
-10000001b & 01011001b = 00000001b
-10000001b & 01011010b = 00000000b
-10000001b & 01011011b = 00000001b
-10000001b & 01011100b = 00000000b
-10000001b & 01011101b = 00000001b
-10000001b & 01011110b = 00000000b
-10000001b & 01011111b = 00000001b
-10000001b & 01100000b = 00000000b
-10000001b & 01100001b = 00000001b
-10000001b & 01100010b = 00000000b
-10000001b & 01100011b = 00000001b
-10000001b & 01100100b = 00000000b
-10000001b & 01100101b = 00000001b
-10000001b & 01100110b = 00000000b
-10000001b & 01100111b = 00000001b
-10000001b & 01101000b = 00000000b
-10000001b & 01101001b = 00000001b
-10000001b & 01101010b = 00000000b
-10000001b & 01101011b = 00000001b
-10000001b & 01101100b = 00000000b
-10000001b & 01101101b = 00000001b
-10000001b & 01101110b = 00000000b
-10000001b & 01101111b = 00000001b
-10000001b & 01110000b = 00000000b
-10000001b & 01110001b = 00000001b
-10000001b & 01110010b = 00000000b
-10000001b & 01110011b = 00000001b
-10000001b & 01110100b = 00000000b
-10000001b & 01110101b = 00000001b
-10000001b & 01110110b = 00000000b
-10000001b & 01110111b = 00000001b
-10000001b & 01111000b = 00000000b
-10000001b & 01111001b = 00000001b
-10000001b & 01111010b = 00000000b
-10000001b & 01111011b = 00000001b
-10000001b & 01111100b = 00000000b
-10000001b & 01111101b = 00000001b
-10000001b & 01111110b = 00000000b
-10000010b & 10000000b = 10000000b
-10000010b & 10000001b = 10000000b
-10000010b & 10000010b = 10000010b
-10000010b & 10000011b = 10000010b
-10000010b & 10000100b = 10000000b
-10000010b & 10000101b = 10000000b
-10000010b & 10000110b = 10000010b
-10000010b & 10000111b = 10000010b
-10000010b & 10001000b = 10000000b
-10000010b & 10001001b = 10000000b
-10000010b & 10001010b = 10000010b
-10000010b & 10001011b = 10000010b
-10000010b & 10001100b = 10000000b
-10000010b & 10001101b = 10000000b
-10000010b & 10001110b = 10000010b
-10000010b & 10001111b = 10000010b
-10000010b & 10010000b = 10000000b
-10000010b & 10010001b = 10000000b
-10000010b & 10010010b = 10000010b
-10000010b & 10010011b = 10000010b
-10000010b & 10010100b = 10000000b
-10000010b & 10010101b = 10000000b
-10000010b & 10010110b = 10000010b
-10000010b & 10010111b = 10000010b
-10000010b & 10011000b = 10000000b
-10000010b & 10011001b = 10000000b
-10000010b & 10011010b = 10000010b
-10000010b & 10011011b = 10000010b
-10000010b & 10011100b = 10000000b
-10000010b & 10011101b = 10000000b
-10000010b & 10011110b = 10000010b
-10000010b & 10011111b = 10000010b
-10000010b & 10100000b = 10000000b
-10000010b & 10100001b = 10000000b
-10000010b & 10100010b = 10000010b
-10000010b & 10100011b = 10000010b
-10000010b & 10100100b = 10000000b
-10000010b & 10100101b = 10000000b
-10000010b & 10100110b = 10000010b
-10000010b & 10100111b = 10000010b
-10000010b & 10101000b = 10000000b
-10000010b & 10101001b = 10000000b
-10000010b & 10101010b = 10000010b
-10000010b & 10101011b = 10000010b
-10000010b & 10101100b = 10000000b
-10000010b & 10101101b = 10000000b
-10000010b & 10101110b = 10000010b
-10000010b & 10101111b = 10000010b
-10000010b & 10110000b = 10000000b
-10000010b & 10110001b = 10000000b
-10000010b & 10110010b = 10000010b
-10000010b & 10110011b = 10000010b
-10000010b & 10110100b = 10000000b
-10000010b & 10110101b = 10000000b
-10000010b & 10110110b = 10000010b
-10000010b & 10110111b = 10000010b
-10000010b & 10111000b = 10000000b
-10000010b & 10111001b = 10000000b
-10000010b & 10111010b = 10000010b
-10000010b & 10111011b = 10000010b
-10000010b & 10111100b = 10000000b
-10000010b & 10111101b = 10000000b
-10000010b & 10111110b = 10000010b
-10000010b & 10111111b = 10000010b
-10000010b & 11000000b = 10000000b
-10000010b & 11000001b = 10000000b
-10000010b & 11000010b = 10000010b
-10000010b & 11000011b = 10000010b
-10000010b & 11000100b = 10000000b
-10000010b & 11000101b = 10000000b
-10000010b & 11000110b = 10000010b
-10000010b & 11000111b = 10000010b
-10000010b & 11001000b = 10000000b
-10000010b & 11001001b = 10000000b
-10000010b & 11001010b = 10000010b
-10000010b & 11001011b = 10000010b
-10000010b & 11001100b = 10000000b
-10000010b & 11001101b = 10000000b
-10000010b & 11001110b = 10000010b
-10000010b & 11001111b = 10000010b
-10000010b & 11010000b = 10000000b
-10000010b & 11010001b = 10000000b
-10000010b & 11010010b = 10000010b
-10000010b & 11010011b = 10000010b
-10000010b & 11010100b = 10000000b
-10000010b & 11010101b = 10000000b
-10000010b & 11010110b = 10000010b
-10000010b & 11010111b = 10000010b
-10000010b & 11011000b = 10000000b
-10000010b & 11011001b = 10000000b
-10000010b & 11011010b = 10000010b
-10000010b & 11011011b = 10000010b
-10000010b & 11011100b = 10000000b
-10000010b & 11011101b = 10000000b
-10000010b & 11011110b = 10000010b
-10000010b & 11011111b = 10000010b
-10000010b & 11100000b = 10000000b
-10000010b & 11100001b = 10000000b
-10000010b & 11100010b = 10000010b
-10000010b & 11100011b = 10000010b
-10000010b & 11100100b = 10000000b
-10000010b & 11100101b = 10000000b
-10000010b & 11100110b = 10000010b
-10000010b & 11100111b = 10000010b
-10000010b & 11101000b = 10000000b
-10000010b & 11101001b = 10000000b
-10000010b & 11101010b = 10000010b
-10000010b & 11101011b = 10000010b
-10000010b & 11101100b = 10000000b
-10000010b & 11101101b = 10000000b
-10000010b & 11101110b = 10000010b
-10000010b & 11101111b = 10000010b
-10000010b & 11110000b = 10000000b
-10000010b & 11110001b = 10000000b
-10000010b & 11110010b = 10000010b
-10000010b & 11110011b = 10000010b
-10000010b & 11110100b = 10000000b
-10000010b & 11110101b = 10000000b
-10000010b & 11110110b = 10000010b
-10000010b & 11110111b = 10000010b
-10000010b & 11111000b = 10000000b
-10000010b & 11111001b = 10000000b
-10000010b & 11111010b = 10000010b
-10000010b & 11111011b = 10000010b
-10000010b & 11111100b = 10000000b
-10000010b & 11111101b = 10000000b
-10000010b & 11111110b = 10000010b
-10000010b & 11111111b = 10000010b
-10000010b & 00000000b = 00000000b
-10000010b & 00000001b = 00000000b
-10000010b & 00000010b = 00000010b
-10000010b & 00000011b = 00000010b
-10000010b & 00000100b = 00000000b
-10000010b & 00000101b = 00000000b
-10000010b & 00000110b = 00000010b
-10000010b & 00000111b = 00000010b
-10000010b & 00001000b = 00000000b
-10000010b & 00001001b = 00000000b
-10000010b & 00001010b = 00000010b
-10000010b & 00001011b = 00000010b
-10000010b & 00001100b = 00000000b
-10000010b & 00001101b = 00000000b
-10000010b & 00001110b = 00000010b
-10000010b & 00001111b = 00000010b
-10000010b & 00010000b = 00000000b
-10000010b & 00010001b = 00000000b
-10000010b & 00010010b = 00000010b
-10000010b & 00010011b = 00000010b
-10000010b & 00010100b = 00000000b
-10000010b & 00010101b = 00000000b
-10000010b & 00010110b = 00000010b
-10000010b & 00010111b = 00000010b
-10000010b & 00011000b = 00000000b
-10000010b & 00011001b = 00000000b
-10000010b & 00011010b = 00000010b
-10000010b & 00011011b = 00000010b
-10000010b & 00011100b = 00000000b
-10000010b & 00011101b = 00000000b
-10000010b & 00011110b = 00000010b
-10000010b & 00011111b = 00000010b
-10000010b & 00100000b = 00000000b
-10000010b & 00100001b = 00000000b
-10000010b & 00100010b = 00000010b
-10000010b & 00100011b = 00000010b
-10000010b & 00100100b = 00000000b
-10000010b & 00100101b = 00000000b
-10000010b & 00100110b = 00000010b
-10000010b & 00100111b = 00000010b
-10000010b & 00101000b = 00000000b
-10000010b & 00101001b = 00000000b
-10000010b & 00101010b = 00000010b
-10000010b & 00101011b = 00000010b
-10000010b & 00101100b = 00000000b
-10000010b & 00101101b = 00000000b
-10000010b & 00101110b = 00000010b
-10000010b & 00101111b = 00000010b
-10000010b & 00110000b = 00000000b
-10000010b & 00110001b = 00000000b
-10000010b & 00110010b = 00000010b
-10000010b & 00110011b = 00000010b
-10000010b & 00110100b = 00000000b
-10000010b & 00110101b = 00000000b
-10000010b & 00110110b = 00000010b
-10000010b & 00110111b = 00000010b
-10000010b & 00111000b = 00000000b
-10000010b & 00111001b = 00000000b
-10000010b & 00111010b = 00000010b
-10000010b & 00111011b = 00000010b
-10000010b & 00111100b = 00000000b
-10000010b & 00111101b = 00000000b
-10000010b & 00111110b = 00000010b
-10000010b & 00111111b = 00000010b
-10000010b & 01000000b = 00000000b
-10000010b & 01000001b = 00000000b
-10000010b & 01000010b = 00000010b
-10000010b & 01000011b = 00000010b
-10000010b & 01000100b = 00000000b
-10000010b & 01000101b = 00000000b
-10000010b & 01000110b = 00000010b
-10000010b & 01000111b = 00000010b
-10000010b & 01001000b = 00000000b
-10000010b & 01001001b = 00000000b
-10000010b & 01001010b = 00000010b
-10000010b & 01001011b = 00000010b
-10000010b & 01001100b = 00000000b
-10000010b & 01001101b = 00000000b
-10000010b & 01001110b = 00000010b
-10000010b & 01001111b = 00000010b
-10000010b & 01010000b = 00000000b
-10000010b & 01010001b = 00000000b
-10000010b & 01010010b = 00000010b
-10000010b & 01010011b = 00000010b
-10000010b & 01010100b = 00000000b
-10000010b & 01010101b = 00000000b
-10000010b & 01010110b = 00000010b
-10000010b & 01010111b = 00000010b
-10000010b & 01011000b = 00000000b
-10000010b & 01011001b = 00000000b
-10000010b & 01011010b = 00000010b
-10000010b & 01011011b = 00000010b
-10000010b & 01011100b = 00000000b
-10000010b & 01011101b = 00000000b
-10000010b & 01011110b = 00000010b
-10000010b & 01011111b = 00000010b
-10000010b & 01100000b = 00000000b
-10000010b & 01100001b = 00000000b
-10000010b & 01100010b = 00000010b
-10000010b & 01100011b = 00000010b
-10000010b & 01100100b = 00000000b
-10000010b & 01100101b = 00000000b
-10000010b & 01100110b = 00000010b
-10000010b & 01100111b = 00000010b
-10000010b & 01101000b = 00000000b
-10000010b & 01101001b = 00000000b
-10000010b & 01101010b = 00000010b
-10000010b & 01101011b = 00000010b
-10000010b & 01101100b = 00000000b
-10000010b & 01101101b = 00000000b
-10000010b & 01101110b = 00000010b
-10000010b & 01101111b = 00000010b
-10000010b & 01110000b = 00000000b
-10000010b & 01110001b = 00000000b
-10000010b & 01110010b = 00000010b
-10000010b & 01110011b = 00000010b
-10000010b & 01110100b = 00000000b
-10000010b & 01110101b = 00000000b
-10000010b & 01110110b = 00000010b
-10000010b & 01110111b = 00000010b
-10000010b & 01111000b = 00000000b
-10000010b & 01111001b = 00000000b
-10000010b & 01111010b = 00000010b
-10000010b & 01111011b = 00000010b
-10000010b & 01111100b = 00000000b
-10000010b & 01111101b = 00000000b
-10000010b & 01111110b = 00000010b
-10000011b & 10000000b = 10000000b
-10000011b & 10000001b = 10000001b
-10000011b & 10000010b = 10000010b
-10000011b & 10000011b = 10000011b
-10000011b & 10000100b = 10000000b
-10000011b & 10000101b = 10000001b
-10000011b & 10000110b = 10000010b
-10000011b & 10000111b = 10000011b
-10000011b & 10001000b = 10000000b
-10000011b & 10001001b = 10000001b
-10000011b & 10001010b = 10000010b
-10000011b & 10001011b = 10000011b
-10000011b & 10001100b = 10000000b
-10000011b & 10001101b = 10000001b
-10000011b & 10001110b = 10000010b
-10000011b & 10001111b = 10000011b
-10000011b & 10010000b = 10000000b
-10000011b & 10010001b = 10000001b
-10000011b & 10010010b = 10000010b
-10000011b & 10010011b = 10000011b
-10000011b & 10010100b = 10000000b
-10000011b & 10010101b = 10000001b
-10000011b & 10010110b = 10000010b
-10000011b & 10010111b = 10000011b
-10000011b & 10011000b = 10000000b
-10000011b & 10011001b = 10000001b
-10000011b & 10011010b = 10000010b
-10000011b & 10011011b = 10000011b
-10000011b & 10011100b = 10000000b
-10000011b & 10011101b = 10000001b
-10000011b & 10011110b = 10000010b
-10000011b & 10011111b = 10000011b
-10000011b & 10100000b = 10000000b
-10000011b & 10100001b = 10000001b
-10000011b & 10100010b = 10000010b
-10000011b & 10100011b = 10000011b
-10000011b & 10100100b = 10000000b
-10000011b & 10100101b = 10000001b
-10000011b & 10100110b = 10000010b
-10000011b & 10100111b = 10000011b
-10000011b & 10101000b = 10000000b
-10000011b & 10101001b = 10000001b
-10000011b & 10101010b = 10000010b
-10000011b & 10101011b = 10000011b
-10000011b & 10101100b = 10000000b
-10000011b & 10101101b = 10000001b
-10000011b & 10101110b = 10000010b
-10000011b & 10101111b = 10000011b
-10000011b & 10110000b = 10000000b
-10000011b & 10110001b = 10000001b
-10000011b & 10110010b = 10000010b
-10000011b & 10110011b = 10000011b
-10000011b & 10110100b = 10000000b
-10000011b & 10110101b = 10000001b
-10000011b & 10110110b = 10000010b
-10000011b & 10110111b = 10000011b
-10000011b & 10111000b = 10000000b
-10000011b & 10111001b = 10000001b
-10000011b & 10111010b = 10000010b
-10000011b & 10111011b = 10000011b
-10000011b & 10111100b = 10000000b
-10000011b & 10111101b = 10000001b
-10000011b & 10111110b = 10000010b
-10000011b & 10111111b = 10000011b
-10000011b & 11000000b = 10000000b
-10000011b & 11000001b = 10000001b
-10000011b & 11000010b = 10000010b
-10000011b & 11000011b = 10000011b
-10000011b & 11000100b = 10000000b
-10000011b & 11000101b = 10000001b
-10000011b & 11000110b = 10000010b
-10000011b & 11000111b = 10000011b
-10000011b & 11001000b = 10000000b
-10000011b & 11001001b = 10000001b
-10000011b & 11001010b = 10000010b
-10000011b & 11001011b = 10000011b
-10000011b & 11001100b = 10000000b
-10000011b & 11001101b = 10000001b
-10000011b & 11001110b = 10000010b
-10000011b & 11001111b = 10000011b
-10000011b & 11010000b = 10000000b
-10000011b & 11010001b = 10000001b
-10000011b & 11010010b = 10000010b
-10000011b & 11010011b = 10000011b
-10000011b & 11010100b = 10000000b
-10000011b & 11010101b = 10000001b
-10000011b & 11010110b = 10000010b
-10000011b & 11010111b = 10000011b
-10000011b & 11011000b = 10000000b
-10000011b & 11011001b = 10000001b
-10000011b & 11011010b = 10000010b
-10000011b & 11011011b = 10000011b
-10000011b & 11011100b = 10000000b
-10000011b & 11011101b = 10000001b
-10000011b & 11011110b = 10000010b
-10000011b & 11011111b = 10000011b
-10000011b & 11100000b = 10000000b
-10000011b & 11100001b = 10000001b
-10000011b & 11100010b = 10000010b
-10000011b & 11100011b = 10000011b
-10000011b & 11100100b = 10000000b
-10000011b & 11100101b = 10000001b
-10000011b & 11100110b = 10000010b
-10000011b & 11100111b = 10000011b
-10000011b & 11101000b = 10000000b
-10000011b & 11101001b = 10000001b
-10000011b & 11101010b = 10000010b
-10000011b & 11101011b = 10000011b
-10000011b & 11101100b = 10000000b
-10000011b & 11101101b = 10000001b
-10000011b & 11101110b = 10000010b
-10000011b & 11101111b = 10000011b
-10000011b & 11110000b = 10000000b
-10000011b & 11110001b = 10000001b
-10000011b & 11110010b = 10000010b
-10000011b & 11110011b = 10000011b
-10000011b & 11110100b = 10000000b
-10000011b & 11110101b = 10000001b
-10000011b & 11110110b = 10000010b
-10000011b & 11110111b = 10000011b
-10000011b & 11111000b = 10000000b
-10000011b & 11111001b = 10000001b
-10000011b & 11111010b = 10000010b
-10000011b & 11111011b = 10000011b
-10000011b & 11111100b = 10000000b
-10000011b & 11111101b = 10000001b
-10000011b & 11111110b = 10000010b
-10000011b & 11111111b = 10000011b
-10000011b & 00000000b = 00000000b
-10000011b & 00000001b = 00000001b
-10000011b & 00000010b = 00000010b
-10000011b & 00000011b = 00000011b
-10000011b & 00000100b = 00000000b
-10000011b & 00000101b = 00000001b
-10000011b & 00000110b = 00000010b
-10000011b & 00000111b = 00000011b
-10000011b & 00001000b = 00000000b
-10000011b & 00001001b = 00000001b
-10000011b & 00001010b = 00000010b
-10000011b & 00001011b = 00000011b
-10000011b & 00001100b = 00000000b
-10000011b & 00001101b = 00000001b
-10000011b & 00001110b = 00000010b
-10000011b & 00001111b = 00000011b
-10000011b & 00010000b = 00000000b
-10000011b & 00010001b = 00000001b
-10000011b & 00010010b = 00000010b
-10000011b & 00010011b = 00000011b
-10000011b & 00010100b = 00000000b
-10000011b & 00010101b = 00000001b
-10000011b & 00010110b = 00000010b
-10000011b & 00010111b = 00000011b
-10000011b & 00011000b = 00000000b
-10000011b & 00011001b = 00000001b
-10000011b & 00011010b = 00000010b
-10000011b & 00011011b = 00000011b
-10000011b & 00011100b = 00000000b
-10000011b & 00011101b = 00000001b
-10000011b & 00011110b = 00000010b
-10000011b & 00011111b = 00000011b
-10000011b & 00100000b = 00000000b
-10000011b & 00100001b = 00000001b
-10000011b & 00100010b = 00000010b
-10000011b & 00100011b = 00000011b
-10000011b & 00100100b = 00000000b
-10000011b & 00100101b = 00000001b
-10000011b & 00100110b = 00000010b
-10000011b & 00100111b = 00000011b
-10000011b & 00101000b = 00000000b
-10000011b & 00101001b = 00000001b
-10000011b & 00101010b = 00000010b
-10000011b & 00101011b = 00000011b
-10000011b & 00101100b = 00000000b
-10000011b & 00101101b = 00000001b
-10000011b & 00101110b = 00000010b
-10000011b & 00101111b = 00000011b
-10000011b & 00110000b = 00000000b
-10000011b & 00110001b = 00000001b
-10000011b & 00110010b = 00000010b
-10000011b & 00110011b = 00000011b
-10000011b & 00110100b = 00000000b
-10000011b & 00110101b = 00000001b
-10000011b & 00110110b = 00000010b
-10000011b & 00110111b = 00000011b
-10000011b & 00111000b = 00000000b
-10000011b & 00111001b = 00000001b
-10000011b & 00111010b = 00000010b
-10000011b & 00111011b = 00000011b
-10000011b & 00111100b = 00000000b
-10000011b & 00111101b = 00000001b
-10000011b & 00111110b = 00000010b
-10000011b & 00111111b = 00000011b
-10000011b & 01000000b = 00000000b
-10000011b & 01000001b = 00000001b
-10000011b & 01000010b = 00000010b
-10000011b & 01000011b = 00000011b
-10000011b & 01000100b = 00000000b
-10000011b & 01000101b = 00000001b
-10000011b & 01000110b = 00000010b
-10000011b & 01000111b = 00000011b
-10000011b & 01001000b = 00000000b
-10000011b & 01001001b = 00000001b
-10000011b & 01001010b = 00000010b
-10000011b & 01001011b = 00000011b
-10000011b & 01001100b = 00000000b
-10000011b & 01001101b = 00000001b
-10000011b & 01001110b = 00000010b
-10000011b & 01001111b = 00000011b
-10000011b & 01010000b = 00000000b
-10000011b & 01010001b = 00000001b
-10000011b & 01010010b = 00000010b
-10000011b & 01010011b = 00000011b
-10000011b & 01010100b = 00000000b
-10000011b & 01010101b = 00000001b
-10000011b & 01010110b = 00000010b
-10000011b & 01010111b = 00000011b
-10000011b & 01011000b = 00000000b
-10000011b & 01011001b = 00000001b
-10000011b & 01011010b = 00000010b
-10000011b & 01011011b = 00000011b
-10000011b & 01011100b = 00000000b
-10000011b & 01011101b = 00000001b
-10000011b & 01011110b = 00000010b
-10000011b & 01011111b = 00000011b
-10000011b & 01100000b = 00000000b
-10000011b & 01100001b = 00000001b
-10000011b & 01100010b = 00000010b
-10000011b & 01100011b = 00000011b
-10000011b & 01100100b = 00000000b
-10000011b & 01100101b = 00000001b
-10000011b & 01100110b = 00000010b
-10000011b & 01100111b = 00000011b
-10000011b & 01101000b = 00000000b
-10000011b & 01101001b = 00000001b
-10000011b & 01101010b = 00000010b
-10000011b & 01101011b = 00000011b
-10000011b & 01101100b = 00000000b
-10000011b & 01101101b = 00000001b
-10000011b & 01101110b = 00000010b
-10000011b & 01101111b = 00000011b
-10000011b & 01110000b = 00000000b
-10000011b & 01110001b = 00000001b
-10000011b & 01110010b = 00000010b
-10000011b & 01110011b = 00000011b
-10000011b & 01110100b = 00000000b
-10000011b & 01110101b = 00000001b
-10000011b & 01110110b = 00000010b
-10000011b & 01110111b = 00000011b
-10000011b & 01111000b = 00000000b
-10000011b & 01111001b = 00000001b
-10000011b & 01111010b = 00000010b
-10000011b & 01111011b = 00000011b
-10000011b & 01111100b = 00000000b
-10000011b & 01111101b = 00000001b
-10000011b & 01111110b = 00000010b
-10000100b & 10000000b = 10000000b
-10000100b & 10000001b = 10000000b
-10000100b & 10000010b = 10000000b
-10000100b & 10000011b = 10000000b
-10000100b & 10000100b = 10000100b
-10000100b & 10000101b = 10000100b
-10000100b & 10000110b = 10000100b
-10000100b & 10000111b = 10000100b
-10000100b & 10001000b = 10000000b
-10000100b & 10001001b = 10000000b
-10000100b & 10001010b = 10000000b
-10000100b & 10001011b = 10000000b
-10000100b & 10001100b = 10000100b
-10000100b & 10001101b = 10000100b
-10000100b & 10001110b = 10000100b
-10000100b & 10001111b = 10000100b
-10000100b & 10010000b = 10000000b
-10000100b & 10010001b = 10000000b
-10000100b & 10010010b = 10000000b
-10000100b & 10010011b = 10000000b
-10000100b & 10010100b = 10000100b
-10000100b & 10010101b = 10000100b
-10000100b & 10010110b = 10000100b
-10000100b & 10010111b = 10000100b
-10000100b & 10011000b = 10000000b
-10000100b & 10011001b = 10000000b
-10000100b & 10011010b = 10000000b
-10000100b & 10011011b = 10000000b
-10000100b & 10011100b = 10000100b
-10000100b & 10011101b = 10000100b
-10000100b & 10011110b = 10000100b
-10000100b & 10011111b = 10000100b
-10000100b & 10100000b = 10000000b
-10000100b & 10100001b = 10000000b
-10000100b & 10100010b = 10000000b
-10000100b & 10100011b = 10000000b
-10000100b & 10100100b = 10000100b
-10000100b & 10100101b = 10000100b
-10000100b & 10100110b = 10000100b
-10000100b & 10100111b = 10000100b
-10000100b & 10101000b = 10000000b
-10000100b & 10101001b = 10000000b
-10000100b & 10101010b = 10000000b
-10000100b & 10101011b = 10000000b
-10000100b & 10101100b = 10000100b
-10000100b & 10101101b = 10000100b
-10000100b & 10101110b = 10000100b
-10000100b & 10101111b = 10000100b
-10000100b & 10110000b = 10000000b
-10000100b & 10110001b = 10000000b
-10000100b & 10110010b = 10000000b
-10000100b & 10110011b = 10000000b
-10000100b & 10110100b = 10000100b
-10000100b & 10110101b = 10000100b
-10000100b & 10110110b = 10000100b
-10000100b & 10110111b = 10000100b
-10000100b & 10111000b = 10000000b
-10000100b & 10111001b = 10000000b
-10000100b & 10111010b = 10000000b
-10000100b & 10111011b = 10000000b
-10000100b & 10111100b = 10000100b
-10000100b & 10111101b = 10000100b
-10000100b & 10111110b = 10000100b
-10000100b & 10111111b = 10000100b
-10000100b & 11000000b = 10000000b
-10000100b & 11000001b = 10000000b
-10000100b & 11000010b = 10000000b
-10000100b & 11000011b = 10000000b
-10000100b & 11000100b = 10000100b
-10000100b & 11000101b = 10000100b
-10000100b & 11000110b = 10000100b
-10000100b & 11000111b = 10000100b
-10000100b & 11001000b = 10000000b
-10000100b & 11001001b = 10000000b
-10000100b & 11001010b = 10000000b
-10000100b & 11001011b = 10000000b
-10000100b & 11001100b = 10000100b
-10000100b & 11001101b = 10000100b
-10000100b & 11001110b = 10000100b
-10000100b & 11001111b = 10000100b
-10000100b & 11010000b = 10000000b
-10000100b & 11010001b = 10000000b
-10000100b & 11010010b = 10000000b
-10000100b & 11010011b = 10000000b
-10000100b & 11010100b = 10000100b
-10000100b & 11010101b = 10000100b
-10000100b & 11010110b = 10000100b
-10000100b & 11010111b = 10000100b
-10000100b & 11011000b = 10000000b
-10000100b & 11011001b = 10000000b
-10000100b & 11011010b = 10000000b
-10000100b & 11011011b = 10000000b
-10000100b & 11011100b = 10000100b
-10000100b & 11011101b = 10000100b
-10000100b & 11011110b = 10000100b
-10000100b & 11011111b = 10000100b
-10000100b & 11100000b = 10000000b
-10000100b & 11100001b = 10000000b
-10000100b & 11100010b = 10000000b
-10000100b & 11100011b = 10000000b
-10000100b & 11100100b = 10000100b
-10000100b & 11100101b = 10000100b
-10000100b & 11100110b = 10000100b
-10000100b & 11100111b = 10000100b
-10000100b & 11101000b = 10000000b
-10000100b & 11101001b = 10000000b
-10000100b & 11101010b = 10000000b
-10000100b & 11101011b = 10000000b
-10000100b & 11101100b = 10000100b
-10000100b & 11101101b = 10000100b
-10000100b & 11101110b = 10000100b
-10000100b & 11101111b = 10000100b
-10000100b & 11110000b = 10000000b
-10000100b & 11110001b = 10000000b
-10000100b & 11110010b = 10000000b
-10000100b & 11110011b = 10000000b
-10000100b & 11110100b = 10000100b
-10000100b & 11110101b = 10000100b
-10000100b & 11110110b = 10000100b
-10000100b & 11110111b = 10000100b
-10000100b & 11111000b = 10000000b
-10000100b & 11111001b = 10000000b
-10000100b & 11111010b = 10000000b
-10000100b & 11111011b = 10000000b
-10000100b & 11111100b = 10000100b
-10000100b & 11111101b = 10000100b
-10000100b & 11111110b = 10000100b
-10000100b & 11111111b = 10000100b
-10000100b & 00000000b = 00000000b
-10000100b & 00000001b = 00000000b
-10000100b & 00000010b = 00000000b
-10000100b & 00000011b = 00000000b
-10000100b & 00000100b = 00000100b
-10000100b & 00000101b = 00000100b
-10000100b & 00000110b = 00000100b
-10000100b & 00000111b = 00000100b
-10000100b & 00001000b = 00000000b
-10000100b & 00001001b = 00000000b
-10000100b & 00001010b = 00000000b
-10000100b & 00001011b = 00000000b
-10000100b & 00001100b = 00000100b
-10000100b & 00001101b = 00000100b
-10000100b & 00001110b = 00000100b
-10000100b & 00001111b = 00000100b
-10000100b & 00010000b = 00000000b
-10000100b & 00010001b = 00000000b
-10000100b & 00010010b = 00000000b
-10000100b & 00010011b = 00000000b
-10000100b & 00010100b = 00000100b
-10000100b & 00010101b = 00000100b
-10000100b & 00010110b = 00000100b
-10000100b & 00010111b = 00000100b
-10000100b & 00011000b = 00000000b
-10000100b & 00011001b = 00000000b
-10000100b & 00011010b = 00000000b
-10000100b & 00011011b = 00000000b
-10000100b & 00011100b = 00000100b
-10000100b & 00011101b = 00000100b
-10000100b & 00011110b = 00000100b
-10000100b & 00011111b = 00000100b
-10000100b & 00100000b = 00000000b
-10000100b & 00100001b = 00000000b
-10000100b & 00100010b = 00000000b
-10000100b & 00100011b = 00000000b
-10000100b & 00100100b = 00000100b
-10000100b & 00100101b = 00000100b
-10000100b & 00100110b = 00000100b
-10000100b & 00100111b = 00000100b
-10000100b & 00101000b = 00000000b
-10000100b & 00101001b = 00000000b
-10000100b & 00101010b = 00000000b
-10000100b & 00101011b = 00000000b
-10000100b & 00101100b = 00000100b
-10000100b & 00101101b = 00000100b
-10000100b & 00101110b = 00000100b
-10000100b & 00101111b = 00000100b
-10000100b & 00110000b = 00000000b
-10000100b & 00110001b = 00000000b
-10000100b & 00110010b = 00000000b
-10000100b & 00110011b = 00000000b
-10000100b & 00110100b = 00000100b
-10000100b & 00110101b = 00000100b
-10000100b & 00110110b = 00000100b
-10000100b & 00110111b = 00000100b
-10000100b & 00111000b = 00000000b
-10000100b & 00111001b = 00000000b
-10000100b & 00111010b = 00000000b
-10000100b & 00111011b = 00000000b
-10000100b & 00111100b = 00000100b
-10000100b & 00111101b = 00000100b
-10000100b & 00111110b = 00000100b
-10000100b & 00111111b = 00000100b
-10000100b & 01000000b = 00000000b
-10000100b & 01000001b = 00000000b
-10000100b & 01000010b = 00000000b
-10000100b & 01000011b = 00000000b
-10000100b & 01000100b = 00000100b
-10000100b & 01000101b = 00000100b
-10000100b & 01000110b = 00000100b
-10000100b & 01000111b = 00000100b
-10000100b & 01001000b = 00000000b
-10000100b & 01001001b = 00000000b
-10000100b & 01001010b = 00000000b
-10000100b & 01001011b = 00000000b
-10000100b & 01001100b = 00000100b
-10000100b & 01001101b = 00000100b
-10000100b & 01001110b = 00000100b
-10000100b & 01001111b = 00000100b
-10000100b & 01010000b = 00000000b
-10000100b & 01010001b = 00000000b
-10000100b & 01010010b = 00000000b
-10000100b & 01010011b = 00000000b
-10000100b & 01010100b = 00000100b
-10000100b & 01010101b = 00000100b
-10000100b & 01010110b = 00000100b
-10000100b & 01010111b = 00000100b
-10000100b & 01011000b = 00000000b
-10000100b & 01011001b = 00000000b
-10000100b & 01011010b = 00000000b
-10000100b & 01011011b = 00000000b
-10000100b & 01011100b = 00000100b
-10000100b & 01011101b = 00000100b
-10000100b & 01011110b = 00000100b
-10000100b & 01011111b = 00000100b
-10000100b & 01100000b = 00000000b
-10000100b & 01100001b = 00000000b
-10000100b & 01100010b = 00000000b
-10000100b & 01100011b = 00000000b
-10000100b & 01100100b = 00000100b
-10000100b & 01100101b = 00000100b
-10000100b & 01100110b = 00000100b
-10000100b & 01100111b = 00000100b
-10000100b & 01101000b = 00000000b
-10000100b & 01101001b = 00000000b
-10000100b & 01101010b = 00000000b
-10000100b & 01101011b = 00000000b
-10000100b & 01101100b = 00000100b
-10000100b & 01101101b = 00000100b
-10000100b & 01101110b = 00000100b
-10000100b & 01101111b = 00000100b
-10000100b & 01110000b = 00000000b
-10000100b & 01110001b = 00000000b
-10000100b & 01110010b = 00000000b
-10000100b & 01110011b = 00000000b
-10000100b & 01110100b = 00000100b
-10000100b & 01110101b = 00000100b
-10000100b & 01110110b = 00000100b
-10000100b & 01110111b = 00000100b
-10000100b & 01111000b = 00000000b
-10000100b & 01111001b = 00000000b
-10000100b & 01111010b = 00000000b
-10000100b & 01111011b = 00000000b
-10000100b & 01111100b = 00000100b
-10000100b & 01111101b = 00000100b
-10000100b & 01111110b = 00000100b
-10000101b & 10000000b = 10000000b
-10000101b & 10000001b = 10000001b
-10000101b & 10000010b = 10000000b
-10000101b & 10000011b = 10000001b
-10000101b & 10000100b = 10000100b
-10000101b & 10000101b = 10000101b
-10000101b & 10000110b = 10000100b
-10000101b & 10000111b = 10000101b
-10000101b & 10001000b = 10000000b
-10000101b & 10001001b = 10000001b
-10000101b & 10001010b = 10000000b
-10000101b & 10001011b = 10000001b
-10000101b & 10001100b = 10000100b
-10000101b & 10001101b = 10000101b
-10000101b & 10001110b = 10000100b
-10000101b & 10001111b = 10000101b
-10000101b & 10010000b = 10000000b
-10000101b & 10010001b = 10000001b
-10000101b & 10010010b = 10000000b
-10000101b & 10010011b = 10000001b
-10000101b & 10010100b = 10000100b
-10000101b & 10010101b = 10000101b
-10000101b & 10010110b = 10000100b
-10000101b & 10010111b = 10000101b
-10000101b & 10011000b = 10000000b
-10000101b & 10011001b = 10000001b
-10000101b & 10011010b = 10000000b
-10000101b & 10011011b = 10000001b
-10000101b & 10011100b = 10000100b
-10000101b & 10011101b = 10000101b
-10000101b & 10011110b = 10000100b
-10000101b & 10011111b = 10000101b
-10000101b & 10100000b = 10000000b
-10000101b & 10100001b = 10000001b
-10000101b & 10100010b = 10000000b
-10000101b & 10100011b = 10000001b
-10000101b & 10100100b = 10000100b
-10000101b & 10100101b = 10000101b
-10000101b & 10100110b = 10000100b
-10000101b & 10100111b = 10000101b
-10000101b & 10101000b = 10000000b
-10000101b & 10101001b = 10000001b
-10000101b & 10101010b = 10000000b
-10000101b & 10101011b = 10000001b
-10000101b & 10101100b = 10000100b
-10000101b & 10101101b = 10000101b
-10000101b & 10101110b = 10000100b
-10000101b & 10101111b = 10000101b
-10000101b & 10110000b = 10000000b
-10000101b & 10110001b = 10000001b
-10000101b & 10110010b = 10000000b
-10000101b & 10110011b = 10000001b
-10000101b & 10110100b = 10000100b
-10000101b & 10110101b = 10000101b
-10000101b & 10110110b = 10000100b
-10000101b & 10110111b = 10000101b
-10000101b & 10111000b = 10000000b
-10000101b & 10111001b = 10000001b
-10000101b & 10111010b = 10000000b
-10000101b & 10111011b = 10000001b
-10000101b & 10111100b = 10000100b
-10000101b & 10111101b = 10000101b
-10000101b & 10111110b = 10000100b
-10000101b & 10111111b = 10000101b
-10000101b & 11000000b = 10000000b
-10000101b & 11000001b = 10000001b
-10000101b & 11000010b = 10000000b
-10000101b & 11000011b = 10000001b
-10000101b & 11000100b = 10000100b
-10000101b & 11000101b = 10000101b
-10000101b & 11000110b = 10000100b
-10000101b & 11000111b = 10000101b
-10000101b & 11001000b = 10000000b
-10000101b & 11001001b = 10000001b
-10000101b & 11001010b = 10000000b
-10000101b & 11001011b = 10000001b
-10000101b & 11001100b = 10000100b
-10000101b & 11001101b = 10000101b
-10000101b & 11001110b = 10000100b
-10000101b & 11001111b = 10000101b
-10000101b & 11010000b = 10000000b
-10000101b & 11010001b = 10000001b
-10000101b & 11010010b = 10000000b
-10000101b & 11010011b = 10000001b
-10000101b & 11010100b = 10000100b
-10000101b & 11010101b = 10000101b
-10000101b & 11010110b = 10000100b
-10000101b & 11010111b = 10000101b
-10000101b & 11011000b = 10000000b
-10000101b & 11011001b = 10000001b
-10000101b & 11011010b = 10000000b
-10000101b & 11011011b = 10000001b
-10000101b & 11011100b = 10000100b
-10000101b & 11011101b = 10000101b
-10000101b & 11011110b = 10000100b
-10000101b & 11011111b = 10000101b
-10000101b & 11100000b = 10000000b
-10000101b & 11100001b = 10000001b
-10000101b & 11100010b = 10000000b
-10000101b & 11100011b = 10000001b
-10000101b & 11100100b = 10000100b
-10000101b & 11100101b = 10000101b
-10000101b & 11100110b = 10000100b
-10000101b & 11100111b = 10000101b
-10000101b & 11101000b = 10000000b
-10000101b & 11101001b = 10000001b
-10000101b & 11101010b = 10000000b
-10000101b & 11101011b = 10000001b
-10000101b & 11101100b = 10000100b
-10000101b & 11101101b = 10000101b
-10000101b & 11101110b = 10000100b
-10000101b & 11101111b = 10000101b
-10000101b & 11110000b = 10000000b
-10000101b & 11110001b = 10000001b
-10000101b & 11110010b = 10000000b
-10000101b & 11110011b = 10000001b
-10000101b & 11110100b = 10000100b
-10000101b & 11110101b = 10000101b
-10000101b & 11110110b = 10000100b
-10000101b & 11110111b = 10000101b
-10000101b & 11111000b = 10000000b
-10000101b & 11111001b = 10000001b
-10000101b & 11111010b = 10000000b
-10000101b & 11111011b = 10000001b
-10000101b & 11111100b = 10000100b
-10000101b & 11111101b = 10000101b
-10000101b & 11111110b = 10000100b
-10000101b & 11111111b = 10000101b
-10000101b & 00000000b = 00000000b
-10000101b & 00000001b = 00000001b
-10000101b & 00000010b = 00000000b
-10000101b & 00000011b = 00000001b
-10000101b & 00000100b = 00000100b
-10000101b & 00000101b = 00000101b
-10000101b & 00000110b = 00000100b
-10000101b & 00000111b = 00000101b
-10000101b & 00001000b = 00000000b
-10000101b & 00001001b = 00000001b
-10000101b & 00001010b = 00000000b
-10000101b & 00001011b = 00000001b
-10000101b & 00001100b = 00000100b
-10000101b & 00001101b = 00000101b
-10000101b & 00001110b = 00000100b
-10000101b & 00001111b = 00000101b
-10000101b & 00010000b = 00000000b
-10000101b & 00010001b = 00000001b
-10000101b & 00010010b = 00000000b
-10000101b & 00010011b = 00000001b
-10000101b & 00010100b = 00000100b
-10000101b & 00010101b = 00000101b
-10000101b & 00010110b = 00000100b
-10000101b & 00010111b = 00000101b
-10000101b & 00011000b = 00000000b
-10000101b & 00011001b = 00000001b
-10000101b & 00011010b = 00000000b
-10000101b & 00011011b = 00000001b
-10000101b & 00011100b = 00000100b
-10000101b & 00011101b = 00000101b
-10000101b & 00011110b = 00000100b
-10000101b & 00011111b = 00000101b
-10000101b & 00100000b = 00000000b
-10000101b & 00100001b = 00000001b
-10000101b & 00100010b = 00000000b
-10000101b & 00100011b = 00000001b
-10000101b & 00100100b = 00000100b
-10000101b & 00100101b = 00000101b
-10000101b & 00100110b = 00000100b
-10000101b & 00100111b = 00000101b
-10000101b & 00101000b = 00000000b
-10000101b & 00101001b = 00000001b
-10000101b & 00101010b = 00000000b
-10000101b & 00101011b = 00000001b
-10000101b & 00101100b = 00000100b
-10000101b & 00101101b = 00000101b
-10000101b & 00101110b = 00000100b
-10000101b & 00101111b = 00000101b
-10000101b & 00110000b = 00000000b
-10000101b & 00110001b = 00000001b
-10000101b & 00110010b = 00000000b
-10000101b & 00110011b = 00000001b
-10000101b & 00110100b = 00000100b
-10000101b & 00110101b = 00000101b
-10000101b & 00110110b = 00000100b
-10000101b & 00110111b = 00000101b
-10000101b & 00111000b = 00000000b
-10000101b & 00111001b = 00000001b
-10000101b & 00111010b = 00000000b
-10000101b & 00111011b = 00000001b
-10000101b & 00111100b = 00000100b
-10000101b & 00111101b = 00000101b
-10000101b & 00111110b = 00000100b
-10000101b & 00111111b = 00000101b
-10000101b & 01000000b = 00000000b
-10000101b & 01000001b = 00000001b
-10000101b & 01000010b = 00000000b
-10000101b & 01000011b = 00000001b
-10000101b & 01000100b = 00000100b
-10000101b & 01000101b = 00000101b
-10000101b & 01000110b = 00000100b
-10000101b & 01000111b = 00000101b
-10000101b & 01001000b = 00000000b
-10000101b & 01001001b = 00000001b
-10000101b & 01001010b = 00000000b
-10000101b & 01001011b = 00000001b
-10000101b & 01001100b = 00000100b
-10000101b & 01001101b = 00000101b
-10000101b & 01001110b = 00000100b
-10000101b & 01001111b = 00000101b
-10000101b & 01010000b = 00000000b
-10000101b & 01010001b = 00000001b
-10000101b & 01010010b = 00000000b
-10000101b & 01010011b = 00000001b
-10000101b & 01010100b = 00000100b
-10000101b & 01010101b = 00000101b
-10000101b & 01010110b = 00000100b
-10000101b & 01010111b = 00000101b
-10000101b & 01011000b = 00000000b
-10000101b & 01011001b = 00000001b
-10000101b & 01011010b = 00000000b
-10000101b & 01011011b = 00000001b
-10000101b & 01011100b = 00000100b
-10000101b & 01011101b = 00000101b
-10000101b & 01011110b = 00000100b
-10000101b & 01011111b = 00000101b
-10000101b & 01100000b = 00000000b
-10000101b & 01100001b = 00000001b
-10000101b & 01100010b = 00000000b
-10000101b & 01100011b = 00000001b
-10000101b & 01100100b = 00000100b
-10000101b & 01100101b = 00000101b
-10000101b & 01100110b = 00000100b
-10000101b & 01100111b = 00000101b
-10000101b & 01101000b = 00000000b
-10000101b & 01101001b = 00000001b
-10000101b & 01101010b = 00000000b
-10000101b & 01101011b = 00000001b
-10000101b & 01101100b = 00000100b
-10000101b & 01101101b = 00000101b
-10000101b & 01101110b = 00000100b
-10000101b & 01101111b = 00000101b
-10000101b & 01110000b = 00000000b
-10000101b & 01110001b = 00000001b
-10000101b & 01110010b = 00000000b
-10000101b & 01110011b = 00000001b
-10000101b & 01110100b = 00000100b
-10000101b & 01110101b = 00000101b
-10000101b & 01110110b = 00000100b
-10000101b & 01110111b = 00000101b
-10000101b & 01111000b = 00000000b
-10000101b & 01111001b = 00000001b
-10000101b & 01111010b = 00000000b
-10000101b & 01111011b = 00000001b
-10000101b & 01111100b = 00000100b
-10000101b & 01111101b = 00000101b
-10000101b & 01111110b = 00000100b
-10000110b & 10000000b = 10000000b
-10000110b & 10000001b = 10000000b
-10000110b & 10000010b = 10000010b
-10000110b & 10000011b = 10000010b
-10000110b & 10000100b = 10000100b
-10000110b & 10000101b = 10000100b
-10000110b & 10000110b = 10000110b
-10000110b & 10000111b = 10000110b
-10000110b & 10001000b = 10000000b
-10000110b & 10001001b = 10000000b
-10000110b & 10001010b = 10000010b
-10000110b & 10001011b = 10000010b
-10000110b & 10001100b = 10000100b
-10000110b & 10001101b = 10000100b
-10000110b & 10001110b = 10000110b
-10000110b & 10001111b = 10000110b
-10000110b & 10010000b = 10000000b
-10000110b & 10010001b = 10000000b
-10000110b & 10010010b = 10000010b
-10000110b & 10010011b = 10000010b
-10000110b & 10010100b = 10000100b
-10000110b & 10010101b = 10000100b
-10000110b & 10010110b = 10000110b
-10000110b & 10010111b = 10000110b
-10000110b & 10011000b = 10000000b
-10000110b & 10011001b = 10000000b
-10000110b & 10011010b = 10000010b
-10000110b & 10011011b = 10000010b
-10000110b & 10011100b = 10000100b
-10000110b & 10011101b = 10000100b
-10000110b & 10011110b = 10000110b
-10000110b & 10011111b = 10000110b
-10000110b & 10100000b = 10000000b
-10000110b & 10100001b = 10000000b
-10000110b & 10100010b = 10000010b
-10000110b & 10100011b = 10000010b
-10000110b & 10100100b = 10000100b
-10000110b & 10100101b = 10000100b
-10000110b & 10100110b = 10000110b
-10000110b & 10100111b = 10000110b
-10000110b & 10101000b = 10000000b
-10000110b & 10101001b = 10000000b
-10000110b & 10101010b = 10000010b
-10000110b & 10101011b = 10000010b
-10000110b & 10101100b = 10000100b
-10000110b & 10101101b = 10000100b
-10000110b & 10101110b = 10000110b
-10000110b & 10101111b = 10000110b
-10000110b & 10110000b = 10000000b
-10000110b & 10110001b = 10000000b
-10000110b & 10110010b = 10000010b
-10000110b & 10110011b = 10000010b
-10000110b & 10110100b = 10000100b
-10000110b & 10110101b = 10000100b
-10000110b & 10110110b = 10000110b
-10000110b & 10110111b = 10000110b
-10000110b & 10111000b = 10000000b
-10000110b & 10111001b = 10000000b
-10000110b & 10111010b = 10000010b
-10000110b & 10111011b = 10000010b
-10000110b & 10111100b = 10000100b
-10000110b & 10111101b = 10000100b
-10000110b & 10111110b = 10000110b
-10000110b & 10111111b = 10000110b
-10000110b & 11000000b = 10000000b
-10000110b & 11000001b = 10000000b
-10000110b & 11000010b = 10000010b
-10000110b & 11000011b = 10000010b
-10000110b & 11000100b = 10000100b
-10000110b & 11000101b = 10000100b
-10000110b & 11000110b = 10000110b
-10000110b & 11000111b = 10000110b
-10000110b & 11001000b = 10000000b
-10000110b & 11001001b = 10000000b
-10000110b & 11001010b = 10000010b
-10000110b & 11001011b = 10000010b
-10000110b & 11001100b = 10000100b
-10000110b & 11001101b = 10000100b
-10000110b & 11001110b = 10000110b
-10000110b & 11001111b = 10000110b
-10000110b & 11010000b = 10000000b
-10000110b & 11010001b = 10000000b
-10000110b & 11010010b = 10000010b
-10000110b & 11010011b = 10000010b
-10000110b & 11010100b = 10000100b
-10000110b & 11010101b = 10000100b
-10000110b & 11010110b = 10000110b
-10000110b & 11010111b = 10000110b
-10000110b & 11011000b = 10000000b
-10000110b & 11011001b = 10000000b
-10000110b & 11011010b = 10000010b
-10000110b & 11011011b = 10000010b
-10000110b & 11011100b = 10000100b
-10000110b & 11011101b = 10000100b
-10000110b & 11011110b = 10000110b
-10000110b & 11011111b = 10000110b
-10000110b & 11100000b = 10000000b
-10000110b & 11100001b = 10000000b
-10000110b & 11100010b = 10000010b
-10000110b & 11100011b = 10000010b
-10000110b & 11100100b = 10000100b
-10000110b & 11100101b = 10000100b
-10000110b & 11100110b = 10000110b
-10000110b & 11100111b = 10000110b
-10000110b & 11101000b = 10000000b
-10000110b & 11101001b = 10000000b
-10000110b & 11101010b = 10000010b
-10000110b & 11101011b = 10000010b
-10000110b & 11101100b = 10000100b
-10000110b & 11101101b = 10000100b
-10000110b & 11101110b = 10000110b
-10000110b & 11101111b = 10000110b
-10000110b & 11110000b = 10000000b
-10000110b & 11110001b = 10000000b
-10000110b & 11110010b = 10000010b
-10000110b & 11110011b = 10000010b
-10000110b & 11110100b = 10000100b
-10000110b & 11110101b = 10000100b
-10000110b & 11110110b = 10000110b
-10000110b & 11110111b = 10000110b
-10000110b & 11111000b = 10000000b
-10000110b & 11111001b = 10000000b
-10000110b & 11111010b = 10000010b
-10000110b & 11111011b = 10000010b
-10000110b & 11111100b = 10000100b
-10000110b & 11111101b = 10000100b
-10000110b & 11111110b = 10000110b
-10000110b & 11111111b = 10000110b
-10000110b & 00000000b = 00000000b
-10000110b & 00000001b = 00000000b
-10000110b & 00000010b = 00000010b
-10000110b & 00000011b = 00000010b
-10000110b & 00000100b = 00000100b
-10000110b & 00000101b = 00000100b
-10000110b & 00000110b = 00000110b
-10000110b & 00000111b = 00000110b
-10000110b & 00001000b = 00000000b
-10000110b & 00001001b = 00000000b
-10000110b & 00001010b = 00000010b
-10000110b & 00001011b = 00000010b
-10000110b & 00001100b = 00000100b
-10000110b & 00001101b = 00000100b
-10000110b & 00001110b = 00000110b
-10000110b & 00001111b = 00000110b
-10000110b & 00010000b = 00000000b
-10000110b & 00010001b = 00000000b
-10000110b & 00010010b = 00000010b
-10000110b & 00010011b = 00000010b
-10000110b & 00010100b = 00000100b
-10000110b & 00010101b = 00000100b
-10000110b & 00010110b = 00000110b
-10000110b & 00010111b = 00000110b
-10000110b & 00011000b = 00000000b
-10000110b & 00011001b = 00000000b
-10000110b & 00011010b = 00000010b
-10000110b & 00011011b = 00000010b
-10000110b & 00011100b = 00000100b
-10000110b & 00011101b = 00000100b
-10000110b & 00011110b = 00000110b
-10000110b & 00011111b = 00000110b
-10000110b & 00100000b = 00000000b
-10000110b & 00100001b = 00000000b
-10000110b & 00100010b = 00000010b
-10000110b & 00100011b = 00000010b
-10000110b & 00100100b = 00000100b
-10000110b & 00100101b = 00000100b
-10000110b & 00100110b = 00000110b
-10000110b & 00100111b = 00000110b
-10000110b & 00101000b = 00000000b
-10000110b & 00101001b = 00000000b
-10000110b & 00101010b = 00000010b
-10000110b & 00101011b = 00000010b
-10000110b & 00101100b = 00000100b
-10000110b & 00101101b = 00000100b
-10000110b & 00101110b = 00000110b
-10000110b & 00101111b = 00000110b
-10000110b & 00110000b = 00000000b
-10000110b & 00110001b = 00000000b
-10000110b & 00110010b = 00000010b
-10000110b & 00110011b = 00000010b
-10000110b & 00110100b = 00000100b
-10000110b & 00110101b = 00000100b
-10000110b & 00110110b = 00000110b
-10000110b & 00110111b = 00000110b
-10000110b & 00111000b = 00000000b
-10000110b & 00111001b = 00000000b
-10000110b & 00111010b = 00000010b
-10000110b & 00111011b = 00000010b
-10000110b & 00111100b = 00000100b
-10000110b & 00111101b = 00000100b
-10000110b & 00111110b = 00000110b
-10000110b & 00111111b = 00000110b
-10000110b & 01000000b = 00000000b
-10000110b & 01000001b = 00000000b
-10000110b & 01000010b = 00000010b
-10000110b & 01000011b = 00000010b
-10000110b & 01000100b = 00000100b
-10000110b & 01000101b = 00000100b
-10000110b & 01000110b = 00000110b
-10000110b & 01000111b = 00000110b
-10000110b & 01001000b = 00000000b
-10000110b & 01001001b = 00000000b
-10000110b & 01001010b = 00000010b
-10000110b & 01001011b = 00000010b
-10000110b & 01001100b = 00000100b
-10000110b & 01001101b = 00000100b
-10000110b & 01001110b = 00000110b
-10000110b & 01001111b = 00000110b
-10000110b & 01010000b = 00000000b
-10000110b & 01010001b = 00000000b
-10000110b & 01010010b = 00000010b
-10000110b & 01010011b = 00000010b
-10000110b & 01010100b = 00000100b
-10000110b & 01010101b = 00000100b
-10000110b & 01010110b = 00000110b
-10000110b & 01010111b = 00000110b
-10000110b & 01011000b = 00000000b
-10000110b & 01011001b = 00000000b
-10000110b & 01011010b = 00000010b
-10000110b & 01011011b = 00000010b
-10000110b & 01011100b = 00000100b
-10000110b & 01011101b = 00000100b
-10000110b & 01011110b = 00000110b
-10000110b & 01011111b = 00000110b
-10000110b & 01100000b = 00000000b
-10000110b & 01100001b = 00000000b
-10000110b & 01100010b = 00000010b
-10000110b & 01100011b = 00000010b
-10000110b & 01100100b = 00000100b
-10000110b & 01100101b = 00000100b
-10000110b & 01100110b = 00000110b
-10000110b & 01100111b = 00000110b
-10000110b & 01101000b = 00000000b
-10000110b & 01101001b = 00000000b
-10000110b & 01101010b = 00000010b
-10000110b & 01101011b = 00000010b
-10000110b & 01101100b = 00000100b
-10000110b & 01101101b = 00000100b
-10000110b & 01101110b = 00000110b
-10000110b & 01101111b = 00000110b
-10000110b & 01110000b = 00000000b
-10000110b & 01110001b = 00000000b
-10000110b & 01110010b = 00000010b
-10000110b & 01110011b = 00000010b
-10000110b & 01110100b = 00000100b
-10000110b & 01110101b = 00000100b
-10000110b & 01110110b = 00000110b
-10000110b & 01110111b = 00000110b
-10000110b & 01111000b = 00000000b
-10000110b & 01111001b = 00000000b
-10000110b & 01111010b = 00000010b
-10000110b & 01111011b = 00000010b
-10000110b & 01111100b = 00000100b
-10000110b & 01111101b = 00000100b
-10000110b & 01111110b = 00000110b
-10000111b & 10000000b = 10000000b
-10000111b & 10000001b = 10000001b
-10000111b & 10000010b = 10000010b
-10000111b & 10000011b = 10000011b
-10000111b & 10000100b = 10000100b
-10000111b & 10000101b = 10000101b
-10000111b & 10000110b = 10000110b
-10000111b & 10000111b = 10000111b
-10000111b & 10001000b = 10000000b
-10000111b & 10001001b = 10000001b
-10000111b & 10001010b = 10000010b
-10000111b & 10001011b = 10000011b
-10000111b & 10001100b = 10000100b
-10000111b & 10001101b = 10000101b
-10000111b & 10001110b = 10000110b
-10000111b & 10001111b = 10000111b
-10000111b & 10010000b = 10000000b
-10000111b & 10010001b = 10000001b
-10000111b & 10010010b = 10000010b
-10000111b & 10010011b = 10000011b
-10000111b & 10010100b = 10000100b
-10000111b & 10010101b = 10000101b
-10000111b & 10010110b = 10000110b
-10000111b & 10010111b = 10000111b
-10000111b & 10011000b = 10000000b
-10000111b & 10011001b = 10000001b
-10000111b & 10011010b = 10000010b
-10000111b & 10011011b = 10000011b
-10000111b & 10011100b = 10000100b
-10000111b & 10011101b = 10000101b
-10000111b & 10011110b = 10000110b
-10000111b & 10011111b = 10000111b
-10000111b & 10100000b = 10000000b
-10000111b & 10100001b = 10000001b
-10000111b & 10100010b = 10000010b
-10000111b & 10100011b = 10000011b
-10000111b & 10100100b = 10000100b
-10000111b & 10100101b = 10000101b
-10000111b & 10100110b = 10000110b
-10000111b & 10100111b = 10000111b
-10000111b & 10101000b = 10000000b
-10000111b & 10101001b = 10000001b
-10000111b & 10101010b = 10000010b
-10000111b & 10101011b = 10000011b
-10000111b & 10101100b = 10000100b
-10000111b & 10101101b = 10000101b
-10000111b & 10101110b = 10000110b
-10000111b & 10101111b = 10000111b
-10000111b & 10110000b = 10000000b
-10000111b & 10110001b = 10000001b
-10000111b & 10110010b = 10000010b
-10000111b & 10110011b = 10000011b
-10000111b & 10110100b = 10000100b
-10000111b & 10110101b = 10000101b
-10000111b & 10110110b = 10000110b
-10000111b & 10110111b = 10000111b
-10000111b & 10111000b = 10000000b
-10000111b & 10111001b = 10000001b
-10000111b & 10111010b = 10000010b
-10000111b & 10111011b = 10000011b
-10000111b & 10111100b = 10000100b
-10000111b & 10111101b = 10000101b
-10000111b & 10111110b = 10000110b
-10000111b & 10111111b = 10000111b
-10000111b & 11000000b = 10000000b
-10000111b & 11000001b = 10000001b
-10000111b & 11000010b = 10000010b
-10000111b & 11000011b = 10000011b
-10000111b & 11000100b = 10000100b
-10000111b & 11000101b = 10000101b
-10000111b & 11000110b = 10000110b
-10000111b & 11000111b = 10000111b
-10000111b & 11001000b = 10000000b
-10000111b & 11001001b = 10000001b
-10000111b & 11001010b = 10000010b
-10000111b & 11001011b = 10000011b
-10000111b & 11001100b = 10000100b
-10000111b & 11001101b = 10000101b
-10000111b & 11001110b = 10000110b
-10000111b & 11001111b = 10000111b
-10000111b & 11010000b = 10000000b
-10000111b & 11010001b = 10000001b
-10000111b & 11010010b = 10000010b
-10000111b & 11010011b = 10000011b
-10000111b & 11010100b = 10000100b
-10000111b & 11010101b = 10000101b
-10000111b & 11010110b = 10000110b
-10000111b & 11010111b = 10000111b
-10000111b & 11011000b = 10000000b
-10000111b & 11011001b = 10000001b
-10000111b & 11011010b = 10000010b
-10000111b & 11011011b = 10000011b
-10000111b & 11011100b = 10000100b
-10000111b & 11011101b = 10000101b
-10000111b & 11011110b = 10000110b
-10000111b & 11011111b = 10000111b
-10000111b & 11100000b = 10000000b
-10000111b & 11100001b = 10000001b
-10000111b & 11100010b = 10000010b
-10000111b & 11100011b = 10000011b
-10000111b & 11100100b = 10000100b
-10000111b & 11100101b = 10000101b
-10000111b & 11100110b = 10000110b
-10000111b & 11100111b = 10000111b
-10000111b & 11101000b = 10000000b
-10000111b & 11101001b = 10000001b
-10000111b & 11101010b = 10000010b
-10000111b & 11101011b = 10000011b
-10000111b & 11101100b = 10000100b
-10000111b & 11101101b = 10000101b
-10000111b & 11101110b = 10000110b
-10000111b & 11101111b = 10000111b
-10000111b & 11110000b = 10000000b
-10000111b & 11110001b = 10000001b
-10000111b & 11110010b = 10000010b
-10000111b & 11110011b = 10000011b
-10000111b & 11110100b = 10000100b
-10000111b & 11110101b = 10000101b
-10000111b & 11110110b = 10000110b
-10000111b & 11110111b = 10000111b
-10000111b & 11111000b = 10000000b
-10000111b & 11111001b = 10000001b
-10000111b & 11111010b = 10000010b
-10000111b & 11111011b = 10000011b
-10000111b & 11111100b = 10000100b
-10000111b & 11111101b = 10000101b
-10000111b & 11111110b = 10000110b
-10000111b & 11111111b = 10000111b
-10000111b & 00000000b = 00000000b
-10000111b & 00000001b = 00000001b
-10000111b & 00000010b = 00000010b
-10000111b & 00000011b = 00000011b
-10000111b & 00000100b = 00000100b
-10000111b & 00000101b = 00000101b
-10000111b & 00000110b = 00000110b
-10000111b & 00000111b = 00000111b
-10000111b & 00001000b = 00000000b
-10000111b & 00001001b = 00000001b
-10000111b & 00001010b = 00000010b
-10000111b & 00001011b = 00000011b
-10000111b & 00001100b = 00000100b
-10000111b & 00001101b = 00000101b
-10000111b & 00001110b = 00000110b
-10000111b & 00001111b = 00000111b
-10000111b & 00010000b = 00000000b
-10000111b & 00010001b = 00000001b
-10000111b & 00010010b = 00000010b
-10000111b & 00010011b = 00000011b
-10000111b & 00010100b = 00000100b
-10000111b & 00010101b = 00000101b
-10000111b & 00010110b = 00000110b
-10000111b & 00010111b = 00000111b
-10000111b & 00011000b = 00000000b
-10000111b & 00011001b = 00000001b
-10000111b & 00011010b = 00000010b
-10000111b & 00011011b = 00000011b
-10000111b & 00011100b = 00000100b
-10000111b & 00011101b = 00000101b
-10000111b & 00011110b = 00000110b
-10000111b & 00011111b = 00000111b
-10000111b & 00100000b = 00000000b
-10000111b & 00100001b = 00000001b
-10000111b & 00100010b = 00000010b
-10000111b & 00100011b = 00000011b
-10000111b & 00100100b = 00000100b
-10000111b & 00100101b = 00000101b
-10000111b & 00100110b = 00000110b
-10000111b & 00100111b = 00000111b
-10000111b & 00101000b = 00000000b
-10000111b & 00101001b = 00000001b
-10000111b & 00101010b = 00000010b
-10000111b & 00101011b = 00000011b
-10000111b & 00101100b = 00000100b
-10000111b & 00101101b = 00000101b
-10000111b & 00101110b = 00000110b
-10000111b & 00101111b = 00000111b
-10000111b & 00110000b = 00000000b
-10000111b & 00110001b = 00000001b
-10000111b & 00110010b = 00000010b
-10000111b & 00110011b = 00000011b
-10000111b & 00110100b = 00000100b
-10000111b & 00110101b = 00000101b
-10000111b & 00110110b = 00000110b
-10000111b & 00110111b = 00000111b
-10000111b & 00111000b = 00000000b
-10000111b & 00111001b = 00000001b
-10000111b & 00111010b = 00000010b
-10000111b & 00111011b = 00000011b
-10000111b & 00111100b = 00000100b
-10000111b & 00111101b = 00000101b
-10000111b & 00111110b = 00000110b
-10000111b & 00111111b = 00000111b
-10000111b & 01000000b = 00000000b
-10000111b & 01000001b = 00000001b
-10000111b & 01000010b = 00000010b
-10000111b & 01000011b = 00000011b
-10000111b & 01000100b = 00000100b
-10000111b & 01000101b = 00000101b
-10000111b & 01000110b = 00000110b
-10000111b & 01000111b = 00000111b
-10000111b & 01001000b = 00000000b
-10000111b & 01001001b = 00000001b
-10000111b & 01001010b = 00000010b
-10000111b & 01001011b = 00000011b
-10000111b & 01001100b = 00000100b
-10000111b & 01001101b = 00000101b
-10000111b & 01001110b = 00000110b
-10000111b & 01001111b = 00000111b
-10000111b & 01010000b = 00000000b
-10000111b & 01010001b = 00000001b
-10000111b & 01010010b = 00000010b
-10000111b & 01010011b = 00000011b
-10000111b & 01010100b = 00000100b
-10000111b & 01010101b = 00000101b
-10000111b & 01010110b = 00000110b
-10000111b & 01010111b = 00000111b
-10000111b & 01011000b = 00000000b
-10000111b & 01011001b = 00000001b
-10000111b & 01011010b = 00000010b
-10000111b & 01011011b = 00000011b
-10000111b & 01011100b = 00000100b
-10000111b & 01011101b = 00000101b
-10000111b & 01011110b = 00000110b
-10000111b & 01011111b = 00000111b
-10000111b & 01100000b = 00000000b
-10000111b & 01100001b = 00000001b
-10000111b & 01100010b = 00000010b
-10000111b & 01100011b = 00000011b
-10000111b & 01100100b = 00000100b
-10000111b & 01100101b = 00000101b
-10000111b & 01100110b = 00000110b
-10000111b & 01100111b = 00000111b
-10000111b & 01101000b = 00000000b
-10000111b & 01101001b = 00000001b
-10000111b & 01101010b = 00000010b
-10000111b & 01101011b = 00000011b
-10000111b & 01101100b = 00000100b
-10000111b & 01101101b = 00000101b
-10000111b & 01101110b = 00000110b
-10000111b & 01101111b = 00000111b
-10000111b & 01110000b = 00000000b
-10000111b & 01110001b = 00000001b
-10000111b & 01110010b = 00000010b
-10000111b & 01110011b = 00000011b
-10000111b & 01110100b = 00000100b
-10000111b & 01110101b = 00000101b
-10000111b & 01110110b = 00000110b
-10000111b & 01110111b = 00000111b
-10000111b & 01111000b = 00000000b
-10000111b & 01111001b = 00000001b
-10000111b & 01111010b = 00000010b
-10000111b & 01111011b = 00000011b
-10000111b & 01111100b = 00000100b
-10000111b & 01111101b = 00000101b
-10000111b & 01111110b = 00000110b
-10001000b & 10000000b = 10000000b
-10001000b & 10000001b = 10000000b
-10001000b & 10000010b = 10000000b
-10001000b & 10000011b = 10000000b
-10001000b & 10000100b = 10000000b
-10001000b & 10000101b = 10000000b
-10001000b & 10000110b = 10000000b
-10001000b & 10000111b = 10000000b
-10001000b & 10001000b = 10001000b
-10001000b & 10001001b = 10001000b
-10001000b & 10001010b = 10001000b
-10001000b & 10001011b = 10001000b
-10001000b & 10001100b = 10001000b
-10001000b & 10001101b = 10001000b
-10001000b & 10001110b = 10001000b
-10001000b & 10001111b = 10001000b
-10001000b & 10010000b = 10000000b
-10001000b & 10010001b = 10000000b
-10001000b & 10010010b = 10000000b
-10001000b & 10010011b = 10000000b
-10001000b & 10010100b = 10000000b
-10001000b & 10010101b = 10000000b
-10001000b & 10010110b = 10000000b
-10001000b & 10010111b = 10000000b
-10001000b & 10011000b = 10001000b
-10001000b & 10011001b = 10001000b
-10001000b & 10011010b = 10001000b
-10001000b & 10011011b = 10001000b
-10001000b & 10011100b = 10001000b
-10001000b & 10011101b = 10001000b
-10001000b & 10011110b = 10001000b
-10001000b & 10011111b = 10001000b
-10001000b & 10100000b = 10000000b
-10001000b & 10100001b = 10000000b
-10001000b & 10100010b = 10000000b
-10001000b & 10100011b = 10000000b
-10001000b & 10100100b = 10000000b
-10001000b & 10100101b = 10000000b
-10001000b & 10100110b = 10000000b
-10001000b & 10100111b = 10000000b
-10001000b & 10101000b = 10001000b
-10001000b & 10101001b = 10001000b
-10001000b & 10101010b = 10001000b
-10001000b & 10101011b = 10001000b
-10001000b & 10101100b = 10001000b
-10001000b & 10101101b = 10001000b
-10001000b & 10101110b = 10001000b
-10001000b & 10101111b = 10001000b
-10001000b & 10110000b = 10000000b
-10001000b & 10110001b = 10000000b
-10001000b & 10110010b = 10000000b
-10001000b & 10110011b = 10000000b
-10001000b & 10110100b = 10000000b
-10001000b & 10110101b = 10000000b
-10001000b & 10110110b = 10000000b
-10001000b & 10110111b = 10000000b
-10001000b & 10111000b = 10001000b
-10001000b & 10111001b = 10001000b
-10001000b & 10111010b = 10001000b
-10001000b & 10111011b = 10001000b
-10001000b & 10111100b = 10001000b
-10001000b & 10111101b = 10001000b
-10001000b & 10111110b = 10001000b
-10001000b & 10111111b = 10001000b
-10001000b & 11000000b = 10000000b
-10001000b & 11000001b = 10000000b
-10001000b & 11000010b = 10000000b
-10001000b & 11000011b = 10000000b
-10001000b & 11000100b = 10000000b
-10001000b & 11000101b = 10000000b
-10001000b & 11000110b = 10000000b
-10001000b & 11000111b = 10000000b
-10001000b & 11001000b = 10001000b
-10001000b & 11001001b = 10001000b
-10001000b & 11001010b = 10001000b
-10001000b & 11001011b = 10001000b
-10001000b & 11001100b = 10001000b
-10001000b & 11001101b = 10001000b
-10001000b & 11001110b = 10001000b
-10001000b & 11001111b = 10001000b
-10001000b & 11010000b = 10000000b
-10001000b & 11010001b = 10000000b
-10001000b & 11010010b = 10000000b
-10001000b & 11010011b = 10000000b
-10001000b & 11010100b = 10000000b
-10001000b & 11010101b = 10000000b
-10001000b & 11010110b = 10000000b
-10001000b & 11010111b = 10000000b
-10001000b & 11011000b = 10001000b
-10001000b & 11011001b = 10001000b
-10001000b & 11011010b = 10001000b
-10001000b & 11011011b = 10001000b
-10001000b & 11011100b = 10001000b
-10001000b & 11011101b = 10001000b
-10001000b & 11011110b = 10001000b
-10001000b & 11011111b = 10001000b
-10001000b & 11100000b = 10000000b
-10001000b & 11100001b = 10000000b
-10001000b & 11100010b = 10000000b
-10001000b & 11100011b = 10000000b
-10001000b & 11100100b = 10000000b
-10001000b & 11100101b = 10000000b
-10001000b & 11100110b = 10000000b
-10001000b & 11100111b = 10000000b
-10001000b & 11101000b = 10001000b
-10001000b & 11101001b = 10001000b
-10001000b & 11101010b = 10001000b
-10001000b & 11101011b = 10001000b
-10001000b & 11101100b = 10001000b
-10001000b & 11101101b = 10001000b
-10001000b & 11101110b = 10001000b
-10001000b & 11101111b = 10001000b
-10001000b & 11110000b = 10000000b
-10001000b & 11110001b = 10000000b
-10001000b & 11110010b = 10000000b
-10001000b & 11110011b = 10000000b
-10001000b & 11110100b = 10000000b
-10001000b & 11110101b = 10000000b
-10001000b & 11110110b = 10000000b
-10001000b & 11110111b = 10000000b
-10001000b & 11111000b = 10001000b
-10001000b & 11111001b = 10001000b
-10001000b & 11111010b = 10001000b
-10001000b & 11111011b = 10001000b
-10001000b & 11111100b = 10001000b
-10001000b & 11111101b = 10001000b
-10001000b & 11111110b = 10001000b
-10001000b & 11111111b = 10001000b
-10001000b & 00000000b = 00000000b
-10001000b & 00000001b = 00000000b
-10001000b & 00000010b = 00000000b
-10001000b & 00000011b = 00000000b
-10001000b & 00000100b = 00000000b
-10001000b & 00000101b = 00000000b
-10001000b & 00000110b = 00000000b
-10001000b & 00000111b = 00000000b
-10001000b & 00001000b = 00001000b
-10001000b & 00001001b = 00001000b
-10001000b & 00001010b = 00001000b
-10001000b & 00001011b = 00001000b
-10001000b & 00001100b = 00001000b
-10001000b & 00001101b = 00001000b
-10001000b & 00001110b = 00001000b
-10001000b & 00001111b = 00001000b
-10001000b & 00010000b = 00000000b
-10001000b & 00010001b = 00000000b
-10001000b & 00010010b = 00000000b
-10001000b & 00010011b = 00000000b
-10001000b & 00010100b = 00000000b
-10001000b & 00010101b = 00000000b
-10001000b & 00010110b = 00000000b
-10001000b & 00010111b = 00000000b
-10001000b & 00011000b = 00001000b
-10001000b & 00011001b = 00001000b
-10001000b & 00011010b = 00001000b
-10001000b & 00011011b = 00001000b
-10001000b & 00011100b = 00001000b
-10001000b & 00011101b = 00001000b
-10001000b & 00011110b = 00001000b
-10001000b & 00011111b = 00001000b
-10001000b & 00100000b = 00000000b
-10001000b & 00100001b = 00000000b
-10001000b & 00100010b = 00000000b
-10001000b & 00100011b = 00000000b
-10001000b & 00100100b = 00000000b
-10001000b & 00100101b = 00000000b
-10001000b & 00100110b = 00000000b
-10001000b & 00100111b = 00000000b
-10001000b & 00101000b = 00001000b
-10001000b & 00101001b = 00001000b
-10001000b & 00101010b = 00001000b
-10001000b & 00101011b = 00001000b
-10001000b & 00101100b = 00001000b
-10001000b & 00101101b = 00001000b
-10001000b & 00101110b = 00001000b
-10001000b & 00101111b = 00001000b
-10001000b & 00110000b = 00000000b
-10001000b & 00110001b = 00000000b
-10001000b & 00110010b = 00000000b
-10001000b & 00110011b = 00000000b
-10001000b & 00110100b = 00000000b
-10001000b & 00110101b = 00000000b
-10001000b & 00110110b = 00000000b
-10001000b & 00110111b = 00000000b
-10001000b & 00111000b = 00001000b
-10001000b & 00111001b = 00001000b
-10001000b & 00111010b = 00001000b
-10001000b & 00111011b = 00001000b
-10001000b & 00111100b = 00001000b
-10001000b & 00111101b = 00001000b
-10001000b & 00111110b = 00001000b
-10001000b & 00111111b = 00001000b
-10001000b & 01000000b = 00000000b
-10001000b & 01000001b = 00000000b
-10001000b & 01000010b = 00000000b
-10001000b & 01000011b = 00000000b
-10001000b & 01000100b = 00000000b
-10001000b & 01000101b = 00000000b
-10001000b & 01000110b = 00000000b
-10001000b & 01000111b = 00000000b
-10001000b & 01001000b = 00001000b
-10001000b & 01001001b = 00001000b
-10001000b & 01001010b = 00001000b
-10001000b & 01001011b = 00001000b
-10001000b & 01001100b = 00001000b
-10001000b & 01001101b = 00001000b
-10001000b & 01001110b = 00001000b
-10001000b & 01001111b = 00001000b
-10001000b & 01010000b = 00000000b
-10001000b & 01010001b = 00000000b
-10001000b & 01010010b = 00000000b
-10001000b & 01010011b = 00000000b
-10001000b & 01010100b = 00000000b
-10001000b & 01010101b = 00000000b
-10001000b & 01010110b = 00000000b
-10001000b & 01010111b = 00000000b
-10001000b & 01011000b = 00001000b
-10001000b & 01011001b = 00001000b
-10001000b & 01011010b = 00001000b
-10001000b & 01011011b = 00001000b
-10001000b & 01011100b = 00001000b
-10001000b & 01011101b = 00001000b
-10001000b & 01011110b = 00001000b
-10001000b & 01011111b = 00001000b
-10001000b & 01100000b = 00000000b
-10001000b & 01100001b = 00000000b
-10001000b & 01100010b = 00000000b
-10001000b & 01100011b = 00000000b
-10001000b & 01100100b = 00000000b
-10001000b & 01100101b = 00000000b
-10001000b & 01100110b = 00000000b
-10001000b & 01100111b = 00000000b
-10001000b & 01101000b = 00001000b
-10001000b & 01101001b = 00001000b
-10001000b & 01101010b = 00001000b
-10001000b & 01101011b = 00001000b
-10001000b & 01101100b = 00001000b
-10001000b & 01101101b = 00001000b
-10001000b & 01101110b = 00001000b
-10001000b & 01101111b = 00001000b
-10001000b & 01110000b = 00000000b
-10001000b & 01110001b = 00000000b
-10001000b & 01110010b = 00000000b
-10001000b & 01110011b = 00000000b
-10001000b & 01110100b = 00000000b
-10001000b & 01110101b = 00000000b
-10001000b & 01110110b = 00000000b
-10001000b & 01110111b = 00000000b
-10001000b & 01111000b = 00001000b
-10001000b & 01111001b = 00001000b
-10001000b & 01111010b = 00001000b
-10001000b & 01111011b = 00001000b
-10001000b & 01111100b = 00001000b
-10001000b & 01111101b = 00001000b
-10001000b & 01111110b = 00001000b
-10001001b & 10000000b = 10000000b
-10001001b & 10000001b = 10000001b
-10001001b & 10000010b = 10000000b
-10001001b & 10000011b = 10000001b
-10001001b & 10000100b = 10000000b
-10001001b & 10000101b = 10000001b
-10001001b & 10000110b = 10000000b
-10001001b & 10000111b = 10000001b
-10001001b & 10001000b = 10001000b
-10001001b & 10001001b = 10001001b
-10001001b & 10001010b = 10001000b
-10001001b & 10001011b = 10001001b
-10001001b & 10001100b = 10001000b
-10001001b & 10001101b = 10001001b
-10001001b & 10001110b = 10001000b
-10001001b & 10001111b = 10001001b
-10001001b & 10010000b = 10000000b
-10001001b & 10010001b = 10000001b
-10001001b & 10010010b = 10000000b
-10001001b & 10010011b = 10000001b
-10001001b & 10010100b = 10000000b
-10001001b & 10010101b = 10000001b
-10001001b & 10010110b = 10000000b
-10001001b & 10010111b = 10000001b
-10001001b & 10011000b = 10001000b
-10001001b & 10011001b = 10001001b
-10001001b & 10011010b = 10001000b
-10001001b & 10011011b = 10001001b
-10001001b & 10011100b = 10001000b
-10001001b & 10011101b = 10001001b
-10001001b & 10011110b = 10001000b
-10001001b & 10011111b = 10001001b
-10001001b & 10100000b = 10000000b
-10001001b & 10100001b = 10000001b
-10001001b & 10100010b = 10000000b
-10001001b & 10100011b = 10000001b
-10001001b & 10100100b = 10000000b
-10001001b & 10100101b = 10000001b
-10001001b & 10100110b = 10000000b
-10001001b & 10100111b = 10000001b
-10001001b & 10101000b = 10001000b
-10001001b & 10101001b = 10001001b
-10001001b & 10101010b = 10001000b
-10001001b & 10101011b = 10001001b
-10001001b & 10101100b = 10001000b
-10001001b & 10101101b = 10001001b
-10001001b & 10101110b = 10001000b
-10001001b & 10101111b = 10001001b
-10001001b & 10110000b = 10000000b
-10001001b & 10110001b = 10000001b
-10001001b & 10110010b = 10000000b
-10001001b & 10110011b = 10000001b
-10001001b & 10110100b = 10000000b
-10001001b & 10110101b = 10000001b
-10001001b & 10110110b = 10000000b
-10001001b & 10110111b = 10000001b
-10001001b & 10111000b = 10001000b
-10001001b & 10111001b = 10001001b
-10001001b & 10111010b = 10001000b
-10001001b & 10111011b = 10001001b
-10001001b & 10111100b = 10001000b
-10001001b & 10111101b = 10001001b
-10001001b & 10111110b = 10001000b
-10001001b & 10111111b = 10001001b
-10001001b & 11000000b = 10000000b
-10001001b & 11000001b = 10000001b
-10001001b & 11000010b = 10000000b
-10001001b & 11000011b = 10000001b
-10001001b & 11000100b = 10000000b
-10001001b & 11000101b = 10000001b
-10001001b & 11000110b = 10000000b
-10001001b & 11000111b = 10000001b
-10001001b & 11001000b = 10001000b
-10001001b & 11001001b = 10001001b
-10001001b & 11001010b = 10001000b
-10001001b & 11001011b = 10001001b
-10001001b & 11001100b = 10001000b
-10001001b & 11001101b = 10001001b
-10001001b & 11001110b = 10001000b
-10001001b & 11001111b = 10001001b
-10001001b & 11010000b = 10000000b
-10001001b & 11010001b = 10000001b
-10001001b & 11010010b = 10000000b
-10001001b & 11010011b = 10000001b
-10001001b & 11010100b = 10000000b
-10001001b & 11010101b = 10000001b
-10001001b & 11010110b = 10000000b
-10001001b & 11010111b = 10000001b
-10001001b & 11011000b = 10001000b
-10001001b & 11011001b = 10001001b
-10001001b & 11011010b = 10001000b
-10001001b & 11011011b = 10001001b
-10001001b & 11011100b = 10001000b
-10001001b & 11011101b = 10001001b
-10001001b & 11011110b = 10001000b
-10001001b & 11011111b = 10001001b
-10001001b & 11100000b = 10000000b
-10001001b & 11100001b = 10000001b
-10001001b & 11100010b = 10000000b
-10001001b & 11100011b = 10000001b
-10001001b & 11100100b = 10000000b
-10001001b & 11100101b = 10000001b
-10001001b & 11100110b = 10000000b
-10001001b & 11100111b = 10000001b
-10001001b & 11101000b = 10001000b
-10001001b & 11101001b = 10001001b
-10001001b & 11101010b = 10001000b
-10001001b & 11101011b = 10001001b
-10001001b & 11101100b = 10001000b
-10001001b & 11101101b = 10001001b
-10001001b & 11101110b = 10001000b
-10001001b & 11101111b = 10001001b
-10001001b & 11110000b = 10000000b
-10001001b & 11110001b = 10000001b
-10001001b & 11110010b = 10000000b
-10001001b & 11110011b = 10000001b
-10001001b & 11110100b = 10000000b
-10001001b & 11110101b = 10000001b
-10001001b & 11110110b = 10000000b
-10001001b & 11110111b = 10000001b
-10001001b & 11111000b = 10001000b
-10001001b & 11111001b = 10001001b
-10001001b & 11111010b = 10001000b
-10001001b & 11111011b = 10001001b
-10001001b & 11111100b = 10001000b
-10001001b & 11111101b = 10001001b
-10001001b & 11111110b = 10001000b
-10001001b & 11111111b = 10001001b
-10001001b & 00000000b = 00000000b
-10001001b & 00000001b = 00000001b
-10001001b & 00000010b = 00000000b
-10001001b & 00000011b = 00000001b
-10001001b & 00000100b = 00000000b
-10001001b & 00000101b = 00000001b
-10001001b & 00000110b = 00000000b
-10001001b & 00000111b = 00000001b
-10001001b & 00001000b = 00001000b
-10001001b & 00001001b = 00001001b
-10001001b & 00001010b = 00001000b
-10001001b & 00001011b = 00001001b
-10001001b & 00001100b = 00001000b
-10001001b & 00001101b = 00001001b
-10001001b & 00001110b = 00001000b
-10001001b & 00001111b = 00001001b
-10001001b & 00010000b = 00000000b
-10001001b & 00010001b = 00000001b
-10001001b & 00010010b = 00000000b
-10001001b & 00010011b = 00000001b
-10001001b & 00010100b = 00000000b
-10001001b & 00010101b = 00000001b
-10001001b & 00010110b = 00000000b
-10001001b & 00010111b = 00000001b
-10001001b & 00011000b = 00001000b
-10001001b & 00011001b = 00001001b
-10001001b & 00011010b = 00001000b
-10001001b & 00011011b = 00001001b
-10001001b & 00011100b = 00001000b
-10001001b & 00011101b = 00001001b
-10001001b & 00011110b = 00001000b
-10001001b & 00011111b = 00001001b
-10001001b & 00100000b = 00000000b
-10001001b & 00100001b = 00000001b
-10001001b & 00100010b = 00000000b
-10001001b & 00100011b = 00000001b
-10001001b & 00100100b = 00000000b
-10001001b & 00100101b = 00000001b
-10001001b & 00100110b = 00000000b
-10001001b & 00100111b = 00000001b
-10001001b & 00101000b = 00001000b
-10001001b & 00101001b = 00001001b
-10001001b & 00101010b = 00001000b
-10001001b & 00101011b = 00001001b
-10001001b & 00101100b = 00001000b
-10001001b & 00101101b = 00001001b
-10001001b & 00101110b = 00001000b
-10001001b & 00101111b = 00001001b
-10001001b & 00110000b = 00000000b
-10001001b & 00110001b = 00000001b
-10001001b & 00110010b = 00000000b
-10001001b & 00110011b = 00000001b
-10001001b & 00110100b = 00000000b
-10001001b & 00110101b = 00000001b
-10001001b & 00110110b = 00000000b
-10001001b & 00110111b = 00000001b
-10001001b & 00111000b = 00001000b
-10001001b & 00111001b = 00001001b
-10001001b & 00111010b = 00001000b
-10001001b & 00111011b = 00001001b
-10001001b & 00111100b = 00001000b
-10001001b & 00111101b = 00001001b
-10001001b & 00111110b = 00001000b
-10001001b & 00111111b = 00001001b
-10001001b & 01000000b = 00000000b
-10001001b & 01000001b = 00000001b
-10001001b & 01000010b = 00000000b
-10001001b & 01000011b = 00000001b
-10001001b & 01000100b = 00000000b
-10001001b & 01000101b = 00000001b
-10001001b & 01000110b = 00000000b
-10001001b & 01000111b = 00000001b
-10001001b & 01001000b = 00001000b
-10001001b & 01001001b = 00001001b
-10001001b & 01001010b = 00001000b
-10001001b & 01001011b = 00001001b
-10001001b & 01001100b = 00001000b
-10001001b & 01001101b = 00001001b
-10001001b & 01001110b = 00001000b
-10001001b & 01001111b = 00001001b
-10001001b & 01010000b = 00000000b
-10001001b & 01010001b = 00000001b
-10001001b & 01010010b = 00000000b
-10001001b & 01010011b = 00000001b
-10001001b & 01010100b = 00000000b
-10001001b & 01010101b = 00000001b
-10001001b & 01010110b = 00000000b
-10001001b & 01010111b = 00000001b
-10001001b & 01011000b = 00001000b
-10001001b & 01011001b = 00001001b
-10001001b & 01011010b = 00001000b
-10001001b & 01011011b = 00001001b
-10001001b & 01011100b = 00001000b
-10001001b & 01011101b = 00001001b
-10001001b & 01011110b = 00001000b
-10001001b & 01011111b = 00001001b
-10001001b & 01100000b = 00000000b
-10001001b & 01100001b = 00000001b
-10001001b & 01100010b = 00000000b
-10001001b & 01100011b = 00000001b
-10001001b & 01100100b = 00000000b
-10001001b & 01100101b = 00000001b
-10001001b & 01100110b = 00000000b
-10001001b & 01100111b = 00000001b
-10001001b & 01101000b = 00001000b
-10001001b & 01101001b = 00001001b
-10001001b & 01101010b = 00001000b
-10001001b & 01101011b = 00001001b
-10001001b & 01101100b = 00001000b
-10001001b & 01101101b = 00001001b
-10001001b & 01101110b = 00001000b
-10001001b & 01101111b = 00001001b
-10001001b & 01110000b = 00000000b
-10001001b & 01110001b = 00000001b
-10001001b & 01110010b = 00000000b
-10001001b & 01110011b = 00000001b
-10001001b & 01110100b = 00000000b
-10001001b & 01110101b = 00000001b
-10001001b & 01110110b = 00000000b
-10001001b & 01110111b = 00000001b
-10001001b & 01111000b = 00001000b
-10001001b & 01111001b = 00001001b
-10001001b & 01111010b = 00001000b
-10001001b & 01111011b = 00001001b
-10001001b & 01111100b = 00001000b
-10001001b & 01111101b = 00001001b
-10001001b & 01111110b = 00001000b
-10001010b & 10000000b = 10000000b
-10001010b & 10000001b = 10000000b
-10001010b & 10000010b = 10000010b
-10001010b & 10000011b = 10000010b
-10001010b & 10000100b = 10000000b
-10001010b & 10000101b = 10000000b
-10001010b & 10000110b = 10000010b
-10001010b & 10000111b = 10000010b
-10001010b & 10001000b = 10001000b
-10001010b & 10001001b = 10001000b
-10001010b & 10001010b = 10001010b
-10001010b & 10001011b = 10001010b
-10001010b & 10001100b = 10001000b
-10001010b & 10001101b = 10001000b
-10001010b & 10001110b = 10001010b
-10001010b & 10001111b = 10001010b
-10001010b & 10010000b = 10000000b
-10001010b & 10010001b = 10000000b
-10001010b & 10010010b = 10000010b
-10001010b & 10010011b = 10000010b
-10001010b & 10010100b = 10000000b
-10001010b & 10010101b = 10000000b
-10001010b & 10010110b = 10000010b
-10001010b & 10010111b = 10000010b
-10001010b & 10011000b = 10001000b
-10001010b & 10011001b = 10001000b
-10001010b & 10011010b = 10001010b
-10001010b & 10011011b = 10001010b
-10001010b & 10011100b = 10001000b
-10001010b & 10011101b = 10001000b
-10001010b & 10011110b = 10001010b
-10001010b & 10011111b = 10001010b
-10001010b & 10100000b = 10000000b
-10001010b & 10100001b = 10000000b
-10001010b & 10100010b = 10000010b
-10001010b & 10100011b = 10000010b
-10001010b & 10100100b = 10000000b
-10001010b & 10100101b = 10000000b
-10001010b & 10100110b = 10000010b
-10001010b & 10100111b = 10000010b
-10001010b & 10101000b = 10001000b
-10001010b & 10101001b = 10001000b
-10001010b & 10101010b = 10001010b
-10001010b & 10101011b = 10001010b
-10001010b & 10101100b = 10001000b
-10001010b & 10101101b = 10001000b
-10001010b & 10101110b = 10001010b
-10001010b & 10101111b = 10001010b
-10001010b & 10110000b = 10000000b
-10001010b & 10110001b = 10000000b
-10001010b & 10110010b = 10000010b
-10001010b & 10110011b = 10000010b
-10001010b & 10110100b = 10000000b
-10001010b & 10110101b = 10000000b
-10001010b & 10110110b = 10000010b
-10001010b & 10110111b = 10000010b
-10001010b & 10111000b = 10001000b
-10001010b & 10111001b = 10001000b
-10001010b & 10111010b = 10001010b
-10001010b & 10111011b = 10001010b
-10001010b & 10111100b = 10001000b
-10001010b & 10111101b = 10001000b
-10001010b & 10111110b = 10001010b
-10001010b & 10111111b = 10001010b
-10001010b & 11000000b = 10000000b
-10001010b & 11000001b = 10000000b
-10001010b & 11000010b = 10000010b
-10001010b & 11000011b = 10000010b
-10001010b & 11000100b = 10000000b
-10001010b & 11000101b = 10000000b
-10001010b & 11000110b = 10000010b
-10001010b & 11000111b = 10000010b
-10001010b & 11001000b = 10001000b
-10001010b & 11001001b = 10001000b
-10001010b & 11001010b = 10001010b
-10001010b & 11001011b = 10001010b
-10001010b & 11001100b = 10001000b
-10001010b & 11001101b = 10001000b
-10001010b & 11001110b = 10001010b
-10001010b & 11001111b = 10001010b
-10001010b & 11010000b = 10000000b
-10001010b & 11010001b = 10000000b
-10001010b & 11010010b = 10000010b
-10001010b & 11010011b = 10000010b
-10001010b & 11010100b = 10000000b
-10001010b & 11010101b = 10000000b
-10001010b & 11010110b = 10000010b
-10001010b & 11010111b = 10000010b
-10001010b & 11011000b = 10001000b
-10001010b & 11011001b = 10001000b
-10001010b & 11011010b = 10001010b
-10001010b & 11011011b = 10001010b
-10001010b & 11011100b = 10001000b
-10001010b & 11011101b = 10001000b
-10001010b & 11011110b = 10001010b
-10001010b & 11011111b = 10001010b
-10001010b & 11100000b = 10000000b
-10001010b & 11100001b = 10000000b
-10001010b & 11100010b = 10000010b
-10001010b & 11100011b = 10000010b
-10001010b & 11100100b = 10000000b
-10001010b & 11100101b = 10000000b
-10001010b & 11100110b = 10000010b
-10001010b & 11100111b = 10000010b
-10001010b & 11101000b = 10001000b
-10001010b & 11101001b = 10001000b
-10001010b & 11101010b = 10001010b
-10001010b & 11101011b = 10001010b
-10001010b & 11101100b = 10001000b
-10001010b & 11101101b = 10001000b
-10001010b & 11101110b = 10001010b
-10001010b & 11101111b = 10001010b
-10001010b & 11110000b = 10000000b
-10001010b & 11110001b = 10000000b
-10001010b & 11110010b = 10000010b
-10001010b & 11110011b = 10000010b
-10001010b & 11110100b = 10000000b
-10001010b & 11110101b = 10000000b
-10001010b & 11110110b = 10000010b
-10001010b & 11110111b = 10000010b
-10001010b & 11111000b = 10001000b
-10001010b & 11111001b = 10001000b
-10001010b & 11111010b = 10001010b
-10001010b & 11111011b = 10001010b
-10001010b & 11111100b = 10001000b
-10001010b & 11111101b = 10001000b
-10001010b & 11111110b = 10001010b
-10001010b & 11111111b = 10001010b
-10001010b & 00000000b = 00000000b
-10001010b & 00000001b = 00000000b
-10001010b & 00000010b = 00000010b
-10001010b & 00000011b = 00000010b
-10001010b & 00000100b = 00000000b
-10001010b & 00000101b = 00000000b
-10001010b & 00000110b = 00000010b
-10001010b & 00000111b = 00000010b
-10001010b & 00001000b = 00001000b
-10001010b & 00001001b = 00001000b
-10001010b & 00001010b = 00001010b
-10001010b & 00001011b = 00001010b
-10001010b & 00001100b = 00001000b
-10001010b & 00001101b = 00001000b
-10001010b & 00001110b = 00001010b
-10001010b & 00001111b = 00001010b
-10001010b & 00010000b = 00000000b
-10001010b & 00010001b = 00000000b
-10001010b & 00010010b = 00000010b
-10001010b & 00010011b = 00000010b
-10001010b & 00010100b = 00000000b
-10001010b & 00010101b = 00000000b
-10001010b & 00010110b = 00000010b
-10001010b & 00010111b = 00000010b
-10001010b & 00011000b = 00001000b
-10001010b & 00011001b = 00001000b
-10001010b & 00011010b = 00001010b
-10001010b & 00011011b = 00001010b
-10001010b & 00011100b = 00001000b
-10001010b & 00011101b = 00001000b
-10001010b & 00011110b = 00001010b
-10001010b & 00011111b = 00001010b
-10001010b & 00100000b = 00000000b
-10001010b & 00100001b = 00000000b
-10001010b & 00100010b = 00000010b
-10001010b & 00100011b = 00000010b
-10001010b & 00100100b = 00000000b
-10001010b & 00100101b = 00000000b
-10001010b & 00100110b = 00000010b
-10001010b & 00100111b = 00000010b
-10001010b & 00101000b = 00001000b
-10001010b & 00101001b = 00001000b
-10001010b & 00101010b = 00001010b
-10001010b & 00101011b = 00001010b
-10001010b & 00101100b = 00001000b
-10001010b & 00101101b = 00001000b
-10001010b & 00101110b = 00001010b
-10001010b & 00101111b = 00001010b
-10001010b & 00110000b = 00000000b
-10001010b & 00110001b = 00000000b
-10001010b & 00110010b = 00000010b
-10001010b & 00110011b = 00000010b
-10001010b & 00110100b = 00000000b
-10001010b & 00110101b = 00000000b
-10001010b & 00110110b = 00000010b
-10001010b & 00110111b = 00000010b
-10001010b & 00111000b = 00001000b
-10001010b & 00111001b = 00001000b
-10001010b & 00111010b = 00001010b
-10001010b & 00111011b = 00001010b
-10001010b & 00111100b = 00001000b
-10001010b & 00111101b = 00001000b
-10001010b & 00111110b = 00001010b
-10001010b & 00111111b = 00001010b
-10001010b & 01000000b = 00000000b
-10001010b & 01000001b = 00000000b
-10001010b & 01000010b = 00000010b
-10001010b & 01000011b = 00000010b
-10001010b & 01000100b = 00000000b
-10001010b & 01000101b = 00000000b
-10001010b & 01000110b = 00000010b
-10001010b & 01000111b = 00000010b
-10001010b & 01001000b = 00001000b
-10001010b & 01001001b = 00001000b
-10001010b & 01001010b = 00001010b
-10001010b & 01001011b = 00001010b
-10001010b & 01001100b = 00001000b
-10001010b & 01001101b = 00001000b
-10001010b & 01001110b = 00001010b
-10001010b & 01001111b = 00001010b
-10001010b & 01010000b = 00000000b
-10001010b & 01010001b = 00000000b
-10001010b & 01010010b = 00000010b
-10001010b & 01010011b = 00000010b
-10001010b & 01010100b = 00000000b
-10001010b & 01010101b = 00000000b
-10001010b & 01010110b = 00000010b
-10001010b & 01010111b = 00000010b
-10001010b & 01011000b = 00001000b
-10001010b & 01011001b = 00001000b
-10001010b & 01011010b = 00001010b
-10001010b & 01011011b = 00001010b
-10001010b & 01011100b = 00001000b
-10001010b & 01011101b = 00001000b
-10001010b & 01011110b = 00001010b
-10001010b & 01011111b = 00001010b
-10001010b & 01100000b = 00000000b
-10001010b & 01100001b = 00000000b
-10001010b & 01100010b = 00000010b
-10001010b & 01100011b = 00000010b
-10001010b & 01100100b = 00000000b
-10001010b & 01100101b = 00000000b
-10001010b & 01100110b = 00000010b
-10001010b & 01100111b = 00000010b
-10001010b & 01101000b = 00001000b
-10001010b & 01101001b = 00001000b
-10001010b & 01101010b = 00001010b
-10001010b & 01101011b = 00001010b
-10001010b & 01101100b = 00001000b
-10001010b & 01101101b = 00001000b
-10001010b & 01101110b = 00001010b
-10001010b & 01101111b = 00001010b
-10001010b & 01110000b = 00000000b
-10001010b & 01110001b = 00000000b
-10001010b & 01110010b = 00000010b
-10001010b & 01110011b = 00000010b
-10001010b & 01110100b = 00000000b
-10001010b & 01110101b = 00000000b
-10001010b & 01110110b = 00000010b
-10001010b & 01110111b = 00000010b
-10001010b & 01111000b = 00001000b
-10001010b & 01111001b = 00001000b
-10001010b & 01111010b = 00001010b
-10001010b & 01111011b = 00001010b
-10001010b & 01111100b = 00001000b
-10001010b & 01111101b = 00001000b
-10001010b & 01111110b = 00001010b
-10001011b & 10000000b = 10000000b
-10001011b & 10000001b = 10000001b
-10001011b & 10000010b = 10000010b
-10001011b & 10000011b = 10000011b
-10001011b & 10000100b = 10000000b
-10001011b & 10000101b = 10000001b
-10001011b & 10000110b = 10000010b
-10001011b & 10000111b = 10000011b
-10001011b & 10001000b = 10001000b
-10001011b & 10001001b = 10001001b
-10001011b & 10001010b = 10001010b
-10001011b & 10001011b = 10001011b
-10001011b & 10001100b = 10001000b
-10001011b & 10001101b = 10001001b
-10001011b & 10001110b = 10001010b
-10001011b & 10001111b = 10001011b
-10001011b & 10010000b = 10000000b
-10001011b & 10010001b = 10000001b
-10001011b & 10010010b = 10000010b
-10001011b & 10010011b = 10000011b
-10001011b & 10010100b = 10000000b
-10001011b & 10010101b = 10000001b
-10001011b & 10010110b = 10000010b
-10001011b & 10010111b = 10000011b
-10001011b & 10011000b = 10001000b
-10001011b & 10011001b = 10001001b
-10001011b & 10011010b = 10001010b
-10001011b & 10011011b = 10001011b
-10001011b & 10011100b = 10001000b
-10001011b & 10011101b = 10001001b
-10001011b & 10011110b = 10001010b
-10001011b & 10011111b = 10001011b
-10001011b & 10100000b = 10000000b
-10001011b & 10100001b = 10000001b
-10001011b & 10100010b = 10000010b
-10001011b & 10100011b = 10000011b
-10001011b & 10100100b = 10000000b
-10001011b & 10100101b = 10000001b
-10001011b & 10100110b = 10000010b
-10001011b & 10100111b = 10000011b
-10001011b & 10101000b = 10001000b
-10001011b & 10101001b = 10001001b
-10001011b & 10101010b = 10001010b
-10001011b & 10101011b = 10001011b
-10001011b & 10101100b = 10001000b
-10001011b & 10101101b = 10001001b
-10001011b & 10101110b = 10001010b
-10001011b & 10101111b = 10001011b
-10001011b & 10110000b = 10000000b
-10001011b & 10110001b = 10000001b
-10001011b & 10110010b = 10000010b
-10001011b & 10110011b = 10000011b
-10001011b & 10110100b = 10000000b
-10001011b & 10110101b = 10000001b
-10001011b & 10110110b = 10000010b
-10001011b & 10110111b = 10000011b
-10001011b & 10111000b = 10001000b
-10001011b & 10111001b = 10001001b
-10001011b & 10111010b = 10001010b
-10001011b & 10111011b = 10001011b
-10001011b & 10111100b = 10001000b
-10001011b & 10111101b = 10001001b
-10001011b & 10111110b = 10001010b
-10001011b & 10111111b = 10001011b
-10001011b & 11000000b = 10000000b
-10001011b & 11000001b = 10000001b
-10001011b & 11000010b = 10000010b
-10001011b & 11000011b = 10000011b
-10001011b & 11000100b = 10000000b
-10001011b & 11000101b = 10000001b
-10001011b & 11000110b = 10000010b
-10001011b & 11000111b = 10000011b
-10001011b & 11001000b = 10001000b
-10001011b & 11001001b = 10001001b
-10001011b & 11001010b = 10001010b
-10001011b & 11001011b = 10001011b
-10001011b & 11001100b = 10001000b
-10001011b & 11001101b = 10001001b
-10001011b & 11001110b = 10001010b
-10001011b & 11001111b = 10001011b
-10001011b & 11010000b = 10000000b
-10001011b & 11010001b = 10000001b
-10001011b & 11010010b = 10000010b
-10001011b & 11010011b = 10000011b
-10001011b & 11010100b = 10000000b
-10001011b & 11010101b = 10000001b
-10001011b & 11010110b = 10000010b
-10001011b & 11010111b = 10000011b
-10001011b & 11011000b = 10001000b
-10001011b & 11011001b = 10001001b
-10001011b & 11011010b = 10001010b
-10001011b & 11011011b = 10001011b
-10001011b & 11011100b = 10001000b
-10001011b & 11011101b = 10001001b
-10001011b & 11011110b = 10001010b
-10001011b & 11011111b = 10001011b
-10001011b & 11100000b = 10000000b
-10001011b & 11100001b = 10000001b
-10001011b & 11100010b = 10000010b
-10001011b & 11100011b = 10000011b
-10001011b & 11100100b = 10000000b
-10001011b & 11100101b = 10000001b
-10001011b & 11100110b = 10000010b
-10001011b & 11100111b = 10000011b
-10001011b & 11101000b = 10001000b
-10001011b & 11101001b = 10001001b
-10001011b & 11101010b = 10001010b
-10001011b & 11101011b = 10001011b
-10001011b & 11101100b = 10001000b
-10001011b & 11101101b = 10001001b
-10001011b & 11101110b = 10001010b
-10001011b & 11101111b = 10001011b
-10001011b & 11110000b = 10000000b
-10001011b & 11110001b = 10000001b
-10001011b & 11110010b = 10000010b
-10001011b & 11110011b = 10000011b
-10001011b & 11110100b = 10000000b
-10001011b & 11110101b = 10000001b
-10001011b & 11110110b = 10000010b
-10001011b & 11110111b = 10000011b
-10001011b & 11111000b = 10001000b
-10001011b & 11111001b = 10001001b
-10001011b & 11111010b = 10001010b
-10001011b & 11111011b = 10001011b
-10001011b & 11111100b = 10001000b
-10001011b & 11111101b = 10001001b
-10001011b & 11111110b = 10001010b
-10001011b & 11111111b = 10001011b
-10001011b & 00000000b = 00000000b
-10001011b & 00000001b = 00000001b
-10001011b & 00000010b = 00000010b
-10001011b & 00000011b = 00000011b
-10001011b & 00000100b = 00000000b
-10001011b & 00000101b = 00000001b
-10001011b & 00000110b = 00000010b
-10001011b & 00000111b = 00000011b
-10001011b & 00001000b = 00001000b
-10001011b & 00001001b = 00001001b
-10001011b & 00001010b = 00001010b
-10001011b & 00001011b = 00001011b
-10001011b & 00001100b = 00001000b
-10001011b & 00001101b = 00001001b
-10001011b & 00001110b = 00001010b
-10001011b & 00001111b = 00001011b
-10001011b & 00010000b = 00000000b
-10001011b & 00010001b = 00000001b
-10001011b & 00010010b = 00000010b
-10001011b & 00010011b = 00000011b
-10001011b & 00010100b = 00000000b
-10001011b & 00010101b = 00000001b
-10001011b & 00010110b = 00000010b
-10001011b & 00010111b = 00000011b
-10001011b & 00011000b = 00001000b
-10001011b & 00011001b = 00001001b
-10001011b & 00011010b = 00001010b
-10001011b & 00011011b = 00001011b
-10001011b & 00011100b = 00001000b
-10001011b & 00011101b = 00001001b
-10001011b & 00011110b = 00001010b
-10001011b & 00011111b = 00001011b
-10001011b & 00100000b = 00000000b
-10001011b & 00100001b = 00000001b
-10001011b & 00100010b = 00000010b
-10001011b & 00100011b = 00000011b
-10001011b & 00100100b = 00000000b
-10001011b & 00100101b = 00000001b
-10001011b & 00100110b = 00000010b
-10001011b & 00100111b = 00000011b
-10001011b & 00101000b = 00001000b
-10001011b & 00101001b = 00001001b
-10001011b & 00101010b = 00001010b
-10001011b & 00101011b = 00001011b
-10001011b & 00101100b = 00001000b
-10001011b & 00101101b = 00001001b
-10001011b & 00101110b = 00001010b
-10001011b & 00101111b = 00001011b
-10001011b & 00110000b = 00000000b
-10001011b & 00110001b = 00000001b
-10001011b & 00110010b = 00000010b
-10001011b & 00110011b = 00000011b
-10001011b & 00110100b = 00000000b
-10001011b & 00110101b = 00000001b
-10001011b & 00110110b = 00000010b
-10001011b & 00110111b = 00000011b
-10001011b & 00111000b = 00001000b
-10001011b & 00111001b = 00001001b
-10001011b & 00111010b = 00001010b
-10001011b & 00111011b = 00001011b
-10001011b & 00111100b = 00001000b
-10001011b & 00111101b = 00001001b
-10001011b & 00111110b = 00001010b
-10001011b & 00111111b = 00001011b
-10001011b & 01000000b = 00000000b
-10001011b & 01000001b = 00000001b
-10001011b & 01000010b = 00000010b
-10001011b & 01000011b = 00000011b
-10001011b & 01000100b = 00000000b
-10001011b & 01000101b = 00000001b
-10001011b & 01000110b = 00000010b
-10001011b & 01000111b = 00000011b
-10001011b & 01001000b = 00001000b
-10001011b & 01001001b = 00001001b
-10001011b & 01001010b = 00001010b
-10001011b & 01001011b = 00001011b
-10001011b & 01001100b = 00001000b
-10001011b & 01001101b = 00001001b
-10001011b & 01001110b = 00001010b
-10001011b & 01001111b = 00001011b
-10001011b & 01010000b = 00000000b
-10001011b & 01010001b = 00000001b
-10001011b & 01010010b = 00000010b
-10001011b & 01010011b = 00000011b
-10001011b & 01010100b = 00000000b
-10001011b & 01010101b = 00000001b
-10001011b & 01010110b = 00000010b
-10001011b & 01010111b = 00000011b
-10001011b & 01011000b = 00001000b
-10001011b & 01011001b = 00001001b
-10001011b & 01011010b = 00001010b
-10001011b & 01011011b = 00001011b
-10001011b & 01011100b = 00001000b
-10001011b & 01011101b = 00001001b
-10001011b & 01011110b = 00001010b
-10001011b & 01011111b = 00001011b
-10001011b & 01100000b = 00000000b
-10001011b & 01100001b = 00000001b
-10001011b & 01100010b = 00000010b
-10001011b & 01100011b = 00000011b
-10001011b & 01100100b = 00000000b
-10001011b & 01100101b = 00000001b
-10001011b & 01100110b = 00000010b
-10001011b & 01100111b = 00000011b
-10001011b & 01101000b = 00001000b
-10001011b & 01101001b = 00001001b
-10001011b & 01101010b = 00001010b
-10001011b & 01101011b = 00001011b
-10001011b & 01101100b = 00001000b
-10001011b & 01101101b = 00001001b
-10001011b & 01101110b = 00001010b
-10001011b & 01101111b = 00001011b
-10001011b & 01110000b = 00000000b
-10001011b & 01110001b = 00000001b
-10001011b & 01110010b = 00000010b
-10001011b & 01110011b = 00000011b
-10001011b & 01110100b = 00000000b
-10001011b & 01110101b = 00000001b
-10001011b & 01110110b = 00000010b
-10001011b & 01110111b = 00000011b
-10001011b & 01111000b = 00001000b
-10001011b & 01111001b = 00001001b
-10001011b & 01111010b = 00001010b
-10001011b & 01111011b = 00001011b
-10001011b & 01111100b = 00001000b
-10001011b & 01111101b = 00001001b
-10001011b & 01111110b = 00001010b
-10001100b & 10000000b = 10000000b
-10001100b & 10000001b = 10000000b
-10001100b & 10000010b = 10000000b
-10001100b & 10000011b = 10000000b
-10001100b & 10000100b = 10000100b
-10001100b & 10000101b = 10000100b
-10001100b & 10000110b = 10000100b
-10001100b & 10000111b = 10000100b
-10001100b & 10001000b = 10001000b
-10001100b & 10001001b = 10001000b
-10001100b & 10001010b = 10001000b
-10001100b & 10001011b = 10001000b
-10001100b & 10001100b = 10001100b
-10001100b & 10001101b = 10001100b
-10001100b & 10001110b = 10001100b
-10001100b & 10001111b = 10001100b
-10001100b & 10010000b = 10000000b
-10001100b & 10010001b = 10000000b
-10001100b & 10010010b = 10000000b
-10001100b & 10010011b = 10000000b
-10001100b & 10010100b = 10000100b
-10001100b & 10010101b = 10000100b
-10001100b & 10010110b = 10000100b
-10001100b & 10010111b = 10000100b
-10001100b & 10011000b = 10001000b
-10001100b & 10011001b = 10001000b
-10001100b & 10011010b = 10001000b
-10001100b & 10011011b = 10001000b
-10001100b & 10011100b = 10001100b
-10001100b & 10011101b = 10001100b
-10001100b & 10011110b = 10001100b
-10001100b & 10011111b = 10001100b
-10001100b & 10100000b = 10000000b
-10001100b & 10100001b = 10000000b
-10001100b & 10100010b = 10000000b
-10001100b & 10100011b = 10000000b
-10001100b & 10100100b = 10000100b
-10001100b & 10100101b = 10000100b
-10001100b & 10100110b = 10000100b
-10001100b & 10100111b = 10000100b
-10001100b & 10101000b = 10001000b
-10001100b & 10101001b = 10001000b
-10001100b & 10101010b = 10001000b
-10001100b & 10101011b = 10001000b
-10001100b & 10101100b = 10001100b
-10001100b & 10101101b = 10001100b
-10001100b & 10101110b = 10001100b
-10001100b & 10101111b = 10001100b
-10001100b & 10110000b = 10000000b
-10001100b & 10110001b = 10000000b
-10001100b & 10110010b = 10000000b
-10001100b & 10110011b = 10000000b
-10001100b & 10110100b = 10000100b
-10001100b & 10110101b = 10000100b
-10001100b & 10110110b = 10000100b
-10001100b & 10110111b = 10000100b
-10001100b & 10111000b = 10001000b
-10001100b & 10111001b = 10001000b
-10001100b & 10111010b = 10001000b
-10001100b & 10111011b = 10001000b
-10001100b & 10111100b = 10001100b
-10001100b & 10111101b = 10001100b
-10001100b & 10111110b = 10001100b
-10001100b & 10111111b = 10001100b
-10001100b & 11000000b = 10000000b
-10001100b & 11000001b = 10000000b
-10001100b & 11000010b = 10000000b
-10001100b & 11000011b = 10000000b
-10001100b & 11000100b = 10000100b
-10001100b & 11000101b = 10000100b
-10001100b & 11000110b = 10000100b
-10001100b & 11000111b = 10000100b
-10001100b & 11001000b = 10001000b
-10001100b & 11001001b = 10001000b
-10001100b & 11001010b = 10001000b
-10001100b & 11001011b = 10001000b
-10001100b & 11001100b = 10001100b
-10001100b & 11001101b = 10001100b
-10001100b & 11001110b = 10001100b
-10001100b & 11001111b = 10001100b
-10001100b & 11010000b = 10000000b
-10001100b & 11010001b = 10000000b
-10001100b & 11010010b = 10000000b
-10001100b & 11010011b = 10000000b
-10001100b & 11010100b = 10000100b
-10001100b & 11010101b = 10000100b
-10001100b & 11010110b = 10000100b
-10001100b & 11010111b = 10000100b
-10001100b & 11011000b = 10001000b
-10001100b & 11011001b = 10001000b
-10001100b & 11011010b = 10001000b
-10001100b & 11011011b = 10001000b
-10001100b & 11011100b = 10001100b
-10001100b & 11011101b = 10001100b
-10001100b & 11011110b = 10001100b
-10001100b & 11011111b = 10001100b
-10001100b & 11100000b = 10000000b
-10001100b & 11100001b = 10000000b
-10001100b & 11100010b = 10000000b
-10001100b & 11100011b = 10000000b
-10001100b & 11100100b = 10000100b
-10001100b & 11100101b = 10000100b
-10001100b & 11100110b = 10000100b
-10001100b & 11100111b = 10000100b
-10001100b & 11101000b = 10001000b
-10001100b & 11101001b = 10001000b
-10001100b & 11101010b = 10001000b
-10001100b & 11101011b = 10001000b
-10001100b & 11101100b = 10001100b
-10001100b & 11101101b = 10001100b
-10001100b & 11101110b = 10001100b
-10001100b & 11101111b = 10001100b
-10001100b & 11110000b = 10000000b
-10001100b & 11110001b = 10000000b
-10001100b & 11110010b = 10000000b
-10001100b & 11110011b = 10000000b
-10001100b & 11110100b = 10000100b
-10001100b & 11110101b = 10000100b
-10001100b & 11110110b = 10000100b
-10001100b & 11110111b = 10000100b
-10001100b & 11111000b = 10001000b
-10001100b & 11111001b = 10001000b
-10001100b & 11111010b = 10001000b
-10001100b & 11111011b = 10001000b
-10001100b & 11111100b = 10001100b
-10001100b & 11111101b = 10001100b
-10001100b & 11111110b = 10001100b
-10001100b & 11111111b = 10001100b
-10001100b & 00000000b = 00000000b
-10001100b & 00000001b = 00000000b
-10001100b & 00000010b = 00000000b
-10001100b & 00000011b = 00000000b
-10001100b & 00000100b = 00000100b
-10001100b & 00000101b = 00000100b
-10001100b & 00000110b = 00000100b
-10001100b & 00000111b = 00000100b
-10001100b & 00001000b = 00001000b
-10001100b & 00001001b = 00001000b
-10001100b & 00001010b = 00001000b
-10001100b & 00001011b = 00001000b
-10001100b & 00001100b = 00001100b
-10001100b & 00001101b = 00001100b
-10001100b & 00001110b = 00001100b
-10001100b & 00001111b = 00001100b
-10001100b & 00010000b = 00000000b
-10001100b & 00010001b = 00000000b
-10001100b & 00010010b = 00000000b
-10001100b & 00010011b = 00000000b
-10001100b & 00010100b = 00000100b
-10001100b & 00010101b = 00000100b
-10001100b & 00010110b = 00000100b
-10001100b & 00010111b = 00000100b
-10001100b & 00011000b = 00001000b
-10001100b & 00011001b = 00001000b
-10001100b & 00011010b = 00001000b
-10001100b & 00011011b = 00001000b
-10001100b & 00011100b = 00001100b
-10001100b & 00011101b = 00001100b
-10001100b & 00011110b = 00001100b
-10001100b & 00011111b = 00001100b
-10001100b & 00100000b = 00000000b
-10001100b & 00100001b = 00000000b
-10001100b & 00100010b = 00000000b
-10001100b & 00100011b = 00000000b
-10001100b & 00100100b = 00000100b
-10001100b & 00100101b = 00000100b
-10001100b & 00100110b = 00000100b
-10001100b & 00100111b = 00000100b
-10001100b & 00101000b = 00001000b
-10001100b & 00101001b = 00001000b
-10001100b & 00101010b = 00001000b
-10001100b & 00101011b = 00001000b
-10001100b & 00101100b = 00001100b
-10001100b & 00101101b = 00001100b
-10001100b & 00101110b = 00001100b
-10001100b & 00101111b = 00001100b
-10001100b & 00110000b = 00000000b
-10001100b & 00110001b = 00000000b
-10001100b & 00110010b = 00000000b
-10001100b & 00110011b = 00000000b
-10001100b & 00110100b = 00000100b
-10001100b & 00110101b = 00000100b
-10001100b & 00110110b = 00000100b
-10001100b & 00110111b = 00000100b
-10001100b & 00111000b = 00001000b
-10001100b & 00111001b = 00001000b
-10001100b & 00111010b = 00001000b
-10001100b & 00111011b = 00001000b
-10001100b & 00111100b = 00001100b
-10001100b & 00111101b = 00001100b
-10001100b & 00111110b = 00001100b
-10001100b & 00111111b = 00001100b
-10001100b & 01000000b = 00000000b
-10001100b & 01000001b = 00000000b
-10001100b & 01000010b = 00000000b
-10001100b & 01000011b = 00000000b
-10001100b & 01000100b = 00000100b
-10001100b & 01000101b = 00000100b
-10001100b & 01000110b = 00000100b
-10001100b & 01000111b = 00000100b
-10001100b & 01001000b = 00001000b
-10001100b & 01001001b = 00001000b
-10001100b & 01001010b = 00001000b
-10001100b & 01001011b = 00001000b
-10001100b & 01001100b = 00001100b
-10001100b & 01001101b = 00001100b
-10001100b & 01001110b = 00001100b
-10001100b & 01001111b = 00001100b
-10001100b & 01010000b = 00000000b
-10001100b & 01010001b = 00000000b
-10001100b & 01010010b = 00000000b
-10001100b & 01010011b = 00000000b
-10001100b & 01010100b = 00000100b
-10001100b & 01010101b = 00000100b
-10001100b & 01010110b = 00000100b
-10001100b & 01010111b = 00000100b
-10001100b & 01011000b = 00001000b
-10001100b & 01011001b = 00001000b
-10001100b & 01011010b = 00001000b
-10001100b & 01011011b = 00001000b
-10001100b & 01011100b = 00001100b
-10001100b & 01011101b = 00001100b
-10001100b & 01011110b = 00001100b
-10001100b & 01011111b = 00001100b
-10001100b & 01100000b = 00000000b
-10001100b & 01100001b = 00000000b
-10001100b & 01100010b = 00000000b
-10001100b & 01100011b = 00000000b
-10001100b & 01100100b = 00000100b
-10001100b & 01100101b = 00000100b
-10001100b & 01100110b = 00000100b
-10001100b & 01100111b = 00000100b
-10001100b & 01101000b = 00001000b
-10001100b & 01101001b = 00001000b
-10001100b & 01101010b = 00001000b
-10001100b & 01101011b = 00001000b
-10001100b & 01101100b = 00001100b
-10001100b & 01101101b = 00001100b
-10001100b & 01101110b = 00001100b
-10001100b & 01101111b = 00001100b
-10001100b & 01110000b = 00000000b
-10001100b & 01110001b = 00000000b
-10001100b & 01110010b = 00000000b
-10001100b & 01110011b = 00000000b
-10001100b & 01110100b = 00000100b
-10001100b & 01110101b = 00000100b
-10001100b & 01110110b = 00000100b
-10001100b & 01110111b = 00000100b
-10001100b & 01111000b = 00001000b
-10001100b & 01111001b = 00001000b
-10001100b & 01111010b = 00001000b
-10001100b & 01111011b = 00001000b
-10001100b & 01111100b = 00001100b
-10001100b & 01111101b = 00001100b
-10001100b & 01111110b = 00001100b
-10001101b & 10000000b = 10000000b
-10001101b & 10000001b = 10000001b
-10001101b & 10000010b = 10000000b
-10001101b & 10000011b = 10000001b
-10001101b & 10000100b = 10000100b
-10001101b & 10000101b = 10000101b
-10001101b & 10000110b = 10000100b
-10001101b & 10000111b = 10000101b
-10001101b & 10001000b = 10001000b
-10001101b & 10001001b = 10001001b
-10001101b & 10001010b = 10001000b
-10001101b & 10001011b = 10001001b
-10001101b & 10001100b = 10001100b
-10001101b & 10001101b = 10001101b
-10001101b & 10001110b = 10001100b
-10001101b & 10001111b = 10001101b
-10001101b & 10010000b = 10000000b
-10001101b & 10010001b = 10000001b
-10001101b & 10010010b = 10000000b
-10001101b & 10010011b = 10000001b
-10001101b & 10010100b = 10000100b
-10001101b & 10010101b = 10000101b
-10001101b & 10010110b = 10000100b
-10001101b & 10010111b = 10000101b
-10001101b & 10011000b = 10001000b
-10001101b & 10011001b = 10001001b
-10001101b & 10011010b = 10001000b
-10001101b & 10011011b = 10001001b
-10001101b & 10011100b = 10001100b
-10001101b & 10011101b = 10001101b
-10001101b & 10011110b = 10001100b
-10001101b & 10011111b = 10001101b
-10001101b & 10100000b = 10000000b
-10001101b & 10100001b = 10000001b
-10001101b & 10100010b = 10000000b
-10001101b & 10100011b = 10000001b
-10001101b & 10100100b = 10000100b
-10001101b & 10100101b = 10000101b
-10001101b & 10100110b = 10000100b
-10001101b & 10100111b = 10000101b
-10001101b & 10101000b = 10001000b
-10001101b & 10101001b = 10001001b
-10001101b & 10101010b = 10001000b
-10001101b & 10101011b = 10001001b
-10001101b & 10101100b = 10001100b
-10001101b & 10101101b = 10001101b
-10001101b & 10101110b = 10001100b
-10001101b & 10101111b = 10001101b
-10001101b & 10110000b = 10000000b
-10001101b & 10110001b = 10000001b
-10001101b & 10110010b = 10000000b
-10001101b & 10110011b = 10000001b
-10001101b & 10110100b = 10000100b
-10001101b & 10110101b = 10000101b
-10001101b & 10110110b = 10000100b
-10001101b & 10110111b = 10000101b
-10001101b & 10111000b = 10001000b
-10001101b & 10111001b = 10001001b
-10001101b & 10111010b = 10001000b
-10001101b & 10111011b = 10001001b
-10001101b & 10111100b = 10001100b
-10001101b & 10111101b = 10001101b
-10001101b & 10111110b = 10001100b
-10001101b & 10111111b = 10001101b
-10001101b & 11000000b = 10000000b
-10001101b & 11000001b = 10000001b
-10001101b & 11000010b = 10000000b
-10001101b & 11000011b = 10000001b
-10001101b & 11000100b = 10000100b
-10001101b & 11000101b = 10000101b
-10001101b & 11000110b = 10000100b
-10001101b & 11000111b = 10000101b
-10001101b & 11001000b = 10001000b
-10001101b & 11001001b = 10001001b
-10001101b & 11001010b = 10001000b
-10001101b & 11001011b = 10001001b
-10001101b & 11001100b = 10001100b
-10001101b & 11001101b = 10001101b
-10001101b & 11001110b = 10001100b
-10001101b & 11001111b = 10001101b
-10001101b & 11010000b = 10000000b
-10001101b & 11010001b = 10000001b
-10001101b & 11010010b = 10000000b
-10001101b & 11010011b = 10000001b
-10001101b & 11010100b = 10000100b
-10001101b & 11010101b = 10000101b
-10001101b & 11010110b = 10000100b
-10001101b & 11010111b = 10000101b
-10001101b & 11011000b = 10001000b
-10001101b & 11011001b = 10001001b
-10001101b & 11011010b = 10001000b
-10001101b & 11011011b = 10001001b
-10001101b & 11011100b = 10001100b
-10001101b & 11011101b = 10001101b
-10001101b & 11011110b = 10001100b
-10001101b & 11011111b = 10001101b
-10001101b & 11100000b = 10000000b
-10001101b & 11100001b = 10000001b
-10001101b & 11100010b = 10000000b
-10001101b & 11100011b = 10000001b
-10001101b & 11100100b = 10000100b
-10001101b & 11100101b = 10000101b
-10001101b & 11100110b = 10000100b
-10001101b & 11100111b = 10000101b
-10001101b & 11101000b = 10001000b
-10001101b & 11101001b = 10001001b
-10001101b & 11101010b = 10001000b
-10001101b & 11101011b = 10001001b
-10001101b & 11101100b = 10001100b
-10001101b & 11101101b = 10001101b
-10001101b & 11101110b = 10001100b
-10001101b & 11101111b = 10001101b
-10001101b & 11110000b = 10000000b
-10001101b & 11110001b = 10000001b
-10001101b & 11110010b = 10000000b
-10001101b & 11110011b = 10000001b
-10001101b & 11110100b = 10000100b
-10001101b & 11110101b = 10000101b
-10001101b & 11110110b = 10000100b
-10001101b & 11110111b = 10000101b
-10001101b & 11111000b = 10001000b
-10001101b & 11111001b = 10001001b
-10001101b & 11111010b = 10001000b
-10001101b & 11111011b = 10001001b
-10001101b & 11111100b = 10001100b
-10001101b & 11111101b = 10001101b
-10001101b & 11111110b = 10001100b
-10001101b & 11111111b = 10001101b
-10001101b & 00000000b = 00000000b
-10001101b & 00000001b = 00000001b
-10001101b & 00000010b = 00000000b
-10001101b & 00000011b = 00000001b
-10001101b & 00000100b = 00000100b
-10001101b & 00000101b = 00000101b
-10001101b & 00000110b = 00000100b
-10001101b & 00000111b = 00000101b
-10001101b & 00001000b = 00001000b
-10001101b & 00001001b = 00001001b
-10001101b & 00001010b = 00001000b
-10001101b & 00001011b = 00001001b
-10001101b & 00001100b = 00001100b
-10001101b & 00001101b = 00001101b
-10001101b & 00001110b = 00001100b
-10001101b & 00001111b = 00001101b
-10001101b & 00010000b = 00000000b
-10001101b & 00010001b = 00000001b
-10001101b & 00010010b = 00000000b
-10001101b & 00010011b = 00000001b
-10001101b & 00010100b = 00000100b
-10001101b & 00010101b = 00000101b
-10001101b & 00010110b = 00000100b
-10001101b & 00010111b = 00000101b
-10001101b & 00011000b = 00001000b
-10001101b & 00011001b = 00001001b
-10001101b & 00011010b = 00001000b
-10001101b & 00011011b = 00001001b
-10001101b & 00011100b = 00001100b
-10001101b & 00011101b = 00001101b
-10001101b & 00011110b = 00001100b
-10001101b & 00011111b = 00001101b
-10001101b & 00100000b = 00000000b
-10001101b & 00100001b = 00000001b
-10001101b & 00100010b = 00000000b
-10001101b & 00100011b = 00000001b
-10001101b & 00100100b = 00000100b
-10001101b & 00100101b = 00000101b
-10001101b & 00100110b = 00000100b
-10001101b & 00100111b = 00000101b
-10001101b & 00101000b = 00001000b
-10001101b & 00101001b = 00001001b
-10001101b & 00101010b = 00001000b
-10001101b & 00101011b = 00001001b
-10001101b & 00101100b = 00001100b
-10001101b & 00101101b = 00001101b
-10001101b & 00101110b = 00001100b
-10001101b & 00101111b = 00001101b
-10001101b & 00110000b = 00000000b
-10001101b & 00110001b = 00000001b
-10001101b & 00110010b = 00000000b
-10001101b & 00110011b = 00000001b
-10001101b & 00110100b = 00000100b
-10001101b & 00110101b = 00000101b
-10001101b & 00110110b = 00000100b
-10001101b & 00110111b = 00000101b
-10001101b & 00111000b = 00001000b
-10001101b & 00111001b = 00001001b
-10001101b & 00111010b = 00001000b
-10001101b & 00111011b = 00001001b
-10001101b & 00111100b = 00001100b
-10001101b & 00111101b = 00001101b
-10001101b & 00111110b = 00001100b
-10001101b & 00111111b = 00001101b
-10001101b & 01000000b = 00000000b
-10001101b & 01000001b = 00000001b
-10001101b & 01000010b = 00000000b
-10001101b & 01000011b = 00000001b
-10001101b & 01000100b = 00000100b
-10001101b & 01000101b = 00000101b
-10001101b & 01000110b = 00000100b
-10001101b & 01000111b = 00000101b
-10001101b & 01001000b = 00001000b
-10001101b & 01001001b = 00001001b
-10001101b & 01001010b = 00001000b
-10001101b & 01001011b = 00001001b
-10001101b & 01001100b = 00001100b
-10001101b & 01001101b = 00001101b
-10001101b & 01001110b = 00001100b
-10001101b & 01001111b = 00001101b
-10001101b & 01010000b = 00000000b
-10001101b & 01010001b = 00000001b
-10001101b & 01010010b = 00000000b
-10001101b & 01010011b = 00000001b
-10001101b & 01010100b = 00000100b
-10001101b & 01010101b = 00000101b
-10001101b & 01010110b = 00000100b
-10001101b & 01010111b = 00000101b
-10001101b & 01011000b = 00001000b
-10001101b & 01011001b = 00001001b
-10001101b & 01011010b = 00001000b
-10001101b & 01011011b = 00001001b
-10001101b & 01011100b = 00001100b
-10001101b & 01011101b = 00001101b
-10001101b & 01011110b = 00001100b
-10001101b & 01011111b = 00001101b
-10001101b & 01100000b = 00000000b
-10001101b & 01100001b = 00000001b
-10001101b & 01100010b = 00000000b
-10001101b & 01100011b = 00000001b
-10001101b & 01100100b = 00000100b
-10001101b & 01100101b = 00000101b
-10001101b & 01100110b = 00000100b
-10001101b & 01100111b = 00000101b
-10001101b & 01101000b = 00001000b
-10001101b & 01101001b = 00001001b
-10001101b & 01101010b = 00001000b
-10001101b & 01101011b = 00001001b
-10001101b & 01101100b = 00001100b
-10001101b & 01101101b = 00001101b
-10001101b & 01101110b = 00001100b
-10001101b & 01101111b = 00001101b
-10001101b & 01110000b = 00000000b
-10001101b & 01110001b = 00000001b
-10001101b & 01110010b = 00000000b
-10001101b & 01110011b = 00000001b
-10001101b & 01110100b = 00000100b
-10001101b & 01110101b = 00000101b
-10001101b & 01110110b = 00000100b
-10001101b & 01110111b = 00000101b
-10001101b & 01111000b = 00001000b
-10001101b & 01111001b = 00001001b
-10001101b & 01111010b = 00001000b
-10001101b & 01111011b = 00001001b
-10001101b & 01111100b = 00001100b
-10001101b & 01111101b = 00001101b
-10001101b & 01111110b = 00001100b
-10001110b & 10000000b = 10000000b
-10001110b & 10000001b = 10000000b
-10001110b & 10000010b = 10000010b
-10001110b & 10000011b = 10000010b
-10001110b & 10000100b = 10000100b
-10001110b & 10000101b = 10000100b
-10001110b & 10000110b = 10000110b
-10001110b & 10000111b = 10000110b
-10001110b & 10001000b = 10001000b
-10001110b & 10001001b = 10001000b
-10001110b & 10001010b = 10001010b
-10001110b & 10001011b = 10001010b
-10001110b & 10001100b = 10001100b
-10001110b & 10001101b = 10001100b
-10001110b & 10001110b = 10001110b
-10001110b & 10001111b = 10001110b
-10001110b & 10010000b = 10000000b
-10001110b & 10010001b = 10000000b
-10001110b & 10010010b = 10000010b
-10001110b & 10010011b = 10000010b
-10001110b & 10010100b = 10000100b
-10001110b & 10010101b = 10000100b
-10001110b & 10010110b = 10000110b
-10001110b & 10010111b = 10000110b
-10001110b & 10011000b = 10001000b
-10001110b & 10011001b = 10001000b
-10001110b & 10011010b = 10001010b
-10001110b & 10011011b = 10001010b
-10001110b & 10011100b = 10001100b
-10001110b & 10011101b = 10001100b
-10001110b & 10011110b = 10001110b
-10001110b & 10011111b = 10001110b
-10001110b & 10100000b = 10000000b
-10001110b & 10100001b = 10000000b
-10001110b & 10100010b = 10000010b
-10001110b & 10100011b = 10000010b
-10001110b & 10100100b = 10000100b
-10001110b & 10100101b = 10000100b
-10001110b & 10100110b = 10000110b
-10001110b & 10100111b = 10000110b
-10001110b & 10101000b = 10001000b
-10001110b & 10101001b = 10001000b
-10001110b & 10101010b = 10001010b
-10001110b & 10101011b = 10001010b
-10001110b & 10101100b = 10001100b
-10001110b & 10101101b = 10001100b
-10001110b & 10101110b = 10001110b
-10001110b & 10101111b = 10001110b
-10001110b & 10110000b = 10000000b
-10001110b & 10110001b = 10000000b
-10001110b & 10110010b = 10000010b
-10001110b & 10110011b = 10000010b
-10001110b & 10110100b = 10000100b
-10001110b & 10110101b = 10000100b
-10001110b & 10110110b = 10000110b
-10001110b & 10110111b = 10000110b
-10001110b & 10111000b = 10001000b
-10001110b & 10111001b = 10001000b
-10001110b & 10111010b = 10001010b
-10001110b & 10111011b = 10001010b
-10001110b & 10111100b = 10001100b
-10001110b & 10111101b = 10001100b
-10001110b & 10111110b = 10001110b
-10001110b & 10111111b = 10001110b
-10001110b & 11000000b = 10000000b
-10001110b & 11000001b = 10000000b
-10001110b & 11000010b = 10000010b
-10001110b & 11000011b = 10000010b
-10001110b & 11000100b = 10000100b
-10001110b & 11000101b = 10000100b
-10001110b & 11000110b = 10000110b
-10001110b & 11000111b = 10000110b
-10001110b & 11001000b = 10001000b
-10001110b & 11001001b = 10001000b
-10001110b & 11001010b = 10001010b
-10001110b & 11001011b = 10001010b
-10001110b & 11001100b = 10001100b
-10001110b & 11001101b = 10001100b
-10001110b & 11001110b = 10001110b
-10001110b & 11001111b = 10001110b
-10001110b & 11010000b = 10000000b
-10001110b & 11010001b = 10000000b
-10001110b & 11010010b = 10000010b
-10001110b & 11010011b = 10000010b
-10001110b & 11010100b = 10000100b
-10001110b & 11010101b = 10000100b
-10001110b & 11010110b = 10000110b
-10001110b & 11010111b = 10000110b
-10001110b & 11011000b = 10001000b
-10001110b & 11011001b = 10001000b
-10001110b & 11011010b = 10001010b
-10001110b & 11011011b = 10001010b
-10001110b & 11011100b = 10001100b
-10001110b & 11011101b = 10001100b
-10001110b & 11011110b = 10001110b
-10001110b & 11011111b = 10001110b
-10001110b & 11100000b = 10000000b
-10001110b & 11100001b = 10000000b
-10001110b & 11100010b = 10000010b
-10001110b & 11100011b = 10000010b
-10001110b & 11100100b = 10000100b
-10001110b & 11100101b = 10000100b
-10001110b & 11100110b = 10000110b
-10001110b & 11100111b = 10000110b
-10001110b & 11101000b = 10001000b
-10001110b & 11101001b = 10001000b
-10001110b & 11101010b = 10001010b
-10001110b & 11101011b = 10001010b
-10001110b & 11101100b = 10001100b
-10001110b & 11101101b = 10001100b
-10001110b & 11101110b = 10001110b
-10001110b & 11101111b = 10001110b
-10001110b & 11110000b = 10000000b
-10001110b & 11110001b = 10000000b
-10001110b & 11110010b = 10000010b
-10001110b & 11110011b = 10000010b
-10001110b & 11110100b = 10000100b
-10001110b & 11110101b = 10000100b
-10001110b & 11110110b = 10000110b
-10001110b & 11110111b = 10000110b
-10001110b & 11111000b = 10001000b
-10001110b & 11111001b = 10001000b
-10001110b & 11111010b = 10001010b
-10001110b & 11111011b = 10001010b
-10001110b & 11111100b = 10001100b
-10001110b & 11111101b = 10001100b
-10001110b & 11111110b = 10001110b
-10001110b & 11111111b = 10001110b
-10001110b & 00000000b = 00000000b
-10001110b & 00000001b = 00000000b
-10001110b & 00000010b = 00000010b
-10001110b & 00000011b = 00000010b
-10001110b & 00000100b = 00000100b
-10001110b & 00000101b = 00000100b
-10001110b & 00000110b = 00000110b
-10001110b & 00000111b = 00000110b
-10001110b & 00001000b = 00001000b
-10001110b & 00001001b = 00001000b
-10001110b & 00001010b = 00001010b
-10001110b & 00001011b = 00001010b
-10001110b & 00001100b = 00001100b
-10001110b & 00001101b = 00001100b
-10001110b & 00001110b = 00001110b
-10001110b & 00001111b = 00001110b
-10001110b & 00010000b = 00000000b
-10001110b & 00010001b = 00000000b
-10001110b & 00010010b = 00000010b
-10001110b & 00010011b = 00000010b
-10001110b & 00010100b = 00000100b
-10001110b & 00010101b = 00000100b
-10001110b & 00010110b = 00000110b
-10001110b & 00010111b = 00000110b
-10001110b & 00011000b = 00001000b
-10001110b & 00011001b = 00001000b
-10001110b & 00011010b = 00001010b
-10001110b & 00011011b = 00001010b
-10001110b & 00011100b = 00001100b
-10001110b & 00011101b = 00001100b
-10001110b & 00011110b = 00001110b
-10001110b & 00011111b = 00001110b
-10001110b & 00100000b = 00000000b
-10001110b & 00100001b = 00000000b
-10001110b & 00100010b = 00000010b
-10001110b & 00100011b = 00000010b
-10001110b & 00100100b = 00000100b
-10001110b & 00100101b = 00000100b
-10001110b & 00100110b = 00000110b
-10001110b & 00100111b = 00000110b
-10001110b & 00101000b = 00001000b
-10001110b & 00101001b = 00001000b
-10001110b & 00101010b = 00001010b
-10001110b & 00101011b = 00001010b
-10001110b & 00101100b = 00001100b
-10001110b & 00101101b = 00001100b
-10001110b & 00101110b = 00001110b
-10001110b & 00101111b = 00001110b
-10001110b & 00110000b = 00000000b
-10001110b & 00110001b = 00000000b
-10001110b & 00110010b = 00000010b
-10001110b & 00110011b = 00000010b
-10001110b & 00110100b = 00000100b
-10001110b & 00110101b = 00000100b
-10001110b & 00110110b = 00000110b
-10001110b & 00110111b = 00000110b
-10001110b & 00111000b = 00001000b
-10001110b & 00111001b = 00001000b
-10001110b & 00111010b = 00001010b
-10001110b & 00111011b = 00001010b
-10001110b & 00111100b = 00001100b
-10001110b & 00111101b = 00001100b
-10001110b & 00111110b = 00001110b
-10001110b & 00111111b = 00001110b
-10001110b & 01000000b = 00000000b
-10001110b & 01000001b = 00000000b
-10001110b & 01000010b = 00000010b
-10001110b & 01000011b = 00000010b
-10001110b & 01000100b = 00000100b
-10001110b & 01000101b = 00000100b
-10001110b & 01000110b = 00000110b
-10001110b & 01000111b = 00000110b
-10001110b & 01001000b = 00001000b
-10001110b & 01001001b = 00001000b
-10001110b & 01001010b = 00001010b
-10001110b & 01001011b = 00001010b
-10001110b & 01001100b = 00001100b
-10001110b & 01001101b = 00001100b
-10001110b & 01001110b = 00001110b
-10001110b & 01001111b = 00001110b
-10001110b & 01010000b = 00000000b
-10001110b & 01010001b = 00000000b
-10001110b & 01010010b = 00000010b
-10001110b & 01010011b = 00000010b
-10001110b & 01010100b = 00000100b
-10001110b & 01010101b = 00000100b
-10001110b & 01010110b = 00000110b
-10001110b & 01010111b = 00000110b
-10001110b & 01011000b = 00001000b
-10001110b & 01011001b = 00001000b
-10001110b & 01011010b = 00001010b
-10001110b & 01011011b = 00001010b
-10001110b & 01011100b = 00001100b
-10001110b & 01011101b = 00001100b
-10001110b & 01011110b = 00001110b
-10001110b & 01011111b = 00001110b
-10001110b & 01100000b = 00000000b
-10001110b & 01100001b = 00000000b
-10001110b & 01100010b = 00000010b
-10001110b & 01100011b = 00000010b
-10001110b & 01100100b = 00000100b
-10001110b & 01100101b = 00000100b
-10001110b & 01100110b = 00000110b
-10001110b & 01100111b = 00000110b
-10001110b & 01101000b = 00001000b
-10001110b & 01101001b = 00001000b
-10001110b & 01101010b = 00001010b
-10001110b & 01101011b = 00001010b
-10001110b & 01101100b = 00001100b
-10001110b & 01101101b = 00001100b
-10001110b & 01101110b = 00001110b
-10001110b & 01101111b = 00001110b
-10001110b & 01110000b = 00000000b
-10001110b & 01110001b = 00000000b
-10001110b & 01110010b = 00000010b
-10001110b & 01110011b = 00000010b
-10001110b & 01110100b = 00000100b
-10001110b & 01110101b = 00000100b
-10001110b & 01110110b = 00000110b
-10001110b & 01110111b = 00000110b
-10001110b & 01111000b = 00001000b
-10001110b & 01111001b = 00001000b
-10001110b & 01111010b = 00001010b
-10001110b & 01111011b = 00001010b
-10001110b & 01111100b = 00001100b
-10001110b & 01111101b = 00001100b
-10001110b & 01111110b = 00001110b
-10001111b & 10000000b = 10000000b
-10001111b & 10000001b = 10000001b
-10001111b & 10000010b = 10000010b
-10001111b & 10000011b = 10000011b
-10001111b & 10000100b = 10000100b
-10001111b & 10000101b = 10000101b
-10001111b & 10000110b = 10000110b
-10001111b & 10000111b = 10000111b
-10001111b & 10001000b = 10001000b
-10001111b & 10001001b = 10001001b
-10001111b & 10001010b = 10001010b
-10001111b & 10001011b = 10001011b
-10001111b & 10001100b = 10001100b
-10001111b & 10001101b = 10001101b
-10001111b & 10001110b = 10001110b
-10001111b & 10001111b = 10001111b
-10001111b & 10010000b = 10000000b
-10001111b & 10010001b = 10000001b
-10001111b & 10010010b = 10000010b
-10001111b & 10010011b = 10000011b
-10001111b & 10010100b = 10000100b
-10001111b & 10010101b = 10000101b
-10001111b & 10010110b = 10000110b
-10001111b & 10010111b = 10000111b
-10001111b & 10011000b = 10001000b
-10001111b & 10011001b = 10001001b
-10001111b & 10011010b = 10001010b
-10001111b & 10011011b = 10001011b
-10001111b & 10011100b = 10001100b
-10001111b & 10011101b = 10001101b
-10001111b & 10011110b = 10001110b
-10001111b & 10011111b = 10001111b
-10001111b & 10100000b = 10000000b
-10001111b & 10100001b = 10000001b
-10001111b & 10100010b = 10000010b
-10001111b & 10100011b = 10000011b
-10001111b & 10100100b = 10000100b
-10001111b & 10100101b = 10000101b
-10001111b & 10100110b = 10000110b
-10001111b & 10100111b = 10000111b
-10001111b & 10101000b = 10001000b
-10001111b & 10101001b = 10001001b
-10001111b & 10101010b = 10001010b
-10001111b & 10101011b = 10001011b
-10001111b & 10101100b = 10001100b
-10001111b & 10101101b = 10001101b
-10001111b & 10101110b = 10001110b
-10001111b & 10101111b = 10001111b
-10001111b & 10110000b = 10000000b
-10001111b & 10110001b = 10000001b
-10001111b & 10110010b = 10000010b
-10001111b & 10110011b = 10000011b
-10001111b & 10110100b = 10000100b
-10001111b & 10110101b = 10000101b
-10001111b & 10110110b = 10000110b
-10001111b & 10110111b = 10000111b
-10001111b & 10111000b = 10001000b
-10001111b & 10111001b = 10001001b
-10001111b & 10111010b = 10001010b
-10001111b & 10111011b = 10001011b
-10001111b & 10111100b = 10001100b
-10001111b & 10111101b = 10001101b
-10001111b & 10111110b = 10001110b
-10001111b & 10111111b = 10001111b
-10001111b & 11000000b = 10000000b
-10001111b & 11000001b = 10000001b
-10001111b & 11000010b = 10000010b
-10001111b & 11000011b = 10000011b
-10001111b & 11000100b = 10000100b
-10001111b & 11000101b = 10000101b
-10001111b & 11000110b = 10000110b
-10001111b & 11000111b = 10000111b
-10001111b & 11001000b = 10001000b
-10001111b & 11001001b = 10001001b
-10001111b & 11001010b = 10001010b
-10001111b & 11001011b = 10001011b
-10001111b & 11001100b = 10001100b
-10001111b & 11001101b = 10001101b
-10001111b & 11001110b = 10001110b
-10001111b & 11001111b = 10001111b
-10001111b & 11010000b = 10000000b
-10001111b & 11010001b = 10000001b
-10001111b & 11010010b = 10000010b
-10001111b & 11010011b = 10000011b
-10001111b & 11010100b = 10000100b
-10001111b & 11010101b = 10000101b
-10001111b & 11010110b = 10000110b
-10001111b & 11010111b = 10000111b
-10001111b & 11011000b = 10001000b
-10001111b & 11011001b = 10001001b
-10001111b & 11011010b = 10001010b
-10001111b & 11011011b = 10001011b
-10001111b & 11011100b = 10001100b
-10001111b & 11011101b = 10001101b
-10001111b & 11011110b = 10001110b
-10001111b & 11011111b = 10001111b
-10001111b & 11100000b = 10000000b
-10001111b & 11100001b = 10000001b
-10001111b & 11100010b = 10000010b
-10001111b & 11100011b = 10000011b
-10001111b & 11100100b = 10000100b
-10001111b & 11100101b = 10000101b
-10001111b & 11100110b = 10000110b
-10001111b & 11100111b = 10000111b
-10001111b & 11101000b = 10001000b
-10001111b & 11101001b = 10001001b
-10001111b & 11101010b = 10001010b
-10001111b & 11101011b = 10001011b
-10001111b & 11101100b = 10001100b
-10001111b & 11101101b = 10001101b
-10001111b & 11101110b = 10001110b
-10001111b & 11101111b = 10001111b
-10001111b & 11110000b = 10000000b
-10001111b & 11110001b = 10000001b
-10001111b & 11110010b = 10000010b
-10001111b & 11110011b = 10000011b
-10001111b & 11110100b = 10000100b
-10001111b & 11110101b = 10000101b
-10001111b & 11110110b = 10000110b
-10001111b & 11110111b = 10000111b
-10001111b & 11111000b = 10001000b
-10001111b & 11111001b = 10001001b
-10001111b & 11111010b = 10001010b
-10001111b & 11111011b = 10001011b
-10001111b & 11111100b = 10001100b
-10001111b & 11111101b = 10001101b
-10001111b & 11111110b = 10001110b
-10001111b & 11111111b = 10001111b
-10001111b & 00000000b = 00000000b
-10001111b & 00000001b = 00000001b
-10001111b & 00000010b = 00000010b
-10001111b & 00000011b = 00000011b
-10001111b & 00000100b = 00000100b
-10001111b & 00000101b = 00000101b
-10001111b & 00000110b = 00000110b
-10001111b & 00000111b = 00000111b
-10001111b & 00001000b = 00001000b
-10001111b & 00001001b = 00001001b
-10001111b & 00001010b = 00001010b
-10001111b & 00001011b = 00001011b
-10001111b & 00001100b = 00001100b
-10001111b & 00001101b = 00001101b
-10001111b & 00001110b = 00001110b
-10001111b & 00001111b = 00001111b
-10001111b & 00010000b = 00000000b
-10001111b & 00010001b = 00000001b
-10001111b & 00010010b = 00000010b
-10001111b & 00010011b = 00000011b
-10001111b & 00010100b = 00000100b
-10001111b & 00010101b = 00000101b
-10001111b & 00010110b = 00000110b
-10001111b & 00010111b = 00000111b
-10001111b & 00011000b = 00001000b
-10001111b & 00011001b = 00001001b
-10001111b & 00011010b = 00001010b
-10001111b & 00011011b = 00001011b
-10001111b & 00011100b = 00001100b
-10001111b & 00011101b = 00001101b
-10001111b & 00011110b = 00001110b
-10001111b & 00011111b = 00001111b
-10001111b & 00100000b = 00000000b
-10001111b & 00100001b = 00000001b
-10001111b & 00100010b = 00000010b
-10001111b & 00100011b = 00000011b
-10001111b & 00100100b = 00000100b
-10001111b & 00100101b = 00000101b
-10001111b & 00100110b = 00000110b
-10001111b & 00100111b = 00000111b
-10001111b & 00101000b = 00001000b
-10001111b & 00101001b = 00001001b
-10001111b & 00101010b = 00001010b
-10001111b & 00101011b = 00001011b
-10001111b & 00101100b = 00001100b
-10001111b & 00101101b = 00001101b
-10001111b & 00101110b = 00001110b
-10001111b & 00101111b = 00001111b
-10001111b & 00110000b = 00000000b
-10001111b & 00110001b = 00000001b
-10001111b & 00110010b = 00000010b
-10001111b & 00110011b = 00000011b
-10001111b & 00110100b = 00000100b
-10001111b & 00110101b = 00000101b
-10001111b & 00110110b = 00000110b
-10001111b & 00110111b = 00000111b
-10001111b & 00111000b = 00001000b
-10001111b & 00111001b = 00001001b
-10001111b & 00111010b = 00001010b
-10001111b & 00111011b = 00001011b
-10001111b & 00111100b = 00001100b
-10001111b & 00111101b = 00001101b
-10001111b & 00111110b = 00001110b
-10001111b & 00111111b = 00001111b
-10001111b & 01000000b = 00000000b
-10001111b & 01000001b = 00000001b
-10001111b & 01000010b = 00000010b
-10001111b & 01000011b = 00000011b
-10001111b & 01000100b = 00000100b
-10001111b & 01000101b = 00000101b
-10001111b & 01000110b = 00000110b
-10001111b & 01000111b = 00000111b
-10001111b & 01001000b = 00001000b
-10001111b & 01001001b = 00001001b
-10001111b & 01001010b = 00001010b
-10001111b & 01001011b = 00001011b
-10001111b & 01001100b = 00001100b
-10001111b & 01001101b = 00001101b
-10001111b & 01001110b = 00001110b
-10001111b & 01001111b = 00001111b
-10001111b & 01010000b = 00000000b
-10001111b & 01010001b = 00000001b
-10001111b & 01010010b = 00000010b
-10001111b & 01010011b = 00000011b
-10001111b & 01010100b = 00000100b
-10001111b & 01010101b = 00000101b
-10001111b & 01010110b = 00000110b
-10001111b & 01010111b = 00000111b
-10001111b & 01011000b = 00001000b
-10001111b & 01011001b = 00001001b
-10001111b & 01011010b = 00001010b
-10001111b & 01011011b = 00001011b
-10001111b & 01011100b = 00001100b
-10001111b & 01011101b = 00001101b
-10001111b & 01011110b = 00001110b
-10001111b & 01011111b = 00001111b
-10001111b & 01100000b = 00000000b
-10001111b & 01100001b = 00000001b
-10001111b & 01100010b = 00000010b
-10001111b & 01100011b = 00000011b
-10001111b & 01100100b = 00000100b
-10001111b & 01100101b = 00000101b
-10001111b & 01100110b = 00000110b
-10001111b & 01100111b = 00000111b
-10001111b & 01101000b = 00001000b
-10001111b & 01101001b = 00001001b
-10001111b & 01101010b = 00001010b
-10001111b & 01101011b = 00001011b
-10001111b & 01101100b = 00001100b
-10001111b & 01101101b = 00001101b
-10001111b & 01101110b = 00001110b
-10001111b & 01101111b = 00001111b
-10001111b & 01110000b = 00000000b
-10001111b & 01110001b = 00000001b
-10001111b & 01110010b = 00000010b
-10001111b & 01110011b = 00000011b
-10001111b & 01110100b = 00000100b
-10001111b & 01110101b = 00000101b
-10001111b & 01110110b = 00000110b
-10001111b & 01110111b = 00000111b
-10001111b & 01111000b = 00001000b
-10001111b & 01111001b = 00001001b
-10001111b & 01111010b = 00001010b
-10001111b & 01111011b = 00001011b
-10001111b & 01111100b = 00001100b
-10001111b & 01111101b = 00001101b
-10001111b & 01111110b = 00001110b
-10010000b & 10000000b = 10000000b
-10010000b & 10000001b = 10000000b
-10010000b & 10000010b = 10000000b
-10010000b & 10000011b = 10000000b
-10010000b & 10000100b = 10000000b
-10010000b & 10000101b = 10000000b
-10010000b & 10000110b = 10000000b
-10010000b & 10000111b = 10000000b
-10010000b & 10001000b = 10000000b
-10010000b & 10001001b = 10000000b
-10010000b & 10001010b = 10000000b
-10010000b & 10001011b = 10000000b
-10010000b & 10001100b = 10000000b
-10010000b & 10001101b = 10000000b
-10010000b & 10001110b = 10000000b
-10010000b & 10001111b = 10000000b
-10010000b & 10010000b = 10010000b
-10010000b & 10010001b = 10010000b
-10010000b & 10010010b = 10010000b
-10010000b & 10010011b = 10010000b
-10010000b & 10010100b = 10010000b
-10010000b & 10010101b = 10010000b
-10010000b & 10010110b = 10010000b
-10010000b & 10010111b = 10010000b
-10010000b & 10011000b = 10010000b
-10010000b & 10011001b = 10010000b
-10010000b & 10011010b = 10010000b
-10010000b & 10011011b = 10010000b
-10010000b & 10011100b = 10010000b
-10010000b & 10011101b = 10010000b
-10010000b & 10011110b = 10010000b
-10010000b & 10011111b = 10010000b
-10010000b & 10100000b = 10000000b
-10010000b & 10100001b = 10000000b
-10010000b & 10100010b = 10000000b
-10010000b & 10100011b = 10000000b
-10010000b & 10100100b = 10000000b
-10010000b & 10100101b = 10000000b
-10010000b & 10100110b = 10000000b
-10010000b & 10100111b = 10000000b
-10010000b & 10101000b = 10000000b
-10010000b & 10101001b = 10000000b
-10010000b & 10101010b = 10000000b
-10010000b & 10101011b = 10000000b
-10010000b & 10101100b = 10000000b
-10010000b & 10101101b = 10000000b
-10010000b & 10101110b = 10000000b
-10010000b & 10101111b = 10000000b
-10010000b & 10110000b = 10010000b
-10010000b & 10110001b = 10010000b
-10010000b & 10110010b = 10010000b
-10010000b & 10110011b = 10010000b
-10010000b & 10110100b = 10010000b
-10010000b & 10110101b = 10010000b
-10010000b & 10110110b = 10010000b
-10010000b & 10110111b = 10010000b
-10010000b & 10111000b = 10010000b
-10010000b & 10111001b = 10010000b
-10010000b & 10111010b = 10010000b
-10010000b & 10111011b = 10010000b
-10010000b & 10111100b = 10010000b
-10010000b & 10111101b = 10010000b
-10010000b & 10111110b = 10010000b
-10010000b & 10111111b = 10010000b
-10010000b & 11000000b = 10000000b
-10010000b & 11000001b = 10000000b
-10010000b & 11000010b = 10000000b
-10010000b & 11000011b = 10000000b
-10010000b & 11000100b = 10000000b
-10010000b & 11000101b = 10000000b
-10010000b & 11000110b = 10000000b
-10010000b & 11000111b = 10000000b
-10010000b & 11001000b = 10000000b
-10010000b & 11001001b = 10000000b
-10010000b & 11001010b = 10000000b
-10010000b & 11001011b = 10000000b
-10010000b & 11001100b = 10000000b
-10010000b & 11001101b = 10000000b
-10010000b & 11001110b = 10000000b
-10010000b & 11001111b = 10000000b
-10010000b & 11010000b = 10010000b
-10010000b & 11010001b = 10010000b
-10010000b & 11010010b = 10010000b
-10010000b & 11010011b = 10010000b
-10010000b & 11010100b = 10010000b
-10010000b & 11010101b = 10010000b
-10010000b & 11010110b = 10010000b
-10010000b & 11010111b = 10010000b
-10010000b & 11011000b = 10010000b
-10010000b & 11011001b = 10010000b
-10010000b & 11011010b = 10010000b
-10010000b & 11011011b = 10010000b
-10010000b & 11011100b = 10010000b
-10010000b & 11011101b = 10010000b
-10010000b & 11011110b = 10010000b
-10010000b & 11011111b = 10010000b
-10010000b & 11100000b = 10000000b
-10010000b & 11100001b = 10000000b
-10010000b & 11100010b = 10000000b
-10010000b & 11100011b = 10000000b
-10010000b & 11100100b = 10000000b
-10010000b & 11100101b = 10000000b
-10010000b & 11100110b = 10000000b
-10010000b & 11100111b = 10000000b
-10010000b & 11101000b = 10000000b
-10010000b & 11101001b = 10000000b
-10010000b & 11101010b = 10000000b
-10010000b & 11101011b = 10000000b
-10010000b & 11101100b = 10000000b
-10010000b & 11101101b = 10000000b
-10010000b & 11101110b = 10000000b
-10010000b & 11101111b = 10000000b
-10010000b & 11110000b = 10010000b
-10010000b & 11110001b = 10010000b
-10010000b & 11110010b = 10010000b
-10010000b & 11110011b = 10010000b
-10010000b & 11110100b = 10010000b
-10010000b & 11110101b = 10010000b
-10010000b & 11110110b = 10010000b
-10010000b & 11110111b = 10010000b
-10010000b & 11111000b = 10010000b
-10010000b & 11111001b = 10010000b
-10010000b & 11111010b = 10010000b
-10010000b & 11111011b = 10010000b
-10010000b & 11111100b = 10010000b
-10010000b & 11111101b = 10010000b
-10010000b & 11111110b = 10010000b
-10010000b & 11111111b = 10010000b
-10010000b & 00000000b = 00000000b
-10010000b & 00000001b = 00000000b
-10010000b & 00000010b = 00000000b
-10010000b & 00000011b = 00000000b
-10010000b & 00000100b = 00000000b
-10010000b & 00000101b = 00000000b
-10010000b & 00000110b = 00000000b
-10010000b & 00000111b = 00000000b
-10010000b & 00001000b = 00000000b
-10010000b & 00001001b = 00000000b
-10010000b & 00001010b = 00000000b
-10010000b & 00001011b = 00000000b
-10010000b & 00001100b = 00000000b
-10010000b & 00001101b = 00000000b
-10010000b & 00001110b = 00000000b
-10010000b & 00001111b = 00000000b
-10010000b & 00010000b = 00010000b
-10010000b & 00010001b = 00010000b
-10010000b & 00010010b = 00010000b
-10010000b & 00010011b = 00010000b
-10010000b & 00010100b = 00010000b
-10010000b & 00010101b = 00010000b
-10010000b & 00010110b = 00010000b
-10010000b & 00010111b = 00010000b
-10010000b & 00011000b = 00010000b
-10010000b & 00011001b = 00010000b
-10010000b & 00011010b = 00010000b
-10010000b & 00011011b = 00010000b
-10010000b & 00011100b = 00010000b
-10010000b & 00011101b = 00010000b
-10010000b & 00011110b = 00010000b
-10010000b & 00011111b = 00010000b
-10010000b & 00100000b = 00000000b
-10010000b & 00100001b = 00000000b
-10010000b & 00100010b = 00000000b
-10010000b & 00100011b = 00000000b
-10010000b & 00100100b = 00000000b
-10010000b & 00100101b = 00000000b
-10010000b & 00100110b = 00000000b
-10010000b & 00100111b = 00000000b
-10010000b & 00101000b = 00000000b
-10010000b & 00101001b = 00000000b
-10010000b & 00101010b = 00000000b
-10010000b & 00101011b = 00000000b
-10010000b & 00101100b = 00000000b
-10010000b & 00101101b = 00000000b
-10010000b & 00101110b = 00000000b
-10010000b & 00101111b = 00000000b
-10010000b & 00110000b = 00010000b
-10010000b & 00110001b = 00010000b
-10010000b & 00110010b = 00010000b
-10010000b & 00110011b = 00010000b
-10010000b & 00110100b = 00010000b
-10010000b & 00110101b = 00010000b
-10010000b & 00110110b = 00010000b
-10010000b & 00110111b = 00010000b
-10010000b & 00111000b = 00010000b
-10010000b & 00111001b = 00010000b
-10010000b & 00111010b = 00010000b
-10010000b & 00111011b = 00010000b
-10010000b & 00111100b = 00010000b
-10010000b & 00111101b = 00010000b
-10010000b & 00111110b = 00010000b
-10010000b & 00111111b = 00010000b
-10010000b & 01000000b = 00000000b
-10010000b & 01000001b = 00000000b
-10010000b & 01000010b = 00000000b
-10010000b & 01000011b = 00000000b
-10010000b & 01000100b = 00000000b
-10010000b & 01000101b = 00000000b
-10010000b & 01000110b = 00000000b
-10010000b & 01000111b = 00000000b
-10010000b & 01001000b = 00000000b
-10010000b & 01001001b = 00000000b
-10010000b & 01001010b = 00000000b
-10010000b & 01001011b = 00000000b
-10010000b & 01001100b = 00000000b
-10010000b & 01001101b = 00000000b
-10010000b & 01001110b = 00000000b
-10010000b & 01001111b = 00000000b
-10010000b & 01010000b = 00010000b
-10010000b & 01010001b = 00010000b
-10010000b & 01010010b = 00010000b
-10010000b & 01010011b = 00010000b
-10010000b & 01010100b = 00010000b
-10010000b & 01010101b = 00010000b
-10010000b & 01010110b = 00010000b
-10010000b & 01010111b = 00010000b
-10010000b & 01011000b = 00010000b
-10010000b & 01011001b = 00010000b
-10010000b & 01011010b = 00010000b
-10010000b & 01011011b = 00010000b
-10010000b & 01011100b = 00010000b
-10010000b & 01011101b = 00010000b
-10010000b & 01011110b = 00010000b
-10010000b & 01011111b = 00010000b
-10010000b & 01100000b = 00000000b
-10010000b & 01100001b = 00000000b
-10010000b & 01100010b = 00000000b
-10010000b & 01100011b = 00000000b
-10010000b & 01100100b = 00000000b
-10010000b & 01100101b = 00000000b
-10010000b & 01100110b = 00000000b
-10010000b & 01100111b = 00000000b
-10010000b & 01101000b = 00000000b
-10010000b & 01101001b = 00000000b
-10010000b & 01101010b = 00000000b
-10010000b & 01101011b = 00000000b
-10010000b & 01101100b = 00000000b
-10010000b & 01101101b = 00000000b
-10010000b & 01101110b = 00000000b
-10010000b & 01101111b = 00000000b
-10010000b & 01110000b = 00010000b
-10010000b & 01110001b = 00010000b
-10010000b & 01110010b = 00010000b
-10010000b & 01110011b = 00010000b
-10010000b & 01110100b = 00010000b
-10010000b & 01110101b = 00010000b
-10010000b & 01110110b = 00010000b
-10010000b & 01110111b = 00010000b
-10010000b & 01111000b = 00010000b
-10010000b & 01111001b = 00010000b
-10010000b & 01111010b = 00010000b
-10010000b & 01111011b = 00010000b
-10010000b & 01111100b = 00010000b
-10010000b & 01111101b = 00010000b
-10010000b & 01111110b = 00010000b
-10010001b & 10000000b = 10000000b
-10010001b & 10000001b = 10000001b
-10010001b & 10000010b = 10000000b
-10010001b & 10000011b = 10000001b
-10010001b & 10000100b = 10000000b
-10010001b & 10000101b = 10000001b
-10010001b & 10000110b = 10000000b
-10010001b & 10000111b = 10000001b
-10010001b & 10001000b = 10000000b
-10010001b & 10001001b = 10000001b
-10010001b & 10001010b = 10000000b
-10010001b & 10001011b = 10000001b
-10010001b & 10001100b = 10000000b
-10010001b & 10001101b = 10000001b
-10010001b & 10001110b = 10000000b
-10010001b & 10001111b = 10000001b
-10010001b & 10010000b = 10010000b
-10010001b & 10010001b = 10010001b
-10010001b & 10010010b = 10010000b
-10010001b & 10010011b = 10010001b
-10010001b & 10010100b = 10010000b
-10010001b & 10010101b = 10010001b
-10010001b & 10010110b = 10010000b
-10010001b & 10010111b = 10010001b
-10010001b & 10011000b = 10010000b
-10010001b & 10011001b = 10010001b
-10010001b & 10011010b = 10010000b
-10010001b & 10011011b = 10010001b
-10010001b & 10011100b = 10010000b
-10010001b & 10011101b = 10010001b
-10010001b & 10011110b = 10010000b
-10010001b & 10011111b = 10010001b
-10010001b & 10100000b = 10000000b
-10010001b & 10100001b = 10000001b
-10010001b & 10100010b = 10000000b
-10010001b & 10100011b = 10000001b
-10010001b & 10100100b = 10000000b
-10010001b & 10100101b = 10000001b
-10010001b & 10100110b = 10000000b
-10010001b & 10100111b = 10000001b
-10010001b & 10101000b = 10000000b
-10010001b & 10101001b = 10000001b
-10010001b & 10101010b = 10000000b
-10010001b & 10101011b = 10000001b
-10010001b & 10101100b = 10000000b
-10010001b & 10101101b = 10000001b
-10010001b & 10101110b = 10000000b
-10010001b & 10101111b = 10000001b
-10010001b & 10110000b = 10010000b
-10010001b & 10110001b = 10010001b
-10010001b & 10110010b = 10010000b
-10010001b & 10110011b = 10010001b
-10010001b & 10110100b = 10010000b
-10010001b & 10110101b = 10010001b
-10010001b & 10110110b = 10010000b
-10010001b & 10110111b = 10010001b
-10010001b & 10111000b = 10010000b
-10010001b & 10111001b = 10010001b
-10010001b & 10111010b = 10010000b
-10010001b & 10111011b = 10010001b
-10010001b & 10111100b = 10010000b
-10010001b & 10111101b = 10010001b
-10010001b & 10111110b = 10010000b
-10010001b & 10111111b = 10010001b
-10010001b & 11000000b = 10000000b
-10010001b & 11000001b = 10000001b
-10010001b & 11000010b = 10000000b
-10010001b & 11000011b = 10000001b
-10010001b & 11000100b = 10000000b
-10010001b & 11000101b = 10000001b
-10010001b & 11000110b = 10000000b
-10010001b & 11000111b = 10000001b
-10010001b & 11001000b = 10000000b
-10010001b & 11001001b = 10000001b
-10010001b & 11001010b = 10000000b
-10010001b & 11001011b = 10000001b
-10010001b & 11001100b = 10000000b
-10010001b & 11001101b = 10000001b
-10010001b & 11001110b = 10000000b
-10010001b & 11001111b = 10000001b
-10010001b & 11010000b = 10010000b
-10010001b & 11010001b = 10010001b
-10010001b & 11010010b = 10010000b
-10010001b & 11010011b = 10010001b
-10010001b & 11010100b = 10010000b
-10010001b & 11010101b = 10010001b
-10010001b & 11010110b = 10010000b
-10010001b & 11010111b = 10010001b
-10010001b & 11011000b = 10010000b
-10010001b & 11011001b = 10010001b
-10010001b & 11011010b = 10010000b
-10010001b & 11011011b = 10010001b
-10010001b & 11011100b = 10010000b
-10010001b & 11011101b = 10010001b
-10010001b & 11011110b = 10010000b
-10010001b & 11011111b = 10010001b
-10010001b & 11100000b = 10000000b
-10010001b & 11100001b = 10000001b
-10010001b & 11100010b = 10000000b
-10010001b & 11100011b = 10000001b
-10010001b & 11100100b = 10000000b
-10010001b & 11100101b = 10000001b
-10010001b & 11100110b = 10000000b
-10010001b & 11100111b = 10000001b
-10010001b & 11101000b = 10000000b
-10010001b & 11101001b = 10000001b
-10010001b & 11101010b = 10000000b
-10010001b & 11101011b = 10000001b
-10010001b & 11101100b = 10000000b
-10010001b & 11101101b = 10000001b
-10010001b & 11101110b = 10000000b
-10010001b & 11101111b = 10000001b
-10010001b & 11110000b = 10010000b
-10010001b & 11110001b = 10010001b
-10010001b & 11110010b = 10010000b
-10010001b & 11110011b = 10010001b
-10010001b & 11110100b = 10010000b
-10010001b & 11110101b = 10010001b
-10010001b & 11110110b = 10010000b
-10010001b & 11110111b = 10010001b
-10010001b & 11111000b = 10010000b
-10010001b & 11111001b = 10010001b
-10010001b & 11111010b = 10010000b
-10010001b & 11111011b = 10010001b
-10010001b & 11111100b = 10010000b
-10010001b & 11111101b = 10010001b
-10010001b & 11111110b = 10010000b
-10010001b & 11111111b = 10010001b
-10010001b & 00000000b = 00000000b
-10010001b & 00000001b = 00000001b
-10010001b & 00000010b = 00000000b
-10010001b & 00000011b = 00000001b
-10010001b & 00000100b = 00000000b
-10010001b & 00000101b = 00000001b
-10010001b & 00000110b = 00000000b
-10010001b & 00000111b = 00000001b
-10010001b & 00001000b = 00000000b
-10010001b & 00001001b = 00000001b
-10010001b & 00001010b = 00000000b
-10010001b & 00001011b = 00000001b
-10010001b & 00001100b = 00000000b
-10010001b & 00001101b = 00000001b
-10010001b & 00001110b = 00000000b
-10010001b & 00001111b = 00000001b
-10010001b & 00010000b = 00010000b
-10010001b & 00010001b = 00010001b
-10010001b & 00010010b = 00010000b
-10010001b & 00010011b = 00010001b
-10010001b & 00010100b = 00010000b
-10010001b & 00010101b = 00010001b
-10010001b & 00010110b = 00010000b
-10010001b & 00010111b = 00010001b
-10010001b & 00011000b = 00010000b
-10010001b & 00011001b = 00010001b
-10010001b & 00011010b = 00010000b
-10010001b & 00011011b = 00010001b
-10010001b & 00011100b = 00010000b
-10010001b & 00011101b = 00010001b
-10010001b & 00011110b = 00010000b
-10010001b & 00011111b = 00010001b
-10010001b & 00100000b = 00000000b
-10010001b & 00100001b = 00000001b
-10010001b & 00100010b = 00000000b
-10010001b & 00100011b = 00000001b
-10010001b & 00100100b = 00000000b
-10010001b & 00100101b = 00000001b
-10010001b & 00100110b = 00000000b
-10010001b & 00100111b = 00000001b
-10010001b & 00101000b = 00000000b
-10010001b & 00101001b = 00000001b
-10010001b & 00101010b = 00000000b
-10010001b & 00101011b = 00000001b
-10010001b & 00101100b = 00000000b
-10010001b & 00101101b = 00000001b
-10010001b & 00101110b = 00000000b
-10010001b & 00101111b = 00000001b
-10010001b & 00110000b = 00010000b
-10010001b & 00110001b = 00010001b
-10010001b & 00110010b = 00010000b
-10010001b & 00110011b = 00010001b
-10010001b & 00110100b = 00010000b
-10010001b & 00110101b = 00010001b
-10010001b & 00110110b = 00010000b
-10010001b & 00110111b = 00010001b
-10010001b & 00111000b = 00010000b
-10010001b & 00111001b = 00010001b
-10010001b & 00111010b = 00010000b
-10010001b & 00111011b = 00010001b
-10010001b & 00111100b = 00010000b
-10010001b & 00111101b = 00010001b
-10010001b & 00111110b = 00010000b
-10010001b & 00111111b = 00010001b
-10010001b & 01000000b = 00000000b
-10010001b & 01000001b = 00000001b
-10010001b & 01000010b = 00000000b
-10010001b & 01000011b = 00000001b
-10010001b & 01000100b = 00000000b
-10010001b & 01000101b = 00000001b
-10010001b & 01000110b = 00000000b
-10010001b & 01000111b = 00000001b
-10010001b & 01001000b = 00000000b
-10010001b & 01001001b = 00000001b
-10010001b & 01001010b = 00000000b
-10010001b & 01001011b = 00000001b
-10010001b & 01001100b = 00000000b
-10010001b & 01001101b = 00000001b
-10010001b & 01001110b = 00000000b
-10010001b & 01001111b = 00000001b
-10010001b & 01010000b = 00010000b
-10010001b & 01010001b = 00010001b
-10010001b & 01010010b = 00010000b
-10010001b & 01010011b = 00010001b
-10010001b & 01010100b = 00010000b
-10010001b & 01010101b = 00010001b
-10010001b & 01010110b = 00010000b
-10010001b & 01010111b = 00010001b
-10010001b & 01011000b = 00010000b
-10010001b & 01011001b = 00010001b
-10010001b & 01011010b = 00010000b
-10010001b & 01011011b = 00010001b
-10010001b & 01011100b = 00010000b
-10010001b & 01011101b = 00010001b
-10010001b & 01011110b = 00010000b
-10010001b & 01011111b = 00010001b
-10010001b & 01100000b = 00000000b
-10010001b & 01100001b = 00000001b
-10010001b & 01100010b = 00000000b
-10010001b & 01100011b = 00000001b
-10010001b & 01100100b = 00000000b
-10010001b & 01100101b = 00000001b
-10010001b & 01100110b = 00000000b
-10010001b & 01100111b = 00000001b
-10010001b & 01101000b = 00000000b
-10010001b & 01101001b = 00000001b
-10010001b & 01101010b = 00000000b
-10010001b & 01101011b = 00000001b
-10010001b & 01101100b = 00000000b
-10010001b & 01101101b = 00000001b
-10010001b & 01101110b = 00000000b
-10010001b & 01101111b = 00000001b
-10010001b & 01110000b = 00010000b
-10010001b & 01110001b = 00010001b
-10010001b & 01110010b = 00010000b
-10010001b & 01110011b = 00010001b
-10010001b & 01110100b = 00010000b
-10010001b & 01110101b = 00010001b
-10010001b & 01110110b = 00010000b
-10010001b & 01110111b = 00010001b
-10010001b & 01111000b = 00010000b
-10010001b & 01111001b = 00010001b
-10010001b & 01111010b = 00010000b
-10010001b & 01111011b = 00010001b
-10010001b & 01111100b = 00010000b
-10010001b & 01111101b = 00010001b
-10010001b & 01111110b = 00010000b
-10010010b & 10000000b = 10000000b
-10010010b & 10000001b = 10000000b
-10010010b & 10000010b = 10000010b
-10010010b & 10000011b = 10000010b
-10010010b & 10000100b = 10000000b
-10010010b & 10000101b = 10000000b
-10010010b & 10000110b = 10000010b
-10010010b & 10000111b = 10000010b
-10010010b & 10001000b = 10000000b
-10010010b & 10001001b = 10000000b
-10010010b & 10001010b = 10000010b
-10010010b & 10001011b = 10000010b
-10010010b & 10001100b = 10000000b
-10010010b & 10001101b = 10000000b
-10010010b & 10001110b = 10000010b
-10010010b & 10001111b = 10000010b
-10010010b & 10010000b = 10010000b
-10010010b & 10010001b = 10010000b
-10010010b & 10010010b = 10010010b
-10010010b & 10010011b = 10010010b
-10010010b & 10010100b = 10010000b
-10010010b & 10010101b = 10010000b
-10010010b & 10010110b = 10010010b
-10010010b & 10010111b = 10010010b
-10010010b & 10011000b = 10010000b
-10010010b & 10011001b = 10010000b
-10010010b & 10011010b = 10010010b
-10010010b & 10011011b = 10010010b
-10010010b & 10011100b = 10010000b
-10010010b & 10011101b = 10010000b
-10010010b & 10011110b = 10010010b
-10010010b & 10011111b = 10010010b
-10010010b & 10100000b = 10000000b
-10010010b & 10100001b = 10000000b
-10010010b & 10100010b = 10000010b
-10010010b & 10100011b = 10000010b
-10010010b & 10100100b = 10000000b
-10010010b & 10100101b = 10000000b
-10010010b & 10100110b = 10000010b
-10010010b & 10100111b = 10000010b
-10010010b & 10101000b = 10000000b
-10010010b & 10101001b = 10000000b
-10010010b & 10101010b = 10000010b
-10010010b & 10101011b = 10000010b
-10010010b & 10101100b = 10000000b
-10010010b & 10101101b = 10000000b
-10010010b & 10101110b = 10000010b
-10010010b & 10101111b = 10000010b
-10010010b & 10110000b = 10010000b
-10010010b & 10110001b = 10010000b
-10010010b & 10110010b = 10010010b
-10010010b & 10110011b = 10010010b
-10010010b & 10110100b = 10010000b
-10010010b & 10110101b = 10010000b
-10010010b & 10110110b = 10010010b
-10010010b & 10110111b = 10010010b
-10010010b & 10111000b = 10010000b
-10010010b & 10111001b = 10010000b
-10010010b & 10111010b = 10010010b
-10010010b & 10111011b = 10010010b
-10010010b & 10111100b = 10010000b
-10010010b & 10111101b = 10010000b
-10010010b & 10111110b = 10010010b
-10010010b & 10111111b = 10010010b
-10010010b & 11000000b = 10000000b
-10010010b & 11000001b = 10000000b
-10010010b & 11000010b = 10000010b
-10010010b & 11000011b = 10000010b
-10010010b & 11000100b = 10000000b
-10010010b & 11000101b = 10000000b
-10010010b & 11000110b = 10000010b
-10010010b & 11000111b = 10000010b
-10010010b & 11001000b = 10000000b
-10010010b & 11001001b = 10000000b
-10010010b & 11001010b = 10000010b
-10010010b & 11001011b = 10000010b
-10010010b & 11001100b = 10000000b
-10010010b & 11001101b = 10000000b
-10010010b & 11001110b = 10000010b
-10010010b & 11001111b = 10000010b
-10010010b & 11010000b = 10010000b
-10010010b & 11010001b = 10010000b
-10010010b & 11010010b = 10010010b
-10010010b & 11010011b = 10010010b
-10010010b & 11010100b = 10010000b
-10010010b & 11010101b = 10010000b
-10010010b & 11010110b = 10010010b
-10010010b & 11010111b = 10010010b
-10010010b & 11011000b = 10010000b
-10010010b & 11011001b = 10010000b
-10010010b & 11011010b = 10010010b
-10010010b & 11011011b = 10010010b
-10010010b & 11011100b = 10010000b
-10010010b & 11011101b = 10010000b
-10010010b & 11011110b = 10010010b
-10010010b & 11011111b = 10010010b
-10010010b & 11100000b = 10000000b
-10010010b & 11100001b = 10000000b
-10010010b & 11100010b = 10000010b
-10010010b & 11100011b = 10000010b
-10010010b & 11100100b = 10000000b
-10010010b & 11100101b = 10000000b
-10010010b & 11100110b = 10000010b
-10010010b & 11100111b = 10000010b
-10010010b & 11101000b = 10000000b
-10010010b & 11101001b = 10000000b
-10010010b & 11101010b = 10000010b
-10010010b & 11101011b = 10000010b
-10010010b & 11101100b = 10000000b
-10010010b & 11101101b = 10000000b
-10010010b & 11101110b = 10000010b
-10010010b & 11101111b = 10000010b
-10010010b & 11110000b = 10010000b
-10010010b & 11110001b = 10010000b
-10010010b & 11110010b = 10010010b
-10010010b & 11110011b = 10010010b
-10010010b & 11110100b = 10010000b
-10010010b & 11110101b = 10010000b
-10010010b & 11110110b = 10010010b
-10010010b & 11110111b = 10010010b
-10010010b & 11111000b = 10010000b
-10010010b & 11111001b = 10010000b
-10010010b & 11111010b = 10010010b
-10010010b & 11111011b = 10010010b
-10010010b & 11111100b = 10010000b
-10010010b & 11111101b = 10010000b
-10010010b & 11111110b = 10010010b
-10010010b & 11111111b = 10010010b
-10010010b & 00000000b = 00000000b
-10010010b & 00000001b = 00000000b
-10010010b & 00000010b = 00000010b
-10010010b & 00000011b = 00000010b
-10010010b & 00000100b = 00000000b
-10010010b & 00000101b = 00000000b
-10010010b & 00000110b = 00000010b
-10010010b & 00000111b = 00000010b
-10010010b & 00001000b = 00000000b
-10010010b & 00001001b = 00000000b
-10010010b & 00001010b = 00000010b
-10010010b & 00001011b = 00000010b
-10010010b & 00001100b = 00000000b
-10010010b & 00001101b = 00000000b
-10010010b & 00001110b = 00000010b
-10010010b & 00001111b = 00000010b
-10010010b & 00010000b = 00010000b
-10010010b & 00010001b = 00010000b
-10010010b & 00010010b = 00010010b
-10010010b & 00010011b = 00010010b
-10010010b & 00010100b = 00010000b
-10010010b & 00010101b = 00010000b
-10010010b & 00010110b = 00010010b
-10010010b & 00010111b = 00010010b
-10010010b & 00011000b = 00010000b
-10010010b & 00011001b = 00010000b
-10010010b & 00011010b = 00010010b
-10010010b & 00011011b = 00010010b
-10010010b & 00011100b = 00010000b
-10010010b & 00011101b = 00010000b
-10010010b & 00011110b = 00010010b
-10010010b & 00011111b = 00010010b
-10010010b & 00100000b = 00000000b
-10010010b & 00100001b = 00000000b
-10010010b & 00100010b = 00000010b
-10010010b & 00100011b = 00000010b
-10010010b & 00100100b = 00000000b
-10010010b & 00100101b = 00000000b
-10010010b & 00100110b = 00000010b
-10010010b & 00100111b = 00000010b
-10010010b & 00101000b = 00000000b
-10010010b & 00101001b = 00000000b
-10010010b & 00101010b = 00000010b
-10010010b & 00101011b = 00000010b
-10010010b & 00101100b = 00000000b
-10010010b & 00101101b = 00000000b
-10010010b & 00101110b = 00000010b
-10010010b & 00101111b = 00000010b
-10010010b & 00110000b = 00010000b
-10010010b & 00110001b = 00010000b
-10010010b & 00110010b = 00010010b
-10010010b & 00110011b = 00010010b
-10010010b & 00110100b = 00010000b
-10010010b & 00110101b = 00010000b
-10010010b & 00110110b = 00010010b
-10010010b & 00110111b = 00010010b
-10010010b & 00111000b = 00010000b
-10010010b & 00111001b = 00010000b
-10010010b & 00111010b = 00010010b
-10010010b & 00111011b = 00010010b
-10010010b & 00111100b = 00010000b
-10010010b & 00111101b = 00010000b
-10010010b & 00111110b = 00010010b
-10010010b & 00111111b = 00010010b
-10010010b & 01000000b = 00000000b
-10010010b & 01000001b = 00000000b
-10010010b & 01000010b = 00000010b
-10010010b & 01000011b = 00000010b
-10010010b & 01000100b = 00000000b
-10010010b & 01000101b = 00000000b
-10010010b & 01000110b = 00000010b
-10010010b & 01000111b = 00000010b
-10010010b & 01001000b = 00000000b
-10010010b & 01001001b = 00000000b
-10010010b & 01001010b = 00000010b
-10010010b & 01001011b = 00000010b
-10010010b & 01001100b = 00000000b
-10010010b & 01001101b = 00000000b
-10010010b & 01001110b = 00000010b
-10010010b & 01001111b = 00000010b
-10010010b & 01010000b = 00010000b
-10010010b & 01010001b = 00010000b
-10010010b & 01010010b = 00010010b
-10010010b & 01010011b = 00010010b
-10010010b & 01010100b = 00010000b
-10010010b & 01010101b = 00010000b
-10010010b & 01010110b = 00010010b
-10010010b & 01010111b = 00010010b
-10010010b & 01011000b = 00010000b
-10010010b & 01011001b = 00010000b
-10010010b & 01011010b = 00010010b
-10010010b & 01011011b = 00010010b
-10010010b & 01011100b = 00010000b
-10010010b & 01011101b = 00010000b
-10010010b & 01011110b = 00010010b
-10010010b & 01011111b = 00010010b
-10010010b & 01100000b = 00000000b
-10010010b & 01100001b = 00000000b
-10010010b & 01100010b = 00000010b
-10010010b & 01100011b = 00000010b
-10010010b & 01100100b = 00000000b
-10010010b & 01100101b = 00000000b
-10010010b & 01100110b = 00000010b
-10010010b & 01100111b = 00000010b
-10010010b & 01101000b = 00000000b
-10010010b & 01101001b = 00000000b
-10010010b & 01101010b = 00000010b
-10010010b & 01101011b = 00000010b
-10010010b & 01101100b = 00000000b
-10010010b & 01101101b = 00000000b
-10010010b & 01101110b = 00000010b
-10010010b & 01101111b = 00000010b
-10010010b & 01110000b = 00010000b
-10010010b & 01110001b = 00010000b
-10010010b & 01110010b = 00010010b
-10010010b & 01110011b = 00010010b
-10010010b & 01110100b = 00010000b
-10010010b & 01110101b = 00010000b
-10010010b & 01110110b = 00010010b
-10010010b & 01110111b = 00010010b
-10010010b & 01111000b = 00010000b
-10010010b & 01111001b = 00010000b
-10010010b & 01111010b = 00010010b
-10010010b & 01111011b = 00010010b
-10010010b & 01111100b = 00010000b
-10010010b & 01111101b = 00010000b
-10010010b & 01111110b = 00010010b
-10010011b & 10000000b = 10000000b
-10010011b & 10000001b = 10000001b
-10010011b & 10000010b = 10000010b
-10010011b & 10000011b = 10000011b
-10010011b & 10000100b = 10000000b
-10010011b & 10000101b = 10000001b
-10010011b & 10000110b = 10000010b
-10010011b & 10000111b = 10000011b
-10010011b & 10001000b = 10000000b
-10010011b & 10001001b = 10000001b
-10010011b & 10001010b = 10000010b
-10010011b & 10001011b = 10000011b
-10010011b & 10001100b = 10000000b
-10010011b & 10001101b = 10000001b
-10010011b & 10001110b = 10000010b
-10010011b & 10001111b = 10000011b
-10010011b & 10010000b = 10010000b
-10010011b & 10010001b = 10010001b
-10010011b & 10010010b = 10010010b
-10010011b & 10010011b = 10010011b
-10010011b & 10010100b = 10010000b
-10010011b & 10010101b = 10010001b
-10010011b & 10010110b = 10010010b
-10010011b & 10010111b = 10010011b
-10010011b & 10011000b = 10010000b
-10010011b & 10011001b = 10010001b
-10010011b & 10011010b = 10010010b
-10010011b & 10011011b = 10010011b
-10010011b & 10011100b = 10010000b
-10010011b & 10011101b = 10010001b
-10010011b & 10011110b = 10010010b
-10010011b & 10011111b = 10010011b
-10010011b & 10100000b = 10000000b
-10010011b & 10100001b = 10000001b
-10010011b & 10100010b = 10000010b
-10010011b & 10100011b = 10000011b
-10010011b & 10100100b = 10000000b
-10010011b & 10100101b = 10000001b
-10010011b & 10100110b = 10000010b
-10010011b & 10100111b = 10000011b
-10010011b & 10101000b = 10000000b
-10010011b & 10101001b = 10000001b
-10010011b & 10101010b = 10000010b
-10010011b & 10101011b = 10000011b
-10010011b & 10101100b = 10000000b
-10010011b & 10101101b = 10000001b
-10010011b & 10101110b = 10000010b
-10010011b & 10101111b = 10000011b
-10010011b & 10110000b = 10010000b
-10010011b & 10110001b = 10010001b
-10010011b & 10110010b = 10010010b
-10010011b & 10110011b = 10010011b
-10010011b & 10110100b = 10010000b
-10010011b & 10110101b = 10010001b
-10010011b & 10110110b = 10010010b
-10010011b & 10110111b = 10010011b
-10010011b & 10111000b = 10010000b
-10010011b & 10111001b = 10010001b
-10010011b & 10111010b = 10010010b
-10010011b & 10111011b = 10010011b
-10010011b & 10111100b = 10010000b
-10010011b & 10111101b = 10010001b
-10010011b & 10111110b = 10010010b
-10010011b & 10111111b = 10010011b
-10010011b & 11000000b = 10000000b
-10010011b & 11000001b = 10000001b
-10010011b & 11000010b = 10000010b
-10010011b & 11000011b = 10000011b
-10010011b & 11000100b = 10000000b
-10010011b & 11000101b = 10000001b
-10010011b & 11000110b = 10000010b
-10010011b & 11000111b = 10000011b
-10010011b & 11001000b = 10000000b
-10010011b & 11001001b = 10000001b
-10010011b & 11001010b = 10000010b
-10010011b & 11001011b = 10000011b
-10010011b & 11001100b = 10000000b
-10010011b & 11001101b = 10000001b
-10010011b & 11001110b = 10000010b
-10010011b & 11001111b = 10000011b
-10010011b & 11010000b = 10010000b
-10010011b & 11010001b = 10010001b
-10010011b & 11010010b = 10010010b
-10010011b & 11010011b = 10010011b
-10010011b & 11010100b = 10010000b
-10010011b & 11010101b = 10010001b
-10010011b & 11010110b = 10010010b
-10010011b & 11010111b = 10010011b
-10010011b & 11011000b = 10010000b
-10010011b & 11011001b = 10010001b
-10010011b & 11011010b = 10010010b
-10010011b & 11011011b = 10010011b
-10010011b & 11011100b = 10010000b
-10010011b & 11011101b = 10010001b
-10010011b & 11011110b = 10010010b
-10010011b & 11011111b = 10010011b
-10010011b & 11100000b = 10000000b
-10010011b & 11100001b = 10000001b
-10010011b & 11100010b = 10000010b
-10010011b & 11100011b = 10000011b
-10010011b & 11100100b = 10000000b
-10010011b & 11100101b = 10000001b
-10010011b & 11100110b = 10000010b
-10010011b & 11100111b = 10000011b
-10010011b & 11101000b = 10000000b
-10010011b & 11101001b = 10000001b
-10010011b & 11101010b = 10000010b
-10010011b & 11101011b = 10000011b
-10010011b & 11101100b = 10000000b
-10010011b & 11101101b = 10000001b
-10010011b & 11101110b = 10000010b
-10010011b & 11101111b = 10000011b
-10010011b & 11110000b = 10010000b
-10010011b & 11110001b = 10010001b
-10010011b & 11110010b = 10010010b
-10010011b & 11110011b = 10010011b
-10010011b & 11110100b = 10010000b
-10010011b & 11110101b = 10010001b
-10010011b & 11110110b = 10010010b
-10010011b & 11110111b = 10010011b
-10010011b & 11111000b = 10010000b
-10010011b & 11111001b = 10010001b
-10010011b & 11111010b = 10010010b
-10010011b & 11111011b = 10010011b
-10010011b & 11111100b = 10010000b
-10010011b & 11111101b = 10010001b
-10010011b & 11111110b = 10010010b
-10010011b & 11111111b = 10010011b
-10010011b & 00000000b = 00000000b
-10010011b & 00000001b = 00000001b
-10010011b & 00000010b = 00000010b
-10010011b & 00000011b = 00000011b
-10010011b & 00000100b = 00000000b
-10010011b & 00000101b = 00000001b
-10010011b & 00000110b = 00000010b
-10010011b & 00000111b = 00000011b
-10010011b & 00001000b = 00000000b
-10010011b & 00001001b = 00000001b
-10010011b & 00001010b = 00000010b
-10010011b & 00001011b = 00000011b
-10010011b & 00001100b = 00000000b
-10010011b & 00001101b = 00000001b
-10010011b & 00001110b = 00000010b
-10010011b & 00001111b = 00000011b
-10010011b & 00010000b = 00010000b
-10010011b & 00010001b = 00010001b
-10010011b & 00010010b = 00010010b
-10010011b & 00010011b = 00010011b
-10010011b & 00010100b = 00010000b
-10010011b & 00010101b = 00010001b
-10010011b & 00010110b = 00010010b
-10010011b & 00010111b = 00010011b
-10010011b & 00011000b = 00010000b
-10010011b & 00011001b = 00010001b
-10010011b & 00011010b = 00010010b
-10010011b & 00011011b = 00010011b
-10010011b & 00011100b = 00010000b
-10010011b & 00011101b = 00010001b
-10010011b & 00011110b = 00010010b
-10010011b & 00011111b = 00010011b
-10010011b & 00100000b = 00000000b
-10010011b & 00100001b = 00000001b
-10010011b & 00100010b = 00000010b
-10010011b & 00100011b = 00000011b
-10010011b & 00100100b = 00000000b
-10010011b & 00100101b = 00000001b
-10010011b & 00100110b = 00000010b
-10010011b & 00100111b = 00000011b
-10010011b & 00101000b = 00000000b
-10010011b & 00101001b = 00000001b
-10010011b & 00101010b = 00000010b
-10010011b & 00101011b = 00000011b
-10010011b & 00101100b = 00000000b
-10010011b & 00101101b = 00000001b
-10010011b & 00101110b = 00000010b
-10010011b & 00101111b = 00000011b
-10010011b & 00110000b = 00010000b
-10010011b & 00110001b = 00010001b
-10010011b & 00110010b = 00010010b
-10010011b & 00110011b = 00010011b
-10010011b & 00110100b = 00010000b
-10010011b & 00110101b = 00010001b
-10010011b & 00110110b = 00010010b
-10010011b & 00110111b = 00010011b
-10010011b & 00111000b = 00010000b
-10010011b & 00111001b = 00010001b
-10010011b & 00111010b = 00010010b
-10010011b & 00111011b = 00010011b
-10010011b & 00111100b = 00010000b
-10010011b & 00111101b = 00010001b
-10010011b & 00111110b = 00010010b
-10010011b & 00111111b = 00010011b
-10010011b & 01000000b = 00000000b
-10010011b & 01000001b = 00000001b
-10010011b & 01000010b = 00000010b
-10010011b & 01000011b = 00000011b
-10010011b & 01000100b = 00000000b
-10010011b & 01000101b = 00000001b
-10010011b & 01000110b = 00000010b
-10010011b & 01000111b = 00000011b
-10010011b & 01001000b = 00000000b
-10010011b & 01001001b = 00000001b
-10010011b & 01001010b = 00000010b
-10010011b & 01001011b = 00000011b
-10010011b & 01001100b = 00000000b
-10010011b & 01001101b = 00000001b
-10010011b & 01001110b = 00000010b
-10010011b & 01001111b = 00000011b
-10010011b & 01010000b = 00010000b
-10010011b & 01010001b = 00010001b
-10010011b & 01010010b = 00010010b
-10010011b & 01010011b = 00010011b
-10010011b & 01010100b = 00010000b
-10010011b & 01010101b = 00010001b
-10010011b & 01010110b = 00010010b
-10010011b & 01010111b = 00010011b
-10010011b & 01011000b = 00010000b
-10010011b & 01011001b = 00010001b
-10010011b & 01011010b = 00010010b
-10010011b & 01011011b = 00010011b
-10010011b & 01011100b = 00010000b
-10010011b & 01011101b = 00010001b
-10010011b & 01011110b = 00010010b
-10010011b & 01011111b = 00010011b
-10010011b & 01100000b = 00000000b
-10010011b & 01100001b = 00000001b
-10010011b & 01100010b = 00000010b
-10010011b & 01100011b = 00000011b
-10010011b & 01100100b = 00000000b
-10010011b & 01100101b = 00000001b
-10010011b & 01100110b = 00000010b
-10010011b & 01100111b = 00000011b
-10010011b & 01101000b = 00000000b
-10010011b & 01101001b = 00000001b
-10010011b & 01101010b = 00000010b
-10010011b & 01101011b = 00000011b
-10010011b & 01101100b = 00000000b
-10010011b & 01101101b = 00000001b
-10010011b & 01101110b = 00000010b
-10010011b & 01101111b = 00000011b
-10010011b & 01110000b = 00010000b
-10010011b & 01110001b = 00010001b
-10010011b & 01110010b = 00010010b
-10010011b & 01110011b = 00010011b
-10010011b & 01110100b = 00010000b
-10010011b & 01110101b = 00010001b
-10010011b & 01110110b = 00010010b
-10010011b & 01110111b = 00010011b
-10010011b & 01111000b = 00010000b
-10010011b & 01111001b = 00010001b
-10010011b & 01111010b = 00010010b
-10010011b & 01111011b = 00010011b
-10010011b & 01111100b = 00010000b
-10010011b & 01111101b = 00010001b
-10010011b & 01111110b = 00010010b
-10010100b & 10000000b = 10000000b
-10010100b & 10000001b = 10000000b
-10010100b & 10000010b = 10000000b
-10010100b & 10000011b = 10000000b
-10010100b & 10000100b = 10000100b
-10010100b & 10000101b = 10000100b
-10010100b & 10000110b = 10000100b
-10010100b & 10000111b = 10000100b
-10010100b & 10001000b = 10000000b
-10010100b & 10001001b = 10000000b
-10010100b & 10001010b = 10000000b
-10010100b & 10001011b = 10000000b
-10010100b & 10001100b = 10000100b
-10010100b & 10001101b = 10000100b
-10010100b & 10001110b = 10000100b
-10010100b & 10001111b = 10000100b
-10010100b & 10010000b = 10010000b
-10010100b & 10010001b = 10010000b
-10010100b & 10010010b = 10010000b
-10010100b & 10010011b = 10010000b
-10010100b & 10010100b = 10010100b
-10010100b & 10010101b = 10010100b
-10010100b & 10010110b = 10010100b
-10010100b & 10010111b = 10010100b
-10010100b & 10011000b = 10010000b
-10010100b & 10011001b = 10010000b
-10010100b & 10011010b = 10010000b
-10010100b & 10011011b = 10010000b
-10010100b & 10011100b = 10010100b
-10010100b & 10011101b = 10010100b
-10010100b & 10011110b = 10010100b
-10010100b & 10011111b = 10010100b
-10010100b & 10100000b = 10000000b
-10010100b & 10100001b = 10000000b
-10010100b & 10100010b = 10000000b
-10010100b & 10100011b = 10000000b
-10010100b & 10100100b = 10000100b
-10010100b & 10100101b = 10000100b
-10010100b & 10100110b = 10000100b
-10010100b & 10100111b = 10000100b
-10010100b & 10101000b = 10000000b
-10010100b & 10101001b = 10000000b
-10010100b & 10101010b = 10000000b
-10010100b & 10101011b = 10000000b
-10010100b & 10101100b = 10000100b
-10010100b & 10101101b = 10000100b
-10010100b & 10101110b = 10000100b
-10010100b & 10101111b = 10000100b
-10010100b & 10110000b = 10010000b
-10010100b & 10110001b = 10010000b
-10010100b & 10110010b = 10010000b
-10010100b & 10110011b = 10010000b
-10010100b & 10110100b = 10010100b
-10010100b & 10110101b = 10010100b
-10010100b & 10110110b = 10010100b
-10010100b & 10110111b = 10010100b
-10010100b & 10111000b = 10010000b
-10010100b & 10111001b = 10010000b
-10010100b & 10111010b = 10010000b
-10010100b & 10111011b = 10010000b
-10010100b & 10111100b = 10010100b
-10010100b & 10111101b = 10010100b
-10010100b & 10111110b = 10010100b
-10010100b & 10111111b = 10010100b
-10010100b & 11000000b = 10000000b
-10010100b & 11000001b = 10000000b
-10010100b & 11000010b = 10000000b
-10010100b & 11000011b = 10000000b
-10010100b & 11000100b = 10000100b
-10010100b & 11000101b = 10000100b
-10010100b & 11000110b = 10000100b
-10010100b & 11000111b = 10000100b
-10010100b & 11001000b = 10000000b
-10010100b & 11001001b = 10000000b
-10010100b & 11001010b = 10000000b
-10010100b & 11001011b = 10000000b
-10010100b & 11001100b = 10000100b
-10010100b & 11001101b = 10000100b
-10010100b & 11001110b = 10000100b
-10010100b & 11001111b = 10000100b
-10010100b & 11010000b = 10010000b
-10010100b & 11010001b = 10010000b
-10010100b & 11010010b = 10010000b
-10010100b & 11010011b = 10010000b
-10010100b & 11010100b = 10010100b
-10010100b & 11010101b = 10010100b
-10010100b & 11010110b = 10010100b
-10010100b & 11010111b = 10010100b
-10010100b & 11011000b = 10010000b
-10010100b & 11011001b = 10010000b
-10010100b & 11011010b = 10010000b
-10010100b & 11011011b = 10010000b
-10010100b & 11011100b = 10010100b
-10010100b & 11011101b = 10010100b
-10010100b & 11011110b = 10010100b
-10010100b & 11011111b = 10010100b
-10010100b & 11100000b = 10000000b
-10010100b & 11100001b = 10000000b
-10010100b & 11100010b = 10000000b
-10010100b & 11100011b = 10000000b
-10010100b & 11100100b = 10000100b
-10010100b & 11100101b = 10000100b
-10010100b & 11100110b = 10000100b
-10010100b & 11100111b = 10000100b
-10010100b & 11101000b = 10000000b
-10010100b & 11101001b = 10000000b
-10010100b & 11101010b = 10000000b
-10010100b & 11101011b = 10000000b
-10010100b & 11101100b = 10000100b
-10010100b & 11101101b = 10000100b
-10010100b & 11101110b = 10000100b
-10010100b & 11101111b = 10000100b
-10010100b & 11110000b = 10010000b
-10010100b & 11110001b = 10010000b
-10010100b & 11110010b = 10010000b
-10010100b & 11110011b = 10010000b
-10010100b & 11110100b = 10010100b
-10010100b & 11110101b = 10010100b
-10010100b & 11110110b = 10010100b
-10010100b & 11110111b = 10010100b
-10010100b & 11111000b = 10010000b
-10010100b & 11111001b = 10010000b
-10010100b & 11111010b = 10010000b
-10010100b & 11111011b = 10010000b
-10010100b & 11111100b = 10010100b
-10010100b & 11111101b = 10010100b
-10010100b & 11111110b = 10010100b
-10010100b & 11111111b = 10010100b
-10010100b & 00000000b = 00000000b
-10010100b & 00000001b = 00000000b
-10010100b & 00000010b = 00000000b
-10010100b & 00000011b = 00000000b
-10010100b & 00000100b = 00000100b
-10010100b & 00000101b = 00000100b
-10010100b & 00000110b = 00000100b
-10010100b & 00000111b = 00000100b
-10010100b & 00001000b = 00000000b
-10010100b & 00001001b = 00000000b
-10010100b & 00001010b = 00000000b
-10010100b & 00001011b = 00000000b
-10010100b & 00001100b = 00000100b
-10010100b & 00001101b = 00000100b
-10010100b & 00001110b = 00000100b
-10010100b & 00001111b = 00000100b
-10010100b & 00010000b = 00010000b
-10010100b & 00010001b = 00010000b
-10010100b & 00010010b = 00010000b
-10010100b & 00010011b = 00010000b
-10010100b & 00010100b = 00010100b
-10010100b & 00010101b = 00010100b
-10010100b & 00010110b = 00010100b
-10010100b & 00010111b = 00010100b
-10010100b & 00011000b = 00010000b
-10010100b & 00011001b = 00010000b
-10010100b & 00011010b = 00010000b
-10010100b & 00011011b = 00010000b
-10010100b & 00011100b = 00010100b
-10010100b & 00011101b = 00010100b
-10010100b & 00011110b = 00010100b
-10010100b & 00011111b = 00010100b
-10010100b & 00100000b = 00000000b
-10010100b & 00100001b = 00000000b
-10010100b & 00100010b = 00000000b
-10010100b & 00100011b = 00000000b
-10010100b & 00100100b = 00000100b
-10010100b & 00100101b = 00000100b
-10010100b & 00100110b = 00000100b
-10010100b & 00100111b = 00000100b
-10010100b & 00101000b = 00000000b
-10010100b & 00101001b = 00000000b
-10010100b & 00101010b = 00000000b
-10010100b & 00101011b = 00000000b
-10010100b & 00101100b = 00000100b
-10010100b & 00101101b = 00000100b
-10010100b & 00101110b = 00000100b
-10010100b & 00101111b = 00000100b
-10010100b & 00110000b = 00010000b
-10010100b & 00110001b = 00010000b
-10010100b & 00110010b = 00010000b
-10010100b & 00110011b = 00010000b
-10010100b & 00110100b = 00010100b
-10010100b & 00110101b = 00010100b
-10010100b & 00110110b = 00010100b
-10010100b & 00110111b = 00010100b
-10010100b & 00111000b = 00010000b
-10010100b & 00111001b = 00010000b
-10010100b & 00111010b = 00010000b
-10010100b & 00111011b = 00010000b
-10010100b & 00111100b = 00010100b
-10010100b & 00111101b = 00010100b
-10010100b & 00111110b = 00010100b
-10010100b & 00111111b = 00010100b
-10010100b & 01000000b = 00000000b
-10010100b & 01000001b = 00000000b
-10010100b & 01000010b = 00000000b
-10010100b & 01000011b = 00000000b
-10010100b & 01000100b = 00000100b
-10010100b & 01000101b = 00000100b
-10010100b & 01000110b = 00000100b
-10010100b & 01000111b = 00000100b
-10010100b & 01001000b = 00000000b
-10010100b & 01001001b = 00000000b
-10010100b & 01001010b = 00000000b
-10010100b & 01001011b = 00000000b
-10010100b & 01001100b = 00000100b
-10010100b & 01001101b = 00000100b
-10010100b & 01001110b = 00000100b
-10010100b & 01001111b = 00000100b
-10010100b & 01010000b = 00010000b
-10010100b & 01010001b = 00010000b
-10010100b & 01010010b = 00010000b
-10010100b & 01010011b = 00010000b
-10010100b & 01010100b = 00010100b
-10010100b & 01010101b = 00010100b
-10010100b & 01010110b = 00010100b
-10010100b & 01010111b = 00010100b
-10010100b & 01011000b = 00010000b
-10010100b & 01011001b = 00010000b
-10010100b & 01011010b = 00010000b
-10010100b & 01011011b = 00010000b
-10010100b & 01011100b = 00010100b
-10010100b & 01011101b = 00010100b
-10010100b & 01011110b = 00010100b
-10010100b & 01011111b = 00010100b
-10010100b & 01100000b = 00000000b
-10010100b & 01100001b = 00000000b
-10010100b & 01100010b = 00000000b
-10010100b & 01100011b = 00000000b
-10010100b & 01100100b = 00000100b
-10010100b & 01100101b = 00000100b
-10010100b & 01100110b = 00000100b
-10010100b & 01100111b = 00000100b
-10010100b & 01101000b = 00000000b
-10010100b & 01101001b = 00000000b
-10010100b & 01101010b = 00000000b
-10010100b & 01101011b = 00000000b
-10010100b & 01101100b = 00000100b
-10010100b & 01101101b = 00000100b
-10010100b & 01101110b = 00000100b
-10010100b & 01101111b = 00000100b
-10010100b & 01110000b = 00010000b
-10010100b & 01110001b = 00010000b
-10010100b & 01110010b = 00010000b
-10010100b & 01110011b = 00010000b
-10010100b & 01110100b = 00010100b
-10010100b & 01110101b = 00010100b
-10010100b & 01110110b = 00010100b
-10010100b & 01110111b = 00010100b
-10010100b & 01111000b = 00010000b
-10010100b & 01111001b = 00010000b
-10010100b & 01111010b = 00010000b
-10010100b & 01111011b = 00010000b
-10010100b & 01111100b = 00010100b
-10010100b & 01111101b = 00010100b
-10010100b & 01111110b = 00010100b
-10010101b & 10000000b = 10000000b
-10010101b & 10000001b = 10000001b
-10010101b & 10000010b = 10000000b
-10010101b & 10000011b = 10000001b
-10010101b & 10000100b = 10000100b
-10010101b & 10000101b = 10000101b
-10010101b & 10000110b = 10000100b
-10010101b & 10000111b = 10000101b
-10010101b & 10001000b = 10000000b
-10010101b & 10001001b = 10000001b
-10010101b & 10001010b = 10000000b
-10010101b & 10001011b = 10000001b
-10010101b & 10001100b = 10000100b
-10010101b & 10001101b = 10000101b
-10010101b & 10001110b = 10000100b
-10010101b & 10001111b = 10000101b
-10010101b & 10010000b = 10010000b
-10010101b & 10010001b = 10010001b
-10010101b & 10010010b = 10010000b
-10010101b & 10010011b = 10010001b
-10010101b & 10010100b = 10010100b
-10010101b & 10010101b = 10010101b
-10010101b & 10010110b = 10010100b
-10010101b & 10010111b = 10010101b
-10010101b & 10011000b = 10010000b
-10010101b & 10011001b = 10010001b
-10010101b & 10011010b = 10010000b
-10010101b & 10011011b = 10010001b
-10010101b & 10011100b = 10010100b
-10010101b & 10011101b = 10010101b
-10010101b & 10011110b = 10010100b
-10010101b & 10011111b = 10010101b
-10010101b & 10100000b = 10000000b
-10010101b & 10100001b = 10000001b
-10010101b & 10100010b = 10000000b
-10010101b & 10100011b = 10000001b
-10010101b & 10100100b = 10000100b
-10010101b & 10100101b = 10000101b
-10010101b & 10100110b = 10000100b
-10010101b & 10100111b = 10000101b
-10010101b & 10101000b = 10000000b
-10010101b & 10101001b = 10000001b
-10010101b & 10101010b = 10000000b
-10010101b & 10101011b = 10000001b
-10010101b & 10101100b = 10000100b
-10010101b & 10101101b = 10000101b
-10010101b & 10101110b = 10000100b
-10010101b & 10101111b = 10000101b
-10010101b & 10110000b = 10010000b
-10010101b & 10110001b = 10010001b
-10010101b & 10110010b = 10010000b
-10010101b & 10110011b = 10010001b
-10010101b & 10110100b = 10010100b
-10010101b & 10110101b = 10010101b
-10010101b & 10110110b = 10010100b
-10010101b & 10110111b = 10010101b
-10010101b & 10111000b = 10010000b
-10010101b & 10111001b = 10010001b
-10010101b & 10111010b = 10010000b
-10010101b & 10111011b = 10010001b
-10010101b & 10111100b = 10010100b
-10010101b & 10111101b = 10010101b
-10010101b & 10111110b = 10010100b
-10010101b & 10111111b = 10010101b
-10010101b & 11000000b = 10000000b
-10010101b & 11000001b = 10000001b
-10010101b & 11000010b = 10000000b
-10010101b & 11000011b = 10000001b
-10010101b & 11000100b = 10000100b
-10010101b & 11000101b = 10000101b
-10010101b & 11000110b = 10000100b
-10010101b & 11000111b = 10000101b
-10010101b & 11001000b = 10000000b
-10010101b & 11001001b = 10000001b
-10010101b & 11001010b = 10000000b
-10010101b & 11001011b = 10000001b
-10010101b & 11001100b = 10000100b
-10010101b & 11001101b = 10000101b
-10010101b & 11001110b = 10000100b
-10010101b & 11001111b = 10000101b
-10010101b & 11010000b = 10010000b
-10010101b & 11010001b = 10010001b
-10010101b & 11010010b = 10010000b
-10010101b & 11010011b = 10010001b
-10010101b & 11010100b = 10010100b
-10010101b & 11010101b = 10010101b
-10010101b & 11010110b = 10010100b
-10010101b & 11010111b = 10010101b
-10010101b & 11011000b = 10010000b
-10010101b & 11011001b = 10010001b
-10010101b & 11011010b = 10010000b
-10010101b & 11011011b = 10010001b
-10010101b & 11011100b = 10010100b
-10010101b & 11011101b = 10010101b
-10010101b & 11011110b = 10010100b
-10010101b & 11011111b = 10010101b
-10010101b & 11100000b = 10000000b
-10010101b & 11100001b = 10000001b
-10010101b & 11100010b = 10000000b
-10010101b & 11100011b = 10000001b
-10010101b & 11100100b = 10000100b
-10010101b & 11100101b = 10000101b
-10010101b & 11100110b = 10000100b
-10010101b & 11100111b = 10000101b
-10010101b & 11101000b = 10000000b
-10010101b & 11101001b = 10000001b
-10010101b & 11101010b = 10000000b
-10010101b & 11101011b = 10000001b
-10010101b & 11101100b = 10000100b
-10010101b & 11101101b = 10000101b
-10010101b & 11101110b = 10000100b
-10010101b & 11101111b = 10000101b
-10010101b & 11110000b = 10010000b
-10010101b & 11110001b = 10010001b
-10010101b & 11110010b = 10010000b
-10010101b & 11110011b = 10010001b
-10010101b & 11110100b = 10010100b
-10010101b & 11110101b = 10010101b
-10010101b & 11110110b = 10010100b
-10010101b & 11110111b = 10010101b
-10010101b & 11111000b = 10010000b
-10010101b & 11111001b = 10010001b
-10010101b & 11111010b = 10010000b
-10010101b & 11111011b = 10010001b
-10010101b & 11111100b = 10010100b
-10010101b & 11111101b = 10010101b
-10010101b & 11111110b = 10010100b
-10010101b & 11111111b = 10010101b
-10010101b & 00000000b = 00000000b
-10010101b & 00000001b = 00000001b
-10010101b & 00000010b = 00000000b
-10010101b & 00000011b = 00000001b
-10010101b & 00000100b = 00000100b
-10010101b & 00000101b = 00000101b
-10010101b & 00000110b = 00000100b
-10010101b & 00000111b = 00000101b
-10010101b & 00001000b = 00000000b
-10010101b & 00001001b = 00000001b
-10010101b & 00001010b = 00000000b
-10010101b & 00001011b = 00000001b
-10010101b & 00001100b = 00000100b
-10010101b & 00001101b = 00000101b
-10010101b & 00001110b = 00000100b
-10010101b & 00001111b = 00000101b
-10010101b & 00010000b = 00010000b
-10010101b & 00010001b = 00010001b
-10010101b & 00010010b = 00010000b
-10010101b & 00010011b = 00010001b
-10010101b & 00010100b = 00010100b
-10010101b & 00010101b = 00010101b
-10010101b & 00010110b = 00010100b
-10010101b & 00010111b = 00010101b
-10010101b & 00011000b = 00010000b
-10010101b & 00011001b = 00010001b
-10010101b & 00011010b = 00010000b
-10010101b & 00011011b = 00010001b
-10010101b & 00011100b = 00010100b
-10010101b & 00011101b = 00010101b
-10010101b & 00011110b = 00010100b
-10010101b & 00011111b = 00010101b
-10010101b & 00100000b = 00000000b
-10010101b & 00100001b = 00000001b
-10010101b & 00100010b = 00000000b
-10010101b & 00100011b = 00000001b
-10010101b & 00100100b = 00000100b
-10010101b & 00100101b = 00000101b
-10010101b & 00100110b = 00000100b
-10010101b & 00100111b = 00000101b
-10010101b & 00101000b = 00000000b
-10010101b & 00101001b = 00000001b
-10010101b & 00101010b = 00000000b
-10010101b & 00101011b = 00000001b
-10010101b & 00101100b = 00000100b
-10010101b & 00101101b = 00000101b
-10010101b & 00101110b = 00000100b
-10010101b & 00101111b = 00000101b
-10010101b & 00110000b = 00010000b
-10010101b & 00110001b = 00010001b
-10010101b & 00110010b = 00010000b
-10010101b & 00110011b = 00010001b
-10010101b & 00110100b = 00010100b
-10010101b & 00110101b = 00010101b
-10010101b & 00110110b = 00010100b
-10010101b & 00110111b = 00010101b
-10010101b & 00111000b = 00010000b
-10010101b & 00111001b = 00010001b
-10010101b & 00111010b = 00010000b
-10010101b & 00111011b = 00010001b
-10010101b & 00111100b = 00010100b
-10010101b & 00111101b = 00010101b
-10010101b & 00111110b = 00010100b
-10010101b & 00111111b = 00010101b
-10010101b & 01000000b = 00000000b
-10010101b & 01000001b = 00000001b
-10010101b & 01000010b = 00000000b
-10010101b & 01000011b = 00000001b
-10010101b & 01000100b = 00000100b
-10010101b & 01000101b = 00000101b
-10010101b & 01000110b = 00000100b
-10010101b & 01000111b = 00000101b
-10010101b & 01001000b = 00000000b
-10010101b & 01001001b = 00000001b
-10010101b & 01001010b = 00000000b
-10010101b & 01001011b = 00000001b
-10010101b & 01001100b = 00000100b
-10010101b & 01001101b = 00000101b
-10010101b & 01001110b = 00000100b
-10010101b & 01001111b = 00000101b
-10010101b & 01010000b = 00010000b
-10010101b & 01010001b = 00010001b
-10010101b & 01010010b = 00010000b
-10010101b & 01010011b = 00010001b
-10010101b & 01010100b = 00010100b
-10010101b & 01010101b = 00010101b
-10010101b & 01010110b = 00010100b
-10010101b & 01010111b = 00010101b
-10010101b & 01011000b = 00010000b
-10010101b & 01011001b = 00010001b
-10010101b & 01011010b = 00010000b
-10010101b & 01011011b = 00010001b
-10010101b & 01011100b = 00010100b
-10010101b & 01011101b = 00010101b
-10010101b & 01011110b = 00010100b
-10010101b & 01011111b = 00010101b
-10010101b & 01100000b = 00000000b
-10010101b & 01100001b = 00000001b
-10010101b & 01100010b = 00000000b
-10010101b & 01100011b = 00000001b
-10010101b & 01100100b = 00000100b
-10010101b & 01100101b = 00000101b
-10010101b & 01100110b = 00000100b
-10010101b & 01100111b = 00000101b
-10010101b & 01101000b = 00000000b
-10010101b & 01101001b = 00000001b
-10010101b & 01101010b = 00000000b
-10010101b & 01101011b = 00000001b
-10010101b & 01101100b = 00000100b
-10010101b & 01101101b = 00000101b
-10010101b & 01101110b = 00000100b
-10010101b & 01101111b = 00000101b
-10010101b & 01110000b = 00010000b
-10010101b & 01110001b = 00010001b
-10010101b & 01110010b = 00010000b
-10010101b & 01110011b = 00010001b
-10010101b & 01110100b = 00010100b
-10010101b & 01110101b = 00010101b
-10010101b & 01110110b = 00010100b
-10010101b & 01110111b = 00010101b
-10010101b & 01111000b = 00010000b
-10010101b & 01111001b = 00010001b
-10010101b & 01111010b = 00010000b
-10010101b & 01111011b = 00010001b
-10010101b & 01111100b = 00010100b
-10010101b & 01111101b = 00010101b
-10010101b & 01111110b = 00010100b
-10010110b & 10000000b = 10000000b
-10010110b & 10000001b = 10000000b
-10010110b & 10000010b = 10000010b
-10010110b & 10000011b = 10000010b
-10010110b & 10000100b = 10000100b
-10010110b & 10000101b = 10000100b
-10010110b & 10000110b = 10000110b
-10010110b & 10000111b = 10000110b
-10010110b & 10001000b = 10000000b
-10010110b & 10001001b = 10000000b
-10010110b & 10001010b = 10000010b
-10010110b & 10001011b = 10000010b
-10010110b & 10001100b = 10000100b
-10010110b & 10001101b = 10000100b
-10010110b & 10001110b = 10000110b
-10010110b & 10001111b = 10000110b
-10010110b & 10010000b = 10010000b
-10010110b & 10010001b = 10010000b
-10010110b & 10010010b = 10010010b
-10010110b & 10010011b = 10010010b
-10010110b & 10010100b = 10010100b
-10010110b & 10010101b = 10010100b
-10010110b & 10010110b = 10010110b
-10010110b & 10010111b = 10010110b
-10010110b & 10011000b = 10010000b
-10010110b & 10011001b = 10010000b
-10010110b & 10011010b = 10010010b
-10010110b & 10011011b = 10010010b
-10010110b & 10011100b = 10010100b
-10010110b & 10011101b = 10010100b
-10010110b & 10011110b = 10010110b
-10010110b & 10011111b = 10010110b
-10010110b & 10100000b = 10000000b
-10010110b & 10100001b = 10000000b
-10010110b & 10100010b = 10000010b
-10010110b & 10100011b = 10000010b
-10010110b & 10100100b = 10000100b
-10010110b & 10100101b = 10000100b
-10010110b & 10100110b = 10000110b
-10010110b & 10100111b = 10000110b
-10010110b & 10101000b = 10000000b
-10010110b & 10101001b = 10000000b
-10010110b & 10101010b = 10000010b
-10010110b & 10101011b = 10000010b
-10010110b & 10101100b = 10000100b
-10010110b & 10101101b = 10000100b
-10010110b & 10101110b = 10000110b
-10010110b & 10101111b = 10000110b
-10010110b & 10110000b = 10010000b
-10010110b & 10110001b = 10010000b
-10010110b & 10110010b = 10010010b
-10010110b & 10110011b = 10010010b
-10010110b & 10110100b = 10010100b
-10010110b & 10110101b = 10010100b
-10010110b & 10110110b = 10010110b
-10010110b & 10110111b = 10010110b
-10010110b & 10111000b = 10010000b
-10010110b & 10111001b = 10010000b
-10010110b & 10111010b = 10010010b
-10010110b & 10111011b = 10010010b
-10010110b & 10111100b = 10010100b
-10010110b & 10111101b = 10010100b
-10010110b & 10111110b = 10010110b
-10010110b & 10111111b = 10010110b
-10010110b & 11000000b = 10000000b
-10010110b & 11000001b = 10000000b
-10010110b & 11000010b = 10000010b
-10010110b & 11000011b = 10000010b
-10010110b & 11000100b = 10000100b
-10010110b & 11000101b = 10000100b
-10010110b & 11000110b = 10000110b
-10010110b & 11000111b = 10000110b
-10010110b & 11001000b = 10000000b
-10010110b & 11001001b = 10000000b
-10010110b & 11001010b = 10000010b
-10010110b & 11001011b = 10000010b
-10010110b & 11001100b = 10000100b
-10010110b & 11001101b = 10000100b
-10010110b & 11001110b = 10000110b
-10010110b & 11001111b = 10000110b
-10010110b & 11010000b = 10010000b
-10010110b & 11010001b = 10010000b
-10010110b & 11010010b = 10010010b
-10010110b & 11010011b = 10010010b
-10010110b & 11010100b = 10010100b
-10010110b & 11010101b = 10010100b
-10010110b & 11010110b = 10010110b
-10010110b & 11010111b = 10010110b
-10010110b & 11011000b = 10010000b
-10010110b & 11011001b = 10010000b
-10010110b & 11011010b = 10010010b
-10010110b & 11011011b = 10010010b
-10010110b & 11011100b = 10010100b
-10010110b & 11011101b = 10010100b
-10010110b & 11011110b = 10010110b
-10010110b & 11011111b = 10010110b
-10010110b & 11100000b = 10000000b
-10010110b & 11100001b = 10000000b
-10010110b & 11100010b = 10000010b
-10010110b & 11100011b = 10000010b
-10010110b & 11100100b = 10000100b
-10010110b & 11100101b = 10000100b
-10010110b & 11100110b = 10000110b
-10010110b & 11100111b = 10000110b
-10010110b & 11101000b = 10000000b
-10010110b & 11101001b = 10000000b
-10010110b & 11101010b = 10000010b
-10010110b & 11101011b = 10000010b
-10010110b & 11101100b = 10000100b
-10010110b & 11101101b = 10000100b
-10010110b & 11101110b = 10000110b
-10010110b & 11101111b = 10000110b
-10010110b & 11110000b = 10010000b
-10010110b & 11110001b = 10010000b
-10010110b & 11110010b = 10010010b
-10010110b & 11110011b = 10010010b
-10010110b & 11110100b = 10010100b
-10010110b & 11110101b = 10010100b
-10010110b & 11110110b = 10010110b
-10010110b & 11110111b = 10010110b
-10010110b & 11111000b = 10010000b
-10010110b & 11111001b = 10010000b
-10010110b & 11111010b = 10010010b
-10010110b & 11111011b = 10010010b
-10010110b & 11111100b = 10010100b
-10010110b & 11111101b = 10010100b
-10010110b & 11111110b = 10010110b
-10010110b & 11111111b = 10010110b
-10010110b & 00000000b = 00000000b
-10010110b & 00000001b = 00000000b
-10010110b & 00000010b = 00000010b
-10010110b & 00000011b = 00000010b
-10010110b & 00000100b = 00000100b
-10010110b & 00000101b = 00000100b
-10010110b & 00000110b = 00000110b
-10010110b & 00000111b = 00000110b
-10010110b & 00001000b = 00000000b
-10010110b & 00001001b = 00000000b
-10010110b & 00001010b = 00000010b
-10010110b & 00001011b = 00000010b
-10010110b & 00001100b = 00000100b
-10010110b & 00001101b = 00000100b
-10010110b & 00001110b = 00000110b
-10010110b & 00001111b = 00000110b
-10010110b & 00010000b = 00010000b
-10010110b & 00010001b = 00010000b
-10010110b & 00010010b = 00010010b
-10010110b & 00010011b = 00010010b
-10010110b & 00010100b = 00010100b
-10010110b & 00010101b = 00010100b
-10010110b & 00010110b = 00010110b
-10010110b & 00010111b = 00010110b
-10010110b & 00011000b = 00010000b
-10010110b & 00011001b = 00010000b
-10010110b & 00011010b = 00010010b
-10010110b & 00011011b = 00010010b
-10010110b & 00011100b = 00010100b
-10010110b & 00011101b = 00010100b
-10010110b & 00011110b = 00010110b
-10010110b & 00011111b = 00010110b
-10010110b & 00100000b = 00000000b
-10010110b & 00100001b = 00000000b
-10010110b & 00100010b = 00000010b
-10010110b & 00100011b = 00000010b
-10010110b & 00100100b = 00000100b
-10010110b & 00100101b = 00000100b
-10010110b & 00100110b = 00000110b
-10010110b & 00100111b = 00000110b
-10010110b & 00101000b = 00000000b
-10010110b & 00101001b = 00000000b
-10010110b & 00101010b = 00000010b
-10010110b & 00101011b = 00000010b
-10010110b & 00101100b = 00000100b
-10010110b & 00101101b = 00000100b
-10010110b & 00101110b = 00000110b
-10010110b & 00101111b = 00000110b
-10010110b & 00110000b = 00010000b
-10010110b & 00110001b = 00010000b
-10010110b & 00110010b = 00010010b
-10010110b & 00110011b = 00010010b
-10010110b & 00110100b = 00010100b
-10010110b & 00110101b = 00010100b
-10010110b & 00110110b = 00010110b
-10010110b & 00110111b = 00010110b
-10010110b & 00111000b = 00010000b
-10010110b & 00111001b = 00010000b
-10010110b & 00111010b = 00010010b
-10010110b & 00111011b = 00010010b
-10010110b & 00111100b = 00010100b
-10010110b & 00111101b = 00010100b
-10010110b & 00111110b = 00010110b
-10010110b & 00111111b = 00010110b
-10010110b & 01000000b = 00000000b
-10010110b & 01000001b = 00000000b
-10010110b & 01000010b = 00000010b
-10010110b & 01000011b = 00000010b
-10010110b & 01000100b = 00000100b
-10010110b & 01000101b = 00000100b
-10010110b & 01000110b = 00000110b
-10010110b & 01000111b = 00000110b
-10010110b & 01001000b = 00000000b
-10010110b & 01001001b = 00000000b
-10010110b & 01001010b = 00000010b
-10010110b & 01001011b = 00000010b
-10010110b & 01001100b = 00000100b
-10010110b & 01001101b = 00000100b
-10010110b & 01001110b = 00000110b
-10010110b & 01001111b = 00000110b
-10010110b & 01010000b = 00010000b
-10010110b & 01010001b = 00010000b
-10010110b & 01010010b = 00010010b
-10010110b & 01010011b = 00010010b
-10010110b & 01010100b = 00010100b
-10010110b & 01010101b = 00010100b
-10010110b & 01010110b = 00010110b
-10010110b & 01010111b = 00010110b
-10010110b & 01011000b = 00010000b
-10010110b & 01011001b = 00010000b
-10010110b & 01011010b = 00010010b
-10010110b & 01011011b = 00010010b
-10010110b & 01011100b = 00010100b
-10010110b & 01011101b = 00010100b
-10010110b & 01011110b = 00010110b
-10010110b & 01011111b = 00010110b
-10010110b & 01100000b = 00000000b
-10010110b & 01100001b = 00000000b
-10010110b & 01100010b = 00000010b
-10010110b & 01100011b = 00000010b
-10010110b & 01100100b = 00000100b
-10010110b & 01100101b = 00000100b
-10010110b & 01100110b = 00000110b
-10010110b & 01100111b = 00000110b
-10010110b & 01101000b = 00000000b
-10010110b & 01101001b = 00000000b
-10010110b & 01101010b = 00000010b
-10010110b & 01101011b = 00000010b
-10010110b & 01101100b = 00000100b
-10010110b & 01101101b = 00000100b
-10010110b & 01101110b = 00000110b
-10010110b & 01101111b = 00000110b
-10010110b & 01110000b = 00010000b
-10010110b & 01110001b = 00010000b
-10010110b & 01110010b = 00010010b
-10010110b & 01110011b = 00010010b
-10010110b & 01110100b = 00010100b
-10010110b & 01110101b = 00010100b
-10010110b & 01110110b = 00010110b
-10010110b & 01110111b = 00010110b
-10010110b & 01111000b = 00010000b
-10010110b & 01111001b = 00010000b
-10010110b & 01111010b = 00010010b
-10010110b & 01111011b = 00010010b
-10010110b & 01111100b = 00010100b
-10010110b & 01111101b = 00010100b
-10010110b & 01111110b = 00010110b
-10010111b & 10000000b = 10000000b
-10010111b & 10000001b = 10000001b
-10010111b & 10000010b = 10000010b
-10010111b & 10000011b = 10000011b
-10010111b & 10000100b = 10000100b
-10010111b & 10000101b = 10000101b
-10010111b & 10000110b = 10000110b
-10010111b & 10000111b = 10000111b
-10010111b & 10001000b = 10000000b
-10010111b & 10001001b = 10000001b
-10010111b & 10001010b = 10000010b
-10010111b & 10001011b = 10000011b
-10010111b & 10001100b = 10000100b
-10010111b & 10001101b = 10000101b
-10010111b & 10001110b = 10000110b
-10010111b & 10001111b = 10000111b
-10010111b & 10010000b = 10010000b
-10010111b & 10010001b = 10010001b
-10010111b & 10010010b = 10010010b
-10010111b & 10010011b = 10010011b
-10010111b & 10010100b = 10010100b
-10010111b & 10010101b = 10010101b
-10010111b & 10010110b = 10010110b
-10010111b & 10010111b = 10010111b
-10010111b & 10011000b = 10010000b
-10010111b & 10011001b = 10010001b
-10010111b & 10011010b = 10010010b
-10010111b & 10011011b = 10010011b
-10010111b & 10011100b = 10010100b
-10010111b & 10011101b = 10010101b
-10010111b & 10011110b = 10010110b
-10010111b & 10011111b = 10010111b
-10010111b & 10100000b = 10000000b
-10010111b & 10100001b = 10000001b
-10010111b & 10100010b = 10000010b
-10010111b & 10100011b = 10000011b
-10010111b & 10100100b = 10000100b
-10010111b & 10100101b = 10000101b
-10010111b & 10100110b = 10000110b
-10010111b & 10100111b = 10000111b
-10010111b & 10101000b = 10000000b
-10010111b & 10101001b = 10000001b
-10010111b & 10101010b = 10000010b
-10010111b & 10101011b = 10000011b
-10010111b & 10101100b = 10000100b
-10010111b & 10101101b = 10000101b
-10010111b & 10101110b = 10000110b
-10010111b & 10101111b = 10000111b
-10010111b & 10110000b = 10010000b
-10010111b & 10110001b = 10010001b
-10010111b & 10110010b = 10010010b
-10010111b & 10110011b = 10010011b
-10010111b & 10110100b = 10010100b
-10010111b & 10110101b = 10010101b
-10010111b & 10110110b = 10010110b
-10010111b & 10110111b = 10010111b
-10010111b & 10111000b = 10010000b
-10010111b & 10111001b = 10010001b
-10010111b & 10111010b = 10010010b
-10010111b & 10111011b = 10010011b
-10010111b & 10111100b = 10010100b
-10010111b & 10111101b = 10010101b
-10010111b & 10111110b = 10010110b
-10010111b & 10111111b = 10010111b
-10010111b & 11000000b = 10000000b
-10010111b & 11000001b = 10000001b
-10010111b & 11000010b = 10000010b
-10010111b & 11000011b = 10000011b
-10010111b & 11000100b = 10000100b
-10010111b & 11000101b = 10000101b
-10010111b & 11000110b = 10000110b
-10010111b & 11000111b = 10000111b
-10010111b & 11001000b = 10000000b
-10010111b & 11001001b = 10000001b
-10010111b & 11001010b = 10000010b
-10010111b & 11001011b = 10000011b
-10010111b & 11001100b = 10000100b
-10010111b & 11001101b = 10000101b
-10010111b & 11001110b = 10000110b
-10010111b & 11001111b = 10000111b
-10010111b & 11010000b = 10010000b
-10010111b & 11010001b = 10010001b
-10010111b & 11010010b = 10010010b
-10010111b & 11010011b = 10010011b
-10010111b & 11010100b = 10010100b
-10010111b & 11010101b = 10010101b
-10010111b & 11010110b = 10010110b
-10010111b & 11010111b = 10010111b
-10010111b & 11011000b = 10010000b
-10010111b & 11011001b = 10010001b
-10010111b & 11011010b = 10010010b
-10010111b & 11011011b = 10010011b
-10010111b & 11011100b = 10010100b
-10010111b & 11011101b = 10010101b
-10010111b & 11011110b = 10010110b
-10010111b & 11011111b = 10010111b
-10010111b & 11100000b = 10000000b
-10010111b & 11100001b = 10000001b
-10010111b & 11100010b = 10000010b
-10010111b & 11100011b = 10000011b
-10010111b & 11100100b = 10000100b
-10010111b & 11100101b = 10000101b
-10010111b & 11100110b = 10000110b
-10010111b & 11100111b = 10000111b
-10010111b & 11101000b = 10000000b
-10010111b & 11101001b = 10000001b
-10010111b & 11101010b = 10000010b
-10010111b & 11101011b = 10000011b
-10010111b & 11101100b = 10000100b
-10010111b & 11101101b = 10000101b
-10010111b & 11101110b = 10000110b
-10010111b & 11101111b = 10000111b
-10010111b & 11110000b = 10010000b
-10010111b & 11110001b = 10010001b
-10010111b & 11110010b = 10010010b
-10010111b & 11110011b = 10010011b
-10010111b & 11110100b = 10010100b
-10010111b & 11110101b = 10010101b
-10010111b & 11110110b = 10010110b
-10010111b & 11110111b = 10010111b
-10010111b & 11111000b = 10010000b
-10010111b & 11111001b = 10010001b
-10010111b & 11111010b = 10010010b
-10010111b & 11111011b = 10010011b
-10010111b & 11111100b = 10010100b
-10010111b & 11111101b = 10010101b
-10010111b & 11111110b = 10010110b
-10010111b & 11111111b = 10010111b
-10010111b & 00000000b = 00000000b
-10010111b & 00000001b = 00000001b
-10010111b & 00000010b = 00000010b
-10010111b & 00000011b = 00000011b
-10010111b & 00000100b = 00000100b
-10010111b & 00000101b = 00000101b
-10010111b & 00000110b = 00000110b
-10010111b & 00000111b = 00000111b
-10010111b & 00001000b = 00000000b
-10010111b & 00001001b = 00000001b
-10010111b & 00001010b = 00000010b
-10010111b & 00001011b = 00000011b
-10010111b & 00001100b = 00000100b
-10010111b & 00001101b = 00000101b
-10010111b & 00001110b = 00000110b
-10010111b & 00001111b = 00000111b
-10010111b & 00010000b = 00010000b
-10010111b & 00010001b = 00010001b
-10010111b & 00010010b = 00010010b
-10010111b & 00010011b = 00010011b
-10010111b & 00010100b = 00010100b
-10010111b & 00010101b = 00010101b
-10010111b & 00010110b = 00010110b
-10010111b & 00010111b = 00010111b
-10010111b & 00011000b = 00010000b
-10010111b & 00011001b = 00010001b
-10010111b & 00011010b = 00010010b
-10010111b & 00011011b = 00010011b
-10010111b & 00011100b = 00010100b
-10010111b & 00011101b = 00010101b
-10010111b & 00011110b = 00010110b
-10010111b & 00011111b = 00010111b
-10010111b & 00100000b = 00000000b
-10010111b & 00100001b = 00000001b
-10010111b & 00100010b = 00000010b
-10010111b & 00100011b = 00000011b
-10010111b & 00100100b = 00000100b
-10010111b & 00100101b = 00000101b
-10010111b & 00100110b = 00000110b
-10010111b & 00100111b = 00000111b
-10010111b & 00101000b = 00000000b
-10010111b & 00101001b = 00000001b
-10010111b & 00101010b = 00000010b
-10010111b & 00101011b = 00000011b
-10010111b & 00101100b = 00000100b
-10010111b & 00101101b = 00000101b
-10010111b & 00101110b = 00000110b
-10010111b & 00101111b = 00000111b
-10010111b & 00110000b = 00010000b
-10010111b & 00110001b = 00010001b
-10010111b & 00110010b = 00010010b
-10010111b & 00110011b = 00010011b
-10010111b & 00110100b = 00010100b
-10010111b & 00110101b = 00010101b
-10010111b & 00110110b = 00010110b
-10010111b & 00110111b = 00010111b
-10010111b & 00111000b = 00010000b
-10010111b & 00111001b = 00010001b
-10010111b & 00111010b = 00010010b
-10010111b & 00111011b = 00010011b
-10010111b & 00111100b = 00010100b
-10010111b & 00111101b = 00010101b
-10010111b & 00111110b = 00010110b
-10010111b & 00111111b = 00010111b
-10010111b & 01000000b = 00000000b
-10010111b & 01000001b = 00000001b
-10010111b & 01000010b = 00000010b
-10010111b & 01000011b = 00000011b
-10010111b & 01000100b = 00000100b
-10010111b & 01000101b = 00000101b
-10010111b & 01000110b = 00000110b
-10010111b & 01000111b = 00000111b
-10010111b & 01001000b = 00000000b
-10010111b & 01001001b = 00000001b
-10010111b & 01001010b = 00000010b
-10010111b & 01001011b = 00000011b
-10010111b & 01001100b = 00000100b
-10010111b & 01001101b = 00000101b
-10010111b & 01001110b = 00000110b
-10010111b & 01001111b = 00000111b
-10010111b & 01010000b = 00010000b
-10010111b & 01010001b = 00010001b
-10010111b & 01010010b = 00010010b
-10010111b & 01010011b = 00010011b
-10010111b & 01010100b = 00010100b
-10010111b & 01010101b = 00010101b
-10010111b & 01010110b = 00010110b
-10010111b & 01010111b = 00010111b
-10010111b & 01011000b = 00010000b
-10010111b & 01011001b = 00010001b
-10010111b & 01011010b = 00010010b
-10010111b & 01011011b = 00010011b
-10010111b & 01011100b = 00010100b
-10010111b & 01011101b = 00010101b
-10010111b & 01011110b = 00010110b
-10010111b & 01011111b = 00010111b
-10010111b & 01100000b = 00000000b
-10010111b & 01100001b = 00000001b
-10010111b & 01100010b = 00000010b
-10010111b & 01100011b = 00000011b
-10010111b & 01100100b = 00000100b
-10010111b & 01100101b = 00000101b
-10010111b & 01100110b = 00000110b
-10010111b & 01100111b = 00000111b
-10010111b & 01101000b = 00000000b
-10010111b & 01101001b = 00000001b
-10010111b & 01101010b = 00000010b
-10010111b & 01101011b = 00000011b
-10010111b & 01101100b = 00000100b
-10010111b & 01101101b = 00000101b
-10010111b & 01101110b = 00000110b
-10010111b & 01101111b = 00000111b
-10010111b & 01110000b = 00010000b
-10010111b & 01110001b = 00010001b
-10010111b & 01110010b = 00010010b
-10010111b & 01110011b = 00010011b
-10010111b & 01110100b = 00010100b
-10010111b & 01110101b = 00010101b
-10010111b & 01110110b = 00010110b
-10010111b & 01110111b = 00010111b
-10010111b & 01111000b = 00010000b
-10010111b & 01111001b = 00010001b
-10010111b & 01111010b = 00010010b
-10010111b & 01111011b = 00010011b
-10010111b & 01111100b = 00010100b
-10010111b & 01111101b = 00010101b
-10010111b & 01111110b = 00010110b
-10011000b & 10000000b = 10000000b
-10011000b & 10000001b = 10000000b
-10011000b & 10000010b = 10000000b
-10011000b & 10000011b = 10000000b
-10011000b & 10000100b = 10000000b
-10011000b & 10000101b = 10000000b
-10011000b & 10000110b = 10000000b
-10011000b & 10000111b = 10000000b
-10011000b & 10001000b = 10001000b
-10011000b & 10001001b = 10001000b
-10011000b & 10001010b = 10001000b
-10011000b & 10001011b = 10001000b
-10011000b & 10001100b = 10001000b
-10011000b & 10001101b = 10001000b
-10011000b & 10001110b = 10001000b
-10011000b & 10001111b = 10001000b
-10011000b & 10010000b = 10010000b
-10011000b & 10010001b = 10010000b
-10011000b & 10010010b = 10010000b
-10011000b & 10010011b = 10010000b
-10011000b & 10010100b = 10010000b
-10011000b & 10010101b = 10010000b
-10011000b & 10010110b = 10010000b
-10011000b & 10010111b = 10010000b
-10011000b & 10011000b = 10011000b
-10011000b & 10011001b = 10011000b
-10011000b & 10011010b = 10011000b
-10011000b & 10011011b = 10011000b
-10011000b & 10011100b = 10011000b
-10011000b & 10011101b = 10011000b
-10011000b & 10011110b = 10011000b
-10011000b & 10011111b = 10011000b
-10011000b & 10100000b = 10000000b
-10011000b & 10100001b = 10000000b
-10011000b & 10100010b = 10000000b
-10011000b & 10100011b = 10000000b
-10011000b & 10100100b = 10000000b
-10011000b & 10100101b = 10000000b
-10011000b & 10100110b = 10000000b
-10011000b & 10100111b = 10000000b
-10011000b & 10101000b = 10001000b
-10011000b & 10101001b = 10001000b
-10011000b & 10101010b = 10001000b
-10011000b & 10101011b = 10001000b
-10011000b & 10101100b = 10001000b
-10011000b & 10101101b = 10001000b
-10011000b & 10101110b = 10001000b
-10011000b & 10101111b = 10001000b
-10011000b & 10110000b = 10010000b
-10011000b & 10110001b = 10010000b
-10011000b & 10110010b = 10010000b
-10011000b & 10110011b = 10010000b
-10011000b & 10110100b = 10010000b
-10011000b & 10110101b = 10010000b
-10011000b & 10110110b = 10010000b
-10011000b & 10110111b = 10010000b
-10011000b & 10111000b = 10011000b
-10011000b & 10111001b = 10011000b
-10011000b & 10111010b = 10011000b
-10011000b & 10111011b = 10011000b
-10011000b & 10111100b = 10011000b
-10011000b & 10111101b = 10011000b
-10011000b & 10111110b = 10011000b
-10011000b & 10111111b = 10011000b
-10011000b & 11000000b = 10000000b
-10011000b & 11000001b = 10000000b
-10011000b & 11000010b = 10000000b
-10011000b & 11000011b = 10000000b
-10011000b & 11000100b = 10000000b
-10011000b & 11000101b = 10000000b
-10011000b & 11000110b = 10000000b
-10011000b & 11000111b = 10000000b
-10011000b & 11001000b = 10001000b
-10011000b & 11001001b = 10001000b
-10011000b & 11001010b = 10001000b
-10011000b & 11001011b = 10001000b
-10011000b & 11001100b = 10001000b
-10011000b & 11001101b = 10001000b
-10011000b & 11001110b = 10001000b
-10011000b & 11001111b = 10001000b
-10011000b & 11010000b = 10010000b
-10011000b & 11010001b = 10010000b
-10011000b & 11010010b = 10010000b
-10011000b & 11010011b = 10010000b
-10011000b & 11010100b = 10010000b
-10011000b & 11010101b = 10010000b
-10011000b & 11010110b = 10010000b
-10011000b & 11010111b = 10010000b
-10011000b & 11011000b = 10011000b
-10011000b & 11011001b = 10011000b
-10011000b & 11011010b = 10011000b
-10011000b & 11011011b = 10011000b
-10011000b & 11011100b = 10011000b
-10011000b & 11011101b = 10011000b
-10011000b & 11011110b = 10011000b
-10011000b & 11011111b = 10011000b
-10011000b & 11100000b = 10000000b
-10011000b & 11100001b = 10000000b
-10011000b & 11100010b = 10000000b
-10011000b & 11100011b = 10000000b
-10011000b & 11100100b = 10000000b
-10011000b & 11100101b = 10000000b
-10011000b & 11100110b = 10000000b
-10011000b & 11100111b = 10000000b
-10011000b & 11101000b = 10001000b
-10011000b & 11101001b = 10001000b
-10011000b & 11101010b = 10001000b
-10011000b & 11101011b = 10001000b
-10011000b & 11101100b = 10001000b
-10011000b & 11101101b = 10001000b
-10011000b & 11101110b = 10001000b
-10011000b & 11101111b = 10001000b
-10011000b & 11110000b = 10010000b
-10011000b & 11110001b = 10010000b
-10011000b & 11110010b = 10010000b
-10011000b & 11110011b = 10010000b
-10011000b & 11110100b = 10010000b
-10011000b & 11110101b = 10010000b
-10011000b & 11110110b = 10010000b
-10011000b & 11110111b = 10010000b
-10011000b & 11111000b = 10011000b
-10011000b & 11111001b = 10011000b
-10011000b & 11111010b = 10011000b
-10011000b & 11111011b = 10011000b
-10011000b & 11111100b = 10011000b
-10011000b & 11111101b = 10011000b
-10011000b & 11111110b = 10011000b
-10011000b & 11111111b = 10011000b
-10011000b & 00000000b = 00000000b
-10011000b & 00000001b = 00000000b
-10011000b & 00000010b = 00000000b
-10011000b & 00000011b = 00000000b
-10011000b & 00000100b = 00000000b
-10011000b & 00000101b = 00000000b
-10011000b & 00000110b = 00000000b
-10011000b & 00000111b = 00000000b
-10011000b & 00001000b = 00001000b
-10011000b & 00001001b = 00001000b
-10011000b & 00001010b = 00001000b
-10011000b & 00001011b = 00001000b
-10011000b & 00001100b = 00001000b
-10011000b & 00001101b = 00001000b
-10011000b & 00001110b = 00001000b
-10011000b & 00001111b = 00001000b
-10011000b & 00010000b = 00010000b
-10011000b & 00010001b = 00010000b
-10011000b & 00010010b = 00010000b
-10011000b & 00010011b = 00010000b
-10011000b & 00010100b = 00010000b
-10011000b & 00010101b = 00010000b
-10011000b & 00010110b = 00010000b
-10011000b & 00010111b = 00010000b
-10011000b & 00011000b = 00011000b
-10011000b & 00011001b = 00011000b
-10011000b & 00011010b = 00011000b
-10011000b & 00011011b = 00011000b
-10011000b & 00011100b = 00011000b
-10011000b & 00011101b = 00011000b
-10011000b & 00011110b = 00011000b
-10011000b & 00011111b = 00011000b
-10011000b & 00100000b = 00000000b
-10011000b & 00100001b = 00000000b
-10011000b & 00100010b = 00000000b
-10011000b & 00100011b = 00000000b
-10011000b & 00100100b = 00000000b
-10011000b & 00100101b = 00000000b
-10011000b & 00100110b = 00000000b
-10011000b & 00100111b = 00000000b
-10011000b & 00101000b = 00001000b
-10011000b & 00101001b = 00001000b
-10011000b & 00101010b = 00001000b
-10011000b & 00101011b = 00001000b
-10011000b & 00101100b = 00001000b
-10011000b & 00101101b = 00001000b
-10011000b & 00101110b = 00001000b
-10011000b & 00101111b = 00001000b
-10011000b & 00110000b = 00010000b
-10011000b & 00110001b = 00010000b
-10011000b & 00110010b = 00010000b
-10011000b & 00110011b = 00010000b
-10011000b & 00110100b = 00010000b
-10011000b & 00110101b = 00010000b
-10011000b & 00110110b = 00010000b
-10011000b & 00110111b = 00010000b
-10011000b & 00111000b = 00011000b
-10011000b & 00111001b = 00011000b
-10011000b & 00111010b = 00011000b
-10011000b & 00111011b = 00011000b
-10011000b & 00111100b = 00011000b
-10011000b & 00111101b = 00011000b
-10011000b & 00111110b = 00011000b
-10011000b & 00111111b = 00011000b
-10011000b & 01000000b = 00000000b
-10011000b & 01000001b = 00000000b
-10011000b & 01000010b = 00000000b
-10011000b & 01000011b = 00000000b
-10011000b & 01000100b = 00000000b
-10011000b & 01000101b = 00000000b
-10011000b & 01000110b = 00000000b
-10011000b & 01000111b = 00000000b
-10011000b & 01001000b = 00001000b
-10011000b & 01001001b = 00001000b
-10011000b & 01001010b = 00001000b
-10011000b & 01001011b = 00001000b
-10011000b & 01001100b = 00001000b
-10011000b & 01001101b = 00001000b
-10011000b & 01001110b = 00001000b
-10011000b & 01001111b = 00001000b
-10011000b & 01010000b = 00010000b
-10011000b & 01010001b = 00010000b
-10011000b & 01010010b = 00010000b
-10011000b & 01010011b = 00010000b
-10011000b & 01010100b = 00010000b
-10011000b & 01010101b = 00010000b
-10011000b & 01010110b = 00010000b
-10011000b & 01010111b = 00010000b
-10011000b & 01011000b = 00011000b
-10011000b & 01011001b = 00011000b
-10011000b & 01011010b = 00011000b
-10011000b & 01011011b = 00011000b
-10011000b & 01011100b = 00011000b
-10011000b & 01011101b = 00011000b
-10011000b & 01011110b = 00011000b
-10011000b & 01011111b = 00011000b
-10011000b & 01100000b = 00000000b
-10011000b & 01100001b = 00000000b
-10011000b & 01100010b = 00000000b
-10011000b & 01100011b = 00000000b
-10011000b & 01100100b = 00000000b
-10011000b & 01100101b = 00000000b
-10011000b & 01100110b = 00000000b
-10011000b & 01100111b = 00000000b
-10011000b & 01101000b = 00001000b
-10011000b & 01101001b = 00001000b
-10011000b & 01101010b = 00001000b
-10011000b & 01101011b = 00001000b
-10011000b & 01101100b = 00001000b
-10011000b & 01101101b = 00001000b
-10011000b & 01101110b = 00001000b
-10011000b & 01101111b = 00001000b
-10011000b & 01110000b = 00010000b
-10011000b & 01110001b = 00010000b
-10011000b & 01110010b = 00010000b
-10011000b & 01110011b = 00010000b
-10011000b & 01110100b = 00010000b
-10011000b & 01110101b = 00010000b
-10011000b & 01110110b = 00010000b
-10011000b & 01110111b = 00010000b
-10011000b & 01111000b = 00011000b
-10011000b & 01111001b = 00011000b
-10011000b & 01111010b = 00011000b
-10011000b & 01111011b = 00011000b
-10011000b & 01111100b = 00011000b
-10011000b & 01111101b = 00011000b
-10011000b & 01111110b = 00011000b
-10011001b & 10000000b = 10000000b
-10011001b & 10000001b = 10000001b
-10011001b & 10000010b = 10000000b
-10011001b & 10000011b = 10000001b
-10011001b & 10000100b = 10000000b
-10011001b & 10000101b = 10000001b
-10011001b & 10000110b = 10000000b
-10011001b & 10000111b = 10000001b
-10011001b & 10001000b = 10001000b
-10011001b & 10001001b = 10001001b
-10011001b & 10001010b = 10001000b
-10011001b & 10001011b = 10001001b
-10011001b & 10001100b = 10001000b
-10011001b & 10001101b = 10001001b
-10011001b & 10001110b = 10001000b
-10011001b & 10001111b = 10001001b
-10011001b & 10010000b = 10010000b
-10011001b & 10010001b = 10010001b
-10011001b & 10010010b = 10010000b
-10011001b & 10010011b = 10010001b
-10011001b & 10010100b = 10010000b
-10011001b & 10010101b = 10010001b
-10011001b & 10010110b = 10010000b
-10011001b & 10010111b = 10010001b
-10011001b & 10011000b = 10011000b
-10011001b & 10011001b = 10011001b
-10011001b & 10011010b = 10011000b
-10011001b & 10011011b = 10011001b
-10011001b & 10011100b = 10011000b
-10011001b & 10011101b = 10011001b
-10011001b & 10011110b = 10011000b
-10011001b & 10011111b = 10011001b
-10011001b & 10100000b = 10000000b
-10011001b & 10100001b = 10000001b
-10011001b & 10100010b = 10000000b
-10011001b & 10100011b = 10000001b
-10011001b & 10100100b = 10000000b
-10011001b & 10100101b = 10000001b
-10011001b & 10100110b = 10000000b
-10011001b & 10100111b = 10000001b
-10011001b & 10101000b = 10001000b
-10011001b & 10101001b = 10001001b
-10011001b & 10101010b = 10001000b
-10011001b & 10101011b = 10001001b
-10011001b & 10101100b = 10001000b
-10011001b & 10101101b = 10001001b
-10011001b & 10101110b = 10001000b
-10011001b & 10101111b = 10001001b
-10011001b & 10110000b = 10010000b
-10011001b & 10110001b = 10010001b
-10011001b & 10110010b = 10010000b
-10011001b & 10110011b = 10010001b
-10011001b & 10110100b = 10010000b
-10011001b & 10110101b = 10010001b
-10011001b & 10110110b = 10010000b
-10011001b & 10110111b = 10010001b
-10011001b & 10111000b = 10011000b
-10011001b & 10111001b = 10011001b
-10011001b & 10111010b = 10011000b
-10011001b & 10111011b = 10011001b
-10011001b & 10111100b = 10011000b
-10011001b & 10111101b = 10011001b
-10011001b & 10111110b = 10011000b
-10011001b & 10111111b = 10011001b
-10011001b & 11000000b = 10000000b
-10011001b & 11000001b = 10000001b
-10011001b & 11000010b = 10000000b
-10011001b & 11000011b = 10000001b
-10011001b & 11000100b = 10000000b
-10011001b & 11000101b = 10000001b
-10011001b & 11000110b = 10000000b
-10011001b & 11000111b = 10000001b
-10011001b & 11001000b = 10001000b
-10011001b & 11001001b = 10001001b
-10011001b & 11001010b = 10001000b
-10011001b & 11001011b = 10001001b
-10011001b & 11001100b = 10001000b
-10011001b & 11001101b = 10001001b
-10011001b & 11001110b = 10001000b
-10011001b & 11001111b = 10001001b
-10011001b & 11010000b = 10010000b
-10011001b & 11010001b = 10010001b
-10011001b & 11010010b = 10010000b
-10011001b & 11010011b = 10010001b
-10011001b & 11010100b = 10010000b
-10011001b & 11010101b = 10010001b
-10011001b & 11010110b = 10010000b
-10011001b & 11010111b = 10010001b
-10011001b & 11011000b = 10011000b
-10011001b & 11011001b = 10011001b
-10011001b & 11011010b = 10011000b
-10011001b & 11011011b = 10011001b
-10011001b & 11011100b = 10011000b
-10011001b & 11011101b = 10011001b
-10011001b & 11011110b = 10011000b
-10011001b & 11011111b = 10011001b
-10011001b & 11100000b = 10000000b
-10011001b & 11100001b = 10000001b
-10011001b & 11100010b = 10000000b
-10011001b & 11100011b = 10000001b
-10011001b & 11100100b = 10000000b
-10011001b & 11100101b = 10000001b
-10011001b & 11100110b = 10000000b
-10011001b & 11100111b = 10000001b
-10011001b & 11101000b = 10001000b
-10011001b & 11101001b = 10001001b
-10011001b & 11101010b = 10001000b
-10011001b & 11101011b = 10001001b
-10011001b & 11101100b = 10001000b
-10011001b & 11101101b = 10001001b
-10011001b & 11101110b = 10001000b
-10011001b & 11101111b = 10001001b
-10011001b & 11110000b = 10010000b
-10011001b & 11110001b = 10010001b
-10011001b & 11110010b = 10010000b
-10011001b & 11110011b = 10010001b
-10011001b & 11110100b = 10010000b
-10011001b & 11110101b = 10010001b
-10011001b & 11110110b = 10010000b
-10011001b & 11110111b = 10010001b
-10011001b & 11111000b = 10011000b
-10011001b & 11111001b = 10011001b
-10011001b & 11111010b = 10011000b
-10011001b & 11111011b = 10011001b
-10011001b & 11111100b = 10011000b
-10011001b & 11111101b = 10011001b
-10011001b & 11111110b = 10011000b
-10011001b & 11111111b = 10011001b
-10011001b & 00000000b = 00000000b
-10011001b & 00000001b = 00000001b
-10011001b & 00000010b = 00000000b
-10011001b & 00000011b = 00000001b
-10011001b & 00000100b = 00000000b
-10011001b & 00000101b = 00000001b
-10011001b & 00000110b = 00000000b
-10011001b & 00000111b = 00000001b
-10011001b & 00001000b = 00001000b
-10011001b & 00001001b = 00001001b
-10011001b & 00001010b = 00001000b
-10011001b & 00001011b = 00001001b
-10011001b & 00001100b = 00001000b
-10011001b & 00001101b = 00001001b
-10011001b & 00001110b = 00001000b
-10011001b & 00001111b = 00001001b
-10011001b & 00010000b = 00010000b
-10011001b & 00010001b = 00010001b
-10011001b & 00010010b = 00010000b
-10011001b & 00010011b = 00010001b
-10011001b & 00010100b = 00010000b
-10011001b & 00010101b = 00010001b
-10011001b & 00010110b = 00010000b
-10011001b & 00010111b = 00010001b
-10011001b & 00011000b = 00011000b
-10011001b & 00011001b = 00011001b
-10011001b & 00011010b = 00011000b
-10011001b & 00011011b = 00011001b
-10011001b & 00011100b = 00011000b
-10011001b & 00011101b = 00011001b
-10011001b & 00011110b = 00011000b
-10011001b & 00011111b = 00011001b
-10011001b & 00100000b = 00000000b
-10011001b & 00100001b = 00000001b
-10011001b & 00100010b = 00000000b
-10011001b & 00100011b = 00000001b
-10011001b & 00100100b = 00000000b
-10011001b & 00100101b = 00000001b
-10011001b & 00100110b = 00000000b
-10011001b & 00100111b = 00000001b
-10011001b & 00101000b = 00001000b
-10011001b & 00101001b = 00001001b
-10011001b & 00101010b = 00001000b
-10011001b & 00101011b = 00001001b
-10011001b & 00101100b = 00001000b
-10011001b & 00101101b = 00001001b
-10011001b & 00101110b = 00001000b
-10011001b & 00101111b = 00001001b
-10011001b & 00110000b = 00010000b
-10011001b & 00110001b = 00010001b
-10011001b & 00110010b = 00010000b
-10011001b & 00110011b = 00010001b
-10011001b & 00110100b = 00010000b
-10011001b & 00110101b = 00010001b
-10011001b & 00110110b = 00010000b
-10011001b & 00110111b = 00010001b
-10011001b & 00111000b = 00011000b
-10011001b & 00111001b = 00011001b
-10011001b & 00111010b = 00011000b
-10011001b & 00111011b = 00011001b
-10011001b & 00111100b = 00011000b
-10011001b & 00111101b = 00011001b
-10011001b & 00111110b = 00011000b
-10011001b & 00111111b = 00011001b
-10011001b & 01000000b = 00000000b
-10011001b & 01000001b = 00000001b
-10011001b & 01000010b = 00000000b
-10011001b & 01000011b = 00000001b
-10011001b & 01000100b = 00000000b
-10011001b & 01000101b = 00000001b
-10011001b & 01000110b = 00000000b
-10011001b & 01000111b = 00000001b
-10011001b & 01001000b = 00001000b
-10011001b & 01001001b = 00001001b
-10011001b & 01001010b = 00001000b
-10011001b & 01001011b = 00001001b
-10011001b & 01001100b = 00001000b
-10011001b & 01001101b = 00001001b
-10011001b & 01001110b = 00001000b
-10011001b & 01001111b = 00001001b
-10011001b & 01010000b = 00010000b
-10011001b & 01010001b = 00010001b
-10011001b & 01010010b = 00010000b
-10011001b & 01010011b = 00010001b
-10011001b & 01010100b = 00010000b
-10011001b & 01010101b = 00010001b
-10011001b & 01010110b = 00010000b
-10011001b & 01010111b = 00010001b
-10011001b & 01011000b = 00011000b
-10011001b & 01011001b = 00011001b
-10011001b & 01011010b = 00011000b
-10011001b & 01011011b = 00011001b
-10011001b & 01011100b = 00011000b
-10011001b & 01011101b = 00011001b
-10011001b & 01011110b = 00011000b
-10011001b & 01011111b = 00011001b
-10011001b & 01100000b = 00000000b
-10011001b & 01100001b = 00000001b
-10011001b & 01100010b = 00000000b
-10011001b & 01100011b = 00000001b
-10011001b & 01100100b = 00000000b
-10011001b & 01100101b = 00000001b
-10011001b & 01100110b = 00000000b
-10011001b & 01100111b = 00000001b
-10011001b & 01101000b = 00001000b
-10011001b & 01101001b = 00001001b
-10011001b & 01101010b = 00001000b
-10011001b & 01101011b = 00001001b
-10011001b & 01101100b = 00001000b
-10011001b & 01101101b = 00001001b
-10011001b & 01101110b = 00001000b
-10011001b & 01101111b = 00001001b
-10011001b & 01110000b = 00010000b
-10011001b & 01110001b = 00010001b
-10011001b & 01110010b = 00010000b
-10011001b & 01110011b = 00010001b
-10011001b & 01110100b = 00010000b
-10011001b & 01110101b = 00010001b
-10011001b & 01110110b = 00010000b
-10011001b & 01110111b = 00010001b
-10011001b & 01111000b = 00011000b
-10011001b & 01111001b = 00011001b
-10011001b & 01111010b = 00011000b
-10011001b & 01111011b = 00011001b
-10011001b & 01111100b = 00011000b
-10011001b & 01111101b = 00011001b
-10011001b & 01111110b = 00011000b
-10011010b & 10000000b = 10000000b
-10011010b & 10000001b = 10000000b
-10011010b & 10000010b = 10000010b
-10011010b & 10000011b = 10000010b
-10011010b & 10000100b = 10000000b
-10011010b & 10000101b = 10000000b
-10011010b & 10000110b = 10000010b
-10011010b & 10000111b = 10000010b
-10011010b & 10001000b = 10001000b
-10011010b & 10001001b = 10001000b
-10011010b & 10001010b = 10001010b
-10011010b & 10001011b = 10001010b
-10011010b & 10001100b = 10001000b
-10011010b & 10001101b = 10001000b
-10011010b & 10001110b = 10001010b
-10011010b & 10001111b = 10001010b
-10011010b & 10010000b = 10010000b
-10011010b & 10010001b = 10010000b
-10011010b & 10010010b = 10010010b
-10011010b & 10010011b = 10010010b
-10011010b & 10010100b = 10010000b
-10011010b & 10010101b = 10010000b
-10011010b & 10010110b = 10010010b
-10011010b & 10010111b = 10010010b
-10011010b & 10011000b = 10011000b
-10011010b & 10011001b = 10011000b
-10011010b & 10011010b = 10011010b
-10011010b & 10011011b = 10011010b
-10011010b & 10011100b = 10011000b
-10011010b & 10011101b = 10011000b
-10011010b & 10011110b = 10011010b
-10011010b & 10011111b = 10011010b
-10011010b & 10100000b = 10000000b
-10011010b & 10100001b = 10000000b
-10011010b & 10100010b = 10000010b
-10011010b & 10100011b = 10000010b
-10011010b & 10100100b = 10000000b
-10011010b & 10100101b = 10000000b
-10011010b & 10100110b = 10000010b
-10011010b & 10100111b = 10000010b
-10011010b & 10101000b = 10001000b
-10011010b & 10101001b = 10001000b
-10011010b & 10101010b = 10001010b
-10011010b & 10101011b = 10001010b
-10011010b & 10101100b = 10001000b
-10011010b & 10101101b = 10001000b
-10011010b & 10101110b = 10001010b
-10011010b & 10101111b = 10001010b
-10011010b & 10110000b = 10010000b
-10011010b & 10110001b = 10010000b
-10011010b & 10110010b = 10010010b
-10011010b & 10110011b = 10010010b
-10011010b & 10110100b = 10010000b
-10011010b & 10110101b = 10010000b
-10011010b & 10110110b = 10010010b
-10011010b & 10110111b = 10010010b
-10011010b & 10111000b = 10011000b
-10011010b & 10111001b = 10011000b
-10011010b & 10111010b = 10011010b
-10011010b & 10111011b = 10011010b
-10011010b & 10111100b = 10011000b
-10011010b & 10111101b = 10011000b
-10011010b & 10111110b = 10011010b
-10011010b & 10111111b = 10011010b
-10011010b & 11000000b = 10000000b
-10011010b & 11000001b = 10000000b
-10011010b & 11000010b = 10000010b
-10011010b & 11000011b = 10000010b
-10011010b & 11000100b = 10000000b
-10011010b & 11000101b = 10000000b
-10011010b & 11000110b = 10000010b
-10011010b & 11000111b = 10000010b
-10011010b & 11001000b = 10001000b
-10011010b & 11001001b = 10001000b
-10011010b & 11001010b = 10001010b
-10011010b & 11001011b = 10001010b
-10011010b & 11001100b = 10001000b
-10011010b & 11001101b = 10001000b
-10011010b & 11001110b = 10001010b
-10011010b & 11001111b = 10001010b
-10011010b & 11010000b = 10010000b
-10011010b & 11010001b = 10010000b
-10011010b & 11010010b = 10010010b
-10011010b & 11010011b = 10010010b
-10011010b & 11010100b = 10010000b
-10011010b & 11010101b = 10010000b
-10011010b & 11010110b = 10010010b
-10011010b & 11010111b = 10010010b
-10011010b & 11011000b = 10011000b
-10011010b & 11011001b = 10011000b
-10011010b & 11011010b = 10011010b
-10011010b & 11011011b = 10011010b
-10011010b & 11011100b = 10011000b
-10011010b & 11011101b = 10011000b
-10011010b & 11011110b = 10011010b
-10011010b & 11011111b = 10011010b
-10011010b & 11100000b = 10000000b
-10011010b & 11100001b = 10000000b
-10011010b & 11100010b = 10000010b
-10011010b & 11100011b = 10000010b
-10011010b & 11100100b = 10000000b
-10011010b & 11100101b = 10000000b
-10011010b & 11100110b = 10000010b
-10011010b & 11100111b = 10000010b
-10011010b & 11101000b = 10001000b
-10011010b & 11101001b = 10001000b
-10011010b & 11101010b = 10001010b
-10011010b & 11101011b = 10001010b
-10011010b & 11101100b = 10001000b
-10011010b & 11101101b = 10001000b
-10011010b & 11101110b = 10001010b
-10011010b & 11101111b = 10001010b
-10011010b & 11110000b = 10010000b
-10011010b & 11110001b = 10010000b
-10011010b & 11110010b = 10010010b
-10011010b & 11110011b = 10010010b
-10011010b & 11110100b = 10010000b
-10011010b & 11110101b = 10010000b
-10011010b & 11110110b = 10010010b
-10011010b & 11110111b = 10010010b
-10011010b & 11111000b = 10011000b
-10011010b & 11111001b = 10011000b
-10011010b & 11111010b = 10011010b
-10011010b & 11111011b = 10011010b
-10011010b & 11111100b = 10011000b
-10011010b & 11111101b = 10011000b
-10011010b & 11111110b = 10011010b
-10011010b & 11111111b = 10011010b
-10011010b & 00000000b = 00000000b
-10011010b & 00000001b = 00000000b
-10011010b & 00000010b = 00000010b
-10011010b & 00000011b = 00000010b
-10011010b & 00000100b = 00000000b
-10011010b & 00000101b = 00000000b
-10011010b & 00000110b = 00000010b
-10011010b & 00000111b = 00000010b
-10011010b & 00001000b = 00001000b
-10011010b & 00001001b = 00001000b
-10011010b & 00001010b = 00001010b
-10011010b & 00001011b = 00001010b
-10011010b & 00001100b = 00001000b
-10011010b & 00001101b = 00001000b
-10011010b & 00001110b = 00001010b
-10011010b & 00001111b = 00001010b
-10011010b & 00010000b = 00010000b
-10011010b & 00010001b = 00010000b
-10011010b & 00010010b = 00010010b
-10011010b & 00010011b = 00010010b
-10011010b & 00010100b = 00010000b
-10011010b & 00010101b = 00010000b
-10011010b & 00010110b = 00010010b
-10011010b & 00010111b = 00010010b
-10011010b & 00011000b = 00011000b
-10011010b & 00011001b = 00011000b
-10011010b & 00011010b = 00011010b
-10011010b & 00011011b = 00011010b
-10011010b & 00011100b = 00011000b
-10011010b & 00011101b = 00011000b
-10011010b & 00011110b = 00011010b
-10011010b & 00011111b = 00011010b
-10011010b & 00100000b = 00000000b
-10011010b & 00100001b = 00000000b
-10011010b & 00100010b = 00000010b
-10011010b & 00100011b = 00000010b
-10011010b & 00100100b = 00000000b
-10011010b & 00100101b = 00000000b
-10011010b & 00100110b = 00000010b
-10011010b & 00100111b = 00000010b
-10011010b & 00101000b = 00001000b
-10011010b & 00101001b = 00001000b
-10011010b & 00101010b = 00001010b
-10011010b & 00101011b = 00001010b
-10011010b & 00101100b = 00001000b
-10011010b & 00101101b = 00001000b
-10011010b & 00101110b = 00001010b
-10011010b & 00101111b = 00001010b
-10011010b & 00110000b = 00010000b
-10011010b & 00110001b = 00010000b
-10011010b & 00110010b = 00010010b
-10011010b & 00110011b = 00010010b
-10011010b & 00110100b = 00010000b
-10011010b & 00110101b = 00010000b
-10011010b & 00110110b = 00010010b
-10011010b & 00110111b = 00010010b
-10011010b & 00111000b = 00011000b
-10011010b & 00111001b = 00011000b
-10011010b & 00111010b = 00011010b
-10011010b & 00111011b = 00011010b
-10011010b & 00111100b = 00011000b
-10011010b & 00111101b = 00011000b
-10011010b & 00111110b = 00011010b
-10011010b & 00111111b = 00011010b
-10011010b & 01000000b = 00000000b
-10011010b & 01000001b = 00000000b
-10011010b & 01000010b = 00000010b
-10011010b & 01000011b = 00000010b
-10011010b & 01000100b = 00000000b
-10011010b & 01000101b = 00000000b
-10011010b & 01000110b = 00000010b
-10011010b & 01000111b = 00000010b
-10011010b & 01001000b = 00001000b
-10011010b & 01001001b = 00001000b
-10011010b & 01001010b = 00001010b
-10011010b & 01001011b = 00001010b
-10011010b & 01001100b = 00001000b
-10011010b & 01001101b = 00001000b
-10011010b & 01001110b = 00001010b
-10011010b & 01001111b = 00001010b
-10011010b & 01010000b = 00010000b
-10011010b & 01010001b = 00010000b
-10011010b & 01010010b = 00010010b
-10011010b & 01010011b = 00010010b
-10011010b & 01010100b = 00010000b
-10011010b & 01010101b = 00010000b
-10011010b & 01010110b = 00010010b
-10011010b & 01010111b = 00010010b
-10011010b & 01011000b = 00011000b
-10011010b & 01011001b = 00011000b
-10011010b & 01011010b = 00011010b
-10011010b & 01011011b = 00011010b
-10011010b & 01011100b = 00011000b
-10011010b & 01011101b = 00011000b
-10011010b & 01011110b = 00011010b
-10011010b & 01011111b = 00011010b
-10011010b & 01100000b = 00000000b
-10011010b & 01100001b = 00000000b
-10011010b & 01100010b = 00000010b
-10011010b & 01100011b = 00000010b
-10011010b & 01100100b = 00000000b
-10011010b & 01100101b = 00000000b
-10011010b & 01100110b = 00000010b
-10011010b & 01100111b = 00000010b
-10011010b & 01101000b = 00001000b
-10011010b & 01101001b = 00001000b
-10011010b & 01101010b = 00001010b
-10011010b & 01101011b = 00001010b
-10011010b & 01101100b = 00001000b
-10011010b & 01101101b = 00001000b
-10011010b & 01101110b = 00001010b
-10011010b & 01101111b = 00001010b
-10011010b & 01110000b = 00010000b
-10011010b & 01110001b = 00010000b
-10011010b & 01110010b = 00010010b
-10011010b & 01110011b = 00010010b
-10011010b & 01110100b = 00010000b
-10011010b & 01110101b = 00010000b
-10011010b & 01110110b = 00010010b
-10011010b & 01110111b = 00010010b
-10011010b & 01111000b = 00011000b
-10011010b & 01111001b = 00011000b
-10011010b & 01111010b = 00011010b
-10011010b & 01111011b = 00011010b
-10011010b & 01111100b = 00011000b
-10011010b & 01111101b = 00011000b
-10011010b & 01111110b = 00011010b
-10011011b & 10000000b = 10000000b
-10011011b & 10000001b = 10000001b
-10011011b & 10000010b = 10000010b
-10011011b & 10000011b = 10000011b
-10011011b & 10000100b = 10000000b
-10011011b & 10000101b = 10000001b
-10011011b & 10000110b = 10000010b
-10011011b & 10000111b = 10000011b
-10011011b & 10001000b = 10001000b
-10011011b & 10001001b = 10001001b
-10011011b & 10001010b = 10001010b
-10011011b & 10001011b = 10001011b
-10011011b & 10001100b = 10001000b
-10011011b & 10001101b = 10001001b
-10011011b & 10001110b = 10001010b
-10011011b & 10001111b = 10001011b
-10011011b & 10010000b = 10010000b
-10011011b & 10010001b = 10010001b
-10011011b & 10010010b = 10010010b
-10011011b & 10010011b = 10010011b
-10011011b & 10010100b = 10010000b
-10011011b & 10010101b = 10010001b
-10011011b & 10010110b = 10010010b
-10011011b & 10010111b = 10010011b
-10011011b & 10011000b = 10011000b
-10011011b & 10011001b = 10011001b
-10011011b & 10011010b = 10011010b
-10011011b & 10011011b = 10011011b
-10011011b & 10011100b = 10011000b
-10011011b & 10011101b = 10011001b
-10011011b & 10011110b = 10011010b
-10011011b & 10011111b = 10011011b
-10011011b & 10100000b = 10000000b
-10011011b & 10100001b = 10000001b
-10011011b & 10100010b = 10000010b
-10011011b & 10100011b = 10000011b
-10011011b & 10100100b = 10000000b
-10011011b & 10100101b = 10000001b
-10011011b & 10100110b = 10000010b
-10011011b & 10100111b = 10000011b
-10011011b & 10101000b = 10001000b
-10011011b & 10101001b = 10001001b
-10011011b & 10101010b = 10001010b
-10011011b & 10101011b = 10001011b
-10011011b & 10101100b = 10001000b
-10011011b & 10101101b = 10001001b
-10011011b & 10101110b = 10001010b
-10011011b & 10101111b = 10001011b
-10011011b & 10110000b = 10010000b
-10011011b & 10110001b = 10010001b
-10011011b & 10110010b = 10010010b
-10011011b & 10110011b = 10010011b
-10011011b & 10110100b = 10010000b
-10011011b & 10110101b = 10010001b
-10011011b & 10110110b = 10010010b
-10011011b & 10110111b = 10010011b
-10011011b & 10111000b = 10011000b
-10011011b & 10111001b = 10011001b
-10011011b & 10111010b = 10011010b
-10011011b & 10111011b = 10011011b
-10011011b & 10111100b = 10011000b
-10011011b & 10111101b = 10011001b
-10011011b & 10111110b = 10011010b
-10011011b & 10111111b = 10011011b
-10011011b & 11000000b = 10000000b
-10011011b & 11000001b = 10000001b
-10011011b & 11000010b = 10000010b
-10011011b & 11000011b = 10000011b
-10011011b & 11000100b = 10000000b
-10011011b & 11000101b = 10000001b
-10011011b & 11000110b = 10000010b
-10011011b & 11000111b = 10000011b
-10011011b & 11001000b = 10001000b
-10011011b & 11001001b = 10001001b
-10011011b & 11001010b = 10001010b
-10011011b & 11001011b = 10001011b
-10011011b & 11001100b = 10001000b
-10011011b & 11001101b = 10001001b
-10011011b & 11001110b = 10001010b
-10011011b & 11001111b = 10001011b
-10011011b & 11010000b = 10010000b
-10011011b & 11010001b = 10010001b
-10011011b & 11010010b = 10010010b
-10011011b & 11010011b = 10010011b
-10011011b & 11010100b = 10010000b
-10011011b & 11010101b = 10010001b
-10011011b & 11010110b = 10010010b
-10011011b & 11010111b = 10010011b
-10011011b & 11011000b = 10011000b
-10011011b & 11011001b = 10011001b
-10011011b & 11011010b = 10011010b
-10011011b & 11011011b = 10011011b
-10011011b & 11011100b = 10011000b
-10011011b & 11011101b = 10011001b
-10011011b & 11011110b = 10011010b
-10011011b & 11011111b = 10011011b
-10011011b & 11100000b = 10000000b
-10011011b & 11100001b = 10000001b
-10011011b & 11100010b = 10000010b
-10011011b & 11100011b = 10000011b
-10011011b & 11100100b = 10000000b
-10011011b & 11100101b = 10000001b
-10011011b & 11100110b = 10000010b
-10011011b & 11100111b = 10000011b
-10011011b & 11101000b = 10001000b
-10011011b & 11101001b = 10001001b
-10011011b & 11101010b = 10001010b
-10011011b & 11101011b = 10001011b
-10011011b & 11101100b = 10001000b
-10011011b & 11101101b = 10001001b
-10011011b & 11101110b = 10001010b
-10011011b & 11101111b = 10001011b
-10011011b & 11110000b = 10010000b
-10011011b & 11110001b = 10010001b
-10011011b & 11110010b = 10010010b
-10011011b & 11110011b = 10010011b
-10011011b & 11110100b = 10010000b
-10011011b & 11110101b = 10010001b
-10011011b & 11110110b = 10010010b
-10011011b & 11110111b = 10010011b
-10011011b & 11111000b = 10011000b
-10011011b & 11111001b = 10011001b
-10011011b & 11111010b = 10011010b
-10011011b & 11111011b = 10011011b
-10011011b & 11111100b = 10011000b
-10011011b & 11111101b = 10011001b
-10011011b & 11111110b = 10011010b
-10011011b & 11111111b = 10011011b
-10011011b & 00000000b = 00000000b
-10011011b & 00000001b = 00000001b
-10011011b & 00000010b = 00000010b
-10011011b & 00000011b = 00000011b
-10011011b & 00000100b = 00000000b
-10011011b & 00000101b = 00000001b
-10011011b & 00000110b = 00000010b
-10011011b & 00000111b = 00000011b
-10011011b & 00001000b = 00001000b
-10011011b & 00001001b = 00001001b
-10011011b & 00001010b = 00001010b
-10011011b & 00001011b = 00001011b
-10011011b & 00001100b = 00001000b
-10011011b & 00001101b = 00001001b
-10011011b & 00001110b = 00001010b
-10011011b & 00001111b = 00001011b
-10011011b & 00010000b = 00010000b
-10011011b & 00010001b = 00010001b
-10011011b & 00010010b = 00010010b
-10011011b & 00010011b = 00010011b
-10011011b & 00010100b = 00010000b
-10011011b & 00010101b = 00010001b
-10011011b & 00010110b = 00010010b
-10011011b & 00010111b = 00010011b
-10011011b & 00011000b = 00011000b
-10011011b & 00011001b = 00011001b
-10011011b & 00011010b = 00011010b
-10011011b & 00011011b = 00011011b
-10011011b & 00011100b = 00011000b
-10011011b & 00011101b = 00011001b
-10011011b & 00011110b = 00011010b
-10011011b & 00011111b = 00011011b
-10011011b & 00100000b = 00000000b
-10011011b & 00100001b = 00000001b
-10011011b & 00100010b = 00000010b
-10011011b & 00100011b = 00000011b
-10011011b & 00100100b = 00000000b
-10011011b & 00100101b = 00000001b
-10011011b & 00100110b = 00000010b
-10011011b & 00100111b = 00000011b
-10011011b & 00101000b = 00001000b
-10011011b & 00101001b = 00001001b
-10011011b & 00101010b = 00001010b
-10011011b & 00101011b = 00001011b
-10011011b & 00101100b = 00001000b
-10011011b & 00101101b = 00001001b
-10011011b & 00101110b = 00001010b
-10011011b & 00101111b = 00001011b
-10011011b & 00110000b = 00010000b
-10011011b & 00110001b = 00010001b
-10011011b & 00110010b = 00010010b
-10011011b & 00110011b = 00010011b
-10011011b & 00110100b = 00010000b
-10011011b & 00110101b = 00010001b
-10011011b & 00110110b = 00010010b
-10011011b & 00110111b = 00010011b
-10011011b & 00111000b = 00011000b
-10011011b & 00111001b = 00011001b
-10011011b & 00111010b = 00011010b
-10011011b & 00111011b = 00011011b
-10011011b & 00111100b = 00011000b
-10011011b & 00111101b = 00011001b
-10011011b & 00111110b = 00011010b
-10011011b & 00111111b = 00011011b
-10011011b & 01000000b = 00000000b
-10011011b & 01000001b = 00000001b
-10011011b & 01000010b = 00000010b
-10011011b & 01000011b = 00000011b
-10011011b & 01000100b = 00000000b
-10011011b & 01000101b = 00000001b
-10011011b & 01000110b = 00000010b
-10011011b & 01000111b = 00000011b
-10011011b & 01001000b = 00001000b
-10011011b & 01001001b = 00001001b
-10011011b & 01001010b = 00001010b
-10011011b & 01001011b = 00001011b
-10011011b & 01001100b = 00001000b
-10011011b & 01001101b = 00001001b
-10011011b & 01001110b = 00001010b
-10011011b & 01001111b = 00001011b
-10011011b & 01010000b = 00010000b
-10011011b & 01010001b = 00010001b
-10011011b & 01010010b = 00010010b
-10011011b & 01010011b = 00010011b
-10011011b & 01010100b = 00010000b
-10011011b & 01010101b = 00010001b
-10011011b & 01010110b = 00010010b
-10011011b & 01010111b = 00010011b
-10011011b & 01011000b = 00011000b
-10011011b & 01011001b = 00011001b
-10011011b & 01011010b = 00011010b
-10011011b & 01011011b = 00011011b
-10011011b & 01011100b = 00011000b
-10011011b & 01011101b = 00011001b
-10011011b & 01011110b = 00011010b
-10011011b & 01011111b = 00011011b
-10011011b & 01100000b = 00000000b
-10011011b & 01100001b = 00000001b
-10011011b & 01100010b = 00000010b
-10011011b & 01100011b = 00000011b
-10011011b & 01100100b = 00000000b
-10011011b & 01100101b = 00000001b
-10011011b & 01100110b = 00000010b
-10011011b & 01100111b = 00000011b
-10011011b & 01101000b = 00001000b
-10011011b & 01101001b = 00001001b
-10011011b & 01101010b = 00001010b
-10011011b & 01101011b = 00001011b
-10011011b & 01101100b = 00001000b
-10011011b & 01101101b = 00001001b
-10011011b & 01101110b = 00001010b
-10011011b & 01101111b = 00001011b
-10011011b & 01110000b = 00010000b
-10011011b & 01110001b = 00010001b
-10011011b & 01110010b = 00010010b
-10011011b & 01110011b = 00010011b
-10011011b & 01110100b = 00010000b
-10011011b & 01110101b = 00010001b
-10011011b & 01110110b = 00010010b
-10011011b & 01110111b = 00010011b
-10011011b & 01111000b = 00011000b
-10011011b & 01111001b = 00011001b
-10011011b & 01111010b = 00011010b
-10011011b & 01111011b = 00011011b
-10011011b & 01111100b = 00011000b
-10011011b & 01111101b = 00011001b
-10011011b & 01111110b = 00011010b
-10011100b & 10000000b = 10000000b
-10011100b & 10000001b = 10000000b
-10011100b & 10000010b = 10000000b
-10011100b & 10000011b = 10000000b
-10011100b & 10000100b = 10000100b
-10011100b & 10000101b = 10000100b
-10011100b & 10000110b = 10000100b
-10011100b & 10000111b = 10000100b
-10011100b & 10001000b = 10001000b
-10011100b & 10001001b = 10001000b
-10011100b & 10001010b = 10001000b
-10011100b & 10001011b = 10001000b
-10011100b & 10001100b = 10001100b
-10011100b & 10001101b = 10001100b
-10011100b & 10001110b = 10001100b
-10011100b & 10001111b = 10001100b
-10011100b & 10010000b = 10010000b
-10011100b & 10010001b = 10010000b
-10011100b & 10010010b = 10010000b
-10011100b & 10010011b = 10010000b
-10011100b & 10010100b = 10010100b
-10011100b & 10010101b = 10010100b
-10011100b & 10010110b = 10010100b
-10011100b & 10010111b = 10010100b
-10011100b & 10011000b = 10011000b
-10011100b & 10011001b = 10011000b
-10011100b & 10011010b = 10011000b
-10011100b & 10011011b = 10011000b
-10011100b & 10011100b = 10011100b
-10011100b & 10011101b = 10011100b
-10011100b & 10011110b = 10011100b
-10011100b & 10011111b = 10011100b
-10011100b & 10100000b = 10000000b
-10011100b & 10100001b = 10000000b
-10011100b & 10100010b = 10000000b
-10011100b & 10100011b = 10000000b
-10011100b & 10100100b = 10000100b
-10011100b & 10100101b = 10000100b
-10011100b & 10100110b = 10000100b
-10011100b & 10100111b = 10000100b
-10011100b & 10101000b = 10001000b
-10011100b & 10101001b = 10001000b
-10011100b & 10101010b = 10001000b
-10011100b & 10101011b = 10001000b
-10011100b & 10101100b = 10001100b
-10011100b & 10101101b = 10001100b
-10011100b & 10101110b = 10001100b
-10011100b & 10101111b = 10001100b
-10011100b & 10110000b = 10010000b
-10011100b & 10110001b = 10010000b
-10011100b & 10110010b = 10010000b
-10011100b & 10110011b = 10010000b
-10011100b & 10110100b = 10010100b
-10011100b & 10110101b = 10010100b
-10011100b & 10110110b = 10010100b
-10011100b & 10110111b = 10010100b
-10011100b & 10111000b = 10011000b
-10011100b & 10111001b = 10011000b
-10011100b & 10111010b = 10011000b
-10011100b & 10111011b = 10011000b
-10011100b & 10111100b = 10011100b
-10011100b & 10111101b = 10011100b
-10011100b & 10111110b = 10011100b
-10011100b & 10111111b = 10011100b
-10011100b & 11000000b = 10000000b
-10011100b & 11000001b = 10000000b
-10011100b & 11000010b = 10000000b
-10011100b & 11000011b = 10000000b
-10011100b & 11000100b = 10000100b
-10011100b & 11000101b = 10000100b
-10011100b & 11000110b = 10000100b
-10011100b & 11000111b = 10000100b
-10011100b & 11001000b = 10001000b
-10011100b & 11001001b = 10001000b
-10011100b & 11001010b = 10001000b
-10011100b & 11001011b = 10001000b
-10011100b & 11001100b = 10001100b
-10011100b & 11001101b = 10001100b
-10011100b & 11001110b = 10001100b
-10011100b & 11001111b = 10001100b
-10011100b & 11010000b = 10010000b
-10011100b & 11010001b = 10010000b
-10011100b & 11010010b = 10010000b
-10011100b & 11010011b = 10010000b
-10011100b & 11010100b = 10010100b
-10011100b & 11010101b = 10010100b
-10011100b & 11010110b = 10010100b
-10011100b & 11010111b = 10010100b
-10011100b & 11011000b = 10011000b
-10011100b & 11011001b = 10011000b
-10011100b & 11011010b = 10011000b
-10011100b & 11011011b = 10011000b
-10011100b & 11011100b = 10011100b
-10011100b & 11011101b = 10011100b
-10011100b & 11011110b = 10011100b
-10011100b & 11011111b = 10011100b
-10011100b & 11100000b = 10000000b
-10011100b & 11100001b = 10000000b
-10011100b & 11100010b = 10000000b
-10011100b & 11100011b = 10000000b
-10011100b & 11100100b = 10000100b
-10011100b & 11100101b = 10000100b
-10011100b & 11100110b = 10000100b
-10011100b & 11100111b = 10000100b
-10011100b & 11101000b = 10001000b
-10011100b & 11101001b = 10001000b
-10011100b & 11101010b = 10001000b
-10011100b & 11101011b = 10001000b
-10011100b & 11101100b = 10001100b
-10011100b & 11101101b = 10001100b
-10011100b & 11101110b = 10001100b
-10011100b & 11101111b = 10001100b
-10011100b & 11110000b = 10010000b
-10011100b & 11110001b = 10010000b
-10011100b & 11110010b = 10010000b
-10011100b & 11110011b = 10010000b
-10011100b & 11110100b = 10010100b
-10011100b & 11110101b = 10010100b
-10011100b & 11110110b = 10010100b
-10011100b & 11110111b = 10010100b
-10011100b & 11111000b = 10011000b
-10011100b & 11111001b = 10011000b
-10011100b & 11111010b = 10011000b
-10011100b & 11111011b = 10011000b
-10011100b & 11111100b = 10011100b
-10011100b & 11111101b = 10011100b
-10011100b & 11111110b = 10011100b
-10011100b & 11111111b = 10011100b
-10011100b & 00000000b = 00000000b
-10011100b & 00000001b = 00000000b
-10011100b & 00000010b = 00000000b
-10011100b & 00000011b = 00000000b
-10011100b & 00000100b = 00000100b
-10011100b & 00000101b = 00000100b
-10011100b & 00000110b = 00000100b
-10011100b & 00000111b = 00000100b
-10011100b & 00001000b = 00001000b
-10011100b & 00001001b = 00001000b
-10011100b & 00001010b = 00001000b
-10011100b & 00001011b = 00001000b
-10011100b & 00001100b = 00001100b
-10011100b & 00001101b = 00001100b
-10011100b & 00001110b = 00001100b
-10011100b & 00001111b = 00001100b
-10011100b & 00010000b = 00010000b
-10011100b & 00010001b = 00010000b
-10011100b & 00010010b = 00010000b
-10011100b & 00010011b = 00010000b
-10011100b & 00010100b = 00010100b
-10011100b & 00010101b = 00010100b
-10011100b & 00010110b = 00010100b
-10011100b & 00010111b = 00010100b
-10011100b & 00011000b = 00011000b
-10011100b & 00011001b = 00011000b
-10011100b & 00011010b = 00011000b
-10011100b & 00011011b = 00011000b
-10011100b & 00011100b = 00011100b
-10011100b & 00011101b = 00011100b
-10011100b & 00011110b = 00011100b
-10011100b & 00011111b = 00011100b
-10011100b & 00100000b = 00000000b
-10011100b & 00100001b = 00000000b
-10011100b & 00100010b = 00000000b
-10011100b & 00100011b = 00000000b
-10011100b & 00100100b = 00000100b
-10011100b & 00100101b = 00000100b
-10011100b & 00100110b = 00000100b
-10011100b & 00100111b = 00000100b
-10011100b & 00101000b = 00001000b
-10011100b & 00101001b = 00001000b
-10011100b & 00101010b = 00001000b
-10011100b & 00101011b = 00001000b
-10011100b & 00101100b = 00001100b
-10011100b & 00101101b = 00001100b
-10011100b & 00101110b = 00001100b
-10011100b & 00101111b = 00001100b
-10011100b & 00110000b = 00010000b
-10011100b & 00110001b = 00010000b
-10011100b & 00110010b = 00010000b
-10011100b & 00110011b = 00010000b
-10011100b & 00110100b = 00010100b
-10011100b & 00110101b = 00010100b
-10011100b & 00110110b = 00010100b
-10011100b & 00110111b = 00010100b
-10011100b & 00111000b = 00011000b
-10011100b & 00111001b = 00011000b
-10011100b & 00111010b = 00011000b
-10011100b & 00111011b = 00011000b
-10011100b & 00111100b = 00011100b
-10011100b & 00111101b = 00011100b
-10011100b & 00111110b = 00011100b
-10011100b & 00111111b = 00011100b
-10011100b & 01000000b = 00000000b
-10011100b & 01000001b = 00000000b
-10011100b & 01000010b = 00000000b
-10011100b & 01000011b = 00000000b
-10011100b & 01000100b = 00000100b
-10011100b & 01000101b = 00000100b
-10011100b & 01000110b = 00000100b
-10011100b & 01000111b = 00000100b
-10011100b & 01001000b = 00001000b
-10011100b & 01001001b = 00001000b
-10011100b & 01001010b = 00001000b
-10011100b & 01001011b = 00001000b
-10011100b & 01001100b = 00001100b
-10011100b & 01001101b = 00001100b
-10011100b & 01001110b = 00001100b
-10011100b & 01001111b = 00001100b
-10011100b & 01010000b = 00010000b
-10011100b & 01010001b = 00010000b
-10011100b & 01010010b = 00010000b
-10011100b & 01010011b = 00010000b
-10011100b & 01010100b = 00010100b
-10011100b & 01010101b = 00010100b
-10011100b & 01010110b = 00010100b
-10011100b & 01010111b = 00010100b
-10011100b & 01011000b = 00011000b
-10011100b & 01011001b = 00011000b
-10011100b & 01011010b = 00011000b
-10011100b & 01011011b = 00011000b
-10011100b & 01011100b = 00011100b
-10011100b & 01011101b = 00011100b
-10011100b & 01011110b = 00011100b
-10011100b & 01011111b = 00011100b
-10011100b & 01100000b = 00000000b
-10011100b & 01100001b = 00000000b
-10011100b & 01100010b = 00000000b
-10011100b & 01100011b = 00000000b
-10011100b & 01100100b = 00000100b
-10011100b & 01100101b = 00000100b
-10011100b & 01100110b = 00000100b
-10011100b & 01100111b = 00000100b
-10011100b & 01101000b = 00001000b
-10011100b & 01101001b = 00001000b
-10011100b & 01101010b = 00001000b
-10011100b & 01101011b = 00001000b
-10011100b & 01101100b = 00001100b
-10011100b & 01101101b = 00001100b
-10011100b & 01101110b = 00001100b
-10011100b & 01101111b = 00001100b
-10011100b & 01110000b = 00010000b
-10011100b & 01110001b = 00010000b
-10011100b & 01110010b = 00010000b
-10011100b & 01110011b = 00010000b
-10011100b & 01110100b = 00010100b
-10011100b & 01110101b = 00010100b
-10011100b & 01110110b = 00010100b
-10011100b & 01110111b = 00010100b
-10011100b & 01111000b = 00011000b
-10011100b & 01111001b = 00011000b
-10011100b & 01111010b = 00011000b
-10011100b & 01111011b = 00011000b
-10011100b & 01111100b = 00011100b
-10011100b & 01111101b = 00011100b
-10011100b & 01111110b = 00011100b
-10011101b & 10000000b = 10000000b
-10011101b & 10000001b = 10000001b
-10011101b & 10000010b = 10000000b
-10011101b & 10000011b = 10000001b
-10011101b & 10000100b = 10000100b
-10011101b & 10000101b = 10000101b
-10011101b & 10000110b = 10000100b
-10011101b & 10000111b = 10000101b
-10011101b & 10001000b = 10001000b
-10011101b & 10001001b = 10001001b
-10011101b & 10001010b = 10001000b
-10011101b & 10001011b = 10001001b
-10011101b & 10001100b = 10001100b
-10011101b & 10001101b = 10001101b
-10011101b & 10001110b = 10001100b
-10011101b & 10001111b = 10001101b
-10011101b & 10010000b = 10010000b
-10011101b & 10010001b = 10010001b
-10011101b & 10010010b = 10010000b
-10011101b & 10010011b = 10010001b
-10011101b & 10010100b = 10010100b
-10011101b & 10010101b = 10010101b
-10011101b & 10010110b = 10010100b
-10011101b & 10010111b = 10010101b
-10011101b & 10011000b = 10011000b
-10011101b & 10011001b = 10011001b
-10011101b & 10011010b = 10011000b
-10011101b & 10011011b = 10011001b
-10011101b & 10011100b = 10011100b
-10011101b & 10011101b = 10011101b
-10011101b & 10011110b = 10011100b
-10011101b & 10011111b = 10011101b
-10011101b & 10100000b = 10000000b
-10011101b & 10100001b = 10000001b
-10011101b & 10100010b = 10000000b
-10011101b & 10100011b = 10000001b
-10011101b & 10100100b = 10000100b
-10011101b & 10100101b = 10000101b
-10011101b & 10100110b = 10000100b
-10011101b & 10100111b = 10000101b
-10011101b & 10101000b = 10001000b
-10011101b & 10101001b = 10001001b
-10011101b & 10101010b = 10001000b
-10011101b & 10101011b = 10001001b
-10011101b & 10101100b = 10001100b
-10011101b & 10101101b = 10001101b
-10011101b & 10101110b = 10001100b
-10011101b & 10101111b = 10001101b
-10011101b & 10110000b = 10010000b
-10011101b & 10110001b = 10010001b
-10011101b & 10110010b = 10010000b
-10011101b & 10110011b = 10010001b
-10011101b & 10110100b = 10010100b
-10011101b & 10110101b = 10010101b
-10011101b & 10110110b = 10010100b
-10011101b & 10110111b = 10010101b
-10011101b & 10111000b = 10011000b
-10011101b & 10111001b = 10011001b
-10011101b & 10111010b = 10011000b
-10011101b & 10111011b = 10011001b
-10011101b & 10111100b = 10011100b
-10011101b & 10111101b = 10011101b
-10011101b & 10111110b = 10011100b
-10011101b & 10111111b = 10011101b
-10011101b & 11000000b = 10000000b
-10011101b & 11000001b = 10000001b
-10011101b & 11000010b = 10000000b
-10011101b & 11000011b = 10000001b
-10011101b & 11000100b = 10000100b
-10011101b & 11000101b = 10000101b
-10011101b & 11000110b = 10000100b
-10011101b & 11000111b = 10000101b
-10011101b & 11001000b = 10001000b
-10011101b & 11001001b = 10001001b
-10011101b & 11001010b = 10001000b
-10011101b & 11001011b = 10001001b
-10011101b & 11001100b = 10001100b
-10011101b & 11001101b = 10001101b
-10011101b & 11001110b = 10001100b
-10011101b & 11001111b = 10001101b
-10011101b & 11010000b = 10010000b
-10011101b & 11010001b = 10010001b
-10011101b & 11010010b = 10010000b
-10011101b & 11010011b = 10010001b
-10011101b & 11010100b = 10010100b
-10011101b & 11010101b = 10010101b
-10011101b & 11010110b = 10010100b
-10011101b & 11010111b = 10010101b
-10011101b & 11011000b = 10011000b
-10011101b & 11011001b = 10011001b
-10011101b & 11011010b = 10011000b
-10011101b & 11011011b = 10011001b
-10011101b & 11011100b = 10011100b
-10011101b & 11011101b = 10011101b
-10011101b & 11011110b = 10011100b
-10011101b & 11011111b = 10011101b
-10011101b & 11100000b = 10000000b
-10011101b & 11100001b = 10000001b
-10011101b & 11100010b = 10000000b
-10011101b & 11100011b = 10000001b
-10011101b & 11100100b = 10000100b
-10011101b & 11100101b = 10000101b
-10011101b & 11100110b = 10000100b
-10011101b & 11100111b = 10000101b
-10011101b & 11101000b = 10001000b
-10011101b & 11101001b = 10001001b
-10011101b & 11101010b = 10001000b
-10011101b & 11101011b = 10001001b
-10011101b & 11101100b = 10001100b
-10011101b & 11101101b = 10001101b
-10011101b & 11101110b = 10001100b
-10011101b & 11101111b = 10001101b
-10011101b & 11110000b = 10010000b
-10011101b & 11110001b = 10010001b
-10011101b & 11110010b = 10010000b
-10011101b & 11110011b = 10010001b
-10011101b & 11110100b = 10010100b
-10011101b & 11110101b = 10010101b
-10011101b & 11110110b = 10010100b
-10011101b & 11110111b = 10010101b
-10011101b & 11111000b = 10011000b
-10011101b & 11111001b = 10011001b
-10011101b & 11111010b = 10011000b
-10011101b & 11111011b = 10011001b
-10011101b & 11111100b = 10011100b
-10011101b & 11111101b = 10011101b
-10011101b & 11111110b = 10011100b
-10011101b & 11111111b = 10011101b
-10011101b & 00000000b = 00000000b
-10011101b & 00000001b = 00000001b
-10011101b & 00000010b = 00000000b
-10011101b & 00000011b = 00000001b
-10011101b & 00000100b = 00000100b
-10011101b & 00000101b = 00000101b
-10011101b & 00000110b = 00000100b
-10011101b & 00000111b = 00000101b
-10011101b & 00001000b = 00001000b
-10011101b & 00001001b = 00001001b
-10011101b & 00001010b = 00001000b
-10011101b & 00001011b = 00001001b
-10011101b & 00001100b = 00001100b
-10011101b & 00001101b = 00001101b
-10011101b & 00001110b = 00001100b
-10011101b & 00001111b = 00001101b
-10011101b & 00010000b = 00010000b
-10011101b & 00010001b = 00010001b
-10011101b & 00010010b = 00010000b
-10011101b & 00010011b = 00010001b
-10011101b & 00010100b = 00010100b
-10011101b & 00010101b = 00010101b
-10011101b & 00010110b = 00010100b
-10011101b & 00010111b = 00010101b
-10011101b & 00011000b = 00011000b
-10011101b & 00011001b = 00011001b
-10011101b & 00011010b = 00011000b
-10011101b & 00011011b = 00011001b
-10011101b & 00011100b = 00011100b
-10011101b & 00011101b = 00011101b
-10011101b & 00011110b = 00011100b
-10011101b & 00011111b = 00011101b
-10011101b & 00100000b = 00000000b
-10011101b & 00100001b = 00000001b
-10011101b & 00100010b = 00000000b
-10011101b & 00100011b = 00000001b
-10011101b & 00100100b = 00000100b
-10011101b & 00100101b = 00000101b
-10011101b & 00100110b = 00000100b
-10011101b & 00100111b = 00000101b
-10011101b & 00101000b = 00001000b
-10011101b & 00101001b = 00001001b
-10011101b & 00101010b = 00001000b
-10011101b & 00101011b = 00001001b
-10011101b & 00101100b = 00001100b
-10011101b & 00101101b = 00001101b
-10011101b & 00101110b = 00001100b
-10011101b & 00101111b = 00001101b
-10011101b & 00110000b = 00010000b
-10011101b & 00110001b = 00010001b
-10011101b & 00110010b = 00010000b
-10011101b & 00110011b = 00010001b
-10011101b & 00110100b = 00010100b
-10011101b & 00110101b = 00010101b
-10011101b & 00110110b = 00010100b
-10011101b & 00110111b = 00010101b
-10011101b & 00111000b = 00011000b
-10011101b & 00111001b = 00011001b
-10011101b & 00111010b = 00011000b
-10011101b & 00111011b = 00011001b
-10011101b & 00111100b = 00011100b
-10011101b & 00111101b = 00011101b
-10011101b & 00111110b = 00011100b
-10011101b & 00111111b = 00011101b
-10011101b & 01000000b = 00000000b
-10011101b & 01000001b = 00000001b
-10011101b & 01000010b = 00000000b
-10011101b & 01000011b = 00000001b
-10011101b & 01000100b = 00000100b
-10011101b & 01000101b = 00000101b
-10011101b & 01000110b = 00000100b
-10011101b & 01000111b = 00000101b
-10011101b & 01001000b = 00001000b
-10011101b & 01001001b = 00001001b
-10011101b & 01001010b = 00001000b
-10011101b & 01001011b = 00001001b
-10011101b & 01001100b = 00001100b
-10011101b & 01001101b = 00001101b
-10011101b & 01001110b = 00001100b
-10011101b & 01001111b = 00001101b
-10011101b & 01010000b = 00010000b
-10011101b & 01010001b = 00010001b
-10011101b & 01010010b = 00010000b
-10011101b & 01010011b = 00010001b
-10011101b & 01010100b = 00010100b
-10011101b & 01010101b = 00010101b
-10011101b & 01010110b = 00010100b
-10011101b & 01010111b = 00010101b
-10011101b & 01011000b = 00011000b
-10011101b & 01011001b = 00011001b
-10011101b & 01011010b = 00011000b
-10011101b & 01011011b = 00011001b
-10011101b & 01011100b = 00011100b
-10011101b & 01011101b = 00011101b
-10011101b & 01011110b = 00011100b
-10011101b & 01011111b = 00011101b
-10011101b & 01100000b = 00000000b
-10011101b & 01100001b = 00000001b
-10011101b & 01100010b = 00000000b
-10011101b & 01100011b = 00000001b
-10011101b & 01100100b = 00000100b
-10011101b & 01100101b = 00000101b
-10011101b & 01100110b = 00000100b
-10011101b & 01100111b = 00000101b
-10011101b & 01101000b = 00001000b
-10011101b & 01101001b = 00001001b
-10011101b & 01101010b = 00001000b
-10011101b & 01101011b = 00001001b
-10011101b & 01101100b = 00001100b
-10011101b & 01101101b = 00001101b
-10011101b & 01101110b = 00001100b
-10011101b & 01101111b = 00001101b
-10011101b & 01110000b = 00010000b
-10011101b & 01110001b = 00010001b
-10011101b & 01110010b = 00010000b
-10011101b & 01110011b = 00010001b
-10011101b & 01110100b = 00010100b
-10011101b & 01110101b = 00010101b
-10011101b & 01110110b = 00010100b
-10011101b & 01110111b = 00010101b
-10011101b & 01111000b = 00011000b
-10011101b & 01111001b = 00011001b
-10011101b & 01111010b = 00011000b
-10011101b & 01111011b = 00011001b
-10011101b & 01111100b = 00011100b
-10011101b & 01111101b = 00011101b
-10011101b & 01111110b = 00011100b
-10011110b & 10000000b = 10000000b
-10011110b & 10000001b = 10000000b
-10011110b & 10000010b = 10000010b
-10011110b & 10000011b = 10000010b
-10011110b & 10000100b = 10000100b
-10011110b & 10000101b = 10000100b
-10011110b & 10000110b = 10000110b
-10011110b & 10000111b = 10000110b
-10011110b & 10001000b = 10001000b
-10011110b & 10001001b = 10001000b
-10011110b & 10001010b = 10001010b
-10011110b & 10001011b = 10001010b
-10011110b & 10001100b = 10001100b
-10011110b & 10001101b = 10001100b
-10011110b & 10001110b = 10001110b
-10011110b & 10001111b = 10001110b
-10011110b & 10010000b = 10010000b
-10011110b & 10010001b = 10010000b
-10011110b & 10010010b = 10010010b
-10011110b & 10010011b = 10010010b
-10011110b & 10010100b = 10010100b
-10011110b & 10010101b = 10010100b
-10011110b & 10010110b = 10010110b
-10011110b & 10010111b = 10010110b
-10011110b & 10011000b = 10011000b
-10011110b & 10011001b = 10011000b
-10011110b & 10011010b = 10011010b
-10011110b & 10011011b = 10011010b
-10011110b & 10011100b = 10011100b
-10011110b & 10011101b = 10011100b
-10011110b & 10011110b = 10011110b
-10011110b & 10011111b = 10011110b
-10011110b & 10100000b = 10000000b
-10011110b & 10100001b = 10000000b
-10011110b & 10100010b = 10000010b
-10011110b & 10100011b = 10000010b
-10011110b & 10100100b = 10000100b
-10011110b & 10100101b = 10000100b
-10011110b & 10100110b = 10000110b
-10011110b & 10100111b = 10000110b
-10011110b & 10101000b = 10001000b
-10011110b & 10101001b = 10001000b
-10011110b & 10101010b = 10001010b
-10011110b & 10101011b = 10001010b
-10011110b & 10101100b = 10001100b
-10011110b & 10101101b = 10001100b
-10011110b & 10101110b = 10001110b
-10011110b & 10101111b = 10001110b
-10011110b & 10110000b = 10010000b
-10011110b & 10110001b = 10010000b
-10011110b & 10110010b = 10010010b
-10011110b & 10110011b = 10010010b
-10011110b & 10110100b = 10010100b
-10011110b & 10110101b = 10010100b
-10011110b & 10110110b = 10010110b
-10011110b & 10110111b = 10010110b
-10011110b & 10111000b = 10011000b
-10011110b & 10111001b = 10011000b
-10011110b & 10111010b = 10011010b
-10011110b & 10111011b = 10011010b
-10011110b & 10111100b = 10011100b
-10011110b & 10111101b = 10011100b
-10011110b & 10111110b = 10011110b
-10011110b & 10111111b = 10011110b
-10011110b & 11000000b = 10000000b
-10011110b & 11000001b = 10000000b
-10011110b & 11000010b = 10000010b
-10011110b & 11000011b = 10000010b
-10011110b & 11000100b = 10000100b
-10011110b & 11000101b = 10000100b
-10011110b & 11000110b = 10000110b
-10011110b & 11000111b = 10000110b
-10011110b & 11001000b = 10001000b
-10011110b & 11001001b = 10001000b
-10011110b & 11001010b = 10001010b
-10011110b & 11001011b = 10001010b
-10011110b & 11001100b = 10001100b
-10011110b & 11001101b = 10001100b
-10011110b & 11001110b = 10001110b
-10011110b & 11001111b = 10001110b
-10011110b & 11010000b = 10010000b
-10011110b & 11010001b = 10010000b
-10011110b & 11010010b = 10010010b
-10011110b & 11010011b = 10010010b
-10011110b & 11010100b = 10010100b
-10011110b & 11010101b = 10010100b
-10011110b & 11010110b = 10010110b
-10011110b & 11010111b = 10010110b
-10011110b & 11011000b = 10011000b
-10011110b & 11011001b = 10011000b
-10011110b & 11011010b = 10011010b
-10011110b & 11011011b = 10011010b
-10011110b & 11011100b = 10011100b
-10011110b & 11011101b = 10011100b
-10011110b & 11011110b = 10011110b
-10011110b & 11011111b = 10011110b
-10011110b & 11100000b = 10000000b
-10011110b & 11100001b = 10000000b
-10011110b & 11100010b = 10000010b
-10011110b & 11100011b = 10000010b
-10011110b & 11100100b = 10000100b
-10011110b & 11100101b = 10000100b
-10011110b & 11100110b = 10000110b
-10011110b & 11100111b = 10000110b
-10011110b & 11101000b = 10001000b
-10011110b & 11101001b = 10001000b
-10011110b & 11101010b = 10001010b
-10011110b & 11101011b = 10001010b
-10011110b & 11101100b = 10001100b
-10011110b & 11101101b = 10001100b
-10011110b & 11101110b = 10001110b
-10011110b & 11101111b = 10001110b
-10011110b & 11110000b = 10010000b
-10011110b & 11110001b = 10010000b
-10011110b & 11110010b = 10010010b
-10011110b & 11110011b = 10010010b
-10011110b & 11110100b = 10010100b
-10011110b & 11110101b = 10010100b
-10011110b & 11110110b = 10010110b
-10011110b & 11110111b = 10010110b
-10011110b & 11111000b = 10011000b
-10011110b & 11111001b = 10011000b
-10011110b & 11111010b = 10011010b
-10011110b & 11111011b = 10011010b
-10011110b & 11111100b = 10011100b
-10011110b & 11111101b = 10011100b
-10011110b & 11111110b = 10011110b
-10011110b & 11111111b = 10011110b
-10011110b & 00000000b = 00000000b
-10011110b & 00000001b = 00000000b
-10011110b & 00000010b = 00000010b
-10011110b & 00000011b = 00000010b
-10011110b & 00000100b = 00000100b
-10011110b & 00000101b = 00000100b
-10011110b & 00000110b = 00000110b
-10011110b & 00000111b = 00000110b
-10011110b & 00001000b = 00001000b
-10011110b & 00001001b = 00001000b
-10011110b & 00001010b = 00001010b
-10011110b & 00001011b = 00001010b
-10011110b & 00001100b = 00001100b
-10011110b & 00001101b = 00001100b
-10011110b & 00001110b = 00001110b
-10011110b & 00001111b = 00001110b
-10011110b & 00010000b = 00010000b
-10011110b & 00010001b = 00010000b
-10011110b & 00010010b = 00010010b
-10011110b & 00010011b = 00010010b
-10011110b & 00010100b = 00010100b
-10011110b & 00010101b = 00010100b
-10011110b & 00010110b = 00010110b
-10011110b & 00010111b = 00010110b
-10011110b & 00011000b = 00011000b
-10011110b & 00011001b = 00011000b
-10011110b & 00011010b = 00011010b
-10011110b & 00011011b = 00011010b
-10011110b & 00011100b = 00011100b
-10011110b & 00011101b = 00011100b
-10011110b & 00011110b = 00011110b
-10011110b & 00011111b = 00011110b
-10011110b & 00100000b = 00000000b
-10011110b & 00100001b = 00000000b
-10011110b & 00100010b = 00000010b
-10011110b & 00100011b = 00000010b
-10011110b & 00100100b = 00000100b
-10011110b & 00100101b = 00000100b
-10011110b & 00100110b = 00000110b
-10011110b & 00100111b = 00000110b
-10011110b & 00101000b = 00001000b
-10011110b & 00101001b = 00001000b
-10011110b & 00101010b = 00001010b
-10011110b & 00101011b = 00001010b
-10011110b & 00101100b = 00001100b
-10011110b & 00101101b = 00001100b
-10011110b & 00101110b = 00001110b
-10011110b & 00101111b = 00001110b
-10011110b & 00110000b = 00010000b
-10011110b & 00110001b = 00010000b
-10011110b & 00110010b = 00010010b
-10011110b & 00110011b = 00010010b
-10011110b & 00110100b = 00010100b
-10011110b & 00110101b = 00010100b
-10011110b & 00110110b = 00010110b
-10011110b & 00110111b = 00010110b
-10011110b & 00111000b = 00011000b
-10011110b & 00111001b = 00011000b
-10011110b & 00111010b = 00011010b
-10011110b & 00111011b = 00011010b
-10011110b & 00111100b = 00011100b
-10011110b & 00111101b = 00011100b
-10011110b & 00111110b = 00011110b
-10011110b & 00111111b = 00011110b
-10011110b & 01000000b = 00000000b
-10011110b & 01000001b = 00000000b
-10011110b & 01000010b = 00000010b
-10011110b & 01000011b = 00000010b
-10011110b & 01000100b = 00000100b
-10011110b & 01000101b = 00000100b
-10011110b & 01000110b = 00000110b
-10011110b & 01000111b = 00000110b
-10011110b & 01001000b = 00001000b
-10011110b & 01001001b = 00001000b
-10011110b & 01001010b = 00001010b
-10011110b & 01001011b = 00001010b
-10011110b & 01001100b = 00001100b
-10011110b & 01001101b = 00001100b
-10011110b & 01001110b = 00001110b
-10011110b & 01001111b = 00001110b
-10011110b & 01010000b = 00010000b
-10011110b & 01010001b = 00010000b
-10011110b & 01010010b = 00010010b
-10011110b & 01010011b = 00010010b
-10011110b & 01010100b = 00010100b
-10011110b & 01010101b = 00010100b
-10011110b & 01010110b = 00010110b
-10011110b & 01010111b = 00010110b
-10011110b & 01011000b = 00011000b
-10011110b & 01011001b = 00011000b
-10011110b & 01011010b = 00011010b
-10011110b & 01011011b = 00011010b
-10011110b & 01011100b = 00011100b
-10011110b & 01011101b = 00011100b
-10011110b & 01011110b = 00011110b
-10011110b & 01011111b = 00011110b
-10011110b & 01100000b = 00000000b
-10011110b & 01100001b = 00000000b
-10011110b & 01100010b = 00000010b
-10011110b & 01100011b = 00000010b
-10011110b & 01100100b = 00000100b
-10011110b & 01100101b = 00000100b
-10011110b & 01100110b = 00000110b
-10011110b & 01100111b = 00000110b
-10011110b & 01101000b = 00001000b
-10011110b & 01101001b = 00001000b
-10011110b & 01101010b = 00001010b
-10011110b & 01101011b = 00001010b
-10011110b & 01101100b = 00001100b
-10011110b & 01101101b = 00001100b
-10011110b & 01101110b = 00001110b
-10011110b & 01101111b = 00001110b
-10011110b & 01110000b = 00010000b
-10011110b & 01110001b = 00010000b
-10011110b & 01110010b = 00010010b
-10011110b & 01110011b = 00010010b
-10011110b & 01110100b = 00010100b
-10011110b & 01110101b = 00010100b
-10011110b & 01110110b = 00010110b
-10011110b & 01110111b = 00010110b
-10011110b & 01111000b = 00011000b
-10011110b & 01111001b = 00011000b
-10011110b & 01111010b = 00011010b
-10011110b & 01111011b = 00011010b
-10011110b & 01111100b = 00011100b
-10011110b & 01111101b = 00011100b
-10011110b & 01111110b = 00011110b
-10011111b & 10000000b = 10000000b
-10011111b & 10000001b = 10000001b
-10011111b & 10000010b = 10000010b
-10011111b & 10000011b = 10000011b
-10011111b & 10000100b = 10000100b
-10011111b & 10000101b = 10000101b
-10011111b & 10000110b = 10000110b
-10011111b & 10000111b = 10000111b
-10011111b & 10001000b = 10001000b
-10011111b & 10001001b = 10001001b
-10011111b & 10001010b = 10001010b
-10011111b & 10001011b = 10001011b
-10011111b & 10001100b = 10001100b
-10011111b & 10001101b = 10001101b
-10011111b & 10001110b = 10001110b
-10011111b & 10001111b = 10001111b
-10011111b & 10010000b = 10010000b
-10011111b & 10010001b = 10010001b
-10011111b & 10010010b = 10010010b
-10011111b & 10010011b = 10010011b
-10011111b & 10010100b = 10010100b
-10011111b & 10010101b = 10010101b
-10011111b & 10010110b = 10010110b
-10011111b & 10010111b = 10010111b
-10011111b & 10011000b = 10011000b
-10011111b & 10011001b = 10011001b
-10011111b & 10011010b = 10011010b
-10011111b & 10011011b = 10011011b
-10011111b & 10011100b = 10011100b
-10011111b & 10011101b = 10011101b
-10011111b & 10011110b = 10011110b
-10011111b & 10011111b = 10011111b
-10011111b & 10100000b = 10000000b
-10011111b & 10100001b = 10000001b
-10011111b & 10100010b = 10000010b
-10011111b & 10100011b = 10000011b
-10011111b & 10100100b = 10000100b
-10011111b & 10100101b = 10000101b
-10011111b & 10100110b = 10000110b
-10011111b & 10100111b = 10000111b
-10011111b & 10101000b = 10001000b
-10011111b & 10101001b = 10001001b
-10011111b & 10101010b = 10001010b
-10011111b & 10101011b = 10001011b
-10011111b & 10101100b = 10001100b
-10011111b & 10101101b = 10001101b
-10011111b & 10101110b = 10001110b
-10011111b & 10101111b = 10001111b
-10011111b & 10110000b = 10010000b
-10011111b & 10110001b = 10010001b
-10011111b & 10110010b = 10010010b
-10011111b & 10110011b = 10010011b
-10011111b & 10110100b = 10010100b
-10011111b & 10110101b = 10010101b
-10011111b & 10110110b = 10010110b
-10011111b & 10110111b = 10010111b
-10011111b & 10111000b = 10011000b
-10011111b & 10111001b = 10011001b
-10011111b & 10111010b = 10011010b
-10011111b & 10111011b = 10011011b
-10011111b & 10111100b = 10011100b
-10011111b & 10111101b = 10011101b
-10011111b & 10111110b = 10011110b
-10011111b & 10111111b = 10011111b
-10011111b & 11000000b = 10000000b
-10011111b & 11000001b = 10000001b
-10011111b & 11000010b = 10000010b
-10011111b & 11000011b = 10000011b
-10011111b & 11000100b = 10000100b
-10011111b & 11000101b = 10000101b
-10011111b & 11000110b = 10000110b
-10011111b & 11000111b = 10000111b
-10011111b & 11001000b = 10001000b
-10011111b & 11001001b = 10001001b
-10011111b & 11001010b = 10001010b
-10011111b & 11001011b = 10001011b
-10011111b & 11001100b = 10001100b
-10011111b & 11001101b = 10001101b
-10011111b & 11001110b = 10001110b
-10011111b & 11001111b = 10001111b
-10011111b & 11010000b = 10010000b
-10011111b & 11010001b = 10010001b
-10011111b & 11010010b = 10010010b
-10011111b & 11010011b = 10010011b
-10011111b & 11010100b = 10010100b
-10011111b & 11010101b = 10010101b
-10011111b & 11010110b = 10010110b
-10011111b & 11010111b = 10010111b
-10011111b & 11011000b = 10011000b
-10011111b & 11011001b = 10011001b
-10011111b & 11011010b = 10011010b
-10011111b & 11011011b = 10011011b
-10011111b & 11011100b = 10011100b
-10011111b & 11011101b = 10011101b
-10011111b & 11011110b = 10011110b
-10011111b & 11011111b = 10011111b
-10011111b & 11100000b = 10000000b
-10011111b & 11100001b = 10000001b
-10011111b & 11100010b = 10000010b
-10011111b & 11100011b = 10000011b
-10011111b & 11100100b = 10000100b
-10011111b & 11100101b = 10000101b
-10011111b & 11100110b = 10000110b
-10011111b & 11100111b = 10000111b
-10011111b & 11101000b = 10001000b
-10011111b & 11101001b = 10001001b
-10011111b & 11101010b = 10001010b
-10011111b & 11101011b = 10001011b
-10011111b & 11101100b = 10001100b
-10011111b & 11101101b = 10001101b
-10011111b & 11101110b = 10001110b
-10011111b & 11101111b = 10001111b
-10011111b & 11110000b = 10010000b
-10011111b & 11110001b = 10010001b
-10011111b & 11110010b = 10010010b
-10011111b & 11110011b = 10010011b
-10011111b & 11110100b = 10010100b
-10011111b & 11110101b = 10010101b
-10011111b & 11110110b = 10010110b
-10011111b & 11110111b = 10010111b
-10011111b & 11111000b = 10011000b
-10011111b & 11111001b = 10011001b
-10011111b & 11111010b = 10011010b
-10011111b & 11111011b = 10011011b
-10011111b & 11111100b = 10011100b
-10011111b & 11111101b = 10011101b
-10011111b & 11111110b = 10011110b
-10011111b & 11111111b = 10011111b
-10011111b & 00000000b = 00000000b
-10011111b & 00000001b = 00000001b
-10011111b & 00000010b = 00000010b
-10011111b & 00000011b = 00000011b
-10011111b & 00000100b = 00000100b
-10011111b & 00000101b = 00000101b
-10011111b & 00000110b = 00000110b
-10011111b & 00000111b = 00000111b
-10011111b & 00001000b = 00001000b
-10011111b & 00001001b = 00001001b
-10011111b & 00001010b = 00001010b
-10011111b & 00001011b = 00001011b
-10011111b & 00001100b = 00001100b
-10011111b & 00001101b = 00001101b
-10011111b & 00001110b = 00001110b
-10011111b & 00001111b = 00001111b
-10011111b & 00010000b = 00010000b
-10011111b & 00010001b = 00010001b
-10011111b & 00010010b = 00010010b
-10011111b & 00010011b = 00010011b
-10011111b & 00010100b = 00010100b
-10011111b & 00010101b = 00010101b
-10011111b & 00010110b = 00010110b
-10011111b & 00010111b = 00010111b
-10011111b & 00011000b = 00011000b
-10011111b & 00011001b = 00011001b
-10011111b & 00011010b = 00011010b
-10011111b & 00011011b = 00011011b
-10011111b & 00011100b = 00011100b
-10011111b & 00011101b = 00011101b
-10011111b & 00011110b = 00011110b
-10011111b & 00011111b = 00011111b
-10011111b & 00100000b = 00000000b
-10011111b & 00100001b = 00000001b
-10011111b & 00100010b = 00000010b
-10011111b & 00100011b = 00000011b
-10011111b & 00100100b = 00000100b
-10011111b & 00100101b = 00000101b
-10011111b & 00100110b = 00000110b
-10011111b & 00100111b = 00000111b
-10011111b & 00101000b = 00001000b
-10011111b & 00101001b = 00001001b
-10011111b & 00101010b = 00001010b
-10011111b & 00101011b = 00001011b
-10011111b & 00101100b = 00001100b
-10011111b & 00101101b = 00001101b
-10011111b & 00101110b = 00001110b
-10011111b & 00101111b = 00001111b
-10011111b & 00110000b = 00010000b
-10011111b & 00110001b = 00010001b
-10011111b & 00110010b = 00010010b
-10011111b & 00110011b = 00010011b
-10011111b & 00110100b = 00010100b
-10011111b & 00110101b = 00010101b
-10011111b & 00110110b = 00010110b
-10011111b & 00110111b = 00010111b
-10011111b & 00111000b = 00011000b
-10011111b & 00111001b = 00011001b
-10011111b & 00111010b = 00011010b
-10011111b & 00111011b = 00011011b
-10011111b & 00111100b = 00011100b
-10011111b & 00111101b = 00011101b
-10011111b & 00111110b = 00011110b
-10011111b & 00111111b = 00011111b
-10011111b & 01000000b = 00000000b
-10011111b & 01000001b = 00000001b
-10011111b & 01000010b = 00000010b
-10011111b & 01000011b = 00000011b
-10011111b & 01000100b = 00000100b
-10011111b & 01000101b = 00000101b
-10011111b & 01000110b = 00000110b
-10011111b & 01000111b = 00000111b
-10011111b & 01001000b = 00001000b
-10011111b & 01001001b = 00001001b
-10011111b & 01001010b = 00001010b
-10011111b & 01001011b = 00001011b
-10011111b & 01001100b = 00001100b
-10011111b & 01001101b = 00001101b
-10011111b & 01001110b = 00001110b
-10011111b & 01001111b = 00001111b
-10011111b & 01010000b = 00010000b
-10011111b & 01010001b = 00010001b
-10011111b & 01010010b = 00010010b
-10011111b & 01010011b = 00010011b
-10011111b & 01010100b = 00010100b
-10011111b & 01010101b = 00010101b
-10011111b & 01010110b = 00010110b
-10011111b & 01010111b = 00010111b
-10011111b & 01011000b = 00011000b
-10011111b & 01011001b = 00011001b
-10011111b & 01011010b = 00011010b
-10011111b & 01011011b = 00011011b
-10011111b & 01011100b = 00011100b
-10011111b & 01011101b = 00011101b
-10011111b & 01011110b = 00011110b
-10011111b & 01011111b = 00011111b
-10011111b & 01100000b = 00000000b
-10011111b & 01100001b = 00000001b
-10011111b & 01100010b = 00000010b
-10011111b & 01100011b = 00000011b
-10011111b & 01100100b = 00000100b
-10011111b & 01100101b = 00000101b
-10011111b & 01100110b = 00000110b
-10011111b & 01100111b = 00000111b
-10011111b & 01101000b = 00001000b
-10011111b & 01101001b = 00001001b
-10011111b & 01101010b = 00001010b
-10011111b & 01101011b = 00001011b
-10011111b & 01101100b = 00001100b
-10011111b & 01101101b = 00001101b
-10011111b & 01101110b = 00001110b
-10011111b & 01101111b = 00001111b
-10011111b & 01110000b = 00010000b
-10011111b & 01110001b = 00010001b
-10011111b & 01110010b = 00010010b
-10011111b & 01110011b = 00010011b
-10011111b & 01110100b = 00010100b
-10011111b & 01110101b = 00010101b
-10011111b & 01110110b = 00010110b
-10011111b & 01110111b = 00010111b
-10011111b & 01111000b = 00011000b
-10011111b & 01111001b = 00011001b
-10011111b & 01111010b = 00011010b
-10011111b & 01111011b = 00011011b
-10011111b & 01111100b = 00011100b
-10011111b & 01111101b = 00011101b
-10011111b & 01111110b = 00011110b
-10100000b & 10000000b = 10000000b
-10100000b & 10000001b = 10000000b
-10100000b & 10000010b = 10000000b
-10100000b & 10000011b = 10000000b
-10100000b & 10000100b = 10000000b
-10100000b & 10000101b = 10000000b
-10100000b & 10000110b = 10000000b
-10100000b & 10000111b = 10000000b
-10100000b & 10001000b = 10000000b
-10100000b & 10001001b = 10000000b
-10100000b & 10001010b = 10000000b
-10100000b & 10001011b = 10000000b
-10100000b & 10001100b = 10000000b
-10100000b & 10001101b = 10000000b
-10100000b & 10001110b = 10000000b
-10100000b & 10001111b = 10000000b
-10100000b & 10010000b = 10000000b
-10100000b & 10010001b = 10000000b
-10100000b & 10010010b = 10000000b
-10100000b & 10010011b = 10000000b
-10100000b & 10010100b = 10000000b
-10100000b & 10010101b = 10000000b
-10100000b & 10010110b = 10000000b
-10100000b & 10010111b = 10000000b
-10100000b & 10011000b = 10000000b
-10100000b & 10011001b = 10000000b
-10100000b & 10011010b = 10000000b
-10100000b & 10011011b = 10000000b
-10100000b & 10011100b = 10000000b
-10100000b & 10011101b = 10000000b
-10100000b & 10011110b = 10000000b
-10100000b & 10011111b = 10000000b
-10100000b & 10100000b = 10100000b
-10100000b & 10100001b = 10100000b
-10100000b & 10100010b = 10100000b
-10100000b & 10100011b = 10100000b
-10100000b & 10100100b = 10100000b
-10100000b & 10100101b = 10100000b
-10100000b & 10100110b = 10100000b
-10100000b & 10100111b = 10100000b
-10100000b & 10101000b = 10100000b
-10100000b & 10101001b = 10100000b
-10100000b & 10101010b = 10100000b
-10100000b & 10101011b = 10100000b
-10100000b & 10101100b = 10100000b
-10100000b & 10101101b = 10100000b
-10100000b & 10101110b = 10100000b
-10100000b & 10101111b = 10100000b
-10100000b & 10110000b = 10100000b
-10100000b & 10110001b = 10100000b
-10100000b & 10110010b = 10100000b
-10100000b & 10110011b = 10100000b
-10100000b & 10110100b = 10100000b
-10100000b & 10110101b = 10100000b
-10100000b & 10110110b = 10100000b
-10100000b & 10110111b = 10100000b
-10100000b & 10111000b = 10100000b
-10100000b & 10111001b = 10100000b
-10100000b & 10111010b = 10100000b
-10100000b & 10111011b = 10100000b
-10100000b & 10111100b = 10100000b
-10100000b & 10111101b = 10100000b
-10100000b & 10111110b = 10100000b
-10100000b & 10111111b = 10100000b
-10100000b & 11000000b = 10000000b
-10100000b & 11000001b = 10000000b
-10100000b & 11000010b = 10000000b
-10100000b & 11000011b = 10000000b
-10100000b & 11000100b = 10000000b
-10100000b & 11000101b = 10000000b
-10100000b & 11000110b = 10000000b
-10100000b & 11000111b = 10000000b
-10100000b & 11001000b = 10000000b
-10100000b & 11001001b = 10000000b
-10100000b & 11001010b = 10000000b
-10100000b & 11001011b = 10000000b
-10100000b & 11001100b = 10000000b
-10100000b & 11001101b = 10000000b
-10100000b & 11001110b = 10000000b
-10100000b & 11001111b = 10000000b
-10100000b & 11010000b = 10000000b
-10100000b & 11010001b = 10000000b
-10100000b & 11010010b = 10000000b
-10100000b & 11010011b = 10000000b
-10100000b & 11010100b = 10000000b
-10100000b & 11010101b = 10000000b
-10100000b & 11010110b = 10000000b
-10100000b & 11010111b = 10000000b
-10100000b & 11011000b = 10000000b
-10100000b & 11011001b = 10000000b
-10100000b & 11011010b = 10000000b
-10100000b & 11011011b = 10000000b
-10100000b & 11011100b = 10000000b
-10100000b & 11011101b = 10000000b
-10100000b & 11011110b = 10000000b
-10100000b & 11011111b = 10000000b
-10100000b & 11100000b = 10100000b
-10100000b & 11100001b = 10100000b
-10100000b & 11100010b = 10100000b
-10100000b & 11100011b = 10100000b
-10100000b & 11100100b = 10100000b
-10100000b & 11100101b = 10100000b
-10100000b & 11100110b = 10100000b
-10100000b & 11100111b = 10100000b
-10100000b & 11101000b = 10100000b
-10100000b & 11101001b = 10100000b
-10100000b & 11101010b = 10100000b
-10100000b & 11101011b = 10100000b
-10100000b & 11101100b = 10100000b
-10100000b & 11101101b = 10100000b
-10100000b & 11101110b = 10100000b
-10100000b & 11101111b = 10100000b
-10100000b & 11110000b = 10100000b
-10100000b & 11110001b = 10100000b
-10100000b & 11110010b = 10100000b
-10100000b & 11110011b = 10100000b
-10100000b & 11110100b = 10100000b
-10100000b & 11110101b = 10100000b
-10100000b & 11110110b = 10100000b
-10100000b & 11110111b = 10100000b
-10100000b & 11111000b = 10100000b
-10100000b & 11111001b = 10100000b
-10100000b & 11111010b = 10100000b
-10100000b & 11111011b = 10100000b
-10100000b & 11111100b = 10100000b
-10100000b & 11111101b = 10100000b
-10100000b & 11111110b = 10100000b
-10100000b & 11111111b = 10100000b
-10100000b & 00000000b = 00000000b
-10100000b & 00000001b = 00000000b
-10100000b & 00000010b = 00000000b
-10100000b & 00000011b = 00000000b
-10100000b & 00000100b = 00000000b
-10100000b & 00000101b = 00000000b
-10100000b & 00000110b = 00000000b
-10100000b & 00000111b = 00000000b
-10100000b & 00001000b = 00000000b
-10100000b & 00001001b = 00000000b
-10100000b & 00001010b = 00000000b
-10100000b & 00001011b = 00000000b
-10100000b & 00001100b = 00000000b
-10100000b & 00001101b = 00000000b
-10100000b & 00001110b = 00000000b
-10100000b & 00001111b = 00000000b
-10100000b & 00010000b = 00000000b
-10100000b & 00010001b = 00000000b
-10100000b & 00010010b = 00000000b
-10100000b & 00010011b = 00000000b
-10100000b & 00010100b = 00000000b
-10100000b & 00010101b = 00000000b
-10100000b & 00010110b = 00000000b
-10100000b & 00010111b = 00000000b
-10100000b & 00011000b = 00000000b
-10100000b & 00011001b = 00000000b
-10100000b & 00011010b = 00000000b
-10100000b & 00011011b = 00000000b
-10100000b & 00011100b = 00000000b
-10100000b & 00011101b = 00000000b
-10100000b & 00011110b = 00000000b
-10100000b & 00011111b = 00000000b
-10100000b & 00100000b = 00100000b
-10100000b & 00100001b = 00100000b
-10100000b & 00100010b = 00100000b
-10100000b & 00100011b = 00100000b
-10100000b & 00100100b = 00100000b
-10100000b & 00100101b = 00100000b
-10100000b & 00100110b = 00100000b
-10100000b & 00100111b = 00100000b
-10100000b & 00101000b = 00100000b
-10100000b & 00101001b = 00100000b
-10100000b & 00101010b = 00100000b
-10100000b & 00101011b = 00100000b
-10100000b & 00101100b = 00100000b
-10100000b & 00101101b = 00100000b
-10100000b & 00101110b = 00100000b
-10100000b & 00101111b = 00100000b
-10100000b & 00110000b = 00100000b
-10100000b & 00110001b = 00100000b
-10100000b & 00110010b = 00100000b
-10100000b & 00110011b = 00100000b
-10100000b & 00110100b = 00100000b
-10100000b & 00110101b = 00100000b
-10100000b & 00110110b = 00100000b
-10100000b & 00110111b = 00100000b
-10100000b & 00111000b = 00100000b
-10100000b & 00111001b = 00100000b
-10100000b & 00111010b = 00100000b
-10100000b & 00111011b = 00100000b
-10100000b & 00111100b = 00100000b
-10100000b & 00111101b = 00100000b
-10100000b & 00111110b = 00100000b
-10100000b & 00111111b = 00100000b
-10100000b & 01000000b = 00000000b
-10100000b & 01000001b = 00000000b
-10100000b & 01000010b = 00000000b
-10100000b & 01000011b = 00000000b
-10100000b & 01000100b = 00000000b
-10100000b & 01000101b = 00000000b
-10100000b & 01000110b = 00000000b
-10100000b & 01000111b = 00000000b
-10100000b & 01001000b = 00000000b
-10100000b & 01001001b = 00000000b
-10100000b & 01001010b = 00000000b
-10100000b & 01001011b = 00000000b
-10100000b & 01001100b = 00000000b
-10100000b & 01001101b = 00000000b
-10100000b & 01001110b = 00000000b
-10100000b & 01001111b = 00000000b
-10100000b & 01010000b = 00000000b
-10100000b & 01010001b = 00000000b
-10100000b & 01010010b = 00000000b
-10100000b & 01010011b = 00000000b
-10100000b & 01010100b = 00000000b
-10100000b & 01010101b = 00000000b
-10100000b & 01010110b = 00000000b
-10100000b & 01010111b = 00000000b
-10100000b & 01011000b = 00000000b
-10100000b & 01011001b = 00000000b
-10100000b & 01011010b = 00000000b
-10100000b & 01011011b = 00000000b
-10100000b & 01011100b = 00000000b
-10100000b & 01011101b = 00000000b
-10100000b & 01011110b = 00000000b
-10100000b & 01011111b = 00000000b
-10100000b & 01100000b = 00100000b
-10100000b & 01100001b = 00100000b
-10100000b & 01100010b = 00100000b
-10100000b & 01100011b = 00100000b
-10100000b & 01100100b = 00100000b
-10100000b & 01100101b = 00100000b
-10100000b & 01100110b = 00100000b
-10100000b & 01100111b = 00100000b
-10100000b & 01101000b = 00100000b
-10100000b & 01101001b = 00100000b
-10100000b & 01101010b = 00100000b
-10100000b & 01101011b = 00100000b
-10100000b & 01101100b = 00100000b
-10100000b & 01101101b = 00100000b
-10100000b & 01101110b = 00100000b
-10100000b & 01101111b = 00100000b
-10100000b & 01110000b = 00100000b
-10100000b & 01110001b = 00100000b
-10100000b & 01110010b = 00100000b
-10100000b & 01110011b = 00100000b
-10100000b & 01110100b = 00100000b
-10100000b & 01110101b = 00100000b
-10100000b & 01110110b = 00100000b
-10100000b & 01110111b = 00100000b
-10100000b & 01111000b = 00100000b
-10100000b & 01111001b = 00100000b
-10100000b & 01111010b = 00100000b
-10100000b & 01111011b = 00100000b
-10100000b & 01111100b = 00100000b
-10100000b & 01111101b = 00100000b
-10100000b & 01111110b = 00100000b
-10100001b & 10000000b = 10000000b
-10100001b & 10000001b = 10000001b
-10100001b & 10000010b = 10000000b
-10100001b & 10000011b = 10000001b
-10100001b & 10000100b = 10000000b
-10100001b & 10000101b = 10000001b
-10100001b & 10000110b = 10000000b
-10100001b & 10000111b = 10000001b
-10100001b & 10001000b = 10000000b
-10100001b & 10001001b = 10000001b
-10100001b & 10001010b = 10000000b
-10100001b & 10001011b = 10000001b
-10100001b & 10001100b = 10000000b
-10100001b & 10001101b = 10000001b
-10100001b & 10001110b = 10000000b
-10100001b & 10001111b = 10000001b
-10100001b & 10010000b = 10000000b
-10100001b & 10010001b = 10000001b
-10100001b & 10010010b = 10000000b
-10100001b & 10010011b = 10000001b
-10100001b & 10010100b = 10000000b
-10100001b & 10010101b = 10000001b
-10100001b & 10010110b = 10000000b
-10100001b & 10010111b = 10000001b
-10100001b & 10011000b = 10000000b
-10100001b & 10011001b = 10000001b
-10100001b & 10011010b = 10000000b
-10100001b & 10011011b = 10000001b
-10100001b & 10011100b = 10000000b
-10100001b & 10011101b = 10000001b
-10100001b & 10011110b = 10000000b
-10100001b & 10011111b = 10000001b
-10100001b & 10100000b = 10100000b
-10100001b & 10100001b = 10100001b
-10100001b & 10100010b = 10100000b
-10100001b & 10100011b = 10100001b
-10100001b & 10100100b = 10100000b
-10100001b & 10100101b = 10100001b
-10100001b & 10100110b = 10100000b
-10100001b & 10100111b = 10100001b
-10100001b & 10101000b = 10100000b
-10100001b & 10101001b = 10100001b
-10100001b & 10101010b = 10100000b
-10100001b & 10101011b = 10100001b
-10100001b & 10101100b = 10100000b
-10100001b & 10101101b = 10100001b
-10100001b & 10101110b = 10100000b
-10100001b & 10101111b = 10100001b
-10100001b & 10110000b = 10100000b
-10100001b & 10110001b = 10100001b
-10100001b & 10110010b = 10100000b
-10100001b & 10110011b = 10100001b
-10100001b & 10110100b = 10100000b
-10100001b & 10110101b = 10100001b
-10100001b & 10110110b = 10100000b
-10100001b & 10110111b = 10100001b
-10100001b & 10111000b = 10100000b
-10100001b & 10111001b = 10100001b
-10100001b & 10111010b = 10100000b
-10100001b & 10111011b = 10100001b
-10100001b & 10111100b = 10100000b
-10100001b & 10111101b = 10100001b
-10100001b & 10111110b = 10100000b
-10100001b & 10111111b = 10100001b
-10100001b & 11000000b = 10000000b
-10100001b & 11000001b = 10000001b
-10100001b & 11000010b = 10000000b
-10100001b & 11000011b = 10000001b
-10100001b & 11000100b = 10000000b
-10100001b & 11000101b = 10000001b
-10100001b & 11000110b = 10000000b
-10100001b & 11000111b = 10000001b
-10100001b & 11001000b = 10000000b
-10100001b & 11001001b = 10000001b
-10100001b & 11001010b = 10000000b
-10100001b & 11001011b = 10000001b
-10100001b & 11001100b = 10000000b
-10100001b & 11001101b = 10000001b
-10100001b & 11001110b = 10000000b
-10100001b & 11001111b = 10000001b
-10100001b & 11010000b = 10000000b
-10100001b & 11010001b = 10000001b
-10100001b & 11010010b = 10000000b
-10100001b & 11010011b = 10000001b
-10100001b & 11010100b = 10000000b
-10100001b & 11010101b = 10000001b
-10100001b & 11010110b = 10000000b
-10100001b & 11010111b = 10000001b
-10100001b & 11011000b = 10000000b
-10100001b & 11011001b = 10000001b
-10100001b & 11011010b = 10000000b
-10100001b & 11011011b = 10000001b
-10100001b & 11011100b = 10000000b
-10100001b & 11011101b = 10000001b
-10100001b & 11011110b = 10000000b
-10100001b & 11011111b = 10000001b
-10100001b & 11100000b = 10100000b
-10100001b & 11100001b = 10100001b
-10100001b & 11100010b = 10100000b
-10100001b & 11100011b = 10100001b
-10100001b & 11100100b = 10100000b
-10100001b & 11100101b = 10100001b
-10100001b & 11100110b = 10100000b
-10100001b & 11100111b = 10100001b
-10100001b & 11101000b = 10100000b
-10100001b & 11101001b = 10100001b
-10100001b & 11101010b = 10100000b
-10100001b & 11101011b = 10100001b
-10100001b & 11101100b = 10100000b
-10100001b & 11101101b = 10100001b
-10100001b & 11101110b = 10100000b
-10100001b & 11101111b = 10100001b
-10100001b & 11110000b = 10100000b
-10100001b & 11110001b = 10100001b
-10100001b & 11110010b = 10100000b
-10100001b & 11110011b = 10100001b
-10100001b & 11110100b = 10100000b
-10100001b & 11110101b = 10100001b
-10100001b & 11110110b = 10100000b
-10100001b & 11110111b = 10100001b
-10100001b & 11111000b = 10100000b
-10100001b & 11111001b = 10100001b
-10100001b & 11111010b = 10100000b
-10100001b & 11111011b = 10100001b
-10100001b & 11111100b = 10100000b
-10100001b & 11111101b = 10100001b
-10100001b & 11111110b = 10100000b
-10100001b & 11111111b = 10100001b
-10100001b & 00000000b = 00000000b
-10100001b & 00000001b = 00000001b
-10100001b & 00000010b = 00000000b
-10100001b & 00000011b = 00000001b
-10100001b & 00000100b = 00000000b
-10100001b & 00000101b = 00000001b
-10100001b & 00000110b = 00000000b
-10100001b & 00000111b = 00000001b
-10100001b & 00001000b = 00000000b
-10100001b & 00001001b = 00000001b
-10100001b & 00001010b = 00000000b
-10100001b & 00001011b = 00000001b
-10100001b & 00001100b = 00000000b
-10100001b & 00001101b = 00000001b
-10100001b & 00001110b = 00000000b
-10100001b & 00001111b = 00000001b
-10100001b & 00010000b = 00000000b
-10100001b & 00010001b = 00000001b
-10100001b & 00010010b = 00000000b
-10100001b & 00010011b = 00000001b
-10100001b & 00010100b = 00000000b
-10100001b & 00010101b = 00000001b
-10100001b & 00010110b = 00000000b
-10100001b & 00010111b = 00000001b
-10100001b & 00011000b = 00000000b
-10100001b & 00011001b = 00000001b
-10100001b & 00011010b = 00000000b
-10100001b & 00011011b = 00000001b
-10100001b & 00011100b = 00000000b
-10100001b & 00011101b = 00000001b
-10100001b & 00011110b = 00000000b
-10100001b & 00011111b = 00000001b
-10100001b & 00100000b = 00100000b
-10100001b & 00100001b = 00100001b
-10100001b & 00100010b = 00100000b
-10100001b & 00100011b = 00100001b
-10100001b & 00100100b = 00100000b
-10100001b & 00100101b = 00100001b
-10100001b & 00100110b = 00100000b
-10100001b & 00100111b = 00100001b
-10100001b & 00101000b = 00100000b
-10100001b & 00101001b = 00100001b
-10100001b & 00101010b = 00100000b
-10100001b & 00101011b = 00100001b
-10100001b & 00101100b = 00100000b
-10100001b & 00101101b = 00100001b
-10100001b & 00101110b = 00100000b
-10100001b & 00101111b = 00100001b
-10100001b & 00110000b = 00100000b
-10100001b & 00110001b = 00100001b
-10100001b & 00110010b = 00100000b
-10100001b & 00110011b = 00100001b
-10100001b & 00110100b = 00100000b
-10100001b & 00110101b = 00100001b
-10100001b & 00110110b = 00100000b
-10100001b & 00110111b = 00100001b
-10100001b & 00111000b = 00100000b
-10100001b & 00111001b = 00100001b
-10100001b & 00111010b = 00100000b
-10100001b & 00111011b = 00100001b
-10100001b & 00111100b = 00100000b
-10100001b & 00111101b = 00100001b
-10100001b & 00111110b = 00100000b
-10100001b & 00111111b = 00100001b
-10100001b & 01000000b = 00000000b
-10100001b & 01000001b = 00000001b
-10100001b & 01000010b = 00000000b
-10100001b & 01000011b = 00000001b
-10100001b & 01000100b = 00000000b
-10100001b & 01000101b = 00000001b
-10100001b & 01000110b = 00000000b
-10100001b & 01000111b = 00000001b
-10100001b & 01001000b = 00000000b
-10100001b & 01001001b = 00000001b
-10100001b & 01001010b = 00000000b
-10100001b & 01001011b = 00000001b
-10100001b & 01001100b = 00000000b
-10100001b & 01001101b = 00000001b
-10100001b & 01001110b = 00000000b
-10100001b & 01001111b = 00000001b
-10100001b & 01010000b = 00000000b
-10100001b & 01010001b = 00000001b
-10100001b & 01010010b = 00000000b
-10100001b & 01010011b = 00000001b
-10100001b & 01010100b = 00000000b
-10100001b & 01010101b = 00000001b
-10100001b & 01010110b = 00000000b
-10100001b & 01010111b = 00000001b
-10100001b & 01011000b = 00000000b
-10100001b & 01011001b = 00000001b
-10100001b & 01011010b = 00000000b
-10100001b & 01011011b = 00000001b
-10100001b & 01011100b = 00000000b
-10100001b & 01011101b = 00000001b
-10100001b & 01011110b = 00000000b
-10100001b & 01011111b = 00000001b
-10100001b & 01100000b = 00100000b
-10100001b & 01100001b = 00100001b
-10100001b & 01100010b = 00100000b
-10100001b & 01100011b = 00100001b
-10100001b & 01100100b = 00100000b
-10100001b & 01100101b = 00100001b
-10100001b & 01100110b = 00100000b
-10100001b & 01100111b = 00100001b
-10100001b & 01101000b = 00100000b
-10100001b & 01101001b = 00100001b
-10100001b & 01101010b = 00100000b
-10100001b & 01101011b = 00100001b
-10100001b & 01101100b = 00100000b
-10100001b & 01101101b = 00100001b
-10100001b & 01101110b = 00100000b
-10100001b & 01101111b = 00100001b
-10100001b & 01110000b = 00100000b
-10100001b & 01110001b = 00100001b
-10100001b & 01110010b = 00100000b
-10100001b & 01110011b = 00100001b
-10100001b & 01110100b = 00100000b
-10100001b & 01110101b = 00100001b
-10100001b & 01110110b = 00100000b
-10100001b & 01110111b = 00100001b
-10100001b & 01111000b = 00100000b
-10100001b & 01111001b = 00100001b
-10100001b & 01111010b = 00100000b
-10100001b & 01111011b = 00100001b
-10100001b & 01111100b = 00100000b
-10100001b & 01111101b = 00100001b
-10100001b & 01111110b = 00100000b
-10100010b & 10000000b = 10000000b
-10100010b & 10000001b = 10000000b
-10100010b & 10000010b = 10000010b
-10100010b & 10000011b = 10000010b
-10100010b & 10000100b = 10000000b
-10100010b & 10000101b = 10000000b
-10100010b & 10000110b = 10000010b
-10100010b & 10000111b = 10000010b
-10100010b & 10001000b = 10000000b
-10100010b & 10001001b = 10000000b
-10100010b & 10001010b = 10000010b
-10100010b & 10001011b = 10000010b
-10100010b & 10001100b = 10000000b
-10100010b & 10001101b = 10000000b
-10100010b & 10001110b = 10000010b
-10100010b & 10001111b = 10000010b
-10100010b & 10010000b = 10000000b
-10100010b & 10010001b = 10000000b
-10100010b & 10010010b = 10000010b
-10100010b & 10010011b = 10000010b
-10100010b & 10010100b = 10000000b
-10100010b & 10010101b = 10000000b
-10100010b & 10010110b = 10000010b
-10100010b & 10010111b = 10000010b
-10100010b & 10011000b = 10000000b
-10100010b & 10011001b = 10000000b
-10100010b & 10011010b = 10000010b
-10100010b & 10011011b = 10000010b
-10100010b & 10011100b = 10000000b
-10100010b & 10011101b = 10000000b
-10100010b & 10011110b = 10000010b
-10100010b & 10011111b = 10000010b
-10100010b & 10100000b = 10100000b
-10100010b & 10100001b = 10100000b
-10100010b & 10100010b = 10100010b
-10100010b & 10100011b = 10100010b
-10100010b & 10100100b = 10100000b
-10100010b & 10100101b = 10100000b
-10100010b & 10100110b = 10100010b
-10100010b & 10100111b = 10100010b
-10100010b & 10101000b = 10100000b
-10100010b & 10101001b = 10100000b
-10100010b & 10101010b = 10100010b
-10100010b & 10101011b = 10100010b
-10100010b & 10101100b = 10100000b
-10100010b & 10101101b = 10100000b
-10100010b & 10101110b = 10100010b
-10100010b & 10101111b = 10100010b
-10100010b & 10110000b = 10100000b
-10100010b & 10110001b = 10100000b
-10100010b & 10110010b = 10100010b
-10100010b & 10110011b = 10100010b
-10100010b & 10110100b = 10100000b
-10100010b & 10110101b = 10100000b
-10100010b & 10110110b = 10100010b
-10100010b & 10110111b = 10100010b
-10100010b & 10111000b = 10100000b
-10100010b & 10111001b = 10100000b
-10100010b & 10111010b = 10100010b
-10100010b & 10111011b = 10100010b
-10100010b & 10111100b = 10100000b
-10100010b & 10111101b = 10100000b
-10100010b & 10111110b = 10100010b
-10100010b & 10111111b = 10100010b
-10100010b & 11000000b = 10000000b
-10100010b & 11000001b = 10000000b
-10100010b & 11000010b = 10000010b
-10100010b & 11000011b = 10000010b
-10100010b & 11000100b = 10000000b
-10100010b & 11000101b = 10000000b
-10100010b & 11000110b = 10000010b
-10100010b & 11000111b = 10000010b
-10100010b & 11001000b = 10000000b
-10100010b & 11001001b = 10000000b
-10100010b & 11001010b = 10000010b
-10100010b & 11001011b = 10000010b
-10100010b & 11001100b = 10000000b
-10100010b & 11001101b = 10000000b
-10100010b & 11001110b = 10000010b
-10100010b & 11001111b = 10000010b
-10100010b & 11010000b = 10000000b
-10100010b & 11010001b = 10000000b
-10100010b & 11010010b = 10000010b
-10100010b & 11010011b = 10000010b
-10100010b & 11010100b = 10000000b
-10100010b & 11010101b = 10000000b
-10100010b & 11010110b = 10000010b
-10100010b & 11010111b = 10000010b
-10100010b & 11011000b = 10000000b
-10100010b & 11011001b = 10000000b
-10100010b & 11011010b = 10000010b
-10100010b & 11011011b = 10000010b
-10100010b & 11011100b = 10000000b
-10100010b & 11011101b = 10000000b
-10100010b & 11011110b = 10000010b
-10100010b & 11011111b = 10000010b
-10100010b & 11100000b = 10100000b
-10100010b & 11100001b = 10100000b
-10100010b & 11100010b = 10100010b
-10100010b & 11100011b = 10100010b
-10100010b & 11100100b = 10100000b
-10100010b & 11100101b = 10100000b
-10100010b & 11100110b = 10100010b
-10100010b & 11100111b = 10100010b
-10100010b & 11101000b = 10100000b
-10100010b & 11101001b = 10100000b
-10100010b & 11101010b = 10100010b
-10100010b & 11101011b = 10100010b
-10100010b & 11101100b = 10100000b
-10100010b & 11101101b = 10100000b
-10100010b & 11101110b = 10100010b
-10100010b & 11101111b = 10100010b
-10100010b & 11110000b = 10100000b
-10100010b & 11110001b = 10100000b
-10100010b & 11110010b = 10100010b
-10100010b & 11110011b = 10100010b
-10100010b & 11110100b = 10100000b
-10100010b & 11110101b = 10100000b
-10100010b & 11110110b = 10100010b
-10100010b & 11110111b = 10100010b
-10100010b & 11111000b = 10100000b
-10100010b & 11111001b = 10100000b
-10100010b & 11111010b = 10100010b
-10100010b & 11111011b = 10100010b
-10100010b & 11111100b = 10100000b
-10100010b & 11111101b = 10100000b
-10100010b & 11111110b = 10100010b
-10100010b & 11111111b = 10100010b
-10100010b & 00000000b = 00000000b
-10100010b & 00000001b = 00000000b
-10100010b & 00000010b = 00000010b
-10100010b & 00000011b = 00000010b
-10100010b & 00000100b = 00000000b
-10100010b & 00000101b = 00000000b
-10100010b & 00000110b = 00000010b
-10100010b & 00000111b = 00000010b
-10100010b & 00001000b = 00000000b
-10100010b & 00001001b = 00000000b
-10100010b & 00001010b = 00000010b
-10100010b & 00001011b = 00000010b
-10100010b & 00001100b = 00000000b
-10100010b & 00001101b = 00000000b
-10100010b & 00001110b = 00000010b
-10100010b & 00001111b = 00000010b
-10100010b & 00010000b = 00000000b
-10100010b & 00010001b = 00000000b
-10100010b & 00010010b = 00000010b
-10100010b & 00010011b = 00000010b
-10100010b & 00010100b = 00000000b
-10100010b & 00010101b = 00000000b
-10100010b & 00010110b = 00000010b
-10100010b & 00010111b = 00000010b
-10100010b & 00011000b = 00000000b
-10100010b & 00011001b = 00000000b
-10100010b & 00011010b = 00000010b
-10100010b & 00011011b = 00000010b
-10100010b & 00011100b = 00000000b
-10100010b & 00011101b = 00000000b
-10100010b & 00011110b = 00000010b
-10100010b & 00011111b = 00000010b
-10100010b & 00100000b = 00100000b
-10100010b & 00100001b = 00100000b
-10100010b & 00100010b = 00100010b
-10100010b & 00100011b = 00100010b
-10100010b & 00100100b = 00100000b
-10100010b & 00100101b = 00100000b
-10100010b & 00100110b = 00100010b
-10100010b & 00100111b = 00100010b
-10100010b & 00101000b = 00100000b
-10100010b & 00101001b = 00100000b
-10100010b & 00101010b = 00100010b
-10100010b & 00101011b = 00100010b
-10100010b & 00101100b = 00100000b
-10100010b & 00101101b = 00100000b
-10100010b & 00101110b = 00100010b
-10100010b & 00101111b = 00100010b
-10100010b & 00110000b = 00100000b
-10100010b & 00110001b = 00100000b
-10100010b & 00110010b = 00100010b
-10100010b & 00110011b = 00100010b
-10100010b & 00110100b = 00100000b
-10100010b & 00110101b = 00100000b
-10100010b & 00110110b = 00100010b
-10100010b & 00110111b = 00100010b
-10100010b & 00111000b = 00100000b
-10100010b & 00111001b = 00100000b
-10100010b & 00111010b = 00100010b
-10100010b & 00111011b = 00100010b
-10100010b & 00111100b = 00100000b
-10100010b & 00111101b = 00100000b
-10100010b & 00111110b = 00100010b
-10100010b & 00111111b = 00100010b
-10100010b & 01000000b = 00000000b
-10100010b & 01000001b = 00000000b
-10100010b & 01000010b = 00000010b
-10100010b & 01000011b = 00000010b
-10100010b & 01000100b = 00000000b
-10100010b & 01000101b = 00000000b
-10100010b & 01000110b = 00000010b
-10100010b & 01000111b = 00000010b
-10100010b & 01001000b = 00000000b
-10100010b & 01001001b = 00000000b
-10100010b & 01001010b = 00000010b
-10100010b & 01001011b = 00000010b
-10100010b & 01001100b = 00000000b
-10100010b & 01001101b = 00000000b
-10100010b & 01001110b = 00000010b
-10100010b & 01001111b = 00000010b
-10100010b & 01010000b = 00000000b
-10100010b & 01010001b = 00000000b
-10100010b & 01010010b = 00000010b
-10100010b & 01010011b = 00000010b
-10100010b & 01010100b = 00000000b
-10100010b & 01010101b = 00000000b
-10100010b & 01010110b = 00000010b
-10100010b & 01010111b = 00000010b
-10100010b & 01011000b = 00000000b
-10100010b & 01011001b = 00000000b
-10100010b & 01011010b = 00000010b
-10100010b & 01011011b = 00000010b
-10100010b & 01011100b = 00000000b
-10100010b & 01011101b = 00000000b
-10100010b & 01011110b = 00000010b
-10100010b & 01011111b = 00000010b
-10100010b & 01100000b = 00100000b
-10100010b & 01100001b = 00100000b
-10100010b & 01100010b = 00100010b
-10100010b & 01100011b = 00100010b
-10100010b & 01100100b = 00100000b
-10100010b & 01100101b = 00100000b
-10100010b & 01100110b = 00100010b
-10100010b & 01100111b = 00100010b
-10100010b & 01101000b = 00100000b
-10100010b & 01101001b = 00100000b
-10100010b & 01101010b = 00100010b
-10100010b & 01101011b = 00100010b
-10100010b & 01101100b = 00100000b
-10100010b & 01101101b = 00100000b
-10100010b & 01101110b = 00100010b
-10100010b & 01101111b = 00100010b
-10100010b & 01110000b = 00100000b
-10100010b & 01110001b = 00100000b
-10100010b & 01110010b = 00100010b
-10100010b & 01110011b = 00100010b
-10100010b & 01110100b = 00100000b
-10100010b & 01110101b = 00100000b
-10100010b & 01110110b = 00100010b
-10100010b & 01110111b = 00100010b
-10100010b & 01111000b = 00100000b
-10100010b & 01111001b = 00100000b
-10100010b & 01111010b = 00100010b
-10100010b & 01111011b = 00100010b
-10100010b & 01111100b = 00100000b
-10100010b & 01111101b = 00100000b
-10100010b & 01111110b = 00100010b
-10100011b & 10000000b = 10000000b
-10100011b & 10000001b = 10000001b
-10100011b & 10000010b = 10000010b
-10100011b & 10000011b = 10000011b
-10100011b & 10000100b = 10000000b
-10100011b & 10000101b = 10000001b
-10100011b & 10000110b = 10000010b
-10100011b & 10000111b = 10000011b
-10100011b & 10001000b = 10000000b
-10100011b & 10001001b = 10000001b
-10100011b & 10001010b = 10000010b
-10100011b & 10001011b = 10000011b
-10100011b & 10001100b = 10000000b
-10100011b & 10001101b = 10000001b
-10100011b & 10001110b = 10000010b
-10100011b & 10001111b = 10000011b
-10100011b & 10010000b = 10000000b
-10100011b & 10010001b = 10000001b
-10100011b & 10010010b = 10000010b
-10100011b & 10010011b = 10000011b
-10100011b & 10010100b = 10000000b
-10100011b & 10010101b = 10000001b
-10100011b & 10010110b = 10000010b
-10100011b & 10010111b = 10000011b
-10100011b & 10011000b = 10000000b
-10100011b & 10011001b = 10000001b
-10100011b & 10011010b = 10000010b
-10100011b & 10011011b = 10000011b
-10100011b & 10011100b = 10000000b
-10100011b & 10011101b = 10000001b
-10100011b & 10011110b = 10000010b
-10100011b & 10011111b = 10000011b
-10100011b & 10100000b = 10100000b
-10100011b & 10100001b = 10100001b
-10100011b & 10100010b = 10100010b
-10100011b & 10100011b = 10100011b
-10100011b & 10100100b = 10100000b
-10100011b & 10100101b = 10100001b
-10100011b & 10100110b = 10100010b
-10100011b & 10100111b = 10100011b
-10100011b & 10101000b = 10100000b
-10100011b & 10101001b = 10100001b
-10100011b & 10101010b = 10100010b
-10100011b & 10101011b = 10100011b
-10100011b & 10101100b = 10100000b
-10100011b & 10101101b = 10100001b
-10100011b & 10101110b = 10100010b
-10100011b & 10101111b = 10100011b
-10100011b & 10110000b = 10100000b
-10100011b & 10110001b = 10100001b
-10100011b & 10110010b = 10100010b
-10100011b & 10110011b = 10100011b
-10100011b & 10110100b = 10100000b
-10100011b & 10110101b = 10100001b
-10100011b & 10110110b = 10100010b
-10100011b & 10110111b = 10100011b
-10100011b & 10111000b = 10100000b
-10100011b & 10111001b = 10100001b
-10100011b & 10111010b = 10100010b
-10100011b & 10111011b = 10100011b
-10100011b & 10111100b = 10100000b
-10100011b & 10111101b = 10100001b
-10100011b & 10111110b = 10100010b
-10100011b & 10111111b = 10100011b
-10100011b & 11000000b = 10000000b
-10100011b & 11000001b = 10000001b
-10100011b & 11000010b = 10000010b
-10100011b & 11000011b = 10000011b
-10100011b & 11000100b = 10000000b
-10100011b & 11000101b = 10000001b
-10100011b & 11000110b = 10000010b
-10100011b & 11000111b = 10000011b
-10100011b & 11001000b = 10000000b
-10100011b & 11001001b = 10000001b
-10100011b & 11001010b = 10000010b
-10100011b & 11001011b = 10000011b
-10100011b & 11001100b = 10000000b
-10100011b & 11001101b = 10000001b
-10100011b & 11001110b = 10000010b
-10100011b & 11001111b = 10000011b
-10100011b & 11010000b = 10000000b
-10100011b & 11010001b = 10000001b
-10100011b & 11010010b = 10000010b
-10100011b & 11010011b = 10000011b
-10100011b & 11010100b = 10000000b
-10100011b & 11010101b = 10000001b
-10100011b & 11010110b = 10000010b
-10100011b & 11010111b = 10000011b
-10100011b & 11011000b = 10000000b
-10100011b & 11011001b = 10000001b
-10100011b & 11011010b = 10000010b
-10100011b & 11011011b = 10000011b
-10100011b & 11011100b = 10000000b
-10100011b & 11011101b = 10000001b
-10100011b & 11011110b = 10000010b
-10100011b & 11011111b = 10000011b
-10100011b & 11100000b = 10100000b
-10100011b & 11100001b = 10100001b
-10100011b & 11100010b = 10100010b
-10100011b & 11100011b = 10100011b
-10100011b & 11100100b = 10100000b
-10100011b & 11100101b = 10100001b
-10100011b & 11100110b = 10100010b
-10100011b & 11100111b = 10100011b
-10100011b & 11101000b = 10100000b
-10100011b & 11101001b = 10100001b
-10100011b & 11101010b = 10100010b
-10100011b & 11101011b = 10100011b
-10100011b & 11101100b = 10100000b
-10100011b & 11101101b = 10100001b
-10100011b & 11101110b = 10100010b
-10100011b & 11101111b = 10100011b
-10100011b & 11110000b = 10100000b
-10100011b & 11110001b = 10100001b
-10100011b & 11110010b = 10100010b
-10100011b & 11110011b = 10100011b
-10100011b & 11110100b = 10100000b
-10100011b & 11110101b = 10100001b
-10100011b & 11110110b = 10100010b
-10100011b & 11110111b = 10100011b
-10100011b & 11111000b = 10100000b
-10100011b & 11111001b = 10100001b
-10100011b & 11111010b = 10100010b
-10100011b & 11111011b = 10100011b
-10100011b & 11111100b = 10100000b
-10100011b & 11111101b = 10100001b
-10100011b & 11111110b = 10100010b
-10100011b & 11111111b = 10100011b
-10100011b & 00000000b = 00000000b
-10100011b & 00000001b = 00000001b
-10100011b & 00000010b = 00000010b
-10100011b & 00000011b = 00000011b
-10100011b & 00000100b = 00000000b
-10100011b & 00000101b = 00000001b
-10100011b & 00000110b = 00000010b
-10100011b & 00000111b = 00000011b
-10100011b & 00001000b = 00000000b
-10100011b & 00001001b = 00000001b
-10100011b & 00001010b = 00000010b
-10100011b & 00001011b = 00000011b
-10100011b & 00001100b = 00000000b
-10100011b & 00001101b = 00000001b
-10100011b & 00001110b = 00000010b
-10100011b & 00001111b = 00000011b
-10100011b & 00010000b = 00000000b
-10100011b & 00010001b = 00000001b
-10100011b & 00010010b = 00000010b
-10100011b & 00010011b = 00000011b
-10100011b & 00010100b = 00000000b
-10100011b & 00010101b = 00000001b
-10100011b & 00010110b = 00000010b
-10100011b & 00010111b = 00000011b
-10100011b & 00011000b = 00000000b
-10100011b & 00011001b = 00000001b
-10100011b & 00011010b = 00000010b
-10100011b & 00011011b = 00000011b
-10100011b & 00011100b = 00000000b
-10100011b & 00011101b = 00000001b
-10100011b & 00011110b = 00000010b
-10100011b & 00011111b = 00000011b
-10100011b & 00100000b = 00100000b
-10100011b & 00100001b = 00100001b
-10100011b & 00100010b = 00100010b
-10100011b & 00100011b = 00100011b
-10100011b & 00100100b = 00100000b
-10100011b & 00100101b = 00100001b
-10100011b & 00100110b = 00100010b
-10100011b & 00100111b = 00100011b
-10100011b & 00101000b = 00100000b
-10100011b & 00101001b = 00100001b
-10100011b & 00101010b = 00100010b
-10100011b & 00101011b = 00100011b
-10100011b & 00101100b = 00100000b
-10100011b & 00101101b = 00100001b
-10100011b & 00101110b = 00100010b
-10100011b & 00101111b = 00100011b
-10100011b & 00110000b = 00100000b
-10100011b & 00110001b = 00100001b
-10100011b & 00110010b = 00100010b
-10100011b & 00110011b = 00100011b
-10100011b & 00110100b = 00100000b
-10100011b & 00110101b = 00100001b
-10100011b & 00110110b = 00100010b
-10100011b & 00110111b = 00100011b
-10100011b & 00111000b = 00100000b
-10100011b & 00111001b = 00100001b
-10100011b & 00111010b = 00100010b
-10100011b & 00111011b = 00100011b
-10100011b & 00111100b = 00100000b
-10100011b & 00111101b = 00100001b
-10100011b & 00111110b = 00100010b
-10100011b & 00111111b = 00100011b
-10100011b & 01000000b = 00000000b
-10100011b & 01000001b = 00000001b
-10100011b & 01000010b = 00000010b
-10100011b & 01000011b = 00000011b
-10100011b & 01000100b = 00000000b
-10100011b & 01000101b = 00000001b
-10100011b & 01000110b = 00000010b
-10100011b & 01000111b = 00000011b
-10100011b & 01001000b = 00000000b
-10100011b & 01001001b = 00000001b
-10100011b & 01001010b = 00000010b
-10100011b & 01001011b = 00000011b
-10100011b & 01001100b = 00000000b
-10100011b & 01001101b = 00000001b
-10100011b & 01001110b = 00000010b
-10100011b & 01001111b = 00000011b
-10100011b & 01010000b = 00000000b
-10100011b & 01010001b = 00000001b
-10100011b & 01010010b = 00000010b
-10100011b & 01010011b = 00000011b
-10100011b & 01010100b = 00000000b
-10100011b & 01010101b = 00000001b
-10100011b & 01010110b = 00000010b
-10100011b & 01010111b = 00000011b
-10100011b & 01011000b = 00000000b
-10100011b & 01011001b = 00000001b
-10100011b & 01011010b = 00000010b
-10100011b & 01011011b = 00000011b
-10100011b & 01011100b = 00000000b
-10100011b & 01011101b = 00000001b
-10100011b & 01011110b = 00000010b
-10100011b & 01011111b = 00000011b
-10100011b & 01100000b = 00100000b
-10100011b & 01100001b = 00100001b
-10100011b & 01100010b = 00100010b
-10100011b & 01100011b = 00100011b
-10100011b & 01100100b = 00100000b
-10100011b & 01100101b = 00100001b
-10100011b & 01100110b = 00100010b
-10100011b & 01100111b = 00100011b
-10100011b & 01101000b = 00100000b
-10100011b & 01101001b = 00100001b
-10100011b & 01101010b = 00100010b
-10100011b & 01101011b = 00100011b
-10100011b & 01101100b = 00100000b
-10100011b & 01101101b = 00100001b
-10100011b & 01101110b = 00100010b
-10100011b & 01101111b = 00100011b
-10100011b & 01110000b = 00100000b
-10100011b & 01110001b = 00100001b
-10100011b & 01110010b = 00100010b
-10100011b & 01110011b = 00100011b
-10100011b & 01110100b = 00100000b
-10100011b & 01110101b = 00100001b
-10100011b & 01110110b = 00100010b
-10100011b & 01110111b = 00100011b
-10100011b & 01111000b = 00100000b
-10100011b & 01111001b = 00100001b
-10100011b & 01111010b = 00100010b
-10100011b & 01111011b = 00100011b
-10100011b & 01111100b = 00100000b
-10100011b & 01111101b = 00100001b
-10100011b & 01111110b = 00100010b
-10100100b & 10000000b = 10000000b
-10100100b & 10000001b = 10000000b
-10100100b & 10000010b = 10000000b
-10100100b & 10000011b = 10000000b
-10100100b & 10000100b = 10000100b
-10100100b & 10000101b = 10000100b
-10100100b & 10000110b = 10000100b
-10100100b & 10000111b = 10000100b
-10100100b & 10001000b = 10000000b
-10100100b & 10001001b = 10000000b
-10100100b & 10001010b = 10000000b
-10100100b & 10001011b = 10000000b
-10100100b & 10001100b = 10000100b
-10100100b & 10001101b = 10000100b
-10100100b & 10001110b = 10000100b
-10100100b & 10001111b = 10000100b
-10100100b & 10010000b = 10000000b
-10100100b & 10010001b = 10000000b
-10100100b & 10010010b = 10000000b
-10100100b & 10010011b = 10000000b
-10100100b & 10010100b = 10000100b
-10100100b & 10010101b = 10000100b
-10100100b & 10010110b = 10000100b
-10100100b & 10010111b = 10000100b
-10100100b & 10011000b = 10000000b
-10100100b & 10011001b = 10000000b
-10100100b & 10011010b = 10000000b
-10100100b & 10011011b = 10000000b
-10100100b & 10011100b = 10000100b
-10100100b & 10011101b = 10000100b
-10100100b & 10011110b = 10000100b
-10100100b & 10011111b = 10000100b
-10100100b & 10100000b = 10100000b
-10100100b & 10100001b = 10100000b
-10100100b & 10100010b = 10100000b
-10100100b & 10100011b = 10100000b
-10100100b & 10100100b = 10100100b
-10100100b & 10100101b = 10100100b
-10100100b & 10100110b = 10100100b
-10100100b & 10100111b = 10100100b
-10100100b & 10101000b = 10100000b
-10100100b & 10101001b = 10100000b
-10100100b & 10101010b = 10100000b
-10100100b & 10101011b = 10100000b
-10100100b & 10101100b = 10100100b
-10100100b & 10101101b = 10100100b
-10100100b & 10101110b = 10100100b
-10100100b & 10101111b = 10100100b
-10100100b & 10110000b = 10100000b
-10100100b & 10110001b = 10100000b
-10100100b & 10110010b = 10100000b
-10100100b & 10110011b = 10100000b
-10100100b & 10110100b = 10100100b
-10100100b & 10110101b = 10100100b
-10100100b & 10110110b = 10100100b
-10100100b & 10110111b = 10100100b
-10100100b & 10111000b = 10100000b
-10100100b & 10111001b = 10100000b
-10100100b & 10111010b = 10100000b
-10100100b & 10111011b = 10100000b
-10100100b & 10111100b = 10100100b
-10100100b & 10111101b = 10100100b
-10100100b & 10111110b = 10100100b
-10100100b & 10111111b = 10100100b
-10100100b & 11000000b = 10000000b
-10100100b & 11000001b = 10000000b
-10100100b & 11000010b = 10000000b
-10100100b & 11000011b = 10000000b
-10100100b & 11000100b = 10000100b
-10100100b & 11000101b = 10000100b
-10100100b & 11000110b = 10000100b
-10100100b & 11000111b = 10000100b
-10100100b & 11001000b = 10000000b
-10100100b & 11001001b = 10000000b
-10100100b & 11001010b = 10000000b
-10100100b & 11001011b = 10000000b
-10100100b & 11001100b = 10000100b
-10100100b & 11001101b = 10000100b
-10100100b & 11001110b = 10000100b
-10100100b & 11001111b = 10000100b
-10100100b & 11010000b = 10000000b
-10100100b & 11010001b = 10000000b
-10100100b & 11010010b = 10000000b
-10100100b & 11010011b = 10000000b
-10100100b & 11010100b = 10000100b
-10100100b & 11010101b = 10000100b
-10100100b & 11010110b = 10000100b
-10100100b & 11010111b = 10000100b
-10100100b & 11011000b = 10000000b
-10100100b & 11011001b = 10000000b
-10100100b & 11011010b = 10000000b
-10100100b & 11011011b = 10000000b
-10100100b & 11011100b = 10000100b
-10100100b & 11011101b = 10000100b
-10100100b & 11011110b = 10000100b
-10100100b & 11011111b = 10000100b
-10100100b & 11100000b = 10100000b
-10100100b & 11100001b = 10100000b
-10100100b & 11100010b = 10100000b
-10100100b & 11100011b = 10100000b
-10100100b & 11100100b = 10100100b
-10100100b & 11100101b = 10100100b
-10100100b & 11100110b = 10100100b
-10100100b & 11100111b = 10100100b
-10100100b & 11101000b = 10100000b
-10100100b & 11101001b = 10100000b
-10100100b & 11101010b = 10100000b
-10100100b & 11101011b = 10100000b
-10100100b & 11101100b = 10100100b
-10100100b & 11101101b = 10100100b
-10100100b & 11101110b = 10100100b
-10100100b & 11101111b = 10100100b
-10100100b & 11110000b = 10100000b
-10100100b & 11110001b = 10100000b
-10100100b & 11110010b = 10100000b
-10100100b & 11110011b = 10100000b
-10100100b & 11110100b = 10100100b
-10100100b & 11110101b = 10100100b
-10100100b & 11110110b = 10100100b
-10100100b & 11110111b = 10100100b
-10100100b & 11111000b = 10100000b
-10100100b & 11111001b = 10100000b
-10100100b & 11111010b = 10100000b
-10100100b & 11111011b = 10100000b
-10100100b & 11111100b = 10100100b
-10100100b & 11111101b = 10100100b
-10100100b & 11111110b = 10100100b
-10100100b & 11111111b = 10100100b
-10100100b & 00000000b = 00000000b
-10100100b & 00000001b = 00000000b
-10100100b & 00000010b = 00000000b
-10100100b & 00000011b = 00000000b
-10100100b & 00000100b = 00000100b
-10100100b & 00000101b = 00000100b
-10100100b & 00000110b = 00000100b
-10100100b & 00000111b = 00000100b
-10100100b & 00001000b = 00000000b
-10100100b & 00001001b = 00000000b
-10100100b & 00001010b = 00000000b
-10100100b & 00001011b = 00000000b
-10100100b & 00001100b = 00000100b
-10100100b & 00001101b = 00000100b
-10100100b & 00001110b = 00000100b
-10100100b & 00001111b = 00000100b
-10100100b & 00010000b = 00000000b
-10100100b & 00010001b = 00000000b
-10100100b & 00010010b = 00000000b
-10100100b & 00010011b = 00000000b
-10100100b & 00010100b = 00000100b
-10100100b & 00010101b = 00000100b
-10100100b & 00010110b = 00000100b
-10100100b & 00010111b = 00000100b
-10100100b & 00011000b = 00000000b
-10100100b & 00011001b = 00000000b
-10100100b & 00011010b = 00000000b
-10100100b & 00011011b = 00000000b
-10100100b & 00011100b = 00000100b
-10100100b & 00011101b = 00000100b
-10100100b & 00011110b = 00000100b
-10100100b & 00011111b = 00000100b
-10100100b & 00100000b = 00100000b
-10100100b & 00100001b = 00100000b
-10100100b & 00100010b = 00100000b
-10100100b & 00100011b = 00100000b
-10100100b & 00100100b = 00100100b
-10100100b & 00100101b = 00100100b
-10100100b & 00100110b = 00100100b
-10100100b & 00100111b = 00100100b
-10100100b & 00101000b = 00100000b
-10100100b & 00101001b = 00100000b
-10100100b & 00101010b = 00100000b
-10100100b & 00101011b = 00100000b
-10100100b & 00101100b = 00100100b
-10100100b & 00101101b = 00100100b
-10100100b & 00101110b = 00100100b
-10100100b & 00101111b = 00100100b
-10100100b & 00110000b = 00100000b
-10100100b & 00110001b = 00100000b
-10100100b & 00110010b = 00100000b
-10100100b & 00110011b = 00100000b
-10100100b & 00110100b = 00100100b
-10100100b & 00110101b = 00100100b
-10100100b & 00110110b = 00100100b
-10100100b & 00110111b = 00100100b
-10100100b & 00111000b = 00100000b
-10100100b & 00111001b = 00100000b
-10100100b & 00111010b = 00100000b
-10100100b & 00111011b = 00100000b
-10100100b & 00111100b = 00100100b
-10100100b & 00111101b = 00100100b
-10100100b & 00111110b = 00100100b
-10100100b & 00111111b = 00100100b
-10100100b & 01000000b = 00000000b
-10100100b & 01000001b = 00000000b
-10100100b & 01000010b = 00000000b
-10100100b & 01000011b = 00000000b
-10100100b & 01000100b = 00000100b
-10100100b & 01000101b = 00000100b
-10100100b & 01000110b = 00000100b
-10100100b & 01000111b = 00000100b
-10100100b & 01001000b = 00000000b
-10100100b & 01001001b = 00000000b
-10100100b & 01001010b = 00000000b
-10100100b & 01001011b = 00000000b
-10100100b & 01001100b = 00000100b
-10100100b & 01001101b = 00000100b
-10100100b & 01001110b = 00000100b
-10100100b & 01001111b = 00000100b
-10100100b & 01010000b = 00000000b
-10100100b & 01010001b = 00000000b
-10100100b & 01010010b = 00000000b
-10100100b & 01010011b = 00000000b
-10100100b & 01010100b = 00000100b
-10100100b & 01010101b = 00000100b
-10100100b & 01010110b = 00000100b
-10100100b & 01010111b = 00000100b
-10100100b & 01011000b = 00000000b
-10100100b & 01011001b = 00000000b
-10100100b & 01011010b = 00000000b
-10100100b & 01011011b = 00000000b
-10100100b & 01011100b = 00000100b
-10100100b & 01011101b = 00000100b
-10100100b & 01011110b = 00000100b
-10100100b & 01011111b = 00000100b
-10100100b & 01100000b = 00100000b
-10100100b & 01100001b = 00100000b
-10100100b & 01100010b = 00100000b
-10100100b & 01100011b = 00100000b
-10100100b & 01100100b = 00100100b
-10100100b & 01100101b = 00100100b
-10100100b & 01100110b = 00100100b
-10100100b & 01100111b = 00100100b
-10100100b & 01101000b = 00100000b
-10100100b & 01101001b = 00100000b
-10100100b & 01101010b = 00100000b
-10100100b & 01101011b = 00100000b
-10100100b & 01101100b = 00100100b
-10100100b & 01101101b = 00100100b
-10100100b & 01101110b = 00100100b
-10100100b & 01101111b = 00100100b
-10100100b & 01110000b = 00100000b
-10100100b & 01110001b = 00100000b
-10100100b & 01110010b = 00100000b
-10100100b & 01110011b = 00100000b
-10100100b & 01110100b = 00100100b
-10100100b & 01110101b = 00100100b
-10100100b & 01110110b = 00100100b
-10100100b & 01110111b = 00100100b
-10100100b & 01111000b = 00100000b
-10100100b & 01111001b = 00100000b
-10100100b & 01111010b = 00100000b
-10100100b & 01111011b = 00100000b
-10100100b & 01111100b = 00100100b
-10100100b & 01111101b = 00100100b
-10100100b & 01111110b = 00100100b
-10100101b & 10000000b = 10000000b
-10100101b & 10000001b = 10000001b
-10100101b & 10000010b = 10000000b
-10100101b & 10000011b = 10000001b
-10100101b & 10000100b = 10000100b
-10100101b & 10000101b = 10000101b
-10100101b & 10000110b = 10000100b
-10100101b & 10000111b = 10000101b
-10100101b & 10001000b = 10000000b
-10100101b & 10001001b = 10000001b
-10100101b & 10001010b = 10000000b
-10100101b & 10001011b = 10000001b
-10100101b & 10001100b = 10000100b
-10100101b & 10001101b = 10000101b
-10100101b & 10001110b = 10000100b
-10100101b & 10001111b = 10000101b
-10100101b & 10010000b = 10000000b
-10100101b & 10010001b = 10000001b
-10100101b & 10010010b = 10000000b
-10100101b & 10010011b = 10000001b
-10100101b & 10010100b = 10000100b
-10100101b & 10010101b = 10000101b
-10100101b & 10010110b = 10000100b
-10100101b & 10010111b = 10000101b
-10100101b & 10011000b = 10000000b
-10100101b & 10011001b = 10000001b
-10100101b & 10011010b = 10000000b
-10100101b & 10011011b = 10000001b
-10100101b & 10011100b = 10000100b
-10100101b & 10011101b = 10000101b
-10100101b & 10011110b = 10000100b
-10100101b & 10011111b = 10000101b
-10100101b & 10100000b = 10100000b
-10100101b & 10100001b = 10100001b
-10100101b & 10100010b = 10100000b
-10100101b & 10100011b = 10100001b
-10100101b & 10100100b = 10100100b
-10100101b & 10100101b = 10100101b
-10100101b & 10100110b = 10100100b
-10100101b & 10100111b = 10100101b
-10100101b & 10101000b = 10100000b
-10100101b & 10101001b = 10100001b
-10100101b & 10101010b = 10100000b
-10100101b & 10101011b = 10100001b
-10100101b & 10101100b = 10100100b
-10100101b & 10101101b = 10100101b
-10100101b & 10101110b = 10100100b
-10100101b & 10101111b = 10100101b
-10100101b & 10110000b = 10100000b
-10100101b & 10110001b = 10100001b
-10100101b & 10110010b = 10100000b
-10100101b & 10110011b = 10100001b
-10100101b & 10110100b = 10100100b
-10100101b & 10110101b = 10100101b
-10100101b & 10110110b = 10100100b
-10100101b & 10110111b = 10100101b
-10100101b & 10111000b = 10100000b
-10100101b & 10111001b = 10100001b
-10100101b & 10111010b = 10100000b
-10100101b & 10111011b = 10100001b
-10100101b & 10111100b = 10100100b
-10100101b & 10111101b = 10100101b
-10100101b & 10111110b = 10100100b
-10100101b & 10111111b = 10100101b
-10100101b & 11000000b = 10000000b
-10100101b & 11000001b = 10000001b
-10100101b & 11000010b = 10000000b
-10100101b & 11000011b = 10000001b
-10100101b & 11000100b = 10000100b
-10100101b & 11000101b = 10000101b
-10100101b & 11000110b = 10000100b
-10100101b & 11000111b = 10000101b
-10100101b & 11001000b = 10000000b
-10100101b & 11001001b = 10000001b
-10100101b & 11001010b = 10000000b
-10100101b & 11001011b = 10000001b
-10100101b & 11001100b = 10000100b
-10100101b & 11001101b = 10000101b
-10100101b & 11001110b = 10000100b
-10100101b & 11001111b = 10000101b
-10100101b & 11010000b = 10000000b
-10100101b & 11010001b = 10000001b
-10100101b & 11010010b = 10000000b
-10100101b & 11010011b = 10000001b
-10100101b & 11010100b = 10000100b
-10100101b & 11010101b = 10000101b
-10100101b & 11010110b = 10000100b
-10100101b & 11010111b = 10000101b
-10100101b & 11011000b = 10000000b
-10100101b & 11011001b = 10000001b
-10100101b & 11011010b = 10000000b
-10100101b & 11011011b = 10000001b
-10100101b & 11011100b = 10000100b
-10100101b & 11011101b = 10000101b
-10100101b & 11011110b = 10000100b
-10100101b & 11011111b = 10000101b
-10100101b & 11100000b = 10100000b
-10100101b & 11100001b = 10100001b
-10100101b & 11100010b = 10100000b
-10100101b & 11100011b = 10100001b
-10100101b & 11100100b = 10100100b
-10100101b & 11100101b = 10100101b
-10100101b & 11100110b = 10100100b
-10100101b & 11100111b = 10100101b
-10100101b & 11101000b = 10100000b
-10100101b & 11101001b = 10100001b
-10100101b & 11101010b = 10100000b
-10100101b & 11101011b = 10100001b
-10100101b & 11101100b = 10100100b
-10100101b & 11101101b = 10100101b
-10100101b & 11101110b = 10100100b
-10100101b & 11101111b = 10100101b
-10100101b & 11110000b = 10100000b
-10100101b & 11110001b = 10100001b
-10100101b & 11110010b = 10100000b
-10100101b & 11110011b = 10100001b
-10100101b & 11110100b = 10100100b
-10100101b & 11110101b = 10100101b
-10100101b & 11110110b = 10100100b
-10100101b & 11110111b = 10100101b
-10100101b & 11111000b = 10100000b
-10100101b & 11111001b = 10100001b
-10100101b & 11111010b = 10100000b
-10100101b & 11111011b = 10100001b
-10100101b & 11111100b = 10100100b
-10100101b & 11111101b = 10100101b
-10100101b & 11111110b = 10100100b
-10100101b & 11111111b = 10100101b
-10100101b & 00000000b = 00000000b
-10100101b & 00000001b = 00000001b
-10100101b & 00000010b = 00000000b
-10100101b & 00000011b = 00000001b
-10100101b & 00000100b = 00000100b
-10100101b & 00000101b = 00000101b
-10100101b & 00000110b = 00000100b
-10100101b & 00000111b = 00000101b
-10100101b & 00001000b = 00000000b
-10100101b & 00001001b = 00000001b
-10100101b & 00001010b = 00000000b
-10100101b & 00001011b = 00000001b
-10100101b & 00001100b = 00000100b
-10100101b & 00001101b = 00000101b
-10100101b & 00001110b = 00000100b
-10100101b & 00001111b = 00000101b
-10100101b & 00010000b = 00000000b
-10100101b & 00010001b = 00000001b
-10100101b & 00010010b = 00000000b
-10100101b & 00010011b = 00000001b
-10100101b & 00010100b = 00000100b
-10100101b & 00010101b = 00000101b
-10100101b & 00010110b = 00000100b
-10100101b & 00010111b = 00000101b
-10100101b & 00011000b = 00000000b
-10100101b & 00011001b = 00000001b
-10100101b & 00011010b = 00000000b
-10100101b & 00011011b = 00000001b
-10100101b & 00011100b = 00000100b
-10100101b & 00011101b = 00000101b
-10100101b & 00011110b = 00000100b
-10100101b & 00011111b = 00000101b
-10100101b & 00100000b = 00100000b
-10100101b & 00100001b = 00100001b
-10100101b & 00100010b = 00100000b
-10100101b & 00100011b = 00100001b
-10100101b & 00100100b = 00100100b
-10100101b & 00100101b = 00100101b
-10100101b & 00100110b = 00100100b
-10100101b & 00100111b = 00100101b
-10100101b & 00101000b = 00100000b
-10100101b & 00101001b = 00100001b
-10100101b & 00101010b = 00100000b
-10100101b & 00101011b = 00100001b
-10100101b & 00101100b = 00100100b
-10100101b & 00101101b = 00100101b
-10100101b & 00101110b = 00100100b
-10100101b & 00101111b = 00100101b
-10100101b & 00110000b = 00100000b
-10100101b & 00110001b = 00100001b
-10100101b & 00110010b = 00100000b
-10100101b & 00110011b = 00100001b
-10100101b & 00110100b = 00100100b
-10100101b & 00110101b = 00100101b
-10100101b & 00110110b = 00100100b
-10100101b & 00110111b = 00100101b
-10100101b & 00111000b = 00100000b
-10100101b & 00111001b = 00100001b
-10100101b & 00111010b = 00100000b
-10100101b & 00111011b = 00100001b
-10100101b & 00111100b = 00100100b
-10100101b & 00111101b = 00100101b
-10100101b & 00111110b = 00100100b
-10100101b & 00111111b = 00100101b
-10100101b & 01000000b = 00000000b
-10100101b & 01000001b = 00000001b
-10100101b & 01000010b = 00000000b
-10100101b & 01000011b = 00000001b
-10100101b & 01000100b = 00000100b
-10100101b & 01000101b = 00000101b
-10100101b & 01000110b = 00000100b
-10100101b & 01000111b = 00000101b
-10100101b & 01001000b = 00000000b
-10100101b & 01001001b = 00000001b
-10100101b & 01001010b = 00000000b
-10100101b & 01001011b = 00000001b
-10100101b & 01001100b = 00000100b
-10100101b & 01001101b = 00000101b
-10100101b & 01001110b = 00000100b
-10100101b & 01001111b = 00000101b
-10100101b & 01010000b = 00000000b
-10100101b & 01010001b = 00000001b
-10100101b & 01010010b = 00000000b
-10100101b & 01010011b = 00000001b
-10100101b & 01010100b = 00000100b
-10100101b & 01010101b = 00000101b
-10100101b & 01010110b = 00000100b
-10100101b & 01010111b = 00000101b
-10100101b & 01011000b = 00000000b
-10100101b & 01011001b = 00000001b
-10100101b & 01011010b = 00000000b
-10100101b & 01011011b = 00000001b
-10100101b & 01011100b = 00000100b
-10100101b & 01011101b = 00000101b
-10100101b & 01011110b = 00000100b
-10100101b & 01011111b = 00000101b
-10100101b & 01100000b = 00100000b
-10100101b & 01100001b = 00100001b
-10100101b & 01100010b = 00100000b
-10100101b & 01100011b = 00100001b
-10100101b & 01100100b = 00100100b
-10100101b & 01100101b = 00100101b
-10100101b & 01100110b = 00100100b
-10100101b & 01100111b = 00100101b
-10100101b & 01101000b = 00100000b
-10100101b & 01101001b = 00100001b
-10100101b & 01101010b = 00100000b
-10100101b & 01101011b = 00100001b
-10100101b & 01101100b = 00100100b
-10100101b & 01101101b = 00100101b
-10100101b & 01101110b = 00100100b
-10100101b & 01101111b = 00100101b
-10100101b & 01110000b = 00100000b
-10100101b & 01110001b = 00100001b
-10100101b & 01110010b = 00100000b
-10100101b & 01110011b = 00100001b
-10100101b & 01110100b = 00100100b
-10100101b & 01110101b = 00100101b
-10100101b & 01110110b = 00100100b
-10100101b & 01110111b = 00100101b
-10100101b & 01111000b = 00100000b
-10100101b & 01111001b = 00100001b
-10100101b & 01111010b = 00100000b
-10100101b & 01111011b = 00100001b
-10100101b & 01111100b = 00100100b
-10100101b & 01111101b = 00100101b
-10100101b & 01111110b = 00100100b
-10100110b & 10000000b = 10000000b
-10100110b & 10000001b = 10000000b
-10100110b & 10000010b = 10000010b
-10100110b & 10000011b = 10000010b
-10100110b & 10000100b = 10000100b
-10100110b & 10000101b = 10000100b
-10100110b & 10000110b = 10000110b
-10100110b & 10000111b = 10000110b
-10100110b & 10001000b = 10000000b
-10100110b & 10001001b = 10000000b
-10100110b & 10001010b = 10000010b
-10100110b & 10001011b = 10000010b
-10100110b & 10001100b = 10000100b
-10100110b & 10001101b = 10000100b
-10100110b & 10001110b = 10000110b
-10100110b & 10001111b = 10000110b
-10100110b & 10010000b = 10000000b
-10100110b & 10010001b = 10000000b
-10100110b & 10010010b = 10000010b
-10100110b & 10010011b = 10000010b
-10100110b & 10010100b = 10000100b
-10100110b & 10010101b = 10000100b
-10100110b & 10010110b = 10000110b
-10100110b & 10010111b = 10000110b
-10100110b & 10011000b = 10000000b
-10100110b & 10011001b = 10000000b
-10100110b & 10011010b = 10000010b
-10100110b & 10011011b = 10000010b
-10100110b & 10011100b = 10000100b
-10100110b & 10011101b = 10000100b
-10100110b & 10011110b = 10000110b
-10100110b & 10011111b = 10000110b
-10100110b & 10100000b = 10100000b
-10100110b & 10100001b = 10100000b
-10100110b & 10100010b = 10100010b
-10100110b & 10100011b = 10100010b
-10100110b & 10100100b = 10100100b
-10100110b & 10100101b = 10100100b
-10100110b & 10100110b = 10100110b
-10100110b & 10100111b = 10100110b
-10100110b & 10101000b = 10100000b
-10100110b & 10101001b = 10100000b
-10100110b & 10101010b = 10100010b
-10100110b & 10101011b = 10100010b
-10100110b & 10101100b = 10100100b
-10100110b & 10101101b = 10100100b
-10100110b & 10101110b = 10100110b
-10100110b & 10101111b = 10100110b
-10100110b & 10110000b = 10100000b
-10100110b & 10110001b = 10100000b
-10100110b & 10110010b = 10100010b
-10100110b & 10110011b = 10100010b
-10100110b & 10110100b = 10100100b
-10100110b & 10110101b = 10100100b
-10100110b & 10110110b = 10100110b
-10100110b & 10110111b = 10100110b
-10100110b & 10111000b = 10100000b
-10100110b & 10111001b = 10100000b
-10100110b & 10111010b = 10100010b
-10100110b & 10111011b = 10100010b
-10100110b & 10111100b = 10100100b
-10100110b & 10111101b = 10100100b
-10100110b & 10111110b = 10100110b
-10100110b & 10111111b = 10100110b
-10100110b & 11000000b = 10000000b
-10100110b & 11000001b = 10000000b
-10100110b & 11000010b = 10000010b
-10100110b & 11000011b = 10000010b
-10100110b & 11000100b = 10000100b
-10100110b & 11000101b = 10000100b
-10100110b & 11000110b = 10000110b
-10100110b & 11000111b = 10000110b
-10100110b & 11001000b = 10000000b
-10100110b & 11001001b = 10000000b
-10100110b & 11001010b = 10000010b
-10100110b & 11001011b = 10000010b
-10100110b & 11001100b = 10000100b
-10100110b & 11001101b = 10000100b
-10100110b & 11001110b = 10000110b
-10100110b & 11001111b = 10000110b
-10100110b & 11010000b = 10000000b
-10100110b & 11010001b = 10000000b
-10100110b & 11010010b = 10000010b
-10100110b & 11010011b = 10000010b
-10100110b & 11010100b = 10000100b
-10100110b & 11010101b = 10000100b
-10100110b & 11010110b = 10000110b
-10100110b & 11010111b = 10000110b
-10100110b & 11011000b = 10000000b
-10100110b & 11011001b = 10000000b
-10100110b & 11011010b = 10000010b
-10100110b & 11011011b = 10000010b
-10100110b & 11011100b = 10000100b
-10100110b & 11011101b = 10000100b
-10100110b & 11011110b = 10000110b
-10100110b & 11011111b = 10000110b
-10100110b & 11100000b = 10100000b
-10100110b & 11100001b = 10100000b
-10100110b & 11100010b = 10100010b
-10100110b & 11100011b = 10100010b
-10100110b & 11100100b = 10100100b
-10100110b & 11100101b = 10100100b
-10100110b & 11100110b = 10100110b
-10100110b & 11100111b = 10100110b
-10100110b & 11101000b = 10100000b
-10100110b & 11101001b = 10100000b
-10100110b & 11101010b = 10100010b
-10100110b & 11101011b = 10100010b
-10100110b & 11101100b = 10100100b
-10100110b & 11101101b = 10100100b
-10100110b & 11101110b = 10100110b
-10100110b & 11101111b = 10100110b
-10100110b & 11110000b = 10100000b
-10100110b & 11110001b = 10100000b
-10100110b & 11110010b = 10100010b
-10100110b & 11110011b = 10100010b
-10100110b & 11110100b = 10100100b
-10100110b & 11110101b = 10100100b
-10100110b & 11110110b = 10100110b
-10100110b & 11110111b = 10100110b
-10100110b & 11111000b = 10100000b
-10100110b & 11111001b = 10100000b
-10100110b & 11111010b = 10100010b
-10100110b & 11111011b = 10100010b
-10100110b & 11111100b = 10100100b
-10100110b & 11111101b = 10100100b
-10100110b & 11111110b = 10100110b
-10100110b & 11111111b = 10100110b
-10100110b & 00000000b = 00000000b
-10100110b & 00000001b = 00000000b
-10100110b & 00000010b = 00000010b
-10100110b & 00000011b = 00000010b
-10100110b & 00000100b = 00000100b
-10100110b & 00000101b = 00000100b
-10100110b & 00000110b = 00000110b
-10100110b & 00000111b = 00000110b
-10100110b & 00001000b = 00000000b
-10100110b & 00001001b = 00000000b
-10100110b & 00001010b = 00000010b
-10100110b & 00001011b = 00000010b
-10100110b & 00001100b = 00000100b
-10100110b & 00001101b = 00000100b
-10100110b & 00001110b = 00000110b
-10100110b & 00001111b = 00000110b
-10100110b & 00010000b = 00000000b
-10100110b & 00010001b = 00000000b
-10100110b & 00010010b = 00000010b
-10100110b & 00010011b = 00000010b
-10100110b & 00010100b = 00000100b
-10100110b & 00010101b = 00000100b
-10100110b & 00010110b = 00000110b
-10100110b & 00010111b = 00000110b
-10100110b & 00011000b = 00000000b
-10100110b & 00011001b = 00000000b
-10100110b & 00011010b = 00000010b
-10100110b & 00011011b = 00000010b
-10100110b & 00011100b = 00000100b
-10100110b & 00011101b = 00000100b
-10100110b & 00011110b = 00000110b
-10100110b & 00011111b = 00000110b
-10100110b & 00100000b = 00100000b
-10100110b & 00100001b = 00100000b
-10100110b & 00100010b = 00100010b
-10100110b & 00100011b = 00100010b
-10100110b & 00100100b = 00100100b
-10100110b & 00100101b = 00100100b
-10100110b & 00100110b = 00100110b
-10100110b & 00100111b = 00100110b
-10100110b & 00101000b = 00100000b
-10100110b & 00101001b = 00100000b
-10100110b & 00101010b = 00100010b
-10100110b & 00101011b = 00100010b
-10100110b & 00101100b = 00100100b
-10100110b & 00101101b = 00100100b
-10100110b & 00101110b = 00100110b
-10100110b & 00101111b = 00100110b
-10100110b & 00110000b = 00100000b
-10100110b & 00110001b = 00100000b
-10100110b & 00110010b = 00100010b
-10100110b & 00110011b = 00100010b
-10100110b & 00110100b = 00100100b
-10100110b & 00110101b = 00100100b
-10100110b & 00110110b = 00100110b
-10100110b & 00110111b = 00100110b
-10100110b & 00111000b = 00100000b
-10100110b & 00111001b = 00100000b
-10100110b & 00111010b = 00100010b
-10100110b & 00111011b = 00100010b
-10100110b & 00111100b = 00100100b
-10100110b & 00111101b = 00100100b
-10100110b & 00111110b = 00100110b
-10100110b & 00111111b = 00100110b
-10100110b & 01000000b = 00000000b
-10100110b & 01000001b = 00000000b
-10100110b & 01000010b = 00000010b
-10100110b & 01000011b = 00000010b
-10100110b & 01000100b = 00000100b
-10100110b & 01000101b = 00000100b
-10100110b & 01000110b = 00000110b
-10100110b & 01000111b = 00000110b
-10100110b & 01001000b = 00000000b
-10100110b & 01001001b = 00000000b
-10100110b & 01001010b = 00000010b
-10100110b & 01001011b = 00000010b
-10100110b & 01001100b = 00000100b
-10100110b & 01001101b = 00000100b
-10100110b & 01001110b = 00000110b
-10100110b & 01001111b = 00000110b
-10100110b & 01010000b = 00000000b
-10100110b & 01010001b = 00000000b
-10100110b & 01010010b = 00000010b
-10100110b & 01010011b = 00000010b
-10100110b & 01010100b = 00000100b
-10100110b & 01010101b = 00000100b
-10100110b & 01010110b = 00000110b
-10100110b & 01010111b = 00000110b
-10100110b & 01011000b = 00000000b
-10100110b & 01011001b = 00000000b
-10100110b & 01011010b = 00000010b
-10100110b & 01011011b = 00000010b
-10100110b & 01011100b = 00000100b
-10100110b & 01011101b = 00000100b
-10100110b & 01011110b = 00000110b
-10100110b & 01011111b = 00000110b
-10100110b & 01100000b = 00100000b
-10100110b & 01100001b = 00100000b
-10100110b & 01100010b = 00100010b
-10100110b & 01100011b = 00100010b
-10100110b & 01100100b = 00100100b
-10100110b & 01100101b = 00100100b
-10100110b & 01100110b = 00100110b
-10100110b & 01100111b = 00100110b
-10100110b & 01101000b = 00100000b
-10100110b & 01101001b = 00100000b
-10100110b & 01101010b = 00100010b
-10100110b & 01101011b = 00100010b
-10100110b & 01101100b = 00100100b
-10100110b & 01101101b = 00100100b
-10100110b & 01101110b = 00100110b
-10100110b & 01101111b = 00100110b
-10100110b & 01110000b = 00100000b
-10100110b & 01110001b = 00100000b
-10100110b & 01110010b = 00100010b
-10100110b & 01110011b = 00100010b
-10100110b & 01110100b = 00100100b
-10100110b & 01110101b = 00100100b
-10100110b & 01110110b = 00100110b
-10100110b & 01110111b = 00100110b
-10100110b & 01111000b = 00100000b
-10100110b & 01111001b = 00100000b
-10100110b & 01111010b = 00100010b
-10100110b & 01111011b = 00100010b
-10100110b & 01111100b = 00100100b
-10100110b & 01111101b = 00100100b
-10100110b & 01111110b = 00100110b
-10100111b & 10000000b = 10000000b
-10100111b & 10000001b = 10000001b
-10100111b & 10000010b = 10000010b
-10100111b & 10000011b = 10000011b
-10100111b & 10000100b = 10000100b
-10100111b & 10000101b = 10000101b
-10100111b & 10000110b = 10000110b
-10100111b & 10000111b = 10000111b
-10100111b & 10001000b = 10000000b
-10100111b & 10001001b = 10000001b
-10100111b & 10001010b = 10000010b
-10100111b & 10001011b = 10000011b
-10100111b & 10001100b = 10000100b
-10100111b & 10001101b = 10000101b
-10100111b & 10001110b = 10000110b
-10100111b & 10001111b = 10000111b
-10100111b & 10010000b = 10000000b
-10100111b & 10010001b = 10000001b
-10100111b & 10010010b = 10000010b
-10100111b & 10010011b = 10000011b
-10100111b & 10010100b = 10000100b
-10100111b & 10010101b = 10000101b
-10100111b & 10010110b = 10000110b
-10100111b & 10010111b = 10000111b
-10100111b & 10011000b = 10000000b
-10100111b & 10011001b = 10000001b
-10100111b & 10011010b = 10000010b
-10100111b & 10011011b = 10000011b
-10100111b & 10011100b = 10000100b
-10100111b & 10011101b = 10000101b
-10100111b & 10011110b = 10000110b
-10100111b & 10011111b = 10000111b
-10100111b & 10100000b = 10100000b
-10100111b & 10100001b = 10100001b
-10100111b & 10100010b = 10100010b
-10100111b & 10100011b = 10100011b
-10100111b & 10100100b = 10100100b
-10100111b & 10100101b = 10100101b
-10100111b & 10100110b = 10100110b
-10100111b & 10100111b = 10100111b
-10100111b & 10101000b = 10100000b
-10100111b & 10101001b = 10100001b
-10100111b & 10101010b = 10100010b
-10100111b & 10101011b = 10100011b
-10100111b & 10101100b = 10100100b
-10100111b & 10101101b = 10100101b
-10100111b & 10101110b = 10100110b
-10100111b & 10101111b = 10100111b
-10100111b & 10110000b = 10100000b
-10100111b & 10110001b = 10100001b
-10100111b & 10110010b = 10100010b
-10100111b & 10110011b = 10100011b
-10100111b & 10110100b = 10100100b
-10100111b & 10110101b = 10100101b
-10100111b & 10110110b = 10100110b
-10100111b & 10110111b = 10100111b
-10100111b & 10111000b = 10100000b
-10100111b & 10111001b = 10100001b
-10100111b & 10111010b = 10100010b
-10100111b & 10111011b = 10100011b
-10100111b & 10111100b = 10100100b
-10100111b & 10111101b = 10100101b
-10100111b & 10111110b = 10100110b
-10100111b & 10111111b = 10100111b
-10100111b & 11000000b = 10000000b
-10100111b & 11000001b = 10000001b
-10100111b & 11000010b = 10000010b
-10100111b & 11000011b = 10000011b
-10100111b & 11000100b = 10000100b
-10100111b & 11000101b = 10000101b
-10100111b & 11000110b = 10000110b
-10100111b & 11000111b = 10000111b
-10100111b & 11001000b = 10000000b
-10100111b & 11001001b = 10000001b
-10100111b & 11001010b = 10000010b
-10100111b & 11001011b = 10000011b
-10100111b & 11001100b = 10000100b
-10100111b & 11001101b = 10000101b
-10100111b & 11001110b = 10000110b
-10100111b & 11001111b = 10000111b
-10100111b & 11010000b = 10000000b
-10100111b & 11010001b = 10000001b
-10100111b & 11010010b = 10000010b
-10100111b & 11010011b = 10000011b
-10100111b & 11010100b = 10000100b
-10100111b & 11010101b = 10000101b
-10100111b & 11010110b = 10000110b
-10100111b & 11010111b = 10000111b
-10100111b & 11011000b = 10000000b
-10100111b & 11011001b = 10000001b
-10100111b & 11011010b = 10000010b
-10100111b & 11011011b = 10000011b
-10100111b & 11011100b = 10000100b
-10100111b & 11011101b = 10000101b
-10100111b & 11011110b = 10000110b
-10100111b & 11011111b = 10000111b
-10100111b & 11100000b = 10100000b
-10100111b & 11100001b = 10100001b
-10100111b & 11100010b = 10100010b
-10100111b & 11100011b = 10100011b
-10100111b & 11100100b = 10100100b
-10100111b & 11100101b = 10100101b
-10100111b & 11100110b = 10100110b
-10100111b & 11100111b = 10100111b
-10100111b & 11101000b = 10100000b
-10100111b & 11101001b = 10100001b
-10100111b & 11101010b = 10100010b
-10100111b & 11101011b = 10100011b
-10100111b & 11101100b = 10100100b
-10100111b & 11101101b = 10100101b
-10100111b & 11101110b = 10100110b
-10100111b & 11101111b = 10100111b
-10100111b & 11110000b = 10100000b
-10100111b & 11110001b = 10100001b
-10100111b & 11110010b = 10100010b
-10100111b & 11110011b = 10100011b
-10100111b & 11110100b = 10100100b
-10100111b & 11110101b = 10100101b
-10100111b & 11110110b = 10100110b
-10100111b & 11110111b = 10100111b
-10100111b & 11111000b = 10100000b
-10100111b & 11111001b = 10100001b
-10100111b & 11111010b = 10100010b
-10100111b & 11111011b = 10100011b
-10100111b & 11111100b = 10100100b
-10100111b & 11111101b = 10100101b
-10100111b & 11111110b = 10100110b
-10100111b & 11111111b = 10100111b
-10100111b & 00000000b = 00000000b
-10100111b & 00000001b = 00000001b
-10100111b & 00000010b = 00000010b
-10100111b & 00000011b = 00000011b
-10100111b & 00000100b = 00000100b
-10100111b & 00000101b = 00000101b
-10100111b & 00000110b = 00000110b
-10100111b & 00000111b = 00000111b
-10100111b & 00001000b = 00000000b
-10100111b & 00001001b = 00000001b
-10100111b & 00001010b = 00000010b
-10100111b & 00001011b = 00000011b
-10100111b & 00001100b = 00000100b
-10100111b & 00001101b = 00000101b
-10100111b & 00001110b = 00000110b
-10100111b & 00001111b = 00000111b
-10100111b & 00010000b = 00000000b
-10100111b & 00010001b = 00000001b
-10100111b & 00010010b = 00000010b
-10100111b & 00010011b = 00000011b
-10100111b & 00010100b = 00000100b
-10100111b & 00010101b = 00000101b
-10100111b & 00010110b = 00000110b
-10100111b & 00010111b = 00000111b
-10100111b & 00011000b = 00000000b
-10100111b & 00011001b = 00000001b
-10100111b & 00011010b = 00000010b
-10100111b & 00011011b = 00000011b
-10100111b & 00011100b = 00000100b
-10100111b & 00011101b = 00000101b
-10100111b & 00011110b = 00000110b
-10100111b & 00011111b = 00000111b
-10100111b & 00100000b = 00100000b
-10100111b & 00100001b = 00100001b
-10100111b & 00100010b = 00100010b
-10100111b & 00100011b = 00100011b
-10100111b & 00100100b = 00100100b
-10100111b & 00100101b = 00100101b
-10100111b & 00100110b = 00100110b
-10100111b & 00100111b = 00100111b
-10100111b & 00101000b = 00100000b
-10100111b & 00101001b = 00100001b
-10100111b & 00101010b = 00100010b
-10100111b & 00101011b = 00100011b
-10100111b & 00101100b = 00100100b
-10100111b & 00101101b = 00100101b
-10100111b & 00101110b = 00100110b
-10100111b & 00101111b = 00100111b
-10100111b & 00110000b = 00100000b
-10100111b & 00110001b = 00100001b
-10100111b & 00110010b = 00100010b
-10100111b & 00110011b = 00100011b
-10100111b & 00110100b = 00100100b
-10100111b & 00110101b = 00100101b
-10100111b & 00110110b = 00100110b
-10100111b & 00110111b = 00100111b
-10100111b & 00111000b = 00100000b
-10100111b & 00111001b = 00100001b
-10100111b & 00111010b = 00100010b
-10100111b & 00111011b = 00100011b
-10100111b & 00111100b = 00100100b
-10100111b & 00111101b = 00100101b
-10100111b & 00111110b = 00100110b
-10100111b & 00111111b = 00100111b
-10100111b & 01000000b = 00000000b
-10100111b & 01000001b = 00000001b
-10100111b & 01000010b = 00000010b
-10100111b & 01000011b = 00000011b
-10100111b & 01000100b = 00000100b
-10100111b & 01000101b = 00000101b
-10100111b & 01000110b = 00000110b
-10100111b & 01000111b = 00000111b
-10100111b & 01001000b = 00000000b
-10100111b & 01001001b = 00000001b
-10100111b & 01001010b = 00000010b
-10100111b & 01001011b = 00000011b
-10100111b & 01001100b = 00000100b
-10100111b & 01001101b = 00000101b
-10100111b & 01001110b = 00000110b
-10100111b & 01001111b = 00000111b
-10100111b & 01010000b = 00000000b
-10100111b & 01010001b = 00000001b
-10100111b & 01010010b = 00000010b
-10100111b & 01010011b = 00000011b
-10100111b & 01010100b = 00000100b
-10100111b & 01010101b = 00000101b
-10100111b & 01010110b = 00000110b
-10100111b & 01010111b = 00000111b
-10100111b & 01011000b = 00000000b
-10100111b & 01011001b = 00000001b
-10100111b & 01011010b = 00000010b
-10100111b & 01011011b = 00000011b
-10100111b & 01011100b = 00000100b
-10100111b & 01011101b = 00000101b
-10100111b & 01011110b = 00000110b
-10100111b & 01011111b = 00000111b
-10100111b & 01100000b = 00100000b
-10100111b & 01100001b = 00100001b
-10100111b & 01100010b = 00100010b
-10100111b & 01100011b = 00100011b
-10100111b & 01100100b = 00100100b
-10100111b & 01100101b = 00100101b
-10100111b & 01100110b = 00100110b
-10100111b & 01100111b = 00100111b
-10100111b & 01101000b = 00100000b
-10100111b & 01101001b = 00100001b
-10100111b & 01101010b = 00100010b
-10100111b & 01101011b = 00100011b
-10100111b & 01101100b = 00100100b
-10100111b & 01101101b = 00100101b
-10100111b & 01101110b = 00100110b
-10100111b & 01101111b = 00100111b
-10100111b & 01110000b = 00100000b
-10100111b & 01110001b = 00100001b
-10100111b & 01110010b = 00100010b
-10100111b & 01110011b = 00100011b
-10100111b & 01110100b = 00100100b
-10100111b & 01110101b = 00100101b
-10100111b & 01110110b = 00100110b
-10100111b & 01110111b = 00100111b
-10100111b & 01111000b = 00100000b
-10100111b & 01111001b = 00100001b
-10100111b & 01111010b = 00100010b
-10100111b & 01111011b = 00100011b
-10100111b & 01111100b = 00100100b
-10100111b & 01111101b = 00100101b
-10100111b & 01111110b = 00100110b
-10101000b & 10000000b = 10000000b
-10101000b & 10000001b = 10000000b
-10101000b & 10000010b = 10000000b
-10101000b & 10000011b = 10000000b
-10101000b & 10000100b = 10000000b
-10101000b & 10000101b = 10000000b
-10101000b & 10000110b = 10000000b
-10101000b & 10000111b = 10000000b
-10101000b & 10001000b = 10001000b
-10101000b & 10001001b = 10001000b
-10101000b & 10001010b = 10001000b
-10101000b & 10001011b = 10001000b
-10101000b & 10001100b = 10001000b
-10101000b & 10001101b = 10001000b
-10101000b & 10001110b = 10001000b
-10101000b & 10001111b = 10001000b
-10101000b & 10010000b = 10000000b
-10101000b & 10010001b = 10000000b
-10101000b & 10010010b = 10000000b
-10101000b & 10010011b = 10000000b
-10101000b & 10010100b = 10000000b
-10101000b & 10010101b = 10000000b
-10101000b & 10010110b = 10000000b
-10101000b & 10010111b = 10000000b
-10101000b & 10011000b = 10001000b
-10101000b & 10011001b = 10001000b
-10101000b & 10011010b = 10001000b
-10101000b & 10011011b = 10001000b
-10101000b & 10011100b = 10001000b
-10101000b & 10011101b = 10001000b
-10101000b & 10011110b = 10001000b
-10101000b & 10011111b = 10001000b
-10101000b & 10100000b = 10100000b
-10101000b & 10100001b = 10100000b
-10101000b & 10100010b = 10100000b
-10101000b & 10100011b = 10100000b
-10101000b & 10100100b = 10100000b
-10101000b & 10100101b = 10100000b
-10101000b & 10100110b = 10100000b
-10101000b & 10100111b = 10100000b
-10101000b & 10101000b = 10101000b
-10101000b & 10101001b = 10101000b
-10101000b & 10101010b = 10101000b
-10101000b & 10101011b = 10101000b
-10101000b & 10101100b = 10101000b
-10101000b & 10101101b = 10101000b
-10101000b & 10101110b = 10101000b
-10101000b & 10101111b = 10101000b
-10101000b & 10110000b = 10100000b
-10101000b & 10110001b = 10100000b
-10101000b & 10110010b = 10100000b
-10101000b & 10110011b = 10100000b
-10101000b & 10110100b = 10100000b
-10101000b & 10110101b = 10100000b
-10101000b & 10110110b = 10100000b
-10101000b & 10110111b = 10100000b
-10101000b & 10111000b = 10101000b
-10101000b & 10111001b = 10101000b
-10101000b & 10111010b = 10101000b
-10101000b & 10111011b = 10101000b
-10101000b & 10111100b = 10101000b
-10101000b & 10111101b = 10101000b
-10101000b & 10111110b = 10101000b
-10101000b & 10111111b = 10101000b
-10101000b & 11000000b = 10000000b
-10101000b & 11000001b = 10000000b
-10101000b & 11000010b = 10000000b
-10101000b & 11000011b = 10000000b
-10101000b & 11000100b = 10000000b
-10101000b & 11000101b = 10000000b
-10101000b & 11000110b = 10000000b
-10101000b & 11000111b = 10000000b
-10101000b & 11001000b = 10001000b
-10101000b & 11001001b = 10001000b
-10101000b & 11001010b = 10001000b
-10101000b & 11001011b = 10001000b
-10101000b & 11001100b = 10001000b
-10101000b & 11001101b = 10001000b
-10101000b & 11001110b = 10001000b
-10101000b & 11001111b = 10001000b
-10101000b & 11010000b = 10000000b
-10101000b & 11010001b = 10000000b
-10101000b & 11010010b = 10000000b
-10101000b & 11010011b = 10000000b
-10101000b & 11010100b = 10000000b
-10101000b & 11010101b = 10000000b
-10101000b & 11010110b = 10000000b
-10101000b & 11010111b = 10000000b
-10101000b & 11011000b = 10001000b
-10101000b & 11011001b = 10001000b
-10101000b & 11011010b = 10001000b
-10101000b & 11011011b = 10001000b
-10101000b & 11011100b = 10001000b
-10101000b & 11011101b = 10001000b
-10101000b & 11011110b = 10001000b
-10101000b & 11011111b = 10001000b
-10101000b & 11100000b = 10100000b
-10101000b & 11100001b = 10100000b
-10101000b & 11100010b = 10100000b
-10101000b & 11100011b = 10100000b
-10101000b & 11100100b = 10100000b
-10101000b & 11100101b = 10100000b
-10101000b & 11100110b = 10100000b
-10101000b & 11100111b = 10100000b
-10101000b & 11101000b = 10101000b
-10101000b & 11101001b = 10101000b
-10101000b & 11101010b = 10101000b
-10101000b & 11101011b = 10101000b
-10101000b & 11101100b = 10101000b
-10101000b & 11101101b = 10101000b
-10101000b & 11101110b = 10101000b
-10101000b & 11101111b = 10101000b
-10101000b & 11110000b = 10100000b
-10101000b & 11110001b = 10100000b
-10101000b & 11110010b = 10100000b
-10101000b & 11110011b = 10100000b
-10101000b & 11110100b = 10100000b
-10101000b & 11110101b = 10100000b
-10101000b & 11110110b = 10100000b
-10101000b & 11110111b = 10100000b
-10101000b & 11111000b = 10101000b
-10101000b & 11111001b = 10101000b
-10101000b & 11111010b = 10101000b
-10101000b & 11111011b = 10101000b
-10101000b & 11111100b = 10101000b
-10101000b & 11111101b = 10101000b
-10101000b & 11111110b = 10101000b
-10101000b & 11111111b = 10101000b
-10101000b & 00000000b = 00000000b
-10101000b & 00000001b = 00000000b
-10101000b & 00000010b = 00000000b
-10101000b & 00000011b = 00000000b
-10101000b & 00000100b = 00000000b
-10101000b & 00000101b = 00000000b
-10101000b & 00000110b = 00000000b
-10101000b & 00000111b = 00000000b
-10101000b & 00001000b = 00001000b
-10101000b & 00001001b = 00001000b
-10101000b & 00001010b = 00001000b
-10101000b & 00001011b = 00001000b
-10101000b & 00001100b = 00001000b
-10101000b & 00001101b = 00001000b
-10101000b & 00001110b = 00001000b
-10101000b & 00001111b = 00001000b
-10101000b & 00010000b = 00000000b
-10101000b & 00010001b = 00000000b
-10101000b & 00010010b = 00000000b
-10101000b & 00010011b = 00000000b
-10101000b & 00010100b = 00000000b
-10101000b & 00010101b = 00000000b
-10101000b & 00010110b = 00000000b
-10101000b & 00010111b = 00000000b
-10101000b & 00011000b = 00001000b
-10101000b & 00011001b = 00001000b
-10101000b & 00011010b = 00001000b
-10101000b & 00011011b = 00001000b
-10101000b & 00011100b = 00001000b
-10101000b & 00011101b = 00001000b
-10101000b & 00011110b = 00001000b
-10101000b & 00011111b = 00001000b
-10101000b & 00100000b = 00100000b
-10101000b & 00100001b = 00100000b
-10101000b & 00100010b = 00100000b
-10101000b & 00100011b = 00100000b
-10101000b & 00100100b = 00100000b
-10101000b & 00100101b = 00100000b
-10101000b & 00100110b = 00100000b
-10101000b & 00100111b = 00100000b
-10101000b & 00101000b = 00101000b
-10101000b & 00101001b = 00101000b
-10101000b & 00101010b = 00101000b
-10101000b & 00101011b = 00101000b
-10101000b & 00101100b = 00101000b
-10101000b & 00101101b = 00101000b
-10101000b & 00101110b = 00101000b
-10101000b & 00101111b = 00101000b
-10101000b & 00110000b = 00100000b
-10101000b & 00110001b = 00100000b
-10101000b & 00110010b = 00100000b
-10101000b & 00110011b = 00100000b
-10101000b & 00110100b = 00100000b
-10101000b & 00110101b = 00100000b
-10101000b & 00110110b = 00100000b
-10101000b & 00110111b = 00100000b
-10101000b & 00111000b = 00101000b
-10101000b & 00111001b = 00101000b
-10101000b & 00111010b = 00101000b
-10101000b & 00111011b = 00101000b
-10101000b & 00111100b = 00101000b
-10101000b & 00111101b = 00101000b
-10101000b & 00111110b = 00101000b
-10101000b & 00111111b = 00101000b
-10101000b & 01000000b = 00000000b
-10101000b & 01000001b = 00000000b
-10101000b & 01000010b = 00000000b
-10101000b & 01000011b = 00000000b
-10101000b & 01000100b = 00000000b
-10101000b & 01000101b = 00000000b
-10101000b & 01000110b = 00000000b
-10101000b & 01000111b = 00000000b
-10101000b & 01001000b = 00001000b
-10101000b & 01001001b = 00001000b
-10101000b & 01001010b = 00001000b
-10101000b & 01001011b = 00001000b
-10101000b & 01001100b = 00001000b
-10101000b & 01001101b = 00001000b
-10101000b & 01001110b = 00001000b
-10101000b & 01001111b = 00001000b
-10101000b & 01010000b = 00000000b
-10101000b & 01010001b = 00000000b
-10101000b & 01010010b = 00000000b
-10101000b & 01010011b = 00000000b
-10101000b & 01010100b = 00000000b
-10101000b & 01010101b = 00000000b
-10101000b & 01010110b = 00000000b
-10101000b & 01010111b = 00000000b
-10101000b & 01011000b = 00001000b
-10101000b & 01011001b = 00001000b
-10101000b & 01011010b = 00001000b
-10101000b & 01011011b = 00001000b
-10101000b & 01011100b = 00001000b
-10101000b & 01011101b = 00001000b
-10101000b & 01011110b = 00001000b
-10101000b & 01011111b = 00001000b
-10101000b & 01100000b = 00100000b
-10101000b & 01100001b = 00100000b
-10101000b & 01100010b = 00100000b
-10101000b & 01100011b = 00100000b
-10101000b & 01100100b = 00100000b
-10101000b & 01100101b = 00100000b
-10101000b & 01100110b = 00100000b
-10101000b & 01100111b = 00100000b
-10101000b & 01101000b = 00101000b
-10101000b & 01101001b = 00101000b
-10101000b & 01101010b = 00101000b
-10101000b & 01101011b = 00101000b
-10101000b & 01101100b = 00101000b
-10101000b & 01101101b = 00101000b
-10101000b & 01101110b = 00101000b
-10101000b & 01101111b = 00101000b
-10101000b & 01110000b = 00100000b
-10101000b & 01110001b = 00100000b
-10101000b & 01110010b = 00100000b
-10101000b & 01110011b = 00100000b
-10101000b & 01110100b = 00100000b
-10101000b & 01110101b = 00100000b
-10101000b & 01110110b = 00100000b
-10101000b & 01110111b = 00100000b
-10101000b & 01111000b = 00101000b
-10101000b & 01111001b = 00101000b
-10101000b & 01111010b = 00101000b
-10101000b & 01111011b = 00101000b
-10101000b & 01111100b = 00101000b
-10101000b & 01111101b = 00101000b
-10101000b & 01111110b = 00101000b
-10101001b & 10000000b = 10000000b
-10101001b & 10000001b = 10000001b
-10101001b & 10000010b = 10000000b
-10101001b & 10000011b = 10000001b
-10101001b & 10000100b = 10000000b
-10101001b & 10000101b = 10000001b
-10101001b & 10000110b = 10000000b
-10101001b & 10000111b = 10000001b
-10101001b & 10001000b = 10001000b
-10101001b & 10001001b = 10001001b
-10101001b & 10001010b = 10001000b
-10101001b & 10001011b = 10001001b
-10101001b & 10001100b = 10001000b
-10101001b & 10001101b = 10001001b
-10101001b & 10001110b = 10001000b
-10101001b & 10001111b = 10001001b
-10101001b & 10010000b = 10000000b
-10101001b & 10010001b = 10000001b
-10101001b & 10010010b = 10000000b
-10101001b & 10010011b = 10000001b
-10101001b & 10010100b = 10000000b
-10101001b & 10010101b = 10000001b
-10101001b & 10010110b = 10000000b
-10101001b & 10010111b = 10000001b
-10101001b & 10011000b = 10001000b
-10101001b & 10011001b = 10001001b
-10101001b & 10011010b = 10001000b
-10101001b & 10011011b = 10001001b
-10101001b & 10011100b = 10001000b
-10101001b & 10011101b = 10001001b
-10101001b & 10011110b = 10001000b
-10101001b & 10011111b = 10001001b
-10101001b & 10100000b = 10100000b
-10101001b & 10100001b = 10100001b
-10101001b & 10100010b = 10100000b
-10101001b & 10100011b = 10100001b
-10101001b & 10100100b = 10100000b
-10101001b & 10100101b = 10100001b
-10101001b & 10100110b = 10100000b
-10101001b & 10100111b = 10100001b
-10101001b & 10101000b = 10101000b
-10101001b & 10101001b = 10101001b
-10101001b & 10101010b = 10101000b
-10101001b & 10101011b = 10101001b
-10101001b & 10101100b = 10101000b
-10101001b & 10101101b = 10101001b
-10101001b & 10101110b = 10101000b
-10101001b & 10101111b = 10101001b
-10101001b & 10110000b = 10100000b
-10101001b & 10110001b = 10100001b
-10101001b & 10110010b = 10100000b
-10101001b & 10110011b = 10100001b
-10101001b & 10110100b = 10100000b
-10101001b & 10110101b = 10100001b
-10101001b & 10110110b = 10100000b
-10101001b & 10110111b = 10100001b
-10101001b & 10111000b = 10101000b
-10101001b & 10111001b = 10101001b
-10101001b & 10111010b = 10101000b
-10101001b & 10111011b = 10101001b
-10101001b & 10111100b = 10101000b
-10101001b & 10111101b = 10101001b
-10101001b & 10111110b = 10101000b
-10101001b & 10111111b = 10101001b
-10101001b & 11000000b = 10000000b
-10101001b & 11000001b = 10000001b
-10101001b & 11000010b = 10000000b
-10101001b & 11000011b = 10000001b
-10101001b & 11000100b = 10000000b
-10101001b & 11000101b = 10000001b
-10101001b & 11000110b = 10000000b
-10101001b & 11000111b = 10000001b
-10101001b & 11001000b = 10001000b
-10101001b & 11001001b = 10001001b
-10101001b & 11001010b = 10001000b
-10101001b & 11001011b = 10001001b
-10101001b & 11001100b = 10001000b
-10101001b & 11001101b = 10001001b
-10101001b & 11001110b = 10001000b
-10101001b & 11001111b = 10001001b
-10101001b & 11010000b = 10000000b
-10101001b & 11010001b = 10000001b
-10101001b & 11010010b = 10000000b
-10101001b & 11010011b = 10000001b
-10101001b & 11010100b = 10000000b
-10101001b & 11010101b = 10000001b
-10101001b & 11010110b = 10000000b
-10101001b & 11010111b = 10000001b
-10101001b & 11011000b = 10001000b
-10101001b & 11011001b = 10001001b
-10101001b & 11011010b = 10001000b
-10101001b & 11011011b = 10001001b
-10101001b & 11011100b = 10001000b
-10101001b & 11011101b = 10001001b
-10101001b & 11011110b = 10001000b
-10101001b & 11011111b = 10001001b
-10101001b & 11100000b = 10100000b
-10101001b & 11100001b = 10100001b
-10101001b & 11100010b = 10100000b
-10101001b & 11100011b = 10100001b
-10101001b & 11100100b = 10100000b
-10101001b & 11100101b = 10100001b
-10101001b & 11100110b = 10100000b
-10101001b & 11100111b = 10100001b
-10101001b & 11101000b = 10101000b
-10101001b & 11101001b = 10101001b
-10101001b & 11101010b = 10101000b
-10101001b & 11101011b = 10101001b
-10101001b & 11101100b = 10101000b
-10101001b & 11101101b = 10101001b
-10101001b & 11101110b = 10101000b
-10101001b & 11101111b = 10101001b
-10101001b & 11110000b = 10100000b
-10101001b & 11110001b = 10100001b
-10101001b & 11110010b = 10100000b
-10101001b & 11110011b = 10100001b
-10101001b & 11110100b = 10100000b
-10101001b & 11110101b = 10100001b
-10101001b & 11110110b = 10100000b
-10101001b & 11110111b = 10100001b
-10101001b & 11111000b = 10101000b
-10101001b & 11111001b = 10101001b
-10101001b & 11111010b = 10101000b
-10101001b & 11111011b = 10101001b
-10101001b & 11111100b = 10101000b
-10101001b & 11111101b = 10101001b
-10101001b & 11111110b = 10101000b
-10101001b & 11111111b = 10101001b
-10101001b & 00000000b = 00000000b
-10101001b & 00000001b = 00000001b
-10101001b & 00000010b = 00000000b
-10101001b & 00000011b = 00000001b
-10101001b & 00000100b = 00000000b
-10101001b & 00000101b = 00000001b
-10101001b & 00000110b = 00000000b
-10101001b & 00000111b = 00000001b
-10101001b & 00001000b = 00001000b
-10101001b & 00001001b = 00001001b
-10101001b & 00001010b = 00001000b
-10101001b & 00001011b = 00001001b
-10101001b & 00001100b = 00001000b
-10101001b & 00001101b = 00001001b
-10101001b & 00001110b = 00001000b
-10101001b & 00001111b = 00001001b
-10101001b & 00010000b = 00000000b
-10101001b & 00010001b = 00000001b
-10101001b & 00010010b = 00000000b
-10101001b & 00010011b = 00000001b
-10101001b & 00010100b = 00000000b
-10101001b & 00010101b = 00000001b
-10101001b & 00010110b = 00000000b
-10101001b & 00010111b = 00000001b
-10101001b & 00011000b = 00001000b
-10101001b & 00011001b = 00001001b
-10101001b & 00011010b = 00001000b
-10101001b & 00011011b = 00001001b
-10101001b & 00011100b = 00001000b
-10101001b & 00011101b = 00001001b
-10101001b & 00011110b = 00001000b
-10101001b & 00011111b = 00001001b
-10101001b & 00100000b = 00100000b
-10101001b & 00100001b = 00100001b
-10101001b & 00100010b = 00100000b
-10101001b & 00100011b = 00100001b
-10101001b & 00100100b = 00100000b
-10101001b & 00100101b = 00100001b
-10101001b & 00100110b = 00100000b
-10101001b & 00100111b = 00100001b
-10101001b & 00101000b = 00101000b
-10101001b & 00101001b = 00101001b
-10101001b & 00101010b = 00101000b
-10101001b & 00101011b = 00101001b
-10101001b & 00101100b = 00101000b
-10101001b & 00101101b = 00101001b
-10101001b & 00101110b = 00101000b
-10101001b & 00101111b = 00101001b
-10101001b & 00110000b = 00100000b
-10101001b & 00110001b = 00100001b
-10101001b & 00110010b = 00100000b
-10101001b & 00110011b = 00100001b
-10101001b & 00110100b = 00100000b
-10101001b & 00110101b = 00100001b
-10101001b & 00110110b = 00100000b
-10101001b & 00110111b = 00100001b
-10101001b & 00111000b = 00101000b
-10101001b & 00111001b = 00101001b
-10101001b & 00111010b = 00101000b
-10101001b & 00111011b = 00101001b
-10101001b & 00111100b = 00101000b
-10101001b & 00111101b = 00101001b
-10101001b & 00111110b = 00101000b
-10101001b & 00111111b = 00101001b
-10101001b & 01000000b = 00000000b
-10101001b & 01000001b = 00000001b
-10101001b & 01000010b = 00000000b
-10101001b & 01000011b = 00000001b
-10101001b & 01000100b = 00000000b
-10101001b & 01000101b = 00000001b
-10101001b & 01000110b = 00000000b
-10101001b & 01000111b = 00000001b
-10101001b & 01001000b = 00001000b
-10101001b & 01001001b = 00001001b
-10101001b & 01001010b = 00001000b
-10101001b & 01001011b = 00001001b
-10101001b & 01001100b = 00001000b
-10101001b & 01001101b = 00001001b
-10101001b & 01001110b = 00001000b
-10101001b & 01001111b = 00001001b
-10101001b & 01010000b = 00000000b
-10101001b & 01010001b = 00000001b
-10101001b & 01010010b = 00000000b
-10101001b & 01010011b = 00000001b
-10101001b & 01010100b = 00000000b
-10101001b & 01010101b = 00000001b
-10101001b & 01010110b = 00000000b
-10101001b & 01010111b = 00000001b
-10101001b & 01011000b = 00001000b
-10101001b & 01011001b = 00001001b
-10101001b & 01011010b = 00001000b
-10101001b & 01011011b = 00001001b
-10101001b & 01011100b = 00001000b
-10101001b & 01011101b = 00001001b
-10101001b & 01011110b = 00001000b
-10101001b & 01011111b = 00001001b
-10101001b & 01100000b = 00100000b
-10101001b & 01100001b = 00100001b
-10101001b & 01100010b = 00100000b
-10101001b & 01100011b = 00100001b
-10101001b & 01100100b = 00100000b
-10101001b & 01100101b = 00100001b
-10101001b & 01100110b = 00100000b
-10101001b & 01100111b = 00100001b
-10101001b & 01101000b = 00101000b
-10101001b & 01101001b = 00101001b
-10101001b & 01101010b = 00101000b
-10101001b & 01101011b = 00101001b
-10101001b & 01101100b = 00101000b
-10101001b & 01101101b = 00101001b
-10101001b & 01101110b = 00101000b
-10101001b & 01101111b = 00101001b
-10101001b & 01110000b = 00100000b
-10101001b & 01110001b = 00100001b
-10101001b & 01110010b = 00100000b
-10101001b & 01110011b = 00100001b
-10101001b & 01110100b = 00100000b
-10101001b & 01110101b = 00100001b
-10101001b & 01110110b = 00100000b
-10101001b & 01110111b = 00100001b
-10101001b & 01111000b = 00101000b
-10101001b & 01111001b = 00101001b
-10101001b & 01111010b = 00101000b
-10101001b & 01111011b = 00101001b
-10101001b & 01111100b = 00101000b
-10101001b & 01111101b = 00101001b
-10101001b & 01111110b = 00101000b
-10101010b & 10000000b = 10000000b
-10101010b & 10000001b = 10000000b
-10101010b & 10000010b = 10000010b
-10101010b & 10000011b = 10000010b
-10101010b & 10000100b = 10000000b
-10101010b & 10000101b = 10000000b
-10101010b & 10000110b = 10000010b
-10101010b & 10000111b = 10000010b
-10101010b & 10001000b = 10001000b
-10101010b & 10001001b = 10001000b
-10101010b & 10001010b = 10001010b
-10101010b & 10001011b = 10001010b
-10101010b & 10001100b = 10001000b
-10101010b & 10001101b = 10001000b
-10101010b & 10001110b = 10001010b
-10101010b & 10001111b = 10001010b
-10101010b & 10010000b = 10000000b
-10101010b & 10010001b = 10000000b
-10101010b & 10010010b = 10000010b
-10101010b & 10010011b = 10000010b
-10101010b & 10010100b = 10000000b
-10101010b & 10010101b = 10000000b
-10101010b & 10010110b = 10000010b
-10101010b & 10010111b = 10000010b
-10101010b & 10011000b = 10001000b
-10101010b & 10011001b = 10001000b
-10101010b & 10011010b = 10001010b
-10101010b & 10011011b = 10001010b
-10101010b & 10011100b = 10001000b
-10101010b & 10011101b = 10001000b
-10101010b & 10011110b = 10001010b
-10101010b & 10011111b = 10001010b
-10101010b & 10100000b = 10100000b
-10101010b & 10100001b = 10100000b
-10101010b & 10100010b = 10100010b
-10101010b & 10100011b = 10100010b
-10101010b & 10100100b = 10100000b
-10101010b & 10100101b = 10100000b
-10101010b & 10100110b = 10100010b
-10101010b & 10100111b = 10100010b
-10101010b & 10101000b = 10101000b
-10101010b & 10101001b = 10101000b
-10101010b & 10101010b = 10101010b
-10101010b & 10101011b = 10101010b
-10101010b & 10101100b = 10101000b
-10101010b & 10101101b = 10101000b
-10101010b & 10101110b = 10101010b
-10101010b & 10101111b = 10101010b
-10101010b & 10110000b = 10100000b
-10101010b & 10110001b = 10100000b
-10101010b & 10110010b = 10100010b
-10101010b & 10110011b = 10100010b
-10101010b & 10110100b = 10100000b
-10101010b & 10110101b = 10100000b
-10101010b & 10110110b = 10100010b
-10101010b & 10110111b = 10100010b
-10101010b & 10111000b = 10101000b
-10101010b & 10111001b = 10101000b
-10101010b & 10111010b = 10101010b
-10101010b & 10111011b = 10101010b
-10101010b & 10111100b = 10101000b
-10101010b & 10111101b = 10101000b
-10101010b & 10111110b = 10101010b
-10101010b & 10111111b = 10101010b
-10101010b & 11000000b = 10000000b
-10101010b & 11000001b = 10000000b
-10101010b & 11000010b = 10000010b
-10101010b & 11000011b = 10000010b
-10101010b & 11000100b = 10000000b
-10101010b & 11000101b = 10000000b
-10101010b & 11000110b = 10000010b
-10101010b & 11000111b = 10000010b
-10101010b & 11001000b = 10001000b
-10101010b & 11001001b = 10001000b
-10101010b & 11001010b = 10001010b
-10101010b & 11001011b = 10001010b
-10101010b & 11001100b = 10001000b
-10101010b & 11001101b = 10001000b
-10101010b & 11001110b = 10001010b
-10101010b & 11001111b = 10001010b
-10101010b & 11010000b = 10000000b
-10101010b & 11010001b = 10000000b
-10101010b & 11010010b = 10000010b
-10101010b & 11010011b = 10000010b
-10101010b & 11010100b = 10000000b
-10101010b & 11010101b = 10000000b
-10101010b & 11010110b = 10000010b
-10101010b & 11010111b = 10000010b
-10101010b & 11011000b = 10001000b
-10101010b & 11011001b = 10001000b
-10101010b & 11011010b = 10001010b
-10101010b & 11011011b = 10001010b
-10101010b & 11011100b = 10001000b
-10101010b & 11011101b = 10001000b
-10101010b & 11011110b = 10001010b
-10101010b & 11011111b = 10001010b
-10101010b & 11100000b = 10100000b
-10101010b & 11100001b = 10100000b
-10101010b & 11100010b = 10100010b
-10101010b & 11100011b = 10100010b
-10101010b & 11100100b = 10100000b
-10101010b & 11100101b = 10100000b
-10101010b & 11100110b = 10100010b
-10101010b & 11100111b = 10100010b
-10101010b & 11101000b = 10101000b
-10101010b & 11101001b = 10101000b
-10101010b & 11101010b = 10101010b
-10101010b & 11101011b = 10101010b
-10101010b & 11101100b = 10101000b
-10101010b & 11101101b = 10101000b
-10101010b & 11101110b = 10101010b
-10101010b & 11101111b = 10101010b
-10101010b & 11110000b = 10100000b
-10101010b & 11110001b = 10100000b
-10101010b & 11110010b = 10100010b
-10101010b & 11110011b = 10100010b
-10101010b & 11110100b = 10100000b
-10101010b & 11110101b = 10100000b
-10101010b & 11110110b = 10100010b
-10101010b & 11110111b = 10100010b
-10101010b & 11111000b = 10101000b
-10101010b & 11111001b = 10101000b
-10101010b & 11111010b = 10101010b
-10101010b & 11111011b = 10101010b
-10101010b & 11111100b = 10101000b
-10101010b & 11111101b = 10101000b
-10101010b & 11111110b = 10101010b
-10101010b & 11111111b = 10101010b
-10101010b & 00000000b = 00000000b
-10101010b & 00000001b = 00000000b
-10101010b & 00000010b = 00000010b
-10101010b & 00000011b = 00000010b
-10101010b & 00000100b = 00000000b
-10101010b & 00000101b = 00000000b
-10101010b & 00000110b = 00000010b
-10101010b & 00000111b = 00000010b
-10101010b & 00001000b = 00001000b
-10101010b & 00001001b = 00001000b
-10101010b & 00001010b = 00001010b
-10101010b & 00001011b = 00001010b
-10101010b & 00001100b = 00001000b
-10101010b & 00001101b = 00001000b
-10101010b & 00001110b = 00001010b
-10101010b & 00001111b = 00001010b
-10101010b & 00010000b = 00000000b
-10101010b & 00010001b = 00000000b
-10101010b & 00010010b = 00000010b
-10101010b & 00010011b = 00000010b
-10101010b & 00010100b = 00000000b
-10101010b & 00010101b = 00000000b
-10101010b & 00010110b = 00000010b
-10101010b & 00010111b = 00000010b
-10101010b & 00011000b = 00001000b
-10101010b & 00011001b = 00001000b
-10101010b & 00011010b = 00001010b
-10101010b & 00011011b = 00001010b
-10101010b & 00011100b = 00001000b
-10101010b & 00011101b = 00001000b
-10101010b & 00011110b = 00001010b
-10101010b & 00011111b = 00001010b
-10101010b & 00100000b = 00100000b
-10101010b & 00100001b = 00100000b
-10101010b & 00100010b = 00100010b
-10101010b & 00100011b = 00100010b
-10101010b & 00100100b = 00100000b
-10101010b & 00100101b = 00100000b
-10101010b & 00100110b = 00100010b
-10101010b & 00100111b = 00100010b
-10101010b & 00101000b = 00101000b
-10101010b & 00101001b = 00101000b
-10101010b & 00101010b = 00101010b
-10101010b & 00101011b = 00101010b
-10101010b & 00101100b = 00101000b
-10101010b & 00101101b = 00101000b
-10101010b & 00101110b = 00101010b
-10101010b & 00101111b = 00101010b
-10101010b & 00110000b = 00100000b
-10101010b & 00110001b = 00100000b
-10101010b & 00110010b = 00100010b
-10101010b & 00110011b = 00100010b
-10101010b & 00110100b = 00100000b
-10101010b & 00110101b = 00100000b
-10101010b & 00110110b = 00100010b
-10101010b & 00110111b = 00100010b
-10101010b & 00111000b = 00101000b
-10101010b & 00111001b = 00101000b
-10101010b & 00111010b = 00101010b
-10101010b & 00111011b = 00101010b
-10101010b & 00111100b = 00101000b
-10101010b & 00111101b = 00101000b
-10101010b & 00111110b = 00101010b
-10101010b & 00111111b = 00101010b
-10101010b & 01000000b = 00000000b
-10101010b & 01000001b = 00000000b
-10101010b & 01000010b = 00000010b
-10101010b & 01000011b = 00000010b
-10101010b & 01000100b = 00000000b
-10101010b & 01000101b = 00000000b
-10101010b & 01000110b = 00000010b
-10101010b & 01000111b = 00000010b
-10101010b & 01001000b = 00001000b
-10101010b & 01001001b = 00001000b
-10101010b & 01001010b = 00001010b
-10101010b & 01001011b = 00001010b
-10101010b & 01001100b = 00001000b
-10101010b & 01001101b = 00001000b
-10101010b & 01001110b = 00001010b
-10101010b & 01001111b = 00001010b
-10101010b & 01010000b = 00000000b
-10101010b & 01010001b = 00000000b
-10101010b & 01010010b = 00000010b
-10101010b & 01010011b = 00000010b
-10101010b & 01010100b = 00000000b
-10101010b & 01010101b = 00000000b
-10101010b & 01010110b = 00000010b
-10101010b & 01010111b = 00000010b
-10101010b & 01011000b = 00001000b
-10101010b & 01011001b = 00001000b
-10101010b & 01011010b = 00001010b
-10101010b & 01011011b = 00001010b
-10101010b & 01011100b = 00001000b
-10101010b & 01011101b = 00001000b
-10101010b & 01011110b = 00001010b
-10101010b & 01011111b = 00001010b
-10101010b & 01100000b = 00100000b
-10101010b & 01100001b = 00100000b
-10101010b & 01100010b = 00100010b
-10101010b & 01100011b = 00100010b
-10101010b & 01100100b = 00100000b
-10101010b & 01100101b = 00100000b
-10101010b & 01100110b = 00100010b
-10101010b & 01100111b = 00100010b
-10101010b & 01101000b = 00101000b
-10101010b & 01101001b = 00101000b
-10101010b & 01101010b = 00101010b
-10101010b & 01101011b = 00101010b
-10101010b & 01101100b = 00101000b
-10101010b & 01101101b = 00101000b
-10101010b & 01101110b = 00101010b
-10101010b & 01101111b = 00101010b
-10101010b & 01110000b = 00100000b
-10101010b & 01110001b = 00100000b
-10101010b & 01110010b = 00100010b
-10101010b & 01110011b = 00100010b
-10101010b & 01110100b = 00100000b
-10101010b & 01110101b = 00100000b
-10101010b & 01110110b = 00100010b
-10101010b & 01110111b = 00100010b
-10101010b & 01111000b = 00101000b
-10101010b & 01111001b = 00101000b
-10101010b & 01111010b = 00101010b
-10101010b & 01111011b = 00101010b
-10101010b & 01111100b = 00101000b
-10101010b & 01111101b = 00101000b
-10101010b & 01111110b = 00101010b
-10101011b & 10000000b = 10000000b
-10101011b & 10000001b = 10000001b
-10101011b & 10000010b = 10000010b
-10101011b & 10000011b = 10000011b
-10101011b & 10000100b = 10000000b
-10101011b & 10000101b = 10000001b
-10101011b & 10000110b = 10000010b
-10101011b & 10000111b = 10000011b
-10101011b & 10001000b = 10001000b
-10101011b & 10001001b = 10001001b
-10101011b & 10001010b = 10001010b
-10101011b & 10001011b = 10001011b
-10101011b & 10001100b = 10001000b
-10101011b & 10001101b = 10001001b
-10101011b & 10001110b = 10001010b
-10101011b & 10001111b = 10001011b
-10101011b & 10010000b = 10000000b
-10101011b & 10010001b = 10000001b
-10101011b & 10010010b = 10000010b
-10101011b & 10010011b = 10000011b
-10101011b & 10010100b = 10000000b
-10101011b & 10010101b = 10000001b
-10101011b & 10010110b = 10000010b
-10101011b & 10010111b = 10000011b
-10101011b & 10011000b = 10001000b
-10101011b & 10011001b = 10001001b
-10101011b & 10011010b = 10001010b
-10101011b & 10011011b = 10001011b
-10101011b & 10011100b = 10001000b
-10101011b & 10011101b = 10001001b
-10101011b & 10011110b = 10001010b
-10101011b & 10011111b = 10001011b
-10101011b & 10100000b = 10100000b
-10101011b & 10100001b = 10100001b
-10101011b & 10100010b = 10100010b
-10101011b & 10100011b = 10100011b
-10101011b & 10100100b = 10100000b
-10101011b & 10100101b = 10100001b
-10101011b & 10100110b = 10100010b
-10101011b & 10100111b = 10100011b
-10101011b & 10101000b = 10101000b
-10101011b & 10101001b = 10101001b
-10101011b & 10101010b = 10101010b
-10101011b & 10101011b = 10101011b
-10101011b & 10101100b = 10101000b
-10101011b & 10101101b = 10101001b
-10101011b & 10101110b = 10101010b
-10101011b & 10101111b = 10101011b
-10101011b & 10110000b = 10100000b
-10101011b & 10110001b = 10100001b
-10101011b & 10110010b = 10100010b
-10101011b & 10110011b = 10100011b
-10101011b & 10110100b = 10100000b
-10101011b & 10110101b = 10100001b
-10101011b & 10110110b = 10100010b
-10101011b & 10110111b = 10100011b
-10101011b & 10111000b = 10101000b
-10101011b & 10111001b = 10101001b
-10101011b & 10111010b = 10101010b
-10101011b & 10111011b = 10101011b
-10101011b & 10111100b = 10101000b
-10101011b & 10111101b = 10101001b
-10101011b & 10111110b = 10101010b
-10101011b & 10111111b = 10101011b
-10101011b & 11000000b = 10000000b
-10101011b & 11000001b = 10000001b
-10101011b & 11000010b = 10000010b
-10101011b & 11000011b = 10000011b
-10101011b & 11000100b = 10000000b
-10101011b & 11000101b = 10000001b
-10101011b & 11000110b = 10000010b
-10101011b & 11000111b = 10000011b
-10101011b & 11001000b = 10001000b
-10101011b & 11001001b = 10001001b
-10101011b & 11001010b = 10001010b
-10101011b & 11001011b = 10001011b
-10101011b & 11001100b = 10001000b
-10101011b & 11001101b = 10001001b
-10101011b & 11001110b = 10001010b
-10101011b & 11001111b = 10001011b
-10101011b & 11010000b = 10000000b
-10101011b & 11010001b = 10000001b
-10101011b & 11010010b = 10000010b
-10101011b & 11010011b = 10000011b
-10101011b & 11010100b = 10000000b
-10101011b & 11010101b = 10000001b
-10101011b & 11010110b = 10000010b
-10101011b & 11010111b = 10000011b
-10101011b & 11011000b = 10001000b
-10101011b & 11011001b = 10001001b
-10101011b & 11011010b = 10001010b
-10101011b & 11011011b = 10001011b
-10101011b & 11011100b = 10001000b
-10101011b & 11011101b = 10001001b
-10101011b & 11011110b = 10001010b
-10101011b & 11011111b = 10001011b
-10101011b & 11100000b = 10100000b
-10101011b & 11100001b = 10100001b
-10101011b & 11100010b = 10100010b
-10101011b & 11100011b = 10100011b
-10101011b & 11100100b = 10100000b
-10101011b & 11100101b = 10100001b
-10101011b & 11100110b = 10100010b
-10101011b & 11100111b = 10100011b
-10101011b & 11101000b = 10101000b
-10101011b & 11101001b = 10101001b
-10101011b & 11101010b = 10101010b
-10101011b & 11101011b = 10101011b
-10101011b & 11101100b = 10101000b
-10101011b & 11101101b = 10101001b
-10101011b & 11101110b = 10101010b
-10101011b & 11101111b = 10101011b
-10101011b & 11110000b = 10100000b
-10101011b & 11110001b = 10100001b
-10101011b & 11110010b = 10100010b
-10101011b & 11110011b = 10100011b
-10101011b & 11110100b = 10100000b
-10101011b & 11110101b = 10100001b
-10101011b & 11110110b = 10100010b
-10101011b & 11110111b = 10100011b
-10101011b & 11111000b = 10101000b
-10101011b & 11111001b = 10101001b
-10101011b & 11111010b = 10101010b
-10101011b & 11111011b = 10101011b
-10101011b & 11111100b = 10101000b
-10101011b & 11111101b = 10101001b
-10101011b & 11111110b = 10101010b
-10101011b & 11111111b = 10101011b
-10101011b & 00000000b = 00000000b
-10101011b & 00000001b = 00000001b
-10101011b & 00000010b = 00000010b
-10101011b & 00000011b = 00000011b
-10101011b & 00000100b = 00000000b
-10101011b & 00000101b = 00000001b
-10101011b & 00000110b = 00000010b
-10101011b & 00000111b = 00000011b
-10101011b & 00001000b = 00001000b
-10101011b & 00001001b = 00001001b
-10101011b & 00001010b = 00001010b
-10101011b & 00001011b = 00001011b
-10101011b & 00001100b = 00001000b
-10101011b & 00001101b = 00001001b
-10101011b & 00001110b = 00001010b
-10101011b & 00001111b = 00001011b
-10101011b & 00010000b = 00000000b
-10101011b & 00010001b = 00000001b
-10101011b & 00010010b = 00000010b
-10101011b & 00010011b = 00000011b
-10101011b & 00010100b = 00000000b
-10101011b & 00010101b = 00000001b
-10101011b & 00010110b = 00000010b
-10101011b & 00010111b = 00000011b
-10101011b & 00011000b = 00001000b
-10101011b & 00011001b = 00001001b
-10101011b & 00011010b = 00001010b
-10101011b & 00011011b = 00001011b
-10101011b & 00011100b = 00001000b
-10101011b & 00011101b = 00001001b
-10101011b & 00011110b = 00001010b
-10101011b & 00011111b = 00001011b
-10101011b & 00100000b = 00100000b
-10101011b & 00100001b = 00100001b
-10101011b & 00100010b = 00100010b
-10101011b & 00100011b = 00100011b
-10101011b & 00100100b = 00100000b
-10101011b & 00100101b = 00100001b
-10101011b & 00100110b = 00100010b
-10101011b & 00100111b = 00100011b
-10101011b & 00101000b = 00101000b
-10101011b & 00101001b = 00101001b
-10101011b & 00101010b = 00101010b
-10101011b & 00101011b = 00101011b
-10101011b & 00101100b = 00101000b
-10101011b & 00101101b = 00101001b
-10101011b & 00101110b = 00101010b
-10101011b & 00101111b = 00101011b
-10101011b & 00110000b = 00100000b
-10101011b & 00110001b = 00100001b
-10101011b & 00110010b = 00100010b
-10101011b & 00110011b = 00100011b
-10101011b & 00110100b = 00100000b
-10101011b & 00110101b = 00100001b
-10101011b & 00110110b = 00100010b
-10101011b & 00110111b = 00100011b
-10101011b & 00111000b = 00101000b
-10101011b & 00111001b = 00101001b
-10101011b & 00111010b = 00101010b
-10101011b & 00111011b = 00101011b
-10101011b & 00111100b = 00101000b
-10101011b & 00111101b = 00101001b
-10101011b & 00111110b = 00101010b
-10101011b & 00111111b = 00101011b
-10101011b & 01000000b = 00000000b
-10101011b & 01000001b = 00000001b
-10101011b & 01000010b = 00000010b
-10101011b & 01000011b = 00000011b
-10101011b & 01000100b = 00000000b
-10101011b & 01000101b = 00000001b
-10101011b & 01000110b = 00000010b
-10101011b & 01000111b = 00000011b
-10101011b & 01001000b = 00001000b
-10101011b & 01001001b = 00001001b
-10101011b & 01001010b = 00001010b
-10101011b & 01001011b = 00001011b
-10101011b & 01001100b = 00001000b
-10101011b & 01001101b = 00001001b
-10101011b & 01001110b = 00001010b
-10101011b & 01001111b = 00001011b
-10101011b & 01010000b = 00000000b
-10101011b & 01010001b = 00000001b
-10101011b & 01010010b = 00000010b
-10101011b & 01010011b = 00000011b
-10101011b & 01010100b = 00000000b
-10101011b & 01010101b = 00000001b
-10101011b & 01010110b = 00000010b
-10101011b & 01010111b = 00000011b
-10101011b & 01011000b = 00001000b
-10101011b & 01011001b = 00001001b
-10101011b & 01011010b = 00001010b
-10101011b & 01011011b = 00001011b
-10101011b & 01011100b = 00001000b
-10101011b & 01011101b = 00001001b
-10101011b & 01011110b = 00001010b
-10101011b & 01011111b = 00001011b
-10101011b & 01100000b = 00100000b
-10101011b & 01100001b = 00100001b
-10101011b & 01100010b = 00100010b
-10101011b & 01100011b = 00100011b
-10101011b & 01100100b = 00100000b
-10101011b & 01100101b = 00100001b
-10101011b & 01100110b = 00100010b
-10101011b & 01100111b = 00100011b
-10101011b & 01101000b = 00101000b
-10101011b & 01101001b = 00101001b
-10101011b & 01101010b = 00101010b
-10101011b & 01101011b = 00101011b
-10101011b & 01101100b = 00101000b
-10101011b & 01101101b = 00101001b
-10101011b & 01101110b = 00101010b
-10101011b & 01101111b = 00101011b
-10101011b & 01110000b = 00100000b
-10101011b & 01110001b = 00100001b
-10101011b & 01110010b = 00100010b
-10101011b & 01110011b = 00100011b
-10101011b & 01110100b = 00100000b
-10101011b & 01110101b = 00100001b
-10101011b & 01110110b = 00100010b
-10101011b & 01110111b = 00100011b
-10101011b & 01111000b = 00101000b
-10101011b & 01111001b = 00101001b
-10101011b & 01111010b = 00101010b
-10101011b & 01111011b = 00101011b
-10101011b & 01111100b = 00101000b
-10101011b & 01111101b = 00101001b
-10101011b & 01111110b = 00101010b
-10101100b & 10000000b = 10000000b
-10101100b & 10000001b = 10000000b
-10101100b & 10000010b = 10000000b
-10101100b & 10000011b = 10000000b
-10101100b & 10000100b = 10000100b
-10101100b & 10000101b = 10000100b
-10101100b & 10000110b = 10000100b
-10101100b & 10000111b = 10000100b
-10101100b & 10001000b = 10001000b
-10101100b & 10001001b = 10001000b
-10101100b & 10001010b = 10001000b
-10101100b & 10001011b = 10001000b
-10101100b & 10001100b = 10001100b
-10101100b & 10001101b = 10001100b
-10101100b & 10001110b = 10001100b
-10101100b & 10001111b = 10001100b
-10101100b & 10010000b = 10000000b
-10101100b & 10010001b = 10000000b
-10101100b & 10010010b = 10000000b
-10101100b & 10010011b = 10000000b
-10101100b & 10010100b = 10000100b
-10101100b & 10010101b = 10000100b
-10101100b & 10010110b = 10000100b
-10101100b & 10010111b = 10000100b
-10101100b & 10011000b = 10001000b
-10101100b & 10011001b = 10001000b
-10101100b & 10011010b = 10001000b
-10101100b & 10011011b = 10001000b
-10101100b & 10011100b = 10001100b
-10101100b & 10011101b = 10001100b
-10101100b & 10011110b = 10001100b
-10101100b & 10011111b = 10001100b
-10101100b & 10100000b = 10100000b
-10101100b & 10100001b = 10100000b
-10101100b & 10100010b = 10100000b
-10101100b & 10100011b = 10100000b
-10101100b & 10100100b = 10100100b
-10101100b & 10100101b = 10100100b
-10101100b & 10100110b = 10100100b
-10101100b & 10100111b = 10100100b
-10101100b & 10101000b = 10101000b
-10101100b & 10101001b = 10101000b
-10101100b & 10101010b = 10101000b
-10101100b & 10101011b = 10101000b
-10101100b & 10101100b = 10101100b
-10101100b & 10101101b = 10101100b
-10101100b & 10101110b = 10101100b
-10101100b & 10101111b = 10101100b
-10101100b & 10110000b = 10100000b
-10101100b & 10110001b = 10100000b
-10101100b & 10110010b = 10100000b
-10101100b & 10110011b = 10100000b
-10101100b & 10110100b = 10100100b
-10101100b & 10110101b = 10100100b
-10101100b & 10110110b = 10100100b
-10101100b & 10110111b = 10100100b
-10101100b & 10111000b = 10101000b
-10101100b & 10111001b = 10101000b
-10101100b & 10111010b = 10101000b
-10101100b & 10111011b = 10101000b
-10101100b & 10111100b = 10101100b
-10101100b & 10111101b = 10101100b
-10101100b & 10111110b = 10101100b
-10101100b & 10111111b = 10101100b
-10101100b & 11000000b = 10000000b
-10101100b & 11000001b = 10000000b
-10101100b & 11000010b = 10000000b
-10101100b & 11000011b = 10000000b
-10101100b & 11000100b = 10000100b
-10101100b & 11000101b = 10000100b
-10101100b & 11000110b = 10000100b
-10101100b & 11000111b = 10000100b
-10101100b & 11001000b = 10001000b
-10101100b & 11001001b = 10001000b
-10101100b & 11001010b = 10001000b
-10101100b & 11001011b = 10001000b
-10101100b & 11001100b = 10001100b
-10101100b & 11001101b = 10001100b
-10101100b & 11001110b = 10001100b
-10101100b & 11001111b = 10001100b
-10101100b & 11010000b = 10000000b
-10101100b & 11010001b = 10000000b
-10101100b & 11010010b = 10000000b
-10101100b & 11010011b = 10000000b
-10101100b & 11010100b = 10000100b
-10101100b & 11010101b = 10000100b
-10101100b & 11010110b = 10000100b
-10101100b & 11010111b = 10000100b
-10101100b & 11011000b = 10001000b
-10101100b & 11011001b = 10001000b
-10101100b & 11011010b = 10001000b
-10101100b & 11011011b = 10001000b
-10101100b & 11011100b = 10001100b
-10101100b & 11011101b = 10001100b
-10101100b & 11011110b = 10001100b
-10101100b & 11011111b = 10001100b
-10101100b & 11100000b = 10100000b
-10101100b & 11100001b = 10100000b
-10101100b & 11100010b = 10100000b
-10101100b & 11100011b = 10100000b
-10101100b & 11100100b = 10100100b
-10101100b & 11100101b = 10100100b
-10101100b & 11100110b = 10100100b
-10101100b & 11100111b = 10100100b
-10101100b & 11101000b = 10101000b
-10101100b & 11101001b = 10101000b
-10101100b & 11101010b = 10101000b
-10101100b & 11101011b = 10101000b
-10101100b & 11101100b = 10101100b
-10101100b & 11101101b = 10101100b
-10101100b & 11101110b = 10101100b
-10101100b & 11101111b = 10101100b
-10101100b & 11110000b = 10100000b
-10101100b & 11110001b = 10100000b
-10101100b & 11110010b = 10100000b
-10101100b & 11110011b = 10100000b
-10101100b & 11110100b = 10100100b
-10101100b & 11110101b = 10100100b
-10101100b & 11110110b = 10100100b
-10101100b & 11110111b = 10100100b
-10101100b & 11111000b = 10101000b
-10101100b & 11111001b = 10101000b
-10101100b & 11111010b = 10101000b
-10101100b & 11111011b = 10101000b
-10101100b & 11111100b = 10101100b
-10101100b & 11111101b = 10101100b
-10101100b & 11111110b = 10101100b
-10101100b & 11111111b = 10101100b
-10101100b & 00000000b = 00000000b
-10101100b & 00000001b = 00000000b
-10101100b & 00000010b = 00000000b
-10101100b & 00000011b = 00000000b
-10101100b & 00000100b = 00000100b
-10101100b & 00000101b = 00000100b
-10101100b & 00000110b = 00000100b
-10101100b & 00000111b = 00000100b
-10101100b & 00001000b = 00001000b
-10101100b & 00001001b = 00001000b
-10101100b & 00001010b = 00001000b
-10101100b & 00001011b = 00001000b
-10101100b & 00001100b = 00001100b
-10101100b & 00001101b = 00001100b
-10101100b & 00001110b = 00001100b
-10101100b & 00001111b = 00001100b
-10101100b & 00010000b = 00000000b
-10101100b & 00010001b = 00000000b
-10101100b & 00010010b = 00000000b
-10101100b & 00010011b = 00000000b
-10101100b & 00010100b = 00000100b
-10101100b & 00010101b = 00000100b
-10101100b & 00010110b = 00000100b
-10101100b & 00010111b = 00000100b
-10101100b & 00011000b = 00001000b
-10101100b & 00011001b = 00001000b
-10101100b & 00011010b = 00001000b
-10101100b & 00011011b = 00001000b
-10101100b & 00011100b = 00001100b
-10101100b & 00011101b = 00001100b
-10101100b & 00011110b = 00001100b
-10101100b & 00011111b = 00001100b
-10101100b & 00100000b = 00100000b
-10101100b & 00100001b = 00100000b
-10101100b & 00100010b = 00100000b
-10101100b & 00100011b = 00100000b
-10101100b & 00100100b = 00100100b
-10101100b & 00100101b = 00100100b
-10101100b & 00100110b = 00100100b
-10101100b & 00100111b = 00100100b
-10101100b & 00101000b = 00101000b
-10101100b & 00101001b = 00101000b
-10101100b & 00101010b = 00101000b
-10101100b & 00101011b = 00101000b
-10101100b & 00101100b = 00101100b
-10101100b & 00101101b = 00101100b
-10101100b & 00101110b = 00101100b
-10101100b & 00101111b = 00101100b
-10101100b & 00110000b = 00100000b
-10101100b & 00110001b = 00100000b
-10101100b & 00110010b = 00100000b
-10101100b & 00110011b = 00100000b
-10101100b & 00110100b = 00100100b
-10101100b & 00110101b = 00100100b
-10101100b & 00110110b = 00100100b
-10101100b & 00110111b = 00100100b
-10101100b & 00111000b = 00101000b
-10101100b & 00111001b = 00101000b
-10101100b & 00111010b = 00101000b
-10101100b & 00111011b = 00101000b
-10101100b & 00111100b = 00101100b
-10101100b & 00111101b = 00101100b
-10101100b & 00111110b = 00101100b
-10101100b & 00111111b = 00101100b
-10101100b & 01000000b = 00000000b
-10101100b & 01000001b = 00000000b
-10101100b & 01000010b = 00000000b
-10101100b & 01000011b = 00000000b
-10101100b & 01000100b = 00000100b
-10101100b & 01000101b = 00000100b
-10101100b & 01000110b = 00000100b
-10101100b & 01000111b = 00000100b
-10101100b & 01001000b = 00001000b
-10101100b & 01001001b = 00001000b
-10101100b & 01001010b = 00001000b
-10101100b & 01001011b = 00001000b
-10101100b & 01001100b = 00001100b
-10101100b & 01001101b = 00001100b
-10101100b & 01001110b = 00001100b
-10101100b & 01001111b = 00001100b
-10101100b & 01010000b = 00000000b
-10101100b & 01010001b = 00000000b
-10101100b & 01010010b = 00000000b
-10101100b & 01010011b = 00000000b
-10101100b & 01010100b = 00000100b
-10101100b & 01010101b = 00000100b
-10101100b & 01010110b = 00000100b
-10101100b & 01010111b = 00000100b
-10101100b & 01011000b = 00001000b
-10101100b & 01011001b = 00001000b
-10101100b & 01011010b = 00001000b
-10101100b & 01011011b = 00001000b
-10101100b & 01011100b = 00001100b
-10101100b & 01011101b = 00001100b
-10101100b & 01011110b = 00001100b
-10101100b & 01011111b = 00001100b
-10101100b & 01100000b = 00100000b
-10101100b & 01100001b = 00100000b
-10101100b & 01100010b = 00100000b
-10101100b & 01100011b = 00100000b
-10101100b & 01100100b = 00100100b
-10101100b & 01100101b = 00100100b
-10101100b & 01100110b = 00100100b
-10101100b & 01100111b = 00100100b
-10101100b & 01101000b = 00101000b
-10101100b & 01101001b = 00101000b
-10101100b & 01101010b = 00101000b
-10101100b & 01101011b = 00101000b
-10101100b & 01101100b = 00101100b
-10101100b & 01101101b = 00101100b
-10101100b & 01101110b = 00101100b
-10101100b & 01101111b = 00101100b
-10101100b & 01110000b = 00100000b
-10101100b & 01110001b = 00100000b
-10101100b & 01110010b = 00100000b
-10101100b & 01110011b = 00100000b
-10101100b & 01110100b = 00100100b
-10101100b & 01110101b = 00100100b
-10101100b & 01110110b = 00100100b
-10101100b & 01110111b = 00100100b
-10101100b & 01111000b = 00101000b
-10101100b & 01111001b = 00101000b
-10101100b & 01111010b = 00101000b
-10101100b & 01111011b = 00101000b
-10101100b & 01111100b = 00101100b
-10101100b & 01111101b = 00101100b
-10101100b & 01111110b = 00101100b
-10101101b & 10000000b = 10000000b
-10101101b & 10000001b = 10000001b
-10101101b & 10000010b = 10000000b
-10101101b & 10000011b = 10000001b
-10101101b & 10000100b = 10000100b
-10101101b & 10000101b = 10000101b
-10101101b & 10000110b = 10000100b
-10101101b & 10000111b = 10000101b
-10101101b & 10001000b = 10001000b
-10101101b & 10001001b = 10001001b
-10101101b & 10001010b = 10001000b
-10101101b & 10001011b = 10001001b
-10101101b & 10001100b = 10001100b
-10101101b & 10001101b = 10001101b
-10101101b & 10001110b = 10001100b
-10101101b & 10001111b = 10001101b
-10101101b & 10010000b = 10000000b
-10101101b & 10010001b = 10000001b
-10101101b & 10010010b = 10000000b
-10101101b & 10010011b = 10000001b
-10101101b & 10010100b = 10000100b
-10101101b & 10010101b = 10000101b
-10101101b & 10010110b = 10000100b
-10101101b & 10010111b = 10000101b
-10101101b & 10011000b = 10001000b
-10101101b & 10011001b = 10001001b
-10101101b & 10011010b = 10001000b
-10101101b & 10011011b = 10001001b
-10101101b & 10011100b = 10001100b
-10101101b & 10011101b = 10001101b
-10101101b & 10011110b = 10001100b
-10101101b & 10011111b = 10001101b
-10101101b & 10100000b = 10100000b
-10101101b & 10100001b = 10100001b
-10101101b & 10100010b = 10100000b
-10101101b & 10100011b = 10100001b
-10101101b & 10100100b = 10100100b
-10101101b & 10100101b = 10100101b
-10101101b & 10100110b = 10100100b
-10101101b & 10100111b = 10100101b
-10101101b & 10101000b = 10101000b
-10101101b & 10101001b = 10101001b
-10101101b & 10101010b = 10101000b
-10101101b & 10101011b = 10101001b
-10101101b & 10101100b = 10101100b
-10101101b & 10101101b = 10101101b
-10101101b & 10101110b = 10101100b
-10101101b & 10101111b = 10101101b
-10101101b & 10110000b = 10100000b
-10101101b & 10110001b = 10100001b
-10101101b & 10110010b = 10100000b
-10101101b & 10110011b = 10100001b
-10101101b & 10110100b = 10100100b
-10101101b & 10110101b = 10100101b
-10101101b & 10110110b = 10100100b
-10101101b & 10110111b = 10100101b
-10101101b & 10111000b = 10101000b
-10101101b & 10111001b = 10101001b
-10101101b & 10111010b = 10101000b
-10101101b & 10111011b = 10101001b
-10101101b & 10111100b = 10101100b
-10101101b & 10111101b = 10101101b
-10101101b & 10111110b = 10101100b
-10101101b & 10111111b = 10101101b
-10101101b & 11000000b = 10000000b
-10101101b & 11000001b = 10000001b
-10101101b & 11000010b = 10000000b
-10101101b & 11000011b = 10000001b
-10101101b & 11000100b = 10000100b
-10101101b & 11000101b = 10000101b
-10101101b & 11000110b = 10000100b
-10101101b & 11000111b = 10000101b
-10101101b & 11001000b = 10001000b
-10101101b & 11001001b = 10001001b
-10101101b & 11001010b = 10001000b
-10101101b & 11001011b = 10001001b
-10101101b & 11001100b = 10001100b
-10101101b & 11001101b = 10001101b
-10101101b & 11001110b = 10001100b
-10101101b & 11001111b = 10001101b
-10101101b & 11010000b = 10000000b
-10101101b & 11010001b = 10000001b
-10101101b & 11010010b = 10000000b
-10101101b & 11010011b = 10000001b
-10101101b & 11010100b = 10000100b
-10101101b & 11010101b = 10000101b
-10101101b & 11010110b = 10000100b
-10101101b & 11010111b = 10000101b
-10101101b & 11011000b = 10001000b
-10101101b & 11011001b = 10001001b
-10101101b & 11011010b = 10001000b
-10101101b & 11011011b = 10001001b
-10101101b & 11011100b = 10001100b
-10101101b & 11011101b = 10001101b
-10101101b & 11011110b = 10001100b
-10101101b & 11011111b = 10001101b
-10101101b & 11100000b = 10100000b
-10101101b & 11100001b = 10100001b
-10101101b & 11100010b = 10100000b
-10101101b & 11100011b = 10100001b
-10101101b & 11100100b = 10100100b
-10101101b & 11100101b = 10100101b
-10101101b & 11100110b = 10100100b
-10101101b & 11100111b = 10100101b
-10101101b & 11101000b = 10101000b
-10101101b & 11101001b = 10101001b
-10101101b & 11101010b = 10101000b
-10101101b & 11101011b = 10101001b
-10101101b & 11101100b = 10101100b
-10101101b & 11101101b = 10101101b
-10101101b & 11101110b = 10101100b
-10101101b & 11101111b = 10101101b
-10101101b & 11110000b = 10100000b
-10101101b & 11110001b = 10100001b
-10101101b & 11110010b = 10100000b
-10101101b & 11110011b = 10100001b
-10101101b & 11110100b = 10100100b
-10101101b & 11110101b = 10100101b
-10101101b & 11110110b = 10100100b
-10101101b & 11110111b = 10100101b
-10101101b & 11111000b = 10101000b
-10101101b & 11111001b = 10101001b
-10101101b & 11111010b = 10101000b
-10101101b & 11111011b = 10101001b
-10101101b & 11111100b = 10101100b
-10101101b & 11111101b = 10101101b
-10101101b & 11111110b = 10101100b
-10101101b & 11111111b = 10101101b
-10101101b & 00000000b = 00000000b
-10101101b & 00000001b = 00000001b
-10101101b & 00000010b = 00000000b
-10101101b & 00000011b = 00000001b
-10101101b & 00000100b = 00000100b
-10101101b & 00000101b = 00000101b
-10101101b & 00000110b = 00000100b
-10101101b & 00000111b = 00000101b
-10101101b & 00001000b = 00001000b
-10101101b & 00001001b = 00001001b
-10101101b & 00001010b = 00001000b
-10101101b & 00001011b = 00001001b
-10101101b & 00001100b = 00001100b
-10101101b & 00001101b = 00001101b
-10101101b & 00001110b = 00001100b
-10101101b & 00001111b = 00001101b
-10101101b & 00010000b = 00000000b
-10101101b & 00010001b = 00000001b
-10101101b & 00010010b = 00000000b
-10101101b & 00010011b = 00000001b
-10101101b & 00010100b = 00000100b
-10101101b & 00010101b = 00000101b
-10101101b & 00010110b = 00000100b
-10101101b & 00010111b = 00000101b
-10101101b & 00011000b = 00001000b
-10101101b & 00011001b = 00001001b
-10101101b & 00011010b = 00001000b
-10101101b & 00011011b = 00001001b
-10101101b & 00011100b = 00001100b
-10101101b & 00011101b = 00001101b
-10101101b & 00011110b = 00001100b
-10101101b & 00011111b = 00001101b
-10101101b & 00100000b = 00100000b
-10101101b & 00100001b = 00100001b
-10101101b & 00100010b = 00100000b
-10101101b & 00100011b = 00100001b
-10101101b & 00100100b = 00100100b
-10101101b & 00100101b = 00100101b
-10101101b & 00100110b = 00100100b
-10101101b & 00100111b = 00100101b
-10101101b & 00101000b = 00101000b
-10101101b & 00101001b = 00101001b
-10101101b & 00101010b = 00101000b
-10101101b & 00101011b = 00101001b
-10101101b & 00101100b = 00101100b
-10101101b & 00101101b = 00101101b
-10101101b & 00101110b = 00101100b
-10101101b & 00101111b = 00101101b
-10101101b & 00110000b = 00100000b
-10101101b & 00110001b = 00100001b
-10101101b & 00110010b = 00100000b
-10101101b & 00110011b = 00100001b
-10101101b & 00110100b = 00100100b
-10101101b & 00110101b = 00100101b
-10101101b & 00110110b = 00100100b
-10101101b & 00110111b = 00100101b
-10101101b & 00111000b = 00101000b
-10101101b & 00111001b = 00101001b
-10101101b & 00111010b = 00101000b
-10101101b & 00111011b = 00101001b
-10101101b & 00111100b = 00101100b
-10101101b & 00111101b = 00101101b
-10101101b & 00111110b = 00101100b
-10101101b & 00111111b = 00101101b
-10101101b & 01000000b = 00000000b
-10101101b & 01000001b = 00000001b
-10101101b & 01000010b = 00000000b
-10101101b & 01000011b = 00000001b
-10101101b & 01000100b = 00000100b
-10101101b & 01000101b = 00000101b
-10101101b & 01000110b = 00000100b
-10101101b & 01000111b = 00000101b
-10101101b & 01001000b = 00001000b
-10101101b & 01001001b = 00001001b
-10101101b & 01001010b = 00001000b
-10101101b & 01001011b = 00001001b
-10101101b & 01001100b = 00001100b
-10101101b & 01001101b = 00001101b
-10101101b & 01001110b = 00001100b
-10101101b & 01001111b = 00001101b
-10101101b & 01010000b = 00000000b
-10101101b & 01010001b = 00000001b
-10101101b & 01010010b = 00000000b
-10101101b & 01010011b = 00000001b
-10101101b & 01010100b = 00000100b
-10101101b & 01010101b = 00000101b
-10101101b & 01010110b = 00000100b
-10101101b & 01010111b = 00000101b
-10101101b & 01011000b = 00001000b
-10101101b & 01011001b = 00001001b
-10101101b & 01011010b = 00001000b
-10101101b & 01011011b = 00001001b
-10101101b & 01011100b = 00001100b
-10101101b & 01011101b = 00001101b
-10101101b & 01011110b = 00001100b
-10101101b & 01011111b = 00001101b
-10101101b & 01100000b = 00100000b
-10101101b & 01100001b = 00100001b
-10101101b & 01100010b = 00100000b
-10101101b & 01100011b = 00100001b
-10101101b & 01100100b = 00100100b
-10101101b & 01100101b = 00100101b
-10101101b & 01100110b = 00100100b
-10101101b & 01100111b = 00100101b
-10101101b & 01101000b = 00101000b
-10101101b & 01101001b = 00101001b
-10101101b & 01101010b = 00101000b
-10101101b & 01101011b = 00101001b
-10101101b & 01101100b = 00101100b
-10101101b & 01101101b = 00101101b
-10101101b & 01101110b = 00101100b
-10101101b & 01101111b = 00101101b
-10101101b & 01110000b = 00100000b
-10101101b & 01110001b = 00100001b
-10101101b & 01110010b = 00100000b
-10101101b & 01110011b = 00100001b
-10101101b & 01110100b = 00100100b
-10101101b & 01110101b = 00100101b
-10101101b & 01110110b = 00100100b
-10101101b & 01110111b = 00100101b
-10101101b & 01111000b = 00101000b
-10101101b & 01111001b = 00101001b
-10101101b & 01111010b = 00101000b
-10101101b & 01111011b = 00101001b
-10101101b & 01111100b = 00101100b
-10101101b & 01111101b = 00101101b
-10101101b & 01111110b = 00101100b
-10101110b & 10000000b = 10000000b
-10101110b & 10000001b = 10000000b
-10101110b & 10000010b = 10000010b
-10101110b & 10000011b = 10000010b
-10101110b & 10000100b = 10000100b
-10101110b & 10000101b = 10000100b
-10101110b & 10000110b = 10000110b
-10101110b & 10000111b = 10000110b
-10101110b & 10001000b = 10001000b
-10101110b & 10001001b = 10001000b
-10101110b & 10001010b = 10001010b
-10101110b & 10001011b = 10001010b
-10101110b & 10001100b = 10001100b
-10101110b & 10001101b = 10001100b
-10101110b & 10001110b = 10001110b
-10101110b & 10001111b = 10001110b
-10101110b & 10010000b = 10000000b
-10101110b & 10010001b = 10000000b
-10101110b & 10010010b = 10000010b
-10101110b & 10010011b = 10000010b
-10101110b & 10010100b = 10000100b
-10101110b & 10010101b = 10000100b
-10101110b & 10010110b = 10000110b
-10101110b & 10010111b = 10000110b
-10101110b & 10011000b = 10001000b
-10101110b & 10011001b = 10001000b
-10101110b & 10011010b = 10001010b
-10101110b & 10011011b = 10001010b
-10101110b & 10011100b = 10001100b
-10101110b & 10011101b = 10001100b
-10101110b & 10011110b = 10001110b
-10101110b & 10011111b = 10001110b
-10101110b & 10100000b = 10100000b
-10101110b & 10100001b = 10100000b
-10101110b & 10100010b = 10100010b
-10101110b & 10100011b = 10100010b
-10101110b & 10100100b = 10100100b
-10101110b & 10100101b = 10100100b
-10101110b & 10100110b = 10100110b
-10101110b & 10100111b = 10100110b
-10101110b & 10101000b = 10101000b
-10101110b & 10101001b = 10101000b
-10101110b & 10101010b = 10101010b
-10101110b & 10101011b = 10101010b
-10101110b & 10101100b = 10101100b
-10101110b & 10101101b = 10101100b
-10101110b & 10101110b = 10101110b
-10101110b & 10101111b = 10101110b
-10101110b & 10110000b = 10100000b
-10101110b & 10110001b = 10100000b
-10101110b & 10110010b = 10100010b
-10101110b & 10110011b = 10100010b
-10101110b & 10110100b = 10100100b
-10101110b & 10110101b = 10100100b
-10101110b & 10110110b = 10100110b
-10101110b & 10110111b = 10100110b
-10101110b & 10111000b = 10101000b
-10101110b & 10111001b = 10101000b
-10101110b & 10111010b = 10101010b
-10101110b & 10111011b = 10101010b
-10101110b & 10111100b = 10101100b
-10101110b & 10111101b = 10101100b
-10101110b & 10111110b = 10101110b
-10101110b & 10111111b = 10101110b
-10101110b & 11000000b = 10000000b
-10101110b & 11000001b = 10000000b
-10101110b & 11000010b = 10000010b
-10101110b & 11000011b = 10000010b
-10101110b & 11000100b = 10000100b
-10101110b & 11000101b = 10000100b
-10101110b & 11000110b = 10000110b
-10101110b & 11000111b = 10000110b
-10101110b & 11001000b = 10001000b
-10101110b & 11001001b = 10001000b
-10101110b & 11001010b = 10001010b
-10101110b & 11001011b = 10001010b
-10101110b & 11001100b = 10001100b
-10101110b & 11001101b = 10001100b
-10101110b & 11001110b = 10001110b
-10101110b & 11001111b = 10001110b
-10101110b & 11010000b = 10000000b
-10101110b & 11010001b = 10000000b
-10101110b & 11010010b = 10000010b
-10101110b & 11010011b = 10000010b
-10101110b & 11010100b = 10000100b
-10101110b & 11010101b = 10000100b
-10101110b & 11010110b = 10000110b
-10101110b & 11010111b = 10000110b
-10101110b & 11011000b = 10001000b
-10101110b & 11011001b = 10001000b
-10101110b & 11011010b = 10001010b
-10101110b & 11011011b = 10001010b
-10101110b & 11011100b = 10001100b
-10101110b & 11011101b = 10001100b
-10101110b & 11011110b = 10001110b
-10101110b & 11011111b = 10001110b
-10101110b & 11100000b = 10100000b
-10101110b & 11100001b = 10100000b
-10101110b & 11100010b = 10100010b
-10101110b & 11100011b = 10100010b
-10101110b & 11100100b = 10100100b
-10101110b & 11100101b = 10100100b
-10101110b & 11100110b = 10100110b
-10101110b & 11100111b = 10100110b
-10101110b & 11101000b = 10101000b
-10101110b & 11101001b = 10101000b
-10101110b & 11101010b = 10101010b
-10101110b & 11101011b = 10101010b
-10101110b & 11101100b = 10101100b
-10101110b & 11101101b = 10101100b
-10101110b & 11101110b = 10101110b
-10101110b & 11101111b = 10101110b
-10101110b & 11110000b = 10100000b
-10101110b & 11110001b = 10100000b
-10101110b & 11110010b = 10100010b
-10101110b & 11110011b = 10100010b
-10101110b & 11110100b = 10100100b
-10101110b & 11110101b = 10100100b
-10101110b & 11110110b = 10100110b
-10101110b & 11110111b = 10100110b
-10101110b & 11111000b = 10101000b
-10101110b & 11111001b = 10101000b
-10101110b & 11111010b = 10101010b
-10101110b & 11111011b = 10101010b
-10101110b & 11111100b = 10101100b
-10101110b & 11111101b = 10101100b
-10101110b & 11111110b = 10101110b
-10101110b & 11111111b = 10101110b
-10101110b & 00000000b = 00000000b
-10101110b & 00000001b = 00000000b
-10101110b & 00000010b = 00000010b
-10101110b & 00000011b = 00000010b
-10101110b & 00000100b = 00000100b
-10101110b & 00000101b = 00000100b
-10101110b & 00000110b = 00000110b
-10101110b & 00000111b = 00000110b
-10101110b & 00001000b = 00001000b
-10101110b & 00001001b = 00001000b
-10101110b & 00001010b = 00001010b
-10101110b & 00001011b = 00001010b
-10101110b & 00001100b = 00001100b
-10101110b & 00001101b = 00001100b
-10101110b & 00001110b = 00001110b
-10101110b & 00001111b = 00001110b
-10101110b & 00010000b = 00000000b
-10101110b & 00010001b = 00000000b
-10101110b & 00010010b = 00000010b
-10101110b & 00010011b = 00000010b
-10101110b & 00010100b = 00000100b
-10101110b & 00010101b = 00000100b
-10101110b & 00010110b = 00000110b
-10101110b & 00010111b = 00000110b
-10101110b & 00011000b = 00001000b
-10101110b & 00011001b = 00001000b
-10101110b & 00011010b = 00001010b
-10101110b & 00011011b = 00001010b
-10101110b & 00011100b = 00001100b
-10101110b & 00011101b = 00001100b
-10101110b & 00011110b = 00001110b
-10101110b & 00011111b = 00001110b
-10101110b & 00100000b = 00100000b
-10101110b & 00100001b = 00100000b
-10101110b & 00100010b = 00100010b
-10101110b & 00100011b = 00100010b
-10101110b & 00100100b = 00100100b
-10101110b & 00100101b = 00100100b
-10101110b & 00100110b = 00100110b
-10101110b & 00100111b = 00100110b
-10101110b & 00101000b = 00101000b
-10101110b & 00101001b = 00101000b
-10101110b & 00101010b = 00101010b
-10101110b & 00101011b = 00101010b
-10101110b & 00101100b = 00101100b
-10101110b & 00101101b = 00101100b
-10101110b & 00101110b = 00101110b
-10101110b & 00101111b = 00101110b
-10101110b & 00110000b = 00100000b
-10101110b & 00110001b = 00100000b
-10101110b & 00110010b = 00100010b
-10101110b & 00110011b = 00100010b
-10101110b & 00110100b = 00100100b
-10101110b & 00110101b = 00100100b
-10101110b & 00110110b = 00100110b
-10101110b & 00110111b = 00100110b
-10101110b & 00111000b = 00101000b
-10101110b & 00111001b = 00101000b
-10101110b & 00111010b = 00101010b
-10101110b & 00111011b = 00101010b
-10101110b & 00111100b = 00101100b
-10101110b & 00111101b = 00101100b
-10101110b & 00111110b = 00101110b
-10101110b & 00111111b = 00101110b
-10101110b & 01000000b = 00000000b
-10101110b & 01000001b = 00000000b
-10101110b & 01000010b = 00000010b
-10101110b & 01000011b = 00000010b
-10101110b & 01000100b = 00000100b
-10101110b & 01000101b = 00000100b
-10101110b & 01000110b = 00000110b
-10101110b & 01000111b = 00000110b
-10101110b & 01001000b = 00001000b
-10101110b & 01001001b = 00001000b
-10101110b & 01001010b = 00001010b
-10101110b & 01001011b = 00001010b
-10101110b & 01001100b = 00001100b
-10101110b & 01001101b = 00001100b
-10101110b & 01001110b = 00001110b
-10101110b & 01001111b = 00001110b
-10101110b & 01010000b = 00000000b
-10101110b & 01010001b = 00000000b
-10101110b & 01010010b = 00000010b
-10101110b & 01010011b = 00000010b
-10101110b & 01010100b = 00000100b
-10101110b & 01010101b = 00000100b
-10101110b & 01010110b = 00000110b
-10101110b & 01010111b = 00000110b
-10101110b & 01011000b = 00001000b
-10101110b & 01011001b = 00001000b
-10101110b & 01011010b = 00001010b
-10101110b & 01011011b = 00001010b
-10101110b & 01011100b = 00001100b
-10101110b & 01011101b = 00001100b
-10101110b & 01011110b = 00001110b
-10101110b & 01011111b = 00001110b
-10101110b & 01100000b = 00100000b
-10101110b & 01100001b = 00100000b
-10101110b & 01100010b = 00100010b
-10101110b & 01100011b = 00100010b
-10101110b & 01100100b = 00100100b
-10101110b & 01100101b = 00100100b
-10101110b & 01100110b = 00100110b
-10101110b & 01100111b = 00100110b
-10101110b & 01101000b = 00101000b
-10101110b & 01101001b = 00101000b
-10101110b & 01101010b = 00101010b
-10101110b & 01101011b = 00101010b
-10101110b & 01101100b = 00101100b
-10101110b & 01101101b = 00101100b
-10101110b & 01101110b = 00101110b
-10101110b & 01101111b = 00101110b
-10101110b & 01110000b = 00100000b
-10101110b & 01110001b = 00100000b
-10101110b & 01110010b = 00100010b
-10101110b & 01110011b = 00100010b
-10101110b & 01110100b = 00100100b
-10101110b & 01110101b = 00100100b
-10101110b & 01110110b = 00100110b
-10101110b & 01110111b = 00100110b
-10101110b & 01111000b = 00101000b
-10101110b & 01111001b = 00101000b
-10101110b & 01111010b = 00101010b
-10101110b & 01111011b = 00101010b
-10101110b & 01111100b = 00101100b
-10101110b & 01111101b = 00101100b
-10101110b & 01111110b = 00101110b
-10101111b & 10000000b = 10000000b
-10101111b & 10000001b = 10000001b
-10101111b & 10000010b = 10000010b
-10101111b & 10000011b = 10000011b
-10101111b & 10000100b = 10000100b
-10101111b & 10000101b = 10000101b
-10101111b & 10000110b = 10000110b
-10101111b & 10000111b = 10000111b
-10101111b & 10001000b = 10001000b
-10101111b & 10001001b = 10001001b
-10101111b & 10001010b = 10001010b
-10101111b & 10001011b = 10001011b
-10101111b & 10001100b = 10001100b
-10101111b & 10001101b = 10001101b
-10101111b & 10001110b = 10001110b
-10101111b & 10001111b = 10001111b
-10101111b & 10010000b = 10000000b
-10101111b & 10010001b = 10000001b
-10101111b & 10010010b = 10000010b
-10101111b & 10010011b = 10000011b
-10101111b & 10010100b = 10000100b
-10101111b & 10010101b = 10000101b
-10101111b & 10010110b = 10000110b
-10101111b & 10010111b = 10000111b
-10101111b & 10011000b = 10001000b
-10101111b & 10011001b = 10001001b
-10101111b & 10011010b = 10001010b
-10101111b & 10011011b = 10001011b
-10101111b & 10011100b = 10001100b
-10101111b & 10011101b = 10001101b
-10101111b & 10011110b = 10001110b
-10101111b & 10011111b = 10001111b
-10101111b & 10100000b = 10100000b
-10101111b & 10100001b = 10100001b
-10101111b & 10100010b = 10100010b
-10101111b & 10100011b = 10100011b
-10101111b & 10100100b = 10100100b
-10101111b & 10100101b = 10100101b
-10101111b & 10100110b = 10100110b
-10101111b & 10100111b = 10100111b
-10101111b & 10101000b = 10101000b
-10101111b & 10101001b = 10101001b
-10101111b & 10101010b = 10101010b
-10101111b & 10101011b = 10101011b
-10101111b & 10101100b = 10101100b
-10101111b & 10101101b = 10101101b
-10101111b & 10101110b = 10101110b
-10101111b & 10101111b = 10101111b
-10101111b & 10110000b = 10100000b
-10101111b & 10110001b = 10100001b
-10101111b & 10110010b = 10100010b
-10101111b & 10110011b = 10100011b
-10101111b & 10110100b = 10100100b
-10101111b & 10110101b = 10100101b
-10101111b & 10110110b = 10100110b
-10101111b & 10110111b = 10100111b
-10101111b & 10111000b = 10101000b
-10101111b & 10111001b = 10101001b
-10101111b & 10111010b = 10101010b
-10101111b & 10111011b = 10101011b
-10101111b & 10111100b = 10101100b
-10101111b & 10111101b = 10101101b
-10101111b & 10111110b = 10101110b
-10101111b & 10111111b = 10101111b
-10101111b & 11000000b = 10000000b
-10101111b & 11000001b = 10000001b
-10101111b & 11000010b = 10000010b
-10101111b & 11000011b = 10000011b
-10101111b & 11000100b = 10000100b
-10101111b & 11000101b = 10000101b
-10101111b & 11000110b = 10000110b
-10101111b & 11000111b = 10000111b
-10101111b & 11001000b = 10001000b
-10101111b & 11001001b = 10001001b
-10101111b & 11001010b = 10001010b
-10101111b & 11001011b = 10001011b
-10101111b & 11001100b = 10001100b
-10101111b & 11001101b = 10001101b
-10101111b & 11001110b = 10001110b
-10101111b & 11001111b = 10001111b
-10101111b & 11010000b = 10000000b
-10101111b & 11010001b = 10000001b
-10101111b & 11010010b = 10000010b
-10101111b & 11010011b = 10000011b
-10101111b & 11010100b = 10000100b
-10101111b & 11010101b = 10000101b
-10101111b & 11010110b = 10000110b
-10101111b & 11010111b = 10000111b
-10101111b & 11011000b = 10001000b
-10101111b & 11011001b = 10001001b
-10101111b & 11011010b = 10001010b
-10101111b & 11011011b = 10001011b
-10101111b & 11011100b = 10001100b
-10101111b & 11011101b = 10001101b
-10101111b & 11011110b = 10001110b
-10101111b & 11011111b = 10001111b
-10101111b & 11100000b = 10100000b
-10101111b & 11100001b = 10100001b
-10101111b & 11100010b = 10100010b
-10101111b & 11100011b = 10100011b
-10101111b & 11100100b = 10100100b
-10101111b & 11100101b = 10100101b
-10101111b & 11100110b = 10100110b
-10101111b & 11100111b = 10100111b
-10101111b & 11101000b = 10101000b
-10101111b & 11101001b = 10101001b
-10101111b & 11101010b = 10101010b
-10101111b & 11101011b = 10101011b
-10101111b & 11101100b = 10101100b
-10101111b & 11101101b = 10101101b
-10101111b & 11101110b = 10101110b
-10101111b & 11101111b = 10101111b
-10101111b & 11110000b = 10100000b
-10101111b & 11110001b = 10100001b
-10101111b & 11110010b = 10100010b
-10101111b & 11110011b = 10100011b
-10101111b & 11110100b = 10100100b
-10101111b & 11110101b = 10100101b
-10101111b & 11110110b = 10100110b
-10101111b & 11110111b = 10100111b
-10101111b & 11111000b = 10101000b
-10101111b & 11111001b = 10101001b
-10101111b & 11111010b = 10101010b
-10101111b & 11111011b = 10101011b
-10101111b & 11111100b = 10101100b
-10101111b & 11111101b = 10101101b
-10101111b & 11111110b = 10101110b
-10101111b & 11111111b = 10101111b
-10101111b & 00000000b = 00000000b
-10101111b & 00000001b = 00000001b
-10101111b & 00000010b = 00000010b
-10101111b & 00000011b = 00000011b
-10101111b & 00000100b = 00000100b
-10101111b & 00000101b = 00000101b
-10101111b & 00000110b = 00000110b
-10101111b & 00000111b = 00000111b
-10101111b & 00001000b = 00001000b
-10101111b & 00001001b = 00001001b
-10101111b & 00001010b = 00001010b
-10101111b & 00001011b = 00001011b
-10101111b & 00001100b = 00001100b
-10101111b & 00001101b = 00001101b
-10101111b & 00001110b = 00001110b
-10101111b & 00001111b = 00001111b
-10101111b & 00010000b = 00000000b
-10101111b & 00010001b = 00000001b
-10101111b & 00010010b = 00000010b
-10101111b & 00010011b = 00000011b
-10101111b & 00010100b = 00000100b
-10101111b & 00010101b = 00000101b
-10101111b & 00010110b = 00000110b
-10101111b & 00010111b = 00000111b
-10101111b & 00011000b = 00001000b
-10101111b & 00011001b = 00001001b
-10101111b & 00011010b = 00001010b
-10101111b & 00011011b = 00001011b
-10101111b & 00011100b = 00001100b
-10101111b & 00011101b = 00001101b
-10101111b & 00011110b = 00001110b
-10101111b & 00011111b = 00001111b
-10101111b & 00100000b = 00100000b
-10101111b & 00100001b = 00100001b
-10101111b & 00100010b = 00100010b
-10101111b & 00100011b = 00100011b
-10101111b & 00100100b = 00100100b
-10101111b & 00100101b = 00100101b
-10101111b & 00100110b = 00100110b
-10101111b & 00100111b = 00100111b
-10101111b & 00101000b = 00101000b
-10101111b & 00101001b = 00101001b
-10101111b & 00101010b = 00101010b
-10101111b & 00101011b = 00101011b
-10101111b & 00101100b = 00101100b
-10101111b & 00101101b = 00101101b
-10101111b & 00101110b = 00101110b
-10101111b & 00101111b = 00101111b
-10101111b & 00110000b = 00100000b
-10101111b & 00110001b = 00100001b
-10101111b & 00110010b = 00100010b
-10101111b & 00110011b = 00100011b
-10101111b & 00110100b = 00100100b
-10101111b & 00110101b = 00100101b
-10101111b & 00110110b = 00100110b
-10101111b & 00110111b = 00100111b
-10101111b & 00111000b = 00101000b
-10101111b & 00111001b = 00101001b
-10101111b & 00111010b = 00101010b
-10101111b & 00111011b = 00101011b
-10101111b & 00111100b = 00101100b
-10101111b & 00111101b = 00101101b
-10101111b & 00111110b = 00101110b
-10101111b & 00111111b = 00101111b
-10101111b & 01000000b = 00000000b
-10101111b & 01000001b = 00000001b
-10101111b & 01000010b = 00000010b
-10101111b & 01000011b = 00000011b
-10101111b & 01000100b = 00000100b
-10101111b & 01000101b = 00000101b
-10101111b & 01000110b = 00000110b
-10101111b & 01000111b = 00000111b
-10101111b & 01001000b = 00001000b
-10101111b & 01001001b = 00001001b
-10101111b & 01001010b = 00001010b
-10101111b & 01001011b = 00001011b
-10101111b & 01001100b = 00001100b
-10101111b & 01001101b = 00001101b
-10101111b & 01001110b = 00001110b
-10101111b & 01001111b = 00001111b
-10101111b & 01010000b = 00000000b
-10101111b & 01010001b = 00000001b
-10101111b & 01010010b = 00000010b
-10101111b & 01010011b = 00000011b
-10101111b & 01010100b = 00000100b
-10101111b & 01010101b = 00000101b
-10101111b & 01010110b = 00000110b
-10101111b & 01010111b = 00000111b
-10101111b & 01011000b = 00001000b
-10101111b & 01011001b = 00001001b
-10101111b & 01011010b = 00001010b
-10101111b & 01011011b = 00001011b
-10101111b & 01011100b = 00001100b
-10101111b & 01011101b = 00001101b
-10101111b & 01011110b = 00001110b
-10101111b & 01011111b = 00001111b
-10101111b & 01100000b = 00100000b
-10101111b & 01100001b = 00100001b
-10101111b & 01100010b = 00100010b
-10101111b & 01100011b = 00100011b
-10101111b & 01100100b = 00100100b
-10101111b & 01100101b = 00100101b
-10101111b & 01100110b = 00100110b
-10101111b & 01100111b = 00100111b
-10101111b & 01101000b = 00101000b
-10101111b & 01101001b = 00101001b
-10101111b & 01101010b = 00101010b
-10101111b & 01101011b = 00101011b
-10101111b & 01101100b = 00101100b
-10101111b & 01101101b = 00101101b
-10101111b & 01101110b = 00101110b
-10101111b & 01101111b = 00101111b
-10101111b & 01110000b = 00100000b
-10101111b & 01110001b = 00100001b
-10101111b & 01110010b = 00100010b
-10101111b & 01110011b = 00100011b
-10101111b & 01110100b = 00100100b
-10101111b & 01110101b = 00100101b
-10101111b & 01110110b = 00100110b
-10101111b & 01110111b = 00100111b
-10101111b & 01111000b = 00101000b
-10101111b & 01111001b = 00101001b
-10101111b & 01111010b = 00101010b
-10101111b & 01111011b = 00101011b
-10101111b & 01111100b = 00101100b
-10101111b & 01111101b = 00101101b
-10101111b & 01111110b = 00101110b
-10110000b & 10000000b = 10000000b
-10110000b & 10000001b = 10000000b
-10110000b & 10000010b = 10000000b
-10110000b & 10000011b = 10000000b
-10110000b & 10000100b = 10000000b
-10110000b & 10000101b = 10000000b
-10110000b & 10000110b = 10000000b
-10110000b & 10000111b = 10000000b
-10110000b & 10001000b = 10000000b
-10110000b & 10001001b = 10000000b
-10110000b & 10001010b = 10000000b
-10110000b & 10001011b = 10000000b
-10110000b & 10001100b = 10000000b
-10110000b & 10001101b = 10000000b
-10110000b & 10001110b = 10000000b
-10110000b & 10001111b = 10000000b
-10110000b & 10010000b = 10010000b
-10110000b & 10010001b = 10010000b
-10110000b & 10010010b = 10010000b
-10110000b & 10010011b = 10010000b
-10110000b & 10010100b = 10010000b
-10110000b & 10010101b = 10010000b
-10110000b & 10010110b = 10010000b
-10110000b & 10010111b = 10010000b
-10110000b & 10011000b = 10010000b
-10110000b & 10011001b = 10010000b
-10110000b & 10011010b = 10010000b
-10110000b & 10011011b = 10010000b
-10110000b & 10011100b = 10010000b
-10110000b & 10011101b = 10010000b
-10110000b & 10011110b = 10010000b
-10110000b & 10011111b = 10010000b
-10110000b & 10100000b = 10100000b
-10110000b & 10100001b = 10100000b
-10110000b & 10100010b = 10100000b
-10110000b & 10100011b = 10100000b
-10110000b & 10100100b = 10100000b
-10110000b & 10100101b = 10100000b
-10110000b & 10100110b = 10100000b
-10110000b & 10100111b = 10100000b
-10110000b & 10101000b = 10100000b
-10110000b & 10101001b = 10100000b
-10110000b & 10101010b = 10100000b
-10110000b & 10101011b = 10100000b
-10110000b & 10101100b = 10100000b
-10110000b & 10101101b = 10100000b
-10110000b & 10101110b = 10100000b
-10110000b & 10101111b = 10100000b
-10110000b & 10110000b = 10110000b
-10110000b & 10110001b = 10110000b
-10110000b & 10110010b = 10110000b
-10110000b & 10110011b = 10110000b
-10110000b & 10110100b = 10110000b
-10110000b & 10110101b = 10110000b
-10110000b & 10110110b = 10110000b
-10110000b & 10110111b = 10110000b
-10110000b & 10111000b = 10110000b
-10110000b & 10111001b = 10110000b
-10110000b & 10111010b = 10110000b
-10110000b & 10111011b = 10110000b
-10110000b & 10111100b = 10110000b
-10110000b & 10111101b = 10110000b
-10110000b & 10111110b = 10110000b
-10110000b & 10111111b = 10110000b
-10110000b & 11000000b = 10000000b
-10110000b & 11000001b = 10000000b
-10110000b & 11000010b = 10000000b
-10110000b & 11000011b = 10000000b
-10110000b & 11000100b = 10000000b
-10110000b & 11000101b = 10000000b
-10110000b & 11000110b = 10000000b
-10110000b & 11000111b = 10000000b
-10110000b & 11001000b = 10000000b
-10110000b & 11001001b = 10000000b
-10110000b & 11001010b = 10000000b
-10110000b & 11001011b = 10000000b
-10110000b & 11001100b = 10000000b
-10110000b & 11001101b = 10000000b
-10110000b & 11001110b = 10000000b
-10110000b & 11001111b = 10000000b
-10110000b & 11010000b = 10010000b
-10110000b & 11010001b = 10010000b
-10110000b & 11010010b = 10010000b
-10110000b & 11010011b = 10010000b
-10110000b & 11010100b = 10010000b
-10110000b & 11010101b = 10010000b
-10110000b & 11010110b = 10010000b
-10110000b & 11010111b = 10010000b
-10110000b & 11011000b = 10010000b
-10110000b & 11011001b = 10010000b
-10110000b & 11011010b = 10010000b
-10110000b & 11011011b = 10010000b
-10110000b & 11011100b = 10010000b
-10110000b & 11011101b = 10010000b
-10110000b & 11011110b = 10010000b
-10110000b & 11011111b = 10010000b
-10110000b & 11100000b = 10100000b
-10110000b & 11100001b = 10100000b
-10110000b & 11100010b = 10100000b
-10110000b & 11100011b = 10100000b
-10110000b & 11100100b = 10100000b
-10110000b & 11100101b = 10100000b
-10110000b & 11100110b = 10100000b
-10110000b & 11100111b = 10100000b
-10110000b & 11101000b = 10100000b
-10110000b & 11101001b = 10100000b
-10110000b & 11101010b = 10100000b
-10110000b & 11101011b = 10100000b
-10110000b & 11101100b = 10100000b
-10110000b & 11101101b = 10100000b
-10110000b & 11101110b = 10100000b
-10110000b & 11101111b = 10100000b
-10110000b & 11110000b = 10110000b
-10110000b & 11110001b = 10110000b
-10110000b & 11110010b = 10110000b
-10110000b & 11110011b = 10110000b
-10110000b & 11110100b = 10110000b
-10110000b & 11110101b = 10110000b
-10110000b & 11110110b = 10110000b
-10110000b & 11110111b = 10110000b
-10110000b & 11111000b = 10110000b
-10110000b & 11111001b = 10110000b
-10110000b & 11111010b = 10110000b
-10110000b & 11111011b = 10110000b
-10110000b & 11111100b = 10110000b
-10110000b & 11111101b = 10110000b
-10110000b & 11111110b = 10110000b
-10110000b & 11111111b = 10110000b
-10110000b & 00000000b = 00000000b
-10110000b & 00000001b = 00000000b
-10110000b & 00000010b = 00000000b
-10110000b & 00000011b = 00000000b
-10110000b & 00000100b = 00000000b
-10110000b & 00000101b = 00000000b
-10110000b & 00000110b = 00000000b
-10110000b & 00000111b = 00000000b
-10110000b & 00001000b = 00000000b
-10110000b & 00001001b = 00000000b
-10110000b & 00001010b = 00000000b
-10110000b & 00001011b = 00000000b
-10110000b & 00001100b = 00000000b
-10110000b & 00001101b = 00000000b
-10110000b & 00001110b = 00000000b
-10110000b & 00001111b = 00000000b
-10110000b & 00010000b = 00010000b
-10110000b & 00010001b = 00010000b
-10110000b & 00010010b = 00010000b
-10110000b & 00010011b = 00010000b
-10110000b & 00010100b = 00010000b
-10110000b & 00010101b = 00010000b
-10110000b & 00010110b = 00010000b
-10110000b & 00010111b = 00010000b
-10110000b & 00011000b = 00010000b
-10110000b & 00011001b = 00010000b
-10110000b & 00011010b = 00010000b
-10110000b & 00011011b = 00010000b
-10110000b & 00011100b = 00010000b
-10110000b & 00011101b = 00010000b
-10110000b & 00011110b = 00010000b
-10110000b & 00011111b = 00010000b
-10110000b & 00100000b = 00100000b
-10110000b & 00100001b = 00100000b
-10110000b & 00100010b = 00100000b
-10110000b & 00100011b = 00100000b
-10110000b & 00100100b = 00100000b
-10110000b & 00100101b = 00100000b
-10110000b & 00100110b = 00100000b
-10110000b & 00100111b = 00100000b
-10110000b & 00101000b = 00100000b
-10110000b & 00101001b = 00100000b
-10110000b & 00101010b = 00100000b
-10110000b & 00101011b = 00100000b
-10110000b & 00101100b = 00100000b
-10110000b & 00101101b = 00100000b
-10110000b & 00101110b = 00100000b
-10110000b & 00101111b = 00100000b
-10110000b & 00110000b = 00110000b
-10110000b & 00110001b = 00110000b
-10110000b & 00110010b = 00110000b
-10110000b & 00110011b = 00110000b
-10110000b & 00110100b = 00110000b
-10110000b & 00110101b = 00110000b
-10110000b & 00110110b = 00110000b
-10110000b & 00110111b = 00110000b
-10110000b & 00111000b = 00110000b
-10110000b & 00111001b = 00110000b
-10110000b & 00111010b = 00110000b
-10110000b & 00111011b = 00110000b
-10110000b & 00111100b = 00110000b
-10110000b & 00111101b = 00110000b
-10110000b & 00111110b = 00110000b
-10110000b & 00111111b = 00110000b
-10110000b & 01000000b = 00000000b
-10110000b & 01000001b = 00000000b
-10110000b & 01000010b = 00000000b
-10110000b & 01000011b = 00000000b
-10110000b & 01000100b = 00000000b
-10110000b & 01000101b = 00000000b
-10110000b & 01000110b = 00000000b
-10110000b & 01000111b = 00000000b
-10110000b & 01001000b = 00000000b
-10110000b & 01001001b = 00000000b
-10110000b & 01001010b = 00000000b
-10110000b & 01001011b = 00000000b
-10110000b & 01001100b = 00000000b
-10110000b & 01001101b = 00000000b
-10110000b & 01001110b = 00000000b
-10110000b & 01001111b = 00000000b
-10110000b & 01010000b = 00010000b
-10110000b & 01010001b = 00010000b
-10110000b & 01010010b = 00010000b
-10110000b & 01010011b = 00010000b
-10110000b & 01010100b = 00010000b
-10110000b & 01010101b = 00010000b
-10110000b & 01010110b = 00010000b
-10110000b & 01010111b = 00010000b
-10110000b & 01011000b = 00010000b
-10110000b & 01011001b = 00010000b
-10110000b & 01011010b = 00010000b
-10110000b & 01011011b = 00010000b
-10110000b & 01011100b = 00010000b
-10110000b & 01011101b = 00010000b
-10110000b & 01011110b = 00010000b
-10110000b & 01011111b = 00010000b
-10110000b & 01100000b = 00100000b
-10110000b & 01100001b = 00100000b
-10110000b & 01100010b = 00100000b
-10110000b & 01100011b = 00100000b
-10110000b & 01100100b = 00100000b
-10110000b & 01100101b = 00100000b
-10110000b & 01100110b = 00100000b
-10110000b & 01100111b = 00100000b
-10110000b & 01101000b = 00100000b
-10110000b & 01101001b = 00100000b
-10110000b & 01101010b = 00100000b
-10110000b & 01101011b = 00100000b
-10110000b & 01101100b = 00100000b
-10110000b & 01101101b = 00100000b
-10110000b & 01101110b = 00100000b
-10110000b & 01101111b = 00100000b
-10110000b & 01110000b = 00110000b
-10110000b & 01110001b = 00110000b
-10110000b & 01110010b = 00110000b
-10110000b & 01110011b = 00110000b
-10110000b & 01110100b = 00110000b
-10110000b & 01110101b = 00110000b
-10110000b & 01110110b = 00110000b
-10110000b & 01110111b = 00110000b
-10110000b & 01111000b = 00110000b
-10110000b & 01111001b = 00110000b
-10110000b & 01111010b = 00110000b
-10110000b & 01111011b = 00110000b
-10110000b & 01111100b = 00110000b
-10110000b & 01111101b = 00110000b
-10110000b & 01111110b = 00110000b
-10110001b & 10000000b = 10000000b
-10110001b & 10000001b = 10000001b
-10110001b & 10000010b = 10000000b
-10110001b & 10000011b = 10000001b
-10110001b & 10000100b = 10000000b
-10110001b & 10000101b = 10000001b
-10110001b & 10000110b = 10000000b
-10110001b & 10000111b = 10000001b
-10110001b & 10001000b = 10000000b
-10110001b & 10001001b = 10000001b
-10110001b & 10001010b = 10000000b
-10110001b & 10001011b = 10000001b
-10110001b & 10001100b = 10000000b
-10110001b & 10001101b = 10000001b
-10110001b & 10001110b = 10000000b
-10110001b & 10001111b = 10000001b
-10110001b & 10010000b = 10010000b
-10110001b & 10010001b = 10010001b
-10110001b & 10010010b = 10010000b
-10110001b & 10010011b = 10010001b
-10110001b & 10010100b = 10010000b
-10110001b & 10010101b = 10010001b
-10110001b & 10010110b = 10010000b
-10110001b & 10010111b = 10010001b
-10110001b & 10011000b = 10010000b
-10110001b & 10011001b = 10010001b
-10110001b & 10011010b = 10010000b
-10110001b & 10011011b = 10010001b
-10110001b & 10011100b = 10010000b
-10110001b & 10011101b = 10010001b
-10110001b & 10011110b = 10010000b
-10110001b & 10011111b = 10010001b
-10110001b & 10100000b = 10100000b
-10110001b & 10100001b = 10100001b
-10110001b & 10100010b = 10100000b
-10110001b & 10100011b = 10100001b
-10110001b & 10100100b = 10100000b
-10110001b & 10100101b = 10100001b
-10110001b & 10100110b = 10100000b
-10110001b & 10100111b = 10100001b
-10110001b & 10101000b = 10100000b
-10110001b & 10101001b = 10100001b
-10110001b & 10101010b = 10100000b
-10110001b & 10101011b = 10100001b
-10110001b & 10101100b = 10100000b
-10110001b & 10101101b = 10100001b
-10110001b & 10101110b = 10100000b
-10110001b & 10101111b = 10100001b
-10110001b & 10110000b = 10110000b
-10110001b & 10110001b = 10110001b
-10110001b & 10110010b = 10110000b
-10110001b & 10110011b = 10110001b
-10110001b & 10110100b = 10110000b
-10110001b & 10110101b = 10110001b
-10110001b & 10110110b = 10110000b
-10110001b & 10110111b = 10110001b
-10110001b & 10111000b = 10110000b
-10110001b & 10111001b = 10110001b
-10110001b & 10111010b = 10110000b
-10110001b & 10111011b = 10110001b
-10110001b & 10111100b = 10110000b
-10110001b & 10111101b = 10110001b
-10110001b & 10111110b = 10110000b
-10110001b & 10111111b = 10110001b
-10110001b & 11000000b = 10000000b
-10110001b & 11000001b = 10000001b
-10110001b & 11000010b = 10000000b
-10110001b & 11000011b = 10000001b
-10110001b & 11000100b = 10000000b
-10110001b & 11000101b = 10000001b
-10110001b & 11000110b = 10000000b
-10110001b & 11000111b = 10000001b
-10110001b & 11001000b = 10000000b
-10110001b & 11001001b = 10000001b
-10110001b & 11001010b = 10000000b
-10110001b & 11001011b = 10000001b
-10110001b & 11001100b = 10000000b
-10110001b & 11001101b = 10000001b
-10110001b & 11001110b = 10000000b
-10110001b & 11001111b = 10000001b
-10110001b & 11010000b = 10010000b
-10110001b & 11010001b = 10010001b
-10110001b & 11010010b = 10010000b
-10110001b & 11010011b = 10010001b
-10110001b & 11010100b = 10010000b
-10110001b & 11010101b = 10010001b
-10110001b & 11010110b = 10010000b
-10110001b & 11010111b = 10010001b
-10110001b & 11011000b = 10010000b
-10110001b & 11011001b = 10010001b
-10110001b & 11011010b = 10010000b
-10110001b & 11011011b = 10010001b
-10110001b & 11011100b = 10010000b
-10110001b & 11011101b = 10010001b
-10110001b & 11011110b = 10010000b
-10110001b & 11011111b = 10010001b
-10110001b & 11100000b = 10100000b
-10110001b & 11100001b = 10100001b
-10110001b & 11100010b = 10100000b
-10110001b & 11100011b = 10100001b
-10110001b & 11100100b = 10100000b
-10110001b & 11100101b = 10100001b
-10110001b & 11100110b = 10100000b
-10110001b & 11100111b = 10100001b
-10110001b & 11101000b = 10100000b
-10110001b & 11101001b = 10100001b
-10110001b & 11101010b = 10100000b
-10110001b & 11101011b = 10100001b
-10110001b & 11101100b = 10100000b
-10110001b & 11101101b = 10100001b
-10110001b & 11101110b = 10100000b
-10110001b & 11101111b = 10100001b
-10110001b & 11110000b = 10110000b
-10110001b & 11110001b = 10110001b
-10110001b & 11110010b = 10110000b
-10110001b & 11110011b = 10110001b
-10110001b & 11110100b = 10110000b
-10110001b & 11110101b = 10110001b
-10110001b & 11110110b = 10110000b
-10110001b & 11110111b = 10110001b
-10110001b & 11111000b = 10110000b
-10110001b & 11111001b = 10110001b
-10110001b & 11111010b = 10110000b
-10110001b & 11111011b = 10110001b
-10110001b & 11111100b = 10110000b
-10110001b & 11111101b = 10110001b
-10110001b & 11111110b = 10110000b
-10110001b & 11111111b = 10110001b
-10110001b & 00000000b = 00000000b
-10110001b & 00000001b = 00000001b
-10110001b & 00000010b = 00000000b
-10110001b & 00000011b = 00000001b
-10110001b & 00000100b = 00000000b
-10110001b & 00000101b = 00000001b
-10110001b & 00000110b = 00000000b
-10110001b & 00000111b = 00000001b
-10110001b & 00001000b = 00000000b
-10110001b & 00001001b = 00000001b
-10110001b & 00001010b = 00000000b
-10110001b & 00001011b = 00000001b
-10110001b & 00001100b = 00000000b
-10110001b & 00001101b = 00000001b
-10110001b & 00001110b = 00000000b
-10110001b & 00001111b = 00000001b
-10110001b & 00010000b = 00010000b
-10110001b & 00010001b = 00010001b
-10110001b & 00010010b = 00010000b
-10110001b & 00010011b = 00010001b
-10110001b & 00010100b = 00010000b
-10110001b & 00010101b = 00010001b
-10110001b & 00010110b = 00010000b
-10110001b & 00010111b = 00010001b
-10110001b & 00011000b = 00010000b
-10110001b & 00011001b = 00010001b
-10110001b & 00011010b = 00010000b
-10110001b & 00011011b = 00010001b
-10110001b & 00011100b = 00010000b
-10110001b & 00011101b = 00010001b
-10110001b & 00011110b = 00010000b
-10110001b & 00011111b = 00010001b
-10110001b & 00100000b = 00100000b
-10110001b & 00100001b = 00100001b
-10110001b & 00100010b = 00100000b
-10110001b & 00100011b = 00100001b
-10110001b & 00100100b = 00100000b
-10110001b & 00100101b = 00100001b
-10110001b & 00100110b = 00100000b
-10110001b & 00100111b = 00100001b
-10110001b & 00101000b = 00100000b
-10110001b & 00101001b = 00100001b
-10110001b & 00101010b = 00100000b
-10110001b & 00101011b = 00100001b
-10110001b & 00101100b = 00100000b
-10110001b & 00101101b = 00100001b
-10110001b & 00101110b = 00100000b
-10110001b & 00101111b = 00100001b
-10110001b & 00110000b = 00110000b
-10110001b & 00110001b = 00110001b
-10110001b & 00110010b = 00110000b
-10110001b & 00110011b = 00110001b
-10110001b & 00110100b = 00110000b
-10110001b & 00110101b = 00110001b
-10110001b & 00110110b = 00110000b
-10110001b & 00110111b = 00110001b
-10110001b & 00111000b = 00110000b
-10110001b & 00111001b = 00110001b
-10110001b & 00111010b = 00110000b
-10110001b & 00111011b = 00110001b
-10110001b & 00111100b = 00110000b
-10110001b & 00111101b = 00110001b
-10110001b & 00111110b = 00110000b
-10110001b & 00111111b = 00110001b
-10110001b & 01000000b = 00000000b
-10110001b & 01000001b = 00000001b
-10110001b & 01000010b = 00000000b
-10110001b & 01000011b = 00000001b
-10110001b & 01000100b = 00000000b
-10110001b & 01000101b = 00000001b
-10110001b & 01000110b = 00000000b
-10110001b & 01000111b = 00000001b
-10110001b & 01001000b = 00000000b
-10110001b & 01001001b = 00000001b
-10110001b & 01001010b = 00000000b
-10110001b & 01001011b = 00000001b
-10110001b & 01001100b = 00000000b
-10110001b & 01001101b = 00000001b
-10110001b & 01001110b = 00000000b
-10110001b & 01001111b = 00000001b
-10110001b & 01010000b = 00010000b
-10110001b & 01010001b = 00010001b
-10110001b & 01010010b = 00010000b
-10110001b & 01010011b = 00010001b
-10110001b & 01010100b = 00010000b
-10110001b & 01010101b = 00010001b
-10110001b & 01010110b = 00010000b
-10110001b & 01010111b = 00010001b
-10110001b & 01011000b = 00010000b
-10110001b & 01011001b = 00010001b
-10110001b & 01011010b = 00010000b
-10110001b & 01011011b = 00010001b
-10110001b & 01011100b = 00010000b
-10110001b & 01011101b = 00010001b
-10110001b & 01011110b = 00010000b
-10110001b & 01011111b = 00010001b
-10110001b & 01100000b = 00100000b
-10110001b & 01100001b = 00100001b
-10110001b & 01100010b = 00100000b
-10110001b & 01100011b = 00100001b
-10110001b & 01100100b = 00100000b
-10110001b & 01100101b = 00100001b
-10110001b & 01100110b = 00100000b
-10110001b & 01100111b = 00100001b
-10110001b & 01101000b = 00100000b
-10110001b & 01101001b = 00100001b
-10110001b & 01101010b = 00100000b
-10110001b & 01101011b = 00100001b
-10110001b & 01101100b = 00100000b
-10110001b & 01101101b = 00100001b
-10110001b & 01101110b = 00100000b
-10110001b & 01101111b = 00100001b
-10110001b & 01110000b = 00110000b
-10110001b & 01110001b = 00110001b
-10110001b & 01110010b = 00110000b
-10110001b & 01110011b = 00110001b
-10110001b & 01110100b = 00110000b
-10110001b & 01110101b = 00110001b
-10110001b & 01110110b = 00110000b
-10110001b & 01110111b = 00110001b
-10110001b & 01111000b = 00110000b
-10110001b & 01111001b = 00110001b
-10110001b & 01111010b = 00110000b
-10110001b & 01111011b = 00110001b
-10110001b & 01111100b = 00110000b
-10110001b & 01111101b = 00110001b
-10110001b & 01111110b = 00110000b
-10110010b & 10000000b = 10000000b
-10110010b & 10000001b = 10000000b
-10110010b & 10000010b = 10000010b
-10110010b & 10000011b = 10000010b
-10110010b & 10000100b = 10000000b
-10110010b & 10000101b = 10000000b
-10110010b & 10000110b = 10000010b
-10110010b & 10000111b = 10000010b
-10110010b & 10001000b = 10000000b
-10110010b & 10001001b = 10000000b
-10110010b & 10001010b = 10000010b
-10110010b & 10001011b = 10000010b
-10110010b & 10001100b = 10000000b
-10110010b & 10001101b = 10000000b
-10110010b & 10001110b = 10000010b
-10110010b & 10001111b = 10000010b
-10110010b & 10010000b = 10010000b
-10110010b & 10010001b = 10010000b
-10110010b & 10010010b = 10010010b
-10110010b & 10010011b = 10010010b
-10110010b & 10010100b = 10010000b
-10110010b & 10010101b = 10010000b
-10110010b & 10010110b = 10010010b
-10110010b & 10010111b = 10010010b
-10110010b & 10011000b = 10010000b
-10110010b & 10011001b = 10010000b
-10110010b & 10011010b = 10010010b
-10110010b & 10011011b = 10010010b
-10110010b & 10011100b = 10010000b
-10110010b & 10011101b = 10010000b
-10110010b & 10011110b = 10010010b
-10110010b & 10011111b = 10010010b
-10110010b & 10100000b = 10100000b
-10110010b & 10100001b = 10100000b
-10110010b & 10100010b = 10100010b
-10110010b & 10100011b = 10100010b
-10110010b & 10100100b = 10100000b
-10110010b & 10100101b = 10100000b
-10110010b & 10100110b = 10100010b
-10110010b & 10100111b = 10100010b
-10110010b & 10101000b = 10100000b
-10110010b & 10101001b = 10100000b
-10110010b & 10101010b = 10100010b
-10110010b & 10101011b = 10100010b
-10110010b & 10101100b = 10100000b
-10110010b & 10101101b = 10100000b
-10110010b & 10101110b = 10100010b
-10110010b & 10101111b = 10100010b
-10110010b & 10110000b = 10110000b
-10110010b & 10110001b = 10110000b
-10110010b & 10110010b = 10110010b
-10110010b & 10110011b = 10110010b
-10110010b & 10110100b = 10110000b
-10110010b & 10110101b = 10110000b
-10110010b & 10110110b = 10110010b
-10110010b & 10110111b = 10110010b
-10110010b & 10111000b = 10110000b
-10110010b & 10111001b = 10110000b
-10110010b & 10111010b = 10110010b
-10110010b & 10111011b = 10110010b
-10110010b & 10111100b = 10110000b
-10110010b & 10111101b = 10110000b
-10110010b & 10111110b = 10110010b
-10110010b & 10111111b = 10110010b
-10110010b & 11000000b = 10000000b
-10110010b & 11000001b = 10000000b
-10110010b & 11000010b = 10000010b
-10110010b & 11000011b = 10000010b
-10110010b & 11000100b = 10000000b
-10110010b & 11000101b = 10000000b
-10110010b & 11000110b = 10000010b
-10110010b & 11000111b = 10000010b
-10110010b & 11001000b = 10000000b
-10110010b & 11001001b = 10000000b
-10110010b & 11001010b = 10000010b
-10110010b & 11001011b = 10000010b
-10110010b & 11001100b = 10000000b
-10110010b & 11001101b = 10000000b
-10110010b & 11001110b = 10000010b
-10110010b & 11001111b = 10000010b
-10110010b & 11010000b = 10010000b
-10110010b & 11010001b = 10010000b
-10110010b & 11010010b = 10010010b
-10110010b & 11010011b = 10010010b
-10110010b & 11010100b = 10010000b
-10110010b & 11010101b = 10010000b
-10110010b & 11010110b = 10010010b
-10110010b & 11010111b = 10010010b
-10110010b & 11011000b = 10010000b
-10110010b & 11011001b = 10010000b
-10110010b & 11011010b = 10010010b
-10110010b & 11011011b = 10010010b
-10110010b & 11011100b = 10010000b
-10110010b & 11011101b = 10010000b
-10110010b & 11011110b = 10010010b
-10110010b & 11011111b = 10010010b
-10110010b & 11100000b = 10100000b
-10110010b & 11100001b = 10100000b
-10110010b & 11100010b = 10100010b
-10110010b & 11100011b = 10100010b
-10110010b & 11100100b = 10100000b
-10110010b & 11100101b = 10100000b
-10110010b & 11100110b = 10100010b
-10110010b & 11100111b = 10100010b
-10110010b & 11101000b = 10100000b
-10110010b & 11101001b = 10100000b
-10110010b & 11101010b = 10100010b
-10110010b & 11101011b = 10100010b
-10110010b & 11101100b = 10100000b
-10110010b & 11101101b = 10100000b
-10110010b & 11101110b = 10100010b
-10110010b & 11101111b = 10100010b
-10110010b & 11110000b = 10110000b
-10110010b & 11110001b = 10110000b
-10110010b & 11110010b = 10110010b
-10110010b & 11110011b = 10110010b
-10110010b & 11110100b = 10110000b
-10110010b & 11110101b = 10110000b
-10110010b & 11110110b = 10110010b
-10110010b & 11110111b = 10110010b
-10110010b & 11111000b = 10110000b
-10110010b & 11111001b = 10110000b
-10110010b & 11111010b = 10110010b
-10110010b & 11111011b = 10110010b
-10110010b & 11111100b = 10110000b
-10110010b & 11111101b = 10110000b
-10110010b & 11111110b = 10110010b
-10110010b & 11111111b = 10110010b
-10110010b & 00000000b = 00000000b
-10110010b & 00000001b = 00000000b
-10110010b & 00000010b = 00000010b
-10110010b & 00000011b = 00000010b
-10110010b & 00000100b = 00000000b
-10110010b & 00000101b = 00000000b
-10110010b & 00000110b = 00000010b
-10110010b & 00000111b = 00000010b
-10110010b & 00001000b = 00000000b
-10110010b & 00001001b = 00000000b
-10110010b & 00001010b = 00000010b
-10110010b & 00001011b = 00000010b
-10110010b & 00001100b = 00000000b
-10110010b & 00001101b = 00000000b
-10110010b & 00001110b = 00000010b
-10110010b & 00001111b = 00000010b
-10110010b & 00010000b = 00010000b
-10110010b & 00010001b = 00010000b
-10110010b & 00010010b = 00010010b
-10110010b & 00010011b = 00010010b
-10110010b & 00010100b = 00010000b
-10110010b & 00010101b = 00010000b
-10110010b & 00010110b = 00010010b
-10110010b & 00010111b = 00010010b
-10110010b & 00011000b = 00010000b
-10110010b & 00011001b = 00010000b
-10110010b & 00011010b = 00010010b
-10110010b & 00011011b = 00010010b
-10110010b & 00011100b = 00010000b
-10110010b & 00011101b = 00010000b
-10110010b & 00011110b = 00010010b
-10110010b & 00011111b = 00010010b
-10110010b & 00100000b = 00100000b
-10110010b & 00100001b = 00100000b
-10110010b & 00100010b = 00100010b
-10110010b & 00100011b = 00100010b
-10110010b & 00100100b = 00100000b
-10110010b & 00100101b = 00100000b
-10110010b & 00100110b = 00100010b
-10110010b & 00100111b = 00100010b
-10110010b & 00101000b = 00100000b
-10110010b & 00101001b = 00100000b
-10110010b & 00101010b = 00100010b
-10110010b & 00101011b = 00100010b
-10110010b & 00101100b = 00100000b
-10110010b & 00101101b = 00100000b
-10110010b & 00101110b = 00100010b
-10110010b & 00101111b = 00100010b
-10110010b & 00110000b = 00110000b
-10110010b & 00110001b = 00110000b
-10110010b & 00110010b = 00110010b
-10110010b & 00110011b = 00110010b
-10110010b & 00110100b = 00110000b
-10110010b & 00110101b = 00110000b
-10110010b & 00110110b = 00110010b
-10110010b & 00110111b = 00110010b
-10110010b & 00111000b = 00110000b
-10110010b & 00111001b = 00110000b
-10110010b & 00111010b = 00110010b
-10110010b & 00111011b = 00110010b
-10110010b & 00111100b = 00110000b
-10110010b & 00111101b = 00110000b
-10110010b & 00111110b = 00110010b
-10110010b & 00111111b = 00110010b
-10110010b & 01000000b = 00000000b
-10110010b & 01000001b = 00000000b
-10110010b & 01000010b = 00000010b
-10110010b & 01000011b = 00000010b
-10110010b & 01000100b = 00000000b
-10110010b & 01000101b = 00000000b
-10110010b & 01000110b = 00000010b
-10110010b & 01000111b = 00000010b
-10110010b & 01001000b = 00000000b
-10110010b & 01001001b = 00000000b
-10110010b & 01001010b = 00000010b
-10110010b & 01001011b = 00000010b
-10110010b & 01001100b = 00000000b
-10110010b & 01001101b = 00000000b
-10110010b & 01001110b = 00000010b
-10110010b & 01001111b = 00000010b
-10110010b & 01010000b = 00010000b
-10110010b & 01010001b = 00010000b
-10110010b & 01010010b = 00010010b
-10110010b & 01010011b = 00010010b
-10110010b & 01010100b = 00010000b
-10110010b & 01010101b = 00010000b
-10110010b & 01010110b = 00010010b
-10110010b & 01010111b = 00010010b
-10110010b & 01011000b = 00010000b
-10110010b & 01011001b = 00010000b
-10110010b & 01011010b = 00010010b
-10110010b & 01011011b = 00010010b
-10110010b & 01011100b = 00010000b
-10110010b & 01011101b = 00010000b
-10110010b & 01011110b = 00010010b
-10110010b & 01011111b = 00010010b
-10110010b & 01100000b = 00100000b
-10110010b & 01100001b = 00100000b
-10110010b & 01100010b = 00100010b
-10110010b & 01100011b = 00100010b
-10110010b & 01100100b = 00100000b
-10110010b & 01100101b = 00100000b
-10110010b & 01100110b = 00100010b
-10110010b & 01100111b = 00100010b
-10110010b & 01101000b = 00100000b
-10110010b & 01101001b = 00100000b
-10110010b & 01101010b = 00100010b
-10110010b & 01101011b = 00100010b
-10110010b & 01101100b = 00100000b
-10110010b & 01101101b = 00100000b
-10110010b & 01101110b = 00100010b
-10110010b & 01101111b = 00100010b
-10110010b & 01110000b = 00110000b
-10110010b & 01110001b = 00110000b
-10110010b & 01110010b = 00110010b
-10110010b & 01110011b = 00110010b
-10110010b & 01110100b = 00110000b
-10110010b & 01110101b = 00110000b
-10110010b & 01110110b = 00110010b
-10110010b & 01110111b = 00110010b
-10110010b & 01111000b = 00110000b
-10110010b & 01111001b = 00110000b
-10110010b & 01111010b = 00110010b
-10110010b & 01111011b = 00110010b
-10110010b & 01111100b = 00110000b
-10110010b & 01111101b = 00110000b
-10110010b & 01111110b = 00110010b
-10110011b & 10000000b = 10000000b
-10110011b & 10000001b = 10000001b
-10110011b & 10000010b = 10000010b
-10110011b & 10000011b = 10000011b
-10110011b & 10000100b = 10000000b
-10110011b & 10000101b = 10000001b
-10110011b & 10000110b = 10000010b
-10110011b & 10000111b = 10000011b
-10110011b & 10001000b = 10000000b
-10110011b & 10001001b = 10000001b
-10110011b & 10001010b = 10000010b
-10110011b & 10001011b = 10000011b
-10110011b & 10001100b = 10000000b
-10110011b & 10001101b = 10000001b
-10110011b & 10001110b = 10000010b
-10110011b & 10001111b = 10000011b
-10110011b & 10010000b = 10010000b
-10110011b & 10010001b = 10010001b
-10110011b & 10010010b = 10010010b
-10110011b & 10010011b = 10010011b
-10110011b & 10010100b = 10010000b
-10110011b & 10010101b = 10010001b
-10110011b & 10010110b = 10010010b
-10110011b & 10010111b = 10010011b
-10110011b & 10011000b = 10010000b
-10110011b & 10011001b = 10010001b
-10110011b & 10011010b = 10010010b
-10110011b & 10011011b = 10010011b
-10110011b & 10011100b = 10010000b
-10110011b & 10011101b = 10010001b
-10110011b & 10011110b = 10010010b
-10110011b & 10011111b = 10010011b
-10110011b & 10100000b = 10100000b
-10110011b & 10100001b = 10100001b
-10110011b & 10100010b = 10100010b
-10110011b & 10100011b = 10100011b
-10110011b & 10100100b = 10100000b
-10110011b & 10100101b = 10100001b
-10110011b & 10100110b = 10100010b
-10110011b & 10100111b = 10100011b
-10110011b & 10101000b = 10100000b
-10110011b & 10101001b = 10100001b
-10110011b & 10101010b = 10100010b
-10110011b & 10101011b = 10100011b
-10110011b & 10101100b = 10100000b
-10110011b & 10101101b = 10100001b
-10110011b & 10101110b = 10100010b
-10110011b & 10101111b = 10100011b
-10110011b & 10110000b = 10110000b
-10110011b & 10110001b = 10110001b
-10110011b & 10110010b = 10110010b
-10110011b & 10110011b = 10110011b
-10110011b & 10110100b = 10110000b
-10110011b & 10110101b = 10110001b
-10110011b & 10110110b = 10110010b
-10110011b & 10110111b = 10110011b
-10110011b & 10111000b = 10110000b
-10110011b & 10111001b = 10110001b
-10110011b & 10111010b = 10110010b
-10110011b & 10111011b = 10110011b
-10110011b & 10111100b = 10110000b
-10110011b & 10111101b = 10110001b
-10110011b & 10111110b = 10110010b
-10110011b & 10111111b = 10110011b
-10110011b & 11000000b = 10000000b
-10110011b & 11000001b = 10000001b
-10110011b & 11000010b = 10000010b
-10110011b & 11000011b = 10000011b
-10110011b & 11000100b = 10000000b
-10110011b & 11000101b = 10000001b
-10110011b & 11000110b = 10000010b
-10110011b & 11000111b = 10000011b
-10110011b & 11001000b = 10000000b
-10110011b & 11001001b = 10000001b
-10110011b & 11001010b = 10000010b
-10110011b & 11001011b = 10000011b
-10110011b & 11001100b = 10000000b
-10110011b & 11001101b = 10000001b
-10110011b & 11001110b = 10000010b
-10110011b & 11001111b = 10000011b
-10110011b & 11010000b = 10010000b
-10110011b & 11010001b = 10010001b
-10110011b & 11010010b = 10010010b
-10110011b & 11010011b = 10010011b
-10110011b & 11010100b = 10010000b
-10110011b & 11010101b = 10010001b
-10110011b & 11010110b = 10010010b
-10110011b & 11010111b = 10010011b
-10110011b & 11011000b = 10010000b
-10110011b & 11011001b = 10010001b
-10110011b & 11011010b = 10010010b
-10110011b & 11011011b = 10010011b
-10110011b & 11011100b = 10010000b
-10110011b & 11011101b = 10010001b
-10110011b & 11011110b = 10010010b
-10110011b & 11011111b = 10010011b
-10110011b & 11100000b = 10100000b
-10110011b & 11100001b = 10100001b
-10110011b & 11100010b = 10100010b
-10110011b & 11100011b = 10100011b
-10110011b & 11100100b = 10100000b
-10110011b & 11100101b = 10100001b
-10110011b & 11100110b = 10100010b
-10110011b & 11100111b = 10100011b
-10110011b & 11101000b = 10100000b
-10110011b & 11101001b = 10100001b
-10110011b & 11101010b = 10100010b
-10110011b & 11101011b = 10100011b
-10110011b & 11101100b = 10100000b
-10110011b & 11101101b = 10100001b
-10110011b & 11101110b = 10100010b
-10110011b & 11101111b = 10100011b
-10110011b & 11110000b = 10110000b
-10110011b & 11110001b = 10110001b
-10110011b & 11110010b = 10110010b
-10110011b & 11110011b = 10110011b
-10110011b & 11110100b = 10110000b
-10110011b & 11110101b = 10110001b
-10110011b & 11110110b = 10110010b
-10110011b & 11110111b = 10110011b
-10110011b & 11111000b = 10110000b
-10110011b & 11111001b = 10110001b
-10110011b & 11111010b = 10110010b
-10110011b & 11111011b = 10110011b
-10110011b & 11111100b = 10110000b
-10110011b & 11111101b = 10110001b
-10110011b & 11111110b = 10110010b
-10110011b & 11111111b = 10110011b
-10110011b & 00000000b = 00000000b
-10110011b & 00000001b = 00000001b
-10110011b & 00000010b = 00000010b
-10110011b & 00000011b = 00000011b
-10110011b & 00000100b = 00000000b
-10110011b & 00000101b = 00000001b
-10110011b & 00000110b = 00000010b
-10110011b & 00000111b = 00000011b
-10110011b & 00001000b = 00000000b
-10110011b & 00001001b = 00000001b
-10110011b & 00001010b = 00000010b
-10110011b & 00001011b = 00000011b
-10110011b & 00001100b = 00000000b
-10110011b & 00001101b = 00000001b
-10110011b & 00001110b = 00000010b
-10110011b & 00001111b = 00000011b
-10110011b & 00010000b = 00010000b
-10110011b & 00010001b = 00010001b
-10110011b & 00010010b = 00010010b
-10110011b & 00010011b = 00010011b
-10110011b & 00010100b = 00010000b
-10110011b & 00010101b = 00010001b
-10110011b & 00010110b = 00010010b
-10110011b & 00010111b = 00010011b
-10110011b & 00011000b = 00010000b
-10110011b & 00011001b = 00010001b
-10110011b & 00011010b = 00010010b
-10110011b & 00011011b = 00010011b
-10110011b & 00011100b = 00010000b
-10110011b & 00011101b = 00010001b
-10110011b & 00011110b = 00010010b
-10110011b & 00011111b = 00010011b
-10110011b & 00100000b = 00100000b
-10110011b & 00100001b = 00100001b
-10110011b & 00100010b = 00100010b
-10110011b & 00100011b = 00100011b
-10110011b & 00100100b = 00100000b
-10110011b & 00100101b = 00100001b
-10110011b & 00100110b = 00100010b
-10110011b & 00100111b = 00100011b
-10110011b & 00101000b = 00100000b
-10110011b & 00101001b = 00100001b
-10110011b & 00101010b = 00100010b
-10110011b & 00101011b = 00100011b
-10110011b & 00101100b = 00100000b
-10110011b & 00101101b = 00100001b
-10110011b & 00101110b = 00100010b
-10110011b & 00101111b = 00100011b
-10110011b & 00110000b = 00110000b
-10110011b & 00110001b = 00110001b
-10110011b & 00110010b = 00110010b
-10110011b & 00110011b = 00110011b
-10110011b & 00110100b = 00110000b
-10110011b & 00110101b = 00110001b
-10110011b & 00110110b = 00110010b
-10110011b & 00110111b = 00110011b
-10110011b & 00111000b = 00110000b
-10110011b & 00111001b = 00110001b
-10110011b & 00111010b = 00110010b
-10110011b & 00111011b = 00110011b
-10110011b & 00111100b = 00110000b
-10110011b & 00111101b = 00110001b
-10110011b & 00111110b = 00110010b
-10110011b & 00111111b = 00110011b
-10110011b & 01000000b = 00000000b
-10110011b & 01000001b = 00000001b
-10110011b & 01000010b = 00000010b
-10110011b & 01000011b = 00000011b
-10110011b & 01000100b = 00000000b
-10110011b & 01000101b = 00000001b
-10110011b & 01000110b = 00000010b
-10110011b & 01000111b = 00000011b
-10110011b & 01001000b = 00000000b
-10110011b & 01001001b = 00000001b
-10110011b & 01001010b = 00000010b
-10110011b & 01001011b = 00000011b
-10110011b & 01001100b = 00000000b
-10110011b & 01001101b = 00000001b
-10110011b & 01001110b = 00000010b
-10110011b & 01001111b = 00000011b
-10110011b & 01010000b = 00010000b
-10110011b & 01010001b = 00010001b
-10110011b & 01010010b = 00010010b
-10110011b & 01010011b = 00010011b
-10110011b & 01010100b = 00010000b
-10110011b & 01010101b = 00010001b
-10110011b & 01010110b = 00010010b
-10110011b & 01010111b = 00010011b
-10110011b & 01011000b = 00010000b
-10110011b & 01011001b = 00010001b
-10110011b & 01011010b = 00010010b
-10110011b & 01011011b = 00010011b
-10110011b & 01011100b = 00010000b
-10110011b & 01011101b = 00010001b
-10110011b & 01011110b = 00010010b
-10110011b & 01011111b = 00010011b
-10110011b & 01100000b = 00100000b
-10110011b & 01100001b = 00100001b
-10110011b & 01100010b = 00100010b
-10110011b & 01100011b = 00100011b
-10110011b & 01100100b = 00100000b
-10110011b & 01100101b = 00100001b
-10110011b & 01100110b = 00100010b
-10110011b & 01100111b = 00100011b
-10110011b & 01101000b = 00100000b
-10110011b & 01101001b = 00100001b
-10110011b & 01101010b = 00100010b
-10110011b & 01101011b = 00100011b
-10110011b & 01101100b = 00100000b
-10110011b & 01101101b = 00100001b
-10110011b & 01101110b = 00100010b
-10110011b & 01101111b = 00100011b
-10110011b & 01110000b = 00110000b
-10110011b & 01110001b = 00110001b
-10110011b & 01110010b = 00110010b
-10110011b & 01110011b = 00110011b
-10110011b & 01110100b = 00110000b
-10110011b & 01110101b = 00110001b
-10110011b & 01110110b = 00110010b
-10110011b & 01110111b = 00110011b
-10110011b & 01111000b = 00110000b
-10110011b & 01111001b = 00110001b
-10110011b & 01111010b = 00110010b
-10110011b & 01111011b = 00110011b
-10110011b & 01111100b = 00110000b
-10110011b & 01111101b = 00110001b
-10110011b & 01111110b = 00110010b
-10110100b & 10000000b = 10000000b
-10110100b & 10000001b = 10000000b
-10110100b & 10000010b = 10000000b
-10110100b & 10000011b = 10000000b
-10110100b & 10000100b = 10000100b
-10110100b & 10000101b = 10000100b
-10110100b & 10000110b = 10000100b
-10110100b & 10000111b = 10000100b
-10110100b & 10001000b = 10000000b
-10110100b & 10001001b = 10000000b
-10110100b & 10001010b = 10000000b
-10110100b & 10001011b = 10000000b
-10110100b & 10001100b = 10000100b
-10110100b & 10001101b = 10000100b
-10110100b & 10001110b = 10000100b
-10110100b & 10001111b = 10000100b
-10110100b & 10010000b = 10010000b
-10110100b & 10010001b = 10010000b
-10110100b & 10010010b = 10010000b
-10110100b & 10010011b = 10010000b
-10110100b & 10010100b = 10010100b
-10110100b & 10010101b = 10010100b
-10110100b & 10010110b = 10010100b
-10110100b & 10010111b = 10010100b
-10110100b & 10011000b = 10010000b
-10110100b & 10011001b = 10010000b
-10110100b & 10011010b = 10010000b
-10110100b & 10011011b = 10010000b
-10110100b & 10011100b = 10010100b
-10110100b & 10011101b = 10010100b
-10110100b & 10011110b = 10010100b
-10110100b & 10011111b = 10010100b
-10110100b & 10100000b = 10100000b
-10110100b & 10100001b = 10100000b
-10110100b & 10100010b = 10100000b
-10110100b & 10100011b = 10100000b
-10110100b & 10100100b = 10100100b
-10110100b & 10100101b = 10100100b
-10110100b & 10100110b = 10100100b
-10110100b & 10100111b = 10100100b
-10110100b & 10101000b = 10100000b
-10110100b & 10101001b = 10100000b
-10110100b & 10101010b = 10100000b
-10110100b & 10101011b = 10100000b
-10110100b & 10101100b = 10100100b
-10110100b & 10101101b = 10100100b
-10110100b & 10101110b = 10100100b
-10110100b & 10101111b = 10100100b
-10110100b & 10110000b = 10110000b
-10110100b & 10110001b = 10110000b
-10110100b & 10110010b = 10110000b
-10110100b & 10110011b = 10110000b
-10110100b & 10110100b = 10110100b
-10110100b & 10110101b = 10110100b
-10110100b & 10110110b = 10110100b
-10110100b & 10110111b = 10110100b
-10110100b & 10111000b = 10110000b
-10110100b & 10111001b = 10110000b
-10110100b & 10111010b = 10110000b
-10110100b & 10111011b = 10110000b
-10110100b & 10111100b = 10110100b
-10110100b & 10111101b = 10110100b
-10110100b & 10111110b = 10110100b
-10110100b & 10111111b = 10110100b
-10110100b & 11000000b = 10000000b
-10110100b & 11000001b = 10000000b
-10110100b & 11000010b = 10000000b
-10110100b & 11000011b = 10000000b
-10110100b & 11000100b = 10000100b
-10110100b & 11000101b = 10000100b
-10110100b & 11000110b = 10000100b
-10110100b & 11000111b = 10000100b
-10110100b & 11001000b = 10000000b
-10110100b & 11001001b = 10000000b
-10110100b & 11001010b = 10000000b
-10110100b & 11001011b = 10000000b
-10110100b & 11001100b = 10000100b
-10110100b & 11001101b = 10000100b
-10110100b & 11001110b = 10000100b
-10110100b & 11001111b = 10000100b
-10110100b & 11010000b = 10010000b
-10110100b & 11010001b = 10010000b
-10110100b & 11010010b = 10010000b
-10110100b & 11010011b = 10010000b
-10110100b & 11010100b = 10010100b
-10110100b & 11010101b = 10010100b
-10110100b & 11010110b = 10010100b
-10110100b & 11010111b = 10010100b
-10110100b & 11011000b = 10010000b
-10110100b & 11011001b = 10010000b
-10110100b & 11011010b = 10010000b
-10110100b & 11011011b = 10010000b
-10110100b & 11011100b = 10010100b
-10110100b & 11011101b = 10010100b
-10110100b & 11011110b = 10010100b
-10110100b & 11011111b = 10010100b
-10110100b & 11100000b = 10100000b
-10110100b & 11100001b = 10100000b
-10110100b & 11100010b = 10100000b
-10110100b & 11100011b = 10100000b
-10110100b & 11100100b = 10100100b
-10110100b & 11100101b = 10100100b
-10110100b & 11100110b = 10100100b
-10110100b & 11100111b = 10100100b
-10110100b & 11101000b = 10100000b
-10110100b & 11101001b = 10100000b
-10110100b & 11101010b = 10100000b
-10110100b & 11101011b = 10100000b
-10110100b & 11101100b = 10100100b
-10110100b & 11101101b = 10100100b
-10110100b & 11101110b = 10100100b
-10110100b & 11101111b = 10100100b
-10110100b & 11110000b = 10110000b
-10110100b & 11110001b = 10110000b
-10110100b & 11110010b = 10110000b
-10110100b & 11110011b = 10110000b
-10110100b & 11110100b = 10110100b
-10110100b & 11110101b = 10110100b
-10110100b & 11110110b = 10110100b
-10110100b & 11110111b = 10110100b
-10110100b & 11111000b = 10110000b
-10110100b & 11111001b = 10110000b
-10110100b & 11111010b = 10110000b
-10110100b & 11111011b = 10110000b
-10110100b & 11111100b = 10110100b
-10110100b & 11111101b = 10110100b
-10110100b & 11111110b = 10110100b
-10110100b & 11111111b = 10110100b
-10110100b & 00000000b = 00000000b
-10110100b & 00000001b = 00000000b
-10110100b & 00000010b = 00000000b
-10110100b & 00000011b = 00000000b
-10110100b & 00000100b = 00000100b
-10110100b & 00000101b = 00000100b
-10110100b & 00000110b = 00000100b
-10110100b & 00000111b = 00000100b
-10110100b & 00001000b = 00000000b
-10110100b & 00001001b = 00000000b
-10110100b & 00001010b = 00000000b
-10110100b & 00001011b = 00000000b
-10110100b & 00001100b = 00000100b
-10110100b & 00001101b = 00000100b
-10110100b & 00001110b = 00000100b
-10110100b & 00001111b = 00000100b
-10110100b & 00010000b = 00010000b
-10110100b & 00010001b = 00010000b
-10110100b & 00010010b = 00010000b
-10110100b & 00010011b = 00010000b
-10110100b & 00010100b = 00010100b
-10110100b & 00010101b = 00010100b
-10110100b & 00010110b = 00010100b
-10110100b & 00010111b = 00010100b
-10110100b & 00011000b = 00010000b
-10110100b & 00011001b = 00010000b
-10110100b & 00011010b = 00010000b
-10110100b & 00011011b = 00010000b
-10110100b & 00011100b = 00010100b
-10110100b & 00011101b = 00010100b
-10110100b & 00011110b = 00010100b
-10110100b & 00011111b = 00010100b
-10110100b & 00100000b = 00100000b
-10110100b & 00100001b = 00100000b
-10110100b & 00100010b = 00100000b
-10110100b & 00100011b = 00100000b
-10110100b & 00100100b = 00100100b
-10110100b & 00100101b = 00100100b
-10110100b & 00100110b = 00100100b
-10110100b & 00100111b = 00100100b
-10110100b & 00101000b = 00100000b
-10110100b & 00101001b = 00100000b
-10110100b & 00101010b = 00100000b
-10110100b & 00101011b = 00100000b
-10110100b & 00101100b = 00100100b
-10110100b & 00101101b = 00100100b
-10110100b & 00101110b = 00100100b
-10110100b & 00101111b = 00100100b
-10110100b & 00110000b = 00110000b
-10110100b & 00110001b = 00110000b
-10110100b & 00110010b = 00110000b
-10110100b & 00110011b = 00110000b
-10110100b & 00110100b = 00110100b
-10110100b & 00110101b = 00110100b
-10110100b & 00110110b = 00110100b
-10110100b & 00110111b = 00110100b
-10110100b & 00111000b = 00110000b
-10110100b & 00111001b = 00110000b
-10110100b & 00111010b = 00110000b
-10110100b & 00111011b = 00110000b
-10110100b & 00111100b = 00110100b
-10110100b & 00111101b = 00110100b
-10110100b & 00111110b = 00110100b
-10110100b & 00111111b = 00110100b
-10110100b & 01000000b = 00000000b
-10110100b & 01000001b = 00000000b
-10110100b & 01000010b = 00000000b
-10110100b & 01000011b = 00000000b
-10110100b & 01000100b = 00000100b
-10110100b & 01000101b = 00000100b
-10110100b & 01000110b = 00000100b
-10110100b & 01000111b = 00000100b
-10110100b & 01001000b = 00000000b
-10110100b & 01001001b = 00000000b
-10110100b & 01001010b = 00000000b
-10110100b & 01001011b = 00000000b
-10110100b & 01001100b = 00000100b
-10110100b & 01001101b = 00000100b
-10110100b & 01001110b = 00000100b
-10110100b & 01001111b = 00000100b
-10110100b & 01010000b = 00010000b
-10110100b & 01010001b = 00010000b
-10110100b & 01010010b = 00010000b
-10110100b & 01010011b = 00010000b
-10110100b & 01010100b = 00010100b
-10110100b & 01010101b = 00010100b
-10110100b & 01010110b = 00010100b
-10110100b & 01010111b = 00010100b
-10110100b & 01011000b = 00010000b
-10110100b & 01011001b = 00010000b
-10110100b & 01011010b = 00010000b
-10110100b & 01011011b = 00010000b
-10110100b & 01011100b = 00010100b
-10110100b & 01011101b = 00010100b
-10110100b & 01011110b = 00010100b
-10110100b & 01011111b = 00010100b
-10110100b & 01100000b = 00100000b
-10110100b & 01100001b = 00100000b
-10110100b & 01100010b = 00100000b
-10110100b & 01100011b = 00100000b
-10110100b & 01100100b = 00100100b
-10110100b & 01100101b = 00100100b
-10110100b & 01100110b = 00100100b
-10110100b & 01100111b = 00100100b
-10110100b & 01101000b = 00100000b
-10110100b & 01101001b = 00100000b
-10110100b & 01101010b = 00100000b
-10110100b & 01101011b = 00100000b
-10110100b & 01101100b = 00100100b
-10110100b & 01101101b = 00100100b
-10110100b & 01101110b = 00100100b
-10110100b & 01101111b = 00100100b
-10110100b & 01110000b = 00110000b
-10110100b & 01110001b = 00110000b
-10110100b & 01110010b = 00110000b
-10110100b & 01110011b = 00110000b
-10110100b & 01110100b = 00110100b
-10110100b & 01110101b = 00110100b
-10110100b & 01110110b = 00110100b
-10110100b & 01110111b = 00110100b
-10110100b & 01111000b = 00110000b
-10110100b & 01111001b = 00110000b
-10110100b & 01111010b = 00110000b
-10110100b & 01111011b = 00110000b
-10110100b & 01111100b = 00110100b
-10110100b & 01111101b = 00110100b
-10110100b & 01111110b = 00110100b
-10110101b & 10000000b = 10000000b
-10110101b & 10000001b = 10000001b
-10110101b & 10000010b = 10000000b
-10110101b & 10000011b = 10000001b
-10110101b & 10000100b = 10000100b
-10110101b & 10000101b = 10000101b
-10110101b & 10000110b = 10000100b
-10110101b & 10000111b = 10000101b
-10110101b & 10001000b = 10000000b
-10110101b & 10001001b = 10000001b
-10110101b & 10001010b = 10000000b
-10110101b & 10001011b = 10000001b
-10110101b & 10001100b = 10000100b
-10110101b & 10001101b = 10000101b
-10110101b & 10001110b = 10000100b
-10110101b & 10001111b = 10000101b
-10110101b & 10010000b = 10010000b
-10110101b & 10010001b = 10010001b
-10110101b & 10010010b = 10010000b
-10110101b & 10010011b = 10010001b
-10110101b & 10010100b = 10010100b
-10110101b & 10010101b = 10010101b
-10110101b & 10010110b = 10010100b
-10110101b & 10010111b = 10010101b
-10110101b & 10011000b = 10010000b
-10110101b & 10011001b = 10010001b
-10110101b & 10011010b = 10010000b
-10110101b & 10011011b = 10010001b
-10110101b & 10011100b = 10010100b
-10110101b & 10011101b = 10010101b
-10110101b & 10011110b = 10010100b
-10110101b & 10011111b = 10010101b
-10110101b & 10100000b = 10100000b
-10110101b & 10100001b = 10100001b
-10110101b & 10100010b = 10100000b
-10110101b & 10100011b = 10100001b
-10110101b & 10100100b = 10100100b
-10110101b & 10100101b = 10100101b
-10110101b & 10100110b = 10100100b
-10110101b & 10100111b = 10100101b
-10110101b & 10101000b = 10100000b
-10110101b & 10101001b = 10100001b
-10110101b & 10101010b = 10100000b
-10110101b & 10101011b = 10100001b
-10110101b & 10101100b = 10100100b
-10110101b & 10101101b = 10100101b
-10110101b & 10101110b = 10100100b
-10110101b & 10101111b = 10100101b
-10110101b & 10110000b = 10110000b
-10110101b & 10110001b = 10110001b
-10110101b & 10110010b = 10110000b
-10110101b & 10110011b = 10110001b
-10110101b & 10110100b = 10110100b
-10110101b & 10110101b = 10110101b
-10110101b & 10110110b = 10110100b
-10110101b & 10110111b = 10110101b
-10110101b & 10111000b = 10110000b
-10110101b & 10111001b = 10110001b
-10110101b & 10111010b = 10110000b
-10110101b & 10111011b = 10110001b
-10110101b & 10111100b = 10110100b
-10110101b & 10111101b = 10110101b
-10110101b & 10111110b = 10110100b
-10110101b & 10111111b = 10110101b
-10110101b & 11000000b = 10000000b
-10110101b & 11000001b = 10000001b
-10110101b & 11000010b = 10000000b
-10110101b & 11000011b = 10000001b
-10110101b & 11000100b = 10000100b
-10110101b & 11000101b = 10000101b
-10110101b & 11000110b = 10000100b
-10110101b & 11000111b = 10000101b
-10110101b & 11001000b = 10000000b
-10110101b & 11001001b = 10000001b
-10110101b & 11001010b = 10000000b
-10110101b & 11001011b = 10000001b
-10110101b & 11001100b = 10000100b
-10110101b & 11001101b = 10000101b
-10110101b & 11001110b = 10000100b
-10110101b & 11001111b = 10000101b
-10110101b & 11010000b = 10010000b
-10110101b & 11010001b = 10010001b
-10110101b & 11010010b = 10010000b
-10110101b & 11010011b = 10010001b
-10110101b & 11010100b = 10010100b
-10110101b & 11010101b = 10010101b
-10110101b & 11010110b = 10010100b
-10110101b & 11010111b = 10010101b
-10110101b & 11011000b = 10010000b
-10110101b & 11011001b = 10010001b
-10110101b & 11011010b = 10010000b
-10110101b & 11011011b = 10010001b
-10110101b & 11011100b = 10010100b
-10110101b & 11011101b = 10010101b
-10110101b & 11011110b = 10010100b
-10110101b & 11011111b = 10010101b
-10110101b & 11100000b = 10100000b
-10110101b & 11100001b = 10100001b
-10110101b & 11100010b = 10100000b
-10110101b & 11100011b = 10100001b
-10110101b & 11100100b = 10100100b
-10110101b & 11100101b = 10100101b
-10110101b & 11100110b = 10100100b
-10110101b & 11100111b = 10100101b
-10110101b & 11101000b = 10100000b
-10110101b & 11101001b = 10100001b
-10110101b & 11101010b = 10100000b
-10110101b & 11101011b = 10100001b
-10110101b & 11101100b = 10100100b
-10110101b & 11101101b = 10100101b
-10110101b & 11101110b = 10100100b
-10110101b & 11101111b = 10100101b
-10110101b & 11110000b = 10110000b
-10110101b & 11110001b = 10110001b
-10110101b & 11110010b = 10110000b
-10110101b & 11110011b = 10110001b
-10110101b & 11110100b = 10110100b
-10110101b & 11110101b = 10110101b
-10110101b & 11110110b = 10110100b
-10110101b & 11110111b = 10110101b
-10110101b & 11111000b = 10110000b
-10110101b & 11111001b = 10110001b
-10110101b & 11111010b = 10110000b
-10110101b & 11111011b = 10110001b
-10110101b & 11111100b = 10110100b
-10110101b & 11111101b = 10110101b
-10110101b & 11111110b = 10110100b
-10110101b & 11111111b = 10110101b
-10110101b & 00000000b = 00000000b
-10110101b & 00000001b = 00000001b
-10110101b & 00000010b = 00000000b
-10110101b & 00000011b = 00000001b
-10110101b & 00000100b = 00000100b
-10110101b & 00000101b = 00000101b
-10110101b & 00000110b = 00000100b
-10110101b & 00000111b = 00000101b
-10110101b & 00001000b = 00000000b
-10110101b & 00001001b = 00000001b
-10110101b & 00001010b = 00000000b
-10110101b & 00001011b = 00000001b
-10110101b & 00001100b = 00000100b
-10110101b & 00001101b = 00000101b
-10110101b & 00001110b = 00000100b
-10110101b & 00001111b = 00000101b
-10110101b & 00010000b = 00010000b
-10110101b & 00010001b = 00010001b
-10110101b & 00010010b = 00010000b
-10110101b & 00010011b = 00010001b
-10110101b & 00010100b = 00010100b
-10110101b & 00010101b = 00010101b
-10110101b & 00010110b = 00010100b
-10110101b & 00010111b = 00010101b
-10110101b & 00011000b = 00010000b
-10110101b & 00011001b = 00010001b
-10110101b & 00011010b = 00010000b
-10110101b & 00011011b = 00010001b
-10110101b & 00011100b = 00010100b
-10110101b & 00011101b = 00010101b
-10110101b & 00011110b = 00010100b
-10110101b & 00011111b = 00010101b
-10110101b & 00100000b = 00100000b
-10110101b & 00100001b = 00100001b
-10110101b & 00100010b = 00100000b
-10110101b & 00100011b = 00100001b
-10110101b & 00100100b = 00100100b
-10110101b & 00100101b = 00100101b
-10110101b & 00100110b = 00100100b
-10110101b & 00100111b = 00100101b
-10110101b & 00101000b = 00100000b
-10110101b & 00101001b = 00100001b
-10110101b & 00101010b = 00100000b
-10110101b & 00101011b = 00100001b
-10110101b & 00101100b = 00100100b
-10110101b & 00101101b = 00100101b
-10110101b & 00101110b = 00100100b
-10110101b & 00101111b = 00100101b
-10110101b & 00110000b = 00110000b
-10110101b & 00110001b = 00110001b
-10110101b & 00110010b = 00110000b
-10110101b & 00110011b = 00110001b
-10110101b & 00110100b = 00110100b
-10110101b & 00110101b = 00110101b
-10110101b & 00110110b = 00110100b
-10110101b & 00110111b = 00110101b
-10110101b & 00111000b = 00110000b
-10110101b & 00111001b = 00110001b
-10110101b & 00111010b = 00110000b
-10110101b & 00111011b = 00110001b
-10110101b & 00111100b = 00110100b
-10110101b & 00111101b = 00110101b
-10110101b & 00111110b = 00110100b
-10110101b & 00111111b = 00110101b
-10110101b & 01000000b = 00000000b
-10110101b & 01000001b = 00000001b
-10110101b & 01000010b = 00000000b
-10110101b & 01000011b = 00000001b
-10110101b & 01000100b = 00000100b
-10110101b & 01000101b = 00000101b
-10110101b & 01000110b = 00000100b
-10110101b & 01000111b = 00000101b
-10110101b & 01001000b = 00000000b
-10110101b & 01001001b = 00000001b
-10110101b & 01001010b = 00000000b
-10110101b & 01001011b = 00000001b
-10110101b & 01001100b = 00000100b
-10110101b & 01001101b = 00000101b
-10110101b & 01001110b = 00000100b
-10110101b & 01001111b = 00000101b
-10110101b & 01010000b = 00010000b
-10110101b & 01010001b = 00010001b
-10110101b & 01010010b = 00010000b
-10110101b & 01010011b = 00010001b
-10110101b & 01010100b = 00010100b
-10110101b & 01010101b = 00010101b
-10110101b & 01010110b = 00010100b
-10110101b & 01010111b = 00010101b
-10110101b & 01011000b = 00010000b
-10110101b & 01011001b = 00010001b
-10110101b & 01011010b = 00010000b
-10110101b & 01011011b = 00010001b
-10110101b & 01011100b = 00010100b
-10110101b & 01011101b = 00010101b
-10110101b & 01011110b = 00010100b
-10110101b & 01011111b = 00010101b
-10110101b & 01100000b = 00100000b
-10110101b & 01100001b = 00100001b
-10110101b & 01100010b = 00100000b
-10110101b & 01100011b = 00100001b
-10110101b & 01100100b = 00100100b
-10110101b & 01100101b = 00100101b
-10110101b & 01100110b = 00100100b
-10110101b & 01100111b = 00100101b
-10110101b & 01101000b = 00100000b
-10110101b & 01101001b = 00100001b
-10110101b & 01101010b = 00100000b
-10110101b & 01101011b = 00100001b
-10110101b & 01101100b = 00100100b
-10110101b & 01101101b = 00100101b
-10110101b & 01101110b = 00100100b
-10110101b & 01101111b = 00100101b
-10110101b & 01110000b = 00110000b
-10110101b & 01110001b = 00110001b
-10110101b & 01110010b = 00110000b
-10110101b & 01110011b = 00110001b
-10110101b & 01110100b = 00110100b
-10110101b & 01110101b = 00110101b
-10110101b & 01110110b = 00110100b
-10110101b & 01110111b = 00110101b
-10110101b & 01111000b = 00110000b
-10110101b & 01111001b = 00110001b
-10110101b & 01111010b = 00110000b
-10110101b & 01111011b = 00110001b
-10110101b & 01111100b = 00110100b
-10110101b & 01111101b = 00110101b
-10110101b & 01111110b = 00110100b
-10110110b & 10000000b = 10000000b
-10110110b & 10000001b = 10000000b
-10110110b & 10000010b = 10000010b
-10110110b & 10000011b = 10000010b
-10110110b & 10000100b = 10000100b
-10110110b & 10000101b = 10000100b
-10110110b & 10000110b = 10000110b
-10110110b & 10000111b = 10000110b
-10110110b & 10001000b = 10000000b
-10110110b & 10001001b = 10000000b
-10110110b & 10001010b = 10000010b
-10110110b & 10001011b = 10000010b
-10110110b & 10001100b = 10000100b
-10110110b & 10001101b = 10000100b
-10110110b & 10001110b = 10000110b
-10110110b & 10001111b = 10000110b
-10110110b & 10010000b = 10010000b
-10110110b & 10010001b = 10010000b
-10110110b & 10010010b = 10010010b
-10110110b & 10010011b = 10010010b
-10110110b & 10010100b = 10010100b
-10110110b & 10010101b = 10010100b
-10110110b & 10010110b = 10010110b
-10110110b & 10010111b = 10010110b
-10110110b & 10011000b = 10010000b
-10110110b & 10011001b = 10010000b
-10110110b & 10011010b = 10010010b
-10110110b & 10011011b = 10010010b
-10110110b & 10011100b = 10010100b
-10110110b & 10011101b = 10010100b
-10110110b & 10011110b = 10010110b
-10110110b & 10011111b = 10010110b
-10110110b & 10100000b = 10100000b
-10110110b & 10100001b = 10100000b
-10110110b & 10100010b = 10100010b
-10110110b & 10100011b = 10100010b
-10110110b & 10100100b = 10100100b
-10110110b & 10100101b = 10100100b
-10110110b & 10100110b = 10100110b
-10110110b & 10100111b = 10100110b
-10110110b & 10101000b = 10100000b
-10110110b & 10101001b = 10100000b
-10110110b & 10101010b = 10100010b
-10110110b & 10101011b = 10100010b
-10110110b & 10101100b = 10100100b
-10110110b & 10101101b = 10100100b
-10110110b & 10101110b = 10100110b
-10110110b & 10101111b = 10100110b
-10110110b & 10110000b = 10110000b
-10110110b & 10110001b = 10110000b
-10110110b & 10110010b = 10110010b
-10110110b & 10110011b = 10110010b
-10110110b & 10110100b = 10110100b
-10110110b & 10110101b = 10110100b
-10110110b & 10110110b = 10110110b
-10110110b & 10110111b = 10110110b
-10110110b & 10111000b = 10110000b
-10110110b & 10111001b = 10110000b
-10110110b & 10111010b = 10110010b
-10110110b & 10111011b = 10110010b
-10110110b & 10111100b = 10110100b
-10110110b & 10111101b = 10110100b
-10110110b & 10111110b = 10110110b
-10110110b & 10111111b = 10110110b
-10110110b & 11000000b = 10000000b
-10110110b & 11000001b = 10000000b
-10110110b & 11000010b = 10000010b
-10110110b & 11000011b = 10000010b
-10110110b & 11000100b = 10000100b
-10110110b & 11000101b = 10000100b
-10110110b & 11000110b = 10000110b
-10110110b & 11000111b = 10000110b
-10110110b & 11001000b = 10000000b
-10110110b & 11001001b = 10000000b
-10110110b & 11001010b = 10000010b
-10110110b & 11001011b = 10000010b
-10110110b & 11001100b = 10000100b
-10110110b & 11001101b = 10000100b
-10110110b & 11001110b = 10000110b
-10110110b & 11001111b = 10000110b
-10110110b & 11010000b = 10010000b
-10110110b & 11010001b = 10010000b
-10110110b & 11010010b = 10010010b
-10110110b & 11010011b = 10010010b
-10110110b & 11010100b = 10010100b
-10110110b & 11010101b = 10010100b
-10110110b & 11010110b = 10010110b
-10110110b & 11010111b = 10010110b
-10110110b & 11011000b = 10010000b
-10110110b & 11011001b = 10010000b
-10110110b & 11011010b = 10010010b
-10110110b & 11011011b = 10010010b
-10110110b & 11011100b = 10010100b
-10110110b & 11011101b = 10010100b
-10110110b & 11011110b = 10010110b
-10110110b & 11011111b = 10010110b
-10110110b & 11100000b = 10100000b
-10110110b & 11100001b = 10100000b
-10110110b & 11100010b = 10100010b
-10110110b & 11100011b = 10100010b
-10110110b & 11100100b = 10100100b
-10110110b & 11100101b = 10100100b
-10110110b & 11100110b = 10100110b
-10110110b & 11100111b = 10100110b
-10110110b & 11101000b = 10100000b
-10110110b & 11101001b = 10100000b
-10110110b & 11101010b = 10100010b
-10110110b & 11101011b = 10100010b
-10110110b & 11101100b = 10100100b
-10110110b & 11101101b = 10100100b
-10110110b & 11101110b = 10100110b
-10110110b & 11101111b = 10100110b
-10110110b & 11110000b = 10110000b
-10110110b & 11110001b = 10110000b
-10110110b & 11110010b = 10110010b
-10110110b & 11110011b = 10110010b
-10110110b & 11110100b = 10110100b
-10110110b & 11110101b = 10110100b
-10110110b & 11110110b = 10110110b
-10110110b & 11110111b = 10110110b
-10110110b & 11111000b = 10110000b
-10110110b & 11111001b = 10110000b
-10110110b & 11111010b = 10110010b
-10110110b & 11111011b = 10110010b
-10110110b & 11111100b = 10110100b
-10110110b & 11111101b = 10110100b
-10110110b & 11111110b = 10110110b
-10110110b & 11111111b = 10110110b
-10110110b & 00000000b = 00000000b
-10110110b & 00000001b = 00000000b
-10110110b & 00000010b = 00000010b
-10110110b & 00000011b = 00000010b
-10110110b & 00000100b = 00000100b
-10110110b & 00000101b = 00000100b
-10110110b & 00000110b = 00000110b
-10110110b & 00000111b = 00000110b
-10110110b & 00001000b = 00000000b
-10110110b & 00001001b = 00000000b
-10110110b & 00001010b = 00000010b
-10110110b & 00001011b = 00000010b
-10110110b & 00001100b = 00000100b
-10110110b & 00001101b = 00000100b
-10110110b & 00001110b = 00000110b
-10110110b & 00001111b = 00000110b
-10110110b & 00010000b = 00010000b
-10110110b & 00010001b = 00010000b
-10110110b & 00010010b = 00010010b
-10110110b & 00010011b = 00010010b
-10110110b & 00010100b = 00010100b
-10110110b & 00010101b = 00010100b
-10110110b & 00010110b = 00010110b
-10110110b & 00010111b = 00010110b
-10110110b & 00011000b = 00010000b
-10110110b & 00011001b = 00010000b
-10110110b & 00011010b = 00010010b
-10110110b & 00011011b = 00010010b
-10110110b & 00011100b = 00010100b
-10110110b & 00011101b = 00010100b
-10110110b & 00011110b = 00010110b
-10110110b & 00011111b = 00010110b
-10110110b & 00100000b = 00100000b
-10110110b & 00100001b = 00100000b
-10110110b & 00100010b = 00100010b
-10110110b & 00100011b = 00100010b
-10110110b & 00100100b = 00100100b
-10110110b & 00100101b = 00100100b
-10110110b & 00100110b = 00100110b
-10110110b & 00100111b = 00100110b
-10110110b & 00101000b = 00100000b
-10110110b & 00101001b = 00100000b
-10110110b & 00101010b = 00100010b
-10110110b & 00101011b = 00100010b
-10110110b & 00101100b = 00100100b
-10110110b & 00101101b = 00100100b
-10110110b & 00101110b = 00100110b
-10110110b & 00101111b = 00100110b
-10110110b & 00110000b = 00110000b
-10110110b & 00110001b = 00110000b
-10110110b & 00110010b = 00110010b
-10110110b & 00110011b = 00110010b
-10110110b & 00110100b = 00110100b
-10110110b & 00110101b = 00110100b
-10110110b & 00110110b = 00110110b
-10110110b & 00110111b = 00110110b
-10110110b & 00111000b = 00110000b
-10110110b & 00111001b = 00110000b
-10110110b & 00111010b = 00110010b
-10110110b & 00111011b = 00110010b
-10110110b & 00111100b = 00110100b
-10110110b & 00111101b = 00110100b
-10110110b & 00111110b = 00110110b
-10110110b & 00111111b = 00110110b
-10110110b & 01000000b = 00000000b
-10110110b & 01000001b = 00000000b
-10110110b & 01000010b = 00000010b
-10110110b & 01000011b = 00000010b
-10110110b & 01000100b = 00000100b
-10110110b & 01000101b = 00000100b
-10110110b & 01000110b = 00000110b
-10110110b & 01000111b = 00000110b
-10110110b & 01001000b = 00000000b
-10110110b & 01001001b = 00000000b
-10110110b & 01001010b = 00000010b
-10110110b & 01001011b = 00000010b
-10110110b & 01001100b = 00000100b
-10110110b & 01001101b = 00000100b
-10110110b & 01001110b = 00000110b
-10110110b & 01001111b = 00000110b
-10110110b & 01010000b = 00010000b
-10110110b & 01010001b = 00010000b
-10110110b & 01010010b = 00010010b
-10110110b & 01010011b = 00010010b
-10110110b & 01010100b = 00010100b
-10110110b & 01010101b = 00010100b
-10110110b & 01010110b = 00010110b
-10110110b & 01010111b = 00010110b
-10110110b & 01011000b = 00010000b
-10110110b & 01011001b = 00010000b
-10110110b & 01011010b = 00010010b
-10110110b & 01011011b = 00010010b
-10110110b & 01011100b = 00010100b
-10110110b & 01011101b = 00010100b
-10110110b & 01011110b = 00010110b
-10110110b & 01011111b = 00010110b
-10110110b & 01100000b = 00100000b
-10110110b & 01100001b = 00100000b
-10110110b & 01100010b = 00100010b
-10110110b & 01100011b = 00100010b
-10110110b & 01100100b = 00100100b
-10110110b & 01100101b = 00100100b
-10110110b & 01100110b = 00100110b
-10110110b & 01100111b = 00100110b
-10110110b & 01101000b = 00100000b
-10110110b & 01101001b = 00100000b
-10110110b & 01101010b = 00100010b
-10110110b & 01101011b = 00100010b
-10110110b & 01101100b = 00100100b
-10110110b & 01101101b = 00100100b
-10110110b & 01101110b = 00100110b
-10110110b & 01101111b = 00100110b
-10110110b & 01110000b = 00110000b
-10110110b & 01110001b = 00110000b
-10110110b & 01110010b = 00110010b
-10110110b & 01110011b = 00110010b
-10110110b & 01110100b = 00110100b
-10110110b & 01110101b = 00110100b
-10110110b & 01110110b = 00110110b
-10110110b & 01110111b = 00110110b
-10110110b & 01111000b = 00110000b
-10110110b & 01111001b = 00110000b
-10110110b & 01111010b = 00110010b
-10110110b & 01111011b = 00110010b
-10110110b & 01111100b = 00110100b
-10110110b & 01111101b = 00110100b
-10110110b & 01111110b = 00110110b
-10110111b & 10000000b = 10000000b
-10110111b & 10000001b = 10000001b
-10110111b & 10000010b = 10000010b
-10110111b & 10000011b = 10000011b
-10110111b & 10000100b = 10000100b
-10110111b & 10000101b = 10000101b
-10110111b & 10000110b = 10000110b
-10110111b & 10000111b = 10000111b
-10110111b & 10001000b = 10000000b
-10110111b & 10001001b = 10000001b
-10110111b & 10001010b = 10000010b
-10110111b & 10001011b = 10000011b
-10110111b & 10001100b = 10000100b
-10110111b & 10001101b = 10000101b
-10110111b & 10001110b = 10000110b
-10110111b & 10001111b = 10000111b
-10110111b & 10010000b = 10010000b
-10110111b & 10010001b = 10010001b
-10110111b & 10010010b = 10010010b
-10110111b & 10010011b = 10010011b
-10110111b & 10010100b = 10010100b
-10110111b & 10010101b = 10010101b
-10110111b & 10010110b = 10010110b
-10110111b & 10010111b = 10010111b
-10110111b & 10011000b = 10010000b
-10110111b & 10011001b = 10010001b
-10110111b & 10011010b = 10010010b
-10110111b & 10011011b = 10010011b
-10110111b & 10011100b = 10010100b
-10110111b & 10011101b = 10010101b
-10110111b & 10011110b = 10010110b
-10110111b & 10011111b = 10010111b
-10110111b & 10100000b = 10100000b
-10110111b & 10100001b = 10100001b
-10110111b & 10100010b = 10100010b
-10110111b & 10100011b = 10100011b
-10110111b & 10100100b = 10100100b
-10110111b & 10100101b = 10100101b
-10110111b & 10100110b = 10100110b
-10110111b & 10100111b = 10100111b
-10110111b & 10101000b = 10100000b
-10110111b & 10101001b = 10100001b
-10110111b & 10101010b = 10100010b
-10110111b & 10101011b = 10100011b
-10110111b & 10101100b = 10100100b
-10110111b & 10101101b = 10100101b
-10110111b & 10101110b = 10100110b
-10110111b & 10101111b = 10100111b
-10110111b & 10110000b = 10110000b
-10110111b & 10110001b = 10110001b
-10110111b & 10110010b = 10110010b
-10110111b & 10110011b = 10110011b
-10110111b & 10110100b = 10110100b
-10110111b & 10110101b = 10110101b
-10110111b & 10110110b = 10110110b
-10110111b & 10110111b = 10110111b
-10110111b & 10111000b = 10110000b
-10110111b & 10111001b = 10110001b
-10110111b & 10111010b = 10110010b
-10110111b & 10111011b = 10110011b
-10110111b & 10111100b = 10110100b
-10110111b & 10111101b = 10110101b
-10110111b & 10111110b = 10110110b
-10110111b & 10111111b = 10110111b
-10110111b & 11000000b = 10000000b
-10110111b & 11000001b = 10000001b
-10110111b & 11000010b = 10000010b
-10110111b & 11000011b = 10000011b
-10110111b & 11000100b = 10000100b
-10110111b & 11000101b = 10000101b
-10110111b & 11000110b = 10000110b
-10110111b & 11000111b = 10000111b
-10110111b & 11001000b = 10000000b
-10110111b & 11001001b = 10000001b
-10110111b & 11001010b = 10000010b
-10110111b & 11001011b = 10000011b
-10110111b & 11001100b = 10000100b
-10110111b & 11001101b = 10000101b
-10110111b & 11001110b = 10000110b
-10110111b & 11001111b = 10000111b
-10110111b & 11010000b = 10010000b
-10110111b & 11010001b = 10010001b
-10110111b & 11010010b = 10010010b
-10110111b & 11010011b = 10010011b
-10110111b & 11010100b = 10010100b
-10110111b & 11010101b = 10010101b
-10110111b & 11010110b = 10010110b
-10110111b & 11010111b = 10010111b
-10110111b & 11011000b = 10010000b
-10110111b & 11011001b = 10010001b
-10110111b & 11011010b = 10010010b
-10110111b & 11011011b = 10010011b
-10110111b & 11011100b = 10010100b
-10110111b & 11011101b = 10010101b
-10110111b & 11011110b = 10010110b
-10110111b & 11011111b = 10010111b
-10110111b & 11100000b = 10100000b
-10110111b & 11100001b = 10100001b
-10110111b & 11100010b = 10100010b
-10110111b & 11100011b = 10100011b
-10110111b & 11100100b = 10100100b
-10110111b & 11100101b = 10100101b
-10110111b & 11100110b = 10100110b
-10110111b & 11100111b = 10100111b
-10110111b & 11101000b = 10100000b
-10110111b & 11101001b = 10100001b
-10110111b & 11101010b = 10100010b
-10110111b & 11101011b = 10100011b
-10110111b & 11101100b = 10100100b
-10110111b & 11101101b = 10100101b
-10110111b & 11101110b = 10100110b
-10110111b & 11101111b = 10100111b
-10110111b & 11110000b = 10110000b
-10110111b & 11110001b = 10110001b
-10110111b & 11110010b = 10110010b
-10110111b & 11110011b = 10110011b
-10110111b & 11110100b = 10110100b
-10110111b & 11110101b = 10110101b
-10110111b & 11110110b = 10110110b
-10110111b & 11110111b = 10110111b
-10110111b & 11111000b = 10110000b
-10110111b & 11111001b = 10110001b
-10110111b & 11111010b = 10110010b
-10110111b & 11111011b = 10110011b
-10110111b & 11111100b = 10110100b
-10110111b & 11111101b = 10110101b
-10110111b & 11111110b = 10110110b
-10110111b & 11111111b = 10110111b
-10110111b & 00000000b = 00000000b
-10110111b & 00000001b = 00000001b
-10110111b & 00000010b = 00000010b
-10110111b & 00000011b = 00000011b
-10110111b & 00000100b = 00000100b
-10110111b & 00000101b = 00000101b
-10110111b & 00000110b = 00000110b
-10110111b & 00000111b = 00000111b
-10110111b & 00001000b = 00000000b
-10110111b & 00001001b = 00000001b
-10110111b & 00001010b = 00000010b
-10110111b & 00001011b = 00000011b
-10110111b & 00001100b = 00000100b
-10110111b & 00001101b = 00000101b
-10110111b & 00001110b = 00000110b
-10110111b & 00001111b = 00000111b
-10110111b & 00010000b = 00010000b
-10110111b & 00010001b = 00010001b
-10110111b & 00010010b = 00010010b
-10110111b & 00010011b = 00010011b
-10110111b & 00010100b = 00010100b
-10110111b & 00010101b = 00010101b
-10110111b & 00010110b = 00010110b
-10110111b & 00010111b = 00010111b
-10110111b & 00011000b = 00010000b
-10110111b & 00011001b = 00010001b
-10110111b & 00011010b = 00010010b
-10110111b & 00011011b = 00010011b
-10110111b & 00011100b = 00010100b
-10110111b & 00011101b = 00010101b
-10110111b & 00011110b = 00010110b
-10110111b & 00011111b = 00010111b
-10110111b & 00100000b = 00100000b
-10110111b & 00100001b = 00100001b
-10110111b & 00100010b = 00100010b
-10110111b & 00100011b = 00100011b
-10110111b & 00100100b = 00100100b
-10110111b & 00100101b = 00100101b
-10110111b & 00100110b = 00100110b
-10110111b & 00100111b = 00100111b
-10110111b & 00101000b = 00100000b
-10110111b & 00101001b = 00100001b
-10110111b & 00101010b = 00100010b
-10110111b & 00101011b = 00100011b
-10110111b & 00101100b = 00100100b
-10110111b & 00101101b = 00100101b
-10110111b & 00101110b = 00100110b
-10110111b & 00101111b = 00100111b
-10110111b & 00110000b = 00110000b
-10110111b & 00110001b = 00110001b
-10110111b & 00110010b = 00110010b
-10110111b & 00110011b = 00110011b
-10110111b & 00110100b = 00110100b
-10110111b & 00110101b = 00110101b
-10110111b & 00110110b = 00110110b
-10110111b & 00110111b = 00110111b
-10110111b & 00111000b = 00110000b
-10110111b & 00111001b = 00110001b
-10110111b & 00111010b = 00110010b
-10110111b & 00111011b = 00110011b
-10110111b & 00111100b = 00110100b
-10110111b & 00111101b = 00110101b
-10110111b & 00111110b = 00110110b
-10110111b & 00111111b = 00110111b
-10110111b & 01000000b = 00000000b
-10110111b & 01000001b = 00000001b
-10110111b & 01000010b = 00000010b
-10110111b & 01000011b = 00000011b
-10110111b & 01000100b = 00000100b
-10110111b & 01000101b = 00000101b
-10110111b & 01000110b = 00000110b
-10110111b & 01000111b = 00000111b
-10110111b & 01001000b = 00000000b
-10110111b & 01001001b = 00000001b
-10110111b & 01001010b = 00000010b
-10110111b & 01001011b = 00000011b
-10110111b & 01001100b = 00000100b
-10110111b & 01001101b = 00000101b
-10110111b & 01001110b = 00000110b
-10110111b & 01001111b = 00000111b
-10110111b & 01010000b = 00010000b
-10110111b & 01010001b = 00010001b
-10110111b & 01010010b = 00010010b
-10110111b & 01010011b = 00010011b
-10110111b & 01010100b = 00010100b
-10110111b & 01010101b = 00010101b
-10110111b & 01010110b = 00010110b
-10110111b & 01010111b = 00010111b
-10110111b & 01011000b = 00010000b
-10110111b & 01011001b = 00010001b
-10110111b & 01011010b = 00010010b
-10110111b & 01011011b = 00010011b
-10110111b & 01011100b = 00010100b
-10110111b & 01011101b = 00010101b
-10110111b & 01011110b = 00010110b
-10110111b & 01011111b = 00010111b
-10110111b & 01100000b = 00100000b
-10110111b & 01100001b = 00100001b
-10110111b & 01100010b = 00100010b
-10110111b & 01100011b = 00100011b
-10110111b & 01100100b = 00100100b
-10110111b & 01100101b = 00100101b
-10110111b & 01100110b = 00100110b
-10110111b & 01100111b = 00100111b
-10110111b & 01101000b = 00100000b
-10110111b & 01101001b = 00100001b
-10110111b & 01101010b = 00100010b
-10110111b & 01101011b = 00100011b
-10110111b & 01101100b = 00100100b
-10110111b & 01101101b = 00100101b
-10110111b & 01101110b = 00100110b
-10110111b & 01101111b = 00100111b
-10110111b & 01110000b = 00110000b
-10110111b & 01110001b = 00110001b
-10110111b & 01110010b = 00110010b
-10110111b & 01110011b = 00110011b
-10110111b & 01110100b = 00110100b
-10110111b & 01110101b = 00110101b
-10110111b & 01110110b = 00110110b
-10110111b & 01110111b = 00110111b
-10110111b & 01111000b = 00110000b
-10110111b & 01111001b = 00110001b
-10110111b & 01111010b = 00110010b
-10110111b & 01111011b = 00110011b
-10110111b & 01111100b = 00110100b
-10110111b & 01111101b = 00110101b
-10110111b & 01111110b = 00110110b
-10111000b & 10000000b = 10000000b
-10111000b & 10000001b = 10000000b
-10111000b & 10000010b = 10000000b
-10111000b & 10000011b = 10000000b
-10111000b & 10000100b = 10000000b
-10111000b & 10000101b = 10000000b
-10111000b & 10000110b = 10000000b
-10111000b & 10000111b = 10000000b
-10111000b & 10001000b = 10001000b
-10111000b & 10001001b = 10001000b
-10111000b & 10001010b = 10001000b
-10111000b & 10001011b = 10001000b
-10111000b & 10001100b = 10001000b
-10111000b & 10001101b = 10001000b
-10111000b & 10001110b = 10001000b
-10111000b & 10001111b = 10001000b
-10111000b & 10010000b = 10010000b
-10111000b & 10010001b = 10010000b
-10111000b & 10010010b = 10010000b
-10111000b & 10010011b = 10010000b
-10111000b & 10010100b = 10010000b
-10111000b & 10010101b = 10010000b
-10111000b & 10010110b = 10010000b
-10111000b & 10010111b = 10010000b
-10111000b & 10011000b = 10011000b
-10111000b & 10011001b = 10011000b
-10111000b & 10011010b = 10011000b
-10111000b & 10011011b = 10011000b
-10111000b & 10011100b = 10011000b
-10111000b & 10011101b = 10011000b
-10111000b & 10011110b = 10011000b
-10111000b & 10011111b = 10011000b
-10111000b & 10100000b = 10100000b
-10111000b & 10100001b = 10100000b
-10111000b & 10100010b = 10100000b
-10111000b & 10100011b = 10100000b
-10111000b & 10100100b = 10100000b
-10111000b & 10100101b = 10100000b
-10111000b & 10100110b = 10100000b
-10111000b & 10100111b = 10100000b
-10111000b & 10101000b = 10101000b
-10111000b & 10101001b = 10101000b
-10111000b & 10101010b = 10101000b
-10111000b & 10101011b = 10101000b
-10111000b & 10101100b = 10101000b
-10111000b & 10101101b = 10101000b
-10111000b & 10101110b = 10101000b
-10111000b & 10101111b = 10101000b
-10111000b & 10110000b = 10110000b
-10111000b & 10110001b = 10110000b
-10111000b & 10110010b = 10110000b
-10111000b & 10110011b = 10110000b
-10111000b & 10110100b = 10110000b
-10111000b & 10110101b = 10110000b
-10111000b & 10110110b = 10110000b
-10111000b & 10110111b = 10110000b
-10111000b & 10111000b = 10111000b
-10111000b & 10111001b = 10111000b
-10111000b & 10111010b = 10111000b
-10111000b & 10111011b = 10111000b
-10111000b & 10111100b = 10111000b
-10111000b & 10111101b = 10111000b
-10111000b & 10111110b = 10111000b
-10111000b & 10111111b = 10111000b
-10111000b & 11000000b = 10000000b
-10111000b & 11000001b = 10000000b
-10111000b & 11000010b = 10000000b
-10111000b & 11000011b = 10000000b
-10111000b & 11000100b = 10000000b
-10111000b & 11000101b = 10000000b
-10111000b & 11000110b = 10000000b
-10111000b & 11000111b = 10000000b
-10111000b & 11001000b = 10001000b
-10111000b & 11001001b = 10001000b
-10111000b & 11001010b = 10001000b
-10111000b & 11001011b = 10001000b
-10111000b & 11001100b = 10001000b
-10111000b & 11001101b = 10001000b
-10111000b & 11001110b = 10001000b
-10111000b & 11001111b = 10001000b
-10111000b & 11010000b = 10010000b
-10111000b & 11010001b = 10010000b
-10111000b & 11010010b = 10010000b
-10111000b & 11010011b = 10010000b
-10111000b & 11010100b = 10010000b
-10111000b & 11010101b = 10010000b
-10111000b & 11010110b = 10010000b
-10111000b & 11010111b = 10010000b
-10111000b & 11011000b = 10011000b
-10111000b & 11011001b = 10011000b
-10111000b & 11011010b = 10011000b
-10111000b & 11011011b = 10011000b
-10111000b & 11011100b = 10011000b
-10111000b & 11011101b = 10011000b
-10111000b & 11011110b = 10011000b
-10111000b & 11011111b = 10011000b
-10111000b & 11100000b = 10100000b
-10111000b & 11100001b = 10100000b
-10111000b & 11100010b = 10100000b
-10111000b & 11100011b = 10100000b
-10111000b & 11100100b = 10100000b
-10111000b & 11100101b = 10100000b
-10111000b & 11100110b = 10100000b
-10111000b & 11100111b = 10100000b
-10111000b & 11101000b = 10101000b
-10111000b & 11101001b = 10101000b
-10111000b & 11101010b = 10101000b
-10111000b & 11101011b = 10101000b
-10111000b & 11101100b = 10101000b
-10111000b & 11101101b = 10101000b
-10111000b & 11101110b = 10101000b
-10111000b & 11101111b = 10101000b
-10111000b & 11110000b = 10110000b
-10111000b & 11110001b = 10110000b
-10111000b & 11110010b = 10110000b
-10111000b & 11110011b = 10110000b
-10111000b & 11110100b = 10110000b
-10111000b & 11110101b = 10110000b
-10111000b & 11110110b = 10110000b
-10111000b & 11110111b = 10110000b
-10111000b & 11111000b = 10111000b
-10111000b & 11111001b = 10111000b
-10111000b & 11111010b = 10111000b
-10111000b & 11111011b = 10111000b
-10111000b & 11111100b = 10111000b
-10111000b & 11111101b = 10111000b
-10111000b & 11111110b = 10111000b
-10111000b & 11111111b = 10111000b
-10111000b & 00000000b = 00000000b
-10111000b & 00000001b = 00000000b
-10111000b & 00000010b = 00000000b
-10111000b & 00000011b = 00000000b
-10111000b & 00000100b = 00000000b
-10111000b & 00000101b = 00000000b
-10111000b & 00000110b = 00000000b
-10111000b & 00000111b = 00000000b
-10111000b & 00001000b = 00001000b
-10111000b & 00001001b = 00001000b
-10111000b & 00001010b = 00001000b
-10111000b & 00001011b = 00001000b
-10111000b & 00001100b = 00001000b
-10111000b & 00001101b = 00001000b
-10111000b & 00001110b = 00001000b
-10111000b & 00001111b = 00001000b
-10111000b & 00010000b = 00010000b
-10111000b & 00010001b = 00010000b
-10111000b & 00010010b = 00010000b
-10111000b & 00010011b = 00010000b
-10111000b & 00010100b = 00010000b
-10111000b & 00010101b = 00010000b
-10111000b & 00010110b = 00010000b
-10111000b & 00010111b = 00010000b
-10111000b & 00011000b = 00011000b
-10111000b & 00011001b = 00011000b
-10111000b & 00011010b = 00011000b
-10111000b & 00011011b = 00011000b
-10111000b & 00011100b = 00011000b
-10111000b & 00011101b = 00011000b
-10111000b & 00011110b = 00011000b
-10111000b & 00011111b = 00011000b
-10111000b & 00100000b = 00100000b
-10111000b & 00100001b = 00100000b
-10111000b & 00100010b = 00100000b
-10111000b & 00100011b = 00100000b
-10111000b & 00100100b = 00100000b
-10111000b & 00100101b = 00100000b
-10111000b & 00100110b = 00100000b
-10111000b & 00100111b = 00100000b
-10111000b & 00101000b = 00101000b
-10111000b & 00101001b = 00101000b
-10111000b & 00101010b = 00101000b
-10111000b & 00101011b = 00101000b
-10111000b & 00101100b = 00101000b
-10111000b & 00101101b = 00101000b
-10111000b & 00101110b = 00101000b
-10111000b & 00101111b = 00101000b
-10111000b & 00110000b = 00110000b
-10111000b & 00110001b = 00110000b
-10111000b & 00110010b = 00110000b
-10111000b & 00110011b = 00110000b
-10111000b & 00110100b = 00110000b
-10111000b & 00110101b = 00110000b
-10111000b & 00110110b = 00110000b
-10111000b & 00110111b = 00110000b
-10111000b & 00111000b = 00111000b
-10111000b & 00111001b = 00111000b
-10111000b & 00111010b = 00111000b
-10111000b & 00111011b = 00111000b
-10111000b & 00111100b = 00111000b
-10111000b & 00111101b = 00111000b
-10111000b & 00111110b = 00111000b
-10111000b & 00111111b = 00111000b
-10111000b & 01000000b = 00000000b
-10111000b & 01000001b = 00000000b
-10111000b & 01000010b = 00000000b
-10111000b & 01000011b = 00000000b
-10111000b & 01000100b = 00000000b
-10111000b & 01000101b = 00000000b
-10111000b & 01000110b = 00000000b
-10111000b & 01000111b = 00000000b
-10111000b & 01001000b = 00001000b
-10111000b & 01001001b = 00001000b
-10111000b & 01001010b = 00001000b
-10111000b & 01001011b = 00001000b
-10111000b & 01001100b = 00001000b
-10111000b & 01001101b = 00001000b
-10111000b & 01001110b = 00001000b
-10111000b & 01001111b = 00001000b
-10111000b & 01010000b = 00010000b
-10111000b & 01010001b = 00010000b
-10111000b & 01010010b = 00010000b
-10111000b & 01010011b = 00010000b
-10111000b & 01010100b = 00010000b
-10111000b & 01010101b = 00010000b
-10111000b & 01010110b = 00010000b
-10111000b & 01010111b = 00010000b
-10111000b & 01011000b = 00011000b
-10111000b & 01011001b = 00011000b
-10111000b & 01011010b = 00011000b
-10111000b & 01011011b = 00011000b
-10111000b & 01011100b = 00011000b
-10111000b & 01011101b = 00011000b
-10111000b & 01011110b = 00011000b
-10111000b & 01011111b = 00011000b
-10111000b & 01100000b = 00100000b
-10111000b & 01100001b = 00100000b
-10111000b & 01100010b = 00100000b
-10111000b & 01100011b = 00100000b
-10111000b & 01100100b = 00100000b
-10111000b & 01100101b = 00100000b
-10111000b & 01100110b = 00100000b
-10111000b & 01100111b = 00100000b
-10111000b & 01101000b = 00101000b
-10111000b & 01101001b = 00101000b
-10111000b & 01101010b = 00101000b
-10111000b & 01101011b = 00101000b
-10111000b & 01101100b = 00101000b
-10111000b & 01101101b = 00101000b
-10111000b & 01101110b = 00101000b
-10111000b & 01101111b = 00101000b
-10111000b & 01110000b = 00110000b
-10111000b & 01110001b = 00110000b
-10111000b & 01110010b = 00110000b
-10111000b & 01110011b = 00110000b
-10111000b & 01110100b = 00110000b
-10111000b & 01110101b = 00110000b
-10111000b & 01110110b = 00110000b
-10111000b & 01110111b = 00110000b
-10111000b & 01111000b = 00111000b
-10111000b & 01111001b = 00111000b
-10111000b & 01111010b = 00111000b
-10111000b & 01111011b = 00111000b
-10111000b & 01111100b = 00111000b
-10111000b & 01111101b = 00111000b
-10111000b & 01111110b = 00111000b
-10111001b & 10000000b = 10000000b
-10111001b & 10000001b = 10000001b
-10111001b & 10000010b = 10000000b
-10111001b & 10000011b = 10000001b
-10111001b & 10000100b = 10000000b
-10111001b & 10000101b = 10000001b
-10111001b & 10000110b = 10000000b
-10111001b & 10000111b = 10000001b
-10111001b & 10001000b = 10001000b
-10111001b & 10001001b = 10001001b
-10111001b & 10001010b = 10001000b
-10111001b & 10001011b = 10001001b
-10111001b & 10001100b = 10001000b
-10111001b & 10001101b = 10001001b
-10111001b & 10001110b = 10001000b
-10111001b & 10001111b = 10001001b
-10111001b & 10010000b = 10010000b
-10111001b & 10010001b = 10010001b
-10111001b & 10010010b = 10010000b
-10111001b & 10010011b = 10010001b
-10111001b & 10010100b = 10010000b
-10111001b & 10010101b = 10010001b
-10111001b & 10010110b = 10010000b
-10111001b & 10010111b = 10010001b
-10111001b & 10011000b = 10011000b
-10111001b & 10011001b = 10011001b
-10111001b & 10011010b = 10011000b
-10111001b & 10011011b = 10011001b
-10111001b & 10011100b = 10011000b
-10111001b & 10011101b = 10011001b
-10111001b & 10011110b = 10011000b
-10111001b & 10011111b = 10011001b
-10111001b & 10100000b = 10100000b
-10111001b & 10100001b = 10100001b
-10111001b & 10100010b = 10100000b
-10111001b & 10100011b = 10100001b
-10111001b & 10100100b = 10100000b
-10111001b & 10100101b = 10100001b
-10111001b & 10100110b = 10100000b
-10111001b & 10100111b = 10100001b
-10111001b & 10101000b = 10101000b
-10111001b & 10101001b = 10101001b
-10111001b & 10101010b = 10101000b
-10111001b & 10101011b = 10101001b
-10111001b & 10101100b = 10101000b
-10111001b & 10101101b = 10101001b
-10111001b & 10101110b = 10101000b
-10111001b & 10101111b = 10101001b
-10111001b & 10110000b = 10110000b
-10111001b & 10110001b = 10110001b
-10111001b & 10110010b = 10110000b
-10111001b & 10110011b = 10110001b
-10111001b & 10110100b = 10110000b
-10111001b & 10110101b = 10110001b
-10111001b & 10110110b = 10110000b
-10111001b & 10110111b = 10110001b
-10111001b & 10111000b = 10111000b
-10111001b & 10111001b = 10111001b
-10111001b & 10111010b = 10111000b
-10111001b & 10111011b = 10111001b
-10111001b & 10111100b = 10111000b
-10111001b & 10111101b = 10111001b
-10111001b & 10111110b = 10111000b
-10111001b & 10111111b = 10111001b
-10111001b & 11000000b = 10000000b
-10111001b & 11000001b = 10000001b
-10111001b & 11000010b = 10000000b
-10111001b & 11000011b = 10000001b
-10111001b & 11000100b = 10000000b
-10111001b & 11000101b = 10000001b
-10111001b & 11000110b = 10000000b
-10111001b & 11000111b = 10000001b
-10111001b & 11001000b = 10001000b
-10111001b & 11001001b = 10001001b
-10111001b & 11001010b = 10001000b
-10111001b & 11001011b = 10001001b
-10111001b & 11001100b = 10001000b
-10111001b & 11001101b = 10001001b
-10111001b & 11001110b = 10001000b
-10111001b & 11001111b = 10001001b
-10111001b & 11010000b = 10010000b
-10111001b & 11010001b = 10010001b
-10111001b & 11010010b = 10010000b
-10111001b & 11010011b = 10010001b
-10111001b & 11010100b = 10010000b
-10111001b & 11010101b = 10010001b
-10111001b & 11010110b = 10010000b
-10111001b & 11010111b = 10010001b
-10111001b & 11011000b = 10011000b
-10111001b & 11011001b = 10011001b
-10111001b & 11011010b = 10011000b
-10111001b & 11011011b = 10011001b
-10111001b & 11011100b = 10011000b
-10111001b & 11011101b = 10011001b
-10111001b & 11011110b = 10011000b
-10111001b & 11011111b = 10011001b
-10111001b & 11100000b = 10100000b
-10111001b & 11100001b = 10100001b
-10111001b & 11100010b = 10100000b
-10111001b & 11100011b = 10100001b
-10111001b & 11100100b = 10100000b
-10111001b & 11100101b = 10100001b
-10111001b & 11100110b = 10100000b
-10111001b & 11100111b = 10100001b
-10111001b & 11101000b = 10101000b
-10111001b & 11101001b = 10101001b
-10111001b & 11101010b = 10101000b
-10111001b & 11101011b = 10101001b
-10111001b & 11101100b = 10101000b
-10111001b & 11101101b = 10101001b
-10111001b & 11101110b = 10101000b
-10111001b & 11101111b = 10101001b
-10111001b & 11110000b = 10110000b
-10111001b & 11110001b = 10110001b
-10111001b & 11110010b = 10110000b
-10111001b & 11110011b = 10110001b
-10111001b & 11110100b = 10110000b
-10111001b & 11110101b = 10110001b
-10111001b & 11110110b = 10110000b
-10111001b & 11110111b = 10110001b
-10111001b & 11111000b = 10111000b
-10111001b & 11111001b = 10111001b
-10111001b & 11111010b = 10111000b
-10111001b & 11111011b = 10111001b
-10111001b & 11111100b = 10111000b
-10111001b & 11111101b = 10111001b
-10111001b & 11111110b = 10111000b
-10111001b & 11111111b = 10111001b
-10111001b & 00000000b = 00000000b
-10111001b & 00000001b = 00000001b
-10111001b & 00000010b = 00000000b
-10111001b & 00000011b = 00000001b
-10111001b & 00000100b = 00000000b
-10111001b & 00000101b = 00000001b
-10111001b & 00000110b = 00000000b
-10111001b & 00000111b = 00000001b
-10111001b & 00001000b = 00001000b
-10111001b & 00001001b = 00001001b
-10111001b & 00001010b = 00001000b
-10111001b & 00001011b = 00001001b
-10111001b & 00001100b = 00001000b
-10111001b & 00001101b = 00001001b
-10111001b & 00001110b = 00001000b
-10111001b & 00001111b = 00001001b
-10111001b & 00010000b = 00010000b
-10111001b & 00010001b = 00010001b
-10111001b & 00010010b = 00010000b
-10111001b & 00010011b = 00010001b
-10111001b & 00010100b = 00010000b
-10111001b & 00010101b = 00010001b
-10111001b & 00010110b = 00010000b
-10111001b & 00010111b = 00010001b
-10111001b & 00011000b = 00011000b
-10111001b & 00011001b = 00011001b
-10111001b & 00011010b = 00011000b
-10111001b & 00011011b = 00011001b
-10111001b & 00011100b = 00011000b
-10111001b & 00011101b = 00011001b
-10111001b & 00011110b = 00011000b
-10111001b & 00011111b = 00011001b
-10111001b & 00100000b = 00100000b
-10111001b & 00100001b = 00100001b
-10111001b & 00100010b = 00100000b
-10111001b & 00100011b = 00100001b
-10111001b & 00100100b = 00100000b
-10111001b & 00100101b = 00100001b
-10111001b & 00100110b = 00100000b
-10111001b & 00100111b = 00100001b
-10111001b & 00101000b = 00101000b
-10111001b & 00101001b = 00101001b
-10111001b & 00101010b = 00101000b
-10111001b & 00101011b = 00101001b
-10111001b & 00101100b = 00101000b
-10111001b & 00101101b = 00101001b
-10111001b & 00101110b = 00101000b
-10111001b & 00101111b = 00101001b
-10111001b & 00110000b = 00110000b
-10111001b & 00110001b = 00110001b
-10111001b & 00110010b = 00110000b
-10111001b & 00110011b = 00110001b
-10111001b & 00110100b = 00110000b
-10111001b & 00110101b = 00110001b
-10111001b & 00110110b = 00110000b
-10111001b & 00110111b = 00110001b
-10111001b & 00111000b = 00111000b
-10111001b & 00111001b = 00111001b
-10111001b & 00111010b = 00111000b
-10111001b & 00111011b = 00111001b
-10111001b & 00111100b = 00111000b
-10111001b & 00111101b = 00111001b
-10111001b & 00111110b = 00111000b
-10111001b & 00111111b = 00111001b
-10111001b & 01000000b = 00000000b
-10111001b & 01000001b = 00000001b
-10111001b & 01000010b = 00000000b
-10111001b & 01000011b = 00000001b
-10111001b & 01000100b = 00000000b
-10111001b & 01000101b = 00000001b
-10111001b & 01000110b = 00000000b
-10111001b & 01000111b = 00000001b
-10111001b & 01001000b = 00001000b
-10111001b & 01001001b = 00001001b
-10111001b & 01001010b = 00001000b
-10111001b & 01001011b = 00001001b
-10111001b & 01001100b = 00001000b
-10111001b & 01001101b = 00001001b
-10111001b & 01001110b = 00001000b
-10111001b & 01001111b = 00001001b
-10111001b & 01010000b = 00010000b
-10111001b & 01010001b = 00010001b
-10111001b & 01010010b = 00010000b
-10111001b & 01010011b = 00010001b
-10111001b & 01010100b = 00010000b
-10111001b & 01010101b = 00010001b
-10111001b & 01010110b = 00010000b
-10111001b & 01010111b = 00010001b
-10111001b & 01011000b = 00011000b
-10111001b & 01011001b = 00011001b
-10111001b & 01011010b = 00011000b
-10111001b & 01011011b = 00011001b
-10111001b & 01011100b = 00011000b
-10111001b & 01011101b = 00011001b
-10111001b & 01011110b = 00011000b
-10111001b & 01011111b = 00011001b
-10111001b & 01100000b = 00100000b
-10111001b & 01100001b = 00100001b
-10111001b & 01100010b = 00100000b
-10111001b & 01100011b = 00100001b
-10111001b & 01100100b = 00100000b
-10111001b & 01100101b = 00100001b
-10111001b & 01100110b = 00100000b
-10111001b & 01100111b = 00100001b
-10111001b & 01101000b = 00101000b
-10111001b & 01101001b = 00101001b
-10111001b & 01101010b = 00101000b
-10111001b & 01101011b = 00101001b
-10111001b & 01101100b = 00101000b
-10111001b & 01101101b = 00101001b
-10111001b & 01101110b = 00101000b
-10111001b & 01101111b = 00101001b
-10111001b & 01110000b = 00110000b
-10111001b & 01110001b = 00110001b
-10111001b & 01110010b = 00110000b
-10111001b & 01110011b = 00110001b
-10111001b & 01110100b = 00110000b
-10111001b & 01110101b = 00110001b
-10111001b & 01110110b = 00110000b
-10111001b & 01110111b = 00110001b
-10111001b & 01111000b = 00111000b
-10111001b & 01111001b = 00111001b
-10111001b & 01111010b = 00111000b
-10111001b & 01111011b = 00111001b
-10111001b & 01111100b = 00111000b
-10111001b & 01111101b = 00111001b
-10111001b & 01111110b = 00111000b
-10111010b & 10000000b = 10000000b
-10111010b & 10000001b = 10000000b
-10111010b & 10000010b = 10000010b
-10111010b & 10000011b = 10000010b
-10111010b & 10000100b = 10000000b
-10111010b & 10000101b = 10000000b
-10111010b & 10000110b = 10000010b
-10111010b & 10000111b = 10000010b
-10111010b & 10001000b = 10001000b
-10111010b & 10001001b = 10001000b
-10111010b & 10001010b = 10001010b
-10111010b & 10001011b = 10001010b
-10111010b & 10001100b = 10001000b
-10111010b & 10001101b = 10001000b
-10111010b & 10001110b = 10001010b
-10111010b & 10001111b = 10001010b
-10111010b & 10010000b = 10010000b
-10111010b & 10010001b = 10010000b
-10111010b & 10010010b = 10010010b
-10111010b & 10010011b = 10010010b
-10111010b & 10010100b = 10010000b
-10111010b & 10010101b = 10010000b
-10111010b & 10010110b = 10010010b
-10111010b & 10010111b = 10010010b
-10111010b & 10011000b = 10011000b
-10111010b & 10011001b = 10011000b
-10111010b & 10011010b = 10011010b
-10111010b & 10011011b = 10011010b
-10111010b & 10011100b = 10011000b
-10111010b & 10011101b = 10011000b
-10111010b & 10011110b = 10011010b
-10111010b & 10011111b = 10011010b
-10111010b & 10100000b = 10100000b
-10111010b & 10100001b = 10100000b
-10111010b & 10100010b = 10100010b
-10111010b & 10100011b = 10100010b
-10111010b & 10100100b = 10100000b
-10111010b & 10100101b = 10100000b
-10111010b & 10100110b = 10100010b
-10111010b & 10100111b = 10100010b
-10111010b & 10101000b = 10101000b
-10111010b & 10101001b = 10101000b
-10111010b & 10101010b = 10101010b
-10111010b & 10101011b = 10101010b
-10111010b & 10101100b = 10101000b
-10111010b & 10101101b = 10101000b
-10111010b & 10101110b = 10101010b
-10111010b & 10101111b = 10101010b
-10111010b & 10110000b = 10110000b
-10111010b & 10110001b = 10110000b
-10111010b & 10110010b = 10110010b
-10111010b & 10110011b = 10110010b
-10111010b & 10110100b = 10110000b
-10111010b & 10110101b = 10110000b
-10111010b & 10110110b = 10110010b
-10111010b & 10110111b = 10110010b
-10111010b & 10111000b = 10111000b
-10111010b & 10111001b = 10111000b
-10111010b & 10111010b = 10111010b
-10111010b & 10111011b = 10111010b
-10111010b & 10111100b = 10111000b
-10111010b & 10111101b = 10111000b
-10111010b & 10111110b = 10111010b
-10111010b & 10111111b = 10111010b
-10111010b & 11000000b = 10000000b
-10111010b & 11000001b = 10000000b
-10111010b & 11000010b = 10000010b
-10111010b & 11000011b = 10000010b
-10111010b & 11000100b = 10000000b
-10111010b & 11000101b = 10000000b
-10111010b & 11000110b = 10000010b
-10111010b & 11000111b = 10000010b
-10111010b & 11001000b = 10001000b
-10111010b & 11001001b = 10001000b
-10111010b & 11001010b = 10001010b
-10111010b & 11001011b = 10001010b
-10111010b & 11001100b = 10001000b
-10111010b & 11001101b = 10001000b
-10111010b & 11001110b = 10001010b
-10111010b & 11001111b = 10001010b
-10111010b & 11010000b = 10010000b
-10111010b & 11010001b = 10010000b
-10111010b & 11010010b = 10010010b
-10111010b & 11010011b = 10010010b
-10111010b & 11010100b = 10010000b
-10111010b & 11010101b = 10010000b
-10111010b & 11010110b = 10010010b
-10111010b & 11010111b = 10010010b
-10111010b & 11011000b = 10011000b
-10111010b & 11011001b = 10011000b
-10111010b & 11011010b = 10011010b
-10111010b & 11011011b = 10011010b
-10111010b & 11011100b = 10011000b
-10111010b & 11011101b = 10011000b
-10111010b & 11011110b = 10011010b
-10111010b & 11011111b = 10011010b
-10111010b & 11100000b = 10100000b
-10111010b & 11100001b = 10100000b
-10111010b & 11100010b = 10100010b
-10111010b & 11100011b = 10100010b
-10111010b & 11100100b = 10100000b
-10111010b & 11100101b = 10100000b
-10111010b & 11100110b = 10100010b
-10111010b & 11100111b = 10100010b
-10111010b & 11101000b = 10101000b
-10111010b & 11101001b = 10101000b
-10111010b & 11101010b = 10101010b
-10111010b & 11101011b = 10101010b
-10111010b & 11101100b = 10101000b
-10111010b & 11101101b = 10101000b
-10111010b & 11101110b = 10101010b
-10111010b & 11101111b = 10101010b
-10111010b & 11110000b = 10110000b
-10111010b & 11110001b = 10110000b
-10111010b & 11110010b = 10110010b
-10111010b & 11110011b = 10110010b
-10111010b & 11110100b = 10110000b
-10111010b & 11110101b = 10110000b
-10111010b & 11110110b = 10110010b
-10111010b & 11110111b = 10110010b
-10111010b & 11111000b = 10111000b
-10111010b & 11111001b = 10111000b
-10111010b & 11111010b = 10111010b
-10111010b & 11111011b = 10111010b
-10111010b & 11111100b = 10111000b
-10111010b & 11111101b = 10111000b
-10111010b & 11111110b = 10111010b
-10111010b & 11111111b = 10111010b
-10111010b & 00000000b = 00000000b
-10111010b & 00000001b = 00000000b
-10111010b & 00000010b = 00000010b
-10111010b & 00000011b = 00000010b
-10111010b & 00000100b = 00000000b
-10111010b & 00000101b = 00000000b
-10111010b & 00000110b = 00000010b
-10111010b & 00000111b = 00000010b
-10111010b & 00001000b = 00001000b
-10111010b & 00001001b = 00001000b
-10111010b & 00001010b = 00001010b
-10111010b & 00001011b = 00001010b
-10111010b & 00001100b = 00001000b
-10111010b & 00001101b = 00001000b
-10111010b & 00001110b = 00001010b
-10111010b & 00001111b = 00001010b
-10111010b & 00010000b = 00010000b
-10111010b & 00010001b = 00010000b
-10111010b & 00010010b = 00010010b
-10111010b & 00010011b = 00010010b
-10111010b & 00010100b = 00010000b
-10111010b & 00010101b = 00010000b
-10111010b & 00010110b = 00010010b
-10111010b & 00010111b = 00010010b
-10111010b & 00011000b = 00011000b
-10111010b & 00011001b = 00011000b
-10111010b & 00011010b = 00011010b
-10111010b & 00011011b = 00011010b
-10111010b & 00011100b = 00011000b
-10111010b & 00011101b = 00011000b
-10111010b & 00011110b = 00011010b
-10111010b & 00011111b = 00011010b
-10111010b & 00100000b = 00100000b
-10111010b & 00100001b = 00100000b
-10111010b & 00100010b = 00100010b
-10111010b & 00100011b = 00100010b
-10111010b & 00100100b = 00100000b
-10111010b & 00100101b = 00100000b
-10111010b & 00100110b = 00100010b
-10111010b & 00100111b = 00100010b
-10111010b & 00101000b = 00101000b
-10111010b & 00101001b = 00101000b
-10111010b & 00101010b = 00101010b
-10111010b & 00101011b = 00101010b
-10111010b & 00101100b = 00101000b
-10111010b & 00101101b = 00101000b
-10111010b & 00101110b = 00101010b
-10111010b & 00101111b = 00101010b
-10111010b & 00110000b = 00110000b
-10111010b & 00110001b = 00110000b
-10111010b & 00110010b = 00110010b
-10111010b & 00110011b = 00110010b
-10111010b & 00110100b = 00110000b
-10111010b & 00110101b = 00110000b
-10111010b & 00110110b = 00110010b
-10111010b & 00110111b = 00110010b
-10111010b & 00111000b = 00111000b
-10111010b & 00111001b = 00111000b
-10111010b & 00111010b = 00111010b
-10111010b & 00111011b = 00111010b
-10111010b & 00111100b = 00111000b
-10111010b & 00111101b = 00111000b
-10111010b & 00111110b = 00111010b
-10111010b & 00111111b = 00111010b
-10111010b & 01000000b = 00000000b
-10111010b & 01000001b = 00000000b
-10111010b & 01000010b = 00000010b
-10111010b & 01000011b = 00000010b
-10111010b & 01000100b = 00000000b
-10111010b & 01000101b = 00000000b
-10111010b & 01000110b = 00000010b
-10111010b & 01000111b = 00000010b
-10111010b & 01001000b = 00001000b
-10111010b & 01001001b = 00001000b
-10111010b & 01001010b = 00001010b
-10111010b & 01001011b = 00001010b
-10111010b & 01001100b = 00001000b
-10111010b & 01001101b = 00001000b
-10111010b & 01001110b = 00001010b
-10111010b & 01001111b = 00001010b
-10111010b & 01010000b = 00010000b
-10111010b & 01010001b = 00010000b
-10111010b & 01010010b = 00010010b
-10111010b & 01010011b = 00010010b
-10111010b & 01010100b = 00010000b
-10111010b & 01010101b = 00010000b
-10111010b & 01010110b = 00010010b
-10111010b & 01010111b = 00010010b
-10111010b & 01011000b = 00011000b
-10111010b & 01011001b = 00011000b
-10111010b & 01011010b = 00011010b
-10111010b & 01011011b = 00011010b
-10111010b & 01011100b = 00011000b
-10111010b & 01011101b = 00011000b
-10111010b & 01011110b = 00011010b
-10111010b & 01011111b = 00011010b
-10111010b & 01100000b = 00100000b
-10111010b & 01100001b = 00100000b
-10111010b & 01100010b = 00100010b
-10111010b & 01100011b = 00100010b
-10111010b & 01100100b = 00100000b
-10111010b & 01100101b = 00100000b
-10111010b & 01100110b = 00100010b
-10111010b & 01100111b = 00100010b
-10111010b & 01101000b = 00101000b
-10111010b & 01101001b = 00101000b
-10111010b & 01101010b = 00101010b
-10111010b & 01101011b = 00101010b
-10111010b & 01101100b = 00101000b
-10111010b & 01101101b = 00101000b
-10111010b & 01101110b = 00101010b
-10111010b & 01101111b = 00101010b
-10111010b & 01110000b = 00110000b
-10111010b & 01110001b = 00110000b
-10111010b & 01110010b = 00110010b
-10111010b & 01110011b = 00110010b
-10111010b & 01110100b = 00110000b
-10111010b & 01110101b = 00110000b
-10111010b & 01110110b = 00110010b
-10111010b & 01110111b = 00110010b
-10111010b & 01111000b = 00111000b
-10111010b & 01111001b = 00111000b
-10111010b & 01111010b = 00111010b
-10111010b & 01111011b = 00111010b
-10111010b & 01111100b = 00111000b
-10111010b & 01111101b = 00111000b
-10111010b & 01111110b = 00111010b
-10111011b & 10000000b = 10000000b
-10111011b & 10000001b = 10000001b
-10111011b & 10000010b = 10000010b
-10111011b & 10000011b = 10000011b
-10111011b & 10000100b = 10000000b
-10111011b & 10000101b = 10000001b
-10111011b & 10000110b = 10000010b
-10111011b & 10000111b = 10000011b
-10111011b & 10001000b = 10001000b
-10111011b & 10001001b = 10001001b
-10111011b & 10001010b = 10001010b
-10111011b & 10001011b = 10001011b
-10111011b & 10001100b = 10001000b
-10111011b & 10001101b = 10001001b
-10111011b & 10001110b = 10001010b
-10111011b & 10001111b = 10001011b
-10111011b & 10010000b = 10010000b
-10111011b & 10010001b = 10010001b
-10111011b & 10010010b = 10010010b
-10111011b & 10010011b = 10010011b
-10111011b & 10010100b = 10010000b
-10111011b & 10010101b = 10010001b
-10111011b & 10010110b = 10010010b
-10111011b & 10010111b = 10010011b
-10111011b & 10011000b = 10011000b
-10111011b & 10011001b = 10011001b
-10111011b & 10011010b = 10011010b
-10111011b & 10011011b = 10011011b
-10111011b & 10011100b = 10011000b
-10111011b & 10011101b = 10011001b
-10111011b & 10011110b = 10011010b
-10111011b & 10011111b = 10011011b
-10111011b & 10100000b = 10100000b
-10111011b & 10100001b = 10100001b
-10111011b & 10100010b = 10100010b
-10111011b & 10100011b = 10100011b
-10111011b & 10100100b = 10100000b
-10111011b & 10100101b = 10100001b
-10111011b & 10100110b = 10100010b
-10111011b & 10100111b = 10100011b
-10111011b & 10101000b = 10101000b
-10111011b & 10101001b = 10101001b
-10111011b & 10101010b = 10101010b
-10111011b & 10101011b = 10101011b
-10111011b & 10101100b = 10101000b
-10111011b & 10101101b = 10101001b
-10111011b & 10101110b = 10101010b
-10111011b & 10101111b = 10101011b
-10111011b & 10110000b = 10110000b
-10111011b & 10110001b = 10110001b
-10111011b & 10110010b = 10110010b
-10111011b & 10110011b = 10110011b
-10111011b & 10110100b = 10110000b
-10111011b & 10110101b = 10110001b
-10111011b & 10110110b = 10110010b
-10111011b & 10110111b = 10110011b
-10111011b & 10111000b = 10111000b
-10111011b & 10111001b = 10111001b
-10111011b & 10111010b = 10111010b
-10111011b & 10111011b = 10111011b
-10111011b & 10111100b = 10111000b
-10111011b & 10111101b = 10111001b
-10111011b & 10111110b = 10111010b
-10111011b & 10111111b = 10111011b
-10111011b & 11000000b = 10000000b
-10111011b & 11000001b = 10000001b
-10111011b & 11000010b = 10000010b
-10111011b & 11000011b = 10000011b
-10111011b & 11000100b = 10000000b
-10111011b & 11000101b = 10000001b
-10111011b & 11000110b = 10000010b
-10111011b & 11000111b = 10000011b
-10111011b & 11001000b = 10001000b
-10111011b & 11001001b = 10001001b
-10111011b & 11001010b = 10001010b
-10111011b & 11001011b = 10001011b
-10111011b & 11001100b = 10001000b
-10111011b & 11001101b = 10001001b
-10111011b & 11001110b = 10001010b
-10111011b & 11001111b = 10001011b
-10111011b & 11010000b = 10010000b
-10111011b & 11010001b = 10010001b
-10111011b & 11010010b = 10010010b
-10111011b & 11010011b = 10010011b
-10111011b & 11010100b = 10010000b
-10111011b & 11010101b = 10010001b
-10111011b & 11010110b = 10010010b
-10111011b & 11010111b = 10010011b
-10111011b & 11011000b = 10011000b
-10111011b & 11011001b = 10011001b
-10111011b & 11011010b = 10011010b
-10111011b & 11011011b = 10011011b
-10111011b & 11011100b = 10011000b
-10111011b & 11011101b = 10011001b
-10111011b & 11011110b = 10011010b
-10111011b & 11011111b = 10011011b
-10111011b & 11100000b = 10100000b
-10111011b & 11100001b = 10100001b
-10111011b & 11100010b = 10100010b
-10111011b & 11100011b = 10100011b
-10111011b & 11100100b = 10100000b
-10111011b & 11100101b = 10100001b
-10111011b & 11100110b = 10100010b
-10111011b & 11100111b = 10100011b
-10111011b & 11101000b = 10101000b
-10111011b & 11101001b = 10101001b
-10111011b & 11101010b = 10101010b
-10111011b & 11101011b = 10101011b
-10111011b & 11101100b = 10101000b
-10111011b & 11101101b = 10101001b
-10111011b & 11101110b = 10101010b
-10111011b & 11101111b = 10101011b
-10111011b & 11110000b = 10110000b
-10111011b & 11110001b = 10110001b
-10111011b & 11110010b = 10110010b
-10111011b & 11110011b = 10110011b
-10111011b & 11110100b = 10110000b
-10111011b & 11110101b = 10110001b
-10111011b & 11110110b = 10110010b
-10111011b & 11110111b = 10110011b
-10111011b & 11111000b = 10111000b
-10111011b & 11111001b = 10111001b
-10111011b & 11111010b = 10111010b
-10111011b & 11111011b = 10111011b
-10111011b & 11111100b = 10111000b
-10111011b & 11111101b = 10111001b
-10111011b & 11111110b = 10111010b
-10111011b & 11111111b = 10111011b
-10111011b & 00000000b = 00000000b
-10111011b & 00000001b = 00000001b
-10111011b & 00000010b = 00000010b
-10111011b & 00000011b = 00000011b
-10111011b & 00000100b = 00000000b
-10111011b & 00000101b = 00000001b
-10111011b & 00000110b = 00000010b
-10111011b & 00000111b = 00000011b
-10111011b & 00001000b = 00001000b
-10111011b & 00001001b = 00001001b
-10111011b & 00001010b = 00001010b
-10111011b & 00001011b = 00001011b
-10111011b & 00001100b = 00001000b
-10111011b & 00001101b = 00001001b
-10111011b & 00001110b = 00001010b
-10111011b & 00001111b = 00001011b
-10111011b & 00010000b = 00010000b
-10111011b & 00010001b = 00010001b
-10111011b & 00010010b = 00010010b
-10111011b & 00010011b = 00010011b
-10111011b & 00010100b = 00010000b
-10111011b & 00010101b = 00010001b
-10111011b & 00010110b = 00010010b
-10111011b & 00010111b = 00010011b
-10111011b & 00011000b = 00011000b
-10111011b & 00011001b = 00011001b
-10111011b & 00011010b = 00011010b
-10111011b & 00011011b = 00011011b
-10111011b & 00011100b = 00011000b
-10111011b & 00011101b = 00011001b
-10111011b & 00011110b = 00011010b
-10111011b & 00011111b = 00011011b
-10111011b & 00100000b = 00100000b
-10111011b & 00100001b = 00100001b
-10111011b & 00100010b = 00100010b
-10111011b & 00100011b = 00100011b
-10111011b & 00100100b = 00100000b
-10111011b & 00100101b = 00100001b
-10111011b & 00100110b = 00100010b
-10111011b & 00100111b = 00100011b
-10111011b & 00101000b = 00101000b
-10111011b & 00101001b = 00101001b
-10111011b & 00101010b = 00101010b
-10111011b & 00101011b = 00101011b
-10111011b & 00101100b = 00101000b
-10111011b & 00101101b = 00101001b
-10111011b & 00101110b = 00101010b
-10111011b & 00101111b = 00101011b
-10111011b & 00110000b = 00110000b
-10111011b & 00110001b = 00110001b
-10111011b & 00110010b = 00110010b
-10111011b & 00110011b = 00110011b
-10111011b & 00110100b = 00110000b
-10111011b & 00110101b = 00110001b
-10111011b & 00110110b = 00110010b
-10111011b & 00110111b = 00110011b
-10111011b & 00111000b = 00111000b
-10111011b & 00111001b = 00111001b
-10111011b & 00111010b = 00111010b
-10111011b & 00111011b = 00111011b
-10111011b & 00111100b = 00111000b
-10111011b & 00111101b = 00111001b
-10111011b & 00111110b = 00111010b
-10111011b & 00111111b = 00111011b
-10111011b & 01000000b = 00000000b
-10111011b & 01000001b = 00000001b
-10111011b & 01000010b = 00000010b
-10111011b & 01000011b = 00000011b
-10111011b & 01000100b = 00000000b
-10111011b & 01000101b = 00000001b
-10111011b & 01000110b = 00000010b
-10111011b & 01000111b = 00000011b
-10111011b & 01001000b = 00001000b
-10111011b & 01001001b = 00001001b
-10111011b & 01001010b = 00001010b
-10111011b & 01001011b = 00001011b
-10111011b & 01001100b = 00001000b
-10111011b & 01001101b = 00001001b
-10111011b & 01001110b = 00001010b
-10111011b & 01001111b = 00001011b
-10111011b & 01010000b = 00010000b
-10111011b & 01010001b = 00010001b
-10111011b & 01010010b = 00010010b
-10111011b & 01010011b = 00010011b
-10111011b & 01010100b = 00010000b
-10111011b & 01010101b = 00010001b
-10111011b & 01010110b = 00010010b
-10111011b & 01010111b = 00010011b
-10111011b & 01011000b = 00011000b
-10111011b & 01011001b = 00011001b
-10111011b & 01011010b = 00011010b
-10111011b & 01011011b = 00011011b
-10111011b & 01011100b = 00011000b
-10111011b & 01011101b = 00011001b
-10111011b & 01011110b = 00011010b
-10111011b & 01011111b = 00011011b
-10111011b & 01100000b = 00100000b
-10111011b & 01100001b = 00100001b
-10111011b & 01100010b = 00100010b
-10111011b & 01100011b = 00100011b
-10111011b & 01100100b = 00100000b
-10111011b & 01100101b = 00100001b
-10111011b & 01100110b = 00100010b
-10111011b & 01100111b = 00100011b
-10111011b & 01101000b = 00101000b
-10111011b & 01101001b = 00101001b
-10111011b & 01101010b = 00101010b
-10111011b & 01101011b = 00101011b
-10111011b & 01101100b = 00101000b
-10111011b & 01101101b = 00101001b
-10111011b & 01101110b = 00101010b
-10111011b & 01101111b = 00101011b
-10111011b & 01110000b = 00110000b
-10111011b & 01110001b = 00110001b
-10111011b & 01110010b = 00110010b
-10111011b & 01110011b = 00110011b
-10111011b & 01110100b = 00110000b
-10111011b & 01110101b = 00110001b
-10111011b & 01110110b = 00110010b
-10111011b & 01110111b = 00110011b
-10111011b & 01111000b = 00111000b
-10111011b & 01111001b = 00111001b
-10111011b & 01111010b = 00111010b
-10111011b & 01111011b = 00111011b
-10111011b & 01111100b = 00111000b
-10111011b & 01111101b = 00111001b
-10111011b & 01111110b = 00111010b
-10111100b & 10000000b = 10000000b
-10111100b & 10000001b = 10000000b
-10111100b & 10000010b = 10000000b
-10111100b & 10000011b = 10000000b
-10111100b & 10000100b = 10000100b
-10111100b & 10000101b = 10000100b
-10111100b & 10000110b = 10000100b
-10111100b & 10000111b = 10000100b
-10111100b & 10001000b = 10001000b
-10111100b & 10001001b = 10001000b
-10111100b & 10001010b = 10001000b
-10111100b & 10001011b = 10001000b
-10111100b & 10001100b = 10001100b
-10111100b & 10001101b = 10001100b
-10111100b & 10001110b = 10001100b
-10111100b & 10001111b = 10001100b
-10111100b & 10010000b = 10010000b
-10111100b & 10010001b = 10010000b
-10111100b & 10010010b = 10010000b
-10111100b & 10010011b = 10010000b
-10111100b & 10010100b = 10010100b
-10111100b & 10010101b = 10010100b
-10111100b & 10010110b = 10010100b
-10111100b & 10010111b = 10010100b
-10111100b & 10011000b = 10011000b
-10111100b & 10011001b = 10011000b
-10111100b & 10011010b = 10011000b
-10111100b & 10011011b = 10011000b
-10111100b & 10011100b = 10011100b
-10111100b & 10011101b = 10011100b
-10111100b & 10011110b = 10011100b
-10111100b & 10011111b = 10011100b
-10111100b & 10100000b = 10100000b
-10111100b & 10100001b = 10100000b
-10111100b & 10100010b = 10100000b
-10111100b & 10100011b = 10100000b
-10111100b & 10100100b = 10100100b
-10111100b & 10100101b = 10100100b
-10111100b & 10100110b = 10100100b
-10111100b & 10100111b = 10100100b
-10111100b & 10101000b = 10101000b
-10111100b & 10101001b = 10101000b
-10111100b & 10101010b = 10101000b
-10111100b & 10101011b = 10101000b
-10111100b & 10101100b = 10101100b
-10111100b & 10101101b = 10101100b
-10111100b & 10101110b = 10101100b
-10111100b & 10101111b = 10101100b
-10111100b & 10110000b = 10110000b
-10111100b & 10110001b = 10110000b
-10111100b & 10110010b = 10110000b
-10111100b & 10110011b = 10110000b
-10111100b & 10110100b = 10110100b
-10111100b & 10110101b = 10110100b
-10111100b & 10110110b = 10110100b
-10111100b & 10110111b = 10110100b
-10111100b & 10111000b = 10111000b
-10111100b & 10111001b = 10111000b
-10111100b & 10111010b = 10111000b
-10111100b & 10111011b = 10111000b
-10111100b & 10111100b = 10111100b
-10111100b & 10111101b = 10111100b
-10111100b & 10111110b = 10111100b
-10111100b & 10111111b = 10111100b
-10111100b & 11000000b = 10000000b
-10111100b & 11000001b = 10000000b
-10111100b & 11000010b = 10000000b
-10111100b & 11000011b = 10000000b
-10111100b & 11000100b = 10000100b
-10111100b & 11000101b = 10000100b
-10111100b & 11000110b = 10000100b
-10111100b & 11000111b = 10000100b
-10111100b & 11001000b = 10001000b
-10111100b & 11001001b = 10001000b
-10111100b & 11001010b = 10001000b
-10111100b & 11001011b = 10001000b
-10111100b & 11001100b = 10001100b
-10111100b & 11001101b = 10001100b
-10111100b & 11001110b = 10001100b
-10111100b & 11001111b = 10001100b
-10111100b & 11010000b = 10010000b
-10111100b & 11010001b = 10010000b
-10111100b & 11010010b = 10010000b
-10111100b & 11010011b = 10010000b
-10111100b & 11010100b = 10010100b
-10111100b & 11010101b = 10010100b
-10111100b & 11010110b = 10010100b
-10111100b & 11010111b = 10010100b
-10111100b & 11011000b = 10011000b
-10111100b & 11011001b = 10011000b
-10111100b & 11011010b = 10011000b
-10111100b & 11011011b = 10011000b
-10111100b & 11011100b = 10011100b
-10111100b & 11011101b = 10011100b
-10111100b & 11011110b = 10011100b
-10111100b & 11011111b = 10011100b
-10111100b & 11100000b = 10100000b
-10111100b & 11100001b = 10100000b
-10111100b & 11100010b = 10100000b
-10111100b & 11100011b = 10100000b
-10111100b & 11100100b = 10100100b
-10111100b & 11100101b = 10100100b
-10111100b & 11100110b = 10100100b
-10111100b & 11100111b = 10100100b
-10111100b & 11101000b = 10101000b
-10111100b & 11101001b = 10101000b
-10111100b & 11101010b = 10101000b
-10111100b & 11101011b = 10101000b
-10111100b & 11101100b = 10101100b
-10111100b & 11101101b = 10101100b
-10111100b & 11101110b = 10101100b
-10111100b & 11101111b = 10101100b
-10111100b & 11110000b = 10110000b
-10111100b & 11110001b = 10110000b
-10111100b & 11110010b = 10110000b
-10111100b & 11110011b = 10110000b
-10111100b & 11110100b = 10110100b
-10111100b & 11110101b = 10110100b
-10111100b & 11110110b = 10110100b
-10111100b & 11110111b = 10110100b
-10111100b & 11111000b = 10111000b
-10111100b & 11111001b = 10111000b
-10111100b & 11111010b = 10111000b
-10111100b & 11111011b = 10111000b
-10111100b & 11111100b = 10111100b
-10111100b & 11111101b = 10111100b
-10111100b & 11111110b = 10111100b
-10111100b & 11111111b = 10111100b
-10111100b & 00000000b = 00000000b
-10111100b & 00000001b = 00000000b
-10111100b & 00000010b = 00000000b
-10111100b & 00000011b = 00000000b
-10111100b & 00000100b = 00000100b
-10111100b & 00000101b = 00000100b
-10111100b & 00000110b = 00000100b
-10111100b & 00000111b = 00000100b
-10111100b & 00001000b = 00001000b
-10111100b & 00001001b = 00001000b
-10111100b & 00001010b = 00001000b
-10111100b & 00001011b = 00001000b
-10111100b & 00001100b = 00001100b
-10111100b & 00001101b = 00001100b
-10111100b & 00001110b = 00001100b
-10111100b & 00001111b = 00001100b
-10111100b & 00010000b = 00010000b
-10111100b & 00010001b = 00010000b
-10111100b & 00010010b = 00010000b
-10111100b & 00010011b = 00010000b
-10111100b & 00010100b = 00010100b
-10111100b & 00010101b = 00010100b
-10111100b & 00010110b = 00010100b
-10111100b & 00010111b = 00010100b
-10111100b & 00011000b = 00011000b
-10111100b & 00011001b = 00011000b
-10111100b & 00011010b = 00011000b
-10111100b & 00011011b = 00011000b
-10111100b & 00011100b = 00011100b
-10111100b & 00011101b = 00011100b
-10111100b & 00011110b = 00011100b
-10111100b & 00011111b = 00011100b
-10111100b & 00100000b = 00100000b
-10111100b & 00100001b = 00100000b
-10111100b & 00100010b = 00100000b
-10111100b & 00100011b = 00100000b
-10111100b & 00100100b = 00100100b
-10111100b & 00100101b = 00100100b
-10111100b & 00100110b = 00100100b
-10111100b & 00100111b = 00100100b
-10111100b & 00101000b = 00101000b
-10111100b & 00101001b = 00101000b
-10111100b & 00101010b = 00101000b
-10111100b & 00101011b = 00101000b
-10111100b & 00101100b = 00101100b
-10111100b & 00101101b = 00101100b
-10111100b & 00101110b = 00101100b
-10111100b & 00101111b = 00101100b
-10111100b & 00110000b = 00110000b
-10111100b & 00110001b = 00110000b
-10111100b & 00110010b = 00110000b
-10111100b & 00110011b = 00110000b
-10111100b & 00110100b = 00110100b
-10111100b & 00110101b = 00110100b
-10111100b & 00110110b = 00110100b
-10111100b & 00110111b = 00110100b
-10111100b & 00111000b = 00111000b
-10111100b & 00111001b = 00111000b
-10111100b & 00111010b = 00111000b
-10111100b & 00111011b = 00111000b
-10111100b & 00111100b = 00111100b
-10111100b & 00111101b = 00111100b
-10111100b & 00111110b = 00111100b
-10111100b & 00111111b = 00111100b
-10111100b & 01000000b = 00000000b
-10111100b & 01000001b = 00000000b
-10111100b & 01000010b = 00000000b
-10111100b & 01000011b = 00000000b
-10111100b & 01000100b = 00000100b
-10111100b & 01000101b = 00000100b
-10111100b & 01000110b = 00000100b
-10111100b & 01000111b = 00000100b
-10111100b & 01001000b = 00001000b
-10111100b & 01001001b = 00001000b
-10111100b & 01001010b = 00001000b
-10111100b & 01001011b = 00001000b
-10111100b & 01001100b = 00001100b
-10111100b & 01001101b = 00001100b
-10111100b & 01001110b = 00001100b
-10111100b & 01001111b = 00001100b
-10111100b & 01010000b = 00010000b
-10111100b & 01010001b = 00010000b
-10111100b & 01010010b = 00010000b
-10111100b & 01010011b = 00010000b
-10111100b & 01010100b = 00010100b
-10111100b & 01010101b = 00010100b
-10111100b & 01010110b = 00010100b
-10111100b & 01010111b = 00010100b
-10111100b & 01011000b = 00011000b
-10111100b & 01011001b = 00011000b
-10111100b & 01011010b = 00011000b
-10111100b & 01011011b = 00011000b
-10111100b & 01011100b = 00011100b
-10111100b & 01011101b = 00011100b
-10111100b & 01011110b = 00011100b
-10111100b & 01011111b = 00011100b
-10111100b & 01100000b = 00100000b
-10111100b & 01100001b = 00100000b
-10111100b & 01100010b = 00100000b
-10111100b & 01100011b = 00100000b
-10111100b & 01100100b = 00100100b
-10111100b & 01100101b = 00100100b
-10111100b & 01100110b = 00100100b
-10111100b & 01100111b = 00100100b
-10111100b & 01101000b = 00101000b
-10111100b & 01101001b = 00101000b
-10111100b & 01101010b = 00101000b
-10111100b & 01101011b = 00101000b
-10111100b & 01101100b = 00101100b
-10111100b & 01101101b = 00101100b
-10111100b & 01101110b = 00101100b
-10111100b & 01101111b = 00101100b
-10111100b & 01110000b = 00110000b
-10111100b & 01110001b = 00110000b
-10111100b & 01110010b = 00110000b
-10111100b & 01110011b = 00110000b
-10111100b & 01110100b = 00110100b
-10111100b & 01110101b = 00110100b
-10111100b & 01110110b = 00110100b
-10111100b & 01110111b = 00110100b
-10111100b & 01111000b = 00111000b
-10111100b & 01111001b = 00111000b
-10111100b & 01111010b = 00111000b
-10111100b & 01111011b = 00111000b
-10111100b & 01111100b = 00111100b
-10111100b & 01111101b = 00111100b
-10111100b & 01111110b = 00111100b
-10111101b & 10000000b = 10000000b
-10111101b & 10000001b = 10000001b
-10111101b & 10000010b = 10000000b
-10111101b & 10000011b = 10000001b
-10111101b & 10000100b = 10000100b
-10111101b & 10000101b = 10000101b
-10111101b & 10000110b = 10000100b
-10111101b & 10000111b = 10000101b
-10111101b & 10001000b = 10001000b
-10111101b & 10001001b = 10001001b
-10111101b & 10001010b = 10001000b
-10111101b & 10001011b = 10001001b
-10111101b & 10001100b = 10001100b
-10111101b & 10001101b = 10001101b
-10111101b & 10001110b = 10001100b
-10111101b & 10001111b = 10001101b
-10111101b & 10010000b = 10010000b
-10111101b & 10010001b = 10010001b
-10111101b & 10010010b = 10010000b
-10111101b & 10010011b = 10010001b
-10111101b & 10010100b = 10010100b
-10111101b & 10010101b = 10010101b
-10111101b & 10010110b = 10010100b
-10111101b & 10010111b = 10010101b
-10111101b & 10011000b = 10011000b
-10111101b & 10011001b = 10011001b
-10111101b & 10011010b = 10011000b
-10111101b & 10011011b = 10011001b
-10111101b & 10011100b = 10011100b
-10111101b & 10011101b = 10011101b
-10111101b & 10011110b = 10011100b
-10111101b & 10011111b = 10011101b
-10111101b & 10100000b = 10100000b
-10111101b & 10100001b = 10100001b
-10111101b & 10100010b = 10100000b
-10111101b & 10100011b = 10100001b
-10111101b & 10100100b = 10100100b
-10111101b & 10100101b = 10100101b
-10111101b & 10100110b = 10100100b
-10111101b & 10100111b = 10100101b
-10111101b & 10101000b = 10101000b
-10111101b & 10101001b = 10101001b
-10111101b & 10101010b = 10101000b
-10111101b & 10101011b = 10101001b
-10111101b & 10101100b = 10101100b
-10111101b & 10101101b = 10101101b
-10111101b & 10101110b = 10101100b
-10111101b & 10101111b = 10101101b
-10111101b & 10110000b = 10110000b
-10111101b & 10110001b = 10110001b
-10111101b & 10110010b = 10110000b
-10111101b & 10110011b = 10110001b
-10111101b & 10110100b = 10110100b
-10111101b & 10110101b = 10110101b
-10111101b & 10110110b = 10110100b
-10111101b & 10110111b = 10110101b
-10111101b & 10111000b = 10111000b
-10111101b & 10111001b = 10111001b
-10111101b & 10111010b = 10111000b
-10111101b & 10111011b = 10111001b
-10111101b & 10111100b = 10111100b
-10111101b & 10111101b = 10111101b
-10111101b & 10111110b = 10111100b
-10111101b & 10111111b = 10111101b
-10111101b & 11000000b = 10000000b
-10111101b & 11000001b = 10000001b
-10111101b & 11000010b = 10000000b
-10111101b & 11000011b = 10000001b
-10111101b & 11000100b = 10000100b
-10111101b & 11000101b = 10000101b
-10111101b & 11000110b = 10000100b
-10111101b & 11000111b = 10000101b
-10111101b & 11001000b = 10001000b
-10111101b & 11001001b = 10001001b
-10111101b & 11001010b = 10001000b
-10111101b & 11001011b = 10001001b
-10111101b & 11001100b = 10001100b
-10111101b & 11001101b = 10001101b
-10111101b & 11001110b = 10001100b
-10111101b & 11001111b = 10001101b
-10111101b & 11010000b = 10010000b
-10111101b & 11010001b = 10010001b
-10111101b & 11010010b = 10010000b
-10111101b & 11010011b = 10010001b
-10111101b & 11010100b = 10010100b
-10111101b & 11010101b = 10010101b
-10111101b & 11010110b = 10010100b
-10111101b & 11010111b = 10010101b
-10111101b & 11011000b = 10011000b
-10111101b & 11011001b = 10011001b
-10111101b & 11011010b = 10011000b
-10111101b & 11011011b = 10011001b
-10111101b & 11011100b = 10011100b
-10111101b & 11011101b = 10011101b
-10111101b & 11011110b = 10011100b
-10111101b & 11011111b = 10011101b
-10111101b & 11100000b = 10100000b
-10111101b & 11100001b = 10100001b
-10111101b & 11100010b = 10100000b
-10111101b & 11100011b = 10100001b
-10111101b & 11100100b = 10100100b
-10111101b & 11100101b = 10100101b
-10111101b & 11100110b = 10100100b
-10111101b & 11100111b = 10100101b
-10111101b & 11101000b = 10101000b
-10111101b & 11101001b = 10101001b
-10111101b & 11101010b = 10101000b
-10111101b & 11101011b = 10101001b
-10111101b & 11101100b = 10101100b
-10111101b & 11101101b = 10101101b
-10111101b & 11101110b = 10101100b
-10111101b & 11101111b = 10101101b
-10111101b & 11110000b = 10110000b
-10111101b & 11110001b = 10110001b
-10111101b & 11110010b = 10110000b
-10111101b & 11110011b = 10110001b
-10111101b & 11110100b = 10110100b
-10111101b & 11110101b = 10110101b
-10111101b & 11110110b = 10110100b
-10111101b & 11110111b = 10110101b
-10111101b & 11111000b = 10111000b
-10111101b & 11111001b = 10111001b
-10111101b & 11111010b = 10111000b
-10111101b & 11111011b = 10111001b
-10111101b & 11111100b = 10111100b
-10111101b & 11111101b = 10111101b
-10111101b & 11111110b = 10111100b
-10111101b & 11111111b = 10111101b
-10111101b & 00000000b = 00000000b
-10111101b & 00000001b = 00000001b
-10111101b & 00000010b = 00000000b
-10111101b & 00000011b = 00000001b
-10111101b & 00000100b = 00000100b
-10111101b & 00000101b = 00000101b
-10111101b & 00000110b = 00000100b
-10111101b & 00000111b = 00000101b
-10111101b & 00001000b = 00001000b
-10111101b & 00001001b = 00001001b
-10111101b & 00001010b = 00001000b
-10111101b & 00001011b = 00001001b
-10111101b & 00001100b = 00001100b
-10111101b & 00001101b = 00001101b
-10111101b & 00001110b = 00001100b
-10111101b & 00001111b = 00001101b
-10111101b & 00010000b = 00010000b
-10111101b & 00010001b = 00010001b
-10111101b & 00010010b = 00010000b
-10111101b & 00010011b = 00010001b
-10111101b & 00010100b = 00010100b
-10111101b & 00010101b = 00010101b
-10111101b & 00010110b = 00010100b
-10111101b & 00010111b = 00010101b
-10111101b & 00011000b = 00011000b
-10111101b & 00011001b = 00011001b
-10111101b & 00011010b = 00011000b
-10111101b & 00011011b = 00011001b
-10111101b & 00011100b = 00011100b
-10111101b & 00011101b = 00011101b
-10111101b & 00011110b = 00011100b
-10111101b & 00011111b = 00011101b
-10111101b & 00100000b = 00100000b
-10111101b & 00100001b = 00100001b
-10111101b & 00100010b = 00100000b
-10111101b & 00100011b = 00100001b
-10111101b & 00100100b = 00100100b
-10111101b & 00100101b = 00100101b
-10111101b & 00100110b = 00100100b
-10111101b & 00100111b = 00100101b
-10111101b & 00101000b = 00101000b
-10111101b & 00101001b = 00101001b
-10111101b & 00101010b = 00101000b
-10111101b & 00101011b = 00101001b
-10111101b & 00101100b = 00101100b
-10111101b & 00101101b = 00101101b
-10111101b & 00101110b = 00101100b
-10111101b & 00101111b = 00101101b
-10111101b & 00110000b = 00110000b
-10111101b & 00110001b = 00110001b
-10111101b & 00110010b = 00110000b
-10111101b & 00110011b = 00110001b
-10111101b & 00110100b = 00110100b
-10111101b & 00110101b = 00110101b
-10111101b & 00110110b = 00110100b
-10111101b & 00110111b = 00110101b
-10111101b & 00111000b = 00111000b
-10111101b & 00111001b = 00111001b
-10111101b & 00111010b = 00111000b
-10111101b & 00111011b = 00111001b
-10111101b & 00111100b = 00111100b
-10111101b & 00111101b = 00111101b
-10111101b & 00111110b = 00111100b
-10111101b & 00111111b = 00111101b
-10111101b & 01000000b = 00000000b
-10111101b & 01000001b = 00000001b
-10111101b & 01000010b = 00000000b
-10111101b & 01000011b = 00000001b
-10111101b & 01000100b = 00000100b
-10111101b & 01000101b = 00000101b
-10111101b & 01000110b = 00000100b
-10111101b & 01000111b = 00000101b
-10111101b & 01001000b = 00001000b
-10111101b & 01001001b = 00001001b
-10111101b & 01001010b = 00001000b
-10111101b & 01001011b = 00001001b
-10111101b & 01001100b = 00001100b
-10111101b & 01001101b = 00001101b
-10111101b & 01001110b = 00001100b
-10111101b & 01001111b = 00001101b
-10111101b & 01010000b = 00010000b
-10111101b & 01010001b = 00010001b
-10111101b & 01010010b = 00010000b
-10111101b & 01010011b = 00010001b
-10111101b & 01010100b = 00010100b
-10111101b & 01010101b = 00010101b
-10111101b & 01010110b = 00010100b
-10111101b & 01010111b = 00010101b
-10111101b & 01011000b = 00011000b
-10111101b & 01011001b = 00011001b
-10111101b & 01011010b = 00011000b
-10111101b & 01011011b = 00011001b
-10111101b & 01011100b = 00011100b
-10111101b & 01011101b = 00011101b
-10111101b & 01011110b = 00011100b
-10111101b & 01011111b = 00011101b
-10111101b & 01100000b = 00100000b
-10111101b & 01100001b = 00100001b
-10111101b & 01100010b = 00100000b
-10111101b & 01100011b = 00100001b
-10111101b & 01100100b = 00100100b
-10111101b & 01100101b = 00100101b
-10111101b & 01100110b = 00100100b
-10111101b & 01100111b = 00100101b
-10111101b & 01101000b = 00101000b
-10111101b & 01101001b = 00101001b
-10111101b & 01101010b = 00101000b
-10111101b & 01101011b = 00101001b
-10111101b & 01101100b = 00101100b
-10111101b & 01101101b = 00101101b
-10111101b & 01101110b = 00101100b
-10111101b & 01101111b = 00101101b
-10111101b & 01110000b = 00110000b
-10111101b & 01110001b = 00110001b
-10111101b & 01110010b = 00110000b
-10111101b & 01110011b = 00110001b
-10111101b & 01110100b = 00110100b
-10111101b & 01110101b = 00110101b
-10111101b & 01110110b = 00110100b
-10111101b & 01110111b = 00110101b
-10111101b & 01111000b = 00111000b
-10111101b & 01111001b = 00111001b
-10111101b & 01111010b = 00111000b
-10111101b & 01111011b = 00111001b
-10111101b & 01111100b = 00111100b
-10111101b & 01111101b = 00111101b
-10111101b & 01111110b = 00111100b
-10111110b & 10000000b = 10000000b
-10111110b & 10000001b = 10000000b
-10111110b & 10000010b = 10000010b
-10111110b & 10000011b = 10000010b
-10111110b & 10000100b = 10000100b
-10111110b & 10000101b = 10000100b
-10111110b & 10000110b = 10000110b
-10111110b & 10000111b = 10000110b
-10111110b & 10001000b = 10001000b
-10111110b & 10001001b = 10001000b
-10111110b & 10001010b = 10001010b
-10111110b & 10001011b = 10001010b
-10111110b & 10001100b = 10001100b
-10111110b & 10001101b = 10001100b
-10111110b & 10001110b = 10001110b
-10111110b & 10001111b = 10001110b
-10111110b & 10010000b = 10010000b
-10111110b & 10010001b = 10010000b
-10111110b & 10010010b = 10010010b
-10111110b & 10010011b = 10010010b
-10111110b & 10010100b = 10010100b
-10111110b & 10010101b = 10010100b
-10111110b & 10010110b = 10010110b
-10111110b & 10010111b = 10010110b
-10111110b & 10011000b = 10011000b
-10111110b & 10011001b = 10011000b
-10111110b & 10011010b = 10011010b
-10111110b & 10011011b = 10011010b
-10111110b & 10011100b = 10011100b
-10111110b & 10011101b = 10011100b
-10111110b & 10011110b = 10011110b
-10111110b & 10011111b = 10011110b
-10111110b & 10100000b = 10100000b
-10111110b & 10100001b = 10100000b
-10111110b & 10100010b = 10100010b
-10111110b & 10100011b = 10100010b
-10111110b & 10100100b = 10100100b
-10111110b & 10100101b = 10100100b
-10111110b & 10100110b = 10100110b
-10111110b & 10100111b = 10100110b
-10111110b & 10101000b = 10101000b
-10111110b & 10101001b = 10101000b
-10111110b & 10101010b = 10101010b
-10111110b & 10101011b = 10101010b
-10111110b & 10101100b = 10101100b
-10111110b & 10101101b = 10101100b
-10111110b & 10101110b = 10101110b
-10111110b & 10101111b = 10101110b
-10111110b & 10110000b = 10110000b
-10111110b & 10110001b = 10110000b
-10111110b & 10110010b = 10110010b
-10111110b & 10110011b = 10110010b
-10111110b & 10110100b = 10110100b
-10111110b & 10110101b = 10110100b
-10111110b & 10110110b = 10110110b
-10111110b & 10110111b = 10110110b
-10111110b & 10111000b = 10111000b
-10111110b & 10111001b = 10111000b
-10111110b & 10111010b = 10111010b
-10111110b & 10111011b = 10111010b
-10111110b & 10111100b = 10111100b
-10111110b & 10111101b = 10111100b
-10111110b & 10111110b = 10111110b
-10111110b & 10111111b = 10111110b
-10111110b & 11000000b = 10000000b
-10111110b & 11000001b = 10000000b
-10111110b & 11000010b = 10000010b
-10111110b & 11000011b = 10000010b
-10111110b & 11000100b = 10000100b
-10111110b & 11000101b = 10000100b
-10111110b & 11000110b = 10000110b
-10111110b & 11000111b = 10000110b
-10111110b & 11001000b = 10001000b
-10111110b & 11001001b = 10001000b
-10111110b & 11001010b = 10001010b
-10111110b & 11001011b = 10001010b
-10111110b & 11001100b = 10001100b
-10111110b & 11001101b = 10001100b
-10111110b & 11001110b = 10001110b
-10111110b & 11001111b = 10001110b
-10111110b & 11010000b = 10010000b
-10111110b & 11010001b = 10010000b
-10111110b & 11010010b = 10010010b
-10111110b & 11010011b = 10010010b
-10111110b & 11010100b = 10010100b
-10111110b & 11010101b = 10010100b
-10111110b & 11010110b = 10010110b
-10111110b & 11010111b = 10010110b
-10111110b & 11011000b = 10011000b
-10111110b & 11011001b = 10011000b
-10111110b & 11011010b = 10011010b
-10111110b & 11011011b = 10011010b
-10111110b & 11011100b = 10011100b
-10111110b & 11011101b = 10011100b
-10111110b & 11011110b = 10011110b
-10111110b & 11011111b = 10011110b
-10111110b & 11100000b = 10100000b
-10111110b & 11100001b = 10100000b
-10111110b & 11100010b = 10100010b
-10111110b & 11100011b = 10100010b
-10111110b & 11100100b = 10100100b
-10111110b & 11100101b = 10100100b
-10111110b & 11100110b = 10100110b
-10111110b & 11100111b = 10100110b
-10111110b & 11101000b = 10101000b
-10111110b & 11101001b = 10101000b
-10111110b & 11101010b = 10101010b
-10111110b & 11101011b = 10101010b
-10111110b & 11101100b = 10101100b
-10111110b & 11101101b = 10101100b
-10111110b & 11101110b = 10101110b
-10111110b & 11101111b = 10101110b
-10111110b & 11110000b = 10110000b
-10111110b & 11110001b = 10110000b
-10111110b & 11110010b = 10110010b
-10111110b & 11110011b = 10110010b
-10111110b & 11110100b = 10110100b
-10111110b & 11110101b = 10110100b
-10111110b & 11110110b = 10110110b
-10111110b & 11110111b = 10110110b
-10111110b & 11111000b = 10111000b
-10111110b & 11111001b = 10111000b
-10111110b & 11111010b = 10111010b
-10111110b & 11111011b = 10111010b
-10111110b & 11111100b = 10111100b
-10111110b & 11111101b = 10111100b
-10111110b & 11111110b = 10111110b
-10111110b & 11111111b = 10111110b
-10111110b & 00000000b = 00000000b
-10111110b & 00000001b = 00000000b
-10111110b & 00000010b = 00000010b
-10111110b & 00000011b = 00000010b
-10111110b & 00000100b = 00000100b
-10111110b & 00000101b = 00000100b
-10111110b & 00000110b = 00000110b
-10111110b & 00000111b = 00000110b
-10111110b & 00001000b = 00001000b
-10111110b & 00001001b = 00001000b
-10111110b & 00001010b = 00001010b
-10111110b & 00001011b = 00001010b
-10111110b & 00001100b = 00001100b
-10111110b & 00001101b = 00001100b
-10111110b & 00001110b = 00001110b
-10111110b & 00001111b = 00001110b
-10111110b & 00010000b = 00010000b
-10111110b & 00010001b = 00010000b
-10111110b & 00010010b = 00010010b
-10111110b & 00010011b = 00010010b
-10111110b & 00010100b = 00010100b
-10111110b & 00010101b = 00010100b
-10111110b & 00010110b = 00010110b
-10111110b & 00010111b = 00010110b
-10111110b & 00011000b = 00011000b
-10111110b & 00011001b = 00011000b
-10111110b & 00011010b = 00011010b
-10111110b & 00011011b = 00011010b
-10111110b & 00011100b = 00011100b
-10111110b & 00011101b = 00011100b
-10111110b & 00011110b = 00011110b
-10111110b & 00011111b = 00011110b
-10111110b & 00100000b = 00100000b
-10111110b & 00100001b = 00100000b
-10111110b & 00100010b = 00100010b
-10111110b & 00100011b = 00100010b
-10111110b & 00100100b = 00100100b
-10111110b & 00100101b = 00100100b
-10111110b & 00100110b = 00100110b
-10111110b & 00100111b = 00100110b
-10111110b & 00101000b = 00101000b
-10111110b & 00101001b = 00101000b
-10111110b & 00101010b = 00101010b
-10111110b & 00101011b = 00101010b
-10111110b & 00101100b = 00101100b
-10111110b & 00101101b = 00101100b
-10111110b & 00101110b = 00101110b
-10111110b & 00101111b = 00101110b
-10111110b & 00110000b = 00110000b
-10111110b & 00110001b = 00110000b
-10111110b & 00110010b = 00110010b
-10111110b & 00110011b = 00110010b
-10111110b & 00110100b = 00110100b
-10111110b & 00110101b = 00110100b
-10111110b & 00110110b = 00110110b
-10111110b & 00110111b = 00110110b
-10111110b & 00111000b = 00111000b
-10111110b & 00111001b = 00111000b
-10111110b & 00111010b = 00111010b
-10111110b & 00111011b = 00111010b
-10111110b & 00111100b = 00111100b
-10111110b & 00111101b = 00111100b
-10111110b & 00111110b = 00111110b
-10111110b & 00111111b = 00111110b
-10111110b & 01000000b = 00000000b
-10111110b & 01000001b = 00000000b
-10111110b & 01000010b = 00000010b
-10111110b & 01000011b = 00000010b
-10111110b & 01000100b = 00000100b
-10111110b & 01000101b = 00000100b
-10111110b & 01000110b = 00000110b
-10111110b & 01000111b = 00000110b
-10111110b & 01001000b = 00001000b
-10111110b & 01001001b = 00001000b
-10111110b & 01001010b = 00001010b
-10111110b & 01001011b = 00001010b
-10111110b & 01001100b = 00001100b
-10111110b & 01001101b = 00001100b
-10111110b & 01001110b = 00001110b
-10111110b & 01001111b = 00001110b
-10111110b & 01010000b = 00010000b
-10111110b & 01010001b = 00010000b
-10111110b & 01010010b = 00010010b
-10111110b & 01010011b = 00010010b
-10111110b & 01010100b = 00010100b
-10111110b & 01010101b = 00010100b
-10111110b & 01010110b = 00010110b
-10111110b & 01010111b = 00010110b
-10111110b & 01011000b = 00011000b
-10111110b & 01011001b = 00011000b
-10111110b & 01011010b = 00011010b
-10111110b & 01011011b = 00011010b
-10111110b & 01011100b = 00011100b
-10111110b & 01011101b = 00011100b
-10111110b & 01011110b = 00011110b
-10111110b & 01011111b = 00011110b
-10111110b & 01100000b = 00100000b
-10111110b & 01100001b = 00100000b
-10111110b & 01100010b = 00100010b
-10111110b & 01100011b = 00100010b
-10111110b & 01100100b = 00100100b
-10111110b & 01100101b = 00100100b
-10111110b & 01100110b = 00100110b
-10111110b & 01100111b = 00100110b
-10111110b & 01101000b = 00101000b
-10111110b & 01101001b = 00101000b
-10111110b & 01101010b = 00101010b
-10111110b & 01101011b = 00101010b
-10111110b & 01101100b = 00101100b
-10111110b & 01101101b = 00101100b
-10111110b & 01101110b = 00101110b
-10111110b & 01101111b = 00101110b
-10111110b & 01110000b = 00110000b
-10111110b & 01110001b = 00110000b
-10111110b & 01110010b = 00110010b
-10111110b & 01110011b = 00110010b
-10111110b & 01110100b = 00110100b
-10111110b & 01110101b = 00110100b
-10111110b & 01110110b = 00110110b
-10111110b & 01110111b = 00110110b
-10111110b & 01111000b = 00111000b
-10111110b & 01111001b = 00111000b
-10111110b & 01111010b = 00111010b
-10111110b & 01111011b = 00111010b
-10111110b & 01111100b = 00111100b
-10111110b & 01111101b = 00111100b
-10111110b & 01111110b = 00111110b
-10111111b & 10000000b = 10000000b
-10111111b & 10000001b = 10000001b
-10111111b & 10000010b = 10000010b
-10111111b & 10000011b = 10000011b
-10111111b & 10000100b = 10000100b
-10111111b & 10000101b = 10000101b
-10111111b & 10000110b = 10000110b
-10111111b & 10000111b = 10000111b
-10111111b & 10001000b = 10001000b
-10111111b & 10001001b = 10001001b
-10111111b & 10001010b = 10001010b
-10111111b & 10001011b = 10001011b
-10111111b & 10001100b = 10001100b
-10111111b & 10001101b = 10001101b
-10111111b & 10001110b = 10001110b
-10111111b & 10001111b = 10001111b
-10111111b & 10010000b = 10010000b
-10111111b & 10010001b = 10010001b
-10111111b & 10010010b = 10010010b
-10111111b & 10010011b = 10010011b
-10111111b & 10010100b = 10010100b
-10111111b & 10010101b = 10010101b
-10111111b & 10010110b = 10010110b
-10111111b & 10010111b = 10010111b
-10111111b & 10011000b = 10011000b
-10111111b & 10011001b = 10011001b
-10111111b & 10011010b = 10011010b
-10111111b & 10011011b = 10011011b
-10111111b & 10011100b = 10011100b
-10111111b & 10011101b = 10011101b
-10111111b & 10011110b = 10011110b
-10111111b & 10011111b = 10011111b
-10111111b & 10100000b = 10100000b
-10111111b & 10100001b = 10100001b
-10111111b & 10100010b = 10100010b
-10111111b & 10100011b = 10100011b
-10111111b & 10100100b = 10100100b
-10111111b & 10100101b = 10100101b
-10111111b & 10100110b = 10100110b
-10111111b & 10100111b = 10100111b
-10111111b & 10101000b = 10101000b
-10111111b & 10101001b = 10101001b
-10111111b & 10101010b = 10101010b
-10111111b & 10101011b = 10101011b
-10111111b & 10101100b = 10101100b
-10111111b & 10101101b = 10101101b
-10111111b & 10101110b = 10101110b
-10111111b & 10101111b = 10101111b
-10111111b & 10110000b = 10110000b
-10111111b & 10110001b = 10110001b
-10111111b & 10110010b = 10110010b
-10111111b & 10110011b = 10110011b
-10111111b & 10110100b = 10110100b
-10111111b & 10110101b = 10110101b
-10111111b & 10110110b = 10110110b
-10111111b & 10110111b = 10110111b
-10111111b & 10111000b = 10111000b
-10111111b & 10111001b = 10111001b
-10111111b & 10111010b = 10111010b
-10111111b & 10111011b = 10111011b
-10111111b & 10111100b = 10111100b
-10111111b & 10111101b = 10111101b
-10111111b & 10111110b = 10111110b
-10111111b & 10111111b = 10111111b
-10111111b & 11000000b = 10000000b
-10111111b & 11000001b = 10000001b
-10111111b & 11000010b = 10000010b
-10111111b & 11000011b = 10000011b
-10111111b & 11000100b = 10000100b
-10111111b & 11000101b = 10000101b
-10111111b & 11000110b = 10000110b
-10111111b & 11000111b = 10000111b
-10111111b & 11001000b = 10001000b
-10111111b & 11001001b = 10001001b
-10111111b & 11001010b = 10001010b
-10111111b & 11001011b = 10001011b
-10111111b & 11001100b = 10001100b
-10111111b & 11001101b = 10001101b
-10111111b & 11001110b = 10001110b
-10111111b & 11001111b = 10001111b
-10111111b & 11010000b = 10010000b
-10111111b & 11010001b = 10010001b
-10111111b & 11010010b = 10010010b
-10111111b & 11010011b = 10010011b
-10111111b & 11010100b = 10010100b
-10111111b & 11010101b = 10010101b
-10111111b & 11010110b = 10010110b
-10111111b & 11010111b = 10010111b
-10111111b & 11011000b = 10011000b
-10111111b & 11011001b = 10011001b
-10111111b & 11011010b = 10011010b
-10111111b & 11011011b = 10011011b
-10111111b & 11011100b = 10011100b
-10111111b & 11011101b = 10011101b
-10111111b & 11011110b = 10011110b
-10111111b & 11011111b = 10011111b
-10111111b & 11100000b = 10100000b
-10111111b & 11100001b = 10100001b
-10111111b & 11100010b = 10100010b
-10111111b & 11100011b = 10100011b
-10111111b & 11100100b = 10100100b
-10111111b & 11100101b = 10100101b
-10111111b & 11100110b = 10100110b
-10111111b & 11100111b = 10100111b
-10111111b & 11101000b = 10101000b
-10111111b & 11101001b = 10101001b
-10111111b & 11101010b = 10101010b
-10111111b & 11101011b = 10101011b
-10111111b & 11101100b = 10101100b
-10111111b & 11101101b = 10101101b
-10111111b & 11101110b = 10101110b
-10111111b & 11101111b = 10101111b
-10111111b & 11110000b = 10110000b
-10111111b & 11110001b = 10110001b
-10111111b & 11110010b = 10110010b
-10111111b & 11110011b = 10110011b
-10111111b & 11110100b = 10110100b
-10111111b & 11110101b = 10110101b
-10111111b & 11110110b = 10110110b
-10111111b & 11110111b = 10110111b
-10111111b & 11111000b = 10111000b
-10111111b & 11111001b = 10111001b
-10111111b & 11111010b = 10111010b
-10111111b & 11111011b = 10111011b
-10111111b & 11111100b = 10111100b
-10111111b & 11111101b = 10111101b
-10111111b & 11111110b = 10111110b
-10111111b & 11111111b = 10111111b
-10111111b & 00000000b = 00000000b
-10111111b & 00000001b = 00000001b
-10111111b & 00000010b = 00000010b
-10111111b & 00000011b = 00000011b
-10111111b & 00000100b = 00000100b
-10111111b & 00000101b = 00000101b
-10111111b & 00000110b = 00000110b
-10111111b & 00000111b = 00000111b
-10111111b & 00001000b = 00001000b
-10111111b & 00001001b = 00001001b
-10111111b & 00001010b = 00001010b
-10111111b & 00001011b = 00001011b
-10111111b & 00001100b = 00001100b
-10111111b & 00001101b = 00001101b
-10111111b & 00001110b = 00001110b
-10111111b & 00001111b = 00001111b
-10111111b & 00010000b = 00010000b
-10111111b & 00010001b = 00010001b
-10111111b & 00010010b = 00010010b
-10111111b & 00010011b = 00010011b
-10111111b & 00010100b = 00010100b
-10111111b & 00010101b = 00010101b
-10111111b & 00010110b = 00010110b
-10111111b & 00010111b = 00010111b
-10111111b & 00011000b = 00011000b
-10111111b & 00011001b = 00011001b
-10111111b & 00011010b = 00011010b
-10111111b & 00011011b = 00011011b
-10111111b & 00011100b = 00011100b
-10111111b & 00011101b = 00011101b
-10111111b & 00011110b = 00011110b
-10111111b & 00011111b = 00011111b
-10111111b & 00100000b = 00100000b
-10111111b & 00100001b = 00100001b
-10111111b & 00100010b = 00100010b
-10111111b & 00100011b = 00100011b
-10111111b & 00100100b = 00100100b
-10111111b & 00100101b = 00100101b
-10111111b & 00100110b = 00100110b
-10111111b & 00100111b = 00100111b
-10111111b & 00101000b = 00101000b
-10111111b & 00101001b = 00101001b
-10111111b & 00101010b = 00101010b
-10111111b & 00101011b = 00101011b
-10111111b & 00101100b = 00101100b
-10111111b & 00101101b = 00101101b
-10111111b & 00101110b = 00101110b
-10111111b & 00101111b = 00101111b
-10111111b & 00110000b = 00110000b
-10111111b & 00110001b = 00110001b
-10111111b & 00110010b = 00110010b
-10111111b & 00110011b = 00110011b
-10111111b & 00110100b = 00110100b
-10111111b & 00110101b = 00110101b
-10111111b & 00110110b = 00110110b
-10111111b & 00110111b = 00110111b
-10111111b & 00111000b = 00111000b
-10111111b & 00111001b = 00111001b
-10111111b & 00111010b = 00111010b
-10111111b & 00111011b = 00111011b
-10111111b & 00111100b = 00111100b
-10111111b & 00111101b = 00111101b
-10111111b & 00111110b = 00111110b
-10111111b & 00111111b = 00111111b
-10111111b & 01000000b = 00000000b
-10111111b & 01000001b = 00000001b
-10111111b & 01000010b = 00000010b
-10111111b & 01000011b = 00000011b
-10111111b & 01000100b = 00000100b
-10111111b & 01000101b = 00000101b
-10111111b & 01000110b = 00000110b
-10111111b & 01000111b = 00000111b
-10111111b & 01001000b = 00001000b
-10111111b & 01001001b = 00001001b
-10111111b & 01001010b = 00001010b
-10111111b & 01001011b = 00001011b
-10111111b & 01001100b = 00001100b
-10111111b & 01001101b = 00001101b
-10111111b & 01001110b = 00001110b
-10111111b & 01001111b = 00001111b
-10111111b & 01010000b = 00010000b
-10111111b & 01010001b = 00010001b
-10111111b & 01010010b = 00010010b
-10111111b & 01010011b = 00010011b
-10111111b & 01010100b = 00010100b
-10111111b & 01010101b = 00010101b
-10111111b & 01010110b = 00010110b
-10111111b & 01010111b = 00010111b
-10111111b & 01011000b = 00011000b
-10111111b & 01011001b = 00011001b
-10111111b & 01011010b = 00011010b
-10111111b & 01011011b = 00011011b
-10111111b & 01011100b = 00011100b
-10111111b & 01011101b = 00011101b
-10111111b & 01011110b = 00011110b
-10111111b & 01011111b = 00011111b
-10111111b & 01100000b = 00100000b
-10111111b & 01100001b = 00100001b
-10111111b & 01100010b = 00100010b
-10111111b & 01100011b = 00100011b
-10111111b & 01100100b = 00100100b
-10111111b & 01100101b = 00100101b
-10111111b & 01100110b = 00100110b
-10111111b & 01100111b = 00100111b
-10111111b & 01101000b = 00101000b
-10111111b & 01101001b = 00101001b
-10111111b & 01101010b = 00101010b
-10111111b & 01101011b = 00101011b
-10111111b & 01101100b = 00101100b
-10111111b & 01101101b = 00101101b
-10111111b & 01101110b = 00101110b
-10111111b & 01101111b = 00101111b
-10111111b & 01110000b = 00110000b
-10111111b & 01110001b = 00110001b
-10111111b & 01110010b = 00110010b
-10111111b & 01110011b = 00110011b
-10111111b & 01110100b = 00110100b
-10111111b & 01110101b = 00110101b
-10111111b & 01110110b = 00110110b
-10111111b & 01110111b = 00110111b
-10111111b & 01111000b = 00111000b
-10111111b & 01111001b = 00111001b
-10111111b & 01111010b = 00111010b
-10111111b & 01111011b = 00111011b
-10111111b & 01111100b = 00111100b
-10111111b & 01111101b = 00111101b
-10111111b & 01111110b = 00111110b
-11000000b & 10000000b = 10000000b
-11000000b & 10000001b = 10000000b
-11000000b & 10000010b = 10000000b
-11000000b & 10000011b = 10000000b
-11000000b & 10000100b = 10000000b
-11000000b & 10000101b = 10000000b
-11000000b & 10000110b = 10000000b
-11000000b & 10000111b = 10000000b
-11000000b & 10001000b = 10000000b
-11000000b & 10001001b = 10000000b
-11000000b & 10001010b = 10000000b
-11000000b & 10001011b = 10000000b
-11000000b & 10001100b = 10000000b
-11000000b & 10001101b = 10000000b
-11000000b & 10001110b = 10000000b
-11000000b & 10001111b = 10000000b
-11000000b & 10010000b = 10000000b
-11000000b & 10010001b = 10000000b
-11000000b & 10010010b = 10000000b
-11000000b & 10010011b = 10000000b
-11000000b & 10010100b = 10000000b
-11000000b & 10010101b = 10000000b
-11000000b & 10010110b = 10000000b
-11000000b & 10010111b = 10000000b
-11000000b & 10011000b = 10000000b
-11000000b & 10011001b = 10000000b
-11000000b & 10011010b = 10000000b
-11000000b & 10011011b = 10000000b
-11000000b & 10011100b = 10000000b
-11000000b & 10011101b = 10000000b
-11000000b & 10011110b = 10000000b
-11000000b & 10011111b = 10000000b
-11000000b & 10100000b = 10000000b
-11000000b & 10100001b = 10000000b
-11000000b & 10100010b = 10000000b
-11000000b & 10100011b = 10000000b
-11000000b & 10100100b = 10000000b
-11000000b & 10100101b = 10000000b
-11000000b & 10100110b = 10000000b
-11000000b & 10100111b = 10000000b
-11000000b & 10101000b = 10000000b
-11000000b & 10101001b = 10000000b
-11000000b & 10101010b = 10000000b
-11000000b & 10101011b = 10000000b
-11000000b & 10101100b = 10000000b
-11000000b & 10101101b = 10000000b
-11000000b & 10101110b = 10000000b
-11000000b & 10101111b = 10000000b
-11000000b & 10110000b = 10000000b
-11000000b & 10110001b = 10000000b
-11000000b & 10110010b = 10000000b
-11000000b & 10110011b = 10000000b
-11000000b & 10110100b = 10000000b
-11000000b & 10110101b = 10000000b
-11000000b & 10110110b = 10000000b
-11000000b & 10110111b = 10000000b
-11000000b & 10111000b = 10000000b
-11000000b & 10111001b = 10000000b
-11000000b & 10111010b = 10000000b
-11000000b & 10111011b = 10000000b
-11000000b & 10111100b = 10000000b
-11000000b & 10111101b = 10000000b
-11000000b & 10111110b = 10000000b
-11000000b & 10111111b = 10000000b
-11000000b & 11000000b = 11000000b
-11000000b & 11000001b = 11000000b
-11000000b & 11000010b = 11000000b
-11000000b & 11000011b = 11000000b
-11000000b & 11000100b = 11000000b
-11000000b & 11000101b = 11000000b
-11000000b & 11000110b = 11000000b
-11000000b & 11000111b = 11000000b
-11000000b & 11001000b = 11000000b
-11000000b & 11001001b = 11000000b
-11000000b & 11001010b = 11000000b
-11000000b & 11001011b = 11000000b
-11000000b & 11001100b = 11000000b
-11000000b & 11001101b = 11000000b
-11000000b & 11001110b = 11000000b
-11000000b & 11001111b = 11000000b
-11000000b & 11010000b = 11000000b
-11000000b & 11010001b = 11000000b
-11000000b & 11010010b = 11000000b
-11000000b & 11010011b = 11000000b
-11000000b & 11010100b = 11000000b
-11000000b & 11010101b = 11000000b
-11000000b & 11010110b = 11000000b
-11000000b & 11010111b = 11000000b
-11000000b & 11011000b = 11000000b
-11000000b & 11011001b = 11000000b
-11000000b & 11011010b = 11000000b
-11000000b & 11011011b = 11000000b
-11000000b & 11011100b = 11000000b
-11000000b & 11011101b = 11000000b
-11000000b & 11011110b = 11000000b
-11000000b & 11011111b = 11000000b
-11000000b & 11100000b = 11000000b
-11000000b & 11100001b = 11000000b
-11000000b & 11100010b = 11000000b
-11000000b & 11100011b = 11000000b
-11000000b & 11100100b = 11000000b
-11000000b & 11100101b = 11000000b
-11000000b & 11100110b = 11000000b
-11000000b & 11100111b = 11000000b
-11000000b & 11101000b = 11000000b
-11000000b & 11101001b = 11000000b
-11000000b & 11101010b = 11000000b
-11000000b & 11101011b = 11000000b
-11000000b & 11101100b = 11000000b
-11000000b & 11101101b = 11000000b
-11000000b & 11101110b = 11000000b
-11000000b & 11101111b = 11000000b
-11000000b & 11110000b = 11000000b
-11000000b & 11110001b = 11000000b
-11000000b & 11110010b = 11000000b
-11000000b & 11110011b = 11000000b
-11000000b & 11110100b = 11000000b
-11000000b & 11110101b = 11000000b
-11000000b & 11110110b = 11000000b
-11000000b & 11110111b = 11000000b
-11000000b & 11111000b = 11000000b
-11000000b & 11111001b = 11000000b
-11000000b & 11111010b = 11000000b
-11000000b & 11111011b = 11000000b
-11000000b & 11111100b = 11000000b
-11000000b & 11111101b = 11000000b
-11000000b & 11111110b = 11000000b
-11000000b & 11111111b = 11000000b
-11000000b & 00000000b = 00000000b
-11000000b & 00000001b = 00000000b
-11000000b & 00000010b = 00000000b
-11000000b & 00000011b = 00000000b
-11000000b & 00000100b = 00000000b
-11000000b & 00000101b = 00000000b
-11000000b & 00000110b = 00000000b
-11000000b & 00000111b = 00000000b
-11000000b & 00001000b = 00000000b
-11000000b & 00001001b = 00000000b
-11000000b & 00001010b = 00000000b
-11000000b & 00001011b = 00000000b
-11000000b & 00001100b = 00000000b
-11000000b & 00001101b = 00000000b
-11000000b & 00001110b = 00000000b
-11000000b & 00001111b = 00000000b
-11000000b & 00010000b = 00000000b
-11000000b & 00010001b = 00000000b
-11000000b & 00010010b = 00000000b
-11000000b & 00010011b = 00000000b
-11000000b & 00010100b = 00000000b
-11000000b & 00010101b = 00000000b
-11000000b & 00010110b = 00000000b
-11000000b & 00010111b = 00000000b
-11000000b & 00011000b = 00000000b
-11000000b & 00011001b = 00000000b
-11000000b & 00011010b = 00000000b
-11000000b & 00011011b = 00000000b
-11000000b & 00011100b = 00000000b
-11000000b & 00011101b = 00000000b
-11000000b & 00011110b = 00000000b
-11000000b & 00011111b = 00000000b
-11000000b & 00100000b = 00000000b
-11000000b & 00100001b = 00000000b
-11000000b & 00100010b = 00000000b
-11000000b & 00100011b = 00000000b
-11000000b & 00100100b = 00000000b
-11000000b & 00100101b = 00000000b
-11000000b & 00100110b = 00000000b
-11000000b & 00100111b = 00000000b
-11000000b & 00101000b = 00000000b
-11000000b & 00101001b = 00000000b
-11000000b & 00101010b = 00000000b
-11000000b & 00101011b = 00000000b
-11000000b & 00101100b = 00000000b
-11000000b & 00101101b = 00000000b
-11000000b & 00101110b = 00000000b
-11000000b & 00101111b = 00000000b
-11000000b & 00110000b = 00000000b
-11000000b & 00110001b = 00000000b
-11000000b & 00110010b = 00000000b
-11000000b & 00110011b = 00000000b
-11000000b & 00110100b = 00000000b
-11000000b & 00110101b = 00000000b
-11000000b & 00110110b = 00000000b
-11000000b & 00110111b = 00000000b
-11000000b & 00111000b = 00000000b
-11000000b & 00111001b = 00000000b
-11000000b & 00111010b = 00000000b
-11000000b & 00111011b = 00000000b
-11000000b & 00111100b = 00000000b
-11000000b & 00111101b = 00000000b
-11000000b & 00111110b = 00000000b
-11000000b & 00111111b = 00000000b
-11000000b & 01000000b = 01000000b
-11000000b & 01000001b = 01000000b
-11000000b & 01000010b = 01000000b
-11000000b & 01000011b = 01000000b
-11000000b & 01000100b = 01000000b
-11000000b & 01000101b = 01000000b
-11000000b & 01000110b = 01000000b
-11000000b & 01000111b = 01000000b
-11000000b & 01001000b = 01000000b
-11000000b & 01001001b = 01000000b
-11000000b & 01001010b = 01000000b
-11000000b & 01001011b = 01000000b
-11000000b & 01001100b = 01000000b
-11000000b & 01001101b = 01000000b
-11000000b & 01001110b = 01000000b
-11000000b & 01001111b = 01000000b
-11000000b & 01010000b = 01000000b
-11000000b & 01010001b = 01000000b
-11000000b & 01010010b = 01000000b
-11000000b & 01010011b = 01000000b
-11000000b & 01010100b = 01000000b
-11000000b & 01010101b = 01000000b
-11000000b & 01010110b = 01000000b
-11000000b & 01010111b = 01000000b
-11000000b & 01011000b = 01000000b
-11000000b & 01011001b = 01000000b
-11000000b & 01011010b = 01000000b
-11000000b & 01011011b = 01000000b
-11000000b & 01011100b = 01000000b
-11000000b & 01011101b = 01000000b
-11000000b & 01011110b = 01000000b
-11000000b & 01011111b = 01000000b
-11000000b & 01100000b = 01000000b
-11000000b & 01100001b = 01000000b
-11000000b & 01100010b = 01000000b
-11000000b & 01100011b = 01000000b
-11000000b & 01100100b = 01000000b
-11000000b & 01100101b = 01000000b
-11000000b & 01100110b = 01000000b
-11000000b & 01100111b = 01000000b
-11000000b & 01101000b = 01000000b
-11000000b & 01101001b = 01000000b
-11000000b & 01101010b = 01000000b
-11000000b & 01101011b = 01000000b
-11000000b & 01101100b = 01000000b
-11000000b & 01101101b = 01000000b
-11000000b & 01101110b = 01000000b
-11000000b & 01101111b = 01000000b
-11000000b & 01110000b = 01000000b
-11000000b & 01110001b = 01000000b
-11000000b & 01110010b = 01000000b
-11000000b & 01110011b = 01000000b
-11000000b & 01110100b = 01000000b
-11000000b & 01110101b = 01000000b
-11000000b & 01110110b = 01000000b
-11000000b & 01110111b = 01000000b
-11000000b & 01111000b = 01000000b
-11000000b & 01111001b = 01000000b
-11000000b & 01111010b = 01000000b
-11000000b & 01111011b = 01000000b
-11000000b & 01111100b = 01000000b
-11000000b & 01111101b = 01000000b
-11000000b & 01111110b = 01000000b
-11000001b & 10000000b = 10000000b
-11000001b & 10000001b = 10000001b
-11000001b & 10000010b = 10000000b
-11000001b & 10000011b = 10000001b
-11000001b & 10000100b = 10000000b
-11000001b & 10000101b = 10000001b
-11000001b & 10000110b = 10000000b
-11000001b & 10000111b = 10000001b
-11000001b & 10001000b = 10000000b
-11000001b & 10001001b = 10000001b
-11000001b & 10001010b = 10000000b
-11000001b & 10001011b = 10000001b
-11000001b & 10001100b = 10000000b
-11000001b & 10001101b = 10000001b
-11000001b & 10001110b = 10000000b
-11000001b & 10001111b = 10000001b
-11000001b & 10010000b = 10000000b
-11000001b & 10010001b = 10000001b
-11000001b & 10010010b = 10000000b
-11000001b & 10010011b = 10000001b
-11000001b & 10010100b = 10000000b
-11000001b & 10010101b = 10000001b
-11000001b & 10010110b = 10000000b
-11000001b & 10010111b = 10000001b
-11000001b & 10011000b = 10000000b
-11000001b & 10011001b = 10000001b
-11000001b & 10011010b = 10000000b
-11000001b & 10011011b = 10000001b
-11000001b & 10011100b = 10000000b
-11000001b & 10011101b = 10000001b
-11000001b & 10011110b = 10000000b
-11000001b & 10011111b = 10000001b
-11000001b & 10100000b = 10000000b
-11000001b & 10100001b = 10000001b
-11000001b & 10100010b = 10000000b
-11000001b & 10100011b = 10000001b
-11000001b & 10100100b = 10000000b
-11000001b & 10100101b = 10000001b
-11000001b & 10100110b = 10000000b
-11000001b & 10100111b = 10000001b
-11000001b & 10101000b = 10000000b
-11000001b & 10101001b = 10000001b
-11000001b & 10101010b = 10000000b
-11000001b & 10101011b = 10000001b
-11000001b & 10101100b = 10000000b
-11000001b & 10101101b = 10000001b
-11000001b & 10101110b = 10000000b
-11000001b & 10101111b = 10000001b
-11000001b & 10110000b = 10000000b
-11000001b & 10110001b = 10000001b
-11000001b & 10110010b = 10000000b
-11000001b & 10110011b = 10000001b
-11000001b & 10110100b = 10000000b
-11000001b & 10110101b = 10000001b
-11000001b & 10110110b = 10000000b
-11000001b & 10110111b = 10000001b
-11000001b & 10111000b = 10000000b
-11000001b & 10111001b = 10000001b
-11000001b & 10111010b = 10000000b
-11000001b & 10111011b = 10000001b
-11000001b & 10111100b = 10000000b
-11000001b & 10111101b = 10000001b
-11000001b & 10111110b = 10000000b
-11000001b & 10111111b = 10000001b
-11000001b & 11000000b = 11000000b
-11000001b & 11000001b = 11000001b
-11000001b & 11000010b = 11000000b
-11000001b & 11000011b = 11000001b
-11000001b & 11000100b = 11000000b
-11000001b & 11000101b = 11000001b
-11000001b & 11000110b = 11000000b
-11000001b & 11000111b = 11000001b
-11000001b & 11001000b = 11000000b
-11000001b & 11001001b = 11000001b
-11000001b & 11001010b = 11000000b
-11000001b & 11001011b = 11000001b
-11000001b & 11001100b = 11000000b
-11000001b & 11001101b = 11000001b
-11000001b & 11001110b = 11000000b
-11000001b & 11001111b = 11000001b
-11000001b & 11010000b = 11000000b
-11000001b & 11010001b = 11000001b
-11000001b & 11010010b = 11000000b
-11000001b & 11010011b = 11000001b
-11000001b & 11010100b = 11000000b
-11000001b & 11010101b = 11000001b
-11000001b & 11010110b = 11000000b
-11000001b & 11010111b = 11000001b
-11000001b & 11011000b = 11000000b
-11000001b & 11011001b = 11000001b
-11000001b & 11011010b = 11000000b
-11000001b & 11011011b = 11000001b
-11000001b & 11011100b = 11000000b
-11000001b & 11011101b = 11000001b
-11000001b & 11011110b = 11000000b
-11000001b & 11011111b = 11000001b
-11000001b & 11100000b = 11000000b
-11000001b & 11100001b = 11000001b
-11000001b & 11100010b = 11000000b
-11000001b & 11100011b = 11000001b
-11000001b & 11100100b = 11000000b
-11000001b & 11100101b = 11000001b
-11000001b & 11100110b = 11000000b
-11000001b & 11100111b = 11000001b
-11000001b & 11101000b = 11000000b
-11000001b & 11101001b = 11000001b
-11000001b & 11101010b = 11000000b
-11000001b & 11101011b = 11000001b
-11000001b & 11101100b = 11000000b
-11000001b & 11101101b = 11000001b
-11000001b & 11101110b = 11000000b
-11000001b & 11101111b = 11000001b
-11000001b & 11110000b = 11000000b
-11000001b & 11110001b = 11000001b
-11000001b & 11110010b = 11000000b
-11000001b & 11110011b = 11000001b
-11000001b & 11110100b = 11000000b
-11000001b & 11110101b = 11000001b
-11000001b & 11110110b = 11000000b
-11000001b & 11110111b = 11000001b
-11000001b & 11111000b = 11000000b
-11000001b & 11111001b = 11000001b
-11000001b & 11111010b = 11000000b
-11000001b & 11111011b = 11000001b
-11000001b & 11111100b = 11000000b
-11000001b & 11111101b = 11000001b
-11000001b & 11111110b = 11000000b
-11000001b & 11111111b = 11000001b
-11000001b & 00000000b = 00000000b
-11000001b & 00000001b = 00000001b
-11000001b & 00000010b = 00000000b
-11000001b & 00000011b = 00000001b
-11000001b & 00000100b = 00000000b
-11000001b & 00000101b = 00000001b
-11000001b & 00000110b = 00000000b
-11000001b & 00000111b = 00000001b
-11000001b & 00001000b = 00000000b
-11000001b & 00001001b = 00000001b
-11000001b & 00001010b = 00000000b
-11000001b & 00001011b = 00000001b
-11000001b & 00001100b = 00000000b
-11000001b & 00001101b = 00000001b
-11000001b & 00001110b = 00000000b
-11000001b & 00001111b = 00000001b
-11000001b & 00010000b = 00000000b
-11000001b & 00010001b = 00000001b
-11000001b & 00010010b = 00000000b
-11000001b & 00010011b = 00000001b
-11000001b & 00010100b = 00000000b
-11000001b & 00010101b = 00000001b
-11000001b & 00010110b = 00000000b
-11000001b & 00010111b = 00000001b
-11000001b & 00011000b = 00000000b
-11000001b & 00011001b = 00000001b
-11000001b & 00011010b = 00000000b
-11000001b & 00011011b = 00000001b
-11000001b & 00011100b = 00000000b
-11000001b & 00011101b = 00000001b
-11000001b & 00011110b = 00000000b
-11000001b & 00011111b = 00000001b
-11000001b & 00100000b = 00000000b
-11000001b & 00100001b = 00000001b
-11000001b & 00100010b = 00000000b
-11000001b & 00100011b = 00000001b
-11000001b & 00100100b = 00000000b
-11000001b & 00100101b = 00000001b
-11000001b & 00100110b = 00000000b
-11000001b & 00100111b = 00000001b
-11000001b & 00101000b = 00000000b
-11000001b & 00101001b = 00000001b
-11000001b & 00101010b = 00000000b
-11000001b & 00101011b = 00000001b
-11000001b & 00101100b = 00000000b
-11000001b & 00101101b = 00000001b
-11000001b & 00101110b = 00000000b
-11000001b & 00101111b = 00000001b
-11000001b & 00110000b = 00000000b
-11000001b & 00110001b = 00000001b
-11000001b & 00110010b = 00000000b
-11000001b & 00110011b = 00000001b
-11000001b & 00110100b = 00000000b
-11000001b & 00110101b = 00000001b
-11000001b & 00110110b = 00000000b
-11000001b & 00110111b = 00000001b
-11000001b & 00111000b = 00000000b
-11000001b & 00111001b = 00000001b
-11000001b & 00111010b = 00000000b
-11000001b & 00111011b = 00000001b
-11000001b & 00111100b = 00000000b
-11000001b & 00111101b = 00000001b
-11000001b & 00111110b = 00000000b
-11000001b & 00111111b = 00000001b
-11000001b & 01000000b = 01000000b
-11000001b & 01000001b = 01000001b
-11000001b & 01000010b = 01000000b
-11000001b & 01000011b = 01000001b
-11000001b & 01000100b = 01000000b
-11000001b & 01000101b = 01000001b
-11000001b & 01000110b = 01000000b
-11000001b & 01000111b = 01000001b
-11000001b & 01001000b = 01000000b
-11000001b & 01001001b = 01000001b
-11000001b & 01001010b = 01000000b
-11000001b & 01001011b = 01000001b
-11000001b & 01001100b = 01000000b
-11000001b & 01001101b = 01000001b
-11000001b & 01001110b = 01000000b
-11000001b & 01001111b = 01000001b
-11000001b & 01010000b = 01000000b
-11000001b & 01010001b = 01000001b
-11000001b & 01010010b = 01000000b
-11000001b & 01010011b = 01000001b
-11000001b & 01010100b = 01000000b
-11000001b & 01010101b = 01000001b
-11000001b & 01010110b = 01000000b
-11000001b & 01010111b = 01000001b
-11000001b & 01011000b = 01000000b
-11000001b & 01011001b = 01000001b
-11000001b & 01011010b = 01000000b
-11000001b & 01011011b = 01000001b
-11000001b & 01011100b = 01000000b
-11000001b & 01011101b = 01000001b
-11000001b & 01011110b = 01000000b
-11000001b & 01011111b = 01000001b
-11000001b & 01100000b = 01000000b
-11000001b & 01100001b = 01000001b
-11000001b & 01100010b = 01000000b
-11000001b & 01100011b = 01000001b
-11000001b & 01100100b = 01000000b
-11000001b & 01100101b = 01000001b
-11000001b & 01100110b = 01000000b
-11000001b & 01100111b = 01000001b
-11000001b & 01101000b = 01000000b
-11000001b & 01101001b = 01000001b
-11000001b & 01101010b = 01000000b
-11000001b & 01101011b = 01000001b
-11000001b & 01101100b = 01000000b
-11000001b & 01101101b = 01000001b
-11000001b & 01101110b = 01000000b
-11000001b & 01101111b = 01000001b
-11000001b & 01110000b = 01000000b
-11000001b & 01110001b = 01000001b
-11000001b & 01110010b = 01000000b
-11000001b & 01110011b = 01000001b
-11000001b & 01110100b = 01000000b
-11000001b & 01110101b = 01000001b
-11000001b & 01110110b = 01000000b
-11000001b & 01110111b = 01000001b
-11000001b & 01111000b = 01000000b
-11000001b & 01111001b = 01000001b
-11000001b & 01111010b = 01000000b
-11000001b & 01111011b = 01000001b
-11000001b & 01111100b = 01000000b
-11000001b & 01111101b = 01000001b
-11000001b & 01111110b = 01000000b
-11000010b & 10000000b = 10000000b
-11000010b & 10000001b = 10000000b
-11000010b & 10000010b = 10000010b
-11000010b & 10000011b = 10000010b
-11000010b & 10000100b = 10000000b
-11000010b & 10000101b = 10000000b
-11000010b & 10000110b = 10000010b
-11000010b & 10000111b = 10000010b
-11000010b & 10001000b = 10000000b
-11000010b & 10001001b = 10000000b
-11000010b & 10001010b = 10000010b
-11000010b & 10001011b = 10000010b
-11000010b & 10001100b = 10000000b
-11000010b & 10001101b = 10000000b
-11000010b & 10001110b = 10000010b
-11000010b & 10001111b = 10000010b
-11000010b & 10010000b = 10000000b
-11000010b & 10010001b = 10000000b
-11000010b & 10010010b = 10000010b
-11000010b & 10010011b = 10000010b
-11000010b & 10010100b = 10000000b
-11000010b & 10010101b = 10000000b
-11000010b & 10010110b = 10000010b
-11000010b & 10010111b = 10000010b
-11000010b & 10011000b = 10000000b
-11000010b & 10011001b = 10000000b
-11000010b & 10011010b = 10000010b
-11000010b & 10011011b = 10000010b
-11000010b & 10011100b = 10000000b
-11000010b & 10011101b = 10000000b
-11000010b & 10011110b = 10000010b
-11000010b & 10011111b = 10000010b
-11000010b & 10100000b = 10000000b
-11000010b & 10100001b = 10000000b
-11000010b & 10100010b = 10000010b
-11000010b & 10100011b = 10000010b
-11000010b & 10100100b = 10000000b
-11000010b & 10100101b = 10000000b
-11000010b & 10100110b = 10000010b
-11000010b & 10100111b = 10000010b
-11000010b & 10101000b = 10000000b
-11000010b & 10101001b = 10000000b
-11000010b & 10101010b = 10000010b
-11000010b & 10101011b = 10000010b
-11000010b & 10101100b = 10000000b
-11000010b & 10101101b = 10000000b
-11000010b & 10101110b = 10000010b
-11000010b & 10101111b = 10000010b
-11000010b & 10110000b = 10000000b
-11000010b & 10110001b = 10000000b
-11000010b & 10110010b = 10000010b
-11000010b & 10110011b = 10000010b
-11000010b & 10110100b = 10000000b
-11000010b & 10110101b = 10000000b
-11000010b & 10110110b = 10000010b
-11000010b & 10110111b = 10000010b
-11000010b & 10111000b = 10000000b
-11000010b & 10111001b = 10000000b
-11000010b & 10111010b = 10000010b
-11000010b & 10111011b = 10000010b
-11000010b & 10111100b = 10000000b
-11000010b & 10111101b = 10000000b
-11000010b & 10111110b = 10000010b
-11000010b & 10111111b = 10000010b
-11000010b & 11000000b = 11000000b
-11000010b & 11000001b = 11000000b
-11000010b & 11000010b = 11000010b
-11000010b & 11000011b = 11000010b
-11000010b & 11000100b = 11000000b
-11000010b & 11000101b = 11000000b
-11000010b & 11000110b = 11000010b
-11000010b & 11000111b = 11000010b
-11000010b & 11001000b = 11000000b
-11000010b & 11001001b = 11000000b
-11000010b & 11001010b = 11000010b
-11000010b & 11001011b = 11000010b
-11000010b & 11001100b = 11000000b
-11000010b & 11001101b = 11000000b
-11000010b & 11001110b = 11000010b
-11000010b & 11001111b = 11000010b
-11000010b & 11010000b = 11000000b
-11000010b & 11010001b = 11000000b
-11000010b & 11010010b = 11000010b
-11000010b & 11010011b = 11000010b
-11000010b & 11010100b = 11000000b
-11000010b & 11010101b = 11000000b
-11000010b & 11010110b = 11000010b
-11000010b & 11010111b = 11000010b
-11000010b & 11011000b = 11000000b
-11000010b & 11011001b = 11000000b
-11000010b & 11011010b = 11000010b
-11000010b & 11011011b = 11000010b
-11000010b & 11011100b = 11000000b
-11000010b & 11011101b = 11000000b
-11000010b & 11011110b = 11000010b
-11000010b & 11011111b = 11000010b
-11000010b & 11100000b = 11000000b
-11000010b & 11100001b = 11000000b
-11000010b & 11100010b = 11000010b
-11000010b & 11100011b = 11000010b
-11000010b & 11100100b = 11000000b
-11000010b & 11100101b = 11000000b
-11000010b & 11100110b = 11000010b
-11000010b & 11100111b = 11000010b
-11000010b & 11101000b = 11000000b
-11000010b & 11101001b = 11000000b
-11000010b & 11101010b = 11000010b
-11000010b & 11101011b = 11000010b
-11000010b & 11101100b = 11000000b
-11000010b & 11101101b = 11000000b
-11000010b & 11101110b = 11000010b
-11000010b & 11101111b = 11000010b
-11000010b & 11110000b = 11000000b
-11000010b & 11110001b = 11000000b
-11000010b & 11110010b = 11000010b
-11000010b & 11110011b = 11000010b
-11000010b & 11110100b = 11000000b
-11000010b & 11110101b = 11000000b
-11000010b & 11110110b = 11000010b
-11000010b & 11110111b = 11000010b
-11000010b & 11111000b = 11000000b
-11000010b & 11111001b = 11000000b
-11000010b & 11111010b = 11000010b
-11000010b & 11111011b = 11000010b
-11000010b & 11111100b = 11000000b
-11000010b & 11111101b = 11000000b
-11000010b & 11111110b = 11000010b
-11000010b & 11111111b = 11000010b
-11000010b & 00000000b = 00000000b
-11000010b & 00000001b = 00000000b
-11000010b & 00000010b = 00000010b
-11000010b & 00000011b = 00000010b
-11000010b & 00000100b = 00000000b
-11000010b & 00000101b = 00000000b
-11000010b & 00000110b = 00000010b
-11000010b & 00000111b = 00000010b
-11000010b & 00001000b = 00000000b
-11000010b & 00001001b = 00000000b
-11000010b & 00001010b = 00000010b
-11000010b & 00001011b = 00000010b
-11000010b & 00001100b = 00000000b
-11000010b & 00001101b = 00000000b
-11000010b & 00001110b = 00000010b
-11000010b & 00001111b = 00000010b
-11000010b & 00010000b = 00000000b
-11000010b & 00010001b = 00000000b
-11000010b & 00010010b = 00000010b
-11000010b & 00010011b = 00000010b
-11000010b & 00010100b = 00000000b
-11000010b & 00010101b = 00000000b
-11000010b & 00010110b = 00000010b
-11000010b & 00010111b = 00000010b
-11000010b & 00011000b = 00000000b
-11000010b & 00011001b = 00000000b
-11000010b & 00011010b = 00000010b
-11000010b & 00011011b = 00000010b
-11000010b & 00011100b = 00000000b
-11000010b & 00011101b = 00000000b
-11000010b & 00011110b = 00000010b
-11000010b & 00011111b = 00000010b
-11000010b & 00100000b = 00000000b
-11000010b & 00100001b = 00000000b
-11000010b & 00100010b = 00000010b
-11000010b & 00100011b = 00000010b
-11000010b & 00100100b = 00000000b
-11000010b & 00100101b = 00000000b
-11000010b & 00100110b = 00000010b
-11000010b & 00100111b = 00000010b
-11000010b & 00101000b = 00000000b
-11000010b & 00101001b = 00000000b
-11000010b & 00101010b = 00000010b
-11000010b & 00101011b = 00000010b
-11000010b & 00101100b = 00000000b
-11000010b & 00101101b = 00000000b
-11000010b & 00101110b = 00000010b
-11000010b & 00101111b = 00000010b
-11000010b & 00110000b = 00000000b
-11000010b & 00110001b = 00000000b
-11000010b & 00110010b = 00000010b
-11000010b & 00110011b = 00000010b
-11000010b & 00110100b = 00000000b
-11000010b & 00110101b = 00000000b
-11000010b & 00110110b = 00000010b
-11000010b & 00110111b = 00000010b
-11000010b & 00111000b = 00000000b
-11000010b & 00111001b = 00000000b
-11000010b & 00111010b = 00000010b
-11000010b & 00111011b = 00000010b
-11000010b & 00111100b = 00000000b
-11000010b & 00111101b = 00000000b
-11000010b & 00111110b = 00000010b
-11000010b & 00111111b = 00000010b
-11000010b & 01000000b = 01000000b
-11000010b & 01000001b = 01000000b
-11000010b & 01000010b = 01000010b
-11000010b & 01000011b = 01000010b
-11000010b & 01000100b = 01000000b
-11000010b & 01000101b = 01000000b
-11000010b & 01000110b = 01000010b
-11000010b & 01000111b = 01000010b
-11000010b & 01001000b = 01000000b
-11000010b & 01001001b = 01000000b
-11000010b & 01001010b = 01000010b
-11000010b & 01001011b = 01000010b
-11000010b & 01001100b = 01000000b
-11000010b & 01001101b = 01000000b
-11000010b & 01001110b = 01000010b
-11000010b & 01001111b = 01000010b
-11000010b & 01010000b = 01000000b
-11000010b & 01010001b = 01000000b
-11000010b & 01010010b = 01000010b
-11000010b & 01010011b = 01000010b
-11000010b & 01010100b = 01000000b
-11000010b & 01010101b = 01000000b
-11000010b & 01010110b = 01000010b
-11000010b & 01010111b = 01000010b
-11000010b & 01011000b = 01000000b
-11000010b & 01011001b = 01000000b
-11000010b & 01011010b = 01000010b
-11000010b & 01011011b = 01000010b
-11000010b & 01011100b = 01000000b
-11000010b & 01011101b = 01000000b
-11000010b & 01011110b = 01000010b
-11000010b & 01011111b = 01000010b
-11000010b & 01100000b = 01000000b
-11000010b & 01100001b = 01000000b
-11000010b & 01100010b = 01000010b
-11000010b & 01100011b = 01000010b
-11000010b & 01100100b = 01000000b
-11000010b & 01100101b = 01000000b
-11000010b & 01100110b = 01000010b
-11000010b & 01100111b = 01000010b
-11000010b & 01101000b = 01000000b
-11000010b & 01101001b = 01000000b
-11000010b & 01101010b = 01000010b
-11000010b & 01101011b = 01000010b
-11000010b & 01101100b = 01000000b
-11000010b & 01101101b = 01000000b
-11000010b & 01101110b = 01000010b
-11000010b & 01101111b = 01000010b
-11000010b & 01110000b = 01000000b
-11000010b & 01110001b = 01000000b
-11000010b & 01110010b = 01000010b
-11000010b & 01110011b = 01000010b
-11000010b & 01110100b = 01000000b
-11000010b & 01110101b = 01000000b
-11000010b & 01110110b = 01000010b
-11000010b & 01110111b = 01000010b
-11000010b & 01111000b = 01000000b
-11000010b & 01111001b = 01000000b
-11000010b & 01111010b = 01000010b
-11000010b & 01111011b = 01000010b
-11000010b & 01111100b = 01000000b
-11000010b & 01111101b = 01000000b
-11000010b & 01111110b = 01000010b
-11000011b & 10000000b = 10000000b
-11000011b & 10000001b = 10000001b
-11000011b & 10000010b = 10000010b
-11000011b & 10000011b = 10000011b
-11000011b & 10000100b = 10000000b
-11000011b & 10000101b = 10000001b
-11000011b & 10000110b = 10000010b
-11000011b & 10000111b = 10000011b
-11000011b & 10001000b = 10000000b
-11000011b & 10001001b = 10000001b
-11000011b & 10001010b = 10000010b
-11000011b & 10001011b = 10000011b
-11000011b & 10001100b = 10000000b
-11000011b & 10001101b = 10000001b
-11000011b & 10001110b = 10000010b
-11000011b & 10001111b = 10000011b
-11000011b & 10010000b = 10000000b
-11000011b & 10010001b = 10000001b
-11000011b & 10010010b = 10000010b
-11000011b & 10010011b = 10000011b
-11000011b & 10010100b = 10000000b
-11000011b & 10010101b = 10000001b
-11000011b & 10010110b = 10000010b
-11000011b & 10010111b = 10000011b
-11000011b & 10011000b = 10000000b
-11000011b & 10011001b = 10000001b
-11000011b & 10011010b = 10000010b
-11000011b & 10011011b = 10000011b
-11000011b & 10011100b = 10000000b
-11000011b & 10011101b = 10000001b
-11000011b & 10011110b = 10000010b
-11000011b & 10011111b = 10000011b
-11000011b & 10100000b = 10000000b
-11000011b & 10100001b = 10000001b
-11000011b & 10100010b = 10000010b
-11000011b & 10100011b = 10000011b
-11000011b & 10100100b = 10000000b
-11000011b & 10100101b = 10000001b
-11000011b & 10100110b = 10000010b
-11000011b & 10100111b = 10000011b
-11000011b & 10101000b = 10000000b
-11000011b & 10101001b = 10000001b
-11000011b & 10101010b = 10000010b
-11000011b & 10101011b = 10000011b
-11000011b & 10101100b = 10000000b
-11000011b & 10101101b = 10000001b
-11000011b & 10101110b = 10000010b
-11000011b & 10101111b = 10000011b
-11000011b & 10110000b = 10000000b
-11000011b & 10110001b = 10000001b
-11000011b & 10110010b = 10000010b
-11000011b & 10110011b = 10000011b
-11000011b & 10110100b = 10000000b
-11000011b & 10110101b = 10000001b
-11000011b & 10110110b = 10000010b
-11000011b & 10110111b = 10000011b
-11000011b & 10111000b = 10000000b
-11000011b & 10111001b = 10000001b
-11000011b & 10111010b = 10000010b
-11000011b & 10111011b = 10000011b
-11000011b & 10111100b = 10000000b
-11000011b & 10111101b = 10000001b
-11000011b & 10111110b = 10000010b
-11000011b & 10111111b = 10000011b
-11000011b & 11000000b = 11000000b
-11000011b & 11000001b = 11000001b
-11000011b & 11000010b = 11000010b
-11000011b & 11000011b = 11000011b
-11000011b & 11000100b = 11000000b
-11000011b & 11000101b = 11000001b
-11000011b & 11000110b = 11000010b
-11000011b & 11000111b = 11000011b
-11000011b & 11001000b = 11000000b
-11000011b & 11001001b = 11000001b
-11000011b & 11001010b = 11000010b
-11000011b & 11001011b = 11000011b
-11000011b & 11001100b = 11000000b
-11000011b & 11001101b = 11000001b
-11000011b & 11001110b = 11000010b
-11000011b & 11001111b = 11000011b
-11000011b & 11010000b = 11000000b
-11000011b & 11010001b = 11000001b
-11000011b & 11010010b = 11000010b
-11000011b & 11010011b = 11000011b
-11000011b & 11010100b = 11000000b
-11000011b & 11010101b = 11000001b
-11000011b & 11010110b = 11000010b
-11000011b & 11010111b = 11000011b
-11000011b & 11011000b = 11000000b
-11000011b & 11011001b = 11000001b
-11000011b & 11011010b = 11000010b
-11000011b & 11011011b = 11000011b
-11000011b & 11011100b = 11000000b
-11000011b & 11011101b = 11000001b
-11000011b & 11011110b = 11000010b
-11000011b & 11011111b = 11000011b
-11000011b & 11100000b = 11000000b
-11000011b & 11100001b = 11000001b
-11000011b & 11100010b = 11000010b
-11000011b & 11100011b = 11000011b
-11000011b & 11100100b = 11000000b
-11000011b & 11100101b = 11000001b
-11000011b & 11100110b = 11000010b
-11000011b & 11100111b = 11000011b
-11000011b & 11101000b = 11000000b
-11000011b & 11101001b = 11000001b
-11000011b & 11101010b = 11000010b
-11000011b & 11101011b = 11000011b
-11000011b & 11101100b = 11000000b
-11000011b & 11101101b = 11000001b
-11000011b & 11101110b = 11000010b
-11000011b & 11101111b = 11000011b
-11000011b & 11110000b = 11000000b
-11000011b & 11110001b = 11000001b
-11000011b & 11110010b = 11000010b
-11000011b & 11110011b = 11000011b
-11000011b & 11110100b = 11000000b
-11000011b & 11110101b = 11000001b
-11000011b & 11110110b = 11000010b
-11000011b & 11110111b = 11000011b
-11000011b & 11111000b = 11000000b
-11000011b & 11111001b = 11000001b
-11000011b & 11111010b = 11000010b
-11000011b & 11111011b = 11000011b
-11000011b & 11111100b = 11000000b
-11000011b & 11111101b = 11000001b
-11000011b & 11111110b = 11000010b
-11000011b & 11111111b = 11000011b
-11000011b & 00000000b = 00000000b
-11000011b & 00000001b = 00000001b
-11000011b & 00000010b = 00000010b
-11000011b & 00000011b = 00000011b
-11000011b & 00000100b = 00000000b
-11000011b & 00000101b = 00000001b
-11000011b & 00000110b = 00000010b
-11000011b & 00000111b = 00000011b
-11000011b & 00001000b = 00000000b
-11000011b & 00001001b = 00000001b
-11000011b & 00001010b = 00000010b
-11000011b & 00001011b = 00000011b
-11000011b & 00001100b = 00000000b
-11000011b & 00001101b = 00000001b
-11000011b & 00001110b = 00000010b
-11000011b & 00001111b = 00000011b
-11000011b & 00010000b = 00000000b
-11000011b & 00010001b = 00000001b
-11000011b & 00010010b = 00000010b
-11000011b & 00010011b = 00000011b
-11000011b & 00010100b = 00000000b
-11000011b & 00010101b = 00000001b
-11000011b & 00010110b = 00000010b
-11000011b & 00010111b = 00000011b
-11000011b & 00011000b = 00000000b
-11000011b & 00011001b = 00000001b
-11000011b & 00011010b = 00000010b
-11000011b & 00011011b = 00000011b
-11000011b & 00011100b = 00000000b
-11000011b & 00011101b = 00000001b
-11000011b & 00011110b = 00000010b
-11000011b & 00011111b = 00000011b
-11000011b & 00100000b = 00000000b
-11000011b & 00100001b = 00000001b
-11000011b & 00100010b = 00000010b
-11000011b & 00100011b = 00000011b
-11000011b & 00100100b = 00000000b
-11000011b & 00100101b = 00000001b
-11000011b & 00100110b = 00000010b
-11000011b & 00100111b = 00000011b
-11000011b & 00101000b = 00000000b
-11000011b & 00101001b = 00000001b
-11000011b & 00101010b = 00000010b
-11000011b & 00101011b = 00000011b
-11000011b & 00101100b = 00000000b
-11000011b & 00101101b = 00000001b
-11000011b & 00101110b = 00000010b
-11000011b & 00101111b = 00000011b
-11000011b & 00110000b = 00000000b
-11000011b & 00110001b = 00000001b
-11000011b & 00110010b = 00000010b
-11000011b & 00110011b = 00000011b
-11000011b & 00110100b = 00000000b
-11000011b & 00110101b = 00000001b
-11000011b & 00110110b = 00000010b
-11000011b & 00110111b = 00000011b
-11000011b & 00111000b = 00000000b
-11000011b & 00111001b = 00000001b
-11000011b & 00111010b = 00000010b
-11000011b & 00111011b = 00000011b
-11000011b & 00111100b = 00000000b
-11000011b & 00111101b = 00000001b
-11000011b & 00111110b = 00000010b
-11000011b & 00111111b = 00000011b
-11000011b & 01000000b = 01000000b
-11000011b & 01000001b = 01000001b
-11000011b & 01000010b = 01000010b
-11000011b & 01000011b = 01000011b
-11000011b & 01000100b = 01000000b
-11000011b & 01000101b = 01000001b
-11000011b & 01000110b = 01000010b
-11000011b & 01000111b = 01000011b
-11000011b & 01001000b = 01000000b
-11000011b & 01001001b = 01000001b
-11000011b & 01001010b = 01000010b
-11000011b & 01001011b = 01000011b
-11000011b & 01001100b = 01000000b
-11000011b & 01001101b = 01000001b
-11000011b & 01001110b = 01000010b
-11000011b & 01001111b = 01000011b
-11000011b & 01010000b = 01000000b
-11000011b & 01010001b = 01000001b
-11000011b & 01010010b = 01000010b
-11000011b & 01010011b = 01000011b
-11000011b & 01010100b = 01000000b
-11000011b & 01010101b = 01000001b
-11000011b & 01010110b = 01000010b
-11000011b & 01010111b = 01000011b
-11000011b & 01011000b = 01000000b
-11000011b & 01011001b = 01000001b
-11000011b & 01011010b = 01000010b
-11000011b & 01011011b = 01000011b
-11000011b & 01011100b = 01000000b
-11000011b & 01011101b = 01000001b
-11000011b & 01011110b = 01000010b
-11000011b & 01011111b = 01000011b
-11000011b & 01100000b = 01000000b
-11000011b & 01100001b = 01000001b
-11000011b & 01100010b = 01000010b
-11000011b & 01100011b = 01000011b
-11000011b & 01100100b = 01000000b
-11000011b & 01100101b = 01000001b
-11000011b & 01100110b = 01000010b
-11000011b & 01100111b = 01000011b
-11000011b & 01101000b = 01000000b
-11000011b & 01101001b = 01000001b
-11000011b & 01101010b = 01000010b
-11000011b & 01101011b = 01000011b
-11000011b & 01101100b = 01000000b
-11000011b & 01101101b = 01000001b
-11000011b & 01101110b = 01000010b
-11000011b & 01101111b = 01000011b
-11000011b & 01110000b = 01000000b
-11000011b & 01110001b = 01000001b
-11000011b & 01110010b = 01000010b
-11000011b & 01110011b = 01000011b
-11000011b & 01110100b = 01000000b
-11000011b & 01110101b = 01000001b
-11000011b & 01110110b = 01000010b
-11000011b & 01110111b = 01000011b
-11000011b & 01111000b = 01000000b
-11000011b & 01111001b = 01000001b
-11000011b & 01111010b = 01000010b
-11000011b & 01111011b = 01000011b
-11000011b & 01111100b = 01000000b
-11000011b & 01111101b = 01000001b
-11000011b & 01111110b = 01000010b
-11000100b & 10000000b = 10000000b
-11000100b & 10000001b = 10000000b
-11000100b & 10000010b = 10000000b
-11000100b & 10000011b = 10000000b
-11000100b & 10000100b = 10000100b
-11000100b & 10000101b = 10000100b
-11000100b & 10000110b = 10000100b
-11000100b & 10000111b = 10000100b
-11000100b & 10001000b = 10000000b
-11000100b & 10001001b = 10000000b
-11000100b & 10001010b = 10000000b
-11000100b & 10001011b = 10000000b
-11000100b & 10001100b = 10000100b
-11000100b & 10001101b = 10000100b
-11000100b & 10001110b = 10000100b
-11000100b & 10001111b = 10000100b
-11000100b & 10010000b = 10000000b
-11000100b & 10010001b = 10000000b
-11000100b & 10010010b = 10000000b
-11000100b & 10010011b = 10000000b
-11000100b & 10010100b = 10000100b
-11000100b & 10010101b = 10000100b
-11000100b & 10010110b = 10000100b
-11000100b & 10010111b = 10000100b
-11000100b & 10011000b = 10000000b
-11000100b & 10011001b = 10000000b
-11000100b & 10011010b = 10000000b
-11000100b & 10011011b = 10000000b
-11000100b & 10011100b = 10000100b
-11000100b & 10011101b = 10000100b
-11000100b & 10011110b = 10000100b
-11000100b & 10011111b = 10000100b
-11000100b & 10100000b = 10000000b
-11000100b & 10100001b = 10000000b
-11000100b & 10100010b = 10000000b
-11000100b & 10100011b = 10000000b
-11000100b & 10100100b = 10000100b
-11000100b & 10100101b = 10000100b
-11000100b & 10100110b = 10000100b
-11000100b & 10100111b = 10000100b
-11000100b & 10101000b = 10000000b
-11000100b & 10101001b = 10000000b
-11000100b & 10101010b = 10000000b
-11000100b & 10101011b = 10000000b
-11000100b & 10101100b = 10000100b
-11000100b & 10101101b = 10000100b
-11000100b & 10101110b = 10000100b
-11000100b & 10101111b = 10000100b
-11000100b & 10110000b = 10000000b
-11000100b & 10110001b = 10000000b
-11000100b & 10110010b = 10000000b
-11000100b & 10110011b = 10000000b
-11000100b & 10110100b = 10000100b
-11000100b & 10110101b = 10000100b
-11000100b & 10110110b = 10000100b
-11000100b & 10110111b = 10000100b
-11000100b & 10111000b = 10000000b
-11000100b & 10111001b = 10000000b
-11000100b & 10111010b = 10000000b
-11000100b & 10111011b = 10000000b
-11000100b & 10111100b = 10000100b
-11000100b & 10111101b = 10000100b
-11000100b & 10111110b = 10000100b
-11000100b & 10111111b = 10000100b
-11000100b & 11000000b = 11000000b
-11000100b & 11000001b = 11000000b
-11000100b & 11000010b = 11000000b
-11000100b & 11000011b = 11000000b
-11000100b & 11000100b = 11000100b
-11000100b & 11000101b = 11000100b
-11000100b & 11000110b = 11000100b
-11000100b & 11000111b = 11000100b
-11000100b & 11001000b = 11000000b
-11000100b & 11001001b = 11000000b
-11000100b & 11001010b = 11000000b
-11000100b & 11001011b = 11000000b
-11000100b & 11001100b = 11000100b
-11000100b & 11001101b = 11000100b
-11000100b & 11001110b = 11000100b
-11000100b & 11001111b = 11000100b
-11000100b & 11010000b = 11000000b
-11000100b & 11010001b = 11000000b
-11000100b & 11010010b = 11000000b
-11000100b & 11010011b = 11000000b
-11000100b & 11010100b = 11000100b
-11000100b & 11010101b = 11000100b
-11000100b & 11010110b = 11000100b
-11000100b & 11010111b = 11000100b
-11000100b & 11011000b = 11000000b
-11000100b & 11011001b = 11000000b
-11000100b & 11011010b = 11000000b
-11000100b & 11011011b = 11000000b
-11000100b & 11011100b = 11000100b
-11000100b & 11011101b = 11000100b
-11000100b & 11011110b = 11000100b
-11000100b & 11011111b = 11000100b
-11000100b & 11100000b = 11000000b
-11000100b & 11100001b = 11000000b
-11000100b & 11100010b = 11000000b
-11000100b & 11100011b = 11000000b
-11000100b & 11100100b = 11000100b
-11000100b & 11100101b = 11000100b
-11000100b & 11100110b = 11000100b
-11000100b & 11100111b = 11000100b
-11000100b & 11101000b = 11000000b
-11000100b & 11101001b = 11000000b
-11000100b & 11101010b = 11000000b
-11000100b & 11101011b = 11000000b
-11000100b & 11101100b = 11000100b
-11000100b & 11101101b = 11000100b
-11000100b & 11101110b = 11000100b
-11000100b & 11101111b = 11000100b
-11000100b & 11110000b = 11000000b
-11000100b & 11110001b = 11000000b
-11000100b & 11110010b = 11000000b
-11000100b & 11110011b = 11000000b
-11000100b & 11110100b = 11000100b
-11000100b & 11110101b = 11000100b
-11000100b & 11110110b = 11000100b
-11000100b & 11110111b = 11000100b
-11000100b & 11111000b = 11000000b
-11000100b & 11111001b = 11000000b
-11000100b & 11111010b = 11000000b
-11000100b & 11111011b = 11000000b
-11000100b & 11111100b = 11000100b
-11000100b & 11111101b = 11000100b
-11000100b & 11111110b = 11000100b
-11000100b & 11111111b = 11000100b
-11000100b & 00000000b = 00000000b
-11000100b & 00000001b = 00000000b
-11000100b & 00000010b = 00000000b
-11000100b & 00000011b = 00000000b
-11000100b & 00000100b = 00000100b
-11000100b & 00000101b = 00000100b
-11000100b & 00000110b = 00000100b
-11000100b & 00000111b = 00000100b
-11000100b & 00001000b = 00000000b
-11000100b & 00001001b = 00000000b
-11000100b & 00001010b = 00000000b
-11000100b & 00001011b = 00000000b
-11000100b & 00001100b = 00000100b
-11000100b & 00001101b = 00000100b
-11000100b & 00001110b = 00000100b
-11000100b & 00001111b = 00000100b
-11000100b & 00010000b = 00000000b
-11000100b & 00010001b = 00000000b
-11000100b & 00010010b = 00000000b
-11000100b & 00010011b = 00000000b
-11000100b & 00010100b = 00000100b
-11000100b & 00010101b = 00000100b
-11000100b & 00010110b = 00000100b
-11000100b & 00010111b = 00000100b
-11000100b & 00011000b = 00000000b
-11000100b & 00011001b = 00000000b
-11000100b & 00011010b = 00000000b
-11000100b & 00011011b = 00000000b
-11000100b & 00011100b = 00000100b
-11000100b & 00011101b = 00000100b
-11000100b & 00011110b = 00000100b
-11000100b & 00011111b = 00000100b
-11000100b & 00100000b = 00000000b
-11000100b & 00100001b = 00000000b
-11000100b & 00100010b = 00000000b
-11000100b & 00100011b = 00000000b
-11000100b & 00100100b = 00000100b
-11000100b & 00100101b = 00000100b
-11000100b & 00100110b = 00000100b
-11000100b & 00100111b = 00000100b
-11000100b & 00101000b = 00000000b
-11000100b & 00101001b = 00000000b
-11000100b & 00101010b = 00000000b
-11000100b & 00101011b = 00000000b
-11000100b & 00101100b = 00000100b
-11000100b & 00101101b = 00000100b
-11000100b & 00101110b = 00000100b
-11000100b & 00101111b = 00000100b
-11000100b & 00110000b = 00000000b
-11000100b & 00110001b = 00000000b
-11000100b & 00110010b = 00000000b
-11000100b & 00110011b = 00000000b
-11000100b & 00110100b = 00000100b
-11000100b & 00110101b = 00000100b
-11000100b & 00110110b = 00000100b
-11000100b & 00110111b = 00000100b
-11000100b & 00111000b = 00000000b
-11000100b & 00111001b = 00000000b
-11000100b & 00111010b = 00000000b
-11000100b & 00111011b = 00000000b
-11000100b & 00111100b = 00000100b
-11000100b & 00111101b = 00000100b
-11000100b & 00111110b = 00000100b
-11000100b & 00111111b = 00000100b
-11000100b & 01000000b = 01000000b
-11000100b & 01000001b = 01000000b
-11000100b & 01000010b = 01000000b
-11000100b & 01000011b = 01000000b
-11000100b & 01000100b = 01000100b
-11000100b & 01000101b = 01000100b
-11000100b & 01000110b = 01000100b
-11000100b & 01000111b = 01000100b
-11000100b & 01001000b = 01000000b
-11000100b & 01001001b = 01000000b
-11000100b & 01001010b = 01000000b
-11000100b & 01001011b = 01000000b
-11000100b & 01001100b = 01000100b
-11000100b & 01001101b = 01000100b
-11000100b & 01001110b = 01000100b
-11000100b & 01001111b = 01000100b
-11000100b & 01010000b = 01000000b
-11000100b & 01010001b = 01000000b
-11000100b & 01010010b = 01000000b
-11000100b & 01010011b = 01000000b
-11000100b & 01010100b = 01000100b
-11000100b & 01010101b = 01000100b
-11000100b & 01010110b = 01000100b
-11000100b & 01010111b = 01000100b
-11000100b & 01011000b = 01000000b
-11000100b & 01011001b = 01000000b
-11000100b & 01011010b = 01000000b
-11000100b & 01011011b = 01000000b
-11000100b & 01011100b = 01000100b
-11000100b & 01011101b = 01000100b
-11000100b & 01011110b = 01000100b
-11000100b & 01011111b = 01000100b
-11000100b & 01100000b = 01000000b
-11000100b & 01100001b = 01000000b
-11000100b & 01100010b = 01000000b
-11000100b & 01100011b = 01000000b
-11000100b & 01100100b = 01000100b
-11000100b & 01100101b = 01000100b
-11000100b & 01100110b = 01000100b
-11000100b & 01100111b = 01000100b
-11000100b & 01101000b = 01000000b
-11000100b & 01101001b = 01000000b
-11000100b & 01101010b = 01000000b
-11000100b & 01101011b = 01000000b
-11000100b & 01101100b = 01000100b
-11000100b & 01101101b = 01000100b
-11000100b & 01101110b = 01000100b
-11000100b & 01101111b = 01000100b
-11000100b & 01110000b = 01000000b
-11000100b & 01110001b = 01000000b
-11000100b & 01110010b = 01000000b
-11000100b & 01110011b = 01000000b
-11000100b & 01110100b = 01000100b
-11000100b & 01110101b = 01000100b
-11000100b & 01110110b = 01000100b
-11000100b & 01110111b = 01000100b
-11000100b & 01111000b = 01000000b
-11000100b & 01111001b = 01000000b
-11000100b & 01111010b = 01000000b
-11000100b & 01111011b = 01000000b
-11000100b & 01111100b = 01000100b
-11000100b & 01111101b = 01000100b
-11000100b & 01111110b = 01000100b
-11000101b & 10000000b = 10000000b
-11000101b & 10000001b = 10000001b
-11000101b & 10000010b = 10000000b
-11000101b & 10000011b = 10000001b
-11000101b & 10000100b = 10000100b
-11000101b & 10000101b = 10000101b
-11000101b & 10000110b = 10000100b
-11000101b & 10000111b = 10000101b
-11000101b & 10001000b = 10000000b
-11000101b & 10001001b = 10000001b
-11000101b & 10001010b = 10000000b
-11000101b & 10001011b = 10000001b
-11000101b & 10001100b = 10000100b
-11000101b & 10001101b = 10000101b
-11000101b & 10001110b = 10000100b
-11000101b & 10001111b = 10000101b
-11000101b & 10010000b = 10000000b
-11000101b & 10010001b = 10000001b
-11000101b & 10010010b = 10000000b
-11000101b & 10010011b = 10000001b
-11000101b & 10010100b = 10000100b
-11000101b & 10010101b = 10000101b
-11000101b & 10010110b = 10000100b
-11000101b & 10010111b = 10000101b
-11000101b & 10011000b = 10000000b
-11000101b & 10011001b = 10000001b
-11000101b & 10011010b = 10000000b
-11000101b & 10011011b = 10000001b
-11000101b & 10011100b = 10000100b
-11000101b & 10011101b = 10000101b
-11000101b & 10011110b = 10000100b
-11000101b & 10011111b = 10000101b
-11000101b & 10100000b = 10000000b
-11000101b & 10100001b = 10000001b
-11000101b & 10100010b = 10000000b
-11000101b & 10100011b = 10000001b
-11000101b & 10100100b = 10000100b
-11000101b & 10100101b = 10000101b
-11000101b & 10100110b = 10000100b
-11000101b & 10100111b = 10000101b
-11000101b & 10101000b = 10000000b
-11000101b & 10101001b = 10000001b
-11000101b & 10101010b = 10000000b
-11000101b & 10101011b = 10000001b
-11000101b & 10101100b = 10000100b
-11000101b & 10101101b = 10000101b
-11000101b & 10101110b = 10000100b
-11000101b & 10101111b = 10000101b
-11000101b & 10110000b = 10000000b
-11000101b & 10110001b = 10000001b
-11000101b & 10110010b = 10000000b
-11000101b & 10110011b = 10000001b
-11000101b & 10110100b = 10000100b
-11000101b & 10110101b = 10000101b
-11000101b & 10110110b = 10000100b
-11000101b & 10110111b = 10000101b
-11000101b & 10111000b = 10000000b
-11000101b & 10111001b = 10000001b
-11000101b & 10111010b = 10000000b
-11000101b & 10111011b = 10000001b
-11000101b & 10111100b = 10000100b
-11000101b & 10111101b = 10000101b
-11000101b & 10111110b = 10000100b
-11000101b & 10111111b = 10000101b
-11000101b & 11000000b = 11000000b
-11000101b & 11000001b = 11000001b
-11000101b & 11000010b = 11000000b
-11000101b & 11000011b = 11000001b
-11000101b & 11000100b = 11000100b
-11000101b & 11000101b = 11000101b
-11000101b & 11000110b = 11000100b
-11000101b & 11000111b = 11000101b
-11000101b & 11001000b = 11000000b
-11000101b & 11001001b = 11000001b
-11000101b & 11001010b = 11000000b
-11000101b & 11001011b = 11000001b
-11000101b & 11001100b = 11000100b
-11000101b & 11001101b = 11000101b
-11000101b & 11001110b = 11000100b
-11000101b & 11001111b = 11000101b
-11000101b & 11010000b = 11000000b
-11000101b & 11010001b = 11000001b
-11000101b & 11010010b = 11000000b
-11000101b & 11010011b = 11000001b
-11000101b & 11010100b = 11000100b
-11000101b & 11010101b = 11000101b
-11000101b & 11010110b = 11000100b
-11000101b & 11010111b = 11000101b
-11000101b & 11011000b = 11000000b
-11000101b & 11011001b = 11000001b
-11000101b & 11011010b = 11000000b
-11000101b & 11011011b = 11000001b
-11000101b & 11011100b = 11000100b
-11000101b & 11011101b = 11000101b
-11000101b & 11011110b = 11000100b
-11000101b & 11011111b = 11000101b
-11000101b & 11100000b = 11000000b
-11000101b & 11100001b = 11000001b
-11000101b & 11100010b = 11000000b
-11000101b & 11100011b = 11000001b
-11000101b & 11100100b = 11000100b
-11000101b & 11100101b = 11000101b
-11000101b & 11100110b = 11000100b
-11000101b & 11100111b = 11000101b
-11000101b & 11101000b = 11000000b
-11000101b & 11101001b = 11000001b
-11000101b & 11101010b = 11000000b
-11000101b & 11101011b = 11000001b
-11000101b & 11101100b = 11000100b
-11000101b & 11101101b = 11000101b
-11000101b & 11101110b = 11000100b
-11000101b & 11101111b = 11000101b
-11000101b & 11110000b = 11000000b
-11000101b & 11110001b = 11000001b
-11000101b & 11110010b = 11000000b
-11000101b & 11110011b = 11000001b
-11000101b & 11110100b = 11000100b
-11000101b & 11110101b = 11000101b
-11000101b & 11110110b = 11000100b
-11000101b & 11110111b = 11000101b
-11000101b & 11111000b = 11000000b
-11000101b & 11111001b = 11000001b
-11000101b & 11111010b = 11000000b
-11000101b & 11111011b = 11000001b
-11000101b & 11111100b = 11000100b
-11000101b & 11111101b = 11000101b
-11000101b & 11111110b = 11000100b
-11000101b & 11111111b = 11000101b
-11000101b & 00000000b = 00000000b
-11000101b & 00000001b = 00000001b
-11000101b & 00000010b = 00000000b
-11000101b & 00000011b = 00000001b
-11000101b & 00000100b = 00000100b
-11000101b & 00000101b = 00000101b
-11000101b & 00000110b = 00000100b
-11000101b & 00000111b = 00000101b
-11000101b & 00001000b = 00000000b
-11000101b & 00001001b = 00000001b
-11000101b & 00001010b = 00000000b
-11000101b & 00001011b = 00000001b
-11000101b & 00001100b = 00000100b
-11000101b & 00001101b = 00000101b
-11000101b & 00001110b = 00000100b
-11000101b & 00001111b = 00000101b
-11000101b & 00010000b = 00000000b
-11000101b & 00010001b = 00000001b
-11000101b & 00010010b = 00000000b
-11000101b & 00010011b = 00000001b
-11000101b & 00010100b = 00000100b
-11000101b & 00010101b = 00000101b
-11000101b & 00010110b = 00000100b
-11000101b & 00010111b = 00000101b
-11000101b & 00011000b = 00000000b
-11000101b & 00011001b = 00000001b
-11000101b & 00011010b = 00000000b
-11000101b & 00011011b = 00000001b
-11000101b & 00011100b = 00000100b
-11000101b & 00011101b = 00000101b
-11000101b & 00011110b = 00000100b
-11000101b & 00011111b = 00000101b
-11000101b & 00100000b = 00000000b
-11000101b & 00100001b = 00000001b
-11000101b & 00100010b = 00000000b
-11000101b & 00100011b = 00000001b
-11000101b & 00100100b = 00000100b
-11000101b & 00100101b = 00000101b
-11000101b & 00100110b = 00000100b
-11000101b & 00100111b = 00000101b
-11000101b & 00101000b = 00000000b
-11000101b & 00101001b = 00000001b
-11000101b & 00101010b = 00000000b
-11000101b & 00101011b = 00000001b
-11000101b & 00101100b = 00000100b
-11000101b & 00101101b = 00000101b
-11000101b & 00101110b = 00000100b
-11000101b & 00101111b = 00000101b
-11000101b & 00110000b = 00000000b
-11000101b & 00110001b = 00000001b
-11000101b & 00110010b = 00000000b
-11000101b & 00110011b = 00000001b
-11000101b & 00110100b = 00000100b
-11000101b & 00110101b = 00000101b
-11000101b & 00110110b = 00000100b
-11000101b & 00110111b = 00000101b
-11000101b & 00111000b = 00000000b
-11000101b & 00111001b = 00000001b
-11000101b & 00111010b = 00000000b
-11000101b & 00111011b = 00000001b
-11000101b & 00111100b = 00000100b
-11000101b & 00111101b = 00000101b
-11000101b & 00111110b = 00000100b
-11000101b & 00111111b = 00000101b
-11000101b & 01000000b = 01000000b
-11000101b & 01000001b = 01000001b
-11000101b & 01000010b = 01000000b
-11000101b & 01000011b = 01000001b
-11000101b & 01000100b = 01000100b
-11000101b & 01000101b = 01000101b
-11000101b & 01000110b = 01000100b
-11000101b & 01000111b = 01000101b
-11000101b & 01001000b = 01000000b
-11000101b & 01001001b = 01000001b
-11000101b & 01001010b = 01000000b
-11000101b & 01001011b = 01000001b
-11000101b & 01001100b = 01000100b
-11000101b & 01001101b = 01000101b
-11000101b & 01001110b = 01000100b
-11000101b & 01001111b = 01000101b
-11000101b & 01010000b = 01000000b
-11000101b & 01010001b = 01000001b
-11000101b & 01010010b = 01000000b
-11000101b & 01010011b = 01000001b
-11000101b & 01010100b = 01000100b
-11000101b & 01010101b = 01000101b
-11000101b & 01010110b = 01000100b
-11000101b & 01010111b = 01000101b
-11000101b & 01011000b = 01000000b
-11000101b & 01011001b = 01000001b
-11000101b & 01011010b = 01000000b
-11000101b & 01011011b = 01000001b
-11000101b & 01011100b = 01000100b
-11000101b & 01011101b = 01000101b
-11000101b & 01011110b = 01000100b
-11000101b & 01011111b = 01000101b
-11000101b & 01100000b = 01000000b
-11000101b & 01100001b = 01000001b
-11000101b & 01100010b = 01000000b
-11000101b & 01100011b = 01000001b
-11000101b & 01100100b = 01000100b
-11000101b & 01100101b = 01000101b
-11000101b & 01100110b = 01000100b
-11000101b & 01100111b = 01000101b
-11000101b & 01101000b = 01000000b
-11000101b & 01101001b = 01000001b
-11000101b & 01101010b = 01000000b
-11000101b & 01101011b = 01000001b
-11000101b & 01101100b = 01000100b
-11000101b & 01101101b = 01000101b
-11000101b & 01101110b = 01000100b
-11000101b & 01101111b = 01000101b
-11000101b & 01110000b = 01000000b
-11000101b & 01110001b = 01000001b
-11000101b & 01110010b = 01000000b
-11000101b & 01110011b = 01000001b
-11000101b & 01110100b = 01000100b
-11000101b & 01110101b = 01000101b
-11000101b & 01110110b = 01000100b
-11000101b & 01110111b = 01000101b
-11000101b & 01111000b = 01000000b
-11000101b & 01111001b = 01000001b
-11000101b & 01111010b = 01000000b
-11000101b & 01111011b = 01000001b
-11000101b & 01111100b = 01000100b
-11000101b & 01111101b = 01000101b
-11000101b & 01111110b = 01000100b
-11000110b & 10000000b = 10000000b
-11000110b & 10000001b = 10000000b
-11000110b & 10000010b = 10000010b
-11000110b & 10000011b = 10000010b
-11000110b & 10000100b = 10000100b
-11000110b & 10000101b = 10000100b
-11000110b & 10000110b = 10000110b
-11000110b & 10000111b = 10000110b
-11000110b & 10001000b = 10000000b
-11000110b & 10001001b = 10000000b
-11000110b & 10001010b = 10000010b
-11000110b & 10001011b = 10000010b
-11000110b & 10001100b = 10000100b
-11000110b & 10001101b = 10000100b
-11000110b & 10001110b = 10000110b
-11000110b & 10001111b = 10000110b
-11000110b & 10010000b = 10000000b
-11000110b & 10010001b = 10000000b
-11000110b & 10010010b = 10000010b
-11000110b & 10010011b = 10000010b
-11000110b & 10010100b = 10000100b
-11000110b & 10010101b = 10000100b
-11000110b & 10010110b = 10000110b
-11000110b & 10010111b = 10000110b
-11000110b & 10011000b = 10000000b
-11000110b & 10011001b = 10000000b
-11000110b & 10011010b = 10000010b
-11000110b & 10011011b = 10000010b
-11000110b & 10011100b = 10000100b
-11000110b & 10011101b = 10000100b
-11000110b & 10011110b = 10000110b
-11000110b & 10011111b = 10000110b
-11000110b & 10100000b = 10000000b
-11000110b & 10100001b = 10000000b
-11000110b & 10100010b = 10000010b
-11000110b & 10100011b = 10000010b
-11000110b & 10100100b = 10000100b
-11000110b & 10100101b = 10000100b
-11000110b & 10100110b = 10000110b
-11000110b & 10100111b = 10000110b
-11000110b & 10101000b = 10000000b
-11000110b & 10101001b = 10000000b
-11000110b & 10101010b = 10000010b
-11000110b & 10101011b = 10000010b
-11000110b & 10101100b = 10000100b
-11000110b & 10101101b = 10000100b
-11000110b & 10101110b = 10000110b
-11000110b & 10101111b = 10000110b
-11000110b & 10110000b = 10000000b
-11000110b & 10110001b = 10000000b
-11000110b & 10110010b = 10000010b
-11000110b & 10110011b = 10000010b
-11000110b & 10110100b = 10000100b
-11000110b & 10110101b = 10000100b
-11000110b & 10110110b = 10000110b
-11000110b & 10110111b = 10000110b
-11000110b & 10111000b = 10000000b
-11000110b & 10111001b = 10000000b
-11000110b & 10111010b = 10000010b
-11000110b & 10111011b = 10000010b
-11000110b & 10111100b = 10000100b
-11000110b & 10111101b = 10000100b
-11000110b & 10111110b = 10000110b
-11000110b & 10111111b = 10000110b
-11000110b & 11000000b = 11000000b
-11000110b & 11000001b = 11000000b
-11000110b & 11000010b = 11000010b
-11000110b & 11000011b = 11000010b
-11000110b & 11000100b = 11000100b
-11000110b & 11000101b = 11000100b
-11000110b & 11000110b = 11000110b
-11000110b & 11000111b = 11000110b
-11000110b & 11001000b = 11000000b
-11000110b & 11001001b = 11000000b
-11000110b & 11001010b = 11000010b
-11000110b & 11001011b = 11000010b
-11000110b & 11001100b = 11000100b
-11000110b & 11001101b = 11000100b
-11000110b & 11001110b = 11000110b
-11000110b & 11001111b = 11000110b
-11000110b & 11010000b = 11000000b
-11000110b & 11010001b = 11000000b
-11000110b & 11010010b = 11000010b
-11000110b & 11010011b = 11000010b
-11000110b & 11010100b = 11000100b
-11000110b & 11010101b = 11000100b
-11000110b & 11010110b = 11000110b
-11000110b & 11010111b = 11000110b
-11000110b & 11011000b = 11000000b
-11000110b & 11011001b = 11000000b
-11000110b & 11011010b = 11000010b
-11000110b & 11011011b = 11000010b
-11000110b & 11011100b = 11000100b
-11000110b & 11011101b = 11000100b
-11000110b & 11011110b = 11000110b
-11000110b & 11011111b = 11000110b
-11000110b & 11100000b = 11000000b
-11000110b & 11100001b = 11000000b
-11000110b & 11100010b = 11000010b
-11000110b & 11100011b = 11000010b
-11000110b & 11100100b = 11000100b
-11000110b & 11100101b = 11000100b
-11000110b & 11100110b = 11000110b
-11000110b & 11100111b = 11000110b
-11000110b & 11101000b = 11000000b
-11000110b & 11101001b = 11000000b
-11000110b & 11101010b = 11000010b
-11000110b & 11101011b = 11000010b
-11000110b & 11101100b = 11000100b
-11000110b & 11101101b = 11000100b
-11000110b & 11101110b = 11000110b
-11000110b & 11101111b = 11000110b
-11000110b & 11110000b = 11000000b
-11000110b & 11110001b = 11000000b
-11000110b & 11110010b = 11000010b
-11000110b & 11110011b = 11000010b
-11000110b & 11110100b = 11000100b
-11000110b & 11110101b = 11000100b
-11000110b & 11110110b = 11000110b
-11000110b & 11110111b = 11000110b
-11000110b & 11111000b = 11000000b
-11000110b & 11111001b = 11000000b
-11000110b & 11111010b = 11000010b
-11000110b & 11111011b = 11000010b
-11000110b & 11111100b = 11000100b
-11000110b & 11111101b = 11000100b
-11000110b & 11111110b = 11000110b
-11000110b & 11111111b = 11000110b
-11000110b & 00000000b = 00000000b
-11000110b & 00000001b = 00000000b
-11000110b & 00000010b = 00000010b
-11000110b & 00000011b = 00000010b
-11000110b & 00000100b = 00000100b
-11000110b & 00000101b = 00000100b
-11000110b & 00000110b = 00000110b
-11000110b & 00000111b = 00000110b
-11000110b & 00001000b = 00000000b
-11000110b & 00001001b = 00000000b
-11000110b & 00001010b = 00000010b
-11000110b & 00001011b = 00000010b
-11000110b & 00001100b = 00000100b
-11000110b & 00001101b = 00000100b
-11000110b & 00001110b = 00000110b
-11000110b & 00001111b = 00000110b
-11000110b & 00010000b = 00000000b
-11000110b & 00010001b = 00000000b
-11000110b & 00010010b = 00000010b
-11000110b & 00010011b = 00000010b
-11000110b & 00010100b = 00000100b
-11000110b & 00010101b = 00000100b
-11000110b & 00010110b = 00000110b
-11000110b & 00010111b = 00000110b
-11000110b & 00011000b = 00000000b
-11000110b & 00011001b = 00000000b
-11000110b & 00011010b = 00000010b
-11000110b & 00011011b = 00000010b
-11000110b & 00011100b = 00000100b
-11000110b & 00011101b = 00000100b
-11000110b & 00011110b = 00000110b
-11000110b & 00011111b = 00000110b
-11000110b & 00100000b = 00000000b
-11000110b & 00100001b = 00000000b
-11000110b & 00100010b = 00000010b
-11000110b & 00100011b = 00000010b
-11000110b & 00100100b = 00000100b
-11000110b & 00100101b = 00000100b
-11000110b & 00100110b = 00000110b
-11000110b & 00100111b = 00000110b
-11000110b & 00101000b = 00000000b
-11000110b & 00101001b = 00000000b
-11000110b & 00101010b = 00000010b
-11000110b & 00101011b = 00000010b
-11000110b & 00101100b = 00000100b
-11000110b & 00101101b = 00000100b
-11000110b & 00101110b = 00000110b
-11000110b & 00101111b = 00000110b
-11000110b & 00110000b = 00000000b
-11000110b & 00110001b = 00000000b
-11000110b & 00110010b = 00000010b
-11000110b & 00110011b = 00000010b
-11000110b & 00110100b = 00000100b
-11000110b & 00110101b = 00000100b
-11000110b & 00110110b = 00000110b
-11000110b & 00110111b = 00000110b
-11000110b & 00111000b = 00000000b
-11000110b & 00111001b = 00000000b
-11000110b & 00111010b = 00000010b
-11000110b & 00111011b = 00000010b
-11000110b & 00111100b = 00000100b
-11000110b & 00111101b = 00000100b
-11000110b & 00111110b = 00000110b
-11000110b & 00111111b = 00000110b
-11000110b & 01000000b = 01000000b
-11000110b & 01000001b = 01000000b
-11000110b & 01000010b = 01000010b
-11000110b & 01000011b = 01000010b
-11000110b & 01000100b = 01000100b
-11000110b & 01000101b = 01000100b
-11000110b & 01000110b = 01000110b
-11000110b & 01000111b = 01000110b
-11000110b & 01001000b = 01000000b
-11000110b & 01001001b = 01000000b
-11000110b & 01001010b = 01000010b
-11000110b & 01001011b = 01000010b
-11000110b & 01001100b = 01000100b
-11000110b & 01001101b = 01000100b
-11000110b & 01001110b = 01000110b
-11000110b & 01001111b = 01000110b
-11000110b & 01010000b = 01000000b
-11000110b & 01010001b = 01000000b
-11000110b & 01010010b = 01000010b
-11000110b & 01010011b = 01000010b
-11000110b & 01010100b = 01000100b
-11000110b & 01010101b = 01000100b
-11000110b & 01010110b = 01000110b
-11000110b & 01010111b = 01000110b
-11000110b & 01011000b = 01000000b
-11000110b & 01011001b = 01000000b
-11000110b & 01011010b = 01000010b
-11000110b & 01011011b = 01000010b
-11000110b & 01011100b = 01000100b
-11000110b & 01011101b = 01000100b
-11000110b & 01011110b = 01000110b
-11000110b & 01011111b = 01000110b
-11000110b & 01100000b = 01000000b
-11000110b & 01100001b = 01000000b
-11000110b & 01100010b = 01000010b
-11000110b & 01100011b = 01000010b
-11000110b & 01100100b = 01000100b
-11000110b & 01100101b = 01000100b
-11000110b & 01100110b = 01000110b
-11000110b & 01100111b = 01000110b
-11000110b & 01101000b = 01000000b
-11000110b & 01101001b = 01000000b
-11000110b & 01101010b = 01000010b
-11000110b & 01101011b = 01000010b
-11000110b & 01101100b = 01000100b
-11000110b & 01101101b = 01000100b
-11000110b & 01101110b = 01000110b
-11000110b & 01101111b = 01000110b
-11000110b & 01110000b = 01000000b
-11000110b & 01110001b = 01000000b
-11000110b & 01110010b = 01000010b
-11000110b & 01110011b = 01000010b
-11000110b & 01110100b = 01000100b
-11000110b & 01110101b = 01000100b
-11000110b & 01110110b = 01000110b
-11000110b & 01110111b = 01000110b
-11000110b & 01111000b = 01000000b
-11000110b & 01111001b = 01000000b
-11000110b & 01111010b = 01000010b
-11000110b & 01111011b = 01000010b
-11000110b & 01111100b = 01000100b
-11000110b & 01111101b = 01000100b
-11000110b & 01111110b = 01000110b
-11000111b & 10000000b = 10000000b
-11000111b & 10000001b = 10000001b
-11000111b & 10000010b = 10000010b
-11000111b & 10000011b = 10000011b
-11000111b & 10000100b = 10000100b
-11000111b & 10000101b = 10000101b
-11000111b & 10000110b = 10000110b
-11000111b & 10000111b = 10000111b
-11000111b & 10001000b = 10000000b
-11000111b & 10001001b = 10000001b
-11000111b & 10001010b = 10000010b
-11000111b & 10001011b = 10000011b
-11000111b & 10001100b = 10000100b
-11000111b & 10001101b = 10000101b
-11000111b & 10001110b = 10000110b
-11000111b & 10001111b = 10000111b
-11000111b & 10010000b = 10000000b
-11000111b & 10010001b = 10000001b
-11000111b & 10010010b = 10000010b
-11000111b & 10010011b = 10000011b
-11000111b & 10010100b = 10000100b
-11000111b & 10010101b = 10000101b
-11000111b & 10010110b = 10000110b
-11000111b & 10010111b = 10000111b
-11000111b & 10011000b = 10000000b
-11000111b & 10011001b = 10000001b
-11000111b & 10011010b = 10000010b
-11000111b & 10011011b = 10000011b
-11000111b & 10011100b = 10000100b
-11000111b & 10011101b = 10000101b
-11000111b & 10011110b = 10000110b
-11000111b & 10011111b = 10000111b
-11000111b & 10100000b = 10000000b
-11000111b & 10100001b = 10000001b
-11000111b & 10100010b = 10000010b
-11000111b & 10100011b = 10000011b
-11000111b & 10100100b = 10000100b
-11000111b & 10100101b = 10000101b
-11000111b & 10100110b = 10000110b
-11000111b & 10100111b = 10000111b
-11000111b & 10101000b = 10000000b
-11000111b & 10101001b = 10000001b
-11000111b & 10101010b = 10000010b
-11000111b & 10101011b = 10000011b
-11000111b & 10101100b = 10000100b
-11000111b & 10101101b = 10000101b
-11000111b & 10101110b = 10000110b
-11000111b & 10101111b = 10000111b
-11000111b & 10110000b = 10000000b
-11000111b & 10110001b = 10000001b
-11000111b & 10110010b = 10000010b
-11000111b & 10110011b = 10000011b
-11000111b & 10110100b = 10000100b
-11000111b & 10110101b = 10000101b
-11000111b & 10110110b = 10000110b
-11000111b & 10110111b = 10000111b
-11000111b & 10111000b = 10000000b
-11000111b & 10111001b = 10000001b
-11000111b & 10111010b = 10000010b
-11000111b & 10111011b = 10000011b
-11000111b & 10111100b = 10000100b
-11000111b & 10111101b = 10000101b
-11000111b & 10111110b = 10000110b
-11000111b & 10111111b = 10000111b
-11000111b & 11000000b = 11000000b
-11000111b & 11000001b = 11000001b
-11000111b & 11000010b = 11000010b
-11000111b & 11000011b = 11000011b
-11000111b & 11000100b = 11000100b
-11000111b & 11000101b = 11000101b
-11000111b & 11000110b = 11000110b
-11000111b & 11000111b = 11000111b
-11000111b & 11001000b = 11000000b
-11000111b & 11001001b = 11000001b
-11000111b & 11001010b = 11000010b
-11000111b & 11001011b = 11000011b
-11000111b & 11001100b = 11000100b
-11000111b & 11001101b = 11000101b
-11000111b & 11001110b = 11000110b
-11000111b & 11001111b = 11000111b
-11000111b & 11010000b = 11000000b
-11000111b & 11010001b = 11000001b
-11000111b & 11010010b = 11000010b
-11000111b & 11010011b = 11000011b
-11000111b & 11010100b = 11000100b
-11000111b & 11010101b = 11000101b
-11000111b & 11010110b = 11000110b
-11000111b & 11010111b = 11000111b
-11000111b & 11011000b = 11000000b
-11000111b & 11011001b = 11000001b
-11000111b & 11011010b = 11000010b
-11000111b & 11011011b = 11000011b
-11000111b & 11011100b = 11000100b
-11000111b & 11011101b = 11000101b
-11000111b & 11011110b = 11000110b
-11000111b & 11011111b = 11000111b
-11000111b & 11100000b = 11000000b
-11000111b & 11100001b = 11000001b
-11000111b & 11100010b = 11000010b
-11000111b & 11100011b = 11000011b
-11000111b & 11100100b = 11000100b
-11000111b & 11100101b = 11000101b
-11000111b & 11100110b = 11000110b
-11000111b & 11100111b = 11000111b
-11000111b & 11101000b = 11000000b
-11000111b & 11101001b = 11000001b
-11000111b & 11101010b = 11000010b
-11000111b & 11101011b = 11000011b
-11000111b & 11101100b = 11000100b
-11000111b & 11101101b = 11000101b
-11000111b & 11101110b = 11000110b
-11000111b & 11101111b = 11000111b
-11000111b & 11110000b = 11000000b
-11000111b & 11110001b = 11000001b
-11000111b & 11110010b = 11000010b
-11000111b & 11110011b = 11000011b
-11000111b & 11110100b = 11000100b
-11000111b & 11110101b = 11000101b
-11000111b & 11110110b = 11000110b
-11000111b & 11110111b = 11000111b
-11000111b & 11111000b = 11000000b
-11000111b & 11111001b = 11000001b
-11000111b & 11111010b = 11000010b
-11000111b & 11111011b = 11000011b
-11000111b & 11111100b = 11000100b
-11000111b & 11111101b = 11000101b
-11000111b & 11111110b = 11000110b
-11000111b & 11111111b = 11000111b
-11000111b & 00000000b = 00000000b
-11000111b & 00000001b = 00000001b
-11000111b & 00000010b = 00000010b
-11000111b & 00000011b = 00000011b
-11000111b & 00000100b = 00000100b
-11000111b & 00000101b = 00000101b
-11000111b & 00000110b = 00000110b
-11000111b & 00000111b = 00000111b
-11000111b & 00001000b = 00000000b
-11000111b & 00001001b = 00000001b
-11000111b & 00001010b = 00000010b
-11000111b & 00001011b = 00000011b
-11000111b & 00001100b = 00000100b
-11000111b & 00001101b = 00000101b
-11000111b & 00001110b = 00000110b
-11000111b & 00001111b = 00000111b
-11000111b & 00010000b = 00000000b
-11000111b & 00010001b = 00000001b
-11000111b & 00010010b = 00000010b
-11000111b & 00010011b = 00000011b
-11000111b & 00010100b = 00000100b
-11000111b & 00010101b = 00000101b
-11000111b & 00010110b = 00000110b
-11000111b & 00010111b = 00000111b
-11000111b & 00011000b = 00000000b
-11000111b & 00011001b = 00000001b
-11000111b & 00011010b = 00000010b
-11000111b & 00011011b = 00000011b
-11000111b & 00011100b = 00000100b
-11000111b & 00011101b = 00000101b
-11000111b & 00011110b = 00000110b
-11000111b & 00011111b = 00000111b
-11000111b & 00100000b = 00000000b
-11000111b & 00100001b = 00000001b
-11000111b & 00100010b = 00000010b
-11000111b & 00100011b = 00000011b
-11000111b & 00100100b = 00000100b
-11000111b & 00100101b = 00000101b
-11000111b & 00100110b = 00000110b
-11000111b & 00100111b = 00000111b
-11000111b & 00101000b = 00000000b
-11000111b & 00101001b = 00000001b
-11000111b & 00101010b = 00000010b
-11000111b & 00101011b = 00000011b
-11000111b & 00101100b = 00000100b
-11000111b & 00101101b = 00000101b
-11000111b & 00101110b = 00000110b
-11000111b & 00101111b = 00000111b
-11000111b & 00110000b = 00000000b
-11000111b & 00110001b = 00000001b
-11000111b & 00110010b = 00000010b
-11000111b & 00110011b = 00000011b
-11000111b & 00110100b = 00000100b
-11000111b & 00110101b = 00000101b
-11000111b & 00110110b = 00000110b
-11000111b & 00110111b = 00000111b
-11000111b & 00111000b = 00000000b
-11000111b & 00111001b = 00000001b
-11000111b & 00111010b = 00000010b
-11000111b & 00111011b = 00000011b
-11000111b & 00111100b = 00000100b
-11000111b & 00111101b = 00000101b
-11000111b & 00111110b = 00000110b
-11000111b & 00111111b = 00000111b
-11000111b & 01000000b = 01000000b
-11000111b & 01000001b = 01000001b
-11000111b & 01000010b = 01000010b
-11000111b & 01000011b = 01000011b
-11000111b & 01000100b = 01000100b
-11000111b & 01000101b = 01000101b
-11000111b & 01000110b = 01000110b
-11000111b & 01000111b = 01000111b
-11000111b & 01001000b = 01000000b
-11000111b & 01001001b = 01000001b
-11000111b & 01001010b = 01000010b
-11000111b & 01001011b = 01000011b
-11000111b & 01001100b = 01000100b
-11000111b & 01001101b = 01000101b
-11000111b & 01001110b = 01000110b
-11000111b & 01001111b = 01000111b
-11000111b & 01010000b = 01000000b
-11000111b & 01010001b = 01000001b
-11000111b & 01010010b = 01000010b
-11000111b & 01010011b = 01000011b
-11000111b & 01010100b = 01000100b
-11000111b & 01010101b = 01000101b
-11000111b & 01010110b = 01000110b
-11000111b & 01010111b = 01000111b
-11000111b & 01011000b = 01000000b
-11000111b & 01011001b = 01000001b
-11000111b & 01011010b = 01000010b
-11000111b & 01011011b = 01000011b
-11000111b & 01011100b = 01000100b
-11000111b & 01011101b = 01000101b
-11000111b & 01011110b = 01000110b
-11000111b & 01011111b = 01000111b
-11000111b & 01100000b = 01000000b
-11000111b & 01100001b = 01000001b
-11000111b & 01100010b = 01000010b
-11000111b & 01100011b = 01000011b
-11000111b & 01100100b = 01000100b
-11000111b & 01100101b = 01000101b
-11000111b & 01100110b = 01000110b
-11000111b & 01100111b = 01000111b
-11000111b & 01101000b = 01000000b
-11000111b & 01101001b = 01000001b
-11000111b & 01101010b = 01000010b
-11000111b & 01101011b = 01000011b
-11000111b & 01101100b = 01000100b
-11000111b & 01101101b = 01000101b
-11000111b & 01101110b = 01000110b
-11000111b & 01101111b = 01000111b
-11000111b & 01110000b = 01000000b
-11000111b & 01110001b = 01000001b
-11000111b & 01110010b = 01000010b
-11000111b & 01110011b = 01000011b
-11000111b & 01110100b = 01000100b
-11000111b & 01110101b = 01000101b
-11000111b & 01110110b = 01000110b
-11000111b & 01110111b = 01000111b
-11000111b & 01111000b = 01000000b
-11000111b & 01111001b = 01000001b
-11000111b & 01111010b = 01000010b
-11000111b & 01111011b = 01000011b
-11000111b & 01111100b = 01000100b
-11000111b & 01111101b = 01000101b
-11000111b & 01111110b = 01000110b
-11001000b & 10000000b = 10000000b
-11001000b & 10000001b = 10000000b
-11001000b & 10000010b = 10000000b
-11001000b & 10000011b = 10000000b
-11001000b & 10000100b = 10000000b
-11001000b & 10000101b = 10000000b
-11001000b & 10000110b = 10000000b
-11001000b & 10000111b = 10000000b
-11001000b & 10001000b = 10001000b
-11001000b & 10001001b = 10001000b
-11001000b & 10001010b = 10001000b
-11001000b & 10001011b = 10001000b
-11001000b & 10001100b = 10001000b
-11001000b & 10001101b = 10001000b
-11001000b & 10001110b = 10001000b
-11001000b & 10001111b = 10001000b
-11001000b & 10010000b = 10000000b
-11001000b & 10010001b = 10000000b
-11001000b & 10010010b = 10000000b
-11001000b & 10010011b = 10000000b
-11001000b & 10010100b = 10000000b
-11001000b & 10010101b = 10000000b
-11001000b & 10010110b = 10000000b
-11001000b & 10010111b = 10000000b
-11001000b & 10011000b = 10001000b
-11001000b & 10011001b = 10001000b
-11001000b & 10011010b = 10001000b
-11001000b & 10011011b = 10001000b
-11001000b & 10011100b = 10001000b
-11001000b & 10011101b = 10001000b
-11001000b & 10011110b = 10001000b
-11001000b & 10011111b = 10001000b
-11001000b & 10100000b = 10000000b
-11001000b & 10100001b = 10000000b
-11001000b & 10100010b = 10000000b
-11001000b & 10100011b = 10000000b
-11001000b & 10100100b = 10000000b
-11001000b & 10100101b = 10000000b
-11001000b & 10100110b = 10000000b
-11001000b & 10100111b = 10000000b
-11001000b & 10101000b = 10001000b
-11001000b & 10101001b = 10001000b
-11001000b & 10101010b = 10001000b
-11001000b & 10101011b = 10001000b
-11001000b & 10101100b = 10001000b
-11001000b & 10101101b = 10001000b
-11001000b & 10101110b = 10001000b
-11001000b & 10101111b = 10001000b
-11001000b & 10110000b = 10000000b
-11001000b & 10110001b = 10000000b
-11001000b & 10110010b = 10000000b
-11001000b & 10110011b = 10000000b
-11001000b & 10110100b = 10000000b
-11001000b & 10110101b = 10000000b
-11001000b & 10110110b = 10000000b
-11001000b & 10110111b = 10000000b
-11001000b & 10111000b = 10001000b
-11001000b & 10111001b = 10001000b
-11001000b & 10111010b = 10001000b
-11001000b & 10111011b = 10001000b
-11001000b & 10111100b = 10001000b
-11001000b & 10111101b = 10001000b
-11001000b & 10111110b = 10001000b
-11001000b & 10111111b = 10001000b
-11001000b & 11000000b = 11000000b
-11001000b & 11000001b = 11000000b
-11001000b & 11000010b = 11000000b
-11001000b & 11000011b = 11000000b
-11001000b & 11000100b = 11000000b
-11001000b & 11000101b = 11000000b
-11001000b & 11000110b = 11000000b
-11001000b & 11000111b = 11000000b
-11001000b & 11001000b = 11001000b
-11001000b & 11001001b = 11001000b
-11001000b & 11001010b = 11001000b
-11001000b & 11001011b = 11001000b
-11001000b & 11001100b = 11001000b
-11001000b & 11001101b = 11001000b
-11001000b & 11001110b = 11001000b
-11001000b & 11001111b = 11001000b
-11001000b & 11010000b = 11000000b
-11001000b & 11010001b = 11000000b
-11001000b & 11010010b = 11000000b
-11001000b & 11010011b = 11000000b
-11001000b & 11010100b = 11000000b
-11001000b & 11010101b = 11000000b
-11001000b & 11010110b = 11000000b
-11001000b & 11010111b = 11000000b
-11001000b & 11011000b = 11001000b
-11001000b & 11011001b = 11001000b
-11001000b & 11011010b = 11001000b
-11001000b & 11011011b = 11001000b
-11001000b & 11011100b = 11001000b
-11001000b & 11011101b = 11001000b
-11001000b & 11011110b = 11001000b
-11001000b & 11011111b = 11001000b
-11001000b & 11100000b = 11000000b
-11001000b & 11100001b = 11000000b
-11001000b & 11100010b = 11000000b
-11001000b & 11100011b = 11000000b
-11001000b & 11100100b = 11000000b
-11001000b & 11100101b = 11000000b
-11001000b & 11100110b = 11000000b
-11001000b & 11100111b = 11000000b
-11001000b & 11101000b = 11001000b
-11001000b & 11101001b = 11001000b
-11001000b & 11101010b = 11001000b
-11001000b & 11101011b = 11001000b
-11001000b & 11101100b = 11001000b
-11001000b & 11101101b = 11001000b
-11001000b & 11101110b = 11001000b
-11001000b & 11101111b = 11001000b
-11001000b & 11110000b = 11000000b
-11001000b & 11110001b = 11000000b
-11001000b & 11110010b = 11000000b
-11001000b & 11110011b = 11000000b
-11001000b & 11110100b = 11000000b
-11001000b & 11110101b = 11000000b
-11001000b & 11110110b = 11000000b
-11001000b & 11110111b = 11000000b
-11001000b & 11111000b = 11001000b
-11001000b & 11111001b = 11001000b
-11001000b & 11111010b = 11001000b
-11001000b & 11111011b = 11001000b
-11001000b & 11111100b = 11001000b
-11001000b & 11111101b = 11001000b
-11001000b & 11111110b = 11001000b
-11001000b & 11111111b = 11001000b
-11001000b & 00000000b = 00000000b
-11001000b & 00000001b = 00000000b
-11001000b & 00000010b = 00000000b
-11001000b & 00000011b = 00000000b
-11001000b & 00000100b = 00000000b
-11001000b & 00000101b = 00000000b
-11001000b & 00000110b = 00000000b
-11001000b & 00000111b = 00000000b
-11001000b & 00001000b = 00001000b
-11001000b & 00001001b = 00001000b
-11001000b & 00001010b = 00001000b
-11001000b & 00001011b = 00001000b
-11001000b & 00001100b = 00001000b
-11001000b & 00001101b = 00001000b
-11001000b & 00001110b = 00001000b
-11001000b & 00001111b = 00001000b
-11001000b & 00010000b = 00000000b
-11001000b & 00010001b = 00000000b
-11001000b & 00010010b = 00000000b
-11001000b & 00010011b = 00000000b
-11001000b & 00010100b = 00000000b
-11001000b & 00010101b = 00000000b
-11001000b & 00010110b = 00000000b
-11001000b & 00010111b = 00000000b
-11001000b & 00011000b = 00001000b
-11001000b & 00011001b = 00001000b
-11001000b & 00011010b = 00001000b
-11001000b & 00011011b = 00001000b
-11001000b & 00011100b = 00001000b
-11001000b & 00011101b = 00001000b
-11001000b & 00011110b = 00001000b
-11001000b & 00011111b = 00001000b
-11001000b & 00100000b = 00000000b
-11001000b & 00100001b = 00000000b
-11001000b & 00100010b = 00000000b
-11001000b & 00100011b = 00000000b
-11001000b & 00100100b = 00000000b
-11001000b & 00100101b = 00000000b
-11001000b & 00100110b = 00000000b
-11001000b & 00100111b = 00000000b
-11001000b & 00101000b = 00001000b
-11001000b & 00101001b = 00001000b
-11001000b & 00101010b = 00001000b
-11001000b & 00101011b = 00001000b
-11001000b & 00101100b = 00001000b
-11001000b & 00101101b = 00001000b
-11001000b & 00101110b = 00001000b
-11001000b & 00101111b = 00001000b
-11001000b & 00110000b = 00000000b
-11001000b & 00110001b = 00000000b
-11001000b & 00110010b = 00000000b
-11001000b & 00110011b = 00000000b
-11001000b & 00110100b = 00000000b
-11001000b & 00110101b = 00000000b
-11001000b & 00110110b = 00000000b
-11001000b & 00110111b = 00000000b
-11001000b & 00111000b = 00001000b
-11001000b & 00111001b = 00001000b
-11001000b & 00111010b = 00001000b
-11001000b & 00111011b = 00001000b
-11001000b & 00111100b = 00001000b
-11001000b & 00111101b = 00001000b
-11001000b & 00111110b = 00001000b
-11001000b & 00111111b = 00001000b
-11001000b & 01000000b = 01000000b
-11001000b & 01000001b = 01000000b
-11001000b & 01000010b = 01000000b
-11001000b & 01000011b = 01000000b
-11001000b & 01000100b = 01000000b
-11001000b & 01000101b = 01000000b
-11001000b & 01000110b = 01000000b
-11001000b & 01000111b = 01000000b
-11001000b & 01001000b = 01001000b
-11001000b & 01001001b = 01001000b
-11001000b & 01001010b = 01001000b
-11001000b & 01001011b = 01001000b
-11001000b & 01001100b = 01001000b
-11001000b & 01001101b = 01001000b
-11001000b & 01001110b = 01001000b
-11001000b & 01001111b = 01001000b
-11001000b & 01010000b = 01000000b
-11001000b & 01010001b = 01000000b
-11001000b & 01010010b = 01000000b
-11001000b & 01010011b = 01000000b
-11001000b & 01010100b = 01000000b
-11001000b & 01010101b = 01000000b
-11001000b & 01010110b = 01000000b
-11001000b & 01010111b = 01000000b
-11001000b & 01011000b = 01001000b
-11001000b & 01011001b = 01001000b
-11001000b & 01011010b = 01001000b
-11001000b & 01011011b = 01001000b
-11001000b & 01011100b = 01001000b
-11001000b & 01011101b = 01001000b
-11001000b & 01011110b = 01001000b
-11001000b & 01011111b = 01001000b
-11001000b & 01100000b = 01000000b
-11001000b & 01100001b = 01000000b
-11001000b & 01100010b = 01000000b
-11001000b & 01100011b = 01000000b
-11001000b & 01100100b = 01000000b
-11001000b & 01100101b = 01000000b
-11001000b & 01100110b = 01000000b
-11001000b & 01100111b = 01000000b
-11001000b & 01101000b = 01001000b
-11001000b & 01101001b = 01001000b
-11001000b & 01101010b = 01001000b
-11001000b & 01101011b = 01001000b
-11001000b & 01101100b = 01001000b
-11001000b & 01101101b = 01001000b
-11001000b & 01101110b = 01001000b
-11001000b & 01101111b = 01001000b
-11001000b & 01110000b = 01000000b
-11001000b & 01110001b = 01000000b
-11001000b & 01110010b = 01000000b
-11001000b & 01110011b = 01000000b
-11001000b & 01110100b = 01000000b
-11001000b & 01110101b = 01000000b
-11001000b & 01110110b = 01000000b
-11001000b & 01110111b = 01000000b
-11001000b & 01111000b = 01001000b
-11001000b & 01111001b = 01001000b
-11001000b & 01111010b = 01001000b
-11001000b & 01111011b = 01001000b
-11001000b & 01111100b = 01001000b
-11001000b & 01111101b = 01001000b
-11001000b & 01111110b = 01001000b
-11001001b & 10000000b = 10000000b
-11001001b & 10000001b = 10000001b
-11001001b & 10000010b = 10000000b
-11001001b & 10000011b = 10000001b
-11001001b & 10000100b = 10000000b
-11001001b & 10000101b = 10000001b
-11001001b & 10000110b = 10000000b
-11001001b & 10000111b = 10000001b
-11001001b & 10001000b = 10001000b
-11001001b & 10001001b = 10001001b
-11001001b & 10001010b = 10001000b
-11001001b & 10001011b = 10001001b
-11001001b & 10001100b = 10001000b
-11001001b & 10001101b = 10001001b
-11001001b & 10001110b = 10001000b
-11001001b & 10001111b = 10001001b
-11001001b & 10010000b = 10000000b
-11001001b & 10010001b = 10000001b
-11001001b & 10010010b = 10000000b
-11001001b & 10010011b = 10000001b
-11001001b & 10010100b = 10000000b
-11001001b & 10010101b = 10000001b
-11001001b & 10010110b = 10000000b
-11001001b & 10010111b = 10000001b
-11001001b & 10011000b = 10001000b
-11001001b & 10011001b = 10001001b
-11001001b & 10011010b = 10001000b
-11001001b & 10011011b = 10001001b
-11001001b & 10011100b = 10001000b
-11001001b & 10011101b = 10001001b
-11001001b & 10011110b = 10001000b
-11001001b & 10011111b = 10001001b
-11001001b & 10100000b = 10000000b
-11001001b & 10100001b = 10000001b
-11001001b & 10100010b = 10000000b
-11001001b & 10100011b = 10000001b
-11001001b & 10100100b = 10000000b
-11001001b & 10100101b = 10000001b
-11001001b & 10100110b = 10000000b
-11001001b & 10100111b = 10000001b
-11001001b & 10101000b = 10001000b
-11001001b & 10101001b = 10001001b
-11001001b & 10101010b = 10001000b
-11001001b & 10101011b = 10001001b
-11001001b & 10101100b = 10001000b
-11001001b & 10101101b = 10001001b
-11001001b & 10101110b = 10001000b
-11001001b & 10101111b = 10001001b
-11001001b & 10110000b = 10000000b
-11001001b & 10110001b = 10000001b
-11001001b & 10110010b = 10000000b
-11001001b & 10110011b = 10000001b
-11001001b & 10110100b = 10000000b
-11001001b & 10110101b = 10000001b
-11001001b & 10110110b = 10000000b
-11001001b & 10110111b = 10000001b
-11001001b & 10111000b = 10001000b
-11001001b & 10111001b = 10001001b
-11001001b & 10111010b = 10001000b
-11001001b & 10111011b = 10001001b
-11001001b & 10111100b = 10001000b
-11001001b & 10111101b = 10001001b
-11001001b & 10111110b = 10001000b
-11001001b & 10111111b = 10001001b
-11001001b & 11000000b = 11000000b
-11001001b & 11000001b = 11000001b
-11001001b & 11000010b = 11000000b
-11001001b & 11000011b = 11000001b
-11001001b & 11000100b = 11000000b
-11001001b & 11000101b = 11000001b
-11001001b & 11000110b = 11000000b
-11001001b & 11000111b = 11000001b
-11001001b & 11001000b = 11001000b
-11001001b & 11001001b = 11001001b
-11001001b & 11001010b = 11001000b
-11001001b & 11001011b = 11001001b
-11001001b & 11001100b = 11001000b
-11001001b & 11001101b = 11001001b
-11001001b & 11001110b = 11001000b
-11001001b & 11001111b = 11001001b
-11001001b & 11010000b = 11000000b
-11001001b & 11010001b = 11000001b
-11001001b & 11010010b = 11000000b
-11001001b & 11010011b = 11000001b
-11001001b & 11010100b = 11000000b
-11001001b & 11010101b = 11000001b
-11001001b & 11010110b = 11000000b
-11001001b & 11010111b = 11000001b
-11001001b & 11011000b = 11001000b
-11001001b & 11011001b = 11001001b
-11001001b & 11011010b = 11001000b
-11001001b & 11011011b = 11001001b
-11001001b & 11011100b = 11001000b
-11001001b & 11011101b = 11001001b
-11001001b & 11011110b = 11001000b
-11001001b & 11011111b = 11001001b
-11001001b & 11100000b = 11000000b
-11001001b & 11100001b = 11000001b
-11001001b & 11100010b = 11000000b
-11001001b & 11100011b = 11000001b
-11001001b & 11100100b = 11000000b
-11001001b & 11100101b = 11000001b
-11001001b & 11100110b = 11000000b
-11001001b & 11100111b = 11000001b
-11001001b & 11101000b = 11001000b
-11001001b & 11101001b = 11001001b
-11001001b & 11101010b = 11001000b
-11001001b & 11101011b = 11001001b
-11001001b & 11101100b = 11001000b
-11001001b & 11101101b = 11001001b
-11001001b & 11101110b = 11001000b
-11001001b & 11101111b = 11001001b
-11001001b & 11110000b = 11000000b
-11001001b & 11110001b = 11000001b
-11001001b & 11110010b = 11000000b
-11001001b & 11110011b = 11000001b
-11001001b & 11110100b = 11000000b
-11001001b & 11110101b = 11000001b
-11001001b & 11110110b = 11000000b
-11001001b & 11110111b = 11000001b
-11001001b & 11111000b = 11001000b
-11001001b & 11111001b = 11001001b
-11001001b & 11111010b = 11001000b
-11001001b & 11111011b = 11001001b
-11001001b & 11111100b = 11001000b
-11001001b & 11111101b = 11001001b
-11001001b & 11111110b = 11001000b
-11001001b & 11111111b = 11001001b
-11001001b & 00000000b = 00000000b
-11001001b & 00000001b = 00000001b
-11001001b & 00000010b = 00000000b
-11001001b & 00000011b = 00000001b
-11001001b & 00000100b = 00000000b
-11001001b & 00000101b = 00000001b
-11001001b & 00000110b = 00000000b
-11001001b & 00000111b = 00000001b
-11001001b & 00001000b = 00001000b
-11001001b & 00001001b = 00001001b
-11001001b & 00001010b = 00001000b
-11001001b & 00001011b = 00001001b
-11001001b & 00001100b = 00001000b
-11001001b & 00001101b = 00001001b
-11001001b & 00001110b = 00001000b
-11001001b & 00001111b = 00001001b
-11001001b & 00010000b = 00000000b
-11001001b & 00010001b = 00000001b
-11001001b & 00010010b = 00000000b
-11001001b & 00010011b = 00000001b
-11001001b & 00010100b = 00000000b
-11001001b & 00010101b = 00000001b
-11001001b & 00010110b = 00000000b
-11001001b & 00010111b = 00000001b
-11001001b & 00011000b = 00001000b
-11001001b & 00011001b = 00001001b
-11001001b & 00011010b = 00001000b
-11001001b & 00011011b = 00001001b
-11001001b & 00011100b = 00001000b
-11001001b & 00011101b = 00001001b
-11001001b & 00011110b = 00001000b
-11001001b & 00011111b = 00001001b
-11001001b & 00100000b = 00000000b
-11001001b & 00100001b = 00000001b
-11001001b & 00100010b = 00000000b
-11001001b & 00100011b = 00000001b
-11001001b & 00100100b = 00000000b
-11001001b & 00100101b = 00000001b
-11001001b & 00100110b = 00000000b
-11001001b & 00100111b = 00000001b
-11001001b & 00101000b = 00001000b
-11001001b & 00101001b = 00001001b
-11001001b & 00101010b = 00001000b
-11001001b & 00101011b = 00001001b
-11001001b & 00101100b = 00001000b
-11001001b & 00101101b = 00001001b
-11001001b & 00101110b = 00001000b
-11001001b & 00101111b = 00001001b
-11001001b & 00110000b = 00000000b
-11001001b & 00110001b = 00000001b
-11001001b & 00110010b = 00000000b
-11001001b & 00110011b = 00000001b
-11001001b & 00110100b = 00000000b
-11001001b & 00110101b = 00000001b
-11001001b & 00110110b = 00000000b
-11001001b & 00110111b = 00000001b
-11001001b & 00111000b = 00001000b
-11001001b & 00111001b = 00001001b
-11001001b & 00111010b = 00001000b
-11001001b & 00111011b = 00001001b
-11001001b & 00111100b = 00001000b
-11001001b & 00111101b = 00001001b
-11001001b & 00111110b = 00001000b
-11001001b & 00111111b = 00001001b
-11001001b & 01000000b = 01000000b
-11001001b & 01000001b = 01000001b
-11001001b & 01000010b = 01000000b
-11001001b & 01000011b = 01000001b
-11001001b & 01000100b = 01000000b
-11001001b & 01000101b = 01000001b
-11001001b & 01000110b = 01000000b
-11001001b & 01000111b = 01000001b
-11001001b & 01001000b = 01001000b
-11001001b & 01001001b = 01001001b
-11001001b & 01001010b = 01001000b
-11001001b & 01001011b = 01001001b
-11001001b & 01001100b = 01001000b
-11001001b & 01001101b = 01001001b
-11001001b & 01001110b = 01001000b
-11001001b & 01001111b = 01001001b
-11001001b & 01010000b = 01000000b
-11001001b & 01010001b = 01000001b
-11001001b & 01010010b = 01000000b
-11001001b & 01010011b = 01000001b
-11001001b & 01010100b = 01000000b
-11001001b & 01010101b = 01000001b
-11001001b & 01010110b = 01000000b
-11001001b & 01010111b = 01000001b
-11001001b & 01011000b = 01001000b
-11001001b & 01011001b = 01001001b
-11001001b & 01011010b = 01001000b
-11001001b & 01011011b = 01001001b
-11001001b & 01011100b = 01001000b
-11001001b & 01011101b = 01001001b
-11001001b & 01011110b = 01001000b
-11001001b & 01011111b = 01001001b
-11001001b & 01100000b = 01000000b
-11001001b & 01100001b = 01000001b
-11001001b & 01100010b = 01000000b
-11001001b & 01100011b = 01000001b
-11001001b & 01100100b = 01000000b
-11001001b & 01100101b = 01000001b
-11001001b & 01100110b = 01000000b
-11001001b & 01100111b = 01000001b
-11001001b & 01101000b = 01001000b
-11001001b & 01101001b = 01001001b
-11001001b & 01101010b = 01001000b
-11001001b & 01101011b = 01001001b
-11001001b & 01101100b = 01001000b
-11001001b & 01101101b = 01001001b
-11001001b & 01101110b = 01001000b
-11001001b & 01101111b = 01001001b
-11001001b & 01110000b = 01000000b
-11001001b & 01110001b = 01000001b
-11001001b & 01110010b = 01000000b
-11001001b & 01110011b = 01000001b
-11001001b & 01110100b = 01000000b
-11001001b & 01110101b = 01000001b
-11001001b & 01110110b = 01000000b
-11001001b & 01110111b = 01000001b
-11001001b & 01111000b = 01001000b
-11001001b & 01111001b = 01001001b
-11001001b & 01111010b = 01001000b
-11001001b & 01111011b = 01001001b
-11001001b & 01111100b = 01001000b
-11001001b & 01111101b = 01001001b
-11001001b & 01111110b = 01001000b
-11001010b & 10000000b = 10000000b
-11001010b & 10000001b = 10000000b
-11001010b & 10000010b = 10000010b
-11001010b & 10000011b = 10000010b
-11001010b & 10000100b = 10000000b
-11001010b & 10000101b = 10000000b
-11001010b & 10000110b = 10000010b
-11001010b & 10000111b = 10000010b
-11001010b & 10001000b = 10001000b
-11001010b & 10001001b = 10001000b
-11001010b & 10001010b = 10001010b
-11001010b & 10001011b = 10001010b
-11001010b & 10001100b = 10001000b
-11001010b & 10001101b = 10001000b
-11001010b & 10001110b = 10001010b
-11001010b & 10001111b = 10001010b
-11001010b & 10010000b = 10000000b
-11001010b & 10010001b = 10000000b
-11001010b & 10010010b = 10000010b
-11001010b & 10010011b = 10000010b
-11001010b & 10010100b = 10000000b
-11001010b & 10010101b = 10000000b
-11001010b & 10010110b = 10000010b
-11001010b & 10010111b = 10000010b
-11001010b & 10011000b = 10001000b
-11001010b & 10011001b = 10001000b
-11001010b & 10011010b = 10001010b
-11001010b & 10011011b = 10001010b
-11001010b & 10011100b = 10001000b
-11001010b & 10011101b = 10001000b
-11001010b & 10011110b = 10001010b
-11001010b & 10011111b = 10001010b
-11001010b & 10100000b = 10000000b
-11001010b & 10100001b = 10000000b
-11001010b & 10100010b = 10000010b
-11001010b & 10100011b = 10000010b
-11001010b & 10100100b = 10000000b
-11001010b & 10100101b = 10000000b
-11001010b & 10100110b = 10000010b
-11001010b & 10100111b = 10000010b
-11001010b & 10101000b = 10001000b
-11001010b & 10101001b = 10001000b
-11001010b & 10101010b = 10001010b
-11001010b & 10101011b = 10001010b
-11001010b & 10101100b = 10001000b
-11001010b & 10101101b = 10001000b
-11001010b & 10101110b = 10001010b
-11001010b & 10101111b = 10001010b
-11001010b & 10110000b = 10000000b
-11001010b & 10110001b = 10000000b
-11001010b & 10110010b = 10000010b
-11001010b & 10110011b = 10000010b
-11001010b & 10110100b = 10000000b
-11001010b & 10110101b = 10000000b
-11001010b & 10110110b = 10000010b
-11001010b & 10110111b = 10000010b
-11001010b & 10111000b = 10001000b
-11001010b & 10111001b = 10001000b
-11001010b & 10111010b = 10001010b
-11001010b & 10111011b = 10001010b
-11001010b & 10111100b = 10001000b
-11001010b & 10111101b = 10001000b
-11001010b & 10111110b = 10001010b
-11001010b & 10111111b = 10001010b
-11001010b & 11000000b = 11000000b
-11001010b & 11000001b = 11000000b
-11001010b & 11000010b = 11000010b
-11001010b & 11000011b = 11000010b
-11001010b & 11000100b = 11000000b
-11001010b & 11000101b = 11000000b
-11001010b & 11000110b = 11000010b
-11001010b & 11000111b = 11000010b
-11001010b & 11001000b = 11001000b
-11001010b & 11001001b = 11001000b
-11001010b & 11001010b = 11001010b
-11001010b & 11001011b = 11001010b
-11001010b & 11001100b = 11001000b
-11001010b & 11001101b = 11001000b
-11001010b & 11001110b = 11001010b
-11001010b & 11001111b = 11001010b
-11001010b & 11010000b = 11000000b
-11001010b & 11010001b = 11000000b
-11001010b & 11010010b = 11000010b
-11001010b & 11010011b = 11000010b
-11001010b & 11010100b = 11000000b
-11001010b & 11010101b = 11000000b
-11001010b & 11010110b = 11000010b
-11001010b & 11010111b = 11000010b
-11001010b & 11011000b = 11001000b
-11001010b & 11011001b = 11001000b
-11001010b & 11011010b = 11001010b
-11001010b & 11011011b = 11001010b
-11001010b & 11011100b = 11001000b
-11001010b & 11011101b = 11001000b
-11001010b & 11011110b = 11001010b
-11001010b & 11011111b = 11001010b
-11001010b & 11100000b = 11000000b
-11001010b & 11100001b = 11000000b
-11001010b & 11100010b = 11000010b
-11001010b & 11100011b = 11000010b
-11001010b & 11100100b = 11000000b
-11001010b & 11100101b = 11000000b
-11001010b & 11100110b = 11000010b
-11001010b & 11100111b = 11000010b
-11001010b & 11101000b = 11001000b
-11001010b & 11101001b = 11001000b
-11001010b & 11101010b = 11001010b
-11001010b & 11101011b = 11001010b
-11001010b & 11101100b = 11001000b
-11001010b & 11101101b = 11001000b
-11001010b & 11101110b = 11001010b
-11001010b & 11101111b = 11001010b
-11001010b & 11110000b = 11000000b
-11001010b & 11110001b = 11000000b
-11001010b & 11110010b = 11000010b
-11001010b & 11110011b = 11000010b
-11001010b & 11110100b = 11000000b
-11001010b & 11110101b = 11000000b
-11001010b & 11110110b = 11000010b
-11001010b & 11110111b = 11000010b
-11001010b & 11111000b = 11001000b
-11001010b & 11111001b = 11001000b
-11001010b & 11111010b = 11001010b
-11001010b & 11111011b = 11001010b
-11001010b & 11111100b = 11001000b
-11001010b & 11111101b = 11001000b
-11001010b & 11111110b = 11001010b
-11001010b & 11111111b = 11001010b
-11001010b & 00000000b = 00000000b
-11001010b & 00000001b = 00000000b
-11001010b & 00000010b = 00000010b
-11001010b & 00000011b = 00000010b
-11001010b & 00000100b = 00000000b
-11001010b & 00000101b = 00000000b
-11001010b & 00000110b = 00000010b
-11001010b & 00000111b = 00000010b
-11001010b & 00001000b = 00001000b
-11001010b & 00001001b = 00001000b
-11001010b & 00001010b = 00001010b
-11001010b & 00001011b = 00001010b
-11001010b & 00001100b = 00001000b
-11001010b & 00001101b = 00001000b
-11001010b & 00001110b = 00001010b
-11001010b & 00001111b = 00001010b
-11001010b & 00010000b = 00000000b
-11001010b & 00010001b = 00000000b
-11001010b & 00010010b = 00000010b
-11001010b & 00010011b = 00000010b
-11001010b & 00010100b = 00000000b
-11001010b & 00010101b = 00000000b
-11001010b & 00010110b = 00000010b
-11001010b & 00010111b = 00000010b
-11001010b & 00011000b = 00001000b
-11001010b & 00011001b = 00001000b
-11001010b & 00011010b = 00001010b
-11001010b & 00011011b = 00001010b
-11001010b & 00011100b = 00001000b
-11001010b & 00011101b = 00001000b
-11001010b & 00011110b = 00001010b
-11001010b & 00011111b = 00001010b
-11001010b & 00100000b = 00000000b
-11001010b & 00100001b = 00000000b
-11001010b & 00100010b = 00000010b
-11001010b & 00100011b = 00000010b
-11001010b & 00100100b = 00000000b
-11001010b & 00100101b = 00000000b
-11001010b & 00100110b = 00000010b
-11001010b & 00100111b = 00000010b
-11001010b & 00101000b = 00001000b
-11001010b & 00101001b = 00001000b
-11001010b & 00101010b = 00001010b
-11001010b & 00101011b = 00001010b
-11001010b & 00101100b = 00001000b
-11001010b & 00101101b = 00001000b
-11001010b & 00101110b = 00001010b
-11001010b & 00101111b = 00001010b
-11001010b & 00110000b = 00000000b
-11001010b & 00110001b = 00000000b
-11001010b & 00110010b = 00000010b
-11001010b & 00110011b = 00000010b
-11001010b & 00110100b = 00000000b
-11001010b & 00110101b = 00000000b
-11001010b & 00110110b = 00000010b
-11001010b & 00110111b = 00000010b
-11001010b & 00111000b = 00001000b
-11001010b & 00111001b = 00001000b
-11001010b & 00111010b = 00001010b
-11001010b & 00111011b = 00001010b
-11001010b & 00111100b = 00001000b
-11001010b & 00111101b = 00001000b
-11001010b & 00111110b = 00001010b
-11001010b & 00111111b = 00001010b
-11001010b & 01000000b = 01000000b
-11001010b & 01000001b = 01000000b
-11001010b & 01000010b = 01000010b
-11001010b & 01000011b = 01000010b
-11001010b & 01000100b = 01000000b
-11001010b & 01000101b = 01000000b
-11001010b & 01000110b = 01000010b
-11001010b & 01000111b = 01000010b
-11001010b & 01001000b = 01001000b
-11001010b & 01001001b = 01001000b
-11001010b & 01001010b = 01001010b
-11001010b & 01001011b = 01001010b
-11001010b & 01001100b = 01001000b
-11001010b & 01001101b = 01001000b
-11001010b & 01001110b = 01001010b
-11001010b & 01001111b = 01001010b
-11001010b & 01010000b = 01000000b
-11001010b & 01010001b = 01000000b
-11001010b & 01010010b = 01000010b
-11001010b & 01010011b = 01000010b
-11001010b & 01010100b = 01000000b
-11001010b & 01010101b = 01000000b
-11001010b & 01010110b = 01000010b
-11001010b & 01010111b = 01000010b
-11001010b & 01011000b = 01001000b
-11001010b & 01011001b = 01001000b
-11001010b & 01011010b = 01001010b
-11001010b & 01011011b = 01001010b
-11001010b & 01011100b = 01001000b
-11001010b & 01011101b = 01001000b
-11001010b & 01011110b = 01001010b
-11001010b & 01011111b = 01001010b
-11001010b & 01100000b = 01000000b
-11001010b & 01100001b = 01000000b
-11001010b & 01100010b = 01000010b
-11001010b & 01100011b = 01000010b
-11001010b & 01100100b = 01000000b
-11001010b & 01100101b = 01000000b
-11001010b & 01100110b = 01000010b
-11001010b & 01100111b = 01000010b
-11001010b & 01101000b = 01001000b
-11001010b & 01101001b = 01001000b
-11001010b & 01101010b = 01001010b
-11001010b & 01101011b = 01001010b
-11001010b & 01101100b = 01001000b
-11001010b & 01101101b = 01001000b
-11001010b & 01101110b = 01001010b
-11001010b & 01101111b = 01001010b
-11001010b & 01110000b = 01000000b
-11001010b & 01110001b = 01000000b
-11001010b & 01110010b = 01000010b
-11001010b & 01110011b = 01000010b
-11001010b & 01110100b = 01000000b
-11001010b & 01110101b = 01000000b
-11001010b & 01110110b = 01000010b
-11001010b & 01110111b = 01000010b
-11001010b & 01111000b = 01001000b
-11001010b & 01111001b = 01001000b
-11001010b & 01111010b = 01001010b
-11001010b & 01111011b = 01001010b
-11001010b & 01111100b = 01001000b
-11001010b & 01111101b = 01001000b
-11001010b & 01111110b = 01001010b
-11001011b & 10000000b = 10000000b
-11001011b & 10000001b = 10000001b
-11001011b & 10000010b = 10000010b
-11001011b & 10000011b = 10000011b
-11001011b & 10000100b = 10000000b
-11001011b & 10000101b = 10000001b
-11001011b & 10000110b = 10000010b
-11001011b & 10000111b = 10000011b
-11001011b & 10001000b = 10001000b
-11001011b & 10001001b = 10001001b
-11001011b & 10001010b = 10001010b
-11001011b & 10001011b = 10001011b
-11001011b & 10001100b = 10001000b
-11001011b & 10001101b = 10001001b
-11001011b & 10001110b = 10001010b
-11001011b & 10001111b = 10001011b
-11001011b & 10010000b = 10000000b
-11001011b & 10010001b = 10000001b
-11001011b & 10010010b = 10000010b
-11001011b & 10010011b = 10000011b
-11001011b & 10010100b = 10000000b
-11001011b & 10010101b = 10000001b
-11001011b & 10010110b = 10000010b
-11001011b & 10010111b = 10000011b
-11001011b & 10011000b = 10001000b
-11001011b & 10011001b = 10001001b
-11001011b & 10011010b = 10001010b
-11001011b & 10011011b = 10001011b
-11001011b & 10011100b = 10001000b
-11001011b & 10011101b = 10001001b
-11001011b & 10011110b = 10001010b
-11001011b & 10011111b = 10001011b
-11001011b & 10100000b = 10000000b
-11001011b & 10100001b = 10000001b
-11001011b & 10100010b = 10000010b
-11001011b & 10100011b = 10000011b
-11001011b & 10100100b = 10000000b
-11001011b & 10100101b = 10000001b
-11001011b & 10100110b = 10000010b
-11001011b & 10100111b = 10000011b
-11001011b & 10101000b = 10001000b
-11001011b & 10101001b = 10001001b
-11001011b & 10101010b = 10001010b
-11001011b & 10101011b = 10001011b
-11001011b & 10101100b = 10001000b
-11001011b & 10101101b = 10001001b
-11001011b & 10101110b = 10001010b
-11001011b & 10101111b = 10001011b
-11001011b & 10110000b = 10000000b
-11001011b & 10110001b = 10000001b
-11001011b & 10110010b = 10000010b
-11001011b & 10110011b = 10000011b
-11001011b & 10110100b = 10000000b
-11001011b & 10110101b = 10000001b
-11001011b & 10110110b = 10000010b
-11001011b & 10110111b = 10000011b
-11001011b & 10111000b = 10001000b
-11001011b & 10111001b = 10001001b
-11001011b & 10111010b = 10001010b
-11001011b & 10111011b = 10001011b
-11001011b & 10111100b = 10001000b
-11001011b & 10111101b = 10001001b
-11001011b & 10111110b = 10001010b
-11001011b & 10111111b = 10001011b
-11001011b & 11000000b = 11000000b
-11001011b & 11000001b = 11000001b
-11001011b & 11000010b = 11000010b
-11001011b & 11000011b = 11000011b
-11001011b & 11000100b = 11000000b
-11001011b & 11000101b = 11000001b
-11001011b & 11000110b = 11000010b
-11001011b & 11000111b = 11000011b
-11001011b & 11001000b = 11001000b
-11001011b & 11001001b = 11001001b
-11001011b & 11001010b = 11001010b
-11001011b & 11001011b = 11001011b
-11001011b & 11001100b = 11001000b
-11001011b & 11001101b = 11001001b
-11001011b & 11001110b = 11001010b
-11001011b & 11001111b = 11001011b
-11001011b & 11010000b = 11000000b
-11001011b & 11010001b = 11000001b
-11001011b & 11010010b = 11000010b
-11001011b & 11010011b = 11000011b
-11001011b & 11010100b = 11000000b
-11001011b & 11010101b = 11000001b
-11001011b & 11010110b = 11000010b
-11001011b & 11010111b = 11000011b
-11001011b & 11011000b = 11001000b
-11001011b & 11011001b = 11001001b
-11001011b & 11011010b = 11001010b
-11001011b & 11011011b = 11001011b
-11001011b & 11011100b = 11001000b
-11001011b & 11011101b = 11001001b
-11001011b & 11011110b = 11001010b
-11001011b & 11011111b = 11001011b
-11001011b & 11100000b = 11000000b
-11001011b & 11100001b = 11000001b
-11001011b & 11100010b = 11000010b
-11001011b & 11100011b = 11000011b
-11001011b & 11100100b = 11000000b
-11001011b & 11100101b = 11000001b
-11001011b & 11100110b = 11000010b
-11001011b & 11100111b = 11000011b
-11001011b & 11101000b = 11001000b
-11001011b & 11101001b = 11001001b
-11001011b & 11101010b = 11001010b
-11001011b & 11101011b = 11001011b
-11001011b & 11101100b = 11001000b
-11001011b & 11101101b = 11001001b
-11001011b & 11101110b = 11001010b
-11001011b & 11101111b = 11001011b
-11001011b & 11110000b = 11000000b
-11001011b & 11110001b = 11000001b
-11001011b & 11110010b = 11000010b
-11001011b & 11110011b = 11000011b
-11001011b & 11110100b = 11000000b
-11001011b & 11110101b = 11000001b
-11001011b & 11110110b = 11000010b
-11001011b & 11110111b = 11000011b
-11001011b & 11111000b = 11001000b
-11001011b & 11111001b = 11001001b
-11001011b & 11111010b = 11001010b
-11001011b & 11111011b = 11001011b
-11001011b & 11111100b = 11001000b
-11001011b & 11111101b = 11001001b
-11001011b & 11111110b = 11001010b
-11001011b & 11111111b = 11001011b
-11001011b & 00000000b = 00000000b
-11001011b & 00000001b = 00000001b
-11001011b & 00000010b = 00000010b
-11001011b & 00000011b = 00000011b
-11001011b & 00000100b = 00000000b
-11001011b & 00000101b = 00000001b
-11001011b & 00000110b = 00000010b
-11001011b & 00000111b = 00000011b
-11001011b & 00001000b = 00001000b
-11001011b & 00001001b = 00001001b
-11001011b & 00001010b = 00001010b
-11001011b & 00001011b = 00001011b
-11001011b & 00001100b = 00001000b
-11001011b & 00001101b = 00001001b
-11001011b & 00001110b = 00001010b
-11001011b & 00001111b = 00001011b
-11001011b & 00010000b = 00000000b
-11001011b & 00010001b = 00000001b
-11001011b & 00010010b = 00000010b
-11001011b & 00010011b = 00000011b
-11001011b & 00010100b = 00000000b
-11001011b & 00010101b = 00000001b
-11001011b & 00010110b = 00000010b
-11001011b & 00010111b = 00000011b
-11001011b & 00011000b = 00001000b
-11001011b & 00011001b = 00001001b
-11001011b & 00011010b = 00001010b
-11001011b & 00011011b = 00001011b
-11001011b & 00011100b = 00001000b
-11001011b & 00011101b = 00001001b
-11001011b & 00011110b = 00001010b
-11001011b & 00011111b = 00001011b
-11001011b & 00100000b = 00000000b
-11001011b & 00100001b = 00000001b
-11001011b & 00100010b = 00000010b
-11001011b & 00100011b = 00000011b
-11001011b & 00100100b = 00000000b
-11001011b & 00100101b = 00000001b
-11001011b & 00100110b = 00000010b
-11001011b & 00100111b = 00000011b
-11001011b & 00101000b = 00001000b
-11001011b & 00101001b = 00001001b
-11001011b & 00101010b = 00001010b
-11001011b & 00101011b = 00001011b
-11001011b & 00101100b = 00001000b
-11001011b & 00101101b = 00001001b
-11001011b & 00101110b = 00001010b
-11001011b & 00101111b = 00001011b
-11001011b & 00110000b = 00000000b
-11001011b & 00110001b = 00000001b
-11001011b & 00110010b = 00000010b
-11001011b & 00110011b = 00000011b
-11001011b & 00110100b = 00000000b
-11001011b & 00110101b = 00000001b
-11001011b & 00110110b = 00000010b
-11001011b & 00110111b = 00000011b
-11001011b & 00111000b = 00001000b
-11001011b & 00111001b = 00001001b
-11001011b & 00111010b = 00001010b
-11001011b & 00111011b = 00001011b
-11001011b & 00111100b = 00001000b
-11001011b & 00111101b = 00001001b
-11001011b & 00111110b = 00001010b
-11001011b & 00111111b = 00001011b
-11001011b & 01000000b = 01000000b
-11001011b & 01000001b = 01000001b
-11001011b & 01000010b = 01000010b
-11001011b & 01000011b = 01000011b
-11001011b & 01000100b = 01000000b
-11001011b & 01000101b = 01000001b
-11001011b & 01000110b = 01000010b
-11001011b & 01000111b = 01000011b
-11001011b & 01001000b = 01001000b
-11001011b & 01001001b = 01001001b
-11001011b & 01001010b = 01001010b
-11001011b & 01001011b = 01001011b
-11001011b & 01001100b = 01001000b
-11001011b & 01001101b = 01001001b
-11001011b & 01001110b = 01001010b
-11001011b & 01001111b = 01001011b
-11001011b & 01010000b = 01000000b
-11001011b & 01010001b = 01000001b
-11001011b & 01010010b = 01000010b
-11001011b & 01010011b = 01000011b
-11001011b & 01010100b = 01000000b
-11001011b & 01010101b = 01000001b
-11001011b & 01010110b = 01000010b
-11001011b & 01010111b = 01000011b
-11001011b & 01011000b = 01001000b
-11001011b & 01011001b = 01001001b
-11001011b & 01011010b = 01001010b
-11001011b & 01011011b = 01001011b
-11001011b & 01011100b = 01001000b
-11001011b & 01011101b = 01001001b
-11001011b & 01011110b = 01001010b
-11001011b & 01011111b = 01001011b
-11001011b & 01100000b = 01000000b
-11001011b & 01100001b = 01000001b
-11001011b & 01100010b = 01000010b
-11001011b & 01100011b = 01000011b
-11001011b & 01100100b = 01000000b
-11001011b & 01100101b = 01000001b
-11001011b & 01100110b = 01000010b
-11001011b & 01100111b = 01000011b
-11001011b & 01101000b = 01001000b
-11001011b & 01101001b = 01001001b
-11001011b & 01101010b = 01001010b
-11001011b & 01101011b = 01001011b
-11001011b & 01101100b = 01001000b
-11001011b & 01101101b = 01001001b
-11001011b & 01101110b = 01001010b
-11001011b & 01101111b = 01001011b
-11001011b & 01110000b = 01000000b
-11001011b & 01110001b = 01000001b
-11001011b & 01110010b = 01000010b
-11001011b & 01110011b = 01000011b
-11001011b & 01110100b = 01000000b
-11001011b & 01110101b = 01000001b
-11001011b & 01110110b = 01000010b
-11001011b & 01110111b = 01000011b
-11001011b & 01111000b = 01001000b
-11001011b & 01111001b = 01001001b
-11001011b & 01111010b = 01001010b
-11001011b & 01111011b = 01001011b
-11001011b & 01111100b = 01001000b
-11001011b & 01111101b = 01001001b
-11001011b & 01111110b = 01001010b
-11001100b & 10000000b = 10000000b
-11001100b & 10000001b = 10000000b
-11001100b & 10000010b = 10000000b
-11001100b & 10000011b = 10000000b
-11001100b & 10000100b = 10000100b
-11001100b & 10000101b = 10000100b
-11001100b & 10000110b = 10000100b
-11001100b & 10000111b = 10000100b
-11001100b & 10001000b = 10001000b
-11001100b & 10001001b = 10001000b
-11001100b & 10001010b = 10001000b
-11001100b & 10001011b = 10001000b
-11001100b & 10001100b = 10001100b
-11001100b & 10001101b = 10001100b
-11001100b & 10001110b = 10001100b
-11001100b & 10001111b = 10001100b
-11001100b & 10010000b = 10000000b
-11001100b & 10010001b = 10000000b
-11001100b & 10010010b = 10000000b
-11001100b & 10010011b = 10000000b
-11001100b & 10010100b = 10000100b
-11001100b & 10010101b = 10000100b
-11001100b & 10010110b = 10000100b
-11001100b & 10010111b = 10000100b
-11001100b & 10011000b = 10001000b
-11001100b & 10011001b = 10001000b
-11001100b & 10011010b = 10001000b
-11001100b & 10011011b = 10001000b
-11001100b & 10011100b = 10001100b
-11001100b & 10011101b = 10001100b
-11001100b & 10011110b = 10001100b
-11001100b & 10011111b = 10001100b
-11001100b & 10100000b = 10000000b
-11001100b & 10100001b = 10000000b
-11001100b & 10100010b = 10000000b
-11001100b & 10100011b = 10000000b
-11001100b & 10100100b = 10000100b
-11001100b & 10100101b = 10000100b
-11001100b & 10100110b = 10000100b
-11001100b & 10100111b = 10000100b
-11001100b & 10101000b = 10001000b
-11001100b & 10101001b = 10001000b
-11001100b & 10101010b = 10001000b
-11001100b & 10101011b = 10001000b
-11001100b & 10101100b = 10001100b
-11001100b & 10101101b = 10001100b
-11001100b & 10101110b = 10001100b
-11001100b & 10101111b = 10001100b
-11001100b & 10110000b = 10000000b
-11001100b & 10110001b = 10000000b
-11001100b & 10110010b = 10000000b
-11001100b & 10110011b = 10000000b
-11001100b & 10110100b = 10000100b
-11001100b & 10110101b = 10000100b
-11001100b & 10110110b = 10000100b
-11001100b & 10110111b = 10000100b
-11001100b & 10111000b = 10001000b
-11001100b & 10111001b = 10001000b
-11001100b & 10111010b = 10001000b
-11001100b & 10111011b = 10001000b
-11001100b & 10111100b = 10001100b
-11001100b & 10111101b = 10001100b
-11001100b & 10111110b = 10001100b
-11001100b & 10111111b = 10001100b
-11001100b & 11000000b = 11000000b
-11001100b & 11000001b = 11000000b
-11001100b & 11000010b = 11000000b
-11001100b & 11000011b = 11000000b
-11001100b & 11000100b = 11000100b
-11001100b & 11000101b = 11000100b
-11001100b & 11000110b = 11000100b
-11001100b & 11000111b = 11000100b
-11001100b & 11001000b = 11001000b
-11001100b & 11001001b = 11001000b
-11001100b & 11001010b = 11001000b
-11001100b & 11001011b = 11001000b
-11001100b & 11001100b = 11001100b
-11001100b & 11001101b = 11001100b
-11001100b & 11001110b = 11001100b
-11001100b & 11001111b = 11001100b
-11001100b & 11010000b = 11000000b
-11001100b & 11010001b = 11000000b
-11001100b & 11010010b = 11000000b
-11001100b & 11010011b = 11000000b
-11001100b & 11010100b = 11000100b
-11001100b & 11010101b = 11000100b
-11001100b & 11010110b = 11000100b
-11001100b & 11010111b = 11000100b
-11001100b & 11011000b = 11001000b
-11001100b & 11011001b = 11001000b
-11001100b & 11011010b = 11001000b
-11001100b & 11011011b = 11001000b
-11001100b & 11011100b = 11001100b
-11001100b & 11011101b = 11001100b
-11001100b & 11011110b = 11001100b
-11001100b & 11011111b = 11001100b
-11001100b & 11100000b = 11000000b
-11001100b & 11100001b = 11000000b
-11001100b & 11100010b = 11000000b
-11001100b & 11100011b = 11000000b
-11001100b & 11100100b = 11000100b
-11001100b & 11100101b = 11000100b
-11001100b & 11100110b = 11000100b
-11001100b & 11100111b = 11000100b
-11001100b & 11101000b = 11001000b
-11001100b & 11101001b = 11001000b
-11001100b & 11101010b = 11001000b
-11001100b & 11101011b = 11001000b
-11001100b & 11101100b = 11001100b
-11001100b & 11101101b = 11001100b
-11001100b & 11101110b = 11001100b
-11001100b & 11101111b = 11001100b
-11001100b & 11110000b = 11000000b
-11001100b & 11110001b = 11000000b
-11001100b & 11110010b = 11000000b
-11001100b & 11110011b = 11000000b
-11001100b & 11110100b = 11000100b
-11001100b & 11110101b = 11000100b
-11001100b & 11110110b = 11000100b
-11001100b & 11110111b = 11000100b
-11001100b & 11111000b = 11001000b
-11001100b & 11111001b = 11001000b
-11001100b & 11111010b = 11001000b
-11001100b & 11111011b = 11001000b
-11001100b & 11111100b = 11001100b
-11001100b & 11111101b = 11001100b
-11001100b & 11111110b = 11001100b
-11001100b & 11111111b = 11001100b
-11001100b & 00000000b = 00000000b
-11001100b & 00000001b = 00000000b
-11001100b & 00000010b = 00000000b
-11001100b & 00000011b = 00000000b
-11001100b & 00000100b = 00000100b
-11001100b & 00000101b = 00000100b
-11001100b & 00000110b = 00000100b
-11001100b & 00000111b = 00000100b
-11001100b & 00001000b = 00001000b
-11001100b & 00001001b = 00001000b
-11001100b & 00001010b = 00001000b
-11001100b & 00001011b = 00001000b
-11001100b & 00001100b = 00001100b
-11001100b & 00001101b = 00001100b
-11001100b & 00001110b = 00001100b
-11001100b & 00001111b = 00001100b
-11001100b & 00010000b = 00000000b
-11001100b & 00010001b = 00000000b
-11001100b & 00010010b = 00000000b
-11001100b & 00010011b = 00000000b
-11001100b & 00010100b = 00000100b
-11001100b & 00010101b = 00000100b
-11001100b & 00010110b = 00000100b
-11001100b & 00010111b = 00000100b
-11001100b & 00011000b = 00001000b
-11001100b & 00011001b = 00001000b
-11001100b & 00011010b = 00001000b
-11001100b & 00011011b = 00001000b
-11001100b & 00011100b = 00001100b
-11001100b & 00011101b = 00001100b
-11001100b & 00011110b = 00001100b
-11001100b & 00011111b = 00001100b
-11001100b & 00100000b = 00000000b
-11001100b & 00100001b = 00000000b
-11001100b & 00100010b = 00000000b
-11001100b & 00100011b = 00000000b
-11001100b & 00100100b = 00000100b
-11001100b & 00100101b = 00000100b
-11001100b & 00100110b = 00000100b
-11001100b & 00100111b = 00000100b
-11001100b & 00101000b = 00001000b
-11001100b & 00101001b = 00001000b
-11001100b & 00101010b = 00001000b
-11001100b & 00101011b = 00001000b
-11001100b & 00101100b = 00001100b
-11001100b & 00101101b = 00001100b
-11001100b & 00101110b = 00001100b
-11001100b & 00101111b = 00001100b
-11001100b & 00110000b = 00000000b
-11001100b & 00110001b = 00000000b
-11001100b & 00110010b = 00000000b
-11001100b & 00110011b = 00000000b
-11001100b & 00110100b = 00000100b
-11001100b & 00110101b = 00000100b
-11001100b & 00110110b = 00000100b
-11001100b & 00110111b = 00000100b
-11001100b & 00111000b = 00001000b
-11001100b & 00111001b = 00001000b
-11001100b & 00111010b = 00001000b
-11001100b & 00111011b = 00001000b
-11001100b & 00111100b = 00001100b
-11001100b & 00111101b = 00001100b
-11001100b & 00111110b = 00001100b
-11001100b & 00111111b = 00001100b
-11001100b & 01000000b = 01000000b
-11001100b & 01000001b = 01000000b
-11001100b & 01000010b = 01000000b
-11001100b & 01000011b = 01000000b
-11001100b & 01000100b = 01000100b
-11001100b & 01000101b = 01000100b
-11001100b & 01000110b = 01000100b
-11001100b & 01000111b = 01000100b
-11001100b & 01001000b = 01001000b
-11001100b & 01001001b = 01001000b
-11001100b & 01001010b = 01001000b
-11001100b & 01001011b = 01001000b
-11001100b & 01001100b = 01001100b
-11001100b & 01001101b = 01001100b
-11001100b & 01001110b = 01001100b
-11001100b & 01001111b = 01001100b
-11001100b & 01010000b = 01000000b
-11001100b & 01010001b = 01000000b
-11001100b & 01010010b = 01000000b
-11001100b & 01010011b = 01000000b
-11001100b & 01010100b = 01000100b
-11001100b & 01010101b = 01000100b
-11001100b & 01010110b = 01000100b
-11001100b & 01010111b = 01000100b
-11001100b & 01011000b = 01001000b
-11001100b & 01011001b = 01001000b
-11001100b & 01011010b = 01001000b
-11001100b & 01011011b = 01001000b
-11001100b & 01011100b = 01001100b
-11001100b & 01011101b = 01001100b
-11001100b & 01011110b = 01001100b
-11001100b & 01011111b = 01001100b
-11001100b & 01100000b = 01000000b
-11001100b & 01100001b = 01000000b
-11001100b & 01100010b = 01000000b
-11001100b & 01100011b = 01000000b
-11001100b & 01100100b = 01000100b
-11001100b & 01100101b = 01000100b
-11001100b & 01100110b = 01000100b
-11001100b & 01100111b = 01000100b
-11001100b & 01101000b = 01001000b
-11001100b & 01101001b = 01001000b
-11001100b & 01101010b = 01001000b
-11001100b & 01101011b = 01001000b
-11001100b & 01101100b = 01001100b
-11001100b & 01101101b = 01001100b
-11001100b & 01101110b = 01001100b
-11001100b & 01101111b = 01001100b
-11001100b & 01110000b = 01000000b
-11001100b & 01110001b = 01000000b
-11001100b & 01110010b = 01000000b
-11001100b & 01110011b = 01000000b
-11001100b & 01110100b = 01000100b
-11001100b & 01110101b = 01000100b
-11001100b & 01110110b = 01000100b
-11001100b & 01110111b = 01000100b
-11001100b & 01111000b = 01001000b
-11001100b & 01111001b = 01001000b
-11001100b & 01111010b = 01001000b
-11001100b & 01111011b = 01001000b
-11001100b & 01111100b = 01001100b
-11001100b & 01111101b = 01001100b
-11001100b & 01111110b = 01001100b
-11001101b & 10000000b = 10000000b
-11001101b & 10000001b = 10000001b
-11001101b & 10000010b = 10000000b
-11001101b & 10000011b = 10000001b
-11001101b & 10000100b = 10000100b
-11001101b & 10000101b = 10000101b
-11001101b & 10000110b = 10000100b
-11001101b & 10000111b = 10000101b
-11001101b & 10001000b = 10001000b
-11001101b & 10001001b = 10001001b
-11001101b & 10001010b = 10001000b
-11001101b & 10001011b = 10001001b
-11001101b & 10001100b = 10001100b
-11001101b & 10001101b = 10001101b
-11001101b & 10001110b = 10001100b
-11001101b & 10001111b = 10001101b
-11001101b & 10010000b = 10000000b
-11001101b & 10010001b = 10000001b
-11001101b & 10010010b = 10000000b
-11001101b & 10010011b = 10000001b
-11001101b & 10010100b = 10000100b
-11001101b & 10010101b = 10000101b
-11001101b & 10010110b = 10000100b
-11001101b & 10010111b = 10000101b
-11001101b & 10011000b = 10001000b
-11001101b & 10011001b = 10001001b
-11001101b & 10011010b = 10001000b
-11001101b & 10011011b = 10001001b
-11001101b & 10011100b = 10001100b
-11001101b & 10011101b = 10001101b
-11001101b & 10011110b = 10001100b
-11001101b & 10011111b = 10001101b
-11001101b & 10100000b = 10000000b
-11001101b & 10100001b = 10000001b
-11001101b & 10100010b = 10000000b
-11001101b & 10100011b = 10000001b
-11001101b & 10100100b = 10000100b
-11001101b & 10100101b = 10000101b
-11001101b & 10100110b = 10000100b
-11001101b & 10100111b = 10000101b
-11001101b & 10101000b = 10001000b
-11001101b & 10101001b = 10001001b
-11001101b & 10101010b = 10001000b
-11001101b & 10101011b = 10001001b
-11001101b & 10101100b = 10001100b
-11001101b & 10101101b = 10001101b
-11001101b & 10101110b = 10001100b
-11001101b & 10101111b = 10001101b
-11001101b & 10110000b = 10000000b
-11001101b & 10110001b = 10000001b
-11001101b & 10110010b = 10000000b
-11001101b & 10110011b = 10000001b
-11001101b & 10110100b = 10000100b
-11001101b & 10110101b = 10000101b
-11001101b & 10110110b = 10000100b
-11001101b & 10110111b = 10000101b
-11001101b & 10111000b = 10001000b
-11001101b & 10111001b = 10001001b
-11001101b & 10111010b = 10001000b
-11001101b & 10111011b = 10001001b
-11001101b & 10111100b = 10001100b
-11001101b & 10111101b = 10001101b
-11001101b & 10111110b = 10001100b
-11001101b & 10111111b = 10001101b
-11001101b & 11000000b = 11000000b
-11001101b & 11000001b = 11000001b
-11001101b & 11000010b = 11000000b
-11001101b & 11000011b = 11000001b
-11001101b & 11000100b = 11000100b
-11001101b & 11000101b = 11000101b
-11001101b & 11000110b = 11000100b
-11001101b & 11000111b = 11000101b
-11001101b & 11001000b = 11001000b
-11001101b & 11001001b = 11001001b
-11001101b & 11001010b = 11001000b
-11001101b & 11001011b = 11001001b
-11001101b & 11001100b = 11001100b
-11001101b & 11001101b = 11001101b
-11001101b & 11001110b = 11001100b
-11001101b & 11001111b = 11001101b
-11001101b & 11010000b = 11000000b
-11001101b & 11010001b = 11000001b
-11001101b & 11010010b = 11000000b
-11001101b & 11010011b = 11000001b
-11001101b & 11010100b = 11000100b
-11001101b & 11010101b = 11000101b
-11001101b & 11010110b = 11000100b
-11001101b & 11010111b = 11000101b
-11001101b & 11011000b = 11001000b
-11001101b & 11011001b = 11001001b
-11001101b & 11011010b = 11001000b
-11001101b & 11011011b = 11001001b
-11001101b & 11011100b = 11001100b
-11001101b & 11011101b = 11001101b
-11001101b & 11011110b = 11001100b
-11001101b & 11011111b = 11001101b
-11001101b & 11100000b = 11000000b
-11001101b & 11100001b = 11000001b
-11001101b & 11100010b = 11000000b
-11001101b & 11100011b = 11000001b
-11001101b & 11100100b = 11000100b
-11001101b & 11100101b = 11000101b
-11001101b & 11100110b = 11000100b
-11001101b & 11100111b = 11000101b
-11001101b & 11101000b = 11001000b
-11001101b & 11101001b = 11001001b
-11001101b & 11101010b = 11001000b
-11001101b & 11101011b = 11001001b
-11001101b & 11101100b = 11001100b
-11001101b & 11101101b = 11001101b
-11001101b & 11101110b = 11001100b
-11001101b & 11101111b = 11001101b
-11001101b & 11110000b = 11000000b
-11001101b & 11110001b = 11000001b
-11001101b & 11110010b = 11000000b
-11001101b & 11110011b = 11000001b
-11001101b & 11110100b = 11000100b
-11001101b & 11110101b = 11000101b
-11001101b & 11110110b = 11000100b
-11001101b & 11110111b = 11000101b
-11001101b & 11111000b = 11001000b
-11001101b & 11111001b = 11001001b
-11001101b & 11111010b = 11001000b
-11001101b & 11111011b = 11001001b
-11001101b & 11111100b = 11001100b
-11001101b & 11111101b = 11001101b
-11001101b & 11111110b = 11001100b
-11001101b & 11111111b = 11001101b
-11001101b & 00000000b = 00000000b
-11001101b & 00000001b = 00000001b
-11001101b & 00000010b = 00000000b
-11001101b & 00000011b = 00000001b
-11001101b & 00000100b = 00000100b
-11001101b & 00000101b = 00000101b
-11001101b & 00000110b = 00000100b
-11001101b & 00000111b = 00000101b
-11001101b & 00001000b = 00001000b
-11001101b & 00001001b = 00001001b
-11001101b & 00001010b = 00001000b
-11001101b & 00001011b = 00001001b
-11001101b & 00001100b = 00001100b
-11001101b & 00001101b = 00001101b
-11001101b & 00001110b = 00001100b
-11001101b & 00001111b = 00001101b
-11001101b & 00010000b = 00000000b
-11001101b & 00010001b = 00000001b
-11001101b & 00010010b = 00000000b
-11001101b & 00010011b = 00000001b
-11001101b & 00010100b = 00000100b
-11001101b & 00010101b = 00000101b
-11001101b & 00010110b = 00000100b
-11001101b & 00010111b = 00000101b
-11001101b & 00011000b = 00001000b
-11001101b & 00011001b = 00001001b
-11001101b & 00011010b = 00001000b
-11001101b & 00011011b = 00001001b
-11001101b & 00011100b = 00001100b
-11001101b & 00011101b = 00001101b
-11001101b & 00011110b = 00001100b
-11001101b & 00011111b = 00001101b
-11001101b & 00100000b = 00000000b
-11001101b & 00100001b = 00000001b
-11001101b & 00100010b = 00000000b
-11001101b & 00100011b = 00000001b
-11001101b & 00100100b = 00000100b
-11001101b & 00100101b = 00000101b
-11001101b & 00100110b = 00000100b
-11001101b & 00100111b = 00000101b
-11001101b & 00101000b = 00001000b
-11001101b & 00101001b = 00001001b
-11001101b & 00101010b = 00001000b
-11001101b & 00101011b = 00001001b
-11001101b & 00101100b = 00001100b
-11001101b & 00101101b = 00001101b
-11001101b & 00101110b = 00001100b
-11001101b & 00101111b = 00001101b
-11001101b & 00110000b = 00000000b
-11001101b & 00110001b = 00000001b
-11001101b & 00110010b = 00000000b
-11001101b & 00110011b = 00000001b
-11001101b & 00110100b = 00000100b
-11001101b & 00110101b = 00000101b
-11001101b & 00110110b = 00000100b
-11001101b & 00110111b = 00000101b
-11001101b & 00111000b = 00001000b
-11001101b & 00111001b = 00001001b
-11001101b & 00111010b = 00001000b
-11001101b & 00111011b = 00001001b
-11001101b & 00111100b = 00001100b
-11001101b & 00111101b = 00001101b
-11001101b & 00111110b = 00001100b
-11001101b & 00111111b = 00001101b
-11001101b & 01000000b = 01000000b
-11001101b & 01000001b = 01000001b
-11001101b & 01000010b = 01000000b
-11001101b & 01000011b = 01000001b
-11001101b & 01000100b = 01000100b
-11001101b & 01000101b = 01000101b
-11001101b & 01000110b = 01000100b
-11001101b & 01000111b = 01000101b
-11001101b & 01001000b = 01001000b
-11001101b & 01001001b = 01001001b
-11001101b & 01001010b = 01001000b
-11001101b & 01001011b = 01001001b
-11001101b & 01001100b = 01001100b
-11001101b & 01001101b = 01001101b
-11001101b & 01001110b = 01001100b
-11001101b & 01001111b = 01001101b
-11001101b & 01010000b = 01000000b
-11001101b & 01010001b = 01000001b
-11001101b & 01010010b = 01000000b
-11001101b & 01010011b = 01000001b
-11001101b & 01010100b = 01000100b
-11001101b & 01010101b = 01000101b
-11001101b & 01010110b = 01000100b
-11001101b & 01010111b = 01000101b
-11001101b & 01011000b = 01001000b
-11001101b & 01011001b = 01001001b
-11001101b & 01011010b = 01001000b
-11001101b & 01011011b = 01001001b
-11001101b & 01011100b = 01001100b
-11001101b & 01011101b = 01001101b
-11001101b & 01011110b = 01001100b
-11001101b & 01011111b = 01001101b
-11001101b & 01100000b = 01000000b
-11001101b & 01100001b = 01000001b
-11001101b & 01100010b = 01000000b
-11001101b & 01100011b = 01000001b
-11001101b & 01100100b = 01000100b
-11001101b & 01100101b = 01000101b
-11001101b & 01100110b = 01000100b
-11001101b & 01100111b = 01000101b
-11001101b & 01101000b = 01001000b
-11001101b & 01101001b = 01001001b
-11001101b & 01101010b = 01001000b
-11001101b & 01101011b = 01001001b
-11001101b & 01101100b = 01001100b
-11001101b & 01101101b = 01001101b
-11001101b & 01101110b = 01001100b
-11001101b & 01101111b = 01001101b
-11001101b & 01110000b = 01000000b
-11001101b & 01110001b = 01000001b
-11001101b & 01110010b = 01000000b
-11001101b & 01110011b = 01000001b
-11001101b & 01110100b = 01000100b
-11001101b & 01110101b = 01000101b
-11001101b & 01110110b = 01000100b
-11001101b & 01110111b = 01000101b
-11001101b & 01111000b = 01001000b
-11001101b & 01111001b = 01001001b
-11001101b & 01111010b = 01001000b
-11001101b & 01111011b = 01001001b
-11001101b & 01111100b = 01001100b
-11001101b & 01111101b = 01001101b
-11001101b & 01111110b = 01001100b
-11001110b & 10000000b = 10000000b
-11001110b & 10000001b = 10000000b
-11001110b & 10000010b = 10000010b
-11001110b & 10000011b = 10000010b
-11001110b & 10000100b = 10000100b
-11001110b & 10000101b = 10000100b
-11001110b & 10000110b = 10000110b
-11001110b & 10000111b = 10000110b
-11001110b & 10001000b = 10001000b
-11001110b & 10001001b = 10001000b
-11001110b & 10001010b = 10001010b
-11001110b & 10001011b = 10001010b
-11001110b & 10001100b = 10001100b
-11001110b & 10001101b = 10001100b
-11001110b & 10001110b = 10001110b
-11001110b & 10001111b = 10001110b
-11001110b & 10010000b = 10000000b
-11001110b & 10010001b = 10000000b
-11001110b & 10010010b = 10000010b
-11001110b & 10010011b = 10000010b
-11001110b & 10010100b = 10000100b
-11001110b & 10010101b = 10000100b
-11001110b & 10010110b = 10000110b
-11001110b & 10010111b = 10000110b
-11001110b & 10011000b = 10001000b
-11001110b & 10011001b = 10001000b
-11001110b & 10011010b = 10001010b
-11001110b & 10011011b = 10001010b
-11001110b & 10011100b = 10001100b
-11001110b & 10011101b = 10001100b
-11001110b & 10011110b = 10001110b
-11001110b & 10011111b = 10001110b
-11001110b & 10100000b = 10000000b
-11001110b & 10100001b = 10000000b
-11001110b & 10100010b = 10000010b
-11001110b & 10100011b = 10000010b
-11001110b & 10100100b = 10000100b
-11001110b & 10100101b = 10000100b
-11001110b & 10100110b = 10000110b
-11001110b & 10100111b = 10000110b
-11001110b & 10101000b = 10001000b
-11001110b & 10101001b = 10001000b
-11001110b & 10101010b = 10001010b
-11001110b & 10101011b = 10001010b
-11001110b & 10101100b = 10001100b
-11001110b & 10101101b = 10001100b
-11001110b & 10101110b = 10001110b
-11001110b & 10101111b = 10001110b
-11001110b & 10110000b = 10000000b
-11001110b & 10110001b = 10000000b
-11001110b & 10110010b = 10000010b
-11001110b & 10110011b = 10000010b
-11001110b & 10110100b = 10000100b
-11001110b & 10110101b = 10000100b
-11001110b & 10110110b = 10000110b
-11001110b & 10110111b = 10000110b
-11001110b & 10111000b = 10001000b
-11001110b & 10111001b = 10001000b
-11001110b & 10111010b = 10001010b
-11001110b & 10111011b = 10001010b
-11001110b & 10111100b = 10001100b
-11001110b & 10111101b = 10001100b
-11001110b & 10111110b = 10001110b
-11001110b & 10111111b = 10001110b
-11001110b & 11000000b = 11000000b
-11001110b & 11000001b = 11000000b
-11001110b & 11000010b = 11000010b
-11001110b & 11000011b = 11000010b
-11001110b & 11000100b = 11000100b
-11001110b & 11000101b = 11000100b
-11001110b & 11000110b = 11000110b
-11001110b & 11000111b = 11000110b
-11001110b & 11001000b = 11001000b
-11001110b & 11001001b = 11001000b
-11001110b & 11001010b = 11001010b
-11001110b & 11001011b = 11001010b
-11001110b & 11001100b = 11001100b
-11001110b & 11001101b = 11001100b
-11001110b & 11001110b = 11001110b
-11001110b & 11001111b = 11001110b
-11001110b & 11010000b = 11000000b
-11001110b & 11010001b = 11000000b
-11001110b & 11010010b = 11000010b
-11001110b & 11010011b = 11000010b
-11001110b & 11010100b = 11000100b
-11001110b & 11010101b = 11000100b
-11001110b & 11010110b = 11000110b
-11001110b & 11010111b = 11000110b
-11001110b & 11011000b = 11001000b
-11001110b & 11011001b = 11001000b
-11001110b & 11011010b = 11001010b
-11001110b & 11011011b = 11001010b
-11001110b & 11011100b = 11001100b
-11001110b & 11011101b = 11001100b
-11001110b & 11011110b = 11001110b
-11001110b & 11011111b = 11001110b
-11001110b & 11100000b = 11000000b
-11001110b & 11100001b = 11000000b
-11001110b & 11100010b = 11000010b
-11001110b & 11100011b = 11000010b
-11001110b & 11100100b = 11000100b
-11001110b & 11100101b = 11000100b
-11001110b & 11100110b = 11000110b
-11001110b & 11100111b = 11000110b
-11001110b & 11101000b = 11001000b
-11001110b & 11101001b = 11001000b
-11001110b & 11101010b = 11001010b
-11001110b & 11101011b = 11001010b
-11001110b & 11101100b = 11001100b
-11001110b & 11101101b = 11001100b
-11001110b & 11101110b = 11001110b
-11001110b & 11101111b = 11001110b
-11001110b & 11110000b = 11000000b
-11001110b & 11110001b = 11000000b
-11001110b & 11110010b = 11000010b
-11001110b & 11110011b = 11000010b
-11001110b & 11110100b = 11000100b
-11001110b & 11110101b = 11000100b
-11001110b & 11110110b = 11000110b
-11001110b & 11110111b = 11000110b
-11001110b & 11111000b = 11001000b
-11001110b & 11111001b = 11001000b
-11001110b & 11111010b = 11001010b
-11001110b & 11111011b = 11001010b
-11001110b & 11111100b = 11001100b
-11001110b & 11111101b = 11001100b
-11001110b & 11111110b = 11001110b
-11001110b & 11111111b = 11001110b
-11001110b & 00000000b = 00000000b
-11001110b & 00000001b = 00000000b
-11001110b & 00000010b = 00000010b
-11001110b & 00000011b = 00000010b
-11001110b & 00000100b = 00000100b
-11001110b & 00000101b = 00000100b
-11001110b & 00000110b = 00000110b
-11001110b & 00000111b = 00000110b
-11001110b & 00001000b = 00001000b
-11001110b & 00001001b = 00001000b
-11001110b & 00001010b = 00001010b
-11001110b & 00001011b = 00001010b
-11001110b & 00001100b = 00001100b
-11001110b & 00001101b = 00001100b
-11001110b & 00001110b = 00001110b
-11001110b & 00001111b = 00001110b
-11001110b & 00010000b = 00000000b
-11001110b & 00010001b = 00000000b
-11001110b & 00010010b = 00000010b
-11001110b & 00010011b = 00000010b
-11001110b & 00010100b = 00000100b
-11001110b & 00010101b = 00000100b
-11001110b & 00010110b = 00000110b
-11001110b & 00010111b = 00000110b
-11001110b & 00011000b = 00001000b
-11001110b & 00011001b = 00001000b
-11001110b & 00011010b = 00001010b
-11001110b & 00011011b = 00001010b
-11001110b & 00011100b = 00001100b
-11001110b & 00011101b = 00001100b
-11001110b & 00011110b = 00001110b
-11001110b & 00011111b = 00001110b
-11001110b & 00100000b = 00000000b
-11001110b & 00100001b = 00000000b
-11001110b & 00100010b = 00000010b
-11001110b & 00100011b = 00000010b
-11001110b & 00100100b = 00000100b
-11001110b & 00100101b = 00000100b
-11001110b & 00100110b = 00000110b
-11001110b & 00100111b = 00000110b
-11001110b & 00101000b = 00001000b
-11001110b & 00101001b = 00001000b
-11001110b & 00101010b = 00001010b
-11001110b & 00101011b = 00001010b
-11001110b & 00101100b = 00001100b
-11001110b & 00101101b = 00001100b
-11001110b & 00101110b = 00001110b
-11001110b & 00101111b = 00001110b
-11001110b & 00110000b = 00000000b
-11001110b & 00110001b = 00000000b
-11001110b & 00110010b = 00000010b
-11001110b & 00110011b = 00000010b
-11001110b & 00110100b = 00000100b
-11001110b & 00110101b = 00000100b
-11001110b & 00110110b = 00000110b
-11001110b & 00110111b = 00000110b
-11001110b & 00111000b = 00001000b
-11001110b & 00111001b = 00001000b
-11001110b & 00111010b = 00001010b
-11001110b & 00111011b = 00001010b
-11001110b & 00111100b = 00001100b
-11001110b & 00111101b = 00001100b
-11001110b & 00111110b = 00001110b
-11001110b & 00111111b = 00001110b
-11001110b & 01000000b = 01000000b
-11001110b & 01000001b = 01000000b
-11001110b & 01000010b = 01000010b
-11001110b & 01000011b = 01000010b
-11001110b & 01000100b = 01000100b
-11001110b & 01000101b = 01000100b
-11001110b & 01000110b = 01000110b
-11001110b & 01000111b = 01000110b
-11001110b & 01001000b = 01001000b
-11001110b & 01001001b = 01001000b
-11001110b & 01001010b = 01001010b
-11001110b & 01001011b = 01001010b
-11001110b & 01001100b = 01001100b
-11001110b & 01001101b = 01001100b
-11001110b & 01001110b = 01001110b
-11001110b & 01001111b = 01001110b
-11001110b & 01010000b = 01000000b
-11001110b & 01010001b = 01000000b
-11001110b & 01010010b = 01000010b
-11001110b & 01010011b = 01000010b
-11001110b & 01010100b = 01000100b
-11001110b & 01010101b = 01000100b
-11001110b & 01010110b = 01000110b
-11001110b & 01010111b = 01000110b
-11001110b & 01011000b = 01001000b
-11001110b & 01011001b = 01001000b
-11001110b & 01011010b = 01001010b
-11001110b & 01011011b = 01001010b
-11001110b & 01011100b = 01001100b
-11001110b & 01011101b = 01001100b
-11001110b & 01011110b = 01001110b
-11001110b & 01011111b = 01001110b
-11001110b & 01100000b = 01000000b
-11001110b & 01100001b = 01000000b
-11001110b & 01100010b = 01000010b
-11001110b & 01100011b = 01000010b
-11001110b & 01100100b = 01000100b
-11001110b & 01100101b = 01000100b
-11001110b & 01100110b = 01000110b
-11001110b & 01100111b = 01000110b
-11001110b & 01101000b = 01001000b
-11001110b & 01101001b = 01001000b
-11001110b & 01101010b = 01001010b
-11001110b & 01101011b = 01001010b
-11001110b & 01101100b = 01001100b
-11001110b & 01101101b = 01001100b
-11001110b & 01101110b = 01001110b
-11001110b & 01101111b = 01001110b
-11001110b & 01110000b = 01000000b
-11001110b & 01110001b = 01000000b
-11001110b & 01110010b = 01000010b
-11001110b & 01110011b = 01000010b
-11001110b & 01110100b = 01000100b
-11001110b & 01110101b = 01000100b
-11001110b & 01110110b = 01000110b
-11001110b & 01110111b = 01000110b
-11001110b & 01111000b = 01001000b
-11001110b & 01111001b = 01001000b
-11001110b & 01111010b = 01001010b
-11001110b & 01111011b = 01001010b
-11001110b & 01111100b = 01001100b
-11001110b & 01111101b = 01001100b
-11001110b & 01111110b = 01001110b
-11001111b & 10000000b = 10000000b
-11001111b & 10000001b = 10000001b
-11001111b & 10000010b = 10000010b
-11001111b & 10000011b = 10000011b
-11001111b & 10000100b = 10000100b
-11001111b & 10000101b = 10000101b
-11001111b & 10000110b = 10000110b
-11001111b & 10000111b = 10000111b
-11001111b & 10001000b = 10001000b
-11001111b & 10001001b = 10001001b
-11001111b & 10001010b = 10001010b
-11001111b & 10001011b = 10001011b
-11001111b & 10001100b = 10001100b
-11001111b & 10001101b = 10001101b
-11001111b & 10001110b = 10001110b
-11001111b & 10001111b = 10001111b
-11001111b & 10010000b = 10000000b
-11001111b & 10010001b = 10000001b
-11001111b & 10010010b = 10000010b
-11001111b & 10010011b = 10000011b
-11001111b & 10010100b = 10000100b
-11001111b & 10010101b = 10000101b
-11001111b & 10010110b = 10000110b
-11001111b & 10010111b = 10000111b
-11001111b & 10011000b = 10001000b
-11001111b & 10011001b = 10001001b
-11001111b & 10011010b = 10001010b
-11001111b & 10011011b = 10001011b
-11001111b & 10011100b = 10001100b
-11001111b & 10011101b = 10001101b
-11001111b & 10011110b = 10001110b
-11001111b & 10011111b = 10001111b
-11001111b & 10100000b = 10000000b
-11001111b & 10100001b = 10000001b
-11001111b & 10100010b = 10000010b
-11001111b & 10100011b = 10000011b
-11001111b & 10100100b = 10000100b
-11001111b & 10100101b = 10000101b
-11001111b & 10100110b = 10000110b
-11001111b & 10100111b = 10000111b
-11001111b & 10101000b = 10001000b
-11001111b & 10101001b = 10001001b
-11001111b & 10101010b = 10001010b
-11001111b & 10101011b = 10001011b
-11001111b & 10101100b = 10001100b
-11001111b & 10101101b = 10001101b
-11001111b & 10101110b = 10001110b
-11001111b & 10101111b = 10001111b
-11001111b & 10110000b = 10000000b
-11001111b & 10110001b = 10000001b
-11001111b & 10110010b = 10000010b
-11001111b & 10110011b = 10000011b
-11001111b & 10110100b = 10000100b
-11001111b & 10110101b = 10000101b
-11001111b & 10110110b = 10000110b
-11001111b & 10110111b = 10000111b
-11001111b & 10111000b = 10001000b
-11001111b & 10111001b = 10001001b
-11001111b & 10111010b = 10001010b
-11001111b & 10111011b = 10001011b
-11001111b & 10111100b = 10001100b
-11001111b & 10111101b = 10001101b
-11001111b & 10111110b = 10001110b
-11001111b & 10111111b = 10001111b
-11001111b & 11000000b = 11000000b
-11001111b & 11000001b = 11000001b
-11001111b & 11000010b = 11000010b
-11001111b & 11000011b = 11000011b
-11001111b & 11000100b = 11000100b
-11001111b & 11000101b = 11000101b
-11001111b & 11000110b = 11000110b
-11001111b & 11000111b = 11000111b
-11001111b & 11001000b = 11001000b
-11001111b & 11001001b = 11001001b
-11001111b & 11001010b = 11001010b
-11001111b & 11001011b = 11001011b
-11001111b & 11001100b = 11001100b
-11001111b & 11001101b = 11001101b
-11001111b & 11001110b = 11001110b
-11001111b & 11001111b = 11001111b
-11001111b & 11010000b = 11000000b
-11001111b & 11010001b = 11000001b
-11001111b & 11010010b = 11000010b
-11001111b & 11010011b = 11000011b
-11001111b & 11010100b = 11000100b
-11001111b & 11010101b = 11000101b
-11001111b & 11010110b = 11000110b
-11001111b & 11010111b = 11000111b
-11001111b & 11011000b = 11001000b
-11001111b & 11011001b = 11001001b
-11001111b & 11011010b = 11001010b
-11001111b & 11011011b = 11001011b
-11001111b & 11011100b = 11001100b
-11001111b & 11011101b = 11001101b
-11001111b & 11011110b = 11001110b
-11001111b & 11011111b = 11001111b
-11001111b & 11100000b = 11000000b
-11001111b & 11100001b = 11000001b
-11001111b & 11100010b = 11000010b
-11001111b & 11100011b = 11000011b
-11001111b & 11100100b = 11000100b
-11001111b & 11100101b = 11000101b
-11001111b & 11100110b = 11000110b
-11001111b & 11100111b = 11000111b
-11001111b & 11101000b = 11001000b
-11001111b & 11101001b = 11001001b
-11001111b & 11101010b = 11001010b
-11001111b & 11101011b = 11001011b
-11001111b & 11101100b = 11001100b
-11001111b & 11101101b = 11001101b
-11001111b & 11101110b = 11001110b
-11001111b & 11101111b = 11001111b
-11001111b & 11110000b = 11000000b
-11001111b & 11110001b = 11000001b
-11001111b & 11110010b = 11000010b
-11001111b & 11110011b = 11000011b
-11001111b & 11110100b = 11000100b
-11001111b & 11110101b = 11000101b
-11001111b & 11110110b = 11000110b
-11001111b & 11110111b = 11000111b
-11001111b & 11111000b = 11001000b
-11001111b & 11111001b = 11001001b
-11001111b & 11111010b = 11001010b
-11001111b & 11111011b = 11001011b
-11001111b & 11111100b = 11001100b
-11001111b & 11111101b = 11001101b
-11001111b & 11111110b = 11001110b
-11001111b & 11111111b = 11001111b
-11001111b & 00000000b = 00000000b
-11001111b & 00000001b = 00000001b
-11001111b & 00000010b = 00000010b
-11001111b & 00000011b = 00000011b
-11001111b & 00000100b = 00000100b
-11001111b & 00000101b = 00000101b
-11001111b & 00000110b = 00000110b
-11001111b & 00000111b = 00000111b
-11001111b & 00001000b = 00001000b
-11001111b & 00001001b = 00001001b
-11001111b & 00001010b = 00001010b
-11001111b & 00001011b = 00001011b
-11001111b & 00001100b = 00001100b
-11001111b & 00001101b = 00001101b
-11001111b & 00001110b = 00001110b
-11001111b & 00001111b = 00001111b
-11001111b & 00010000b = 00000000b
-11001111b & 00010001b = 00000001b
-11001111b & 00010010b = 00000010b
-11001111b & 00010011b = 00000011b
-11001111b & 00010100b = 00000100b
-11001111b & 00010101b = 00000101b
-11001111b & 00010110b = 00000110b
-11001111b & 00010111b = 00000111b
-11001111b & 00011000b = 00001000b
-11001111b & 00011001b = 00001001b
-11001111b & 00011010b = 00001010b
-11001111b & 00011011b = 00001011b
-11001111b & 00011100b = 00001100b
-11001111b & 00011101b = 00001101b
-11001111b & 00011110b = 00001110b
-11001111b & 00011111b = 00001111b
-11001111b & 00100000b = 00000000b
-11001111b & 00100001b = 00000001b
-11001111b & 00100010b = 00000010b
-11001111b & 00100011b = 00000011b
-11001111b & 00100100b = 00000100b
-11001111b & 00100101b = 00000101b
-11001111b & 00100110b = 00000110b
-11001111b & 00100111b = 00000111b
-11001111b & 00101000b = 00001000b
-11001111b & 00101001b = 00001001b
-11001111b & 00101010b = 00001010b
-11001111b & 00101011b = 00001011b
-11001111b & 00101100b = 00001100b
-11001111b & 00101101b = 00001101b
-11001111b & 00101110b = 00001110b
-11001111b & 00101111b = 00001111b
-11001111b & 00110000b = 00000000b
-11001111b & 00110001b = 00000001b
-11001111b & 00110010b = 00000010b
-11001111b & 00110011b = 00000011b
-11001111b & 00110100b = 00000100b
-11001111b & 00110101b = 00000101b
-11001111b & 00110110b = 00000110b
-11001111b & 00110111b = 00000111b
-11001111b & 00111000b = 00001000b
-11001111b & 00111001b = 00001001b
-11001111b & 00111010b = 00001010b
-11001111b & 00111011b = 00001011b
-11001111b & 00111100b = 00001100b
-11001111b & 00111101b = 00001101b
-11001111b & 00111110b = 00001110b
-11001111b & 00111111b = 00001111b
-11001111b & 01000000b = 01000000b
-11001111b & 01000001b = 01000001b
-11001111b & 01000010b = 01000010b
-11001111b & 01000011b = 01000011b
-11001111b & 01000100b = 01000100b
-11001111b & 01000101b = 01000101b
-11001111b & 01000110b = 01000110b
-11001111b & 01000111b = 01000111b
-11001111b & 01001000b = 01001000b
-11001111b & 01001001b = 01001001b
-11001111b & 01001010b = 01001010b
-11001111b & 01001011b = 01001011b
-11001111b & 01001100b = 01001100b
-11001111b & 01001101b = 01001101b
-11001111b & 01001110b = 01001110b
-11001111b & 01001111b = 01001111b
-11001111b & 01010000b = 01000000b
-11001111b & 01010001b = 01000001b
-11001111b & 01010010b = 01000010b
-11001111b & 01010011b = 01000011b
-11001111b & 01010100b = 01000100b
-11001111b & 01010101b = 01000101b
-11001111b & 01010110b = 01000110b
-11001111b & 01010111b = 01000111b
-11001111b & 01011000b = 01001000b
-11001111b & 01011001b = 01001001b
-11001111b & 01011010b = 01001010b
-11001111b & 01011011b = 01001011b
-11001111b & 01011100b = 01001100b
-11001111b & 01011101b = 01001101b
-11001111b & 01011110b = 01001110b
-11001111b & 01011111b = 01001111b
-11001111b & 01100000b = 01000000b
-11001111b & 01100001b = 01000001b
-11001111b & 01100010b = 01000010b
-11001111b & 01100011b = 01000011b
-11001111b & 01100100b = 01000100b
-11001111b & 01100101b = 01000101b
-11001111b & 01100110b = 01000110b
-11001111b & 01100111b = 01000111b
-11001111b & 01101000b = 01001000b
-11001111b & 01101001b = 01001001b
-11001111b & 01101010b = 01001010b
-11001111b & 01101011b = 01001011b
-11001111b & 01101100b = 01001100b
-11001111b & 01101101b = 01001101b
-11001111b & 01101110b = 01001110b
-11001111b & 01101111b = 01001111b
-11001111b & 01110000b = 01000000b
-11001111b & 01110001b = 01000001b
-11001111b & 01110010b = 01000010b
-11001111b & 01110011b = 01000011b
-11001111b & 01110100b = 01000100b
-11001111b & 01110101b = 01000101b
-11001111b & 01110110b = 01000110b
-11001111b & 01110111b = 01000111b
-11001111b & 01111000b = 01001000b
-11001111b & 01111001b = 01001001b
-11001111b & 01111010b = 01001010b
-11001111b & 01111011b = 01001011b
-11001111b & 01111100b = 01001100b
-11001111b & 01111101b = 01001101b
-11001111b & 01111110b = 01001110b
-11010000b & 10000000b = 10000000b
-11010000b & 10000001b = 10000000b
-11010000b & 10000010b = 10000000b
-11010000b & 10000011b = 10000000b
-11010000b & 10000100b = 10000000b
-11010000b & 10000101b = 10000000b
-11010000b & 10000110b = 10000000b
-11010000b & 10000111b = 10000000b
-11010000b & 10001000b = 10000000b
-11010000b & 10001001b = 10000000b
-11010000b & 10001010b = 10000000b
-11010000b & 10001011b = 10000000b
-11010000b & 10001100b = 10000000b
-11010000b & 10001101b = 10000000b
-11010000b & 10001110b = 10000000b
-11010000b & 10001111b = 10000000b
-11010000b & 10010000b = 10010000b
-11010000b & 10010001b = 10010000b
-11010000b & 10010010b = 10010000b
-11010000b & 10010011b = 10010000b
-11010000b & 10010100b = 10010000b
-11010000b & 10010101b = 10010000b
-11010000b & 10010110b = 10010000b
-11010000b & 10010111b = 10010000b
-11010000b & 10011000b = 10010000b
-11010000b & 10011001b = 10010000b
-11010000b & 10011010b = 10010000b
-11010000b & 10011011b = 10010000b
-11010000b & 10011100b = 10010000b
-11010000b & 10011101b = 10010000b
-11010000b & 10011110b = 10010000b
-11010000b & 10011111b = 10010000b
-11010000b & 10100000b = 10000000b
-11010000b & 10100001b = 10000000b
-11010000b & 10100010b = 10000000b
-11010000b & 10100011b = 10000000b
-11010000b & 10100100b = 10000000b
-11010000b & 10100101b = 10000000b
-11010000b & 10100110b = 10000000b
-11010000b & 10100111b = 10000000b
-11010000b & 10101000b = 10000000b
-11010000b & 10101001b = 10000000b
-11010000b & 10101010b = 10000000b
-11010000b & 10101011b = 10000000b
-11010000b & 10101100b = 10000000b
-11010000b & 10101101b = 10000000b
-11010000b & 10101110b = 10000000b
-11010000b & 10101111b = 10000000b
-11010000b & 10110000b = 10010000b
-11010000b & 10110001b = 10010000b
-11010000b & 10110010b = 10010000b
-11010000b & 10110011b = 10010000b
-11010000b & 10110100b = 10010000b
-11010000b & 10110101b = 10010000b
-11010000b & 10110110b = 10010000b
-11010000b & 10110111b = 10010000b
-11010000b & 10111000b = 10010000b
-11010000b & 10111001b = 10010000b
-11010000b & 10111010b = 10010000b
-11010000b & 10111011b = 10010000b
-11010000b & 10111100b = 10010000b
-11010000b & 10111101b = 10010000b
-11010000b & 10111110b = 10010000b
-11010000b & 10111111b = 10010000b
-11010000b & 11000000b = 11000000b
-11010000b & 11000001b = 11000000b
-11010000b & 11000010b = 11000000b
-11010000b & 11000011b = 11000000b
-11010000b & 11000100b = 11000000b
-11010000b & 11000101b = 11000000b
-11010000b & 11000110b = 11000000b
-11010000b & 11000111b = 11000000b
-11010000b & 11001000b = 11000000b
-11010000b & 11001001b = 11000000b
-11010000b & 11001010b = 11000000b
-11010000b & 11001011b = 11000000b
-11010000b & 11001100b = 11000000b
-11010000b & 11001101b = 11000000b
-11010000b & 11001110b = 11000000b
-11010000b & 11001111b = 11000000b
-11010000b & 11010000b = 11010000b
-11010000b & 11010001b = 11010000b
-11010000b & 11010010b = 11010000b
-11010000b & 11010011b = 11010000b
-11010000b & 11010100b = 11010000b
-11010000b & 11010101b = 11010000b
-11010000b & 11010110b = 11010000b
-11010000b & 11010111b = 11010000b
-11010000b & 11011000b = 11010000b
-11010000b & 11011001b = 11010000b
-11010000b & 11011010b = 11010000b
-11010000b & 11011011b = 11010000b
-11010000b & 11011100b = 11010000b
-11010000b & 11011101b = 11010000b
-11010000b & 11011110b = 11010000b
-11010000b & 11011111b = 11010000b
-11010000b & 11100000b = 11000000b
-11010000b & 11100001b = 11000000b
-11010000b & 11100010b = 11000000b
-11010000b & 11100011b = 11000000b
-11010000b & 11100100b = 11000000b
-11010000b & 11100101b = 11000000b
-11010000b & 11100110b = 11000000b
-11010000b & 11100111b = 11000000b
-11010000b & 11101000b = 11000000b
-11010000b & 11101001b = 11000000b
-11010000b & 11101010b = 11000000b
-11010000b & 11101011b = 11000000b
-11010000b & 11101100b = 11000000b
-11010000b & 11101101b = 11000000b
-11010000b & 11101110b = 11000000b
-11010000b & 11101111b = 11000000b
-11010000b & 11110000b = 11010000b
-11010000b & 11110001b = 11010000b
-11010000b & 11110010b = 11010000b
-11010000b & 11110011b = 11010000b
-11010000b & 11110100b = 11010000b
-11010000b & 11110101b = 11010000b
-11010000b & 11110110b = 11010000b
-11010000b & 11110111b = 11010000b
-11010000b & 11111000b = 11010000b
-11010000b & 11111001b = 11010000b
-11010000b & 11111010b = 11010000b
-11010000b & 11111011b = 11010000b
-11010000b & 11111100b = 11010000b
-11010000b & 11111101b = 11010000b
-11010000b & 11111110b = 11010000b
-11010000b & 11111111b = 11010000b
-11010000b & 00000000b = 00000000b
-11010000b & 00000001b = 00000000b
-11010000b & 00000010b = 00000000b
-11010000b & 00000011b = 00000000b
-11010000b & 00000100b = 00000000b
-11010000b & 00000101b = 00000000b
-11010000b & 00000110b = 00000000b
-11010000b & 00000111b = 00000000b
-11010000b & 00001000b = 00000000b
-11010000b & 00001001b = 00000000b
-11010000b & 00001010b = 00000000b
-11010000b & 00001011b = 00000000b
-11010000b & 00001100b = 00000000b
-11010000b & 00001101b = 00000000b
-11010000b & 00001110b = 00000000b
-11010000b & 00001111b = 00000000b
-11010000b & 00010000b = 00010000b
-11010000b & 00010001b = 00010000b
-11010000b & 00010010b = 00010000b
-11010000b & 00010011b = 00010000b
-11010000b & 00010100b = 00010000b
-11010000b & 00010101b = 00010000b
-11010000b & 00010110b = 00010000b
-11010000b & 00010111b = 00010000b
-11010000b & 00011000b = 00010000b
-11010000b & 00011001b = 00010000b
-11010000b & 00011010b = 00010000b
-11010000b & 00011011b = 00010000b
-11010000b & 00011100b = 00010000b
-11010000b & 00011101b = 00010000b
-11010000b & 00011110b = 00010000b
-11010000b & 00011111b = 00010000b
-11010000b & 00100000b = 00000000b
-11010000b & 00100001b = 00000000b
-11010000b & 00100010b = 00000000b
-11010000b & 00100011b = 00000000b
-11010000b & 00100100b = 00000000b
-11010000b & 00100101b = 00000000b
-11010000b & 00100110b = 00000000b
-11010000b & 00100111b = 00000000b
-11010000b & 00101000b = 00000000b
-11010000b & 00101001b = 00000000b
-11010000b & 00101010b = 00000000b
-11010000b & 00101011b = 00000000b
-11010000b & 00101100b = 00000000b
-11010000b & 00101101b = 00000000b
-11010000b & 00101110b = 00000000b
-11010000b & 00101111b = 00000000b
-11010000b & 00110000b = 00010000b
-11010000b & 00110001b = 00010000b
-11010000b & 00110010b = 00010000b
-11010000b & 00110011b = 00010000b
-11010000b & 00110100b = 00010000b
-11010000b & 00110101b = 00010000b
-11010000b & 00110110b = 00010000b
-11010000b & 00110111b = 00010000b
-11010000b & 00111000b = 00010000b
-11010000b & 00111001b = 00010000b
-11010000b & 00111010b = 00010000b
-11010000b & 00111011b = 00010000b
-11010000b & 00111100b = 00010000b
-11010000b & 00111101b = 00010000b
-11010000b & 00111110b = 00010000b
-11010000b & 00111111b = 00010000b
-11010000b & 01000000b = 01000000b
-11010000b & 01000001b = 01000000b
-11010000b & 01000010b = 01000000b
-11010000b & 01000011b = 01000000b
-11010000b & 01000100b = 01000000b
-11010000b & 01000101b = 01000000b
-11010000b & 01000110b = 01000000b
-11010000b & 01000111b = 01000000b
-11010000b & 01001000b = 01000000b
-11010000b & 01001001b = 01000000b
-11010000b & 01001010b = 01000000b
-11010000b & 01001011b = 01000000b
-11010000b & 01001100b = 01000000b
-11010000b & 01001101b = 01000000b
-11010000b & 01001110b = 01000000b
-11010000b & 01001111b = 01000000b
-11010000b & 01010000b = 01010000b
-11010000b & 01010001b = 01010000b
-11010000b & 01010010b = 01010000b
-11010000b & 01010011b = 01010000b
-11010000b & 01010100b = 01010000b
-11010000b & 01010101b = 01010000b
-11010000b & 01010110b = 01010000b
-11010000b & 01010111b = 01010000b
-11010000b & 01011000b = 01010000b
-11010000b & 01011001b = 01010000b
-11010000b & 01011010b = 01010000b
-11010000b & 01011011b = 01010000b
-11010000b & 01011100b = 01010000b
-11010000b & 01011101b = 01010000b
-11010000b & 01011110b = 01010000b
-11010000b & 01011111b = 01010000b
-11010000b & 01100000b = 01000000b
-11010000b & 01100001b = 01000000b
-11010000b & 01100010b = 01000000b
-11010000b & 01100011b = 01000000b
-11010000b & 01100100b = 01000000b
-11010000b & 01100101b = 01000000b
-11010000b & 01100110b = 01000000b
-11010000b & 01100111b = 01000000b
-11010000b & 01101000b = 01000000b
-11010000b & 01101001b = 01000000b
-11010000b & 01101010b = 01000000b
-11010000b & 01101011b = 01000000b
-11010000b & 01101100b = 01000000b
-11010000b & 01101101b = 01000000b
-11010000b & 01101110b = 01000000b
-11010000b & 01101111b = 01000000b
-11010000b & 01110000b = 01010000b
-11010000b & 01110001b = 01010000b
-11010000b & 01110010b = 01010000b
-11010000b & 01110011b = 01010000b
-11010000b & 01110100b = 01010000b
-11010000b & 01110101b = 01010000b
-11010000b & 01110110b = 01010000b
-11010000b & 01110111b = 01010000b
-11010000b & 01111000b = 01010000b
-11010000b & 01111001b = 01010000b
-11010000b & 01111010b = 01010000b
-11010000b & 01111011b = 01010000b
-11010000b & 01111100b = 01010000b
-11010000b & 01111101b = 01010000b
-11010000b & 01111110b = 01010000b
-11010001b & 10000000b = 10000000b
-11010001b & 10000001b = 10000001b
-11010001b & 10000010b = 10000000b
-11010001b & 10000011b = 10000001b
-11010001b & 10000100b = 10000000b
-11010001b & 10000101b = 10000001b
-11010001b & 10000110b = 10000000b
-11010001b & 10000111b = 10000001b
-11010001b & 10001000b = 10000000b
-11010001b & 10001001b = 10000001b
-11010001b & 10001010b = 10000000b
-11010001b & 10001011b = 10000001b
-11010001b & 10001100b = 10000000b
-11010001b & 10001101b = 10000001b
-11010001b & 10001110b = 10000000b
-11010001b & 10001111b = 10000001b
-11010001b & 10010000b = 10010000b
-11010001b & 10010001b = 10010001b
-11010001b & 10010010b = 10010000b
-11010001b & 10010011b = 10010001b
-11010001b & 10010100b = 10010000b
-11010001b & 10010101b = 10010001b
-11010001b & 10010110b = 10010000b
-11010001b & 10010111b = 10010001b
-11010001b & 10011000b = 10010000b
-11010001b & 10011001b = 10010001b
-11010001b & 10011010b = 10010000b
-11010001b & 10011011b = 10010001b
-11010001b & 10011100b = 10010000b
-11010001b & 10011101b = 10010001b
-11010001b & 10011110b = 10010000b
-11010001b & 10011111b = 10010001b
-11010001b & 10100000b = 10000000b
-11010001b & 10100001b = 10000001b
-11010001b & 10100010b = 10000000b
-11010001b & 10100011b = 10000001b
-11010001b & 10100100b = 10000000b
-11010001b & 10100101b = 10000001b
-11010001b & 10100110b = 10000000b
-11010001b & 10100111b = 10000001b
-11010001b & 10101000b = 10000000b
-11010001b & 10101001b = 10000001b
-11010001b & 10101010b = 10000000b
-11010001b & 10101011b = 10000001b
-11010001b & 10101100b = 10000000b
-11010001b & 10101101b = 10000001b
-11010001b & 10101110b = 10000000b
-11010001b & 10101111b = 10000001b
-11010001b & 10110000b = 10010000b
-11010001b & 10110001b = 10010001b
-11010001b & 10110010b = 10010000b
-11010001b & 10110011b = 10010001b
-11010001b & 10110100b = 10010000b
-11010001b & 10110101b = 10010001b
-11010001b & 10110110b = 10010000b
-11010001b & 10110111b = 10010001b
-11010001b & 10111000b = 10010000b
-11010001b & 10111001b = 10010001b
-11010001b & 10111010b = 10010000b
-11010001b & 10111011b = 10010001b
-11010001b & 10111100b = 10010000b
-11010001b & 10111101b = 10010001b
-11010001b & 10111110b = 10010000b
-11010001b & 10111111b = 10010001b
-11010001b & 11000000b = 11000000b
-11010001b & 11000001b = 11000001b
-11010001b & 11000010b = 11000000b
-11010001b & 11000011b = 11000001b
-11010001b & 11000100b = 11000000b
-11010001b & 11000101b = 11000001b
-11010001b & 11000110b = 11000000b
-11010001b & 11000111b = 11000001b
-11010001b & 11001000b = 11000000b
-11010001b & 11001001b = 11000001b
-11010001b & 11001010b = 11000000b
-11010001b & 11001011b = 11000001b
-11010001b & 11001100b = 11000000b
-11010001b & 11001101b = 11000001b
-11010001b & 11001110b = 11000000b
-11010001b & 11001111b = 11000001b
-11010001b & 11010000b = 11010000b
-11010001b & 11010001b = 11010001b
-11010001b & 11010010b = 11010000b
-11010001b & 11010011b = 11010001b
-11010001b & 11010100b = 11010000b
-11010001b & 11010101b = 11010001b
-11010001b & 11010110b = 11010000b
-11010001b & 11010111b = 11010001b
-11010001b & 11011000b = 11010000b
-11010001b & 11011001b = 11010001b
-11010001b & 11011010b = 11010000b
-11010001b & 11011011b = 11010001b
-11010001b & 11011100b = 11010000b
-11010001b & 11011101b = 11010001b
-11010001b & 11011110b = 11010000b
-11010001b & 11011111b = 11010001b
-11010001b & 11100000b = 11000000b
-11010001b & 11100001b = 11000001b
-11010001b & 11100010b = 11000000b
-11010001b & 11100011b = 11000001b
-11010001b & 11100100b = 11000000b
-11010001b & 11100101b = 11000001b
-11010001b & 11100110b = 11000000b
-11010001b & 11100111b = 11000001b
-11010001b & 11101000b = 11000000b
-11010001b & 11101001b = 11000001b
-11010001b & 11101010b = 11000000b
-11010001b & 11101011b = 11000001b
-11010001b & 11101100b = 11000000b
-11010001b & 11101101b = 11000001b
-11010001b & 11101110b = 11000000b
-11010001b & 11101111b = 11000001b
-11010001b & 11110000b = 11010000b
-11010001b & 11110001b = 11010001b
-11010001b & 11110010b = 11010000b
-11010001b & 11110011b = 11010001b
-11010001b & 11110100b = 11010000b
-11010001b & 11110101b = 11010001b
-11010001b & 11110110b = 11010000b
-11010001b & 11110111b = 11010001b
-11010001b & 11111000b = 11010000b
-11010001b & 11111001b = 11010001b
-11010001b & 11111010b = 11010000b
-11010001b & 11111011b = 11010001b
-11010001b & 11111100b = 11010000b
-11010001b & 11111101b = 11010001b
-11010001b & 11111110b = 11010000b
-11010001b & 11111111b = 11010001b
-11010001b & 00000000b = 00000000b
-11010001b & 00000001b = 00000001b
-11010001b & 00000010b = 00000000b
-11010001b & 00000011b = 00000001b
-11010001b & 00000100b = 00000000b
-11010001b & 00000101b = 00000001b
-11010001b & 00000110b = 00000000b
-11010001b & 00000111b = 00000001b
-11010001b & 00001000b = 00000000b
-11010001b & 00001001b = 00000001b
-11010001b & 00001010b = 00000000b
-11010001b & 00001011b = 00000001b
-11010001b & 00001100b = 00000000b
-11010001b & 00001101b = 00000001b
-11010001b & 00001110b = 00000000b
-11010001b & 00001111b = 00000001b
-11010001b & 00010000b = 00010000b
-11010001b & 00010001b = 00010001b
-11010001b & 00010010b = 00010000b
-11010001b & 00010011b = 00010001b
-11010001b & 00010100b = 00010000b
-11010001b & 00010101b = 00010001b
-11010001b & 00010110b = 00010000b
-11010001b & 00010111b = 00010001b
-11010001b & 00011000b = 00010000b
-11010001b & 00011001b = 00010001b
-11010001b & 00011010b = 00010000b
-11010001b & 00011011b = 00010001b
-11010001b & 00011100b = 00010000b
-11010001b & 00011101b = 00010001b
-11010001b & 00011110b = 00010000b
-11010001b & 00011111b = 00010001b
-11010001b & 00100000b = 00000000b
-11010001b & 00100001b = 00000001b
-11010001b & 00100010b = 00000000b
-11010001b & 00100011b = 00000001b
-11010001b & 00100100b = 00000000b
-11010001b & 00100101b = 00000001b
-11010001b & 00100110b = 00000000b
-11010001b & 00100111b = 00000001b
-11010001b & 00101000b = 00000000b
-11010001b & 00101001b = 00000001b
-11010001b & 00101010b = 00000000b
-11010001b & 00101011b = 00000001b
-11010001b & 00101100b = 00000000b
-11010001b & 00101101b = 00000001b
-11010001b & 00101110b = 00000000b
-11010001b & 00101111b = 00000001b
-11010001b & 00110000b = 00010000b
-11010001b & 00110001b = 00010001b
-11010001b & 00110010b = 00010000b
-11010001b & 00110011b = 00010001b
-11010001b & 00110100b = 00010000b
-11010001b & 00110101b = 00010001b
-11010001b & 00110110b = 00010000b
-11010001b & 00110111b = 00010001b
-11010001b & 00111000b = 00010000b
-11010001b & 00111001b = 00010001b
-11010001b & 00111010b = 00010000b
-11010001b & 00111011b = 00010001b
-11010001b & 00111100b = 00010000b
-11010001b & 00111101b = 00010001b
-11010001b & 00111110b = 00010000b
-11010001b & 00111111b = 00010001b
-11010001b & 01000000b = 01000000b
-11010001b & 01000001b = 01000001b
-11010001b & 01000010b = 01000000b
-11010001b & 01000011b = 01000001b
-11010001b & 01000100b = 01000000b
-11010001b & 01000101b = 01000001b
-11010001b & 01000110b = 01000000b
-11010001b & 01000111b = 01000001b
-11010001b & 01001000b = 01000000b
-11010001b & 01001001b = 01000001b
-11010001b & 01001010b = 01000000b
-11010001b & 01001011b = 01000001b
-11010001b & 01001100b = 01000000b
-11010001b & 01001101b = 01000001b
-11010001b & 01001110b = 01000000b
-11010001b & 01001111b = 01000001b
-11010001b & 01010000b = 01010000b
-11010001b & 01010001b = 01010001b
-11010001b & 01010010b = 01010000b
-11010001b & 01010011b = 01010001b
-11010001b & 01010100b = 01010000b
-11010001b & 01010101b = 01010001b
-11010001b & 01010110b = 01010000b
-11010001b & 01010111b = 01010001b
-11010001b & 01011000b = 01010000b
-11010001b & 01011001b = 01010001b
-11010001b & 01011010b = 01010000b
-11010001b & 01011011b = 01010001b
-11010001b & 01011100b = 01010000b
-11010001b & 01011101b = 01010001b
-11010001b & 01011110b = 01010000b
-11010001b & 01011111b = 01010001b
-11010001b & 01100000b = 01000000b
-11010001b & 01100001b = 01000001b
-11010001b & 01100010b = 01000000b
-11010001b & 01100011b = 01000001b
-11010001b & 01100100b = 01000000b
-11010001b & 01100101b = 01000001b
-11010001b & 01100110b = 01000000b
-11010001b & 01100111b = 01000001b
-11010001b & 01101000b = 01000000b
-11010001b & 01101001b = 01000001b
-11010001b & 01101010b = 01000000b
-11010001b & 01101011b = 01000001b
-11010001b & 01101100b = 01000000b
-11010001b & 01101101b = 01000001b
-11010001b & 01101110b = 01000000b
-11010001b & 01101111b = 01000001b
-11010001b & 01110000b = 01010000b
-11010001b & 01110001b = 01010001b
-11010001b & 01110010b = 01010000b
-11010001b & 01110011b = 01010001b
-11010001b & 01110100b = 01010000b
-11010001b & 01110101b = 01010001b
-11010001b & 01110110b = 01010000b
-11010001b & 01110111b = 01010001b
-11010001b & 01111000b = 01010000b
-11010001b & 01111001b = 01010001b
-11010001b & 01111010b = 01010000b
-11010001b & 01111011b = 01010001b
-11010001b & 01111100b = 01010000b
-11010001b & 01111101b = 01010001b
-11010001b & 01111110b = 01010000b
-11010010b & 10000000b = 10000000b
-11010010b & 10000001b = 10000000b
-11010010b & 10000010b = 10000010b
-11010010b & 10000011b = 10000010b
-11010010b & 10000100b = 10000000b
-11010010b & 10000101b = 10000000b
-11010010b & 10000110b = 10000010b
-11010010b & 10000111b = 10000010b
-11010010b & 10001000b = 10000000b
-11010010b & 10001001b = 10000000b
-11010010b & 10001010b = 10000010b
-11010010b & 10001011b = 10000010b
-11010010b & 10001100b = 10000000b
-11010010b & 10001101b = 10000000b
-11010010b & 10001110b = 10000010b
-11010010b & 10001111b = 10000010b
-11010010b & 10010000b = 10010000b
-11010010b & 10010001b = 10010000b
-11010010b & 10010010b = 10010010b
-11010010b & 10010011b = 10010010b
-11010010b & 10010100b = 10010000b
-11010010b & 10010101b = 10010000b
-11010010b & 10010110b = 10010010b
-11010010b & 10010111b = 10010010b
-11010010b & 10011000b = 10010000b
-11010010b & 10011001b = 10010000b
-11010010b & 10011010b = 10010010b
-11010010b & 10011011b = 10010010b
-11010010b & 10011100b = 10010000b
-11010010b & 10011101b = 10010000b
-11010010b & 10011110b = 10010010b
-11010010b & 10011111b = 10010010b
-11010010b & 10100000b = 10000000b
-11010010b & 10100001b = 10000000b
-11010010b & 10100010b = 10000010b
-11010010b & 10100011b = 10000010b
-11010010b & 10100100b = 10000000b
-11010010b & 10100101b = 10000000b
-11010010b & 10100110b = 10000010b
-11010010b & 10100111b = 10000010b
-11010010b & 10101000b = 10000000b
-11010010b & 10101001b = 10000000b
-11010010b & 10101010b = 10000010b
-11010010b & 10101011b = 10000010b
-11010010b & 10101100b = 10000000b
-11010010b & 10101101b = 10000000b
-11010010b & 10101110b = 10000010b
-11010010b & 10101111b = 10000010b
-11010010b & 10110000b = 10010000b
-11010010b & 10110001b = 10010000b
-11010010b & 10110010b = 10010010b
-11010010b & 10110011b = 10010010b
-11010010b & 10110100b = 10010000b
-11010010b & 10110101b = 10010000b
-11010010b & 10110110b = 10010010b
-11010010b & 10110111b = 10010010b
-11010010b & 10111000b = 10010000b
-11010010b & 10111001b = 10010000b
-11010010b & 10111010b = 10010010b
-11010010b & 10111011b = 10010010b
-11010010b & 10111100b = 10010000b
-11010010b & 10111101b = 10010000b
-11010010b & 10111110b = 10010010b
-11010010b & 10111111b = 10010010b
-11010010b & 11000000b = 11000000b
-11010010b & 11000001b = 11000000b
-11010010b & 11000010b = 11000010b
-11010010b & 11000011b = 11000010b
-11010010b & 11000100b = 11000000b
-11010010b & 11000101b = 11000000b
-11010010b & 11000110b = 11000010b
-11010010b & 11000111b = 11000010b
-11010010b & 11001000b = 11000000b
-11010010b & 11001001b = 11000000b
-11010010b & 11001010b = 11000010b
-11010010b & 11001011b = 11000010b
-11010010b & 11001100b = 11000000b
-11010010b & 11001101b = 11000000b
-11010010b & 11001110b = 11000010b
-11010010b & 11001111b = 11000010b
-11010010b & 11010000b = 11010000b
-11010010b & 11010001b = 11010000b
-11010010b & 11010010b = 11010010b
-11010010b & 11010011b = 11010010b
-11010010b & 11010100b = 11010000b
-11010010b & 11010101b = 11010000b
-11010010b & 11010110b = 11010010b
-11010010b & 11010111b = 11010010b
-11010010b & 11011000b = 11010000b
-11010010b & 11011001b = 11010000b
-11010010b & 11011010b = 11010010b
-11010010b & 11011011b = 11010010b
-11010010b & 11011100b = 11010000b
-11010010b & 11011101b = 11010000b
-11010010b & 11011110b = 11010010b
-11010010b & 11011111b = 11010010b
-11010010b & 11100000b = 11000000b
-11010010b & 11100001b = 11000000b
-11010010b & 11100010b = 11000010b
-11010010b & 11100011b = 11000010b
-11010010b & 11100100b = 11000000b
-11010010b & 11100101b = 11000000b
-11010010b & 11100110b = 11000010b
-11010010b & 11100111b = 11000010b
-11010010b & 11101000b = 11000000b
-11010010b & 11101001b = 11000000b
-11010010b & 11101010b = 11000010b
-11010010b & 11101011b = 11000010b
-11010010b & 11101100b = 11000000b
-11010010b & 11101101b = 11000000b
-11010010b & 11101110b = 11000010b
-11010010b & 11101111b = 11000010b
-11010010b & 11110000b = 11010000b
-11010010b & 11110001b = 11010000b
-11010010b & 11110010b = 11010010b
-11010010b & 11110011b = 11010010b
-11010010b & 11110100b = 11010000b
-11010010b & 11110101b = 11010000b
-11010010b & 11110110b = 11010010b
-11010010b & 11110111b = 11010010b
-11010010b & 11111000b = 11010000b
-11010010b & 11111001b = 11010000b
-11010010b & 11111010b = 11010010b
-11010010b & 11111011b = 11010010b
-11010010b & 11111100b = 11010000b
-11010010b & 11111101b = 11010000b
-11010010b & 11111110b = 11010010b
-11010010b & 11111111b = 11010010b
-11010010b & 00000000b = 00000000b
-11010010b & 00000001b = 00000000b
-11010010b & 00000010b = 00000010b
-11010010b & 00000011b = 00000010b
-11010010b & 00000100b = 00000000b
-11010010b & 00000101b = 00000000b
-11010010b & 00000110b = 00000010b
-11010010b & 00000111b = 00000010b
-11010010b & 00001000b = 00000000b
-11010010b & 00001001b = 00000000b
-11010010b & 00001010b = 00000010b
-11010010b & 00001011b = 00000010b
-11010010b & 00001100b = 00000000b
-11010010b & 00001101b = 00000000b
-11010010b & 00001110b = 00000010b
-11010010b & 00001111b = 00000010b
-11010010b & 00010000b = 00010000b
-11010010b & 00010001b = 00010000b
-11010010b & 00010010b = 00010010b
-11010010b & 00010011b = 00010010b
-11010010b & 00010100b = 00010000b
-11010010b & 00010101b = 00010000b
-11010010b & 00010110b = 00010010b
-11010010b & 00010111b = 00010010b
-11010010b & 00011000b = 00010000b
-11010010b & 00011001b = 00010000b
-11010010b & 00011010b = 00010010b
-11010010b & 00011011b = 00010010b
-11010010b & 00011100b = 00010000b
-11010010b & 00011101b = 00010000b
-11010010b & 00011110b = 00010010b
-11010010b & 00011111b = 00010010b
-11010010b & 00100000b = 00000000b
-11010010b & 00100001b = 00000000b
-11010010b & 00100010b = 00000010b
-11010010b & 00100011b = 00000010b
-11010010b & 00100100b = 00000000b
-11010010b & 00100101b = 00000000b
-11010010b & 00100110b = 00000010b
-11010010b & 00100111b = 00000010b
-11010010b & 00101000b = 00000000b
-11010010b & 00101001b = 00000000b
-11010010b & 00101010b = 00000010b
-11010010b & 00101011b = 00000010b
-11010010b & 00101100b = 00000000b
-11010010b & 00101101b = 00000000b
-11010010b & 00101110b = 00000010b
-11010010b & 00101111b = 00000010b
-11010010b & 00110000b = 00010000b
-11010010b & 00110001b = 00010000b
-11010010b & 00110010b = 00010010b
-11010010b & 00110011b = 00010010b
-11010010b & 00110100b = 00010000b
-11010010b & 00110101b = 00010000b
-11010010b & 00110110b = 00010010b
-11010010b & 00110111b = 00010010b
-11010010b & 00111000b = 00010000b
-11010010b & 00111001b = 00010000b
-11010010b & 00111010b = 00010010b
-11010010b & 00111011b = 00010010b
-11010010b & 00111100b = 00010000b
-11010010b & 00111101b = 00010000b
-11010010b & 00111110b = 00010010b
-11010010b & 00111111b = 00010010b
-11010010b & 01000000b = 01000000b
-11010010b & 01000001b = 01000000b
-11010010b & 01000010b = 01000010b
-11010010b & 01000011b = 01000010b
-11010010b & 01000100b = 01000000b
-11010010b & 01000101b = 01000000b
-11010010b & 01000110b = 01000010b
-11010010b & 01000111b = 01000010b
-11010010b & 01001000b = 01000000b
-11010010b & 01001001b = 01000000b
-11010010b & 01001010b = 01000010b
-11010010b & 01001011b = 01000010b
-11010010b & 01001100b = 01000000b
-11010010b & 01001101b = 01000000b
-11010010b & 01001110b = 01000010b
-11010010b & 01001111b = 01000010b
-11010010b & 01010000b = 01010000b
-11010010b & 01010001b = 01010000b
-11010010b & 01010010b = 01010010b
-11010010b & 01010011b = 01010010b
-11010010b & 01010100b = 01010000b
-11010010b & 01010101b = 01010000b
-11010010b & 01010110b = 01010010b
-11010010b & 01010111b = 01010010b
-11010010b & 01011000b = 01010000b
-11010010b & 01011001b = 01010000b
-11010010b & 01011010b = 01010010b
-11010010b & 01011011b = 01010010b
-11010010b & 01011100b = 01010000b
-11010010b & 01011101b = 01010000b
-11010010b & 01011110b = 01010010b
-11010010b & 01011111b = 01010010b
-11010010b & 01100000b = 01000000b
-11010010b & 01100001b = 01000000b
-11010010b & 01100010b = 01000010b
-11010010b & 01100011b = 01000010b
-11010010b & 01100100b = 01000000b
-11010010b & 01100101b = 01000000b
-11010010b & 01100110b = 01000010b
-11010010b & 01100111b = 01000010b
-11010010b & 01101000b = 01000000b
-11010010b & 01101001b = 01000000b
-11010010b & 01101010b = 01000010b
-11010010b & 01101011b = 01000010b
-11010010b & 01101100b = 01000000b
-11010010b & 01101101b = 01000000b
-11010010b & 01101110b = 01000010b
-11010010b & 01101111b = 01000010b
-11010010b & 01110000b = 01010000b
-11010010b & 01110001b = 01010000b
-11010010b & 01110010b = 01010010b
-11010010b & 01110011b = 01010010b
-11010010b & 01110100b = 01010000b
-11010010b & 01110101b = 01010000b
-11010010b & 01110110b = 01010010b
-11010010b & 01110111b = 01010010b
-11010010b & 01111000b = 01010000b
-11010010b & 01111001b = 01010000b
-11010010b & 01111010b = 01010010b
-11010010b & 01111011b = 01010010b
-11010010b & 01111100b = 01010000b
-11010010b & 01111101b = 01010000b
-11010010b & 01111110b = 01010010b
-11010011b & 10000000b = 10000000b
-11010011b & 10000001b = 10000001b
-11010011b & 10000010b = 10000010b
-11010011b & 10000011b = 10000011b
-11010011b & 10000100b = 10000000b
-11010011b & 10000101b = 10000001b
-11010011b & 10000110b = 10000010b
-11010011b & 10000111b = 10000011b
-11010011b & 10001000b = 10000000b
-11010011b & 10001001b = 10000001b
-11010011b & 10001010b = 10000010b
-11010011b & 10001011b = 10000011b
-11010011b & 10001100b = 10000000b
-11010011b & 10001101b = 10000001b
-11010011b & 10001110b = 10000010b
-11010011b & 10001111b = 10000011b
-11010011b & 10010000b = 10010000b
-11010011b & 10010001b = 10010001b
-11010011b & 10010010b = 10010010b
-11010011b & 10010011b = 10010011b
-11010011b & 10010100b = 10010000b
-11010011b & 10010101b = 10010001b
-11010011b & 10010110b = 10010010b
-11010011b & 10010111b = 10010011b
-11010011b & 10011000b = 10010000b
-11010011b & 10011001b = 10010001b
-11010011b & 10011010b = 10010010b
-11010011b & 10011011b = 10010011b
-11010011b & 10011100b = 10010000b
-11010011b & 10011101b = 10010001b
-11010011b & 10011110b = 10010010b
-11010011b & 10011111b = 10010011b
-11010011b & 10100000b = 10000000b
-11010011b & 10100001b = 10000001b
-11010011b & 10100010b = 10000010b
-11010011b & 10100011b = 10000011b
-11010011b & 10100100b = 10000000b
-11010011b & 10100101b = 10000001b
-11010011b & 10100110b = 10000010b
-11010011b & 10100111b = 10000011b
-11010011b & 10101000b = 10000000b
-11010011b & 10101001b = 10000001b
-11010011b & 10101010b = 10000010b
-11010011b & 10101011b = 10000011b
-11010011b & 10101100b = 10000000b
-11010011b & 10101101b = 10000001b
-11010011b & 10101110b = 10000010b
-11010011b & 10101111b = 10000011b
-11010011b & 10110000b = 10010000b
-11010011b & 10110001b = 10010001b
-11010011b & 10110010b = 10010010b
-11010011b & 10110011b = 10010011b
-11010011b & 10110100b = 10010000b
-11010011b & 10110101b = 10010001b
-11010011b & 10110110b = 10010010b
-11010011b & 10110111b = 10010011b
-11010011b & 10111000b = 10010000b
-11010011b & 10111001b = 10010001b
-11010011b & 10111010b = 10010010b
-11010011b & 10111011b = 10010011b
-11010011b & 10111100b = 10010000b
-11010011b & 10111101b = 10010001b
-11010011b & 10111110b = 10010010b
-11010011b & 10111111b = 10010011b
-11010011b & 11000000b = 11000000b
-11010011b & 11000001b = 11000001b
-11010011b & 11000010b = 11000010b
-11010011b & 11000011b = 11000011b
-11010011b & 11000100b = 11000000b
-11010011b & 11000101b = 11000001b
-11010011b & 11000110b = 11000010b
-11010011b & 11000111b = 11000011b
-11010011b & 11001000b = 11000000b
-11010011b & 11001001b = 11000001b
-11010011b & 11001010b = 11000010b
-11010011b & 11001011b = 11000011b
-11010011b & 11001100b = 11000000b
-11010011b & 11001101b = 11000001b
-11010011b & 11001110b = 11000010b
-11010011b & 11001111b = 11000011b
-11010011b & 11010000b = 11010000b
-11010011b & 11010001b = 11010001b
-11010011b & 11010010b = 11010010b
-11010011b & 11010011b = 11010011b
-11010011b & 11010100b = 11010000b
-11010011b & 11010101b = 11010001b
-11010011b & 11010110b = 11010010b
-11010011b & 11010111b = 11010011b
-11010011b & 11011000b = 11010000b
-11010011b & 11011001b = 11010001b
-11010011b & 11011010b = 11010010b
-11010011b & 11011011b = 11010011b
-11010011b & 11011100b = 11010000b
-11010011b & 11011101b = 11010001b
-11010011b & 11011110b = 11010010b
-11010011b & 11011111b = 11010011b
-11010011b & 11100000b = 11000000b
-11010011b & 11100001b = 11000001b
-11010011b & 11100010b = 11000010b
-11010011b & 11100011b = 11000011b
-11010011b & 11100100b = 11000000b
-11010011b & 11100101b = 11000001b
-11010011b & 11100110b = 11000010b
-11010011b & 11100111b = 11000011b
-11010011b & 11101000b = 11000000b
-11010011b & 11101001b = 11000001b
-11010011b & 11101010b = 11000010b
-11010011b & 11101011b = 11000011b
-11010011b & 11101100b = 11000000b
-11010011b & 11101101b = 11000001b
-11010011b & 11101110b = 11000010b
-11010011b & 11101111b = 11000011b
-11010011b & 11110000b = 11010000b
-11010011b & 11110001b = 11010001b
-11010011b & 11110010b = 11010010b
-11010011b & 11110011b = 11010011b
-11010011b & 11110100b = 11010000b
-11010011b & 11110101b = 11010001b
-11010011b & 11110110b = 11010010b
-11010011b & 11110111b = 11010011b
-11010011b & 11111000b = 11010000b
-11010011b & 11111001b = 11010001b
-11010011b & 11111010b = 11010010b
-11010011b & 11111011b = 11010011b
-11010011b & 11111100b = 11010000b
-11010011b & 11111101b = 11010001b
-11010011b & 11111110b = 11010010b
-11010011b & 11111111b = 11010011b
-11010011b & 00000000b = 00000000b
-11010011b & 00000001b = 00000001b
-11010011b & 00000010b = 00000010b
-11010011b & 00000011b = 00000011b
-11010011b & 00000100b = 00000000b
-11010011b & 00000101b = 00000001b
-11010011b & 00000110b = 00000010b
-11010011b & 00000111b = 00000011b
-11010011b & 00001000b = 00000000b
-11010011b & 00001001b = 00000001b
-11010011b & 00001010b = 00000010b
-11010011b & 00001011b = 00000011b
-11010011b & 00001100b = 00000000b
-11010011b & 00001101b = 00000001b
-11010011b & 00001110b = 00000010b
-11010011b & 00001111b = 00000011b
-11010011b & 00010000b = 00010000b
-11010011b & 00010001b = 00010001b
-11010011b & 00010010b = 00010010b
-11010011b & 00010011b = 00010011b
-11010011b & 00010100b = 00010000b
-11010011b & 00010101b = 00010001b
-11010011b & 00010110b = 00010010b
-11010011b & 00010111b = 00010011b
-11010011b & 00011000b = 00010000b
-11010011b & 00011001b = 00010001b
-11010011b & 00011010b = 00010010b
-11010011b & 00011011b = 00010011b
-11010011b & 00011100b = 00010000b
-11010011b & 00011101b = 00010001b
-11010011b & 00011110b = 00010010b
-11010011b & 00011111b = 00010011b
-11010011b & 00100000b = 00000000b
-11010011b & 00100001b = 00000001b
-11010011b & 00100010b = 00000010b
-11010011b & 00100011b = 00000011b
-11010011b & 00100100b = 00000000b
-11010011b & 00100101b = 00000001b
-11010011b & 00100110b = 00000010b
-11010011b & 00100111b = 00000011b
-11010011b & 00101000b = 00000000b
-11010011b & 00101001b = 00000001b
-11010011b & 00101010b = 00000010b
-11010011b & 00101011b = 00000011b
-11010011b & 00101100b = 00000000b
-11010011b & 00101101b = 00000001b
-11010011b & 00101110b = 00000010b
-11010011b & 00101111b = 00000011b
-11010011b & 00110000b = 00010000b
-11010011b & 00110001b = 00010001b
-11010011b & 00110010b = 00010010b
-11010011b & 00110011b = 00010011b
-11010011b & 00110100b = 00010000b
-11010011b & 00110101b = 00010001b
-11010011b & 00110110b = 00010010b
-11010011b & 00110111b = 00010011b
-11010011b & 00111000b = 00010000b
-11010011b & 00111001b = 00010001b
-11010011b & 00111010b = 00010010b
-11010011b & 00111011b = 00010011b
-11010011b & 00111100b = 00010000b
-11010011b & 00111101b = 00010001b
-11010011b & 00111110b = 00010010b
-11010011b & 00111111b = 00010011b
-11010011b & 01000000b = 01000000b
-11010011b & 01000001b = 01000001b
-11010011b & 01000010b = 01000010b
-11010011b & 01000011b = 01000011b
-11010011b & 01000100b = 01000000b
-11010011b & 01000101b = 01000001b
-11010011b & 01000110b = 01000010b
-11010011b & 01000111b = 01000011b
-11010011b & 01001000b = 01000000b
-11010011b & 01001001b = 01000001b
-11010011b & 01001010b = 01000010b
-11010011b & 01001011b = 01000011b
-11010011b & 01001100b = 01000000b
-11010011b & 01001101b = 01000001b
-11010011b & 01001110b = 01000010b
-11010011b & 01001111b = 01000011b
-11010011b & 01010000b = 01010000b
-11010011b & 01010001b = 01010001b
-11010011b & 01010010b = 01010010b
-11010011b & 01010011b = 01010011b
-11010011b & 01010100b = 01010000b
-11010011b & 01010101b = 01010001b
-11010011b & 01010110b = 01010010b
-11010011b & 01010111b = 01010011b
-11010011b & 01011000b = 01010000b
-11010011b & 01011001b = 01010001b
-11010011b & 01011010b = 01010010b
-11010011b & 01011011b = 01010011b
-11010011b & 01011100b = 01010000b
-11010011b & 01011101b = 01010001b
-11010011b & 01011110b = 01010010b
-11010011b & 01011111b = 01010011b
-11010011b & 01100000b = 01000000b
-11010011b & 01100001b = 01000001b
-11010011b & 01100010b = 01000010b
-11010011b & 01100011b = 01000011b
-11010011b & 01100100b = 01000000b
-11010011b & 01100101b = 01000001b
-11010011b & 01100110b = 01000010b
-11010011b & 01100111b = 01000011b
-11010011b & 01101000b = 01000000b
-11010011b & 01101001b = 01000001b
-11010011b & 01101010b = 01000010b
-11010011b & 01101011b = 01000011b
-11010011b & 01101100b = 01000000b
-11010011b & 01101101b = 01000001b
-11010011b & 01101110b = 01000010b
-11010011b & 01101111b = 01000011b
-11010011b & 01110000b = 01010000b
-11010011b & 01110001b = 01010001b
-11010011b & 01110010b = 01010010b
-11010011b & 01110011b = 01010011b
-11010011b & 01110100b = 01010000b
-11010011b & 01110101b = 01010001b
-11010011b & 01110110b = 01010010b
-11010011b & 01110111b = 01010011b
-11010011b & 01111000b = 01010000b
-11010011b & 01111001b = 01010001b
-11010011b & 01111010b = 01010010b
-11010011b & 01111011b = 01010011b
-11010011b & 01111100b = 01010000b
-11010011b & 01111101b = 01010001b
-11010011b & 01111110b = 01010010b
-11010100b & 10000000b = 10000000b
-11010100b & 10000001b = 10000000b
-11010100b & 10000010b = 10000000b
-11010100b & 10000011b = 10000000b
-11010100b & 10000100b = 10000100b
-11010100b & 10000101b = 10000100b
-11010100b & 10000110b = 10000100b
-11010100b & 10000111b = 10000100b
-11010100b & 10001000b = 10000000b
-11010100b & 10001001b = 10000000b
-11010100b & 10001010b = 10000000b
-11010100b & 10001011b = 10000000b
-11010100b & 10001100b = 10000100b
-11010100b & 10001101b = 10000100b
-11010100b & 10001110b = 10000100b
-11010100b & 10001111b = 10000100b
-11010100b & 10010000b = 10010000b
-11010100b & 10010001b = 10010000b
-11010100b & 10010010b = 10010000b
-11010100b & 10010011b = 10010000b
-11010100b & 10010100b = 10010100b
-11010100b & 10010101b = 10010100b
-11010100b & 10010110b = 10010100b
-11010100b & 10010111b = 10010100b
-11010100b & 10011000b = 10010000b
-11010100b & 10011001b = 10010000b
-11010100b & 10011010b = 10010000b
-11010100b & 10011011b = 10010000b
-11010100b & 10011100b = 10010100b
-11010100b & 10011101b = 10010100b
-11010100b & 10011110b = 10010100b
-11010100b & 10011111b = 10010100b
-11010100b & 10100000b = 10000000b
-11010100b & 10100001b = 10000000b
-11010100b & 10100010b = 10000000b
-11010100b & 10100011b = 10000000b
-11010100b & 10100100b = 10000100b
-11010100b & 10100101b = 10000100b
-11010100b & 10100110b = 10000100b
-11010100b & 10100111b = 10000100b
-11010100b & 10101000b = 10000000b
-11010100b & 10101001b = 10000000b
-11010100b & 10101010b = 10000000b
-11010100b & 10101011b = 10000000b
-11010100b & 10101100b = 10000100b
-11010100b & 10101101b = 10000100b
-11010100b & 10101110b = 10000100b
-11010100b & 10101111b = 10000100b
-11010100b & 10110000b = 10010000b
-11010100b & 10110001b = 10010000b
-11010100b & 10110010b = 10010000b
-11010100b & 10110011b = 10010000b
-11010100b & 10110100b = 10010100b
-11010100b & 10110101b = 10010100b
-11010100b & 10110110b = 10010100b
-11010100b & 10110111b = 10010100b
-11010100b & 10111000b = 10010000b
-11010100b & 10111001b = 10010000b
-11010100b & 10111010b = 10010000b
-11010100b & 10111011b = 10010000b
-11010100b & 10111100b = 10010100b
-11010100b & 10111101b = 10010100b
-11010100b & 10111110b = 10010100b
-11010100b & 10111111b = 10010100b
-11010100b & 11000000b = 11000000b
-11010100b & 11000001b = 11000000b
-11010100b & 11000010b = 11000000b
-11010100b & 11000011b = 11000000b
-11010100b & 11000100b = 11000100b
-11010100b & 11000101b = 11000100b
-11010100b & 11000110b = 11000100b
-11010100b & 11000111b = 11000100b
-11010100b & 11001000b = 11000000b
-11010100b & 11001001b = 11000000b
-11010100b & 11001010b = 11000000b
-11010100b & 11001011b = 11000000b
-11010100b & 11001100b = 11000100b
-11010100b & 11001101b = 11000100b
-11010100b & 11001110b = 11000100b
-11010100b & 11001111b = 11000100b
-11010100b & 11010000b = 11010000b
-11010100b & 11010001b = 11010000b
-11010100b & 11010010b = 11010000b
-11010100b & 11010011b = 11010000b
-11010100b & 11010100b = 11010100b
-11010100b & 11010101b = 11010100b
-11010100b & 11010110b = 11010100b
-11010100b & 11010111b = 11010100b
-11010100b & 11011000b = 11010000b
-11010100b & 11011001b = 11010000b
-11010100b & 11011010b = 11010000b
-11010100b & 11011011b = 11010000b
-11010100b & 11011100b = 11010100b
-11010100b & 11011101b = 11010100b
-11010100b & 11011110b = 11010100b
-11010100b & 11011111b = 11010100b
-11010100b & 11100000b = 11000000b
-11010100b & 11100001b = 11000000b
-11010100b & 11100010b = 11000000b
-11010100b & 11100011b = 11000000b
-11010100b & 11100100b = 11000100b
-11010100b & 11100101b = 11000100b
-11010100b & 11100110b = 11000100b
-11010100b & 11100111b = 11000100b
-11010100b & 11101000b = 11000000b
-11010100b & 11101001b = 11000000b
-11010100b & 11101010b = 11000000b
-11010100b & 11101011b = 11000000b
-11010100b & 11101100b = 11000100b
-11010100b & 11101101b = 11000100b
-11010100b & 11101110b = 11000100b
-11010100b & 11101111b = 11000100b
-11010100b & 11110000b = 11010000b
-11010100b & 11110001b = 11010000b
-11010100b & 11110010b = 11010000b
-11010100b & 11110011b = 11010000b
-11010100b & 11110100b = 11010100b
-11010100b & 11110101b = 11010100b
-11010100b & 11110110b = 11010100b
-11010100b & 11110111b = 11010100b
-11010100b & 11111000b = 11010000b
-11010100b & 11111001b = 11010000b
-11010100b & 11111010b = 11010000b
-11010100b & 11111011b = 11010000b
-11010100b & 11111100b = 11010100b
-11010100b & 11111101b = 11010100b
-11010100b & 11111110b = 11010100b
-11010100b & 11111111b = 11010100b
-11010100b & 00000000b = 00000000b
-11010100b & 00000001b = 00000000b
-11010100b & 00000010b = 00000000b
-11010100b & 00000011b = 00000000b
-11010100b & 00000100b = 00000100b
-11010100b & 00000101b = 00000100b
-11010100b & 00000110b = 00000100b
-11010100b & 00000111b = 00000100b
-11010100b & 00001000b = 00000000b
-11010100b & 00001001b = 00000000b
-11010100b & 00001010b = 00000000b
-11010100b & 00001011b = 00000000b
-11010100b & 00001100b = 00000100b
-11010100b & 00001101b = 00000100b
-11010100b & 00001110b = 00000100b
-11010100b & 00001111b = 00000100b
-11010100b & 00010000b = 00010000b
-11010100b & 00010001b = 00010000b
-11010100b & 00010010b = 00010000b
-11010100b & 00010011b = 00010000b
-11010100b & 00010100b = 00010100b
-11010100b & 00010101b = 00010100b
-11010100b & 00010110b = 00010100b
-11010100b & 00010111b = 00010100b
-11010100b & 00011000b = 00010000b
-11010100b & 00011001b = 00010000b
-11010100b & 00011010b = 00010000b
-11010100b & 00011011b = 00010000b
-11010100b & 00011100b = 00010100b
-11010100b & 00011101b = 00010100b
-11010100b & 00011110b = 00010100b
-11010100b & 00011111b = 00010100b
-11010100b & 00100000b = 00000000b
-11010100b & 00100001b = 00000000b
-11010100b & 00100010b = 00000000b
-11010100b & 00100011b = 00000000b
-11010100b & 00100100b = 00000100b
-11010100b & 00100101b = 00000100b
-11010100b & 00100110b = 00000100b
-11010100b & 00100111b = 00000100b
-11010100b & 00101000b = 00000000b
-11010100b & 00101001b = 00000000b
-11010100b & 00101010b = 00000000b
-11010100b & 00101011b = 00000000b
-11010100b & 00101100b = 00000100b
-11010100b & 00101101b = 00000100b
-11010100b & 00101110b = 00000100b
-11010100b & 00101111b = 00000100b
-11010100b & 00110000b = 00010000b
-11010100b & 00110001b = 00010000b
-11010100b & 00110010b = 00010000b
-11010100b & 00110011b = 00010000b
-11010100b & 00110100b = 00010100b
-11010100b & 00110101b = 00010100b
-11010100b & 00110110b = 00010100b
-11010100b & 00110111b = 00010100b
-11010100b & 00111000b = 00010000b
-11010100b & 00111001b = 00010000b
-11010100b & 00111010b = 00010000b
-11010100b & 00111011b = 00010000b
-11010100b & 00111100b = 00010100b
-11010100b & 00111101b = 00010100b
-11010100b & 00111110b = 00010100b
-11010100b & 00111111b = 00010100b
-11010100b & 01000000b = 01000000b
-11010100b & 01000001b = 01000000b
-11010100b & 01000010b = 01000000b
-11010100b & 01000011b = 01000000b
-11010100b & 01000100b = 01000100b
-11010100b & 01000101b = 01000100b
-11010100b & 01000110b = 01000100b
-11010100b & 01000111b = 01000100b
-11010100b & 01001000b = 01000000b
-11010100b & 01001001b = 01000000b
-11010100b & 01001010b = 01000000b
-11010100b & 01001011b = 01000000b
-11010100b & 01001100b = 01000100b
-11010100b & 01001101b = 01000100b
-11010100b & 01001110b = 01000100b
-11010100b & 01001111b = 01000100b
-11010100b & 01010000b = 01010000b
-11010100b & 01010001b = 01010000b
-11010100b & 01010010b = 01010000b
-11010100b & 01010011b = 01010000b
-11010100b & 01010100b = 01010100b
-11010100b & 01010101b = 01010100b
-11010100b & 01010110b = 01010100b
-11010100b & 01010111b = 01010100b
-11010100b & 01011000b = 01010000b
-11010100b & 01011001b = 01010000b
-11010100b & 01011010b = 01010000b
-11010100b & 01011011b = 01010000b
-11010100b & 01011100b = 01010100b
-11010100b & 01011101b = 01010100b
-11010100b & 01011110b = 01010100b
-11010100b & 01011111b = 01010100b
-11010100b & 01100000b = 01000000b
-11010100b & 01100001b = 01000000b
-11010100b & 01100010b = 01000000b
-11010100b & 01100011b = 01000000b
-11010100b & 01100100b = 01000100b
-11010100b & 01100101b = 01000100b
-11010100b & 01100110b = 01000100b
-11010100b & 01100111b = 01000100b
-11010100b & 01101000b = 01000000b
-11010100b & 01101001b = 01000000b
-11010100b & 01101010b = 01000000b
-11010100b & 01101011b = 01000000b
-11010100b & 01101100b = 01000100b
-11010100b & 01101101b = 01000100b
-11010100b & 01101110b = 01000100b
-11010100b & 01101111b = 01000100b
-11010100b & 01110000b = 01010000b
-11010100b & 01110001b = 01010000b
-11010100b & 01110010b = 01010000b
-11010100b & 01110011b = 01010000b
-11010100b & 01110100b = 01010100b
-11010100b & 01110101b = 01010100b
-11010100b & 01110110b = 01010100b
-11010100b & 01110111b = 01010100b
-11010100b & 01111000b = 01010000b
-11010100b & 01111001b = 01010000b
-11010100b & 01111010b = 01010000b
-11010100b & 01111011b = 01010000b
-11010100b & 01111100b = 01010100b
-11010100b & 01111101b = 01010100b
-11010100b & 01111110b = 01010100b
-11010101b & 10000000b = 10000000b
-11010101b & 10000001b = 10000001b
-11010101b & 10000010b = 10000000b
-11010101b & 10000011b = 10000001b
-11010101b & 10000100b = 10000100b
-11010101b & 10000101b = 10000101b
-11010101b & 10000110b = 10000100b
-11010101b & 10000111b = 10000101b
-11010101b & 10001000b = 10000000b
-11010101b & 10001001b = 10000001b
-11010101b & 10001010b = 10000000b
-11010101b & 10001011b = 10000001b
-11010101b & 10001100b = 10000100b
-11010101b & 10001101b = 10000101b
-11010101b & 10001110b = 10000100b
-11010101b & 10001111b = 10000101b
-11010101b & 10010000b = 10010000b
-11010101b & 10010001b = 10010001b
-11010101b & 10010010b = 10010000b
-11010101b & 10010011b = 10010001b
-11010101b & 10010100b = 10010100b
-11010101b & 10010101b = 10010101b
-11010101b & 10010110b = 10010100b
-11010101b & 10010111b = 10010101b
-11010101b & 10011000b = 10010000b
-11010101b & 10011001b = 10010001b
-11010101b & 10011010b = 10010000b
-11010101b & 10011011b = 10010001b
-11010101b & 10011100b = 10010100b
-11010101b & 10011101b = 10010101b
-11010101b & 10011110b = 10010100b
-11010101b & 10011111b = 10010101b
-11010101b & 10100000b = 10000000b
-11010101b & 10100001b = 10000001b
-11010101b & 10100010b = 10000000b
-11010101b & 10100011b = 10000001b
-11010101b & 10100100b = 10000100b
-11010101b & 10100101b = 10000101b
-11010101b & 10100110b = 10000100b
-11010101b & 10100111b = 10000101b
-11010101b & 10101000b = 10000000b
-11010101b & 10101001b = 10000001b
-11010101b & 10101010b = 10000000b
-11010101b & 10101011b = 10000001b
-11010101b & 10101100b = 10000100b
-11010101b & 10101101b = 10000101b
-11010101b & 10101110b = 10000100b
-11010101b & 10101111b = 10000101b
-11010101b & 10110000b = 10010000b
-11010101b & 10110001b = 10010001b
-11010101b & 10110010b = 10010000b
-11010101b & 10110011b = 10010001b
-11010101b & 10110100b = 10010100b
-11010101b & 10110101b = 10010101b
-11010101b & 10110110b = 10010100b
-11010101b & 10110111b = 10010101b
-11010101b & 10111000b = 10010000b
-11010101b & 10111001b = 10010001b
-11010101b & 10111010b = 10010000b
-11010101b & 10111011b = 10010001b
-11010101b & 10111100b = 10010100b
-11010101b & 10111101b = 10010101b
-11010101b & 10111110b = 10010100b
-11010101b & 10111111b = 10010101b
-11010101b & 11000000b = 11000000b
-11010101b & 11000001b = 11000001b
-11010101b & 11000010b = 11000000b
-11010101b & 11000011b = 11000001b
-11010101b & 11000100b = 11000100b
-11010101b & 11000101b = 11000101b
-11010101b & 11000110b = 11000100b
-11010101b & 11000111b = 11000101b
-11010101b & 11001000b = 11000000b
-11010101b & 11001001b = 11000001b
-11010101b & 11001010b = 11000000b
-11010101b & 11001011b = 11000001b
-11010101b & 11001100b = 11000100b
-11010101b & 11001101b = 11000101b
-11010101b & 11001110b = 11000100b
-11010101b & 11001111b = 11000101b
-11010101b & 11010000b = 11010000b
-11010101b & 11010001b = 11010001b
-11010101b & 11010010b = 11010000b
-11010101b & 11010011b = 11010001b
-11010101b & 11010100b = 11010100b
-11010101b & 11010101b = 11010101b
-11010101b & 11010110b = 11010100b
-11010101b & 11010111b = 11010101b
-11010101b & 11011000b = 11010000b
-11010101b & 11011001b = 11010001b
-11010101b & 11011010b = 11010000b
-11010101b & 11011011b = 11010001b
-11010101b & 11011100b = 11010100b
-11010101b & 11011101b = 11010101b
-11010101b & 11011110b = 11010100b
-11010101b & 11011111b = 11010101b
-11010101b & 11100000b = 11000000b
-11010101b & 11100001b = 11000001b
-11010101b & 11100010b = 11000000b
-11010101b & 11100011b = 11000001b
-11010101b & 11100100b = 11000100b
-11010101b & 11100101b = 11000101b
-11010101b & 11100110b = 11000100b
-11010101b & 11100111b = 11000101b
-11010101b & 11101000b = 11000000b
-11010101b & 11101001b = 11000001b
-11010101b & 11101010b = 11000000b
-11010101b & 11101011b = 11000001b
-11010101b & 11101100b = 11000100b
-11010101b & 11101101b = 11000101b
-11010101b & 11101110b = 11000100b
-11010101b & 11101111b = 11000101b
-11010101b & 11110000b = 11010000b
-11010101b & 11110001b = 11010001b
-11010101b & 11110010b = 11010000b
-11010101b & 11110011b = 11010001b
-11010101b & 11110100b = 11010100b
-11010101b & 11110101b = 11010101b
-11010101b & 11110110b = 11010100b
-11010101b & 11110111b = 11010101b
-11010101b & 11111000b = 11010000b
-11010101b & 11111001b = 11010001b
-11010101b & 11111010b = 11010000b
-11010101b & 11111011b = 11010001b
-11010101b & 11111100b = 11010100b
-11010101b & 11111101b = 11010101b
-11010101b & 11111110b = 11010100b
-11010101b & 11111111b = 11010101b
-11010101b & 00000000b = 00000000b
-11010101b & 00000001b = 00000001b
-11010101b & 00000010b = 00000000b
-11010101b & 00000011b = 00000001b
-11010101b & 00000100b = 00000100b
-11010101b & 00000101b = 00000101b
-11010101b & 00000110b = 00000100b
-11010101b & 00000111b = 00000101b
-11010101b & 00001000b = 00000000b
-11010101b & 00001001b = 00000001b
-11010101b & 00001010b = 00000000b
-11010101b & 00001011b = 00000001b
-11010101b & 00001100b = 00000100b
-11010101b & 00001101b = 00000101b
-11010101b & 00001110b = 00000100b
-11010101b & 00001111b = 00000101b
-11010101b & 00010000b = 00010000b
-11010101b & 00010001b = 00010001b
-11010101b & 00010010b = 00010000b
-11010101b & 00010011b = 00010001b
-11010101b & 00010100b = 00010100b
-11010101b & 00010101b = 00010101b
-11010101b & 00010110b = 00010100b
-11010101b & 00010111b = 00010101b
-11010101b & 00011000b = 00010000b
-11010101b & 00011001b = 00010001b
-11010101b & 00011010b = 00010000b
-11010101b & 00011011b = 00010001b
-11010101b & 00011100b = 00010100b
-11010101b & 00011101b = 00010101b
-11010101b & 00011110b = 00010100b
-11010101b & 00011111b = 00010101b
-11010101b & 00100000b = 00000000b
-11010101b & 00100001b = 00000001b
-11010101b & 00100010b = 00000000b
-11010101b & 00100011b = 00000001b
-11010101b & 00100100b = 00000100b
-11010101b & 00100101b = 00000101b
-11010101b & 00100110b = 00000100b
-11010101b & 00100111b = 00000101b
-11010101b & 00101000b = 00000000b
-11010101b & 00101001b = 00000001b
-11010101b & 00101010b = 00000000b
-11010101b & 00101011b = 00000001b
-11010101b & 00101100b = 00000100b
-11010101b & 00101101b = 00000101b
-11010101b & 00101110b = 00000100b
-11010101b & 00101111b = 00000101b
-11010101b & 00110000b = 00010000b
-11010101b & 00110001b = 00010001b
-11010101b & 00110010b = 00010000b
-11010101b & 00110011b = 00010001b
-11010101b & 00110100b = 00010100b
-11010101b & 00110101b = 00010101b
-11010101b & 00110110b = 00010100b
-11010101b & 00110111b = 00010101b
-11010101b & 00111000b = 00010000b
-11010101b & 00111001b = 00010001b
-11010101b & 00111010b = 00010000b
-11010101b & 00111011b = 00010001b
-11010101b & 00111100b = 00010100b
-11010101b & 00111101b = 00010101b
-11010101b & 00111110b = 00010100b
-11010101b & 00111111b = 00010101b
-11010101b & 01000000b = 01000000b
-11010101b & 01000001b = 01000001b
-11010101b & 01000010b = 01000000b
-11010101b & 01000011b = 01000001b
-11010101b & 01000100b = 01000100b
-11010101b & 01000101b = 01000101b
-11010101b & 01000110b = 01000100b
-11010101b & 01000111b = 01000101b
-11010101b & 01001000b = 01000000b
-11010101b & 01001001b = 01000001b
-11010101b & 01001010b = 01000000b
-11010101b & 01001011b = 01000001b
-11010101b & 01001100b = 01000100b
-11010101b & 01001101b = 01000101b
-11010101b & 01001110b = 01000100b
-11010101b & 01001111b = 01000101b
-11010101b & 01010000b = 01010000b
-11010101b & 01010001b = 01010001b
-11010101b & 01010010b = 01010000b
-11010101b & 01010011b = 01010001b
-11010101b & 01010100b = 01010100b
-11010101b & 01010101b = 01010101b
-11010101b & 01010110b = 01010100b
-11010101b & 01010111b = 01010101b
-11010101b & 01011000b = 01010000b
-11010101b & 01011001b = 01010001b
-11010101b & 01011010b = 01010000b
-11010101b & 01011011b = 01010001b
-11010101b & 01011100b = 01010100b
-11010101b & 01011101b = 01010101b
-11010101b & 01011110b = 01010100b
-11010101b & 01011111b = 01010101b
-11010101b & 01100000b = 01000000b
-11010101b & 01100001b = 01000001b
-11010101b & 01100010b = 01000000b
-11010101b & 01100011b = 01000001b
-11010101b & 01100100b = 01000100b
-11010101b & 01100101b = 01000101b
-11010101b & 01100110b = 01000100b
-11010101b & 01100111b = 01000101b
-11010101b & 01101000b = 01000000b
-11010101b & 01101001b = 01000001b
-11010101b & 01101010b = 01000000b
-11010101b & 01101011b = 01000001b
-11010101b & 01101100b = 01000100b
-11010101b & 01101101b = 01000101b
-11010101b & 01101110b = 01000100b
-11010101b & 01101111b = 01000101b
-11010101b & 01110000b = 01010000b
-11010101b & 01110001b = 01010001b
-11010101b & 01110010b = 01010000b
-11010101b & 01110011b = 01010001b
-11010101b & 01110100b = 01010100b
-11010101b & 01110101b = 01010101b
-11010101b & 01110110b = 01010100b
-11010101b & 01110111b = 01010101b
-11010101b & 01111000b = 01010000b
-11010101b & 01111001b = 01010001b
-11010101b & 01111010b = 01010000b
-11010101b & 01111011b = 01010001b
-11010101b & 01111100b = 01010100b
-11010101b & 01111101b = 01010101b
-11010101b & 01111110b = 01010100b
-11010110b & 10000000b = 10000000b
-11010110b & 10000001b = 10000000b
-11010110b & 10000010b = 10000010b
-11010110b & 10000011b = 10000010b
-11010110b & 10000100b = 10000100b
-11010110b & 10000101b = 10000100b
-11010110b & 10000110b = 10000110b
-11010110b & 10000111b = 10000110b
-11010110b & 10001000b = 10000000b
-11010110b & 10001001b = 10000000b
-11010110b & 10001010b = 10000010b
-11010110b & 10001011b = 10000010b
-11010110b & 10001100b = 10000100b
-11010110b & 10001101b = 10000100b
-11010110b & 10001110b = 10000110b
-11010110b & 10001111b = 10000110b
-11010110b & 10010000b = 10010000b
-11010110b & 10010001b = 10010000b
-11010110b & 10010010b = 10010010b
-11010110b & 10010011b = 10010010b
-11010110b & 10010100b = 10010100b
-11010110b & 10010101b = 10010100b
-11010110b & 10010110b = 10010110b
-11010110b & 10010111b = 10010110b
-11010110b & 10011000b = 10010000b
-11010110b & 10011001b = 10010000b
-11010110b & 10011010b = 10010010b
-11010110b & 10011011b = 10010010b
-11010110b & 10011100b = 10010100b
-11010110b & 10011101b = 10010100b
-11010110b & 10011110b = 10010110b
-11010110b & 10011111b = 10010110b
-11010110b & 10100000b = 10000000b
-11010110b & 10100001b = 10000000b
-11010110b & 10100010b = 10000010b
-11010110b & 10100011b = 10000010b
-11010110b & 10100100b = 10000100b
-11010110b & 10100101b = 10000100b
-11010110b & 10100110b = 10000110b
-11010110b & 10100111b = 10000110b
-11010110b & 10101000b = 10000000b
-11010110b & 10101001b = 10000000b
-11010110b & 10101010b = 10000010b
-11010110b & 10101011b = 10000010b
-11010110b & 10101100b = 10000100b
-11010110b & 10101101b = 10000100b
-11010110b & 10101110b = 10000110b
-11010110b & 10101111b = 10000110b
-11010110b & 10110000b = 10010000b
-11010110b & 10110001b = 10010000b
-11010110b & 10110010b = 10010010b
-11010110b & 10110011b = 10010010b
-11010110b & 10110100b = 10010100b
-11010110b & 10110101b = 10010100b
-11010110b & 10110110b = 10010110b
-11010110b & 10110111b = 10010110b
-11010110b & 10111000b = 10010000b
-11010110b & 10111001b = 10010000b
-11010110b & 10111010b = 10010010b
-11010110b & 10111011b = 10010010b
-11010110b & 10111100b = 10010100b
-11010110b & 10111101b = 10010100b
-11010110b & 10111110b = 10010110b
-11010110b & 10111111b = 10010110b
-11010110b & 11000000b = 11000000b
-11010110b & 11000001b = 11000000b
-11010110b & 11000010b = 11000010b
-11010110b & 11000011b = 11000010b
-11010110b & 11000100b = 11000100b
-11010110b & 11000101b = 11000100b
-11010110b & 11000110b = 11000110b
-11010110b & 11000111b = 11000110b
-11010110b & 11001000b = 11000000b
-11010110b & 11001001b = 11000000b
-11010110b & 11001010b = 11000010b
-11010110b & 11001011b = 11000010b
-11010110b & 11001100b = 11000100b
-11010110b & 11001101b = 11000100b
-11010110b & 11001110b = 11000110b
-11010110b & 11001111b = 11000110b
-11010110b & 11010000b = 11010000b
-11010110b & 11010001b = 11010000b
-11010110b & 11010010b = 11010010b
-11010110b & 11010011b = 11010010b
-11010110b & 11010100b = 11010100b
-11010110b & 11010101b = 11010100b
-11010110b & 11010110b = 11010110b
-11010110b & 11010111b = 11010110b
-11010110b & 11011000b = 11010000b
-11010110b & 11011001b = 11010000b
-11010110b & 11011010b = 11010010b
-11010110b & 11011011b = 11010010b
-11010110b & 11011100b = 11010100b
-11010110b & 11011101b = 11010100b
-11010110b & 11011110b = 11010110b
-11010110b & 11011111b = 11010110b
-11010110b & 11100000b = 11000000b
-11010110b & 11100001b = 11000000b
-11010110b & 11100010b = 11000010b
-11010110b & 11100011b = 11000010b
-11010110b & 11100100b = 11000100b
-11010110b & 11100101b = 11000100b
-11010110b & 11100110b = 11000110b
-11010110b & 11100111b = 11000110b
-11010110b & 11101000b = 11000000b
-11010110b & 11101001b = 11000000b
-11010110b & 11101010b = 11000010b
-11010110b & 11101011b = 11000010b
-11010110b & 11101100b = 11000100b
-11010110b & 11101101b = 11000100b
-11010110b & 11101110b = 11000110b
-11010110b & 11101111b = 11000110b
-11010110b & 11110000b = 11010000b
-11010110b & 11110001b = 11010000b
-11010110b & 11110010b = 11010010b
-11010110b & 11110011b = 11010010b
-11010110b & 11110100b = 11010100b
-11010110b & 11110101b = 11010100b
-11010110b & 11110110b = 11010110b
-11010110b & 11110111b = 11010110b
-11010110b & 11111000b = 11010000b
-11010110b & 11111001b = 11010000b
-11010110b & 11111010b = 11010010b
-11010110b & 11111011b = 11010010b
-11010110b & 11111100b = 11010100b
-11010110b & 11111101b = 11010100b
-11010110b & 11111110b = 11010110b
-11010110b & 11111111b = 11010110b
-11010110b & 00000000b = 00000000b
-11010110b & 00000001b = 00000000b
-11010110b & 00000010b = 00000010b
-11010110b & 00000011b = 00000010b
-11010110b & 00000100b = 00000100b
-11010110b & 00000101b = 00000100b
-11010110b & 00000110b = 00000110b
-11010110b & 00000111b = 00000110b
-11010110b & 00001000b = 00000000b
-11010110b & 00001001b = 00000000b
-11010110b & 00001010b = 00000010b
-11010110b & 00001011b = 00000010b
-11010110b & 00001100b = 00000100b
-11010110b & 00001101b = 00000100b
-11010110b & 00001110b = 00000110b
-11010110b & 00001111b = 00000110b
-11010110b & 00010000b = 00010000b
-11010110b & 00010001b = 00010000b
-11010110b & 00010010b = 00010010b
-11010110b & 00010011b = 00010010b
-11010110b & 00010100b = 00010100b
-11010110b & 00010101b = 00010100b
-11010110b & 00010110b = 00010110b
-11010110b & 00010111b = 00010110b
-11010110b & 00011000b = 00010000b
-11010110b & 00011001b = 00010000b
-11010110b & 00011010b = 00010010b
-11010110b & 00011011b = 00010010b
-11010110b & 00011100b = 00010100b
-11010110b & 00011101b = 00010100b
-11010110b & 00011110b = 00010110b
-11010110b & 00011111b = 00010110b
-11010110b & 00100000b = 00000000b
-11010110b & 00100001b = 00000000b
-11010110b & 00100010b = 00000010b
-11010110b & 00100011b = 00000010b
-11010110b & 00100100b = 00000100b
-11010110b & 00100101b = 00000100b
-11010110b & 00100110b = 00000110b
-11010110b & 00100111b = 00000110b
-11010110b & 00101000b = 00000000b
-11010110b & 00101001b = 00000000b
-11010110b & 00101010b = 00000010b
-11010110b & 00101011b = 00000010b
-11010110b & 00101100b = 00000100b
-11010110b & 00101101b = 00000100b
-11010110b & 00101110b = 00000110b
-11010110b & 00101111b = 00000110b
-11010110b & 00110000b = 00010000b
-11010110b & 00110001b = 00010000b
-11010110b & 00110010b = 00010010b
-11010110b & 00110011b = 00010010b
-11010110b & 00110100b = 00010100b
-11010110b & 00110101b = 00010100b
-11010110b & 00110110b = 00010110b
-11010110b & 00110111b = 00010110b
-11010110b & 00111000b = 00010000b
-11010110b & 00111001b = 00010000b
-11010110b & 00111010b = 00010010b
-11010110b & 00111011b = 00010010b
-11010110b & 00111100b = 00010100b
-11010110b & 00111101b = 00010100b
-11010110b & 00111110b = 00010110b
-11010110b & 00111111b = 00010110b
-11010110b & 01000000b = 01000000b
-11010110b & 01000001b = 01000000b
-11010110b & 01000010b = 01000010b
-11010110b & 01000011b = 01000010b
-11010110b & 01000100b = 01000100b
-11010110b & 01000101b = 01000100b
-11010110b & 01000110b = 01000110b
-11010110b & 01000111b = 01000110b
-11010110b & 01001000b = 01000000b
-11010110b & 01001001b = 01000000b
-11010110b & 01001010b = 01000010b
-11010110b & 01001011b = 01000010b
-11010110b & 01001100b = 01000100b
-11010110b & 01001101b = 01000100b
-11010110b & 01001110b = 01000110b
-11010110b & 01001111b = 01000110b
-11010110b & 01010000b = 01010000b
-11010110b & 01010001b = 01010000b
-11010110b & 01010010b = 01010010b
-11010110b & 01010011b = 01010010b
-11010110b & 01010100b = 01010100b
-11010110b & 01010101b = 01010100b
-11010110b & 01010110b = 01010110b
-11010110b & 01010111b = 01010110b
-11010110b & 01011000b = 01010000b
-11010110b & 01011001b = 01010000b
-11010110b & 01011010b = 01010010b
-11010110b & 01011011b = 01010010b
-11010110b & 01011100b = 01010100b
-11010110b & 01011101b = 01010100b
-11010110b & 01011110b = 01010110b
-11010110b & 01011111b = 01010110b
-11010110b & 01100000b = 01000000b
-11010110b & 01100001b = 01000000b
-11010110b & 01100010b = 01000010b
-11010110b & 01100011b = 01000010b
-11010110b & 01100100b = 01000100b
-11010110b & 01100101b = 01000100b
-11010110b & 01100110b = 01000110b
-11010110b & 01100111b = 01000110b
-11010110b & 01101000b = 01000000b
-11010110b & 01101001b = 01000000b
-11010110b & 01101010b = 01000010b
-11010110b & 01101011b = 01000010b
-11010110b & 01101100b = 01000100b
-11010110b & 01101101b = 01000100b
-11010110b & 01101110b = 01000110b
-11010110b & 01101111b = 01000110b
-11010110b & 01110000b = 01010000b
-11010110b & 01110001b = 01010000b
-11010110b & 01110010b = 01010010b
-11010110b & 01110011b = 01010010b
-11010110b & 01110100b = 01010100b
-11010110b & 01110101b = 01010100b
-11010110b & 01110110b = 01010110b
-11010110b & 01110111b = 01010110b
-11010110b & 01111000b = 01010000b
-11010110b & 01111001b = 01010000b
-11010110b & 01111010b = 01010010b
-11010110b & 01111011b = 01010010b
-11010110b & 01111100b = 01010100b
-11010110b & 01111101b = 01010100b
-11010110b & 01111110b = 01010110b
-11010111b & 10000000b = 10000000b
-11010111b & 10000001b = 10000001b
-11010111b & 10000010b = 10000010b
-11010111b & 10000011b = 10000011b
-11010111b & 10000100b = 10000100b
-11010111b & 10000101b = 10000101b
-11010111b & 10000110b = 10000110b
-11010111b & 10000111b = 10000111b
-11010111b & 10001000b = 10000000b
-11010111b & 10001001b = 10000001b
-11010111b & 10001010b = 10000010b
-11010111b & 10001011b = 10000011b
-11010111b & 10001100b = 10000100b
-11010111b & 10001101b = 10000101b
-11010111b & 10001110b = 10000110b
-11010111b & 10001111b = 10000111b
-11010111b & 10010000b = 10010000b
-11010111b & 10010001b = 10010001b
-11010111b & 10010010b = 10010010b
-11010111b & 10010011b = 10010011b
-11010111b & 10010100b = 10010100b
-11010111b & 10010101b = 10010101b
-11010111b & 10010110b = 10010110b
-11010111b & 10010111b = 10010111b
-11010111b & 10011000b = 10010000b
-11010111b & 10011001b = 10010001b
-11010111b & 10011010b = 10010010b
-11010111b & 10011011b = 10010011b
-11010111b & 10011100b = 10010100b
-11010111b & 10011101b = 10010101b
-11010111b & 10011110b = 10010110b
-11010111b & 10011111b = 10010111b
-11010111b & 10100000b = 10000000b
-11010111b & 10100001b = 10000001b
-11010111b & 10100010b = 10000010b
-11010111b & 10100011b = 10000011b
-11010111b & 10100100b = 10000100b
-11010111b & 10100101b = 10000101b
-11010111b & 10100110b = 10000110b
-11010111b & 10100111b = 10000111b
-11010111b & 10101000b = 10000000b
-11010111b & 10101001b = 10000001b
-11010111b & 10101010b = 10000010b
-11010111b & 10101011b = 10000011b
-11010111b & 10101100b = 10000100b
-11010111b & 10101101b = 10000101b
-11010111b & 10101110b = 10000110b
-11010111b & 10101111b = 10000111b
-11010111b & 10110000b = 10010000b
-11010111b & 10110001b = 10010001b
-11010111b & 10110010b = 10010010b
-11010111b & 10110011b = 10010011b
-11010111b & 10110100b = 10010100b
-11010111b & 10110101b = 10010101b
-11010111b & 10110110b = 10010110b
-11010111b & 10110111b = 10010111b
-11010111b & 10111000b = 10010000b
-11010111b & 10111001b = 10010001b
-11010111b & 10111010b = 10010010b
-11010111b & 10111011b = 10010011b
-11010111b & 10111100b = 10010100b
-11010111b & 10111101b = 10010101b
-11010111b & 10111110b = 10010110b
-11010111b & 10111111b = 10010111b
-11010111b & 11000000b = 11000000b
-11010111b & 11000001b = 11000001b
-11010111b & 11000010b = 11000010b
-11010111b & 11000011b = 11000011b
-11010111b & 11000100b = 11000100b
-11010111b & 11000101b = 11000101b
-11010111b & 11000110b = 11000110b
-11010111b & 11000111b = 11000111b
-11010111b & 11001000b = 11000000b
-11010111b & 11001001b = 11000001b
-11010111b & 11001010b = 11000010b
-11010111b & 11001011b = 11000011b
-11010111b & 11001100b = 11000100b
-11010111b & 11001101b = 11000101b
-11010111b & 11001110b = 11000110b
-11010111b & 11001111b = 11000111b
-11010111b & 11010000b = 11010000b
-11010111b & 11010001b = 11010001b
-11010111b & 11010010b = 11010010b
-11010111b & 11010011b = 11010011b
-11010111b & 11010100b = 11010100b
-11010111b & 11010101b = 11010101b
-11010111b & 11010110b = 11010110b
-11010111b & 11010111b = 11010111b
-11010111b & 11011000b = 11010000b
-11010111b & 11011001b = 11010001b
-11010111b & 11011010b = 11010010b
-11010111b & 11011011b = 11010011b
-11010111b & 11011100b = 11010100b
-11010111b & 11011101b = 11010101b
-11010111b & 11011110b = 11010110b
-11010111b & 11011111b = 11010111b
-11010111b & 11100000b = 11000000b
-11010111b & 11100001b = 11000001b
-11010111b & 11100010b = 11000010b
-11010111b & 11100011b = 11000011b
-11010111b & 11100100b = 11000100b
-11010111b & 11100101b = 11000101b
-11010111b & 11100110b = 11000110b
-11010111b & 11100111b = 11000111b
-11010111b & 11101000b = 11000000b
-11010111b & 11101001b = 11000001b
-11010111b & 11101010b = 11000010b
-11010111b & 11101011b = 11000011b
-11010111b & 11101100b = 11000100b
-11010111b & 11101101b = 11000101b
-11010111b & 11101110b = 11000110b
-11010111b & 11101111b = 11000111b
-11010111b & 11110000b = 11010000b
-11010111b & 11110001b = 11010001b
-11010111b & 11110010b = 11010010b
-11010111b & 11110011b = 11010011b
-11010111b & 11110100b = 11010100b
-11010111b & 11110101b = 11010101b
-11010111b & 11110110b = 11010110b
-11010111b & 11110111b = 11010111b
-11010111b & 11111000b = 11010000b
-11010111b & 11111001b = 11010001b
-11010111b & 11111010b = 11010010b
-11010111b & 11111011b = 11010011b
-11010111b & 11111100b = 11010100b
-11010111b & 11111101b = 11010101b
-11010111b & 11111110b = 11010110b
-11010111b & 11111111b = 11010111b
-11010111b & 00000000b = 00000000b
-11010111b & 00000001b = 00000001b
-11010111b & 00000010b = 00000010b
-11010111b & 00000011b = 00000011b
-11010111b & 00000100b = 00000100b
-11010111b & 00000101b = 00000101b
-11010111b & 00000110b = 00000110b
-11010111b & 00000111b = 00000111b
-11010111b & 00001000b = 00000000b
-11010111b & 00001001b = 00000001b
-11010111b & 00001010b = 00000010b
-11010111b & 00001011b = 00000011b
-11010111b & 00001100b = 00000100b
-11010111b & 00001101b = 00000101b
-11010111b & 00001110b = 00000110b
-11010111b & 00001111b = 00000111b
-11010111b & 00010000b = 00010000b
-11010111b & 00010001b = 00010001b
-11010111b & 00010010b = 00010010b
-11010111b & 00010011b = 00010011b
-11010111b & 00010100b = 00010100b
-11010111b & 00010101b = 00010101b
-11010111b & 00010110b = 00010110b
-11010111b & 00010111b = 00010111b
-11010111b & 00011000b = 00010000b
-11010111b & 00011001b = 00010001b
-11010111b & 00011010b = 00010010b
-11010111b & 00011011b = 00010011b
-11010111b & 00011100b = 00010100b
-11010111b & 00011101b = 00010101b
-11010111b & 00011110b = 00010110b
-11010111b & 00011111b = 00010111b
-11010111b & 00100000b = 00000000b
-11010111b & 00100001b = 00000001b
-11010111b & 00100010b = 00000010b
-11010111b & 00100011b = 00000011b
-11010111b & 00100100b = 00000100b
-11010111b & 00100101b = 00000101b
-11010111b & 00100110b = 00000110b
-11010111b & 00100111b = 00000111b
-11010111b & 00101000b = 00000000b
-11010111b & 00101001b = 00000001b
-11010111b & 00101010b = 00000010b
-11010111b & 00101011b = 00000011b
-11010111b & 00101100b = 00000100b
-11010111b & 00101101b = 00000101b
-11010111b & 00101110b = 00000110b
-11010111b & 00101111b = 00000111b
-11010111b & 00110000b = 00010000b
-11010111b & 00110001b = 00010001b
-11010111b & 00110010b = 00010010b
-11010111b & 00110011b = 00010011b
-11010111b & 00110100b = 00010100b
-11010111b & 00110101b = 00010101b
-11010111b & 00110110b = 00010110b
-11010111b & 00110111b = 00010111b
-11010111b & 00111000b = 00010000b
-11010111b & 00111001b = 00010001b
-11010111b & 00111010b = 00010010b
-11010111b & 00111011b = 00010011b
-11010111b & 00111100b = 00010100b
-11010111b & 00111101b = 00010101b
-11010111b & 00111110b = 00010110b
-11010111b & 00111111b = 00010111b
-11010111b & 01000000b = 01000000b
-11010111b & 01000001b = 01000001b
-11010111b & 01000010b = 01000010b
-11010111b & 01000011b = 01000011b
-11010111b & 01000100b = 01000100b
-11010111b & 01000101b = 01000101b
-11010111b & 01000110b = 01000110b
-11010111b & 01000111b = 01000111b
-11010111b & 01001000b = 01000000b
-11010111b & 01001001b = 01000001b
-11010111b & 01001010b = 01000010b
-11010111b & 01001011b = 01000011b
-11010111b & 01001100b = 01000100b
-11010111b & 01001101b = 01000101b
-11010111b & 01001110b = 01000110b
-11010111b & 01001111b = 01000111b
-11010111b & 01010000b = 01010000b
-11010111b & 01010001b = 01010001b
-11010111b & 01010010b = 01010010b
-11010111b & 01010011b = 01010011b
-11010111b & 01010100b = 01010100b
-11010111b & 01010101b = 01010101b
-11010111b & 01010110b = 01010110b
-11010111b & 01010111b = 01010111b
-11010111b & 01011000b = 01010000b
-11010111b & 01011001b = 01010001b
-11010111b & 01011010b = 01010010b
-11010111b & 01011011b = 01010011b
-11010111b & 01011100b = 01010100b
-11010111b & 01011101b = 01010101b
-11010111b & 01011110b = 01010110b
-11010111b & 01011111b = 01010111b
-11010111b & 01100000b = 01000000b
-11010111b & 01100001b = 01000001b
-11010111b & 01100010b = 01000010b
-11010111b & 01100011b = 01000011b
-11010111b & 01100100b = 01000100b
-11010111b & 01100101b = 01000101b
-11010111b & 01100110b = 01000110b
-11010111b & 01100111b = 01000111b
-11010111b & 01101000b = 01000000b
-11010111b & 01101001b = 01000001b
-11010111b & 01101010b = 01000010b
-11010111b & 01101011b = 01000011b
-11010111b & 01101100b = 01000100b
-11010111b & 01101101b = 01000101b
-11010111b & 01101110b = 01000110b
-11010111b & 01101111b = 01000111b
-11010111b & 01110000b = 01010000b
-11010111b & 01110001b = 01010001b
-11010111b & 01110010b = 01010010b
-11010111b & 01110011b = 01010011b
-11010111b & 01110100b = 01010100b
-11010111b & 01110101b = 01010101b
-11010111b & 01110110b = 01010110b
-11010111b & 01110111b = 01010111b
-11010111b & 01111000b = 01010000b
-11010111b & 01111001b = 01010001b
-11010111b & 01111010b = 01010010b
-11010111b & 01111011b = 01010011b
-11010111b & 01111100b = 01010100b
-11010111b & 01111101b = 01010101b
-11010111b & 01111110b = 01010110b
-11011000b & 10000000b = 10000000b
-11011000b & 10000001b = 10000000b
-11011000b & 10000010b = 10000000b
-11011000b & 10000011b = 10000000b
-11011000b & 10000100b = 10000000b
-11011000b & 10000101b = 10000000b
-11011000b & 10000110b = 10000000b
-11011000b & 10000111b = 10000000b
-11011000b & 10001000b = 10001000b
-11011000b & 10001001b = 10001000b
-11011000b & 10001010b = 10001000b
-11011000b & 10001011b = 10001000b
-11011000b & 10001100b = 10001000b
-11011000b & 10001101b = 10001000b
-11011000b & 10001110b = 10001000b
-11011000b & 10001111b = 10001000b
-11011000b & 10010000b = 10010000b
-11011000b & 10010001b = 10010000b
-11011000b & 10010010b = 10010000b
-11011000b & 10010011b = 10010000b
-11011000b & 10010100b = 10010000b
-11011000b & 10010101b = 10010000b
-11011000b & 10010110b = 10010000b
-11011000b & 10010111b = 10010000b
-11011000b & 10011000b = 10011000b
-11011000b & 10011001b = 10011000b
-11011000b & 10011010b = 10011000b
-11011000b & 10011011b = 10011000b
-11011000b & 10011100b = 10011000b
-11011000b & 10011101b = 10011000b
-11011000b & 10011110b = 10011000b
-11011000b & 10011111b = 10011000b
-11011000b & 10100000b = 10000000b
-11011000b & 10100001b = 10000000b
-11011000b & 10100010b = 10000000b
-11011000b & 10100011b = 10000000b
-11011000b & 10100100b = 10000000b
-11011000b & 10100101b = 10000000b
-11011000b & 10100110b = 10000000b
-11011000b & 10100111b = 10000000b
-11011000b & 10101000b = 10001000b
-11011000b & 10101001b = 10001000b
-11011000b & 10101010b = 10001000b
-11011000b & 10101011b = 10001000b
-11011000b & 10101100b = 10001000b
-11011000b & 10101101b = 10001000b
-11011000b & 10101110b = 10001000b
-11011000b & 10101111b = 10001000b
-11011000b & 10110000b = 10010000b
-11011000b & 10110001b = 10010000b
-11011000b & 10110010b = 10010000b
-11011000b & 10110011b = 10010000b
-11011000b & 10110100b = 10010000b
-11011000b & 10110101b = 10010000b
-11011000b & 10110110b = 10010000b
-11011000b & 10110111b = 10010000b
-11011000b & 10111000b = 10011000b
-11011000b & 10111001b = 10011000b
-11011000b & 10111010b = 10011000b
-11011000b & 10111011b = 10011000b
-11011000b & 10111100b = 10011000b
-11011000b & 10111101b = 10011000b
-11011000b & 10111110b = 10011000b
-11011000b & 10111111b = 10011000b
-11011000b & 11000000b = 11000000b
-11011000b & 11000001b = 11000000b
-11011000b & 11000010b = 11000000b
-11011000b & 11000011b = 11000000b
-11011000b & 11000100b = 11000000b
-11011000b & 11000101b = 11000000b
-11011000b & 11000110b = 11000000b
-11011000b & 11000111b = 11000000b
-11011000b & 11001000b = 11001000b
-11011000b & 11001001b = 11001000b
-11011000b & 11001010b = 11001000b
-11011000b & 11001011b = 11001000b
-11011000b & 11001100b = 11001000b
-11011000b & 11001101b = 11001000b
-11011000b & 11001110b = 11001000b
-11011000b & 11001111b = 11001000b
-11011000b & 11010000b = 11010000b
-11011000b & 11010001b = 11010000b
-11011000b & 11010010b = 11010000b
-11011000b & 11010011b = 11010000b
-11011000b & 11010100b = 11010000b
-11011000b & 11010101b = 11010000b
-11011000b & 11010110b = 11010000b
-11011000b & 11010111b = 11010000b
-11011000b & 11011000b = 11011000b
-11011000b & 11011001b = 11011000b
-11011000b & 11011010b = 11011000b
-11011000b & 11011011b = 11011000b
-11011000b & 11011100b = 11011000b
-11011000b & 11011101b = 11011000b
-11011000b & 11011110b = 11011000b
-11011000b & 11011111b = 11011000b
-11011000b & 11100000b = 11000000b
-11011000b & 11100001b = 11000000b
-11011000b & 11100010b = 11000000b
-11011000b & 11100011b = 11000000b
-11011000b & 11100100b = 11000000b
-11011000b & 11100101b = 11000000b
-11011000b & 11100110b = 11000000b
-11011000b & 11100111b = 11000000b
-11011000b & 11101000b = 11001000b
-11011000b & 11101001b = 11001000b
-11011000b & 11101010b = 11001000b
-11011000b & 11101011b = 11001000b
-11011000b & 11101100b = 11001000b
-11011000b & 11101101b = 11001000b
-11011000b & 11101110b = 11001000b
-11011000b & 11101111b = 11001000b
-11011000b & 11110000b = 11010000b
-11011000b & 11110001b = 11010000b
-11011000b & 11110010b = 11010000b
-11011000b & 11110011b = 11010000b
-11011000b & 11110100b = 11010000b
-11011000b & 11110101b = 11010000b
-11011000b & 11110110b = 11010000b
-11011000b & 11110111b = 11010000b
-11011000b & 11111000b = 11011000b
-11011000b & 11111001b = 11011000b
-11011000b & 11111010b = 11011000b
-11011000b & 11111011b = 11011000b
-11011000b & 11111100b = 11011000b
-11011000b & 11111101b = 11011000b
-11011000b & 11111110b = 11011000b
-11011000b & 11111111b = 11011000b
-11011000b & 00000000b = 00000000b
-11011000b & 00000001b = 00000000b
-11011000b & 00000010b = 00000000b
-11011000b & 00000011b = 00000000b
-11011000b & 00000100b = 00000000b
-11011000b & 00000101b = 00000000b
-11011000b & 00000110b = 00000000b
-11011000b & 00000111b = 00000000b
-11011000b & 00001000b = 00001000b
-11011000b & 00001001b = 00001000b
-11011000b & 00001010b = 00001000b
-11011000b & 00001011b = 00001000b
-11011000b & 00001100b = 00001000b
-11011000b & 00001101b = 00001000b
-11011000b & 00001110b = 00001000b
-11011000b & 00001111b = 00001000b
-11011000b & 00010000b = 00010000b
-11011000b & 00010001b = 00010000b
-11011000b & 00010010b = 00010000b
-11011000b & 00010011b = 00010000b
-11011000b & 00010100b = 00010000b
-11011000b & 00010101b = 00010000b
-11011000b & 00010110b = 00010000b
-11011000b & 00010111b = 00010000b
-11011000b & 00011000b = 00011000b
-11011000b & 00011001b = 00011000b
-11011000b & 00011010b = 00011000b
-11011000b & 00011011b = 00011000b
-11011000b & 00011100b = 00011000b
-11011000b & 00011101b = 00011000b
-11011000b & 00011110b = 00011000b
-11011000b & 00011111b = 00011000b
-11011000b & 00100000b = 00000000b
-11011000b & 00100001b = 00000000b
-11011000b & 00100010b = 00000000b
-11011000b & 00100011b = 00000000b
-11011000b & 00100100b = 00000000b
-11011000b & 00100101b = 00000000b
-11011000b & 00100110b = 00000000b
-11011000b & 00100111b = 00000000b
-11011000b & 00101000b = 00001000b
-11011000b & 00101001b = 00001000b
-11011000b & 00101010b = 00001000b
-11011000b & 00101011b = 00001000b
-11011000b & 00101100b = 00001000b
-11011000b & 00101101b = 00001000b
-11011000b & 00101110b = 00001000b
-11011000b & 00101111b = 00001000b
-11011000b & 00110000b = 00010000b
-11011000b & 00110001b = 00010000b
-11011000b & 00110010b = 00010000b
-11011000b & 00110011b = 00010000b
-11011000b & 00110100b = 00010000b
-11011000b & 00110101b = 00010000b
-11011000b & 00110110b = 00010000b
-11011000b & 00110111b = 00010000b
-11011000b & 00111000b = 00011000b
-11011000b & 00111001b = 00011000b
-11011000b & 00111010b = 00011000b
-11011000b & 00111011b = 00011000b
-11011000b & 00111100b = 00011000b
-11011000b & 00111101b = 00011000b
-11011000b & 00111110b = 00011000b
-11011000b & 00111111b = 00011000b
-11011000b & 01000000b = 01000000b
-11011000b & 01000001b = 01000000b
-11011000b & 01000010b = 01000000b
-11011000b & 01000011b = 01000000b
-11011000b & 01000100b = 01000000b
-11011000b & 01000101b = 01000000b
-11011000b & 01000110b = 01000000b
-11011000b & 01000111b = 01000000b
-11011000b & 01001000b = 01001000b
-11011000b & 01001001b = 01001000b
-11011000b & 01001010b = 01001000b
-11011000b & 01001011b = 01001000b
-11011000b & 01001100b = 01001000b
-11011000b & 01001101b = 01001000b
-11011000b & 01001110b = 01001000b
-11011000b & 01001111b = 01001000b
-11011000b & 01010000b = 01010000b
-11011000b & 01010001b = 01010000b
-11011000b & 01010010b = 01010000b
-11011000b & 01010011b = 01010000b
-11011000b & 01010100b = 01010000b
-11011000b & 01010101b = 01010000b
-11011000b & 01010110b = 01010000b
-11011000b & 01010111b = 01010000b
-11011000b & 01011000b = 01011000b
-11011000b & 01011001b = 01011000b
-11011000b & 01011010b = 01011000b
-11011000b & 01011011b = 01011000b
-11011000b & 01011100b = 01011000b
-11011000b & 01011101b = 01011000b
-11011000b & 01011110b = 01011000b
-11011000b & 01011111b = 01011000b
-11011000b & 01100000b = 01000000b
-11011000b & 01100001b = 01000000b
-11011000b & 01100010b = 01000000b
-11011000b & 01100011b = 01000000b
-11011000b & 01100100b = 01000000b
-11011000b & 01100101b = 01000000b
-11011000b & 01100110b = 01000000b
-11011000b & 01100111b = 01000000b
-11011000b & 01101000b = 01001000b
-11011000b & 01101001b = 01001000b
-11011000b & 01101010b = 01001000b
-11011000b & 01101011b = 01001000b
-11011000b & 01101100b = 01001000b
-11011000b & 01101101b = 01001000b
-11011000b & 01101110b = 01001000b
-11011000b & 01101111b = 01001000b
-11011000b & 01110000b = 01010000b
-11011000b & 01110001b = 01010000b
-11011000b & 01110010b = 01010000b
-11011000b & 01110011b = 01010000b
-11011000b & 01110100b = 01010000b
-11011000b & 01110101b = 01010000b
-11011000b & 01110110b = 01010000b
-11011000b & 01110111b = 01010000b
-11011000b & 01111000b = 01011000b
-11011000b & 01111001b = 01011000b
-11011000b & 01111010b = 01011000b
-11011000b & 01111011b = 01011000b
-11011000b & 01111100b = 01011000b
-11011000b & 01111101b = 01011000b
-11011000b & 01111110b = 01011000b
-11011001b & 10000000b = 10000000b
-11011001b & 10000001b = 10000001b
-11011001b & 10000010b = 10000000b
-11011001b & 10000011b = 10000001b
-11011001b & 10000100b = 10000000b
-11011001b & 10000101b = 10000001b
-11011001b & 10000110b = 10000000b
-11011001b & 10000111b = 10000001b
-11011001b & 10001000b = 10001000b
-11011001b & 10001001b = 10001001b
-11011001b & 10001010b = 10001000b
-11011001b & 10001011b = 10001001b
-11011001b & 10001100b = 10001000b
-11011001b & 10001101b = 10001001b
-11011001b & 10001110b = 10001000b
-11011001b & 10001111b = 10001001b
-11011001b & 10010000b = 10010000b
-11011001b & 10010001b = 10010001b
-11011001b & 10010010b = 10010000b
-11011001b & 10010011b = 10010001b
-11011001b & 10010100b = 10010000b
-11011001b & 10010101b = 10010001b
-11011001b & 10010110b = 10010000b
-11011001b & 10010111b = 10010001b
-11011001b & 10011000b = 10011000b
-11011001b & 10011001b = 10011001b
-11011001b & 10011010b = 10011000b
-11011001b & 10011011b = 10011001b
-11011001b & 10011100b = 10011000b
-11011001b & 10011101b = 10011001b
-11011001b & 10011110b = 10011000b
-11011001b & 10011111b = 10011001b
-11011001b & 10100000b = 10000000b
-11011001b & 10100001b = 10000001b
-11011001b & 10100010b = 10000000b
-11011001b & 10100011b = 10000001b
-11011001b & 10100100b = 10000000b
-11011001b & 10100101b = 10000001b
-11011001b & 10100110b = 10000000b
-11011001b & 10100111b = 10000001b
-11011001b & 10101000b = 10001000b
-11011001b & 10101001b = 10001001b
-11011001b & 10101010b = 10001000b
-11011001b & 10101011b = 10001001b
-11011001b & 10101100b = 10001000b
-11011001b & 10101101b = 10001001b
-11011001b & 10101110b = 10001000b
-11011001b & 10101111b = 10001001b
-11011001b & 10110000b = 10010000b
-11011001b & 10110001b = 10010001b
-11011001b & 10110010b = 10010000b
-11011001b & 10110011b = 10010001b
-11011001b & 10110100b = 10010000b
-11011001b & 10110101b = 10010001b
-11011001b & 10110110b = 10010000b
-11011001b & 10110111b = 10010001b
-11011001b & 10111000b = 10011000b
-11011001b & 10111001b = 10011001b
-11011001b & 10111010b = 10011000b
-11011001b & 10111011b = 10011001b
-11011001b & 10111100b = 10011000b
-11011001b & 10111101b = 10011001b
-11011001b & 10111110b = 10011000b
-11011001b & 10111111b = 10011001b
-11011001b & 11000000b = 11000000b
-11011001b & 11000001b = 11000001b
-11011001b & 11000010b = 11000000b
-11011001b & 11000011b = 11000001b
-11011001b & 11000100b = 11000000b
-11011001b & 11000101b = 11000001b
-11011001b & 11000110b = 11000000b
-11011001b & 11000111b = 11000001b
-11011001b & 11001000b = 11001000b
-11011001b & 11001001b = 11001001b
-11011001b & 11001010b = 11001000b
-11011001b & 11001011b = 11001001b
-11011001b & 11001100b = 11001000b
-11011001b & 11001101b = 11001001b
-11011001b & 11001110b = 11001000b
-11011001b & 11001111b = 11001001b
-11011001b & 11010000b = 11010000b
-11011001b & 11010001b = 11010001b
-11011001b & 11010010b = 11010000b
-11011001b & 11010011b = 11010001b
-11011001b & 11010100b = 11010000b
-11011001b & 11010101b = 11010001b
-11011001b & 11010110b = 11010000b
-11011001b & 11010111b = 11010001b
-11011001b & 11011000b = 11011000b
-11011001b & 11011001b = 11011001b
-11011001b & 11011010b = 11011000b
-11011001b & 11011011b = 11011001b
-11011001b & 11011100b = 11011000b
-11011001b & 11011101b = 11011001b
-11011001b & 11011110b = 11011000b
-11011001b & 11011111b = 11011001b
-11011001b & 11100000b = 11000000b
-11011001b & 11100001b = 11000001b
-11011001b & 11100010b = 11000000b
-11011001b & 11100011b = 11000001b
-11011001b & 11100100b = 11000000b
-11011001b & 11100101b = 11000001b
-11011001b & 11100110b = 11000000b
-11011001b & 11100111b = 11000001b
-11011001b & 11101000b = 11001000b
-11011001b & 11101001b = 11001001b
-11011001b & 11101010b = 11001000b
-11011001b & 11101011b = 11001001b
-11011001b & 11101100b = 11001000b
-11011001b & 11101101b = 11001001b
-11011001b & 11101110b = 11001000b
-11011001b & 11101111b = 11001001b
-11011001b & 11110000b = 11010000b
-11011001b & 11110001b = 11010001b
-11011001b & 11110010b = 11010000b
-11011001b & 11110011b = 11010001b
-11011001b & 11110100b = 11010000b
-11011001b & 11110101b = 11010001b
-11011001b & 11110110b = 11010000b
-11011001b & 11110111b = 11010001b
-11011001b & 11111000b = 11011000b
-11011001b & 11111001b = 11011001b
-11011001b & 11111010b = 11011000b
-11011001b & 11111011b = 11011001b
-11011001b & 11111100b = 11011000b
-11011001b & 11111101b = 11011001b
-11011001b & 11111110b = 11011000b
-11011001b & 11111111b = 11011001b
-11011001b & 00000000b = 00000000b
-11011001b & 00000001b = 00000001b
-11011001b & 00000010b = 00000000b
-11011001b & 00000011b = 00000001b
-11011001b & 00000100b = 00000000b
-11011001b & 00000101b = 00000001b
-11011001b & 00000110b = 00000000b
-11011001b & 00000111b = 00000001b
-11011001b & 00001000b = 00001000b
-11011001b & 00001001b = 00001001b
-11011001b & 00001010b = 00001000b
-11011001b & 00001011b = 00001001b
-11011001b & 00001100b = 00001000b
-11011001b & 00001101b = 00001001b
-11011001b & 00001110b = 00001000b
-11011001b & 00001111b = 00001001b
-11011001b & 00010000b = 00010000b
-11011001b & 00010001b = 00010001b
-11011001b & 00010010b = 00010000b
-11011001b & 00010011b = 00010001b
-11011001b & 00010100b = 00010000b
-11011001b & 00010101b = 00010001b
-11011001b & 00010110b = 00010000b
-11011001b & 00010111b = 00010001b
-11011001b & 00011000b = 00011000b
-11011001b & 00011001b = 00011001b
-11011001b & 00011010b = 00011000b
-11011001b & 00011011b = 00011001b
-11011001b & 00011100b = 00011000b
-11011001b & 00011101b = 00011001b
-11011001b & 00011110b = 00011000b
-11011001b & 00011111b = 00011001b
-11011001b & 00100000b = 00000000b
-11011001b & 00100001b = 00000001b
-11011001b & 00100010b = 00000000b
-11011001b & 00100011b = 00000001b
-11011001b & 00100100b = 00000000b
-11011001b & 00100101b = 00000001b
-11011001b & 00100110b = 00000000b
-11011001b & 00100111b = 00000001b
-11011001b & 00101000b = 00001000b
-11011001b & 00101001b = 00001001b
-11011001b & 00101010b = 00001000b
-11011001b & 00101011b = 00001001b
-11011001b & 00101100b = 00001000b
-11011001b & 00101101b = 00001001b
-11011001b & 00101110b = 00001000b
-11011001b & 00101111b = 00001001b
-11011001b & 00110000b = 00010000b
-11011001b & 00110001b = 00010001b
-11011001b & 00110010b = 00010000b
-11011001b & 00110011b = 00010001b
-11011001b & 00110100b = 00010000b
-11011001b & 00110101b = 00010001b
-11011001b & 00110110b = 00010000b
-11011001b & 00110111b = 00010001b
-11011001b & 00111000b = 00011000b
-11011001b & 00111001b = 00011001b
-11011001b & 00111010b = 00011000b
-11011001b & 00111011b = 00011001b
-11011001b & 00111100b = 00011000b
-11011001b & 00111101b = 00011001b
-11011001b & 00111110b = 00011000b
-11011001b & 00111111b = 00011001b
-11011001b & 01000000b = 01000000b
-11011001b & 01000001b = 01000001b
-11011001b & 01000010b = 01000000b
-11011001b & 01000011b = 01000001b
-11011001b & 01000100b = 01000000b
-11011001b & 01000101b = 01000001b
-11011001b & 01000110b = 01000000b
-11011001b & 01000111b = 01000001b
-11011001b & 01001000b = 01001000b
-11011001b & 01001001b = 01001001b
-11011001b & 01001010b = 01001000b
-11011001b & 01001011b = 01001001b
-11011001b & 01001100b = 01001000b
-11011001b & 01001101b = 01001001b
-11011001b & 01001110b = 01001000b
-11011001b & 01001111b = 01001001b
-11011001b & 01010000b = 01010000b
-11011001b & 01010001b = 01010001b
-11011001b & 01010010b = 01010000b
-11011001b & 01010011b = 01010001b
-11011001b & 01010100b = 01010000b
-11011001b & 01010101b = 01010001b
-11011001b & 01010110b = 01010000b
-11011001b & 01010111b = 01010001b
-11011001b & 01011000b = 01011000b
-11011001b & 01011001b = 01011001b
-11011001b & 01011010b = 01011000b
-11011001b & 01011011b = 01011001b
-11011001b & 01011100b = 01011000b
-11011001b & 01011101b = 01011001b
-11011001b & 01011110b = 01011000b
-11011001b & 01011111b = 01011001b
-11011001b & 01100000b = 01000000b
-11011001b & 01100001b = 01000001b
-11011001b & 01100010b = 01000000b
-11011001b & 01100011b = 01000001b
-11011001b & 01100100b = 01000000b
-11011001b & 01100101b = 01000001b
-11011001b & 01100110b = 01000000b
-11011001b & 01100111b = 01000001b
-11011001b & 01101000b = 01001000b
-11011001b & 01101001b = 01001001b
-11011001b & 01101010b = 01001000b
-11011001b & 01101011b = 01001001b
-11011001b & 01101100b = 01001000b
-11011001b & 01101101b = 01001001b
-11011001b & 01101110b = 01001000b
-11011001b & 01101111b = 01001001b
-11011001b & 01110000b = 01010000b
-11011001b & 01110001b = 01010001b
-11011001b & 01110010b = 01010000b
-11011001b & 01110011b = 01010001b
-11011001b & 01110100b = 01010000b
-11011001b & 01110101b = 01010001b
-11011001b & 01110110b = 01010000b
-11011001b & 01110111b = 01010001b
-11011001b & 01111000b = 01011000b
-11011001b & 01111001b = 01011001b
-11011001b & 01111010b = 01011000b
-11011001b & 01111011b = 01011001b
-11011001b & 01111100b = 01011000b
-11011001b & 01111101b = 01011001b
-11011001b & 01111110b = 01011000b
-11011010b & 10000000b = 10000000b
-11011010b & 10000001b = 10000000b
-11011010b & 10000010b = 10000010b
-11011010b & 10000011b = 10000010b
-11011010b & 10000100b = 10000000b
-11011010b & 10000101b = 10000000b
-11011010b & 10000110b = 10000010b
-11011010b & 10000111b = 10000010b
-11011010b & 10001000b = 10001000b
-11011010b & 10001001b = 10001000b
-11011010b & 10001010b = 10001010b
-11011010b & 10001011b = 10001010b
-11011010b & 10001100b = 10001000b
-11011010b & 10001101b = 10001000b
-11011010b & 10001110b = 10001010b
-11011010b & 10001111b = 10001010b
-11011010b & 10010000b = 10010000b
-11011010b & 10010001b = 10010000b
-11011010b & 10010010b = 10010010b
-11011010b & 10010011b = 10010010b
-11011010b & 10010100b = 10010000b
-11011010b & 10010101b = 10010000b
-11011010b & 10010110b = 10010010b
-11011010b & 10010111b = 10010010b
-11011010b & 10011000b = 10011000b
-11011010b & 10011001b = 10011000b
-11011010b & 10011010b = 10011010b
-11011010b & 10011011b = 10011010b
-11011010b & 10011100b = 10011000b
-11011010b & 10011101b = 10011000b
-11011010b & 10011110b = 10011010b
-11011010b & 10011111b = 10011010b
-11011010b & 10100000b = 10000000b
-11011010b & 10100001b = 10000000b
-11011010b & 10100010b = 10000010b
-11011010b & 10100011b = 10000010b
-11011010b & 10100100b = 10000000b
-11011010b & 10100101b = 10000000b
-11011010b & 10100110b = 10000010b
-11011010b & 10100111b = 10000010b
-11011010b & 10101000b = 10001000b
-11011010b & 10101001b = 10001000b
-11011010b & 10101010b = 10001010b
-11011010b & 10101011b = 10001010b
-11011010b & 10101100b = 10001000b
-11011010b & 10101101b = 10001000b
-11011010b & 10101110b = 10001010b
-11011010b & 10101111b = 10001010b
-11011010b & 10110000b = 10010000b
-11011010b & 10110001b = 10010000b
-11011010b & 10110010b = 10010010b
-11011010b & 10110011b = 10010010b
-11011010b & 10110100b = 10010000b
-11011010b & 10110101b = 10010000b
-11011010b & 10110110b = 10010010b
-11011010b & 10110111b = 10010010b
-11011010b & 10111000b = 10011000b
-11011010b & 10111001b = 10011000b
-11011010b & 10111010b = 10011010b
-11011010b & 10111011b = 10011010b
-11011010b & 10111100b = 10011000b
-11011010b & 10111101b = 10011000b
-11011010b & 10111110b = 10011010b
-11011010b & 10111111b = 10011010b
-11011010b & 11000000b = 11000000b
-11011010b & 11000001b = 11000000b
-11011010b & 11000010b = 11000010b
-11011010b & 11000011b = 11000010b
-11011010b & 11000100b = 11000000b
-11011010b & 11000101b = 11000000b
-11011010b & 11000110b = 11000010b
-11011010b & 11000111b = 11000010b
-11011010b & 11001000b = 11001000b
-11011010b & 11001001b = 11001000b
-11011010b & 11001010b = 11001010b
-11011010b & 11001011b = 11001010b
-11011010b & 11001100b = 11001000b
-11011010b & 11001101b = 11001000b
-11011010b & 11001110b = 11001010b
-11011010b & 11001111b = 11001010b
-11011010b & 11010000b = 11010000b
-11011010b & 11010001b = 11010000b
-11011010b & 11010010b = 11010010b
-11011010b & 11010011b = 11010010b
-11011010b & 11010100b = 11010000b
-11011010b & 11010101b = 11010000b
-11011010b & 11010110b = 11010010b
-11011010b & 11010111b = 11010010b
-11011010b & 11011000b = 11011000b
-11011010b & 11011001b = 11011000b
-11011010b & 11011010b = 11011010b
-11011010b & 11011011b = 11011010b
-11011010b & 11011100b = 11011000b
-11011010b & 11011101b = 11011000b
-11011010b & 11011110b = 11011010b
-11011010b & 11011111b = 11011010b
-11011010b & 11100000b = 11000000b
-11011010b & 11100001b = 11000000b
-11011010b & 11100010b = 11000010b
-11011010b & 11100011b = 11000010b
-11011010b & 11100100b = 11000000b
-11011010b & 11100101b = 11000000b
-11011010b & 11100110b = 11000010b
-11011010b & 11100111b = 11000010b
-11011010b & 11101000b = 11001000b
-11011010b & 11101001b = 11001000b
-11011010b & 11101010b = 11001010b
-11011010b & 11101011b = 11001010b
-11011010b & 11101100b = 11001000b
-11011010b & 11101101b = 11001000b
-11011010b & 11101110b = 11001010b
-11011010b & 11101111b = 11001010b
-11011010b & 11110000b = 11010000b
-11011010b & 11110001b = 11010000b
-11011010b & 11110010b = 11010010b
-11011010b & 11110011b = 11010010b
-11011010b & 11110100b = 11010000b
-11011010b & 11110101b = 11010000b
-11011010b & 11110110b = 11010010b
-11011010b & 11110111b = 11010010b
-11011010b & 11111000b = 11011000b
-11011010b & 11111001b = 11011000b
-11011010b & 11111010b = 11011010b
-11011010b & 11111011b = 11011010b
-11011010b & 11111100b = 11011000b
-11011010b & 11111101b = 11011000b
-11011010b & 11111110b = 11011010b
-11011010b & 11111111b = 11011010b
-11011010b & 00000000b = 00000000b
-11011010b & 00000001b = 00000000b
-11011010b & 00000010b = 00000010b
-11011010b & 00000011b = 00000010b
-11011010b & 00000100b = 00000000b
-11011010b & 00000101b = 00000000b
-11011010b & 00000110b = 00000010b
-11011010b & 00000111b = 00000010b
-11011010b & 00001000b = 00001000b
-11011010b & 00001001b = 00001000b
-11011010b & 00001010b = 00001010b
-11011010b & 00001011b = 00001010b
-11011010b & 00001100b = 00001000b
-11011010b & 00001101b = 00001000b
-11011010b & 00001110b = 00001010b
-11011010b & 00001111b = 00001010b
-11011010b & 00010000b = 00010000b
-11011010b & 00010001b = 00010000b
-11011010b & 00010010b = 00010010b
-11011010b & 00010011b = 00010010b
-11011010b & 00010100b = 00010000b
-11011010b & 00010101b = 00010000b
-11011010b & 00010110b = 00010010b
-11011010b & 00010111b = 00010010b
-11011010b & 00011000b = 00011000b
-11011010b & 00011001b = 00011000b
-11011010b & 00011010b = 00011010b
-11011010b & 00011011b = 00011010b
-11011010b & 00011100b = 00011000b
-11011010b & 00011101b = 00011000b
-11011010b & 00011110b = 00011010b
-11011010b & 00011111b = 00011010b
-11011010b & 00100000b = 00000000b
-11011010b & 00100001b = 00000000b
-11011010b & 00100010b = 00000010b
-11011010b & 00100011b = 00000010b
-11011010b & 00100100b = 00000000b
-11011010b & 00100101b = 00000000b
-11011010b & 00100110b = 00000010b
-11011010b & 00100111b = 00000010b
-11011010b & 00101000b = 00001000b
-11011010b & 00101001b = 00001000b
-11011010b & 00101010b = 00001010b
-11011010b & 00101011b = 00001010b
-11011010b & 00101100b = 00001000b
-11011010b & 00101101b = 00001000b
-11011010b & 00101110b = 00001010b
-11011010b & 00101111b = 00001010b
-11011010b & 00110000b = 00010000b
-11011010b & 00110001b = 00010000b
-11011010b & 00110010b = 00010010b
-11011010b & 00110011b = 00010010b
-11011010b & 00110100b = 00010000b
-11011010b & 00110101b = 00010000b
-11011010b & 00110110b = 00010010b
-11011010b & 00110111b = 00010010b
-11011010b & 00111000b = 00011000b
-11011010b & 00111001b = 00011000b
-11011010b & 00111010b = 00011010b
-11011010b & 00111011b = 00011010b
-11011010b & 00111100b = 00011000b
-11011010b & 00111101b = 00011000b
-11011010b & 00111110b = 00011010b
-11011010b & 00111111b = 00011010b
-11011010b & 01000000b = 01000000b
-11011010b & 01000001b = 01000000b
-11011010b & 01000010b = 01000010b
-11011010b & 01000011b = 01000010b
-11011010b & 01000100b = 01000000b
-11011010b & 01000101b = 01000000b
-11011010b & 01000110b = 01000010b
-11011010b & 01000111b = 01000010b
-11011010b & 01001000b = 01001000b
-11011010b & 01001001b = 01001000b
-11011010b & 01001010b = 01001010b
-11011010b & 01001011b = 01001010b
-11011010b & 01001100b = 01001000b
-11011010b & 01001101b = 01001000b
-11011010b & 01001110b = 01001010b
-11011010b & 01001111b = 01001010b
-11011010b & 01010000b = 01010000b
-11011010b & 01010001b = 01010000b
-11011010b & 01010010b = 01010010b
-11011010b & 01010011b = 01010010b
-11011010b & 01010100b = 01010000b
-11011010b & 01010101b = 01010000b
-11011010b & 01010110b = 01010010b
-11011010b & 01010111b = 01010010b
-11011010b & 01011000b = 01011000b
-11011010b & 01011001b = 01011000b
-11011010b & 01011010b = 01011010b
-11011010b & 01011011b = 01011010b
-11011010b & 01011100b = 01011000b
-11011010b & 01011101b = 01011000b
-11011010b & 01011110b = 01011010b
-11011010b & 01011111b = 01011010b
-11011010b & 01100000b = 01000000b
-11011010b & 01100001b = 01000000b
-11011010b & 01100010b = 01000010b
-11011010b & 01100011b = 01000010b
-11011010b & 01100100b = 01000000b
-11011010b & 01100101b = 01000000b
-11011010b & 01100110b = 01000010b
-11011010b & 01100111b = 01000010b
-11011010b & 01101000b = 01001000b
-11011010b & 01101001b = 01001000b
-11011010b & 01101010b = 01001010b
-11011010b & 01101011b = 01001010b
-11011010b & 01101100b = 01001000b
-11011010b & 01101101b = 01001000b
-11011010b & 01101110b = 01001010b
-11011010b & 01101111b = 01001010b
-11011010b & 01110000b = 01010000b
-11011010b & 01110001b = 01010000b
-11011010b & 01110010b = 01010010b
-11011010b & 01110011b = 01010010b
-11011010b & 01110100b = 01010000b
-11011010b & 01110101b = 01010000b
-11011010b & 01110110b = 01010010b
-11011010b & 01110111b = 01010010b
-11011010b & 01111000b = 01011000b
-11011010b & 01111001b = 01011000b
-11011010b & 01111010b = 01011010b
-11011010b & 01111011b = 01011010b
-11011010b & 01111100b = 01011000b
-11011010b & 01111101b = 01011000b
-11011010b & 01111110b = 01011010b
-11011011b & 10000000b = 10000000b
-11011011b & 10000001b = 10000001b
-11011011b & 10000010b = 10000010b
-11011011b & 10000011b = 10000011b
-11011011b & 10000100b = 10000000b
-11011011b & 10000101b = 10000001b
-11011011b & 10000110b = 10000010b
-11011011b & 10000111b = 10000011b
-11011011b & 10001000b = 10001000b
-11011011b & 10001001b = 10001001b
-11011011b & 10001010b = 10001010b
-11011011b & 10001011b = 10001011b
-11011011b & 10001100b = 10001000b
-11011011b & 10001101b = 10001001b
-11011011b & 10001110b = 10001010b
-11011011b & 10001111b = 10001011b
-11011011b & 10010000b = 10010000b
-11011011b & 10010001b = 10010001b
-11011011b & 10010010b = 10010010b
-11011011b & 10010011b = 10010011b
-11011011b & 10010100b = 10010000b
-11011011b & 10010101b = 10010001b
-11011011b & 10010110b = 10010010b
-11011011b & 10010111b = 10010011b
-11011011b & 10011000b = 10011000b
-11011011b & 10011001b = 10011001b
-11011011b & 10011010b = 10011010b
-11011011b & 10011011b = 10011011b
-11011011b & 10011100b = 10011000b
-11011011b & 10011101b = 10011001b
-11011011b & 10011110b = 10011010b
-11011011b & 10011111b = 10011011b
-11011011b & 10100000b = 10000000b
-11011011b & 10100001b = 10000001b
-11011011b & 10100010b = 10000010b
-11011011b & 10100011b = 10000011b
-11011011b & 10100100b = 10000000b
-11011011b & 10100101b = 10000001b
-11011011b & 10100110b = 10000010b
-11011011b & 10100111b = 10000011b
-11011011b & 10101000b = 10001000b
-11011011b & 10101001b = 10001001b
-11011011b & 10101010b = 10001010b
-11011011b & 10101011b = 10001011b
-11011011b & 10101100b = 10001000b
-11011011b & 10101101b = 10001001b
-11011011b & 10101110b = 10001010b
-11011011b & 10101111b = 10001011b
-11011011b & 10110000b = 10010000b
-11011011b & 10110001b = 10010001b
-11011011b & 10110010b = 10010010b
-11011011b & 10110011b = 10010011b
-11011011b & 10110100b = 10010000b
-11011011b & 10110101b = 10010001b
-11011011b & 10110110b = 10010010b
-11011011b & 10110111b = 10010011b
-11011011b & 10111000b = 10011000b
-11011011b & 10111001b = 10011001b
-11011011b & 10111010b = 10011010b
-11011011b & 10111011b = 10011011b
-11011011b & 10111100b = 10011000b
-11011011b & 10111101b = 10011001b
-11011011b & 10111110b = 10011010b
-11011011b & 10111111b = 10011011b
-11011011b & 11000000b = 11000000b
-11011011b & 11000001b = 11000001b
-11011011b & 11000010b = 11000010b
-11011011b & 11000011b = 11000011b
-11011011b & 11000100b = 11000000b
-11011011b & 11000101b = 11000001b
-11011011b & 11000110b = 11000010b
-11011011b & 11000111b = 11000011b
-11011011b & 11001000b = 11001000b
-11011011b & 11001001b = 11001001b
-11011011b & 11001010b = 11001010b
-11011011b & 11001011b = 11001011b
-11011011b & 11001100b = 11001000b
-11011011b & 11001101b = 11001001b
-11011011b & 11001110b = 11001010b
-11011011b & 11001111b = 11001011b
-11011011b & 11010000b = 11010000b
-11011011b & 11010001b = 11010001b
-11011011b & 11010010b = 11010010b
-11011011b & 11010011b = 11010011b
-11011011b & 11010100b = 11010000b
-11011011b & 11010101b = 11010001b
-11011011b & 11010110b = 11010010b
-11011011b & 11010111b = 11010011b
-11011011b & 11011000b = 11011000b
-11011011b & 11011001b = 11011001b
-11011011b & 11011010b = 11011010b
-11011011b & 11011011b = 11011011b
-11011011b & 11011100b = 11011000b
-11011011b & 11011101b = 11011001b
-11011011b & 11011110b = 11011010b
-11011011b & 11011111b = 11011011b
-11011011b & 11100000b = 11000000b
-11011011b & 11100001b = 11000001b
-11011011b & 11100010b = 11000010b
-11011011b & 11100011b = 11000011b
-11011011b & 11100100b = 11000000b
-11011011b & 11100101b = 11000001b
-11011011b & 11100110b = 11000010b
-11011011b & 11100111b = 11000011b
-11011011b & 11101000b = 11001000b
-11011011b & 11101001b = 11001001b
-11011011b & 11101010b = 11001010b
-11011011b & 11101011b = 11001011b
-11011011b & 11101100b = 11001000b
-11011011b & 11101101b = 11001001b
-11011011b & 11101110b = 11001010b
-11011011b & 11101111b = 11001011b
-11011011b & 11110000b = 11010000b
-11011011b & 11110001b = 11010001b
-11011011b & 11110010b = 11010010b
-11011011b & 11110011b = 11010011b
-11011011b & 11110100b = 11010000b
-11011011b & 11110101b = 11010001b
-11011011b & 11110110b = 11010010b
-11011011b & 11110111b = 11010011b
-11011011b & 11111000b = 11011000b
-11011011b & 11111001b = 11011001b
-11011011b & 11111010b = 11011010b
-11011011b & 11111011b = 11011011b
-11011011b & 11111100b = 11011000b
-11011011b & 11111101b = 11011001b
-11011011b & 11111110b = 11011010b
-11011011b & 11111111b = 11011011b
-11011011b & 00000000b = 00000000b
-11011011b & 00000001b = 00000001b
-11011011b & 00000010b = 00000010b
-11011011b & 00000011b = 00000011b
-11011011b & 00000100b = 00000000b
-11011011b & 00000101b = 00000001b
-11011011b & 00000110b = 00000010b
-11011011b & 00000111b = 00000011b
-11011011b & 00001000b = 00001000b
-11011011b & 00001001b = 00001001b
-11011011b & 00001010b = 00001010b
-11011011b & 00001011b = 00001011b
-11011011b & 00001100b = 00001000b
-11011011b & 00001101b = 00001001b
-11011011b & 00001110b = 00001010b
-11011011b & 00001111b = 00001011b
-11011011b & 00010000b = 00010000b
-11011011b & 00010001b = 00010001b
-11011011b & 00010010b = 00010010b
-11011011b & 00010011b = 00010011b
-11011011b & 00010100b = 00010000b
-11011011b & 00010101b = 00010001b
-11011011b & 00010110b = 00010010b
-11011011b & 00010111b = 00010011b
-11011011b & 00011000b = 00011000b
-11011011b & 00011001b = 00011001b
-11011011b & 00011010b = 00011010b
-11011011b & 00011011b = 00011011b
-11011011b & 00011100b = 00011000b
-11011011b & 00011101b = 00011001b
-11011011b & 00011110b = 00011010b
-11011011b & 00011111b = 00011011b
-11011011b & 00100000b = 00000000b
-11011011b & 00100001b = 00000001b
-11011011b & 00100010b = 00000010b
-11011011b & 00100011b = 00000011b
-11011011b & 00100100b = 00000000b
-11011011b & 00100101b = 00000001b
-11011011b & 00100110b = 00000010b
-11011011b & 00100111b = 00000011b
-11011011b & 00101000b = 00001000b
-11011011b & 00101001b = 00001001b
-11011011b & 00101010b = 00001010b
-11011011b & 00101011b = 00001011b
-11011011b & 00101100b = 00001000b
-11011011b & 00101101b = 00001001b
-11011011b & 00101110b = 00001010b
-11011011b & 00101111b = 00001011b
-11011011b & 00110000b = 00010000b
-11011011b & 00110001b = 00010001b
-11011011b & 00110010b = 00010010b
-11011011b & 00110011b = 00010011b
-11011011b & 00110100b = 00010000b
-11011011b & 00110101b = 00010001b
-11011011b & 00110110b = 00010010b
-11011011b & 00110111b = 00010011b
-11011011b & 00111000b = 00011000b
-11011011b & 00111001b = 00011001b
-11011011b & 00111010b = 00011010b
-11011011b & 00111011b = 00011011b
-11011011b & 00111100b = 00011000b
-11011011b & 00111101b = 00011001b
-11011011b & 00111110b = 00011010b
-11011011b & 00111111b = 00011011b
-11011011b & 01000000b = 01000000b
-11011011b & 01000001b = 01000001b
-11011011b & 01000010b = 01000010b
-11011011b & 01000011b = 01000011b
-11011011b & 01000100b = 01000000b
-11011011b & 01000101b = 01000001b
-11011011b & 01000110b = 01000010b
-11011011b & 01000111b = 01000011b
-11011011b & 01001000b = 01001000b
-11011011b & 01001001b = 01001001b
-11011011b & 01001010b = 01001010b
-11011011b & 01001011b = 01001011b
-11011011b & 01001100b = 01001000b
-11011011b & 01001101b = 01001001b
-11011011b & 01001110b = 01001010b
-11011011b & 01001111b = 01001011b
-11011011b & 01010000b = 01010000b
-11011011b & 01010001b = 01010001b
-11011011b & 01010010b = 01010010b
-11011011b & 01010011b = 01010011b
-11011011b & 01010100b = 01010000b
-11011011b & 01010101b = 01010001b
-11011011b & 01010110b = 01010010b
-11011011b & 01010111b = 01010011b
-11011011b & 01011000b = 01011000b
-11011011b & 01011001b = 01011001b
-11011011b & 01011010b = 01011010b
-11011011b & 01011011b = 01011011b
-11011011b & 01011100b = 01011000b
-11011011b & 01011101b = 01011001b
-11011011b & 01011110b = 01011010b
-11011011b & 01011111b = 01011011b
-11011011b & 01100000b = 01000000b
-11011011b & 01100001b = 01000001b
-11011011b & 01100010b = 01000010b
-11011011b & 01100011b = 01000011b
-11011011b & 01100100b = 01000000b
-11011011b & 01100101b = 01000001b
-11011011b & 01100110b = 01000010b
-11011011b & 01100111b = 01000011b
-11011011b & 01101000b = 01001000b
-11011011b & 01101001b = 01001001b
-11011011b & 01101010b = 01001010b
-11011011b & 01101011b = 01001011b
-11011011b & 01101100b = 01001000b
-11011011b & 01101101b = 01001001b
-11011011b & 01101110b = 01001010b
-11011011b & 01101111b = 01001011b
-11011011b & 01110000b = 01010000b
-11011011b & 01110001b = 01010001b
-11011011b & 01110010b = 01010010b
-11011011b & 01110011b = 01010011b
-11011011b & 01110100b = 01010000b
-11011011b & 01110101b = 01010001b
-11011011b & 01110110b = 01010010b
-11011011b & 01110111b = 01010011b
-11011011b & 01111000b = 01011000b
-11011011b & 01111001b = 01011001b
-11011011b & 01111010b = 01011010b
-11011011b & 01111011b = 01011011b
-11011011b & 01111100b = 01011000b
-11011011b & 01111101b = 01011001b
-11011011b & 01111110b = 01011010b
-11011100b & 10000000b = 10000000b
-11011100b & 10000001b = 10000000b
-11011100b & 10000010b = 10000000b
-11011100b & 10000011b = 10000000b
-11011100b & 10000100b = 10000100b
-11011100b & 10000101b = 10000100b
-11011100b & 10000110b = 10000100b
-11011100b & 10000111b = 10000100b
-11011100b & 10001000b = 10001000b
-11011100b & 10001001b = 10001000b
-11011100b & 10001010b = 10001000b
-11011100b & 10001011b = 10001000b
-11011100b & 10001100b = 10001100b
-11011100b & 10001101b = 10001100b
-11011100b & 10001110b = 10001100b
-11011100b & 10001111b = 10001100b
-11011100b & 10010000b = 10010000b
-11011100b & 10010001b = 10010000b
-11011100b & 10010010b = 10010000b
-11011100b & 10010011b = 10010000b
-11011100b & 10010100b = 10010100b
-11011100b & 10010101b = 10010100b
-11011100b & 10010110b = 10010100b
-11011100b & 10010111b = 10010100b
-11011100b & 10011000b = 10011000b
-11011100b & 10011001b = 10011000b
-11011100b & 10011010b = 10011000b
-11011100b & 10011011b = 10011000b
-11011100b & 10011100b = 10011100b
-11011100b & 10011101b = 10011100b
-11011100b & 10011110b = 10011100b
-11011100b & 10011111b = 10011100b
-11011100b & 10100000b = 10000000b
-11011100b & 10100001b = 10000000b
-11011100b & 10100010b = 10000000b
-11011100b & 10100011b = 10000000b
-11011100b & 10100100b = 10000100b
-11011100b & 10100101b = 10000100b
-11011100b & 10100110b = 10000100b
-11011100b & 10100111b = 10000100b
-11011100b & 10101000b = 10001000b
-11011100b & 10101001b = 10001000b
-11011100b & 10101010b = 10001000b
-11011100b & 10101011b = 10001000b
-11011100b & 10101100b = 10001100b
-11011100b & 10101101b = 10001100b
-11011100b & 10101110b = 10001100b
-11011100b & 10101111b = 10001100b
-11011100b & 10110000b = 10010000b
-11011100b & 10110001b = 10010000b
-11011100b & 10110010b = 10010000b
-11011100b & 10110011b = 10010000b
-11011100b & 10110100b = 10010100b
-11011100b & 10110101b = 10010100b
-11011100b & 10110110b = 10010100b
-11011100b & 10110111b = 10010100b
-11011100b & 10111000b = 10011000b
-11011100b & 10111001b = 10011000b
-11011100b & 10111010b = 10011000b
-11011100b & 10111011b = 10011000b
-11011100b & 10111100b = 10011100b
-11011100b & 10111101b = 10011100b
-11011100b & 10111110b = 10011100b
-11011100b & 10111111b = 10011100b
-11011100b & 11000000b = 11000000b
-11011100b & 11000001b = 11000000b
-11011100b & 11000010b = 11000000b
-11011100b & 11000011b = 11000000b
-11011100b & 11000100b = 11000100b
-11011100b & 11000101b = 11000100b
-11011100b & 11000110b = 11000100b
-11011100b & 11000111b = 11000100b
-11011100b & 11001000b = 11001000b
-11011100b & 11001001b = 11001000b
-11011100b & 11001010b = 11001000b
-11011100b & 11001011b = 11001000b
-11011100b & 11001100b = 11001100b
-11011100b & 11001101b = 11001100b
-11011100b & 11001110b = 11001100b
-11011100b & 11001111b = 11001100b
-11011100b & 11010000b = 11010000b
-11011100b & 11010001b = 11010000b
-11011100b & 11010010b = 11010000b
-11011100b & 11010011b = 11010000b
-11011100b & 11010100b = 11010100b
-11011100b & 11010101b = 11010100b
-11011100b & 11010110b = 11010100b
-11011100b & 11010111b = 11010100b
-11011100b & 11011000b = 11011000b
-11011100b & 11011001b = 11011000b
-11011100b & 11011010b = 11011000b
-11011100b & 11011011b = 11011000b
-11011100b & 11011100b = 11011100b
-11011100b & 11011101b = 11011100b
-11011100b & 11011110b = 11011100b
-11011100b & 11011111b = 11011100b
-11011100b & 11100000b = 11000000b
-11011100b & 11100001b = 11000000b
-11011100b & 11100010b = 11000000b
-11011100b & 11100011b = 11000000b
-11011100b & 11100100b = 11000100b
-11011100b & 11100101b = 11000100b
-11011100b & 11100110b = 11000100b
-11011100b & 11100111b = 11000100b
-11011100b & 11101000b = 11001000b
-11011100b & 11101001b = 11001000b
-11011100b & 11101010b = 11001000b
-11011100b & 11101011b = 11001000b
-11011100b & 11101100b = 11001100b
-11011100b & 11101101b = 11001100b
-11011100b & 11101110b = 11001100b
-11011100b & 11101111b = 11001100b
-11011100b & 11110000b = 11010000b
-11011100b & 11110001b = 11010000b
-11011100b & 11110010b = 11010000b
-11011100b & 11110011b = 11010000b
-11011100b & 11110100b = 11010100b
-11011100b & 11110101b = 11010100b
-11011100b & 11110110b = 11010100b
-11011100b & 11110111b = 11010100b
-11011100b & 11111000b = 11011000b
-11011100b & 11111001b = 11011000b
-11011100b & 11111010b = 11011000b
-11011100b & 11111011b = 11011000b
-11011100b & 11111100b = 11011100b
-11011100b & 11111101b = 11011100b
-11011100b & 11111110b = 11011100b
-11011100b & 11111111b = 11011100b
-11011100b & 00000000b = 00000000b
-11011100b & 00000001b = 00000000b
-11011100b & 00000010b = 00000000b
-11011100b & 00000011b = 00000000b
-11011100b & 00000100b = 00000100b
-11011100b & 00000101b = 00000100b
-11011100b & 00000110b = 00000100b
-11011100b & 00000111b = 00000100b
-11011100b & 00001000b = 00001000b
-11011100b & 00001001b = 00001000b
-11011100b & 00001010b = 00001000b
-11011100b & 00001011b = 00001000b
-11011100b & 00001100b = 00001100b
-11011100b & 00001101b = 00001100b
-11011100b & 00001110b = 00001100b
-11011100b & 00001111b = 00001100b
-11011100b & 00010000b = 00010000b
-11011100b & 00010001b = 00010000b
-11011100b & 00010010b = 00010000b
-11011100b & 00010011b = 00010000b
-11011100b & 00010100b = 00010100b
-11011100b & 00010101b = 00010100b
-11011100b & 00010110b = 00010100b
-11011100b & 00010111b = 00010100b
-11011100b & 00011000b = 00011000b
-11011100b & 00011001b = 00011000b
-11011100b & 00011010b = 00011000b
-11011100b & 00011011b = 00011000b
-11011100b & 00011100b = 00011100b
-11011100b & 00011101b = 00011100b
-11011100b & 00011110b = 00011100b
-11011100b & 00011111b = 00011100b
-11011100b & 00100000b = 00000000b
-11011100b & 00100001b = 00000000b
-11011100b & 00100010b = 00000000b
-11011100b & 00100011b = 00000000b
-11011100b & 00100100b = 00000100b
-11011100b & 00100101b = 00000100b
-11011100b & 00100110b = 00000100b
-11011100b & 00100111b = 00000100b
-11011100b & 00101000b = 00001000b
-11011100b & 00101001b = 00001000b
-11011100b & 00101010b = 00001000b
-11011100b & 00101011b = 00001000b
-11011100b & 00101100b = 00001100b
-11011100b & 00101101b = 00001100b
-11011100b & 00101110b = 00001100b
-11011100b & 00101111b = 00001100b
-11011100b & 00110000b = 00010000b
-11011100b & 00110001b = 00010000b
-11011100b & 00110010b = 00010000b
-11011100b & 00110011b = 00010000b
-11011100b & 00110100b = 00010100b
-11011100b & 00110101b = 00010100b
-11011100b & 00110110b = 00010100b
-11011100b & 00110111b = 00010100b
-11011100b & 00111000b = 00011000b
-11011100b & 00111001b = 00011000b
-11011100b & 00111010b = 00011000b
-11011100b & 00111011b = 00011000b
-11011100b & 00111100b = 00011100b
-11011100b & 00111101b = 00011100b
-11011100b & 00111110b = 00011100b
-11011100b & 00111111b = 00011100b
-11011100b & 01000000b = 01000000b
-11011100b & 01000001b = 01000000b
-11011100b & 01000010b = 01000000b
-11011100b & 01000011b = 01000000b
-11011100b & 01000100b = 01000100b
-11011100b & 01000101b = 01000100b
-11011100b & 01000110b = 01000100b
-11011100b & 01000111b = 01000100b
-11011100b & 01001000b = 01001000b
-11011100b & 01001001b = 01001000b
-11011100b & 01001010b = 01001000b
-11011100b & 01001011b = 01001000b
-11011100b & 01001100b = 01001100b
-11011100b & 01001101b = 01001100b
-11011100b & 01001110b = 01001100b
-11011100b & 01001111b = 01001100b
-11011100b & 01010000b = 01010000b
-11011100b & 01010001b = 01010000b
-11011100b & 01010010b = 01010000b
-11011100b & 01010011b = 01010000b
-11011100b & 01010100b = 01010100b
-11011100b & 01010101b = 01010100b
-11011100b & 01010110b = 01010100b
-11011100b & 01010111b = 01010100b
-11011100b & 01011000b = 01011000b
-11011100b & 01011001b = 01011000b
-11011100b & 01011010b = 01011000b
-11011100b & 01011011b = 01011000b
-11011100b & 01011100b = 01011100b
-11011100b & 01011101b = 01011100b
-11011100b & 01011110b = 01011100b
-11011100b & 01011111b = 01011100b
-11011100b & 01100000b = 01000000b
-11011100b & 01100001b = 01000000b
-11011100b & 01100010b = 01000000b
-11011100b & 01100011b = 01000000b
-11011100b & 01100100b = 01000100b
-11011100b & 01100101b = 01000100b
-11011100b & 01100110b = 01000100b
-11011100b & 01100111b = 01000100b
-11011100b & 01101000b = 01001000b
-11011100b & 01101001b = 01001000b
-11011100b & 01101010b = 01001000b
-11011100b & 01101011b = 01001000b
-11011100b & 01101100b = 01001100b
-11011100b & 01101101b = 01001100b
-11011100b & 01101110b = 01001100b
-11011100b & 01101111b = 01001100b
-11011100b & 01110000b = 01010000b
-11011100b & 01110001b = 01010000b
-11011100b & 01110010b = 01010000b
-11011100b & 01110011b = 01010000b
-11011100b & 01110100b = 01010100b
-11011100b & 01110101b = 01010100b
-11011100b & 01110110b = 01010100b
-11011100b & 01110111b = 01010100b
-11011100b & 01111000b = 01011000b
-11011100b & 01111001b = 01011000b
-11011100b & 01111010b = 01011000b
-11011100b & 01111011b = 01011000b
-11011100b & 01111100b = 01011100b
-11011100b & 01111101b = 01011100b
-11011100b & 01111110b = 01011100b
-11011101b & 10000000b = 10000000b
-11011101b & 10000001b = 10000001b
-11011101b & 10000010b = 10000000b
-11011101b & 10000011b = 10000001b
-11011101b & 10000100b = 10000100b
-11011101b & 10000101b = 10000101b
-11011101b & 10000110b = 10000100b
-11011101b & 10000111b = 10000101b
-11011101b & 10001000b = 10001000b
-11011101b & 10001001b = 10001001b
-11011101b & 10001010b = 10001000b
-11011101b & 10001011b = 10001001b
-11011101b & 10001100b = 10001100b
-11011101b & 10001101b = 10001101b
-11011101b & 10001110b = 10001100b
-11011101b & 10001111b = 10001101b
-11011101b & 10010000b = 10010000b
-11011101b & 10010001b = 10010001b
-11011101b & 10010010b = 10010000b
-11011101b & 10010011b = 10010001b
-11011101b & 10010100b = 10010100b
-11011101b & 10010101b = 10010101b
-11011101b & 10010110b = 10010100b
-11011101b & 10010111b = 10010101b
-11011101b & 10011000b = 10011000b
-11011101b & 10011001b = 10011001b
-11011101b & 10011010b = 10011000b
-11011101b & 10011011b = 10011001b
-11011101b & 10011100b = 10011100b
-11011101b & 10011101b = 10011101b
-11011101b & 10011110b = 10011100b
-11011101b & 10011111b = 10011101b
-11011101b & 10100000b = 10000000b
-11011101b & 10100001b = 10000001b
-11011101b & 10100010b = 10000000b
-11011101b & 10100011b = 10000001b
-11011101b & 10100100b = 10000100b
-11011101b & 10100101b = 10000101b
-11011101b & 10100110b = 10000100b
-11011101b & 10100111b = 10000101b
-11011101b & 10101000b = 10001000b
-11011101b & 10101001b = 10001001b
-11011101b & 10101010b = 10001000b
-11011101b & 10101011b = 10001001b
-11011101b & 10101100b = 10001100b
-11011101b & 10101101b = 10001101b
-11011101b & 10101110b = 10001100b
-11011101b & 10101111b = 10001101b
-11011101b & 10110000b = 10010000b
-11011101b & 10110001b = 10010001b
-11011101b & 10110010b = 10010000b
-11011101b & 10110011b = 10010001b
-11011101b & 10110100b = 10010100b
-11011101b & 10110101b = 10010101b
-11011101b & 10110110b = 10010100b
-11011101b & 10110111b = 10010101b
-11011101b & 10111000b = 10011000b
-11011101b & 10111001b = 10011001b
-11011101b & 10111010b = 10011000b
-11011101b & 10111011b = 10011001b
-11011101b & 10111100b = 10011100b
-11011101b & 10111101b = 10011101b
-11011101b & 10111110b = 10011100b
-11011101b & 10111111b = 10011101b
-11011101b & 11000000b = 11000000b
-11011101b & 11000001b = 11000001b
-11011101b & 11000010b = 11000000b
-11011101b & 11000011b = 11000001b
-11011101b & 11000100b = 11000100b
-11011101b & 11000101b = 11000101b
-11011101b & 11000110b = 11000100b
-11011101b & 11000111b = 11000101b
-11011101b & 11001000b = 11001000b
-11011101b & 11001001b = 11001001b
-11011101b & 11001010b = 11001000b
-11011101b & 11001011b = 11001001b
-11011101b & 11001100b = 11001100b
-11011101b & 11001101b = 11001101b
-11011101b & 11001110b = 11001100b
-11011101b & 11001111b = 11001101b
-11011101b & 11010000b = 11010000b
-11011101b & 11010001b = 11010001b
-11011101b & 11010010b = 11010000b
-11011101b & 11010011b = 11010001b
-11011101b & 11010100b = 11010100b
-11011101b & 11010101b = 11010101b
-11011101b & 11010110b = 11010100b
-11011101b & 11010111b = 11010101b
-11011101b & 11011000b = 11011000b
-11011101b & 11011001b = 11011001b
-11011101b & 11011010b = 11011000b
-11011101b & 11011011b = 11011001b
-11011101b & 11011100b = 11011100b
-11011101b & 11011101b = 11011101b
-11011101b & 11011110b = 11011100b
-11011101b & 11011111b = 11011101b
-11011101b & 11100000b = 11000000b
-11011101b & 11100001b = 11000001b
-11011101b & 11100010b = 11000000b
-11011101b & 11100011b = 11000001b
-11011101b & 11100100b = 11000100b
-11011101b & 11100101b = 11000101b
-11011101b & 11100110b = 11000100b
-11011101b & 11100111b = 11000101b
-11011101b & 11101000b = 11001000b
-11011101b & 11101001b = 11001001b
-11011101b & 11101010b = 11001000b
-11011101b & 11101011b = 11001001b
-11011101b & 11101100b = 11001100b
-11011101b & 11101101b = 11001101b
-11011101b & 11101110b = 11001100b
-11011101b & 11101111b = 11001101b
-11011101b & 11110000b = 11010000b
-11011101b & 11110001b = 11010001b
-11011101b & 11110010b = 11010000b
-11011101b & 11110011b = 11010001b
-11011101b & 11110100b = 11010100b
-11011101b & 11110101b = 11010101b
-11011101b & 11110110b = 11010100b
-11011101b & 11110111b = 11010101b
-11011101b & 11111000b = 11011000b
-11011101b & 11111001b = 11011001b
-11011101b & 11111010b = 11011000b
-11011101b & 11111011b = 11011001b
-11011101b & 11111100b = 11011100b
-11011101b & 11111101b = 11011101b
-11011101b & 11111110b = 11011100b
-11011101b & 11111111b = 11011101b
-11011101b & 00000000b = 00000000b
-11011101b & 00000001b = 00000001b
-11011101b & 00000010b = 00000000b
-11011101b & 00000011b = 00000001b
-11011101b & 00000100b = 00000100b
-11011101b & 00000101b = 00000101b
-11011101b & 00000110b = 00000100b
-11011101b & 00000111b = 00000101b
-11011101b & 00001000b = 00001000b
-11011101b & 00001001b = 00001001b
-11011101b & 00001010b = 00001000b
-11011101b & 00001011b = 00001001b
-11011101b & 00001100b = 00001100b
-11011101b & 00001101b = 00001101b
-11011101b & 00001110b = 00001100b
-11011101b & 00001111b = 00001101b
-11011101b & 00010000b = 00010000b
-11011101b & 00010001b = 00010001b
-11011101b & 00010010b = 00010000b
-11011101b & 00010011b = 00010001b
-11011101b & 00010100b = 00010100b
-11011101b & 00010101b = 00010101b
-11011101b & 00010110b = 00010100b
-11011101b & 00010111b = 00010101b
-11011101b & 00011000b = 00011000b
-11011101b & 00011001b = 00011001b
-11011101b & 00011010b = 00011000b
-11011101b & 00011011b = 00011001b
-11011101b & 00011100b = 00011100b
-11011101b & 00011101b = 00011101b
-11011101b & 00011110b = 00011100b
-11011101b & 00011111b = 00011101b
-11011101b & 00100000b = 00000000b
-11011101b & 00100001b = 00000001b
-11011101b & 00100010b = 00000000b
-11011101b & 00100011b = 00000001b
-11011101b & 00100100b = 00000100b
-11011101b & 00100101b = 00000101b
-11011101b & 00100110b = 00000100b
-11011101b & 00100111b = 00000101b
-11011101b & 00101000b = 00001000b
-11011101b & 00101001b = 00001001b
-11011101b & 00101010b = 00001000b
-11011101b & 00101011b = 00001001b
-11011101b & 00101100b = 00001100b
-11011101b & 00101101b = 00001101b
-11011101b & 00101110b = 00001100b
-11011101b & 00101111b = 00001101b
-11011101b & 00110000b = 00010000b
-11011101b & 00110001b = 00010001b
-11011101b & 00110010b = 00010000b
-11011101b & 00110011b = 00010001b
-11011101b & 00110100b = 00010100b
-11011101b & 00110101b = 00010101b
-11011101b & 00110110b = 00010100b
-11011101b & 00110111b = 00010101b
-11011101b & 00111000b = 00011000b
-11011101b & 00111001b = 00011001b
-11011101b & 00111010b = 00011000b
-11011101b & 00111011b = 00011001b
-11011101b & 00111100b = 00011100b
-11011101b & 00111101b = 00011101b
-11011101b & 00111110b = 00011100b
-11011101b & 00111111b = 00011101b
-11011101b & 01000000b = 01000000b
-11011101b & 01000001b = 01000001b
-11011101b & 01000010b = 01000000b
-11011101b & 01000011b = 01000001b
-11011101b & 01000100b = 01000100b
-11011101b & 01000101b = 01000101b
-11011101b & 01000110b = 01000100b
-11011101b & 01000111b = 01000101b
-11011101b & 01001000b = 01001000b
-11011101b & 01001001b = 01001001b
-11011101b & 01001010b = 01001000b
-11011101b & 01001011b = 01001001b
-11011101b & 01001100b = 01001100b
-11011101b & 01001101b = 01001101b
-11011101b & 01001110b = 01001100b
-11011101b & 01001111b = 01001101b
-11011101b & 01010000b = 01010000b
-11011101b & 01010001b = 01010001b
-11011101b & 01010010b = 01010000b
-11011101b & 01010011b = 01010001b
-11011101b & 01010100b = 01010100b
-11011101b & 01010101b = 01010101b
-11011101b & 01010110b = 01010100b
-11011101b & 01010111b = 01010101b
-11011101b & 01011000b = 01011000b
-11011101b & 01011001b = 01011001b
-11011101b & 01011010b = 01011000b
-11011101b & 01011011b = 01011001b
-11011101b & 01011100b = 01011100b
-11011101b & 01011101b = 01011101b
-11011101b & 01011110b = 01011100b
-11011101b & 01011111b = 01011101b
-11011101b & 01100000b = 01000000b
-11011101b & 01100001b = 01000001b
-11011101b & 01100010b = 01000000b
-11011101b & 01100011b = 01000001b
-11011101b & 01100100b = 01000100b
-11011101b & 01100101b = 01000101b
-11011101b & 01100110b = 01000100b
-11011101b & 01100111b = 01000101b
-11011101b & 01101000b = 01001000b
-11011101b & 01101001b = 01001001b
-11011101b & 01101010b = 01001000b
-11011101b & 01101011b = 01001001b
-11011101b & 01101100b = 01001100b
-11011101b & 01101101b = 01001101b
-11011101b & 01101110b = 01001100b
-11011101b & 01101111b = 01001101b
-11011101b & 01110000b = 01010000b
-11011101b & 01110001b = 01010001b
-11011101b & 01110010b = 01010000b
-11011101b & 01110011b = 01010001b
-11011101b & 01110100b = 01010100b
-11011101b & 01110101b = 01010101b
-11011101b & 01110110b = 01010100b
-11011101b & 01110111b = 01010101b
-11011101b & 01111000b = 01011000b
-11011101b & 01111001b = 01011001b
-11011101b & 01111010b = 01011000b
-11011101b & 01111011b = 01011001b
-11011101b & 01111100b = 01011100b
-11011101b & 01111101b = 01011101b
-11011101b & 01111110b = 01011100b
-11011110b & 10000000b = 10000000b
-11011110b & 10000001b = 10000000b
-11011110b & 10000010b = 10000010b
-11011110b & 10000011b = 10000010b
-11011110b & 10000100b = 10000100b
-11011110b & 10000101b = 10000100b
-11011110b & 10000110b = 10000110b
-11011110b & 10000111b = 10000110b
-11011110b & 10001000b = 10001000b
-11011110b & 10001001b = 10001000b
-11011110b & 10001010b = 10001010b
-11011110b & 10001011b = 10001010b
-11011110b & 10001100b = 10001100b
-11011110b & 10001101b = 10001100b
-11011110b & 10001110b = 10001110b
-11011110b & 10001111b = 10001110b
-11011110b & 10010000b = 10010000b
-11011110b & 10010001b = 10010000b
-11011110b & 10010010b = 10010010b
-11011110b & 10010011b = 10010010b
-11011110b & 10010100b = 10010100b
-11011110b & 10010101b = 10010100b
-11011110b & 10010110b = 10010110b
-11011110b & 10010111b = 10010110b
-11011110b & 10011000b = 10011000b
-11011110b & 10011001b = 10011000b
-11011110b & 10011010b = 10011010b
-11011110b & 10011011b = 10011010b
-11011110b & 10011100b = 10011100b
-11011110b & 10011101b = 10011100b
-11011110b & 10011110b = 10011110b
-11011110b & 10011111b = 10011110b
-11011110b & 10100000b = 10000000b
-11011110b & 10100001b = 10000000b
-11011110b & 10100010b = 10000010b
-11011110b & 10100011b = 10000010b
-11011110b & 10100100b = 10000100b
-11011110b & 10100101b = 10000100b
-11011110b & 10100110b = 10000110b
-11011110b & 10100111b = 10000110b
-11011110b & 10101000b = 10001000b
-11011110b & 10101001b = 10001000b
-11011110b & 10101010b = 10001010b
-11011110b & 10101011b = 10001010b
-11011110b & 10101100b = 10001100b
-11011110b & 10101101b = 10001100b
-11011110b & 10101110b = 10001110b
-11011110b & 10101111b = 10001110b
-11011110b & 10110000b = 10010000b
-11011110b & 10110001b = 10010000b
-11011110b & 10110010b = 10010010b
-11011110b & 10110011b = 10010010b
-11011110b & 10110100b = 10010100b
-11011110b & 10110101b = 10010100b
-11011110b & 10110110b = 10010110b
-11011110b & 10110111b = 10010110b
-11011110b & 10111000b = 10011000b
-11011110b & 10111001b = 10011000b
-11011110b & 10111010b = 10011010b
-11011110b & 10111011b = 10011010b
-11011110b & 10111100b = 10011100b
-11011110b & 10111101b = 10011100b
-11011110b & 10111110b = 10011110b
-11011110b & 10111111b = 10011110b
-11011110b & 11000000b = 11000000b
-11011110b & 11000001b = 11000000b
-11011110b & 11000010b = 11000010b
-11011110b & 11000011b = 11000010b
-11011110b & 11000100b = 11000100b
-11011110b & 11000101b = 11000100b
-11011110b & 11000110b = 11000110b
-11011110b & 11000111b = 11000110b
-11011110b & 11001000b = 11001000b
-11011110b & 11001001b = 11001000b
-11011110b & 11001010b = 11001010b
-11011110b & 11001011b = 11001010b
-11011110b & 11001100b = 11001100b
-11011110b & 11001101b = 11001100b
-11011110b & 11001110b = 11001110b
-11011110b & 11001111b = 11001110b
-11011110b & 11010000b = 11010000b
-11011110b & 11010001b = 11010000b
-11011110b & 11010010b = 11010010b
-11011110b & 11010011b = 11010010b
-11011110b & 11010100b = 11010100b
-11011110b & 11010101b = 11010100b
-11011110b & 11010110b = 11010110b
-11011110b & 11010111b = 11010110b
-11011110b & 11011000b = 11011000b
-11011110b & 11011001b = 11011000b
-11011110b & 11011010b = 11011010b
-11011110b & 11011011b = 11011010b
-11011110b & 11011100b = 11011100b
-11011110b & 11011101b = 11011100b
-11011110b & 11011110b = 11011110b
-11011110b & 11011111b = 11011110b
-11011110b & 11100000b = 11000000b
-11011110b & 11100001b = 11000000b
-11011110b & 11100010b = 11000010b
-11011110b & 11100011b = 11000010b
-11011110b & 11100100b = 11000100b
-11011110b & 11100101b = 11000100b
-11011110b & 11100110b = 11000110b
-11011110b & 11100111b = 11000110b
-11011110b & 11101000b = 11001000b
-11011110b & 11101001b = 11001000b
-11011110b & 11101010b = 11001010b
-11011110b & 11101011b = 11001010b
-11011110b & 11101100b = 11001100b
-11011110b & 11101101b = 11001100b
-11011110b & 11101110b = 11001110b
-11011110b & 11101111b = 11001110b
-11011110b & 11110000b = 11010000b
-11011110b & 11110001b = 11010000b
-11011110b & 11110010b = 11010010b
-11011110b & 11110011b = 11010010b
-11011110b & 11110100b = 11010100b
-11011110b & 11110101b = 11010100b
-11011110b & 11110110b = 11010110b
-11011110b & 11110111b = 11010110b
-11011110b & 11111000b = 11011000b
-11011110b & 11111001b = 11011000b
-11011110b & 11111010b = 11011010b
-11011110b & 11111011b = 11011010b
-11011110b & 11111100b = 11011100b
-11011110b & 11111101b = 11011100b
-11011110b & 11111110b = 11011110b
-11011110b & 11111111b = 11011110b
-11011110b & 00000000b = 00000000b
-11011110b & 00000001b = 00000000b
-11011110b & 00000010b = 00000010b
-11011110b & 00000011b = 00000010b
-11011110b & 00000100b = 00000100b
-11011110b & 00000101b = 00000100b
-11011110b & 00000110b = 00000110b
-11011110b & 00000111b = 00000110b
-11011110b & 00001000b = 00001000b
-11011110b & 00001001b = 00001000b
-11011110b & 00001010b = 00001010b
-11011110b & 00001011b = 00001010b
-11011110b & 00001100b = 00001100b
-11011110b & 00001101b = 00001100b
-11011110b & 00001110b = 00001110b
-11011110b & 00001111b = 00001110b
-11011110b & 00010000b = 00010000b
-11011110b & 00010001b = 00010000b
-11011110b & 00010010b = 00010010b
-11011110b & 00010011b = 00010010b
-11011110b & 00010100b = 00010100b
-11011110b & 00010101b = 00010100b
-11011110b & 00010110b = 00010110b
-11011110b & 00010111b = 00010110b
-11011110b & 00011000b = 00011000b
-11011110b & 00011001b = 00011000b
-11011110b & 00011010b = 00011010b
-11011110b & 00011011b = 00011010b
-11011110b & 00011100b = 00011100b
-11011110b & 00011101b = 00011100b
-11011110b & 00011110b = 00011110b
-11011110b & 00011111b = 00011110b
-11011110b & 00100000b = 00000000b
-11011110b & 00100001b = 00000000b
-11011110b & 00100010b = 00000010b
-11011110b & 00100011b = 00000010b
-11011110b & 00100100b = 00000100b
-11011110b & 00100101b = 00000100b
-11011110b & 00100110b = 00000110b
-11011110b & 00100111b = 00000110b
-11011110b & 00101000b = 00001000b
-11011110b & 00101001b = 00001000b
-11011110b & 00101010b = 00001010b
-11011110b & 00101011b = 00001010b
-11011110b & 00101100b = 00001100b
-11011110b & 00101101b = 00001100b
-11011110b & 00101110b = 00001110b
-11011110b & 00101111b = 00001110b
-11011110b & 00110000b = 00010000b
-11011110b & 00110001b = 00010000b
-11011110b & 00110010b = 00010010b
-11011110b & 00110011b = 00010010b
-11011110b & 00110100b = 00010100b
-11011110b & 00110101b = 00010100b
-11011110b & 00110110b = 00010110b
-11011110b & 00110111b = 00010110b
-11011110b & 00111000b = 00011000b
-11011110b & 00111001b = 00011000b
-11011110b & 00111010b = 00011010b
-11011110b & 00111011b = 00011010b
-11011110b & 00111100b = 00011100b
-11011110b & 00111101b = 00011100b
-11011110b & 00111110b = 00011110b
-11011110b & 00111111b = 00011110b
-11011110b & 01000000b = 01000000b
-11011110b & 01000001b = 01000000b
-11011110b & 01000010b = 01000010b
-11011110b & 01000011b = 01000010b
-11011110b & 01000100b = 01000100b
-11011110b & 01000101b = 01000100b
-11011110b & 01000110b = 01000110b
-11011110b & 01000111b = 01000110b
-11011110b & 01001000b = 01001000b
-11011110b & 01001001b = 01001000b
-11011110b & 01001010b = 01001010b
-11011110b & 01001011b = 01001010b
-11011110b & 01001100b = 01001100b
-11011110b & 01001101b = 01001100b
-11011110b & 01001110b = 01001110b
-11011110b & 01001111b = 01001110b
-11011110b & 01010000b = 01010000b
-11011110b & 01010001b = 01010000b
-11011110b & 01010010b = 01010010b
-11011110b & 01010011b = 01010010b
-11011110b & 01010100b = 01010100b
-11011110b & 01010101b = 01010100b
-11011110b & 01010110b = 01010110b
-11011110b & 01010111b = 01010110b
-11011110b & 01011000b = 01011000b
-11011110b & 01011001b = 01011000b
-11011110b & 01011010b = 01011010b
-11011110b & 01011011b = 01011010b
-11011110b & 01011100b = 01011100b
-11011110b & 01011101b = 01011100b
-11011110b & 01011110b = 01011110b
-11011110b & 01011111b = 01011110b
-11011110b & 01100000b = 01000000b
-11011110b & 01100001b = 01000000b
-11011110b & 01100010b = 01000010b
-11011110b & 01100011b = 01000010b
-11011110b & 01100100b = 01000100b
-11011110b & 01100101b = 01000100b
-11011110b & 01100110b = 01000110b
-11011110b & 01100111b = 01000110b
-11011110b & 01101000b = 01001000b
-11011110b & 01101001b = 01001000b
-11011110b & 01101010b = 01001010b
-11011110b & 01101011b = 01001010b
-11011110b & 01101100b = 01001100b
-11011110b & 01101101b = 01001100b
-11011110b & 01101110b = 01001110b
-11011110b & 01101111b = 01001110b
-11011110b & 01110000b = 01010000b
-11011110b & 01110001b = 01010000b
-11011110b & 01110010b = 01010010b
-11011110b & 01110011b = 01010010b
-11011110b & 01110100b = 01010100b
-11011110b & 01110101b = 01010100b
-11011110b & 01110110b = 01010110b
-11011110b & 01110111b = 01010110b
-11011110b & 01111000b = 01011000b
-11011110b & 01111001b = 01011000b
-11011110b & 01111010b = 01011010b
-11011110b & 01111011b = 01011010b
-11011110b & 01111100b = 01011100b
-11011110b & 01111101b = 01011100b
-11011110b & 01111110b = 01011110b
-11011111b & 10000000b = 10000000b
-11011111b & 10000001b = 10000001b
-11011111b & 10000010b = 10000010b
-11011111b & 10000011b = 10000011b
-11011111b & 10000100b = 10000100b
-11011111b & 10000101b = 10000101b
-11011111b & 10000110b = 10000110b
-11011111b & 10000111b = 10000111b
-11011111b & 10001000b = 10001000b
-11011111b & 10001001b = 10001001b
-11011111b & 10001010b = 10001010b
-11011111b & 10001011b = 10001011b
-11011111b & 10001100b = 10001100b
-11011111b & 10001101b = 10001101b
-11011111b & 10001110b = 10001110b
-11011111b & 10001111b = 10001111b
-11011111b & 10010000b = 10010000b
-11011111b & 10010001b = 10010001b
-11011111b & 10010010b = 10010010b
-11011111b & 10010011b = 10010011b
-11011111b & 10010100b = 10010100b
-11011111b & 10010101b = 10010101b
-11011111b & 10010110b = 10010110b
-11011111b & 10010111b = 10010111b
-11011111b & 10011000b = 10011000b
-11011111b & 10011001b = 10011001b
-11011111b & 10011010b = 10011010b
-11011111b & 10011011b = 10011011b
-11011111b & 10011100b = 10011100b
-11011111b & 10011101b = 10011101b
-11011111b & 10011110b = 10011110b
-11011111b & 10011111b = 10011111b
-11011111b & 10100000b = 10000000b
-11011111b & 10100001b = 10000001b
-11011111b & 10100010b = 10000010b
-11011111b & 10100011b = 10000011b
-11011111b & 10100100b = 10000100b
-11011111b & 10100101b = 10000101b
-11011111b & 10100110b = 10000110b
-11011111b & 10100111b = 10000111b
-11011111b & 10101000b = 10001000b
-11011111b & 10101001b = 10001001b
-11011111b & 10101010b = 10001010b
-11011111b & 10101011b = 10001011b
-11011111b & 10101100b = 10001100b
-11011111b & 10101101b = 10001101b
-11011111b & 10101110b = 10001110b
-11011111b & 10101111b = 10001111b
-11011111b & 10110000b = 10010000b
-11011111b & 10110001b = 10010001b
-11011111b & 10110010b = 10010010b
-11011111b & 10110011b = 10010011b
-11011111b & 10110100b = 10010100b
-11011111b & 10110101b = 10010101b
-11011111b & 10110110b = 10010110b
-11011111b & 10110111b = 10010111b
-11011111b & 10111000b = 10011000b
-11011111b & 10111001b = 10011001b
-11011111b & 10111010b = 10011010b
-11011111b & 10111011b = 10011011b
-11011111b & 10111100b = 10011100b
-11011111b & 10111101b = 10011101b
-11011111b & 10111110b = 10011110b
-11011111b & 10111111b = 10011111b
-11011111b & 11000000b = 11000000b
-11011111b & 11000001b = 11000001b
-11011111b & 11000010b = 11000010b
-11011111b & 11000011b = 11000011b
-11011111b & 11000100b = 11000100b
-11011111b & 11000101b = 11000101b
-11011111b & 11000110b = 11000110b
-11011111b & 11000111b = 11000111b
-11011111b & 11001000b = 11001000b
-11011111b & 11001001b = 11001001b
-11011111b & 11001010b = 11001010b
-11011111b & 11001011b = 11001011b
-11011111b & 11001100b = 11001100b
-11011111b & 11001101b = 11001101b
-11011111b & 11001110b = 11001110b
-11011111b & 11001111b = 11001111b
-11011111b & 11010000b = 11010000b
-11011111b & 11010001b = 11010001b
-11011111b & 11010010b = 11010010b
-11011111b & 11010011b = 11010011b
-11011111b & 11010100b = 11010100b
-11011111b & 11010101b = 11010101b
-11011111b & 11010110b = 11010110b
-11011111b & 11010111b = 11010111b
-11011111b & 11011000b = 11011000b
-11011111b & 11011001b = 11011001b
-11011111b & 11011010b = 11011010b
-11011111b & 11011011b = 11011011b
-11011111b & 11011100b = 11011100b
-11011111b & 11011101b = 11011101b
-11011111b & 11011110b = 11011110b
-11011111b & 11011111b = 11011111b
-11011111b & 11100000b = 11000000b
-11011111b & 11100001b = 11000001b
-11011111b & 11100010b = 11000010b
-11011111b & 11100011b = 11000011b
-11011111b & 11100100b = 11000100b
-11011111b & 11100101b = 11000101b
-11011111b & 11100110b = 11000110b
-11011111b & 11100111b = 11000111b
-11011111b & 11101000b = 11001000b
-11011111b & 11101001b = 11001001b
-11011111b & 11101010b = 11001010b
-11011111b & 11101011b = 11001011b
-11011111b & 11101100b = 11001100b
-11011111b & 11101101b = 11001101b
-11011111b & 11101110b = 11001110b
-11011111b & 11101111b = 11001111b
-11011111b & 11110000b = 11010000b
-11011111b & 11110001b = 11010001b
-11011111b & 11110010b = 11010010b
-11011111b & 11110011b = 11010011b
-11011111b & 11110100b = 11010100b
-11011111b & 11110101b = 11010101b
-11011111b & 11110110b = 11010110b
-11011111b & 11110111b = 11010111b
-11011111b & 11111000b = 11011000b
-11011111b & 11111001b = 11011001b
-11011111b & 11111010b = 11011010b
-11011111b & 11111011b = 11011011b
-11011111b & 11111100b = 11011100b
-11011111b & 11111101b = 11011101b
-11011111b & 11111110b = 11011110b
-11011111b & 11111111b = 11011111b
-11011111b & 00000000b = 00000000b
-11011111b & 00000001b = 00000001b
-11011111b & 00000010b = 00000010b
-11011111b & 00000011b = 00000011b
-11011111b & 00000100b = 00000100b
-11011111b & 00000101b = 00000101b
-11011111b & 00000110b = 00000110b
-11011111b & 00000111b = 00000111b
-11011111b & 00001000b = 00001000b
-11011111b & 00001001b = 00001001b
-11011111b & 00001010b = 00001010b
-11011111b & 00001011b = 00001011b
-11011111b & 00001100b = 00001100b
-11011111b & 00001101b = 00001101b
-11011111b & 00001110b = 00001110b
-11011111b & 00001111b = 00001111b
-11011111b & 00010000b = 00010000b
-11011111b & 00010001b = 00010001b
-11011111b & 00010010b = 00010010b
-11011111b & 00010011b = 00010011b
-11011111b & 00010100b = 00010100b
-11011111b & 00010101b = 00010101b
-11011111b & 00010110b = 00010110b
-11011111b & 00010111b = 00010111b
-11011111b & 00011000b = 00011000b
-11011111b & 00011001b = 00011001b
-11011111b & 00011010b = 00011010b
-11011111b & 00011011b = 00011011b
-11011111b & 00011100b = 00011100b
-11011111b & 00011101b = 00011101b
-11011111b & 00011110b = 00011110b
-11011111b & 00011111b = 00011111b
-11011111b & 00100000b = 00000000b
-11011111b & 00100001b = 00000001b
-11011111b & 00100010b = 00000010b
-11011111b & 00100011b = 00000011b
-11011111b & 00100100b = 00000100b
-11011111b & 00100101b = 00000101b
-11011111b & 00100110b = 00000110b
-11011111b & 00100111b = 00000111b
-11011111b & 00101000b = 00001000b
-11011111b & 00101001b = 00001001b
-11011111b & 00101010b = 00001010b
-11011111b & 00101011b = 00001011b
-11011111b & 00101100b = 00001100b
-11011111b & 00101101b = 00001101b
-11011111b & 00101110b = 00001110b
-11011111b & 00101111b = 00001111b
-11011111b & 00110000b = 00010000b
-11011111b & 00110001b = 00010001b
-11011111b & 00110010b = 00010010b
-11011111b & 00110011b = 00010011b
-11011111b & 00110100b = 00010100b
-11011111b & 00110101b = 00010101b
-11011111b & 00110110b = 00010110b
-11011111b & 00110111b = 00010111b
-11011111b & 00111000b = 00011000b
-11011111b & 00111001b = 00011001b
-11011111b & 00111010b = 00011010b
-11011111b & 00111011b = 00011011b
-11011111b & 00111100b = 00011100b
-11011111b & 00111101b = 00011101b
-11011111b & 00111110b = 00011110b
-11011111b & 00111111b = 00011111b
-11011111b & 01000000b = 01000000b
-11011111b & 01000001b = 01000001b
-11011111b & 01000010b = 01000010b
-11011111b & 01000011b = 01000011b
-11011111b & 01000100b = 01000100b
-11011111b & 01000101b = 01000101b
-11011111b & 01000110b = 01000110b
-11011111b & 01000111b = 01000111b
-11011111b & 01001000b = 01001000b
-11011111b & 01001001b = 01001001b
-11011111b & 01001010b = 01001010b
-11011111b & 01001011b = 01001011b
-11011111b & 01001100b = 01001100b
-11011111b & 01001101b = 01001101b
-11011111b & 01001110b = 01001110b
-11011111b & 01001111b = 01001111b
-11011111b & 01010000b = 01010000b
-11011111b & 01010001b = 01010001b
-11011111b & 01010010b = 01010010b
-11011111b & 01010011b = 01010011b
-11011111b & 01010100b = 01010100b
-11011111b & 01010101b = 01010101b
-11011111b & 01010110b = 01010110b
-11011111b & 01010111b = 01010111b
-11011111b & 01011000b = 01011000b
-11011111b & 01011001b = 01011001b
-11011111b & 01011010b = 01011010b
-11011111b & 01011011b = 01011011b
-11011111b & 01011100b = 01011100b
-11011111b & 01011101b = 01011101b
-11011111b & 01011110b = 01011110b
-11011111b & 01011111b = 01011111b
-11011111b & 01100000b = 01000000b
-11011111b & 01100001b = 01000001b
-11011111b & 01100010b = 01000010b
-11011111b & 01100011b = 01000011b
-11011111b & 01100100b = 01000100b
-11011111b & 01100101b = 01000101b
-11011111b & 01100110b = 01000110b
-11011111b & 01100111b = 01000111b
-11011111b & 01101000b = 01001000b
-11011111b & 01101001b = 01001001b
-11011111b & 01101010b = 01001010b
-11011111b & 01101011b = 01001011b
-11011111b & 01101100b = 01001100b
-11011111b & 01101101b = 01001101b
-11011111b & 01101110b = 01001110b
-11011111b & 01101111b = 01001111b
-11011111b & 01110000b = 01010000b
-11011111b & 01110001b = 01010001b
-11011111b & 01110010b = 01010010b
-11011111b & 01110011b = 01010011b
-11011111b & 01110100b = 01010100b
-11011111b & 01110101b = 01010101b
-11011111b & 01110110b = 01010110b
-11011111b & 01110111b = 01010111b
-11011111b & 01111000b = 01011000b
-11011111b & 01111001b = 01011001b
-11011111b & 01111010b = 01011010b
-11011111b & 01111011b = 01011011b
-11011111b & 01111100b = 01011100b
-11011111b & 01111101b = 01011101b
-11011111b & 01111110b = 01011110b
-11100000b & 10000000b = 10000000b
-11100000b & 10000001b = 10000000b
-11100000b & 10000010b = 10000000b
-11100000b & 10000011b = 10000000b
-11100000b & 10000100b = 10000000b
-11100000b & 10000101b = 10000000b
-11100000b & 10000110b = 10000000b
-11100000b & 10000111b = 10000000b
-11100000b & 10001000b = 10000000b
-11100000b & 10001001b = 10000000b
-11100000b & 10001010b = 10000000b
-11100000b & 10001011b = 10000000b
-11100000b & 10001100b = 10000000b
-11100000b & 10001101b = 10000000b
-11100000b & 10001110b = 10000000b
-11100000b & 10001111b = 10000000b
-11100000b & 10010000b = 10000000b
-11100000b & 10010001b = 10000000b
-11100000b & 10010010b = 10000000b
-11100000b & 10010011b = 10000000b
-11100000b & 10010100b = 10000000b
-11100000b & 10010101b = 10000000b
-11100000b & 10010110b = 10000000b
-11100000b & 10010111b = 10000000b
-11100000b & 10011000b = 10000000b
-11100000b & 10011001b = 10000000b
-11100000b & 10011010b = 10000000b
-11100000b & 10011011b = 10000000b
-11100000b & 10011100b = 10000000b
-11100000b & 10011101b = 10000000b
-11100000b & 10011110b = 10000000b
-11100000b & 10011111b = 10000000b
-11100000b & 10100000b = 10100000b
-11100000b & 10100001b = 10100000b
-11100000b & 10100010b = 10100000b
-11100000b & 10100011b = 10100000b
-11100000b & 10100100b = 10100000b
-11100000b & 10100101b = 10100000b
-11100000b & 10100110b = 10100000b
-11100000b & 10100111b = 10100000b
-11100000b & 10101000b = 10100000b
-11100000b & 10101001b = 10100000b
-11100000b & 10101010b = 10100000b
-11100000b & 10101011b = 10100000b
-11100000b & 10101100b = 10100000b
-11100000b & 10101101b = 10100000b
-11100000b & 10101110b = 10100000b
-11100000b & 10101111b = 10100000b
-11100000b & 10110000b = 10100000b
-11100000b & 10110001b = 10100000b
-11100000b & 10110010b = 10100000b
-11100000b & 10110011b = 10100000b
-11100000b & 10110100b = 10100000b
-11100000b & 10110101b = 10100000b
-11100000b & 10110110b = 10100000b
-11100000b & 10110111b = 10100000b
-11100000b & 10111000b = 10100000b
-11100000b & 10111001b = 10100000b
-11100000b & 10111010b = 10100000b
-11100000b & 10111011b = 10100000b
-11100000b & 10111100b = 10100000b
-11100000b & 10111101b = 10100000b
-11100000b & 10111110b = 10100000b
-11100000b & 10111111b = 10100000b
-11100000b & 11000000b = 11000000b
-11100000b & 11000001b = 11000000b
-11100000b & 11000010b = 11000000b
-11100000b & 11000011b = 11000000b
-11100000b & 11000100b = 11000000b
-11100000b & 11000101b = 11000000b
-11100000b & 11000110b = 11000000b
-11100000b & 11000111b = 11000000b
-11100000b & 11001000b = 11000000b
-11100000b & 11001001b = 11000000b
-11100000b & 11001010b = 11000000b
-11100000b & 11001011b = 11000000b
-11100000b & 11001100b = 11000000b
-11100000b & 11001101b = 11000000b
-11100000b & 11001110b = 11000000b
-11100000b & 11001111b = 11000000b
-11100000b & 11010000b = 11000000b
-11100000b & 11010001b = 11000000b
-11100000b & 11010010b = 11000000b
-11100000b & 11010011b = 11000000b
-11100000b & 11010100b = 11000000b
-11100000b & 11010101b = 11000000b
-11100000b & 11010110b = 11000000b
-11100000b & 11010111b = 11000000b
-11100000b & 11011000b = 11000000b
-11100000b & 11011001b = 11000000b
-11100000b & 11011010b = 11000000b
-11100000b & 11011011b = 11000000b
-11100000b & 11011100b = 11000000b
-11100000b & 11011101b = 11000000b
-11100000b & 11011110b = 11000000b
-11100000b & 11011111b = 11000000b
-11100000b & 11100000b = 11100000b
-11100000b & 11100001b = 11100000b
-11100000b & 11100010b = 11100000b
-11100000b & 11100011b = 11100000b
-11100000b & 11100100b = 11100000b
-11100000b & 11100101b = 11100000b
-11100000b & 11100110b = 11100000b
-11100000b & 11100111b = 11100000b
-11100000b & 11101000b = 11100000b
-11100000b & 11101001b = 11100000b
-11100000b & 11101010b = 11100000b
-11100000b & 11101011b = 11100000b
-11100000b & 11101100b = 11100000b
-11100000b & 11101101b = 11100000b
-11100000b & 11101110b = 11100000b
-11100000b & 11101111b = 11100000b
-11100000b & 11110000b = 11100000b
-11100000b & 11110001b = 11100000b
-11100000b & 11110010b = 11100000b
-11100000b & 11110011b = 11100000b
-11100000b & 11110100b = 11100000b
-11100000b & 11110101b = 11100000b
-11100000b & 11110110b = 11100000b
-11100000b & 11110111b = 11100000b
-11100000b & 11111000b = 11100000b
-11100000b & 11111001b = 11100000b
-11100000b & 11111010b = 11100000b
-11100000b & 11111011b = 11100000b
-11100000b & 11111100b = 11100000b
-11100000b & 11111101b = 11100000b
-11100000b & 11111110b = 11100000b
-11100000b & 11111111b = 11100000b
-11100000b & 00000000b = 00000000b
-11100000b & 00000001b = 00000000b
-11100000b & 00000010b = 00000000b
-11100000b & 00000011b = 00000000b
-11100000b & 00000100b = 00000000b
-11100000b & 00000101b = 00000000b
-11100000b & 00000110b = 00000000b
-11100000b & 00000111b = 00000000b
-11100000b & 00001000b = 00000000b
-11100000b & 00001001b = 00000000b
-11100000b & 00001010b = 00000000b
-11100000b & 00001011b = 00000000b
-11100000b & 00001100b = 00000000b
-11100000b & 00001101b = 00000000b
-11100000b & 00001110b = 00000000b
-11100000b & 00001111b = 00000000b
-11100000b & 00010000b = 00000000b
-11100000b & 00010001b = 00000000b
-11100000b & 00010010b = 00000000b
-11100000b & 00010011b = 00000000b
-11100000b & 00010100b = 00000000b
-11100000b & 00010101b = 00000000b
-11100000b & 00010110b = 00000000b
-11100000b & 00010111b = 00000000b
-11100000b & 00011000b = 00000000b
-11100000b & 00011001b = 00000000b
-11100000b & 00011010b = 00000000b
-11100000b & 00011011b = 00000000b
-11100000b & 00011100b = 00000000b
-11100000b & 00011101b = 00000000b
-11100000b & 00011110b = 00000000b
-11100000b & 00011111b = 00000000b
-11100000b & 00100000b = 00100000b
-11100000b & 00100001b = 00100000b
-11100000b & 00100010b = 00100000b
-11100000b & 00100011b = 00100000b
-11100000b & 00100100b = 00100000b
-11100000b & 00100101b = 00100000b
-11100000b & 00100110b = 00100000b
-11100000b & 00100111b = 00100000b
-11100000b & 00101000b = 00100000b
-11100000b & 00101001b = 00100000b
-11100000b & 00101010b = 00100000b
-11100000b & 00101011b = 00100000b
-11100000b & 00101100b = 00100000b
-11100000b & 00101101b = 00100000b
-11100000b & 00101110b = 00100000b
-11100000b & 00101111b = 00100000b
-11100000b & 00110000b = 00100000b
-11100000b & 00110001b = 00100000b
-11100000b & 00110010b = 00100000b
-11100000b & 00110011b = 00100000b
-11100000b & 00110100b = 00100000b
-11100000b & 00110101b = 00100000b
-11100000b & 00110110b = 00100000b
-11100000b & 00110111b = 00100000b
-11100000b & 00111000b = 00100000b
-11100000b & 00111001b = 00100000b
-11100000b & 00111010b = 00100000b
-11100000b & 00111011b = 00100000b
-11100000b & 00111100b = 00100000b
-11100000b & 00111101b = 00100000b
-11100000b & 00111110b = 00100000b
-11100000b & 00111111b = 00100000b
-11100000b & 01000000b = 01000000b
-11100000b & 01000001b = 01000000b
-11100000b & 01000010b = 01000000b
-11100000b & 01000011b = 01000000b
-11100000b & 01000100b = 01000000b
-11100000b & 01000101b = 01000000b
-11100000b & 01000110b = 01000000b
-11100000b & 01000111b = 01000000b
-11100000b & 01001000b = 01000000b
-11100000b & 01001001b = 01000000b
-11100000b & 01001010b = 01000000b
-11100000b & 01001011b = 01000000b
-11100000b & 01001100b = 01000000b
-11100000b & 01001101b = 01000000b
-11100000b & 01001110b = 01000000b
-11100000b & 01001111b = 01000000b
-11100000b & 01010000b = 01000000b
-11100000b & 01010001b = 01000000b
-11100000b & 01010010b = 01000000b
-11100000b & 01010011b = 01000000b
-11100000b & 01010100b = 01000000b
-11100000b & 01010101b = 01000000b
-11100000b & 01010110b = 01000000b
-11100000b & 01010111b = 01000000b
-11100000b & 01011000b = 01000000b
-11100000b & 01011001b = 01000000b
-11100000b & 01011010b = 01000000b
-11100000b & 01011011b = 01000000b
-11100000b & 01011100b = 01000000b
-11100000b & 01011101b = 01000000b
-11100000b & 01011110b = 01000000b
-11100000b & 01011111b = 01000000b
-11100000b & 01100000b = 01100000b
-11100000b & 01100001b = 01100000b
-11100000b & 01100010b = 01100000b
-11100000b & 01100011b = 01100000b
-11100000b & 01100100b = 01100000b
-11100000b & 01100101b = 01100000b
-11100000b & 01100110b = 01100000b
-11100000b & 01100111b = 01100000b
-11100000b & 01101000b = 01100000b
-11100000b & 01101001b = 01100000b
-11100000b & 01101010b = 01100000b
-11100000b & 01101011b = 01100000b
-11100000b & 01101100b = 01100000b
-11100000b & 01101101b = 01100000b
-11100000b & 01101110b = 01100000b
-11100000b & 01101111b = 01100000b
-11100000b & 01110000b = 01100000b
-11100000b & 01110001b = 01100000b
-11100000b & 01110010b = 01100000b
-11100000b & 01110011b = 01100000b
-11100000b & 01110100b = 01100000b
-11100000b & 01110101b = 01100000b
-11100000b & 01110110b = 01100000b
-11100000b & 01110111b = 01100000b
-11100000b & 01111000b = 01100000b
-11100000b & 01111001b = 01100000b
-11100000b & 01111010b = 01100000b
-11100000b & 01111011b = 01100000b
-11100000b & 01111100b = 01100000b
-11100000b & 01111101b = 01100000b
-11100000b & 01111110b = 01100000b
-11100001b & 10000000b = 10000000b
-11100001b & 10000001b = 10000001b
-11100001b & 10000010b = 10000000b
-11100001b & 10000011b = 10000001b
-11100001b & 10000100b = 10000000b
-11100001b & 10000101b = 10000001b
-11100001b & 10000110b = 10000000b
-11100001b & 10000111b = 10000001b
-11100001b & 10001000b = 10000000b
-11100001b & 10001001b = 10000001b
-11100001b & 10001010b = 10000000b
-11100001b & 10001011b = 10000001b
-11100001b & 10001100b = 10000000b
-11100001b & 10001101b = 10000001b
-11100001b & 10001110b = 10000000b
-11100001b & 10001111b = 10000001b
-11100001b & 10010000b = 10000000b
-11100001b & 10010001b = 10000001b
-11100001b & 10010010b = 10000000b
-11100001b & 10010011b = 10000001b
-11100001b & 10010100b = 10000000b
-11100001b & 10010101b = 10000001b
-11100001b & 10010110b = 10000000b
-11100001b & 10010111b = 10000001b
-11100001b & 10011000b = 10000000b
-11100001b & 10011001b = 10000001b
-11100001b & 10011010b = 10000000b
-11100001b & 10011011b = 10000001b
-11100001b & 10011100b = 10000000b
-11100001b & 10011101b = 10000001b
-11100001b & 10011110b = 10000000b
-11100001b & 10011111b = 10000001b
-11100001b & 10100000b = 10100000b
-11100001b & 10100001b = 10100001b
-11100001b & 10100010b = 10100000b
-11100001b & 10100011b = 10100001b
-11100001b & 10100100b = 10100000b
-11100001b & 10100101b = 10100001b
-11100001b & 10100110b = 10100000b
-11100001b & 10100111b = 10100001b
-11100001b & 10101000b = 10100000b
-11100001b & 10101001b = 10100001b
-11100001b & 10101010b = 10100000b
-11100001b & 10101011b = 10100001b
-11100001b & 10101100b = 10100000b
-11100001b & 10101101b = 10100001b
-11100001b & 10101110b = 10100000b
-11100001b & 10101111b = 10100001b
-11100001b & 10110000b = 10100000b
-11100001b & 10110001b = 10100001b
-11100001b & 10110010b = 10100000b
-11100001b & 10110011b = 10100001b
-11100001b & 10110100b = 10100000b
-11100001b & 10110101b = 10100001b
-11100001b & 10110110b = 10100000b
-11100001b & 10110111b = 10100001b
-11100001b & 10111000b = 10100000b
-11100001b & 10111001b = 10100001b
-11100001b & 10111010b = 10100000b
-11100001b & 10111011b = 10100001b
-11100001b & 10111100b = 10100000b
-11100001b & 10111101b = 10100001b
-11100001b & 10111110b = 10100000b
-11100001b & 10111111b = 10100001b
-11100001b & 11000000b = 11000000b
-11100001b & 11000001b = 11000001b
-11100001b & 11000010b = 11000000b
-11100001b & 11000011b = 11000001b
-11100001b & 11000100b = 11000000b
-11100001b & 11000101b = 11000001b
-11100001b & 11000110b = 11000000b
-11100001b & 11000111b = 11000001b
-11100001b & 11001000b = 11000000b
-11100001b & 11001001b = 11000001b
-11100001b & 11001010b = 11000000b
-11100001b & 11001011b = 11000001b
-11100001b & 11001100b = 11000000b
-11100001b & 11001101b = 11000001b
-11100001b & 11001110b = 11000000b
-11100001b & 11001111b = 11000001b
-11100001b & 11010000b = 11000000b
-11100001b & 11010001b = 11000001b
-11100001b & 11010010b = 11000000b
-11100001b & 11010011b = 11000001b
-11100001b & 11010100b = 11000000b
-11100001b & 11010101b = 11000001b
-11100001b & 11010110b = 11000000b
-11100001b & 11010111b = 11000001b
-11100001b & 11011000b = 11000000b
-11100001b & 11011001b = 11000001b
-11100001b & 11011010b = 11000000b
-11100001b & 11011011b = 11000001b
-11100001b & 11011100b = 11000000b
-11100001b & 11011101b = 11000001b
-11100001b & 11011110b = 11000000b
-11100001b & 11011111b = 11000001b
-11100001b & 11100000b = 11100000b
-11100001b & 11100001b = 11100001b
-11100001b & 11100010b = 11100000b
-11100001b & 11100011b = 11100001b
-11100001b & 11100100b = 11100000b
-11100001b & 11100101b = 11100001b
-11100001b & 11100110b = 11100000b
-11100001b & 11100111b = 11100001b
-11100001b & 11101000b = 11100000b
-11100001b & 11101001b = 11100001b
-11100001b & 11101010b = 11100000b
-11100001b & 11101011b = 11100001b
-11100001b & 11101100b = 11100000b
-11100001b & 11101101b = 11100001b
-11100001b & 11101110b = 11100000b
-11100001b & 11101111b = 11100001b
-11100001b & 11110000b = 11100000b
-11100001b & 11110001b = 11100001b
-11100001b & 11110010b = 11100000b
-11100001b & 11110011b = 11100001b
-11100001b & 11110100b = 11100000b
-11100001b & 11110101b = 11100001b
-11100001b & 11110110b = 11100000b
-11100001b & 11110111b = 11100001b
-11100001b & 11111000b = 11100000b
-11100001b & 11111001b = 11100001b
-11100001b & 11111010b = 11100000b
-11100001b & 11111011b = 11100001b
-11100001b & 11111100b = 11100000b
-11100001b & 11111101b = 11100001b
-11100001b & 11111110b = 11100000b
-11100001b & 11111111b = 11100001b
-11100001b & 00000000b = 00000000b
-11100001b & 00000001b = 00000001b
-11100001b & 00000010b = 00000000b
-11100001b & 00000011b = 00000001b
-11100001b & 00000100b = 00000000b
-11100001b & 00000101b = 00000001b
-11100001b & 00000110b = 00000000b
-11100001b & 00000111b = 00000001b
-11100001b & 00001000b = 00000000b
-11100001b & 00001001b = 00000001b
-11100001b & 00001010b = 00000000b
-11100001b & 00001011b = 00000001b
-11100001b & 00001100b = 00000000b
-11100001b & 00001101b = 00000001b
-11100001b & 00001110b = 00000000b
-11100001b & 00001111b = 00000001b
-11100001b & 00010000b = 00000000b
-11100001b & 00010001b = 00000001b
-11100001b & 00010010b = 00000000b
-11100001b & 00010011b = 00000001b
-11100001b & 00010100b = 00000000b
-11100001b & 00010101b = 00000001b
-11100001b & 00010110b = 00000000b
-11100001b & 00010111b = 00000001b
-11100001b & 00011000b = 00000000b
-11100001b & 00011001b = 00000001b
-11100001b & 00011010b = 00000000b
-11100001b & 00011011b = 00000001b
-11100001b & 00011100b = 00000000b
-11100001b & 00011101b = 00000001b
-11100001b & 00011110b = 00000000b
-11100001b & 00011111b = 00000001b
-11100001b & 00100000b = 00100000b
-11100001b & 00100001b = 00100001b
-11100001b & 00100010b = 00100000b
-11100001b & 00100011b = 00100001b
-11100001b & 00100100b = 00100000b
-11100001b & 00100101b = 00100001b
-11100001b & 00100110b = 00100000b
-11100001b & 00100111b = 00100001b
-11100001b & 00101000b = 00100000b
-11100001b & 00101001b = 00100001b
-11100001b & 00101010b = 00100000b
-11100001b & 00101011b = 00100001b
-11100001b & 00101100b = 00100000b
-11100001b & 00101101b = 00100001b
-11100001b & 00101110b = 00100000b
-11100001b & 00101111b = 00100001b
-11100001b & 00110000b = 00100000b
-11100001b & 00110001b = 00100001b
-11100001b & 00110010b = 00100000b
-11100001b & 00110011b = 00100001b
-11100001b & 00110100b = 00100000b
-11100001b & 00110101b = 00100001b
-11100001b & 00110110b = 00100000b
-11100001b & 00110111b = 00100001b
-11100001b & 00111000b = 00100000b
-11100001b & 00111001b = 00100001b
-11100001b & 00111010b = 00100000b
-11100001b & 00111011b = 00100001b
-11100001b & 00111100b = 00100000b
-11100001b & 00111101b = 00100001b
-11100001b & 00111110b = 00100000b
-11100001b & 00111111b = 00100001b
-11100001b & 01000000b = 01000000b
-11100001b & 01000001b = 01000001b
-11100001b & 01000010b = 01000000b
-11100001b & 01000011b = 01000001b
-11100001b & 01000100b = 01000000b
-11100001b & 01000101b = 01000001b
-11100001b & 01000110b = 01000000b
-11100001b & 01000111b = 01000001b
-11100001b & 01001000b = 01000000b
-11100001b & 01001001b = 01000001b
-11100001b & 01001010b = 01000000b
-11100001b & 01001011b = 01000001b
-11100001b & 01001100b = 01000000b
-11100001b & 01001101b = 01000001b
-11100001b & 01001110b = 01000000b
-11100001b & 01001111b = 01000001b
-11100001b & 01010000b = 01000000b
-11100001b & 01010001b = 01000001b
-11100001b & 01010010b = 01000000b
-11100001b & 01010011b = 01000001b
-11100001b & 01010100b = 01000000b
-11100001b & 01010101b = 01000001b
-11100001b & 01010110b = 01000000b
-11100001b & 01010111b = 01000001b
-11100001b & 01011000b = 01000000b
-11100001b & 01011001b = 01000001b
-11100001b & 01011010b = 01000000b
-11100001b & 01011011b = 01000001b
-11100001b & 01011100b = 01000000b
-11100001b & 01011101b = 01000001b
-11100001b & 01011110b = 01000000b
-11100001b & 01011111b = 01000001b
-11100001b & 01100000b = 01100000b
-11100001b & 01100001b = 01100001b
-11100001b & 01100010b = 01100000b
-11100001b & 01100011b = 01100001b
-11100001b & 01100100b = 01100000b
-11100001b & 01100101b = 01100001b
-11100001b & 01100110b = 01100000b
-11100001b & 01100111b = 01100001b
-11100001b & 01101000b = 01100000b
-11100001b & 01101001b = 01100001b
-11100001b & 01101010b = 01100000b
-11100001b & 01101011b = 01100001b
-11100001b & 01101100b = 01100000b
-11100001b & 01101101b = 01100001b
-11100001b & 01101110b = 01100000b
-11100001b & 01101111b = 01100001b
-11100001b & 01110000b = 01100000b
-11100001b & 01110001b = 01100001b
-11100001b & 01110010b = 01100000b
-11100001b & 01110011b = 01100001b
-11100001b & 01110100b = 01100000b
-11100001b & 01110101b = 01100001b
-11100001b & 01110110b = 01100000b
-11100001b & 01110111b = 01100001b
-11100001b & 01111000b = 01100000b
-11100001b & 01111001b = 01100001b
-11100001b & 01111010b = 01100000b
-11100001b & 01111011b = 01100001b
-11100001b & 01111100b = 01100000b
-11100001b & 01111101b = 01100001b
-11100001b & 01111110b = 01100000b
-11100010b & 10000000b = 10000000b
-11100010b & 10000001b = 10000000b
-11100010b & 10000010b = 10000010b
-11100010b & 10000011b = 10000010b
-11100010b & 10000100b = 10000000b
-11100010b & 10000101b = 10000000b
-11100010b & 10000110b = 10000010b
-11100010b & 10000111b = 10000010b
-11100010b & 10001000b = 10000000b
-11100010b & 10001001b = 10000000b
-11100010b & 10001010b = 10000010b
-11100010b & 10001011b = 10000010b
-11100010b & 10001100b = 10000000b
-11100010b & 10001101b = 10000000b
-11100010b & 10001110b = 10000010b
-11100010b & 10001111b = 10000010b
-11100010b & 10010000b = 10000000b
-11100010b & 10010001b = 10000000b
-11100010b & 10010010b = 10000010b
-11100010b & 10010011b = 10000010b
-11100010b & 10010100b = 10000000b
-11100010b & 10010101b = 10000000b
-11100010b & 10010110b = 10000010b
-11100010b & 10010111b = 10000010b
-11100010b & 10011000b = 10000000b
-11100010b & 10011001b = 10000000b
-11100010b & 10011010b = 10000010b
-11100010b & 10011011b = 10000010b
-11100010b & 10011100b = 10000000b
-11100010b & 10011101b = 10000000b
-11100010b & 10011110b = 10000010b
-11100010b & 10011111b = 10000010b
-11100010b & 10100000b = 10100000b
-11100010b & 10100001b = 10100000b
-11100010b & 10100010b = 10100010b
-11100010b & 10100011b = 10100010b
-11100010b & 10100100b = 10100000b
-11100010b & 10100101b = 10100000b
-11100010b & 10100110b = 10100010b
-11100010b & 10100111b = 10100010b
-11100010b & 10101000b = 10100000b
-11100010b & 10101001b = 10100000b
-11100010b & 10101010b = 10100010b
-11100010b & 10101011b = 10100010b
-11100010b & 10101100b = 10100000b
-11100010b & 10101101b = 10100000b
-11100010b & 10101110b = 10100010b
-11100010b & 10101111b = 10100010b
-11100010b & 10110000b = 10100000b
-11100010b & 10110001b = 10100000b
-11100010b & 10110010b = 10100010b
-11100010b & 10110011b = 10100010b
-11100010b & 10110100b = 10100000b
-11100010b & 10110101b = 10100000b
-11100010b & 10110110b = 10100010b
-11100010b & 10110111b = 10100010b
-11100010b & 10111000b = 10100000b
-11100010b & 10111001b = 10100000b
-11100010b & 10111010b = 10100010b
-11100010b & 10111011b = 10100010b
-11100010b & 10111100b = 10100000b
-11100010b & 10111101b = 10100000b
-11100010b & 10111110b = 10100010b
-11100010b & 10111111b = 10100010b
-11100010b & 11000000b = 11000000b
-11100010b & 11000001b = 11000000b
-11100010b & 11000010b = 11000010b
-11100010b & 11000011b = 11000010b
-11100010b & 11000100b = 11000000b
-11100010b & 11000101b = 11000000b
-11100010b & 11000110b = 11000010b
-11100010b & 11000111b = 11000010b
-11100010b & 11001000b = 11000000b
-11100010b & 11001001b = 11000000b
-11100010b & 11001010b = 11000010b
-11100010b & 11001011b = 11000010b
-11100010b & 11001100b = 11000000b
-11100010b & 11001101b = 11000000b
-11100010b & 11001110b = 11000010b
-11100010b & 11001111b = 11000010b
-11100010b & 11010000b = 11000000b
-11100010b & 11010001b = 11000000b
-11100010b & 11010010b = 11000010b
-11100010b & 11010011b = 11000010b
-11100010b & 11010100b = 11000000b
-11100010b & 11010101b = 11000000b
-11100010b & 11010110b = 11000010b
-11100010b & 11010111b = 11000010b
-11100010b & 11011000b = 11000000b
-11100010b & 11011001b = 11000000b
-11100010b & 11011010b = 11000010b
-11100010b & 11011011b = 11000010b
-11100010b & 11011100b = 11000000b
-11100010b & 11011101b = 11000000b
-11100010b & 11011110b = 11000010b
-11100010b & 11011111b = 11000010b
-11100010b & 11100000b = 11100000b
-11100010b & 11100001b = 11100000b
-11100010b & 11100010b = 11100010b
-11100010b & 11100011b = 11100010b
-11100010b & 11100100b = 11100000b
-11100010b & 11100101b = 11100000b
-11100010b & 11100110b = 11100010b
-11100010b & 11100111b = 11100010b
-11100010b & 11101000b = 11100000b
-11100010b & 11101001b = 11100000b
-11100010b & 11101010b = 11100010b
-11100010b & 11101011b = 11100010b
-11100010b & 11101100b = 11100000b
-11100010b & 11101101b = 11100000b
-11100010b & 11101110b = 11100010b
-11100010b & 11101111b = 11100010b
-11100010b & 11110000b = 11100000b
-11100010b & 11110001b = 11100000b
-11100010b & 11110010b = 11100010b
-11100010b & 11110011b = 11100010b
-11100010b & 11110100b = 11100000b
-11100010b & 11110101b = 11100000b
-11100010b & 11110110b = 11100010b
-11100010b & 11110111b = 11100010b
-11100010b & 11111000b = 11100000b
-11100010b & 11111001b = 11100000b
-11100010b & 11111010b = 11100010b
-11100010b & 11111011b = 11100010b
-11100010b & 11111100b = 11100000b
-11100010b & 11111101b = 11100000b
-11100010b & 11111110b = 11100010b
-11100010b & 11111111b = 11100010b
-11100010b & 00000000b = 00000000b
-11100010b & 00000001b = 00000000b
-11100010b & 00000010b = 00000010b
-11100010b & 00000011b = 00000010b
-11100010b & 00000100b = 00000000b
-11100010b & 00000101b = 00000000b
-11100010b & 00000110b = 00000010b
-11100010b & 00000111b = 00000010b
-11100010b & 00001000b = 00000000b
-11100010b & 00001001b = 00000000b
-11100010b & 00001010b = 00000010b
-11100010b & 00001011b = 00000010b
-11100010b & 00001100b = 00000000b
-11100010b & 00001101b = 00000000b
-11100010b & 00001110b = 00000010b
-11100010b & 00001111b = 00000010b
-11100010b & 00010000b = 00000000b
-11100010b & 00010001b = 00000000b
-11100010b & 00010010b = 00000010b
-11100010b & 00010011b = 00000010b
-11100010b & 00010100b = 00000000b
-11100010b & 00010101b = 00000000b
-11100010b & 00010110b = 00000010b
-11100010b & 00010111b = 00000010b
-11100010b & 00011000b = 00000000b
-11100010b & 00011001b = 00000000b
-11100010b & 00011010b = 00000010b
-11100010b & 00011011b = 00000010b
-11100010b & 00011100b = 00000000b
-11100010b & 00011101b = 00000000b
-11100010b & 00011110b = 00000010b
-11100010b & 00011111b = 00000010b
-11100010b & 00100000b = 00100000b
-11100010b & 00100001b = 00100000b
-11100010b & 00100010b = 00100010b
-11100010b & 00100011b = 00100010b
-11100010b & 00100100b = 00100000b
-11100010b & 00100101b = 00100000b
-11100010b & 00100110b = 00100010b
-11100010b & 00100111b = 00100010b
-11100010b & 00101000b = 00100000b
-11100010b & 00101001b = 00100000b
-11100010b & 00101010b = 00100010b
-11100010b & 00101011b = 00100010b
-11100010b & 00101100b = 00100000b
-11100010b & 00101101b = 00100000b
-11100010b & 00101110b = 00100010b
-11100010b & 00101111b = 00100010b
-11100010b & 00110000b = 00100000b
-11100010b & 00110001b = 00100000b
-11100010b & 00110010b = 00100010b
-11100010b & 00110011b = 00100010b
-11100010b & 00110100b = 00100000b
-11100010b & 00110101b = 00100000b
-11100010b & 00110110b = 00100010b
-11100010b & 00110111b = 00100010b
-11100010b & 00111000b = 00100000b
-11100010b & 00111001b = 00100000b
-11100010b & 00111010b = 00100010b
-11100010b & 00111011b = 00100010b
-11100010b & 00111100b = 00100000b
-11100010b & 00111101b = 00100000b
-11100010b & 00111110b = 00100010b
-11100010b & 00111111b = 00100010b
-11100010b & 01000000b = 01000000b
-11100010b & 01000001b = 01000000b
-11100010b & 01000010b = 01000010b
-11100010b & 01000011b = 01000010b
-11100010b & 01000100b = 01000000b
-11100010b & 01000101b = 01000000b
-11100010b & 01000110b = 01000010b
-11100010b & 01000111b = 01000010b
-11100010b & 01001000b = 01000000b
-11100010b & 01001001b = 01000000b
-11100010b & 01001010b = 01000010b
-11100010b & 01001011b = 01000010b
-11100010b & 01001100b = 01000000b
-11100010b & 01001101b = 01000000b
-11100010b & 01001110b = 01000010b
-11100010b & 01001111b = 01000010b
-11100010b & 01010000b = 01000000b
-11100010b & 01010001b = 01000000b
-11100010b & 01010010b = 01000010b
-11100010b & 01010011b = 01000010b
-11100010b & 01010100b = 01000000b
-11100010b & 01010101b = 01000000b
-11100010b & 01010110b = 01000010b
-11100010b & 01010111b = 01000010b
-11100010b & 01011000b = 01000000b
-11100010b & 01011001b = 01000000b
-11100010b & 01011010b = 01000010b
-11100010b & 01011011b = 01000010b
-11100010b & 01011100b = 01000000b
-11100010b & 01011101b = 01000000b
-11100010b & 01011110b = 01000010b
-11100010b & 01011111b = 01000010b
-11100010b & 01100000b = 01100000b
-11100010b & 01100001b = 01100000b
-11100010b & 01100010b = 01100010b
-11100010b & 01100011b = 01100010b
-11100010b & 01100100b = 01100000b
-11100010b & 01100101b = 01100000b
-11100010b & 01100110b = 01100010b
-11100010b & 01100111b = 01100010b
-11100010b & 01101000b = 01100000b
-11100010b & 01101001b = 01100000b
-11100010b & 01101010b = 01100010b
-11100010b & 01101011b = 01100010b
-11100010b & 01101100b = 01100000b
-11100010b & 01101101b = 01100000b
-11100010b & 01101110b = 01100010b
-11100010b & 01101111b = 01100010b
-11100010b & 01110000b = 01100000b
-11100010b & 01110001b = 01100000b
-11100010b & 01110010b = 01100010b
-11100010b & 01110011b = 01100010b
-11100010b & 01110100b = 01100000b
-11100010b & 01110101b = 01100000b
-11100010b & 01110110b = 01100010b
-11100010b & 01110111b = 01100010b
-11100010b & 01111000b = 01100000b
-11100010b & 01111001b = 01100000b
-11100010b & 01111010b = 01100010b
-11100010b & 01111011b = 01100010b
-11100010b & 01111100b = 01100000b
-11100010b & 01111101b = 01100000b
-11100010b & 01111110b = 01100010b
-11100011b & 10000000b = 10000000b
-11100011b & 10000001b = 10000001b
-11100011b & 10000010b = 10000010b
-11100011b & 10000011b = 10000011b
-11100011b & 10000100b = 10000000b
-11100011b & 10000101b = 10000001b
-11100011b & 10000110b = 10000010b
-11100011b & 10000111b = 10000011b
-11100011b & 10001000b = 10000000b
-11100011b & 10001001b = 10000001b
-11100011b & 10001010b = 10000010b
-11100011b & 10001011b = 10000011b
-11100011b & 10001100b = 10000000b
-11100011b & 10001101b = 10000001b
-11100011b & 10001110b = 10000010b
-11100011b & 10001111b = 10000011b
-11100011b & 10010000b = 10000000b
-11100011b & 10010001b = 10000001b
-11100011b & 10010010b = 10000010b
-11100011b & 10010011b = 10000011b
-11100011b & 10010100b = 10000000b
-11100011b & 10010101b = 10000001b
-11100011b & 10010110b = 10000010b
-11100011b & 10010111b = 10000011b
-11100011b & 10011000b = 10000000b
-11100011b & 10011001b = 10000001b
-11100011b & 10011010b = 10000010b
-11100011b & 10011011b = 10000011b
-11100011b & 10011100b = 10000000b
-11100011b & 10011101b = 10000001b
-11100011b & 10011110b = 10000010b
-11100011b & 10011111b = 10000011b
-11100011b & 10100000b = 10100000b
-11100011b & 10100001b = 10100001b
-11100011b & 10100010b = 10100010b
-11100011b & 10100011b = 10100011b
-11100011b & 10100100b = 10100000b
-11100011b & 10100101b = 10100001b
-11100011b & 10100110b = 10100010b
-11100011b & 10100111b = 10100011b
-11100011b & 10101000b = 10100000b
-11100011b & 10101001b = 10100001b
-11100011b & 10101010b = 10100010b
-11100011b & 10101011b = 10100011b
-11100011b & 10101100b = 10100000b
-11100011b & 10101101b = 10100001b
-11100011b & 10101110b = 10100010b
-11100011b & 10101111b = 10100011b
-11100011b & 10110000b = 10100000b
-11100011b & 10110001b = 10100001b
-11100011b & 10110010b = 10100010b
-11100011b & 10110011b = 10100011b
-11100011b & 10110100b = 10100000b
-11100011b & 10110101b = 10100001b
-11100011b & 10110110b = 10100010b
-11100011b & 10110111b = 10100011b
-11100011b & 10111000b = 10100000b
-11100011b & 10111001b = 10100001b
-11100011b & 10111010b = 10100010b
-11100011b & 10111011b = 10100011b
-11100011b & 10111100b = 10100000b
-11100011b & 10111101b = 10100001b
-11100011b & 10111110b = 10100010b
-11100011b & 10111111b = 10100011b
-11100011b & 11000000b = 11000000b
-11100011b & 11000001b = 11000001b
-11100011b & 11000010b = 11000010b
-11100011b & 11000011b = 11000011b
-11100011b & 11000100b = 11000000b
-11100011b & 11000101b = 11000001b
-11100011b & 11000110b = 11000010b
-11100011b & 11000111b = 11000011b
-11100011b & 11001000b = 11000000b
-11100011b & 11001001b = 11000001b
-11100011b & 11001010b = 11000010b
-11100011b & 11001011b = 11000011b
-11100011b & 11001100b = 11000000b
-11100011b & 11001101b = 11000001b
-11100011b & 11001110b = 11000010b
-11100011b & 11001111b = 11000011b
-11100011b & 11010000b = 11000000b
-11100011b & 11010001b = 11000001b
-11100011b & 11010010b = 11000010b
-11100011b & 11010011b = 11000011b
-11100011b & 11010100b = 11000000b
-11100011b & 11010101b = 11000001b
-11100011b & 11010110b = 11000010b
-11100011b & 11010111b = 11000011b
-11100011b & 11011000b = 11000000b
-11100011b & 11011001b = 11000001b
-11100011b & 11011010b = 11000010b
-11100011b & 11011011b = 11000011b
-11100011b & 11011100b = 11000000b
-11100011b & 11011101b = 11000001b
-11100011b & 11011110b = 11000010b
-11100011b & 11011111b = 11000011b
-11100011b & 11100000b = 11100000b
-11100011b & 11100001b = 11100001b
-11100011b & 11100010b = 11100010b
-11100011b & 11100011b = 11100011b
-11100011b & 11100100b = 11100000b
-11100011b & 11100101b = 11100001b
-11100011b & 11100110b = 11100010b
-11100011b & 11100111b = 11100011b
-11100011b & 11101000b = 11100000b
-11100011b & 11101001b = 11100001b
-11100011b & 11101010b = 11100010b
-11100011b & 11101011b = 11100011b
-11100011b & 11101100b = 11100000b
-11100011b & 11101101b = 11100001b
-11100011b & 11101110b = 11100010b
-11100011b & 11101111b = 11100011b
-11100011b & 11110000b = 11100000b
-11100011b & 11110001b = 11100001b
-11100011b & 11110010b = 11100010b
-11100011b & 11110011b = 11100011b
-11100011b & 11110100b = 11100000b
-11100011b & 11110101b = 11100001b
-11100011b & 11110110b = 11100010b
-11100011b & 11110111b = 11100011b
-11100011b & 11111000b = 11100000b
-11100011b & 11111001b = 11100001b
-11100011b & 11111010b = 11100010b
-11100011b & 11111011b = 11100011b
-11100011b & 11111100b = 11100000b
-11100011b & 11111101b = 11100001b
-11100011b & 11111110b = 11100010b
-11100011b & 11111111b = 11100011b
-11100011b & 00000000b = 00000000b
-11100011b & 00000001b = 00000001b
-11100011b & 00000010b = 00000010b
-11100011b & 00000011b = 00000011b
-11100011b & 00000100b = 00000000b
-11100011b & 00000101b = 00000001b
-11100011b & 00000110b = 00000010b
-11100011b & 00000111b = 00000011b
-11100011b & 00001000b = 00000000b
-11100011b & 00001001b = 00000001b
-11100011b & 00001010b = 00000010b
-11100011b & 00001011b = 00000011b
-11100011b & 00001100b = 00000000b
-11100011b & 00001101b = 00000001b
-11100011b & 00001110b = 00000010b
-11100011b & 00001111b = 00000011b
-11100011b & 00010000b = 00000000b
-11100011b & 00010001b = 00000001b
-11100011b & 00010010b = 00000010b
-11100011b & 00010011b = 00000011b
-11100011b & 00010100b = 00000000b
-11100011b & 00010101b = 00000001b
-11100011b & 00010110b = 00000010b
-11100011b & 00010111b = 00000011b
-11100011b & 00011000b = 00000000b
-11100011b & 00011001b = 00000001b
-11100011b & 00011010b = 00000010b
-11100011b & 00011011b = 00000011b
-11100011b & 00011100b = 00000000b
-11100011b & 00011101b = 00000001b
-11100011b & 00011110b = 00000010b
-11100011b & 00011111b = 00000011b
-11100011b & 00100000b = 00100000b
-11100011b & 00100001b = 00100001b
-11100011b & 00100010b = 00100010b
-11100011b & 00100011b = 00100011b
-11100011b & 00100100b = 00100000b
-11100011b & 00100101b = 00100001b
-11100011b & 00100110b = 00100010b
-11100011b & 00100111b = 00100011b
-11100011b & 00101000b = 00100000b
-11100011b & 00101001b = 00100001b
-11100011b & 00101010b = 00100010b
-11100011b & 00101011b = 00100011b
-11100011b & 00101100b = 00100000b
-11100011b & 00101101b = 00100001b
-11100011b & 00101110b = 00100010b
-11100011b & 00101111b = 00100011b
-11100011b & 00110000b = 00100000b
-11100011b & 00110001b = 00100001b
-11100011b & 00110010b = 00100010b
-11100011b & 00110011b = 00100011b
-11100011b & 00110100b = 00100000b
-11100011b & 00110101b = 00100001b
-11100011b & 00110110b = 00100010b
-11100011b & 00110111b = 00100011b
-11100011b & 00111000b = 00100000b
-11100011b & 00111001b = 00100001b
-11100011b & 00111010b = 00100010b
-11100011b & 00111011b = 00100011b
-11100011b & 00111100b = 00100000b
-11100011b & 00111101b = 00100001b
-11100011b & 00111110b = 00100010b
-11100011b & 00111111b = 00100011b
-11100011b & 01000000b = 01000000b
-11100011b & 01000001b = 01000001b
-11100011b & 01000010b = 01000010b
-11100011b & 01000011b = 01000011b
-11100011b & 01000100b = 01000000b
-11100011b & 01000101b = 01000001b
-11100011b & 01000110b = 01000010b
-11100011b & 01000111b = 01000011b
-11100011b & 01001000b = 01000000b
-11100011b & 01001001b = 01000001b
-11100011b & 01001010b = 01000010b
-11100011b & 01001011b = 01000011b
-11100011b & 01001100b = 01000000b
-11100011b & 01001101b = 01000001b
-11100011b & 01001110b = 01000010b
-11100011b & 01001111b = 01000011b
-11100011b & 01010000b = 01000000b
-11100011b & 01010001b = 01000001b
-11100011b & 01010010b = 01000010b
-11100011b & 01010011b = 01000011b
-11100011b & 01010100b = 01000000b
-11100011b & 01010101b = 01000001b
-11100011b & 01010110b = 01000010b
-11100011b & 01010111b = 01000011b
-11100011b & 01011000b = 01000000b
-11100011b & 01011001b = 01000001b
-11100011b & 01011010b = 01000010b
-11100011b & 01011011b = 01000011b
-11100011b & 01011100b = 01000000b
-11100011b & 01011101b = 01000001b
-11100011b & 01011110b = 01000010b
-11100011b & 01011111b = 01000011b
-11100011b & 01100000b = 01100000b
-11100011b & 01100001b = 01100001b
-11100011b & 01100010b = 01100010b
-11100011b & 01100011b = 01100011b
-11100011b & 01100100b = 01100000b
-11100011b & 01100101b = 01100001b
-11100011b & 01100110b = 01100010b
-11100011b & 01100111b = 01100011b
-11100011b & 01101000b = 01100000b
-11100011b & 01101001b = 01100001b
-11100011b & 01101010b = 01100010b
-11100011b & 01101011b = 01100011b
-11100011b & 01101100b = 01100000b
-11100011b & 01101101b = 01100001b
-11100011b & 01101110b = 01100010b
-11100011b & 01101111b = 01100011b
-11100011b & 01110000b = 01100000b
-11100011b & 01110001b = 01100001b
-11100011b & 01110010b = 01100010b
-11100011b & 01110011b = 01100011b
-11100011b & 01110100b = 01100000b
-11100011b & 01110101b = 01100001b
-11100011b & 01110110b = 01100010b
-11100011b & 01110111b = 01100011b
-11100011b & 01111000b = 01100000b
-11100011b & 01111001b = 01100001b
-11100011b & 01111010b = 01100010b
-11100011b & 01111011b = 01100011b
-11100011b & 01111100b = 01100000b
-11100011b & 01111101b = 01100001b
-11100011b & 01111110b = 01100010b
-11100100b & 10000000b = 10000000b
-11100100b & 10000001b = 10000000b
-11100100b & 10000010b = 10000000b
-11100100b & 10000011b = 10000000b
-11100100b & 10000100b = 10000100b
-11100100b & 10000101b = 10000100b
-11100100b & 10000110b = 10000100b
-11100100b & 10000111b = 10000100b
-11100100b & 10001000b = 10000000b
-11100100b & 10001001b = 10000000b
-11100100b & 10001010b = 10000000b
-11100100b & 10001011b = 10000000b
-11100100b & 10001100b = 10000100b
-11100100b & 10001101b = 10000100b
-11100100b & 10001110b = 10000100b
-11100100b & 10001111b = 10000100b
-11100100b & 10010000b = 10000000b
-11100100b & 10010001b = 10000000b
-11100100b & 10010010b = 10000000b
-11100100b & 10010011b = 10000000b
-11100100b & 10010100b = 10000100b
-11100100b & 10010101b = 10000100b
-11100100b & 10010110b = 10000100b
-11100100b & 10010111b = 10000100b
-11100100b & 10011000b = 10000000b
-11100100b & 10011001b = 10000000b
-11100100b & 10011010b = 10000000b
-11100100b & 10011011b = 10000000b
-11100100b & 10011100b = 10000100b
-11100100b & 10011101b = 10000100b
-11100100b & 10011110b = 10000100b
-11100100b & 10011111b = 10000100b
-11100100b & 10100000b = 10100000b
-11100100b & 10100001b = 10100000b
-11100100b & 10100010b = 10100000b
-11100100b & 10100011b = 10100000b
-11100100b & 10100100b = 10100100b
-11100100b & 10100101b = 10100100b
-11100100b & 10100110b = 10100100b
-11100100b & 10100111b = 10100100b
-11100100b & 10101000b = 10100000b
-11100100b & 10101001b = 10100000b
-11100100b & 10101010b = 10100000b
-11100100b & 10101011b = 10100000b
-11100100b & 10101100b = 10100100b
-11100100b & 10101101b = 10100100b
-11100100b & 10101110b = 10100100b
-11100100b & 10101111b = 10100100b
-11100100b & 10110000b = 10100000b
-11100100b & 10110001b = 10100000b
-11100100b & 10110010b = 10100000b
-11100100b & 10110011b = 10100000b
-11100100b & 10110100b = 10100100b
-11100100b & 10110101b = 10100100b
-11100100b & 10110110b = 10100100b
-11100100b & 10110111b = 10100100b
-11100100b & 10111000b = 10100000b
-11100100b & 10111001b = 10100000b
-11100100b & 10111010b = 10100000b
-11100100b & 10111011b = 10100000b
-11100100b & 10111100b = 10100100b
-11100100b & 10111101b = 10100100b
-11100100b & 10111110b = 10100100b
-11100100b & 10111111b = 10100100b
-11100100b & 11000000b = 11000000b
-11100100b & 11000001b = 11000000b
-11100100b & 11000010b = 11000000b
-11100100b & 11000011b = 11000000b
-11100100b & 11000100b = 11000100b
-11100100b & 11000101b = 11000100b
-11100100b & 11000110b = 11000100b
-11100100b & 11000111b = 11000100b
-11100100b & 11001000b = 11000000b
-11100100b & 11001001b = 11000000b
-11100100b & 11001010b = 11000000b
-11100100b & 11001011b = 11000000b
-11100100b & 11001100b = 11000100b
-11100100b & 11001101b = 11000100b
-11100100b & 11001110b = 11000100b
-11100100b & 11001111b = 11000100b
-11100100b & 11010000b = 11000000b
-11100100b & 11010001b = 11000000b
-11100100b & 11010010b = 11000000b
-11100100b & 11010011b = 11000000b
-11100100b & 11010100b = 11000100b
-11100100b & 11010101b = 11000100b
-11100100b & 11010110b = 11000100b
-11100100b & 11010111b = 11000100b
-11100100b & 11011000b = 11000000b
-11100100b & 11011001b = 11000000b
-11100100b & 11011010b = 11000000b
-11100100b & 11011011b = 11000000b
-11100100b & 11011100b = 11000100b
-11100100b & 11011101b = 11000100b
-11100100b & 11011110b = 11000100b
-11100100b & 11011111b = 11000100b
-11100100b & 11100000b = 11100000b
-11100100b & 11100001b = 11100000b
-11100100b & 11100010b = 11100000b
-11100100b & 11100011b = 11100000b
-11100100b & 11100100b = 11100100b
-11100100b & 11100101b = 11100100b
-11100100b & 11100110b = 11100100b
-11100100b & 11100111b = 11100100b
-11100100b & 11101000b = 11100000b
-11100100b & 11101001b = 11100000b
-11100100b & 11101010b = 11100000b
-11100100b & 11101011b = 11100000b
-11100100b & 11101100b = 11100100b
-11100100b & 11101101b = 11100100b
-11100100b & 11101110b = 11100100b
-11100100b & 11101111b = 11100100b
-11100100b & 11110000b = 11100000b
-11100100b & 11110001b = 11100000b
-11100100b & 11110010b = 11100000b
-11100100b & 11110011b = 11100000b
-11100100b & 11110100b = 11100100b
-11100100b & 11110101b = 11100100b
-11100100b & 11110110b = 11100100b
-11100100b & 11110111b = 11100100b
-11100100b & 11111000b = 11100000b
-11100100b & 11111001b = 11100000b
-11100100b & 11111010b = 11100000b
-11100100b & 11111011b = 11100000b
-11100100b & 11111100b = 11100100b
-11100100b & 11111101b = 11100100b
-11100100b & 11111110b = 11100100b
-11100100b & 11111111b = 11100100b
-11100100b & 00000000b = 00000000b
-11100100b & 00000001b = 00000000b
-11100100b & 00000010b = 00000000b
-11100100b & 00000011b = 00000000b
-11100100b & 00000100b = 00000100b
-11100100b & 00000101b = 00000100b
-11100100b & 00000110b = 00000100b
-11100100b & 00000111b = 00000100b
-11100100b & 00001000b = 00000000b
-11100100b & 00001001b = 00000000b
-11100100b & 00001010b = 00000000b
-11100100b & 00001011b = 00000000b
-11100100b & 00001100b = 00000100b
-11100100b & 00001101b = 00000100b
-11100100b & 00001110b = 00000100b
-11100100b & 00001111b = 00000100b
-11100100b & 00010000b = 00000000b
-11100100b & 00010001b = 00000000b
-11100100b & 00010010b = 00000000b
-11100100b & 00010011b = 00000000b
-11100100b & 00010100b = 00000100b
-11100100b & 00010101b = 00000100b
-11100100b & 00010110b = 00000100b
-11100100b & 00010111b = 00000100b
-11100100b & 00011000b = 00000000b
-11100100b & 00011001b = 00000000b
-11100100b & 00011010b = 00000000b
-11100100b & 00011011b = 00000000b
-11100100b & 00011100b = 00000100b
-11100100b & 00011101b = 00000100b
-11100100b & 00011110b = 00000100b
-11100100b & 00011111b = 00000100b
-11100100b & 00100000b = 00100000b
-11100100b & 00100001b = 00100000b
-11100100b & 00100010b = 00100000b
-11100100b & 00100011b = 00100000b
-11100100b & 00100100b = 00100100b
-11100100b & 00100101b = 00100100b
-11100100b & 00100110b = 00100100b
-11100100b & 00100111b = 00100100b
-11100100b & 00101000b = 00100000b
-11100100b & 00101001b = 00100000b
-11100100b & 00101010b = 00100000b
-11100100b & 00101011b = 00100000b
-11100100b & 00101100b = 00100100b
-11100100b & 00101101b = 00100100b
-11100100b & 00101110b = 00100100b
-11100100b & 00101111b = 00100100b
-11100100b & 00110000b = 00100000b
-11100100b & 00110001b = 00100000b
-11100100b & 00110010b = 00100000b
-11100100b & 00110011b = 00100000b
-11100100b & 00110100b = 00100100b
-11100100b & 00110101b = 00100100b
-11100100b & 00110110b = 00100100b
-11100100b & 00110111b = 00100100b
-11100100b & 00111000b = 00100000b
-11100100b & 00111001b = 00100000b
-11100100b & 00111010b = 00100000b
-11100100b & 00111011b = 00100000b
-11100100b & 00111100b = 00100100b
-11100100b & 00111101b = 00100100b
-11100100b & 00111110b = 00100100b
-11100100b & 00111111b = 00100100b
-11100100b & 01000000b = 01000000b
-11100100b & 01000001b = 01000000b
-11100100b & 01000010b = 01000000b
-11100100b & 01000011b = 01000000b
-11100100b & 01000100b = 01000100b
-11100100b & 01000101b = 01000100b
-11100100b & 01000110b = 01000100b
-11100100b & 01000111b = 01000100b
-11100100b & 01001000b = 01000000b
-11100100b & 01001001b = 01000000b
-11100100b & 01001010b = 01000000b
-11100100b & 01001011b = 01000000b
-11100100b & 01001100b = 01000100b
-11100100b & 01001101b = 01000100b
-11100100b & 01001110b = 01000100b
-11100100b & 01001111b = 01000100b
-11100100b & 01010000b = 01000000b
-11100100b & 01010001b = 01000000b
-11100100b & 01010010b = 01000000b
-11100100b & 01010011b = 01000000b
-11100100b & 01010100b = 01000100b
-11100100b & 01010101b = 01000100b
-11100100b & 01010110b = 01000100b
-11100100b & 01010111b = 01000100b
-11100100b & 01011000b = 01000000b
-11100100b & 01011001b = 01000000b
-11100100b & 01011010b = 01000000b
-11100100b & 01011011b = 01000000b
-11100100b & 01011100b = 01000100b
-11100100b & 01011101b = 01000100b
-11100100b & 01011110b = 01000100b
-11100100b & 01011111b = 01000100b
-11100100b & 01100000b = 01100000b
-11100100b & 01100001b = 01100000b
-11100100b & 01100010b = 01100000b
-11100100b & 01100011b = 01100000b
-11100100b & 01100100b = 01100100b
-11100100b & 01100101b = 01100100b
-11100100b & 01100110b = 01100100b
-11100100b & 01100111b = 01100100b
-11100100b & 01101000b = 01100000b
-11100100b & 01101001b = 01100000b
-11100100b & 01101010b = 01100000b
-11100100b & 01101011b = 01100000b
-11100100b & 01101100b = 01100100b
-11100100b & 01101101b = 01100100b
-11100100b & 01101110b = 01100100b
-11100100b & 01101111b = 01100100b
-11100100b & 01110000b = 01100000b
-11100100b & 01110001b = 01100000b
-11100100b & 01110010b = 01100000b
-11100100b & 01110011b = 01100000b
-11100100b & 01110100b = 01100100b
-11100100b & 01110101b = 01100100b
-11100100b & 01110110b = 01100100b
-11100100b & 01110111b = 01100100b
-11100100b & 01111000b = 01100000b
-11100100b & 01111001b = 01100000b
-11100100b & 01111010b = 01100000b
-11100100b & 01111011b = 01100000b
-11100100b & 01111100b = 01100100b
-11100100b & 01111101b = 01100100b
-11100100b & 01111110b = 01100100b
-11100101b & 10000000b = 10000000b
-11100101b & 10000001b = 10000001b
-11100101b & 10000010b = 10000000b
-11100101b & 10000011b = 10000001b
-11100101b & 10000100b = 10000100b
-11100101b & 10000101b = 10000101b
-11100101b & 10000110b = 10000100b
-11100101b & 10000111b = 10000101b
-11100101b & 10001000b = 10000000b
-11100101b & 10001001b = 10000001b
-11100101b & 10001010b = 10000000b
-11100101b & 10001011b = 10000001b
-11100101b & 10001100b = 10000100b
-11100101b & 10001101b = 10000101b
-11100101b & 10001110b = 10000100b
-11100101b & 10001111b = 10000101b
-11100101b & 10010000b = 10000000b
-11100101b & 10010001b = 10000001b
-11100101b & 10010010b = 10000000b
-11100101b & 10010011b = 10000001b
-11100101b & 10010100b = 10000100b
-11100101b & 10010101b = 10000101b
-11100101b & 10010110b = 10000100b
-11100101b & 10010111b = 10000101b
-11100101b & 10011000b = 10000000b
-11100101b & 10011001b = 10000001b
-11100101b & 10011010b = 10000000b
-11100101b & 10011011b = 10000001b
-11100101b & 10011100b = 10000100b
-11100101b & 10011101b = 10000101b
-11100101b & 10011110b = 10000100b
-11100101b & 10011111b = 10000101b
-11100101b & 10100000b = 10100000b
-11100101b & 10100001b = 10100001b
-11100101b & 10100010b = 10100000b
-11100101b & 10100011b = 10100001b
-11100101b & 10100100b = 10100100b
-11100101b & 10100101b = 10100101b
-11100101b & 10100110b = 10100100b
-11100101b & 10100111b = 10100101b
-11100101b & 10101000b = 10100000b
-11100101b & 10101001b = 10100001b
-11100101b & 10101010b = 10100000b
-11100101b & 10101011b = 10100001b
-11100101b & 10101100b = 10100100b
-11100101b & 10101101b = 10100101b
-11100101b & 10101110b = 10100100b
-11100101b & 10101111b = 10100101b
-11100101b & 10110000b = 10100000b
-11100101b & 10110001b = 10100001b
-11100101b & 10110010b = 10100000b
-11100101b & 10110011b = 10100001b
-11100101b & 10110100b = 10100100b
-11100101b & 10110101b = 10100101b
-11100101b & 10110110b = 10100100b
-11100101b & 10110111b = 10100101b
-11100101b & 10111000b = 10100000b
-11100101b & 10111001b = 10100001b
-11100101b & 10111010b = 10100000b
-11100101b & 10111011b = 10100001b
-11100101b & 10111100b = 10100100b
-11100101b & 10111101b = 10100101b
-11100101b & 10111110b = 10100100b
-11100101b & 10111111b = 10100101b
-11100101b & 11000000b = 11000000b
-11100101b & 11000001b = 11000001b
-11100101b & 11000010b = 11000000b
-11100101b & 11000011b = 11000001b
-11100101b & 11000100b = 11000100b
-11100101b & 11000101b = 11000101b
-11100101b & 11000110b = 11000100b
-11100101b & 11000111b = 11000101b
-11100101b & 11001000b = 11000000b
-11100101b & 11001001b = 11000001b
-11100101b & 11001010b = 11000000b
-11100101b & 11001011b = 11000001b
-11100101b & 11001100b = 11000100b
-11100101b & 11001101b = 11000101b
-11100101b & 11001110b = 11000100b
-11100101b & 11001111b = 11000101b
-11100101b & 11010000b = 11000000b
-11100101b & 11010001b = 11000001b
-11100101b & 11010010b = 11000000b
-11100101b & 11010011b = 11000001b
-11100101b & 11010100b = 11000100b
-11100101b & 11010101b = 11000101b
-11100101b & 11010110b = 11000100b
-11100101b & 11010111b = 11000101b
-11100101b & 11011000b = 11000000b
-11100101b & 11011001b = 11000001b
-11100101b & 11011010b = 11000000b
-11100101b & 11011011b = 11000001b
-11100101b & 11011100b = 11000100b
-11100101b & 11011101b = 11000101b
-11100101b & 11011110b = 11000100b
-11100101b & 11011111b = 11000101b
-11100101b & 11100000b = 11100000b
-11100101b & 11100001b = 11100001b
-11100101b & 11100010b = 11100000b
-11100101b & 11100011b = 11100001b
-11100101b & 11100100b = 11100100b
-11100101b & 11100101b = 11100101b
-11100101b & 11100110b = 11100100b
-11100101b & 11100111b = 11100101b
-11100101b & 11101000b = 11100000b
-11100101b & 11101001b = 11100001b
-11100101b & 11101010b = 11100000b
-11100101b & 11101011b = 11100001b
-11100101b & 11101100b = 11100100b
-11100101b & 11101101b = 11100101b
-11100101b & 11101110b = 11100100b
-11100101b & 11101111b = 11100101b
-11100101b & 11110000b = 11100000b
-11100101b & 11110001b = 11100001b
-11100101b & 11110010b = 11100000b
-11100101b & 11110011b = 11100001b
-11100101b & 11110100b = 11100100b
-11100101b & 11110101b = 11100101b
-11100101b & 11110110b = 11100100b
-11100101b & 11110111b = 11100101b
-11100101b & 11111000b = 11100000b
-11100101b & 11111001b = 11100001b
-11100101b & 11111010b = 11100000b
-11100101b & 11111011b = 11100001b
-11100101b & 11111100b = 11100100b
-11100101b & 11111101b = 11100101b
-11100101b & 11111110b = 11100100b
-11100101b & 11111111b = 11100101b
-11100101b & 00000000b = 00000000b
-11100101b & 00000001b = 00000001b
-11100101b & 00000010b = 00000000b
-11100101b & 00000011b = 00000001b
-11100101b & 00000100b = 00000100b
-11100101b & 00000101b = 00000101b
-11100101b & 00000110b = 00000100b
-11100101b & 00000111b = 00000101b
-11100101b & 00001000b = 00000000b
-11100101b & 00001001b = 00000001b
-11100101b & 00001010b = 00000000b
-11100101b & 00001011b = 00000001b
-11100101b & 00001100b = 00000100b
-11100101b & 00001101b = 00000101b
-11100101b & 00001110b = 00000100b
-11100101b & 00001111b = 00000101b
-11100101b & 00010000b = 00000000b
-11100101b & 00010001b = 00000001b
-11100101b & 00010010b = 00000000b
-11100101b & 00010011b = 00000001b
-11100101b & 00010100b = 00000100b
-11100101b & 00010101b = 00000101b
-11100101b & 00010110b = 00000100b
-11100101b & 00010111b = 00000101b
-11100101b & 00011000b = 00000000b
-11100101b & 00011001b = 00000001b
-11100101b & 00011010b = 00000000b
-11100101b & 00011011b = 00000001b
-11100101b & 00011100b = 00000100b
-11100101b & 00011101b = 00000101b
-11100101b & 00011110b = 00000100b
-11100101b & 00011111b = 00000101b
-11100101b & 00100000b = 00100000b
-11100101b & 00100001b = 00100001b
-11100101b & 00100010b = 00100000b
-11100101b & 00100011b = 00100001b
-11100101b & 00100100b = 00100100b
-11100101b & 00100101b = 00100101b
-11100101b & 00100110b = 00100100b
-11100101b & 00100111b = 00100101b
-11100101b & 00101000b = 00100000b
-11100101b & 00101001b = 00100001b
-11100101b & 00101010b = 00100000b
-11100101b & 00101011b = 00100001b
-11100101b & 00101100b = 00100100b
-11100101b & 00101101b = 00100101b
-11100101b & 00101110b = 00100100b
-11100101b & 00101111b = 00100101b
-11100101b & 00110000b = 00100000b
-11100101b & 00110001b = 00100001b
-11100101b & 00110010b = 00100000b
-11100101b & 00110011b = 00100001b
-11100101b & 00110100b = 00100100b
-11100101b & 00110101b = 00100101b
-11100101b & 00110110b = 00100100b
-11100101b & 00110111b = 00100101b
-11100101b & 00111000b = 00100000b
-11100101b & 00111001b = 00100001b
-11100101b & 00111010b = 00100000b
-11100101b & 00111011b = 00100001b
-11100101b & 00111100b = 00100100b
-11100101b & 00111101b = 00100101b
-11100101b & 00111110b = 00100100b
-11100101b & 00111111b = 00100101b
-11100101b & 01000000b = 01000000b
-11100101b & 01000001b = 01000001b
-11100101b & 01000010b = 01000000b
-11100101b & 01000011b = 01000001b
-11100101b & 01000100b = 01000100b
-11100101b & 01000101b = 01000101b
-11100101b & 01000110b = 01000100b
-11100101b & 01000111b = 01000101b
-11100101b & 01001000b = 01000000b
-11100101b & 01001001b = 01000001b
-11100101b & 01001010b = 01000000b
-11100101b & 01001011b = 01000001b
-11100101b & 01001100b = 01000100b
-11100101b & 01001101b = 01000101b
-11100101b & 01001110b = 01000100b
-11100101b & 01001111b = 01000101b
-11100101b & 01010000b = 01000000b
-11100101b & 01010001b = 01000001b
-11100101b & 01010010b = 01000000b
-11100101b & 01010011b = 01000001b
-11100101b & 01010100b = 01000100b
-11100101b & 01010101b = 01000101b
-11100101b & 01010110b = 01000100b
-11100101b & 01010111b = 01000101b
-11100101b & 01011000b = 01000000b
-11100101b & 01011001b = 01000001b
-11100101b & 01011010b = 01000000b
-11100101b & 01011011b = 01000001b
-11100101b & 01011100b = 01000100b
-11100101b & 01011101b = 01000101b
-11100101b & 01011110b = 01000100b
-11100101b & 01011111b = 01000101b
-11100101b & 01100000b = 01100000b
-11100101b & 01100001b = 01100001b
-11100101b & 01100010b = 01100000b
-11100101b & 01100011b = 01100001b
-11100101b & 01100100b = 01100100b
-11100101b & 01100101b = 01100101b
-11100101b & 01100110b = 01100100b
-11100101b & 01100111b = 01100101b
-11100101b & 01101000b = 01100000b
-11100101b & 01101001b = 01100001b
-11100101b & 01101010b = 01100000b
-11100101b & 01101011b = 01100001b
-11100101b & 01101100b = 01100100b
-11100101b & 01101101b = 01100101b
-11100101b & 01101110b = 01100100b
-11100101b & 01101111b = 01100101b
-11100101b & 01110000b = 01100000b
-11100101b & 01110001b = 01100001b
-11100101b & 01110010b = 01100000b
-11100101b & 01110011b = 01100001b
-11100101b & 01110100b = 01100100b
-11100101b & 01110101b = 01100101b
-11100101b & 01110110b = 01100100b
-11100101b & 01110111b = 01100101b
-11100101b & 01111000b = 01100000b
-11100101b & 01111001b = 01100001b
-11100101b & 01111010b = 01100000b
-11100101b & 01111011b = 01100001b
-11100101b & 01111100b = 01100100b
-11100101b & 01111101b = 01100101b
-11100101b & 01111110b = 01100100b
-11100110b & 10000000b = 10000000b
-11100110b & 10000001b = 10000000b
-11100110b & 10000010b = 10000010b
-11100110b & 10000011b = 10000010b
-11100110b & 10000100b = 10000100b
-11100110b & 10000101b = 10000100b
-11100110b & 10000110b = 10000110b
-11100110b & 10000111b = 10000110b
-11100110b & 10001000b = 10000000b
-11100110b & 10001001b = 10000000b
-11100110b & 10001010b = 10000010b
-11100110b & 10001011b = 10000010b
-11100110b & 10001100b = 10000100b
-11100110b & 10001101b = 10000100b
-11100110b & 10001110b = 10000110b
-11100110b & 10001111b = 10000110b
-11100110b & 10010000b = 10000000b
-11100110b & 10010001b = 10000000b
-11100110b & 10010010b = 10000010b
-11100110b & 10010011b = 10000010b
-11100110b & 10010100b = 10000100b
-11100110b & 10010101b = 10000100b
-11100110b & 10010110b = 10000110b
-11100110b & 10010111b = 10000110b
-11100110b & 10011000b = 10000000b
-11100110b & 10011001b = 10000000b
-11100110b & 10011010b = 10000010b
-11100110b & 10011011b = 10000010b
-11100110b & 10011100b = 10000100b
-11100110b & 10011101b = 10000100b
-11100110b & 10011110b = 10000110b
-11100110b & 10011111b = 10000110b
-11100110b & 10100000b = 10100000b
-11100110b & 10100001b = 10100000b
-11100110b & 10100010b = 10100010b
-11100110b & 10100011b = 10100010b
-11100110b & 10100100b = 10100100b
-11100110b & 10100101b = 10100100b
-11100110b & 10100110b = 10100110b
-11100110b & 10100111b = 10100110b
-11100110b & 10101000b = 10100000b
-11100110b & 10101001b = 10100000b
-11100110b & 10101010b = 10100010b
-11100110b & 10101011b = 10100010b
-11100110b & 10101100b = 10100100b
-11100110b & 10101101b = 10100100b
-11100110b & 10101110b = 10100110b
-11100110b & 10101111b = 10100110b
-11100110b & 10110000b = 10100000b
-11100110b & 10110001b = 10100000b
-11100110b & 10110010b = 10100010b
-11100110b & 10110011b = 10100010b
-11100110b & 10110100b = 10100100b
-11100110b & 10110101b = 10100100b
-11100110b & 10110110b = 10100110b
-11100110b & 10110111b = 10100110b
-11100110b & 10111000b = 10100000b
-11100110b & 10111001b = 10100000b
-11100110b & 10111010b = 10100010b
-11100110b & 10111011b = 10100010b
-11100110b & 10111100b = 10100100b
-11100110b & 10111101b = 10100100b
-11100110b & 10111110b = 10100110b
-11100110b & 10111111b = 10100110b
-11100110b & 11000000b = 11000000b
-11100110b & 11000001b = 11000000b
-11100110b & 11000010b = 11000010b
-11100110b & 11000011b = 11000010b
-11100110b & 11000100b = 11000100b
-11100110b & 11000101b = 11000100b
-11100110b & 11000110b = 11000110b
-11100110b & 11000111b = 11000110b
-11100110b & 11001000b = 11000000b
-11100110b & 11001001b = 11000000b
-11100110b & 11001010b = 11000010b
-11100110b & 11001011b = 11000010b
-11100110b & 11001100b = 11000100b
-11100110b & 11001101b = 11000100b
-11100110b & 11001110b = 11000110b
-11100110b & 11001111b = 11000110b
-11100110b & 11010000b = 11000000b
-11100110b & 11010001b = 11000000b
-11100110b & 11010010b = 11000010b
-11100110b & 11010011b = 11000010b
-11100110b & 11010100b = 11000100b
-11100110b & 11010101b = 11000100b
-11100110b & 11010110b = 11000110b
-11100110b & 11010111b = 11000110b
-11100110b & 11011000b = 11000000b
-11100110b & 11011001b = 11000000b
-11100110b & 11011010b = 11000010b
-11100110b & 11011011b = 11000010b
-11100110b & 11011100b = 11000100b
-11100110b & 11011101b = 11000100b
-11100110b & 11011110b = 11000110b
-11100110b & 11011111b = 11000110b
-11100110b & 11100000b = 11100000b
-11100110b & 11100001b = 11100000b
-11100110b & 11100010b = 11100010b
-11100110b & 11100011b = 11100010b
-11100110b & 11100100b = 11100100b
-11100110b & 11100101b = 11100100b
-11100110b & 11100110b = 11100110b
-11100110b & 11100111b = 11100110b
-11100110b & 11101000b = 11100000b
-11100110b & 11101001b = 11100000b
-11100110b & 11101010b = 11100010b
-11100110b & 11101011b = 11100010b
-11100110b & 11101100b = 11100100b
-11100110b & 11101101b = 11100100b
-11100110b & 11101110b = 11100110b
-11100110b & 11101111b = 11100110b
-11100110b & 11110000b = 11100000b
-11100110b & 11110001b = 11100000b
-11100110b & 11110010b = 11100010b
-11100110b & 11110011b = 11100010b
-11100110b & 11110100b = 11100100b
-11100110b & 11110101b = 11100100b
-11100110b & 11110110b = 11100110b
-11100110b & 11110111b = 11100110b
-11100110b & 11111000b = 11100000b
-11100110b & 11111001b = 11100000b
-11100110b & 11111010b = 11100010b
-11100110b & 11111011b = 11100010b
-11100110b & 11111100b = 11100100b
-11100110b & 11111101b = 11100100b
-11100110b & 11111110b = 11100110b
-11100110b & 11111111b = 11100110b
-11100110b & 00000000b = 00000000b
-11100110b & 00000001b = 00000000b
-11100110b & 00000010b = 00000010b
-11100110b & 00000011b = 00000010b
-11100110b & 00000100b = 00000100b
-11100110b & 00000101b = 00000100b
-11100110b & 00000110b = 00000110b
-11100110b & 00000111b = 00000110b
-11100110b & 00001000b = 00000000b
-11100110b & 00001001b = 00000000b
-11100110b & 00001010b = 00000010b
-11100110b & 00001011b = 00000010b
-11100110b & 00001100b = 00000100b
-11100110b & 00001101b = 00000100b
-11100110b & 00001110b = 00000110b
-11100110b & 00001111b = 00000110b
-11100110b & 00010000b = 00000000b
-11100110b & 00010001b = 00000000b
-11100110b & 00010010b = 00000010b
-11100110b & 00010011b = 00000010b
-11100110b & 00010100b = 00000100b
-11100110b & 00010101b = 00000100b
-11100110b & 00010110b = 00000110b
-11100110b & 00010111b = 00000110b
-11100110b & 00011000b = 00000000b
-11100110b & 00011001b = 00000000b
-11100110b & 00011010b = 00000010b
-11100110b & 00011011b = 00000010b
-11100110b & 00011100b = 00000100b
-11100110b & 00011101b = 00000100b
-11100110b & 00011110b = 00000110b
-11100110b & 00011111b = 00000110b
-11100110b & 00100000b = 00100000b
-11100110b & 00100001b = 00100000b
-11100110b & 00100010b = 00100010b
-11100110b & 00100011b = 00100010b
-11100110b & 00100100b = 00100100b
-11100110b & 00100101b = 00100100b
-11100110b & 00100110b = 00100110b
-11100110b & 00100111b = 00100110b
-11100110b & 00101000b = 00100000b
-11100110b & 00101001b = 00100000b
-11100110b & 00101010b = 00100010b
-11100110b & 00101011b = 00100010b
-11100110b & 00101100b = 00100100b
-11100110b & 00101101b = 00100100b
-11100110b & 00101110b = 00100110b
-11100110b & 00101111b = 00100110b
-11100110b & 00110000b = 00100000b
-11100110b & 00110001b = 00100000b
-11100110b & 00110010b = 00100010b
-11100110b & 00110011b = 00100010b
-11100110b & 00110100b = 00100100b
-11100110b & 00110101b = 00100100b
-11100110b & 00110110b = 00100110b
-11100110b & 00110111b = 00100110b
-11100110b & 00111000b = 00100000b
-11100110b & 00111001b = 00100000b
-11100110b & 00111010b = 00100010b
-11100110b & 00111011b = 00100010b
-11100110b & 00111100b = 00100100b
-11100110b & 00111101b = 00100100b
-11100110b & 00111110b = 00100110b
-11100110b & 00111111b = 00100110b
-11100110b & 01000000b = 01000000b
-11100110b & 01000001b = 01000000b
-11100110b & 01000010b = 01000010b
-11100110b & 01000011b = 01000010b
-11100110b & 01000100b = 01000100b
-11100110b & 01000101b = 01000100b
-11100110b & 01000110b = 01000110b
-11100110b & 01000111b = 01000110b
-11100110b & 01001000b = 01000000b
-11100110b & 01001001b = 01000000b
-11100110b & 01001010b = 01000010b
-11100110b & 01001011b = 01000010b
-11100110b & 01001100b = 01000100b
-11100110b & 01001101b = 01000100b
-11100110b & 01001110b = 01000110b
-11100110b & 01001111b = 01000110b
-11100110b & 01010000b = 01000000b
-11100110b & 01010001b = 01000000b
-11100110b & 01010010b = 01000010b
-11100110b & 01010011b = 01000010b
-11100110b & 01010100b = 01000100b
-11100110b & 01010101b = 01000100b
-11100110b & 01010110b = 01000110b
-11100110b & 01010111b = 01000110b
-11100110b & 01011000b = 01000000b
-11100110b & 01011001b = 01000000b
-11100110b & 01011010b = 01000010b
-11100110b & 01011011b = 01000010b
-11100110b & 01011100b = 01000100b
-11100110b & 01011101b = 01000100b
-11100110b & 01011110b = 01000110b
-11100110b & 01011111b = 01000110b
-11100110b & 01100000b = 01100000b
-11100110b & 01100001b = 01100000b
-11100110b & 01100010b = 01100010b
-11100110b & 01100011b = 01100010b
-11100110b & 01100100b = 01100100b
-11100110b & 01100101b = 01100100b
-11100110b & 01100110b = 01100110b
-11100110b & 01100111b = 01100110b
-11100110b & 01101000b = 01100000b
-11100110b & 01101001b = 01100000b
-11100110b & 01101010b = 01100010b
-11100110b & 01101011b = 01100010b
-11100110b & 01101100b = 01100100b
-11100110b & 01101101b = 01100100b
-11100110b & 01101110b = 01100110b
-11100110b & 01101111b = 01100110b
-11100110b & 01110000b = 01100000b
-11100110b & 01110001b = 01100000b
-11100110b & 01110010b = 01100010b
-11100110b & 01110011b = 01100010b
-11100110b & 01110100b = 01100100b
-11100110b & 01110101b = 01100100b
-11100110b & 01110110b = 01100110b
-11100110b & 01110111b = 01100110b
-11100110b & 01111000b = 01100000b
-11100110b & 01111001b = 01100000b
-11100110b & 01111010b = 01100010b
-11100110b & 01111011b = 01100010b
-11100110b & 01111100b = 01100100b
-11100110b & 01111101b = 01100100b
-11100110b & 01111110b = 01100110b
-11100111b & 10000000b = 10000000b
-11100111b & 10000001b = 10000001b
-11100111b & 10000010b = 10000010b
-11100111b & 10000011b = 10000011b
-11100111b & 10000100b = 10000100b
-11100111b & 10000101b = 10000101b
-11100111b & 10000110b = 10000110b
-11100111b & 10000111b = 10000111b
-11100111b & 10001000b = 10000000b
-11100111b & 10001001b = 10000001b
-11100111b & 10001010b = 10000010b
-11100111b & 10001011b = 10000011b
-11100111b & 10001100b = 10000100b
-11100111b & 10001101b = 10000101b
-11100111b & 10001110b = 10000110b
-11100111b & 10001111b = 10000111b
-11100111b & 10010000b = 10000000b
-11100111b & 10010001b = 10000001b
-11100111b & 10010010b = 10000010b
-11100111b & 10010011b = 10000011b
-11100111b & 10010100b = 10000100b
-11100111b & 10010101b = 10000101b
-11100111b & 10010110b = 10000110b
-11100111b & 10010111b = 10000111b
-11100111b & 10011000b = 10000000b
-11100111b & 10011001b = 10000001b
-11100111b & 10011010b = 10000010b
-11100111b & 10011011b = 10000011b
-11100111b & 10011100b = 10000100b
-11100111b & 10011101b = 10000101b
-11100111b & 10011110b = 10000110b
-11100111b & 10011111b = 10000111b
-11100111b & 10100000b = 10100000b
-11100111b & 10100001b = 10100001b
-11100111b & 10100010b = 10100010b
-11100111b & 10100011b = 10100011b
-11100111b & 10100100b = 10100100b
-11100111b & 10100101b = 10100101b
-11100111b & 10100110b = 10100110b
-11100111b & 10100111b = 10100111b
-11100111b & 10101000b = 10100000b
-11100111b & 10101001b = 10100001b
-11100111b & 10101010b = 10100010b
-11100111b & 10101011b = 10100011b
-11100111b & 10101100b = 10100100b
-11100111b & 10101101b = 10100101b
-11100111b & 10101110b = 10100110b
-11100111b & 10101111b = 10100111b
-11100111b & 10110000b = 10100000b
-11100111b & 10110001b = 10100001b
-11100111b & 10110010b = 10100010b
-11100111b & 10110011b = 10100011b
-11100111b & 10110100b = 10100100b
-11100111b & 10110101b = 10100101b
-11100111b & 10110110b = 10100110b
-11100111b & 10110111b = 10100111b
-11100111b & 10111000b = 10100000b
-11100111b & 10111001b = 10100001b
-11100111b & 10111010b = 10100010b
-11100111b & 10111011b = 10100011b
-11100111b & 10111100b = 10100100b
-11100111b & 10111101b = 10100101b
-11100111b & 10111110b = 10100110b
-11100111b & 10111111b = 10100111b
-11100111b & 11000000b = 11000000b
-11100111b & 11000001b = 11000001b
-11100111b & 11000010b = 11000010b
-11100111b & 11000011b = 11000011b
-11100111b & 11000100b = 11000100b
-11100111b & 11000101b = 11000101b
-11100111b & 11000110b = 11000110b
-11100111b & 11000111b = 11000111b
-11100111b & 11001000b = 11000000b
-11100111b & 11001001b = 11000001b
-11100111b & 11001010b = 11000010b
-11100111b & 11001011b = 11000011b
-11100111b & 11001100b = 11000100b
-11100111b & 11001101b = 11000101b
-11100111b & 11001110b = 11000110b
-11100111b & 11001111b = 11000111b
-11100111b & 11010000b = 11000000b
-11100111b & 11010001b = 11000001b
-11100111b & 11010010b = 11000010b
-11100111b & 11010011b = 11000011b
-11100111b & 11010100b = 11000100b
-11100111b & 11010101b = 11000101b
-11100111b & 11010110b = 11000110b
-11100111b & 11010111b = 11000111b
-11100111b & 11011000b = 11000000b
-11100111b & 11011001b = 11000001b
-11100111b & 11011010b = 11000010b
-11100111b & 11011011b = 11000011b
-11100111b & 11011100b = 11000100b
-11100111b & 11011101b = 11000101b
-11100111b & 11011110b = 11000110b
-11100111b & 11011111b = 11000111b
-11100111b & 11100000b = 11100000b
-11100111b & 11100001b = 11100001b
-11100111b & 11100010b = 11100010b
-11100111b & 11100011b = 11100011b
-11100111b & 11100100b = 11100100b
-11100111b & 11100101b = 11100101b
-11100111b & 11100110b = 11100110b
-11100111b & 11100111b = 11100111b
-11100111b & 11101000b = 11100000b
-11100111b & 11101001b = 11100001b
-11100111b & 11101010b = 11100010b
-11100111b & 11101011b = 11100011b
-11100111b & 11101100b = 11100100b
-11100111b & 11101101b = 11100101b
-11100111b & 11101110b = 11100110b
-11100111b & 11101111b = 11100111b
-11100111b & 11110000b = 11100000b
-11100111b & 11110001b = 11100001b
-11100111b & 11110010b = 11100010b
-11100111b & 11110011b = 11100011b
-11100111b & 11110100b = 11100100b
-11100111b & 11110101b = 11100101b
-11100111b & 11110110b = 11100110b
-11100111b & 11110111b = 11100111b
-11100111b & 11111000b = 11100000b
-11100111b & 11111001b = 11100001b
-11100111b & 11111010b = 11100010b
-11100111b & 11111011b = 11100011b
-11100111b & 11111100b = 11100100b
-11100111b & 11111101b = 11100101b
-11100111b & 11111110b = 11100110b
-11100111b & 11111111b = 11100111b
-11100111b & 00000000b = 00000000b
-11100111b & 00000001b = 00000001b
-11100111b & 00000010b = 00000010b
-11100111b & 00000011b = 00000011b
-11100111b & 00000100b = 00000100b
-11100111b & 00000101b = 00000101b
-11100111b & 00000110b = 00000110b
-11100111b & 00000111b = 00000111b
-11100111b & 00001000b = 00000000b
-11100111b & 00001001b = 00000001b
-11100111b & 00001010b = 00000010b
-11100111b & 00001011b = 00000011b
-11100111b & 00001100b = 00000100b
-11100111b & 00001101b = 00000101b
-11100111b & 00001110b = 00000110b
-11100111b & 00001111b = 00000111b
-11100111b & 00010000b = 00000000b
-11100111b & 00010001b = 00000001b
-11100111b & 00010010b = 00000010b
-11100111b & 00010011b = 00000011b
-11100111b & 00010100b = 00000100b
-11100111b & 00010101b = 00000101b
-11100111b & 00010110b = 00000110b
-11100111b & 00010111b = 00000111b
-11100111b & 00011000b = 00000000b
-11100111b & 00011001b = 00000001b
-11100111b & 00011010b = 00000010b
-11100111b & 00011011b = 00000011b
-11100111b & 00011100b = 00000100b
-11100111b & 00011101b = 00000101b
-11100111b & 00011110b = 00000110b
-11100111b & 00011111b = 00000111b
-11100111b & 00100000b = 00100000b
-11100111b & 00100001b = 00100001b
-11100111b & 00100010b = 00100010b
-11100111b & 00100011b = 00100011b
-11100111b & 00100100b = 00100100b
-11100111b & 00100101b = 00100101b
-11100111b & 00100110b = 00100110b
-11100111b & 00100111b = 00100111b
-11100111b & 00101000b = 00100000b
-11100111b & 00101001b = 00100001b
-11100111b & 00101010b = 00100010b
-11100111b & 00101011b = 00100011b
-11100111b & 00101100b = 00100100b
-11100111b & 00101101b = 00100101b
-11100111b & 00101110b = 00100110b
-11100111b & 00101111b = 00100111b
-11100111b & 00110000b = 00100000b
-11100111b & 00110001b = 00100001b
-11100111b & 00110010b = 00100010b
-11100111b & 00110011b = 00100011b
-11100111b & 00110100b = 00100100b
-11100111b & 00110101b = 00100101b
-11100111b & 00110110b = 00100110b
-11100111b & 00110111b = 00100111b
-11100111b & 00111000b = 00100000b
-11100111b & 00111001b = 00100001b
-11100111b & 00111010b = 00100010b
-11100111b & 00111011b = 00100011b
-11100111b & 00111100b = 00100100b
-11100111b & 00111101b = 00100101b
-11100111b & 00111110b = 00100110b
-11100111b & 00111111b = 00100111b
-11100111b & 01000000b = 01000000b
-11100111b & 01000001b = 01000001b
-11100111b & 01000010b = 01000010b
-11100111b & 01000011b = 01000011b
-11100111b & 01000100b = 01000100b
-11100111b & 01000101b = 01000101b
-11100111b & 01000110b = 01000110b
-11100111b & 01000111b = 01000111b
-11100111b & 01001000b = 01000000b
-11100111b & 01001001b = 01000001b
-11100111b & 01001010b = 01000010b
-11100111b & 01001011b = 01000011b
-11100111b & 01001100b = 01000100b
-11100111b & 01001101b = 01000101b
-11100111b & 01001110b = 01000110b
-11100111b & 01001111b = 01000111b
-11100111b & 01010000b = 01000000b
-11100111b & 01010001b = 01000001b
-11100111b & 01010010b = 01000010b
-11100111b & 01010011b = 01000011b
-11100111b & 01010100b = 01000100b
-11100111b & 01010101b = 01000101b
-11100111b & 01010110b = 01000110b
-11100111b & 01010111b = 01000111b
-11100111b & 01011000b = 01000000b
-11100111b & 01011001b = 01000001b
-11100111b & 01011010b = 01000010b
-11100111b & 01011011b = 01000011b
-11100111b & 01011100b = 01000100b
-11100111b & 01011101b = 01000101b
-11100111b & 01011110b = 01000110b
-11100111b & 01011111b = 01000111b
-11100111b & 01100000b = 01100000b
-11100111b & 01100001b = 01100001b
-11100111b & 01100010b = 01100010b
-11100111b & 01100011b = 01100011b
-11100111b & 01100100b = 01100100b
-11100111b & 01100101b = 01100101b
-11100111b & 01100110b = 01100110b
-11100111b & 01100111b = 01100111b
-11100111b & 01101000b = 01100000b
-11100111b & 01101001b = 01100001b
-11100111b & 01101010b = 01100010b
-11100111b & 01101011b = 01100011b
-11100111b & 01101100b = 01100100b
-11100111b & 01101101b = 01100101b
-11100111b & 01101110b = 01100110b
-11100111b & 01101111b = 01100111b
-11100111b & 01110000b = 01100000b
-11100111b & 01110001b = 01100001b
-11100111b & 01110010b = 01100010b
-11100111b & 01110011b = 01100011b
-11100111b & 01110100b = 01100100b
-11100111b & 01110101b = 01100101b
-11100111b & 01110110b = 01100110b
-11100111b & 01110111b = 01100111b
-11100111b & 01111000b = 01100000b
-11100111b & 01111001b = 01100001b
-11100111b & 01111010b = 01100010b
-11100111b & 01111011b = 01100011b
-11100111b & 01111100b = 01100100b
-11100111b & 01111101b = 01100101b
-11100111b & 01111110b = 01100110b
-11101000b & 10000000b = 10000000b
-11101000b & 10000001b = 10000000b
-11101000b & 10000010b = 10000000b
-11101000b & 10000011b = 10000000b
-11101000b & 10000100b = 10000000b
-11101000b & 10000101b = 10000000b
-11101000b & 10000110b = 10000000b
-11101000b & 10000111b = 10000000b
-11101000b & 10001000b = 10001000b
-11101000b & 10001001b = 10001000b
-11101000b & 10001010b = 10001000b
-11101000b & 10001011b = 10001000b
-11101000b & 10001100b = 10001000b
-11101000b & 10001101b = 10001000b
-11101000b & 10001110b = 10001000b
-11101000b & 10001111b = 10001000b
-11101000b & 10010000b = 10000000b
-11101000b & 10010001b = 10000000b
-11101000b & 10010010b = 10000000b
-11101000b & 10010011b = 10000000b
-11101000b & 10010100b = 10000000b
-11101000b & 10010101b = 10000000b
-11101000b & 10010110b = 10000000b
-11101000b & 10010111b = 10000000b
-11101000b & 10011000b = 10001000b
-11101000b & 10011001b = 10001000b
-11101000b & 10011010b = 10001000b
-11101000b & 10011011b = 10001000b
-11101000b & 10011100b = 10001000b
-11101000b & 10011101b = 10001000b
-11101000b & 10011110b = 10001000b
-11101000b & 10011111b = 10001000b
-11101000b & 10100000b = 10100000b
-11101000b & 10100001b = 10100000b
-11101000b & 10100010b = 10100000b
-11101000b & 10100011b = 10100000b
-11101000b & 10100100b = 10100000b
-11101000b & 10100101b = 10100000b
-11101000b & 10100110b = 10100000b
-11101000b & 10100111b = 10100000b
-11101000b & 10101000b = 10101000b
-11101000b & 10101001b = 10101000b
-11101000b & 10101010b = 10101000b
-11101000b & 10101011b = 10101000b
-11101000b & 10101100b = 10101000b
-11101000b & 10101101b = 10101000b
-11101000b & 10101110b = 10101000b
-11101000b & 10101111b = 10101000b
-11101000b & 10110000b = 10100000b
-11101000b & 10110001b = 10100000b
-11101000b & 10110010b = 10100000b
-11101000b & 10110011b = 10100000b
-11101000b & 10110100b = 10100000b
-11101000b & 10110101b = 10100000b
-11101000b & 10110110b = 10100000b
-11101000b & 10110111b = 10100000b
-11101000b & 10111000b = 10101000b
-11101000b & 10111001b = 10101000b
-11101000b & 10111010b = 10101000b
-11101000b & 10111011b = 10101000b
-11101000b & 10111100b = 10101000b
-11101000b & 10111101b = 10101000b
-11101000b & 10111110b = 10101000b
-11101000b & 10111111b = 10101000b
-11101000b & 11000000b = 11000000b
-11101000b & 11000001b = 11000000b
-11101000b & 11000010b = 11000000b
-11101000b & 11000011b = 11000000b
-11101000b & 11000100b = 11000000b
-11101000b & 11000101b = 11000000b
-11101000b & 11000110b = 11000000b
-11101000b & 11000111b = 11000000b
-11101000b & 11001000b = 11001000b
-11101000b & 11001001b = 11001000b
-11101000b & 11001010b = 11001000b
-11101000b & 11001011b = 11001000b
-11101000b & 11001100b = 11001000b
-11101000b & 11001101b = 11001000b
-11101000b & 11001110b = 11001000b
-11101000b & 11001111b = 11001000b
-11101000b & 11010000b = 11000000b
-11101000b & 11010001b = 11000000b
-11101000b & 11010010b = 11000000b
-11101000b & 11010011b = 11000000b
-11101000b & 11010100b = 11000000b
-11101000b & 11010101b = 11000000b
-11101000b & 11010110b = 11000000b
-11101000b & 11010111b = 11000000b
-11101000b & 11011000b = 11001000b
-11101000b & 11011001b = 11001000b
-11101000b & 11011010b = 11001000b
-11101000b & 11011011b = 11001000b
-11101000b & 11011100b = 11001000b
-11101000b & 11011101b = 11001000b
-11101000b & 11011110b = 11001000b
-11101000b & 11011111b = 11001000b
-11101000b & 11100000b = 11100000b
-11101000b & 11100001b = 11100000b
-11101000b & 11100010b = 11100000b
-11101000b & 11100011b = 11100000b
-11101000b & 11100100b = 11100000b
-11101000b & 11100101b = 11100000b
-11101000b & 11100110b = 11100000b
-11101000b & 11100111b = 11100000b
-11101000b & 11101000b = 11101000b
-11101000b & 11101001b = 11101000b
-11101000b & 11101010b = 11101000b
-11101000b & 11101011b = 11101000b
-11101000b & 11101100b = 11101000b
-11101000b & 11101101b = 11101000b
-11101000b & 11101110b = 11101000b
-11101000b & 11101111b = 11101000b
-11101000b & 11110000b = 11100000b
-11101000b & 11110001b = 11100000b
-11101000b & 11110010b = 11100000b
-11101000b & 11110011b = 11100000b
-11101000b & 11110100b = 11100000b
-11101000b & 11110101b = 11100000b
-11101000b & 11110110b = 11100000b
-11101000b & 11110111b = 11100000b
-11101000b & 11111000b = 11101000b
-11101000b & 11111001b = 11101000b
-11101000b & 11111010b = 11101000b
-11101000b & 11111011b = 11101000b
-11101000b & 11111100b = 11101000b
-11101000b & 11111101b = 11101000b
-11101000b & 11111110b = 11101000b
-11101000b & 11111111b = 11101000b
-11101000b & 00000000b = 00000000b
-11101000b & 00000001b = 00000000b
-11101000b & 00000010b = 00000000b
-11101000b & 00000011b = 00000000b
-11101000b & 00000100b = 00000000b
-11101000b & 00000101b = 00000000b
-11101000b & 00000110b = 00000000b
-11101000b & 00000111b = 00000000b
-11101000b & 00001000b = 00001000b
-11101000b & 00001001b = 00001000b
-11101000b & 00001010b = 00001000b
-11101000b & 00001011b = 00001000b
-11101000b & 00001100b = 00001000b
-11101000b & 00001101b = 00001000b
-11101000b & 00001110b = 00001000b
-11101000b & 00001111b = 00001000b
-11101000b & 00010000b = 00000000b
-11101000b & 00010001b = 00000000b
-11101000b & 00010010b = 00000000b
-11101000b & 00010011b = 00000000b
-11101000b & 00010100b = 00000000b
-11101000b & 00010101b = 00000000b
-11101000b & 00010110b = 00000000b
-11101000b & 00010111b = 00000000b
-11101000b & 00011000b = 00001000b
-11101000b & 00011001b = 00001000b
-11101000b & 00011010b = 00001000b
-11101000b & 00011011b = 00001000b
-11101000b & 00011100b = 00001000b
-11101000b & 00011101b = 00001000b
-11101000b & 00011110b = 00001000b
-11101000b & 00011111b = 00001000b
-11101000b & 00100000b = 00100000b
-11101000b & 00100001b = 00100000b
-11101000b & 00100010b = 00100000b
-11101000b & 00100011b = 00100000b
-11101000b & 00100100b = 00100000b
-11101000b & 00100101b = 00100000b
-11101000b & 00100110b = 00100000b
-11101000b & 00100111b = 00100000b
-11101000b & 00101000b = 00101000b
-11101000b & 00101001b = 00101000b
-11101000b & 00101010b = 00101000b
-11101000b & 00101011b = 00101000b
-11101000b & 00101100b = 00101000b
-11101000b & 00101101b = 00101000b
-11101000b & 00101110b = 00101000b
-11101000b & 00101111b = 00101000b
-11101000b & 00110000b = 00100000b
-11101000b & 00110001b = 00100000b
-11101000b & 00110010b = 00100000b
-11101000b & 00110011b = 00100000b
-11101000b & 00110100b = 00100000b
-11101000b & 00110101b = 00100000b
-11101000b & 00110110b = 00100000b
-11101000b & 00110111b = 00100000b
-11101000b & 00111000b = 00101000b
-11101000b & 00111001b = 00101000b
-11101000b & 00111010b = 00101000b
-11101000b & 00111011b = 00101000b
-11101000b & 00111100b = 00101000b
-11101000b & 00111101b = 00101000b
-11101000b & 00111110b = 00101000b
-11101000b & 00111111b = 00101000b
-11101000b & 01000000b = 01000000b
-11101000b & 01000001b = 01000000b
-11101000b & 01000010b = 01000000b
-11101000b & 01000011b = 01000000b
-11101000b & 01000100b = 01000000b
-11101000b & 01000101b = 01000000b
-11101000b & 01000110b = 01000000b
-11101000b & 01000111b = 01000000b
-11101000b & 01001000b = 01001000b
-11101000b & 01001001b = 01001000b
-11101000b & 01001010b = 01001000b
-11101000b & 01001011b = 01001000b
-11101000b & 01001100b = 01001000b
-11101000b & 01001101b = 01001000b
-11101000b & 01001110b = 01001000b
-11101000b & 01001111b = 01001000b
-11101000b & 01010000b = 01000000b
-11101000b & 01010001b = 01000000b
-11101000b & 01010010b = 01000000b
-11101000b & 01010011b = 01000000b
-11101000b & 01010100b = 01000000b
-11101000b & 01010101b = 01000000b
-11101000b & 01010110b = 01000000b
-11101000b & 01010111b = 01000000b
-11101000b & 01011000b = 01001000b
-11101000b & 01011001b = 01001000b
-11101000b & 01011010b = 01001000b
-11101000b & 01011011b = 01001000b
-11101000b & 01011100b = 01001000b
-11101000b & 01011101b = 01001000b
-11101000b & 01011110b = 01001000b
-11101000b & 01011111b = 01001000b
-11101000b & 01100000b = 01100000b
-11101000b & 01100001b = 01100000b
-11101000b & 01100010b = 01100000b
-11101000b & 01100011b = 01100000b
-11101000b & 01100100b = 01100000b
-11101000b & 01100101b = 01100000b
-11101000b & 01100110b = 01100000b
-11101000b & 01100111b = 01100000b
-11101000b & 01101000b = 01101000b
-11101000b & 01101001b = 01101000b
-11101000b & 01101010b = 01101000b
-11101000b & 01101011b = 01101000b
-11101000b & 01101100b = 01101000b
-11101000b & 01101101b = 01101000b
-11101000b & 01101110b = 01101000b
-11101000b & 01101111b = 01101000b
-11101000b & 01110000b = 01100000b
-11101000b & 01110001b = 01100000b
-11101000b & 01110010b = 01100000b
-11101000b & 01110011b = 01100000b
-11101000b & 01110100b = 01100000b
-11101000b & 01110101b = 01100000b
-11101000b & 01110110b = 01100000b
-11101000b & 01110111b = 01100000b
-11101000b & 01111000b = 01101000b
-11101000b & 01111001b = 01101000b
-11101000b & 01111010b = 01101000b
-11101000b & 01111011b = 01101000b
-11101000b & 01111100b = 01101000b
-11101000b & 01111101b = 01101000b
-11101000b & 01111110b = 01101000b
-11101001b & 10000000b = 10000000b
-11101001b & 10000001b = 10000001b
-11101001b & 10000010b = 10000000b
-11101001b & 10000011b = 10000001b
-11101001b & 10000100b = 10000000b
-11101001b & 10000101b = 10000001b
-11101001b & 10000110b = 10000000b
-11101001b & 10000111b = 10000001b
-11101001b & 10001000b = 10001000b
-11101001b & 10001001b = 10001001b
-11101001b & 10001010b = 10001000b
-11101001b & 10001011b = 10001001b
-11101001b & 10001100b = 10001000b
-11101001b & 10001101b = 10001001b
-11101001b & 10001110b = 10001000b
-11101001b & 10001111b = 10001001b
-11101001b & 10010000b = 10000000b
-11101001b & 10010001b = 10000001b
-11101001b & 10010010b = 10000000b
-11101001b & 10010011b = 10000001b
-11101001b & 10010100b = 10000000b
-11101001b & 10010101b = 10000001b
-11101001b & 10010110b = 10000000b
-11101001b & 10010111b = 10000001b
-11101001b & 10011000b = 10001000b
-11101001b & 10011001b = 10001001b
-11101001b & 10011010b = 10001000b
-11101001b & 10011011b = 10001001b
-11101001b & 10011100b = 10001000b
-11101001b & 10011101b = 10001001b
-11101001b & 10011110b = 10001000b
-11101001b & 10011111b = 10001001b
-11101001b & 10100000b = 10100000b
-11101001b & 10100001b = 10100001b
-11101001b & 10100010b = 10100000b
-11101001b & 10100011b = 10100001b
-11101001b & 10100100b = 10100000b
-11101001b & 10100101b = 10100001b
-11101001b & 10100110b = 10100000b
-11101001b & 10100111b = 10100001b
-11101001b & 10101000b = 10101000b
-11101001b & 10101001b = 10101001b
-11101001b & 10101010b = 10101000b
-11101001b & 10101011b = 10101001b
-11101001b & 10101100b = 10101000b
-11101001b & 10101101b = 10101001b
-11101001b & 10101110b = 10101000b
-11101001b & 10101111b = 10101001b
-11101001b & 10110000b = 10100000b
-11101001b & 10110001b = 10100001b
-11101001b & 10110010b = 10100000b
-11101001b & 10110011b = 10100001b
-11101001b & 10110100b = 10100000b
-11101001b & 10110101b = 10100001b
-11101001b & 10110110b = 10100000b
-11101001b & 10110111b = 10100001b
-11101001b & 10111000b = 10101000b
-11101001b & 10111001b = 10101001b
-11101001b & 10111010b = 10101000b
-11101001b & 10111011b = 10101001b
-11101001b & 10111100b = 10101000b
-11101001b & 10111101b = 10101001b
-11101001b & 10111110b = 10101000b
-11101001b & 10111111b = 10101001b
-11101001b & 11000000b = 11000000b
-11101001b & 11000001b = 11000001b
-11101001b & 11000010b = 11000000b
-11101001b & 11000011b = 11000001b
-11101001b & 11000100b = 11000000b
-11101001b & 11000101b = 11000001b
-11101001b & 11000110b = 11000000b
-11101001b & 11000111b = 11000001b
-11101001b & 11001000b = 11001000b
-11101001b & 11001001b = 11001001b
-11101001b & 11001010b = 11001000b
-11101001b & 11001011b = 11001001b
-11101001b & 11001100b = 11001000b
-11101001b & 11001101b = 11001001b
-11101001b & 11001110b = 11001000b
-11101001b & 11001111b = 11001001b
-11101001b & 11010000b = 11000000b
-11101001b & 11010001b = 11000001b
-11101001b & 11010010b = 11000000b
-11101001b & 11010011b = 11000001b
-11101001b & 11010100b = 11000000b
-11101001b & 11010101b = 11000001b
-11101001b & 11010110b = 11000000b
-11101001b & 11010111b = 11000001b
-11101001b & 11011000b = 11001000b
-11101001b & 11011001b = 11001001b
-11101001b & 11011010b = 11001000b
-11101001b & 11011011b = 11001001b
-11101001b & 11011100b = 11001000b
-11101001b & 11011101b = 11001001b
-11101001b & 11011110b = 11001000b
-11101001b & 11011111b = 11001001b
-11101001b & 11100000b = 11100000b
-11101001b & 11100001b = 11100001b
-11101001b & 11100010b = 11100000b
-11101001b & 11100011b = 11100001b
-11101001b & 11100100b = 11100000b
-11101001b & 11100101b = 11100001b
-11101001b & 11100110b = 11100000b
-11101001b & 11100111b = 11100001b
-11101001b & 11101000b = 11101000b
-11101001b & 11101001b = 11101001b
-11101001b & 11101010b = 11101000b
-11101001b & 11101011b = 11101001b
-11101001b & 11101100b = 11101000b
-11101001b & 11101101b = 11101001b
-11101001b & 11101110b = 11101000b
-11101001b & 11101111b = 11101001b
-11101001b & 11110000b = 11100000b
-11101001b & 11110001b = 11100001b
-11101001b & 11110010b = 11100000b
-11101001b & 11110011b = 11100001b
-11101001b & 11110100b = 11100000b
-11101001b & 11110101b = 11100001b
-11101001b & 11110110b = 11100000b
-11101001b & 11110111b = 11100001b
-11101001b & 11111000b = 11101000b
-11101001b & 11111001b = 11101001b
-11101001b & 11111010b = 11101000b
-11101001b & 11111011b = 11101001b
-11101001b & 11111100b = 11101000b
-11101001b & 11111101b = 11101001b
-11101001b & 11111110b = 11101000b
-11101001b & 11111111b = 11101001b
-11101001b & 00000000b = 00000000b
-11101001b & 00000001b = 00000001b
-11101001b & 00000010b = 00000000b
-11101001b & 00000011b = 00000001b
-11101001b & 00000100b = 00000000b
-11101001b & 00000101b = 00000001b
-11101001b & 00000110b = 00000000b
-11101001b & 00000111b = 00000001b
-11101001b & 00001000b = 00001000b
-11101001b & 00001001b = 00001001b
-11101001b & 00001010b = 00001000b
-11101001b & 00001011b = 00001001b
-11101001b & 00001100b = 00001000b
-11101001b & 00001101b = 00001001b
-11101001b & 00001110b = 00001000b
-11101001b & 00001111b = 00001001b
-11101001b & 00010000b = 00000000b
-11101001b & 00010001b = 00000001b
-11101001b & 00010010b = 00000000b
-11101001b & 00010011b = 00000001b
-11101001b & 00010100b = 00000000b
-11101001b & 00010101b = 00000001b
-11101001b & 00010110b = 00000000b
-11101001b & 00010111b = 00000001b
-11101001b & 00011000b = 00001000b
-11101001b & 00011001b = 00001001b
-11101001b & 00011010b = 00001000b
-11101001b & 00011011b = 00001001b
-11101001b & 00011100b = 00001000b
-11101001b & 00011101b = 00001001b
-11101001b & 00011110b = 00001000b
-11101001b & 00011111b = 00001001b
-11101001b & 00100000b = 00100000b
-11101001b & 00100001b = 00100001b
-11101001b & 00100010b = 00100000b
-11101001b & 00100011b = 00100001b
-11101001b & 00100100b = 00100000b
-11101001b & 00100101b = 00100001b
-11101001b & 00100110b = 00100000b
-11101001b & 00100111b = 00100001b
-11101001b & 00101000b = 00101000b
-11101001b & 00101001b = 00101001b
-11101001b & 00101010b = 00101000b
-11101001b & 00101011b = 00101001b
-11101001b & 00101100b = 00101000b
-11101001b & 00101101b = 00101001b
-11101001b & 00101110b = 00101000b
-11101001b & 00101111b = 00101001b
-11101001b & 00110000b = 00100000b
-11101001b & 00110001b = 00100001b
-11101001b & 00110010b = 00100000b
-11101001b & 00110011b = 00100001b
-11101001b & 00110100b = 00100000b
-11101001b & 00110101b = 00100001b
-11101001b & 00110110b = 00100000b
-11101001b & 00110111b = 00100001b
-11101001b & 00111000b = 00101000b
-11101001b & 00111001b = 00101001b
-11101001b & 00111010b = 00101000b
-11101001b & 00111011b = 00101001b
-11101001b & 00111100b = 00101000b
-11101001b & 00111101b = 00101001b
-11101001b & 00111110b = 00101000b
-11101001b & 00111111b = 00101001b
-11101001b & 01000000b = 01000000b
-11101001b & 01000001b = 01000001b
-11101001b & 01000010b = 01000000b
-11101001b & 01000011b = 01000001b
-11101001b & 01000100b = 01000000b
-11101001b & 01000101b = 01000001b
-11101001b & 01000110b = 01000000b
-11101001b & 01000111b = 01000001b
-11101001b & 01001000b = 01001000b
-11101001b & 01001001b = 01001001b
-11101001b & 01001010b = 01001000b
-11101001b & 01001011b = 01001001b
-11101001b & 01001100b = 01001000b
-11101001b & 01001101b = 01001001b
-11101001b & 01001110b = 01001000b
-11101001b & 01001111b = 01001001b
-11101001b & 01010000b = 01000000b
-11101001b & 01010001b = 01000001b
-11101001b & 01010010b = 01000000b
-11101001b & 01010011b = 01000001b
-11101001b & 01010100b = 01000000b
-11101001b & 01010101b = 01000001b
-11101001b & 01010110b = 01000000b
-11101001b & 01010111b = 01000001b
-11101001b & 01011000b = 01001000b
-11101001b & 01011001b = 01001001b
-11101001b & 01011010b = 01001000b
-11101001b & 01011011b = 01001001b
-11101001b & 01011100b = 01001000b
-11101001b & 01011101b = 01001001b
-11101001b & 01011110b = 01001000b
-11101001b & 01011111b = 01001001b
-11101001b & 01100000b = 01100000b
-11101001b & 01100001b = 01100001b
-11101001b & 01100010b = 01100000b
-11101001b & 01100011b = 01100001b
-11101001b & 01100100b = 01100000b
-11101001b & 01100101b = 01100001b
-11101001b & 01100110b = 01100000b
-11101001b & 01100111b = 01100001b
-11101001b & 01101000b = 01101000b
-11101001b & 01101001b = 01101001b
-11101001b & 01101010b = 01101000b
-11101001b & 01101011b = 01101001b
-11101001b & 01101100b = 01101000b
-11101001b & 01101101b = 01101001b
-11101001b & 01101110b = 01101000b
-11101001b & 01101111b = 01101001b
-11101001b & 01110000b = 01100000b
-11101001b & 01110001b = 01100001b
-11101001b & 01110010b = 01100000b
-11101001b & 01110011b = 01100001b
-11101001b & 01110100b = 01100000b
-11101001b & 01110101b = 01100001b
-11101001b & 01110110b = 01100000b
-11101001b & 01110111b = 01100001b
-11101001b & 01111000b = 01101000b
-11101001b & 01111001b = 01101001b
-11101001b & 01111010b = 01101000b
-11101001b & 01111011b = 01101001b
-11101001b & 01111100b = 01101000b
-11101001b & 01111101b = 01101001b
-11101001b & 01111110b = 01101000b
-11101010b & 10000000b = 10000000b
-11101010b & 10000001b = 10000000b
-11101010b & 10000010b = 10000010b
-11101010b & 10000011b = 10000010b
-11101010b & 10000100b = 10000000b
-11101010b & 10000101b = 10000000b
-11101010b & 10000110b = 10000010b
-11101010b & 10000111b = 10000010b
-11101010b & 10001000b = 10001000b
-11101010b & 10001001b = 10001000b
-11101010b & 10001010b = 10001010b
-11101010b & 10001011b = 10001010b
-11101010b & 10001100b = 10001000b
-11101010b & 10001101b = 10001000b
-11101010b & 10001110b = 10001010b
-11101010b & 10001111b = 10001010b
-11101010b & 10010000b = 10000000b
-11101010b & 10010001b = 10000000b
-11101010b & 10010010b = 10000010b
-11101010b & 10010011b = 10000010b
-11101010b & 10010100b = 10000000b
-11101010b & 10010101b = 10000000b
-11101010b & 10010110b = 10000010b
-11101010b & 10010111b = 10000010b
-11101010b & 10011000b = 10001000b
-11101010b & 10011001b = 10001000b
-11101010b & 10011010b = 10001010b
-11101010b & 10011011b = 10001010b
-11101010b & 10011100b = 10001000b
-11101010b & 10011101b = 10001000b
-11101010b & 10011110b = 10001010b
-11101010b & 10011111b = 10001010b
-11101010b & 10100000b = 10100000b
-11101010b & 10100001b = 10100000b
-11101010b & 10100010b = 10100010b
-11101010b & 10100011b = 10100010b
-11101010b & 10100100b = 10100000b
-11101010b & 10100101b = 10100000b
-11101010b & 10100110b = 10100010b
-11101010b & 10100111b = 10100010b
-11101010b & 10101000b = 10101000b
-11101010b & 10101001b = 10101000b
-11101010b & 10101010b = 10101010b
-11101010b & 10101011b = 10101010b
-11101010b & 10101100b = 10101000b
-11101010b & 10101101b = 10101000b
-11101010b & 10101110b = 10101010b
-11101010b & 10101111b = 10101010b
-11101010b & 10110000b = 10100000b
-11101010b & 10110001b = 10100000b
-11101010b & 10110010b = 10100010b
-11101010b & 10110011b = 10100010b
-11101010b & 10110100b = 10100000b
-11101010b & 10110101b = 10100000b
-11101010b & 10110110b = 10100010b
-11101010b & 10110111b = 10100010b
-11101010b & 10111000b = 10101000b
-11101010b & 10111001b = 10101000b
-11101010b & 10111010b = 10101010b
-11101010b & 10111011b = 10101010b
-11101010b & 10111100b = 10101000b
-11101010b & 10111101b = 10101000b
-11101010b & 10111110b = 10101010b
-11101010b & 10111111b = 10101010b
-11101010b & 11000000b = 11000000b
-11101010b & 11000001b = 11000000b
-11101010b & 11000010b = 11000010b
-11101010b & 11000011b = 11000010b
-11101010b & 11000100b = 11000000b
-11101010b & 11000101b = 11000000b
-11101010b & 11000110b = 11000010b
-11101010b & 11000111b = 11000010b
-11101010b & 11001000b = 11001000b
-11101010b & 11001001b = 11001000b
-11101010b & 11001010b = 11001010b
-11101010b & 11001011b = 11001010b
-11101010b & 11001100b = 11001000b
-11101010b & 11001101b = 11001000b
-11101010b & 11001110b = 11001010b
-11101010b & 11001111b = 11001010b
-11101010b & 11010000b = 11000000b
-11101010b & 11010001b = 11000000b
-11101010b & 11010010b = 11000010b
-11101010b & 11010011b = 11000010b
-11101010b & 11010100b = 11000000b
-11101010b & 11010101b = 11000000b
-11101010b & 11010110b = 11000010b
-11101010b & 11010111b = 11000010b
-11101010b & 11011000b = 11001000b
-11101010b & 11011001b = 11001000b
-11101010b & 11011010b = 11001010b
-11101010b & 11011011b = 11001010b
-11101010b & 11011100b = 11001000b
-11101010b & 11011101b = 11001000b
-11101010b & 11011110b = 11001010b
-11101010b & 11011111b = 11001010b
-11101010b & 11100000b = 11100000b
-11101010b & 11100001b = 11100000b
-11101010b & 11100010b = 11100010b
-11101010b & 11100011b = 11100010b
-11101010b & 11100100b = 11100000b
-11101010b & 11100101b = 11100000b
-11101010b & 11100110b = 11100010b
-11101010b & 11100111b = 11100010b
-11101010b & 11101000b = 11101000b
-11101010b & 11101001b = 11101000b
-11101010b & 11101010b = 11101010b
-11101010b & 11101011b = 11101010b
-11101010b & 11101100b = 11101000b
-11101010b & 11101101b = 11101000b
-11101010b & 11101110b = 11101010b
-11101010b & 11101111b = 11101010b
-11101010b & 11110000b = 11100000b
-11101010b & 11110001b = 11100000b
-11101010b & 11110010b = 11100010b
-11101010b & 11110011b = 11100010b
-11101010b & 11110100b = 11100000b
-11101010b & 11110101b = 11100000b
-11101010b & 11110110b = 11100010b
-11101010b & 11110111b = 11100010b
-11101010b & 11111000b = 11101000b
-11101010b & 11111001b = 11101000b
-11101010b & 11111010b = 11101010b
-11101010b & 11111011b = 11101010b
-11101010b & 11111100b = 11101000b
-11101010b & 11111101b = 11101000b
-11101010b & 11111110b = 11101010b
-11101010b & 11111111b = 11101010b
-11101010b & 00000000b = 00000000b
-11101010b & 00000001b = 00000000b
-11101010b & 00000010b = 00000010b
-11101010b & 00000011b = 00000010b
-11101010b & 00000100b = 00000000b
-11101010b & 00000101b = 00000000b
-11101010b & 00000110b = 00000010b
-11101010b & 00000111b = 00000010b
-11101010b & 00001000b = 00001000b
-11101010b & 00001001b = 00001000b
-11101010b & 00001010b = 00001010b
-11101010b & 00001011b = 00001010b
-11101010b & 00001100b = 00001000b
-11101010b & 00001101b = 00001000b
-11101010b & 00001110b = 00001010b
-11101010b & 00001111b = 00001010b
-11101010b & 00010000b = 00000000b
-11101010b & 00010001b = 00000000b
-11101010b & 00010010b = 00000010b
-11101010b & 00010011b = 00000010b
-11101010b & 00010100b = 00000000b
-11101010b & 00010101b = 00000000b
-11101010b & 00010110b = 00000010b
-11101010b & 00010111b = 00000010b
-11101010b & 00011000b = 00001000b
-11101010b & 00011001b = 00001000b
-11101010b & 00011010b = 00001010b
-11101010b & 00011011b = 00001010b
-11101010b & 00011100b = 00001000b
-11101010b & 00011101b = 00001000b
-11101010b & 00011110b = 00001010b
-11101010b & 00011111b = 00001010b
-11101010b & 00100000b = 00100000b
-11101010b & 00100001b = 00100000b
-11101010b & 00100010b = 00100010b
-11101010b & 00100011b = 00100010b
-11101010b & 00100100b = 00100000b
-11101010b & 00100101b = 00100000b
-11101010b & 00100110b = 00100010b
-11101010b & 00100111b = 00100010b
-11101010b & 00101000b = 00101000b
-11101010b & 00101001b = 00101000b
-11101010b & 00101010b = 00101010b
-11101010b & 00101011b = 00101010b
-11101010b & 00101100b = 00101000b
-11101010b & 00101101b = 00101000b
-11101010b & 00101110b = 00101010b
-11101010b & 00101111b = 00101010b
-11101010b & 00110000b = 00100000b
-11101010b & 00110001b = 00100000b
-11101010b & 00110010b = 00100010b
-11101010b & 00110011b = 00100010b
-11101010b & 00110100b = 00100000b
-11101010b & 00110101b = 00100000b
-11101010b & 00110110b = 00100010b
-11101010b & 00110111b = 00100010b
-11101010b & 00111000b = 00101000b
-11101010b & 00111001b = 00101000b
-11101010b & 00111010b = 00101010b
-11101010b & 00111011b = 00101010b
-11101010b & 00111100b = 00101000b
-11101010b & 00111101b = 00101000b
-11101010b & 00111110b = 00101010b
-11101010b & 00111111b = 00101010b
-11101010b & 01000000b = 01000000b
-11101010b & 01000001b = 01000000b
-11101010b & 01000010b = 01000010b
-11101010b & 01000011b = 01000010b
-11101010b & 01000100b = 01000000b
-11101010b & 01000101b = 01000000b
-11101010b & 01000110b = 01000010b
-11101010b & 01000111b = 01000010b
-11101010b & 01001000b = 01001000b
-11101010b & 01001001b = 01001000b
-11101010b & 01001010b = 01001010b
-11101010b & 01001011b = 01001010b
-11101010b & 01001100b = 01001000b
-11101010b & 01001101b = 01001000b
-11101010b & 01001110b = 01001010b
-11101010b & 01001111b = 01001010b
-11101010b & 01010000b = 01000000b
-11101010b & 01010001b = 01000000b
-11101010b & 01010010b = 01000010b
-11101010b & 01010011b = 01000010b
-11101010b & 01010100b = 01000000b
-11101010b & 01010101b = 01000000b
-11101010b & 01010110b = 01000010b
-11101010b & 01010111b = 01000010b
-11101010b & 01011000b = 01001000b
-11101010b & 01011001b = 01001000b
-11101010b & 01011010b = 01001010b
-11101010b & 01011011b = 01001010b
-11101010b & 01011100b = 01001000b
-11101010b & 01011101b = 01001000b
-11101010b & 01011110b = 01001010b
-11101010b & 01011111b = 01001010b
-11101010b & 01100000b = 01100000b
-11101010b & 01100001b = 01100000b
-11101010b & 01100010b = 01100010b
-11101010b & 01100011b = 01100010b
-11101010b & 01100100b = 01100000b
-11101010b & 01100101b = 01100000b
-11101010b & 01100110b = 01100010b
-11101010b & 01100111b = 01100010b
-11101010b & 01101000b = 01101000b
-11101010b & 01101001b = 01101000b
-11101010b & 01101010b = 01101010b
-11101010b & 01101011b = 01101010b
-11101010b & 01101100b = 01101000b
-11101010b & 01101101b = 01101000b
-11101010b & 01101110b = 01101010b
-11101010b & 01101111b = 01101010b
-11101010b & 01110000b = 01100000b
-11101010b & 01110001b = 01100000b
-11101010b & 01110010b = 01100010b
-11101010b & 01110011b = 01100010b
-11101010b & 01110100b = 01100000b
-11101010b & 01110101b = 01100000b
-11101010b & 01110110b = 01100010b
-11101010b & 01110111b = 01100010b
-11101010b & 01111000b = 01101000b
-11101010b & 01111001b = 01101000b
-11101010b & 01111010b = 01101010b
-11101010b & 01111011b = 01101010b
-11101010b & 01111100b = 01101000b
-11101010b & 01111101b = 01101000b
-11101010b & 01111110b = 01101010b
-11101011b & 10000000b = 10000000b
-11101011b & 10000001b = 10000001b
-11101011b & 10000010b = 10000010b
-11101011b & 10000011b = 10000011b
-11101011b & 10000100b = 10000000b
-11101011b & 10000101b = 10000001b
-11101011b & 10000110b = 10000010b
-11101011b & 10000111b = 10000011b
-11101011b & 10001000b = 10001000b
-11101011b & 10001001b = 10001001b
-11101011b & 10001010b = 10001010b
-11101011b & 10001011b = 10001011b
-11101011b & 10001100b = 10001000b
-11101011b & 10001101b = 10001001b
-11101011b & 10001110b = 10001010b
-11101011b & 10001111b = 10001011b
-11101011b & 10010000b = 10000000b
-11101011b & 10010001b = 10000001b
-11101011b & 10010010b = 10000010b
-11101011b & 10010011b = 10000011b
-11101011b & 10010100b = 10000000b
-11101011b & 10010101b = 10000001b
-11101011b & 10010110b = 10000010b
-11101011b & 10010111b = 10000011b
-11101011b & 10011000b = 10001000b
-11101011b & 10011001b = 10001001b
-11101011b & 10011010b = 10001010b
-11101011b & 10011011b = 10001011b
-11101011b & 10011100b = 10001000b
-11101011b & 10011101b = 10001001b
-11101011b & 10011110b = 10001010b
-11101011b & 10011111b = 10001011b
-11101011b & 10100000b = 10100000b
-11101011b & 10100001b = 10100001b
-11101011b & 10100010b = 10100010b
-11101011b & 10100011b = 10100011b
-11101011b & 10100100b = 10100000b
-11101011b & 10100101b = 10100001b
-11101011b & 10100110b = 10100010b
-11101011b & 10100111b = 10100011b
-11101011b & 10101000b = 10101000b
-11101011b & 10101001b = 10101001b
-11101011b & 10101010b = 10101010b
-11101011b & 10101011b = 10101011b
-11101011b & 10101100b = 10101000b
-11101011b & 10101101b = 10101001b
-11101011b & 10101110b = 10101010b
-11101011b & 10101111b = 10101011b
-11101011b & 10110000b = 10100000b
-11101011b & 10110001b = 10100001b
-11101011b & 10110010b = 10100010b
-11101011b & 10110011b = 10100011b
-11101011b & 10110100b = 10100000b
-11101011b & 10110101b = 10100001b
-11101011b & 10110110b = 10100010b
-11101011b & 10110111b = 10100011b
-11101011b & 10111000b = 10101000b
-11101011b & 10111001b = 10101001b
-11101011b & 10111010b = 10101010b
-11101011b & 10111011b = 10101011b
-11101011b & 10111100b = 10101000b
-11101011b & 10111101b = 10101001b
-11101011b & 10111110b = 10101010b
-11101011b & 10111111b = 10101011b
-11101011b & 11000000b = 11000000b
-11101011b & 11000001b = 11000001b
-11101011b & 11000010b = 11000010b
-11101011b & 11000011b = 11000011b
-11101011b & 11000100b = 11000000b
-11101011b & 11000101b = 11000001b
-11101011b & 11000110b = 11000010b
-11101011b & 11000111b = 11000011b
-11101011b & 11001000b = 11001000b
-11101011b & 11001001b = 11001001b
-11101011b & 11001010b = 11001010b
-11101011b & 11001011b = 11001011b
-11101011b & 11001100b = 11001000b
-11101011b & 11001101b = 11001001b
-11101011b & 11001110b = 11001010b
-11101011b & 11001111b = 11001011b
-11101011b & 11010000b = 11000000b
-11101011b & 11010001b = 11000001b
-11101011b & 11010010b = 11000010b
-11101011b & 11010011b = 11000011b
-11101011b & 11010100b = 11000000b
-11101011b & 11010101b = 11000001b
-11101011b & 11010110b = 11000010b
-11101011b & 11010111b = 11000011b
-11101011b & 11011000b = 11001000b
-11101011b & 11011001b = 11001001b
-11101011b & 11011010b = 11001010b
-11101011b & 11011011b = 11001011b
-11101011b & 11011100b = 11001000b
-11101011b & 11011101b = 11001001b
-11101011b & 11011110b = 11001010b
-11101011b & 11011111b = 11001011b
-11101011b & 11100000b = 11100000b
-11101011b & 11100001b = 11100001b
-11101011b & 11100010b = 11100010b
-11101011b & 11100011b = 11100011b
-11101011b & 11100100b = 11100000b
-11101011b & 11100101b = 11100001b
-11101011b & 11100110b = 11100010b
-11101011b & 11100111b = 11100011b
-11101011b & 11101000b = 11101000b
-11101011b & 11101001b = 11101001b
-11101011b & 11101010b = 11101010b
-11101011b & 11101011b = 11101011b
-11101011b & 11101100b = 11101000b
-11101011b & 11101101b = 11101001b
-11101011b & 11101110b = 11101010b
-11101011b & 11101111b = 11101011b
-11101011b & 11110000b = 11100000b
-11101011b & 11110001b = 11100001b
-11101011b & 11110010b = 11100010b
-11101011b & 11110011b = 11100011b
-11101011b & 11110100b = 11100000b
-11101011b & 11110101b = 11100001b
-11101011b & 11110110b = 11100010b
-11101011b & 11110111b = 11100011b
-11101011b & 11111000b = 11101000b
-11101011b & 11111001b = 11101001b
-11101011b & 11111010b = 11101010b
-11101011b & 11111011b = 11101011b
-11101011b & 11111100b = 11101000b
-11101011b & 11111101b = 11101001b
-11101011b & 11111110b = 11101010b
-11101011b & 11111111b = 11101011b
-11101011b & 00000000b = 00000000b
-11101011b & 00000001b = 00000001b
-11101011b & 00000010b = 00000010b
-11101011b & 00000011b = 00000011b
-11101011b & 00000100b = 00000000b
-11101011b & 00000101b = 00000001b
-11101011b & 00000110b = 00000010b
-11101011b & 00000111b = 00000011b
-11101011b & 00001000b = 00001000b
-11101011b & 00001001b = 00001001b
-11101011b & 00001010b = 00001010b
-11101011b & 00001011b = 00001011b
-11101011b & 00001100b = 00001000b
-11101011b & 00001101b = 00001001b
-11101011b & 00001110b = 00001010b
-11101011b & 00001111b = 00001011b
-11101011b & 00010000b = 00000000b
-11101011b & 00010001b = 00000001b
-11101011b & 00010010b = 00000010b
-11101011b & 00010011b = 00000011b
-11101011b & 00010100b = 00000000b
-11101011b & 00010101b = 00000001b
-11101011b & 00010110b = 00000010b
-11101011b & 00010111b = 00000011b
-11101011b & 00011000b = 00001000b
-11101011b & 00011001b = 00001001b
-11101011b & 00011010b = 00001010b
-11101011b & 00011011b = 00001011b
-11101011b & 00011100b = 00001000b
-11101011b & 00011101b = 00001001b
-11101011b & 00011110b = 00001010b
-11101011b & 00011111b = 00001011b
-11101011b & 00100000b = 00100000b
-11101011b & 00100001b = 00100001b
-11101011b & 00100010b = 00100010b
-11101011b & 00100011b = 00100011b
-11101011b & 00100100b = 00100000b
-11101011b & 00100101b = 00100001b
-11101011b & 00100110b = 00100010b
-11101011b & 00100111b = 00100011b
-11101011b & 00101000b = 00101000b
-11101011b & 00101001b = 00101001b
-11101011b & 00101010b = 00101010b
-11101011b & 00101011b = 00101011b
-11101011b & 00101100b = 00101000b
-11101011b & 00101101b = 00101001b
-11101011b & 00101110b = 00101010b
-11101011b & 00101111b = 00101011b
-11101011b & 00110000b = 00100000b
-11101011b & 00110001b = 00100001b
-11101011b & 00110010b = 00100010b
-11101011b & 00110011b = 00100011b
-11101011b & 00110100b = 00100000b
-11101011b & 00110101b = 00100001b
-11101011b & 00110110b = 00100010b
-11101011b & 00110111b = 00100011b
-11101011b & 00111000b = 00101000b
-11101011b & 00111001b = 00101001b
-11101011b & 00111010b = 00101010b
-11101011b & 00111011b = 00101011b
-11101011b & 00111100b = 00101000b
-11101011b & 00111101b = 00101001b
-11101011b & 00111110b = 00101010b
-11101011b & 00111111b = 00101011b
-11101011b & 01000000b = 01000000b
-11101011b & 01000001b = 01000001b
-11101011b & 01000010b = 01000010b
-11101011b & 01000011b = 01000011b
-11101011b & 01000100b = 01000000b
-11101011b & 01000101b = 01000001b
-11101011b & 01000110b = 01000010b
-11101011b & 01000111b = 01000011b
-11101011b & 01001000b = 01001000b
-11101011b & 01001001b = 01001001b
-11101011b & 01001010b = 01001010b
-11101011b & 01001011b = 01001011b
-11101011b & 01001100b = 01001000b
-11101011b & 01001101b = 01001001b
-11101011b & 01001110b = 01001010b
-11101011b & 01001111b = 01001011b
-11101011b & 01010000b = 01000000b
-11101011b & 01010001b = 01000001b
-11101011b & 01010010b = 01000010b
-11101011b & 01010011b = 01000011b
-11101011b & 01010100b = 01000000b
-11101011b & 01010101b = 01000001b
-11101011b & 01010110b = 01000010b
-11101011b & 01010111b = 01000011b
-11101011b & 01011000b = 01001000b
-11101011b & 01011001b = 01001001b
-11101011b & 01011010b = 01001010b
-11101011b & 01011011b = 01001011b
-11101011b & 01011100b = 01001000b
-11101011b & 01011101b = 01001001b
-11101011b & 01011110b = 01001010b
-11101011b & 01011111b = 01001011b
-11101011b & 01100000b = 01100000b
-11101011b & 01100001b = 01100001b
-11101011b & 01100010b = 01100010b
-11101011b & 01100011b = 01100011b
-11101011b & 01100100b = 01100000b
-11101011b & 01100101b = 01100001b
-11101011b & 01100110b = 01100010b
-11101011b & 01100111b = 01100011b
-11101011b & 01101000b = 01101000b
-11101011b & 01101001b = 01101001b
-11101011b & 01101010b = 01101010b
-11101011b & 01101011b = 01101011b
-11101011b & 01101100b = 01101000b
-11101011b & 01101101b = 01101001b
-11101011b & 01101110b = 01101010b
-11101011b & 01101111b = 01101011b
-11101011b & 01110000b = 01100000b
-11101011b & 01110001b = 01100001b
-11101011b & 01110010b = 01100010b
-11101011b & 01110011b = 01100011b
-11101011b & 01110100b = 01100000b
-11101011b & 01110101b = 01100001b
-11101011b & 01110110b = 01100010b
-11101011b & 01110111b = 01100011b
-11101011b & 01111000b = 01101000b
-11101011b & 01111001b = 01101001b
-11101011b & 01111010b = 01101010b
-11101011b & 01111011b = 01101011b
-11101011b & 01111100b = 01101000b
-11101011b & 01111101b = 01101001b
-11101011b & 01111110b = 01101010b
-11101100b & 10000000b = 10000000b
-11101100b & 10000001b = 10000000b
-11101100b & 10000010b = 10000000b
-11101100b & 10000011b = 10000000b
-11101100b & 10000100b = 10000100b
-11101100b & 10000101b = 10000100b
-11101100b & 10000110b = 10000100b
-11101100b & 10000111b = 10000100b
-11101100b & 10001000b = 10001000b
-11101100b & 10001001b = 10001000b
-11101100b & 10001010b = 10001000b
-11101100b & 10001011b = 10001000b
-11101100b & 10001100b = 10001100b
-11101100b & 10001101b = 10001100b
-11101100b & 10001110b = 10001100b
-11101100b & 10001111b = 10001100b
-11101100b & 10010000b = 10000000b
-11101100b & 10010001b = 10000000b
-11101100b & 10010010b = 10000000b
-11101100b & 10010011b = 10000000b
-11101100b & 10010100b = 10000100b
-11101100b & 10010101b = 10000100b
-11101100b & 10010110b = 10000100b
-11101100b & 10010111b = 10000100b
-11101100b & 10011000b = 10001000b
-11101100b & 10011001b = 10001000b
-11101100b & 10011010b = 10001000b
-11101100b & 10011011b = 10001000b
-11101100b & 10011100b = 10001100b
-11101100b & 10011101b = 10001100b
-11101100b & 10011110b = 10001100b
-11101100b & 10011111b = 10001100b
-11101100b & 10100000b = 10100000b
-11101100b & 10100001b = 10100000b
-11101100b & 10100010b = 10100000b
-11101100b & 10100011b = 10100000b
-11101100b & 10100100b = 10100100b
-11101100b & 10100101b = 10100100b
-11101100b & 10100110b = 10100100b
-11101100b & 10100111b = 10100100b
-11101100b & 10101000b = 10101000b
-11101100b & 10101001b = 10101000b
-11101100b & 10101010b = 10101000b
-11101100b & 10101011b = 10101000b
-11101100b & 10101100b = 10101100b
-11101100b & 10101101b = 10101100b
-11101100b & 10101110b = 10101100b
-11101100b & 10101111b = 10101100b
-11101100b & 10110000b = 10100000b
-11101100b & 10110001b = 10100000b
-11101100b & 10110010b = 10100000b
-11101100b & 10110011b = 10100000b
-11101100b & 10110100b = 10100100b
-11101100b & 10110101b = 10100100b
-11101100b & 10110110b = 10100100b
-11101100b & 10110111b = 10100100b
-11101100b & 10111000b = 10101000b
-11101100b & 10111001b = 10101000b
-11101100b & 10111010b = 10101000b
-11101100b & 10111011b = 10101000b
-11101100b & 10111100b = 10101100b
-11101100b & 10111101b = 10101100b
-11101100b & 10111110b = 10101100b
-11101100b & 10111111b = 10101100b
-11101100b & 11000000b = 11000000b
-11101100b & 11000001b = 11000000b
-11101100b & 11000010b = 11000000b
-11101100b & 11000011b = 11000000b
-11101100b & 11000100b = 11000100b
-11101100b & 11000101b = 11000100b
-11101100b & 11000110b = 11000100b
-11101100b & 11000111b = 11000100b
-11101100b & 11001000b = 11001000b
-11101100b & 11001001b = 11001000b
-11101100b & 11001010b = 11001000b
-11101100b & 11001011b = 11001000b
-11101100b & 11001100b = 11001100b
-11101100b & 11001101b = 11001100b
-11101100b & 11001110b = 11001100b
-11101100b & 11001111b = 11001100b
-11101100b & 11010000b = 11000000b
-11101100b & 11010001b = 11000000b
-11101100b & 11010010b = 11000000b
-11101100b & 11010011b = 11000000b
-11101100b & 11010100b = 11000100b
-11101100b & 11010101b = 11000100b
-11101100b & 11010110b = 11000100b
-11101100b & 11010111b = 11000100b
-11101100b & 11011000b = 11001000b
-11101100b & 11011001b = 11001000b
-11101100b & 11011010b = 11001000b
-11101100b & 11011011b = 11001000b
-11101100b & 11011100b = 11001100b
-11101100b & 11011101b = 11001100b
-11101100b & 11011110b = 11001100b
-11101100b & 11011111b = 11001100b
-11101100b & 11100000b = 11100000b
-11101100b & 11100001b = 11100000b
-11101100b & 11100010b = 11100000b
-11101100b & 11100011b = 11100000b
-11101100b & 11100100b = 11100100b
-11101100b & 11100101b = 11100100b
-11101100b & 11100110b = 11100100b
-11101100b & 11100111b = 11100100b
-11101100b & 11101000b = 11101000b
-11101100b & 11101001b = 11101000b
-11101100b & 11101010b = 11101000b
-11101100b & 11101011b = 11101000b
-11101100b & 11101100b = 11101100b
-11101100b & 11101101b = 11101100b
-11101100b & 11101110b = 11101100b
-11101100b & 11101111b = 11101100b
-11101100b & 11110000b = 11100000b
-11101100b & 11110001b = 11100000b
-11101100b & 11110010b = 11100000b
-11101100b & 11110011b = 11100000b
-11101100b & 11110100b = 11100100b
-11101100b & 11110101b = 11100100b
-11101100b & 11110110b = 11100100b
-11101100b & 11110111b = 11100100b
-11101100b & 11111000b = 11101000b
-11101100b & 11111001b = 11101000b
-11101100b & 11111010b = 11101000b
-11101100b & 11111011b = 11101000b
-11101100b & 11111100b = 11101100b
-11101100b & 11111101b = 11101100b
-11101100b & 11111110b = 11101100b
-11101100b & 11111111b = 11101100b
-11101100b & 00000000b = 00000000b
-11101100b & 00000001b = 00000000b
-11101100b & 00000010b = 00000000b
-11101100b & 00000011b = 00000000b
-11101100b & 00000100b = 00000100b
-11101100b & 00000101b = 00000100b
-11101100b & 00000110b = 00000100b
-11101100b & 00000111b = 00000100b
-11101100b & 00001000b = 00001000b
-11101100b & 00001001b = 00001000b
-11101100b & 00001010b = 00001000b
-11101100b & 00001011b = 00001000b
-11101100b & 00001100b = 00001100b
-11101100b & 00001101b = 00001100b
-11101100b & 00001110b = 00001100b
-11101100b & 00001111b = 00001100b
-11101100b & 00010000b = 00000000b
-11101100b & 00010001b = 00000000b
-11101100b & 00010010b = 00000000b
-11101100b & 00010011b = 00000000b
-11101100b & 00010100b = 00000100b
-11101100b & 00010101b = 00000100b
-11101100b & 00010110b = 00000100b
-11101100b & 00010111b = 00000100b
-11101100b & 00011000b = 00001000b
-11101100b & 00011001b = 00001000b
-11101100b & 00011010b = 00001000b
-11101100b & 00011011b = 00001000b
-11101100b & 00011100b = 00001100b
-11101100b & 00011101b = 00001100b
-11101100b & 00011110b = 00001100b
-11101100b & 00011111b = 00001100b
-11101100b & 00100000b = 00100000b
-11101100b & 00100001b = 00100000b
-11101100b & 00100010b = 00100000b
-11101100b & 00100011b = 00100000b
-11101100b & 00100100b = 00100100b
-11101100b & 00100101b = 00100100b
-11101100b & 00100110b = 00100100b
-11101100b & 00100111b = 00100100b
-11101100b & 00101000b = 00101000b
-11101100b & 00101001b = 00101000b
-11101100b & 00101010b = 00101000b
-11101100b & 00101011b = 00101000b
-11101100b & 00101100b = 00101100b
-11101100b & 00101101b = 00101100b
-11101100b & 00101110b = 00101100b
-11101100b & 00101111b = 00101100b
-11101100b & 00110000b = 00100000b
-11101100b & 00110001b = 00100000b
-11101100b & 00110010b = 00100000b
-11101100b & 00110011b = 00100000b
-11101100b & 00110100b = 00100100b
-11101100b & 00110101b = 00100100b
-11101100b & 00110110b = 00100100b
-11101100b & 00110111b = 00100100b
-11101100b & 00111000b = 00101000b
-11101100b & 00111001b = 00101000b
-11101100b & 00111010b = 00101000b
-11101100b & 00111011b = 00101000b
-11101100b & 00111100b = 00101100b
-11101100b & 00111101b = 00101100b
-11101100b & 00111110b = 00101100b
-11101100b & 00111111b = 00101100b
-11101100b & 01000000b = 01000000b
-11101100b & 01000001b = 01000000b
-11101100b & 01000010b = 01000000b
-11101100b & 01000011b = 01000000b
-11101100b & 01000100b = 01000100b
-11101100b & 01000101b = 01000100b
-11101100b & 01000110b = 01000100b
-11101100b & 01000111b = 01000100b
-11101100b & 01001000b = 01001000b
-11101100b & 01001001b = 01001000b
-11101100b & 01001010b = 01001000b
-11101100b & 01001011b = 01001000b
-11101100b & 01001100b = 01001100b
-11101100b & 01001101b = 01001100b
-11101100b & 01001110b = 01001100b
-11101100b & 01001111b = 01001100b
-11101100b & 01010000b = 01000000b
-11101100b & 01010001b = 01000000b
-11101100b & 01010010b = 01000000b
-11101100b & 01010011b = 01000000b
-11101100b & 01010100b = 01000100b
-11101100b & 01010101b = 01000100b
-11101100b & 01010110b = 01000100b
-11101100b & 01010111b = 01000100b
-11101100b & 01011000b = 01001000b
-11101100b & 01011001b = 01001000b
-11101100b & 01011010b = 01001000b
-11101100b & 01011011b = 01001000b
-11101100b & 01011100b = 01001100b
-11101100b & 01011101b = 01001100b
-11101100b & 01011110b = 01001100b
-11101100b & 01011111b = 01001100b
-11101100b & 01100000b = 01100000b
-11101100b & 01100001b = 01100000b
-11101100b & 01100010b = 01100000b
-11101100b & 01100011b = 01100000b
-11101100b & 01100100b = 01100100b
-11101100b & 01100101b = 01100100b
-11101100b & 01100110b = 01100100b
-11101100b & 01100111b = 01100100b
-11101100b & 01101000b = 01101000b
-11101100b & 01101001b = 01101000b
-11101100b & 01101010b = 01101000b
-11101100b & 01101011b = 01101000b
-11101100b & 01101100b = 01101100b
-11101100b & 01101101b = 01101100b
-11101100b & 01101110b = 01101100b
-11101100b & 01101111b = 01101100b
-11101100b & 01110000b = 01100000b
-11101100b & 01110001b = 01100000b
-11101100b & 01110010b = 01100000b
-11101100b & 01110011b = 01100000b
-11101100b & 01110100b = 01100100b
-11101100b & 01110101b = 01100100b
-11101100b & 01110110b = 01100100b
-11101100b & 01110111b = 01100100b
-11101100b & 01111000b = 01101000b
-11101100b & 01111001b = 01101000b
-11101100b & 01111010b = 01101000b
-11101100b & 01111011b = 01101000b
-11101100b & 01111100b = 01101100b
-11101100b & 01111101b = 01101100b
-11101100b & 01111110b = 01101100b
-11101101b & 10000000b = 10000000b
-11101101b & 10000001b = 10000001b
-11101101b & 10000010b = 10000000b
-11101101b & 10000011b = 10000001b
-11101101b & 10000100b = 10000100b
-11101101b & 10000101b = 10000101b
-11101101b & 10000110b = 10000100b
-11101101b & 10000111b = 10000101b
-11101101b & 10001000b = 10001000b
-11101101b & 10001001b = 10001001b
-11101101b & 10001010b = 10001000b
-11101101b & 10001011b = 10001001b
-11101101b & 10001100b = 10001100b
-11101101b & 10001101b = 10001101b
-11101101b & 10001110b = 10001100b
-11101101b & 10001111b = 10001101b
-11101101b & 10010000b = 10000000b
-11101101b & 10010001b = 10000001b
-11101101b & 10010010b = 10000000b
-11101101b & 10010011b = 10000001b
-11101101b & 10010100b = 10000100b
-11101101b & 10010101b = 10000101b
-11101101b & 10010110b = 10000100b
-11101101b & 10010111b = 10000101b
-11101101b & 10011000b = 10001000b
-11101101b & 10011001b = 10001001b
-11101101b & 10011010b = 10001000b
-11101101b & 10011011b = 10001001b
-11101101b & 10011100b = 10001100b
-11101101b & 10011101b = 10001101b
-11101101b & 10011110b = 10001100b
-11101101b & 10011111b = 10001101b
-11101101b & 10100000b = 10100000b
-11101101b & 10100001b = 10100001b
-11101101b & 10100010b = 10100000b
-11101101b & 10100011b = 10100001b
-11101101b & 10100100b = 10100100b
-11101101b & 10100101b = 10100101b
-11101101b & 10100110b = 10100100b
-11101101b & 10100111b = 10100101b
-11101101b & 10101000b = 10101000b
-11101101b & 10101001b = 10101001b
-11101101b & 10101010b = 10101000b
-11101101b & 10101011b = 10101001b
-11101101b & 10101100b = 10101100b
-11101101b & 10101101b = 10101101b
-11101101b & 10101110b = 10101100b
-11101101b & 10101111b = 10101101b
-11101101b & 10110000b = 10100000b
-11101101b & 10110001b = 10100001b
-11101101b & 10110010b = 10100000b
-11101101b & 10110011b = 10100001b
-11101101b & 10110100b = 10100100b
-11101101b & 10110101b = 10100101b
-11101101b & 10110110b = 10100100b
-11101101b & 10110111b = 10100101b
-11101101b & 10111000b = 10101000b
-11101101b & 10111001b = 10101001b
-11101101b & 10111010b = 10101000b
-11101101b & 10111011b = 10101001b
-11101101b & 10111100b = 10101100b
-11101101b & 10111101b = 10101101b
-11101101b & 10111110b = 10101100b
-11101101b & 10111111b = 10101101b
-11101101b & 11000000b = 11000000b
-11101101b & 11000001b = 11000001b
-11101101b & 11000010b = 11000000b
-11101101b & 11000011b = 11000001b
-11101101b & 11000100b = 11000100b
-11101101b & 11000101b = 11000101b
-11101101b & 11000110b = 11000100b
-11101101b & 11000111b = 11000101b
-11101101b & 11001000b = 11001000b
-11101101b & 11001001b = 11001001b
-11101101b & 11001010b = 11001000b
-11101101b & 11001011b = 11001001b
-11101101b & 11001100b = 11001100b
-11101101b & 11001101b = 11001101b
-11101101b & 11001110b = 11001100b
-11101101b & 11001111b = 11001101b
-11101101b & 11010000b = 11000000b
-11101101b & 11010001b = 11000001b
-11101101b & 11010010b = 11000000b
-11101101b & 11010011b = 11000001b
-11101101b & 11010100b = 11000100b
-11101101b & 11010101b = 11000101b
-11101101b & 11010110b = 11000100b
-11101101b & 11010111b = 11000101b
-11101101b & 11011000b = 11001000b
-11101101b & 11011001b = 11001001b
-11101101b & 11011010b = 11001000b
-11101101b & 11011011b = 11001001b
-11101101b & 11011100b = 11001100b
-11101101b & 11011101b = 11001101b
-11101101b & 11011110b = 11001100b
-11101101b & 11011111b = 11001101b
-11101101b & 11100000b = 11100000b
-11101101b & 11100001b = 11100001b
-11101101b & 11100010b = 11100000b
-11101101b & 11100011b = 11100001b
-11101101b & 11100100b = 11100100b
-11101101b & 11100101b = 11100101b
-11101101b & 11100110b = 11100100b
-11101101b & 11100111b = 11100101b
-11101101b & 11101000b = 11101000b
-11101101b & 11101001b = 11101001b
-11101101b & 11101010b = 11101000b
-11101101b & 11101011b = 11101001b
-11101101b & 11101100b = 11101100b
-11101101b & 11101101b = 11101101b
-11101101b & 11101110b = 11101100b
-11101101b & 11101111b = 11101101b
-11101101b & 11110000b = 11100000b
-11101101b & 11110001b = 11100001b
-11101101b & 11110010b = 11100000b
-11101101b & 11110011b = 11100001b
-11101101b & 11110100b = 11100100b
-11101101b & 11110101b = 11100101b
-11101101b & 11110110b = 11100100b
-11101101b & 11110111b = 11100101b
-11101101b & 11111000b = 11101000b
-11101101b & 11111001b = 11101001b
-11101101b & 11111010b = 11101000b
-11101101b & 11111011b = 11101001b
-11101101b & 11111100b = 11101100b
-11101101b & 11111101b = 11101101b
-11101101b & 11111110b = 11101100b
-11101101b & 11111111b = 11101101b
-11101101b & 00000000b = 00000000b
-11101101b & 00000001b = 00000001b
-11101101b & 00000010b = 00000000b
-11101101b & 00000011b = 00000001b
-11101101b & 00000100b = 00000100b
-11101101b & 00000101b = 00000101b
-11101101b & 00000110b = 00000100b
-11101101b & 00000111b = 00000101b
-11101101b & 00001000b = 00001000b
-11101101b & 00001001b = 00001001b
-11101101b & 00001010b = 00001000b
-11101101b & 00001011b = 00001001b
-11101101b & 00001100b = 00001100b
-11101101b & 00001101b = 00001101b
-11101101b & 00001110b = 00001100b
-11101101b & 00001111b = 00001101b
-11101101b & 00010000b = 00000000b
-11101101b & 00010001b = 00000001b
-11101101b & 00010010b = 00000000b
-11101101b & 00010011b = 00000001b
-11101101b & 00010100b = 00000100b
-11101101b & 00010101b = 00000101b
-11101101b & 00010110b = 00000100b
-11101101b & 00010111b = 00000101b
-11101101b & 00011000b = 00001000b
-11101101b & 00011001b = 00001001b
-11101101b & 00011010b = 00001000b
-11101101b & 00011011b = 00001001b
-11101101b & 00011100b = 00001100b
-11101101b & 00011101b = 00001101b
-11101101b & 00011110b = 00001100b
-11101101b & 00011111b = 00001101b
-11101101b & 00100000b = 00100000b
-11101101b & 00100001b = 00100001b
-11101101b & 00100010b = 00100000b
-11101101b & 00100011b = 00100001b
-11101101b & 00100100b = 00100100b
-11101101b & 00100101b = 00100101b
-11101101b & 00100110b = 00100100b
-11101101b & 00100111b = 00100101b
-11101101b & 00101000b = 00101000b
-11101101b & 00101001b = 00101001b
-11101101b & 00101010b = 00101000b
-11101101b & 00101011b = 00101001b
-11101101b & 00101100b = 00101100b
-11101101b & 00101101b = 00101101b
-11101101b & 00101110b = 00101100b
-11101101b & 00101111b = 00101101b
-11101101b & 00110000b = 00100000b
-11101101b & 00110001b = 00100001b
-11101101b & 00110010b = 00100000b
-11101101b & 00110011b = 00100001b
-11101101b & 00110100b = 00100100b
-11101101b & 00110101b = 00100101b
-11101101b & 00110110b = 00100100b
-11101101b & 00110111b = 00100101b
-11101101b & 00111000b = 00101000b
-11101101b & 00111001b = 00101001b
-11101101b & 00111010b = 00101000b
-11101101b & 00111011b = 00101001b
-11101101b & 00111100b = 00101100b
-11101101b & 00111101b = 00101101b
-11101101b & 00111110b = 00101100b
-11101101b & 00111111b = 00101101b
-11101101b & 01000000b = 01000000b
-11101101b & 01000001b = 01000001b
-11101101b & 01000010b = 01000000b
-11101101b & 01000011b = 01000001b
-11101101b & 01000100b = 01000100b
-11101101b & 01000101b = 01000101b
-11101101b & 01000110b = 01000100b
-11101101b & 01000111b = 01000101b
-11101101b & 01001000b = 01001000b
-11101101b & 01001001b = 01001001b
-11101101b & 01001010b = 01001000b
-11101101b & 01001011b = 01001001b
-11101101b & 01001100b = 01001100b
-11101101b & 01001101b = 01001101b
-11101101b & 01001110b = 01001100b
-11101101b & 01001111b = 01001101b
-11101101b & 01010000b = 01000000b
-11101101b & 01010001b = 01000001b
-11101101b & 01010010b = 01000000b
-11101101b & 01010011b = 01000001b
-11101101b & 01010100b = 01000100b
-11101101b & 01010101b = 01000101b
-11101101b & 01010110b = 01000100b
-11101101b & 01010111b = 01000101b
-11101101b & 01011000b = 01001000b
-11101101b & 01011001b = 01001001b
-11101101b & 01011010b = 01001000b
-11101101b & 01011011b = 01001001b
-11101101b & 01011100b = 01001100b
-11101101b & 01011101b = 01001101b
-11101101b & 01011110b = 01001100b
-11101101b & 01011111b = 01001101b
-11101101b & 01100000b = 01100000b
-11101101b & 01100001b = 01100001b
-11101101b & 01100010b = 01100000b
-11101101b & 01100011b = 01100001b
-11101101b & 01100100b = 01100100b
-11101101b & 01100101b = 01100101b
-11101101b & 01100110b = 01100100b
-11101101b & 01100111b = 01100101b
-11101101b & 01101000b = 01101000b
-11101101b & 01101001b = 01101001b
-11101101b & 01101010b = 01101000b
-11101101b & 01101011b = 01101001b
-11101101b & 01101100b = 01101100b
-11101101b & 01101101b = 01101101b
-11101101b & 01101110b = 01101100b
-11101101b & 01101111b = 01101101b
-11101101b & 01110000b = 01100000b
-11101101b & 01110001b = 01100001b
-11101101b & 01110010b = 01100000b
-11101101b & 01110011b = 01100001b
-11101101b & 01110100b = 01100100b
-11101101b & 01110101b = 01100101b
-11101101b & 01110110b = 01100100b
-11101101b & 01110111b = 01100101b
-11101101b & 01111000b = 01101000b
-11101101b & 01111001b = 01101001b
-11101101b & 01111010b = 01101000b
-11101101b & 01111011b = 01101001b
-11101101b & 01111100b = 01101100b
-11101101b & 01111101b = 01101101b
-11101101b & 01111110b = 01101100b
-11101110b & 10000000b = 10000000b
-11101110b & 10000001b = 10000000b
-11101110b & 10000010b = 10000010b
-11101110b & 10000011b = 10000010b
-11101110b & 10000100b = 10000100b
-11101110b & 10000101b = 10000100b
-11101110b & 10000110b = 10000110b
-11101110b & 10000111b = 10000110b
-11101110b & 10001000b = 10001000b
-11101110b & 10001001b = 10001000b
-11101110b & 10001010b = 10001010b
-11101110b & 10001011b = 10001010b
-11101110b & 10001100b = 10001100b
-11101110b & 10001101b = 10001100b
-11101110b & 10001110b = 10001110b
-11101110b & 10001111b = 10001110b
-11101110b & 10010000b = 10000000b
-11101110b & 10010001b = 10000000b
-11101110b & 10010010b = 10000010b
-11101110b & 10010011b = 10000010b
-11101110b & 10010100b = 10000100b
-11101110b & 10010101b = 10000100b
-11101110b & 10010110b = 10000110b
-11101110b & 10010111b = 10000110b
-11101110b & 10011000b = 10001000b
-11101110b & 10011001b = 10001000b
-11101110b & 10011010b = 10001010b
-11101110b & 10011011b = 10001010b
-11101110b & 10011100b = 10001100b
-11101110b & 10011101b = 10001100b
-11101110b & 10011110b = 10001110b
-11101110b & 10011111b = 10001110b
-11101110b & 10100000b = 10100000b
-11101110b & 10100001b = 10100000b
-11101110b & 10100010b = 10100010b
-11101110b & 10100011b = 10100010b
-11101110b & 10100100b = 10100100b
-11101110b & 10100101b = 10100100b
-11101110b & 10100110b = 10100110b
-11101110b & 10100111b = 10100110b
-11101110b & 10101000b = 10101000b
-11101110b & 10101001b = 10101000b
-11101110b & 10101010b = 10101010b
-11101110b & 10101011b = 10101010b
-11101110b & 10101100b = 10101100b
-11101110b & 10101101b = 10101100b
-11101110b & 10101110b = 10101110b
-11101110b & 10101111b = 10101110b
-11101110b & 10110000b = 10100000b
-11101110b & 10110001b = 10100000b
-11101110b & 10110010b = 10100010b
-11101110b & 10110011b = 10100010b
-11101110b & 10110100b = 10100100b
-11101110b & 10110101b = 10100100b
-11101110b & 10110110b = 10100110b
-11101110b & 10110111b = 10100110b
-11101110b & 10111000b = 10101000b
-11101110b & 10111001b = 10101000b
-11101110b & 10111010b = 10101010b
-11101110b & 10111011b = 10101010b
-11101110b & 10111100b = 10101100b
-11101110b & 10111101b = 10101100b
-11101110b & 10111110b = 10101110b
-11101110b & 10111111b = 10101110b
-11101110b & 11000000b = 11000000b
-11101110b & 11000001b = 11000000b
-11101110b & 11000010b = 11000010b
-11101110b & 11000011b = 11000010b
-11101110b & 11000100b = 11000100b
-11101110b & 11000101b = 11000100b
-11101110b & 11000110b = 11000110b
-11101110b & 11000111b = 11000110b
-11101110b & 11001000b = 11001000b
-11101110b & 11001001b = 11001000b
-11101110b & 11001010b = 11001010b
-11101110b & 11001011b = 11001010b
-11101110b & 11001100b = 11001100b
-11101110b & 11001101b = 11001100b
-11101110b & 11001110b = 11001110b
-11101110b & 11001111b = 11001110b
-11101110b & 11010000b = 11000000b
-11101110b & 11010001b = 11000000b
-11101110b & 11010010b = 11000010b
-11101110b & 11010011b = 11000010b
-11101110b & 11010100b = 11000100b
-11101110b & 11010101b = 11000100b
-11101110b & 11010110b = 11000110b
-11101110b & 11010111b = 11000110b
-11101110b & 11011000b = 11001000b
-11101110b & 11011001b = 11001000b
-11101110b & 11011010b = 11001010b
-11101110b & 11011011b = 11001010b
-11101110b & 11011100b = 11001100b
-11101110b & 11011101b = 11001100b
-11101110b & 11011110b = 11001110b
-11101110b & 11011111b = 11001110b
-11101110b & 11100000b = 11100000b
-11101110b & 11100001b = 11100000b
-11101110b & 11100010b = 11100010b
-11101110b & 11100011b = 11100010b
-11101110b & 11100100b = 11100100b
-11101110b & 11100101b = 11100100b
-11101110b & 11100110b = 11100110b
-11101110b & 11100111b = 11100110b
-11101110b & 11101000b = 11101000b
-11101110b & 11101001b = 11101000b
-11101110b & 11101010b = 11101010b
-11101110b & 11101011b = 11101010b
-11101110b & 11101100b = 11101100b
-11101110b & 11101101b = 11101100b
-11101110b & 11101110b = 11101110b
-11101110b & 11101111b = 11101110b
-11101110b & 11110000b = 11100000b
-11101110b & 11110001b = 11100000b
-11101110b & 11110010b = 11100010b
-11101110b & 11110011b = 11100010b
-11101110b & 11110100b = 11100100b
-11101110b & 11110101b = 11100100b
-11101110b & 11110110b = 11100110b
-11101110b & 11110111b = 11100110b
-11101110b & 11111000b = 11101000b
-11101110b & 11111001b = 11101000b
-11101110b & 11111010b = 11101010b
-11101110b & 11111011b = 11101010b
-11101110b & 11111100b = 11101100b
-11101110b & 11111101b = 11101100b
-11101110b & 11111110b = 11101110b
-11101110b & 11111111b = 11101110b
-11101110b & 00000000b = 00000000b
-11101110b & 00000001b = 00000000b
-11101110b & 00000010b = 00000010b
-11101110b & 00000011b = 00000010b
-11101110b & 00000100b = 00000100b
-11101110b & 00000101b = 00000100b
-11101110b & 00000110b = 00000110b
-11101110b & 00000111b = 00000110b
-11101110b & 00001000b = 00001000b
-11101110b & 00001001b = 00001000b
-11101110b & 00001010b = 00001010b
-11101110b & 00001011b = 00001010b
-11101110b & 00001100b = 00001100b
-11101110b & 00001101b = 00001100b
-11101110b & 00001110b = 00001110b
-11101110b & 00001111b = 00001110b
-11101110b & 00010000b = 00000000b
-11101110b & 00010001b = 00000000b
-11101110b & 00010010b = 00000010b
-11101110b & 00010011b = 00000010b
-11101110b & 00010100b = 00000100b
-11101110b & 00010101b = 00000100b
-11101110b & 00010110b = 00000110b
-11101110b & 00010111b = 00000110b
-11101110b & 00011000b = 00001000b
-11101110b & 00011001b = 00001000b
-11101110b & 00011010b = 00001010b
-11101110b & 00011011b = 00001010b
-11101110b & 00011100b = 00001100b
-11101110b & 00011101b = 00001100b
-11101110b & 00011110b = 00001110b
-11101110b & 00011111b = 00001110b
-11101110b & 00100000b = 00100000b
-11101110b & 00100001b = 00100000b
-11101110b & 00100010b = 00100010b
-11101110b & 00100011b = 00100010b
-11101110b & 00100100b = 00100100b
-11101110b & 00100101b = 00100100b
-11101110b & 00100110b = 00100110b
-11101110b & 00100111b = 00100110b
-11101110b & 00101000b = 00101000b
-11101110b & 00101001b = 00101000b
-11101110b & 00101010b = 00101010b
-11101110b & 00101011b = 00101010b
-11101110b & 00101100b = 00101100b
-11101110b & 00101101b = 00101100b
-11101110b & 00101110b = 00101110b
-11101110b & 00101111b = 00101110b
-11101110b & 00110000b = 00100000b
-11101110b & 00110001b = 00100000b
-11101110b & 00110010b = 00100010b
-11101110b & 00110011b = 00100010b
-11101110b & 00110100b = 00100100b
-11101110b & 00110101b = 00100100b
-11101110b & 00110110b = 00100110b
-11101110b & 00110111b = 00100110b
-11101110b & 00111000b = 00101000b
-11101110b & 00111001b = 00101000b
-11101110b & 00111010b = 00101010b
-11101110b & 00111011b = 00101010b
-11101110b & 00111100b = 00101100b
-11101110b & 00111101b = 00101100b
-11101110b & 00111110b = 00101110b
-11101110b & 00111111b = 00101110b
-11101110b & 01000000b = 01000000b
-11101110b & 01000001b = 01000000b
-11101110b & 01000010b = 01000010b
-11101110b & 01000011b = 01000010b
-11101110b & 01000100b = 01000100b
-11101110b & 01000101b = 01000100b
-11101110b & 01000110b = 01000110b
-11101110b & 01000111b = 01000110b
-11101110b & 01001000b = 01001000b
-11101110b & 01001001b = 01001000b
-11101110b & 01001010b = 01001010b
-11101110b & 01001011b = 01001010b
-11101110b & 01001100b = 01001100b
-11101110b & 01001101b = 01001100b
-11101110b & 01001110b = 01001110b
-11101110b & 01001111b = 01001110b
-11101110b & 01010000b = 01000000b
-11101110b & 01010001b = 01000000b
-11101110b & 01010010b = 01000010b
-11101110b & 01010011b = 01000010b
-11101110b & 01010100b = 01000100b
-11101110b & 01010101b = 01000100b
-11101110b & 01010110b = 01000110b
-11101110b & 01010111b = 01000110b
-11101110b & 01011000b = 01001000b
-11101110b & 01011001b = 01001000b
-11101110b & 01011010b = 01001010b
-11101110b & 01011011b = 01001010b
-11101110b & 01011100b = 01001100b
-11101110b & 01011101b = 01001100b
-11101110b & 01011110b = 01001110b
-11101110b & 01011111b = 01001110b
-11101110b & 01100000b = 01100000b
-11101110b & 01100001b = 01100000b
-11101110b & 01100010b = 01100010b
-11101110b & 01100011b = 01100010b
-11101110b & 01100100b = 01100100b
-11101110b & 01100101b = 01100100b
-11101110b & 01100110b = 01100110b
-11101110b & 01100111b = 01100110b
-11101110b & 01101000b = 01101000b
-11101110b & 01101001b = 01101000b
-11101110b & 01101010b = 01101010b
-11101110b & 01101011b = 01101010b
-11101110b & 01101100b = 01101100b
-11101110b & 01101101b = 01101100b
-11101110b & 01101110b = 01101110b
-11101110b & 01101111b = 01101110b
-11101110b & 01110000b = 01100000b
-11101110b & 01110001b = 01100000b
-11101110b & 01110010b = 01100010b
-11101110b & 01110011b = 01100010b
-11101110b & 01110100b = 01100100b
-11101110b & 01110101b = 01100100b
-11101110b & 01110110b = 01100110b
-11101110b & 01110111b = 01100110b
-11101110b & 01111000b = 01101000b
-11101110b & 01111001b = 01101000b
-11101110b & 01111010b = 01101010b
-11101110b & 01111011b = 01101010b
-11101110b & 01111100b = 01101100b
-11101110b & 01111101b = 01101100b
-11101110b & 01111110b = 01101110b
-11101111b & 10000000b = 10000000b
-11101111b & 10000001b = 10000001b
-11101111b & 10000010b = 10000010b
-11101111b & 10000011b = 10000011b
-11101111b & 10000100b = 10000100b
-11101111b & 10000101b = 10000101b
-11101111b & 10000110b = 10000110b
-11101111b & 10000111b = 10000111b
-11101111b & 10001000b = 10001000b
-11101111b & 10001001b = 10001001b
-11101111b & 10001010b = 10001010b
-11101111b & 10001011b = 10001011b
-11101111b & 10001100b = 10001100b
-11101111b & 10001101b = 10001101b
-11101111b & 10001110b = 10001110b
-11101111b & 10001111b = 10001111b
-11101111b & 10010000b = 10000000b
-11101111b & 10010001b = 10000001b
-11101111b & 10010010b = 10000010b
-11101111b & 10010011b = 10000011b
-11101111b & 10010100b = 10000100b
-11101111b & 10010101b = 10000101b
-11101111b & 10010110b = 10000110b
-11101111b & 10010111b = 10000111b
-11101111b & 10011000b = 10001000b
-11101111b & 10011001b = 10001001b
-11101111b & 10011010b = 10001010b
-11101111b & 10011011b = 10001011b
-11101111b & 10011100b = 10001100b
-11101111b & 10011101b = 10001101b
-11101111b & 10011110b = 10001110b
-11101111b & 10011111b = 10001111b
-11101111b & 10100000b = 10100000b
-11101111b & 10100001b = 10100001b
-11101111b & 10100010b = 10100010b
-11101111b & 10100011b = 10100011b
-11101111b & 10100100b = 10100100b
-11101111b & 10100101b = 10100101b
-11101111b & 10100110b = 10100110b
-11101111b & 10100111b = 10100111b
-11101111b & 10101000b = 10101000b
-11101111b & 10101001b = 10101001b
-11101111b & 10101010b = 10101010b
-11101111b & 10101011b = 10101011b
-11101111b & 10101100b = 10101100b
-11101111b & 10101101b = 10101101b
-11101111b & 10101110b = 10101110b
-11101111b & 10101111b = 10101111b
-11101111b & 10110000b = 10100000b
-11101111b & 10110001b = 10100001b
-11101111b & 10110010b = 10100010b
-11101111b & 10110011b = 10100011b
-11101111b & 10110100b = 10100100b
-11101111b & 10110101b = 10100101b
-11101111b & 10110110b = 10100110b
-11101111b & 10110111b = 10100111b
-11101111b & 10111000b = 10101000b
-11101111b & 10111001b = 10101001b
-11101111b & 10111010b = 10101010b
-11101111b & 10111011b = 10101011b
-11101111b & 10111100b = 10101100b
-11101111b & 10111101b = 10101101b
-11101111b & 10111110b = 10101110b
-11101111b & 10111111b = 10101111b
-11101111b & 11000000b = 11000000b
-11101111b & 11000001b = 11000001b
-11101111b & 11000010b = 11000010b
-11101111b & 11000011b = 11000011b
-11101111b & 11000100b = 11000100b
-11101111b & 11000101b = 11000101b
-11101111b & 11000110b = 11000110b
-11101111b & 11000111b = 11000111b
-11101111b & 11001000b = 11001000b
-11101111b & 11001001b = 11001001b
-11101111b & 11001010b = 11001010b
-11101111b & 11001011b = 11001011b
-11101111b & 11001100b = 11001100b
-11101111b & 11001101b = 11001101b
-11101111b & 11001110b = 11001110b
-11101111b & 11001111b = 11001111b
-11101111b & 11010000b = 11000000b
-11101111b & 11010001b = 11000001b
-11101111b & 11010010b = 11000010b
-11101111b & 11010011b = 11000011b
-11101111b & 11010100b = 11000100b
-11101111b & 11010101b = 11000101b
-11101111b & 11010110b = 11000110b
-11101111b & 11010111b = 11000111b
-11101111b & 11011000b = 11001000b
-11101111b & 11011001b = 11001001b
-11101111b & 11011010b = 11001010b
-11101111b & 11011011b = 11001011b
-11101111b & 11011100b = 11001100b
-11101111b & 11011101b = 11001101b
-11101111b & 11011110b = 11001110b
-11101111b & 11011111b = 11001111b
-11101111b & 11100000b = 11100000b
-11101111b & 11100001b = 11100001b
-11101111b & 11100010b = 11100010b
-11101111b & 11100011b = 11100011b
-11101111b & 11100100b = 11100100b
-11101111b & 11100101b = 11100101b
-11101111b & 11100110b = 11100110b
-11101111b & 11100111b = 11100111b
-11101111b & 11101000b = 11101000b
-11101111b & 11101001b = 11101001b
-11101111b & 11101010b = 11101010b
-11101111b & 11101011b = 11101011b
-11101111b & 11101100b = 11101100b
-11101111b & 11101101b = 11101101b
-11101111b & 11101110b = 11101110b
-11101111b & 11101111b = 11101111b
-11101111b & 11110000b = 11100000b
-11101111b & 11110001b = 11100001b
-11101111b & 11110010b = 11100010b
-11101111b & 11110011b = 11100011b
-11101111b & 11110100b = 11100100b
-11101111b & 11110101b = 11100101b
-11101111b & 11110110b = 11100110b
-11101111b & 11110111b = 11100111b
-11101111b & 11111000b = 11101000b
-11101111b & 11111001b = 11101001b
-11101111b & 11111010b = 11101010b
-11101111b & 11111011b = 11101011b
-11101111b & 11111100b = 11101100b
-11101111b & 11111101b = 11101101b
-11101111b & 11111110b = 11101110b
-11101111b & 11111111b = 11101111b
-11101111b & 00000000b = 00000000b
-11101111b & 00000001b = 00000001b
-11101111b & 00000010b = 00000010b
-11101111b & 00000011b = 00000011b
-11101111b & 00000100b = 00000100b
-11101111b & 00000101b = 00000101b
-11101111b & 00000110b = 00000110b
-11101111b & 00000111b = 00000111b
-11101111b & 00001000b = 00001000b
-11101111b & 00001001b = 00001001b
-11101111b & 00001010b = 00001010b
-11101111b & 00001011b = 00001011b
-11101111b & 00001100b = 00001100b
-11101111b & 00001101b = 00001101b
-11101111b & 00001110b = 00001110b
-11101111b & 00001111b = 00001111b
-11101111b & 00010000b = 00000000b
-11101111b & 00010001b = 00000001b
-11101111b & 00010010b = 00000010b
-11101111b & 00010011b = 00000011b
-11101111b & 00010100b = 00000100b
-11101111b & 00010101b = 00000101b
-11101111b & 00010110b = 00000110b
-11101111b & 00010111b = 00000111b
-11101111b & 00011000b = 00001000b
-11101111b & 00011001b = 00001001b
-11101111b & 00011010b = 00001010b
-11101111b & 00011011b = 00001011b
-11101111b & 00011100b = 00001100b
-11101111b & 00011101b = 00001101b
-11101111b & 00011110b = 00001110b
-11101111b & 00011111b = 00001111b
-11101111b & 00100000b = 00100000b
-11101111b & 00100001b = 00100001b
-11101111b & 00100010b = 00100010b
-11101111b & 00100011b = 00100011b
-11101111b & 00100100b = 00100100b
-11101111b & 00100101b = 00100101b
-11101111b & 00100110b = 00100110b
-11101111b & 00100111b = 00100111b
-11101111b & 00101000b = 00101000b
-11101111b & 00101001b = 00101001b
-11101111b & 00101010b = 00101010b
-11101111b & 00101011b = 00101011b
-11101111b & 00101100b = 00101100b
-11101111b & 00101101b = 00101101b
-11101111b & 00101110b = 00101110b
-11101111b & 00101111b = 00101111b
-11101111b & 00110000b = 00100000b
-11101111b & 00110001b = 00100001b
-11101111b & 00110010b = 00100010b
-11101111b & 00110011b = 00100011b
-11101111b & 00110100b = 00100100b
-11101111b & 00110101b = 00100101b
-11101111b & 00110110b = 00100110b
-11101111b & 00110111b = 00100111b
-11101111b & 00111000b = 00101000b
-11101111b & 00111001b = 00101001b
-11101111b & 00111010b = 00101010b
-11101111b & 00111011b = 00101011b
-11101111b & 00111100b = 00101100b
-11101111b & 00111101b = 00101101b
-11101111b & 00111110b = 00101110b
-11101111b & 00111111b = 00101111b
-11101111b & 01000000b = 01000000b
-11101111b & 01000001b = 01000001b
-11101111b & 01000010b = 01000010b
-11101111b & 01000011b = 01000011b
-11101111b & 01000100b = 01000100b
-11101111b & 01000101b = 01000101b
-11101111b & 01000110b = 01000110b
-11101111b & 01000111b = 01000111b
-11101111b & 01001000b = 01001000b
-11101111b & 01001001b = 01001001b
-11101111b & 01001010b = 01001010b
-11101111b & 01001011b = 01001011b
-11101111b & 01001100b = 01001100b
-11101111b & 01001101b = 01001101b
-11101111b & 01001110b = 01001110b
-11101111b & 01001111b = 01001111b
-11101111b & 01010000b = 01000000b
-11101111b & 01010001b = 01000001b
-11101111b & 01010010b = 01000010b
-11101111b & 01010011b = 01000011b
-11101111b & 01010100b = 01000100b
-11101111b & 01010101b = 01000101b
-11101111b & 01010110b = 01000110b
-11101111b & 01010111b = 01000111b
-11101111b & 01011000b = 01001000b
-11101111b & 01011001b = 01001001b
-11101111b & 01011010b = 01001010b
-11101111b & 01011011b = 01001011b
-11101111b & 01011100b = 01001100b
-11101111b & 01011101b = 01001101b
-11101111b & 01011110b = 01001110b
-11101111b & 01011111b = 01001111b
-11101111b & 01100000b = 01100000b
-11101111b & 01100001b = 01100001b
-11101111b & 01100010b = 01100010b
-11101111b & 01100011b = 01100011b
-11101111b & 01100100b = 01100100b
-11101111b & 01100101b = 01100101b
-11101111b & 01100110b = 01100110b
-11101111b & 01100111b = 01100111b
-11101111b & 01101000b = 01101000b
-11101111b & 01101001b = 01101001b
-11101111b & 01101010b = 01101010b
-11101111b & 01101011b = 01101011b
-11101111b & 01101100b = 01101100b
-11101111b & 01101101b = 01101101b
-11101111b & 01101110b = 01101110b
-11101111b & 01101111b = 01101111b
-11101111b & 01110000b = 01100000b
-11101111b & 01110001b = 01100001b
-11101111b & 01110010b = 01100010b
-11101111b & 01110011b = 01100011b
-11101111b & 01110100b = 01100100b
-11101111b & 01110101b = 01100101b
-11101111b & 01110110b = 01100110b
-11101111b & 01110111b = 01100111b
-11101111b & 01111000b = 01101000b
-11101111b & 01111001b = 01101001b
-11101111b & 01111010b = 01101010b
-11101111b & 01111011b = 01101011b
-11101111b & 01111100b = 01101100b
-11101111b & 01111101b = 01101101b
-11101111b & 01111110b = 01101110b
-11110000b & 10000000b = 10000000b
-11110000b & 10000001b = 10000000b
-11110000b & 10000010b = 10000000b
-11110000b & 10000011b = 10000000b
-11110000b & 10000100b = 10000000b
-11110000b & 10000101b = 10000000b
-11110000b & 10000110b = 10000000b
-11110000b & 10000111b = 10000000b
-11110000b & 10001000b = 10000000b
-11110000b & 10001001b = 10000000b
-11110000b & 10001010b = 10000000b
-11110000b & 10001011b = 10000000b
-11110000b & 10001100b = 10000000b
-11110000b & 10001101b = 10000000b
-11110000b & 10001110b = 10000000b
-11110000b & 10001111b = 10000000b
-11110000b & 10010000b = 10010000b
-11110000b & 10010001b = 10010000b
-11110000b & 10010010b = 10010000b
-11110000b & 10010011b = 10010000b
-11110000b & 10010100b = 10010000b
-11110000b & 10010101b = 10010000b
-11110000b & 10010110b = 10010000b
-11110000b & 10010111b = 10010000b
-11110000b & 10011000b = 10010000b
-11110000b & 10011001b = 10010000b
-11110000b & 10011010b = 10010000b
-11110000b & 10011011b = 10010000b
-11110000b & 10011100b = 10010000b
-11110000b & 10011101b = 10010000b
-11110000b & 10011110b = 10010000b
-11110000b & 10011111b = 10010000b
-11110000b & 10100000b = 10100000b
-11110000b & 10100001b = 10100000b
-11110000b & 10100010b = 10100000b
-11110000b & 10100011b = 10100000b
-11110000b & 10100100b = 10100000b
-11110000b & 10100101b = 10100000b
-11110000b & 10100110b = 10100000b
-11110000b & 10100111b = 10100000b
-11110000b & 10101000b = 10100000b
-11110000b & 10101001b = 10100000b
-11110000b & 10101010b = 10100000b
-11110000b & 10101011b = 10100000b
-11110000b & 10101100b = 10100000b
-11110000b & 10101101b = 10100000b
-11110000b & 10101110b = 10100000b
-11110000b & 10101111b = 10100000b
-11110000b & 10110000b = 10110000b
-11110000b & 10110001b = 10110000b
-11110000b & 10110010b = 10110000b
-11110000b & 10110011b = 10110000b
-11110000b & 10110100b = 10110000b
-11110000b & 10110101b = 10110000b
-11110000b & 10110110b = 10110000b
-11110000b & 10110111b = 10110000b
-11110000b & 10111000b = 10110000b
-11110000b & 10111001b = 10110000b
-11110000b & 10111010b = 10110000b
-11110000b & 10111011b = 10110000b
-11110000b & 10111100b = 10110000b
-11110000b & 10111101b = 10110000b
-11110000b & 10111110b = 10110000b
-11110000b & 10111111b = 10110000b
-11110000b & 11000000b = 11000000b
-11110000b & 11000001b = 11000000b
-11110000b & 11000010b = 11000000b
-11110000b & 11000011b = 11000000b
-11110000b & 11000100b = 11000000b
-11110000b & 11000101b = 11000000b
-11110000b & 11000110b = 11000000b
-11110000b & 11000111b = 11000000b
-11110000b & 11001000b = 11000000b
-11110000b & 11001001b = 11000000b
-11110000b & 11001010b = 11000000b
-11110000b & 11001011b = 11000000b
-11110000b & 11001100b = 11000000b
-11110000b & 11001101b = 11000000b
-11110000b & 11001110b = 11000000b
-11110000b & 11001111b = 11000000b
-11110000b & 11010000b = 11010000b
-11110000b & 11010001b = 11010000b
-11110000b & 11010010b = 11010000b
-11110000b & 11010011b = 11010000b
-11110000b & 11010100b = 11010000b
-11110000b & 11010101b = 11010000b
-11110000b & 11010110b = 11010000b
-11110000b & 11010111b = 11010000b
-11110000b & 11011000b = 11010000b
-11110000b & 11011001b = 11010000b
-11110000b & 11011010b = 11010000b
-11110000b & 11011011b = 11010000b
-11110000b & 11011100b = 11010000b
-11110000b & 11011101b = 11010000b
-11110000b & 11011110b = 11010000b
-11110000b & 11011111b = 11010000b
-11110000b & 11100000b = 11100000b
-11110000b & 11100001b = 11100000b
-11110000b & 11100010b = 11100000b
-11110000b & 11100011b = 11100000b
-11110000b & 11100100b = 11100000b
-11110000b & 11100101b = 11100000b
-11110000b & 11100110b = 11100000b
-11110000b & 11100111b = 11100000b
-11110000b & 11101000b = 11100000b
-11110000b & 11101001b = 11100000b
-11110000b & 11101010b = 11100000b
-11110000b & 11101011b = 11100000b
-11110000b & 11101100b = 11100000b
-11110000b & 11101101b = 11100000b
-11110000b & 11101110b = 11100000b
-11110000b & 11101111b = 11100000b
-11110000b & 11110000b = 11110000b
-11110000b & 11110001b = 11110000b
-11110000b & 11110010b = 11110000b
-11110000b & 11110011b = 11110000b
-11110000b & 11110100b = 11110000b
-11110000b & 11110101b = 11110000b
-11110000b & 11110110b = 11110000b
-11110000b & 11110111b = 11110000b
-11110000b & 11111000b = 11110000b
-11110000b & 11111001b = 11110000b
-11110000b & 11111010b = 11110000b
-11110000b & 11111011b = 11110000b
-11110000b & 11111100b = 11110000b
-11110000b & 11111101b = 11110000b
-11110000b & 11111110b = 11110000b
-11110000b & 11111111b = 11110000b
-11110000b & 00000000b = 00000000b
-11110000b & 00000001b = 00000000b
-11110000b & 00000010b = 00000000b
-11110000b & 00000011b = 00000000b
-11110000b & 00000100b = 00000000b
-11110000b & 00000101b = 00000000b
-11110000b & 00000110b = 00000000b
-11110000b & 00000111b = 00000000b
-11110000b & 00001000b = 00000000b
-11110000b & 00001001b = 00000000b
-11110000b & 00001010b = 00000000b
-11110000b & 00001011b = 00000000b
-11110000b & 00001100b = 00000000b
-11110000b & 00001101b = 00000000b
-11110000b & 00001110b = 00000000b
-11110000b & 00001111b = 00000000b
-11110000b & 00010000b = 00010000b
-11110000b & 00010001b = 00010000b
-11110000b & 00010010b = 00010000b
-11110000b & 00010011b = 00010000b
-11110000b & 00010100b = 00010000b
-11110000b & 00010101b = 00010000b
-11110000b & 00010110b = 00010000b
-11110000b & 00010111b = 00010000b
-11110000b & 00011000b = 00010000b
-11110000b & 00011001b = 00010000b
-11110000b & 00011010b = 00010000b
-11110000b & 00011011b = 00010000b
-11110000b & 00011100b = 00010000b
-11110000b & 00011101b = 00010000b
-11110000b & 00011110b = 00010000b
-11110000b & 00011111b = 00010000b
-11110000b & 00100000b = 00100000b
-11110000b & 00100001b = 00100000b
-11110000b & 00100010b = 00100000b
-11110000b & 00100011b = 00100000b
-11110000b & 00100100b = 00100000b
-11110000b & 00100101b = 00100000b
-11110000b & 00100110b = 00100000b
-11110000b & 00100111b = 00100000b
-11110000b & 00101000b = 00100000b
-11110000b & 00101001b = 00100000b
-11110000b & 00101010b = 00100000b
-11110000b & 00101011b = 00100000b
-11110000b & 00101100b = 00100000b
-11110000b & 00101101b = 00100000b
-11110000b & 00101110b = 00100000b
-11110000b & 00101111b = 00100000b
-11110000b & 00110000b = 00110000b
-11110000b & 00110001b = 00110000b
-11110000b & 00110010b = 00110000b
-11110000b & 00110011b = 00110000b
-11110000b & 00110100b = 00110000b
-11110000b & 00110101b = 00110000b
-11110000b & 00110110b = 00110000b
-11110000b & 00110111b = 00110000b
-11110000b & 00111000b = 00110000b
-11110000b & 00111001b = 00110000b
-11110000b & 00111010b = 00110000b
-11110000b & 00111011b = 00110000b
-11110000b & 00111100b = 00110000b
-11110000b & 00111101b = 00110000b
-11110000b & 00111110b = 00110000b
-11110000b & 00111111b = 00110000b
-11110000b & 01000000b = 01000000b
-11110000b & 01000001b = 01000000b
-11110000b & 01000010b = 01000000b
-11110000b & 01000011b = 01000000b
-11110000b & 01000100b = 01000000b
-11110000b & 01000101b = 01000000b
-11110000b & 01000110b = 01000000b
-11110000b & 01000111b = 01000000b
-11110000b & 01001000b = 01000000b
-11110000b & 01001001b = 01000000b
-11110000b & 01001010b = 01000000b
-11110000b & 01001011b = 01000000b
-11110000b & 01001100b = 01000000b
-11110000b & 01001101b = 01000000b
-11110000b & 01001110b = 01000000b
-11110000b & 01001111b = 01000000b
-11110000b & 01010000b = 01010000b
-11110000b & 01010001b = 01010000b
-11110000b & 01010010b = 01010000b
-11110000b & 01010011b = 01010000b
-11110000b & 01010100b = 01010000b
-11110000b & 01010101b = 01010000b
-11110000b & 01010110b = 01010000b
-11110000b & 01010111b = 01010000b
-11110000b & 01011000b = 01010000b
-11110000b & 01011001b = 01010000b
-11110000b & 01011010b = 01010000b
-11110000b & 01011011b = 01010000b
-11110000b & 01011100b = 01010000b
-11110000b & 01011101b = 01010000b
-11110000b & 01011110b = 01010000b
-11110000b & 01011111b = 01010000b
-11110000b & 01100000b = 01100000b
-11110000b & 01100001b = 01100000b
-11110000b & 01100010b = 01100000b
-11110000b & 01100011b = 01100000b
-11110000b & 01100100b = 01100000b
-11110000b & 01100101b = 01100000b
-11110000b & 01100110b = 01100000b
-11110000b & 01100111b = 01100000b
-11110000b & 01101000b = 01100000b
-11110000b & 01101001b = 01100000b
-11110000b & 01101010b = 01100000b
-11110000b & 01101011b = 01100000b
-11110000b & 01101100b = 01100000b
-11110000b & 01101101b = 01100000b
-11110000b & 01101110b = 01100000b
-11110000b & 01101111b = 01100000b
-11110000b & 01110000b = 01110000b
-11110000b & 01110001b = 01110000b
-11110000b & 01110010b = 01110000b
-11110000b & 01110011b = 01110000b
-11110000b & 01110100b = 01110000b
-11110000b & 01110101b = 01110000b
-11110000b & 01110110b = 01110000b
-11110000b & 01110111b = 01110000b
-11110000b & 01111000b = 01110000b
-11110000b & 01111001b = 01110000b
-11110000b & 01111010b = 01110000b
-11110000b & 01111011b = 01110000b
-11110000b & 01111100b = 01110000b
-11110000b & 01111101b = 01110000b
-11110000b & 01111110b = 01110000b
-11110001b & 10000000b = 10000000b
-11110001b & 10000001b = 10000001b
-11110001b & 10000010b = 10000000b
-11110001b & 10000011b = 10000001b
-11110001b & 10000100b = 10000000b
-11110001b & 10000101b = 10000001b
-11110001b & 10000110b = 10000000b
-11110001b & 10000111b = 10000001b
-11110001b & 10001000b = 10000000b
-11110001b & 10001001b = 10000001b
-11110001b & 10001010b = 10000000b
-11110001b & 10001011b = 10000001b
-11110001b & 10001100b = 10000000b
-11110001b & 10001101b = 10000001b
-11110001b & 10001110b = 10000000b
-11110001b & 10001111b = 10000001b
-11110001b & 10010000b = 10010000b
-11110001b & 10010001b = 10010001b
-11110001b & 10010010b = 10010000b
-11110001b & 10010011b = 10010001b
-11110001b & 10010100b = 10010000b
-11110001b & 10010101b = 10010001b
-11110001b & 10010110b = 10010000b
-11110001b & 10010111b = 10010001b
-11110001b & 10011000b = 10010000b
-11110001b & 10011001b = 10010001b
-11110001b & 10011010b = 10010000b
-11110001b & 10011011b = 10010001b
-11110001b & 10011100b = 10010000b
-11110001b & 10011101b = 10010001b
-11110001b & 10011110b = 10010000b
-11110001b & 10011111b = 10010001b
-11110001b & 10100000b = 10100000b
-11110001b & 10100001b = 10100001b
-11110001b & 10100010b = 10100000b
-11110001b & 10100011b = 10100001b
-11110001b & 10100100b = 10100000b
-11110001b & 10100101b = 10100001b
-11110001b & 10100110b = 10100000b
-11110001b & 10100111b = 10100001b
-11110001b & 10101000b = 10100000b
-11110001b & 10101001b = 10100001b
-11110001b & 10101010b = 10100000b
-11110001b & 10101011b = 10100001b
-11110001b & 10101100b = 10100000b
-11110001b & 10101101b = 10100001b
-11110001b & 10101110b = 10100000b
-11110001b & 10101111b = 10100001b
-11110001b & 10110000b = 10110000b
-11110001b & 10110001b = 10110001b
-11110001b & 10110010b = 10110000b
-11110001b & 10110011b = 10110001b
-11110001b & 10110100b = 10110000b
-11110001b & 10110101b = 10110001b
-11110001b & 10110110b = 10110000b
-11110001b & 10110111b = 10110001b
-11110001b & 10111000b = 10110000b
-11110001b & 10111001b = 10110001b
-11110001b & 10111010b = 10110000b
-11110001b & 10111011b = 10110001b
-11110001b & 10111100b = 10110000b
-11110001b & 10111101b = 10110001b
-11110001b & 10111110b = 10110000b
-11110001b & 10111111b = 10110001b
-11110001b & 11000000b = 11000000b
-11110001b & 11000001b = 11000001b
-11110001b & 11000010b = 11000000b
-11110001b & 11000011b = 11000001b
-11110001b & 11000100b = 11000000b
-11110001b & 11000101b = 11000001b
-11110001b & 11000110b = 11000000b
-11110001b & 11000111b = 11000001b
-11110001b & 11001000b = 11000000b
-11110001b & 11001001b = 11000001b
-11110001b & 11001010b = 11000000b
-11110001b & 11001011b = 11000001b
-11110001b & 11001100b = 11000000b
-11110001b & 11001101b = 11000001b
-11110001b & 11001110b = 11000000b
-11110001b & 11001111b = 11000001b
-11110001b & 11010000b = 11010000b
-11110001b & 11010001b = 11010001b
-11110001b & 11010010b = 11010000b
-11110001b & 11010011b = 11010001b
-11110001b & 11010100b = 11010000b
-11110001b & 11010101b = 11010001b
-11110001b & 11010110b = 11010000b
-11110001b & 11010111b = 11010001b
-11110001b & 11011000b = 11010000b
-11110001b & 11011001b = 11010001b
-11110001b & 11011010b = 11010000b
-11110001b & 11011011b = 11010001b
-11110001b & 11011100b = 11010000b
-11110001b & 11011101b = 11010001b
-11110001b & 11011110b = 11010000b
-11110001b & 11011111b = 11010001b
-11110001b & 11100000b = 11100000b
-11110001b & 11100001b = 11100001b
-11110001b & 11100010b = 11100000b
-11110001b & 11100011b = 11100001b
-11110001b & 11100100b = 11100000b
-11110001b & 11100101b = 11100001b
-11110001b & 11100110b = 11100000b
-11110001b & 11100111b = 11100001b
-11110001b & 11101000b = 11100000b
-11110001b & 11101001b = 11100001b
-11110001b & 11101010b = 11100000b
-11110001b & 11101011b = 11100001b
-11110001b & 11101100b = 11100000b
-11110001b & 11101101b = 11100001b
-11110001b & 11101110b = 11100000b
-11110001b & 11101111b = 11100001b
-11110001b & 11110000b = 11110000b
-11110001b & 11110001b = 11110001b
-11110001b & 11110010b = 11110000b
-11110001b & 11110011b = 11110001b
-11110001b & 11110100b = 11110000b
-11110001b & 11110101b = 11110001b
-11110001b & 11110110b = 11110000b
-11110001b & 11110111b = 11110001b
-11110001b & 11111000b = 11110000b
-11110001b & 11111001b = 11110001b
-11110001b & 11111010b = 11110000b
-11110001b & 11111011b = 11110001b
-11110001b & 11111100b = 11110000b
-11110001b & 11111101b = 11110001b
-11110001b & 11111110b = 11110000b
-11110001b & 11111111b = 11110001b
-11110001b & 00000000b = 00000000b
-11110001b & 00000001b = 00000001b
-11110001b & 00000010b = 00000000b
-11110001b & 00000011b = 00000001b
-11110001b & 00000100b = 00000000b
-11110001b & 00000101b = 00000001b
-11110001b & 00000110b = 00000000b
-11110001b & 00000111b = 00000001b
-11110001b & 00001000b = 00000000b
-11110001b & 00001001b = 00000001b
-11110001b & 00001010b = 00000000b
-11110001b & 00001011b = 00000001b
-11110001b & 00001100b = 00000000b
-11110001b & 00001101b = 00000001b
-11110001b & 00001110b = 00000000b
-11110001b & 00001111b = 00000001b
-11110001b & 00010000b = 00010000b
-11110001b & 00010001b = 00010001b
-11110001b & 00010010b = 00010000b
-11110001b & 00010011b = 00010001b
-11110001b & 00010100b = 00010000b
-11110001b & 00010101b = 00010001b
-11110001b & 00010110b = 00010000b
-11110001b & 00010111b = 00010001b
-11110001b & 00011000b = 00010000b
-11110001b & 00011001b = 00010001b
-11110001b & 00011010b = 00010000b
-11110001b & 00011011b = 00010001b
-11110001b & 00011100b = 00010000b
-11110001b & 00011101b = 00010001b
-11110001b & 00011110b = 00010000b
-11110001b & 00011111b = 00010001b
-11110001b & 00100000b = 00100000b
-11110001b & 00100001b = 00100001b
-11110001b & 00100010b = 00100000b
-11110001b & 00100011b = 00100001b
-11110001b & 00100100b = 00100000b
-11110001b & 00100101b = 00100001b
-11110001b & 00100110b = 00100000b
-11110001b & 00100111b = 00100001b
-11110001b & 00101000b = 00100000b
-11110001b & 00101001b = 00100001b
-11110001b & 00101010b = 00100000b
-11110001b & 00101011b = 00100001b
-11110001b & 00101100b = 00100000b
-11110001b & 00101101b = 00100001b
-11110001b & 00101110b = 00100000b
-11110001b & 00101111b = 00100001b
-11110001b & 00110000b = 00110000b
-11110001b & 00110001b = 00110001b
-11110001b & 00110010b = 00110000b
-11110001b & 00110011b = 00110001b
-11110001b & 00110100b = 00110000b
-11110001b & 00110101b = 00110001b
-11110001b & 00110110b = 00110000b
-11110001b & 00110111b = 00110001b
-11110001b & 00111000b = 00110000b
-11110001b & 00111001b = 00110001b
-11110001b & 00111010b = 00110000b
-11110001b & 00111011b = 00110001b
-11110001b & 00111100b = 00110000b
-11110001b & 00111101b = 00110001b
-11110001b & 00111110b = 00110000b
-11110001b & 00111111b = 00110001b
-11110001b & 01000000b = 01000000b
-11110001b & 01000001b = 01000001b
-11110001b & 01000010b = 01000000b
-11110001b & 01000011b = 01000001b
-11110001b & 01000100b = 01000000b
-11110001b & 01000101b = 01000001b
-11110001b & 01000110b = 01000000b
-11110001b & 01000111b = 01000001b
-11110001b & 01001000b = 01000000b
-11110001b & 01001001b = 01000001b
-11110001b & 01001010b = 01000000b
-11110001b & 01001011b = 01000001b
-11110001b & 01001100b = 01000000b
-11110001b & 01001101b = 01000001b
-11110001b & 01001110b = 01000000b
-11110001b & 01001111b = 01000001b
-11110001b & 01010000b = 01010000b
-11110001b & 01010001b = 01010001b
-11110001b & 01010010b = 01010000b
-11110001b & 01010011b = 01010001b
-11110001b & 01010100b = 01010000b
-11110001b & 01010101b = 01010001b
-11110001b & 01010110b = 01010000b
-11110001b & 01010111b = 01010001b
-11110001b & 01011000b = 01010000b
-11110001b & 01011001b = 01010001b
-11110001b & 01011010b = 01010000b
-11110001b & 01011011b = 01010001b
-11110001b & 01011100b = 01010000b
-11110001b & 01011101b = 01010001b
-11110001b & 01011110b = 01010000b
-11110001b & 01011111b = 01010001b
-11110001b & 01100000b = 01100000b
-11110001b & 01100001b = 01100001b
-11110001b & 01100010b = 01100000b
-11110001b & 01100011b = 01100001b
-11110001b & 01100100b = 01100000b
-11110001b & 01100101b = 01100001b
-11110001b & 01100110b = 01100000b
-11110001b & 01100111b = 01100001b
-11110001b & 01101000b = 01100000b
-11110001b & 01101001b = 01100001b
-11110001b & 01101010b = 01100000b
-11110001b & 01101011b = 01100001b
-11110001b & 01101100b = 01100000b
-11110001b & 01101101b = 01100001b
-11110001b & 01101110b = 01100000b
-11110001b & 01101111b = 01100001b
-11110001b & 01110000b = 01110000b
-11110001b & 01110001b = 01110001b
-11110001b & 01110010b = 01110000b
-11110001b & 01110011b = 01110001b
-11110001b & 01110100b = 01110000b
-11110001b & 01110101b = 01110001b
-11110001b & 01110110b = 01110000b
-11110001b & 01110111b = 01110001b
-11110001b & 01111000b = 01110000b
-11110001b & 01111001b = 01110001b
-11110001b & 01111010b = 01110000b
-11110001b & 01111011b = 01110001b
-11110001b & 01111100b = 01110000b
-11110001b & 01111101b = 01110001b
-11110001b & 01111110b = 01110000b
-11110010b & 10000000b = 10000000b
-11110010b & 10000001b = 10000000b
-11110010b & 10000010b = 10000010b
-11110010b & 10000011b = 10000010b
-11110010b & 10000100b = 10000000b
-11110010b & 10000101b = 10000000b
-11110010b & 10000110b = 10000010b
-11110010b & 10000111b = 10000010b
-11110010b & 10001000b = 10000000b
-11110010b & 10001001b = 10000000b
-11110010b & 10001010b = 10000010b
-11110010b & 10001011b = 10000010b
-11110010b & 10001100b = 10000000b
-11110010b & 10001101b = 10000000b
-11110010b & 10001110b = 10000010b
-11110010b & 10001111b = 10000010b
-11110010b & 10010000b = 10010000b
-11110010b & 10010001b = 10010000b
-11110010b & 10010010b = 10010010b
-11110010b & 10010011b = 10010010b
-11110010b & 10010100b = 10010000b
-11110010b & 10010101b = 10010000b
-11110010b & 10010110b = 10010010b
-11110010b & 10010111b = 10010010b
-11110010b & 10011000b = 10010000b
-11110010b & 10011001b = 10010000b
-11110010b & 10011010b = 10010010b
-11110010b & 10011011b = 10010010b
-11110010b & 10011100b = 10010000b
-11110010b & 10011101b = 10010000b
-11110010b & 10011110b = 10010010b
-11110010b & 10011111b = 10010010b
-11110010b & 10100000b = 10100000b
-11110010b & 10100001b = 10100000b
-11110010b & 10100010b = 10100010b
-11110010b & 10100011b = 10100010b
-11110010b & 10100100b = 10100000b
-11110010b & 10100101b = 10100000b
-11110010b & 10100110b = 10100010b
-11110010b & 10100111b = 10100010b
-11110010b & 10101000b = 10100000b
-11110010b & 10101001b = 10100000b
-11110010b & 10101010b = 10100010b
-11110010b & 10101011b = 10100010b
-11110010b & 10101100b = 10100000b
-11110010b & 10101101b = 10100000b
-11110010b & 10101110b = 10100010b
-11110010b & 10101111b = 10100010b
-11110010b & 10110000b = 10110000b
-11110010b & 10110001b = 10110000b
-11110010b & 10110010b = 10110010b
-11110010b & 10110011b = 10110010b
-11110010b & 10110100b = 10110000b
-11110010b & 10110101b = 10110000b
-11110010b & 10110110b = 10110010b
-11110010b & 10110111b = 10110010b
-11110010b & 10111000b = 10110000b
-11110010b & 10111001b = 10110000b
-11110010b & 10111010b = 10110010b
-11110010b & 10111011b = 10110010b
-11110010b & 10111100b = 10110000b
-11110010b & 10111101b = 10110000b
-11110010b & 10111110b = 10110010b
-11110010b & 10111111b = 10110010b
-11110010b & 11000000b = 11000000b
-11110010b & 11000001b = 11000000b
-11110010b & 11000010b = 11000010b
-11110010b & 11000011b = 11000010b
-11110010b & 11000100b = 11000000b
-11110010b & 11000101b = 11000000b
-11110010b & 11000110b = 11000010b
-11110010b & 11000111b = 11000010b
-11110010b & 11001000b = 11000000b
-11110010b & 11001001b = 11000000b
-11110010b & 11001010b = 11000010b
-11110010b & 11001011b = 11000010b
-11110010b & 11001100b = 11000000b
-11110010b & 11001101b = 11000000b
-11110010b & 11001110b = 11000010b
-11110010b & 11001111b = 11000010b
-11110010b & 11010000b = 11010000b
-11110010b & 11010001b = 11010000b
-11110010b & 11010010b = 11010010b
-11110010b & 11010011b = 11010010b
-11110010b & 11010100b = 11010000b
-11110010b & 11010101b = 11010000b
-11110010b & 11010110b = 11010010b
-11110010b & 11010111b = 11010010b
-11110010b & 11011000b = 11010000b
-11110010b & 11011001b = 11010000b
-11110010b & 11011010b = 11010010b
-11110010b & 11011011b = 11010010b
-11110010b & 11011100b = 11010000b
-11110010b & 11011101b = 11010000b
-11110010b & 11011110b = 11010010b
-11110010b & 11011111b = 11010010b
-11110010b & 11100000b = 11100000b
-11110010b & 11100001b = 11100000b
-11110010b & 11100010b = 11100010b
-11110010b & 11100011b = 11100010b
-11110010b & 11100100b = 11100000b
-11110010b & 11100101b = 11100000b
-11110010b & 11100110b = 11100010b
-11110010b & 11100111b = 11100010b
-11110010b & 11101000b = 11100000b
-11110010b & 11101001b = 11100000b
-11110010b & 11101010b = 11100010b
-11110010b & 11101011b = 11100010b
-11110010b & 11101100b = 11100000b
-11110010b & 11101101b = 11100000b
-11110010b & 11101110b = 11100010b
-11110010b & 11101111b = 11100010b
-11110010b & 11110000b = 11110000b
-11110010b & 11110001b = 11110000b
-11110010b & 11110010b = 11110010b
-11110010b & 11110011b = 11110010b
-11110010b & 11110100b = 11110000b
-11110010b & 11110101b = 11110000b
-11110010b & 11110110b = 11110010b
-11110010b & 11110111b = 11110010b
-11110010b & 11111000b = 11110000b
-11110010b & 11111001b = 11110000b
-11110010b & 11111010b = 11110010b
-11110010b & 11111011b = 11110010b
-11110010b & 11111100b = 11110000b
-11110010b & 11111101b = 11110000b
-11110010b & 11111110b = 11110010b
-11110010b & 11111111b = 11110010b
-11110010b & 00000000b = 00000000b
-11110010b & 00000001b = 00000000b
-11110010b & 00000010b = 00000010b
-11110010b & 00000011b = 00000010b
-11110010b & 00000100b = 00000000b
-11110010b & 00000101b = 00000000b
-11110010b & 00000110b = 00000010b
-11110010b & 00000111b = 00000010b
-11110010b & 00001000b = 00000000b
-11110010b & 00001001b = 00000000b
-11110010b & 00001010b = 00000010b
-11110010b & 00001011b = 00000010b
-11110010b & 00001100b = 00000000b
-11110010b & 00001101b = 00000000b
-11110010b & 00001110b = 00000010b
-11110010b & 00001111b = 00000010b
-11110010b & 00010000b = 00010000b
-11110010b & 00010001b = 00010000b
-11110010b & 00010010b = 00010010b
-11110010b & 00010011b = 00010010b
-11110010b & 00010100b = 00010000b
-11110010b & 00010101b = 00010000b
-11110010b & 00010110b = 00010010b
-11110010b & 00010111b = 00010010b
-11110010b & 00011000b = 00010000b
-11110010b & 00011001b = 00010000b
-11110010b & 00011010b = 00010010b
-11110010b & 00011011b = 00010010b
-11110010b & 00011100b = 00010000b
-11110010b & 00011101b = 00010000b
-11110010b & 00011110b = 00010010b
-11110010b & 00011111b = 00010010b
-11110010b & 00100000b = 00100000b
-11110010b & 00100001b = 00100000b
-11110010b & 00100010b = 00100010b
-11110010b & 00100011b = 00100010b
-11110010b & 00100100b = 00100000b
-11110010b & 00100101b = 00100000b
-11110010b & 00100110b = 00100010b
-11110010b & 00100111b = 00100010b
-11110010b & 00101000b = 00100000b
-11110010b & 00101001b = 00100000b
-11110010b & 00101010b = 00100010b
-11110010b & 00101011b = 00100010b
-11110010b & 00101100b = 00100000b
-11110010b & 00101101b = 00100000b
-11110010b & 00101110b = 00100010b
-11110010b & 00101111b = 00100010b
-11110010b & 00110000b = 00110000b
-11110010b & 00110001b = 00110000b
-11110010b & 00110010b = 00110010b
-11110010b & 00110011b = 00110010b
-11110010b & 00110100b = 00110000b
-11110010b & 00110101b = 00110000b
-11110010b & 00110110b = 00110010b
-11110010b & 00110111b = 00110010b
-11110010b & 00111000b = 00110000b
-11110010b & 00111001b = 00110000b
-11110010b & 00111010b = 00110010b
-11110010b & 00111011b = 00110010b
-11110010b & 00111100b = 00110000b
-11110010b & 00111101b = 00110000b
-11110010b & 00111110b = 00110010b
-11110010b & 00111111b = 00110010b
-11110010b & 01000000b = 01000000b
-11110010b & 01000001b = 01000000b
-11110010b & 01000010b = 01000010b
-11110010b & 01000011b = 01000010b
-11110010b & 01000100b = 01000000b
-11110010b & 01000101b = 01000000b
-11110010b & 01000110b = 01000010b
-11110010b & 01000111b = 01000010b
-11110010b & 01001000b = 01000000b
-11110010b & 01001001b = 01000000b
-11110010b & 01001010b = 01000010b
-11110010b & 01001011b = 01000010b
-11110010b & 01001100b = 01000000b
-11110010b & 01001101b = 01000000b
-11110010b & 01001110b = 01000010b
-11110010b & 01001111b = 01000010b
-11110010b & 01010000b = 01010000b
-11110010b & 01010001b = 01010000b
-11110010b & 01010010b = 01010010b
-11110010b & 01010011b = 01010010b
-11110010b & 01010100b = 01010000b
-11110010b & 01010101b = 01010000b
-11110010b & 01010110b = 01010010b
-11110010b & 01010111b = 01010010b
-11110010b & 01011000b = 01010000b
-11110010b & 01011001b = 01010000b
-11110010b & 01011010b = 01010010b
-11110010b & 01011011b = 01010010b
-11110010b & 01011100b = 01010000b
-11110010b & 01011101b = 01010000b
-11110010b & 01011110b = 01010010b
-11110010b & 01011111b = 01010010b
-11110010b & 01100000b = 01100000b
-11110010b & 01100001b = 01100000b
-11110010b & 01100010b = 01100010b
-11110010b & 01100011b = 01100010b
-11110010b & 01100100b = 01100000b
-11110010b & 01100101b = 01100000b
-11110010b & 01100110b = 01100010b
-11110010b & 01100111b = 01100010b
-11110010b & 01101000b = 01100000b
-11110010b & 01101001b = 01100000b
-11110010b & 01101010b = 01100010b
-11110010b & 01101011b = 01100010b
-11110010b & 01101100b = 01100000b
-11110010b & 01101101b = 01100000b
-11110010b & 01101110b = 01100010b
-11110010b & 01101111b = 01100010b
-11110010b & 01110000b = 01110000b
-11110010b & 01110001b = 01110000b
-11110010b & 01110010b = 01110010b
-11110010b & 01110011b = 01110010b
-11110010b & 01110100b = 01110000b
-11110010b & 01110101b = 01110000b
-11110010b & 01110110b = 01110010b
-11110010b & 01110111b = 01110010b
-11110010b & 01111000b = 01110000b
-11110010b & 01111001b = 01110000b
-11110010b & 01111010b = 01110010b
-11110010b & 01111011b = 01110010b
-11110010b & 01111100b = 01110000b
-11110010b & 01111101b = 01110000b
-11110010b & 01111110b = 01110010b
-11110011b & 10000000b = 10000000b
-11110011b & 10000001b = 10000001b
-11110011b & 10000010b = 10000010b
-11110011b & 10000011b = 10000011b
-11110011b & 10000100b = 10000000b
-11110011b & 10000101b = 10000001b
-11110011b & 10000110b = 10000010b
-11110011b & 10000111b = 10000011b
-11110011b & 10001000b = 10000000b
-11110011b & 10001001b = 10000001b
-11110011b & 10001010b = 10000010b
-11110011b & 10001011b = 10000011b
-11110011b & 10001100b = 10000000b
-11110011b & 10001101b = 10000001b
-11110011b & 10001110b = 10000010b
-11110011b & 10001111b = 10000011b
-11110011b & 10010000b = 10010000b
-11110011b & 10010001b = 10010001b
-11110011b & 10010010b = 10010010b
-11110011b & 10010011b = 10010011b
-11110011b & 10010100b = 10010000b
-11110011b & 10010101b = 10010001b
-11110011b & 10010110b = 10010010b
-11110011b & 10010111b = 10010011b
-11110011b & 10011000b = 10010000b
-11110011b & 10011001b = 10010001b
-11110011b & 10011010b = 10010010b
-11110011b & 10011011b = 10010011b
-11110011b & 10011100b = 10010000b
-11110011b & 10011101b = 10010001b
-11110011b & 10011110b = 10010010b
-11110011b & 10011111b = 10010011b
-11110011b & 10100000b = 10100000b
-11110011b & 10100001b = 10100001b
-11110011b & 10100010b = 10100010b
-11110011b & 10100011b = 10100011b
-11110011b & 10100100b = 10100000b
-11110011b & 10100101b = 10100001b
-11110011b & 10100110b = 10100010b
-11110011b & 10100111b = 10100011b
-11110011b & 10101000b = 10100000b
-11110011b & 10101001b = 10100001b
-11110011b & 10101010b = 10100010b
-11110011b & 10101011b = 10100011b
-11110011b & 10101100b = 10100000b
-11110011b & 10101101b = 10100001b
-11110011b & 10101110b = 10100010b
-11110011b & 10101111b = 10100011b
-11110011b & 10110000b = 10110000b
-11110011b & 10110001b = 10110001b
-11110011b & 10110010b = 10110010b
-11110011b & 10110011b = 10110011b
-11110011b & 10110100b = 10110000b
-11110011b & 10110101b = 10110001b
-11110011b & 10110110b = 10110010b
-11110011b & 10110111b = 10110011b
-11110011b & 10111000b = 10110000b
-11110011b & 10111001b = 10110001b
-11110011b & 10111010b = 10110010b
-11110011b & 10111011b = 10110011b
-11110011b & 10111100b = 10110000b
-11110011b & 10111101b = 10110001b
-11110011b & 10111110b = 10110010b
-11110011b & 10111111b = 10110011b
-11110011b & 11000000b = 11000000b
-11110011b & 11000001b = 11000001b
-11110011b & 11000010b = 11000010b
-11110011b & 11000011b = 11000011b
-11110011b & 11000100b = 11000000b
-11110011b & 11000101b = 11000001b
-11110011b & 11000110b = 11000010b
-11110011b & 11000111b = 11000011b
-11110011b & 11001000b = 11000000b
-11110011b & 11001001b = 11000001b
-11110011b & 11001010b = 11000010b
-11110011b & 11001011b = 11000011b
-11110011b & 11001100b = 11000000b
-11110011b & 11001101b = 11000001b
-11110011b & 11001110b = 11000010b
-11110011b & 11001111b = 11000011b
-11110011b & 11010000b = 11010000b
-11110011b & 11010001b = 11010001b
-11110011b & 11010010b = 11010010b
-11110011b & 11010011b = 11010011b
-11110011b & 11010100b = 11010000b
-11110011b & 11010101b = 11010001b
-11110011b & 11010110b = 11010010b
-11110011b & 11010111b = 11010011b
-11110011b & 11011000b = 11010000b
-11110011b & 11011001b = 11010001b
-11110011b & 11011010b = 11010010b
-11110011b & 11011011b = 11010011b
-11110011b & 11011100b = 11010000b
-11110011b & 11011101b = 11010001b
-11110011b & 11011110b = 11010010b
-11110011b & 11011111b = 11010011b
-11110011b & 11100000b = 11100000b
-11110011b & 11100001b = 11100001b
-11110011b & 11100010b = 11100010b
-11110011b & 11100011b = 11100011b
-11110011b & 11100100b = 11100000b
-11110011b & 11100101b = 11100001b
-11110011b & 11100110b = 11100010b
-11110011b & 11100111b = 11100011b
-11110011b & 11101000b = 11100000b
-11110011b & 11101001b = 11100001b
-11110011b & 11101010b = 11100010b
-11110011b & 11101011b = 11100011b
-11110011b & 11101100b = 11100000b
-11110011b & 11101101b = 11100001b
-11110011b & 11101110b = 11100010b
-11110011b & 11101111b = 11100011b
-11110011b & 11110000b = 11110000b
-11110011b & 11110001b = 11110001b
-11110011b & 11110010b = 11110010b
-11110011b & 11110011b = 11110011b
-11110011b & 11110100b = 11110000b
-11110011b & 11110101b = 11110001b
-11110011b & 11110110b = 11110010b
-11110011b & 11110111b = 11110011b
-11110011b & 11111000b = 11110000b
-11110011b & 11111001b = 11110001b
-11110011b & 11111010b = 11110010b
-11110011b & 11111011b = 11110011b
-11110011b & 11111100b = 11110000b
-11110011b & 11111101b = 11110001b
-11110011b & 11111110b = 11110010b
-11110011b & 11111111b = 11110011b
-11110011b & 00000000b = 00000000b
-11110011b & 00000001b = 00000001b
-11110011b & 00000010b = 00000010b
-11110011b & 00000011b = 00000011b
-11110011b & 00000100b = 00000000b
-11110011b & 00000101b = 00000001b
-11110011b & 00000110b = 00000010b
-11110011b & 00000111b = 00000011b
-11110011b & 00001000b = 00000000b
-11110011b & 00001001b = 00000001b
-11110011b & 00001010b = 00000010b
-11110011b & 00001011b = 00000011b
-11110011b & 00001100b = 00000000b
-11110011b & 00001101b = 00000001b
-11110011b & 00001110b = 00000010b
-11110011b & 00001111b = 00000011b
-11110011b & 00010000b = 00010000b
-11110011b & 00010001b = 00010001b
-11110011b & 00010010b = 00010010b
-11110011b & 00010011b = 00010011b
-11110011b & 00010100b = 00010000b
-11110011b & 00010101b = 00010001b
-11110011b & 00010110b = 00010010b
-11110011b & 00010111b = 00010011b
-11110011b & 00011000b = 00010000b
-11110011b & 00011001b = 00010001b
-11110011b & 00011010b = 00010010b
-11110011b & 00011011b = 00010011b
-11110011b & 00011100b = 00010000b
-11110011b & 00011101b = 00010001b
-11110011b & 00011110b = 00010010b
-11110011b & 00011111b = 00010011b
-11110011b & 00100000b = 00100000b
-11110011b & 00100001b = 00100001b
-11110011b & 00100010b = 00100010b
-11110011b & 00100011b = 00100011b
-11110011b & 00100100b = 00100000b
-11110011b & 00100101b = 00100001b
-11110011b & 00100110b = 00100010b
-11110011b & 00100111b = 00100011b
-11110011b & 00101000b = 00100000b
-11110011b & 00101001b = 00100001b
-11110011b & 00101010b = 00100010b
-11110011b & 00101011b = 00100011b
-11110011b & 00101100b = 00100000b
-11110011b & 00101101b = 00100001b
-11110011b & 00101110b = 00100010b
-11110011b & 00101111b = 00100011b
-11110011b & 00110000b = 00110000b
-11110011b & 00110001b = 00110001b
-11110011b & 00110010b = 00110010b
-11110011b & 00110011b = 00110011b
-11110011b & 00110100b = 00110000b
-11110011b & 00110101b = 00110001b
-11110011b & 00110110b = 00110010b
-11110011b & 00110111b = 00110011b
-11110011b & 00111000b = 00110000b
-11110011b & 00111001b = 00110001b
-11110011b & 00111010b = 00110010b
-11110011b & 00111011b = 00110011b
-11110011b & 00111100b = 00110000b
-11110011b & 00111101b = 00110001b
-11110011b & 00111110b = 00110010b
-11110011b & 00111111b = 00110011b
-11110011b & 01000000b = 01000000b
-11110011b & 01000001b = 01000001b
-11110011b & 01000010b = 01000010b
-11110011b & 01000011b = 01000011b
-11110011b & 01000100b = 01000000b
-11110011b & 01000101b = 01000001b
-11110011b & 01000110b = 01000010b
-11110011b & 01000111b = 01000011b
-11110011b & 01001000b = 01000000b
-11110011b & 01001001b = 01000001b
-11110011b & 01001010b = 01000010b
-11110011b & 01001011b = 01000011b
-11110011b & 01001100b = 01000000b
-11110011b & 01001101b = 01000001b
-11110011b & 01001110b = 01000010b
-11110011b & 01001111b = 01000011b
-11110011b & 01010000b = 01010000b
-11110011b & 01010001b = 01010001b
-11110011b & 01010010b = 01010010b
-11110011b & 01010011b = 01010011b
-11110011b & 01010100b = 01010000b
-11110011b & 01010101b = 01010001b
-11110011b & 01010110b = 01010010b
-11110011b & 01010111b = 01010011b
-11110011b & 01011000b = 01010000b
-11110011b & 01011001b = 01010001b
-11110011b & 01011010b = 01010010b
-11110011b & 01011011b = 01010011b
-11110011b & 01011100b = 01010000b
-11110011b & 01011101b = 01010001b
-11110011b & 01011110b = 01010010b
-11110011b & 01011111b = 01010011b
-11110011b & 01100000b = 01100000b
-11110011b & 01100001b = 01100001b
-11110011b & 01100010b = 01100010b
-11110011b & 01100011b = 01100011b
-11110011b & 01100100b = 01100000b
-11110011b & 01100101b = 01100001b
-11110011b & 01100110b = 01100010b
-11110011b & 01100111b = 01100011b
-11110011b & 01101000b = 01100000b
-11110011b & 01101001b = 01100001b
-11110011b & 01101010b = 01100010b
-11110011b & 01101011b = 01100011b
-11110011b & 01101100b = 01100000b
-11110011b & 01101101b = 01100001b
-11110011b & 01101110b = 01100010b
-11110011b & 01101111b = 01100011b
-11110011b & 01110000b = 01110000b
-11110011b & 01110001b = 01110001b
-11110011b & 01110010b = 01110010b
-11110011b & 01110011b = 01110011b
-11110011b & 01110100b = 01110000b
-11110011b & 01110101b = 01110001b
-11110011b & 01110110b = 01110010b
-11110011b & 01110111b = 01110011b
-11110011b & 01111000b = 01110000b
-11110011b & 01111001b = 01110001b
-11110011b & 01111010b = 01110010b
-11110011b & 01111011b = 01110011b
-11110011b & 01111100b = 01110000b
-11110011b & 01111101b = 01110001b
-11110011b & 01111110b = 01110010b
-11110100b & 10000000b = 10000000b
-11110100b & 10000001b = 10000000b
-11110100b & 10000010b = 10000000b
-11110100b & 10000011b = 10000000b
-11110100b & 10000100b = 10000100b
-11110100b & 10000101b = 10000100b
-11110100b & 10000110b = 10000100b
-11110100b & 10000111b = 10000100b
-11110100b & 10001000b = 10000000b
-11110100b & 10001001b = 10000000b
-11110100b & 10001010b = 10000000b
-11110100b & 10001011b = 10000000b
-11110100b & 10001100b = 10000100b
-11110100b & 10001101b = 10000100b
-11110100b & 10001110b = 10000100b
-11110100b & 10001111b = 10000100b
-11110100b & 10010000b = 10010000b
-11110100b & 10010001b = 10010000b
-11110100b & 10010010b = 10010000b
-11110100b & 10010011b = 10010000b
-11110100b & 10010100b = 10010100b
-11110100b & 10010101b = 10010100b
-11110100b & 10010110b = 10010100b
-11110100b & 10010111b = 10010100b
-11110100b & 10011000b = 10010000b
-11110100b & 10011001b = 10010000b
-11110100b & 10011010b = 10010000b
-11110100b & 10011011b = 10010000b
-11110100b & 10011100b = 10010100b
-11110100b & 10011101b = 10010100b
-11110100b & 10011110b = 10010100b
-11110100b & 10011111b = 10010100b
-11110100b & 10100000b = 10100000b
-11110100b & 10100001b = 10100000b
-11110100b & 10100010b = 10100000b
-11110100b & 10100011b = 10100000b
-11110100b & 10100100b = 10100100b
-11110100b & 10100101b = 10100100b
-11110100b & 10100110b = 10100100b
-11110100b & 10100111b = 10100100b
-11110100b & 10101000b = 10100000b
-11110100b & 10101001b = 10100000b
-11110100b & 10101010b = 10100000b
-11110100b & 10101011b = 10100000b
-11110100b & 10101100b = 10100100b
-11110100b & 10101101b = 10100100b
-11110100b & 10101110b = 10100100b
-11110100b & 10101111b = 10100100b
-11110100b & 10110000b = 10110000b
-11110100b & 10110001b = 10110000b
-11110100b & 10110010b = 10110000b
-11110100b & 10110011b = 10110000b
-11110100b & 10110100b = 10110100b
-11110100b & 10110101b = 10110100b
-11110100b & 10110110b = 10110100b
-11110100b & 10110111b = 10110100b
-11110100b & 10111000b = 10110000b
-11110100b & 10111001b = 10110000b
-11110100b & 10111010b = 10110000b
-11110100b & 10111011b = 10110000b
-11110100b & 10111100b = 10110100b
-11110100b & 10111101b = 10110100b
-11110100b & 10111110b = 10110100b
-11110100b & 10111111b = 10110100b
-11110100b & 11000000b = 11000000b
-11110100b & 11000001b = 11000000b
-11110100b & 11000010b = 11000000b
-11110100b & 11000011b = 11000000b
-11110100b & 11000100b = 11000100b
-11110100b & 11000101b = 11000100b
-11110100b & 11000110b = 11000100b
-11110100b & 11000111b = 11000100b
-11110100b & 11001000b = 11000000b
-11110100b & 11001001b = 11000000b
-11110100b & 11001010b = 11000000b
-11110100b & 11001011b = 11000000b
-11110100b & 11001100b = 11000100b
-11110100b & 11001101b = 11000100b
-11110100b & 11001110b = 11000100b
-11110100b & 11001111b = 11000100b
-11110100b & 11010000b = 11010000b
-11110100b & 11010001b = 11010000b
-11110100b & 11010010b = 11010000b
-11110100b & 11010011b = 11010000b
-11110100b & 11010100b = 11010100b
-11110100b & 11010101b = 11010100b
-11110100b & 11010110b = 11010100b
-11110100b & 11010111b = 11010100b
-11110100b & 11011000b = 11010000b
-11110100b & 11011001b = 11010000b
-11110100b & 11011010b = 11010000b
-11110100b & 11011011b = 11010000b
-11110100b & 11011100b = 11010100b
-11110100b & 11011101b = 11010100b
-11110100b & 11011110b = 11010100b
-11110100b & 11011111b = 11010100b
-11110100b & 11100000b = 11100000b
-11110100b & 11100001b = 11100000b
-11110100b & 11100010b = 11100000b
-11110100b & 11100011b = 11100000b
-11110100b & 11100100b = 11100100b
-11110100b & 11100101b = 11100100b
-11110100b & 11100110b = 11100100b
-11110100b & 11100111b = 11100100b
-11110100b & 11101000b = 11100000b
-11110100b & 11101001b = 11100000b
-11110100b & 11101010b = 11100000b
-11110100b & 11101011b = 11100000b
-11110100b & 11101100b = 11100100b
-11110100b & 11101101b = 11100100b
-11110100b & 11101110b = 11100100b
-11110100b & 11101111b = 11100100b
-11110100b & 11110000b = 11110000b
-11110100b & 11110001b = 11110000b
-11110100b & 11110010b = 11110000b
-11110100b & 11110011b = 11110000b
-11110100b & 11110100b = 11110100b
-11110100b & 11110101b = 11110100b
-11110100b & 11110110b = 11110100b
-11110100b & 11110111b = 11110100b
-11110100b & 11111000b = 11110000b
-11110100b & 11111001b = 11110000b
-11110100b & 11111010b = 11110000b
-11110100b & 11111011b = 11110000b
-11110100b & 11111100b = 11110100b
-11110100b & 11111101b = 11110100b
-11110100b & 11111110b = 11110100b
-11110100b & 11111111b = 11110100b
-11110100b & 00000000b = 00000000b
-11110100b & 00000001b = 00000000b
-11110100b & 00000010b = 00000000b
-11110100b & 00000011b = 00000000b
-11110100b & 00000100b = 00000100b
-11110100b & 00000101b = 00000100b
-11110100b & 00000110b = 00000100b
-11110100b & 00000111b = 00000100b
-11110100b & 00001000b = 00000000b
-11110100b & 00001001b = 00000000b
-11110100b & 00001010b = 00000000b
-11110100b & 00001011b = 00000000b
-11110100b & 00001100b = 00000100b
-11110100b & 00001101b = 00000100b
-11110100b & 00001110b = 00000100b
-11110100b & 00001111b = 00000100b
-11110100b & 00010000b = 00010000b
-11110100b & 00010001b = 00010000b
-11110100b & 00010010b = 00010000b
-11110100b & 00010011b = 00010000b
-11110100b & 00010100b = 00010100b
-11110100b & 00010101b = 00010100b
-11110100b & 00010110b = 00010100b
-11110100b & 00010111b = 00010100b
-11110100b & 00011000b = 00010000b
-11110100b & 00011001b = 00010000b
-11110100b & 00011010b = 00010000b
-11110100b & 00011011b = 00010000b
-11110100b & 00011100b = 00010100b
-11110100b & 00011101b = 00010100b
-11110100b & 00011110b = 00010100b
-11110100b & 00011111b = 00010100b
-11110100b & 00100000b = 00100000b
-11110100b & 00100001b = 00100000b
-11110100b & 00100010b = 00100000b
-11110100b & 00100011b = 00100000b
-11110100b & 00100100b = 00100100b
-11110100b & 00100101b = 00100100b
-11110100b & 00100110b = 00100100b
-11110100b & 00100111b = 00100100b
-11110100b & 00101000b = 00100000b
-11110100b & 00101001b = 00100000b
-11110100b & 00101010b = 00100000b
-11110100b & 00101011b = 00100000b
-11110100b & 00101100b = 00100100b
-11110100b & 00101101b = 00100100b
-11110100b & 00101110b = 00100100b
-11110100b & 00101111b = 00100100b
-11110100b & 00110000b = 00110000b
-11110100b & 00110001b = 00110000b
-11110100b & 00110010b = 00110000b
-11110100b & 00110011b = 00110000b
-11110100b & 00110100b = 00110100b
-11110100b & 00110101b = 00110100b
-11110100b & 00110110b = 00110100b
-11110100b & 00110111b = 00110100b
-11110100b & 00111000b = 00110000b
-11110100b & 00111001b = 00110000b
-11110100b & 00111010b = 00110000b
-11110100b & 00111011b = 00110000b
-11110100b & 00111100b = 00110100b
-11110100b & 00111101b = 00110100b
-11110100b & 00111110b = 00110100b
-11110100b & 00111111b = 00110100b
-11110100b & 01000000b = 01000000b
-11110100b & 01000001b = 01000000b
-11110100b & 01000010b = 01000000b
-11110100b & 01000011b = 01000000b
-11110100b & 01000100b = 01000100b
-11110100b & 01000101b = 01000100b
-11110100b & 01000110b = 01000100b
-11110100b & 01000111b = 01000100b
-11110100b & 01001000b = 01000000b
-11110100b & 01001001b = 01000000b
-11110100b & 01001010b = 01000000b
-11110100b & 01001011b = 01000000b
-11110100b & 01001100b = 01000100b
-11110100b & 01001101b = 01000100b
-11110100b & 01001110b = 01000100b
-11110100b & 01001111b = 01000100b
-11110100b & 01010000b = 01010000b
-11110100b & 01010001b = 01010000b
-11110100b & 01010010b = 01010000b
-11110100b & 01010011b = 01010000b
-11110100b & 01010100b = 01010100b
-11110100b & 01010101b = 01010100b
-11110100b & 01010110b = 01010100b
-11110100b & 01010111b = 01010100b
-11110100b & 01011000b = 01010000b
-11110100b & 01011001b = 01010000b
-11110100b & 01011010b = 01010000b
-11110100b & 01011011b = 01010000b
-11110100b & 01011100b = 01010100b
-11110100b & 01011101b = 01010100b
-11110100b & 01011110b = 01010100b
-11110100b & 01011111b = 01010100b
-11110100b & 01100000b = 01100000b
-11110100b & 01100001b = 01100000b
-11110100b & 01100010b = 01100000b
-11110100b & 01100011b = 01100000b
-11110100b & 01100100b = 01100100b
-11110100b & 01100101b = 01100100b
-11110100b & 01100110b = 01100100b
-11110100b & 01100111b = 01100100b
-11110100b & 01101000b = 01100000b
-11110100b & 01101001b = 01100000b
-11110100b & 01101010b = 01100000b
-11110100b & 01101011b = 01100000b
-11110100b & 01101100b = 01100100b
-11110100b & 01101101b = 01100100b
-11110100b & 01101110b = 01100100b
-11110100b & 01101111b = 01100100b
-11110100b & 01110000b = 01110000b
-11110100b & 01110001b = 01110000b
-11110100b & 01110010b = 01110000b
-11110100b & 01110011b = 01110000b
-11110100b & 01110100b = 01110100b
-11110100b & 01110101b = 01110100b
-11110100b & 01110110b = 01110100b
-11110100b & 01110111b = 01110100b
-11110100b & 01111000b = 01110000b
-11110100b & 01111001b = 01110000b
-11110100b & 01111010b = 01110000b
-11110100b & 01111011b = 01110000b
-11110100b & 01111100b = 01110100b
-11110100b & 01111101b = 01110100b
-11110100b & 01111110b = 01110100b
-11110101b & 10000000b = 10000000b
-11110101b & 10000001b = 10000001b
-11110101b & 10000010b = 10000000b
-11110101b & 10000011b = 10000001b
-11110101b & 10000100b = 10000100b
-11110101b & 10000101b = 10000101b
-11110101b & 10000110b = 10000100b
-11110101b & 10000111b = 10000101b
-11110101b & 10001000b = 10000000b
-11110101b & 10001001b = 10000001b
-11110101b & 10001010b = 10000000b
-11110101b & 10001011b = 10000001b
-11110101b & 10001100b = 10000100b
-11110101b & 10001101b = 10000101b
-11110101b & 10001110b = 10000100b
-11110101b & 10001111b = 10000101b
-11110101b & 10010000b = 10010000b
-11110101b & 10010001b = 10010001b
-11110101b & 10010010b = 10010000b
-11110101b & 10010011b = 10010001b
-11110101b & 10010100b = 10010100b
-11110101b & 10010101b = 10010101b
-11110101b & 10010110b = 10010100b
-11110101b & 10010111b = 10010101b
-11110101b & 10011000b = 10010000b
-11110101b & 10011001b = 10010001b
-11110101b & 10011010b = 10010000b
-11110101b & 10011011b = 10010001b
-11110101b & 10011100b = 10010100b
-11110101b & 10011101b = 10010101b
-11110101b & 10011110b = 10010100b
-11110101b & 10011111b = 10010101b
-11110101b & 10100000b = 10100000b
-11110101b & 10100001b = 10100001b
-11110101b & 10100010b = 10100000b
-11110101b & 10100011b = 10100001b
-11110101b & 10100100b = 10100100b
-11110101b & 10100101b = 10100101b
-11110101b & 10100110b = 10100100b
-11110101b & 10100111b = 10100101b
-11110101b & 10101000b = 10100000b
-11110101b & 10101001b = 10100001b
-11110101b & 10101010b = 10100000b
-11110101b & 10101011b = 10100001b
-11110101b & 10101100b = 10100100b
-11110101b & 10101101b = 10100101b
-11110101b & 10101110b = 10100100b
-11110101b & 10101111b = 10100101b
-11110101b & 10110000b = 10110000b
-11110101b & 10110001b = 10110001b
-11110101b & 10110010b = 10110000b
-11110101b & 10110011b = 10110001b
-11110101b & 10110100b = 10110100b
-11110101b & 10110101b = 10110101b
-11110101b & 10110110b = 10110100b
-11110101b & 10110111b = 10110101b
-11110101b & 10111000b = 10110000b
-11110101b & 10111001b = 10110001b
-11110101b & 10111010b = 10110000b
-11110101b & 10111011b = 10110001b
-11110101b & 10111100b = 10110100b
-11110101b & 10111101b = 10110101b
-11110101b & 10111110b = 10110100b
-11110101b & 10111111b = 10110101b
-11110101b & 11000000b = 11000000b
-11110101b & 11000001b = 11000001b
-11110101b & 11000010b = 11000000b
-11110101b & 11000011b = 11000001b
-11110101b & 11000100b = 11000100b
-11110101b & 11000101b = 11000101b
-11110101b & 11000110b = 11000100b
-11110101b & 11000111b = 11000101b
-11110101b & 11001000b = 11000000b
-11110101b & 11001001b = 11000001b
-11110101b & 11001010b = 11000000b
-11110101b & 11001011b = 11000001b
-11110101b & 11001100b = 11000100b
-11110101b & 11001101b = 11000101b
-11110101b & 11001110b = 11000100b
-11110101b & 11001111b = 11000101b
-11110101b & 11010000b = 11010000b
-11110101b & 11010001b = 11010001b
-11110101b & 11010010b = 11010000b
-11110101b & 11010011b = 11010001b
-11110101b & 11010100b = 11010100b
-11110101b & 11010101b = 11010101b
-11110101b & 11010110b = 11010100b
-11110101b & 11010111b = 11010101b
-11110101b & 11011000b = 11010000b
-11110101b & 11011001b = 11010001b
-11110101b & 11011010b = 11010000b
-11110101b & 11011011b = 11010001b
-11110101b & 11011100b = 11010100b
-11110101b & 11011101b = 11010101b
-11110101b & 11011110b = 11010100b
-11110101b & 11011111b = 11010101b
-11110101b & 11100000b = 11100000b
-11110101b & 11100001b = 11100001b
-11110101b & 11100010b = 11100000b
-11110101b & 11100011b = 11100001b
-11110101b & 11100100b = 11100100b
-11110101b & 11100101b = 11100101b
-11110101b & 11100110b = 11100100b
-11110101b & 11100111b = 11100101b
-11110101b & 11101000b = 11100000b
-11110101b & 11101001b = 11100001b
-11110101b & 11101010b = 11100000b
-11110101b & 11101011b = 11100001b
-11110101b & 11101100b = 11100100b
-11110101b & 11101101b = 11100101b
-11110101b & 11101110b = 11100100b
-11110101b & 11101111b = 11100101b
-11110101b & 11110000b = 11110000b
-11110101b & 11110001b = 11110001b
-11110101b & 11110010b = 11110000b
-11110101b & 11110011b = 11110001b
-11110101b & 11110100b = 11110100b
-11110101b & 11110101b = 11110101b
-11110101b & 11110110b = 11110100b
-11110101b & 11110111b = 11110101b
-11110101b & 11111000b = 11110000b
-11110101b & 11111001b = 11110001b
-11110101b & 11111010b = 11110000b
-11110101b & 11111011b = 11110001b
-11110101b & 11111100b = 11110100b
-11110101b & 11111101b = 11110101b
-11110101b & 11111110b = 11110100b
-11110101b & 11111111b = 11110101b
-11110101b & 00000000b = 00000000b
-11110101b & 00000001b = 00000001b
-11110101b & 00000010b = 00000000b
-11110101b & 00000011b = 00000001b
-11110101b & 00000100b = 00000100b
-11110101b & 00000101b = 00000101b
-11110101b & 00000110b = 00000100b
-11110101b & 00000111b = 00000101b
-11110101b & 00001000b = 00000000b
-11110101b & 00001001b = 00000001b
-11110101b & 00001010b = 00000000b
-11110101b & 00001011b = 00000001b
-11110101b & 00001100b = 00000100b
-11110101b & 00001101b = 00000101b
-11110101b & 00001110b = 00000100b
-11110101b & 00001111b = 00000101b
-11110101b & 00010000b = 00010000b
-11110101b & 00010001b = 00010001b
-11110101b & 00010010b = 00010000b
-11110101b & 00010011b = 00010001b
-11110101b & 00010100b = 00010100b
-11110101b & 00010101b = 00010101b
-11110101b & 00010110b = 00010100b
-11110101b & 00010111b = 00010101b
-11110101b & 00011000b = 00010000b
-11110101b & 00011001b = 00010001b
-11110101b & 00011010b = 00010000b
-11110101b & 00011011b = 00010001b
-11110101b & 00011100b = 00010100b
-11110101b & 00011101b = 00010101b
-11110101b & 00011110b = 00010100b
-11110101b & 00011111b = 00010101b
-11110101b & 00100000b = 00100000b
-11110101b & 00100001b = 00100001b
-11110101b & 00100010b = 00100000b
-11110101b & 00100011b = 00100001b
-11110101b & 00100100b = 00100100b
-11110101b & 00100101b = 00100101b
-11110101b & 00100110b = 00100100b
-11110101b & 00100111b = 00100101b
-11110101b & 00101000b = 00100000b
-11110101b & 00101001b = 00100001b
-11110101b & 00101010b = 00100000b
-11110101b & 00101011b = 00100001b
-11110101b & 00101100b = 00100100b
-11110101b & 00101101b = 00100101b
-11110101b & 00101110b = 00100100b
-11110101b & 00101111b = 00100101b
-11110101b & 00110000b = 00110000b
-11110101b & 00110001b = 00110001b
-11110101b & 00110010b = 00110000b
-11110101b & 00110011b = 00110001b
-11110101b & 00110100b = 00110100b
-11110101b & 00110101b = 00110101b
-11110101b & 00110110b = 00110100b
-11110101b & 00110111b = 00110101b
-11110101b & 00111000b = 00110000b
-11110101b & 00111001b = 00110001b
-11110101b & 00111010b = 00110000b
-11110101b & 00111011b = 00110001b
-11110101b & 00111100b = 00110100b
-11110101b & 00111101b = 00110101b
-11110101b & 00111110b = 00110100b
-11110101b & 00111111b = 00110101b
-11110101b & 01000000b = 01000000b
-11110101b & 01000001b = 01000001b
-11110101b & 01000010b = 01000000b
-11110101b & 01000011b = 01000001b
-11110101b & 01000100b = 01000100b
-11110101b & 01000101b = 01000101b
-11110101b & 01000110b = 01000100b
-11110101b & 01000111b = 01000101b
-11110101b & 01001000b = 01000000b
-11110101b & 01001001b = 01000001b
-11110101b & 01001010b = 01000000b
-11110101b & 01001011b = 01000001b
-11110101b & 01001100b = 01000100b
-11110101b & 01001101b = 01000101b
-11110101b & 01001110b = 01000100b
-11110101b & 01001111b = 01000101b
-11110101b & 01010000b = 01010000b
-11110101b & 01010001b = 01010001b
-11110101b & 01010010b = 01010000b
-11110101b & 01010011b = 01010001b
-11110101b & 01010100b = 01010100b
-11110101b & 01010101b = 01010101b
-11110101b & 01010110b = 01010100b
-11110101b & 01010111b = 01010101b
-11110101b & 01011000b = 01010000b
-11110101b & 01011001b = 01010001b
-11110101b & 01011010b = 01010000b
-11110101b & 01011011b = 01010001b
-11110101b & 01011100b = 01010100b
-11110101b & 01011101b = 01010101b
-11110101b & 01011110b = 01010100b
-11110101b & 01011111b = 01010101b
-11110101b & 01100000b = 01100000b
-11110101b & 01100001b = 01100001b
-11110101b & 01100010b = 01100000b
-11110101b & 01100011b = 01100001b
-11110101b & 01100100b = 01100100b
-11110101b & 01100101b = 01100101b
-11110101b & 01100110b = 01100100b
-11110101b & 01100111b = 01100101b
-11110101b & 01101000b = 01100000b
-11110101b & 01101001b = 01100001b
-11110101b & 01101010b = 01100000b
-11110101b & 01101011b = 01100001b
-11110101b & 01101100b = 01100100b
-11110101b & 01101101b = 01100101b
-11110101b & 01101110b = 01100100b
-11110101b & 01101111b = 01100101b
-11110101b & 01110000b = 01110000b
-11110101b & 01110001b = 01110001b
-11110101b & 01110010b = 01110000b
-11110101b & 01110011b = 01110001b
-11110101b & 01110100b = 01110100b
-11110101b & 01110101b = 01110101b
-11110101b & 01110110b = 01110100b
-11110101b & 01110111b = 01110101b
-11110101b & 01111000b = 01110000b
-11110101b & 01111001b = 01110001b
-11110101b & 01111010b = 01110000b
-11110101b & 01111011b = 01110001b
-11110101b & 01111100b = 01110100b
-11110101b & 01111101b = 01110101b
-11110101b & 01111110b = 01110100b
-11110110b & 10000000b = 10000000b
-11110110b & 10000001b = 10000000b
-11110110b & 10000010b = 10000010b
-11110110b & 10000011b = 10000010b
-11110110b & 10000100b = 10000100b
-11110110b & 10000101b = 10000100b
-11110110b & 10000110b = 10000110b
-11110110b & 10000111b = 10000110b
-11110110b & 10001000b = 10000000b
-11110110b & 10001001b = 10000000b
-11110110b & 10001010b = 10000010b
-11110110b & 10001011b = 10000010b
-11110110b & 10001100b = 10000100b
-11110110b & 10001101b = 10000100b
-11110110b & 10001110b = 10000110b
-11110110b & 10001111b = 10000110b
-11110110b & 10010000b = 10010000b
-11110110b & 10010001b = 10010000b
-11110110b & 10010010b = 10010010b
-11110110b & 10010011b = 10010010b
-11110110b & 10010100b = 10010100b
-11110110b & 10010101b = 10010100b
-11110110b & 10010110b = 10010110b
-11110110b & 10010111b = 10010110b
-11110110b & 10011000b = 10010000b
-11110110b & 10011001b = 10010000b
-11110110b & 10011010b = 10010010b
-11110110b & 10011011b = 10010010b
-11110110b & 10011100b = 10010100b
-11110110b & 10011101b = 10010100b
-11110110b & 10011110b = 10010110b
-11110110b & 10011111b = 10010110b
-11110110b & 10100000b = 10100000b
-11110110b & 10100001b = 10100000b
-11110110b & 10100010b = 10100010b
-11110110b & 10100011b = 10100010b
-11110110b & 10100100b = 10100100b
-11110110b & 10100101b = 10100100b
-11110110b & 10100110b = 10100110b
-11110110b & 10100111b = 10100110b
-11110110b & 10101000b = 10100000b
-11110110b & 10101001b = 10100000b
-11110110b & 10101010b = 10100010b
-11110110b & 10101011b = 10100010b
-11110110b & 10101100b = 10100100b
-11110110b & 10101101b = 10100100b
-11110110b & 10101110b = 10100110b
-11110110b & 10101111b = 10100110b
-11110110b & 10110000b = 10110000b
-11110110b & 10110001b = 10110000b
-11110110b & 10110010b = 10110010b
-11110110b & 10110011b = 10110010b
-11110110b & 10110100b = 10110100b
-11110110b & 10110101b = 10110100b
-11110110b & 10110110b = 10110110b
-11110110b & 10110111b = 10110110b
-11110110b & 10111000b = 10110000b
-11110110b & 10111001b = 10110000b
-11110110b & 10111010b = 10110010b
-11110110b & 10111011b = 10110010b
-11110110b & 10111100b = 10110100b
-11110110b & 10111101b = 10110100b
-11110110b & 10111110b = 10110110b
-11110110b & 10111111b = 10110110b
-11110110b & 11000000b = 11000000b
-11110110b & 11000001b = 11000000b
-11110110b & 11000010b = 11000010b
-11110110b & 11000011b = 11000010b
-11110110b & 11000100b = 11000100b
-11110110b & 11000101b = 11000100b
-11110110b & 11000110b = 11000110b
-11110110b & 11000111b = 11000110b
-11110110b & 11001000b = 11000000b
-11110110b & 11001001b = 11000000b
-11110110b & 11001010b = 11000010b
-11110110b & 11001011b = 11000010b
-11110110b & 11001100b = 11000100b
-11110110b & 11001101b = 11000100b
-11110110b & 11001110b = 11000110b
-11110110b & 11001111b = 11000110b
-11110110b & 11010000b = 11010000b
-11110110b & 11010001b = 11010000b
-11110110b & 11010010b = 11010010b
-11110110b & 11010011b = 11010010b
-11110110b & 11010100b = 11010100b
-11110110b & 11010101b = 11010100b
-11110110b & 11010110b = 11010110b
-11110110b & 11010111b = 11010110b
-11110110b & 11011000b = 11010000b
-11110110b & 11011001b = 11010000b
-11110110b & 11011010b = 11010010b
-11110110b & 11011011b = 11010010b
-11110110b & 11011100b = 11010100b
-11110110b & 11011101b = 11010100b
-11110110b & 11011110b = 11010110b
-11110110b & 11011111b = 11010110b
-11110110b & 11100000b = 11100000b
-11110110b & 11100001b = 11100000b
-11110110b & 11100010b = 11100010b
-11110110b & 11100011b = 11100010b
-11110110b & 11100100b = 11100100b
-11110110b & 11100101b = 11100100b
-11110110b & 11100110b = 11100110b
-11110110b & 11100111b = 11100110b
-11110110b & 11101000b = 11100000b
-11110110b & 11101001b = 11100000b
-11110110b & 11101010b = 11100010b
-11110110b & 11101011b = 11100010b
-11110110b & 11101100b = 11100100b
-11110110b & 11101101b = 11100100b
-11110110b & 11101110b = 11100110b
-11110110b & 11101111b = 11100110b
-11110110b & 11110000b = 11110000b
-11110110b & 11110001b = 11110000b
-11110110b & 11110010b = 11110010b
-11110110b & 11110011b = 11110010b
-11110110b & 11110100b = 11110100b
-11110110b & 11110101b = 11110100b
-11110110b & 11110110b = 11110110b
-11110110b & 11110111b = 11110110b
-11110110b & 11111000b = 11110000b
-11110110b & 11111001b = 11110000b
-11110110b & 11111010b = 11110010b
-11110110b & 11111011b = 11110010b
-11110110b & 11111100b = 11110100b
-11110110b & 11111101b = 11110100b
-11110110b & 11111110b = 11110110b
-11110110b & 11111111b = 11110110b
-11110110b & 00000000b = 00000000b
-11110110b & 00000001b = 00000000b
-11110110b & 00000010b = 00000010b
-11110110b & 00000011b = 00000010b
-11110110b & 00000100b = 00000100b
-11110110b & 00000101b = 00000100b
-11110110b & 00000110b = 00000110b
-11110110b & 00000111b = 00000110b
-11110110b & 00001000b = 00000000b
-11110110b & 00001001b = 00000000b
-11110110b & 00001010b = 00000010b
-11110110b & 00001011b = 00000010b
-11110110b & 00001100b = 00000100b
-11110110b & 00001101b = 00000100b
-11110110b & 00001110b = 00000110b
-11110110b & 00001111b = 00000110b
-11110110b & 00010000b = 00010000b
-11110110b & 00010001b = 00010000b
-11110110b & 00010010b = 00010010b
-11110110b & 00010011b = 00010010b
-11110110b & 00010100b = 00010100b
-11110110b & 00010101b = 00010100b
-11110110b & 00010110b = 00010110b
-11110110b & 00010111b = 00010110b
-11110110b & 00011000b = 00010000b
-11110110b & 00011001b = 00010000b
-11110110b & 00011010b = 00010010b
-11110110b & 00011011b = 00010010b
-11110110b & 00011100b = 00010100b
-11110110b & 00011101b = 00010100b
-11110110b & 00011110b = 00010110b
-11110110b & 00011111b = 00010110b
-11110110b & 00100000b = 00100000b
-11110110b & 00100001b = 00100000b
-11110110b & 00100010b = 00100010b
-11110110b & 00100011b = 00100010b
-11110110b & 00100100b = 00100100b
-11110110b & 00100101b = 00100100b
-11110110b & 00100110b = 00100110b
-11110110b & 00100111b = 00100110b
-11110110b & 00101000b = 00100000b
-11110110b & 00101001b = 00100000b
-11110110b & 00101010b = 00100010b
-11110110b & 00101011b = 00100010b
-11110110b & 00101100b = 00100100b
-11110110b & 00101101b = 00100100b
-11110110b & 00101110b = 00100110b
-11110110b & 00101111b = 00100110b
-11110110b & 00110000b = 00110000b
-11110110b & 00110001b = 00110000b
-11110110b & 00110010b = 00110010b
-11110110b & 00110011b = 00110010b
-11110110b & 00110100b = 00110100b
-11110110b & 00110101b = 00110100b
-11110110b & 00110110b = 00110110b
-11110110b & 00110111b = 00110110b
-11110110b & 00111000b = 00110000b
-11110110b & 00111001b = 00110000b
-11110110b & 00111010b = 00110010b
-11110110b & 00111011b = 00110010b
-11110110b & 00111100b = 00110100b
-11110110b & 00111101b = 00110100b
-11110110b & 00111110b = 00110110b
-11110110b & 00111111b = 00110110b
-11110110b & 01000000b = 01000000b
-11110110b & 01000001b = 01000000b
-11110110b & 01000010b = 01000010b
-11110110b & 01000011b = 01000010b
-11110110b & 01000100b = 01000100b
-11110110b & 01000101b = 01000100b
-11110110b & 01000110b = 01000110b
-11110110b & 01000111b = 01000110b
-11110110b & 01001000b = 01000000b
-11110110b & 01001001b = 01000000b
-11110110b & 01001010b = 01000010b
-11110110b & 01001011b = 01000010b
-11110110b & 01001100b = 01000100b
-11110110b & 01001101b = 01000100b
-11110110b & 01001110b = 01000110b
-11110110b & 01001111b = 01000110b
-11110110b & 01010000b = 01010000b
-11110110b & 01010001b = 01010000b
-11110110b & 01010010b = 01010010b
-11110110b & 01010011b = 01010010b
-11110110b & 01010100b = 01010100b
-11110110b & 01010101b = 01010100b
-11110110b & 01010110b = 01010110b
-11110110b & 01010111b = 01010110b
-11110110b & 01011000b = 01010000b
-11110110b & 01011001b = 01010000b
-11110110b & 01011010b = 01010010b
-11110110b & 01011011b = 01010010b
-11110110b & 01011100b = 01010100b
-11110110b & 01011101b = 01010100b
-11110110b & 01011110b = 01010110b
-11110110b & 01011111b = 01010110b
-11110110b & 01100000b = 01100000b
-11110110b & 01100001b = 01100000b
-11110110b & 01100010b = 01100010b
-11110110b & 01100011b = 01100010b
-11110110b & 01100100b = 01100100b
-11110110b & 01100101b = 01100100b
-11110110b & 01100110b = 01100110b
-11110110b & 01100111b = 01100110b
-11110110b & 01101000b = 01100000b
-11110110b & 01101001b = 01100000b
-11110110b & 01101010b = 01100010b
-11110110b & 01101011b = 01100010b
-11110110b & 01101100b = 01100100b
-11110110b & 01101101b = 01100100b
-11110110b & 01101110b = 01100110b
-11110110b & 01101111b = 01100110b
-11110110b & 01110000b = 01110000b
-11110110b & 01110001b = 01110000b
-11110110b & 01110010b = 01110010b
-11110110b & 01110011b = 01110010b
-11110110b & 01110100b = 01110100b
-11110110b & 01110101b = 01110100b
-11110110b & 01110110b = 01110110b
-11110110b & 01110111b = 01110110b
-11110110b & 01111000b = 01110000b
-11110110b & 01111001b = 01110000b
-11110110b & 01111010b = 01110010b
-11110110b & 01111011b = 01110010b
-11110110b & 01111100b = 01110100b
-11110110b & 01111101b = 01110100b
-11110110b & 01111110b = 01110110b
-11110111b & 10000000b = 10000000b
-11110111b & 10000001b = 10000001b
-11110111b & 10000010b = 10000010b
-11110111b & 10000011b = 10000011b
-11110111b & 10000100b = 10000100b
-11110111b & 10000101b = 10000101b
-11110111b & 10000110b = 10000110b
-11110111b & 10000111b = 10000111b
-11110111b & 10001000b = 10000000b
-11110111b & 10001001b = 10000001b
-11110111b & 10001010b = 10000010b
-11110111b & 10001011b = 10000011b
-11110111b & 10001100b = 10000100b
-11110111b & 10001101b = 10000101b
-11110111b & 10001110b = 10000110b
-11110111b & 10001111b = 10000111b
-11110111b & 10010000b = 10010000b
-11110111b & 10010001b = 10010001b
-11110111b & 10010010b = 10010010b
-11110111b & 10010011b = 10010011b
-11110111b & 10010100b = 10010100b
-11110111b & 10010101b = 10010101b
-11110111b & 10010110b = 10010110b
-11110111b & 10010111b = 10010111b
-11110111b & 10011000b = 10010000b
-11110111b & 10011001b = 10010001b
-11110111b & 10011010b = 10010010b
-11110111b & 10011011b = 10010011b
-11110111b & 10011100b = 10010100b
-11110111b & 10011101b = 10010101b
-11110111b & 10011110b = 10010110b
-11110111b & 10011111b = 10010111b
-11110111b & 10100000b = 10100000b
-11110111b & 10100001b = 10100001b
-11110111b & 10100010b = 10100010b
-11110111b & 10100011b = 10100011b
-11110111b & 10100100b = 10100100b
-11110111b & 10100101b = 10100101b
-11110111b & 10100110b = 10100110b
-11110111b & 10100111b = 10100111b
-11110111b & 10101000b = 10100000b
-11110111b & 10101001b = 10100001b
-11110111b & 10101010b = 10100010b
-11110111b & 10101011b = 10100011b
-11110111b & 10101100b = 10100100b
-11110111b & 10101101b = 10100101b
-11110111b & 10101110b = 10100110b
-11110111b & 10101111b = 10100111b
-11110111b & 10110000b = 10110000b
-11110111b & 10110001b = 10110001b
-11110111b & 10110010b = 10110010b
-11110111b & 10110011b = 10110011b
-11110111b & 10110100b = 10110100b
-11110111b & 10110101b = 10110101b
-11110111b & 10110110b = 10110110b
-11110111b & 10110111b = 10110111b
-11110111b & 10111000b = 10110000b
-11110111b & 10111001b = 10110001b
-11110111b & 10111010b = 10110010b
-11110111b & 10111011b = 10110011b
-11110111b & 10111100b = 10110100b
-11110111b & 10111101b = 10110101b
-11110111b & 10111110b = 10110110b
-11110111b & 10111111b = 10110111b
-11110111b & 11000000b = 11000000b
-11110111b & 11000001b = 11000001b
-11110111b & 11000010b = 11000010b
-11110111b & 11000011b = 11000011b
-11110111b & 11000100b = 11000100b
-11110111b & 11000101b = 11000101b
-11110111b & 11000110b = 11000110b
-11110111b & 11000111b = 11000111b
-11110111b & 11001000b = 11000000b
-11110111b & 11001001b = 11000001b
-11110111b & 11001010b = 11000010b
-11110111b & 11001011b = 11000011b
-11110111b & 11001100b = 11000100b
-11110111b & 11001101b = 11000101b
-11110111b & 11001110b = 11000110b
-11110111b & 11001111b = 11000111b
-11110111b & 11010000b = 11010000b
-11110111b & 11010001b = 11010001b
-11110111b & 11010010b = 11010010b
-11110111b & 11010011b = 11010011b
-11110111b & 11010100b = 11010100b
-11110111b & 11010101b = 11010101b
-11110111b & 11010110b = 11010110b
-11110111b & 11010111b = 11010111b
-11110111b & 11011000b = 11010000b
-11110111b & 11011001b = 11010001b
-11110111b & 11011010b = 11010010b
-11110111b & 11011011b = 11010011b
-11110111b & 11011100b = 11010100b
-11110111b & 11011101b = 11010101b
-11110111b & 11011110b = 11010110b
-11110111b & 11011111b = 11010111b
-11110111b & 11100000b = 11100000b
-11110111b & 11100001b = 11100001b
-11110111b & 11100010b = 11100010b
-11110111b & 11100011b = 11100011b
-11110111b & 11100100b = 11100100b
-11110111b & 11100101b = 11100101b
-11110111b & 11100110b = 11100110b
-11110111b & 11100111b = 11100111b
-11110111b & 11101000b = 11100000b
-11110111b & 11101001b = 11100001b
-11110111b & 11101010b = 11100010b
-11110111b & 11101011b = 11100011b
-11110111b & 11101100b = 11100100b
-11110111b & 11101101b = 11100101b
-11110111b & 11101110b = 11100110b
-11110111b & 11101111b = 11100111b
-11110111b & 11110000b = 11110000b
-11110111b & 11110001b = 11110001b
-11110111b & 11110010b = 11110010b
-11110111b & 11110011b = 11110011b
-11110111b & 11110100b = 11110100b
-11110111b & 11110101b = 11110101b
-11110111b & 11110110b = 11110110b
-11110111b & 11110111b = 11110111b
-11110111b & 11111000b = 11110000b
-11110111b & 11111001b = 11110001b
-11110111b & 11111010b = 11110010b
-11110111b & 11111011b = 11110011b
-11110111b & 11111100b = 11110100b
-11110111b & 11111101b = 11110101b
-11110111b & 11111110b = 11110110b
-11110111b & 11111111b = 11110111b
-11110111b & 00000000b = 00000000b
-11110111b & 00000001b = 00000001b
-11110111b & 00000010b = 00000010b
-11110111b & 00000011b = 00000011b
-11110111b & 00000100b = 00000100b
-11110111b & 00000101b = 00000101b
-11110111b & 00000110b = 00000110b
-11110111b & 00000111b = 00000111b
-11110111b & 00001000b = 00000000b
-11110111b & 00001001b = 00000001b
-11110111b & 00001010b = 00000010b
-11110111b & 00001011b = 00000011b
-11110111b & 00001100b = 00000100b
-11110111b & 00001101b = 00000101b
-11110111b & 00001110b = 00000110b
-11110111b & 00001111b = 00000111b
-11110111b & 00010000b = 00010000b
-11110111b & 00010001b = 00010001b
-11110111b & 00010010b = 00010010b
-11110111b & 00010011b = 00010011b
-11110111b & 00010100b = 00010100b
-11110111b & 00010101b = 00010101b
-11110111b & 00010110b = 00010110b
-11110111b & 00010111b = 00010111b
-11110111b & 00011000b = 00010000b
-11110111b & 00011001b = 00010001b
-11110111b & 00011010b = 00010010b
-11110111b & 00011011b = 00010011b
-11110111b & 00011100b = 00010100b
-11110111b & 00011101b = 00010101b
-11110111b & 00011110b = 00010110b
-11110111b & 00011111b = 00010111b
-11110111b & 00100000b = 00100000b
-11110111b & 00100001b = 00100001b
-11110111b & 00100010b = 00100010b
-11110111b & 00100011b = 00100011b
-11110111b & 00100100b = 00100100b
-11110111b & 00100101b = 00100101b
-11110111b & 00100110b = 00100110b
-11110111b & 00100111b = 00100111b
-11110111b & 00101000b = 00100000b
-11110111b & 00101001b = 00100001b
-11110111b & 00101010b = 00100010b
-11110111b & 00101011b = 00100011b
-11110111b & 00101100b = 00100100b
-11110111b & 00101101b = 00100101b
-11110111b & 00101110b = 00100110b
-11110111b & 00101111b = 00100111b
-11110111b & 00110000b = 00110000b
-11110111b & 00110001b = 00110001b
-11110111b & 00110010b = 00110010b
-11110111b & 00110011b = 00110011b
-11110111b & 00110100b = 00110100b
-11110111b & 00110101b = 00110101b
-11110111b & 00110110b = 00110110b
-11110111b & 00110111b = 00110111b
-11110111b & 00111000b = 00110000b
-11110111b & 00111001b = 00110001b
-11110111b & 00111010b = 00110010b
-11110111b & 00111011b = 00110011b
-11110111b & 00111100b = 00110100b
-11110111b & 00111101b = 00110101b
-11110111b & 00111110b = 00110110b
-11110111b & 00111111b = 00110111b
-11110111b & 01000000b = 01000000b
-11110111b & 01000001b = 01000001b
-11110111b & 01000010b = 01000010b
-11110111b & 01000011b = 01000011b
-11110111b & 01000100b = 01000100b
-11110111b & 01000101b = 01000101b
-11110111b & 01000110b = 01000110b
-11110111b & 01000111b = 01000111b
-11110111b & 01001000b = 01000000b
-11110111b & 01001001b = 01000001b
-11110111b & 01001010b = 01000010b
-11110111b & 01001011b = 01000011b
-11110111b & 01001100b = 01000100b
-11110111b & 01001101b = 01000101b
-11110111b & 01001110b = 01000110b
-11110111b & 01001111b = 01000111b
-11110111b & 01010000b = 01010000b
-11110111b & 01010001b = 01010001b
-11110111b & 01010010b = 01010010b
-11110111b & 01010011b = 01010011b
-11110111b & 01010100b = 01010100b
-11110111b & 01010101b = 01010101b
-11110111b & 01010110b = 01010110b
-11110111b & 01010111b = 01010111b
-11110111b & 01011000b = 01010000b
-11110111b & 01011001b = 01010001b
-11110111b & 01011010b = 01010010b
-11110111b & 01011011b = 01010011b
-11110111b & 01011100b = 01010100b
-11110111b & 01011101b = 01010101b
-11110111b & 01011110b = 01010110b
-11110111b & 01011111b = 01010111b
-11110111b & 01100000b = 01100000b
-11110111b & 01100001b = 01100001b
-11110111b & 01100010b = 01100010b
-11110111b & 01100011b = 01100011b
-11110111b & 01100100b = 01100100b
-11110111b & 01100101b = 01100101b
-11110111b & 01100110b = 01100110b
-11110111b & 01100111b = 01100111b
-11110111b & 01101000b = 01100000b
-11110111b & 01101001b = 01100001b
-11110111b & 01101010b = 01100010b
-11110111b & 01101011b = 01100011b
-11110111b & 01101100b = 01100100b
-11110111b & 01101101b = 01100101b
-11110111b & 01101110b = 01100110b
-11110111b & 01101111b = 01100111b
-11110111b & 01110000b = 01110000b
-11110111b & 01110001b = 01110001b
-11110111b & 01110010b = 01110010b
-11110111b & 01110011b = 01110011b
-11110111b & 01110100b = 01110100b
-11110111b & 01110101b = 01110101b
-11110111b & 01110110b = 01110110b
-11110111b & 01110111b = 01110111b
-11110111b & 01111000b = 01110000b
-11110111b & 01111001b = 01110001b
-11110111b & 01111010b = 01110010b
-11110111b & 01111011b = 01110011b
-11110111b & 01111100b = 01110100b
-11110111b & 01111101b = 01110101b
-11110111b & 01111110b = 01110110b
-11111000b & 10000000b = 10000000b
-11111000b & 10000001b = 10000000b
-11111000b & 10000010b = 10000000b
-11111000b & 10000011b = 10000000b
-11111000b & 10000100b = 10000000b
-11111000b & 10000101b = 10000000b
-11111000b & 10000110b = 10000000b
-11111000b & 10000111b = 10000000b
-11111000b & 10001000b = 10001000b
-11111000b & 10001001b = 10001000b
-11111000b & 10001010b = 10001000b
-11111000b & 10001011b = 10001000b
-11111000b & 10001100b = 10001000b
-11111000b & 10001101b = 10001000b
-11111000b & 10001110b = 10001000b
-11111000b & 10001111b = 10001000b
-11111000b & 10010000b = 10010000b
-11111000b & 10010001b = 10010000b
-11111000b & 10010010b = 10010000b
-11111000b & 10010011b = 10010000b
-11111000b & 10010100b = 10010000b
-11111000b & 10010101b = 10010000b
-11111000b & 10010110b = 10010000b
-11111000b & 10010111b = 10010000b
-11111000b & 10011000b = 10011000b
-11111000b & 10011001b = 10011000b
-11111000b & 10011010b = 10011000b
-11111000b & 10011011b = 10011000b
-11111000b & 10011100b = 10011000b
-11111000b & 10011101b = 10011000b
-11111000b & 10011110b = 10011000b
-11111000b & 10011111b = 10011000b
-11111000b & 10100000b = 10100000b
-11111000b & 10100001b = 10100000b
-11111000b & 10100010b = 10100000b
-11111000b & 10100011b = 10100000b
-11111000b & 10100100b = 10100000b
-11111000b & 10100101b = 10100000b
-11111000b & 10100110b = 10100000b
-11111000b & 10100111b = 10100000b
-11111000b & 10101000b = 10101000b
-11111000b & 10101001b = 10101000b
-11111000b & 10101010b = 10101000b
-11111000b & 10101011b = 10101000b
-11111000b & 10101100b = 10101000b
-11111000b & 10101101b = 10101000b
-11111000b & 10101110b = 10101000b
-11111000b & 10101111b = 10101000b
-11111000b & 10110000b = 10110000b
-11111000b & 10110001b = 10110000b
-11111000b & 10110010b = 10110000b
-11111000b & 10110011b = 10110000b
-11111000b & 10110100b = 10110000b
-11111000b & 10110101b = 10110000b
-11111000b & 10110110b = 10110000b
-11111000b & 10110111b = 10110000b
-11111000b & 10111000b = 10111000b
-11111000b & 10111001b = 10111000b
-11111000b & 10111010b = 10111000b
-11111000b & 10111011b = 10111000b
-11111000b & 10111100b = 10111000b
-11111000b & 10111101b = 10111000b
-11111000b & 10111110b = 10111000b
-11111000b & 10111111b = 10111000b
-11111000b & 11000000b = 11000000b
-11111000b & 11000001b = 11000000b
-11111000b & 11000010b = 11000000b
-11111000b & 11000011b = 11000000b
-11111000b & 11000100b = 11000000b
-11111000b & 11000101b = 11000000b
-11111000b & 11000110b = 11000000b
-11111000b & 11000111b = 11000000b
-11111000b & 11001000b = 11001000b
-11111000b & 11001001b = 11001000b
-11111000b & 11001010b = 11001000b
-11111000b & 11001011b = 11001000b
-11111000b & 11001100b = 11001000b
-11111000b & 11001101b = 11001000b
-11111000b & 11001110b = 11001000b
-11111000b & 11001111b = 11001000b
-11111000b & 11010000b = 11010000b
-11111000b & 11010001b = 11010000b
-11111000b & 11010010b = 11010000b
-11111000b & 11010011b = 11010000b
-11111000b & 11010100b = 11010000b
-11111000b & 11010101b = 11010000b
-11111000b & 11010110b = 11010000b
-11111000b & 11010111b = 11010000b
-11111000b & 11011000b = 11011000b
-11111000b & 11011001b = 11011000b
-11111000b & 11011010b = 11011000b
-11111000b & 11011011b = 11011000b
-11111000b & 11011100b = 11011000b
-11111000b & 11011101b = 11011000b
-11111000b & 11011110b = 11011000b
-11111000b & 11011111b = 11011000b
-11111000b & 11100000b = 11100000b
-11111000b & 11100001b = 11100000b
-11111000b & 11100010b = 11100000b
-11111000b & 11100011b = 11100000b
-11111000b & 11100100b = 11100000b
-11111000b & 11100101b = 11100000b
-11111000b & 11100110b = 11100000b
-11111000b & 11100111b = 11100000b
-11111000b & 11101000b = 11101000b
-11111000b & 11101001b = 11101000b
-11111000b & 11101010b = 11101000b
-11111000b & 11101011b = 11101000b
-11111000b & 11101100b = 11101000b
-11111000b & 11101101b = 11101000b
-11111000b & 11101110b = 11101000b
-11111000b & 11101111b = 11101000b
-11111000b & 11110000b = 11110000b
-11111000b & 11110001b = 11110000b
-11111000b & 11110010b = 11110000b
-11111000b & 11110011b = 11110000b
-11111000b & 11110100b = 11110000b
-11111000b & 11110101b = 11110000b
-11111000b & 11110110b = 11110000b
-11111000b & 11110111b = 11110000b
-11111000b & 11111000b = 11111000b
-11111000b & 11111001b = 11111000b
-11111000b & 11111010b = 11111000b
-11111000b & 11111011b = 11111000b
-11111000b & 11111100b = 11111000b
-11111000b & 11111101b = 11111000b
-11111000b & 11111110b = 11111000b
-11111000b & 11111111b = 11111000b
-11111000b & 00000000b = 00000000b
-11111000b & 00000001b = 00000000b
-11111000b & 00000010b = 00000000b
-11111000b & 00000011b = 00000000b
-11111000b & 00000100b = 00000000b
-11111000b & 00000101b = 00000000b
-11111000b & 00000110b = 00000000b
-11111000b & 00000111b = 00000000b
-11111000b & 00001000b = 00001000b
-11111000b & 00001001b = 00001000b
-11111000b & 00001010b = 00001000b
-11111000b & 00001011b = 00001000b
-11111000b & 00001100b = 00001000b
-11111000b & 00001101b = 00001000b
-11111000b & 00001110b = 00001000b
-11111000b & 00001111b = 00001000b
-11111000b & 00010000b = 00010000b
-11111000b & 00010001b = 00010000b
-11111000b & 00010010b = 00010000b
-11111000b & 00010011b = 00010000b
-11111000b & 00010100b = 00010000b
-11111000b & 00010101b = 00010000b
-11111000b & 00010110b = 00010000b
-11111000b & 00010111b = 00010000b
-11111000b & 00011000b = 00011000b
-11111000b & 00011001b = 00011000b
-11111000b & 00011010b = 00011000b
-11111000b & 00011011b = 00011000b
-11111000b & 00011100b = 00011000b
-11111000b & 00011101b = 00011000b
-11111000b & 00011110b = 00011000b
-11111000b & 00011111b = 00011000b
-11111000b & 00100000b = 00100000b
-11111000b & 00100001b = 00100000b
-11111000b & 00100010b = 00100000b
-11111000b & 00100011b = 00100000b
-11111000b & 00100100b = 00100000b
-11111000b & 00100101b = 00100000b
-11111000b & 00100110b = 00100000b
-11111000b & 00100111b = 00100000b
-11111000b & 00101000b = 00101000b
-11111000b & 00101001b = 00101000b
-11111000b & 00101010b = 00101000b
-11111000b & 00101011b = 00101000b
-11111000b & 00101100b = 00101000b
-11111000b & 00101101b = 00101000b
-11111000b & 00101110b = 00101000b
-11111000b & 00101111b = 00101000b
-11111000b & 00110000b = 00110000b
-11111000b & 00110001b = 00110000b
-11111000b & 00110010b = 00110000b
-11111000b & 00110011b = 00110000b
-11111000b & 00110100b = 00110000b
-11111000b & 00110101b = 00110000b
-11111000b & 00110110b = 00110000b
-11111000b & 00110111b = 00110000b
-11111000b & 00111000b = 00111000b
-11111000b & 00111001b = 00111000b
-11111000b & 00111010b = 00111000b
-11111000b & 00111011b = 00111000b
-11111000b & 00111100b = 00111000b
-11111000b & 00111101b = 00111000b
-11111000b & 00111110b = 00111000b
-11111000b & 00111111b = 00111000b
-11111000b & 01000000b = 01000000b
-11111000b & 01000001b = 01000000b
-11111000b & 01000010b = 01000000b
-11111000b & 01000011b = 01000000b
-11111000b & 01000100b = 01000000b
-11111000b & 01000101b = 01000000b
-11111000b & 01000110b = 01000000b
-11111000b & 01000111b = 01000000b
-11111000b & 01001000b = 01001000b
-11111000b & 01001001b = 01001000b
-11111000b & 01001010b = 01001000b
-11111000b & 01001011b = 01001000b
-11111000b & 01001100b = 01001000b
-11111000b & 01001101b = 01001000b
-11111000b & 01001110b = 01001000b
-11111000b & 01001111b = 01001000b
-11111000b & 01010000b = 01010000b
-11111000b & 01010001b = 01010000b
-11111000b & 01010010b = 01010000b
-11111000b & 01010011b = 01010000b
-11111000b & 01010100b = 01010000b
-11111000b & 01010101b = 01010000b
-11111000b & 01010110b = 01010000b
-11111000b & 01010111b = 01010000b
-11111000b & 01011000b = 01011000b
-11111000b & 01011001b = 01011000b
-11111000b & 01011010b = 01011000b
-11111000b & 01011011b = 01011000b
-11111000b & 01011100b = 01011000b
-11111000b & 01011101b = 01011000b
-11111000b & 01011110b = 01011000b
-11111000b & 01011111b = 01011000b
-11111000b & 01100000b = 01100000b
-11111000b & 01100001b = 01100000b
-11111000b & 01100010b = 01100000b
-11111000b & 01100011b = 01100000b
-11111000b & 01100100b = 01100000b
-11111000b & 01100101b = 01100000b
-11111000b & 01100110b = 01100000b
-11111000b & 01100111b = 01100000b
-11111000b & 01101000b = 01101000b
-11111000b & 01101001b = 01101000b
-11111000b & 01101010b = 01101000b
-11111000b & 01101011b = 01101000b
-11111000b & 01101100b = 01101000b
-11111000b & 01101101b = 01101000b
-11111000b & 01101110b = 01101000b
-11111000b & 01101111b = 01101000b
-11111000b & 01110000b = 01110000b
-11111000b & 01110001b = 01110000b
-11111000b & 01110010b = 01110000b
-11111000b & 01110011b = 01110000b
-11111000b & 01110100b = 01110000b
-11111000b & 01110101b = 01110000b
-11111000b & 01110110b = 01110000b
-11111000b & 01110111b = 01110000b
-11111000b & 01111000b = 01111000b
-11111000b & 01111001b = 01111000b
-11111000b & 01111010b = 01111000b
-11111000b & 01111011b = 01111000b
-11111000b & 01111100b = 01111000b
-11111000b & 01111101b = 01111000b
-11111000b & 01111110b = 01111000b
-11111001b & 10000000b = 10000000b
-11111001b & 10000001b = 10000001b
-11111001b & 10000010b = 10000000b
-11111001b & 10000011b = 10000001b
-11111001b & 10000100b = 10000000b
-11111001b & 10000101b = 10000001b
-11111001b & 10000110b = 10000000b
-11111001b & 10000111b = 10000001b
-11111001b & 10001000b = 10001000b
-11111001b & 10001001b = 10001001b
-11111001b & 10001010b = 10001000b
-11111001b & 10001011b = 10001001b
-11111001b & 10001100b = 10001000b
-11111001b & 10001101b = 10001001b
-11111001b & 10001110b = 10001000b
-11111001b & 10001111b = 10001001b
-11111001b & 10010000b = 10010000b
-11111001b & 10010001b = 10010001b
-11111001b & 10010010b = 10010000b
-11111001b & 10010011b = 10010001b
-11111001b & 10010100b = 10010000b
-11111001b & 10010101b = 10010001b
-11111001b & 10010110b = 10010000b
-11111001b & 10010111b = 10010001b
-11111001b & 10011000b = 10011000b
-11111001b & 10011001b = 10011001b
-11111001b & 10011010b = 10011000b
-11111001b & 10011011b = 10011001b
-11111001b & 10011100b = 10011000b
-11111001b & 10011101b = 10011001b
-11111001b & 10011110b = 10011000b
-11111001b & 10011111b = 10011001b
-11111001b & 10100000b = 10100000b
-11111001b & 10100001b = 10100001b
-11111001b & 10100010b = 10100000b
-11111001b & 10100011b = 10100001b
-11111001b & 10100100b = 10100000b
-11111001b & 10100101b = 10100001b
-11111001b & 10100110b = 10100000b
-11111001b & 10100111b = 10100001b
-11111001b & 10101000b = 10101000b
-11111001b & 10101001b = 10101001b
-11111001b & 10101010b = 10101000b
-11111001b & 10101011b = 10101001b
-11111001b & 10101100b = 10101000b
-11111001b & 10101101b = 10101001b
-11111001b & 10101110b = 10101000b
-11111001b & 10101111b = 10101001b
-11111001b & 10110000b = 10110000b
-11111001b & 10110001b = 10110001b
-11111001b & 10110010b = 10110000b
-11111001b & 10110011b = 10110001b
-11111001b & 10110100b = 10110000b
-11111001b & 10110101b = 10110001b
-11111001b & 10110110b = 10110000b
-11111001b & 10110111b = 10110001b
-11111001b & 10111000b = 10111000b
-11111001b & 10111001b = 10111001b
-11111001b & 10111010b = 10111000b
-11111001b & 10111011b = 10111001b
-11111001b & 10111100b = 10111000b
-11111001b & 10111101b = 10111001b
-11111001b & 10111110b = 10111000b
-11111001b & 10111111b = 10111001b
-11111001b & 11000000b = 11000000b
-11111001b & 11000001b = 11000001b
-11111001b & 11000010b = 11000000b
-11111001b & 11000011b = 11000001b
-11111001b & 11000100b = 11000000b
-11111001b & 11000101b = 11000001b
-11111001b & 11000110b = 11000000b
-11111001b & 11000111b = 11000001b
-11111001b & 11001000b = 11001000b
-11111001b & 11001001b = 11001001b
-11111001b & 11001010b = 11001000b
-11111001b & 11001011b = 11001001b
-11111001b & 11001100b = 11001000b
-11111001b & 11001101b = 11001001b
-11111001b & 11001110b = 11001000b
-11111001b & 11001111b = 11001001b
-11111001b & 11010000b = 11010000b
-11111001b & 11010001b = 11010001b
-11111001b & 11010010b = 11010000b
-11111001b & 11010011b = 11010001b
-11111001b & 11010100b = 11010000b
-11111001b & 11010101b = 11010001b
-11111001b & 11010110b = 11010000b
-11111001b & 11010111b = 11010001b
-11111001b & 11011000b = 11011000b
-11111001b & 11011001b = 11011001b
-11111001b & 11011010b = 11011000b
-11111001b & 11011011b = 11011001b
-11111001b & 11011100b = 11011000b
-11111001b & 11011101b = 11011001b
-11111001b & 11011110b = 11011000b
-11111001b & 11011111b = 11011001b
-11111001b & 11100000b = 11100000b
-11111001b & 11100001b = 11100001b
-11111001b & 11100010b = 11100000b
-11111001b & 11100011b = 11100001b
-11111001b & 11100100b = 11100000b
-11111001b & 11100101b = 11100001b
-11111001b & 11100110b = 11100000b
-11111001b & 11100111b = 11100001b
-11111001b & 11101000b = 11101000b
-11111001b & 11101001b = 11101001b
-11111001b & 11101010b = 11101000b
-11111001b & 11101011b = 11101001b
-11111001b & 11101100b = 11101000b
-11111001b & 11101101b = 11101001b
-11111001b & 11101110b = 11101000b
-11111001b & 11101111b = 11101001b
-11111001b & 11110000b = 11110000b
-11111001b & 11110001b = 11110001b
-11111001b & 11110010b = 11110000b
-11111001b & 11110011b = 11110001b
-11111001b & 11110100b = 11110000b
-11111001b & 11110101b = 11110001b
-11111001b & 11110110b = 11110000b
-11111001b & 11110111b = 11110001b
-11111001b & 11111000b = 11111000b
-11111001b & 11111001b = 11111001b
-11111001b & 11111010b = 11111000b
-11111001b & 11111011b = 11111001b
-11111001b & 11111100b = 11111000b
-11111001b & 11111101b = 11111001b
-11111001b & 11111110b = 11111000b
-11111001b & 11111111b = 11111001b
-11111001b & 00000000b = 00000000b
-11111001b & 00000001b = 00000001b
-11111001b & 00000010b = 00000000b
-11111001b & 00000011b = 00000001b
-11111001b & 00000100b = 00000000b
-11111001b & 00000101b = 00000001b
-11111001b & 00000110b = 00000000b
-11111001b & 00000111b = 00000001b
-11111001b & 00001000b = 00001000b
-11111001b & 00001001b = 00001001b
-11111001b & 00001010b = 00001000b
-11111001b & 00001011b = 00001001b
-11111001b & 00001100b = 00001000b
-11111001b & 00001101b = 00001001b
-11111001b & 00001110b = 00001000b
-11111001b & 00001111b = 00001001b
-11111001b & 00010000b = 00010000b
-11111001b & 00010001b = 00010001b
-11111001b & 00010010b = 00010000b
-11111001b & 00010011b = 00010001b
-11111001b & 00010100b = 00010000b
-11111001b & 00010101b = 00010001b
-11111001b & 00010110b = 00010000b
-11111001b & 00010111b = 00010001b
-11111001b & 00011000b = 00011000b
-11111001b & 00011001b = 00011001b
-11111001b & 00011010b = 00011000b
-11111001b & 00011011b = 00011001b
-11111001b & 00011100b = 00011000b
-11111001b & 00011101b = 00011001b
-11111001b & 00011110b = 00011000b
-11111001b & 00011111b = 00011001b
-11111001b & 00100000b = 00100000b
-11111001b & 00100001b = 00100001b
-11111001b & 00100010b = 00100000b
-11111001b & 00100011b = 00100001b
-11111001b & 00100100b = 00100000b
-11111001b & 00100101b = 00100001b
-11111001b & 00100110b = 00100000b
-11111001b & 00100111b = 00100001b
-11111001b & 00101000b = 00101000b
-11111001b & 00101001b = 00101001b
-11111001b & 00101010b = 00101000b
-11111001b & 00101011b = 00101001b
-11111001b & 00101100b = 00101000b
-11111001b & 00101101b = 00101001b
-11111001b & 00101110b = 00101000b
-11111001b & 00101111b = 00101001b
-11111001b & 00110000b = 00110000b
-11111001b & 00110001b = 00110001b
-11111001b & 00110010b = 00110000b
-11111001b & 00110011b = 00110001b
-11111001b & 00110100b = 00110000b
-11111001b & 00110101b = 00110001b
-11111001b & 00110110b = 00110000b
-11111001b & 00110111b = 00110001b
-11111001b & 00111000b = 00111000b
-11111001b & 00111001b = 00111001b
-11111001b & 00111010b = 00111000b
-11111001b & 00111011b = 00111001b
-11111001b & 00111100b = 00111000b
-11111001b & 00111101b = 00111001b
-11111001b & 00111110b = 00111000b
-11111001b & 00111111b = 00111001b
-11111001b & 01000000b = 01000000b
-11111001b & 01000001b = 01000001b
-11111001b & 01000010b = 01000000b
-11111001b & 01000011b = 01000001b
-11111001b & 01000100b = 01000000b
-11111001b & 01000101b = 01000001b
-11111001b & 01000110b = 01000000b
-11111001b & 01000111b = 01000001b
-11111001b & 01001000b = 01001000b
-11111001b & 01001001b = 01001001b
-11111001b & 01001010b = 01001000b
-11111001b & 01001011b = 01001001b
-11111001b & 01001100b = 01001000b
-11111001b & 01001101b = 01001001b
-11111001b & 01001110b = 01001000b
-11111001b & 01001111b = 01001001b
-11111001b & 01010000b = 01010000b
-11111001b & 01010001b = 01010001b
-11111001b & 01010010b = 01010000b
-11111001b & 01010011b = 01010001b
-11111001b & 01010100b = 01010000b
-11111001b & 01010101b = 01010001b
-11111001b & 01010110b = 01010000b
-11111001b & 01010111b = 01010001b
-11111001b & 01011000b = 01011000b
-11111001b & 01011001b = 01011001b
-11111001b & 01011010b = 01011000b
-11111001b & 01011011b = 01011001b
-11111001b & 01011100b = 01011000b
-11111001b & 01011101b = 01011001b
-11111001b & 01011110b = 01011000b
-11111001b & 01011111b = 01011001b
-11111001b & 01100000b = 01100000b
-11111001b & 01100001b = 01100001b
-11111001b & 01100010b = 01100000b
-11111001b & 01100011b = 01100001b
-11111001b & 01100100b = 01100000b
-11111001b & 01100101b = 01100001b
-11111001b & 01100110b = 01100000b
-11111001b & 01100111b = 01100001b
-11111001b & 01101000b = 01101000b
-11111001b & 01101001b = 01101001b
-11111001b & 01101010b = 01101000b
-11111001b & 01101011b = 01101001b
-11111001b & 01101100b = 01101000b
-11111001b & 01101101b = 01101001b
-11111001b & 01101110b = 01101000b
-11111001b & 01101111b = 01101001b
-11111001b & 01110000b = 01110000b
-11111001b & 01110001b = 01110001b
-11111001b & 01110010b = 01110000b
-11111001b & 01110011b = 01110001b
-11111001b & 01110100b = 01110000b
-11111001b & 01110101b = 01110001b
-11111001b & 01110110b = 01110000b
-11111001b & 01110111b = 01110001b
-11111001b & 01111000b = 01111000b
-11111001b & 01111001b = 01111001b
-11111001b & 01111010b = 01111000b
-11111001b & 01111011b = 01111001b
-11111001b & 01111100b = 01111000b
-11111001b & 01111101b = 01111001b
-11111001b & 01111110b = 01111000b
-11111010b & 10000000b = 10000000b
-11111010b & 10000001b = 10000000b
-11111010b & 10000010b = 10000010b
-11111010b & 10000011b = 10000010b
-11111010b & 10000100b = 10000000b
-11111010b & 10000101b = 10000000b
-11111010b & 10000110b = 10000010b
-11111010b & 10000111b = 10000010b
-11111010b & 10001000b = 10001000b
-11111010b & 10001001b = 10001000b
-11111010b & 10001010b = 10001010b
-11111010b & 10001011b = 10001010b
-11111010b & 10001100b = 10001000b
-11111010b & 10001101b = 10001000b
-11111010b & 10001110b = 10001010b
-11111010b & 10001111b = 10001010b
-11111010b & 10010000b = 10010000b
-11111010b & 10010001b = 10010000b
-11111010b & 10010010b = 10010010b
-11111010b & 10010011b = 10010010b
-11111010b & 10010100b = 10010000b
-11111010b & 10010101b = 10010000b
-11111010b & 10010110b = 10010010b
-11111010b & 10010111b = 10010010b
-11111010b & 10011000b = 10011000b
-11111010b & 10011001b = 10011000b
-11111010b & 10011010b = 10011010b
-11111010b & 10011011b = 10011010b
-11111010b & 10011100b = 10011000b
-11111010b & 10011101b = 10011000b
-11111010b & 10011110b = 10011010b
-11111010b & 10011111b = 10011010b
-11111010b & 10100000b = 10100000b
-11111010b & 10100001b = 10100000b
-11111010b & 10100010b = 10100010b
-11111010b & 10100011b = 10100010b
-11111010b & 10100100b = 10100000b
-11111010b & 10100101b = 10100000b
-11111010b & 10100110b = 10100010b
-11111010b & 10100111b = 10100010b
-11111010b & 10101000b = 10101000b
-11111010b & 10101001b = 10101000b
-11111010b & 10101010b = 10101010b
-11111010b & 10101011b = 10101010b
-11111010b & 10101100b = 10101000b
-11111010b & 10101101b = 10101000b
-11111010b & 10101110b = 10101010b
-11111010b & 10101111b = 10101010b
-11111010b & 10110000b = 10110000b
-11111010b & 10110001b = 10110000b
-11111010b & 10110010b = 10110010b
-11111010b & 10110011b = 10110010b
-11111010b & 10110100b = 10110000b
-11111010b & 10110101b = 10110000b
-11111010b & 10110110b = 10110010b
-11111010b & 10110111b = 10110010b
-11111010b & 10111000b = 10111000b
-11111010b & 10111001b = 10111000b
-11111010b & 10111010b = 10111010b
-11111010b & 10111011b = 10111010b
-11111010b & 10111100b = 10111000b
-11111010b & 10111101b = 10111000b
-11111010b & 10111110b = 10111010b
-11111010b & 10111111b = 10111010b
-11111010b & 11000000b = 11000000b
-11111010b & 11000001b = 11000000b
-11111010b & 11000010b = 11000010b
-11111010b & 11000011b = 11000010b
-11111010b & 11000100b = 11000000b
-11111010b & 11000101b = 11000000b
-11111010b & 11000110b = 11000010b
-11111010b & 11000111b = 11000010b
-11111010b & 11001000b = 11001000b
-11111010b & 11001001b = 11001000b
-11111010b & 11001010b = 11001010b
-11111010b & 11001011b = 11001010b
-11111010b & 11001100b = 11001000b
-11111010b & 11001101b = 11001000b
-11111010b & 11001110b = 11001010b
-11111010b & 11001111b = 11001010b
-11111010b & 11010000b = 11010000b
-11111010b & 11010001b = 11010000b
-11111010b & 11010010b = 11010010b
-11111010b & 11010011b = 11010010b
-11111010b & 11010100b = 11010000b
-11111010b & 11010101b = 11010000b
-11111010b & 11010110b = 11010010b
-11111010b & 11010111b = 11010010b
-11111010b & 11011000b = 11011000b
-11111010b & 11011001b = 11011000b
-11111010b & 11011010b = 11011010b
-11111010b & 11011011b = 11011010b
-11111010b & 11011100b = 11011000b
-11111010b & 11011101b = 11011000b
-11111010b & 11011110b = 11011010b
-11111010b & 11011111b = 11011010b
-11111010b & 11100000b = 11100000b
-11111010b & 11100001b = 11100000b
-11111010b & 11100010b = 11100010b
-11111010b & 11100011b = 11100010b
-11111010b & 11100100b = 11100000b
-11111010b & 11100101b = 11100000b
-11111010b & 11100110b = 11100010b
-11111010b & 11100111b = 11100010b
-11111010b & 11101000b = 11101000b
-11111010b & 11101001b = 11101000b
-11111010b & 11101010b = 11101010b
-11111010b & 11101011b = 11101010b
-11111010b & 11101100b = 11101000b
-11111010b & 11101101b = 11101000b
-11111010b & 11101110b = 11101010b
-11111010b & 11101111b = 11101010b
-11111010b & 11110000b = 11110000b
-11111010b & 11110001b = 11110000b
-11111010b & 11110010b = 11110010b
-11111010b & 11110011b = 11110010b
-11111010b & 11110100b = 11110000b
-11111010b & 11110101b = 11110000b
-11111010b & 11110110b = 11110010b
-11111010b & 11110111b = 11110010b
-11111010b & 11111000b = 11111000b
-11111010b & 11111001b = 11111000b
-11111010b & 11111010b = 11111010b
-11111010b & 11111011b = 11111010b
-11111010b & 11111100b = 11111000b
-11111010b & 11111101b = 11111000b
-11111010b & 11111110b = 11111010b
-11111010b & 11111111b = 11111010b
-11111010b & 00000000b = 00000000b
-11111010b & 00000001b = 00000000b
-11111010b & 00000010b = 00000010b
-11111010b & 00000011b = 00000010b
-11111010b & 00000100b = 00000000b
-11111010b & 00000101b = 00000000b
-11111010b & 00000110b = 00000010b
-11111010b & 00000111b = 00000010b
-11111010b & 00001000b = 00001000b
-11111010b & 00001001b = 00001000b
-11111010b & 00001010b = 00001010b
-11111010b & 00001011b = 00001010b
-11111010b & 00001100b = 00001000b
-11111010b & 00001101b = 00001000b
-11111010b & 00001110b = 00001010b
-11111010b & 00001111b = 00001010b
-11111010b & 00010000b = 00010000b
-11111010b & 00010001b = 00010000b
-11111010b & 00010010b = 00010010b
-11111010b & 00010011b = 00010010b
-11111010b & 00010100b = 00010000b
-11111010b & 00010101b = 00010000b
-11111010b & 00010110b = 00010010b
-11111010b & 00010111b = 00010010b
-11111010b & 00011000b = 00011000b
-11111010b & 00011001b = 00011000b
-11111010b & 00011010b = 00011010b
-11111010b & 00011011b = 00011010b
-11111010b & 00011100b = 00011000b
-11111010b & 00011101b = 00011000b
-11111010b & 00011110b = 00011010b
-11111010b & 00011111b = 00011010b
-11111010b & 00100000b = 00100000b
-11111010b & 00100001b = 00100000b
-11111010b & 00100010b = 00100010b
-11111010b & 00100011b = 00100010b
-11111010b & 00100100b = 00100000b
-11111010b & 00100101b = 00100000b
-11111010b & 00100110b = 00100010b
-11111010b & 00100111b = 00100010b
-11111010b & 00101000b = 00101000b
-11111010b & 00101001b = 00101000b
-11111010b & 00101010b = 00101010b
-11111010b & 00101011b = 00101010b
-11111010b & 00101100b = 00101000b
-11111010b & 00101101b = 00101000b
-11111010b & 00101110b = 00101010b
-11111010b & 00101111b = 00101010b
-11111010b & 00110000b = 00110000b
-11111010b & 00110001b = 00110000b
-11111010b & 00110010b = 00110010b
-11111010b & 00110011b = 00110010b
-11111010b & 00110100b = 00110000b
-11111010b & 00110101b = 00110000b
-11111010b & 00110110b = 00110010b
-11111010b & 00110111b = 00110010b
-11111010b & 00111000b = 00111000b
-11111010b & 00111001b = 00111000b
-11111010b & 00111010b = 00111010b
-11111010b & 00111011b = 00111010b
-11111010b & 00111100b = 00111000b
-11111010b & 00111101b = 00111000b
-11111010b & 00111110b = 00111010b
-11111010b & 00111111b = 00111010b
-11111010b & 01000000b = 01000000b
-11111010b & 01000001b = 01000000b
-11111010b & 01000010b = 01000010b
-11111010b & 01000011b = 01000010b
-11111010b & 01000100b = 01000000b
-11111010b & 01000101b = 01000000b
-11111010b & 01000110b = 01000010b
-11111010b & 01000111b = 01000010b
-11111010b & 01001000b = 01001000b
-11111010b & 01001001b = 01001000b
-11111010b & 01001010b = 01001010b
-11111010b & 01001011b = 01001010b
-11111010b & 01001100b = 01001000b
-11111010b & 01001101b = 01001000b
-11111010b & 01001110b = 01001010b
-11111010b & 01001111b = 01001010b
-11111010b & 01010000b = 01010000b
-11111010b & 01010001b = 01010000b
-11111010b & 01010010b = 01010010b
-11111010b & 01010011b = 01010010b
-11111010b & 01010100b = 01010000b
-11111010b & 01010101b = 01010000b
-11111010b & 01010110b = 01010010b
-11111010b & 01010111b = 01010010b
-11111010b & 01011000b = 01011000b
-11111010b & 01011001b = 01011000b
-11111010b & 01011010b = 01011010b
-11111010b & 01011011b = 01011010b
-11111010b & 01011100b = 01011000b
-11111010b & 01011101b = 01011000b
-11111010b & 01011110b = 01011010b
-11111010b & 01011111b = 01011010b
-11111010b & 01100000b = 01100000b
-11111010b & 01100001b = 01100000b
-11111010b & 01100010b = 01100010b
-11111010b & 01100011b = 01100010b
-11111010b & 01100100b = 01100000b
-11111010b & 01100101b = 01100000b
-11111010b & 01100110b = 01100010b
-11111010b & 01100111b = 01100010b
-11111010b & 01101000b = 01101000b
-11111010b & 01101001b = 01101000b
-11111010b & 01101010b = 01101010b
-11111010b & 01101011b = 01101010b
-11111010b & 01101100b = 01101000b
-11111010b & 01101101b = 01101000b
-11111010b & 01101110b = 01101010b
-11111010b & 01101111b = 01101010b
-11111010b & 01110000b = 01110000b
-11111010b & 01110001b = 01110000b
-11111010b & 01110010b = 01110010b
-11111010b & 01110011b = 01110010b
-11111010b & 01110100b = 01110000b
-11111010b & 01110101b = 01110000b
-11111010b & 01110110b = 01110010b
-11111010b & 01110111b = 01110010b
-11111010b & 01111000b = 01111000b
-11111010b & 01111001b = 01111000b
-11111010b & 01111010b = 01111010b
-11111010b & 01111011b = 01111010b
-11111010b & 01111100b = 01111000b
-11111010b & 01111101b = 01111000b
-11111010b & 01111110b = 01111010b
-11111011b & 10000000b = 10000000b
-11111011b & 10000001b = 10000001b
-11111011b & 10000010b = 10000010b
-11111011b & 10000011b = 10000011b
-11111011b & 10000100b = 10000000b
-11111011b & 10000101b = 10000001b
-11111011b & 10000110b = 10000010b
-11111011b & 10000111b = 10000011b
-11111011b & 10001000b = 10001000b
-11111011b & 10001001b = 10001001b
-11111011b & 10001010b = 10001010b
-11111011b & 10001011b = 10001011b
-11111011b & 10001100b = 10001000b
-11111011b & 10001101b = 10001001b
-11111011b & 10001110b = 10001010b
-11111011b & 10001111b = 10001011b
-11111011b & 10010000b = 10010000b
-11111011b & 10010001b = 10010001b
-11111011b & 10010010b = 10010010b
-11111011b & 10010011b = 10010011b
-11111011b & 10010100b = 10010000b
-11111011b & 10010101b = 10010001b
-11111011b & 10010110b = 10010010b
-11111011b & 10010111b = 10010011b
-11111011b & 10011000b = 10011000b
-11111011b & 10011001b = 10011001b
-11111011b & 10011010b = 10011010b
-11111011b & 10011011b = 10011011b
-11111011b & 10011100b = 10011000b
-11111011b & 10011101b = 10011001b
-11111011b & 10011110b = 10011010b
-11111011b & 10011111b = 10011011b
-11111011b & 10100000b = 10100000b
-11111011b & 10100001b = 10100001b
-11111011b & 10100010b = 10100010b
-11111011b & 10100011b = 10100011b
-11111011b & 10100100b = 10100000b
-11111011b & 10100101b = 10100001b
-11111011b & 10100110b = 10100010b
-11111011b & 10100111b = 10100011b
-11111011b & 10101000b = 10101000b
-11111011b & 10101001b = 10101001b
-11111011b & 10101010b = 10101010b
-11111011b & 10101011b = 10101011b
-11111011b & 10101100b = 10101000b
-11111011b & 10101101b = 10101001b
-11111011b & 10101110b = 10101010b
-11111011b & 10101111b = 10101011b
-11111011b & 10110000b = 10110000b
-11111011b & 10110001b = 10110001b
-11111011b & 10110010b = 10110010b
-11111011b & 10110011b = 10110011b
-11111011b & 10110100b = 10110000b
-11111011b & 10110101b = 10110001b
-11111011b & 10110110b = 10110010b
-11111011b & 10110111b = 10110011b
-11111011b & 10111000b = 10111000b
-11111011b & 10111001b = 10111001b
-11111011b & 10111010b = 10111010b
-11111011b & 10111011b = 10111011b
-11111011b & 10111100b = 10111000b
-11111011b & 10111101b = 10111001b
-11111011b & 10111110b = 10111010b
-11111011b & 10111111b = 10111011b
-11111011b & 11000000b = 11000000b
-11111011b & 11000001b = 11000001b
-11111011b & 11000010b = 11000010b
-11111011b & 11000011b = 11000011b
-11111011b & 11000100b = 11000000b
-11111011b & 11000101b = 11000001b
-11111011b & 11000110b = 11000010b
-11111011b & 11000111b = 11000011b
-11111011b & 11001000b = 11001000b
-11111011b & 11001001b = 11001001b
-11111011b & 11001010b = 11001010b
-11111011b & 11001011b = 11001011b
-11111011b & 11001100b = 11001000b
-11111011b & 11001101b = 11001001b
-11111011b & 11001110b = 11001010b
-11111011b & 11001111b = 11001011b
-11111011b & 11010000b = 11010000b
-11111011b & 11010001b = 11010001b
-11111011b & 11010010b = 11010010b
-11111011b & 11010011b = 11010011b
-11111011b & 11010100b = 11010000b
-11111011b & 11010101b = 11010001b
-11111011b & 11010110b = 11010010b
-11111011b & 11010111b = 11010011b
-11111011b & 11011000b = 11011000b
-11111011b & 11011001b = 11011001b
-11111011b & 11011010b = 11011010b
-11111011b & 11011011b = 11011011b
-11111011b & 11011100b = 11011000b
-11111011b & 11011101b = 11011001b
-11111011b & 11011110b = 11011010b
-11111011b & 11011111b = 11011011b
-11111011b & 11100000b = 11100000b
-11111011b & 11100001b = 11100001b
-11111011b & 11100010b = 11100010b
-11111011b & 11100011b = 11100011b
-11111011b & 11100100b = 11100000b
-11111011b & 11100101b = 11100001b
-11111011b & 11100110b = 11100010b
-11111011b & 11100111b = 11100011b
-11111011b & 11101000b = 11101000b
-11111011b & 11101001b = 11101001b
-11111011b & 11101010b = 11101010b
-11111011b & 11101011b = 11101011b
-11111011b & 11101100b = 11101000b
-11111011b & 11101101b = 11101001b
-11111011b & 11101110b = 11101010b
-11111011b & 11101111b = 11101011b
-11111011b & 11110000b = 11110000b
-11111011b & 11110001b = 11110001b
-11111011b & 11110010b = 11110010b
-11111011b & 11110011b = 11110011b
-11111011b & 11110100b = 11110000b
-11111011b & 11110101b = 11110001b
-11111011b & 11110110b = 11110010b
-11111011b & 11110111b = 11110011b
-11111011b & 11111000b = 11111000b
-11111011b & 11111001b = 11111001b
-11111011b & 11111010b = 11111010b
-11111011b & 11111011b = 11111011b
-11111011b & 11111100b = 11111000b
-11111011b & 11111101b = 11111001b
-11111011b & 11111110b = 11111010b
-11111011b & 11111111b = 11111011b
-11111011b & 00000000b = 00000000b
-11111011b & 00000001b = 00000001b
-11111011b & 00000010b = 00000010b
-11111011b & 00000011b = 00000011b
-11111011b & 00000100b = 00000000b
-11111011b & 00000101b = 00000001b
-11111011b & 00000110b = 00000010b
-11111011b & 00000111b = 00000011b
-11111011b & 00001000b = 00001000b
-11111011b & 00001001b = 00001001b
-11111011b & 00001010b = 00001010b
-11111011b & 00001011b = 00001011b
-11111011b & 00001100b = 00001000b
-11111011b & 00001101b = 00001001b
-11111011b & 00001110b = 00001010b
-11111011b & 00001111b = 00001011b
-11111011b & 00010000b = 00010000b
-11111011b & 00010001b = 00010001b
-11111011b & 00010010b = 00010010b
-11111011b & 00010011b = 00010011b
-11111011b & 00010100b = 00010000b
-11111011b & 00010101b = 00010001b
-11111011b & 00010110b = 00010010b
-11111011b & 00010111b = 00010011b
-11111011b & 00011000b = 00011000b
-11111011b & 00011001b = 00011001b
-11111011b & 00011010b = 00011010b
-11111011b & 00011011b = 00011011b
-11111011b & 00011100b = 00011000b
-11111011b & 00011101b = 00011001b
-11111011b & 00011110b = 00011010b
-11111011b & 00011111b = 00011011b
-11111011b & 00100000b = 00100000b
-11111011b & 00100001b = 00100001b
-11111011b & 00100010b = 00100010b
-11111011b & 00100011b = 00100011b
-11111011b & 00100100b = 00100000b
-11111011b & 00100101b = 00100001b
-11111011b & 00100110b = 00100010b
-11111011b & 00100111b = 00100011b
-11111011b & 00101000b = 00101000b
-11111011b & 00101001b = 00101001b
-11111011b & 00101010b = 00101010b
-11111011b & 00101011b = 00101011b
-11111011b & 00101100b = 00101000b
-11111011b & 00101101b = 00101001b
-11111011b & 00101110b = 00101010b
-11111011b & 00101111b = 00101011b
-11111011b & 00110000b = 00110000b
-11111011b & 00110001b = 00110001b
-11111011b & 00110010b = 00110010b
-11111011b & 00110011b = 00110011b
-11111011b & 00110100b = 00110000b
-11111011b & 00110101b = 00110001b
-11111011b & 00110110b = 00110010b
-11111011b & 00110111b = 00110011b
-11111011b & 00111000b = 00111000b
-11111011b & 00111001b = 00111001b
-11111011b & 00111010b = 00111010b
-11111011b & 00111011b = 00111011b
-11111011b & 00111100b = 00111000b
-11111011b & 00111101b = 00111001b
-11111011b & 00111110b = 00111010b
-11111011b & 00111111b = 00111011b
-11111011b & 01000000b = 01000000b
-11111011b & 01000001b = 01000001b
-11111011b & 01000010b = 01000010b
-11111011b & 01000011b = 01000011b
-11111011b & 01000100b = 01000000b
-11111011b & 01000101b = 01000001b
-11111011b & 01000110b = 01000010b
-11111011b & 01000111b = 01000011b
-11111011b & 01001000b = 01001000b
-11111011b & 01001001b = 01001001b
-11111011b & 01001010b = 01001010b
-11111011b & 01001011b = 01001011b
-11111011b & 01001100b = 01001000b
-11111011b & 01001101b = 01001001b
-11111011b & 01001110b = 01001010b
-11111011b & 01001111b = 01001011b
-11111011b & 01010000b = 01010000b
-11111011b & 01010001b = 01010001b
-11111011b & 01010010b = 01010010b
-11111011b & 01010011b = 01010011b
-11111011b & 01010100b = 01010000b
-11111011b & 01010101b = 01010001b
-11111011b & 01010110b = 01010010b
-11111011b & 01010111b = 01010011b
-11111011b & 01011000b = 01011000b
-11111011b & 01011001b = 01011001b
-11111011b & 01011010b = 01011010b
-11111011b & 01011011b = 01011011b
-11111011b & 01011100b = 01011000b
-11111011b & 01011101b = 01011001b
-11111011b & 01011110b = 01011010b
-11111011b & 01011111b = 01011011b
-11111011b & 01100000b = 01100000b
-11111011b & 01100001b = 01100001b
-11111011b & 01100010b = 01100010b
-11111011b & 01100011b = 01100011b
-11111011b & 01100100b = 01100000b
-11111011b & 01100101b = 01100001b
-11111011b & 01100110b = 01100010b
-11111011b & 01100111b = 01100011b
-11111011b & 01101000b = 01101000b
-11111011b & 01101001b = 01101001b
-11111011b & 01101010b = 01101010b
-11111011b & 01101011b = 01101011b
-11111011b & 01101100b = 01101000b
-11111011b & 01101101b = 01101001b
-11111011b & 01101110b = 01101010b
-11111011b & 01101111b = 01101011b
-11111011b & 01110000b = 01110000b
-11111011b & 01110001b = 01110001b
-11111011b & 01110010b = 01110010b
-11111011b & 01110011b = 01110011b
-11111011b & 01110100b = 01110000b
-11111011b & 01110101b = 01110001b
-11111011b & 01110110b = 01110010b
-11111011b & 01110111b = 01110011b
-11111011b & 01111000b = 01111000b
-11111011b & 01111001b = 01111001b
-11111011b & 01111010b = 01111010b
-11111011b & 01111011b = 01111011b
-11111011b & 01111100b = 01111000b
-11111011b & 01111101b = 01111001b
-11111011b & 01111110b = 01111010b
-11111100b & 10000000b = 10000000b
-11111100b & 10000001b = 10000000b
-11111100b & 10000010b = 10000000b
-11111100b & 10000011b = 10000000b
-11111100b & 10000100b = 10000100b
-11111100b & 10000101b = 10000100b
-11111100b & 10000110b = 10000100b
-11111100b & 10000111b = 10000100b
-11111100b & 10001000b = 10001000b
-11111100b & 10001001b = 10001000b
-11111100b & 10001010b = 10001000b
-11111100b & 10001011b = 10001000b
-11111100b & 10001100b = 10001100b
-11111100b & 10001101b = 10001100b
-11111100b & 10001110b = 10001100b
-11111100b & 10001111b = 10001100b
-11111100b & 10010000b = 10010000b
-11111100b & 10010001b = 10010000b
-11111100b & 10010010b = 10010000b
-11111100b & 10010011b = 10010000b
-11111100b & 10010100b = 10010100b
-11111100b & 10010101b = 10010100b
-11111100b & 10010110b = 10010100b
-11111100b & 10010111b = 10010100b
-11111100b & 10011000b = 10011000b
-11111100b & 10011001b = 10011000b
-11111100b & 10011010b = 10011000b
-11111100b & 10011011b = 10011000b
-11111100b & 10011100b = 10011100b
-11111100b & 10011101b = 10011100b
-11111100b & 10011110b = 10011100b
-11111100b & 10011111b = 10011100b
-11111100b & 10100000b = 10100000b
-11111100b & 10100001b = 10100000b
-11111100b & 10100010b = 10100000b
-11111100b & 10100011b = 10100000b
-11111100b & 10100100b = 10100100b
-11111100b & 10100101b = 10100100b
-11111100b & 10100110b = 10100100b
-11111100b & 10100111b = 10100100b
-11111100b & 10101000b = 10101000b
-11111100b & 10101001b = 10101000b
-11111100b & 10101010b = 10101000b
-11111100b & 10101011b = 10101000b
-11111100b & 10101100b = 10101100b
-11111100b & 10101101b = 10101100b
-11111100b & 10101110b = 10101100b
-11111100b & 10101111b = 10101100b
-11111100b & 10110000b = 10110000b
-11111100b & 10110001b = 10110000b
-11111100b & 10110010b = 10110000b
-11111100b & 10110011b = 10110000b
-11111100b & 10110100b = 10110100b
-11111100b & 10110101b = 10110100b
-11111100b & 10110110b = 10110100b
-11111100b & 10110111b = 10110100b
-11111100b & 10111000b = 10111000b
-11111100b & 10111001b = 10111000b
-11111100b & 10111010b = 10111000b
-11111100b & 10111011b = 10111000b
-11111100b & 10111100b = 10111100b
-11111100b & 10111101b = 10111100b
-11111100b & 10111110b = 10111100b
-11111100b & 10111111b = 10111100b
-11111100b & 11000000b = 11000000b
-11111100b & 11000001b = 11000000b
-11111100b & 11000010b = 11000000b
-11111100b & 11000011b = 11000000b
-11111100b & 11000100b = 11000100b
-11111100b & 11000101b = 11000100b
-11111100b & 11000110b = 11000100b
-11111100b & 11000111b = 11000100b
-11111100b & 11001000b = 11001000b
-11111100b & 11001001b = 11001000b
-11111100b & 11001010b = 11001000b
-11111100b & 11001011b = 11001000b
-11111100b & 11001100b = 11001100b
-11111100b & 11001101b = 11001100b
-11111100b & 11001110b = 11001100b
-11111100b & 11001111b = 11001100b
-11111100b & 11010000b = 11010000b
-11111100b & 11010001b = 11010000b
-11111100b & 11010010b = 11010000b
-11111100b & 11010011b = 11010000b
-11111100b & 11010100b = 11010100b
-11111100b & 11010101b = 11010100b
-11111100b & 11010110b = 11010100b
-11111100b & 11010111b = 11010100b
-11111100b & 11011000b = 11011000b
-11111100b & 11011001b = 11011000b
-11111100b & 11011010b = 11011000b
-11111100b & 11011011b = 11011000b
-11111100b & 11011100b = 11011100b
-11111100b & 11011101b = 11011100b
-11111100b & 11011110b = 11011100b
-11111100b & 11011111b = 11011100b
-11111100b & 11100000b = 11100000b
-11111100b & 11100001b = 11100000b
-11111100b & 11100010b = 11100000b
-11111100b & 11100011b = 11100000b
-11111100b & 11100100b = 11100100b
-11111100b & 11100101b = 11100100b
-11111100b & 11100110b = 11100100b
-11111100b & 11100111b = 11100100b
-11111100b & 11101000b = 11101000b
-11111100b & 11101001b = 11101000b
-11111100b & 11101010b = 11101000b
-11111100b & 11101011b = 11101000b
-11111100b & 11101100b = 11101100b
-11111100b & 11101101b = 11101100b
-11111100b & 11101110b = 11101100b
-11111100b & 11101111b = 11101100b
-11111100b & 11110000b = 11110000b
-11111100b & 11110001b = 11110000b
-11111100b & 11110010b = 11110000b
-11111100b & 11110011b = 11110000b
-11111100b & 11110100b = 11110100b
-11111100b & 11110101b = 11110100b
-11111100b & 11110110b = 11110100b
-11111100b & 11110111b = 11110100b
-11111100b & 11111000b = 11111000b
-11111100b & 11111001b = 11111000b
-11111100b & 11111010b = 11111000b
-11111100b & 11111011b = 11111000b
-11111100b & 11111100b = 11111100b
-11111100b & 11111101b = 11111100b
-11111100b & 11111110b = 11111100b
-11111100b & 11111111b = 11111100b
-11111100b & 00000000b = 00000000b
-11111100b & 00000001b = 00000000b
-11111100b & 00000010b = 00000000b
-11111100b & 00000011b = 00000000b
-11111100b & 00000100b = 00000100b
-11111100b & 00000101b = 00000100b
-11111100b & 00000110b = 00000100b
-11111100b & 00000111b = 00000100b
-11111100b & 00001000b = 00001000b
-11111100b & 00001001b = 00001000b
-11111100b & 00001010b = 00001000b
-11111100b & 00001011b = 00001000b
-11111100b & 00001100b = 00001100b
-11111100b & 00001101b = 00001100b
-11111100b & 00001110b = 00001100b
-11111100b & 00001111b = 00001100b
-11111100b & 00010000b = 00010000b
-11111100b & 00010001b = 00010000b
-11111100b & 00010010b = 00010000b
-11111100b & 00010011b = 00010000b
-11111100b & 00010100b = 00010100b
-11111100b & 00010101b = 00010100b
-11111100b & 00010110b = 00010100b
-11111100b & 00010111b = 00010100b
-11111100b & 00011000b = 00011000b
-11111100b & 00011001b = 00011000b
-11111100b & 00011010b = 00011000b
-11111100b & 00011011b = 00011000b
-11111100b & 00011100b = 00011100b
-11111100b & 00011101b = 00011100b
-11111100b & 00011110b = 00011100b
-11111100b & 00011111b = 00011100b
-11111100b & 00100000b = 00100000b
-11111100b & 00100001b = 00100000b
-11111100b & 00100010b = 00100000b
-11111100b & 00100011b = 00100000b
-11111100b & 00100100b = 00100100b
-11111100b & 00100101b = 00100100b
-11111100b & 00100110b = 00100100b
-11111100b & 00100111b = 00100100b
-11111100b & 00101000b = 00101000b
-11111100b & 00101001b = 00101000b
-11111100b & 00101010b = 00101000b
-11111100b & 00101011b = 00101000b
-11111100b & 00101100b = 00101100b
-11111100b & 00101101b = 00101100b
-11111100b & 00101110b = 00101100b
-11111100b & 00101111b = 00101100b
-11111100b & 00110000b = 00110000b
-11111100b & 00110001b = 00110000b
-11111100b & 00110010b = 00110000b
-11111100b & 00110011b = 00110000b
-11111100b & 00110100b = 00110100b
-11111100b & 00110101b = 00110100b
-11111100b & 00110110b = 00110100b
-11111100b & 00110111b = 00110100b
-11111100b & 00111000b = 00111000b
-11111100b & 00111001b = 00111000b
-11111100b & 00111010b = 00111000b
-11111100b & 00111011b = 00111000b
-11111100b & 00111100b = 00111100b
-11111100b & 00111101b = 00111100b
-11111100b & 00111110b = 00111100b
-11111100b & 00111111b = 00111100b
-11111100b & 01000000b = 01000000b
-11111100b & 01000001b = 01000000b
-11111100b & 01000010b = 01000000b
-11111100b & 01000011b = 01000000b
-11111100b & 01000100b = 01000100b
-11111100b & 01000101b = 01000100b
-11111100b & 01000110b = 01000100b
-11111100b & 01000111b = 01000100b
-11111100b & 01001000b = 01001000b
-11111100b & 01001001b = 01001000b
-11111100b & 01001010b = 01001000b
-11111100b & 01001011b = 01001000b
-11111100b & 01001100b = 01001100b
-11111100b & 01001101b = 01001100b
-11111100b & 01001110b = 01001100b
-11111100b & 01001111b = 01001100b
-11111100b & 01010000b = 01010000b
-11111100b & 01010001b = 01010000b
-11111100b & 01010010b = 01010000b
-11111100b & 01010011b = 01010000b
-11111100b & 01010100b = 01010100b
-11111100b & 01010101b = 01010100b
-11111100b & 01010110b = 01010100b
-11111100b & 01010111b = 01010100b
-11111100b & 01011000b = 01011000b
-11111100b & 01011001b = 01011000b
-11111100b & 01011010b = 01011000b
-11111100b & 01011011b = 01011000b
-11111100b & 01011100b = 01011100b
-11111100b & 01011101b = 01011100b
-11111100b & 01011110b = 01011100b
-11111100b & 01011111b = 01011100b
-11111100b & 01100000b = 01100000b
-11111100b & 01100001b = 01100000b
-11111100b & 01100010b = 01100000b
-11111100b & 01100011b = 01100000b
-11111100b & 01100100b = 01100100b
-11111100b & 01100101b = 01100100b
-11111100b & 01100110b = 01100100b
-11111100b & 01100111b = 01100100b
-11111100b & 01101000b = 01101000b
-11111100b & 01101001b = 01101000b
-11111100b & 01101010b = 01101000b
-11111100b & 01101011b = 01101000b
-11111100b & 01101100b = 01101100b
-11111100b & 01101101b = 01101100b
-11111100b & 01101110b = 01101100b
-11111100b & 01101111b = 01101100b
-11111100b & 01110000b = 01110000b
-11111100b & 01110001b = 01110000b
-11111100b & 01110010b = 01110000b
-11111100b & 01110011b = 01110000b
-11111100b & 01110100b = 01110100b
-11111100b & 01110101b = 01110100b
-11111100b & 01110110b = 01110100b
-11111100b & 01110111b = 01110100b
-11111100b & 01111000b = 01111000b
-11111100b & 01111001b = 01111000b
-11111100b & 01111010b = 01111000b
-11111100b & 01111011b = 01111000b
-11111100b & 01111100b = 01111100b
-11111100b & 01111101b = 01111100b
-11111100b & 01111110b = 01111100b
-11111101b & 10000000b = 10000000b
-11111101b & 10000001b = 10000001b
-11111101b & 10000010b = 10000000b
-11111101b & 10000011b = 10000001b
-11111101b & 10000100b = 10000100b
-11111101b & 10000101b = 10000101b
-11111101b & 10000110b = 10000100b
-11111101b & 10000111b = 10000101b
-11111101b & 10001000b = 10001000b
-11111101b & 10001001b = 10001001b
-11111101b & 10001010b = 10001000b
-11111101b & 10001011b = 10001001b
-11111101b & 10001100b = 10001100b
-11111101b & 10001101b = 10001101b
-11111101b & 10001110b = 10001100b
-11111101b & 10001111b = 10001101b
-11111101b & 10010000b = 10010000b
-11111101b & 10010001b = 10010001b
-11111101b & 10010010b = 10010000b
-11111101b & 10010011b = 10010001b
-11111101b & 10010100b = 10010100b
-11111101b & 10010101b = 10010101b
-11111101b & 10010110b = 10010100b
-11111101b & 10010111b = 10010101b
-11111101b & 10011000b = 10011000b
-11111101b & 10011001b = 10011001b
-11111101b & 10011010b = 10011000b
-11111101b & 10011011b = 10011001b
-11111101b & 10011100b = 10011100b
-11111101b & 10011101b = 10011101b
-11111101b & 10011110b = 10011100b
-11111101b & 10011111b = 10011101b
-11111101b & 10100000b = 10100000b
-11111101b & 10100001b = 10100001b
-11111101b & 10100010b = 10100000b
-11111101b & 10100011b = 10100001b
-11111101b & 10100100b = 10100100b
-11111101b & 10100101b = 10100101b
-11111101b & 10100110b = 10100100b
-11111101b & 10100111b = 10100101b
-11111101b & 10101000b = 10101000b
-11111101b & 10101001b = 10101001b
-11111101b & 10101010b = 10101000b
-11111101b & 10101011b = 10101001b
-11111101b & 10101100b = 10101100b
-11111101b & 10101101b = 10101101b
-11111101b & 10101110b = 10101100b
-11111101b & 10101111b = 10101101b
-11111101b & 10110000b = 10110000b
-11111101b & 10110001b = 10110001b
-11111101b & 10110010b = 10110000b
-11111101b & 10110011b = 10110001b
-11111101b & 10110100b = 10110100b
-11111101b & 10110101b = 10110101b
-11111101b & 10110110b = 10110100b
-11111101b & 10110111b = 10110101b
-11111101b & 10111000b = 10111000b
-11111101b & 10111001b = 10111001b
-11111101b & 10111010b = 10111000b
-11111101b & 10111011b = 10111001b
-11111101b & 10111100b = 10111100b
-11111101b & 10111101b = 10111101b
-11111101b & 10111110b = 10111100b
-11111101b & 10111111b = 10111101b
-11111101b & 11000000b = 11000000b
-11111101b & 11000001b = 11000001b
-11111101b & 11000010b = 11000000b
-11111101b & 11000011b = 11000001b
-11111101b & 11000100b = 11000100b
-11111101b & 11000101b = 11000101b
-11111101b & 11000110b = 11000100b
-11111101b & 11000111b = 11000101b
-11111101b & 11001000b = 11001000b
-11111101b & 11001001b = 11001001b
-11111101b & 11001010b = 11001000b
-11111101b & 11001011b = 11001001b
-11111101b & 11001100b = 11001100b
-11111101b & 11001101b = 11001101b
-11111101b & 11001110b = 11001100b
-11111101b & 11001111b = 11001101b
-11111101b & 11010000b = 11010000b
-11111101b & 11010001b = 11010001b
-11111101b & 11010010b = 11010000b
-11111101b & 11010011b = 11010001b
-11111101b & 11010100b = 11010100b
-11111101b & 11010101b = 11010101b
-11111101b & 11010110b = 11010100b
-11111101b & 11010111b = 11010101b
-11111101b & 11011000b = 11011000b
-11111101b & 11011001b = 11011001b
-11111101b & 11011010b = 11011000b
-11111101b & 11011011b = 11011001b
-11111101b & 11011100b = 11011100b
-11111101b & 11011101b = 11011101b
-11111101b & 11011110b = 11011100b
-11111101b & 11011111b = 11011101b
-11111101b & 11100000b = 11100000b
-11111101b & 11100001b = 11100001b
-11111101b & 11100010b = 11100000b
-11111101b & 11100011b = 11100001b
-11111101b & 11100100b = 11100100b
-11111101b & 11100101b = 11100101b
-11111101b & 11100110b = 11100100b
-11111101b & 11100111b = 11100101b
-11111101b & 11101000b = 11101000b
-11111101b & 11101001b = 11101001b
-11111101b & 11101010b = 11101000b
-11111101b & 11101011b = 11101001b
-11111101b & 11101100b = 11101100b
-11111101b & 11101101b = 11101101b
-11111101b & 11101110b = 11101100b
-11111101b & 11101111b = 11101101b
-11111101b & 11110000b = 11110000b
-11111101b & 11110001b = 11110001b
-11111101b & 11110010b = 11110000b
-11111101b & 11110011b = 11110001b
-11111101b & 11110100b = 11110100b
-11111101b & 11110101b = 11110101b
-11111101b & 11110110b = 11110100b
-11111101b & 11110111b = 11110101b
-11111101b & 11111000b = 11111000b
-11111101b & 11111001b = 11111001b
-11111101b & 11111010b = 11111000b
-11111101b & 11111011b = 11111001b
-11111101b & 11111100b = 11111100b
-11111101b & 11111101b = 11111101b
-11111101b & 11111110b = 11111100b
-11111101b & 11111111b = 11111101b
-11111101b & 00000000b = 00000000b
-11111101b & 00000001b = 00000001b
-11111101b & 00000010b = 00000000b
-11111101b & 00000011b = 00000001b
-11111101b & 00000100b = 00000100b
-11111101b & 00000101b = 00000101b
-11111101b & 00000110b = 00000100b
-11111101b & 00000111b = 00000101b
-11111101b & 00001000b = 00001000b
-11111101b & 00001001b = 00001001b
-11111101b & 00001010b = 00001000b
-11111101b & 00001011b = 00001001b
-11111101b & 00001100b = 00001100b
-11111101b & 00001101b = 00001101b
-11111101b & 00001110b = 00001100b
-11111101b & 00001111b = 00001101b
-11111101b & 00010000b = 00010000b
-11111101b & 00010001b = 00010001b
-11111101b & 00010010b = 00010000b
-11111101b & 00010011b = 00010001b
-11111101b & 00010100b = 00010100b
-11111101b & 00010101b = 00010101b
-11111101b & 00010110b = 00010100b
-11111101b & 00010111b = 00010101b
-11111101b & 00011000b = 00011000b
-11111101b & 00011001b = 00011001b
-11111101b & 00011010b = 00011000b
-11111101b & 00011011b = 00011001b
-11111101b & 00011100b = 00011100b
-11111101b & 00011101b = 00011101b
-11111101b & 00011110b = 00011100b
-11111101b & 00011111b = 00011101b
-11111101b & 00100000b = 00100000b
-11111101b & 00100001b = 00100001b
-11111101b & 00100010b = 00100000b
-11111101b & 00100011b = 00100001b
-11111101b & 00100100b = 00100100b
-11111101b & 00100101b = 00100101b
-11111101b & 00100110b = 00100100b
-11111101b & 00100111b = 00100101b
-11111101b & 00101000b = 00101000b
-11111101b & 00101001b = 00101001b
-11111101b & 00101010b = 00101000b
-11111101b & 00101011b = 00101001b
-11111101b & 00101100b = 00101100b
-11111101b & 00101101b = 00101101b
-11111101b & 00101110b = 00101100b
-11111101b & 00101111b = 00101101b
-11111101b & 00110000b = 00110000b
-11111101b & 00110001b = 00110001b
-11111101b & 00110010b = 00110000b
-11111101b & 00110011b = 00110001b
-11111101b & 00110100b = 00110100b
-11111101b & 00110101b = 00110101b
-11111101b & 00110110b = 00110100b
-11111101b & 00110111b = 00110101b
-11111101b & 00111000b = 00111000b
-11111101b & 00111001b = 00111001b
-11111101b & 00111010b = 00111000b
-11111101b & 00111011b = 00111001b
-11111101b & 00111100b = 00111100b
-11111101b & 00111101b = 00111101b
-11111101b & 00111110b = 00111100b
-11111101b & 00111111b = 00111101b
-11111101b & 01000000b = 01000000b
-11111101b & 01000001b = 01000001b
-11111101b & 01000010b = 01000000b
-11111101b & 01000011b = 01000001b
-11111101b & 01000100b = 01000100b
-11111101b & 01000101b = 01000101b
-11111101b & 01000110b = 01000100b
-11111101b & 01000111b = 01000101b
-11111101b & 01001000b = 01001000b
-11111101b & 01001001b = 01001001b
-11111101b & 01001010b = 01001000b
-11111101b & 01001011b = 01001001b
-11111101b & 01001100b = 01001100b
-11111101b & 01001101b = 01001101b
-11111101b & 01001110b = 01001100b
-11111101b & 01001111b = 01001101b
-11111101b & 01010000b = 01010000b
-11111101b & 01010001b = 01010001b
-11111101b & 01010010b = 01010000b
-11111101b & 01010011b = 01010001b
-11111101b & 01010100b = 01010100b
-11111101b & 01010101b = 01010101b
-11111101b & 01010110b = 01010100b
-11111101b & 01010111b = 01010101b
-11111101b & 01011000b = 01011000b
-11111101b & 01011001b = 01011001b
-11111101b & 01011010b = 01011000b
-11111101b & 01011011b = 01011001b
-11111101b & 01011100b = 01011100b
-11111101b & 01011101b = 01011101b
-11111101b & 01011110b = 01011100b
-11111101b & 01011111b = 01011101b
-11111101b & 01100000b = 01100000b
-11111101b & 01100001b = 01100001b
-11111101b & 01100010b = 01100000b
-11111101b & 01100011b = 01100001b
-11111101b & 01100100b = 01100100b
-11111101b & 01100101b = 01100101b
-11111101b & 01100110b = 01100100b
-11111101b & 01100111b = 01100101b
-11111101b & 01101000b = 01101000b
-11111101b & 01101001b = 01101001b
-11111101b & 01101010b = 01101000b
-11111101b & 01101011b = 01101001b
-11111101b & 01101100b = 01101100b
-11111101b & 01101101b = 01101101b
-11111101b & 01101110b = 01101100b
-11111101b & 01101111b = 01101101b
-11111101b & 01110000b = 01110000b
-11111101b & 01110001b = 01110001b
-11111101b & 01110010b = 01110000b
-11111101b & 01110011b = 01110001b
-11111101b & 01110100b = 01110100b
-11111101b & 01110101b = 01110101b
-11111101b & 01110110b = 01110100b
-11111101b & 01110111b = 01110101b
-11111101b & 01111000b = 01111000b
-11111101b & 01111001b = 01111001b
-11111101b & 01111010b = 01111000b
-11111101b & 01111011b = 01111001b
-11111101b & 01111100b = 01111100b
-11111101b & 01111101b = 01111101b
-11111101b & 01111110b = 01111100b
-11111110b & 10000000b = 10000000b
-11111110b & 10000001b = 10000000b
-11111110b & 10000010b = 10000010b
-11111110b & 10000011b = 10000010b
-11111110b & 10000100b = 10000100b
-11111110b & 10000101b = 10000100b
-11111110b & 10000110b = 10000110b
-11111110b & 10000111b = 10000110b
-11111110b & 10001000b = 10001000b
-11111110b & 10001001b = 10001000b
-11111110b & 10001010b = 10001010b
-11111110b & 10001011b = 10001010b
-11111110b & 10001100b = 10001100b
-11111110b & 10001101b = 10001100b
-11111110b & 10001110b = 10001110b
-11111110b & 10001111b = 10001110b
-11111110b & 10010000b = 10010000b
-11111110b & 10010001b = 10010000b
-11111110b & 10010010b = 10010010b
-11111110b & 10010011b = 10010010b
-11111110b & 10010100b = 10010100b
-11111110b & 10010101b = 10010100b
-11111110b & 10010110b = 10010110b
-11111110b & 10010111b = 10010110b
-11111110b & 10011000b = 10011000b
-11111110b & 10011001b = 10011000b
-11111110b & 10011010b = 10011010b
-11111110b & 10011011b = 10011010b
-11111110b & 10011100b = 10011100b
-11111110b & 10011101b = 10011100b
-11111110b & 10011110b = 10011110b
-11111110b & 10011111b = 10011110b
-11111110b & 10100000b = 10100000b
-11111110b & 10100001b = 10100000b
-11111110b & 10100010b = 10100010b
-11111110b & 10100011b = 10100010b
-11111110b & 10100100b = 10100100b
-11111110b & 10100101b = 10100100b
-11111110b & 10100110b = 10100110b
-11111110b & 10100111b = 10100110b
-11111110b & 10101000b = 10101000b
-11111110b & 10101001b = 10101000b
-11111110b & 10101010b = 10101010b
-11111110b & 10101011b = 10101010b
-11111110b & 10101100b = 10101100b
-11111110b & 10101101b = 10101100b
-11111110b & 10101110b = 10101110b
-11111110b & 10101111b = 10101110b
-11111110b & 10110000b = 10110000b
-11111110b & 10110001b = 10110000b
-11111110b & 10110010b = 10110010b
-11111110b & 10110011b = 10110010b
-11111110b & 10110100b = 10110100b
-11111110b & 10110101b = 10110100b
-11111110b & 10110110b = 10110110b
-11111110b & 10110111b = 10110110b
-11111110b & 10111000b = 10111000b
-11111110b & 10111001b = 10111000b
-11111110b & 10111010b = 10111010b
-11111110b & 10111011b = 10111010b
-11111110b & 10111100b = 10111100b
-11111110b & 10111101b = 10111100b
-11111110b & 10111110b = 10111110b
-11111110b & 10111111b = 10111110b
-11111110b & 11000000b = 11000000b
-11111110b & 11000001b = 11000000b
-11111110b & 11000010b = 11000010b
-11111110b & 11000011b = 11000010b
-11111110b & 11000100b = 11000100b
-11111110b & 11000101b = 11000100b
-11111110b & 11000110b = 11000110b
-11111110b & 11000111b = 11000110b
-11111110b & 11001000b = 11001000b
-11111110b & 11001001b = 11001000b
-11111110b & 11001010b = 11001010b
-11111110b & 11001011b = 11001010b
-11111110b & 11001100b = 11001100b
-11111110b & 11001101b = 11001100b
-11111110b & 11001110b = 11001110b
-11111110b & 11001111b = 11001110b
-11111110b & 11010000b = 11010000b
-11111110b & 11010001b = 11010000b
-11111110b & 11010010b = 11010010b
-11111110b & 11010011b = 11010010b
-11111110b & 11010100b = 11010100b
-11111110b & 11010101b = 11010100b
-11111110b & 11010110b = 11010110b
-11111110b & 11010111b = 11010110b
-11111110b & 11011000b = 11011000b
-11111110b & 11011001b = 11011000b
-11111110b & 11011010b = 11011010b
-11111110b & 11011011b = 11011010b
-11111110b & 11011100b = 11011100b
-11111110b & 11011101b = 11011100b
-11111110b & 11011110b = 11011110b
-11111110b & 11011111b = 11011110b
-11111110b & 11100000b = 11100000b
-11111110b & 11100001b = 11100000b
-11111110b & 11100010b = 11100010b
-11111110b & 11100011b = 11100010b
-11111110b & 11100100b = 11100100b
-11111110b & 11100101b = 11100100b
-11111110b & 11100110b = 11100110b
-11111110b & 11100111b = 11100110b
-11111110b & 11101000b = 11101000b
-11111110b & 11101001b = 11101000b
-11111110b & 11101010b = 11101010b
-11111110b & 11101011b = 11101010b
-11111110b & 11101100b = 11101100b
-11111110b & 11101101b = 11101100b
-11111110b & 11101110b = 11101110b
-11111110b & 11101111b = 11101110b
-11111110b & 11110000b = 11110000b
-11111110b & 11110001b = 11110000b
-11111110b & 11110010b = 11110010b
-11111110b & 11110011b = 11110010b
-11111110b & 11110100b = 11110100b
-11111110b & 11110101b = 11110100b
-11111110b & 11110110b = 11110110b
-11111110b & 11110111b = 11110110b
-11111110b & 11111000b = 11111000b
-11111110b & 11111001b = 11111000b
-11111110b & 11111010b = 11111010b
-11111110b & 11111011b = 11111010b
-11111110b & 11111100b = 11111100b
-11111110b & 11111101b = 11111100b
-11111110b & 11111110b = 11111110b
-11111110b & 11111111b = 11111110b
-11111110b & 00000000b = 00000000b
-11111110b & 00000001b = 00000000b
-11111110b & 00000010b = 00000010b
-11111110b & 00000011b = 00000010b
-11111110b & 00000100b = 00000100b
-11111110b & 00000101b = 00000100b
-11111110b & 00000110b = 00000110b
-11111110b & 00000111b = 00000110b
-11111110b & 00001000b = 00001000b
-11111110b & 00001001b = 00001000b
-11111110b & 00001010b = 00001010b
-11111110b & 00001011b = 00001010b
-11111110b & 00001100b = 00001100b
-11111110b & 00001101b = 00001100b
-11111110b & 00001110b = 00001110b
-11111110b & 00001111b = 00001110b
-11111110b & 00010000b = 00010000b
-11111110b & 00010001b = 00010000b
-11111110b & 00010010b = 00010010b
-11111110b & 00010011b = 00010010b
-11111110b & 00010100b = 00010100b
-11111110b & 00010101b = 00010100b
-11111110b & 00010110b = 00010110b
-11111110b & 00010111b = 00010110b
-11111110b & 00011000b = 00011000b
-11111110b & 00011001b = 00011000b
-11111110b & 00011010b = 00011010b
-11111110b & 00011011b = 00011010b
-11111110b & 00011100b = 00011100b
-11111110b & 00011101b = 00011100b
-11111110b & 00011110b = 00011110b
-11111110b & 00011111b = 00011110b
-11111110b & 00100000b = 00100000b
-11111110b & 00100001b = 00100000b
-11111110b & 00100010b = 00100010b
-11111110b & 00100011b = 00100010b
-11111110b & 00100100b = 00100100b
-11111110b & 00100101b = 00100100b
-11111110b & 00100110b = 00100110b
-11111110b & 00100111b = 00100110b
-11111110b & 00101000b = 00101000b
-11111110b & 00101001b = 00101000b
-11111110b & 00101010b = 00101010b
-11111110b & 00101011b = 00101010b
-11111110b & 00101100b = 00101100b
-11111110b & 00101101b = 00101100b
-11111110b & 00101110b = 00101110b
-11111110b & 00101111b = 00101110b
-11111110b & 00110000b = 00110000b
-11111110b & 00110001b = 00110000b
-11111110b & 00110010b = 00110010b
-11111110b & 00110011b = 00110010b
-11111110b & 00110100b = 00110100b
-11111110b & 00110101b = 00110100b
-11111110b & 00110110b = 00110110b
-11111110b & 00110111b = 00110110b
-11111110b & 00111000b = 00111000b
-11111110b & 00111001b = 00111000b
-11111110b & 00111010b = 00111010b
-11111110b & 00111011b = 00111010b
-11111110b & 00111100b = 00111100b
-11111110b & 00111101b = 00111100b
-11111110b & 00111110b = 00111110b
-11111110b & 00111111b = 00111110b
-11111110b & 01000000b = 01000000b
-11111110b & 01000001b = 01000000b
-11111110b & 01000010b = 01000010b
-11111110b & 01000011b = 01000010b
-11111110b & 01000100b = 01000100b
-11111110b & 01000101b = 01000100b
-11111110b & 01000110b = 01000110b
-11111110b & 01000111b = 01000110b
-11111110b & 01001000b = 01001000b
-11111110b & 01001001b = 01001000b
-11111110b & 01001010b = 01001010b
-11111110b & 01001011b = 01001010b
-11111110b & 01001100b = 01001100b
-11111110b & 01001101b = 01001100b
-11111110b & 01001110b = 01001110b
-11111110b & 01001111b = 01001110b
-11111110b & 01010000b = 01010000b
-11111110b & 01010001b = 01010000b
-11111110b & 01010010b = 01010010b
-11111110b & 01010011b = 01010010b
-11111110b & 01010100b = 01010100b
-11111110b & 01010101b = 01010100b
-11111110b & 01010110b = 01010110b
-11111110b & 01010111b = 01010110b
-11111110b & 01011000b = 01011000b
-11111110b & 01011001b = 01011000b
-11111110b & 01011010b = 01011010b
-11111110b & 01011011b = 01011010b
-11111110b & 01011100b = 01011100b
-11111110b & 01011101b = 01011100b
-11111110b & 01011110b = 01011110b
-11111110b & 01011111b = 01011110b
-11111110b & 01100000b = 01100000b
-11111110b & 01100001b = 01100000b
-11111110b & 01100010b = 01100010b
-11111110b & 01100011b = 01100010b
-11111110b & 01100100b = 01100100b
-11111110b & 01100101b = 01100100b
-11111110b & 01100110b = 01100110b
-11111110b & 01100111b = 01100110b
-11111110b & 01101000b = 01101000b
-11111110b & 01101001b = 01101000b
-11111110b & 01101010b = 01101010b
-11111110b & 01101011b = 01101010b
-11111110b & 01101100b = 01101100b
-11111110b & 01101101b = 01101100b
-11111110b & 01101110b = 01101110b
-11111110b & 01101111b = 01101110b
-11111110b & 01110000b = 01110000b
-11111110b & 01110001b = 01110000b
-11111110b & 01110010b = 01110010b
-11111110b & 01110011b = 01110010b
-11111110b & 01110100b = 01110100b
-11111110b & 01110101b = 01110100b
-11111110b & 01110110b = 01110110b
-11111110b & 01110111b = 01110110b
-11111110b & 01111000b = 01111000b
-11111110b & 01111001b = 01111000b
-11111110b & 01111010b = 01111010b
-11111110b & 01111011b = 01111010b
-11111110b & 01111100b = 01111100b
-11111110b & 01111101b = 01111100b
-11111110b & 01111110b = 01111110b
-11111111b & 10000000b = 10000000b
-11111111b & 10000001b = 10000001b
-11111111b & 10000010b = 10000010b
-11111111b & 10000011b = 10000011b
-11111111b & 10000100b = 10000100b
-11111111b & 10000101b = 10000101b
-11111111b & 10000110b = 10000110b
-11111111b & 10000111b = 10000111b
-11111111b & 10001000b = 10001000b
-11111111b & 10001001b = 10001001b
-11111111b & 10001010b = 10001010b
-11111111b & 10001011b = 10001011b
-11111111b & 10001100b = 10001100b
-11111111b & 10001101b = 10001101b
-11111111b & 10001110b = 10001110b
-11111111b & 10001111b = 10001111b
-11111111b & 10010000b = 10010000b
-11111111b & 10010001b = 10010001b
-11111111b & 10010010b = 10010010b
-11111111b & 10010011b = 10010011b
-11111111b & 10010100b = 10010100b
-11111111b & 10010101b = 10010101b
-11111111b & 10010110b = 10010110b
-11111111b & 10010111b = 10010111b
-11111111b & 10011000b = 10011000b
-11111111b & 10011001b = 10011001b
-11111111b & 10011010b = 10011010b
-11111111b & 10011011b = 10011011b
-11111111b & 10011100b = 10011100b
-11111111b & 10011101b = 10011101b
-11111111b & 10011110b = 10011110b
-11111111b & 10011111b = 10011111b
-11111111b & 10100000b = 10100000b
-11111111b & 10100001b = 10100001b
-11111111b & 10100010b = 10100010b
-11111111b & 10100011b = 10100011b
-11111111b & 10100100b = 10100100b
-11111111b & 10100101b = 10100101b
-11111111b & 10100110b = 10100110b
-11111111b & 10100111b = 10100111b
-11111111b & 10101000b = 10101000b
-11111111b & 10101001b = 10101001b
-11111111b & 10101010b = 10101010b
-11111111b & 10101011b = 10101011b
-11111111b & 10101100b = 10101100b
-11111111b & 10101101b = 10101101b
-11111111b & 10101110b = 10101110b
-11111111b & 10101111b = 10101111b
-11111111b & 10110000b = 10110000b
-11111111b & 10110001b = 10110001b
-11111111b & 10110010b = 10110010b
-11111111b & 10110011b = 10110011b
-11111111b & 10110100b = 10110100b
-11111111b & 10110101b = 10110101b
-11111111b & 10110110b = 10110110b
-11111111b & 10110111b = 10110111b
-11111111b & 10111000b = 10111000b
-11111111b & 10111001b = 10111001b
-11111111b & 10111010b = 10111010b
-11111111b & 10111011b = 10111011b
-11111111b & 10111100b = 10111100b
-11111111b & 10111101b = 10111101b
-11111111b & 10111110b = 10111110b
-11111111b & 10111111b = 10111111b
-11111111b & 11000000b = 11000000b
-11111111b & 11000001b = 11000001b
-11111111b & 11000010b = 11000010b
-11111111b & 11000011b = 11000011b
-11111111b & 11000100b = 11000100b
-11111111b & 11000101b = 11000101b
-11111111b & 11000110b = 11000110b
-11111111b & 11000111b = 11000111b
-11111111b & 11001000b = 11001000b
-11111111b & 11001001b = 11001001b
-11111111b & 11001010b = 11001010b
-11111111b & 11001011b = 11001011b
-11111111b & 11001100b = 11001100b
-11111111b & 11001101b = 11001101b
-11111111b & 11001110b = 11001110b
-11111111b & 11001111b = 11001111b
-11111111b & 11010000b = 11010000b
-11111111b & 11010001b = 11010001b
-11111111b & 11010010b = 11010010b
-11111111b & 11010011b = 11010011b
-11111111b & 11010100b = 11010100b
-11111111b & 11010101b = 11010101b
-11111111b & 11010110b = 11010110b
-11111111b & 11010111b = 11010111b
-11111111b & 11011000b = 11011000b
-11111111b & 11011001b = 11011001b
-11111111b & 11011010b = 11011010b
-11111111b & 11011011b = 11011011b
-11111111b & 11011100b = 11011100b
-11111111b & 11011101b = 11011101b
-11111111b & 11011110b = 11011110b
-11111111b & 11011111b = 11011111b
-11111111b & 11100000b = 11100000b
-11111111b & 11100001b = 11100001b
-11111111b & 11100010b = 11100010b
-11111111b & 11100011b = 11100011b
-11111111b & 11100100b = 11100100b
-11111111b & 11100101b = 11100101b
-11111111b & 11100110b = 11100110b
-11111111b & 11100111b = 11100111b
-11111111b & 11101000b = 11101000b
-11111111b & 11101001b = 11101001b
-11111111b & 11101010b = 11101010b
-11111111b & 11101011b = 11101011b
-11111111b & 11101100b = 11101100b
-11111111b & 11101101b = 11101101b
-11111111b & 11101110b = 11101110b
-11111111b & 11101111b = 11101111b
-11111111b & 11110000b = 11110000b
-11111111b & 11110001b = 11110001b
-11111111b & 11110010b = 11110010b
-11111111b & 11110011b = 11110011b
-11111111b & 11110100b = 11110100b
-11111111b & 11110101b = 11110101b
-11111111b & 11110110b = 11110110b
-11111111b & 11110111b = 11110111b
-11111111b & 11111000b = 11111000b
-11111111b & 11111001b = 11111001b
-11111111b & 11111010b = 11111010b
-11111111b & 11111011b = 11111011b
-11111111b & 11111100b = 11111100b
-11111111b & 11111101b = 11111101b
-11111111b & 11111110b = 11111110b
-11111111b & 11111111b = 11111111b
-11111111b & 00000000b = 00000000b
-11111111b & 00000001b = 00000001b
-11111111b & 00000010b = 00000010b
-11111111b & 00000011b = 00000011b
-11111111b & 00000100b = 00000100b
-11111111b & 00000101b = 00000101b
-11111111b & 00000110b = 00000110b
-11111111b & 00000111b = 00000111b
-11111111b & 00001000b = 00001000b
-11111111b & 00001001b = 00001001b
-11111111b & 00001010b = 00001010b
-11111111b & 00001011b = 00001011b
-11111111b & 00001100b = 00001100b
-11111111b & 00001101b = 00001101b
-11111111b & 00001110b = 00001110b
-11111111b & 00001111b = 00001111b
-11111111b & 00010000b = 00010000b
-11111111b & 00010001b = 00010001b
-11111111b & 00010010b = 00010010b
-11111111b & 00010011b = 00010011b
-11111111b & 00010100b = 00010100b
-11111111b & 00010101b = 00010101b
-11111111b & 00010110b = 00010110b
-11111111b & 00010111b = 00010111b
-11111111b & 00011000b = 00011000b
-11111111b & 00011001b = 00011001b
-11111111b & 00011010b = 00011010b
-11111111b & 00011011b = 00011011b
-11111111b & 00011100b = 00011100b
-11111111b & 00011101b = 00011101b
-11111111b & 00011110b = 00011110b
-11111111b & 00011111b = 00011111b
-11111111b & 00100000b = 00100000b
-11111111b & 00100001b = 00100001b
-11111111b & 00100010b = 00100010b
-11111111b & 00100011b = 00100011b
-11111111b & 00100100b = 00100100b
-11111111b & 00100101b = 00100101b
-11111111b & 00100110b = 00100110b
-11111111b & 00100111b = 00100111b
-11111111b & 00101000b = 00101000b
-11111111b & 00101001b = 00101001b
-11111111b & 00101010b = 00101010b
-11111111b & 00101011b = 00101011b
-11111111b & 00101100b = 00101100b
-11111111b & 00101101b = 00101101b
-11111111b & 00101110b = 00101110b
-11111111b & 00101111b = 00101111b
-11111111b & 00110000b = 00110000b
-11111111b & 00110001b = 00110001b
-11111111b & 00110010b = 00110010b
-11111111b & 00110011b = 00110011b
-11111111b & 00110100b = 00110100b
-11111111b & 00110101b = 00110101b
-11111111b & 00110110b = 00110110b
-11111111b & 00110111b = 00110111b
-11111111b & 00111000b = 00111000b
-11111111b & 00111001b = 00111001b
-11111111b & 00111010b = 00111010b
-11111111b & 00111011b = 00111011b
-11111111b & 00111100b = 00111100b
-11111111b & 00111101b = 00111101b
-11111111b & 00111110b = 00111110b
-11111111b & 00111111b = 00111111b
-11111111b & 01000000b = 01000000b
-11111111b & 01000001b = 01000001b
-11111111b & 01000010b = 01000010b
-11111111b & 01000011b = 01000011b
-11111111b & 01000100b = 01000100b
-11111111b & 01000101b = 01000101b
-11111111b & 01000110b = 01000110b
-11111111b & 01000111b = 01000111b
-11111111b & 01001000b = 01001000b
-11111111b & 01001001b = 01001001b
-11111111b & 01001010b = 01001010b
-11111111b & 01001011b = 01001011b
-11111111b & 01001100b = 01001100b
-11111111b & 01001101b = 01001101b
-11111111b & 01001110b = 01001110b
-11111111b & 01001111b = 01001111b
-11111111b & 01010000b = 01010000b
-11111111b & 01010001b = 01010001b
-11111111b & 01010010b = 01010010b
-11111111b & 01010011b = 01010011b
-11111111b & 01010100b = 01010100b
-11111111b & 01010101b = 01010101b
-11111111b & 01010110b = 01010110b
-11111111b & 01010111b = 01010111b
-11111111b & 01011000b = 01011000b
-11111111b & 01011001b = 01011001b
-11111111b & 01011010b = 01011010b
-11111111b & 01011011b = 01011011b
-11111111b & 01011100b = 01011100b
-11111111b & 01011101b = 01011101b
-11111111b & 01011110b = 01011110b
-11111111b & 01011111b = 01011111b
-11111111b & 01100000b = 01100000b
-11111111b & 01100001b = 01100001b
-11111111b & 01100010b = 01100010b
-11111111b & 01100011b = 01100011b
-11111111b & 01100100b = 01100100b
-11111111b & 01100101b = 01100101b
-11111111b & 01100110b = 01100110b
-11111111b & 01100111b = 01100111b
-11111111b & 01101000b = 01101000b
-11111111b & 01101001b = 01101001b
-11111111b & 01101010b = 01101010b
-11111111b & 01101011b = 01101011b
-11111111b & 01101100b = 01101100b
-11111111b & 01101101b = 01101101b
-11111111b & 01101110b = 01101110b
-11111111b & 01101111b = 01101111b
-11111111b & 01110000b = 01110000b
-11111111b & 01110001b = 01110001b
-11111111b & 01110010b = 01110010b
-11111111b & 01110011b = 01110011b
-11111111b & 01110100b = 01110100b
-11111111b & 01110101b = 01110101b
-11111111b & 01110110b = 01110110b
-11111111b & 01110111b = 01110111b
-11111111b & 01111000b = 01111000b
-11111111b & 01111001b = 01111001b
-11111111b & 01111010b = 01111010b
-11111111b & 01111011b = 01111011b
-11111111b & 01111100b = 01111100b
-11111111b & 01111101b = 01111101b
-11111111b & 01111110b = 01111110b
-00000000b & 10000000b = 00000000b
-00000000b & 10000001b = 00000000b
-00000000b & 10000010b = 00000000b
-00000000b & 10000011b = 00000000b
-00000000b & 10000100b = 00000000b
-00000000b & 10000101b = 00000000b
-00000000b & 10000110b = 00000000b
-00000000b & 10000111b = 00000000b
-00000000b & 10001000b = 00000000b
-00000000b & 10001001b = 00000000b
-00000000b & 10001010b = 00000000b
-00000000b & 10001011b = 00000000b
-00000000b & 10001100b = 00000000b
-00000000b & 10001101b = 00000000b
-00000000b & 10001110b = 00000000b
-00000000b & 10001111b = 00000000b
-00000000b & 10010000b = 00000000b
-00000000b & 10010001b = 00000000b
-00000000b & 10010010b = 00000000b
-00000000b & 10010011b = 00000000b
-00000000b & 10010100b = 00000000b
-00000000b & 10010101b = 00000000b
-00000000b & 10010110b = 00000000b
-00000000b & 10010111b = 00000000b
-00000000b & 10011000b = 00000000b
-00000000b & 10011001b = 00000000b
-00000000b & 10011010b = 00000000b
-00000000b & 10011011b = 00000000b
-00000000b & 10011100b = 00000000b
-00000000b & 10011101b = 00000000b
-00000000b & 10011110b = 00000000b
-00000000b & 10011111b = 00000000b
-00000000b & 10100000b = 00000000b
-00000000b & 10100001b = 00000000b
-00000000b & 10100010b = 00000000b
-00000000b & 10100011b = 00000000b
-00000000b & 10100100b = 00000000b
-00000000b & 10100101b = 00000000b
-00000000b & 10100110b = 00000000b
-00000000b & 10100111b = 00000000b
-00000000b & 10101000b = 00000000b
-00000000b & 10101001b = 00000000b
-00000000b & 10101010b = 00000000b
-00000000b & 10101011b = 00000000b
-00000000b & 10101100b = 00000000b
-00000000b & 10101101b = 00000000b
-00000000b & 10101110b = 00000000b
-00000000b & 10101111b = 00000000b
-00000000b & 10110000b = 00000000b
-00000000b & 10110001b = 00000000b
-00000000b & 10110010b = 00000000b
-00000000b & 10110011b = 00000000b
-00000000b & 10110100b = 00000000b
-00000000b & 10110101b = 00000000b
-00000000b & 10110110b = 00000000b
-00000000b & 10110111b = 00000000b
-00000000b & 10111000b = 00000000b
-00000000b & 10111001b = 00000000b
-00000000b & 10111010b = 00000000b
-00000000b & 10111011b = 00000000b
-00000000b & 10111100b = 00000000b
-00000000b & 10111101b = 00000000b
-00000000b & 10111110b = 00000000b
-00000000b & 10111111b = 00000000b
-00000000b & 11000000b = 00000000b
-00000000b & 11000001b = 00000000b
-00000000b & 11000010b = 00000000b
-00000000b & 11000011b = 00000000b
-00000000b & 11000100b = 00000000b
-00000000b & 11000101b = 00000000b
-00000000b & 11000110b = 00000000b
-00000000b & 11000111b = 00000000b
-00000000b & 11001000b = 00000000b
-00000000b & 11001001b = 00000000b
-00000000b & 11001010b = 00000000b
-00000000b & 11001011b = 00000000b
-00000000b & 11001100b = 00000000b
-00000000b & 11001101b = 00000000b
-00000000b & 11001110b = 00000000b
-00000000b & 11001111b = 00000000b
-00000000b & 11010000b = 00000000b
-00000000b & 11010001b = 00000000b
-00000000b & 11010010b = 00000000b
-00000000b & 11010011b = 00000000b
-00000000b & 11010100b = 00000000b
-00000000b & 11010101b = 00000000b
-00000000b & 11010110b = 00000000b
-00000000b & 11010111b = 00000000b
-00000000b & 11011000b = 00000000b
-00000000b & 11011001b = 00000000b
-00000000b & 11011010b = 00000000b
-00000000b & 11011011b = 00000000b
-00000000b & 11011100b = 00000000b
-00000000b & 11011101b = 00000000b
-00000000b & 11011110b = 00000000b
-00000000b & 11011111b = 00000000b
-00000000b & 11100000b = 00000000b
-00000000b & 11100001b = 00000000b
-00000000b & 11100010b = 00000000b
-00000000b & 11100011b = 00000000b
-00000000b & 11100100b = 00000000b
-00000000b & 11100101b = 00000000b
-00000000b & 11100110b = 00000000b
-00000000b & 11100111b = 00000000b
-00000000b & 11101000b = 00000000b
-00000000b & 11101001b = 00000000b
-00000000b & 11101010b = 00000000b
-00000000b & 11101011b = 00000000b
-00000000b & 11101100b = 00000000b
-00000000b & 11101101b = 00000000b
-00000000b & 11101110b = 00000000b
-00000000b & 11101111b = 00000000b
-00000000b & 11110000b = 00000000b
-00000000b & 11110001b = 00000000b
-00000000b & 11110010b = 00000000b
-00000000b & 11110011b = 00000000b
-00000000b & 11110100b = 00000000b
-00000000b & 11110101b = 00000000b
-00000000b & 11110110b = 00000000b
-00000000b & 11110111b = 00000000b
-00000000b & 11111000b = 00000000b
-00000000b & 11111001b = 00000000b
-00000000b & 11111010b = 00000000b
-00000000b & 11111011b = 00000000b
-00000000b & 11111100b = 00000000b
-00000000b & 11111101b = 00000000b
-00000000b & 11111110b = 00000000b
-00000000b & 11111111b = 00000000b
-00000000b & 00000000b = 00000000b
-00000000b & 00000001b = 00000000b
-00000000b & 00000010b = 00000000b
-00000000b & 00000011b = 00000000b
-00000000b & 00000100b = 00000000b
-00000000b & 00000101b = 00000000b
-00000000b & 00000110b = 00000000b
-00000000b & 00000111b = 00000000b
-00000000b & 00001000b = 00000000b
-00000000b & 00001001b = 00000000b
-00000000b & 00001010b = 00000000b
-00000000b & 00001011b = 00000000b
-00000000b & 00001100b = 00000000b
-00000000b & 00001101b = 00000000b
-00000000b & 00001110b = 00000000b
-00000000b & 00001111b = 00000000b
-00000000b & 00010000b = 00000000b
-00000000b & 00010001b = 00000000b
-00000000b & 00010010b = 00000000b
-00000000b & 00010011b = 00000000b
-00000000b & 00010100b = 00000000b
-00000000b & 00010101b = 00000000b
-00000000b & 00010110b = 00000000b
-00000000b & 00010111b = 00000000b
-00000000b & 00011000b = 00000000b
-00000000b & 00011001b = 00000000b
-00000000b & 00011010b = 00000000b
-00000000b & 00011011b = 00000000b
-00000000b & 00011100b = 00000000b
-00000000b & 00011101b = 00000000b
-00000000b & 00011110b = 00000000b
-00000000b & 00011111b = 00000000b
-00000000b & 00100000b = 00000000b
-00000000b & 00100001b = 00000000b
-00000000b & 00100010b = 00000000b
-00000000b & 00100011b = 00000000b
-00000000b & 00100100b = 00000000b
-00000000b & 00100101b = 00000000b
-00000000b & 00100110b = 00000000b
-00000000b & 00100111b = 00000000b
-00000000b & 00101000b = 00000000b
-00000000b & 00101001b = 00000000b
-00000000b & 00101010b = 00000000b
-00000000b & 00101011b = 00000000b
-00000000b & 00101100b = 00000000b
-00000000b & 00101101b = 00000000b
-00000000b & 00101110b = 00000000b
-00000000b & 00101111b = 00000000b
-00000000b & 00110000b = 00000000b
-00000000b & 00110001b = 00000000b
-00000000b & 00110010b = 00000000b
-00000000b & 00110011b = 00000000b
-00000000b & 00110100b = 00000000b
-00000000b & 00110101b = 00000000b
-00000000b & 00110110b = 00000000b
-00000000b & 00110111b = 00000000b
-00000000b & 00111000b = 00000000b
-00000000b & 00111001b = 00000000b
-00000000b & 00111010b = 00000000b
-00000000b & 00111011b = 00000000b
-00000000b & 00111100b = 00000000b
-00000000b & 00111101b = 00000000b
-00000000b & 00111110b = 00000000b
-00000000b & 00111111b = 00000000b
-00000000b & 01000000b = 00000000b
-00000000b & 01000001b = 00000000b
-00000000b & 01000010b = 00000000b
-00000000b & 01000011b = 00000000b
-00000000b & 01000100b = 00000000b
-00000000b & 01000101b = 00000000b
-00000000b & 01000110b = 00000000b
-00000000b & 01000111b = 00000000b
-00000000b & 01001000b = 00000000b
-00000000b & 01001001b = 00000000b
-00000000b & 01001010b = 00000000b
-00000000b & 01001011b = 00000000b
-00000000b & 01001100b = 00000000b
-00000000b & 01001101b = 00000000b
-00000000b & 01001110b = 00000000b
-00000000b & 01001111b = 00000000b
-00000000b & 01010000b = 00000000b
-00000000b & 01010001b = 00000000b
-00000000b & 01010010b = 00000000b
-00000000b & 01010011b = 00000000b
-00000000b & 01010100b = 00000000b
-00000000b & 01010101b = 00000000b
-00000000b & 01010110b = 00000000b
-00000000b & 01010111b = 00000000b
-00000000b & 01011000b = 00000000b
-00000000b & 01011001b = 00000000b
-00000000b & 01011010b = 00000000b
-00000000b & 01011011b = 00000000b
-00000000b & 01011100b = 00000000b
-00000000b & 01011101b = 00000000b
-00000000b & 01011110b = 00000000b
-00000000b & 01011111b = 00000000b
-00000000b & 01100000b = 00000000b
-00000000b & 01100001b = 00000000b
-00000000b & 01100010b = 00000000b
-00000000b & 01100011b = 00000000b
-00000000b & 01100100b = 00000000b
-00000000b & 01100101b = 00000000b
-00000000b & 01100110b = 00000000b
-00000000b & 01100111b = 00000000b
-00000000b & 01101000b = 00000000b
-00000000b & 01101001b = 00000000b
-00000000b & 01101010b = 00000000b
-00000000b & 01101011b = 00000000b
-00000000b & 01101100b = 00000000b
-00000000b & 01101101b = 00000000b
-00000000b & 01101110b = 00000000b
-00000000b & 01101111b = 00000000b
-00000000b & 01110000b = 00000000b
-00000000b & 01110001b = 00000000b
-00000000b & 01110010b = 00000000b
-00000000b & 01110011b = 00000000b
-00000000b & 01110100b = 00000000b
-00000000b & 01110101b = 00000000b
-00000000b & 01110110b = 00000000b
-00000000b & 01110111b = 00000000b
-00000000b & 01111000b = 00000000b
-00000000b & 01111001b = 00000000b
-00000000b & 01111010b = 00000000b
-00000000b & 01111011b = 00000000b
-00000000b & 01111100b = 00000000b
-00000000b & 01111101b = 00000000b
-00000000b & 01111110b = 00000000b
-00000001b & 10000000b = 00000000b
-00000001b & 10000001b = 00000001b
-00000001b & 10000010b = 00000000b
-00000001b & 10000011b = 00000001b
-00000001b & 10000100b = 00000000b
-00000001b & 10000101b = 00000001b
-00000001b & 10000110b = 00000000b
-00000001b & 10000111b = 00000001b
-00000001b & 10001000b = 00000000b
-00000001b & 10001001b = 00000001b
-00000001b & 10001010b = 00000000b
-00000001b & 10001011b = 00000001b
-00000001b & 10001100b = 00000000b
-00000001b & 10001101b = 00000001b
-00000001b & 10001110b = 00000000b
-00000001b & 10001111b = 00000001b
-00000001b & 10010000b = 00000000b
-00000001b & 10010001b = 00000001b
-00000001b & 10010010b = 00000000b
-00000001b & 10010011b = 00000001b
-00000001b & 10010100b = 00000000b
-00000001b & 10010101b = 00000001b
-00000001b & 10010110b = 00000000b
-00000001b & 10010111b = 00000001b
-00000001b & 10011000b = 00000000b
-00000001b & 10011001b = 00000001b
-00000001b & 10011010b = 00000000b
-00000001b & 10011011b = 00000001b
-00000001b & 10011100b = 00000000b
-00000001b & 10011101b = 00000001b
-00000001b & 10011110b = 00000000b
-00000001b & 10011111b = 00000001b
-00000001b & 10100000b = 00000000b
-00000001b & 10100001b = 00000001b
-00000001b & 10100010b = 00000000b
-00000001b & 10100011b = 00000001b
-00000001b & 10100100b = 00000000b
-00000001b & 10100101b = 00000001b
-00000001b & 10100110b = 00000000b
-00000001b & 10100111b = 00000001b
-00000001b & 10101000b = 00000000b
-00000001b & 10101001b = 00000001b
-00000001b & 10101010b = 00000000b
-00000001b & 10101011b = 00000001b
-00000001b & 10101100b = 00000000b
-00000001b & 10101101b = 00000001b
-00000001b & 10101110b = 00000000b
-00000001b & 10101111b = 00000001b
-00000001b & 10110000b = 00000000b
-00000001b & 10110001b = 00000001b
-00000001b & 10110010b = 00000000b
-00000001b & 10110011b = 00000001b
-00000001b & 10110100b = 00000000b
-00000001b & 10110101b = 00000001b
-00000001b & 10110110b = 00000000b
-00000001b & 10110111b = 00000001b
-00000001b & 10111000b = 00000000b
-00000001b & 10111001b = 00000001b
-00000001b & 10111010b = 00000000b
-00000001b & 10111011b = 00000001b
-00000001b & 10111100b = 00000000b
-00000001b & 10111101b = 00000001b
-00000001b & 10111110b = 00000000b
-00000001b & 10111111b = 00000001b
-00000001b & 11000000b = 00000000b
-00000001b & 11000001b = 00000001b
-00000001b & 11000010b = 00000000b
-00000001b & 11000011b = 00000001b
-00000001b & 11000100b = 00000000b
-00000001b & 11000101b = 00000001b
-00000001b & 11000110b = 00000000b
-00000001b & 11000111b = 00000001b
-00000001b & 11001000b = 00000000b
-00000001b & 11001001b = 00000001b
-00000001b & 11001010b = 00000000b
-00000001b & 11001011b = 00000001b
-00000001b & 11001100b = 00000000b
-00000001b & 11001101b = 00000001b
-00000001b & 11001110b = 00000000b
-00000001b & 11001111b = 00000001b
-00000001b & 11010000b = 00000000b
-00000001b & 11010001b = 00000001b
-00000001b & 11010010b = 00000000b
-00000001b & 11010011b = 00000001b
-00000001b & 11010100b = 00000000b
-00000001b & 11010101b = 00000001b
-00000001b & 11010110b = 00000000b
-00000001b & 11010111b = 00000001b
-00000001b & 11011000b = 00000000b
-00000001b & 11011001b = 00000001b
-00000001b & 11011010b = 00000000b
-00000001b & 11011011b = 00000001b
-00000001b & 11011100b = 00000000b
-00000001b & 11011101b = 00000001b
-00000001b & 11011110b = 00000000b
-00000001b & 11011111b = 00000001b
-00000001b & 11100000b = 00000000b
-00000001b & 11100001b = 00000001b
-00000001b & 11100010b = 00000000b
-00000001b & 11100011b = 00000001b
-00000001b & 11100100b = 00000000b
-00000001b & 11100101b = 00000001b
-00000001b & 11100110b = 00000000b
-00000001b & 11100111b = 00000001b
-00000001b & 11101000b = 00000000b
-00000001b & 11101001b = 00000001b
-00000001b & 11101010b = 00000000b
-00000001b & 11101011b = 00000001b
-00000001b & 11101100b = 00000000b
-00000001b & 11101101b = 00000001b
-00000001b & 11101110b = 00000000b
-00000001b & 11101111b = 00000001b
-00000001b & 11110000b = 00000000b
-00000001b & 11110001b = 00000001b
-00000001b & 11110010b = 00000000b
-00000001b & 11110011b = 00000001b
-00000001b & 11110100b = 00000000b
-00000001b & 11110101b = 00000001b
-00000001b & 11110110b = 00000000b
-00000001b & 11110111b = 00000001b
-00000001b & 11111000b = 00000000b
-00000001b & 11111001b = 00000001b
-00000001b & 11111010b = 00000000b
-00000001b & 11111011b = 00000001b
-00000001b & 11111100b = 00000000b
-00000001b & 11111101b = 00000001b
-00000001b & 11111110b = 00000000b
-00000001b & 11111111b = 00000001b
-00000001b & 00000000b = 00000000b
-00000001b & 00000001b = 00000001b
-00000001b & 00000010b = 00000000b
-00000001b & 00000011b = 00000001b
-00000001b & 00000100b = 00000000b
-00000001b & 00000101b = 00000001b
-00000001b & 00000110b = 00000000b
-00000001b & 00000111b = 00000001b
-00000001b & 00001000b = 00000000b
-00000001b & 00001001b = 00000001b
-00000001b & 00001010b = 00000000b
-00000001b & 00001011b = 00000001b
-00000001b & 00001100b = 00000000b
-00000001b & 00001101b = 00000001b
-00000001b & 00001110b = 00000000b
-00000001b & 00001111b = 00000001b
-00000001b & 00010000b = 00000000b
-00000001b & 00010001b = 00000001b
-00000001b & 00010010b = 00000000b
-00000001b & 00010011b = 00000001b
-00000001b & 00010100b = 00000000b
-00000001b & 00010101b = 00000001b
-00000001b & 00010110b = 00000000b
-00000001b & 00010111b = 00000001b
-00000001b & 00011000b = 00000000b
-00000001b & 00011001b = 00000001b
-00000001b & 00011010b = 00000000b
-00000001b & 00011011b = 00000001b
-00000001b & 00011100b = 00000000b
-00000001b & 00011101b = 00000001b
-00000001b & 00011110b = 00000000b
-00000001b & 00011111b = 00000001b
-00000001b & 00100000b = 00000000b
-00000001b & 00100001b = 00000001b
-00000001b & 00100010b = 00000000b
-00000001b & 00100011b = 00000001b
-00000001b & 00100100b = 00000000b
-00000001b & 00100101b = 00000001b
-00000001b & 00100110b = 00000000b
-00000001b & 00100111b = 00000001b
-00000001b & 00101000b = 00000000b
-00000001b & 00101001b = 00000001b
-00000001b & 00101010b = 00000000b
-00000001b & 00101011b = 00000001b
-00000001b & 00101100b = 00000000b
-00000001b & 00101101b = 00000001b
-00000001b & 00101110b = 00000000b
-00000001b & 00101111b = 00000001b
-00000001b & 00110000b = 00000000b
-00000001b & 00110001b = 00000001b
-00000001b & 00110010b = 00000000b
-00000001b & 00110011b = 00000001b
-00000001b & 00110100b = 00000000b
-00000001b & 00110101b = 00000001b
-00000001b & 00110110b = 00000000b
-00000001b & 00110111b = 00000001b
-00000001b & 00111000b = 00000000b
-00000001b & 00111001b = 00000001b
-00000001b & 00111010b = 00000000b
-00000001b & 00111011b = 00000001b
-00000001b & 00111100b = 00000000b
-00000001b & 00111101b = 00000001b
-00000001b & 00111110b = 00000000b
-00000001b & 00111111b = 00000001b
-00000001b & 01000000b = 00000000b
-00000001b & 01000001b = 00000001b
-00000001b & 01000010b = 00000000b
-00000001b & 01000011b = 00000001b
-00000001b & 01000100b = 00000000b
-00000001b & 01000101b = 00000001b
-00000001b & 01000110b = 00000000b
-00000001b & 01000111b = 00000001b
-00000001b & 01001000b = 00000000b
-00000001b & 01001001b = 00000001b
-00000001b & 01001010b = 00000000b
-00000001b & 01001011b = 00000001b
-00000001b & 01001100b = 00000000b
-00000001b & 01001101b = 00000001b
-00000001b & 01001110b = 00000000b
-00000001b & 01001111b = 00000001b
-00000001b & 01010000b = 00000000b
-00000001b & 01010001b = 00000001b
-00000001b & 01010010b = 00000000b
-00000001b & 01010011b = 00000001b
-00000001b & 01010100b = 00000000b
-00000001b & 01010101b = 00000001b
-00000001b & 01010110b = 00000000b
-00000001b & 01010111b = 00000001b
-00000001b & 01011000b = 00000000b
-00000001b & 01011001b = 00000001b
-00000001b & 01011010b = 00000000b
-00000001b & 01011011b = 00000001b
-00000001b & 01011100b = 00000000b
-00000001b & 01011101b = 00000001b
-00000001b & 01011110b = 00000000b
-00000001b & 01011111b = 00000001b
-00000001b & 01100000b = 00000000b
-00000001b & 01100001b = 00000001b
-00000001b & 01100010b = 00000000b
-00000001b & 01100011b = 00000001b
-00000001b & 01100100b = 00000000b
-00000001b & 01100101b = 00000001b
-00000001b & 01100110b = 00000000b
-00000001b & 01100111b = 00000001b
-00000001b & 01101000b = 00000000b
-00000001b & 01101001b = 00000001b
-00000001b & 01101010b = 00000000b
-00000001b & 01101011b = 00000001b
-00000001b & 01101100b = 00000000b
-00000001b & 01101101b = 00000001b
-00000001b & 01101110b = 00000000b
-00000001b & 01101111b = 00000001b
-00000001b & 01110000b = 00000000b
-00000001b & 01110001b = 00000001b
-00000001b & 01110010b = 00000000b
-00000001b & 01110011b = 00000001b
-00000001b & 01110100b = 00000000b
-00000001b & 01110101b = 00000001b
-00000001b & 01110110b = 00000000b
-00000001b & 01110111b = 00000001b
-00000001b & 01111000b = 00000000b
-00000001b & 01111001b = 00000001b
-00000001b & 01111010b = 00000000b
-00000001b & 01111011b = 00000001b
-00000001b & 01111100b = 00000000b
-00000001b & 01111101b = 00000001b
-00000001b & 01111110b = 00000000b
-00000010b & 10000000b = 00000000b
-00000010b & 10000001b = 00000000b
-00000010b & 10000010b = 00000010b
-00000010b & 10000011b = 00000010b
-00000010b & 10000100b = 00000000b
-00000010b & 10000101b = 00000000b
-00000010b & 10000110b = 00000010b
-00000010b & 10000111b = 00000010b
-00000010b & 10001000b = 00000000b
-00000010b & 10001001b = 00000000b
-00000010b & 10001010b = 00000010b
-00000010b & 10001011b = 00000010b
-00000010b & 10001100b = 00000000b
-00000010b & 10001101b = 00000000b
-00000010b & 10001110b = 00000010b
-00000010b & 10001111b = 00000010b
-00000010b & 10010000b = 00000000b
-00000010b & 10010001b = 00000000b
-00000010b & 10010010b = 00000010b
-00000010b & 10010011b = 00000010b
-00000010b & 10010100b = 00000000b
-00000010b & 10010101b = 00000000b
-00000010b & 10010110b = 00000010b
-00000010b & 10010111b = 00000010b
-00000010b & 10011000b = 00000000b
-00000010b & 10011001b = 00000000b
-00000010b & 10011010b = 00000010b
-00000010b & 10011011b = 00000010b
-00000010b & 10011100b = 00000000b
-00000010b & 10011101b = 00000000b
-00000010b & 10011110b = 00000010b
-00000010b & 10011111b = 00000010b
-00000010b & 10100000b = 00000000b
-00000010b & 10100001b = 00000000b
-00000010b & 10100010b = 00000010b
-00000010b & 10100011b = 00000010b
-00000010b & 10100100b = 00000000b
-00000010b & 10100101b = 00000000b
-00000010b & 10100110b = 00000010b
-00000010b & 10100111b = 00000010b
-00000010b & 10101000b = 00000000b
-00000010b & 10101001b = 00000000b
-00000010b & 10101010b = 00000010b
-00000010b & 10101011b = 00000010b
-00000010b & 10101100b = 00000000b
-00000010b & 10101101b = 00000000b
-00000010b & 10101110b = 00000010b
-00000010b & 10101111b = 00000010b
-00000010b & 10110000b = 00000000b
-00000010b & 10110001b = 00000000b
-00000010b & 10110010b = 00000010b
-00000010b & 10110011b = 00000010b
-00000010b & 10110100b = 00000000b
-00000010b & 10110101b = 00000000b
-00000010b & 10110110b = 00000010b
-00000010b & 10110111b = 00000010b
-00000010b & 10111000b = 00000000b
-00000010b & 10111001b = 00000000b
-00000010b & 10111010b = 00000010b
-00000010b & 10111011b = 00000010b
-00000010b & 10111100b = 00000000b
-00000010b & 10111101b = 00000000b
-00000010b & 10111110b = 00000010b
-00000010b & 10111111b = 00000010b
-00000010b & 11000000b = 00000000b
-00000010b & 11000001b = 00000000b
-00000010b & 11000010b = 00000010b
-00000010b & 11000011b = 00000010b
-00000010b & 11000100b = 00000000b
-00000010b & 11000101b = 00000000b
-00000010b & 11000110b = 00000010b
-00000010b & 11000111b = 00000010b
-00000010b & 11001000b = 00000000b
-00000010b & 11001001b = 00000000b
-00000010b & 11001010b = 00000010b
-00000010b & 11001011b = 00000010b
-00000010b & 11001100b = 00000000b
-00000010b & 11001101b = 00000000b
-00000010b & 11001110b = 00000010b
-00000010b & 11001111b = 00000010b
-00000010b & 11010000b = 00000000b
-00000010b & 11010001b = 00000000b
-00000010b & 11010010b = 00000010b
-00000010b & 11010011b = 00000010b
-00000010b & 11010100b = 00000000b
-00000010b & 11010101b = 00000000b
-00000010b & 11010110b = 00000010b
-00000010b & 11010111b = 00000010b
-00000010b & 11011000b = 00000000b
-00000010b & 11011001b = 00000000b
-00000010b & 11011010b = 00000010b
-00000010b & 11011011b = 00000010b
-00000010b & 11011100b = 00000000b
-00000010b & 11011101b = 00000000b
-00000010b & 11011110b = 00000010b
-00000010b & 11011111b = 00000010b
-00000010b & 11100000b = 00000000b
-00000010b & 11100001b = 00000000b
-00000010b & 11100010b = 00000010b
-00000010b & 11100011b = 00000010b
-00000010b & 11100100b = 00000000b
-00000010b & 11100101b = 00000000b
-00000010b & 11100110b = 00000010b
-00000010b & 11100111b = 00000010b
-00000010b & 11101000b = 00000000b
-00000010b & 11101001b = 00000000b
-00000010b & 11101010b = 00000010b
-00000010b & 11101011b = 00000010b
-00000010b & 11101100b = 00000000b
-00000010b & 11101101b = 00000000b
-00000010b & 11101110b = 00000010b
-00000010b & 11101111b = 00000010b
-00000010b & 11110000b = 00000000b
-00000010b & 11110001b = 00000000b
-00000010b & 11110010b = 00000010b
-00000010b & 11110011b = 00000010b
-00000010b & 11110100b = 00000000b
-00000010b & 11110101b = 00000000b
-00000010b & 11110110b = 00000010b
-00000010b & 11110111b = 00000010b
-00000010b & 11111000b = 00000000b
-00000010b & 11111001b = 00000000b
-00000010b & 11111010b = 00000010b
-00000010b & 11111011b = 00000010b
-00000010b & 11111100b = 00000000b
-00000010b & 11111101b = 00000000b
-00000010b & 11111110b = 00000010b
-00000010b & 11111111b = 00000010b
-00000010b & 00000000b = 00000000b
-00000010b & 00000001b = 00000000b
-00000010b & 00000010b = 00000010b
-00000010b & 00000011b = 00000010b
-00000010b & 00000100b = 00000000b
-00000010b & 00000101b = 00000000b
-00000010b & 00000110b = 00000010b
-00000010b & 00000111b = 00000010b
-00000010b & 00001000b = 00000000b
-00000010b & 00001001b = 00000000b
-00000010b & 00001010b = 00000010b
-00000010b & 00001011b = 00000010b
-00000010b & 00001100b = 00000000b
-00000010b & 00001101b = 00000000b
-00000010b & 00001110b = 00000010b
-00000010b & 00001111b = 00000010b
-00000010b & 00010000b = 00000000b
-00000010b & 00010001b = 00000000b
-00000010b & 00010010b = 00000010b
-00000010b & 00010011b = 00000010b
-00000010b & 00010100b = 00000000b
-00000010b & 00010101b = 00000000b
-00000010b & 00010110b = 00000010b
-00000010b & 00010111b = 00000010b
-00000010b & 00011000b = 00000000b
-00000010b & 00011001b = 00000000b
-00000010b & 00011010b = 00000010b
-00000010b & 00011011b = 00000010b
-00000010b & 00011100b = 00000000b
-00000010b & 00011101b = 00000000b
-00000010b & 00011110b = 00000010b
-00000010b & 00011111b = 00000010b
-00000010b & 00100000b = 00000000b
-00000010b & 00100001b = 00000000b
-00000010b & 00100010b = 00000010b
-00000010b & 00100011b = 00000010b
-00000010b & 00100100b = 00000000b
-00000010b & 00100101b = 00000000b
-00000010b & 00100110b = 00000010b
-00000010b & 00100111b = 00000010b
-00000010b & 00101000b = 00000000b
-00000010b & 00101001b = 00000000b
-00000010b & 00101010b = 00000010b
-00000010b & 00101011b = 00000010b
-00000010b & 00101100b = 00000000b
-00000010b & 00101101b = 00000000b
-00000010b & 00101110b = 00000010b
-00000010b & 00101111b = 00000010b
-00000010b & 00110000b = 00000000b
-00000010b & 00110001b = 00000000b
-00000010b & 00110010b = 00000010b
-00000010b & 00110011b = 00000010b
-00000010b & 00110100b = 00000000b
-00000010b & 00110101b = 00000000b
-00000010b & 00110110b = 00000010b
-00000010b & 00110111b = 00000010b
-00000010b & 00111000b = 00000000b
-00000010b & 00111001b = 00000000b
-00000010b & 00111010b = 00000010b
-00000010b & 00111011b = 00000010b
-00000010b & 00111100b = 00000000b
-00000010b & 00111101b = 00000000b
-00000010b & 00111110b = 00000010b
-00000010b & 00111111b = 00000010b
-00000010b & 01000000b = 00000000b
-00000010b & 01000001b = 00000000b
-00000010b & 01000010b = 00000010b
-00000010b & 01000011b = 00000010b
-00000010b & 01000100b = 00000000b
-00000010b & 01000101b = 00000000b
-00000010b & 01000110b = 00000010b
-00000010b & 01000111b = 00000010b
-00000010b & 01001000b = 00000000b
-00000010b & 01001001b = 00000000b
-00000010b & 01001010b = 00000010b
-00000010b & 01001011b = 00000010b
-00000010b & 01001100b = 00000000b
-00000010b & 01001101b = 00000000b
-00000010b & 01001110b = 00000010b
-00000010b & 01001111b = 00000010b
-00000010b & 01010000b = 00000000b
-00000010b & 01010001b = 00000000b
-00000010b & 01010010b = 00000010b
-00000010b & 01010011b = 00000010b
-00000010b & 01010100b = 00000000b
-00000010b & 01010101b = 00000000b
-00000010b & 01010110b = 00000010b
-00000010b & 01010111b = 00000010b
-00000010b & 01011000b = 00000000b
-00000010b & 01011001b = 00000000b
-00000010b & 01011010b = 00000010b
-00000010b & 01011011b = 00000010b
-00000010b & 01011100b = 00000000b
-00000010b & 01011101b = 00000000b
-00000010b & 01011110b = 00000010b
-00000010b & 01011111b = 00000010b
-00000010b & 01100000b = 00000000b
-00000010b & 01100001b = 00000000b
-00000010b & 01100010b = 00000010b
-00000010b & 01100011b = 00000010b
-00000010b & 01100100b = 00000000b
-00000010b & 01100101b = 00000000b
-00000010b & 01100110b = 00000010b
-00000010b & 01100111b = 00000010b
-00000010b & 01101000b = 00000000b
-00000010b & 01101001b = 00000000b
-00000010b & 01101010b = 00000010b
-00000010b & 01101011b = 00000010b
-00000010b & 01101100b = 00000000b
-00000010b & 01101101b = 00000000b
-00000010b & 01101110b = 00000010b
-00000010b & 01101111b = 00000010b
-00000010b & 01110000b = 00000000b
-00000010b & 01110001b = 00000000b
-00000010b & 01110010b = 00000010b
-00000010b & 01110011b = 00000010b
-00000010b & 01110100b = 00000000b
-00000010b & 01110101b = 00000000b
-00000010b & 01110110b = 00000010b
-00000010b & 01110111b = 00000010b
-00000010b & 01111000b = 00000000b
-00000010b & 01111001b = 00000000b
-00000010b & 01111010b = 00000010b
-00000010b & 01111011b = 00000010b
-00000010b & 01111100b = 00000000b
-00000010b & 01111101b = 00000000b
-00000010b & 01111110b = 00000010b
-00000011b & 10000000b = 00000000b
-00000011b & 10000001b = 00000001b
-00000011b & 10000010b = 00000010b
-00000011b & 10000011b = 00000011b
-00000011b & 10000100b = 00000000b
-00000011b & 10000101b = 00000001b
-00000011b & 10000110b = 00000010b
-00000011b & 10000111b = 00000011b
-00000011b & 10001000b = 00000000b
-00000011b & 10001001b = 00000001b
-00000011b & 10001010b = 00000010b
-00000011b & 10001011b = 00000011b
-00000011b & 10001100b = 00000000b
-00000011b & 10001101b = 00000001b
-00000011b & 10001110b = 00000010b
-00000011b & 10001111b = 00000011b
-00000011b & 10010000b = 00000000b
-00000011b & 10010001b = 00000001b
-00000011b & 10010010b = 00000010b
-00000011b & 10010011b = 00000011b
-00000011b & 10010100b = 00000000b
-00000011b & 10010101b = 00000001b
-00000011b & 10010110b = 00000010b
-00000011b & 10010111b = 00000011b
-00000011b & 10011000b = 00000000b
-00000011b & 10011001b = 00000001b
-00000011b & 10011010b = 00000010b
-00000011b & 10011011b = 00000011b
-00000011b & 10011100b = 00000000b
-00000011b & 10011101b = 00000001b
-00000011b & 10011110b = 00000010b
-00000011b & 10011111b = 00000011b
-00000011b & 10100000b = 00000000b
-00000011b & 10100001b = 00000001b
-00000011b & 10100010b = 00000010b
-00000011b & 10100011b = 00000011b
-00000011b & 10100100b = 00000000b
-00000011b & 10100101b = 00000001b
-00000011b & 10100110b = 00000010b
-00000011b & 10100111b = 00000011b
-00000011b & 10101000b = 00000000b
-00000011b & 10101001b = 00000001b
-00000011b & 10101010b = 00000010b
-00000011b & 10101011b = 00000011b
-00000011b & 10101100b = 00000000b
-00000011b & 10101101b = 00000001b
-00000011b & 10101110b = 00000010b
-00000011b & 10101111b = 00000011b
-00000011b & 10110000b = 00000000b
-00000011b & 10110001b = 00000001b
-00000011b & 10110010b = 00000010b
-00000011b & 10110011b = 00000011b
-00000011b & 10110100b = 00000000b
-00000011b & 10110101b = 00000001b
-00000011b & 10110110b = 00000010b
-00000011b & 10110111b = 00000011b
-00000011b & 10111000b = 00000000b
-00000011b & 10111001b = 00000001b
-00000011b & 10111010b = 00000010b
-00000011b & 10111011b = 00000011b
-00000011b & 10111100b = 00000000b
-00000011b & 10111101b = 00000001b
-00000011b & 10111110b = 00000010b
-00000011b & 10111111b = 00000011b
-00000011b & 11000000b = 00000000b
-00000011b & 11000001b = 00000001b
-00000011b & 11000010b = 00000010b
-00000011b & 11000011b = 00000011b
-00000011b & 11000100b = 00000000b
-00000011b & 11000101b = 00000001b
-00000011b & 11000110b = 00000010b
-00000011b & 11000111b = 00000011b
-00000011b & 11001000b = 00000000b
-00000011b & 11001001b = 00000001b
-00000011b & 11001010b = 00000010b
-00000011b & 11001011b = 00000011b
-00000011b & 11001100b = 00000000b
-00000011b & 11001101b = 00000001b
-00000011b & 11001110b = 00000010b
-00000011b & 11001111b = 00000011b
-00000011b & 11010000b = 00000000b
-00000011b & 11010001b = 00000001b
-00000011b & 11010010b = 00000010b
-00000011b & 11010011b = 00000011b
-00000011b & 11010100b = 00000000b
-00000011b & 11010101b = 00000001b
-00000011b & 11010110b = 00000010b
-00000011b & 11010111b = 00000011b
-00000011b & 11011000b = 00000000b
-00000011b & 11011001b = 00000001b
-00000011b & 11011010b = 00000010b
-00000011b & 11011011b = 00000011b
-00000011b & 11011100b = 00000000b
-00000011b & 11011101b = 00000001b
-00000011b & 11011110b = 00000010b
-00000011b & 11011111b = 00000011b
-00000011b & 11100000b = 00000000b
-00000011b & 11100001b = 00000001b
-00000011b & 11100010b = 00000010b
-00000011b & 11100011b = 00000011b
-00000011b & 11100100b = 00000000b
-00000011b & 11100101b = 00000001b
-00000011b & 11100110b = 00000010b
-00000011b & 11100111b = 00000011b
-00000011b & 11101000b = 00000000b
-00000011b & 11101001b = 00000001b
-00000011b & 11101010b = 00000010b
-00000011b & 11101011b = 00000011b
-00000011b & 11101100b = 00000000b
-00000011b & 11101101b = 00000001b
-00000011b & 11101110b = 00000010b
-00000011b & 11101111b = 00000011b
-00000011b & 11110000b = 00000000b
-00000011b & 11110001b = 00000001b
-00000011b & 11110010b = 00000010b
-00000011b & 11110011b = 00000011b
-00000011b & 11110100b = 00000000b
-00000011b & 11110101b = 00000001b
-00000011b & 11110110b = 00000010b
-00000011b & 11110111b = 00000011b
-00000011b & 11111000b = 00000000b
-00000011b & 11111001b = 00000001b
-00000011b & 11111010b = 00000010b
-00000011b & 11111011b = 00000011b
-00000011b & 11111100b = 00000000b
-00000011b & 11111101b = 00000001b
-00000011b & 11111110b = 00000010b
-00000011b & 11111111b = 00000011b
-00000011b & 00000000b = 00000000b
-00000011b & 00000001b = 00000001b
-00000011b & 00000010b = 00000010b
-00000011b & 00000011b = 00000011b
-00000011b & 00000100b = 00000000b
-00000011b & 00000101b = 00000001b
-00000011b & 00000110b = 00000010b
-00000011b & 00000111b = 00000011b
-00000011b & 00001000b = 00000000b
-00000011b & 00001001b = 00000001b
-00000011b & 00001010b = 00000010b
-00000011b & 00001011b = 00000011b
-00000011b & 00001100b = 00000000b
-00000011b & 00001101b = 00000001b
-00000011b & 00001110b = 00000010b
-00000011b & 00001111b = 00000011b
-00000011b & 00010000b = 00000000b
-00000011b & 00010001b = 00000001b
-00000011b & 00010010b = 00000010b
-00000011b & 00010011b = 00000011b
-00000011b & 00010100b = 00000000b
-00000011b & 00010101b = 00000001b
-00000011b & 00010110b = 00000010b
-00000011b & 00010111b = 00000011b
-00000011b & 00011000b = 00000000b
-00000011b & 00011001b = 00000001b
-00000011b & 00011010b = 00000010b
-00000011b & 00011011b = 00000011b
-00000011b & 00011100b = 00000000b
-00000011b & 00011101b = 00000001b
-00000011b & 00011110b = 00000010b
-00000011b & 00011111b = 00000011b
-00000011b & 00100000b = 00000000b
-00000011b & 00100001b = 00000001b
-00000011b & 00100010b = 00000010b
-00000011b & 00100011b = 00000011b
-00000011b & 00100100b = 00000000b
-00000011b & 00100101b = 00000001b
-00000011b & 00100110b = 00000010b
-00000011b & 00100111b = 00000011b
-00000011b & 00101000b = 00000000b
-00000011b & 00101001b = 00000001b
-00000011b & 00101010b = 00000010b
-00000011b & 00101011b = 00000011b
-00000011b & 00101100b = 00000000b
-00000011b & 00101101b = 00000001b
-00000011b & 00101110b = 00000010b
-00000011b & 00101111b = 00000011b
-00000011b & 00110000b = 00000000b
-00000011b & 00110001b = 00000001b
-00000011b & 00110010b = 00000010b
-00000011b & 00110011b = 00000011b
-00000011b & 00110100b = 00000000b
-00000011b & 00110101b = 00000001b
-00000011b & 00110110b = 00000010b
-00000011b & 00110111b = 00000011b
-00000011b & 00111000b = 00000000b
-00000011b & 00111001b = 00000001b
-00000011b & 00111010b = 00000010b
-00000011b & 00111011b = 00000011b
-00000011b & 00111100b = 00000000b
-00000011b & 00111101b = 00000001b
-00000011b & 00111110b = 00000010b
-00000011b & 00111111b = 00000011b
-00000011b & 01000000b = 00000000b
-00000011b & 01000001b = 00000001b
-00000011b & 01000010b = 00000010b
-00000011b & 01000011b = 00000011b
-00000011b & 01000100b = 00000000b
-00000011b & 01000101b = 00000001b
-00000011b & 01000110b = 00000010b
-00000011b & 01000111b = 00000011b
-00000011b & 01001000b = 00000000b
-00000011b & 01001001b = 00000001b
-00000011b & 01001010b = 00000010b
-00000011b & 01001011b = 00000011b
-00000011b & 01001100b = 00000000b
-00000011b & 01001101b = 00000001b
-00000011b & 01001110b = 00000010b
-00000011b & 01001111b = 00000011b
-00000011b & 01010000b = 00000000b
-00000011b & 01010001b = 00000001b
-00000011b & 01010010b = 00000010b
-00000011b & 01010011b = 00000011b
-00000011b & 01010100b = 00000000b
-00000011b & 01010101b = 00000001b
-00000011b & 01010110b = 00000010b
-00000011b & 01010111b = 00000011b
-00000011b & 01011000b = 00000000b
-00000011b & 01011001b = 00000001b
-00000011b & 01011010b = 00000010b
-00000011b & 01011011b = 00000011b
-00000011b & 01011100b = 00000000b
-00000011b & 01011101b = 00000001b
-00000011b & 01011110b = 00000010b
-00000011b & 01011111b = 00000011b
-00000011b & 01100000b = 00000000b
-00000011b & 01100001b = 00000001b
-00000011b & 01100010b = 00000010b
-00000011b & 01100011b = 00000011b
-00000011b & 01100100b = 00000000b
-00000011b & 01100101b = 00000001b
-00000011b & 01100110b = 00000010b
-00000011b & 01100111b = 00000011b
-00000011b & 01101000b = 00000000b
-00000011b & 01101001b = 00000001b
-00000011b & 01101010b = 00000010b
-00000011b & 01101011b = 00000011b
-00000011b & 01101100b = 00000000b
-00000011b & 01101101b = 00000001b
-00000011b & 01101110b = 00000010b
-00000011b & 01101111b = 00000011b
-00000011b & 01110000b = 00000000b
-00000011b & 01110001b = 00000001b
-00000011b & 01110010b = 00000010b
-00000011b & 01110011b = 00000011b
-00000011b & 01110100b = 00000000b
-00000011b & 01110101b = 00000001b
-00000011b & 01110110b = 00000010b
-00000011b & 01110111b = 00000011b
-00000011b & 01111000b = 00000000b
-00000011b & 01111001b = 00000001b
-00000011b & 01111010b = 00000010b
-00000011b & 01111011b = 00000011b
-00000011b & 01111100b = 00000000b
-00000011b & 01111101b = 00000001b
-00000011b & 01111110b = 00000010b
-00000100b & 10000000b = 00000000b
-00000100b & 10000001b = 00000000b
-00000100b & 10000010b = 00000000b
-00000100b & 10000011b = 00000000b
-00000100b & 10000100b = 00000100b
-00000100b & 10000101b = 00000100b
-00000100b & 10000110b = 00000100b
-00000100b & 10000111b = 00000100b
-00000100b & 10001000b = 00000000b
-00000100b & 10001001b = 00000000b
-00000100b & 10001010b = 00000000b
-00000100b & 10001011b = 00000000b
-00000100b & 10001100b = 00000100b
-00000100b & 10001101b = 00000100b
-00000100b & 10001110b = 00000100b
-00000100b & 10001111b = 00000100b
-00000100b & 10010000b = 00000000b
-00000100b & 10010001b = 00000000b
-00000100b & 10010010b = 00000000b
-00000100b & 10010011b = 00000000b
-00000100b & 10010100b = 00000100b
-00000100b & 10010101b = 00000100b
-00000100b & 10010110b = 00000100b
-00000100b & 10010111b = 00000100b
-00000100b & 10011000b = 00000000b
-00000100b & 10011001b = 00000000b
-00000100b & 10011010b = 00000000b
-00000100b & 10011011b = 00000000b
-00000100b & 10011100b = 00000100b
-00000100b & 10011101b = 00000100b
-00000100b & 10011110b = 00000100b
-00000100b & 10011111b = 00000100b
-00000100b & 10100000b = 00000000b
-00000100b & 10100001b = 00000000b
-00000100b & 10100010b = 00000000b
-00000100b & 10100011b = 00000000b
-00000100b & 10100100b = 00000100b
-00000100b & 10100101b = 00000100b
-00000100b & 10100110b = 00000100b
-00000100b & 10100111b = 00000100b
-00000100b & 10101000b = 00000000b
-00000100b & 10101001b = 00000000b
-00000100b & 10101010b = 00000000b
-00000100b & 10101011b = 00000000b
-00000100b & 10101100b = 00000100b
-00000100b & 10101101b = 00000100b
-00000100b & 10101110b = 00000100b
-00000100b & 10101111b = 00000100b
-00000100b & 10110000b = 00000000b
-00000100b & 10110001b = 00000000b
-00000100b & 10110010b = 00000000b
-00000100b & 10110011b = 00000000b
-00000100b & 10110100b = 00000100b
-00000100b & 10110101b = 00000100b
-00000100b & 10110110b = 00000100b
-00000100b & 10110111b = 00000100b
-00000100b & 10111000b = 00000000b
-00000100b & 10111001b = 00000000b
-00000100b & 10111010b = 00000000b
-00000100b & 10111011b = 00000000b
-00000100b & 10111100b = 00000100b
-00000100b & 10111101b = 00000100b
-00000100b & 10111110b = 00000100b
-00000100b & 10111111b = 00000100b
-00000100b & 11000000b = 00000000b
-00000100b & 11000001b = 00000000b
-00000100b & 11000010b = 00000000b
-00000100b & 11000011b = 00000000b
-00000100b & 11000100b = 00000100b
-00000100b & 11000101b = 00000100b
-00000100b & 11000110b = 00000100b
-00000100b & 11000111b = 00000100b
-00000100b & 11001000b = 00000000b
-00000100b & 11001001b = 00000000b
-00000100b & 11001010b = 00000000b
-00000100b & 11001011b = 00000000b
-00000100b & 11001100b = 00000100b
-00000100b & 11001101b = 00000100b
-00000100b & 11001110b = 00000100b
-00000100b & 11001111b = 00000100b
-00000100b & 11010000b = 00000000b
-00000100b & 11010001b = 00000000b
-00000100b & 11010010b = 00000000b
-00000100b & 11010011b = 00000000b
-00000100b & 11010100b = 00000100b
-00000100b & 11010101b = 00000100b
-00000100b & 11010110b = 00000100b
-00000100b & 11010111b = 00000100b
-00000100b & 11011000b = 00000000b
-00000100b & 11011001b = 00000000b
-00000100b & 11011010b = 00000000b
-00000100b & 11011011b = 00000000b
-00000100b & 11011100b = 00000100b
-00000100b & 11011101b = 00000100b
-00000100b & 11011110b = 00000100b
-00000100b & 11011111b = 00000100b
-00000100b & 11100000b = 00000000b
-00000100b & 11100001b = 00000000b
-00000100b & 11100010b = 00000000b
-00000100b & 11100011b = 00000000b
-00000100b & 11100100b = 00000100b
-00000100b & 11100101b = 00000100b
-00000100b & 11100110b = 00000100b
-00000100b & 11100111b = 00000100b
-00000100b & 11101000b = 00000000b
-00000100b & 11101001b = 00000000b
-00000100b & 11101010b = 00000000b
-00000100b & 11101011b = 00000000b
-00000100b & 11101100b = 00000100b
-00000100b & 11101101b = 00000100b
-00000100b & 11101110b = 00000100b
-00000100b & 11101111b = 00000100b
-00000100b & 11110000b = 00000000b
-00000100b & 11110001b = 00000000b
-00000100b & 11110010b = 00000000b
-00000100b & 11110011b = 00000000b
-00000100b & 11110100b = 00000100b
-00000100b & 11110101b = 00000100b
-00000100b & 11110110b = 00000100b
-00000100b & 11110111b = 00000100b
-00000100b & 11111000b = 00000000b
-00000100b & 11111001b = 00000000b
-00000100b & 11111010b = 00000000b
-00000100b & 11111011b = 00000000b
-00000100b & 11111100b = 00000100b
-00000100b & 11111101b = 00000100b
-00000100b & 11111110b = 00000100b
-00000100b & 11111111b = 00000100b
-00000100b & 00000000b = 00000000b
-00000100b & 00000001b = 00000000b
-00000100b & 00000010b = 00000000b
-00000100b & 00000011b = 00000000b
-00000100b & 00000100b = 00000100b
-00000100b & 00000101b = 00000100b
-00000100b & 00000110b = 00000100b
-00000100b & 00000111b = 00000100b
-00000100b & 00001000b = 00000000b
-00000100b & 00001001b = 00000000b
-00000100b & 00001010b = 00000000b
-00000100b & 00001011b = 00000000b
-00000100b & 00001100b = 00000100b
-00000100b & 00001101b = 00000100b
-00000100b & 00001110b = 00000100b
-00000100b & 00001111b = 00000100b
-00000100b & 00010000b = 00000000b
-00000100b & 00010001b = 00000000b
-00000100b & 00010010b = 00000000b
-00000100b & 00010011b = 00000000b
-00000100b & 00010100b = 00000100b
-00000100b & 00010101b = 00000100b
-00000100b & 00010110b = 00000100b
-00000100b & 00010111b = 00000100b
-00000100b & 00011000b = 00000000b
-00000100b & 00011001b = 00000000b
-00000100b & 00011010b = 00000000b
-00000100b & 00011011b = 00000000b
-00000100b & 00011100b = 00000100b
-00000100b & 00011101b = 00000100b
-00000100b & 00011110b = 00000100b
-00000100b & 00011111b = 00000100b
-00000100b & 00100000b = 00000000b
-00000100b & 00100001b = 00000000b
-00000100b & 00100010b = 00000000b
-00000100b & 00100011b = 00000000b
-00000100b & 00100100b = 00000100b
-00000100b & 00100101b = 00000100b
-00000100b & 00100110b = 00000100b
-00000100b & 00100111b = 00000100b
-00000100b & 00101000b = 00000000b
-00000100b & 00101001b = 00000000b
-00000100b & 00101010b = 00000000b
-00000100b & 00101011b = 00000000b
-00000100b & 00101100b = 00000100b
-00000100b & 00101101b = 00000100b
-00000100b & 00101110b = 00000100b
-00000100b & 00101111b = 00000100b
-00000100b & 00110000b = 00000000b
-00000100b & 00110001b = 00000000b
-00000100b & 00110010b = 00000000b
-00000100b & 00110011b = 00000000b
-00000100b & 00110100b = 00000100b
-00000100b & 00110101b = 00000100b
-00000100b & 00110110b = 00000100b
-00000100b & 00110111b = 00000100b
-00000100b & 00111000b = 00000000b
-00000100b & 00111001b = 00000000b
-00000100b & 00111010b = 00000000b
-00000100b & 00111011b = 00000000b
-00000100b & 00111100b = 00000100b
-00000100b & 00111101b = 00000100b
-00000100b & 00111110b = 00000100b
-00000100b & 00111111b = 00000100b
-00000100b & 01000000b = 00000000b
-00000100b & 01000001b = 00000000b
-00000100b & 01000010b = 00000000b
-00000100b & 01000011b = 00000000b
-00000100b & 01000100b = 00000100b
-00000100b & 01000101b = 00000100b
-00000100b & 01000110b = 00000100b
-00000100b & 01000111b = 00000100b
-00000100b & 01001000b = 00000000b
-00000100b & 01001001b = 00000000b
-00000100b & 01001010b = 00000000b
-00000100b & 01001011b = 00000000b
-00000100b & 01001100b = 00000100b
-00000100b & 01001101b = 00000100b
-00000100b & 01001110b = 00000100b
-00000100b & 01001111b = 00000100b
-00000100b & 01010000b = 00000000b
-00000100b & 01010001b = 00000000b
-00000100b & 01010010b = 00000000b
-00000100b & 01010011b = 00000000b
-00000100b & 01010100b = 00000100b
-00000100b & 01010101b = 00000100b
-00000100b & 01010110b = 00000100b
-00000100b & 01010111b = 00000100b
-00000100b & 01011000b = 00000000b
-00000100b & 01011001b = 00000000b
-00000100b & 01011010b = 00000000b
-00000100b & 01011011b = 00000000b
-00000100b & 01011100b = 00000100b
-00000100b & 01011101b = 00000100b
-00000100b & 01011110b = 00000100b
-00000100b & 01011111b = 00000100b
-00000100b & 01100000b = 00000000b
-00000100b & 01100001b = 00000000b
-00000100b & 01100010b = 00000000b
-00000100b & 01100011b = 00000000b
-00000100b & 01100100b = 00000100b
-00000100b & 01100101b = 00000100b
-00000100b & 01100110b = 00000100b
-00000100b & 01100111b = 00000100b
-00000100b & 01101000b = 00000000b
-00000100b & 01101001b = 00000000b
-00000100b & 01101010b = 00000000b
-00000100b & 01101011b = 00000000b
-00000100b & 01101100b = 00000100b
-00000100b & 01101101b = 00000100b
-00000100b & 01101110b = 00000100b
-00000100b & 01101111b = 00000100b
-00000100b & 01110000b = 00000000b
-00000100b & 01110001b = 00000000b
-00000100b & 01110010b = 00000000b
-00000100b & 01110011b = 00000000b
-00000100b & 01110100b = 00000100b
-00000100b & 01110101b = 00000100b
-00000100b & 01110110b = 00000100b
-00000100b & 01110111b = 00000100b
-00000100b & 01111000b = 00000000b
-00000100b & 01111001b = 00000000b
-00000100b & 01111010b = 00000000b
-00000100b & 01111011b = 00000000b
-00000100b & 01111100b = 00000100b
-00000100b & 01111101b = 00000100b
-00000100b & 01111110b = 00000100b
-00000101b & 10000000b = 00000000b
-00000101b & 10000001b = 00000001b
-00000101b & 10000010b = 00000000b
-00000101b & 10000011b = 00000001b
-00000101b & 10000100b = 00000100b
-00000101b & 10000101b = 00000101b
-00000101b & 10000110b = 00000100b
-00000101b & 10000111b = 00000101b
-00000101b & 10001000b = 00000000b
-00000101b & 10001001b = 00000001b
-00000101b & 10001010b = 00000000b
-00000101b & 10001011b = 00000001b
-00000101b & 10001100b = 00000100b
-00000101b & 10001101b = 00000101b
-00000101b & 10001110b = 00000100b
-00000101b & 10001111b = 00000101b
-00000101b & 10010000b = 00000000b
-00000101b & 10010001b = 00000001b
-00000101b & 10010010b = 00000000b
-00000101b & 10010011b = 00000001b
-00000101b & 10010100b = 00000100b
-00000101b & 10010101b = 00000101b
-00000101b & 10010110b = 00000100b
-00000101b & 10010111b = 00000101b
-00000101b & 10011000b = 00000000b
-00000101b & 10011001b = 00000001b
-00000101b & 10011010b = 00000000b
-00000101b & 10011011b = 00000001b
-00000101b & 10011100b = 00000100b
-00000101b & 10011101b = 00000101b
-00000101b & 10011110b = 00000100b
-00000101b & 10011111b = 00000101b
-00000101b & 10100000b = 00000000b
-00000101b & 10100001b = 00000001b
-00000101b & 10100010b = 00000000b
-00000101b & 10100011b = 00000001b
-00000101b & 10100100b = 00000100b
-00000101b & 10100101b = 00000101b
-00000101b & 10100110b = 00000100b
-00000101b & 10100111b = 00000101b
-00000101b & 10101000b = 00000000b
-00000101b & 10101001b = 00000001b
-00000101b & 10101010b = 00000000b
-00000101b & 10101011b = 00000001b
-00000101b & 10101100b = 00000100b
-00000101b & 10101101b = 00000101b
-00000101b & 10101110b = 00000100b
-00000101b & 10101111b = 00000101b
-00000101b & 10110000b = 00000000b
-00000101b & 10110001b = 00000001b
-00000101b & 10110010b = 00000000b
-00000101b & 10110011b = 00000001b
-00000101b & 10110100b = 00000100b
-00000101b & 10110101b = 00000101b
-00000101b & 10110110b = 00000100b
-00000101b & 10110111b = 00000101b
-00000101b & 10111000b = 00000000b
-00000101b & 10111001b = 00000001b
-00000101b & 10111010b = 00000000b
-00000101b & 10111011b = 00000001b
-00000101b & 10111100b = 00000100b
-00000101b & 10111101b = 00000101b
-00000101b & 10111110b = 00000100b
-00000101b & 10111111b = 00000101b
-00000101b & 11000000b = 00000000b
-00000101b & 11000001b = 00000001b
-00000101b & 11000010b = 00000000b
-00000101b & 11000011b = 00000001b
-00000101b & 11000100b = 00000100b
-00000101b & 11000101b = 00000101b
-00000101b & 11000110b = 00000100b
-00000101b & 11000111b = 00000101b
-00000101b & 11001000b = 00000000b
-00000101b & 11001001b = 00000001b
-00000101b & 11001010b = 00000000b
-00000101b & 11001011b = 00000001b
-00000101b & 11001100b = 00000100b
-00000101b & 11001101b = 00000101b
-00000101b & 11001110b = 00000100b
-00000101b & 11001111b = 00000101b
-00000101b & 11010000b = 00000000b
-00000101b & 11010001b = 00000001b
-00000101b & 11010010b = 00000000b
-00000101b & 11010011b = 00000001b
-00000101b & 11010100b = 00000100b
-00000101b & 11010101b = 00000101b
-00000101b & 11010110b = 00000100b
-00000101b & 11010111b = 00000101b
-00000101b & 11011000b = 00000000b
-00000101b & 11011001b = 00000001b
-00000101b & 11011010b = 00000000b
-00000101b & 11011011b = 00000001b
-00000101b & 11011100b = 00000100b
-00000101b & 11011101b = 00000101b
-00000101b & 11011110b = 00000100b
-00000101b & 11011111b = 00000101b
-00000101b & 11100000b = 00000000b
-00000101b & 11100001b = 00000001b
-00000101b & 11100010b = 00000000b
-00000101b & 11100011b = 00000001b
-00000101b & 11100100b = 00000100b
-00000101b & 11100101b = 00000101b
-00000101b & 11100110b = 00000100b
-00000101b & 11100111b = 00000101b
-00000101b & 11101000b = 00000000b
-00000101b & 11101001b = 00000001b
-00000101b & 11101010b = 00000000b
-00000101b & 11101011b = 00000001b
-00000101b & 11101100b = 00000100b
-00000101b & 11101101b = 00000101b
-00000101b & 11101110b = 00000100b
-00000101b & 11101111b = 00000101b
-00000101b & 11110000b = 00000000b
-00000101b & 11110001b = 00000001b
-00000101b & 11110010b = 00000000b
-00000101b & 11110011b = 00000001b
-00000101b & 11110100b = 00000100b
-00000101b & 11110101b = 00000101b
-00000101b & 11110110b = 00000100b
-00000101b & 11110111b = 00000101b
-00000101b & 11111000b = 00000000b
-00000101b & 11111001b = 00000001b
-00000101b & 11111010b = 00000000b
-00000101b & 11111011b = 00000001b
-00000101b & 11111100b = 00000100b
-00000101b & 11111101b = 00000101b
-00000101b & 11111110b = 00000100b
-00000101b & 11111111b = 00000101b
-00000101b & 00000000b = 00000000b
-00000101b & 00000001b = 00000001b
-00000101b & 00000010b = 00000000b
-00000101b & 00000011b = 00000001b
-00000101b & 00000100b = 00000100b
-00000101b & 00000101b = 00000101b
-00000101b & 00000110b = 00000100b
-00000101b & 00000111b = 00000101b
-00000101b & 00001000b = 00000000b
-00000101b & 00001001b = 00000001b
-00000101b & 00001010b = 00000000b
-00000101b & 00001011b = 00000001b
-00000101b & 00001100b = 00000100b
-00000101b & 00001101b = 00000101b
-00000101b & 00001110b = 00000100b
-00000101b & 00001111b = 00000101b
-00000101b & 00010000b = 00000000b
-00000101b & 00010001b = 00000001b
-00000101b & 00010010b = 00000000b
-00000101b & 00010011b = 00000001b
-00000101b & 00010100b = 00000100b
-00000101b & 00010101b = 00000101b
-00000101b & 00010110b = 00000100b
-00000101b & 00010111b = 00000101b
-00000101b & 00011000b = 00000000b
-00000101b & 00011001b = 00000001b
-00000101b & 00011010b = 00000000b
-00000101b & 00011011b = 00000001b
-00000101b & 00011100b = 00000100b
-00000101b & 00011101b = 00000101b
-00000101b & 00011110b = 00000100b
-00000101b & 00011111b = 00000101b
-00000101b & 00100000b = 00000000b
-00000101b & 00100001b = 00000001b
-00000101b & 00100010b = 00000000b
-00000101b & 00100011b = 00000001b
-00000101b & 00100100b = 00000100b
-00000101b & 00100101b = 00000101b
-00000101b & 00100110b = 00000100b
-00000101b & 00100111b = 00000101b
-00000101b & 00101000b = 00000000b
-00000101b & 00101001b = 00000001b
-00000101b & 00101010b = 00000000b
-00000101b & 00101011b = 00000001b
-00000101b & 00101100b = 00000100b
-00000101b & 00101101b = 00000101b
-00000101b & 00101110b = 00000100b
-00000101b & 00101111b = 00000101b
-00000101b & 00110000b = 00000000b
-00000101b & 00110001b = 00000001b
-00000101b & 00110010b = 00000000b
-00000101b & 00110011b = 00000001b
-00000101b & 00110100b = 00000100b
-00000101b & 00110101b = 00000101b
-00000101b & 00110110b = 00000100b
-00000101b & 00110111b = 00000101b
-00000101b & 00111000b = 00000000b
-00000101b & 00111001b = 00000001b
-00000101b & 00111010b = 00000000b
-00000101b & 00111011b = 00000001b
-00000101b & 00111100b = 00000100b
-00000101b & 00111101b = 00000101b
-00000101b & 00111110b = 00000100b
-00000101b & 00111111b = 00000101b
-00000101b & 01000000b = 00000000b
-00000101b & 01000001b = 00000001b
-00000101b & 01000010b = 00000000b
-00000101b & 01000011b = 00000001b
-00000101b & 01000100b = 00000100b
-00000101b & 01000101b = 00000101b
-00000101b & 01000110b = 00000100b
-00000101b & 01000111b = 00000101b
-00000101b & 01001000b = 00000000b
-00000101b & 01001001b = 00000001b
-00000101b & 01001010b = 00000000b
-00000101b & 01001011b = 00000001b
-00000101b & 01001100b = 00000100b
-00000101b & 01001101b = 00000101b
-00000101b & 01001110b = 00000100b
-00000101b & 01001111b = 00000101b
-00000101b & 01010000b = 00000000b
-00000101b & 01010001b = 00000001b
-00000101b & 01010010b = 00000000b
-00000101b & 01010011b = 00000001b
-00000101b & 01010100b = 00000100b
-00000101b & 01010101b = 00000101b
-00000101b & 01010110b = 00000100b
-00000101b & 01010111b = 00000101b
-00000101b & 01011000b = 00000000b
-00000101b & 01011001b = 00000001b
-00000101b & 01011010b = 00000000b
-00000101b & 01011011b = 00000001b
-00000101b & 01011100b = 00000100b
-00000101b & 01011101b = 00000101b
-00000101b & 01011110b = 00000100b
-00000101b & 01011111b = 00000101b
-00000101b & 01100000b = 00000000b
-00000101b & 01100001b = 00000001b
-00000101b & 01100010b = 00000000b
-00000101b & 01100011b = 00000001b
-00000101b & 01100100b = 00000100b
-00000101b & 01100101b = 00000101b
-00000101b & 01100110b = 00000100b
-00000101b & 01100111b = 00000101b
-00000101b & 01101000b = 00000000b
-00000101b & 01101001b = 00000001b
-00000101b & 01101010b = 00000000b
-00000101b & 01101011b = 00000001b
-00000101b & 01101100b = 00000100b
-00000101b & 01101101b = 00000101b
-00000101b & 01101110b = 00000100b
-00000101b & 01101111b = 00000101b
-00000101b & 01110000b = 00000000b
-00000101b & 01110001b = 00000001b
-00000101b & 01110010b = 00000000b
-00000101b & 01110011b = 00000001b
-00000101b & 01110100b = 00000100b
-00000101b & 01110101b = 00000101b
-00000101b & 01110110b = 00000100b
-00000101b & 01110111b = 00000101b
-00000101b & 01111000b = 00000000b
-00000101b & 01111001b = 00000001b
-00000101b & 01111010b = 00000000b
-00000101b & 01111011b = 00000001b
-00000101b & 01111100b = 00000100b
-00000101b & 01111101b = 00000101b
-00000101b & 01111110b = 00000100b
-00000110b & 10000000b = 00000000b
-00000110b & 10000001b = 00000000b
-00000110b & 10000010b = 00000010b
-00000110b & 10000011b = 00000010b
-00000110b & 10000100b = 00000100b
-00000110b & 10000101b = 00000100b
-00000110b & 10000110b = 00000110b
-00000110b & 10000111b = 00000110b
-00000110b & 10001000b = 00000000b
-00000110b & 10001001b = 00000000b
-00000110b & 10001010b = 00000010b
-00000110b & 10001011b = 00000010b
-00000110b & 10001100b = 00000100b
-00000110b & 10001101b = 00000100b
-00000110b & 10001110b = 00000110b
-00000110b & 10001111b = 00000110b
-00000110b & 10010000b = 00000000b
-00000110b & 10010001b = 00000000b
-00000110b & 10010010b = 00000010b
-00000110b & 10010011b = 00000010b
-00000110b & 10010100b = 00000100b
-00000110b & 10010101b = 00000100b
-00000110b & 10010110b = 00000110b
-00000110b & 10010111b = 00000110b
-00000110b & 10011000b = 00000000b
-00000110b & 10011001b = 00000000b
-00000110b & 10011010b = 00000010b
-00000110b & 10011011b = 00000010b
-00000110b & 10011100b = 00000100b
-00000110b & 10011101b = 00000100b
-00000110b & 10011110b = 00000110b
-00000110b & 10011111b = 00000110b
-00000110b & 10100000b = 00000000b
-00000110b & 10100001b = 00000000b
-00000110b & 10100010b = 00000010b
-00000110b & 10100011b = 00000010b
-00000110b & 10100100b = 00000100b
-00000110b & 10100101b = 00000100b
-00000110b & 10100110b = 00000110b
-00000110b & 10100111b = 00000110b
-00000110b & 10101000b = 00000000b
-00000110b & 10101001b = 00000000b
-00000110b & 10101010b = 00000010b
-00000110b & 10101011b = 00000010b
-00000110b & 10101100b = 00000100b
-00000110b & 10101101b = 00000100b
-00000110b & 10101110b = 00000110b
-00000110b & 10101111b = 00000110b
-00000110b & 10110000b = 00000000b
-00000110b & 10110001b = 00000000b
-00000110b & 10110010b = 00000010b
-00000110b & 10110011b = 00000010b
-00000110b & 10110100b = 00000100b
-00000110b & 10110101b = 00000100b
-00000110b & 10110110b = 00000110b
-00000110b & 10110111b = 00000110b
-00000110b & 10111000b = 00000000b
-00000110b & 10111001b = 00000000b
-00000110b & 10111010b = 00000010b
-00000110b & 10111011b = 00000010b
-00000110b & 10111100b = 00000100b
-00000110b & 10111101b = 00000100b
-00000110b & 10111110b = 00000110b
-00000110b & 10111111b = 00000110b
-00000110b & 11000000b = 00000000b
-00000110b & 11000001b = 00000000b
-00000110b & 11000010b = 00000010b
-00000110b & 11000011b = 00000010b
-00000110b & 11000100b = 00000100b
-00000110b & 11000101b = 00000100b
-00000110b & 11000110b = 00000110b
-00000110b & 11000111b = 00000110b
-00000110b & 11001000b = 00000000b
-00000110b & 11001001b = 00000000b
-00000110b & 11001010b = 00000010b
-00000110b & 11001011b = 00000010b
-00000110b & 11001100b = 00000100b
-00000110b & 11001101b = 00000100b
-00000110b & 11001110b = 00000110b
-00000110b & 11001111b = 00000110b
-00000110b & 11010000b = 00000000b
-00000110b & 11010001b = 00000000b
-00000110b & 11010010b = 00000010b
-00000110b & 11010011b = 00000010b
-00000110b & 11010100b = 00000100b
-00000110b & 11010101b = 00000100b
-00000110b & 11010110b = 00000110b
-00000110b & 11010111b = 00000110b
-00000110b & 11011000b = 00000000b
-00000110b & 11011001b = 00000000b
-00000110b & 11011010b = 00000010b
-00000110b & 11011011b = 00000010b
-00000110b & 11011100b = 00000100b
-00000110b & 11011101b = 00000100b
-00000110b & 11011110b = 00000110b
-00000110b & 11011111b = 00000110b
-00000110b & 11100000b = 00000000b
-00000110b & 11100001b = 00000000b
-00000110b & 11100010b = 00000010b
-00000110b & 11100011b = 00000010b
-00000110b & 11100100b = 00000100b
-00000110b & 11100101b = 00000100b
-00000110b & 11100110b = 00000110b
-00000110b & 11100111b = 00000110b
-00000110b & 11101000b = 00000000b
-00000110b & 11101001b = 00000000b
-00000110b & 11101010b = 00000010b
-00000110b & 11101011b = 00000010b
-00000110b & 11101100b = 00000100b
-00000110b & 11101101b = 00000100b
-00000110b & 11101110b = 00000110b
-00000110b & 11101111b = 00000110b
-00000110b & 11110000b = 00000000b
-00000110b & 11110001b = 00000000b
-00000110b & 11110010b = 00000010b
-00000110b & 11110011b = 00000010b
-00000110b & 11110100b = 00000100b
-00000110b & 11110101b = 00000100b
-00000110b & 11110110b = 00000110b
-00000110b & 11110111b = 00000110b
-00000110b & 11111000b = 00000000b
-00000110b & 11111001b = 00000000b
-00000110b & 11111010b = 00000010b
-00000110b & 11111011b = 00000010b
-00000110b & 11111100b = 00000100b
-00000110b & 11111101b = 00000100b
-00000110b & 11111110b = 00000110b
-00000110b & 11111111b = 00000110b
-00000110b & 00000000b = 00000000b
-00000110b & 00000001b = 00000000b
-00000110b & 00000010b = 00000010b
-00000110b & 00000011b = 00000010b
-00000110b & 00000100b = 00000100b
-00000110b & 00000101b = 00000100b
-00000110b & 00000110b = 00000110b
-00000110b & 00000111b = 00000110b
-00000110b & 00001000b = 00000000b
-00000110b & 00001001b = 00000000b
-00000110b & 00001010b = 00000010b
-00000110b & 00001011b = 00000010b
-00000110b & 00001100b = 00000100b
-00000110b & 00001101b = 00000100b
-00000110b & 00001110b = 00000110b
-00000110b & 00001111b = 00000110b
-00000110b & 00010000b = 00000000b
-00000110b & 00010001b = 00000000b
-00000110b & 00010010b = 00000010b
-00000110b & 00010011b = 00000010b
-00000110b & 00010100b = 00000100b
-00000110b & 00010101b = 00000100b
-00000110b & 00010110b = 00000110b
-00000110b & 00010111b = 00000110b
-00000110b & 00011000b = 00000000b
-00000110b & 00011001b = 00000000b
-00000110b & 00011010b = 00000010b
-00000110b & 00011011b = 00000010b
-00000110b & 00011100b = 00000100b
-00000110b & 00011101b = 00000100b
-00000110b & 00011110b = 00000110b
-00000110b & 00011111b = 00000110b
-00000110b & 00100000b = 00000000b
-00000110b & 00100001b = 00000000b
-00000110b & 00100010b = 00000010b
-00000110b & 00100011b = 00000010b
-00000110b & 00100100b = 00000100b
-00000110b & 00100101b = 00000100b
-00000110b & 00100110b = 00000110b
-00000110b & 00100111b = 00000110b
-00000110b & 00101000b = 00000000b
-00000110b & 00101001b = 00000000b
-00000110b & 00101010b = 00000010b
-00000110b & 00101011b = 00000010b
-00000110b & 00101100b = 00000100b
-00000110b & 00101101b = 00000100b
-00000110b & 00101110b = 00000110b
-00000110b & 00101111b = 00000110b
-00000110b & 00110000b = 00000000b
-00000110b & 00110001b = 00000000b
-00000110b & 00110010b = 00000010b
-00000110b & 00110011b = 00000010b
-00000110b & 00110100b = 00000100b
-00000110b & 00110101b = 00000100b
-00000110b & 00110110b = 00000110b
-00000110b & 00110111b = 00000110b
-00000110b & 00111000b = 00000000b
-00000110b & 00111001b = 00000000b
-00000110b & 00111010b = 00000010b
-00000110b & 00111011b = 00000010b
-00000110b & 00111100b = 00000100b
-00000110b & 00111101b = 00000100b
-00000110b & 00111110b = 00000110b
-00000110b & 00111111b = 00000110b
-00000110b & 01000000b = 00000000b
-00000110b & 01000001b = 00000000b
-00000110b & 01000010b = 00000010b
-00000110b & 01000011b = 00000010b
-00000110b & 01000100b = 00000100b
-00000110b & 01000101b = 00000100b
-00000110b & 01000110b = 00000110b
-00000110b & 01000111b = 00000110b
-00000110b & 01001000b = 00000000b
-00000110b & 01001001b = 00000000b
-00000110b & 01001010b = 00000010b
-00000110b & 01001011b = 00000010b
-00000110b & 01001100b = 00000100b
-00000110b & 01001101b = 00000100b
-00000110b & 01001110b = 00000110b
-00000110b & 01001111b = 00000110b
-00000110b & 01010000b = 00000000b
-00000110b & 01010001b = 00000000b
-00000110b & 01010010b = 00000010b
-00000110b & 01010011b = 00000010b
-00000110b & 01010100b = 00000100b
-00000110b & 01010101b = 00000100b
-00000110b & 01010110b = 00000110b
-00000110b & 01010111b = 00000110b
-00000110b & 01011000b = 00000000b
-00000110b & 01011001b = 00000000b
-00000110b & 01011010b = 00000010b
-00000110b & 01011011b = 00000010b
-00000110b & 01011100b = 00000100b
-00000110b & 01011101b = 00000100b
-00000110b & 01011110b = 00000110b
-00000110b & 01011111b = 00000110b
-00000110b & 01100000b = 00000000b
-00000110b & 01100001b = 00000000b
-00000110b & 01100010b = 00000010b
-00000110b & 01100011b = 00000010b
-00000110b & 01100100b = 00000100b
-00000110b & 01100101b = 00000100b
-00000110b & 01100110b = 00000110b
-00000110b & 01100111b = 00000110b
-00000110b & 01101000b = 00000000b
-00000110b & 01101001b = 00000000b
-00000110b & 01101010b = 00000010b
-00000110b & 01101011b = 00000010b
-00000110b & 01101100b = 00000100b
-00000110b & 01101101b = 00000100b
-00000110b & 01101110b = 00000110b
-00000110b & 01101111b = 00000110b
-00000110b & 01110000b = 00000000b
-00000110b & 01110001b = 00000000b
-00000110b & 01110010b = 00000010b
-00000110b & 01110011b = 00000010b
-00000110b & 01110100b = 00000100b
-00000110b & 01110101b = 00000100b
-00000110b & 01110110b = 00000110b
-00000110b & 01110111b = 00000110b
-00000110b & 01111000b = 00000000b
-00000110b & 01111001b = 00000000b
-00000110b & 01111010b = 00000010b
-00000110b & 01111011b = 00000010b
-00000110b & 01111100b = 00000100b
-00000110b & 01111101b = 00000100b
-00000110b & 01111110b = 00000110b
-00000111b & 10000000b = 00000000b
-00000111b & 10000001b = 00000001b
-00000111b & 10000010b = 00000010b
-00000111b & 10000011b = 00000011b
-00000111b & 10000100b = 00000100b
-00000111b & 10000101b = 00000101b
-00000111b & 10000110b = 00000110b
-00000111b & 10000111b = 00000111b
-00000111b & 10001000b = 00000000b
-00000111b & 10001001b = 00000001b
-00000111b & 10001010b = 00000010b
-00000111b & 10001011b = 00000011b
-00000111b & 10001100b = 00000100b
-00000111b & 10001101b = 00000101b
-00000111b & 10001110b = 00000110b
-00000111b & 10001111b = 00000111b
-00000111b & 10010000b = 00000000b
-00000111b & 10010001b = 00000001b
-00000111b & 10010010b = 00000010b
-00000111b & 10010011b = 00000011b
-00000111b & 10010100b = 00000100b
-00000111b & 10010101b = 00000101b
-00000111b & 10010110b = 00000110b
-00000111b & 10010111b = 00000111b
-00000111b & 10011000b = 00000000b
-00000111b & 10011001b = 00000001b
-00000111b & 10011010b = 00000010b
-00000111b & 10011011b = 00000011b
-00000111b & 10011100b = 00000100b
-00000111b & 10011101b = 00000101b
-00000111b & 10011110b = 00000110b
-00000111b & 10011111b = 00000111b
-00000111b & 10100000b = 00000000b
-00000111b & 10100001b = 00000001b
-00000111b & 10100010b = 00000010b
-00000111b & 10100011b = 00000011b
-00000111b & 10100100b = 00000100b
-00000111b & 10100101b = 00000101b
-00000111b & 10100110b = 00000110b
-00000111b & 10100111b = 00000111b
-00000111b & 10101000b = 00000000b
-00000111b & 10101001b = 00000001b
-00000111b & 10101010b = 00000010b
-00000111b & 10101011b = 00000011b
-00000111b & 10101100b = 00000100b
-00000111b & 10101101b = 00000101b
-00000111b & 10101110b = 00000110b
-00000111b & 10101111b = 00000111b
-00000111b & 10110000b = 00000000b
-00000111b & 10110001b = 00000001b
-00000111b & 10110010b = 00000010b
-00000111b & 10110011b = 00000011b
-00000111b & 10110100b = 00000100b
-00000111b & 10110101b = 00000101b
-00000111b & 10110110b = 00000110b
-00000111b & 10110111b = 00000111b
-00000111b & 10111000b = 00000000b
-00000111b & 10111001b = 00000001b
-00000111b & 10111010b = 00000010b
-00000111b & 10111011b = 00000011b
-00000111b & 10111100b = 00000100b
-00000111b & 10111101b = 00000101b
-00000111b & 10111110b = 00000110b
-00000111b & 10111111b = 00000111b
-00000111b & 11000000b = 00000000b
-00000111b & 11000001b = 00000001b
-00000111b & 11000010b = 00000010b
-00000111b & 11000011b = 00000011b
-00000111b & 11000100b = 00000100b
-00000111b & 11000101b = 00000101b
-00000111b & 11000110b = 00000110b
-00000111b & 11000111b = 00000111b
-00000111b & 11001000b = 00000000b
-00000111b & 11001001b = 00000001b
-00000111b & 11001010b = 00000010b
-00000111b & 11001011b = 00000011b
-00000111b & 11001100b = 00000100b
-00000111b & 11001101b = 00000101b
-00000111b & 11001110b = 00000110b
-00000111b & 11001111b = 00000111b
-00000111b & 11010000b = 00000000b
-00000111b & 11010001b = 00000001b
-00000111b & 11010010b = 00000010b
-00000111b & 11010011b = 00000011b
-00000111b & 11010100b = 00000100b
-00000111b & 11010101b = 00000101b
-00000111b & 11010110b = 00000110b
-00000111b & 11010111b = 00000111b
-00000111b & 11011000b = 00000000b
-00000111b & 11011001b = 00000001b
-00000111b & 11011010b = 00000010b
-00000111b & 11011011b = 00000011b
-00000111b & 11011100b = 00000100b
-00000111b & 11011101b = 00000101b
-00000111b & 11011110b = 00000110b
-00000111b & 11011111b = 00000111b
-00000111b & 11100000b = 00000000b
-00000111b & 11100001b = 00000001b
-00000111b & 11100010b = 00000010b
-00000111b & 11100011b = 00000011b
-00000111b & 11100100b = 00000100b
-00000111b & 11100101b = 00000101b
-00000111b & 11100110b = 00000110b
-00000111b & 11100111b = 00000111b
-00000111b & 11101000b = 00000000b
-00000111b & 11101001b = 00000001b
-00000111b & 11101010b = 00000010b
-00000111b & 11101011b = 00000011b
-00000111b & 11101100b = 00000100b
-00000111b & 11101101b = 00000101b
-00000111b & 11101110b = 00000110b
-00000111b & 11101111b = 00000111b
-00000111b & 11110000b = 00000000b
-00000111b & 11110001b = 00000001b
-00000111b & 11110010b = 00000010b
-00000111b & 11110011b = 00000011b
-00000111b & 11110100b = 00000100b
-00000111b & 11110101b = 00000101b
-00000111b & 11110110b = 00000110b
-00000111b & 11110111b = 00000111b
-00000111b & 11111000b = 00000000b
-00000111b & 11111001b = 00000001b
-00000111b & 11111010b = 00000010b
-00000111b & 11111011b = 00000011b
-00000111b & 11111100b = 00000100b
-00000111b & 11111101b = 00000101b
-00000111b & 11111110b = 00000110b
-00000111b & 11111111b = 00000111b
-00000111b & 00000000b = 00000000b
-00000111b & 00000001b = 00000001b
-00000111b & 00000010b = 00000010b
-00000111b & 00000011b = 00000011b
-00000111b & 00000100b = 00000100b
-00000111b & 00000101b = 00000101b
-00000111b & 00000110b = 00000110b
-00000111b & 00000111b = 00000111b
-00000111b & 00001000b = 00000000b
-00000111b & 00001001b = 00000001b
-00000111b & 00001010b = 00000010b
-00000111b & 00001011b = 00000011b
-00000111b & 00001100b = 00000100b
-00000111b & 00001101b = 00000101b
-00000111b & 00001110b = 00000110b
-00000111b & 00001111b = 00000111b
-00000111b & 00010000b = 00000000b
-00000111b & 00010001b = 00000001b
-00000111b & 00010010b = 00000010b
-00000111b & 00010011b = 00000011b
-00000111b & 00010100b = 00000100b
-00000111b & 00010101b = 00000101b
-00000111b & 00010110b = 00000110b
-00000111b & 00010111b = 00000111b
-00000111b & 00011000b = 00000000b
-00000111b & 00011001b = 00000001b
-00000111b & 00011010b = 00000010b
-00000111b & 00011011b = 00000011b
-00000111b & 00011100b = 00000100b
-00000111b & 00011101b = 00000101b
-00000111b & 00011110b = 00000110b
-00000111b & 00011111b = 00000111b
-00000111b & 00100000b = 00000000b
-00000111b & 00100001b = 00000001b
-00000111b & 00100010b = 00000010b
-00000111b & 00100011b = 00000011b
-00000111b & 00100100b = 00000100b
-00000111b & 00100101b = 00000101b
-00000111b & 00100110b = 00000110b
-00000111b & 00100111b = 00000111b
-00000111b & 00101000b = 00000000b
-00000111b & 00101001b = 00000001b
-00000111b & 00101010b = 00000010b
-00000111b & 00101011b = 00000011b
-00000111b & 00101100b = 00000100b
-00000111b & 00101101b = 00000101b
-00000111b & 00101110b = 00000110b
-00000111b & 00101111b = 00000111b
-00000111b & 00110000b = 00000000b
-00000111b & 00110001b = 00000001b
-00000111b & 00110010b = 00000010b
-00000111b & 00110011b = 00000011b
-00000111b & 00110100b = 00000100b
-00000111b & 00110101b = 00000101b
-00000111b & 00110110b = 00000110b
-00000111b & 00110111b = 00000111b
-00000111b & 00111000b = 00000000b
-00000111b & 00111001b = 00000001b
-00000111b & 00111010b = 00000010b
-00000111b & 00111011b = 00000011b
-00000111b & 00111100b = 00000100b
-00000111b & 00111101b = 00000101b
-00000111b & 00111110b = 00000110b
-00000111b & 00111111b = 00000111b
-00000111b & 01000000b = 00000000b
-00000111b & 01000001b = 00000001b
-00000111b & 01000010b = 00000010b
-00000111b & 01000011b = 00000011b
-00000111b & 01000100b = 00000100b
-00000111b & 01000101b = 00000101b
-00000111b & 01000110b = 00000110b
-00000111b & 01000111b = 00000111b
-00000111b & 01001000b = 00000000b
-00000111b & 01001001b = 00000001b
-00000111b & 01001010b = 00000010b
-00000111b & 01001011b = 00000011b
-00000111b & 01001100b = 00000100b
-00000111b & 01001101b = 00000101b
-00000111b & 01001110b = 00000110b
-00000111b & 01001111b = 00000111b
-00000111b & 01010000b = 00000000b
-00000111b & 01010001b = 00000001b
-00000111b & 01010010b = 00000010b
-00000111b & 01010011b = 00000011b
-00000111b & 01010100b = 00000100b
-00000111b & 01010101b = 00000101b
-00000111b & 01010110b = 00000110b
-00000111b & 01010111b = 00000111b
-00000111b & 01011000b = 00000000b
-00000111b & 01011001b = 00000001b
-00000111b & 01011010b = 00000010b
-00000111b & 01011011b = 00000011b
-00000111b & 01011100b = 00000100b
-00000111b & 01011101b = 00000101b
-00000111b & 01011110b = 00000110b
-00000111b & 01011111b = 00000111b
-00000111b & 01100000b = 00000000b
-00000111b & 01100001b = 00000001b
-00000111b & 01100010b = 00000010b
-00000111b & 01100011b = 00000011b
-00000111b & 01100100b = 00000100b
-00000111b & 01100101b = 00000101b
-00000111b & 01100110b = 00000110b
-00000111b & 01100111b = 00000111b
-00000111b & 01101000b = 00000000b
-00000111b & 01101001b = 00000001b
-00000111b & 01101010b = 00000010b
-00000111b & 01101011b = 00000011b
-00000111b & 01101100b = 00000100b
-00000111b & 01101101b = 00000101b
-00000111b & 01101110b = 00000110b
-00000111b & 01101111b = 00000111b
-00000111b & 01110000b = 00000000b
-00000111b & 01110001b = 00000001b
-00000111b & 01110010b = 00000010b
-00000111b & 01110011b = 00000011b
-00000111b & 01110100b = 00000100b
-00000111b & 01110101b = 00000101b
-00000111b & 01110110b = 00000110b
-00000111b & 01110111b = 00000111b
-00000111b & 01111000b = 00000000b
-00000111b & 01111001b = 00000001b
-00000111b & 01111010b = 00000010b
-00000111b & 01111011b = 00000011b
-00000111b & 01111100b = 00000100b
-00000111b & 01111101b = 00000101b
-00000111b & 01111110b = 00000110b
-00001000b & 10000000b = 00000000b
-00001000b & 10000001b = 00000000b
-00001000b & 10000010b = 00000000b
-00001000b & 10000011b = 00000000b
-00001000b & 10000100b = 00000000b
-00001000b & 10000101b = 00000000b
-00001000b & 10000110b = 00000000b
-00001000b & 10000111b = 00000000b
-00001000b & 10001000b = 00001000b
-00001000b & 10001001b = 00001000b
-00001000b & 10001010b = 00001000b
-00001000b & 10001011b = 00001000b
-00001000b & 10001100b = 00001000b
-00001000b & 10001101b = 00001000b
-00001000b & 10001110b = 00001000b
-00001000b & 10001111b = 00001000b
-00001000b & 10010000b = 00000000b
-00001000b & 10010001b = 00000000b
-00001000b & 10010010b = 00000000b
-00001000b & 10010011b = 00000000b
-00001000b & 10010100b = 00000000b
-00001000b & 10010101b = 00000000b
-00001000b & 10010110b = 00000000b
-00001000b & 10010111b = 00000000b
-00001000b & 10011000b = 00001000b
-00001000b & 10011001b = 00001000b
-00001000b & 10011010b = 00001000b
-00001000b & 10011011b = 00001000b
-00001000b & 10011100b = 00001000b
-00001000b & 10011101b = 00001000b
-00001000b & 10011110b = 00001000b
-00001000b & 10011111b = 00001000b
-00001000b & 10100000b = 00000000b
-00001000b & 10100001b = 00000000b
-00001000b & 10100010b = 00000000b
-00001000b & 10100011b = 00000000b
-00001000b & 10100100b = 00000000b
-00001000b & 10100101b = 00000000b
-00001000b & 10100110b = 00000000b
-00001000b & 10100111b = 00000000b
-00001000b & 10101000b = 00001000b
-00001000b & 10101001b = 00001000b
-00001000b & 10101010b = 00001000b
-00001000b & 10101011b = 00001000b
-00001000b & 10101100b = 00001000b
-00001000b & 10101101b = 00001000b
-00001000b & 10101110b = 00001000b
-00001000b & 10101111b = 00001000b
-00001000b & 10110000b = 00000000b
-00001000b & 10110001b = 00000000b
-00001000b & 10110010b = 00000000b
-00001000b & 10110011b = 00000000b
-00001000b & 10110100b = 00000000b
-00001000b & 10110101b = 00000000b
-00001000b & 10110110b = 00000000b
-00001000b & 10110111b = 00000000b
-00001000b & 10111000b = 00001000b
-00001000b & 10111001b = 00001000b
-00001000b & 10111010b = 00001000b
-00001000b & 10111011b = 00001000b
-00001000b & 10111100b = 00001000b
-00001000b & 10111101b = 00001000b
-00001000b & 10111110b = 00001000b
-00001000b & 10111111b = 00001000b
-00001000b & 11000000b = 00000000b
-00001000b & 11000001b = 00000000b
-00001000b & 11000010b = 00000000b
-00001000b & 11000011b = 00000000b
-00001000b & 11000100b = 00000000b
-00001000b & 11000101b = 00000000b
-00001000b & 11000110b = 00000000b
-00001000b & 11000111b = 00000000b
-00001000b & 11001000b = 00001000b
-00001000b & 11001001b = 00001000b
-00001000b & 11001010b = 00001000b
-00001000b & 11001011b = 00001000b
-00001000b & 11001100b = 00001000b
-00001000b & 11001101b = 00001000b
-00001000b & 11001110b = 00001000b
-00001000b & 11001111b = 00001000b
-00001000b & 11010000b = 00000000b
-00001000b & 11010001b = 00000000b
-00001000b & 11010010b = 00000000b
-00001000b & 11010011b = 00000000b
-00001000b & 11010100b = 00000000b
-00001000b & 11010101b = 00000000b
-00001000b & 11010110b = 00000000b
-00001000b & 11010111b = 00000000b
-00001000b & 11011000b = 00001000b
-00001000b & 11011001b = 00001000b
-00001000b & 11011010b = 00001000b
-00001000b & 11011011b = 00001000b
-00001000b & 11011100b = 00001000b
-00001000b & 11011101b = 00001000b
-00001000b & 11011110b = 00001000b
-00001000b & 11011111b = 00001000b
-00001000b & 11100000b = 00000000b
-00001000b & 11100001b = 00000000b
-00001000b & 11100010b = 00000000b
-00001000b & 11100011b = 00000000b
-00001000b & 11100100b = 00000000b
-00001000b & 11100101b = 00000000b
-00001000b & 11100110b = 00000000b
-00001000b & 11100111b = 00000000b
-00001000b & 11101000b = 00001000b
-00001000b & 11101001b = 00001000b
-00001000b & 11101010b = 00001000b
-00001000b & 11101011b = 00001000b
-00001000b & 11101100b = 00001000b
-00001000b & 11101101b = 00001000b
-00001000b & 11101110b = 00001000b
-00001000b & 11101111b = 00001000b
-00001000b & 11110000b = 00000000b
-00001000b & 11110001b = 00000000b
-00001000b & 11110010b = 00000000b
-00001000b & 11110011b = 00000000b
-00001000b & 11110100b = 00000000b
-00001000b & 11110101b = 00000000b
-00001000b & 11110110b = 00000000b
-00001000b & 11110111b = 00000000b
-00001000b & 11111000b = 00001000b
-00001000b & 11111001b = 00001000b
-00001000b & 11111010b = 00001000b
-00001000b & 11111011b = 00001000b
-00001000b & 11111100b = 00001000b
-00001000b & 11111101b = 00001000b
-00001000b & 11111110b = 00001000b
-00001000b & 11111111b = 00001000b
-00001000b & 00000000b = 00000000b
-00001000b & 00000001b = 00000000b
-00001000b & 00000010b = 00000000b
-00001000b & 00000011b = 00000000b
-00001000b & 00000100b = 00000000b
-00001000b & 00000101b = 00000000b
-00001000b & 00000110b = 00000000b
-00001000b & 00000111b = 00000000b
-00001000b & 00001000b = 00001000b
-00001000b & 00001001b = 00001000b
-00001000b & 00001010b = 00001000b
-00001000b & 00001011b = 00001000b
-00001000b & 00001100b = 00001000b
-00001000b & 00001101b = 00001000b
-00001000b & 00001110b = 00001000b
-00001000b & 00001111b = 00001000b
-00001000b & 00010000b = 00000000b
-00001000b & 00010001b = 00000000b
-00001000b & 00010010b = 00000000b
-00001000b & 00010011b = 00000000b
-00001000b & 00010100b = 00000000b
-00001000b & 00010101b = 00000000b
-00001000b & 00010110b = 00000000b
-00001000b & 00010111b = 00000000b
-00001000b & 00011000b = 00001000b
-00001000b & 00011001b = 00001000b
-00001000b & 00011010b = 00001000b
-00001000b & 00011011b = 00001000b
-00001000b & 00011100b = 00001000b
-00001000b & 00011101b = 00001000b
-00001000b & 00011110b = 00001000b
-00001000b & 00011111b = 00001000b
-00001000b & 00100000b = 00000000b
-00001000b & 00100001b = 00000000b
-00001000b & 00100010b = 00000000b
-00001000b & 00100011b = 00000000b
-00001000b & 00100100b = 00000000b
-00001000b & 00100101b = 00000000b
-00001000b & 00100110b = 00000000b
-00001000b & 00100111b = 00000000b
-00001000b & 00101000b = 00001000b
-00001000b & 00101001b = 00001000b
-00001000b & 00101010b = 00001000b
-00001000b & 00101011b = 00001000b
-00001000b & 00101100b = 00001000b
-00001000b & 00101101b = 00001000b
-00001000b & 00101110b = 00001000b
-00001000b & 00101111b = 00001000b
-00001000b & 00110000b = 00000000b
-00001000b & 00110001b = 00000000b
-00001000b & 00110010b = 00000000b
-00001000b & 00110011b = 00000000b
-00001000b & 00110100b = 00000000b
-00001000b & 00110101b = 00000000b
-00001000b & 00110110b = 00000000b
-00001000b & 00110111b = 00000000b
-00001000b & 00111000b = 00001000b
-00001000b & 00111001b = 00001000b
-00001000b & 00111010b = 00001000b
-00001000b & 00111011b = 00001000b
-00001000b & 00111100b = 00001000b
-00001000b & 00111101b = 00001000b
-00001000b & 00111110b = 00001000b
-00001000b & 00111111b = 00001000b
-00001000b & 01000000b = 00000000b
-00001000b & 01000001b = 00000000b
-00001000b & 01000010b = 00000000b
-00001000b & 01000011b = 00000000b
-00001000b & 01000100b = 00000000b
-00001000b & 01000101b = 00000000b
-00001000b & 01000110b = 00000000b
-00001000b & 01000111b = 00000000b
-00001000b & 01001000b = 00001000b
-00001000b & 01001001b = 00001000b
-00001000b & 01001010b = 00001000b
-00001000b & 01001011b = 00001000b
-00001000b & 01001100b = 00001000b
-00001000b & 01001101b = 00001000b
-00001000b & 01001110b = 00001000b
-00001000b & 01001111b = 00001000b
-00001000b & 01010000b = 00000000b
-00001000b & 01010001b = 00000000b
-00001000b & 01010010b = 00000000b
-00001000b & 01010011b = 00000000b
-00001000b & 01010100b = 00000000b
-00001000b & 01010101b = 00000000b
-00001000b & 01010110b = 00000000b
-00001000b & 01010111b = 00000000b
-00001000b & 01011000b = 00001000b
-00001000b & 01011001b = 00001000b
-00001000b & 01011010b = 00001000b
-00001000b & 01011011b = 00001000b
-00001000b & 01011100b = 00001000b
-00001000b & 01011101b = 00001000b
-00001000b & 01011110b = 00001000b
-00001000b & 01011111b = 00001000b
-00001000b & 01100000b = 00000000b
-00001000b & 01100001b = 00000000b
-00001000b & 01100010b = 00000000b
-00001000b & 01100011b = 00000000b
-00001000b & 01100100b = 00000000b
-00001000b & 01100101b = 00000000b
-00001000b & 01100110b = 00000000b
-00001000b & 01100111b = 00000000b
-00001000b & 01101000b = 00001000b
-00001000b & 01101001b = 00001000b
-00001000b & 01101010b = 00001000b
-00001000b & 01101011b = 00001000b
-00001000b & 01101100b = 00001000b
-00001000b & 01101101b = 00001000b
-00001000b & 01101110b = 00001000b
-00001000b & 01101111b = 00001000b
-00001000b & 01110000b = 00000000b
-00001000b & 01110001b = 00000000b
-00001000b & 01110010b = 00000000b
-00001000b & 01110011b = 00000000b
-00001000b & 01110100b = 00000000b
-00001000b & 01110101b = 00000000b
-00001000b & 01110110b = 00000000b
-00001000b & 01110111b = 00000000b
-00001000b & 01111000b = 00001000b
-00001000b & 01111001b = 00001000b
-00001000b & 01111010b = 00001000b
-00001000b & 01111011b = 00001000b
-00001000b & 01111100b = 00001000b
-00001000b & 01111101b = 00001000b
-00001000b & 01111110b = 00001000b
-00001001b & 10000000b = 00000000b
-00001001b & 10000001b = 00000001b
-00001001b & 10000010b = 00000000b
-00001001b & 10000011b = 00000001b
-00001001b & 10000100b = 00000000b
-00001001b & 10000101b = 00000001b
-00001001b & 10000110b = 00000000b
-00001001b & 10000111b = 00000001b
-00001001b & 10001000b = 00001000b
-00001001b & 10001001b = 00001001b
-00001001b & 10001010b = 00001000b
-00001001b & 10001011b = 00001001b
-00001001b & 10001100b = 00001000b
-00001001b & 10001101b = 00001001b
-00001001b & 10001110b = 00001000b
-00001001b & 10001111b = 00001001b
-00001001b & 10010000b = 00000000b
-00001001b & 10010001b = 00000001b
-00001001b & 10010010b = 00000000b
-00001001b & 10010011b = 00000001b
-00001001b & 10010100b = 00000000b
-00001001b & 10010101b = 00000001b
-00001001b & 10010110b = 00000000b
-00001001b & 10010111b = 00000001b
-00001001b & 10011000b = 00001000b
-00001001b & 10011001b = 00001001b
-00001001b & 10011010b = 00001000b
-00001001b & 10011011b = 00001001b
-00001001b & 10011100b = 00001000b
-00001001b & 10011101b = 00001001b
-00001001b & 10011110b = 00001000b
-00001001b & 10011111b = 00001001b
-00001001b & 10100000b = 00000000b
-00001001b & 10100001b = 00000001b
-00001001b & 10100010b = 00000000b
-00001001b & 10100011b = 00000001b
-00001001b & 10100100b = 00000000b
-00001001b & 10100101b = 00000001b
-00001001b & 10100110b = 00000000b
-00001001b & 10100111b = 00000001b
-00001001b & 10101000b = 00001000b
-00001001b & 10101001b = 00001001b
-00001001b & 10101010b = 00001000b
-00001001b & 10101011b = 00001001b
-00001001b & 10101100b = 00001000b
-00001001b & 10101101b = 00001001b
-00001001b & 10101110b = 00001000b
-00001001b & 10101111b = 00001001b
-00001001b & 10110000b = 00000000b
-00001001b & 10110001b = 00000001b
-00001001b & 10110010b = 00000000b
-00001001b & 10110011b = 00000001b
-00001001b & 10110100b = 00000000b
-00001001b & 10110101b = 00000001b
-00001001b & 10110110b = 00000000b
-00001001b & 10110111b = 00000001b
-00001001b & 10111000b = 00001000b
-00001001b & 10111001b = 00001001b
-00001001b & 10111010b = 00001000b
-00001001b & 10111011b = 00001001b
-00001001b & 10111100b = 00001000b
-00001001b & 10111101b = 00001001b
-00001001b & 10111110b = 00001000b
-00001001b & 10111111b = 00001001b
-00001001b & 11000000b = 00000000b
-00001001b & 11000001b = 00000001b
-00001001b & 11000010b = 00000000b
-00001001b & 11000011b = 00000001b
-00001001b & 11000100b = 00000000b
-00001001b & 11000101b = 00000001b
-00001001b & 11000110b = 00000000b
-00001001b & 11000111b = 00000001b
-00001001b & 11001000b = 00001000b
-00001001b & 11001001b = 00001001b
-00001001b & 11001010b = 00001000b
-00001001b & 11001011b = 00001001b
-00001001b & 11001100b = 00001000b
-00001001b & 11001101b = 00001001b
-00001001b & 11001110b = 00001000b
-00001001b & 11001111b = 00001001b
-00001001b & 11010000b = 00000000b
-00001001b & 11010001b = 00000001b
-00001001b & 11010010b = 00000000b
-00001001b & 11010011b = 00000001b
-00001001b & 11010100b = 00000000b
-00001001b & 11010101b = 00000001b
-00001001b & 11010110b = 00000000b
-00001001b & 11010111b = 00000001b
-00001001b & 11011000b = 00001000b
-00001001b & 11011001b = 00001001b
-00001001b & 11011010b = 00001000b
-00001001b & 11011011b = 00001001b
-00001001b & 11011100b = 00001000b
-00001001b & 11011101b = 00001001b
-00001001b & 11011110b = 00001000b
-00001001b & 11011111b = 00001001b
-00001001b & 11100000b = 00000000b
-00001001b & 11100001b = 00000001b
-00001001b & 11100010b = 00000000b
-00001001b & 11100011b = 00000001b
-00001001b & 11100100b = 00000000b
-00001001b & 11100101b = 00000001b
-00001001b & 11100110b = 00000000b
-00001001b & 11100111b = 00000001b
-00001001b & 11101000b = 00001000b
-00001001b & 11101001b = 00001001b
-00001001b & 11101010b = 00001000b
-00001001b & 11101011b = 00001001b
-00001001b & 11101100b = 00001000b
-00001001b & 11101101b = 00001001b
-00001001b & 11101110b = 00001000b
-00001001b & 11101111b = 00001001b
-00001001b & 11110000b = 00000000b
-00001001b & 11110001b = 00000001b
-00001001b & 11110010b = 00000000b
-00001001b & 11110011b = 00000001b
-00001001b & 11110100b = 00000000b
-00001001b & 11110101b = 00000001b
-00001001b & 11110110b = 00000000b
-00001001b & 11110111b = 00000001b
-00001001b & 11111000b = 00001000b
-00001001b & 11111001b = 00001001b
-00001001b & 11111010b = 00001000b
-00001001b & 11111011b = 00001001b
-00001001b & 11111100b = 00001000b
-00001001b & 11111101b = 00001001b
-00001001b & 11111110b = 00001000b
-00001001b & 11111111b = 00001001b
-00001001b & 00000000b = 00000000b
-00001001b & 00000001b = 00000001b
-00001001b & 00000010b = 00000000b
-00001001b & 00000011b = 00000001b
-00001001b & 00000100b = 00000000b
-00001001b & 00000101b = 00000001b
-00001001b & 00000110b = 00000000b
-00001001b & 00000111b = 00000001b
-00001001b & 00001000b = 00001000b
-00001001b & 00001001b = 00001001b
-00001001b & 00001010b = 00001000b
-00001001b & 00001011b = 00001001b
-00001001b & 00001100b = 00001000b
-00001001b & 00001101b = 00001001b
-00001001b & 00001110b = 00001000b
-00001001b & 00001111b = 00001001b
-00001001b & 00010000b = 00000000b
-00001001b & 00010001b = 00000001b
-00001001b & 00010010b = 00000000b
-00001001b & 00010011b = 00000001b
-00001001b & 00010100b = 00000000b
-00001001b & 00010101b = 00000001b
-00001001b & 00010110b = 00000000b
-00001001b & 00010111b = 00000001b
-00001001b & 00011000b = 00001000b
-00001001b & 00011001b = 00001001b
-00001001b & 00011010b = 00001000b
-00001001b & 00011011b = 00001001b
-00001001b & 00011100b = 00001000b
-00001001b & 00011101b = 00001001b
-00001001b & 00011110b = 00001000b
-00001001b & 00011111b = 00001001b
-00001001b & 00100000b = 00000000b
-00001001b & 00100001b = 00000001b
-00001001b & 00100010b = 00000000b
-00001001b & 00100011b = 00000001b
-00001001b & 00100100b = 00000000b
-00001001b & 00100101b = 00000001b
-00001001b & 00100110b = 00000000b
-00001001b & 00100111b = 00000001b
-00001001b & 00101000b = 00001000b
-00001001b & 00101001b = 00001001b
-00001001b & 00101010b = 00001000b
-00001001b & 00101011b = 00001001b
-00001001b & 00101100b = 00001000b
-00001001b & 00101101b = 00001001b
-00001001b & 00101110b = 00001000b
-00001001b & 00101111b = 00001001b
-00001001b & 00110000b = 00000000b
-00001001b & 00110001b = 00000001b
-00001001b & 00110010b = 00000000b
-00001001b & 00110011b = 00000001b
-00001001b & 00110100b = 00000000b
-00001001b & 00110101b = 00000001b
-00001001b & 00110110b = 00000000b
-00001001b & 00110111b = 00000001b
-00001001b & 00111000b = 00001000b
-00001001b & 00111001b = 00001001b
-00001001b & 00111010b = 00001000b
-00001001b & 00111011b = 00001001b
-00001001b & 00111100b = 00001000b
-00001001b & 00111101b = 00001001b
-00001001b & 00111110b = 00001000b
-00001001b & 00111111b = 00001001b
-00001001b & 01000000b = 00000000b
-00001001b & 01000001b = 00000001b
-00001001b & 01000010b = 00000000b
-00001001b & 01000011b = 00000001b
-00001001b & 01000100b = 00000000b
-00001001b & 01000101b = 00000001b
-00001001b & 01000110b = 00000000b
-00001001b & 01000111b = 00000001b
-00001001b & 01001000b = 00001000b
-00001001b & 01001001b = 00001001b
-00001001b & 01001010b = 00001000b
-00001001b & 01001011b = 00001001b
-00001001b & 01001100b = 00001000b
-00001001b & 01001101b = 00001001b
-00001001b & 01001110b = 00001000b
-00001001b & 01001111b = 00001001b
-00001001b & 01010000b = 00000000b
-00001001b & 01010001b = 00000001b
-00001001b & 01010010b = 00000000b
-00001001b & 01010011b = 00000001b
-00001001b & 01010100b = 00000000b
-00001001b & 01010101b = 00000001b
-00001001b & 01010110b = 00000000b
-00001001b & 01010111b = 00000001b
-00001001b & 01011000b = 00001000b
-00001001b & 01011001b = 00001001b
-00001001b & 01011010b = 00001000b
-00001001b & 01011011b = 00001001b
-00001001b & 01011100b = 00001000b
-00001001b & 01011101b = 00001001b
-00001001b & 01011110b = 00001000b
-00001001b & 01011111b = 00001001b
-00001001b & 01100000b = 00000000b
-00001001b & 01100001b = 00000001b
-00001001b & 01100010b = 00000000b
-00001001b & 01100011b = 00000001b
-00001001b & 01100100b = 00000000b
-00001001b & 01100101b = 00000001b
-00001001b & 01100110b = 00000000b
-00001001b & 01100111b = 00000001b
-00001001b & 01101000b = 00001000b
-00001001b & 01101001b = 00001001b
-00001001b & 01101010b = 00001000b
-00001001b & 01101011b = 00001001b
-00001001b & 01101100b = 00001000b
-00001001b & 01101101b = 00001001b
-00001001b & 01101110b = 00001000b
-00001001b & 01101111b = 00001001b
-00001001b & 01110000b = 00000000b
-00001001b & 01110001b = 00000001b
-00001001b & 01110010b = 00000000b
-00001001b & 01110011b = 00000001b
-00001001b & 01110100b = 00000000b
-00001001b & 01110101b = 00000001b
-00001001b & 01110110b = 00000000b
-00001001b & 01110111b = 00000001b
-00001001b & 01111000b = 00001000b
-00001001b & 01111001b = 00001001b
-00001001b & 01111010b = 00001000b
-00001001b & 01111011b = 00001001b
-00001001b & 01111100b = 00001000b
-00001001b & 01111101b = 00001001b
-00001001b & 01111110b = 00001000b
-00001010b & 10000000b = 00000000b
-00001010b & 10000001b = 00000000b
-00001010b & 10000010b = 00000010b
-00001010b & 10000011b = 00000010b
-00001010b & 10000100b = 00000000b
-00001010b & 10000101b = 00000000b
-00001010b & 10000110b = 00000010b
-00001010b & 10000111b = 00000010b
-00001010b & 10001000b = 00001000b
-00001010b & 10001001b = 00001000b
-00001010b & 10001010b = 00001010b
-00001010b & 10001011b = 00001010b
-00001010b & 10001100b = 00001000b
-00001010b & 10001101b = 00001000b
-00001010b & 10001110b = 00001010b
-00001010b & 10001111b = 00001010b
-00001010b & 10010000b = 00000000b
-00001010b & 10010001b = 00000000b
-00001010b & 10010010b = 00000010b
-00001010b & 10010011b = 00000010b
-00001010b & 10010100b = 00000000b
-00001010b & 10010101b = 00000000b
-00001010b & 10010110b = 00000010b
-00001010b & 10010111b = 00000010b
-00001010b & 10011000b = 00001000b
-00001010b & 10011001b = 00001000b
-00001010b & 10011010b = 00001010b
-00001010b & 10011011b = 00001010b
-00001010b & 10011100b = 00001000b
-00001010b & 10011101b = 00001000b
-00001010b & 10011110b = 00001010b
-00001010b & 10011111b = 00001010b
-00001010b & 10100000b = 00000000b
-00001010b & 10100001b = 00000000b
-00001010b & 10100010b = 00000010b
-00001010b & 10100011b = 00000010b
-00001010b & 10100100b = 00000000b
-00001010b & 10100101b = 00000000b
-00001010b & 10100110b = 00000010b
-00001010b & 10100111b = 00000010b
-00001010b & 10101000b = 00001000b
-00001010b & 10101001b = 00001000b
-00001010b & 10101010b = 00001010b
-00001010b & 10101011b = 00001010b
-00001010b & 10101100b = 00001000b
-00001010b & 10101101b = 00001000b
-00001010b & 10101110b = 00001010b
-00001010b & 10101111b = 00001010b
-00001010b & 10110000b = 00000000b
-00001010b & 10110001b = 00000000b
-00001010b & 10110010b = 00000010b
-00001010b & 10110011b = 00000010b
-00001010b & 10110100b = 00000000b
-00001010b & 10110101b = 00000000b
-00001010b & 10110110b = 00000010b
-00001010b & 10110111b = 00000010b
-00001010b & 10111000b = 00001000b
-00001010b & 10111001b = 00001000b
-00001010b & 10111010b = 00001010b
-00001010b & 10111011b = 00001010b
-00001010b & 10111100b = 00001000b
-00001010b & 10111101b = 00001000b
-00001010b & 10111110b = 00001010b
-00001010b & 10111111b = 00001010b
-00001010b & 11000000b = 00000000b
-00001010b & 11000001b = 00000000b
-00001010b & 11000010b = 00000010b
-00001010b & 11000011b = 00000010b
-00001010b & 11000100b = 00000000b
-00001010b & 11000101b = 00000000b
-00001010b & 11000110b = 00000010b
-00001010b & 11000111b = 00000010b
-00001010b & 11001000b = 00001000b
-00001010b & 11001001b = 00001000b
-00001010b & 11001010b = 00001010b
-00001010b & 11001011b = 00001010b
-00001010b & 11001100b = 00001000b
-00001010b & 11001101b = 00001000b
-00001010b & 11001110b = 00001010b
-00001010b & 11001111b = 00001010b
-00001010b & 11010000b = 00000000b
-00001010b & 11010001b = 00000000b
-00001010b & 11010010b = 00000010b
-00001010b & 11010011b = 00000010b
-00001010b & 11010100b = 00000000b
-00001010b & 11010101b = 00000000b
-00001010b & 11010110b = 00000010b
-00001010b & 11010111b = 00000010b
-00001010b & 11011000b = 00001000b
-00001010b & 11011001b = 00001000b
-00001010b & 11011010b = 00001010b
-00001010b & 11011011b = 00001010b
-00001010b & 11011100b = 00001000b
-00001010b & 11011101b = 00001000b
-00001010b & 11011110b = 00001010b
-00001010b & 11011111b = 00001010b
-00001010b & 11100000b = 00000000b
-00001010b & 11100001b = 00000000b
-00001010b & 11100010b = 00000010b
-00001010b & 11100011b = 00000010b
-00001010b & 11100100b = 00000000b
-00001010b & 11100101b = 00000000b
-00001010b & 11100110b = 00000010b
-00001010b & 11100111b = 00000010b
-00001010b & 11101000b = 00001000b
-00001010b & 11101001b = 00001000b
-00001010b & 11101010b = 00001010b
-00001010b & 11101011b = 00001010b
-00001010b & 11101100b = 00001000b
-00001010b & 11101101b = 00001000b
-00001010b & 11101110b = 00001010b
-00001010b & 11101111b = 00001010b
-00001010b & 11110000b = 00000000b
-00001010b & 11110001b = 00000000b
-00001010b & 11110010b = 00000010b
-00001010b & 11110011b = 00000010b
-00001010b & 11110100b = 00000000b
-00001010b & 11110101b = 00000000b
-00001010b & 11110110b = 00000010b
-00001010b & 11110111b = 00000010b
-00001010b & 11111000b = 00001000b
-00001010b & 11111001b = 00001000b
-00001010b & 11111010b = 00001010b
-00001010b & 11111011b = 00001010b
-00001010b & 11111100b = 00001000b
-00001010b & 11111101b = 00001000b
-00001010b & 11111110b = 00001010b
-00001010b & 11111111b = 00001010b
-00001010b & 00000000b = 00000000b
-00001010b & 00000001b = 00000000b
-00001010b & 00000010b = 00000010b
-00001010b & 00000011b = 00000010b
-00001010b & 00000100b = 00000000b
-00001010b & 00000101b = 00000000b
-00001010b & 00000110b = 00000010b
-00001010b & 00000111b = 00000010b
-00001010b & 00001000b = 00001000b
-00001010b & 00001001b = 00001000b
-00001010b & 00001010b = 00001010b
-00001010b & 00001011b = 00001010b
-00001010b & 00001100b = 00001000b
-00001010b & 00001101b = 00001000b
-00001010b & 00001110b = 00001010b
-00001010b & 00001111b = 00001010b
-00001010b & 00010000b = 00000000b
-00001010b & 00010001b = 00000000b
-00001010b & 00010010b = 00000010b
-00001010b & 00010011b = 00000010b
-00001010b & 00010100b = 00000000b
-00001010b & 00010101b = 00000000b
-00001010b & 00010110b = 00000010b
-00001010b & 00010111b = 00000010b
-00001010b & 00011000b = 00001000b
-00001010b & 00011001b = 00001000b
-00001010b & 00011010b = 00001010b
-00001010b & 00011011b = 00001010b
-00001010b & 00011100b = 00001000b
-00001010b & 00011101b = 00001000b
-00001010b & 00011110b = 00001010b
-00001010b & 00011111b = 00001010b
-00001010b & 00100000b = 00000000b
-00001010b & 00100001b = 00000000b
-00001010b & 00100010b = 00000010b
-00001010b & 00100011b = 00000010b
-00001010b & 00100100b = 00000000b
-00001010b & 00100101b = 00000000b
-00001010b & 00100110b = 00000010b
-00001010b & 00100111b = 00000010b
-00001010b & 00101000b = 00001000b
-00001010b & 00101001b = 00001000b
-00001010b & 00101010b = 00001010b
-00001010b & 00101011b = 00001010b
-00001010b & 00101100b = 00001000b
-00001010b & 00101101b = 00001000b
-00001010b & 00101110b = 00001010b
-00001010b & 00101111b = 00001010b
-00001010b & 00110000b = 00000000b
-00001010b & 00110001b = 00000000b
-00001010b & 00110010b = 00000010b
-00001010b & 00110011b = 00000010b
-00001010b & 00110100b = 00000000b
-00001010b & 00110101b = 00000000b
-00001010b & 00110110b = 00000010b
-00001010b & 00110111b = 00000010b
-00001010b & 00111000b = 00001000b
-00001010b & 00111001b = 00001000b
-00001010b & 00111010b = 00001010b
-00001010b & 00111011b = 00001010b
-00001010b & 00111100b = 00001000b
-00001010b & 00111101b = 00001000b
-00001010b & 00111110b = 00001010b
-00001010b & 00111111b = 00001010b
-00001010b & 01000000b = 00000000b
-00001010b & 01000001b = 00000000b
-00001010b & 01000010b = 00000010b
-00001010b & 01000011b = 00000010b
-00001010b & 01000100b = 00000000b
-00001010b & 01000101b = 00000000b
-00001010b & 01000110b = 00000010b
-00001010b & 01000111b = 00000010b
-00001010b & 01001000b = 00001000b
-00001010b & 01001001b = 00001000b
-00001010b & 01001010b = 00001010b
-00001010b & 01001011b = 00001010b
-00001010b & 01001100b = 00001000b
-00001010b & 01001101b = 00001000b
-00001010b & 01001110b = 00001010b
-00001010b & 01001111b = 00001010b
-00001010b & 01010000b = 00000000b
-00001010b & 01010001b = 00000000b
-00001010b & 01010010b = 00000010b
-00001010b & 01010011b = 00000010b
-00001010b & 01010100b = 00000000b
-00001010b & 01010101b = 00000000b
-00001010b & 01010110b = 00000010b
-00001010b & 01010111b = 00000010b
-00001010b & 01011000b = 00001000b
-00001010b & 01011001b = 00001000b
-00001010b & 01011010b = 00001010b
-00001010b & 01011011b = 00001010b
-00001010b & 01011100b = 00001000b
-00001010b & 01011101b = 00001000b
-00001010b & 01011110b = 00001010b
-00001010b & 01011111b = 00001010b
-00001010b & 01100000b = 00000000b
-00001010b & 01100001b = 00000000b
-00001010b & 01100010b = 00000010b
-00001010b & 01100011b = 00000010b
-00001010b & 01100100b = 00000000b
-00001010b & 01100101b = 00000000b
-00001010b & 01100110b = 00000010b
-00001010b & 01100111b = 00000010b
-00001010b & 01101000b = 00001000b
-00001010b & 01101001b = 00001000b
-00001010b & 01101010b = 00001010b
-00001010b & 01101011b = 00001010b
-00001010b & 01101100b = 00001000b
-00001010b & 01101101b = 00001000b
-00001010b & 01101110b = 00001010b
-00001010b & 01101111b = 00001010b
-00001010b & 01110000b = 00000000b
-00001010b & 01110001b = 00000000b
-00001010b & 01110010b = 00000010b
-00001010b & 01110011b = 00000010b
-00001010b & 01110100b = 00000000b
-00001010b & 01110101b = 00000000b
-00001010b & 01110110b = 00000010b
-00001010b & 01110111b = 00000010b
-00001010b & 01111000b = 00001000b
-00001010b & 01111001b = 00001000b
-00001010b & 01111010b = 00001010b
-00001010b & 01111011b = 00001010b
-00001010b & 01111100b = 00001000b
-00001010b & 01111101b = 00001000b
-00001010b & 01111110b = 00001010b
-00001011b & 10000000b = 00000000b
-00001011b & 10000001b = 00000001b
-00001011b & 10000010b = 00000010b
-00001011b & 10000011b = 00000011b
-00001011b & 10000100b = 00000000b
-00001011b & 10000101b = 00000001b
-00001011b & 10000110b = 00000010b
-00001011b & 10000111b = 00000011b
-00001011b & 10001000b = 00001000b
-00001011b & 10001001b = 00001001b
-00001011b & 10001010b = 00001010b
-00001011b & 10001011b = 00001011b
-00001011b & 10001100b = 00001000b
-00001011b & 10001101b = 00001001b
-00001011b & 10001110b = 00001010b
-00001011b & 10001111b = 00001011b
-00001011b & 10010000b = 00000000b
-00001011b & 10010001b = 00000001b
-00001011b & 10010010b = 00000010b
-00001011b & 10010011b = 00000011b
-00001011b & 10010100b = 00000000b
-00001011b & 10010101b = 00000001b
-00001011b & 10010110b = 00000010b
-00001011b & 10010111b = 00000011b
-00001011b & 10011000b = 00001000b
-00001011b & 10011001b = 00001001b
-00001011b & 10011010b = 00001010b
-00001011b & 10011011b = 00001011b
-00001011b & 10011100b = 00001000b
-00001011b & 10011101b = 00001001b
-00001011b & 10011110b = 00001010b
-00001011b & 10011111b = 00001011b
-00001011b & 10100000b = 00000000b
-00001011b & 10100001b = 00000001b
-00001011b & 10100010b = 00000010b
-00001011b & 10100011b = 00000011b
-00001011b & 10100100b = 00000000b
-00001011b & 10100101b = 00000001b
-00001011b & 10100110b = 00000010b
-00001011b & 10100111b = 00000011b
-00001011b & 10101000b = 00001000b
-00001011b & 10101001b = 00001001b
-00001011b & 10101010b = 00001010b
-00001011b & 10101011b = 00001011b
-00001011b & 10101100b = 00001000b
-00001011b & 10101101b = 00001001b
-00001011b & 10101110b = 00001010b
-00001011b & 10101111b = 00001011b
-00001011b & 10110000b = 00000000b
-00001011b & 10110001b = 00000001b
-00001011b & 10110010b = 00000010b
-00001011b & 10110011b = 00000011b
-00001011b & 10110100b = 00000000b
-00001011b & 10110101b = 00000001b
-00001011b & 10110110b = 00000010b
-00001011b & 10110111b = 00000011b
-00001011b & 10111000b = 00001000b
-00001011b & 10111001b = 00001001b
-00001011b & 10111010b = 00001010b
-00001011b & 10111011b = 00001011b
-00001011b & 10111100b = 00001000b
-00001011b & 10111101b = 00001001b
-00001011b & 10111110b = 00001010b
-00001011b & 10111111b = 00001011b
-00001011b & 11000000b = 00000000b
-00001011b & 11000001b = 00000001b
-00001011b & 11000010b = 00000010b
-00001011b & 11000011b = 00000011b
-00001011b & 11000100b = 00000000b
-00001011b & 11000101b = 00000001b
-00001011b & 11000110b = 00000010b
-00001011b & 11000111b = 00000011b
-00001011b & 11001000b = 00001000b
-00001011b & 11001001b = 00001001b
-00001011b & 11001010b = 00001010b
-00001011b & 11001011b = 00001011b
-00001011b & 11001100b = 00001000b
-00001011b & 11001101b = 00001001b
-00001011b & 11001110b = 00001010b
-00001011b & 11001111b = 00001011b
-00001011b & 11010000b = 00000000b
-00001011b & 11010001b = 00000001b
-00001011b & 11010010b = 00000010b
-00001011b & 11010011b = 00000011b
-00001011b & 11010100b = 00000000b
-00001011b & 11010101b = 00000001b
-00001011b & 11010110b = 00000010b
-00001011b & 11010111b = 00000011b
-00001011b & 11011000b = 00001000b
-00001011b & 11011001b = 00001001b
-00001011b & 11011010b = 00001010b
-00001011b & 11011011b = 00001011b
-00001011b & 11011100b = 00001000b
-00001011b & 11011101b = 00001001b
-00001011b & 11011110b = 00001010b
-00001011b & 11011111b = 00001011b
-00001011b & 11100000b = 00000000b
-00001011b & 11100001b = 00000001b
-00001011b & 11100010b = 00000010b
-00001011b & 11100011b = 00000011b
-00001011b & 11100100b = 00000000b
-00001011b & 11100101b = 00000001b
-00001011b & 11100110b = 00000010b
-00001011b & 11100111b = 00000011b
-00001011b & 11101000b = 00001000b
-00001011b & 11101001b = 00001001b
-00001011b & 11101010b = 00001010b
-00001011b & 11101011b = 00001011b
-00001011b & 11101100b = 00001000b
-00001011b & 11101101b = 00001001b
-00001011b & 11101110b = 00001010b
-00001011b & 11101111b = 00001011b
-00001011b & 11110000b = 00000000b
-00001011b & 11110001b = 00000001b
-00001011b & 11110010b = 00000010b
-00001011b & 11110011b = 00000011b
-00001011b & 11110100b = 00000000b
-00001011b & 11110101b = 00000001b
-00001011b & 11110110b = 00000010b
-00001011b & 11110111b = 00000011b
-00001011b & 11111000b = 00001000b
-00001011b & 11111001b = 00001001b
-00001011b & 11111010b = 00001010b
-00001011b & 11111011b = 00001011b
-00001011b & 11111100b = 00001000b
-00001011b & 11111101b = 00001001b
-00001011b & 11111110b = 00001010b
-00001011b & 11111111b = 00001011b
-00001011b & 00000000b = 00000000b
-00001011b & 00000001b = 00000001b
-00001011b & 00000010b = 00000010b
-00001011b & 00000011b = 00000011b
-00001011b & 00000100b = 00000000b
-00001011b & 00000101b = 00000001b
-00001011b & 00000110b = 00000010b
-00001011b & 00000111b = 00000011b
-00001011b & 00001000b = 00001000b
-00001011b & 00001001b = 00001001b
-00001011b & 00001010b = 00001010b
-00001011b & 00001011b = 00001011b
-00001011b & 00001100b = 00001000b
-00001011b & 00001101b = 00001001b
-00001011b & 00001110b = 00001010b
-00001011b & 00001111b = 00001011b
-00001011b & 00010000b = 00000000b
-00001011b & 00010001b = 00000001b
-00001011b & 00010010b = 00000010b
-00001011b & 00010011b = 00000011b
-00001011b & 00010100b = 00000000b
-00001011b & 00010101b = 00000001b
-00001011b & 00010110b = 00000010b
-00001011b & 00010111b = 00000011b
-00001011b & 00011000b = 00001000b
-00001011b & 00011001b = 00001001b
-00001011b & 00011010b = 00001010b
-00001011b & 00011011b = 00001011b
-00001011b & 00011100b = 00001000b
-00001011b & 00011101b = 00001001b
-00001011b & 00011110b = 00001010b
-00001011b & 00011111b = 00001011b
-00001011b & 00100000b = 00000000b
-00001011b & 00100001b = 00000001b
-00001011b & 00100010b = 00000010b
-00001011b & 00100011b = 00000011b
-00001011b & 00100100b = 00000000b
-00001011b & 00100101b = 00000001b
-00001011b & 00100110b = 00000010b
-00001011b & 00100111b = 00000011b
-00001011b & 00101000b = 00001000b
-00001011b & 00101001b = 00001001b
-00001011b & 00101010b = 00001010b
-00001011b & 00101011b = 00001011b
-00001011b & 00101100b = 00001000b
-00001011b & 00101101b = 00001001b
-00001011b & 00101110b = 00001010b
-00001011b & 00101111b = 00001011b
-00001011b & 00110000b = 00000000b
-00001011b & 00110001b = 00000001b
-00001011b & 00110010b = 00000010b
-00001011b & 00110011b = 00000011b
-00001011b & 00110100b = 00000000b
-00001011b & 00110101b = 00000001b
-00001011b & 00110110b = 00000010b
-00001011b & 00110111b = 00000011b
-00001011b & 00111000b = 00001000b
-00001011b & 00111001b = 00001001b
-00001011b & 00111010b = 00001010b
-00001011b & 00111011b = 00001011b
-00001011b & 00111100b = 00001000b
-00001011b & 00111101b = 00001001b
-00001011b & 00111110b = 00001010b
-00001011b & 00111111b = 00001011b
-00001011b & 01000000b = 00000000b
-00001011b & 01000001b = 00000001b
-00001011b & 01000010b = 00000010b
-00001011b & 01000011b = 00000011b
-00001011b & 01000100b = 00000000b
-00001011b & 01000101b = 00000001b
-00001011b & 01000110b = 00000010b
-00001011b & 01000111b = 00000011b
-00001011b & 01001000b = 00001000b
-00001011b & 01001001b = 00001001b
-00001011b & 01001010b = 00001010b
-00001011b & 01001011b = 00001011b
-00001011b & 01001100b = 00001000b
-00001011b & 01001101b = 00001001b
-00001011b & 01001110b = 00001010b
-00001011b & 01001111b = 00001011b
-00001011b & 01010000b = 00000000b
-00001011b & 01010001b = 00000001b
-00001011b & 01010010b = 00000010b
-00001011b & 01010011b = 00000011b
-00001011b & 01010100b = 00000000b
-00001011b & 01010101b = 00000001b
-00001011b & 01010110b = 00000010b
-00001011b & 01010111b = 00000011b
-00001011b & 01011000b = 00001000b
-00001011b & 01011001b = 00001001b
-00001011b & 01011010b = 00001010b
-00001011b & 01011011b = 00001011b
-00001011b & 01011100b = 00001000b
-00001011b & 01011101b = 00001001b
-00001011b & 01011110b = 00001010b
-00001011b & 01011111b = 00001011b
-00001011b & 01100000b = 00000000b
-00001011b & 01100001b = 00000001b
-00001011b & 01100010b = 00000010b
-00001011b & 01100011b = 00000011b
-00001011b & 01100100b = 00000000b
-00001011b & 01100101b = 00000001b
-00001011b & 01100110b = 00000010b
-00001011b & 01100111b = 00000011b
-00001011b & 01101000b = 00001000b
-00001011b & 01101001b = 00001001b
-00001011b & 01101010b = 00001010b
-00001011b & 01101011b = 00001011b
-00001011b & 01101100b = 00001000b
-00001011b & 01101101b = 00001001b
-00001011b & 01101110b = 00001010b
-00001011b & 01101111b = 00001011b
-00001011b & 01110000b = 00000000b
-00001011b & 01110001b = 00000001b
-00001011b & 01110010b = 00000010b
-00001011b & 01110011b = 00000011b
-00001011b & 01110100b = 00000000b
-00001011b & 01110101b = 00000001b
-00001011b & 01110110b = 00000010b
-00001011b & 01110111b = 00000011b
-00001011b & 01111000b = 00001000b
-00001011b & 01111001b = 00001001b
-00001011b & 01111010b = 00001010b
-00001011b & 01111011b = 00001011b
-00001011b & 01111100b = 00001000b
-00001011b & 01111101b = 00001001b
-00001011b & 01111110b = 00001010b
-00001100b & 10000000b = 00000000b
-00001100b & 10000001b = 00000000b
-00001100b & 10000010b = 00000000b
-00001100b & 10000011b = 00000000b
-00001100b & 10000100b = 00000100b
-00001100b & 10000101b = 00000100b
-00001100b & 10000110b = 00000100b
-00001100b & 10000111b = 00000100b
-00001100b & 10001000b = 00001000b
-00001100b & 10001001b = 00001000b
-00001100b & 10001010b = 00001000b
-00001100b & 10001011b = 00001000b
-00001100b & 10001100b = 00001100b
-00001100b & 10001101b = 00001100b
-00001100b & 10001110b = 00001100b
-00001100b & 10001111b = 00001100b
-00001100b & 10010000b = 00000000b
-00001100b & 10010001b = 00000000b
-00001100b & 10010010b = 00000000b
-00001100b & 10010011b = 00000000b
-00001100b & 10010100b = 00000100b
-00001100b & 10010101b = 00000100b
-00001100b & 10010110b = 00000100b
-00001100b & 10010111b = 00000100b
-00001100b & 10011000b = 00001000b
-00001100b & 10011001b = 00001000b
-00001100b & 10011010b = 00001000b
-00001100b & 10011011b = 00001000b
-00001100b & 10011100b = 00001100b
-00001100b & 10011101b = 00001100b
-00001100b & 10011110b = 00001100b
-00001100b & 10011111b = 00001100b
-00001100b & 10100000b = 00000000b
-00001100b & 10100001b = 00000000b
-00001100b & 10100010b = 00000000b
-00001100b & 10100011b = 00000000b
-00001100b & 10100100b = 00000100b
-00001100b & 10100101b = 00000100b
-00001100b & 10100110b = 00000100b
-00001100b & 10100111b = 00000100b
-00001100b & 10101000b = 00001000b
-00001100b & 10101001b = 00001000b
-00001100b & 10101010b = 00001000b
-00001100b & 10101011b = 00001000b
-00001100b & 10101100b = 00001100b
-00001100b & 10101101b = 00001100b
-00001100b & 10101110b = 00001100b
-00001100b & 10101111b = 00001100b
-00001100b & 10110000b = 00000000b
-00001100b & 10110001b = 00000000b
-00001100b & 10110010b = 00000000b
-00001100b & 10110011b = 00000000b
-00001100b & 10110100b = 00000100b
-00001100b & 10110101b = 00000100b
-00001100b & 10110110b = 00000100b
-00001100b & 10110111b = 00000100b
-00001100b & 10111000b = 00001000b
-00001100b & 10111001b = 00001000b
-00001100b & 10111010b = 00001000b
-00001100b & 10111011b = 00001000b
-00001100b & 10111100b = 00001100b
-00001100b & 10111101b = 00001100b
-00001100b & 10111110b = 00001100b
-00001100b & 10111111b = 00001100b
-00001100b & 11000000b = 00000000b
-00001100b & 11000001b = 00000000b
-00001100b & 11000010b = 00000000b
-00001100b & 11000011b = 00000000b
-00001100b & 11000100b = 00000100b
-00001100b & 11000101b = 00000100b
-00001100b & 11000110b = 00000100b
-00001100b & 11000111b = 00000100b
-00001100b & 11001000b = 00001000b
-00001100b & 11001001b = 00001000b
-00001100b & 11001010b = 00001000b
-00001100b & 11001011b = 00001000b
-00001100b & 11001100b = 00001100b
-00001100b & 11001101b = 00001100b
-00001100b & 11001110b = 00001100b
-00001100b & 11001111b = 00001100b
-00001100b & 11010000b = 00000000b
-00001100b & 11010001b = 00000000b
-00001100b & 11010010b = 00000000b
-00001100b & 11010011b = 00000000b
-00001100b & 11010100b = 00000100b
-00001100b & 11010101b = 00000100b
-00001100b & 11010110b = 00000100b
-00001100b & 11010111b = 00000100b
-00001100b & 11011000b = 00001000b
-00001100b & 11011001b = 00001000b
-00001100b & 11011010b = 00001000b
-00001100b & 11011011b = 00001000b
-00001100b & 11011100b = 00001100b
-00001100b & 11011101b = 00001100b
-00001100b & 11011110b = 00001100b
-00001100b & 11011111b = 00001100b
-00001100b & 11100000b = 00000000b
-00001100b & 11100001b = 00000000b
-00001100b & 11100010b = 00000000b
-00001100b & 11100011b = 00000000b
-00001100b & 11100100b = 00000100b
-00001100b & 11100101b = 00000100b
-00001100b & 11100110b = 00000100b
-00001100b & 11100111b = 00000100b
-00001100b & 11101000b = 00001000b
-00001100b & 11101001b = 00001000b
-00001100b & 11101010b = 00001000b
-00001100b & 11101011b = 00001000b
-00001100b & 11101100b = 00001100b
-00001100b & 11101101b = 00001100b
-00001100b & 11101110b = 00001100b
-00001100b & 11101111b = 00001100b
-00001100b & 11110000b = 00000000b
-00001100b & 11110001b = 00000000b
-00001100b & 11110010b = 00000000b
-00001100b & 11110011b = 00000000b
-00001100b & 11110100b = 00000100b
-00001100b & 11110101b = 00000100b
-00001100b & 11110110b = 00000100b
-00001100b & 11110111b = 00000100b
-00001100b & 11111000b = 00001000b
-00001100b & 11111001b = 00001000b
-00001100b & 11111010b = 00001000b
-00001100b & 11111011b = 00001000b
-00001100b & 11111100b = 00001100b
-00001100b & 11111101b = 00001100b
-00001100b & 11111110b = 00001100b
-00001100b & 11111111b = 00001100b
-00001100b & 00000000b = 00000000b
-00001100b & 00000001b = 00000000b
-00001100b & 00000010b = 00000000b
-00001100b & 00000011b = 00000000b
-00001100b & 00000100b = 00000100b
-00001100b & 00000101b = 00000100b
-00001100b & 00000110b = 00000100b
-00001100b & 00000111b = 00000100b
-00001100b & 00001000b = 00001000b
-00001100b & 00001001b = 00001000b
-00001100b & 00001010b = 00001000b
-00001100b & 00001011b = 00001000b
-00001100b & 00001100b = 00001100b
-00001100b & 00001101b = 00001100b
-00001100b & 00001110b = 00001100b
-00001100b & 00001111b = 00001100b
-00001100b & 00010000b = 00000000b
-00001100b & 00010001b = 00000000b
-00001100b & 00010010b = 00000000b
-00001100b & 00010011b = 00000000b
-00001100b & 00010100b = 00000100b
-00001100b & 00010101b = 00000100b
-00001100b & 00010110b = 00000100b
-00001100b & 00010111b = 00000100b
-00001100b & 00011000b = 00001000b
-00001100b & 00011001b = 00001000b
-00001100b & 00011010b = 00001000b
-00001100b & 00011011b = 00001000b
-00001100b & 00011100b = 00001100b
-00001100b & 00011101b = 00001100b
-00001100b & 00011110b = 00001100b
-00001100b & 00011111b = 00001100b
-00001100b & 00100000b = 00000000b
-00001100b & 00100001b = 00000000b
-00001100b & 00100010b = 00000000b
-00001100b & 00100011b = 00000000b
-00001100b & 00100100b = 00000100b
-00001100b & 00100101b = 00000100b
-00001100b & 00100110b = 00000100b
-00001100b & 00100111b = 00000100b
-00001100b & 00101000b = 00001000b
-00001100b & 00101001b = 00001000b
-00001100b & 00101010b = 00001000b
-00001100b & 00101011b = 00001000b
-00001100b & 00101100b = 00001100b
-00001100b & 00101101b = 00001100b
-00001100b & 00101110b = 00001100b
-00001100b & 00101111b = 00001100b
-00001100b & 00110000b = 00000000b
-00001100b & 00110001b = 00000000b
-00001100b & 00110010b = 00000000b
-00001100b & 00110011b = 00000000b
-00001100b & 00110100b = 00000100b
-00001100b & 00110101b = 00000100b
-00001100b & 00110110b = 00000100b
-00001100b & 00110111b = 00000100b
-00001100b & 00111000b = 00001000b
-00001100b & 00111001b = 00001000b
-00001100b & 00111010b = 00001000b
-00001100b & 00111011b = 00001000b
-00001100b & 00111100b = 00001100b
-00001100b & 00111101b = 00001100b
-00001100b & 00111110b = 00001100b
-00001100b & 00111111b = 00001100b
-00001100b & 01000000b = 00000000b
-00001100b & 01000001b = 00000000b
-00001100b & 01000010b = 00000000b
-00001100b & 01000011b = 00000000b
-00001100b & 01000100b = 00000100b
-00001100b & 01000101b = 00000100b
-00001100b & 01000110b = 00000100b
-00001100b & 01000111b = 00000100b
-00001100b & 01001000b = 00001000b
-00001100b & 01001001b = 00001000b
-00001100b & 01001010b = 00001000b
-00001100b & 01001011b = 00001000b
-00001100b & 01001100b = 00001100b
-00001100b & 01001101b = 00001100b
-00001100b & 01001110b = 00001100b
-00001100b & 01001111b = 00001100b
-00001100b & 01010000b = 00000000b
-00001100b & 01010001b = 00000000b
-00001100b & 01010010b = 00000000b
-00001100b & 01010011b = 00000000b
-00001100b & 01010100b = 00000100b
-00001100b & 01010101b = 00000100b
-00001100b & 01010110b = 00000100b
-00001100b & 01010111b = 00000100b
-00001100b & 01011000b = 00001000b
-00001100b & 01011001b = 00001000b
-00001100b & 01011010b = 00001000b
-00001100b & 01011011b = 00001000b
-00001100b & 01011100b = 00001100b
-00001100b & 01011101b = 00001100b
-00001100b & 01011110b = 00001100b
-00001100b & 01011111b = 00001100b
-00001100b & 01100000b = 00000000b
-00001100b & 01100001b = 00000000b
-00001100b & 01100010b = 00000000b
-00001100b & 01100011b = 00000000b
-00001100b & 01100100b = 00000100b
-00001100b & 01100101b = 00000100b
-00001100b & 01100110b = 00000100b
-00001100b & 01100111b = 00000100b
-00001100b & 01101000b = 00001000b
-00001100b & 01101001b = 00001000b
-00001100b & 01101010b = 00001000b
-00001100b & 01101011b = 00001000b
-00001100b & 01101100b = 00001100b
-00001100b & 01101101b = 00001100b
-00001100b & 01101110b = 00001100b
-00001100b & 01101111b = 00001100b
-00001100b & 01110000b = 00000000b
-00001100b & 01110001b = 00000000b
-00001100b & 01110010b = 00000000b
-00001100b & 01110011b = 00000000b
-00001100b & 01110100b = 00000100b
-00001100b & 01110101b = 00000100b
-00001100b & 01110110b = 00000100b
-00001100b & 01110111b = 00000100b
-00001100b & 01111000b = 00001000b
-00001100b & 01111001b = 00001000b
-00001100b & 01111010b = 00001000b
-00001100b & 01111011b = 00001000b
-00001100b & 01111100b = 00001100b
-00001100b & 01111101b = 00001100b
-00001100b & 01111110b = 00001100b
-00001101b & 10000000b = 00000000b
-00001101b & 10000001b = 00000001b
-00001101b & 10000010b = 00000000b
-00001101b & 10000011b = 00000001b
-00001101b & 10000100b = 00000100b
-00001101b & 10000101b = 00000101b
-00001101b & 10000110b = 00000100b
-00001101b & 10000111b = 00000101b
-00001101b & 10001000b = 00001000b
-00001101b & 10001001b = 00001001b
-00001101b & 10001010b = 00001000b
-00001101b & 10001011b = 00001001b
-00001101b & 10001100b = 00001100b
-00001101b & 10001101b = 00001101b
-00001101b & 10001110b = 00001100b
-00001101b & 10001111b = 00001101b
-00001101b & 10010000b = 00000000b
-00001101b & 10010001b = 00000001b
-00001101b & 10010010b = 00000000b
-00001101b & 10010011b = 00000001b
-00001101b & 10010100b = 00000100b
-00001101b & 10010101b = 00000101b
-00001101b & 10010110b = 00000100b
-00001101b & 10010111b = 00000101b
-00001101b & 10011000b = 00001000b
-00001101b & 10011001b = 00001001b
-00001101b & 10011010b = 00001000b
-00001101b & 10011011b = 00001001b
-00001101b & 10011100b = 00001100b
-00001101b & 10011101b = 00001101b
-00001101b & 10011110b = 00001100b
-00001101b & 10011111b = 00001101b
-00001101b & 10100000b = 00000000b
-00001101b & 10100001b = 00000001b
-00001101b & 10100010b = 00000000b
-00001101b & 10100011b = 00000001b
-00001101b & 10100100b = 00000100b
-00001101b & 10100101b = 00000101b
-00001101b & 10100110b = 00000100b
-00001101b & 10100111b = 00000101b
-00001101b & 10101000b = 00001000b
-00001101b & 10101001b = 00001001b
-00001101b & 10101010b = 00001000b
-00001101b & 10101011b = 00001001b
-00001101b & 10101100b = 00001100b
-00001101b & 10101101b = 00001101b
-00001101b & 10101110b = 00001100b
-00001101b & 10101111b = 00001101b
-00001101b & 10110000b = 00000000b
-00001101b & 10110001b = 00000001b
-00001101b & 10110010b = 00000000b
-00001101b & 10110011b = 00000001b
-00001101b & 10110100b = 00000100b
-00001101b & 10110101b = 00000101b
-00001101b & 10110110b = 00000100b
-00001101b & 10110111b = 00000101b
-00001101b & 10111000b = 00001000b
-00001101b & 10111001b = 00001001b
-00001101b & 10111010b = 00001000b
-00001101b & 10111011b = 00001001b
-00001101b & 10111100b = 00001100b
-00001101b & 10111101b = 00001101b
-00001101b & 10111110b = 00001100b
-00001101b & 10111111b = 00001101b
-00001101b & 11000000b = 00000000b
-00001101b & 11000001b = 00000001b
-00001101b & 11000010b = 00000000b
-00001101b & 11000011b = 00000001b
-00001101b & 11000100b = 00000100b
-00001101b & 11000101b = 00000101b
-00001101b & 11000110b = 00000100b
-00001101b & 11000111b = 00000101b
-00001101b & 11001000b = 00001000b
-00001101b & 11001001b = 00001001b
-00001101b & 11001010b = 00001000b
-00001101b & 11001011b = 00001001b
-00001101b & 11001100b = 00001100b
-00001101b & 11001101b = 00001101b
-00001101b & 11001110b = 00001100b
-00001101b & 11001111b = 00001101b
-00001101b & 11010000b = 00000000b
-00001101b & 11010001b = 00000001b
-00001101b & 11010010b = 00000000b
-00001101b & 11010011b = 00000001b
-00001101b & 11010100b = 00000100b
-00001101b & 11010101b = 00000101b
-00001101b & 11010110b = 00000100b
-00001101b & 11010111b = 00000101b
-00001101b & 11011000b = 00001000b
-00001101b & 11011001b = 00001001b
-00001101b & 11011010b = 00001000b
-00001101b & 11011011b = 00001001b
-00001101b & 11011100b = 00001100b
-00001101b & 11011101b = 00001101b
-00001101b & 11011110b = 00001100b
-00001101b & 11011111b = 00001101b
-00001101b & 11100000b = 00000000b
-00001101b & 11100001b = 00000001b
-00001101b & 11100010b = 00000000b
-00001101b & 11100011b = 00000001b
-00001101b & 11100100b = 00000100b
-00001101b & 11100101b = 00000101b
-00001101b & 11100110b = 00000100b
-00001101b & 11100111b = 00000101b
-00001101b & 11101000b = 00001000b
-00001101b & 11101001b = 00001001b
-00001101b & 11101010b = 00001000b
-00001101b & 11101011b = 00001001b
-00001101b & 11101100b = 00001100b
-00001101b & 11101101b = 00001101b
-00001101b & 11101110b = 00001100b
-00001101b & 11101111b = 00001101b
-00001101b & 11110000b = 00000000b
-00001101b & 11110001b = 00000001b
-00001101b & 11110010b = 00000000b
-00001101b & 11110011b = 00000001b
-00001101b & 11110100b = 00000100b
-00001101b & 11110101b = 00000101b
-00001101b & 11110110b = 00000100b
-00001101b & 11110111b = 00000101b
-00001101b & 11111000b = 00001000b
-00001101b & 11111001b = 00001001b
-00001101b & 11111010b = 00001000b
-00001101b & 11111011b = 00001001b
-00001101b & 11111100b = 00001100b
-00001101b & 11111101b = 00001101b
-00001101b & 11111110b = 00001100b
-00001101b & 11111111b = 00001101b
-00001101b & 00000000b = 00000000b
-00001101b & 00000001b = 00000001b
-00001101b & 00000010b = 00000000b
-00001101b & 00000011b = 00000001b
-00001101b & 00000100b = 00000100b
-00001101b & 00000101b = 00000101b
-00001101b & 00000110b = 00000100b
-00001101b & 00000111b = 00000101b
-00001101b & 00001000b = 00001000b
-00001101b & 00001001b = 00001001b
-00001101b & 00001010b = 00001000b
-00001101b & 00001011b = 00001001b
-00001101b & 00001100b = 00001100b
-00001101b & 00001101b = 00001101b
-00001101b & 00001110b = 00001100b
-00001101b & 00001111b = 00001101b
-00001101b & 00010000b = 00000000b
-00001101b & 00010001b = 00000001b
-00001101b & 00010010b = 00000000b
-00001101b & 00010011b = 00000001b
-00001101b & 00010100b = 00000100b
-00001101b & 00010101b = 00000101b
-00001101b & 00010110b = 00000100b
-00001101b & 00010111b = 00000101b
-00001101b & 00011000b = 00001000b
-00001101b & 00011001b = 00001001b
-00001101b & 00011010b = 00001000b
-00001101b & 00011011b = 00001001b
-00001101b & 00011100b = 00001100b
-00001101b & 00011101b = 00001101b
-00001101b & 00011110b = 00001100b
-00001101b & 00011111b = 00001101b
-00001101b & 00100000b = 00000000b
-00001101b & 00100001b = 00000001b
-00001101b & 00100010b = 00000000b
-00001101b & 00100011b = 00000001b
-00001101b & 00100100b = 00000100b
-00001101b & 00100101b = 00000101b
-00001101b & 00100110b = 00000100b
-00001101b & 00100111b = 00000101b
-00001101b & 00101000b = 00001000b
-00001101b & 00101001b = 00001001b
-00001101b & 00101010b = 00001000b
-00001101b & 00101011b = 00001001b
-00001101b & 00101100b = 00001100b
-00001101b & 00101101b = 00001101b
-00001101b & 00101110b = 00001100b
-00001101b & 00101111b = 00001101b
-00001101b & 00110000b = 00000000b
-00001101b & 00110001b = 00000001b
-00001101b & 00110010b = 00000000b
-00001101b & 00110011b = 00000001b
-00001101b & 00110100b = 00000100b
-00001101b & 00110101b = 00000101b
-00001101b & 00110110b = 00000100b
-00001101b & 00110111b = 00000101b
-00001101b & 00111000b = 00001000b
-00001101b & 00111001b = 00001001b
-00001101b & 00111010b = 00001000b
-00001101b & 00111011b = 00001001b
-00001101b & 00111100b = 00001100b
-00001101b & 00111101b = 00001101b
-00001101b & 00111110b = 00001100b
-00001101b & 00111111b = 00001101b
-00001101b & 01000000b = 00000000b
-00001101b & 01000001b = 00000001b
-00001101b & 01000010b = 00000000b
-00001101b & 01000011b = 00000001b
-00001101b & 01000100b = 00000100b
-00001101b & 01000101b = 00000101b
-00001101b & 01000110b = 00000100b
-00001101b & 01000111b = 00000101b
-00001101b & 01001000b = 00001000b
-00001101b & 01001001b = 00001001b
-00001101b & 01001010b = 00001000b
-00001101b & 01001011b = 00001001b
-00001101b & 01001100b = 00001100b
-00001101b & 01001101b = 00001101b
-00001101b & 01001110b = 00001100b
-00001101b & 01001111b = 00001101b
-00001101b & 01010000b = 00000000b
-00001101b & 01010001b = 00000001b
-00001101b & 01010010b = 00000000b
-00001101b & 01010011b = 00000001b
-00001101b & 01010100b = 00000100b
-00001101b & 01010101b = 00000101b
-00001101b & 01010110b = 00000100b
-00001101b & 01010111b = 00000101b
-00001101b & 01011000b = 00001000b
-00001101b & 01011001b = 00001001b
-00001101b & 01011010b = 00001000b
-00001101b & 01011011b = 00001001b
-00001101b & 01011100b = 00001100b
-00001101b & 01011101b = 00001101b
-00001101b & 01011110b = 00001100b
-00001101b & 01011111b = 00001101b
-00001101b & 01100000b = 00000000b
-00001101b & 01100001b = 00000001b
-00001101b & 01100010b = 00000000b
-00001101b & 01100011b = 00000001b
-00001101b & 01100100b = 00000100b
-00001101b & 01100101b = 00000101b
-00001101b & 01100110b = 00000100b
-00001101b & 01100111b = 00000101b
-00001101b & 01101000b = 00001000b
-00001101b & 01101001b = 00001001b
-00001101b & 01101010b = 00001000b
-00001101b & 01101011b = 00001001b
-00001101b & 01101100b = 00001100b
-00001101b & 01101101b = 00001101b
-00001101b & 01101110b = 00001100b
-00001101b & 01101111b = 00001101b
-00001101b & 01110000b = 00000000b
-00001101b & 01110001b = 00000001b
-00001101b & 01110010b = 00000000b
-00001101b & 01110011b = 00000001b
-00001101b & 01110100b = 00000100b
-00001101b & 01110101b = 00000101b
-00001101b & 01110110b = 00000100b
-00001101b & 01110111b = 00000101b
-00001101b & 01111000b = 00001000b
-00001101b & 01111001b = 00001001b
-00001101b & 01111010b = 00001000b
-00001101b & 01111011b = 00001001b
-00001101b & 01111100b = 00001100b
-00001101b & 01111101b = 00001101b
-00001101b & 01111110b = 00001100b
-00001110b & 10000000b = 00000000b
-00001110b & 10000001b = 00000000b
-00001110b & 10000010b = 00000010b
-00001110b & 10000011b = 00000010b
-00001110b & 10000100b = 00000100b
-00001110b & 10000101b = 00000100b
-00001110b & 10000110b = 00000110b
-00001110b & 10000111b = 00000110b
-00001110b & 10001000b = 00001000b
-00001110b & 10001001b = 00001000b
-00001110b & 10001010b = 00001010b
-00001110b & 10001011b = 00001010b
-00001110b & 10001100b = 00001100b
-00001110b & 10001101b = 00001100b
-00001110b & 10001110b = 00001110b
-00001110b & 10001111b = 00001110b
-00001110b & 10010000b = 00000000b
-00001110b & 10010001b = 00000000b
-00001110b & 10010010b = 00000010b
-00001110b & 10010011b = 00000010b
-00001110b & 10010100b = 00000100b
-00001110b & 10010101b = 00000100b
-00001110b & 10010110b = 00000110b
-00001110b & 10010111b = 00000110b
-00001110b & 10011000b = 00001000b
-00001110b & 10011001b = 00001000b
-00001110b & 10011010b = 00001010b
-00001110b & 10011011b = 00001010b
-00001110b & 10011100b = 00001100b
-00001110b & 10011101b = 00001100b
-00001110b & 10011110b = 00001110b
-00001110b & 10011111b = 00001110b
-00001110b & 10100000b = 00000000b
-00001110b & 10100001b = 00000000b
-00001110b & 10100010b = 00000010b
-00001110b & 10100011b = 00000010b
-00001110b & 10100100b = 00000100b
-00001110b & 10100101b = 00000100b
-00001110b & 10100110b = 00000110b
-00001110b & 10100111b = 00000110b
-00001110b & 10101000b = 00001000b
-00001110b & 10101001b = 00001000b
-00001110b & 10101010b = 00001010b
-00001110b & 10101011b = 00001010b
-00001110b & 10101100b = 00001100b
-00001110b & 10101101b = 00001100b
-00001110b & 10101110b = 00001110b
-00001110b & 10101111b = 00001110b
-00001110b & 10110000b = 00000000b
-00001110b & 10110001b = 00000000b
-00001110b & 10110010b = 00000010b
-00001110b & 10110011b = 00000010b
-00001110b & 10110100b = 00000100b
-00001110b & 10110101b = 00000100b
-00001110b & 10110110b = 00000110b
-00001110b & 10110111b = 00000110b
-00001110b & 10111000b = 00001000b
-00001110b & 10111001b = 00001000b
-00001110b & 10111010b = 00001010b
-00001110b & 10111011b = 00001010b
-00001110b & 10111100b = 00001100b
-00001110b & 10111101b = 00001100b
-00001110b & 10111110b = 00001110b
-00001110b & 10111111b = 00001110b
-00001110b & 11000000b = 00000000b
-00001110b & 11000001b = 00000000b
-00001110b & 11000010b = 00000010b
-00001110b & 11000011b = 00000010b
-00001110b & 11000100b = 00000100b
-00001110b & 11000101b = 00000100b
-00001110b & 11000110b = 00000110b
-00001110b & 11000111b = 00000110b
-00001110b & 11001000b = 00001000b
-00001110b & 11001001b = 00001000b
-00001110b & 11001010b = 00001010b
-00001110b & 11001011b = 00001010b
-00001110b & 11001100b = 00001100b
-00001110b & 11001101b = 00001100b
-00001110b & 11001110b = 00001110b
-00001110b & 11001111b = 00001110b
-00001110b & 11010000b = 00000000b
-00001110b & 11010001b = 00000000b
-00001110b & 11010010b = 00000010b
-00001110b & 11010011b = 00000010b
-00001110b & 11010100b = 00000100b
-00001110b & 11010101b = 00000100b
-00001110b & 11010110b = 00000110b
-00001110b & 11010111b = 00000110b
-00001110b & 11011000b = 00001000b
-00001110b & 11011001b = 00001000b
-00001110b & 11011010b = 00001010b
-00001110b & 11011011b = 00001010b
-00001110b & 11011100b = 00001100b
-00001110b & 11011101b = 00001100b
-00001110b & 11011110b = 00001110b
-00001110b & 11011111b = 00001110b
-00001110b & 11100000b = 00000000b
-00001110b & 11100001b = 00000000b
-00001110b & 11100010b = 00000010b
-00001110b & 11100011b = 00000010b
-00001110b & 11100100b = 00000100b
-00001110b & 11100101b = 00000100b
-00001110b & 11100110b = 00000110b
-00001110b & 11100111b = 00000110b
-00001110b & 11101000b = 00001000b
-00001110b & 11101001b = 00001000b
-00001110b & 11101010b = 00001010b
-00001110b & 11101011b = 00001010b
-00001110b & 11101100b = 00001100b
-00001110b & 11101101b = 00001100b
-00001110b & 11101110b = 00001110b
-00001110b & 11101111b = 00001110b
-00001110b & 11110000b = 00000000b
-00001110b & 11110001b = 00000000b
-00001110b & 11110010b = 00000010b
-00001110b & 11110011b = 00000010b
-00001110b & 11110100b = 00000100b
-00001110b & 11110101b = 00000100b
-00001110b & 11110110b = 00000110b
-00001110b & 11110111b = 00000110b
-00001110b & 11111000b = 00001000b
-00001110b & 11111001b = 00001000b
-00001110b & 11111010b = 00001010b
-00001110b & 11111011b = 00001010b
-00001110b & 11111100b = 00001100b
-00001110b & 11111101b = 00001100b
-00001110b & 11111110b = 00001110b
-00001110b & 11111111b = 00001110b
-00001110b & 00000000b = 00000000b
-00001110b & 00000001b = 00000000b
-00001110b & 00000010b = 00000010b
-00001110b & 00000011b = 00000010b
-00001110b & 00000100b = 00000100b
-00001110b & 00000101b = 00000100b
-00001110b & 00000110b = 00000110b
-00001110b & 00000111b = 00000110b
-00001110b & 00001000b = 00001000b
-00001110b & 00001001b = 00001000b
-00001110b & 00001010b = 00001010b
-00001110b & 00001011b = 00001010b
-00001110b & 00001100b = 00001100b
-00001110b & 00001101b = 00001100b
-00001110b & 00001110b = 00001110b
-00001110b & 00001111b = 00001110b
-00001110b & 00010000b = 00000000b
-00001110b & 00010001b = 00000000b
-00001110b & 00010010b = 00000010b
-00001110b & 00010011b = 00000010b
-00001110b & 00010100b = 00000100b
-00001110b & 00010101b = 00000100b
-00001110b & 00010110b = 00000110b
-00001110b & 00010111b = 00000110b
-00001110b & 00011000b = 00001000b
-00001110b & 00011001b = 00001000b
-00001110b & 00011010b = 00001010b
-00001110b & 00011011b = 00001010b
-00001110b & 00011100b = 00001100b
-00001110b & 00011101b = 00001100b
-00001110b & 00011110b = 00001110b
-00001110b & 00011111b = 00001110b
-00001110b & 00100000b = 00000000b
-00001110b & 00100001b = 00000000b
-00001110b & 00100010b = 00000010b
-00001110b & 00100011b = 00000010b
-00001110b & 00100100b = 00000100b
-00001110b & 00100101b = 00000100b
-00001110b & 00100110b = 00000110b
-00001110b & 00100111b = 00000110b
-00001110b & 00101000b = 00001000b
-00001110b & 00101001b = 00001000b
-00001110b & 00101010b = 00001010b
-00001110b & 00101011b = 00001010b
-00001110b & 00101100b = 00001100b
-00001110b & 00101101b = 00001100b
-00001110b & 00101110b = 00001110b
-00001110b & 00101111b = 00001110b
-00001110b & 00110000b = 00000000b
-00001110b & 00110001b = 00000000b
-00001110b & 00110010b = 00000010b
-00001110b & 00110011b = 00000010b
-00001110b & 00110100b = 00000100b
-00001110b & 00110101b = 00000100b
-00001110b & 00110110b = 00000110b
-00001110b & 00110111b = 00000110b
-00001110b & 00111000b = 00001000b
-00001110b & 00111001b = 00001000b
-00001110b & 00111010b = 00001010b
-00001110b & 00111011b = 00001010b
-00001110b & 00111100b = 00001100b
-00001110b & 00111101b = 00001100b
-00001110b & 00111110b = 00001110b
-00001110b & 00111111b = 00001110b
-00001110b & 01000000b = 00000000b
-00001110b & 01000001b = 00000000b
-00001110b & 01000010b = 00000010b
-00001110b & 01000011b = 00000010b
-00001110b & 01000100b = 00000100b
-00001110b & 01000101b = 00000100b
-00001110b & 01000110b = 00000110b
-00001110b & 01000111b = 00000110b
-00001110b & 01001000b = 00001000b
-00001110b & 01001001b = 00001000b
-00001110b & 01001010b = 00001010b
-00001110b & 01001011b = 00001010b
-00001110b & 01001100b = 00001100b
-00001110b & 01001101b = 00001100b
-00001110b & 01001110b = 00001110b
-00001110b & 01001111b = 00001110b
-00001110b & 01010000b = 00000000b
-00001110b & 01010001b = 00000000b
-00001110b & 01010010b = 00000010b
-00001110b & 01010011b = 00000010b
-00001110b & 01010100b = 00000100b
-00001110b & 01010101b = 00000100b
-00001110b & 01010110b = 00000110b
-00001110b & 01010111b = 00000110b
-00001110b & 01011000b = 00001000b
-00001110b & 01011001b = 00001000b
-00001110b & 01011010b = 00001010b
-00001110b & 01011011b = 00001010b
-00001110b & 01011100b = 00001100b
-00001110b & 01011101b = 00001100b
-00001110b & 01011110b = 00001110b
-00001110b & 01011111b = 00001110b
-00001110b & 01100000b = 00000000b
-00001110b & 01100001b = 00000000b
-00001110b & 01100010b = 00000010b
-00001110b & 01100011b = 00000010b
-00001110b & 01100100b = 00000100b
-00001110b & 01100101b = 00000100b
-00001110b & 01100110b = 00000110b
-00001110b & 01100111b = 00000110b
-00001110b & 01101000b = 00001000b
-00001110b & 01101001b = 00001000b
-00001110b & 01101010b = 00001010b
-00001110b & 01101011b = 00001010b
-00001110b & 01101100b = 00001100b
-00001110b & 01101101b = 00001100b
-00001110b & 01101110b = 00001110b
-00001110b & 01101111b = 00001110b
-00001110b & 01110000b = 00000000b
-00001110b & 01110001b = 00000000b
-00001110b & 01110010b = 00000010b
-00001110b & 01110011b = 00000010b
-00001110b & 01110100b = 00000100b
-00001110b & 01110101b = 00000100b
-00001110b & 01110110b = 00000110b
-00001110b & 01110111b = 00000110b
-00001110b & 01111000b = 00001000b
-00001110b & 01111001b = 00001000b
-00001110b & 01111010b = 00001010b
-00001110b & 01111011b = 00001010b
-00001110b & 01111100b = 00001100b
-00001110b & 01111101b = 00001100b
-00001110b & 01111110b = 00001110b
-00001111b & 10000000b = 00000000b
-00001111b & 10000001b = 00000001b
-00001111b & 10000010b = 00000010b
-00001111b & 10000011b = 00000011b
-00001111b & 10000100b = 00000100b
-00001111b & 10000101b = 00000101b
-00001111b & 10000110b = 00000110b
-00001111b & 10000111b = 00000111b
-00001111b & 10001000b = 00001000b
-00001111b & 10001001b = 00001001b
-00001111b & 10001010b = 00001010b
-00001111b & 10001011b = 00001011b
-00001111b & 10001100b = 00001100b
-00001111b & 10001101b = 00001101b
-00001111b & 10001110b = 00001110b
-00001111b & 10001111b = 00001111b
-00001111b & 10010000b = 00000000b
-00001111b & 10010001b = 00000001b
-00001111b & 10010010b = 00000010b
-00001111b & 10010011b = 00000011b
-00001111b & 10010100b = 00000100b
-00001111b & 10010101b = 00000101b
-00001111b & 10010110b = 00000110b
-00001111b & 10010111b = 00000111b
-00001111b & 10011000b = 00001000b
-00001111b & 10011001b = 00001001b
-00001111b & 10011010b = 00001010b
-00001111b & 10011011b = 00001011b
-00001111b & 10011100b = 00001100b
-00001111b & 10011101b = 00001101b
-00001111b & 10011110b = 00001110b
-00001111b & 10011111b = 00001111b
-00001111b & 10100000b = 00000000b
-00001111b & 10100001b = 00000001b
-00001111b & 10100010b = 00000010b
-00001111b & 10100011b = 00000011b
-00001111b & 10100100b = 00000100b
-00001111b & 10100101b = 00000101b
-00001111b & 10100110b = 00000110b
-00001111b & 10100111b = 00000111b
-00001111b & 10101000b = 00001000b
-00001111b & 10101001b = 00001001b
-00001111b & 10101010b = 00001010b
-00001111b & 10101011b = 00001011b
-00001111b & 10101100b = 00001100b
-00001111b & 10101101b = 00001101b
-00001111b & 10101110b = 00001110b
-00001111b & 10101111b = 00001111b
-00001111b & 10110000b = 00000000b
-00001111b & 10110001b = 00000001b
-00001111b & 10110010b = 00000010b
-00001111b & 10110011b = 00000011b
-00001111b & 10110100b = 00000100b
-00001111b & 10110101b = 00000101b
-00001111b & 10110110b = 00000110b
-00001111b & 10110111b = 00000111b
-00001111b & 10111000b = 00001000b
-00001111b & 10111001b = 00001001b
-00001111b & 10111010b = 00001010b
-00001111b & 10111011b = 00001011b
-00001111b & 10111100b = 00001100b
-00001111b & 10111101b = 00001101b
-00001111b & 10111110b = 00001110b
-00001111b & 10111111b = 00001111b
-00001111b & 11000000b = 00000000b
-00001111b & 11000001b = 00000001b
-00001111b & 11000010b = 00000010b
-00001111b & 11000011b = 00000011b
-00001111b & 11000100b = 00000100b
-00001111b & 11000101b = 00000101b
-00001111b & 11000110b = 00000110b
-00001111b & 11000111b = 00000111b
-00001111b & 11001000b = 00001000b
-00001111b & 11001001b = 00001001b
-00001111b & 11001010b = 00001010b
-00001111b & 11001011b = 00001011b
-00001111b & 11001100b = 00001100b
-00001111b & 11001101b = 00001101b
-00001111b & 11001110b = 00001110b
-00001111b & 11001111b = 00001111b
-00001111b & 11010000b = 00000000b
-00001111b & 11010001b = 00000001b
-00001111b & 11010010b = 00000010b
-00001111b & 11010011b = 00000011b
-00001111b & 11010100b = 00000100b
-00001111b & 11010101b = 00000101b
-00001111b & 11010110b = 00000110b
-00001111b & 11010111b = 00000111b
-00001111b & 11011000b = 00001000b
-00001111b & 11011001b = 00001001b
-00001111b & 11011010b = 00001010b
-00001111b & 11011011b = 00001011b
-00001111b & 11011100b = 00001100b
-00001111b & 11011101b = 00001101b
-00001111b & 11011110b = 00001110b
-00001111b & 11011111b = 00001111b
-00001111b & 11100000b = 00000000b
-00001111b & 11100001b = 00000001b
-00001111b & 11100010b = 00000010b
-00001111b & 11100011b = 00000011b
-00001111b & 11100100b = 00000100b
-00001111b & 11100101b = 00000101b
-00001111b & 11100110b = 00000110b
-00001111b & 11100111b = 00000111b
-00001111b & 11101000b = 00001000b
-00001111b & 11101001b = 00001001b
-00001111b & 11101010b = 00001010b
-00001111b & 11101011b = 00001011b
-00001111b & 11101100b = 00001100b
-00001111b & 11101101b = 00001101b
-00001111b & 11101110b = 00001110b
-00001111b & 11101111b = 00001111b
-00001111b & 11110000b = 00000000b
-00001111b & 11110001b = 00000001b
-00001111b & 11110010b = 00000010b
-00001111b & 11110011b = 00000011b
-00001111b & 11110100b = 00000100b
-00001111b & 11110101b = 00000101b
-00001111b & 11110110b = 00000110b
-00001111b & 11110111b = 00000111b
-00001111b & 11111000b = 00001000b
-00001111b & 11111001b = 00001001b
-00001111b & 11111010b = 00001010b
-00001111b & 11111011b = 00001011b
-00001111b & 11111100b = 00001100b
-00001111b & 11111101b = 00001101b
-00001111b & 11111110b = 00001110b
-00001111b & 11111111b = 00001111b
-00001111b & 00000000b = 00000000b
-00001111b & 00000001b = 00000001b
-00001111b & 00000010b = 00000010b
-00001111b & 00000011b = 00000011b
-00001111b & 00000100b = 00000100b
-00001111b & 00000101b = 00000101b
-00001111b & 00000110b = 00000110b
-00001111b & 00000111b = 00000111b
-00001111b & 00001000b = 00001000b
-00001111b & 00001001b = 00001001b
-00001111b & 00001010b = 00001010b
-00001111b & 00001011b = 00001011b
-00001111b & 00001100b = 00001100b
-00001111b & 00001101b = 00001101b
-00001111b & 00001110b = 00001110b
-00001111b & 00001111b = 00001111b
-00001111b & 00010000b = 00000000b
-00001111b & 00010001b = 00000001b
-00001111b & 00010010b = 00000010b
-00001111b & 00010011b = 00000011b
-00001111b & 00010100b = 00000100b
-00001111b & 00010101b = 00000101b
-00001111b & 00010110b = 00000110b
-00001111b & 00010111b = 00000111b
-00001111b & 00011000b = 00001000b
-00001111b & 00011001b = 00001001b
-00001111b & 00011010b = 00001010b
-00001111b & 00011011b = 00001011b
-00001111b & 00011100b = 00001100b
-00001111b & 00011101b = 00001101b
-00001111b & 00011110b = 00001110b
-00001111b & 00011111b = 00001111b
-00001111b & 00100000b = 00000000b
-00001111b & 00100001b = 00000001b
-00001111b & 00100010b = 00000010b
-00001111b & 00100011b = 00000011b
-00001111b & 00100100b = 00000100b
-00001111b & 00100101b = 00000101b
-00001111b & 00100110b = 00000110b
-00001111b & 00100111b = 00000111b
-00001111b & 00101000b = 00001000b
-00001111b & 00101001b = 00001001b
-00001111b & 00101010b = 00001010b
-00001111b & 00101011b = 00001011b
-00001111b & 00101100b = 00001100b
-00001111b & 00101101b = 00001101b
-00001111b & 00101110b = 00001110b
-00001111b & 00101111b = 00001111b
-00001111b & 00110000b = 00000000b
-00001111b & 00110001b = 00000001b
-00001111b & 00110010b = 00000010b
-00001111b & 00110011b = 00000011b
-00001111b & 00110100b = 00000100b
-00001111b & 00110101b = 00000101b
-00001111b & 00110110b = 00000110b
-00001111b & 00110111b = 00000111b
-00001111b & 00111000b = 00001000b
-00001111b & 00111001b = 00001001b
-00001111b & 00111010b = 00001010b
-00001111b & 00111011b = 00001011b
-00001111b & 00111100b = 00001100b
-00001111b & 00111101b = 00001101b
-00001111b & 00111110b = 00001110b
-00001111b & 00111111b = 00001111b
-00001111b & 01000000b = 00000000b
-00001111b & 01000001b = 00000001b
-00001111b & 01000010b = 00000010b
-00001111b & 01000011b = 00000011b
-00001111b & 01000100b = 00000100b
-00001111b & 01000101b = 00000101b
-00001111b & 01000110b = 00000110b
-00001111b & 01000111b = 00000111b
-00001111b & 01001000b = 00001000b
-00001111b & 01001001b = 00001001b
-00001111b & 01001010b = 00001010b
-00001111b & 01001011b = 00001011b
-00001111b & 01001100b = 00001100b
-00001111b & 01001101b = 00001101b
-00001111b & 01001110b = 00001110b
-00001111b & 01001111b = 00001111b
-00001111b & 01010000b = 00000000b
-00001111b & 01010001b = 00000001b
-00001111b & 01010010b = 00000010b
-00001111b & 01010011b = 00000011b
-00001111b & 01010100b = 00000100b
-00001111b & 01010101b = 00000101b
-00001111b & 01010110b = 00000110b
-00001111b & 01010111b = 00000111b
-00001111b & 01011000b = 00001000b
-00001111b & 01011001b = 00001001b
-00001111b & 01011010b = 00001010b
-00001111b & 01011011b = 00001011b
-00001111b & 01011100b = 00001100b
-00001111b & 01011101b = 00001101b
-00001111b & 01011110b = 00001110b
-00001111b & 01011111b = 00001111b
-00001111b & 01100000b = 00000000b
-00001111b & 01100001b = 00000001b
-00001111b & 01100010b = 00000010b
-00001111b & 01100011b = 00000011b
-00001111b & 01100100b = 00000100b
-00001111b & 01100101b = 00000101b
-00001111b & 01100110b = 00000110b
-00001111b & 01100111b = 00000111b
-00001111b & 01101000b = 00001000b
-00001111b & 01101001b = 00001001b
-00001111b & 01101010b = 00001010b
-00001111b & 01101011b = 00001011b
-00001111b & 01101100b = 00001100b
-00001111b & 01101101b = 00001101b
-00001111b & 01101110b = 00001110b
-00001111b & 01101111b = 00001111b
-00001111b & 01110000b = 00000000b
-00001111b & 01110001b = 00000001b
-00001111b & 01110010b = 00000010b
-00001111b & 01110011b = 00000011b
-00001111b & 01110100b = 00000100b
-00001111b & 01110101b = 00000101b
-00001111b & 01110110b = 00000110b
-00001111b & 01110111b = 00000111b
-00001111b & 01111000b = 00001000b
-00001111b & 01111001b = 00001001b
-00001111b & 01111010b = 00001010b
-00001111b & 01111011b = 00001011b
-00001111b & 01111100b = 00001100b
-00001111b & 01111101b = 00001101b
-00001111b & 01111110b = 00001110b
-00010000b & 10000000b = 00000000b
-00010000b & 10000001b = 00000000b
-00010000b & 10000010b = 00000000b
-00010000b & 10000011b = 00000000b
-00010000b & 10000100b = 00000000b
-00010000b & 10000101b = 00000000b
-00010000b & 10000110b = 00000000b
-00010000b & 10000111b = 00000000b
-00010000b & 10001000b = 00000000b
-00010000b & 10001001b = 00000000b
-00010000b & 10001010b = 00000000b
-00010000b & 10001011b = 00000000b
-00010000b & 10001100b = 00000000b
-00010000b & 10001101b = 00000000b
-00010000b & 10001110b = 00000000b
-00010000b & 10001111b = 00000000b
-00010000b & 10010000b = 00010000b
-00010000b & 10010001b = 00010000b
-00010000b & 10010010b = 00010000b
-00010000b & 10010011b = 00010000b
-00010000b & 10010100b = 00010000b
-00010000b & 10010101b = 00010000b
-00010000b & 10010110b = 00010000b
-00010000b & 10010111b = 00010000b
-00010000b & 10011000b = 00010000b
-00010000b & 10011001b = 00010000b
-00010000b & 10011010b = 00010000b
-00010000b & 10011011b = 00010000b
-00010000b & 10011100b = 00010000b
-00010000b & 10011101b = 00010000b
-00010000b & 10011110b = 00010000b
-00010000b & 10011111b = 00010000b
-00010000b & 10100000b = 00000000b
-00010000b & 10100001b = 00000000b
-00010000b & 10100010b = 00000000b
-00010000b & 10100011b = 00000000b
-00010000b & 10100100b = 00000000b
-00010000b & 10100101b = 00000000b
-00010000b & 10100110b = 00000000b
-00010000b & 10100111b = 00000000b
-00010000b & 10101000b = 00000000b
-00010000b & 10101001b = 00000000b
-00010000b & 10101010b = 00000000b
-00010000b & 10101011b = 00000000b
-00010000b & 10101100b = 00000000b
-00010000b & 10101101b = 00000000b
-00010000b & 10101110b = 00000000b
-00010000b & 10101111b = 00000000b
-00010000b & 10110000b = 00010000b
-00010000b & 10110001b = 00010000b
-00010000b & 10110010b = 00010000b
-00010000b & 10110011b = 00010000b
-00010000b & 10110100b = 00010000b
-00010000b & 10110101b = 00010000b
-00010000b & 10110110b = 00010000b
-00010000b & 10110111b = 00010000b
-00010000b & 10111000b = 00010000b
-00010000b & 10111001b = 00010000b
-00010000b & 10111010b = 00010000b
-00010000b & 10111011b = 00010000b
-00010000b & 10111100b = 00010000b
-00010000b & 10111101b = 00010000b
-00010000b & 10111110b = 00010000b
-00010000b & 10111111b = 00010000b
-00010000b & 11000000b = 00000000b
-00010000b & 11000001b = 00000000b
-00010000b & 11000010b = 00000000b
-00010000b & 11000011b = 00000000b
-00010000b & 11000100b = 00000000b
-00010000b & 11000101b = 00000000b
-00010000b & 11000110b = 00000000b
-00010000b & 11000111b = 00000000b
-00010000b & 11001000b = 00000000b
-00010000b & 11001001b = 00000000b
-00010000b & 11001010b = 00000000b
-00010000b & 11001011b = 00000000b
-00010000b & 11001100b = 00000000b
-00010000b & 11001101b = 00000000b
-00010000b & 11001110b = 00000000b
-00010000b & 11001111b = 00000000b
-00010000b & 11010000b = 00010000b
-00010000b & 11010001b = 00010000b
-00010000b & 11010010b = 00010000b
-00010000b & 11010011b = 00010000b
-00010000b & 11010100b = 00010000b
-00010000b & 11010101b = 00010000b
-00010000b & 11010110b = 00010000b
-00010000b & 11010111b = 00010000b
-00010000b & 11011000b = 00010000b
-00010000b & 11011001b = 00010000b
-00010000b & 11011010b = 00010000b
-00010000b & 11011011b = 00010000b
-00010000b & 11011100b = 00010000b
-00010000b & 11011101b = 00010000b
-00010000b & 11011110b = 00010000b
-00010000b & 11011111b = 00010000b
-00010000b & 11100000b = 00000000b
-00010000b & 11100001b = 00000000b
-00010000b & 11100010b = 00000000b
-00010000b & 11100011b = 00000000b
-00010000b & 11100100b = 00000000b
-00010000b & 11100101b = 00000000b
-00010000b & 11100110b = 00000000b
-00010000b & 11100111b = 00000000b
-00010000b & 11101000b = 00000000b
-00010000b & 11101001b = 00000000b
-00010000b & 11101010b = 00000000b
-00010000b & 11101011b = 00000000b
-00010000b & 11101100b = 00000000b
-00010000b & 11101101b = 00000000b
-00010000b & 11101110b = 00000000b
-00010000b & 11101111b = 00000000b
-00010000b & 11110000b = 00010000b
-00010000b & 11110001b = 00010000b
-00010000b & 11110010b = 00010000b
-00010000b & 11110011b = 00010000b
-00010000b & 11110100b = 00010000b
-00010000b & 11110101b = 00010000b
-00010000b & 11110110b = 00010000b
-00010000b & 11110111b = 00010000b
-00010000b & 11111000b = 00010000b
-00010000b & 11111001b = 00010000b
-00010000b & 11111010b = 00010000b
-00010000b & 11111011b = 00010000b
-00010000b & 11111100b = 00010000b
-00010000b & 11111101b = 00010000b
-00010000b & 11111110b = 00010000b
-00010000b & 11111111b = 00010000b
-00010000b & 00000000b = 00000000b
-00010000b & 00000001b = 00000000b
-00010000b & 00000010b = 00000000b
-00010000b & 00000011b = 00000000b
-00010000b & 00000100b = 00000000b
-00010000b & 00000101b = 00000000b
-00010000b & 00000110b = 00000000b
-00010000b & 00000111b = 00000000b
-00010000b & 00001000b = 00000000b
-00010000b & 00001001b = 00000000b
-00010000b & 00001010b = 00000000b
-00010000b & 00001011b = 00000000b
-00010000b & 00001100b = 00000000b
-00010000b & 00001101b = 00000000b
-00010000b & 00001110b = 00000000b
-00010000b & 00001111b = 00000000b
-00010000b & 00010000b = 00010000b
-00010000b & 00010001b = 00010000b
-00010000b & 00010010b = 00010000b
-00010000b & 00010011b = 00010000b
-00010000b & 00010100b = 00010000b
-00010000b & 00010101b = 00010000b
-00010000b & 00010110b = 00010000b
-00010000b & 00010111b = 00010000b
-00010000b & 00011000b = 00010000b
-00010000b & 00011001b = 00010000b
-00010000b & 00011010b = 00010000b
-00010000b & 00011011b = 00010000b
-00010000b & 00011100b = 00010000b
-00010000b & 00011101b = 00010000b
-00010000b & 00011110b = 00010000b
-00010000b & 00011111b = 00010000b
-00010000b & 00100000b = 00000000b
-00010000b & 00100001b = 00000000b
-00010000b & 00100010b = 00000000b
-00010000b & 00100011b = 00000000b
-00010000b & 00100100b = 00000000b
-00010000b & 00100101b = 00000000b
-00010000b & 00100110b = 00000000b
-00010000b & 00100111b = 00000000b
-00010000b & 00101000b = 00000000b
-00010000b & 00101001b = 00000000b
-00010000b & 00101010b = 00000000b
-00010000b & 00101011b = 00000000b
-00010000b & 00101100b = 00000000b
-00010000b & 00101101b = 00000000b
-00010000b & 00101110b = 00000000b
-00010000b & 00101111b = 00000000b
-00010000b & 00110000b = 00010000b
-00010000b & 00110001b = 00010000b
-00010000b & 00110010b = 00010000b
-00010000b & 00110011b = 00010000b
-00010000b & 00110100b = 00010000b
-00010000b & 00110101b = 00010000b
-00010000b & 00110110b = 00010000b
-00010000b & 00110111b = 00010000b
-00010000b & 00111000b = 00010000b
-00010000b & 00111001b = 00010000b
-00010000b & 00111010b = 00010000b
-00010000b & 00111011b = 00010000b
-00010000b & 00111100b = 00010000b
-00010000b & 00111101b = 00010000b
-00010000b & 00111110b = 00010000b
-00010000b & 00111111b = 00010000b
-00010000b & 01000000b = 00000000b
-00010000b & 01000001b = 00000000b
-00010000b & 01000010b = 00000000b
-00010000b & 01000011b = 00000000b
-00010000b & 01000100b = 00000000b
-00010000b & 01000101b = 00000000b
-00010000b & 01000110b = 00000000b
-00010000b & 01000111b = 00000000b
-00010000b & 01001000b = 00000000b
-00010000b & 01001001b = 00000000b
-00010000b & 01001010b = 00000000b
-00010000b & 01001011b = 00000000b
-00010000b & 01001100b = 00000000b
-00010000b & 01001101b = 00000000b
-00010000b & 01001110b = 00000000b
-00010000b & 01001111b = 00000000b
-00010000b & 01010000b = 00010000b
-00010000b & 01010001b = 00010000b
-00010000b & 01010010b = 00010000b
-00010000b & 01010011b = 00010000b
-00010000b & 01010100b = 00010000b
-00010000b & 01010101b = 00010000b
-00010000b & 01010110b = 00010000b
-00010000b & 01010111b = 00010000b
-00010000b & 01011000b = 00010000b
-00010000b & 01011001b = 00010000b
-00010000b & 01011010b = 00010000b
-00010000b & 01011011b = 00010000b
-00010000b & 01011100b = 00010000b
-00010000b & 01011101b = 00010000b
-00010000b & 01011110b = 00010000b
-00010000b & 01011111b = 00010000b
-00010000b & 01100000b = 00000000b
-00010000b & 01100001b = 00000000b
-00010000b & 01100010b = 00000000b
-00010000b & 01100011b = 00000000b
-00010000b & 01100100b = 00000000b
-00010000b & 01100101b = 00000000b
-00010000b & 01100110b = 00000000b
-00010000b & 01100111b = 00000000b
-00010000b & 01101000b = 00000000b
-00010000b & 01101001b = 00000000b
-00010000b & 01101010b = 00000000b
-00010000b & 01101011b = 00000000b
-00010000b & 01101100b = 00000000b
-00010000b & 01101101b = 00000000b
-00010000b & 01101110b = 00000000b
-00010000b & 01101111b = 00000000b
-00010000b & 01110000b = 00010000b
-00010000b & 01110001b = 00010000b
-00010000b & 01110010b = 00010000b
-00010000b & 01110011b = 00010000b
-00010000b & 01110100b = 00010000b
-00010000b & 01110101b = 00010000b
-00010000b & 01110110b = 00010000b
-00010000b & 01110111b = 00010000b
-00010000b & 01111000b = 00010000b
-00010000b & 01111001b = 00010000b
-00010000b & 01111010b = 00010000b
-00010000b & 01111011b = 00010000b
-00010000b & 01111100b = 00010000b
-00010000b & 01111101b = 00010000b
-00010000b & 01111110b = 00010000b
-00010001b & 10000000b = 00000000b
-00010001b & 10000001b = 00000001b
-00010001b & 10000010b = 00000000b
-00010001b & 10000011b = 00000001b
-00010001b & 10000100b = 00000000b
-00010001b & 10000101b = 00000001b
-00010001b & 10000110b = 00000000b
-00010001b & 10000111b = 00000001b
-00010001b & 10001000b = 00000000b
-00010001b & 10001001b = 00000001b
-00010001b & 10001010b = 00000000b
-00010001b & 10001011b = 00000001b
-00010001b & 10001100b = 00000000b
-00010001b & 10001101b = 00000001b
-00010001b & 10001110b = 00000000b
-00010001b & 10001111b = 00000001b
-00010001b & 10010000b = 00010000b
-00010001b & 10010001b = 00010001b
-00010001b & 10010010b = 00010000b
-00010001b & 10010011b = 00010001b
-00010001b & 10010100b = 00010000b
-00010001b & 10010101b = 00010001b
-00010001b & 10010110b = 00010000b
-00010001b & 10010111b = 00010001b
-00010001b & 10011000b = 00010000b
-00010001b & 10011001b = 00010001b
-00010001b & 10011010b = 00010000b
-00010001b & 10011011b = 00010001b
-00010001b & 10011100b = 00010000b
-00010001b & 10011101b = 00010001b
-00010001b & 10011110b = 00010000b
-00010001b & 10011111b = 00010001b
-00010001b & 10100000b = 00000000b
-00010001b & 10100001b = 00000001b
-00010001b & 10100010b = 00000000b
-00010001b & 10100011b = 00000001b
-00010001b & 10100100b = 00000000b
-00010001b & 10100101b = 00000001b
-00010001b & 10100110b = 00000000b
-00010001b & 10100111b = 00000001b
-00010001b & 10101000b = 00000000b
-00010001b & 10101001b = 00000001b
-00010001b & 10101010b = 00000000b
-00010001b & 10101011b = 00000001b
-00010001b & 10101100b = 00000000b
-00010001b & 10101101b = 00000001b
-00010001b & 10101110b = 00000000b
-00010001b & 10101111b = 00000001b
-00010001b & 10110000b = 00010000b
-00010001b & 10110001b = 00010001b
-00010001b & 10110010b = 00010000b
-00010001b & 10110011b = 00010001b
-00010001b & 10110100b = 00010000b
-00010001b & 10110101b = 00010001b
-00010001b & 10110110b = 00010000b
-00010001b & 10110111b = 00010001b
-00010001b & 10111000b = 00010000b
-00010001b & 10111001b = 00010001b
-00010001b & 10111010b = 00010000b
-00010001b & 10111011b = 00010001b
-00010001b & 10111100b = 00010000b
-00010001b & 10111101b = 00010001b
-00010001b & 10111110b = 00010000b
-00010001b & 10111111b = 00010001b
-00010001b & 11000000b = 00000000b
-00010001b & 11000001b = 00000001b
-00010001b & 11000010b = 00000000b
-00010001b & 11000011b = 00000001b
-00010001b & 11000100b = 00000000b
-00010001b & 11000101b = 00000001b
-00010001b & 11000110b = 00000000b
-00010001b & 11000111b = 00000001b
-00010001b & 11001000b = 00000000b
-00010001b & 11001001b = 00000001b
-00010001b & 11001010b = 00000000b
-00010001b & 11001011b = 00000001b
-00010001b & 11001100b = 00000000b
-00010001b & 11001101b = 00000001b
-00010001b & 11001110b = 00000000b
-00010001b & 11001111b = 00000001b
-00010001b & 11010000b = 00010000b
-00010001b & 11010001b = 00010001b
-00010001b & 11010010b = 00010000b
-00010001b & 11010011b = 00010001b
-00010001b & 11010100b = 00010000b
-00010001b & 11010101b = 00010001b
-00010001b & 11010110b = 00010000b
-00010001b & 11010111b = 00010001b
-00010001b & 11011000b = 00010000b
-00010001b & 11011001b = 00010001b
-00010001b & 11011010b = 00010000b
-00010001b & 11011011b = 00010001b
-00010001b & 11011100b = 00010000b
-00010001b & 11011101b = 00010001b
-00010001b & 11011110b = 00010000b
-00010001b & 11011111b = 00010001b
-00010001b & 11100000b = 00000000b
-00010001b & 11100001b = 00000001b
-00010001b & 11100010b = 00000000b
-00010001b & 11100011b = 00000001b
-00010001b & 11100100b = 00000000b
-00010001b & 11100101b = 00000001b
-00010001b & 11100110b = 00000000b
-00010001b & 11100111b = 00000001b
-00010001b & 11101000b = 00000000b
-00010001b & 11101001b = 00000001b
-00010001b & 11101010b = 00000000b
-00010001b & 11101011b = 00000001b
-00010001b & 11101100b = 00000000b
-00010001b & 11101101b = 00000001b
-00010001b & 11101110b = 00000000b
-00010001b & 11101111b = 00000001b
-00010001b & 11110000b = 00010000b
-00010001b & 11110001b = 00010001b
-00010001b & 11110010b = 00010000b
-00010001b & 11110011b = 00010001b
-00010001b & 11110100b = 00010000b
-00010001b & 11110101b = 00010001b
-00010001b & 11110110b = 00010000b
-00010001b & 11110111b = 00010001b
-00010001b & 11111000b = 00010000b
-00010001b & 11111001b = 00010001b
-00010001b & 11111010b = 00010000b
-00010001b & 11111011b = 00010001b
-00010001b & 11111100b = 00010000b
-00010001b & 11111101b = 00010001b
-00010001b & 11111110b = 00010000b
-00010001b & 11111111b = 00010001b
-00010001b & 00000000b = 00000000b
-00010001b & 00000001b = 00000001b
-00010001b & 00000010b = 00000000b
-00010001b & 00000011b = 00000001b
-00010001b & 00000100b = 00000000b
-00010001b & 00000101b = 00000001b
-00010001b & 00000110b = 00000000b
-00010001b & 00000111b = 00000001b
-00010001b & 00001000b = 00000000b
-00010001b & 00001001b = 00000001b
-00010001b & 00001010b = 00000000b
-00010001b & 00001011b = 00000001b
-00010001b & 00001100b = 00000000b
-00010001b & 00001101b = 00000001b
-00010001b & 00001110b = 00000000b
-00010001b & 00001111b = 00000001b
-00010001b & 00010000b = 00010000b
-00010001b & 00010001b = 00010001b
-00010001b & 00010010b = 00010000b
-00010001b & 00010011b = 00010001b
-00010001b & 00010100b = 00010000b
-00010001b & 00010101b = 00010001b
-00010001b & 00010110b = 00010000b
-00010001b & 00010111b = 00010001b
-00010001b & 00011000b = 00010000b
-00010001b & 00011001b = 00010001b
-00010001b & 00011010b = 00010000b
-00010001b & 00011011b = 00010001b
-00010001b & 00011100b = 00010000b
-00010001b & 00011101b = 00010001b
-00010001b & 00011110b = 00010000b
-00010001b & 00011111b = 00010001b
-00010001b & 00100000b = 00000000b
-00010001b & 00100001b = 00000001b
-00010001b & 00100010b = 00000000b
-00010001b & 00100011b = 00000001b
-00010001b & 00100100b = 00000000b
-00010001b & 00100101b = 00000001b
-00010001b & 00100110b = 00000000b
-00010001b & 00100111b = 00000001b
-00010001b & 00101000b = 00000000b
-00010001b & 00101001b = 00000001b
-00010001b & 00101010b = 00000000b
-00010001b & 00101011b = 00000001b
-00010001b & 00101100b = 00000000b
-00010001b & 00101101b = 00000001b
-00010001b & 00101110b = 00000000b
-00010001b & 00101111b = 00000001b
-00010001b & 00110000b = 00010000b
-00010001b & 00110001b = 00010001b
-00010001b & 00110010b = 00010000b
-00010001b & 00110011b = 00010001b
-00010001b & 00110100b = 00010000b
-00010001b & 00110101b = 00010001b
-00010001b & 00110110b = 00010000b
-00010001b & 00110111b = 00010001b
-00010001b & 00111000b = 00010000b
-00010001b & 00111001b = 00010001b
-00010001b & 00111010b = 00010000b
-00010001b & 00111011b = 00010001b
-00010001b & 00111100b = 00010000b
-00010001b & 00111101b = 00010001b
-00010001b & 00111110b = 00010000b
-00010001b & 00111111b = 00010001b
-00010001b & 01000000b = 00000000b
-00010001b & 01000001b = 00000001b
-00010001b & 01000010b = 00000000b
-00010001b & 01000011b = 00000001b
-00010001b & 01000100b = 00000000b
-00010001b & 01000101b = 00000001b
-00010001b & 01000110b = 00000000b
-00010001b & 01000111b = 00000001b
-00010001b & 01001000b = 00000000b
-00010001b & 01001001b = 00000001b
-00010001b & 01001010b = 00000000b
-00010001b & 01001011b = 00000001b
-00010001b & 01001100b = 00000000b
-00010001b & 01001101b = 00000001b
-00010001b & 01001110b = 00000000b
-00010001b & 01001111b = 00000001b
-00010001b & 01010000b = 00010000b
-00010001b & 01010001b = 00010001b
-00010001b & 01010010b = 00010000b
-00010001b & 01010011b = 00010001b
-00010001b & 01010100b = 00010000b
-00010001b & 01010101b = 00010001b
-00010001b & 01010110b = 00010000b
-00010001b & 01010111b = 00010001b
-00010001b & 01011000b = 00010000b
-00010001b & 01011001b = 00010001b
-00010001b & 01011010b = 00010000b
-00010001b & 01011011b = 00010001b
-00010001b & 01011100b = 00010000b
-00010001b & 01011101b = 00010001b
-00010001b & 01011110b = 00010000b
-00010001b & 01011111b = 00010001b
-00010001b & 01100000b = 00000000b
-00010001b & 01100001b = 00000001b
-00010001b & 01100010b = 00000000b
-00010001b & 01100011b = 00000001b
-00010001b & 01100100b = 00000000b
-00010001b & 01100101b = 00000001b
-00010001b & 01100110b = 00000000b
-00010001b & 01100111b = 00000001b
-00010001b & 01101000b = 00000000b
-00010001b & 01101001b = 00000001b
-00010001b & 01101010b = 00000000b
-00010001b & 01101011b = 00000001b
-00010001b & 01101100b = 00000000b
-00010001b & 01101101b = 00000001b
-00010001b & 01101110b = 00000000b
-00010001b & 01101111b = 00000001b
-00010001b & 01110000b = 00010000b
-00010001b & 01110001b = 00010001b
-00010001b & 01110010b = 00010000b
-00010001b & 01110011b = 00010001b
-00010001b & 01110100b = 00010000b
-00010001b & 01110101b = 00010001b
-00010001b & 01110110b = 00010000b
-00010001b & 01110111b = 00010001b
-00010001b & 01111000b = 00010000b
-00010001b & 01111001b = 00010001b
-00010001b & 01111010b = 00010000b
-00010001b & 01111011b = 00010001b
-00010001b & 01111100b = 00010000b
-00010001b & 01111101b = 00010001b
-00010001b & 01111110b = 00010000b
-00010010b & 10000000b = 00000000b
-00010010b & 10000001b = 00000000b
-00010010b & 10000010b = 00000010b
-00010010b & 10000011b = 00000010b
-00010010b & 10000100b = 00000000b
-00010010b & 10000101b = 00000000b
-00010010b & 10000110b = 00000010b
-00010010b & 10000111b = 00000010b
-00010010b & 10001000b = 00000000b
-00010010b & 10001001b = 00000000b
-00010010b & 10001010b = 00000010b
-00010010b & 10001011b = 00000010b
-00010010b & 10001100b = 00000000b
-00010010b & 10001101b = 00000000b
-00010010b & 10001110b = 00000010b
-00010010b & 10001111b = 00000010b
-00010010b & 10010000b = 00010000b
-00010010b & 10010001b = 00010000b
-00010010b & 10010010b = 00010010b
-00010010b & 10010011b = 00010010b
-00010010b & 10010100b = 00010000b
-00010010b & 10010101b = 00010000b
-00010010b & 10010110b = 00010010b
-00010010b & 10010111b = 00010010b
-00010010b & 10011000b = 00010000b
-00010010b & 10011001b = 00010000b
-00010010b & 10011010b = 00010010b
-00010010b & 10011011b = 00010010b
-00010010b & 10011100b = 00010000b
-00010010b & 10011101b = 00010000b
-00010010b & 10011110b = 00010010b
-00010010b & 10011111b = 00010010b
-00010010b & 10100000b = 00000000b
-00010010b & 10100001b = 00000000b
-00010010b & 10100010b = 00000010b
-00010010b & 10100011b = 00000010b
-00010010b & 10100100b = 00000000b
-00010010b & 10100101b = 00000000b
-00010010b & 10100110b = 00000010b
-00010010b & 10100111b = 00000010b
-00010010b & 10101000b = 00000000b
-00010010b & 10101001b = 00000000b
-00010010b & 10101010b = 00000010b
-00010010b & 10101011b = 00000010b
-00010010b & 10101100b = 00000000b
-00010010b & 10101101b = 00000000b
-00010010b & 10101110b = 00000010b
-00010010b & 10101111b = 00000010b
-00010010b & 10110000b = 00010000b
-00010010b & 10110001b = 00010000b
-00010010b & 10110010b = 00010010b
-00010010b & 10110011b = 00010010b
-00010010b & 10110100b = 00010000b
-00010010b & 10110101b = 00010000b
-00010010b & 10110110b = 00010010b
-00010010b & 10110111b = 00010010b
-00010010b & 10111000b = 00010000b
-00010010b & 10111001b = 00010000b
-00010010b & 10111010b = 00010010b
-00010010b & 10111011b = 00010010b
-00010010b & 10111100b = 00010000b
-00010010b & 10111101b = 00010000b
-00010010b & 10111110b = 00010010b
-00010010b & 10111111b = 00010010b
-00010010b & 11000000b = 00000000b
-00010010b & 11000001b = 00000000b
-00010010b & 11000010b = 00000010b
-00010010b & 11000011b = 00000010b
-00010010b & 11000100b = 00000000b
-00010010b & 11000101b = 00000000b
-00010010b & 11000110b = 00000010b
-00010010b & 11000111b = 00000010b
-00010010b & 11001000b = 00000000b
-00010010b & 11001001b = 00000000b
-00010010b & 11001010b = 00000010b
-00010010b & 11001011b = 00000010b
-00010010b & 11001100b = 00000000b
-00010010b & 11001101b = 00000000b
-00010010b & 11001110b = 00000010b
-00010010b & 11001111b = 00000010b
-00010010b & 11010000b = 00010000b
-00010010b & 11010001b = 00010000b
-00010010b & 11010010b = 00010010b
-00010010b & 11010011b = 00010010b
-00010010b & 11010100b = 00010000b
-00010010b & 11010101b = 00010000b
-00010010b & 11010110b = 00010010b
-00010010b & 11010111b = 00010010b
-00010010b & 11011000b = 00010000b
-00010010b & 11011001b = 00010000b
-00010010b & 11011010b = 00010010b
-00010010b & 11011011b = 00010010b
-00010010b & 11011100b = 00010000b
-00010010b & 11011101b = 00010000b
-00010010b & 11011110b = 00010010b
-00010010b & 11011111b = 00010010b
-00010010b & 11100000b = 00000000b
-00010010b & 11100001b = 00000000b
-00010010b & 11100010b = 00000010b
-00010010b & 11100011b = 00000010b
-00010010b & 11100100b = 00000000b
-00010010b & 11100101b = 00000000b
-00010010b & 11100110b = 00000010b
-00010010b & 11100111b = 00000010b
-00010010b & 11101000b = 00000000b
-00010010b & 11101001b = 00000000b
-00010010b & 11101010b = 00000010b
-00010010b & 11101011b = 00000010b
-00010010b & 11101100b = 00000000b
-00010010b & 11101101b = 00000000b
-00010010b & 11101110b = 00000010b
-00010010b & 11101111b = 00000010b
-00010010b & 11110000b = 00010000b
-00010010b & 11110001b = 00010000b
-00010010b & 11110010b = 00010010b
-00010010b & 11110011b = 00010010b
-00010010b & 11110100b = 00010000b
-00010010b & 11110101b = 00010000b
-00010010b & 11110110b = 00010010b
-00010010b & 11110111b = 00010010b
-00010010b & 11111000b = 00010000b
-00010010b & 11111001b = 00010000b
-00010010b & 11111010b = 00010010b
-00010010b & 11111011b = 00010010b
-00010010b & 11111100b = 00010000b
-00010010b & 11111101b = 00010000b
-00010010b & 11111110b = 00010010b
-00010010b & 11111111b = 00010010b
-00010010b & 00000000b = 00000000b
-00010010b & 00000001b = 00000000b
-00010010b & 00000010b = 00000010b
-00010010b & 00000011b = 00000010b
-00010010b & 00000100b = 00000000b
-00010010b & 00000101b = 00000000b
-00010010b & 00000110b = 00000010b
-00010010b & 00000111b = 00000010b
-00010010b & 00001000b = 00000000b
-00010010b & 00001001b = 00000000b
-00010010b & 00001010b = 00000010b
-00010010b & 00001011b = 00000010b
-00010010b & 00001100b = 00000000b
-00010010b & 00001101b = 00000000b
-00010010b & 00001110b = 00000010b
-00010010b & 00001111b = 00000010b
-00010010b & 00010000b = 00010000b
-00010010b & 00010001b = 00010000b
-00010010b & 00010010b = 00010010b
-00010010b & 00010011b = 00010010b
-00010010b & 00010100b = 00010000b
-00010010b & 00010101b = 00010000b
-00010010b & 00010110b = 00010010b
-00010010b & 00010111b = 00010010b
-00010010b & 00011000b = 00010000b
-00010010b & 00011001b = 00010000b
-00010010b & 00011010b = 00010010b
-00010010b & 00011011b = 00010010b
-00010010b & 00011100b = 00010000b
-00010010b & 00011101b = 00010000b
-00010010b & 00011110b = 00010010b
-00010010b & 00011111b = 00010010b
-00010010b & 00100000b = 00000000b
-00010010b & 00100001b = 00000000b
-00010010b & 00100010b = 00000010b
-00010010b & 00100011b = 00000010b
-00010010b & 00100100b = 00000000b
-00010010b & 00100101b = 00000000b
-00010010b & 00100110b = 00000010b
-00010010b & 00100111b = 00000010b
-00010010b & 00101000b = 00000000b
-00010010b & 00101001b = 00000000b
-00010010b & 00101010b = 00000010b
-00010010b & 00101011b = 00000010b
-00010010b & 00101100b = 00000000b
-00010010b & 00101101b = 00000000b
-00010010b & 00101110b = 00000010b
-00010010b & 00101111b = 00000010b
-00010010b & 00110000b = 00010000b
-00010010b & 00110001b = 00010000b
-00010010b & 00110010b = 00010010b
-00010010b & 00110011b = 00010010b
-00010010b & 00110100b = 00010000b
-00010010b & 00110101b = 00010000b
-00010010b & 00110110b = 00010010b
-00010010b & 00110111b = 00010010b
-00010010b & 00111000b = 00010000b
-00010010b & 00111001b = 00010000b
-00010010b & 00111010b = 00010010b
-00010010b & 00111011b = 00010010b
-00010010b & 00111100b = 00010000b
-00010010b & 00111101b = 00010000b
-00010010b & 00111110b = 00010010b
-00010010b & 00111111b = 00010010b
-00010010b & 01000000b = 00000000b
-00010010b & 01000001b = 00000000b
-00010010b & 01000010b = 00000010b
-00010010b & 01000011b = 00000010b
-00010010b & 01000100b = 00000000b
-00010010b & 01000101b = 00000000b
-00010010b & 01000110b = 00000010b
-00010010b & 01000111b = 00000010b
-00010010b & 01001000b = 00000000b
-00010010b & 01001001b = 00000000b
-00010010b & 01001010b = 00000010b
-00010010b & 01001011b = 00000010b
-00010010b & 01001100b = 00000000b
-00010010b & 01001101b = 00000000b
-00010010b & 01001110b = 00000010b
-00010010b & 01001111b = 00000010b
-00010010b & 01010000b = 00010000b
-00010010b & 01010001b = 00010000b
-00010010b & 01010010b = 00010010b
-00010010b & 01010011b = 00010010b
-00010010b & 01010100b = 00010000b
-00010010b & 01010101b = 00010000b
-00010010b & 01010110b = 00010010b
-00010010b & 01010111b = 00010010b
-00010010b & 01011000b = 00010000b
-00010010b & 01011001b = 00010000b
-00010010b & 01011010b = 00010010b
-00010010b & 01011011b = 00010010b
-00010010b & 01011100b = 00010000b
-00010010b & 01011101b = 00010000b
-00010010b & 01011110b = 00010010b
-00010010b & 01011111b = 00010010b
-00010010b & 01100000b = 00000000b
-00010010b & 01100001b = 00000000b
-00010010b & 01100010b = 00000010b
-00010010b & 01100011b = 00000010b
-00010010b & 01100100b = 00000000b
-00010010b & 01100101b = 00000000b
-00010010b & 01100110b = 00000010b
-00010010b & 01100111b = 00000010b
-00010010b & 01101000b = 00000000b
-00010010b & 01101001b = 00000000b
-00010010b & 01101010b = 00000010b
-00010010b & 01101011b = 00000010b
-00010010b & 01101100b = 00000000b
-00010010b & 01101101b = 00000000b
-00010010b & 01101110b = 00000010b
-00010010b & 01101111b = 00000010b
-00010010b & 01110000b = 00010000b
-00010010b & 01110001b = 00010000b
-00010010b & 01110010b = 00010010b
-00010010b & 01110011b = 00010010b
-00010010b & 01110100b = 00010000b
-00010010b & 01110101b = 00010000b
-00010010b & 01110110b = 00010010b
-00010010b & 01110111b = 00010010b
-00010010b & 01111000b = 00010000b
-00010010b & 01111001b = 00010000b
-00010010b & 01111010b = 00010010b
-00010010b & 01111011b = 00010010b
-00010010b & 01111100b = 00010000b
-00010010b & 01111101b = 00010000b
-00010010b & 01111110b = 00010010b
-00010011b & 10000000b = 00000000b
-00010011b & 10000001b = 00000001b
-00010011b & 10000010b = 00000010b
-00010011b & 10000011b = 00000011b
-00010011b & 10000100b = 00000000b
-00010011b & 10000101b = 00000001b
-00010011b & 10000110b = 00000010b
-00010011b & 10000111b = 00000011b
-00010011b & 10001000b = 00000000b
-00010011b & 10001001b = 00000001b
-00010011b & 10001010b = 00000010b
-00010011b & 10001011b = 00000011b
-00010011b & 10001100b = 00000000b
-00010011b & 10001101b = 00000001b
-00010011b & 10001110b = 00000010b
-00010011b & 10001111b = 00000011b
-00010011b & 10010000b = 00010000b
-00010011b & 10010001b = 00010001b
-00010011b & 10010010b = 00010010b
-00010011b & 10010011b = 00010011b
-00010011b & 10010100b = 00010000b
-00010011b & 10010101b = 00010001b
-00010011b & 10010110b = 00010010b
-00010011b & 10010111b = 00010011b
-00010011b & 10011000b = 00010000b
-00010011b & 10011001b = 00010001b
-00010011b & 10011010b = 00010010b
-00010011b & 10011011b = 00010011b
-00010011b & 10011100b = 00010000b
-00010011b & 10011101b = 00010001b
-00010011b & 10011110b = 00010010b
-00010011b & 10011111b = 00010011b
-00010011b & 10100000b = 00000000b
-00010011b & 10100001b = 00000001b
-00010011b & 10100010b = 00000010b
-00010011b & 10100011b = 00000011b
-00010011b & 10100100b = 00000000b
-00010011b & 10100101b = 00000001b
-00010011b & 10100110b = 00000010b
-00010011b & 10100111b = 00000011b
-00010011b & 10101000b = 00000000b
-00010011b & 10101001b = 00000001b
-00010011b & 10101010b = 00000010b
-00010011b & 10101011b = 00000011b
-00010011b & 10101100b = 00000000b
-00010011b & 10101101b = 00000001b
-00010011b & 10101110b = 00000010b
-00010011b & 10101111b = 00000011b
-00010011b & 10110000b = 00010000b
-00010011b & 10110001b = 00010001b
-00010011b & 10110010b = 00010010b
-00010011b & 10110011b = 00010011b
-00010011b & 10110100b = 00010000b
-00010011b & 10110101b = 00010001b
-00010011b & 10110110b = 00010010b
-00010011b & 10110111b = 00010011b
-00010011b & 10111000b = 00010000b
-00010011b & 10111001b = 00010001b
-00010011b & 10111010b = 00010010b
-00010011b & 10111011b = 00010011b
-00010011b & 10111100b = 00010000b
-00010011b & 10111101b = 00010001b
-00010011b & 10111110b = 00010010b
-00010011b & 10111111b = 00010011b
-00010011b & 11000000b = 00000000b
-00010011b & 11000001b = 00000001b
-00010011b & 11000010b = 00000010b
-00010011b & 11000011b = 00000011b
-00010011b & 11000100b = 00000000b
-00010011b & 11000101b = 00000001b
-00010011b & 11000110b = 00000010b
-00010011b & 11000111b = 00000011b
-00010011b & 11001000b = 00000000b
-00010011b & 11001001b = 00000001b
-00010011b & 11001010b = 00000010b
-00010011b & 11001011b = 00000011b
-00010011b & 11001100b = 00000000b
-00010011b & 11001101b = 00000001b
-00010011b & 11001110b = 00000010b
-00010011b & 11001111b = 00000011b
-00010011b & 11010000b = 00010000b
-00010011b & 11010001b = 00010001b
-00010011b & 11010010b = 00010010b
-00010011b & 11010011b = 00010011b
-00010011b & 11010100b = 00010000b
-00010011b & 11010101b = 00010001b
-00010011b & 11010110b = 00010010b
-00010011b & 11010111b = 00010011b
-00010011b & 11011000b = 00010000b
-00010011b & 11011001b = 00010001b
-00010011b & 11011010b = 00010010b
-00010011b & 11011011b = 00010011b
-00010011b & 11011100b = 00010000b
-00010011b & 11011101b = 00010001b
-00010011b & 11011110b = 00010010b
-00010011b & 11011111b = 00010011b
-00010011b & 11100000b = 00000000b
-00010011b & 11100001b = 00000001b
-00010011b & 11100010b = 00000010b
-00010011b & 11100011b = 00000011b
-00010011b & 11100100b = 00000000b
-00010011b & 11100101b = 00000001b
-00010011b & 11100110b = 00000010b
-00010011b & 11100111b = 00000011b
-00010011b & 11101000b = 00000000b
-00010011b & 11101001b = 00000001b
-00010011b & 11101010b = 00000010b
-00010011b & 11101011b = 00000011b
-00010011b & 11101100b = 00000000b
-00010011b & 11101101b = 00000001b
-00010011b & 11101110b = 00000010b
-00010011b & 11101111b = 00000011b
-00010011b & 11110000b = 00010000b
-00010011b & 11110001b = 00010001b
-00010011b & 11110010b = 00010010b
-00010011b & 11110011b = 00010011b
-00010011b & 11110100b = 00010000b
-00010011b & 11110101b = 00010001b
-00010011b & 11110110b = 00010010b
-00010011b & 11110111b = 00010011b
-00010011b & 11111000b = 00010000b
-00010011b & 11111001b = 00010001b
-00010011b & 11111010b = 00010010b
-00010011b & 11111011b = 00010011b
-00010011b & 11111100b = 00010000b
-00010011b & 11111101b = 00010001b
-00010011b & 11111110b = 00010010b
-00010011b & 11111111b = 00010011b
-00010011b & 00000000b = 00000000b
-00010011b & 00000001b = 00000001b
-00010011b & 00000010b = 00000010b
-00010011b & 00000011b = 00000011b
-00010011b & 00000100b = 00000000b
-00010011b & 00000101b = 00000001b
-00010011b & 00000110b = 00000010b
-00010011b & 00000111b = 00000011b
-00010011b & 00001000b = 00000000b
-00010011b & 00001001b = 00000001b
-00010011b & 00001010b = 00000010b
-00010011b & 00001011b = 00000011b
-00010011b & 00001100b = 00000000b
-00010011b & 00001101b = 00000001b
-00010011b & 00001110b = 00000010b
-00010011b & 00001111b = 00000011b
-00010011b & 00010000b = 00010000b
-00010011b & 00010001b = 00010001b
-00010011b & 00010010b = 00010010b
-00010011b & 00010011b = 00010011b
-00010011b & 00010100b = 00010000b
-00010011b & 00010101b = 00010001b
-00010011b & 00010110b = 00010010b
-00010011b & 00010111b = 00010011b
-00010011b & 00011000b = 00010000b
-00010011b & 00011001b = 00010001b
-00010011b & 00011010b = 00010010b
-00010011b & 00011011b = 00010011b
-00010011b & 00011100b = 00010000b
-00010011b & 00011101b = 00010001b
-00010011b & 00011110b = 00010010b
-00010011b & 00011111b = 00010011b
-00010011b & 00100000b = 00000000b
-00010011b & 00100001b = 00000001b
-00010011b & 00100010b = 00000010b
-00010011b & 00100011b = 00000011b
-00010011b & 00100100b = 00000000b
-00010011b & 00100101b = 00000001b
-00010011b & 00100110b = 00000010b
-00010011b & 00100111b = 00000011b
-00010011b & 00101000b = 00000000b
-00010011b & 00101001b = 00000001b
-00010011b & 00101010b = 00000010b
-00010011b & 00101011b = 00000011b
-00010011b & 00101100b = 00000000b
-00010011b & 00101101b = 00000001b
-00010011b & 00101110b = 00000010b
-00010011b & 00101111b = 00000011b
-00010011b & 00110000b = 00010000b
-00010011b & 00110001b = 00010001b
-00010011b & 00110010b = 00010010b
-00010011b & 00110011b = 00010011b
-00010011b & 00110100b = 00010000b
-00010011b & 00110101b = 00010001b
-00010011b & 00110110b = 00010010b
-00010011b & 00110111b = 00010011b
-00010011b & 00111000b = 00010000b
-00010011b & 00111001b = 00010001b
-00010011b & 00111010b = 00010010b
-00010011b & 00111011b = 00010011b
-00010011b & 00111100b = 00010000b
-00010011b & 00111101b = 00010001b
-00010011b & 00111110b = 00010010b
-00010011b & 00111111b = 00010011b
-00010011b & 01000000b = 00000000b
-00010011b & 01000001b = 00000001b
-00010011b & 01000010b = 00000010b
-00010011b & 01000011b = 00000011b
-00010011b & 01000100b = 00000000b
-00010011b & 01000101b = 00000001b
-00010011b & 01000110b = 00000010b
-00010011b & 01000111b = 00000011b
-00010011b & 01001000b = 00000000b
-00010011b & 01001001b = 00000001b
-00010011b & 01001010b = 00000010b
-00010011b & 01001011b = 00000011b
-00010011b & 01001100b = 00000000b
-00010011b & 01001101b = 00000001b
-00010011b & 01001110b = 00000010b
-00010011b & 01001111b = 00000011b
-00010011b & 01010000b = 00010000b
-00010011b & 01010001b = 00010001b
-00010011b & 01010010b = 00010010b
-00010011b & 01010011b = 00010011b
-00010011b & 01010100b = 00010000b
-00010011b & 01010101b = 00010001b
-00010011b & 01010110b = 00010010b
-00010011b & 01010111b = 00010011b
-00010011b & 01011000b = 00010000b
-00010011b & 01011001b = 00010001b
-00010011b & 01011010b = 00010010b
-00010011b & 01011011b = 00010011b
-00010011b & 01011100b = 00010000b
-00010011b & 01011101b = 00010001b
-00010011b & 01011110b = 00010010b
-00010011b & 01011111b = 00010011b
-00010011b & 01100000b = 00000000b
-00010011b & 01100001b = 00000001b
-00010011b & 01100010b = 00000010b
-00010011b & 01100011b = 00000011b
-00010011b & 01100100b = 00000000b
-00010011b & 01100101b = 00000001b
-00010011b & 01100110b = 00000010b
-00010011b & 01100111b = 00000011b
-00010011b & 01101000b = 00000000b
-00010011b & 01101001b = 00000001b
-00010011b & 01101010b = 00000010b
-00010011b & 01101011b = 00000011b
-00010011b & 01101100b = 00000000b
-00010011b & 01101101b = 00000001b
-00010011b & 01101110b = 00000010b
-00010011b & 01101111b = 00000011b
-00010011b & 01110000b = 00010000b
-00010011b & 01110001b = 00010001b
-00010011b & 01110010b = 00010010b
-00010011b & 01110011b = 00010011b
-00010011b & 01110100b = 00010000b
-00010011b & 01110101b = 00010001b
-00010011b & 01110110b = 00010010b
-00010011b & 01110111b = 00010011b
-00010011b & 01111000b = 00010000b
-00010011b & 01111001b = 00010001b
-00010011b & 01111010b = 00010010b
-00010011b & 01111011b = 00010011b
-00010011b & 01111100b = 00010000b
-00010011b & 01111101b = 00010001b
-00010011b & 01111110b = 00010010b
-00010100b & 10000000b = 00000000b
-00010100b & 10000001b = 00000000b
-00010100b & 10000010b = 00000000b
-00010100b & 10000011b = 00000000b
-00010100b & 10000100b = 00000100b
-00010100b & 10000101b = 00000100b
-00010100b & 10000110b = 00000100b
-00010100b & 10000111b = 00000100b
-00010100b & 10001000b = 00000000b
-00010100b & 10001001b = 00000000b
-00010100b & 10001010b = 00000000b
-00010100b & 10001011b = 00000000b
-00010100b & 10001100b = 00000100b
-00010100b & 10001101b = 00000100b
-00010100b & 10001110b = 00000100b
-00010100b & 10001111b = 00000100b
-00010100b & 10010000b = 00010000b
-00010100b & 10010001b = 00010000b
-00010100b & 10010010b = 00010000b
-00010100b & 10010011b = 00010000b
-00010100b & 10010100b = 00010100b
-00010100b & 10010101b = 00010100b
-00010100b & 10010110b = 00010100b
-00010100b & 10010111b = 00010100b
-00010100b & 10011000b = 00010000b
-00010100b & 10011001b = 00010000b
-00010100b & 10011010b = 00010000b
-00010100b & 10011011b = 00010000b
-00010100b & 10011100b = 00010100b
-00010100b & 10011101b = 00010100b
-00010100b & 10011110b = 00010100b
-00010100b & 10011111b = 00010100b
-00010100b & 10100000b = 00000000b
-00010100b & 10100001b = 00000000b
-00010100b & 10100010b = 00000000b
-00010100b & 10100011b = 00000000b
-00010100b & 10100100b = 00000100b
-00010100b & 10100101b = 00000100b
-00010100b & 10100110b = 00000100b
-00010100b & 10100111b = 00000100b
-00010100b & 10101000b = 00000000b
-00010100b & 10101001b = 00000000b
-00010100b & 10101010b = 00000000b
-00010100b & 10101011b = 00000000b
-00010100b & 10101100b = 00000100b
-00010100b & 10101101b = 00000100b
-00010100b & 10101110b = 00000100b
-00010100b & 10101111b = 00000100b
-00010100b & 10110000b = 00010000b
-00010100b & 10110001b = 00010000b
-00010100b & 10110010b = 00010000b
-00010100b & 10110011b = 00010000b
-00010100b & 10110100b = 00010100b
-00010100b & 10110101b = 00010100b
-00010100b & 10110110b = 00010100b
-00010100b & 10110111b = 00010100b
-00010100b & 10111000b = 00010000b
-00010100b & 10111001b = 00010000b
-00010100b & 10111010b = 00010000b
-00010100b & 10111011b = 00010000b
-00010100b & 10111100b = 00010100b
-00010100b & 10111101b = 00010100b
-00010100b & 10111110b = 00010100b
-00010100b & 10111111b = 00010100b
-00010100b & 11000000b = 00000000b
-00010100b & 11000001b = 00000000b
-00010100b & 11000010b = 00000000b
-00010100b & 11000011b = 00000000b
-00010100b & 11000100b = 00000100b
-00010100b & 11000101b = 00000100b
-00010100b & 11000110b = 00000100b
-00010100b & 11000111b = 00000100b
-00010100b & 11001000b = 00000000b
-00010100b & 11001001b = 00000000b
-00010100b & 11001010b = 00000000b
-00010100b & 11001011b = 00000000b
-00010100b & 11001100b = 00000100b
-00010100b & 11001101b = 00000100b
-00010100b & 11001110b = 00000100b
-00010100b & 11001111b = 00000100b
-00010100b & 11010000b = 00010000b
-00010100b & 11010001b = 00010000b
-00010100b & 11010010b = 00010000b
-00010100b & 11010011b = 00010000b
-00010100b & 11010100b = 00010100b
-00010100b & 11010101b = 00010100b
-00010100b & 11010110b = 00010100b
-00010100b & 11010111b = 00010100b
-00010100b & 11011000b = 00010000b
-00010100b & 11011001b = 00010000b
-00010100b & 11011010b = 00010000b
-00010100b & 11011011b = 00010000b
-00010100b & 11011100b = 00010100b
-00010100b & 11011101b = 00010100b
-00010100b & 11011110b = 00010100b
-00010100b & 11011111b = 00010100b
-00010100b & 11100000b = 00000000b
-00010100b & 11100001b = 00000000b
-00010100b & 11100010b = 00000000b
-00010100b & 11100011b = 00000000b
-00010100b & 11100100b = 00000100b
-00010100b & 11100101b = 00000100b
-00010100b & 11100110b = 00000100b
-00010100b & 11100111b = 00000100b
-00010100b & 11101000b = 00000000b
-00010100b & 11101001b = 00000000b
-00010100b & 11101010b = 00000000b
-00010100b & 11101011b = 00000000b
-00010100b & 11101100b = 00000100b
-00010100b & 11101101b = 00000100b
-00010100b & 11101110b = 00000100b
-00010100b & 11101111b = 00000100b
-00010100b & 11110000b = 00010000b
-00010100b & 11110001b = 00010000b
-00010100b & 11110010b = 00010000b
-00010100b & 11110011b = 00010000b
-00010100b & 11110100b = 00010100b
-00010100b & 11110101b = 00010100b
-00010100b & 11110110b = 00010100b
-00010100b & 11110111b = 00010100b
-00010100b & 11111000b = 00010000b
-00010100b & 11111001b = 00010000b
-00010100b & 11111010b = 00010000b
-00010100b & 11111011b = 00010000b
-00010100b & 11111100b = 00010100b
-00010100b & 11111101b = 00010100b
-00010100b & 11111110b = 00010100b
-00010100b & 11111111b = 00010100b
-00010100b & 00000000b = 00000000b
-00010100b & 00000001b = 00000000b
-00010100b & 00000010b = 00000000b
-00010100b & 00000011b = 00000000b
-00010100b & 00000100b = 00000100b
-00010100b & 00000101b = 00000100b
-00010100b & 00000110b = 00000100b
-00010100b & 00000111b = 00000100b
-00010100b & 00001000b = 00000000b
-00010100b & 00001001b = 00000000b
-00010100b & 00001010b = 00000000b
-00010100b & 00001011b = 00000000b
-00010100b & 00001100b = 00000100b
-00010100b & 00001101b = 00000100b
-00010100b & 00001110b = 00000100b
-00010100b & 00001111b = 00000100b
-00010100b & 00010000b = 00010000b
-00010100b & 00010001b = 00010000b
-00010100b & 00010010b = 00010000b
-00010100b & 00010011b = 00010000b
-00010100b & 00010100b = 00010100b
-00010100b & 00010101b = 00010100b
-00010100b & 00010110b = 00010100b
-00010100b & 00010111b = 00010100b
-00010100b & 00011000b = 00010000b
-00010100b & 00011001b = 00010000b
-00010100b & 00011010b = 00010000b
-00010100b & 00011011b = 00010000b
-00010100b & 00011100b = 00010100b
-00010100b & 00011101b = 00010100b
-00010100b & 00011110b = 00010100b
-00010100b & 00011111b = 00010100b
-00010100b & 00100000b = 00000000b
-00010100b & 00100001b = 00000000b
-00010100b & 00100010b = 00000000b
-00010100b & 00100011b = 00000000b
-00010100b & 00100100b = 00000100b
-00010100b & 00100101b = 00000100b
-00010100b & 00100110b = 00000100b
-00010100b & 00100111b = 00000100b
-00010100b & 00101000b = 00000000b
-00010100b & 00101001b = 00000000b
-00010100b & 00101010b = 00000000b
-00010100b & 00101011b = 00000000b
-00010100b & 00101100b = 00000100b
-00010100b & 00101101b = 00000100b
-00010100b & 00101110b = 00000100b
-00010100b & 00101111b = 00000100b
-00010100b & 00110000b = 00010000b
-00010100b & 00110001b = 00010000b
-00010100b & 00110010b = 00010000b
-00010100b & 00110011b = 00010000b
-00010100b & 00110100b = 00010100b
-00010100b & 00110101b = 00010100b
-00010100b & 00110110b = 00010100b
-00010100b & 00110111b = 00010100b
-00010100b & 00111000b = 00010000b
-00010100b & 00111001b = 00010000b
-00010100b & 00111010b = 00010000b
-00010100b & 00111011b = 00010000b
-00010100b & 00111100b = 00010100b
-00010100b & 00111101b = 00010100b
-00010100b & 00111110b = 00010100b
-00010100b & 00111111b = 00010100b
-00010100b & 01000000b = 00000000b
-00010100b & 01000001b = 00000000b
-00010100b & 01000010b = 00000000b
-00010100b & 01000011b = 00000000b
-00010100b & 01000100b = 00000100b
-00010100b & 01000101b = 00000100b
-00010100b & 01000110b = 00000100b
-00010100b & 01000111b = 00000100b
-00010100b & 01001000b = 00000000b
-00010100b & 01001001b = 00000000b
-00010100b & 01001010b = 00000000b
-00010100b & 01001011b = 00000000b
-00010100b & 01001100b = 00000100b
-00010100b & 01001101b = 00000100b
-00010100b & 01001110b = 00000100b
-00010100b & 01001111b = 00000100b
-00010100b & 01010000b = 00010000b
-00010100b & 01010001b = 00010000b
-00010100b & 01010010b = 00010000b
-00010100b & 01010011b = 00010000b
-00010100b & 01010100b = 00010100b
-00010100b & 01010101b = 00010100b
-00010100b & 01010110b = 00010100b
-00010100b & 01010111b = 00010100b
-00010100b & 01011000b = 00010000b
-00010100b & 01011001b = 00010000b
-00010100b & 01011010b = 00010000b
-00010100b & 01011011b = 00010000b
-00010100b & 01011100b = 00010100b
-00010100b & 01011101b = 00010100b
-00010100b & 01011110b = 00010100b
-00010100b & 01011111b = 00010100b
-00010100b & 01100000b = 00000000b
-00010100b & 01100001b = 00000000b
-00010100b & 01100010b = 00000000b
-00010100b & 01100011b = 00000000b
-00010100b & 01100100b = 00000100b
-00010100b & 01100101b = 00000100b
-00010100b & 01100110b = 00000100b
-00010100b & 01100111b = 00000100b
-00010100b & 01101000b = 00000000b
-00010100b & 01101001b = 00000000b
-00010100b & 01101010b = 00000000b
-00010100b & 01101011b = 00000000b
-00010100b & 01101100b = 00000100b
-00010100b & 01101101b = 00000100b
-00010100b & 01101110b = 00000100b
-00010100b & 01101111b = 00000100b
-00010100b & 01110000b = 00010000b
-00010100b & 01110001b = 00010000b
-00010100b & 01110010b = 00010000b
-00010100b & 01110011b = 00010000b
-00010100b & 01110100b = 00010100b
-00010100b & 01110101b = 00010100b
-00010100b & 01110110b = 00010100b
-00010100b & 01110111b = 00010100b
-00010100b & 01111000b = 00010000b
-00010100b & 01111001b = 00010000b
-00010100b & 01111010b = 00010000b
-00010100b & 01111011b = 00010000b
-00010100b & 01111100b = 00010100b
-00010100b & 01111101b = 00010100b
-00010100b & 01111110b = 00010100b
-00010101b & 10000000b = 00000000b
-00010101b & 10000001b = 00000001b
-00010101b & 10000010b = 00000000b
-00010101b & 10000011b = 00000001b
-00010101b & 10000100b = 00000100b
-00010101b & 10000101b = 00000101b
-00010101b & 10000110b = 00000100b
-00010101b & 10000111b = 00000101b
-00010101b & 10001000b = 00000000b
-00010101b & 10001001b = 00000001b
-00010101b & 10001010b = 00000000b
-00010101b & 10001011b = 00000001b
-00010101b & 10001100b = 00000100b
-00010101b & 10001101b = 00000101b
-00010101b & 10001110b = 00000100b
-00010101b & 10001111b = 00000101b
-00010101b & 10010000b = 00010000b
-00010101b & 10010001b = 00010001b
-00010101b & 10010010b = 00010000b
-00010101b & 10010011b = 00010001b
-00010101b & 10010100b = 00010100b
-00010101b & 10010101b = 00010101b
-00010101b & 10010110b = 00010100b
-00010101b & 10010111b = 00010101b
-00010101b & 10011000b = 00010000b
-00010101b & 10011001b = 00010001b
-00010101b & 10011010b = 00010000b
-00010101b & 10011011b = 00010001b
-00010101b & 10011100b = 00010100b
-00010101b & 10011101b = 00010101b
-00010101b & 10011110b = 00010100b
-00010101b & 10011111b = 00010101b
-00010101b & 10100000b = 00000000b
-00010101b & 10100001b = 00000001b
-00010101b & 10100010b = 00000000b
-00010101b & 10100011b = 00000001b
-00010101b & 10100100b = 00000100b
-00010101b & 10100101b = 00000101b
-00010101b & 10100110b = 00000100b
-00010101b & 10100111b = 00000101b
-00010101b & 10101000b = 00000000b
-00010101b & 10101001b = 00000001b
-00010101b & 10101010b = 00000000b
-00010101b & 10101011b = 00000001b
-00010101b & 10101100b = 00000100b
-00010101b & 10101101b = 00000101b
-00010101b & 10101110b = 00000100b
-00010101b & 10101111b = 00000101b
-00010101b & 10110000b = 00010000b
-00010101b & 10110001b = 00010001b
-00010101b & 10110010b = 00010000b
-00010101b & 10110011b = 00010001b
-00010101b & 10110100b = 00010100b
-00010101b & 10110101b = 00010101b
-00010101b & 10110110b = 00010100b
-00010101b & 10110111b = 00010101b
-00010101b & 10111000b = 00010000b
-00010101b & 10111001b = 00010001b
-00010101b & 10111010b = 00010000b
-00010101b & 10111011b = 00010001b
-00010101b & 10111100b = 00010100b
-00010101b & 10111101b = 00010101b
-00010101b & 10111110b = 00010100b
-00010101b & 10111111b = 00010101b
-00010101b & 11000000b = 00000000b
-00010101b & 11000001b = 00000001b
-00010101b & 11000010b = 00000000b
-00010101b & 11000011b = 00000001b
-00010101b & 11000100b = 00000100b
-00010101b & 11000101b = 00000101b
-00010101b & 11000110b = 00000100b
-00010101b & 11000111b = 00000101b
-00010101b & 11001000b = 00000000b
-00010101b & 11001001b = 00000001b
-00010101b & 11001010b = 00000000b
-00010101b & 11001011b = 00000001b
-00010101b & 11001100b = 00000100b
-00010101b & 11001101b = 00000101b
-00010101b & 11001110b = 00000100b
-00010101b & 11001111b = 00000101b
-00010101b & 11010000b = 00010000b
-00010101b & 11010001b = 00010001b
-00010101b & 11010010b = 00010000b
-00010101b & 11010011b = 00010001b
-00010101b & 11010100b = 00010100b
-00010101b & 11010101b = 00010101b
-00010101b & 11010110b = 00010100b
-00010101b & 11010111b = 00010101b
-00010101b & 11011000b = 00010000b
-00010101b & 11011001b = 00010001b
-00010101b & 11011010b = 00010000b
-00010101b & 11011011b = 00010001b
-00010101b & 11011100b = 00010100b
-00010101b & 11011101b = 00010101b
-00010101b & 11011110b = 00010100b
-00010101b & 11011111b = 00010101b
-00010101b & 11100000b = 00000000b
-00010101b & 11100001b = 00000001b
-00010101b & 11100010b = 00000000b
-00010101b & 11100011b = 00000001b
-00010101b & 11100100b = 00000100b
-00010101b & 11100101b = 00000101b
-00010101b & 11100110b = 00000100b
-00010101b & 11100111b = 00000101b
-00010101b & 11101000b = 00000000b
-00010101b & 11101001b = 00000001b
-00010101b & 11101010b = 00000000b
-00010101b & 11101011b = 00000001b
-00010101b & 11101100b = 00000100b
-00010101b & 11101101b = 00000101b
-00010101b & 11101110b = 00000100b
-00010101b & 11101111b = 00000101b
-00010101b & 11110000b = 00010000b
-00010101b & 11110001b = 00010001b
-00010101b & 11110010b = 00010000b
-00010101b & 11110011b = 00010001b
-00010101b & 11110100b = 00010100b
-00010101b & 11110101b = 00010101b
-00010101b & 11110110b = 00010100b
-00010101b & 11110111b = 00010101b
-00010101b & 11111000b = 00010000b
-00010101b & 11111001b = 00010001b
-00010101b & 11111010b = 00010000b
-00010101b & 11111011b = 00010001b
-00010101b & 11111100b = 00010100b
-00010101b & 11111101b = 00010101b
-00010101b & 11111110b = 00010100b
-00010101b & 11111111b = 00010101b
-00010101b & 00000000b = 00000000b
-00010101b & 00000001b = 00000001b
-00010101b & 00000010b = 00000000b
-00010101b & 00000011b = 00000001b
-00010101b & 00000100b = 00000100b
-00010101b & 00000101b = 00000101b
-00010101b & 00000110b = 00000100b
-00010101b & 00000111b = 00000101b
-00010101b & 00001000b = 00000000b
-00010101b & 00001001b = 00000001b
-00010101b & 00001010b = 00000000b
-00010101b & 00001011b = 00000001b
-00010101b & 00001100b = 00000100b
-00010101b & 00001101b = 00000101b
-00010101b & 00001110b = 00000100b
-00010101b & 00001111b = 00000101b
-00010101b & 00010000b = 00010000b
-00010101b & 00010001b = 00010001b
-00010101b & 00010010b = 00010000b
-00010101b & 00010011b = 00010001b
-00010101b & 00010100b = 00010100b
-00010101b & 00010101b = 00010101b
-00010101b & 00010110b = 00010100b
-00010101b & 00010111b = 00010101b
-00010101b & 00011000b = 00010000b
-00010101b & 00011001b = 00010001b
-00010101b & 00011010b = 00010000b
-00010101b & 00011011b = 00010001b
-00010101b & 00011100b = 00010100b
-00010101b & 00011101b = 00010101b
-00010101b & 00011110b = 00010100b
-00010101b & 00011111b = 00010101b
-00010101b & 00100000b = 00000000b
-00010101b & 00100001b = 00000001b
-00010101b & 00100010b = 00000000b
-00010101b & 00100011b = 00000001b
-00010101b & 00100100b = 00000100b
-00010101b & 00100101b = 00000101b
-00010101b & 00100110b = 00000100b
-00010101b & 00100111b = 00000101b
-00010101b & 00101000b = 00000000b
-00010101b & 00101001b = 00000001b
-00010101b & 00101010b = 00000000b
-00010101b & 00101011b = 00000001b
-00010101b & 00101100b = 00000100b
-00010101b & 00101101b = 00000101b
-00010101b & 00101110b = 00000100b
-00010101b & 00101111b = 00000101b
-00010101b & 00110000b = 00010000b
-00010101b & 00110001b = 00010001b
-00010101b & 00110010b = 00010000b
-00010101b & 00110011b = 00010001b
-00010101b & 00110100b = 00010100b
-00010101b & 00110101b = 00010101b
-00010101b & 00110110b = 00010100b
-00010101b & 00110111b = 00010101b
-00010101b & 00111000b = 00010000b
-00010101b & 00111001b = 00010001b
-00010101b & 00111010b = 00010000b
-00010101b & 00111011b = 00010001b
-00010101b & 00111100b = 00010100b
-00010101b & 00111101b = 00010101b
-00010101b & 00111110b = 00010100b
-00010101b & 00111111b = 00010101b
-00010101b & 01000000b = 00000000b
-00010101b & 01000001b = 00000001b
-00010101b & 01000010b = 00000000b
-00010101b & 01000011b = 00000001b
-00010101b & 01000100b = 00000100b
-00010101b & 01000101b = 00000101b
-00010101b & 01000110b = 00000100b
-00010101b & 01000111b = 00000101b
-00010101b & 01001000b = 00000000b
-00010101b & 01001001b = 00000001b
-00010101b & 01001010b = 00000000b
-00010101b & 01001011b = 00000001b
-00010101b & 01001100b = 00000100b
-00010101b & 01001101b = 00000101b
-00010101b & 01001110b = 00000100b
-00010101b & 01001111b = 00000101b
-00010101b & 01010000b = 00010000b
-00010101b & 01010001b = 00010001b
-00010101b & 01010010b = 00010000b
-00010101b & 01010011b = 00010001b
-00010101b & 01010100b = 00010100b
-00010101b & 01010101b = 00010101b
-00010101b & 01010110b = 00010100b
-00010101b & 01010111b = 00010101b
-00010101b & 01011000b = 00010000b
-00010101b & 01011001b = 00010001b
-00010101b & 01011010b = 00010000b
-00010101b & 01011011b = 00010001b
-00010101b & 01011100b = 00010100b
-00010101b & 01011101b = 00010101b
-00010101b & 01011110b = 00010100b
-00010101b & 01011111b = 00010101b
-00010101b & 01100000b = 00000000b
-00010101b & 01100001b = 00000001b
-00010101b & 01100010b = 00000000b
-00010101b & 01100011b = 00000001b
-00010101b & 01100100b = 00000100b
-00010101b & 01100101b = 00000101b
-00010101b & 01100110b = 00000100b
-00010101b & 01100111b = 00000101b
-00010101b & 01101000b = 00000000b
-00010101b & 01101001b = 00000001b
-00010101b & 01101010b = 00000000b
-00010101b & 01101011b = 00000001b
-00010101b & 01101100b = 00000100b
-00010101b & 01101101b = 00000101b
-00010101b & 01101110b = 00000100b
-00010101b & 01101111b = 00000101b
-00010101b & 01110000b = 00010000b
-00010101b & 01110001b = 00010001b
-00010101b & 01110010b = 00010000b
-00010101b & 01110011b = 00010001b
-00010101b & 01110100b = 00010100b
-00010101b & 01110101b = 00010101b
-00010101b & 01110110b = 00010100b
-00010101b & 01110111b = 00010101b
-00010101b & 01111000b = 00010000b
-00010101b & 01111001b = 00010001b
-00010101b & 01111010b = 00010000b
-00010101b & 01111011b = 00010001b
-00010101b & 01111100b = 00010100b
-00010101b & 01111101b = 00010101b
-00010101b & 01111110b = 00010100b
-00010110b & 10000000b = 00000000b
-00010110b & 10000001b = 00000000b
-00010110b & 10000010b = 00000010b
-00010110b & 10000011b = 00000010b
-00010110b & 10000100b = 00000100b
-00010110b & 10000101b = 00000100b
-00010110b & 10000110b = 00000110b
-00010110b & 10000111b = 00000110b
-00010110b & 10001000b = 00000000b
-00010110b & 10001001b = 00000000b
-00010110b & 10001010b = 00000010b
-00010110b & 10001011b = 00000010b
-00010110b & 10001100b = 00000100b
-00010110b & 10001101b = 00000100b
-00010110b & 10001110b = 00000110b
-00010110b & 10001111b = 00000110b
-00010110b & 10010000b = 00010000b
-00010110b & 10010001b = 00010000b
-00010110b & 10010010b = 00010010b
-00010110b & 10010011b = 00010010b
-00010110b & 10010100b = 00010100b
-00010110b & 10010101b = 00010100b
-00010110b & 10010110b = 00010110b
-00010110b & 10010111b = 00010110b
-00010110b & 10011000b = 00010000b
-00010110b & 10011001b = 00010000b
-00010110b & 10011010b = 00010010b
-00010110b & 10011011b = 00010010b
-00010110b & 10011100b = 00010100b
-00010110b & 10011101b = 00010100b
-00010110b & 10011110b = 00010110b
-00010110b & 10011111b = 00010110b
-00010110b & 10100000b = 00000000b
-00010110b & 10100001b = 00000000b
-00010110b & 10100010b = 00000010b
-00010110b & 10100011b = 00000010b
-00010110b & 10100100b = 00000100b
-00010110b & 10100101b = 00000100b
-00010110b & 10100110b = 00000110b
-00010110b & 10100111b = 00000110b
-00010110b & 10101000b = 00000000b
-00010110b & 10101001b = 00000000b
-00010110b & 10101010b = 00000010b
-00010110b & 10101011b = 00000010b
-00010110b & 10101100b = 00000100b
-00010110b & 10101101b = 00000100b
-00010110b & 10101110b = 00000110b
-00010110b & 10101111b = 00000110b
-00010110b & 10110000b = 00010000b
-00010110b & 10110001b = 00010000b
-00010110b & 10110010b = 00010010b
-00010110b & 10110011b = 00010010b
-00010110b & 10110100b = 00010100b
-00010110b & 10110101b = 00010100b
-00010110b & 10110110b = 00010110b
-00010110b & 10110111b = 00010110b
-00010110b & 10111000b = 00010000b
-00010110b & 10111001b = 00010000b
-00010110b & 10111010b = 00010010b
-00010110b & 10111011b = 00010010b
-00010110b & 10111100b = 00010100b
-00010110b & 10111101b = 00010100b
-00010110b & 10111110b = 00010110b
-00010110b & 10111111b = 00010110b
-00010110b & 11000000b = 00000000b
-00010110b & 11000001b = 00000000b
-00010110b & 11000010b = 00000010b
-00010110b & 11000011b = 00000010b
-00010110b & 11000100b = 00000100b
-00010110b & 11000101b = 00000100b
-00010110b & 11000110b = 00000110b
-00010110b & 11000111b = 00000110b
-00010110b & 11001000b = 00000000b
-00010110b & 11001001b = 00000000b
-00010110b & 11001010b = 00000010b
-00010110b & 11001011b = 00000010b
-00010110b & 11001100b = 00000100b
-00010110b & 11001101b = 00000100b
-00010110b & 11001110b = 00000110b
-00010110b & 11001111b = 00000110b
-00010110b & 11010000b = 00010000b
-00010110b & 11010001b = 00010000b
-00010110b & 11010010b = 00010010b
-00010110b & 11010011b = 00010010b
-00010110b & 11010100b = 00010100b
-00010110b & 11010101b = 00010100b
-00010110b & 11010110b = 00010110b
-00010110b & 11010111b = 00010110b
-00010110b & 11011000b = 00010000b
-00010110b & 11011001b = 00010000b
-00010110b & 11011010b = 00010010b
-00010110b & 11011011b = 00010010b
-00010110b & 11011100b = 00010100b
-00010110b & 11011101b = 00010100b
-00010110b & 11011110b = 00010110b
-00010110b & 11011111b = 00010110b
-00010110b & 11100000b = 00000000b
-00010110b & 11100001b = 00000000b
-00010110b & 11100010b = 00000010b
-00010110b & 11100011b = 00000010b
-00010110b & 11100100b = 00000100b
-00010110b & 11100101b = 00000100b
-00010110b & 11100110b = 00000110b
-00010110b & 11100111b = 00000110b
-00010110b & 11101000b = 00000000b
-00010110b & 11101001b = 00000000b
-00010110b & 11101010b = 00000010b
-00010110b & 11101011b = 00000010b
-00010110b & 11101100b = 00000100b
-00010110b & 11101101b = 00000100b
-00010110b & 11101110b = 00000110b
-00010110b & 11101111b = 00000110b
-00010110b & 11110000b = 00010000b
-00010110b & 11110001b = 00010000b
-00010110b & 11110010b = 00010010b
-00010110b & 11110011b = 00010010b
-00010110b & 11110100b = 00010100b
-00010110b & 11110101b = 00010100b
-00010110b & 11110110b = 00010110b
-00010110b & 11110111b = 00010110b
-00010110b & 11111000b = 00010000b
-00010110b & 11111001b = 00010000b
-00010110b & 11111010b = 00010010b
-00010110b & 11111011b = 00010010b
-00010110b & 11111100b = 00010100b
-00010110b & 11111101b = 00010100b
-00010110b & 11111110b = 00010110b
-00010110b & 11111111b = 00010110b
-00010110b & 00000000b = 00000000b
-00010110b & 00000001b = 00000000b
-00010110b & 00000010b = 00000010b
-00010110b & 00000011b = 00000010b
-00010110b & 00000100b = 00000100b
-00010110b & 00000101b = 00000100b
-00010110b & 00000110b = 00000110b
-00010110b & 00000111b = 00000110b
-00010110b & 00001000b = 00000000b
-00010110b & 00001001b = 00000000b
-00010110b & 00001010b = 00000010b
-00010110b & 00001011b = 00000010b
-00010110b & 00001100b = 00000100b
-00010110b & 00001101b = 00000100b
-00010110b & 00001110b = 00000110b
-00010110b & 00001111b = 00000110b
-00010110b & 00010000b = 00010000b
-00010110b & 00010001b = 00010000b
-00010110b & 00010010b = 00010010b
-00010110b & 00010011b = 00010010b
-00010110b & 00010100b = 00010100b
-00010110b & 00010101b = 00010100b
-00010110b & 00010110b = 00010110b
-00010110b & 00010111b = 00010110b
-00010110b & 00011000b = 00010000b
-00010110b & 00011001b = 00010000b
-00010110b & 00011010b = 00010010b
-00010110b & 00011011b = 00010010b
-00010110b & 00011100b = 00010100b
-00010110b & 00011101b = 00010100b
-00010110b & 00011110b = 00010110b
-00010110b & 00011111b = 00010110b
-00010110b & 00100000b = 00000000b
-00010110b & 00100001b = 00000000b
-00010110b & 00100010b = 00000010b
-00010110b & 00100011b = 00000010b
-00010110b & 00100100b = 00000100b
-00010110b & 00100101b = 00000100b
-00010110b & 00100110b = 00000110b
-00010110b & 00100111b = 00000110b
-00010110b & 00101000b = 00000000b
-00010110b & 00101001b = 00000000b
-00010110b & 00101010b = 00000010b
-00010110b & 00101011b = 00000010b
-00010110b & 00101100b = 00000100b
-00010110b & 00101101b = 00000100b
-00010110b & 00101110b = 00000110b
-00010110b & 00101111b = 00000110b
-00010110b & 00110000b = 00010000b
-00010110b & 00110001b = 00010000b
-00010110b & 00110010b = 00010010b
-00010110b & 00110011b = 00010010b
-00010110b & 00110100b = 00010100b
-00010110b & 00110101b = 00010100b
-00010110b & 00110110b = 00010110b
-00010110b & 00110111b = 00010110b
-00010110b & 00111000b = 00010000b
-00010110b & 00111001b = 00010000b
-00010110b & 00111010b = 00010010b
-00010110b & 00111011b = 00010010b
-00010110b & 00111100b = 00010100b
-00010110b & 00111101b = 00010100b
-00010110b & 00111110b = 00010110b
-00010110b & 00111111b = 00010110b
-00010110b & 01000000b = 00000000b
-00010110b & 01000001b = 00000000b
-00010110b & 01000010b = 00000010b
-00010110b & 01000011b = 00000010b
-00010110b & 01000100b = 00000100b
-00010110b & 01000101b = 00000100b
-00010110b & 01000110b = 00000110b
-00010110b & 01000111b = 00000110b
-00010110b & 01001000b = 00000000b
-00010110b & 01001001b = 00000000b
-00010110b & 01001010b = 00000010b
-00010110b & 01001011b = 00000010b
-00010110b & 01001100b = 00000100b
-00010110b & 01001101b = 00000100b
-00010110b & 01001110b = 00000110b
-00010110b & 01001111b = 00000110b
-00010110b & 01010000b = 00010000b
-00010110b & 01010001b = 00010000b
-00010110b & 01010010b = 00010010b
-00010110b & 01010011b = 00010010b
-00010110b & 01010100b = 00010100b
-00010110b & 01010101b = 00010100b
-00010110b & 01010110b = 00010110b
-00010110b & 01010111b = 00010110b
-00010110b & 01011000b = 00010000b
-00010110b & 01011001b = 00010000b
-00010110b & 01011010b = 00010010b
-00010110b & 01011011b = 00010010b
-00010110b & 01011100b = 00010100b
-00010110b & 01011101b = 00010100b
-00010110b & 01011110b = 00010110b
-00010110b & 01011111b = 00010110b
-00010110b & 01100000b = 00000000b
-00010110b & 01100001b = 00000000b
-00010110b & 01100010b = 00000010b
-00010110b & 01100011b = 00000010b
-00010110b & 01100100b = 00000100b
-00010110b & 01100101b = 00000100b
-00010110b & 01100110b = 00000110b
-00010110b & 01100111b = 00000110b
-00010110b & 01101000b = 00000000b
-00010110b & 01101001b = 00000000b
-00010110b & 01101010b = 00000010b
-00010110b & 01101011b = 00000010b
-00010110b & 01101100b = 00000100b
-00010110b & 01101101b = 00000100b
-00010110b & 01101110b = 00000110b
-00010110b & 01101111b = 00000110b
-00010110b & 01110000b = 00010000b
-00010110b & 01110001b = 00010000b
-00010110b & 01110010b = 00010010b
-00010110b & 01110011b = 00010010b
-00010110b & 01110100b = 00010100b
-00010110b & 01110101b = 00010100b
-00010110b & 01110110b = 00010110b
-00010110b & 01110111b = 00010110b
-00010110b & 01111000b = 00010000b
-00010110b & 01111001b = 00010000b
-00010110b & 01111010b = 00010010b
-00010110b & 01111011b = 00010010b
-00010110b & 01111100b = 00010100b
-00010110b & 01111101b = 00010100b
-00010110b & 01111110b = 00010110b
-00010111b & 10000000b = 00000000b
-00010111b & 10000001b = 00000001b
-00010111b & 10000010b = 00000010b
-00010111b & 10000011b = 00000011b
-00010111b & 10000100b = 00000100b
-00010111b & 10000101b = 00000101b
-00010111b & 10000110b = 00000110b
-00010111b & 10000111b = 00000111b
-00010111b & 10001000b = 00000000b
-00010111b & 10001001b = 00000001b
-00010111b & 10001010b = 00000010b
-00010111b & 10001011b = 00000011b
-00010111b & 10001100b = 00000100b
-00010111b & 10001101b = 00000101b
-00010111b & 10001110b = 00000110b
-00010111b & 10001111b = 00000111b
-00010111b & 10010000b = 00010000b
-00010111b & 10010001b = 00010001b
-00010111b & 10010010b = 00010010b
-00010111b & 10010011b = 00010011b
-00010111b & 10010100b = 00010100b
-00010111b & 10010101b = 00010101b
-00010111b & 10010110b = 00010110b
-00010111b & 10010111b = 00010111b
-00010111b & 10011000b = 00010000b
-00010111b & 10011001b = 00010001b
-00010111b & 10011010b = 00010010b
-00010111b & 10011011b = 00010011b
-00010111b & 10011100b = 00010100b
-00010111b & 10011101b = 00010101b
-00010111b & 10011110b = 00010110b
-00010111b & 10011111b = 00010111b
-00010111b & 10100000b = 00000000b
-00010111b & 10100001b = 00000001b
-00010111b & 10100010b = 00000010b
-00010111b & 10100011b = 00000011b
-00010111b & 10100100b = 00000100b
-00010111b & 10100101b = 00000101b
-00010111b & 10100110b = 00000110b
-00010111b & 10100111b = 00000111b
-00010111b & 10101000b = 00000000b
-00010111b & 10101001b = 00000001b
-00010111b & 10101010b = 00000010b
-00010111b & 10101011b = 00000011b
-00010111b & 10101100b = 00000100b
-00010111b & 10101101b = 00000101b
-00010111b & 10101110b = 00000110b
-00010111b & 10101111b = 00000111b
-00010111b & 10110000b = 00010000b
-00010111b & 10110001b = 00010001b
-00010111b & 10110010b = 00010010b
-00010111b & 10110011b = 00010011b
-00010111b & 10110100b = 00010100b
-00010111b & 10110101b = 00010101b
-00010111b & 10110110b = 00010110b
-00010111b & 10110111b = 00010111b
-00010111b & 10111000b = 00010000b
-00010111b & 10111001b = 00010001b
-00010111b & 10111010b = 00010010b
-00010111b & 10111011b = 00010011b
-00010111b & 10111100b = 00010100b
-00010111b & 10111101b = 00010101b
-00010111b & 10111110b = 00010110b
-00010111b & 10111111b = 00010111b
-00010111b & 11000000b = 00000000b
-00010111b & 11000001b = 00000001b
-00010111b & 11000010b = 00000010b
-00010111b & 11000011b = 00000011b
-00010111b & 11000100b = 00000100b
-00010111b & 11000101b = 00000101b
-00010111b & 11000110b = 00000110b
-00010111b & 11000111b = 00000111b
-00010111b & 11001000b = 00000000b
-00010111b & 11001001b = 00000001b
-00010111b & 11001010b = 00000010b
-00010111b & 11001011b = 00000011b
-00010111b & 11001100b = 00000100b
-00010111b & 11001101b = 00000101b
-00010111b & 11001110b = 00000110b
-00010111b & 11001111b = 00000111b
-00010111b & 11010000b = 00010000b
-00010111b & 11010001b = 00010001b
-00010111b & 11010010b = 00010010b
-00010111b & 11010011b = 00010011b
-00010111b & 11010100b = 00010100b
-00010111b & 11010101b = 00010101b
-00010111b & 11010110b = 00010110b
-00010111b & 11010111b = 00010111b
-00010111b & 11011000b = 00010000b
-00010111b & 11011001b = 00010001b
-00010111b & 11011010b = 00010010b
-00010111b & 11011011b = 00010011b
-00010111b & 11011100b = 00010100b
-00010111b & 11011101b = 00010101b
-00010111b & 11011110b = 00010110b
-00010111b & 11011111b = 00010111b
-00010111b & 11100000b = 00000000b
-00010111b & 11100001b = 00000001b
-00010111b & 11100010b = 00000010b
-00010111b & 11100011b = 00000011b
-00010111b & 11100100b = 00000100b
-00010111b & 11100101b = 00000101b
-00010111b & 11100110b = 00000110b
-00010111b & 11100111b = 00000111b
-00010111b & 11101000b = 00000000b
-00010111b & 11101001b = 00000001b
-00010111b & 11101010b = 00000010b
-00010111b & 11101011b = 00000011b
-00010111b & 11101100b = 00000100b
-00010111b & 11101101b = 00000101b
-00010111b & 11101110b = 00000110b
-00010111b & 11101111b = 00000111b
-00010111b & 11110000b = 00010000b
-00010111b & 11110001b = 00010001b
-00010111b & 11110010b = 00010010b
-00010111b & 11110011b = 00010011b
-00010111b & 11110100b = 00010100b
-00010111b & 11110101b = 00010101b
-00010111b & 11110110b = 00010110b
-00010111b & 11110111b = 00010111b
-00010111b & 11111000b = 00010000b
-00010111b & 11111001b = 00010001b
-00010111b & 11111010b = 00010010b
-00010111b & 11111011b = 00010011b
-00010111b & 11111100b = 00010100b
-00010111b & 11111101b = 00010101b
-00010111b & 11111110b = 00010110b
-00010111b & 11111111b = 00010111b
-00010111b & 00000000b = 00000000b
-00010111b & 00000001b = 00000001b
-00010111b & 00000010b = 00000010b
-00010111b & 00000011b = 00000011b
-00010111b & 00000100b = 00000100b
-00010111b & 00000101b = 00000101b
-00010111b & 00000110b = 00000110b
-00010111b & 00000111b = 00000111b
-00010111b & 00001000b = 00000000b
-00010111b & 00001001b = 00000001b
-00010111b & 00001010b = 00000010b
-00010111b & 00001011b = 00000011b
-00010111b & 00001100b = 00000100b
-00010111b & 00001101b = 00000101b
-00010111b & 00001110b = 00000110b
-00010111b & 00001111b = 00000111b
-00010111b & 00010000b = 00010000b
-00010111b & 00010001b = 00010001b
-00010111b & 00010010b = 00010010b
-00010111b & 00010011b = 00010011b
-00010111b & 00010100b = 00010100b
-00010111b & 00010101b = 00010101b
-00010111b & 00010110b = 00010110b
-00010111b & 00010111b = 00010111b
-00010111b & 00011000b = 00010000b
-00010111b & 00011001b = 00010001b
-00010111b & 00011010b = 00010010b
-00010111b & 00011011b = 00010011b
-00010111b & 00011100b = 00010100b
-00010111b & 00011101b = 00010101b
-00010111b & 00011110b = 00010110b
-00010111b & 00011111b = 00010111b
-00010111b & 00100000b = 00000000b
-00010111b & 00100001b = 00000001b
-00010111b & 00100010b = 00000010b
-00010111b & 00100011b = 00000011b
-00010111b & 00100100b = 00000100b
-00010111b & 00100101b = 00000101b
-00010111b & 00100110b = 00000110b
-00010111b & 00100111b = 00000111b
-00010111b & 00101000b = 00000000b
-00010111b & 00101001b = 00000001b
-00010111b & 00101010b = 00000010b
-00010111b & 00101011b = 00000011b
-00010111b & 00101100b = 00000100b
-00010111b & 00101101b = 00000101b
-00010111b & 00101110b = 00000110b
-00010111b & 00101111b = 00000111b
-00010111b & 00110000b = 00010000b
-00010111b & 00110001b = 00010001b
-00010111b & 00110010b = 00010010b
-00010111b & 00110011b = 00010011b
-00010111b & 00110100b = 00010100b
-00010111b & 00110101b = 00010101b
-00010111b & 00110110b = 00010110b
-00010111b & 00110111b = 00010111b
-00010111b & 00111000b = 00010000b
-00010111b & 00111001b = 00010001b
-00010111b & 00111010b = 00010010b
-00010111b & 00111011b = 00010011b
-00010111b & 00111100b = 00010100b
-00010111b & 00111101b = 00010101b
-00010111b & 00111110b = 00010110b
-00010111b & 00111111b = 00010111b
-00010111b & 01000000b = 00000000b
-00010111b & 01000001b = 00000001b
-00010111b & 01000010b = 00000010b
-00010111b & 01000011b = 00000011b
-00010111b & 01000100b = 00000100b
-00010111b & 01000101b = 00000101b
-00010111b & 01000110b = 00000110b
-00010111b & 01000111b = 00000111b
-00010111b & 01001000b = 00000000b
-00010111b & 01001001b = 00000001b
-00010111b & 01001010b = 00000010b
-00010111b & 01001011b = 00000011b
-00010111b & 01001100b = 00000100b
-00010111b & 01001101b = 00000101b
-00010111b & 01001110b = 00000110b
-00010111b & 01001111b = 00000111b
-00010111b & 01010000b = 00010000b
-00010111b & 01010001b = 00010001b
-00010111b & 01010010b = 00010010b
-00010111b & 01010011b = 00010011b
-00010111b & 01010100b = 00010100b
-00010111b & 01010101b = 00010101b
-00010111b & 01010110b = 00010110b
-00010111b & 01010111b = 00010111b
-00010111b & 01011000b = 00010000b
-00010111b & 01011001b = 00010001b
-00010111b & 01011010b = 00010010b
-00010111b & 01011011b = 00010011b
-00010111b & 01011100b = 00010100b
-00010111b & 01011101b = 00010101b
-00010111b & 01011110b = 00010110b
-00010111b & 01011111b = 00010111b
-00010111b & 01100000b = 00000000b
-00010111b & 01100001b = 00000001b
-00010111b & 01100010b = 00000010b
-00010111b & 01100011b = 00000011b
-00010111b & 01100100b = 00000100b
-00010111b & 01100101b = 00000101b
-00010111b & 01100110b = 00000110b
-00010111b & 01100111b = 00000111b
-00010111b & 01101000b = 00000000b
-00010111b & 01101001b = 00000001b
-00010111b & 01101010b = 00000010b
-00010111b & 01101011b = 00000011b
-00010111b & 01101100b = 00000100b
-00010111b & 01101101b = 00000101b
-00010111b & 01101110b = 00000110b
-00010111b & 01101111b = 00000111b
-00010111b & 01110000b = 00010000b
-00010111b & 01110001b = 00010001b
-00010111b & 01110010b = 00010010b
-00010111b & 01110011b = 00010011b
-00010111b & 01110100b = 00010100b
-00010111b & 01110101b = 00010101b
-00010111b & 01110110b = 00010110b
-00010111b & 01110111b = 00010111b
-00010111b & 01111000b = 00010000b
-00010111b & 01111001b = 00010001b
-00010111b & 01111010b = 00010010b
-00010111b & 01111011b = 00010011b
-00010111b & 01111100b = 00010100b
-00010111b & 01111101b = 00010101b
-00010111b & 01111110b = 00010110b
-00011000b & 10000000b = 00000000b
-00011000b & 10000001b = 00000000b
-00011000b & 10000010b = 00000000b
-00011000b & 10000011b = 00000000b
-00011000b & 10000100b = 00000000b
-00011000b & 10000101b = 00000000b
-00011000b & 10000110b = 00000000b
-00011000b & 10000111b = 00000000b
-00011000b & 10001000b = 00001000b
-00011000b & 10001001b = 00001000b
-00011000b & 10001010b = 00001000b
-00011000b & 10001011b = 00001000b
-00011000b & 10001100b = 00001000b
-00011000b & 10001101b = 00001000b
-00011000b & 10001110b = 00001000b
-00011000b & 10001111b = 00001000b
-00011000b & 10010000b = 00010000b
-00011000b & 10010001b = 00010000b
-00011000b & 10010010b = 00010000b
-00011000b & 10010011b = 00010000b
-00011000b & 10010100b = 00010000b
-00011000b & 10010101b = 00010000b
-00011000b & 10010110b = 00010000b
-00011000b & 10010111b = 00010000b
-00011000b & 10011000b = 00011000b
-00011000b & 10011001b = 00011000b
-00011000b & 10011010b = 00011000b
-00011000b & 10011011b = 00011000b
-00011000b & 10011100b = 00011000b
-00011000b & 10011101b = 00011000b
-00011000b & 10011110b = 00011000b
-00011000b & 10011111b = 00011000b
-00011000b & 10100000b = 00000000b
-00011000b & 10100001b = 00000000b
-00011000b & 10100010b = 00000000b
-00011000b & 10100011b = 00000000b
-00011000b & 10100100b = 00000000b
-00011000b & 10100101b = 00000000b
-00011000b & 10100110b = 00000000b
-00011000b & 10100111b = 00000000b
-00011000b & 10101000b = 00001000b
-00011000b & 10101001b = 00001000b
-00011000b & 10101010b = 00001000b
-00011000b & 10101011b = 00001000b
-00011000b & 10101100b = 00001000b
-00011000b & 10101101b = 00001000b
-00011000b & 10101110b = 00001000b
-00011000b & 10101111b = 00001000b
-00011000b & 10110000b = 00010000b
-00011000b & 10110001b = 00010000b
-00011000b & 10110010b = 00010000b
-00011000b & 10110011b = 00010000b
-00011000b & 10110100b = 00010000b
-00011000b & 10110101b = 00010000b
-00011000b & 10110110b = 00010000b
-00011000b & 10110111b = 00010000b
-00011000b & 10111000b = 00011000b
-00011000b & 10111001b = 00011000b
-00011000b & 10111010b = 00011000b
-00011000b & 10111011b = 00011000b
-00011000b & 10111100b = 00011000b
-00011000b & 10111101b = 00011000b
-00011000b & 10111110b = 00011000b
-00011000b & 10111111b = 00011000b
-00011000b & 11000000b = 00000000b
-00011000b & 11000001b = 00000000b
-00011000b & 11000010b = 00000000b
-00011000b & 11000011b = 00000000b
-00011000b & 11000100b = 00000000b
-00011000b & 11000101b = 00000000b
-00011000b & 11000110b = 00000000b
-00011000b & 11000111b = 00000000b
-00011000b & 11001000b = 00001000b
-00011000b & 11001001b = 00001000b
-00011000b & 11001010b = 00001000b
-00011000b & 11001011b = 00001000b
-00011000b & 11001100b = 00001000b
-00011000b & 11001101b = 00001000b
-00011000b & 11001110b = 00001000b
-00011000b & 11001111b = 00001000b
-00011000b & 11010000b = 00010000b
-00011000b & 11010001b = 00010000b
-00011000b & 11010010b = 00010000b
-00011000b & 11010011b = 00010000b
-00011000b & 11010100b = 00010000b
-00011000b & 11010101b = 00010000b
-00011000b & 11010110b = 00010000b
-00011000b & 11010111b = 00010000b
-00011000b & 11011000b = 00011000b
-00011000b & 11011001b = 00011000b
-00011000b & 11011010b = 00011000b
-00011000b & 11011011b = 00011000b
-00011000b & 11011100b = 00011000b
-00011000b & 11011101b = 00011000b
-00011000b & 11011110b = 00011000b
-00011000b & 11011111b = 00011000b
-00011000b & 11100000b = 00000000b
-00011000b & 11100001b = 00000000b
-00011000b & 11100010b = 00000000b
-00011000b & 11100011b = 00000000b
-00011000b & 11100100b = 00000000b
-00011000b & 11100101b = 00000000b
-00011000b & 11100110b = 00000000b
-00011000b & 11100111b = 00000000b
-00011000b & 11101000b = 00001000b
-00011000b & 11101001b = 00001000b
-00011000b & 11101010b = 00001000b
-00011000b & 11101011b = 00001000b
-00011000b & 11101100b = 00001000b
-00011000b & 11101101b = 00001000b
-00011000b & 11101110b = 00001000b
-00011000b & 11101111b = 00001000b
-00011000b & 11110000b = 00010000b
-00011000b & 11110001b = 00010000b
-00011000b & 11110010b = 00010000b
-00011000b & 11110011b = 00010000b
-00011000b & 11110100b = 00010000b
-00011000b & 11110101b = 00010000b
-00011000b & 11110110b = 00010000b
-00011000b & 11110111b = 00010000b
-00011000b & 11111000b = 00011000b
-00011000b & 11111001b = 00011000b
-00011000b & 11111010b = 00011000b
-00011000b & 11111011b = 00011000b
-00011000b & 11111100b = 00011000b
-00011000b & 11111101b = 00011000b
-00011000b & 11111110b = 00011000b
-00011000b & 11111111b = 00011000b
-00011000b & 00000000b = 00000000b
-00011000b & 00000001b = 00000000b
-00011000b & 00000010b = 00000000b
-00011000b & 00000011b = 00000000b
-00011000b & 00000100b = 00000000b
-00011000b & 00000101b = 00000000b
-00011000b & 00000110b = 00000000b
-00011000b & 00000111b = 00000000b
-00011000b & 00001000b = 00001000b
-00011000b & 00001001b = 00001000b
-00011000b & 00001010b = 00001000b
-00011000b & 00001011b = 00001000b
-00011000b & 00001100b = 00001000b
-00011000b & 00001101b = 00001000b
-00011000b & 00001110b = 00001000b
-00011000b & 00001111b = 00001000b
-00011000b & 00010000b = 00010000b
-00011000b & 00010001b = 00010000b
-00011000b & 00010010b = 00010000b
-00011000b & 00010011b = 00010000b
-00011000b & 00010100b = 00010000b
-00011000b & 00010101b = 00010000b
-00011000b & 00010110b = 00010000b
-00011000b & 00010111b = 00010000b
-00011000b & 00011000b = 00011000b
-00011000b & 00011001b = 00011000b
-00011000b & 00011010b = 00011000b
-00011000b & 00011011b = 00011000b
-00011000b & 00011100b = 00011000b
-00011000b & 00011101b = 00011000b
-00011000b & 00011110b = 00011000b
-00011000b & 00011111b = 00011000b
-00011000b & 00100000b = 00000000b
-00011000b & 00100001b = 00000000b
-00011000b & 00100010b = 00000000b
-00011000b & 00100011b = 00000000b
-00011000b & 00100100b = 00000000b
-00011000b & 00100101b = 00000000b
-00011000b & 00100110b = 00000000b
-00011000b & 00100111b = 00000000b
-00011000b & 00101000b = 00001000b
-00011000b & 00101001b = 00001000b
-00011000b & 00101010b = 00001000b
-00011000b & 00101011b = 00001000b
-00011000b & 00101100b = 00001000b
-00011000b & 00101101b = 00001000b
-00011000b & 00101110b = 00001000b
-00011000b & 00101111b = 00001000b
-00011000b & 00110000b = 00010000b
-00011000b & 00110001b = 00010000b
-00011000b & 00110010b = 00010000b
-00011000b & 00110011b = 00010000b
-00011000b & 00110100b = 00010000b
-00011000b & 00110101b = 00010000b
-00011000b & 00110110b = 00010000b
-00011000b & 00110111b = 00010000b
-00011000b & 00111000b = 00011000b
-00011000b & 00111001b = 00011000b
-00011000b & 00111010b = 00011000b
-00011000b & 00111011b = 00011000b
-00011000b & 00111100b = 00011000b
-00011000b & 00111101b = 00011000b
-00011000b & 00111110b = 00011000b
-00011000b & 00111111b = 00011000b
-00011000b & 01000000b = 00000000b
-00011000b & 01000001b = 00000000b
-00011000b & 01000010b = 00000000b
-00011000b & 01000011b = 00000000b
-00011000b & 01000100b = 00000000b
-00011000b & 01000101b = 00000000b
-00011000b & 01000110b = 00000000b
-00011000b & 01000111b = 00000000b
-00011000b & 01001000b = 00001000b
-00011000b & 01001001b = 00001000b
-00011000b & 01001010b = 00001000b
-00011000b & 01001011b = 00001000b
-00011000b & 01001100b = 00001000b
-00011000b & 01001101b = 00001000b
-00011000b & 01001110b = 00001000b
-00011000b & 01001111b = 00001000b
-00011000b & 01010000b = 00010000b
-00011000b & 01010001b = 00010000b
-00011000b & 01010010b = 00010000b
-00011000b & 01010011b = 00010000b
-00011000b & 01010100b = 00010000b
-00011000b & 01010101b = 00010000b
-00011000b & 01010110b = 00010000b
-00011000b & 01010111b = 00010000b
-00011000b & 01011000b = 00011000b
-00011000b & 01011001b = 00011000b
-00011000b & 01011010b = 00011000b
-00011000b & 01011011b = 00011000b
-00011000b & 01011100b = 00011000b
-00011000b & 01011101b = 00011000b
-00011000b & 01011110b = 00011000b
-00011000b & 01011111b = 00011000b
-00011000b & 01100000b = 00000000b
-00011000b & 01100001b = 00000000b
-00011000b & 01100010b = 00000000b
-00011000b & 01100011b = 00000000b
-00011000b & 01100100b = 00000000b
-00011000b & 01100101b = 00000000b
-00011000b & 01100110b = 00000000b
-00011000b & 01100111b = 00000000b
-00011000b & 01101000b = 00001000b
-00011000b & 01101001b = 00001000b
-00011000b & 01101010b = 00001000b
-00011000b & 01101011b = 00001000b
-00011000b & 01101100b = 00001000b
-00011000b & 01101101b = 00001000b
-00011000b & 01101110b = 00001000b
-00011000b & 01101111b = 00001000b
-00011000b & 01110000b = 00010000b
-00011000b & 01110001b = 00010000b
-00011000b & 01110010b = 00010000b
-00011000b & 01110011b = 00010000b
-00011000b & 01110100b = 00010000b
-00011000b & 01110101b = 00010000b
-00011000b & 01110110b = 00010000b
-00011000b & 01110111b = 00010000b
-00011000b & 01111000b = 00011000b
-00011000b & 01111001b = 00011000b
-00011000b & 01111010b = 00011000b
-00011000b & 01111011b = 00011000b
-00011000b & 01111100b = 00011000b
-00011000b & 01111101b = 00011000b
-00011000b & 01111110b = 00011000b
-00011001b & 10000000b = 00000000b
-00011001b & 10000001b = 00000001b
-00011001b & 10000010b = 00000000b
-00011001b & 10000011b = 00000001b
-00011001b & 10000100b = 00000000b
-00011001b & 10000101b = 00000001b
-00011001b & 10000110b = 00000000b
-00011001b & 10000111b = 00000001b
-00011001b & 10001000b = 00001000b
-00011001b & 10001001b = 00001001b
-00011001b & 10001010b = 00001000b
-00011001b & 10001011b = 00001001b
-00011001b & 10001100b = 00001000b
-00011001b & 10001101b = 00001001b
-00011001b & 10001110b = 00001000b
-00011001b & 10001111b = 00001001b
-00011001b & 10010000b = 00010000b
-00011001b & 10010001b = 00010001b
-00011001b & 10010010b = 00010000b
-00011001b & 10010011b = 00010001b
-00011001b & 10010100b = 00010000b
-00011001b & 10010101b = 00010001b
-00011001b & 10010110b = 00010000b
-00011001b & 10010111b = 00010001b
-00011001b & 10011000b = 00011000b
-00011001b & 10011001b = 00011001b
-00011001b & 10011010b = 00011000b
-00011001b & 10011011b = 00011001b
-00011001b & 10011100b = 00011000b
-00011001b & 10011101b = 00011001b
-00011001b & 10011110b = 00011000b
-00011001b & 10011111b = 00011001b
-00011001b & 10100000b = 00000000b
-00011001b & 10100001b = 00000001b
-00011001b & 10100010b = 00000000b
-00011001b & 10100011b = 00000001b
-00011001b & 10100100b = 00000000b
-00011001b & 10100101b = 00000001b
-00011001b & 10100110b = 00000000b
-00011001b & 10100111b = 00000001b
-00011001b & 10101000b = 00001000b
-00011001b & 10101001b = 00001001b
-00011001b & 10101010b = 00001000b
-00011001b & 10101011b = 00001001b
-00011001b & 10101100b = 00001000b
-00011001b & 10101101b = 00001001b
-00011001b & 10101110b = 00001000b
-00011001b & 10101111b = 00001001b
-00011001b & 10110000b = 00010000b
-00011001b & 10110001b = 00010001b
-00011001b & 10110010b = 00010000b
-00011001b & 10110011b = 00010001b
-00011001b & 10110100b = 00010000b
-00011001b & 10110101b = 00010001b
-00011001b & 10110110b = 00010000b
-00011001b & 10110111b = 00010001b
-00011001b & 10111000b = 00011000b
-00011001b & 10111001b = 00011001b
-00011001b & 10111010b = 00011000b
-00011001b & 10111011b = 00011001b
-00011001b & 10111100b = 00011000b
-00011001b & 10111101b = 00011001b
-00011001b & 10111110b = 00011000b
-00011001b & 10111111b = 00011001b
-00011001b & 11000000b = 00000000b
-00011001b & 11000001b = 00000001b
-00011001b & 11000010b = 00000000b
-00011001b & 11000011b = 00000001b
-00011001b & 11000100b = 00000000b
-00011001b & 11000101b = 00000001b
-00011001b & 11000110b = 00000000b
-00011001b & 11000111b = 00000001b
-00011001b & 11001000b = 00001000b
-00011001b & 11001001b = 00001001b
-00011001b & 11001010b = 00001000b
-00011001b & 11001011b = 00001001b
-00011001b & 11001100b = 00001000b
-00011001b & 11001101b = 00001001b
-00011001b & 11001110b = 00001000b
-00011001b & 11001111b = 00001001b
-00011001b & 11010000b = 00010000b
-00011001b & 11010001b = 00010001b
-00011001b & 11010010b = 00010000b
-00011001b & 11010011b = 00010001b
-00011001b & 11010100b = 00010000b
-00011001b & 11010101b = 00010001b
-00011001b & 11010110b = 00010000b
-00011001b & 11010111b = 00010001b
-00011001b & 11011000b = 00011000b
-00011001b & 11011001b = 00011001b
-00011001b & 11011010b = 00011000b
-00011001b & 11011011b = 00011001b
-00011001b & 11011100b = 00011000b
-00011001b & 11011101b = 00011001b
-00011001b & 11011110b = 00011000b
-00011001b & 11011111b = 00011001b
-00011001b & 11100000b = 00000000b
-00011001b & 11100001b = 00000001b
-00011001b & 11100010b = 00000000b
-00011001b & 11100011b = 00000001b
-00011001b & 11100100b = 00000000b
-00011001b & 11100101b = 00000001b
-00011001b & 11100110b = 00000000b
-00011001b & 11100111b = 00000001b
-00011001b & 11101000b = 00001000b
-00011001b & 11101001b = 00001001b
-00011001b & 11101010b = 00001000b
-00011001b & 11101011b = 00001001b
-00011001b & 11101100b = 00001000b
-00011001b & 11101101b = 00001001b
-00011001b & 11101110b = 00001000b
-00011001b & 11101111b = 00001001b
-00011001b & 11110000b = 00010000b
-00011001b & 11110001b = 00010001b
-00011001b & 11110010b = 00010000b
-00011001b & 11110011b = 00010001b
-00011001b & 11110100b = 00010000b
-00011001b & 11110101b = 00010001b
-00011001b & 11110110b = 00010000b
-00011001b & 11110111b = 00010001b
-00011001b & 11111000b = 00011000b
-00011001b & 11111001b = 00011001b
-00011001b & 11111010b = 00011000b
-00011001b & 11111011b = 00011001b
-00011001b & 11111100b = 00011000b
-00011001b & 11111101b = 00011001b
-00011001b & 11111110b = 00011000b
-00011001b & 11111111b = 00011001b
-00011001b & 00000000b = 00000000b
-00011001b & 00000001b = 00000001b
-00011001b & 00000010b = 00000000b
-00011001b & 00000011b = 00000001b
-00011001b & 00000100b = 00000000b
-00011001b & 00000101b = 00000001b
-00011001b & 00000110b = 00000000b
-00011001b & 00000111b = 00000001b
-00011001b & 00001000b = 00001000b
-00011001b & 00001001b = 00001001b
-00011001b & 00001010b = 00001000b
-00011001b & 00001011b = 00001001b
-00011001b & 00001100b = 00001000b
-00011001b & 00001101b = 00001001b
-00011001b & 00001110b = 00001000b
-00011001b & 00001111b = 00001001b
-00011001b & 00010000b = 00010000b
-00011001b & 00010001b = 00010001b
-00011001b & 00010010b = 00010000b
-00011001b & 00010011b = 00010001b
-00011001b & 00010100b = 00010000b
-00011001b & 00010101b = 00010001b
-00011001b & 00010110b = 00010000b
-00011001b & 00010111b = 00010001b
-00011001b & 00011000b = 00011000b
-00011001b & 00011001b = 00011001b
-00011001b & 00011010b = 00011000b
-00011001b & 00011011b = 00011001b
-00011001b & 00011100b = 00011000b
-00011001b & 00011101b = 00011001b
-00011001b & 00011110b = 00011000b
-00011001b & 00011111b = 00011001b
-00011001b & 00100000b = 00000000b
-00011001b & 00100001b = 00000001b
-00011001b & 00100010b = 00000000b
-00011001b & 00100011b = 00000001b
-00011001b & 00100100b = 00000000b
-00011001b & 00100101b = 00000001b
-00011001b & 00100110b = 00000000b
-00011001b & 00100111b = 00000001b
-00011001b & 00101000b = 00001000b
-00011001b & 00101001b = 00001001b
-00011001b & 00101010b = 00001000b
-00011001b & 00101011b = 00001001b
-00011001b & 00101100b = 00001000b
-00011001b & 00101101b = 00001001b
-00011001b & 00101110b = 00001000b
-00011001b & 00101111b = 00001001b
-00011001b & 00110000b = 00010000b
-00011001b & 00110001b = 00010001b
-00011001b & 00110010b = 00010000b
-00011001b & 00110011b = 00010001b
-00011001b & 00110100b = 00010000b
-00011001b & 00110101b = 00010001b
-00011001b & 00110110b = 00010000b
-00011001b & 00110111b = 00010001b
-00011001b & 00111000b = 00011000b
-00011001b & 00111001b = 00011001b
-00011001b & 00111010b = 00011000b
-00011001b & 00111011b = 00011001b
-00011001b & 00111100b = 00011000b
-00011001b & 00111101b = 00011001b
-00011001b & 00111110b = 00011000b
-00011001b & 00111111b = 00011001b
-00011001b & 01000000b = 00000000b
-00011001b & 01000001b = 00000001b
-00011001b & 01000010b = 00000000b
-00011001b & 01000011b = 00000001b
-00011001b & 01000100b = 00000000b
-00011001b & 01000101b = 00000001b
-00011001b & 01000110b = 00000000b
-00011001b & 01000111b = 00000001b
-00011001b & 01001000b = 00001000b
-00011001b & 01001001b = 00001001b
-00011001b & 01001010b = 00001000b
-00011001b & 01001011b = 00001001b
-00011001b & 01001100b = 00001000b
-00011001b & 01001101b = 00001001b
-00011001b & 01001110b = 00001000b
-00011001b & 01001111b = 00001001b
-00011001b & 01010000b = 00010000b
-00011001b & 01010001b = 00010001b
-00011001b & 01010010b = 00010000b
-00011001b & 01010011b = 00010001b
-00011001b & 01010100b = 00010000b
-00011001b & 01010101b = 00010001b
-00011001b & 01010110b = 00010000b
-00011001b & 01010111b = 00010001b
-00011001b & 01011000b = 00011000b
-00011001b & 01011001b = 00011001b
-00011001b & 01011010b = 00011000b
-00011001b & 01011011b = 00011001b
-00011001b & 01011100b = 00011000b
-00011001b & 01011101b = 00011001b
-00011001b & 01011110b = 00011000b
-00011001b & 01011111b = 00011001b
-00011001b & 01100000b = 00000000b
-00011001b & 01100001b = 00000001b
-00011001b & 01100010b = 00000000b
-00011001b & 01100011b = 00000001b
-00011001b & 01100100b = 00000000b
-00011001b & 01100101b = 00000001b
-00011001b & 01100110b = 00000000b
-00011001b & 01100111b = 00000001b
-00011001b & 01101000b = 00001000b
-00011001b & 01101001b = 00001001b
-00011001b & 01101010b = 00001000b
-00011001b & 01101011b = 00001001b
-00011001b & 01101100b = 00001000b
-00011001b & 01101101b = 00001001b
-00011001b & 01101110b = 00001000b
-00011001b & 01101111b = 00001001b
-00011001b & 01110000b = 00010000b
-00011001b & 01110001b = 00010001b
-00011001b & 01110010b = 00010000b
-00011001b & 01110011b = 00010001b
-00011001b & 01110100b = 00010000b
-00011001b & 01110101b = 00010001b
-00011001b & 01110110b = 00010000b
-00011001b & 01110111b = 00010001b
-00011001b & 01111000b = 00011000b
-00011001b & 01111001b = 00011001b
-00011001b & 01111010b = 00011000b
-00011001b & 01111011b = 00011001b
-00011001b & 01111100b = 00011000b
-00011001b & 01111101b = 00011001b
-00011001b & 01111110b = 00011000b
-00011010b & 10000000b = 00000000b
-00011010b & 10000001b = 00000000b
-00011010b & 10000010b = 00000010b
-00011010b & 10000011b = 00000010b
-00011010b & 10000100b = 00000000b
-00011010b & 10000101b = 00000000b
-00011010b & 10000110b = 00000010b
-00011010b & 10000111b = 00000010b
-00011010b & 10001000b = 00001000b
-00011010b & 10001001b = 00001000b
-00011010b & 10001010b = 00001010b
-00011010b & 10001011b = 00001010b
-00011010b & 10001100b = 00001000b
-00011010b & 10001101b = 00001000b
-00011010b & 10001110b = 00001010b
-00011010b & 10001111b = 00001010b
-00011010b & 10010000b = 00010000b
-00011010b & 10010001b = 00010000b
-00011010b & 10010010b = 00010010b
-00011010b & 10010011b = 00010010b
-00011010b & 10010100b = 00010000b
-00011010b & 10010101b = 00010000b
-00011010b & 10010110b = 00010010b
-00011010b & 10010111b = 00010010b
-00011010b & 10011000b = 00011000b
-00011010b & 10011001b = 00011000b
-00011010b & 10011010b = 00011010b
-00011010b & 10011011b = 00011010b
-00011010b & 10011100b = 00011000b
-00011010b & 10011101b = 00011000b
-00011010b & 10011110b = 00011010b
-00011010b & 10011111b = 00011010b
-00011010b & 10100000b = 00000000b
-00011010b & 10100001b = 00000000b
-00011010b & 10100010b = 00000010b
-00011010b & 10100011b = 00000010b
-00011010b & 10100100b = 00000000b
-00011010b & 10100101b = 00000000b
-00011010b & 10100110b = 00000010b
-00011010b & 10100111b = 00000010b
-00011010b & 10101000b = 00001000b
-00011010b & 10101001b = 00001000b
-00011010b & 10101010b = 00001010b
-00011010b & 10101011b = 00001010b
-00011010b & 10101100b = 00001000b
-00011010b & 10101101b = 00001000b
-00011010b & 10101110b = 00001010b
-00011010b & 10101111b = 00001010b
-00011010b & 10110000b = 00010000b
-00011010b & 10110001b = 00010000b
-00011010b & 10110010b = 00010010b
-00011010b & 10110011b = 00010010b
-00011010b & 10110100b = 00010000b
-00011010b & 10110101b = 00010000b
-00011010b & 10110110b = 00010010b
-00011010b & 10110111b = 00010010b
-00011010b & 10111000b = 00011000b
-00011010b & 10111001b = 00011000b
-00011010b & 10111010b = 00011010b
-00011010b & 10111011b = 00011010b
-00011010b & 10111100b = 00011000b
-00011010b & 10111101b = 00011000b
-00011010b & 10111110b = 00011010b
-00011010b & 10111111b = 00011010b
-00011010b & 11000000b = 00000000b
-00011010b & 11000001b = 00000000b
-00011010b & 11000010b = 00000010b
-00011010b & 11000011b = 00000010b
-00011010b & 11000100b = 00000000b
-00011010b & 11000101b = 00000000b
-00011010b & 11000110b = 00000010b
-00011010b & 11000111b = 00000010b
-00011010b & 11001000b = 00001000b
-00011010b & 11001001b = 00001000b
-00011010b & 11001010b = 00001010b
-00011010b & 11001011b = 00001010b
-00011010b & 11001100b = 00001000b
-00011010b & 11001101b = 00001000b
-00011010b & 11001110b = 00001010b
-00011010b & 11001111b = 00001010b
-00011010b & 11010000b = 00010000b
-00011010b & 11010001b = 00010000b
-00011010b & 11010010b = 00010010b
-00011010b & 11010011b = 00010010b
-00011010b & 11010100b = 00010000b
-00011010b & 11010101b = 00010000b
-00011010b & 11010110b = 00010010b
-00011010b & 11010111b = 00010010b
-00011010b & 11011000b = 00011000b
-00011010b & 11011001b = 00011000b
-00011010b & 11011010b = 00011010b
-00011010b & 11011011b = 00011010b
-00011010b & 11011100b = 00011000b
-00011010b & 11011101b = 00011000b
-00011010b & 11011110b = 00011010b
-00011010b & 11011111b = 00011010b
-00011010b & 11100000b = 00000000b
-00011010b & 11100001b = 00000000b
-00011010b & 11100010b = 00000010b
-00011010b & 11100011b = 00000010b
-00011010b & 11100100b = 00000000b
-00011010b & 11100101b = 00000000b
-00011010b & 11100110b = 00000010b
-00011010b & 11100111b = 00000010b
-00011010b & 11101000b = 00001000b
-00011010b & 11101001b = 00001000b
-00011010b & 11101010b = 00001010b
-00011010b & 11101011b = 00001010b
-00011010b & 11101100b = 00001000b
-00011010b & 11101101b = 00001000b
-00011010b & 11101110b = 00001010b
-00011010b & 11101111b = 00001010b
-00011010b & 11110000b = 00010000b
-00011010b & 11110001b = 00010000b
-00011010b & 11110010b = 00010010b
-00011010b & 11110011b = 00010010b
-00011010b & 11110100b = 00010000b
-00011010b & 11110101b = 00010000b
-00011010b & 11110110b = 00010010b
-00011010b & 11110111b = 00010010b
-00011010b & 11111000b = 00011000b
-00011010b & 11111001b = 00011000b
-00011010b & 11111010b = 00011010b
-00011010b & 11111011b = 00011010b
-00011010b & 11111100b = 00011000b
-00011010b & 11111101b = 00011000b
-00011010b & 11111110b = 00011010b
-00011010b & 11111111b = 00011010b
-00011010b & 00000000b = 00000000b
-00011010b & 00000001b = 00000000b
-00011010b & 00000010b = 00000010b
-00011010b & 00000011b = 00000010b
-00011010b & 00000100b = 00000000b
-00011010b & 00000101b = 00000000b
-00011010b & 00000110b = 00000010b
-00011010b & 00000111b = 00000010b
-00011010b & 00001000b = 00001000b
-00011010b & 00001001b = 00001000b
-00011010b & 00001010b = 00001010b
-00011010b & 00001011b = 00001010b
-00011010b & 00001100b = 00001000b
-00011010b & 00001101b = 00001000b
-00011010b & 00001110b = 00001010b
-00011010b & 00001111b = 00001010b
-00011010b & 00010000b = 00010000b
-00011010b & 00010001b = 00010000b
-00011010b & 00010010b = 00010010b
-00011010b & 00010011b = 00010010b
-00011010b & 00010100b = 00010000b
-00011010b & 00010101b = 00010000b
-00011010b & 00010110b = 00010010b
-00011010b & 00010111b = 00010010b
-00011010b & 00011000b = 00011000b
-00011010b & 00011001b = 00011000b
-00011010b & 00011010b = 00011010b
-00011010b & 00011011b = 00011010b
-00011010b & 00011100b = 00011000b
-00011010b & 00011101b = 00011000b
-00011010b & 00011110b = 00011010b
-00011010b & 00011111b = 00011010b
-00011010b & 00100000b = 00000000b
-00011010b & 00100001b = 00000000b
-00011010b & 00100010b = 00000010b
-00011010b & 00100011b = 00000010b
-00011010b & 00100100b = 00000000b
-00011010b & 00100101b = 00000000b
-00011010b & 00100110b = 00000010b
-00011010b & 00100111b = 00000010b
-00011010b & 00101000b = 00001000b
-00011010b & 00101001b = 00001000b
-00011010b & 00101010b = 00001010b
-00011010b & 00101011b = 00001010b
-00011010b & 00101100b = 00001000b
-00011010b & 00101101b = 00001000b
-00011010b & 00101110b = 00001010b
-00011010b & 00101111b = 00001010b
-00011010b & 00110000b = 00010000b
-00011010b & 00110001b = 00010000b
-00011010b & 00110010b = 00010010b
-00011010b & 00110011b = 00010010b
-00011010b & 00110100b = 00010000b
-00011010b & 00110101b = 00010000b
-00011010b & 00110110b = 00010010b
-00011010b & 00110111b = 00010010b
-00011010b & 00111000b = 00011000b
-00011010b & 00111001b = 00011000b
-00011010b & 00111010b = 00011010b
-00011010b & 00111011b = 00011010b
-00011010b & 00111100b = 00011000b
-00011010b & 00111101b = 00011000b
-00011010b & 00111110b = 00011010b
-00011010b & 00111111b = 00011010b
-00011010b & 01000000b = 00000000b
-00011010b & 01000001b = 00000000b
-00011010b & 01000010b = 00000010b
-00011010b & 01000011b = 00000010b
-00011010b & 01000100b = 00000000b
-00011010b & 01000101b = 00000000b
-00011010b & 01000110b = 00000010b
-00011010b & 01000111b = 00000010b
-00011010b & 01001000b = 00001000b
-00011010b & 01001001b = 00001000b
-00011010b & 01001010b = 00001010b
-00011010b & 01001011b = 00001010b
-00011010b & 01001100b = 00001000b
-00011010b & 01001101b = 00001000b
-00011010b & 01001110b = 00001010b
-00011010b & 01001111b = 00001010b
-00011010b & 01010000b = 00010000b
-00011010b & 01010001b = 00010000b
-00011010b & 01010010b = 00010010b
-00011010b & 01010011b = 00010010b
-00011010b & 01010100b = 00010000b
-00011010b & 01010101b = 00010000b
-00011010b & 01010110b = 00010010b
-00011010b & 01010111b = 00010010b
-00011010b & 01011000b = 00011000b
-00011010b & 01011001b = 00011000b
-00011010b & 01011010b = 00011010b
-00011010b & 01011011b = 00011010b
-00011010b & 01011100b = 00011000b
-00011010b & 01011101b = 00011000b
-00011010b & 01011110b = 00011010b
-00011010b & 01011111b = 00011010b
-00011010b & 01100000b = 00000000b
-00011010b & 01100001b = 00000000b
-00011010b & 01100010b = 00000010b
-00011010b & 01100011b = 00000010b
-00011010b & 01100100b = 00000000b
-00011010b & 01100101b = 00000000b
-00011010b & 01100110b = 00000010b
-00011010b & 01100111b = 00000010b
-00011010b & 01101000b = 00001000b
-00011010b & 01101001b = 00001000b
-00011010b & 01101010b = 00001010b
-00011010b & 01101011b = 00001010b
-00011010b & 01101100b = 00001000b
-00011010b & 01101101b = 00001000b
-00011010b & 01101110b = 00001010b
-00011010b & 01101111b = 00001010b
-00011010b & 01110000b = 00010000b
-00011010b & 01110001b = 00010000b
-00011010b & 01110010b = 00010010b
-00011010b & 01110011b = 00010010b
-00011010b & 01110100b = 00010000b
-00011010b & 01110101b = 00010000b
-00011010b & 01110110b = 00010010b
-00011010b & 01110111b = 00010010b
-00011010b & 01111000b = 00011000b
-00011010b & 01111001b = 00011000b
-00011010b & 01111010b = 00011010b
-00011010b & 01111011b = 00011010b
-00011010b & 01111100b = 00011000b
-00011010b & 01111101b = 00011000b
-00011010b & 01111110b = 00011010b
-00011011b & 10000000b = 00000000b
-00011011b & 10000001b = 00000001b
-00011011b & 10000010b = 00000010b
-00011011b & 10000011b = 00000011b
-00011011b & 10000100b = 00000000b
-00011011b & 10000101b = 00000001b
-00011011b & 10000110b = 00000010b
-00011011b & 10000111b = 00000011b
-00011011b & 10001000b = 00001000b
-00011011b & 10001001b = 00001001b
-00011011b & 10001010b = 00001010b
-00011011b & 10001011b = 00001011b
-00011011b & 10001100b = 00001000b
-00011011b & 10001101b = 00001001b
-00011011b & 10001110b = 00001010b
-00011011b & 10001111b = 00001011b
-00011011b & 10010000b = 00010000b
-00011011b & 10010001b = 00010001b
-00011011b & 10010010b = 00010010b
-00011011b & 10010011b = 00010011b
-00011011b & 10010100b = 00010000b
-00011011b & 10010101b = 00010001b
-00011011b & 10010110b = 00010010b
-00011011b & 10010111b = 00010011b
-00011011b & 10011000b = 00011000b
-00011011b & 10011001b = 00011001b
-00011011b & 10011010b = 00011010b
-00011011b & 10011011b = 00011011b
-00011011b & 10011100b = 00011000b
-00011011b & 10011101b = 00011001b
-00011011b & 10011110b = 00011010b
-00011011b & 10011111b = 00011011b
-00011011b & 10100000b = 00000000b
-00011011b & 10100001b = 00000001b
-00011011b & 10100010b = 00000010b
-00011011b & 10100011b = 00000011b
-00011011b & 10100100b = 00000000b
-00011011b & 10100101b = 00000001b
-00011011b & 10100110b = 00000010b
-00011011b & 10100111b = 00000011b
-00011011b & 10101000b = 00001000b
-00011011b & 10101001b = 00001001b
-00011011b & 10101010b = 00001010b
-00011011b & 10101011b = 00001011b
-00011011b & 10101100b = 00001000b
-00011011b & 10101101b = 00001001b
-00011011b & 10101110b = 00001010b
-00011011b & 10101111b = 00001011b
-00011011b & 10110000b = 00010000b
-00011011b & 10110001b = 00010001b
-00011011b & 10110010b = 00010010b
-00011011b & 10110011b = 00010011b
-00011011b & 10110100b = 00010000b
-00011011b & 10110101b = 00010001b
-00011011b & 10110110b = 00010010b
-00011011b & 10110111b = 00010011b
-00011011b & 10111000b = 00011000b
-00011011b & 10111001b = 00011001b
-00011011b & 10111010b = 00011010b
-00011011b & 10111011b = 00011011b
-00011011b & 10111100b = 00011000b
-00011011b & 10111101b = 00011001b
-00011011b & 10111110b = 00011010b
-00011011b & 10111111b = 00011011b
-00011011b & 11000000b = 00000000b
-00011011b & 11000001b = 00000001b
-00011011b & 11000010b = 00000010b
-00011011b & 11000011b = 00000011b
-00011011b & 11000100b = 00000000b
-00011011b & 11000101b = 00000001b
-00011011b & 11000110b = 00000010b
-00011011b & 11000111b = 00000011b
-00011011b & 11001000b = 00001000b
-00011011b & 11001001b = 00001001b
-00011011b & 11001010b = 00001010b
-00011011b & 11001011b = 00001011b
-00011011b & 11001100b = 00001000b
-00011011b & 11001101b = 00001001b
-00011011b & 11001110b = 00001010b
-00011011b & 11001111b = 00001011b
-00011011b & 11010000b = 00010000b
-00011011b & 11010001b = 00010001b
-00011011b & 11010010b = 00010010b
-00011011b & 11010011b = 00010011b
-00011011b & 11010100b = 00010000b
-00011011b & 11010101b = 00010001b
-00011011b & 11010110b = 00010010b
-00011011b & 11010111b = 00010011b
-00011011b & 11011000b = 00011000b
-00011011b & 11011001b = 00011001b
-00011011b & 11011010b = 00011010b
-00011011b & 11011011b = 00011011b
-00011011b & 11011100b = 00011000b
-00011011b & 11011101b = 00011001b
-00011011b & 11011110b = 00011010b
-00011011b & 11011111b = 00011011b
-00011011b & 11100000b = 00000000b
-00011011b & 11100001b = 00000001b
-00011011b & 11100010b = 00000010b
-00011011b & 11100011b = 00000011b
-00011011b & 11100100b = 00000000b
-00011011b & 11100101b = 00000001b
-00011011b & 11100110b = 00000010b
-00011011b & 11100111b = 00000011b
-00011011b & 11101000b = 00001000b
-00011011b & 11101001b = 00001001b
-00011011b & 11101010b = 00001010b
-00011011b & 11101011b = 00001011b
-00011011b & 11101100b = 00001000b
-00011011b & 11101101b = 00001001b
-00011011b & 11101110b = 00001010b
-00011011b & 11101111b = 00001011b
-00011011b & 11110000b = 00010000b
-00011011b & 11110001b = 00010001b
-00011011b & 11110010b = 00010010b
-00011011b & 11110011b = 00010011b
-00011011b & 11110100b = 00010000b
-00011011b & 11110101b = 00010001b
-00011011b & 11110110b = 00010010b
-00011011b & 11110111b = 00010011b
-00011011b & 11111000b = 00011000b
-00011011b & 11111001b = 00011001b
-00011011b & 11111010b = 00011010b
-00011011b & 11111011b = 00011011b
-00011011b & 11111100b = 00011000b
-00011011b & 11111101b = 00011001b
-00011011b & 11111110b = 00011010b
-00011011b & 11111111b = 00011011b
-00011011b & 00000000b = 00000000b
-00011011b & 00000001b = 00000001b
-00011011b & 00000010b = 00000010b
-00011011b & 00000011b = 00000011b
-00011011b & 00000100b = 00000000b
-00011011b & 00000101b = 00000001b
-00011011b & 00000110b = 00000010b
-00011011b & 00000111b = 00000011b
-00011011b & 00001000b = 00001000b
-00011011b & 00001001b = 00001001b
-00011011b & 00001010b = 00001010b
-00011011b & 00001011b = 00001011b
-00011011b & 00001100b = 00001000b
-00011011b & 00001101b = 00001001b
-00011011b & 00001110b = 00001010b
-00011011b & 00001111b = 00001011b
-00011011b & 00010000b = 00010000b
-00011011b & 00010001b = 00010001b
-00011011b & 00010010b = 00010010b
-00011011b & 00010011b = 00010011b
-00011011b & 00010100b = 00010000b
-00011011b & 00010101b = 00010001b
-00011011b & 00010110b = 00010010b
-00011011b & 00010111b = 00010011b
-00011011b & 00011000b = 00011000b
-00011011b & 00011001b = 00011001b
-00011011b & 00011010b = 00011010b
-00011011b & 00011011b = 00011011b
-00011011b & 00011100b = 00011000b
-00011011b & 00011101b = 00011001b
-00011011b & 00011110b = 00011010b
-00011011b & 00011111b = 00011011b
-00011011b & 00100000b = 00000000b
-00011011b & 00100001b = 00000001b
-00011011b & 00100010b = 00000010b
-00011011b & 00100011b = 00000011b
-00011011b & 00100100b = 00000000b
-00011011b & 00100101b = 00000001b
-00011011b & 00100110b = 00000010b
-00011011b & 00100111b = 00000011b
-00011011b & 00101000b = 00001000b
-00011011b & 00101001b = 00001001b
-00011011b & 00101010b = 00001010b
-00011011b & 00101011b = 00001011b
-00011011b & 00101100b = 00001000b
-00011011b & 00101101b = 00001001b
-00011011b & 00101110b = 00001010b
-00011011b & 00101111b = 00001011b
-00011011b & 00110000b = 00010000b
-00011011b & 00110001b = 00010001b
-00011011b & 00110010b = 00010010b
-00011011b & 00110011b = 00010011b
-00011011b & 00110100b = 00010000b
-00011011b & 00110101b = 00010001b
-00011011b & 00110110b = 00010010b
-00011011b & 00110111b = 00010011b
-00011011b & 00111000b = 00011000b
-00011011b & 00111001b = 00011001b
-00011011b & 00111010b = 00011010b
-00011011b & 00111011b = 00011011b
-00011011b & 00111100b = 00011000b
-00011011b & 00111101b = 00011001b
-00011011b & 00111110b = 00011010b
-00011011b & 00111111b = 00011011b
-00011011b & 01000000b = 00000000b
-00011011b & 01000001b = 00000001b
-00011011b & 01000010b = 00000010b
-00011011b & 01000011b = 00000011b
-00011011b & 01000100b = 00000000b
-00011011b & 01000101b = 00000001b
-00011011b & 01000110b = 00000010b
-00011011b & 01000111b = 00000011b
-00011011b & 01001000b = 00001000b
-00011011b & 01001001b = 00001001b
-00011011b & 01001010b = 00001010b
-00011011b & 01001011b = 00001011b
-00011011b & 01001100b = 00001000b
-00011011b & 01001101b = 00001001b
-00011011b & 01001110b = 00001010b
-00011011b & 01001111b = 00001011b
-00011011b & 01010000b = 00010000b
-00011011b & 01010001b = 00010001b
-00011011b & 01010010b = 00010010b
-00011011b & 01010011b = 00010011b
-00011011b & 01010100b = 00010000b
-00011011b & 01010101b = 00010001b
-00011011b & 01010110b = 00010010b
-00011011b & 01010111b = 00010011b
-00011011b & 01011000b = 00011000b
-00011011b & 01011001b = 00011001b
-00011011b & 01011010b = 00011010b
-00011011b & 01011011b = 00011011b
-00011011b & 01011100b = 00011000b
-00011011b & 01011101b = 00011001b
-00011011b & 01011110b = 00011010b
-00011011b & 01011111b = 00011011b
-00011011b & 01100000b = 00000000b
-00011011b & 01100001b = 00000001b
-00011011b & 01100010b = 00000010b
-00011011b & 01100011b = 00000011b
-00011011b & 01100100b = 00000000b
-00011011b & 01100101b = 00000001b
-00011011b & 01100110b = 00000010b
-00011011b & 01100111b = 00000011b
-00011011b & 01101000b = 00001000b
-00011011b & 01101001b = 00001001b
-00011011b & 01101010b = 00001010b
-00011011b & 01101011b = 00001011b
-00011011b & 01101100b = 00001000b
-00011011b & 01101101b = 00001001b
-00011011b & 01101110b = 00001010b
-00011011b & 01101111b = 00001011b
-00011011b & 01110000b = 00010000b
-00011011b & 01110001b = 00010001b
-00011011b & 01110010b = 00010010b
-00011011b & 01110011b = 00010011b
-00011011b & 01110100b = 00010000b
-00011011b & 01110101b = 00010001b
-00011011b & 01110110b = 00010010b
-00011011b & 01110111b = 00010011b
-00011011b & 01111000b = 00011000b
-00011011b & 01111001b = 00011001b
-00011011b & 01111010b = 00011010b
-00011011b & 01111011b = 00011011b
-00011011b & 01111100b = 00011000b
-00011011b & 01111101b = 00011001b
-00011011b & 01111110b = 00011010b
-00011100b & 10000000b = 00000000b
-00011100b & 10000001b = 00000000b
-00011100b & 10000010b = 00000000b
-00011100b & 10000011b = 00000000b
-00011100b & 10000100b = 00000100b
-00011100b & 10000101b = 00000100b
-00011100b & 10000110b = 00000100b
-00011100b & 10000111b = 00000100b
-00011100b & 10001000b = 00001000b
-00011100b & 10001001b = 00001000b
-00011100b & 10001010b = 00001000b
-00011100b & 10001011b = 00001000b
-00011100b & 10001100b = 00001100b
-00011100b & 10001101b = 00001100b
-00011100b & 10001110b = 00001100b
-00011100b & 10001111b = 00001100b
-00011100b & 10010000b = 00010000b
-00011100b & 10010001b = 00010000b
-00011100b & 10010010b = 00010000b
-00011100b & 10010011b = 00010000b
-00011100b & 10010100b = 00010100b
-00011100b & 10010101b = 00010100b
-00011100b & 10010110b = 00010100b
-00011100b & 10010111b = 00010100b
-00011100b & 10011000b = 00011000b
-00011100b & 10011001b = 00011000b
-00011100b & 10011010b = 00011000b
-00011100b & 10011011b = 00011000b
-00011100b & 10011100b = 00011100b
-00011100b & 10011101b = 00011100b
-00011100b & 10011110b = 00011100b
-00011100b & 10011111b = 00011100b
-00011100b & 10100000b = 00000000b
-00011100b & 10100001b = 00000000b
-00011100b & 10100010b = 00000000b
-00011100b & 10100011b = 00000000b
-00011100b & 10100100b = 00000100b
-00011100b & 10100101b = 00000100b
-00011100b & 10100110b = 00000100b
-00011100b & 10100111b = 00000100b
-00011100b & 10101000b = 00001000b
-00011100b & 10101001b = 00001000b
-00011100b & 10101010b = 00001000b
-00011100b & 10101011b = 00001000b
-00011100b & 10101100b = 00001100b
-00011100b & 10101101b = 00001100b
-00011100b & 10101110b = 00001100b
-00011100b & 10101111b = 00001100b
-00011100b & 10110000b = 00010000b
-00011100b & 10110001b = 00010000b
-00011100b & 10110010b = 00010000b
-00011100b & 10110011b = 00010000b
-00011100b & 10110100b = 00010100b
-00011100b & 10110101b = 00010100b
-00011100b & 10110110b = 00010100b
-00011100b & 10110111b = 00010100b
-00011100b & 10111000b = 00011000b
-00011100b & 10111001b = 00011000b
-00011100b & 10111010b = 00011000b
-00011100b & 10111011b = 00011000b
-00011100b & 10111100b = 00011100b
-00011100b & 10111101b = 00011100b
-00011100b & 10111110b = 00011100b
-00011100b & 10111111b = 00011100b
-00011100b & 11000000b = 00000000b
-00011100b & 11000001b = 00000000b
-00011100b & 11000010b = 00000000b
-00011100b & 11000011b = 00000000b
-00011100b & 11000100b = 00000100b
-00011100b & 11000101b = 00000100b
-00011100b & 11000110b = 00000100b
-00011100b & 11000111b = 00000100b
-00011100b & 11001000b = 00001000b
-00011100b & 11001001b = 00001000b
-00011100b & 11001010b = 00001000b
-00011100b & 11001011b = 00001000b
-00011100b & 11001100b = 00001100b
-00011100b & 11001101b = 00001100b
-00011100b & 11001110b = 00001100b
-00011100b & 11001111b = 00001100b
-00011100b & 11010000b = 00010000b
-00011100b & 11010001b = 00010000b
-00011100b & 11010010b = 00010000b
-00011100b & 11010011b = 00010000b
-00011100b & 11010100b = 00010100b
-00011100b & 11010101b = 00010100b
-00011100b & 11010110b = 00010100b
-00011100b & 11010111b = 00010100b
-00011100b & 11011000b = 00011000b
-00011100b & 11011001b = 00011000b
-00011100b & 11011010b = 00011000b
-00011100b & 11011011b = 00011000b
-00011100b & 11011100b = 00011100b
-00011100b & 11011101b = 00011100b
-00011100b & 11011110b = 00011100b
-00011100b & 11011111b = 00011100b
-00011100b & 11100000b = 00000000b
-00011100b & 11100001b = 00000000b
-00011100b & 11100010b = 00000000b
-00011100b & 11100011b = 00000000b
-00011100b & 11100100b = 00000100b
-00011100b & 11100101b = 00000100b
-00011100b & 11100110b = 00000100b
-00011100b & 11100111b = 00000100b
-00011100b & 11101000b = 00001000b
-00011100b & 11101001b = 00001000b
-00011100b & 11101010b = 00001000b
-00011100b & 11101011b = 00001000b
-00011100b & 11101100b = 00001100b
-00011100b & 11101101b = 00001100b
-00011100b & 11101110b = 00001100b
-00011100b & 11101111b = 00001100b
-00011100b & 11110000b = 00010000b
-00011100b & 11110001b = 00010000b
-00011100b & 11110010b = 00010000b
-00011100b & 11110011b = 00010000b
-00011100b & 11110100b = 00010100b
-00011100b & 11110101b = 00010100b
-00011100b & 11110110b = 00010100b
-00011100b & 11110111b = 00010100b
-00011100b & 11111000b = 00011000b
-00011100b & 11111001b = 00011000b
-00011100b & 11111010b = 00011000b
-00011100b & 11111011b = 00011000b
-00011100b & 11111100b = 00011100b
-00011100b & 11111101b = 00011100b
-00011100b & 11111110b = 00011100b
-00011100b & 11111111b = 00011100b
-00011100b & 00000000b = 00000000b
-00011100b & 00000001b = 00000000b
-00011100b & 00000010b = 00000000b
-00011100b & 00000011b = 00000000b
-00011100b & 00000100b = 00000100b
-00011100b & 00000101b = 00000100b
-00011100b & 00000110b = 00000100b
-00011100b & 00000111b = 00000100b
-00011100b & 00001000b = 00001000b
-00011100b & 00001001b = 00001000b
-00011100b & 00001010b = 00001000b
-00011100b & 00001011b = 00001000b
-00011100b & 00001100b = 00001100b
-00011100b & 00001101b = 00001100b
-00011100b & 00001110b = 00001100b
-00011100b & 00001111b = 00001100b
-00011100b & 00010000b = 00010000b
-00011100b & 00010001b = 00010000b
-00011100b & 00010010b = 00010000b
-00011100b & 00010011b = 00010000b
-00011100b & 00010100b = 00010100b
-00011100b & 00010101b = 00010100b
-00011100b & 00010110b = 00010100b
-00011100b & 00010111b = 00010100b
-00011100b & 00011000b = 00011000b
-00011100b & 00011001b = 00011000b
-00011100b & 00011010b = 00011000b
-00011100b & 00011011b = 00011000b
-00011100b & 00011100b = 00011100b
-00011100b & 00011101b = 00011100b
-00011100b & 00011110b = 00011100b
-00011100b & 00011111b = 00011100b
-00011100b & 00100000b = 00000000b
-00011100b & 00100001b = 00000000b
-00011100b & 00100010b = 00000000b
-00011100b & 00100011b = 00000000b
-00011100b & 00100100b = 00000100b
-00011100b & 00100101b = 00000100b
-00011100b & 00100110b = 00000100b
-00011100b & 00100111b = 00000100b
-00011100b & 00101000b = 00001000b
-00011100b & 00101001b = 00001000b
-00011100b & 00101010b = 00001000b
-00011100b & 00101011b = 00001000b
-00011100b & 00101100b = 00001100b
-00011100b & 00101101b = 00001100b
-00011100b & 00101110b = 00001100b
-00011100b & 00101111b = 00001100b
-00011100b & 00110000b = 00010000b
-00011100b & 00110001b = 00010000b
-00011100b & 00110010b = 00010000b
-00011100b & 00110011b = 00010000b
-00011100b & 00110100b = 00010100b
-00011100b & 00110101b = 00010100b
-00011100b & 00110110b = 00010100b
-00011100b & 00110111b = 00010100b
-00011100b & 00111000b = 00011000b
-00011100b & 00111001b = 00011000b
-00011100b & 00111010b = 00011000b
-00011100b & 00111011b = 00011000b
-00011100b & 00111100b = 00011100b
-00011100b & 00111101b = 00011100b
-00011100b & 00111110b = 00011100b
-00011100b & 00111111b = 00011100b
-00011100b & 01000000b = 00000000b
-00011100b & 01000001b = 00000000b
-00011100b & 01000010b = 00000000b
-00011100b & 01000011b = 00000000b
-00011100b & 01000100b = 00000100b
-00011100b & 01000101b = 00000100b
-00011100b & 01000110b = 00000100b
-00011100b & 01000111b = 00000100b
-00011100b & 01001000b = 00001000b
-00011100b & 01001001b = 00001000b
-00011100b & 01001010b = 00001000b
-00011100b & 01001011b = 00001000b
-00011100b & 01001100b = 00001100b
-00011100b & 01001101b = 00001100b
-00011100b & 01001110b = 00001100b
-00011100b & 01001111b = 00001100b
-00011100b & 01010000b = 00010000b
-00011100b & 01010001b = 00010000b
-00011100b & 01010010b = 00010000b
-00011100b & 01010011b = 00010000b
-00011100b & 01010100b = 00010100b
-00011100b & 01010101b = 00010100b
-00011100b & 01010110b = 00010100b
-00011100b & 01010111b = 00010100b
-00011100b & 01011000b = 00011000b
-00011100b & 01011001b = 00011000b
-00011100b & 01011010b = 00011000b
-00011100b & 01011011b = 00011000b
-00011100b & 01011100b = 00011100b
-00011100b & 01011101b = 00011100b
-00011100b & 01011110b = 00011100b
-00011100b & 01011111b = 00011100b
-00011100b & 01100000b = 00000000b
-00011100b & 01100001b = 00000000b
-00011100b & 01100010b = 00000000b
-00011100b & 01100011b = 00000000b
-00011100b & 01100100b = 00000100b
-00011100b & 01100101b = 00000100b
-00011100b & 01100110b = 00000100b
-00011100b & 01100111b = 00000100b
-00011100b & 01101000b = 00001000b
-00011100b & 01101001b = 00001000b
-00011100b & 01101010b = 00001000b
-00011100b & 01101011b = 00001000b
-00011100b & 01101100b = 00001100b
-00011100b & 01101101b = 00001100b
-00011100b & 01101110b = 00001100b
-00011100b & 01101111b = 00001100b
-00011100b & 01110000b = 00010000b
-00011100b & 01110001b = 00010000b
-00011100b & 01110010b = 00010000b
-00011100b & 01110011b = 00010000b
-00011100b & 01110100b = 00010100b
-00011100b & 01110101b = 00010100b
-00011100b & 01110110b = 00010100b
-00011100b & 01110111b = 00010100b
-00011100b & 01111000b = 00011000b
-00011100b & 01111001b = 00011000b
-00011100b & 01111010b = 00011000b
-00011100b & 01111011b = 00011000b
-00011100b & 01111100b = 00011100b
-00011100b & 01111101b = 00011100b
-00011100b & 01111110b = 00011100b
-00011101b & 10000000b = 00000000b
-00011101b & 10000001b = 00000001b
-00011101b & 10000010b = 00000000b
-00011101b & 10000011b = 00000001b
-00011101b & 10000100b = 00000100b
-00011101b & 10000101b = 00000101b
-00011101b & 10000110b = 00000100b
-00011101b & 10000111b = 00000101b
-00011101b & 10001000b = 00001000b
-00011101b & 10001001b = 00001001b
-00011101b & 10001010b = 00001000b
-00011101b & 10001011b = 00001001b
-00011101b & 10001100b = 00001100b
-00011101b & 10001101b = 00001101b
-00011101b & 10001110b = 00001100b
-00011101b & 10001111b = 00001101b
-00011101b & 10010000b = 00010000b
-00011101b & 10010001b = 00010001b
-00011101b & 10010010b = 00010000b
-00011101b & 10010011b = 00010001b
-00011101b & 10010100b = 00010100b
-00011101b & 10010101b = 00010101b
-00011101b & 10010110b = 00010100b
-00011101b & 10010111b = 00010101b
-00011101b & 10011000b = 00011000b
-00011101b & 10011001b = 00011001b
-00011101b & 10011010b = 00011000b
-00011101b & 10011011b = 00011001b
-00011101b & 10011100b = 00011100b
-00011101b & 10011101b = 00011101b
-00011101b & 10011110b = 00011100b
-00011101b & 10011111b = 00011101b
-00011101b & 10100000b = 00000000b
-00011101b & 10100001b = 00000001b
-00011101b & 10100010b = 00000000b
-00011101b & 10100011b = 00000001b
-00011101b & 10100100b = 00000100b
-00011101b & 10100101b = 00000101b
-00011101b & 10100110b = 00000100b
-00011101b & 10100111b = 00000101b
-00011101b & 10101000b = 00001000b
-00011101b & 10101001b = 00001001b
-00011101b & 10101010b = 00001000b
-00011101b & 10101011b = 00001001b
-00011101b & 10101100b = 00001100b
-00011101b & 10101101b = 00001101b
-00011101b & 10101110b = 00001100b
-00011101b & 10101111b = 00001101b
-00011101b & 10110000b = 00010000b
-00011101b & 10110001b = 00010001b
-00011101b & 10110010b = 00010000b
-00011101b & 10110011b = 00010001b
-00011101b & 10110100b = 00010100b
-00011101b & 10110101b = 00010101b
-00011101b & 10110110b = 00010100b
-00011101b & 10110111b = 00010101b
-00011101b & 10111000b = 00011000b
-00011101b & 10111001b = 00011001b
-00011101b & 10111010b = 00011000b
-00011101b & 10111011b = 00011001b
-00011101b & 10111100b = 00011100b
-00011101b & 10111101b = 00011101b
-00011101b & 10111110b = 00011100b
-00011101b & 10111111b = 00011101b
-00011101b & 11000000b = 00000000b
-00011101b & 11000001b = 00000001b
-00011101b & 11000010b = 00000000b
-00011101b & 11000011b = 00000001b
-00011101b & 11000100b = 00000100b
-00011101b & 11000101b = 00000101b
-00011101b & 11000110b = 00000100b
-00011101b & 11000111b = 00000101b
-00011101b & 11001000b = 00001000b
-00011101b & 11001001b = 00001001b
-00011101b & 11001010b = 00001000b
-00011101b & 11001011b = 00001001b
-00011101b & 11001100b = 00001100b
-00011101b & 11001101b = 00001101b
-00011101b & 11001110b = 00001100b
-00011101b & 11001111b = 00001101b
-00011101b & 11010000b = 00010000b
-00011101b & 11010001b = 00010001b
-00011101b & 11010010b = 00010000b
-00011101b & 11010011b = 00010001b
-00011101b & 11010100b = 00010100b
-00011101b & 11010101b = 00010101b
-00011101b & 11010110b = 00010100b
-00011101b & 11010111b = 00010101b
-00011101b & 11011000b = 00011000b
-00011101b & 11011001b = 00011001b
-00011101b & 11011010b = 00011000b
-00011101b & 11011011b = 00011001b
-00011101b & 11011100b = 00011100b
-00011101b & 11011101b = 00011101b
-00011101b & 11011110b = 00011100b
-00011101b & 11011111b = 00011101b
-00011101b & 11100000b = 00000000b
-00011101b & 11100001b = 00000001b
-00011101b & 11100010b = 00000000b
-00011101b & 11100011b = 00000001b
-00011101b & 11100100b = 00000100b
-00011101b & 11100101b = 00000101b
-00011101b & 11100110b = 00000100b
-00011101b & 11100111b = 00000101b
-00011101b & 11101000b = 00001000b
-00011101b & 11101001b = 00001001b
-00011101b & 11101010b = 00001000b
-00011101b & 11101011b = 00001001b
-00011101b & 11101100b = 00001100b
-00011101b & 11101101b = 00001101b
-00011101b & 11101110b = 00001100b
-00011101b & 11101111b = 00001101b
-00011101b & 11110000b = 00010000b
-00011101b & 11110001b = 00010001b
-00011101b & 11110010b = 00010000b
-00011101b & 11110011b = 00010001b
-00011101b & 11110100b = 00010100b
-00011101b & 11110101b = 00010101b
-00011101b & 11110110b = 00010100b
-00011101b & 11110111b = 00010101b
-00011101b & 11111000b = 00011000b
-00011101b & 11111001b = 00011001b
-00011101b & 11111010b = 00011000b
-00011101b & 11111011b = 00011001b
-00011101b & 11111100b = 00011100b
-00011101b & 11111101b = 00011101b
-00011101b & 11111110b = 00011100b
-00011101b & 11111111b = 00011101b
-00011101b & 00000000b = 00000000b
-00011101b & 00000001b = 00000001b
-00011101b & 00000010b = 00000000b
-00011101b & 00000011b = 00000001b
-00011101b & 00000100b = 00000100b
-00011101b & 00000101b = 00000101b
-00011101b & 00000110b = 00000100b
-00011101b & 00000111b = 00000101b
-00011101b & 00001000b = 00001000b
-00011101b & 00001001b = 00001001b
-00011101b & 00001010b = 00001000b
-00011101b & 00001011b = 00001001b
-00011101b & 00001100b = 00001100b
-00011101b & 00001101b = 00001101b
-00011101b & 00001110b = 00001100b
-00011101b & 00001111b = 00001101b
-00011101b & 00010000b = 00010000b
-00011101b & 00010001b = 00010001b
-00011101b & 00010010b = 00010000b
-00011101b & 00010011b = 00010001b
-00011101b & 00010100b = 00010100b
-00011101b & 00010101b = 00010101b
-00011101b & 00010110b = 00010100b
-00011101b & 00010111b = 00010101b
-00011101b & 00011000b = 00011000b
-00011101b & 00011001b = 00011001b
-00011101b & 00011010b = 00011000b
-00011101b & 00011011b = 00011001b
-00011101b & 00011100b = 00011100b
-00011101b & 00011101b = 00011101b
-00011101b & 00011110b = 00011100b
-00011101b & 00011111b = 00011101b
-00011101b & 00100000b = 00000000b
-00011101b & 00100001b = 00000001b
-00011101b & 00100010b = 00000000b
-00011101b & 00100011b = 00000001b
-00011101b & 00100100b = 00000100b
-00011101b & 00100101b = 00000101b
-00011101b & 00100110b = 00000100b
-00011101b & 00100111b = 00000101b
-00011101b & 00101000b = 00001000b
-00011101b & 00101001b = 00001001b
-00011101b & 00101010b = 00001000b
-00011101b & 00101011b = 00001001b
-00011101b & 00101100b = 00001100b
-00011101b & 00101101b = 00001101b
-00011101b & 00101110b = 00001100b
-00011101b & 00101111b = 00001101b
-00011101b & 00110000b = 00010000b
-00011101b & 00110001b = 00010001b
-00011101b & 00110010b = 00010000b
-00011101b & 00110011b = 00010001b
-00011101b & 00110100b = 00010100b
-00011101b & 00110101b = 00010101b
-00011101b & 00110110b = 00010100b
-00011101b & 00110111b = 00010101b
-00011101b & 00111000b = 00011000b
-00011101b & 00111001b = 00011001b
-00011101b & 00111010b = 00011000b
-00011101b & 00111011b = 00011001b
-00011101b & 00111100b = 00011100b
-00011101b & 00111101b = 00011101b
-00011101b & 00111110b = 00011100b
-00011101b & 00111111b = 00011101b
-00011101b & 01000000b = 00000000b
-00011101b & 01000001b = 00000001b
-00011101b & 01000010b = 00000000b
-00011101b & 01000011b = 00000001b
-00011101b & 01000100b = 00000100b
-00011101b & 01000101b = 00000101b
-00011101b & 01000110b = 00000100b
-00011101b & 01000111b = 00000101b
-00011101b & 01001000b = 00001000b
-00011101b & 01001001b = 00001001b
-00011101b & 01001010b = 00001000b
-00011101b & 01001011b = 00001001b
-00011101b & 01001100b = 00001100b
-00011101b & 01001101b = 00001101b
-00011101b & 01001110b = 00001100b
-00011101b & 01001111b = 00001101b
-00011101b & 01010000b = 00010000b
-00011101b & 01010001b = 00010001b
-00011101b & 01010010b = 00010000b
-00011101b & 01010011b = 00010001b
-00011101b & 01010100b = 00010100b
-00011101b & 01010101b = 00010101b
-00011101b & 01010110b = 00010100b
-00011101b & 01010111b = 00010101b
-00011101b & 01011000b = 00011000b
-00011101b & 01011001b = 00011001b
-00011101b & 01011010b = 00011000b
-00011101b & 01011011b = 00011001b
-00011101b & 01011100b = 00011100b
-00011101b & 01011101b = 00011101b
-00011101b & 01011110b = 00011100b
-00011101b & 01011111b = 00011101b
-00011101b & 01100000b = 00000000b
-00011101b & 01100001b = 00000001b
-00011101b & 01100010b = 00000000b
-00011101b & 01100011b = 00000001b
-00011101b & 01100100b = 00000100b
-00011101b & 01100101b = 00000101b
-00011101b & 01100110b = 00000100b
-00011101b & 01100111b = 00000101b
-00011101b & 01101000b = 00001000b
-00011101b & 01101001b = 00001001b
-00011101b & 01101010b = 00001000b
-00011101b & 01101011b = 00001001b
-00011101b & 01101100b = 00001100b
-00011101b & 01101101b = 00001101b
-00011101b & 01101110b = 00001100b
-00011101b & 01101111b = 00001101b
-00011101b & 01110000b = 00010000b
-00011101b & 01110001b = 00010001b
-00011101b & 01110010b = 00010000b
-00011101b & 01110011b = 00010001b
-00011101b & 01110100b = 00010100b
-00011101b & 01110101b = 00010101b
-00011101b & 01110110b = 00010100b
-00011101b & 01110111b = 00010101b
-00011101b & 01111000b = 00011000b
-00011101b & 01111001b = 00011001b
-00011101b & 01111010b = 00011000b
-00011101b & 01111011b = 00011001b
-00011101b & 01111100b = 00011100b
-00011101b & 01111101b = 00011101b
-00011101b & 01111110b = 00011100b
-00011110b & 10000000b = 00000000b
-00011110b & 10000001b = 00000000b
-00011110b & 10000010b = 00000010b
-00011110b & 10000011b = 00000010b
-00011110b & 10000100b = 00000100b
-00011110b & 10000101b = 00000100b
-00011110b & 10000110b = 00000110b
-00011110b & 10000111b = 00000110b
-00011110b & 10001000b = 00001000b
-00011110b & 10001001b = 00001000b
-00011110b & 10001010b = 00001010b
-00011110b & 10001011b = 00001010b
-00011110b & 10001100b = 00001100b
-00011110b & 10001101b = 00001100b
-00011110b & 10001110b = 00001110b
-00011110b & 10001111b = 00001110b
-00011110b & 10010000b = 00010000b
-00011110b & 10010001b = 00010000b
-00011110b & 10010010b = 00010010b
-00011110b & 10010011b = 00010010b
-00011110b & 10010100b = 00010100b
-00011110b & 10010101b = 00010100b
-00011110b & 10010110b = 00010110b
-00011110b & 10010111b = 00010110b
-00011110b & 10011000b = 00011000b
-00011110b & 10011001b = 00011000b
-00011110b & 10011010b = 00011010b
-00011110b & 10011011b = 00011010b
-00011110b & 10011100b = 00011100b
-00011110b & 10011101b = 00011100b
-00011110b & 10011110b = 00011110b
-00011110b & 10011111b = 00011110b
-00011110b & 10100000b = 00000000b
-00011110b & 10100001b = 00000000b
-00011110b & 10100010b = 00000010b
-00011110b & 10100011b = 00000010b
-00011110b & 10100100b = 00000100b
-00011110b & 10100101b = 00000100b
-00011110b & 10100110b = 00000110b
-00011110b & 10100111b = 00000110b
-00011110b & 10101000b = 00001000b
-00011110b & 10101001b = 00001000b
-00011110b & 10101010b = 00001010b
-00011110b & 10101011b = 00001010b
-00011110b & 10101100b = 00001100b
-00011110b & 10101101b = 00001100b
-00011110b & 10101110b = 00001110b
-00011110b & 10101111b = 00001110b
-00011110b & 10110000b = 00010000b
-00011110b & 10110001b = 00010000b
-00011110b & 10110010b = 00010010b
-00011110b & 10110011b = 00010010b
-00011110b & 10110100b = 00010100b
-00011110b & 10110101b = 00010100b
-00011110b & 10110110b = 00010110b
-00011110b & 10110111b = 00010110b
-00011110b & 10111000b = 00011000b
-00011110b & 10111001b = 00011000b
-00011110b & 10111010b = 00011010b
-00011110b & 10111011b = 00011010b
-00011110b & 10111100b = 00011100b
-00011110b & 10111101b = 00011100b
-00011110b & 10111110b = 00011110b
-00011110b & 10111111b = 00011110b
-00011110b & 11000000b = 00000000b
-00011110b & 11000001b = 00000000b
-00011110b & 11000010b = 00000010b
-00011110b & 11000011b = 00000010b
-00011110b & 11000100b = 00000100b
-00011110b & 11000101b = 00000100b
-00011110b & 11000110b = 00000110b
-00011110b & 11000111b = 00000110b
-00011110b & 11001000b = 00001000b
-00011110b & 11001001b = 00001000b
-00011110b & 11001010b = 00001010b
-00011110b & 11001011b = 00001010b
-00011110b & 11001100b = 00001100b
-00011110b & 11001101b = 00001100b
-00011110b & 11001110b = 00001110b
-00011110b & 11001111b = 00001110b
-00011110b & 11010000b = 00010000b
-00011110b & 11010001b = 00010000b
-00011110b & 11010010b = 00010010b
-00011110b & 11010011b = 00010010b
-00011110b & 11010100b = 00010100b
-00011110b & 11010101b = 00010100b
-00011110b & 11010110b = 00010110b
-00011110b & 11010111b = 00010110b
-00011110b & 11011000b = 00011000b
-00011110b & 11011001b = 00011000b
-00011110b & 11011010b = 00011010b
-00011110b & 11011011b = 00011010b
-00011110b & 11011100b = 00011100b
-00011110b & 11011101b = 00011100b
-00011110b & 11011110b = 00011110b
-00011110b & 11011111b = 00011110b
-00011110b & 11100000b = 00000000b
-00011110b & 11100001b = 00000000b
-00011110b & 11100010b = 00000010b
-00011110b & 11100011b = 00000010b
-00011110b & 11100100b = 00000100b
-00011110b & 11100101b = 00000100b
-00011110b & 11100110b = 00000110b
-00011110b & 11100111b = 00000110b
-00011110b & 11101000b = 00001000b
-00011110b & 11101001b = 00001000b
-00011110b & 11101010b = 00001010b
-00011110b & 11101011b = 00001010b
-00011110b & 11101100b = 00001100b
-00011110b & 11101101b = 00001100b
-00011110b & 11101110b = 00001110b
-00011110b & 11101111b = 00001110b
-00011110b & 11110000b = 00010000b
-00011110b & 11110001b = 00010000b
-00011110b & 11110010b = 00010010b
-00011110b & 11110011b = 00010010b
-00011110b & 11110100b = 00010100b
-00011110b & 11110101b = 00010100b
-00011110b & 11110110b = 00010110b
-00011110b & 11110111b = 00010110b
-00011110b & 11111000b = 00011000b
-00011110b & 11111001b = 00011000b
-00011110b & 11111010b = 00011010b
-00011110b & 11111011b = 00011010b
-00011110b & 11111100b = 00011100b
-00011110b & 11111101b = 00011100b
-00011110b & 11111110b = 00011110b
-00011110b & 11111111b = 00011110b
-00011110b & 00000000b = 00000000b
-00011110b & 00000001b = 00000000b
-00011110b & 00000010b = 00000010b
-00011110b & 00000011b = 00000010b
-00011110b & 00000100b = 00000100b
-00011110b & 00000101b = 00000100b
-00011110b & 00000110b = 00000110b
-00011110b & 00000111b = 00000110b
-00011110b & 00001000b = 00001000b
-00011110b & 00001001b = 00001000b
-00011110b & 00001010b = 00001010b
-00011110b & 00001011b = 00001010b
-00011110b & 00001100b = 00001100b
-00011110b & 00001101b = 00001100b
-00011110b & 00001110b = 00001110b
-00011110b & 00001111b = 00001110b
-00011110b & 00010000b = 00010000b
-00011110b & 00010001b = 00010000b
-00011110b & 00010010b = 00010010b
-00011110b & 00010011b = 00010010b
-00011110b & 00010100b = 00010100b
-00011110b & 00010101b = 00010100b
-00011110b & 00010110b = 00010110b
-00011110b & 00010111b = 00010110b
-00011110b & 00011000b = 00011000b
-00011110b & 00011001b = 00011000b
-00011110b & 00011010b = 00011010b
-00011110b & 00011011b = 00011010b
-00011110b & 00011100b = 00011100b
-00011110b & 00011101b = 00011100b
-00011110b & 00011110b = 00011110b
-00011110b & 00011111b = 00011110b
-00011110b & 00100000b = 00000000b
-00011110b & 00100001b = 00000000b
-00011110b & 00100010b = 00000010b
-00011110b & 00100011b = 00000010b
-00011110b & 00100100b = 00000100b
-00011110b & 00100101b = 00000100b
-00011110b & 00100110b = 00000110b
-00011110b & 00100111b = 00000110b
-00011110b & 00101000b = 00001000b
-00011110b & 00101001b = 00001000b
-00011110b & 00101010b = 00001010b
-00011110b & 00101011b = 00001010b
-00011110b & 00101100b = 00001100b
-00011110b & 00101101b = 00001100b
-00011110b & 00101110b = 00001110b
-00011110b & 00101111b = 00001110b
-00011110b & 00110000b = 00010000b
-00011110b & 00110001b = 00010000b
-00011110b & 00110010b = 00010010b
-00011110b & 00110011b = 00010010b
-00011110b & 00110100b = 00010100b
-00011110b & 00110101b = 00010100b
-00011110b & 00110110b = 00010110b
-00011110b & 00110111b = 00010110b
-00011110b & 00111000b = 00011000b
-00011110b & 00111001b = 00011000b
-00011110b & 00111010b = 00011010b
-00011110b & 00111011b = 00011010b
-00011110b & 00111100b = 00011100b
-00011110b & 00111101b = 00011100b
-00011110b & 00111110b = 00011110b
-00011110b & 00111111b = 00011110b
-00011110b & 01000000b = 00000000b
-00011110b & 01000001b = 00000000b
-00011110b & 01000010b = 00000010b
-00011110b & 01000011b = 00000010b
-00011110b & 01000100b = 00000100b
-00011110b & 01000101b = 00000100b
-00011110b & 01000110b = 00000110b
-00011110b & 01000111b = 00000110b
-00011110b & 01001000b = 00001000b
-00011110b & 01001001b = 00001000b
-00011110b & 01001010b = 00001010b
-00011110b & 01001011b = 00001010b
-00011110b & 01001100b = 00001100b
-00011110b & 01001101b = 00001100b
-00011110b & 01001110b = 00001110b
-00011110b & 01001111b = 00001110b
-00011110b & 01010000b = 00010000b
-00011110b & 01010001b = 00010000b
-00011110b & 01010010b = 00010010b
-00011110b & 01010011b = 00010010b
-00011110b & 01010100b = 00010100b
-00011110b & 01010101b = 00010100b
-00011110b & 01010110b = 00010110b
-00011110b & 01010111b = 00010110b
-00011110b & 01011000b = 00011000b
-00011110b & 01011001b = 00011000b
-00011110b & 01011010b = 00011010b
-00011110b & 01011011b = 00011010b
-00011110b & 01011100b = 00011100b
-00011110b & 01011101b = 00011100b
-00011110b & 01011110b = 00011110b
-00011110b & 01011111b = 00011110b
-00011110b & 01100000b = 00000000b
-00011110b & 01100001b = 00000000b
-00011110b & 01100010b = 00000010b
-00011110b & 01100011b = 00000010b
-00011110b & 01100100b = 00000100b
-00011110b & 01100101b = 00000100b
-00011110b & 01100110b = 00000110b
-00011110b & 01100111b = 00000110b
-00011110b & 01101000b = 00001000b
-00011110b & 01101001b = 00001000b
-00011110b & 01101010b = 00001010b
-00011110b & 01101011b = 00001010b
-00011110b & 01101100b = 00001100b
-00011110b & 01101101b = 00001100b
-00011110b & 01101110b = 00001110b
-00011110b & 01101111b = 00001110b
-00011110b & 01110000b = 00010000b
-00011110b & 01110001b = 00010000b
-00011110b & 01110010b = 00010010b
-00011110b & 01110011b = 00010010b
-00011110b & 01110100b = 00010100b
-00011110b & 01110101b = 00010100b
-00011110b & 01110110b = 00010110b
-00011110b & 01110111b = 00010110b
-00011110b & 01111000b = 00011000b
-00011110b & 01111001b = 00011000b
-00011110b & 01111010b = 00011010b
-00011110b & 01111011b = 00011010b
-00011110b & 01111100b = 00011100b
-00011110b & 01111101b = 00011100b
-00011110b & 01111110b = 00011110b
-00011111b & 10000000b = 00000000b
-00011111b & 10000001b = 00000001b
-00011111b & 10000010b = 00000010b
-00011111b & 10000011b = 00000011b
-00011111b & 10000100b = 00000100b
-00011111b & 10000101b = 00000101b
-00011111b & 10000110b = 00000110b
-00011111b & 10000111b = 00000111b
-00011111b & 10001000b = 00001000b
-00011111b & 10001001b = 00001001b
-00011111b & 10001010b = 00001010b
-00011111b & 10001011b = 00001011b
-00011111b & 10001100b = 00001100b
-00011111b & 10001101b = 00001101b
-00011111b & 10001110b = 00001110b
-00011111b & 10001111b = 00001111b
-00011111b & 10010000b = 00010000b
-00011111b & 10010001b = 00010001b
-00011111b & 10010010b = 00010010b
-00011111b & 10010011b = 00010011b
-00011111b & 10010100b = 00010100b
-00011111b & 10010101b = 00010101b
-00011111b & 10010110b = 00010110b
-00011111b & 10010111b = 00010111b
-00011111b & 10011000b = 00011000b
-00011111b & 10011001b = 00011001b
-00011111b & 10011010b = 00011010b
-00011111b & 10011011b = 00011011b
-00011111b & 10011100b = 00011100b
-00011111b & 10011101b = 00011101b
-00011111b & 10011110b = 00011110b
-00011111b & 10011111b = 00011111b
-00011111b & 10100000b = 00000000b
-00011111b & 10100001b = 00000001b
-00011111b & 10100010b = 00000010b
-00011111b & 10100011b = 00000011b
-00011111b & 10100100b = 00000100b
-00011111b & 10100101b = 00000101b
-00011111b & 10100110b = 00000110b
-00011111b & 10100111b = 00000111b
-00011111b & 10101000b = 00001000b
-00011111b & 10101001b = 00001001b
-00011111b & 10101010b = 00001010b
-00011111b & 10101011b = 00001011b
-00011111b & 10101100b = 00001100b
-00011111b & 10101101b = 00001101b
-00011111b & 10101110b = 00001110b
-00011111b & 10101111b = 00001111b
-00011111b & 10110000b = 00010000b
-00011111b & 10110001b = 00010001b
-00011111b & 10110010b = 00010010b
-00011111b & 10110011b = 00010011b
-00011111b & 10110100b = 00010100b
-00011111b & 10110101b = 00010101b
-00011111b & 10110110b = 00010110b
-00011111b & 10110111b = 00010111b
-00011111b & 10111000b = 00011000b
-00011111b & 10111001b = 00011001b
-00011111b & 10111010b = 00011010b
-00011111b & 10111011b = 00011011b
-00011111b & 10111100b = 00011100b
-00011111b & 10111101b = 00011101b
-00011111b & 10111110b = 00011110b
-00011111b & 10111111b = 00011111b
-00011111b & 11000000b = 00000000b
-00011111b & 11000001b = 00000001b
-00011111b & 11000010b = 00000010b
-00011111b & 11000011b = 00000011b
-00011111b & 11000100b = 00000100b
-00011111b & 11000101b = 00000101b
-00011111b & 11000110b = 00000110b
-00011111b & 11000111b = 00000111b
-00011111b & 11001000b = 00001000b
-00011111b & 11001001b = 00001001b
-00011111b & 11001010b = 00001010b
-00011111b & 11001011b = 00001011b
-00011111b & 11001100b = 00001100b
-00011111b & 11001101b = 00001101b
-00011111b & 11001110b = 00001110b
-00011111b & 11001111b = 00001111b
-00011111b & 11010000b = 00010000b
-00011111b & 11010001b = 00010001b
-00011111b & 11010010b = 00010010b
-00011111b & 11010011b = 00010011b
-00011111b & 11010100b = 00010100b
-00011111b & 11010101b = 00010101b
-00011111b & 11010110b = 00010110b
-00011111b & 11010111b = 00010111b
-00011111b & 11011000b = 00011000b
-00011111b & 11011001b = 00011001b
-00011111b & 11011010b = 00011010b
-00011111b & 11011011b = 00011011b
-00011111b & 11011100b = 00011100b
-00011111b & 11011101b = 00011101b
-00011111b & 11011110b = 00011110b
-00011111b & 11011111b = 00011111b
-00011111b & 11100000b = 00000000b
-00011111b & 11100001b = 00000001b
-00011111b & 11100010b = 00000010b
-00011111b & 11100011b = 00000011b
-00011111b & 11100100b = 00000100b
-00011111b & 11100101b = 00000101b
-00011111b & 11100110b = 00000110b
-00011111b & 11100111b = 00000111b
-00011111b & 11101000b = 00001000b
-00011111b & 11101001b = 00001001b
-00011111b & 11101010b = 00001010b
-00011111b & 11101011b = 00001011b
-00011111b & 11101100b = 00001100b
-00011111b & 11101101b = 00001101b
-00011111b & 11101110b = 00001110b
-00011111b & 11101111b = 00001111b
-00011111b & 11110000b = 00010000b
-00011111b & 11110001b = 00010001b
-00011111b & 11110010b = 00010010b
-00011111b & 11110011b = 00010011b
-00011111b & 11110100b = 00010100b
-00011111b & 11110101b = 00010101b
-00011111b & 11110110b = 00010110b
-00011111b & 11110111b = 00010111b
-00011111b & 11111000b = 00011000b
-00011111b & 11111001b = 00011001b
-00011111b & 11111010b = 00011010b
-00011111b & 11111011b = 00011011b
-00011111b & 11111100b = 00011100b
-00011111b & 11111101b = 00011101b
-00011111b & 11111110b = 00011110b
-00011111b & 11111111b = 00011111b
-00011111b & 00000000b = 00000000b
-00011111b & 00000001b = 00000001b
-00011111b & 00000010b = 00000010b
-00011111b & 00000011b = 00000011b
-00011111b & 00000100b = 00000100b
-00011111b & 00000101b = 00000101b
-00011111b & 00000110b = 00000110b
-00011111b & 00000111b = 00000111b
-00011111b & 00001000b = 00001000b
-00011111b & 00001001b = 00001001b
-00011111b & 00001010b = 00001010b
-00011111b & 00001011b = 00001011b
-00011111b & 00001100b = 00001100b
-00011111b & 00001101b = 00001101b
-00011111b & 00001110b = 00001110b
-00011111b & 00001111b = 00001111b
-00011111b & 00010000b = 00010000b
-00011111b & 00010001b = 00010001b
-00011111b & 00010010b = 00010010b
-00011111b & 00010011b = 00010011b
-00011111b & 00010100b = 00010100b
-00011111b & 00010101b = 00010101b
-00011111b & 00010110b = 00010110b
-00011111b & 00010111b = 00010111b
-00011111b & 00011000b = 00011000b
-00011111b & 00011001b = 00011001b
-00011111b & 00011010b = 00011010b
-00011111b & 00011011b = 00011011b
-00011111b & 00011100b = 00011100b
-00011111b & 00011101b = 00011101b
-00011111b & 00011110b = 00011110b
-00011111b & 00011111b = 00011111b
-00011111b & 00100000b = 00000000b
-00011111b & 00100001b = 00000001b
-00011111b & 00100010b = 00000010b
-00011111b & 00100011b = 00000011b
-00011111b & 00100100b = 00000100b
-00011111b & 00100101b = 00000101b
-00011111b & 00100110b = 00000110b
-00011111b & 00100111b = 00000111b
-00011111b & 00101000b = 00001000b
-00011111b & 00101001b = 00001001b
-00011111b & 00101010b = 00001010b
-00011111b & 00101011b = 00001011b
-00011111b & 00101100b = 00001100b
-00011111b & 00101101b = 00001101b
-00011111b & 00101110b = 00001110b
-00011111b & 00101111b = 00001111b
-00011111b & 00110000b = 00010000b
-00011111b & 00110001b = 00010001b
-00011111b & 00110010b = 00010010b
-00011111b & 00110011b = 00010011b
-00011111b & 00110100b = 00010100b
-00011111b & 00110101b = 00010101b
-00011111b & 00110110b = 00010110b
-00011111b & 00110111b = 00010111b
-00011111b & 00111000b = 00011000b
-00011111b & 00111001b = 00011001b
-00011111b & 00111010b = 00011010b
-00011111b & 00111011b = 00011011b
-00011111b & 00111100b = 00011100b
-00011111b & 00111101b = 00011101b
-00011111b & 00111110b = 00011110b
-00011111b & 00111111b = 00011111b
-00011111b & 01000000b = 00000000b
-00011111b & 01000001b = 00000001b
-00011111b & 01000010b = 00000010b
-00011111b & 01000011b = 00000011b
-00011111b & 01000100b = 00000100b
-00011111b & 01000101b = 00000101b
-00011111b & 01000110b = 00000110b
-00011111b & 01000111b = 00000111b
-00011111b & 01001000b = 00001000b
-00011111b & 01001001b = 00001001b
-00011111b & 01001010b = 00001010b
-00011111b & 01001011b = 00001011b
-00011111b & 01001100b = 00001100b
-00011111b & 01001101b = 00001101b
-00011111b & 01001110b = 00001110b
-00011111b & 01001111b = 00001111b
-00011111b & 01010000b = 00010000b
-00011111b & 01010001b = 00010001b
-00011111b & 01010010b = 00010010b
-00011111b & 01010011b = 00010011b
-00011111b & 01010100b = 00010100b
-00011111b & 01010101b = 00010101b
-00011111b & 01010110b = 00010110b
-00011111b & 01010111b = 00010111b
-00011111b & 01011000b = 00011000b
-00011111b & 01011001b = 00011001b
-00011111b & 01011010b = 00011010b
-00011111b & 01011011b = 00011011b
-00011111b & 01011100b = 00011100b
-00011111b & 01011101b = 00011101b
-00011111b & 01011110b = 00011110b
-00011111b & 01011111b = 00011111b
-00011111b & 01100000b = 00000000b
-00011111b & 01100001b = 00000001b
-00011111b & 01100010b = 00000010b
-00011111b & 01100011b = 00000011b
-00011111b & 01100100b = 00000100b
-00011111b & 01100101b = 00000101b
-00011111b & 01100110b = 00000110b
-00011111b & 01100111b = 00000111b
-00011111b & 01101000b = 00001000b
-00011111b & 01101001b = 00001001b
-00011111b & 01101010b = 00001010b
-00011111b & 01101011b = 00001011b
-00011111b & 01101100b = 00001100b
-00011111b & 01101101b = 00001101b
-00011111b & 01101110b = 00001110b
-00011111b & 01101111b = 00001111b
-00011111b & 01110000b = 00010000b
-00011111b & 01110001b = 00010001b
-00011111b & 01110010b = 00010010b
-00011111b & 01110011b = 00010011b
-00011111b & 01110100b = 00010100b
-00011111b & 01110101b = 00010101b
-00011111b & 01110110b = 00010110b
-00011111b & 01110111b = 00010111b
-00011111b & 01111000b = 00011000b
-00011111b & 01111001b = 00011001b
-00011111b & 01111010b = 00011010b
-00011111b & 01111011b = 00011011b
-00011111b & 01111100b = 00011100b
-00011111b & 01111101b = 00011101b
-00011111b & 01111110b = 00011110b
-00100000b & 10000000b = 00000000b
-00100000b & 10000001b = 00000000b
-00100000b & 10000010b = 00000000b
-00100000b & 10000011b = 00000000b
-00100000b & 10000100b = 00000000b
-00100000b & 10000101b = 00000000b
-00100000b & 10000110b = 00000000b
-00100000b & 10000111b = 00000000b
-00100000b & 10001000b = 00000000b
-00100000b & 10001001b = 00000000b
-00100000b & 10001010b = 00000000b
-00100000b & 10001011b = 00000000b
-00100000b & 10001100b = 00000000b
-00100000b & 10001101b = 00000000b
-00100000b & 10001110b = 00000000b
-00100000b & 10001111b = 00000000b
-00100000b & 10010000b = 00000000b
-00100000b & 10010001b = 00000000b
-00100000b & 10010010b = 00000000b
-00100000b & 10010011b = 00000000b
-00100000b & 10010100b = 00000000b
-00100000b & 10010101b = 00000000b
-00100000b & 10010110b = 00000000b
-00100000b & 10010111b = 00000000b
-00100000b & 10011000b = 00000000b
-00100000b & 10011001b = 00000000b
-00100000b & 10011010b = 00000000b
-00100000b & 10011011b = 00000000b
-00100000b & 10011100b = 00000000b
-00100000b & 10011101b = 00000000b
-00100000b & 10011110b = 00000000b
-00100000b & 10011111b = 00000000b
-00100000b & 10100000b = 00100000b
-00100000b & 10100001b = 00100000b
-00100000b & 10100010b = 00100000b
-00100000b & 10100011b = 00100000b
-00100000b & 10100100b = 00100000b
-00100000b & 10100101b = 00100000b
-00100000b & 10100110b = 00100000b
-00100000b & 10100111b = 00100000b
-00100000b & 10101000b = 00100000b
-00100000b & 10101001b = 00100000b
-00100000b & 10101010b = 00100000b
-00100000b & 10101011b = 00100000b
-00100000b & 10101100b = 00100000b
-00100000b & 10101101b = 00100000b
-00100000b & 10101110b = 00100000b
-00100000b & 10101111b = 00100000b
-00100000b & 10110000b = 00100000b
-00100000b & 10110001b = 00100000b
-00100000b & 10110010b = 00100000b
-00100000b & 10110011b = 00100000b
-00100000b & 10110100b = 00100000b
-00100000b & 10110101b = 00100000b
-00100000b & 10110110b = 00100000b
-00100000b & 10110111b = 00100000b
-00100000b & 10111000b = 00100000b
-00100000b & 10111001b = 00100000b
-00100000b & 10111010b = 00100000b
-00100000b & 10111011b = 00100000b
-00100000b & 10111100b = 00100000b
-00100000b & 10111101b = 00100000b
-00100000b & 10111110b = 00100000b
-00100000b & 10111111b = 00100000b
-00100000b & 11000000b = 00000000b
-00100000b & 11000001b = 00000000b
-00100000b & 11000010b = 00000000b
-00100000b & 11000011b = 00000000b
-00100000b & 11000100b = 00000000b
-00100000b & 11000101b = 00000000b
-00100000b & 11000110b = 00000000b
-00100000b & 11000111b = 00000000b
-00100000b & 11001000b = 00000000b
-00100000b & 11001001b = 00000000b
-00100000b & 11001010b = 00000000b
-00100000b & 11001011b = 00000000b
-00100000b & 11001100b = 00000000b
-00100000b & 11001101b = 00000000b
-00100000b & 11001110b = 00000000b
-00100000b & 11001111b = 00000000b
-00100000b & 11010000b = 00000000b
-00100000b & 11010001b = 00000000b
-00100000b & 11010010b = 00000000b
-00100000b & 11010011b = 00000000b
-00100000b & 11010100b = 00000000b
-00100000b & 11010101b = 00000000b
-00100000b & 11010110b = 00000000b
-00100000b & 11010111b = 00000000b
-00100000b & 11011000b = 00000000b
-00100000b & 11011001b = 00000000b
-00100000b & 11011010b = 00000000b
-00100000b & 11011011b = 00000000b
-00100000b & 11011100b = 00000000b
-00100000b & 11011101b = 00000000b
-00100000b & 11011110b = 00000000b
-00100000b & 11011111b = 00000000b
-00100000b & 11100000b = 00100000b
-00100000b & 11100001b = 00100000b
-00100000b & 11100010b = 00100000b
-00100000b & 11100011b = 00100000b
-00100000b & 11100100b = 00100000b
-00100000b & 11100101b = 00100000b
-00100000b & 11100110b = 00100000b
-00100000b & 11100111b = 00100000b
-00100000b & 11101000b = 00100000b
-00100000b & 11101001b = 00100000b
-00100000b & 11101010b = 00100000b
-00100000b & 11101011b = 00100000b
-00100000b & 11101100b = 00100000b
-00100000b & 11101101b = 00100000b
-00100000b & 11101110b = 00100000b
-00100000b & 11101111b = 00100000b
-00100000b & 11110000b = 00100000b
-00100000b & 11110001b = 00100000b
-00100000b & 11110010b = 00100000b
-00100000b & 11110011b = 00100000b
-00100000b & 11110100b = 00100000b
-00100000b & 11110101b = 00100000b
-00100000b & 11110110b = 00100000b
-00100000b & 11110111b = 00100000b
-00100000b & 11111000b = 00100000b
-00100000b & 11111001b = 00100000b
-00100000b & 11111010b = 00100000b
-00100000b & 11111011b = 00100000b
-00100000b & 11111100b = 00100000b
-00100000b & 11111101b = 00100000b
-00100000b & 11111110b = 00100000b
-00100000b & 11111111b = 00100000b
-00100000b & 00000000b = 00000000b
-00100000b & 00000001b = 00000000b
-00100000b & 00000010b = 00000000b
-00100000b & 00000011b = 00000000b
-00100000b & 00000100b = 00000000b
-00100000b & 00000101b = 00000000b
-00100000b & 00000110b = 00000000b
-00100000b & 00000111b = 00000000b
-00100000b & 00001000b = 00000000b
-00100000b & 00001001b = 00000000b
-00100000b & 00001010b = 00000000b
-00100000b & 00001011b = 00000000b
-00100000b & 00001100b = 00000000b
-00100000b & 00001101b = 00000000b
-00100000b & 00001110b = 00000000b
-00100000b & 00001111b = 00000000b
-00100000b & 00010000b = 00000000b
-00100000b & 00010001b = 00000000b
-00100000b & 00010010b = 00000000b
-00100000b & 00010011b = 00000000b
-00100000b & 00010100b = 00000000b
-00100000b & 00010101b = 00000000b
-00100000b & 00010110b = 00000000b
-00100000b & 00010111b = 00000000b
-00100000b & 00011000b = 00000000b
-00100000b & 00011001b = 00000000b
-00100000b & 00011010b = 00000000b
-00100000b & 00011011b = 00000000b
-00100000b & 00011100b = 00000000b
-00100000b & 00011101b = 00000000b
-00100000b & 00011110b = 00000000b
-00100000b & 00011111b = 00000000b
-00100000b & 00100000b = 00100000b
-00100000b & 00100001b = 00100000b
-00100000b & 00100010b = 00100000b
-00100000b & 00100011b = 00100000b
-00100000b & 00100100b = 00100000b
-00100000b & 00100101b = 00100000b
-00100000b & 00100110b = 00100000b
-00100000b & 00100111b = 00100000b
-00100000b & 00101000b = 00100000b
-00100000b & 00101001b = 00100000b
-00100000b & 00101010b = 00100000b
-00100000b & 00101011b = 00100000b
-00100000b & 00101100b = 00100000b
-00100000b & 00101101b = 00100000b
-00100000b & 00101110b = 00100000b
-00100000b & 00101111b = 00100000b
-00100000b & 00110000b = 00100000b
-00100000b & 00110001b = 00100000b
-00100000b & 00110010b = 00100000b
-00100000b & 00110011b = 00100000b
-00100000b & 00110100b = 00100000b
-00100000b & 00110101b = 00100000b
-00100000b & 00110110b = 00100000b
-00100000b & 00110111b = 00100000b
-00100000b & 00111000b = 00100000b
-00100000b & 00111001b = 00100000b
-00100000b & 00111010b = 00100000b
-00100000b & 00111011b = 00100000b
-00100000b & 00111100b = 00100000b
-00100000b & 00111101b = 00100000b
-00100000b & 00111110b = 00100000b
-00100000b & 00111111b = 00100000b
-00100000b & 01000000b = 00000000b
-00100000b & 01000001b = 00000000b
-00100000b & 01000010b = 00000000b
-00100000b & 01000011b = 00000000b
-00100000b & 01000100b = 00000000b
-00100000b & 01000101b = 00000000b
-00100000b & 01000110b = 00000000b
-00100000b & 01000111b = 00000000b
-00100000b & 01001000b = 00000000b
-00100000b & 01001001b = 00000000b
-00100000b & 01001010b = 00000000b
-00100000b & 01001011b = 00000000b
-00100000b & 01001100b = 00000000b
-00100000b & 01001101b = 00000000b
-00100000b & 01001110b = 00000000b
-00100000b & 01001111b = 00000000b
-00100000b & 01010000b = 00000000b
-00100000b & 01010001b = 00000000b
-00100000b & 01010010b = 00000000b
-00100000b & 01010011b = 00000000b
-00100000b & 01010100b = 00000000b
-00100000b & 01010101b = 00000000b
-00100000b & 01010110b = 00000000b
-00100000b & 01010111b = 00000000b
-00100000b & 01011000b = 00000000b
-00100000b & 01011001b = 00000000b
-00100000b & 01011010b = 00000000b
-00100000b & 01011011b = 00000000b
-00100000b & 01011100b = 00000000b
-00100000b & 01011101b = 00000000b
-00100000b & 01011110b = 00000000b
-00100000b & 01011111b = 00000000b
-00100000b & 01100000b = 00100000b
-00100000b & 01100001b = 00100000b
-00100000b & 01100010b = 00100000b
-00100000b & 01100011b = 00100000b
-00100000b & 01100100b = 00100000b
-00100000b & 01100101b = 00100000b
-00100000b & 01100110b = 00100000b
-00100000b & 01100111b = 00100000b
-00100000b & 01101000b = 00100000b
-00100000b & 01101001b = 00100000b
-00100000b & 01101010b = 00100000b
-00100000b & 01101011b = 00100000b
-00100000b & 01101100b = 00100000b
-00100000b & 01101101b = 00100000b
-00100000b & 01101110b = 00100000b
-00100000b & 01101111b = 00100000b
-00100000b & 01110000b = 00100000b
-00100000b & 01110001b = 00100000b
-00100000b & 01110010b = 00100000b
-00100000b & 01110011b = 00100000b
-00100000b & 01110100b = 00100000b
-00100000b & 01110101b = 00100000b
-00100000b & 01110110b = 00100000b
-00100000b & 01110111b = 00100000b
-00100000b & 01111000b = 00100000b
-00100000b & 01111001b = 00100000b
-00100000b & 01111010b = 00100000b
-00100000b & 01111011b = 00100000b
-00100000b & 01111100b = 00100000b
-00100000b & 01111101b = 00100000b
-00100000b & 01111110b = 00100000b
-00100001b & 10000000b = 00000000b
-00100001b & 10000001b = 00000001b
-00100001b & 10000010b = 00000000b
-00100001b & 10000011b = 00000001b
-00100001b & 10000100b = 00000000b
-00100001b & 10000101b = 00000001b
-00100001b & 10000110b = 00000000b
-00100001b & 10000111b = 00000001b
-00100001b & 10001000b = 00000000b
-00100001b & 10001001b = 00000001b
-00100001b & 10001010b = 00000000b
-00100001b & 10001011b = 00000001b
-00100001b & 10001100b = 00000000b
-00100001b & 10001101b = 00000001b
-00100001b & 10001110b = 00000000b
-00100001b & 10001111b = 00000001b
-00100001b & 10010000b = 00000000b
-00100001b & 10010001b = 00000001b
-00100001b & 10010010b = 00000000b
-00100001b & 10010011b = 00000001b
-00100001b & 10010100b = 00000000b
-00100001b & 10010101b = 00000001b
-00100001b & 10010110b = 00000000b
-00100001b & 10010111b = 00000001b
-00100001b & 10011000b = 00000000b
-00100001b & 10011001b = 00000001b
-00100001b & 10011010b = 00000000b
-00100001b & 10011011b = 00000001b
-00100001b & 10011100b = 00000000b
-00100001b & 10011101b = 00000001b
-00100001b & 10011110b = 00000000b
-00100001b & 10011111b = 00000001b
-00100001b & 10100000b = 00100000b
-00100001b & 10100001b = 00100001b
-00100001b & 10100010b = 00100000b
-00100001b & 10100011b = 00100001b
-00100001b & 10100100b = 00100000b
-00100001b & 10100101b = 00100001b
-00100001b & 10100110b = 00100000b
-00100001b & 10100111b = 00100001b
-00100001b & 10101000b = 00100000b
-00100001b & 10101001b = 00100001b
-00100001b & 10101010b = 00100000b
-00100001b & 10101011b = 00100001b
-00100001b & 10101100b = 00100000b
-00100001b & 10101101b = 00100001b
-00100001b & 10101110b = 00100000b
-00100001b & 10101111b = 00100001b
-00100001b & 10110000b = 00100000b
-00100001b & 10110001b = 00100001b
-00100001b & 10110010b = 00100000b
-00100001b & 10110011b = 00100001b
-00100001b & 10110100b = 00100000b
-00100001b & 10110101b = 00100001b
-00100001b & 10110110b = 00100000b
-00100001b & 10110111b = 00100001b
-00100001b & 10111000b = 00100000b
-00100001b & 10111001b = 00100001b
-00100001b & 10111010b = 00100000b
-00100001b & 10111011b = 00100001b
-00100001b & 10111100b = 00100000b
-00100001b & 10111101b = 00100001b
-00100001b & 10111110b = 00100000b
-00100001b & 10111111b = 00100001b
-00100001b & 11000000b = 00000000b
-00100001b & 11000001b = 00000001b
-00100001b & 11000010b = 00000000b
-00100001b & 11000011b = 00000001b
-00100001b & 11000100b = 00000000b
-00100001b & 11000101b = 00000001b
-00100001b & 11000110b = 00000000b
-00100001b & 11000111b = 00000001b
-00100001b & 11001000b = 00000000b
-00100001b & 11001001b = 00000001b
-00100001b & 11001010b = 00000000b
-00100001b & 11001011b = 00000001b
-00100001b & 11001100b = 00000000b
-00100001b & 11001101b = 00000001b
-00100001b & 11001110b = 00000000b
-00100001b & 11001111b = 00000001b
-00100001b & 11010000b = 00000000b
-00100001b & 11010001b = 00000001b
-00100001b & 11010010b = 00000000b
-00100001b & 11010011b = 00000001b
-00100001b & 11010100b = 00000000b
-00100001b & 11010101b = 00000001b
-00100001b & 11010110b = 00000000b
-00100001b & 11010111b = 00000001b
-00100001b & 11011000b = 00000000b
-00100001b & 11011001b = 00000001b
-00100001b & 11011010b = 00000000b
-00100001b & 11011011b = 00000001b
-00100001b & 11011100b = 00000000b
-00100001b & 11011101b = 00000001b
-00100001b & 11011110b = 00000000b
-00100001b & 11011111b = 00000001b
-00100001b & 11100000b = 00100000b
-00100001b & 11100001b = 00100001b
-00100001b & 11100010b = 00100000b
-00100001b & 11100011b = 00100001b
-00100001b & 11100100b = 00100000b
-00100001b & 11100101b = 00100001b
-00100001b & 11100110b = 00100000b
-00100001b & 11100111b = 00100001b
-00100001b & 11101000b = 00100000b
-00100001b & 11101001b = 00100001b
-00100001b & 11101010b = 00100000b
-00100001b & 11101011b = 00100001b
-00100001b & 11101100b = 00100000b
-00100001b & 11101101b = 00100001b
-00100001b & 11101110b = 00100000b
-00100001b & 11101111b = 00100001b
-00100001b & 11110000b = 00100000b
-00100001b & 11110001b = 00100001b
-00100001b & 11110010b = 00100000b
-00100001b & 11110011b = 00100001b
-00100001b & 11110100b = 00100000b
-00100001b & 11110101b = 00100001b
-00100001b & 11110110b = 00100000b
-00100001b & 11110111b = 00100001b
-00100001b & 11111000b = 00100000b
-00100001b & 11111001b = 00100001b
-00100001b & 11111010b = 00100000b
-00100001b & 11111011b = 00100001b
-00100001b & 11111100b = 00100000b
-00100001b & 11111101b = 00100001b
-00100001b & 11111110b = 00100000b
-00100001b & 11111111b = 00100001b
-00100001b & 00000000b = 00000000b
-00100001b & 00000001b = 00000001b
-00100001b & 00000010b = 00000000b
-00100001b & 00000011b = 00000001b
-00100001b & 00000100b = 00000000b
-00100001b & 00000101b = 00000001b
-00100001b & 00000110b = 00000000b
-00100001b & 00000111b = 00000001b
-00100001b & 00001000b = 00000000b
-00100001b & 00001001b = 00000001b
-00100001b & 00001010b = 00000000b
-00100001b & 00001011b = 00000001b
-00100001b & 00001100b = 00000000b
-00100001b & 00001101b = 00000001b
-00100001b & 00001110b = 00000000b
-00100001b & 00001111b = 00000001b
-00100001b & 00010000b = 00000000b
-00100001b & 00010001b = 00000001b
-00100001b & 00010010b = 00000000b
-00100001b & 00010011b = 00000001b
-00100001b & 00010100b = 00000000b
-00100001b & 00010101b = 00000001b
-00100001b & 00010110b = 00000000b
-00100001b & 00010111b = 00000001b
-00100001b & 00011000b = 00000000b
-00100001b & 00011001b = 00000001b
-00100001b & 00011010b = 00000000b
-00100001b & 00011011b = 00000001b
-00100001b & 00011100b = 00000000b
-00100001b & 00011101b = 00000001b
-00100001b & 00011110b = 00000000b
-00100001b & 00011111b = 00000001b
-00100001b & 00100000b = 00100000b
-00100001b & 00100001b = 00100001b
-00100001b & 00100010b = 00100000b
-00100001b & 00100011b = 00100001b
-00100001b & 00100100b = 00100000b
-00100001b & 00100101b = 00100001b
-00100001b & 00100110b = 00100000b
-00100001b & 00100111b = 00100001b
-00100001b & 00101000b = 00100000b
-00100001b & 00101001b = 00100001b
-00100001b & 00101010b = 00100000b
-00100001b & 00101011b = 00100001b
-00100001b & 00101100b = 00100000b
-00100001b & 00101101b = 00100001b
-00100001b & 00101110b = 00100000b
-00100001b & 00101111b = 00100001b
-00100001b & 00110000b = 00100000b
-00100001b & 00110001b = 00100001b
-00100001b & 00110010b = 00100000b
-00100001b & 00110011b = 00100001b
-00100001b & 00110100b = 00100000b
-00100001b & 00110101b = 00100001b
-00100001b & 00110110b = 00100000b
-00100001b & 00110111b = 00100001b
-00100001b & 00111000b = 00100000b
-00100001b & 00111001b = 00100001b
-00100001b & 00111010b = 00100000b
-00100001b & 00111011b = 00100001b
-00100001b & 00111100b = 00100000b
-00100001b & 00111101b = 00100001b
-00100001b & 00111110b = 00100000b
-00100001b & 00111111b = 00100001b
-00100001b & 01000000b = 00000000b
-00100001b & 01000001b = 00000001b
-00100001b & 01000010b = 00000000b
-00100001b & 01000011b = 00000001b
-00100001b & 01000100b = 00000000b
-00100001b & 01000101b = 00000001b
-00100001b & 01000110b = 00000000b
-00100001b & 01000111b = 00000001b
-00100001b & 01001000b = 00000000b
-00100001b & 01001001b = 00000001b
-00100001b & 01001010b = 00000000b
-00100001b & 01001011b = 00000001b
-00100001b & 01001100b = 00000000b
-00100001b & 01001101b = 00000001b
-00100001b & 01001110b = 00000000b
-00100001b & 01001111b = 00000001b
-00100001b & 01010000b = 00000000b
-00100001b & 01010001b = 00000001b
-00100001b & 01010010b = 00000000b
-00100001b & 01010011b = 00000001b
-00100001b & 01010100b = 00000000b
-00100001b & 01010101b = 00000001b
-00100001b & 01010110b = 00000000b
-00100001b & 01010111b = 00000001b
-00100001b & 01011000b = 00000000b
-00100001b & 01011001b = 00000001b
-00100001b & 01011010b = 00000000b
-00100001b & 01011011b = 00000001b
-00100001b & 01011100b = 00000000b
-00100001b & 01011101b = 00000001b
-00100001b & 01011110b = 00000000b
-00100001b & 01011111b = 00000001b
-00100001b & 01100000b = 00100000b
-00100001b & 01100001b = 00100001b
-00100001b & 01100010b = 00100000b
-00100001b & 01100011b = 00100001b
-00100001b & 01100100b = 00100000b
-00100001b & 01100101b = 00100001b
-00100001b & 01100110b = 00100000b
-00100001b & 01100111b = 00100001b
-00100001b & 01101000b = 00100000b
-00100001b & 01101001b = 00100001b
-00100001b & 01101010b = 00100000b
-00100001b & 01101011b = 00100001b
-00100001b & 01101100b = 00100000b
-00100001b & 01101101b = 00100001b
-00100001b & 01101110b = 00100000b
-00100001b & 01101111b = 00100001b
-00100001b & 01110000b = 00100000b
-00100001b & 01110001b = 00100001b
-00100001b & 01110010b = 00100000b
-00100001b & 01110011b = 00100001b
-00100001b & 01110100b = 00100000b
-00100001b & 01110101b = 00100001b
-00100001b & 01110110b = 00100000b
-00100001b & 01110111b = 00100001b
-00100001b & 01111000b = 00100000b
-00100001b & 01111001b = 00100001b
-00100001b & 01111010b = 00100000b
-00100001b & 01111011b = 00100001b
-00100001b & 01111100b = 00100000b
-00100001b & 01111101b = 00100001b
-00100001b & 01111110b = 00100000b
-00100010b & 10000000b = 00000000b
-00100010b & 10000001b = 00000000b
-00100010b & 10000010b = 00000010b
-00100010b & 10000011b = 00000010b
-00100010b & 10000100b = 00000000b
-00100010b & 10000101b = 00000000b
-00100010b & 10000110b = 00000010b
-00100010b & 10000111b = 00000010b
-00100010b & 10001000b = 00000000b
-00100010b & 10001001b = 00000000b
-00100010b & 10001010b = 00000010b
-00100010b & 10001011b = 00000010b
-00100010b & 10001100b = 00000000b
-00100010b & 10001101b = 00000000b
-00100010b & 10001110b = 00000010b
-00100010b & 10001111b = 00000010b
-00100010b & 10010000b = 00000000b
-00100010b & 10010001b = 00000000b
-00100010b & 10010010b = 00000010b
-00100010b & 10010011b = 00000010b
-00100010b & 10010100b = 00000000b
-00100010b & 10010101b = 00000000b
-00100010b & 10010110b = 00000010b
-00100010b & 10010111b = 00000010b
-00100010b & 10011000b = 00000000b
-00100010b & 10011001b = 00000000b
-00100010b & 10011010b = 00000010b
-00100010b & 10011011b = 00000010b
-00100010b & 10011100b = 00000000b
-00100010b & 10011101b = 00000000b
-00100010b & 10011110b = 00000010b
-00100010b & 10011111b = 00000010b
-00100010b & 10100000b = 00100000b
-00100010b & 10100001b = 00100000b
-00100010b & 10100010b = 00100010b
-00100010b & 10100011b = 00100010b
-00100010b & 10100100b = 00100000b
-00100010b & 10100101b = 00100000b
-00100010b & 10100110b = 00100010b
-00100010b & 10100111b = 00100010b
-00100010b & 10101000b = 00100000b
-00100010b & 10101001b = 00100000b
-00100010b & 10101010b = 00100010b
-00100010b & 10101011b = 00100010b
-00100010b & 10101100b = 00100000b
-00100010b & 10101101b = 00100000b
-00100010b & 10101110b = 00100010b
-00100010b & 10101111b = 00100010b
-00100010b & 10110000b = 00100000b
-00100010b & 10110001b = 00100000b
-00100010b & 10110010b = 00100010b
-00100010b & 10110011b = 00100010b
-00100010b & 10110100b = 00100000b
-00100010b & 10110101b = 00100000b
-00100010b & 10110110b = 00100010b
-00100010b & 10110111b = 00100010b
-00100010b & 10111000b = 00100000b
-00100010b & 10111001b = 00100000b
-00100010b & 10111010b = 00100010b
-00100010b & 10111011b = 00100010b
-00100010b & 10111100b = 00100000b
-00100010b & 10111101b = 00100000b
-00100010b & 10111110b = 00100010b
-00100010b & 10111111b = 00100010b
-00100010b & 11000000b = 00000000b
-00100010b & 11000001b = 00000000b
-00100010b & 11000010b = 00000010b
-00100010b & 11000011b = 00000010b
-00100010b & 11000100b = 00000000b
-00100010b & 11000101b = 00000000b
-00100010b & 11000110b = 00000010b
-00100010b & 11000111b = 00000010b
-00100010b & 11001000b = 00000000b
-00100010b & 11001001b = 00000000b
-00100010b & 11001010b = 00000010b
-00100010b & 11001011b = 00000010b
-00100010b & 11001100b = 00000000b
-00100010b & 11001101b = 00000000b
-00100010b & 11001110b = 00000010b
-00100010b & 11001111b = 00000010b
-00100010b & 11010000b = 00000000b
-00100010b & 11010001b = 00000000b
-00100010b & 11010010b = 00000010b
-00100010b & 11010011b = 00000010b
-00100010b & 11010100b = 00000000b
-00100010b & 11010101b = 00000000b
-00100010b & 11010110b = 00000010b
-00100010b & 11010111b = 00000010b
-00100010b & 11011000b = 00000000b
-00100010b & 11011001b = 00000000b
-00100010b & 11011010b = 00000010b
-00100010b & 11011011b = 00000010b
-00100010b & 11011100b = 00000000b
-00100010b & 11011101b = 00000000b
-00100010b & 11011110b = 00000010b
-00100010b & 11011111b = 00000010b
-00100010b & 11100000b = 00100000b
-00100010b & 11100001b = 00100000b
-00100010b & 11100010b = 00100010b
-00100010b & 11100011b = 00100010b
-00100010b & 11100100b = 00100000b
-00100010b & 11100101b = 00100000b
-00100010b & 11100110b = 00100010b
-00100010b & 11100111b = 00100010b
-00100010b & 11101000b = 00100000b
-00100010b & 11101001b = 00100000b
-00100010b & 11101010b = 00100010b
-00100010b & 11101011b = 00100010b
-00100010b & 11101100b = 00100000b
-00100010b & 11101101b = 00100000b
-00100010b & 11101110b = 00100010b
-00100010b & 11101111b = 00100010b
-00100010b & 11110000b = 00100000b
-00100010b & 11110001b = 00100000b
-00100010b & 11110010b = 00100010b
-00100010b & 11110011b = 00100010b
-00100010b & 11110100b = 00100000b
-00100010b & 11110101b = 00100000b
-00100010b & 11110110b = 00100010b
-00100010b & 11110111b = 00100010b
-00100010b & 11111000b = 00100000b
-00100010b & 11111001b = 00100000b
-00100010b & 11111010b = 00100010b
-00100010b & 11111011b = 00100010b
-00100010b & 11111100b = 00100000b
-00100010b & 11111101b = 00100000b
-00100010b & 11111110b = 00100010b
-00100010b & 11111111b = 00100010b
-00100010b & 00000000b = 00000000b
-00100010b & 00000001b = 00000000b
-00100010b & 00000010b = 00000010b
-00100010b & 00000011b = 00000010b
-00100010b & 00000100b = 00000000b
-00100010b & 00000101b = 00000000b
-00100010b & 00000110b = 00000010b
-00100010b & 00000111b = 00000010b
-00100010b & 00001000b = 00000000b
-00100010b & 00001001b = 00000000b
-00100010b & 00001010b = 00000010b
-00100010b & 00001011b = 00000010b
-00100010b & 00001100b = 00000000b
-00100010b & 00001101b = 00000000b
-00100010b & 00001110b = 00000010b
-00100010b & 00001111b = 00000010b
-00100010b & 00010000b = 00000000b
-00100010b & 00010001b = 00000000b
-00100010b & 00010010b = 00000010b
-00100010b & 00010011b = 00000010b
-00100010b & 00010100b = 00000000b
-00100010b & 00010101b = 00000000b
-00100010b & 00010110b = 00000010b
-00100010b & 00010111b = 00000010b
-00100010b & 00011000b = 00000000b
-00100010b & 00011001b = 00000000b
-00100010b & 00011010b = 00000010b
-00100010b & 00011011b = 00000010b
-00100010b & 00011100b = 00000000b
-00100010b & 00011101b = 00000000b
-00100010b & 00011110b = 00000010b
-00100010b & 00011111b = 00000010b
-00100010b & 00100000b = 00100000b
-00100010b & 00100001b = 00100000b
-00100010b & 00100010b = 00100010b
-00100010b & 00100011b = 00100010b
-00100010b & 00100100b = 00100000b
-00100010b & 00100101b = 00100000b
-00100010b & 00100110b = 00100010b
-00100010b & 00100111b = 00100010b
-00100010b & 00101000b = 00100000b
-00100010b & 00101001b = 00100000b
-00100010b & 00101010b = 00100010b
-00100010b & 00101011b = 00100010b
-00100010b & 00101100b = 00100000b
-00100010b & 00101101b = 00100000b
-00100010b & 00101110b = 00100010b
-00100010b & 00101111b = 00100010b
-00100010b & 00110000b = 00100000b
-00100010b & 00110001b = 00100000b
-00100010b & 00110010b = 00100010b
-00100010b & 00110011b = 00100010b
-00100010b & 00110100b = 00100000b
-00100010b & 00110101b = 00100000b
-00100010b & 00110110b = 00100010b
-00100010b & 00110111b = 00100010b
-00100010b & 00111000b = 00100000b
-00100010b & 00111001b = 00100000b
-00100010b & 00111010b = 00100010b
-00100010b & 00111011b = 00100010b
-00100010b & 00111100b = 00100000b
-00100010b & 00111101b = 00100000b
-00100010b & 00111110b = 00100010b
-00100010b & 00111111b = 00100010b
-00100010b & 01000000b = 00000000b
-00100010b & 01000001b = 00000000b
-00100010b & 01000010b = 00000010b
-00100010b & 01000011b = 00000010b
-00100010b & 01000100b = 00000000b
-00100010b & 01000101b = 00000000b
-00100010b & 01000110b = 00000010b
-00100010b & 01000111b = 00000010b
-00100010b & 01001000b = 00000000b
-00100010b & 01001001b = 00000000b
-00100010b & 01001010b = 00000010b
-00100010b & 01001011b = 00000010b
-00100010b & 01001100b = 00000000b
-00100010b & 01001101b = 00000000b
-00100010b & 01001110b = 00000010b
-00100010b & 01001111b = 00000010b
-00100010b & 01010000b = 00000000b
-00100010b & 01010001b = 00000000b
-00100010b & 01010010b = 00000010b
-00100010b & 01010011b = 00000010b
-00100010b & 01010100b = 00000000b
-00100010b & 01010101b = 00000000b
-00100010b & 01010110b = 00000010b
-00100010b & 01010111b = 00000010b
-00100010b & 01011000b = 00000000b
-00100010b & 01011001b = 00000000b
-00100010b & 01011010b = 00000010b
-00100010b & 01011011b = 00000010b
-00100010b & 01011100b = 00000000b
-00100010b & 01011101b = 00000000b
-00100010b & 01011110b = 00000010b
-00100010b & 01011111b = 00000010b
-00100010b & 01100000b = 00100000b
-00100010b & 01100001b = 00100000b
-00100010b & 01100010b = 00100010b
-00100010b & 01100011b = 00100010b
-00100010b & 01100100b = 00100000b
-00100010b & 01100101b = 00100000b
-00100010b & 01100110b = 00100010b
-00100010b & 01100111b = 00100010b
-00100010b & 01101000b = 00100000b
-00100010b & 01101001b = 00100000b
-00100010b & 01101010b = 00100010b
-00100010b & 01101011b = 00100010b
-00100010b & 01101100b = 00100000b
-00100010b & 01101101b = 00100000b
-00100010b & 01101110b = 00100010b
-00100010b & 01101111b = 00100010b
-00100010b & 01110000b = 00100000b
-00100010b & 01110001b = 00100000b
-00100010b & 01110010b = 00100010b
-00100010b & 01110011b = 00100010b
-00100010b & 01110100b = 00100000b
-00100010b & 01110101b = 00100000b
-00100010b & 01110110b = 00100010b
-00100010b & 01110111b = 00100010b
-00100010b & 01111000b = 00100000b
-00100010b & 01111001b = 00100000b
-00100010b & 01111010b = 00100010b
-00100010b & 01111011b = 00100010b
-00100010b & 01111100b = 00100000b
-00100010b & 01111101b = 00100000b
-00100010b & 01111110b = 00100010b
-00100011b & 10000000b = 00000000b
-00100011b & 10000001b = 00000001b
-00100011b & 10000010b = 00000010b
-00100011b & 10000011b = 00000011b
-00100011b & 10000100b = 00000000b
-00100011b & 10000101b = 00000001b
-00100011b & 10000110b = 00000010b
-00100011b & 10000111b = 00000011b
-00100011b & 10001000b = 00000000b
-00100011b & 10001001b = 00000001b
-00100011b & 10001010b = 00000010b
-00100011b & 10001011b = 00000011b
-00100011b & 10001100b = 00000000b
-00100011b & 10001101b = 00000001b
-00100011b & 10001110b = 00000010b
-00100011b & 10001111b = 00000011b
-00100011b & 10010000b = 00000000b
-00100011b & 10010001b = 00000001b
-00100011b & 10010010b = 00000010b
-00100011b & 10010011b = 00000011b
-00100011b & 10010100b = 00000000b
-00100011b & 10010101b = 00000001b
-00100011b & 10010110b = 00000010b
-00100011b & 10010111b = 00000011b
-00100011b & 10011000b = 00000000b
-00100011b & 10011001b = 00000001b
-00100011b & 10011010b = 00000010b
-00100011b & 10011011b = 00000011b
-00100011b & 10011100b = 00000000b
-00100011b & 10011101b = 00000001b
-00100011b & 10011110b = 00000010b
-00100011b & 10011111b = 00000011b
-00100011b & 10100000b = 00100000b
-00100011b & 10100001b = 00100001b
-00100011b & 10100010b = 00100010b
-00100011b & 10100011b = 00100011b
-00100011b & 10100100b = 00100000b
-00100011b & 10100101b = 00100001b
-00100011b & 10100110b = 00100010b
-00100011b & 10100111b = 00100011b
-00100011b & 10101000b = 00100000b
-00100011b & 10101001b = 00100001b
-00100011b & 10101010b = 00100010b
-00100011b & 10101011b = 00100011b
-00100011b & 10101100b = 00100000b
-00100011b & 10101101b = 00100001b
-00100011b & 10101110b = 00100010b
-00100011b & 10101111b = 00100011b
-00100011b & 10110000b = 00100000b
-00100011b & 10110001b = 00100001b
-00100011b & 10110010b = 00100010b
-00100011b & 10110011b = 00100011b
-00100011b & 10110100b = 00100000b
-00100011b & 10110101b = 00100001b
-00100011b & 10110110b = 00100010b
-00100011b & 10110111b = 00100011b
-00100011b & 10111000b = 00100000b
-00100011b & 10111001b = 00100001b
-00100011b & 10111010b = 00100010b
-00100011b & 10111011b = 00100011b
-00100011b & 10111100b = 00100000b
-00100011b & 10111101b = 00100001b
-00100011b & 10111110b = 00100010b
-00100011b & 10111111b = 00100011b
-00100011b & 11000000b = 00000000b
-00100011b & 11000001b = 00000001b
-00100011b & 11000010b = 00000010b
-00100011b & 11000011b = 00000011b
-00100011b & 11000100b = 00000000b
-00100011b & 11000101b = 00000001b
-00100011b & 11000110b = 00000010b
-00100011b & 11000111b = 00000011b
-00100011b & 11001000b = 00000000b
-00100011b & 11001001b = 00000001b
-00100011b & 11001010b = 00000010b
-00100011b & 11001011b = 00000011b
-00100011b & 11001100b = 00000000b
-00100011b & 11001101b = 00000001b
-00100011b & 11001110b = 00000010b
-00100011b & 11001111b = 00000011b
-00100011b & 11010000b = 00000000b
-00100011b & 11010001b = 00000001b
-00100011b & 11010010b = 00000010b
-00100011b & 11010011b = 00000011b
-00100011b & 11010100b = 00000000b
-00100011b & 11010101b = 00000001b
-00100011b & 11010110b = 00000010b
-00100011b & 11010111b = 00000011b
-00100011b & 11011000b = 00000000b
-00100011b & 11011001b = 00000001b
-00100011b & 11011010b = 00000010b
-00100011b & 11011011b = 00000011b
-00100011b & 11011100b = 00000000b
-00100011b & 11011101b = 00000001b
-00100011b & 11011110b = 00000010b
-00100011b & 11011111b = 00000011b
-00100011b & 11100000b = 00100000b
-00100011b & 11100001b = 00100001b
-00100011b & 11100010b = 00100010b
-00100011b & 11100011b = 00100011b
-00100011b & 11100100b = 00100000b
-00100011b & 11100101b = 00100001b
-00100011b & 11100110b = 00100010b
-00100011b & 11100111b = 00100011b
-00100011b & 11101000b = 00100000b
-00100011b & 11101001b = 00100001b
-00100011b & 11101010b = 00100010b
-00100011b & 11101011b = 00100011b
-00100011b & 11101100b = 00100000b
-00100011b & 11101101b = 00100001b
-00100011b & 11101110b = 00100010b
-00100011b & 11101111b = 00100011b
-00100011b & 11110000b = 00100000b
-00100011b & 11110001b = 00100001b
-00100011b & 11110010b = 00100010b
-00100011b & 11110011b = 00100011b
-00100011b & 11110100b = 00100000b
-00100011b & 11110101b = 00100001b
-00100011b & 11110110b = 00100010b
-00100011b & 11110111b = 00100011b
-00100011b & 11111000b = 00100000b
-00100011b & 11111001b = 00100001b
-00100011b & 11111010b = 00100010b
-00100011b & 11111011b = 00100011b
-00100011b & 11111100b = 00100000b
-00100011b & 11111101b = 00100001b
-00100011b & 11111110b = 00100010b
-00100011b & 11111111b = 00100011b
-00100011b & 00000000b = 00000000b
-00100011b & 00000001b = 00000001b
-00100011b & 00000010b = 00000010b
-00100011b & 00000011b = 00000011b
-00100011b & 00000100b = 00000000b
-00100011b & 00000101b = 00000001b
-00100011b & 00000110b = 00000010b
-00100011b & 00000111b = 00000011b
-00100011b & 00001000b = 00000000b
-00100011b & 00001001b = 00000001b
-00100011b & 00001010b = 00000010b
-00100011b & 00001011b = 00000011b
-00100011b & 00001100b = 00000000b
-00100011b & 00001101b = 00000001b
-00100011b & 00001110b = 00000010b
-00100011b & 00001111b = 00000011b
-00100011b & 00010000b = 00000000b
-00100011b & 00010001b = 00000001b
-00100011b & 00010010b = 00000010b
-00100011b & 00010011b = 00000011b
-00100011b & 00010100b = 00000000b
-00100011b & 00010101b = 00000001b
-00100011b & 00010110b = 00000010b
-00100011b & 00010111b = 00000011b
-00100011b & 00011000b = 00000000b
-00100011b & 00011001b = 00000001b
-00100011b & 00011010b = 00000010b
-00100011b & 00011011b = 00000011b
-00100011b & 00011100b = 00000000b
-00100011b & 00011101b = 00000001b
-00100011b & 00011110b = 00000010b
-00100011b & 00011111b = 00000011b
-00100011b & 00100000b = 00100000b
-00100011b & 00100001b = 00100001b
-00100011b & 00100010b = 00100010b
-00100011b & 00100011b = 00100011b
-00100011b & 00100100b = 00100000b
-00100011b & 00100101b = 00100001b
-00100011b & 00100110b = 00100010b
-00100011b & 00100111b = 00100011b
-00100011b & 00101000b = 00100000b
-00100011b & 00101001b = 00100001b
-00100011b & 00101010b = 00100010b
-00100011b & 00101011b = 00100011b
-00100011b & 00101100b = 00100000b
-00100011b & 00101101b = 00100001b
-00100011b & 00101110b = 00100010b
-00100011b & 00101111b = 00100011b
-00100011b & 00110000b = 00100000b
-00100011b & 00110001b = 00100001b
-00100011b & 00110010b = 00100010b
-00100011b & 00110011b = 00100011b
-00100011b & 00110100b = 00100000b
-00100011b & 00110101b = 00100001b
-00100011b & 00110110b = 00100010b
-00100011b & 00110111b = 00100011b
-00100011b & 00111000b = 00100000b
-00100011b & 00111001b = 00100001b
-00100011b & 00111010b = 00100010b
-00100011b & 00111011b = 00100011b
-00100011b & 00111100b = 00100000b
-00100011b & 00111101b = 00100001b
-00100011b & 00111110b = 00100010b
-00100011b & 00111111b = 00100011b
-00100011b & 01000000b = 00000000b
-00100011b & 01000001b = 00000001b
-00100011b & 01000010b = 00000010b
-00100011b & 01000011b = 00000011b
-00100011b & 01000100b = 00000000b
-00100011b & 01000101b = 00000001b
-00100011b & 01000110b = 00000010b
-00100011b & 01000111b = 00000011b
-00100011b & 01001000b = 00000000b
-00100011b & 01001001b = 00000001b
-00100011b & 01001010b = 00000010b
-00100011b & 01001011b = 00000011b
-00100011b & 01001100b = 00000000b
-00100011b & 01001101b = 00000001b
-00100011b & 01001110b = 00000010b
-00100011b & 01001111b = 00000011b
-00100011b & 01010000b = 00000000b
-00100011b & 01010001b = 00000001b
-00100011b & 01010010b = 00000010b
-00100011b & 01010011b = 00000011b
-00100011b & 01010100b = 00000000b
-00100011b & 01010101b = 00000001b
-00100011b & 01010110b = 00000010b
-00100011b & 01010111b = 00000011b
-00100011b & 01011000b = 00000000b
-00100011b & 01011001b = 00000001b
-00100011b & 01011010b = 00000010b
-00100011b & 01011011b = 00000011b
-00100011b & 01011100b = 00000000b
-00100011b & 01011101b = 00000001b
-00100011b & 01011110b = 00000010b
-00100011b & 01011111b = 00000011b
-00100011b & 01100000b = 00100000b
-00100011b & 01100001b = 00100001b
-00100011b & 01100010b = 00100010b
-00100011b & 01100011b = 00100011b
-00100011b & 01100100b = 00100000b
-00100011b & 01100101b = 00100001b
-00100011b & 01100110b = 00100010b
-00100011b & 01100111b = 00100011b
-00100011b & 01101000b = 00100000b
-00100011b & 01101001b = 00100001b
-00100011b & 01101010b = 00100010b
-00100011b & 01101011b = 00100011b
-00100011b & 01101100b = 00100000b
-00100011b & 01101101b = 00100001b
-00100011b & 01101110b = 00100010b
-00100011b & 01101111b = 00100011b
-00100011b & 01110000b = 00100000b
-00100011b & 01110001b = 00100001b
-00100011b & 01110010b = 00100010b
-00100011b & 01110011b = 00100011b
-00100011b & 01110100b = 00100000b
-00100011b & 01110101b = 00100001b
-00100011b & 01110110b = 00100010b
-00100011b & 01110111b = 00100011b
-00100011b & 01111000b = 00100000b
-00100011b & 01111001b = 00100001b
-00100011b & 01111010b = 00100010b
-00100011b & 01111011b = 00100011b
-00100011b & 01111100b = 00100000b
-00100011b & 01111101b = 00100001b
-00100011b & 01111110b = 00100010b
-00100100b & 10000000b = 00000000b
-00100100b & 10000001b = 00000000b
-00100100b & 10000010b = 00000000b
-00100100b & 10000011b = 00000000b
-00100100b & 10000100b = 00000100b
-00100100b & 10000101b = 00000100b
-00100100b & 10000110b = 00000100b
-00100100b & 10000111b = 00000100b
-00100100b & 10001000b = 00000000b
-00100100b & 10001001b = 00000000b
-00100100b & 10001010b = 00000000b
-00100100b & 10001011b = 00000000b
-00100100b & 10001100b = 00000100b
-00100100b & 10001101b = 00000100b
-00100100b & 10001110b = 00000100b
-00100100b & 10001111b = 00000100b
-00100100b & 10010000b = 00000000b
-00100100b & 10010001b = 00000000b
-00100100b & 10010010b = 00000000b
-00100100b & 10010011b = 00000000b
-00100100b & 10010100b = 00000100b
-00100100b & 10010101b = 00000100b
-00100100b & 10010110b = 00000100b
-00100100b & 10010111b = 00000100b
-00100100b & 10011000b = 00000000b
-00100100b & 10011001b = 00000000b
-00100100b & 10011010b = 00000000b
-00100100b & 10011011b = 00000000b
-00100100b & 10011100b = 00000100b
-00100100b & 10011101b = 00000100b
-00100100b & 10011110b = 00000100b
-00100100b & 10011111b = 00000100b
-00100100b & 10100000b = 00100000b
-00100100b & 10100001b = 00100000b
-00100100b & 10100010b = 00100000b
-00100100b & 10100011b = 00100000b
-00100100b & 10100100b = 00100100b
-00100100b & 10100101b = 00100100b
-00100100b & 10100110b = 00100100b
-00100100b & 10100111b = 00100100b
-00100100b & 10101000b = 00100000b
-00100100b & 10101001b = 00100000b
-00100100b & 10101010b = 00100000b
-00100100b & 10101011b = 00100000b
-00100100b & 10101100b = 00100100b
-00100100b & 10101101b = 00100100b
-00100100b & 10101110b = 00100100b
-00100100b & 10101111b = 00100100b
-00100100b & 10110000b = 00100000b
-00100100b & 10110001b = 00100000b
-00100100b & 10110010b = 00100000b
-00100100b & 10110011b = 00100000b
-00100100b & 10110100b = 00100100b
-00100100b & 10110101b = 00100100b
-00100100b & 10110110b = 00100100b
-00100100b & 10110111b = 00100100b
-00100100b & 10111000b = 00100000b
-00100100b & 10111001b = 00100000b
-00100100b & 10111010b = 00100000b
-00100100b & 10111011b = 00100000b
-00100100b & 10111100b = 00100100b
-00100100b & 10111101b = 00100100b
-00100100b & 10111110b = 00100100b
-00100100b & 10111111b = 00100100b
-00100100b & 11000000b = 00000000b
-00100100b & 11000001b = 00000000b
-00100100b & 11000010b = 00000000b
-00100100b & 11000011b = 00000000b
-00100100b & 11000100b = 00000100b
-00100100b & 11000101b = 00000100b
-00100100b & 11000110b = 00000100b
-00100100b & 11000111b = 00000100b
-00100100b & 11001000b = 00000000b
-00100100b & 11001001b = 00000000b
-00100100b & 11001010b = 00000000b
-00100100b & 11001011b = 00000000b
-00100100b & 11001100b = 00000100b
-00100100b & 11001101b = 00000100b
-00100100b & 11001110b = 00000100b
-00100100b & 11001111b = 00000100b
-00100100b & 11010000b = 00000000b
-00100100b & 11010001b = 00000000b
-00100100b & 11010010b = 00000000b
-00100100b & 11010011b = 00000000b
-00100100b & 11010100b = 00000100b
-00100100b & 11010101b = 00000100b
-00100100b & 11010110b = 00000100b
-00100100b & 11010111b = 00000100b
-00100100b & 11011000b = 00000000b
-00100100b & 11011001b = 00000000b
-00100100b & 11011010b = 00000000b
-00100100b & 11011011b = 00000000b
-00100100b & 11011100b = 00000100b
-00100100b & 11011101b = 00000100b
-00100100b & 11011110b = 00000100b
-00100100b & 11011111b = 00000100b
-00100100b & 11100000b = 00100000b
-00100100b & 11100001b = 00100000b
-00100100b & 11100010b = 00100000b
-00100100b & 11100011b = 00100000b
-00100100b & 11100100b = 00100100b
-00100100b & 11100101b = 00100100b
-00100100b & 11100110b = 00100100b
-00100100b & 11100111b = 00100100b
-00100100b & 11101000b = 00100000b
-00100100b & 11101001b = 00100000b
-00100100b & 11101010b = 00100000b
-00100100b & 11101011b = 00100000b
-00100100b & 11101100b = 00100100b
-00100100b & 11101101b = 00100100b
-00100100b & 11101110b = 00100100b
-00100100b & 11101111b = 00100100b
-00100100b & 11110000b = 00100000b
-00100100b & 11110001b = 00100000b
-00100100b & 11110010b = 00100000b
-00100100b & 11110011b = 00100000b
-00100100b & 11110100b = 00100100b
-00100100b & 11110101b = 00100100b
-00100100b & 11110110b = 00100100b
-00100100b & 11110111b = 00100100b
-00100100b & 11111000b = 00100000b
-00100100b & 11111001b = 00100000b
-00100100b & 11111010b = 00100000b
-00100100b & 11111011b = 00100000b
-00100100b & 11111100b = 00100100b
-00100100b & 11111101b = 00100100b
-00100100b & 11111110b = 00100100b
-00100100b & 11111111b = 00100100b
-00100100b & 00000000b = 00000000b
-00100100b & 00000001b = 00000000b
-00100100b & 00000010b = 00000000b
-00100100b & 00000011b = 00000000b
-00100100b & 00000100b = 00000100b
-00100100b & 00000101b = 00000100b
-00100100b & 00000110b = 00000100b
-00100100b & 00000111b = 00000100b
-00100100b & 00001000b = 00000000b
-00100100b & 00001001b = 00000000b
-00100100b & 00001010b = 00000000b
-00100100b & 00001011b = 00000000b
-00100100b & 00001100b = 00000100b
-00100100b & 00001101b = 00000100b
-00100100b & 00001110b = 00000100b
-00100100b & 00001111b = 00000100b
-00100100b & 00010000b = 00000000b
-00100100b & 00010001b = 00000000b
-00100100b & 00010010b = 00000000b
-00100100b & 00010011b = 00000000b
-00100100b & 00010100b = 00000100b
-00100100b & 00010101b = 00000100b
-00100100b & 00010110b = 00000100b
-00100100b & 00010111b = 00000100b
-00100100b & 00011000b = 00000000b
-00100100b & 00011001b = 00000000b
-00100100b & 00011010b = 00000000b
-00100100b & 00011011b = 00000000b
-00100100b & 00011100b = 00000100b
-00100100b & 00011101b = 00000100b
-00100100b & 00011110b = 00000100b
-00100100b & 00011111b = 00000100b
-00100100b & 00100000b = 00100000b
-00100100b & 00100001b = 00100000b
-00100100b & 00100010b = 00100000b
-00100100b & 00100011b = 00100000b
-00100100b & 00100100b = 00100100b
-00100100b & 00100101b = 00100100b
-00100100b & 00100110b = 00100100b
-00100100b & 00100111b = 00100100b
-00100100b & 00101000b = 00100000b
-00100100b & 00101001b = 00100000b
-00100100b & 00101010b = 00100000b
-00100100b & 00101011b = 00100000b
-00100100b & 00101100b = 00100100b
-00100100b & 00101101b = 00100100b
-00100100b & 00101110b = 00100100b
-00100100b & 00101111b = 00100100b
-00100100b & 00110000b = 00100000b
-00100100b & 00110001b = 00100000b
-00100100b & 00110010b = 00100000b
-00100100b & 00110011b = 00100000b
-00100100b & 00110100b = 00100100b
-00100100b & 00110101b = 00100100b
-00100100b & 00110110b = 00100100b
-00100100b & 00110111b = 00100100b
-00100100b & 00111000b = 00100000b
-00100100b & 00111001b = 00100000b
-00100100b & 00111010b = 00100000b
-00100100b & 00111011b = 00100000b
-00100100b & 00111100b = 00100100b
-00100100b & 00111101b = 00100100b
-00100100b & 00111110b = 00100100b
-00100100b & 00111111b = 00100100b
-00100100b & 01000000b = 00000000b
-00100100b & 01000001b = 00000000b
-00100100b & 01000010b = 00000000b
-00100100b & 01000011b = 00000000b
-00100100b & 01000100b = 00000100b
-00100100b & 01000101b = 00000100b
-00100100b & 01000110b = 00000100b
-00100100b & 01000111b = 00000100b
-00100100b & 01001000b = 00000000b
-00100100b & 01001001b = 00000000b
-00100100b & 01001010b = 00000000b
-00100100b & 01001011b = 00000000b
-00100100b & 01001100b = 00000100b
-00100100b & 01001101b = 00000100b
-00100100b & 01001110b = 00000100b
-00100100b & 01001111b = 00000100b
-00100100b & 01010000b = 00000000b
-00100100b & 01010001b = 00000000b
-00100100b & 01010010b = 00000000b
-00100100b & 01010011b = 00000000b
-00100100b & 01010100b = 00000100b
-00100100b & 01010101b = 00000100b
-00100100b & 01010110b = 00000100b
-00100100b & 01010111b = 00000100b
-00100100b & 01011000b = 00000000b
-00100100b & 01011001b = 00000000b
-00100100b & 01011010b = 00000000b
-00100100b & 01011011b = 00000000b
-00100100b & 01011100b = 00000100b
-00100100b & 01011101b = 00000100b
-00100100b & 01011110b = 00000100b
-00100100b & 01011111b = 00000100b
-00100100b & 01100000b = 00100000b
-00100100b & 01100001b = 00100000b
-00100100b & 01100010b = 00100000b
-00100100b & 01100011b = 00100000b
-00100100b & 01100100b = 00100100b
-00100100b & 01100101b = 00100100b
-00100100b & 01100110b = 00100100b
-00100100b & 01100111b = 00100100b
-00100100b & 01101000b = 00100000b
-00100100b & 01101001b = 00100000b
-00100100b & 01101010b = 00100000b
-00100100b & 01101011b = 00100000b
-00100100b & 01101100b = 00100100b
-00100100b & 01101101b = 00100100b
-00100100b & 01101110b = 00100100b
-00100100b & 01101111b = 00100100b
-00100100b & 01110000b = 00100000b
-00100100b & 01110001b = 00100000b
-00100100b & 01110010b = 00100000b
-00100100b & 01110011b = 00100000b
-00100100b & 01110100b = 00100100b
-00100100b & 01110101b = 00100100b
-00100100b & 01110110b = 00100100b
-00100100b & 01110111b = 00100100b
-00100100b & 01111000b = 00100000b
-00100100b & 01111001b = 00100000b
-00100100b & 01111010b = 00100000b
-00100100b & 01111011b = 00100000b
-00100100b & 01111100b = 00100100b
-00100100b & 01111101b = 00100100b
-00100100b & 01111110b = 00100100b
-00100101b & 10000000b = 00000000b
-00100101b & 10000001b = 00000001b
-00100101b & 10000010b = 00000000b
-00100101b & 10000011b = 00000001b
-00100101b & 10000100b = 00000100b
-00100101b & 10000101b = 00000101b
-00100101b & 10000110b = 00000100b
-00100101b & 10000111b = 00000101b
-00100101b & 10001000b = 00000000b
-00100101b & 10001001b = 00000001b
-00100101b & 10001010b = 00000000b
-00100101b & 10001011b = 00000001b
-00100101b & 10001100b = 00000100b
-00100101b & 10001101b = 00000101b
-00100101b & 10001110b = 00000100b
-00100101b & 10001111b = 00000101b
-00100101b & 10010000b = 00000000b
-00100101b & 10010001b = 00000001b
-00100101b & 10010010b = 00000000b
-00100101b & 10010011b = 00000001b
-00100101b & 10010100b = 00000100b
-00100101b & 10010101b = 00000101b
-00100101b & 10010110b = 00000100b
-00100101b & 10010111b = 00000101b
-00100101b & 10011000b = 00000000b
-00100101b & 10011001b = 00000001b
-00100101b & 10011010b = 00000000b
-00100101b & 10011011b = 00000001b
-00100101b & 10011100b = 00000100b
-00100101b & 10011101b = 00000101b
-00100101b & 10011110b = 00000100b
-00100101b & 10011111b = 00000101b
-00100101b & 10100000b = 00100000b
-00100101b & 10100001b = 00100001b
-00100101b & 10100010b = 00100000b
-00100101b & 10100011b = 00100001b
-00100101b & 10100100b = 00100100b
-00100101b & 10100101b = 00100101b
-00100101b & 10100110b = 00100100b
-00100101b & 10100111b = 00100101b
-00100101b & 10101000b = 00100000b
-00100101b & 10101001b = 00100001b
-00100101b & 10101010b = 00100000b
-00100101b & 10101011b = 00100001b
-00100101b & 10101100b = 00100100b
-00100101b & 10101101b = 00100101b
-00100101b & 10101110b = 00100100b
-00100101b & 10101111b = 00100101b
-00100101b & 10110000b = 00100000b
-00100101b & 10110001b = 00100001b
-00100101b & 10110010b = 00100000b
-00100101b & 10110011b = 00100001b
-00100101b & 10110100b = 00100100b
-00100101b & 10110101b = 00100101b
-00100101b & 10110110b = 00100100b
-00100101b & 10110111b = 00100101b
-00100101b & 10111000b = 00100000b
-00100101b & 10111001b = 00100001b
-00100101b & 10111010b = 00100000b
-00100101b & 10111011b = 00100001b
-00100101b & 10111100b = 00100100b
-00100101b & 10111101b = 00100101b
-00100101b & 10111110b = 00100100b
-00100101b & 10111111b = 00100101b
-00100101b & 11000000b = 00000000b
-00100101b & 11000001b = 00000001b
-00100101b & 11000010b = 00000000b
-00100101b & 11000011b = 00000001b
-00100101b & 11000100b = 00000100b
-00100101b & 11000101b = 00000101b
-00100101b & 11000110b = 00000100b
-00100101b & 11000111b = 00000101b
-00100101b & 11001000b = 00000000b
-00100101b & 11001001b = 00000001b
-00100101b & 11001010b = 00000000b
-00100101b & 11001011b = 00000001b
-00100101b & 11001100b = 00000100b
-00100101b & 11001101b = 00000101b
-00100101b & 11001110b = 00000100b
-00100101b & 11001111b = 00000101b
-00100101b & 11010000b = 00000000b
-00100101b & 11010001b = 00000001b
-00100101b & 11010010b = 00000000b
-00100101b & 11010011b = 00000001b
-00100101b & 11010100b = 00000100b
-00100101b & 11010101b = 00000101b
-00100101b & 11010110b = 00000100b
-00100101b & 11010111b = 00000101b
-00100101b & 11011000b = 00000000b
-00100101b & 11011001b = 00000001b
-00100101b & 11011010b = 00000000b
-00100101b & 11011011b = 00000001b
-00100101b & 11011100b = 00000100b
-00100101b & 11011101b = 00000101b
-00100101b & 11011110b = 00000100b
-00100101b & 11011111b = 00000101b
-00100101b & 11100000b = 00100000b
-00100101b & 11100001b = 00100001b
-00100101b & 11100010b = 00100000b
-00100101b & 11100011b = 00100001b
-00100101b & 11100100b = 00100100b
-00100101b & 11100101b = 00100101b
-00100101b & 11100110b = 00100100b
-00100101b & 11100111b = 00100101b
-00100101b & 11101000b = 00100000b
-00100101b & 11101001b = 00100001b
-00100101b & 11101010b = 00100000b
-00100101b & 11101011b = 00100001b
-00100101b & 11101100b = 00100100b
-00100101b & 11101101b = 00100101b
-00100101b & 11101110b = 00100100b
-00100101b & 11101111b = 00100101b
-00100101b & 11110000b = 00100000b
-00100101b & 11110001b = 00100001b
-00100101b & 11110010b = 00100000b
-00100101b & 11110011b = 00100001b
-00100101b & 11110100b = 00100100b
-00100101b & 11110101b = 00100101b
-00100101b & 11110110b = 00100100b
-00100101b & 11110111b = 00100101b
-00100101b & 11111000b = 00100000b
-00100101b & 11111001b = 00100001b
-00100101b & 11111010b = 00100000b
-00100101b & 11111011b = 00100001b
-00100101b & 11111100b = 00100100b
-00100101b & 11111101b = 00100101b
-00100101b & 11111110b = 00100100b
-00100101b & 11111111b = 00100101b
-00100101b & 00000000b = 00000000b
-00100101b & 00000001b = 00000001b
-00100101b & 00000010b = 00000000b
-00100101b & 00000011b = 00000001b
-00100101b & 00000100b = 00000100b
-00100101b & 00000101b = 00000101b
-00100101b & 00000110b = 00000100b
-00100101b & 00000111b = 00000101b
-00100101b & 00001000b = 00000000b
-00100101b & 00001001b = 00000001b
-00100101b & 00001010b = 00000000b
-00100101b & 00001011b = 00000001b
-00100101b & 00001100b = 00000100b
-00100101b & 00001101b = 00000101b
-00100101b & 00001110b = 00000100b
-00100101b & 00001111b = 00000101b
-00100101b & 00010000b = 00000000b
-00100101b & 00010001b = 00000001b
-00100101b & 00010010b = 00000000b
-00100101b & 00010011b = 00000001b
-00100101b & 00010100b = 00000100b
-00100101b & 00010101b = 00000101b
-00100101b & 00010110b = 00000100b
-00100101b & 00010111b = 00000101b
-00100101b & 00011000b = 00000000b
-00100101b & 00011001b = 00000001b
-00100101b & 00011010b = 00000000b
-00100101b & 00011011b = 00000001b
-00100101b & 00011100b = 00000100b
-00100101b & 00011101b = 00000101b
-00100101b & 00011110b = 00000100b
-00100101b & 00011111b = 00000101b
-00100101b & 00100000b = 00100000b
-00100101b & 00100001b = 00100001b
-00100101b & 00100010b = 00100000b
-00100101b & 00100011b = 00100001b
-00100101b & 00100100b = 00100100b
-00100101b & 00100101b = 00100101b
-00100101b & 00100110b = 00100100b
-00100101b & 00100111b = 00100101b
-00100101b & 00101000b = 00100000b
-00100101b & 00101001b = 00100001b
-00100101b & 00101010b = 00100000b
-00100101b & 00101011b = 00100001b
-00100101b & 00101100b = 00100100b
-00100101b & 00101101b = 00100101b
-00100101b & 00101110b = 00100100b
-00100101b & 00101111b = 00100101b
-00100101b & 00110000b = 00100000b
-00100101b & 00110001b = 00100001b
-00100101b & 00110010b = 00100000b
-00100101b & 00110011b = 00100001b
-00100101b & 00110100b = 00100100b
-00100101b & 00110101b = 00100101b
-00100101b & 00110110b = 00100100b
-00100101b & 00110111b = 00100101b
-00100101b & 00111000b = 00100000b
-00100101b & 00111001b = 00100001b
-00100101b & 00111010b = 00100000b
-00100101b & 00111011b = 00100001b
-00100101b & 00111100b = 00100100b
-00100101b & 00111101b = 00100101b
-00100101b & 00111110b = 00100100b
-00100101b & 00111111b = 00100101b
-00100101b & 01000000b = 00000000b
-00100101b & 01000001b = 00000001b
-00100101b & 01000010b = 00000000b
-00100101b & 01000011b = 00000001b
-00100101b & 01000100b = 00000100b
-00100101b & 01000101b = 00000101b
-00100101b & 01000110b = 00000100b
-00100101b & 01000111b = 00000101b
-00100101b & 01001000b = 00000000b
-00100101b & 01001001b = 00000001b
-00100101b & 01001010b = 00000000b
-00100101b & 01001011b = 00000001b
-00100101b & 01001100b = 00000100b
-00100101b & 01001101b = 00000101b
-00100101b & 01001110b = 00000100b
-00100101b & 01001111b = 00000101b
-00100101b & 01010000b = 00000000b
-00100101b & 01010001b = 00000001b
-00100101b & 01010010b = 00000000b
-00100101b & 01010011b = 00000001b
-00100101b & 01010100b = 00000100b
-00100101b & 01010101b = 00000101b
-00100101b & 01010110b = 00000100b
-00100101b & 01010111b = 00000101b
-00100101b & 01011000b = 00000000b
-00100101b & 01011001b = 00000001b
-00100101b & 01011010b = 00000000b
-00100101b & 01011011b = 00000001b
-00100101b & 01011100b = 00000100b
-00100101b & 01011101b = 00000101b
-00100101b & 01011110b = 00000100b
-00100101b & 01011111b = 00000101b
-00100101b & 01100000b = 00100000b
-00100101b & 01100001b = 00100001b
-00100101b & 01100010b = 00100000b
-00100101b & 01100011b = 00100001b
-00100101b & 01100100b = 00100100b
-00100101b & 01100101b = 00100101b
-00100101b & 01100110b = 00100100b
-00100101b & 01100111b = 00100101b
-00100101b & 01101000b = 00100000b
-00100101b & 01101001b = 00100001b
-00100101b & 01101010b = 00100000b
-00100101b & 01101011b = 00100001b
-00100101b & 01101100b = 00100100b
-00100101b & 01101101b = 00100101b
-00100101b & 01101110b = 00100100b
-00100101b & 01101111b = 00100101b
-00100101b & 01110000b = 00100000b
-00100101b & 01110001b = 00100001b
-00100101b & 01110010b = 00100000b
-00100101b & 01110011b = 00100001b
-00100101b & 01110100b = 00100100b
-00100101b & 01110101b = 00100101b
-00100101b & 01110110b = 00100100b
-00100101b & 01110111b = 00100101b
-00100101b & 01111000b = 00100000b
-00100101b & 01111001b = 00100001b
-00100101b & 01111010b = 00100000b
-00100101b & 01111011b = 00100001b
-00100101b & 01111100b = 00100100b
-00100101b & 01111101b = 00100101b
-00100101b & 01111110b = 00100100b
-00100110b & 10000000b = 00000000b
-00100110b & 10000001b = 00000000b
-00100110b & 10000010b = 00000010b
-00100110b & 10000011b = 00000010b
-00100110b & 10000100b = 00000100b
-00100110b & 10000101b = 00000100b
-00100110b & 10000110b = 00000110b
-00100110b & 10000111b = 00000110b
-00100110b & 10001000b = 00000000b
-00100110b & 10001001b = 00000000b
-00100110b & 10001010b = 00000010b
-00100110b & 10001011b = 00000010b
-00100110b & 10001100b = 00000100b
-00100110b & 10001101b = 00000100b
-00100110b & 10001110b = 00000110b
-00100110b & 10001111b = 00000110b
-00100110b & 10010000b = 00000000b
-00100110b & 10010001b = 00000000b
-00100110b & 10010010b = 00000010b
-00100110b & 10010011b = 00000010b
-00100110b & 10010100b = 00000100b
-00100110b & 10010101b = 00000100b
-00100110b & 10010110b = 00000110b
-00100110b & 10010111b = 00000110b
-00100110b & 10011000b = 00000000b
-00100110b & 10011001b = 00000000b
-00100110b & 10011010b = 00000010b
-00100110b & 10011011b = 00000010b
-00100110b & 10011100b = 00000100b
-00100110b & 10011101b = 00000100b
-00100110b & 10011110b = 00000110b
-00100110b & 10011111b = 00000110b
-00100110b & 10100000b = 00100000b
-00100110b & 10100001b = 00100000b
-00100110b & 10100010b = 00100010b
-00100110b & 10100011b = 00100010b
-00100110b & 10100100b = 00100100b
-00100110b & 10100101b = 00100100b
-00100110b & 10100110b = 00100110b
-00100110b & 10100111b = 00100110b
-00100110b & 10101000b = 00100000b
-00100110b & 10101001b = 00100000b
-00100110b & 10101010b = 00100010b
-00100110b & 10101011b = 00100010b
-00100110b & 10101100b = 00100100b
-00100110b & 10101101b = 00100100b
-00100110b & 10101110b = 00100110b
-00100110b & 10101111b = 00100110b
-00100110b & 10110000b = 00100000b
-00100110b & 10110001b = 00100000b
-00100110b & 10110010b = 00100010b
-00100110b & 10110011b = 00100010b
-00100110b & 10110100b = 00100100b
-00100110b & 10110101b = 00100100b
-00100110b & 10110110b = 00100110b
-00100110b & 10110111b = 00100110b
-00100110b & 10111000b = 00100000b
-00100110b & 10111001b = 00100000b
-00100110b & 10111010b = 00100010b
-00100110b & 10111011b = 00100010b
-00100110b & 10111100b = 00100100b
-00100110b & 10111101b = 00100100b
-00100110b & 10111110b = 00100110b
-00100110b & 10111111b = 00100110b
-00100110b & 11000000b = 00000000b
-00100110b & 11000001b = 00000000b
-00100110b & 11000010b = 00000010b
-00100110b & 11000011b = 00000010b
-00100110b & 11000100b = 00000100b
-00100110b & 11000101b = 00000100b
-00100110b & 11000110b = 00000110b
-00100110b & 11000111b = 00000110b
-00100110b & 11001000b = 00000000b
-00100110b & 11001001b = 00000000b
-00100110b & 11001010b = 00000010b
-00100110b & 11001011b = 00000010b
-00100110b & 11001100b = 00000100b
-00100110b & 11001101b = 00000100b
-00100110b & 11001110b = 00000110b
-00100110b & 11001111b = 00000110b
-00100110b & 11010000b = 00000000b
-00100110b & 11010001b = 00000000b
-00100110b & 11010010b = 00000010b
-00100110b & 11010011b = 00000010b
-00100110b & 11010100b = 00000100b
-00100110b & 11010101b = 00000100b
-00100110b & 11010110b = 00000110b
-00100110b & 11010111b = 00000110b
-00100110b & 11011000b = 00000000b
-00100110b & 11011001b = 00000000b
-00100110b & 11011010b = 00000010b
-00100110b & 11011011b = 00000010b
-00100110b & 11011100b = 00000100b
-00100110b & 11011101b = 00000100b
-00100110b & 11011110b = 00000110b
-00100110b & 11011111b = 00000110b
-00100110b & 11100000b = 00100000b
-00100110b & 11100001b = 00100000b
-00100110b & 11100010b = 00100010b
-00100110b & 11100011b = 00100010b
-00100110b & 11100100b = 00100100b
-00100110b & 11100101b = 00100100b
-00100110b & 11100110b = 00100110b
-00100110b & 11100111b = 00100110b
-00100110b & 11101000b = 00100000b
-00100110b & 11101001b = 00100000b
-00100110b & 11101010b = 00100010b
-00100110b & 11101011b = 00100010b
-00100110b & 11101100b = 00100100b
-00100110b & 11101101b = 00100100b
-00100110b & 11101110b = 00100110b
-00100110b & 11101111b = 00100110b
-00100110b & 11110000b = 00100000b
-00100110b & 11110001b = 00100000b
-00100110b & 11110010b = 00100010b
-00100110b & 11110011b = 00100010b
-00100110b & 11110100b = 00100100b
-00100110b & 11110101b = 00100100b
-00100110b & 11110110b = 00100110b
-00100110b & 11110111b = 00100110b
-00100110b & 11111000b = 00100000b
-00100110b & 11111001b = 00100000b
-00100110b & 11111010b = 00100010b
-00100110b & 11111011b = 00100010b
-00100110b & 11111100b = 00100100b
-00100110b & 11111101b = 00100100b
-00100110b & 11111110b = 00100110b
-00100110b & 11111111b = 00100110b
-00100110b & 00000000b = 00000000b
-00100110b & 00000001b = 00000000b
-00100110b & 00000010b = 00000010b
-00100110b & 00000011b = 00000010b
-00100110b & 00000100b = 00000100b
-00100110b & 00000101b = 00000100b
-00100110b & 00000110b = 00000110b
-00100110b & 00000111b = 00000110b
-00100110b & 00001000b = 00000000b
-00100110b & 00001001b = 00000000b
-00100110b & 00001010b = 00000010b
-00100110b & 00001011b = 00000010b
-00100110b & 00001100b = 00000100b
-00100110b & 00001101b = 00000100b
-00100110b & 00001110b = 00000110b
-00100110b & 00001111b = 00000110b
-00100110b & 00010000b = 00000000b
-00100110b & 00010001b = 00000000b
-00100110b & 00010010b = 00000010b
-00100110b & 00010011b = 00000010b
-00100110b & 00010100b = 00000100b
-00100110b & 00010101b = 00000100b
-00100110b & 00010110b = 00000110b
-00100110b & 00010111b = 00000110b
-00100110b & 00011000b = 00000000b
-00100110b & 00011001b = 00000000b
-00100110b & 00011010b = 00000010b
-00100110b & 00011011b = 00000010b
-00100110b & 00011100b = 00000100b
-00100110b & 00011101b = 00000100b
-00100110b & 00011110b = 00000110b
-00100110b & 00011111b = 00000110b
-00100110b & 00100000b = 00100000b
-00100110b & 00100001b = 00100000b
-00100110b & 00100010b = 00100010b
-00100110b & 00100011b = 00100010b
-00100110b & 00100100b = 00100100b
-00100110b & 00100101b = 00100100b
-00100110b & 00100110b = 00100110b
-00100110b & 00100111b = 00100110b
-00100110b & 00101000b = 00100000b
-00100110b & 00101001b = 00100000b
-00100110b & 00101010b = 00100010b
-00100110b & 00101011b = 00100010b
-00100110b & 00101100b = 00100100b
-00100110b & 00101101b = 00100100b
-00100110b & 00101110b = 00100110b
-00100110b & 00101111b = 00100110b
-00100110b & 00110000b = 00100000b
-00100110b & 00110001b = 00100000b
-00100110b & 00110010b = 00100010b
-00100110b & 00110011b = 00100010b
-00100110b & 00110100b = 00100100b
-00100110b & 00110101b = 00100100b
-00100110b & 00110110b = 00100110b
-00100110b & 00110111b = 00100110b
-00100110b & 00111000b = 00100000b
-00100110b & 00111001b = 00100000b
-00100110b & 00111010b = 00100010b
-00100110b & 00111011b = 00100010b
-00100110b & 00111100b = 00100100b
-00100110b & 00111101b = 00100100b
-00100110b & 00111110b = 00100110b
-00100110b & 00111111b = 00100110b
-00100110b & 01000000b = 00000000b
-00100110b & 01000001b = 00000000b
-00100110b & 01000010b = 00000010b
-00100110b & 01000011b = 00000010b
-00100110b & 01000100b = 00000100b
-00100110b & 01000101b = 00000100b
-00100110b & 01000110b = 00000110b
-00100110b & 01000111b = 00000110b
-00100110b & 01001000b = 00000000b
-00100110b & 01001001b = 00000000b
-00100110b & 01001010b = 00000010b
-00100110b & 01001011b = 00000010b
-00100110b & 01001100b = 00000100b
-00100110b & 01001101b = 00000100b
-00100110b & 01001110b = 00000110b
-00100110b & 01001111b = 00000110b
-00100110b & 01010000b = 00000000b
-00100110b & 01010001b = 00000000b
-00100110b & 01010010b = 00000010b
-00100110b & 01010011b = 00000010b
-00100110b & 01010100b = 00000100b
-00100110b & 01010101b = 00000100b
-00100110b & 01010110b = 00000110b
-00100110b & 01010111b = 00000110b
-00100110b & 01011000b = 00000000b
-00100110b & 01011001b = 00000000b
-00100110b & 01011010b = 00000010b
-00100110b & 01011011b = 00000010b
-00100110b & 01011100b = 00000100b
-00100110b & 01011101b = 00000100b
-00100110b & 01011110b = 00000110b
-00100110b & 01011111b = 00000110b
-00100110b & 01100000b = 00100000b
-00100110b & 01100001b = 00100000b
-00100110b & 01100010b = 00100010b
-00100110b & 01100011b = 00100010b
-00100110b & 01100100b = 00100100b
-00100110b & 01100101b = 00100100b
-00100110b & 01100110b = 00100110b
-00100110b & 01100111b = 00100110b
-00100110b & 01101000b = 00100000b
-00100110b & 01101001b = 00100000b
-00100110b & 01101010b = 00100010b
-00100110b & 01101011b = 00100010b
-00100110b & 01101100b = 00100100b
-00100110b & 01101101b = 00100100b
-00100110b & 01101110b = 00100110b
-00100110b & 01101111b = 00100110b
-00100110b & 01110000b = 00100000b
-00100110b & 01110001b = 00100000b
-00100110b & 01110010b = 00100010b
-00100110b & 01110011b = 00100010b
-00100110b & 01110100b = 00100100b
-00100110b & 01110101b = 00100100b
-00100110b & 01110110b = 00100110b
-00100110b & 01110111b = 00100110b
-00100110b & 01111000b = 00100000b
-00100110b & 01111001b = 00100000b
-00100110b & 01111010b = 00100010b
-00100110b & 01111011b = 00100010b
-00100110b & 01111100b = 00100100b
-00100110b & 01111101b = 00100100b
-00100110b & 01111110b = 00100110b
-00100111b & 10000000b = 00000000b
-00100111b & 10000001b = 00000001b
-00100111b & 10000010b = 00000010b
-00100111b & 10000011b = 00000011b
-00100111b & 10000100b = 00000100b
-00100111b & 10000101b = 00000101b
-00100111b & 10000110b = 00000110b
-00100111b & 10000111b = 00000111b
-00100111b & 10001000b = 00000000b
-00100111b & 10001001b = 00000001b
-00100111b & 10001010b = 00000010b
-00100111b & 10001011b = 00000011b
-00100111b & 10001100b = 00000100b
-00100111b & 10001101b = 00000101b
-00100111b & 10001110b = 00000110b
-00100111b & 10001111b = 00000111b
-00100111b & 10010000b = 00000000b
-00100111b & 10010001b = 00000001b
-00100111b & 10010010b = 00000010b
-00100111b & 10010011b = 00000011b
-00100111b & 10010100b = 00000100b
-00100111b & 10010101b = 00000101b
-00100111b & 10010110b = 00000110b
-00100111b & 10010111b = 00000111b
-00100111b & 10011000b = 00000000b
-00100111b & 10011001b = 00000001b
-00100111b & 10011010b = 00000010b
-00100111b & 10011011b = 00000011b
-00100111b & 10011100b = 00000100b
-00100111b & 10011101b = 00000101b
-00100111b & 10011110b = 00000110b
-00100111b & 10011111b = 00000111b
-00100111b & 10100000b = 00100000b
-00100111b & 10100001b = 00100001b
-00100111b & 10100010b = 00100010b
-00100111b & 10100011b = 00100011b
-00100111b & 10100100b = 00100100b
-00100111b & 10100101b = 00100101b
-00100111b & 10100110b = 00100110b
-00100111b & 10100111b = 00100111b
-00100111b & 10101000b = 00100000b
-00100111b & 10101001b = 00100001b
-00100111b & 10101010b = 00100010b
-00100111b & 10101011b = 00100011b
-00100111b & 10101100b = 00100100b
-00100111b & 10101101b = 00100101b
-00100111b & 10101110b = 00100110b
-00100111b & 10101111b = 00100111b
-00100111b & 10110000b = 00100000b
-00100111b & 10110001b = 00100001b
-00100111b & 10110010b = 00100010b
-00100111b & 10110011b = 00100011b
-00100111b & 10110100b = 00100100b
-00100111b & 10110101b = 00100101b
-00100111b & 10110110b = 00100110b
-00100111b & 10110111b = 00100111b
-00100111b & 10111000b = 00100000b
-00100111b & 10111001b = 00100001b
-00100111b & 10111010b = 00100010b
-00100111b & 10111011b = 00100011b
-00100111b & 10111100b = 00100100b
-00100111b & 10111101b = 00100101b
-00100111b & 10111110b = 00100110b
-00100111b & 10111111b = 00100111b
-00100111b & 11000000b = 00000000b
-00100111b & 11000001b = 00000001b
-00100111b & 11000010b = 00000010b
-00100111b & 11000011b = 00000011b
-00100111b & 11000100b = 00000100b
-00100111b & 11000101b = 00000101b
-00100111b & 11000110b = 00000110b
-00100111b & 11000111b = 00000111b
-00100111b & 11001000b = 00000000b
-00100111b & 11001001b = 00000001b
-00100111b & 11001010b = 00000010b
-00100111b & 11001011b = 00000011b
-00100111b & 11001100b = 00000100b
-00100111b & 11001101b = 00000101b
-00100111b & 11001110b = 00000110b
-00100111b & 11001111b = 00000111b
-00100111b & 11010000b = 00000000b
-00100111b & 11010001b = 00000001b
-00100111b & 11010010b = 00000010b
-00100111b & 11010011b = 00000011b
-00100111b & 11010100b = 00000100b
-00100111b & 11010101b = 00000101b
-00100111b & 11010110b = 00000110b
-00100111b & 11010111b = 00000111b
-00100111b & 11011000b = 00000000b
-00100111b & 11011001b = 00000001b
-00100111b & 11011010b = 00000010b
-00100111b & 11011011b = 00000011b
-00100111b & 11011100b = 00000100b
-00100111b & 11011101b = 00000101b
-00100111b & 11011110b = 00000110b
-00100111b & 11011111b = 00000111b
-00100111b & 11100000b = 00100000b
-00100111b & 11100001b = 00100001b
-00100111b & 11100010b = 00100010b
-00100111b & 11100011b = 00100011b
-00100111b & 11100100b = 00100100b
-00100111b & 11100101b = 00100101b
-00100111b & 11100110b = 00100110b
-00100111b & 11100111b = 00100111b
-00100111b & 11101000b = 00100000b
-00100111b & 11101001b = 00100001b
-00100111b & 11101010b = 00100010b
-00100111b & 11101011b = 00100011b
-00100111b & 11101100b = 00100100b
-00100111b & 11101101b = 00100101b
-00100111b & 11101110b = 00100110b
-00100111b & 11101111b = 00100111b
-00100111b & 11110000b = 00100000b
-00100111b & 11110001b = 00100001b
-00100111b & 11110010b = 00100010b
-00100111b & 11110011b = 00100011b
-00100111b & 11110100b = 00100100b
-00100111b & 11110101b = 00100101b
-00100111b & 11110110b = 00100110b
-00100111b & 11110111b = 00100111b
-00100111b & 11111000b = 00100000b
-00100111b & 11111001b = 00100001b
-00100111b & 11111010b = 00100010b
-00100111b & 11111011b = 00100011b
-00100111b & 11111100b = 00100100b
-00100111b & 11111101b = 00100101b
-00100111b & 11111110b = 00100110b
-00100111b & 11111111b = 00100111b
-00100111b & 00000000b = 00000000b
-00100111b & 00000001b = 00000001b
-00100111b & 00000010b = 00000010b
-00100111b & 00000011b = 00000011b
-00100111b & 00000100b = 00000100b
-00100111b & 00000101b = 00000101b
-00100111b & 00000110b = 00000110b
-00100111b & 00000111b = 00000111b
-00100111b & 00001000b = 00000000b
-00100111b & 00001001b = 00000001b
-00100111b & 00001010b = 00000010b
-00100111b & 00001011b = 00000011b
-00100111b & 00001100b = 00000100b
-00100111b & 00001101b = 00000101b
-00100111b & 00001110b = 00000110b
-00100111b & 00001111b = 00000111b
-00100111b & 00010000b = 00000000b
-00100111b & 00010001b = 00000001b
-00100111b & 00010010b = 00000010b
-00100111b & 00010011b = 00000011b
-00100111b & 00010100b = 00000100b
-00100111b & 00010101b = 00000101b
-00100111b & 00010110b = 00000110b
-00100111b & 00010111b = 00000111b
-00100111b & 00011000b = 00000000b
-00100111b & 00011001b = 00000001b
-00100111b & 00011010b = 00000010b
-00100111b & 00011011b = 00000011b
-00100111b & 00011100b = 00000100b
-00100111b & 00011101b = 00000101b
-00100111b & 00011110b = 00000110b
-00100111b & 00011111b = 00000111b
-00100111b & 00100000b = 00100000b
-00100111b & 00100001b = 00100001b
-00100111b & 00100010b = 00100010b
-00100111b & 00100011b = 00100011b
-00100111b & 00100100b = 00100100b
-00100111b & 00100101b = 00100101b
-00100111b & 00100110b = 00100110b
-00100111b & 00100111b = 00100111b
-00100111b & 00101000b = 00100000b
-00100111b & 00101001b = 00100001b
-00100111b & 00101010b = 00100010b
-00100111b & 00101011b = 00100011b
-00100111b & 00101100b = 00100100b
-00100111b & 00101101b = 00100101b
-00100111b & 00101110b = 00100110b
-00100111b & 00101111b = 00100111b
-00100111b & 00110000b = 00100000b
-00100111b & 00110001b = 00100001b
-00100111b & 00110010b = 00100010b
-00100111b & 00110011b = 00100011b
-00100111b & 00110100b = 00100100b
-00100111b & 00110101b = 00100101b
-00100111b & 00110110b = 00100110b
-00100111b & 00110111b = 00100111b
-00100111b & 00111000b = 00100000b
-00100111b & 00111001b = 00100001b
-00100111b & 00111010b = 00100010b
-00100111b & 00111011b = 00100011b
-00100111b & 00111100b = 00100100b
-00100111b & 00111101b = 00100101b
-00100111b & 00111110b = 00100110b
-00100111b & 00111111b = 00100111b
-00100111b & 01000000b = 00000000b
-00100111b & 01000001b = 00000001b
-00100111b & 01000010b = 00000010b
-00100111b & 01000011b = 00000011b
-00100111b & 01000100b = 00000100b
-00100111b & 01000101b = 00000101b
-00100111b & 01000110b = 00000110b
-00100111b & 01000111b = 00000111b
-00100111b & 01001000b = 00000000b
-00100111b & 01001001b = 00000001b
-00100111b & 01001010b = 00000010b
-00100111b & 01001011b = 00000011b
-00100111b & 01001100b = 00000100b
-00100111b & 01001101b = 00000101b
-00100111b & 01001110b = 00000110b
-00100111b & 01001111b = 00000111b
-00100111b & 01010000b = 00000000b
-00100111b & 01010001b = 00000001b
-00100111b & 01010010b = 00000010b
-00100111b & 01010011b = 00000011b
-00100111b & 01010100b = 00000100b
-00100111b & 01010101b = 00000101b
-00100111b & 01010110b = 00000110b
-00100111b & 01010111b = 00000111b
-00100111b & 01011000b = 00000000b
-00100111b & 01011001b = 00000001b
-00100111b & 01011010b = 00000010b
-00100111b & 01011011b = 00000011b
-00100111b & 01011100b = 00000100b
-00100111b & 01011101b = 00000101b
-00100111b & 01011110b = 00000110b
-00100111b & 01011111b = 00000111b
-00100111b & 01100000b = 00100000b
-00100111b & 01100001b = 00100001b
-00100111b & 01100010b = 00100010b
-00100111b & 01100011b = 00100011b
-00100111b & 01100100b = 00100100b
-00100111b & 01100101b = 00100101b
-00100111b & 01100110b = 00100110b
-00100111b & 01100111b = 00100111b
-00100111b & 01101000b = 00100000b
-00100111b & 01101001b = 00100001b
-00100111b & 01101010b = 00100010b
-00100111b & 01101011b = 00100011b
-00100111b & 01101100b = 00100100b
-00100111b & 01101101b = 00100101b
-00100111b & 01101110b = 00100110b
-00100111b & 01101111b = 00100111b
-00100111b & 01110000b = 00100000b
-00100111b & 01110001b = 00100001b
-00100111b & 01110010b = 00100010b
-00100111b & 01110011b = 00100011b
-00100111b & 01110100b = 00100100b
-00100111b & 01110101b = 00100101b
-00100111b & 01110110b = 00100110b
-00100111b & 01110111b = 00100111b
-00100111b & 01111000b = 00100000b
-00100111b & 01111001b = 00100001b
-00100111b & 01111010b = 00100010b
-00100111b & 01111011b = 00100011b
-00100111b & 01111100b = 00100100b
-00100111b & 01111101b = 00100101b
-00100111b & 01111110b = 00100110b
-00101000b & 10000000b = 00000000b
-00101000b & 10000001b = 00000000b
-00101000b & 10000010b = 00000000b
-00101000b & 10000011b = 00000000b
-00101000b & 10000100b = 00000000b
-00101000b & 10000101b = 00000000b
-00101000b & 10000110b = 00000000b
-00101000b & 10000111b = 00000000b
-00101000b & 10001000b = 00001000b
-00101000b & 10001001b = 00001000b
-00101000b & 10001010b = 00001000b
-00101000b & 10001011b = 00001000b
-00101000b & 10001100b = 00001000b
-00101000b & 10001101b = 00001000b
-00101000b & 10001110b = 00001000b
-00101000b & 10001111b = 00001000b
-00101000b & 10010000b = 00000000b
-00101000b & 10010001b = 00000000b
-00101000b & 10010010b = 00000000b
-00101000b & 10010011b = 00000000b
-00101000b & 10010100b = 00000000b
-00101000b & 10010101b = 00000000b
-00101000b & 10010110b = 00000000b
-00101000b & 10010111b = 00000000b
-00101000b & 10011000b = 00001000b
-00101000b & 10011001b = 00001000b
-00101000b & 10011010b = 00001000b
-00101000b & 10011011b = 00001000b
-00101000b & 10011100b = 00001000b
-00101000b & 10011101b = 00001000b
-00101000b & 10011110b = 00001000b
-00101000b & 10011111b = 00001000b
-00101000b & 10100000b = 00100000b
-00101000b & 10100001b = 00100000b
-00101000b & 10100010b = 00100000b
-00101000b & 10100011b = 00100000b
-00101000b & 10100100b = 00100000b
-00101000b & 10100101b = 00100000b
-00101000b & 10100110b = 00100000b
-00101000b & 10100111b = 00100000b
-00101000b & 10101000b = 00101000b
-00101000b & 10101001b = 00101000b
-00101000b & 10101010b = 00101000b
-00101000b & 10101011b = 00101000b
-00101000b & 10101100b = 00101000b
-00101000b & 10101101b = 00101000b
-00101000b & 10101110b = 00101000b
-00101000b & 10101111b = 00101000b
-00101000b & 10110000b = 00100000b
-00101000b & 10110001b = 00100000b
-00101000b & 10110010b = 00100000b
-00101000b & 10110011b = 00100000b
-00101000b & 10110100b = 00100000b
-00101000b & 10110101b = 00100000b
-00101000b & 10110110b = 00100000b
-00101000b & 10110111b = 00100000b
-00101000b & 10111000b = 00101000b
-00101000b & 10111001b = 00101000b
-00101000b & 10111010b = 00101000b
-00101000b & 10111011b = 00101000b
-00101000b & 10111100b = 00101000b
-00101000b & 10111101b = 00101000b
-00101000b & 10111110b = 00101000b
-00101000b & 10111111b = 00101000b
-00101000b & 11000000b = 00000000b
-00101000b & 11000001b = 00000000b
-00101000b & 11000010b = 00000000b
-00101000b & 11000011b = 00000000b
-00101000b & 11000100b = 00000000b
-00101000b & 11000101b = 00000000b
-00101000b & 11000110b = 00000000b
-00101000b & 11000111b = 00000000b
-00101000b & 11001000b = 00001000b
-00101000b & 11001001b = 00001000b
-00101000b & 11001010b = 00001000b
-00101000b & 11001011b = 00001000b
-00101000b & 11001100b = 00001000b
-00101000b & 11001101b = 00001000b
-00101000b & 11001110b = 00001000b
-00101000b & 11001111b = 00001000b
-00101000b & 11010000b = 00000000b
-00101000b & 11010001b = 00000000b
-00101000b & 11010010b = 00000000b
-00101000b & 11010011b = 00000000b
-00101000b & 11010100b = 00000000b
-00101000b & 11010101b = 00000000b
-00101000b & 11010110b = 00000000b
-00101000b & 11010111b = 00000000b
-00101000b & 11011000b = 00001000b
-00101000b & 11011001b = 00001000b
-00101000b & 11011010b = 00001000b
-00101000b & 11011011b = 00001000b
-00101000b & 11011100b = 00001000b
-00101000b & 11011101b = 00001000b
-00101000b & 11011110b = 00001000b
-00101000b & 11011111b = 00001000b
-00101000b & 11100000b = 00100000b
-00101000b & 11100001b = 00100000b
-00101000b & 11100010b = 00100000b
-00101000b & 11100011b = 00100000b
-00101000b & 11100100b = 00100000b
-00101000b & 11100101b = 00100000b
-00101000b & 11100110b = 00100000b
-00101000b & 11100111b = 00100000b
-00101000b & 11101000b = 00101000b
-00101000b & 11101001b = 00101000b
-00101000b & 11101010b = 00101000b
-00101000b & 11101011b = 00101000b
-00101000b & 11101100b = 00101000b
-00101000b & 11101101b = 00101000b
-00101000b & 11101110b = 00101000b
-00101000b & 11101111b = 00101000b
-00101000b & 11110000b = 00100000b
-00101000b & 11110001b = 00100000b
-00101000b & 11110010b = 00100000b
-00101000b & 11110011b = 00100000b
-00101000b & 11110100b = 00100000b
-00101000b & 11110101b = 00100000b
-00101000b & 11110110b = 00100000b
-00101000b & 11110111b = 00100000b
-00101000b & 11111000b = 00101000b
-00101000b & 11111001b = 00101000b
-00101000b & 11111010b = 00101000b
-00101000b & 11111011b = 00101000b
-00101000b & 11111100b = 00101000b
-00101000b & 11111101b = 00101000b
-00101000b & 11111110b = 00101000b
-00101000b & 11111111b = 00101000b
-00101000b & 00000000b = 00000000b
-00101000b & 00000001b = 00000000b
-00101000b & 00000010b = 00000000b
-00101000b & 00000011b = 00000000b
-00101000b & 00000100b = 00000000b
-00101000b & 00000101b = 00000000b
-00101000b & 00000110b = 00000000b
-00101000b & 00000111b = 00000000b
-00101000b & 00001000b = 00001000b
-00101000b & 00001001b = 00001000b
-00101000b & 00001010b = 00001000b
-00101000b & 00001011b = 00001000b
-00101000b & 00001100b = 00001000b
-00101000b & 00001101b = 00001000b
-00101000b & 00001110b = 00001000b
-00101000b & 00001111b = 00001000b
-00101000b & 00010000b = 00000000b
-00101000b & 00010001b = 00000000b
-00101000b & 00010010b = 00000000b
-00101000b & 00010011b = 00000000b
-00101000b & 00010100b = 00000000b
-00101000b & 00010101b = 00000000b
-00101000b & 00010110b = 00000000b
-00101000b & 00010111b = 00000000b
-00101000b & 00011000b = 00001000b
-00101000b & 00011001b = 00001000b
-00101000b & 00011010b = 00001000b
-00101000b & 00011011b = 00001000b
-00101000b & 00011100b = 00001000b
-00101000b & 00011101b = 00001000b
-00101000b & 00011110b = 00001000b
-00101000b & 00011111b = 00001000b
-00101000b & 00100000b = 00100000b
-00101000b & 00100001b = 00100000b
-00101000b & 00100010b = 00100000b
-00101000b & 00100011b = 00100000b
-00101000b & 00100100b = 00100000b
-00101000b & 00100101b = 00100000b
-00101000b & 00100110b = 00100000b
-00101000b & 00100111b = 00100000b
-00101000b & 00101000b = 00101000b
-00101000b & 00101001b = 00101000b
-00101000b & 00101010b = 00101000b
-00101000b & 00101011b = 00101000b
-00101000b & 00101100b = 00101000b
-00101000b & 00101101b = 00101000b
-00101000b & 00101110b = 00101000b
-00101000b & 00101111b = 00101000b
-00101000b & 00110000b = 00100000b
-00101000b & 00110001b = 00100000b
-00101000b & 00110010b = 00100000b
-00101000b & 00110011b = 00100000b
-00101000b & 00110100b = 00100000b
-00101000b & 00110101b = 00100000b
-00101000b & 00110110b = 00100000b
-00101000b & 00110111b = 00100000b
-00101000b & 00111000b = 00101000b
-00101000b & 00111001b = 00101000b
-00101000b & 00111010b = 00101000b
-00101000b & 00111011b = 00101000b
-00101000b & 00111100b = 00101000b
-00101000b & 00111101b = 00101000b
-00101000b & 00111110b = 00101000b
-00101000b & 00111111b = 00101000b
-00101000b & 01000000b = 00000000b
-00101000b & 01000001b = 00000000b
-00101000b & 01000010b = 00000000b
-00101000b & 01000011b = 00000000b
-00101000b & 01000100b = 00000000b
-00101000b & 01000101b = 00000000b
-00101000b & 01000110b = 00000000b
-00101000b & 01000111b = 00000000b
-00101000b & 01001000b = 00001000b
-00101000b & 01001001b = 00001000b
-00101000b & 01001010b = 00001000b
-00101000b & 01001011b = 00001000b
-00101000b & 01001100b = 00001000b
-00101000b & 01001101b = 00001000b
-00101000b & 01001110b = 00001000b
-00101000b & 01001111b = 00001000b
-00101000b & 01010000b = 00000000b
-00101000b & 01010001b = 00000000b
-00101000b & 01010010b = 00000000b
-00101000b & 01010011b = 00000000b
-00101000b & 01010100b = 00000000b
-00101000b & 01010101b = 00000000b
-00101000b & 01010110b = 00000000b
-00101000b & 01010111b = 00000000b
-00101000b & 01011000b = 00001000b
-00101000b & 01011001b = 00001000b
-00101000b & 01011010b = 00001000b
-00101000b & 01011011b = 00001000b
-00101000b & 01011100b = 00001000b
-00101000b & 01011101b = 00001000b
-00101000b & 01011110b = 00001000b
-00101000b & 01011111b = 00001000b
-00101000b & 01100000b = 00100000b
-00101000b & 01100001b = 00100000b
-00101000b & 01100010b = 00100000b
-00101000b & 01100011b = 00100000b
-00101000b & 01100100b = 00100000b
-00101000b & 01100101b = 00100000b
-00101000b & 01100110b = 00100000b
-00101000b & 01100111b = 00100000b
-00101000b & 01101000b = 00101000b
-00101000b & 01101001b = 00101000b
-00101000b & 01101010b = 00101000b
-00101000b & 01101011b = 00101000b
-00101000b & 01101100b = 00101000b
-00101000b & 01101101b = 00101000b
-00101000b & 01101110b = 00101000b
-00101000b & 01101111b = 00101000b
-00101000b & 01110000b = 00100000b
-00101000b & 01110001b = 00100000b
-00101000b & 01110010b = 00100000b
-00101000b & 01110011b = 00100000b
-00101000b & 01110100b = 00100000b
-00101000b & 01110101b = 00100000b
-00101000b & 01110110b = 00100000b
-00101000b & 01110111b = 00100000b
-00101000b & 01111000b = 00101000b
-00101000b & 01111001b = 00101000b
-00101000b & 01111010b = 00101000b
-00101000b & 01111011b = 00101000b
-00101000b & 01111100b = 00101000b
-00101000b & 01111101b = 00101000b
-00101000b & 01111110b = 00101000b
-00101001b & 10000000b = 00000000b
-00101001b & 10000001b = 00000001b
-00101001b & 10000010b = 00000000b
-00101001b & 10000011b = 00000001b
-00101001b & 10000100b = 00000000b
-00101001b & 10000101b = 00000001b
-00101001b & 10000110b = 00000000b
-00101001b & 10000111b = 00000001b
-00101001b & 10001000b = 00001000b
-00101001b & 10001001b = 00001001b
-00101001b & 10001010b = 00001000b
-00101001b & 10001011b = 00001001b
-00101001b & 10001100b = 00001000b
-00101001b & 10001101b = 00001001b
-00101001b & 10001110b = 00001000b
-00101001b & 10001111b = 00001001b
-00101001b & 10010000b = 00000000b
-00101001b & 10010001b = 00000001b
-00101001b & 10010010b = 00000000b
-00101001b & 10010011b = 00000001b
-00101001b & 10010100b = 00000000b
-00101001b & 10010101b = 00000001b
-00101001b & 10010110b = 00000000b
-00101001b & 10010111b = 00000001b
-00101001b & 10011000b = 00001000b
-00101001b & 10011001b = 00001001b
-00101001b & 10011010b = 00001000b
-00101001b & 10011011b = 00001001b
-00101001b & 10011100b = 00001000b
-00101001b & 10011101b = 00001001b
-00101001b & 10011110b = 00001000b
-00101001b & 10011111b = 00001001b
-00101001b & 10100000b = 00100000b
-00101001b & 10100001b = 00100001b
-00101001b & 10100010b = 00100000b
-00101001b & 10100011b = 00100001b
-00101001b & 10100100b = 00100000b
-00101001b & 10100101b = 00100001b
-00101001b & 10100110b = 00100000b
-00101001b & 10100111b = 00100001b
-00101001b & 10101000b = 00101000b
-00101001b & 10101001b = 00101001b
-00101001b & 10101010b = 00101000b
-00101001b & 10101011b = 00101001b
-00101001b & 10101100b = 00101000b
-00101001b & 10101101b = 00101001b
-00101001b & 10101110b = 00101000b
-00101001b & 10101111b = 00101001b
-00101001b & 10110000b = 00100000b
-00101001b & 10110001b = 00100001b
-00101001b & 10110010b = 00100000b
-00101001b & 10110011b = 00100001b
-00101001b & 10110100b = 00100000b
-00101001b & 10110101b = 00100001b
-00101001b & 10110110b = 00100000b
-00101001b & 10110111b = 00100001b
-00101001b & 10111000b = 00101000b
-00101001b & 10111001b = 00101001b
-00101001b & 10111010b = 00101000b
-00101001b & 10111011b = 00101001b
-00101001b & 10111100b = 00101000b
-00101001b & 10111101b = 00101001b
-00101001b & 10111110b = 00101000b
-00101001b & 10111111b = 00101001b
-00101001b & 11000000b = 00000000b
-00101001b & 11000001b = 00000001b
-00101001b & 11000010b = 00000000b
-00101001b & 11000011b = 00000001b
-00101001b & 11000100b = 00000000b
-00101001b & 11000101b = 00000001b
-00101001b & 11000110b = 00000000b
-00101001b & 11000111b = 00000001b
-00101001b & 11001000b = 00001000b
-00101001b & 11001001b = 00001001b
-00101001b & 11001010b = 00001000b
-00101001b & 11001011b = 00001001b
-00101001b & 11001100b = 00001000b
-00101001b & 11001101b = 00001001b
-00101001b & 11001110b = 00001000b
-00101001b & 11001111b = 00001001b
-00101001b & 11010000b = 00000000b
-00101001b & 11010001b = 00000001b
-00101001b & 11010010b = 00000000b
-00101001b & 11010011b = 00000001b
-00101001b & 11010100b = 00000000b
-00101001b & 11010101b = 00000001b
-00101001b & 11010110b = 00000000b
-00101001b & 11010111b = 00000001b
-00101001b & 11011000b = 00001000b
-00101001b & 11011001b = 00001001b
-00101001b & 11011010b = 00001000b
-00101001b & 11011011b = 00001001b
-00101001b & 11011100b = 00001000b
-00101001b & 11011101b = 00001001b
-00101001b & 11011110b = 00001000b
-00101001b & 11011111b = 00001001b
-00101001b & 11100000b = 00100000b
-00101001b & 11100001b = 00100001b
-00101001b & 11100010b = 00100000b
-00101001b & 11100011b = 00100001b
-00101001b & 11100100b = 00100000b
-00101001b & 11100101b = 00100001b
-00101001b & 11100110b = 00100000b
-00101001b & 11100111b = 00100001b
-00101001b & 11101000b = 00101000b
-00101001b & 11101001b = 00101001b
-00101001b & 11101010b = 00101000b
-00101001b & 11101011b = 00101001b
-00101001b & 11101100b = 00101000b
-00101001b & 11101101b = 00101001b
-00101001b & 11101110b = 00101000b
-00101001b & 11101111b = 00101001b
-00101001b & 11110000b = 00100000b
-00101001b & 11110001b = 00100001b
-00101001b & 11110010b = 00100000b
-00101001b & 11110011b = 00100001b
-00101001b & 11110100b = 00100000b
-00101001b & 11110101b = 00100001b
-00101001b & 11110110b = 00100000b
-00101001b & 11110111b = 00100001b
-00101001b & 11111000b = 00101000b
-00101001b & 11111001b = 00101001b
-00101001b & 11111010b = 00101000b
-00101001b & 11111011b = 00101001b
-00101001b & 11111100b = 00101000b
-00101001b & 11111101b = 00101001b
-00101001b & 11111110b = 00101000b
-00101001b & 11111111b = 00101001b
-00101001b & 00000000b = 00000000b
-00101001b & 00000001b = 00000001b
-00101001b & 00000010b = 00000000b
-00101001b & 00000011b = 00000001b
-00101001b & 00000100b = 00000000b
-00101001b & 00000101b = 00000001b
-00101001b & 00000110b = 00000000b
-00101001b & 00000111b = 00000001b
-00101001b & 00001000b = 00001000b
-00101001b & 00001001b = 00001001b
-00101001b & 00001010b = 00001000b
-00101001b & 00001011b = 00001001b
-00101001b & 00001100b = 00001000b
-00101001b & 00001101b = 00001001b
-00101001b & 00001110b = 00001000b
-00101001b & 00001111b = 00001001b
-00101001b & 00010000b = 00000000b
-00101001b & 00010001b = 00000001b
-00101001b & 00010010b = 00000000b
-00101001b & 00010011b = 00000001b
-00101001b & 00010100b = 00000000b
-00101001b & 00010101b = 00000001b
-00101001b & 00010110b = 00000000b
-00101001b & 00010111b = 00000001b
-00101001b & 00011000b = 00001000b
-00101001b & 00011001b = 00001001b
-00101001b & 00011010b = 00001000b
-00101001b & 00011011b = 00001001b
-00101001b & 00011100b = 00001000b
-00101001b & 00011101b = 00001001b
-00101001b & 00011110b = 00001000b
-00101001b & 00011111b = 00001001b
-00101001b & 00100000b = 00100000b
-00101001b & 00100001b = 00100001b
-00101001b & 00100010b = 00100000b
-00101001b & 00100011b = 00100001b
-00101001b & 00100100b = 00100000b
-00101001b & 00100101b = 00100001b
-00101001b & 00100110b = 00100000b
-00101001b & 00100111b = 00100001b
-00101001b & 00101000b = 00101000b
-00101001b & 00101001b = 00101001b
-00101001b & 00101010b = 00101000b
-00101001b & 00101011b = 00101001b
-00101001b & 00101100b = 00101000b
-00101001b & 00101101b = 00101001b
-00101001b & 00101110b = 00101000b
-00101001b & 00101111b = 00101001b
-00101001b & 00110000b = 00100000b
-00101001b & 00110001b = 00100001b
-00101001b & 00110010b = 00100000b
-00101001b & 00110011b = 00100001b
-00101001b & 00110100b = 00100000b
-00101001b & 00110101b = 00100001b
-00101001b & 00110110b = 00100000b
-00101001b & 00110111b = 00100001b
-00101001b & 00111000b = 00101000b
-00101001b & 00111001b = 00101001b
-00101001b & 00111010b = 00101000b
-00101001b & 00111011b = 00101001b
-00101001b & 00111100b = 00101000b
-00101001b & 00111101b = 00101001b
-00101001b & 00111110b = 00101000b
-00101001b & 00111111b = 00101001b
-00101001b & 01000000b = 00000000b
-00101001b & 01000001b = 00000001b
-00101001b & 01000010b = 00000000b
-00101001b & 01000011b = 00000001b
-00101001b & 01000100b = 00000000b
-00101001b & 01000101b = 00000001b
-00101001b & 01000110b = 00000000b
-00101001b & 01000111b = 00000001b
-00101001b & 01001000b = 00001000b
-00101001b & 01001001b = 00001001b
-00101001b & 01001010b = 00001000b
-00101001b & 01001011b = 00001001b
-00101001b & 01001100b = 00001000b
-00101001b & 01001101b = 00001001b
-00101001b & 01001110b = 00001000b
-00101001b & 01001111b = 00001001b
-00101001b & 01010000b = 00000000b
-00101001b & 01010001b = 00000001b
-00101001b & 01010010b = 00000000b
-00101001b & 01010011b = 00000001b
-00101001b & 01010100b = 00000000b
-00101001b & 01010101b = 00000001b
-00101001b & 01010110b = 00000000b
-00101001b & 01010111b = 00000001b
-00101001b & 01011000b = 00001000b
-00101001b & 01011001b = 00001001b
-00101001b & 01011010b = 00001000b
-00101001b & 01011011b = 00001001b
-00101001b & 01011100b = 00001000b
-00101001b & 01011101b = 00001001b
-00101001b & 01011110b = 00001000b
-00101001b & 01011111b = 00001001b
-00101001b & 01100000b = 00100000b
-00101001b & 01100001b = 00100001b
-00101001b & 01100010b = 00100000b
-00101001b & 01100011b = 00100001b
-00101001b & 01100100b = 00100000b
-00101001b & 01100101b = 00100001b
-00101001b & 01100110b = 00100000b
-00101001b & 01100111b = 00100001b
-00101001b & 01101000b = 00101000b
-00101001b & 01101001b = 00101001b
-00101001b & 01101010b = 00101000b
-00101001b & 01101011b = 00101001b
-00101001b & 01101100b = 00101000b
-00101001b & 01101101b = 00101001b
-00101001b & 01101110b = 00101000b
-00101001b & 01101111b = 00101001b
-00101001b & 01110000b = 00100000b
-00101001b & 01110001b = 00100001b
-00101001b & 01110010b = 00100000b
-00101001b & 01110011b = 00100001b
-00101001b & 01110100b = 00100000b
-00101001b & 01110101b = 00100001b
-00101001b & 01110110b = 00100000b
-00101001b & 01110111b = 00100001b
-00101001b & 01111000b = 00101000b
-00101001b & 01111001b = 00101001b
-00101001b & 01111010b = 00101000b
-00101001b & 01111011b = 00101001b
-00101001b & 01111100b = 00101000b
-00101001b & 01111101b = 00101001b
-00101001b & 01111110b = 00101000b
-00101010b & 10000000b = 00000000b
-00101010b & 10000001b = 00000000b
-00101010b & 10000010b = 00000010b
-00101010b & 10000011b = 00000010b
-00101010b & 10000100b = 00000000b
-00101010b & 10000101b = 00000000b
-00101010b & 10000110b = 00000010b
-00101010b & 10000111b = 00000010b
-00101010b & 10001000b = 00001000b
-00101010b & 10001001b = 00001000b
-00101010b & 10001010b = 00001010b
-00101010b & 10001011b = 00001010b
-00101010b & 10001100b = 00001000b
-00101010b & 10001101b = 00001000b
-00101010b & 10001110b = 00001010b
-00101010b & 10001111b = 00001010b
-00101010b & 10010000b = 00000000b
-00101010b & 10010001b = 00000000b
-00101010b & 10010010b = 00000010b
-00101010b & 10010011b = 00000010b
-00101010b & 10010100b = 00000000b
-00101010b & 10010101b = 00000000b
-00101010b & 10010110b = 00000010b
-00101010b & 10010111b = 00000010b
-00101010b & 10011000b = 00001000b
-00101010b & 10011001b = 00001000b
-00101010b & 10011010b = 00001010b
-00101010b & 10011011b = 00001010b
-00101010b & 10011100b = 00001000b
-00101010b & 10011101b = 00001000b
-00101010b & 10011110b = 00001010b
-00101010b & 10011111b = 00001010b
-00101010b & 10100000b = 00100000b
-00101010b & 10100001b = 00100000b
-00101010b & 10100010b = 00100010b
-00101010b & 10100011b = 00100010b
-00101010b & 10100100b = 00100000b
-00101010b & 10100101b = 00100000b
-00101010b & 10100110b = 00100010b
-00101010b & 10100111b = 00100010b
-00101010b & 10101000b = 00101000b
-00101010b & 10101001b = 00101000b
-00101010b & 10101010b = 00101010b
-00101010b & 10101011b = 00101010b
-00101010b & 10101100b = 00101000b
-00101010b & 10101101b = 00101000b
-00101010b & 10101110b = 00101010b
-00101010b & 10101111b = 00101010b
-00101010b & 10110000b = 00100000b
-00101010b & 10110001b = 00100000b
-00101010b & 10110010b = 00100010b
-00101010b & 10110011b = 00100010b
-00101010b & 10110100b = 00100000b
-00101010b & 10110101b = 00100000b
-00101010b & 10110110b = 00100010b
-00101010b & 10110111b = 00100010b
-00101010b & 10111000b = 00101000b
-00101010b & 10111001b = 00101000b
-00101010b & 10111010b = 00101010b
-00101010b & 10111011b = 00101010b
-00101010b & 10111100b = 00101000b
-00101010b & 10111101b = 00101000b
-00101010b & 10111110b = 00101010b
-00101010b & 10111111b = 00101010b
-00101010b & 11000000b = 00000000b
-00101010b & 11000001b = 00000000b
-00101010b & 11000010b = 00000010b
-00101010b & 11000011b = 00000010b
-00101010b & 11000100b = 00000000b
-00101010b & 11000101b = 00000000b
-00101010b & 11000110b = 00000010b
-00101010b & 11000111b = 00000010b
-00101010b & 11001000b = 00001000b
-00101010b & 11001001b = 00001000b
-00101010b & 11001010b = 00001010b
-00101010b & 11001011b = 00001010b
-00101010b & 11001100b = 00001000b
-00101010b & 11001101b = 00001000b
-00101010b & 11001110b = 00001010b
-00101010b & 11001111b = 00001010b
-00101010b & 11010000b = 00000000b
-00101010b & 11010001b = 00000000b
-00101010b & 11010010b = 00000010b
-00101010b & 11010011b = 00000010b
-00101010b & 11010100b = 00000000b
-00101010b & 11010101b = 00000000b
-00101010b & 11010110b = 00000010b
-00101010b & 11010111b = 00000010b
-00101010b & 11011000b = 00001000b
-00101010b & 11011001b = 00001000b
-00101010b & 11011010b = 00001010b
-00101010b & 11011011b = 00001010b
-00101010b & 11011100b = 00001000b
-00101010b & 11011101b = 00001000b
-00101010b & 11011110b = 00001010b
-00101010b & 11011111b = 00001010b
-00101010b & 11100000b = 00100000b
-00101010b & 11100001b = 00100000b
-00101010b & 11100010b = 00100010b
-00101010b & 11100011b = 00100010b
-00101010b & 11100100b = 00100000b
-00101010b & 11100101b = 00100000b
-00101010b & 11100110b = 00100010b
-00101010b & 11100111b = 00100010b
-00101010b & 11101000b = 00101000b
-00101010b & 11101001b = 00101000b
-00101010b & 11101010b = 00101010b
-00101010b & 11101011b = 00101010b
-00101010b & 11101100b = 00101000b
-00101010b & 11101101b = 00101000b
-00101010b & 11101110b = 00101010b
-00101010b & 11101111b = 00101010b
-00101010b & 11110000b = 00100000b
-00101010b & 11110001b = 00100000b
-00101010b & 11110010b = 00100010b
-00101010b & 11110011b = 00100010b
-00101010b & 11110100b = 00100000b
-00101010b & 11110101b = 00100000b
-00101010b & 11110110b = 00100010b
-00101010b & 11110111b = 00100010b
-00101010b & 11111000b = 00101000b
-00101010b & 11111001b = 00101000b
-00101010b & 11111010b = 00101010b
-00101010b & 11111011b = 00101010b
-00101010b & 11111100b = 00101000b
-00101010b & 11111101b = 00101000b
-00101010b & 11111110b = 00101010b
-00101010b & 11111111b = 00101010b
-00101010b & 00000000b = 00000000b
-00101010b & 00000001b = 00000000b
-00101010b & 00000010b = 00000010b
-00101010b & 00000011b = 00000010b
-00101010b & 00000100b = 00000000b
-00101010b & 00000101b = 00000000b
-00101010b & 00000110b = 00000010b
-00101010b & 00000111b = 00000010b
-00101010b & 00001000b = 00001000b
-00101010b & 00001001b = 00001000b
-00101010b & 00001010b = 00001010b
-00101010b & 00001011b = 00001010b
-00101010b & 00001100b = 00001000b
-00101010b & 00001101b = 00001000b
-00101010b & 00001110b = 00001010b
-00101010b & 00001111b = 00001010b
-00101010b & 00010000b = 00000000b
-00101010b & 00010001b = 00000000b
-00101010b & 00010010b = 00000010b
-00101010b & 00010011b = 00000010b
-00101010b & 00010100b = 00000000b
-00101010b & 00010101b = 00000000b
-00101010b & 00010110b = 00000010b
-00101010b & 00010111b = 00000010b
-00101010b & 00011000b = 00001000b
-00101010b & 00011001b = 00001000b
-00101010b & 00011010b = 00001010b
-00101010b & 00011011b = 00001010b
-00101010b & 00011100b = 00001000b
-00101010b & 00011101b = 00001000b
-00101010b & 00011110b = 00001010b
-00101010b & 00011111b = 00001010b
-00101010b & 00100000b = 00100000b
-00101010b & 00100001b = 00100000b
-00101010b & 00100010b = 00100010b
-00101010b & 00100011b = 00100010b
-00101010b & 00100100b = 00100000b
-00101010b & 00100101b = 00100000b
-00101010b & 00100110b = 00100010b
-00101010b & 00100111b = 00100010b
-00101010b & 00101000b = 00101000b
-00101010b & 00101001b = 00101000b
-00101010b & 00101010b = 00101010b
-00101010b & 00101011b = 00101010b
-00101010b & 00101100b = 00101000b
-00101010b & 00101101b = 00101000b
-00101010b & 00101110b = 00101010b
-00101010b & 00101111b = 00101010b
-00101010b & 00110000b = 00100000b
-00101010b & 00110001b = 00100000b
-00101010b & 00110010b = 00100010b
-00101010b & 00110011b = 00100010b
-00101010b & 00110100b = 00100000b
-00101010b & 00110101b = 00100000b
-00101010b & 00110110b = 00100010b
-00101010b & 00110111b = 00100010b
-00101010b & 00111000b = 00101000b
-00101010b & 00111001b = 00101000b
-00101010b & 00111010b = 00101010b
-00101010b & 00111011b = 00101010b
-00101010b & 00111100b = 00101000b
-00101010b & 00111101b = 00101000b
-00101010b & 00111110b = 00101010b
-00101010b & 00111111b = 00101010b
-00101010b & 01000000b = 00000000b
-00101010b & 01000001b = 00000000b
-00101010b & 01000010b = 00000010b
-00101010b & 01000011b = 00000010b
-00101010b & 01000100b = 00000000b
-00101010b & 01000101b = 00000000b
-00101010b & 01000110b = 00000010b
-00101010b & 01000111b = 00000010b
-00101010b & 01001000b = 00001000b
-00101010b & 01001001b = 00001000b
-00101010b & 01001010b = 00001010b
-00101010b & 01001011b = 00001010b
-00101010b & 01001100b = 00001000b
-00101010b & 01001101b = 00001000b
-00101010b & 01001110b = 00001010b
-00101010b & 01001111b = 00001010b
-00101010b & 01010000b = 00000000b
-00101010b & 01010001b = 00000000b
-00101010b & 01010010b = 00000010b
-00101010b & 01010011b = 00000010b
-00101010b & 01010100b = 00000000b
-00101010b & 01010101b = 00000000b
-00101010b & 01010110b = 00000010b
-00101010b & 01010111b = 00000010b
-00101010b & 01011000b = 00001000b
-00101010b & 01011001b = 00001000b
-00101010b & 01011010b = 00001010b
-00101010b & 01011011b = 00001010b
-00101010b & 01011100b = 00001000b
-00101010b & 01011101b = 00001000b
-00101010b & 01011110b = 00001010b
-00101010b & 01011111b = 00001010b
-00101010b & 01100000b = 00100000b
-00101010b & 01100001b = 00100000b
-00101010b & 01100010b = 00100010b
-00101010b & 01100011b = 00100010b
-00101010b & 01100100b = 00100000b
-00101010b & 01100101b = 00100000b
-00101010b & 01100110b = 00100010b
-00101010b & 01100111b = 00100010b
-00101010b & 01101000b = 00101000b
-00101010b & 01101001b = 00101000b
-00101010b & 01101010b = 00101010b
-00101010b & 01101011b = 00101010b
-00101010b & 01101100b = 00101000b
-00101010b & 01101101b = 00101000b
-00101010b & 01101110b = 00101010b
-00101010b & 01101111b = 00101010b
-00101010b & 01110000b = 00100000b
-00101010b & 01110001b = 00100000b
-00101010b & 01110010b = 00100010b
-00101010b & 01110011b = 00100010b
-00101010b & 01110100b = 00100000b
-00101010b & 01110101b = 00100000b
-00101010b & 01110110b = 00100010b
-00101010b & 01110111b = 00100010b
-00101010b & 01111000b = 00101000b
-00101010b & 01111001b = 00101000b
-00101010b & 01111010b = 00101010b
-00101010b & 01111011b = 00101010b
-00101010b & 01111100b = 00101000b
-00101010b & 01111101b = 00101000b
-00101010b & 01111110b = 00101010b
-00101011b & 10000000b = 00000000b
-00101011b & 10000001b = 00000001b
-00101011b & 10000010b = 00000010b
-00101011b & 10000011b = 00000011b
-00101011b & 10000100b = 00000000b
-00101011b & 10000101b = 00000001b
-00101011b & 10000110b = 00000010b
-00101011b & 10000111b = 00000011b
-00101011b & 10001000b = 00001000b
-00101011b & 10001001b = 00001001b
-00101011b & 10001010b = 00001010b
-00101011b & 10001011b = 00001011b
-00101011b & 10001100b = 00001000b
-00101011b & 10001101b = 00001001b
-00101011b & 10001110b = 00001010b
-00101011b & 10001111b = 00001011b
-00101011b & 10010000b = 00000000b
-00101011b & 10010001b = 00000001b
-00101011b & 10010010b = 00000010b
-00101011b & 10010011b = 00000011b
-00101011b & 10010100b = 00000000b
-00101011b & 10010101b = 00000001b
-00101011b & 10010110b = 00000010b
-00101011b & 10010111b = 00000011b
-00101011b & 10011000b = 00001000b
-00101011b & 10011001b = 00001001b
-00101011b & 10011010b = 00001010b
-00101011b & 10011011b = 00001011b
-00101011b & 10011100b = 00001000b
-00101011b & 10011101b = 00001001b
-00101011b & 10011110b = 00001010b
-00101011b & 10011111b = 00001011b
-00101011b & 10100000b = 00100000b
-00101011b & 10100001b = 00100001b
-00101011b & 10100010b = 00100010b
-00101011b & 10100011b = 00100011b
-00101011b & 10100100b = 00100000b
-00101011b & 10100101b = 00100001b
-00101011b & 10100110b = 00100010b
-00101011b & 10100111b = 00100011b
-00101011b & 10101000b = 00101000b
-00101011b & 10101001b = 00101001b
-00101011b & 10101010b = 00101010b
-00101011b & 10101011b = 00101011b
-00101011b & 10101100b = 00101000b
-00101011b & 10101101b = 00101001b
-00101011b & 10101110b = 00101010b
-00101011b & 10101111b = 00101011b
-00101011b & 10110000b = 00100000b
-00101011b & 10110001b = 00100001b
-00101011b & 10110010b = 00100010b
-00101011b & 10110011b = 00100011b
-00101011b & 10110100b = 00100000b
-00101011b & 10110101b = 00100001b
-00101011b & 10110110b = 00100010b
-00101011b & 10110111b = 00100011b
-00101011b & 10111000b = 00101000b
-00101011b & 10111001b = 00101001b
-00101011b & 10111010b = 00101010b
-00101011b & 10111011b = 00101011b
-00101011b & 10111100b = 00101000b
-00101011b & 10111101b = 00101001b
-00101011b & 10111110b = 00101010b
-00101011b & 10111111b = 00101011b
-00101011b & 11000000b = 00000000b
-00101011b & 11000001b = 00000001b
-00101011b & 11000010b = 00000010b
-00101011b & 11000011b = 00000011b
-00101011b & 11000100b = 00000000b
-00101011b & 11000101b = 00000001b
-00101011b & 11000110b = 00000010b
-00101011b & 11000111b = 00000011b
-00101011b & 11001000b = 00001000b
-00101011b & 11001001b = 00001001b
-00101011b & 11001010b = 00001010b
-00101011b & 11001011b = 00001011b
-00101011b & 11001100b = 00001000b
-00101011b & 11001101b = 00001001b
-00101011b & 11001110b = 00001010b
-00101011b & 11001111b = 00001011b
-00101011b & 11010000b = 00000000b
-00101011b & 11010001b = 00000001b
-00101011b & 11010010b = 00000010b
-00101011b & 11010011b = 00000011b
-00101011b & 11010100b = 00000000b
-00101011b & 11010101b = 00000001b
-00101011b & 11010110b = 00000010b
-00101011b & 11010111b = 00000011b
-00101011b & 11011000b = 00001000b
-00101011b & 11011001b = 00001001b
-00101011b & 11011010b = 00001010b
-00101011b & 11011011b = 00001011b
-00101011b & 11011100b = 00001000b
-00101011b & 11011101b = 00001001b
-00101011b & 11011110b = 00001010b
-00101011b & 11011111b = 00001011b
-00101011b & 11100000b = 00100000b
-00101011b & 11100001b = 00100001b
-00101011b & 11100010b = 00100010b
-00101011b & 11100011b = 00100011b
-00101011b & 11100100b = 00100000b
-00101011b & 11100101b = 00100001b
-00101011b & 11100110b = 00100010b
-00101011b & 11100111b = 00100011b
-00101011b & 11101000b = 00101000b
-00101011b & 11101001b = 00101001b
-00101011b & 11101010b = 00101010b
-00101011b & 11101011b = 00101011b
-00101011b & 11101100b = 00101000b
-00101011b & 11101101b = 00101001b
-00101011b & 11101110b = 00101010b
-00101011b & 11101111b = 00101011b
-00101011b & 11110000b = 00100000b
-00101011b & 11110001b = 00100001b
-00101011b & 11110010b = 00100010b
-00101011b & 11110011b = 00100011b
-00101011b & 11110100b = 00100000b
-00101011b & 11110101b = 00100001b
-00101011b & 11110110b = 00100010b
-00101011b & 11110111b = 00100011b
-00101011b & 11111000b = 00101000b
-00101011b & 11111001b = 00101001b
-00101011b & 11111010b = 00101010b
-00101011b & 11111011b = 00101011b
-00101011b & 11111100b = 00101000b
-00101011b & 11111101b = 00101001b
-00101011b & 11111110b = 00101010b
-00101011b & 11111111b = 00101011b
-00101011b & 00000000b = 00000000b
-00101011b & 00000001b = 00000001b
-00101011b & 00000010b = 00000010b
-00101011b & 00000011b = 00000011b
-00101011b & 00000100b = 00000000b
-00101011b & 00000101b = 00000001b
-00101011b & 00000110b = 00000010b
-00101011b & 00000111b = 00000011b
-00101011b & 00001000b = 00001000b
-00101011b & 00001001b = 00001001b
-00101011b & 00001010b = 00001010b
-00101011b & 00001011b = 00001011b
-00101011b & 00001100b = 00001000b
-00101011b & 00001101b = 00001001b
-00101011b & 00001110b = 00001010b
-00101011b & 00001111b = 00001011b
-00101011b & 00010000b = 00000000b
-00101011b & 00010001b = 00000001b
-00101011b & 00010010b = 00000010b
-00101011b & 00010011b = 00000011b
-00101011b & 00010100b = 00000000b
-00101011b & 00010101b = 00000001b
-00101011b & 00010110b = 00000010b
-00101011b & 00010111b = 00000011b
-00101011b & 00011000b = 00001000b
-00101011b & 00011001b = 00001001b
-00101011b & 00011010b = 00001010b
-00101011b & 00011011b = 00001011b
-00101011b & 00011100b = 00001000b
-00101011b & 00011101b = 00001001b
-00101011b & 00011110b = 00001010b
-00101011b & 00011111b = 00001011b
-00101011b & 00100000b = 00100000b
-00101011b & 00100001b = 00100001b
-00101011b & 00100010b = 00100010b
-00101011b & 00100011b = 00100011b
-00101011b & 00100100b = 00100000b
-00101011b & 00100101b = 00100001b
-00101011b & 00100110b = 00100010b
-00101011b & 00100111b = 00100011b
-00101011b & 00101000b = 00101000b
-00101011b & 00101001b = 00101001b
-00101011b & 00101010b = 00101010b
-00101011b & 00101011b = 00101011b
-00101011b & 00101100b = 00101000b
-00101011b & 00101101b = 00101001b
-00101011b & 00101110b = 00101010b
-00101011b & 00101111b = 00101011b
-00101011b & 00110000b = 00100000b
-00101011b & 00110001b = 00100001b
-00101011b & 00110010b = 00100010b
-00101011b & 00110011b = 00100011b
-00101011b & 00110100b = 00100000b
-00101011b & 00110101b = 00100001b
-00101011b & 00110110b = 00100010b
-00101011b & 00110111b = 00100011b
-00101011b & 00111000b = 00101000b
-00101011b & 00111001b = 00101001b
-00101011b & 00111010b = 00101010b
-00101011b & 00111011b = 00101011b
-00101011b & 00111100b = 00101000b
-00101011b & 00111101b = 00101001b
-00101011b & 00111110b = 00101010b
-00101011b & 00111111b = 00101011b
-00101011b & 01000000b = 00000000b
-00101011b & 01000001b = 00000001b
-00101011b & 01000010b = 00000010b
-00101011b & 01000011b = 00000011b
-00101011b & 01000100b = 00000000b
-00101011b & 01000101b = 00000001b
-00101011b & 01000110b = 00000010b
-00101011b & 01000111b = 00000011b
-00101011b & 01001000b = 00001000b
-00101011b & 01001001b = 00001001b
-00101011b & 01001010b = 00001010b
-00101011b & 01001011b = 00001011b
-00101011b & 01001100b = 00001000b
-00101011b & 01001101b = 00001001b
-00101011b & 01001110b = 00001010b
-00101011b & 01001111b = 00001011b
-00101011b & 01010000b = 00000000b
-00101011b & 01010001b = 00000001b
-00101011b & 01010010b = 00000010b
-00101011b & 01010011b = 00000011b
-00101011b & 01010100b = 00000000b
-00101011b & 01010101b = 00000001b
-00101011b & 01010110b = 00000010b
-00101011b & 01010111b = 00000011b
-00101011b & 01011000b = 00001000b
-00101011b & 01011001b = 00001001b
-00101011b & 01011010b = 00001010b
-00101011b & 01011011b = 00001011b
-00101011b & 01011100b = 00001000b
-00101011b & 01011101b = 00001001b
-00101011b & 01011110b = 00001010b
-00101011b & 01011111b = 00001011b
-00101011b & 01100000b = 00100000b
-00101011b & 01100001b = 00100001b
-00101011b & 01100010b = 00100010b
-00101011b & 01100011b = 00100011b
-00101011b & 01100100b = 00100000b
-00101011b & 01100101b = 00100001b
-00101011b & 01100110b = 00100010b
-00101011b & 01100111b = 00100011b
-00101011b & 01101000b = 00101000b
-00101011b & 01101001b = 00101001b
-00101011b & 01101010b = 00101010b
-00101011b & 01101011b = 00101011b
-00101011b & 01101100b = 00101000b
-00101011b & 01101101b = 00101001b
-00101011b & 01101110b = 00101010b
-00101011b & 01101111b = 00101011b
-00101011b & 01110000b = 00100000b
-00101011b & 01110001b = 00100001b
-00101011b & 01110010b = 00100010b
-00101011b & 01110011b = 00100011b
-00101011b & 01110100b = 00100000b
-00101011b & 01110101b = 00100001b
-00101011b & 01110110b = 00100010b
-00101011b & 01110111b = 00100011b
-00101011b & 01111000b = 00101000b
-00101011b & 01111001b = 00101001b
-00101011b & 01111010b = 00101010b
-00101011b & 01111011b = 00101011b
-00101011b & 01111100b = 00101000b
-00101011b & 01111101b = 00101001b
-00101011b & 01111110b = 00101010b
-00101100b & 10000000b = 00000000b
-00101100b & 10000001b = 00000000b
-00101100b & 10000010b = 00000000b
-00101100b & 10000011b = 00000000b
-00101100b & 10000100b = 00000100b
-00101100b & 10000101b = 00000100b
-00101100b & 10000110b = 00000100b
-00101100b & 10000111b = 00000100b
-00101100b & 10001000b = 00001000b
-00101100b & 10001001b = 00001000b
-00101100b & 10001010b = 00001000b
-00101100b & 10001011b = 00001000b
-00101100b & 10001100b = 00001100b
-00101100b & 10001101b = 00001100b
-00101100b & 10001110b = 00001100b
-00101100b & 10001111b = 00001100b
-00101100b & 10010000b = 00000000b
-00101100b & 10010001b = 00000000b
-00101100b & 10010010b = 00000000b
-00101100b & 10010011b = 00000000b
-00101100b & 10010100b = 00000100b
-00101100b & 10010101b = 00000100b
-00101100b & 10010110b = 00000100b
-00101100b & 10010111b = 00000100b
-00101100b & 10011000b = 00001000b
-00101100b & 10011001b = 00001000b
-00101100b & 10011010b = 00001000b
-00101100b & 10011011b = 00001000b
-00101100b & 10011100b = 00001100b
-00101100b & 10011101b = 00001100b
-00101100b & 10011110b = 00001100b
-00101100b & 10011111b = 00001100b
-00101100b & 10100000b = 00100000b
-00101100b & 10100001b = 00100000b
-00101100b & 10100010b = 00100000b
-00101100b & 10100011b = 00100000b
-00101100b & 10100100b = 00100100b
-00101100b & 10100101b = 00100100b
-00101100b & 10100110b = 00100100b
-00101100b & 10100111b = 00100100b
-00101100b & 10101000b = 00101000b
-00101100b & 10101001b = 00101000b
-00101100b & 10101010b = 00101000b
-00101100b & 10101011b = 00101000b
-00101100b & 10101100b = 00101100b
-00101100b & 10101101b = 00101100b
-00101100b & 10101110b = 00101100b
-00101100b & 10101111b = 00101100b
-00101100b & 10110000b = 00100000b
-00101100b & 10110001b = 00100000b
-00101100b & 10110010b = 00100000b
-00101100b & 10110011b = 00100000b
-00101100b & 10110100b = 00100100b
-00101100b & 10110101b = 00100100b
-00101100b & 10110110b = 00100100b
-00101100b & 10110111b = 00100100b
-00101100b & 10111000b = 00101000b
-00101100b & 10111001b = 00101000b
-00101100b & 10111010b = 00101000b
-00101100b & 10111011b = 00101000b
-00101100b & 10111100b = 00101100b
-00101100b & 10111101b = 00101100b
-00101100b & 10111110b = 00101100b
-00101100b & 10111111b = 00101100b
-00101100b & 11000000b = 00000000b
-00101100b & 11000001b = 00000000b
-00101100b & 11000010b = 00000000b
-00101100b & 11000011b = 00000000b
-00101100b & 11000100b = 00000100b
-00101100b & 11000101b = 00000100b
-00101100b & 11000110b = 00000100b
-00101100b & 11000111b = 00000100b
-00101100b & 11001000b = 00001000b
-00101100b & 11001001b = 00001000b
-00101100b & 11001010b = 00001000b
-00101100b & 11001011b = 00001000b
-00101100b & 11001100b = 00001100b
-00101100b & 11001101b = 00001100b
-00101100b & 11001110b = 00001100b
-00101100b & 11001111b = 00001100b
-00101100b & 11010000b = 00000000b
-00101100b & 11010001b = 00000000b
-00101100b & 11010010b = 00000000b
-00101100b & 11010011b = 00000000b
-00101100b & 11010100b = 00000100b
-00101100b & 11010101b = 00000100b
-00101100b & 11010110b = 00000100b
-00101100b & 11010111b = 00000100b
-00101100b & 11011000b = 00001000b
-00101100b & 11011001b = 00001000b
-00101100b & 11011010b = 00001000b
-00101100b & 11011011b = 00001000b
-00101100b & 11011100b = 00001100b
-00101100b & 11011101b = 00001100b
-00101100b & 11011110b = 00001100b
-00101100b & 11011111b = 00001100b
-00101100b & 11100000b = 00100000b
-00101100b & 11100001b = 00100000b
-00101100b & 11100010b = 00100000b
-00101100b & 11100011b = 00100000b
-00101100b & 11100100b = 00100100b
-00101100b & 11100101b = 00100100b
-00101100b & 11100110b = 00100100b
-00101100b & 11100111b = 00100100b
-00101100b & 11101000b = 00101000b
-00101100b & 11101001b = 00101000b
-00101100b & 11101010b = 00101000b
-00101100b & 11101011b = 00101000b
-00101100b & 11101100b = 00101100b
-00101100b & 11101101b = 00101100b
-00101100b & 11101110b = 00101100b
-00101100b & 11101111b = 00101100b
-00101100b & 11110000b = 00100000b
-00101100b & 11110001b = 00100000b
-00101100b & 11110010b = 00100000b
-00101100b & 11110011b = 00100000b
-00101100b & 11110100b = 00100100b
-00101100b & 11110101b = 00100100b
-00101100b & 11110110b = 00100100b
-00101100b & 11110111b = 00100100b
-00101100b & 11111000b = 00101000b
-00101100b & 11111001b = 00101000b
-00101100b & 11111010b = 00101000b
-00101100b & 11111011b = 00101000b
-00101100b & 11111100b = 00101100b
-00101100b & 11111101b = 00101100b
-00101100b & 11111110b = 00101100b
-00101100b & 11111111b = 00101100b
-00101100b & 00000000b = 00000000b
-00101100b & 00000001b = 00000000b
-00101100b & 00000010b = 00000000b
-00101100b & 00000011b = 00000000b
-00101100b & 00000100b = 00000100b
-00101100b & 00000101b = 00000100b
-00101100b & 00000110b = 00000100b
-00101100b & 00000111b = 00000100b
-00101100b & 00001000b = 00001000b
-00101100b & 00001001b = 00001000b
-00101100b & 00001010b = 00001000b
-00101100b & 00001011b = 00001000b
-00101100b & 00001100b = 00001100b
-00101100b & 00001101b = 00001100b
-00101100b & 00001110b = 00001100b
-00101100b & 00001111b = 00001100b
-00101100b & 00010000b = 00000000b
-00101100b & 00010001b = 00000000b
-00101100b & 00010010b = 00000000b
-00101100b & 00010011b = 00000000b
-00101100b & 00010100b = 00000100b
-00101100b & 00010101b = 00000100b
-00101100b & 00010110b = 00000100b
-00101100b & 00010111b = 00000100b
-00101100b & 00011000b = 00001000b
-00101100b & 00011001b = 00001000b
-00101100b & 00011010b = 00001000b
-00101100b & 00011011b = 00001000b
-00101100b & 00011100b = 00001100b
-00101100b & 00011101b = 00001100b
-00101100b & 00011110b = 00001100b
-00101100b & 00011111b = 00001100b
-00101100b & 00100000b = 00100000b
-00101100b & 00100001b = 00100000b
-00101100b & 00100010b = 00100000b
-00101100b & 00100011b = 00100000b
-00101100b & 00100100b = 00100100b
-00101100b & 00100101b = 00100100b
-00101100b & 00100110b = 00100100b
-00101100b & 00100111b = 00100100b
-00101100b & 00101000b = 00101000b
-00101100b & 00101001b = 00101000b
-00101100b & 00101010b = 00101000b
-00101100b & 00101011b = 00101000b
-00101100b & 00101100b = 00101100b
-00101100b & 00101101b = 00101100b
-00101100b & 00101110b = 00101100b
-00101100b & 00101111b = 00101100b
-00101100b & 00110000b = 00100000b
-00101100b & 00110001b = 00100000b
-00101100b & 00110010b = 00100000b
-00101100b & 00110011b = 00100000b
-00101100b & 00110100b = 00100100b
-00101100b & 00110101b = 00100100b
-00101100b & 00110110b = 00100100b
-00101100b & 00110111b = 00100100b
-00101100b & 00111000b = 00101000b
-00101100b & 00111001b = 00101000b
-00101100b & 00111010b = 00101000b
-00101100b & 00111011b = 00101000b
-00101100b & 00111100b = 00101100b
-00101100b & 00111101b = 00101100b
-00101100b & 00111110b = 00101100b
-00101100b & 00111111b = 00101100b
-00101100b & 01000000b = 00000000b
-00101100b & 01000001b = 00000000b
-00101100b & 01000010b = 00000000b
-00101100b & 01000011b = 00000000b
-00101100b & 01000100b = 00000100b
-00101100b & 01000101b = 00000100b
-00101100b & 01000110b = 00000100b
-00101100b & 01000111b = 00000100b
-00101100b & 01001000b = 00001000b
-00101100b & 01001001b = 00001000b
-00101100b & 01001010b = 00001000b
-00101100b & 01001011b = 00001000b
-00101100b & 01001100b = 00001100b
-00101100b & 01001101b = 00001100b
-00101100b & 01001110b = 00001100b
-00101100b & 01001111b = 00001100b
-00101100b & 01010000b = 00000000b
-00101100b & 01010001b = 00000000b
-00101100b & 01010010b = 00000000b
-00101100b & 01010011b = 00000000b
-00101100b & 01010100b = 00000100b
-00101100b & 01010101b = 00000100b
-00101100b & 01010110b = 00000100b
-00101100b & 01010111b = 00000100b
-00101100b & 01011000b = 00001000b
-00101100b & 01011001b = 00001000b
-00101100b & 01011010b = 00001000b
-00101100b & 01011011b = 00001000b
-00101100b & 01011100b = 00001100b
-00101100b & 01011101b = 00001100b
-00101100b & 01011110b = 00001100b
-00101100b & 01011111b = 00001100b
-00101100b & 01100000b = 00100000b
-00101100b & 01100001b = 00100000b
-00101100b & 01100010b = 00100000b
-00101100b & 01100011b = 00100000b
-00101100b & 01100100b = 00100100b
-00101100b & 01100101b = 00100100b
-00101100b & 01100110b = 00100100b
-00101100b & 01100111b = 00100100b
-00101100b & 01101000b = 00101000b
-00101100b & 01101001b = 00101000b
-00101100b & 01101010b = 00101000b
-00101100b & 01101011b = 00101000b
-00101100b & 01101100b = 00101100b
-00101100b & 01101101b = 00101100b
-00101100b & 01101110b = 00101100b
-00101100b & 01101111b = 00101100b
-00101100b & 01110000b = 00100000b
-00101100b & 01110001b = 00100000b
-00101100b & 01110010b = 00100000b
-00101100b & 01110011b = 00100000b
-00101100b & 01110100b = 00100100b
-00101100b & 01110101b = 00100100b
-00101100b & 01110110b = 00100100b
-00101100b & 01110111b = 00100100b
-00101100b & 01111000b = 00101000b
-00101100b & 01111001b = 00101000b
-00101100b & 01111010b = 00101000b
-00101100b & 01111011b = 00101000b
-00101100b & 01111100b = 00101100b
-00101100b & 01111101b = 00101100b
-00101100b & 01111110b = 00101100b
-00101101b & 10000000b = 00000000b
-00101101b & 10000001b = 00000001b
-00101101b & 10000010b = 00000000b
-00101101b & 10000011b = 00000001b
-00101101b & 10000100b = 00000100b
-00101101b & 10000101b = 00000101b
-00101101b & 10000110b = 00000100b
-00101101b & 10000111b = 00000101b
-00101101b & 10001000b = 00001000b
-00101101b & 10001001b = 00001001b
-00101101b & 10001010b = 00001000b
-00101101b & 10001011b = 00001001b
-00101101b & 10001100b = 00001100b
-00101101b & 10001101b = 00001101b
-00101101b & 10001110b = 00001100b
-00101101b & 10001111b = 00001101b
-00101101b & 10010000b = 00000000b
-00101101b & 10010001b = 00000001b
-00101101b & 10010010b = 00000000b
-00101101b & 10010011b = 00000001b
-00101101b & 10010100b = 00000100b
-00101101b & 10010101b = 00000101b
-00101101b & 10010110b = 00000100b
-00101101b & 10010111b = 00000101b
-00101101b & 10011000b = 00001000b
-00101101b & 10011001b = 00001001b
-00101101b & 10011010b = 00001000b
-00101101b & 10011011b = 00001001b
-00101101b & 10011100b = 00001100b
-00101101b & 10011101b = 00001101b
-00101101b & 10011110b = 00001100b
-00101101b & 10011111b = 00001101b
-00101101b & 10100000b = 00100000b
-00101101b & 10100001b = 00100001b
-00101101b & 10100010b = 00100000b
-00101101b & 10100011b = 00100001b
-00101101b & 10100100b = 00100100b
-00101101b & 10100101b = 00100101b
-00101101b & 10100110b = 00100100b
-00101101b & 10100111b = 00100101b
-00101101b & 10101000b = 00101000b
-00101101b & 10101001b = 00101001b
-00101101b & 10101010b = 00101000b
-00101101b & 10101011b = 00101001b
-00101101b & 10101100b = 00101100b
-00101101b & 10101101b = 00101101b
-00101101b & 10101110b = 00101100b
-00101101b & 10101111b = 00101101b
-00101101b & 10110000b = 00100000b
-00101101b & 10110001b = 00100001b
-00101101b & 10110010b = 00100000b
-00101101b & 10110011b = 00100001b
-00101101b & 10110100b = 00100100b
-00101101b & 10110101b = 00100101b
-00101101b & 10110110b = 00100100b
-00101101b & 10110111b = 00100101b
-00101101b & 10111000b = 00101000b
-00101101b & 10111001b = 00101001b
-00101101b & 10111010b = 00101000b
-00101101b & 10111011b = 00101001b
-00101101b & 10111100b = 00101100b
-00101101b & 10111101b = 00101101b
-00101101b & 10111110b = 00101100b
-00101101b & 10111111b = 00101101b
-00101101b & 11000000b = 00000000b
-00101101b & 11000001b = 00000001b
-00101101b & 11000010b = 00000000b
-00101101b & 11000011b = 00000001b
-00101101b & 11000100b = 00000100b
-00101101b & 11000101b = 00000101b
-00101101b & 11000110b = 00000100b
-00101101b & 11000111b = 00000101b
-00101101b & 11001000b = 00001000b
-00101101b & 11001001b = 00001001b
-00101101b & 11001010b = 00001000b
-00101101b & 11001011b = 00001001b
-00101101b & 11001100b = 00001100b
-00101101b & 11001101b = 00001101b
-00101101b & 11001110b = 00001100b
-00101101b & 11001111b = 00001101b
-00101101b & 11010000b = 00000000b
-00101101b & 11010001b = 00000001b
-00101101b & 11010010b = 00000000b
-00101101b & 11010011b = 00000001b
-00101101b & 11010100b = 00000100b
-00101101b & 11010101b = 00000101b
-00101101b & 11010110b = 00000100b
-00101101b & 11010111b = 00000101b
-00101101b & 11011000b = 00001000b
-00101101b & 11011001b = 00001001b
-00101101b & 11011010b = 00001000b
-00101101b & 11011011b = 00001001b
-00101101b & 11011100b = 00001100b
-00101101b & 11011101b = 00001101b
-00101101b & 11011110b = 00001100b
-00101101b & 11011111b = 00001101b
-00101101b & 11100000b = 00100000b
-00101101b & 11100001b = 00100001b
-00101101b & 11100010b = 00100000b
-00101101b & 11100011b = 00100001b
-00101101b & 11100100b = 00100100b
-00101101b & 11100101b = 00100101b
-00101101b & 11100110b = 00100100b
-00101101b & 11100111b = 00100101b
-00101101b & 11101000b = 00101000b
-00101101b & 11101001b = 00101001b
-00101101b & 11101010b = 00101000b
-00101101b & 11101011b = 00101001b
-00101101b & 11101100b = 00101100b
-00101101b & 11101101b = 00101101b
-00101101b & 11101110b = 00101100b
-00101101b & 11101111b = 00101101b
-00101101b & 11110000b = 00100000b
-00101101b & 11110001b = 00100001b
-00101101b & 11110010b = 00100000b
-00101101b & 11110011b = 00100001b
-00101101b & 11110100b = 00100100b
-00101101b & 11110101b = 00100101b
-00101101b & 11110110b = 00100100b
-00101101b & 11110111b = 00100101b
-00101101b & 11111000b = 00101000b
-00101101b & 11111001b = 00101001b
-00101101b & 11111010b = 00101000b
-00101101b & 11111011b = 00101001b
-00101101b & 11111100b = 00101100b
-00101101b & 11111101b = 00101101b
-00101101b & 11111110b = 00101100b
-00101101b & 11111111b = 00101101b
-00101101b & 00000000b = 00000000b
-00101101b & 00000001b = 00000001b
-00101101b & 00000010b = 00000000b
-00101101b & 00000011b = 00000001b
-00101101b & 00000100b = 00000100b
-00101101b & 00000101b = 00000101b
-00101101b & 00000110b = 00000100b
-00101101b & 00000111b = 00000101b
-00101101b & 00001000b = 00001000b
-00101101b & 00001001b = 00001001b
-00101101b & 00001010b = 00001000b
-00101101b & 00001011b = 00001001b
-00101101b & 00001100b = 00001100b
-00101101b & 00001101b = 00001101b
-00101101b & 00001110b = 00001100b
-00101101b & 00001111b = 00001101b
-00101101b & 00010000b = 00000000b
-00101101b & 00010001b = 00000001b
-00101101b & 00010010b = 00000000b
-00101101b & 00010011b = 00000001b
-00101101b & 00010100b = 00000100b
-00101101b & 00010101b = 00000101b
-00101101b & 00010110b = 00000100b
-00101101b & 00010111b = 00000101b
-00101101b & 00011000b = 00001000b
-00101101b & 00011001b = 00001001b
-00101101b & 00011010b = 00001000b
-00101101b & 00011011b = 00001001b
-00101101b & 00011100b = 00001100b
-00101101b & 00011101b = 00001101b
-00101101b & 00011110b = 00001100b
-00101101b & 00011111b = 00001101b
-00101101b & 00100000b = 00100000b
-00101101b & 00100001b = 00100001b
-00101101b & 00100010b = 00100000b
-00101101b & 00100011b = 00100001b
-00101101b & 00100100b = 00100100b
-00101101b & 00100101b = 00100101b
-00101101b & 00100110b = 00100100b
-00101101b & 00100111b = 00100101b
-00101101b & 00101000b = 00101000b
-00101101b & 00101001b = 00101001b
-00101101b & 00101010b = 00101000b
-00101101b & 00101011b = 00101001b
-00101101b & 00101100b = 00101100b
-00101101b & 00101101b = 00101101b
-00101101b & 00101110b = 00101100b
-00101101b & 00101111b = 00101101b
-00101101b & 00110000b = 00100000b
-00101101b & 00110001b = 00100001b
-00101101b & 00110010b = 00100000b
-00101101b & 00110011b = 00100001b
-00101101b & 00110100b = 00100100b
-00101101b & 00110101b = 00100101b
-00101101b & 00110110b = 00100100b
-00101101b & 00110111b = 00100101b
-00101101b & 00111000b = 00101000b
-00101101b & 00111001b = 00101001b
-00101101b & 00111010b = 00101000b
-00101101b & 00111011b = 00101001b
-00101101b & 00111100b = 00101100b
-00101101b & 00111101b = 00101101b
-00101101b & 00111110b = 00101100b
-00101101b & 00111111b = 00101101b
-00101101b & 01000000b = 00000000b
-00101101b & 01000001b = 00000001b
-00101101b & 01000010b = 00000000b
-00101101b & 01000011b = 00000001b
-00101101b & 01000100b = 00000100b
-00101101b & 01000101b = 00000101b
-00101101b & 01000110b = 00000100b
-00101101b & 01000111b = 00000101b
-00101101b & 01001000b = 00001000b
-00101101b & 01001001b = 00001001b
-00101101b & 01001010b = 00001000b
-00101101b & 01001011b = 00001001b
-00101101b & 01001100b = 00001100b
-00101101b & 01001101b = 00001101b
-00101101b & 01001110b = 00001100b
-00101101b & 01001111b = 00001101b
-00101101b & 01010000b = 00000000b
-00101101b & 01010001b = 00000001b
-00101101b & 01010010b = 00000000b
-00101101b & 01010011b = 00000001b
-00101101b & 01010100b = 00000100b
-00101101b & 01010101b = 00000101b
-00101101b & 01010110b = 00000100b
-00101101b & 01010111b = 00000101b
-00101101b & 01011000b = 00001000b
-00101101b & 01011001b = 00001001b
-00101101b & 01011010b = 00001000b
-00101101b & 01011011b = 00001001b
-00101101b & 01011100b = 00001100b
-00101101b & 01011101b = 00001101b
-00101101b & 01011110b = 00001100b
-00101101b & 01011111b = 00001101b
-00101101b & 01100000b = 00100000b
-00101101b & 01100001b = 00100001b
-00101101b & 01100010b = 00100000b
-00101101b & 01100011b = 00100001b
-00101101b & 01100100b = 00100100b
-00101101b & 01100101b = 00100101b
-00101101b & 01100110b = 00100100b
-00101101b & 01100111b = 00100101b
-00101101b & 01101000b = 00101000b
-00101101b & 01101001b = 00101001b
-00101101b & 01101010b = 00101000b
-00101101b & 01101011b = 00101001b
-00101101b & 01101100b = 00101100b
-00101101b & 01101101b = 00101101b
-00101101b & 01101110b = 00101100b
-00101101b & 01101111b = 00101101b
-00101101b & 01110000b = 00100000b
-00101101b & 01110001b = 00100001b
-00101101b & 01110010b = 00100000b
-00101101b & 01110011b = 00100001b
-00101101b & 01110100b = 00100100b
-00101101b & 01110101b = 00100101b
-00101101b & 01110110b = 00100100b
-00101101b & 01110111b = 00100101b
-00101101b & 01111000b = 00101000b
-00101101b & 01111001b = 00101001b
-00101101b & 01111010b = 00101000b
-00101101b & 01111011b = 00101001b
-00101101b & 01111100b = 00101100b
-00101101b & 01111101b = 00101101b
-00101101b & 01111110b = 00101100b
-00101110b & 10000000b = 00000000b
-00101110b & 10000001b = 00000000b
-00101110b & 10000010b = 00000010b
-00101110b & 10000011b = 00000010b
-00101110b & 10000100b = 00000100b
-00101110b & 10000101b = 00000100b
-00101110b & 10000110b = 00000110b
-00101110b & 10000111b = 00000110b
-00101110b & 10001000b = 00001000b
-00101110b & 10001001b = 00001000b
-00101110b & 10001010b = 00001010b
-00101110b & 10001011b = 00001010b
-00101110b & 10001100b = 00001100b
-00101110b & 10001101b = 00001100b
-00101110b & 10001110b = 00001110b
-00101110b & 10001111b = 00001110b
-00101110b & 10010000b = 00000000b
-00101110b & 10010001b = 00000000b
-00101110b & 10010010b = 00000010b
-00101110b & 10010011b = 00000010b
-00101110b & 10010100b = 00000100b
-00101110b & 10010101b = 00000100b
-00101110b & 10010110b = 00000110b
-00101110b & 10010111b = 00000110b
-00101110b & 10011000b = 00001000b
-00101110b & 10011001b = 00001000b
-00101110b & 10011010b = 00001010b
-00101110b & 10011011b = 00001010b
-00101110b & 10011100b = 00001100b
-00101110b & 10011101b = 00001100b
-00101110b & 10011110b = 00001110b
-00101110b & 10011111b = 00001110b
-00101110b & 10100000b = 00100000b
-00101110b & 10100001b = 00100000b
-00101110b & 10100010b = 00100010b
-00101110b & 10100011b = 00100010b
-00101110b & 10100100b = 00100100b
-00101110b & 10100101b = 00100100b
-00101110b & 10100110b = 00100110b
-00101110b & 10100111b = 00100110b
-00101110b & 10101000b = 00101000b
-00101110b & 10101001b = 00101000b
-00101110b & 10101010b = 00101010b
-00101110b & 10101011b = 00101010b
-00101110b & 10101100b = 00101100b
-00101110b & 10101101b = 00101100b
-00101110b & 10101110b = 00101110b
-00101110b & 10101111b = 00101110b
-00101110b & 10110000b = 00100000b
-00101110b & 10110001b = 00100000b
-00101110b & 10110010b = 00100010b
-00101110b & 10110011b = 00100010b
-00101110b & 10110100b = 00100100b
-00101110b & 10110101b = 00100100b
-00101110b & 10110110b = 00100110b
-00101110b & 10110111b = 00100110b
-00101110b & 10111000b = 00101000b
-00101110b & 10111001b = 00101000b
-00101110b & 10111010b = 00101010b
-00101110b & 10111011b = 00101010b
-00101110b & 10111100b = 00101100b
-00101110b & 10111101b = 00101100b
-00101110b & 10111110b = 00101110b
-00101110b & 10111111b = 00101110b
-00101110b & 11000000b = 00000000b
-00101110b & 11000001b = 00000000b
-00101110b & 11000010b = 00000010b
-00101110b & 11000011b = 00000010b
-00101110b & 11000100b = 00000100b
-00101110b & 11000101b = 00000100b
-00101110b & 11000110b = 00000110b
-00101110b & 11000111b = 00000110b
-00101110b & 11001000b = 00001000b
-00101110b & 11001001b = 00001000b
-00101110b & 11001010b = 00001010b
-00101110b & 11001011b = 00001010b
-00101110b & 11001100b = 00001100b
-00101110b & 11001101b = 00001100b
-00101110b & 11001110b = 00001110b
-00101110b & 11001111b = 00001110b
-00101110b & 11010000b = 00000000b
-00101110b & 11010001b = 00000000b
-00101110b & 11010010b = 00000010b
-00101110b & 11010011b = 00000010b
-00101110b & 11010100b = 00000100b
-00101110b & 11010101b = 00000100b
-00101110b & 11010110b = 00000110b
-00101110b & 11010111b = 00000110b
-00101110b & 11011000b = 00001000b
-00101110b & 11011001b = 00001000b
-00101110b & 11011010b = 00001010b
-00101110b & 11011011b = 00001010b
-00101110b & 11011100b = 00001100b
-00101110b & 11011101b = 00001100b
-00101110b & 11011110b = 00001110b
-00101110b & 11011111b = 00001110b
-00101110b & 11100000b = 00100000b
-00101110b & 11100001b = 00100000b
-00101110b & 11100010b = 00100010b
-00101110b & 11100011b = 00100010b
-00101110b & 11100100b = 00100100b
-00101110b & 11100101b = 00100100b
-00101110b & 11100110b = 00100110b
-00101110b & 11100111b = 00100110b
-00101110b & 11101000b = 00101000b
-00101110b & 11101001b = 00101000b
-00101110b & 11101010b = 00101010b
-00101110b & 11101011b = 00101010b
-00101110b & 11101100b = 00101100b
-00101110b & 11101101b = 00101100b
-00101110b & 11101110b = 00101110b
-00101110b & 11101111b = 00101110b
-00101110b & 11110000b = 00100000b
-00101110b & 11110001b = 00100000b
-00101110b & 11110010b = 00100010b
-00101110b & 11110011b = 00100010b
-00101110b & 11110100b = 00100100b
-00101110b & 11110101b = 00100100b
-00101110b & 11110110b = 00100110b
-00101110b & 11110111b = 00100110b
-00101110b & 11111000b = 00101000b
-00101110b & 11111001b = 00101000b
-00101110b & 11111010b = 00101010b
-00101110b & 11111011b = 00101010b
-00101110b & 11111100b = 00101100b
-00101110b & 11111101b = 00101100b
-00101110b & 11111110b = 00101110b
-00101110b & 11111111b = 00101110b
-00101110b & 00000000b = 00000000b
-00101110b & 00000001b = 00000000b
-00101110b & 00000010b = 00000010b
-00101110b & 00000011b = 00000010b
-00101110b & 00000100b = 00000100b
-00101110b & 00000101b = 00000100b
-00101110b & 00000110b = 00000110b
-00101110b & 00000111b = 00000110b
-00101110b & 00001000b = 00001000b
-00101110b & 00001001b = 00001000b
-00101110b & 00001010b = 00001010b
-00101110b & 00001011b = 00001010b
-00101110b & 00001100b = 00001100b
-00101110b & 00001101b = 00001100b
-00101110b & 00001110b = 00001110b
-00101110b & 00001111b = 00001110b
-00101110b & 00010000b = 00000000b
-00101110b & 00010001b = 00000000b
-00101110b & 00010010b = 00000010b
-00101110b & 00010011b = 00000010b
-00101110b & 00010100b = 00000100b
-00101110b & 00010101b = 00000100b
-00101110b & 00010110b = 00000110b
-00101110b & 00010111b = 00000110b
-00101110b & 00011000b = 00001000b
-00101110b & 00011001b = 00001000b
-00101110b & 00011010b = 00001010b
-00101110b & 00011011b = 00001010b
-00101110b & 00011100b = 00001100b
-00101110b & 00011101b = 00001100b
-00101110b & 00011110b = 00001110b
-00101110b & 00011111b = 00001110b
-00101110b & 00100000b = 00100000b
-00101110b & 00100001b = 00100000b
-00101110b & 00100010b = 00100010b
-00101110b & 00100011b = 00100010b
-00101110b & 00100100b = 00100100b
-00101110b & 00100101b = 00100100b
-00101110b & 00100110b = 00100110b
-00101110b & 00100111b = 00100110b
-00101110b & 00101000b = 00101000b
-00101110b & 00101001b = 00101000b
-00101110b & 00101010b = 00101010b
-00101110b & 00101011b = 00101010b
-00101110b & 00101100b = 00101100b
-00101110b & 00101101b = 00101100b
-00101110b & 00101110b = 00101110b
-00101110b & 00101111b = 00101110b
-00101110b & 00110000b = 00100000b
-00101110b & 00110001b = 00100000b
-00101110b & 00110010b = 00100010b
-00101110b & 00110011b = 00100010b
-00101110b & 00110100b = 00100100b
-00101110b & 00110101b = 00100100b
-00101110b & 00110110b = 00100110b
-00101110b & 00110111b = 00100110b
-00101110b & 00111000b = 00101000b
-00101110b & 00111001b = 00101000b
-00101110b & 00111010b = 00101010b
-00101110b & 00111011b = 00101010b
-00101110b & 00111100b = 00101100b
-00101110b & 00111101b = 00101100b
-00101110b & 00111110b = 00101110b
-00101110b & 00111111b = 00101110b
-00101110b & 01000000b = 00000000b
-00101110b & 01000001b = 00000000b
-00101110b & 01000010b = 00000010b
-00101110b & 01000011b = 00000010b
-00101110b & 01000100b = 00000100b
-00101110b & 01000101b = 00000100b
-00101110b & 01000110b = 00000110b
-00101110b & 01000111b = 00000110b
-00101110b & 01001000b = 00001000b
-00101110b & 01001001b = 00001000b
-00101110b & 01001010b = 00001010b
-00101110b & 01001011b = 00001010b
-00101110b & 01001100b = 00001100b
-00101110b & 01001101b = 00001100b
-00101110b & 01001110b = 00001110b
-00101110b & 01001111b = 00001110b
-00101110b & 01010000b = 00000000b
-00101110b & 01010001b = 00000000b
-00101110b & 01010010b = 00000010b
-00101110b & 01010011b = 00000010b
-00101110b & 01010100b = 00000100b
-00101110b & 01010101b = 00000100b
-00101110b & 01010110b = 00000110b
-00101110b & 01010111b = 00000110b
-00101110b & 01011000b = 00001000b
-00101110b & 01011001b = 00001000b
-00101110b & 01011010b = 00001010b
-00101110b & 01011011b = 00001010b
-00101110b & 01011100b = 00001100b
-00101110b & 01011101b = 00001100b
-00101110b & 01011110b = 00001110b
-00101110b & 01011111b = 00001110b
-00101110b & 01100000b = 00100000b
-00101110b & 01100001b = 00100000b
-00101110b & 01100010b = 00100010b
-00101110b & 01100011b = 00100010b
-00101110b & 01100100b = 00100100b
-00101110b & 01100101b = 00100100b
-00101110b & 01100110b = 00100110b
-00101110b & 01100111b = 00100110b
-00101110b & 01101000b = 00101000b
-00101110b & 01101001b = 00101000b
-00101110b & 01101010b = 00101010b
-00101110b & 01101011b = 00101010b
-00101110b & 01101100b = 00101100b
-00101110b & 01101101b = 00101100b
-00101110b & 01101110b = 00101110b
-00101110b & 01101111b = 00101110b
-00101110b & 01110000b = 00100000b
-00101110b & 01110001b = 00100000b
-00101110b & 01110010b = 00100010b
-00101110b & 01110011b = 00100010b
-00101110b & 01110100b = 00100100b
-00101110b & 01110101b = 00100100b
-00101110b & 01110110b = 00100110b
-00101110b & 01110111b = 00100110b
-00101110b & 01111000b = 00101000b
-00101110b & 01111001b = 00101000b
-00101110b & 01111010b = 00101010b
-00101110b & 01111011b = 00101010b
-00101110b & 01111100b = 00101100b
-00101110b & 01111101b = 00101100b
-00101110b & 01111110b = 00101110b
-00101111b & 10000000b = 00000000b
-00101111b & 10000001b = 00000001b
-00101111b & 10000010b = 00000010b
-00101111b & 10000011b = 00000011b
-00101111b & 10000100b = 00000100b
-00101111b & 10000101b = 00000101b
-00101111b & 10000110b = 00000110b
-00101111b & 10000111b = 00000111b
-00101111b & 10001000b = 00001000b
-00101111b & 10001001b = 00001001b
-00101111b & 10001010b = 00001010b
-00101111b & 10001011b = 00001011b
-00101111b & 10001100b = 00001100b
-00101111b & 10001101b = 00001101b
-00101111b & 10001110b = 00001110b
-00101111b & 10001111b = 00001111b
-00101111b & 10010000b = 00000000b
-00101111b & 10010001b = 00000001b
-00101111b & 10010010b = 00000010b
-00101111b & 10010011b = 00000011b
-00101111b & 10010100b = 00000100b
-00101111b & 10010101b = 00000101b
-00101111b & 10010110b = 00000110b
-00101111b & 10010111b = 00000111b
-00101111b & 10011000b = 00001000b
-00101111b & 10011001b = 00001001b
-00101111b & 10011010b = 00001010b
-00101111b & 10011011b = 00001011b
-00101111b & 10011100b = 00001100b
-00101111b & 10011101b = 00001101b
-00101111b & 10011110b = 00001110b
-00101111b & 10011111b = 00001111b
-00101111b & 10100000b = 00100000b
-00101111b & 10100001b = 00100001b
-00101111b & 10100010b = 00100010b
-00101111b & 10100011b = 00100011b
-00101111b & 10100100b = 00100100b
-00101111b & 10100101b = 00100101b
-00101111b & 10100110b = 00100110b
-00101111b & 10100111b = 00100111b
-00101111b & 10101000b = 00101000b
-00101111b & 10101001b = 00101001b
-00101111b & 10101010b = 00101010b
-00101111b & 10101011b = 00101011b
-00101111b & 10101100b = 00101100b
-00101111b & 10101101b = 00101101b
-00101111b & 10101110b = 00101110b
-00101111b & 10101111b = 00101111b
-00101111b & 10110000b = 00100000b
-00101111b & 10110001b = 00100001b
-00101111b & 10110010b = 00100010b
-00101111b & 10110011b = 00100011b
-00101111b & 10110100b = 00100100b
-00101111b & 10110101b = 00100101b
-00101111b & 10110110b = 00100110b
-00101111b & 10110111b = 00100111b
-00101111b & 10111000b = 00101000b
-00101111b & 10111001b = 00101001b
-00101111b & 10111010b = 00101010b
-00101111b & 10111011b = 00101011b
-00101111b & 10111100b = 00101100b
-00101111b & 10111101b = 00101101b
-00101111b & 10111110b = 00101110b
-00101111b & 10111111b = 00101111b
-00101111b & 11000000b = 00000000b
-00101111b & 11000001b = 00000001b
-00101111b & 11000010b = 00000010b
-00101111b & 11000011b = 00000011b
-00101111b & 11000100b = 00000100b
-00101111b & 11000101b = 00000101b
-00101111b & 11000110b = 00000110b
-00101111b & 11000111b = 00000111b
-00101111b & 11001000b = 00001000b
-00101111b & 11001001b = 00001001b
-00101111b & 11001010b = 00001010b
-00101111b & 11001011b = 00001011b
-00101111b & 11001100b = 00001100b
-00101111b & 11001101b = 00001101b
-00101111b & 11001110b = 00001110b
-00101111b & 11001111b = 00001111b
-00101111b & 11010000b = 00000000b
-00101111b & 11010001b = 00000001b
-00101111b & 11010010b = 00000010b
-00101111b & 11010011b = 00000011b
-00101111b & 11010100b = 00000100b
-00101111b & 11010101b = 00000101b
-00101111b & 11010110b = 00000110b
-00101111b & 11010111b = 00000111b
-00101111b & 11011000b = 00001000b
-00101111b & 11011001b = 00001001b
-00101111b & 11011010b = 00001010b
-00101111b & 11011011b = 00001011b
-00101111b & 11011100b = 00001100b
-00101111b & 11011101b = 00001101b
-00101111b & 11011110b = 00001110b
-00101111b & 11011111b = 00001111b
-00101111b & 11100000b = 00100000b
-00101111b & 11100001b = 00100001b
-00101111b & 11100010b = 00100010b
-00101111b & 11100011b = 00100011b
-00101111b & 11100100b = 00100100b
-00101111b & 11100101b = 00100101b
-00101111b & 11100110b = 00100110b
-00101111b & 11100111b = 00100111b
-00101111b & 11101000b = 00101000b
-00101111b & 11101001b = 00101001b
-00101111b & 11101010b = 00101010b
-00101111b & 11101011b = 00101011b
-00101111b & 11101100b = 00101100b
-00101111b & 11101101b = 00101101b
-00101111b & 11101110b = 00101110b
-00101111b & 11101111b = 00101111b
-00101111b & 11110000b = 00100000b
-00101111b & 11110001b = 00100001b
-00101111b & 11110010b = 00100010b
-00101111b & 11110011b = 00100011b
-00101111b & 11110100b = 00100100b
-00101111b & 11110101b = 00100101b
-00101111b & 11110110b = 00100110b
-00101111b & 11110111b = 00100111b
-00101111b & 11111000b = 00101000b
-00101111b & 11111001b = 00101001b
-00101111b & 11111010b = 00101010b
-00101111b & 11111011b = 00101011b
-00101111b & 11111100b = 00101100b
-00101111b & 11111101b = 00101101b
-00101111b & 11111110b = 00101110b
-00101111b & 11111111b = 00101111b
-00101111b & 00000000b = 00000000b
-00101111b & 00000001b = 00000001b
-00101111b & 00000010b = 00000010b
-00101111b & 00000011b = 00000011b
-00101111b & 00000100b = 00000100b
-00101111b & 00000101b = 00000101b
-00101111b & 00000110b = 00000110b
-00101111b & 00000111b = 00000111b
-00101111b & 00001000b = 00001000b
-00101111b & 00001001b = 00001001b
-00101111b & 00001010b = 00001010b
-00101111b & 00001011b = 00001011b
-00101111b & 00001100b = 00001100b
-00101111b & 00001101b = 00001101b
-00101111b & 00001110b = 00001110b
-00101111b & 00001111b = 00001111b
-00101111b & 00010000b = 00000000b
-00101111b & 00010001b = 00000001b
-00101111b & 00010010b = 00000010b
-00101111b & 00010011b = 00000011b
-00101111b & 00010100b = 00000100b
-00101111b & 00010101b = 00000101b
-00101111b & 00010110b = 00000110b
-00101111b & 00010111b = 00000111b
-00101111b & 00011000b = 00001000b
-00101111b & 00011001b = 00001001b
-00101111b & 00011010b = 00001010b
-00101111b & 00011011b = 00001011b
-00101111b & 00011100b = 00001100b
-00101111b & 00011101b = 00001101b
-00101111b & 00011110b = 00001110b
-00101111b & 00011111b = 00001111b
-00101111b & 00100000b = 00100000b
-00101111b & 00100001b = 00100001b
-00101111b & 00100010b = 00100010b
-00101111b & 00100011b = 00100011b
-00101111b & 00100100b = 00100100b
-00101111b & 00100101b = 00100101b
-00101111b & 00100110b = 00100110b
-00101111b & 00100111b = 00100111b
-00101111b & 00101000b = 00101000b
-00101111b & 00101001b = 00101001b
-00101111b & 00101010b = 00101010b
-00101111b & 00101011b = 00101011b
-00101111b & 00101100b = 00101100b
-00101111b & 00101101b = 00101101b
-00101111b & 00101110b = 00101110b
-00101111b & 00101111b = 00101111b
-00101111b & 00110000b = 00100000b
-00101111b & 00110001b = 00100001b
-00101111b & 00110010b = 00100010b
-00101111b & 00110011b = 00100011b
-00101111b & 00110100b = 00100100b
-00101111b & 00110101b = 00100101b
-00101111b & 00110110b = 00100110b
-00101111b & 00110111b = 00100111b
-00101111b & 00111000b = 00101000b
-00101111b & 00111001b = 00101001b
-00101111b & 00111010b = 00101010b
-00101111b & 00111011b = 00101011b
-00101111b & 00111100b = 00101100b
-00101111b & 00111101b = 00101101b
-00101111b & 00111110b = 00101110b
-00101111b & 00111111b = 00101111b
-00101111b & 01000000b = 00000000b
-00101111b & 01000001b = 00000001b
-00101111b & 01000010b = 00000010b
-00101111b & 01000011b = 00000011b
-00101111b & 01000100b = 00000100b
-00101111b & 01000101b = 00000101b
-00101111b & 01000110b = 00000110b
-00101111b & 01000111b = 00000111b
-00101111b & 01001000b = 00001000b
-00101111b & 01001001b = 00001001b
-00101111b & 01001010b = 00001010b
-00101111b & 01001011b = 00001011b
-00101111b & 01001100b = 00001100b
-00101111b & 01001101b = 00001101b
-00101111b & 01001110b = 00001110b
-00101111b & 01001111b = 00001111b
-00101111b & 01010000b = 00000000b
-00101111b & 01010001b = 00000001b
-00101111b & 01010010b = 00000010b
-00101111b & 01010011b = 00000011b
-00101111b & 01010100b = 00000100b
-00101111b & 01010101b = 00000101b
-00101111b & 01010110b = 00000110b
-00101111b & 01010111b = 00000111b
-00101111b & 01011000b = 00001000b
-00101111b & 01011001b = 00001001b
-00101111b & 01011010b = 00001010b
-00101111b & 01011011b = 00001011b
-00101111b & 01011100b = 00001100b
-00101111b & 01011101b = 00001101b
-00101111b & 01011110b = 00001110b
-00101111b & 01011111b = 00001111b
-00101111b & 01100000b = 00100000b
-00101111b & 01100001b = 00100001b
-00101111b & 01100010b = 00100010b
-00101111b & 01100011b = 00100011b
-00101111b & 01100100b = 00100100b
-00101111b & 01100101b = 00100101b
-00101111b & 01100110b = 00100110b
-00101111b & 01100111b = 00100111b
-00101111b & 01101000b = 00101000b
-00101111b & 01101001b = 00101001b
-00101111b & 01101010b = 00101010b
-00101111b & 01101011b = 00101011b
-00101111b & 01101100b = 00101100b
-00101111b & 01101101b = 00101101b
-00101111b & 01101110b = 00101110b
-00101111b & 01101111b = 00101111b
-00101111b & 01110000b = 00100000b
-00101111b & 01110001b = 00100001b
-00101111b & 01110010b = 00100010b
-00101111b & 01110011b = 00100011b
-00101111b & 01110100b = 00100100b
-00101111b & 01110101b = 00100101b
-00101111b & 01110110b = 00100110b
-00101111b & 01110111b = 00100111b
-00101111b & 01111000b = 00101000b
-00101111b & 01111001b = 00101001b
-00101111b & 01111010b = 00101010b
-00101111b & 01111011b = 00101011b
-00101111b & 01111100b = 00101100b
-00101111b & 01111101b = 00101101b
-00101111b & 01111110b = 00101110b
-00110000b & 10000000b = 00000000b
-00110000b & 10000001b = 00000000b
-00110000b & 10000010b = 00000000b
-00110000b & 10000011b = 00000000b
-00110000b & 10000100b = 00000000b
-00110000b & 10000101b = 00000000b
-00110000b & 10000110b = 00000000b
-00110000b & 10000111b = 00000000b
-00110000b & 10001000b = 00000000b
-00110000b & 10001001b = 00000000b
-00110000b & 10001010b = 00000000b
-00110000b & 10001011b = 00000000b
-00110000b & 10001100b = 00000000b
-00110000b & 10001101b = 00000000b
-00110000b & 10001110b = 00000000b
-00110000b & 10001111b = 00000000b
-00110000b & 10010000b = 00010000b
-00110000b & 10010001b = 00010000b
-00110000b & 10010010b = 00010000b
-00110000b & 10010011b = 00010000b
-00110000b & 10010100b = 00010000b
-00110000b & 10010101b = 00010000b
-00110000b & 10010110b = 00010000b
-00110000b & 10010111b = 00010000b
-00110000b & 10011000b = 00010000b
-00110000b & 10011001b = 00010000b
-00110000b & 10011010b = 00010000b
-00110000b & 10011011b = 00010000b
-00110000b & 10011100b = 00010000b
-00110000b & 10011101b = 00010000b
-00110000b & 10011110b = 00010000b
-00110000b & 10011111b = 00010000b
-00110000b & 10100000b = 00100000b
-00110000b & 10100001b = 00100000b
-00110000b & 10100010b = 00100000b
-00110000b & 10100011b = 00100000b
-00110000b & 10100100b = 00100000b
-00110000b & 10100101b = 00100000b
-00110000b & 10100110b = 00100000b
-00110000b & 10100111b = 00100000b
-00110000b & 10101000b = 00100000b
-00110000b & 10101001b = 00100000b
-00110000b & 10101010b = 00100000b
-00110000b & 10101011b = 00100000b
-00110000b & 10101100b = 00100000b
-00110000b & 10101101b = 00100000b
-00110000b & 10101110b = 00100000b
-00110000b & 10101111b = 00100000b
-00110000b & 10110000b = 00110000b
-00110000b & 10110001b = 00110000b
-00110000b & 10110010b = 00110000b
-00110000b & 10110011b = 00110000b
-00110000b & 10110100b = 00110000b
-00110000b & 10110101b = 00110000b
-00110000b & 10110110b = 00110000b
-00110000b & 10110111b = 00110000b
-00110000b & 10111000b = 00110000b
-00110000b & 10111001b = 00110000b
-00110000b & 10111010b = 00110000b
-00110000b & 10111011b = 00110000b
-00110000b & 10111100b = 00110000b
-00110000b & 10111101b = 00110000b
-00110000b & 10111110b = 00110000b
-00110000b & 10111111b = 00110000b
-00110000b & 11000000b = 00000000b
-00110000b & 11000001b = 00000000b
-00110000b & 11000010b = 00000000b
-00110000b & 11000011b = 00000000b
-00110000b & 11000100b = 00000000b
-00110000b & 11000101b = 00000000b
-00110000b & 11000110b = 00000000b
-00110000b & 11000111b = 00000000b
-00110000b & 11001000b = 00000000b
-00110000b & 11001001b = 00000000b
-00110000b & 11001010b = 00000000b
-00110000b & 11001011b = 00000000b
-00110000b & 11001100b = 00000000b
-00110000b & 11001101b = 00000000b
-00110000b & 11001110b = 00000000b
-00110000b & 11001111b = 00000000b
-00110000b & 11010000b = 00010000b
-00110000b & 11010001b = 00010000b
-00110000b & 11010010b = 00010000b
-00110000b & 11010011b = 00010000b
-00110000b & 11010100b = 00010000b
-00110000b & 11010101b = 00010000b
-00110000b & 11010110b = 00010000b
-00110000b & 11010111b = 00010000b
-00110000b & 11011000b = 00010000b
-00110000b & 11011001b = 00010000b
-00110000b & 11011010b = 00010000b
-00110000b & 11011011b = 00010000b
-00110000b & 11011100b = 00010000b
-00110000b & 11011101b = 00010000b
-00110000b & 11011110b = 00010000b
-00110000b & 11011111b = 00010000b
-00110000b & 11100000b = 00100000b
-00110000b & 11100001b = 00100000b
-00110000b & 11100010b = 00100000b
-00110000b & 11100011b = 00100000b
-00110000b & 11100100b = 00100000b
-00110000b & 11100101b = 00100000b
-00110000b & 11100110b = 00100000b
-00110000b & 11100111b = 00100000b
-00110000b & 11101000b = 00100000b
-00110000b & 11101001b = 00100000b
-00110000b & 11101010b = 00100000b
-00110000b & 11101011b = 00100000b
-00110000b & 11101100b = 00100000b
-00110000b & 11101101b = 00100000b
-00110000b & 11101110b = 00100000b
-00110000b & 11101111b = 00100000b
-00110000b & 11110000b = 00110000b
-00110000b & 11110001b = 00110000b
-00110000b & 11110010b = 00110000b
-00110000b & 11110011b = 00110000b
-00110000b & 11110100b = 00110000b
-00110000b & 11110101b = 00110000b
-00110000b & 11110110b = 00110000b
-00110000b & 11110111b = 00110000b
-00110000b & 11111000b = 00110000b
-00110000b & 11111001b = 00110000b
-00110000b & 11111010b = 00110000b
-00110000b & 11111011b = 00110000b
-00110000b & 11111100b = 00110000b
-00110000b & 11111101b = 00110000b
-00110000b & 11111110b = 00110000b
-00110000b & 11111111b = 00110000b
-00110000b & 00000000b = 00000000b
-00110000b & 00000001b = 00000000b
-00110000b & 00000010b = 00000000b
-00110000b & 00000011b = 00000000b
-00110000b & 00000100b = 00000000b
-00110000b & 00000101b = 00000000b
-00110000b & 00000110b = 00000000b
-00110000b & 00000111b = 00000000b
-00110000b & 00001000b = 00000000b
-00110000b & 00001001b = 00000000b
-00110000b & 00001010b = 00000000b
-00110000b & 00001011b = 00000000b
-00110000b & 00001100b = 00000000b
-00110000b & 00001101b = 00000000b
-00110000b & 00001110b = 00000000b
-00110000b & 00001111b = 00000000b
-00110000b & 00010000b = 00010000b
-00110000b & 00010001b = 00010000b
-00110000b & 00010010b = 00010000b
-00110000b & 00010011b = 00010000b
-00110000b & 00010100b = 00010000b
-00110000b & 00010101b = 00010000b
-00110000b & 00010110b = 00010000b
-00110000b & 00010111b = 00010000b
-00110000b & 00011000b = 00010000b
-00110000b & 00011001b = 00010000b
-00110000b & 00011010b = 00010000b
-00110000b & 00011011b = 00010000b
-00110000b & 00011100b = 00010000b
-00110000b & 00011101b = 00010000b
-00110000b & 00011110b = 00010000b
-00110000b & 00011111b = 00010000b
-00110000b & 00100000b = 00100000b
-00110000b & 00100001b = 00100000b
-00110000b & 00100010b = 00100000b
-00110000b & 00100011b = 00100000b
-00110000b & 00100100b = 00100000b
-00110000b & 00100101b = 00100000b
-00110000b & 00100110b = 00100000b
-00110000b & 00100111b = 00100000b
-00110000b & 00101000b = 00100000b
-00110000b & 00101001b = 00100000b
-00110000b & 00101010b = 00100000b
-00110000b & 00101011b = 00100000b
-00110000b & 00101100b = 00100000b
-00110000b & 00101101b = 00100000b
-00110000b & 00101110b = 00100000b
-00110000b & 00101111b = 00100000b
-00110000b & 00110000b = 00110000b
-00110000b & 00110001b = 00110000b
-00110000b & 00110010b = 00110000b
-00110000b & 00110011b = 00110000b
-00110000b & 00110100b = 00110000b
-00110000b & 00110101b = 00110000b
-00110000b & 00110110b = 00110000b
-00110000b & 00110111b = 00110000b
-00110000b & 00111000b = 00110000b
-00110000b & 00111001b = 00110000b
-00110000b & 00111010b = 00110000b
-00110000b & 00111011b = 00110000b
-00110000b & 00111100b = 00110000b
-00110000b & 00111101b = 00110000b
-00110000b & 00111110b = 00110000b
-00110000b & 00111111b = 00110000b
-00110000b & 01000000b = 00000000b
-00110000b & 01000001b = 00000000b
-00110000b & 01000010b = 00000000b
-00110000b & 01000011b = 00000000b
-00110000b & 01000100b = 00000000b
-00110000b & 01000101b = 00000000b
-00110000b & 01000110b = 00000000b
-00110000b & 01000111b = 00000000b
-00110000b & 01001000b = 00000000b
-00110000b & 01001001b = 00000000b
-00110000b & 01001010b = 00000000b
-00110000b & 01001011b = 00000000b
-00110000b & 01001100b = 00000000b
-00110000b & 01001101b = 00000000b
-00110000b & 01001110b = 00000000b
-00110000b & 01001111b = 00000000b
-00110000b & 01010000b = 00010000b
-00110000b & 01010001b = 00010000b
-00110000b & 01010010b = 00010000b
-00110000b & 01010011b = 00010000b
-00110000b & 01010100b = 00010000b
-00110000b & 01010101b = 00010000b
-00110000b & 01010110b = 00010000b
-00110000b & 01010111b = 00010000b
-00110000b & 01011000b = 00010000b
-00110000b & 01011001b = 00010000b
-00110000b & 01011010b = 00010000b
-00110000b & 01011011b = 00010000b
-00110000b & 01011100b = 00010000b
-00110000b & 01011101b = 00010000b
-00110000b & 01011110b = 00010000b
-00110000b & 01011111b = 00010000b
-00110000b & 01100000b = 00100000b
-00110000b & 01100001b = 00100000b
-00110000b & 01100010b = 00100000b
-00110000b & 01100011b = 00100000b
-00110000b & 01100100b = 00100000b
-00110000b & 01100101b = 00100000b
-00110000b & 01100110b = 00100000b
-00110000b & 01100111b = 00100000b
-00110000b & 01101000b = 00100000b
-00110000b & 01101001b = 00100000b
-00110000b & 01101010b = 00100000b
-00110000b & 01101011b = 00100000b
-00110000b & 01101100b = 00100000b
-00110000b & 01101101b = 00100000b
-00110000b & 01101110b = 00100000b
-00110000b & 01101111b = 00100000b
-00110000b & 01110000b = 00110000b
-00110000b & 01110001b = 00110000b
-00110000b & 01110010b = 00110000b
-00110000b & 01110011b = 00110000b
-00110000b & 01110100b = 00110000b
-00110000b & 01110101b = 00110000b
-00110000b & 01110110b = 00110000b
-00110000b & 01110111b = 00110000b
-00110000b & 01111000b = 00110000b
-00110000b & 01111001b = 00110000b
-00110000b & 01111010b = 00110000b
-00110000b & 01111011b = 00110000b
-00110000b & 01111100b = 00110000b
-00110000b & 01111101b = 00110000b
-00110000b & 01111110b = 00110000b
-00110001b & 10000000b = 00000000b
-00110001b & 10000001b = 00000001b
-00110001b & 10000010b = 00000000b
-00110001b & 10000011b = 00000001b
-00110001b & 10000100b = 00000000b
-00110001b & 10000101b = 00000001b
-00110001b & 10000110b = 00000000b
-00110001b & 10000111b = 00000001b
-00110001b & 10001000b = 00000000b
-00110001b & 10001001b = 00000001b
-00110001b & 10001010b = 00000000b
-00110001b & 10001011b = 00000001b
-00110001b & 10001100b = 00000000b
-00110001b & 10001101b = 00000001b
-00110001b & 10001110b = 00000000b
-00110001b & 10001111b = 00000001b
-00110001b & 10010000b = 00010000b
-00110001b & 10010001b = 00010001b
-00110001b & 10010010b = 00010000b
-00110001b & 10010011b = 00010001b
-00110001b & 10010100b = 00010000b
-00110001b & 10010101b = 00010001b
-00110001b & 10010110b = 00010000b
-00110001b & 10010111b = 00010001b
-00110001b & 10011000b = 00010000b
-00110001b & 10011001b = 00010001b
-00110001b & 10011010b = 00010000b
-00110001b & 10011011b = 00010001b
-00110001b & 10011100b = 00010000b
-00110001b & 10011101b = 00010001b
-00110001b & 10011110b = 00010000b
-00110001b & 10011111b = 00010001b
-00110001b & 10100000b = 00100000b
-00110001b & 10100001b = 00100001b
-00110001b & 10100010b = 00100000b
-00110001b & 10100011b = 00100001b
-00110001b & 10100100b = 00100000b
-00110001b & 10100101b = 00100001b
-00110001b & 10100110b = 00100000b
-00110001b & 10100111b = 00100001b
-00110001b & 10101000b = 00100000b
-00110001b & 10101001b = 00100001b
-00110001b & 10101010b = 00100000b
-00110001b & 10101011b = 00100001b
-00110001b & 10101100b = 00100000b
-00110001b & 10101101b = 00100001b
-00110001b & 10101110b = 00100000b
-00110001b & 10101111b = 00100001b
-00110001b & 10110000b = 00110000b
-00110001b & 10110001b = 00110001b
-00110001b & 10110010b = 00110000b
-00110001b & 10110011b = 00110001b
-00110001b & 10110100b = 00110000b
-00110001b & 10110101b = 00110001b
-00110001b & 10110110b = 00110000b
-00110001b & 10110111b = 00110001b
-00110001b & 10111000b = 00110000b
-00110001b & 10111001b = 00110001b
-00110001b & 10111010b = 00110000b
-00110001b & 10111011b = 00110001b
-00110001b & 10111100b = 00110000b
-00110001b & 10111101b = 00110001b
-00110001b & 10111110b = 00110000b
-00110001b & 10111111b = 00110001b
-00110001b & 11000000b = 00000000b
-00110001b & 11000001b = 00000001b
-00110001b & 11000010b = 00000000b
-00110001b & 11000011b = 00000001b
-00110001b & 11000100b = 00000000b
-00110001b & 11000101b = 00000001b
-00110001b & 11000110b = 00000000b
-00110001b & 11000111b = 00000001b
-00110001b & 11001000b = 00000000b
-00110001b & 11001001b = 00000001b
-00110001b & 11001010b = 00000000b
-00110001b & 11001011b = 00000001b
-00110001b & 11001100b = 00000000b
-00110001b & 11001101b = 00000001b
-00110001b & 11001110b = 00000000b
-00110001b & 11001111b = 00000001b
-00110001b & 11010000b = 00010000b
-00110001b & 11010001b = 00010001b
-00110001b & 11010010b = 00010000b
-00110001b & 11010011b = 00010001b
-00110001b & 11010100b = 00010000b
-00110001b & 11010101b = 00010001b
-00110001b & 11010110b = 00010000b
-00110001b & 11010111b = 00010001b
-00110001b & 11011000b = 00010000b
-00110001b & 11011001b = 00010001b
-00110001b & 11011010b = 00010000b
-00110001b & 11011011b = 00010001b
-00110001b & 11011100b = 00010000b
-00110001b & 11011101b = 00010001b
-00110001b & 11011110b = 00010000b
-00110001b & 11011111b = 00010001b
-00110001b & 11100000b = 00100000b
-00110001b & 11100001b = 00100001b
-00110001b & 11100010b = 00100000b
-00110001b & 11100011b = 00100001b
-00110001b & 11100100b = 00100000b
-00110001b & 11100101b = 00100001b
-00110001b & 11100110b = 00100000b
-00110001b & 11100111b = 00100001b
-00110001b & 11101000b = 00100000b
-00110001b & 11101001b = 00100001b
-00110001b & 11101010b = 00100000b
-00110001b & 11101011b = 00100001b
-00110001b & 11101100b = 00100000b
-00110001b & 11101101b = 00100001b
-00110001b & 11101110b = 00100000b
-00110001b & 11101111b = 00100001b
-00110001b & 11110000b = 00110000b
-00110001b & 11110001b = 00110001b
-00110001b & 11110010b = 00110000b
-00110001b & 11110011b = 00110001b
-00110001b & 11110100b = 00110000b
-00110001b & 11110101b = 00110001b
-00110001b & 11110110b = 00110000b
-00110001b & 11110111b = 00110001b
-00110001b & 11111000b = 00110000b
-00110001b & 11111001b = 00110001b
-00110001b & 11111010b = 00110000b
-00110001b & 11111011b = 00110001b
-00110001b & 11111100b = 00110000b
-00110001b & 11111101b = 00110001b
-00110001b & 11111110b = 00110000b
-00110001b & 11111111b = 00110001b
-00110001b & 00000000b = 00000000b
-00110001b & 00000001b = 00000001b
-00110001b & 00000010b = 00000000b
-00110001b & 00000011b = 00000001b
-00110001b & 00000100b = 00000000b
-00110001b & 00000101b = 00000001b
-00110001b & 00000110b = 00000000b
-00110001b & 00000111b = 00000001b
-00110001b & 00001000b = 00000000b
-00110001b & 00001001b = 00000001b
-00110001b & 00001010b = 00000000b
-00110001b & 00001011b = 00000001b
-00110001b & 00001100b = 00000000b
-00110001b & 00001101b = 00000001b
-00110001b & 00001110b = 00000000b
-00110001b & 00001111b = 00000001b
-00110001b & 00010000b = 00010000b
-00110001b & 00010001b = 00010001b
-00110001b & 00010010b = 00010000b
-00110001b & 00010011b = 00010001b
-00110001b & 00010100b = 00010000b
-00110001b & 00010101b = 00010001b
-00110001b & 00010110b = 00010000b
-00110001b & 00010111b = 00010001b
-00110001b & 00011000b = 00010000b
-00110001b & 00011001b = 00010001b
-00110001b & 00011010b = 00010000b
-00110001b & 00011011b = 00010001b
-00110001b & 00011100b = 00010000b
-00110001b & 00011101b = 00010001b
-00110001b & 00011110b = 00010000b
-00110001b & 00011111b = 00010001b
-00110001b & 00100000b = 00100000b
-00110001b & 00100001b = 00100001b
-00110001b & 00100010b = 00100000b
-00110001b & 00100011b = 00100001b
-00110001b & 00100100b = 00100000b
-00110001b & 00100101b = 00100001b
-00110001b & 00100110b = 00100000b
-00110001b & 00100111b = 00100001b
-00110001b & 00101000b = 00100000b
-00110001b & 00101001b = 00100001b
-00110001b & 00101010b = 00100000b
-00110001b & 00101011b = 00100001b
-00110001b & 00101100b = 00100000b
-00110001b & 00101101b = 00100001b
-00110001b & 00101110b = 00100000b
-00110001b & 00101111b = 00100001b
-00110001b & 00110000b = 00110000b
-00110001b & 00110001b = 00110001b
-00110001b & 00110010b = 00110000b
-00110001b & 00110011b = 00110001b
-00110001b & 00110100b = 00110000b
-00110001b & 00110101b = 00110001b
-00110001b & 00110110b = 00110000b
-00110001b & 00110111b = 00110001b
-00110001b & 00111000b = 00110000b
-00110001b & 00111001b = 00110001b
-00110001b & 00111010b = 00110000b
-00110001b & 00111011b = 00110001b
-00110001b & 00111100b = 00110000b
-00110001b & 00111101b = 00110001b
-00110001b & 00111110b = 00110000b
-00110001b & 00111111b = 00110001b
-00110001b & 01000000b = 00000000b
-00110001b & 01000001b = 00000001b
-00110001b & 01000010b = 00000000b
-00110001b & 01000011b = 00000001b
-00110001b & 01000100b = 00000000b
-00110001b & 01000101b = 00000001b
-00110001b & 01000110b = 00000000b
-00110001b & 01000111b = 00000001b
-00110001b & 01001000b = 00000000b
-00110001b & 01001001b = 00000001b
-00110001b & 01001010b = 00000000b
-00110001b & 01001011b = 00000001b
-00110001b & 01001100b = 00000000b
-00110001b & 01001101b = 00000001b
-00110001b & 01001110b = 00000000b
-00110001b & 01001111b = 00000001b
-00110001b & 01010000b = 00010000b
-00110001b & 01010001b = 00010001b
-00110001b & 01010010b = 00010000b
-00110001b & 01010011b = 00010001b
-00110001b & 01010100b = 00010000b
-00110001b & 01010101b = 00010001b
-00110001b & 01010110b = 00010000b
-00110001b & 01010111b = 00010001b
-00110001b & 01011000b = 00010000b
-00110001b & 01011001b = 00010001b
-00110001b & 01011010b = 00010000b
-00110001b & 01011011b = 00010001b
-00110001b & 01011100b = 00010000b
-00110001b & 01011101b = 00010001b
-00110001b & 01011110b = 00010000b
-00110001b & 01011111b = 00010001b
-00110001b & 01100000b = 00100000b
-00110001b & 01100001b = 00100001b
-00110001b & 01100010b = 00100000b
-00110001b & 01100011b = 00100001b
-00110001b & 01100100b = 00100000b
-00110001b & 01100101b = 00100001b
-00110001b & 01100110b = 00100000b
-00110001b & 01100111b = 00100001b
-00110001b & 01101000b = 00100000b
-00110001b & 01101001b = 00100001b
-00110001b & 01101010b = 00100000b
-00110001b & 01101011b = 00100001b
-00110001b & 01101100b = 00100000b
-00110001b & 01101101b = 00100001b
-00110001b & 01101110b = 00100000b
-00110001b & 01101111b = 00100001b
-00110001b & 01110000b = 00110000b
-00110001b & 01110001b = 00110001b
-00110001b & 01110010b = 00110000b
-00110001b & 01110011b = 00110001b
-00110001b & 01110100b = 00110000b
-00110001b & 01110101b = 00110001b
-00110001b & 01110110b = 00110000b
-00110001b & 01110111b = 00110001b
-00110001b & 01111000b = 00110000b
-00110001b & 01111001b = 00110001b
-00110001b & 01111010b = 00110000b
-00110001b & 01111011b = 00110001b
-00110001b & 01111100b = 00110000b
-00110001b & 01111101b = 00110001b
-00110001b & 01111110b = 00110000b
-00110010b & 10000000b = 00000000b
-00110010b & 10000001b = 00000000b
-00110010b & 10000010b = 00000010b
-00110010b & 10000011b = 00000010b
-00110010b & 10000100b = 00000000b
-00110010b & 10000101b = 00000000b
-00110010b & 10000110b = 00000010b
-00110010b & 10000111b = 00000010b
-00110010b & 10001000b = 00000000b
-00110010b & 10001001b = 00000000b
-00110010b & 10001010b = 00000010b
-00110010b & 10001011b = 00000010b
-00110010b & 10001100b = 00000000b
-00110010b & 10001101b = 00000000b
-00110010b & 10001110b = 00000010b
-00110010b & 10001111b = 00000010b
-00110010b & 10010000b = 00010000b
-00110010b & 10010001b = 00010000b
-00110010b & 10010010b = 00010010b
-00110010b & 10010011b = 00010010b
-00110010b & 10010100b = 00010000b
-00110010b & 10010101b = 00010000b
-00110010b & 10010110b = 00010010b
-00110010b & 10010111b = 00010010b
-00110010b & 10011000b = 00010000b
-00110010b & 10011001b = 00010000b
-00110010b & 10011010b = 00010010b
-00110010b & 10011011b = 00010010b
-00110010b & 10011100b = 00010000b
-00110010b & 10011101b = 00010000b
-00110010b & 10011110b = 00010010b
-00110010b & 10011111b = 00010010b
-00110010b & 10100000b = 00100000b
-00110010b & 10100001b = 00100000b
-00110010b & 10100010b = 00100010b
-00110010b & 10100011b = 00100010b
-00110010b & 10100100b = 00100000b
-00110010b & 10100101b = 00100000b
-00110010b & 10100110b = 00100010b
-00110010b & 10100111b = 00100010b
-00110010b & 10101000b = 00100000b
-00110010b & 10101001b = 00100000b
-00110010b & 10101010b = 00100010b
-00110010b & 10101011b = 00100010b
-00110010b & 10101100b = 00100000b
-00110010b & 10101101b = 00100000b
-00110010b & 10101110b = 00100010b
-00110010b & 10101111b = 00100010b
-00110010b & 10110000b = 00110000b
-00110010b & 10110001b = 00110000b
-00110010b & 10110010b = 00110010b
-00110010b & 10110011b = 00110010b
-00110010b & 10110100b = 00110000b
-00110010b & 10110101b = 00110000b
-00110010b & 10110110b = 00110010b
-00110010b & 10110111b = 00110010b
-00110010b & 10111000b = 00110000b
-00110010b & 10111001b = 00110000b
-00110010b & 10111010b = 00110010b
-00110010b & 10111011b = 00110010b
-00110010b & 10111100b = 00110000b
-00110010b & 10111101b = 00110000b
-00110010b & 10111110b = 00110010b
-00110010b & 10111111b = 00110010b
-00110010b & 11000000b = 00000000b
-00110010b & 11000001b = 00000000b
-00110010b & 11000010b = 00000010b
-00110010b & 11000011b = 00000010b
-00110010b & 11000100b = 00000000b
-00110010b & 11000101b = 00000000b
-00110010b & 11000110b = 00000010b
-00110010b & 11000111b = 00000010b
-00110010b & 11001000b = 00000000b
-00110010b & 11001001b = 00000000b
-00110010b & 11001010b = 00000010b
-00110010b & 11001011b = 00000010b
-00110010b & 11001100b = 00000000b
-00110010b & 11001101b = 00000000b
-00110010b & 11001110b = 00000010b
-00110010b & 11001111b = 00000010b
-00110010b & 11010000b = 00010000b
-00110010b & 11010001b = 00010000b
-00110010b & 11010010b = 00010010b
-00110010b & 11010011b = 00010010b
-00110010b & 11010100b = 00010000b
-00110010b & 11010101b = 00010000b
-00110010b & 11010110b = 00010010b
-00110010b & 11010111b = 00010010b
-00110010b & 11011000b = 00010000b
-00110010b & 11011001b = 00010000b
-00110010b & 11011010b = 00010010b
-00110010b & 11011011b = 00010010b
-00110010b & 11011100b = 00010000b
-00110010b & 11011101b = 00010000b
-00110010b & 11011110b = 00010010b
-00110010b & 11011111b = 00010010b
-00110010b & 11100000b = 00100000b
-00110010b & 11100001b = 00100000b
-00110010b & 11100010b = 00100010b
-00110010b & 11100011b = 00100010b
-00110010b & 11100100b = 00100000b
-00110010b & 11100101b = 00100000b
-00110010b & 11100110b = 00100010b
-00110010b & 11100111b = 00100010b
-00110010b & 11101000b = 00100000b
-00110010b & 11101001b = 00100000b
-00110010b & 11101010b = 00100010b
-00110010b & 11101011b = 00100010b
-00110010b & 11101100b = 00100000b
-00110010b & 11101101b = 00100000b
-00110010b & 11101110b = 00100010b
-00110010b & 11101111b = 00100010b
-00110010b & 11110000b = 00110000b
-00110010b & 11110001b = 00110000b
-00110010b & 11110010b = 00110010b
-00110010b & 11110011b = 00110010b
-00110010b & 11110100b = 00110000b
-00110010b & 11110101b = 00110000b
-00110010b & 11110110b = 00110010b
-00110010b & 11110111b = 00110010b
-00110010b & 11111000b = 00110000b
-00110010b & 11111001b = 00110000b
-00110010b & 11111010b = 00110010b
-00110010b & 11111011b = 00110010b
-00110010b & 11111100b = 00110000b
-00110010b & 11111101b = 00110000b
-00110010b & 11111110b = 00110010b
-00110010b & 11111111b = 00110010b
-00110010b & 00000000b = 00000000b
-00110010b & 00000001b = 00000000b
-00110010b & 00000010b = 00000010b
-00110010b & 00000011b = 00000010b
-00110010b & 00000100b = 00000000b
-00110010b & 00000101b = 00000000b
-00110010b & 00000110b = 00000010b
-00110010b & 00000111b = 00000010b
-00110010b & 00001000b = 00000000b
-00110010b & 00001001b = 00000000b
-00110010b & 00001010b = 00000010b
-00110010b & 00001011b = 00000010b
-00110010b & 00001100b = 00000000b
-00110010b & 00001101b = 00000000b
-00110010b & 00001110b = 00000010b
-00110010b & 00001111b = 00000010b
-00110010b & 00010000b = 00010000b
-00110010b & 00010001b = 00010000b
-00110010b & 00010010b = 00010010b
-00110010b & 00010011b = 00010010b
-00110010b & 00010100b = 00010000b
-00110010b & 00010101b = 00010000b
-00110010b & 00010110b = 00010010b
-00110010b & 00010111b = 00010010b
-00110010b & 00011000b = 00010000b
-00110010b & 00011001b = 00010000b
-00110010b & 00011010b = 00010010b
-00110010b & 00011011b = 00010010b
-00110010b & 00011100b = 00010000b
-00110010b & 00011101b = 00010000b
-00110010b & 00011110b = 00010010b
-00110010b & 00011111b = 00010010b
-00110010b & 00100000b = 00100000b
-00110010b & 00100001b = 00100000b
-00110010b & 00100010b = 00100010b
-00110010b & 00100011b = 00100010b
-00110010b & 00100100b = 00100000b
-00110010b & 00100101b = 00100000b
-00110010b & 00100110b = 00100010b
-00110010b & 00100111b = 00100010b
-00110010b & 00101000b = 00100000b
-00110010b & 00101001b = 00100000b
-00110010b & 00101010b = 00100010b
-00110010b & 00101011b = 00100010b
-00110010b & 00101100b = 00100000b
-00110010b & 00101101b = 00100000b
-00110010b & 00101110b = 00100010b
-00110010b & 00101111b = 00100010b
-00110010b & 00110000b = 00110000b
-00110010b & 00110001b = 00110000b
-00110010b & 00110010b = 00110010b
-00110010b & 00110011b = 00110010b
-00110010b & 00110100b = 00110000b
-00110010b & 00110101b = 00110000b
-00110010b & 00110110b = 00110010b
-00110010b & 00110111b = 00110010b
-00110010b & 00111000b = 00110000b
-00110010b & 00111001b = 00110000b
-00110010b & 00111010b = 00110010b
-00110010b & 00111011b = 00110010b
-00110010b & 00111100b = 00110000b
-00110010b & 00111101b = 00110000b
-00110010b & 00111110b = 00110010b
-00110010b & 00111111b = 00110010b
-00110010b & 01000000b = 00000000b
-00110010b & 01000001b = 00000000b
-00110010b & 01000010b = 00000010b
-00110010b & 01000011b = 00000010b
-00110010b & 01000100b = 00000000b
-00110010b & 01000101b = 00000000b
-00110010b & 01000110b = 00000010b
-00110010b & 01000111b = 00000010b
-00110010b & 01001000b = 00000000b
-00110010b & 01001001b = 00000000b
-00110010b & 01001010b = 00000010b
-00110010b & 01001011b = 00000010b
-00110010b & 01001100b = 00000000b
-00110010b & 01001101b = 00000000b
-00110010b & 01001110b = 00000010b
-00110010b & 01001111b = 00000010b
-00110010b & 01010000b = 00010000b
-00110010b & 01010001b = 00010000b
-00110010b & 01010010b = 00010010b
-00110010b & 01010011b = 00010010b
-00110010b & 01010100b = 00010000b
-00110010b & 01010101b = 00010000b
-00110010b & 01010110b = 00010010b
-00110010b & 01010111b = 00010010b
-00110010b & 01011000b = 00010000b
-00110010b & 01011001b = 00010000b
-00110010b & 01011010b = 00010010b
-00110010b & 01011011b = 00010010b
-00110010b & 01011100b = 00010000b
-00110010b & 01011101b = 00010000b
-00110010b & 01011110b = 00010010b
-00110010b & 01011111b = 00010010b
-00110010b & 01100000b = 00100000b
-00110010b & 01100001b = 00100000b
-00110010b & 01100010b = 00100010b
-00110010b & 01100011b = 00100010b
-00110010b & 01100100b = 00100000b
-00110010b & 01100101b = 00100000b
-00110010b & 01100110b = 00100010b
-00110010b & 01100111b = 00100010b
-00110010b & 01101000b = 00100000b
-00110010b & 01101001b = 00100000b
-00110010b & 01101010b = 00100010b
-00110010b & 01101011b = 00100010b
-00110010b & 01101100b = 00100000b
-00110010b & 01101101b = 00100000b
-00110010b & 01101110b = 00100010b
-00110010b & 01101111b = 00100010b
-00110010b & 01110000b = 00110000b
-00110010b & 01110001b = 00110000b
-00110010b & 01110010b = 00110010b
-00110010b & 01110011b = 00110010b
-00110010b & 01110100b = 00110000b
-00110010b & 01110101b = 00110000b
-00110010b & 01110110b = 00110010b
-00110010b & 01110111b = 00110010b
-00110010b & 01111000b = 00110000b
-00110010b & 01111001b = 00110000b
-00110010b & 01111010b = 00110010b
-00110010b & 01111011b = 00110010b
-00110010b & 01111100b = 00110000b
-00110010b & 01111101b = 00110000b
-00110010b & 01111110b = 00110010b
-00110011b & 10000000b = 00000000b
-00110011b & 10000001b = 00000001b
-00110011b & 10000010b = 00000010b
-00110011b & 10000011b = 00000011b
-00110011b & 10000100b = 00000000b
-00110011b & 10000101b = 00000001b
-00110011b & 10000110b = 00000010b
-00110011b & 10000111b = 00000011b
-00110011b & 10001000b = 00000000b
-00110011b & 10001001b = 00000001b
-00110011b & 10001010b = 00000010b
-00110011b & 10001011b = 00000011b
-00110011b & 10001100b = 00000000b
-00110011b & 10001101b = 00000001b
-00110011b & 10001110b = 00000010b
-00110011b & 10001111b = 00000011b
-00110011b & 10010000b = 00010000b
-00110011b & 10010001b = 00010001b
-00110011b & 10010010b = 00010010b
-00110011b & 10010011b = 00010011b
-00110011b & 10010100b = 00010000b
-00110011b & 10010101b = 00010001b
-00110011b & 10010110b = 00010010b
-00110011b & 10010111b = 00010011b
-00110011b & 10011000b = 00010000b
-00110011b & 10011001b = 00010001b
-00110011b & 10011010b = 00010010b
-00110011b & 10011011b = 00010011b
-00110011b & 10011100b = 00010000b
-00110011b & 10011101b = 00010001b
-00110011b & 10011110b = 00010010b
-00110011b & 10011111b = 00010011b
-00110011b & 10100000b = 00100000b
-00110011b & 10100001b = 00100001b
-00110011b & 10100010b = 00100010b
-00110011b & 10100011b = 00100011b
-00110011b & 10100100b = 00100000b
-00110011b & 10100101b = 00100001b
-00110011b & 10100110b = 00100010b
-00110011b & 10100111b = 00100011b
-00110011b & 10101000b = 00100000b
-00110011b & 10101001b = 00100001b
-00110011b & 10101010b = 00100010b
-00110011b & 10101011b = 00100011b
-00110011b & 10101100b = 00100000b
-00110011b & 10101101b = 00100001b
-00110011b & 10101110b = 00100010b
-00110011b & 10101111b = 00100011b
-00110011b & 10110000b = 00110000b
-00110011b & 10110001b = 00110001b
-00110011b & 10110010b = 00110010b
-00110011b & 10110011b = 00110011b
-00110011b & 10110100b = 00110000b
-00110011b & 10110101b = 00110001b
-00110011b & 10110110b = 00110010b
-00110011b & 10110111b = 00110011b
-00110011b & 10111000b = 00110000b
-00110011b & 10111001b = 00110001b
-00110011b & 10111010b = 00110010b
-00110011b & 10111011b = 00110011b
-00110011b & 10111100b = 00110000b
-00110011b & 10111101b = 00110001b
-00110011b & 10111110b = 00110010b
-00110011b & 10111111b = 00110011b
-00110011b & 11000000b = 00000000b
-00110011b & 11000001b = 00000001b
-00110011b & 11000010b = 00000010b
-00110011b & 11000011b = 00000011b
-00110011b & 11000100b = 00000000b
-00110011b & 11000101b = 00000001b
-00110011b & 11000110b = 00000010b
-00110011b & 11000111b = 00000011b
-00110011b & 11001000b = 00000000b
-00110011b & 11001001b = 00000001b
-00110011b & 11001010b = 00000010b
-00110011b & 11001011b = 00000011b
-00110011b & 11001100b = 00000000b
-00110011b & 11001101b = 00000001b
-00110011b & 11001110b = 00000010b
-00110011b & 11001111b = 00000011b
-00110011b & 11010000b = 00010000b
-00110011b & 11010001b = 00010001b
-00110011b & 11010010b = 00010010b
-00110011b & 11010011b = 00010011b
-00110011b & 11010100b = 00010000b
-00110011b & 11010101b = 00010001b
-00110011b & 11010110b = 00010010b
-00110011b & 11010111b = 00010011b
-00110011b & 11011000b = 00010000b
-00110011b & 11011001b = 00010001b
-00110011b & 11011010b = 00010010b
-00110011b & 11011011b = 00010011b
-00110011b & 11011100b = 00010000b
-00110011b & 11011101b = 00010001b
-00110011b & 11011110b = 00010010b
-00110011b & 11011111b = 00010011b
-00110011b & 11100000b = 00100000b
-00110011b & 11100001b = 00100001b
-00110011b & 11100010b = 00100010b
-00110011b & 11100011b = 00100011b
-00110011b & 11100100b = 00100000b
-00110011b & 11100101b = 00100001b
-00110011b & 11100110b = 00100010b
-00110011b & 11100111b = 00100011b
-00110011b & 11101000b = 00100000b
-00110011b & 11101001b = 00100001b
-00110011b & 11101010b = 00100010b
-00110011b & 11101011b = 00100011b
-00110011b & 11101100b = 00100000b
-00110011b & 11101101b = 00100001b
-00110011b & 11101110b = 00100010b
-00110011b & 11101111b = 00100011b
-00110011b & 11110000b = 00110000b
-00110011b & 11110001b = 00110001b
-00110011b & 11110010b = 00110010b
-00110011b & 11110011b = 00110011b
-00110011b & 11110100b = 00110000b
-00110011b & 11110101b = 00110001b
-00110011b & 11110110b = 00110010b
-00110011b & 11110111b = 00110011b
-00110011b & 11111000b = 00110000b
-00110011b & 11111001b = 00110001b
-00110011b & 11111010b = 00110010b
-00110011b & 11111011b = 00110011b
-00110011b & 11111100b = 00110000b
-00110011b & 11111101b = 00110001b
-00110011b & 11111110b = 00110010b
-00110011b & 11111111b = 00110011b
-00110011b & 00000000b = 00000000b
-00110011b & 00000001b = 00000001b
-00110011b & 00000010b = 00000010b
-00110011b & 00000011b = 00000011b
-00110011b & 00000100b = 00000000b
-00110011b & 00000101b = 00000001b
-00110011b & 00000110b = 00000010b
-00110011b & 00000111b = 00000011b
-00110011b & 00001000b = 00000000b
-00110011b & 00001001b = 00000001b
-00110011b & 00001010b = 00000010b
-00110011b & 00001011b = 00000011b
-00110011b & 00001100b = 00000000b
-00110011b & 00001101b = 00000001b
-00110011b & 00001110b = 00000010b
-00110011b & 00001111b = 00000011b
-00110011b & 00010000b = 00010000b
-00110011b & 00010001b = 00010001b
-00110011b & 00010010b = 00010010b
-00110011b & 00010011b = 00010011b
-00110011b & 00010100b = 00010000b
-00110011b & 00010101b = 00010001b
-00110011b & 00010110b = 00010010b
-00110011b & 00010111b = 00010011b
-00110011b & 00011000b = 00010000b
-00110011b & 00011001b = 00010001b
-00110011b & 00011010b = 00010010b
-00110011b & 00011011b = 00010011b
-00110011b & 00011100b = 00010000b
-00110011b & 00011101b = 00010001b
-00110011b & 00011110b = 00010010b
-00110011b & 00011111b = 00010011b
-00110011b & 00100000b = 00100000b
-00110011b & 00100001b = 00100001b
-00110011b & 00100010b = 00100010b
-00110011b & 00100011b = 00100011b
-00110011b & 00100100b = 00100000b
-00110011b & 00100101b = 00100001b
-00110011b & 00100110b = 00100010b
-00110011b & 00100111b = 00100011b
-00110011b & 00101000b = 00100000b
-00110011b & 00101001b = 00100001b
-00110011b & 00101010b = 00100010b
-00110011b & 00101011b = 00100011b
-00110011b & 00101100b = 00100000b
-00110011b & 00101101b = 00100001b
-00110011b & 00101110b = 00100010b
-00110011b & 00101111b = 00100011b
-00110011b & 00110000b = 00110000b
-00110011b & 00110001b = 00110001b
-00110011b & 00110010b = 00110010b
-00110011b & 00110011b = 00110011b
-00110011b & 00110100b = 00110000b
-00110011b & 00110101b = 00110001b
-00110011b & 00110110b = 00110010b
-00110011b & 00110111b = 00110011b
-00110011b & 00111000b = 00110000b
-00110011b & 00111001b = 00110001b
-00110011b & 00111010b = 00110010b
-00110011b & 00111011b = 00110011b
-00110011b & 00111100b = 00110000b
-00110011b & 00111101b = 00110001b
-00110011b & 00111110b = 00110010b
-00110011b & 00111111b = 00110011b
-00110011b & 01000000b = 00000000b
-00110011b & 01000001b = 00000001b
-00110011b & 01000010b = 00000010b
-00110011b & 01000011b = 00000011b
-00110011b & 01000100b = 00000000b
-00110011b & 01000101b = 00000001b
-00110011b & 01000110b = 00000010b
-00110011b & 01000111b = 00000011b
-00110011b & 01001000b = 00000000b
-00110011b & 01001001b = 00000001b
-00110011b & 01001010b = 00000010b
-00110011b & 01001011b = 00000011b
-00110011b & 01001100b = 00000000b
-00110011b & 01001101b = 00000001b
-00110011b & 01001110b = 00000010b
-00110011b & 01001111b = 00000011b
-00110011b & 01010000b = 00010000b
-00110011b & 01010001b = 00010001b
-00110011b & 01010010b = 00010010b
-00110011b & 01010011b = 00010011b
-00110011b & 01010100b = 00010000b
-00110011b & 01010101b = 00010001b
-00110011b & 01010110b = 00010010b
-00110011b & 01010111b = 00010011b
-00110011b & 01011000b = 00010000b
-00110011b & 01011001b = 00010001b
-00110011b & 01011010b = 00010010b
-00110011b & 01011011b = 00010011b
-00110011b & 01011100b = 00010000b
-00110011b & 01011101b = 00010001b
-00110011b & 01011110b = 00010010b
-00110011b & 01011111b = 00010011b
-00110011b & 01100000b = 00100000b
-00110011b & 01100001b = 00100001b
-00110011b & 01100010b = 00100010b
-00110011b & 01100011b = 00100011b
-00110011b & 01100100b = 00100000b
-00110011b & 01100101b = 00100001b
-00110011b & 01100110b = 00100010b
-00110011b & 01100111b = 00100011b
-00110011b & 01101000b = 00100000b
-00110011b & 01101001b = 00100001b
-00110011b & 01101010b = 00100010b
-00110011b & 01101011b = 00100011b
-00110011b & 01101100b = 00100000b
-00110011b & 01101101b = 00100001b
-00110011b & 01101110b = 00100010b
-00110011b & 01101111b = 00100011b
-00110011b & 01110000b = 00110000b
-00110011b & 01110001b = 00110001b
-00110011b & 01110010b = 00110010b
-00110011b & 01110011b = 00110011b
-00110011b & 01110100b = 00110000b
-00110011b & 01110101b = 00110001b
-00110011b & 01110110b = 00110010b
-00110011b & 01110111b = 00110011b
-00110011b & 01111000b = 00110000b
-00110011b & 01111001b = 00110001b
-00110011b & 01111010b = 00110010b
-00110011b & 01111011b = 00110011b
-00110011b & 01111100b = 00110000b
-00110011b & 01111101b = 00110001b
-00110011b & 01111110b = 00110010b
-00110100b & 10000000b = 00000000b
-00110100b & 10000001b = 00000000b
-00110100b & 10000010b = 00000000b
-00110100b & 10000011b = 00000000b
-00110100b & 10000100b = 00000100b
-00110100b & 10000101b = 00000100b
-00110100b & 10000110b = 00000100b
-00110100b & 10000111b = 00000100b
-00110100b & 10001000b = 00000000b
-00110100b & 10001001b = 00000000b
-00110100b & 10001010b = 00000000b
-00110100b & 10001011b = 00000000b
-00110100b & 10001100b = 00000100b
-00110100b & 10001101b = 00000100b
-00110100b & 10001110b = 00000100b
-00110100b & 10001111b = 00000100b
-00110100b & 10010000b = 00010000b
-00110100b & 10010001b = 00010000b
-00110100b & 10010010b = 00010000b
-00110100b & 10010011b = 00010000b
-00110100b & 10010100b = 00010100b
-00110100b & 10010101b = 00010100b
-00110100b & 10010110b = 00010100b
-00110100b & 10010111b = 00010100b
-00110100b & 10011000b = 00010000b
-00110100b & 10011001b = 00010000b
-00110100b & 10011010b = 00010000b
-00110100b & 10011011b = 00010000b
-00110100b & 10011100b = 00010100b
-00110100b & 10011101b = 00010100b
-00110100b & 10011110b = 00010100b
-00110100b & 10011111b = 00010100b
-00110100b & 10100000b = 00100000b
-00110100b & 10100001b = 00100000b
-00110100b & 10100010b = 00100000b
-00110100b & 10100011b = 00100000b
-00110100b & 10100100b = 00100100b
-00110100b & 10100101b = 00100100b
-00110100b & 10100110b = 00100100b
-00110100b & 10100111b = 00100100b
-00110100b & 10101000b = 00100000b
-00110100b & 10101001b = 00100000b
-00110100b & 10101010b = 00100000b
-00110100b & 10101011b = 00100000b
-00110100b & 10101100b = 00100100b
-00110100b & 10101101b = 00100100b
-00110100b & 10101110b = 00100100b
-00110100b & 10101111b = 00100100b
-00110100b & 10110000b = 00110000b
-00110100b & 10110001b = 00110000b
-00110100b & 10110010b = 00110000b
-00110100b & 10110011b = 00110000b
-00110100b & 10110100b = 00110100b
-00110100b & 10110101b = 00110100b
-00110100b & 10110110b = 00110100b
-00110100b & 10110111b = 00110100b
-00110100b & 10111000b = 00110000b
-00110100b & 10111001b = 00110000b
-00110100b & 10111010b = 00110000b
-00110100b & 10111011b = 00110000b
-00110100b & 10111100b = 00110100b
-00110100b & 10111101b = 00110100b
-00110100b & 10111110b = 00110100b
-00110100b & 10111111b = 00110100b
-00110100b & 11000000b = 00000000b
-00110100b & 11000001b = 00000000b
-00110100b & 11000010b = 00000000b
-00110100b & 11000011b = 00000000b
-00110100b & 11000100b = 00000100b
-00110100b & 11000101b = 00000100b
-00110100b & 11000110b = 00000100b
-00110100b & 11000111b = 00000100b
-00110100b & 11001000b = 00000000b
-00110100b & 11001001b = 00000000b
-00110100b & 11001010b = 00000000b
-00110100b & 11001011b = 00000000b
-00110100b & 11001100b = 00000100b
-00110100b & 11001101b = 00000100b
-00110100b & 11001110b = 00000100b
-00110100b & 11001111b = 00000100b
-00110100b & 11010000b = 00010000b
-00110100b & 11010001b = 00010000b
-00110100b & 11010010b = 00010000b
-00110100b & 11010011b = 00010000b
-00110100b & 11010100b = 00010100b
-00110100b & 11010101b = 00010100b
-00110100b & 11010110b = 00010100b
-00110100b & 11010111b = 00010100b
-00110100b & 11011000b = 00010000b
-00110100b & 11011001b = 00010000b
-00110100b & 11011010b = 00010000b
-00110100b & 11011011b = 00010000b
-00110100b & 11011100b = 00010100b
-00110100b & 11011101b = 00010100b
-00110100b & 11011110b = 00010100b
-00110100b & 11011111b = 00010100b
-00110100b & 11100000b = 00100000b
-00110100b & 11100001b = 00100000b
-00110100b & 11100010b = 00100000b
-00110100b & 11100011b = 00100000b
-00110100b & 11100100b = 00100100b
-00110100b & 11100101b = 00100100b
-00110100b & 11100110b = 00100100b
-00110100b & 11100111b = 00100100b
-00110100b & 11101000b = 00100000b
-00110100b & 11101001b = 00100000b
-00110100b & 11101010b = 00100000b
-00110100b & 11101011b = 00100000b
-00110100b & 11101100b = 00100100b
-00110100b & 11101101b = 00100100b
-00110100b & 11101110b = 00100100b
-00110100b & 11101111b = 00100100b
-00110100b & 11110000b = 00110000b
-00110100b & 11110001b = 00110000b
-00110100b & 11110010b = 00110000b
-00110100b & 11110011b = 00110000b
-00110100b & 11110100b = 00110100b
-00110100b & 11110101b = 00110100b
-00110100b & 11110110b = 00110100b
-00110100b & 11110111b = 00110100b
-00110100b & 11111000b = 00110000b
-00110100b & 11111001b = 00110000b
-00110100b & 11111010b = 00110000b
-00110100b & 11111011b = 00110000b
-00110100b & 11111100b = 00110100b
-00110100b & 11111101b = 00110100b
-00110100b & 11111110b = 00110100b
-00110100b & 11111111b = 00110100b
-00110100b & 00000000b = 00000000b
-00110100b & 00000001b = 00000000b
-00110100b & 00000010b = 00000000b
-00110100b & 00000011b = 00000000b
-00110100b & 00000100b = 00000100b
-00110100b & 00000101b = 00000100b
-00110100b & 00000110b = 00000100b
-00110100b & 00000111b = 00000100b
-00110100b & 00001000b = 00000000b
-00110100b & 00001001b = 00000000b
-00110100b & 00001010b = 00000000b
-00110100b & 00001011b = 00000000b
-00110100b & 00001100b = 00000100b
-00110100b & 00001101b = 00000100b
-00110100b & 00001110b = 00000100b
-00110100b & 00001111b = 00000100b
-00110100b & 00010000b = 00010000b
-00110100b & 00010001b = 00010000b
-00110100b & 00010010b = 00010000b
-00110100b & 00010011b = 00010000b
-00110100b & 00010100b = 00010100b
-00110100b & 00010101b = 00010100b
-00110100b & 00010110b = 00010100b
-00110100b & 00010111b = 00010100b
-00110100b & 00011000b = 00010000b
-00110100b & 00011001b = 00010000b
-00110100b & 00011010b = 00010000b
-00110100b & 00011011b = 00010000b
-00110100b & 00011100b = 00010100b
-00110100b & 00011101b = 00010100b
-00110100b & 00011110b = 00010100b
-00110100b & 00011111b = 00010100b
-00110100b & 00100000b = 00100000b
-00110100b & 00100001b = 00100000b
-00110100b & 00100010b = 00100000b
-00110100b & 00100011b = 00100000b
-00110100b & 00100100b = 00100100b
-00110100b & 00100101b = 00100100b
-00110100b & 00100110b = 00100100b
-00110100b & 00100111b = 00100100b
-00110100b & 00101000b = 00100000b
-00110100b & 00101001b = 00100000b
-00110100b & 00101010b = 00100000b
-00110100b & 00101011b = 00100000b
-00110100b & 00101100b = 00100100b
-00110100b & 00101101b = 00100100b
-00110100b & 00101110b = 00100100b
-00110100b & 00101111b = 00100100b
-00110100b & 00110000b = 00110000b
-00110100b & 00110001b = 00110000b
-00110100b & 00110010b = 00110000b
-00110100b & 00110011b = 00110000b
-00110100b & 00110100b = 00110100b
-00110100b & 00110101b = 00110100b
-00110100b & 00110110b = 00110100b
-00110100b & 00110111b = 00110100b
-00110100b & 00111000b = 00110000b
-00110100b & 00111001b = 00110000b
-00110100b & 00111010b = 00110000b
-00110100b & 00111011b = 00110000b
-00110100b & 00111100b = 00110100b
-00110100b & 00111101b = 00110100b
-00110100b & 00111110b = 00110100b
-00110100b & 00111111b = 00110100b
-00110100b & 01000000b = 00000000b
-00110100b & 01000001b = 00000000b
-00110100b & 01000010b = 00000000b
-00110100b & 01000011b = 00000000b
-00110100b & 01000100b = 00000100b
-00110100b & 01000101b = 00000100b
-00110100b & 01000110b = 00000100b
-00110100b & 01000111b = 00000100b
-00110100b & 01001000b = 00000000b
-00110100b & 01001001b = 00000000b
-00110100b & 01001010b = 00000000b
-00110100b & 01001011b = 00000000b
-00110100b & 01001100b = 00000100b
-00110100b & 01001101b = 00000100b
-00110100b & 01001110b = 00000100b
-00110100b & 01001111b = 00000100b
-00110100b & 01010000b = 00010000b
-00110100b & 01010001b = 00010000b
-00110100b & 01010010b = 00010000b
-00110100b & 01010011b = 00010000b
-00110100b & 01010100b = 00010100b
-00110100b & 01010101b = 00010100b
-00110100b & 01010110b = 00010100b
-00110100b & 01010111b = 00010100b
-00110100b & 01011000b = 00010000b
-00110100b & 01011001b = 00010000b
-00110100b & 01011010b = 00010000b
-00110100b & 01011011b = 00010000b
-00110100b & 01011100b = 00010100b
-00110100b & 01011101b = 00010100b
-00110100b & 01011110b = 00010100b
-00110100b & 01011111b = 00010100b
-00110100b & 01100000b = 00100000b
-00110100b & 01100001b = 00100000b
-00110100b & 01100010b = 00100000b
-00110100b & 01100011b = 00100000b
-00110100b & 01100100b = 00100100b
-00110100b & 01100101b = 00100100b
-00110100b & 01100110b = 00100100b
-00110100b & 01100111b = 00100100b
-00110100b & 01101000b = 00100000b
-00110100b & 01101001b = 00100000b
-00110100b & 01101010b = 00100000b
-00110100b & 01101011b = 00100000b
-00110100b & 01101100b = 00100100b
-00110100b & 01101101b = 00100100b
-00110100b & 01101110b = 00100100b
-00110100b & 01101111b = 00100100b
-00110100b & 01110000b = 00110000b
-00110100b & 01110001b = 00110000b
-00110100b & 01110010b = 00110000b
-00110100b & 01110011b = 00110000b
-00110100b & 01110100b = 00110100b
-00110100b & 01110101b = 00110100b
-00110100b & 01110110b = 00110100b
-00110100b & 01110111b = 00110100b
-00110100b & 01111000b = 00110000b
-00110100b & 01111001b = 00110000b
-00110100b & 01111010b = 00110000b
-00110100b & 01111011b = 00110000b
-00110100b & 01111100b = 00110100b
-00110100b & 01111101b = 00110100b
-00110100b & 01111110b = 00110100b
-00110101b & 10000000b = 00000000b
-00110101b & 10000001b = 00000001b
-00110101b & 10000010b = 00000000b
-00110101b & 10000011b = 00000001b
-00110101b & 10000100b = 00000100b
-00110101b & 10000101b = 00000101b
-00110101b & 10000110b = 00000100b
-00110101b & 10000111b = 00000101b
-00110101b & 10001000b = 00000000b
-00110101b & 10001001b = 00000001b
-00110101b & 10001010b = 00000000b
-00110101b & 10001011b = 00000001b
-00110101b & 10001100b = 00000100b
-00110101b & 10001101b = 00000101b
-00110101b & 10001110b = 00000100b
-00110101b & 10001111b = 00000101b
-00110101b & 10010000b = 00010000b
-00110101b & 10010001b = 00010001b
-00110101b & 10010010b = 00010000b
-00110101b & 10010011b = 00010001b
-00110101b & 10010100b = 00010100b
-00110101b & 10010101b = 00010101b
-00110101b & 10010110b = 00010100b
-00110101b & 10010111b = 00010101b
-00110101b & 10011000b = 00010000b
-00110101b & 10011001b = 00010001b
-00110101b & 10011010b = 00010000b
-00110101b & 10011011b = 00010001b
-00110101b & 10011100b = 00010100b
-00110101b & 10011101b = 00010101b
-00110101b & 10011110b = 00010100b
-00110101b & 10011111b = 00010101b
-00110101b & 10100000b = 00100000b
-00110101b & 10100001b = 00100001b
-00110101b & 10100010b = 00100000b
-00110101b & 10100011b = 00100001b
-00110101b & 10100100b = 00100100b
-00110101b & 10100101b = 00100101b
-00110101b & 10100110b = 00100100b
-00110101b & 10100111b = 00100101b
-00110101b & 10101000b = 00100000b
-00110101b & 10101001b = 00100001b
-00110101b & 10101010b = 00100000b
-00110101b & 10101011b = 00100001b
-00110101b & 10101100b = 00100100b
-00110101b & 10101101b = 00100101b
-00110101b & 10101110b = 00100100b
-00110101b & 10101111b = 00100101b
-00110101b & 10110000b = 00110000b
-00110101b & 10110001b = 00110001b
-00110101b & 10110010b = 00110000b
-00110101b & 10110011b = 00110001b
-00110101b & 10110100b = 00110100b
-00110101b & 10110101b = 00110101b
-00110101b & 10110110b = 00110100b
-00110101b & 10110111b = 00110101b
-00110101b & 10111000b = 00110000b
-00110101b & 10111001b = 00110001b
-00110101b & 10111010b = 00110000b
-00110101b & 10111011b = 00110001b
-00110101b & 10111100b = 00110100b
-00110101b & 10111101b = 00110101b
-00110101b & 10111110b = 00110100b
-00110101b & 10111111b = 00110101b
-00110101b & 11000000b = 00000000b
-00110101b & 11000001b = 00000001b
-00110101b & 11000010b = 00000000b
-00110101b & 11000011b = 00000001b
-00110101b & 11000100b = 00000100b
-00110101b & 11000101b = 00000101b
-00110101b & 11000110b = 00000100b
-00110101b & 11000111b = 00000101b
-00110101b & 11001000b = 00000000b
-00110101b & 11001001b = 00000001b
-00110101b & 11001010b = 00000000b
-00110101b & 11001011b = 00000001b
-00110101b & 11001100b = 00000100b
-00110101b & 11001101b = 00000101b
-00110101b & 11001110b = 00000100b
-00110101b & 11001111b = 00000101b
-00110101b & 11010000b = 00010000b
-00110101b & 11010001b = 00010001b
-00110101b & 11010010b = 00010000b
-00110101b & 11010011b = 00010001b
-00110101b & 11010100b = 00010100b
-00110101b & 11010101b = 00010101b
-00110101b & 11010110b = 00010100b
-00110101b & 11010111b = 00010101b
-00110101b & 11011000b = 00010000b
-00110101b & 11011001b = 00010001b
-00110101b & 11011010b = 00010000b
-00110101b & 11011011b = 00010001b
-00110101b & 11011100b = 00010100b
-00110101b & 11011101b = 00010101b
-00110101b & 11011110b = 00010100b
-00110101b & 11011111b = 00010101b
-00110101b & 11100000b = 00100000b
-00110101b & 11100001b = 00100001b
-00110101b & 11100010b = 00100000b
-00110101b & 11100011b = 00100001b
-00110101b & 11100100b = 00100100b
-00110101b & 11100101b = 00100101b
-00110101b & 11100110b = 00100100b
-00110101b & 11100111b = 00100101b
-00110101b & 11101000b = 00100000b
-00110101b & 11101001b = 00100001b
-00110101b & 11101010b = 00100000b
-00110101b & 11101011b = 00100001b
-00110101b & 11101100b = 00100100b
-00110101b & 11101101b = 00100101b
-00110101b & 11101110b = 00100100b
-00110101b & 11101111b = 00100101b
-00110101b & 11110000b = 00110000b
-00110101b & 11110001b = 00110001b
-00110101b & 11110010b = 00110000b
-00110101b & 11110011b = 00110001b
-00110101b & 11110100b = 00110100b
-00110101b & 11110101b = 00110101b
-00110101b & 11110110b = 00110100b
-00110101b & 11110111b = 00110101b
-00110101b & 11111000b = 00110000b
-00110101b & 11111001b = 00110001b
-00110101b & 11111010b = 00110000b
-00110101b & 11111011b = 00110001b
-00110101b & 11111100b = 00110100b
-00110101b & 11111101b = 00110101b
-00110101b & 11111110b = 00110100b
-00110101b & 11111111b = 00110101b
-00110101b & 00000000b = 00000000b
-00110101b & 00000001b = 00000001b
-00110101b & 00000010b = 00000000b
-00110101b & 00000011b = 00000001b
-00110101b & 00000100b = 00000100b
-00110101b & 00000101b = 00000101b
-00110101b & 00000110b = 00000100b
-00110101b & 00000111b = 00000101b
-00110101b & 00001000b = 00000000b
-00110101b & 00001001b = 00000001b
-00110101b & 00001010b = 00000000b
-00110101b & 00001011b = 00000001b
-00110101b & 00001100b = 00000100b
-00110101b & 00001101b = 00000101b
-00110101b & 00001110b = 00000100b
-00110101b & 00001111b = 00000101b
-00110101b & 00010000b = 00010000b
-00110101b & 00010001b = 00010001b
-00110101b & 00010010b = 00010000b
-00110101b & 00010011b = 00010001b
-00110101b & 00010100b = 00010100b
-00110101b & 00010101b = 00010101b
-00110101b & 00010110b = 00010100b
-00110101b & 00010111b = 00010101b
-00110101b & 00011000b = 00010000b
-00110101b & 00011001b = 00010001b
-00110101b & 00011010b = 00010000b
-00110101b & 00011011b = 00010001b
-00110101b & 00011100b = 00010100b
-00110101b & 00011101b = 00010101b
-00110101b & 00011110b = 00010100b
-00110101b & 00011111b = 00010101b
-00110101b & 00100000b = 00100000b
-00110101b & 00100001b = 00100001b
-00110101b & 00100010b = 00100000b
-00110101b & 00100011b = 00100001b
-00110101b & 00100100b = 00100100b
-00110101b & 00100101b = 00100101b
-00110101b & 00100110b = 00100100b
-00110101b & 00100111b = 00100101b
-00110101b & 00101000b = 00100000b
-00110101b & 00101001b = 00100001b
-00110101b & 00101010b = 00100000b
-00110101b & 00101011b = 00100001b
-00110101b & 00101100b = 00100100b
-00110101b & 00101101b = 00100101b
-00110101b & 00101110b = 00100100b
-00110101b & 00101111b = 00100101b
-00110101b & 00110000b = 00110000b
-00110101b & 00110001b = 00110001b
-00110101b & 00110010b = 00110000b
-00110101b & 00110011b = 00110001b
-00110101b & 00110100b = 00110100b
-00110101b & 00110101b = 00110101b
-00110101b & 00110110b = 00110100b
-00110101b & 00110111b = 00110101b
-00110101b & 00111000b = 00110000b
-00110101b & 00111001b = 00110001b
-00110101b & 00111010b = 00110000b
-00110101b & 00111011b = 00110001b
-00110101b & 00111100b = 00110100b
-00110101b & 00111101b = 00110101b
-00110101b & 00111110b = 00110100b
-00110101b & 00111111b = 00110101b
-00110101b & 01000000b = 00000000b
-00110101b & 01000001b = 00000001b
-00110101b & 01000010b = 00000000b
-00110101b & 01000011b = 00000001b
-00110101b & 01000100b = 00000100b
-00110101b & 01000101b = 00000101b
-00110101b & 01000110b = 00000100b
-00110101b & 01000111b = 00000101b
-00110101b & 01001000b = 00000000b
-00110101b & 01001001b = 00000001b
-00110101b & 01001010b = 00000000b
-00110101b & 01001011b = 00000001b
-00110101b & 01001100b = 00000100b
-00110101b & 01001101b = 00000101b
-00110101b & 01001110b = 00000100b
-00110101b & 01001111b = 00000101b
-00110101b & 01010000b = 00010000b
-00110101b & 01010001b = 00010001b
-00110101b & 01010010b = 00010000b
-00110101b & 01010011b = 00010001b
-00110101b & 01010100b = 00010100b
-00110101b & 01010101b = 00010101b
-00110101b & 01010110b = 00010100b
-00110101b & 01010111b = 00010101b
-00110101b & 01011000b = 00010000b
-00110101b & 01011001b = 00010001b
-00110101b & 01011010b = 00010000b
-00110101b & 01011011b = 00010001b
-00110101b & 01011100b = 00010100b
-00110101b & 01011101b = 00010101b
-00110101b & 01011110b = 00010100b
-00110101b & 01011111b = 00010101b
-00110101b & 01100000b = 00100000b
-00110101b & 01100001b = 00100001b
-00110101b & 01100010b = 00100000b
-00110101b & 01100011b = 00100001b
-00110101b & 01100100b = 00100100b
-00110101b & 01100101b = 00100101b
-00110101b & 01100110b = 00100100b
-00110101b & 01100111b = 00100101b
-00110101b & 01101000b = 00100000b
-00110101b & 01101001b = 00100001b
-00110101b & 01101010b = 00100000b
-00110101b & 01101011b = 00100001b
-00110101b & 01101100b = 00100100b
-00110101b & 01101101b = 00100101b
-00110101b & 01101110b = 00100100b
-00110101b & 01101111b = 00100101b
-00110101b & 01110000b = 00110000b
-00110101b & 01110001b = 00110001b
-00110101b & 01110010b = 00110000b
-00110101b & 01110011b = 00110001b
-00110101b & 01110100b = 00110100b
-00110101b & 01110101b = 00110101b
-00110101b & 01110110b = 00110100b
-00110101b & 01110111b = 00110101b
-00110101b & 01111000b = 00110000b
-00110101b & 01111001b = 00110001b
-00110101b & 01111010b = 00110000b
-00110101b & 01111011b = 00110001b
-00110101b & 01111100b = 00110100b
-00110101b & 01111101b = 00110101b
-00110101b & 01111110b = 00110100b
-00110110b & 10000000b = 00000000b
-00110110b & 10000001b = 00000000b
-00110110b & 10000010b = 00000010b
-00110110b & 10000011b = 00000010b
-00110110b & 10000100b = 00000100b
-00110110b & 10000101b = 00000100b
-00110110b & 10000110b = 00000110b
-00110110b & 10000111b = 00000110b
-00110110b & 10001000b = 00000000b
-00110110b & 10001001b = 00000000b
-00110110b & 10001010b = 00000010b
-00110110b & 10001011b = 00000010b
-00110110b & 10001100b = 00000100b
-00110110b & 10001101b = 00000100b
-00110110b & 10001110b = 00000110b
-00110110b & 10001111b = 00000110b
-00110110b & 10010000b = 00010000b
-00110110b & 10010001b = 00010000b
-00110110b & 10010010b = 00010010b
-00110110b & 10010011b = 00010010b
-00110110b & 10010100b = 00010100b
-00110110b & 10010101b = 00010100b
-00110110b & 10010110b = 00010110b
-00110110b & 10010111b = 00010110b
-00110110b & 10011000b = 00010000b
-00110110b & 10011001b = 00010000b
-00110110b & 10011010b = 00010010b
-00110110b & 10011011b = 00010010b
-00110110b & 10011100b = 00010100b
-00110110b & 10011101b = 00010100b
-00110110b & 10011110b = 00010110b
-00110110b & 10011111b = 00010110b
-00110110b & 10100000b = 00100000b
-00110110b & 10100001b = 00100000b
-00110110b & 10100010b = 00100010b
-00110110b & 10100011b = 00100010b
-00110110b & 10100100b = 00100100b
-00110110b & 10100101b = 00100100b
-00110110b & 10100110b = 00100110b
-00110110b & 10100111b = 00100110b
-00110110b & 10101000b = 00100000b
-00110110b & 10101001b = 00100000b
-00110110b & 10101010b = 00100010b
-00110110b & 10101011b = 00100010b
-00110110b & 10101100b = 00100100b
-00110110b & 10101101b = 00100100b
-00110110b & 10101110b = 00100110b
-00110110b & 10101111b = 00100110b
-00110110b & 10110000b = 00110000b
-00110110b & 10110001b = 00110000b
-00110110b & 10110010b = 00110010b
-00110110b & 10110011b = 00110010b
-00110110b & 10110100b = 00110100b
-00110110b & 10110101b = 00110100b
-00110110b & 10110110b = 00110110b
-00110110b & 10110111b = 00110110b
-00110110b & 10111000b = 00110000b
-00110110b & 10111001b = 00110000b
-00110110b & 10111010b = 00110010b
-00110110b & 10111011b = 00110010b
-00110110b & 10111100b = 00110100b
-00110110b & 10111101b = 00110100b
-00110110b & 10111110b = 00110110b
-00110110b & 10111111b = 00110110b
-00110110b & 11000000b = 00000000b
-00110110b & 11000001b = 00000000b
-00110110b & 11000010b = 00000010b
-00110110b & 11000011b = 00000010b
-00110110b & 11000100b = 00000100b
-00110110b & 11000101b = 00000100b
-00110110b & 11000110b = 00000110b
-00110110b & 11000111b = 00000110b
-00110110b & 11001000b = 00000000b
-00110110b & 11001001b = 00000000b
-00110110b & 11001010b = 00000010b
-00110110b & 11001011b = 00000010b
-00110110b & 11001100b = 00000100b
-00110110b & 11001101b = 00000100b
-00110110b & 11001110b = 00000110b
-00110110b & 11001111b = 00000110b
-00110110b & 11010000b = 00010000b
-00110110b & 11010001b = 00010000b
-00110110b & 11010010b = 00010010b
-00110110b & 11010011b = 00010010b
-00110110b & 11010100b = 00010100b
-00110110b & 11010101b = 00010100b
-00110110b & 11010110b = 00010110b
-00110110b & 11010111b = 00010110b
-00110110b & 11011000b = 00010000b
-00110110b & 11011001b = 00010000b
-00110110b & 11011010b = 00010010b
-00110110b & 11011011b = 00010010b
-00110110b & 11011100b = 00010100b
-00110110b & 11011101b = 00010100b
-00110110b & 11011110b = 00010110b
-00110110b & 11011111b = 00010110b
-00110110b & 11100000b = 00100000b
-00110110b & 11100001b = 00100000b
-00110110b & 11100010b = 00100010b
-00110110b & 11100011b = 00100010b
-00110110b & 11100100b = 00100100b
-00110110b & 11100101b = 00100100b
-00110110b & 11100110b = 00100110b
-00110110b & 11100111b = 00100110b
-00110110b & 11101000b = 00100000b
-00110110b & 11101001b = 00100000b
-00110110b & 11101010b = 00100010b
-00110110b & 11101011b = 00100010b
-00110110b & 11101100b = 00100100b
-00110110b & 11101101b = 00100100b
-00110110b & 11101110b = 00100110b
-00110110b & 11101111b = 00100110b
-00110110b & 11110000b = 00110000b
-00110110b & 11110001b = 00110000b
-00110110b & 11110010b = 00110010b
-00110110b & 11110011b = 00110010b
-00110110b & 11110100b = 00110100b
-00110110b & 11110101b = 00110100b
-00110110b & 11110110b = 00110110b
-00110110b & 11110111b = 00110110b
-00110110b & 11111000b = 00110000b
-00110110b & 11111001b = 00110000b
-00110110b & 11111010b = 00110010b
-00110110b & 11111011b = 00110010b
-00110110b & 11111100b = 00110100b
-00110110b & 11111101b = 00110100b
-00110110b & 11111110b = 00110110b
-00110110b & 11111111b = 00110110b
-00110110b & 00000000b = 00000000b
-00110110b & 00000001b = 00000000b
-00110110b & 00000010b = 00000010b
-00110110b & 00000011b = 00000010b
-00110110b & 00000100b = 00000100b
-00110110b & 00000101b = 00000100b
-00110110b & 00000110b = 00000110b
-00110110b & 00000111b = 00000110b
-00110110b & 00001000b = 00000000b
-00110110b & 00001001b = 00000000b
-00110110b & 00001010b = 00000010b
-00110110b & 00001011b = 00000010b
-00110110b & 00001100b = 00000100b
-00110110b & 00001101b = 00000100b
-00110110b & 00001110b = 00000110b
-00110110b & 00001111b = 00000110b
-00110110b & 00010000b = 00010000b
-00110110b & 00010001b = 00010000b
-00110110b & 00010010b = 00010010b
-00110110b & 00010011b = 00010010b
-00110110b & 00010100b = 00010100b
-00110110b & 00010101b = 00010100b
-00110110b & 00010110b = 00010110b
-00110110b & 00010111b = 00010110b
-00110110b & 00011000b = 00010000b
-00110110b & 00011001b = 00010000b
-00110110b & 00011010b = 00010010b
-00110110b & 00011011b = 00010010b
-00110110b & 00011100b = 00010100b
-00110110b & 00011101b = 00010100b
-00110110b & 00011110b = 00010110b
-00110110b & 00011111b = 00010110b
-00110110b & 00100000b = 00100000b
-00110110b & 00100001b = 00100000b
-00110110b & 00100010b = 00100010b
-00110110b & 00100011b = 00100010b
-00110110b & 00100100b = 00100100b
-00110110b & 00100101b = 00100100b
-00110110b & 00100110b = 00100110b
-00110110b & 00100111b = 00100110b
-00110110b & 00101000b = 00100000b
-00110110b & 00101001b = 00100000b
-00110110b & 00101010b = 00100010b
-00110110b & 00101011b = 00100010b
-00110110b & 00101100b = 00100100b
-00110110b & 00101101b = 00100100b
-00110110b & 00101110b = 00100110b
-00110110b & 00101111b = 00100110b
-00110110b & 00110000b = 00110000b
-00110110b & 00110001b = 00110000b
-00110110b & 00110010b = 00110010b
-00110110b & 00110011b = 00110010b
-00110110b & 00110100b = 00110100b
-00110110b & 00110101b = 00110100b
-00110110b & 00110110b = 00110110b
-00110110b & 00110111b = 00110110b
-00110110b & 00111000b = 00110000b
-00110110b & 00111001b = 00110000b
-00110110b & 00111010b = 00110010b
-00110110b & 00111011b = 00110010b
-00110110b & 00111100b = 00110100b
-00110110b & 00111101b = 00110100b
-00110110b & 00111110b = 00110110b
-00110110b & 00111111b = 00110110b
-00110110b & 01000000b = 00000000b
-00110110b & 01000001b = 00000000b
-00110110b & 01000010b = 00000010b
-00110110b & 01000011b = 00000010b
-00110110b & 01000100b = 00000100b
-00110110b & 01000101b = 00000100b
-00110110b & 01000110b = 00000110b
-00110110b & 01000111b = 00000110b
-00110110b & 01001000b = 00000000b
-00110110b & 01001001b = 00000000b
-00110110b & 01001010b = 00000010b
-00110110b & 01001011b = 00000010b
-00110110b & 01001100b = 00000100b
-00110110b & 01001101b = 00000100b
-00110110b & 01001110b = 00000110b
-00110110b & 01001111b = 00000110b
-00110110b & 01010000b = 00010000b
-00110110b & 01010001b = 00010000b
-00110110b & 01010010b = 00010010b
-00110110b & 01010011b = 00010010b
-00110110b & 01010100b = 00010100b
-00110110b & 01010101b = 00010100b
-00110110b & 01010110b = 00010110b
-00110110b & 01010111b = 00010110b
-00110110b & 01011000b = 00010000b
-00110110b & 01011001b = 00010000b
-00110110b & 01011010b = 00010010b
-00110110b & 01011011b = 00010010b
-00110110b & 01011100b = 00010100b
-00110110b & 01011101b = 00010100b
-00110110b & 01011110b = 00010110b
-00110110b & 01011111b = 00010110b
-00110110b & 01100000b = 00100000b
-00110110b & 01100001b = 00100000b
-00110110b & 01100010b = 00100010b
-00110110b & 01100011b = 00100010b
-00110110b & 01100100b = 00100100b
-00110110b & 01100101b = 00100100b
-00110110b & 01100110b = 00100110b
-00110110b & 01100111b = 00100110b
-00110110b & 01101000b = 00100000b
-00110110b & 01101001b = 00100000b
-00110110b & 01101010b = 00100010b
-00110110b & 01101011b = 00100010b
-00110110b & 01101100b = 00100100b
-00110110b & 01101101b = 00100100b
-00110110b & 01101110b = 00100110b
-00110110b & 01101111b = 00100110b
-00110110b & 01110000b = 00110000b
-00110110b & 01110001b = 00110000b
-00110110b & 01110010b = 00110010b
-00110110b & 01110011b = 00110010b
-00110110b & 01110100b = 00110100b
-00110110b & 01110101b = 00110100b
-00110110b & 01110110b = 00110110b
-00110110b & 01110111b = 00110110b
-00110110b & 01111000b = 00110000b
-00110110b & 01111001b = 00110000b
-00110110b & 01111010b = 00110010b
-00110110b & 01111011b = 00110010b
-00110110b & 01111100b = 00110100b
-00110110b & 01111101b = 00110100b
-00110110b & 01111110b = 00110110b
-00110111b & 10000000b = 00000000b
-00110111b & 10000001b = 00000001b
-00110111b & 10000010b = 00000010b
-00110111b & 10000011b = 00000011b
-00110111b & 10000100b = 00000100b
-00110111b & 10000101b = 00000101b
-00110111b & 10000110b = 00000110b
-00110111b & 10000111b = 00000111b
-00110111b & 10001000b = 00000000b
-00110111b & 10001001b = 00000001b
-00110111b & 10001010b = 00000010b
-00110111b & 10001011b = 00000011b
-00110111b & 10001100b = 00000100b
-00110111b & 10001101b = 00000101b
-00110111b & 10001110b = 00000110b
-00110111b & 10001111b = 00000111b
-00110111b & 10010000b = 00010000b
-00110111b & 10010001b = 00010001b
-00110111b & 10010010b = 00010010b
-00110111b & 10010011b = 00010011b
-00110111b & 10010100b = 00010100b
-00110111b & 10010101b = 00010101b
-00110111b & 10010110b = 00010110b
-00110111b & 10010111b = 00010111b
-00110111b & 10011000b = 00010000b
-00110111b & 10011001b = 00010001b
-00110111b & 10011010b = 00010010b
-00110111b & 10011011b = 00010011b
-00110111b & 10011100b = 00010100b
-00110111b & 10011101b = 00010101b
-00110111b & 10011110b = 00010110b
-00110111b & 10011111b = 00010111b
-00110111b & 10100000b = 00100000b
-00110111b & 10100001b = 00100001b
-00110111b & 10100010b = 00100010b
-00110111b & 10100011b = 00100011b
-00110111b & 10100100b = 00100100b
-00110111b & 10100101b = 00100101b
-00110111b & 10100110b = 00100110b
-00110111b & 10100111b = 00100111b
-00110111b & 10101000b = 00100000b
-00110111b & 10101001b = 00100001b
-00110111b & 10101010b = 00100010b
-00110111b & 10101011b = 00100011b
-00110111b & 10101100b = 00100100b
-00110111b & 10101101b = 00100101b
-00110111b & 10101110b = 00100110b
-00110111b & 10101111b = 00100111b
-00110111b & 10110000b = 00110000b
-00110111b & 10110001b = 00110001b
-00110111b & 10110010b = 00110010b
-00110111b & 10110011b = 00110011b
-00110111b & 10110100b = 00110100b
-00110111b & 10110101b = 00110101b
-00110111b & 10110110b = 00110110b
-00110111b & 10110111b = 00110111b
-00110111b & 10111000b = 00110000b
-00110111b & 10111001b = 00110001b
-00110111b & 10111010b = 00110010b
-00110111b & 10111011b = 00110011b
-00110111b & 10111100b = 00110100b
-00110111b & 10111101b = 00110101b
-00110111b & 10111110b = 00110110b
-00110111b & 10111111b = 00110111b
-00110111b & 11000000b = 00000000b
-00110111b & 11000001b = 00000001b
-00110111b & 11000010b = 00000010b
-00110111b & 11000011b = 00000011b
-00110111b & 11000100b = 00000100b
-00110111b & 11000101b = 00000101b
-00110111b & 11000110b = 00000110b
-00110111b & 11000111b = 00000111b
-00110111b & 11001000b = 00000000b
-00110111b & 11001001b = 00000001b
-00110111b & 11001010b = 00000010b
-00110111b & 11001011b = 00000011b
-00110111b & 11001100b = 00000100b
-00110111b & 11001101b = 00000101b
-00110111b & 11001110b = 00000110b
-00110111b & 11001111b = 00000111b
-00110111b & 11010000b = 00010000b
-00110111b & 11010001b = 00010001b
-00110111b & 11010010b = 00010010b
-00110111b & 11010011b = 00010011b
-00110111b & 11010100b = 00010100b
-00110111b & 11010101b = 00010101b
-00110111b & 11010110b = 00010110b
-00110111b & 11010111b = 00010111b
-00110111b & 11011000b = 00010000b
-00110111b & 11011001b = 00010001b
-00110111b & 11011010b = 00010010b
-00110111b & 11011011b = 00010011b
-00110111b & 11011100b = 00010100b
-00110111b & 11011101b = 00010101b
-00110111b & 11011110b = 00010110b
-00110111b & 11011111b = 00010111b
-00110111b & 11100000b = 00100000b
-00110111b & 11100001b = 00100001b
-00110111b & 11100010b = 00100010b
-00110111b & 11100011b = 00100011b
-00110111b & 11100100b = 00100100b
-00110111b & 11100101b = 00100101b
-00110111b & 11100110b = 00100110b
-00110111b & 11100111b = 00100111b
-00110111b & 11101000b = 00100000b
-00110111b & 11101001b = 00100001b
-00110111b & 11101010b = 00100010b
-00110111b & 11101011b = 00100011b
-00110111b & 11101100b = 00100100b
-00110111b & 11101101b = 00100101b
-00110111b & 11101110b = 00100110b
-00110111b & 11101111b = 00100111b
-00110111b & 11110000b = 00110000b
-00110111b & 11110001b = 00110001b
-00110111b & 11110010b = 00110010b
-00110111b & 11110011b = 00110011b
-00110111b & 11110100b = 00110100b
-00110111b & 11110101b = 00110101b
-00110111b & 11110110b = 00110110b
-00110111b & 11110111b = 00110111b
-00110111b & 11111000b = 00110000b
-00110111b & 11111001b = 00110001b
-00110111b & 11111010b = 00110010b
-00110111b & 11111011b = 00110011b
-00110111b & 11111100b = 00110100b
-00110111b & 11111101b = 00110101b
-00110111b & 11111110b = 00110110b
-00110111b & 11111111b = 00110111b
-00110111b & 00000000b = 00000000b
-00110111b & 00000001b = 00000001b
-00110111b & 00000010b = 00000010b
-00110111b & 00000011b = 00000011b
-00110111b & 00000100b = 00000100b
-00110111b & 00000101b = 00000101b
-00110111b & 00000110b = 00000110b
-00110111b & 00000111b = 00000111b
-00110111b & 00001000b = 00000000b
-00110111b & 00001001b = 00000001b
-00110111b & 00001010b = 00000010b
-00110111b & 00001011b = 00000011b
-00110111b & 00001100b = 00000100b
-00110111b & 00001101b = 00000101b
-00110111b & 00001110b = 00000110b
-00110111b & 00001111b = 00000111b
-00110111b & 00010000b = 00010000b
-00110111b & 00010001b = 00010001b
-00110111b & 00010010b = 00010010b
-00110111b & 00010011b = 00010011b
-00110111b & 00010100b = 00010100b
-00110111b & 00010101b = 00010101b
-00110111b & 00010110b = 00010110b
-00110111b & 00010111b = 00010111b
-00110111b & 00011000b = 00010000b
-00110111b & 00011001b = 00010001b
-00110111b & 00011010b = 00010010b
-00110111b & 00011011b = 00010011b
-00110111b & 00011100b = 00010100b
-00110111b & 00011101b = 00010101b
-00110111b & 00011110b = 00010110b
-00110111b & 00011111b = 00010111b
-00110111b & 00100000b = 00100000b
-00110111b & 00100001b = 00100001b
-00110111b & 00100010b = 00100010b
-00110111b & 00100011b = 00100011b
-00110111b & 00100100b = 00100100b
-00110111b & 00100101b = 00100101b
-00110111b & 00100110b = 00100110b
-00110111b & 00100111b = 00100111b
-00110111b & 00101000b = 00100000b
-00110111b & 00101001b = 00100001b
-00110111b & 00101010b = 00100010b
-00110111b & 00101011b = 00100011b
-00110111b & 00101100b = 00100100b
-00110111b & 00101101b = 00100101b
-00110111b & 00101110b = 00100110b
-00110111b & 00101111b = 00100111b
-00110111b & 00110000b = 00110000b
-00110111b & 00110001b = 00110001b
-00110111b & 00110010b = 00110010b
-00110111b & 00110011b = 00110011b
-00110111b & 00110100b = 00110100b
-00110111b & 00110101b = 00110101b
-00110111b & 00110110b = 00110110b
-00110111b & 00110111b = 00110111b
-00110111b & 00111000b = 00110000b
-00110111b & 00111001b = 00110001b
-00110111b & 00111010b = 00110010b
-00110111b & 00111011b = 00110011b
-00110111b & 00111100b = 00110100b
-00110111b & 00111101b = 00110101b
-00110111b & 00111110b = 00110110b
-00110111b & 00111111b = 00110111b
-00110111b & 01000000b = 00000000b
-00110111b & 01000001b = 00000001b
-00110111b & 01000010b = 00000010b
-00110111b & 01000011b = 00000011b
-00110111b & 01000100b = 00000100b
-00110111b & 01000101b = 00000101b
-00110111b & 01000110b = 00000110b
-00110111b & 01000111b = 00000111b
-00110111b & 01001000b = 00000000b
-00110111b & 01001001b = 00000001b
-00110111b & 01001010b = 00000010b
-00110111b & 01001011b = 00000011b
-00110111b & 01001100b = 00000100b
-00110111b & 01001101b = 00000101b
-00110111b & 01001110b = 00000110b
-00110111b & 01001111b = 00000111b
-00110111b & 01010000b = 00010000b
-00110111b & 01010001b = 00010001b
-00110111b & 01010010b = 00010010b
-00110111b & 01010011b = 00010011b
-00110111b & 01010100b = 00010100b
-00110111b & 01010101b = 00010101b
-00110111b & 01010110b = 00010110b
-00110111b & 01010111b = 00010111b
-00110111b & 01011000b = 00010000b
-00110111b & 01011001b = 00010001b
-00110111b & 01011010b = 00010010b
-00110111b & 01011011b = 00010011b
-00110111b & 01011100b = 00010100b
-00110111b & 01011101b = 00010101b
-00110111b & 01011110b = 00010110b
-00110111b & 01011111b = 00010111b
-00110111b & 01100000b = 00100000b
-00110111b & 01100001b = 00100001b
-00110111b & 01100010b = 00100010b
-00110111b & 01100011b = 00100011b
-00110111b & 01100100b = 00100100b
-00110111b & 01100101b = 00100101b
-00110111b & 01100110b = 00100110b
-00110111b & 01100111b = 00100111b
-00110111b & 01101000b = 00100000b
-00110111b & 01101001b = 00100001b
-00110111b & 01101010b = 00100010b
-00110111b & 01101011b = 00100011b
-00110111b & 01101100b = 00100100b
-00110111b & 01101101b = 00100101b
-00110111b & 01101110b = 00100110b
-00110111b & 01101111b = 00100111b
-00110111b & 01110000b = 00110000b
-00110111b & 01110001b = 00110001b
-00110111b & 01110010b = 00110010b
-00110111b & 01110011b = 00110011b
-00110111b & 01110100b = 00110100b
-00110111b & 01110101b = 00110101b
-00110111b & 01110110b = 00110110b
-00110111b & 01110111b = 00110111b
-00110111b & 01111000b = 00110000b
-00110111b & 01111001b = 00110001b
-00110111b & 01111010b = 00110010b
-00110111b & 01111011b = 00110011b
-00110111b & 01111100b = 00110100b
-00110111b & 01111101b = 00110101b
-00110111b & 01111110b = 00110110b
-00111000b & 10000000b = 00000000b
-00111000b & 10000001b = 00000000b
-00111000b & 10000010b = 00000000b
-00111000b & 10000011b = 00000000b
-00111000b & 10000100b = 00000000b
-00111000b & 10000101b = 00000000b
-00111000b & 10000110b = 00000000b
-00111000b & 10000111b = 00000000b
-00111000b & 10001000b = 00001000b
-00111000b & 10001001b = 00001000b
-00111000b & 10001010b = 00001000b
-00111000b & 10001011b = 00001000b
-00111000b & 10001100b = 00001000b
-00111000b & 10001101b = 00001000b
-00111000b & 10001110b = 00001000b
-00111000b & 10001111b = 00001000b
-00111000b & 10010000b = 00010000b
-00111000b & 10010001b = 00010000b
-00111000b & 10010010b = 00010000b
-00111000b & 10010011b = 00010000b
-00111000b & 10010100b = 00010000b
-00111000b & 10010101b = 00010000b
-00111000b & 10010110b = 00010000b
-00111000b & 10010111b = 00010000b
-00111000b & 10011000b = 00011000b
-00111000b & 10011001b = 00011000b
-00111000b & 10011010b = 00011000b
-00111000b & 10011011b = 00011000b
-00111000b & 10011100b = 00011000b
-00111000b & 10011101b = 00011000b
-00111000b & 10011110b = 00011000b
-00111000b & 10011111b = 00011000b
-00111000b & 10100000b = 00100000b
-00111000b & 10100001b = 00100000b
-00111000b & 10100010b = 00100000b
-00111000b & 10100011b = 00100000b
-00111000b & 10100100b = 00100000b
-00111000b & 10100101b = 00100000b
-00111000b & 10100110b = 00100000b
-00111000b & 10100111b = 00100000b
-00111000b & 10101000b = 00101000b
-00111000b & 10101001b = 00101000b
-00111000b & 10101010b = 00101000b
-00111000b & 10101011b = 00101000b
-00111000b & 10101100b = 00101000b
-00111000b & 10101101b = 00101000b
-00111000b & 10101110b = 00101000b
-00111000b & 10101111b = 00101000b
-00111000b & 10110000b = 00110000b
-00111000b & 10110001b = 00110000b
-00111000b & 10110010b = 00110000b
-00111000b & 10110011b = 00110000b
-00111000b & 10110100b = 00110000b
-00111000b & 10110101b = 00110000b
-00111000b & 10110110b = 00110000b
-00111000b & 10110111b = 00110000b
-00111000b & 10111000b = 00111000b
-00111000b & 10111001b = 00111000b
-00111000b & 10111010b = 00111000b
-00111000b & 10111011b = 00111000b
-00111000b & 10111100b = 00111000b
-00111000b & 10111101b = 00111000b
-00111000b & 10111110b = 00111000b
-00111000b & 10111111b = 00111000b
-00111000b & 11000000b = 00000000b
-00111000b & 11000001b = 00000000b
-00111000b & 11000010b = 00000000b
-00111000b & 11000011b = 00000000b
-00111000b & 11000100b = 00000000b
-00111000b & 11000101b = 00000000b
-00111000b & 11000110b = 00000000b
-00111000b & 11000111b = 00000000b
-00111000b & 11001000b = 00001000b
-00111000b & 11001001b = 00001000b
-00111000b & 11001010b = 00001000b
-00111000b & 11001011b = 00001000b
-00111000b & 11001100b = 00001000b
-00111000b & 11001101b = 00001000b
-00111000b & 11001110b = 00001000b
-00111000b & 11001111b = 00001000b
-00111000b & 11010000b = 00010000b
-00111000b & 11010001b = 00010000b
-00111000b & 11010010b = 00010000b
-00111000b & 11010011b = 00010000b
-00111000b & 11010100b = 00010000b
-00111000b & 11010101b = 00010000b
-00111000b & 11010110b = 00010000b
-00111000b & 11010111b = 00010000b
-00111000b & 11011000b = 00011000b
-00111000b & 11011001b = 00011000b
-00111000b & 11011010b = 00011000b
-00111000b & 11011011b = 00011000b
-00111000b & 11011100b = 00011000b
-00111000b & 11011101b = 00011000b
-00111000b & 11011110b = 00011000b
-00111000b & 11011111b = 00011000b
-00111000b & 11100000b = 00100000b
-00111000b & 11100001b = 00100000b
-00111000b & 11100010b = 00100000b
-00111000b & 11100011b = 00100000b
-00111000b & 11100100b = 00100000b
-00111000b & 11100101b = 00100000b
-00111000b & 11100110b = 00100000b
-00111000b & 11100111b = 00100000b
-00111000b & 11101000b = 00101000b
-00111000b & 11101001b = 00101000b
-00111000b & 11101010b = 00101000b
-00111000b & 11101011b = 00101000b
-00111000b & 11101100b = 00101000b
-00111000b & 11101101b = 00101000b
-00111000b & 11101110b = 00101000b
-00111000b & 11101111b = 00101000b
-00111000b & 11110000b = 00110000b
-00111000b & 11110001b = 00110000b
-00111000b & 11110010b = 00110000b
-00111000b & 11110011b = 00110000b
-00111000b & 11110100b = 00110000b
-00111000b & 11110101b = 00110000b
-00111000b & 11110110b = 00110000b
-00111000b & 11110111b = 00110000b
-00111000b & 11111000b = 00111000b
-00111000b & 11111001b = 00111000b
-00111000b & 11111010b = 00111000b
-00111000b & 11111011b = 00111000b
-00111000b & 11111100b = 00111000b
-00111000b & 11111101b = 00111000b
-00111000b & 11111110b = 00111000b
-00111000b & 11111111b = 00111000b
-00111000b & 00000000b = 00000000b
-00111000b & 00000001b = 00000000b
-00111000b & 00000010b = 00000000b
-00111000b & 00000011b = 00000000b
-00111000b & 00000100b = 00000000b
-00111000b & 00000101b = 00000000b
-00111000b & 00000110b = 00000000b
-00111000b & 00000111b = 00000000b
-00111000b & 00001000b = 00001000b
-00111000b & 00001001b = 00001000b
-00111000b & 00001010b = 00001000b
-00111000b & 00001011b = 00001000b
-00111000b & 00001100b = 00001000b
-00111000b & 00001101b = 00001000b
-00111000b & 00001110b = 00001000b
-00111000b & 00001111b = 00001000b
-00111000b & 00010000b = 00010000b
-00111000b & 00010001b = 00010000b
-00111000b & 00010010b = 00010000b
-00111000b & 00010011b = 00010000b
-00111000b & 00010100b = 00010000b
-00111000b & 00010101b = 00010000b
-00111000b & 00010110b = 00010000b
-00111000b & 00010111b = 00010000b
-00111000b & 00011000b = 00011000b
-00111000b & 00011001b = 00011000b
-00111000b & 00011010b = 00011000b
-00111000b & 00011011b = 00011000b
-00111000b & 00011100b = 00011000b
-00111000b & 00011101b = 00011000b
-00111000b & 00011110b = 00011000b
-00111000b & 00011111b = 00011000b
-00111000b & 00100000b = 00100000b
-00111000b & 00100001b = 00100000b
-00111000b & 00100010b = 00100000b
-00111000b & 00100011b = 00100000b
-00111000b & 00100100b = 00100000b
-00111000b & 00100101b = 00100000b
-00111000b & 00100110b = 00100000b
-00111000b & 00100111b = 00100000b
-00111000b & 00101000b = 00101000b
-00111000b & 00101001b = 00101000b
-00111000b & 00101010b = 00101000b
-00111000b & 00101011b = 00101000b
-00111000b & 00101100b = 00101000b
-00111000b & 00101101b = 00101000b
-00111000b & 00101110b = 00101000b
-00111000b & 00101111b = 00101000b
-00111000b & 00110000b = 00110000b
-00111000b & 00110001b = 00110000b
-00111000b & 00110010b = 00110000b
-00111000b & 00110011b = 00110000b
-00111000b & 00110100b = 00110000b
-00111000b & 00110101b = 00110000b
-00111000b & 00110110b = 00110000b
-00111000b & 00110111b = 00110000b
-00111000b & 00111000b = 00111000b
-00111000b & 00111001b = 00111000b
-00111000b & 00111010b = 00111000b
-00111000b & 00111011b = 00111000b
-00111000b & 00111100b = 00111000b
-00111000b & 00111101b = 00111000b
-00111000b & 00111110b = 00111000b
-00111000b & 00111111b = 00111000b
-00111000b & 01000000b = 00000000b
-00111000b & 01000001b = 00000000b
-00111000b & 01000010b = 00000000b
-00111000b & 01000011b = 00000000b
-00111000b & 01000100b = 00000000b
-00111000b & 01000101b = 00000000b
-00111000b & 01000110b = 00000000b
-00111000b & 01000111b = 00000000b
-00111000b & 01001000b = 00001000b
-00111000b & 01001001b = 00001000b
-00111000b & 01001010b = 00001000b
-00111000b & 01001011b = 00001000b
-00111000b & 01001100b = 00001000b
-00111000b & 01001101b = 00001000b
-00111000b & 01001110b = 00001000b
-00111000b & 01001111b = 00001000b
-00111000b & 01010000b = 00010000b
-00111000b & 01010001b = 00010000b
-00111000b & 01010010b = 00010000b
-00111000b & 01010011b = 00010000b
-00111000b & 01010100b = 00010000b
-00111000b & 01010101b = 00010000b
-00111000b & 01010110b = 00010000b
-00111000b & 01010111b = 00010000b
-00111000b & 01011000b = 00011000b
-00111000b & 01011001b = 00011000b
-00111000b & 01011010b = 00011000b
-00111000b & 01011011b = 00011000b
-00111000b & 01011100b = 00011000b
-00111000b & 01011101b = 00011000b
-00111000b & 01011110b = 00011000b
-00111000b & 01011111b = 00011000b
-00111000b & 01100000b = 00100000b
-00111000b & 01100001b = 00100000b
-00111000b & 01100010b = 00100000b
-00111000b & 01100011b = 00100000b
-00111000b & 01100100b = 00100000b
-00111000b & 01100101b = 00100000b
-00111000b & 01100110b = 00100000b
-00111000b & 01100111b = 00100000b
-00111000b & 01101000b = 00101000b
-00111000b & 01101001b = 00101000b
-00111000b & 01101010b = 00101000b
-00111000b & 01101011b = 00101000b
-00111000b & 01101100b = 00101000b
-00111000b & 01101101b = 00101000b
-00111000b & 01101110b = 00101000b
-00111000b & 01101111b = 00101000b
-00111000b & 01110000b = 00110000b
-00111000b & 01110001b = 00110000b
-00111000b & 01110010b = 00110000b
-00111000b & 01110011b = 00110000b
-00111000b & 01110100b = 00110000b
-00111000b & 01110101b = 00110000b
-00111000b & 01110110b = 00110000b
-00111000b & 01110111b = 00110000b
-00111000b & 01111000b = 00111000b
-00111000b & 01111001b = 00111000b
-00111000b & 01111010b = 00111000b
-00111000b & 01111011b = 00111000b
-00111000b & 01111100b = 00111000b
-00111000b & 01111101b = 00111000b
-00111000b & 01111110b = 00111000b
-00111001b & 10000000b = 00000000b
-00111001b & 10000001b = 00000001b
-00111001b & 10000010b = 00000000b
-00111001b & 10000011b = 00000001b
-00111001b & 10000100b = 00000000b
-00111001b & 10000101b = 00000001b
-00111001b & 10000110b = 00000000b
-00111001b & 10000111b = 00000001b
-00111001b & 10001000b = 00001000b
-00111001b & 10001001b = 00001001b
-00111001b & 10001010b = 00001000b
-00111001b & 10001011b = 00001001b
-00111001b & 10001100b = 00001000b
-00111001b & 10001101b = 00001001b
-00111001b & 10001110b = 00001000b
-00111001b & 10001111b = 00001001b
-00111001b & 10010000b = 00010000b
-00111001b & 10010001b = 00010001b
-00111001b & 10010010b = 00010000b
-00111001b & 10010011b = 00010001b
-00111001b & 10010100b = 00010000b
-00111001b & 10010101b = 00010001b
-00111001b & 10010110b = 00010000b
-00111001b & 10010111b = 00010001b
-00111001b & 10011000b = 00011000b
-00111001b & 10011001b = 00011001b
-00111001b & 10011010b = 00011000b
-00111001b & 10011011b = 00011001b
-00111001b & 10011100b = 00011000b
-00111001b & 10011101b = 00011001b
-00111001b & 10011110b = 00011000b
-00111001b & 10011111b = 00011001b
-00111001b & 10100000b = 00100000b
-00111001b & 10100001b = 00100001b
-00111001b & 10100010b = 00100000b
-00111001b & 10100011b = 00100001b
-00111001b & 10100100b = 00100000b
-00111001b & 10100101b = 00100001b
-00111001b & 10100110b = 00100000b
-00111001b & 10100111b = 00100001b
-00111001b & 10101000b = 00101000b
-00111001b & 10101001b = 00101001b
-00111001b & 10101010b = 00101000b
-00111001b & 10101011b = 00101001b
-00111001b & 10101100b = 00101000b
-00111001b & 10101101b = 00101001b
-00111001b & 10101110b = 00101000b
-00111001b & 10101111b = 00101001b
-00111001b & 10110000b = 00110000b
-00111001b & 10110001b = 00110001b
-00111001b & 10110010b = 00110000b
-00111001b & 10110011b = 00110001b
-00111001b & 10110100b = 00110000b
-00111001b & 10110101b = 00110001b
-00111001b & 10110110b = 00110000b
-00111001b & 10110111b = 00110001b
-00111001b & 10111000b = 00111000b
-00111001b & 10111001b = 00111001b
-00111001b & 10111010b = 00111000b
-00111001b & 10111011b = 00111001b
-00111001b & 10111100b = 00111000b
-00111001b & 10111101b = 00111001b
-00111001b & 10111110b = 00111000b
-00111001b & 10111111b = 00111001b
-00111001b & 11000000b = 00000000b
-00111001b & 11000001b = 00000001b
-00111001b & 11000010b = 00000000b
-00111001b & 11000011b = 00000001b
-00111001b & 11000100b = 00000000b
-00111001b & 11000101b = 00000001b
-00111001b & 11000110b = 00000000b
-00111001b & 11000111b = 00000001b
-00111001b & 11001000b = 00001000b
-00111001b & 11001001b = 00001001b
-00111001b & 11001010b = 00001000b
-00111001b & 11001011b = 00001001b
-00111001b & 11001100b = 00001000b
-00111001b & 11001101b = 00001001b
-00111001b & 11001110b = 00001000b
-00111001b & 11001111b = 00001001b
-00111001b & 11010000b = 00010000b
-00111001b & 11010001b = 00010001b
-00111001b & 11010010b = 00010000b
-00111001b & 11010011b = 00010001b
-00111001b & 11010100b = 00010000b
-00111001b & 11010101b = 00010001b
-00111001b & 11010110b = 00010000b
-00111001b & 11010111b = 00010001b
-00111001b & 11011000b = 00011000b
-00111001b & 11011001b = 00011001b
-00111001b & 11011010b = 00011000b
-00111001b & 11011011b = 00011001b
-00111001b & 11011100b = 00011000b
-00111001b & 11011101b = 00011001b
-00111001b & 11011110b = 00011000b
-00111001b & 11011111b = 00011001b
-00111001b & 11100000b = 00100000b
-00111001b & 11100001b = 00100001b
-00111001b & 11100010b = 00100000b
-00111001b & 11100011b = 00100001b
-00111001b & 11100100b = 00100000b
-00111001b & 11100101b = 00100001b
-00111001b & 11100110b = 00100000b
-00111001b & 11100111b = 00100001b
-00111001b & 11101000b = 00101000b
-00111001b & 11101001b = 00101001b
-00111001b & 11101010b = 00101000b
-00111001b & 11101011b = 00101001b
-00111001b & 11101100b = 00101000b
-00111001b & 11101101b = 00101001b
-00111001b & 11101110b = 00101000b
-00111001b & 11101111b = 00101001b
-00111001b & 11110000b = 00110000b
-00111001b & 11110001b = 00110001b
-00111001b & 11110010b = 00110000b
-00111001b & 11110011b = 00110001b
-00111001b & 11110100b = 00110000b
-00111001b & 11110101b = 00110001b
-00111001b & 11110110b = 00110000b
-00111001b & 11110111b = 00110001b
-00111001b & 11111000b = 00111000b
-00111001b & 11111001b = 00111001b
-00111001b & 11111010b = 00111000b
-00111001b & 11111011b = 00111001b
-00111001b & 11111100b = 00111000b
-00111001b & 11111101b = 00111001b
-00111001b & 11111110b = 00111000b
-00111001b & 11111111b = 00111001b
-00111001b & 00000000b = 00000000b
-00111001b & 00000001b = 00000001b
-00111001b & 00000010b = 00000000b
-00111001b & 00000011b = 00000001b
-00111001b & 00000100b = 00000000b
-00111001b & 00000101b = 00000001b
-00111001b & 00000110b = 00000000b
-00111001b & 00000111b = 00000001b
-00111001b & 00001000b = 00001000b
-00111001b & 00001001b = 00001001b
-00111001b & 00001010b = 00001000b
-00111001b & 00001011b = 00001001b
-00111001b & 00001100b = 00001000b
-00111001b & 00001101b = 00001001b
-00111001b & 00001110b = 00001000b
-00111001b & 00001111b = 00001001b
-00111001b & 00010000b = 00010000b
-00111001b & 00010001b = 00010001b
-00111001b & 00010010b = 00010000b
-00111001b & 00010011b = 00010001b
-00111001b & 00010100b = 00010000b
-00111001b & 00010101b = 00010001b
-00111001b & 00010110b = 00010000b
-00111001b & 00010111b = 00010001b
-00111001b & 00011000b = 00011000b
-00111001b & 00011001b = 00011001b
-00111001b & 00011010b = 00011000b
-00111001b & 00011011b = 00011001b
-00111001b & 00011100b = 00011000b
-00111001b & 00011101b = 00011001b
-00111001b & 00011110b = 00011000b
-00111001b & 00011111b = 00011001b
-00111001b & 00100000b = 00100000b
-00111001b & 00100001b = 00100001b
-00111001b & 00100010b = 00100000b
-00111001b & 00100011b = 00100001b
-00111001b & 00100100b = 00100000b
-00111001b & 00100101b = 00100001b
-00111001b & 00100110b = 00100000b
-00111001b & 00100111b = 00100001b
-00111001b & 00101000b = 00101000b
-00111001b & 00101001b = 00101001b
-00111001b & 00101010b = 00101000b
-00111001b & 00101011b = 00101001b
-00111001b & 00101100b = 00101000b
-00111001b & 00101101b = 00101001b
-00111001b & 00101110b = 00101000b
-00111001b & 00101111b = 00101001b
-00111001b & 00110000b = 00110000b
-00111001b & 00110001b = 00110001b
-00111001b & 00110010b = 00110000b
-00111001b & 00110011b = 00110001b
-00111001b & 00110100b = 00110000b
-00111001b & 00110101b = 00110001b
-00111001b & 00110110b = 00110000b
-00111001b & 00110111b = 00110001b
-00111001b & 00111000b = 00111000b
-00111001b & 00111001b = 00111001b
-00111001b & 00111010b = 00111000b
-00111001b & 00111011b = 00111001b
-00111001b & 00111100b = 00111000b
-00111001b & 00111101b = 00111001b
-00111001b & 00111110b = 00111000b
-00111001b & 00111111b = 00111001b
-00111001b & 01000000b = 00000000b
-00111001b & 01000001b = 00000001b
-00111001b & 01000010b = 00000000b
-00111001b & 01000011b = 00000001b
-00111001b & 01000100b = 00000000b
-00111001b & 01000101b = 00000001b
-00111001b & 01000110b = 00000000b
-00111001b & 01000111b = 00000001b
-00111001b & 01001000b = 00001000b
-00111001b & 01001001b = 00001001b
-00111001b & 01001010b = 00001000b
-00111001b & 01001011b = 00001001b
-00111001b & 01001100b = 00001000b
-00111001b & 01001101b = 00001001b
-00111001b & 01001110b = 00001000b
-00111001b & 01001111b = 00001001b
-00111001b & 01010000b = 00010000b
-00111001b & 01010001b = 00010001b
-00111001b & 01010010b = 00010000b
-00111001b & 01010011b = 00010001b
-00111001b & 01010100b = 00010000b
-00111001b & 01010101b = 00010001b
-00111001b & 01010110b = 00010000b
-00111001b & 01010111b = 00010001b
-00111001b & 01011000b = 00011000b
-00111001b & 01011001b = 00011001b
-00111001b & 01011010b = 00011000b
-00111001b & 01011011b = 00011001b
-00111001b & 01011100b = 00011000b
-00111001b & 01011101b = 00011001b
-00111001b & 01011110b = 00011000b
-00111001b & 01011111b = 00011001b
-00111001b & 01100000b = 00100000b
-00111001b & 01100001b = 00100001b
-00111001b & 01100010b = 00100000b
-00111001b & 01100011b = 00100001b
-00111001b & 01100100b = 00100000b
-00111001b & 01100101b = 00100001b
-00111001b & 01100110b = 00100000b
-00111001b & 01100111b = 00100001b
-00111001b & 01101000b = 00101000b
-00111001b & 01101001b = 00101001b
-00111001b & 01101010b = 00101000b
-00111001b & 01101011b = 00101001b
-00111001b & 01101100b = 00101000b
-00111001b & 01101101b = 00101001b
-00111001b & 01101110b = 00101000b
-00111001b & 01101111b = 00101001b
-00111001b & 01110000b = 00110000b
-00111001b & 01110001b = 00110001b
-00111001b & 01110010b = 00110000b
-00111001b & 01110011b = 00110001b
-00111001b & 01110100b = 00110000b
-00111001b & 01110101b = 00110001b
-00111001b & 01110110b = 00110000b
-00111001b & 01110111b = 00110001b
-00111001b & 01111000b = 00111000b
-00111001b & 01111001b = 00111001b
-00111001b & 01111010b = 00111000b
-00111001b & 01111011b = 00111001b
-00111001b & 01111100b = 00111000b
-00111001b & 01111101b = 00111001b
-00111001b & 01111110b = 00111000b
-00111010b & 10000000b = 00000000b
-00111010b & 10000001b = 00000000b
-00111010b & 10000010b = 00000010b
-00111010b & 10000011b = 00000010b
-00111010b & 10000100b = 00000000b
-00111010b & 10000101b = 00000000b
-00111010b & 10000110b = 00000010b
-00111010b & 10000111b = 00000010b
-00111010b & 10001000b = 00001000b
-00111010b & 10001001b = 00001000b
-00111010b & 10001010b = 00001010b
-00111010b & 10001011b = 00001010b
-00111010b & 10001100b = 00001000b
-00111010b & 10001101b = 00001000b
-00111010b & 10001110b = 00001010b
-00111010b & 10001111b = 00001010b
-00111010b & 10010000b = 00010000b
-00111010b & 10010001b = 00010000b
-00111010b & 10010010b = 00010010b
-00111010b & 10010011b = 00010010b
-00111010b & 10010100b = 00010000b
-00111010b & 10010101b = 00010000b
-00111010b & 10010110b = 00010010b
-00111010b & 10010111b = 00010010b
-00111010b & 10011000b = 00011000b
-00111010b & 10011001b = 00011000b
-00111010b & 10011010b = 00011010b
-00111010b & 10011011b = 00011010b
-00111010b & 10011100b = 00011000b
-00111010b & 10011101b = 00011000b
-00111010b & 10011110b = 00011010b
-00111010b & 10011111b = 00011010b
-00111010b & 10100000b = 00100000b
-00111010b & 10100001b = 00100000b
-00111010b & 10100010b = 00100010b
-00111010b & 10100011b = 00100010b
-00111010b & 10100100b = 00100000b
-00111010b & 10100101b = 00100000b
-00111010b & 10100110b = 00100010b
-00111010b & 10100111b = 00100010b
-00111010b & 10101000b = 00101000b
-00111010b & 10101001b = 00101000b
-00111010b & 10101010b = 00101010b
-00111010b & 10101011b = 00101010b
-00111010b & 10101100b = 00101000b
-00111010b & 10101101b = 00101000b
-00111010b & 10101110b = 00101010b
-00111010b & 10101111b = 00101010b
-00111010b & 10110000b = 00110000b
-00111010b & 10110001b = 00110000b
-00111010b & 10110010b = 00110010b
-00111010b & 10110011b = 00110010b
-00111010b & 10110100b = 00110000b
-00111010b & 10110101b = 00110000b
-00111010b & 10110110b = 00110010b
-00111010b & 10110111b = 00110010b
-00111010b & 10111000b = 00111000b
-00111010b & 10111001b = 00111000b
-00111010b & 10111010b = 00111010b
-00111010b & 10111011b = 00111010b
-00111010b & 10111100b = 00111000b
-00111010b & 10111101b = 00111000b
-00111010b & 10111110b = 00111010b
-00111010b & 10111111b = 00111010b
-00111010b & 11000000b = 00000000b
-00111010b & 11000001b = 00000000b
-00111010b & 11000010b = 00000010b
-00111010b & 11000011b = 00000010b
-00111010b & 11000100b = 00000000b
-00111010b & 11000101b = 00000000b
-00111010b & 11000110b = 00000010b
-00111010b & 11000111b = 00000010b
-00111010b & 11001000b = 00001000b
-00111010b & 11001001b = 00001000b
-00111010b & 11001010b = 00001010b
-00111010b & 11001011b = 00001010b
-00111010b & 11001100b = 00001000b
-00111010b & 11001101b = 00001000b
-00111010b & 11001110b = 00001010b
-00111010b & 11001111b = 00001010b
-00111010b & 11010000b = 00010000b
-00111010b & 11010001b = 00010000b
-00111010b & 11010010b = 00010010b
-00111010b & 11010011b = 00010010b
-00111010b & 11010100b = 00010000b
-00111010b & 11010101b = 00010000b
-00111010b & 11010110b = 00010010b
-00111010b & 11010111b = 00010010b
-00111010b & 11011000b = 00011000b
-00111010b & 11011001b = 00011000b
-00111010b & 11011010b = 00011010b
-00111010b & 11011011b = 00011010b
-00111010b & 11011100b = 00011000b
-00111010b & 11011101b = 00011000b
-00111010b & 11011110b = 00011010b
-00111010b & 11011111b = 00011010b
-00111010b & 11100000b = 00100000b
-00111010b & 11100001b = 00100000b
-00111010b & 11100010b = 00100010b
-00111010b & 11100011b = 00100010b
-00111010b & 11100100b = 00100000b
-00111010b & 11100101b = 00100000b
-00111010b & 11100110b = 00100010b
-00111010b & 11100111b = 00100010b
-00111010b & 11101000b = 00101000b
-00111010b & 11101001b = 00101000b
-00111010b & 11101010b = 00101010b
-00111010b & 11101011b = 00101010b
-00111010b & 11101100b = 00101000b
-00111010b & 11101101b = 00101000b
-00111010b & 11101110b = 00101010b
-00111010b & 11101111b = 00101010b
-00111010b & 11110000b = 00110000b
-00111010b & 11110001b = 00110000b
-00111010b & 11110010b = 00110010b
-00111010b & 11110011b = 00110010b
-00111010b & 11110100b = 00110000b
-00111010b & 11110101b = 00110000b
-00111010b & 11110110b = 00110010b
-00111010b & 11110111b = 00110010b
-00111010b & 11111000b = 00111000b
-00111010b & 11111001b = 00111000b
-00111010b & 11111010b = 00111010b
-00111010b & 11111011b = 00111010b
-00111010b & 11111100b = 00111000b
-00111010b & 11111101b = 00111000b
-00111010b & 11111110b = 00111010b
-00111010b & 11111111b = 00111010b
-00111010b & 00000000b = 00000000b
-00111010b & 00000001b = 00000000b
-00111010b & 00000010b = 00000010b
-00111010b & 00000011b = 00000010b
-00111010b & 00000100b = 00000000b
-00111010b & 00000101b = 00000000b
-00111010b & 00000110b = 00000010b
-00111010b & 00000111b = 00000010b
-00111010b & 00001000b = 00001000b
-00111010b & 00001001b = 00001000b
-00111010b & 00001010b = 00001010b
-00111010b & 00001011b = 00001010b
-00111010b & 00001100b = 00001000b
-00111010b & 00001101b = 00001000b
-00111010b & 00001110b = 00001010b
-00111010b & 00001111b = 00001010b
-00111010b & 00010000b = 00010000b
-00111010b & 00010001b = 00010000b
-00111010b & 00010010b = 00010010b
-00111010b & 00010011b = 00010010b
-00111010b & 00010100b = 00010000b
-00111010b & 00010101b = 00010000b
-00111010b & 00010110b = 00010010b
-00111010b & 00010111b = 00010010b
-00111010b & 00011000b = 00011000b
-00111010b & 00011001b = 00011000b
-00111010b & 00011010b = 00011010b
-00111010b & 00011011b = 00011010b
-00111010b & 00011100b = 00011000b
-00111010b & 00011101b = 00011000b
-00111010b & 00011110b = 00011010b
-00111010b & 00011111b = 00011010b
-00111010b & 00100000b = 00100000b
-00111010b & 00100001b = 00100000b
-00111010b & 00100010b = 00100010b
-00111010b & 00100011b = 00100010b
-00111010b & 00100100b = 00100000b
-00111010b & 00100101b = 00100000b
-00111010b & 00100110b = 00100010b
-00111010b & 00100111b = 00100010b
-00111010b & 00101000b = 00101000b
-00111010b & 00101001b = 00101000b
-00111010b & 00101010b = 00101010b
-00111010b & 00101011b = 00101010b
-00111010b & 00101100b = 00101000b
-00111010b & 00101101b = 00101000b
-00111010b & 00101110b = 00101010b
-00111010b & 00101111b = 00101010b
-00111010b & 00110000b = 00110000b
-00111010b & 00110001b = 00110000b
-00111010b & 00110010b = 00110010b
-00111010b & 00110011b = 00110010b
-00111010b & 00110100b = 00110000b
-00111010b & 00110101b = 00110000b
-00111010b & 00110110b = 00110010b
-00111010b & 00110111b = 00110010b
-00111010b & 00111000b = 00111000b
-00111010b & 00111001b = 00111000b
-00111010b & 00111010b = 00111010b
-00111010b & 00111011b = 00111010b
-00111010b & 00111100b = 00111000b
-00111010b & 00111101b = 00111000b
-00111010b & 00111110b = 00111010b
-00111010b & 00111111b = 00111010b
-00111010b & 01000000b = 00000000b
-00111010b & 01000001b = 00000000b
-00111010b & 01000010b = 00000010b
-00111010b & 01000011b = 00000010b
-00111010b & 01000100b = 00000000b
-00111010b & 01000101b = 00000000b
-00111010b & 01000110b = 00000010b
-00111010b & 01000111b = 00000010b
-00111010b & 01001000b = 00001000b
-00111010b & 01001001b = 00001000b
-00111010b & 01001010b = 00001010b
-00111010b & 01001011b = 00001010b
-00111010b & 01001100b = 00001000b
-00111010b & 01001101b = 00001000b
-00111010b & 01001110b = 00001010b
-00111010b & 01001111b = 00001010b
-00111010b & 01010000b = 00010000b
-00111010b & 01010001b = 00010000b
-00111010b & 01010010b = 00010010b
-00111010b & 01010011b = 00010010b
-00111010b & 01010100b = 00010000b
-00111010b & 01010101b = 00010000b
-00111010b & 01010110b = 00010010b
-00111010b & 01010111b = 00010010b
-00111010b & 01011000b = 00011000b
-00111010b & 01011001b = 00011000b
-00111010b & 01011010b = 00011010b
-00111010b & 01011011b = 00011010b
-00111010b & 01011100b = 00011000b
-00111010b & 01011101b = 00011000b
-00111010b & 01011110b = 00011010b
-00111010b & 01011111b = 00011010b
-00111010b & 01100000b = 00100000b
-00111010b & 01100001b = 00100000b
-00111010b & 01100010b = 00100010b
-00111010b & 01100011b = 00100010b
-00111010b & 01100100b = 00100000b
-00111010b & 01100101b = 00100000b
-00111010b & 01100110b = 00100010b
-00111010b & 01100111b = 00100010b
-00111010b & 01101000b = 00101000b
-00111010b & 01101001b = 00101000b
-00111010b & 01101010b = 00101010b
-00111010b & 01101011b = 00101010b
-00111010b & 01101100b = 00101000b
-00111010b & 01101101b = 00101000b
-00111010b & 01101110b = 00101010b
-00111010b & 01101111b = 00101010b
-00111010b & 01110000b = 00110000b
-00111010b & 01110001b = 00110000b
-00111010b & 01110010b = 00110010b
-00111010b & 01110011b = 00110010b
-00111010b & 01110100b = 00110000b
-00111010b & 01110101b = 00110000b
-00111010b & 01110110b = 00110010b
-00111010b & 01110111b = 00110010b
-00111010b & 01111000b = 00111000b
-00111010b & 01111001b = 00111000b
-00111010b & 01111010b = 00111010b
-00111010b & 01111011b = 00111010b
-00111010b & 01111100b = 00111000b
-00111010b & 01111101b = 00111000b
-00111010b & 01111110b = 00111010b
-00111011b & 10000000b = 00000000b
-00111011b & 10000001b = 00000001b
-00111011b & 10000010b = 00000010b
-00111011b & 10000011b = 00000011b
-00111011b & 10000100b = 00000000b
-00111011b & 10000101b = 00000001b
-00111011b & 10000110b = 00000010b
-00111011b & 10000111b = 00000011b
-00111011b & 10001000b = 00001000b
-00111011b & 10001001b = 00001001b
-00111011b & 10001010b = 00001010b
-00111011b & 10001011b = 00001011b
-00111011b & 10001100b = 00001000b
-00111011b & 10001101b = 00001001b
-00111011b & 10001110b = 00001010b
-00111011b & 10001111b = 00001011b
-00111011b & 10010000b = 00010000b
-00111011b & 10010001b = 00010001b
-00111011b & 10010010b = 00010010b
-00111011b & 10010011b = 00010011b
-00111011b & 10010100b = 00010000b
-00111011b & 10010101b = 00010001b
-00111011b & 10010110b = 00010010b
-00111011b & 10010111b = 00010011b
-00111011b & 10011000b = 00011000b
-00111011b & 10011001b = 00011001b
-00111011b & 10011010b = 00011010b
-00111011b & 10011011b = 00011011b
-00111011b & 10011100b = 00011000b
-00111011b & 10011101b = 00011001b
-00111011b & 10011110b = 00011010b
-00111011b & 10011111b = 00011011b
-00111011b & 10100000b = 00100000b
-00111011b & 10100001b = 00100001b
-00111011b & 10100010b = 00100010b
-00111011b & 10100011b = 00100011b
-00111011b & 10100100b = 00100000b
-00111011b & 10100101b = 00100001b
-00111011b & 10100110b = 00100010b
-00111011b & 10100111b = 00100011b
-00111011b & 10101000b = 00101000b
-00111011b & 10101001b = 00101001b
-00111011b & 10101010b = 00101010b
-00111011b & 10101011b = 00101011b
-00111011b & 10101100b = 00101000b
-00111011b & 10101101b = 00101001b
-00111011b & 10101110b = 00101010b
-00111011b & 10101111b = 00101011b
-00111011b & 10110000b = 00110000b
-00111011b & 10110001b = 00110001b
-00111011b & 10110010b = 00110010b
-00111011b & 10110011b = 00110011b
-00111011b & 10110100b = 00110000b
-00111011b & 10110101b = 00110001b
-00111011b & 10110110b = 00110010b
-00111011b & 10110111b = 00110011b
-00111011b & 10111000b = 00111000b
-00111011b & 10111001b = 00111001b
-00111011b & 10111010b = 00111010b
-00111011b & 10111011b = 00111011b
-00111011b & 10111100b = 00111000b
-00111011b & 10111101b = 00111001b
-00111011b & 10111110b = 00111010b
-00111011b & 10111111b = 00111011b
-00111011b & 11000000b = 00000000b
-00111011b & 11000001b = 00000001b
-00111011b & 11000010b = 00000010b
-00111011b & 11000011b = 00000011b
-00111011b & 11000100b = 00000000b
-00111011b & 11000101b = 00000001b
-00111011b & 11000110b = 00000010b
-00111011b & 11000111b = 00000011b
-00111011b & 11001000b = 00001000b
-00111011b & 11001001b = 00001001b
-00111011b & 11001010b = 00001010b
-00111011b & 11001011b = 00001011b
-00111011b & 11001100b = 00001000b
-00111011b & 11001101b = 00001001b
-00111011b & 11001110b = 00001010b
-00111011b & 11001111b = 00001011b
-00111011b & 11010000b = 00010000b
-00111011b & 11010001b = 00010001b
-00111011b & 11010010b = 00010010b
-00111011b & 11010011b = 00010011b
-00111011b & 11010100b = 00010000b
-00111011b & 11010101b = 00010001b
-00111011b & 11010110b = 00010010b
-00111011b & 11010111b = 00010011b
-00111011b & 11011000b = 00011000b
-00111011b & 11011001b = 00011001b
-00111011b & 11011010b = 00011010b
-00111011b & 11011011b = 00011011b
-00111011b & 11011100b = 00011000b
-00111011b & 11011101b = 00011001b
-00111011b & 11011110b = 00011010b
-00111011b & 11011111b = 00011011b
-00111011b & 11100000b = 00100000b
-00111011b & 11100001b = 00100001b
-00111011b & 11100010b = 00100010b
-00111011b & 11100011b = 00100011b
-00111011b & 11100100b = 00100000b
-00111011b & 11100101b = 00100001b
-00111011b & 11100110b = 00100010b
-00111011b & 11100111b = 00100011b
-00111011b & 11101000b = 00101000b
-00111011b & 11101001b = 00101001b
-00111011b & 11101010b = 00101010b
-00111011b & 11101011b = 00101011b
-00111011b & 11101100b = 00101000b
-00111011b & 11101101b = 00101001b
-00111011b & 11101110b = 00101010b
-00111011b & 11101111b = 00101011b
-00111011b & 11110000b = 00110000b
-00111011b & 11110001b = 00110001b
-00111011b & 11110010b = 00110010b
-00111011b & 11110011b = 00110011b
-00111011b & 11110100b = 00110000b
-00111011b & 11110101b = 00110001b
-00111011b & 11110110b = 00110010b
-00111011b & 11110111b = 00110011b
-00111011b & 11111000b = 00111000b
-00111011b & 11111001b = 00111001b
-00111011b & 11111010b = 00111010b
-00111011b & 11111011b = 00111011b
-00111011b & 11111100b = 00111000b
-00111011b & 11111101b = 00111001b
-00111011b & 11111110b = 00111010b
-00111011b & 11111111b = 00111011b
-00111011b & 00000000b = 00000000b
-00111011b & 00000001b = 00000001b
-00111011b & 00000010b = 00000010b
-00111011b & 00000011b = 00000011b
-00111011b & 00000100b = 00000000b
-00111011b & 00000101b = 00000001b
-00111011b & 00000110b = 00000010b
-00111011b & 00000111b = 00000011b
-00111011b & 00001000b = 00001000b
-00111011b & 00001001b = 00001001b
-00111011b & 00001010b = 00001010b
-00111011b & 00001011b = 00001011b
-00111011b & 00001100b = 00001000b
-00111011b & 00001101b = 00001001b
-00111011b & 00001110b = 00001010b
-00111011b & 00001111b = 00001011b
-00111011b & 00010000b = 00010000b
-00111011b & 00010001b = 00010001b
-00111011b & 00010010b = 00010010b
-00111011b & 00010011b = 00010011b
-00111011b & 00010100b = 00010000b
-00111011b & 00010101b = 00010001b
-00111011b & 00010110b = 00010010b
-00111011b & 00010111b = 00010011b
-00111011b & 00011000b = 00011000b
-00111011b & 00011001b = 00011001b
-00111011b & 00011010b = 00011010b
-00111011b & 00011011b = 00011011b
-00111011b & 00011100b = 00011000b
-00111011b & 00011101b = 00011001b
-00111011b & 00011110b = 00011010b
-00111011b & 00011111b = 00011011b
-00111011b & 00100000b = 00100000b
-00111011b & 00100001b = 00100001b
-00111011b & 00100010b = 00100010b
-00111011b & 00100011b = 00100011b
-00111011b & 00100100b = 00100000b
-00111011b & 00100101b = 00100001b
-00111011b & 00100110b = 00100010b
-00111011b & 00100111b = 00100011b
-00111011b & 00101000b = 00101000b
-00111011b & 00101001b = 00101001b
-00111011b & 00101010b = 00101010b
-00111011b & 00101011b = 00101011b
-00111011b & 00101100b = 00101000b
-00111011b & 00101101b = 00101001b
-00111011b & 00101110b = 00101010b
-00111011b & 00101111b = 00101011b
-00111011b & 00110000b = 00110000b
-00111011b & 00110001b = 00110001b
-00111011b & 00110010b = 00110010b
-00111011b & 00110011b = 00110011b
-00111011b & 00110100b = 00110000b
-00111011b & 00110101b = 00110001b
-00111011b & 00110110b = 00110010b
-00111011b & 00110111b = 00110011b
-00111011b & 00111000b = 00111000b
-00111011b & 00111001b = 00111001b
-00111011b & 00111010b = 00111010b
-00111011b & 00111011b = 00111011b
-00111011b & 00111100b = 00111000b
-00111011b & 00111101b = 00111001b
-00111011b & 00111110b = 00111010b
-00111011b & 00111111b = 00111011b
-00111011b & 01000000b = 00000000b
-00111011b & 01000001b = 00000001b
-00111011b & 01000010b = 00000010b
-00111011b & 01000011b = 00000011b
-00111011b & 01000100b = 00000000b
-00111011b & 01000101b = 00000001b
-00111011b & 01000110b = 00000010b
-00111011b & 01000111b = 00000011b
-00111011b & 01001000b = 00001000b
-00111011b & 01001001b = 00001001b
-00111011b & 01001010b = 00001010b
-00111011b & 01001011b = 00001011b
-00111011b & 01001100b = 00001000b
-00111011b & 01001101b = 00001001b
-00111011b & 01001110b = 00001010b
-00111011b & 01001111b = 00001011b
-00111011b & 01010000b = 00010000b
-00111011b & 01010001b = 00010001b
-00111011b & 01010010b = 00010010b
-00111011b & 01010011b = 00010011b
-00111011b & 01010100b = 00010000b
-00111011b & 01010101b = 00010001b
-00111011b & 01010110b = 00010010b
-00111011b & 01010111b = 00010011b
-00111011b & 01011000b = 00011000b
-00111011b & 01011001b = 00011001b
-00111011b & 01011010b = 00011010b
-00111011b & 01011011b = 00011011b
-00111011b & 01011100b = 00011000b
-00111011b & 01011101b = 00011001b
-00111011b & 01011110b = 00011010b
-00111011b & 01011111b = 00011011b
-00111011b & 01100000b = 00100000b
-00111011b & 01100001b = 00100001b
-00111011b & 01100010b = 00100010b
-00111011b & 01100011b = 00100011b
-00111011b & 01100100b = 00100000b
-00111011b & 01100101b = 00100001b
-00111011b & 01100110b = 00100010b
-00111011b & 01100111b = 00100011b
-00111011b & 01101000b = 00101000b
-00111011b & 01101001b = 00101001b
-00111011b & 01101010b = 00101010b
-00111011b & 01101011b = 00101011b
-00111011b & 01101100b = 00101000b
-00111011b & 01101101b = 00101001b
-00111011b & 01101110b = 00101010b
-00111011b & 01101111b = 00101011b
-00111011b & 01110000b = 00110000b
-00111011b & 01110001b = 00110001b
-00111011b & 01110010b = 00110010b
-00111011b & 01110011b = 00110011b
-00111011b & 01110100b = 00110000b
-00111011b & 01110101b = 00110001b
-00111011b & 01110110b = 00110010b
-00111011b & 01110111b = 00110011b
-00111011b & 01111000b = 00111000b
-00111011b & 01111001b = 00111001b
-00111011b & 01111010b = 00111010b
-00111011b & 01111011b = 00111011b
-00111011b & 01111100b = 00111000b
-00111011b & 01111101b = 00111001b
-00111011b & 01111110b = 00111010b
-00111100b & 10000000b = 00000000b
-00111100b & 10000001b = 00000000b
-00111100b & 10000010b = 00000000b
-00111100b & 10000011b = 00000000b
-00111100b & 10000100b = 00000100b
-00111100b & 10000101b = 00000100b
-00111100b & 10000110b = 00000100b
-00111100b & 10000111b = 00000100b
-00111100b & 10001000b = 00001000b
-00111100b & 10001001b = 00001000b
-00111100b & 10001010b = 00001000b
-00111100b & 10001011b = 00001000b
-00111100b & 10001100b = 00001100b
-00111100b & 10001101b = 00001100b
-00111100b & 10001110b = 00001100b
-00111100b & 10001111b = 00001100b
-00111100b & 10010000b = 00010000b
-00111100b & 10010001b = 00010000b
-00111100b & 10010010b = 00010000b
-00111100b & 10010011b = 00010000b
-00111100b & 10010100b = 00010100b
-00111100b & 10010101b = 00010100b
-00111100b & 10010110b = 00010100b
-00111100b & 10010111b = 00010100b
-00111100b & 10011000b = 00011000b
-00111100b & 10011001b = 00011000b
-00111100b & 10011010b = 00011000b
-00111100b & 10011011b = 00011000b
-00111100b & 10011100b = 00011100b
-00111100b & 10011101b = 00011100b
-00111100b & 10011110b = 00011100b
-00111100b & 10011111b = 00011100b
-00111100b & 10100000b = 00100000b
-00111100b & 10100001b = 00100000b
-00111100b & 10100010b = 00100000b
-00111100b & 10100011b = 00100000b
-00111100b & 10100100b = 00100100b
-00111100b & 10100101b = 00100100b
-00111100b & 10100110b = 00100100b
-00111100b & 10100111b = 00100100b
-00111100b & 10101000b = 00101000b
-00111100b & 10101001b = 00101000b
-00111100b & 10101010b = 00101000b
-00111100b & 10101011b = 00101000b
-00111100b & 10101100b = 00101100b
-00111100b & 10101101b = 00101100b
-00111100b & 10101110b = 00101100b
-00111100b & 10101111b = 00101100b
-00111100b & 10110000b = 00110000b
-00111100b & 10110001b = 00110000b
-00111100b & 10110010b = 00110000b
-00111100b & 10110011b = 00110000b
-00111100b & 10110100b = 00110100b
-00111100b & 10110101b = 00110100b
-00111100b & 10110110b = 00110100b
-00111100b & 10110111b = 00110100b
-00111100b & 10111000b = 00111000b
-00111100b & 10111001b = 00111000b
-00111100b & 10111010b = 00111000b
-00111100b & 10111011b = 00111000b
-00111100b & 10111100b = 00111100b
-00111100b & 10111101b = 00111100b
-00111100b & 10111110b = 00111100b
-00111100b & 10111111b = 00111100b
-00111100b & 11000000b = 00000000b
-00111100b & 11000001b = 00000000b
-00111100b & 11000010b = 00000000b
-00111100b & 11000011b = 00000000b
-00111100b & 11000100b = 00000100b
-00111100b & 11000101b = 00000100b
-00111100b & 11000110b = 00000100b
-00111100b & 11000111b = 00000100b
-00111100b & 11001000b = 00001000b
-00111100b & 11001001b = 00001000b
-00111100b & 11001010b = 00001000b
-00111100b & 11001011b = 00001000b
-00111100b & 11001100b = 00001100b
-00111100b & 11001101b = 00001100b
-00111100b & 11001110b = 00001100b
-00111100b & 11001111b = 00001100b
-00111100b & 11010000b = 00010000b
-00111100b & 11010001b = 00010000b
-00111100b & 11010010b = 00010000b
-00111100b & 11010011b = 00010000b
-00111100b & 11010100b = 00010100b
-00111100b & 11010101b = 00010100b
-00111100b & 11010110b = 00010100b
-00111100b & 11010111b = 00010100b
-00111100b & 11011000b = 00011000b
-00111100b & 11011001b = 00011000b
-00111100b & 11011010b = 00011000b
-00111100b & 11011011b = 00011000b
-00111100b & 11011100b = 00011100b
-00111100b & 11011101b = 00011100b
-00111100b & 11011110b = 00011100b
-00111100b & 11011111b = 00011100b
-00111100b & 11100000b = 00100000b
-00111100b & 11100001b = 00100000b
-00111100b & 11100010b = 00100000b
-00111100b & 11100011b = 00100000b
-00111100b & 11100100b = 00100100b
-00111100b & 11100101b = 00100100b
-00111100b & 11100110b = 00100100b
-00111100b & 11100111b = 00100100b
-00111100b & 11101000b = 00101000b
-00111100b & 11101001b = 00101000b
-00111100b & 11101010b = 00101000b
-00111100b & 11101011b = 00101000b
-00111100b & 11101100b = 00101100b
-00111100b & 11101101b = 00101100b
-00111100b & 11101110b = 00101100b
-00111100b & 11101111b = 00101100b
-00111100b & 11110000b = 00110000b
-00111100b & 11110001b = 00110000b
-00111100b & 11110010b = 00110000b
-00111100b & 11110011b = 00110000b
-00111100b & 11110100b = 00110100b
-00111100b & 11110101b = 00110100b
-00111100b & 11110110b = 00110100b
-00111100b & 11110111b = 00110100b
-00111100b & 11111000b = 00111000b
-00111100b & 11111001b = 00111000b
-00111100b & 11111010b = 00111000b
-00111100b & 11111011b = 00111000b
-00111100b & 11111100b = 00111100b
-00111100b & 11111101b = 00111100b
-00111100b & 11111110b = 00111100b
-00111100b & 11111111b = 00111100b
-00111100b & 00000000b = 00000000b
-00111100b & 00000001b = 00000000b
-00111100b & 00000010b = 00000000b
-00111100b & 00000011b = 00000000b
-00111100b & 00000100b = 00000100b
-00111100b & 00000101b = 00000100b
-00111100b & 00000110b = 00000100b
-00111100b & 00000111b = 00000100b
-00111100b & 00001000b = 00001000b
-00111100b & 00001001b = 00001000b
-00111100b & 00001010b = 00001000b
-00111100b & 00001011b = 00001000b
-00111100b & 00001100b = 00001100b
-00111100b & 00001101b = 00001100b
-00111100b & 00001110b = 00001100b
-00111100b & 00001111b = 00001100b
-00111100b & 00010000b = 00010000b
-00111100b & 00010001b = 00010000b
-00111100b & 00010010b = 00010000b
-00111100b & 00010011b = 00010000b
-00111100b & 00010100b = 00010100b
-00111100b & 00010101b = 00010100b
-00111100b & 00010110b = 00010100b
-00111100b & 00010111b = 00010100b
-00111100b & 00011000b = 00011000b
-00111100b & 00011001b = 00011000b
-00111100b & 00011010b = 00011000b
-00111100b & 00011011b = 00011000b
-00111100b & 00011100b = 00011100b
-00111100b & 00011101b = 00011100b
-00111100b & 00011110b = 00011100b
-00111100b & 00011111b = 00011100b
-00111100b & 00100000b = 00100000b
-00111100b & 00100001b = 00100000b
-00111100b & 00100010b = 00100000b
-00111100b & 00100011b = 00100000b
-00111100b & 00100100b = 00100100b
-00111100b & 00100101b = 00100100b
-00111100b & 00100110b = 00100100b
-00111100b & 00100111b = 00100100b
-00111100b & 00101000b = 00101000b
-00111100b & 00101001b = 00101000b
-00111100b & 00101010b = 00101000b
-00111100b & 00101011b = 00101000b
-00111100b & 00101100b = 00101100b
-00111100b & 00101101b = 00101100b
-00111100b & 00101110b = 00101100b
-00111100b & 00101111b = 00101100b
-00111100b & 00110000b = 00110000b
-00111100b & 00110001b = 00110000b
-00111100b & 00110010b = 00110000b
-00111100b & 00110011b = 00110000b
-00111100b & 00110100b = 00110100b
-00111100b & 00110101b = 00110100b
-00111100b & 00110110b = 00110100b
-00111100b & 00110111b = 00110100b
-00111100b & 00111000b = 00111000b
-00111100b & 00111001b = 00111000b
-00111100b & 00111010b = 00111000b
-00111100b & 00111011b = 00111000b
-00111100b & 00111100b = 00111100b
-00111100b & 00111101b = 00111100b
-00111100b & 00111110b = 00111100b
-00111100b & 00111111b = 00111100b
-00111100b & 01000000b = 00000000b
-00111100b & 01000001b = 00000000b
-00111100b & 01000010b = 00000000b
-00111100b & 01000011b = 00000000b
-00111100b & 01000100b = 00000100b
-00111100b & 01000101b = 00000100b
-00111100b & 01000110b = 00000100b
-00111100b & 01000111b = 00000100b
-00111100b & 01001000b = 00001000b
-00111100b & 01001001b = 00001000b
-00111100b & 01001010b = 00001000b
-00111100b & 01001011b = 00001000b
-00111100b & 01001100b = 00001100b
-00111100b & 01001101b = 00001100b
-00111100b & 01001110b = 00001100b
-00111100b & 01001111b = 00001100b
-00111100b & 01010000b = 00010000b
-00111100b & 01010001b = 00010000b
-00111100b & 01010010b = 00010000b
-00111100b & 01010011b = 00010000b
-00111100b & 01010100b = 00010100b
-00111100b & 01010101b = 00010100b
-00111100b & 01010110b = 00010100b
-00111100b & 01010111b = 00010100b
-00111100b & 01011000b = 00011000b
-00111100b & 01011001b = 00011000b
-00111100b & 01011010b = 00011000b
-00111100b & 01011011b = 00011000b
-00111100b & 01011100b = 00011100b
-00111100b & 01011101b = 00011100b
-00111100b & 01011110b = 00011100b
-00111100b & 01011111b = 00011100b
-00111100b & 01100000b = 00100000b
-00111100b & 01100001b = 00100000b
-00111100b & 01100010b = 00100000b
-00111100b & 01100011b = 00100000b
-00111100b & 01100100b = 00100100b
-00111100b & 01100101b = 00100100b
-00111100b & 01100110b = 00100100b
-00111100b & 01100111b = 00100100b
-00111100b & 01101000b = 00101000b
-00111100b & 01101001b = 00101000b
-00111100b & 01101010b = 00101000b
-00111100b & 01101011b = 00101000b
-00111100b & 01101100b = 00101100b
-00111100b & 01101101b = 00101100b
-00111100b & 01101110b = 00101100b
-00111100b & 01101111b = 00101100b
-00111100b & 01110000b = 00110000b
-00111100b & 01110001b = 00110000b
-00111100b & 01110010b = 00110000b
-00111100b & 01110011b = 00110000b
-00111100b & 01110100b = 00110100b
-00111100b & 01110101b = 00110100b
-00111100b & 01110110b = 00110100b
-00111100b & 01110111b = 00110100b
-00111100b & 01111000b = 00111000b
-00111100b & 01111001b = 00111000b
-00111100b & 01111010b = 00111000b
-00111100b & 01111011b = 00111000b
-00111100b & 01111100b = 00111100b
-00111100b & 01111101b = 00111100b
-00111100b & 01111110b = 00111100b
-00111101b & 10000000b = 00000000b
-00111101b & 10000001b = 00000001b
-00111101b & 10000010b = 00000000b
-00111101b & 10000011b = 00000001b
-00111101b & 10000100b = 00000100b
-00111101b & 10000101b = 00000101b
-00111101b & 10000110b = 00000100b
-00111101b & 10000111b = 00000101b
-00111101b & 10001000b = 00001000b
-00111101b & 10001001b = 00001001b
-00111101b & 10001010b = 00001000b
-00111101b & 10001011b = 00001001b
-00111101b & 10001100b = 00001100b
-00111101b & 10001101b = 00001101b
-00111101b & 10001110b = 00001100b
-00111101b & 10001111b = 00001101b
-00111101b & 10010000b = 00010000b
-00111101b & 10010001b = 00010001b
-00111101b & 10010010b = 00010000b
-00111101b & 10010011b = 00010001b
-00111101b & 10010100b = 00010100b
-00111101b & 10010101b = 00010101b
-00111101b & 10010110b = 00010100b
-00111101b & 10010111b = 00010101b
-00111101b & 10011000b = 00011000b
-00111101b & 10011001b = 00011001b
-00111101b & 10011010b = 00011000b
-00111101b & 10011011b = 00011001b
-00111101b & 10011100b = 00011100b
-00111101b & 10011101b = 00011101b
-00111101b & 10011110b = 00011100b
-00111101b & 10011111b = 00011101b
-00111101b & 10100000b = 00100000b
-00111101b & 10100001b = 00100001b
-00111101b & 10100010b = 00100000b
-00111101b & 10100011b = 00100001b
-00111101b & 10100100b = 00100100b
-00111101b & 10100101b = 00100101b
-00111101b & 10100110b = 00100100b
-00111101b & 10100111b = 00100101b
-00111101b & 10101000b = 00101000b
-00111101b & 10101001b = 00101001b
-00111101b & 10101010b = 00101000b
-00111101b & 10101011b = 00101001b
-00111101b & 10101100b = 00101100b
-00111101b & 10101101b = 00101101b
-00111101b & 10101110b = 00101100b
-00111101b & 10101111b = 00101101b
-00111101b & 10110000b = 00110000b
-00111101b & 10110001b = 00110001b
-00111101b & 10110010b = 00110000b
-00111101b & 10110011b = 00110001b
-00111101b & 10110100b = 00110100b
-00111101b & 10110101b = 00110101b
-00111101b & 10110110b = 00110100b
-00111101b & 10110111b = 00110101b
-00111101b & 10111000b = 00111000b
-00111101b & 10111001b = 00111001b
-00111101b & 10111010b = 00111000b
-00111101b & 10111011b = 00111001b
-00111101b & 10111100b = 00111100b
-00111101b & 10111101b = 00111101b
-00111101b & 10111110b = 00111100b
-00111101b & 10111111b = 00111101b
-00111101b & 11000000b = 00000000b
-00111101b & 11000001b = 00000001b
-00111101b & 11000010b = 00000000b
-00111101b & 11000011b = 00000001b
-00111101b & 11000100b = 00000100b
-00111101b & 11000101b = 00000101b
-00111101b & 11000110b = 00000100b
-00111101b & 11000111b = 00000101b
-00111101b & 11001000b = 00001000b
-00111101b & 11001001b = 00001001b
-00111101b & 11001010b = 00001000b
-00111101b & 11001011b = 00001001b
-00111101b & 11001100b = 00001100b
-00111101b & 11001101b = 00001101b
-00111101b & 11001110b = 00001100b
-00111101b & 11001111b = 00001101b
-00111101b & 11010000b = 00010000b
-00111101b & 11010001b = 00010001b
-00111101b & 11010010b = 00010000b
-00111101b & 11010011b = 00010001b
-00111101b & 11010100b = 00010100b
-00111101b & 11010101b = 00010101b
-00111101b & 11010110b = 00010100b
-00111101b & 11010111b = 00010101b
-00111101b & 11011000b = 00011000b
-00111101b & 11011001b = 00011001b
-00111101b & 11011010b = 00011000b
-00111101b & 11011011b = 00011001b
-00111101b & 11011100b = 00011100b
-00111101b & 11011101b = 00011101b
-00111101b & 11011110b = 00011100b
-00111101b & 11011111b = 00011101b
-00111101b & 11100000b = 00100000b
-00111101b & 11100001b = 00100001b
-00111101b & 11100010b = 00100000b
-00111101b & 11100011b = 00100001b
-00111101b & 11100100b = 00100100b
-00111101b & 11100101b = 00100101b
-00111101b & 11100110b = 00100100b
-00111101b & 11100111b = 00100101b
-00111101b & 11101000b = 00101000b
-00111101b & 11101001b = 00101001b
-00111101b & 11101010b = 00101000b
-00111101b & 11101011b = 00101001b
-00111101b & 11101100b = 00101100b
-00111101b & 11101101b = 00101101b
-00111101b & 11101110b = 00101100b
-00111101b & 11101111b = 00101101b
-00111101b & 11110000b = 00110000b
-00111101b & 11110001b = 00110001b
-00111101b & 11110010b = 00110000b
-00111101b & 11110011b = 00110001b
-00111101b & 11110100b = 00110100b
-00111101b & 11110101b = 00110101b
-00111101b & 11110110b = 00110100b
-00111101b & 11110111b = 00110101b
-00111101b & 11111000b = 00111000b
-00111101b & 11111001b = 00111001b
-00111101b & 11111010b = 00111000b
-00111101b & 11111011b = 00111001b
-00111101b & 11111100b = 00111100b
-00111101b & 11111101b = 00111101b
-00111101b & 11111110b = 00111100b
-00111101b & 11111111b = 00111101b
-00111101b & 00000000b = 00000000b
-00111101b & 00000001b = 00000001b
-00111101b & 00000010b = 00000000b
-00111101b & 00000011b = 00000001b
-00111101b & 00000100b = 00000100b
-00111101b & 00000101b = 00000101b
-00111101b & 00000110b = 00000100b
-00111101b & 00000111b = 00000101b
-00111101b & 00001000b = 00001000b
-00111101b & 00001001b = 00001001b
-00111101b & 00001010b = 00001000b
-00111101b & 00001011b = 00001001b
-00111101b & 00001100b = 00001100b
-00111101b & 00001101b = 00001101b
-00111101b & 00001110b = 00001100b
-00111101b & 00001111b = 00001101b
-00111101b & 00010000b = 00010000b
-00111101b & 00010001b = 00010001b
-00111101b & 00010010b = 00010000b
-00111101b & 00010011b = 00010001b
-00111101b & 00010100b = 00010100b
-00111101b & 00010101b = 00010101b
-00111101b & 00010110b = 00010100b
-00111101b & 00010111b = 00010101b
-00111101b & 00011000b = 00011000b
-00111101b & 00011001b = 00011001b
-00111101b & 00011010b = 00011000b
-00111101b & 00011011b = 00011001b
-00111101b & 00011100b = 00011100b
-00111101b & 00011101b = 00011101b
-00111101b & 00011110b = 00011100b
-00111101b & 00011111b = 00011101b
-00111101b & 00100000b = 00100000b
-00111101b & 00100001b = 00100001b
-00111101b & 00100010b = 00100000b
-00111101b & 00100011b = 00100001b
-00111101b & 00100100b = 00100100b
-00111101b & 00100101b = 00100101b
-00111101b & 00100110b = 00100100b
-00111101b & 00100111b = 00100101b
-00111101b & 00101000b = 00101000b
-00111101b & 00101001b = 00101001b
-00111101b & 00101010b = 00101000b
-00111101b & 00101011b = 00101001b
-00111101b & 00101100b = 00101100b
-00111101b & 00101101b = 00101101b
-00111101b & 00101110b = 00101100b
-00111101b & 00101111b = 00101101b
-00111101b & 00110000b = 00110000b
-00111101b & 00110001b = 00110001b
-00111101b & 00110010b = 00110000b
-00111101b & 00110011b = 00110001b
-00111101b & 00110100b = 00110100b
-00111101b & 00110101b = 00110101b
-00111101b & 00110110b = 00110100b
-00111101b & 00110111b = 00110101b
-00111101b & 00111000b = 00111000b
-00111101b & 00111001b = 00111001b
-00111101b & 00111010b = 00111000b
-00111101b & 00111011b = 00111001b
-00111101b & 00111100b = 00111100b
-00111101b & 00111101b = 00111101b
-00111101b & 00111110b = 00111100b
-00111101b & 00111111b = 00111101b
-00111101b & 01000000b = 00000000b
-00111101b & 01000001b = 00000001b
-00111101b & 01000010b = 00000000b
-00111101b & 01000011b = 00000001b
-00111101b & 01000100b = 00000100b
-00111101b & 01000101b = 00000101b
-00111101b & 01000110b = 00000100b
-00111101b & 01000111b = 00000101b
-00111101b & 01001000b = 00001000b
-00111101b & 01001001b = 00001001b
-00111101b & 01001010b = 00001000b
-00111101b & 01001011b = 00001001b
-00111101b & 01001100b = 00001100b
-00111101b & 01001101b = 00001101b
-00111101b & 01001110b = 00001100b
-00111101b & 01001111b = 00001101b
-00111101b & 01010000b = 00010000b
-00111101b & 01010001b = 00010001b
-00111101b & 01010010b = 00010000b
-00111101b & 01010011b = 00010001b
-00111101b & 01010100b = 00010100b
-00111101b & 01010101b = 00010101b
-00111101b & 01010110b = 00010100b
-00111101b & 01010111b = 00010101b
-00111101b & 01011000b = 00011000b
-00111101b & 01011001b = 00011001b
-00111101b & 01011010b = 00011000b
-00111101b & 01011011b = 00011001b
-00111101b & 01011100b = 00011100b
-00111101b & 01011101b = 00011101b
-00111101b & 01011110b = 00011100b
-00111101b & 01011111b = 00011101b
-00111101b & 01100000b = 00100000b
-00111101b & 01100001b = 00100001b
-00111101b & 01100010b = 00100000b
-00111101b & 01100011b = 00100001b
-00111101b & 01100100b = 00100100b
-00111101b & 01100101b = 00100101b
-00111101b & 01100110b = 00100100b
-00111101b & 01100111b = 00100101b
-00111101b & 01101000b = 00101000b
-00111101b & 01101001b = 00101001b
-00111101b & 01101010b = 00101000b
-00111101b & 01101011b = 00101001b
-00111101b & 01101100b = 00101100b
-00111101b & 01101101b = 00101101b
-00111101b & 01101110b = 00101100b
-00111101b & 01101111b = 00101101b
-00111101b & 01110000b = 00110000b
-00111101b & 01110001b = 00110001b
-00111101b & 01110010b = 00110000b
-00111101b & 01110011b = 00110001b
-00111101b & 01110100b = 00110100b
-00111101b & 01110101b = 00110101b
-00111101b & 01110110b = 00110100b
-00111101b & 01110111b = 00110101b
-00111101b & 01111000b = 00111000b
-00111101b & 01111001b = 00111001b
-00111101b & 01111010b = 00111000b
-00111101b & 01111011b = 00111001b
-00111101b & 01111100b = 00111100b
-00111101b & 01111101b = 00111101b
-00111101b & 01111110b = 00111100b
-00111110b & 10000000b = 00000000b
-00111110b & 10000001b = 00000000b
-00111110b & 10000010b = 00000010b
-00111110b & 10000011b = 00000010b
-00111110b & 10000100b = 00000100b
-00111110b & 10000101b = 00000100b
-00111110b & 10000110b = 00000110b
-00111110b & 10000111b = 00000110b
-00111110b & 10001000b = 00001000b
-00111110b & 10001001b = 00001000b
-00111110b & 10001010b = 00001010b
-00111110b & 10001011b = 00001010b
-00111110b & 10001100b = 00001100b
-00111110b & 10001101b = 00001100b
-00111110b & 10001110b = 00001110b
-00111110b & 10001111b = 00001110b
-00111110b & 10010000b = 00010000b
-00111110b & 10010001b = 00010000b
-00111110b & 10010010b = 00010010b
-00111110b & 10010011b = 00010010b
-00111110b & 10010100b = 00010100b
-00111110b & 10010101b = 00010100b
-00111110b & 10010110b = 00010110b
-00111110b & 10010111b = 00010110b
-00111110b & 10011000b = 00011000b
-00111110b & 10011001b = 00011000b
-00111110b & 10011010b = 00011010b
-00111110b & 10011011b = 00011010b
-00111110b & 10011100b = 00011100b
-00111110b & 10011101b = 00011100b
-00111110b & 10011110b = 00011110b
-00111110b & 10011111b = 00011110b
-00111110b & 10100000b = 00100000b
-00111110b & 10100001b = 00100000b
-00111110b & 10100010b = 00100010b
-00111110b & 10100011b = 00100010b
-00111110b & 10100100b = 00100100b
-00111110b & 10100101b = 00100100b
-00111110b & 10100110b = 00100110b
-00111110b & 10100111b = 00100110b
-00111110b & 10101000b = 00101000b
-00111110b & 10101001b = 00101000b
-00111110b & 10101010b = 00101010b
-00111110b & 10101011b = 00101010b
-00111110b & 10101100b = 00101100b
-00111110b & 10101101b = 00101100b
-00111110b & 10101110b = 00101110b
-00111110b & 10101111b = 00101110b
-00111110b & 10110000b = 00110000b
-00111110b & 10110001b = 00110000b
-00111110b & 10110010b = 00110010b
-00111110b & 10110011b = 00110010b
-00111110b & 10110100b = 00110100b
-00111110b & 10110101b = 00110100b
-00111110b & 10110110b = 00110110b
-00111110b & 10110111b = 00110110b
-00111110b & 10111000b = 00111000b
-00111110b & 10111001b = 00111000b
-00111110b & 10111010b = 00111010b
-00111110b & 10111011b = 00111010b
-00111110b & 10111100b = 00111100b
-00111110b & 10111101b = 00111100b
-00111110b & 10111110b = 00111110b
-00111110b & 10111111b = 00111110b
-00111110b & 11000000b = 00000000b
-00111110b & 11000001b = 00000000b
-00111110b & 11000010b = 00000010b
-00111110b & 11000011b = 00000010b
-00111110b & 11000100b = 00000100b
-00111110b & 11000101b = 00000100b
-00111110b & 11000110b = 00000110b
-00111110b & 11000111b = 00000110b
-00111110b & 11001000b = 00001000b
-00111110b & 11001001b = 00001000b
-00111110b & 11001010b = 00001010b
-00111110b & 11001011b = 00001010b
-00111110b & 11001100b = 00001100b
-00111110b & 11001101b = 00001100b
-00111110b & 11001110b = 00001110b
-00111110b & 11001111b = 00001110b
-00111110b & 11010000b = 00010000b
-00111110b & 11010001b = 00010000b
-00111110b & 11010010b = 00010010b
-00111110b & 11010011b = 00010010b
-00111110b & 11010100b = 00010100b
-00111110b & 11010101b = 00010100b
-00111110b & 11010110b = 00010110b
-00111110b & 11010111b = 00010110b
-00111110b & 11011000b = 00011000b
-00111110b & 11011001b = 00011000b
-00111110b & 11011010b = 00011010b
-00111110b & 11011011b = 00011010b
-00111110b & 11011100b = 00011100b
-00111110b & 11011101b = 00011100b
-00111110b & 11011110b = 00011110b
-00111110b & 11011111b = 00011110b
-00111110b & 11100000b = 00100000b
-00111110b & 11100001b = 00100000b
-00111110b & 11100010b = 00100010b
-00111110b & 11100011b = 00100010b
-00111110b & 11100100b = 00100100b
-00111110b & 11100101b = 00100100b
-00111110b & 11100110b = 00100110b
-00111110b & 11100111b = 00100110b
-00111110b & 11101000b = 00101000b
-00111110b & 11101001b = 00101000b
-00111110b & 11101010b = 00101010b
-00111110b & 11101011b = 00101010b
-00111110b & 11101100b = 00101100b
-00111110b & 11101101b = 00101100b
-00111110b & 11101110b = 00101110b
-00111110b & 11101111b = 00101110b
-00111110b & 11110000b = 00110000b
-00111110b & 11110001b = 00110000b
-00111110b & 11110010b = 00110010b
-00111110b & 11110011b = 00110010b
-00111110b & 11110100b = 00110100b
-00111110b & 11110101b = 00110100b
-00111110b & 11110110b = 00110110b
-00111110b & 11110111b = 00110110b
-00111110b & 11111000b = 00111000b
-00111110b & 11111001b = 00111000b
-00111110b & 11111010b = 00111010b
-00111110b & 11111011b = 00111010b
-00111110b & 11111100b = 00111100b
-00111110b & 11111101b = 00111100b
-00111110b & 11111110b = 00111110b
-00111110b & 11111111b = 00111110b
-00111110b & 00000000b = 00000000b
-00111110b & 00000001b = 00000000b
-00111110b & 00000010b = 00000010b
-00111110b & 00000011b = 00000010b
-00111110b & 00000100b = 00000100b
-00111110b & 00000101b = 00000100b
-00111110b & 00000110b = 00000110b
-00111110b & 00000111b = 00000110b
-00111110b & 00001000b = 00001000b
-00111110b & 00001001b = 00001000b
-00111110b & 00001010b = 00001010b
-00111110b & 00001011b = 00001010b
-00111110b & 00001100b = 00001100b
-00111110b & 00001101b = 00001100b
-00111110b & 00001110b = 00001110b
-00111110b & 00001111b = 00001110b
-00111110b & 00010000b = 00010000b
-00111110b & 00010001b = 00010000b
-00111110b & 00010010b = 00010010b
-00111110b & 00010011b = 00010010b
-00111110b & 00010100b = 00010100b
-00111110b & 00010101b = 00010100b
-00111110b & 00010110b = 00010110b
-00111110b & 00010111b = 00010110b
-00111110b & 00011000b = 00011000b
-00111110b & 00011001b = 00011000b
-00111110b & 00011010b = 00011010b
-00111110b & 00011011b = 00011010b
-00111110b & 00011100b = 00011100b
-00111110b & 00011101b = 00011100b
-00111110b & 00011110b = 00011110b
-00111110b & 00011111b = 00011110b
-00111110b & 00100000b = 00100000b
-00111110b & 00100001b = 00100000b
-00111110b & 00100010b = 00100010b
-00111110b & 00100011b = 00100010b
-00111110b & 00100100b = 00100100b
-00111110b & 00100101b = 00100100b
-00111110b & 00100110b = 00100110b
-00111110b & 00100111b = 00100110b
-00111110b & 00101000b = 00101000b
-00111110b & 00101001b = 00101000b
-00111110b & 00101010b = 00101010b
-00111110b & 00101011b = 00101010b
-00111110b & 00101100b = 00101100b
-00111110b & 00101101b = 00101100b
-00111110b & 00101110b = 00101110b
-00111110b & 00101111b = 00101110b
-00111110b & 00110000b = 00110000b
-00111110b & 00110001b = 00110000b
-00111110b & 00110010b = 00110010b
-00111110b & 00110011b = 00110010b
-00111110b & 00110100b = 00110100b
-00111110b & 00110101b = 00110100b
-00111110b & 00110110b = 00110110b
-00111110b & 00110111b = 00110110b
-00111110b & 00111000b = 00111000b
-00111110b & 00111001b = 00111000b
-00111110b & 00111010b = 00111010b
-00111110b & 00111011b = 00111010b
-00111110b & 00111100b = 00111100b
-00111110b & 00111101b = 00111100b
-00111110b & 00111110b = 00111110b
-00111110b & 00111111b = 00111110b
-00111110b & 01000000b = 00000000b
-00111110b & 01000001b = 00000000b
-00111110b & 01000010b = 00000010b
-00111110b & 01000011b = 00000010b
-00111110b & 01000100b = 00000100b
-00111110b & 01000101b = 00000100b
-00111110b & 01000110b = 00000110b
-00111110b & 01000111b = 00000110b
-00111110b & 01001000b = 00001000b
-00111110b & 01001001b = 00001000b
-00111110b & 01001010b = 00001010b
-00111110b & 01001011b = 00001010b
-00111110b & 01001100b = 00001100b
-00111110b & 01001101b = 00001100b
-00111110b & 01001110b = 00001110b
-00111110b & 01001111b = 00001110b
-00111110b & 01010000b = 00010000b
-00111110b & 01010001b = 00010000b
-00111110b & 01010010b = 00010010b
-00111110b & 01010011b = 00010010b
-00111110b & 01010100b = 00010100b
-00111110b & 01010101b = 00010100b
-00111110b & 01010110b = 00010110b
-00111110b & 01010111b = 00010110b
-00111110b & 01011000b = 00011000b
-00111110b & 01011001b = 00011000b
-00111110b & 01011010b = 00011010b
-00111110b & 01011011b = 00011010b
-00111110b & 01011100b = 00011100b
-00111110b & 01011101b = 00011100b
-00111110b & 01011110b = 00011110b
-00111110b & 01011111b = 00011110b
-00111110b & 01100000b = 00100000b
-00111110b & 01100001b = 00100000b
-00111110b & 01100010b = 00100010b
-00111110b & 01100011b = 00100010b
-00111110b & 01100100b = 00100100b
-00111110b & 01100101b = 00100100b
-00111110b & 01100110b = 00100110b
-00111110b & 01100111b = 00100110b
-00111110b & 01101000b = 00101000b
-00111110b & 01101001b = 00101000b
-00111110b & 01101010b = 00101010b
-00111110b & 01101011b = 00101010b
-00111110b & 01101100b = 00101100b
-00111110b & 01101101b = 00101100b
-00111110b & 01101110b = 00101110b
-00111110b & 01101111b = 00101110b
-00111110b & 01110000b = 00110000b
-00111110b & 01110001b = 00110000b
-00111110b & 01110010b = 00110010b
-00111110b & 01110011b = 00110010b
-00111110b & 01110100b = 00110100b
-00111110b & 01110101b = 00110100b
-00111110b & 01110110b = 00110110b
-00111110b & 01110111b = 00110110b
-00111110b & 01111000b = 00111000b
-00111110b & 01111001b = 00111000b
-00111110b & 01111010b = 00111010b
-00111110b & 01111011b = 00111010b
-00111110b & 01111100b = 00111100b
-00111110b & 01111101b = 00111100b
-00111110b & 01111110b = 00111110b
-00111111b & 10000000b = 00000000b
-00111111b & 10000001b = 00000001b
-00111111b & 10000010b = 00000010b
-00111111b & 10000011b = 00000011b
-00111111b & 10000100b = 00000100b
-00111111b & 10000101b = 00000101b
-00111111b & 10000110b = 00000110b
-00111111b & 10000111b = 00000111b
-00111111b & 10001000b = 00001000b
-00111111b & 10001001b = 00001001b
-00111111b & 10001010b = 00001010b
-00111111b & 10001011b = 00001011b
-00111111b & 10001100b = 00001100b
-00111111b & 10001101b = 00001101b
-00111111b & 10001110b = 00001110b
-00111111b & 10001111b = 00001111b
-00111111b & 10010000b = 00010000b
-00111111b & 10010001b = 00010001b
-00111111b & 10010010b = 00010010b
-00111111b & 10010011b = 00010011b
-00111111b & 10010100b = 00010100b
-00111111b & 10010101b = 00010101b
-00111111b & 10010110b = 00010110b
-00111111b & 10010111b = 00010111b
-00111111b & 10011000b = 00011000b
-00111111b & 10011001b = 00011001b
-00111111b & 10011010b = 00011010b
-00111111b & 10011011b = 00011011b
-00111111b & 10011100b = 00011100b
-00111111b & 10011101b = 00011101b
-00111111b & 10011110b = 00011110b
-00111111b & 10011111b = 00011111b
-00111111b & 10100000b = 00100000b
-00111111b & 10100001b = 00100001b
-00111111b & 10100010b = 00100010b
-00111111b & 10100011b = 00100011b
-00111111b & 10100100b = 00100100b
-00111111b & 10100101b = 00100101b
-00111111b & 10100110b = 00100110b
-00111111b & 10100111b = 00100111b
-00111111b & 10101000b = 00101000b
-00111111b & 10101001b = 00101001b
-00111111b & 10101010b = 00101010b
-00111111b & 10101011b = 00101011b
-00111111b & 10101100b = 00101100b
-00111111b & 10101101b = 00101101b
-00111111b & 10101110b = 00101110b
-00111111b & 10101111b = 00101111b
-00111111b & 10110000b = 00110000b
-00111111b & 10110001b = 00110001b
-00111111b & 10110010b = 00110010b
-00111111b & 10110011b = 00110011b
-00111111b & 10110100b = 00110100b
-00111111b & 10110101b = 00110101b
-00111111b & 10110110b = 00110110b
-00111111b & 10110111b = 00110111b
-00111111b & 10111000b = 00111000b
-00111111b & 10111001b = 00111001b
-00111111b & 10111010b = 00111010b
-00111111b & 10111011b = 00111011b
-00111111b & 10111100b = 00111100b
-00111111b & 10111101b = 00111101b
-00111111b & 10111110b = 00111110b
-00111111b & 10111111b = 00111111b
-00111111b & 11000000b = 00000000b
-00111111b & 11000001b = 00000001b
-00111111b & 11000010b = 00000010b
-00111111b & 11000011b = 00000011b
-00111111b & 11000100b = 00000100b
-00111111b & 11000101b = 00000101b
-00111111b & 11000110b = 00000110b
-00111111b & 11000111b = 00000111b
-00111111b & 11001000b = 00001000b
-00111111b & 11001001b = 00001001b
-00111111b & 11001010b = 00001010b
-00111111b & 11001011b = 00001011b
-00111111b & 11001100b = 00001100b
-00111111b & 11001101b = 00001101b
-00111111b & 11001110b = 00001110b
-00111111b & 11001111b = 00001111b
-00111111b & 11010000b = 00010000b
-00111111b & 11010001b = 00010001b
-00111111b & 11010010b = 00010010b
-00111111b & 11010011b = 00010011b
-00111111b & 11010100b = 00010100b
-00111111b & 11010101b = 00010101b
-00111111b & 11010110b = 00010110b
-00111111b & 11010111b = 00010111b
-00111111b & 11011000b = 00011000b
-00111111b & 11011001b = 00011001b
-00111111b & 11011010b = 00011010b
-00111111b & 11011011b = 00011011b
-00111111b & 11011100b = 00011100b
-00111111b & 11011101b = 00011101b
-00111111b & 11011110b = 00011110b
-00111111b & 11011111b = 00011111b
-00111111b & 11100000b = 00100000b
-00111111b & 11100001b = 00100001b
-00111111b & 11100010b = 00100010b
-00111111b & 11100011b = 00100011b
-00111111b & 11100100b = 00100100b
-00111111b & 11100101b = 00100101b
-00111111b & 11100110b = 00100110b
-00111111b & 11100111b = 00100111b
-00111111b & 11101000b = 00101000b
-00111111b & 11101001b = 00101001b
-00111111b & 11101010b = 00101010b
-00111111b & 11101011b = 00101011b
-00111111b & 11101100b = 00101100b
-00111111b & 11101101b = 00101101b
-00111111b & 11101110b = 00101110b
-00111111b & 11101111b = 00101111b
-00111111b & 11110000b = 00110000b
-00111111b & 11110001b = 00110001b
-00111111b & 11110010b = 00110010b
-00111111b & 11110011b = 00110011b
-00111111b & 11110100b = 00110100b
-00111111b & 11110101b = 00110101b
-00111111b & 11110110b = 00110110b
-00111111b & 11110111b = 00110111b
-00111111b & 11111000b = 00111000b
-00111111b & 11111001b = 00111001b
-00111111b & 11111010b = 00111010b
-00111111b & 11111011b = 00111011b
-00111111b & 11111100b = 00111100b
-00111111b & 11111101b = 00111101b
-00111111b & 11111110b = 00111110b
-00111111b & 11111111b = 00111111b
-00111111b & 00000000b = 00000000b
-00111111b & 00000001b = 00000001b
-00111111b & 00000010b = 00000010b
-00111111b & 00000011b = 00000011b
-00111111b & 00000100b = 00000100b
-00111111b & 00000101b = 00000101b
-00111111b & 00000110b = 00000110b
-00111111b & 00000111b = 00000111b
-00111111b & 00001000b = 00001000b
-00111111b & 00001001b = 00001001b
-00111111b & 00001010b = 00001010b
-00111111b & 00001011b = 00001011b
-00111111b & 00001100b = 00001100b
-00111111b & 00001101b = 00001101b
-00111111b & 00001110b = 00001110b
-00111111b & 00001111b = 00001111b
-00111111b & 00010000b = 00010000b
-00111111b & 00010001b = 00010001b
-00111111b & 00010010b = 00010010b
-00111111b & 00010011b = 00010011b
-00111111b & 00010100b = 00010100b
-00111111b & 00010101b = 00010101b
-00111111b & 00010110b = 00010110b
-00111111b & 00010111b = 00010111b
-00111111b & 00011000b = 00011000b
-00111111b & 00011001b = 00011001b
-00111111b & 00011010b = 00011010b
-00111111b & 00011011b = 00011011b
-00111111b & 00011100b = 00011100b
-00111111b & 00011101b = 00011101b
-00111111b & 00011110b = 00011110b
-00111111b & 00011111b = 00011111b
-00111111b & 00100000b = 00100000b
-00111111b & 00100001b = 00100001b
-00111111b & 00100010b = 00100010b
-00111111b & 00100011b = 00100011b
-00111111b & 00100100b = 00100100b
-00111111b & 00100101b = 00100101b
-00111111b & 00100110b = 00100110b
-00111111b & 00100111b = 00100111b
-00111111b & 00101000b = 00101000b
-00111111b & 00101001b = 00101001b
-00111111b & 00101010b = 00101010b
-00111111b & 00101011b = 00101011b
-00111111b & 00101100b = 00101100b
-00111111b & 00101101b = 00101101b
-00111111b & 00101110b = 00101110b
-00111111b & 00101111b = 00101111b
-00111111b & 00110000b = 00110000b
-00111111b & 00110001b = 00110001b
-00111111b & 00110010b = 00110010b
-00111111b & 00110011b = 00110011b
-00111111b & 00110100b = 00110100b
-00111111b & 00110101b = 00110101b
-00111111b & 00110110b = 00110110b
-00111111b & 00110111b = 00110111b
-00111111b & 00111000b = 00111000b
-00111111b & 00111001b = 00111001b
-00111111b & 00111010b = 00111010b
-00111111b & 00111011b = 00111011b
-00111111b & 00111100b = 00111100b
-00111111b & 00111101b = 00111101b
-00111111b & 00111110b = 00111110b
-00111111b & 00111111b = 00111111b
-00111111b & 01000000b = 00000000b
-00111111b & 01000001b = 00000001b
-00111111b & 01000010b = 00000010b
-00111111b & 01000011b = 00000011b
-00111111b & 01000100b = 00000100b
-00111111b & 01000101b = 00000101b
-00111111b & 01000110b = 00000110b
-00111111b & 01000111b = 00000111b
-00111111b & 01001000b = 00001000b
-00111111b & 01001001b = 00001001b
-00111111b & 01001010b = 00001010b
-00111111b & 01001011b = 00001011b
-00111111b & 01001100b = 00001100b
-00111111b & 01001101b = 00001101b
-00111111b & 01001110b = 00001110b
-00111111b & 01001111b = 00001111b
-00111111b & 01010000b = 00010000b
-00111111b & 01010001b = 00010001b
-00111111b & 01010010b = 00010010b
-00111111b & 01010011b = 00010011b
-00111111b & 01010100b = 00010100b
-00111111b & 01010101b = 00010101b
-00111111b & 01010110b = 00010110b
-00111111b & 01010111b = 00010111b
-00111111b & 01011000b = 00011000b
-00111111b & 01011001b = 00011001b
-00111111b & 01011010b = 00011010b
-00111111b & 01011011b = 00011011b
-00111111b & 01011100b = 00011100b
-00111111b & 01011101b = 00011101b
-00111111b & 01011110b = 00011110b
-00111111b & 01011111b = 00011111b
-00111111b & 01100000b = 00100000b
-00111111b & 01100001b = 00100001b
-00111111b & 01100010b = 00100010b
-00111111b & 01100011b = 00100011b
-00111111b & 01100100b = 00100100b
-00111111b & 01100101b = 00100101b
-00111111b & 01100110b = 00100110b
-00111111b & 01100111b = 00100111b
-00111111b & 01101000b = 00101000b
-00111111b & 01101001b = 00101001b
-00111111b & 01101010b = 00101010b
-00111111b & 01101011b = 00101011b
-00111111b & 01101100b = 00101100b
-00111111b & 01101101b = 00101101b
-00111111b & 01101110b = 00101110b
-00111111b & 01101111b = 00101111b
-00111111b & 01110000b = 00110000b
-00111111b & 01110001b = 00110001b
-00111111b & 01110010b = 00110010b
-00111111b & 01110011b = 00110011b
-00111111b & 01110100b = 00110100b
-00111111b & 01110101b = 00110101b
-00111111b & 01110110b = 00110110b
-00111111b & 01110111b = 00110111b
-00111111b & 01111000b = 00111000b
-00111111b & 01111001b = 00111001b
-00111111b & 01111010b = 00111010b
-00111111b & 01111011b = 00111011b
-00111111b & 01111100b = 00111100b
-00111111b & 01111101b = 00111101b
-00111111b & 01111110b = 00111110b
-01000000b & 10000000b = 00000000b
-01000000b & 10000001b = 00000000b
-01000000b & 10000010b = 00000000b
-01000000b & 10000011b = 00000000b
-01000000b & 10000100b = 00000000b
-01000000b & 10000101b = 00000000b
-01000000b & 10000110b = 00000000b
-01000000b & 10000111b = 00000000b
-01000000b & 10001000b = 00000000b
-01000000b & 10001001b = 00000000b
-01000000b & 10001010b = 00000000b
-01000000b & 10001011b = 00000000b
-01000000b & 10001100b = 00000000b
-01000000b & 10001101b = 00000000b
-01000000b & 10001110b = 00000000b
-01000000b & 10001111b = 00000000b
-01000000b & 10010000b = 00000000b
-01000000b & 10010001b = 00000000b
-01000000b & 10010010b = 00000000b
-01000000b & 10010011b = 00000000b
-01000000b & 10010100b = 00000000b
-01000000b & 10010101b = 00000000b
-01000000b & 10010110b = 00000000b
-01000000b & 10010111b = 00000000b
-01000000b & 10011000b = 00000000b
-01000000b & 10011001b = 00000000b
-01000000b & 10011010b = 00000000b
-01000000b & 10011011b = 00000000b
-01000000b & 10011100b = 00000000b
-01000000b & 10011101b = 00000000b
-01000000b & 10011110b = 00000000b
-01000000b & 10011111b = 00000000b
-01000000b & 10100000b = 00000000b
-01000000b & 10100001b = 00000000b
-01000000b & 10100010b = 00000000b
-01000000b & 10100011b = 00000000b
-01000000b & 10100100b = 00000000b
-01000000b & 10100101b = 00000000b
-01000000b & 10100110b = 00000000b
-01000000b & 10100111b = 00000000b
-01000000b & 10101000b = 00000000b
-01000000b & 10101001b = 00000000b
-01000000b & 10101010b = 00000000b
-01000000b & 10101011b = 00000000b
-01000000b & 10101100b = 00000000b
-01000000b & 10101101b = 00000000b
-01000000b & 10101110b = 00000000b
-01000000b & 10101111b = 00000000b
-01000000b & 10110000b = 00000000b
-01000000b & 10110001b = 00000000b
-01000000b & 10110010b = 00000000b
-01000000b & 10110011b = 00000000b
-01000000b & 10110100b = 00000000b
-01000000b & 10110101b = 00000000b
-01000000b & 10110110b = 00000000b
-01000000b & 10110111b = 00000000b
-01000000b & 10111000b = 00000000b
-01000000b & 10111001b = 00000000b
-01000000b & 10111010b = 00000000b
-01000000b & 10111011b = 00000000b
-01000000b & 10111100b = 00000000b
-01000000b & 10111101b = 00000000b
-01000000b & 10111110b = 00000000b
-01000000b & 10111111b = 00000000b
-01000000b & 11000000b = 01000000b
-01000000b & 11000001b = 01000000b
-01000000b & 11000010b = 01000000b
-01000000b & 11000011b = 01000000b
-01000000b & 11000100b = 01000000b
-01000000b & 11000101b = 01000000b
-01000000b & 11000110b = 01000000b
-01000000b & 11000111b = 01000000b
-01000000b & 11001000b = 01000000b
-01000000b & 11001001b = 01000000b
-01000000b & 11001010b = 01000000b
-01000000b & 11001011b = 01000000b
-01000000b & 11001100b = 01000000b
-01000000b & 11001101b = 01000000b
-01000000b & 11001110b = 01000000b
-01000000b & 11001111b = 01000000b
-01000000b & 11010000b = 01000000b
-01000000b & 11010001b = 01000000b
-01000000b & 11010010b = 01000000b
-01000000b & 11010011b = 01000000b
-01000000b & 11010100b = 01000000b
-01000000b & 11010101b = 01000000b
-01000000b & 11010110b = 01000000b
-01000000b & 11010111b = 01000000b
-01000000b & 11011000b = 01000000b
-01000000b & 11011001b = 01000000b
-01000000b & 11011010b = 01000000b
-01000000b & 11011011b = 01000000b
-01000000b & 11011100b = 01000000b
-01000000b & 11011101b = 01000000b
-01000000b & 11011110b = 01000000b
-01000000b & 11011111b = 01000000b
-01000000b & 11100000b = 01000000b
-01000000b & 11100001b = 01000000b
-01000000b & 11100010b = 01000000b
-01000000b & 11100011b = 01000000b
-01000000b & 11100100b = 01000000b
-01000000b & 11100101b = 01000000b
-01000000b & 11100110b = 01000000b
-01000000b & 11100111b = 01000000b
-01000000b & 11101000b = 01000000b
-01000000b & 11101001b = 01000000b
-01000000b & 11101010b = 01000000b
-01000000b & 11101011b = 01000000b
-01000000b & 11101100b = 01000000b
-01000000b & 11101101b = 01000000b
-01000000b & 11101110b = 01000000b
-01000000b & 11101111b = 01000000b
-01000000b & 11110000b = 01000000b
-01000000b & 11110001b = 01000000b
-01000000b & 11110010b = 01000000b
-01000000b & 11110011b = 01000000b
-01000000b & 11110100b = 01000000b
-01000000b & 11110101b = 01000000b
-01000000b & 11110110b = 01000000b
-01000000b & 11110111b = 01000000b
-01000000b & 11111000b = 01000000b
-01000000b & 11111001b = 01000000b
-01000000b & 11111010b = 01000000b
-01000000b & 11111011b = 01000000b
-01000000b & 11111100b = 01000000b
-01000000b & 11111101b = 01000000b
-01000000b & 11111110b = 01000000b
-01000000b & 11111111b = 01000000b
-01000000b & 00000000b = 00000000b
-01000000b & 00000001b = 00000000b
-01000000b & 00000010b = 00000000b
-01000000b & 00000011b = 00000000b
-01000000b & 00000100b = 00000000b
-01000000b & 00000101b = 00000000b
-01000000b & 00000110b = 00000000b
-01000000b & 00000111b = 00000000b
-01000000b & 00001000b = 00000000b
-01000000b & 00001001b = 00000000b
-01000000b & 00001010b = 00000000b
-01000000b & 00001011b = 00000000b
-01000000b & 00001100b = 00000000b
-01000000b & 00001101b = 00000000b
-01000000b & 00001110b = 00000000b
-01000000b & 00001111b = 00000000b
-01000000b & 00010000b = 00000000b
-01000000b & 00010001b = 00000000b
-01000000b & 00010010b = 00000000b
-01000000b & 00010011b = 00000000b
-01000000b & 00010100b = 00000000b
-01000000b & 00010101b = 00000000b
-01000000b & 00010110b = 00000000b
-01000000b & 00010111b = 00000000b
-01000000b & 00011000b = 00000000b
-01000000b & 00011001b = 00000000b
-01000000b & 00011010b = 00000000b
-01000000b & 00011011b = 00000000b
-01000000b & 00011100b = 00000000b
-01000000b & 00011101b = 00000000b
-01000000b & 00011110b = 00000000b
-01000000b & 00011111b = 00000000b
-01000000b & 00100000b = 00000000b
-01000000b & 00100001b = 00000000b
-01000000b & 00100010b = 00000000b
-01000000b & 00100011b = 00000000b
-01000000b & 00100100b = 00000000b
-01000000b & 00100101b = 00000000b
-01000000b & 00100110b = 00000000b
-01000000b & 00100111b = 00000000b
-01000000b & 00101000b = 00000000b
-01000000b & 00101001b = 00000000b
-01000000b & 00101010b = 00000000b
-01000000b & 00101011b = 00000000b
-01000000b & 00101100b = 00000000b
-01000000b & 00101101b = 00000000b
-01000000b & 00101110b = 00000000b
-01000000b & 00101111b = 00000000b
-01000000b & 00110000b = 00000000b
-01000000b & 00110001b = 00000000b
-01000000b & 00110010b = 00000000b
-01000000b & 00110011b = 00000000b
-01000000b & 00110100b = 00000000b
-01000000b & 00110101b = 00000000b
-01000000b & 00110110b = 00000000b
-01000000b & 00110111b = 00000000b
-01000000b & 00111000b = 00000000b
-01000000b & 00111001b = 00000000b
-01000000b & 00111010b = 00000000b
-01000000b & 00111011b = 00000000b
-01000000b & 00111100b = 00000000b
-01000000b & 00111101b = 00000000b
-01000000b & 00111110b = 00000000b
-01000000b & 00111111b = 00000000b
-01000000b & 01000000b = 01000000b
-01000000b & 01000001b = 01000000b
-01000000b & 01000010b = 01000000b
-01000000b & 01000011b = 01000000b
-01000000b & 01000100b = 01000000b
-01000000b & 01000101b = 01000000b
-01000000b & 01000110b = 01000000b
-01000000b & 01000111b = 01000000b
-01000000b & 01001000b = 01000000b
-01000000b & 01001001b = 01000000b
-01000000b & 01001010b = 01000000b
-01000000b & 01001011b = 01000000b
-01000000b & 01001100b = 01000000b
-01000000b & 01001101b = 01000000b
-01000000b & 01001110b = 01000000b
-01000000b & 01001111b = 01000000b
-01000000b & 01010000b = 01000000b
-01000000b & 01010001b = 01000000b
-01000000b & 01010010b = 01000000b
-01000000b & 01010011b = 01000000b
-01000000b & 01010100b = 01000000b
-01000000b & 01010101b = 01000000b
-01000000b & 01010110b = 01000000b
-01000000b & 01010111b = 01000000b
-01000000b & 01011000b = 01000000b
-01000000b & 01011001b = 01000000b
-01000000b & 01011010b = 01000000b
-01000000b & 01011011b = 01000000b
-01000000b & 01011100b = 01000000b
-01000000b & 01011101b = 01000000b
-01000000b & 01011110b = 01000000b
-01000000b & 01011111b = 01000000b
-01000000b & 01100000b = 01000000b
-01000000b & 01100001b = 01000000b
-01000000b & 01100010b = 01000000b
-01000000b & 01100011b = 01000000b
-01000000b & 01100100b = 01000000b
-01000000b & 01100101b = 01000000b
-01000000b & 01100110b = 01000000b
-01000000b & 01100111b = 01000000b
-01000000b & 01101000b = 01000000b
-01000000b & 01101001b = 01000000b
-01000000b & 01101010b = 01000000b
-01000000b & 01101011b = 01000000b
-01000000b & 01101100b = 01000000b
-01000000b & 01101101b = 01000000b
-01000000b & 01101110b = 01000000b
-01000000b & 01101111b = 01000000b
-01000000b & 01110000b = 01000000b
-01000000b & 01110001b = 01000000b
-01000000b & 01110010b = 01000000b
-01000000b & 01110011b = 01000000b
-01000000b & 01110100b = 01000000b
-01000000b & 01110101b = 01000000b
-01000000b & 01110110b = 01000000b
-01000000b & 01110111b = 01000000b
-01000000b & 01111000b = 01000000b
-01000000b & 01111001b = 01000000b
-01000000b & 01111010b = 01000000b
-01000000b & 01111011b = 01000000b
-01000000b & 01111100b = 01000000b
-01000000b & 01111101b = 01000000b
-01000000b & 01111110b = 01000000b
-01000001b & 10000000b = 00000000b
-01000001b & 10000001b = 00000001b
-01000001b & 10000010b = 00000000b
-01000001b & 10000011b = 00000001b
-01000001b & 10000100b = 00000000b
-01000001b & 10000101b = 00000001b
-01000001b & 10000110b = 00000000b
-01000001b & 10000111b = 00000001b
-01000001b & 10001000b = 00000000b
-01000001b & 10001001b = 00000001b
-01000001b & 10001010b = 00000000b
-01000001b & 10001011b = 00000001b
-01000001b & 10001100b = 00000000b
-01000001b & 10001101b = 00000001b
-01000001b & 10001110b = 00000000b
-01000001b & 10001111b = 00000001b
-01000001b & 10010000b = 00000000b
-01000001b & 10010001b = 00000001b
-01000001b & 10010010b = 00000000b
-01000001b & 10010011b = 00000001b
-01000001b & 10010100b = 00000000b
-01000001b & 10010101b = 00000001b
-01000001b & 10010110b = 00000000b
-01000001b & 10010111b = 00000001b
-01000001b & 10011000b = 00000000b
-01000001b & 10011001b = 00000001b
-01000001b & 10011010b = 00000000b
-01000001b & 10011011b = 00000001b
-01000001b & 10011100b = 00000000b
-01000001b & 10011101b = 00000001b
-01000001b & 10011110b = 00000000b
-01000001b & 10011111b = 00000001b
-01000001b & 10100000b = 00000000b
-01000001b & 10100001b = 00000001b
-01000001b & 10100010b = 00000000b
-01000001b & 10100011b = 00000001b
-01000001b & 10100100b = 00000000b
-01000001b & 10100101b = 00000001b
-01000001b & 10100110b = 00000000b
-01000001b & 10100111b = 00000001b
-01000001b & 10101000b = 00000000b
-01000001b & 10101001b = 00000001b
-01000001b & 10101010b = 00000000b
-01000001b & 10101011b = 00000001b
-01000001b & 10101100b = 00000000b
-01000001b & 10101101b = 00000001b
-01000001b & 10101110b = 00000000b
-01000001b & 10101111b = 00000001b
-01000001b & 10110000b = 00000000b
-01000001b & 10110001b = 00000001b
-01000001b & 10110010b = 00000000b
-01000001b & 10110011b = 00000001b
-01000001b & 10110100b = 00000000b
-01000001b & 10110101b = 00000001b
-01000001b & 10110110b = 00000000b
-01000001b & 10110111b = 00000001b
-01000001b & 10111000b = 00000000b
-01000001b & 10111001b = 00000001b
-01000001b & 10111010b = 00000000b
-01000001b & 10111011b = 00000001b
-01000001b & 10111100b = 00000000b
-01000001b & 10111101b = 00000001b
-01000001b & 10111110b = 00000000b
-01000001b & 10111111b = 00000001b
-01000001b & 11000000b = 01000000b
-01000001b & 11000001b = 01000001b
-01000001b & 11000010b = 01000000b
-01000001b & 11000011b = 01000001b
-01000001b & 11000100b = 01000000b
-01000001b & 11000101b = 01000001b
-01000001b & 11000110b = 01000000b
-01000001b & 11000111b = 01000001b
-01000001b & 11001000b = 01000000b
-01000001b & 11001001b = 01000001b
-01000001b & 11001010b = 01000000b
-01000001b & 11001011b = 01000001b
-01000001b & 11001100b = 01000000b
-01000001b & 11001101b = 01000001b
-01000001b & 11001110b = 01000000b
-01000001b & 11001111b = 01000001b
-01000001b & 11010000b = 01000000b
-01000001b & 11010001b = 01000001b
-01000001b & 11010010b = 01000000b
-01000001b & 11010011b = 01000001b
-01000001b & 11010100b = 01000000b
-01000001b & 11010101b = 01000001b
-01000001b & 11010110b = 01000000b
-01000001b & 11010111b = 01000001b
-01000001b & 11011000b = 01000000b
-01000001b & 11011001b = 01000001b
-01000001b & 11011010b = 01000000b
-01000001b & 11011011b = 01000001b
-01000001b & 11011100b = 01000000b
-01000001b & 11011101b = 01000001b
-01000001b & 11011110b = 01000000b
-01000001b & 11011111b = 01000001b
-01000001b & 11100000b = 01000000b
-01000001b & 11100001b = 01000001b
-01000001b & 11100010b = 01000000b
-01000001b & 11100011b = 01000001b
-01000001b & 11100100b = 01000000b
-01000001b & 11100101b = 01000001b
-01000001b & 11100110b = 01000000b
-01000001b & 11100111b = 01000001b
-01000001b & 11101000b = 01000000b
-01000001b & 11101001b = 01000001b
-01000001b & 11101010b = 01000000b
-01000001b & 11101011b = 01000001b
-01000001b & 11101100b = 01000000b
-01000001b & 11101101b = 01000001b
-01000001b & 11101110b = 01000000b
-01000001b & 11101111b = 01000001b
-01000001b & 11110000b = 01000000b
-01000001b & 11110001b = 01000001b
-01000001b & 11110010b = 01000000b
-01000001b & 11110011b = 01000001b
-01000001b & 11110100b = 01000000b
-01000001b & 11110101b = 01000001b
-01000001b & 11110110b = 01000000b
-01000001b & 11110111b = 01000001b
-01000001b & 11111000b = 01000000b
-01000001b & 11111001b = 01000001b
-01000001b & 11111010b = 01000000b
-01000001b & 11111011b = 01000001b
-01000001b & 11111100b = 01000000b
-01000001b & 11111101b = 01000001b
-01000001b & 11111110b = 01000000b
-01000001b & 11111111b = 01000001b
-01000001b & 00000000b = 00000000b
-01000001b & 00000001b = 00000001b
-01000001b & 00000010b = 00000000b
-01000001b & 00000011b = 00000001b
-01000001b & 00000100b = 00000000b
-01000001b & 00000101b = 00000001b
-01000001b & 00000110b = 00000000b
-01000001b & 00000111b = 00000001b
-01000001b & 00001000b = 00000000b
-01000001b & 00001001b = 00000001b
-01000001b & 00001010b = 00000000b
-01000001b & 00001011b = 00000001b
-01000001b & 00001100b = 00000000b
-01000001b & 00001101b = 00000001b
-01000001b & 00001110b = 00000000b
-01000001b & 00001111b = 00000001b
-01000001b & 00010000b = 00000000b
-01000001b & 00010001b = 00000001b
-01000001b & 00010010b = 00000000b
-01000001b & 00010011b = 00000001b
-01000001b & 00010100b = 00000000b
-01000001b & 00010101b = 00000001b
-01000001b & 00010110b = 00000000b
-01000001b & 00010111b = 00000001b
-01000001b & 00011000b = 00000000b
-01000001b & 00011001b = 00000001b
-01000001b & 00011010b = 00000000b
-01000001b & 00011011b = 00000001b
-01000001b & 00011100b = 00000000b
-01000001b & 00011101b = 00000001b
-01000001b & 00011110b = 00000000b
-01000001b & 00011111b = 00000001b
-01000001b & 00100000b = 00000000b
-01000001b & 00100001b = 00000001b
-01000001b & 00100010b = 00000000b
-01000001b & 00100011b = 00000001b
-01000001b & 00100100b = 00000000b
-01000001b & 00100101b = 00000001b
-01000001b & 00100110b = 00000000b
-01000001b & 00100111b = 00000001b
-01000001b & 00101000b = 00000000b
-01000001b & 00101001b = 00000001b
-01000001b & 00101010b = 00000000b
-01000001b & 00101011b = 00000001b
-01000001b & 00101100b = 00000000b
-01000001b & 00101101b = 00000001b
-01000001b & 00101110b = 00000000b
-01000001b & 00101111b = 00000001b
-01000001b & 00110000b = 00000000b
-01000001b & 00110001b = 00000001b
-01000001b & 00110010b = 00000000b
-01000001b & 00110011b = 00000001b
-01000001b & 00110100b = 00000000b
-01000001b & 00110101b = 00000001b
-01000001b & 00110110b = 00000000b
-01000001b & 00110111b = 00000001b
-01000001b & 00111000b = 00000000b
-01000001b & 00111001b = 00000001b
-01000001b & 00111010b = 00000000b
-01000001b & 00111011b = 00000001b
-01000001b & 00111100b = 00000000b
-01000001b & 00111101b = 00000001b
-01000001b & 00111110b = 00000000b
-01000001b & 00111111b = 00000001b
-01000001b & 01000000b = 01000000b
-01000001b & 01000001b = 01000001b
-01000001b & 01000010b = 01000000b
-01000001b & 01000011b = 01000001b
-01000001b & 01000100b = 01000000b
-01000001b & 01000101b = 01000001b
-01000001b & 01000110b = 01000000b
-01000001b & 01000111b = 01000001b
-01000001b & 01001000b = 01000000b
-01000001b & 01001001b = 01000001b
-01000001b & 01001010b = 01000000b
-01000001b & 01001011b = 01000001b
-01000001b & 01001100b = 01000000b
-01000001b & 01001101b = 01000001b
-01000001b & 01001110b = 01000000b
-01000001b & 01001111b = 01000001b
-01000001b & 01010000b = 01000000b
-01000001b & 01010001b = 01000001b
-01000001b & 01010010b = 01000000b
-01000001b & 01010011b = 01000001b
-01000001b & 01010100b = 01000000b
-01000001b & 01010101b = 01000001b
-01000001b & 01010110b = 01000000b
-01000001b & 01010111b = 01000001b
-01000001b & 01011000b = 01000000b
-01000001b & 01011001b = 01000001b
-01000001b & 01011010b = 01000000b
-01000001b & 01011011b = 01000001b
-01000001b & 01011100b = 01000000b
-01000001b & 01011101b = 01000001b
-01000001b & 01011110b = 01000000b
-01000001b & 01011111b = 01000001b
-01000001b & 01100000b = 01000000b
-01000001b & 01100001b = 01000001b
-01000001b & 01100010b = 01000000b
-01000001b & 01100011b = 01000001b
-01000001b & 01100100b = 01000000b
-01000001b & 01100101b = 01000001b
-01000001b & 01100110b = 01000000b
-01000001b & 01100111b = 01000001b
-01000001b & 01101000b = 01000000b
-01000001b & 01101001b = 01000001b
-01000001b & 01101010b = 01000000b
-01000001b & 01101011b = 01000001b
-01000001b & 01101100b = 01000000b
-01000001b & 01101101b = 01000001b
-01000001b & 01101110b = 01000000b
-01000001b & 01101111b = 01000001b
-01000001b & 01110000b = 01000000b
-01000001b & 01110001b = 01000001b
-01000001b & 01110010b = 01000000b
-01000001b & 01110011b = 01000001b
-01000001b & 01110100b = 01000000b
-01000001b & 01110101b = 01000001b
-01000001b & 01110110b = 01000000b
-01000001b & 01110111b = 01000001b
-01000001b & 01111000b = 01000000b
-01000001b & 01111001b = 01000001b
-01000001b & 01111010b = 01000000b
-01000001b & 01111011b = 01000001b
-01000001b & 01111100b = 01000000b
-01000001b & 01111101b = 01000001b
-01000001b & 01111110b = 01000000b
-01000010b & 10000000b = 00000000b
-01000010b & 10000001b = 00000000b
-01000010b & 10000010b = 00000010b
-01000010b & 10000011b = 00000010b
-01000010b & 10000100b = 00000000b
-01000010b & 10000101b = 00000000b
-01000010b & 10000110b = 00000010b
-01000010b & 10000111b = 00000010b
-01000010b & 10001000b = 00000000b
-01000010b & 10001001b = 00000000b
-01000010b & 10001010b = 00000010b
-01000010b & 10001011b = 00000010b
-01000010b & 10001100b = 00000000b
-01000010b & 10001101b = 00000000b
-01000010b & 10001110b = 00000010b
-01000010b & 10001111b = 00000010b
-01000010b & 10010000b = 00000000b
-01000010b & 10010001b = 00000000b
-01000010b & 10010010b = 00000010b
-01000010b & 10010011b = 00000010b
-01000010b & 10010100b = 00000000b
-01000010b & 10010101b = 00000000b
-01000010b & 10010110b = 00000010b
-01000010b & 10010111b = 00000010b
-01000010b & 10011000b = 00000000b
-01000010b & 10011001b = 00000000b
-01000010b & 10011010b = 00000010b
-01000010b & 10011011b = 00000010b
-01000010b & 10011100b = 00000000b
-01000010b & 10011101b = 00000000b
-01000010b & 10011110b = 00000010b
-01000010b & 10011111b = 00000010b
-01000010b & 10100000b = 00000000b
-01000010b & 10100001b = 00000000b
-01000010b & 10100010b = 00000010b
-01000010b & 10100011b = 00000010b
-01000010b & 10100100b = 00000000b
-01000010b & 10100101b = 00000000b
-01000010b & 10100110b = 00000010b
-01000010b & 10100111b = 00000010b
-01000010b & 10101000b = 00000000b
-01000010b & 10101001b = 00000000b
-01000010b & 10101010b = 00000010b
-01000010b & 10101011b = 00000010b
-01000010b & 10101100b = 00000000b
-01000010b & 10101101b = 00000000b
-01000010b & 10101110b = 00000010b
-01000010b & 10101111b = 00000010b
-01000010b & 10110000b = 00000000b
-01000010b & 10110001b = 00000000b
-01000010b & 10110010b = 00000010b
-01000010b & 10110011b = 00000010b
-01000010b & 10110100b = 00000000b
-01000010b & 10110101b = 00000000b
-01000010b & 10110110b = 00000010b
-01000010b & 10110111b = 00000010b
-01000010b & 10111000b = 00000000b
-01000010b & 10111001b = 00000000b
-01000010b & 10111010b = 00000010b
-01000010b & 10111011b = 00000010b
-01000010b & 10111100b = 00000000b
-01000010b & 10111101b = 00000000b
-01000010b & 10111110b = 00000010b
-01000010b & 10111111b = 00000010b
-01000010b & 11000000b = 01000000b
-01000010b & 11000001b = 01000000b
-01000010b & 11000010b = 01000010b
-01000010b & 11000011b = 01000010b
-01000010b & 11000100b = 01000000b
-01000010b & 11000101b = 01000000b
-01000010b & 11000110b = 01000010b
-01000010b & 11000111b = 01000010b
-01000010b & 11001000b = 01000000b
-01000010b & 11001001b = 01000000b
-01000010b & 11001010b = 01000010b
-01000010b & 11001011b = 01000010b
-01000010b & 11001100b = 01000000b
-01000010b & 11001101b = 01000000b
-01000010b & 11001110b = 01000010b
-01000010b & 11001111b = 01000010b
-01000010b & 11010000b = 01000000b
-01000010b & 11010001b = 01000000b
-01000010b & 11010010b = 01000010b
-01000010b & 11010011b = 01000010b
-01000010b & 11010100b = 01000000b
-01000010b & 11010101b = 01000000b
-01000010b & 11010110b = 01000010b
-01000010b & 11010111b = 01000010b
-01000010b & 11011000b = 01000000b
-01000010b & 11011001b = 01000000b
-01000010b & 11011010b = 01000010b
-01000010b & 11011011b = 01000010b
-01000010b & 11011100b = 01000000b
-01000010b & 11011101b = 01000000b
-01000010b & 11011110b = 01000010b
-01000010b & 11011111b = 01000010b
-01000010b & 11100000b = 01000000b
-01000010b & 11100001b = 01000000b
-01000010b & 11100010b = 01000010b
-01000010b & 11100011b = 01000010b
-01000010b & 11100100b = 01000000b
-01000010b & 11100101b = 01000000b
-01000010b & 11100110b = 01000010b
-01000010b & 11100111b = 01000010b
-01000010b & 11101000b = 01000000b
-01000010b & 11101001b = 01000000b
-01000010b & 11101010b = 01000010b
-01000010b & 11101011b = 01000010b
-01000010b & 11101100b = 01000000b
-01000010b & 11101101b = 01000000b
-01000010b & 11101110b = 01000010b
-01000010b & 11101111b = 01000010b
-01000010b & 11110000b = 01000000b
-01000010b & 11110001b = 01000000b
-01000010b & 11110010b = 01000010b
-01000010b & 11110011b = 01000010b
-01000010b & 11110100b = 01000000b
-01000010b & 11110101b = 01000000b
-01000010b & 11110110b = 01000010b
-01000010b & 11110111b = 01000010b
-01000010b & 11111000b = 01000000b
-01000010b & 11111001b = 01000000b
-01000010b & 11111010b = 01000010b
-01000010b & 11111011b = 01000010b
-01000010b & 11111100b = 01000000b
-01000010b & 11111101b = 01000000b
-01000010b & 11111110b = 01000010b
-01000010b & 11111111b = 01000010b
-01000010b & 00000000b = 00000000b
-01000010b & 00000001b = 00000000b
-01000010b & 00000010b = 00000010b
-01000010b & 00000011b = 00000010b
-01000010b & 00000100b = 00000000b
-01000010b & 00000101b = 00000000b
-01000010b & 00000110b = 00000010b
-01000010b & 00000111b = 00000010b
-01000010b & 00001000b = 00000000b
-01000010b & 00001001b = 00000000b
-01000010b & 00001010b = 00000010b
-01000010b & 00001011b = 00000010b
-01000010b & 00001100b = 00000000b
-01000010b & 00001101b = 00000000b
-01000010b & 00001110b = 00000010b
-01000010b & 00001111b = 00000010b
-01000010b & 00010000b = 00000000b
-01000010b & 00010001b = 00000000b
-01000010b & 00010010b = 00000010b
-01000010b & 00010011b = 00000010b
-01000010b & 00010100b = 00000000b
-01000010b & 00010101b = 00000000b
-01000010b & 00010110b = 00000010b
-01000010b & 00010111b = 00000010b
-01000010b & 00011000b = 00000000b
-01000010b & 00011001b = 00000000b
-01000010b & 00011010b = 00000010b
-01000010b & 00011011b = 00000010b
-01000010b & 00011100b = 00000000b
-01000010b & 00011101b = 00000000b
-01000010b & 00011110b = 00000010b
-01000010b & 00011111b = 00000010b
-01000010b & 00100000b = 00000000b
-01000010b & 00100001b = 00000000b
-01000010b & 00100010b = 00000010b
-01000010b & 00100011b = 00000010b
-01000010b & 00100100b = 00000000b
-01000010b & 00100101b = 00000000b
-01000010b & 00100110b = 00000010b
-01000010b & 00100111b = 00000010b
-01000010b & 00101000b = 00000000b
-01000010b & 00101001b = 00000000b
-01000010b & 00101010b = 00000010b
-01000010b & 00101011b = 00000010b
-01000010b & 00101100b = 00000000b
-01000010b & 00101101b = 00000000b
-01000010b & 00101110b = 00000010b
-01000010b & 00101111b = 00000010b
-01000010b & 00110000b = 00000000b
-01000010b & 00110001b = 00000000b
-01000010b & 00110010b = 00000010b
-01000010b & 00110011b = 00000010b
-01000010b & 00110100b = 00000000b
-01000010b & 00110101b = 00000000b
-01000010b & 00110110b = 00000010b
-01000010b & 00110111b = 00000010b
-01000010b & 00111000b = 00000000b
-01000010b & 00111001b = 00000000b
-01000010b & 00111010b = 00000010b
-01000010b & 00111011b = 00000010b
-01000010b & 00111100b = 00000000b
-01000010b & 00111101b = 00000000b
-01000010b & 00111110b = 00000010b
-01000010b & 00111111b = 00000010b
-01000010b & 01000000b = 01000000b
-01000010b & 01000001b = 01000000b
-01000010b & 01000010b = 01000010b
-01000010b & 01000011b = 01000010b
-01000010b & 01000100b = 01000000b
-01000010b & 01000101b = 01000000b
-01000010b & 01000110b = 01000010b
-01000010b & 01000111b = 01000010b
-01000010b & 01001000b = 01000000b
-01000010b & 01001001b = 01000000b
-01000010b & 01001010b = 01000010b
-01000010b & 01001011b = 01000010b
-01000010b & 01001100b = 01000000b
-01000010b & 01001101b = 01000000b
-01000010b & 01001110b = 01000010b
-01000010b & 01001111b = 01000010b
-01000010b & 01010000b = 01000000b
-01000010b & 01010001b = 01000000b
-01000010b & 01010010b = 01000010b
-01000010b & 01010011b = 01000010b
-01000010b & 01010100b = 01000000b
-01000010b & 01010101b = 01000000b
-01000010b & 01010110b = 01000010b
-01000010b & 01010111b = 01000010b
-01000010b & 01011000b = 01000000b
-01000010b & 01011001b = 01000000b
-01000010b & 01011010b = 01000010b
-01000010b & 01011011b = 01000010b
-01000010b & 01011100b = 01000000b
-01000010b & 01011101b = 01000000b
-01000010b & 01011110b = 01000010b
-01000010b & 01011111b = 01000010b
-01000010b & 01100000b = 01000000b
-01000010b & 01100001b = 01000000b
-01000010b & 01100010b = 01000010b
-01000010b & 01100011b = 01000010b
-01000010b & 01100100b = 01000000b
-01000010b & 01100101b = 01000000b
-01000010b & 01100110b = 01000010b
-01000010b & 01100111b = 01000010b
-01000010b & 01101000b = 01000000b
-01000010b & 01101001b = 01000000b
-01000010b & 01101010b = 01000010b
-01000010b & 01101011b = 01000010b
-01000010b & 01101100b = 01000000b
-01000010b & 01101101b = 01000000b
-01000010b & 01101110b = 01000010b
-01000010b & 01101111b = 01000010b
-01000010b & 01110000b = 01000000b
-01000010b & 01110001b = 01000000b
-01000010b & 01110010b = 01000010b
-01000010b & 01110011b = 01000010b
-01000010b & 01110100b = 01000000b
-01000010b & 01110101b = 01000000b
-01000010b & 01110110b = 01000010b
-01000010b & 01110111b = 01000010b
-01000010b & 01111000b = 01000000b
-01000010b & 01111001b = 01000000b
-01000010b & 01111010b = 01000010b
-01000010b & 01111011b = 01000010b
-01000010b & 01111100b = 01000000b
-01000010b & 01111101b = 01000000b
-01000010b & 01111110b = 01000010b
-01000011b & 10000000b = 00000000b
-01000011b & 10000001b = 00000001b
-01000011b & 10000010b = 00000010b
-01000011b & 10000011b = 00000011b
-01000011b & 10000100b = 00000000b
-01000011b & 10000101b = 00000001b
-01000011b & 10000110b = 00000010b
-01000011b & 10000111b = 00000011b
-01000011b & 10001000b = 00000000b
-01000011b & 10001001b = 00000001b
-01000011b & 10001010b = 00000010b
-01000011b & 10001011b = 00000011b
-01000011b & 10001100b = 00000000b
-01000011b & 10001101b = 00000001b
-01000011b & 10001110b = 00000010b
-01000011b & 10001111b = 00000011b
-01000011b & 10010000b = 00000000b
-01000011b & 10010001b = 00000001b
-01000011b & 10010010b = 00000010b
-01000011b & 10010011b = 00000011b
-01000011b & 10010100b = 00000000b
-01000011b & 10010101b = 00000001b
-01000011b & 10010110b = 00000010b
-01000011b & 10010111b = 00000011b
-01000011b & 10011000b = 00000000b
-01000011b & 10011001b = 00000001b
-01000011b & 10011010b = 00000010b
-01000011b & 10011011b = 00000011b
-01000011b & 10011100b = 00000000b
-01000011b & 10011101b = 00000001b
-01000011b & 10011110b = 00000010b
-01000011b & 10011111b = 00000011b
-01000011b & 10100000b = 00000000b
-01000011b & 10100001b = 00000001b
-01000011b & 10100010b = 00000010b
-01000011b & 10100011b = 00000011b
-01000011b & 10100100b = 00000000b
-01000011b & 10100101b = 00000001b
-01000011b & 10100110b = 00000010b
-01000011b & 10100111b = 00000011b
-01000011b & 10101000b = 00000000b
-01000011b & 10101001b = 00000001b
-01000011b & 10101010b = 00000010b
-01000011b & 10101011b = 00000011b
-01000011b & 10101100b = 00000000b
-01000011b & 10101101b = 00000001b
-01000011b & 10101110b = 00000010b
-01000011b & 10101111b = 00000011b
-01000011b & 10110000b = 00000000b
-01000011b & 10110001b = 00000001b
-01000011b & 10110010b = 00000010b
-01000011b & 10110011b = 00000011b
-01000011b & 10110100b = 00000000b
-01000011b & 10110101b = 00000001b
-01000011b & 10110110b = 00000010b
-01000011b & 10110111b = 00000011b
-01000011b & 10111000b = 00000000b
-01000011b & 10111001b = 00000001b
-01000011b & 10111010b = 00000010b
-01000011b & 10111011b = 00000011b
-01000011b & 10111100b = 00000000b
-01000011b & 10111101b = 00000001b
-01000011b & 10111110b = 00000010b
-01000011b & 10111111b = 00000011b
-01000011b & 11000000b = 01000000b
-01000011b & 11000001b = 01000001b
-01000011b & 11000010b = 01000010b
-01000011b & 11000011b = 01000011b
-01000011b & 11000100b = 01000000b
-01000011b & 11000101b = 01000001b
-01000011b & 11000110b = 01000010b
-01000011b & 11000111b = 01000011b
-01000011b & 11001000b = 01000000b
-01000011b & 11001001b = 01000001b
-01000011b & 11001010b = 01000010b
-01000011b & 11001011b = 01000011b
-01000011b & 11001100b = 01000000b
-01000011b & 11001101b = 01000001b
-01000011b & 11001110b = 01000010b
-01000011b & 11001111b = 01000011b
-01000011b & 11010000b = 01000000b
-01000011b & 11010001b = 01000001b
-01000011b & 11010010b = 01000010b
-01000011b & 11010011b = 01000011b
-01000011b & 11010100b = 01000000b
-01000011b & 11010101b = 01000001b
-01000011b & 11010110b = 01000010b
-01000011b & 11010111b = 01000011b
-01000011b & 11011000b = 01000000b
-01000011b & 11011001b = 01000001b
-01000011b & 11011010b = 01000010b
-01000011b & 11011011b = 01000011b
-01000011b & 11011100b = 01000000b
-01000011b & 11011101b = 01000001b
-01000011b & 11011110b = 01000010b
-01000011b & 11011111b = 01000011b
-01000011b & 11100000b = 01000000b
-01000011b & 11100001b = 01000001b
-01000011b & 11100010b = 01000010b
-01000011b & 11100011b = 01000011b
-01000011b & 11100100b = 01000000b
-01000011b & 11100101b = 01000001b
-01000011b & 11100110b = 01000010b
-01000011b & 11100111b = 01000011b
-01000011b & 11101000b = 01000000b
-01000011b & 11101001b = 01000001b
-01000011b & 11101010b = 01000010b
-01000011b & 11101011b = 01000011b
-01000011b & 11101100b = 01000000b
-01000011b & 11101101b = 01000001b
-01000011b & 11101110b = 01000010b
-01000011b & 11101111b = 01000011b
-01000011b & 11110000b = 01000000b
-01000011b & 11110001b = 01000001b
-01000011b & 11110010b = 01000010b
-01000011b & 11110011b = 01000011b
-01000011b & 11110100b = 01000000b
-01000011b & 11110101b = 01000001b
-01000011b & 11110110b = 01000010b
-01000011b & 11110111b = 01000011b
-01000011b & 11111000b = 01000000b
-01000011b & 11111001b = 01000001b
-01000011b & 11111010b = 01000010b
-01000011b & 11111011b = 01000011b
-01000011b & 11111100b = 01000000b
-01000011b & 11111101b = 01000001b
-01000011b & 11111110b = 01000010b
-01000011b & 11111111b = 01000011b
-01000011b & 00000000b = 00000000b
-01000011b & 00000001b = 00000001b
-01000011b & 00000010b = 00000010b
-01000011b & 00000011b = 00000011b
-01000011b & 00000100b = 00000000b
-01000011b & 00000101b = 00000001b
-01000011b & 00000110b = 00000010b
-01000011b & 00000111b = 00000011b
-01000011b & 00001000b = 00000000b
-01000011b & 00001001b = 00000001b
-01000011b & 00001010b = 00000010b
-01000011b & 00001011b = 00000011b
-01000011b & 00001100b = 00000000b
-01000011b & 00001101b = 00000001b
-01000011b & 00001110b = 00000010b
-01000011b & 00001111b = 00000011b
-01000011b & 00010000b = 00000000b
-01000011b & 00010001b = 00000001b
-01000011b & 00010010b = 00000010b
-01000011b & 00010011b = 00000011b
-01000011b & 00010100b = 00000000b
-01000011b & 00010101b = 00000001b
-01000011b & 00010110b = 00000010b
-01000011b & 00010111b = 00000011b
-01000011b & 00011000b = 00000000b
-01000011b & 00011001b = 00000001b
-01000011b & 00011010b = 00000010b
-01000011b & 00011011b = 00000011b
-01000011b & 00011100b = 00000000b
-01000011b & 00011101b = 00000001b
-01000011b & 00011110b = 00000010b
-01000011b & 00011111b = 00000011b
-01000011b & 00100000b = 00000000b
-01000011b & 00100001b = 00000001b
-01000011b & 00100010b = 00000010b
-01000011b & 00100011b = 00000011b
-01000011b & 00100100b = 00000000b
-01000011b & 00100101b = 00000001b
-01000011b & 00100110b = 00000010b
-01000011b & 00100111b = 00000011b
-01000011b & 00101000b = 00000000b
-01000011b & 00101001b = 00000001b
-01000011b & 00101010b = 00000010b
-01000011b & 00101011b = 00000011b
-01000011b & 00101100b = 00000000b
-01000011b & 00101101b = 00000001b
-01000011b & 00101110b = 00000010b
-01000011b & 00101111b = 00000011b
-01000011b & 00110000b = 00000000b
-01000011b & 00110001b = 00000001b
-01000011b & 00110010b = 00000010b
-01000011b & 00110011b = 00000011b
-01000011b & 00110100b = 00000000b
-01000011b & 00110101b = 00000001b
-01000011b & 00110110b = 00000010b
-01000011b & 00110111b = 00000011b
-01000011b & 00111000b = 00000000b
-01000011b & 00111001b = 00000001b
-01000011b & 00111010b = 00000010b
-01000011b & 00111011b = 00000011b
-01000011b & 00111100b = 00000000b
-01000011b & 00111101b = 00000001b
-01000011b & 00111110b = 00000010b
-01000011b & 00111111b = 00000011b
-01000011b & 01000000b = 01000000b
-01000011b & 01000001b = 01000001b
-01000011b & 01000010b = 01000010b
-01000011b & 01000011b = 01000011b
-01000011b & 01000100b = 01000000b
-01000011b & 01000101b = 01000001b
-01000011b & 01000110b = 01000010b
-01000011b & 01000111b = 01000011b
-01000011b & 01001000b = 01000000b
-01000011b & 01001001b = 01000001b
-01000011b & 01001010b = 01000010b
-01000011b & 01001011b = 01000011b
-01000011b & 01001100b = 01000000b
-01000011b & 01001101b = 01000001b
-01000011b & 01001110b = 01000010b
-01000011b & 01001111b = 01000011b
-01000011b & 01010000b = 01000000b
-01000011b & 01010001b = 01000001b
-01000011b & 01010010b = 01000010b
-01000011b & 01010011b = 01000011b
-01000011b & 01010100b = 01000000b
-01000011b & 01010101b = 01000001b
-01000011b & 01010110b = 01000010b
-01000011b & 01010111b = 01000011b
-01000011b & 01011000b = 01000000b
-01000011b & 01011001b = 01000001b
-01000011b & 01011010b = 01000010b
-01000011b & 01011011b = 01000011b
-01000011b & 01011100b = 01000000b
-01000011b & 01011101b = 01000001b
-01000011b & 01011110b = 01000010b
-01000011b & 01011111b = 01000011b
-01000011b & 01100000b = 01000000b
-01000011b & 01100001b = 01000001b
-01000011b & 01100010b = 01000010b
-01000011b & 01100011b = 01000011b
-01000011b & 01100100b = 01000000b
-01000011b & 01100101b = 01000001b
-01000011b & 01100110b = 01000010b
-01000011b & 01100111b = 01000011b
-01000011b & 01101000b = 01000000b
-01000011b & 01101001b = 01000001b
-01000011b & 01101010b = 01000010b
-01000011b & 01101011b = 01000011b
-01000011b & 01101100b = 01000000b
-01000011b & 01101101b = 01000001b
-01000011b & 01101110b = 01000010b
-01000011b & 01101111b = 01000011b
-01000011b & 01110000b = 01000000b
-01000011b & 01110001b = 01000001b
-01000011b & 01110010b = 01000010b
-01000011b & 01110011b = 01000011b
-01000011b & 01110100b = 01000000b
-01000011b & 01110101b = 01000001b
-01000011b & 01110110b = 01000010b
-01000011b & 01110111b = 01000011b
-01000011b & 01111000b = 01000000b
-01000011b & 01111001b = 01000001b
-01000011b & 01111010b = 01000010b
-01000011b & 01111011b = 01000011b
-01000011b & 01111100b = 01000000b
-01000011b & 01111101b = 01000001b
-01000011b & 01111110b = 01000010b
-01000100b & 10000000b = 00000000b
-01000100b & 10000001b = 00000000b
-01000100b & 10000010b = 00000000b
-01000100b & 10000011b = 00000000b
-01000100b & 10000100b = 00000100b
-01000100b & 10000101b = 00000100b
-01000100b & 10000110b = 00000100b
-01000100b & 10000111b = 00000100b
-01000100b & 10001000b = 00000000b
-01000100b & 10001001b = 00000000b
-01000100b & 10001010b = 00000000b
-01000100b & 10001011b = 00000000b
-01000100b & 10001100b = 00000100b
-01000100b & 10001101b = 00000100b
-01000100b & 10001110b = 00000100b
-01000100b & 10001111b = 00000100b
-01000100b & 10010000b = 00000000b
-01000100b & 10010001b = 00000000b
-01000100b & 10010010b = 00000000b
-01000100b & 10010011b = 00000000b
-01000100b & 10010100b = 00000100b
-01000100b & 10010101b = 00000100b
-01000100b & 10010110b = 00000100b
-01000100b & 10010111b = 00000100b
-01000100b & 10011000b = 00000000b
-01000100b & 10011001b = 00000000b
-01000100b & 10011010b = 00000000b
-01000100b & 10011011b = 00000000b
-01000100b & 10011100b = 00000100b
-01000100b & 10011101b = 00000100b
-01000100b & 10011110b = 00000100b
-01000100b & 10011111b = 00000100b
-01000100b & 10100000b = 00000000b
-01000100b & 10100001b = 00000000b
-01000100b & 10100010b = 00000000b
-01000100b & 10100011b = 00000000b
-01000100b & 10100100b = 00000100b
-01000100b & 10100101b = 00000100b
-01000100b & 10100110b = 00000100b
-01000100b & 10100111b = 00000100b
-01000100b & 10101000b = 00000000b
-01000100b & 10101001b = 00000000b
-01000100b & 10101010b = 00000000b
-01000100b & 10101011b = 00000000b
-01000100b & 10101100b = 00000100b
-01000100b & 10101101b = 00000100b
-01000100b & 10101110b = 00000100b
-01000100b & 10101111b = 00000100b
-01000100b & 10110000b = 00000000b
-01000100b & 10110001b = 00000000b
-01000100b & 10110010b = 00000000b
-01000100b & 10110011b = 00000000b
-01000100b & 10110100b = 00000100b
-01000100b & 10110101b = 00000100b
-01000100b & 10110110b = 00000100b
-01000100b & 10110111b = 00000100b
-01000100b & 10111000b = 00000000b
-01000100b & 10111001b = 00000000b
-01000100b & 10111010b = 00000000b
-01000100b & 10111011b = 00000000b
-01000100b & 10111100b = 00000100b
-01000100b & 10111101b = 00000100b
-01000100b & 10111110b = 00000100b
-01000100b & 10111111b = 00000100b
-01000100b & 11000000b = 01000000b
-01000100b & 11000001b = 01000000b
-01000100b & 11000010b = 01000000b
-01000100b & 11000011b = 01000000b
-01000100b & 11000100b = 01000100b
-01000100b & 11000101b = 01000100b
-01000100b & 11000110b = 01000100b
-01000100b & 11000111b = 01000100b
-01000100b & 11001000b = 01000000b
-01000100b & 11001001b = 01000000b
-01000100b & 11001010b = 01000000b
-01000100b & 11001011b = 01000000b
-01000100b & 11001100b = 01000100b
-01000100b & 11001101b = 01000100b
-01000100b & 11001110b = 01000100b
-01000100b & 11001111b = 01000100b
-01000100b & 11010000b = 01000000b
-01000100b & 11010001b = 01000000b
-01000100b & 11010010b = 01000000b
-01000100b & 11010011b = 01000000b
-01000100b & 11010100b = 01000100b
-01000100b & 11010101b = 01000100b
-01000100b & 11010110b = 01000100b
-01000100b & 11010111b = 01000100b
-01000100b & 11011000b = 01000000b
-01000100b & 11011001b = 01000000b
-01000100b & 11011010b = 01000000b
-01000100b & 11011011b = 01000000b
-01000100b & 11011100b = 01000100b
-01000100b & 11011101b = 01000100b
-01000100b & 11011110b = 01000100b
-01000100b & 11011111b = 01000100b
-01000100b & 11100000b = 01000000b
-01000100b & 11100001b = 01000000b
-01000100b & 11100010b = 01000000b
-01000100b & 11100011b = 01000000b
-01000100b & 11100100b = 01000100b
-01000100b & 11100101b = 01000100b
-01000100b & 11100110b = 01000100b
-01000100b & 11100111b = 01000100b
-01000100b & 11101000b = 01000000b
-01000100b & 11101001b = 01000000b
-01000100b & 11101010b = 01000000b
-01000100b & 11101011b = 01000000b
-01000100b & 11101100b = 01000100b
-01000100b & 11101101b = 01000100b
-01000100b & 11101110b = 01000100b
-01000100b & 11101111b = 01000100b
-01000100b & 11110000b = 01000000b
-01000100b & 11110001b = 01000000b
-01000100b & 11110010b = 01000000b
-01000100b & 11110011b = 01000000b
-01000100b & 11110100b = 01000100b
-01000100b & 11110101b = 01000100b
-01000100b & 11110110b = 01000100b
-01000100b & 11110111b = 01000100b
-01000100b & 11111000b = 01000000b
-01000100b & 11111001b = 01000000b
-01000100b & 11111010b = 01000000b
-01000100b & 11111011b = 01000000b
-01000100b & 11111100b = 01000100b
-01000100b & 11111101b = 01000100b
-01000100b & 11111110b = 01000100b
-01000100b & 11111111b = 01000100b
-01000100b & 00000000b = 00000000b
-01000100b & 00000001b = 00000000b
-01000100b & 00000010b = 00000000b
-01000100b & 00000011b = 00000000b
-01000100b & 00000100b = 00000100b
-01000100b & 00000101b = 00000100b
-01000100b & 00000110b = 00000100b
-01000100b & 00000111b = 00000100b
-01000100b & 00001000b = 00000000b
-01000100b & 00001001b = 00000000b
-01000100b & 00001010b = 00000000b
-01000100b & 00001011b = 00000000b
-01000100b & 00001100b = 00000100b
-01000100b & 00001101b = 00000100b
-01000100b & 00001110b = 00000100b
-01000100b & 00001111b = 00000100b
-01000100b & 00010000b = 00000000b
-01000100b & 00010001b = 00000000b
-01000100b & 00010010b = 00000000b
-01000100b & 00010011b = 00000000b
-01000100b & 00010100b = 00000100b
-01000100b & 00010101b = 00000100b
-01000100b & 00010110b = 00000100b
-01000100b & 00010111b = 00000100b
-01000100b & 00011000b = 00000000b
-01000100b & 00011001b = 00000000b
-01000100b & 00011010b = 00000000b
-01000100b & 00011011b = 00000000b
-01000100b & 00011100b = 00000100b
-01000100b & 00011101b = 00000100b
-01000100b & 00011110b = 00000100b
-01000100b & 00011111b = 00000100b
-01000100b & 00100000b = 00000000b
-01000100b & 00100001b = 00000000b
-01000100b & 00100010b = 00000000b
-01000100b & 00100011b = 00000000b
-01000100b & 00100100b = 00000100b
-01000100b & 00100101b = 00000100b
-01000100b & 00100110b = 00000100b
-01000100b & 00100111b = 00000100b
-01000100b & 00101000b = 00000000b
-01000100b & 00101001b = 00000000b
-01000100b & 00101010b = 00000000b
-01000100b & 00101011b = 00000000b
-01000100b & 00101100b = 00000100b
-01000100b & 00101101b = 00000100b
-01000100b & 00101110b = 00000100b
-01000100b & 00101111b = 00000100b
-01000100b & 00110000b = 00000000b
-01000100b & 00110001b = 00000000b
-01000100b & 00110010b = 00000000b
-01000100b & 00110011b = 00000000b
-01000100b & 00110100b = 00000100b
-01000100b & 00110101b = 00000100b
-01000100b & 00110110b = 00000100b
-01000100b & 00110111b = 00000100b
-01000100b & 00111000b = 00000000b
-01000100b & 00111001b = 00000000b
-01000100b & 00111010b = 00000000b
-01000100b & 00111011b = 00000000b
-01000100b & 00111100b = 00000100b
-01000100b & 00111101b = 00000100b
-01000100b & 00111110b = 00000100b
-01000100b & 00111111b = 00000100b
-01000100b & 01000000b = 01000000b
-01000100b & 01000001b = 01000000b
-01000100b & 01000010b = 01000000b
-01000100b & 01000011b = 01000000b
-01000100b & 01000100b = 01000100b
-01000100b & 01000101b = 01000100b
-01000100b & 01000110b = 01000100b
-01000100b & 01000111b = 01000100b
-01000100b & 01001000b = 01000000b
-01000100b & 01001001b = 01000000b
-01000100b & 01001010b = 01000000b
-01000100b & 01001011b = 01000000b
-01000100b & 01001100b = 01000100b
-01000100b & 01001101b = 01000100b
-01000100b & 01001110b = 01000100b
-01000100b & 01001111b = 01000100b
-01000100b & 01010000b = 01000000b
-01000100b & 01010001b = 01000000b
-01000100b & 01010010b = 01000000b
-01000100b & 01010011b = 01000000b
-01000100b & 01010100b = 01000100b
-01000100b & 01010101b = 01000100b
-01000100b & 01010110b = 01000100b
-01000100b & 01010111b = 01000100b
-01000100b & 01011000b = 01000000b
-01000100b & 01011001b = 01000000b
-01000100b & 01011010b = 01000000b
-01000100b & 01011011b = 01000000b
-01000100b & 01011100b = 01000100b
-01000100b & 01011101b = 01000100b
-01000100b & 01011110b = 01000100b
-01000100b & 01011111b = 01000100b
-01000100b & 01100000b = 01000000b
-01000100b & 01100001b = 01000000b
-01000100b & 01100010b = 01000000b
-01000100b & 01100011b = 01000000b
-01000100b & 01100100b = 01000100b
-01000100b & 01100101b = 01000100b
-01000100b & 01100110b = 01000100b
-01000100b & 01100111b = 01000100b
-01000100b & 01101000b = 01000000b
-01000100b & 01101001b = 01000000b
-01000100b & 01101010b = 01000000b
-01000100b & 01101011b = 01000000b
-01000100b & 01101100b = 01000100b
-01000100b & 01101101b = 01000100b
-01000100b & 01101110b = 01000100b
-01000100b & 01101111b = 01000100b
-01000100b & 01110000b = 01000000b
-01000100b & 01110001b = 01000000b
-01000100b & 01110010b = 01000000b
-01000100b & 01110011b = 01000000b
-01000100b & 01110100b = 01000100b
-01000100b & 01110101b = 01000100b
-01000100b & 01110110b = 01000100b
-01000100b & 01110111b = 01000100b
-01000100b & 01111000b = 01000000b
-01000100b & 01111001b = 01000000b
-01000100b & 01111010b = 01000000b
-01000100b & 01111011b = 01000000b
-01000100b & 01111100b = 01000100b
-01000100b & 01111101b = 01000100b
-01000100b & 01111110b = 01000100b
-01000101b & 10000000b = 00000000b
-01000101b & 10000001b = 00000001b
-01000101b & 10000010b = 00000000b
-01000101b & 10000011b = 00000001b
-01000101b & 10000100b = 00000100b
-01000101b & 10000101b = 00000101b
-01000101b & 10000110b = 00000100b
-01000101b & 10000111b = 00000101b
-01000101b & 10001000b = 00000000b
-01000101b & 10001001b = 00000001b
-01000101b & 10001010b = 00000000b
-01000101b & 10001011b = 00000001b
-01000101b & 10001100b = 00000100b
-01000101b & 10001101b = 00000101b
-01000101b & 10001110b = 00000100b
-01000101b & 10001111b = 00000101b
-01000101b & 10010000b = 00000000b
-01000101b & 10010001b = 00000001b
-01000101b & 10010010b = 00000000b
-01000101b & 10010011b = 00000001b
-01000101b & 10010100b = 00000100b
-01000101b & 10010101b = 00000101b
-01000101b & 10010110b = 00000100b
-01000101b & 10010111b = 00000101b
-01000101b & 10011000b = 00000000b
-01000101b & 10011001b = 00000001b
-01000101b & 10011010b = 00000000b
-01000101b & 10011011b = 00000001b
-01000101b & 10011100b = 00000100b
-01000101b & 10011101b = 00000101b
-01000101b & 10011110b = 00000100b
-01000101b & 10011111b = 00000101b
-01000101b & 10100000b = 00000000b
-01000101b & 10100001b = 00000001b
-01000101b & 10100010b = 00000000b
-01000101b & 10100011b = 00000001b
-01000101b & 10100100b = 00000100b
-01000101b & 10100101b = 00000101b
-01000101b & 10100110b = 00000100b
-01000101b & 10100111b = 00000101b
-01000101b & 10101000b = 00000000b
-01000101b & 10101001b = 00000001b
-01000101b & 10101010b = 00000000b
-01000101b & 10101011b = 00000001b
-01000101b & 10101100b = 00000100b
-01000101b & 10101101b = 00000101b
-01000101b & 10101110b = 00000100b
-01000101b & 10101111b = 00000101b
-01000101b & 10110000b = 00000000b
-01000101b & 10110001b = 00000001b
-01000101b & 10110010b = 00000000b
-01000101b & 10110011b = 00000001b
-01000101b & 10110100b = 00000100b
-01000101b & 10110101b = 00000101b
-01000101b & 10110110b = 00000100b
-01000101b & 10110111b = 00000101b
-01000101b & 10111000b = 00000000b
-01000101b & 10111001b = 00000001b
-01000101b & 10111010b = 00000000b
-01000101b & 10111011b = 00000001b
-01000101b & 10111100b = 00000100b
-01000101b & 10111101b = 00000101b
-01000101b & 10111110b = 00000100b
-01000101b & 10111111b = 00000101b
-01000101b & 11000000b = 01000000b
-01000101b & 11000001b = 01000001b
-01000101b & 11000010b = 01000000b
-01000101b & 11000011b = 01000001b
-01000101b & 11000100b = 01000100b
-01000101b & 11000101b = 01000101b
-01000101b & 11000110b = 01000100b
-01000101b & 11000111b = 01000101b
-01000101b & 11001000b = 01000000b
-01000101b & 11001001b = 01000001b
-01000101b & 11001010b = 01000000b
-01000101b & 11001011b = 01000001b
-01000101b & 11001100b = 01000100b
-01000101b & 11001101b = 01000101b
-01000101b & 11001110b = 01000100b
-01000101b & 11001111b = 01000101b
-01000101b & 11010000b = 01000000b
-01000101b & 11010001b = 01000001b
-01000101b & 11010010b = 01000000b
-01000101b & 11010011b = 01000001b
-01000101b & 11010100b = 01000100b
-01000101b & 11010101b = 01000101b
-01000101b & 11010110b = 01000100b
-01000101b & 11010111b = 01000101b
-01000101b & 11011000b = 01000000b
-01000101b & 11011001b = 01000001b
-01000101b & 11011010b = 01000000b
-01000101b & 11011011b = 01000001b
-01000101b & 11011100b = 01000100b
-01000101b & 11011101b = 01000101b
-01000101b & 11011110b = 01000100b
-01000101b & 11011111b = 01000101b
-01000101b & 11100000b = 01000000b
-01000101b & 11100001b = 01000001b
-01000101b & 11100010b = 01000000b
-01000101b & 11100011b = 01000001b
-01000101b & 11100100b = 01000100b
-01000101b & 11100101b = 01000101b
-01000101b & 11100110b = 01000100b
-01000101b & 11100111b = 01000101b
-01000101b & 11101000b = 01000000b
-01000101b & 11101001b = 01000001b
-01000101b & 11101010b = 01000000b
-01000101b & 11101011b = 01000001b
-01000101b & 11101100b = 01000100b
-01000101b & 11101101b = 01000101b
-01000101b & 11101110b = 01000100b
-01000101b & 11101111b = 01000101b
-01000101b & 11110000b = 01000000b
-01000101b & 11110001b = 01000001b
-01000101b & 11110010b = 01000000b
-01000101b & 11110011b = 01000001b
-01000101b & 11110100b = 01000100b
-01000101b & 11110101b = 01000101b
-01000101b & 11110110b = 01000100b
-01000101b & 11110111b = 01000101b
-01000101b & 11111000b = 01000000b
-01000101b & 11111001b = 01000001b
-01000101b & 11111010b = 01000000b
-01000101b & 11111011b = 01000001b
-01000101b & 11111100b = 01000100b
-01000101b & 11111101b = 01000101b
-01000101b & 11111110b = 01000100b
-01000101b & 11111111b = 01000101b
-01000101b & 00000000b = 00000000b
-01000101b & 00000001b = 00000001b
-01000101b & 00000010b = 00000000b
-01000101b & 00000011b = 00000001b
-01000101b & 00000100b = 00000100b
-01000101b & 00000101b = 00000101b
-01000101b & 00000110b = 00000100b
-01000101b & 00000111b = 00000101b
-01000101b & 00001000b = 00000000b
-01000101b & 00001001b = 00000001b
-01000101b & 00001010b = 00000000b
-01000101b & 00001011b = 00000001b
-01000101b & 00001100b = 00000100b
-01000101b & 00001101b = 00000101b
-01000101b & 00001110b = 00000100b
-01000101b & 00001111b = 00000101b
-01000101b & 00010000b = 00000000b
-01000101b & 00010001b = 00000001b
-01000101b & 00010010b = 00000000b
-01000101b & 00010011b = 00000001b
-01000101b & 00010100b = 00000100b
-01000101b & 00010101b = 00000101b
-01000101b & 00010110b = 00000100b
-01000101b & 00010111b = 00000101b
-01000101b & 00011000b = 00000000b
-01000101b & 00011001b = 00000001b
-01000101b & 00011010b = 00000000b
-01000101b & 00011011b = 00000001b
-01000101b & 00011100b = 00000100b
-01000101b & 00011101b = 00000101b
-01000101b & 00011110b = 00000100b
-01000101b & 00011111b = 00000101b
-01000101b & 00100000b = 00000000b
-01000101b & 00100001b = 00000001b
-01000101b & 00100010b = 00000000b
-01000101b & 00100011b = 00000001b
-01000101b & 00100100b = 00000100b
-01000101b & 00100101b = 00000101b
-01000101b & 00100110b = 00000100b
-01000101b & 00100111b = 00000101b
-01000101b & 00101000b = 00000000b
-01000101b & 00101001b = 00000001b
-01000101b & 00101010b = 00000000b
-01000101b & 00101011b = 00000001b
-01000101b & 00101100b = 00000100b
-01000101b & 00101101b = 00000101b
-01000101b & 00101110b = 00000100b
-01000101b & 00101111b = 00000101b
-01000101b & 00110000b = 00000000b
-01000101b & 00110001b = 00000001b
-01000101b & 00110010b = 00000000b
-01000101b & 00110011b = 00000001b
-01000101b & 00110100b = 00000100b
-01000101b & 00110101b = 00000101b
-01000101b & 00110110b = 00000100b
-01000101b & 00110111b = 00000101b
-01000101b & 00111000b = 00000000b
-01000101b & 00111001b = 00000001b
-01000101b & 00111010b = 00000000b
-01000101b & 00111011b = 00000001b
-01000101b & 00111100b = 00000100b
-01000101b & 00111101b = 00000101b
-01000101b & 00111110b = 00000100b
-01000101b & 00111111b = 00000101b
-01000101b & 01000000b = 01000000b
-01000101b & 01000001b = 01000001b
-01000101b & 01000010b = 01000000b
-01000101b & 01000011b = 01000001b
-01000101b & 01000100b = 01000100b
-01000101b & 01000101b = 01000101b
-01000101b & 01000110b = 01000100b
-01000101b & 01000111b = 01000101b
-01000101b & 01001000b = 01000000b
-01000101b & 01001001b = 01000001b
-01000101b & 01001010b = 01000000b
-01000101b & 01001011b = 01000001b
-01000101b & 01001100b = 01000100b
-01000101b & 01001101b = 01000101b
-01000101b & 01001110b = 01000100b
-01000101b & 01001111b = 01000101b
-01000101b & 01010000b = 01000000b
-01000101b & 01010001b = 01000001b
-01000101b & 01010010b = 01000000b
-01000101b & 01010011b = 01000001b
-01000101b & 01010100b = 01000100b
-01000101b & 01010101b = 01000101b
-01000101b & 01010110b = 01000100b
-01000101b & 01010111b = 01000101b
-01000101b & 01011000b = 01000000b
-01000101b & 01011001b = 01000001b
-01000101b & 01011010b = 01000000b
-01000101b & 01011011b = 01000001b
-01000101b & 01011100b = 01000100b
-01000101b & 01011101b = 01000101b
-01000101b & 01011110b = 01000100b
-01000101b & 01011111b = 01000101b
-01000101b & 01100000b = 01000000b
-01000101b & 01100001b = 01000001b
-01000101b & 01100010b = 01000000b
-01000101b & 01100011b = 01000001b
-01000101b & 01100100b = 01000100b
-01000101b & 01100101b = 01000101b
-01000101b & 01100110b = 01000100b
-01000101b & 01100111b = 01000101b
-01000101b & 01101000b = 01000000b
-01000101b & 01101001b = 01000001b
-01000101b & 01101010b = 01000000b
-01000101b & 01101011b = 01000001b
-01000101b & 01101100b = 01000100b
-01000101b & 01101101b = 01000101b
-01000101b & 01101110b = 01000100b
-01000101b & 01101111b = 01000101b
-01000101b & 01110000b = 01000000b
-01000101b & 01110001b = 01000001b
-01000101b & 01110010b = 01000000b
-01000101b & 01110011b = 01000001b
-01000101b & 01110100b = 01000100b
-01000101b & 01110101b = 01000101b
-01000101b & 01110110b = 01000100b
-01000101b & 01110111b = 01000101b
-01000101b & 01111000b = 01000000b
-01000101b & 01111001b = 01000001b
-01000101b & 01111010b = 01000000b
-01000101b & 01111011b = 01000001b
-01000101b & 01111100b = 01000100b
-01000101b & 01111101b = 01000101b
-01000101b & 01111110b = 01000100b
-01000110b & 10000000b = 00000000b
-01000110b & 10000001b = 00000000b
-01000110b & 10000010b = 00000010b
-01000110b & 10000011b = 00000010b
-01000110b & 10000100b = 00000100b
-01000110b & 10000101b = 00000100b
-01000110b & 10000110b = 00000110b
-01000110b & 10000111b = 00000110b
-01000110b & 10001000b = 00000000b
-01000110b & 10001001b = 00000000b
-01000110b & 10001010b = 00000010b
-01000110b & 10001011b = 00000010b
-01000110b & 10001100b = 00000100b
-01000110b & 10001101b = 00000100b
-01000110b & 10001110b = 00000110b
-01000110b & 10001111b = 00000110b
-01000110b & 10010000b = 00000000b
-01000110b & 10010001b = 00000000b
-01000110b & 10010010b = 00000010b
-01000110b & 10010011b = 00000010b
-01000110b & 10010100b = 00000100b
-01000110b & 10010101b = 00000100b
-01000110b & 10010110b = 00000110b
-01000110b & 10010111b = 00000110b
-01000110b & 10011000b = 00000000b
-01000110b & 10011001b = 00000000b
-01000110b & 10011010b = 00000010b
-01000110b & 10011011b = 00000010b
-01000110b & 10011100b = 00000100b
-01000110b & 10011101b = 00000100b
-01000110b & 10011110b = 00000110b
-01000110b & 10011111b = 00000110b
-01000110b & 10100000b = 00000000b
-01000110b & 10100001b = 00000000b
-01000110b & 10100010b = 00000010b
-01000110b & 10100011b = 00000010b
-01000110b & 10100100b = 00000100b
-01000110b & 10100101b = 00000100b
-01000110b & 10100110b = 00000110b
-01000110b & 10100111b = 00000110b
-01000110b & 10101000b = 00000000b
-01000110b & 10101001b = 00000000b
-01000110b & 10101010b = 00000010b
-01000110b & 10101011b = 00000010b
-01000110b & 10101100b = 00000100b
-01000110b & 10101101b = 00000100b
-01000110b & 10101110b = 00000110b
-01000110b & 10101111b = 00000110b
-01000110b & 10110000b = 00000000b
-01000110b & 10110001b = 00000000b
-01000110b & 10110010b = 00000010b
-01000110b & 10110011b = 00000010b
-01000110b & 10110100b = 00000100b
-01000110b & 10110101b = 00000100b
-01000110b & 10110110b = 00000110b
-01000110b & 10110111b = 00000110b
-01000110b & 10111000b = 00000000b
-01000110b & 10111001b = 00000000b
-01000110b & 10111010b = 00000010b
-01000110b & 10111011b = 00000010b
-01000110b & 10111100b = 00000100b
-01000110b & 10111101b = 00000100b
-01000110b & 10111110b = 00000110b
-01000110b & 10111111b = 00000110b
-01000110b & 11000000b = 01000000b
-01000110b & 11000001b = 01000000b
-01000110b & 11000010b = 01000010b
-01000110b & 11000011b = 01000010b
-01000110b & 11000100b = 01000100b
-01000110b & 11000101b = 01000100b
-01000110b & 11000110b = 01000110b
-01000110b & 11000111b = 01000110b
-01000110b & 11001000b = 01000000b
-01000110b & 11001001b = 01000000b
-01000110b & 11001010b = 01000010b
-01000110b & 11001011b = 01000010b
-01000110b & 11001100b = 01000100b
-01000110b & 11001101b = 01000100b
-01000110b & 11001110b = 01000110b
-01000110b & 11001111b = 01000110b
-01000110b & 11010000b = 01000000b
-01000110b & 11010001b = 01000000b
-01000110b & 11010010b = 01000010b
-01000110b & 11010011b = 01000010b
-01000110b & 11010100b = 01000100b
-01000110b & 11010101b = 01000100b
-01000110b & 11010110b = 01000110b
-01000110b & 11010111b = 01000110b
-01000110b & 11011000b = 01000000b
-01000110b & 11011001b = 01000000b
-01000110b & 11011010b = 01000010b
-01000110b & 11011011b = 01000010b
-01000110b & 11011100b = 01000100b
-01000110b & 11011101b = 01000100b
-01000110b & 11011110b = 01000110b
-01000110b & 11011111b = 01000110b
-01000110b & 11100000b = 01000000b
-01000110b & 11100001b = 01000000b
-01000110b & 11100010b = 01000010b
-01000110b & 11100011b = 01000010b
-01000110b & 11100100b = 01000100b
-01000110b & 11100101b = 01000100b
-01000110b & 11100110b = 01000110b
-01000110b & 11100111b = 01000110b
-01000110b & 11101000b = 01000000b
-01000110b & 11101001b = 01000000b
-01000110b & 11101010b = 01000010b
-01000110b & 11101011b = 01000010b
-01000110b & 11101100b = 01000100b
-01000110b & 11101101b = 01000100b
-01000110b & 11101110b = 01000110b
-01000110b & 11101111b = 01000110b
-01000110b & 11110000b = 01000000b
-01000110b & 11110001b = 01000000b
-01000110b & 11110010b = 01000010b
-01000110b & 11110011b = 01000010b
-01000110b & 11110100b = 01000100b
-01000110b & 11110101b = 01000100b
-01000110b & 11110110b = 01000110b
-01000110b & 11110111b = 01000110b
-01000110b & 11111000b = 01000000b
-01000110b & 11111001b = 01000000b
-01000110b & 11111010b = 01000010b
-01000110b & 11111011b = 01000010b
-01000110b & 11111100b = 01000100b
-01000110b & 11111101b = 01000100b
-01000110b & 11111110b = 01000110b
-01000110b & 11111111b = 01000110b
-01000110b & 00000000b = 00000000b
-01000110b & 00000001b = 00000000b
-01000110b & 00000010b = 00000010b
-01000110b & 00000011b = 00000010b
-01000110b & 00000100b = 00000100b
-01000110b & 00000101b = 00000100b
-01000110b & 00000110b = 00000110b
-01000110b & 00000111b = 00000110b
-01000110b & 00001000b = 00000000b
-01000110b & 00001001b = 00000000b
-01000110b & 00001010b = 00000010b
-01000110b & 00001011b = 00000010b
-01000110b & 00001100b = 00000100b
-01000110b & 00001101b = 00000100b
-01000110b & 00001110b = 00000110b
-01000110b & 00001111b = 00000110b
-01000110b & 00010000b = 00000000b
-01000110b & 00010001b = 00000000b
-01000110b & 00010010b = 00000010b
-01000110b & 00010011b = 00000010b
-01000110b & 00010100b = 00000100b
-01000110b & 00010101b = 00000100b
-01000110b & 00010110b = 00000110b
-01000110b & 00010111b = 00000110b
-01000110b & 00011000b = 00000000b
-01000110b & 00011001b = 00000000b
-01000110b & 00011010b = 00000010b
-01000110b & 00011011b = 00000010b
-01000110b & 00011100b = 00000100b
-01000110b & 00011101b = 00000100b
-01000110b & 00011110b = 00000110b
-01000110b & 00011111b = 00000110b
-01000110b & 00100000b = 00000000b
-01000110b & 00100001b = 00000000b
-01000110b & 00100010b = 00000010b
-01000110b & 00100011b = 00000010b
-01000110b & 00100100b = 00000100b
-01000110b & 00100101b = 00000100b
-01000110b & 00100110b = 00000110b
-01000110b & 00100111b = 00000110b
-01000110b & 00101000b = 00000000b
-01000110b & 00101001b = 00000000b
-01000110b & 00101010b = 00000010b
-01000110b & 00101011b = 00000010b
-01000110b & 00101100b = 00000100b
-01000110b & 00101101b = 00000100b
-01000110b & 00101110b = 00000110b
-01000110b & 00101111b = 00000110b
-01000110b & 00110000b = 00000000b
-01000110b & 00110001b = 00000000b
-01000110b & 00110010b = 00000010b
-01000110b & 00110011b = 00000010b
-01000110b & 00110100b = 00000100b
-01000110b & 00110101b = 00000100b
-01000110b & 00110110b = 00000110b
-01000110b & 00110111b = 00000110b
-01000110b & 00111000b = 00000000b
-01000110b & 00111001b = 00000000b
-01000110b & 00111010b = 00000010b
-01000110b & 00111011b = 00000010b
-01000110b & 00111100b = 00000100b
-01000110b & 00111101b = 00000100b
-01000110b & 00111110b = 00000110b
-01000110b & 00111111b = 00000110b
-01000110b & 01000000b = 01000000b
-01000110b & 01000001b = 01000000b
-01000110b & 01000010b = 01000010b
-01000110b & 01000011b = 01000010b
-01000110b & 01000100b = 01000100b
-01000110b & 01000101b = 01000100b
-01000110b & 01000110b = 01000110b
-01000110b & 01000111b = 01000110b
-01000110b & 01001000b = 01000000b
-01000110b & 01001001b = 01000000b
-01000110b & 01001010b = 01000010b
-01000110b & 01001011b = 01000010b
-01000110b & 01001100b = 01000100b
-01000110b & 01001101b = 01000100b
-01000110b & 01001110b = 01000110b
-01000110b & 01001111b = 01000110b
-01000110b & 01010000b = 01000000b
-01000110b & 01010001b = 01000000b
-01000110b & 01010010b = 01000010b
-01000110b & 01010011b = 01000010b
-01000110b & 01010100b = 01000100b
-01000110b & 01010101b = 01000100b
-01000110b & 01010110b = 01000110b
-01000110b & 01010111b = 01000110b
-01000110b & 01011000b = 01000000b
-01000110b & 01011001b = 01000000b
-01000110b & 01011010b = 01000010b
-01000110b & 01011011b = 01000010b
-01000110b & 01011100b = 01000100b
-01000110b & 01011101b = 01000100b
-01000110b & 01011110b = 01000110b
-01000110b & 01011111b = 01000110b
-01000110b & 01100000b = 01000000b
-01000110b & 01100001b = 01000000b
-01000110b & 01100010b = 01000010b
-01000110b & 01100011b = 01000010b
-01000110b & 01100100b = 01000100b
-01000110b & 01100101b = 01000100b
-01000110b & 01100110b = 01000110b
-01000110b & 01100111b = 01000110b
-01000110b & 01101000b = 01000000b
-01000110b & 01101001b = 01000000b
-01000110b & 01101010b = 01000010b
-01000110b & 01101011b = 01000010b
-01000110b & 01101100b = 01000100b
-01000110b & 01101101b = 01000100b
-01000110b & 01101110b = 01000110b
-01000110b & 01101111b = 01000110b
-01000110b & 01110000b = 01000000b
-01000110b & 01110001b = 01000000b
-01000110b & 01110010b = 01000010b
-01000110b & 01110011b = 01000010b
-01000110b & 01110100b = 01000100b
-01000110b & 01110101b = 01000100b
-01000110b & 01110110b = 01000110b
-01000110b & 01110111b = 01000110b
-01000110b & 01111000b = 01000000b
-01000110b & 01111001b = 01000000b
-01000110b & 01111010b = 01000010b
-01000110b & 01111011b = 01000010b
-01000110b & 01111100b = 01000100b
-01000110b & 01111101b = 01000100b
-01000110b & 01111110b = 01000110b
-01000111b & 10000000b = 00000000b
-01000111b & 10000001b = 00000001b
-01000111b & 10000010b = 00000010b
-01000111b & 10000011b = 00000011b
-01000111b & 10000100b = 00000100b
-01000111b & 10000101b = 00000101b
-01000111b & 10000110b = 00000110b
-01000111b & 10000111b = 00000111b
-01000111b & 10001000b = 00000000b
-01000111b & 10001001b = 00000001b
-01000111b & 10001010b = 00000010b
-01000111b & 10001011b = 00000011b
-01000111b & 10001100b = 00000100b
-01000111b & 10001101b = 00000101b
-01000111b & 10001110b = 00000110b
-01000111b & 10001111b = 00000111b
-01000111b & 10010000b = 00000000b
-01000111b & 10010001b = 00000001b
-01000111b & 10010010b = 00000010b
-01000111b & 10010011b = 00000011b
-01000111b & 10010100b = 00000100b
-01000111b & 10010101b = 00000101b
-01000111b & 10010110b = 00000110b
-01000111b & 10010111b = 00000111b
-01000111b & 10011000b = 00000000b
-01000111b & 10011001b = 00000001b
-01000111b & 10011010b = 00000010b
-01000111b & 10011011b = 00000011b
-01000111b & 10011100b = 00000100b
-01000111b & 10011101b = 00000101b
-01000111b & 10011110b = 00000110b
-01000111b & 10011111b = 00000111b
-01000111b & 10100000b = 00000000b
-01000111b & 10100001b = 00000001b
-01000111b & 10100010b = 00000010b
-01000111b & 10100011b = 00000011b
-01000111b & 10100100b = 00000100b
-01000111b & 10100101b = 00000101b
-01000111b & 10100110b = 00000110b
-01000111b & 10100111b = 00000111b
-01000111b & 10101000b = 00000000b
-01000111b & 10101001b = 00000001b
-01000111b & 10101010b = 00000010b
-01000111b & 10101011b = 00000011b
-01000111b & 10101100b = 00000100b
-01000111b & 10101101b = 00000101b
-01000111b & 10101110b = 00000110b
-01000111b & 10101111b = 00000111b
-01000111b & 10110000b = 00000000b
-01000111b & 10110001b = 00000001b
-01000111b & 10110010b = 00000010b
-01000111b & 10110011b = 00000011b
-01000111b & 10110100b = 00000100b
-01000111b & 10110101b = 00000101b
-01000111b & 10110110b = 00000110b
-01000111b & 10110111b = 00000111b
-01000111b & 10111000b = 00000000b
-01000111b & 10111001b = 00000001b
-01000111b & 10111010b = 00000010b
-01000111b & 10111011b = 00000011b
-01000111b & 10111100b = 00000100b
-01000111b & 10111101b = 00000101b
-01000111b & 10111110b = 00000110b
-01000111b & 10111111b = 00000111b
-01000111b & 11000000b = 01000000b
-01000111b & 11000001b = 01000001b
-01000111b & 11000010b = 01000010b
-01000111b & 11000011b = 01000011b
-01000111b & 11000100b = 01000100b
-01000111b & 11000101b = 01000101b
-01000111b & 11000110b = 01000110b
-01000111b & 11000111b = 01000111b
-01000111b & 11001000b = 01000000b
-01000111b & 11001001b = 01000001b
-01000111b & 11001010b = 01000010b
-01000111b & 11001011b = 01000011b
-01000111b & 11001100b = 01000100b
-01000111b & 11001101b = 01000101b
-01000111b & 11001110b = 01000110b
-01000111b & 11001111b = 01000111b
-01000111b & 11010000b = 01000000b
-01000111b & 11010001b = 01000001b
-01000111b & 11010010b = 01000010b
-01000111b & 11010011b = 01000011b
-01000111b & 11010100b = 01000100b
-01000111b & 11010101b = 01000101b
-01000111b & 11010110b = 01000110b
-01000111b & 11010111b = 01000111b
-01000111b & 11011000b = 01000000b
-01000111b & 11011001b = 01000001b
-01000111b & 11011010b = 01000010b
-01000111b & 11011011b = 01000011b
-01000111b & 11011100b = 01000100b
-01000111b & 11011101b = 01000101b
-01000111b & 11011110b = 01000110b
-01000111b & 11011111b = 01000111b
-01000111b & 11100000b = 01000000b
-01000111b & 11100001b = 01000001b
-01000111b & 11100010b = 01000010b
-01000111b & 11100011b = 01000011b
-01000111b & 11100100b = 01000100b
-01000111b & 11100101b = 01000101b
-01000111b & 11100110b = 01000110b
-01000111b & 11100111b = 01000111b
-01000111b & 11101000b = 01000000b
-01000111b & 11101001b = 01000001b
-01000111b & 11101010b = 01000010b
-01000111b & 11101011b = 01000011b
-01000111b & 11101100b = 01000100b
-01000111b & 11101101b = 01000101b
-01000111b & 11101110b = 01000110b
-01000111b & 11101111b = 01000111b
-01000111b & 11110000b = 01000000b
-01000111b & 11110001b = 01000001b
-01000111b & 11110010b = 01000010b
-01000111b & 11110011b = 01000011b
-01000111b & 11110100b = 01000100b
-01000111b & 11110101b = 01000101b
-01000111b & 11110110b = 01000110b
-01000111b & 11110111b = 01000111b
-01000111b & 11111000b = 01000000b
-01000111b & 11111001b = 01000001b
-01000111b & 11111010b = 01000010b
-01000111b & 11111011b = 01000011b
-01000111b & 11111100b = 01000100b
-01000111b & 11111101b = 01000101b
-01000111b & 11111110b = 01000110b
-01000111b & 11111111b = 01000111b
-01000111b & 00000000b = 00000000b
-01000111b & 00000001b = 00000001b
-01000111b & 00000010b = 00000010b
-01000111b & 00000011b = 00000011b
-01000111b & 00000100b = 00000100b
-01000111b & 00000101b = 00000101b
-01000111b & 00000110b = 00000110b
-01000111b & 00000111b = 00000111b
-01000111b & 00001000b = 00000000b
-01000111b & 00001001b = 00000001b
-01000111b & 00001010b = 00000010b
-01000111b & 00001011b = 00000011b
-01000111b & 00001100b = 00000100b
-01000111b & 00001101b = 00000101b
-01000111b & 00001110b = 00000110b
-01000111b & 00001111b = 00000111b
-01000111b & 00010000b = 00000000b
-01000111b & 00010001b = 00000001b
-01000111b & 00010010b = 00000010b
-01000111b & 00010011b = 00000011b
-01000111b & 00010100b = 00000100b
-01000111b & 00010101b = 00000101b
-01000111b & 00010110b = 00000110b
-01000111b & 00010111b = 00000111b
-01000111b & 00011000b = 00000000b
-01000111b & 00011001b = 00000001b
-01000111b & 00011010b = 00000010b
-01000111b & 00011011b = 00000011b
-01000111b & 00011100b = 00000100b
-01000111b & 00011101b = 00000101b
-01000111b & 00011110b = 00000110b
-01000111b & 00011111b = 00000111b
-01000111b & 00100000b = 00000000b
-01000111b & 00100001b = 00000001b
-01000111b & 00100010b = 00000010b
-01000111b & 00100011b = 00000011b
-01000111b & 00100100b = 00000100b
-01000111b & 00100101b = 00000101b
-01000111b & 00100110b = 00000110b
-01000111b & 00100111b = 00000111b
-01000111b & 00101000b = 00000000b
-01000111b & 00101001b = 00000001b
-01000111b & 00101010b = 00000010b
-01000111b & 00101011b = 00000011b
-01000111b & 00101100b = 00000100b
-01000111b & 00101101b = 00000101b
-01000111b & 00101110b = 00000110b
-01000111b & 00101111b = 00000111b
-01000111b & 00110000b = 00000000b
-01000111b & 00110001b = 00000001b
-01000111b & 00110010b = 00000010b
-01000111b & 00110011b = 00000011b
-01000111b & 00110100b = 00000100b
-01000111b & 00110101b = 00000101b
-01000111b & 00110110b = 00000110b
-01000111b & 00110111b = 00000111b
-01000111b & 00111000b = 00000000b
-01000111b & 00111001b = 00000001b
-01000111b & 00111010b = 00000010b
-01000111b & 00111011b = 00000011b
-01000111b & 00111100b = 00000100b
-01000111b & 00111101b = 00000101b
-01000111b & 00111110b = 00000110b
-01000111b & 00111111b = 00000111b
-01000111b & 01000000b = 01000000b
-01000111b & 01000001b = 01000001b
-01000111b & 01000010b = 01000010b
-01000111b & 01000011b = 01000011b
-01000111b & 01000100b = 01000100b
-01000111b & 01000101b = 01000101b
-01000111b & 01000110b = 01000110b
-01000111b & 01000111b = 01000111b
-01000111b & 01001000b = 01000000b
-01000111b & 01001001b = 01000001b
-01000111b & 01001010b = 01000010b
-01000111b & 01001011b = 01000011b
-01000111b & 01001100b = 01000100b
-01000111b & 01001101b = 01000101b
-01000111b & 01001110b = 01000110b
-01000111b & 01001111b = 01000111b
-01000111b & 01010000b = 01000000b
-01000111b & 01010001b = 01000001b
-01000111b & 01010010b = 01000010b
-01000111b & 01010011b = 01000011b
-01000111b & 01010100b = 01000100b
-01000111b & 01010101b = 01000101b
-01000111b & 01010110b = 01000110b
-01000111b & 01010111b = 01000111b
-01000111b & 01011000b = 01000000b
-01000111b & 01011001b = 01000001b
-01000111b & 01011010b = 01000010b
-01000111b & 01011011b = 01000011b
-01000111b & 01011100b = 01000100b
-01000111b & 01011101b = 01000101b
-01000111b & 01011110b = 01000110b
-01000111b & 01011111b = 01000111b
-01000111b & 01100000b = 01000000b
-01000111b & 01100001b = 01000001b
-01000111b & 01100010b = 01000010b
-01000111b & 01100011b = 01000011b
-01000111b & 01100100b = 01000100b
-01000111b & 01100101b = 01000101b
-01000111b & 01100110b = 01000110b
-01000111b & 01100111b = 01000111b
-01000111b & 01101000b = 01000000b
-01000111b & 01101001b = 01000001b
-01000111b & 01101010b = 01000010b
-01000111b & 01101011b = 01000011b
-01000111b & 01101100b = 01000100b
-01000111b & 01101101b = 01000101b
-01000111b & 01101110b = 01000110b
-01000111b & 01101111b = 01000111b
-01000111b & 01110000b = 01000000b
-01000111b & 01110001b = 01000001b
-01000111b & 01110010b = 01000010b
-01000111b & 01110011b = 01000011b
-01000111b & 01110100b = 01000100b
-01000111b & 01110101b = 01000101b
-01000111b & 01110110b = 01000110b
-01000111b & 01110111b = 01000111b
-01000111b & 01111000b = 01000000b
-01000111b & 01111001b = 01000001b
-01000111b & 01111010b = 01000010b
-01000111b & 01111011b = 01000011b
-01000111b & 01111100b = 01000100b
-01000111b & 01111101b = 01000101b
-01000111b & 01111110b = 01000110b
-01001000b & 10000000b = 00000000b
-01001000b & 10000001b = 00000000b
-01001000b & 10000010b = 00000000b
-01001000b & 10000011b = 00000000b
-01001000b & 10000100b = 00000000b
-01001000b & 10000101b = 00000000b
-01001000b & 10000110b = 00000000b
-01001000b & 10000111b = 00000000b
-01001000b & 10001000b = 00001000b
-01001000b & 10001001b = 00001000b
-01001000b & 10001010b = 00001000b
-01001000b & 10001011b = 00001000b
-01001000b & 10001100b = 00001000b
-01001000b & 10001101b = 00001000b
-01001000b & 10001110b = 00001000b
-01001000b & 10001111b = 00001000b
-01001000b & 10010000b = 00000000b
-01001000b & 10010001b = 00000000b
-01001000b & 10010010b = 00000000b
-01001000b & 10010011b = 00000000b
-01001000b & 10010100b = 00000000b
-01001000b & 10010101b = 00000000b
-01001000b & 10010110b = 00000000b
-01001000b & 10010111b = 00000000b
-01001000b & 10011000b = 00001000b
-01001000b & 10011001b = 00001000b
-01001000b & 10011010b = 00001000b
-01001000b & 10011011b = 00001000b
-01001000b & 10011100b = 00001000b
-01001000b & 10011101b = 00001000b
-01001000b & 10011110b = 00001000b
-01001000b & 10011111b = 00001000b
-01001000b & 10100000b = 00000000b
-01001000b & 10100001b = 00000000b
-01001000b & 10100010b = 00000000b
-01001000b & 10100011b = 00000000b
-01001000b & 10100100b = 00000000b
-01001000b & 10100101b = 00000000b
-01001000b & 10100110b = 00000000b
-01001000b & 10100111b = 00000000b
-01001000b & 10101000b = 00001000b
-01001000b & 10101001b = 00001000b
-01001000b & 10101010b = 00001000b
-01001000b & 10101011b = 00001000b
-01001000b & 10101100b = 00001000b
-01001000b & 10101101b = 00001000b
-01001000b & 10101110b = 00001000b
-01001000b & 10101111b = 00001000b
-01001000b & 10110000b = 00000000b
-01001000b & 10110001b = 00000000b
-01001000b & 10110010b = 00000000b
-01001000b & 10110011b = 00000000b
-01001000b & 10110100b = 00000000b
-01001000b & 10110101b = 00000000b
-01001000b & 10110110b = 00000000b
-01001000b & 10110111b = 00000000b
-01001000b & 10111000b = 00001000b
-01001000b & 10111001b = 00001000b
-01001000b & 10111010b = 00001000b
-01001000b & 10111011b = 00001000b
-01001000b & 10111100b = 00001000b
-01001000b & 10111101b = 00001000b
-01001000b & 10111110b = 00001000b
-01001000b & 10111111b = 00001000b
-01001000b & 11000000b = 01000000b
-01001000b & 11000001b = 01000000b
-01001000b & 11000010b = 01000000b
-01001000b & 11000011b = 01000000b
-01001000b & 11000100b = 01000000b
-01001000b & 11000101b = 01000000b
-01001000b & 11000110b = 01000000b
-01001000b & 11000111b = 01000000b
-01001000b & 11001000b = 01001000b
-01001000b & 11001001b = 01001000b
-01001000b & 11001010b = 01001000b
-01001000b & 11001011b = 01001000b
-01001000b & 11001100b = 01001000b
-01001000b & 11001101b = 01001000b
-01001000b & 11001110b = 01001000b
-01001000b & 11001111b = 01001000b
-01001000b & 11010000b = 01000000b
-01001000b & 11010001b = 01000000b
-01001000b & 11010010b = 01000000b
-01001000b & 11010011b = 01000000b
-01001000b & 11010100b = 01000000b
-01001000b & 11010101b = 01000000b
-01001000b & 11010110b = 01000000b
-01001000b & 11010111b = 01000000b
-01001000b & 11011000b = 01001000b
-01001000b & 11011001b = 01001000b
-01001000b & 11011010b = 01001000b
-01001000b & 11011011b = 01001000b
-01001000b & 11011100b = 01001000b
-01001000b & 11011101b = 01001000b
-01001000b & 11011110b = 01001000b
-01001000b & 11011111b = 01001000b
-01001000b & 11100000b = 01000000b
-01001000b & 11100001b = 01000000b
-01001000b & 11100010b = 01000000b
-01001000b & 11100011b = 01000000b
-01001000b & 11100100b = 01000000b
-01001000b & 11100101b = 01000000b
-01001000b & 11100110b = 01000000b
-01001000b & 11100111b = 01000000b
-01001000b & 11101000b = 01001000b
-01001000b & 11101001b = 01001000b
-01001000b & 11101010b = 01001000b
-01001000b & 11101011b = 01001000b
-01001000b & 11101100b = 01001000b
-01001000b & 11101101b = 01001000b
-01001000b & 11101110b = 01001000b
-01001000b & 11101111b = 01001000b
-01001000b & 11110000b = 01000000b
-01001000b & 11110001b = 01000000b
-01001000b & 11110010b = 01000000b
-01001000b & 11110011b = 01000000b
-01001000b & 11110100b = 01000000b
-01001000b & 11110101b = 01000000b
-01001000b & 11110110b = 01000000b
-01001000b & 11110111b = 01000000b
-01001000b & 11111000b = 01001000b
-01001000b & 11111001b = 01001000b
-01001000b & 11111010b = 01001000b
-01001000b & 11111011b = 01001000b
-01001000b & 11111100b = 01001000b
-01001000b & 11111101b = 01001000b
-01001000b & 11111110b = 01001000b
-01001000b & 11111111b = 01001000b
-01001000b & 00000000b = 00000000b
-01001000b & 00000001b = 00000000b
-01001000b & 00000010b = 00000000b
-01001000b & 00000011b = 00000000b
-01001000b & 00000100b = 00000000b
-01001000b & 00000101b = 00000000b
-01001000b & 00000110b = 00000000b
-01001000b & 00000111b = 00000000b
-01001000b & 00001000b = 00001000b
-01001000b & 00001001b = 00001000b
-01001000b & 00001010b = 00001000b
-01001000b & 00001011b = 00001000b
-01001000b & 00001100b = 00001000b
-01001000b & 00001101b = 00001000b
-01001000b & 00001110b = 00001000b
-01001000b & 00001111b = 00001000b
-01001000b & 00010000b = 00000000b
-01001000b & 00010001b = 00000000b
-01001000b & 00010010b = 00000000b
-01001000b & 00010011b = 00000000b
-01001000b & 00010100b = 00000000b
-01001000b & 00010101b = 00000000b
-01001000b & 00010110b = 00000000b
-01001000b & 00010111b = 00000000b
-01001000b & 00011000b = 00001000b
-01001000b & 00011001b = 00001000b
-01001000b & 00011010b = 00001000b
-01001000b & 00011011b = 00001000b
-01001000b & 00011100b = 00001000b
-01001000b & 00011101b = 00001000b
-01001000b & 00011110b = 00001000b
-01001000b & 00011111b = 00001000b
-01001000b & 00100000b = 00000000b
-01001000b & 00100001b = 00000000b
-01001000b & 00100010b = 00000000b
-01001000b & 00100011b = 00000000b
-01001000b & 00100100b = 00000000b
-01001000b & 00100101b = 00000000b
-01001000b & 00100110b = 00000000b
-01001000b & 00100111b = 00000000b
-01001000b & 00101000b = 00001000b
-01001000b & 00101001b = 00001000b
-01001000b & 00101010b = 00001000b
-01001000b & 00101011b = 00001000b
-01001000b & 00101100b = 00001000b
-01001000b & 00101101b = 00001000b
-01001000b & 00101110b = 00001000b
-01001000b & 00101111b = 00001000b
-01001000b & 00110000b = 00000000b
-01001000b & 00110001b = 00000000b
-01001000b & 00110010b = 00000000b
-01001000b & 00110011b = 00000000b
-01001000b & 00110100b = 00000000b
-01001000b & 00110101b = 00000000b
-01001000b & 00110110b = 00000000b
-01001000b & 00110111b = 00000000b
-01001000b & 00111000b = 00001000b
-01001000b & 00111001b = 00001000b
-01001000b & 00111010b = 00001000b
-01001000b & 00111011b = 00001000b
-01001000b & 00111100b = 00001000b
-01001000b & 00111101b = 00001000b
-01001000b & 00111110b = 00001000b
-01001000b & 00111111b = 00001000b
-01001000b & 01000000b = 01000000b
-01001000b & 01000001b = 01000000b
-01001000b & 01000010b = 01000000b
-01001000b & 01000011b = 01000000b
-01001000b & 01000100b = 01000000b
-01001000b & 01000101b = 01000000b
-01001000b & 01000110b = 01000000b
-01001000b & 01000111b = 01000000b
-01001000b & 01001000b = 01001000b
-01001000b & 01001001b = 01001000b
-01001000b & 01001010b = 01001000b
-01001000b & 01001011b = 01001000b
-01001000b & 01001100b = 01001000b
-01001000b & 01001101b = 01001000b
-01001000b & 01001110b = 01001000b
-01001000b & 01001111b = 01001000b
-01001000b & 01010000b = 01000000b
-01001000b & 01010001b = 01000000b
-01001000b & 01010010b = 01000000b
-01001000b & 01010011b = 01000000b
-01001000b & 01010100b = 01000000b
-01001000b & 01010101b = 01000000b
-01001000b & 01010110b = 01000000b
-01001000b & 01010111b = 01000000b
-01001000b & 01011000b = 01001000b
-01001000b & 01011001b = 01001000b
-01001000b & 01011010b = 01001000b
-01001000b & 01011011b = 01001000b
-01001000b & 01011100b = 01001000b
-01001000b & 01011101b = 01001000b
-01001000b & 01011110b = 01001000b
-01001000b & 01011111b = 01001000b
-01001000b & 01100000b = 01000000b
-01001000b & 01100001b = 01000000b
-01001000b & 01100010b = 01000000b
-01001000b & 01100011b = 01000000b
-01001000b & 01100100b = 01000000b
-01001000b & 01100101b = 01000000b
-01001000b & 01100110b = 01000000b
-01001000b & 01100111b = 01000000b
-01001000b & 01101000b = 01001000b
-01001000b & 01101001b = 01001000b
-01001000b & 01101010b = 01001000b
-01001000b & 01101011b = 01001000b
-01001000b & 01101100b = 01001000b
-01001000b & 01101101b = 01001000b
-01001000b & 01101110b = 01001000b
-01001000b & 01101111b = 01001000b
-01001000b & 01110000b = 01000000b
-01001000b & 01110001b = 01000000b
-01001000b & 01110010b = 01000000b
-01001000b & 01110011b = 01000000b
-01001000b & 01110100b = 01000000b
-01001000b & 01110101b = 01000000b
-01001000b & 01110110b = 01000000b
-01001000b & 01110111b = 01000000b
-01001000b & 01111000b = 01001000b
-01001000b & 01111001b = 01001000b
-01001000b & 01111010b = 01001000b
-01001000b & 01111011b = 01001000b
-01001000b & 01111100b = 01001000b
-01001000b & 01111101b = 01001000b
-01001000b & 01111110b = 01001000b
-01001001b & 10000000b = 00000000b
-01001001b & 10000001b = 00000001b
-01001001b & 10000010b = 00000000b
-01001001b & 10000011b = 00000001b
-01001001b & 10000100b = 00000000b
-01001001b & 10000101b = 00000001b
-01001001b & 10000110b = 00000000b
-01001001b & 10000111b = 00000001b
-01001001b & 10001000b = 00001000b
-01001001b & 10001001b = 00001001b
-01001001b & 10001010b = 00001000b
-01001001b & 10001011b = 00001001b
-01001001b & 10001100b = 00001000b
-01001001b & 10001101b = 00001001b
-01001001b & 10001110b = 00001000b
-01001001b & 10001111b = 00001001b
-01001001b & 10010000b = 00000000b
-01001001b & 10010001b = 00000001b
-01001001b & 10010010b = 00000000b
-01001001b & 10010011b = 00000001b
-01001001b & 10010100b = 00000000b
-01001001b & 10010101b = 00000001b
-01001001b & 10010110b = 00000000b
-01001001b & 10010111b = 00000001b
-01001001b & 10011000b = 00001000b
-01001001b & 10011001b = 00001001b
-01001001b & 10011010b = 00001000b
-01001001b & 10011011b = 00001001b
-01001001b & 10011100b = 00001000b
-01001001b & 10011101b = 00001001b
-01001001b & 10011110b = 00001000b
-01001001b & 10011111b = 00001001b
-01001001b & 10100000b = 00000000b
-01001001b & 10100001b = 00000001b
-01001001b & 10100010b = 00000000b
-01001001b & 10100011b = 00000001b
-01001001b & 10100100b = 00000000b
-01001001b & 10100101b = 00000001b
-01001001b & 10100110b = 00000000b
-01001001b & 10100111b = 00000001b
-01001001b & 10101000b = 00001000b
-01001001b & 10101001b = 00001001b
-01001001b & 10101010b = 00001000b
-01001001b & 10101011b = 00001001b
-01001001b & 10101100b = 00001000b
-01001001b & 10101101b = 00001001b
-01001001b & 10101110b = 00001000b
-01001001b & 10101111b = 00001001b
-01001001b & 10110000b = 00000000b
-01001001b & 10110001b = 00000001b
-01001001b & 10110010b = 00000000b
-01001001b & 10110011b = 00000001b
-01001001b & 10110100b = 00000000b
-01001001b & 10110101b = 00000001b
-01001001b & 10110110b = 00000000b
-01001001b & 10110111b = 00000001b
-01001001b & 10111000b = 00001000b
-01001001b & 10111001b = 00001001b
-01001001b & 10111010b = 00001000b
-01001001b & 10111011b = 00001001b
-01001001b & 10111100b = 00001000b
-01001001b & 10111101b = 00001001b
-01001001b & 10111110b = 00001000b
-01001001b & 10111111b = 00001001b
-01001001b & 11000000b = 01000000b
-01001001b & 11000001b = 01000001b
-01001001b & 11000010b = 01000000b
-01001001b & 11000011b = 01000001b
-01001001b & 11000100b = 01000000b
-01001001b & 11000101b = 01000001b
-01001001b & 11000110b = 01000000b
-01001001b & 11000111b = 01000001b
-01001001b & 11001000b = 01001000b
-01001001b & 11001001b = 01001001b
-01001001b & 11001010b = 01001000b
-01001001b & 11001011b = 01001001b
-01001001b & 11001100b = 01001000b
-01001001b & 11001101b = 01001001b
-01001001b & 11001110b = 01001000b
-01001001b & 11001111b = 01001001b
-01001001b & 11010000b = 01000000b
-01001001b & 11010001b = 01000001b
-01001001b & 11010010b = 01000000b
-01001001b & 11010011b = 01000001b
-01001001b & 11010100b = 01000000b
-01001001b & 11010101b = 01000001b
-01001001b & 11010110b = 01000000b
-01001001b & 11010111b = 01000001b
-01001001b & 11011000b = 01001000b
-01001001b & 11011001b = 01001001b
-01001001b & 11011010b = 01001000b
-01001001b & 11011011b = 01001001b
-01001001b & 11011100b = 01001000b
-01001001b & 11011101b = 01001001b
-01001001b & 11011110b = 01001000b
-01001001b & 11011111b = 01001001b
-01001001b & 11100000b = 01000000b
-01001001b & 11100001b = 01000001b
-01001001b & 11100010b = 01000000b
-01001001b & 11100011b = 01000001b
-01001001b & 11100100b = 01000000b
-01001001b & 11100101b = 01000001b
-01001001b & 11100110b = 01000000b
-01001001b & 11100111b = 01000001b
-01001001b & 11101000b = 01001000b
-01001001b & 11101001b = 01001001b
-01001001b & 11101010b = 01001000b
-01001001b & 11101011b = 01001001b
-01001001b & 11101100b = 01001000b
-01001001b & 11101101b = 01001001b
-01001001b & 11101110b = 01001000b
-01001001b & 11101111b = 01001001b
-01001001b & 11110000b = 01000000b
-01001001b & 11110001b = 01000001b
-01001001b & 11110010b = 01000000b
-01001001b & 11110011b = 01000001b
-01001001b & 11110100b = 01000000b
-01001001b & 11110101b = 01000001b
-01001001b & 11110110b = 01000000b
-01001001b & 11110111b = 01000001b
-01001001b & 11111000b = 01001000b
-01001001b & 11111001b = 01001001b
-01001001b & 11111010b = 01001000b
-01001001b & 11111011b = 01001001b
-01001001b & 11111100b = 01001000b
-01001001b & 11111101b = 01001001b
-01001001b & 11111110b = 01001000b
-01001001b & 11111111b = 01001001b
-01001001b & 00000000b = 00000000b
-01001001b & 00000001b = 00000001b
-01001001b & 00000010b = 00000000b
-01001001b & 00000011b = 00000001b
-01001001b & 00000100b = 00000000b
-01001001b & 00000101b = 00000001b
-01001001b & 00000110b = 00000000b
-01001001b & 00000111b = 00000001b
-01001001b & 00001000b = 00001000b
-01001001b & 00001001b = 00001001b
-01001001b & 00001010b = 00001000b
-01001001b & 00001011b = 00001001b
-01001001b & 00001100b = 00001000b
-01001001b & 00001101b = 00001001b
-01001001b & 00001110b = 00001000b
-01001001b & 00001111b = 00001001b
-01001001b & 00010000b = 00000000b
-01001001b & 00010001b = 00000001b
-01001001b & 00010010b = 00000000b
-01001001b & 00010011b = 00000001b
-01001001b & 00010100b = 00000000b
-01001001b & 00010101b = 00000001b
-01001001b & 00010110b = 00000000b
-01001001b & 00010111b = 00000001b
-01001001b & 00011000b = 00001000b
-01001001b & 00011001b = 00001001b
-01001001b & 00011010b = 00001000b
-01001001b & 00011011b = 00001001b
-01001001b & 00011100b = 00001000b
-01001001b & 00011101b = 00001001b
-01001001b & 00011110b = 00001000b
-01001001b & 00011111b = 00001001b
-01001001b & 00100000b = 00000000b
-01001001b & 00100001b = 00000001b
-01001001b & 00100010b = 00000000b
-01001001b & 00100011b = 00000001b
-01001001b & 00100100b = 00000000b
-01001001b & 00100101b = 00000001b
-01001001b & 00100110b = 00000000b
-01001001b & 00100111b = 00000001b
-01001001b & 00101000b = 00001000b
-01001001b & 00101001b = 00001001b
-01001001b & 00101010b = 00001000b
-01001001b & 00101011b = 00001001b
-01001001b & 00101100b = 00001000b
-01001001b & 00101101b = 00001001b
-01001001b & 00101110b = 00001000b
-01001001b & 00101111b = 00001001b
-01001001b & 00110000b = 00000000b
-01001001b & 00110001b = 00000001b
-01001001b & 00110010b = 00000000b
-01001001b & 00110011b = 00000001b
-01001001b & 00110100b = 00000000b
-01001001b & 00110101b = 00000001b
-01001001b & 00110110b = 00000000b
-01001001b & 00110111b = 00000001b
-01001001b & 00111000b = 00001000b
-01001001b & 00111001b = 00001001b
-01001001b & 00111010b = 00001000b
-01001001b & 00111011b = 00001001b
-01001001b & 00111100b = 00001000b
-01001001b & 00111101b = 00001001b
-01001001b & 00111110b = 00001000b
-01001001b & 00111111b = 00001001b
-01001001b & 01000000b = 01000000b
-01001001b & 01000001b = 01000001b
-01001001b & 01000010b = 01000000b
-01001001b & 01000011b = 01000001b
-01001001b & 01000100b = 01000000b
-01001001b & 01000101b = 01000001b
-01001001b & 01000110b = 01000000b
-01001001b & 01000111b = 01000001b
-01001001b & 01001000b = 01001000b
-01001001b & 01001001b = 01001001b
-01001001b & 01001010b = 01001000b
-01001001b & 01001011b = 01001001b
-01001001b & 01001100b = 01001000b
-01001001b & 01001101b = 01001001b
-01001001b & 01001110b = 01001000b
-01001001b & 01001111b = 01001001b
-01001001b & 01010000b = 01000000b
-01001001b & 01010001b = 01000001b
-01001001b & 01010010b = 01000000b
-01001001b & 01010011b = 01000001b
-01001001b & 01010100b = 01000000b
-01001001b & 01010101b = 01000001b
-01001001b & 01010110b = 01000000b
-01001001b & 01010111b = 01000001b
-01001001b & 01011000b = 01001000b
-01001001b & 01011001b = 01001001b
-01001001b & 01011010b = 01001000b
-01001001b & 01011011b = 01001001b
-01001001b & 01011100b = 01001000b
-01001001b & 01011101b = 01001001b
-01001001b & 01011110b = 01001000b
-01001001b & 01011111b = 01001001b
-01001001b & 01100000b = 01000000b
-01001001b & 01100001b = 01000001b
-01001001b & 01100010b = 01000000b
-01001001b & 01100011b = 01000001b
-01001001b & 01100100b = 01000000b
-01001001b & 01100101b = 01000001b
-01001001b & 01100110b = 01000000b
-01001001b & 01100111b = 01000001b
-01001001b & 01101000b = 01001000b
-01001001b & 01101001b = 01001001b
-01001001b & 01101010b = 01001000b
-01001001b & 01101011b = 01001001b
-01001001b & 01101100b = 01001000b
-01001001b & 01101101b = 01001001b
-01001001b & 01101110b = 01001000b
-01001001b & 01101111b = 01001001b
-01001001b & 01110000b = 01000000b
-01001001b & 01110001b = 01000001b
-01001001b & 01110010b = 01000000b
-01001001b & 01110011b = 01000001b
-01001001b & 01110100b = 01000000b
-01001001b & 01110101b = 01000001b
-01001001b & 01110110b = 01000000b
-01001001b & 01110111b = 01000001b
-01001001b & 01111000b = 01001000b
-01001001b & 01111001b = 01001001b
-01001001b & 01111010b = 01001000b
-01001001b & 01111011b = 01001001b
-01001001b & 01111100b = 01001000b
-01001001b & 01111101b = 01001001b
-01001001b & 01111110b = 01001000b
-01001010b & 10000000b = 00000000b
-01001010b & 10000001b = 00000000b
-01001010b & 10000010b = 00000010b
-01001010b & 10000011b = 00000010b
-01001010b & 10000100b = 00000000b
-01001010b & 10000101b = 00000000b
-01001010b & 10000110b = 00000010b
-01001010b & 10000111b = 00000010b
-01001010b & 10001000b = 00001000b
-01001010b & 10001001b = 00001000b
-01001010b & 10001010b = 00001010b
-01001010b & 10001011b = 00001010b
-01001010b & 10001100b = 00001000b
-01001010b & 10001101b = 00001000b
-01001010b & 10001110b = 00001010b
-01001010b & 10001111b = 00001010b
-01001010b & 10010000b = 00000000b
-01001010b & 10010001b = 00000000b
-01001010b & 10010010b = 00000010b
-01001010b & 10010011b = 00000010b
-01001010b & 10010100b = 00000000b
-01001010b & 10010101b = 00000000b
-01001010b & 10010110b = 00000010b
-01001010b & 10010111b = 00000010b
-01001010b & 10011000b = 00001000b
-01001010b & 10011001b = 00001000b
-01001010b & 10011010b = 00001010b
-01001010b & 10011011b = 00001010b
-01001010b & 10011100b = 00001000b
-01001010b & 10011101b = 00001000b
-01001010b & 10011110b = 00001010b
-01001010b & 10011111b = 00001010b
-01001010b & 10100000b = 00000000b
-01001010b & 10100001b = 00000000b
-01001010b & 10100010b = 00000010b
-01001010b & 10100011b = 00000010b
-01001010b & 10100100b = 00000000b
-01001010b & 10100101b = 00000000b
-01001010b & 10100110b = 00000010b
-01001010b & 10100111b = 00000010b
-01001010b & 10101000b = 00001000b
-01001010b & 10101001b = 00001000b
-01001010b & 10101010b = 00001010b
-01001010b & 10101011b = 00001010b
-01001010b & 10101100b = 00001000b
-01001010b & 10101101b = 00001000b
-01001010b & 10101110b = 00001010b
-01001010b & 10101111b = 00001010b
-01001010b & 10110000b = 00000000b
-01001010b & 10110001b = 00000000b
-01001010b & 10110010b = 00000010b
-01001010b & 10110011b = 00000010b
-01001010b & 10110100b = 00000000b
-01001010b & 10110101b = 00000000b
-01001010b & 10110110b = 00000010b
-01001010b & 10110111b = 00000010b
-01001010b & 10111000b = 00001000b
-01001010b & 10111001b = 00001000b
-01001010b & 10111010b = 00001010b
-01001010b & 10111011b = 00001010b
-01001010b & 10111100b = 00001000b
-01001010b & 10111101b = 00001000b
-01001010b & 10111110b = 00001010b
-01001010b & 10111111b = 00001010b
-01001010b & 11000000b = 01000000b
-01001010b & 11000001b = 01000000b
-01001010b & 11000010b = 01000010b
-01001010b & 11000011b = 01000010b
-01001010b & 11000100b = 01000000b
-01001010b & 11000101b = 01000000b
-01001010b & 11000110b = 01000010b
-01001010b & 11000111b = 01000010b
-01001010b & 11001000b = 01001000b
-01001010b & 11001001b = 01001000b
-01001010b & 11001010b = 01001010b
-01001010b & 11001011b = 01001010b
-01001010b & 11001100b = 01001000b
-01001010b & 11001101b = 01001000b
-01001010b & 11001110b = 01001010b
-01001010b & 11001111b = 01001010b
-01001010b & 11010000b = 01000000b
-01001010b & 11010001b = 01000000b
-01001010b & 11010010b = 01000010b
-01001010b & 11010011b = 01000010b
-01001010b & 11010100b = 01000000b
-01001010b & 11010101b = 01000000b
-01001010b & 11010110b = 01000010b
-01001010b & 11010111b = 01000010b
-01001010b & 11011000b = 01001000b
-01001010b & 11011001b = 01001000b
-01001010b & 11011010b = 01001010b
-01001010b & 11011011b = 01001010b
-01001010b & 11011100b = 01001000b
-01001010b & 11011101b = 01001000b
-01001010b & 11011110b = 01001010b
-01001010b & 11011111b = 01001010b
-01001010b & 11100000b = 01000000b
-01001010b & 11100001b = 01000000b
-01001010b & 11100010b = 01000010b
-01001010b & 11100011b = 01000010b
-01001010b & 11100100b = 01000000b
-01001010b & 11100101b = 01000000b
-01001010b & 11100110b = 01000010b
-01001010b & 11100111b = 01000010b
-01001010b & 11101000b = 01001000b
-01001010b & 11101001b = 01001000b
-01001010b & 11101010b = 01001010b
-01001010b & 11101011b = 01001010b
-01001010b & 11101100b = 01001000b
-01001010b & 11101101b = 01001000b
-01001010b & 11101110b = 01001010b
-01001010b & 11101111b = 01001010b
-01001010b & 11110000b = 01000000b
-01001010b & 11110001b = 01000000b
-01001010b & 11110010b = 01000010b
-01001010b & 11110011b = 01000010b
-01001010b & 11110100b = 01000000b
-01001010b & 11110101b = 01000000b
-01001010b & 11110110b = 01000010b
-01001010b & 11110111b = 01000010b
-01001010b & 11111000b = 01001000b
-01001010b & 11111001b = 01001000b
-01001010b & 11111010b = 01001010b
-01001010b & 11111011b = 01001010b
-01001010b & 11111100b = 01001000b
-01001010b & 11111101b = 01001000b
-01001010b & 11111110b = 01001010b
-01001010b & 11111111b = 01001010b
-01001010b & 00000000b = 00000000b
-01001010b & 00000001b = 00000000b
-01001010b & 00000010b = 00000010b
-01001010b & 00000011b = 00000010b
-01001010b & 00000100b = 00000000b
-01001010b & 00000101b = 00000000b
-01001010b & 00000110b = 00000010b
-01001010b & 00000111b = 00000010b
-01001010b & 00001000b = 00001000b
-01001010b & 00001001b = 00001000b
-01001010b & 00001010b = 00001010b
-01001010b & 00001011b = 00001010b
-01001010b & 00001100b = 00001000b
-01001010b & 00001101b = 00001000b
-01001010b & 00001110b = 00001010b
-01001010b & 00001111b = 00001010b
-01001010b & 00010000b = 00000000b
-01001010b & 00010001b = 00000000b
-01001010b & 00010010b = 00000010b
-01001010b & 00010011b = 00000010b
-01001010b & 00010100b = 00000000b
-01001010b & 00010101b = 00000000b
-01001010b & 00010110b = 00000010b
-01001010b & 00010111b = 00000010b
-01001010b & 00011000b = 00001000b
-01001010b & 00011001b = 00001000b
-01001010b & 00011010b = 00001010b
-01001010b & 00011011b = 00001010b
-01001010b & 00011100b = 00001000b
-01001010b & 00011101b = 00001000b
-01001010b & 00011110b = 00001010b
-01001010b & 00011111b = 00001010b
-01001010b & 00100000b = 00000000b
-01001010b & 00100001b = 00000000b
-01001010b & 00100010b = 00000010b
-01001010b & 00100011b = 00000010b
-01001010b & 00100100b = 00000000b
-01001010b & 00100101b = 00000000b
-01001010b & 00100110b = 00000010b
-01001010b & 00100111b = 00000010b
-01001010b & 00101000b = 00001000b
-01001010b & 00101001b = 00001000b
-01001010b & 00101010b = 00001010b
-01001010b & 00101011b = 00001010b
-01001010b & 00101100b = 00001000b
-01001010b & 00101101b = 00001000b
-01001010b & 00101110b = 00001010b
-01001010b & 00101111b = 00001010b
-01001010b & 00110000b = 00000000b
-01001010b & 00110001b = 00000000b
-01001010b & 00110010b = 00000010b
-01001010b & 00110011b = 00000010b
-01001010b & 00110100b = 00000000b
-01001010b & 00110101b = 00000000b
-01001010b & 00110110b = 00000010b
-01001010b & 00110111b = 00000010b
-01001010b & 00111000b = 00001000b
-01001010b & 00111001b = 00001000b
-01001010b & 00111010b = 00001010b
-01001010b & 00111011b = 00001010b
-01001010b & 00111100b = 00001000b
-01001010b & 00111101b = 00001000b
-01001010b & 00111110b = 00001010b
-01001010b & 00111111b = 00001010b
-01001010b & 01000000b = 01000000b
-01001010b & 01000001b = 01000000b
-01001010b & 01000010b = 01000010b
-01001010b & 01000011b = 01000010b
-01001010b & 01000100b = 01000000b
-01001010b & 01000101b = 01000000b
-01001010b & 01000110b = 01000010b
-01001010b & 01000111b = 01000010b
-01001010b & 01001000b = 01001000b
-01001010b & 01001001b = 01001000b
-01001010b & 01001010b = 01001010b
-01001010b & 01001011b = 01001010b
-01001010b & 01001100b = 01001000b
-01001010b & 01001101b = 01001000b
-01001010b & 01001110b = 01001010b
-01001010b & 01001111b = 01001010b
-01001010b & 01010000b = 01000000b
-01001010b & 01010001b = 01000000b
-01001010b & 01010010b = 01000010b
-01001010b & 01010011b = 01000010b
-01001010b & 01010100b = 01000000b
-01001010b & 01010101b = 01000000b
-01001010b & 01010110b = 01000010b
-01001010b & 01010111b = 01000010b
-01001010b & 01011000b = 01001000b
-01001010b & 01011001b = 01001000b
-01001010b & 01011010b = 01001010b
-01001010b & 01011011b = 01001010b
-01001010b & 01011100b = 01001000b
-01001010b & 01011101b = 01001000b
-01001010b & 01011110b = 01001010b
-01001010b & 01011111b = 01001010b
-01001010b & 01100000b = 01000000b
-01001010b & 01100001b = 01000000b
-01001010b & 01100010b = 01000010b
-01001010b & 01100011b = 01000010b
-01001010b & 01100100b = 01000000b
-01001010b & 01100101b = 01000000b
-01001010b & 01100110b = 01000010b
-01001010b & 01100111b = 01000010b
-01001010b & 01101000b = 01001000b
-01001010b & 01101001b = 01001000b
-01001010b & 01101010b = 01001010b
-01001010b & 01101011b = 01001010b
-01001010b & 01101100b = 01001000b
-01001010b & 01101101b = 01001000b
-01001010b & 01101110b = 01001010b
-01001010b & 01101111b = 01001010b
-01001010b & 01110000b = 01000000b
-01001010b & 01110001b = 01000000b
-01001010b & 01110010b = 01000010b
-01001010b & 01110011b = 01000010b
-01001010b & 01110100b = 01000000b
-01001010b & 01110101b = 01000000b
-01001010b & 01110110b = 01000010b
-01001010b & 01110111b = 01000010b
-01001010b & 01111000b = 01001000b
-01001010b & 01111001b = 01001000b
-01001010b & 01111010b = 01001010b
-01001010b & 01111011b = 01001010b
-01001010b & 01111100b = 01001000b
-01001010b & 01111101b = 01001000b
-01001010b & 01111110b = 01001010b
-01001011b & 10000000b = 00000000b
-01001011b & 10000001b = 00000001b
-01001011b & 10000010b = 00000010b
-01001011b & 10000011b = 00000011b
-01001011b & 10000100b = 00000000b
-01001011b & 10000101b = 00000001b
-01001011b & 10000110b = 00000010b
-01001011b & 10000111b = 00000011b
-01001011b & 10001000b = 00001000b
-01001011b & 10001001b = 00001001b
-01001011b & 10001010b = 00001010b
-01001011b & 10001011b = 00001011b
-01001011b & 10001100b = 00001000b
-01001011b & 10001101b = 00001001b
-01001011b & 10001110b = 00001010b
-01001011b & 10001111b = 00001011b
-01001011b & 10010000b = 00000000b
-01001011b & 10010001b = 00000001b
-01001011b & 10010010b = 00000010b
-01001011b & 10010011b = 00000011b
-01001011b & 10010100b = 00000000b
-01001011b & 10010101b = 00000001b
-01001011b & 10010110b = 00000010b
-01001011b & 10010111b = 00000011b
-01001011b & 10011000b = 00001000b
-01001011b & 10011001b = 00001001b
-01001011b & 10011010b = 00001010b
-01001011b & 10011011b = 00001011b
-01001011b & 10011100b = 00001000b
-01001011b & 10011101b = 00001001b
-01001011b & 10011110b = 00001010b
-01001011b & 10011111b = 00001011b
-01001011b & 10100000b = 00000000b
-01001011b & 10100001b = 00000001b
-01001011b & 10100010b = 00000010b
-01001011b & 10100011b = 00000011b
-01001011b & 10100100b = 00000000b
-01001011b & 10100101b = 00000001b
-01001011b & 10100110b = 00000010b
-01001011b & 10100111b = 00000011b
-01001011b & 10101000b = 00001000b
-01001011b & 10101001b = 00001001b
-01001011b & 10101010b = 00001010b
-01001011b & 10101011b = 00001011b
-01001011b & 10101100b = 00001000b
-01001011b & 10101101b = 00001001b
-01001011b & 10101110b = 00001010b
-01001011b & 10101111b = 00001011b
-01001011b & 10110000b = 00000000b
-01001011b & 10110001b = 00000001b
-01001011b & 10110010b = 00000010b
-01001011b & 10110011b = 00000011b
-01001011b & 10110100b = 00000000b
-01001011b & 10110101b = 00000001b
-01001011b & 10110110b = 00000010b
-01001011b & 10110111b = 00000011b
-01001011b & 10111000b = 00001000b
-01001011b & 10111001b = 00001001b
-01001011b & 10111010b = 00001010b
-01001011b & 10111011b = 00001011b
-01001011b & 10111100b = 00001000b
-01001011b & 10111101b = 00001001b
-01001011b & 10111110b = 00001010b
-01001011b & 10111111b = 00001011b
-01001011b & 11000000b = 01000000b
-01001011b & 11000001b = 01000001b
-01001011b & 11000010b = 01000010b
-01001011b & 11000011b = 01000011b
-01001011b & 11000100b = 01000000b
-01001011b & 11000101b = 01000001b
-01001011b & 11000110b = 01000010b
-01001011b & 11000111b = 01000011b
-01001011b & 11001000b = 01001000b
-01001011b & 11001001b = 01001001b
-01001011b & 11001010b = 01001010b
-01001011b & 11001011b = 01001011b
-01001011b & 11001100b = 01001000b
-01001011b & 11001101b = 01001001b
-01001011b & 11001110b = 01001010b
-01001011b & 11001111b = 01001011b
-01001011b & 11010000b = 01000000b
-01001011b & 11010001b = 01000001b
-01001011b & 11010010b = 01000010b
-01001011b & 11010011b = 01000011b
-01001011b & 11010100b = 01000000b
-01001011b & 11010101b = 01000001b
-01001011b & 11010110b = 01000010b
-01001011b & 11010111b = 01000011b
-01001011b & 11011000b = 01001000b
-01001011b & 11011001b = 01001001b
-01001011b & 11011010b = 01001010b
-01001011b & 11011011b = 01001011b
-01001011b & 11011100b = 01001000b
-01001011b & 11011101b = 01001001b
-01001011b & 11011110b = 01001010b
-01001011b & 11011111b = 01001011b
-01001011b & 11100000b = 01000000b
-01001011b & 11100001b = 01000001b
-01001011b & 11100010b = 01000010b
-01001011b & 11100011b = 01000011b
-01001011b & 11100100b = 01000000b
-01001011b & 11100101b = 01000001b
-01001011b & 11100110b = 01000010b
-01001011b & 11100111b = 01000011b
-01001011b & 11101000b = 01001000b
-01001011b & 11101001b = 01001001b
-01001011b & 11101010b = 01001010b
-01001011b & 11101011b = 01001011b
-01001011b & 11101100b = 01001000b
-01001011b & 11101101b = 01001001b
-01001011b & 11101110b = 01001010b
-01001011b & 11101111b = 01001011b
-01001011b & 11110000b = 01000000b
-01001011b & 11110001b = 01000001b
-01001011b & 11110010b = 01000010b
-01001011b & 11110011b = 01000011b
-01001011b & 11110100b = 01000000b
-01001011b & 11110101b = 01000001b
-01001011b & 11110110b = 01000010b
-01001011b & 11110111b = 01000011b
-01001011b & 11111000b = 01001000b
-01001011b & 11111001b = 01001001b
-01001011b & 11111010b = 01001010b
-01001011b & 11111011b = 01001011b
-01001011b & 11111100b = 01001000b
-01001011b & 11111101b = 01001001b
-01001011b & 11111110b = 01001010b
-01001011b & 11111111b = 01001011b
-01001011b & 00000000b = 00000000b
-01001011b & 00000001b = 00000001b
-01001011b & 00000010b = 00000010b
-01001011b & 00000011b = 00000011b
-01001011b & 00000100b = 00000000b
-01001011b & 00000101b = 00000001b
-01001011b & 00000110b = 00000010b
-01001011b & 00000111b = 00000011b
-01001011b & 00001000b = 00001000b
-01001011b & 00001001b = 00001001b
-01001011b & 00001010b = 00001010b
-01001011b & 00001011b = 00001011b
-01001011b & 00001100b = 00001000b
-01001011b & 00001101b = 00001001b
-01001011b & 00001110b = 00001010b
-01001011b & 00001111b = 00001011b
-01001011b & 00010000b = 00000000b
-01001011b & 00010001b = 00000001b
-01001011b & 00010010b = 00000010b
-01001011b & 00010011b = 00000011b
-01001011b & 00010100b = 00000000b
-01001011b & 00010101b = 00000001b
-01001011b & 00010110b = 00000010b
-01001011b & 00010111b = 00000011b
-01001011b & 00011000b = 00001000b
-01001011b & 00011001b = 00001001b
-01001011b & 00011010b = 00001010b
-01001011b & 00011011b = 00001011b
-01001011b & 00011100b = 00001000b
-01001011b & 00011101b = 00001001b
-01001011b & 00011110b = 00001010b
-01001011b & 00011111b = 00001011b
-01001011b & 00100000b = 00000000b
-01001011b & 00100001b = 00000001b
-01001011b & 00100010b = 00000010b
-01001011b & 00100011b = 00000011b
-01001011b & 00100100b = 00000000b
-01001011b & 00100101b = 00000001b
-01001011b & 00100110b = 00000010b
-01001011b & 00100111b = 00000011b
-01001011b & 00101000b = 00001000b
-01001011b & 00101001b = 00001001b
-01001011b & 00101010b = 00001010b
-01001011b & 00101011b = 00001011b
-01001011b & 00101100b = 00001000b
-01001011b & 00101101b = 00001001b
-01001011b & 00101110b = 00001010b
-01001011b & 00101111b = 00001011b
-01001011b & 00110000b = 00000000b
-01001011b & 00110001b = 00000001b
-01001011b & 00110010b = 00000010b
-01001011b & 00110011b = 00000011b
-01001011b & 00110100b = 00000000b
-01001011b & 00110101b = 00000001b
-01001011b & 00110110b = 00000010b
-01001011b & 00110111b = 00000011b
-01001011b & 00111000b = 00001000b
-01001011b & 00111001b = 00001001b
-01001011b & 00111010b = 00001010b
-01001011b & 00111011b = 00001011b
-01001011b & 00111100b = 00001000b
-01001011b & 00111101b = 00001001b
-01001011b & 00111110b = 00001010b
-01001011b & 00111111b = 00001011b
-01001011b & 01000000b = 01000000b
-01001011b & 01000001b = 01000001b
-01001011b & 01000010b = 01000010b
-01001011b & 01000011b = 01000011b
-01001011b & 01000100b = 01000000b
-01001011b & 01000101b = 01000001b
-01001011b & 01000110b = 01000010b
-01001011b & 01000111b = 01000011b
-01001011b & 01001000b = 01001000b
-01001011b & 01001001b = 01001001b
-01001011b & 01001010b = 01001010b
-01001011b & 01001011b = 01001011b
-01001011b & 01001100b = 01001000b
-01001011b & 01001101b = 01001001b
-01001011b & 01001110b = 01001010b
-01001011b & 01001111b = 01001011b
-01001011b & 01010000b = 01000000b
-01001011b & 01010001b = 01000001b
-01001011b & 01010010b = 01000010b
-01001011b & 01010011b = 01000011b
-01001011b & 01010100b = 01000000b
-01001011b & 01010101b = 01000001b
-01001011b & 01010110b = 01000010b
-01001011b & 01010111b = 01000011b
-01001011b & 01011000b = 01001000b
-01001011b & 01011001b = 01001001b
-01001011b & 01011010b = 01001010b
-01001011b & 01011011b = 01001011b
-01001011b & 01011100b = 01001000b
-01001011b & 01011101b = 01001001b
-01001011b & 01011110b = 01001010b
-01001011b & 01011111b = 01001011b
-01001011b & 01100000b = 01000000b
-01001011b & 01100001b = 01000001b
-01001011b & 01100010b = 01000010b
-01001011b & 01100011b = 01000011b
-01001011b & 01100100b = 01000000b
-01001011b & 01100101b = 01000001b
-01001011b & 01100110b = 01000010b
-01001011b & 01100111b = 01000011b
-01001011b & 01101000b = 01001000b
-01001011b & 01101001b = 01001001b
-01001011b & 01101010b = 01001010b
-01001011b & 01101011b = 01001011b
-01001011b & 01101100b = 01001000b
-01001011b & 01101101b = 01001001b
-01001011b & 01101110b = 01001010b
-01001011b & 01101111b = 01001011b
-01001011b & 01110000b = 01000000b
-01001011b & 01110001b = 01000001b
-01001011b & 01110010b = 01000010b
-01001011b & 01110011b = 01000011b
-01001011b & 01110100b = 01000000b
-01001011b & 01110101b = 01000001b
-01001011b & 01110110b = 01000010b
-01001011b & 01110111b = 01000011b
-01001011b & 01111000b = 01001000b
-01001011b & 01111001b = 01001001b
-01001011b & 01111010b = 01001010b
-01001011b & 01111011b = 01001011b
-01001011b & 01111100b = 01001000b
-01001011b & 01111101b = 01001001b
-01001011b & 01111110b = 01001010b
-01001100b & 10000000b = 00000000b
-01001100b & 10000001b = 00000000b
-01001100b & 10000010b = 00000000b
-01001100b & 10000011b = 00000000b
-01001100b & 10000100b = 00000100b
-01001100b & 10000101b = 00000100b
-01001100b & 10000110b = 00000100b
-01001100b & 10000111b = 00000100b
-01001100b & 10001000b = 00001000b
-01001100b & 10001001b = 00001000b
-01001100b & 10001010b = 00001000b
-01001100b & 10001011b = 00001000b
-01001100b & 10001100b = 00001100b
-01001100b & 10001101b = 00001100b
-01001100b & 10001110b = 00001100b
-01001100b & 10001111b = 00001100b
-01001100b & 10010000b = 00000000b
-01001100b & 10010001b = 00000000b
-01001100b & 10010010b = 00000000b
-01001100b & 10010011b = 00000000b
-01001100b & 10010100b = 00000100b
-01001100b & 10010101b = 00000100b
-01001100b & 10010110b = 00000100b
-01001100b & 10010111b = 00000100b
-01001100b & 10011000b = 00001000b
-01001100b & 10011001b = 00001000b
-01001100b & 10011010b = 00001000b
-01001100b & 10011011b = 00001000b
-01001100b & 10011100b = 00001100b
-01001100b & 10011101b = 00001100b
-01001100b & 10011110b = 00001100b
-01001100b & 10011111b = 00001100b
-01001100b & 10100000b = 00000000b
-01001100b & 10100001b = 00000000b
-01001100b & 10100010b = 00000000b
-01001100b & 10100011b = 00000000b
-01001100b & 10100100b = 00000100b
-01001100b & 10100101b = 00000100b
-01001100b & 10100110b = 00000100b
-01001100b & 10100111b = 00000100b
-01001100b & 10101000b = 00001000b
-01001100b & 10101001b = 00001000b
-01001100b & 10101010b = 00001000b
-01001100b & 10101011b = 00001000b
-01001100b & 10101100b = 00001100b
-01001100b & 10101101b = 00001100b
-01001100b & 10101110b = 00001100b
-01001100b & 10101111b = 00001100b
-01001100b & 10110000b = 00000000b
-01001100b & 10110001b = 00000000b
-01001100b & 10110010b = 00000000b
-01001100b & 10110011b = 00000000b
-01001100b & 10110100b = 00000100b
-01001100b & 10110101b = 00000100b
-01001100b & 10110110b = 00000100b
-01001100b & 10110111b = 00000100b
-01001100b & 10111000b = 00001000b
-01001100b & 10111001b = 00001000b
-01001100b & 10111010b = 00001000b
-01001100b & 10111011b = 00001000b
-01001100b & 10111100b = 00001100b
-01001100b & 10111101b = 00001100b
-01001100b & 10111110b = 00001100b
-01001100b & 10111111b = 00001100b
-01001100b & 11000000b = 01000000b
-01001100b & 11000001b = 01000000b
-01001100b & 11000010b = 01000000b
-01001100b & 11000011b = 01000000b
-01001100b & 11000100b = 01000100b
-01001100b & 11000101b = 01000100b
-01001100b & 11000110b = 01000100b
-01001100b & 11000111b = 01000100b
-01001100b & 11001000b = 01001000b
-01001100b & 11001001b = 01001000b
-01001100b & 11001010b = 01001000b
-01001100b & 11001011b = 01001000b
-01001100b & 11001100b = 01001100b
-01001100b & 11001101b = 01001100b
-01001100b & 11001110b = 01001100b
-01001100b & 11001111b = 01001100b
-01001100b & 11010000b = 01000000b
-01001100b & 11010001b = 01000000b
-01001100b & 11010010b = 01000000b
-01001100b & 11010011b = 01000000b
-01001100b & 11010100b = 01000100b
-01001100b & 11010101b = 01000100b
-01001100b & 11010110b = 01000100b
-01001100b & 11010111b = 01000100b
-01001100b & 11011000b = 01001000b
-01001100b & 11011001b = 01001000b
-01001100b & 11011010b = 01001000b
-01001100b & 11011011b = 01001000b
-01001100b & 11011100b = 01001100b
-01001100b & 11011101b = 01001100b
-01001100b & 11011110b = 01001100b
-01001100b & 11011111b = 01001100b
-01001100b & 11100000b = 01000000b
-01001100b & 11100001b = 01000000b
-01001100b & 11100010b = 01000000b
-01001100b & 11100011b = 01000000b
-01001100b & 11100100b = 01000100b
-01001100b & 11100101b = 01000100b
-01001100b & 11100110b = 01000100b
-01001100b & 11100111b = 01000100b
-01001100b & 11101000b = 01001000b
-01001100b & 11101001b = 01001000b
-01001100b & 11101010b = 01001000b
-01001100b & 11101011b = 01001000b
-01001100b & 11101100b = 01001100b
-01001100b & 11101101b = 01001100b
-01001100b & 11101110b = 01001100b
-01001100b & 11101111b = 01001100b
-01001100b & 11110000b = 01000000b
-01001100b & 11110001b = 01000000b
-01001100b & 11110010b = 01000000b
-01001100b & 11110011b = 01000000b
-01001100b & 11110100b = 01000100b
-01001100b & 11110101b = 01000100b
-01001100b & 11110110b = 01000100b
-01001100b & 11110111b = 01000100b
-01001100b & 11111000b = 01001000b
-01001100b & 11111001b = 01001000b
-01001100b & 11111010b = 01001000b
-01001100b & 11111011b = 01001000b
-01001100b & 11111100b = 01001100b
-01001100b & 11111101b = 01001100b
-01001100b & 11111110b = 01001100b
-01001100b & 11111111b = 01001100b
-01001100b & 00000000b = 00000000b
-01001100b & 00000001b = 00000000b
-01001100b & 00000010b = 00000000b
-01001100b & 00000011b = 00000000b
-01001100b & 00000100b = 00000100b
-01001100b & 00000101b = 00000100b
-01001100b & 00000110b = 00000100b
-01001100b & 00000111b = 00000100b
-01001100b & 00001000b = 00001000b
-01001100b & 00001001b = 00001000b
-01001100b & 00001010b = 00001000b
-01001100b & 00001011b = 00001000b
-01001100b & 00001100b = 00001100b
-01001100b & 00001101b = 00001100b
-01001100b & 00001110b = 00001100b
-01001100b & 00001111b = 00001100b
-01001100b & 00010000b = 00000000b
-01001100b & 00010001b = 00000000b
-01001100b & 00010010b = 00000000b
-01001100b & 00010011b = 00000000b
-01001100b & 00010100b = 00000100b
-01001100b & 00010101b = 00000100b
-01001100b & 00010110b = 00000100b
-01001100b & 00010111b = 00000100b
-01001100b & 00011000b = 00001000b
-01001100b & 00011001b = 00001000b
-01001100b & 00011010b = 00001000b
-01001100b & 00011011b = 00001000b
-01001100b & 00011100b = 00001100b
-01001100b & 00011101b = 00001100b
-01001100b & 00011110b = 00001100b
-01001100b & 00011111b = 00001100b
-01001100b & 00100000b = 00000000b
-01001100b & 00100001b = 00000000b
-01001100b & 00100010b = 00000000b
-01001100b & 00100011b = 00000000b
-01001100b & 00100100b = 00000100b
-01001100b & 00100101b = 00000100b
-01001100b & 00100110b = 00000100b
-01001100b & 00100111b = 00000100b
-01001100b & 00101000b = 00001000b
-01001100b & 00101001b = 00001000b
-01001100b & 00101010b = 00001000b
-01001100b & 00101011b = 00001000b
-01001100b & 00101100b = 00001100b
-01001100b & 00101101b = 00001100b
-01001100b & 00101110b = 00001100b
-01001100b & 00101111b = 00001100b
-01001100b & 00110000b = 00000000b
-01001100b & 00110001b = 00000000b
-01001100b & 00110010b = 00000000b
-01001100b & 00110011b = 00000000b
-01001100b & 00110100b = 00000100b
-01001100b & 00110101b = 00000100b
-01001100b & 00110110b = 00000100b
-01001100b & 00110111b = 00000100b
-01001100b & 00111000b = 00001000b
-01001100b & 00111001b = 00001000b
-01001100b & 00111010b = 00001000b
-01001100b & 00111011b = 00001000b
-01001100b & 00111100b = 00001100b
-01001100b & 00111101b = 00001100b
-01001100b & 00111110b = 00001100b
-01001100b & 00111111b = 00001100b
-01001100b & 01000000b = 01000000b
-01001100b & 01000001b = 01000000b
-01001100b & 01000010b = 01000000b
-01001100b & 01000011b = 01000000b
-01001100b & 01000100b = 01000100b
-01001100b & 01000101b = 01000100b
-01001100b & 01000110b = 01000100b
-01001100b & 01000111b = 01000100b
-01001100b & 01001000b = 01001000b
-01001100b & 01001001b = 01001000b
-01001100b & 01001010b = 01001000b
-01001100b & 01001011b = 01001000b
-01001100b & 01001100b = 01001100b
-01001100b & 01001101b = 01001100b
-01001100b & 01001110b = 01001100b
-01001100b & 01001111b = 01001100b
-01001100b & 01010000b = 01000000b
-01001100b & 01010001b = 01000000b
-01001100b & 01010010b = 01000000b
-01001100b & 01010011b = 01000000b
-01001100b & 01010100b = 01000100b
-01001100b & 01010101b = 01000100b
-01001100b & 01010110b = 01000100b
-01001100b & 01010111b = 01000100b
-01001100b & 01011000b = 01001000b
-01001100b & 01011001b = 01001000b
-01001100b & 01011010b = 01001000b
-01001100b & 01011011b = 01001000b
-01001100b & 01011100b = 01001100b
-01001100b & 01011101b = 01001100b
-01001100b & 01011110b = 01001100b
-01001100b & 01011111b = 01001100b
-01001100b & 01100000b = 01000000b
-01001100b & 01100001b = 01000000b
-01001100b & 01100010b = 01000000b
-01001100b & 01100011b = 01000000b
-01001100b & 01100100b = 01000100b
-01001100b & 01100101b = 01000100b
-01001100b & 01100110b = 01000100b
-01001100b & 01100111b = 01000100b
-01001100b & 01101000b = 01001000b
-01001100b & 01101001b = 01001000b
-01001100b & 01101010b = 01001000b
-01001100b & 01101011b = 01001000b
-01001100b & 01101100b = 01001100b
-01001100b & 01101101b = 01001100b
-01001100b & 01101110b = 01001100b
-01001100b & 01101111b = 01001100b
-01001100b & 01110000b = 01000000b
-01001100b & 01110001b = 01000000b
-01001100b & 01110010b = 01000000b
-01001100b & 01110011b = 01000000b
-01001100b & 01110100b = 01000100b
-01001100b & 01110101b = 01000100b
-01001100b & 01110110b = 01000100b
-01001100b & 01110111b = 01000100b
-01001100b & 01111000b = 01001000b
-01001100b & 01111001b = 01001000b
-01001100b & 01111010b = 01001000b
-01001100b & 01111011b = 01001000b
-01001100b & 01111100b = 01001100b
-01001100b & 01111101b = 01001100b
-01001100b & 01111110b = 01001100b
-01001101b & 10000000b = 00000000b
-01001101b & 10000001b = 00000001b
-01001101b & 10000010b = 00000000b
-01001101b & 10000011b = 00000001b
-01001101b & 10000100b = 00000100b
-01001101b & 10000101b = 00000101b
-01001101b & 10000110b = 00000100b
-01001101b & 10000111b = 00000101b
-01001101b & 10001000b = 00001000b
-01001101b & 10001001b = 00001001b
-01001101b & 10001010b = 00001000b
-01001101b & 10001011b = 00001001b
-01001101b & 10001100b = 00001100b
-01001101b & 10001101b = 00001101b
-01001101b & 10001110b = 00001100b
-01001101b & 10001111b = 00001101b
-01001101b & 10010000b = 00000000b
-01001101b & 10010001b = 00000001b
-01001101b & 10010010b = 00000000b
-01001101b & 10010011b = 00000001b
-01001101b & 10010100b = 00000100b
-01001101b & 10010101b = 00000101b
-01001101b & 10010110b = 00000100b
-01001101b & 10010111b = 00000101b
-01001101b & 10011000b = 00001000b
-01001101b & 10011001b = 00001001b
-01001101b & 10011010b = 00001000b
-01001101b & 10011011b = 00001001b
-01001101b & 10011100b = 00001100b
-01001101b & 10011101b = 00001101b
-01001101b & 10011110b = 00001100b
-01001101b & 10011111b = 00001101b
-01001101b & 10100000b = 00000000b
-01001101b & 10100001b = 00000001b
-01001101b & 10100010b = 00000000b
-01001101b & 10100011b = 00000001b
-01001101b & 10100100b = 00000100b
-01001101b & 10100101b = 00000101b
-01001101b & 10100110b = 00000100b
-01001101b & 10100111b = 00000101b
-01001101b & 10101000b = 00001000b
-01001101b & 10101001b = 00001001b
-01001101b & 10101010b = 00001000b
-01001101b & 10101011b = 00001001b
-01001101b & 10101100b = 00001100b
-01001101b & 10101101b = 00001101b
-01001101b & 10101110b = 00001100b
-01001101b & 10101111b = 00001101b
-01001101b & 10110000b = 00000000b
-01001101b & 10110001b = 00000001b
-01001101b & 10110010b = 00000000b
-01001101b & 10110011b = 00000001b
-01001101b & 10110100b = 00000100b
-01001101b & 10110101b = 00000101b
-01001101b & 10110110b = 00000100b
-01001101b & 10110111b = 00000101b
-01001101b & 10111000b = 00001000b
-01001101b & 10111001b = 00001001b
-01001101b & 10111010b = 00001000b
-01001101b & 10111011b = 00001001b
-01001101b & 10111100b = 00001100b
-01001101b & 10111101b = 00001101b
-01001101b & 10111110b = 00001100b
-01001101b & 10111111b = 00001101b
-01001101b & 11000000b = 01000000b
-01001101b & 11000001b = 01000001b
-01001101b & 11000010b = 01000000b
-01001101b & 11000011b = 01000001b
-01001101b & 11000100b = 01000100b
-01001101b & 11000101b = 01000101b
-01001101b & 11000110b = 01000100b
-01001101b & 11000111b = 01000101b
-01001101b & 11001000b = 01001000b
-01001101b & 11001001b = 01001001b
-01001101b & 11001010b = 01001000b
-01001101b & 11001011b = 01001001b
-01001101b & 11001100b = 01001100b
-01001101b & 11001101b = 01001101b
-01001101b & 11001110b = 01001100b
-01001101b & 11001111b = 01001101b
-01001101b & 11010000b = 01000000b
-01001101b & 11010001b = 01000001b
-01001101b & 11010010b = 01000000b
-01001101b & 11010011b = 01000001b
-01001101b & 11010100b = 01000100b
-01001101b & 11010101b = 01000101b
-01001101b & 11010110b = 01000100b
-01001101b & 11010111b = 01000101b
-01001101b & 11011000b = 01001000b
-01001101b & 11011001b = 01001001b
-01001101b & 11011010b = 01001000b
-01001101b & 11011011b = 01001001b
-01001101b & 11011100b = 01001100b
-01001101b & 11011101b = 01001101b
-01001101b & 11011110b = 01001100b
-01001101b & 11011111b = 01001101b
-01001101b & 11100000b = 01000000b
-01001101b & 11100001b = 01000001b
-01001101b & 11100010b = 01000000b
-01001101b & 11100011b = 01000001b
-01001101b & 11100100b = 01000100b
-01001101b & 11100101b = 01000101b
-01001101b & 11100110b = 01000100b
-01001101b & 11100111b = 01000101b
-01001101b & 11101000b = 01001000b
-01001101b & 11101001b = 01001001b
-01001101b & 11101010b = 01001000b
-01001101b & 11101011b = 01001001b
-01001101b & 11101100b = 01001100b
-01001101b & 11101101b = 01001101b
-01001101b & 11101110b = 01001100b
-01001101b & 11101111b = 01001101b
-01001101b & 11110000b = 01000000b
-01001101b & 11110001b = 01000001b
-01001101b & 11110010b = 01000000b
-01001101b & 11110011b = 01000001b
-01001101b & 11110100b = 01000100b
-01001101b & 11110101b = 01000101b
-01001101b & 11110110b = 01000100b
-01001101b & 11110111b = 01000101b
-01001101b & 11111000b = 01001000b
-01001101b & 11111001b = 01001001b
-01001101b & 11111010b = 01001000b
-01001101b & 11111011b = 01001001b
-01001101b & 11111100b = 01001100b
-01001101b & 11111101b = 01001101b
-01001101b & 11111110b = 01001100b
-01001101b & 11111111b = 01001101b
-01001101b & 00000000b = 00000000b
-01001101b & 00000001b = 00000001b
-01001101b & 00000010b = 00000000b
-01001101b & 00000011b = 00000001b
-01001101b & 00000100b = 00000100b
-01001101b & 00000101b = 00000101b
-01001101b & 00000110b = 00000100b
-01001101b & 00000111b = 00000101b
-01001101b & 00001000b = 00001000b
-01001101b & 00001001b = 00001001b
-01001101b & 00001010b = 00001000b
-01001101b & 00001011b = 00001001b
-01001101b & 00001100b = 00001100b
-01001101b & 00001101b = 00001101b
-01001101b & 00001110b = 00001100b
-01001101b & 00001111b = 00001101b
-01001101b & 00010000b = 00000000b
-01001101b & 00010001b = 00000001b
-01001101b & 00010010b = 00000000b
-01001101b & 00010011b = 00000001b
-01001101b & 00010100b = 00000100b
-01001101b & 00010101b = 00000101b
-01001101b & 00010110b = 00000100b
-01001101b & 00010111b = 00000101b
-01001101b & 00011000b = 00001000b
-01001101b & 00011001b = 00001001b
-01001101b & 00011010b = 00001000b
-01001101b & 00011011b = 00001001b
-01001101b & 00011100b = 00001100b
-01001101b & 00011101b = 00001101b
-01001101b & 00011110b = 00001100b
-01001101b & 00011111b = 00001101b
-01001101b & 00100000b = 00000000b
-01001101b & 00100001b = 00000001b
-01001101b & 00100010b = 00000000b
-01001101b & 00100011b = 00000001b
-01001101b & 00100100b = 00000100b
-01001101b & 00100101b = 00000101b
-01001101b & 00100110b = 00000100b
-01001101b & 00100111b = 00000101b
-01001101b & 00101000b = 00001000b
-01001101b & 00101001b = 00001001b
-01001101b & 00101010b = 00001000b
-01001101b & 00101011b = 00001001b
-01001101b & 00101100b = 00001100b
-01001101b & 00101101b = 00001101b
-01001101b & 00101110b = 00001100b
-01001101b & 00101111b = 00001101b
-01001101b & 00110000b = 00000000b
-01001101b & 00110001b = 00000001b
-01001101b & 00110010b = 00000000b
-01001101b & 00110011b = 00000001b
-01001101b & 00110100b = 00000100b
-01001101b & 00110101b = 00000101b
-01001101b & 00110110b = 00000100b
-01001101b & 00110111b = 00000101b
-01001101b & 00111000b = 00001000b
-01001101b & 00111001b = 00001001b
-01001101b & 00111010b = 00001000b
-01001101b & 00111011b = 00001001b
-01001101b & 00111100b = 00001100b
-01001101b & 00111101b = 00001101b
-01001101b & 00111110b = 00001100b
-01001101b & 00111111b = 00001101b
-01001101b & 01000000b = 01000000b
-01001101b & 01000001b = 01000001b
-01001101b & 01000010b = 01000000b
-01001101b & 01000011b = 01000001b
-01001101b & 01000100b = 01000100b
-01001101b & 01000101b = 01000101b
-01001101b & 01000110b = 01000100b
-01001101b & 01000111b = 01000101b
-01001101b & 01001000b = 01001000b
-01001101b & 01001001b = 01001001b
-01001101b & 01001010b = 01001000b
-01001101b & 01001011b = 01001001b
-01001101b & 01001100b = 01001100b
-01001101b & 01001101b = 01001101b
-01001101b & 01001110b = 01001100b
-01001101b & 01001111b = 01001101b
-01001101b & 01010000b = 01000000b
-01001101b & 01010001b = 01000001b
-01001101b & 01010010b = 01000000b
-01001101b & 01010011b = 01000001b
-01001101b & 01010100b = 01000100b
-01001101b & 01010101b = 01000101b
-01001101b & 01010110b = 01000100b
-01001101b & 01010111b = 01000101b
-01001101b & 01011000b = 01001000b
-01001101b & 01011001b = 01001001b
-01001101b & 01011010b = 01001000b
-01001101b & 01011011b = 01001001b
-01001101b & 01011100b = 01001100b
-01001101b & 01011101b = 01001101b
-01001101b & 01011110b = 01001100b
-01001101b & 01011111b = 01001101b
-01001101b & 01100000b = 01000000b
-01001101b & 01100001b = 01000001b
-01001101b & 01100010b = 01000000b
-01001101b & 01100011b = 01000001b
-01001101b & 01100100b = 01000100b
-01001101b & 01100101b = 01000101b
-01001101b & 01100110b = 01000100b
-01001101b & 01100111b = 01000101b
-01001101b & 01101000b = 01001000b
-01001101b & 01101001b = 01001001b
-01001101b & 01101010b = 01001000b
-01001101b & 01101011b = 01001001b
-01001101b & 01101100b = 01001100b
-01001101b & 01101101b = 01001101b
-01001101b & 01101110b = 01001100b
-01001101b & 01101111b = 01001101b
-01001101b & 01110000b = 01000000b
-01001101b & 01110001b = 01000001b
-01001101b & 01110010b = 01000000b
-01001101b & 01110011b = 01000001b
-01001101b & 01110100b = 01000100b
-01001101b & 01110101b = 01000101b
-01001101b & 01110110b = 01000100b
-01001101b & 01110111b = 01000101b
-01001101b & 01111000b = 01001000b
-01001101b & 01111001b = 01001001b
-01001101b & 01111010b = 01001000b
-01001101b & 01111011b = 01001001b
-01001101b & 01111100b = 01001100b
-01001101b & 01111101b = 01001101b
-01001101b & 01111110b = 01001100b
-01001110b & 10000000b = 00000000b
-01001110b & 10000001b = 00000000b
-01001110b & 10000010b = 00000010b
-01001110b & 10000011b = 00000010b
-01001110b & 10000100b = 00000100b
-01001110b & 10000101b = 00000100b
-01001110b & 10000110b = 00000110b
-01001110b & 10000111b = 00000110b
-01001110b & 10001000b = 00001000b
-01001110b & 10001001b = 00001000b
-01001110b & 10001010b = 00001010b
-01001110b & 10001011b = 00001010b
-01001110b & 10001100b = 00001100b
-01001110b & 10001101b = 00001100b
-01001110b & 10001110b = 00001110b
-01001110b & 10001111b = 00001110b
-01001110b & 10010000b = 00000000b
-01001110b & 10010001b = 00000000b
-01001110b & 10010010b = 00000010b
-01001110b & 10010011b = 00000010b
-01001110b & 10010100b = 00000100b
-01001110b & 10010101b = 00000100b
-01001110b & 10010110b = 00000110b
-01001110b & 10010111b = 00000110b
-01001110b & 10011000b = 00001000b
-01001110b & 10011001b = 00001000b
-01001110b & 10011010b = 00001010b
-01001110b & 10011011b = 00001010b
-01001110b & 10011100b = 00001100b
-01001110b & 10011101b = 00001100b
-01001110b & 10011110b = 00001110b
-01001110b & 10011111b = 00001110b
-01001110b & 10100000b = 00000000b
-01001110b & 10100001b = 00000000b
-01001110b & 10100010b = 00000010b
-01001110b & 10100011b = 00000010b
-01001110b & 10100100b = 00000100b
-01001110b & 10100101b = 00000100b
-01001110b & 10100110b = 00000110b
-01001110b & 10100111b = 00000110b
-01001110b & 10101000b = 00001000b
-01001110b & 10101001b = 00001000b
-01001110b & 10101010b = 00001010b
-01001110b & 10101011b = 00001010b
-01001110b & 10101100b = 00001100b
-01001110b & 10101101b = 00001100b
-01001110b & 10101110b = 00001110b
-01001110b & 10101111b = 00001110b
-01001110b & 10110000b = 00000000b
-01001110b & 10110001b = 00000000b
-01001110b & 10110010b = 00000010b
-01001110b & 10110011b = 00000010b
-01001110b & 10110100b = 00000100b
-01001110b & 10110101b = 00000100b
-01001110b & 10110110b = 00000110b
-01001110b & 10110111b = 00000110b
-01001110b & 10111000b = 00001000b
-01001110b & 10111001b = 00001000b
-01001110b & 10111010b = 00001010b
-01001110b & 10111011b = 00001010b
-01001110b & 10111100b = 00001100b
-01001110b & 10111101b = 00001100b
-01001110b & 10111110b = 00001110b
-01001110b & 10111111b = 00001110b
-01001110b & 11000000b = 01000000b
-01001110b & 11000001b = 01000000b
-01001110b & 11000010b = 01000010b
-01001110b & 11000011b = 01000010b
-01001110b & 11000100b = 01000100b
-01001110b & 11000101b = 01000100b
-01001110b & 11000110b = 01000110b
-01001110b & 11000111b = 01000110b
-01001110b & 11001000b = 01001000b
-01001110b & 11001001b = 01001000b
-01001110b & 11001010b = 01001010b
-01001110b & 11001011b = 01001010b
-01001110b & 11001100b = 01001100b
-01001110b & 11001101b = 01001100b
-01001110b & 11001110b = 01001110b
-01001110b & 11001111b = 01001110b
-01001110b & 11010000b = 01000000b
-01001110b & 11010001b = 01000000b
-01001110b & 11010010b = 01000010b
-01001110b & 11010011b = 01000010b
-01001110b & 11010100b = 01000100b
-01001110b & 11010101b = 01000100b
-01001110b & 11010110b = 01000110b
-01001110b & 11010111b = 01000110b
-01001110b & 11011000b = 01001000b
-01001110b & 11011001b = 01001000b
-01001110b & 11011010b = 01001010b
-01001110b & 11011011b = 01001010b
-01001110b & 11011100b = 01001100b
-01001110b & 11011101b = 01001100b
-01001110b & 11011110b = 01001110b
-01001110b & 11011111b = 01001110b
-01001110b & 11100000b = 01000000b
-01001110b & 11100001b = 01000000b
-01001110b & 11100010b = 01000010b
-01001110b & 11100011b = 01000010b
-01001110b & 11100100b = 01000100b
-01001110b & 11100101b = 01000100b
-01001110b & 11100110b = 01000110b
-01001110b & 11100111b = 01000110b
-01001110b & 11101000b = 01001000b
-01001110b & 11101001b = 01001000b
-01001110b & 11101010b = 01001010b
-01001110b & 11101011b = 01001010b
-01001110b & 11101100b = 01001100b
-01001110b & 11101101b = 01001100b
-01001110b & 11101110b = 01001110b
-01001110b & 11101111b = 01001110b
-01001110b & 11110000b = 01000000b
-01001110b & 11110001b = 01000000b
-01001110b & 11110010b = 01000010b
-01001110b & 11110011b = 01000010b
-01001110b & 11110100b = 01000100b
-01001110b & 11110101b = 01000100b
-01001110b & 11110110b = 01000110b
-01001110b & 11110111b = 01000110b
-01001110b & 11111000b = 01001000b
-01001110b & 11111001b = 01001000b
-01001110b & 11111010b = 01001010b
-01001110b & 11111011b = 01001010b
-01001110b & 11111100b = 01001100b
-01001110b & 11111101b = 01001100b
-01001110b & 11111110b = 01001110b
-01001110b & 11111111b = 01001110b
-01001110b & 00000000b = 00000000b
-01001110b & 00000001b = 00000000b
-01001110b & 00000010b = 00000010b
-01001110b & 00000011b = 00000010b
-01001110b & 00000100b = 00000100b
-01001110b & 00000101b = 00000100b
-01001110b & 00000110b = 00000110b
-01001110b & 00000111b = 00000110b
-01001110b & 00001000b = 00001000b
-01001110b & 00001001b = 00001000b
-01001110b & 00001010b = 00001010b
-01001110b & 00001011b = 00001010b
-01001110b & 00001100b = 00001100b
-01001110b & 00001101b = 00001100b
-01001110b & 00001110b = 00001110b
-01001110b & 00001111b = 00001110b
-01001110b & 00010000b = 00000000b
-01001110b & 00010001b = 00000000b
-01001110b & 00010010b = 00000010b
-01001110b & 00010011b = 00000010b
-01001110b & 00010100b = 00000100b
-01001110b & 00010101b = 00000100b
-01001110b & 00010110b = 00000110b
-01001110b & 00010111b = 00000110b
-01001110b & 00011000b = 00001000b
-01001110b & 00011001b = 00001000b
-01001110b & 00011010b = 00001010b
-01001110b & 00011011b = 00001010b
-01001110b & 00011100b = 00001100b
-01001110b & 00011101b = 00001100b
-01001110b & 00011110b = 00001110b
-01001110b & 00011111b = 00001110b
-01001110b & 00100000b = 00000000b
-01001110b & 00100001b = 00000000b
-01001110b & 00100010b = 00000010b
-01001110b & 00100011b = 00000010b
-01001110b & 00100100b = 00000100b
-01001110b & 00100101b = 00000100b
-01001110b & 00100110b = 00000110b
-01001110b & 00100111b = 00000110b
-01001110b & 00101000b = 00001000b
-01001110b & 00101001b = 00001000b
-01001110b & 00101010b = 00001010b
-01001110b & 00101011b = 00001010b
-01001110b & 00101100b = 00001100b
-01001110b & 00101101b = 00001100b
-01001110b & 00101110b = 00001110b
-01001110b & 00101111b = 00001110b
-01001110b & 00110000b = 00000000b
-01001110b & 00110001b = 00000000b
-01001110b & 00110010b = 00000010b
-01001110b & 00110011b = 00000010b
-01001110b & 00110100b = 00000100b
-01001110b & 00110101b = 00000100b
-01001110b & 00110110b = 00000110b
-01001110b & 00110111b = 00000110b
-01001110b & 00111000b = 00001000b
-01001110b & 00111001b = 00001000b
-01001110b & 00111010b = 00001010b
-01001110b & 00111011b = 00001010b
-01001110b & 00111100b = 00001100b
-01001110b & 00111101b = 00001100b
-01001110b & 00111110b = 00001110b
-01001110b & 00111111b = 00001110b
-01001110b & 01000000b = 01000000b
-01001110b & 01000001b = 01000000b
-01001110b & 01000010b = 01000010b
-01001110b & 01000011b = 01000010b
-01001110b & 01000100b = 01000100b
-01001110b & 01000101b = 01000100b
-01001110b & 01000110b = 01000110b
-01001110b & 01000111b = 01000110b
-01001110b & 01001000b = 01001000b
-01001110b & 01001001b = 01001000b
-01001110b & 01001010b = 01001010b
-01001110b & 01001011b = 01001010b
-01001110b & 01001100b = 01001100b
-01001110b & 01001101b = 01001100b
-01001110b & 01001110b = 01001110b
-01001110b & 01001111b = 01001110b
-01001110b & 01010000b = 01000000b
-01001110b & 01010001b = 01000000b
-01001110b & 01010010b = 01000010b
-01001110b & 01010011b = 01000010b
-01001110b & 01010100b = 01000100b
-01001110b & 01010101b = 01000100b
-01001110b & 01010110b = 01000110b
-01001110b & 01010111b = 01000110b
-01001110b & 01011000b = 01001000b
-01001110b & 01011001b = 01001000b
-01001110b & 01011010b = 01001010b
-01001110b & 01011011b = 01001010b
-01001110b & 01011100b = 01001100b
-01001110b & 01011101b = 01001100b
-01001110b & 01011110b = 01001110b
-01001110b & 01011111b = 01001110b
-01001110b & 01100000b = 01000000b
-01001110b & 01100001b = 01000000b
-01001110b & 01100010b = 01000010b
-01001110b & 01100011b = 01000010b
-01001110b & 01100100b = 01000100b
-01001110b & 01100101b = 01000100b
-01001110b & 01100110b = 01000110b
-01001110b & 01100111b = 01000110b
-01001110b & 01101000b = 01001000b
-01001110b & 01101001b = 01001000b
-01001110b & 01101010b = 01001010b
-01001110b & 01101011b = 01001010b
-01001110b & 01101100b = 01001100b
-01001110b & 01101101b = 01001100b
-01001110b & 01101110b = 01001110b
-01001110b & 01101111b = 01001110b
-01001110b & 01110000b = 01000000b
-01001110b & 01110001b = 01000000b
-01001110b & 01110010b = 01000010b
-01001110b & 01110011b = 01000010b
-01001110b & 01110100b = 01000100b
-01001110b & 01110101b = 01000100b
-01001110b & 01110110b = 01000110b
-01001110b & 01110111b = 01000110b
-01001110b & 01111000b = 01001000b
-01001110b & 01111001b = 01001000b
-01001110b & 01111010b = 01001010b
-01001110b & 01111011b = 01001010b
-01001110b & 01111100b = 01001100b
-01001110b & 01111101b = 01001100b
-01001110b & 01111110b = 01001110b
-01001111b & 10000000b = 00000000b
-01001111b & 10000001b = 00000001b
-01001111b & 10000010b = 00000010b
-01001111b & 10000011b = 00000011b
-01001111b & 10000100b = 00000100b
-01001111b & 10000101b = 00000101b
-01001111b & 10000110b = 00000110b
-01001111b & 10000111b = 00000111b
-01001111b & 10001000b = 00001000b
-01001111b & 10001001b = 00001001b
-01001111b & 10001010b = 00001010b
-01001111b & 10001011b = 00001011b
-01001111b & 10001100b = 00001100b
-01001111b & 10001101b = 00001101b
-01001111b & 10001110b = 00001110b
-01001111b & 10001111b = 00001111b
-01001111b & 10010000b = 00000000b
-01001111b & 10010001b = 00000001b
-01001111b & 10010010b = 00000010b
-01001111b & 10010011b = 00000011b
-01001111b & 10010100b = 00000100b
-01001111b & 10010101b = 00000101b
-01001111b & 10010110b = 00000110b
-01001111b & 10010111b = 00000111b
-01001111b & 10011000b = 00001000b
-01001111b & 10011001b = 00001001b
-01001111b & 10011010b = 00001010b
-01001111b & 10011011b = 00001011b
-01001111b & 10011100b = 00001100b
-01001111b & 10011101b = 00001101b
-01001111b & 10011110b = 00001110b
-01001111b & 10011111b = 00001111b
-01001111b & 10100000b = 00000000b
-01001111b & 10100001b = 00000001b
-01001111b & 10100010b = 00000010b
-01001111b & 10100011b = 00000011b
-01001111b & 10100100b = 00000100b
-01001111b & 10100101b = 00000101b
-01001111b & 10100110b = 00000110b
-01001111b & 10100111b = 00000111b
-01001111b & 10101000b = 00001000b
-01001111b & 10101001b = 00001001b
-01001111b & 10101010b = 00001010b
-01001111b & 10101011b = 00001011b
-01001111b & 10101100b = 00001100b
-01001111b & 10101101b = 00001101b
-01001111b & 10101110b = 00001110b
-01001111b & 10101111b = 00001111b
-01001111b & 10110000b = 00000000b
-01001111b & 10110001b = 00000001b
-01001111b & 10110010b = 00000010b
-01001111b & 10110011b = 00000011b
-01001111b & 10110100b = 00000100b
-01001111b & 10110101b = 00000101b
-01001111b & 10110110b = 00000110b
-01001111b & 10110111b = 00000111b
-01001111b & 10111000b = 00001000b
-01001111b & 10111001b = 00001001b
-01001111b & 10111010b = 00001010b
-01001111b & 10111011b = 00001011b
-01001111b & 10111100b = 00001100b
-01001111b & 10111101b = 00001101b
-01001111b & 10111110b = 00001110b
-01001111b & 10111111b = 00001111b
-01001111b & 11000000b = 01000000b
-01001111b & 11000001b = 01000001b
-01001111b & 11000010b = 01000010b
-01001111b & 11000011b = 01000011b
-01001111b & 11000100b = 01000100b
-01001111b & 11000101b = 01000101b
-01001111b & 11000110b = 01000110b
-01001111b & 11000111b = 01000111b
-01001111b & 11001000b = 01001000b
-01001111b & 11001001b = 01001001b
-01001111b & 11001010b = 01001010b
-01001111b & 11001011b = 01001011b
-01001111b & 11001100b = 01001100b
-01001111b & 11001101b = 01001101b
-01001111b & 11001110b = 01001110b
-01001111b & 11001111b = 01001111b
-01001111b & 11010000b = 01000000b
-01001111b & 11010001b = 01000001b
-01001111b & 11010010b = 01000010b
-01001111b & 11010011b = 01000011b
-01001111b & 11010100b = 01000100b
-01001111b & 11010101b = 01000101b
-01001111b & 11010110b = 01000110b
-01001111b & 11010111b = 01000111b
-01001111b & 11011000b = 01001000b
-01001111b & 11011001b = 01001001b
-01001111b & 11011010b = 01001010b
-01001111b & 11011011b = 01001011b
-01001111b & 11011100b = 01001100b
-01001111b & 11011101b = 01001101b
-01001111b & 11011110b = 01001110b
-01001111b & 11011111b = 01001111b
-01001111b & 11100000b = 01000000b
-01001111b & 11100001b = 01000001b
-01001111b & 11100010b = 01000010b
-01001111b & 11100011b = 01000011b
-01001111b & 11100100b = 01000100b
-01001111b & 11100101b = 01000101b
-01001111b & 11100110b = 01000110b
-01001111b & 11100111b = 01000111b
-01001111b & 11101000b = 01001000b
-01001111b & 11101001b = 01001001b
-01001111b & 11101010b = 01001010b
-01001111b & 11101011b = 01001011b
-01001111b & 11101100b = 01001100b
-01001111b & 11101101b = 01001101b
-01001111b & 11101110b = 01001110b
-01001111b & 11101111b = 01001111b
-01001111b & 11110000b = 01000000b
-01001111b & 11110001b = 01000001b
-01001111b & 11110010b = 01000010b
-01001111b & 11110011b = 01000011b
-01001111b & 11110100b = 01000100b
-01001111b & 11110101b = 01000101b
-01001111b & 11110110b = 01000110b
-01001111b & 11110111b = 01000111b
-01001111b & 11111000b = 01001000b
-01001111b & 11111001b = 01001001b
-01001111b & 11111010b = 01001010b
-01001111b & 11111011b = 01001011b
-01001111b & 11111100b = 01001100b
-01001111b & 11111101b = 01001101b
-01001111b & 11111110b = 01001110b
-01001111b & 11111111b = 01001111b
-01001111b & 00000000b = 00000000b
-01001111b & 00000001b = 00000001b
-01001111b & 00000010b = 00000010b
-01001111b & 00000011b = 00000011b
-01001111b & 00000100b = 00000100b
-01001111b & 00000101b = 00000101b
-01001111b & 00000110b = 00000110b
-01001111b & 00000111b = 00000111b
-01001111b & 00001000b = 00001000b
-01001111b & 00001001b = 00001001b
-01001111b & 00001010b = 00001010b
-01001111b & 00001011b = 00001011b
-01001111b & 00001100b = 00001100b
-01001111b & 00001101b = 00001101b
-01001111b & 00001110b = 00001110b
-01001111b & 00001111b = 00001111b
-01001111b & 00010000b = 00000000b
-01001111b & 00010001b = 00000001b
-01001111b & 00010010b = 00000010b
-01001111b & 00010011b = 00000011b
-01001111b & 00010100b = 00000100b
-01001111b & 00010101b = 00000101b
-01001111b & 00010110b = 00000110b
-01001111b & 00010111b = 00000111b
-01001111b & 00011000b = 00001000b
-01001111b & 00011001b = 00001001b
-01001111b & 00011010b = 00001010b
-01001111b & 00011011b = 00001011b
-01001111b & 00011100b = 00001100b
-01001111b & 00011101b = 00001101b
-01001111b & 00011110b = 00001110b
-01001111b & 00011111b = 00001111b
-01001111b & 00100000b = 00000000b
-01001111b & 00100001b = 00000001b
-01001111b & 00100010b = 00000010b
-01001111b & 00100011b = 00000011b
-01001111b & 00100100b = 00000100b
-01001111b & 00100101b = 00000101b
-01001111b & 00100110b = 00000110b
-01001111b & 00100111b = 00000111b
-01001111b & 00101000b = 00001000b
-01001111b & 00101001b = 00001001b
-01001111b & 00101010b = 00001010b
-01001111b & 00101011b = 00001011b
-01001111b & 00101100b = 00001100b
-01001111b & 00101101b = 00001101b
-01001111b & 00101110b = 00001110b
-01001111b & 00101111b = 00001111b
-01001111b & 00110000b = 00000000b
-01001111b & 00110001b = 00000001b
-01001111b & 00110010b = 00000010b
-01001111b & 00110011b = 00000011b
-01001111b & 00110100b = 00000100b
-01001111b & 00110101b = 00000101b
-01001111b & 00110110b = 00000110b
-01001111b & 00110111b = 00000111b
-01001111b & 00111000b = 00001000b
-01001111b & 00111001b = 00001001b
-01001111b & 00111010b = 00001010b
-01001111b & 00111011b = 00001011b
-01001111b & 00111100b = 00001100b
-01001111b & 00111101b = 00001101b
-01001111b & 00111110b = 00001110b
-01001111b & 00111111b = 00001111b
-01001111b & 01000000b = 01000000b
-01001111b & 01000001b = 01000001b
-01001111b & 01000010b = 01000010b
-01001111b & 01000011b = 01000011b
-01001111b & 01000100b = 01000100b
-01001111b & 01000101b = 01000101b
-01001111b & 01000110b = 01000110b
-01001111b & 01000111b = 01000111b
-01001111b & 01001000b = 01001000b
-01001111b & 01001001b = 01001001b
-01001111b & 01001010b = 01001010b
-01001111b & 01001011b = 01001011b
-01001111b & 01001100b = 01001100b
-01001111b & 01001101b = 01001101b
-01001111b & 01001110b = 01001110b
-01001111b & 01001111b = 01001111b
-01001111b & 01010000b = 01000000b
-01001111b & 01010001b = 01000001b
-01001111b & 01010010b = 01000010b
-01001111b & 01010011b = 01000011b
-01001111b & 01010100b = 01000100b
-01001111b & 01010101b = 01000101b
-01001111b & 01010110b = 01000110b
-01001111b & 01010111b = 01000111b
-01001111b & 01011000b = 01001000b
-01001111b & 01011001b = 01001001b
-01001111b & 01011010b = 01001010b
-01001111b & 01011011b = 01001011b
-01001111b & 01011100b = 01001100b
-01001111b & 01011101b = 01001101b
-01001111b & 01011110b = 01001110b
-01001111b & 01011111b = 01001111b
-01001111b & 01100000b = 01000000b
-01001111b & 01100001b = 01000001b
-01001111b & 01100010b = 01000010b
-01001111b & 01100011b = 01000011b
-01001111b & 01100100b = 01000100b
-01001111b & 01100101b = 01000101b
-01001111b & 01100110b = 01000110b
-01001111b & 01100111b = 01000111b
-01001111b & 01101000b = 01001000b
-01001111b & 01101001b = 01001001b
-01001111b & 01101010b = 01001010b
-01001111b & 01101011b = 01001011b
-01001111b & 01101100b = 01001100b
-01001111b & 01101101b = 01001101b
-01001111b & 01101110b = 01001110b
-01001111b & 01101111b = 01001111b
-01001111b & 01110000b = 01000000b
-01001111b & 01110001b = 01000001b
-01001111b & 01110010b = 01000010b
-01001111b & 01110011b = 01000011b
-01001111b & 01110100b = 01000100b
-01001111b & 01110101b = 01000101b
-01001111b & 01110110b = 01000110b
-01001111b & 01110111b = 01000111b
-01001111b & 01111000b = 01001000b
-01001111b & 01111001b = 01001001b
-01001111b & 01111010b = 01001010b
-01001111b & 01111011b = 01001011b
-01001111b & 01111100b = 01001100b
-01001111b & 01111101b = 01001101b
-01001111b & 01111110b = 01001110b
-01010000b & 10000000b = 00000000b
-01010000b & 10000001b = 00000000b
-01010000b & 10000010b = 00000000b
-01010000b & 10000011b = 00000000b
-01010000b & 10000100b = 00000000b
-01010000b & 10000101b = 00000000b
-01010000b & 10000110b = 00000000b
-01010000b & 10000111b = 00000000b
-01010000b & 10001000b = 00000000b
-01010000b & 10001001b = 00000000b
-01010000b & 10001010b = 00000000b
-01010000b & 10001011b = 00000000b
-01010000b & 10001100b = 00000000b
-01010000b & 10001101b = 00000000b
-01010000b & 10001110b = 00000000b
-01010000b & 10001111b = 00000000b
-01010000b & 10010000b = 00010000b
-01010000b & 10010001b = 00010000b
-01010000b & 10010010b = 00010000b
-01010000b & 10010011b = 00010000b
-01010000b & 10010100b = 00010000b
-01010000b & 10010101b = 00010000b
-01010000b & 10010110b = 00010000b
-01010000b & 10010111b = 00010000b
-01010000b & 10011000b = 00010000b
-01010000b & 10011001b = 00010000b
-01010000b & 10011010b = 00010000b
-01010000b & 10011011b = 00010000b
-01010000b & 10011100b = 00010000b
-01010000b & 10011101b = 00010000b
-01010000b & 10011110b = 00010000b
-01010000b & 10011111b = 00010000b
-01010000b & 10100000b = 00000000b
-01010000b & 10100001b = 00000000b
-01010000b & 10100010b = 00000000b
-01010000b & 10100011b = 00000000b
-01010000b & 10100100b = 00000000b
-01010000b & 10100101b = 00000000b
-01010000b & 10100110b = 00000000b
-01010000b & 10100111b = 00000000b
-01010000b & 10101000b = 00000000b
-01010000b & 10101001b = 00000000b
-01010000b & 10101010b = 00000000b
-01010000b & 10101011b = 00000000b
-01010000b & 10101100b = 00000000b
-01010000b & 10101101b = 00000000b
-01010000b & 10101110b = 00000000b
-01010000b & 10101111b = 00000000b
-01010000b & 10110000b = 00010000b
-01010000b & 10110001b = 00010000b
-01010000b & 10110010b = 00010000b
-01010000b & 10110011b = 00010000b
-01010000b & 10110100b = 00010000b
-01010000b & 10110101b = 00010000b
-01010000b & 10110110b = 00010000b
-01010000b & 10110111b = 00010000b
-01010000b & 10111000b = 00010000b
-01010000b & 10111001b = 00010000b
-01010000b & 10111010b = 00010000b
-01010000b & 10111011b = 00010000b
-01010000b & 10111100b = 00010000b
-01010000b & 10111101b = 00010000b
-01010000b & 10111110b = 00010000b
-01010000b & 10111111b = 00010000b
-01010000b & 11000000b = 01000000b
-01010000b & 11000001b = 01000000b
-01010000b & 11000010b = 01000000b
-01010000b & 11000011b = 01000000b
-01010000b & 11000100b = 01000000b
-01010000b & 11000101b = 01000000b
-01010000b & 11000110b = 01000000b
-01010000b & 11000111b = 01000000b
-01010000b & 11001000b = 01000000b
-01010000b & 11001001b = 01000000b
-01010000b & 11001010b = 01000000b
-01010000b & 11001011b = 01000000b
-01010000b & 11001100b = 01000000b
-01010000b & 11001101b = 01000000b
-01010000b & 11001110b = 01000000b
-01010000b & 11001111b = 01000000b
-01010000b & 11010000b = 01010000b
-01010000b & 11010001b = 01010000b
-01010000b & 11010010b = 01010000b
-01010000b & 11010011b = 01010000b
-01010000b & 11010100b = 01010000b
-01010000b & 11010101b = 01010000b
-01010000b & 11010110b = 01010000b
-01010000b & 11010111b = 01010000b
-01010000b & 11011000b = 01010000b
-01010000b & 11011001b = 01010000b
-01010000b & 11011010b = 01010000b
-01010000b & 11011011b = 01010000b
-01010000b & 11011100b = 01010000b
-01010000b & 11011101b = 01010000b
-01010000b & 11011110b = 01010000b
-01010000b & 11011111b = 01010000b
-01010000b & 11100000b = 01000000b
-01010000b & 11100001b = 01000000b
-01010000b & 11100010b = 01000000b
-01010000b & 11100011b = 01000000b
-01010000b & 11100100b = 01000000b
-01010000b & 11100101b = 01000000b
-01010000b & 11100110b = 01000000b
-01010000b & 11100111b = 01000000b
-01010000b & 11101000b = 01000000b
-01010000b & 11101001b = 01000000b
-01010000b & 11101010b = 01000000b
-01010000b & 11101011b = 01000000b
-01010000b & 11101100b = 01000000b
-01010000b & 11101101b = 01000000b
-01010000b & 11101110b = 01000000b
-01010000b & 11101111b = 01000000b
-01010000b & 11110000b = 01010000b
-01010000b & 11110001b = 01010000b
-01010000b & 11110010b = 01010000b
-01010000b & 11110011b = 01010000b
-01010000b & 11110100b = 01010000b
-01010000b & 11110101b = 01010000b
-01010000b & 11110110b = 01010000b
-01010000b & 11110111b = 01010000b
-01010000b & 11111000b = 01010000b
-01010000b & 11111001b = 01010000b
-01010000b & 11111010b = 01010000b
-01010000b & 11111011b = 01010000b
-01010000b & 11111100b = 01010000b
-01010000b & 11111101b = 01010000b
-01010000b & 11111110b = 01010000b
-01010000b & 11111111b = 01010000b
-01010000b & 00000000b = 00000000b
-01010000b & 00000001b = 00000000b
-01010000b & 00000010b = 00000000b
-01010000b & 00000011b = 00000000b
-01010000b & 00000100b = 00000000b
-01010000b & 00000101b = 00000000b
-01010000b & 00000110b = 00000000b
-01010000b & 00000111b = 00000000b
-01010000b & 00001000b = 00000000b
-01010000b & 00001001b = 00000000b
-01010000b & 00001010b = 00000000b
-01010000b & 00001011b = 00000000b
-01010000b & 00001100b = 00000000b
-01010000b & 00001101b = 00000000b
-01010000b & 00001110b = 00000000b
-01010000b & 00001111b = 00000000b
-01010000b & 00010000b = 00010000b
-01010000b & 00010001b = 00010000b
-01010000b & 00010010b = 00010000b
-01010000b & 00010011b = 00010000b
-01010000b & 00010100b = 00010000b
-01010000b & 00010101b = 00010000b
-01010000b & 00010110b = 00010000b
-01010000b & 00010111b = 00010000b
-01010000b & 00011000b = 00010000b
-01010000b & 00011001b = 00010000b
-01010000b & 00011010b = 00010000b
-01010000b & 00011011b = 00010000b
-01010000b & 00011100b = 00010000b
-01010000b & 00011101b = 00010000b
-01010000b & 00011110b = 00010000b
-01010000b & 00011111b = 00010000b
-01010000b & 00100000b = 00000000b
-01010000b & 00100001b = 00000000b
-01010000b & 00100010b = 00000000b
-01010000b & 00100011b = 00000000b
-01010000b & 00100100b = 00000000b
-01010000b & 00100101b = 00000000b
-01010000b & 00100110b = 00000000b
-01010000b & 00100111b = 00000000b
-01010000b & 00101000b = 00000000b
-01010000b & 00101001b = 00000000b
-01010000b & 00101010b = 00000000b
-01010000b & 00101011b = 00000000b
-01010000b & 00101100b = 00000000b
-01010000b & 00101101b = 00000000b
-01010000b & 00101110b = 00000000b
-01010000b & 00101111b = 00000000b
-01010000b & 00110000b = 00010000b
-01010000b & 00110001b = 00010000b
-01010000b & 00110010b = 00010000b
-01010000b & 00110011b = 00010000b
-01010000b & 00110100b = 00010000b
-01010000b & 00110101b = 00010000b
-01010000b & 00110110b = 00010000b
-01010000b & 00110111b = 00010000b
-01010000b & 00111000b = 00010000b
-01010000b & 00111001b = 00010000b
-01010000b & 00111010b = 00010000b
-01010000b & 00111011b = 00010000b
-01010000b & 00111100b = 00010000b
-01010000b & 00111101b = 00010000b
-01010000b & 00111110b = 00010000b
-01010000b & 00111111b = 00010000b
-01010000b & 01000000b = 01000000b
-01010000b & 01000001b = 01000000b
-01010000b & 01000010b = 01000000b
-01010000b & 01000011b = 01000000b
-01010000b & 01000100b = 01000000b
-01010000b & 01000101b = 01000000b
-01010000b & 01000110b = 01000000b
-01010000b & 01000111b = 01000000b
-01010000b & 01001000b = 01000000b
-01010000b & 01001001b = 01000000b
-01010000b & 01001010b = 01000000b
-01010000b & 01001011b = 01000000b
-01010000b & 01001100b = 01000000b
-01010000b & 01001101b = 01000000b
-01010000b & 01001110b = 01000000b
-01010000b & 01001111b = 01000000b
-01010000b & 01010000b = 01010000b
-01010000b & 01010001b = 01010000b
-01010000b & 01010010b = 01010000b
-01010000b & 01010011b = 01010000b
-01010000b & 01010100b = 01010000b
-01010000b & 01010101b = 01010000b
-01010000b & 01010110b = 01010000b
-01010000b & 01010111b = 01010000b
-01010000b & 01011000b = 01010000b
-01010000b & 01011001b = 01010000b
-01010000b & 01011010b = 01010000b
-01010000b & 01011011b = 01010000b
-01010000b & 01011100b = 01010000b
-01010000b & 01011101b = 01010000b
-01010000b & 01011110b = 01010000b
-01010000b & 01011111b = 01010000b
-01010000b & 01100000b = 01000000b
-01010000b & 01100001b = 01000000b
-01010000b & 01100010b = 01000000b
-01010000b & 01100011b = 01000000b
-01010000b & 01100100b = 01000000b
-01010000b & 01100101b = 01000000b
-01010000b & 01100110b = 01000000b
-01010000b & 01100111b = 01000000b
-01010000b & 01101000b = 01000000b
-01010000b & 01101001b = 01000000b
-01010000b & 01101010b = 01000000b
-01010000b & 01101011b = 01000000b
-01010000b & 01101100b = 01000000b
-01010000b & 01101101b = 01000000b
-01010000b & 01101110b = 01000000b
-01010000b & 01101111b = 01000000b
-01010000b & 01110000b = 01010000b
-01010000b & 01110001b = 01010000b
-01010000b & 01110010b = 01010000b
-01010000b & 01110011b = 01010000b
-01010000b & 01110100b = 01010000b
-01010000b & 01110101b = 01010000b
-01010000b & 01110110b = 01010000b
-01010000b & 01110111b = 01010000b
-01010000b & 01111000b = 01010000b
-01010000b & 01111001b = 01010000b
-01010000b & 01111010b = 01010000b
-01010000b & 01111011b = 01010000b
-01010000b & 01111100b = 01010000b
-01010000b & 01111101b = 01010000b
-01010000b & 01111110b = 01010000b
-01010001b & 10000000b = 00000000b
-01010001b & 10000001b = 00000001b
-01010001b & 10000010b = 00000000b
-01010001b & 10000011b = 00000001b
-01010001b & 10000100b = 00000000b
-01010001b & 10000101b = 00000001b
-01010001b & 10000110b = 00000000b
-01010001b & 10000111b = 00000001b
-01010001b & 10001000b = 00000000b
-01010001b & 10001001b = 00000001b
-01010001b & 10001010b = 00000000b
-01010001b & 10001011b = 00000001b
-01010001b & 10001100b = 00000000b
-01010001b & 10001101b = 00000001b
-01010001b & 10001110b = 00000000b
-01010001b & 10001111b = 00000001b
-01010001b & 10010000b = 00010000b
-01010001b & 10010001b = 00010001b
-01010001b & 10010010b = 00010000b
-01010001b & 10010011b = 00010001b
-01010001b & 10010100b = 00010000b
-01010001b & 10010101b = 00010001b
-01010001b & 10010110b = 00010000b
-01010001b & 10010111b = 00010001b
-01010001b & 10011000b = 00010000b
-01010001b & 10011001b = 00010001b
-01010001b & 10011010b = 00010000b
-01010001b & 10011011b = 00010001b
-01010001b & 10011100b = 00010000b
-01010001b & 10011101b = 00010001b
-01010001b & 10011110b = 00010000b
-01010001b & 10011111b = 00010001b
-01010001b & 10100000b = 00000000b
-01010001b & 10100001b = 00000001b
-01010001b & 10100010b = 00000000b
-01010001b & 10100011b = 00000001b
-01010001b & 10100100b = 00000000b
-01010001b & 10100101b = 00000001b
-01010001b & 10100110b = 00000000b
-01010001b & 10100111b = 00000001b
-01010001b & 10101000b = 00000000b
-01010001b & 10101001b = 00000001b
-01010001b & 10101010b = 00000000b
-01010001b & 10101011b = 00000001b
-01010001b & 10101100b = 00000000b
-01010001b & 10101101b = 00000001b
-01010001b & 10101110b = 00000000b
-01010001b & 10101111b = 00000001b
-01010001b & 10110000b = 00010000b
-01010001b & 10110001b = 00010001b
-01010001b & 10110010b = 00010000b
-01010001b & 10110011b = 00010001b
-01010001b & 10110100b = 00010000b
-01010001b & 10110101b = 00010001b
-01010001b & 10110110b = 00010000b
-01010001b & 10110111b = 00010001b
-01010001b & 10111000b = 00010000b
-01010001b & 10111001b = 00010001b
-01010001b & 10111010b = 00010000b
-01010001b & 10111011b = 00010001b
-01010001b & 10111100b = 00010000b
-01010001b & 10111101b = 00010001b
-01010001b & 10111110b = 00010000b
-01010001b & 10111111b = 00010001b
-01010001b & 11000000b = 01000000b
-01010001b & 11000001b = 01000001b
-01010001b & 11000010b = 01000000b
-01010001b & 11000011b = 01000001b
-01010001b & 11000100b = 01000000b
-01010001b & 11000101b = 01000001b
-01010001b & 11000110b = 01000000b
-01010001b & 11000111b = 01000001b
-01010001b & 11001000b = 01000000b
-01010001b & 11001001b = 01000001b
-01010001b & 11001010b = 01000000b
-01010001b & 11001011b = 01000001b
-01010001b & 11001100b = 01000000b
-01010001b & 11001101b = 01000001b
-01010001b & 11001110b = 01000000b
-01010001b & 11001111b = 01000001b
-01010001b & 11010000b = 01010000b
-01010001b & 11010001b = 01010001b
-01010001b & 11010010b = 01010000b
-01010001b & 11010011b = 01010001b
-01010001b & 11010100b = 01010000b
-01010001b & 11010101b = 01010001b
-01010001b & 11010110b = 01010000b
-01010001b & 11010111b = 01010001b
-01010001b & 11011000b = 01010000b
-01010001b & 11011001b = 01010001b
-01010001b & 11011010b = 01010000b
-01010001b & 11011011b = 01010001b
-01010001b & 11011100b = 01010000b
-01010001b & 11011101b = 01010001b
-01010001b & 11011110b = 01010000b
-01010001b & 11011111b = 01010001b
-01010001b & 11100000b = 01000000b
-01010001b & 11100001b = 01000001b
-01010001b & 11100010b = 01000000b
-01010001b & 11100011b = 01000001b
-01010001b & 11100100b = 01000000b
-01010001b & 11100101b = 01000001b
-01010001b & 11100110b = 01000000b
-01010001b & 11100111b = 01000001b
-01010001b & 11101000b = 01000000b
-01010001b & 11101001b = 01000001b
-01010001b & 11101010b = 01000000b
-01010001b & 11101011b = 01000001b
-01010001b & 11101100b = 01000000b
-01010001b & 11101101b = 01000001b
-01010001b & 11101110b = 01000000b
-01010001b & 11101111b = 01000001b
-01010001b & 11110000b = 01010000b
-01010001b & 11110001b = 01010001b
-01010001b & 11110010b = 01010000b
-01010001b & 11110011b = 01010001b
-01010001b & 11110100b = 01010000b
-01010001b & 11110101b = 01010001b
-01010001b & 11110110b = 01010000b
-01010001b & 11110111b = 01010001b
-01010001b & 11111000b = 01010000b
-01010001b & 11111001b = 01010001b
-01010001b & 11111010b = 01010000b
-01010001b & 11111011b = 01010001b
-01010001b & 11111100b = 01010000b
-01010001b & 11111101b = 01010001b
-01010001b & 11111110b = 01010000b
-01010001b & 11111111b = 01010001b
-01010001b & 00000000b = 00000000b
-01010001b & 00000001b = 00000001b
-01010001b & 00000010b = 00000000b
-01010001b & 00000011b = 00000001b
-01010001b & 00000100b = 00000000b
-01010001b & 00000101b = 00000001b
-01010001b & 00000110b = 00000000b
-01010001b & 00000111b = 00000001b
-01010001b & 00001000b = 00000000b
-01010001b & 00001001b = 00000001b
-01010001b & 00001010b = 00000000b
-01010001b & 00001011b = 00000001b
-01010001b & 00001100b = 00000000b
-01010001b & 00001101b = 00000001b
-01010001b & 00001110b = 00000000b
-01010001b & 00001111b = 00000001b
-01010001b & 00010000b = 00010000b
-01010001b & 00010001b = 00010001b
-01010001b & 00010010b = 00010000b
-01010001b & 00010011b = 00010001b
-01010001b & 00010100b = 00010000b
-01010001b & 00010101b = 00010001b
-01010001b & 00010110b = 00010000b
-01010001b & 00010111b = 00010001b
-01010001b & 00011000b = 00010000b
-01010001b & 00011001b = 00010001b
-01010001b & 00011010b = 00010000b
-01010001b & 00011011b = 00010001b
-01010001b & 00011100b = 00010000b
-01010001b & 00011101b = 00010001b
-01010001b & 00011110b = 00010000b
-01010001b & 00011111b = 00010001b
-01010001b & 00100000b = 00000000b
-01010001b & 00100001b = 00000001b
-01010001b & 00100010b = 00000000b
-01010001b & 00100011b = 00000001b
-01010001b & 00100100b = 00000000b
-01010001b & 00100101b = 00000001b
-01010001b & 00100110b = 00000000b
-01010001b & 00100111b = 00000001b
-01010001b & 00101000b = 00000000b
-01010001b & 00101001b = 00000001b
-01010001b & 00101010b = 00000000b
-01010001b & 00101011b = 00000001b
-01010001b & 00101100b = 00000000b
-01010001b & 00101101b = 00000001b
-01010001b & 00101110b = 00000000b
-01010001b & 00101111b = 00000001b
-01010001b & 00110000b = 00010000b
-01010001b & 00110001b = 00010001b
-01010001b & 00110010b = 00010000b
-01010001b & 00110011b = 00010001b
-01010001b & 00110100b = 00010000b
-01010001b & 00110101b = 00010001b
-01010001b & 00110110b = 00010000b
-01010001b & 00110111b = 00010001b
-01010001b & 00111000b = 00010000b
-01010001b & 00111001b = 00010001b
-01010001b & 00111010b = 00010000b
-01010001b & 00111011b = 00010001b
-01010001b & 00111100b = 00010000b
-01010001b & 00111101b = 00010001b
-01010001b & 00111110b = 00010000b
-01010001b & 00111111b = 00010001b
-01010001b & 01000000b = 01000000b
-01010001b & 01000001b = 01000001b
-01010001b & 01000010b = 01000000b
-01010001b & 01000011b = 01000001b
-01010001b & 01000100b = 01000000b
-01010001b & 01000101b = 01000001b
-01010001b & 01000110b = 01000000b
-01010001b & 01000111b = 01000001b
-01010001b & 01001000b = 01000000b
-01010001b & 01001001b = 01000001b
-01010001b & 01001010b = 01000000b
-01010001b & 01001011b = 01000001b
-01010001b & 01001100b = 01000000b
-01010001b & 01001101b = 01000001b
-01010001b & 01001110b = 01000000b
-01010001b & 01001111b = 01000001b
-01010001b & 01010000b = 01010000b
-01010001b & 01010001b = 01010001b
-01010001b & 01010010b = 01010000b
-01010001b & 01010011b = 01010001b
-01010001b & 01010100b = 01010000b
-01010001b & 01010101b = 01010001b
-01010001b & 01010110b = 01010000b
-01010001b & 01010111b = 01010001b
-01010001b & 01011000b = 01010000b
-01010001b & 01011001b = 01010001b
-01010001b & 01011010b = 01010000b
-01010001b & 01011011b = 01010001b
-01010001b & 01011100b = 01010000b
-01010001b & 01011101b = 01010001b
-01010001b & 01011110b = 01010000b
-01010001b & 01011111b = 01010001b
-01010001b & 01100000b = 01000000b
-01010001b & 01100001b = 01000001b
-01010001b & 01100010b = 01000000b
-01010001b & 01100011b = 01000001b
-01010001b & 01100100b = 01000000b
-01010001b & 01100101b = 01000001b
-01010001b & 01100110b = 01000000b
-01010001b & 01100111b = 01000001b
-01010001b & 01101000b = 01000000b
-01010001b & 01101001b = 01000001b
-01010001b & 01101010b = 01000000b
-01010001b & 01101011b = 01000001b
-01010001b & 01101100b = 01000000b
-01010001b & 01101101b = 01000001b
-01010001b & 01101110b = 01000000b
-01010001b & 01101111b = 01000001b
-01010001b & 01110000b = 01010000b
-01010001b & 01110001b = 01010001b
-01010001b & 01110010b = 01010000b
-01010001b & 01110011b = 01010001b
-01010001b & 01110100b = 01010000b
-01010001b & 01110101b = 01010001b
-01010001b & 01110110b = 01010000b
-01010001b & 01110111b = 01010001b
-01010001b & 01111000b = 01010000b
-01010001b & 01111001b = 01010001b
-01010001b & 01111010b = 01010000b
-01010001b & 01111011b = 01010001b
-01010001b & 01111100b = 01010000b
-01010001b & 01111101b = 01010001b
-01010001b & 01111110b = 01010000b
-01010010b & 10000000b = 00000000b
-01010010b & 10000001b = 00000000b
-01010010b & 10000010b = 00000010b
-01010010b & 10000011b = 00000010b
-01010010b & 10000100b = 00000000b
-01010010b & 10000101b = 00000000b
-01010010b & 10000110b = 00000010b
-01010010b & 10000111b = 00000010b
-01010010b & 10001000b = 00000000b
-01010010b & 10001001b = 00000000b
-01010010b & 10001010b = 00000010b
-01010010b & 10001011b = 00000010b
-01010010b & 10001100b = 00000000b
-01010010b & 10001101b = 00000000b
-01010010b & 10001110b = 00000010b
-01010010b & 10001111b = 00000010b
-01010010b & 10010000b = 00010000b
-01010010b & 10010001b = 00010000b
-01010010b & 10010010b = 00010010b
-01010010b & 10010011b = 00010010b
-01010010b & 10010100b = 00010000b
-01010010b & 10010101b = 00010000b
-01010010b & 10010110b = 00010010b
-01010010b & 10010111b = 00010010b
-01010010b & 10011000b = 00010000b
-01010010b & 10011001b = 00010000b
-01010010b & 10011010b = 00010010b
-01010010b & 10011011b = 00010010b
-01010010b & 10011100b = 00010000b
-01010010b & 10011101b = 00010000b
-01010010b & 10011110b = 00010010b
-01010010b & 10011111b = 00010010b
-01010010b & 10100000b = 00000000b
-01010010b & 10100001b = 00000000b
-01010010b & 10100010b = 00000010b
-01010010b & 10100011b = 00000010b
-01010010b & 10100100b = 00000000b
-01010010b & 10100101b = 00000000b
-01010010b & 10100110b = 00000010b
-01010010b & 10100111b = 00000010b
-01010010b & 10101000b = 00000000b
-01010010b & 10101001b = 00000000b
-01010010b & 10101010b = 00000010b
-01010010b & 10101011b = 00000010b
-01010010b & 10101100b = 00000000b
-01010010b & 10101101b = 00000000b
-01010010b & 10101110b = 00000010b
-01010010b & 10101111b = 00000010b
-01010010b & 10110000b = 00010000b
-01010010b & 10110001b = 00010000b
-01010010b & 10110010b = 00010010b
-01010010b & 10110011b = 00010010b
-01010010b & 10110100b = 00010000b
-01010010b & 10110101b = 00010000b
-01010010b & 10110110b = 00010010b
-01010010b & 10110111b = 00010010b
-01010010b & 10111000b = 00010000b
-01010010b & 10111001b = 00010000b
-01010010b & 10111010b = 00010010b
-01010010b & 10111011b = 00010010b
-01010010b & 10111100b = 00010000b
-01010010b & 10111101b = 00010000b
-01010010b & 10111110b = 00010010b
-01010010b & 10111111b = 00010010b
-01010010b & 11000000b = 01000000b
-01010010b & 11000001b = 01000000b
-01010010b & 11000010b = 01000010b
-01010010b & 11000011b = 01000010b
-01010010b & 11000100b = 01000000b
-01010010b & 11000101b = 01000000b
-01010010b & 11000110b = 01000010b
-01010010b & 11000111b = 01000010b
-01010010b & 11001000b = 01000000b
-01010010b & 11001001b = 01000000b
-01010010b & 11001010b = 01000010b
-01010010b & 11001011b = 01000010b
-01010010b & 11001100b = 01000000b
-01010010b & 11001101b = 01000000b
-01010010b & 11001110b = 01000010b
-01010010b & 11001111b = 01000010b
-01010010b & 11010000b = 01010000b
-01010010b & 11010001b = 01010000b
-01010010b & 11010010b = 01010010b
-01010010b & 11010011b = 01010010b
-01010010b & 11010100b = 01010000b
-01010010b & 11010101b = 01010000b
-01010010b & 11010110b = 01010010b
-01010010b & 11010111b = 01010010b
-01010010b & 11011000b = 01010000b
-01010010b & 11011001b = 01010000b
-01010010b & 11011010b = 01010010b
-01010010b & 11011011b = 01010010b
-01010010b & 11011100b = 01010000b
-01010010b & 11011101b = 01010000b
-01010010b & 11011110b = 01010010b
-01010010b & 11011111b = 01010010b
-01010010b & 11100000b = 01000000b
-01010010b & 11100001b = 01000000b
-01010010b & 11100010b = 01000010b
-01010010b & 11100011b = 01000010b
-01010010b & 11100100b = 01000000b
-01010010b & 11100101b = 01000000b
-01010010b & 11100110b = 01000010b
-01010010b & 11100111b = 01000010b
-01010010b & 11101000b = 01000000b
-01010010b & 11101001b = 01000000b
-01010010b & 11101010b = 01000010b
-01010010b & 11101011b = 01000010b
-01010010b & 11101100b = 01000000b
-01010010b & 11101101b = 01000000b
-01010010b & 11101110b = 01000010b
-01010010b & 11101111b = 01000010b
-01010010b & 11110000b = 01010000b
-01010010b & 11110001b = 01010000b
-01010010b & 11110010b = 01010010b
-01010010b & 11110011b = 01010010b
-01010010b & 11110100b = 01010000b
-01010010b & 11110101b = 01010000b
-01010010b & 11110110b = 01010010b
-01010010b & 11110111b = 01010010b
-01010010b & 11111000b = 01010000b
-01010010b & 11111001b = 01010000b
-01010010b & 11111010b = 01010010b
-01010010b & 11111011b = 01010010b
-01010010b & 11111100b = 01010000b
-01010010b & 11111101b = 01010000b
-01010010b & 11111110b = 01010010b
-01010010b & 11111111b = 01010010b
-01010010b & 00000000b = 00000000b
-01010010b & 00000001b = 00000000b
-01010010b & 00000010b = 00000010b
-01010010b & 00000011b = 00000010b
-01010010b & 00000100b = 00000000b
-01010010b & 00000101b = 00000000b
-01010010b & 00000110b = 00000010b
-01010010b & 00000111b = 00000010b
-01010010b & 00001000b = 00000000b
-01010010b & 00001001b = 00000000b
-01010010b & 00001010b = 00000010b
-01010010b & 00001011b = 00000010b
-01010010b & 00001100b = 00000000b
-01010010b & 00001101b = 00000000b
-01010010b & 00001110b = 00000010b
-01010010b & 00001111b = 00000010b
-01010010b & 00010000b = 00010000b
-01010010b & 00010001b = 00010000b
-01010010b & 00010010b = 00010010b
-01010010b & 00010011b = 00010010b
-01010010b & 00010100b = 00010000b
-01010010b & 00010101b = 00010000b
-01010010b & 00010110b = 00010010b
-01010010b & 00010111b = 00010010b
-01010010b & 00011000b = 00010000b
-01010010b & 00011001b = 00010000b
-01010010b & 00011010b = 00010010b
-01010010b & 00011011b = 00010010b
-01010010b & 00011100b = 00010000b
-01010010b & 00011101b = 00010000b
-01010010b & 00011110b = 00010010b
-01010010b & 00011111b = 00010010b
-01010010b & 00100000b = 00000000b
-01010010b & 00100001b = 00000000b
-01010010b & 00100010b = 00000010b
-01010010b & 00100011b = 00000010b
-01010010b & 00100100b = 00000000b
-01010010b & 00100101b = 00000000b
-01010010b & 00100110b = 00000010b
-01010010b & 00100111b = 00000010b
-01010010b & 00101000b = 00000000b
-01010010b & 00101001b = 00000000b
-01010010b & 00101010b = 00000010b
-01010010b & 00101011b = 00000010b
-01010010b & 00101100b = 00000000b
-01010010b & 00101101b = 00000000b
-01010010b & 00101110b = 00000010b
-01010010b & 00101111b = 00000010b
-01010010b & 00110000b = 00010000b
-01010010b & 00110001b = 00010000b
-01010010b & 00110010b = 00010010b
-01010010b & 00110011b = 00010010b
-01010010b & 00110100b = 00010000b
-01010010b & 00110101b = 00010000b
-01010010b & 00110110b = 00010010b
-01010010b & 00110111b = 00010010b
-01010010b & 00111000b = 00010000b
-01010010b & 00111001b = 00010000b
-01010010b & 00111010b = 00010010b
-01010010b & 00111011b = 00010010b
-01010010b & 00111100b = 00010000b
-01010010b & 00111101b = 00010000b
-01010010b & 00111110b = 00010010b
-01010010b & 00111111b = 00010010b
-01010010b & 01000000b = 01000000b
-01010010b & 01000001b = 01000000b
-01010010b & 01000010b = 01000010b
-01010010b & 01000011b = 01000010b
-01010010b & 01000100b = 01000000b
-01010010b & 01000101b = 01000000b
-01010010b & 01000110b = 01000010b
-01010010b & 01000111b = 01000010b
-01010010b & 01001000b = 01000000b
-01010010b & 01001001b = 01000000b
-01010010b & 01001010b = 01000010b
-01010010b & 01001011b = 01000010b
-01010010b & 01001100b = 01000000b
-01010010b & 01001101b = 01000000b
-01010010b & 01001110b = 01000010b
-01010010b & 01001111b = 01000010b
-01010010b & 01010000b = 01010000b
-01010010b & 01010001b = 01010000b
-01010010b & 01010010b = 01010010b
-01010010b & 01010011b = 01010010b
-01010010b & 01010100b = 01010000b
-01010010b & 01010101b = 01010000b
-01010010b & 01010110b = 01010010b
-01010010b & 01010111b = 01010010b
-01010010b & 01011000b = 01010000b
-01010010b & 01011001b = 01010000b
-01010010b & 01011010b = 01010010b
-01010010b & 01011011b = 01010010b
-01010010b & 01011100b = 01010000b
-01010010b & 01011101b = 01010000b
-01010010b & 01011110b = 01010010b
-01010010b & 01011111b = 01010010b
-01010010b & 01100000b = 01000000b
-01010010b & 01100001b = 01000000b
-01010010b & 01100010b = 01000010b
-01010010b & 01100011b = 01000010b
-01010010b & 01100100b = 01000000b
-01010010b & 01100101b = 01000000b
-01010010b & 01100110b = 01000010b
-01010010b & 01100111b = 01000010b
-01010010b & 01101000b = 01000000b
-01010010b & 01101001b = 01000000b
-01010010b & 01101010b = 01000010b
-01010010b & 01101011b = 01000010b
-01010010b & 01101100b = 01000000b
-01010010b & 01101101b = 01000000b
-01010010b & 01101110b = 01000010b
-01010010b & 01101111b = 01000010b
-01010010b & 01110000b = 01010000b
-01010010b & 01110001b = 01010000b
-01010010b & 01110010b = 01010010b
-01010010b & 01110011b = 01010010b
-01010010b & 01110100b = 01010000b
-01010010b & 01110101b = 01010000b
-01010010b & 01110110b = 01010010b
-01010010b & 01110111b = 01010010b
-01010010b & 01111000b = 01010000b
-01010010b & 01111001b = 01010000b
-01010010b & 01111010b = 01010010b
-01010010b & 01111011b = 01010010b
-01010010b & 01111100b = 01010000b
-01010010b & 01111101b = 01010000b
-01010010b & 01111110b = 01010010b
-01010011b & 10000000b = 00000000b
-01010011b & 10000001b = 00000001b
-01010011b & 10000010b = 00000010b
-01010011b & 10000011b = 00000011b
-01010011b & 10000100b = 00000000b
-01010011b & 10000101b = 00000001b
-01010011b & 10000110b = 00000010b
-01010011b & 10000111b = 00000011b
-01010011b & 10001000b = 00000000b
-01010011b & 10001001b = 00000001b
-01010011b & 10001010b = 00000010b
-01010011b & 10001011b = 00000011b
-01010011b & 10001100b = 00000000b
-01010011b & 10001101b = 00000001b
-01010011b & 10001110b = 00000010b
-01010011b & 10001111b = 00000011b
-01010011b & 10010000b = 00010000b
-01010011b & 10010001b = 00010001b
-01010011b & 10010010b = 00010010b
-01010011b & 10010011b = 00010011b
-01010011b & 10010100b = 00010000b
-01010011b & 10010101b = 00010001b
-01010011b & 10010110b = 00010010b
-01010011b & 10010111b = 00010011b
-01010011b & 10011000b = 00010000b
-01010011b & 10011001b = 00010001b
-01010011b & 10011010b = 00010010b
-01010011b & 10011011b = 00010011b
-01010011b & 10011100b = 00010000b
-01010011b & 10011101b = 00010001b
-01010011b & 10011110b = 00010010b
-01010011b & 10011111b = 00010011b
-01010011b & 10100000b = 00000000b
-01010011b & 10100001b = 00000001b
-01010011b & 10100010b = 00000010b
-01010011b & 10100011b = 00000011b
-01010011b & 10100100b = 00000000b
-01010011b & 10100101b = 00000001b
-01010011b & 10100110b = 00000010b
-01010011b & 10100111b = 00000011b
-01010011b & 10101000b = 00000000b
-01010011b & 10101001b = 00000001b
-01010011b & 10101010b = 00000010b
-01010011b & 10101011b = 00000011b
-01010011b & 10101100b = 00000000b
-01010011b & 10101101b = 00000001b
-01010011b & 10101110b = 00000010b
-01010011b & 10101111b = 00000011b
-01010011b & 10110000b = 00010000b
-01010011b & 10110001b = 00010001b
-01010011b & 10110010b = 00010010b
-01010011b & 10110011b = 00010011b
-01010011b & 10110100b = 00010000b
-01010011b & 10110101b = 00010001b
-01010011b & 10110110b = 00010010b
-01010011b & 10110111b = 00010011b
-01010011b & 10111000b = 00010000b
-01010011b & 10111001b = 00010001b
-01010011b & 10111010b = 00010010b
-01010011b & 10111011b = 00010011b
-01010011b & 10111100b = 00010000b
-01010011b & 10111101b = 00010001b
-01010011b & 10111110b = 00010010b
-01010011b & 10111111b = 00010011b
-01010011b & 11000000b = 01000000b
-01010011b & 11000001b = 01000001b
-01010011b & 11000010b = 01000010b
-01010011b & 11000011b = 01000011b
-01010011b & 11000100b = 01000000b
-01010011b & 11000101b = 01000001b
-01010011b & 11000110b = 01000010b
-01010011b & 11000111b = 01000011b
-01010011b & 11001000b = 01000000b
-01010011b & 11001001b = 01000001b
-01010011b & 11001010b = 01000010b
-01010011b & 11001011b = 01000011b
-01010011b & 11001100b = 01000000b
-01010011b & 11001101b = 01000001b
-01010011b & 11001110b = 01000010b
-01010011b & 11001111b = 01000011b
-01010011b & 11010000b = 01010000b
-01010011b & 11010001b = 01010001b
-01010011b & 11010010b = 01010010b
-01010011b & 11010011b = 01010011b
-01010011b & 11010100b = 01010000b
-01010011b & 11010101b = 01010001b
-01010011b & 11010110b = 01010010b
-01010011b & 11010111b = 01010011b
-01010011b & 11011000b = 01010000b
-01010011b & 11011001b = 01010001b
-01010011b & 11011010b = 01010010b
-01010011b & 11011011b = 01010011b
-01010011b & 11011100b = 01010000b
-01010011b & 11011101b = 01010001b
-01010011b & 11011110b = 01010010b
-01010011b & 11011111b = 01010011b
-01010011b & 11100000b = 01000000b
-01010011b & 11100001b = 01000001b
-01010011b & 11100010b = 01000010b
-01010011b & 11100011b = 01000011b
-01010011b & 11100100b = 01000000b
-01010011b & 11100101b = 01000001b
-01010011b & 11100110b = 01000010b
-01010011b & 11100111b = 01000011b
-01010011b & 11101000b = 01000000b
-01010011b & 11101001b = 01000001b
-01010011b & 11101010b = 01000010b
-01010011b & 11101011b = 01000011b
-01010011b & 11101100b = 01000000b
-01010011b & 11101101b = 01000001b
-01010011b & 11101110b = 01000010b
-01010011b & 11101111b = 01000011b
-01010011b & 11110000b = 01010000b
-01010011b & 11110001b = 01010001b
-01010011b & 11110010b = 01010010b
-01010011b & 11110011b = 01010011b
-01010011b & 11110100b = 01010000b
-01010011b & 11110101b = 01010001b
-01010011b & 11110110b = 01010010b
-01010011b & 11110111b = 01010011b
-01010011b & 11111000b = 01010000b
-01010011b & 11111001b = 01010001b
-01010011b & 11111010b = 01010010b
-01010011b & 11111011b = 01010011b
-01010011b & 11111100b = 01010000b
-01010011b & 11111101b = 01010001b
-01010011b & 11111110b = 01010010b
-01010011b & 11111111b = 01010011b
-01010011b & 00000000b = 00000000b
-01010011b & 00000001b = 00000001b
-01010011b & 00000010b = 00000010b
-01010011b & 00000011b = 00000011b
-01010011b & 00000100b = 00000000b
-01010011b & 00000101b = 00000001b
-01010011b & 00000110b = 00000010b
-01010011b & 00000111b = 00000011b
-01010011b & 00001000b = 00000000b
-01010011b & 00001001b = 00000001b
-01010011b & 00001010b = 00000010b
-01010011b & 00001011b = 00000011b
-01010011b & 00001100b = 00000000b
-01010011b & 00001101b = 00000001b
-01010011b & 00001110b = 00000010b
-01010011b & 00001111b = 00000011b
-01010011b & 00010000b = 00010000b
-01010011b & 00010001b = 00010001b
-01010011b & 00010010b = 00010010b
-01010011b & 00010011b = 00010011b
-01010011b & 00010100b = 00010000b
-01010011b & 00010101b = 00010001b
-01010011b & 00010110b = 00010010b
-01010011b & 00010111b = 00010011b
-01010011b & 00011000b = 00010000b
-01010011b & 00011001b = 00010001b
-01010011b & 00011010b = 00010010b
-01010011b & 00011011b = 00010011b
-01010011b & 00011100b = 00010000b
-01010011b & 00011101b = 00010001b
-01010011b & 00011110b = 00010010b
-01010011b & 00011111b = 00010011b
-01010011b & 00100000b = 00000000b
-01010011b & 00100001b = 00000001b
-01010011b & 00100010b = 00000010b
-01010011b & 00100011b = 00000011b
-01010011b & 00100100b = 00000000b
-01010011b & 00100101b = 00000001b
-01010011b & 00100110b = 00000010b
-01010011b & 00100111b = 00000011b
-01010011b & 00101000b = 00000000b
-01010011b & 00101001b = 00000001b
-01010011b & 00101010b = 00000010b
-01010011b & 00101011b = 00000011b
-01010011b & 00101100b = 00000000b
-01010011b & 00101101b = 00000001b
-01010011b & 00101110b = 00000010b
-01010011b & 00101111b = 00000011b
-01010011b & 00110000b = 00010000b
-01010011b & 00110001b = 00010001b
-01010011b & 00110010b = 00010010b
-01010011b & 00110011b = 00010011b
-01010011b & 00110100b = 00010000b
-01010011b & 00110101b = 00010001b
-01010011b & 00110110b = 00010010b
-01010011b & 00110111b = 00010011b
-01010011b & 00111000b = 00010000b
-01010011b & 00111001b = 00010001b
-01010011b & 00111010b = 00010010b
-01010011b & 00111011b = 00010011b
-01010011b & 00111100b = 00010000b
-01010011b & 00111101b = 00010001b
-01010011b & 00111110b = 00010010b
-01010011b & 00111111b = 00010011b
-01010011b & 01000000b = 01000000b
-01010011b & 01000001b = 01000001b
-01010011b & 01000010b = 01000010b
-01010011b & 01000011b = 01000011b
-01010011b & 01000100b = 01000000b
-01010011b & 01000101b = 01000001b
-01010011b & 01000110b = 01000010b
-01010011b & 01000111b = 01000011b
-01010011b & 01001000b = 01000000b
-01010011b & 01001001b = 01000001b
-01010011b & 01001010b = 01000010b
-01010011b & 01001011b = 01000011b
-01010011b & 01001100b = 01000000b
-01010011b & 01001101b = 01000001b
-01010011b & 01001110b = 01000010b
-01010011b & 01001111b = 01000011b
-01010011b & 01010000b = 01010000b
-01010011b & 01010001b = 01010001b
-01010011b & 01010010b = 01010010b
-01010011b & 01010011b = 01010011b
-01010011b & 01010100b = 01010000b
-01010011b & 01010101b = 01010001b
-01010011b & 01010110b = 01010010b
-01010011b & 01010111b = 01010011b
-01010011b & 01011000b = 01010000b
-01010011b & 01011001b = 01010001b
-01010011b & 01011010b = 01010010b
-01010011b & 01011011b = 01010011b
-01010011b & 01011100b = 01010000b
-01010011b & 01011101b = 01010001b
-01010011b & 01011110b = 01010010b
-01010011b & 01011111b = 01010011b
-01010011b & 01100000b = 01000000b
-01010011b & 01100001b = 01000001b
-01010011b & 01100010b = 01000010b
-01010011b & 01100011b = 01000011b
-01010011b & 01100100b = 01000000b
-01010011b & 01100101b = 01000001b
-01010011b & 01100110b = 01000010b
-01010011b & 01100111b = 01000011b
-01010011b & 01101000b = 01000000b
-01010011b & 01101001b = 01000001b
-01010011b & 01101010b = 01000010b
-01010011b & 01101011b = 01000011b
-01010011b & 01101100b = 01000000b
-01010011b & 01101101b = 01000001b
-01010011b & 01101110b = 01000010b
-01010011b & 01101111b = 01000011b
-01010011b & 01110000b = 01010000b
-01010011b & 01110001b = 01010001b
-01010011b & 01110010b = 01010010b
-01010011b & 01110011b = 01010011b
-01010011b & 01110100b = 01010000b
-01010011b & 01110101b = 01010001b
-01010011b & 01110110b = 01010010b
-01010011b & 01110111b = 01010011b
-01010011b & 01111000b = 01010000b
-01010011b & 01111001b = 01010001b
-01010011b & 01111010b = 01010010b
-01010011b & 01111011b = 01010011b
-01010011b & 01111100b = 01010000b
-01010011b & 01111101b = 01010001b
-01010011b & 01111110b = 01010010b
-01010100b & 10000000b = 00000000b
-01010100b & 10000001b = 00000000b
-01010100b & 10000010b = 00000000b
-01010100b & 10000011b = 00000000b
-01010100b & 10000100b = 00000100b
-01010100b & 10000101b = 00000100b
-01010100b & 10000110b = 00000100b
-01010100b & 10000111b = 00000100b
-01010100b & 10001000b = 00000000b
-01010100b & 10001001b = 00000000b
-01010100b & 10001010b = 00000000b
-01010100b & 10001011b = 00000000b
-01010100b & 10001100b = 00000100b
-01010100b & 10001101b = 00000100b
-01010100b & 10001110b = 00000100b
-01010100b & 10001111b = 00000100b
-01010100b & 10010000b = 00010000b
-01010100b & 10010001b = 00010000b
-01010100b & 10010010b = 00010000b
-01010100b & 10010011b = 00010000b
-01010100b & 10010100b = 00010100b
-01010100b & 10010101b = 00010100b
-01010100b & 10010110b = 00010100b
-01010100b & 10010111b = 00010100b
-01010100b & 10011000b = 00010000b
-01010100b & 10011001b = 00010000b
-01010100b & 10011010b = 00010000b
-01010100b & 10011011b = 00010000b
-01010100b & 10011100b = 00010100b
-01010100b & 10011101b = 00010100b
-01010100b & 10011110b = 00010100b
-01010100b & 10011111b = 00010100b
-01010100b & 10100000b = 00000000b
-01010100b & 10100001b = 00000000b
-01010100b & 10100010b = 00000000b
-01010100b & 10100011b = 00000000b
-01010100b & 10100100b = 00000100b
-01010100b & 10100101b = 00000100b
-01010100b & 10100110b = 00000100b
-01010100b & 10100111b = 00000100b
-01010100b & 10101000b = 00000000b
-01010100b & 10101001b = 00000000b
-01010100b & 10101010b = 00000000b
-01010100b & 10101011b = 00000000b
-01010100b & 10101100b = 00000100b
-01010100b & 10101101b = 00000100b
-01010100b & 10101110b = 00000100b
-01010100b & 10101111b = 00000100b
-01010100b & 10110000b = 00010000b
-01010100b & 10110001b = 00010000b
-01010100b & 10110010b = 00010000b
-01010100b & 10110011b = 00010000b
-01010100b & 10110100b = 00010100b
-01010100b & 10110101b = 00010100b
-01010100b & 10110110b = 00010100b
-01010100b & 10110111b = 00010100b
-01010100b & 10111000b = 00010000b
-01010100b & 10111001b = 00010000b
-01010100b & 10111010b = 00010000b
-01010100b & 10111011b = 00010000b
-01010100b & 10111100b = 00010100b
-01010100b & 10111101b = 00010100b
-01010100b & 10111110b = 00010100b
-01010100b & 10111111b = 00010100b
-01010100b & 11000000b = 01000000b
-01010100b & 11000001b = 01000000b
-01010100b & 11000010b = 01000000b
-01010100b & 11000011b = 01000000b
-01010100b & 11000100b = 01000100b
-01010100b & 11000101b = 01000100b
-01010100b & 11000110b = 01000100b
-01010100b & 11000111b = 01000100b
-01010100b & 11001000b = 01000000b
-01010100b & 11001001b = 01000000b
-01010100b & 11001010b = 01000000b
-01010100b & 11001011b = 01000000b
-01010100b & 11001100b = 01000100b
-01010100b & 11001101b = 01000100b
-01010100b & 11001110b = 01000100b
-01010100b & 11001111b = 01000100b
-01010100b & 11010000b = 01010000b
-01010100b & 11010001b = 01010000b
-01010100b & 11010010b = 01010000b
-01010100b & 11010011b = 01010000b
-01010100b & 11010100b = 01010100b
-01010100b & 11010101b = 01010100b
-01010100b & 11010110b = 01010100b
-01010100b & 11010111b = 01010100b
-01010100b & 11011000b = 01010000b
-01010100b & 11011001b = 01010000b
-01010100b & 11011010b = 01010000b
-01010100b & 11011011b = 01010000b
-01010100b & 11011100b = 01010100b
-01010100b & 11011101b = 01010100b
-01010100b & 11011110b = 01010100b
-01010100b & 11011111b = 01010100b
-01010100b & 11100000b = 01000000b
-01010100b & 11100001b = 01000000b
-01010100b & 11100010b = 01000000b
-01010100b & 11100011b = 01000000b
-01010100b & 11100100b = 01000100b
-01010100b & 11100101b = 01000100b
-01010100b & 11100110b = 01000100b
-01010100b & 11100111b = 01000100b
-01010100b & 11101000b = 01000000b
-01010100b & 11101001b = 01000000b
-01010100b & 11101010b = 01000000b
-01010100b & 11101011b = 01000000b
-01010100b & 11101100b = 01000100b
-01010100b & 11101101b = 01000100b
-01010100b & 11101110b = 01000100b
-01010100b & 11101111b = 01000100b
-01010100b & 11110000b = 01010000b
-01010100b & 11110001b = 01010000b
-01010100b & 11110010b = 01010000b
-01010100b & 11110011b = 01010000b
-01010100b & 11110100b = 01010100b
-01010100b & 11110101b = 01010100b
-01010100b & 11110110b = 01010100b
-01010100b & 11110111b = 01010100b
-01010100b & 11111000b = 01010000b
-01010100b & 11111001b = 01010000b
-01010100b & 11111010b = 01010000b
-01010100b & 11111011b = 01010000b
-01010100b & 11111100b = 01010100b
-01010100b & 11111101b = 01010100b
-01010100b & 11111110b = 01010100b
-01010100b & 11111111b = 01010100b
-01010100b & 00000000b = 00000000b
-01010100b & 00000001b = 00000000b
-01010100b & 00000010b = 00000000b
-01010100b & 00000011b = 00000000b
-01010100b & 00000100b = 00000100b
-01010100b & 00000101b = 00000100b
-01010100b & 00000110b = 00000100b
-01010100b & 00000111b = 00000100b
-01010100b & 00001000b = 00000000b
-01010100b & 00001001b = 00000000b
-01010100b & 00001010b = 00000000b
-01010100b & 00001011b = 00000000b
-01010100b & 00001100b = 00000100b
-01010100b & 00001101b = 00000100b
-01010100b & 00001110b = 00000100b
-01010100b & 00001111b = 00000100b
-01010100b & 00010000b = 00010000b
-01010100b & 00010001b = 00010000b
-01010100b & 00010010b = 00010000b
-01010100b & 00010011b = 00010000b
-01010100b & 00010100b = 00010100b
-01010100b & 00010101b = 00010100b
-01010100b & 00010110b = 00010100b
-01010100b & 00010111b = 00010100b
-01010100b & 00011000b = 00010000b
-01010100b & 00011001b = 00010000b
-01010100b & 00011010b = 00010000b
-01010100b & 00011011b = 00010000b
-01010100b & 00011100b = 00010100b
-01010100b & 00011101b = 00010100b
-01010100b & 00011110b = 00010100b
-01010100b & 00011111b = 00010100b
-01010100b & 00100000b = 00000000b
-01010100b & 00100001b = 00000000b
-01010100b & 00100010b = 00000000b
-01010100b & 00100011b = 00000000b
-01010100b & 00100100b = 00000100b
-01010100b & 00100101b = 00000100b
-01010100b & 00100110b = 00000100b
-01010100b & 00100111b = 00000100b
-01010100b & 00101000b = 00000000b
-01010100b & 00101001b = 00000000b
-01010100b & 00101010b = 00000000b
-01010100b & 00101011b = 00000000b
-01010100b & 00101100b = 00000100b
-01010100b & 00101101b = 00000100b
-01010100b & 00101110b = 00000100b
-01010100b & 00101111b = 00000100b
-01010100b & 00110000b = 00010000b
-01010100b & 00110001b = 00010000b
-01010100b & 00110010b = 00010000b
-01010100b & 00110011b = 00010000b
-01010100b & 00110100b = 00010100b
-01010100b & 00110101b = 00010100b
-01010100b & 00110110b = 00010100b
-01010100b & 00110111b = 00010100b
-01010100b & 00111000b = 00010000b
-01010100b & 00111001b = 00010000b
-01010100b & 00111010b = 00010000b
-01010100b & 00111011b = 00010000b
-01010100b & 00111100b = 00010100b
-01010100b & 00111101b = 00010100b
-01010100b & 00111110b = 00010100b
-01010100b & 00111111b = 00010100b
-01010100b & 01000000b = 01000000b
-01010100b & 01000001b = 01000000b
-01010100b & 01000010b = 01000000b
-01010100b & 01000011b = 01000000b
-01010100b & 01000100b = 01000100b
-01010100b & 01000101b = 01000100b
-01010100b & 01000110b = 01000100b
-01010100b & 01000111b = 01000100b
-01010100b & 01001000b = 01000000b
-01010100b & 01001001b = 01000000b
-01010100b & 01001010b = 01000000b
-01010100b & 01001011b = 01000000b
-01010100b & 01001100b = 01000100b
-01010100b & 01001101b = 01000100b
-01010100b & 01001110b = 01000100b
-01010100b & 01001111b = 01000100b
-01010100b & 01010000b = 01010000b
-01010100b & 01010001b = 01010000b
-01010100b & 01010010b = 01010000b
-01010100b & 01010011b = 01010000b
-01010100b & 01010100b = 01010100b
-01010100b & 01010101b = 01010100b
-01010100b & 01010110b = 01010100b
-01010100b & 01010111b = 01010100b
-01010100b & 01011000b = 01010000b
-01010100b & 01011001b = 01010000b
-01010100b & 01011010b = 01010000b
-01010100b & 01011011b = 01010000b
-01010100b & 01011100b = 01010100b
-01010100b & 01011101b = 01010100b
-01010100b & 01011110b = 01010100b
-01010100b & 01011111b = 01010100b
-01010100b & 01100000b = 01000000b
-01010100b & 01100001b = 01000000b
-01010100b & 01100010b = 01000000b
-01010100b & 01100011b = 01000000b
-01010100b & 01100100b = 01000100b
-01010100b & 01100101b = 01000100b
-01010100b & 01100110b = 01000100b
-01010100b & 01100111b = 01000100b
-01010100b & 01101000b = 01000000b
-01010100b & 01101001b = 01000000b
-01010100b & 01101010b = 01000000b
-01010100b & 01101011b = 01000000b
-01010100b & 01101100b = 01000100b
-01010100b & 01101101b = 01000100b
-01010100b & 01101110b = 01000100b
-01010100b & 01101111b = 01000100b
-01010100b & 01110000b = 01010000b
-01010100b & 01110001b = 01010000b
-01010100b & 01110010b = 01010000b
-01010100b & 01110011b = 01010000b
-01010100b & 01110100b = 01010100b
-01010100b & 01110101b = 01010100b
-01010100b & 01110110b = 01010100b
-01010100b & 01110111b = 01010100b
-01010100b & 01111000b = 01010000b
-01010100b & 01111001b = 01010000b
-01010100b & 01111010b = 01010000b
-01010100b & 01111011b = 01010000b
-01010100b & 01111100b = 01010100b
-01010100b & 01111101b = 01010100b
-01010100b & 01111110b = 01010100b
-01010101b & 10000000b = 00000000b
-01010101b & 10000001b = 00000001b
-01010101b & 10000010b = 00000000b
-01010101b & 10000011b = 00000001b
-01010101b & 10000100b = 00000100b
-01010101b & 10000101b = 00000101b
-01010101b & 10000110b = 00000100b
-01010101b & 10000111b = 00000101b
-01010101b & 10001000b = 00000000b
-01010101b & 10001001b = 00000001b
-01010101b & 10001010b = 00000000b
-01010101b & 10001011b = 00000001b
-01010101b & 10001100b = 00000100b
-01010101b & 10001101b = 00000101b
-01010101b & 10001110b = 00000100b
-01010101b & 10001111b = 00000101b
-01010101b & 10010000b = 00010000b
-01010101b & 10010001b = 00010001b
-01010101b & 10010010b = 00010000b
-01010101b & 10010011b = 00010001b
-01010101b & 10010100b = 00010100b
-01010101b & 10010101b = 00010101b
-01010101b & 10010110b = 00010100b
-01010101b & 10010111b = 00010101b
-01010101b & 10011000b = 00010000b
-01010101b & 10011001b = 00010001b
-01010101b & 10011010b = 00010000b
-01010101b & 10011011b = 00010001b
-01010101b & 10011100b = 00010100b
-01010101b & 10011101b = 00010101b
-01010101b & 10011110b = 00010100b
-01010101b & 10011111b = 00010101b
-01010101b & 10100000b = 00000000b
-01010101b & 10100001b = 00000001b
-01010101b & 10100010b = 00000000b
-01010101b & 10100011b = 00000001b
-01010101b & 10100100b = 00000100b
-01010101b & 10100101b = 00000101b
-01010101b & 10100110b = 00000100b
-01010101b & 10100111b = 00000101b
-01010101b & 10101000b = 00000000b
-01010101b & 10101001b = 00000001b
-01010101b & 10101010b = 00000000b
-01010101b & 10101011b = 00000001b
-01010101b & 10101100b = 00000100b
-01010101b & 10101101b = 00000101b
-01010101b & 10101110b = 00000100b
-01010101b & 10101111b = 00000101b
-01010101b & 10110000b = 00010000b
-01010101b & 10110001b = 00010001b
-01010101b & 10110010b = 00010000b
-01010101b & 10110011b = 00010001b
-01010101b & 10110100b = 00010100b
-01010101b & 10110101b = 00010101b
-01010101b & 10110110b = 00010100b
-01010101b & 10110111b = 00010101b
-01010101b & 10111000b = 00010000b
-01010101b & 10111001b = 00010001b
-01010101b & 10111010b = 00010000b
-01010101b & 10111011b = 00010001b
-01010101b & 10111100b = 00010100b
-01010101b & 10111101b = 00010101b
-01010101b & 10111110b = 00010100b
-01010101b & 10111111b = 00010101b
-01010101b & 11000000b = 01000000b
-01010101b & 11000001b = 01000001b
-01010101b & 11000010b = 01000000b
-01010101b & 11000011b = 01000001b
-01010101b & 11000100b = 01000100b
-01010101b & 11000101b = 01000101b
-01010101b & 11000110b = 01000100b
-01010101b & 11000111b = 01000101b
-01010101b & 11001000b = 01000000b
-01010101b & 11001001b = 01000001b
-01010101b & 11001010b = 01000000b
-01010101b & 11001011b = 01000001b
-01010101b & 11001100b = 01000100b
-01010101b & 11001101b = 01000101b
-01010101b & 11001110b = 01000100b
-01010101b & 11001111b = 01000101b
-01010101b & 11010000b = 01010000b
-01010101b & 11010001b = 01010001b
-01010101b & 11010010b = 01010000b
-01010101b & 11010011b = 01010001b
-01010101b & 11010100b = 01010100b
-01010101b & 11010101b = 01010101b
-01010101b & 11010110b = 01010100b
-01010101b & 11010111b = 01010101b
-01010101b & 11011000b = 01010000b
-01010101b & 11011001b = 01010001b
-01010101b & 11011010b = 01010000b
-01010101b & 11011011b = 01010001b
-01010101b & 11011100b = 01010100b
-01010101b & 11011101b = 01010101b
-01010101b & 11011110b = 01010100b
-01010101b & 11011111b = 01010101b
-01010101b & 11100000b = 01000000b
-01010101b & 11100001b = 01000001b
-01010101b & 11100010b = 01000000b
-01010101b & 11100011b = 01000001b
-01010101b & 11100100b = 01000100b
-01010101b & 11100101b = 01000101b
-01010101b & 11100110b = 01000100b
-01010101b & 11100111b = 01000101b
-01010101b & 11101000b = 01000000b
-01010101b & 11101001b = 01000001b
-01010101b & 11101010b = 01000000b
-01010101b & 11101011b = 01000001b
-01010101b & 11101100b = 01000100b
-01010101b & 11101101b = 01000101b
-01010101b & 11101110b = 01000100b
-01010101b & 11101111b = 01000101b
-01010101b & 11110000b = 01010000b
-01010101b & 11110001b = 01010001b
-01010101b & 11110010b = 01010000b
-01010101b & 11110011b = 01010001b
-01010101b & 11110100b = 01010100b
-01010101b & 11110101b = 01010101b
-01010101b & 11110110b = 01010100b
-01010101b & 11110111b = 01010101b
-01010101b & 11111000b = 01010000b
-01010101b & 11111001b = 01010001b
-01010101b & 11111010b = 01010000b
-01010101b & 11111011b = 01010001b
-01010101b & 11111100b = 01010100b
-01010101b & 11111101b = 01010101b
-01010101b & 11111110b = 01010100b
-01010101b & 11111111b = 01010101b
-01010101b & 00000000b = 00000000b
-01010101b & 00000001b = 00000001b
-01010101b & 00000010b = 00000000b
-01010101b & 00000011b = 00000001b
-01010101b & 00000100b = 00000100b
-01010101b & 00000101b = 00000101b
-01010101b & 00000110b = 00000100b
-01010101b & 00000111b = 00000101b
-01010101b & 00001000b = 00000000b
-01010101b & 00001001b = 00000001b
-01010101b & 00001010b = 00000000b
-01010101b & 00001011b = 00000001b
-01010101b & 00001100b = 00000100b
-01010101b & 00001101b = 00000101b
-01010101b & 00001110b = 00000100b
-01010101b & 00001111b = 00000101b
-01010101b & 00010000b = 00010000b
-01010101b & 00010001b = 00010001b
-01010101b & 00010010b = 00010000b
-01010101b & 00010011b = 00010001b
-01010101b & 00010100b = 00010100b
-01010101b & 00010101b = 00010101b
-01010101b & 00010110b = 00010100b
-01010101b & 00010111b = 00010101b
-01010101b & 00011000b = 00010000b
-01010101b & 00011001b = 00010001b
-01010101b & 00011010b = 00010000b
-01010101b & 00011011b = 00010001b
-01010101b & 00011100b = 00010100b
-01010101b & 00011101b = 00010101b
-01010101b & 00011110b = 00010100b
-01010101b & 00011111b = 00010101b
-01010101b & 00100000b = 00000000b
-01010101b & 00100001b = 00000001b
-01010101b & 00100010b = 00000000b
-01010101b & 00100011b = 00000001b
-01010101b & 00100100b = 00000100b
-01010101b & 00100101b = 00000101b
-01010101b & 00100110b = 00000100b
-01010101b & 00100111b = 00000101b
-01010101b & 00101000b = 00000000b
-01010101b & 00101001b = 00000001b
-01010101b & 00101010b = 00000000b
-01010101b & 00101011b = 00000001b
-01010101b & 00101100b = 00000100b
-01010101b & 00101101b = 00000101b
-01010101b & 00101110b = 00000100b
-01010101b & 00101111b = 00000101b
-01010101b & 00110000b = 00010000b
-01010101b & 00110001b = 00010001b
-01010101b & 00110010b = 00010000b
-01010101b & 00110011b = 00010001b
-01010101b & 00110100b = 00010100b
-01010101b & 00110101b = 00010101b
-01010101b & 00110110b = 00010100b
-01010101b & 00110111b = 00010101b
-01010101b & 00111000b = 00010000b
-01010101b & 00111001b = 00010001b
-01010101b & 00111010b = 00010000b
-01010101b & 00111011b = 00010001b
-01010101b & 00111100b = 00010100b
-01010101b & 00111101b = 00010101b
-01010101b & 00111110b = 00010100b
-01010101b & 00111111b = 00010101b
-01010101b & 01000000b = 01000000b
-01010101b & 01000001b = 01000001b
-01010101b & 01000010b = 01000000b
-01010101b & 01000011b = 01000001b
-01010101b & 01000100b = 01000100b
-01010101b & 01000101b = 01000101b
-01010101b & 01000110b = 01000100b
-01010101b & 01000111b = 01000101b
-01010101b & 01001000b = 01000000b
-01010101b & 01001001b = 01000001b
-01010101b & 01001010b = 01000000b
-01010101b & 01001011b = 01000001b
-01010101b & 01001100b = 01000100b
-01010101b & 01001101b = 01000101b
-01010101b & 01001110b = 01000100b
-01010101b & 01001111b = 01000101b
-01010101b & 01010000b = 01010000b
-01010101b & 01010001b = 01010001b
-01010101b & 01010010b = 01010000b
-01010101b & 01010011b = 01010001b
-01010101b & 01010100b = 01010100b
-01010101b & 01010101b = 01010101b
-01010101b & 01010110b = 01010100b
-01010101b & 01010111b = 01010101b
-01010101b & 01011000b = 01010000b
-01010101b & 01011001b = 01010001b
-01010101b & 01011010b = 01010000b
-01010101b & 01011011b = 01010001b
-01010101b & 01011100b = 01010100b
-01010101b & 01011101b = 01010101b
-01010101b & 01011110b = 01010100b
-01010101b & 01011111b = 01010101b
-01010101b & 01100000b = 01000000b
-01010101b & 01100001b = 01000001b
-01010101b & 01100010b = 01000000b
-01010101b & 01100011b = 01000001b
-01010101b & 01100100b = 01000100b
-01010101b & 01100101b = 01000101b
-01010101b & 01100110b = 01000100b
-01010101b & 01100111b = 01000101b
-01010101b & 01101000b = 01000000b
-01010101b & 01101001b = 01000001b
-01010101b & 01101010b = 01000000b
-01010101b & 01101011b = 01000001b
-01010101b & 01101100b = 01000100b
-01010101b & 01101101b = 01000101b
-01010101b & 01101110b = 01000100b
-01010101b & 01101111b = 01000101b
-01010101b & 01110000b = 01010000b
-01010101b & 01110001b = 01010001b
-01010101b & 01110010b = 01010000b
-01010101b & 01110011b = 01010001b
-01010101b & 01110100b = 01010100b
-01010101b & 01110101b = 01010101b
-01010101b & 01110110b = 01010100b
-01010101b & 01110111b = 01010101b
-01010101b & 01111000b = 01010000b
-01010101b & 01111001b = 01010001b
-01010101b & 01111010b = 01010000b
-01010101b & 01111011b = 01010001b
-01010101b & 01111100b = 01010100b
-01010101b & 01111101b = 01010101b
-01010101b & 01111110b = 01010100b
-01010110b & 10000000b = 00000000b
-01010110b & 10000001b = 00000000b
-01010110b & 10000010b = 00000010b
-01010110b & 10000011b = 00000010b
-01010110b & 10000100b = 00000100b
-01010110b & 10000101b = 00000100b
-01010110b & 10000110b = 00000110b
-01010110b & 10000111b = 00000110b
-01010110b & 10001000b = 00000000b
-01010110b & 10001001b = 00000000b
-01010110b & 10001010b = 00000010b
-01010110b & 10001011b = 00000010b
-01010110b & 10001100b = 00000100b
-01010110b & 10001101b = 00000100b
-01010110b & 10001110b = 00000110b
-01010110b & 10001111b = 00000110b
-01010110b & 10010000b = 00010000b
-01010110b & 10010001b = 00010000b
-01010110b & 10010010b = 00010010b
-01010110b & 10010011b = 00010010b
-01010110b & 10010100b = 00010100b
-01010110b & 10010101b = 00010100b
-01010110b & 10010110b = 00010110b
-01010110b & 10010111b = 00010110b
-01010110b & 10011000b = 00010000b
-01010110b & 10011001b = 00010000b
-01010110b & 10011010b = 00010010b
-01010110b & 10011011b = 00010010b
-01010110b & 10011100b = 00010100b
-01010110b & 10011101b = 00010100b
-01010110b & 10011110b = 00010110b
-01010110b & 10011111b = 00010110b
-01010110b & 10100000b = 00000000b
-01010110b & 10100001b = 00000000b
-01010110b & 10100010b = 00000010b
-01010110b & 10100011b = 00000010b
-01010110b & 10100100b = 00000100b
-01010110b & 10100101b = 00000100b
-01010110b & 10100110b = 00000110b
-01010110b & 10100111b = 00000110b
-01010110b & 10101000b = 00000000b
-01010110b & 10101001b = 00000000b
-01010110b & 10101010b = 00000010b
-01010110b & 10101011b = 00000010b
-01010110b & 10101100b = 00000100b
-01010110b & 10101101b = 00000100b
-01010110b & 10101110b = 00000110b
-01010110b & 10101111b = 00000110b
-01010110b & 10110000b = 00010000b
-01010110b & 10110001b = 00010000b
-01010110b & 10110010b = 00010010b
-01010110b & 10110011b = 00010010b
-01010110b & 10110100b = 00010100b
-01010110b & 10110101b = 00010100b
-01010110b & 10110110b = 00010110b
-01010110b & 10110111b = 00010110b
-01010110b & 10111000b = 00010000b
-01010110b & 10111001b = 00010000b
-01010110b & 10111010b = 00010010b
-01010110b & 10111011b = 00010010b
-01010110b & 10111100b = 00010100b
-01010110b & 10111101b = 00010100b
-01010110b & 10111110b = 00010110b
-01010110b & 10111111b = 00010110b
-01010110b & 11000000b = 01000000b
-01010110b & 11000001b = 01000000b
-01010110b & 11000010b = 01000010b
-01010110b & 11000011b = 01000010b
-01010110b & 11000100b = 01000100b
-01010110b & 11000101b = 01000100b
-01010110b & 11000110b = 01000110b
-01010110b & 11000111b = 01000110b
-01010110b & 11001000b = 01000000b
-01010110b & 11001001b = 01000000b
-01010110b & 11001010b = 01000010b
-01010110b & 11001011b = 01000010b
-01010110b & 11001100b = 01000100b
-01010110b & 11001101b = 01000100b
-01010110b & 11001110b = 01000110b
-01010110b & 11001111b = 01000110b
-01010110b & 11010000b = 01010000b
-01010110b & 11010001b = 01010000b
-01010110b & 11010010b = 01010010b
-01010110b & 11010011b = 01010010b
-01010110b & 11010100b = 01010100b
-01010110b & 11010101b = 01010100b
-01010110b & 11010110b = 01010110b
-01010110b & 11010111b = 01010110b
-01010110b & 11011000b = 01010000b
-01010110b & 11011001b = 01010000b
-01010110b & 11011010b = 01010010b
-01010110b & 11011011b = 01010010b
-01010110b & 11011100b = 01010100b
-01010110b & 11011101b = 01010100b
-01010110b & 11011110b = 01010110b
-01010110b & 11011111b = 01010110b
-01010110b & 11100000b = 01000000b
-01010110b & 11100001b = 01000000b
-01010110b & 11100010b = 01000010b
-01010110b & 11100011b = 01000010b
-01010110b & 11100100b = 01000100b
-01010110b & 11100101b = 01000100b
-01010110b & 11100110b = 01000110b
-01010110b & 11100111b = 01000110b
-01010110b & 11101000b = 01000000b
-01010110b & 11101001b = 01000000b
-01010110b & 11101010b = 01000010b
-01010110b & 11101011b = 01000010b
-01010110b & 11101100b = 01000100b
-01010110b & 11101101b = 01000100b
-01010110b & 11101110b = 01000110b
-01010110b & 11101111b = 01000110b
-01010110b & 11110000b = 01010000b
-01010110b & 11110001b = 01010000b
-01010110b & 11110010b = 01010010b
-01010110b & 11110011b = 01010010b
-01010110b & 11110100b = 01010100b
-01010110b & 11110101b = 01010100b
-01010110b & 11110110b = 01010110b
-01010110b & 11110111b = 01010110b
-01010110b & 11111000b = 01010000b
-01010110b & 11111001b = 01010000b
-01010110b & 11111010b = 01010010b
-01010110b & 11111011b = 01010010b
-01010110b & 11111100b = 01010100b
-01010110b & 11111101b = 01010100b
-01010110b & 11111110b = 01010110b
-01010110b & 11111111b = 01010110b
-01010110b & 00000000b = 00000000b
-01010110b & 00000001b = 00000000b
-01010110b & 00000010b = 00000010b
-01010110b & 00000011b = 00000010b
-01010110b & 00000100b = 00000100b
-01010110b & 00000101b = 00000100b
-01010110b & 00000110b = 00000110b
-01010110b & 00000111b = 00000110b
-01010110b & 00001000b = 00000000b
-01010110b & 00001001b = 00000000b
-01010110b & 00001010b = 00000010b
-01010110b & 00001011b = 00000010b
-01010110b & 00001100b = 00000100b
-01010110b & 00001101b = 00000100b
-01010110b & 00001110b = 00000110b
-01010110b & 00001111b = 00000110b
-01010110b & 00010000b = 00010000b
-01010110b & 00010001b = 00010000b
-01010110b & 00010010b = 00010010b
-01010110b & 00010011b = 00010010b
-01010110b & 00010100b = 00010100b
-01010110b & 00010101b = 00010100b
-01010110b & 00010110b = 00010110b
-01010110b & 00010111b = 00010110b
-01010110b & 00011000b = 00010000b
-01010110b & 00011001b = 00010000b
-01010110b & 00011010b = 00010010b
-01010110b & 00011011b = 00010010b
-01010110b & 00011100b = 00010100b
-01010110b & 00011101b = 00010100b
-01010110b & 00011110b = 00010110b
-01010110b & 00011111b = 00010110b
-01010110b & 00100000b = 00000000b
-01010110b & 00100001b = 00000000b
-01010110b & 00100010b = 00000010b
-01010110b & 00100011b = 00000010b
-01010110b & 00100100b = 00000100b
-01010110b & 00100101b = 00000100b
-01010110b & 00100110b = 00000110b
-01010110b & 00100111b = 00000110b
-01010110b & 00101000b = 00000000b
-01010110b & 00101001b = 00000000b
-01010110b & 00101010b = 00000010b
-01010110b & 00101011b = 00000010b
-01010110b & 00101100b = 00000100b
-01010110b & 00101101b = 00000100b
-01010110b & 00101110b = 00000110b
-01010110b & 00101111b = 00000110b
-01010110b & 00110000b = 00010000b
-01010110b & 00110001b = 00010000b
-01010110b & 00110010b = 00010010b
-01010110b & 00110011b = 00010010b
-01010110b & 00110100b = 00010100b
-01010110b & 00110101b = 00010100b
-01010110b & 00110110b = 00010110b
-01010110b & 00110111b = 00010110b
-01010110b & 00111000b = 00010000b
-01010110b & 00111001b = 00010000b
-01010110b & 00111010b = 00010010b
-01010110b & 00111011b = 00010010b
-01010110b & 00111100b = 00010100b
-01010110b & 00111101b = 00010100b
-01010110b & 00111110b = 00010110b
-01010110b & 00111111b = 00010110b
-01010110b & 01000000b = 01000000b
-01010110b & 01000001b = 01000000b
-01010110b & 01000010b = 01000010b
-01010110b & 01000011b = 01000010b
-01010110b & 01000100b = 01000100b
-01010110b & 01000101b = 01000100b
-01010110b & 01000110b = 01000110b
-01010110b & 01000111b = 01000110b
-01010110b & 01001000b = 01000000b
-01010110b & 01001001b = 01000000b
-01010110b & 01001010b = 01000010b
-01010110b & 01001011b = 01000010b
-01010110b & 01001100b = 01000100b
-01010110b & 01001101b = 01000100b
-01010110b & 01001110b = 01000110b
-01010110b & 01001111b = 01000110b
-01010110b & 01010000b = 01010000b
-01010110b & 01010001b = 01010000b
-01010110b & 01010010b = 01010010b
-01010110b & 01010011b = 01010010b
-01010110b & 01010100b = 01010100b
-01010110b & 01010101b = 01010100b
-01010110b & 01010110b = 01010110b
-01010110b & 01010111b = 01010110b
-01010110b & 01011000b = 01010000b
-01010110b & 01011001b = 01010000b
-01010110b & 01011010b = 01010010b
-01010110b & 01011011b = 01010010b
-01010110b & 01011100b = 01010100b
-01010110b & 01011101b = 01010100b
-01010110b & 01011110b = 01010110b
-01010110b & 01011111b = 01010110b
-01010110b & 01100000b = 01000000b
-01010110b & 01100001b = 01000000b
-01010110b & 01100010b = 01000010b
-01010110b & 01100011b = 01000010b
-01010110b & 01100100b = 01000100b
-01010110b & 01100101b = 01000100b
-01010110b & 01100110b = 01000110b
-01010110b & 01100111b = 01000110b
-01010110b & 01101000b = 01000000b
-01010110b & 01101001b = 01000000b
-01010110b & 01101010b = 01000010b
-01010110b & 01101011b = 01000010b
-01010110b & 01101100b = 01000100b
-01010110b & 01101101b = 01000100b
-01010110b & 01101110b = 01000110b
-01010110b & 01101111b = 01000110b
-01010110b & 01110000b = 01010000b
-01010110b & 01110001b = 01010000b
-01010110b & 01110010b = 01010010b
-01010110b & 01110011b = 01010010b
-01010110b & 01110100b = 01010100b
-01010110b & 01110101b = 01010100b
-01010110b & 01110110b = 01010110b
-01010110b & 01110111b = 01010110b
-01010110b & 01111000b = 01010000b
-01010110b & 01111001b = 01010000b
-01010110b & 01111010b = 01010010b
-01010110b & 01111011b = 01010010b
-01010110b & 01111100b = 01010100b
-01010110b & 01111101b = 01010100b
-01010110b & 01111110b = 01010110b
-01010111b & 10000000b = 00000000b
-01010111b & 10000001b = 00000001b
-01010111b & 10000010b = 00000010b
-01010111b & 10000011b = 00000011b
-01010111b & 10000100b = 00000100b
-01010111b & 10000101b = 00000101b
-01010111b & 10000110b = 00000110b
-01010111b & 10000111b = 00000111b
-01010111b & 10001000b = 00000000b
-01010111b & 10001001b = 00000001b
-01010111b & 10001010b = 00000010b
-01010111b & 10001011b = 00000011b
-01010111b & 10001100b = 00000100b
-01010111b & 10001101b = 00000101b
-01010111b & 10001110b = 00000110b
-01010111b & 10001111b = 00000111b
-01010111b & 10010000b = 00010000b
-01010111b & 10010001b = 00010001b
-01010111b & 10010010b = 00010010b
-01010111b & 10010011b = 00010011b
-01010111b & 10010100b = 00010100b
-01010111b & 10010101b = 00010101b
-01010111b & 10010110b = 00010110b
-01010111b & 10010111b = 00010111b
-01010111b & 10011000b = 00010000b
-01010111b & 10011001b = 00010001b
-01010111b & 10011010b = 00010010b
-01010111b & 10011011b = 00010011b
-01010111b & 10011100b = 00010100b
-01010111b & 10011101b = 00010101b
-01010111b & 10011110b = 00010110b
-01010111b & 10011111b = 00010111b
-01010111b & 10100000b = 00000000b
-01010111b & 10100001b = 00000001b
-01010111b & 10100010b = 00000010b
-01010111b & 10100011b = 00000011b
-01010111b & 10100100b = 00000100b
-01010111b & 10100101b = 00000101b
-01010111b & 10100110b = 00000110b
-01010111b & 10100111b = 00000111b
-01010111b & 10101000b = 00000000b
-01010111b & 10101001b = 00000001b
-01010111b & 10101010b = 00000010b
-01010111b & 10101011b = 00000011b
-01010111b & 10101100b = 00000100b
-01010111b & 10101101b = 00000101b
-01010111b & 10101110b = 00000110b
-01010111b & 10101111b = 00000111b
-01010111b & 10110000b = 00010000b
-01010111b & 10110001b = 00010001b
-01010111b & 10110010b = 00010010b
-01010111b & 10110011b = 00010011b
-01010111b & 10110100b = 00010100b
-01010111b & 10110101b = 00010101b
-01010111b & 10110110b = 00010110b
-01010111b & 10110111b = 00010111b
-01010111b & 10111000b = 00010000b
-01010111b & 10111001b = 00010001b
-01010111b & 10111010b = 00010010b
-01010111b & 10111011b = 00010011b
-01010111b & 10111100b = 00010100b
-01010111b & 10111101b = 00010101b
-01010111b & 10111110b = 00010110b
-01010111b & 10111111b = 00010111b
-01010111b & 11000000b = 01000000b
-01010111b & 11000001b = 01000001b
-01010111b & 11000010b = 01000010b
-01010111b & 11000011b = 01000011b
-01010111b & 11000100b = 01000100b
-01010111b & 11000101b = 01000101b
-01010111b & 11000110b = 01000110b
-01010111b & 11000111b = 01000111b
-01010111b & 11001000b = 01000000b
-01010111b & 11001001b = 01000001b
-01010111b & 11001010b = 01000010b
-01010111b & 11001011b = 01000011b
-01010111b & 11001100b = 01000100b
-01010111b & 11001101b = 01000101b
-01010111b & 11001110b = 01000110b
-01010111b & 11001111b = 01000111b
-01010111b & 11010000b = 01010000b
-01010111b & 11010001b = 01010001b
-01010111b & 11010010b = 01010010b
-01010111b & 11010011b = 01010011b
-01010111b & 11010100b = 01010100b
-01010111b & 11010101b = 01010101b
-01010111b & 11010110b = 01010110b
-01010111b & 11010111b = 01010111b
-01010111b & 11011000b = 01010000b
-01010111b & 11011001b = 01010001b
-01010111b & 11011010b = 01010010b
-01010111b & 11011011b = 01010011b
-01010111b & 11011100b = 01010100b
-01010111b & 11011101b = 01010101b
-01010111b & 11011110b = 01010110b
-01010111b & 11011111b = 01010111b
-01010111b & 11100000b = 01000000b
-01010111b & 11100001b = 01000001b
-01010111b & 11100010b = 01000010b
-01010111b & 11100011b = 01000011b
-01010111b & 11100100b = 01000100b
-01010111b & 11100101b = 01000101b
-01010111b & 11100110b = 01000110b
-01010111b & 11100111b = 01000111b
-01010111b & 11101000b = 01000000b
-01010111b & 11101001b = 01000001b
-01010111b & 11101010b = 01000010b
-01010111b & 11101011b = 01000011b
-01010111b & 11101100b = 01000100b
-01010111b & 11101101b = 01000101b
-01010111b & 11101110b = 01000110b
-01010111b & 11101111b = 01000111b
-01010111b & 11110000b = 01010000b
-01010111b & 11110001b = 01010001b
-01010111b & 11110010b = 01010010b
-01010111b & 11110011b = 01010011b
-01010111b & 11110100b = 01010100b
-01010111b & 11110101b = 01010101b
-01010111b & 11110110b = 01010110b
-01010111b & 11110111b = 01010111b
-01010111b & 11111000b = 01010000b
-01010111b & 11111001b = 01010001b
-01010111b & 11111010b = 01010010b
-01010111b & 11111011b = 01010011b
-01010111b & 11111100b = 01010100b
-01010111b & 11111101b = 01010101b
-01010111b & 11111110b = 01010110b
-01010111b & 11111111b = 01010111b
-01010111b & 00000000b = 00000000b
-01010111b & 00000001b = 00000001b
-01010111b & 00000010b = 00000010b
-01010111b & 00000011b = 00000011b
-01010111b & 00000100b = 00000100b
-01010111b & 00000101b = 00000101b
-01010111b & 00000110b = 00000110b
-01010111b & 00000111b = 00000111b
-01010111b & 00001000b = 00000000b
-01010111b & 00001001b = 00000001b
-01010111b & 00001010b = 00000010b
-01010111b & 00001011b = 00000011b
-01010111b & 00001100b = 00000100b
-01010111b & 00001101b = 00000101b
-01010111b & 00001110b = 00000110b
-01010111b & 00001111b = 00000111b
-01010111b & 00010000b = 00010000b
-01010111b & 00010001b = 00010001b
-01010111b & 00010010b = 00010010b
-01010111b & 00010011b = 00010011b
-01010111b & 00010100b = 00010100b
-01010111b & 00010101b = 00010101b
-01010111b & 00010110b = 00010110b
-01010111b & 00010111b = 00010111b
-01010111b & 00011000b = 00010000b
-01010111b & 00011001b = 00010001b
-01010111b & 00011010b = 00010010b
-01010111b & 00011011b = 00010011b
-01010111b & 00011100b = 00010100b
-01010111b & 00011101b = 00010101b
-01010111b & 00011110b = 00010110b
-01010111b & 00011111b = 00010111b
-01010111b & 00100000b = 00000000b
-01010111b & 00100001b = 00000001b
-01010111b & 00100010b = 00000010b
-01010111b & 00100011b = 00000011b
-01010111b & 00100100b = 00000100b
-01010111b & 00100101b = 00000101b
-01010111b & 00100110b = 00000110b
-01010111b & 00100111b = 00000111b
-01010111b & 00101000b = 00000000b
-01010111b & 00101001b = 00000001b
-01010111b & 00101010b = 00000010b
-01010111b & 00101011b = 00000011b
-01010111b & 00101100b = 00000100b
-01010111b & 00101101b = 00000101b
-01010111b & 00101110b = 00000110b
-01010111b & 00101111b = 00000111b
-01010111b & 00110000b = 00010000b
-01010111b & 00110001b = 00010001b
-01010111b & 00110010b = 00010010b
-01010111b & 00110011b = 00010011b
-01010111b & 00110100b = 00010100b
-01010111b & 00110101b = 00010101b
-01010111b & 00110110b = 00010110b
-01010111b & 00110111b = 00010111b
-01010111b & 00111000b = 00010000b
-01010111b & 00111001b = 00010001b
-01010111b & 00111010b = 00010010b
-01010111b & 00111011b = 00010011b
-01010111b & 00111100b = 00010100b
-01010111b & 00111101b = 00010101b
-01010111b & 00111110b = 00010110b
-01010111b & 00111111b = 00010111b
-01010111b & 01000000b = 01000000b
-01010111b & 01000001b = 01000001b
-01010111b & 01000010b = 01000010b
-01010111b & 01000011b = 01000011b
-01010111b & 01000100b = 01000100b
-01010111b & 01000101b = 01000101b
-01010111b & 01000110b = 01000110b
-01010111b & 01000111b = 01000111b
-01010111b & 01001000b = 01000000b
-01010111b & 01001001b = 01000001b
-01010111b & 01001010b = 01000010b
-01010111b & 01001011b = 01000011b
-01010111b & 01001100b = 01000100b
-01010111b & 01001101b = 01000101b
-01010111b & 01001110b = 01000110b
-01010111b & 01001111b = 01000111b
-01010111b & 01010000b = 01010000b
-01010111b & 01010001b = 01010001b
-01010111b & 01010010b = 01010010b
-01010111b & 01010011b = 01010011b
-01010111b & 01010100b = 01010100b
-01010111b & 01010101b = 01010101b
-01010111b & 01010110b = 01010110b
-01010111b & 01010111b = 01010111b
-01010111b & 01011000b = 01010000b
-01010111b & 01011001b = 01010001b
-01010111b & 01011010b = 01010010b
-01010111b & 01011011b = 01010011b
-01010111b & 01011100b = 01010100b
-01010111b & 01011101b = 01010101b
-01010111b & 01011110b = 01010110b
-01010111b & 01011111b = 01010111b
-01010111b & 01100000b = 01000000b
-01010111b & 01100001b = 01000001b
-01010111b & 01100010b = 01000010b
-01010111b & 01100011b = 01000011b
-01010111b & 01100100b = 01000100b
-01010111b & 01100101b = 01000101b
-01010111b & 01100110b = 01000110b
-01010111b & 01100111b = 01000111b
-01010111b & 01101000b = 01000000b
-01010111b & 01101001b = 01000001b
-01010111b & 01101010b = 01000010b
-01010111b & 01101011b = 01000011b
-01010111b & 01101100b = 01000100b
-01010111b & 01101101b = 01000101b
-01010111b & 01101110b = 01000110b
-01010111b & 01101111b = 01000111b
-01010111b & 01110000b = 01010000b
-01010111b & 01110001b = 01010001b
-01010111b & 01110010b = 01010010b
-01010111b & 01110011b = 01010011b
-01010111b & 01110100b = 01010100b
-01010111b & 01110101b = 01010101b
-01010111b & 01110110b = 01010110b
-01010111b & 01110111b = 01010111b
-01010111b & 01111000b = 01010000b
-01010111b & 01111001b = 01010001b
-01010111b & 01111010b = 01010010b
-01010111b & 01111011b = 01010011b
-01010111b & 01111100b = 01010100b
-01010111b & 01111101b = 01010101b
-01010111b & 01111110b = 01010110b
-01011000b & 10000000b = 00000000b
-01011000b & 10000001b = 00000000b
-01011000b & 10000010b = 00000000b
-01011000b & 10000011b = 00000000b
-01011000b & 10000100b = 00000000b
-01011000b & 10000101b = 00000000b
-01011000b & 10000110b = 00000000b
-01011000b & 10000111b = 00000000b
-01011000b & 10001000b = 00001000b
-01011000b & 10001001b = 00001000b
-01011000b & 10001010b = 00001000b
-01011000b & 10001011b = 00001000b
-01011000b & 10001100b = 00001000b
-01011000b & 10001101b = 00001000b
-01011000b & 10001110b = 00001000b
-01011000b & 10001111b = 00001000b
-01011000b & 10010000b = 00010000b
-01011000b & 10010001b = 00010000b
-01011000b & 10010010b = 00010000b
-01011000b & 10010011b = 00010000b
-01011000b & 10010100b = 00010000b
-01011000b & 10010101b = 00010000b
-01011000b & 10010110b = 00010000b
-01011000b & 10010111b = 00010000b
-01011000b & 10011000b = 00011000b
-01011000b & 10011001b = 00011000b
-01011000b & 10011010b = 00011000b
-01011000b & 10011011b = 00011000b
-01011000b & 10011100b = 00011000b
-01011000b & 10011101b = 00011000b
-01011000b & 10011110b = 00011000b
-01011000b & 10011111b = 00011000b
-01011000b & 10100000b = 00000000b
-01011000b & 10100001b = 00000000b
-01011000b & 10100010b = 00000000b
-01011000b & 10100011b = 00000000b
-01011000b & 10100100b = 00000000b
-01011000b & 10100101b = 00000000b
-01011000b & 10100110b = 00000000b
-01011000b & 10100111b = 00000000b
-01011000b & 10101000b = 00001000b
-01011000b & 10101001b = 00001000b
-01011000b & 10101010b = 00001000b
-01011000b & 10101011b = 00001000b
-01011000b & 10101100b = 00001000b
-01011000b & 10101101b = 00001000b
-01011000b & 10101110b = 00001000b
-01011000b & 10101111b = 00001000b
-01011000b & 10110000b = 00010000b
-01011000b & 10110001b = 00010000b
-01011000b & 10110010b = 00010000b
-01011000b & 10110011b = 00010000b
-01011000b & 10110100b = 00010000b
-01011000b & 10110101b = 00010000b
-01011000b & 10110110b = 00010000b
-01011000b & 10110111b = 00010000b
-01011000b & 10111000b = 00011000b
-01011000b & 10111001b = 00011000b
-01011000b & 10111010b = 00011000b
-01011000b & 10111011b = 00011000b
-01011000b & 10111100b = 00011000b
-01011000b & 10111101b = 00011000b
-01011000b & 10111110b = 00011000b
-01011000b & 10111111b = 00011000b
-01011000b & 11000000b = 01000000b
-01011000b & 11000001b = 01000000b
-01011000b & 11000010b = 01000000b
-01011000b & 11000011b = 01000000b
-01011000b & 11000100b = 01000000b
-01011000b & 11000101b = 01000000b
-01011000b & 11000110b = 01000000b
-01011000b & 11000111b = 01000000b
-01011000b & 11001000b = 01001000b
-01011000b & 11001001b = 01001000b
-01011000b & 11001010b = 01001000b
-01011000b & 11001011b = 01001000b
-01011000b & 11001100b = 01001000b
-01011000b & 11001101b = 01001000b
-01011000b & 11001110b = 01001000b
-01011000b & 11001111b = 01001000b
-01011000b & 11010000b = 01010000b
-01011000b & 11010001b = 01010000b
-01011000b & 11010010b = 01010000b
-01011000b & 11010011b = 01010000b
-01011000b & 11010100b = 01010000b
-01011000b & 11010101b = 01010000b
-01011000b & 11010110b = 01010000b
-01011000b & 11010111b = 01010000b
-01011000b & 11011000b = 01011000b
-01011000b & 11011001b = 01011000b
-01011000b & 11011010b = 01011000b
-01011000b & 11011011b = 01011000b
-01011000b & 11011100b = 01011000b
-01011000b & 11011101b = 01011000b
-01011000b & 11011110b = 01011000b
-01011000b & 11011111b = 01011000b
-01011000b & 11100000b = 01000000b
-01011000b & 11100001b = 01000000b
-01011000b & 11100010b = 01000000b
-01011000b & 11100011b = 01000000b
-01011000b & 11100100b = 01000000b
-01011000b & 11100101b = 01000000b
-01011000b & 11100110b = 01000000b
-01011000b & 11100111b = 01000000b
-01011000b & 11101000b = 01001000b
-01011000b & 11101001b = 01001000b
-01011000b & 11101010b = 01001000b
-01011000b & 11101011b = 01001000b
-01011000b & 11101100b = 01001000b
-01011000b & 11101101b = 01001000b
-01011000b & 11101110b = 01001000b
-01011000b & 11101111b = 01001000b
-01011000b & 11110000b = 01010000b
-01011000b & 11110001b = 01010000b
-01011000b & 11110010b = 01010000b
-01011000b & 11110011b = 01010000b
-01011000b & 11110100b = 01010000b
-01011000b & 11110101b = 01010000b
-01011000b & 11110110b = 01010000b
-01011000b & 11110111b = 01010000b
-01011000b & 11111000b = 01011000b
-01011000b & 11111001b = 01011000b
-01011000b & 11111010b = 01011000b
-01011000b & 11111011b = 01011000b
-01011000b & 11111100b = 01011000b
-01011000b & 11111101b = 01011000b
-01011000b & 11111110b = 01011000b
-01011000b & 11111111b = 01011000b
-01011000b & 00000000b = 00000000b
-01011000b & 00000001b = 00000000b
-01011000b & 00000010b = 00000000b
-01011000b & 00000011b = 00000000b
-01011000b & 00000100b = 00000000b
-01011000b & 00000101b = 00000000b
-01011000b & 00000110b = 00000000b
-01011000b & 00000111b = 00000000b
-01011000b & 00001000b = 00001000b
-01011000b & 00001001b = 00001000b
-01011000b & 00001010b = 00001000b
-01011000b & 00001011b = 00001000b
-01011000b & 00001100b = 00001000b
-01011000b & 00001101b = 00001000b
-01011000b & 00001110b = 00001000b
-01011000b & 00001111b = 00001000b
-01011000b & 00010000b = 00010000b
-01011000b & 00010001b = 00010000b
-01011000b & 00010010b = 00010000b
-01011000b & 00010011b = 00010000b
-01011000b & 00010100b = 00010000b
-01011000b & 00010101b = 00010000b
-01011000b & 00010110b = 00010000b
-01011000b & 00010111b = 00010000b
-01011000b & 00011000b = 00011000b
-01011000b & 00011001b = 00011000b
-01011000b & 00011010b = 00011000b
-01011000b & 00011011b = 00011000b
-01011000b & 00011100b = 00011000b
-01011000b & 00011101b = 00011000b
-01011000b & 00011110b = 00011000b
-01011000b & 00011111b = 00011000b
-01011000b & 00100000b = 00000000b
-01011000b & 00100001b = 00000000b
-01011000b & 00100010b = 00000000b
-01011000b & 00100011b = 00000000b
-01011000b & 00100100b = 00000000b
-01011000b & 00100101b = 00000000b
-01011000b & 00100110b = 00000000b
-01011000b & 00100111b = 00000000b
-01011000b & 00101000b = 00001000b
-01011000b & 00101001b = 00001000b
-01011000b & 00101010b = 00001000b
-01011000b & 00101011b = 00001000b
-01011000b & 00101100b = 00001000b
-01011000b & 00101101b = 00001000b
-01011000b & 00101110b = 00001000b
-01011000b & 00101111b = 00001000b
-01011000b & 00110000b = 00010000b
-01011000b & 00110001b = 00010000b
-01011000b & 00110010b = 00010000b
-01011000b & 00110011b = 00010000b
-01011000b & 00110100b = 00010000b
-01011000b & 00110101b = 00010000b
-01011000b & 00110110b = 00010000b
-01011000b & 00110111b = 00010000b
-01011000b & 00111000b = 00011000b
-01011000b & 00111001b = 00011000b
-01011000b & 00111010b = 00011000b
-01011000b & 00111011b = 00011000b
-01011000b & 00111100b = 00011000b
-01011000b & 00111101b = 00011000b
-01011000b & 00111110b = 00011000b
-01011000b & 00111111b = 00011000b
-01011000b & 01000000b = 01000000b
-01011000b & 01000001b = 01000000b
-01011000b & 01000010b = 01000000b
-01011000b & 01000011b = 01000000b
-01011000b & 01000100b = 01000000b
-01011000b & 01000101b = 01000000b
-01011000b & 01000110b = 01000000b
-01011000b & 01000111b = 01000000b
-01011000b & 01001000b = 01001000b
-01011000b & 01001001b = 01001000b
-01011000b & 01001010b = 01001000b
-01011000b & 01001011b = 01001000b
-01011000b & 01001100b = 01001000b
-01011000b & 01001101b = 01001000b
-01011000b & 01001110b = 01001000b
-01011000b & 01001111b = 01001000b
-01011000b & 01010000b = 01010000b
-01011000b & 01010001b = 01010000b
-01011000b & 01010010b = 01010000b
-01011000b & 01010011b = 01010000b
-01011000b & 01010100b = 01010000b
-01011000b & 01010101b = 01010000b
-01011000b & 01010110b = 01010000b
-01011000b & 01010111b = 01010000b
-01011000b & 01011000b = 01011000b
-01011000b & 01011001b = 01011000b
-01011000b & 01011010b = 01011000b
-01011000b & 01011011b = 01011000b
-01011000b & 01011100b = 01011000b
-01011000b & 01011101b = 01011000b
-01011000b & 01011110b = 01011000b
-01011000b & 01011111b = 01011000b
-01011000b & 01100000b = 01000000b
-01011000b & 01100001b = 01000000b
-01011000b & 01100010b = 01000000b
-01011000b & 01100011b = 01000000b
-01011000b & 01100100b = 01000000b
-01011000b & 01100101b = 01000000b
-01011000b & 01100110b = 01000000b
-01011000b & 01100111b = 01000000b
-01011000b & 01101000b = 01001000b
-01011000b & 01101001b = 01001000b
-01011000b & 01101010b = 01001000b
-01011000b & 01101011b = 01001000b
-01011000b & 01101100b = 01001000b
-01011000b & 01101101b = 01001000b
-01011000b & 01101110b = 01001000b
-01011000b & 01101111b = 01001000b
-01011000b & 01110000b = 01010000b
-01011000b & 01110001b = 01010000b
-01011000b & 01110010b = 01010000b
-01011000b & 01110011b = 01010000b
-01011000b & 01110100b = 01010000b
-01011000b & 01110101b = 01010000b
-01011000b & 01110110b = 01010000b
-01011000b & 01110111b = 01010000b
-01011000b & 01111000b = 01011000b
-01011000b & 01111001b = 01011000b
-01011000b & 01111010b = 01011000b
-01011000b & 01111011b = 01011000b
-01011000b & 01111100b = 01011000b
-01011000b & 01111101b = 01011000b
-01011000b & 01111110b = 01011000b
-01011001b & 10000000b = 00000000b
-01011001b & 10000001b = 00000001b
-01011001b & 10000010b = 00000000b
-01011001b & 10000011b = 00000001b
-01011001b & 10000100b = 00000000b
-01011001b & 10000101b = 00000001b
-01011001b & 10000110b = 00000000b
-01011001b & 10000111b = 00000001b
-01011001b & 10001000b = 00001000b
-01011001b & 10001001b = 00001001b
-01011001b & 10001010b = 00001000b
-01011001b & 10001011b = 00001001b
-01011001b & 10001100b = 00001000b
-01011001b & 10001101b = 00001001b
-01011001b & 10001110b = 00001000b
-01011001b & 10001111b = 00001001b
-01011001b & 10010000b = 00010000b
-01011001b & 10010001b = 00010001b
-01011001b & 10010010b = 00010000b
-01011001b & 10010011b = 00010001b
-01011001b & 10010100b = 00010000b
-01011001b & 10010101b = 00010001b
-01011001b & 10010110b = 00010000b
-01011001b & 10010111b = 00010001b
-01011001b & 10011000b = 00011000b
-01011001b & 10011001b = 00011001b
-01011001b & 10011010b = 00011000b
-01011001b & 10011011b = 00011001b
-01011001b & 10011100b = 00011000b
-01011001b & 10011101b = 00011001b
-01011001b & 10011110b = 00011000b
-01011001b & 10011111b = 00011001b
-01011001b & 10100000b = 00000000b
-01011001b & 10100001b = 00000001b
-01011001b & 10100010b = 00000000b
-01011001b & 10100011b = 00000001b
-01011001b & 10100100b = 00000000b
-01011001b & 10100101b = 00000001b
-01011001b & 10100110b = 00000000b
-01011001b & 10100111b = 00000001b
-01011001b & 10101000b = 00001000b
-01011001b & 10101001b = 00001001b
-01011001b & 10101010b = 00001000b
-01011001b & 10101011b = 00001001b
-01011001b & 10101100b = 00001000b
-01011001b & 10101101b = 00001001b
-01011001b & 10101110b = 00001000b
-01011001b & 10101111b = 00001001b
-01011001b & 10110000b = 00010000b
-01011001b & 10110001b = 00010001b
-01011001b & 10110010b = 00010000b
-01011001b & 10110011b = 00010001b
-01011001b & 10110100b = 00010000b
-01011001b & 10110101b = 00010001b
-01011001b & 10110110b = 00010000b
-01011001b & 10110111b = 00010001b
-01011001b & 10111000b = 00011000b
-01011001b & 10111001b = 00011001b
-01011001b & 10111010b = 00011000b
-01011001b & 10111011b = 00011001b
-01011001b & 10111100b = 00011000b
-01011001b & 10111101b = 00011001b
-01011001b & 10111110b = 00011000b
-01011001b & 10111111b = 00011001b
-01011001b & 11000000b = 01000000b
-01011001b & 11000001b = 01000001b
-01011001b & 11000010b = 01000000b
-01011001b & 11000011b = 01000001b
-01011001b & 11000100b = 01000000b
-01011001b & 11000101b = 01000001b
-01011001b & 11000110b = 01000000b
-01011001b & 11000111b = 01000001b
-01011001b & 11001000b = 01001000b
-01011001b & 11001001b = 01001001b
-01011001b & 11001010b = 01001000b
-01011001b & 11001011b = 01001001b
-01011001b & 11001100b = 01001000b
-01011001b & 11001101b = 01001001b
-01011001b & 11001110b = 01001000b
-01011001b & 11001111b = 01001001b
-01011001b & 11010000b = 01010000b
-01011001b & 11010001b = 01010001b
-01011001b & 11010010b = 01010000b
-01011001b & 11010011b = 01010001b
-01011001b & 11010100b = 01010000b
-01011001b & 11010101b = 01010001b
-01011001b & 11010110b = 01010000b
-01011001b & 11010111b = 01010001b
-01011001b & 11011000b = 01011000b
-01011001b & 11011001b = 01011001b
-01011001b & 11011010b = 01011000b
-01011001b & 11011011b = 01011001b
-01011001b & 11011100b = 01011000b
-01011001b & 11011101b = 01011001b
-01011001b & 11011110b = 01011000b
-01011001b & 11011111b = 01011001b
-01011001b & 11100000b = 01000000b
-01011001b & 11100001b = 01000001b
-01011001b & 11100010b = 01000000b
-01011001b & 11100011b = 01000001b
-01011001b & 11100100b = 01000000b
-01011001b & 11100101b = 01000001b
-01011001b & 11100110b = 01000000b
-01011001b & 11100111b = 01000001b
-01011001b & 11101000b = 01001000b
-01011001b & 11101001b = 01001001b
-01011001b & 11101010b = 01001000b
-01011001b & 11101011b = 01001001b
-01011001b & 11101100b = 01001000b
-01011001b & 11101101b = 01001001b
-01011001b & 11101110b = 01001000b
-01011001b & 11101111b = 01001001b
-01011001b & 11110000b = 01010000b
-01011001b & 11110001b = 01010001b
-01011001b & 11110010b = 01010000b
-01011001b & 11110011b = 01010001b
-01011001b & 11110100b = 01010000b
-01011001b & 11110101b = 01010001b
-01011001b & 11110110b = 01010000b
-01011001b & 11110111b = 01010001b
-01011001b & 11111000b = 01011000b
-01011001b & 11111001b = 01011001b
-01011001b & 11111010b = 01011000b
-01011001b & 11111011b = 01011001b
-01011001b & 11111100b = 01011000b
-01011001b & 11111101b = 01011001b
-01011001b & 11111110b = 01011000b
-01011001b & 11111111b = 01011001b
-01011001b & 00000000b = 00000000b
-01011001b & 00000001b = 00000001b
-01011001b & 00000010b = 00000000b
-01011001b & 00000011b = 00000001b
-01011001b & 00000100b = 00000000b
-01011001b & 00000101b = 00000001b
-01011001b & 00000110b = 00000000b
-01011001b & 00000111b = 00000001b
-01011001b & 00001000b = 00001000b
-01011001b & 00001001b = 00001001b
-01011001b & 00001010b = 00001000b
-01011001b & 00001011b = 00001001b
-01011001b & 00001100b = 00001000b
-01011001b & 00001101b = 00001001b
-01011001b & 00001110b = 00001000b
-01011001b & 00001111b = 00001001b
-01011001b & 00010000b = 00010000b
-01011001b & 00010001b = 00010001b
-01011001b & 00010010b = 00010000b
-01011001b & 00010011b = 00010001b
-01011001b & 00010100b = 00010000b
-01011001b & 00010101b = 00010001b
-01011001b & 00010110b = 00010000b
-01011001b & 00010111b = 00010001b
-01011001b & 00011000b = 00011000b
-01011001b & 00011001b = 00011001b
-01011001b & 00011010b = 00011000b
-01011001b & 00011011b = 00011001b
-01011001b & 00011100b = 00011000b
-01011001b & 00011101b = 00011001b
-01011001b & 00011110b = 00011000b
-01011001b & 00011111b = 00011001b
-01011001b & 00100000b = 00000000b
-01011001b & 00100001b = 00000001b
-01011001b & 00100010b = 00000000b
-01011001b & 00100011b = 00000001b
-01011001b & 00100100b = 00000000b
-01011001b & 00100101b = 00000001b
-01011001b & 00100110b = 00000000b
-01011001b & 00100111b = 00000001b
-01011001b & 00101000b = 00001000b
-01011001b & 00101001b = 00001001b
-01011001b & 00101010b = 00001000b
-01011001b & 00101011b = 00001001b
-01011001b & 00101100b = 00001000b
-01011001b & 00101101b = 00001001b
-01011001b & 00101110b = 00001000b
-01011001b & 00101111b = 00001001b
-01011001b & 00110000b = 00010000b
-01011001b & 00110001b = 00010001b
-01011001b & 00110010b = 00010000b
-01011001b & 00110011b = 00010001b
-01011001b & 00110100b = 00010000b
-01011001b & 00110101b = 00010001b
-01011001b & 00110110b = 00010000b
-01011001b & 00110111b = 00010001b
-01011001b & 00111000b = 00011000b
-01011001b & 00111001b = 00011001b
-01011001b & 00111010b = 00011000b
-01011001b & 00111011b = 00011001b
-01011001b & 00111100b = 00011000b
-01011001b & 00111101b = 00011001b
-01011001b & 00111110b = 00011000b
-01011001b & 00111111b = 00011001b
-01011001b & 01000000b = 01000000b
-01011001b & 01000001b = 01000001b
-01011001b & 01000010b = 01000000b
-01011001b & 01000011b = 01000001b
-01011001b & 01000100b = 01000000b
-01011001b & 01000101b = 01000001b
-01011001b & 01000110b = 01000000b
-01011001b & 01000111b = 01000001b
-01011001b & 01001000b = 01001000b
-01011001b & 01001001b = 01001001b
-01011001b & 01001010b = 01001000b
-01011001b & 01001011b = 01001001b
-01011001b & 01001100b = 01001000b
-01011001b & 01001101b = 01001001b
-01011001b & 01001110b = 01001000b
-01011001b & 01001111b = 01001001b
-01011001b & 01010000b = 01010000b
-01011001b & 01010001b = 01010001b
-01011001b & 01010010b = 01010000b
-01011001b & 01010011b = 01010001b
-01011001b & 01010100b = 01010000b
-01011001b & 01010101b = 01010001b
-01011001b & 01010110b = 01010000b
-01011001b & 01010111b = 01010001b
-01011001b & 01011000b = 01011000b
-01011001b & 01011001b = 01011001b
-01011001b & 01011010b = 01011000b
-01011001b & 01011011b = 01011001b
-01011001b & 01011100b = 01011000b
-01011001b & 01011101b = 01011001b
-01011001b & 01011110b = 01011000b
-01011001b & 01011111b = 01011001b
-01011001b & 01100000b = 01000000b
-01011001b & 01100001b = 01000001b
-01011001b & 01100010b = 01000000b
-01011001b & 01100011b = 01000001b
-01011001b & 01100100b = 01000000b
-01011001b & 01100101b = 01000001b
-01011001b & 01100110b = 01000000b
-01011001b & 01100111b = 01000001b
-01011001b & 01101000b = 01001000b
-01011001b & 01101001b = 01001001b
-01011001b & 01101010b = 01001000b
-01011001b & 01101011b = 01001001b
-01011001b & 01101100b = 01001000b
-01011001b & 01101101b = 01001001b
-01011001b & 01101110b = 01001000b
-01011001b & 01101111b = 01001001b
-01011001b & 01110000b = 01010000b
-01011001b & 01110001b = 01010001b
-01011001b & 01110010b = 01010000b
-01011001b & 01110011b = 01010001b
-01011001b & 01110100b = 01010000b
-01011001b & 01110101b = 01010001b
-01011001b & 01110110b = 01010000b
-01011001b & 01110111b = 01010001b
-01011001b & 01111000b = 01011000b
-01011001b & 01111001b = 01011001b
-01011001b & 01111010b = 01011000b
-01011001b & 01111011b = 01011001b
-01011001b & 01111100b = 01011000b
-01011001b & 01111101b = 01011001b
-01011001b & 01111110b = 01011000b
-01011010b & 10000000b = 00000000b
-01011010b & 10000001b = 00000000b
-01011010b & 10000010b = 00000010b
-01011010b & 10000011b = 00000010b
-01011010b & 10000100b = 00000000b
-01011010b & 10000101b = 00000000b
-01011010b & 10000110b = 00000010b
-01011010b & 10000111b = 00000010b
-01011010b & 10001000b = 00001000b
-01011010b & 10001001b = 00001000b
-01011010b & 10001010b = 00001010b
-01011010b & 10001011b = 00001010b
-01011010b & 10001100b = 00001000b
-01011010b & 10001101b = 00001000b
-01011010b & 10001110b = 00001010b
-01011010b & 10001111b = 00001010b
-01011010b & 10010000b = 00010000b
-01011010b & 10010001b = 00010000b
-01011010b & 10010010b = 00010010b
-01011010b & 10010011b = 00010010b
-01011010b & 10010100b = 00010000b
-01011010b & 10010101b = 00010000b
-01011010b & 10010110b = 00010010b
-01011010b & 10010111b = 00010010b
-01011010b & 10011000b = 00011000b
-01011010b & 10011001b = 00011000b
-01011010b & 10011010b = 00011010b
-01011010b & 10011011b = 00011010b
-01011010b & 10011100b = 00011000b
-01011010b & 10011101b = 00011000b
-01011010b & 10011110b = 00011010b
-01011010b & 10011111b = 00011010b
-01011010b & 10100000b = 00000000b
-01011010b & 10100001b = 00000000b
-01011010b & 10100010b = 00000010b
-01011010b & 10100011b = 00000010b
-01011010b & 10100100b = 00000000b
-01011010b & 10100101b = 00000000b
-01011010b & 10100110b = 00000010b
-01011010b & 10100111b = 00000010b
-01011010b & 10101000b = 00001000b
-01011010b & 10101001b = 00001000b
-01011010b & 10101010b = 00001010b
-01011010b & 10101011b = 00001010b
-01011010b & 10101100b = 00001000b
-01011010b & 10101101b = 00001000b
-01011010b & 10101110b = 00001010b
-01011010b & 10101111b = 00001010b
-01011010b & 10110000b = 00010000b
-01011010b & 10110001b = 00010000b
-01011010b & 10110010b = 00010010b
-01011010b & 10110011b = 00010010b
-01011010b & 10110100b = 00010000b
-01011010b & 10110101b = 00010000b
-01011010b & 10110110b = 00010010b
-01011010b & 10110111b = 00010010b
-01011010b & 10111000b = 00011000b
-01011010b & 10111001b = 00011000b
-01011010b & 10111010b = 00011010b
-01011010b & 10111011b = 00011010b
-01011010b & 10111100b = 00011000b
-01011010b & 10111101b = 00011000b
-01011010b & 10111110b = 00011010b
-01011010b & 10111111b = 00011010b
-01011010b & 11000000b = 01000000b
-01011010b & 11000001b = 01000000b
-01011010b & 11000010b = 01000010b
-01011010b & 11000011b = 01000010b
-01011010b & 11000100b = 01000000b
-01011010b & 11000101b = 01000000b
-01011010b & 11000110b = 01000010b
-01011010b & 11000111b = 01000010b
-01011010b & 11001000b = 01001000b
-01011010b & 11001001b = 01001000b
-01011010b & 11001010b = 01001010b
-01011010b & 11001011b = 01001010b
-01011010b & 11001100b = 01001000b
-01011010b & 11001101b = 01001000b
-01011010b & 11001110b = 01001010b
-01011010b & 11001111b = 01001010b
-01011010b & 11010000b = 01010000b
-01011010b & 11010001b = 01010000b
-01011010b & 11010010b = 01010010b
-01011010b & 11010011b = 01010010b
-01011010b & 11010100b = 01010000b
-01011010b & 11010101b = 01010000b
-01011010b & 11010110b = 01010010b
-01011010b & 11010111b = 01010010b
-01011010b & 11011000b = 01011000b
-01011010b & 11011001b = 01011000b
-01011010b & 11011010b = 01011010b
-01011010b & 11011011b = 01011010b
-01011010b & 11011100b = 01011000b
-01011010b & 11011101b = 01011000b
-01011010b & 11011110b = 01011010b
-01011010b & 11011111b = 01011010b
-01011010b & 11100000b = 01000000b
-01011010b & 11100001b = 01000000b
-01011010b & 11100010b = 01000010b
-01011010b & 11100011b = 01000010b
-01011010b & 11100100b = 01000000b
-01011010b & 11100101b = 01000000b
-01011010b & 11100110b = 01000010b
-01011010b & 11100111b = 01000010b
-01011010b & 11101000b = 01001000b
-01011010b & 11101001b = 01001000b
-01011010b & 11101010b = 01001010b
-01011010b & 11101011b = 01001010b
-01011010b & 11101100b = 01001000b
-01011010b & 11101101b = 01001000b
-01011010b & 11101110b = 01001010b
-01011010b & 11101111b = 01001010b
-01011010b & 11110000b = 01010000b
-01011010b & 11110001b = 01010000b
-01011010b & 11110010b = 01010010b
-01011010b & 11110011b = 01010010b
-01011010b & 11110100b = 01010000b
-01011010b & 11110101b = 01010000b
-01011010b & 11110110b = 01010010b
-01011010b & 11110111b = 01010010b
-01011010b & 11111000b = 01011000b
-01011010b & 11111001b = 01011000b
-01011010b & 11111010b = 01011010b
-01011010b & 11111011b = 01011010b
-01011010b & 11111100b = 01011000b
-01011010b & 11111101b = 01011000b
-01011010b & 11111110b = 01011010b
-01011010b & 11111111b = 01011010b
-01011010b & 00000000b = 00000000b
-01011010b & 00000001b = 00000000b
-01011010b & 00000010b = 00000010b
-01011010b & 00000011b = 00000010b
-01011010b & 00000100b = 00000000b
-01011010b & 00000101b = 00000000b
-01011010b & 00000110b = 00000010b
-01011010b & 00000111b = 00000010b
-01011010b & 00001000b = 00001000b
-01011010b & 00001001b = 00001000b
-01011010b & 00001010b = 00001010b
-01011010b & 00001011b = 00001010b
-01011010b & 00001100b = 00001000b
-01011010b & 00001101b = 00001000b
-01011010b & 00001110b = 00001010b
-01011010b & 00001111b = 00001010b
-01011010b & 00010000b = 00010000b
-01011010b & 00010001b = 00010000b
-01011010b & 00010010b = 00010010b
-01011010b & 00010011b = 00010010b
-01011010b & 00010100b = 00010000b
-01011010b & 00010101b = 00010000b
-01011010b & 00010110b = 00010010b
-01011010b & 00010111b = 00010010b
-01011010b & 00011000b = 00011000b
-01011010b & 00011001b = 00011000b
-01011010b & 00011010b = 00011010b
-01011010b & 00011011b = 00011010b
-01011010b & 00011100b = 00011000b
-01011010b & 00011101b = 00011000b
-01011010b & 00011110b = 00011010b
-01011010b & 00011111b = 00011010b
-01011010b & 00100000b = 00000000b
-01011010b & 00100001b = 00000000b
-01011010b & 00100010b = 00000010b
-01011010b & 00100011b = 00000010b
-01011010b & 00100100b = 00000000b
-01011010b & 00100101b = 00000000b
-01011010b & 00100110b = 00000010b
-01011010b & 00100111b = 00000010b
-01011010b & 00101000b = 00001000b
-01011010b & 00101001b = 00001000b
-01011010b & 00101010b = 00001010b
-01011010b & 00101011b = 00001010b
-01011010b & 00101100b = 00001000b
-01011010b & 00101101b = 00001000b
-01011010b & 00101110b = 00001010b
-01011010b & 00101111b = 00001010b
-01011010b & 00110000b = 00010000b
-01011010b & 00110001b = 00010000b
-01011010b & 00110010b = 00010010b
-01011010b & 00110011b = 00010010b
-01011010b & 00110100b = 00010000b
-01011010b & 00110101b = 00010000b
-01011010b & 00110110b = 00010010b
-01011010b & 00110111b = 00010010b
-01011010b & 00111000b = 00011000b
-01011010b & 00111001b = 00011000b
-01011010b & 00111010b = 00011010b
-01011010b & 00111011b = 00011010b
-01011010b & 00111100b = 00011000b
-01011010b & 00111101b = 00011000b
-01011010b & 00111110b = 00011010b
-01011010b & 00111111b = 00011010b
-01011010b & 01000000b = 01000000b
-01011010b & 01000001b = 01000000b
-01011010b & 01000010b = 01000010b
-01011010b & 01000011b = 01000010b
-01011010b & 01000100b = 01000000b
-01011010b & 01000101b = 01000000b
-01011010b & 01000110b = 01000010b
-01011010b & 01000111b = 01000010b
-01011010b & 01001000b = 01001000b
-01011010b & 01001001b = 01001000b
-01011010b & 01001010b = 01001010b
-01011010b & 01001011b = 01001010b
-01011010b & 01001100b = 01001000b
-01011010b & 01001101b = 01001000b
-01011010b & 01001110b = 01001010b
-01011010b & 01001111b = 01001010b
-01011010b & 01010000b = 01010000b
-01011010b & 01010001b = 01010000b
-01011010b & 01010010b = 01010010b
-01011010b & 01010011b = 01010010b
-01011010b & 01010100b = 01010000b
-01011010b & 01010101b = 01010000b
-01011010b & 01010110b = 01010010b
-01011010b & 01010111b = 01010010b
-01011010b & 01011000b = 01011000b
-01011010b & 01011001b = 01011000b
-01011010b & 01011010b = 01011010b
-01011010b & 01011011b = 01011010b
-01011010b & 01011100b = 01011000b
-01011010b & 01011101b = 01011000b
-01011010b & 01011110b = 01011010b
-01011010b & 01011111b = 01011010b
-01011010b & 01100000b = 01000000b
-01011010b & 01100001b = 01000000b
-01011010b & 01100010b = 01000010b
-01011010b & 01100011b = 01000010b
-01011010b & 01100100b = 01000000b
-01011010b & 01100101b = 01000000b
-01011010b & 01100110b = 01000010b
-01011010b & 01100111b = 01000010b
-01011010b & 01101000b = 01001000b
-01011010b & 01101001b = 01001000b
-01011010b & 01101010b = 01001010b
-01011010b & 01101011b = 01001010b
-01011010b & 01101100b = 01001000b
-01011010b & 01101101b = 01001000b
-01011010b & 01101110b = 01001010b
-01011010b & 01101111b = 01001010b
-01011010b & 01110000b = 01010000b
-01011010b & 01110001b = 01010000b
-01011010b & 01110010b = 01010010b
-01011010b & 01110011b = 01010010b
-01011010b & 01110100b = 01010000b
-01011010b & 01110101b = 01010000b
-01011010b & 01110110b = 01010010b
-01011010b & 01110111b = 01010010b
-01011010b & 01111000b = 01011000b
-01011010b & 01111001b = 01011000b
-01011010b & 01111010b = 01011010b
-01011010b & 01111011b = 01011010b
-01011010b & 01111100b = 01011000b
-01011010b & 01111101b = 01011000b
-01011010b & 01111110b = 01011010b
-01011011b & 10000000b = 00000000b
-01011011b & 10000001b = 00000001b
-01011011b & 10000010b = 00000010b
-01011011b & 10000011b = 00000011b
-01011011b & 10000100b = 00000000b
-01011011b & 10000101b = 00000001b
-01011011b & 10000110b = 00000010b
-01011011b & 10000111b = 00000011b
-01011011b & 10001000b = 00001000b
-01011011b & 10001001b = 00001001b
-01011011b & 10001010b = 00001010b
-01011011b & 10001011b = 00001011b
-01011011b & 10001100b = 00001000b
-01011011b & 10001101b = 00001001b
-01011011b & 10001110b = 00001010b
-01011011b & 10001111b = 00001011b
-01011011b & 10010000b = 00010000b
-01011011b & 10010001b = 00010001b
-01011011b & 10010010b = 00010010b
-01011011b & 10010011b = 00010011b
-01011011b & 10010100b = 00010000b
-01011011b & 10010101b = 00010001b
-01011011b & 10010110b = 00010010b
-01011011b & 10010111b = 00010011b
-01011011b & 10011000b = 00011000b
-01011011b & 10011001b = 00011001b
-01011011b & 10011010b = 00011010b
-01011011b & 10011011b = 00011011b
-01011011b & 10011100b = 00011000b
-01011011b & 10011101b = 00011001b
-01011011b & 10011110b = 00011010b
-01011011b & 10011111b = 00011011b
-01011011b & 10100000b = 00000000b
-01011011b & 10100001b = 00000001b
-01011011b & 10100010b = 00000010b
-01011011b & 10100011b = 00000011b
-01011011b & 10100100b = 00000000b
-01011011b & 10100101b = 00000001b
-01011011b & 10100110b = 00000010b
-01011011b & 10100111b = 00000011b
-01011011b & 10101000b = 00001000b
-01011011b & 10101001b = 00001001b
-01011011b & 10101010b = 00001010b
-01011011b & 10101011b = 00001011b
-01011011b & 10101100b = 00001000b
-01011011b & 10101101b = 00001001b
-01011011b & 10101110b = 00001010b
-01011011b & 10101111b = 00001011b
-01011011b & 10110000b = 00010000b
-01011011b & 10110001b = 00010001b
-01011011b & 10110010b = 00010010b
-01011011b & 10110011b = 00010011b
-01011011b & 10110100b = 00010000b
-01011011b & 10110101b = 00010001b
-01011011b & 10110110b = 00010010b
-01011011b & 10110111b = 00010011b
-01011011b & 10111000b = 00011000b
-01011011b & 10111001b = 00011001b
-01011011b & 10111010b = 00011010b
-01011011b & 10111011b = 00011011b
-01011011b & 10111100b = 00011000b
-01011011b & 10111101b = 00011001b
-01011011b & 10111110b = 00011010b
-01011011b & 10111111b = 00011011b
-01011011b & 11000000b = 01000000b
-01011011b & 11000001b = 01000001b
-01011011b & 11000010b = 01000010b
-01011011b & 11000011b = 01000011b
-01011011b & 11000100b = 01000000b
-01011011b & 11000101b = 01000001b
-01011011b & 11000110b = 01000010b
-01011011b & 11000111b = 01000011b
-01011011b & 11001000b = 01001000b
-01011011b & 11001001b = 01001001b
-01011011b & 11001010b = 01001010b
-01011011b & 11001011b = 01001011b
-01011011b & 11001100b = 01001000b
-01011011b & 11001101b = 01001001b
-01011011b & 11001110b = 01001010b
-01011011b & 11001111b = 01001011b
-01011011b & 11010000b = 01010000b
-01011011b & 11010001b = 01010001b
-01011011b & 11010010b = 01010010b
-01011011b & 11010011b = 01010011b
-01011011b & 11010100b = 01010000b
-01011011b & 11010101b = 01010001b
-01011011b & 11010110b = 01010010b
-01011011b & 11010111b = 01010011b
-01011011b & 11011000b = 01011000b
-01011011b & 11011001b = 01011001b
-01011011b & 11011010b = 01011010b
-01011011b & 11011011b = 01011011b
-01011011b & 11011100b = 01011000b
-01011011b & 11011101b = 01011001b
-01011011b & 11011110b = 01011010b
-01011011b & 11011111b = 01011011b
-01011011b & 11100000b = 01000000b
-01011011b & 11100001b = 01000001b
-01011011b & 11100010b = 01000010b
-01011011b & 11100011b = 01000011b
-01011011b & 11100100b = 01000000b
-01011011b & 11100101b = 01000001b
-01011011b & 11100110b = 01000010b
-01011011b & 11100111b = 01000011b
-01011011b & 11101000b = 01001000b
-01011011b & 11101001b = 01001001b
-01011011b & 11101010b = 01001010b
-01011011b & 11101011b = 01001011b
-01011011b & 11101100b = 01001000b
-01011011b & 11101101b = 01001001b
-01011011b & 11101110b = 01001010b
-01011011b & 11101111b = 01001011b
-01011011b & 11110000b = 01010000b
-01011011b & 11110001b = 01010001b
-01011011b & 11110010b = 01010010b
-01011011b & 11110011b = 01010011b
-01011011b & 11110100b = 01010000b
-01011011b & 11110101b = 01010001b
-01011011b & 11110110b = 01010010b
-01011011b & 11110111b = 01010011b
-01011011b & 11111000b = 01011000b
-01011011b & 11111001b = 01011001b
-01011011b & 11111010b = 01011010b
-01011011b & 11111011b = 01011011b
-01011011b & 11111100b = 01011000b
-01011011b & 11111101b = 01011001b
-01011011b & 11111110b = 01011010b
-01011011b & 11111111b = 01011011b
-01011011b & 00000000b = 00000000b
-01011011b & 00000001b = 00000001b
-01011011b & 00000010b = 00000010b
-01011011b & 00000011b = 00000011b
-01011011b & 00000100b = 00000000b
-01011011b & 00000101b = 00000001b
-01011011b & 00000110b = 00000010b
-01011011b & 00000111b = 00000011b
-01011011b & 00001000b = 00001000b
-01011011b & 00001001b = 00001001b
-01011011b & 00001010b = 00001010b
-01011011b & 00001011b = 00001011b
-01011011b & 00001100b = 00001000b
-01011011b & 00001101b = 00001001b
-01011011b & 00001110b = 00001010b
-01011011b & 00001111b = 00001011b
-01011011b & 00010000b = 00010000b
-01011011b & 00010001b = 00010001b
-01011011b & 00010010b = 00010010b
-01011011b & 00010011b = 00010011b
-01011011b & 00010100b = 00010000b
-01011011b & 00010101b = 00010001b
-01011011b & 00010110b = 00010010b
-01011011b & 00010111b = 00010011b
-01011011b & 00011000b = 00011000b
-01011011b & 00011001b = 00011001b
-01011011b & 00011010b = 00011010b
-01011011b & 00011011b = 00011011b
-01011011b & 00011100b = 00011000b
-01011011b & 00011101b = 00011001b
-01011011b & 00011110b = 00011010b
-01011011b & 00011111b = 00011011b
-01011011b & 00100000b = 00000000b
-01011011b & 00100001b = 00000001b
-01011011b & 00100010b = 00000010b
-01011011b & 00100011b = 00000011b
-01011011b & 00100100b = 00000000b
-01011011b & 00100101b = 00000001b
-01011011b & 00100110b = 00000010b
-01011011b & 00100111b = 00000011b
-01011011b & 00101000b = 00001000b
-01011011b & 00101001b = 00001001b
-01011011b & 00101010b = 00001010b
-01011011b & 00101011b = 00001011b
-01011011b & 00101100b = 00001000b
-01011011b & 00101101b = 00001001b
-01011011b & 00101110b = 00001010b
-01011011b & 00101111b = 00001011b
-01011011b & 00110000b = 00010000b
-01011011b & 00110001b = 00010001b
-01011011b & 00110010b = 00010010b
-01011011b & 00110011b = 00010011b
-01011011b & 00110100b = 00010000b
-01011011b & 00110101b = 00010001b
-01011011b & 00110110b = 00010010b
-01011011b & 00110111b = 00010011b
-01011011b & 00111000b = 00011000b
-01011011b & 00111001b = 00011001b
-01011011b & 00111010b = 00011010b
-01011011b & 00111011b = 00011011b
-01011011b & 00111100b = 00011000b
-01011011b & 00111101b = 00011001b
-01011011b & 00111110b = 00011010b
-01011011b & 00111111b = 00011011b
-01011011b & 01000000b = 01000000b
-01011011b & 01000001b = 01000001b
-01011011b & 01000010b = 01000010b
-01011011b & 01000011b = 01000011b
-01011011b & 01000100b = 01000000b
-01011011b & 01000101b = 01000001b
-01011011b & 01000110b = 01000010b
-01011011b & 01000111b = 01000011b
-01011011b & 01001000b = 01001000b
-01011011b & 01001001b = 01001001b
-01011011b & 01001010b = 01001010b
-01011011b & 01001011b = 01001011b
-01011011b & 01001100b = 01001000b
-01011011b & 01001101b = 01001001b
-01011011b & 01001110b = 01001010b
-01011011b & 01001111b = 01001011b
-01011011b & 01010000b = 01010000b
-01011011b & 01010001b = 01010001b
-01011011b & 01010010b = 01010010b
-01011011b & 01010011b = 01010011b
-01011011b & 01010100b = 01010000b
-01011011b & 01010101b = 01010001b
-01011011b & 01010110b = 01010010b
-01011011b & 01010111b = 01010011b
-01011011b & 01011000b = 01011000b
-01011011b & 01011001b = 01011001b
-01011011b & 01011010b = 01011010b
-01011011b & 01011011b = 01011011b
-01011011b & 01011100b = 01011000b
-01011011b & 01011101b = 01011001b
-01011011b & 01011110b = 01011010b
-01011011b & 01011111b = 01011011b
-01011011b & 01100000b = 01000000b
-01011011b & 01100001b = 01000001b
-01011011b & 01100010b = 01000010b
-01011011b & 01100011b = 01000011b
-01011011b & 01100100b = 01000000b
-01011011b & 01100101b = 01000001b
-01011011b & 01100110b = 01000010b
-01011011b & 01100111b = 01000011b
-01011011b & 01101000b = 01001000b
-01011011b & 01101001b = 01001001b
-01011011b & 01101010b = 01001010b
-01011011b & 01101011b = 01001011b
-01011011b & 01101100b = 01001000b
-01011011b & 01101101b = 01001001b
-01011011b & 01101110b = 01001010b
-01011011b & 01101111b = 01001011b
-01011011b & 01110000b = 01010000b
-01011011b & 01110001b = 01010001b
-01011011b & 01110010b = 01010010b
-01011011b & 01110011b = 01010011b
-01011011b & 01110100b = 01010000b
-01011011b & 01110101b = 01010001b
-01011011b & 01110110b = 01010010b
-01011011b & 01110111b = 01010011b
-01011011b & 01111000b = 01011000b
-01011011b & 01111001b = 01011001b
-01011011b & 01111010b = 01011010b
-01011011b & 01111011b = 01011011b
-01011011b & 01111100b = 01011000b
-01011011b & 01111101b = 01011001b
-01011011b & 01111110b = 01011010b
-01011100b & 10000000b = 00000000b
-01011100b & 10000001b = 00000000b
-01011100b & 10000010b = 00000000b
-01011100b & 10000011b = 00000000b
-01011100b & 10000100b = 00000100b
-01011100b & 10000101b = 00000100b
-01011100b & 10000110b = 00000100b
-01011100b & 10000111b = 00000100b
-01011100b & 10001000b = 00001000b
-01011100b & 10001001b = 00001000b
-01011100b & 10001010b = 00001000b
-01011100b & 10001011b = 00001000b
-01011100b & 10001100b = 00001100b
-01011100b & 10001101b = 00001100b
-01011100b & 10001110b = 00001100b
-01011100b & 10001111b = 00001100b
-01011100b & 10010000b = 00010000b
-01011100b & 10010001b = 00010000b
-01011100b & 10010010b = 00010000b
-01011100b & 10010011b = 00010000b
-01011100b & 10010100b = 00010100b
-01011100b & 10010101b = 00010100b
-01011100b & 10010110b = 00010100b
-01011100b & 10010111b = 00010100b
-01011100b & 10011000b = 00011000b
-01011100b & 10011001b = 00011000b
-01011100b & 10011010b = 00011000b
-01011100b & 10011011b = 00011000b
-01011100b & 10011100b = 00011100b
-01011100b & 10011101b = 00011100b
-01011100b & 10011110b = 00011100b
-01011100b & 10011111b = 00011100b
-01011100b & 10100000b = 00000000b
-01011100b & 10100001b = 00000000b
-01011100b & 10100010b = 00000000b
-01011100b & 10100011b = 00000000b
-01011100b & 10100100b = 00000100b
-01011100b & 10100101b = 00000100b
-01011100b & 10100110b = 00000100b
-01011100b & 10100111b = 00000100b
-01011100b & 10101000b = 00001000b
-01011100b & 10101001b = 00001000b
-01011100b & 10101010b = 00001000b
-01011100b & 10101011b = 00001000b
-01011100b & 10101100b = 00001100b
-01011100b & 10101101b = 00001100b
-01011100b & 10101110b = 00001100b
-01011100b & 10101111b = 00001100b
-01011100b & 10110000b = 00010000b
-01011100b & 10110001b = 00010000b
-01011100b & 10110010b = 00010000b
-01011100b & 10110011b = 00010000b
-01011100b & 10110100b = 00010100b
-01011100b & 10110101b = 00010100b
-01011100b & 10110110b = 00010100b
-01011100b & 10110111b = 00010100b
-01011100b & 10111000b = 00011000b
-01011100b & 10111001b = 00011000b
-01011100b & 10111010b = 00011000b
-01011100b & 10111011b = 00011000b
-01011100b & 10111100b = 00011100b
-01011100b & 10111101b = 00011100b
-01011100b & 10111110b = 00011100b
-01011100b & 10111111b = 00011100b
-01011100b & 11000000b = 01000000b
-01011100b & 11000001b = 01000000b
-01011100b & 11000010b = 01000000b
-01011100b & 11000011b = 01000000b
-01011100b & 11000100b = 01000100b
-01011100b & 11000101b = 01000100b
-01011100b & 11000110b = 01000100b
-01011100b & 11000111b = 01000100b
-01011100b & 11001000b = 01001000b
-01011100b & 11001001b = 01001000b
-01011100b & 11001010b = 01001000b
-01011100b & 11001011b = 01001000b
-01011100b & 11001100b = 01001100b
-01011100b & 11001101b = 01001100b
-01011100b & 11001110b = 01001100b
-01011100b & 11001111b = 01001100b
-01011100b & 11010000b = 01010000b
-01011100b & 11010001b = 01010000b
-01011100b & 11010010b = 01010000b
-01011100b & 11010011b = 01010000b
-01011100b & 11010100b = 01010100b
-01011100b & 11010101b = 01010100b
-01011100b & 11010110b = 01010100b
-01011100b & 11010111b = 01010100b
-01011100b & 11011000b = 01011000b
-01011100b & 11011001b = 01011000b
-01011100b & 11011010b = 01011000b
-01011100b & 11011011b = 01011000b
-01011100b & 11011100b = 01011100b
-01011100b & 11011101b = 01011100b
-01011100b & 11011110b = 01011100b
-01011100b & 11011111b = 01011100b
-01011100b & 11100000b = 01000000b
-01011100b & 11100001b = 01000000b
-01011100b & 11100010b = 01000000b
-01011100b & 11100011b = 01000000b
-01011100b & 11100100b = 01000100b
-01011100b & 11100101b = 01000100b
-01011100b & 11100110b = 01000100b
-01011100b & 11100111b = 01000100b
-01011100b & 11101000b = 01001000b
-01011100b & 11101001b = 01001000b
-01011100b & 11101010b = 01001000b
-01011100b & 11101011b = 01001000b
-01011100b & 11101100b = 01001100b
-01011100b & 11101101b = 01001100b
-01011100b & 11101110b = 01001100b
-01011100b & 11101111b = 01001100b
-01011100b & 11110000b = 01010000b
-01011100b & 11110001b = 01010000b
-01011100b & 11110010b = 01010000b
-01011100b & 11110011b = 01010000b
-01011100b & 11110100b = 01010100b
-01011100b & 11110101b = 01010100b
-01011100b & 11110110b = 01010100b
-01011100b & 11110111b = 01010100b
-01011100b & 11111000b = 01011000b
-01011100b & 11111001b = 01011000b
-01011100b & 11111010b = 01011000b
-01011100b & 11111011b = 01011000b
-01011100b & 11111100b = 01011100b
-01011100b & 11111101b = 01011100b
-01011100b & 11111110b = 01011100b
-01011100b & 11111111b = 01011100b
-01011100b & 00000000b = 00000000b
-01011100b & 00000001b = 00000000b
-01011100b & 00000010b = 00000000b
-01011100b & 00000011b = 00000000b
-01011100b & 00000100b = 00000100b
-01011100b & 00000101b = 00000100b
-01011100b & 00000110b = 00000100b
-01011100b & 00000111b = 00000100b
-01011100b & 00001000b = 00001000b
-01011100b & 00001001b = 00001000b
-01011100b & 00001010b = 00001000b
-01011100b & 00001011b = 00001000b
-01011100b & 00001100b = 00001100b
-01011100b & 00001101b = 00001100b
-01011100b & 00001110b = 00001100b
-01011100b & 00001111b = 00001100b
-01011100b & 00010000b = 00010000b
-01011100b & 00010001b = 00010000b
-01011100b & 00010010b = 00010000b
-01011100b & 00010011b = 00010000b
-01011100b & 00010100b = 00010100b
-01011100b & 00010101b = 00010100b
-01011100b & 00010110b = 00010100b
-01011100b & 00010111b = 00010100b
-01011100b & 00011000b = 00011000b
-01011100b & 00011001b = 00011000b
-01011100b & 00011010b = 00011000b
-01011100b & 00011011b = 00011000b
-01011100b & 00011100b = 00011100b
-01011100b & 00011101b = 00011100b
-01011100b & 00011110b = 00011100b
-01011100b & 00011111b = 00011100b
-01011100b & 00100000b = 00000000b
-01011100b & 00100001b = 00000000b
-01011100b & 00100010b = 00000000b
-01011100b & 00100011b = 00000000b
-01011100b & 00100100b = 00000100b
-01011100b & 00100101b = 00000100b
-01011100b & 00100110b = 00000100b
-01011100b & 00100111b = 00000100b
-01011100b & 00101000b = 00001000b
-01011100b & 00101001b = 00001000b
-01011100b & 00101010b = 00001000b
-01011100b & 00101011b = 00001000b
-01011100b & 00101100b = 00001100b
-01011100b & 00101101b = 00001100b
-01011100b & 00101110b = 00001100b
-01011100b & 00101111b = 00001100b
-01011100b & 00110000b = 00010000b
-01011100b & 00110001b = 00010000b
-01011100b & 00110010b = 00010000b
-01011100b & 00110011b = 00010000b
-01011100b & 00110100b = 00010100b
-01011100b & 00110101b = 00010100b
-01011100b & 00110110b = 00010100b
-01011100b & 00110111b = 00010100b
-01011100b & 00111000b = 00011000b
-01011100b & 00111001b = 00011000b
-01011100b & 00111010b = 00011000b
-01011100b & 00111011b = 00011000b
-01011100b & 00111100b = 00011100b
-01011100b & 00111101b = 00011100b
-01011100b & 00111110b = 00011100b
-01011100b & 00111111b = 00011100b
-01011100b & 01000000b = 01000000b
-01011100b & 01000001b = 01000000b
-01011100b & 01000010b = 01000000b
-01011100b & 01000011b = 01000000b
-01011100b & 01000100b = 01000100b
-01011100b & 01000101b = 01000100b
-01011100b & 01000110b = 01000100b
-01011100b & 01000111b = 01000100b
-01011100b & 01001000b = 01001000b
-01011100b & 01001001b = 01001000b
-01011100b & 01001010b = 01001000b
-01011100b & 01001011b = 01001000b
-01011100b & 01001100b = 01001100b
-01011100b & 01001101b = 01001100b
-01011100b & 01001110b = 01001100b
-01011100b & 01001111b = 01001100b
-01011100b & 01010000b = 01010000b
-01011100b & 01010001b = 01010000b
-01011100b & 01010010b = 01010000b
-01011100b & 01010011b = 01010000b
-01011100b & 01010100b = 01010100b
-01011100b & 01010101b = 01010100b
-01011100b & 01010110b = 01010100b
-01011100b & 01010111b = 01010100b
-01011100b & 01011000b = 01011000b
-01011100b & 01011001b = 01011000b
-01011100b & 01011010b = 01011000b
-01011100b & 01011011b = 01011000b
-01011100b & 01011100b = 01011100b
-01011100b & 01011101b = 01011100b
-01011100b & 01011110b = 01011100b
-01011100b & 01011111b = 01011100b
-01011100b & 01100000b = 01000000b
-01011100b & 01100001b = 01000000b
-01011100b & 01100010b = 01000000b
-01011100b & 01100011b = 01000000b
-01011100b & 01100100b = 01000100b
-01011100b & 01100101b = 01000100b
-01011100b & 01100110b = 01000100b
-01011100b & 01100111b = 01000100b
-01011100b & 01101000b = 01001000b
-01011100b & 01101001b = 01001000b
-01011100b & 01101010b = 01001000b
-01011100b & 01101011b = 01001000b
-01011100b & 01101100b = 01001100b
-01011100b & 01101101b = 01001100b
-01011100b & 01101110b = 01001100b
-01011100b & 01101111b = 01001100b
-01011100b & 01110000b = 01010000b
-01011100b & 01110001b = 01010000b
-01011100b & 01110010b = 01010000b
-01011100b & 01110011b = 01010000b
-01011100b & 01110100b = 01010100b
-01011100b & 01110101b = 01010100b
-01011100b & 01110110b = 01010100b
-01011100b & 01110111b = 01010100b
-01011100b & 01111000b = 01011000b
-01011100b & 01111001b = 01011000b
-01011100b & 01111010b = 01011000b
-01011100b & 01111011b = 01011000b
-01011100b & 01111100b = 01011100b
-01011100b & 01111101b = 01011100b
-01011100b & 01111110b = 01011100b
-01011101b & 10000000b = 00000000b
-01011101b & 10000001b = 00000001b
-01011101b & 10000010b = 00000000b
-01011101b & 10000011b = 00000001b
-01011101b & 10000100b = 00000100b
-01011101b & 10000101b = 00000101b
-01011101b & 10000110b = 00000100b
-01011101b & 10000111b = 00000101b
-01011101b & 10001000b = 00001000b
-01011101b & 10001001b = 00001001b
-01011101b & 10001010b = 00001000b
-01011101b & 10001011b = 00001001b
-01011101b & 10001100b = 00001100b
-01011101b & 10001101b = 00001101b
-01011101b & 10001110b = 00001100b
-01011101b & 10001111b = 00001101b
-01011101b & 10010000b = 00010000b
-01011101b & 10010001b = 00010001b
-01011101b & 10010010b = 00010000b
-01011101b & 10010011b = 00010001b
-01011101b & 10010100b = 00010100b
-01011101b & 10010101b = 00010101b
-01011101b & 10010110b = 00010100b
-01011101b & 10010111b = 00010101b
-01011101b & 10011000b = 00011000b
-01011101b & 10011001b = 00011001b
-01011101b & 10011010b = 00011000b
-01011101b & 10011011b = 00011001b
-01011101b & 10011100b = 00011100b
-01011101b & 10011101b = 00011101b
-01011101b & 10011110b = 00011100b
-01011101b & 10011111b = 00011101b
-01011101b & 10100000b = 00000000b
-01011101b & 10100001b = 00000001b
-01011101b & 10100010b = 00000000b
-01011101b & 10100011b = 00000001b
-01011101b & 10100100b = 00000100b
-01011101b & 10100101b = 00000101b
-01011101b & 10100110b = 00000100b
-01011101b & 10100111b = 00000101b
-01011101b & 10101000b = 00001000b
-01011101b & 10101001b = 00001001b
-01011101b & 10101010b = 00001000b
-01011101b & 10101011b = 00001001b
-01011101b & 10101100b = 00001100b
-01011101b & 10101101b = 00001101b
-01011101b & 10101110b = 00001100b
-01011101b & 10101111b = 00001101b
-01011101b & 10110000b = 00010000b
-01011101b & 10110001b = 00010001b
-01011101b & 10110010b = 00010000b
-01011101b & 10110011b = 00010001b
-01011101b & 10110100b = 00010100b
-01011101b & 10110101b = 00010101b
-01011101b & 10110110b = 00010100b
-01011101b & 10110111b = 00010101b
-01011101b & 10111000b = 00011000b
-01011101b & 10111001b = 00011001b
-01011101b & 10111010b = 00011000b
-01011101b & 10111011b = 00011001b
-01011101b & 10111100b = 00011100b
-01011101b & 10111101b = 00011101b
-01011101b & 10111110b = 00011100b
-01011101b & 10111111b = 00011101b
-01011101b & 11000000b = 01000000b
-01011101b & 11000001b = 01000001b
-01011101b & 11000010b = 01000000b
-01011101b & 11000011b = 01000001b
-01011101b & 11000100b = 01000100b
-01011101b & 11000101b = 01000101b
-01011101b & 11000110b = 01000100b
-01011101b & 11000111b = 01000101b
-01011101b & 11001000b = 01001000b
-01011101b & 11001001b = 01001001b
-01011101b & 11001010b = 01001000b
-01011101b & 11001011b = 01001001b
-01011101b & 11001100b = 01001100b
-01011101b & 11001101b = 01001101b
-01011101b & 11001110b = 01001100b
-01011101b & 11001111b = 01001101b
-01011101b & 11010000b = 01010000b
-01011101b & 11010001b = 01010001b
-01011101b & 11010010b = 01010000b
-01011101b & 11010011b = 01010001b
-01011101b & 11010100b = 01010100b
-01011101b & 11010101b = 01010101b
-01011101b & 11010110b = 01010100b
-01011101b & 11010111b = 01010101b
-01011101b & 11011000b = 01011000b
-01011101b & 11011001b = 01011001b
-01011101b & 11011010b = 01011000b
-01011101b & 11011011b = 01011001b
-01011101b & 11011100b = 01011100b
-01011101b & 11011101b = 01011101b
-01011101b & 11011110b = 01011100b
-01011101b & 11011111b = 01011101b
-01011101b & 11100000b = 01000000b
-01011101b & 11100001b = 01000001b
-01011101b & 11100010b = 01000000b
-01011101b & 11100011b = 01000001b
-01011101b & 11100100b = 01000100b
-01011101b & 11100101b = 01000101b
-01011101b & 11100110b = 01000100b
-01011101b & 11100111b = 01000101b
-01011101b & 11101000b = 01001000b
-01011101b & 11101001b = 01001001b
-01011101b & 11101010b = 01001000b
-01011101b & 11101011b = 01001001b
-01011101b & 11101100b = 01001100b
-01011101b & 11101101b = 01001101b
-01011101b & 11101110b = 01001100b
-01011101b & 11101111b = 01001101b
-01011101b & 11110000b = 01010000b
-01011101b & 11110001b = 01010001b
-01011101b & 11110010b = 01010000b
-01011101b & 11110011b = 01010001b
-01011101b & 11110100b = 01010100b
-01011101b & 11110101b = 01010101b
-01011101b & 11110110b = 01010100b
-01011101b & 11110111b = 01010101b
-01011101b & 11111000b = 01011000b
-01011101b & 11111001b = 01011001b
-01011101b & 11111010b = 01011000b
-01011101b & 11111011b = 01011001b
-01011101b & 11111100b = 01011100b
-01011101b & 11111101b = 01011101b
-01011101b & 11111110b = 01011100b
-01011101b & 11111111b = 01011101b
-01011101b & 00000000b = 00000000b
-01011101b & 00000001b = 00000001b
-01011101b & 00000010b = 00000000b
-01011101b & 00000011b = 00000001b
-01011101b & 00000100b = 00000100b
-01011101b & 00000101b = 00000101b
-01011101b & 00000110b = 00000100b
-01011101b & 00000111b = 00000101b
-01011101b & 00001000b = 00001000b
-01011101b & 00001001b = 00001001b
-01011101b & 00001010b = 00001000b
-01011101b & 00001011b = 00001001b
-01011101b & 00001100b = 00001100b
-01011101b & 00001101b = 00001101b
-01011101b & 00001110b = 00001100b
-01011101b & 00001111b = 00001101b
-01011101b & 00010000b = 00010000b
-01011101b & 00010001b = 00010001b
-01011101b & 00010010b = 00010000b
-01011101b & 00010011b = 00010001b
-01011101b & 00010100b = 00010100b
-01011101b & 00010101b = 00010101b
-01011101b & 00010110b = 00010100b
-01011101b & 00010111b = 00010101b
-01011101b & 00011000b = 00011000b
-01011101b & 00011001b = 00011001b
-01011101b & 00011010b = 00011000b
-01011101b & 00011011b = 00011001b
-01011101b & 00011100b = 00011100b
-01011101b & 00011101b = 00011101b
-01011101b & 00011110b = 00011100b
-01011101b & 00011111b = 00011101b
-01011101b & 00100000b = 00000000b
-01011101b & 00100001b = 00000001b
-01011101b & 00100010b = 00000000b
-01011101b & 00100011b = 00000001b
-01011101b & 00100100b = 00000100b
-01011101b & 00100101b = 00000101b
-01011101b & 00100110b = 00000100b
-01011101b & 00100111b = 00000101b
-01011101b & 00101000b = 00001000b
-01011101b & 00101001b = 00001001b
-01011101b & 00101010b = 00001000b
-01011101b & 00101011b = 00001001b
-01011101b & 00101100b = 00001100b
-01011101b & 00101101b = 00001101b
-01011101b & 00101110b = 00001100b
-01011101b & 00101111b = 00001101b
-01011101b & 00110000b = 00010000b
-01011101b & 00110001b = 00010001b
-01011101b & 00110010b = 00010000b
-01011101b & 00110011b = 00010001b
-01011101b & 00110100b = 00010100b
-01011101b & 00110101b = 00010101b
-01011101b & 00110110b = 00010100b
-01011101b & 00110111b = 00010101b
-01011101b & 00111000b = 00011000b
-01011101b & 00111001b = 00011001b
-01011101b & 00111010b = 00011000b
-01011101b & 00111011b = 00011001b
-01011101b & 00111100b = 00011100b
-01011101b & 00111101b = 00011101b
-01011101b & 00111110b = 00011100b
-01011101b & 00111111b = 00011101b
-01011101b & 01000000b = 01000000b
-01011101b & 01000001b = 01000001b
-01011101b & 01000010b = 01000000b
-01011101b & 01000011b = 01000001b
-01011101b & 01000100b = 01000100b
-01011101b & 01000101b = 01000101b
-01011101b & 01000110b = 01000100b
-01011101b & 01000111b = 01000101b
-01011101b & 01001000b = 01001000b
-01011101b & 01001001b = 01001001b
-01011101b & 01001010b = 01001000b
-01011101b & 01001011b = 01001001b
-01011101b & 01001100b = 01001100b
-01011101b & 01001101b = 01001101b
-01011101b & 01001110b = 01001100b
-01011101b & 01001111b = 01001101b
-01011101b & 01010000b = 01010000b
-01011101b & 01010001b = 01010001b
-01011101b & 01010010b = 01010000b
-01011101b & 01010011b = 01010001b
-01011101b & 01010100b = 01010100b
-01011101b & 01010101b = 01010101b
-01011101b & 01010110b = 01010100b
-01011101b & 01010111b = 01010101b
-01011101b & 01011000b = 01011000b
-01011101b & 01011001b = 01011001b
-01011101b & 01011010b = 01011000b
-01011101b & 01011011b = 01011001b
-01011101b & 01011100b = 01011100b
-01011101b & 01011101b = 01011101b
-01011101b & 01011110b = 01011100b
-01011101b & 01011111b = 01011101b
-01011101b & 01100000b = 01000000b
-01011101b & 01100001b = 01000001b
-01011101b & 01100010b = 01000000b
-01011101b & 01100011b = 01000001b
-01011101b & 01100100b = 01000100b
-01011101b & 01100101b = 01000101b
-01011101b & 01100110b = 01000100b
-01011101b & 01100111b = 01000101b
-01011101b & 01101000b = 01001000b
-01011101b & 01101001b = 01001001b
-01011101b & 01101010b = 01001000b
-01011101b & 01101011b = 01001001b
-01011101b & 01101100b = 01001100b
-01011101b & 01101101b = 01001101b
-01011101b & 01101110b = 01001100b
-01011101b & 01101111b = 01001101b
-01011101b & 01110000b = 01010000b
-01011101b & 01110001b = 01010001b
-01011101b & 01110010b = 01010000b
-01011101b & 01110011b = 01010001b
-01011101b & 01110100b = 01010100b
-01011101b & 01110101b = 01010101b
-01011101b & 01110110b = 01010100b
-01011101b & 01110111b = 01010101b
-01011101b & 01111000b = 01011000b
-01011101b & 01111001b = 01011001b
-01011101b & 01111010b = 01011000b
-01011101b & 01111011b = 01011001b
-01011101b & 01111100b = 01011100b
-01011101b & 01111101b = 01011101b
-01011101b & 01111110b = 01011100b
-01011110b & 10000000b = 00000000b
-01011110b & 10000001b = 00000000b
-01011110b & 10000010b = 00000010b
-01011110b & 10000011b = 00000010b
-01011110b & 10000100b = 00000100b
-01011110b & 10000101b = 00000100b
-01011110b & 10000110b = 00000110b
-01011110b & 10000111b = 00000110b
-01011110b & 10001000b = 00001000b
-01011110b & 10001001b = 00001000b
-01011110b & 10001010b = 00001010b
-01011110b & 10001011b = 00001010b
-01011110b & 10001100b = 00001100b
-01011110b & 10001101b = 00001100b
-01011110b & 10001110b = 00001110b
-01011110b & 10001111b = 00001110b
-01011110b & 10010000b = 00010000b
-01011110b & 10010001b = 00010000b
-01011110b & 10010010b = 00010010b
-01011110b & 10010011b = 00010010b
-01011110b & 10010100b = 00010100b
-01011110b & 10010101b = 00010100b
-01011110b & 10010110b = 00010110b
-01011110b & 10010111b = 00010110b
-01011110b & 10011000b = 00011000b
-01011110b & 10011001b = 00011000b
-01011110b & 10011010b = 00011010b
-01011110b & 10011011b = 00011010b
-01011110b & 10011100b = 00011100b
-01011110b & 10011101b = 00011100b
-01011110b & 10011110b = 00011110b
-01011110b & 10011111b = 00011110b
-01011110b & 10100000b = 00000000b
-01011110b & 10100001b = 00000000b
-01011110b & 10100010b = 00000010b
-01011110b & 10100011b = 00000010b
-01011110b & 10100100b = 00000100b
-01011110b & 10100101b = 00000100b
-01011110b & 10100110b = 00000110b
-01011110b & 10100111b = 00000110b
-01011110b & 10101000b = 00001000b
-01011110b & 10101001b = 00001000b
-01011110b & 10101010b = 00001010b
-01011110b & 10101011b = 00001010b
-01011110b & 10101100b = 00001100b
-01011110b & 10101101b = 00001100b
-01011110b & 10101110b = 00001110b
-01011110b & 10101111b = 00001110b
-01011110b & 10110000b = 00010000b
-01011110b & 10110001b = 00010000b
-01011110b & 10110010b = 00010010b
-01011110b & 10110011b = 00010010b
-01011110b & 10110100b = 00010100b
-01011110b & 10110101b = 00010100b
-01011110b & 10110110b = 00010110b
-01011110b & 10110111b = 00010110b
-01011110b & 10111000b = 00011000b
-01011110b & 10111001b = 00011000b
-01011110b & 10111010b = 00011010b
-01011110b & 10111011b = 00011010b
-01011110b & 10111100b = 00011100b
-01011110b & 10111101b = 00011100b
-01011110b & 10111110b = 00011110b
-01011110b & 10111111b = 00011110b
-01011110b & 11000000b = 01000000b
-01011110b & 11000001b = 01000000b
-01011110b & 11000010b = 01000010b
-01011110b & 11000011b = 01000010b
-01011110b & 11000100b = 01000100b
-01011110b & 11000101b = 01000100b
-01011110b & 11000110b = 01000110b
-01011110b & 11000111b = 01000110b
-01011110b & 11001000b = 01001000b
-01011110b & 11001001b = 01001000b
-01011110b & 11001010b = 01001010b
-01011110b & 11001011b = 01001010b
-01011110b & 11001100b = 01001100b
-01011110b & 11001101b = 01001100b
-01011110b & 11001110b = 01001110b
-01011110b & 11001111b = 01001110b
-01011110b & 11010000b = 01010000b
-01011110b & 11010001b = 01010000b
-01011110b & 11010010b = 01010010b
-01011110b & 11010011b = 01010010b
-01011110b & 11010100b = 01010100b
-01011110b & 11010101b = 01010100b
-01011110b & 11010110b = 01010110b
-01011110b & 11010111b = 01010110b
-01011110b & 11011000b = 01011000b
-01011110b & 11011001b = 01011000b
-01011110b & 11011010b = 01011010b
-01011110b & 11011011b = 01011010b
-01011110b & 11011100b = 01011100b
-01011110b & 11011101b = 01011100b
-01011110b & 11011110b = 01011110b
-01011110b & 11011111b = 01011110b
-01011110b & 11100000b = 01000000b
-01011110b & 11100001b = 01000000b
-01011110b & 11100010b = 01000010b
-01011110b & 11100011b = 01000010b
-01011110b & 11100100b = 01000100b
-01011110b & 11100101b = 01000100b
-01011110b & 11100110b = 01000110b
-01011110b & 11100111b = 01000110b
-01011110b & 11101000b = 01001000b
-01011110b & 11101001b = 01001000b
-01011110b & 11101010b = 01001010b
-01011110b & 11101011b = 01001010b
-01011110b & 11101100b = 01001100b
-01011110b & 11101101b = 01001100b
-01011110b & 11101110b = 01001110b
-01011110b & 11101111b = 01001110b
-01011110b & 11110000b = 01010000b
-01011110b & 11110001b = 01010000b
-01011110b & 11110010b = 01010010b
-01011110b & 11110011b = 01010010b
-01011110b & 11110100b = 01010100b
-01011110b & 11110101b = 01010100b
-01011110b & 11110110b = 01010110b
-01011110b & 11110111b = 01010110b
-01011110b & 11111000b = 01011000b
-01011110b & 11111001b = 01011000b
-01011110b & 11111010b = 01011010b
-01011110b & 11111011b = 01011010b
-01011110b & 11111100b = 01011100b
-01011110b & 11111101b = 01011100b
-01011110b & 11111110b = 01011110b
-01011110b & 11111111b = 01011110b
-01011110b & 00000000b = 00000000b
-01011110b & 00000001b = 00000000b
-01011110b & 00000010b = 00000010b
-01011110b & 00000011b = 00000010b
-01011110b & 00000100b = 00000100b
-01011110b & 00000101b = 00000100b
-01011110b & 00000110b = 00000110b
-01011110b & 00000111b = 00000110b
-01011110b & 00001000b = 00001000b
-01011110b & 00001001b = 00001000b
-01011110b & 00001010b = 00001010b
-01011110b & 00001011b = 00001010b
-01011110b & 00001100b = 00001100b
-01011110b & 00001101b = 00001100b
-01011110b & 00001110b = 00001110b
-01011110b & 00001111b = 00001110b
-01011110b & 00010000b = 00010000b
-01011110b & 00010001b = 00010000b
-01011110b & 00010010b = 00010010b
-01011110b & 00010011b = 00010010b
-01011110b & 00010100b = 00010100b
-01011110b & 00010101b = 00010100b
-01011110b & 00010110b = 00010110b
-01011110b & 00010111b = 00010110b
-01011110b & 00011000b = 00011000b
-01011110b & 00011001b = 00011000b
-01011110b & 00011010b = 00011010b
-01011110b & 00011011b = 00011010b
-01011110b & 00011100b = 00011100b
-01011110b & 00011101b = 00011100b
-01011110b & 00011110b = 00011110b
-01011110b & 00011111b = 00011110b
-01011110b & 00100000b = 00000000b
-01011110b & 00100001b = 00000000b
-01011110b & 00100010b = 00000010b
-01011110b & 00100011b = 00000010b
-01011110b & 00100100b = 00000100b
-01011110b & 00100101b = 00000100b
-01011110b & 00100110b = 00000110b
-01011110b & 00100111b = 00000110b
-01011110b & 00101000b = 00001000b
-01011110b & 00101001b = 00001000b
-01011110b & 00101010b = 00001010b
-01011110b & 00101011b = 00001010b
-01011110b & 00101100b = 00001100b
-01011110b & 00101101b = 00001100b
-01011110b & 00101110b = 00001110b
-01011110b & 00101111b = 00001110b
-01011110b & 00110000b = 00010000b
-01011110b & 00110001b = 00010000b
-01011110b & 00110010b = 00010010b
-01011110b & 00110011b = 00010010b
-01011110b & 00110100b = 00010100b
-01011110b & 00110101b = 00010100b
-01011110b & 00110110b = 00010110b
-01011110b & 00110111b = 00010110b
-01011110b & 00111000b = 00011000b
-01011110b & 00111001b = 00011000b
-01011110b & 00111010b = 00011010b
-01011110b & 00111011b = 00011010b
-01011110b & 00111100b = 00011100b
-01011110b & 00111101b = 00011100b
-01011110b & 00111110b = 00011110b
-01011110b & 00111111b = 00011110b
-01011110b & 01000000b = 01000000b
-01011110b & 01000001b = 01000000b
-01011110b & 01000010b = 01000010b
-01011110b & 01000011b = 01000010b
-01011110b & 01000100b = 01000100b
-01011110b & 01000101b = 01000100b
-01011110b & 01000110b = 01000110b
-01011110b & 01000111b = 01000110b
-01011110b & 01001000b = 01001000b
-01011110b & 01001001b = 01001000b
-01011110b & 01001010b = 01001010b
-01011110b & 01001011b = 01001010b
-01011110b & 01001100b = 01001100b
-01011110b & 01001101b = 01001100b
-01011110b & 01001110b = 01001110b
-01011110b & 01001111b = 01001110b
-01011110b & 01010000b = 01010000b
-01011110b & 01010001b = 01010000b
-01011110b & 01010010b = 01010010b
-01011110b & 01010011b = 01010010b
-01011110b & 01010100b = 01010100b
-01011110b & 01010101b = 01010100b
-01011110b & 01010110b = 01010110b
-01011110b & 01010111b = 01010110b
-01011110b & 01011000b = 01011000b
-01011110b & 01011001b = 01011000b
-01011110b & 01011010b = 01011010b
-01011110b & 01011011b = 01011010b
-01011110b & 01011100b = 01011100b
-01011110b & 01011101b = 01011100b
-01011110b & 01011110b = 01011110b
-01011110b & 01011111b = 01011110b
-01011110b & 01100000b = 01000000b
-01011110b & 01100001b = 01000000b
-01011110b & 01100010b = 01000010b
-01011110b & 01100011b = 01000010b
-01011110b & 01100100b = 01000100b
-01011110b & 01100101b = 01000100b
-01011110b & 01100110b = 01000110b
-01011110b & 01100111b = 01000110b
-01011110b & 01101000b = 01001000b
-01011110b & 01101001b = 01001000b
-01011110b & 01101010b = 01001010b
-01011110b & 01101011b = 01001010b
-01011110b & 01101100b = 01001100b
-01011110b & 01101101b = 01001100b
-01011110b & 01101110b = 01001110b
-01011110b & 01101111b = 01001110b
-01011110b & 01110000b = 01010000b
-01011110b & 01110001b = 01010000b
-01011110b & 01110010b = 01010010b
-01011110b & 01110011b = 01010010b
-01011110b & 01110100b = 01010100b
-01011110b & 01110101b = 01010100b
-01011110b & 01110110b = 01010110b
-01011110b & 01110111b = 01010110b
-01011110b & 01111000b = 01011000b
-01011110b & 01111001b = 01011000b
-01011110b & 01111010b = 01011010b
-01011110b & 01111011b = 01011010b
-01011110b & 01111100b = 01011100b
-01011110b & 01111101b = 01011100b
-01011110b & 01111110b = 01011110b
-01011111b & 10000000b = 00000000b
-01011111b & 10000001b = 00000001b
-01011111b & 10000010b = 00000010b
-01011111b & 10000011b = 00000011b
-01011111b & 10000100b = 00000100b
-01011111b & 10000101b = 00000101b
-01011111b & 10000110b = 00000110b
-01011111b & 10000111b = 00000111b
-01011111b & 10001000b = 00001000b
-01011111b & 10001001b = 00001001b
-01011111b & 10001010b = 00001010b
-01011111b & 10001011b = 00001011b
-01011111b & 10001100b = 00001100b
-01011111b & 10001101b = 00001101b
-01011111b & 10001110b = 00001110b
-01011111b & 10001111b = 00001111b
-01011111b & 10010000b = 00010000b
-01011111b & 10010001b = 00010001b
-01011111b & 10010010b = 00010010b
-01011111b & 10010011b = 00010011b
-01011111b & 10010100b = 00010100b
-01011111b & 10010101b = 00010101b
-01011111b & 10010110b = 00010110b
-01011111b & 10010111b = 00010111b
-01011111b & 10011000b = 00011000b
-01011111b & 10011001b = 00011001b
-01011111b & 10011010b = 00011010b
-01011111b & 10011011b = 00011011b
-01011111b & 10011100b = 00011100b
-01011111b & 10011101b = 00011101b
-01011111b & 10011110b = 00011110b
-01011111b & 10011111b = 00011111b
-01011111b & 10100000b = 00000000b
-01011111b & 10100001b = 00000001b
-01011111b & 10100010b = 00000010b
-01011111b & 10100011b = 00000011b
-01011111b & 10100100b = 00000100b
-01011111b & 10100101b = 00000101b
-01011111b & 10100110b = 00000110b
-01011111b & 10100111b = 00000111b
-01011111b & 10101000b = 00001000b
-01011111b & 10101001b = 00001001b
-01011111b & 10101010b = 00001010b
-01011111b & 10101011b = 00001011b
-01011111b & 10101100b = 00001100b
-01011111b & 10101101b = 00001101b
-01011111b & 10101110b = 00001110b
-01011111b & 10101111b = 00001111b
-01011111b & 10110000b = 00010000b
-01011111b & 10110001b = 00010001b
-01011111b & 10110010b = 00010010b
-01011111b & 10110011b = 00010011b
-01011111b & 10110100b = 00010100b
-01011111b & 10110101b = 00010101b
-01011111b & 10110110b = 00010110b
-01011111b & 10110111b = 00010111b
-01011111b & 10111000b = 00011000b
-01011111b & 10111001b = 00011001b
-01011111b & 10111010b = 00011010b
-01011111b & 10111011b = 00011011b
-01011111b & 10111100b = 00011100b
-01011111b & 10111101b = 00011101b
-01011111b & 10111110b = 00011110b
-01011111b & 10111111b = 00011111b
-01011111b & 11000000b = 01000000b
-01011111b & 11000001b = 01000001b
-01011111b & 11000010b = 01000010b
-01011111b & 11000011b = 01000011b
-01011111b & 11000100b = 01000100b
-01011111b & 11000101b = 01000101b
-01011111b & 11000110b = 01000110b
-01011111b & 11000111b = 01000111b
-01011111b & 11001000b = 01001000b
-01011111b & 11001001b = 01001001b
-01011111b & 11001010b = 01001010b
-01011111b & 11001011b = 01001011b
-01011111b & 11001100b = 01001100b
-01011111b & 11001101b = 01001101b
-01011111b & 11001110b = 01001110b
-01011111b & 11001111b = 01001111b
-01011111b & 11010000b = 01010000b
-01011111b & 11010001b = 01010001b
-01011111b & 11010010b = 01010010b
-01011111b & 11010011b = 01010011b
-01011111b & 11010100b = 01010100b
-01011111b & 11010101b = 01010101b
-01011111b & 11010110b = 01010110b
-01011111b & 11010111b = 01010111b
-01011111b & 11011000b = 01011000b
-01011111b & 11011001b = 01011001b
-01011111b & 11011010b = 01011010b
-01011111b & 11011011b = 01011011b
-01011111b & 11011100b = 01011100b
-01011111b & 11011101b = 01011101b
-01011111b & 11011110b = 01011110b
-01011111b & 11011111b = 01011111b
-01011111b & 11100000b = 01000000b
-01011111b & 11100001b = 01000001b
-01011111b & 11100010b = 01000010b
-01011111b & 11100011b = 01000011b
-01011111b & 11100100b = 01000100b
-01011111b & 11100101b = 01000101b
-01011111b & 11100110b = 01000110b
-01011111b & 11100111b = 01000111b
-01011111b & 11101000b = 01001000b
-01011111b & 11101001b = 01001001b
-01011111b & 11101010b = 01001010b
-01011111b & 11101011b = 01001011b
-01011111b & 11101100b = 01001100b
-01011111b & 11101101b = 01001101b
-01011111b & 11101110b = 01001110b
-01011111b & 11101111b = 01001111b
-01011111b & 11110000b = 01010000b
-01011111b & 11110001b = 01010001b
-01011111b & 11110010b = 01010010b
-01011111b & 11110011b = 01010011b
-01011111b & 11110100b = 01010100b
-01011111b & 11110101b = 01010101b
-01011111b & 11110110b = 01010110b
-01011111b & 11110111b = 01010111b
-01011111b & 11111000b = 01011000b
-01011111b & 11111001b = 01011001b
-01011111b & 11111010b = 01011010b
-01011111b & 11111011b = 01011011b
-01011111b & 11111100b = 01011100b
-01011111b & 11111101b = 01011101b
-01011111b & 11111110b = 01011110b
-01011111b & 11111111b = 01011111b
-01011111b & 00000000b = 00000000b
-01011111b & 00000001b = 00000001b
-01011111b & 00000010b = 00000010b
-01011111b & 00000011b = 00000011b
-01011111b & 00000100b = 00000100b
-01011111b & 00000101b = 00000101b
-01011111b & 00000110b = 00000110b
-01011111b & 00000111b = 00000111b
-01011111b & 00001000b = 00001000b
-01011111b & 00001001b = 00001001b
-01011111b & 00001010b = 00001010b
-01011111b & 00001011b = 00001011b
-01011111b & 00001100b = 00001100b
-01011111b & 00001101b = 00001101b
-01011111b & 00001110b = 00001110b
-01011111b & 00001111b = 00001111b
-01011111b & 00010000b = 00010000b
-01011111b & 00010001b = 00010001b
-01011111b & 00010010b = 00010010b
-01011111b & 00010011b = 00010011b
-01011111b & 00010100b = 00010100b
-01011111b & 00010101b = 00010101b
-01011111b & 00010110b = 00010110b
-01011111b & 00010111b = 00010111b
-01011111b & 00011000b = 00011000b
-01011111b & 00011001b = 00011001b
-01011111b & 00011010b = 00011010b
-01011111b & 00011011b = 00011011b
-01011111b & 00011100b = 00011100b
-01011111b & 00011101b = 00011101b
-01011111b & 00011110b = 00011110b
-01011111b & 00011111b = 00011111b
-01011111b & 00100000b = 00000000b
-01011111b & 00100001b = 00000001b
-01011111b & 00100010b = 00000010b
-01011111b & 00100011b = 00000011b
-01011111b & 00100100b = 00000100b
-01011111b & 00100101b = 00000101b
-01011111b & 00100110b = 00000110b
-01011111b & 00100111b = 00000111b
-01011111b & 00101000b = 00001000b
-01011111b & 00101001b = 00001001b
-01011111b & 00101010b = 00001010b
-01011111b & 00101011b = 00001011b
-01011111b & 00101100b = 00001100b
-01011111b & 00101101b = 00001101b
-01011111b & 00101110b = 00001110b
-01011111b & 00101111b = 00001111b
-01011111b & 00110000b = 00010000b
-01011111b & 00110001b = 00010001b
-01011111b & 00110010b = 00010010b
-01011111b & 00110011b = 00010011b
-01011111b & 00110100b = 00010100b
-01011111b & 00110101b = 00010101b
-01011111b & 00110110b = 00010110b
-01011111b & 00110111b = 00010111b
-01011111b & 00111000b = 00011000b
-01011111b & 00111001b = 00011001b
-01011111b & 00111010b = 00011010b
-01011111b & 00111011b = 00011011b
-01011111b & 00111100b = 00011100b
-01011111b & 00111101b = 00011101b
-01011111b & 00111110b = 00011110b
-01011111b & 00111111b = 00011111b
-01011111b & 01000000b = 01000000b
-01011111b & 01000001b = 01000001b
-01011111b & 01000010b = 01000010b
-01011111b & 01000011b = 01000011b
-01011111b & 01000100b = 01000100b
-01011111b & 01000101b = 01000101b
-01011111b & 01000110b = 01000110b
-01011111b & 01000111b = 01000111b
-01011111b & 01001000b = 01001000b
-01011111b & 01001001b = 01001001b
-01011111b & 01001010b = 01001010b
-01011111b & 01001011b = 01001011b
-01011111b & 01001100b = 01001100b
-01011111b & 01001101b = 01001101b
-01011111b & 01001110b = 01001110b
-01011111b & 01001111b = 01001111b
-01011111b & 01010000b = 01010000b
-01011111b & 01010001b = 01010001b
-01011111b & 01010010b = 01010010b
-01011111b & 01010011b = 01010011b
-01011111b & 01010100b = 01010100b
-01011111b & 01010101b = 01010101b
-01011111b & 01010110b = 01010110b
-01011111b & 01010111b = 01010111b
-01011111b & 01011000b = 01011000b
-01011111b & 01011001b = 01011001b
-01011111b & 01011010b = 01011010b
-01011111b & 01011011b = 01011011b
-01011111b & 01011100b = 01011100b
-01011111b & 01011101b = 01011101b
-01011111b & 01011110b = 01011110b
-01011111b & 01011111b = 01011111b
-01011111b & 01100000b = 01000000b
-01011111b & 01100001b = 01000001b
-01011111b & 01100010b = 01000010b
-01011111b & 01100011b = 01000011b
-01011111b & 01100100b = 01000100b
-01011111b & 01100101b = 01000101b
-01011111b & 01100110b = 01000110b
-01011111b & 01100111b = 01000111b
-01011111b & 01101000b = 01001000b
-01011111b & 01101001b = 01001001b
-01011111b & 01101010b = 01001010b
-01011111b & 01101011b = 01001011b
-01011111b & 01101100b = 01001100b
-01011111b & 01101101b = 01001101b
-01011111b & 01101110b = 01001110b
-01011111b & 01101111b = 01001111b
-01011111b & 01110000b = 01010000b
-01011111b & 01110001b = 01010001b
-01011111b & 01110010b = 01010010b
-01011111b & 01110011b = 01010011b
-01011111b & 01110100b = 01010100b
-01011111b & 01110101b = 01010101b
-01011111b & 01110110b = 01010110b
-01011111b & 01110111b = 01010111b
-01011111b & 01111000b = 01011000b
-01011111b & 01111001b = 01011001b
-01011111b & 01111010b = 01011010b
-01011111b & 01111011b = 01011011b
-01011111b & 01111100b = 01011100b
-01011111b & 01111101b = 01011101b
-01011111b & 01111110b = 01011110b
-01100000b & 10000000b = 00000000b
-01100000b & 10000001b = 00000000b
-01100000b & 10000010b = 00000000b
-01100000b & 10000011b = 00000000b
-01100000b & 10000100b = 00000000b
-01100000b & 10000101b = 00000000b
-01100000b & 10000110b = 00000000b
-01100000b & 10000111b = 00000000b
-01100000b & 10001000b = 00000000b
-01100000b & 10001001b = 00000000b
-01100000b & 10001010b = 00000000b
-01100000b & 10001011b = 00000000b
-01100000b & 10001100b = 00000000b
-01100000b & 10001101b = 00000000b
-01100000b & 10001110b = 00000000b
-01100000b & 10001111b = 00000000b
-01100000b & 10010000b = 00000000b
-01100000b & 10010001b = 00000000b
-01100000b & 10010010b = 00000000b
-01100000b & 10010011b = 00000000b
-01100000b & 10010100b = 00000000b
-01100000b & 10010101b = 00000000b
-01100000b & 10010110b = 00000000b
-01100000b & 10010111b = 00000000b
-01100000b & 10011000b = 00000000b
-01100000b & 10011001b = 00000000b
-01100000b & 10011010b = 00000000b
-01100000b & 10011011b = 00000000b
-01100000b & 10011100b = 00000000b
-01100000b & 10011101b = 00000000b
-01100000b & 10011110b = 00000000b
-01100000b & 10011111b = 00000000b
-01100000b & 10100000b = 00100000b
-01100000b & 10100001b = 00100000b
-01100000b & 10100010b = 00100000b
-01100000b & 10100011b = 00100000b
-01100000b & 10100100b = 00100000b
-01100000b & 10100101b = 00100000b
-01100000b & 10100110b = 00100000b
-01100000b & 10100111b = 00100000b
-01100000b & 10101000b = 00100000b
-01100000b & 10101001b = 00100000b
-01100000b & 10101010b = 00100000b
-01100000b & 10101011b = 00100000b
-01100000b & 10101100b = 00100000b
-01100000b & 10101101b = 00100000b
-01100000b & 10101110b = 00100000b
-01100000b & 10101111b = 00100000b
-01100000b & 10110000b = 00100000b
-01100000b & 10110001b = 00100000b
-01100000b & 10110010b = 00100000b
-01100000b & 10110011b = 00100000b
-01100000b & 10110100b = 00100000b
-01100000b & 10110101b = 00100000b
-01100000b & 10110110b = 00100000b
-01100000b & 10110111b = 00100000b
-01100000b & 10111000b = 00100000b
-01100000b & 10111001b = 00100000b
-01100000b & 10111010b = 00100000b
-01100000b & 10111011b = 00100000b
-01100000b & 10111100b = 00100000b
-01100000b & 10111101b = 00100000b
-01100000b & 10111110b = 00100000b
-01100000b & 10111111b = 00100000b
-01100000b & 11000000b = 01000000b
-01100000b & 11000001b = 01000000b
-01100000b & 11000010b = 01000000b
-01100000b & 11000011b = 01000000b
-01100000b & 11000100b = 01000000b
-01100000b & 11000101b = 01000000b
-01100000b & 11000110b = 01000000b
-01100000b & 11000111b = 01000000b
-01100000b & 11001000b = 01000000b
-01100000b & 11001001b = 01000000b
-01100000b & 11001010b = 01000000b
-01100000b & 11001011b = 01000000b
-01100000b & 11001100b = 01000000b
-01100000b & 11001101b = 01000000b
-01100000b & 11001110b = 01000000b
-01100000b & 11001111b = 01000000b
-01100000b & 11010000b = 01000000b
-01100000b & 11010001b = 01000000b
-01100000b & 11010010b = 01000000b
-01100000b & 11010011b = 01000000b
-01100000b & 11010100b = 01000000b
-01100000b & 11010101b = 01000000b
-01100000b & 11010110b = 01000000b
-01100000b & 11010111b = 01000000b
-01100000b & 11011000b = 01000000b
-01100000b & 11011001b = 01000000b
-01100000b & 11011010b = 01000000b
-01100000b & 11011011b = 01000000b
-01100000b & 11011100b = 01000000b
-01100000b & 11011101b = 01000000b
-01100000b & 11011110b = 01000000b
-01100000b & 11011111b = 01000000b
-01100000b & 11100000b = 01100000b
-01100000b & 11100001b = 01100000b
-01100000b & 11100010b = 01100000b
-01100000b & 11100011b = 01100000b
-01100000b & 11100100b = 01100000b
-01100000b & 11100101b = 01100000b
-01100000b & 11100110b = 01100000b
-01100000b & 11100111b = 01100000b
-01100000b & 11101000b = 01100000b
-01100000b & 11101001b = 01100000b
-01100000b & 11101010b = 01100000b
-01100000b & 11101011b = 01100000b
-01100000b & 11101100b = 01100000b
-01100000b & 11101101b = 01100000b
-01100000b & 11101110b = 01100000b
-01100000b & 11101111b = 01100000b
-01100000b & 11110000b = 01100000b
-01100000b & 11110001b = 01100000b
-01100000b & 11110010b = 01100000b
-01100000b & 11110011b = 01100000b
-01100000b & 11110100b = 01100000b
-01100000b & 11110101b = 01100000b
-01100000b & 11110110b = 01100000b
-01100000b & 11110111b = 01100000b
-01100000b & 11111000b = 01100000b
-01100000b & 11111001b = 01100000b
-01100000b & 11111010b = 01100000b
-01100000b & 11111011b = 01100000b
-01100000b & 11111100b = 01100000b
-01100000b & 11111101b = 01100000b
-01100000b & 11111110b = 01100000b
-01100000b & 11111111b = 01100000b
-01100000b & 00000000b = 00000000b
-01100000b & 00000001b = 00000000b
-01100000b & 00000010b = 00000000b
-01100000b & 00000011b = 00000000b
-01100000b & 00000100b = 00000000b
-01100000b & 00000101b = 00000000b
-01100000b & 00000110b = 00000000b
-01100000b & 00000111b = 00000000b
-01100000b & 00001000b = 00000000b
-01100000b & 00001001b = 00000000b
-01100000b & 00001010b = 00000000b
-01100000b & 00001011b = 00000000b
-01100000b & 00001100b = 00000000b
-01100000b & 00001101b = 00000000b
-01100000b & 00001110b = 00000000b
-01100000b & 00001111b = 00000000b
-01100000b & 00010000b = 00000000b
-01100000b & 00010001b = 00000000b
-01100000b & 00010010b = 00000000b
-01100000b & 00010011b = 00000000b
-01100000b & 00010100b = 00000000b
-01100000b & 00010101b = 00000000b
-01100000b & 00010110b = 00000000b
-01100000b & 00010111b = 00000000b
-01100000b & 00011000b = 00000000b
-01100000b & 00011001b = 00000000b
-01100000b & 00011010b = 00000000b
-01100000b & 00011011b = 00000000b
-01100000b & 00011100b = 00000000b
-01100000b & 00011101b = 00000000b
-01100000b & 00011110b = 00000000b
-01100000b & 00011111b = 00000000b
-01100000b & 00100000b = 00100000b
-01100000b & 00100001b = 00100000b
-01100000b & 00100010b = 00100000b
-01100000b & 00100011b = 00100000b
-01100000b & 00100100b = 00100000b
-01100000b & 00100101b = 00100000b
-01100000b & 00100110b = 00100000b
-01100000b & 00100111b = 00100000b
-01100000b & 00101000b = 00100000b
-01100000b & 00101001b = 00100000b
-01100000b & 00101010b = 00100000b
-01100000b & 00101011b = 00100000b
-01100000b & 00101100b = 00100000b
-01100000b & 00101101b = 00100000b
-01100000b & 00101110b = 00100000b
-01100000b & 00101111b = 00100000b
-01100000b & 00110000b = 00100000b
-01100000b & 00110001b = 00100000b
-01100000b & 00110010b = 00100000b
-01100000b & 00110011b = 00100000b
-01100000b & 00110100b = 00100000b
-01100000b & 00110101b = 00100000b
-01100000b & 00110110b = 00100000b
-01100000b & 00110111b = 00100000b
-01100000b & 00111000b = 00100000b
-01100000b & 00111001b = 00100000b
-01100000b & 00111010b = 00100000b
-01100000b & 00111011b = 00100000b
-01100000b & 00111100b = 00100000b
-01100000b & 00111101b = 00100000b
-01100000b & 00111110b = 00100000b
-01100000b & 00111111b = 00100000b
-01100000b & 01000000b = 01000000b
-01100000b & 01000001b = 01000000b
-01100000b & 01000010b = 01000000b
-01100000b & 01000011b = 01000000b
-01100000b & 01000100b = 01000000b
-01100000b & 01000101b = 01000000b
-01100000b & 01000110b = 01000000b
-01100000b & 01000111b = 01000000b
-01100000b & 01001000b = 01000000b
-01100000b & 01001001b = 01000000b
-01100000b & 01001010b = 01000000b
-01100000b & 01001011b = 01000000b
-01100000b & 01001100b = 01000000b
-01100000b & 01001101b = 01000000b
-01100000b & 01001110b = 01000000b
-01100000b & 01001111b = 01000000b
-01100000b & 01010000b = 01000000b
-01100000b & 01010001b = 01000000b
-01100000b & 01010010b = 01000000b
-01100000b & 01010011b = 01000000b
-01100000b & 01010100b = 01000000b
-01100000b & 01010101b = 01000000b
-01100000b & 01010110b = 01000000b
-01100000b & 01010111b = 01000000b
-01100000b & 01011000b = 01000000b
-01100000b & 01011001b = 01000000b
-01100000b & 01011010b = 01000000b
-01100000b & 01011011b = 01000000b
-01100000b & 01011100b = 01000000b
-01100000b & 01011101b = 01000000b
-01100000b & 01011110b = 01000000b
-01100000b & 01011111b = 01000000b
-01100000b & 01100000b = 01100000b
-01100000b & 01100001b = 01100000b
-01100000b & 01100010b = 01100000b
-01100000b & 01100011b = 01100000b
-01100000b & 01100100b = 01100000b
-01100000b & 01100101b = 01100000b
-01100000b & 01100110b = 01100000b
-01100000b & 01100111b = 01100000b
-01100000b & 01101000b = 01100000b
-01100000b & 01101001b = 01100000b
-01100000b & 01101010b = 01100000b
-01100000b & 01101011b = 01100000b
-01100000b & 01101100b = 01100000b
-01100000b & 01101101b = 01100000b
-01100000b & 01101110b = 01100000b
-01100000b & 01101111b = 01100000b
-01100000b & 01110000b = 01100000b
-01100000b & 01110001b = 01100000b
-01100000b & 01110010b = 01100000b
-01100000b & 01110011b = 01100000b
-01100000b & 01110100b = 01100000b
-01100000b & 01110101b = 01100000b
-01100000b & 01110110b = 01100000b
-01100000b & 01110111b = 01100000b
-01100000b & 01111000b = 01100000b
-01100000b & 01111001b = 01100000b
-01100000b & 01111010b = 01100000b
-01100000b & 01111011b = 01100000b
-01100000b & 01111100b = 01100000b
-01100000b & 01111101b = 01100000b
-01100000b & 01111110b = 01100000b
-01100001b & 10000000b = 00000000b
-01100001b & 10000001b = 00000001b
-01100001b & 10000010b = 00000000b
-01100001b & 10000011b = 00000001b
-01100001b & 10000100b = 00000000b
-01100001b & 10000101b = 00000001b
-01100001b & 10000110b = 00000000b
-01100001b & 10000111b = 00000001b
-01100001b & 10001000b = 00000000b
-01100001b & 10001001b = 00000001b
-01100001b & 10001010b = 00000000b
-01100001b & 10001011b = 00000001b
-01100001b & 10001100b = 00000000b
-01100001b & 10001101b = 00000001b
-01100001b & 10001110b = 00000000b
-01100001b & 10001111b = 00000001b
-01100001b & 10010000b = 00000000b
-01100001b & 10010001b = 00000001b
-01100001b & 10010010b = 00000000b
-01100001b & 10010011b = 00000001b
-01100001b & 10010100b = 00000000b
-01100001b & 10010101b = 00000001b
-01100001b & 10010110b = 00000000b
-01100001b & 10010111b = 00000001b
-01100001b & 10011000b = 00000000b
-01100001b & 10011001b = 00000001b
-01100001b & 10011010b = 00000000b
-01100001b & 10011011b = 00000001b
-01100001b & 10011100b = 00000000b
-01100001b & 10011101b = 00000001b
-01100001b & 10011110b = 00000000b
-01100001b & 10011111b = 00000001b
-01100001b & 10100000b = 00100000b
-01100001b & 10100001b = 00100001b
-01100001b & 10100010b = 00100000b
-01100001b & 10100011b = 00100001b
-01100001b & 10100100b = 00100000b
-01100001b & 10100101b = 00100001b
-01100001b & 10100110b = 00100000b
-01100001b & 10100111b = 00100001b
-01100001b & 10101000b = 00100000b
-01100001b & 10101001b = 00100001b
-01100001b & 10101010b = 00100000b
-01100001b & 10101011b = 00100001b
-01100001b & 10101100b = 00100000b
-01100001b & 10101101b = 00100001b
-01100001b & 10101110b = 00100000b
-01100001b & 10101111b = 00100001b
-01100001b & 10110000b = 00100000b
-01100001b & 10110001b = 00100001b
-01100001b & 10110010b = 00100000b
-01100001b & 10110011b = 00100001b
-01100001b & 10110100b = 00100000b
-01100001b & 10110101b = 00100001b
-01100001b & 10110110b = 00100000b
-01100001b & 10110111b = 00100001b
-01100001b & 10111000b = 00100000b
-01100001b & 10111001b = 00100001b
-01100001b & 10111010b = 00100000b
-01100001b & 10111011b = 00100001b
-01100001b & 10111100b = 00100000b
-01100001b & 10111101b = 00100001b
-01100001b & 10111110b = 00100000b
-01100001b & 10111111b = 00100001b
-01100001b & 11000000b = 01000000b
-01100001b & 11000001b = 01000001b
-01100001b & 11000010b = 01000000b
-01100001b & 11000011b = 01000001b
-01100001b & 11000100b = 01000000b
-01100001b & 11000101b = 01000001b
-01100001b & 11000110b = 01000000b
-01100001b & 11000111b = 01000001b
-01100001b & 11001000b = 01000000b
-01100001b & 11001001b = 01000001b
-01100001b & 11001010b = 01000000b
-01100001b & 11001011b = 01000001b
-01100001b & 11001100b = 01000000b
-01100001b & 11001101b = 01000001b
-01100001b & 11001110b = 01000000b
-01100001b & 11001111b = 01000001b
-01100001b & 11010000b = 01000000b
-01100001b & 11010001b = 01000001b
-01100001b & 11010010b = 01000000b
-01100001b & 11010011b = 01000001b
-01100001b & 11010100b = 01000000b
-01100001b & 11010101b = 01000001b
-01100001b & 11010110b = 01000000b
-01100001b & 11010111b = 01000001b
-01100001b & 11011000b = 01000000b
-01100001b & 11011001b = 01000001b
-01100001b & 11011010b = 01000000b
-01100001b & 11011011b = 01000001b
-01100001b & 11011100b = 01000000b
-01100001b & 11011101b = 01000001b
-01100001b & 11011110b = 01000000b
-01100001b & 11011111b = 01000001b
-01100001b & 11100000b = 01100000b
-01100001b & 11100001b = 01100001b
-01100001b & 11100010b = 01100000b
-01100001b & 11100011b = 01100001b
-01100001b & 11100100b = 01100000b
-01100001b & 11100101b = 01100001b
-01100001b & 11100110b = 01100000b
-01100001b & 11100111b = 01100001b
-01100001b & 11101000b = 01100000b
-01100001b & 11101001b = 01100001b
-01100001b & 11101010b = 01100000b
-01100001b & 11101011b = 01100001b
-01100001b & 11101100b = 01100000b
-01100001b & 11101101b = 01100001b
-01100001b & 11101110b = 01100000b
-01100001b & 11101111b = 01100001b
-01100001b & 11110000b = 01100000b
-01100001b & 11110001b = 01100001b
-01100001b & 11110010b = 01100000b
-01100001b & 11110011b = 01100001b
-01100001b & 11110100b = 01100000b
-01100001b & 11110101b = 01100001b
-01100001b & 11110110b = 01100000b
-01100001b & 11110111b = 01100001b
-01100001b & 11111000b = 01100000b
-01100001b & 11111001b = 01100001b
-01100001b & 11111010b = 01100000b
-01100001b & 11111011b = 01100001b
-01100001b & 11111100b = 01100000b
-01100001b & 11111101b = 01100001b
-01100001b & 11111110b = 01100000b
-01100001b & 11111111b = 01100001b
-01100001b & 00000000b = 00000000b
-01100001b & 00000001b = 00000001b
-01100001b & 00000010b = 00000000b
-01100001b & 00000011b = 00000001b
-01100001b & 00000100b = 00000000b
-01100001b & 00000101b = 00000001b
-01100001b & 00000110b = 00000000b
-01100001b & 00000111b = 00000001b
-01100001b & 00001000b = 00000000b
-01100001b & 00001001b = 00000001b
-01100001b & 00001010b = 00000000b
-01100001b & 00001011b = 00000001b
-01100001b & 00001100b = 00000000b
-01100001b & 00001101b = 00000001b
-01100001b & 00001110b = 00000000b
-01100001b & 00001111b = 00000001b
-01100001b & 00010000b = 00000000b
-01100001b & 00010001b = 00000001b
-01100001b & 00010010b = 00000000b
-01100001b & 00010011b = 00000001b
-01100001b & 00010100b = 00000000b
-01100001b & 00010101b = 00000001b
-01100001b & 00010110b = 00000000b
-01100001b & 00010111b = 00000001b
-01100001b & 00011000b = 00000000b
-01100001b & 00011001b = 00000001b
-01100001b & 00011010b = 00000000b
-01100001b & 00011011b = 00000001b
-01100001b & 00011100b = 00000000b
-01100001b & 00011101b = 00000001b
-01100001b & 00011110b = 00000000b
-01100001b & 00011111b = 00000001b
-01100001b & 00100000b = 00100000b
-01100001b & 00100001b = 00100001b
-01100001b & 00100010b = 00100000b
-01100001b & 00100011b = 00100001b
-01100001b & 00100100b = 00100000b
-01100001b & 00100101b = 00100001b
-01100001b & 00100110b = 00100000b
-01100001b & 00100111b = 00100001b
-01100001b & 00101000b = 00100000b
-01100001b & 00101001b = 00100001b
-01100001b & 00101010b = 00100000b
-01100001b & 00101011b = 00100001b
-01100001b & 00101100b = 00100000b
-01100001b & 00101101b = 00100001b
-01100001b & 00101110b = 00100000b
-01100001b & 00101111b = 00100001b
-01100001b & 00110000b = 00100000b
-01100001b & 00110001b = 00100001b
-01100001b & 00110010b = 00100000b
-01100001b & 00110011b = 00100001b
-01100001b & 00110100b = 00100000b
-01100001b & 00110101b = 00100001b
-01100001b & 00110110b = 00100000b
-01100001b & 00110111b = 00100001b
-01100001b & 00111000b = 00100000b
-01100001b & 00111001b = 00100001b
-01100001b & 00111010b = 00100000b
-01100001b & 00111011b = 00100001b
-01100001b & 00111100b = 00100000b
-01100001b & 00111101b = 00100001b
-01100001b & 00111110b = 00100000b
-01100001b & 00111111b = 00100001b
-01100001b & 01000000b = 01000000b
-01100001b & 01000001b = 01000001b
-01100001b & 01000010b = 01000000b
-01100001b & 01000011b = 01000001b
-01100001b & 01000100b = 01000000b
-01100001b & 01000101b = 01000001b
-01100001b & 01000110b = 01000000b
-01100001b & 01000111b = 01000001b
-01100001b & 01001000b = 01000000b
-01100001b & 01001001b = 01000001b
-01100001b & 01001010b = 01000000b
-01100001b & 01001011b = 01000001b
-01100001b & 01001100b = 01000000b
-01100001b & 01001101b = 01000001b
-01100001b & 01001110b = 01000000b
-01100001b & 01001111b = 01000001b
-01100001b & 01010000b = 01000000b
-01100001b & 01010001b = 01000001b
-01100001b & 01010010b = 01000000b
-01100001b & 01010011b = 01000001b
-01100001b & 01010100b = 01000000b
-01100001b & 01010101b = 01000001b
-01100001b & 01010110b = 01000000b
-01100001b & 01010111b = 01000001b
-01100001b & 01011000b = 01000000b
-01100001b & 01011001b = 01000001b
-01100001b & 01011010b = 01000000b
-01100001b & 01011011b = 01000001b
-01100001b & 01011100b = 01000000b
-01100001b & 01011101b = 01000001b
-01100001b & 01011110b = 01000000b
-01100001b & 01011111b = 01000001b
-01100001b & 01100000b = 01100000b
-01100001b & 01100001b = 01100001b
-01100001b & 01100010b = 01100000b
-01100001b & 01100011b = 01100001b
-01100001b & 01100100b = 01100000b
-01100001b & 01100101b = 01100001b
-01100001b & 01100110b = 01100000b
-01100001b & 01100111b = 01100001b
-01100001b & 01101000b = 01100000b
-01100001b & 01101001b = 01100001b
-01100001b & 01101010b = 01100000b
-01100001b & 01101011b = 01100001b
-01100001b & 01101100b = 01100000b
-01100001b & 01101101b = 01100001b
-01100001b & 01101110b = 01100000b
-01100001b & 01101111b = 01100001b
-01100001b & 01110000b = 01100000b
-01100001b & 01110001b = 01100001b
-01100001b & 01110010b = 01100000b
-01100001b & 01110011b = 01100001b
-01100001b & 01110100b = 01100000b
-01100001b & 01110101b = 01100001b
-01100001b & 01110110b = 01100000b
-01100001b & 01110111b = 01100001b
-01100001b & 01111000b = 01100000b
-01100001b & 01111001b = 01100001b
-01100001b & 01111010b = 01100000b
-01100001b & 01111011b = 01100001b
-01100001b & 01111100b = 01100000b
-01100001b & 01111101b = 01100001b
-01100001b & 01111110b = 01100000b
-01100010b & 10000000b = 00000000b
-01100010b & 10000001b = 00000000b
-01100010b & 10000010b = 00000010b
-01100010b & 10000011b = 00000010b
-01100010b & 10000100b = 00000000b
-01100010b & 10000101b = 00000000b
-01100010b & 10000110b = 00000010b
-01100010b & 10000111b = 00000010b
-01100010b & 10001000b = 00000000b
-01100010b & 10001001b = 00000000b
-01100010b & 10001010b = 00000010b
-01100010b & 10001011b = 00000010b
-01100010b & 10001100b = 00000000b
-01100010b & 10001101b = 00000000b
-01100010b & 10001110b = 00000010b
-01100010b & 10001111b = 00000010b
-01100010b & 10010000b = 00000000b
-01100010b & 10010001b = 00000000b
-01100010b & 10010010b = 00000010b
-01100010b & 10010011b = 00000010b
-01100010b & 10010100b = 00000000b
-01100010b & 10010101b = 00000000b
-01100010b & 10010110b = 00000010b
-01100010b & 10010111b = 00000010b
-01100010b & 10011000b = 00000000b
-01100010b & 10011001b = 00000000b
-01100010b & 10011010b = 00000010b
-01100010b & 10011011b = 00000010b
-01100010b & 10011100b = 00000000b
-01100010b & 10011101b = 00000000b
-01100010b & 10011110b = 00000010b
-01100010b & 10011111b = 00000010b
-01100010b & 10100000b = 00100000b
-01100010b & 10100001b = 00100000b
-01100010b & 10100010b = 00100010b
-01100010b & 10100011b = 00100010b
-01100010b & 10100100b = 00100000b
-01100010b & 10100101b = 00100000b
-01100010b & 10100110b = 00100010b
-01100010b & 10100111b = 00100010b
-01100010b & 10101000b = 00100000b
-01100010b & 10101001b = 00100000b
-01100010b & 10101010b = 00100010b
-01100010b & 10101011b = 00100010b
-01100010b & 10101100b = 00100000b
-01100010b & 10101101b = 00100000b
-01100010b & 10101110b = 00100010b
-01100010b & 10101111b = 00100010b
-01100010b & 10110000b = 00100000b
-01100010b & 10110001b = 00100000b
-01100010b & 10110010b = 00100010b
-01100010b & 10110011b = 00100010b
-01100010b & 10110100b = 00100000b
-01100010b & 10110101b = 00100000b
-01100010b & 10110110b = 00100010b
-01100010b & 10110111b = 00100010b
-01100010b & 10111000b = 00100000b
-01100010b & 10111001b = 00100000b
-01100010b & 10111010b = 00100010b
-01100010b & 10111011b = 00100010b
-01100010b & 10111100b = 00100000b
-01100010b & 10111101b = 00100000b
-01100010b & 10111110b = 00100010b
-01100010b & 10111111b = 00100010b
-01100010b & 11000000b = 01000000b
-01100010b & 11000001b = 01000000b
-01100010b & 11000010b = 01000010b
-01100010b & 11000011b = 01000010b
-01100010b & 11000100b = 01000000b
-01100010b & 11000101b = 01000000b
-01100010b & 11000110b = 01000010b
-01100010b & 11000111b = 01000010b
-01100010b & 11001000b = 01000000b
-01100010b & 11001001b = 01000000b
-01100010b & 11001010b = 01000010b
-01100010b & 11001011b = 01000010b
-01100010b & 11001100b = 01000000b
-01100010b & 11001101b = 01000000b
-01100010b & 11001110b = 01000010b
-01100010b & 11001111b = 01000010b
-01100010b & 11010000b = 01000000b
-01100010b & 11010001b = 01000000b
-01100010b & 11010010b = 01000010b
-01100010b & 11010011b = 01000010b
-01100010b & 11010100b = 01000000b
-01100010b & 11010101b = 01000000b
-01100010b & 11010110b = 01000010b
-01100010b & 11010111b = 01000010b
-01100010b & 11011000b = 01000000b
-01100010b & 11011001b = 01000000b
-01100010b & 11011010b = 01000010b
-01100010b & 11011011b = 01000010b
-01100010b & 11011100b = 01000000b
-01100010b & 11011101b = 01000000b
-01100010b & 11011110b = 01000010b
-01100010b & 11011111b = 01000010b
-01100010b & 11100000b = 01100000b
-01100010b & 11100001b = 01100000b
-01100010b & 11100010b = 01100010b
-01100010b & 11100011b = 01100010b
-01100010b & 11100100b = 01100000b
-01100010b & 11100101b = 01100000b
-01100010b & 11100110b = 01100010b
-01100010b & 11100111b = 01100010b
-01100010b & 11101000b = 01100000b
-01100010b & 11101001b = 01100000b
-01100010b & 11101010b = 01100010b
-01100010b & 11101011b = 01100010b
-01100010b & 11101100b = 01100000b
-01100010b & 11101101b = 01100000b
-01100010b & 11101110b = 01100010b
-01100010b & 11101111b = 01100010b
-01100010b & 11110000b = 01100000b
-01100010b & 11110001b = 01100000b
-01100010b & 11110010b = 01100010b
-01100010b & 11110011b = 01100010b
-01100010b & 11110100b = 01100000b
-01100010b & 11110101b = 01100000b
-01100010b & 11110110b = 01100010b
-01100010b & 11110111b = 01100010b
-01100010b & 11111000b = 01100000b
-01100010b & 11111001b = 01100000b
-01100010b & 11111010b = 01100010b
-01100010b & 11111011b = 01100010b
-01100010b & 11111100b = 01100000b
-01100010b & 11111101b = 01100000b
-01100010b & 11111110b = 01100010b
-01100010b & 11111111b = 01100010b
-01100010b & 00000000b = 00000000b
-01100010b & 00000001b = 00000000b
-01100010b & 00000010b = 00000010b
-01100010b & 00000011b = 00000010b
-01100010b & 00000100b = 00000000b
-01100010b & 00000101b = 00000000b
-01100010b & 00000110b = 00000010b
-01100010b & 00000111b = 00000010b
-01100010b & 00001000b = 00000000b
-01100010b & 00001001b = 00000000b
-01100010b & 00001010b = 00000010b
-01100010b & 00001011b = 00000010b
-01100010b & 00001100b = 00000000b
-01100010b & 00001101b = 00000000b
-01100010b & 00001110b = 00000010b
-01100010b & 00001111b = 00000010b
-01100010b & 00010000b = 00000000b
-01100010b & 00010001b = 00000000b
-01100010b & 00010010b = 00000010b
-01100010b & 00010011b = 00000010b
-01100010b & 00010100b = 00000000b
-01100010b & 00010101b = 00000000b
-01100010b & 00010110b = 00000010b
-01100010b & 00010111b = 00000010b
-01100010b & 00011000b = 00000000b
-01100010b & 00011001b = 00000000b
-01100010b & 00011010b = 00000010b
-01100010b & 00011011b = 00000010b
-01100010b & 00011100b = 00000000b
-01100010b & 00011101b = 00000000b
-01100010b & 00011110b = 00000010b
-01100010b & 00011111b = 00000010b
-01100010b & 00100000b = 00100000b
-01100010b & 00100001b = 00100000b
-01100010b & 00100010b = 00100010b
-01100010b & 00100011b = 00100010b
-01100010b & 00100100b = 00100000b
-01100010b & 00100101b = 00100000b
-01100010b & 00100110b = 00100010b
-01100010b & 00100111b = 00100010b
-01100010b & 00101000b = 00100000b
-01100010b & 00101001b = 00100000b
-01100010b & 00101010b = 00100010b
-01100010b & 00101011b = 00100010b
-01100010b & 00101100b = 00100000b
-01100010b & 00101101b = 00100000b
-01100010b & 00101110b = 00100010b
-01100010b & 00101111b = 00100010b
-01100010b & 00110000b = 00100000b
-01100010b & 00110001b = 00100000b
-01100010b & 00110010b = 00100010b
-01100010b & 00110011b = 00100010b
-01100010b & 00110100b = 00100000b
-01100010b & 00110101b = 00100000b
-01100010b & 00110110b = 00100010b
-01100010b & 00110111b = 00100010b
-01100010b & 00111000b = 00100000b
-01100010b & 00111001b = 00100000b
-01100010b & 00111010b = 00100010b
-01100010b & 00111011b = 00100010b
-01100010b & 00111100b = 00100000b
-01100010b & 00111101b = 00100000b
-01100010b & 00111110b = 00100010b
-01100010b & 00111111b = 00100010b
-01100010b & 01000000b = 01000000b
-01100010b & 01000001b = 01000000b
-01100010b & 01000010b = 01000010b
-01100010b & 01000011b = 01000010b
-01100010b & 01000100b = 01000000b
-01100010b & 01000101b = 01000000b
-01100010b & 01000110b = 01000010b
-01100010b & 01000111b = 01000010b
-01100010b & 01001000b = 01000000b
-01100010b & 01001001b = 01000000b
-01100010b & 01001010b = 01000010b
-01100010b & 01001011b = 01000010b
-01100010b & 01001100b = 01000000b
-01100010b & 01001101b = 01000000b
-01100010b & 01001110b = 01000010b
-01100010b & 01001111b = 01000010b
-01100010b & 01010000b = 01000000b
-01100010b & 01010001b = 01000000b
-01100010b & 01010010b = 01000010b
-01100010b & 01010011b = 01000010b
-01100010b & 01010100b = 01000000b
-01100010b & 01010101b = 01000000b
-01100010b & 01010110b = 01000010b
-01100010b & 01010111b = 01000010b
-01100010b & 01011000b = 01000000b
-01100010b & 01011001b = 01000000b
-01100010b & 01011010b = 01000010b
-01100010b & 01011011b = 01000010b
-01100010b & 01011100b = 01000000b
-01100010b & 01011101b = 01000000b
-01100010b & 01011110b = 01000010b
-01100010b & 01011111b = 01000010b
-01100010b & 01100000b = 01100000b
-01100010b & 01100001b = 01100000b
-01100010b & 01100010b = 01100010b
-01100010b & 01100011b = 01100010b
-01100010b & 01100100b = 01100000b
-01100010b & 01100101b = 01100000b
-01100010b & 01100110b = 01100010b
-01100010b & 01100111b = 01100010b
-01100010b & 01101000b = 01100000b
-01100010b & 01101001b = 01100000b
-01100010b & 01101010b = 01100010b
-01100010b & 01101011b = 01100010b
-01100010b & 01101100b = 01100000b
-01100010b & 01101101b = 01100000b
-01100010b & 01101110b = 01100010b
-01100010b & 01101111b = 01100010b
-01100010b & 01110000b = 01100000b
-01100010b & 01110001b = 01100000b
-01100010b & 01110010b = 01100010b
-01100010b & 01110011b = 01100010b
-01100010b & 01110100b = 01100000b
-01100010b & 01110101b = 01100000b
-01100010b & 01110110b = 01100010b
-01100010b & 01110111b = 01100010b
-01100010b & 01111000b = 01100000b
-01100010b & 01111001b = 01100000b
-01100010b & 01111010b = 01100010b
-01100010b & 01111011b = 01100010b
-01100010b & 01111100b = 01100000b
-01100010b & 01111101b = 01100000b
-01100010b & 01111110b = 01100010b
-01100011b & 10000000b = 00000000b
-01100011b & 10000001b = 00000001b
-01100011b & 10000010b = 00000010b
-01100011b & 10000011b = 00000011b
-01100011b & 10000100b = 00000000b
-01100011b & 10000101b = 00000001b
-01100011b & 10000110b = 00000010b
-01100011b & 10000111b = 00000011b
-01100011b & 10001000b = 00000000b
-01100011b & 10001001b = 00000001b
-01100011b & 10001010b = 00000010b
-01100011b & 10001011b = 00000011b
-01100011b & 10001100b = 00000000b
-01100011b & 10001101b = 00000001b
-01100011b & 10001110b = 00000010b
-01100011b & 10001111b = 00000011b
-01100011b & 10010000b = 00000000b
-01100011b & 10010001b = 00000001b
-01100011b & 10010010b = 00000010b
-01100011b & 10010011b = 00000011b
-01100011b & 10010100b = 00000000b
-01100011b & 10010101b = 00000001b
-01100011b & 10010110b = 00000010b
-01100011b & 10010111b = 00000011b
-01100011b & 10011000b = 00000000b
-01100011b & 10011001b = 00000001b
-01100011b & 10011010b = 00000010b
-01100011b & 10011011b = 00000011b
-01100011b & 10011100b = 00000000b
-01100011b & 10011101b = 00000001b
-01100011b & 10011110b = 00000010b
-01100011b & 10011111b = 00000011b
-01100011b & 10100000b = 00100000b
-01100011b & 10100001b = 00100001b
-01100011b & 10100010b = 00100010b
-01100011b & 10100011b = 00100011b
-01100011b & 10100100b = 00100000b
-01100011b & 10100101b = 00100001b
-01100011b & 10100110b = 00100010b
-01100011b & 10100111b = 00100011b
-01100011b & 10101000b = 00100000b
-01100011b & 10101001b = 00100001b
-01100011b & 10101010b = 00100010b
-01100011b & 10101011b = 00100011b
-01100011b & 10101100b = 00100000b
-01100011b & 10101101b = 00100001b
-01100011b & 10101110b = 00100010b
-01100011b & 10101111b = 00100011b
-01100011b & 10110000b = 00100000b
-01100011b & 10110001b = 00100001b
-01100011b & 10110010b = 00100010b
-01100011b & 10110011b = 00100011b
-01100011b & 10110100b = 00100000b
-01100011b & 10110101b = 00100001b
-01100011b & 10110110b = 00100010b
-01100011b & 10110111b = 00100011b
-01100011b & 10111000b = 00100000b
-01100011b & 10111001b = 00100001b
-01100011b & 10111010b = 00100010b
-01100011b & 10111011b = 00100011b
-01100011b & 10111100b = 00100000b
-01100011b & 10111101b = 00100001b
-01100011b & 10111110b = 00100010b
-01100011b & 10111111b = 00100011b
-01100011b & 11000000b = 01000000b
-01100011b & 11000001b = 01000001b
-01100011b & 11000010b = 01000010b
-01100011b & 11000011b = 01000011b
-01100011b & 11000100b = 01000000b
-01100011b & 11000101b = 01000001b
-01100011b & 11000110b = 01000010b
-01100011b & 11000111b = 01000011b
-01100011b & 11001000b = 01000000b
-01100011b & 11001001b = 01000001b
-01100011b & 11001010b = 01000010b
-01100011b & 11001011b = 01000011b
-01100011b & 11001100b = 01000000b
-01100011b & 11001101b = 01000001b
-01100011b & 11001110b = 01000010b
-01100011b & 11001111b = 01000011b
-01100011b & 11010000b = 01000000b
-01100011b & 11010001b = 01000001b
-01100011b & 11010010b = 01000010b
-01100011b & 11010011b = 01000011b
-01100011b & 11010100b = 01000000b
-01100011b & 11010101b = 01000001b
-01100011b & 11010110b = 01000010b
-01100011b & 11010111b = 01000011b
-01100011b & 11011000b = 01000000b
-01100011b & 11011001b = 01000001b
-01100011b & 11011010b = 01000010b
-01100011b & 11011011b = 01000011b
-01100011b & 11011100b = 01000000b
-01100011b & 11011101b = 01000001b
-01100011b & 11011110b = 01000010b
-01100011b & 11011111b = 01000011b
-01100011b & 11100000b = 01100000b
-01100011b & 11100001b = 01100001b
-01100011b & 11100010b = 01100010b
-01100011b & 11100011b = 01100011b
-01100011b & 11100100b = 01100000b
-01100011b & 11100101b = 01100001b
-01100011b & 11100110b = 01100010b
-01100011b & 11100111b = 01100011b
-01100011b & 11101000b = 01100000b
-01100011b & 11101001b = 01100001b
-01100011b & 11101010b = 01100010b
-01100011b & 11101011b = 01100011b
-01100011b & 11101100b = 01100000b
-01100011b & 11101101b = 01100001b
-01100011b & 11101110b = 01100010b
-01100011b & 11101111b = 01100011b
-01100011b & 11110000b = 01100000b
-01100011b & 11110001b = 01100001b
-01100011b & 11110010b = 01100010b
-01100011b & 11110011b = 01100011b
-01100011b & 11110100b = 01100000b
-01100011b & 11110101b = 01100001b
-01100011b & 11110110b = 01100010b
-01100011b & 11110111b = 01100011b
-01100011b & 11111000b = 01100000b
-01100011b & 11111001b = 01100001b
-01100011b & 11111010b = 01100010b
-01100011b & 11111011b = 01100011b
-01100011b & 11111100b = 01100000b
-01100011b & 11111101b = 01100001b
-01100011b & 11111110b = 01100010b
-01100011b & 11111111b = 01100011b
-01100011b & 00000000b = 00000000b
-01100011b & 00000001b = 00000001b
-01100011b & 00000010b = 00000010b
-01100011b & 00000011b = 00000011b
-01100011b & 00000100b = 00000000b
-01100011b & 00000101b = 00000001b
-01100011b & 00000110b = 00000010b
-01100011b & 00000111b = 00000011b
-01100011b & 00001000b = 00000000b
-01100011b & 00001001b = 00000001b
-01100011b & 00001010b = 00000010b
-01100011b & 00001011b = 00000011b
-01100011b & 00001100b = 00000000b
-01100011b & 00001101b = 00000001b
-01100011b & 00001110b = 00000010b
-01100011b & 00001111b = 00000011b
-01100011b & 00010000b = 00000000b
-01100011b & 00010001b = 00000001b
-01100011b & 00010010b = 00000010b
-01100011b & 00010011b = 00000011b
-01100011b & 00010100b = 00000000b
-01100011b & 00010101b = 00000001b
-01100011b & 00010110b = 00000010b
-01100011b & 00010111b = 00000011b
-01100011b & 00011000b = 00000000b
-01100011b & 00011001b = 00000001b
-01100011b & 00011010b = 00000010b
-01100011b & 00011011b = 00000011b
-01100011b & 00011100b = 00000000b
-01100011b & 00011101b = 00000001b
-01100011b & 00011110b = 00000010b
-01100011b & 00011111b = 00000011b
-01100011b & 00100000b = 00100000b
-01100011b & 00100001b = 00100001b
-01100011b & 00100010b = 00100010b
-01100011b & 00100011b = 00100011b
-01100011b & 00100100b = 00100000b
-01100011b & 00100101b = 00100001b
-01100011b & 00100110b = 00100010b
-01100011b & 00100111b = 00100011b
-01100011b & 00101000b = 00100000b
-01100011b & 00101001b = 00100001b
-01100011b & 00101010b = 00100010b
-01100011b & 00101011b = 00100011b
-01100011b & 00101100b = 00100000b
-01100011b & 00101101b = 00100001b
-01100011b & 00101110b = 00100010b
-01100011b & 00101111b = 00100011b
-01100011b & 00110000b = 00100000b
-01100011b & 00110001b = 00100001b
-01100011b & 00110010b = 00100010b
-01100011b & 00110011b = 00100011b
-01100011b & 00110100b = 00100000b
-01100011b & 00110101b = 00100001b
-01100011b & 00110110b = 00100010b
-01100011b & 00110111b = 00100011b
-01100011b & 00111000b = 00100000b
-01100011b & 00111001b = 00100001b
-01100011b & 00111010b = 00100010b
-01100011b & 00111011b = 00100011b
-01100011b & 00111100b = 00100000b
-01100011b & 00111101b = 00100001b
-01100011b & 00111110b = 00100010b
-01100011b & 00111111b = 00100011b
-01100011b & 01000000b = 01000000b
-01100011b & 01000001b = 01000001b
-01100011b & 01000010b = 01000010b
-01100011b & 01000011b = 01000011b
-01100011b & 01000100b = 01000000b
-01100011b & 01000101b = 01000001b
-01100011b & 01000110b = 01000010b
-01100011b & 01000111b = 01000011b
-01100011b & 01001000b = 01000000b
-01100011b & 01001001b = 01000001b
-01100011b & 01001010b = 01000010b
-01100011b & 01001011b = 01000011b
-01100011b & 01001100b = 01000000b
-01100011b & 01001101b = 01000001b
-01100011b & 01001110b = 01000010b
-01100011b & 01001111b = 01000011b
-01100011b & 01010000b = 01000000b
-01100011b & 01010001b = 01000001b
-01100011b & 01010010b = 01000010b
-01100011b & 01010011b = 01000011b
-01100011b & 01010100b = 01000000b
-01100011b & 01010101b = 01000001b
-01100011b & 01010110b = 01000010b
-01100011b & 01010111b = 01000011b
-01100011b & 01011000b = 01000000b
-01100011b & 01011001b = 01000001b
-01100011b & 01011010b = 01000010b
-01100011b & 01011011b = 01000011b
-01100011b & 01011100b = 01000000b
-01100011b & 01011101b = 01000001b
-01100011b & 01011110b = 01000010b
-01100011b & 01011111b = 01000011b
-01100011b & 01100000b = 01100000b
-01100011b & 01100001b = 01100001b
-01100011b & 01100010b = 01100010b
-01100011b & 01100011b = 01100011b
-01100011b & 01100100b = 01100000b
-01100011b & 01100101b = 01100001b
-01100011b & 01100110b = 01100010b
-01100011b & 01100111b = 01100011b
-01100011b & 01101000b = 01100000b
-01100011b & 01101001b = 01100001b
-01100011b & 01101010b = 01100010b
-01100011b & 01101011b = 01100011b
-01100011b & 01101100b = 01100000b
-01100011b & 01101101b = 01100001b
-01100011b & 01101110b = 01100010b
-01100011b & 01101111b = 01100011b
-01100011b & 01110000b = 01100000b
-01100011b & 01110001b = 01100001b
-01100011b & 01110010b = 01100010b
-01100011b & 01110011b = 01100011b
-01100011b & 01110100b = 01100000b
-01100011b & 01110101b = 01100001b
-01100011b & 01110110b = 01100010b
-01100011b & 01110111b = 01100011b
-01100011b & 01111000b = 01100000b
-01100011b & 01111001b = 01100001b
-01100011b & 01111010b = 01100010b
-01100011b & 01111011b = 01100011b
-01100011b & 01111100b = 01100000b
-01100011b & 01111101b = 01100001b
-01100011b & 01111110b = 01100010b
-01100100b & 10000000b = 00000000b
-01100100b & 10000001b = 00000000b
-01100100b & 10000010b = 00000000b
-01100100b & 10000011b = 00000000b
-01100100b & 10000100b = 00000100b
-01100100b & 10000101b = 00000100b
-01100100b & 10000110b = 00000100b
-01100100b & 10000111b = 00000100b
-01100100b & 10001000b = 00000000b
-01100100b & 10001001b = 00000000b
-01100100b & 10001010b = 00000000b
-01100100b & 10001011b = 00000000b
-01100100b & 10001100b = 00000100b
-01100100b & 10001101b = 00000100b
-01100100b & 10001110b = 00000100b
-01100100b & 10001111b = 00000100b
-01100100b & 10010000b = 00000000b
-01100100b & 10010001b = 00000000b
-01100100b & 10010010b = 00000000b
-01100100b & 10010011b = 00000000b
-01100100b & 10010100b = 00000100b
-01100100b & 10010101b = 00000100b
-01100100b & 10010110b = 00000100b
-01100100b & 10010111b = 00000100b
-01100100b & 10011000b = 00000000b
-01100100b & 10011001b = 00000000b
-01100100b & 10011010b = 00000000b
-01100100b & 10011011b = 00000000b
-01100100b & 10011100b = 00000100b
-01100100b & 10011101b = 00000100b
-01100100b & 10011110b = 00000100b
-01100100b & 10011111b = 00000100b
-01100100b & 10100000b = 00100000b
-01100100b & 10100001b = 00100000b
-01100100b & 10100010b = 00100000b
-01100100b & 10100011b = 00100000b
-01100100b & 10100100b = 00100100b
-01100100b & 10100101b = 00100100b
-01100100b & 10100110b = 00100100b
-01100100b & 10100111b = 00100100b
-01100100b & 10101000b = 00100000b
-01100100b & 10101001b = 00100000b
-01100100b & 10101010b = 00100000b
-01100100b & 10101011b = 00100000b
-01100100b & 10101100b = 00100100b
-01100100b & 10101101b = 00100100b
-01100100b & 10101110b = 00100100b
-01100100b & 10101111b = 00100100b
-01100100b & 10110000b = 00100000b
-01100100b & 10110001b = 00100000b
-01100100b & 10110010b = 00100000b
-01100100b & 10110011b = 00100000b
-01100100b & 10110100b = 00100100b
-01100100b & 10110101b = 00100100b
-01100100b & 10110110b = 00100100b
-01100100b & 10110111b = 00100100b
-01100100b & 10111000b = 00100000b
-01100100b & 10111001b = 00100000b
-01100100b & 10111010b = 00100000b
-01100100b & 10111011b = 00100000b
-01100100b & 10111100b = 00100100b
-01100100b & 10111101b = 00100100b
-01100100b & 10111110b = 00100100b
-01100100b & 10111111b = 00100100b
-01100100b & 11000000b = 01000000b
-01100100b & 11000001b = 01000000b
-01100100b & 11000010b = 01000000b
-01100100b & 11000011b = 01000000b
-01100100b & 11000100b = 01000100b
-01100100b & 11000101b = 01000100b
-01100100b & 11000110b = 01000100b
-01100100b & 11000111b = 01000100b
-01100100b & 11001000b = 01000000b
-01100100b & 11001001b = 01000000b
-01100100b & 11001010b = 01000000b
-01100100b & 11001011b = 01000000b
-01100100b & 11001100b = 01000100b
-01100100b & 11001101b = 01000100b
-01100100b & 11001110b = 01000100b
-01100100b & 11001111b = 01000100b
-01100100b & 11010000b = 01000000b
-01100100b & 11010001b = 01000000b
-01100100b & 11010010b = 01000000b
-01100100b & 11010011b = 01000000b
-01100100b & 11010100b = 01000100b
-01100100b & 11010101b = 01000100b
-01100100b & 11010110b = 01000100b
-01100100b & 11010111b = 01000100b
-01100100b & 11011000b = 01000000b
-01100100b & 11011001b = 01000000b
-01100100b & 11011010b = 01000000b
-01100100b & 11011011b = 01000000b
-01100100b & 11011100b = 01000100b
-01100100b & 11011101b = 01000100b
-01100100b & 11011110b = 01000100b
-01100100b & 11011111b = 01000100b
-01100100b & 11100000b = 01100000b
-01100100b & 11100001b = 01100000b
-01100100b & 11100010b = 01100000b
-01100100b & 11100011b = 01100000b
-01100100b & 11100100b = 01100100b
-01100100b & 11100101b = 01100100b
-01100100b & 11100110b = 01100100b
-01100100b & 11100111b = 01100100b
-01100100b & 11101000b = 01100000b
-01100100b & 11101001b = 01100000b
-01100100b & 11101010b = 01100000b
-01100100b & 11101011b = 01100000b
-01100100b & 11101100b = 01100100b
-01100100b & 11101101b = 01100100b
-01100100b & 11101110b = 01100100b
-01100100b & 11101111b = 01100100b
-01100100b & 11110000b = 01100000b
-01100100b & 11110001b = 01100000b
-01100100b & 11110010b = 01100000b
-01100100b & 11110011b = 01100000b
-01100100b & 11110100b = 01100100b
-01100100b & 11110101b = 01100100b
-01100100b & 11110110b = 01100100b
-01100100b & 11110111b = 01100100b
-01100100b & 11111000b = 01100000b
-01100100b & 11111001b = 01100000b
-01100100b & 11111010b = 01100000b
-01100100b & 11111011b = 01100000b
-01100100b & 11111100b = 01100100b
-01100100b & 11111101b = 01100100b
-01100100b & 11111110b = 01100100b
-01100100b & 11111111b = 01100100b
-01100100b & 00000000b = 00000000b
-01100100b & 00000001b = 00000000b
-01100100b & 00000010b = 00000000b
-01100100b & 00000011b = 00000000b
-01100100b & 00000100b = 00000100b
-01100100b & 00000101b = 00000100b
-01100100b & 00000110b = 00000100b
-01100100b & 00000111b = 00000100b
-01100100b & 00001000b = 00000000b
-01100100b & 00001001b = 00000000b
-01100100b & 00001010b = 00000000b
-01100100b & 00001011b = 00000000b
-01100100b & 00001100b = 00000100b
-01100100b & 00001101b = 00000100b
-01100100b & 00001110b = 00000100b
-01100100b & 00001111b = 00000100b
-01100100b & 00010000b = 00000000b
-01100100b & 00010001b = 00000000b
-01100100b & 00010010b = 00000000b
-01100100b & 00010011b = 00000000b
-01100100b & 00010100b = 00000100b
-01100100b & 00010101b = 00000100b
-01100100b & 00010110b = 00000100b
-01100100b & 00010111b = 00000100b
-01100100b & 00011000b = 00000000b
-01100100b & 00011001b = 00000000b
-01100100b & 00011010b = 00000000b
-01100100b & 00011011b = 00000000b
-01100100b & 00011100b = 00000100b
-01100100b & 00011101b = 00000100b
-01100100b & 00011110b = 00000100b
-01100100b & 00011111b = 00000100b
-01100100b & 00100000b = 00100000b
-01100100b & 00100001b = 00100000b
-01100100b & 00100010b = 00100000b
-01100100b & 00100011b = 00100000b
-01100100b & 00100100b = 00100100b
-01100100b & 00100101b = 00100100b
-01100100b & 00100110b = 00100100b
-01100100b & 00100111b = 00100100b
-01100100b & 00101000b = 00100000b
-01100100b & 00101001b = 00100000b
-01100100b & 00101010b = 00100000b
-01100100b & 00101011b = 00100000b
-01100100b & 00101100b = 00100100b
-01100100b & 00101101b = 00100100b
-01100100b & 00101110b = 00100100b
-01100100b & 00101111b = 00100100b
-01100100b & 00110000b = 00100000b
-01100100b & 00110001b = 00100000b
-01100100b & 00110010b = 00100000b
-01100100b & 00110011b = 00100000b
-01100100b & 00110100b = 00100100b
-01100100b & 00110101b = 00100100b
-01100100b & 00110110b = 00100100b
-01100100b & 00110111b = 00100100b
-01100100b & 00111000b = 00100000b
-01100100b & 00111001b = 00100000b
-01100100b & 00111010b = 00100000b
-01100100b & 00111011b = 00100000b
-01100100b & 00111100b = 00100100b
-01100100b & 00111101b = 00100100b
-01100100b & 00111110b = 00100100b
-01100100b & 00111111b = 00100100b
-01100100b & 01000000b = 01000000b
-01100100b & 01000001b = 01000000b
-01100100b & 01000010b = 01000000b
-01100100b & 01000011b = 01000000b
-01100100b & 01000100b = 01000100b
-01100100b & 01000101b = 01000100b
-01100100b & 01000110b = 01000100b
-01100100b & 01000111b = 01000100b
-01100100b & 01001000b = 01000000b
-01100100b & 01001001b = 01000000b
-01100100b & 01001010b = 01000000b
-01100100b & 01001011b = 01000000b
-01100100b & 01001100b = 01000100b
-01100100b & 01001101b = 01000100b
-01100100b & 01001110b = 01000100b
-01100100b & 01001111b = 01000100b
-01100100b & 01010000b = 01000000b
-01100100b & 01010001b = 01000000b
-01100100b & 01010010b = 01000000b
-01100100b & 01010011b = 01000000b
-01100100b & 01010100b = 01000100b
-01100100b & 01010101b = 01000100b
-01100100b & 01010110b = 01000100b
-01100100b & 01010111b = 01000100b
-01100100b & 01011000b = 01000000b
-01100100b & 01011001b = 01000000b
-01100100b & 01011010b = 01000000b
-01100100b & 01011011b = 01000000b
-01100100b & 01011100b = 01000100b
-01100100b & 01011101b = 01000100b
-01100100b & 01011110b = 01000100b
-01100100b & 01011111b = 01000100b
-01100100b & 01100000b = 01100000b
-01100100b & 01100001b = 01100000b
-01100100b & 01100010b = 01100000b
-01100100b & 01100011b = 01100000b
-01100100b & 01100100b = 01100100b
-01100100b & 01100101b = 01100100b
-01100100b & 01100110b = 01100100b
-01100100b & 01100111b = 01100100b
-01100100b & 01101000b = 01100000b
-01100100b & 01101001b = 01100000b
-01100100b & 01101010b = 01100000b
-01100100b & 01101011b = 01100000b
-01100100b & 01101100b = 01100100b
-01100100b & 01101101b = 01100100b
-01100100b & 01101110b = 01100100b
-01100100b & 01101111b = 01100100b
-01100100b & 01110000b = 01100000b
-01100100b & 01110001b = 01100000b
-01100100b & 01110010b = 01100000b
-01100100b & 01110011b = 01100000b
-01100100b & 01110100b = 01100100b
-01100100b & 01110101b = 01100100b
-01100100b & 01110110b = 01100100b
-01100100b & 01110111b = 01100100b
-01100100b & 01111000b = 01100000b
-01100100b & 01111001b = 01100000b
-01100100b & 01111010b = 01100000b
-01100100b & 01111011b = 01100000b
-01100100b & 01111100b = 01100100b
-01100100b & 01111101b = 01100100b
-01100100b & 01111110b = 01100100b
-01100101b & 10000000b = 00000000b
-01100101b & 10000001b = 00000001b
-01100101b & 10000010b = 00000000b
-01100101b & 10000011b = 00000001b
-01100101b & 10000100b = 00000100b
-01100101b & 10000101b = 00000101b
-01100101b & 10000110b = 00000100b
-01100101b & 10000111b = 00000101b
-01100101b & 10001000b = 00000000b
-01100101b & 10001001b = 00000001b
-01100101b & 10001010b = 00000000b
-01100101b & 10001011b = 00000001b
-01100101b & 10001100b = 00000100b
-01100101b & 10001101b = 00000101b
-01100101b & 10001110b = 00000100b
-01100101b & 10001111b = 00000101b
-01100101b & 10010000b = 00000000b
-01100101b & 10010001b = 00000001b
-01100101b & 10010010b = 00000000b
-01100101b & 10010011b = 00000001b
-01100101b & 10010100b = 00000100b
-01100101b & 10010101b = 00000101b
-01100101b & 10010110b = 00000100b
-01100101b & 10010111b = 00000101b
-01100101b & 10011000b = 00000000b
-01100101b & 10011001b = 00000001b
-01100101b & 10011010b = 00000000b
-01100101b & 10011011b = 00000001b
-01100101b & 10011100b = 00000100b
-01100101b & 10011101b = 00000101b
-01100101b & 10011110b = 00000100b
-01100101b & 10011111b = 00000101b
-01100101b & 10100000b = 00100000b
-01100101b & 10100001b = 00100001b
-01100101b & 10100010b = 00100000b
-01100101b & 10100011b = 00100001b
-01100101b & 10100100b = 00100100b
-01100101b & 10100101b = 00100101b
-01100101b & 10100110b = 00100100b
-01100101b & 10100111b = 00100101b
-01100101b & 10101000b = 00100000b
-01100101b & 10101001b = 00100001b
-01100101b & 10101010b = 00100000b
-01100101b & 10101011b = 00100001b
-01100101b & 10101100b = 00100100b
-01100101b & 10101101b = 00100101b
-01100101b & 10101110b = 00100100b
-01100101b & 10101111b = 00100101b
-01100101b & 10110000b = 00100000b
-01100101b & 10110001b = 00100001b
-01100101b & 10110010b = 00100000b
-01100101b & 10110011b = 00100001b
-01100101b & 10110100b = 00100100b
-01100101b & 10110101b = 00100101b
-01100101b & 10110110b = 00100100b
-01100101b & 10110111b = 00100101b
-01100101b & 10111000b = 00100000b
-01100101b & 10111001b = 00100001b
-01100101b & 10111010b = 00100000b
-01100101b & 10111011b = 00100001b
-01100101b & 10111100b = 00100100b
-01100101b & 10111101b = 00100101b
-01100101b & 10111110b = 00100100b
-01100101b & 10111111b = 00100101b
-01100101b & 11000000b = 01000000b
-01100101b & 11000001b = 01000001b
-01100101b & 11000010b = 01000000b
-01100101b & 11000011b = 01000001b
-01100101b & 11000100b = 01000100b
-01100101b & 11000101b = 01000101b
-01100101b & 11000110b = 01000100b
-01100101b & 11000111b = 01000101b
-01100101b & 11001000b = 01000000b
-01100101b & 11001001b = 01000001b
-01100101b & 11001010b = 01000000b
-01100101b & 11001011b = 01000001b
-01100101b & 11001100b = 01000100b
-01100101b & 11001101b = 01000101b
-01100101b & 11001110b = 01000100b
-01100101b & 11001111b = 01000101b
-01100101b & 11010000b = 01000000b
-01100101b & 11010001b = 01000001b
-01100101b & 11010010b = 01000000b
-01100101b & 11010011b = 01000001b
-01100101b & 11010100b = 01000100b
-01100101b & 11010101b = 01000101b
-01100101b & 11010110b = 01000100b
-01100101b & 11010111b = 01000101b
-01100101b & 11011000b = 01000000b
-01100101b & 11011001b = 01000001b
-01100101b & 11011010b = 01000000b
-01100101b & 11011011b = 01000001b
-01100101b & 11011100b = 01000100b
-01100101b & 11011101b = 01000101b
-01100101b & 11011110b = 01000100b
-01100101b & 11011111b = 01000101b
-01100101b & 11100000b = 01100000b
-01100101b & 11100001b = 01100001b
-01100101b & 11100010b = 01100000b
-01100101b & 11100011b = 01100001b
-01100101b & 11100100b = 01100100b
-01100101b & 11100101b = 01100101b
-01100101b & 11100110b = 01100100b
-01100101b & 11100111b = 01100101b
-01100101b & 11101000b = 01100000b
-01100101b & 11101001b = 01100001b
-01100101b & 11101010b = 01100000b
-01100101b & 11101011b = 01100001b
-01100101b & 11101100b = 01100100b
-01100101b & 11101101b = 01100101b
-01100101b & 11101110b = 01100100b
-01100101b & 11101111b = 01100101b
-01100101b & 11110000b = 01100000b
-01100101b & 11110001b = 01100001b
-01100101b & 11110010b = 01100000b
-01100101b & 11110011b = 01100001b
-01100101b & 11110100b = 01100100b
-01100101b & 11110101b = 01100101b
-01100101b & 11110110b = 01100100b
-01100101b & 11110111b = 01100101b
-01100101b & 11111000b = 01100000b
-01100101b & 11111001b = 01100001b
-01100101b & 11111010b = 01100000b
-01100101b & 11111011b = 01100001b
-01100101b & 11111100b = 01100100b
-01100101b & 11111101b = 01100101b
-01100101b & 11111110b = 01100100b
-01100101b & 11111111b = 01100101b
-01100101b & 00000000b = 00000000b
-01100101b & 00000001b = 00000001b
-01100101b & 00000010b = 00000000b
-01100101b & 00000011b = 00000001b
-01100101b & 00000100b = 00000100b
-01100101b & 00000101b = 00000101b
-01100101b & 00000110b = 00000100b
-01100101b & 00000111b = 00000101b
-01100101b & 00001000b = 00000000b
-01100101b & 00001001b = 00000001b
-01100101b & 00001010b = 00000000b
-01100101b & 00001011b = 00000001b
-01100101b & 00001100b = 00000100b
-01100101b & 00001101b = 00000101b
-01100101b & 00001110b = 00000100b
-01100101b & 00001111b = 00000101b
-01100101b & 00010000b = 00000000b
-01100101b & 00010001b = 00000001b
-01100101b & 00010010b = 00000000b
-01100101b & 00010011b = 00000001b
-01100101b & 00010100b = 00000100b
-01100101b & 00010101b = 00000101b
-01100101b & 00010110b = 00000100b
-01100101b & 00010111b = 00000101b
-01100101b & 00011000b = 00000000b
-01100101b & 00011001b = 00000001b
-01100101b & 00011010b = 00000000b
-01100101b & 00011011b = 00000001b
-01100101b & 00011100b = 00000100b
-01100101b & 00011101b = 00000101b
-01100101b & 00011110b = 00000100b
-01100101b & 00011111b = 00000101b
-01100101b & 00100000b = 00100000b
-01100101b & 00100001b = 00100001b
-01100101b & 00100010b = 00100000b
-01100101b & 00100011b = 00100001b
-01100101b & 00100100b = 00100100b
-01100101b & 00100101b = 00100101b
-01100101b & 00100110b = 00100100b
-01100101b & 00100111b = 00100101b
-01100101b & 00101000b = 00100000b
-01100101b & 00101001b = 00100001b
-01100101b & 00101010b = 00100000b
-01100101b & 00101011b = 00100001b
-01100101b & 00101100b = 00100100b
-01100101b & 00101101b = 00100101b
-01100101b & 00101110b = 00100100b
-01100101b & 00101111b = 00100101b
-01100101b & 00110000b = 00100000b
-01100101b & 00110001b = 00100001b
-01100101b & 00110010b = 00100000b
-01100101b & 00110011b = 00100001b
-01100101b & 00110100b = 00100100b
-01100101b & 00110101b = 00100101b
-01100101b & 00110110b = 00100100b
-01100101b & 00110111b = 00100101b
-01100101b & 00111000b = 00100000b
-01100101b & 00111001b = 00100001b
-01100101b & 00111010b = 00100000b
-01100101b & 00111011b = 00100001b
-01100101b & 00111100b = 00100100b
-01100101b & 00111101b = 00100101b
-01100101b & 00111110b = 00100100b
-01100101b & 00111111b = 00100101b
-01100101b & 01000000b = 01000000b
-01100101b & 01000001b = 01000001b
-01100101b & 01000010b = 01000000b
-01100101b & 01000011b = 01000001b
-01100101b & 01000100b = 01000100b
-01100101b & 01000101b = 01000101b
-01100101b & 01000110b = 01000100b
-01100101b & 01000111b = 01000101b
-01100101b & 01001000b = 01000000b
-01100101b & 01001001b = 01000001b
-01100101b & 01001010b = 01000000b
-01100101b & 01001011b = 01000001b
-01100101b & 01001100b = 01000100b
-01100101b & 01001101b = 01000101b
-01100101b & 01001110b = 01000100b
-01100101b & 01001111b = 01000101b
-01100101b & 01010000b = 01000000b
-01100101b & 01010001b = 01000001b
-01100101b & 01010010b = 01000000b
-01100101b & 01010011b = 01000001b
-01100101b & 01010100b = 01000100b
-01100101b & 01010101b = 01000101b
-01100101b & 01010110b = 01000100b
-01100101b & 01010111b = 01000101b
-01100101b & 01011000b = 01000000b
-01100101b & 01011001b = 01000001b
-01100101b & 01011010b = 01000000b
-01100101b & 01011011b = 01000001b
-01100101b & 01011100b = 01000100b
-01100101b & 01011101b = 01000101b
-01100101b & 01011110b = 01000100b
-01100101b & 01011111b = 01000101b
-01100101b & 01100000b = 01100000b
-01100101b & 01100001b = 01100001b
-01100101b & 01100010b = 01100000b
-01100101b & 01100011b = 01100001b
-01100101b & 01100100b = 01100100b
-01100101b & 01100101b = 01100101b
-01100101b & 01100110b = 01100100b
-01100101b & 01100111b = 01100101b
-01100101b & 01101000b = 01100000b
-01100101b & 01101001b = 01100001b
-01100101b & 01101010b = 01100000b
-01100101b & 01101011b = 01100001b
-01100101b & 01101100b = 01100100b
-01100101b & 01101101b = 01100101b
-01100101b & 01101110b = 01100100b
-01100101b & 01101111b = 01100101b
-01100101b & 01110000b = 01100000b
-01100101b & 01110001b = 01100001b
-01100101b & 01110010b = 01100000b
-01100101b & 01110011b = 01100001b
-01100101b & 01110100b = 01100100b
-01100101b & 01110101b = 01100101b
-01100101b & 01110110b = 01100100b
-01100101b & 01110111b = 01100101b
-01100101b & 01111000b = 01100000b
-01100101b & 01111001b = 01100001b
-01100101b & 01111010b = 01100000b
-01100101b & 01111011b = 01100001b
-01100101b & 01111100b = 01100100b
-01100101b & 01111101b = 01100101b
-01100101b & 01111110b = 01100100b
-01100110b & 10000000b = 00000000b
-01100110b & 10000001b = 00000000b
-01100110b & 10000010b = 00000010b
-01100110b & 10000011b = 00000010b
-01100110b & 10000100b = 00000100b
-01100110b & 10000101b = 00000100b
-01100110b & 10000110b = 00000110b
-01100110b & 10000111b = 00000110b
-01100110b & 10001000b = 00000000b
-01100110b & 10001001b = 00000000b
-01100110b & 10001010b = 00000010b
-01100110b & 10001011b = 00000010b
-01100110b & 10001100b = 00000100b
-01100110b & 10001101b = 00000100b
-01100110b & 10001110b = 00000110b
-01100110b & 10001111b = 00000110b
-01100110b & 10010000b = 00000000b
-01100110b & 10010001b = 00000000b
-01100110b & 10010010b = 00000010b
-01100110b & 10010011b = 00000010b
-01100110b & 10010100b = 00000100b
-01100110b & 10010101b = 00000100b
-01100110b & 10010110b = 00000110b
-01100110b & 10010111b = 00000110b
-01100110b & 10011000b = 00000000b
-01100110b & 10011001b = 00000000b
-01100110b & 10011010b = 00000010b
-01100110b & 10011011b = 00000010b
-01100110b & 10011100b = 00000100b
-01100110b & 10011101b = 00000100b
-01100110b & 10011110b = 00000110b
-01100110b & 10011111b = 00000110b
-01100110b & 10100000b = 00100000b
-01100110b & 10100001b = 00100000b
-01100110b & 10100010b = 00100010b
-01100110b & 10100011b = 00100010b
-01100110b & 10100100b = 00100100b
-01100110b & 10100101b = 00100100b
-01100110b & 10100110b = 00100110b
-01100110b & 10100111b = 00100110b
-01100110b & 10101000b = 00100000b
-01100110b & 10101001b = 00100000b
-01100110b & 10101010b = 00100010b
-01100110b & 10101011b = 00100010b
-01100110b & 10101100b = 00100100b
-01100110b & 10101101b = 00100100b
-01100110b & 10101110b = 00100110b
-01100110b & 10101111b = 00100110b
-01100110b & 10110000b = 00100000b
-01100110b & 10110001b = 00100000b
-01100110b & 10110010b = 00100010b
-01100110b & 10110011b = 00100010b
-01100110b & 10110100b = 00100100b
-01100110b & 10110101b = 00100100b
-01100110b & 10110110b = 00100110b
-01100110b & 10110111b = 00100110b
-01100110b & 10111000b = 00100000b
-01100110b & 10111001b = 00100000b
-01100110b & 10111010b = 00100010b
-01100110b & 10111011b = 00100010b
-01100110b & 10111100b = 00100100b
-01100110b & 10111101b = 00100100b
-01100110b & 10111110b = 00100110b
-01100110b & 10111111b = 00100110b
-01100110b & 11000000b = 01000000b
-01100110b & 11000001b = 01000000b
-01100110b & 11000010b = 01000010b
-01100110b & 11000011b = 01000010b
-01100110b & 11000100b = 01000100b
-01100110b & 11000101b = 01000100b
-01100110b & 11000110b = 01000110b
-01100110b & 11000111b = 01000110b
-01100110b & 11001000b = 01000000b
-01100110b & 11001001b = 01000000b
-01100110b & 11001010b = 01000010b
-01100110b & 11001011b = 01000010b
-01100110b & 11001100b = 01000100b
-01100110b & 11001101b = 01000100b
-01100110b & 11001110b = 01000110b
-01100110b & 11001111b = 01000110b
-01100110b & 11010000b = 01000000b
-01100110b & 11010001b = 01000000b
-01100110b & 11010010b = 01000010b
-01100110b & 11010011b = 01000010b
-01100110b & 11010100b = 01000100b
-01100110b & 11010101b = 01000100b
-01100110b & 11010110b = 01000110b
-01100110b & 11010111b = 01000110b
-01100110b & 11011000b = 01000000b
-01100110b & 11011001b = 01000000b
-01100110b & 11011010b = 01000010b
-01100110b & 11011011b = 01000010b
-01100110b & 11011100b = 01000100b
-01100110b & 11011101b = 01000100b
-01100110b & 11011110b = 01000110b
-01100110b & 11011111b = 01000110b
-01100110b & 11100000b = 01100000b
-01100110b & 11100001b = 01100000b
-01100110b & 11100010b = 01100010b
-01100110b & 11100011b = 01100010b
-01100110b & 11100100b = 01100100b
-01100110b & 11100101b = 01100100b
-01100110b & 11100110b = 01100110b
-01100110b & 11100111b = 01100110b
-01100110b & 11101000b = 01100000b
-01100110b & 11101001b = 01100000b
-01100110b & 11101010b = 01100010b
-01100110b & 11101011b = 01100010b
-01100110b & 11101100b = 01100100b
-01100110b & 11101101b = 01100100b
-01100110b & 11101110b = 01100110b
-01100110b & 11101111b = 01100110b
-01100110b & 11110000b = 01100000b
-01100110b & 11110001b = 01100000b
-01100110b & 11110010b = 01100010b
-01100110b & 11110011b = 01100010b
-01100110b & 11110100b = 01100100b
-01100110b & 11110101b = 01100100b
-01100110b & 11110110b = 01100110b
-01100110b & 11110111b = 01100110b
-01100110b & 11111000b = 01100000b
-01100110b & 11111001b = 01100000b
-01100110b & 11111010b = 01100010b
-01100110b & 11111011b = 01100010b
-01100110b & 11111100b = 01100100b
-01100110b & 11111101b = 01100100b
-01100110b & 11111110b = 01100110b
-01100110b & 11111111b = 01100110b
-01100110b & 00000000b = 00000000b
-01100110b & 00000001b = 00000000b
-01100110b & 00000010b = 00000010b
-01100110b & 00000011b = 00000010b
-01100110b & 00000100b = 00000100b
-01100110b & 00000101b = 00000100b
-01100110b & 00000110b = 00000110b
-01100110b & 00000111b = 00000110b
-01100110b & 00001000b = 00000000b
-01100110b & 00001001b = 00000000b
-01100110b & 00001010b = 00000010b
-01100110b & 00001011b = 00000010b
-01100110b & 00001100b = 00000100b
-01100110b & 00001101b = 00000100b
-01100110b & 00001110b = 00000110b
-01100110b & 00001111b = 00000110b
-01100110b & 00010000b = 00000000b
-01100110b & 00010001b = 00000000b
-01100110b & 00010010b = 00000010b
-01100110b & 00010011b = 00000010b
-01100110b & 00010100b = 00000100b
-01100110b & 00010101b = 00000100b
-01100110b & 00010110b = 00000110b
-01100110b & 00010111b = 00000110b
-01100110b & 00011000b = 00000000b
-01100110b & 00011001b = 00000000b
-01100110b & 00011010b = 00000010b
-01100110b & 00011011b = 00000010b
-01100110b & 00011100b = 00000100b
-01100110b & 00011101b = 00000100b
-01100110b & 00011110b = 00000110b
-01100110b & 00011111b = 00000110b
-01100110b & 00100000b = 00100000b
-01100110b & 00100001b = 00100000b
-01100110b & 00100010b = 00100010b
-01100110b & 00100011b = 00100010b
-01100110b & 00100100b = 00100100b
-01100110b & 00100101b = 00100100b
-01100110b & 00100110b = 00100110b
-01100110b & 00100111b = 00100110b
-01100110b & 00101000b = 00100000b
-01100110b & 00101001b = 00100000b
-01100110b & 00101010b = 00100010b
-01100110b & 00101011b = 00100010b
-01100110b & 00101100b = 00100100b
-01100110b & 00101101b = 00100100b
-01100110b & 00101110b = 00100110b
-01100110b & 00101111b = 00100110b
-01100110b & 00110000b = 00100000b
-01100110b & 00110001b = 00100000b
-01100110b & 00110010b = 00100010b
-01100110b & 00110011b = 00100010b
-01100110b & 00110100b = 00100100b
-01100110b & 00110101b = 00100100b
-01100110b & 00110110b = 00100110b
-01100110b & 00110111b = 00100110b
-01100110b & 00111000b = 00100000b
-01100110b & 00111001b = 00100000b
-01100110b & 00111010b = 00100010b
-01100110b & 00111011b = 00100010b
-01100110b & 00111100b = 00100100b
-01100110b & 00111101b = 00100100b
-01100110b & 00111110b = 00100110b
-01100110b & 00111111b = 00100110b
-01100110b & 01000000b = 01000000b
-01100110b & 01000001b = 01000000b
-01100110b & 01000010b = 01000010b
-01100110b & 01000011b = 01000010b
-01100110b & 01000100b = 01000100b
-01100110b & 01000101b = 01000100b
-01100110b & 01000110b = 01000110b
-01100110b & 01000111b = 01000110b
-01100110b & 01001000b = 01000000b
-01100110b & 01001001b = 01000000b
-01100110b & 01001010b = 01000010b
-01100110b & 01001011b = 01000010b
-01100110b & 01001100b = 01000100b
-01100110b & 01001101b = 01000100b
-01100110b & 01001110b = 01000110b
-01100110b & 01001111b = 01000110b
-01100110b & 01010000b = 01000000b
-01100110b & 01010001b = 01000000b
-01100110b & 01010010b = 01000010b
-01100110b & 01010011b = 01000010b
-01100110b & 01010100b = 01000100b
-01100110b & 01010101b = 01000100b
-01100110b & 01010110b = 01000110b
-01100110b & 01010111b = 01000110b
-01100110b & 01011000b = 01000000b
-01100110b & 01011001b = 01000000b
-01100110b & 01011010b = 01000010b
-01100110b & 01011011b = 01000010b
-01100110b & 01011100b = 01000100b
-01100110b & 01011101b = 01000100b
-01100110b & 01011110b = 01000110b
-01100110b & 01011111b = 01000110b
-01100110b & 01100000b = 01100000b
-01100110b & 01100001b = 01100000b
-01100110b & 01100010b = 01100010b
-01100110b & 01100011b = 01100010b
-01100110b & 01100100b = 01100100b
-01100110b & 01100101b = 01100100b
-01100110b & 01100110b = 01100110b
-01100110b & 01100111b = 01100110b
-01100110b & 01101000b = 01100000b
-01100110b & 01101001b = 01100000b
-01100110b & 01101010b = 01100010b
-01100110b & 01101011b = 01100010b
-01100110b & 01101100b = 01100100b
-01100110b & 01101101b = 01100100b
-01100110b & 01101110b = 01100110b
-01100110b & 01101111b = 01100110b
-01100110b & 01110000b = 01100000b
-01100110b & 01110001b = 01100000b
-01100110b & 01110010b = 01100010b
-01100110b & 01110011b = 01100010b
-01100110b & 01110100b = 01100100b
-01100110b & 01110101b = 01100100b
-01100110b & 01110110b = 01100110b
-01100110b & 01110111b = 01100110b
-01100110b & 01111000b = 01100000b
-01100110b & 01111001b = 01100000b
-01100110b & 01111010b = 01100010b
-01100110b & 01111011b = 01100010b
-01100110b & 01111100b = 01100100b
-01100110b & 01111101b = 01100100b
-01100110b & 01111110b = 01100110b
-01100111b & 10000000b = 00000000b
-01100111b & 10000001b = 00000001b
-01100111b & 10000010b = 00000010b
-01100111b & 10000011b = 00000011b
-01100111b & 10000100b = 00000100b
-01100111b & 10000101b = 00000101b
-01100111b & 10000110b = 00000110b
-01100111b & 10000111b = 00000111b
-01100111b & 10001000b = 00000000b
-01100111b & 10001001b = 00000001b
-01100111b & 10001010b = 00000010b
-01100111b & 10001011b = 00000011b
-01100111b & 10001100b = 00000100b
-01100111b & 10001101b = 00000101b
-01100111b & 10001110b = 00000110b
-01100111b & 10001111b = 00000111b
-01100111b & 10010000b = 00000000b
-01100111b & 10010001b = 00000001b
-01100111b & 10010010b = 00000010b
-01100111b & 10010011b = 00000011b
-01100111b & 10010100b = 00000100b
-01100111b & 10010101b = 00000101b
-01100111b & 10010110b = 00000110b
-01100111b & 10010111b = 00000111b
-01100111b & 10011000b = 00000000b
-01100111b & 10011001b = 00000001b
-01100111b & 10011010b = 00000010b
-01100111b & 10011011b = 00000011b
-01100111b & 10011100b = 00000100b
-01100111b & 10011101b = 00000101b
-01100111b & 10011110b = 00000110b
-01100111b & 10011111b = 00000111b
-01100111b & 10100000b = 00100000b
-01100111b & 10100001b = 00100001b
-01100111b & 10100010b = 00100010b
-01100111b & 10100011b = 00100011b
-01100111b & 10100100b = 00100100b
-01100111b & 10100101b = 00100101b
-01100111b & 10100110b = 00100110b
-01100111b & 10100111b = 00100111b
-01100111b & 10101000b = 00100000b
-01100111b & 10101001b = 00100001b
-01100111b & 10101010b = 00100010b
-01100111b & 10101011b = 00100011b
-01100111b & 10101100b = 00100100b
-01100111b & 10101101b = 00100101b
-01100111b & 10101110b = 00100110b
-01100111b & 10101111b = 00100111b
-01100111b & 10110000b = 00100000b
-01100111b & 10110001b = 00100001b
-01100111b & 10110010b = 00100010b
-01100111b & 10110011b = 00100011b
-01100111b & 10110100b = 00100100b
-01100111b & 10110101b = 00100101b
-01100111b & 10110110b = 00100110b
-01100111b & 10110111b = 00100111b
-01100111b & 10111000b = 00100000b
-01100111b & 10111001b = 00100001b
-01100111b & 10111010b = 00100010b
-01100111b & 10111011b = 00100011b
-01100111b & 10111100b = 00100100b
-01100111b & 10111101b = 00100101b
-01100111b & 10111110b = 00100110b
-01100111b & 10111111b = 00100111b
-01100111b & 11000000b = 01000000b
-01100111b & 11000001b = 01000001b
-01100111b & 11000010b = 01000010b
-01100111b & 11000011b = 01000011b
-01100111b & 11000100b = 01000100b
-01100111b & 11000101b = 01000101b
-01100111b & 11000110b = 01000110b
-01100111b & 11000111b = 01000111b
-01100111b & 11001000b = 01000000b
-01100111b & 11001001b = 01000001b
-01100111b & 11001010b = 01000010b
-01100111b & 11001011b = 01000011b
-01100111b & 11001100b = 01000100b
-01100111b & 11001101b = 01000101b
-01100111b & 11001110b = 01000110b
-01100111b & 11001111b = 01000111b
-01100111b & 11010000b = 01000000b
-01100111b & 11010001b = 01000001b
-01100111b & 11010010b = 01000010b
-01100111b & 11010011b = 01000011b
-01100111b & 11010100b = 01000100b
-01100111b & 11010101b = 01000101b
-01100111b & 11010110b = 01000110b
-01100111b & 11010111b = 01000111b
-01100111b & 11011000b = 01000000b
-01100111b & 11011001b = 01000001b
-01100111b & 11011010b = 01000010b
-01100111b & 11011011b = 01000011b
-01100111b & 11011100b = 01000100b
-01100111b & 11011101b = 01000101b
-01100111b & 11011110b = 01000110b
-01100111b & 11011111b = 01000111b
-01100111b & 11100000b = 01100000b
-01100111b & 11100001b = 01100001b
-01100111b & 11100010b = 01100010b
-01100111b & 11100011b = 01100011b
-01100111b & 11100100b = 01100100b
-01100111b & 11100101b = 01100101b
-01100111b & 11100110b = 01100110b
-01100111b & 11100111b = 01100111b
-01100111b & 11101000b = 01100000b
-01100111b & 11101001b = 01100001b
-01100111b & 11101010b = 01100010b
-01100111b & 11101011b = 01100011b
-01100111b & 11101100b = 01100100b
-01100111b & 11101101b = 01100101b
-01100111b & 11101110b = 01100110b
-01100111b & 11101111b = 01100111b
-01100111b & 11110000b = 01100000b
-01100111b & 11110001b = 01100001b
-01100111b & 11110010b = 01100010b
-01100111b & 11110011b = 01100011b
-01100111b & 11110100b = 01100100b
-01100111b & 11110101b = 01100101b
-01100111b & 11110110b = 01100110b
-01100111b & 11110111b = 01100111b
-01100111b & 11111000b = 01100000b
-01100111b & 11111001b = 01100001b
-01100111b & 11111010b = 01100010b
-01100111b & 11111011b = 01100011b
-01100111b & 11111100b = 01100100b
-01100111b & 11111101b = 01100101b
-01100111b & 11111110b = 01100110b
-01100111b & 11111111b = 01100111b
-01100111b & 00000000b = 00000000b
-01100111b & 00000001b = 00000001b
-01100111b & 00000010b = 00000010b
-01100111b & 00000011b = 00000011b
-01100111b & 00000100b = 00000100b
-01100111b & 00000101b = 00000101b
-01100111b & 00000110b = 00000110b
-01100111b & 00000111b = 00000111b
-01100111b & 00001000b = 00000000b
-01100111b & 00001001b = 00000001b
-01100111b & 00001010b = 00000010b
-01100111b & 00001011b = 00000011b
-01100111b & 00001100b = 00000100b
-01100111b & 00001101b = 00000101b
-01100111b & 00001110b = 00000110b
-01100111b & 00001111b = 00000111b
-01100111b & 00010000b = 00000000b
-01100111b & 00010001b = 00000001b
-01100111b & 00010010b = 00000010b
-01100111b & 00010011b = 00000011b
-01100111b & 00010100b = 00000100b
-01100111b & 00010101b = 00000101b
-01100111b & 00010110b = 00000110b
-01100111b & 00010111b = 00000111b
-01100111b & 00011000b = 00000000b
-01100111b & 00011001b = 00000001b
-01100111b & 00011010b = 00000010b
-01100111b & 00011011b = 00000011b
-01100111b & 00011100b = 00000100b
-01100111b & 00011101b = 00000101b
-01100111b & 00011110b = 00000110b
-01100111b & 00011111b = 00000111b
-01100111b & 00100000b = 00100000b
-01100111b & 00100001b = 00100001b
-01100111b & 00100010b = 00100010b
-01100111b & 00100011b = 00100011b
-01100111b & 00100100b = 00100100b
-01100111b & 00100101b = 00100101b
-01100111b & 00100110b = 00100110b
-01100111b & 00100111b = 00100111b
-01100111b & 00101000b = 00100000b
-01100111b & 00101001b = 00100001b
-01100111b & 00101010b = 00100010b
-01100111b & 00101011b = 00100011b
-01100111b & 00101100b = 00100100b
-01100111b & 00101101b = 00100101b
-01100111b & 00101110b = 00100110b
-01100111b & 00101111b = 00100111b
-01100111b & 00110000b = 00100000b
-01100111b & 00110001b = 00100001b
-01100111b & 00110010b = 00100010b
-01100111b & 00110011b = 00100011b
-01100111b & 00110100b = 00100100b
-01100111b & 00110101b = 00100101b
-01100111b & 00110110b = 00100110b
-01100111b & 00110111b = 00100111b
-01100111b & 00111000b = 00100000b
-01100111b & 00111001b = 00100001b
-01100111b & 00111010b = 00100010b
-01100111b & 00111011b = 00100011b
-01100111b & 00111100b = 00100100b
-01100111b & 00111101b = 00100101b
-01100111b & 00111110b = 00100110b
-01100111b & 00111111b = 00100111b
-01100111b & 01000000b = 01000000b
-01100111b & 01000001b = 01000001b
-01100111b & 01000010b = 01000010b
-01100111b & 01000011b = 01000011b
-01100111b & 01000100b = 01000100b
-01100111b & 01000101b = 01000101b
-01100111b & 01000110b = 01000110b
-01100111b & 01000111b = 01000111b
-01100111b & 01001000b = 01000000b
-01100111b & 01001001b = 01000001b
-01100111b & 01001010b = 01000010b
-01100111b & 01001011b = 01000011b
-01100111b & 01001100b = 01000100b
-01100111b & 01001101b = 01000101b
-01100111b & 01001110b = 01000110b
-01100111b & 01001111b = 01000111b
-01100111b & 01010000b = 01000000b
-01100111b & 01010001b = 01000001b
-01100111b & 01010010b = 01000010b
-01100111b & 01010011b = 01000011b
-01100111b & 01010100b = 01000100b
-01100111b & 01010101b = 01000101b
-01100111b & 01010110b = 01000110b
-01100111b & 01010111b = 01000111b
-01100111b & 01011000b = 01000000b
-01100111b & 01011001b = 01000001b
-01100111b & 01011010b = 01000010b
-01100111b & 01011011b = 01000011b
-01100111b & 01011100b = 01000100b
-01100111b & 01011101b = 01000101b
-01100111b & 01011110b = 01000110b
-01100111b & 01011111b = 01000111b
-01100111b & 01100000b = 01100000b
-01100111b & 01100001b = 01100001b
-01100111b & 01100010b = 01100010b
-01100111b & 01100011b = 01100011b
-01100111b & 01100100b = 01100100b
-01100111b & 01100101b = 01100101b
-01100111b & 01100110b = 01100110b
-01100111b & 01100111b = 01100111b
-01100111b & 01101000b = 01100000b
-01100111b & 01101001b = 01100001b
-01100111b & 01101010b = 01100010b
-01100111b & 01101011b = 01100011b
-01100111b & 01101100b = 01100100b
-01100111b & 01101101b = 01100101b
-01100111b & 01101110b = 01100110b
-01100111b & 01101111b = 01100111b
-01100111b & 01110000b = 01100000b
-01100111b & 01110001b = 01100001b
-01100111b & 01110010b = 01100010b
-01100111b & 01110011b = 01100011b
-01100111b & 01110100b = 01100100b
-01100111b & 01110101b = 01100101b
-01100111b & 01110110b = 01100110b
-01100111b & 01110111b = 01100111b
-01100111b & 01111000b = 01100000b
-01100111b & 01111001b = 01100001b
-01100111b & 01111010b = 01100010b
-01100111b & 01111011b = 01100011b
-01100111b & 01111100b = 01100100b
-01100111b & 01111101b = 01100101b
-01100111b & 01111110b = 01100110b
-01101000b & 10000000b = 00000000b
-01101000b & 10000001b = 00000000b
-01101000b & 10000010b = 00000000b
-01101000b & 10000011b = 00000000b
-01101000b & 10000100b = 00000000b
-01101000b & 10000101b = 00000000b
-01101000b & 10000110b = 00000000b
-01101000b & 10000111b = 00000000b
-01101000b & 10001000b = 00001000b
-01101000b & 10001001b = 00001000b
-01101000b & 10001010b = 00001000b
-01101000b & 10001011b = 00001000b
-01101000b & 10001100b = 00001000b
-01101000b & 10001101b = 00001000b
-01101000b & 10001110b = 00001000b
-01101000b & 10001111b = 00001000b
-01101000b & 10010000b = 00000000b
-01101000b & 10010001b = 00000000b
-01101000b & 10010010b = 00000000b
-01101000b & 10010011b = 00000000b
-01101000b & 10010100b = 00000000b
-01101000b & 10010101b = 00000000b
-01101000b & 10010110b = 00000000b
-01101000b & 10010111b = 00000000b
-01101000b & 10011000b = 00001000b
-01101000b & 10011001b = 00001000b
-01101000b & 10011010b = 00001000b
-01101000b & 10011011b = 00001000b
-01101000b & 10011100b = 00001000b
-01101000b & 10011101b = 00001000b
-01101000b & 10011110b = 00001000b
-01101000b & 10011111b = 00001000b
-01101000b & 10100000b = 00100000b
-01101000b & 10100001b = 00100000b
-01101000b & 10100010b = 00100000b
-01101000b & 10100011b = 00100000b
-01101000b & 10100100b = 00100000b
-01101000b & 10100101b = 00100000b
-01101000b & 10100110b = 00100000b
-01101000b & 10100111b = 00100000b
-01101000b & 10101000b = 00101000b
-01101000b & 10101001b = 00101000b
-01101000b & 10101010b = 00101000b
-01101000b & 10101011b = 00101000b
-01101000b & 10101100b = 00101000b
-01101000b & 10101101b = 00101000b
-01101000b & 10101110b = 00101000b
-01101000b & 10101111b = 00101000b
-01101000b & 10110000b = 00100000b
-01101000b & 10110001b = 00100000b
-01101000b & 10110010b = 00100000b
-01101000b & 10110011b = 00100000b
-01101000b & 10110100b = 00100000b
-01101000b & 10110101b = 00100000b
-01101000b & 10110110b = 00100000b
-01101000b & 10110111b = 00100000b
-01101000b & 10111000b = 00101000b
-01101000b & 10111001b = 00101000b
-01101000b & 10111010b = 00101000b
-01101000b & 10111011b = 00101000b
-01101000b & 10111100b = 00101000b
-01101000b & 10111101b = 00101000b
-01101000b & 10111110b = 00101000b
-01101000b & 10111111b = 00101000b
-01101000b & 11000000b = 01000000b
-01101000b & 11000001b = 01000000b
-01101000b & 11000010b = 01000000b
-01101000b & 11000011b = 01000000b
-01101000b & 11000100b = 01000000b
-01101000b & 11000101b = 01000000b
-01101000b & 11000110b = 01000000b
-01101000b & 11000111b = 01000000b
-01101000b & 11001000b = 01001000b
-01101000b & 11001001b = 01001000b
-01101000b & 11001010b = 01001000b
-01101000b & 11001011b = 01001000b
-01101000b & 11001100b = 01001000b
-01101000b & 11001101b = 01001000b
-01101000b & 11001110b = 01001000b
-01101000b & 11001111b = 01001000b
-01101000b & 11010000b = 01000000b
-01101000b & 11010001b = 01000000b
-01101000b & 11010010b = 01000000b
-01101000b & 11010011b = 01000000b
-01101000b & 11010100b = 01000000b
-01101000b & 11010101b = 01000000b
-01101000b & 11010110b = 01000000b
-01101000b & 11010111b = 01000000b
-01101000b & 11011000b = 01001000b
-01101000b & 11011001b = 01001000b
-01101000b & 11011010b = 01001000b
-01101000b & 11011011b = 01001000b
-01101000b & 11011100b = 01001000b
-01101000b & 11011101b = 01001000b
-01101000b & 11011110b = 01001000b
-01101000b & 11011111b = 01001000b
-01101000b & 11100000b = 01100000b
-01101000b & 11100001b = 01100000b
-01101000b & 11100010b = 01100000b
-01101000b & 11100011b = 01100000b
-01101000b & 11100100b = 01100000b
-01101000b & 11100101b = 01100000b
-01101000b & 11100110b = 01100000b
-01101000b & 11100111b = 01100000b
-01101000b & 11101000b = 01101000b
-01101000b & 11101001b = 01101000b
-01101000b & 11101010b = 01101000b
-01101000b & 11101011b = 01101000b
-01101000b & 11101100b = 01101000b
-01101000b & 11101101b = 01101000b
-01101000b & 11101110b = 01101000b
-01101000b & 11101111b = 01101000b
-01101000b & 11110000b = 01100000b
-01101000b & 11110001b = 01100000b
-01101000b & 11110010b = 01100000b
-01101000b & 11110011b = 01100000b
-01101000b & 11110100b = 01100000b
-01101000b & 11110101b = 01100000b
-01101000b & 11110110b = 01100000b
-01101000b & 11110111b = 01100000b
-01101000b & 11111000b = 01101000b
-01101000b & 11111001b = 01101000b
-01101000b & 11111010b = 01101000b
-01101000b & 11111011b = 01101000b
-01101000b & 11111100b = 01101000b
-01101000b & 11111101b = 01101000b
-01101000b & 11111110b = 01101000b
-01101000b & 11111111b = 01101000b
-01101000b & 00000000b = 00000000b
-01101000b & 00000001b = 00000000b
-01101000b & 00000010b = 00000000b
-01101000b & 00000011b = 00000000b
-01101000b & 00000100b = 00000000b
-01101000b & 00000101b = 00000000b
-01101000b & 00000110b = 00000000b
-01101000b & 00000111b = 00000000b
-01101000b & 00001000b = 00001000b
-01101000b & 00001001b = 00001000b
-01101000b & 00001010b = 00001000b
-01101000b & 00001011b = 00001000b
-01101000b & 00001100b = 00001000b
-01101000b & 00001101b = 00001000b
-01101000b & 00001110b = 00001000b
-01101000b & 00001111b = 00001000b
-01101000b & 00010000b = 00000000b
-01101000b & 00010001b = 00000000b
-01101000b & 00010010b = 00000000b
-01101000b & 00010011b = 00000000b
-01101000b & 00010100b = 00000000b
-01101000b & 00010101b = 00000000b
-01101000b & 00010110b = 00000000b
-01101000b & 00010111b = 00000000b
-01101000b & 00011000b = 00001000b
-01101000b & 00011001b = 00001000b
-01101000b & 00011010b = 00001000b
-01101000b & 00011011b = 00001000b
-01101000b & 00011100b = 00001000b
-01101000b & 00011101b = 00001000b
-01101000b & 00011110b = 00001000b
-01101000b & 00011111b = 00001000b
-01101000b & 00100000b = 00100000b
-01101000b & 00100001b = 00100000b
-01101000b & 00100010b = 00100000b
-01101000b & 00100011b = 00100000b
-01101000b & 00100100b = 00100000b
-01101000b & 00100101b = 00100000b
-01101000b & 00100110b = 00100000b
-01101000b & 00100111b = 00100000b
-01101000b & 00101000b = 00101000b
-01101000b & 00101001b = 00101000b
-01101000b & 00101010b = 00101000b
-01101000b & 00101011b = 00101000b
-01101000b & 00101100b = 00101000b
-01101000b & 00101101b = 00101000b
-01101000b & 00101110b = 00101000b
-01101000b & 00101111b = 00101000b
-01101000b & 00110000b = 00100000b
-01101000b & 00110001b = 00100000b
-01101000b & 00110010b = 00100000b
-01101000b & 00110011b = 00100000b
-01101000b & 00110100b = 00100000b
-01101000b & 00110101b = 00100000b
-01101000b & 00110110b = 00100000b
-01101000b & 00110111b = 00100000b
-01101000b & 00111000b = 00101000b
-01101000b & 00111001b = 00101000b
-01101000b & 00111010b = 00101000b
-01101000b & 00111011b = 00101000b
-01101000b & 00111100b = 00101000b
-01101000b & 00111101b = 00101000b
-01101000b & 00111110b = 00101000b
-01101000b & 00111111b = 00101000b
-01101000b & 01000000b = 01000000b
-01101000b & 01000001b = 01000000b
-01101000b & 01000010b = 01000000b
-01101000b & 01000011b = 01000000b
-01101000b & 01000100b = 01000000b
-01101000b & 01000101b = 01000000b
-01101000b & 01000110b = 01000000b
-01101000b & 01000111b = 01000000b
-01101000b & 01001000b = 01001000b
-01101000b & 01001001b = 01001000b
-01101000b & 01001010b = 01001000b
-01101000b & 01001011b = 01001000b
-01101000b & 01001100b = 01001000b
-01101000b & 01001101b = 01001000b
-01101000b & 01001110b = 01001000b
-01101000b & 01001111b = 01001000b
-01101000b & 01010000b = 01000000b
-01101000b & 01010001b = 01000000b
-01101000b & 01010010b = 01000000b
-01101000b & 01010011b = 01000000b
-01101000b & 01010100b = 01000000b
-01101000b & 01010101b = 01000000b
-01101000b & 01010110b = 01000000b
-01101000b & 01010111b = 01000000b
-01101000b & 01011000b = 01001000b
-01101000b & 01011001b = 01001000b
-01101000b & 01011010b = 01001000b
-01101000b & 01011011b = 01001000b
-01101000b & 01011100b = 01001000b
-01101000b & 01011101b = 01001000b
-01101000b & 01011110b = 01001000b
-01101000b & 01011111b = 01001000b
-01101000b & 01100000b = 01100000b
-01101000b & 01100001b = 01100000b
-01101000b & 01100010b = 01100000b
-01101000b & 01100011b = 01100000b
-01101000b & 01100100b = 01100000b
-01101000b & 01100101b = 01100000b
-01101000b & 01100110b = 01100000b
-01101000b & 01100111b = 01100000b
-01101000b & 01101000b = 01101000b
-01101000b & 01101001b = 01101000b
-01101000b & 01101010b = 01101000b
-01101000b & 01101011b = 01101000b
-01101000b & 01101100b = 01101000b
-01101000b & 01101101b = 01101000b
-01101000b & 01101110b = 01101000b
-01101000b & 01101111b = 01101000b
-01101000b & 01110000b = 01100000b
-01101000b & 01110001b = 01100000b
-01101000b & 01110010b = 01100000b
-01101000b & 01110011b = 01100000b
-01101000b & 01110100b = 01100000b
-01101000b & 01110101b = 01100000b
-01101000b & 01110110b = 01100000b
-01101000b & 01110111b = 01100000b
-01101000b & 01111000b = 01101000b
-01101000b & 01111001b = 01101000b
-01101000b & 01111010b = 01101000b
-01101000b & 01111011b = 01101000b
-01101000b & 01111100b = 01101000b
-01101000b & 01111101b = 01101000b
-01101000b & 01111110b = 01101000b
-01101001b & 10000000b = 00000000b
-01101001b & 10000001b = 00000001b
-01101001b & 10000010b = 00000000b
-01101001b & 10000011b = 00000001b
-01101001b & 10000100b = 00000000b
-01101001b & 10000101b = 00000001b
-01101001b & 10000110b = 00000000b
-01101001b & 10000111b = 00000001b
-01101001b & 10001000b = 00001000b
-01101001b & 10001001b = 00001001b
-01101001b & 10001010b = 00001000b
-01101001b & 10001011b = 00001001b
-01101001b & 10001100b = 00001000b
-01101001b & 10001101b = 00001001b
-01101001b & 10001110b = 00001000b
-01101001b & 10001111b = 00001001b
-01101001b & 10010000b = 00000000b
-01101001b & 10010001b = 00000001b
-01101001b & 10010010b = 00000000b
-01101001b & 10010011b = 00000001b
-01101001b & 10010100b = 00000000b
-01101001b & 10010101b = 00000001b
-01101001b & 10010110b = 00000000b
-01101001b & 10010111b = 00000001b
-01101001b & 10011000b = 00001000b
-01101001b & 10011001b = 00001001b
-01101001b & 10011010b = 00001000b
-01101001b & 10011011b = 00001001b
-01101001b & 10011100b = 00001000b
-01101001b & 10011101b = 00001001b
-01101001b & 10011110b = 00001000b
-01101001b & 10011111b = 00001001b
-01101001b & 10100000b = 00100000b
-01101001b & 10100001b = 00100001b
-01101001b & 10100010b = 00100000b
-01101001b & 10100011b = 00100001b
-01101001b & 10100100b = 00100000b
-01101001b & 10100101b = 00100001b
-01101001b & 10100110b = 00100000b
-01101001b & 10100111b = 00100001b
-01101001b & 10101000b = 00101000b
-01101001b & 10101001b = 00101001b
-01101001b & 10101010b = 00101000b
-01101001b & 10101011b = 00101001b
-01101001b & 10101100b = 00101000b
-01101001b & 10101101b = 00101001b
-01101001b & 10101110b = 00101000b
-01101001b & 10101111b = 00101001b
-01101001b & 10110000b = 00100000b
-01101001b & 10110001b = 00100001b
-01101001b & 10110010b = 00100000b
-01101001b & 10110011b = 00100001b
-01101001b & 10110100b = 00100000b
-01101001b & 10110101b = 00100001b
-01101001b & 10110110b = 00100000b
-01101001b & 10110111b = 00100001b
-01101001b & 10111000b = 00101000b
-01101001b & 10111001b = 00101001b
-01101001b & 10111010b = 00101000b
-01101001b & 10111011b = 00101001b
-01101001b & 10111100b = 00101000b
-01101001b & 10111101b = 00101001b
-01101001b & 10111110b = 00101000b
-01101001b & 10111111b = 00101001b
-01101001b & 11000000b = 01000000b
-01101001b & 11000001b = 01000001b
-01101001b & 11000010b = 01000000b
-01101001b & 11000011b = 01000001b
-01101001b & 11000100b = 01000000b
-01101001b & 11000101b = 01000001b
-01101001b & 11000110b = 01000000b
-01101001b & 11000111b = 01000001b
-01101001b & 11001000b = 01001000b
-01101001b & 11001001b = 01001001b
-01101001b & 11001010b = 01001000b
-01101001b & 11001011b = 01001001b
-01101001b & 11001100b = 01001000b
-01101001b & 11001101b = 01001001b
-01101001b & 11001110b = 01001000b
-01101001b & 11001111b = 01001001b
-01101001b & 11010000b = 01000000b
-01101001b & 11010001b = 01000001b
-01101001b & 11010010b = 01000000b
-01101001b & 11010011b = 01000001b
-01101001b & 11010100b = 01000000b
-01101001b & 11010101b = 01000001b
-01101001b & 11010110b = 01000000b
-01101001b & 11010111b = 01000001b
-01101001b & 11011000b = 01001000b
-01101001b & 11011001b = 01001001b
-01101001b & 11011010b = 01001000b
-01101001b & 11011011b = 01001001b
-01101001b & 11011100b = 01001000b
-01101001b & 11011101b = 01001001b
-01101001b & 11011110b = 01001000b
-01101001b & 11011111b = 01001001b
-01101001b & 11100000b = 01100000b
-01101001b & 11100001b = 01100001b
-01101001b & 11100010b = 01100000b
-01101001b & 11100011b = 01100001b
-01101001b & 11100100b = 01100000b
-01101001b & 11100101b = 01100001b
-01101001b & 11100110b = 01100000b
-01101001b & 11100111b = 01100001b
-01101001b & 11101000b = 01101000b
-01101001b & 11101001b = 01101001b
-01101001b & 11101010b = 01101000b
-01101001b & 11101011b = 01101001b
-01101001b & 11101100b = 01101000b
-01101001b & 11101101b = 01101001b
-01101001b & 11101110b = 01101000b
-01101001b & 11101111b = 01101001b
-01101001b & 11110000b = 01100000b
-01101001b & 11110001b = 01100001b
-01101001b & 11110010b = 01100000b
-01101001b & 11110011b = 01100001b
-01101001b & 11110100b = 01100000b
-01101001b & 11110101b = 01100001b
-01101001b & 11110110b = 01100000b
-01101001b & 11110111b = 01100001b
-01101001b & 11111000b = 01101000b
-01101001b & 11111001b = 01101001b
-01101001b & 11111010b = 01101000b
-01101001b & 11111011b = 01101001b
-01101001b & 11111100b = 01101000b
-01101001b & 11111101b = 01101001b
-01101001b & 11111110b = 01101000b
-01101001b & 11111111b = 01101001b
-01101001b & 00000000b = 00000000b
-01101001b & 00000001b = 00000001b
-01101001b & 00000010b = 00000000b
-01101001b & 00000011b = 00000001b
-01101001b & 00000100b = 00000000b
-01101001b & 00000101b = 00000001b
-01101001b & 00000110b = 00000000b
-01101001b & 00000111b = 00000001b
-01101001b & 00001000b = 00001000b
-01101001b & 00001001b = 00001001b
-01101001b & 00001010b = 00001000b
-01101001b & 00001011b = 00001001b
-01101001b & 00001100b = 00001000b
-01101001b & 00001101b = 00001001b
-01101001b & 00001110b = 00001000b
-01101001b & 00001111b = 00001001b
-01101001b & 00010000b = 00000000b
-01101001b & 00010001b = 00000001b
-01101001b & 00010010b = 00000000b
-01101001b & 00010011b = 00000001b
-01101001b & 00010100b = 00000000b
-01101001b & 00010101b = 00000001b
-01101001b & 00010110b = 00000000b
-01101001b & 00010111b = 00000001b
-01101001b & 00011000b = 00001000b
-01101001b & 00011001b = 00001001b
-01101001b & 00011010b = 00001000b
-01101001b & 00011011b = 00001001b
-01101001b & 00011100b = 00001000b
-01101001b & 00011101b = 00001001b
-01101001b & 00011110b = 00001000b
-01101001b & 00011111b = 00001001b
-01101001b & 00100000b = 00100000b
-01101001b & 00100001b = 00100001b
-01101001b & 00100010b = 00100000b
-01101001b & 00100011b = 00100001b
-01101001b & 00100100b = 00100000b
-01101001b & 00100101b = 00100001b
-01101001b & 00100110b = 00100000b
-01101001b & 00100111b = 00100001b
-01101001b & 00101000b = 00101000b
-01101001b & 00101001b = 00101001b
-01101001b & 00101010b = 00101000b
-01101001b & 00101011b = 00101001b
-01101001b & 00101100b = 00101000b
-01101001b & 00101101b = 00101001b
-01101001b & 00101110b = 00101000b
-01101001b & 00101111b = 00101001b
-01101001b & 00110000b = 00100000b
-01101001b & 00110001b = 00100001b
-01101001b & 00110010b = 00100000b
-01101001b & 00110011b = 00100001b
-01101001b & 00110100b = 00100000b
-01101001b & 00110101b = 00100001b
-01101001b & 00110110b = 00100000b
-01101001b & 00110111b = 00100001b
-01101001b & 00111000b = 00101000b
-01101001b & 00111001b = 00101001b
-01101001b & 00111010b = 00101000b
-01101001b & 00111011b = 00101001b
-01101001b & 00111100b = 00101000b
-01101001b & 00111101b = 00101001b
-01101001b & 00111110b = 00101000b
-01101001b & 00111111b = 00101001b
-01101001b & 01000000b = 01000000b
-01101001b & 01000001b = 01000001b
-01101001b & 01000010b = 01000000b
-01101001b & 01000011b = 01000001b
-01101001b & 01000100b = 01000000b
-01101001b & 01000101b = 01000001b
-01101001b & 01000110b = 01000000b
-01101001b & 01000111b = 01000001b
-01101001b & 01001000b = 01001000b
-01101001b & 01001001b = 01001001b
-01101001b & 01001010b = 01001000b
-01101001b & 01001011b = 01001001b
-01101001b & 01001100b = 01001000b
-01101001b & 01001101b = 01001001b
-01101001b & 01001110b = 01001000b
-01101001b & 01001111b = 01001001b
-01101001b & 01010000b = 01000000b
-01101001b & 01010001b = 01000001b
-01101001b & 01010010b = 01000000b
-01101001b & 01010011b = 01000001b
-01101001b & 01010100b = 01000000b
-01101001b & 01010101b = 01000001b
-01101001b & 01010110b = 01000000b
-01101001b & 01010111b = 01000001b
-01101001b & 01011000b = 01001000b
-01101001b & 01011001b = 01001001b
-01101001b & 01011010b = 01001000b
-01101001b & 01011011b = 01001001b
-01101001b & 01011100b = 01001000b
-01101001b & 01011101b = 01001001b
-01101001b & 01011110b = 01001000b
-01101001b & 01011111b = 01001001b
-01101001b & 01100000b = 01100000b
-01101001b & 01100001b = 01100001b
-01101001b & 01100010b = 01100000b
-01101001b & 01100011b = 01100001b
-01101001b & 01100100b = 01100000b
-01101001b & 01100101b = 01100001b
-01101001b & 01100110b = 01100000b
-01101001b & 01100111b = 01100001b
-01101001b & 01101000b = 01101000b
-01101001b & 01101001b = 01101001b
-01101001b & 01101010b = 01101000b
-01101001b & 01101011b = 01101001b
-01101001b & 01101100b = 01101000b
-01101001b & 01101101b = 01101001b
-01101001b & 01101110b = 01101000b
-01101001b & 01101111b = 01101001b
-01101001b & 01110000b = 01100000b
-01101001b & 01110001b = 01100001b
-01101001b & 01110010b = 01100000b
-01101001b & 01110011b = 01100001b
-01101001b & 01110100b = 01100000b
-01101001b & 01110101b = 01100001b
-01101001b & 01110110b = 01100000b
-01101001b & 01110111b = 01100001b
-01101001b & 01111000b = 01101000b
-01101001b & 01111001b = 01101001b
-01101001b & 01111010b = 01101000b
-01101001b & 01111011b = 01101001b
-01101001b & 01111100b = 01101000b
-01101001b & 01111101b = 01101001b
-01101001b & 01111110b = 01101000b
-01101010b & 10000000b = 00000000b
-01101010b & 10000001b = 00000000b
-01101010b & 10000010b = 00000010b
-01101010b & 10000011b = 00000010b
-01101010b & 10000100b = 00000000b
-01101010b & 10000101b = 00000000b
-01101010b & 10000110b = 00000010b
-01101010b & 10000111b = 00000010b
-01101010b & 10001000b = 00001000b
-01101010b & 10001001b = 00001000b
-01101010b & 10001010b = 00001010b
-01101010b & 10001011b = 00001010b
-01101010b & 10001100b = 00001000b
-01101010b & 10001101b = 00001000b
-01101010b & 10001110b = 00001010b
-01101010b & 10001111b = 00001010b
-01101010b & 10010000b = 00000000b
-01101010b & 10010001b = 00000000b
-01101010b & 10010010b = 00000010b
-01101010b & 10010011b = 00000010b
-01101010b & 10010100b = 00000000b
-01101010b & 10010101b = 00000000b
-01101010b & 10010110b = 00000010b
-01101010b & 10010111b = 00000010b
-01101010b & 10011000b = 00001000b
-01101010b & 10011001b = 00001000b
-01101010b & 10011010b = 00001010b
-01101010b & 10011011b = 00001010b
-01101010b & 10011100b = 00001000b
-01101010b & 10011101b = 00001000b
-01101010b & 10011110b = 00001010b
-01101010b & 10011111b = 00001010b
-01101010b & 10100000b = 00100000b
-01101010b & 10100001b = 00100000b
-01101010b & 10100010b = 00100010b
-01101010b & 10100011b = 00100010b
-01101010b & 10100100b = 00100000b
-01101010b & 10100101b = 00100000b
-01101010b & 10100110b = 00100010b
-01101010b & 10100111b = 00100010b
-01101010b & 10101000b = 00101000b
-01101010b & 10101001b = 00101000b
-01101010b & 10101010b = 00101010b
-01101010b & 10101011b = 00101010b
-01101010b & 10101100b = 00101000b
-01101010b & 10101101b = 00101000b
-01101010b & 10101110b = 00101010b
-01101010b & 10101111b = 00101010b
-01101010b & 10110000b = 00100000b
-01101010b & 10110001b = 00100000b
-01101010b & 10110010b = 00100010b
-01101010b & 10110011b = 00100010b
-01101010b & 10110100b = 00100000b
-01101010b & 10110101b = 00100000b
-01101010b & 10110110b = 00100010b
-01101010b & 10110111b = 00100010b
-01101010b & 10111000b = 00101000b
-01101010b & 10111001b = 00101000b
-01101010b & 10111010b = 00101010b
-01101010b & 10111011b = 00101010b
-01101010b & 10111100b = 00101000b
-01101010b & 10111101b = 00101000b
-01101010b & 10111110b = 00101010b
-01101010b & 10111111b = 00101010b
-01101010b & 11000000b = 01000000b
-01101010b & 11000001b = 01000000b
-01101010b & 11000010b = 01000010b
-01101010b & 11000011b = 01000010b
-01101010b & 11000100b = 01000000b
-01101010b & 11000101b = 01000000b
-01101010b & 11000110b = 01000010b
-01101010b & 11000111b = 01000010b
-01101010b & 11001000b = 01001000b
-01101010b & 11001001b = 01001000b
-01101010b & 11001010b = 01001010b
-01101010b & 11001011b = 01001010b
-01101010b & 11001100b = 01001000b
-01101010b & 11001101b = 01001000b
-01101010b & 11001110b = 01001010b
-01101010b & 11001111b = 01001010b
-01101010b & 11010000b = 01000000b
-01101010b & 11010001b = 01000000b
-01101010b & 11010010b = 01000010b
-01101010b & 11010011b = 01000010b
-01101010b & 11010100b = 01000000b
-01101010b & 11010101b = 01000000b
-01101010b & 11010110b = 01000010b
-01101010b & 11010111b = 01000010b
-01101010b & 11011000b = 01001000b
-01101010b & 11011001b = 01001000b
-01101010b & 11011010b = 01001010b
-01101010b & 11011011b = 01001010b
-01101010b & 11011100b = 01001000b
-01101010b & 11011101b = 01001000b
-01101010b & 11011110b = 01001010b
-01101010b & 11011111b = 01001010b
-01101010b & 11100000b = 01100000b
-01101010b & 11100001b = 01100000b
-01101010b & 11100010b = 01100010b
-01101010b & 11100011b = 01100010b
-01101010b & 11100100b = 01100000b
-01101010b & 11100101b = 01100000b
-01101010b & 11100110b = 01100010b
-01101010b & 11100111b = 01100010b
-01101010b & 11101000b = 01101000b
-01101010b & 11101001b = 01101000b
-01101010b & 11101010b = 01101010b
-01101010b & 11101011b = 01101010b
-01101010b & 11101100b = 01101000b
-01101010b & 11101101b = 01101000b
-01101010b & 11101110b = 01101010b
-01101010b & 11101111b = 01101010b
-01101010b & 11110000b = 01100000b
-01101010b & 11110001b = 01100000b
-01101010b & 11110010b = 01100010b
-01101010b & 11110011b = 01100010b
-01101010b & 11110100b = 01100000b
-01101010b & 11110101b = 01100000b
-01101010b & 11110110b = 01100010b
-01101010b & 11110111b = 01100010b
-01101010b & 11111000b = 01101000b
-01101010b & 11111001b = 01101000b
-01101010b & 11111010b = 01101010b
-01101010b & 11111011b = 01101010b
-01101010b & 11111100b = 01101000b
-01101010b & 11111101b = 01101000b
-01101010b & 11111110b = 01101010b
-01101010b & 11111111b = 01101010b
-01101010b & 00000000b = 00000000b
-01101010b & 00000001b = 00000000b
-01101010b & 00000010b = 00000010b
-01101010b & 00000011b = 00000010b
-01101010b & 00000100b = 00000000b
-01101010b & 00000101b = 00000000b
-01101010b & 00000110b = 00000010b
-01101010b & 00000111b = 00000010b
-01101010b & 00001000b = 00001000b
-01101010b & 00001001b = 00001000b
-01101010b & 00001010b = 00001010b
-01101010b & 00001011b = 00001010b
-01101010b & 00001100b = 00001000b
-01101010b & 00001101b = 00001000b
-01101010b & 00001110b = 00001010b
-01101010b & 00001111b = 00001010b
-01101010b & 00010000b = 00000000b
-01101010b & 00010001b = 00000000b
-01101010b & 00010010b = 00000010b
-01101010b & 00010011b = 00000010b
-01101010b & 00010100b = 00000000b
-01101010b & 00010101b = 00000000b
-01101010b & 00010110b = 00000010b
-01101010b & 00010111b = 00000010b
-01101010b & 00011000b = 00001000b
-01101010b & 00011001b = 00001000b
-01101010b & 00011010b = 00001010b
-01101010b & 00011011b = 00001010b
-01101010b & 00011100b = 00001000b
-01101010b & 00011101b = 00001000b
-01101010b & 00011110b = 00001010b
-01101010b & 00011111b = 00001010b
-01101010b & 00100000b = 00100000b
-01101010b & 00100001b = 00100000b
-01101010b & 00100010b = 00100010b
-01101010b & 00100011b = 00100010b
-01101010b & 00100100b = 00100000b
-01101010b & 00100101b = 00100000b
-01101010b & 00100110b = 00100010b
-01101010b & 00100111b = 00100010b
-01101010b & 00101000b = 00101000b
-01101010b & 00101001b = 00101000b
-01101010b & 00101010b = 00101010b
-01101010b & 00101011b = 00101010b
-01101010b & 00101100b = 00101000b
-01101010b & 00101101b = 00101000b
-01101010b & 00101110b = 00101010b
-01101010b & 00101111b = 00101010b
-01101010b & 00110000b = 00100000b
-01101010b & 00110001b = 00100000b
-01101010b & 00110010b = 00100010b
-01101010b & 00110011b = 00100010b
-01101010b & 00110100b = 00100000b
-01101010b & 00110101b = 00100000b
-01101010b & 00110110b = 00100010b
-01101010b & 00110111b = 00100010b
-01101010b & 00111000b = 00101000b
-01101010b & 00111001b = 00101000b
-01101010b & 00111010b = 00101010b
-01101010b & 00111011b = 00101010b
-01101010b & 00111100b = 00101000b
-01101010b & 00111101b = 00101000b
-01101010b & 00111110b = 00101010b
-01101010b & 00111111b = 00101010b
-01101010b & 01000000b = 01000000b
-01101010b & 01000001b = 01000000b
-01101010b & 01000010b = 01000010b
-01101010b & 01000011b = 01000010b
-01101010b & 01000100b = 01000000b
-01101010b & 01000101b = 01000000b
-01101010b & 01000110b = 01000010b
-01101010b & 01000111b = 01000010b
-01101010b & 01001000b = 01001000b
-01101010b & 01001001b = 01001000b
-01101010b & 01001010b = 01001010b
-01101010b & 01001011b = 01001010b
-01101010b & 01001100b = 01001000b
-01101010b & 01001101b = 01001000b
-01101010b & 01001110b = 01001010b
-01101010b & 01001111b = 01001010b
-01101010b & 01010000b = 01000000b
-01101010b & 01010001b = 01000000b
-01101010b & 01010010b = 01000010b
-01101010b & 01010011b = 01000010b
-01101010b & 01010100b = 01000000b
-01101010b & 01010101b = 01000000b
-01101010b & 01010110b = 01000010b
-01101010b & 01010111b = 01000010b
-01101010b & 01011000b = 01001000b
-01101010b & 01011001b = 01001000b
-01101010b & 01011010b = 01001010b
-01101010b & 01011011b = 01001010b
-01101010b & 01011100b = 01001000b
-01101010b & 01011101b = 01001000b
-01101010b & 01011110b = 01001010b
-01101010b & 01011111b = 01001010b
-01101010b & 01100000b = 01100000b
-01101010b & 01100001b = 01100000b
-01101010b & 01100010b = 01100010b
-01101010b & 01100011b = 01100010b
-01101010b & 01100100b = 01100000b
-01101010b & 01100101b = 01100000b
-01101010b & 01100110b = 01100010b
-01101010b & 01100111b = 01100010b
-01101010b & 01101000b = 01101000b
-01101010b & 01101001b = 01101000b
-01101010b & 01101010b = 01101010b
-01101010b & 01101011b = 01101010b
-01101010b & 01101100b = 01101000b
-01101010b & 01101101b = 01101000b
-01101010b & 01101110b = 01101010b
-01101010b & 01101111b = 01101010b
-01101010b & 01110000b = 01100000b
-01101010b & 01110001b = 01100000b
-01101010b & 01110010b = 01100010b
-01101010b & 01110011b = 01100010b
-01101010b & 01110100b = 01100000b
-01101010b & 01110101b = 01100000b
-01101010b & 01110110b = 01100010b
-01101010b & 01110111b = 01100010b
-01101010b & 01111000b = 01101000b
-01101010b & 01111001b = 01101000b
-01101010b & 01111010b = 01101010b
-01101010b & 01111011b = 01101010b
-01101010b & 01111100b = 01101000b
-01101010b & 01111101b = 01101000b
-01101010b & 01111110b = 01101010b
-01101011b & 10000000b = 00000000b
-01101011b & 10000001b = 00000001b
-01101011b & 10000010b = 00000010b
-01101011b & 10000011b = 00000011b
-01101011b & 10000100b = 00000000b
-01101011b & 10000101b = 00000001b
-01101011b & 10000110b = 00000010b
-01101011b & 10000111b = 00000011b
-01101011b & 10001000b = 00001000b
-01101011b & 10001001b = 00001001b
-01101011b & 10001010b = 00001010b
-01101011b & 10001011b = 00001011b
-01101011b & 10001100b = 00001000b
-01101011b & 10001101b = 00001001b
-01101011b & 10001110b = 00001010b
-01101011b & 10001111b = 00001011b
-01101011b & 10010000b = 00000000b
-01101011b & 10010001b = 00000001b
-01101011b & 10010010b = 00000010b
-01101011b & 10010011b = 00000011b
-01101011b & 10010100b = 00000000b
-01101011b & 10010101b = 00000001b
-01101011b & 10010110b = 00000010b
-01101011b & 10010111b = 00000011b
-01101011b & 10011000b = 00001000b
-01101011b & 10011001b = 00001001b
-01101011b & 10011010b = 00001010b
-01101011b & 10011011b = 00001011b
-01101011b & 10011100b = 00001000b
-01101011b & 10011101b = 00001001b
-01101011b & 10011110b = 00001010b
-01101011b & 10011111b = 00001011b
-01101011b & 10100000b = 00100000b
-01101011b & 10100001b = 00100001b
-01101011b & 10100010b = 00100010b
-01101011b & 10100011b = 00100011b
-01101011b & 10100100b = 00100000b
-01101011b & 10100101b = 00100001b
-01101011b & 10100110b = 00100010b
-01101011b & 10100111b = 00100011b
-01101011b & 10101000b = 00101000b
-01101011b & 10101001b = 00101001b
-01101011b & 10101010b = 00101010b
-01101011b & 10101011b = 00101011b
-01101011b & 10101100b = 00101000b
-01101011b & 10101101b = 00101001b
-01101011b & 10101110b = 00101010b
-01101011b & 10101111b = 00101011b
-01101011b & 10110000b = 00100000b
-01101011b & 10110001b = 00100001b
-01101011b & 10110010b = 00100010b
-01101011b & 10110011b = 00100011b
-01101011b & 10110100b = 00100000b
-01101011b & 10110101b = 00100001b
-01101011b & 10110110b = 00100010b
-01101011b & 10110111b = 00100011b
-01101011b & 10111000b = 00101000b
-01101011b & 10111001b = 00101001b
-01101011b & 10111010b = 00101010b
-01101011b & 10111011b = 00101011b
-01101011b & 10111100b = 00101000b
-01101011b & 10111101b = 00101001b
-01101011b & 10111110b = 00101010b
-01101011b & 10111111b = 00101011b
-01101011b & 11000000b = 01000000b
-01101011b & 11000001b = 01000001b
-01101011b & 11000010b = 01000010b
-01101011b & 11000011b = 01000011b
-01101011b & 11000100b = 01000000b
-01101011b & 11000101b = 01000001b
-01101011b & 11000110b = 01000010b
-01101011b & 11000111b = 01000011b
-01101011b & 11001000b = 01001000b
-01101011b & 11001001b = 01001001b
-01101011b & 11001010b = 01001010b
-01101011b & 11001011b = 01001011b
-01101011b & 11001100b = 01001000b
-01101011b & 11001101b = 01001001b
-01101011b & 11001110b = 01001010b
-01101011b & 11001111b = 01001011b
-01101011b & 11010000b = 01000000b
-01101011b & 11010001b = 01000001b
-01101011b & 11010010b = 01000010b
-01101011b & 11010011b = 01000011b
-01101011b & 11010100b = 01000000b
-01101011b & 11010101b = 01000001b
-01101011b & 11010110b = 01000010b
-01101011b & 11010111b = 01000011b
-01101011b & 11011000b = 01001000b
-01101011b & 11011001b = 01001001b
-01101011b & 11011010b = 01001010b
-01101011b & 11011011b = 01001011b
-01101011b & 11011100b = 01001000b
-01101011b & 11011101b = 01001001b
-01101011b & 11011110b = 01001010b
-01101011b & 11011111b = 01001011b
-01101011b & 11100000b = 01100000b
-01101011b & 11100001b = 01100001b
-01101011b & 11100010b = 01100010b
-01101011b & 11100011b = 01100011b
-01101011b & 11100100b = 01100000b
-01101011b & 11100101b = 01100001b
-01101011b & 11100110b = 01100010b
-01101011b & 11100111b = 01100011b
-01101011b & 11101000b = 01101000b
-01101011b & 11101001b = 01101001b
-01101011b & 11101010b = 01101010b
-01101011b & 11101011b = 01101011b
-01101011b & 11101100b = 01101000b
-01101011b & 11101101b = 01101001b
-01101011b & 11101110b = 01101010b
-01101011b & 11101111b = 01101011b
-01101011b & 11110000b = 01100000b
-01101011b & 11110001b = 01100001b
-01101011b & 11110010b = 01100010b
-01101011b & 11110011b = 01100011b
-01101011b & 11110100b = 01100000b
-01101011b & 11110101b = 01100001b
-01101011b & 11110110b = 01100010b
-01101011b & 11110111b = 01100011b
-01101011b & 11111000b = 01101000b
-01101011b & 11111001b = 01101001b
-01101011b & 11111010b = 01101010b
-01101011b & 11111011b = 01101011b
-01101011b & 11111100b = 01101000b
-01101011b & 11111101b = 01101001b
-01101011b & 11111110b = 01101010b
-01101011b & 11111111b = 01101011b
-01101011b & 00000000b = 00000000b
-01101011b & 00000001b = 00000001b
-01101011b & 00000010b = 00000010b
-01101011b & 00000011b = 00000011b
-01101011b & 00000100b = 00000000b
-01101011b & 00000101b = 00000001b
-01101011b & 00000110b = 00000010b
-01101011b & 00000111b = 00000011b
-01101011b & 00001000b = 00001000b
-01101011b & 00001001b = 00001001b
-01101011b & 00001010b = 00001010b
-01101011b & 00001011b = 00001011b
-01101011b & 00001100b = 00001000b
-01101011b & 00001101b = 00001001b
-01101011b & 00001110b = 00001010b
-01101011b & 00001111b = 00001011b
-01101011b & 00010000b = 00000000b
-01101011b & 00010001b = 00000001b
-01101011b & 00010010b = 00000010b
-01101011b & 00010011b = 00000011b
-01101011b & 00010100b = 00000000b
-01101011b & 00010101b = 00000001b
-01101011b & 00010110b = 00000010b
-01101011b & 00010111b = 00000011b
-01101011b & 00011000b = 00001000b
-01101011b & 00011001b = 00001001b
-01101011b & 00011010b = 00001010b
-01101011b & 00011011b = 00001011b
-01101011b & 00011100b = 00001000b
-01101011b & 00011101b = 00001001b
-01101011b & 00011110b = 00001010b
-01101011b & 00011111b = 00001011b
-01101011b & 00100000b = 00100000b
-01101011b & 00100001b = 00100001b
-01101011b & 00100010b = 00100010b
-01101011b & 00100011b = 00100011b
-01101011b & 00100100b = 00100000b
-01101011b & 00100101b = 00100001b
-01101011b & 00100110b = 00100010b
-01101011b & 00100111b = 00100011b
-01101011b & 00101000b = 00101000b
-01101011b & 00101001b = 00101001b
-01101011b & 00101010b = 00101010b
-01101011b & 00101011b = 00101011b
-01101011b & 00101100b = 00101000b
-01101011b & 00101101b = 00101001b
-01101011b & 00101110b = 00101010b
-01101011b & 00101111b = 00101011b
-01101011b & 00110000b = 00100000b
-01101011b & 00110001b = 00100001b
-01101011b & 00110010b = 00100010b
-01101011b & 00110011b = 00100011b
-01101011b & 00110100b = 00100000b
-01101011b & 00110101b = 00100001b
-01101011b & 00110110b = 00100010b
-01101011b & 00110111b = 00100011b
-01101011b & 00111000b = 00101000b
-01101011b & 00111001b = 00101001b
-01101011b & 00111010b = 00101010b
-01101011b & 00111011b = 00101011b
-01101011b & 00111100b = 00101000b
-01101011b & 00111101b = 00101001b
-01101011b & 00111110b = 00101010b
-01101011b & 00111111b = 00101011b
-01101011b & 01000000b = 01000000b
-01101011b & 01000001b = 01000001b
-01101011b & 01000010b = 01000010b
-01101011b & 01000011b = 01000011b
-01101011b & 01000100b = 01000000b
-01101011b & 01000101b = 01000001b
-01101011b & 01000110b = 01000010b
-01101011b & 01000111b = 01000011b
-01101011b & 01001000b = 01001000b
-01101011b & 01001001b = 01001001b
-01101011b & 01001010b = 01001010b
-01101011b & 01001011b = 01001011b
-01101011b & 01001100b = 01001000b
-01101011b & 01001101b = 01001001b
-01101011b & 01001110b = 01001010b
-01101011b & 01001111b = 01001011b
-01101011b & 01010000b = 01000000b
-01101011b & 01010001b = 01000001b
-01101011b & 01010010b = 01000010b
-01101011b & 01010011b = 01000011b
-01101011b & 01010100b = 01000000b
-01101011b & 01010101b = 01000001b
-01101011b & 01010110b = 01000010b
-01101011b & 01010111b = 01000011b
-01101011b & 01011000b = 01001000b
-01101011b & 01011001b = 01001001b
-01101011b & 01011010b = 01001010b
-01101011b & 01011011b = 01001011b
-01101011b & 01011100b = 01001000b
-01101011b & 01011101b = 01001001b
-01101011b & 01011110b = 01001010b
-01101011b & 01011111b = 01001011b
-01101011b & 01100000b = 01100000b
-01101011b & 01100001b = 01100001b
-01101011b & 01100010b = 01100010b
-01101011b & 01100011b = 01100011b
-01101011b & 01100100b = 01100000b
-01101011b & 01100101b = 01100001b
-01101011b & 01100110b = 01100010b
-01101011b & 01100111b = 01100011b
-01101011b & 01101000b = 01101000b
-01101011b & 01101001b = 01101001b
-01101011b & 01101010b = 01101010b
-01101011b & 01101011b = 01101011b
-01101011b & 01101100b = 01101000b
-01101011b & 01101101b = 01101001b
-01101011b & 01101110b = 01101010b
-01101011b & 01101111b = 01101011b
-01101011b & 01110000b = 01100000b
-01101011b & 01110001b = 01100001b
-01101011b & 01110010b = 01100010b
-01101011b & 01110011b = 01100011b
-01101011b & 01110100b = 01100000b
-01101011b & 01110101b = 01100001b
-01101011b & 01110110b = 01100010b
-01101011b & 01110111b = 01100011b
-01101011b & 01111000b = 01101000b
-01101011b & 01111001b = 01101001b
-01101011b & 01111010b = 01101010b
-01101011b & 01111011b = 01101011b
-01101011b & 01111100b = 01101000b
-01101011b & 01111101b = 01101001b
-01101011b & 01111110b = 01101010b
-01101100b & 10000000b = 00000000b
-01101100b & 10000001b = 00000000b
-01101100b & 10000010b = 00000000b
-01101100b & 10000011b = 00000000b
-01101100b & 10000100b = 00000100b
-01101100b & 10000101b = 00000100b
-01101100b & 10000110b = 00000100b
-01101100b & 10000111b = 00000100b
-01101100b & 10001000b = 00001000b
-01101100b & 10001001b = 00001000b
-01101100b & 10001010b = 00001000b
-01101100b & 10001011b = 00001000b
-01101100b & 10001100b = 00001100b
-01101100b & 10001101b = 00001100b
-01101100b & 10001110b = 00001100b
-01101100b & 10001111b = 00001100b
-01101100b & 10010000b = 00000000b
-01101100b & 10010001b = 00000000b
-01101100b & 10010010b = 00000000b
-01101100b & 10010011b = 00000000b
-01101100b & 10010100b = 00000100b
-01101100b & 10010101b = 00000100b
-01101100b & 10010110b = 00000100b
-01101100b & 10010111b = 00000100b
-01101100b & 10011000b = 00001000b
-01101100b & 10011001b = 00001000b
-01101100b & 10011010b = 00001000b
-01101100b & 10011011b = 00001000b
-01101100b & 10011100b = 00001100b
-01101100b & 10011101b = 00001100b
-01101100b & 10011110b = 00001100b
-01101100b & 10011111b = 00001100b
-01101100b & 10100000b = 00100000b
-01101100b & 10100001b = 00100000b
-01101100b & 10100010b = 00100000b
-01101100b & 10100011b = 00100000b
-01101100b & 10100100b = 00100100b
-01101100b & 10100101b = 00100100b
-01101100b & 10100110b = 00100100b
-01101100b & 10100111b = 00100100b
-01101100b & 10101000b = 00101000b
-01101100b & 10101001b = 00101000b
-01101100b & 10101010b = 00101000b
-01101100b & 10101011b = 00101000b
-01101100b & 10101100b = 00101100b
-01101100b & 10101101b = 00101100b
-01101100b & 10101110b = 00101100b
-01101100b & 10101111b = 00101100b
-01101100b & 10110000b = 00100000b
-01101100b & 10110001b = 00100000b
-01101100b & 10110010b = 00100000b
-01101100b & 10110011b = 00100000b
-01101100b & 10110100b = 00100100b
-01101100b & 10110101b = 00100100b
-01101100b & 10110110b = 00100100b
-01101100b & 10110111b = 00100100b
-01101100b & 10111000b = 00101000b
-01101100b & 10111001b = 00101000b
-01101100b & 10111010b = 00101000b
-01101100b & 10111011b = 00101000b
-01101100b & 10111100b = 00101100b
-01101100b & 10111101b = 00101100b
-01101100b & 10111110b = 00101100b
-01101100b & 10111111b = 00101100b
-01101100b & 11000000b = 01000000b
-01101100b & 11000001b = 01000000b
-01101100b & 11000010b = 01000000b
-01101100b & 11000011b = 01000000b
-01101100b & 11000100b = 01000100b
-01101100b & 11000101b = 01000100b
-01101100b & 11000110b = 01000100b
-01101100b & 11000111b = 01000100b
-01101100b & 11001000b = 01001000b
-01101100b & 11001001b = 01001000b
-01101100b & 11001010b = 01001000b
-01101100b & 11001011b = 01001000b
-01101100b & 11001100b = 01001100b
-01101100b & 11001101b = 01001100b
-01101100b & 11001110b = 01001100b
-01101100b & 11001111b = 01001100b
-01101100b & 11010000b = 01000000b
-01101100b & 11010001b = 01000000b
-01101100b & 11010010b = 01000000b
-01101100b & 11010011b = 01000000b
-01101100b & 11010100b = 01000100b
-01101100b & 11010101b = 01000100b
-01101100b & 11010110b = 01000100b
-01101100b & 11010111b = 01000100b
-01101100b & 11011000b = 01001000b
-01101100b & 11011001b = 01001000b
-01101100b & 11011010b = 01001000b
-01101100b & 11011011b = 01001000b
-01101100b & 11011100b = 01001100b
-01101100b & 11011101b = 01001100b
-01101100b & 11011110b = 01001100b
-01101100b & 11011111b = 01001100b
-01101100b & 11100000b = 01100000b
-01101100b & 11100001b = 01100000b
-01101100b & 11100010b = 01100000b
-01101100b & 11100011b = 01100000b
-01101100b & 11100100b = 01100100b
-01101100b & 11100101b = 01100100b
-01101100b & 11100110b = 01100100b
-01101100b & 11100111b = 01100100b
-01101100b & 11101000b = 01101000b
-01101100b & 11101001b = 01101000b
-01101100b & 11101010b = 01101000b
-01101100b & 11101011b = 01101000b
-01101100b & 11101100b = 01101100b
-01101100b & 11101101b = 01101100b
-01101100b & 11101110b = 01101100b
-01101100b & 11101111b = 01101100b
-01101100b & 11110000b = 01100000b
-01101100b & 11110001b = 01100000b
-01101100b & 11110010b = 01100000b
-01101100b & 11110011b = 01100000b
-01101100b & 11110100b = 01100100b
-01101100b & 11110101b = 01100100b
-01101100b & 11110110b = 01100100b
-01101100b & 11110111b = 01100100b
-01101100b & 11111000b = 01101000b
-01101100b & 11111001b = 01101000b
-01101100b & 11111010b = 01101000b
-01101100b & 11111011b = 01101000b
-01101100b & 11111100b = 01101100b
-01101100b & 11111101b = 01101100b
-01101100b & 11111110b = 01101100b
-01101100b & 11111111b = 01101100b
-01101100b & 00000000b = 00000000b
-01101100b & 00000001b = 00000000b
-01101100b & 00000010b = 00000000b
-01101100b & 00000011b = 00000000b
-01101100b & 00000100b = 00000100b
-01101100b & 00000101b = 00000100b
-01101100b & 00000110b = 00000100b
-01101100b & 00000111b = 00000100b
-01101100b & 00001000b = 00001000b
-01101100b & 00001001b = 00001000b
-01101100b & 00001010b = 00001000b
-01101100b & 00001011b = 00001000b
-01101100b & 00001100b = 00001100b
-01101100b & 00001101b = 00001100b
-01101100b & 00001110b = 00001100b
-01101100b & 00001111b = 00001100b
-01101100b & 00010000b = 00000000b
-01101100b & 00010001b = 00000000b
-01101100b & 00010010b = 00000000b
-01101100b & 00010011b = 00000000b
-01101100b & 00010100b = 00000100b
-01101100b & 00010101b = 00000100b
-01101100b & 00010110b = 00000100b
-01101100b & 00010111b = 00000100b
-01101100b & 00011000b = 00001000b
-01101100b & 00011001b = 00001000b
-01101100b & 00011010b = 00001000b
-01101100b & 00011011b = 00001000b
-01101100b & 00011100b = 00001100b
-01101100b & 00011101b = 00001100b
-01101100b & 00011110b = 00001100b
-01101100b & 00011111b = 00001100b
-01101100b & 00100000b = 00100000b
-01101100b & 00100001b = 00100000b
-01101100b & 00100010b = 00100000b
-01101100b & 00100011b = 00100000b
-01101100b & 00100100b = 00100100b
-01101100b & 00100101b = 00100100b
-01101100b & 00100110b = 00100100b
-01101100b & 00100111b = 00100100b
-01101100b & 00101000b = 00101000b
-01101100b & 00101001b = 00101000b
-01101100b & 00101010b = 00101000b
-01101100b & 00101011b = 00101000b
-01101100b & 00101100b = 00101100b
-01101100b & 00101101b = 00101100b
-01101100b & 00101110b = 00101100b
-01101100b & 00101111b = 00101100b
-01101100b & 00110000b = 00100000b
-01101100b & 00110001b = 00100000b
-01101100b & 00110010b = 00100000b
-01101100b & 00110011b = 00100000b
-01101100b & 00110100b = 00100100b
-01101100b & 00110101b = 00100100b
-01101100b & 00110110b = 00100100b
-01101100b & 00110111b = 00100100b
-01101100b & 00111000b = 00101000b
-01101100b & 00111001b = 00101000b
-01101100b & 00111010b = 00101000b
-01101100b & 00111011b = 00101000b
-01101100b & 00111100b = 00101100b
-01101100b & 00111101b = 00101100b
-01101100b & 00111110b = 00101100b
-01101100b & 00111111b = 00101100b
-01101100b & 01000000b = 01000000b
-01101100b & 01000001b = 01000000b
-01101100b & 01000010b = 01000000b
-01101100b & 01000011b = 01000000b
-01101100b & 01000100b = 01000100b
-01101100b & 01000101b = 01000100b
-01101100b & 01000110b = 01000100b
-01101100b & 01000111b = 01000100b
-01101100b & 01001000b = 01001000b
-01101100b & 01001001b = 01001000b
-01101100b & 01001010b = 01001000b
-01101100b & 01001011b = 01001000b
-01101100b & 01001100b = 01001100b
-01101100b & 01001101b = 01001100b
-01101100b & 01001110b = 01001100b
-01101100b & 01001111b = 01001100b
-01101100b & 01010000b = 01000000b
-01101100b & 01010001b = 01000000b
-01101100b & 01010010b = 01000000b
-01101100b & 01010011b = 01000000b
-01101100b & 01010100b = 01000100b
-01101100b & 01010101b = 01000100b
-01101100b & 01010110b = 01000100b
-01101100b & 01010111b = 01000100b
-01101100b & 01011000b = 01001000b
-01101100b & 01011001b = 01001000b
-01101100b & 01011010b = 01001000b
-01101100b & 01011011b = 01001000b
-01101100b & 01011100b = 01001100b
-01101100b & 01011101b = 01001100b
-01101100b & 01011110b = 01001100b
-01101100b & 01011111b = 01001100b
-01101100b & 01100000b = 01100000b
-01101100b & 01100001b = 01100000b
-01101100b & 01100010b = 01100000b
-01101100b & 01100011b = 01100000b
-01101100b & 01100100b = 01100100b
-01101100b & 01100101b = 01100100b
-01101100b & 01100110b = 01100100b
-01101100b & 01100111b = 01100100b
-01101100b & 01101000b = 01101000b
-01101100b & 01101001b = 01101000b
-01101100b & 01101010b = 01101000b
-01101100b & 01101011b = 01101000b
-01101100b & 01101100b = 01101100b
-01101100b & 01101101b = 01101100b
-01101100b & 01101110b = 01101100b
-01101100b & 01101111b = 01101100b
-01101100b & 01110000b = 01100000b
-01101100b & 01110001b = 01100000b
-01101100b & 01110010b = 01100000b
-01101100b & 01110011b = 01100000b
-01101100b & 01110100b = 01100100b
-01101100b & 01110101b = 01100100b
-01101100b & 01110110b = 01100100b
-01101100b & 01110111b = 01100100b
-01101100b & 01111000b = 01101000b
-01101100b & 01111001b = 01101000b
-01101100b & 01111010b = 01101000b
-01101100b & 01111011b = 01101000b
-01101100b & 01111100b = 01101100b
-01101100b & 01111101b = 01101100b
-01101100b & 01111110b = 01101100b
-01101101b & 10000000b = 00000000b
-01101101b & 10000001b = 00000001b
-01101101b & 10000010b = 00000000b
-01101101b & 10000011b = 00000001b
-01101101b & 10000100b = 00000100b
-01101101b & 10000101b = 00000101b
-01101101b & 10000110b = 00000100b
-01101101b & 10000111b = 00000101b
-01101101b & 10001000b = 00001000b
-01101101b & 10001001b = 00001001b
-01101101b & 10001010b = 00001000b
-01101101b & 10001011b = 00001001b
-01101101b & 10001100b = 00001100b
-01101101b & 10001101b = 00001101b
-01101101b & 10001110b = 00001100b
-01101101b & 10001111b = 00001101b
-01101101b & 10010000b = 00000000b
-01101101b & 10010001b = 00000001b
-01101101b & 10010010b = 00000000b
-01101101b & 10010011b = 00000001b
-01101101b & 10010100b = 00000100b
-01101101b & 10010101b = 00000101b
-01101101b & 10010110b = 00000100b
-01101101b & 10010111b = 00000101b
-01101101b & 10011000b = 00001000b
-01101101b & 10011001b = 00001001b
-01101101b & 10011010b = 00001000b
-01101101b & 10011011b = 00001001b
-01101101b & 10011100b = 00001100b
-01101101b & 10011101b = 00001101b
-01101101b & 10011110b = 00001100b
-01101101b & 10011111b = 00001101b
-01101101b & 10100000b = 00100000b
-01101101b & 10100001b = 00100001b
-01101101b & 10100010b = 00100000b
-01101101b & 10100011b = 00100001b
-01101101b & 10100100b = 00100100b
-01101101b & 10100101b = 00100101b
-01101101b & 10100110b = 00100100b
-01101101b & 10100111b = 00100101b
-01101101b & 10101000b = 00101000b
-01101101b & 10101001b = 00101001b
-01101101b & 10101010b = 00101000b
-01101101b & 10101011b = 00101001b
-01101101b & 10101100b = 00101100b
-01101101b & 10101101b = 00101101b
-01101101b & 10101110b = 00101100b
-01101101b & 10101111b = 00101101b
-01101101b & 10110000b = 00100000b
-01101101b & 10110001b = 00100001b
-01101101b & 10110010b = 00100000b
-01101101b & 10110011b = 00100001b
-01101101b & 10110100b = 00100100b
-01101101b & 10110101b = 00100101b
-01101101b & 10110110b = 00100100b
-01101101b & 10110111b = 00100101b
-01101101b & 10111000b = 00101000b
-01101101b & 10111001b = 00101001b
-01101101b & 10111010b = 00101000b
-01101101b & 10111011b = 00101001b
-01101101b & 10111100b = 00101100b
-01101101b & 10111101b = 00101101b
-01101101b & 10111110b = 00101100b
-01101101b & 10111111b = 00101101b
-01101101b & 11000000b = 01000000b
-01101101b & 11000001b = 01000001b
-01101101b & 11000010b = 01000000b
-01101101b & 11000011b = 01000001b
-01101101b & 11000100b = 01000100b
-01101101b & 11000101b = 01000101b
-01101101b & 11000110b = 01000100b
-01101101b & 11000111b = 01000101b
-01101101b & 11001000b = 01001000b
-01101101b & 11001001b = 01001001b
-01101101b & 11001010b = 01001000b
-01101101b & 11001011b = 01001001b
-01101101b & 11001100b = 01001100b
-01101101b & 11001101b = 01001101b
-01101101b & 11001110b = 01001100b
-01101101b & 11001111b = 01001101b
-01101101b & 11010000b = 01000000b
-01101101b & 11010001b = 01000001b
-01101101b & 11010010b = 01000000b
-01101101b & 11010011b = 01000001b
-01101101b & 11010100b = 01000100b
-01101101b & 11010101b = 01000101b
-01101101b & 11010110b = 01000100b
-01101101b & 11010111b = 01000101b
-01101101b & 11011000b = 01001000b
-01101101b & 11011001b = 01001001b
-01101101b & 11011010b = 01001000b
-01101101b & 11011011b = 01001001b
-01101101b & 11011100b = 01001100b
-01101101b & 11011101b = 01001101b
-01101101b & 11011110b = 01001100b
-01101101b & 11011111b = 01001101b
-01101101b & 11100000b = 01100000b
-01101101b & 11100001b = 01100001b
-01101101b & 11100010b = 01100000b
-01101101b & 11100011b = 01100001b
-01101101b & 11100100b = 01100100b
-01101101b & 11100101b = 01100101b
-01101101b & 11100110b = 01100100b
-01101101b & 11100111b = 01100101b
-01101101b & 11101000b = 01101000b
-01101101b & 11101001b = 01101001b
-01101101b & 11101010b = 01101000b
-01101101b & 11101011b = 01101001b
-01101101b & 11101100b = 01101100b
-01101101b & 11101101b = 01101101b
-01101101b & 11101110b = 01101100b
-01101101b & 11101111b = 01101101b
-01101101b & 11110000b = 01100000b
-01101101b & 11110001b = 01100001b
-01101101b & 11110010b = 01100000b
-01101101b & 11110011b = 01100001b
-01101101b & 11110100b = 01100100b
-01101101b & 11110101b = 01100101b
-01101101b & 11110110b = 01100100b
-01101101b & 11110111b = 01100101b
-01101101b & 11111000b = 01101000b
-01101101b & 11111001b = 01101001b
-01101101b & 11111010b = 01101000b
-01101101b & 11111011b = 01101001b
-01101101b & 11111100b = 01101100b
-01101101b & 11111101b = 01101101b
-01101101b & 11111110b = 01101100b
-01101101b & 11111111b = 01101101b
-01101101b & 00000000b = 00000000b
-01101101b & 00000001b = 00000001b
-01101101b & 00000010b = 00000000b
-01101101b & 00000011b = 00000001b
-01101101b & 00000100b = 00000100b
-01101101b & 00000101b = 00000101b
-01101101b & 00000110b = 00000100b
-01101101b & 00000111b = 00000101b
-01101101b & 00001000b = 00001000b
-01101101b & 00001001b = 00001001b
-01101101b & 00001010b = 00001000b
-01101101b & 00001011b = 00001001b
-01101101b & 00001100b = 00001100b
-01101101b & 00001101b = 00001101b
-01101101b & 00001110b = 00001100b
-01101101b & 00001111b = 00001101b
-01101101b & 00010000b = 00000000b
-01101101b & 00010001b = 00000001b
-01101101b & 00010010b = 00000000b
-01101101b & 00010011b = 00000001b
-01101101b & 00010100b = 00000100b
-01101101b & 00010101b = 00000101b
-01101101b & 00010110b = 00000100b
-01101101b & 00010111b = 00000101b
-01101101b & 00011000b = 00001000b
-01101101b & 00011001b = 00001001b
-01101101b & 00011010b = 00001000b
-01101101b & 00011011b = 00001001b
-01101101b & 00011100b = 00001100b
-01101101b & 00011101b = 00001101b
-01101101b & 00011110b = 00001100b
-01101101b & 00011111b = 00001101b
-01101101b & 00100000b = 00100000b
-01101101b & 00100001b = 00100001b
-01101101b & 00100010b = 00100000b
-01101101b & 00100011b = 00100001b
-01101101b & 00100100b = 00100100b
-01101101b & 00100101b = 00100101b
-01101101b & 00100110b = 00100100b
-01101101b & 00100111b = 00100101b
-01101101b & 00101000b = 00101000b
-01101101b & 00101001b = 00101001b
-01101101b & 00101010b = 00101000b
-01101101b & 00101011b = 00101001b
-01101101b & 00101100b = 00101100b
-01101101b & 00101101b = 00101101b
-01101101b & 00101110b = 00101100b
-01101101b & 00101111b = 00101101b
-01101101b & 00110000b = 00100000b
-01101101b & 00110001b = 00100001b
-01101101b & 00110010b = 00100000b
-01101101b & 00110011b = 00100001b
-01101101b & 00110100b = 00100100b
-01101101b & 00110101b = 00100101b
-01101101b & 00110110b = 00100100b
-01101101b & 00110111b = 00100101b
-01101101b & 00111000b = 00101000b
-01101101b & 00111001b = 00101001b
-01101101b & 00111010b = 00101000b
-01101101b & 00111011b = 00101001b
-01101101b & 00111100b = 00101100b
-01101101b & 00111101b = 00101101b
-01101101b & 00111110b = 00101100b
-01101101b & 00111111b = 00101101b
-01101101b & 01000000b = 01000000b
-01101101b & 01000001b = 01000001b
-01101101b & 01000010b = 01000000b
-01101101b & 01000011b = 01000001b
-01101101b & 01000100b = 01000100b
-01101101b & 01000101b = 01000101b
-01101101b & 01000110b = 01000100b
-01101101b & 01000111b = 01000101b
-01101101b & 01001000b = 01001000b
-01101101b & 01001001b = 01001001b
-01101101b & 01001010b = 01001000b
-01101101b & 01001011b = 01001001b
-01101101b & 01001100b = 01001100b
-01101101b & 01001101b = 01001101b
-01101101b & 01001110b = 01001100b
-01101101b & 01001111b = 01001101b
-01101101b & 01010000b = 01000000b
-01101101b & 01010001b = 01000001b
-01101101b & 01010010b = 01000000b
-01101101b & 01010011b = 01000001b
-01101101b & 01010100b = 01000100b
-01101101b & 01010101b = 01000101b
-01101101b & 01010110b = 01000100b
-01101101b & 01010111b = 01000101b
-01101101b & 01011000b = 01001000b
-01101101b & 01011001b = 01001001b
-01101101b & 01011010b = 01001000b
-01101101b & 01011011b = 01001001b
-01101101b & 01011100b = 01001100b
-01101101b & 01011101b = 01001101b
-01101101b & 01011110b = 01001100b
-01101101b & 01011111b = 01001101b
-01101101b & 01100000b = 01100000b
-01101101b & 01100001b = 01100001b
-01101101b & 01100010b = 01100000b
-01101101b & 01100011b = 01100001b
-01101101b & 01100100b = 01100100b
-01101101b & 01100101b = 01100101b
-01101101b & 01100110b = 01100100b
-01101101b & 01100111b = 01100101b
-01101101b & 01101000b = 01101000b
-01101101b & 01101001b = 01101001b
-01101101b & 01101010b = 01101000b
-01101101b & 01101011b = 01101001b
-01101101b & 01101100b = 01101100b
-01101101b & 01101101b = 01101101b
-01101101b & 01101110b = 01101100b
-01101101b & 01101111b = 01101101b
-01101101b & 01110000b = 01100000b
-01101101b & 01110001b = 01100001b
-01101101b & 01110010b = 01100000b
-01101101b & 01110011b = 01100001b
-01101101b & 01110100b = 01100100b
-01101101b & 01110101b = 01100101b
-01101101b & 01110110b = 01100100b
-01101101b & 01110111b = 01100101b
-01101101b & 01111000b = 01101000b
-01101101b & 01111001b = 01101001b
-01101101b & 01111010b = 01101000b
-01101101b & 01111011b = 01101001b
-01101101b & 01111100b = 01101100b
-01101101b & 01111101b = 01101101b
-01101101b & 01111110b = 01101100b
-01101110b & 10000000b = 00000000b
-01101110b & 10000001b = 00000000b
-01101110b & 10000010b = 00000010b
-01101110b & 10000011b = 00000010b
-01101110b & 10000100b = 00000100b
-01101110b & 10000101b = 00000100b
-01101110b & 10000110b = 00000110b
-01101110b & 10000111b = 00000110b
-01101110b & 10001000b = 00001000b
-01101110b & 10001001b = 00001000b
-01101110b & 10001010b = 00001010b
-01101110b & 10001011b = 00001010b
-01101110b & 10001100b = 00001100b
-01101110b & 10001101b = 00001100b
-01101110b & 10001110b = 00001110b
-01101110b & 10001111b = 00001110b
-01101110b & 10010000b = 00000000b
-01101110b & 10010001b = 00000000b
-01101110b & 10010010b = 00000010b
-01101110b & 10010011b = 00000010b
-01101110b & 10010100b = 00000100b
-01101110b & 10010101b = 00000100b
-01101110b & 10010110b = 00000110b
-01101110b & 10010111b = 00000110b
-01101110b & 10011000b = 00001000b
-01101110b & 10011001b = 00001000b
-01101110b & 10011010b = 00001010b
-01101110b & 10011011b = 00001010b
-01101110b & 10011100b = 00001100b
-01101110b & 10011101b = 00001100b
-01101110b & 10011110b = 00001110b
-01101110b & 10011111b = 00001110b
-01101110b & 10100000b = 00100000b
-01101110b & 10100001b = 00100000b
-01101110b & 10100010b = 00100010b
-01101110b & 10100011b = 00100010b
-01101110b & 10100100b = 00100100b
-01101110b & 10100101b = 00100100b
-01101110b & 10100110b = 00100110b
-01101110b & 10100111b = 00100110b
-01101110b & 10101000b = 00101000b
-01101110b & 10101001b = 00101000b
-01101110b & 10101010b = 00101010b
-01101110b & 10101011b = 00101010b
-01101110b & 10101100b = 00101100b
-01101110b & 10101101b = 00101100b
-01101110b & 10101110b = 00101110b
-01101110b & 10101111b = 00101110b
-01101110b & 10110000b = 00100000b
-01101110b & 10110001b = 00100000b
-01101110b & 10110010b = 00100010b
-01101110b & 10110011b = 00100010b
-01101110b & 10110100b = 00100100b
-01101110b & 10110101b = 00100100b
-01101110b & 10110110b = 00100110b
-01101110b & 10110111b = 00100110b
-01101110b & 10111000b = 00101000b
-01101110b & 10111001b = 00101000b
-01101110b & 10111010b = 00101010b
-01101110b & 10111011b = 00101010b
-01101110b & 10111100b = 00101100b
-01101110b & 10111101b = 00101100b
-01101110b & 10111110b = 00101110b
-01101110b & 10111111b = 00101110b
-01101110b & 11000000b = 01000000b
-01101110b & 11000001b = 01000000b
-01101110b & 11000010b = 01000010b
-01101110b & 11000011b = 01000010b
-01101110b & 11000100b = 01000100b
-01101110b & 11000101b = 01000100b
-01101110b & 11000110b = 01000110b
-01101110b & 11000111b = 01000110b
-01101110b & 11001000b = 01001000b
-01101110b & 11001001b = 01001000b
-01101110b & 11001010b = 01001010b
-01101110b & 11001011b = 01001010b
-01101110b & 11001100b = 01001100b
-01101110b & 11001101b = 01001100b
-01101110b & 11001110b = 01001110b
-01101110b & 11001111b = 01001110b
-01101110b & 11010000b = 01000000b
-01101110b & 11010001b = 01000000b
-01101110b & 11010010b = 01000010b
-01101110b & 11010011b = 01000010b
-01101110b & 11010100b = 01000100b
-01101110b & 11010101b = 01000100b
-01101110b & 11010110b = 01000110b
-01101110b & 11010111b = 01000110b
-01101110b & 11011000b = 01001000b
-01101110b & 11011001b = 01001000b
-01101110b & 11011010b = 01001010b
-01101110b & 11011011b = 01001010b
-01101110b & 11011100b = 01001100b
-01101110b & 11011101b = 01001100b
-01101110b & 11011110b = 01001110b
-01101110b & 11011111b = 01001110b
-01101110b & 11100000b = 01100000b
-01101110b & 11100001b = 01100000b
-01101110b & 11100010b = 01100010b
-01101110b & 11100011b = 01100010b
-01101110b & 11100100b = 01100100b
-01101110b & 11100101b = 01100100b
-01101110b & 11100110b = 01100110b
-01101110b & 11100111b = 01100110b
-01101110b & 11101000b = 01101000b
-01101110b & 11101001b = 01101000b
-01101110b & 11101010b = 01101010b
-01101110b & 11101011b = 01101010b
-01101110b & 11101100b = 01101100b
-01101110b & 11101101b = 01101100b
-01101110b & 11101110b = 01101110b
-01101110b & 11101111b = 01101110b
-01101110b & 11110000b = 01100000b
-01101110b & 11110001b = 01100000b
-01101110b & 11110010b = 01100010b
-01101110b & 11110011b = 01100010b
-01101110b & 11110100b = 01100100b
-01101110b & 11110101b = 01100100b
-01101110b & 11110110b = 01100110b
-01101110b & 11110111b = 01100110b
-01101110b & 11111000b = 01101000b
-01101110b & 11111001b = 01101000b
-01101110b & 11111010b = 01101010b
-01101110b & 11111011b = 01101010b
-01101110b & 11111100b = 01101100b
-01101110b & 11111101b = 01101100b
-01101110b & 11111110b = 01101110b
-01101110b & 11111111b = 01101110b
-01101110b & 00000000b = 00000000b
-01101110b & 00000001b = 00000000b
-01101110b & 00000010b = 00000010b
-01101110b & 00000011b = 00000010b
-01101110b & 00000100b = 00000100b
-01101110b & 00000101b = 00000100b
-01101110b & 00000110b = 00000110b
-01101110b & 00000111b = 00000110b
-01101110b & 00001000b = 00001000b
-01101110b & 00001001b = 00001000b
-01101110b & 00001010b = 00001010b
-01101110b & 00001011b = 00001010b
-01101110b & 00001100b = 00001100b
-01101110b & 00001101b = 00001100b
-01101110b & 00001110b = 00001110b
-01101110b & 00001111b = 00001110b
-01101110b & 00010000b = 00000000b
-01101110b & 00010001b = 00000000b
-01101110b & 00010010b = 00000010b
-01101110b & 00010011b = 00000010b
-01101110b & 00010100b = 00000100b
-01101110b & 00010101b = 00000100b
-01101110b & 00010110b = 00000110b
-01101110b & 00010111b = 00000110b
-01101110b & 00011000b = 00001000b
-01101110b & 00011001b = 00001000b
-01101110b & 00011010b = 00001010b
-01101110b & 00011011b = 00001010b
-01101110b & 00011100b = 00001100b
-01101110b & 00011101b = 00001100b
-01101110b & 00011110b = 00001110b
-01101110b & 00011111b = 00001110b
-01101110b & 00100000b = 00100000b
-01101110b & 00100001b = 00100000b
-01101110b & 00100010b = 00100010b
-01101110b & 00100011b = 00100010b
-01101110b & 00100100b = 00100100b
-01101110b & 00100101b = 00100100b
-01101110b & 00100110b = 00100110b
-01101110b & 00100111b = 00100110b
-01101110b & 00101000b = 00101000b
-01101110b & 00101001b = 00101000b
-01101110b & 00101010b = 00101010b
-01101110b & 00101011b = 00101010b
-01101110b & 00101100b = 00101100b
-01101110b & 00101101b = 00101100b
-01101110b & 00101110b = 00101110b
-01101110b & 00101111b = 00101110b
-01101110b & 00110000b = 00100000b
-01101110b & 00110001b = 00100000b
-01101110b & 00110010b = 00100010b
-01101110b & 00110011b = 00100010b
-01101110b & 00110100b = 00100100b
-01101110b & 00110101b = 00100100b
-01101110b & 00110110b = 00100110b
-01101110b & 00110111b = 00100110b
-01101110b & 00111000b = 00101000b
-01101110b & 00111001b = 00101000b
-01101110b & 00111010b = 00101010b
-01101110b & 00111011b = 00101010b
-01101110b & 00111100b = 00101100b
-01101110b & 00111101b = 00101100b
-01101110b & 00111110b = 00101110b
-01101110b & 00111111b = 00101110b
-01101110b & 01000000b = 01000000b
-01101110b & 01000001b = 01000000b
-01101110b & 01000010b = 01000010b
-01101110b & 01000011b = 01000010b
-01101110b & 01000100b = 01000100b
-01101110b & 01000101b = 01000100b
-01101110b & 01000110b = 01000110b
-01101110b & 01000111b = 01000110b
-01101110b & 01001000b = 01001000b
-01101110b & 01001001b = 01001000b
-01101110b & 01001010b = 01001010b
-01101110b & 01001011b = 01001010b
-01101110b & 01001100b = 01001100b
-01101110b & 01001101b = 01001100b
-01101110b & 01001110b = 01001110b
-01101110b & 01001111b = 01001110b
-01101110b & 01010000b = 01000000b
-01101110b & 01010001b = 01000000b
-01101110b & 01010010b = 01000010b
-01101110b & 01010011b = 01000010b
-01101110b & 01010100b = 01000100b
-01101110b & 01010101b = 01000100b
-01101110b & 01010110b = 01000110b
-01101110b & 01010111b = 01000110b
-01101110b & 01011000b = 01001000b
-01101110b & 01011001b = 01001000b
-01101110b & 01011010b = 01001010b
-01101110b & 01011011b = 01001010b
-01101110b & 01011100b = 01001100b
-01101110b & 01011101b = 01001100b
-01101110b & 01011110b = 01001110b
-01101110b & 01011111b = 01001110b
-01101110b & 01100000b = 01100000b
-01101110b & 01100001b = 01100000b
-01101110b & 01100010b = 01100010b
-01101110b & 01100011b = 01100010b
-01101110b & 01100100b = 01100100b
-01101110b & 01100101b = 01100100b
-01101110b & 01100110b = 01100110b
-01101110b & 01100111b = 01100110b
-01101110b & 01101000b = 01101000b
-01101110b & 01101001b = 01101000b
-01101110b & 01101010b = 01101010b
-01101110b & 01101011b = 01101010b
-01101110b & 01101100b = 01101100b
-01101110b & 01101101b = 01101100b
-01101110b & 01101110b = 01101110b
-01101110b & 01101111b = 01101110b
-01101110b & 01110000b = 01100000b
-01101110b & 01110001b = 01100000b
-01101110b & 01110010b = 01100010b
-01101110b & 01110011b = 01100010b
-01101110b & 01110100b = 01100100b
-01101110b & 01110101b = 01100100b
-01101110b & 01110110b = 01100110b
-01101110b & 01110111b = 01100110b
-01101110b & 01111000b = 01101000b
-01101110b & 01111001b = 01101000b
-01101110b & 01111010b = 01101010b
-01101110b & 01111011b = 01101010b
-01101110b & 01111100b = 01101100b
-01101110b & 01111101b = 01101100b
-01101110b & 01111110b = 01101110b
-01101111b & 10000000b = 00000000b
-01101111b & 10000001b = 00000001b
-01101111b & 10000010b = 00000010b
-01101111b & 10000011b = 00000011b
-01101111b & 10000100b = 00000100b
-01101111b & 10000101b = 00000101b
-01101111b & 10000110b = 00000110b
-01101111b & 10000111b = 00000111b
-01101111b & 10001000b = 00001000b
-01101111b & 10001001b = 00001001b
-01101111b & 10001010b = 00001010b
-01101111b & 10001011b = 00001011b
-01101111b & 10001100b = 00001100b
-01101111b & 10001101b = 00001101b
-01101111b & 10001110b = 00001110b
-01101111b & 10001111b = 00001111b
-01101111b & 10010000b = 00000000b
-01101111b & 10010001b = 00000001b
-01101111b & 10010010b = 00000010b
-01101111b & 10010011b = 00000011b
-01101111b & 10010100b = 00000100b
-01101111b & 10010101b = 00000101b
-01101111b & 10010110b = 00000110b
-01101111b & 10010111b = 00000111b
-01101111b & 10011000b = 00001000b
-01101111b & 10011001b = 00001001b
-01101111b & 10011010b = 00001010b
-01101111b & 10011011b = 00001011b
-01101111b & 10011100b = 00001100b
-01101111b & 10011101b = 00001101b
-01101111b & 10011110b = 00001110b
-01101111b & 10011111b = 00001111b
-01101111b & 10100000b = 00100000b
-01101111b & 10100001b = 00100001b
-01101111b & 10100010b = 00100010b
-01101111b & 10100011b = 00100011b
-01101111b & 10100100b = 00100100b
-01101111b & 10100101b = 00100101b
-01101111b & 10100110b = 00100110b
-01101111b & 10100111b = 00100111b
-01101111b & 10101000b = 00101000b
-01101111b & 10101001b = 00101001b
-01101111b & 10101010b = 00101010b
-01101111b & 10101011b = 00101011b
-01101111b & 10101100b = 00101100b
-01101111b & 10101101b = 00101101b
-01101111b & 10101110b = 00101110b
-01101111b & 10101111b = 00101111b
-01101111b & 10110000b = 00100000b
-01101111b & 10110001b = 00100001b
-01101111b & 10110010b = 00100010b
-01101111b & 10110011b = 00100011b
-01101111b & 10110100b = 00100100b
-01101111b & 10110101b = 00100101b
-01101111b & 10110110b = 00100110b
-01101111b & 10110111b = 00100111b
-01101111b & 10111000b = 00101000b
-01101111b & 10111001b = 00101001b
-01101111b & 10111010b = 00101010b
-01101111b & 10111011b = 00101011b
-01101111b & 10111100b = 00101100b
-01101111b & 10111101b = 00101101b
-01101111b & 10111110b = 00101110b
-01101111b & 10111111b = 00101111b
-01101111b & 11000000b = 01000000b
-01101111b & 11000001b = 01000001b
-01101111b & 11000010b = 01000010b
-01101111b & 11000011b = 01000011b
-01101111b & 11000100b = 01000100b
-01101111b & 11000101b = 01000101b
-01101111b & 11000110b = 01000110b
-01101111b & 11000111b = 01000111b
-01101111b & 11001000b = 01001000b
-01101111b & 11001001b = 01001001b
-01101111b & 11001010b = 01001010b
-01101111b & 11001011b = 01001011b
-01101111b & 11001100b = 01001100b
-01101111b & 11001101b = 01001101b
-01101111b & 11001110b = 01001110b
-01101111b & 11001111b = 01001111b
-01101111b & 11010000b = 01000000b
-01101111b & 11010001b = 01000001b
-01101111b & 11010010b = 01000010b
-01101111b & 11010011b = 01000011b
-01101111b & 11010100b = 01000100b
-01101111b & 11010101b = 01000101b
-01101111b & 11010110b = 01000110b
-01101111b & 11010111b = 01000111b
-01101111b & 11011000b = 01001000b
-01101111b & 11011001b = 01001001b
-01101111b & 11011010b = 01001010b
-01101111b & 11011011b = 01001011b
-01101111b & 11011100b = 01001100b
-01101111b & 11011101b = 01001101b
-01101111b & 11011110b = 01001110b
-01101111b & 11011111b = 01001111b
-01101111b & 11100000b = 01100000b
-01101111b & 11100001b = 01100001b
-01101111b & 11100010b = 01100010b
-01101111b & 11100011b = 01100011b
-01101111b & 11100100b = 01100100b
-01101111b & 11100101b = 01100101b
-01101111b & 11100110b = 01100110b
-01101111b & 11100111b = 01100111b
-01101111b & 11101000b = 01101000b
-01101111b & 11101001b = 01101001b
-01101111b & 11101010b = 01101010b
-01101111b & 11101011b = 01101011b
-01101111b & 11101100b = 01101100b
-01101111b & 11101101b = 01101101b
-01101111b & 11101110b = 01101110b
-01101111b & 11101111b = 01101111b
-01101111b & 11110000b = 01100000b
-01101111b & 11110001b = 01100001b
-01101111b & 11110010b = 01100010b
-01101111b & 11110011b = 01100011b
-01101111b & 11110100b = 01100100b
-01101111b & 11110101b = 01100101b
-01101111b & 11110110b = 01100110b
-01101111b & 11110111b = 01100111b
-01101111b & 11111000b = 01101000b
-01101111b & 11111001b = 01101001b
-01101111b & 11111010b = 01101010b
-01101111b & 11111011b = 01101011b
-01101111b & 11111100b = 01101100b
-01101111b & 11111101b = 01101101b
-01101111b & 11111110b = 01101110b
-01101111b & 11111111b = 01101111b
-01101111b & 00000000b = 00000000b
-01101111b & 00000001b = 00000001b
-01101111b & 00000010b = 00000010b
-01101111b & 00000011b = 00000011b
-01101111b & 00000100b = 00000100b
-01101111b & 00000101b = 00000101b
-01101111b & 00000110b = 00000110b
-01101111b & 00000111b = 00000111b
-01101111b & 00001000b = 00001000b
-01101111b & 00001001b = 00001001b
-01101111b & 00001010b = 00001010b
-01101111b & 00001011b = 00001011b
-01101111b & 00001100b = 00001100b
-01101111b & 00001101b = 00001101b
-01101111b & 00001110b = 00001110b
-01101111b & 00001111b = 00001111b
-01101111b & 00010000b = 00000000b
-01101111b & 00010001b = 00000001b
-01101111b & 00010010b = 00000010b
-01101111b & 00010011b = 00000011b
-01101111b & 00010100b = 00000100b
-01101111b & 00010101b = 00000101b
-01101111b & 00010110b = 00000110b
-01101111b & 00010111b = 00000111b
-01101111b & 00011000b = 00001000b
-01101111b & 00011001b = 00001001b
-01101111b & 00011010b = 00001010b
-01101111b & 00011011b = 00001011b
-01101111b & 00011100b = 00001100b
-01101111b & 00011101b = 00001101b
-01101111b & 00011110b = 00001110b
-01101111b & 00011111b = 00001111b
-01101111b & 00100000b = 00100000b
-01101111b & 00100001b = 00100001b
-01101111b & 00100010b = 00100010b
-01101111b & 00100011b = 00100011b
-01101111b & 00100100b = 00100100b
-01101111b & 00100101b = 00100101b
-01101111b & 00100110b = 00100110b
-01101111b & 00100111b = 00100111b
-01101111b & 00101000b = 00101000b
-01101111b & 00101001b = 00101001b
-01101111b & 00101010b = 00101010b
-01101111b & 00101011b = 00101011b
-01101111b & 00101100b = 00101100b
-01101111b & 00101101b = 00101101b
-01101111b & 00101110b = 00101110b
-01101111b & 00101111b = 00101111b
-01101111b & 00110000b = 00100000b
-01101111b & 00110001b = 00100001b
-01101111b & 00110010b = 00100010b
-01101111b & 00110011b = 00100011b
-01101111b & 00110100b = 00100100b
-01101111b & 00110101b = 00100101b
-01101111b & 00110110b = 00100110b
-01101111b & 00110111b = 00100111b
-01101111b & 00111000b = 00101000b
-01101111b & 00111001b = 00101001b
-01101111b & 00111010b = 00101010b
-01101111b & 00111011b = 00101011b
-01101111b & 00111100b = 00101100b
-01101111b & 00111101b = 00101101b
-01101111b & 00111110b = 00101110b
-01101111b & 00111111b = 00101111b
-01101111b & 01000000b = 01000000b
-01101111b & 01000001b = 01000001b
-01101111b & 01000010b = 01000010b
-01101111b & 01000011b = 01000011b
-01101111b & 01000100b = 01000100b
-01101111b & 01000101b = 01000101b
-01101111b & 01000110b = 01000110b
-01101111b & 01000111b = 01000111b
-01101111b & 01001000b = 01001000b
-01101111b & 01001001b = 01001001b
-01101111b & 01001010b = 01001010b
-01101111b & 01001011b = 01001011b
-01101111b & 01001100b = 01001100b
-01101111b & 01001101b = 01001101b
-01101111b & 01001110b = 01001110b
-01101111b & 01001111b = 01001111b
-01101111b & 01010000b = 01000000b
-01101111b & 01010001b = 01000001b
-01101111b & 01010010b = 01000010b
-01101111b & 01010011b = 01000011b
-01101111b & 01010100b = 01000100b
-01101111b & 01010101b = 01000101b
-01101111b & 01010110b = 01000110b
-01101111b & 01010111b = 01000111b
-01101111b & 01011000b = 01001000b
-01101111b & 01011001b = 01001001b
-01101111b & 01011010b = 01001010b
-01101111b & 01011011b = 01001011b
-01101111b & 01011100b = 01001100b
-01101111b & 01011101b = 01001101b
-01101111b & 01011110b = 01001110b
-01101111b & 01011111b = 01001111b
-01101111b & 01100000b = 01100000b
-01101111b & 01100001b = 01100001b
-01101111b & 01100010b = 01100010b
-01101111b & 01100011b = 01100011b
-01101111b & 01100100b = 01100100b
-01101111b & 01100101b = 01100101b
-01101111b & 01100110b = 01100110b
-01101111b & 01100111b = 01100111b
-01101111b & 01101000b = 01101000b
-01101111b & 01101001b = 01101001b
-01101111b & 01101010b = 01101010b
-01101111b & 01101011b = 01101011b
-01101111b & 01101100b = 01101100b
-01101111b & 01101101b = 01101101b
-01101111b & 01101110b = 01101110b
-01101111b & 01101111b = 01101111b
-01101111b & 01110000b = 01100000b
-01101111b & 01110001b = 01100001b
-01101111b & 01110010b = 01100010b
-01101111b & 01110011b = 01100011b
-01101111b & 01110100b = 01100100b
-01101111b & 01110101b = 01100101b
-01101111b & 01110110b = 01100110b
-01101111b & 01110111b = 01100111b
-01101111b & 01111000b = 01101000b
-01101111b & 01111001b = 01101001b
-01101111b & 01111010b = 01101010b
-01101111b & 01111011b = 01101011b
-01101111b & 01111100b = 01101100b
-01101111b & 01111101b = 01101101b
-01101111b & 01111110b = 01101110b
-01110000b & 10000000b = 00000000b
-01110000b & 10000001b = 00000000b
-01110000b & 10000010b = 00000000b
-01110000b & 10000011b = 00000000b
-01110000b & 10000100b = 00000000b
-01110000b & 10000101b = 00000000b
-01110000b & 10000110b = 00000000b
-01110000b & 10000111b = 00000000b
-01110000b & 10001000b = 00000000b
-01110000b & 10001001b = 00000000b
-01110000b & 10001010b = 00000000b
-01110000b & 10001011b = 00000000b
-01110000b & 10001100b = 00000000b
-01110000b & 10001101b = 00000000b
-01110000b & 10001110b = 00000000b
-01110000b & 10001111b = 00000000b
-01110000b & 10010000b = 00010000b
-01110000b & 10010001b = 00010000b
-01110000b & 10010010b = 00010000b
-01110000b & 10010011b = 00010000b
-01110000b & 10010100b = 00010000b
-01110000b & 10010101b = 00010000b
-01110000b & 10010110b = 00010000b
-01110000b & 10010111b = 00010000b
-01110000b & 10011000b = 00010000b
-01110000b & 10011001b = 00010000b
-01110000b & 10011010b = 00010000b
-01110000b & 10011011b = 00010000b
-01110000b & 10011100b = 00010000b
-01110000b & 10011101b = 00010000b
-01110000b & 10011110b = 00010000b
-01110000b & 10011111b = 00010000b
-01110000b & 10100000b = 00100000b
-01110000b & 10100001b = 00100000b
-01110000b & 10100010b = 00100000b
-01110000b & 10100011b = 00100000b
-01110000b & 10100100b = 00100000b
-01110000b & 10100101b = 00100000b
-01110000b & 10100110b = 00100000b
-01110000b & 10100111b = 00100000b
-01110000b & 10101000b = 00100000b
-01110000b & 10101001b = 00100000b
-01110000b & 10101010b = 00100000b
-01110000b & 10101011b = 00100000b
-01110000b & 10101100b = 00100000b
-01110000b & 10101101b = 00100000b
-01110000b & 10101110b = 00100000b
-01110000b & 10101111b = 00100000b
-01110000b & 10110000b = 00110000b
-01110000b & 10110001b = 00110000b
-01110000b & 10110010b = 00110000b
-01110000b & 10110011b = 00110000b
-01110000b & 10110100b = 00110000b
-01110000b & 10110101b = 00110000b
-01110000b & 10110110b = 00110000b
-01110000b & 10110111b = 00110000b
-01110000b & 10111000b = 00110000b
-01110000b & 10111001b = 00110000b
-01110000b & 10111010b = 00110000b
-01110000b & 10111011b = 00110000b
-01110000b & 10111100b = 00110000b
-01110000b & 10111101b = 00110000b
-01110000b & 10111110b = 00110000b
-01110000b & 10111111b = 00110000b
-01110000b & 11000000b = 01000000b
-01110000b & 11000001b = 01000000b
-01110000b & 11000010b = 01000000b
-01110000b & 11000011b = 01000000b
-01110000b & 11000100b = 01000000b
-01110000b & 11000101b = 01000000b
-01110000b & 11000110b = 01000000b
-01110000b & 11000111b = 01000000b
-01110000b & 11001000b = 01000000b
-01110000b & 11001001b = 01000000b
-01110000b & 11001010b = 01000000b
-01110000b & 11001011b = 01000000b
-01110000b & 11001100b = 01000000b
-01110000b & 11001101b = 01000000b
-01110000b & 11001110b = 01000000b
-01110000b & 11001111b = 01000000b
-01110000b & 11010000b = 01010000b
-01110000b & 11010001b = 01010000b
-01110000b & 11010010b = 01010000b
-01110000b & 11010011b = 01010000b
-01110000b & 11010100b = 01010000b
-01110000b & 11010101b = 01010000b
-01110000b & 11010110b = 01010000b
-01110000b & 11010111b = 01010000b
-01110000b & 11011000b = 01010000b
-01110000b & 11011001b = 01010000b
-01110000b & 11011010b = 01010000b
-01110000b & 11011011b = 01010000b
-01110000b & 11011100b = 01010000b
-01110000b & 11011101b = 01010000b
-01110000b & 11011110b = 01010000b
-01110000b & 11011111b = 01010000b
-01110000b & 11100000b = 01100000b
-01110000b & 11100001b = 01100000b
-01110000b & 11100010b = 01100000b
-01110000b & 11100011b = 01100000b
-01110000b & 11100100b = 01100000b
-01110000b & 11100101b = 01100000b
-01110000b & 11100110b = 01100000b
-01110000b & 11100111b = 01100000b
-01110000b & 11101000b = 01100000b
-01110000b & 11101001b = 01100000b
-01110000b & 11101010b = 01100000b
-01110000b & 11101011b = 01100000b
-01110000b & 11101100b = 01100000b
-01110000b & 11101101b = 01100000b
-01110000b & 11101110b = 01100000b
-01110000b & 11101111b = 01100000b
-01110000b & 11110000b = 01110000b
-01110000b & 11110001b = 01110000b
-01110000b & 11110010b = 01110000b
-01110000b & 11110011b = 01110000b
-01110000b & 11110100b = 01110000b
-01110000b & 11110101b = 01110000b
-01110000b & 11110110b = 01110000b
-01110000b & 11110111b = 01110000b
-01110000b & 11111000b = 01110000b
-01110000b & 11111001b = 01110000b
-01110000b & 11111010b = 01110000b
-01110000b & 11111011b = 01110000b
-01110000b & 11111100b = 01110000b
-01110000b & 11111101b = 01110000b
-01110000b & 11111110b = 01110000b
-01110000b & 11111111b = 01110000b
-01110000b & 00000000b = 00000000b
-01110000b & 00000001b = 00000000b
-01110000b & 00000010b = 00000000b
-01110000b & 00000011b = 00000000b
-01110000b & 00000100b = 00000000b
-01110000b & 00000101b = 00000000b
-01110000b & 00000110b = 00000000b
-01110000b & 00000111b = 00000000b
-01110000b & 00001000b = 00000000b
-01110000b & 00001001b = 00000000b
-01110000b & 00001010b = 00000000b
-01110000b & 00001011b = 00000000b
-01110000b & 00001100b = 00000000b
-01110000b & 00001101b = 00000000b
-01110000b & 00001110b = 00000000b
-01110000b & 00001111b = 00000000b
-01110000b & 00010000b = 00010000b
-01110000b & 00010001b = 00010000b
-01110000b & 00010010b = 00010000b
-01110000b & 00010011b = 00010000b
-01110000b & 00010100b = 00010000b
-01110000b & 00010101b = 00010000b
-01110000b & 00010110b = 00010000b
-01110000b & 00010111b = 00010000b
-01110000b & 00011000b = 00010000b
-01110000b & 00011001b = 00010000b
-01110000b & 00011010b = 00010000b
-01110000b & 00011011b = 00010000b
-01110000b & 00011100b = 00010000b
-01110000b & 00011101b = 00010000b
-01110000b & 00011110b = 00010000b
-01110000b & 00011111b = 00010000b
-01110000b & 00100000b = 00100000b
-01110000b & 00100001b = 00100000b
-01110000b & 00100010b = 00100000b
-01110000b & 00100011b = 00100000b
-01110000b & 00100100b = 00100000b
-01110000b & 00100101b = 00100000b
-01110000b & 00100110b = 00100000b
-01110000b & 00100111b = 00100000b
-01110000b & 00101000b = 00100000b
-01110000b & 00101001b = 00100000b
-01110000b & 00101010b = 00100000b
-01110000b & 00101011b = 00100000b
-01110000b & 00101100b = 00100000b
-01110000b & 00101101b = 00100000b
-01110000b & 00101110b = 00100000b
-01110000b & 00101111b = 00100000b
-01110000b & 00110000b = 00110000b
-01110000b & 00110001b = 00110000b
-01110000b & 00110010b = 00110000b
-01110000b & 00110011b = 00110000b
-01110000b & 00110100b = 00110000b
-01110000b & 00110101b = 00110000b
-01110000b & 00110110b = 00110000b
-01110000b & 00110111b = 00110000b
-01110000b & 00111000b = 00110000b
-01110000b & 00111001b = 00110000b
-01110000b & 00111010b = 00110000b
-01110000b & 00111011b = 00110000b
-01110000b & 00111100b = 00110000b
-01110000b & 00111101b = 00110000b
-01110000b & 00111110b = 00110000b
-01110000b & 00111111b = 00110000b
-01110000b & 01000000b = 01000000b
-01110000b & 01000001b = 01000000b
-01110000b & 01000010b = 01000000b
-01110000b & 01000011b = 01000000b
-01110000b & 01000100b = 01000000b
-01110000b & 01000101b = 01000000b
-01110000b & 01000110b = 01000000b
-01110000b & 01000111b = 01000000b
-01110000b & 01001000b = 01000000b
-01110000b & 01001001b = 01000000b
-01110000b & 01001010b = 01000000b
-01110000b & 01001011b = 01000000b
-01110000b & 01001100b = 01000000b
-01110000b & 01001101b = 01000000b
-01110000b & 01001110b = 01000000b
-01110000b & 01001111b = 01000000b
-01110000b & 01010000b = 01010000b
-01110000b & 01010001b = 01010000b
-01110000b & 01010010b = 01010000b
-01110000b & 01010011b = 01010000b
-01110000b & 01010100b = 01010000b
-01110000b & 01010101b = 01010000b
-01110000b & 01010110b = 01010000b
-01110000b & 01010111b = 01010000b
-01110000b & 01011000b = 01010000b
-01110000b & 01011001b = 01010000b
-01110000b & 01011010b = 01010000b
-01110000b & 01011011b = 01010000b
-01110000b & 01011100b = 01010000b
-01110000b & 01011101b = 01010000b
-01110000b & 01011110b = 01010000b
-01110000b & 01011111b = 01010000b
-01110000b & 01100000b = 01100000b
-01110000b & 01100001b = 01100000b
-01110000b & 01100010b = 01100000b
-01110000b & 01100011b = 01100000b
-01110000b & 01100100b = 01100000b
-01110000b & 01100101b = 01100000b
-01110000b & 01100110b = 01100000b
-01110000b & 01100111b = 01100000b
-01110000b & 01101000b = 01100000b
-01110000b & 01101001b = 01100000b
-01110000b & 01101010b = 01100000b
-01110000b & 01101011b = 01100000b
-01110000b & 01101100b = 01100000b
-01110000b & 01101101b = 01100000b
-01110000b & 01101110b = 01100000b
-01110000b & 01101111b = 01100000b
-01110000b & 01110000b = 01110000b
-01110000b & 01110001b = 01110000b
-01110000b & 01110010b = 01110000b
-01110000b & 01110011b = 01110000b
-01110000b & 01110100b = 01110000b
-01110000b & 01110101b = 01110000b
-01110000b & 01110110b = 01110000b
-01110000b & 01110111b = 01110000b
-01110000b & 01111000b = 01110000b
-01110000b & 01111001b = 01110000b
-01110000b & 01111010b = 01110000b
-01110000b & 01111011b = 01110000b
-01110000b & 01111100b = 01110000b
-01110000b & 01111101b = 01110000b
-01110000b & 01111110b = 01110000b
-01110001b & 10000000b = 00000000b
-01110001b & 10000001b = 00000001b
-01110001b & 10000010b = 00000000b
-01110001b & 10000011b = 00000001b
-01110001b & 10000100b = 00000000b
-01110001b & 10000101b = 00000001b
-01110001b & 10000110b = 00000000b
-01110001b & 10000111b = 00000001b
-01110001b & 10001000b = 00000000b
-01110001b & 10001001b = 00000001b
-01110001b & 10001010b = 00000000b
-01110001b & 10001011b = 00000001b
-01110001b & 10001100b = 00000000b
-01110001b & 10001101b = 00000001b
-01110001b & 10001110b = 00000000b
-01110001b & 10001111b = 00000001b
-01110001b & 10010000b = 00010000b
-01110001b & 10010001b = 00010001b
-01110001b & 10010010b = 00010000b
-01110001b & 10010011b = 00010001b
-01110001b & 10010100b = 00010000b
-01110001b & 10010101b = 00010001b
-01110001b & 10010110b = 00010000b
-01110001b & 10010111b = 00010001b
-01110001b & 10011000b = 00010000b
-01110001b & 10011001b = 00010001b
-01110001b & 10011010b = 00010000b
-01110001b & 10011011b = 00010001b
-01110001b & 10011100b = 00010000b
-01110001b & 10011101b = 00010001b
-01110001b & 10011110b = 00010000b
-01110001b & 10011111b = 00010001b
-01110001b & 10100000b = 00100000b
-01110001b & 10100001b = 00100001b
-01110001b & 10100010b = 00100000b
-01110001b & 10100011b = 00100001b
-01110001b & 10100100b = 00100000b
-01110001b & 10100101b = 00100001b
-01110001b & 10100110b = 00100000b
-01110001b & 10100111b = 00100001b
-01110001b & 10101000b = 00100000b
-01110001b & 10101001b = 00100001b
-01110001b & 10101010b = 00100000b
-01110001b & 10101011b = 00100001b
-01110001b & 10101100b = 00100000b
-01110001b & 10101101b = 00100001b
-01110001b & 10101110b = 00100000b
-01110001b & 10101111b = 00100001b
-01110001b & 10110000b = 00110000b
-01110001b & 10110001b = 00110001b
-01110001b & 10110010b = 00110000b
-01110001b & 10110011b = 00110001b
-01110001b & 10110100b = 00110000b
-01110001b & 10110101b = 00110001b
-01110001b & 10110110b = 00110000b
-01110001b & 10110111b = 00110001b
-01110001b & 10111000b = 00110000b
-01110001b & 10111001b = 00110001b
-01110001b & 10111010b = 00110000b
-01110001b & 10111011b = 00110001b
-01110001b & 10111100b = 00110000b
-01110001b & 10111101b = 00110001b
-01110001b & 10111110b = 00110000b
-01110001b & 10111111b = 00110001b
-01110001b & 11000000b = 01000000b
-01110001b & 11000001b = 01000001b
-01110001b & 11000010b = 01000000b
-01110001b & 11000011b = 01000001b
-01110001b & 11000100b = 01000000b
-01110001b & 11000101b = 01000001b
-01110001b & 11000110b = 01000000b
-01110001b & 11000111b = 01000001b
-01110001b & 11001000b = 01000000b
-01110001b & 11001001b = 01000001b
-01110001b & 11001010b = 01000000b
-01110001b & 11001011b = 01000001b
-01110001b & 11001100b = 01000000b
-01110001b & 11001101b = 01000001b
-01110001b & 11001110b = 01000000b
-01110001b & 11001111b = 01000001b
-01110001b & 11010000b = 01010000b
-01110001b & 11010001b = 01010001b
-01110001b & 11010010b = 01010000b
-01110001b & 11010011b = 01010001b
-01110001b & 11010100b = 01010000b
-01110001b & 11010101b = 01010001b
-01110001b & 11010110b = 01010000b
-01110001b & 11010111b = 01010001b
-01110001b & 11011000b = 01010000b
-01110001b & 11011001b = 01010001b
-01110001b & 11011010b = 01010000b
-01110001b & 11011011b = 01010001b
-01110001b & 11011100b = 01010000b
-01110001b & 11011101b = 01010001b
-01110001b & 11011110b = 01010000b
-01110001b & 11011111b = 01010001b
-01110001b & 11100000b = 01100000b
-01110001b & 11100001b = 01100001b
-01110001b & 11100010b = 01100000b
-01110001b & 11100011b = 01100001b
-01110001b & 11100100b = 01100000b
-01110001b & 11100101b = 01100001b
-01110001b & 11100110b = 01100000b
-01110001b & 11100111b = 01100001b
-01110001b & 11101000b = 01100000b
-01110001b & 11101001b = 01100001b
-01110001b & 11101010b = 01100000b
-01110001b & 11101011b = 01100001b
-01110001b & 11101100b = 01100000b
-01110001b & 11101101b = 01100001b
-01110001b & 11101110b = 01100000b
-01110001b & 11101111b = 01100001b
-01110001b & 11110000b = 01110000b
-01110001b & 11110001b = 01110001b
-01110001b & 11110010b = 01110000b
-01110001b & 11110011b = 01110001b
-01110001b & 11110100b = 01110000b
-01110001b & 11110101b = 01110001b
-01110001b & 11110110b = 01110000b
-01110001b & 11110111b = 01110001b
-01110001b & 11111000b = 01110000b
-01110001b & 11111001b = 01110001b
-01110001b & 11111010b = 01110000b
-01110001b & 11111011b = 01110001b
-01110001b & 11111100b = 01110000b
-01110001b & 11111101b = 01110001b
-01110001b & 11111110b = 01110000b
-01110001b & 11111111b = 01110001b
-01110001b & 00000000b = 00000000b
-01110001b & 00000001b = 00000001b
-01110001b & 00000010b = 00000000b
-01110001b & 00000011b = 00000001b
-01110001b & 00000100b = 00000000b
-01110001b & 00000101b = 00000001b
-01110001b & 00000110b = 00000000b
-01110001b & 00000111b = 00000001b
-01110001b & 00001000b = 00000000b
-01110001b & 00001001b = 00000001b
-01110001b & 00001010b = 00000000b
-01110001b & 00001011b = 00000001b
-01110001b & 00001100b = 00000000b
-01110001b & 00001101b = 00000001b
-01110001b & 00001110b = 00000000b
-01110001b & 00001111b = 00000001b
-01110001b & 00010000b = 00010000b
-01110001b & 00010001b = 00010001b
-01110001b & 00010010b = 00010000b
-01110001b & 00010011b = 00010001b
-01110001b & 00010100b = 00010000b
-01110001b & 00010101b = 00010001b
-01110001b & 00010110b = 00010000b
-01110001b & 00010111b = 00010001b
-01110001b & 00011000b = 00010000b
-01110001b & 00011001b = 00010001b
-01110001b & 00011010b = 00010000b
-01110001b & 00011011b = 00010001b
-01110001b & 00011100b = 00010000b
-01110001b & 00011101b = 00010001b
-01110001b & 00011110b = 00010000b
-01110001b & 00011111b = 00010001b
-01110001b & 00100000b = 00100000b
-01110001b & 00100001b = 00100001b
-01110001b & 00100010b = 00100000b
-01110001b & 00100011b = 00100001b
-01110001b & 00100100b = 00100000b
-01110001b & 00100101b = 00100001b
-01110001b & 00100110b = 00100000b
-01110001b & 00100111b = 00100001b
-01110001b & 00101000b = 00100000b
-01110001b & 00101001b = 00100001b
-01110001b & 00101010b = 00100000b
-01110001b & 00101011b = 00100001b
-01110001b & 00101100b = 00100000b
-01110001b & 00101101b = 00100001b
-01110001b & 00101110b = 00100000b
-01110001b & 00101111b = 00100001b
-01110001b & 00110000b = 00110000b
-01110001b & 00110001b = 00110001b
-01110001b & 00110010b = 00110000b
-01110001b & 00110011b = 00110001b
-01110001b & 00110100b = 00110000b
-01110001b & 00110101b = 00110001b
-01110001b & 00110110b = 00110000b
-01110001b & 00110111b = 00110001b
-01110001b & 00111000b = 00110000b
-01110001b & 00111001b = 00110001b
-01110001b & 00111010b = 00110000b
-01110001b & 00111011b = 00110001b
-01110001b & 00111100b = 00110000b
-01110001b & 00111101b = 00110001b
-01110001b & 00111110b = 00110000b
-01110001b & 00111111b = 00110001b
-01110001b & 01000000b = 01000000b
-01110001b & 01000001b = 01000001b
-01110001b & 01000010b = 01000000b
-01110001b & 01000011b = 01000001b
-01110001b & 01000100b = 01000000b
-01110001b & 01000101b = 01000001b
-01110001b & 01000110b = 01000000b
-01110001b & 01000111b = 01000001b
-01110001b & 01001000b = 01000000b
-01110001b & 01001001b = 01000001b
-01110001b & 01001010b = 01000000b
-01110001b & 01001011b = 01000001b
-01110001b & 01001100b = 01000000b
-01110001b & 01001101b = 01000001b
-01110001b & 01001110b = 01000000b
-01110001b & 01001111b = 01000001b
-01110001b & 01010000b = 01010000b
-01110001b & 01010001b = 01010001b
-01110001b & 01010010b = 01010000b
-01110001b & 01010011b = 01010001b
-01110001b & 01010100b = 01010000b
-01110001b & 01010101b = 01010001b
-01110001b & 01010110b = 01010000b
-01110001b & 01010111b = 01010001b
-01110001b & 01011000b = 01010000b
-01110001b & 01011001b = 01010001b
-01110001b & 01011010b = 01010000b
-01110001b & 01011011b = 01010001b
-01110001b & 01011100b = 01010000b
-01110001b & 01011101b = 01010001b
-01110001b & 01011110b = 01010000b
-01110001b & 01011111b = 01010001b
-01110001b & 01100000b = 01100000b
-01110001b & 01100001b = 01100001b
-01110001b & 01100010b = 01100000b
-01110001b & 01100011b = 01100001b
-01110001b & 01100100b = 01100000b
-01110001b & 01100101b = 01100001b
-01110001b & 01100110b = 01100000b
-01110001b & 01100111b = 01100001b
-01110001b & 01101000b = 01100000b
-01110001b & 01101001b = 01100001b
-01110001b & 01101010b = 01100000b
-01110001b & 01101011b = 01100001b
-01110001b & 01101100b = 01100000b
-01110001b & 01101101b = 01100001b
-01110001b & 01101110b = 01100000b
-01110001b & 01101111b = 01100001b
-01110001b & 01110000b = 01110000b
-01110001b & 01110001b = 01110001b
-01110001b & 01110010b = 01110000b
-01110001b & 01110011b = 01110001b
-01110001b & 01110100b = 01110000b
-01110001b & 01110101b = 01110001b
-01110001b & 01110110b = 01110000b
-01110001b & 01110111b = 01110001b
-01110001b & 01111000b = 01110000b
-01110001b & 01111001b = 01110001b
-01110001b & 01111010b = 01110000b
-01110001b & 01111011b = 01110001b
-01110001b & 01111100b = 01110000b
-01110001b & 01111101b = 01110001b
-01110001b & 01111110b = 01110000b
-01110010b & 10000000b = 00000000b
-01110010b & 10000001b = 00000000b
-01110010b & 10000010b = 00000010b
-01110010b & 10000011b = 00000010b
-01110010b & 10000100b = 00000000b
-01110010b & 10000101b = 00000000b
-01110010b & 10000110b = 00000010b
-01110010b & 10000111b = 00000010b
-01110010b & 10001000b = 00000000b
-01110010b & 10001001b = 00000000b
-01110010b & 10001010b = 00000010b
-01110010b & 10001011b = 00000010b
-01110010b & 10001100b = 00000000b
-01110010b & 10001101b = 00000000b
-01110010b & 10001110b = 00000010b
-01110010b & 10001111b = 00000010b
-01110010b & 10010000b = 00010000b
-01110010b & 10010001b = 00010000b
-01110010b & 10010010b = 00010010b
-01110010b & 10010011b = 00010010b
-01110010b & 10010100b = 00010000b
-01110010b & 10010101b = 00010000b
-01110010b & 10010110b = 00010010b
-01110010b & 10010111b = 00010010b
-01110010b & 10011000b = 00010000b
-01110010b & 10011001b = 00010000b
-01110010b & 10011010b = 00010010b
-01110010b & 10011011b = 00010010b
-01110010b & 10011100b = 00010000b
-01110010b & 10011101b = 00010000b
-01110010b & 10011110b = 00010010b
-01110010b & 10011111b = 00010010b
-01110010b & 10100000b = 00100000b
-01110010b & 10100001b = 00100000b
-01110010b & 10100010b = 00100010b
-01110010b & 10100011b = 00100010b
-01110010b & 10100100b = 00100000b
-01110010b & 10100101b = 00100000b
-01110010b & 10100110b = 00100010b
-01110010b & 10100111b = 00100010b
-01110010b & 10101000b = 00100000b
-01110010b & 10101001b = 00100000b
-01110010b & 10101010b = 00100010b
-01110010b & 10101011b = 00100010b
-01110010b & 10101100b = 00100000b
-01110010b & 10101101b = 00100000b
-01110010b & 10101110b = 00100010b
-01110010b & 10101111b = 00100010b
-01110010b & 10110000b = 00110000b
-01110010b & 10110001b = 00110000b
-01110010b & 10110010b = 00110010b
-01110010b & 10110011b = 00110010b
-01110010b & 10110100b = 00110000b
-01110010b & 10110101b = 00110000b
-01110010b & 10110110b = 00110010b
-01110010b & 10110111b = 00110010b
-01110010b & 10111000b = 00110000b
-01110010b & 10111001b = 00110000b
-01110010b & 10111010b = 00110010b
-01110010b & 10111011b = 00110010b
-01110010b & 10111100b = 00110000b
-01110010b & 10111101b = 00110000b
-01110010b & 10111110b = 00110010b
-01110010b & 10111111b = 00110010b
-01110010b & 11000000b = 01000000b
-01110010b & 11000001b = 01000000b
-01110010b & 11000010b = 01000010b
-01110010b & 11000011b = 01000010b
-01110010b & 11000100b = 01000000b
-01110010b & 11000101b = 01000000b
-01110010b & 11000110b = 01000010b
-01110010b & 11000111b = 01000010b
-01110010b & 11001000b = 01000000b
-01110010b & 11001001b = 01000000b
-01110010b & 11001010b = 01000010b
-01110010b & 11001011b = 01000010b
-01110010b & 11001100b = 01000000b
-01110010b & 11001101b = 01000000b
-01110010b & 11001110b = 01000010b
-01110010b & 11001111b = 01000010b
-01110010b & 11010000b = 01010000b
-01110010b & 11010001b = 01010000b
-01110010b & 11010010b = 01010010b
-01110010b & 11010011b = 01010010b
-01110010b & 11010100b = 01010000b
-01110010b & 11010101b = 01010000b
-01110010b & 11010110b = 01010010b
-01110010b & 11010111b = 01010010b
-01110010b & 11011000b = 01010000b
-01110010b & 11011001b = 01010000b
-01110010b & 11011010b = 01010010b
-01110010b & 11011011b = 01010010b
-01110010b & 11011100b = 01010000b
-01110010b & 11011101b = 01010000b
-01110010b & 11011110b = 01010010b
-01110010b & 11011111b = 01010010b
-01110010b & 11100000b = 01100000b
-01110010b & 11100001b = 01100000b
-01110010b & 11100010b = 01100010b
-01110010b & 11100011b = 01100010b
-01110010b & 11100100b = 01100000b
-01110010b & 11100101b = 01100000b
-01110010b & 11100110b = 01100010b
-01110010b & 11100111b = 01100010b
-01110010b & 11101000b = 01100000b
-01110010b & 11101001b = 01100000b
-01110010b & 11101010b = 01100010b
-01110010b & 11101011b = 01100010b
-01110010b & 11101100b = 01100000b
-01110010b & 11101101b = 01100000b
-01110010b & 11101110b = 01100010b
-01110010b & 11101111b = 01100010b
-01110010b & 11110000b = 01110000b
-01110010b & 11110001b = 01110000b
-01110010b & 11110010b = 01110010b
-01110010b & 11110011b = 01110010b
-01110010b & 11110100b = 01110000b
-01110010b & 11110101b = 01110000b
-01110010b & 11110110b = 01110010b
-01110010b & 11110111b = 01110010b
-01110010b & 11111000b = 01110000b
-01110010b & 11111001b = 01110000b
-01110010b & 11111010b = 01110010b
-01110010b & 11111011b = 01110010b
-01110010b & 11111100b = 01110000b
-01110010b & 11111101b = 01110000b
-01110010b & 11111110b = 01110010b
-01110010b & 11111111b = 01110010b
-01110010b & 00000000b = 00000000b
-01110010b & 00000001b = 00000000b
-01110010b & 00000010b = 00000010b
-01110010b & 00000011b = 00000010b
-01110010b & 00000100b = 00000000b
-01110010b & 00000101b = 00000000b
-01110010b & 00000110b = 00000010b
-01110010b & 00000111b = 00000010b
-01110010b & 00001000b = 00000000b
-01110010b & 00001001b = 00000000b
-01110010b & 00001010b = 00000010b
-01110010b & 00001011b = 00000010b
-01110010b & 00001100b = 00000000b
-01110010b & 00001101b = 00000000b
-01110010b & 00001110b = 00000010b
-01110010b & 00001111b = 00000010b
-01110010b & 00010000b = 00010000b
-01110010b & 00010001b = 00010000b
-01110010b & 00010010b = 00010010b
-01110010b & 00010011b = 00010010b
-01110010b & 00010100b = 00010000b
-01110010b & 00010101b = 00010000b
-01110010b & 00010110b = 00010010b
-01110010b & 00010111b = 00010010b
-01110010b & 00011000b = 00010000b
-01110010b & 00011001b = 00010000b
-01110010b & 00011010b = 00010010b
-01110010b & 00011011b = 00010010b
-01110010b & 00011100b = 00010000b
-01110010b & 00011101b = 00010000b
-01110010b & 00011110b = 00010010b
-01110010b & 00011111b = 00010010b
-01110010b & 00100000b = 00100000b
-01110010b & 00100001b = 00100000b
-01110010b & 00100010b = 00100010b
-01110010b & 00100011b = 00100010b
-01110010b & 00100100b = 00100000b
-01110010b & 00100101b = 00100000b
-01110010b & 00100110b = 00100010b
-01110010b & 00100111b = 00100010b
-01110010b & 00101000b = 00100000b
-01110010b & 00101001b = 00100000b
-01110010b & 00101010b = 00100010b
-01110010b & 00101011b = 00100010b
-01110010b & 00101100b = 00100000b
-01110010b & 00101101b = 00100000b
-01110010b & 00101110b = 00100010b
-01110010b & 00101111b = 00100010b
-01110010b & 00110000b = 00110000b
-01110010b & 00110001b = 00110000b
-01110010b & 00110010b = 00110010b
-01110010b & 00110011b = 00110010b
-01110010b & 00110100b = 00110000b
-01110010b & 00110101b = 00110000b
-01110010b & 00110110b = 00110010b
-01110010b & 00110111b = 00110010b
-01110010b & 00111000b = 00110000b
-01110010b & 00111001b = 00110000b
-01110010b & 00111010b = 00110010b
-01110010b & 00111011b = 00110010b
-01110010b & 00111100b = 00110000b
-01110010b & 00111101b = 00110000b
-01110010b & 00111110b = 00110010b
-01110010b & 00111111b = 00110010b
-01110010b & 01000000b = 01000000b
-01110010b & 01000001b = 01000000b
-01110010b & 01000010b = 01000010b
-01110010b & 01000011b = 01000010b
-01110010b & 01000100b = 01000000b
-01110010b & 01000101b = 01000000b
-01110010b & 01000110b = 01000010b
-01110010b & 01000111b = 01000010b
-01110010b & 01001000b = 01000000b
-01110010b & 01001001b = 01000000b
-01110010b & 01001010b = 01000010b
-01110010b & 01001011b = 01000010b
-01110010b & 01001100b = 01000000b
-01110010b & 01001101b = 01000000b
-01110010b & 01001110b = 01000010b
-01110010b & 01001111b = 01000010b
-01110010b & 01010000b = 01010000b
-01110010b & 01010001b = 01010000b
-01110010b & 01010010b = 01010010b
-01110010b & 01010011b = 01010010b
-01110010b & 01010100b = 01010000b
-01110010b & 01010101b = 01010000b
-01110010b & 01010110b = 01010010b
-01110010b & 01010111b = 01010010b
-01110010b & 01011000b = 01010000b
-01110010b & 01011001b = 01010000b
-01110010b & 01011010b = 01010010b
-01110010b & 01011011b = 01010010b
-01110010b & 01011100b = 01010000b
-01110010b & 01011101b = 01010000b
-01110010b & 01011110b = 01010010b
-01110010b & 01011111b = 01010010b
-01110010b & 01100000b = 01100000b
-01110010b & 01100001b = 01100000b
-01110010b & 01100010b = 01100010b
-01110010b & 01100011b = 01100010b
-01110010b & 01100100b = 01100000b
-01110010b & 01100101b = 01100000b
-01110010b & 01100110b = 01100010b
-01110010b & 01100111b = 01100010b
-01110010b & 01101000b = 01100000b
-01110010b & 01101001b = 01100000b
-01110010b & 01101010b = 01100010b
-01110010b & 01101011b = 01100010b
-01110010b & 01101100b = 01100000b
-01110010b & 01101101b = 01100000b
-01110010b & 01101110b = 01100010b
-01110010b & 01101111b = 01100010b
-01110010b & 01110000b = 01110000b
-01110010b & 01110001b = 01110000b
-01110010b & 01110010b = 01110010b
-01110010b & 01110011b = 01110010b
-01110010b & 01110100b = 01110000b
-01110010b & 01110101b = 01110000b
-01110010b & 01110110b = 01110010b
-01110010b & 01110111b = 01110010b
-01110010b & 01111000b = 01110000b
-01110010b & 01111001b = 01110000b
-01110010b & 01111010b = 01110010b
-01110010b & 01111011b = 01110010b
-01110010b & 01111100b = 01110000b
-01110010b & 01111101b = 01110000b
-01110010b & 01111110b = 01110010b
-01110011b & 10000000b = 00000000b
-01110011b & 10000001b = 00000001b
-01110011b & 10000010b = 00000010b
-01110011b & 10000011b = 00000011b
-01110011b & 10000100b = 00000000b
-01110011b & 10000101b = 00000001b
-01110011b & 10000110b = 00000010b
-01110011b & 10000111b = 00000011b
-01110011b & 10001000b = 00000000b
-01110011b & 10001001b = 00000001b
-01110011b & 10001010b = 00000010b
-01110011b & 10001011b = 00000011b
-01110011b & 10001100b = 00000000b
-01110011b & 10001101b = 00000001b
-01110011b & 10001110b = 00000010b
-01110011b & 10001111b = 00000011b
-01110011b & 10010000b = 00010000b
-01110011b & 10010001b = 00010001b
-01110011b & 10010010b = 00010010b
-01110011b & 10010011b = 00010011b
-01110011b & 10010100b = 00010000b
-01110011b & 10010101b = 00010001b
-01110011b & 10010110b = 00010010b
-01110011b & 10010111b = 00010011b
-01110011b & 10011000b = 00010000b
-01110011b & 10011001b = 00010001b
-01110011b & 10011010b = 00010010b
-01110011b & 10011011b = 00010011b
-01110011b & 10011100b = 00010000b
-01110011b & 10011101b = 00010001b
-01110011b & 10011110b = 00010010b
-01110011b & 10011111b = 00010011b
-01110011b & 10100000b = 00100000b
-01110011b & 10100001b = 00100001b
-01110011b & 10100010b = 00100010b
-01110011b & 10100011b = 00100011b
-01110011b & 10100100b = 00100000b
-01110011b & 10100101b = 00100001b
-01110011b & 10100110b = 00100010b
-01110011b & 10100111b = 00100011b
-01110011b & 10101000b = 00100000b
-01110011b & 10101001b = 00100001b
-01110011b & 10101010b = 00100010b
-01110011b & 10101011b = 00100011b
-01110011b & 10101100b = 00100000b
-01110011b & 10101101b = 00100001b
-01110011b & 10101110b = 00100010b
-01110011b & 10101111b = 00100011b
-01110011b & 10110000b = 00110000b
-01110011b & 10110001b = 00110001b
-01110011b & 10110010b = 00110010b
-01110011b & 10110011b = 00110011b
-01110011b & 10110100b = 00110000b
-01110011b & 10110101b = 00110001b
-01110011b & 10110110b = 00110010b
-01110011b & 10110111b = 00110011b
-01110011b & 10111000b = 00110000b
-01110011b & 10111001b = 00110001b
-01110011b & 10111010b = 00110010b
-01110011b & 10111011b = 00110011b
-01110011b & 10111100b = 00110000b
-01110011b & 10111101b = 00110001b
-01110011b & 10111110b = 00110010b
-01110011b & 10111111b = 00110011b
-01110011b & 11000000b = 01000000b
-01110011b & 11000001b = 01000001b
-01110011b & 11000010b = 01000010b
-01110011b & 11000011b = 01000011b
-01110011b & 11000100b = 01000000b
-01110011b & 11000101b = 01000001b
-01110011b & 11000110b = 01000010b
-01110011b & 11000111b = 01000011b
-01110011b & 11001000b = 01000000b
-01110011b & 11001001b = 01000001b
-01110011b & 11001010b = 01000010b
-01110011b & 11001011b = 01000011b
-01110011b & 11001100b = 01000000b
-01110011b & 11001101b = 01000001b
-01110011b & 11001110b = 01000010b
-01110011b & 11001111b = 01000011b
-01110011b & 11010000b = 01010000b
-01110011b & 11010001b = 01010001b
-01110011b & 11010010b = 01010010b
-01110011b & 11010011b = 01010011b
-01110011b & 11010100b = 01010000b
-01110011b & 11010101b = 01010001b
-01110011b & 11010110b = 01010010b
-01110011b & 11010111b = 01010011b
-01110011b & 11011000b = 01010000b
-01110011b & 11011001b = 01010001b
-01110011b & 11011010b = 01010010b
-01110011b & 11011011b = 01010011b
-01110011b & 11011100b = 01010000b
-01110011b & 11011101b = 01010001b
-01110011b & 11011110b = 01010010b
-01110011b & 11011111b = 01010011b
-01110011b & 11100000b = 01100000b
-01110011b & 11100001b = 01100001b
-01110011b & 11100010b = 01100010b
-01110011b & 11100011b = 01100011b
-01110011b & 11100100b = 01100000b
-01110011b & 11100101b = 01100001b
-01110011b & 11100110b = 01100010b
-01110011b & 11100111b = 01100011b
-01110011b & 11101000b = 01100000b
-01110011b & 11101001b = 01100001b
-01110011b & 11101010b = 01100010b
-01110011b & 11101011b = 01100011b
-01110011b & 11101100b = 01100000b
-01110011b & 11101101b = 01100001b
-01110011b & 11101110b = 01100010b
-01110011b & 11101111b = 01100011b
-01110011b & 11110000b = 01110000b
-01110011b & 11110001b = 01110001b
-01110011b & 11110010b = 01110010b
-01110011b & 11110011b = 01110011b
-01110011b & 11110100b = 01110000b
-01110011b & 11110101b = 01110001b
-01110011b & 11110110b = 01110010b
-01110011b & 11110111b = 01110011b
-01110011b & 11111000b = 01110000b
-01110011b & 11111001b = 01110001b
-01110011b & 11111010b = 01110010b
-01110011b & 11111011b = 01110011b
-01110011b & 11111100b = 01110000b
-01110011b & 11111101b = 01110001b
-01110011b & 11111110b = 01110010b
-01110011b & 11111111b = 01110011b
-01110011b & 00000000b = 00000000b
-01110011b & 00000001b = 00000001b
-01110011b & 00000010b = 00000010b
-01110011b & 00000011b = 00000011b
-01110011b & 00000100b = 00000000b
-01110011b & 00000101b = 00000001b
-01110011b & 00000110b = 00000010b
-01110011b & 00000111b = 00000011b
-01110011b & 00001000b = 00000000b
-01110011b & 00001001b = 00000001b
-01110011b & 00001010b = 00000010b
-01110011b & 00001011b = 00000011b
-01110011b & 00001100b = 00000000b
-01110011b & 00001101b = 00000001b
-01110011b & 00001110b = 00000010b
-01110011b & 00001111b = 00000011b
-01110011b & 00010000b = 00010000b
-01110011b & 00010001b = 00010001b
-01110011b & 00010010b = 00010010b
-01110011b & 00010011b = 00010011b
-01110011b & 00010100b = 00010000b
-01110011b & 00010101b = 00010001b
-01110011b & 00010110b = 00010010b
-01110011b & 00010111b = 00010011b
-01110011b & 00011000b = 00010000b
-01110011b & 00011001b = 00010001b
-01110011b & 00011010b = 00010010b
-01110011b & 00011011b = 00010011b
-01110011b & 00011100b = 00010000b
-01110011b & 00011101b = 00010001b
-01110011b & 00011110b = 00010010b
-01110011b & 00011111b = 00010011b
-01110011b & 00100000b = 00100000b
-01110011b & 00100001b = 00100001b
-01110011b & 00100010b = 00100010b
-01110011b & 00100011b = 00100011b
-01110011b & 00100100b = 00100000b
-01110011b & 00100101b = 00100001b
-01110011b & 00100110b = 00100010b
-01110011b & 00100111b = 00100011b
-01110011b & 00101000b = 00100000b
-01110011b & 00101001b = 00100001b
-01110011b & 00101010b = 00100010b
-01110011b & 00101011b = 00100011b
-01110011b & 00101100b = 00100000b
-01110011b & 00101101b = 00100001b
-01110011b & 00101110b = 00100010b
-01110011b & 00101111b = 00100011b
-01110011b & 00110000b = 00110000b
-01110011b & 00110001b = 00110001b
-01110011b & 00110010b = 00110010b
-01110011b & 00110011b = 00110011b
-01110011b & 00110100b = 00110000b
-01110011b & 00110101b = 00110001b
-01110011b & 00110110b = 00110010b
-01110011b & 00110111b = 00110011b
-01110011b & 00111000b = 00110000b
-01110011b & 00111001b = 00110001b
-01110011b & 00111010b = 00110010b
-01110011b & 00111011b = 00110011b
-01110011b & 00111100b = 00110000b
-01110011b & 00111101b = 00110001b
-01110011b & 00111110b = 00110010b
-01110011b & 00111111b = 00110011b
-01110011b & 01000000b = 01000000b
-01110011b & 01000001b = 01000001b
-01110011b & 01000010b = 01000010b
-01110011b & 01000011b = 01000011b
-01110011b & 01000100b = 01000000b
-01110011b & 01000101b = 01000001b
-01110011b & 01000110b = 01000010b
-01110011b & 01000111b = 01000011b
-01110011b & 01001000b = 01000000b
-01110011b & 01001001b = 01000001b
-01110011b & 01001010b = 01000010b
-01110011b & 01001011b = 01000011b
-01110011b & 01001100b = 01000000b
-01110011b & 01001101b = 01000001b
-01110011b & 01001110b = 01000010b
-01110011b & 01001111b = 01000011b
-01110011b & 01010000b = 01010000b
-01110011b & 01010001b = 01010001b
-01110011b & 01010010b = 01010010b
-01110011b & 01010011b = 01010011b
-01110011b & 01010100b = 01010000b
-01110011b & 01010101b = 01010001b
-01110011b & 01010110b = 01010010b
-01110011b & 01010111b = 01010011b
-01110011b & 01011000b = 01010000b
-01110011b & 01011001b = 01010001b
-01110011b & 01011010b = 01010010b
-01110011b & 01011011b = 01010011b
-01110011b & 01011100b = 01010000b
-01110011b & 01011101b = 01010001b
-01110011b & 01011110b = 01010010b
-01110011b & 01011111b = 01010011b
-01110011b & 01100000b = 01100000b
-01110011b & 01100001b = 01100001b
-01110011b & 01100010b = 01100010b
-01110011b & 01100011b = 01100011b
-01110011b & 01100100b = 01100000b
-01110011b & 01100101b = 01100001b
-01110011b & 01100110b = 01100010b
-01110011b & 01100111b = 01100011b
-01110011b & 01101000b = 01100000b
-01110011b & 01101001b = 01100001b
-01110011b & 01101010b = 01100010b
-01110011b & 01101011b = 01100011b
-01110011b & 01101100b = 01100000b
-01110011b & 01101101b = 01100001b
-01110011b & 01101110b = 01100010b
-01110011b & 01101111b = 01100011b
-01110011b & 01110000b = 01110000b
-01110011b & 01110001b = 01110001b
-01110011b & 01110010b = 01110010b
-01110011b & 01110011b = 01110011b
-01110011b & 01110100b = 01110000b
-01110011b & 01110101b = 01110001b
-01110011b & 01110110b = 01110010b
-01110011b & 01110111b = 01110011b
-01110011b & 01111000b = 01110000b
-01110011b & 01111001b = 01110001b
-01110011b & 01111010b = 01110010b
-01110011b & 01111011b = 01110011b
-01110011b & 01111100b = 01110000b
-01110011b & 01111101b = 01110001b
-01110011b & 01111110b = 01110010b
-01110100b & 10000000b = 00000000b
-01110100b & 10000001b = 00000000b
-01110100b & 10000010b = 00000000b
-01110100b & 10000011b = 00000000b
-01110100b & 10000100b = 00000100b
-01110100b & 10000101b = 00000100b
-01110100b & 10000110b = 00000100b
-01110100b & 10000111b = 00000100b
-01110100b & 10001000b = 00000000b
-01110100b & 10001001b = 00000000b
-01110100b & 10001010b = 00000000b
-01110100b & 10001011b = 00000000b
-01110100b & 10001100b = 00000100b
-01110100b & 10001101b = 00000100b
-01110100b & 10001110b = 00000100b
-01110100b & 10001111b = 00000100b
-01110100b & 10010000b = 00010000b
-01110100b & 10010001b = 00010000b
-01110100b & 10010010b = 00010000b
-01110100b & 10010011b = 00010000b
-01110100b & 10010100b = 00010100b
-01110100b & 10010101b = 00010100b
-01110100b & 10010110b = 00010100b
-01110100b & 10010111b = 00010100b
-01110100b & 10011000b = 00010000b
-01110100b & 10011001b = 00010000b
-01110100b & 10011010b = 00010000b
-01110100b & 10011011b = 00010000b
-01110100b & 10011100b = 00010100b
-01110100b & 10011101b = 00010100b
-01110100b & 10011110b = 00010100b
-01110100b & 10011111b = 00010100b
-01110100b & 10100000b = 00100000b
-01110100b & 10100001b = 00100000b
-01110100b & 10100010b = 00100000b
-01110100b & 10100011b = 00100000b
-01110100b & 10100100b = 00100100b
-01110100b & 10100101b = 00100100b
-01110100b & 10100110b = 00100100b
-01110100b & 10100111b = 00100100b
-01110100b & 10101000b = 00100000b
-01110100b & 10101001b = 00100000b
-01110100b & 10101010b = 00100000b
-01110100b & 10101011b = 00100000b
-01110100b & 10101100b = 00100100b
-01110100b & 10101101b = 00100100b
-01110100b & 10101110b = 00100100b
-01110100b & 10101111b = 00100100b
-01110100b & 10110000b = 00110000b
-01110100b & 10110001b = 00110000b
-01110100b & 10110010b = 00110000b
-01110100b & 10110011b = 00110000b
-01110100b & 10110100b = 00110100b
-01110100b & 10110101b = 00110100b
-01110100b & 10110110b = 00110100b
-01110100b & 10110111b = 00110100b
-01110100b & 10111000b = 00110000b
-01110100b & 10111001b = 00110000b
-01110100b & 10111010b = 00110000b
-01110100b & 10111011b = 00110000b
-01110100b & 10111100b = 00110100b
-01110100b & 10111101b = 00110100b
-01110100b & 10111110b = 00110100b
-01110100b & 10111111b = 00110100b
-01110100b & 11000000b = 01000000b
-01110100b & 11000001b = 01000000b
-01110100b & 11000010b = 01000000b
-01110100b & 11000011b = 01000000b
-01110100b & 11000100b = 01000100b
-01110100b & 11000101b = 01000100b
-01110100b & 11000110b = 01000100b
-01110100b & 11000111b = 01000100b
-01110100b & 11001000b = 01000000b
-01110100b & 11001001b = 01000000b
-01110100b & 11001010b = 01000000b
-01110100b & 11001011b = 01000000b
-01110100b & 11001100b = 01000100b
-01110100b & 11001101b = 01000100b
-01110100b & 11001110b = 01000100b
-01110100b & 11001111b = 01000100b
-01110100b & 11010000b = 01010000b
-01110100b & 11010001b = 01010000b
-01110100b & 11010010b = 01010000b
-01110100b & 11010011b = 01010000b
-01110100b & 11010100b = 01010100b
-01110100b & 11010101b = 01010100b
-01110100b & 11010110b = 01010100b
-01110100b & 11010111b = 01010100b
-01110100b & 11011000b = 01010000b
-01110100b & 11011001b = 01010000b
-01110100b & 11011010b = 01010000b
-01110100b & 11011011b = 01010000b
-01110100b & 11011100b = 01010100b
-01110100b & 11011101b = 01010100b
-01110100b & 11011110b = 01010100b
-01110100b & 11011111b = 01010100b
-01110100b & 11100000b = 01100000b
-01110100b & 11100001b = 01100000b
-01110100b & 11100010b = 01100000b
-01110100b & 11100011b = 01100000b
-01110100b & 11100100b = 01100100b
-01110100b & 11100101b = 01100100b
-01110100b & 11100110b = 01100100b
-01110100b & 11100111b = 01100100b
-01110100b & 11101000b = 01100000b
-01110100b & 11101001b = 01100000b
-01110100b & 11101010b = 01100000b
-01110100b & 11101011b = 01100000b
-01110100b & 11101100b = 01100100b
-01110100b & 11101101b = 01100100b
-01110100b & 11101110b = 01100100b
-01110100b & 11101111b = 01100100b
-01110100b & 11110000b = 01110000b
-01110100b & 11110001b = 01110000b
-01110100b & 11110010b = 01110000b
-01110100b & 11110011b = 01110000b
-01110100b & 11110100b = 01110100b
-01110100b & 11110101b = 01110100b
-01110100b & 11110110b = 01110100b
-01110100b & 11110111b = 01110100b
-01110100b & 11111000b = 01110000b
-01110100b & 11111001b = 01110000b
-01110100b & 11111010b = 01110000b
-01110100b & 11111011b = 01110000b
-01110100b & 11111100b = 01110100b
-01110100b & 11111101b = 01110100b
-01110100b & 11111110b = 01110100b
-01110100b & 11111111b = 01110100b
-01110100b & 00000000b = 00000000b
-01110100b & 00000001b = 00000000b
-01110100b & 00000010b = 00000000b
-01110100b & 00000011b = 00000000b
-01110100b & 00000100b = 00000100b
-01110100b & 00000101b = 00000100b
-01110100b & 00000110b = 00000100b
-01110100b & 00000111b = 00000100b
-01110100b & 00001000b = 00000000b
-01110100b & 00001001b = 00000000b
-01110100b & 00001010b = 00000000b
-01110100b & 00001011b = 00000000b
-01110100b & 00001100b = 00000100b
-01110100b & 00001101b = 00000100b
-01110100b & 00001110b = 00000100b
-01110100b & 00001111b = 00000100b
-01110100b & 00010000b = 00010000b
-01110100b & 00010001b = 00010000b
-01110100b & 00010010b = 00010000b
-01110100b & 00010011b = 00010000b
-01110100b & 00010100b = 00010100b
-01110100b & 00010101b = 00010100b
-01110100b & 00010110b = 00010100b
-01110100b & 00010111b = 00010100b
-01110100b & 00011000b = 00010000b
-01110100b & 00011001b = 00010000b
-01110100b & 00011010b = 00010000b
-01110100b & 00011011b = 00010000b
-01110100b & 00011100b = 00010100b
-01110100b & 00011101b = 00010100b
-01110100b & 00011110b = 00010100b
-01110100b & 00011111b = 00010100b
-01110100b & 00100000b = 00100000b
-01110100b & 00100001b = 00100000b
-01110100b & 00100010b = 00100000b
-01110100b & 00100011b = 00100000b
-01110100b & 00100100b = 00100100b
-01110100b & 00100101b = 00100100b
-01110100b & 00100110b = 00100100b
-01110100b & 00100111b = 00100100b
-01110100b & 00101000b = 00100000b
-01110100b & 00101001b = 00100000b
-01110100b & 00101010b = 00100000b
-01110100b & 00101011b = 00100000b
-01110100b & 00101100b = 00100100b
-01110100b & 00101101b = 00100100b
-01110100b & 00101110b = 00100100b
-01110100b & 00101111b = 00100100b
-01110100b & 00110000b = 00110000b
-01110100b & 00110001b = 00110000b
-01110100b & 00110010b = 00110000b
-01110100b & 00110011b = 00110000b
-01110100b & 00110100b = 00110100b
-01110100b & 00110101b = 00110100b
-01110100b & 00110110b = 00110100b
-01110100b & 00110111b = 00110100b
-01110100b & 00111000b = 00110000b
-01110100b & 00111001b = 00110000b
-01110100b & 00111010b = 00110000b
-01110100b & 00111011b = 00110000b
-01110100b & 00111100b = 00110100b
-01110100b & 00111101b = 00110100b
-01110100b & 00111110b = 00110100b
-01110100b & 00111111b = 00110100b
-01110100b & 01000000b = 01000000b
-01110100b & 01000001b = 01000000b
-01110100b & 01000010b = 01000000b
-01110100b & 01000011b = 01000000b
-01110100b & 01000100b = 01000100b
-01110100b & 01000101b = 01000100b
-01110100b & 01000110b = 01000100b
-01110100b & 01000111b = 01000100b
-01110100b & 01001000b = 01000000b
-01110100b & 01001001b = 01000000b
-01110100b & 01001010b = 01000000b
-01110100b & 01001011b = 01000000b
-01110100b & 01001100b = 01000100b
-01110100b & 01001101b = 01000100b
-01110100b & 01001110b = 01000100b
-01110100b & 01001111b = 01000100b
-01110100b & 01010000b = 01010000b
-01110100b & 01010001b = 01010000b
-01110100b & 01010010b = 01010000b
-01110100b & 01010011b = 01010000b
-01110100b & 01010100b = 01010100b
-01110100b & 01010101b = 01010100b
-01110100b & 01010110b = 01010100b
-01110100b & 01010111b = 01010100b
-01110100b & 01011000b = 01010000b
-01110100b & 01011001b = 01010000b
-01110100b & 01011010b = 01010000b
-01110100b & 01011011b = 01010000b
-01110100b & 01011100b = 01010100b
-01110100b & 01011101b = 01010100b
-01110100b & 01011110b = 01010100b
-01110100b & 01011111b = 01010100b
-01110100b & 01100000b = 01100000b
-01110100b & 01100001b = 01100000b
-01110100b & 01100010b = 01100000b
-01110100b & 01100011b = 01100000b
-01110100b & 01100100b = 01100100b
-01110100b & 01100101b = 01100100b
-01110100b & 01100110b = 01100100b
-01110100b & 01100111b = 01100100b
-01110100b & 01101000b = 01100000b
-01110100b & 01101001b = 01100000b
-01110100b & 01101010b = 01100000b
-01110100b & 01101011b = 01100000b
-01110100b & 01101100b = 01100100b
-01110100b & 01101101b = 01100100b
-01110100b & 01101110b = 01100100b
-01110100b & 01101111b = 01100100b
-01110100b & 01110000b = 01110000b
-01110100b & 01110001b = 01110000b
-01110100b & 01110010b = 01110000b
-01110100b & 01110011b = 01110000b
-01110100b & 01110100b = 01110100b
-01110100b & 01110101b = 01110100b
-01110100b & 01110110b = 01110100b
-01110100b & 01110111b = 01110100b
-01110100b & 01111000b = 01110000b
-01110100b & 01111001b = 01110000b
-01110100b & 01111010b = 01110000b
-01110100b & 01111011b = 01110000b
-01110100b & 01111100b = 01110100b
-01110100b & 01111101b = 01110100b
-01110100b & 01111110b = 01110100b
-01110101b & 10000000b = 00000000b
-01110101b & 10000001b = 00000001b
-01110101b & 10000010b = 00000000b
-01110101b & 10000011b = 00000001b
-01110101b & 10000100b = 00000100b
-01110101b & 10000101b = 00000101b
-01110101b & 10000110b = 00000100b
-01110101b & 10000111b = 00000101b
-01110101b & 10001000b = 00000000b
-01110101b & 10001001b = 00000001b
-01110101b & 10001010b = 00000000b
-01110101b & 10001011b = 00000001b
-01110101b & 10001100b = 00000100b
-01110101b & 10001101b = 00000101b
-01110101b & 10001110b = 00000100b
-01110101b & 10001111b = 00000101b
-01110101b & 10010000b = 00010000b
-01110101b & 10010001b = 00010001b
-01110101b & 10010010b = 00010000b
-01110101b & 10010011b = 00010001b
-01110101b & 10010100b = 00010100b
-01110101b & 10010101b = 00010101b
-01110101b & 10010110b = 00010100b
-01110101b & 10010111b = 00010101b
-01110101b & 10011000b = 00010000b
-01110101b & 10011001b = 00010001b
-01110101b & 10011010b = 00010000b
-01110101b & 10011011b = 00010001b
-01110101b & 10011100b = 00010100b
-01110101b & 10011101b = 00010101b
-01110101b & 10011110b = 00010100b
-01110101b & 10011111b = 00010101b
-01110101b & 10100000b = 00100000b
-01110101b & 10100001b = 00100001b
-01110101b & 10100010b = 00100000b
-01110101b & 10100011b = 00100001b
-01110101b & 10100100b = 00100100b
-01110101b & 10100101b = 00100101b
-01110101b & 10100110b = 00100100b
-01110101b & 10100111b = 00100101b
-01110101b & 10101000b = 00100000b
-01110101b & 10101001b = 00100001b
-01110101b & 10101010b = 00100000b
-01110101b & 10101011b = 00100001b
-01110101b & 10101100b = 00100100b
-01110101b & 10101101b = 00100101b
-01110101b & 10101110b = 00100100b
-01110101b & 10101111b = 00100101b
-01110101b & 10110000b = 00110000b
-01110101b & 10110001b = 00110001b
-01110101b & 10110010b = 00110000b
-01110101b & 10110011b = 00110001b
-01110101b & 10110100b = 00110100b
-01110101b & 10110101b = 00110101b
-01110101b & 10110110b = 00110100b
-01110101b & 10110111b = 00110101b
-01110101b & 10111000b = 00110000b
-01110101b & 10111001b = 00110001b
-01110101b & 10111010b = 00110000b
-01110101b & 10111011b = 00110001b
-01110101b & 10111100b = 00110100b
-01110101b & 10111101b = 00110101b
-01110101b & 10111110b = 00110100b
-01110101b & 10111111b = 00110101b
-01110101b & 11000000b = 01000000b
-01110101b & 11000001b = 01000001b
-01110101b & 11000010b = 01000000b
-01110101b & 11000011b = 01000001b
-01110101b & 11000100b = 01000100b
-01110101b & 11000101b = 01000101b
-01110101b & 11000110b = 01000100b
-01110101b & 11000111b = 01000101b
-01110101b & 11001000b = 01000000b
-01110101b & 11001001b = 01000001b
-01110101b & 11001010b = 01000000b
-01110101b & 11001011b = 01000001b
-01110101b & 11001100b = 01000100b
-01110101b & 11001101b = 01000101b
-01110101b & 11001110b = 01000100b
-01110101b & 11001111b = 01000101b
-01110101b & 11010000b = 01010000b
-01110101b & 11010001b = 01010001b
-01110101b & 11010010b = 01010000b
-01110101b & 11010011b = 01010001b
-01110101b & 11010100b = 01010100b
-01110101b & 11010101b = 01010101b
-01110101b & 11010110b = 01010100b
-01110101b & 11010111b = 01010101b
-01110101b & 11011000b = 01010000b
-01110101b & 11011001b = 01010001b
-01110101b & 11011010b = 01010000b
-01110101b & 11011011b = 01010001b
-01110101b & 11011100b = 01010100b
-01110101b & 11011101b = 01010101b
-01110101b & 11011110b = 01010100b
-01110101b & 11011111b = 01010101b
-01110101b & 11100000b = 01100000b
-01110101b & 11100001b = 01100001b
-01110101b & 11100010b = 01100000b
-01110101b & 11100011b = 01100001b
-01110101b & 11100100b = 01100100b
-01110101b & 11100101b = 01100101b
-01110101b & 11100110b = 01100100b
-01110101b & 11100111b = 01100101b
-01110101b & 11101000b = 01100000b
-01110101b & 11101001b = 01100001b
-01110101b & 11101010b = 01100000b
-01110101b & 11101011b = 01100001b
-01110101b & 11101100b = 01100100b
-01110101b & 11101101b = 01100101b
-01110101b & 11101110b = 01100100b
-01110101b & 11101111b = 01100101b
-01110101b & 11110000b = 01110000b
-01110101b & 11110001b = 01110001b
-01110101b & 11110010b = 01110000b
-01110101b & 11110011b = 01110001b
-01110101b & 11110100b = 01110100b
-01110101b & 11110101b = 01110101b
-01110101b & 11110110b = 01110100b
-01110101b & 11110111b = 01110101b
-01110101b & 11111000b = 01110000b
-01110101b & 11111001b = 01110001b
-01110101b & 11111010b = 01110000b
-01110101b & 11111011b = 01110001b
-01110101b & 11111100b = 01110100b
-01110101b & 11111101b = 01110101b
-01110101b & 11111110b = 01110100b
-01110101b & 11111111b = 01110101b
-01110101b & 00000000b = 00000000b
-01110101b & 00000001b = 00000001b
-01110101b & 00000010b = 00000000b
-01110101b & 00000011b = 00000001b
-01110101b & 00000100b = 00000100b
-01110101b & 00000101b = 00000101b
-01110101b & 00000110b = 00000100b
-01110101b & 00000111b = 00000101b
-01110101b & 00001000b = 00000000b
-01110101b & 00001001b = 00000001b
-01110101b & 00001010b = 00000000b
-01110101b & 00001011b = 00000001b
-01110101b & 00001100b = 00000100b
-01110101b & 00001101b = 00000101b
-01110101b & 00001110b = 00000100b
-01110101b & 00001111b = 00000101b
-01110101b & 00010000b = 00010000b
-01110101b & 00010001b = 00010001b
-01110101b & 00010010b = 00010000b
-01110101b & 00010011b = 00010001b
-01110101b & 00010100b = 00010100b
-01110101b & 00010101b = 00010101b
-01110101b & 00010110b = 00010100b
-01110101b & 00010111b = 00010101b
-01110101b & 00011000b = 00010000b
-01110101b & 00011001b = 00010001b
-01110101b & 00011010b = 00010000b
-01110101b & 00011011b = 00010001b
-01110101b & 00011100b = 00010100b
-01110101b & 00011101b = 00010101b
-01110101b & 00011110b = 00010100b
-01110101b & 00011111b = 00010101b
-01110101b & 00100000b = 00100000b
-01110101b & 00100001b = 00100001b
-01110101b & 00100010b = 00100000b
-01110101b & 00100011b = 00100001b
-01110101b & 00100100b = 00100100b
-01110101b & 00100101b = 00100101b
-01110101b & 00100110b = 00100100b
-01110101b & 00100111b = 00100101b
-01110101b & 00101000b = 00100000b
-01110101b & 00101001b = 00100001b
-01110101b & 00101010b = 00100000b
-01110101b & 00101011b = 00100001b
-01110101b & 00101100b = 00100100b
-01110101b & 00101101b = 00100101b
-01110101b & 00101110b = 00100100b
-01110101b & 00101111b = 00100101b
-01110101b & 00110000b = 00110000b
-01110101b & 00110001b = 00110001b
-01110101b & 00110010b = 00110000b
-01110101b & 00110011b = 00110001b
-01110101b & 00110100b = 00110100b
-01110101b & 00110101b = 00110101b
-01110101b & 00110110b = 00110100b
-01110101b & 00110111b = 00110101b
-01110101b & 00111000b = 00110000b
-01110101b & 00111001b = 00110001b
-01110101b & 00111010b = 00110000b
-01110101b & 00111011b = 00110001b
-01110101b & 00111100b = 00110100b
-01110101b & 00111101b = 00110101b
-01110101b & 00111110b = 00110100b
-01110101b & 00111111b = 00110101b
-01110101b & 01000000b = 01000000b
-01110101b & 01000001b = 01000001b
-01110101b & 01000010b = 01000000b
-01110101b & 01000011b = 01000001b
-01110101b & 01000100b = 01000100b
-01110101b & 01000101b = 01000101b
-01110101b & 01000110b = 01000100b
-01110101b & 01000111b = 01000101b
-01110101b & 01001000b = 01000000b
-01110101b & 01001001b = 01000001b
-01110101b & 01001010b = 01000000b
-01110101b & 01001011b = 01000001b
-01110101b & 01001100b = 01000100b
-01110101b & 01001101b = 01000101b
-01110101b & 01001110b = 01000100b
-01110101b & 01001111b = 01000101b
-01110101b & 01010000b = 01010000b
-01110101b & 01010001b = 01010001b
-01110101b & 01010010b = 01010000b
-01110101b & 01010011b = 01010001b
-01110101b & 01010100b = 01010100b
-01110101b & 01010101b = 01010101b
-01110101b & 01010110b = 01010100b
-01110101b & 01010111b = 01010101b
-01110101b & 01011000b = 01010000b
-01110101b & 01011001b = 01010001b
-01110101b & 01011010b = 01010000b
-01110101b & 01011011b = 01010001b
-01110101b & 01011100b = 01010100b
-01110101b & 01011101b = 01010101b
-01110101b & 01011110b = 01010100b
-01110101b & 01011111b = 01010101b
-01110101b & 01100000b = 01100000b
-01110101b & 01100001b = 01100001b
-01110101b & 01100010b = 01100000b
-01110101b & 01100011b = 01100001b
-01110101b & 01100100b = 01100100b
-01110101b & 01100101b = 01100101b
-01110101b & 01100110b = 01100100b
-01110101b & 01100111b = 01100101b
-01110101b & 01101000b = 01100000b
-01110101b & 01101001b = 01100001b
-01110101b & 01101010b = 01100000b
-01110101b & 01101011b = 01100001b
-01110101b & 01101100b = 01100100b
-01110101b & 01101101b = 01100101b
-01110101b & 01101110b = 01100100b
-01110101b & 01101111b = 01100101b
-01110101b & 01110000b = 01110000b
-01110101b & 01110001b = 01110001b
-01110101b & 01110010b = 01110000b
-01110101b & 01110011b = 01110001b
-01110101b & 01110100b = 01110100b
-01110101b & 01110101b = 01110101b
-01110101b & 01110110b = 01110100b
-01110101b & 01110111b = 01110101b
-01110101b & 01111000b = 01110000b
-01110101b & 01111001b = 01110001b
-01110101b & 01111010b = 01110000b
-01110101b & 01111011b = 01110001b
-01110101b & 01111100b = 01110100b
-01110101b & 01111101b = 01110101b
-01110101b & 01111110b = 01110100b
-01110110b & 10000000b = 00000000b
-01110110b & 10000001b = 00000000b
-01110110b & 10000010b = 00000010b
-01110110b & 10000011b = 00000010b
-01110110b & 10000100b = 00000100b
-01110110b & 10000101b = 00000100b
-01110110b & 10000110b = 00000110b
-01110110b & 10000111b = 00000110b
-01110110b & 10001000b = 00000000b
-01110110b & 10001001b = 00000000b
-01110110b & 10001010b = 00000010b
-01110110b & 10001011b = 00000010b
-01110110b & 10001100b = 00000100b
-01110110b & 10001101b = 00000100b
-01110110b & 10001110b = 00000110b
-01110110b & 10001111b = 00000110b
-01110110b & 10010000b = 00010000b
-01110110b & 10010001b = 00010000b
-01110110b & 10010010b = 00010010b
-01110110b & 10010011b = 00010010b
-01110110b & 10010100b = 00010100b
-01110110b & 10010101b = 00010100b
-01110110b & 10010110b = 00010110b
-01110110b & 10010111b = 00010110b
-01110110b & 10011000b = 00010000b
-01110110b & 10011001b = 00010000b
-01110110b & 10011010b = 00010010b
-01110110b & 10011011b = 00010010b
-01110110b & 10011100b = 00010100b
-01110110b & 10011101b = 00010100b
-01110110b & 10011110b = 00010110b
-01110110b & 10011111b = 00010110b
-01110110b & 10100000b = 00100000b
-01110110b & 10100001b = 00100000b
-01110110b & 10100010b = 00100010b
-01110110b & 10100011b = 00100010b
-01110110b & 10100100b = 00100100b
-01110110b & 10100101b = 00100100b
-01110110b & 10100110b = 00100110b
-01110110b & 10100111b = 00100110b
-01110110b & 10101000b = 00100000b
-01110110b & 10101001b = 00100000b
-01110110b & 10101010b = 00100010b
-01110110b & 10101011b = 00100010b
-01110110b & 10101100b = 00100100b
-01110110b & 10101101b = 00100100b
-01110110b & 10101110b = 00100110b
-01110110b & 10101111b = 00100110b
-01110110b & 10110000b = 00110000b
-01110110b & 10110001b = 00110000b
-01110110b & 10110010b = 00110010b
-01110110b & 10110011b = 00110010b
-01110110b & 10110100b = 00110100b
-01110110b & 10110101b = 00110100b
-01110110b & 10110110b = 00110110b
-01110110b & 10110111b = 00110110b
-01110110b & 10111000b = 00110000b
-01110110b & 10111001b = 00110000b
-01110110b & 10111010b = 00110010b
-01110110b & 10111011b = 00110010b
-01110110b & 10111100b = 00110100b
-01110110b & 10111101b = 00110100b
-01110110b & 10111110b = 00110110b
-01110110b & 10111111b = 00110110b
-01110110b & 11000000b = 01000000b
-01110110b & 11000001b = 01000000b
-01110110b & 11000010b = 01000010b
-01110110b & 11000011b = 01000010b
-01110110b & 11000100b = 01000100b
-01110110b & 11000101b = 01000100b
-01110110b & 11000110b = 01000110b
-01110110b & 11000111b = 01000110b
-01110110b & 11001000b = 01000000b
-01110110b & 11001001b = 01000000b
-01110110b & 11001010b = 01000010b
-01110110b & 11001011b = 01000010b
-01110110b & 11001100b = 01000100b
-01110110b & 11001101b = 01000100b
-01110110b & 11001110b = 01000110b
-01110110b & 11001111b = 01000110b
-01110110b & 11010000b = 01010000b
-01110110b & 11010001b = 01010000b
-01110110b & 11010010b = 01010010b
-01110110b & 11010011b = 01010010b
-01110110b & 11010100b = 01010100b
-01110110b & 11010101b = 01010100b
-01110110b & 11010110b = 01010110b
-01110110b & 11010111b = 01010110b
-01110110b & 11011000b = 01010000b
-01110110b & 11011001b = 01010000b
-01110110b & 11011010b = 01010010b
-01110110b & 11011011b = 01010010b
-01110110b & 11011100b = 01010100b
-01110110b & 11011101b = 01010100b
-01110110b & 11011110b = 01010110b
-01110110b & 11011111b = 01010110b
-01110110b & 11100000b = 01100000b
-01110110b & 11100001b = 01100000b
-01110110b & 11100010b = 01100010b
-01110110b & 11100011b = 01100010b
-01110110b & 11100100b = 01100100b
-01110110b & 11100101b = 01100100b
-01110110b & 11100110b = 01100110b
-01110110b & 11100111b = 01100110b
-01110110b & 11101000b = 01100000b
-01110110b & 11101001b = 01100000b
-01110110b & 11101010b = 01100010b
-01110110b & 11101011b = 01100010b
-01110110b & 11101100b = 01100100b
-01110110b & 11101101b = 01100100b
-01110110b & 11101110b = 01100110b
-01110110b & 11101111b = 01100110b
-01110110b & 11110000b = 01110000b
-01110110b & 11110001b = 01110000b
-01110110b & 11110010b = 01110010b
-01110110b & 11110011b = 01110010b
-01110110b & 11110100b = 01110100b
-01110110b & 11110101b = 01110100b
-01110110b & 11110110b = 01110110b
-01110110b & 11110111b = 01110110b
-01110110b & 11111000b = 01110000b
-01110110b & 11111001b = 01110000b
-01110110b & 11111010b = 01110010b
-01110110b & 11111011b = 01110010b
-01110110b & 11111100b = 01110100b
-01110110b & 11111101b = 01110100b
-01110110b & 11111110b = 01110110b
-01110110b & 11111111b = 01110110b
-01110110b & 00000000b = 00000000b
-01110110b & 00000001b = 00000000b
-01110110b & 00000010b = 00000010b
-01110110b & 00000011b = 00000010b
-01110110b & 00000100b = 00000100b
-01110110b & 00000101b = 00000100b
-01110110b & 00000110b = 00000110b
-01110110b & 00000111b = 00000110b
-01110110b & 00001000b = 00000000b
-01110110b & 00001001b = 00000000b
-01110110b & 00001010b = 00000010b
-01110110b & 00001011b = 00000010b
-01110110b & 00001100b = 00000100b
-01110110b & 00001101b = 00000100b
-01110110b & 00001110b = 00000110b
-01110110b & 00001111b = 00000110b
-01110110b & 00010000b = 00010000b
-01110110b & 00010001b = 00010000b
-01110110b & 00010010b = 00010010b
-01110110b & 00010011b = 00010010b
-01110110b & 00010100b = 00010100b
-01110110b & 00010101b = 00010100b
-01110110b & 00010110b = 00010110b
-01110110b & 00010111b = 00010110b
-01110110b & 00011000b = 00010000b
-01110110b & 00011001b = 00010000b
-01110110b & 00011010b = 00010010b
-01110110b & 00011011b = 00010010b
-01110110b & 00011100b = 00010100b
-01110110b & 00011101b = 00010100b
-01110110b & 00011110b = 00010110b
-01110110b & 00011111b = 00010110b
-01110110b & 00100000b = 00100000b
-01110110b & 00100001b = 00100000b
-01110110b & 00100010b = 00100010b
-01110110b & 00100011b = 00100010b
-01110110b & 00100100b = 00100100b
-01110110b & 00100101b = 00100100b
-01110110b & 00100110b = 00100110b
-01110110b & 00100111b = 00100110b
-01110110b & 00101000b = 00100000b
-01110110b & 00101001b = 00100000b
-01110110b & 00101010b = 00100010b
-01110110b & 00101011b = 00100010b
-01110110b & 00101100b = 00100100b
-01110110b & 00101101b = 00100100b
-01110110b & 00101110b = 00100110b
-01110110b & 00101111b = 00100110b
-01110110b & 00110000b = 00110000b
-01110110b & 00110001b = 00110000b
-01110110b & 00110010b = 00110010b
-01110110b & 00110011b = 00110010b
-01110110b & 00110100b = 00110100b
-01110110b & 00110101b = 00110100b
-01110110b & 00110110b = 00110110b
-01110110b & 00110111b = 00110110b
-01110110b & 00111000b = 00110000b
-01110110b & 00111001b = 00110000b
-01110110b & 00111010b = 00110010b
-01110110b & 00111011b = 00110010b
-01110110b & 00111100b = 00110100b
-01110110b & 00111101b = 00110100b
-01110110b & 00111110b = 00110110b
-01110110b & 00111111b = 00110110b
-01110110b & 01000000b = 01000000b
-01110110b & 01000001b = 01000000b
-01110110b & 01000010b = 01000010b
-01110110b & 01000011b = 01000010b
-01110110b & 01000100b = 01000100b
-01110110b & 01000101b = 01000100b
-01110110b & 01000110b = 01000110b
-01110110b & 01000111b = 01000110b
-01110110b & 01001000b = 01000000b
-01110110b & 01001001b = 01000000b
-01110110b & 01001010b = 01000010b
-01110110b & 01001011b = 01000010b
-01110110b & 01001100b = 01000100b
-01110110b & 01001101b = 01000100b
-01110110b & 01001110b = 01000110b
-01110110b & 01001111b = 01000110b
-01110110b & 01010000b = 01010000b
-01110110b & 01010001b = 01010000b
-01110110b & 01010010b = 01010010b
-01110110b & 01010011b = 01010010b
-01110110b & 01010100b = 01010100b
-01110110b & 01010101b = 01010100b
-01110110b & 01010110b = 01010110b
-01110110b & 01010111b = 01010110b
-01110110b & 01011000b = 01010000b
-01110110b & 01011001b = 01010000b
-01110110b & 01011010b = 01010010b
-01110110b & 01011011b = 01010010b
-01110110b & 01011100b = 01010100b
-01110110b & 01011101b = 01010100b
-01110110b & 01011110b = 01010110b
-01110110b & 01011111b = 01010110b
-01110110b & 01100000b = 01100000b
-01110110b & 01100001b = 01100000b
-01110110b & 01100010b = 01100010b
-01110110b & 01100011b = 01100010b
-01110110b & 01100100b = 01100100b
-01110110b & 01100101b = 01100100b
-01110110b & 01100110b = 01100110b
-01110110b & 01100111b = 01100110b
-01110110b & 01101000b = 01100000b
-01110110b & 01101001b = 01100000b
-01110110b & 01101010b = 01100010b
-01110110b & 01101011b = 01100010b
-01110110b & 01101100b = 01100100b
-01110110b & 01101101b = 01100100b
-01110110b & 01101110b = 01100110b
-01110110b & 01101111b = 01100110b
-01110110b & 01110000b = 01110000b
-01110110b & 01110001b = 01110000b
-01110110b & 01110010b = 01110010b
-01110110b & 01110011b = 01110010b
-01110110b & 01110100b = 01110100b
-01110110b & 01110101b = 01110100b
-01110110b & 01110110b = 01110110b
-01110110b & 01110111b = 01110110b
-01110110b & 01111000b = 01110000b
-01110110b & 01111001b = 01110000b
-01110110b & 01111010b = 01110010b
-01110110b & 01111011b = 01110010b
-01110110b & 01111100b = 01110100b
-01110110b & 01111101b = 01110100b
-01110110b & 01111110b = 01110110b
-01110111b & 10000000b = 00000000b
-01110111b & 10000001b = 00000001b
-01110111b & 10000010b = 00000010b
-01110111b & 10000011b = 00000011b
-01110111b & 10000100b = 00000100b
-01110111b & 10000101b = 00000101b
-01110111b & 10000110b = 00000110b
-01110111b & 10000111b = 00000111b
-01110111b & 10001000b = 00000000b
-01110111b & 10001001b = 00000001b
-01110111b & 10001010b = 00000010b
-01110111b & 10001011b = 00000011b
-01110111b & 10001100b = 00000100b
-01110111b & 10001101b = 00000101b
-01110111b & 10001110b = 00000110b
-01110111b & 10001111b = 00000111b
-01110111b & 10010000b = 00010000b
-01110111b & 10010001b = 00010001b
-01110111b & 10010010b = 00010010b
-01110111b & 10010011b = 00010011b
-01110111b & 10010100b = 00010100b
-01110111b & 10010101b = 00010101b
-01110111b & 10010110b = 00010110b
-01110111b & 10010111b = 00010111b
-01110111b & 10011000b = 00010000b
-01110111b & 10011001b = 00010001b
-01110111b & 10011010b = 00010010b
-01110111b & 10011011b = 00010011b
-01110111b & 10011100b = 00010100b
-01110111b & 10011101b = 00010101b
-01110111b & 10011110b = 00010110b
-01110111b & 10011111b = 00010111b
-01110111b & 10100000b = 00100000b
-01110111b & 10100001b = 00100001b
-01110111b & 10100010b = 00100010b
-01110111b & 10100011b = 00100011b
-01110111b & 10100100b = 00100100b
-01110111b & 10100101b = 00100101b
-01110111b & 10100110b = 00100110b
-01110111b & 10100111b = 00100111b
-01110111b & 10101000b = 00100000b
-01110111b & 10101001b = 00100001b
-01110111b & 10101010b = 00100010b
-01110111b & 10101011b = 00100011b
-01110111b & 10101100b = 00100100b
-01110111b & 10101101b = 00100101b
-01110111b & 10101110b = 00100110b
-01110111b & 10101111b = 00100111b
-01110111b & 10110000b = 00110000b
-01110111b & 10110001b = 00110001b
-01110111b & 10110010b = 00110010b
-01110111b & 10110011b = 00110011b
-01110111b & 10110100b = 00110100b
-01110111b & 10110101b = 00110101b
-01110111b & 10110110b = 00110110b
-01110111b & 10110111b = 00110111b
-01110111b & 10111000b = 00110000b
-01110111b & 10111001b = 00110001b
-01110111b & 10111010b = 00110010b
-01110111b & 10111011b = 00110011b
-01110111b & 10111100b = 00110100b
-01110111b & 10111101b = 00110101b
-01110111b & 10111110b = 00110110b
-01110111b & 10111111b = 00110111b
-01110111b & 11000000b = 01000000b
-01110111b & 11000001b = 01000001b
-01110111b & 11000010b = 01000010b
-01110111b & 11000011b = 01000011b
-01110111b & 11000100b = 01000100b
-01110111b & 11000101b = 01000101b
-01110111b & 11000110b = 01000110b
-01110111b & 11000111b = 01000111b
-01110111b & 11001000b = 01000000b
-01110111b & 11001001b = 01000001b
-01110111b & 11001010b = 01000010b
-01110111b & 11001011b = 01000011b
-01110111b & 11001100b = 01000100b
-01110111b & 11001101b = 01000101b
-01110111b & 11001110b = 01000110b
-01110111b & 11001111b = 01000111b
-01110111b & 11010000b = 01010000b
-01110111b & 11010001b = 01010001b
-01110111b & 11010010b = 01010010b
-01110111b & 11010011b = 01010011b
-01110111b & 11010100b = 01010100b
-01110111b & 11010101b = 01010101b
-01110111b & 11010110b = 01010110b
-01110111b & 11010111b = 01010111b
-01110111b & 11011000b = 01010000b
-01110111b & 11011001b = 01010001b
-01110111b & 11011010b = 01010010b
-01110111b & 11011011b = 01010011b
-01110111b & 11011100b = 01010100b
-01110111b & 11011101b = 01010101b
-01110111b & 11011110b = 01010110b
-01110111b & 11011111b = 01010111b
-01110111b & 11100000b = 01100000b
-01110111b & 11100001b = 01100001b
-01110111b & 11100010b = 01100010b
-01110111b & 11100011b = 01100011b
-01110111b & 11100100b = 01100100b
-01110111b & 11100101b = 01100101b
-01110111b & 11100110b = 01100110b
-01110111b & 11100111b = 01100111b
-01110111b & 11101000b = 01100000b
-01110111b & 11101001b = 01100001b
-01110111b & 11101010b = 01100010b
-01110111b & 11101011b = 01100011b
-01110111b & 11101100b = 01100100b
-01110111b & 11101101b = 01100101b
-01110111b & 11101110b = 01100110b
-01110111b & 11101111b = 01100111b
-01110111b & 11110000b = 01110000b
-01110111b & 11110001b = 01110001b
-01110111b & 11110010b = 01110010b
-01110111b & 11110011b = 01110011b
-01110111b & 11110100b = 01110100b
-01110111b & 11110101b = 01110101b
-01110111b & 11110110b = 01110110b
-01110111b & 11110111b = 01110111b
-01110111b & 11111000b = 01110000b
-01110111b & 11111001b = 01110001b
-01110111b & 11111010b = 01110010b
-01110111b & 11111011b = 01110011b
-01110111b & 11111100b = 01110100b
-01110111b & 11111101b = 01110101b
-01110111b & 11111110b = 01110110b
-01110111b & 11111111b = 01110111b
-01110111b & 00000000b = 00000000b
-01110111b & 00000001b = 00000001b
-01110111b & 00000010b = 00000010b
-01110111b & 00000011b = 00000011b
-01110111b & 00000100b = 00000100b
-01110111b & 00000101b = 00000101b
-01110111b & 00000110b = 00000110b
-01110111b & 00000111b = 00000111b
-01110111b & 00001000b = 00000000b
-01110111b & 00001001b = 00000001b
-01110111b & 00001010b = 00000010b
-01110111b & 00001011b = 00000011b
-01110111b & 00001100b = 00000100b
-01110111b & 00001101b = 00000101b
-01110111b & 00001110b = 00000110b
-01110111b & 00001111b = 00000111b
-01110111b & 00010000b = 00010000b
-01110111b & 00010001b = 00010001b
-01110111b & 00010010b = 00010010b
-01110111b & 00010011b = 00010011b
-01110111b & 00010100b = 00010100b
-01110111b & 00010101b = 00010101b
-01110111b & 00010110b = 00010110b
-01110111b & 00010111b = 00010111b
-01110111b & 00011000b = 00010000b
-01110111b & 00011001b = 00010001b
-01110111b & 00011010b = 00010010b
-01110111b & 00011011b = 00010011b
-01110111b & 00011100b = 00010100b
-01110111b & 00011101b = 00010101b
-01110111b & 00011110b = 00010110b
-01110111b & 00011111b = 00010111b
-01110111b & 00100000b = 00100000b
-01110111b & 00100001b = 00100001b
-01110111b & 00100010b = 00100010b
-01110111b & 00100011b = 00100011b
-01110111b & 00100100b = 00100100b
-01110111b & 00100101b = 00100101b
-01110111b & 00100110b = 00100110b
-01110111b & 00100111b = 00100111b
-01110111b & 00101000b = 00100000b
-01110111b & 00101001b = 00100001b
-01110111b & 00101010b = 00100010b
-01110111b & 00101011b = 00100011b
-01110111b & 00101100b = 00100100b
-01110111b & 00101101b = 00100101b
-01110111b & 00101110b = 00100110b
-01110111b & 00101111b = 00100111b
-01110111b & 00110000b = 00110000b
-01110111b & 00110001b = 00110001b
-01110111b & 00110010b = 00110010b
-01110111b & 00110011b = 00110011b
-01110111b & 00110100b = 00110100b
-01110111b & 00110101b = 00110101b
-01110111b & 00110110b = 00110110b
-01110111b & 00110111b = 00110111b
-01110111b & 00111000b = 00110000b
-01110111b & 00111001b = 00110001b
-01110111b & 00111010b = 00110010b
-01110111b & 00111011b = 00110011b
-01110111b & 00111100b = 00110100b
-01110111b & 00111101b = 00110101b
-01110111b & 00111110b = 00110110b
-01110111b & 00111111b = 00110111b
-01110111b & 01000000b = 01000000b
-01110111b & 01000001b = 01000001b
-01110111b & 01000010b = 01000010b
-01110111b & 01000011b = 01000011b
-01110111b & 01000100b = 01000100b
-01110111b & 01000101b = 01000101b
-01110111b & 01000110b = 01000110b
-01110111b & 01000111b = 01000111b
-01110111b & 01001000b = 01000000b
-01110111b & 01001001b = 01000001b
-01110111b & 01001010b = 01000010b
-01110111b & 01001011b = 01000011b
-01110111b & 01001100b = 01000100b
-01110111b & 01001101b = 01000101b
-01110111b & 01001110b = 01000110b
-01110111b & 01001111b = 01000111b
-01110111b & 01010000b = 01010000b
-01110111b & 01010001b = 01010001b
-01110111b & 01010010b = 01010010b
-01110111b & 01010011b = 01010011b
-01110111b & 01010100b = 01010100b
-01110111b & 01010101b = 01010101b
-01110111b & 01010110b = 01010110b
-01110111b & 01010111b = 01010111b
-01110111b & 01011000b = 01010000b
-01110111b & 01011001b = 01010001b
-01110111b & 01011010b = 01010010b
-01110111b & 01011011b = 01010011b
-01110111b & 01011100b = 01010100b
-01110111b & 01011101b = 01010101b
-01110111b & 01011110b = 01010110b
-01110111b & 01011111b = 01010111b
-01110111b & 01100000b = 01100000b
-01110111b & 01100001b = 01100001b
-01110111b & 01100010b = 01100010b
-01110111b & 01100011b = 01100011b
-01110111b & 01100100b = 01100100b
-01110111b & 01100101b = 01100101b
-01110111b & 01100110b = 01100110b
-01110111b & 01100111b = 01100111b
-01110111b & 01101000b = 01100000b
-01110111b & 01101001b = 01100001b
-01110111b & 01101010b = 01100010b
-01110111b & 01101011b = 01100011b
-01110111b & 01101100b = 01100100b
-01110111b & 01101101b = 01100101b
-01110111b & 01101110b = 01100110b
-01110111b & 01101111b = 01100111b
-01110111b & 01110000b = 01110000b
-01110111b & 01110001b = 01110001b
-01110111b & 01110010b = 01110010b
-01110111b & 01110011b = 01110011b
-01110111b & 01110100b = 01110100b
-01110111b & 01110101b = 01110101b
-01110111b & 01110110b = 01110110b
-01110111b & 01110111b = 01110111b
-01110111b & 01111000b = 01110000b
-01110111b & 01111001b = 01110001b
-01110111b & 01111010b = 01110010b
-01110111b & 01111011b = 01110011b
-01110111b & 01111100b = 01110100b
-01110111b & 01111101b = 01110101b
-01110111b & 01111110b = 01110110b
-01111000b & 10000000b = 00000000b
-01111000b & 10000001b = 00000000b
-01111000b & 10000010b = 00000000b
-01111000b & 10000011b = 00000000b
-01111000b & 10000100b = 00000000b
-01111000b & 10000101b = 00000000b
-01111000b & 10000110b = 00000000b
-01111000b & 10000111b = 00000000b
-01111000b & 10001000b = 00001000b
-01111000b & 10001001b = 00001000b
-01111000b & 10001010b = 00001000b
-01111000b & 10001011b = 00001000b
-01111000b & 10001100b = 00001000b
-01111000b & 10001101b = 00001000b
-01111000b & 10001110b = 00001000b
-01111000b & 10001111b = 00001000b
-01111000b & 10010000b = 00010000b
-01111000b & 10010001b = 00010000b
-01111000b & 10010010b = 00010000b
-01111000b & 10010011b = 00010000b
-01111000b & 10010100b = 00010000b
-01111000b & 10010101b = 00010000b
-01111000b & 10010110b = 00010000b
-01111000b & 10010111b = 00010000b
-01111000b & 10011000b = 00011000b
-01111000b & 10011001b = 00011000b
-01111000b & 10011010b = 00011000b
-01111000b & 10011011b = 00011000b
-01111000b & 10011100b = 00011000b
-01111000b & 10011101b = 00011000b
-01111000b & 10011110b = 00011000b
-01111000b & 10011111b = 00011000b
-01111000b & 10100000b = 00100000b
-01111000b & 10100001b = 00100000b
-01111000b & 10100010b = 00100000b
-01111000b & 10100011b = 00100000b
-01111000b & 10100100b = 00100000b
-01111000b & 10100101b = 00100000b
-01111000b & 10100110b = 00100000b
-01111000b & 10100111b = 00100000b
-01111000b & 10101000b = 00101000b
-01111000b & 10101001b = 00101000b
-01111000b & 10101010b = 00101000b
-01111000b & 10101011b = 00101000b
-01111000b & 10101100b = 00101000b
-01111000b & 10101101b = 00101000b
-01111000b & 10101110b = 00101000b
-01111000b & 10101111b = 00101000b
-01111000b & 10110000b = 00110000b
-01111000b & 10110001b = 00110000b
-01111000b & 10110010b = 00110000b
-01111000b & 10110011b = 00110000b
-01111000b & 10110100b = 00110000b
-01111000b & 10110101b = 00110000b
-01111000b & 10110110b = 00110000b
-01111000b & 10110111b = 00110000b
-01111000b & 10111000b = 00111000b
-01111000b & 10111001b = 00111000b
-01111000b & 10111010b = 00111000b
-01111000b & 10111011b = 00111000b
-01111000b & 10111100b = 00111000b
-01111000b & 10111101b = 00111000b
-01111000b & 10111110b = 00111000b
-01111000b & 10111111b = 00111000b
-01111000b & 11000000b = 01000000b
-01111000b & 11000001b = 01000000b
-01111000b & 11000010b = 01000000b
-01111000b & 11000011b = 01000000b
-01111000b & 11000100b = 01000000b
-01111000b & 11000101b = 01000000b
-01111000b & 11000110b = 01000000b
-01111000b & 11000111b = 01000000b
-01111000b & 11001000b = 01001000b
-01111000b & 11001001b = 01001000b
-01111000b & 11001010b = 01001000b
-01111000b & 11001011b = 01001000b
-01111000b & 11001100b = 01001000b
-01111000b & 11001101b = 01001000b
-01111000b & 11001110b = 01001000b
-01111000b & 11001111b = 01001000b
-01111000b & 11010000b = 01010000b
-01111000b & 11010001b = 01010000b
-01111000b & 11010010b = 01010000b
-01111000b & 11010011b = 01010000b
-01111000b & 11010100b = 01010000b
-01111000b & 11010101b = 01010000b
-01111000b & 11010110b = 01010000b
-01111000b & 11010111b = 01010000b
-01111000b & 11011000b = 01011000b
-01111000b & 11011001b = 01011000b
-01111000b & 11011010b = 01011000b
-01111000b & 11011011b = 01011000b
-01111000b & 11011100b = 01011000b
-01111000b & 11011101b = 01011000b
-01111000b & 11011110b = 01011000b
-01111000b & 11011111b = 01011000b
-01111000b & 11100000b = 01100000b
-01111000b & 11100001b = 01100000b
-01111000b & 11100010b = 01100000b
-01111000b & 11100011b = 01100000b
-01111000b & 11100100b = 01100000b
-01111000b & 11100101b = 01100000b
-01111000b & 11100110b = 01100000b
-01111000b & 11100111b = 01100000b
-01111000b & 11101000b = 01101000b
-01111000b & 11101001b = 01101000b
-01111000b & 11101010b = 01101000b
-01111000b & 11101011b = 01101000b
-01111000b & 11101100b = 01101000b
-01111000b & 11101101b = 01101000b
-01111000b & 11101110b = 01101000b
-01111000b & 11101111b = 01101000b
-01111000b & 11110000b = 01110000b
-01111000b & 11110001b = 01110000b
-01111000b & 11110010b = 01110000b
-01111000b & 11110011b = 01110000b
-01111000b & 11110100b = 01110000b
-01111000b & 11110101b = 01110000b
-01111000b & 11110110b = 01110000b
-01111000b & 11110111b = 01110000b
-01111000b & 11111000b = 01111000b
-01111000b & 11111001b = 01111000b
-01111000b & 11111010b = 01111000b
-01111000b & 11111011b = 01111000b
-01111000b & 11111100b = 01111000b
-01111000b & 11111101b = 01111000b
-01111000b & 11111110b = 01111000b
-01111000b & 11111111b = 01111000b
-01111000b & 00000000b = 00000000b
-01111000b & 00000001b = 00000000b
-01111000b & 00000010b = 00000000b
-01111000b & 00000011b = 00000000b
-01111000b & 00000100b = 00000000b
-01111000b & 00000101b = 00000000b
-01111000b & 00000110b = 00000000b
-01111000b & 00000111b = 00000000b
-01111000b & 00001000b = 00001000b
-01111000b & 00001001b = 00001000b
-01111000b & 00001010b = 00001000b
-01111000b & 00001011b = 00001000b
-01111000b & 00001100b = 00001000b
-01111000b & 00001101b = 00001000b
-01111000b & 00001110b = 00001000b
-01111000b & 00001111b = 00001000b
-01111000b & 00010000b = 00010000b
-01111000b & 00010001b = 00010000b
-01111000b & 00010010b = 00010000b
-01111000b & 00010011b = 00010000b
-01111000b & 00010100b = 00010000b
-01111000b & 00010101b = 00010000b
-01111000b & 00010110b = 00010000b
-01111000b & 00010111b = 00010000b
-01111000b & 00011000b = 00011000b
-01111000b & 00011001b = 00011000b
-01111000b & 00011010b = 00011000b
-01111000b & 00011011b = 00011000b
-01111000b & 00011100b = 00011000b
-01111000b & 00011101b = 00011000b
-01111000b & 00011110b = 00011000b
-01111000b & 00011111b = 00011000b
-01111000b & 00100000b = 00100000b
-01111000b & 00100001b = 00100000b
-01111000b & 00100010b = 00100000b
-01111000b & 00100011b = 00100000b
-01111000b & 00100100b = 00100000b
-01111000b & 00100101b = 00100000b
-01111000b & 00100110b = 00100000b
-01111000b & 00100111b = 00100000b
-01111000b & 00101000b = 00101000b
-01111000b & 00101001b = 00101000b
-01111000b & 00101010b = 00101000b
-01111000b & 00101011b = 00101000b
-01111000b & 00101100b = 00101000b
-01111000b & 00101101b = 00101000b
-01111000b & 00101110b = 00101000b
-01111000b & 00101111b = 00101000b
-01111000b & 00110000b = 00110000b
-01111000b & 00110001b = 00110000b
-01111000b & 00110010b = 00110000b
-01111000b & 00110011b = 00110000b
-01111000b & 00110100b = 00110000b
-01111000b & 00110101b = 00110000b
-01111000b & 00110110b = 00110000b
-01111000b & 00110111b = 00110000b
-01111000b & 00111000b = 00111000b
-01111000b & 00111001b = 00111000b
-01111000b & 00111010b = 00111000b
-01111000b & 00111011b = 00111000b
-01111000b & 00111100b = 00111000b
-01111000b & 00111101b = 00111000b
-01111000b & 00111110b = 00111000b
-01111000b & 00111111b = 00111000b
-01111000b & 01000000b = 01000000b
-01111000b & 01000001b = 01000000b
-01111000b & 01000010b = 01000000b
-01111000b & 01000011b = 01000000b
-01111000b & 01000100b = 01000000b
-01111000b & 01000101b = 01000000b
-01111000b & 01000110b = 01000000b
-01111000b & 01000111b = 01000000b
-01111000b & 01001000b = 01001000b
-01111000b & 01001001b = 01001000b
-01111000b & 01001010b = 01001000b
-01111000b & 01001011b = 01001000b
-01111000b & 01001100b = 01001000b
-01111000b & 01001101b = 01001000b
-01111000b & 01001110b = 01001000b
-01111000b & 01001111b = 01001000b
-01111000b & 01010000b = 01010000b
-01111000b & 01010001b = 01010000b
-01111000b & 01010010b = 01010000b
-01111000b & 01010011b = 01010000b
-01111000b & 01010100b = 01010000b
-01111000b & 01010101b = 01010000b
-01111000b & 01010110b = 01010000b
-01111000b & 01010111b = 01010000b
-01111000b & 01011000b = 01011000b
-01111000b & 01011001b = 01011000b
-01111000b & 01011010b = 01011000b
-01111000b & 01011011b = 01011000b
-01111000b & 01011100b = 01011000b
-01111000b & 01011101b = 01011000b
-01111000b & 01011110b = 01011000b
-01111000b & 01011111b = 01011000b
-01111000b & 01100000b = 01100000b
-01111000b & 01100001b = 01100000b
-01111000b & 01100010b = 01100000b
-01111000b & 01100011b = 01100000b
-01111000b & 01100100b = 01100000b
-01111000b & 01100101b = 01100000b
-01111000b & 01100110b = 01100000b
-01111000b & 01100111b = 01100000b
-01111000b & 01101000b = 01101000b
-01111000b & 01101001b = 01101000b
-01111000b & 01101010b = 01101000b
-01111000b & 01101011b = 01101000b
-01111000b & 01101100b = 01101000b
-01111000b & 01101101b = 01101000b
-01111000b & 01101110b = 01101000b
-01111000b & 01101111b = 01101000b
-01111000b & 01110000b = 01110000b
-01111000b & 01110001b = 01110000b
-01111000b & 01110010b = 01110000b
-01111000b & 01110011b = 01110000b
-01111000b & 01110100b = 01110000b
-01111000b & 01110101b = 01110000b
-01111000b & 01110110b = 01110000b
-01111000b & 01110111b = 01110000b
-01111000b & 01111000b = 01111000b
-01111000b & 01111001b = 01111000b
-01111000b & 01111010b = 01111000b
-01111000b & 01111011b = 01111000b
-01111000b & 01111100b = 01111000b
-01111000b & 01111101b = 01111000b
-01111000b & 01111110b = 01111000b
-01111001b & 10000000b = 00000000b
-01111001b & 10000001b = 00000001b
-01111001b & 10000010b = 00000000b
-01111001b & 10000011b = 00000001b
-01111001b & 10000100b = 00000000b
-01111001b & 10000101b = 00000001b
-01111001b & 10000110b = 00000000b
-01111001b & 10000111b = 00000001b
-01111001b & 10001000b = 00001000b
-01111001b & 10001001b = 00001001b
-01111001b & 10001010b = 00001000b
-01111001b & 10001011b = 00001001b
-01111001b & 10001100b = 00001000b
-01111001b & 10001101b = 00001001b
-01111001b & 10001110b = 00001000b
-01111001b & 10001111b = 00001001b
-01111001b & 10010000b = 00010000b
-01111001b & 10010001b = 00010001b
-01111001b & 10010010b = 00010000b
-01111001b & 10010011b = 00010001b
-01111001b & 10010100b = 00010000b
-01111001b & 10010101b = 00010001b
-01111001b & 10010110b = 00010000b
-01111001b & 10010111b = 00010001b
-01111001b & 10011000b = 00011000b
-01111001b & 10011001b = 00011001b
-01111001b & 10011010b = 00011000b
-01111001b & 10011011b = 00011001b
-01111001b & 10011100b = 00011000b
-01111001b & 10011101b = 00011001b
-01111001b & 10011110b = 00011000b
-01111001b & 10011111b = 00011001b
-01111001b & 10100000b = 00100000b
-01111001b & 10100001b = 00100001b
-01111001b & 10100010b = 00100000b
-01111001b & 10100011b = 00100001b
-01111001b & 10100100b = 00100000b
-01111001b & 10100101b = 00100001b
-01111001b & 10100110b = 00100000b
-01111001b & 10100111b = 00100001b
-01111001b & 10101000b = 00101000b
-01111001b & 10101001b = 00101001b
-01111001b & 10101010b = 00101000b
-01111001b & 10101011b = 00101001b
-01111001b & 10101100b = 00101000b
-01111001b & 10101101b = 00101001b
-01111001b & 10101110b = 00101000b
-01111001b & 10101111b = 00101001b
-01111001b & 10110000b = 00110000b
-01111001b & 10110001b = 00110001b
-01111001b & 10110010b = 00110000b
-01111001b & 10110011b = 00110001b
-01111001b & 10110100b = 00110000b
-01111001b & 10110101b = 00110001b
-01111001b & 10110110b = 00110000b
-01111001b & 10110111b = 00110001b
-01111001b & 10111000b = 00111000b
-01111001b & 10111001b = 00111001b
-01111001b & 10111010b = 00111000b
-01111001b & 10111011b = 00111001b
-01111001b & 10111100b = 00111000b
-01111001b & 10111101b = 00111001b
-01111001b & 10111110b = 00111000b
-01111001b & 10111111b = 00111001b
-01111001b & 11000000b = 01000000b
-01111001b & 11000001b = 01000001b
-01111001b & 11000010b = 01000000b
-01111001b & 11000011b = 01000001b
-01111001b & 11000100b = 01000000b
-01111001b & 11000101b = 01000001b
-01111001b & 11000110b = 01000000b
-01111001b & 11000111b = 01000001b
-01111001b & 11001000b = 01001000b
-01111001b & 11001001b = 01001001b
-01111001b & 11001010b = 01001000b
-01111001b & 11001011b = 01001001b
-01111001b & 11001100b = 01001000b
-01111001b & 11001101b = 01001001b
-01111001b & 11001110b = 01001000b
-01111001b & 11001111b = 01001001b
-01111001b & 11010000b = 01010000b
-01111001b & 11010001b = 01010001b
-01111001b & 11010010b = 01010000b
-01111001b & 11010011b = 01010001b
-01111001b & 11010100b = 01010000b
-01111001b & 11010101b = 01010001b
-01111001b & 11010110b = 01010000b
-01111001b & 11010111b = 01010001b
-01111001b & 11011000b = 01011000b
-01111001b & 11011001b = 01011001b
-01111001b & 11011010b = 01011000b
-01111001b & 11011011b = 01011001b
-01111001b & 11011100b = 01011000b
-01111001b & 11011101b = 01011001b
-01111001b & 11011110b = 01011000b
-01111001b & 11011111b = 01011001b
-01111001b & 11100000b = 01100000b
-01111001b & 11100001b = 01100001b
-01111001b & 11100010b = 01100000b
-01111001b & 11100011b = 01100001b
-01111001b & 11100100b = 01100000b
-01111001b & 11100101b = 01100001b
-01111001b & 11100110b = 01100000b
-01111001b & 11100111b = 01100001b
-01111001b & 11101000b = 01101000b
-01111001b & 11101001b = 01101001b
-01111001b & 11101010b = 01101000b
-01111001b & 11101011b = 01101001b
-01111001b & 11101100b = 01101000b
-01111001b & 11101101b = 01101001b
-01111001b & 11101110b = 01101000b
-01111001b & 11101111b = 01101001b
-01111001b & 11110000b = 01110000b
-01111001b & 11110001b = 01110001b
-01111001b & 11110010b = 01110000b
-01111001b & 11110011b = 01110001b
-01111001b & 11110100b = 01110000b
-01111001b & 11110101b = 01110001b
-01111001b & 11110110b = 01110000b
-01111001b & 11110111b = 01110001b
-01111001b & 11111000b = 01111000b
-01111001b & 11111001b = 01111001b
-01111001b & 11111010b = 01111000b
-01111001b & 11111011b = 01111001b
-01111001b & 11111100b = 01111000b
-01111001b & 11111101b = 01111001b
-01111001b & 11111110b = 01111000b
-01111001b & 11111111b = 01111001b
-01111001b & 00000000b = 00000000b
-01111001b & 00000001b = 00000001b
-01111001b & 00000010b = 00000000b
-01111001b & 00000011b = 00000001b
-01111001b & 00000100b = 00000000b
-01111001b & 00000101b = 00000001b
-01111001b & 00000110b = 00000000b
-01111001b & 00000111b = 00000001b
-01111001b & 00001000b = 00001000b
-01111001b & 00001001b = 00001001b
-01111001b & 00001010b = 00001000b
-01111001b & 00001011b = 00001001b
-01111001b & 00001100b = 00001000b
-01111001b & 00001101b = 00001001b
-01111001b & 00001110b = 00001000b
-01111001b & 00001111b = 00001001b
-01111001b & 00010000b = 00010000b
-01111001b & 00010001b = 00010001b
-01111001b & 00010010b = 00010000b
-01111001b & 00010011b = 00010001b
-01111001b & 00010100b = 00010000b
-01111001b & 00010101b = 00010001b
-01111001b & 00010110b = 00010000b
-01111001b & 00010111b = 00010001b
-01111001b & 00011000b = 00011000b
-01111001b & 00011001b = 00011001b
-01111001b & 00011010b = 00011000b
-01111001b & 00011011b = 00011001b
-01111001b & 00011100b = 00011000b
-01111001b & 00011101b = 00011001b
-01111001b & 00011110b = 00011000b
-01111001b & 00011111b = 00011001b
-01111001b & 00100000b = 00100000b
-01111001b & 00100001b = 00100001b
-01111001b & 00100010b = 00100000b
-01111001b & 00100011b = 00100001b
-01111001b & 00100100b = 00100000b
-01111001b & 00100101b = 00100001b
-01111001b & 00100110b = 00100000b
-01111001b & 00100111b = 00100001b
-01111001b & 00101000b = 00101000b
-01111001b & 00101001b = 00101001b
-01111001b & 00101010b = 00101000b
-01111001b & 00101011b = 00101001b
-01111001b & 00101100b = 00101000b
-01111001b & 00101101b = 00101001b
-01111001b & 00101110b = 00101000b
-01111001b & 00101111b = 00101001b
-01111001b & 00110000b = 00110000b
-01111001b & 00110001b = 00110001b
-01111001b & 00110010b = 00110000b
-01111001b & 00110011b = 00110001b
-01111001b & 00110100b = 00110000b
-01111001b & 00110101b = 00110001b
-01111001b & 00110110b = 00110000b
-01111001b & 00110111b = 00110001b
-01111001b & 00111000b = 00111000b
-01111001b & 00111001b = 00111001b
-01111001b & 00111010b = 00111000b
-01111001b & 00111011b = 00111001b
-01111001b & 00111100b = 00111000b
-01111001b & 00111101b = 00111001b
-01111001b & 00111110b = 00111000b
-01111001b & 00111111b = 00111001b
-01111001b & 01000000b = 01000000b
-01111001b & 01000001b = 01000001b
-01111001b & 01000010b = 01000000b
-01111001b & 01000011b = 01000001b
-01111001b & 01000100b = 01000000b
-01111001b & 01000101b = 01000001b
-01111001b & 01000110b = 01000000b
-01111001b & 01000111b = 01000001b
-01111001b & 01001000b = 01001000b
-01111001b & 01001001b = 01001001b
-01111001b & 01001010b = 01001000b
-01111001b & 01001011b = 01001001b
-01111001b & 01001100b = 01001000b
-01111001b & 01001101b = 01001001b
-01111001b & 01001110b = 01001000b
-01111001b & 01001111b = 01001001b
-01111001b & 01010000b = 01010000b
-01111001b & 01010001b = 01010001b
-01111001b & 01010010b = 01010000b
-01111001b & 01010011b = 01010001b
-01111001b & 01010100b = 01010000b
-01111001b & 01010101b = 01010001b
-01111001b & 01010110b = 01010000b
-01111001b & 01010111b = 01010001b
-01111001b & 01011000b = 01011000b
-01111001b & 01011001b = 01011001b
-01111001b & 01011010b = 01011000b
-01111001b & 01011011b = 01011001b
-01111001b & 01011100b = 01011000b
-01111001b & 01011101b = 01011001b
-01111001b & 01011110b = 01011000b
-01111001b & 01011111b = 01011001b
-01111001b & 01100000b = 01100000b
-01111001b & 01100001b = 01100001b
-01111001b & 01100010b = 01100000b
-01111001b & 01100011b = 01100001b
-01111001b & 01100100b = 01100000b
-01111001b & 01100101b = 01100001b
-01111001b & 01100110b = 01100000b
-01111001b & 01100111b = 01100001b
-01111001b & 01101000b = 01101000b
-01111001b & 01101001b = 01101001b
-01111001b & 01101010b = 01101000b
-01111001b & 01101011b = 01101001b
-01111001b & 01101100b = 01101000b
-01111001b & 01101101b = 01101001b
-01111001b & 01101110b = 01101000b
-01111001b & 01101111b = 01101001b
-01111001b & 01110000b = 01110000b
-01111001b & 01110001b = 01110001b
-01111001b & 01110010b = 01110000b
-01111001b & 01110011b = 01110001b
-01111001b & 01110100b = 01110000b
-01111001b & 01110101b = 01110001b
-01111001b & 01110110b = 01110000b
-01111001b & 01110111b = 01110001b
-01111001b & 01111000b = 01111000b
-01111001b & 01111001b = 01111001b
-01111001b & 01111010b = 01111000b
-01111001b & 01111011b = 01111001b
-01111001b & 01111100b = 01111000b
-01111001b & 01111101b = 01111001b
-01111001b & 01111110b = 01111000b
-01111010b & 10000000b = 00000000b
-01111010b & 10000001b = 00000000b
-01111010b & 10000010b = 00000010b
-01111010b & 10000011b = 00000010b
-01111010b & 10000100b = 00000000b
-01111010b & 10000101b = 00000000b
-01111010b & 10000110b = 00000010b
-01111010b & 10000111b = 00000010b
-01111010b & 10001000b = 00001000b
-01111010b & 10001001b = 00001000b
-01111010b & 10001010b = 00001010b
-01111010b & 10001011b = 00001010b
-01111010b & 10001100b = 00001000b
-01111010b & 10001101b = 00001000b
-01111010b & 10001110b = 00001010b
-01111010b & 10001111b = 00001010b
-01111010b & 10010000b = 00010000b
-01111010b & 10010001b = 00010000b
-01111010b & 10010010b = 00010010b
-01111010b & 10010011b = 00010010b
-01111010b & 10010100b = 00010000b
-01111010b & 10010101b = 00010000b
-01111010b & 10010110b = 00010010b
-01111010b & 10010111b = 00010010b
-01111010b & 10011000b = 00011000b
-01111010b & 10011001b = 00011000b
-01111010b & 10011010b = 00011010b
-01111010b & 10011011b = 00011010b
-01111010b & 10011100b = 00011000b
-01111010b & 10011101b = 00011000b
-01111010b & 10011110b = 00011010b
-01111010b & 10011111b = 00011010b
-01111010b & 10100000b = 00100000b
-01111010b & 10100001b = 00100000b
-01111010b & 10100010b = 00100010b
-01111010b & 10100011b = 00100010b
-01111010b & 10100100b = 00100000b
-01111010b & 10100101b = 00100000b
-01111010b & 10100110b = 00100010b
-01111010b & 10100111b = 00100010b
-01111010b & 10101000b = 00101000b
-01111010b & 10101001b = 00101000b
-01111010b & 10101010b = 00101010b
-01111010b & 10101011b = 00101010b
-01111010b & 10101100b = 00101000b
-01111010b & 10101101b = 00101000b
-01111010b & 10101110b = 00101010b
-01111010b & 10101111b = 00101010b
-01111010b & 10110000b = 00110000b
-01111010b & 10110001b = 00110000b
-01111010b & 10110010b = 00110010b
-01111010b & 10110011b = 00110010b
-01111010b & 10110100b = 00110000b
-01111010b & 10110101b = 00110000b
-01111010b & 10110110b = 00110010b
-01111010b & 10110111b = 00110010b
-01111010b & 10111000b = 00111000b
-01111010b & 10111001b = 00111000b
-01111010b & 10111010b = 00111010b
-01111010b & 10111011b = 00111010b
-01111010b & 10111100b = 00111000b
-01111010b & 10111101b = 00111000b
-01111010b & 10111110b = 00111010b
-01111010b & 10111111b = 00111010b
-01111010b & 11000000b = 01000000b
-01111010b & 11000001b = 01000000b
-01111010b & 11000010b = 01000010b
-01111010b & 11000011b = 01000010b
-01111010b & 11000100b = 01000000b
-01111010b & 11000101b = 01000000b
-01111010b & 11000110b = 01000010b
-01111010b & 11000111b = 01000010b
-01111010b & 11001000b = 01001000b
-01111010b & 11001001b = 01001000b
-01111010b & 11001010b = 01001010b
-01111010b & 11001011b = 01001010b
-01111010b & 11001100b = 01001000b
-01111010b & 11001101b = 01001000b
-01111010b & 11001110b = 01001010b
-01111010b & 11001111b = 01001010b
-01111010b & 11010000b = 01010000b
-01111010b & 11010001b = 01010000b
-01111010b & 11010010b = 01010010b
-01111010b & 11010011b = 01010010b
-01111010b & 11010100b = 01010000b
-01111010b & 11010101b = 01010000b
-01111010b & 11010110b = 01010010b
-01111010b & 11010111b = 01010010b
-01111010b & 11011000b = 01011000b
-01111010b & 11011001b = 01011000b
-01111010b & 11011010b = 01011010b
-01111010b & 11011011b = 01011010b
-01111010b & 11011100b = 01011000b
-01111010b & 11011101b = 01011000b
-01111010b & 11011110b = 01011010b
-01111010b & 11011111b = 01011010b
-01111010b & 11100000b = 01100000b
-01111010b & 11100001b = 01100000b
-01111010b & 11100010b = 01100010b
-01111010b & 11100011b = 01100010b
-01111010b & 11100100b = 01100000b
-01111010b & 11100101b = 01100000b
-01111010b & 11100110b = 01100010b
-01111010b & 11100111b = 01100010b
-01111010b & 11101000b = 01101000b
-01111010b & 11101001b = 01101000b
-01111010b & 11101010b = 01101010b
-01111010b & 11101011b = 01101010b
-01111010b & 11101100b = 01101000b
-01111010b & 11101101b = 01101000b
-01111010b & 11101110b = 01101010b
-01111010b & 11101111b = 01101010b
-01111010b & 11110000b = 01110000b
-01111010b & 11110001b = 01110000b
-01111010b & 11110010b = 01110010b
-01111010b & 11110011b = 01110010b
-01111010b & 11110100b = 01110000b
-01111010b & 11110101b = 01110000b
-01111010b & 11110110b = 01110010b
-01111010b & 11110111b = 01110010b
-01111010b & 11111000b = 01111000b
-01111010b & 11111001b = 01111000b
-01111010b & 11111010b = 01111010b
-01111010b & 11111011b = 01111010b
-01111010b & 11111100b = 01111000b
-01111010b & 11111101b = 01111000b
-01111010b & 11111110b = 01111010b
-01111010b & 11111111b = 01111010b
-01111010b & 00000000b = 00000000b
-01111010b & 00000001b = 00000000b
-01111010b & 00000010b = 00000010b
-01111010b & 00000011b = 00000010b
-01111010b & 00000100b = 00000000b
-01111010b & 00000101b = 00000000b
-01111010b & 00000110b = 00000010b
-01111010b & 00000111b = 00000010b
-01111010b & 00001000b = 00001000b
-01111010b & 00001001b = 00001000b
-01111010b & 00001010b = 00001010b
-01111010b & 00001011b = 00001010b
-01111010b & 00001100b = 00001000b
-01111010b & 00001101b = 00001000b
-01111010b & 00001110b = 00001010b
-01111010b & 00001111b = 00001010b
-01111010b & 00010000b = 00010000b
-01111010b & 00010001b = 00010000b
-01111010b & 00010010b = 00010010b
-01111010b & 00010011b = 00010010b
-01111010b & 00010100b = 00010000b
-01111010b & 00010101b = 00010000b
-01111010b & 00010110b = 00010010b
-01111010b & 00010111b = 00010010b
-01111010b & 00011000b = 00011000b
-01111010b & 00011001b = 00011000b
-01111010b & 00011010b = 00011010b
-01111010b & 00011011b = 00011010b
-01111010b & 00011100b = 00011000b
-01111010b & 00011101b = 00011000b
-01111010b & 00011110b = 00011010b
-01111010b & 00011111b = 00011010b
-01111010b & 00100000b = 00100000b
-01111010b & 00100001b = 00100000b
-01111010b & 00100010b = 00100010b
-01111010b & 00100011b = 00100010b
-01111010b & 00100100b = 00100000b
-01111010b & 00100101b = 00100000b
-01111010b & 00100110b = 00100010b
-01111010b & 00100111b = 00100010b
-01111010b & 00101000b = 00101000b
-01111010b & 00101001b = 00101000b
-01111010b & 00101010b = 00101010b
-01111010b & 00101011b = 00101010b
-01111010b & 00101100b = 00101000b
-01111010b & 00101101b = 00101000b
-01111010b & 00101110b = 00101010b
-01111010b & 00101111b = 00101010b
-01111010b & 00110000b = 00110000b
-01111010b & 00110001b = 00110000b
-01111010b & 00110010b = 00110010b
-01111010b & 00110011b = 00110010b
-01111010b & 00110100b = 00110000b
-01111010b & 00110101b = 00110000b
-01111010b & 00110110b = 00110010b
-01111010b & 00110111b = 00110010b
-01111010b & 00111000b = 00111000b
-01111010b & 00111001b = 00111000b
-01111010b & 00111010b = 00111010b
-01111010b & 00111011b = 00111010b
-01111010b & 00111100b = 00111000b
-01111010b & 00111101b = 00111000b
-01111010b & 00111110b = 00111010b
-01111010b & 00111111b = 00111010b
-01111010b & 01000000b = 01000000b
-01111010b & 01000001b = 01000000b
-01111010b & 01000010b = 01000010b
-01111010b & 01000011b = 01000010b
-01111010b & 01000100b = 01000000b
-01111010b & 01000101b = 01000000b
-01111010b & 01000110b = 01000010b
-01111010b & 01000111b = 01000010b
-01111010b & 01001000b = 01001000b
-01111010b & 01001001b = 01001000b
-01111010b & 01001010b = 01001010b
-01111010b & 01001011b = 01001010b
-01111010b & 01001100b = 01001000b
-01111010b & 01001101b = 01001000b
-01111010b & 01001110b = 01001010b
-01111010b & 01001111b = 01001010b
-01111010b & 01010000b = 01010000b
-01111010b & 01010001b = 01010000b
-01111010b & 01010010b = 01010010b
-01111010b & 01010011b = 01010010b
-01111010b & 01010100b = 01010000b
-01111010b & 01010101b = 01010000b
-01111010b & 01010110b = 01010010b
-01111010b & 01010111b = 01010010b
-01111010b & 01011000b = 01011000b
-01111010b & 01011001b = 01011000b
-01111010b & 01011010b = 01011010b
-01111010b & 01011011b = 01011010b
-01111010b & 01011100b = 01011000b
-01111010b & 01011101b = 01011000b
-01111010b & 01011110b = 01011010b
-01111010b & 01011111b = 01011010b
-01111010b & 01100000b = 01100000b
-01111010b & 01100001b = 01100000b
-01111010b & 01100010b = 01100010b
-01111010b & 01100011b = 01100010b
-01111010b & 01100100b = 01100000b
-01111010b & 01100101b = 01100000b
-01111010b & 01100110b = 01100010b
-01111010b & 01100111b = 01100010b
-01111010b & 01101000b = 01101000b
-01111010b & 01101001b = 01101000b
-01111010b & 01101010b = 01101010b
-01111010b & 01101011b = 01101010b
-01111010b & 01101100b = 01101000b
-01111010b & 01101101b = 01101000b
-01111010b & 01101110b = 01101010b
-01111010b & 01101111b = 01101010b
-01111010b & 01110000b = 01110000b
-01111010b & 01110001b = 01110000b
-01111010b & 01110010b = 01110010b
-01111010b & 01110011b = 01110010b
-01111010b & 01110100b = 01110000b
-01111010b & 01110101b = 01110000b
-01111010b & 01110110b = 01110010b
-01111010b & 01110111b = 01110010b
-01111010b & 01111000b = 01111000b
-01111010b & 01111001b = 01111000b
-01111010b & 01111010b = 01111010b
-01111010b & 01111011b = 01111010b
-01111010b & 01111100b = 01111000b
-01111010b & 01111101b = 01111000b
-01111010b & 01111110b = 01111010b
-01111011b & 10000000b = 00000000b
-01111011b & 10000001b = 00000001b
-01111011b & 10000010b = 00000010b
-01111011b & 10000011b = 00000011b
-01111011b & 10000100b = 00000000b
-01111011b & 10000101b = 00000001b
-01111011b & 10000110b = 00000010b
-01111011b & 10000111b = 00000011b
-01111011b & 10001000b = 00001000b
-01111011b & 10001001b = 00001001b
-01111011b & 10001010b = 00001010b
-01111011b & 10001011b = 00001011b
-01111011b & 10001100b = 00001000b
-01111011b & 10001101b = 00001001b
-01111011b & 10001110b = 00001010b
-01111011b & 10001111b = 00001011b
-01111011b & 10010000b = 00010000b
-01111011b & 10010001b = 00010001b
-01111011b & 10010010b = 00010010b
-01111011b & 10010011b = 00010011b
-01111011b & 10010100b = 00010000b
-01111011b & 10010101b = 00010001b
-01111011b & 10010110b = 00010010b
-01111011b & 10010111b = 00010011b
-01111011b & 10011000b = 00011000b
-01111011b & 10011001b = 00011001b
-01111011b & 10011010b = 00011010b
-01111011b & 10011011b = 00011011b
-01111011b & 10011100b = 00011000b
-01111011b & 10011101b = 00011001b
-01111011b & 10011110b = 00011010b
-01111011b & 10011111b = 00011011b
-01111011b & 10100000b = 00100000b
-01111011b & 10100001b = 00100001b
-01111011b & 10100010b = 00100010b
-01111011b & 10100011b = 00100011b
-01111011b & 10100100b = 00100000b
-01111011b & 10100101b = 00100001b
-01111011b & 10100110b = 00100010b
-01111011b & 10100111b = 00100011b
-01111011b & 10101000b = 00101000b
-01111011b & 10101001b = 00101001b
-01111011b & 10101010b = 00101010b
-01111011b & 10101011b = 00101011b
-01111011b & 10101100b = 00101000b
-01111011b & 10101101b = 00101001b
-01111011b & 10101110b = 00101010b
-01111011b & 10101111b = 00101011b
-01111011b & 10110000b = 00110000b
-01111011b & 10110001b = 00110001b
-01111011b & 10110010b = 00110010b
-01111011b & 10110011b = 00110011b
-01111011b & 10110100b = 00110000b
-01111011b & 10110101b = 00110001b
-01111011b & 10110110b = 00110010b
-01111011b & 10110111b = 00110011b
-01111011b & 10111000b = 00111000b
-01111011b & 10111001b = 00111001b
-01111011b & 10111010b = 00111010b
-01111011b & 10111011b = 00111011b
-01111011b & 10111100b = 00111000b
-01111011b & 10111101b = 00111001b
-01111011b & 10111110b = 00111010b
-01111011b & 10111111b = 00111011b
-01111011b & 11000000b = 01000000b
-01111011b & 11000001b = 01000001b
-01111011b & 11000010b = 01000010b
-01111011b & 11000011b = 01000011b
-01111011b & 11000100b = 01000000b
-01111011b & 11000101b = 01000001b
-01111011b & 11000110b = 01000010b
-01111011b & 11000111b = 01000011b
-01111011b & 11001000b = 01001000b
-01111011b & 11001001b = 01001001b
-01111011b & 11001010b = 01001010b
-01111011b & 11001011b = 01001011b
-01111011b & 11001100b = 01001000b
-01111011b & 11001101b = 01001001b
-01111011b & 11001110b = 01001010b
-01111011b & 11001111b = 01001011b
-01111011b & 11010000b = 01010000b
-01111011b & 11010001b = 01010001b
-01111011b & 11010010b = 01010010b
-01111011b & 11010011b = 01010011b
-01111011b & 11010100b = 01010000b
-01111011b & 11010101b = 01010001b
-01111011b & 11010110b = 01010010b
-01111011b & 11010111b = 01010011b
-01111011b & 11011000b = 01011000b
-01111011b & 11011001b = 01011001b
-01111011b & 11011010b = 01011010b
-01111011b & 11011011b = 01011011b
-01111011b & 11011100b = 01011000b
-01111011b & 11011101b = 01011001b
-01111011b & 11011110b = 01011010b
-01111011b & 11011111b = 01011011b
-01111011b & 11100000b = 01100000b
-01111011b & 11100001b = 01100001b
-01111011b & 11100010b = 01100010b
-01111011b & 11100011b = 01100011b
-01111011b & 11100100b = 01100000b
-01111011b & 11100101b = 01100001b
-01111011b & 11100110b = 01100010b
-01111011b & 11100111b = 01100011b
-01111011b & 11101000b = 01101000b
-01111011b & 11101001b = 01101001b
-01111011b & 11101010b = 01101010b
-01111011b & 11101011b = 01101011b
-01111011b & 11101100b = 01101000b
-01111011b & 11101101b = 01101001b
-01111011b & 11101110b = 01101010b
-01111011b & 11101111b = 01101011b
-01111011b & 11110000b = 01110000b
-01111011b & 11110001b = 01110001b
-01111011b & 11110010b = 01110010b
-01111011b & 11110011b = 01110011b
-01111011b & 11110100b = 01110000b
-01111011b & 11110101b = 01110001b
-01111011b & 11110110b = 01110010b
-01111011b & 11110111b = 01110011b
-01111011b & 11111000b = 01111000b
-01111011b & 11111001b = 01111001b
-01111011b & 11111010b = 01111010b
-01111011b & 11111011b = 01111011b
-01111011b & 11111100b = 01111000b
-01111011b & 11111101b = 01111001b
-01111011b & 11111110b = 01111010b
-01111011b & 11111111b = 01111011b
-01111011b & 00000000b = 00000000b
-01111011b & 00000001b = 00000001b
-01111011b & 00000010b = 00000010b
-01111011b & 00000011b = 00000011b
-01111011b & 00000100b = 00000000b
-01111011b & 00000101b = 00000001b
-01111011b & 00000110b = 00000010b
-01111011b & 00000111b = 00000011b
-01111011b & 00001000b = 00001000b
-01111011b & 00001001b = 00001001b
-01111011b & 00001010b = 00001010b
-01111011b & 00001011b = 00001011b
-01111011b & 00001100b = 00001000b
-01111011b & 00001101b = 00001001b
-01111011b & 00001110b = 00001010b
-01111011b & 00001111b = 00001011b
-01111011b & 00010000b = 00010000b
-01111011b & 00010001b = 00010001b
-01111011b & 00010010b = 00010010b
-01111011b & 00010011b = 00010011b
-01111011b & 00010100b = 00010000b
-01111011b & 00010101b = 00010001b
-01111011b & 00010110b = 00010010b
-01111011b & 00010111b = 00010011b
-01111011b & 00011000b = 00011000b
-01111011b & 00011001b = 00011001b
-01111011b & 00011010b = 00011010b
-01111011b & 00011011b = 00011011b
-01111011b & 00011100b = 00011000b
-01111011b & 00011101b = 00011001b
-01111011b & 00011110b = 00011010b
-01111011b & 00011111b = 00011011b
-01111011b & 00100000b = 00100000b
-01111011b & 00100001b = 00100001b
-01111011b & 00100010b = 00100010b
-01111011b & 00100011b = 00100011b
-01111011b & 00100100b = 00100000b
-01111011b & 00100101b = 00100001b
-01111011b & 00100110b = 00100010b
-01111011b & 00100111b = 00100011b
-01111011b & 00101000b = 00101000b
-01111011b & 00101001b = 00101001b
-01111011b & 00101010b = 00101010b
-01111011b & 00101011b = 00101011b
-01111011b & 00101100b = 00101000b
-01111011b & 00101101b = 00101001b
-01111011b & 00101110b = 00101010b
-01111011b & 00101111b = 00101011b
-01111011b & 00110000b = 00110000b
-01111011b & 00110001b = 00110001b
-01111011b & 00110010b = 00110010b
-01111011b & 00110011b = 00110011b
-01111011b & 00110100b = 00110000b
-01111011b & 00110101b = 00110001b
-01111011b & 00110110b = 00110010b
-01111011b & 00110111b = 00110011b
-01111011b & 00111000b = 00111000b
-01111011b & 00111001b = 00111001b
-01111011b & 00111010b = 00111010b
-01111011b & 00111011b = 00111011b
-01111011b & 00111100b = 00111000b
-01111011b & 00111101b = 00111001b
-01111011b & 00111110b = 00111010b
-01111011b & 00111111b = 00111011b
-01111011b & 01000000b = 01000000b
-01111011b & 01000001b = 01000001b
-01111011b & 01000010b = 01000010b
-01111011b & 01000011b = 01000011b
-01111011b & 01000100b = 01000000b
-01111011b & 01000101b = 01000001b
-01111011b & 01000110b = 01000010b
-01111011b & 01000111b = 01000011b
-01111011b & 01001000b = 01001000b
-01111011b & 01001001b = 01001001b
-01111011b & 01001010b = 01001010b
-01111011b & 01001011b = 01001011b
-01111011b & 01001100b = 01001000b
-01111011b & 01001101b = 01001001b
-01111011b & 01001110b = 01001010b
-01111011b & 01001111b = 01001011b
-01111011b & 01010000b = 01010000b
-01111011b & 01010001b = 01010001b
-01111011b & 01010010b = 01010010b
-01111011b & 01010011b = 01010011b
-01111011b & 01010100b = 01010000b
-01111011b & 01010101b = 01010001b
-01111011b & 01010110b = 01010010b
-01111011b & 01010111b = 01010011b
-01111011b & 01011000b = 01011000b
-01111011b & 01011001b = 01011001b
-01111011b & 01011010b = 01011010b
-01111011b & 01011011b = 01011011b
-01111011b & 01011100b = 01011000b
-01111011b & 01011101b = 01011001b
-01111011b & 01011110b = 01011010b
-01111011b & 01011111b = 01011011b
-01111011b & 01100000b = 01100000b
-01111011b & 01100001b = 01100001b
-01111011b & 01100010b = 01100010b
-01111011b & 01100011b = 01100011b
-01111011b & 01100100b = 01100000b
-01111011b & 01100101b = 01100001b
-01111011b & 01100110b = 01100010b
-01111011b & 01100111b = 01100011b
-01111011b & 01101000b = 01101000b
-01111011b & 01101001b = 01101001b
-01111011b & 01101010b = 01101010b
-01111011b & 01101011b = 01101011b
-01111011b & 01101100b = 01101000b
-01111011b & 01101101b = 01101001b
-01111011b & 01101110b = 01101010b
-01111011b & 01101111b = 01101011b
-01111011b & 01110000b = 01110000b
-01111011b & 01110001b = 01110001b
-01111011b & 01110010b = 01110010b
-01111011b & 01110011b = 01110011b
-01111011b & 01110100b = 01110000b
-01111011b & 01110101b = 01110001b
-01111011b & 01110110b = 01110010b
-01111011b & 01110111b = 01110011b
-01111011b & 01111000b = 01111000b
-01111011b & 01111001b = 01111001b
-01111011b & 01111010b = 01111010b
-01111011b & 01111011b = 01111011b
-01111011b & 01111100b = 01111000b
-01111011b & 01111101b = 01111001b
-01111011b & 01111110b = 01111010b
-01111100b & 10000000b = 00000000b
-01111100b & 10000001b = 00000000b
-01111100b & 10000010b = 00000000b
-01111100b & 10000011b = 00000000b
-01111100b & 10000100b = 00000100b
-01111100b & 10000101b = 00000100b
-01111100b & 10000110b = 00000100b
-01111100b & 10000111b = 00000100b
-01111100b & 10001000b = 00001000b
-01111100b & 10001001b = 00001000b
-01111100b & 10001010b = 00001000b
-01111100b & 10001011b = 00001000b
-01111100b & 10001100b = 00001100b
-01111100b & 10001101b = 00001100b
-01111100b & 10001110b = 00001100b
-01111100b & 10001111b = 00001100b
-01111100b & 10010000b = 00010000b
-01111100b & 10010001b = 00010000b
-01111100b & 10010010b = 00010000b
-01111100b & 10010011b = 00010000b
-01111100b & 10010100b = 00010100b
-01111100b & 10010101b = 00010100b
-01111100b & 10010110b = 00010100b
-01111100b & 10010111b = 00010100b
-01111100b & 10011000b = 00011000b
-01111100b & 10011001b = 00011000b
-01111100b & 10011010b = 00011000b
-01111100b & 10011011b = 00011000b
-01111100b & 10011100b = 00011100b
-01111100b & 10011101b = 00011100b
-01111100b & 10011110b = 00011100b
-01111100b & 10011111b = 00011100b
-01111100b & 10100000b = 00100000b
-01111100b & 10100001b = 00100000b
-01111100b & 10100010b = 00100000b
-01111100b & 10100011b = 00100000b
-01111100b & 10100100b = 00100100b
-01111100b & 10100101b = 00100100b
-01111100b & 10100110b = 00100100b
-01111100b & 10100111b = 00100100b
-01111100b & 10101000b = 00101000b
-01111100b & 10101001b = 00101000b
-01111100b & 10101010b = 00101000b
-01111100b & 10101011b = 00101000b
-01111100b & 10101100b = 00101100b
-01111100b & 10101101b = 00101100b
-01111100b & 10101110b = 00101100b
-01111100b & 10101111b = 00101100b
-01111100b & 10110000b = 00110000b
-01111100b & 10110001b = 00110000b
-01111100b & 10110010b = 00110000b
-01111100b & 10110011b = 00110000b
-01111100b & 10110100b = 00110100b
-01111100b & 10110101b = 00110100b
-01111100b & 10110110b = 00110100b
-01111100b & 10110111b = 00110100b
-01111100b & 10111000b = 00111000b
-01111100b & 10111001b = 00111000b
-01111100b & 10111010b = 00111000b
-01111100b & 10111011b = 00111000b
-01111100b & 10111100b = 00111100b
-01111100b & 10111101b = 00111100b
-01111100b & 10111110b = 00111100b
-01111100b & 10111111b = 00111100b
-01111100b & 11000000b = 01000000b
-01111100b & 11000001b = 01000000b
-01111100b & 11000010b = 01000000b
-01111100b & 11000011b = 01000000b
-01111100b & 11000100b = 01000100b
-01111100b & 11000101b = 01000100b
-01111100b & 11000110b = 01000100b
-01111100b & 11000111b = 01000100b
-01111100b & 11001000b = 01001000b
-01111100b & 11001001b = 01001000b
-01111100b & 11001010b = 01001000b
-01111100b & 11001011b = 01001000b
-01111100b & 11001100b = 01001100b
-01111100b & 11001101b = 01001100b
-01111100b & 11001110b = 01001100b
-01111100b & 11001111b = 01001100b
-01111100b & 11010000b = 01010000b
-01111100b & 11010001b = 01010000b
-01111100b & 11010010b = 01010000b
-01111100b & 11010011b = 01010000b
-01111100b & 11010100b = 01010100b
-01111100b & 11010101b = 01010100b
-01111100b & 11010110b = 01010100b
-01111100b & 11010111b = 01010100b
-01111100b & 11011000b = 01011000b
-01111100b & 11011001b = 01011000b
-01111100b & 11011010b = 01011000b
-01111100b & 11011011b = 01011000b
-01111100b & 11011100b = 01011100b
-01111100b & 11011101b = 01011100b
-01111100b & 11011110b = 01011100b
-01111100b & 11011111b = 01011100b
-01111100b & 11100000b = 01100000b
-01111100b & 11100001b = 01100000b
-01111100b & 11100010b = 01100000b
-01111100b & 11100011b = 01100000b
-01111100b & 11100100b = 01100100b
-01111100b & 11100101b = 01100100b
-01111100b & 11100110b = 01100100b
-01111100b & 11100111b = 01100100b
-01111100b & 11101000b = 01101000b
-01111100b & 11101001b = 01101000b
-01111100b & 11101010b = 01101000b
-01111100b & 11101011b = 01101000b
-01111100b & 11101100b = 01101100b
-01111100b & 11101101b = 01101100b
-01111100b & 11101110b = 01101100b
-01111100b & 11101111b = 01101100b
-01111100b & 11110000b = 01110000b
-01111100b & 11110001b = 01110000b
-01111100b & 11110010b = 01110000b
-01111100b & 11110011b = 01110000b
-01111100b & 11110100b = 01110100b
-01111100b & 11110101b = 01110100b
-01111100b & 11110110b = 01110100b
-01111100b & 11110111b = 01110100b
-01111100b & 11111000b = 01111000b
-01111100b & 11111001b = 01111000b
-01111100b & 11111010b = 01111000b
-01111100b & 11111011b = 01111000b
-01111100b & 11111100b = 01111100b
-01111100b & 11111101b = 01111100b
-01111100b & 11111110b = 01111100b
-01111100b & 11111111b = 01111100b
-01111100b & 00000000b = 00000000b
-01111100b & 00000001b = 00000000b
-01111100b & 00000010b = 00000000b
-01111100b & 00000011b = 00000000b
-01111100b & 00000100b = 00000100b
-01111100b & 00000101b = 00000100b
-01111100b & 00000110b = 00000100b
-01111100b & 00000111b = 00000100b
-01111100b & 00001000b = 00001000b
-01111100b & 00001001b = 00001000b
-01111100b & 00001010b = 00001000b
-01111100b & 00001011b = 00001000b
-01111100b & 00001100b = 00001100b
-01111100b & 00001101b = 00001100b
-01111100b & 00001110b = 00001100b
-01111100b & 00001111b = 00001100b
-01111100b & 00010000b = 00010000b
-01111100b & 00010001b = 00010000b
-01111100b & 00010010b = 00010000b
-01111100b & 00010011b = 00010000b
-01111100b & 00010100b = 00010100b
-01111100b & 00010101b = 00010100b
-01111100b & 00010110b = 00010100b
-01111100b & 00010111b = 00010100b
-01111100b & 00011000b = 00011000b
-01111100b & 00011001b = 00011000b
-01111100b & 00011010b = 00011000b
-01111100b & 00011011b = 00011000b
-01111100b & 00011100b = 00011100b
-01111100b & 00011101b = 00011100b
-01111100b & 00011110b = 00011100b
-01111100b & 00011111b = 00011100b
-01111100b & 00100000b = 00100000b
-01111100b & 00100001b = 00100000b
-01111100b & 00100010b = 00100000b
-01111100b & 00100011b = 00100000b
-01111100b & 00100100b = 00100100b
-01111100b & 00100101b = 00100100b
-01111100b & 00100110b = 00100100b
-01111100b & 00100111b = 00100100b
-01111100b & 00101000b = 00101000b
-01111100b & 00101001b = 00101000b
-01111100b & 00101010b = 00101000b
-01111100b & 00101011b = 00101000b
-01111100b & 00101100b = 00101100b
-01111100b & 00101101b = 00101100b
-01111100b & 00101110b = 00101100b
-01111100b & 00101111b = 00101100b
-01111100b & 00110000b = 00110000b
-01111100b & 00110001b = 00110000b
-01111100b & 00110010b = 00110000b
-01111100b & 00110011b = 00110000b
-01111100b & 00110100b = 00110100b
-01111100b & 00110101b = 00110100b
-01111100b & 00110110b = 00110100b
-01111100b & 00110111b = 00110100b
-01111100b & 00111000b = 00111000b
-01111100b & 00111001b = 00111000b
-01111100b & 00111010b = 00111000b
-01111100b & 00111011b = 00111000b
-01111100b & 00111100b = 00111100b
-01111100b & 00111101b = 00111100b
-01111100b & 00111110b = 00111100b
-01111100b & 00111111b = 00111100b
-01111100b & 01000000b = 01000000b
-01111100b & 01000001b = 01000000b
-01111100b & 01000010b = 01000000b
-01111100b & 01000011b = 01000000b
-01111100b & 01000100b = 01000100b
-01111100b & 01000101b = 01000100b
-01111100b & 01000110b = 01000100b
-01111100b & 01000111b = 01000100b
-01111100b & 01001000b = 01001000b
-01111100b & 01001001b = 01001000b
-01111100b & 01001010b = 01001000b
-01111100b & 01001011b = 01001000b
-01111100b & 01001100b = 01001100b
-01111100b & 01001101b = 01001100b
-01111100b & 01001110b = 01001100b
-01111100b & 01001111b = 01001100b
-01111100b & 01010000b = 01010000b
-01111100b & 01010001b = 01010000b
-01111100b & 01010010b = 01010000b
-01111100b & 01010011b = 01010000b
-01111100b & 01010100b = 01010100b
-01111100b & 01010101b = 01010100b
-01111100b & 01010110b = 01010100b
-01111100b & 01010111b = 01010100b
-01111100b & 01011000b = 01011000b
-01111100b & 01011001b = 01011000b
-01111100b & 01011010b = 01011000b
-01111100b & 01011011b = 01011000b
-01111100b & 01011100b = 01011100b
-01111100b & 01011101b = 01011100b
-01111100b & 01011110b = 01011100b
-01111100b & 01011111b = 01011100b
-01111100b & 01100000b = 01100000b
-01111100b & 01100001b = 01100000b
-01111100b & 01100010b = 01100000b
-01111100b & 01100011b = 01100000b
-01111100b & 01100100b = 01100100b
-01111100b & 01100101b = 01100100b
-01111100b & 01100110b = 01100100b
-01111100b & 01100111b = 01100100b
-01111100b & 01101000b = 01101000b
-01111100b & 01101001b = 01101000b
-01111100b & 01101010b = 01101000b
-01111100b & 01101011b = 01101000b
-01111100b & 01101100b = 01101100b
-01111100b & 01101101b = 01101100b
-01111100b & 01101110b = 01101100b
-01111100b & 01101111b = 01101100b
-01111100b & 01110000b = 01110000b
-01111100b & 01110001b = 01110000b
-01111100b & 01110010b = 01110000b
-01111100b & 01110011b = 01110000b
-01111100b & 01110100b = 01110100b
-01111100b & 01110101b = 01110100b
-01111100b & 01110110b = 01110100b
-01111100b & 01110111b = 01110100b
-01111100b & 01111000b = 01111000b
-01111100b & 01111001b = 01111000b
-01111100b & 01111010b = 01111000b
-01111100b & 01111011b = 01111000b
-01111100b & 01111100b = 01111100b
-01111100b & 01111101b = 01111100b
-01111100b & 01111110b = 01111100b
-01111101b & 10000000b = 00000000b
-01111101b & 10000001b = 00000001b
-01111101b & 10000010b = 00000000b
-01111101b & 10000011b = 00000001b
-01111101b & 10000100b = 00000100b
-01111101b & 10000101b = 00000101b
-01111101b & 10000110b = 00000100b
-01111101b & 10000111b = 00000101b
-01111101b & 10001000b = 00001000b
-01111101b & 10001001b = 00001001b
-01111101b & 10001010b = 00001000b
-01111101b & 10001011b = 00001001b
-01111101b & 10001100b = 00001100b
-01111101b & 10001101b = 00001101b
-01111101b & 10001110b = 00001100b
-01111101b & 10001111b = 00001101b
-01111101b & 10010000b = 00010000b
-01111101b & 10010001b = 00010001b
-01111101b & 10010010b = 00010000b
-01111101b & 10010011b = 00010001b
-01111101b & 10010100b = 00010100b
-01111101b & 10010101b = 00010101b
-01111101b & 10010110b = 00010100b
-01111101b & 10010111b = 00010101b
-01111101b & 10011000b = 00011000b
-01111101b & 10011001b = 00011001b
-01111101b & 10011010b = 00011000b
-01111101b & 10011011b = 00011001b
-01111101b & 10011100b = 00011100b
-01111101b & 10011101b = 00011101b
-01111101b & 10011110b = 00011100b
-01111101b & 10011111b = 00011101b
-01111101b & 10100000b = 00100000b
-01111101b & 10100001b = 00100001b
-01111101b & 10100010b = 00100000b
-01111101b & 10100011b = 00100001b
-01111101b & 10100100b = 00100100b
-01111101b & 10100101b = 00100101b
-01111101b & 10100110b = 00100100b
-01111101b & 10100111b = 00100101b
-01111101b & 10101000b = 00101000b
-01111101b & 10101001b = 00101001b
-01111101b & 10101010b = 00101000b
-01111101b & 10101011b = 00101001b
-01111101b & 10101100b = 00101100b
-01111101b & 10101101b = 00101101b
-01111101b & 10101110b = 00101100b
-01111101b & 10101111b = 00101101b
-01111101b & 10110000b = 00110000b
-01111101b & 10110001b = 00110001b
-01111101b & 10110010b = 00110000b
-01111101b & 10110011b = 00110001b
-01111101b & 10110100b = 00110100b
-01111101b & 10110101b = 00110101b
-01111101b & 10110110b = 00110100b
-01111101b & 10110111b = 00110101b
-01111101b & 10111000b = 00111000b
-01111101b & 10111001b = 00111001b
-01111101b & 10111010b = 00111000b
-01111101b & 10111011b = 00111001b
-01111101b & 10111100b = 00111100b
-01111101b & 10111101b = 00111101b
-01111101b & 10111110b = 00111100b
-01111101b & 10111111b = 00111101b
-01111101b & 11000000b = 01000000b
-01111101b & 11000001b = 01000001b
-01111101b & 11000010b = 01000000b
-01111101b & 11000011b = 01000001b
-01111101b & 11000100b = 01000100b
-01111101b & 11000101b = 01000101b
-01111101b & 11000110b = 01000100b
-01111101b & 11000111b = 01000101b
-01111101b & 11001000b = 01001000b
-01111101b & 11001001b = 01001001b
-01111101b & 11001010b = 01001000b
-01111101b & 11001011b = 01001001b
-01111101b & 11001100b = 01001100b
-01111101b & 11001101b = 01001101b
-01111101b & 11001110b = 01001100b
-01111101b & 11001111b = 01001101b
-01111101b & 11010000b = 01010000b
-01111101b & 11010001b = 01010001b
-01111101b & 11010010b = 01010000b
-01111101b & 11010011b = 01010001b
-01111101b & 11010100b = 01010100b
-01111101b & 11010101b = 01010101b
-01111101b & 11010110b = 01010100b
-01111101b & 11010111b = 01010101b
-01111101b & 11011000b = 01011000b
-01111101b & 11011001b = 01011001b
-01111101b & 11011010b = 01011000b
-01111101b & 11011011b = 01011001b
-01111101b & 11011100b = 01011100b
-01111101b & 11011101b = 01011101b
-01111101b & 11011110b = 01011100b
-01111101b & 11011111b = 01011101b
-01111101b & 11100000b = 01100000b
-01111101b & 11100001b = 01100001b
-01111101b & 11100010b = 01100000b
-01111101b & 11100011b = 01100001b
-01111101b & 11100100b = 01100100b
-01111101b & 11100101b = 01100101b
-01111101b & 11100110b = 01100100b
-01111101b & 11100111b = 01100101b
-01111101b & 11101000b = 01101000b
-01111101b & 11101001b = 01101001b
-01111101b & 11101010b = 01101000b
-01111101b & 11101011b = 01101001b
-01111101b & 11101100b = 01101100b
-01111101b & 11101101b = 01101101b
-01111101b & 11101110b = 01101100b
-01111101b & 11101111b = 01101101b
-01111101b & 11110000b = 01110000b
-01111101b & 11110001b = 01110001b
-01111101b & 11110010b = 01110000b
-01111101b & 11110011b = 01110001b
-01111101b & 11110100b = 01110100b
-01111101b & 11110101b = 01110101b
-01111101b & 11110110b = 01110100b
-01111101b & 11110111b = 01110101b
-01111101b & 11111000b = 01111000b
-01111101b & 11111001b = 01111001b
-01111101b & 11111010b = 01111000b
-01111101b & 11111011b = 01111001b
-01111101b & 11111100b = 01111100b
-01111101b & 11111101b = 01111101b
-01111101b & 11111110b = 01111100b
-01111101b & 11111111b = 01111101b
-01111101b & 00000000b = 00000000b
-01111101b & 00000001b = 00000001b
-01111101b & 00000010b = 00000000b
-01111101b & 00000011b = 00000001b
-01111101b & 00000100b = 00000100b
-01111101b & 00000101b = 00000101b
-01111101b & 00000110b = 00000100b
-01111101b & 00000111b = 00000101b
-01111101b & 00001000b = 00001000b
-01111101b & 00001001b = 00001001b
-01111101b & 00001010b = 00001000b
-01111101b & 00001011b = 00001001b
-01111101b & 00001100b = 00001100b
-01111101b & 00001101b = 00001101b
-01111101b & 00001110b = 00001100b
-01111101b & 00001111b = 00001101b
-01111101b & 00010000b = 00010000b
-01111101b & 00010001b = 00010001b
-01111101b & 00010010b = 00010000b
-01111101b & 00010011b = 00010001b
-01111101b & 00010100b = 00010100b
-01111101b & 00010101b = 00010101b
-01111101b & 00010110b = 00010100b
-01111101b & 00010111b = 00010101b
-01111101b & 00011000b = 00011000b
-01111101b & 00011001b = 00011001b
-01111101b & 00011010b = 00011000b
-01111101b & 00011011b = 00011001b
-01111101b & 00011100b = 00011100b
-01111101b & 00011101b = 00011101b
-01111101b & 00011110b = 00011100b
-01111101b & 00011111b = 00011101b
-01111101b & 00100000b = 00100000b
-01111101b & 00100001b = 00100001b
-01111101b & 00100010b = 00100000b
-01111101b & 00100011b = 00100001b
-01111101b & 00100100b = 00100100b
-01111101b & 00100101b = 00100101b
-01111101b & 00100110b = 00100100b
-01111101b & 00100111b = 00100101b
-01111101b & 00101000b = 00101000b
-01111101b & 00101001b = 00101001b
-01111101b & 00101010b = 00101000b
-01111101b & 00101011b = 00101001b
-01111101b & 00101100b = 00101100b
-01111101b & 00101101b = 00101101b
-01111101b & 00101110b = 00101100b
-01111101b & 00101111b = 00101101b
-01111101b & 00110000b = 00110000b
-01111101b & 00110001b = 00110001b
-01111101b & 00110010b = 00110000b
-01111101b & 00110011b = 00110001b
-01111101b & 00110100b = 00110100b
-01111101b & 00110101b = 00110101b
-01111101b & 00110110b = 00110100b
-01111101b & 00110111b = 00110101b
-01111101b & 00111000b = 00111000b
-01111101b & 00111001b = 00111001b
-01111101b & 00111010b = 00111000b
-01111101b & 00111011b = 00111001b
-01111101b & 00111100b = 00111100b
-01111101b & 00111101b = 00111101b
-01111101b & 00111110b = 00111100b
-01111101b & 00111111b = 00111101b
-01111101b & 01000000b = 01000000b
-01111101b & 01000001b = 01000001b
-01111101b & 01000010b = 01000000b
-01111101b & 01000011b = 01000001b
-01111101b & 01000100b = 01000100b
-01111101b & 01000101b = 01000101b
-01111101b & 01000110b = 01000100b
-01111101b & 01000111b = 01000101b
-01111101b & 01001000b = 01001000b
-01111101b & 01001001b = 01001001b
-01111101b & 01001010b = 01001000b
-01111101b & 01001011b = 01001001b
-01111101b & 01001100b = 01001100b
-01111101b & 01001101b = 01001101b
-01111101b & 01001110b = 01001100b
-01111101b & 01001111b = 01001101b
-01111101b & 01010000b = 01010000b
-01111101b & 01010001b = 01010001b
-01111101b & 01010010b = 01010000b
-01111101b & 01010011b = 01010001b
-01111101b & 01010100b = 01010100b
-01111101b & 01010101b = 01010101b
-01111101b & 01010110b = 01010100b
-01111101b & 01010111b = 01010101b
-01111101b & 01011000b = 01011000b
-01111101b & 01011001b = 01011001b
-01111101b & 01011010b = 01011000b
-01111101b & 01011011b = 01011001b
-01111101b & 01011100b = 01011100b
-01111101b & 01011101b = 01011101b
-01111101b & 01011110b = 01011100b
-01111101b & 01011111b = 01011101b
-01111101b & 01100000b = 01100000b
-01111101b & 01100001b = 01100001b
-01111101b & 01100010b = 01100000b
-01111101b & 01100011b = 01100001b
-01111101b & 01100100b = 01100100b
-01111101b & 01100101b = 01100101b
-01111101b & 01100110b = 01100100b
-01111101b & 01100111b = 01100101b
-01111101b & 01101000b = 01101000b
-01111101b & 01101001b = 01101001b
-01111101b & 01101010b = 01101000b
-01111101b & 01101011b = 01101001b
-01111101b & 01101100b = 01101100b
-01111101b & 01101101b = 01101101b
-01111101b & 01101110b = 01101100b
-01111101b & 01101111b = 01101101b
-01111101b & 01110000b = 01110000b
-01111101b & 01110001b = 01110001b
-01111101b & 01110010b = 01110000b
-01111101b & 01110011b = 01110001b
-01111101b & 01110100b = 01110100b
-01111101b & 01110101b = 01110101b
-01111101b & 01110110b = 01110100b
-01111101b & 01110111b = 01110101b
-01111101b & 01111000b = 01111000b
-01111101b & 01111001b = 01111001b
-01111101b & 01111010b = 01111000b
-01111101b & 01111011b = 01111001b
-01111101b & 01111100b = 01111100b
-01111101b & 01111101b = 01111101b
-01111101b & 01111110b = 01111100b
-01111110b & 10000000b = 00000000b
-01111110b & 10000001b = 00000000b
-01111110b & 10000010b = 00000010b
-01111110b & 10000011b = 00000010b
-01111110b & 10000100b = 00000100b
-01111110b & 10000101b = 00000100b
-01111110b & 10000110b = 00000110b
-01111110b & 10000111b = 00000110b
-01111110b & 10001000b = 00001000b
-01111110b & 10001001b = 00001000b
-01111110b & 10001010b = 00001010b
-01111110b & 10001011b = 00001010b
-01111110b & 10001100b = 00001100b
-01111110b & 10001101b = 00001100b
-01111110b & 10001110b = 00001110b
-01111110b & 10001111b = 00001110b
-01111110b & 10010000b = 00010000b
-01111110b & 10010001b = 00010000b
-01111110b & 10010010b = 00010010b
-01111110b & 10010011b = 00010010b
-01111110b & 10010100b = 00010100b
-01111110b & 10010101b = 00010100b
-01111110b & 10010110b = 00010110b
-01111110b & 10010111b = 00010110b
-01111110b & 10011000b = 00011000b
-01111110b & 10011001b = 00011000b
-01111110b & 10011010b = 00011010b
-01111110b & 10011011b = 00011010b
-01111110b & 10011100b = 00011100b
-01111110b & 10011101b = 00011100b
-01111110b & 10011110b = 00011110b
-01111110b & 10011111b = 00011110b
-01111110b & 10100000b = 00100000b
-01111110b & 10100001b = 00100000b
-01111110b & 10100010b = 00100010b
-01111110b & 10100011b = 00100010b
-01111110b & 10100100b = 00100100b
-01111110b & 10100101b = 00100100b
-01111110b & 10100110b = 00100110b
-01111110b & 10100111b = 00100110b
-01111110b & 10101000b = 00101000b
-01111110b & 10101001b = 00101000b
-01111110b & 10101010b = 00101010b
-01111110b & 10101011b = 00101010b
-01111110b & 10101100b = 00101100b
-01111110b & 10101101b = 00101100b
-01111110b & 10101110b = 00101110b
-01111110b & 10101111b = 00101110b
-01111110b & 10110000b = 00110000b
-01111110b & 10110001b = 00110000b
-01111110b & 10110010b = 00110010b
-01111110b & 10110011b = 00110010b
-01111110b & 10110100b = 00110100b
-01111110b & 10110101b = 00110100b
-01111110b & 10110110b = 00110110b
-01111110b & 10110111b = 00110110b
-01111110b & 10111000b = 00111000b
-01111110b & 10111001b = 00111000b
-01111110b & 10111010b = 00111010b
-01111110b & 10111011b = 00111010b
-01111110b & 10111100b = 00111100b
-01111110b & 10111101b = 00111100b
-01111110b & 10111110b = 00111110b
-01111110b & 10111111b = 00111110b
-01111110b & 11000000b = 01000000b
-01111110b & 11000001b = 01000000b
-01111110b & 11000010b = 01000010b
-01111110b & 11000011b = 01000010b
-01111110b & 11000100b = 01000100b
-01111110b & 11000101b = 01000100b
-01111110b & 11000110b = 01000110b
-01111110b & 11000111b = 01000110b
-01111110b & 11001000b = 01001000b
-01111110b & 11001001b = 01001000b
-01111110b & 11001010b = 01001010b
-01111110b & 11001011b = 01001010b
-01111110b & 11001100b = 01001100b
-01111110b & 11001101b = 01001100b
-01111110b & 11001110b = 01001110b
-01111110b & 11001111b = 01001110b
-01111110b & 11010000b = 01010000b
-01111110b & 11010001b = 01010000b
-01111110b & 11010010b = 01010010b
-01111110b & 11010011b = 01010010b
-01111110b & 11010100b = 01010100b
-01111110b & 11010101b = 01010100b
-01111110b & 11010110b = 01010110b
-01111110b & 11010111b = 01010110b
-01111110b & 11011000b = 01011000b
-01111110b & 11011001b = 01011000b
-01111110b & 11011010b = 01011010b
-01111110b & 11011011b = 01011010b
-01111110b & 11011100b = 01011100b
-01111110b & 11011101b = 01011100b
-01111110b & 11011110b = 01011110b
-01111110b & 11011111b = 01011110b
-01111110b & 11100000b = 01100000b
-01111110b & 11100001b = 01100000b
-01111110b & 11100010b = 01100010b
-01111110b & 11100011b = 01100010b
-01111110b & 11100100b = 01100100b
-01111110b & 11100101b = 01100100b
-01111110b & 11100110b = 01100110b
-01111110b & 11100111b = 01100110b
-01111110b & 11101000b = 01101000b
-01111110b & 11101001b = 01101000b
-01111110b & 11101010b = 01101010b
-01111110b & 11101011b = 01101010b
-01111110b & 11101100b = 01101100b
-01111110b & 11101101b = 01101100b
-01111110b & 11101110b = 01101110b
-01111110b & 11101111b = 01101110b
-01111110b & 11110000b = 01110000b
-01111110b & 11110001b = 01110000b
-01111110b & 11110010b = 01110010b
-01111110b & 11110011b = 01110010b
-01111110b & 11110100b = 01110100b
-01111110b & 11110101b = 01110100b
-01111110b & 11110110b = 01110110b
-01111110b & 11110111b = 01110110b
-01111110b & 11111000b = 01111000b
-01111110b & 11111001b = 01111000b
-01111110b & 11111010b = 01111010b
-01111110b & 11111011b = 01111010b
-01111110b & 11111100b = 01111100b
-01111110b & 11111101b = 01111100b
-01111110b & 11111110b = 01111110b
-01111110b & 11111111b = 01111110b
-01111110b & 00000000b = 00000000b
-01111110b & 00000001b = 00000000b
-01111110b & 00000010b = 00000010b
-01111110b & 00000011b = 00000010b
-01111110b & 00000100b = 00000100b
-01111110b & 00000101b = 00000100b
-01111110b & 00000110b = 00000110b
-01111110b & 00000111b = 00000110b
-01111110b & 00001000b = 00001000b
-01111110b & 00001001b = 00001000b
-01111110b & 00001010b = 00001010b
-01111110b & 00001011b = 00001010b
-01111110b & 00001100b = 00001100b
-01111110b & 00001101b = 00001100b
-01111110b & 00001110b = 00001110b
-01111110b & 00001111b = 00001110b
-01111110b & 00010000b = 00010000b
-01111110b & 00010001b = 00010000b
-01111110b & 00010010b = 00010010b
-01111110b & 00010011b = 00010010b
-01111110b & 00010100b = 00010100b
-01111110b & 00010101b = 00010100b
-01111110b & 00010110b = 00010110b
-01111110b & 00010111b = 00010110b
-01111110b & 00011000b = 00011000b
-01111110b & 00011001b = 00011000b
-01111110b & 00011010b = 00011010b
-01111110b & 00011011b = 00011010b
-01111110b & 00011100b = 00011100b
-01111110b & 00011101b = 00011100b
-01111110b & 00011110b = 00011110b
-01111110b & 00011111b = 00011110b
-01111110b & 00100000b = 00100000b
-01111110b & 00100001b = 00100000b
-01111110b & 00100010b = 00100010b
-01111110b & 00100011b = 00100010b
-01111110b & 00100100b = 00100100b
-01111110b & 00100101b = 00100100b
-01111110b & 00100110b = 00100110b
-01111110b & 00100111b = 00100110b
-01111110b & 00101000b = 00101000b
-01111110b & 00101001b = 00101000b
-01111110b & 00101010b = 00101010b
-01111110b & 00101011b = 00101010b
-01111110b & 00101100b = 00101100b
-01111110b & 00101101b = 00101100b
-01111110b & 00101110b = 00101110b
-01111110b & 00101111b = 00101110b
-01111110b & 00110000b = 00110000b
-01111110b & 00110001b = 00110000b
-01111110b & 00110010b = 00110010b
-01111110b & 00110011b = 00110010b
-01111110b & 00110100b = 00110100b
-01111110b & 00110101b = 00110100b
-01111110b & 00110110b = 00110110b
-01111110b & 00110111b = 00110110b
-01111110b & 00111000b = 00111000b
-01111110b & 00111001b = 00111000b
-01111110b & 00111010b = 00111010b
-01111110b & 00111011b = 00111010b
-01111110b & 00111100b = 00111100b
-01111110b & 00111101b = 00111100b
-01111110b & 00111110b = 00111110b
-01111110b & 00111111b = 00111110b
-01111110b & 01000000b = 01000000b
-01111110b & 01000001b = 01000000b
-01111110b & 01000010b = 01000010b
-01111110b & 01000011b = 01000010b
-01111110b & 01000100b = 01000100b
-01111110b & 01000101b = 01000100b
-01111110b & 01000110b = 01000110b
-01111110b & 01000111b = 01000110b
-01111110b & 01001000b = 01001000b
-01111110b & 01001001b = 01001000b
-01111110b & 01001010b = 01001010b
-01111110b & 01001011b = 01001010b
-01111110b & 01001100b = 01001100b
-01111110b & 01001101b = 01001100b
-01111110b & 01001110b = 01001110b
-01111110b & 01001111b = 01001110b
-01111110b & 01010000b = 01010000b
-01111110b & 01010001b = 01010000b
-01111110b & 01010010b = 01010010b
-01111110b & 01010011b = 01010010b
-01111110b & 01010100b = 01010100b
-01111110b & 01010101b = 01010100b
-01111110b & 01010110b = 01010110b
-01111110b & 01010111b = 01010110b
-01111110b & 01011000b = 01011000b
-01111110b & 01011001b = 01011000b
-01111110b & 01011010b = 01011010b
-01111110b & 01011011b = 01011010b
-01111110b & 01011100b = 01011100b
-01111110b & 01011101b = 01011100b
-01111110b & 01011110b = 01011110b
-01111110b & 01011111b = 01011110b
-01111110b & 01100000b = 01100000b
-01111110b & 01100001b = 01100000b
-01111110b & 01100010b = 01100010b
-01111110b & 01100011b = 01100010b
-01111110b & 01100100b = 01100100b
-01111110b & 01100101b = 01100100b
-01111110b & 01100110b = 01100110b
-01111110b & 01100111b = 01100110b
-01111110b & 01101000b = 01101000b
-01111110b & 01101001b = 01101000b
-01111110b & 01101010b = 01101010b
-01111110b & 01101011b = 01101010b
-01111110b & 01101100b = 01101100b
-01111110b & 01101101b = 01101100b
-01111110b & 01101110b = 01101110b
-01111110b & 01101111b = 01101110b
-01111110b & 01110000b = 01110000b
-01111110b & 01110001b = 01110000b
-01111110b & 01110010b = 01110010b
-01111110b & 01110011b = 01110010b
-01111110b & 01110100b = 01110100b
-01111110b & 01110101b = 01110100b
-01111110b & 01110110b = 01110110b
-01111110b & 01110111b = 01110110b
-01111110b & 01111000b = 01111000b
-01111110b & 01111001b = 01111000b
-01111110b & 01111010b = 01111010b
-01111110b & 01111011b = 01111010b
-01111110b & 01111100b = 01111100b
-01111110b & 01111101b = 01111100b
-01111110b & 01111110b = 01111110b
diff --git a/tests/valid/Byte_Valid_2.whiley b/tests/valid/Byte_Valid_2.whiley
index 404a5b70e6..bf85dc795a 100644
--- a/tests/valid/Byte_Valid_2.whiley
+++ b/tests/valid/Byte_Valid_2.whiley
@@ -1,11 +1,31 @@
-import whiley.lang.*
-import print from whiley.lang.*
+
constant constants is [10000000b, 10000001b, 10000010b, 10000011b, 10000100b, 10000101b, 10000110b, 10000111b, 10001000b, 10001001b, 10001010b, 10001011b, 10001100b, 10001101b, 10001110b, 10001111b, 10010000b, 10010001b, 10010010b, 10010011b, 10010100b, 10010101b, 10010110b, 10010111b, 10011000b, 10011001b, 10011010b, 10011011b, 10011100b, 10011101b, 10011110b, 10011111b, 10100000b, 10100001b, 10100010b, 10100011b, 10100100b, 10100101b, 10100110b, 10100111b, 10101000b, 10101001b, 10101010b, 10101011b, 10101100b, 10101101b, 10101110b, 10101111b, 10110000b, 10110001b, 10110010b, 10110011b, 10110100b, 10110101b, 10110110b, 10110111b, 10111000b, 10111001b, 10111010b, 10111011b, 10111100b, 10111101b, 10111110b, 10111111b, 11000000b, 11000001b, 11000010b, 11000011b, 11000100b, 11000101b, 11000110b, 11000111b, 11001000b, 11001001b, 11001010b, 11001011b, 11001100b, 11001101b, 11001110b, 11001111b, 11010000b, 11010001b, 11010010b, 11010011b, 11010100b, 11010101b, 11010110b, 11010111b, 11011000b, 11011001b, 11011010b, 11011011b, 11011100b, 11011101b, 11011110b, 11011111b, 11100000b, 11100001b, 11100010b, 11100011b, 11100100b, 11100101b, 11100110b, 11100111b, 11101000b, 11101001b, 11101010b, 11101011b, 11101100b, 11101101b, 11101110b, 11101111b, 11110000b, 11110001b, 11110010b, 11110011b, 11110100b, 11110101b, 11110110b, 11110111b, 11111000b, 11111001b, 11111010b, 11111011b, 11111100b, 11111101b, 11111110b, 11111111b, 00000000b, 00000001b, 00000010b, 00000011b, 00000100b, 00000101b, 00000110b, 00000111b, 00001000b, 00001001b, 00001010b, 00001011b, 00001100b, 00001101b, 00001110b, 00001111b, 00010000b, 00010001b, 00010010b, 00010011b, 00010100b, 00010101b, 00010110b, 00010111b, 00011000b, 00011001b, 00011010b, 00011011b, 00011100b, 00011101b, 00011110b, 00011111b, 00100000b, 00100001b, 00100010b, 00100011b, 00100100b, 00100101b, 00100110b, 00100111b, 00101000b, 00101001b, 00101010b, 00101011b, 00101100b, 00101101b, 00101110b, 00101111b, 00110000b, 00110001b, 00110010b, 00110011b, 00110100b, 00110101b, 00110110b, 00110111b, 00111000b, 00111001b, 00111010b, 00111011b, 00111100b, 00111101b, 00111110b, 00111111b, 01000000b, 01000001b, 01000010b, 01000011b, 01000100b, 01000101b, 01000110b, 01000111b, 01001000b, 01001001b, 01001010b, 01001011b, 01001100b, 01001101b, 01001110b, 01001111b, 01010000b, 01010001b, 01010010b, 01010011b, 01010100b, 01010101b, 01010110b, 01010111b, 01011000b, 01011001b, 01011010b, 01011011b, 01011100b, 01011101b, 01011110b, 01011111b, 01100000b, 01100001b, 01100010b, 01100011b, 01100100b, 01100101b, 01100110b, 01100111b, 01101000b, 01101001b, 01101010b, 01101011b, 01101100b, 01101101b, 01101110b, 01101111b, 01110000b, 01110001b, 01110010b, 01110011b, 01110100b, 01110101b, 01110110b, 01110111b, 01111000b, 01111001b, 01111010b, 01111011b, 01111100b, 01111101b, 01111110b]
-public method main(System.Console sys) -> void:
- for i in constants:
- for j in constants:
- sys.out.print_s(Any.toString(i) ++ " & ")
- sys.out.print_s(Any.toString(j) ++ " = ")
- sys.out.println_s(Any.toString(i & j))
+function set(byte b, int i) -> bool:
+ byte mask = 1b << i
+ return (b&mask) == mask
+
+function and(byte b1, byte b2) -> byte:
+ byte mask = 1b
+ byte r = 0b
+ int i = 0
+ while i < 8:
+ if set(b1,i) && set(b2,i):
+ r = r | mask
+ mask = mask << 1
+ i = i + 1
+ //
+ return r
+
+public export method test() -> void:
+ int i = 0
+ while i < |constants|:
+ byte constant_i = constants[i]
+ int j = 0
+ while j < |constants|:
+ byte constant_j = constants[j]
+ assume (constant_i & constant_j) == and(constant_i,constant_j)
+ j = j + 1
+ //
+ i = i + 1
diff --git a/tests/valid/Byte_Valid_3.sysout b/tests/valid/Byte_Valid_3.sysout
deleted file mode 100644
index 1b9fb5f2f2..0000000000
--- a/tests/valid/Byte_Valid_3.sysout
+++ /dev/null
@@ -1,65025 +0,0 @@
-10000000b | 10000000b = 10000000b
-10000000b | 10000001b = 10000001b
-10000000b | 10000010b = 10000010b
-10000000b | 10000011b = 10000011b
-10000000b | 10000100b = 10000100b
-10000000b | 10000101b = 10000101b
-10000000b | 10000110b = 10000110b
-10000000b | 10000111b = 10000111b
-10000000b | 10001000b = 10001000b
-10000000b | 10001001b = 10001001b
-10000000b | 10001010b = 10001010b
-10000000b | 10001011b = 10001011b
-10000000b | 10001100b = 10001100b
-10000000b | 10001101b = 10001101b
-10000000b | 10001110b = 10001110b
-10000000b | 10001111b = 10001111b
-10000000b | 10010000b = 10010000b
-10000000b | 10010001b = 10010001b
-10000000b | 10010010b = 10010010b
-10000000b | 10010011b = 10010011b
-10000000b | 10010100b = 10010100b
-10000000b | 10010101b = 10010101b
-10000000b | 10010110b = 10010110b
-10000000b | 10010111b = 10010111b
-10000000b | 10011000b = 10011000b
-10000000b | 10011001b = 10011001b
-10000000b | 10011010b = 10011010b
-10000000b | 10011011b = 10011011b
-10000000b | 10011100b = 10011100b
-10000000b | 10011101b = 10011101b
-10000000b | 10011110b = 10011110b
-10000000b | 10011111b = 10011111b
-10000000b | 10100000b = 10100000b
-10000000b | 10100001b = 10100001b
-10000000b | 10100010b = 10100010b
-10000000b | 10100011b = 10100011b
-10000000b | 10100100b = 10100100b
-10000000b | 10100101b = 10100101b
-10000000b | 10100110b = 10100110b
-10000000b | 10100111b = 10100111b
-10000000b | 10101000b = 10101000b
-10000000b | 10101001b = 10101001b
-10000000b | 10101010b = 10101010b
-10000000b | 10101011b = 10101011b
-10000000b | 10101100b = 10101100b
-10000000b | 10101101b = 10101101b
-10000000b | 10101110b = 10101110b
-10000000b | 10101111b = 10101111b
-10000000b | 10110000b = 10110000b
-10000000b | 10110001b = 10110001b
-10000000b | 10110010b = 10110010b
-10000000b | 10110011b = 10110011b
-10000000b | 10110100b = 10110100b
-10000000b | 10110101b = 10110101b
-10000000b | 10110110b = 10110110b
-10000000b | 10110111b = 10110111b
-10000000b | 10111000b = 10111000b
-10000000b | 10111001b = 10111001b
-10000000b | 10111010b = 10111010b
-10000000b | 10111011b = 10111011b
-10000000b | 10111100b = 10111100b
-10000000b | 10111101b = 10111101b
-10000000b | 10111110b = 10111110b
-10000000b | 10111111b = 10111111b
-10000000b | 11000000b = 11000000b
-10000000b | 11000001b = 11000001b
-10000000b | 11000010b = 11000010b
-10000000b | 11000011b = 11000011b
-10000000b | 11000100b = 11000100b
-10000000b | 11000101b = 11000101b
-10000000b | 11000110b = 11000110b
-10000000b | 11000111b = 11000111b
-10000000b | 11001000b = 11001000b
-10000000b | 11001001b = 11001001b
-10000000b | 11001010b = 11001010b
-10000000b | 11001011b = 11001011b
-10000000b | 11001100b = 11001100b
-10000000b | 11001101b = 11001101b
-10000000b | 11001110b = 11001110b
-10000000b | 11001111b = 11001111b
-10000000b | 11010000b = 11010000b
-10000000b | 11010001b = 11010001b
-10000000b | 11010010b = 11010010b
-10000000b | 11010011b = 11010011b
-10000000b | 11010100b = 11010100b
-10000000b | 11010101b = 11010101b
-10000000b | 11010110b = 11010110b
-10000000b | 11010111b = 11010111b
-10000000b | 11011000b = 11011000b
-10000000b | 11011001b = 11011001b
-10000000b | 11011010b = 11011010b
-10000000b | 11011011b = 11011011b
-10000000b | 11011100b = 11011100b
-10000000b | 11011101b = 11011101b
-10000000b | 11011110b = 11011110b
-10000000b | 11011111b = 11011111b
-10000000b | 11100000b = 11100000b
-10000000b | 11100001b = 11100001b
-10000000b | 11100010b = 11100010b
-10000000b | 11100011b = 11100011b
-10000000b | 11100100b = 11100100b
-10000000b | 11100101b = 11100101b
-10000000b | 11100110b = 11100110b
-10000000b | 11100111b = 11100111b
-10000000b | 11101000b = 11101000b
-10000000b | 11101001b = 11101001b
-10000000b | 11101010b = 11101010b
-10000000b | 11101011b = 11101011b
-10000000b | 11101100b = 11101100b
-10000000b | 11101101b = 11101101b
-10000000b | 11101110b = 11101110b
-10000000b | 11101111b = 11101111b
-10000000b | 11110000b = 11110000b
-10000000b | 11110001b = 11110001b
-10000000b | 11110010b = 11110010b
-10000000b | 11110011b = 11110011b
-10000000b | 11110100b = 11110100b
-10000000b | 11110101b = 11110101b
-10000000b | 11110110b = 11110110b
-10000000b | 11110111b = 11110111b
-10000000b | 11111000b = 11111000b
-10000000b | 11111001b = 11111001b
-10000000b | 11111010b = 11111010b
-10000000b | 11111011b = 11111011b
-10000000b | 11111100b = 11111100b
-10000000b | 11111101b = 11111101b
-10000000b | 11111110b = 11111110b
-10000000b | 11111111b = 11111111b
-10000000b | 00000000b = 10000000b
-10000000b | 00000001b = 10000001b
-10000000b | 00000010b = 10000010b
-10000000b | 00000011b = 10000011b
-10000000b | 00000100b = 10000100b
-10000000b | 00000101b = 10000101b
-10000000b | 00000110b = 10000110b
-10000000b | 00000111b = 10000111b
-10000000b | 00001000b = 10001000b
-10000000b | 00001001b = 10001001b
-10000000b | 00001010b = 10001010b
-10000000b | 00001011b = 10001011b
-10000000b | 00001100b = 10001100b
-10000000b | 00001101b = 10001101b
-10000000b | 00001110b = 10001110b
-10000000b | 00001111b = 10001111b
-10000000b | 00010000b = 10010000b
-10000000b | 00010001b = 10010001b
-10000000b | 00010010b = 10010010b
-10000000b | 00010011b = 10010011b
-10000000b | 00010100b = 10010100b
-10000000b | 00010101b = 10010101b
-10000000b | 00010110b = 10010110b
-10000000b | 00010111b = 10010111b
-10000000b | 00011000b = 10011000b
-10000000b | 00011001b = 10011001b
-10000000b | 00011010b = 10011010b
-10000000b | 00011011b = 10011011b
-10000000b | 00011100b = 10011100b
-10000000b | 00011101b = 10011101b
-10000000b | 00011110b = 10011110b
-10000000b | 00011111b = 10011111b
-10000000b | 00100000b = 10100000b
-10000000b | 00100001b = 10100001b
-10000000b | 00100010b = 10100010b
-10000000b | 00100011b = 10100011b
-10000000b | 00100100b = 10100100b
-10000000b | 00100101b = 10100101b
-10000000b | 00100110b = 10100110b
-10000000b | 00100111b = 10100111b
-10000000b | 00101000b = 10101000b
-10000000b | 00101001b = 10101001b
-10000000b | 00101010b = 10101010b
-10000000b | 00101011b = 10101011b
-10000000b | 00101100b = 10101100b
-10000000b | 00101101b = 10101101b
-10000000b | 00101110b = 10101110b
-10000000b | 00101111b = 10101111b
-10000000b | 00110000b = 10110000b
-10000000b | 00110001b = 10110001b
-10000000b | 00110010b = 10110010b
-10000000b | 00110011b = 10110011b
-10000000b | 00110100b = 10110100b
-10000000b | 00110101b = 10110101b
-10000000b | 00110110b = 10110110b
-10000000b | 00110111b = 10110111b
-10000000b | 00111000b = 10111000b
-10000000b | 00111001b = 10111001b
-10000000b | 00111010b = 10111010b
-10000000b | 00111011b = 10111011b
-10000000b | 00111100b = 10111100b
-10000000b | 00111101b = 10111101b
-10000000b | 00111110b = 10111110b
-10000000b | 00111111b = 10111111b
-10000000b | 01000000b = 11000000b
-10000000b | 01000001b = 11000001b
-10000000b | 01000010b = 11000010b
-10000000b | 01000011b = 11000011b
-10000000b | 01000100b = 11000100b
-10000000b | 01000101b = 11000101b
-10000000b | 01000110b = 11000110b
-10000000b | 01000111b = 11000111b
-10000000b | 01001000b = 11001000b
-10000000b | 01001001b = 11001001b
-10000000b | 01001010b = 11001010b
-10000000b | 01001011b = 11001011b
-10000000b | 01001100b = 11001100b
-10000000b | 01001101b = 11001101b
-10000000b | 01001110b = 11001110b
-10000000b | 01001111b = 11001111b
-10000000b | 01010000b = 11010000b
-10000000b | 01010001b = 11010001b
-10000000b | 01010010b = 11010010b
-10000000b | 01010011b = 11010011b
-10000000b | 01010100b = 11010100b
-10000000b | 01010101b = 11010101b
-10000000b | 01010110b = 11010110b
-10000000b | 01010111b = 11010111b
-10000000b | 01011000b = 11011000b
-10000000b | 01011001b = 11011001b
-10000000b | 01011010b = 11011010b
-10000000b | 01011011b = 11011011b
-10000000b | 01011100b = 11011100b
-10000000b | 01011101b = 11011101b
-10000000b | 01011110b = 11011110b
-10000000b | 01011111b = 11011111b
-10000000b | 01100000b = 11100000b
-10000000b | 01100001b = 11100001b
-10000000b | 01100010b = 11100010b
-10000000b | 01100011b = 11100011b
-10000000b | 01100100b = 11100100b
-10000000b | 01100101b = 11100101b
-10000000b | 01100110b = 11100110b
-10000000b | 01100111b = 11100111b
-10000000b | 01101000b = 11101000b
-10000000b | 01101001b = 11101001b
-10000000b | 01101010b = 11101010b
-10000000b | 01101011b = 11101011b
-10000000b | 01101100b = 11101100b
-10000000b | 01101101b = 11101101b
-10000000b | 01101110b = 11101110b
-10000000b | 01101111b = 11101111b
-10000000b | 01110000b = 11110000b
-10000000b | 01110001b = 11110001b
-10000000b | 01110010b = 11110010b
-10000000b | 01110011b = 11110011b
-10000000b | 01110100b = 11110100b
-10000000b | 01110101b = 11110101b
-10000000b | 01110110b = 11110110b
-10000000b | 01110111b = 11110111b
-10000000b | 01111000b = 11111000b
-10000000b | 01111001b = 11111001b
-10000000b | 01111010b = 11111010b
-10000000b | 01111011b = 11111011b
-10000000b | 01111100b = 11111100b
-10000000b | 01111101b = 11111101b
-10000000b | 01111110b = 11111110b
-10000001b | 10000000b = 10000001b
-10000001b | 10000001b = 10000001b
-10000001b | 10000010b = 10000011b
-10000001b | 10000011b = 10000011b
-10000001b | 10000100b = 10000101b
-10000001b | 10000101b = 10000101b
-10000001b | 10000110b = 10000111b
-10000001b | 10000111b = 10000111b
-10000001b | 10001000b = 10001001b
-10000001b | 10001001b = 10001001b
-10000001b | 10001010b = 10001011b
-10000001b | 10001011b = 10001011b
-10000001b | 10001100b = 10001101b
-10000001b | 10001101b = 10001101b
-10000001b | 10001110b = 10001111b
-10000001b | 10001111b = 10001111b
-10000001b | 10010000b = 10010001b
-10000001b | 10010001b = 10010001b
-10000001b | 10010010b = 10010011b
-10000001b | 10010011b = 10010011b
-10000001b | 10010100b = 10010101b
-10000001b | 10010101b = 10010101b
-10000001b | 10010110b = 10010111b
-10000001b | 10010111b = 10010111b
-10000001b | 10011000b = 10011001b
-10000001b | 10011001b = 10011001b
-10000001b | 10011010b = 10011011b
-10000001b | 10011011b = 10011011b
-10000001b | 10011100b = 10011101b
-10000001b | 10011101b = 10011101b
-10000001b | 10011110b = 10011111b
-10000001b | 10011111b = 10011111b
-10000001b | 10100000b = 10100001b
-10000001b | 10100001b = 10100001b
-10000001b | 10100010b = 10100011b
-10000001b | 10100011b = 10100011b
-10000001b | 10100100b = 10100101b
-10000001b | 10100101b = 10100101b
-10000001b | 10100110b = 10100111b
-10000001b | 10100111b = 10100111b
-10000001b | 10101000b = 10101001b
-10000001b | 10101001b = 10101001b
-10000001b | 10101010b = 10101011b
-10000001b | 10101011b = 10101011b
-10000001b | 10101100b = 10101101b
-10000001b | 10101101b = 10101101b
-10000001b | 10101110b = 10101111b
-10000001b | 10101111b = 10101111b
-10000001b | 10110000b = 10110001b
-10000001b | 10110001b = 10110001b
-10000001b | 10110010b = 10110011b
-10000001b | 10110011b = 10110011b
-10000001b | 10110100b = 10110101b
-10000001b | 10110101b = 10110101b
-10000001b | 10110110b = 10110111b
-10000001b | 10110111b = 10110111b
-10000001b | 10111000b = 10111001b
-10000001b | 10111001b = 10111001b
-10000001b | 10111010b = 10111011b
-10000001b | 10111011b = 10111011b
-10000001b | 10111100b = 10111101b
-10000001b | 10111101b = 10111101b
-10000001b | 10111110b = 10111111b
-10000001b | 10111111b = 10111111b
-10000001b | 11000000b = 11000001b
-10000001b | 11000001b = 11000001b
-10000001b | 11000010b = 11000011b
-10000001b | 11000011b = 11000011b
-10000001b | 11000100b = 11000101b
-10000001b | 11000101b = 11000101b
-10000001b | 11000110b = 11000111b
-10000001b | 11000111b = 11000111b
-10000001b | 11001000b = 11001001b
-10000001b | 11001001b = 11001001b
-10000001b | 11001010b = 11001011b
-10000001b | 11001011b = 11001011b
-10000001b | 11001100b = 11001101b
-10000001b | 11001101b = 11001101b
-10000001b | 11001110b = 11001111b
-10000001b | 11001111b = 11001111b
-10000001b | 11010000b = 11010001b
-10000001b | 11010001b = 11010001b
-10000001b | 11010010b = 11010011b
-10000001b | 11010011b = 11010011b
-10000001b | 11010100b = 11010101b
-10000001b | 11010101b = 11010101b
-10000001b | 11010110b = 11010111b
-10000001b | 11010111b = 11010111b
-10000001b | 11011000b = 11011001b
-10000001b | 11011001b = 11011001b
-10000001b | 11011010b = 11011011b
-10000001b | 11011011b = 11011011b
-10000001b | 11011100b = 11011101b
-10000001b | 11011101b = 11011101b
-10000001b | 11011110b = 11011111b
-10000001b | 11011111b = 11011111b
-10000001b | 11100000b = 11100001b
-10000001b | 11100001b = 11100001b
-10000001b | 11100010b = 11100011b
-10000001b | 11100011b = 11100011b
-10000001b | 11100100b = 11100101b
-10000001b | 11100101b = 11100101b
-10000001b | 11100110b = 11100111b
-10000001b | 11100111b = 11100111b
-10000001b | 11101000b = 11101001b
-10000001b | 11101001b = 11101001b
-10000001b | 11101010b = 11101011b
-10000001b | 11101011b = 11101011b
-10000001b | 11101100b = 11101101b
-10000001b | 11101101b = 11101101b
-10000001b | 11101110b = 11101111b
-10000001b | 11101111b = 11101111b
-10000001b | 11110000b = 11110001b
-10000001b | 11110001b = 11110001b
-10000001b | 11110010b = 11110011b
-10000001b | 11110011b = 11110011b
-10000001b | 11110100b = 11110101b
-10000001b | 11110101b = 11110101b
-10000001b | 11110110b = 11110111b
-10000001b | 11110111b = 11110111b
-10000001b | 11111000b = 11111001b
-10000001b | 11111001b = 11111001b
-10000001b | 11111010b = 11111011b
-10000001b | 11111011b = 11111011b
-10000001b | 11111100b = 11111101b
-10000001b | 11111101b = 11111101b
-10000001b | 11111110b = 11111111b
-10000001b | 11111111b = 11111111b
-10000001b | 00000000b = 10000001b
-10000001b | 00000001b = 10000001b
-10000001b | 00000010b = 10000011b
-10000001b | 00000011b = 10000011b
-10000001b | 00000100b = 10000101b
-10000001b | 00000101b = 10000101b
-10000001b | 00000110b = 10000111b
-10000001b | 00000111b = 10000111b
-10000001b | 00001000b = 10001001b
-10000001b | 00001001b = 10001001b
-10000001b | 00001010b = 10001011b
-10000001b | 00001011b = 10001011b
-10000001b | 00001100b = 10001101b
-10000001b | 00001101b = 10001101b
-10000001b | 00001110b = 10001111b
-10000001b | 00001111b = 10001111b
-10000001b | 00010000b = 10010001b
-10000001b | 00010001b = 10010001b
-10000001b | 00010010b = 10010011b
-10000001b | 00010011b = 10010011b
-10000001b | 00010100b = 10010101b
-10000001b | 00010101b = 10010101b
-10000001b | 00010110b = 10010111b
-10000001b | 00010111b = 10010111b
-10000001b | 00011000b = 10011001b
-10000001b | 00011001b = 10011001b
-10000001b | 00011010b = 10011011b
-10000001b | 00011011b = 10011011b
-10000001b | 00011100b = 10011101b
-10000001b | 00011101b = 10011101b
-10000001b | 00011110b = 10011111b
-10000001b | 00011111b = 10011111b
-10000001b | 00100000b = 10100001b
-10000001b | 00100001b = 10100001b
-10000001b | 00100010b = 10100011b
-10000001b | 00100011b = 10100011b
-10000001b | 00100100b = 10100101b
-10000001b | 00100101b = 10100101b
-10000001b | 00100110b = 10100111b
-10000001b | 00100111b = 10100111b
-10000001b | 00101000b = 10101001b
-10000001b | 00101001b = 10101001b
-10000001b | 00101010b = 10101011b
-10000001b | 00101011b = 10101011b
-10000001b | 00101100b = 10101101b
-10000001b | 00101101b = 10101101b
-10000001b | 00101110b = 10101111b
-10000001b | 00101111b = 10101111b
-10000001b | 00110000b = 10110001b
-10000001b | 00110001b = 10110001b
-10000001b | 00110010b = 10110011b
-10000001b | 00110011b = 10110011b
-10000001b | 00110100b = 10110101b
-10000001b | 00110101b = 10110101b
-10000001b | 00110110b = 10110111b
-10000001b | 00110111b = 10110111b
-10000001b | 00111000b = 10111001b
-10000001b | 00111001b = 10111001b
-10000001b | 00111010b = 10111011b
-10000001b | 00111011b = 10111011b
-10000001b | 00111100b = 10111101b
-10000001b | 00111101b = 10111101b
-10000001b | 00111110b = 10111111b
-10000001b | 00111111b = 10111111b
-10000001b | 01000000b = 11000001b
-10000001b | 01000001b = 11000001b
-10000001b | 01000010b = 11000011b
-10000001b | 01000011b = 11000011b
-10000001b | 01000100b = 11000101b
-10000001b | 01000101b = 11000101b
-10000001b | 01000110b = 11000111b
-10000001b | 01000111b = 11000111b
-10000001b | 01001000b = 11001001b
-10000001b | 01001001b = 11001001b
-10000001b | 01001010b = 11001011b
-10000001b | 01001011b = 11001011b
-10000001b | 01001100b = 11001101b
-10000001b | 01001101b = 11001101b
-10000001b | 01001110b = 11001111b
-10000001b | 01001111b = 11001111b
-10000001b | 01010000b = 11010001b
-10000001b | 01010001b = 11010001b
-10000001b | 01010010b = 11010011b
-10000001b | 01010011b = 11010011b
-10000001b | 01010100b = 11010101b
-10000001b | 01010101b = 11010101b
-10000001b | 01010110b = 11010111b
-10000001b | 01010111b = 11010111b
-10000001b | 01011000b = 11011001b
-10000001b | 01011001b = 11011001b
-10000001b | 01011010b = 11011011b
-10000001b | 01011011b = 11011011b
-10000001b | 01011100b = 11011101b
-10000001b | 01011101b = 11011101b
-10000001b | 01011110b = 11011111b
-10000001b | 01011111b = 11011111b
-10000001b | 01100000b = 11100001b
-10000001b | 01100001b = 11100001b
-10000001b | 01100010b = 11100011b
-10000001b | 01100011b = 11100011b
-10000001b | 01100100b = 11100101b
-10000001b | 01100101b = 11100101b
-10000001b | 01100110b = 11100111b
-10000001b | 01100111b = 11100111b
-10000001b | 01101000b = 11101001b
-10000001b | 01101001b = 11101001b
-10000001b | 01101010b = 11101011b
-10000001b | 01101011b = 11101011b
-10000001b | 01101100b = 11101101b
-10000001b | 01101101b = 11101101b
-10000001b | 01101110b = 11101111b
-10000001b | 01101111b = 11101111b
-10000001b | 01110000b = 11110001b
-10000001b | 01110001b = 11110001b
-10000001b | 01110010b = 11110011b
-10000001b | 01110011b = 11110011b
-10000001b | 01110100b = 11110101b
-10000001b | 01110101b = 11110101b
-10000001b | 01110110b = 11110111b
-10000001b | 01110111b = 11110111b
-10000001b | 01111000b = 11111001b
-10000001b | 01111001b = 11111001b
-10000001b | 01111010b = 11111011b
-10000001b | 01111011b = 11111011b
-10000001b | 01111100b = 11111101b
-10000001b | 01111101b = 11111101b
-10000001b | 01111110b = 11111111b
-10000010b | 10000000b = 10000010b
-10000010b | 10000001b = 10000011b
-10000010b | 10000010b = 10000010b
-10000010b | 10000011b = 10000011b
-10000010b | 10000100b = 10000110b
-10000010b | 10000101b = 10000111b
-10000010b | 10000110b = 10000110b
-10000010b | 10000111b = 10000111b
-10000010b | 10001000b = 10001010b
-10000010b | 10001001b = 10001011b
-10000010b | 10001010b = 10001010b
-10000010b | 10001011b = 10001011b
-10000010b | 10001100b = 10001110b
-10000010b | 10001101b = 10001111b
-10000010b | 10001110b = 10001110b
-10000010b | 10001111b = 10001111b
-10000010b | 10010000b = 10010010b
-10000010b | 10010001b = 10010011b
-10000010b | 10010010b = 10010010b
-10000010b | 10010011b = 10010011b
-10000010b | 10010100b = 10010110b
-10000010b | 10010101b = 10010111b
-10000010b | 10010110b = 10010110b
-10000010b | 10010111b = 10010111b
-10000010b | 10011000b = 10011010b
-10000010b | 10011001b = 10011011b
-10000010b | 10011010b = 10011010b
-10000010b | 10011011b = 10011011b
-10000010b | 10011100b = 10011110b
-10000010b | 10011101b = 10011111b
-10000010b | 10011110b = 10011110b
-10000010b | 10011111b = 10011111b
-10000010b | 10100000b = 10100010b
-10000010b | 10100001b = 10100011b
-10000010b | 10100010b = 10100010b
-10000010b | 10100011b = 10100011b
-10000010b | 10100100b = 10100110b
-10000010b | 10100101b = 10100111b
-10000010b | 10100110b = 10100110b
-10000010b | 10100111b = 10100111b
-10000010b | 10101000b = 10101010b
-10000010b | 10101001b = 10101011b
-10000010b | 10101010b = 10101010b
-10000010b | 10101011b = 10101011b
-10000010b | 10101100b = 10101110b
-10000010b | 10101101b = 10101111b
-10000010b | 10101110b = 10101110b
-10000010b | 10101111b = 10101111b
-10000010b | 10110000b = 10110010b
-10000010b | 10110001b = 10110011b
-10000010b | 10110010b = 10110010b
-10000010b | 10110011b = 10110011b
-10000010b | 10110100b = 10110110b
-10000010b | 10110101b = 10110111b
-10000010b | 10110110b = 10110110b
-10000010b | 10110111b = 10110111b
-10000010b | 10111000b = 10111010b
-10000010b | 10111001b = 10111011b
-10000010b | 10111010b = 10111010b
-10000010b | 10111011b = 10111011b
-10000010b | 10111100b = 10111110b
-10000010b | 10111101b = 10111111b
-10000010b | 10111110b = 10111110b
-10000010b | 10111111b = 10111111b
-10000010b | 11000000b = 11000010b
-10000010b | 11000001b = 11000011b
-10000010b | 11000010b = 11000010b
-10000010b | 11000011b = 11000011b
-10000010b | 11000100b = 11000110b
-10000010b | 11000101b = 11000111b
-10000010b | 11000110b = 11000110b
-10000010b | 11000111b = 11000111b
-10000010b | 11001000b = 11001010b
-10000010b | 11001001b = 11001011b
-10000010b | 11001010b = 11001010b
-10000010b | 11001011b = 11001011b
-10000010b | 11001100b = 11001110b
-10000010b | 11001101b = 11001111b
-10000010b | 11001110b = 11001110b
-10000010b | 11001111b = 11001111b
-10000010b | 11010000b = 11010010b
-10000010b | 11010001b = 11010011b
-10000010b | 11010010b = 11010010b
-10000010b | 11010011b = 11010011b
-10000010b | 11010100b = 11010110b
-10000010b | 11010101b = 11010111b
-10000010b | 11010110b = 11010110b
-10000010b | 11010111b = 11010111b
-10000010b | 11011000b = 11011010b
-10000010b | 11011001b = 11011011b
-10000010b | 11011010b = 11011010b
-10000010b | 11011011b = 11011011b
-10000010b | 11011100b = 11011110b
-10000010b | 11011101b = 11011111b
-10000010b | 11011110b = 11011110b
-10000010b | 11011111b = 11011111b
-10000010b | 11100000b = 11100010b
-10000010b | 11100001b = 11100011b
-10000010b | 11100010b = 11100010b
-10000010b | 11100011b = 11100011b
-10000010b | 11100100b = 11100110b
-10000010b | 11100101b = 11100111b
-10000010b | 11100110b = 11100110b
-10000010b | 11100111b = 11100111b
-10000010b | 11101000b = 11101010b
-10000010b | 11101001b = 11101011b
-10000010b | 11101010b = 11101010b
-10000010b | 11101011b = 11101011b
-10000010b | 11101100b = 11101110b
-10000010b | 11101101b = 11101111b
-10000010b | 11101110b = 11101110b
-10000010b | 11101111b = 11101111b
-10000010b | 11110000b = 11110010b
-10000010b | 11110001b = 11110011b
-10000010b | 11110010b = 11110010b
-10000010b | 11110011b = 11110011b
-10000010b | 11110100b = 11110110b
-10000010b | 11110101b = 11110111b
-10000010b | 11110110b = 11110110b
-10000010b | 11110111b = 11110111b
-10000010b | 11111000b = 11111010b
-10000010b | 11111001b = 11111011b
-10000010b | 11111010b = 11111010b
-10000010b | 11111011b = 11111011b
-10000010b | 11111100b = 11111110b
-10000010b | 11111101b = 11111111b
-10000010b | 11111110b = 11111110b
-10000010b | 11111111b = 11111111b
-10000010b | 00000000b = 10000010b
-10000010b | 00000001b = 10000011b
-10000010b | 00000010b = 10000010b
-10000010b | 00000011b = 10000011b
-10000010b | 00000100b = 10000110b
-10000010b | 00000101b = 10000111b
-10000010b | 00000110b = 10000110b
-10000010b | 00000111b = 10000111b
-10000010b | 00001000b = 10001010b
-10000010b | 00001001b = 10001011b
-10000010b | 00001010b = 10001010b
-10000010b | 00001011b = 10001011b
-10000010b | 00001100b = 10001110b
-10000010b | 00001101b = 10001111b
-10000010b | 00001110b = 10001110b
-10000010b | 00001111b = 10001111b
-10000010b | 00010000b = 10010010b
-10000010b | 00010001b = 10010011b
-10000010b | 00010010b = 10010010b
-10000010b | 00010011b = 10010011b
-10000010b | 00010100b = 10010110b
-10000010b | 00010101b = 10010111b
-10000010b | 00010110b = 10010110b
-10000010b | 00010111b = 10010111b
-10000010b | 00011000b = 10011010b
-10000010b | 00011001b = 10011011b
-10000010b | 00011010b = 10011010b
-10000010b | 00011011b = 10011011b
-10000010b | 00011100b = 10011110b
-10000010b | 00011101b = 10011111b
-10000010b | 00011110b = 10011110b
-10000010b | 00011111b = 10011111b
-10000010b | 00100000b = 10100010b
-10000010b | 00100001b = 10100011b
-10000010b | 00100010b = 10100010b
-10000010b | 00100011b = 10100011b
-10000010b | 00100100b = 10100110b
-10000010b | 00100101b = 10100111b
-10000010b | 00100110b = 10100110b
-10000010b | 00100111b = 10100111b
-10000010b | 00101000b = 10101010b
-10000010b | 00101001b = 10101011b
-10000010b | 00101010b = 10101010b
-10000010b | 00101011b = 10101011b
-10000010b | 00101100b = 10101110b
-10000010b | 00101101b = 10101111b
-10000010b | 00101110b = 10101110b
-10000010b | 00101111b = 10101111b
-10000010b | 00110000b = 10110010b
-10000010b | 00110001b = 10110011b
-10000010b | 00110010b = 10110010b
-10000010b | 00110011b = 10110011b
-10000010b | 00110100b = 10110110b
-10000010b | 00110101b = 10110111b
-10000010b | 00110110b = 10110110b
-10000010b | 00110111b = 10110111b
-10000010b | 00111000b = 10111010b
-10000010b | 00111001b = 10111011b
-10000010b | 00111010b = 10111010b
-10000010b | 00111011b = 10111011b
-10000010b | 00111100b = 10111110b
-10000010b | 00111101b = 10111111b
-10000010b | 00111110b = 10111110b
-10000010b | 00111111b = 10111111b
-10000010b | 01000000b = 11000010b
-10000010b | 01000001b = 11000011b
-10000010b | 01000010b = 11000010b
-10000010b | 01000011b = 11000011b
-10000010b | 01000100b = 11000110b
-10000010b | 01000101b = 11000111b
-10000010b | 01000110b = 11000110b
-10000010b | 01000111b = 11000111b
-10000010b | 01001000b = 11001010b
-10000010b | 01001001b = 11001011b
-10000010b | 01001010b = 11001010b
-10000010b | 01001011b = 11001011b
-10000010b | 01001100b = 11001110b
-10000010b | 01001101b = 11001111b
-10000010b | 01001110b = 11001110b
-10000010b | 01001111b = 11001111b
-10000010b | 01010000b = 11010010b
-10000010b | 01010001b = 11010011b
-10000010b | 01010010b = 11010010b
-10000010b | 01010011b = 11010011b
-10000010b | 01010100b = 11010110b
-10000010b | 01010101b = 11010111b
-10000010b | 01010110b = 11010110b
-10000010b | 01010111b = 11010111b
-10000010b | 01011000b = 11011010b
-10000010b | 01011001b = 11011011b
-10000010b | 01011010b = 11011010b
-10000010b | 01011011b = 11011011b
-10000010b | 01011100b = 11011110b
-10000010b | 01011101b = 11011111b
-10000010b | 01011110b = 11011110b
-10000010b | 01011111b = 11011111b
-10000010b | 01100000b = 11100010b
-10000010b | 01100001b = 11100011b
-10000010b | 01100010b = 11100010b
-10000010b | 01100011b = 11100011b
-10000010b | 01100100b = 11100110b
-10000010b | 01100101b = 11100111b
-10000010b | 01100110b = 11100110b
-10000010b | 01100111b = 11100111b
-10000010b | 01101000b = 11101010b
-10000010b | 01101001b = 11101011b
-10000010b | 01101010b = 11101010b
-10000010b | 01101011b = 11101011b
-10000010b | 01101100b = 11101110b
-10000010b | 01101101b = 11101111b
-10000010b | 01101110b = 11101110b
-10000010b | 01101111b = 11101111b
-10000010b | 01110000b = 11110010b
-10000010b | 01110001b = 11110011b
-10000010b | 01110010b = 11110010b
-10000010b | 01110011b = 11110011b
-10000010b | 01110100b = 11110110b
-10000010b | 01110101b = 11110111b
-10000010b | 01110110b = 11110110b
-10000010b | 01110111b = 11110111b
-10000010b | 01111000b = 11111010b
-10000010b | 01111001b = 11111011b
-10000010b | 01111010b = 11111010b
-10000010b | 01111011b = 11111011b
-10000010b | 01111100b = 11111110b
-10000010b | 01111101b = 11111111b
-10000010b | 01111110b = 11111110b
-10000011b | 10000000b = 10000011b
-10000011b | 10000001b = 10000011b
-10000011b | 10000010b = 10000011b
-10000011b | 10000011b = 10000011b
-10000011b | 10000100b = 10000111b
-10000011b | 10000101b = 10000111b
-10000011b | 10000110b = 10000111b
-10000011b | 10000111b = 10000111b
-10000011b | 10001000b = 10001011b
-10000011b | 10001001b = 10001011b
-10000011b | 10001010b = 10001011b
-10000011b | 10001011b = 10001011b
-10000011b | 10001100b = 10001111b
-10000011b | 10001101b = 10001111b
-10000011b | 10001110b = 10001111b
-10000011b | 10001111b = 10001111b
-10000011b | 10010000b = 10010011b
-10000011b | 10010001b = 10010011b
-10000011b | 10010010b = 10010011b
-10000011b | 10010011b = 10010011b
-10000011b | 10010100b = 10010111b
-10000011b | 10010101b = 10010111b
-10000011b | 10010110b = 10010111b
-10000011b | 10010111b = 10010111b
-10000011b | 10011000b = 10011011b
-10000011b | 10011001b = 10011011b
-10000011b | 10011010b = 10011011b
-10000011b | 10011011b = 10011011b
-10000011b | 10011100b = 10011111b
-10000011b | 10011101b = 10011111b
-10000011b | 10011110b = 10011111b
-10000011b | 10011111b = 10011111b
-10000011b | 10100000b = 10100011b
-10000011b | 10100001b = 10100011b
-10000011b | 10100010b = 10100011b
-10000011b | 10100011b = 10100011b
-10000011b | 10100100b = 10100111b
-10000011b | 10100101b = 10100111b
-10000011b | 10100110b = 10100111b
-10000011b | 10100111b = 10100111b
-10000011b | 10101000b = 10101011b
-10000011b | 10101001b = 10101011b
-10000011b | 10101010b = 10101011b
-10000011b | 10101011b = 10101011b
-10000011b | 10101100b = 10101111b
-10000011b | 10101101b = 10101111b
-10000011b | 10101110b = 10101111b
-10000011b | 10101111b = 10101111b
-10000011b | 10110000b = 10110011b
-10000011b | 10110001b = 10110011b
-10000011b | 10110010b = 10110011b
-10000011b | 10110011b = 10110011b
-10000011b | 10110100b = 10110111b
-10000011b | 10110101b = 10110111b
-10000011b | 10110110b = 10110111b
-10000011b | 10110111b = 10110111b
-10000011b | 10111000b = 10111011b
-10000011b | 10111001b = 10111011b
-10000011b | 10111010b = 10111011b
-10000011b | 10111011b = 10111011b
-10000011b | 10111100b = 10111111b
-10000011b | 10111101b = 10111111b
-10000011b | 10111110b = 10111111b
-10000011b | 10111111b = 10111111b
-10000011b | 11000000b = 11000011b
-10000011b | 11000001b = 11000011b
-10000011b | 11000010b = 11000011b
-10000011b | 11000011b = 11000011b
-10000011b | 11000100b = 11000111b
-10000011b | 11000101b = 11000111b
-10000011b | 11000110b = 11000111b
-10000011b | 11000111b = 11000111b
-10000011b | 11001000b = 11001011b
-10000011b | 11001001b = 11001011b
-10000011b | 11001010b = 11001011b
-10000011b | 11001011b = 11001011b
-10000011b | 11001100b = 11001111b
-10000011b | 11001101b = 11001111b
-10000011b | 11001110b = 11001111b
-10000011b | 11001111b = 11001111b
-10000011b | 11010000b = 11010011b
-10000011b | 11010001b = 11010011b
-10000011b | 11010010b = 11010011b
-10000011b | 11010011b = 11010011b
-10000011b | 11010100b = 11010111b
-10000011b | 11010101b = 11010111b
-10000011b | 11010110b = 11010111b
-10000011b | 11010111b = 11010111b
-10000011b | 11011000b = 11011011b
-10000011b | 11011001b = 11011011b
-10000011b | 11011010b = 11011011b
-10000011b | 11011011b = 11011011b
-10000011b | 11011100b = 11011111b
-10000011b | 11011101b = 11011111b
-10000011b | 11011110b = 11011111b
-10000011b | 11011111b = 11011111b
-10000011b | 11100000b = 11100011b
-10000011b | 11100001b = 11100011b
-10000011b | 11100010b = 11100011b
-10000011b | 11100011b = 11100011b
-10000011b | 11100100b = 11100111b
-10000011b | 11100101b = 11100111b
-10000011b | 11100110b = 11100111b
-10000011b | 11100111b = 11100111b
-10000011b | 11101000b = 11101011b
-10000011b | 11101001b = 11101011b
-10000011b | 11101010b = 11101011b
-10000011b | 11101011b = 11101011b
-10000011b | 11101100b = 11101111b
-10000011b | 11101101b = 11101111b
-10000011b | 11101110b = 11101111b
-10000011b | 11101111b = 11101111b
-10000011b | 11110000b = 11110011b
-10000011b | 11110001b = 11110011b
-10000011b | 11110010b = 11110011b
-10000011b | 11110011b = 11110011b
-10000011b | 11110100b = 11110111b
-10000011b | 11110101b = 11110111b
-10000011b | 11110110b = 11110111b
-10000011b | 11110111b = 11110111b
-10000011b | 11111000b = 11111011b
-10000011b | 11111001b = 11111011b
-10000011b | 11111010b = 11111011b
-10000011b | 11111011b = 11111011b
-10000011b | 11111100b = 11111111b
-10000011b | 11111101b = 11111111b
-10000011b | 11111110b = 11111111b
-10000011b | 11111111b = 11111111b
-10000011b | 00000000b = 10000011b
-10000011b | 00000001b = 10000011b
-10000011b | 00000010b = 10000011b
-10000011b | 00000011b = 10000011b
-10000011b | 00000100b = 10000111b
-10000011b | 00000101b = 10000111b
-10000011b | 00000110b = 10000111b
-10000011b | 00000111b = 10000111b
-10000011b | 00001000b = 10001011b
-10000011b | 00001001b = 10001011b
-10000011b | 00001010b = 10001011b
-10000011b | 00001011b = 10001011b
-10000011b | 00001100b = 10001111b
-10000011b | 00001101b = 10001111b
-10000011b | 00001110b = 10001111b
-10000011b | 00001111b = 10001111b
-10000011b | 00010000b = 10010011b
-10000011b | 00010001b = 10010011b
-10000011b | 00010010b = 10010011b
-10000011b | 00010011b = 10010011b
-10000011b | 00010100b = 10010111b
-10000011b | 00010101b = 10010111b
-10000011b | 00010110b = 10010111b
-10000011b | 00010111b = 10010111b
-10000011b | 00011000b = 10011011b
-10000011b | 00011001b = 10011011b
-10000011b | 00011010b = 10011011b
-10000011b | 00011011b = 10011011b
-10000011b | 00011100b = 10011111b
-10000011b | 00011101b = 10011111b
-10000011b | 00011110b = 10011111b
-10000011b | 00011111b = 10011111b
-10000011b | 00100000b = 10100011b
-10000011b | 00100001b = 10100011b
-10000011b | 00100010b = 10100011b
-10000011b | 00100011b = 10100011b
-10000011b | 00100100b = 10100111b
-10000011b | 00100101b = 10100111b
-10000011b | 00100110b = 10100111b
-10000011b | 00100111b = 10100111b
-10000011b | 00101000b = 10101011b
-10000011b | 00101001b = 10101011b
-10000011b | 00101010b = 10101011b
-10000011b | 00101011b = 10101011b
-10000011b | 00101100b = 10101111b
-10000011b | 00101101b = 10101111b
-10000011b | 00101110b = 10101111b
-10000011b | 00101111b = 10101111b
-10000011b | 00110000b = 10110011b
-10000011b | 00110001b = 10110011b
-10000011b | 00110010b = 10110011b
-10000011b | 00110011b = 10110011b
-10000011b | 00110100b = 10110111b
-10000011b | 00110101b = 10110111b
-10000011b | 00110110b = 10110111b
-10000011b | 00110111b = 10110111b
-10000011b | 00111000b = 10111011b
-10000011b | 00111001b = 10111011b
-10000011b | 00111010b = 10111011b
-10000011b | 00111011b = 10111011b
-10000011b | 00111100b = 10111111b
-10000011b | 00111101b = 10111111b
-10000011b | 00111110b = 10111111b
-10000011b | 00111111b = 10111111b
-10000011b | 01000000b = 11000011b
-10000011b | 01000001b = 11000011b
-10000011b | 01000010b = 11000011b
-10000011b | 01000011b = 11000011b
-10000011b | 01000100b = 11000111b
-10000011b | 01000101b = 11000111b
-10000011b | 01000110b = 11000111b
-10000011b | 01000111b = 11000111b
-10000011b | 01001000b = 11001011b
-10000011b | 01001001b = 11001011b
-10000011b | 01001010b = 11001011b
-10000011b | 01001011b = 11001011b
-10000011b | 01001100b = 11001111b
-10000011b | 01001101b = 11001111b
-10000011b | 01001110b = 11001111b
-10000011b | 01001111b = 11001111b
-10000011b | 01010000b = 11010011b
-10000011b | 01010001b = 11010011b
-10000011b | 01010010b = 11010011b
-10000011b | 01010011b = 11010011b
-10000011b | 01010100b = 11010111b
-10000011b | 01010101b = 11010111b
-10000011b | 01010110b = 11010111b
-10000011b | 01010111b = 11010111b
-10000011b | 01011000b = 11011011b
-10000011b | 01011001b = 11011011b
-10000011b | 01011010b = 11011011b
-10000011b | 01011011b = 11011011b
-10000011b | 01011100b = 11011111b
-10000011b | 01011101b = 11011111b
-10000011b | 01011110b = 11011111b
-10000011b | 01011111b = 11011111b
-10000011b | 01100000b = 11100011b
-10000011b | 01100001b = 11100011b
-10000011b | 01100010b = 11100011b
-10000011b | 01100011b = 11100011b
-10000011b | 01100100b = 11100111b
-10000011b | 01100101b = 11100111b
-10000011b | 01100110b = 11100111b
-10000011b | 01100111b = 11100111b
-10000011b | 01101000b = 11101011b
-10000011b | 01101001b = 11101011b
-10000011b | 01101010b = 11101011b
-10000011b | 01101011b = 11101011b
-10000011b | 01101100b = 11101111b
-10000011b | 01101101b = 11101111b
-10000011b | 01101110b = 11101111b
-10000011b | 01101111b = 11101111b
-10000011b | 01110000b = 11110011b
-10000011b | 01110001b = 11110011b
-10000011b | 01110010b = 11110011b
-10000011b | 01110011b = 11110011b
-10000011b | 01110100b = 11110111b
-10000011b | 01110101b = 11110111b
-10000011b | 01110110b = 11110111b
-10000011b | 01110111b = 11110111b
-10000011b | 01111000b = 11111011b
-10000011b | 01111001b = 11111011b
-10000011b | 01111010b = 11111011b
-10000011b | 01111011b = 11111011b
-10000011b | 01111100b = 11111111b
-10000011b | 01111101b = 11111111b
-10000011b | 01111110b = 11111111b
-10000100b | 10000000b = 10000100b
-10000100b | 10000001b = 10000101b
-10000100b | 10000010b = 10000110b
-10000100b | 10000011b = 10000111b
-10000100b | 10000100b = 10000100b
-10000100b | 10000101b = 10000101b
-10000100b | 10000110b = 10000110b
-10000100b | 10000111b = 10000111b
-10000100b | 10001000b = 10001100b
-10000100b | 10001001b = 10001101b
-10000100b | 10001010b = 10001110b
-10000100b | 10001011b = 10001111b
-10000100b | 10001100b = 10001100b
-10000100b | 10001101b = 10001101b
-10000100b | 10001110b = 10001110b
-10000100b | 10001111b = 10001111b
-10000100b | 10010000b = 10010100b
-10000100b | 10010001b = 10010101b
-10000100b | 10010010b = 10010110b
-10000100b | 10010011b = 10010111b
-10000100b | 10010100b = 10010100b
-10000100b | 10010101b = 10010101b
-10000100b | 10010110b = 10010110b
-10000100b | 10010111b = 10010111b
-10000100b | 10011000b = 10011100b
-10000100b | 10011001b = 10011101b
-10000100b | 10011010b = 10011110b
-10000100b | 10011011b = 10011111b
-10000100b | 10011100b = 10011100b
-10000100b | 10011101b = 10011101b
-10000100b | 10011110b = 10011110b
-10000100b | 10011111b = 10011111b
-10000100b | 10100000b = 10100100b
-10000100b | 10100001b = 10100101b
-10000100b | 10100010b = 10100110b
-10000100b | 10100011b = 10100111b
-10000100b | 10100100b = 10100100b
-10000100b | 10100101b = 10100101b
-10000100b | 10100110b = 10100110b
-10000100b | 10100111b = 10100111b
-10000100b | 10101000b = 10101100b
-10000100b | 10101001b = 10101101b
-10000100b | 10101010b = 10101110b
-10000100b | 10101011b = 10101111b
-10000100b | 10101100b = 10101100b
-10000100b | 10101101b = 10101101b
-10000100b | 10101110b = 10101110b
-10000100b | 10101111b = 10101111b
-10000100b | 10110000b = 10110100b
-10000100b | 10110001b = 10110101b
-10000100b | 10110010b = 10110110b
-10000100b | 10110011b = 10110111b
-10000100b | 10110100b = 10110100b
-10000100b | 10110101b = 10110101b
-10000100b | 10110110b = 10110110b
-10000100b | 10110111b = 10110111b
-10000100b | 10111000b = 10111100b
-10000100b | 10111001b = 10111101b
-10000100b | 10111010b = 10111110b
-10000100b | 10111011b = 10111111b
-10000100b | 10111100b = 10111100b
-10000100b | 10111101b = 10111101b
-10000100b | 10111110b = 10111110b
-10000100b | 10111111b = 10111111b
-10000100b | 11000000b = 11000100b
-10000100b | 11000001b = 11000101b
-10000100b | 11000010b = 11000110b
-10000100b | 11000011b = 11000111b
-10000100b | 11000100b = 11000100b
-10000100b | 11000101b = 11000101b
-10000100b | 11000110b = 11000110b
-10000100b | 11000111b = 11000111b
-10000100b | 11001000b = 11001100b
-10000100b | 11001001b = 11001101b
-10000100b | 11001010b = 11001110b
-10000100b | 11001011b = 11001111b
-10000100b | 11001100b = 11001100b
-10000100b | 11001101b = 11001101b
-10000100b | 11001110b = 11001110b
-10000100b | 11001111b = 11001111b
-10000100b | 11010000b = 11010100b
-10000100b | 11010001b = 11010101b
-10000100b | 11010010b = 11010110b
-10000100b | 11010011b = 11010111b
-10000100b | 11010100b = 11010100b
-10000100b | 11010101b = 11010101b
-10000100b | 11010110b = 11010110b
-10000100b | 11010111b = 11010111b
-10000100b | 11011000b = 11011100b
-10000100b | 11011001b = 11011101b
-10000100b | 11011010b = 11011110b
-10000100b | 11011011b = 11011111b
-10000100b | 11011100b = 11011100b
-10000100b | 11011101b = 11011101b
-10000100b | 11011110b = 11011110b
-10000100b | 11011111b = 11011111b
-10000100b | 11100000b = 11100100b
-10000100b | 11100001b = 11100101b
-10000100b | 11100010b = 11100110b
-10000100b | 11100011b = 11100111b
-10000100b | 11100100b = 11100100b
-10000100b | 11100101b = 11100101b
-10000100b | 11100110b = 11100110b
-10000100b | 11100111b = 11100111b
-10000100b | 11101000b = 11101100b
-10000100b | 11101001b = 11101101b
-10000100b | 11101010b = 11101110b
-10000100b | 11101011b = 11101111b
-10000100b | 11101100b = 11101100b
-10000100b | 11101101b = 11101101b
-10000100b | 11101110b = 11101110b
-10000100b | 11101111b = 11101111b
-10000100b | 11110000b = 11110100b
-10000100b | 11110001b = 11110101b
-10000100b | 11110010b = 11110110b
-10000100b | 11110011b = 11110111b
-10000100b | 11110100b = 11110100b
-10000100b | 11110101b = 11110101b
-10000100b | 11110110b = 11110110b
-10000100b | 11110111b = 11110111b
-10000100b | 11111000b = 11111100b
-10000100b | 11111001b = 11111101b
-10000100b | 11111010b = 11111110b
-10000100b | 11111011b = 11111111b
-10000100b | 11111100b = 11111100b
-10000100b | 11111101b = 11111101b
-10000100b | 11111110b = 11111110b
-10000100b | 11111111b = 11111111b
-10000100b | 00000000b = 10000100b
-10000100b | 00000001b = 10000101b
-10000100b | 00000010b = 10000110b
-10000100b | 00000011b = 10000111b
-10000100b | 00000100b = 10000100b
-10000100b | 00000101b = 10000101b
-10000100b | 00000110b = 10000110b
-10000100b | 00000111b = 10000111b
-10000100b | 00001000b = 10001100b
-10000100b | 00001001b = 10001101b
-10000100b | 00001010b = 10001110b
-10000100b | 00001011b = 10001111b
-10000100b | 00001100b = 10001100b
-10000100b | 00001101b = 10001101b
-10000100b | 00001110b = 10001110b
-10000100b | 00001111b = 10001111b
-10000100b | 00010000b = 10010100b
-10000100b | 00010001b = 10010101b
-10000100b | 00010010b = 10010110b
-10000100b | 00010011b = 10010111b
-10000100b | 00010100b = 10010100b
-10000100b | 00010101b = 10010101b
-10000100b | 00010110b = 10010110b
-10000100b | 00010111b = 10010111b
-10000100b | 00011000b = 10011100b
-10000100b | 00011001b = 10011101b
-10000100b | 00011010b = 10011110b
-10000100b | 00011011b = 10011111b
-10000100b | 00011100b = 10011100b
-10000100b | 00011101b = 10011101b
-10000100b | 00011110b = 10011110b
-10000100b | 00011111b = 10011111b
-10000100b | 00100000b = 10100100b
-10000100b | 00100001b = 10100101b
-10000100b | 00100010b = 10100110b
-10000100b | 00100011b = 10100111b
-10000100b | 00100100b = 10100100b
-10000100b | 00100101b = 10100101b
-10000100b | 00100110b = 10100110b
-10000100b | 00100111b = 10100111b
-10000100b | 00101000b = 10101100b
-10000100b | 00101001b = 10101101b
-10000100b | 00101010b = 10101110b
-10000100b | 00101011b = 10101111b
-10000100b | 00101100b = 10101100b
-10000100b | 00101101b = 10101101b
-10000100b | 00101110b = 10101110b
-10000100b | 00101111b = 10101111b
-10000100b | 00110000b = 10110100b
-10000100b | 00110001b = 10110101b
-10000100b | 00110010b = 10110110b
-10000100b | 00110011b = 10110111b
-10000100b | 00110100b = 10110100b
-10000100b | 00110101b = 10110101b
-10000100b | 00110110b = 10110110b
-10000100b | 00110111b = 10110111b
-10000100b | 00111000b = 10111100b
-10000100b | 00111001b = 10111101b
-10000100b | 00111010b = 10111110b
-10000100b | 00111011b = 10111111b
-10000100b | 00111100b = 10111100b
-10000100b | 00111101b = 10111101b
-10000100b | 00111110b = 10111110b
-10000100b | 00111111b = 10111111b
-10000100b | 01000000b = 11000100b
-10000100b | 01000001b = 11000101b
-10000100b | 01000010b = 11000110b
-10000100b | 01000011b = 11000111b
-10000100b | 01000100b = 11000100b
-10000100b | 01000101b = 11000101b
-10000100b | 01000110b = 11000110b
-10000100b | 01000111b = 11000111b
-10000100b | 01001000b = 11001100b
-10000100b | 01001001b = 11001101b
-10000100b | 01001010b = 11001110b
-10000100b | 01001011b = 11001111b
-10000100b | 01001100b = 11001100b
-10000100b | 01001101b = 11001101b
-10000100b | 01001110b = 11001110b
-10000100b | 01001111b = 11001111b
-10000100b | 01010000b = 11010100b
-10000100b | 01010001b = 11010101b
-10000100b | 01010010b = 11010110b
-10000100b | 01010011b = 11010111b
-10000100b | 01010100b = 11010100b
-10000100b | 01010101b = 11010101b
-10000100b | 01010110b = 11010110b
-10000100b | 01010111b = 11010111b
-10000100b | 01011000b = 11011100b
-10000100b | 01011001b = 11011101b
-10000100b | 01011010b = 11011110b
-10000100b | 01011011b = 11011111b
-10000100b | 01011100b = 11011100b
-10000100b | 01011101b = 11011101b
-10000100b | 01011110b = 11011110b
-10000100b | 01011111b = 11011111b
-10000100b | 01100000b = 11100100b
-10000100b | 01100001b = 11100101b
-10000100b | 01100010b = 11100110b
-10000100b | 01100011b = 11100111b
-10000100b | 01100100b = 11100100b
-10000100b | 01100101b = 11100101b
-10000100b | 01100110b = 11100110b
-10000100b | 01100111b = 11100111b
-10000100b | 01101000b = 11101100b
-10000100b | 01101001b = 11101101b
-10000100b | 01101010b = 11101110b
-10000100b | 01101011b = 11101111b
-10000100b | 01101100b = 11101100b
-10000100b | 01101101b = 11101101b
-10000100b | 01101110b = 11101110b
-10000100b | 01101111b = 11101111b
-10000100b | 01110000b = 11110100b
-10000100b | 01110001b = 11110101b
-10000100b | 01110010b = 11110110b
-10000100b | 01110011b = 11110111b
-10000100b | 01110100b = 11110100b
-10000100b | 01110101b = 11110101b
-10000100b | 01110110b = 11110110b
-10000100b | 01110111b = 11110111b
-10000100b | 01111000b = 11111100b
-10000100b | 01111001b = 11111101b
-10000100b | 01111010b = 11111110b
-10000100b | 01111011b = 11111111b
-10000100b | 01111100b = 11111100b
-10000100b | 01111101b = 11111101b
-10000100b | 01111110b = 11111110b
-10000101b | 10000000b = 10000101b
-10000101b | 10000001b = 10000101b
-10000101b | 10000010b = 10000111b
-10000101b | 10000011b = 10000111b
-10000101b | 10000100b = 10000101b
-10000101b | 10000101b = 10000101b
-10000101b | 10000110b = 10000111b
-10000101b | 10000111b = 10000111b
-10000101b | 10001000b = 10001101b
-10000101b | 10001001b = 10001101b
-10000101b | 10001010b = 10001111b
-10000101b | 10001011b = 10001111b
-10000101b | 10001100b = 10001101b
-10000101b | 10001101b = 10001101b
-10000101b | 10001110b = 10001111b
-10000101b | 10001111b = 10001111b
-10000101b | 10010000b = 10010101b
-10000101b | 10010001b = 10010101b
-10000101b | 10010010b = 10010111b
-10000101b | 10010011b = 10010111b
-10000101b | 10010100b = 10010101b
-10000101b | 10010101b = 10010101b
-10000101b | 10010110b = 10010111b
-10000101b | 10010111b = 10010111b
-10000101b | 10011000b = 10011101b
-10000101b | 10011001b = 10011101b
-10000101b | 10011010b = 10011111b
-10000101b | 10011011b = 10011111b
-10000101b | 10011100b = 10011101b
-10000101b | 10011101b = 10011101b
-10000101b | 10011110b = 10011111b
-10000101b | 10011111b = 10011111b
-10000101b | 10100000b = 10100101b
-10000101b | 10100001b = 10100101b
-10000101b | 10100010b = 10100111b
-10000101b | 10100011b = 10100111b
-10000101b | 10100100b = 10100101b
-10000101b | 10100101b = 10100101b
-10000101b | 10100110b = 10100111b
-10000101b | 10100111b = 10100111b
-10000101b | 10101000b = 10101101b
-10000101b | 10101001b = 10101101b
-10000101b | 10101010b = 10101111b
-10000101b | 10101011b = 10101111b
-10000101b | 10101100b = 10101101b
-10000101b | 10101101b = 10101101b
-10000101b | 10101110b = 10101111b
-10000101b | 10101111b = 10101111b
-10000101b | 10110000b = 10110101b
-10000101b | 10110001b = 10110101b
-10000101b | 10110010b = 10110111b
-10000101b | 10110011b = 10110111b
-10000101b | 10110100b = 10110101b
-10000101b | 10110101b = 10110101b
-10000101b | 10110110b = 10110111b
-10000101b | 10110111b = 10110111b
-10000101b | 10111000b = 10111101b
-10000101b | 10111001b = 10111101b
-10000101b | 10111010b = 10111111b
-10000101b | 10111011b = 10111111b
-10000101b | 10111100b = 10111101b
-10000101b | 10111101b = 10111101b
-10000101b | 10111110b = 10111111b
-10000101b | 10111111b = 10111111b
-10000101b | 11000000b = 11000101b
-10000101b | 11000001b = 11000101b
-10000101b | 11000010b = 11000111b
-10000101b | 11000011b = 11000111b
-10000101b | 11000100b = 11000101b
-10000101b | 11000101b = 11000101b
-10000101b | 11000110b = 11000111b
-10000101b | 11000111b = 11000111b
-10000101b | 11001000b = 11001101b
-10000101b | 11001001b = 11001101b
-10000101b | 11001010b = 11001111b
-10000101b | 11001011b = 11001111b
-10000101b | 11001100b = 11001101b
-10000101b | 11001101b = 11001101b
-10000101b | 11001110b = 11001111b
-10000101b | 11001111b = 11001111b
-10000101b | 11010000b = 11010101b
-10000101b | 11010001b = 11010101b
-10000101b | 11010010b = 11010111b
-10000101b | 11010011b = 11010111b
-10000101b | 11010100b = 11010101b
-10000101b | 11010101b = 11010101b
-10000101b | 11010110b = 11010111b
-10000101b | 11010111b = 11010111b
-10000101b | 11011000b = 11011101b
-10000101b | 11011001b = 11011101b
-10000101b | 11011010b = 11011111b
-10000101b | 11011011b = 11011111b
-10000101b | 11011100b = 11011101b
-10000101b | 11011101b = 11011101b
-10000101b | 11011110b = 11011111b
-10000101b | 11011111b = 11011111b
-10000101b | 11100000b = 11100101b
-10000101b | 11100001b = 11100101b
-10000101b | 11100010b = 11100111b
-10000101b | 11100011b = 11100111b
-10000101b | 11100100b = 11100101b
-10000101b | 11100101b = 11100101b
-10000101b | 11100110b = 11100111b
-10000101b | 11100111b = 11100111b
-10000101b | 11101000b = 11101101b
-10000101b | 11101001b = 11101101b
-10000101b | 11101010b = 11101111b
-10000101b | 11101011b = 11101111b
-10000101b | 11101100b = 11101101b
-10000101b | 11101101b = 11101101b
-10000101b | 11101110b = 11101111b
-10000101b | 11101111b = 11101111b
-10000101b | 11110000b = 11110101b
-10000101b | 11110001b = 11110101b
-10000101b | 11110010b = 11110111b
-10000101b | 11110011b = 11110111b
-10000101b | 11110100b = 11110101b
-10000101b | 11110101b = 11110101b
-10000101b | 11110110b = 11110111b
-10000101b | 11110111b = 11110111b
-10000101b | 11111000b = 11111101b
-10000101b | 11111001b = 11111101b
-10000101b | 11111010b = 11111111b
-10000101b | 11111011b = 11111111b
-10000101b | 11111100b = 11111101b
-10000101b | 11111101b = 11111101b
-10000101b | 11111110b = 11111111b
-10000101b | 11111111b = 11111111b
-10000101b | 00000000b = 10000101b
-10000101b | 00000001b = 10000101b
-10000101b | 00000010b = 10000111b
-10000101b | 00000011b = 10000111b
-10000101b | 00000100b = 10000101b
-10000101b | 00000101b = 10000101b
-10000101b | 00000110b = 10000111b
-10000101b | 00000111b = 10000111b
-10000101b | 00001000b = 10001101b
-10000101b | 00001001b = 10001101b
-10000101b | 00001010b = 10001111b
-10000101b | 00001011b = 10001111b
-10000101b | 00001100b = 10001101b
-10000101b | 00001101b = 10001101b
-10000101b | 00001110b = 10001111b
-10000101b | 00001111b = 10001111b
-10000101b | 00010000b = 10010101b
-10000101b | 00010001b = 10010101b
-10000101b | 00010010b = 10010111b
-10000101b | 00010011b = 10010111b
-10000101b | 00010100b = 10010101b
-10000101b | 00010101b = 10010101b
-10000101b | 00010110b = 10010111b
-10000101b | 00010111b = 10010111b
-10000101b | 00011000b = 10011101b
-10000101b | 00011001b = 10011101b
-10000101b | 00011010b = 10011111b
-10000101b | 00011011b = 10011111b
-10000101b | 00011100b = 10011101b
-10000101b | 00011101b = 10011101b
-10000101b | 00011110b = 10011111b
-10000101b | 00011111b = 10011111b
-10000101b | 00100000b = 10100101b
-10000101b | 00100001b = 10100101b
-10000101b | 00100010b = 10100111b
-10000101b | 00100011b = 10100111b
-10000101b | 00100100b = 10100101b
-10000101b | 00100101b = 10100101b
-10000101b | 00100110b = 10100111b
-10000101b | 00100111b = 10100111b
-10000101b | 00101000b = 10101101b
-10000101b | 00101001b = 10101101b
-10000101b | 00101010b = 10101111b
-10000101b | 00101011b = 10101111b
-10000101b | 00101100b = 10101101b
-10000101b | 00101101b = 10101101b
-10000101b | 00101110b = 10101111b
-10000101b | 00101111b = 10101111b
-10000101b | 00110000b = 10110101b
-10000101b | 00110001b = 10110101b
-10000101b | 00110010b = 10110111b
-10000101b | 00110011b = 10110111b
-10000101b | 00110100b = 10110101b
-10000101b | 00110101b = 10110101b
-10000101b | 00110110b = 10110111b
-10000101b | 00110111b = 10110111b
-10000101b | 00111000b = 10111101b
-10000101b | 00111001b = 10111101b
-10000101b | 00111010b = 10111111b
-10000101b | 00111011b = 10111111b
-10000101b | 00111100b = 10111101b
-10000101b | 00111101b = 10111101b
-10000101b | 00111110b = 10111111b
-10000101b | 00111111b = 10111111b
-10000101b | 01000000b = 11000101b
-10000101b | 01000001b = 11000101b
-10000101b | 01000010b = 11000111b
-10000101b | 01000011b = 11000111b
-10000101b | 01000100b = 11000101b
-10000101b | 01000101b = 11000101b
-10000101b | 01000110b = 11000111b
-10000101b | 01000111b = 11000111b
-10000101b | 01001000b = 11001101b
-10000101b | 01001001b = 11001101b
-10000101b | 01001010b = 11001111b
-10000101b | 01001011b = 11001111b
-10000101b | 01001100b = 11001101b
-10000101b | 01001101b = 11001101b
-10000101b | 01001110b = 11001111b
-10000101b | 01001111b = 11001111b
-10000101b | 01010000b = 11010101b
-10000101b | 01010001b = 11010101b
-10000101b | 01010010b = 11010111b
-10000101b | 01010011b = 11010111b
-10000101b | 01010100b = 11010101b
-10000101b | 01010101b = 11010101b
-10000101b | 01010110b = 11010111b
-10000101b | 01010111b = 11010111b
-10000101b | 01011000b = 11011101b
-10000101b | 01011001b = 11011101b
-10000101b | 01011010b = 11011111b
-10000101b | 01011011b = 11011111b
-10000101b | 01011100b = 11011101b
-10000101b | 01011101b = 11011101b
-10000101b | 01011110b = 11011111b
-10000101b | 01011111b = 11011111b
-10000101b | 01100000b = 11100101b
-10000101b | 01100001b = 11100101b
-10000101b | 01100010b = 11100111b
-10000101b | 01100011b = 11100111b
-10000101b | 01100100b = 11100101b
-10000101b | 01100101b = 11100101b
-10000101b | 01100110b = 11100111b
-10000101b | 01100111b = 11100111b
-10000101b | 01101000b = 11101101b
-10000101b | 01101001b = 11101101b
-10000101b | 01101010b = 11101111b
-10000101b | 01101011b = 11101111b
-10000101b | 01101100b = 11101101b
-10000101b | 01101101b = 11101101b
-10000101b | 01101110b = 11101111b
-10000101b | 01101111b = 11101111b
-10000101b | 01110000b = 11110101b
-10000101b | 01110001b = 11110101b
-10000101b | 01110010b = 11110111b
-10000101b | 01110011b = 11110111b
-10000101b | 01110100b = 11110101b
-10000101b | 01110101b = 11110101b
-10000101b | 01110110b = 11110111b
-10000101b | 01110111b = 11110111b
-10000101b | 01111000b = 11111101b
-10000101b | 01111001b = 11111101b
-10000101b | 01111010b = 11111111b
-10000101b | 01111011b = 11111111b
-10000101b | 01111100b = 11111101b
-10000101b | 01111101b = 11111101b
-10000101b | 01111110b = 11111111b
-10000110b | 10000000b = 10000110b
-10000110b | 10000001b = 10000111b
-10000110b | 10000010b = 10000110b
-10000110b | 10000011b = 10000111b
-10000110b | 10000100b = 10000110b
-10000110b | 10000101b = 10000111b
-10000110b | 10000110b = 10000110b
-10000110b | 10000111b = 10000111b
-10000110b | 10001000b = 10001110b
-10000110b | 10001001b = 10001111b
-10000110b | 10001010b = 10001110b
-10000110b | 10001011b = 10001111b
-10000110b | 10001100b = 10001110b
-10000110b | 10001101b = 10001111b
-10000110b | 10001110b = 10001110b
-10000110b | 10001111b = 10001111b
-10000110b | 10010000b = 10010110b
-10000110b | 10010001b = 10010111b
-10000110b | 10010010b = 10010110b
-10000110b | 10010011b = 10010111b
-10000110b | 10010100b = 10010110b
-10000110b | 10010101b = 10010111b
-10000110b | 10010110b = 10010110b
-10000110b | 10010111b = 10010111b
-10000110b | 10011000b = 10011110b
-10000110b | 10011001b = 10011111b
-10000110b | 10011010b = 10011110b
-10000110b | 10011011b = 10011111b
-10000110b | 10011100b = 10011110b
-10000110b | 10011101b = 10011111b
-10000110b | 10011110b = 10011110b
-10000110b | 10011111b = 10011111b
-10000110b | 10100000b = 10100110b
-10000110b | 10100001b = 10100111b
-10000110b | 10100010b = 10100110b
-10000110b | 10100011b = 10100111b
-10000110b | 10100100b = 10100110b
-10000110b | 10100101b = 10100111b
-10000110b | 10100110b = 10100110b
-10000110b | 10100111b = 10100111b
-10000110b | 10101000b = 10101110b
-10000110b | 10101001b = 10101111b
-10000110b | 10101010b = 10101110b
-10000110b | 10101011b = 10101111b
-10000110b | 10101100b = 10101110b
-10000110b | 10101101b = 10101111b
-10000110b | 10101110b = 10101110b
-10000110b | 10101111b = 10101111b
-10000110b | 10110000b = 10110110b
-10000110b | 10110001b = 10110111b
-10000110b | 10110010b = 10110110b
-10000110b | 10110011b = 10110111b
-10000110b | 10110100b = 10110110b
-10000110b | 10110101b = 10110111b
-10000110b | 10110110b = 10110110b
-10000110b | 10110111b = 10110111b
-10000110b | 10111000b = 10111110b
-10000110b | 10111001b = 10111111b
-10000110b | 10111010b = 10111110b
-10000110b | 10111011b = 10111111b
-10000110b | 10111100b = 10111110b
-10000110b | 10111101b = 10111111b
-10000110b | 10111110b = 10111110b
-10000110b | 10111111b = 10111111b
-10000110b | 11000000b = 11000110b
-10000110b | 11000001b = 11000111b
-10000110b | 11000010b = 11000110b
-10000110b | 11000011b = 11000111b
-10000110b | 11000100b = 11000110b
-10000110b | 11000101b = 11000111b
-10000110b | 11000110b = 11000110b
-10000110b | 11000111b = 11000111b
-10000110b | 11001000b = 11001110b
-10000110b | 11001001b = 11001111b
-10000110b | 11001010b = 11001110b
-10000110b | 11001011b = 11001111b
-10000110b | 11001100b = 11001110b
-10000110b | 11001101b = 11001111b
-10000110b | 11001110b = 11001110b
-10000110b | 11001111b = 11001111b
-10000110b | 11010000b = 11010110b
-10000110b | 11010001b = 11010111b
-10000110b | 11010010b = 11010110b
-10000110b | 11010011b = 11010111b
-10000110b | 11010100b = 11010110b
-10000110b | 11010101b = 11010111b
-10000110b | 11010110b = 11010110b
-10000110b | 11010111b = 11010111b
-10000110b | 11011000b = 11011110b
-10000110b | 11011001b = 11011111b
-10000110b | 11011010b = 11011110b
-10000110b | 11011011b = 11011111b
-10000110b | 11011100b = 11011110b
-10000110b | 11011101b = 11011111b
-10000110b | 11011110b = 11011110b
-10000110b | 11011111b = 11011111b
-10000110b | 11100000b = 11100110b
-10000110b | 11100001b = 11100111b
-10000110b | 11100010b = 11100110b
-10000110b | 11100011b = 11100111b
-10000110b | 11100100b = 11100110b
-10000110b | 11100101b = 11100111b
-10000110b | 11100110b = 11100110b
-10000110b | 11100111b = 11100111b
-10000110b | 11101000b = 11101110b
-10000110b | 11101001b = 11101111b
-10000110b | 11101010b = 11101110b
-10000110b | 11101011b = 11101111b
-10000110b | 11101100b = 11101110b
-10000110b | 11101101b = 11101111b
-10000110b | 11101110b = 11101110b
-10000110b | 11101111b = 11101111b
-10000110b | 11110000b = 11110110b
-10000110b | 11110001b = 11110111b
-10000110b | 11110010b = 11110110b
-10000110b | 11110011b = 11110111b
-10000110b | 11110100b = 11110110b
-10000110b | 11110101b = 11110111b
-10000110b | 11110110b = 11110110b
-10000110b | 11110111b = 11110111b
-10000110b | 11111000b = 11111110b
-10000110b | 11111001b = 11111111b
-10000110b | 11111010b = 11111110b
-10000110b | 11111011b = 11111111b
-10000110b | 11111100b = 11111110b
-10000110b | 11111101b = 11111111b
-10000110b | 11111110b = 11111110b
-10000110b | 11111111b = 11111111b
-10000110b | 00000000b = 10000110b
-10000110b | 00000001b = 10000111b
-10000110b | 00000010b = 10000110b
-10000110b | 00000011b = 10000111b
-10000110b | 00000100b = 10000110b
-10000110b | 00000101b = 10000111b
-10000110b | 00000110b = 10000110b
-10000110b | 00000111b = 10000111b
-10000110b | 00001000b = 10001110b
-10000110b | 00001001b = 10001111b
-10000110b | 00001010b = 10001110b
-10000110b | 00001011b = 10001111b
-10000110b | 00001100b = 10001110b
-10000110b | 00001101b = 10001111b
-10000110b | 00001110b = 10001110b
-10000110b | 00001111b = 10001111b
-10000110b | 00010000b = 10010110b
-10000110b | 00010001b = 10010111b
-10000110b | 00010010b = 10010110b
-10000110b | 00010011b = 10010111b
-10000110b | 00010100b = 10010110b
-10000110b | 00010101b = 10010111b
-10000110b | 00010110b = 10010110b
-10000110b | 00010111b = 10010111b
-10000110b | 00011000b = 10011110b
-10000110b | 00011001b = 10011111b
-10000110b | 00011010b = 10011110b
-10000110b | 00011011b = 10011111b
-10000110b | 00011100b = 10011110b
-10000110b | 00011101b = 10011111b
-10000110b | 00011110b = 10011110b
-10000110b | 00011111b = 10011111b
-10000110b | 00100000b = 10100110b
-10000110b | 00100001b = 10100111b
-10000110b | 00100010b = 10100110b
-10000110b | 00100011b = 10100111b
-10000110b | 00100100b = 10100110b
-10000110b | 00100101b = 10100111b
-10000110b | 00100110b = 10100110b
-10000110b | 00100111b = 10100111b
-10000110b | 00101000b = 10101110b
-10000110b | 00101001b = 10101111b
-10000110b | 00101010b = 10101110b
-10000110b | 00101011b = 10101111b
-10000110b | 00101100b = 10101110b
-10000110b | 00101101b = 10101111b
-10000110b | 00101110b = 10101110b
-10000110b | 00101111b = 10101111b
-10000110b | 00110000b = 10110110b
-10000110b | 00110001b = 10110111b
-10000110b | 00110010b = 10110110b
-10000110b | 00110011b = 10110111b
-10000110b | 00110100b = 10110110b
-10000110b | 00110101b = 10110111b
-10000110b | 00110110b = 10110110b
-10000110b | 00110111b = 10110111b
-10000110b | 00111000b = 10111110b
-10000110b | 00111001b = 10111111b
-10000110b | 00111010b = 10111110b
-10000110b | 00111011b = 10111111b
-10000110b | 00111100b = 10111110b
-10000110b | 00111101b = 10111111b
-10000110b | 00111110b = 10111110b
-10000110b | 00111111b = 10111111b
-10000110b | 01000000b = 11000110b
-10000110b | 01000001b = 11000111b
-10000110b | 01000010b = 11000110b
-10000110b | 01000011b = 11000111b
-10000110b | 01000100b = 11000110b
-10000110b | 01000101b = 11000111b
-10000110b | 01000110b = 11000110b
-10000110b | 01000111b = 11000111b
-10000110b | 01001000b = 11001110b
-10000110b | 01001001b = 11001111b
-10000110b | 01001010b = 11001110b
-10000110b | 01001011b = 11001111b
-10000110b | 01001100b = 11001110b
-10000110b | 01001101b = 11001111b
-10000110b | 01001110b = 11001110b
-10000110b | 01001111b = 11001111b
-10000110b | 01010000b = 11010110b
-10000110b | 01010001b = 11010111b
-10000110b | 01010010b = 11010110b
-10000110b | 01010011b = 11010111b
-10000110b | 01010100b = 11010110b
-10000110b | 01010101b = 11010111b
-10000110b | 01010110b = 11010110b
-10000110b | 01010111b = 11010111b
-10000110b | 01011000b = 11011110b
-10000110b | 01011001b = 11011111b
-10000110b | 01011010b = 11011110b
-10000110b | 01011011b = 11011111b
-10000110b | 01011100b = 11011110b
-10000110b | 01011101b = 11011111b
-10000110b | 01011110b = 11011110b
-10000110b | 01011111b = 11011111b
-10000110b | 01100000b = 11100110b
-10000110b | 01100001b = 11100111b
-10000110b | 01100010b = 11100110b
-10000110b | 01100011b = 11100111b
-10000110b | 01100100b = 11100110b
-10000110b | 01100101b = 11100111b
-10000110b | 01100110b = 11100110b
-10000110b | 01100111b = 11100111b
-10000110b | 01101000b = 11101110b
-10000110b | 01101001b = 11101111b
-10000110b | 01101010b = 11101110b
-10000110b | 01101011b = 11101111b
-10000110b | 01101100b = 11101110b
-10000110b | 01101101b = 11101111b
-10000110b | 01101110b = 11101110b
-10000110b | 01101111b = 11101111b
-10000110b | 01110000b = 11110110b
-10000110b | 01110001b = 11110111b
-10000110b | 01110010b = 11110110b
-10000110b | 01110011b = 11110111b
-10000110b | 01110100b = 11110110b
-10000110b | 01110101b = 11110111b
-10000110b | 01110110b = 11110110b
-10000110b | 01110111b = 11110111b
-10000110b | 01111000b = 11111110b
-10000110b | 01111001b = 11111111b
-10000110b | 01111010b = 11111110b
-10000110b | 01111011b = 11111111b
-10000110b | 01111100b = 11111110b
-10000110b | 01111101b = 11111111b
-10000110b | 01111110b = 11111110b
-10000111b | 10000000b = 10000111b
-10000111b | 10000001b = 10000111b
-10000111b | 10000010b = 10000111b
-10000111b | 10000011b = 10000111b
-10000111b | 10000100b = 10000111b
-10000111b | 10000101b = 10000111b
-10000111b | 10000110b = 10000111b
-10000111b | 10000111b = 10000111b
-10000111b | 10001000b = 10001111b
-10000111b | 10001001b = 10001111b
-10000111b | 10001010b = 10001111b
-10000111b | 10001011b = 10001111b
-10000111b | 10001100b = 10001111b
-10000111b | 10001101b = 10001111b
-10000111b | 10001110b = 10001111b
-10000111b | 10001111b = 10001111b
-10000111b | 10010000b = 10010111b
-10000111b | 10010001b = 10010111b
-10000111b | 10010010b = 10010111b
-10000111b | 10010011b = 10010111b
-10000111b | 10010100b = 10010111b
-10000111b | 10010101b = 10010111b
-10000111b | 10010110b = 10010111b
-10000111b | 10010111b = 10010111b
-10000111b | 10011000b = 10011111b
-10000111b | 10011001b = 10011111b
-10000111b | 10011010b = 10011111b
-10000111b | 10011011b = 10011111b
-10000111b | 10011100b = 10011111b
-10000111b | 10011101b = 10011111b
-10000111b | 10011110b = 10011111b
-10000111b | 10011111b = 10011111b
-10000111b | 10100000b = 10100111b
-10000111b | 10100001b = 10100111b
-10000111b | 10100010b = 10100111b
-10000111b | 10100011b = 10100111b
-10000111b | 10100100b = 10100111b
-10000111b | 10100101b = 10100111b
-10000111b | 10100110b = 10100111b
-10000111b | 10100111b = 10100111b
-10000111b | 10101000b = 10101111b
-10000111b | 10101001b = 10101111b
-10000111b | 10101010b = 10101111b
-10000111b | 10101011b = 10101111b
-10000111b | 10101100b = 10101111b
-10000111b | 10101101b = 10101111b
-10000111b | 10101110b = 10101111b
-10000111b | 10101111b = 10101111b
-10000111b | 10110000b = 10110111b
-10000111b | 10110001b = 10110111b
-10000111b | 10110010b = 10110111b
-10000111b | 10110011b = 10110111b
-10000111b | 10110100b = 10110111b
-10000111b | 10110101b = 10110111b
-10000111b | 10110110b = 10110111b
-10000111b | 10110111b = 10110111b
-10000111b | 10111000b = 10111111b
-10000111b | 10111001b = 10111111b
-10000111b | 10111010b = 10111111b
-10000111b | 10111011b = 10111111b
-10000111b | 10111100b = 10111111b
-10000111b | 10111101b = 10111111b
-10000111b | 10111110b = 10111111b
-10000111b | 10111111b = 10111111b
-10000111b | 11000000b = 11000111b
-10000111b | 11000001b = 11000111b
-10000111b | 11000010b = 11000111b
-10000111b | 11000011b = 11000111b
-10000111b | 11000100b = 11000111b
-10000111b | 11000101b = 11000111b
-10000111b | 11000110b = 11000111b
-10000111b | 11000111b = 11000111b
-10000111b | 11001000b = 11001111b
-10000111b | 11001001b = 11001111b
-10000111b | 11001010b = 11001111b
-10000111b | 11001011b = 11001111b
-10000111b | 11001100b = 11001111b
-10000111b | 11001101b = 11001111b
-10000111b | 11001110b = 11001111b
-10000111b | 11001111b = 11001111b
-10000111b | 11010000b = 11010111b
-10000111b | 11010001b = 11010111b
-10000111b | 11010010b = 11010111b
-10000111b | 11010011b = 11010111b
-10000111b | 11010100b = 11010111b
-10000111b | 11010101b = 11010111b
-10000111b | 11010110b = 11010111b
-10000111b | 11010111b = 11010111b
-10000111b | 11011000b = 11011111b
-10000111b | 11011001b = 11011111b
-10000111b | 11011010b = 11011111b
-10000111b | 11011011b = 11011111b
-10000111b | 11011100b = 11011111b
-10000111b | 11011101b = 11011111b
-10000111b | 11011110b = 11011111b
-10000111b | 11011111b = 11011111b
-10000111b | 11100000b = 11100111b
-10000111b | 11100001b = 11100111b
-10000111b | 11100010b = 11100111b
-10000111b | 11100011b = 11100111b
-10000111b | 11100100b = 11100111b
-10000111b | 11100101b = 11100111b
-10000111b | 11100110b = 11100111b
-10000111b | 11100111b = 11100111b
-10000111b | 11101000b = 11101111b
-10000111b | 11101001b = 11101111b
-10000111b | 11101010b = 11101111b
-10000111b | 11101011b = 11101111b
-10000111b | 11101100b = 11101111b
-10000111b | 11101101b = 11101111b
-10000111b | 11101110b = 11101111b
-10000111b | 11101111b = 11101111b
-10000111b | 11110000b = 11110111b
-10000111b | 11110001b = 11110111b
-10000111b | 11110010b = 11110111b
-10000111b | 11110011b = 11110111b
-10000111b | 11110100b = 11110111b
-10000111b | 11110101b = 11110111b
-10000111b | 11110110b = 11110111b
-10000111b | 11110111b = 11110111b
-10000111b | 11111000b = 11111111b
-10000111b | 11111001b = 11111111b
-10000111b | 11111010b = 11111111b
-10000111b | 11111011b = 11111111b
-10000111b | 11111100b = 11111111b
-10000111b | 11111101b = 11111111b
-10000111b | 11111110b = 11111111b
-10000111b | 11111111b = 11111111b
-10000111b | 00000000b = 10000111b
-10000111b | 00000001b = 10000111b
-10000111b | 00000010b = 10000111b
-10000111b | 00000011b = 10000111b
-10000111b | 00000100b = 10000111b
-10000111b | 00000101b = 10000111b
-10000111b | 00000110b = 10000111b
-10000111b | 00000111b = 10000111b
-10000111b | 00001000b = 10001111b
-10000111b | 00001001b = 10001111b
-10000111b | 00001010b = 10001111b
-10000111b | 00001011b = 10001111b
-10000111b | 00001100b = 10001111b
-10000111b | 00001101b = 10001111b
-10000111b | 00001110b = 10001111b
-10000111b | 00001111b = 10001111b
-10000111b | 00010000b = 10010111b
-10000111b | 00010001b = 10010111b
-10000111b | 00010010b = 10010111b
-10000111b | 00010011b = 10010111b
-10000111b | 00010100b = 10010111b
-10000111b | 00010101b = 10010111b
-10000111b | 00010110b = 10010111b
-10000111b | 00010111b = 10010111b
-10000111b | 00011000b = 10011111b
-10000111b | 00011001b = 10011111b
-10000111b | 00011010b = 10011111b
-10000111b | 00011011b = 10011111b
-10000111b | 00011100b = 10011111b
-10000111b | 00011101b = 10011111b
-10000111b | 00011110b = 10011111b
-10000111b | 00011111b = 10011111b
-10000111b | 00100000b = 10100111b
-10000111b | 00100001b = 10100111b
-10000111b | 00100010b = 10100111b
-10000111b | 00100011b = 10100111b
-10000111b | 00100100b = 10100111b
-10000111b | 00100101b = 10100111b
-10000111b | 00100110b = 10100111b
-10000111b | 00100111b = 10100111b
-10000111b | 00101000b = 10101111b
-10000111b | 00101001b = 10101111b
-10000111b | 00101010b = 10101111b
-10000111b | 00101011b = 10101111b
-10000111b | 00101100b = 10101111b
-10000111b | 00101101b = 10101111b
-10000111b | 00101110b = 10101111b
-10000111b | 00101111b = 10101111b
-10000111b | 00110000b = 10110111b
-10000111b | 00110001b = 10110111b
-10000111b | 00110010b = 10110111b
-10000111b | 00110011b = 10110111b
-10000111b | 00110100b = 10110111b
-10000111b | 00110101b = 10110111b
-10000111b | 00110110b = 10110111b
-10000111b | 00110111b = 10110111b
-10000111b | 00111000b = 10111111b
-10000111b | 00111001b = 10111111b
-10000111b | 00111010b = 10111111b
-10000111b | 00111011b = 10111111b
-10000111b | 00111100b = 10111111b
-10000111b | 00111101b = 10111111b
-10000111b | 00111110b = 10111111b
-10000111b | 00111111b = 10111111b
-10000111b | 01000000b = 11000111b
-10000111b | 01000001b = 11000111b
-10000111b | 01000010b = 11000111b
-10000111b | 01000011b = 11000111b
-10000111b | 01000100b = 11000111b
-10000111b | 01000101b = 11000111b
-10000111b | 01000110b = 11000111b
-10000111b | 01000111b = 11000111b
-10000111b | 01001000b = 11001111b
-10000111b | 01001001b = 11001111b
-10000111b | 01001010b = 11001111b
-10000111b | 01001011b = 11001111b
-10000111b | 01001100b = 11001111b
-10000111b | 01001101b = 11001111b
-10000111b | 01001110b = 11001111b
-10000111b | 01001111b = 11001111b
-10000111b | 01010000b = 11010111b
-10000111b | 01010001b = 11010111b
-10000111b | 01010010b = 11010111b
-10000111b | 01010011b = 11010111b
-10000111b | 01010100b = 11010111b
-10000111b | 01010101b = 11010111b
-10000111b | 01010110b = 11010111b
-10000111b | 01010111b = 11010111b
-10000111b | 01011000b = 11011111b
-10000111b | 01011001b = 11011111b
-10000111b | 01011010b = 11011111b
-10000111b | 01011011b = 11011111b
-10000111b | 01011100b = 11011111b
-10000111b | 01011101b = 11011111b
-10000111b | 01011110b = 11011111b
-10000111b | 01011111b = 11011111b
-10000111b | 01100000b = 11100111b
-10000111b | 01100001b = 11100111b
-10000111b | 01100010b = 11100111b
-10000111b | 01100011b = 11100111b
-10000111b | 01100100b = 11100111b
-10000111b | 01100101b = 11100111b
-10000111b | 01100110b = 11100111b
-10000111b | 01100111b = 11100111b
-10000111b | 01101000b = 11101111b
-10000111b | 01101001b = 11101111b
-10000111b | 01101010b = 11101111b
-10000111b | 01101011b = 11101111b
-10000111b | 01101100b = 11101111b
-10000111b | 01101101b = 11101111b
-10000111b | 01101110b = 11101111b
-10000111b | 01101111b = 11101111b
-10000111b | 01110000b = 11110111b
-10000111b | 01110001b = 11110111b
-10000111b | 01110010b = 11110111b
-10000111b | 01110011b = 11110111b
-10000111b | 01110100b = 11110111b
-10000111b | 01110101b = 11110111b
-10000111b | 01110110b = 11110111b
-10000111b | 01110111b = 11110111b
-10000111b | 01111000b = 11111111b
-10000111b | 01111001b = 11111111b
-10000111b | 01111010b = 11111111b
-10000111b | 01111011b = 11111111b
-10000111b | 01111100b = 11111111b
-10000111b | 01111101b = 11111111b
-10000111b | 01111110b = 11111111b
-10001000b | 10000000b = 10001000b
-10001000b | 10000001b = 10001001b
-10001000b | 10000010b = 10001010b
-10001000b | 10000011b = 10001011b
-10001000b | 10000100b = 10001100b
-10001000b | 10000101b = 10001101b
-10001000b | 10000110b = 10001110b
-10001000b | 10000111b = 10001111b
-10001000b | 10001000b = 10001000b
-10001000b | 10001001b = 10001001b
-10001000b | 10001010b = 10001010b
-10001000b | 10001011b = 10001011b
-10001000b | 10001100b = 10001100b
-10001000b | 10001101b = 10001101b
-10001000b | 10001110b = 10001110b
-10001000b | 10001111b = 10001111b
-10001000b | 10010000b = 10011000b
-10001000b | 10010001b = 10011001b
-10001000b | 10010010b = 10011010b
-10001000b | 10010011b = 10011011b
-10001000b | 10010100b = 10011100b
-10001000b | 10010101b = 10011101b
-10001000b | 10010110b = 10011110b
-10001000b | 10010111b = 10011111b
-10001000b | 10011000b = 10011000b
-10001000b | 10011001b = 10011001b
-10001000b | 10011010b = 10011010b
-10001000b | 10011011b = 10011011b
-10001000b | 10011100b = 10011100b
-10001000b | 10011101b = 10011101b
-10001000b | 10011110b = 10011110b
-10001000b | 10011111b = 10011111b
-10001000b | 10100000b = 10101000b
-10001000b | 10100001b = 10101001b
-10001000b | 10100010b = 10101010b
-10001000b | 10100011b = 10101011b
-10001000b | 10100100b = 10101100b
-10001000b | 10100101b = 10101101b
-10001000b | 10100110b = 10101110b
-10001000b | 10100111b = 10101111b
-10001000b | 10101000b = 10101000b
-10001000b | 10101001b = 10101001b
-10001000b | 10101010b = 10101010b
-10001000b | 10101011b = 10101011b
-10001000b | 10101100b = 10101100b
-10001000b | 10101101b = 10101101b
-10001000b | 10101110b = 10101110b
-10001000b | 10101111b = 10101111b
-10001000b | 10110000b = 10111000b
-10001000b | 10110001b = 10111001b
-10001000b | 10110010b = 10111010b
-10001000b | 10110011b = 10111011b
-10001000b | 10110100b = 10111100b
-10001000b | 10110101b = 10111101b
-10001000b | 10110110b = 10111110b
-10001000b | 10110111b = 10111111b
-10001000b | 10111000b = 10111000b
-10001000b | 10111001b = 10111001b
-10001000b | 10111010b = 10111010b
-10001000b | 10111011b = 10111011b
-10001000b | 10111100b = 10111100b
-10001000b | 10111101b = 10111101b
-10001000b | 10111110b = 10111110b
-10001000b | 10111111b = 10111111b
-10001000b | 11000000b = 11001000b
-10001000b | 11000001b = 11001001b
-10001000b | 11000010b = 11001010b
-10001000b | 11000011b = 11001011b
-10001000b | 11000100b = 11001100b
-10001000b | 11000101b = 11001101b
-10001000b | 11000110b = 11001110b
-10001000b | 11000111b = 11001111b
-10001000b | 11001000b = 11001000b
-10001000b | 11001001b = 11001001b
-10001000b | 11001010b = 11001010b
-10001000b | 11001011b = 11001011b
-10001000b | 11001100b = 11001100b
-10001000b | 11001101b = 11001101b
-10001000b | 11001110b = 11001110b
-10001000b | 11001111b = 11001111b
-10001000b | 11010000b = 11011000b
-10001000b | 11010001b = 11011001b
-10001000b | 11010010b = 11011010b
-10001000b | 11010011b = 11011011b
-10001000b | 11010100b = 11011100b
-10001000b | 11010101b = 11011101b
-10001000b | 11010110b = 11011110b
-10001000b | 11010111b = 11011111b
-10001000b | 11011000b = 11011000b
-10001000b | 11011001b = 11011001b
-10001000b | 11011010b = 11011010b
-10001000b | 11011011b = 11011011b
-10001000b | 11011100b = 11011100b
-10001000b | 11011101b = 11011101b
-10001000b | 11011110b = 11011110b
-10001000b | 11011111b = 11011111b
-10001000b | 11100000b = 11101000b
-10001000b | 11100001b = 11101001b
-10001000b | 11100010b = 11101010b
-10001000b | 11100011b = 11101011b
-10001000b | 11100100b = 11101100b
-10001000b | 11100101b = 11101101b
-10001000b | 11100110b = 11101110b
-10001000b | 11100111b = 11101111b
-10001000b | 11101000b = 11101000b
-10001000b | 11101001b = 11101001b
-10001000b | 11101010b = 11101010b
-10001000b | 11101011b = 11101011b
-10001000b | 11101100b = 11101100b
-10001000b | 11101101b = 11101101b
-10001000b | 11101110b = 11101110b
-10001000b | 11101111b = 11101111b
-10001000b | 11110000b = 11111000b
-10001000b | 11110001b = 11111001b
-10001000b | 11110010b = 11111010b
-10001000b | 11110011b = 11111011b
-10001000b | 11110100b = 11111100b
-10001000b | 11110101b = 11111101b
-10001000b | 11110110b = 11111110b
-10001000b | 11110111b = 11111111b
-10001000b | 11111000b = 11111000b
-10001000b | 11111001b = 11111001b
-10001000b | 11111010b = 11111010b
-10001000b | 11111011b = 11111011b
-10001000b | 11111100b = 11111100b
-10001000b | 11111101b = 11111101b
-10001000b | 11111110b = 11111110b
-10001000b | 11111111b = 11111111b
-10001000b | 00000000b = 10001000b
-10001000b | 00000001b = 10001001b
-10001000b | 00000010b = 10001010b
-10001000b | 00000011b = 10001011b
-10001000b | 00000100b = 10001100b
-10001000b | 00000101b = 10001101b
-10001000b | 00000110b = 10001110b
-10001000b | 00000111b = 10001111b
-10001000b | 00001000b = 10001000b
-10001000b | 00001001b = 10001001b
-10001000b | 00001010b = 10001010b
-10001000b | 00001011b = 10001011b
-10001000b | 00001100b = 10001100b
-10001000b | 00001101b = 10001101b
-10001000b | 00001110b = 10001110b
-10001000b | 00001111b = 10001111b
-10001000b | 00010000b = 10011000b
-10001000b | 00010001b = 10011001b
-10001000b | 00010010b = 10011010b
-10001000b | 00010011b = 10011011b
-10001000b | 00010100b = 10011100b
-10001000b | 00010101b = 10011101b
-10001000b | 00010110b = 10011110b
-10001000b | 00010111b = 10011111b
-10001000b | 00011000b = 10011000b
-10001000b | 00011001b = 10011001b
-10001000b | 00011010b = 10011010b
-10001000b | 00011011b = 10011011b
-10001000b | 00011100b = 10011100b
-10001000b | 00011101b = 10011101b
-10001000b | 00011110b = 10011110b
-10001000b | 00011111b = 10011111b
-10001000b | 00100000b = 10101000b
-10001000b | 00100001b = 10101001b
-10001000b | 00100010b = 10101010b
-10001000b | 00100011b = 10101011b
-10001000b | 00100100b = 10101100b
-10001000b | 00100101b = 10101101b
-10001000b | 00100110b = 10101110b
-10001000b | 00100111b = 10101111b
-10001000b | 00101000b = 10101000b
-10001000b | 00101001b = 10101001b
-10001000b | 00101010b = 10101010b
-10001000b | 00101011b = 10101011b
-10001000b | 00101100b = 10101100b
-10001000b | 00101101b = 10101101b
-10001000b | 00101110b = 10101110b
-10001000b | 00101111b = 10101111b
-10001000b | 00110000b = 10111000b
-10001000b | 00110001b = 10111001b
-10001000b | 00110010b = 10111010b
-10001000b | 00110011b = 10111011b
-10001000b | 00110100b = 10111100b
-10001000b | 00110101b = 10111101b
-10001000b | 00110110b = 10111110b
-10001000b | 00110111b = 10111111b
-10001000b | 00111000b = 10111000b
-10001000b | 00111001b = 10111001b
-10001000b | 00111010b = 10111010b
-10001000b | 00111011b = 10111011b
-10001000b | 00111100b = 10111100b
-10001000b | 00111101b = 10111101b
-10001000b | 00111110b = 10111110b
-10001000b | 00111111b = 10111111b
-10001000b | 01000000b = 11001000b
-10001000b | 01000001b = 11001001b
-10001000b | 01000010b = 11001010b
-10001000b | 01000011b = 11001011b
-10001000b | 01000100b = 11001100b
-10001000b | 01000101b = 11001101b
-10001000b | 01000110b = 11001110b
-10001000b | 01000111b = 11001111b
-10001000b | 01001000b = 11001000b
-10001000b | 01001001b = 11001001b
-10001000b | 01001010b = 11001010b
-10001000b | 01001011b = 11001011b
-10001000b | 01001100b = 11001100b
-10001000b | 01001101b = 11001101b
-10001000b | 01001110b = 11001110b
-10001000b | 01001111b = 11001111b
-10001000b | 01010000b = 11011000b
-10001000b | 01010001b = 11011001b
-10001000b | 01010010b = 11011010b
-10001000b | 01010011b = 11011011b
-10001000b | 01010100b = 11011100b
-10001000b | 01010101b = 11011101b
-10001000b | 01010110b = 11011110b
-10001000b | 01010111b = 11011111b
-10001000b | 01011000b = 11011000b
-10001000b | 01011001b = 11011001b
-10001000b | 01011010b = 11011010b
-10001000b | 01011011b = 11011011b
-10001000b | 01011100b = 11011100b
-10001000b | 01011101b = 11011101b
-10001000b | 01011110b = 11011110b
-10001000b | 01011111b = 11011111b
-10001000b | 01100000b = 11101000b
-10001000b | 01100001b = 11101001b
-10001000b | 01100010b = 11101010b
-10001000b | 01100011b = 11101011b
-10001000b | 01100100b = 11101100b
-10001000b | 01100101b = 11101101b
-10001000b | 01100110b = 11101110b
-10001000b | 01100111b = 11101111b
-10001000b | 01101000b = 11101000b
-10001000b | 01101001b = 11101001b
-10001000b | 01101010b = 11101010b
-10001000b | 01101011b = 11101011b
-10001000b | 01101100b = 11101100b
-10001000b | 01101101b = 11101101b
-10001000b | 01101110b = 11101110b
-10001000b | 01101111b = 11101111b
-10001000b | 01110000b = 11111000b
-10001000b | 01110001b = 11111001b
-10001000b | 01110010b = 11111010b
-10001000b | 01110011b = 11111011b
-10001000b | 01110100b = 11111100b
-10001000b | 01110101b = 11111101b
-10001000b | 01110110b = 11111110b
-10001000b | 01110111b = 11111111b
-10001000b | 01111000b = 11111000b
-10001000b | 01111001b = 11111001b
-10001000b | 01111010b = 11111010b
-10001000b | 01111011b = 11111011b
-10001000b | 01111100b = 11111100b
-10001000b | 01111101b = 11111101b
-10001000b | 01111110b = 11111110b
-10001001b | 10000000b = 10001001b
-10001001b | 10000001b = 10001001b
-10001001b | 10000010b = 10001011b
-10001001b | 10000011b = 10001011b
-10001001b | 10000100b = 10001101b
-10001001b | 10000101b = 10001101b
-10001001b | 10000110b = 10001111b
-10001001b | 10000111b = 10001111b
-10001001b | 10001000b = 10001001b
-10001001b | 10001001b = 10001001b
-10001001b | 10001010b = 10001011b
-10001001b | 10001011b = 10001011b
-10001001b | 10001100b = 10001101b
-10001001b | 10001101b = 10001101b
-10001001b | 10001110b = 10001111b
-10001001b | 10001111b = 10001111b
-10001001b | 10010000b = 10011001b
-10001001b | 10010001b = 10011001b
-10001001b | 10010010b = 10011011b
-10001001b | 10010011b = 10011011b
-10001001b | 10010100b = 10011101b
-10001001b | 10010101b = 10011101b
-10001001b | 10010110b = 10011111b
-10001001b | 10010111b = 10011111b
-10001001b | 10011000b = 10011001b
-10001001b | 10011001b = 10011001b
-10001001b | 10011010b = 10011011b
-10001001b | 10011011b = 10011011b
-10001001b | 10011100b = 10011101b
-10001001b | 10011101b = 10011101b
-10001001b | 10011110b = 10011111b
-10001001b | 10011111b = 10011111b
-10001001b | 10100000b = 10101001b
-10001001b | 10100001b = 10101001b
-10001001b | 10100010b = 10101011b
-10001001b | 10100011b = 10101011b
-10001001b | 10100100b = 10101101b
-10001001b | 10100101b = 10101101b
-10001001b | 10100110b = 10101111b
-10001001b | 10100111b = 10101111b
-10001001b | 10101000b = 10101001b
-10001001b | 10101001b = 10101001b
-10001001b | 10101010b = 10101011b
-10001001b | 10101011b = 10101011b
-10001001b | 10101100b = 10101101b
-10001001b | 10101101b = 10101101b
-10001001b | 10101110b = 10101111b
-10001001b | 10101111b = 10101111b
-10001001b | 10110000b = 10111001b
-10001001b | 10110001b = 10111001b
-10001001b | 10110010b = 10111011b
-10001001b | 10110011b = 10111011b
-10001001b | 10110100b = 10111101b
-10001001b | 10110101b = 10111101b
-10001001b | 10110110b = 10111111b
-10001001b | 10110111b = 10111111b
-10001001b | 10111000b = 10111001b
-10001001b | 10111001b = 10111001b
-10001001b | 10111010b = 10111011b
-10001001b | 10111011b = 10111011b
-10001001b | 10111100b = 10111101b
-10001001b | 10111101b = 10111101b
-10001001b | 10111110b = 10111111b
-10001001b | 10111111b = 10111111b
-10001001b | 11000000b = 11001001b
-10001001b | 11000001b = 11001001b
-10001001b | 11000010b = 11001011b
-10001001b | 11000011b = 11001011b
-10001001b | 11000100b = 11001101b
-10001001b | 11000101b = 11001101b
-10001001b | 11000110b = 11001111b
-10001001b | 11000111b = 11001111b
-10001001b | 11001000b = 11001001b
-10001001b | 11001001b = 11001001b
-10001001b | 11001010b = 11001011b
-10001001b | 11001011b = 11001011b
-10001001b | 11001100b = 11001101b
-10001001b | 11001101b = 11001101b
-10001001b | 11001110b = 11001111b
-10001001b | 11001111b = 11001111b
-10001001b | 11010000b = 11011001b
-10001001b | 11010001b = 11011001b
-10001001b | 11010010b = 11011011b
-10001001b | 11010011b = 11011011b
-10001001b | 11010100b = 11011101b
-10001001b | 11010101b = 11011101b
-10001001b | 11010110b = 11011111b
-10001001b | 11010111b = 11011111b
-10001001b | 11011000b = 11011001b
-10001001b | 11011001b = 11011001b
-10001001b | 11011010b = 11011011b
-10001001b | 11011011b = 11011011b
-10001001b | 11011100b = 11011101b
-10001001b | 11011101b = 11011101b
-10001001b | 11011110b = 11011111b
-10001001b | 11011111b = 11011111b
-10001001b | 11100000b = 11101001b
-10001001b | 11100001b = 11101001b
-10001001b | 11100010b = 11101011b
-10001001b | 11100011b = 11101011b
-10001001b | 11100100b = 11101101b
-10001001b | 11100101b = 11101101b
-10001001b | 11100110b = 11101111b
-10001001b | 11100111b = 11101111b
-10001001b | 11101000b = 11101001b
-10001001b | 11101001b = 11101001b
-10001001b | 11101010b = 11101011b
-10001001b | 11101011b = 11101011b
-10001001b | 11101100b = 11101101b
-10001001b | 11101101b = 11101101b
-10001001b | 11101110b = 11101111b
-10001001b | 11101111b = 11101111b
-10001001b | 11110000b = 11111001b
-10001001b | 11110001b = 11111001b
-10001001b | 11110010b = 11111011b
-10001001b | 11110011b = 11111011b
-10001001b | 11110100b = 11111101b
-10001001b | 11110101b = 11111101b
-10001001b | 11110110b = 11111111b
-10001001b | 11110111b = 11111111b
-10001001b | 11111000b = 11111001b
-10001001b | 11111001b = 11111001b
-10001001b | 11111010b = 11111011b
-10001001b | 11111011b = 11111011b
-10001001b | 11111100b = 11111101b
-10001001b | 11111101b = 11111101b
-10001001b | 11111110b = 11111111b
-10001001b | 11111111b = 11111111b
-10001001b | 00000000b = 10001001b
-10001001b | 00000001b = 10001001b
-10001001b | 00000010b = 10001011b
-10001001b | 00000011b = 10001011b
-10001001b | 00000100b = 10001101b
-10001001b | 00000101b = 10001101b
-10001001b | 00000110b = 10001111b
-10001001b | 00000111b = 10001111b
-10001001b | 00001000b = 10001001b
-10001001b | 00001001b = 10001001b
-10001001b | 00001010b = 10001011b
-10001001b | 00001011b = 10001011b
-10001001b | 00001100b = 10001101b
-10001001b | 00001101b = 10001101b
-10001001b | 00001110b = 10001111b
-10001001b | 00001111b = 10001111b
-10001001b | 00010000b = 10011001b
-10001001b | 00010001b = 10011001b
-10001001b | 00010010b = 10011011b
-10001001b | 00010011b = 10011011b
-10001001b | 00010100b = 10011101b
-10001001b | 00010101b = 10011101b
-10001001b | 00010110b = 10011111b
-10001001b | 00010111b = 10011111b
-10001001b | 00011000b = 10011001b
-10001001b | 00011001b = 10011001b
-10001001b | 00011010b = 10011011b
-10001001b | 00011011b = 10011011b
-10001001b | 00011100b = 10011101b
-10001001b | 00011101b = 10011101b
-10001001b | 00011110b = 10011111b
-10001001b | 00011111b = 10011111b
-10001001b | 00100000b = 10101001b
-10001001b | 00100001b = 10101001b
-10001001b | 00100010b = 10101011b
-10001001b | 00100011b = 10101011b
-10001001b | 00100100b = 10101101b
-10001001b | 00100101b = 10101101b
-10001001b | 00100110b = 10101111b
-10001001b | 00100111b = 10101111b
-10001001b | 00101000b = 10101001b
-10001001b | 00101001b = 10101001b
-10001001b | 00101010b = 10101011b
-10001001b | 00101011b = 10101011b
-10001001b | 00101100b = 10101101b
-10001001b | 00101101b = 10101101b
-10001001b | 00101110b = 10101111b
-10001001b | 00101111b = 10101111b
-10001001b | 00110000b = 10111001b
-10001001b | 00110001b = 10111001b
-10001001b | 00110010b = 10111011b
-10001001b | 00110011b = 10111011b
-10001001b | 00110100b = 10111101b
-10001001b | 00110101b = 10111101b
-10001001b | 00110110b = 10111111b
-10001001b | 00110111b = 10111111b
-10001001b | 00111000b = 10111001b
-10001001b | 00111001b = 10111001b
-10001001b | 00111010b = 10111011b
-10001001b | 00111011b = 10111011b
-10001001b | 00111100b = 10111101b
-10001001b | 00111101b = 10111101b
-10001001b | 00111110b = 10111111b
-10001001b | 00111111b = 10111111b
-10001001b | 01000000b = 11001001b
-10001001b | 01000001b = 11001001b
-10001001b | 01000010b = 11001011b
-10001001b | 01000011b = 11001011b
-10001001b | 01000100b = 11001101b
-10001001b | 01000101b = 11001101b
-10001001b | 01000110b = 11001111b
-10001001b | 01000111b = 11001111b
-10001001b | 01001000b = 11001001b
-10001001b | 01001001b = 11001001b
-10001001b | 01001010b = 11001011b
-10001001b | 01001011b = 11001011b
-10001001b | 01001100b = 11001101b
-10001001b | 01001101b = 11001101b
-10001001b | 01001110b = 11001111b
-10001001b | 01001111b = 11001111b
-10001001b | 01010000b = 11011001b
-10001001b | 01010001b = 11011001b
-10001001b | 01010010b = 11011011b
-10001001b | 01010011b = 11011011b
-10001001b | 01010100b = 11011101b
-10001001b | 01010101b = 11011101b
-10001001b | 01010110b = 11011111b
-10001001b | 01010111b = 11011111b
-10001001b | 01011000b = 11011001b
-10001001b | 01011001b = 11011001b
-10001001b | 01011010b = 11011011b
-10001001b | 01011011b = 11011011b
-10001001b | 01011100b = 11011101b
-10001001b | 01011101b = 11011101b
-10001001b | 01011110b = 11011111b
-10001001b | 01011111b = 11011111b
-10001001b | 01100000b = 11101001b
-10001001b | 01100001b = 11101001b
-10001001b | 01100010b = 11101011b
-10001001b | 01100011b = 11101011b
-10001001b | 01100100b = 11101101b
-10001001b | 01100101b = 11101101b
-10001001b | 01100110b = 11101111b
-10001001b | 01100111b = 11101111b
-10001001b | 01101000b = 11101001b
-10001001b | 01101001b = 11101001b
-10001001b | 01101010b = 11101011b
-10001001b | 01101011b = 11101011b
-10001001b | 01101100b = 11101101b
-10001001b | 01101101b = 11101101b
-10001001b | 01101110b = 11101111b
-10001001b | 01101111b = 11101111b
-10001001b | 01110000b = 11111001b
-10001001b | 01110001b = 11111001b
-10001001b | 01110010b = 11111011b
-10001001b | 01110011b = 11111011b
-10001001b | 01110100b = 11111101b
-10001001b | 01110101b = 11111101b
-10001001b | 01110110b = 11111111b
-10001001b | 01110111b = 11111111b
-10001001b | 01111000b = 11111001b
-10001001b | 01111001b = 11111001b
-10001001b | 01111010b = 11111011b
-10001001b | 01111011b = 11111011b
-10001001b | 01111100b = 11111101b
-10001001b | 01111101b = 11111101b
-10001001b | 01111110b = 11111111b
-10001010b | 10000000b = 10001010b
-10001010b | 10000001b = 10001011b
-10001010b | 10000010b = 10001010b
-10001010b | 10000011b = 10001011b
-10001010b | 10000100b = 10001110b
-10001010b | 10000101b = 10001111b
-10001010b | 10000110b = 10001110b
-10001010b | 10000111b = 10001111b
-10001010b | 10001000b = 10001010b
-10001010b | 10001001b = 10001011b
-10001010b | 10001010b = 10001010b
-10001010b | 10001011b = 10001011b
-10001010b | 10001100b = 10001110b
-10001010b | 10001101b = 10001111b
-10001010b | 10001110b = 10001110b
-10001010b | 10001111b = 10001111b
-10001010b | 10010000b = 10011010b
-10001010b | 10010001b = 10011011b
-10001010b | 10010010b = 10011010b
-10001010b | 10010011b = 10011011b
-10001010b | 10010100b = 10011110b
-10001010b | 10010101b = 10011111b
-10001010b | 10010110b = 10011110b
-10001010b | 10010111b = 10011111b
-10001010b | 10011000b = 10011010b
-10001010b | 10011001b = 10011011b
-10001010b | 10011010b = 10011010b
-10001010b | 10011011b = 10011011b
-10001010b | 10011100b = 10011110b
-10001010b | 10011101b = 10011111b
-10001010b | 10011110b = 10011110b
-10001010b | 10011111b = 10011111b
-10001010b | 10100000b = 10101010b
-10001010b | 10100001b = 10101011b
-10001010b | 10100010b = 10101010b
-10001010b | 10100011b = 10101011b
-10001010b | 10100100b = 10101110b
-10001010b | 10100101b = 10101111b
-10001010b | 10100110b = 10101110b
-10001010b | 10100111b = 10101111b
-10001010b | 10101000b = 10101010b
-10001010b | 10101001b = 10101011b
-10001010b | 10101010b = 10101010b
-10001010b | 10101011b = 10101011b
-10001010b | 10101100b = 10101110b
-10001010b | 10101101b = 10101111b
-10001010b | 10101110b = 10101110b
-10001010b | 10101111b = 10101111b
-10001010b | 10110000b = 10111010b
-10001010b | 10110001b = 10111011b
-10001010b | 10110010b = 10111010b
-10001010b | 10110011b = 10111011b
-10001010b | 10110100b = 10111110b
-10001010b | 10110101b = 10111111b
-10001010b | 10110110b = 10111110b
-10001010b | 10110111b = 10111111b
-10001010b | 10111000b = 10111010b
-10001010b | 10111001b = 10111011b
-10001010b | 10111010b = 10111010b
-10001010b | 10111011b = 10111011b
-10001010b | 10111100b = 10111110b
-10001010b | 10111101b = 10111111b
-10001010b | 10111110b = 10111110b
-10001010b | 10111111b = 10111111b
-10001010b | 11000000b = 11001010b
-10001010b | 11000001b = 11001011b
-10001010b | 11000010b = 11001010b
-10001010b | 11000011b = 11001011b
-10001010b | 11000100b = 11001110b
-10001010b | 11000101b = 11001111b
-10001010b | 11000110b = 11001110b
-10001010b | 11000111b = 11001111b
-10001010b | 11001000b = 11001010b
-10001010b | 11001001b = 11001011b
-10001010b | 11001010b = 11001010b
-10001010b | 11001011b = 11001011b
-10001010b | 11001100b = 11001110b
-10001010b | 11001101b = 11001111b
-10001010b | 11001110b = 11001110b
-10001010b | 11001111b = 11001111b
-10001010b | 11010000b = 11011010b
-10001010b | 11010001b = 11011011b
-10001010b | 11010010b = 11011010b
-10001010b | 11010011b = 11011011b
-10001010b | 11010100b = 11011110b
-10001010b | 11010101b = 11011111b
-10001010b | 11010110b = 11011110b
-10001010b | 11010111b = 11011111b
-10001010b | 11011000b = 11011010b
-10001010b | 11011001b = 11011011b
-10001010b | 11011010b = 11011010b
-10001010b | 11011011b = 11011011b
-10001010b | 11011100b = 11011110b
-10001010b | 11011101b = 11011111b
-10001010b | 11011110b = 11011110b
-10001010b | 11011111b = 11011111b
-10001010b | 11100000b = 11101010b
-10001010b | 11100001b = 11101011b
-10001010b | 11100010b = 11101010b
-10001010b | 11100011b = 11101011b
-10001010b | 11100100b = 11101110b
-10001010b | 11100101b = 11101111b
-10001010b | 11100110b = 11101110b
-10001010b | 11100111b = 11101111b
-10001010b | 11101000b = 11101010b
-10001010b | 11101001b = 11101011b
-10001010b | 11101010b = 11101010b
-10001010b | 11101011b = 11101011b
-10001010b | 11101100b = 11101110b
-10001010b | 11101101b = 11101111b
-10001010b | 11101110b = 11101110b
-10001010b | 11101111b = 11101111b
-10001010b | 11110000b = 11111010b
-10001010b | 11110001b = 11111011b
-10001010b | 11110010b = 11111010b
-10001010b | 11110011b = 11111011b
-10001010b | 11110100b = 11111110b
-10001010b | 11110101b = 11111111b
-10001010b | 11110110b = 11111110b
-10001010b | 11110111b = 11111111b
-10001010b | 11111000b = 11111010b
-10001010b | 11111001b = 11111011b
-10001010b | 11111010b = 11111010b
-10001010b | 11111011b = 11111011b
-10001010b | 11111100b = 11111110b
-10001010b | 11111101b = 11111111b
-10001010b | 11111110b = 11111110b
-10001010b | 11111111b = 11111111b
-10001010b | 00000000b = 10001010b
-10001010b | 00000001b = 10001011b
-10001010b | 00000010b = 10001010b
-10001010b | 00000011b = 10001011b
-10001010b | 00000100b = 10001110b
-10001010b | 00000101b = 10001111b
-10001010b | 00000110b = 10001110b
-10001010b | 00000111b = 10001111b
-10001010b | 00001000b = 10001010b
-10001010b | 00001001b = 10001011b
-10001010b | 00001010b = 10001010b
-10001010b | 00001011b = 10001011b
-10001010b | 00001100b = 10001110b
-10001010b | 00001101b = 10001111b
-10001010b | 00001110b = 10001110b
-10001010b | 00001111b = 10001111b
-10001010b | 00010000b = 10011010b
-10001010b | 00010001b = 10011011b
-10001010b | 00010010b = 10011010b
-10001010b | 00010011b = 10011011b
-10001010b | 00010100b = 10011110b
-10001010b | 00010101b = 10011111b
-10001010b | 00010110b = 10011110b
-10001010b | 00010111b = 10011111b
-10001010b | 00011000b = 10011010b
-10001010b | 00011001b = 10011011b
-10001010b | 00011010b = 10011010b
-10001010b | 00011011b = 10011011b
-10001010b | 00011100b = 10011110b
-10001010b | 00011101b = 10011111b
-10001010b | 00011110b = 10011110b
-10001010b | 00011111b = 10011111b
-10001010b | 00100000b = 10101010b
-10001010b | 00100001b = 10101011b
-10001010b | 00100010b = 10101010b
-10001010b | 00100011b = 10101011b
-10001010b | 00100100b = 10101110b
-10001010b | 00100101b = 10101111b
-10001010b | 00100110b = 10101110b
-10001010b | 00100111b = 10101111b
-10001010b | 00101000b = 10101010b
-10001010b | 00101001b = 10101011b
-10001010b | 00101010b = 10101010b
-10001010b | 00101011b = 10101011b
-10001010b | 00101100b = 10101110b
-10001010b | 00101101b = 10101111b
-10001010b | 00101110b = 10101110b
-10001010b | 00101111b = 10101111b
-10001010b | 00110000b = 10111010b
-10001010b | 00110001b = 10111011b
-10001010b | 00110010b = 10111010b
-10001010b | 00110011b = 10111011b
-10001010b | 00110100b = 10111110b
-10001010b | 00110101b = 10111111b
-10001010b | 00110110b = 10111110b
-10001010b | 00110111b = 10111111b
-10001010b | 00111000b = 10111010b
-10001010b | 00111001b = 10111011b
-10001010b | 00111010b = 10111010b
-10001010b | 00111011b = 10111011b
-10001010b | 00111100b = 10111110b
-10001010b | 00111101b = 10111111b
-10001010b | 00111110b = 10111110b
-10001010b | 00111111b = 10111111b
-10001010b | 01000000b = 11001010b
-10001010b | 01000001b = 11001011b
-10001010b | 01000010b = 11001010b
-10001010b | 01000011b = 11001011b
-10001010b | 01000100b = 11001110b
-10001010b | 01000101b = 11001111b
-10001010b | 01000110b = 11001110b
-10001010b | 01000111b = 11001111b
-10001010b | 01001000b = 11001010b
-10001010b | 01001001b = 11001011b
-10001010b | 01001010b = 11001010b
-10001010b | 01001011b = 11001011b
-10001010b | 01001100b = 11001110b
-10001010b | 01001101b = 11001111b
-10001010b | 01001110b = 11001110b
-10001010b | 01001111b = 11001111b
-10001010b | 01010000b = 11011010b
-10001010b | 01010001b = 11011011b
-10001010b | 01010010b = 11011010b
-10001010b | 01010011b = 11011011b
-10001010b | 01010100b = 11011110b
-10001010b | 01010101b = 11011111b
-10001010b | 01010110b = 11011110b
-10001010b | 01010111b = 11011111b
-10001010b | 01011000b = 11011010b
-10001010b | 01011001b = 11011011b
-10001010b | 01011010b = 11011010b
-10001010b | 01011011b = 11011011b
-10001010b | 01011100b = 11011110b
-10001010b | 01011101b = 11011111b
-10001010b | 01011110b = 11011110b
-10001010b | 01011111b = 11011111b
-10001010b | 01100000b = 11101010b
-10001010b | 01100001b = 11101011b
-10001010b | 01100010b = 11101010b
-10001010b | 01100011b = 11101011b
-10001010b | 01100100b = 11101110b
-10001010b | 01100101b = 11101111b
-10001010b | 01100110b = 11101110b
-10001010b | 01100111b = 11101111b
-10001010b | 01101000b = 11101010b
-10001010b | 01101001b = 11101011b
-10001010b | 01101010b = 11101010b
-10001010b | 01101011b = 11101011b
-10001010b | 01101100b = 11101110b
-10001010b | 01101101b = 11101111b
-10001010b | 01101110b = 11101110b
-10001010b | 01101111b = 11101111b
-10001010b | 01110000b = 11111010b
-10001010b | 01110001b = 11111011b
-10001010b | 01110010b = 11111010b
-10001010b | 01110011b = 11111011b
-10001010b | 01110100b = 11111110b
-10001010b | 01110101b = 11111111b
-10001010b | 01110110b = 11111110b
-10001010b | 01110111b = 11111111b
-10001010b | 01111000b = 11111010b
-10001010b | 01111001b = 11111011b
-10001010b | 01111010b = 11111010b
-10001010b | 01111011b = 11111011b
-10001010b | 01111100b = 11111110b
-10001010b | 01111101b = 11111111b
-10001010b | 01111110b = 11111110b
-10001011b | 10000000b = 10001011b
-10001011b | 10000001b = 10001011b
-10001011b | 10000010b = 10001011b
-10001011b | 10000011b = 10001011b
-10001011b | 10000100b = 10001111b
-10001011b | 10000101b = 10001111b
-10001011b | 10000110b = 10001111b
-10001011b | 10000111b = 10001111b
-10001011b | 10001000b = 10001011b
-10001011b | 10001001b = 10001011b
-10001011b | 10001010b = 10001011b
-10001011b | 10001011b = 10001011b
-10001011b | 10001100b = 10001111b
-10001011b | 10001101b = 10001111b
-10001011b | 10001110b = 10001111b
-10001011b | 10001111b = 10001111b
-10001011b | 10010000b = 10011011b
-10001011b | 10010001b = 10011011b
-10001011b | 10010010b = 10011011b
-10001011b | 10010011b = 10011011b
-10001011b | 10010100b = 10011111b
-10001011b | 10010101b = 10011111b
-10001011b | 10010110b = 10011111b
-10001011b | 10010111b = 10011111b
-10001011b | 10011000b = 10011011b
-10001011b | 10011001b = 10011011b
-10001011b | 10011010b = 10011011b
-10001011b | 10011011b = 10011011b
-10001011b | 10011100b = 10011111b
-10001011b | 10011101b = 10011111b
-10001011b | 10011110b = 10011111b
-10001011b | 10011111b = 10011111b
-10001011b | 10100000b = 10101011b
-10001011b | 10100001b = 10101011b
-10001011b | 10100010b = 10101011b
-10001011b | 10100011b = 10101011b
-10001011b | 10100100b = 10101111b
-10001011b | 10100101b = 10101111b
-10001011b | 10100110b = 10101111b
-10001011b | 10100111b = 10101111b
-10001011b | 10101000b = 10101011b
-10001011b | 10101001b = 10101011b
-10001011b | 10101010b = 10101011b
-10001011b | 10101011b = 10101011b
-10001011b | 10101100b = 10101111b
-10001011b | 10101101b = 10101111b
-10001011b | 10101110b = 10101111b
-10001011b | 10101111b = 10101111b
-10001011b | 10110000b = 10111011b
-10001011b | 10110001b = 10111011b
-10001011b | 10110010b = 10111011b
-10001011b | 10110011b = 10111011b
-10001011b | 10110100b = 10111111b
-10001011b | 10110101b = 10111111b
-10001011b | 10110110b = 10111111b
-10001011b | 10110111b = 10111111b
-10001011b | 10111000b = 10111011b
-10001011b | 10111001b = 10111011b
-10001011b | 10111010b = 10111011b
-10001011b | 10111011b = 10111011b
-10001011b | 10111100b = 10111111b
-10001011b | 10111101b = 10111111b
-10001011b | 10111110b = 10111111b
-10001011b | 10111111b = 10111111b
-10001011b | 11000000b = 11001011b
-10001011b | 11000001b = 11001011b
-10001011b | 11000010b = 11001011b
-10001011b | 11000011b = 11001011b
-10001011b | 11000100b = 11001111b
-10001011b | 11000101b = 11001111b
-10001011b | 11000110b = 11001111b
-10001011b | 11000111b = 11001111b
-10001011b | 11001000b = 11001011b
-10001011b | 11001001b = 11001011b
-10001011b | 11001010b = 11001011b
-10001011b | 11001011b = 11001011b
-10001011b | 11001100b = 11001111b
-10001011b | 11001101b = 11001111b
-10001011b | 11001110b = 11001111b
-10001011b | 11001111b = 11001111b
-10001011b | 11010000b = 11011011b
-10001011b | 11010001b = 11011011b
-10001011b | 11010010b = 11011011b
-10001011b | 11010011b = 11011011b
-10001011b | 11010100b = 11011111b
-10001011b | 11010101b = 11011111b
-10001011b | 11010110b = 11011111b
-10001011b | 11010111b = 11011111b
-10001011b | 11011000b = 11011011b
-10001011b | 11011001b = 11011011b
-10001011b | 11011010b = 11011011b
-10001011b | 11011011b = 11011011b
-10001011b | 11011100b = 11011111b
-10001011b | 11011101b = 11011111b
-10001011b | 11011110b = 11011111b
-10001011b | 11011111b = 11011111b
-10001011b | 11100000b = 11101011b
-10001011b | 11100001b = 11101011b
-10001011b | 11100010b = 11101011b
-10001011b | 11100011b = 11101011b
-10001011b | 11100100b = 11101111b
-10001011b | 11100101b = 11101111b
-10001011b | 11100110b = 11101111b
-10001011b | 11100111b = 11101111b
-10001011b | 11101000b = 11101011b
-10001011b | 11101001b = 11101011b
-10001011b | 11101010b = 11101011b
-10001011b | 11101011b = 11101011b
-10001011b | 11101100b = 11101111b
-10001011b | 11101101b = 11101111b
-10001011b | 11101110b = 11101111b
-10001011b | 11101111b = 11101111b
-10001011b | 11110000b = 11111011b
-10001011b | 11110001b = 11111011b
-10001011b | 11110010b = 11111011b
-10001011b | 11110011b = 11111011b
-10001011b | 11110100b = 11111111b
-10001011b | 11110101b = 11111111b
-10001011b | 11110110b = 11111111b
-10001011b | 11110111b = 11111111b
-10001011b | 11111000b = 11111011b
-10001011b | 11111001b = 11111011b
-10001011b | 11111010b = 11111011b
-10001011b | 11111011b = 11111011b
-10001011b | 11111100b = 11111111b
-10001011b | 11111101b = 11111111b
-10001011b | 11111110b = 11111111b
-10001011b | 11111111b = 11111111b
-10001011b | 00000000b = 10001011b
-10001011b | 00000001b = 10001011b
-10001011b | 00000010b = 10001011b
-10001011b | 00000011b = 10001011b
-10001011b | 00000100b = 10001111b
-10001011b | 00000101b = 10001111b
-10001011b | 00000110b = 10001111b
-10001011b | 00000111b = 10001111b
-10001011b | 00001000b = 10001011b
-10001011b | 00001001b = 10001011b
-10001011b | 00001010b = 10001011b
-10001011b | 00001011b = 10001011b
-10001011b | 00001100b = 10001111b
-10001011b | 00001101b = 10001111b
-10001011b | 00001110b = 10001111b
-10001011b | 00001111b = 10001111b
-10001011b | 00010000b = 10011011b
-10001011b | 00010001b = 10011011b
-10001011b | 00010010b = 10011011b
-10001011b | 00010011b = 10011011b
-10001011b | 00010100b = 10011111b
-10001011b | 00010101b = 10011111b
-10001011b | 00010110b = 10011111b
-10001011b | 00010111b = 10011111b
-10001011b | 00011000b = 10011011b
-10001011b | 00011001b = 10011011b
-10001011b | 00011010b = 10011011b
-10001011b | 00011011b = 10011011b
-10001011b | 00011100b = 10011111b
-10001011b | 00011101b = 10011111b
-10001011b | 00011110b = 10011111b
-10001011b | 00011111b = 10011111b
-10001011b | 00100000b = 10101011b
-10001011b | 00100001b = 10101011b
-10001011b | 00100010b = 10101011b
-10001011b | 00100011b = 10101011b
-10001011b | 00100100b = 10101111b
-10001011b | 00100101b = 10101111b
-10001011b | 00100110b = 10101111b
-10001011b | 00100111b = 10101111b
-10001011b | 00101000b = 10101011b
-10001011b | 00101001b = 10101011b
-10001011b | 00101010b = 10101011b
-10001011b | 00101011b = 10101011b
-10001011b | 00101100b = 10101111b
-10001011b | 00101101b = 10101111b
-10001011b | 00101110b = 10101111b
-10001011b | 00101111b = 10101111b
-10001011b | 00110000b = 10111011b
-10001011b | 00110001b = 10111011b
-10001011b | 00110010b = 10111011b
-10001011b | 00110011b = 10111011b
-10001011b | 00110100b = 10111111b
-10001011b | 00110101b = 10111111b
-10001011b | 00110110b = 10111111b
-10001011b | 00110111b = 10111111b
-10001011b | 00111000b = 10111011b
-10001011b | 00111001b = 10111011b
-10001011b | 00111010b = 10111011b
-10001011b | 00111011b = 10111011b
-10001011b | 00111100b = 10111111b
-10001011b | 00111101b = 10111111b
-10001011b | 00111110b = 10111111b
-10001011b | 00111111b = 10111111b
-10001011b | 01000000b = 11001011b
-10001011b | 01000001b = 11001011b
-10001011b | 01000010b = 11001011b
-10001011b | 01000011b = 11001011b
-10001011b | 01000100b = 11001111b
-10001011b | 01000101b = 11001111b
-10001011b | 01000110b = 11001111b
-10001011b | 01000111b = 11001111b
-10001011b | 01001000b = 11001011b
-10001011b | 01001001b = 11001011b
-10001011b | 01001010b = 11001011b
-10001011b | 01001011b = 11001011b
-10001011b | 01001100b = 11001111b
-10001011b | 01001101b = 11001111b
-10001011b | 01001110b = 11001111b
-10001011b | 01001111b = 11001111b
-10001011b | 01010000b = 11011011b
-10001011b | 01010001b = 11011011b
-10001011b | 01010010b = 11011011b
-10001011b | 01010011b = 11011011b
-10001011b | 01010100b = 11011111b
-10001011b | 01010101b = 11011111b
-10001011b | 01010110b = 11011111b
-10001011b | 01010111b = 11011111b
-10001011b | 01011000b = 11011011b
-10001011b | 01011001b = 11011011b
-10001011b | 01011010b = 11011011b
-10001011b | 01011011b = 11011011b
-10001011b | 01011100b = 11011111b
-10001011b | 01011101b = 11011111b
-10001011b | 01011110b = 11011111b
-10001011b | 01011111b = 11011111b
-10001011b | 01100000b = 11101011b
-10001011b | 01100001b = 11101011b
-10001011b | 01100010b = 11101011b
-10001011b | 01100011b = 11101011b
-10001011b | 01100100b = 11101111b
-10001011b | 01100101b = 11101111b
-10001011b | 01100110b = 11101111b
-10001011b | 01100111b = 11101111b
-10001011b | 01101000b = 11101011b
-10001011b | 01101001b = 11101011b
-10001011b | 01101010b = 11101011b
-10001011b | 01101011b = 11101011b
-10001011b | 01101100b = 11101111b
-10001011b | 01101101b = 11101111b
-10001011b | 01101110b = 11101111b
-10001011b | 01101111b = 11101111b
-10001011b | 01110000b = 11111011b
-10001011b | 01110001b = 11111011b
-10001011b | 01110010b = 11111011b
-10001011b | 01110011b = 11111011b
-10001011b | 01110100b = 11111111b
-10001011b | 01110101b = 11111111b
-10001011b | 01110110b = 11111111b
-10001011b | 01110111b = 11111111b
-10001011b | 01111000b = 11111011b
-10001011b | 01111001b = 11111011b
-10001011b | 01111010b = 11111011b
-10001011b | 01111011b = 11111011b
-10001011b | 01111100b = 11111111b
-10001011b | 01111101b = 11111111b
-10001011b | 01111110b = 11111111b
-10001100b | 10000000b = 10001100b
-10001100b | 10000001b = 10001101b
-10001100b | 10000010b = 10001110b
-10001100b | 10000011b = 10001111b
-10001100b | 10000100b = 10001100b
-10001100b | 10000101b = 10001101b
-10001100b | 10000110b = 10001110b
-10001100b | 10000111b = 10001111b
-10001100b | 10001000b = 10001100b
-10001100b | 10001001b = 10001101b
-10001100b | 10001010b = 10001110b
-10001100b | 10001011b = 10001111b
-10001100b | 10001100b = 10001100b
-10001100b | 10001101b = 10001101b
-10001100b | 10001110b = 10001110b
-10001100b | 10001111b = 10001111b
-10001100b | 10010000b = 10011100b
-10001100b | 10010001b = 10011101b
-10001100b | 10010010b = 10011110b
-10001100b | 10010011b = 10011111b
-10001100b | 10010100b = 10011100b
-10001100b | 10010101b = 10011101b
-10001100b | 10010110b = 10011110b
-10001100b | 10010111b = 10011111b
-10001100b | 10011000b = 10011100b
-10001100b | 10011001b = 10011101b
-10001100b | 10011010b = 10011110b
-10001100b | 10011011b = 10011111b
-10001100b | 10011100b = 10011100b
-10001100b | 10011101b = 10011101b
-10001100b | 10011110b = 10011110b
-10001100b | 10011111b = 10011111b
-10001100b | 10100000b = 10101100b
-10001100b | 10100001b = 10101101b
-10001100b | 10100010b = 10101110b
-10001100b | 10100011b = 10101111b
-10001100b | 10100100b = 10101100b
-10001100b | 10100101b = 10101101b
-10001100b | 10100110b = 10101110b
-10001100b | 10100111b = 10101111b
-10001100b | 10101000b = 10101100b
-10001100b | 10101001b = 10101101b
-10001100b | 10101010b = 10101110b
-10001100b | 10101011b = 10101111b
-10001100b | 10101100b = 10101100b
-10001100b | 10101101b = 10101101b
-10001100b | 10101110b = 10101110b
-10001100b | 10101111b = 10101111b
-10001100b | 10110000b = 10111100b
-10001100b | 10110001b = 10111101b
-10001100b | 10110010b = 10111110b
-10001100b | 10110011b = 10111111b
-10001100b | 10110100b = 10111100b
-10001100b | 10110101b = 10111101b
-10001100b | 10110110b = 10111110b
-10001100b | 10110111b = 10111111b
-10001100b | 10111000b = 10111100b
-10001100b | 10111001b = 10111101b
-10001100b | 10111010b = 10111110b
-10001100b | 10111011b = 10111111b
-10001100b | 10111100b = 10111100b
-10001100b | 10111101b = 10111101b
-10001100b | 10111110b = 10111110b
-10001100b | 10111111b = 10111111b
-10001100b | 11000000b = 11001100b
-10001100b | 11000001b = 11001101b
-10001100b | 11000010b = 11001110b
-10001100b | 11000011b = 11001111b
-10001100b | 11000100b = 11001100b
-10001100b | 11000101b = 11001101b
-10001100b | 11000110b = 11001110b
-10001100b | 11000111b = 11001111b
-10001100b | 11001000b = 11001100b
-10001100b | 11001001b = 11001101b
-10001100b | 11001010b = 11001110b
-10001100b | 11001011b = 11001111b
-10001100b | 11001100b = 11001100b
-10001100b | 11001101b = 11001101b
-10001100b | 11001110b = 11001110b
-10001100b | 11001111b = 11001111b
-10001100b | 11010000b = 11011100b
-10001100b | 11010001b = 11011101b
-10001100b | 11010010b = 11011110b
-10001100b | 11010011b = 11011111b
-10001100b | 11010100b = 11011100b
-10001100b | 11010101b = 11011101b
-10001100b | 11010110b = 11011110b
-10001100b | 11010111b = 11011111b
-10001100b | 11011000b = 11011100b
-10001100b | 11011001b = 11011101b
-10001100b | 11011010b = 11011110b
-10001100b | 11011011b = 11011111b
-10001100b | 11011100b = 11011100b
-10001100b | 11011101b = 11011101b
-10001100b | 11011110b = 11011110b
-10001100b | 11011111b = 11011111b
-10001100b | 11100000b = 11101100b
-10001100b | 11100001b = 11101101b
-10001100b | 11100010b = 11101110b
-10001100b | 11100011b = 11101111b
-10001100b | 11100100b = 11101100b
-10001100b | 11100101b = 11101101b
-10001100b | 11100110b = 11101110b
-10001100b | 11100111b = 11101111b
-10001100b | 11101000b = 11101100b
-10001100b | 11101001b = 11101101b
-10001100b | 11101010b = 11101110b
-10001100b | 11101011b = 11101111b
-10001100b | 11101100b = 11101100b
-10001100b | 11101101b = 11101101b
-10001100b | 11101110b = 11101110b
-10001100b | 11101111b = 11101111b
-10001100b | 11110000b = 11111100b
-10001100b | 11110001b = 11111101b
-10001100b | 11110010b = 11111110b
-10001100b | 11110011b = 11111111b
-10001100b | 11110100b = 11111100b
-10001100b | 11110101b = 11111101b
-10001100b | 11110110b = 11111110b
-10001100b | 11110111b = 11111111b
-10001100b | 11111000b = 11111100b
-10001100b | 11111001b = 11111101b
-10001100b | 11111010b = 11111110b
-10001100b | 11111011b = 11111111b
-10001100b | 11111100b = 11111100b
-10001100b | 11111101b = 11111101b
-10001100b | 11111110b = 11111110b
-10001100b | 11111111b = 11111111b
-10001100b | 00000000b = 10001100b
-10001100b | 00000001b = 10001101b
-10001100b | 00000010b = 10001110b
-10001100b | 00000011b = 10001111b
-10001100b | 00000100b = 10001100b
-10001100b | 00000101b = 10001101b
-10001100b | 00000110b = 10001110b
-10001100b | 00000111b = 10001111b
-10001100b | 00001000b = 10001100b
-10001100b | 00001001b = 10001101b
-10001100b | 00001010b = 10001110b
-10001100b | 00001011b = 10001111b
-10001100b | 00001100b = 10001100b
-10001100b | 00001101b = 10001101b
-10001100b | 00001110b = 10001110b
-10001100b | 00001111b = 10001111b
-10001100b | 00010000b = 10011100b
-10001100b | 00010001b = 10011101b
-10001100b | 00010010b = 10011110b
-10001100b | 00010011b = 10011111b
-10001100b | 00010100b = 10011100b
-10001100b | 00010101b = 10011101b
-10001100b | 00010110b = 10011110b
-10001100b | 00010111b = 10011111b
-10001100b | 00011000b = 10011100b
-10001100b | 00011001b = 10011101b
-10001100b | 00011010b = 10011110b
-10001100b | 00011011b = 10011111b
-10001100b | 00011100b = 10011100b
-10001100b | 00011101b = 10011101b
-10001100b | 00011110b = 10011110b
-10001100b | 00011111b = 10011111b
-10001100b | 00100000b = 10101100b
-10001100b | 00100001b = 10101101b
-10001100b | 00100010b = 10101110b
-10001100b | 00100011b = 10101111b
-10001100b | 00100100b = 10101100b
-10001100b | 00100101b = 10101101b
-10001100b | 00100110b = 10101110b
-10001100b | 00100111b = 10101111b
-10001100b | 00101000b = 10101100b
-10001100b | 00101001b = 10101101b
-10001100b | 00101010b = 10101110b
-10001100b | 00101011b = 10101111b
-10001100b | 00101100b = 10101100b
-10001100b | 00101101b = 10101101b
-10001100b | 00101110b = 10101110b
-10001100b | 00101111b = 10101111b
-10001100b | 00110000b = 10111100b
-10001100b | 00110001b = 10111101b
-10001100b | 00110010b = 10111110b
-10001100b | 00110011b = 10111111b
-10001100b | 00110100b = 10111100b
-10001100b | 00110101b = 10111101b
-10001100b | 00110110b = 10111110b
-10001100b | 00110111b = 10111111b
-10001100b | 00111000b = 10111100b
-10001100b | 00111001b = 10111101b
-10001100b | 00111010b = 10111110b
-10001100b | 00111011b = 10111111b
-10001100b | 00111100b = 10111100b
-10001100b | 00111101b = 10111101b
-10001100b | 00111110b = 10111110b
-10001100b | 00111111b = 10111111b
-10001100b | 01000000b = 11001100b
-10001100b | 01000001b = 11001101b
-10001100b | 01000010b = 11001110b
-10001100b | 01000011b = 11001111b
-10001100b | 01000100b = 11001100b
-10001100b | 01000101b = 11001101b
-10001100b | 01000110b = 11001110b
-10001100b | 01000111b = 11001111b
-10001100b | 01001000b = 11001100b
-10001100b | 01001001b = 11001101b
-10001100b | 01001010b = 11001110b
-10001100b | 01001011b = 11001111b
-10001100b | 01001100b = 11001100b
-10001100b | 01001101b = 11001101b
-10001100b | 01001110b = 11001110b
-10001100b | 01001111b = 11001111b
-10001100b | 01010000b = 11011100b
-10001100b | 01010001b = 11011101b
-10001100b | 01010010b = 11011110b
-10001100b | 01010011b = 11011111b
-10001100b | 01010100b = 11011100b
-10001100b | 01010101b = 11011101b
-10001100b | 01010110b = 11011110b
-10001100b | 01010111b = 11011111b
-10001100b | 01011000b = 11011100b
-10001100b | 01011001b = 11011101b
-10001100b | 01011010b = 11011110b
-10001100b | 01011011b = 11011111b
-10001100b | 01011100b = 11011100b
-10001100b | 01011101b = 11011101b
-10001100b | 01011110b = 11011110b
-10001100b | 01011111b = 11011111b
-10001100b | 01100000b = 11101100b
-10001100b | 01100001b = 11101101b
-10001100b | 01100010b = 11101110b
-10001100b | 01100011b = 11101111b
-10001100b | 01100100b = 11101100b
-10001100b | 01100101b = 11101101b
-10001100b | 01100110b = 11101110b
-10001100b | 01100111b = 11101111b
-10001100b | 01101000b = 11101100b
-10001100b | 01101001b = 11101101b
-10001100b | 01101010b = 11101110b
-10001100b | 01101011b = 11101111b
-10001100b | 01101100b = 11101100b
-10001100b | 01101101b = 11101101b
-10001100b | 01101110b = 11101110b
-10001100b | 01101111b = 11101111b
-10001100b | 01110000b = 11111100b
-10001100b | 01110001b = 11111101b
-10001100b | 01110010b = 11111110b
-10001100b | 01110011b = 11111111b
-10001100b | 01110100b = 11111100b
-10001100b | 01110101b = 11111101b
-10001100b | 01110110b = 11111110b
-10001100b | 01110111b = 11111111b
-10001100b | 01111000b = 11111100b
-10001100b | 01111001b = 11111101b
-10001100b | 01111010b = 11111110b
-10001100b | 01111011b = 11111111b
-10001100b | 01111100b = 11111100b
-10001100b | 01111101b = 11111101b
-10001100b | 01111110b = 11111110b
-10001101b | 10000000b = 10001101b
-10001101b | 10000001b = 10001101b
-10001101b | 10000010b = 10001111b
-10001101b | 10000011b = 10001111b
-10001101b | 10000100b = 10001101b
-10001101b | 10000101b = 10001101b
-10001101b | 10000110b = 10001111b
-10001101b | 10000111b = 10001111b
-10001101b | 10001000b = 10001101b
-10001101b | 10001001b = 10001101b
-10001101b | 10001010b = 10001111b
-10001101b | 10001011b = 10001111b
-10001101b | 10001100b = 10001101b
-10001101b | 10001101b = 10001101b
-10001101b | 10001110b = 10001111b
-10001101b | 10001111b = 10001111b
-10001101b | 10010000b = 10011101b
-10001101b | 10010001b = 10011101b
-10001101b | 10010010b = 10011111b
-10001101b | 10010011b = 10011111b
-10001101b | 10010100b = 10011101b
-10001101b | 10010101b = 10011101b
-10001101b | 10010110b = 10011111b
-10001101b | 10010111b = 10011111b
-10001101b | 10011000b = 10011101b
-10001101b | 10011001b = 10011101b
-10001101b | 10011010b = 10011111b
-10001101b | 10011011b = 10011111b
-10001101b | 10011100b = 10011101b
-10001101b | 10011101b = 10011101b
-10001101b | 10011110b = 10011111b
-10001101b | 10011111b = 10011111b
-10001101b | 10100000b = 10101101b
-10001101b | 10100001b = 10101101b
-10001101b | 10100010b = 10101111b
-10001101b | 10100011b = 10101111b
-10001101b | 10100100b = 10101101b
-10001101b | 10100101b = 10101101b
-10001101b | 10100110b = 10101111b
-10001101b | 10100111b = 10101111b
-10001101b | 10101000b = 10101101b
-10001101b | 10101001b = 10101101b
-10001101b | 10101010b = 10101111b
-10001101b | 10101011b = 10101111b
-10001101b | 10101100b = 10101101b
-10001101b | 10101101b = 10101101b
-10001101b | 10101110b = 10101111b
-10001101b | 10101111b = 10101111b
-10001101b | 10110000b = 10111101b
-10001101b | 10110001b = 10111101b
-10001101b | 10110010b = 10111111b
-10001101b | 10110011b = 10111111b
-10001101b | 10110100b = 10111101b
-10001101b | 10110101b = 10111101b
-10001101b | 10110110b = 10111111b
-10001101b | 10110111b = 10111111b
-10001101b | 10111000b = 10111101b
-10001101b | 10111001b = 10111101b
-10001101b | 10111010b = 10111111b
-10001101b | 10111011b = 10111111b
-10001101b | 10111100b = 10111101b
-10001101b | 10111101b = 10111101b
-10001101b | 10111110b = 10111111b
-10001101b | 10111111b = 10111111b
-10001101b | 11000000b = 11001101b
-10001101b | 11000001b = 11001101b
-10001101b | 11000010b = 11001111b
-10001101b | 11000011b = 11001111b
-10001101b | 11000100b = 11001101b
-10001101b | 11000101b = 11001101b
-10001101b | 11000110b = 11001111b
-10001101b | 11000111b = 11001111b
-10001101b | 11001000b = 11001101b
-10001101b | 11001001b = 11001101b
-10001101b | 11001010b = 11001111b
-10001101b | 11001011b = 11001111b
-10001101b | 11001100b = 11001101b
-10001101b | 11001101b = 11001101b
-10001101b | 11001110b = 11001111b
-10001101b | 11001111b = 11001111b
-10001101b | 11010000b = 11011101b
-10001101b | 11010001b = 11011101b
-10001101b | 11010010b = 11011111b
-10001101b | 11010011b = 11011111b
-10001101b | 11010100b = 11011101b
-10001101b | 11010101b = 11011101b
-10001101b | 11010110b = 11011111b
-10001101b | 11010111b = 11011111b
-10001101b | 11011000b = 11011101b
-10001101b | 11011001b = 11011101b
-10001101b | 11011010b = 11011111b
-10001101b | 11011011b = 11011111b
-10001101b | 11011100b = 11011101b
-10001101b | 11011101b = 11011101b
-10001101b | 11011110b = 11011111b
-10001101b | 11011111b = 11011111b
-10001101b | 11100000b = 11101101b
-10001101b | 11100001b = 11101101b
-10001101b | 11100010b = 11101111b
-10001101b | 11100011b = 11101111b
-10001101b | 11100100b = 11101101b
-10001101b | 11100101b = 11101101b
-10001101b | 11100110b = 11101111b
-10001101b | 11100111b = 11101111b
-10001101b | 11101000b = 11101101b
-10001101b | 11101001b = 11101101b
-10001101b | 11101010b = 11101111b
-10001101b | 11101011b = 11101111b
-10001101b | 11101100b = 11101101b
-10001101b | 11101101b = 11101101b
-10001101b | 11101110b = 11101111b
-10001101b | 11101111b = 11101111b
-10001101b | 11110000b = 11111101b
-10001101b | 11110001b = 11111101b
-10001101b | 11110010b = 11111111b
-10001101b | 11110011b = 11111111b
-10001101b | 11110100b = 11111101b
-10001101b | 11110101b = 11111101b
-10001101b | 11110110b = 11111111b
-10001101b | 11110111b = 11111111b
-10001101b | 11111000b = 11111101b
-10001101b | 11111001b = 11111101b
-10001101b | 11111010b = 11111111b
-10001101b | 11111011b = 11111111b
-10001101b | 11111100b = 11111101b
-10001101b | 11111101b = 11111101b
-10001101b | 11111110b = 11111111b
-10001101b | 11111111b = 11111111b
-10001101b | 00000000b = 10001101b
-10001101b | 00000001b = 10001101b
-10001101b | 00000010b = 10001111b
-10001101b | 00000011b = 10001111b
-10001101b | 00000100b = 10001101b
-10001101b | 00000101b = 10001101b
-10001101b | 00000110b = 10001111b
-10001101b | 00000111b = 10001111b
-10001101b | 00001000b = 10001101b
-10001101b | 00001001b = 10001101b
-10001101b | 00001010b = 10001111b
-10001101b | 00001011b = 10001111b
-10001101b | 00001100b = 10001101b
-10001101b | 00001101b = 10001101b
-10001101b | 00001110b = 10001111b
-10001101b | 00001111b = 10001111b
-10001101b | 00010000b = 10011101b
-10001101b | 00010001b = 10011101b
-10001101b | 00010010b = 10011111b
-10001101b | 00010011b = 10011111b
-10001101b | 00010100b = 10011101b
-10001101b | 00010101b = 10011101b
-10001101b | 00010110b = 10011111b
-10001101b | 00010111b = 10011111b
-10001101b | 00011000b = 10011101b
-10001101b | 00011001b = 10011101b
-10001101b | 00011010b = 10011111b
-10001101b | 00011011b = 10011111b
-10001101b | 00011100b = 10011101b
-10001101b | 00011101b = 10011101b
-10001101b | 00011110b = 10011111b
-10001101b | 00011111b = 10011111b
-10001101b | 00100000b = 10101101b
-10001101b | 00100001b = 10101101b
-10001101b | 00100010b = 10101111b
-10001101b | 00100011b = 10101111b
-10001101b | 00100100b = 10101101b
-10001101b | 00100101b = 10101101b
-10001101b | 00100110b = 10101111b
-10001101b | 00100111b = 10101111b
-10001101b | 00101000b = 10101101b
-10001101b | 00101001b = 10101101b
-10001101b | 00101010b = 10101111b
-10001101b | 00101011b = 10101111b
-10001101b | 00101100b = 10101101b
-10001101b | 00101101b = 10101101b
-10001101b | 00101110b = 10101111b
-10001101b | 00101111b = 10101111b
-10001101b | 00110000b = 10111101b
-10001101b | 00110001b = 10111101b
-10001101b | 00110010b = 10111111b
-10001101b | 00110011b = 10111111b
-10001101b | 00110100b = 10111101b
-10001101b | 00110101b = 10111101b
-10001101b | 00110110b = 10111111b
-10001101b | 00110111b = 10111111b
-10001101b | 00111000b = 10111101b
-10001101b | 00111001b = 10111101b
-10001101b | 00111010b = 10111111b
-10001101b | 00111011b = 10111111b
-10001101b | 00111100b = 10111101b
-10001101b | 00111101b = 10111101b
-10001101b | 00111110b = 10111111b
-10001101b | 00111111b = 10111111b
-10001101b | 01000000b = 11001101b
-10001101b | 01000001b = 11001101b
-10001101b | 01000010b = 11001111b
-10001101b | 01000011b = 11001111b
-10001101b | 01000100b = 11001101b
-10001101b | 01000101b = 11001101b
-10001101b | 01000110b = 11001111b
-10001101b | 01000111b = 11001111b
-10001101b | 01001000b = 11001101b
-10001101b | 01001001b = 11001101b
-10001101b | 01001010b = 11001111b
-10001101b | 01001011b = 11001111b
-10001101b | 01001100b = 11001101b
-10001101b | 01001101b = 11001101b
-10001101b | 01001110b = 11001111b
-10001101b | 01001111b = 11001111b
-10001101b | 01010000b = 11011101b
-10001101b | 01010001b = 11011101b
-10001101b | 01010010b = 11011111b
-10001101b | 01010011b = 11011111b
-10001101b | 01010100b = 11011101b
-10001101b | 01010101b = 11011101b
-10001101b | 01010110b = 11011111b
-10001101b | 01010111b = 11011111b
-10001101b | 01011000b = 11011101b
-10001101b | 01011001b = 11011101b
-10001101b | 01011010b = 11011111b
-10001101b | 01011011b = 11011111b
-10001101b | 01011100b = 11011101b
-10001101b | 01011101b = 11011101b
-10001101b | 01011110b = 11011111b
-10001101b | 01011111b = 11011111b
-10001101b | 01100000b = 11101101b
-10001101b | 01100001b = 11101101b
-10001101b | 01100010b = 11101111b
-10001101b | 01100011b = 11101111b
-10001101b | 01100100b = 11101101b
-10001101b | 01100101b = 11101101b
-10001101b | 01100110b = 11101111b
-10001101b | 01100111b = 11101111b
-10001101b | 01101000b = 11101101b
-10001101b | 01101001b = 11101101b
-10001101b | 01101010b = 11101111b
-10001101b | 01101011b = 11101111b
-10001101b | 01101100b = 11101101b
-10001101b | 01101101b = 11101101b
-10001101b | 01101110b = 11101111b
-10001101b | 01101111b = 11101111b
-10001101b | 01110000b = 11111101b
-10001101b | 01110001b = 11111101b
-10001101b | 01110010b = 11111111b
-10001101b | 01110011b = 11111111b
-10001101b | 01110100b = 11111101b
-10001101b | 01110101b = 11111101b
-10001101b | 01110110b = 11111111b
-10001101b | 01110111b = 11111111b
-10001101b | 01111000b = 11111101b
-10001101b | 01111001b = 11111101b
-10001101b | 01111010b = 11111111b
-10001101b | 01111011b = 11111111b
-10001101b | 01111100b = 11111101b
-10001101b | 01111101b = 11111101b
-10001101b | 01111110b = 11111111b
-10001110b | 10000000b = 10001110b
-10001110b | 10000001b = 10001111b
-10001110b | 10000010b = 10001110b
-10001110b | 10000011b = 10001111b
-10001110b | 10000100b = 10001110b
-10001110b | 10000101b = 10001111b
-10001110b | 10000110b = 10001110b
-10001110b | 10000111b = 10001111b
-10001110b | 10001000b = 10001110b
-10001110b | 10001001b = 10001111b
-10001110b | 10001010b = 10001110b
-10001110b | 10001011b = 10001111b
-10001110b | 10001100b = 10001110b
-10001110b | 10001101b = 10001111b
-10001110b | 10001110b = 10001110b
-10001110b | 10001111b = 10001111b
-10001110b | 10010000b = 10011110b
-10001110b | 10010001b = 10011111b
-10001110b | 10010010b = 10011110b
-10001110b | 10010011b = 10011111b
-10001110b | 10010100b = 10011110b
-10001110b | 10010101b = 10011111b
-10001110b | 10010110b = 10011110b
-10001110b | 10010111b = 10011111b
-10001110b | 10011000b = 10011110b
-10001110b | 10011001b = 10011111b
-10001110b | 10011010b = 10011110b
-10001110b | 10011011b = 10011111b
-10001110b | 10011100b = 10011110b
-10001110b | 10011101b = 10011111b
-10001110b | 10011110b = 10011110b
-10001110b | 10011111b = 10011111b
-10001110b | 10100000b = 10101110b
-10001110b | 10100001b = 10101111b
-10001110b | 10100010b = 10101110b
-10001110b | 10100011b = 10101111b
-10001110b | 10100100b = 10101110b
-10001110b | 10100101b = 10101111b
-10001110b | 10100110b = 10101110b
-10001110b | 10100111b = 10101111b
-10001110b | 10101000b = 10101110b
-10001110b | 10101001b = 10101111b
-10001110b | 10101010b = 10101110b
-10001110b | 10101011b = 10101111b
-10001110b | 10101100b = 10101110b
-10001110b | 10101101b = 10101111b
-10001110b | 10101110b = 10101110b
-10001110b | 10101111b = 10101111b
-10001110b | 10110000b = 10111110b
-10001110b | 10110001b = 10111111b
-10001110b | 10110010b = 10111110b
-10001110b | 10110011b = 10111111b
-10001110b | 10110100b = 10111110b
-10001110b | 10110101b = 10111111b
-10001110b | 10110110b = 10111110b
-10001110b | 10110111b = 10111111b
-10001110b | 10111000b = 10111110b
-10001110b | 10111001b = 10111111b
-10001110b | 10111010b = 10111110b
-10001110b | 10111011b = 10111111b
-10001110b | 10111100b = 10111110b
-10001110b | 10111101b = 10111111b
-10001110b | 10111110b = 10111110b
-10001110b | 10111111b = 10111111b
-10001110b | 11000000b = 11001110b
-10001110b | 11000001b = 11001111b
-10001110b | 11000010b = 11001110b
-10001110b | 11000011b = 11001111b
-10001110b | 11000100b = 11001110b
-10001110b | 11000101b = 11001111b
-10001110b | 11000110b = 11001110b
-10001110b | 11000111b = 11001111b
-10001110b | 11001000b = 11001110b
-10001110b | 11001001b = 11001111b
-10001110b | 11001010b = 11001110b
-10001110b | 11001011b = 11001111b
-10001110b | 11001100b = 11001110b
-10001110b | 11001101b = 11001111b
-10001110b | 11001110b = 11001110b
-10001110b | 11001111b = 11001111b
-10001110b | 11010000b = 11011110b
-10001110b | 11010001b = 11011111b
-10001110b | 11010010b = 11011110b
-10001110b | 11010011b = 11011111b
-10001110b | 11010100b = 11011110b
-10001110b | 11010101b = 11011111b
-10001110b | 11010110b = 11011110b
-10001110b | 11010111b = 11011111b
-10001110b | 11011000b = 11011110b
-10001110b | 11011001b = 11011111b
-10001110b | 11011010b = 11011110b
-10001110b | 11011011b = 11011111b
-10001110b | 11011100b = 11011110b
-10001110b | 11011101b = 11011111b
-10001110b | 11011110b = 11011110b
-10001110b | 11011111b = 11011111b
-10001110b | 11100000b = 11101110b
-10001110b | 11100001b = 11101111b
-10001110b | 11100010b = 11101110b
-10001110b | 11100011b = 11101111b
-10001110b | 11100100b = 11101110b
-10001110b | 11100101b = 11101111b
-10001110b | 11100110b = 11101110b
-10001110b | 11100111b = 11101111b
-10001110b | 11101000b = 11101110b
-10001110b | 11101001b = 11101111b
-10001110b | 11101010b = 11101110b
-10001110b | 11101011b = 11101111b
-10001110b | 11101100b = 11101110b
-10001110b | 11101101b = 11101111b
-10001110b | 11101110b = 11101110b
-10001110b | 11101111b = 11101111b
-10001110b | 11110000b = 11111110b
-10001110b | 11110001b = 11111111b
-10001110b | 11110010b = 11111110b
-10001110b | 11110011b = 11111111b
-10001110b | 11110100b = 11111110b
-10001110b | 11110101b = 11111111b
-10001110b | 11110110b = 11111110b
-10001110b | 11110111b = 11111111b
-10001110b | 11111000b = 11111110b
-10001110b | 11111001b = 11111111b
-10001110b | 11111010b = 11111110b
-10001110b | 11111011b = 11111111b
-10001110b | 11111100b = 11111110b
-10001110b | 11111101b = 11111111b
-10001110b | 11111110b = 11111110b
-10001110b | 11111111b = 11111111b
-10001110b | 00000000b = 10001110b
-10001110b | 00000001b = 10001111b
-10001110b | 00000010b = 10001110b
-10001110b | 00000011b = 10001111b
-10001110b | 00000100b = 10001110b
-10001110b | 00000101b = 10001111b
-10001110b | 00000110b = 10001110b
-10001110b | 00000111b = 10001111b
-10001110b | 00001000b = 10001110b
-10001110b | 00001001b = 10001111b
-10001110b | 00001010b = 10001110b
-10001110b | 00001011b = 10001111b
-10001110b | 00001100b = 10001110b
-10001110b | 00001101b = 10001111b
-10001110b | 00001110b = 10001110b
-10001110b | 00001111b = 10001111b
-10001110b | 00010000b = 10011110b
-10001110b | 00010001b = 10011111b
-10001110b | 00010010b = 10011110b
-10001110b | 00010011b = 10011111b
-10001110b | 00010100b = 10011110b
-10001110b | 00010101b = 10011111b
-10001110b | 00010110b = 10011110b
-10001110b | 00010111b = 10011111b
-10001110b | 00011000b = 10011110b
-10001110b | 00011001b = 10011111b
-10001110b | 00011010b = 10011110b
-10001110b | 00011011b = 10011111b
-10001110b | 00011100b = 10011110b
-10001110b | 00011101b = 10011111b
-10001110b | 00011110b = 10011110b
-10001110b | 00011111b = 10011111b
-10001110b | 00100000b = 10101110b
-10001110b | 00100001b = 10101111b
-10001110b | 00100010b = 10101110b
-10001110b | 00100011b = 10101111b
-10001110b | 00100100b = 10101110b
-10001110b | 00100101b = 10101111b
-10001110b | 00100110b = 10101110b
-10001110b | 00100111b = 10101111b
-10001110b | 00101000b = 10101110b
-10001110b | 00101001b = 10101111b
-10001110b | 00101010b = 10101110b
-10001110b | 00101011b = 10101111b
-10001110b | 00101100b = 10101110b
-10001110b | 00101101b = 10101111b
-10001110b | 00101110b = 10101110b
-10001110b | 00101111b = 10101111b
-10001110b | 00110000b = 10111110b
-10001110b | 00110001b = 10111111b
-10001110b | 00110010b = 10111110b
-10001110b | 00110011b = 10111111b
-10001110b | 00110100b = 10111110b
-10001110b | 00110101b = 10111111b
-10001110b | 00110110b = 10111110b
-10001110b | 00110111b = 10111111b
-10001110b | 00111000b = 10111110b
-10001110b | 00111001b = 10111111b
-10001110b | 00111010b = 10111110b
-10001110b | 00111011b = 10111111b
-10001110b | 00111100b = 10111110b
-10001110b | 00111101b = 10111111b
-10001110b | 00111110b = 10111110b
-10001110b | 00111111b = 10111111b
-10001110b | 01000000b = 11001110b
-10001110b | 01000001b = 11001111b
-10001110b | 01000010b = 11001110b
-10001110b | 01000011b = 11001111b
-10001110b | 01000100b = 11001110b
-10001110b | 01000101b = 11001111b
-10001110b | 01000110b = 11001110b
-10001110b | 01000111b = 11001111b
-10001110b | 01001000b = 11001110b
-10001110b | 01001001b = 11001111b
-10001110b | 01001010b = 11001110b
-10001110b | 01001011b = 11001111b
-10001110b | 01001100b = 11001110b
-10001110b | 01001101b = 11001111b
-10001110b | 01001110b = 11001110b
-10001110b | 01001111b = 11001111b
-10001110b | 01010000b = 11011110b
-10001110b | 01010001b = 11011111b
-10001110b | 01010010b = 11011110b
-10001110b | 01010011b = 11011111b
-10001110b | 01010100b = 11011110b
-10001110b | 01010101b = 11011111b
-10001110b | 01010110b = 11011110b
-10001110b | 01010111b = 11011111b
-10001110b | 01011000b = 11011110b
-10001110b | 01011001b = 11011111b
-10001110b | 01011010b = 11011110b
-10001110b | 01011011b = 11011111b
-10001110b | 01011100b = 11011110b
-10001110b | 01011101b = 11011111b
-10001110b | 01011110b = 11011110b
-10001110b | 01011111b = 11011111b
-10001110b | 01100000b = 11101110b
-10001110b | 01100001b = 11101111b
-10001110b | 01100010b = 11101110b
-10001110b | 01100011b = 11101111b
-10001110b | 01100100b = 11101110b
-10001110b | 01100101b = 11101111b
-10001110b | 01100110b = 11101110b
-10001110b | 01100111b = 11101111b
-10001110b | 01101000b = 11101110b
-10001110b | 01101001b = 11101111b
-10001110b | 01101010b = 11101110b
-10001110b | 01101011b = 11101111b
-10001110b | 01101100b = 11101110b
-10001110b | 01101101b = 11101111b
-10001110b | 01101110b = 11101110b
-10001110b | 01101111b = 11101111b
-10001110b | 01110000b = 11111110b
-10001110b | 01110001b = 11111111b
-10001110b | 01110010b = 11111110b
-10001110b | 01110011b = 11111111b
-10001110b | 01110100b = 11111110b
-10001110b | 01110101b = 11111111b
-10001110b | 01110110b = 11111110b
-10001110b | 01110111b = 11111111b
-10001110b | 01111000b = 11111110b
-10001110b | 01111001b = 11111111b
-10001110b | 01111010b = 11111110b
-10001110b | 01111011b = 11111111b
-10001110b | 01111100b = 11111110b
-10001110b | 01111101b = 11111111b
-10001110b | 01111110b = 11111110b
-10001111b | 10000000b = 10001111b
-10001111b | 10000001b = 10001111b
-10001111b | 10000010b = 10001111b
-10001111b | 10000011b = 10001111b
-10001111b | 10000100b = 10001111b
-10001111b | 10000101b = 10001111b
-10001111b | 10000110b = 10001111b
-10001111b | 10000111b = 10001111b
-10001111b | 10001000b = 10001111b
-10001111b | 10001001b = 10001111b
-10001111b | 10001010b = 10001111b
-10001111b | 10001011b = 10001111b
-10001111b | 10001100b = 10001111b
-10001111b | 10001101b = 10001111b
-10001111b | 10001110b = 10001111b
-10001111b | 10001111b = 10001111b
-10001111b | 10010000b = 10011111b
-10001111b | 10010001b = 10011111b
-10001111b | 10010010b = 10011111b
-10001111b | 10010011b = 10011111b
-10001111b | 10010100b = 10011111b
-10001111b | 10010101b = 10011111b
-10001111b | 10010110b = 10011111b
-10001111b | 10010111b = 10011111b
-10001111b | 10011000b = 10011111b
-10001111b | 10011001b = 10011111b
-10001111b | 10011010b = 10011111b
-10001111b | 10011011b = 10011111b
-10001111b | 10011100b = 10011111b
-10001111b | 10011101b = 10011111b
-10001111b | 10011110b = 10011111b
-10001111b | 10011111b = 10011111b
-10001111b | 10100000b = 10101111b
-10001111b | 10100001b = 10101111b
-10001111b | 10100010b = 10101111b
-10001111b | 10100011b = 10101111b
-10001111b | 10100100b = 10101111b
-10001111b | 10100101b = 10101111b
-10001111b | 10100110b = 10101111b
-10001111b | 10100111b = 10101111b
-10001111b | 10101000b = 10101111b
-10001111b | 10101001b = 10101111b
-10001111b | 10101010b = 10101111b
-10001111b | 10101011b = 10101111b
-10001111b | 10101100b = 10101111b
-10001111b | 10101101b = 10101111b
-10001111b | 10101110b = 10101111b
-10001111b | 10101111b = 10101111b
-10001111b | 10110000b = 10111111b
-10001111b | 10110001b = 10111111b
-10001111b | 10110010b = 10111111b
-10001111b | 10110011b = 10111111b
-10001111b | 10110100b = 10111111b
-10001111b | 10110101b = 10111111b
-10001111b | 10110110b = 10111111b
-10001111b | 10110111b = 10111111b
-10001111b | 10111000b = 10111111b
-10001111b | 10111001b = 10111111b
-10001111b | 10111010b = 10111111b
-10001111b | 10111011b = 10111111b
-10001111b | 10111100b = 10111111b
-10001111b | 10111101b = 10111111b
-10001111b | 10111110b = 10111111b
-10001111b | 10111111b = 10111111b
-10001111b | 11000000b = 11001111b
-10001111b | 11000001b = 11001111b
-10001111b | 11000010b = 11001111b
-10001111b | 11000011b = 11001111b
-10001111b | 11000100b = 11001111b
-10001111b | 11000101b = 11001111b
-10001111b | 11000110b = 11001111b
-10001111b | 11000111b = 11001111b
-10001111b | 11001000b = 11001111b
-10001111b | 11001001b = 11001111b
-10001111b | 11001010b = 11001111b
-10001111b | 11001011b = 11001111b
-10001111b | 11001100b = 11001111b
-10001111b | 11001101b = 11001111b
-10001111b | 11001110b = 11001111b
-10001111b | 11001111b = 11001111b
-10001111b | 11010000b = 11011111b
-10001111b | 11010001b = 11011111b
-10001111b | 11010010b = 11011111b
-10001111b | 11010011b = 11011111b
-10001111b | 11010100b = 11011111b
-10001111b | 11010101b = 11011111b
-10001111b | 11010110b = 11011111b
-10001111b | 11010111b = 11011111b
-10001111b | 11011000b = 11011111b
-10001111b | 11011001b = 11011111b
-10001111b | 11011010b = 11011111b
-10001111b | 11011011b = 11011111b
-10001111b | 11011100b = 11011111b
-10001111b | 11011101b = 11011111b
-10001111b | 11011110b = 11011111b
-10001111b | 11011111b = 11011111b
-10001111b | 11100000b = 11101111b
-10001111b | 11100001b = 11101111b
-10001111b | 11100010b = 11101111b
-10001111b | 11100011b = 11101111b
-10001111b | 11100100b = 11101111b
-10001111b | 11100101b = 11101111b
-10001111b | 11100110b = 11101111b
-10001111b | 11100111b = 11101111b
-10001111b | 11101000b = 11101111b
-10001111b | 11101001b = 11101111b
-10001111b | 11101010b = 11101111b
-10001111b | 11101011b = 11101111b
-10001111b | 11101100b = 11101111b
-10001111b | 11101101b = 11101111b
-10001111b | 11101110b = 11101111b
-10001111b | 11101111b = 11101111b
-10001111b | 11110000b = 11111111b
-10001111b | 11110001b = 11111111b
-10001111b | 11110010b = 11111111b
-10001111b | 11110011b = 11111111b
-10001111b | 11110100b = 11111111b
-10001111b | 11110101b = 11111111b
-10001111b | 11110110b = 11111111b
-10001111b | 11110111b = 11111111b
-10001111b | 11111000b = 11111111b
-10001111b | 11111001b = 11111111b
-10001111b | 11111010b = 11111111b
-10001111b | 11111011b = 11111111b
-10001111b | 11111100b = 11111111b
-10001111b | 11111101b = 11111111b
-10001111b | 11111110b = 11111111b
-10001111b | 11111111b = 11111111b
-10001111b | 00000000b = 10001111b
-10001111b | 00000001b = 10001111b
-10001111b | 00000010b = 10001111b
-10001111b | 00000011b = 10001111b
-10001111b | 00000100b = 10001111b
-10001111b | 00000101b = 10001111b
-10001111b | 00000110b = 10001111b
-10001111b | 00000111b = 10001111b
-10001111b | 00001000b = 10001111b
-10001111b | 00001001b = 10001111b
-10001111b | 00001010b = 10001111b
-10001111b | 00001011b = 10001111b
-10001111b | 00001100b = 10001111b
-10001111b | 00001101b = 10001111b
-10001111b | 00001110b = 10001111b
-10001111b | 00001111b = 10001111b
-10001111b | 00010000b = 10011111b
-10001111b | 00010001b = 10011111b
-10001111b | 00010010b = 10011111b
-10001111b | 00010011b = 10011111b
-10001111b | 00010100b = 10011111b
-10001111b | 00010101b = 10011111b
-10001111b | 00010110b = 10011111b
-10001111b | 00010111b = 10011111b
-10001111b | 00011000b = 10011111b
-10001111b | 00011001b = 10011111b
-10001111b | 00011010b = 10011111b
-10001111b | 00011011b = 10011111b
-10001111b | 00011100b = 10011111b
-10001111b | 00011101b = 10011111b
-10001111b | 00011110b = 10011111b
-10001111b | 00011111b = 10011111b
-10001111b | 00100000b = 10101111b
-10001111b | 00100001b = 10101111b
-10001111b | 00100010b = 10101111b
-10001111b | 00100011b = 10101111b
-10001111b | 00100100b = 10101111b
-10001111b | 00100101b = 10101111b
-10001111b | 00100110b = 10101111b
-10001111b | 00100111b = 10101111b
-10001111b | 00101000b = 10101111b
-10001111b | 00101001b = 10101111b
-10001111b | 00101010b = 10101111b
-10001111b | 00101011b = 10101111b
-10001111b | 00101100b = 10101111b
-10001111b | 00101101b = 10101111b
-10001111b | 00101110b = 10101111b
-10001111b | 00101111b = 10101111b
-10001111b | 00110000b = 10111111b
-10001111b | 00110001b = 10111111b
-10001111b | 00110010b = 10111111b
-10001111b | 00110011b = 10111111b
-10001111b | 00110100b = 10111111b
-10001111b | 00110101b = 10111111b
-10001111b | 00110110b = 10111111b
-10001111b | 00110111b = 10111111b
-10001111b | 00111000b = 10111111b
-10001111b | 00111001b = 10111111b
-10001111b | 00111010b = 10111111b
-10001111b | 00111011b = 10111111b
-10001111b | 00111100b = 10111111b
-10001111b | 00111101b = 10111111b
-10001111b | 00111110b = 10111111b
-10001111b | 00111111b = 10111111b
-10001111b | 01000000b = 11001111b
-10001111b | 01000001b = 11001111b
-10001111b | 01000010b = 11001111b
-10001111b | 01000011b = 11001111b
-10001111b | 01000100b = 11001111b
-10001111b | 01000101b = 11001111b
-10001111b | 01000110b = 11001111b
-10001111b | 01000111b = 11001111b
-10001111b | 01001000b = 11001111b
-10001111b | 01001001b = 11001111b
-10001111b | 01001010b = 11001111b
-10001111b | 01001011b = 11001111b
-10001111b | 01001100b = 11001111b
-10001111b | 01001101b = 11001111b
-10001111b | 01001110b = 11001111b
-10001111b | 01001111b = 11001111b
-10001111b | 01010000b = 11011111b
-10001111b | 01010001b = 11011111b
-10001111b | 01010010b = 11011111b
-10001111b | 01010011b = 11011111b
-10001111b | 01010100b = 11011111b
-10001111b | 01010101b = 11011111b
-10001111b | 01010110b = 11011111b
-10001111b | 01010111b = 11011111b
-10001111b | 01011000b = 11011111b
-10001111b | 01011001b = 11011111b
-10001111b | 01011010b = 11011111b
-10001111b | 01011011b = 11011111b
-10001111b | 01011100b = 11011111b
-10001111b | 01011101b = 11011111b
-10001111b | 01011110b = 11011111b
-10001111b | 01011111b = 11011111b
-10001111b | 01100000b = 11101111b
-10001111b | 01100001b = 11101111b
-10001111b | 01100010b = 11101111b
-10001111b | 01100011b = 11101111b
-10001111b | 01100100b = 11101111b
-10001111b | 01100101b = 11101111b
-10001111b | 01100110b = 11101111b
-10001111b | 01100111b = 11101111b
-10001111b | 01101000b = 11101111b
-10001111b | 01101001b = 11101111b
-10001111b | 01101010b = 11101111b
-10001111b | 01101011b = 11101111b
-10001111b | 01101100b = 11101111b
-10001111b | 01101101b = 11101111b
-10001111b | 01101110b = 11101111b
-10001111b | 01101111b = 11101111b
-10001111b | 01110000b = 11111111b
-10001111b | 01110001b = 11111111b
-10001111b | 01110010b = 11111111b
-10001111b | 01110011b = 11111111b
-10001111b | 01110100b = 11111111b
-10001111b | 01110101b = 11111111b
-10001111b | 01110110b = 11111111b
-10001111b | 01110111b = 11111111b
-10001111b | 01111000b = 11111111b
-10001111b | 01111001b = 11111111b
-10001111b | 01111010b = 11111111b
-10001111b | 01111011b = 11111111b
-10001111b | 01111100b = 11111111b
-10001111b | 01111101b = 11111111b
-10001111b | 01111110b = 11111111b
-10010000b | 10000000b = 10010000b
-10010000b | 10000001b = 10010001b
-10010000b | 10000010b = 10010010b
-10010000b | 10000011b = 10010011b
-10010000b | 10000100b = 10010100b
-10010000b | 10000101b = 10010101b
-10010000b | 10000110b = 10010110b
-10010000b | 10000111b = 10010111b
-10010000b | 10001000b = 10011000b
-10010000b | 10001001b = 10011001b
-10010000b | 10001010b = 10011010b
-10010000b | 10001011b = 10011011b
-10010000b | 10001100b = 10011100b
-10010000b | 10001101b = 10011101b
-10010000b | 10001110b = 10011110b
-10010000b | 10001111b = 10011111b
-10010000b | 10010000b = 10010000b
-10010000b | 10010001b = 10010001b
-10010000b | 10010010b = 10010010b
-10010000b | 10010011b = 10010011b
-10010000b | 10010100b = 10010100b
-10010000b | 10010101b = 10010101b
-10010000b | 10010110b = 10010110b
-10010000b | 10010111b = 10010111b
-10010000b | 10011000b = 10011000b
-10010000b | 10011001b = 10011001b
-10010000b | 10011010b = 10011010b
-10010000b | 10011011b = 10011011b
-10010000b | 10011100b = 10011100b
-10010000b | 10011101b = 10011101b
-10010000b | 10011110b = 10011110b
-10010000b | 10011111b = 10011111b
-10010000b | 10100000b = 10110000b
-10010000b | 10100001b = 10110001b
-10010000b | 10100010b = 10110010b
-10010000b | 10100011b = 10110011b
-10010000b | 10100100b = 10110100b
-10010000b | 10100101b = 10110101b
-10010000b | 10100110b = 10110110b
-10010000b | 10100111b = 10110111b
-10010000b | 10101000b = 10111000b
-10010000b | 10101001b = 10111001b
-10010000b | 10101010b = 10111010b
-10010000b | 10101011b = 10111011b
-10010000b | 10101100b = 10111100b
-10010000b | 10101101b = 10111101b
-10010000b | 10101110b = 10111110b
-10010000b | 10101111b = 10111111b
-10010000b | 10110000b = 10110000b
-10010000b | 10110001b = 10110001b
-10010000b | 10110010b = 10110010b
-10010000b | 10110011b = 10110011b
-10010000b | 10110100b = 10110100b
-10010000b | 10110101b = 10110101b
-10010000b | 10110110b = 10110110b
-10010000b | 10110111b = 10110111b
-10010000b | 10111000b = 10111000b
-10010000b | 10111001b = 10111001b
-10010000b | 10111010b = 10111010b
-10010000b | 10111011b = 10111011b
-10010000b | 10111100b = 10111100b
-10010000b | 10111101b = 10111101b
-10010000b | 10111110b = 10111110b
-10010000b | 10111111b = 10111111b
-10010000b | 11000000b = 11010000b
-10010000b | 11000001b = 11010001b
-10010000b | 11000010b = 11010010b
-10010000b | 11000011b = 11010011b
-10010000b | 11000100b = 11010100b
-10010000b | 11000101b = 11010101b
-10010000b | 11000110b = 11010110b
-10010000b | 11000111b = 11010111b
-10010000b | 11001000b = 11011000b
-10010000b | 11001001b = 11011001b
-10010000b | 11001010b = 11011010b
-10010000b | 11001011b = 11011011b
-10010000b | 11001100b = 11011100b
-10010000b | 11001101b = 11011101b
-10010000b | 11001110b = 11011110b
-10010000b | 11001111b = 11011111b
-10010000b | 11010000b = 11010000b
-10010000b | 11010001b = 11010001b
-10010000b | 11010010b = 11010010b
-10010000b | 11010011b = 11010011b
-10010000b | 11010100b = 11010100b
-10010000b | 11010101b = 11010101b
-10010000b | 11010110b = 11010110b
-10010000b | 11010111b = 11010111b
-10010000b | 11011000b = 11011000b
-10010000b | 11011001b = 11011001b
-10010000b | 11011010b = 11011010b
-10010000b | 11011011b = 11011011b
-10010000b | 11011100b = 11011100b
-10010000b | 11011101b = 11011101b
-10010000b | 11011110b = 11011110b
-10010000b | 11011111b = 11011111b
-10010000b | 11100000b = 11110000b
-10010000b | 11100001b = 11110001b
-10010000b | 11100010b = 11110010b
-10010000b | 11100011b = 11110011b
-10010000b | 11100100b = 11110100b
-10010000b | 11100101b = 11110101b
-10010000b | 11100110b = 11110110b
-10010000b | 11100111b = 11110111b
-10010000b | 11101000b = 11111000b
-10010000b | 11101001b = 11111001b
-10010000b | 11101010b = 11111010b
-10010000b | 11101011b = 11111011b
-10010000b | 11101100b = 11111100b
-10010000b | 11101101b = 11111101b
-10010000b | 11101110b = 11111110b
-10010000b | 11101111b = 11111111b
-10010000b | 11110000b = 11110000b
-10010000b | 11110001b = 11110001b
-10010000b | 11110010b = 11110010b
-10010000b | 11110011b = 11110011b
-10010000b | 11110100b = 11110100b
-10010000b | 11110101b = 11110101b
-10010000b | 11110110b = 11110110b
-10010000b | 11110111b = 11110111b
-10010000b | 11111000b = 11111000b
-10010000b | 11111001b = 11111001b
-10010000b | 11111010b = 11111010b
-10010000b | 11111011b = 11111011b
-10010000b | 11111100b = 11111100b
-10010000b | 11111101b = 11111101b
-10010000b | 11111110b = 11111110b
-10010000b | 11111111b = 11111111b
-10010000b | 00000000b = 10010000b
-10010000b | 00000001b = 10010001b
-10010000b | 00000010b = 10010010b
-10010000b | 00000011b = 10010011b
-10010000b | 00000100b = 10010100b
-10010000b | 00000101b = 10010101b
-10010000b | 00000110b = 10010110b
-10010000b | 00000111b = 10010111b
-10010000b | 00001000b = 10011000b
-10010000b | 00001001b = 10011001b
-10010000b | 00001010b = 10011010b
-10010000b | 00001011b = 10011011b
-10010000b | 00001100b = 10011100b
-10010000b | 00001101b = 10011101b
-10010000b | 00001110b = 10011110b
-10010000b | 00001111b = 10011111b
-10010000b | 00010000b = 10010000b
-10010000b | 00010001b = 10010001b
-10010000b | 00010010b = 10010010b
-10010000b | 00010011b = 10010011b
-10010000b | 00010100b = 10010100b
-10010000b | 00010101b = 10010101b
-10010000b | 00010110b = 10010110b
-10010000b | 00010111b = 10010111b
-10010000b | 00011000b = 10011000b
-10010000b | 00011001b = 10011001b
-10010000b | 00011010b = 10011010b
-10010000b | 00011011b = 10011011b
-10010000b | 00011100b = 10011100b
-10010000b | 00011101b = 10011101b
-10010000b | 00011110b = 10011110b
-10010000b | 00011111b = 10011111b
-10010000b | 00100000b = 10110000b
-10010000b | 00100001b = 10110001b
-10010000b | 00100010b = 10110010b
-10010000b | 00100011b = 10110011b
-10010000b | 00100100b = 10110100b
-10010000b | 00100101b = 10110101b
-10010000b | 00100110b = 10110110b
-10010000b | 00100111b = 10110111b
-10010000b | 00101000b = 10111000b
-10010000b | 00101001b = 10111001b
-10010000b | 00101010b = 10111010b
-10010000b | 00101011b = 10111011b
-10010000b | 00101100b = 10111100b
-10010000b | 00101101b = 10111101b
-10010000b | 00101110b = 10111110b
-10010000b | 00101111b = 10111111b
-10010000b | 00110000b = 10110000b
-10010000b | 00110001b = 10110001b
-10010000b | 00110010b = 10110010b
-10010000b | 00110011b = 10110011b
-10010000b | 00110100b = 10110100b
-10010000b | 00110101b = 10110101b
-10010000b | 00110110b = 10110110b
-10010000b | 00110111b = 10110111b
-10010000b | 00111000b = 10111000b
-10010000b | 00111001b = 10111001b
-10010000b | 00111010b = 10111010b
-10010000b | 00111011b = 10111011b
-10010000b | 00111100b = 10111100b
-10010000b | 00111101b = 10111101b
-10010000b | 00111110b = 10111110b
-10010000b | 00111111b = 10111111b
-10010000b | 01000000b = 11010000b
-10010000b | 01000001b = 11010001b
-10010000b | 01000010b = 11010010b
-10010000b | 01000011b = 11010011b
-10010000b | 01000100b = 11010100b
-10010000b | 01000101b = 11010101b
-10010000b | 01000110b = 11010110b
-10010000b | 01000111b = 11010111b
-10010000b | 01001000b = 11011000b
-10010000b | 01001001b = 11011001b
-10010000b | 01001010b = 11011010b
-10010000b | 01001011b = 11011011b
-10010000b | 01001100b = 11011100b
-10010000b | 01001101b = 11011101b
-10010000b | 01001110b = 11011110b
-10010000b | 01001111b = 11011111b
-10010000b | 01010000b = 11010000b
-10010000b | 01010001b = 11010001b
-10010000b | 01010010b = 11010010b
-10010000b | 01010011b = 11010011b
-10010000b | 01010100b = 11010100b
-10010000b | 01010101b = 11010101b
-10010000b | 01010110b = 11010110b
-10010000b | 01010111b = 11010111b
-10010000b | 01011000b = 11011000b
-10010000b | 01011001b = 11011001b
-10010000b | 01011010b = 11011010b
-10010000b | 01011011b = 11011011b
-10010000b | 01011100b = 11011100b
-10010000b | 01011101b = 11011101b
-10010000b | 01011110b = 11011110b
-10010000b | 01011111b = 11011111b
-10010000b | 01100000b = 11110000b
-10010000b | 01100001b = 11110001b
-10010000b | 01100010b = 11110010b
-10010000b | 01100011b = 11110011b
-10010000b | 01100100b = 11110100b
-10010000b | 01100101b = 11110101b
-10010000b | 01100110b = 11110110b
-10010000b | 01100111b = 11110111b
-10010000b | 01101000b = 11111000b
-10010000b | 01101001b = 11111001b
-10010000b | 01101010b = 11111010b
-10010000b | 01101011b = 11111011b
-10010000b | 01101100b = 11111100b
-10010000b | 01101101b = 11111101b
-10010000b | 01101110b = 11111110b
-10010000b | 01101111b = 11111111b
-10010000b | 01110000b = 11110000b
-10010000b | 01110001b = 11110001b
-10010000b | 01110010b = 11110010b
-10010000b | 01110011b = 11110011b
-10010000b | 01110100b = 11110100b
-10010000b | 01110101b = 11110101b
-10010000b | 01110110b = 11110110b
-10010000b | 01110111b = 11110111b
-10010000b | 01111000b = 11111000b
-10010000b | 01111001b = 11111001b
-10010000b | 01111010b = 11111010b
-10010000b | 01111011b = 11111011b
-10010000b | 01111100b = 11111100b
-10010000b | 01111101b = 11111101b
-10010000b | 01111110b = 11111110b
-10010001b | 10000000b = 10010001b
-10010001b | 10000001b = 10010001b
-10010001b | 10000010b = 10010011b
-10010001b | 10000011b = 10010011b
-10010001b | 10000100b = 10010101b
-10010001b | 10000101b = 10010101b
-10010001b | 10000110b = 10010111b
-10010001b | 10000111b = 10010111b
-10010001b | 10001000b = 10011001b
-10010001b | 10001001b = 10011001b
-10010001b | 10001010b = 10011011b
-10010001b | 10001011b = 10011011b
-10010001b | 10001100b = 10011101b
-10010001b | 10001101b = 10011101b
-10010001b | 10001110b = 10011111b
-10010001b | 10001111b = 10011111b
-10010001b | 10010000b = 10010001b
-10010001b | 10010001b = 10010001b
-10010001b | 10010010b = 10010011b
-10010001b | 10010011b = 10010011b
-10010001b | 10010100b = 10010101b
-10010001b | 10010101b = 10010101b
-10010001b | 10010110b = 10010111b
-10010001b | 10010111b = 10010111b
-10010001b | 10011000b = 10011001b
-10010001b | 10011001b = 10011001b
-10010001b | 10011010b = 10011011b
-10010001b | 10011011b = 10011011b
-10010001b | 10011100b = 10011101b
-10010001b | 10011101b = 10011101b
-10010001b | 10011110b = 10011111b
-10010001b | 10011111b = 10011111b
-10010001b | 10100000b = 10110001b
-10010001b | 10100001b = 10110001b
-10010001b | 10100010b = 10110011b
-10010001b | 10100011b = 10110011b
-10010001b | 10100100b = 10110101b
-10010001b | 10100101b = 10110101b
-10010001b | 10100110b = 10110111b
-10010001b | 10100111b = 10110111b
-10010001b | 10101000b = 10111001b
-10010001b | 10101001b = 10111001b
-10010001b | 10101010b = 10111011b
-10010001b | 10101011b = 10111011b
-10010001b | 10101100b = 10111101b
-10010001b | 10101101b = 10111101b
-10010001b | 10101110b = 10111111b
-10010001b | 10101111b = 10111111b
-10010001b | 10110000b = 10110001b
-10010001b | 10110001b = 10110001b
-10010001b | 10110010b = 10110011b
-10010001b | 10110011b = 10110011b
-10010001b | 10110100b = 10110101b
-10010001b | 10110101b = 10110101b
-10010001b | 10110110b = 10110111b
-10010001b | 10110111b = 10110111b
-10010001b | 10111000b = 10111001b
-10010001b | 10111001b = 10111001b
-10010001b | 10111010b = 10111011b
-10010001b | 10111011b = 10111011b
-10010001b | 10111100b = 10111101b
-10010001b | 10111101b = 10111101b
-10010001b | 10111110b = 10111111b
-10010001b | 10111111b = 10111111b
-10010001b | 11000000b = 11010001b
-10010001b | 11000001b = 11010001b
-10010001b | 11000010b = 11010011b
-10010001b | 11000011b = 11010011b
-10010001b | 11000100b = 11010101b
-10010001b | 11000101b = 11010101b
-10010001b | 11000110b = 11010111b
-10010001b | 11000111b = 11010111b
-10010001b | 11001000b = 11011001b
-10010001b | 11001001b = 11011001b
-10010001b | 11001010b = 11011011b
-10010001b | 11001011b = 11011011b
-10010001b | 11001100b = 11011101b
-10010001b | 11001101b = 11011101b
-10010001b | 11001110b = 11011111b
-10010001b | 11001111b = 11011111b
-10010001b | 11010000b = 11010001b
-10010001b | 11010001b = 11010001b
-10010001b | 11010010b = 11010011b
-10010001b | 11010011b = 11010011b
-10010001b | 11010100b = 11010101b
-10010001b | 11010101b = 11010101b
-10010001b | 11010110b = 11010111b
-10010001b | 11010111b = 11010111b
-10010001b | 11011000b = 11011001b
-10010001b | 11011001b = 11011001b
-10010001b | 11011010b = 11011011b
-10010001b | 11011011b = 11011011b
-10010001b | 11011100b = 11011101b
-10010001b | 11011101b = 11011101b
-10010001b | 11011110b = 11011111b
-10010001b | 11011111b = 11011111b
-10010001b | 11100000b = 11110001b
-10010001b | 11100001b = 11110001b
-10010001b | 11100010b = 11110011b
-10010001b | 11100011b = 11110011b
-10010001b | 11100100b = 11110101b
-10010001b | 11100101b = 11110101b
-10010001b | 11100110b = 11110111b
-10010001b | 11100111b = 11110111b
-10010001b | 11101000b = 11111001b
-10010001b | 11101001b = 11111001b
-10010001b | 11101010b = 11111011b
-10010001b | 11101011b = 11111011b
-10010001b | 11101100b = 11111101b
-10010001b | 11101101b = 11111101b
-10010001b | 11101110b = 11111111b
-10010001b | 11101111b = 11111111b
-10010001b | 11110000b = 11110001b
-10010001b | 11110001b = 11110001b
-10010001b | 11110010b = 11110011b
-10010001b | 11110011b = 11110011b
-10010001b | 11110100b = 11110101b
-10010001b | 11110101b = 11110101b
-10010001b | 11110110b = 11110111b
-10010001b | 11110111b = 11110111b
-10010001b | 11111000b = 11111001b
-10010001b | 11111001b = 11111001b
-10010001b | 11111010b = 11111011b
-10010001b | 11111011b = 11111011b
-10010001b | 11111100b = 11111101b
-10010001b | 11111101b = 11111101b
-10010001b | 11111110b = 11111111b
-10010001b | 11111111b = 11111111b
-10010001b | 00000000b = 10010001b
-10010001b | 00000001b = 10010001b
-10010001b | 00000010b = 10010011b
-10010001b | 00000011b = 10010011b
-10010001b | 00000100b = 10010101b
-10010001b | 00000101b = 10010101b
-10010001b | 00000110b = 10010111b
-10010001b | 00000111b = 10010111b
-10010001b | 00001000b = 10011001b
-10010001b | 00001001b = 10011001b
-10010001b | 00001010b = 10011011b
-10010001b | 00001011b = 10011011b
-10010001b | 00001100b = 10011101b
-10010001b | 00001101b = 10011101b
-10010001b | 00001110b = 10011111b
-10010001b | 00001111b = 10011111b
-10010001b | 00010000b = 10010001b
-10010001b | 00010001b = 10010001b
-10010001b | 00010010b = 10010011b
-10010001b | 00010011b = 10010011b
-10010001b | 00010100b = 10010101b
-10010001b | 00010101b = 10010101b
-10010001b | 00010110b = 10010111b
-10010001b | 00010111b = 10010111b
-10010001b | 00011000b = 10011001b
-10010001b | 00011001b = 10011001b
-10010001b | 00011010b = 10011011b
-10010001b | 00011011b = 10011011b
-10010001b | 00011100b = 10011101b
-10010001b | 00011101b = 10011101b
-10010001b | 00011110b = 10011111b
-10010001b | 00011111b = 10011111b
-10010001b | 00100000b = 10110001b
-10010001b | 00100001b = 10110001b
-10010001b | 00100010b = 10110011b
-10010001b | 00100011b = 10110011b
-10010001b | 00100100b = 10110101b
-10010001b | 00100101b = 10110101b
-10010001b | 00100110b = 10110111b
-10010001b | 00100111b = 10110111b
-10010001b | 00101000b = 10111001b
-10010001b | 00101001b = 10111001b
-10010001b | 00101010b = 10111011b
-10010001b | 00101011b = 10111011b
-10010001b | 00101100b = 10111101b
-10010001b | 00101101b = 10111101b
-10010001b | 00101110b = 10111111b
-10010001b | 00101111b = 10111111b
-10010001b | 00110000b = 10110001b
-10010001b | 00110001b = 10110001b
-10010001b | 00110010b = 10110011b
-10010001b | 00110011b = 10110011b
-10010001b | 00110100b = 10110101b
-10010001b | 00110101b = 10110101b
-10010001b | 00110110b = 10110111b
-10010001b | 00110111b = 10110111b
-10010001b | 00111000b = 10111001b
-10010001b | 00111001b = 10111001b
-10010001b | 00111010b = 10111011b
-10010001b | 00111011b = 10111011b
-10010001b | 00111100b = 10111101b
-10010001b | 00111101b = 10111101b
-10010001b | 00111110b = 10111111b
-10010001b | 00111111b = 10111111b
-10010001b | 01000000b = 11010001b
-10010001b | 01000001b = 11010001b
-10010001b | 01000010b = 11010011b
-10010001b | 01000011b = 11010011b
-10010001b | 01000100b = 11010101b
-10010001b | 01000101b = 11010101b
-10010001b | 01000110b = 11010111b
-10010001b | 01000111b = 11010111b
-10010001b | 01001000b = 11011001b
-10010001b | 01001001b = 11011001b
-10010001b | 01001010b = 11011011b
-10010001b | 01001011b = 11011011b
-10010001b | 01001100b = 11011101b
-10010001b | 01001101b = 11011101b
-10010001b | 01001110b = 11011111b
-10010001b | 01001111b = 11011111b
-10010001b | 01010000b = 11010001b
-10010001b | 01010001b = 11010001b
-10010001b | 01010010b = 11010011b
-10010001b | 01010011b = 11010011b
-10010001b | 01010100b = 11010101b
-10010001b | 01010101b = 11010101b
-10010001b | 01010110b = 11010111b
-10010001b | 01010111b = 11010111b
-10010001b | 01011000b = 11011001b
-10010001b | 01011001b = 11011001b
-10010001b | 01011010b = 11011011b
-10010001b | 01011011b = 11011011b
-10010001b | 01011100b = 11011101b
-10010001b | 01011101b = 11011101b
-10010001b | 01011110b = 11011111b
-10010001b | 01011111b = 11011111b
-10010001b | 01100000b = 11110001b
-10010001b | 01100001b = 11110001b
-10010001b | 01100010b = 11110011b
-10010001b | 01100011b = 11110011b
-10010001b | 01100100b = 11110101b
-10010001b | 01100101b = 11110101b
-10010001b | 01100110b = 11110111b
-10010001b | 01100111b = 11110111b
-10010001b | 01101000b = 11111001b
-10010001b | 01101001b = 11111001b
-10010001b | 01101010b = 11111011b
-10010001b | 01101011b = 11111011b
-10010001b | 01101100b = 11111101b
-10010001b | 01101101b = 11111101b
-10010001b | 01101110b = 11111111b
-10010001b | 01101111b = 11111111b
-10010001b | 01110000b = 11110001b
-10010001b | 01110001b = 11110001b
-10010001b | 01110010b = 11110011b
-10010001b | 01110011b = 11110011b
-10010001b | 01110100b = 11110101b
-10010001b | 01110101b = 11110101b
-10010001b | 01110110b = 11110111b
-10010001b | 01110111b = 11110111b
-10010001b | 01111000b = 11111001b
-10010001b | 01111001b = 11111001b
-10010001b | 01111010b = 11111011b
-10010001b | 01111011b = 11111011b
-10010001b | 01111100b = 11111101b
-10010001b | 01111101b = 11111101b
-10010001b | 01111110b = 11111111b
-10010010b | 10000000b = 10010010b
-10010010b | 10000001b = 10010011b
-10010010b | 10000010b = 10010010b
-10010010b | 10000011b = 10010011b
-10010010b | 10000100b = 10010110b
-10010010b | 10000101b = 10010111b
-10010010b | 10000110b = 10010110b
-10010010b | 10000111b = 10010111b
-10010010b | 10001000b = 10011010b
-10010010b | 10001001b = 10011011b
-10010010b | 10001010b = 10011010b
-10010010b | 10001011b = 10011011b
-10010010b | 10001100b = 10011110b
-10010010b | 10001101b = 10011111b
-10010010b | 10001110b = 10011110b
-10010010b | 10001111b = 10011111b
-10010010b | 10010000b = 10010010b
-10010010b | 10010001b = 10010011b
-10010010b | 10010010b = 10010010b
-10010010b | 10010011b = 10010011b
-10010010b | 10010100b = 10010110b
-10010010b | 10010101b = 10010111b
-10010010b | 10010110b = 10010110b
-10010010b | 10010111b = 10010111b
-10010010b | 10011000b = 10011010b
-10010010b | 10011001b = 10011011b
-10010010b | 10011010b = 10011010b
-10010010b | 10011011b = 10011011b
-10010010b | 10011100b = 10011110b
-10010010b | 10011101b = 10011111b
-10010010b | 10011110b = 10011110b
-10010010b | 10011111b = 10011111b
-10010010b | 10100000b = 10110010b
-10010010b | 10100001b = 10110011b
-10010010b | 10100010b = 10110010b
-10010010b | 10100011b = 10110011b
-10010010b | 10100100b = 10110110b
-10010010b | 10100101b = 10110111b
-10010010b | 10100110b = 10110110b
-10010010b | 10100111b = 10110111b
-10010010b | 10101000b = 10111010b
-10010010b | 10101001b = 10111011b
-10010010b | 10101010b = 10111010b
-10010010b | 10101011b = 10111011b
-10010010b | 10101100b = 10111110b
-10010010b | 10101101b = 10111111b
-10010010b | 10101110b = 10111110b
-10010010b | 10101111b = 10111111b
-10010010b | 10110000b = 10110010b
-10010010b | 10110001b = 10110011b
-10010010b | 10110010b = 10110010b
-10010010b | 10110011b = 10110011b
-10010010b | 10110100b = 10110110b
-10010010b | 10110101b = 10110111b
-10010010b | 10110110b = 10110110b
-10010010b | 10110111b = 10110111b
-10010010b | 10111000b = 10111010b
-10010010b | 10111001b = 10111011b
-10010010b | 10111010b = 10111010b
-10010010b | 10111011b = 10111011b
-10010010b | 10111100b = 10111110b
-10010010b | 10111101b = 10111111b
-10010010b | 10111110b = 10111110b
-10010010b | 10111111b = 10111111b
-10010010b | 11000000b = 11010010b
-10010010b | 11000001b = 11010011b
-10010010b | 11000010b = 11010010b
-10010010b | 11000011b = 11010011b
-10010010b | 11000100b = 11010110b
-10010010b | 11000101b = 11010111b
-10010010b | 11000110b = 11010110b
-10010010b | 11000111b = 11010111b
-10010010b | 11001000b = 11011010b
-10010010b | 11001001b = 11011011b
-10010010b | 11001010b = 11011010b
-10010010b | 11001011b = 11011011b
-10010010b | 11001100b = 11011110b
-10010010b | 11001101b = 11011111b
-10010010b | 11001110b = 11011110b
-10010010b | 11001111b = 11011111b
-10010010b | 11010000b = 11010010b
-10010010b | 11010001b = 11010011b
-10010010b | 11010010b = 11010010b
-10010010b | 11010011b = 11010011b
-10010010b | 11010100b = 11010110b
-10010010b | 11010101b = 11010111b
-10010010b | 11010110b = 11010110b
-10010010b | 11010111b = 11010111b
-10010010b | 11011000b = 11011010b
-10010010b | 11011001b = 11011011b
-10010010b | 11011010b = 11011010b
-10010010b | 11011011b = 11011011b
-10010010b | 11011100b = 11011110b
-10010010b | 11011101b = 11011111b
-10010010b | 11011110b = 11011110b
-10010010b | 11011111b = 11011111b
-10010010b | 11100000b = 11110010b
-10010010b | 11100001b = 11110011b
-10010010b | 11100010b = 11110010b
-10010010b | 11100011b = 11110011b
-10010010b | 11100100b = 11110110b
-10010010b | 11100101b = 11110111b
-10010010b | 11100110b = 11110110b
-10010010b | 11100111b = 11110111b
-10010010b | 11101000b = 11111010b
-10010010b | 11101001b = 11111011b
-10010010b | 11101010b = 11111010b
-10010010b | 11101011b = 11111011b
-10010010b | 11101100b = 11111110b
-10010010b | 11101101b = 11111111b
-10010010b | 11101110b = 11111110b
-10010010b | 11101111b = 11111111b
-10010010b | 11110000b = 11110010b
-10010010b | 11110001b = 11110011b
-10010010b | 11110010b = 11110010b
-10010010b | 11110011b = 11110011b
-10010010b | 11110100b = 11110110b
-10010010b | 11110101b = 11110111b
-10010010b | 11110110b = 11110110b
-10010010b | 11110111b = 11110111b
-10010010b | 11111000b = 11111010b
-10010010b | 11111001b = 11111011b
-10010010b | 11111010b = 11111010b
-10010010b | 11111011b = 11111011b
-10010010b | 11111100b = 11111110b
-10010010b | 11111101b = 11111111b
-10010010b | 11111110b = 11111110b
-10010010b | 11111111b = 11111111b
-10010010b | 00000000b = 10010010b
-10010010b | 00000001b = 10010011b
-10010010b | 00000010b = 10010010b
-10010010b | 00000011b = 10010011b
-10010010b | 00000100b = 10010110b
-10010010b | 00000101b = 10010111b
-10010010b | 00000110b = 10010110b
-10010010b | 00000111b = 10010111b
-10010010b | 00001000b = 10011010b
-10010010b | 00001001b = 10011011b
-10010010b | 00001010b = 10011010b
-10010010b | 00001011b = 10011011b
-10010010b | 00001100b = 10011110b
-10010010b | 00001101b = 10011111b
-10010010b | 00001110b = 10011110b
-10010010b | 00001111b = 10011111b
-10010010b | 00010000b = 10010010b
-10010010b | 00010001b = 10010011b
-10010010b | 00010010b = 10010010b
-10010010b | 00010011b = 10010011b
-10010010b | 00010100b = 10010110b
-10010010b | 00010101b = 10010111b
-10010010b | 00010110b = 10010110b
-10010010b | 00010111b = 10010111b
-10010010b | 00011000b = 10011010b
-10010010b | 00011001b = 10011011b
-10010010b | 00011010b = 10011010b
-10010010b | 00011011b = 10011011b
-10010010b | 00011100b = 10011110b
-10010010b | 00011101b = 10011111b
-10010010b | 00011110b = 10011110b
-10010010b | 00011111b = 10011111b
-10010010b | 00100000b = 10110010b
-10010010b | 00100001b = 10110011b
-10010010b | 00100010b = 10110010b
-10010010b | 00100011b = 10110011b
-10010010b | 00100100b = 10110110b
-10010010b | 00100101b = 10110111b
-10010010b | 00100110b = 10110110b
-10010010b | 00100111b = 10110111b
-10010010b | 00101000b = 10111010b
-10010010b | 00101001b = 10111011b
-10010010b | 00101010b = 10111010b
-10010010b | 00101011b = 10111011b
-10010010b | 00101100b = 10111110b
-10010010b | 00101101b = 10111111b
-10010010b | 00101110b = 10111110b
-10010010b | 00101111b = 10111111b
-10010010b | 00110000b = 10110010b
-10010010b | 00110001b = 10110011b
-10010010b | 00110010b = 10110010b
-10010010b | 00110011b = 10110011b
-10010010b | 00110100b = 10110110b
-10010010b | 00110101b = 10110111b
-10010010b | 00110110b = 10110110b
-10010010b | 00110111b = 10110111b
-10010010b | 00111000b = 10111010b
-10010010b | 00111001b = 10111011b
-10010010b | 00111010b = 10111010b
-10010010b | 00111011b = 10111011b
-10010010b | 00111100b = 10111110b
-10010010b | 00111101b = 10111111b
-10010010b | 00111110b = 10111110b
-10010010b | 00111111b = 10111111b
-10010010b | 01000000b = 11010010b
-10010010b | 01000001b = 11010011b
-10010010b | 01000010b = 11010010b
-10010010b | 01000011b = 11010011b
-10010010b | 01000100b = 11010110b
-10010010b | 01000101b = 11010111b
-10010010b | 01000110b = 11010110b
-10010010b | 01000111b = 11010111b
-10010010b | 01001000b = 11011010b
-10010010b | 01001001b = 11011011b
-10010010b | 01001010b = 11011010b
-10010010b | 01001011b = 11011011b
-10010010b | 01001100b = 11011110b
-10010010b | 01001101b = 11011111b
-10010010b | 01001110b = 11011110b
-10010010b | 01001111b = 11011111b
-10010010b | 01010000b = 11010010b
-10010010b | 01010001b = 11010011b
-10010010b | 01010010b = 11010010b
-10010010b | 01010011b = 11010011b
-10010010b | 01010100b = 11010110b
-10010010b | 01010101b = 11010111b
-10010010b | 01010110b = 11010110b
-10010010b | 01010111b = 11010111b
-10010010b | 01011000b = 11011010b
-10010010b | 01011001b = 11011011b
-10010010b | 01011010b = 11011010b
-10010010b | 01011011b = 11011011b
-10010010b | 01011100b = 11011110b
-10010010b | 01011101b = 11011111b
-10010010b | 01011110b = 11011110b
-10010010b | 01011111b = 11011111b
-10010010b | 01100000b = 11110010b
-10010010b | 01100001b = 11110011b
-10010010b | 01100010b = 11110010b
-10010010b | 01100011b = 11110011b
-10010010b | 01100100b = 11110110b
-10010010b | 01100101b = 11110111b
-10010010b | 01100110b = 11110110b
-10010010b | 01100111b = 11110111b
-10010010b | 01101000b = 11111010b
-10010010b | 01101001b = 11111011b
-10010010b | 01101010b = 11111010b
-10010010b | 01101011b = 11111011b
-10010010b | 01101100b = 11111110b
-10010010b | 01101101b = 11111111b
-10010010b | 01101110b = 11111110b
-10010010b | 01101111b = 11111111b
-10010010b | 01110000b = 11110010b
-10010010b | 01110001b = 11110011b
-10010010b | 01110010b = 11110010b
-10010010b | 01110011b = 11110011b
-10010010b | 01110100b = 11110110b
-10010010b | 01110101b = 11110111b
-10010010b | 01110110b = 11110110b
-10010010b | 01110111b = 11110111b
-10010010b | 01111000b = 11111010b
-10010010b | 01111001b = 11111011b
-10010010b | 01111010b = 11111010b
-10010010b | 01111011b = 11111011b
-10010010b | 01111100b = 11111110b
-10010010b | 01111101b = 11111111b
-10010010b | 01111110b = 11111110b
-10010011b | 10000000b = 10010011b
-10010011b | 10000001b = 10010011b
-10010011b | 10000010b = 10010011b
-10010011b | 10000011b = 10010011b
-10010011b | 10000100b = 10010111b
-10010011b | 10000101b = 10010111b
-10010011b | 10000110b = 10010111b
-10010011b | 10000111b = 10010111b
-10010011b | 10001000b = 10011011b
-10010011b | 10001001b = 10011011b
-10010011b | 10001010b = 10011011b
-10010011b | 10001011b = 10011011b
-10010011b | 10001100b = 10011111b
-10010011b | 10001101b = 10011111b
-10010011b | 10001110b = 10011111b
-10010011b | 10001111b = 10011111b
-10010011b | 10010000b = 10010011b
-10010011b | 10010001b = 10010011b
-10010011b | 10010010b = 10010011b
-10010011b | 10010011b = 10010011b
-10010011b | 10010100b = 10010111b
-10010011b | 10010101b = 10010111b
-10010011b | 10010110b = 10010111b
-10010011b | 10010111b = 10010111b
-10010011b | 10011000b = 10011011b
-10010011b | 10011001b = 10011011b
-10010011b | 10011010b = 10011011b
-10010011b | 10011011b = 10011011b
-10010011b | 10011100b = 10011111b
-10010011b | 10011101b = 10011111b
-10010011b | 10011110b = 10011111b
-10010011b | 10011111b = 10011111b
-10010011b | 10100000b = 10110011b
-10010011b | 10100001b = 10110011b
-10010011b | 10100010b = 10110011b
-10010011b | 10100011b = 10110011b
-10010011b | 10100100b = 10110111b
-10010011b | 10100101b = 10110111b
-10010011b | 10100110b = 10110111b
-10010011b | 10100111b = 10110111b
-10010011b | 10101000b = 10111011b
-10010011b | 10101001b = 10111011b
-10010011b | 10101010b = 10111011b
-10010011b | 10101011b = 10111011b
-10010011b | 10101100b = 10111111b
-10010011b | 10101101b = 10111111b
-10010011b | 10101110b = 10111111b
-10010011b | 10101111b = 10111111b
-10010011b | 10110000b = 10110011b
-10010011b | 10110001b = 10110011b
-10010011b | 10110010b = 10110011b
-10010011b | 10110011b = 10110011b
-10010011b | 10110100b = 10110111b
-10010011b | 10110101b = 10110111b
-10010011b | 10110110b = 10110111b
-10010011b | 10110111b = 10110111b
-10010011b | 10111000b = 10111011b
-10010011b | 10111001b = 10111011b
-10010011b | 10111010b = 10111011b
-10010011b | 10111011b = 10111011b
-10010011b | 10111100b = 10111111b
-10010011b | 10111101b = 10111111b
-10010011b | 10111110b = 10111111b
-10010011b | 10111111b = 10111111b
-10010011b | 11000000b = 11010011b
-10010011b | 11000001b = 11010011b
-10010011b | 11000010b = 11010011b
-10010011b | 11000011b = 11010011b
-10010011b | 11000100b = 11010111b
-10010011b | 11000101b = 11010111b
-10010011b | 11000110b = 11010111b
-10010011b | 11000111b = 11010111b
-10010011b | 11001000b = 11011011b
-10010011b | 11001001b = 11011011b
-10010011b | 11001010b = 11011011b
-10010011b | 11001011b = 11011011b
-10010011b | 11001100b = 11011111b
-10010011b | 11001101b = 11011111b
-10010011b | 11001110b = 11011111b
-10010011b | 11001111b = 11011111b
-10010011b | 11010000b = 11010011b
-10010011b | 11010001b = 11010011b
-10010011b | 11010010b = 11010011b
-10010011b | 11010011b = 11010011b
-10010011b | 11010100b = 11010111b
-10010011b | 11010101b = 11010111b
-10010011b | 11010110b = 11010111b
-10010011b | 11010111b = 11010111b
-10010011b | 11011000b = 11011011b
-10010011b | 11011001b = 11011011b
-10010011b | 11011010b = 11011011b
-10010011b | 11011011b = 11011011b
-10010011b | 11011100b = 11011111b
-10010011b | 11011101b = 11011111b
-10010011b | 11011110b = 11011111b
-10010011b | 11011111b = 11011111b
-10010011b | 11100000b = 11110011b
-10010011b | 11100001b = 11110011b
-10010011b | 11100010b = 11110011b
-10010011b | 11100011b = 11110011b
-10010011b | 11100100b = 11110111b
-10010011b | 11100101b = 11110111b
-10010011b | 11100110b = 11110111b
-10010011b | 11100111b = 11110111b
-10010011b | 11101000b = 11111011b
-10010011b | 11101001b = 11111011b
-10010011b | 11101010b = 11111011b
-10010011b | 11101011b = 11111011b
-10010011b | 11101100b = 11111111b
-10010011b | 11101101b = 11111111b
-10010011b | 11101110b = 11111111b
-10010011b | 11101111b = 11111111b
-10010011b | 11110000b = 11110011b
-10010011b | 11110001b = 11110011b
-10010011b | 11110010b = 11110011b
-10010011b | 11110011b = 11110011b
-10010011b | 11110100b = 11110111b
-10010011b | 11110101b = 11110111b
-10010011b | 11110110b = 11110111b
-10010011b | 11110111b = 11110111b
-10010011b | 11111000b = 11111011b
-10010011b | 11111001b = 11111011b
-10010011b | 11111010b = 11111011b
-10010011b | 11111011b = 11111011b
-10010011b | 11111100b = 11111111b
-10010011b | 11111101b = 11111111b
-10010011b | 11111110b = 11111111b
-10010011b | 11111111b = 11111111b
-10010011b | 00000000b = 10010011b
-10010011b | 00000001b = 10010011b
-10010011b | 00000010b = 10010011b
-10010011b | 00000011b = 10010011b
-10010011b | 00000100b = 10010111b
-10010011b | 00000101b = 10010111b
-10010011b | 00000110b = 10010111b
-10010011b | 00000111b = 10010111b
-10010011b | 00001000b = 10011011b
-10010011b | 00001001b = 10011011b
-10010011b | 00001010b = 10011011b
-10010011b | 00001011b = 10011011b
-10010011b | 00001100b = 10011111b
-10010011b | 00001101b = 10011111b
-10010011b | 00001110b = 10011111b
-10010011b | 00001111b = 10011111b
-10010011b | 00010000b = 10010011b
-10010011b | 00010001b = 10010011b
-10010011b | 00010010b = 10010011b
-10010011b | 00010011b = 10010011b
-10010011b | 00010100b = 10010111b
-10010011b | 00010101b = 10010111b
-10010011b | 00010110b = 10010111b
-10010011b | 00010111b = 10010111b
-10010011b | 00011000b = 10011011b
-10010011b | 00011001b = 10011011b
-10010011b | 00011010b = 10011011b
-10010011b | 00011011b = 10011011b
-10010011b | 00011100b = 10011111b
-10010011b | 00011101b = 10011111b
-10010011b | 00011110b = 10011111b
-10010011b | 00011111b = 10011111b
-10010011b | 00100000b = 10110011b
-10010011b | 00100001b = 10110011b
-10010011b | 00100010b = 10110011b
-10010011b | 00100011b = 10110011b
-10010011b | 00100100b = 10110111b
-10010011b | 00100101b = 10110111b
-10010011b | 00100110b = 10110111b
-10010011b | 00100111b = 10110111b
-10010011b | 00101000b = 10111011b
-10010011b | 00101001b = 10111011b
-10010011b | 00101010b = 10111011b
-10010011b | 00101011b = 10111011b
-10010011b | 00101100b = 10111111b
-10010011b | 00101101b = 10111111b
-10010011b | 00101110b = 10111111b
-10010011b | 00101111b = 10111111b
-10010011b | 00110000b = 10110011b
-10010011b | 00110001b = 10110011b
-10010011b | 00110010b = 10110011b
-10010011b | 00110011b = 10110011b
-10010011b | 00110100b = 10110111b
-10010011b | 00110101b = 10110111b
-10010011b | 00110110b = 10110111b
-10010011b | 00110111b = 10110111b
-10010011b | 00111000b = 10111011b
-10010011b | 00111001b = 10111011b
-10010011b | 00111010b = 10111011b
-10010011b | 00111011b = 10111011b
-10010011b | 00111100b = 10111111b
-10010011b | 00111101b = 10111111b
-10010011b | 00111110b = 10111111b
-10010011b | 00111111b = 10111111b
-10010011b | 01000000b = 11010011b
-10010011b | 01000001b = 11010011b
-10010011b | 01000010b = 11010011b
-10010011b | 01000011b = 11010011b
-10010011b | 01000100b = 11010111b
-10010011b | 01000101b = 11010111b
-10010011b | 01000110b = 11010111b
-10010011b | 01000111b = 11010111b
-10010011b | 01001000b = 11011011b
-10010011b | 01001001b = 11011011b
-10010011b | 01001010b = 11011011b
-10010011b | 01001011b = 11011011b
-10010011b | 01001100b = 11011111b
-10010011b | 01001101b = 11011111b
-10010011b | 01001110b = 11011111b
-10010011b | 01001111b = 11011111b
-10010011b | 01010000b = 11010011b
-10010011b | 01010001b = 11010011b
-10010011b | 01010010b = 11010011b
-10010011b | 01010011b = 11010011b
-10010011b | 01010100b = 11010111b
-10010011b | 01010101b = 11010111b
-10010011b | 01010110b = 11010111b
-10010011b | 01010111b = 11010111b
-10010011b | 01011000b = 11011011b
-10010011b | 01011001b = 11011011b
-10010011b | 01011010b = 11011011b
-10010011b | 01011011b = 11011011b
-10010011b | 01011100b = 11011111b
-10010011b | 01011101b = 11011111b
-10010011b | 01011110b = 11011111b
-10010011b | 01011111b = 11011111b
-10010011b | 01100000b = 11110011b
-10010011b | 01100001b = 11110011b
-10010011b | 01100010b = 11110011b
-10010011b | 01100011b = 11110011b
-10010011b | 01100100b = 11110111b
-10010011b | 01100101b = 11110111b
-10010011b | 01100110b = 11110111b
-10010011b | 01100111b = 11110111b
-10010011b | 01101000b = 11111011b
-10010011b | 01101001b = 11111011b
-10010011b | 01101010b = 11111011b
-10010011b | 01101011b = 11111011b
-10010011b | 01101100b = 11111111b
-10010011b | 01101101b = 11111111b
-10010011b | 01101110b = 11111111b
-10010011b | 01101111b = 11111111b
-10010011b | 01110000b = 11110011b
-10010011b | 01110001b = 11110011b
-10010011b | 01110010b = 11110011b
-10010011b | 01110011b = 11110011b
-10010011b | 01110100b = 11110111b
-10010011b | 01110101b = 11110111b
-10010011b | 01110110b = 11110111b
-10010011b | 01110111b = 11110111b
-10010011b | 01111000b = 11111011b
-10010011b | 01111001b = 11111011b
-10010011b | 01111010b = 11111011b
-10010011b | 01111011b = 11111011b
-10010011b | 01111100b = 11111111b
-10010011b | 01111101b = 11111111b
-10010011b | 01111110b = 11111111b
-10010100b | 10000000b = 10010100b
-10010100b | 10000001b = 10010101b
-10010100b | 10000010b = 10010110b
-10010100b | 10000011b = 10010111b
-10010100b | 10000100b = 10010100b
-10010100b | 10000101b = 10010101b
-10010100b | 10000110b = 10010110b
-10010100b | 10000111b = 10010111b
-10010100b | 10001000b = 10011100b
-10010100b | 10001001b = 10011101b
-10010100b | 10001010b = 10011110b
-10010100b | 10001011b = 10011111b
-10010100b | 10001100b = 10011100b
-10010100b | 10001101b = 10011101b
-10010100b | 10001110b = 10011110b
-10010100b | 10001111b = 10011111b
-10010100b | 10010000b = 10010100b
-10010100b | 10010001b = 10010101b
-10010100b | 10010010b = 10010110b
-10010100b | 10010011b = 10010111b
-10010100b | 10010100b = 10010100b
-10010100b | 10010101b = 10010101b
-10010100b | 10010110b = 10010110b
-10010100b | 10010111b = 10010111b
-10010100b | 10011000b = 10011100b
-10010100b | 10011001b = 10011101b
-10010100b | 10011010b = 10011110b
-10010100b | 10011011b = 10011111b
-10010100b | 10011100b = 10011100b
-10010100b | 10011101b = 10011101b
-10010100b | 10011110b = 10011110b
-10010100b | 10011111b = 10011111b
-10010100b | 10100000b = 10110100b
-10010100b | 10100001b = 10110101b
-10010100b | 10100010b = 10110110b
-10010100b | 10100011b = 10110111b
-10010100b | 10100100b = 10110100b
-10010100b | 10100101b = 10110101b
-10010100b | 10100110b = 10110110b
-10010100b | 10100111b = 10110111b
-10010100b | 10101000b = 10111100b
-10010100b | 10101001b = 10111101b
-10010100b | 10101010b = 10111110b
-10010100b | 10101011b = 10111111b
-10010100b | 10101100b = 10111100b
-10010100b | 10101101b = 10111101b
-10010100b | 10101110b = 10111110b
-10010100b | 10101111b = 10111111b
-10010100b | 10110000b = 10110100b
-10010100b | 10110001b = 10110101b
-10010100b | 10110010b = 10110110b
-10010100b | 10110011b = 10110111b
-10010100b | 10110100b = 10110100b
-10010100b | 10110101b = 10110101b
-10010100b | 10110110b = 10110110b
-10010100b | 10110111b = 10110111b
-10010100b | 10111000b = 10111100b
-10010100b | 10111001b = 10111101b
-10010100b | 10111010b = 10111110b
-10010100b | 10111011b = 10111111b
-10010100b | 10111100b = 10111100b
-10010100b | 10111101b = 10111101b
-10010100b | 10111110b = 10111110b
-10010100b | 10111111b = 10111111b
-10010100b | 11000000b = 11010100b
-10010100b | 11000001b = 11010101b
-10010100b | 11000010b = 11010110b
-10010100b | 11000011b = 11010111b
-10010100b | 11000100b = 11010100b
-10010100b | 11000101b = 11010101b
-10010100b | 11000110b = 11010110b
-10010100b | 11000111b = 11010111b
-10010100b | 11001000b = 11011100b
-10010100b | 11001001b = 11011101b
-10010100b | 11001010b = 11011110b
-10010100b | 11001011b = 11011111b
-10010100b | 11001100b = 11011100b
-10010100b | 11001101b = 11011101b
-10010100b | 11001110b = 11011110b
-10010100b | 11001111b = 11011111b
-10010100b | 11010000b = 11010100b
-10010100b | 11010001b = 11010101b
-10010100b | 11010010b = 11010110b
-10010100b | 11010011b = 11010111b
-10010100b | 11010100b = 11010100b
-10010100b | 11010101b = 11010101b
-10010100b | 11010110b = 11010110b
-10010100b | 11010111b = 11010111b
-10010100b | 11011000b = 11011100b
-10010100b | 11011001b = 11011101b
-10010100b | 11011010b = 11011110b
-10010100b | 11011011b = 11011111b
-10010100b | 11011100b = 11011100b
-10010100b | 11011101b = 11011101b
-10010100b | 11011110b = 11011110b
-10010100b | 11011111b = 11011111b
-10010100b | 11100000b = 11110100b
-10010100b | 11100001b = 11110101b
-10010100b | 11100010b = 11110110b
-10010100b | 11100011b = 11110111b
-10010100b | 11100100b = 11110100b
-10010100b | 11100101b = 11110101b
-10010100b | 11100110b = 11110110b
-10010100b | 11100111b = 11110111b
-10010100b | 11101000b = 11111100b
-10010100b | 11101001b = 11111101b
-10010100b | 11101010b = 11111110b
-10010100b | 11101011b = 11111111b
-10010100b | 11101100b = 11111100b
-10010100b | 11101101b = 11111101b
-10010100b | 11101110b = 11111110b
-10010100b | 11101111b = 11111111b
-10010100b | 11110000b = 11110100b
-10010100b | 11110001b = 11110101b
-10010100b | 11110010b = 11110110b
-10010100b | 11110011b = 11110111b
-10010100b | 11110100b = 11110100b
-10010100b | 11110101b = 11110101b
-10010100b | 11110110b = 11110110b
-10010100b | 11110111b = 11110111b
-10010100b | 11111000b = 11111100b
-10010100b | 11111001b = 11111101b
-10010100b | 11111010b = 11111110b
-10010100b | 11111011b = 11111111b
-10010100b | 11111100b = 11111100b
-10010100b | 11111101b = 11111101b
-10010100b | 11111110b = 11111110b
-10010100b | 11111111b = 11111111b
-10010100b | 00000000b = 10010100b
-10010100b | 00000001b = 10010101b
-10010100b | 00000010b = 10010110b
-10010100b | 00000011b = 10010111b
-10010100b | 00000100b = 10010100b
-10010100b | 00000101b = 10010101b
-10010100b | 00000110b = 10010110b
-10010100b | 00000111b = 10010111b
-10010100b | 00001000b = 10011100b
-10010100b | 00001001b = 10011101b
-10010100b | 00001010b = 10011110b
-10010100b | 00001011b = 10011111b
-10010100b | 00001100b = 10011100b
-10010100b | 00001101b = 10011101b
-10010100b | 00001110b = 10011110b
-10010100b | 00001111b = 10011111b
-10010100b | 00010000b = 10010100b
-10010100b | 00010001b = 10010101b
-10010100b | 00010010b = 10010110b
-10010100b | 00010011b = 10010111b
-10010100b | 00010100b = 10010100b
-10010100b | 00010101b = 10010101b
-10010100b | 00010110b = 10010110b
-10010100b | 00010111b = 10010111b
-10010100b | 00011000b = 10011100b
-10010100b | 00011001b = 10011101b
-10010100b | 00011010b = 10011110b
-10010100b | 00011011b = 10011111b
-10010100b | 00011100b = 10011100b
-10010100b | 00011101b = 10011101b
-10010100b | 00011110b = 10011110b
-10010100b | 00011111b = 10011111b
-10010100b | 00100000b = 10110100b
-10010100b | 00100001b = 10110101b
-10010100b | 00100010b = 10110110b
-10010100b | 00100011b = 10110111b
-10010100b | 00100100b = 10110100b
-10010100b | 00100101b = 10110101b
-10010100b | 00100110b = 10110110b
-10010100b | 00100111b = 10110111b
-10010100b | 00101000b = 10111100b
-10010100b | 00101001b = 10111101b
-10010100b | 00101010b = 10111110b
-10010100b | 00101011b = 10111111b
-10010100b | 00101100b = 10111100b
-10010100b | 00101101b = 10111101b
-10010100b | 00101110b = 10111110b
-10010100b | 00101111b = 10111111b
-10010100b | 00110000b = 10110100b
-10010100b | 00110001b = 10110101b
-10010100b | 00110010b = 10110110b
-10010100b | 00110011b = 10110111b
-10010100b | 00110100b = 10110100b
-10010100b | 00110101b = 10110101b
-10010100b | 00110110b = 10110110b
-10010100b | 00110111b = 10110111b
-10010100b | 00111000b = 10111100b
-10010100b | 00111001b = 10111101b
-10010100b | 00111010b = 10111110b
-10010100b | 00111011b = 10111111b
-10010100b | 00111100b = 10111100b
-10010100b | 00111101b = 10111101b
-10010100b | 00111110b = 10111110b
-10010100b | 00111111b = 10111111b
-10010100b | 01000000b = 11010100b
-10010100b | 01000001b = 11010101b
-10010100b | 01000010b = 11010110b
-10010100b | 01000011b = 11010111b
-10010100b | 01000100b = 11010100b
-10010100b | 01000101b = 11010101b
-10010100b | 01000110b = 11010110b
-10010100b | 01000111b = 11010111b
-10010100b | 01001000b = 11011100b
-10010100b | 01001001b = 11011101b
-10010100b | 01001010b = 11011110b
-10010100b | 01001011b = 11011111b
-10010100b | 01001100b = 11011100b
-10010100b | 01001101b = 11011101b
-10010100b | 01001110b = 11011110b
-10010100b | 01001111b = 11011111b
-10010100b | 01010000b = 11010100b
-10010100b | 01010001b = 11010101b
-10010100b | 01010010b = 11010110b
-10010100b | 01010011b = 11010111b
-10010100b | 01010100b = 11010100b
-10010100b | 01010101b = 11010101b
-10010100b | 01010110b = 11010110b
-10010100b | 01010111b = 11010111b
-10010100b | 01011000b = 11011100b
-10010100b | 01011001b = 11011101b
-10010100b | 01011010b = 11011110b
-10010100b | 01011011b = 11011111b
-10010100b | 01011100b = 11011100b
-10010100b | 01011101b = 11011101b
-10010100b | 01011110b = 11011110b
-10010100b | 01011111b = 11011111b
-10010100b | 01100000b = 11110100b
-10010100b | 01100001b = 11110101b
-10010100b | 01100010b = 11110110b
-10010100b | 01100011b = 11110111b
-10010100b | 01100100b = 11110100b
-10010100b | 01100101b = 11110101b
-10010100b | 01100110b = 11110110b
-10010100b | 01100111b = 11110111b
-10010100b | 01101000b = 11111100b
-10010100b | 01101001b = 11111101b
-10010100b | 01101010b = 11111110b
-10010100b | 01101011b = 11111111b
-10010100b | 01101100b = 11111100b
-10010100b | 01101101b = 11111101b
-10010100b | 01101110b = 11111110b
-10010100b | 01101111b = 11111111b
-10010100b | 01110000b = 11110100b
-10010100b | 01110001b = 11110101b
-10010100b | 01110010b = 11110110b
-10010100b | 01110011b = 11110111b
-10010100b | 01110100b = 11110100b
-10010100b | 01110101b = 11110101b
-10010100b | 01110110b = 11110110b
-10010100b | 01110111b = 11110111b
-10010100b | 01111000b = 11111100b
-10010100b | 01111001b = 11111101b
-10010100b | 01111010b = 11111110b
-10010100b | 01111011b = 11111111b
-10010100b | 01111100b = 11111100b
-10010100b | 01111101b = 11111101b
-10010100b | 01111110b = 11111110b
-10010101b | 10000000b = 10010101b
-10010101b | 10000001b = 10010101b
-10010101b | 10000010b = 10010111b
-10010101b | 10000011b = 10010111b
-10010101b | 10000100b = 10010101b
-10010101b | 10000101b = 10010101b
-10010101b | 10000110b = 10010111b
-10010101b | 10000111b = 10010111b
-10010101b | 10001000b = 10011101b
-10010101b | 10001001b = 10011101b
-10010101b | 10001010b = 10011111b
-10010101b | 10001011b = 10011111b
-10010101b | 10001100b = 10011101b
-10010101b | 10001101b = 10011101b
-10010101b | 10001110b = 10011111b
-10010101b | 10001111b = 10011111b
-10010101b | 10010000b = 10010101b
-10010101b | 10010001b = 10010101b
-10010101b | 10010010b = 10010111b
-10010101b | 10010011b = 10010111b
-10010101b | 10010100b = 10010101b
-10010101b | 10010101b = 10010101b
-10010101b | 10010110b = 10010111b
-10010101b | 10010111b = 10010111b
-10010101b | 10011000b = 10011101b
-10010101b | 10011001b = 10011101b
-10010101b | 10011010b = 10011111b
-10010101b | 10011011b = 10011111b
-10010101b | 10011100b = 10011101b
-10010101b | 10011101b = 10011101b
-10010101b | 10011110b = 10011111b
-10010101b | 10011111b = 10011111b
-10010101b | 10100000b = 10110101b
-10010101b | 10100001b = 10110101b
-10010101b | 10100010b = 10110111b
-10010101b | 10100011b = 10110111b
-10010101b | 10100100b = 10110101b
-10010101b | 10100101b = 10110101b
-10010101b | 10100110b = 10110111b
-10010101b | 10100111b = 10110111b
-10010101b | 10101000b = 10111101b
-10010101b | 10101001b = 10111101b
-10010101b | 10101010b = 10111111b
-10010101b | 10101011b = 10111111b
-10010101b | 10101100b = 10111101b
-10010101b | 10101101b = 10111101b
-10010101b | 10101110b = 10111111b
-10010101b | 10101111b = 10111111b
-10010101b | 10110000b = 10110101b
-10010101b | 10110001b = 10110101b
-10010101b | 10110010b = 10110111b
-10010101b | 10110011b = 10110111b
-10010101b | 10110100b = 10110101b
-10010101b | 10110101b = 10110101b
-10010101b | 10110110b = 10110111b
-10010101b | 10110111b = 10110111b
-10010101b | 10111000b = 10111101b
-10010101b | 10111001b = 10111101b
-10010101b | 10111010b = 10111111b
-10010101b | 10111011b = 10111111b
-10010101b | 10111100b = 10111101b
-10010101b | 10111101b = 10111101b
-10010101b | 10111110b = 10111111b
-10010101b | 10111111b = 10111111b
-10010101b | 11000000b = 11010101b
-10010101b | 11000001b = 11010101b
-10010101b | 11000010b = 11010111b
-10010101b | 11000011b = 11010111b
-10010101b | 11000100b = 11010101b
-10010101b | 11000101b = 11010101b
-10010101b | 11000110b = 11010111b
-10010101b | 11000111b = 11010111b
-10010101b | 11001000b = 11011101b
-10010101b | 11001001b = 11011101b
-10010101b | 11001010b = 11011111b
-10010101b | 11001011b = 11011111b
-10010101b | 11001100b = 11011101b
-10010101b | 11001101b = 11011101b
-10010101b | 11001110b = 11011111b
-10010101b | 11001111b = 11011111b
-10010101b | 11010000b = 11010101b
-10010101b | 11010001b = 11010101b
-10010101b | 11010010b = 11010111b
-10010101b | 11010011b = 11010111b
-10010101b | 11010100b = 11010101b
-10010101b | 11010101b = 11010101b
-10010101b | 11010110b = 11010111b
-10010101b | 11010111b = 11010111b
-10010101b | 11011000b = 11011101b
-10010101b | 11011001b = 11011101b
-10010101b | 11011010b = 11011111b
-10010101b | 11011011b = 11011111b
-10010101b | 11011100b = 11011101b
-10010101b | 11011101b = 11011101b
-10010101b | 11011110b = 11011111b
-10010101b | 11011111b = 11011111b
-10010101b | 11100000b = 11110101b
-10010101b | 11100001b = 11110101b
-10010101b | 11100010b = 11110111b
-10010101b | 11100011b = 11110111b
-10010101b | 11100100b = 11110101b
-10010101b | 11100101b = 11110101b
-10010101b | 11100110b = 11110111b
-10010101b | 11100111b = 11110111b
-10010101b | 11101000b = 11111101b
-10010101b | 11101001b = 11111101b
-10010101b | 11101010b = 11111111b
-10010101b | 11101011b = 11111111b
-10010101b | 11101100b = 11111101b
-10010101b | 11101101b = 11111101b
-10010101b | 11101110b = 11111111b
-10010101b | 11101111b = 11111111b
-10010101b | 11110000b = 11110101b
-10010101b | 11110001b = 11110101b
-10010101b | 11110010b = 11110111b
-10010101b | 11110011b = 11110111b
-10010101b | 11110100b = 11110101b
-10010101b | 11110101b = 11110101b
-10010101b | 11110110b = 11110111b
-10010101b | 11110111b = 11110111b
-10010101b | 11111000b = 11111101b
-10010101b | 11111001b = 11111101b
-10010101b | 11111010b = 11111111b
-10010101b | 11111011b = 11111111b
-10010101b | 11111100b = 11111101b
-10010101b | 11111101b = 11111101b
-10010101b | 11111110b = 11111111b
-10010101b | 11111111b = 11111111b
-10010101b | 00000000b = 10010101b
-10010101b | 00000001b = 10010101b
-10010101b | 00000010b = 10010111b
-10010101b | 00000011b = 10010111b
-10010101b | 00000100b = 10010101b
-10010101b | 00000101b = 10010101b
-10010101b | 00000110b = 10010111b
-10010101b | 00000111b = 10010111b
-10010101b | 00001000b = 10011101b
-10010101b | 00001001b = 10011101b
-10010101b | 00001010b = 10011111b
-10010101b | 00001011b = 10011111b
-10010101b | 00001100b = 10011101b
-10010101b | 00001101b = 10011101b
-10010101b | 00001110b = 10011111b
-10010101b | 00001111b = 10011111b
-10010101b | 00010000b = 10010101b
-10010101b | 00010001b = 10010101b
-10010101b | 00010010b = 10010111b
-10010101b | 00010011b = 10010111b
-10010101b | 00010100b = 10010101b
-10010101b | 00010101b = 10010101b
-10010101b | 00010110b = 10010111b
-10010101b | 00010111b = 10010111b
-10010101b | 00011000b = 10011101b
-10010101b | 00011001b = 10011101b
-10010101b | 00011010b = 10011111b
-10010101b | 00011011b = 10011111b
-10010101b | 00011100b = 10011101b
-10010101b | 00011101b = 10011101b
-10010101b | 00011110b = 10011111b
-10010101b | 00011111b = 10011111b
-10010101b | 00100000b = 10110101b
-10010101b | 00100001b = 10110101b
-10010101b | 00100010b = 10110111b
-10010101b | 00100011b = 10110111b
-10010101b | 00100100b = 10110101b
-10010101b | 00100101b = 10110101b
-10010101b | 00100110b = 10110111b
-10010101b | 00100111b = 10110111b
-10010101b | 00101000b = 10111101b
-10010101b | 00101001b = 10111101b
-10010101b | 00101010b = 10111111b
-10010101b | 00101011b = 10111111b
-10010101b | 00101100b = 10111101b
-10010101b | 00101101b = 10111101b
-10010101b | 00101110b = 10111111b
-10010101b | 00101111b = 10111111b
-10010101b | 00110000b = 10110101b
-10010101b | 00110001b = 10110101b
-10010101b | 00110010b = 10110111b
-10010101b | 00110011b = 10110111b
-10010101b | 00110100b = 10110101b
-10010101b | 00110101b = 10110101b
-10010101b | 00110110b = 10110111b
-10010101b | 00110111b = 10110111b
-10010101b | 00111000b = 10111101b
-10010101b | 00111001b = 10111101b
-10010101b | 00111010b = 10111111b
-10010101b | 00111011b = 10111111b
-10010101b | 00111100b = 10111101b
-10010101b | 00111101b = 10111101b
-10010101b | 00111110b = 10111111b
-10010101b | 00111111b = 10111111b
-10010101b | 01000000b = 11010101b
-10010101b | 01000001b = 11010101b
-10010101b | 01000010b = 11010111b
-10010101b | 01000011b = 11010111b
-10010101b | 01000100b = 11010101b
-10010101b | 01000101b = 11010101b
-10010101b | 01000110b = 11010111b
-10010101b | 01000111b = 11010111b
-10010101b | 01001000b = 11011101b
-10010101b | 01001001b = 11011101b
-10010101b | 01001010b = 11011111b
-10010101b | 01001011b = 11011111b
-10010101b | 01001100b = 11011101b
-10010101b | 01001101b = 11011101b
-10010101b | 01001110b = 11011111b
-10010101b | 01001111b = 11011111b
-10010101b | 01010000b = 11010101b
-10010101b | 01010001b = 11010101b
-10010101b | 01010010b = 11010111b
-10010101b | 01010011b = 11010111b
-10010101b | 01010100b = 11010101b
-10010101b | 01010101b = 11010101b
-10010101b | 01010110b = 11010111b
-10010101b | 01010111b = 11010111b
-10010101b | 01011000b = 11011101b
-10010101b | 01011001b = 11011101b
-10010101b | 01011010b = 11011111b
-10010101b | 01011011b = 11011111b
-10010101b | 01011100b = 11011101b
-10010101b | 01011101b = 11011101b
-10010101b | 01011110b = 11011111b
-10010101b | 01011111b = 11011111b
-10010101b | 01100000b = 11110101b
-10010101b | 01100001b = 11110101b
-10010101b | 01100010b = 11110111b
-10010101b | 01100011b = 11110111b
-10010101b | 01100100b = 11110101b
-10010101b | 01100101b = 11110101b
-10010101b | 01100110b = 11110111b
-10010101b | 01100111b = 11110111b
-10010101b | 01101000b = 11111101b
-10010101b | 01101001b = 11111101b
-10010101b | 01101010b = 11111111b
-10010101b | 01101011b = 11111111b
-10010101b | 01101100b = 11111101b
-10010101b | 01101101b = 11111101b
-10010101b | 01101110b = 11111111b
-10010101b | 01101111b = 11111111b
-10010101b | 01110000b = 11110101b
-10010101b | 01110001b = 11110101b
-10010101b | 01110010b = 11110111b
-10010101b | 01110011b = 11110111b
-10010101b | 01110100b = 11110101b
-10010101b | 01110101b = 11110101b
-10010101b | 01110110b = 11110111b
-10010101b | 01110111b = 11110111b
-10010101b | 01111000b = 11111101b
-10010101b | 01111001b = 11111101b
-10010101b | 01111010b = 11111111b
-10010101b | 01111011b = 11111111b
-10010101b | 01111100b = 11111101b
-10010101b | 01111101b = 11111101b
-10010101b | 01111110b = 11111111b
-10010110b | 10000000b = 10010110b
-10010110b | 10000001b = 10010111b
-10010110b | 10000010b = 10010110b
-10010110b | 10000011b = 10010111b
-10010110b | 10000100b = 10010110b
-10010110b | 10000101b = 10010111b
-10010110b | 10000110b = 10010110b
-10010110b | 10000111b = 10010111b
-10010110b | 10001000b = 10011110b
-10010110b | 10001001b = 10011111b
-10010110b | 10001010b = 10011110b
-10010110b | 10001011b = 10011111b
-10010110b | 10001100b = 10011110b
-10010110b | 10001101b = 10011111b
-10010110b | 10001110b = 10011110b
-10010110b | 10001111b = 10011111b
-10010110b | 10010000b = 10010110b
-10010110b | 10010001b = 10010111b
-10010110b | 10010010b = 10010110b
-10010110b | 10010011b = 10010111b
-10010110b | 10010100b = 10010110b
-10010110b | 10010101b = 10010111b
-10010110b | 10010110b = 10010110b
-10010110b | 10010111b = 10010111b
-10010110b | 10011000b = 10011110b
-10010110b | 10011001b = 10011111b
-10010110b | 10011010b = 10011110b
-10010110b | 10011011b = 10011111b
-10010110b | 10011100b = 10011110b
-10010110b | 10011101b = 10011111b
-10010110b | 10011110b = 10011110b
-10010110b | 10011111b = 10011111b
-10010110b | 10100000b = 10110110b
-10010110b | 10100001b = 10110111b
-10010110b | 10100010b = 10110110b
-10010110b | 10100011b = 10110111b
-10010110b | 10100100b = 10110110b
-10010110b | 10100101b = 10110111b
-10010110b | 10100110b = 10110110b
-10010110b | 10100111b = 10110111b
-10010110b | 10101000b = 10111110b
-10010110b | 10101001b = 10111111b
-10010110b | 10101010b = 10111110b
-10010110b | 10101011b = 10111111b
-10010110b | 10101100b = 10111110b
-10010110b | 10101101b = 10111111b
-10010110b | 10101110b = 10111110b
-10010110b | 10101111b = 10111111b
-10010110b | 10110000b = 10110110b
-10010110b | 10110001b = 10110111b
-10010110b | 10110010b = 10110110b
-10010110b | 10110011b = 10110111b
-10010110b | 10110100b = 10110110b
-10010110b | 10110101b = 10110111b
-10010110b | 10110110b = 10110110b
-10010110b | 10110111b = 10110111b
-10010110b | 10111000b = 10111110b
-10010110b | 10111001b = 10111111b
-10010110b | 10111010b = 10111110b
-10010110b | 10111011b = 10111111b
-10010110b | 10111100b = 10111110b
-10010110b | 10111101b = 10111111b
-10010110b | 10111110b = 10111110b
-10010110b | 10111111b = 10111111b
-10010110b | 11000000b = 11010110b
-10010110b | 11000001b = 11010111b
-10010110b | 11000010b = 11010110b
-10010110b | 11000011b = 11010111b
-10010110b | 11000100b = 11010110b
-10010110b | 11000101b = 11010111b
-10010110b | 11000110b = 11010110b
-10010110b | 11000111b = 11010111b
-10010110b | 11001000b = 11011110b
-10010110b | 11001001b = 11011111b
-10010110b | 11001010b = 11011110b
-10010110b | 11001011b = 11011111b
-10010110b | 11001100b = 11011110b
-10010110b | 11001101b = 11011111b
-10010110b | 11001110b = 11011110b
-10010110b | 11001111b = 11011111b
-10010110b | 11010000b = 11010110b
-10010110b | 11010001b = 11010111b
-10010110b | 11010010b = 11010110b
-10010110b | 11010011b = 11010111b
-10010110b | 11010100b = 11010110b
-10010110b | 11010101b = 11010111b
-10010110b | 11010110b = 11010110b
-10010110b | 11010111b = 11010111b
-10010110b | 11011000b = 11011110b
-10010110b | 11011001b = 11011111b
-10010110b | 11011010b = 11011110b
-10010110b | 11011011b = 11011111b
-10010110b | 11011100b = 11011110b
-10010110b | 11011101b = 11011111b
-10010110b | 11011110b = 11011110b
-10010110b | 11011111b = 11011111b
-10010110b | 11100000b = 11110110b
-10010110b | 11100001b = 11110111b
-10010110b | 11100010b = 11110110b
-10010110b | 11100011b = 11110111b
-10010110b | 11100100b = 11110110b
-10010110b | 11100101b = 11110111b
-10010110b | 11100110b = 11110110b
-10010110b | 11100111b = 11110111b
-10010110b | 11101000b = 11111110b
-10010110b | 11101001b = 11111111b
-10010110b | 11101010b = 11111110b
-10010110b | 11101011b = 11111111b
-10010110b | 11101100b = 11111110b
-10010110b | 11101101b = 11111111b
-10010110b | 11101110b = 11111110b
-10010110b | 11101111b = 11111111b
-10010110b | 11110000b = 11110110b
-10010110b | 11110001b = 11110111b
-10010110b | 11110010b = 11110110b
-10010110b | 11110011b = 11110111b
-10010110b | 11110100b = 11110110b
-10010110b | 11110101b = 11110111b
-10010110b | 11110110b = 11110110b
-10010110b | 11110111b = 11110111b
-10010110b | 11111000b = 11111110b
-10010110b | 11111001b = 11111111b
-10010110b | 11111010b = 11111110b
-10010110b | 11111011b = 11111111b
-10010110b | 11111100b = 11111110b
-10010110b | 11111101b = 11111111b
-10010110b | 11111110b = 11111110b
-10010110b | 11111111b = 11111111b
-10010110b | 00000000b = 10010110b
-10010110b | 00000001b = 10010111b
-10010110b | 00000010b = 10010110b
-10010110b | 00000011b = 10010111b
-10010110b | 00000100b = 10010110b
-10010110b | 00000101b = 10010111b
-10010110b | 00000110b = 10010110b
-10010110b | 00000111b = 10010111b
-10010110b | 00001000b = 10011110b
-10010110b | 00001001b = 10011111b
-10010110b | 00001010b = 10011110b
-10010110b | 00001011b = 10011111b
-10010110b | 00001100b = 10011110b
-10010110b | 00001101b = 10011111b
-10010110b | 00001110b = 10011110b
-10010110b | 00001111b = 10011111b
-10010110b | 00010000b = 10010110b
-10010110b | 00010001b = 10010111b
-10010110b | 00010010b = 10010110b
-10010110b | 00010011b = 10010111b
-10010110b | 00010100b = 10010110b
-10010110b | 00010101b = 10010111b
-10010110b | 00010110b = 10010110b
-10010110b | 00010111b = 10010111b
-10010110b | 00011000b = 10011110b
-10010110b | 00011001b = 10011111b
-10010110b | 00011010b = 10011110b
-10010110b | 00011011b = 10011111b
-10010110b | 00011100b = 10011110b
-10010110b | 00011101b = 10011111b
-10010110b | 00011110b = 10011110b
-10010110b | 00011111b = 10011111b
-10010110b | 00100000b = 10110110b
-10010110b | 00100001b = 10110111b
-10010110b | 00100010b = 10110110b
-10010110b | 00100011b = 10110111b
-10010110b | 00100100b = 10110110b
-10010110b | 00100101b = 10110111b
-10010110b | 00100110b = 10110110b
-10010110b | 00100111b = 10110111b
-10010110b | 00101000b = 10111110b
-10010110b | 00101001b = 10111111b
-10010110b | 00101010b = 10111110b
-10010110b | 00101011b = 10111111b
-10010110b | 00101100b = 10111110b
-10010110b | 00101101b = 10111111b
-10010110b | 00101110b = 10111110b
-10010110b | 00101111b = 10111111b
-10010110b | 00110000b = 10110110b
-10010110b | 00110001b = 10110111b
-10010110b | 00110010b = 10110110b
-10010110b | 00110011b = 10110111b
-10010110b | 00110100b = 10110110b
-10010110b | 00110101b = 10110111b
-10010110b | 00110110b = 10110110b
-10010110b | 00110111b = 10110111b
-10010110b | 00111000b = 10111110b
-10010110b | 00111001b = 10111111b
-10010110b | 00111010b = 10111110b
-10010110b | 00111011b = 10111111b
-10010110b | 00111100b = 10111110b
-10010110b | 00111101b = 10111111b
-10010110b | 00111110b = 10111110b
-10010110b | 00111111b = 10111111b
-10010110b | 01000000b = 11010110b
-10010110b | 01000001b = 11010111b
-10010110b | 01000010b = 11010110b
-10010110b | 01000011b = 11010111b
-10010110b | 01000100b = 11010110b
-10010110b | 01000101b = 11010111b
-10010110b | 01000110b = 11010110b
-10010110b | 01000111b = 11010111b
-10010110b | 01001000b = 11011110b
-10010110b | 01001001b = 11011111b
-10010110b | 01001010b = 11011110b
-10010110b | 01001011b = 11011111b
-10010110b | 01001100b = 11011110b
-10010110b | 01001101b = 11011111b
-10010110b | 01001110b = 11011110b
-10010110b | 01001111b = 11011111b
-10010110b | 01010000b = 11010110b
-10010110b | 01010001b = 11010111b
-10010110b | 01010010b = 11010110b
-10010110b | 01010011b = 11010111b
-10010110b | 01010100b = 11010110b
-10010110b | 01010101b = 11010111b
-10010110b | 01010110b = 11010110b
-10010110b | 01010111b = 11010111b
-10010110b | 01011000b = 11011110b
-10010110b | 01011001b = 11011111b
-10010110b | 01011010b = 11011110b
-10010110b | 01011011b = 11011111b
-10010110b | 01011100b = 11011110b
-10010110b | 01011101b = 11011111b
-10010110b | 01011110b = 11011110b
-10010110b | 01011111b = 11011111b
-10010110b | 01100000b = 11110110b
-10010110b | 01100001b = 11110111b
-10010110b | 01100010b = 11110110b
-10010110b | 01100011b = 11110111b
-10010110b | 01100100b = 11110110b
-10010110b | 01100101b = 11110111b
-10010110b | 01100110b = 11110110b
-10010110b | 01100111b = 11110111b
-10010110b | 01101000b = 11111110b
-10010110b | 01101001b = 11111111b
-10010110b | 01101010b = 11111110b
-10010110b | 01101011b = 11111111b
-10010110b | 01101100b = 11111110b
-10010110b | 01101101b = 11111111b
-10010110b | 01101110b = 11111110b
-10010110b | 01101111b = 11111111b
-10010110b | 01110000b = 11110110b
-10010110b | 01110001b = 11110111b
-10010110b | 01110010b = 11110110b
-10010110b | 01110011b = 11110111b
-10010110b | 01110100b = 11110110b
-10010110b | 01110101b = 11110111b
-10010110b | 01110110b = 11110110b
-10010110b | 01110111b = 11110111b
-10010110b | 01111000b = 11111110b
-10010110b | 01111001b = 11111111b
-10010110b | 01111010b = 11111110b
-10010110b | 01111011b = 11111111b
-10010110b | 01111100b = 11111110b
-10010110b | 01111101b = 11111111b
-10010110b | 01111110b = 11111110b
-10010111b | 10000000b = 10010111b
-10010111b | 10000001b = 10010111b
-10010111b | 10000010b = 10010111b
-10010111b | 10000011b = 10010111b
-10010111b | 10000100b = 10010111b
-10010111b | 10000101b = 10010111b
-10010111b | 10000110b = 10010111b
-10010111b | 10000111b = 10010111b
-10010111b | 10001000b = 10011111b
-10010111b | 10001001b = 10011111b
-10010111b | 10001010b = 10011111b
-10010111b | 10001011b = 10011111b
-10010111b | 10001100b = 10011111b
-10010111b | 10001101b = 10011111b
-10010111b | 10001110b = 10011111b
-10010111b | 10001111b = 10011111b
-10010111b | 10010000b = 10010111b
-10010111b | 10010001b = 10010111b
-10010111b | 10010010b = 10010111b
-10010111b | 10010011b = 10010111b
-10010111b | 10010100b = 10010111b
-10010111b | 10010101b = 10010111b
-10010111b | 10010110b = 10010111b
-10010111b | 10010111b = 10010111b
-10010111b | 10011000b = 10011111b
-10010111b | 10011001b = 10011111b
-10010111b | 10011010b = 10011111b
-10010111b | 10011011b = 10011111b
-10010111b | 10011100b = 10011111b
-10010111b | 10011101b = 10011111b
-10010111b | 10011110b = 10011111b
-10010111b | 10011111b = 10011111b
-10010111b | 10100000b = 10110111b
-10010111b | 10100001b = 10110111b
-10010111b | 10100010b = 10110111b
-10010111b | 10100011b = 10110111b
-10010111b | 10100100b = 10110111b
-10010111b | 10100101b = 10110111b
-10010111b | 10100110b = 10110111b
-10010111b | 10100111b = 10110111b
-10010111b | 10101000b = 10111111b
-10010111b | 10101001b = 10111111b
-10010111b | 10101010b = 10111111b
-10010111b | 10101011b = 10111111b
-10010111b | 10101100b = 10111111b
-10010111b | 10101101b = 10111111b
-10010111b | 10101110b = 10111111b
-10010111b | 10101111b = 10111111b
-10010111b | 10110000b = 10110111b
-10010111b | 10110001b = 10110111b
-10010111b | 10110010b = 10110111b
-10010111b | 10110011b = 10110111b
-10010111b | 10110100b = 10110111b
-10010111b | 10110101b = 10110111b
-10010111b | 10110110b = 10110111b
-10010111b | 10110111b = 10110111b
-10010111b | 10111000b = 10111111b
-10010111b | 10111001b = 10111111b
-10010111b | 10111010b = 10111111b
-10010111b | 10111011b = 10111111b
-10010111b | 10111100b = 10111111b
-10010111b | 10111101b = 10111111b
-10010111b | 10111110b = 10111111b
-10010111b | 10111111b = 10111111b
-10010111b | 11000000b = 11010111b
-10010111b | 11000001b = 11010111b
-10010111b | 11000010b = 11010111b
-10010111b | 11000011b = 11010111b
-10010111b | 11000100b = 11010111b
-10010111b | 11000101b = 11010111b
-10010111b | 11000110b = 11010111b
-10010111b | 11000111b = 11010111b
-10010111b | 11001000b = 11011111b
-10010111b | 11001001b = 11011111b
-10010111b | 11001010b = 11011111b
-10010111b | 11001011b = 11011111b
-10010111b | 11001100b = 11011111b
-10010111b | 11001101b = 11011111b
-10010111b | 11001110b = 11011111b
-10010111b | 11001111b = 11011111b
-10010111b | 11010000b = 11010111b
-10010111b | 11010001b = 11010111b
-10010111b | 11010010b = 11010111b
-10010111b | 11010011b = 11010111b
-10010111b | 11010100b = 11010111b
-10010111b | 11010101b = 11010111b
-10010111b | 11010110b = 11010111b
-10010111b | 11010111b = 11010111b
-10010111b | 11011000b = 11011111b
-10010111b | 11011001b = 11011111b
-10010111b | 11011010b = 11011111b
-10010111b | 11011011b = 11011111b
-10010111b | 11011100b = 11011111b
-10010111b | 11011101b = 11011111b
-10010111b | 11011110b = 11011111b
-10010111b | 11011111b = 11011111b
-10010111b | 11100000b = 11110111b
-10010111b | 11100001b = 11110111b
-10010111b | 11100010b = 11110111b
-10010111b | 11100011b = 11110111b
-10010111b | 11100100b = 11110111b
-10010111b | 11100101b = 11110111b
-10010111b | 11100110b = 11110111b
-10010111b | 11100111b = 11110111b
-10010111b | 11101000b = 11111111b
-10010111b | 11101001b = 11111111b
-10010111b | 11101010b = 11111111b
-10010111b | 11101011b = 11111111b
-10010111b | 11101100b = 11111111b
-10010111b | 11101101b = 11111111b
-10010111b | 11101110b = 11111111b
-10010111b | 11101111b = 11111111b
-10010111b | 11110000b = 11110111b
-10010111b | 11110001b = 11110111b
-10010111b | 11110010b = 11110111b
-10010111b | 11110011b = 11110111b
-10010111b | 11110100b = 11110111b
-10010111b | 11110101b = 11110111b
-10010111b | 11110110b = 11110111b
-10010111b | 11110111b = 11110111b
-10010111b | 11111000b = 11111111b
-10010111b | 11111001b = 11111111b
-10010111b | 11111010b = 11111111b
-10010111b | 11111011b = 11111111b
-10010111b | 11111100b = 11111111b
-10010111b | 11111101b = 11111111b
-10010111b | 11111110b = 11111111b
-10010111b | 11111111b = 11111111b
-10010111b | 00000000b = 10010111b
-10010111b | 00000001b = 10010111b
-10010111b | 00000010b = 10010111b
-10010111b | 00000011b = 10010111b
-10010111b | 00000100b = 10010111b
-10010111b | 00000101b = 10010111b
-10010111b | 00000110b = 10010111b
-10010111b | 00000111b = 10010111b
-10010111b | 00001000b = 10011111b
-10010111b | 00001001b = 10011111b
-10010111b | 00001010b = 10011111b
-10010111b | 00001011b = 10011111b
-10010111b | 00001100b = 10011111b
-10010111b | 00001101b = 10011111b
-10010111b | 00001110b = 10011111b
-10010111b | 00001111b = 10011111b
-10010111b | 00010000b = 10010111b
-10010111b | 00010001b = 10010111b
-10010111b | 00010010b = 10010111b
-10010111b | 00010011b = 10010111b
-10010111b | 00010100b = 10010111b
-10010111b | 00010101b = 10010111b
-10010111b | 00010110b = 10010111b
-10010111b | 00010111b = 10010111b
-10010111b | 00011000b = 10011111b
-10010111b | 00011001b = 10011111b
-10010111b | 00011010b = 10011111b
-10010111b | 00011011b = 10011111b
-10010111b | 00011100b = 10011111b
-10010111b | 00011101b = 10011111b
-10010111b | 00011110b = 10011111b
-10010111b | 00011111b = 10011111b
-10010111b | 00100000b = 10110111b
-10010111b | 00100001b = 10110111b
-10010111b | 00100010b = 10110111b
-10010111b | 00100011b = 10110111b
-10010111b | 00100100b = 10110111b
-10010111b | 00100101b = 10110111b
-10010111b | 00100110b = 10110111b
-10010111b | 00100111b = 10110111b
-10010111b | 00101000b = 10111111b
-10010111b | 00101001b = 10111111b
-10010111b | 00101010b = 10111111b
-10010111b | 00101011b = 10111111b
-10010111b | 00101100b = 10111111b
-10010111b | 00101101b = 10111111b
-10010111b | 00101110b = 10111111b
-10010111b | 00101111b = 10111111b
-10010111b | 00110000b = 10110111b
-10010111b | 00110001b = 10110111b
-10010111b | 00110010b = 10110111b
-10010111b | 00110011b = 10110111b
-10010111b | 00110100b = 10110111b
-10010111b | 00110101b = 10110111b
-10010111b | 00110110b = 10110111b
-10010111b | 00110111b = 10110111b
-10010111b | 00111000b = 10111111b
-10010111b | 00111001b = 10111111b
-10010111b | 00111010b = 10111111b
-10010111b | 00111011b = 10111111b
-10010111b | 00111100b = 10111111b
-10010111b | 00111101b = 10111111b
-10010111b | 00111110b = 10111111b
-10010111b | 00111111b = 10111111b
-10010111b | 01000000b = 11010111b
-10010111b | 01000001b = 11010111b
-10010111b | 01000010b = 11010111b
-10010111b | 01000011b = 11010111b
-10010111b | 01000100b = 11010111b
-10010111b | 01000101b = 11010111b
-10010111b | 01000110b = 11010111b
-10010111b | 01000111b = 11010111b
-10010111b | 01001000b = 11011111b
-10010111b | 01001001b = 11011111b
-10010111b | 01001010b = 11011111b
-10010111b | 01001011b = 11011111b
-10010111b | 01001100b = 11011111b
-10010111b | 01001101b = 11011111b
-10010111b | 01001110b = 11011111b
-10010111b | 01001111b = 11011111b
-10010111b | 01010000b = 11010111b
-10010111b | 01010001b = 11010111b
-10010111b | 01010010b = 11010111b
-10010111b | 01010011b = 11010111b
-10010111b | 01010100b = 11010111b
-10010111b | 01010101b = 11010111b
-10010111b | 01010110b = 11010111b
-10010111b | 01010111b = 11010111b
-10010111b | 01011000b = 11011111b
-10010111b | 01011001b = 11011111b
-10010111b | 01011010b = 11011111b
-10010111b | 01011011b = 11011111b
-10010111b | 01011100b = 11011111b
-10010111b | 01011101b = 11011111b
-10010111b | 01011110b = 11011111b
-10010111b | 01011111b = 11011111b
-10010111b | 01100000b = 11110111b
-10010111b | 01100001b = 11110111b
-10010111b | 01100010b = 11110111b
-10010111b | 01100011b = 11110111b
-10010111b | 01100100b = 11110111b
-10010111b | 01100101b = 11110111b
-10010111b | 01100110b = 11110111b
-10010111b | 01100111b = 11110111b
-10010111b | 01101000b = 11111111b
-10010111b | 01101001b = 11111111b
-10010111b | 01101010b = 11111111b
-10010111b | 01101011b = 11111111b
-10010111b | 01101100b = 11111111b
-10010111b | 01101101b = 11111111b
-10010111b | 01101110b = 11111111b
-10010111b | 01101111b = 11111111b
-10010111b | 01110000b = 11110111b
-10010111b | 01110001b = 11110111b
-10010111b | 01110010b = 11110111b
-10010111b | 01110011b = 11110111b
-10010111b | 01110100b = 11110111b
-10010111b | 01110101b = 11110111b
-10010111b | 01110110b = 11110111b
-10010111b | 01110111b = 11110111b
-10010111b | 01111000b = 11111111b
-10010111b | 01111001b = 11111111b
-10010111b | 01111010b = 11111111b
-10010111b | 01111011b = 11111111b
-10010111b | 01111100b = 11111111b
-10010111b | 01111101b = 11111111b
-10010111b | 01111110b = 11111111b
-10011000b | 10000000b = 10011000b
-10011000b | 10000001b = 10011001b
-10011000b | 10000010b = 10011010b
-10011000b | 10000011b = 10011011b
-10011000b | 10000100b = 10011100b
-10011000b | 10000101b = 10011101b
-10011000b | 10000110b = 10011110b
-10011000b | 10000111b = 10011111b
-10011000b | 10001000b = 10011000b
-10011000b | 10001001b = 10011001b
-10011000b | 10001010b = 10011010b
-10011000b | 10001011b = 10011011b
-10011000b | 10001100b = 10011100b
-10011000b | 10001101b = 10011101b
-10011000b | 10001110b = 10011110b
-10011000b | 10001111b = 10011111b
-10011000b | 10010000b = 10011000b
-10011000b | 10010001b = 10011001b
-10011000b | 10010010b = 10011010b
-10011000b | 10010011b = 10011011b
-10011000b | 10010100b = 10011100b
-10011000b | 10010101b = 10011101b
-10011000b | 10010110b = 10011110b
-10011000b | 10010111b = 10011111b
-10011000b | 10011000b = 10011000b
-10011000b | 10011001b = 10011001b
-10011000b | 10011010b = 10011010b
-10011000b | 10011011b = 10011011b
-10011000b | 10011100b = 10011100b
-10011000b | 10011101b = 10011101b
-10011000b | 10011110b = 10011110b
-10011000b | 10011111b = 10011111b
-10011000b | 10100000b = 10111000b
-10011000b | 10100001b = 10111001b
-10011000b | 10100010b = 10111010b
-10011000b | 10100011b = 10111011b
-10011000b | 10100100b = 10111100b
-10011000b | 10100101b = 10111101b
-10011000b | 10100110b = 10111110b
-10011000b | 10100111b = 10111111b
-10011000b | 10101000b = 10111000b
-10011000b | 10101001b = 10111001b
-10011000b | 10101010b = 10111010b
-10011000b | 10101011b = 10111011b
-10011000b | 10101100b = 10111100b
-10011000b | 10101101b = 10111101b
-10011000b | 10101110b = 10111110b
-10011000b | 10101111b = 10111111b
-10011000b | 10110000b = 10111000b
-10011000b | 10110001b = 10111001b
-10011000b | 10110010b = 10111010b
-10011000b | 10110011b = 10111011b
-10011000b | 10110100b = 10111100b
-10011000b | 10110101b = 10111101b
-10011000b | 10110110b = 10111110b
-10011000b | 10110111b = 10111111b
-10011000b | 10111000b = 10111000b
-10011000b | 10111001b = 10111001b
-10011000b | 10111010b = 10111010b
-10011000b | 10111011b = 10111011b
-10011000b | 10111100b = 10111100b
-10011000b | 10111101b = 10111101b
-10011000b | 10111110b = 10111110b
-10011000b | 10111111b = 10111111b
-10011000b | 11000000b = 11011000b
-10011000b | 11000001b = 11011001b
-10011000b | 11000010b = 11011010b
-10011000b | 11000011b = 11011011b
-10011000b | 11000100b = 11011100b
-10011000b | 11000101b = 11011101b
-10011000b | 11000110b = 11011110b
-10011000b | 11000111b = 11011111b
-10011000b | 11001000b = 11011000b
-10011000b | 11001001b = 11011001b
-10011000b | 11001010b = 11011010b
-10011000b | 11001011b = 11011011b
-10011000b | 11001100b = 11011100b
-10011000b | 11001101b = 11011101b
-10011000b | 11001110b = 11011110b
-10011000b | 11001111b = 11011111b
-10011000b | 11010000b = 11011000b
-10011000b | 11010001b = 11011001b
-10011000b | 11010010b = 11011010b
-10011000b | 11010011b = 11011011b
-10011000b | 11010100b = 11011100b
-10011000b | 11010101b = 11011101b
-10011000b | 11010110b = 11011110b
-10011000b | 11010111b = 11011111b
-10011000b | 11011000b = 11011000b
-10011000b | 11011001b = 11011001b
-10011000b | 11011010b = 11011010b
-10011000b | 11011011b = 11011011b
-10011000b | 11011100b = 11011100b
-10011000b | 11011101b = 11011101b
-10011000b | 11011110b = 11011110b
-10011000b | 11011111b = 11011111b
-10011000b | 11100000b = 11111000b
-10011000b | 11100001b = 11111001b
-10011000b | 11100010b = 11111010b
-10011000b | 11100011b = 11111011b
-10011000b | 11100100b = 11111100b
-10011000b | 11100101b = 11111101b
-10011000b | 11100110b = 11111110b
-10011000b | 11100111b = 11111111b
-10011000b | 11101000b = 11111000b
-10011000b | 11101001b = 11111001b
-10011000b | 11101010b = 11111010b
-10011000b | 11101011b = 11111011b
-10011000b | 11101100b = 11111100b
-10011000b | 11101101b = 11111101b
-10011000b | 11101110b = 11111110b
-10011000b | 11101111b = 11111111b
-10011000b | 11110000b = 11111000b
-10011000b | 11110001b = 11111001b
-10011000b | 11110010b = 11111010b
-10011000b | 11110011b = 11111011b
-10011000b | 11110100b = 11111100b
-10011000b | 11110101b = 11111101b
-10011000b | 11110110b = 11111110b
-10011000b | 11110111b = 11111111b
-10011000b | 11111000b = 11111000b
-10011000b | 11111001b = 11111001b
-10011000b | 11111010b = 11111010b
-10011000b | 11111011b = 11111011b
-10011000b | 11111100b = 11111100b
-10011000b | 11111101b = 11111101b
-10011000b | 11111110b = 11111110b
-10011000b | 11111111b = 11111111b
-10011000b | 00000000b = 10011000b
-10011000b | 00000001b = 10011001b
-10011000b | 00000010b = 10011010b
-10011000b | 00000011b = 10011011b
-10011000b | 00000100b = 10011100b
-10011000b | 00000101b = 10011101b
-10011000b | 00000110b = 10011110b
-10011000b | 00000111b = 10011111b
-10011000b | 00001000b = 10011000b
-10011000b | 00001001b = 10011001b
-10011000b | 00001010b = 10011010b
-10011000b | 00001011b = 10011011b
-10011000b | 00001100b = 10011100b
-10011000b | 00001101b = 10011101b
-10011000b | 00001110b = 10011110b
-10011000b | 00001111b = 10011111b
-10011000b | 00010000b = 10011000b
-10011000b | 00010001b = 10011001b
-10011000b | 00010010b = 10011010b
-10011000b | 00010011b = 10011011b
-10011000b | 00010100b = 10011100b
-10011000b | 00010101b = 10011101b
-10011000b | 00010110b = 10011110b
-10011000b | 00010111b = 10011111b
-10011000b | 00011000b = 10011000b
-10011000b | 00011001b = 10011001b
-10011000b | 00011010b = 10011010b
-10011000b | 00011011b = 10011011b
-10011000b | 00011100b = 10011100b
-10011000b | 00011101b = 10011101b
-10011000b | 00011110b = 10011110b
-10011000b | 00011111b = 10011111b
-10011000b | 00100000b = 10111000b
-10011000b | 00100001b = 10111001b
-10011000b | 00100010b = 10111010b
-10011000b | 00100011b = 10111011b
-10011000b | 00100100b = 10111100b
-10011000b | 00100101b = 10111101b
-10011000b | 00100110b = 10111110b
-10011000b | 00100111b = 10111111b
-10011000b | 00101000b = 10111000b
-10011000b | 00101001b = 10111001b
-10011000b | 00101010b = 10111010b
-10011000b | 00101011b = 10111011b
-10011000b | 00101100b = 10111100b
-10011000b | 00101101b = 10111101b
-10011000b | 00101110b = 10111110b
-10011000b | 00101111b = 10111111b
-10011000b | 00110000b = 10111000b
-10011000b | 00110001b = 10111001b
-10011000b | 00110010b = 10111010b
-10011000b | 00110011b = 10111011b
-10011000b | 00110100b = 10111100b
-10011000b | 00110101b = 10111101b
-10011000b | 00110110b = 10111110b
-10011000b | 00110111b = 10111111b
-10011000b | 00111000b = 10111000b
-10011000b | 00111001b = 10111001b
-10011000b | 00111010b = 10111010b
-10011000b | 00111011b = 10111011b
-10011000b | 00111100b = 10111100b
-10011000b | 00111101b = 10111101b
-10011000b | 00111110b = 10111110b
-10011000b | 00111111b = 10111111b
-10011000b | 01000000b = 11011000b
-10011000b | 01000001b = 11011001b
-10011000b | 01000010b = 11011010b
-10011000b | 01000011b = 11011011b
-10011000b | 01000100b = 11011100b
-10011000b | 01000101b = 11011101b
-10011000b | 01000110b = 11011110b
-10011000b | 01000111b = 11011111b
-10011000b | 01001000b = 11011000b
-10011000b | 01001001b = 11011001b
-10011000b | 01001010b = 11011010b
-10011000b | 01001011b = 11011011b
-10011000b | 01001100b = 11011100b
-10011000b | 01001101b = 11011101b
-10011000b | 01001110b = 11011110b
-10011000b | 01001111b = 11011111b
-10011000b | 01010000b = 11011000b
-10011000b | 01010001b = 11011001b
-10011000b | 01010010b = 11011010b
-10011000b | 01010011b = 11011011b
-10011000b | 01010100b = 11011100b
-10011000b | 01010101b = 11011101b
-10011000b | 01010110b = 11011110b
-10011000b | 01010111b = 11011111b
-10011000b | 01011000b = 11011000b
-10011000b | 01011001b = 11011001b
-10011000b | 01011010b = 11011010b
-10011000b | 01011011b = 11011011b
-10011000b | 01011100b = 11011100b
-10011000b | 01011101b = 11011101b
-10011000b | 01011110b = 11011110b
-10011000b | 01011111b = 11011111b
-10011000b | 01100000b = 11111000b
-10011000b | 01100001b = 11111001b
-10011000b | 01100010b = 11111010b
-10011000b | 01100011b = 11111011b
-10011000b | 01100100b = 11111100b
-10011000b | 01100101b = 11111101b
-10011000b | 01100110b = 11111110b
-10011000b | 01100111b = 11111111b
-10011000b | 01101000b = 11111000b
-10011000b | 01101001b = 11111001b
-10011000b | 01101010b = 11111010b
-10011000b | 01101011b = 11111011b
-10011000b | 01101100b = 11111100b
-10011000b | 01101101b = 11111101b
-10011000b | 01101110b = 11111110b
-10011000b | 01101111b = 11111111b
-10011000b | 01110000b = 11111000b
-10011000b | 01110001b = 11111001b
-10011000b | 01110010b = 11111010b
-10011000b | 01110011b = 11111011b
-10011000b | 01110100b = 11111100b
-10011000b | 01110101b = 11111101b
-10011000b | 01110110b = 11111110b
-10011000b | 01110111b = 11111111b
-10011000b | 01111000b = 11111000b
-10011000b | 01111001b = 11111001b
-10011000b | 01111010b = 11111010b
-10011000b | 01111011b = 11111011b
-10011000b | 01111100b = 11111100b
-10011000b | 01111101b = 11111101b
-10011000b | 01111110b = 11111110b
-10011001b | 10000000b = 10011001b
-10011001b | 10000001b = 10011001b
-10011001b | 10000010b = 10011011b
-10011001b | 10000011b = 10011011b
-10011001b | 10000100b = 10011101b
-10011001b | 10000101b = 10011101b
-10011001b | 10000110b = 10011111b
-10011001b | 10000111b = 10011111b
-10011001b | 10001000b = 10011001b
-10011001b | 10001001b = 10011001b
-10011001b | 10001010b = 10011011b
-10011001b | 10001011b = 10011011b
-10011001b | 10001100b = 10011101b
-10011001b | 10001101b = 10011101b
-10011001b | 10001110b = 10011111b
-10011001b | 10001111b = 10011111b
-10011001b | 10010000b = 10011001b
-10011001b | 10010001b = 10011001b
-10011001b | 10010010b = 10011011b
-10011001b | 10010011b = 10011011b
-10011001b | 10010100b = 10011101b
-10011001b | 10010101b = 10011101b
-10011001b | 10010110b = 10011111b
-10011001b | 10010111b = 10011111b
-10011001b | 10011000b = 10011001b
-10011001b | 10011001b = 10011001b
-10011001b | 10011010b = 10011011b
-10011001b | 10011011b = 10011011b
-10011001b | 10011100b = 10011101b
-10011001b | 10011101b = 10011101b
-10011001b | 10011110b = 10011111b
-10011001b | 10011111b = 10011111b
-10011001b | 10100000b = 10111001b
-10011001b | 10100001b = 10111001b
-10011001b | 10100010b = 10111011b
-10011001b | 10100011b = 10111011b
-10011001b | 10100100b = 10111101b
-10011001b | 10100101b = 10111101b
-10011001b | 10100110b = 10111111b
-10011001b | 10100111b = 10111111b
-10011001b | 10101000b = 10111001b
-10011001b | 10101001b = 10111001b
-10011001b | 10101010b = 10111011b
-10011001b | 10101011b = 10111011b
-10011001b | 10101100b = 10111101b
-10011001b | 10101101b = 10111101b
-10011001b | 10101110b = 10111111b
-10011001b | 10101111b = 10111111b
-10011001b | 10110000b = 10111001b
-10011001b | 10110001b = 10111001b
-10011001b | 10110010b = 10111011b
-10011001b | 10110011b = 10111011b
-10011001b | 10110100b = 10111101b
-10011001b | 10110101b = 10111101b
-10011001b | 10110110b = 10111111b
-10011001b | 10110111b = 10111111b
-10011001b | 10111000b = 10111001b
-10011001b | 10111001b = 10111001b
-10011001b | 10111010b = 10111011b
-10011001b | 10111011b = 10111011b
-10011001b | 10111100b = 10111101b
-10011001b | 10111101b = 10111101b
-10011001b | 10111110b = 10111111b
-10011001b | 10111111b = 10111111b
-10011001b | 11000000b = 11011001b
-10011001b | 11000001b = 11011001b
-10011001b | 11000010b = 11011011b
-10011001b | 11000011b = 11011011b
-10011001b | 11000100b = 11011101b
-10011001b | 11000101b = 11011101b
-10011001b | 11000110b = 11011111b
-10011001b | 11000111b = 11011111b
-10011001b | 11001000b = 11011001b
-10011001b | 11001001b = 11011001b
-10011001b | 11001010b = 11011011b
-10011001b | 11001011b = 11011011b
-10011001b | 11001100b = 11011101b
-10011001b | 11001101b = 11011101b
-10011001b | 11001110b = 11011111b
-10011001b | 11001111b = 11011111b
-10011001b | 11010000b = 11011001b
-10011001b | 11010001b = 11011001b
-10011001b | 11010010b = 11011011b
-10011001b | 11010011b = 11011011b
-10011001b | 11010100b = 11011101b
-10011001b | 11010101b = 11011101b
-10011001b | 11010110b = 11011111b
-10011001b | 11010111b = 11011111b
-10011001b | 11011000b = 11011001b
-10011001b | 11011001b = 11011001b
-10011001b | 11011010b = 11011011b
-10011001b | 11011011b = 11011011b
-10011001b | 11011100b = 11011101b
-10011001b | 11011101b = 11011101b
-10011001b | 11011110b = 11011111b
-10011001b | 11011111b = 11011111b
-10011001b | 11100000b = 11111001b
-10011001b | 11100001b = 11111001b
-10011001b | 11100010b = 11111011b
-10011001b | 11100011b = 11111011b
-10011001b | 11100100b = 11111101b
-10011001b | 11100101b = 11111101b
-10011001b | 11100110b = 11111111b
-10011001b | 11100111b = 11111111b
-10011001b | 11101000b = 11111001b
-10011001b | 11101001b = 11111001b
-10011001b | 11101010b = 11111011b
-10011001b | 11101011b = 11111011b
-10011001b | 11101100b = 11111101b
-10011001b | 11101101b = 11111101b
-10011001b | 11101110b = 11111111b
-10011001b | 11101111b = 11111111b
-10011001b | 11110000b = 11111001b
-10011001b | 11110001b = 11111001b
-10011001b | 11110010b = 11111011b
-10011001b | 11110011b = 11111011b
-10011001b | 11110100b = 11111101b
-10011001b | 11110101b = 11111101b
-10011001b | 11110110b = 11111111b
-10011001b | 11110111b = 11111111b
-10011001b | 11111000b = 11111001b
-10011001b | 11111001b = 11111001b
-10011001b | 11111010b = 11111011b
-10011001b | 11111011b = 11111011b
-10011001b | 11111100b = 11111101b
-10011001b | 11111101b = 11111101b
-10011001b | 11111110b = 11111111b
-10011001b | 11111111b = 11111111b
-10011001b | 00000000b = 10011001b
-10011001b | 00000001b = 10011001b
-10011001b | 00000010b = 10011011b
-10011001b | 00000011b = 10011011b
-10011001b | 00000100b = 10011101b
-10011001b | 00000101b = 10011101b
-10011001b | 00000110b = 10011111b
-10011001b | 00000111b = 10011111b
-10011001b | 00001000b = 10011001b
-10011001b | 00001001b = 10011001b
-10011001b | 00001010b = 10011011b
-10011001b | 00001011b = 10011011b
-10011001b | 00001100b = 10011101b
-10011001b | 00001101b = 10011101b
-10011001b | 00001110b = 10011111b
-10011001b | 00001111b = 10011111b
-10011001b | 00010000b = 10011001b
-10011001b | 00010001b = 10011001b
-10011001b | 00010010b = 10011011b
-10011001b | 00010011b = 10011011b
-10011001b | 00010100b = 10011101b
-10011001b | 00010101b = 10011101b
-10011001b | 00010110b = 10011111b
-10011001b | 00010111b = 10011111b
-10011001b | 00011000b = 10011001b
-10011001b | 00011001b = 10011001b
-10011001b | 00011010b = 10011011b
-10011001b | 00011011b = 10011011b
-10011001b | 00011100b = 10011101b
-10011001b | 00011101b = 10011101b
-10011001b | 00011110b = 10011111b
-10011001b | 00011111b = 10011111b
-10011001b | 00100000b = 10111001b
-10011001b | 00100001b = 10111001b
-10011001b | 00100010b = 10111011b
-10011001b | 00100011b = 10111011b
-10011001b | 00100100b = 10111101b
-10011001b | 00100101b = 10111101b
-10011001b | 00100110b = 10111111b
-10011001b | 00100111b = 10111111b
-10011001b | 00101000b = 10111001b
-10011001b | 00101001b = 10111001b
-10011001b | 00101010b = 10111011b
-10011001b | 00101011b = 10111011b
-10011001b | 00101100b = 10111101b
-10011001b | 00101101b = 10111101b
-10011001b | 00101110b = 10111111b
-10011001b | 00101111b = 10111111b
-10011001b | 00110000b = 10111001b
-10011001b | 00110001b = 10111001b
-10011001b | 00110010b = 10111011b
-10011001b | 00110011b = 10111011b
-10011001b | 00110100b = 10111101b
-10011001b | 00110101b = 10111101b
-10011001b | 00110110b = 10111111b
-10011001b | 00110111b = 10111111b
-10011001b | 00111000b = 10111001b
-10011001b | 00111001b = 10111001b
-10011001b | 00111010b = 10111011b
-10011001b | 00111011b = 10111011b
-10011001b | 00111100b = 10111101b
-10011001b | 00111101b = 10111101b
-10011001b | 00111110b = 10111111b
-10011001b | 00111111b = 10111111b
-10011001b | 01000000b = 11011001b
-10011001b | 01000001b = 11011001b
-10011001b | 01000010b = 11011011b
-10011001b | 01000011b = 11011011b
-10011001b | 01000100b = 11011101b
-10011001b | 01000101b = 11011101b
-10011001b | 01000110b = 11011111b
-10011001b | 01000111b = 11011111b
-10011001b | 01001000b = 11011001b
-10011001b | 01001001b = 11011001b
-10011001b | 01001010b = 11011011b
-10011001b | 01001011b = 11011011b
-10011001b | 01001100b = 11011101b
-10011001b | 01001101b = 11011101b
-10011001b | 01001110b = 11011111b
-10011001b | 01001111b = 11011111b
-10011001b | 01010000b = 11011001b
-10011001b | 01010001b = 11011001b
-10011001b | 01010010b = 11011011b
-10011001b | 01010011b = 11011011b
-10011001b | 01010100b = 11011101b
-10011001b | 01010101b = 11011101b
-10011001b | 01010110b = 11011111b
-10011001b | 01010111b = 11011111b
-10011001b | 01011000b = 11011001b
-10011001b | 01011001b = 11011001b
-10011001b | 01011010b = 11011011b
-10011001b | 01011011b = 11011011b
-10011001b | 01011100b = 11011101b
-10011001b | 01011101b = 11011101b
-10011001b | 01011110b = 11011111b
-10011001b | 01011111b = 11011111b
-10011001b | 01100000b = 11111001b
-10011001b | 01100001b = 11111001b
-10011001b | 01100010b = 11111011b
-10011001b | 01100011b = 11111011b
-10011001b | 01100100b = 11111101b
-10011001b | 01100101b = 11111101b
-10011001b | 01100110b = 11111111b
-10011001b | 01100111b = 11111111b
-10011001b | 01101000b = 11111001b
-10011001b | 01101001b = 11111001b
-10011001b | 01101010b = 11111011b
-10011001b | 01101011b = 11111011b
-10011001b | 01101100b = 11111101b
-10011001b | 01101101b = 11111101b
-10011001b | 01101110b = 11111111b
-10011001b | 01101111b = 11111111b
-10011001b | 01110000b = 11111001b
-10011001b | 01110001b = 11111001b
-10011001b | 01110010b = 11111011b
-10011001b | 01110011b = 11111011b
-10011001b | 01110100b = 11111101b
-10011001b | 01110101b = 11111101b
-10011001b | 01110110b = 11111111b
-10011001b | 01110111b = 11111111b
-10011001b | 01111000b = 11111001b
-10011001b | 01111001b = 11111001b
-10011001b | 01111010b = 11111011b
-10011001b | 01111011b = 11111011b
-10011001b | 01111100b = 11111101b
-10011001b | 01111101b = 11111101b
-10011001b | 01111110b = 11111111b
-10011010b | 10000000b = 10011010b
-10011010b | 10000001b = 10011011b
-10011010b | 10000010b = 10011010b
-10011010b | 10000011b = 10011011b
-10011010b | 10000100b = 10011110b
-10011010b | 10000101b = 10011111b
-10011010b | 10000110b = 10011110b
-10011010b | 10000111b = 10011111b
-10011010b | 10001000b = 10011010b
-10011010b | 10001001b = 10011011b
-10011010b | 10001010b = 10011010b
-10011010b | 10001011b = 10011011b
-10011010b | 10001100b = 10011110b
-10011010b | 10001101b = 10011111b
-10011010b | 10001110b = 10011110b
-10011010b | 10001111b = 10011111b
-10011010b | 10010000b = 10011010b
-10011010b | 10010001b = 10011011b
-10011010b | 10010010b = 10011010b
-10011010b | 10010011b = 10011011b
-10011010b | 10010100b = 10011110b
-10011010b | 10010101b = 10011111b
-10011010b | 10010110b = 10011110b
-10011010b | 10010111b = 10011111b
-10011010b | 10011000b = 10011010b
-10011010b | 10011001b = 10011011b
-10011010b | 10011010b = 10011010b
-10011010b | 10011011b = 10011011b
-10011010b | 10011100b = 10011110b
-10011010b | 10011101b = 10011111b
-10011010b | 10011110b = 10011110b
-10011010b | 10011111b = 10011111b
-10011010b | 10100000b = 10111010b
-10011010b | 10100001b = 10111011b
-10011010b | 10100010b = 10111010b
-10011010b | 10100011b = 10111011b
-10011010b | 10100100b = 10111110b
-10011010b | 10100101b = 10111111b
-10011010b | 10100110b = 10111110b
-10011010b | 10100111b = 10111111b
-10011010b | 10101000b = 10111010b
-10011010b | 10101001b = 10111011b
-10011010b | 10101010b = 10111010b
-10011010b | 10101011b = 10111011b
-10011010b | 10101100b = 10111110b
-10011010b | 10101101b = 10111111b
-10011010b | 10101110b = 10111110b
-10011010b | 10101111b = 10111111b
-10011010b | 10110000b = 10111010b
-10011010b | 10110001b = 10111011b
-10011010b | 10110010b = 10111010b
-10011010b | 10110011b = 10111011b
-10011010b | 10110100b = 10111110b
-10011010b | 10110101b = 10111111b
-10011010b | 10110110b = 10111110b
-10011010b | 10110111b = 10111111b
-10011010b | 10111000b = 10111010b
-10011010b | 10111001b = 10111011b
-10011010b | 10111010b = 10111010b
-10011010b | 10111011b = 10111011b
-10011010b | 10111100b = 10111110b
-10011010b | 10111101b = 10111111b
-10011010b | 10111110b = 10111110b
-10011010b | 10111111b = 10111111b
-10011010b | 11000000b = 11011010b
-10011010b | 11000001b = 11011011b
-10011010b | 11000010b = 11011010b
-10011010b | 11000011b = 11011011b
-10011010b | 11000100b = 11011110b
-10011010b | 11000101b = 11011111b
-10011010b | 11000110b = 11011110b
-10011010b | 11000111b = 11011111b
-10011010b | 11001000b = 11011010b
-10011010b | 11001001b = 11011011b
-10011010b | 11001010b = 11011010b
-10011010b | 11001011b = 11011011b
-10011010b | 11001100b = 11011110b
-10011010b | 11001101b = 11011111b
-10011010b | 11001110b = 11011110b
-10011010b | 11001111b = 11011111b
-10011010b | 11010000b = 11011010b
-10011010b | 11010001b = 11011011b
-10011010b | 11010010b = 11011010b
-10011010b | 11010011b = 11011011b
-10011010b | 11010100b = 11011110b
-10011010b | 11010101b = 11011111b
-10011010b | 11010110b = 11011110b
-10011010b | 11010111b = 11011111b
-10011010b | 11011000b = 11011010b
-10011010b | 11011001b = 11011011b
-10011010b | 11011010b = 11011010b
-10011010b | 11011011b = 11011011b
-10011010b | 11011100b = 11011110b
-10011010b | 11011101b = 11011111b
-10011010b | 11011110b = 11011110b
-10011010b | 11011111b = 11011111b
-10011010b | 11100000b = 11111010b
-10011010b | 11100001b = 11111011b
-10011010b | 11100010b = 11111010b
-10011010b | 11100011b = 11111011b
-10011010b | 11100100b = 11111110b
-10011010b | 11100101b = 11111111b
-10011010b | 11100110b = 11111110b
-10011010b | 11100111b = 11111111b
-10011010b | 11101000b = 11111010b
-10011010b | 11101001b = 11111011b
-10011010b | 11101010b = 11111010b
-10011010b | 11101011b = 11111011b
-10011010b | 11101100b = 11111110b
-10011010b | 11101101b = 11111111b
-10011010b | 11101110b = 11111110b
-10011010b | 11101111b = 11111111b
-10011010b | 11110000b = 11111010b
-10011010b | 11110001b = 11111011b
-10011010b | 11110010b = 11111010b
-10011010b | 11110011b = 11111011b
-10011010b | 11110100b = 11111110b
-10011010b | 11110101b = 11111111b
-10011010b | 11110110b = 11111110b
-10011010b | 11110111b = 11111111b
-10011010b | 11111000b = 11111010b
-10011010b | 11111001b = 11111011b
-10011010b | 11111010b = 11111010b
-10011010b | 11111011b = 11111011b
-10011010b | 11111100b = 11111110b
-10011010b | 11111101b = 11111111b
-10011010b | 11111110b = 11111110b
-10011010b | 11111111b = 11111111b
-10011010b | 00000000b = 10011010b
-10011010b | 00000001b = 10011011b
-10011010b | 00000010b = 10011010b
-10011010b | 00000011b = 10011011b
-10011010b | 00000100b = 10011110b
-10011010b | 00000101b = 10011111b
-10011010b | 00000110b = 10011110b
-10011010b | 00000111b = 10011111b
-10011010b | 00001000b = 10011010b
-10011010b | 00001001b = 10011011b
-10011010b | 00001010b = 10011010b
-10011010b | 00001011b = 10011011b
-10011010b | 00001100b = 10011110b
-10011010b | 00001101b = 10011111b
-10011010b | 00001110b = 10011110b
-10011010b | 00001111b = 10011111b
-10011010b | 00010000b = 10011010b
-10011010b | 00010001b = 10011011b
-10011010b | 00010010b = 10011010b
-10011010b | 00010011b = 10011011b
-10011010b | 00010100b = 10011110b
-10011010b | 00010101b = 10011111b
-10011010b | 00010110b = 10011110b
-10011010b | 00010111b = 10011111b
-10011010b | 00011000b = 10011010b
-10011010b | 00011001b = 10011011b
-10011010b | 00011010b = 10011010b
-10011010b | 00011011b = 10011011b
-10011010b | 00011100b = 10011110b
-10011010b | 00011101b = 10011111b
-10011010b | 00011110b = 10011110b
-10011010b | 00011111b = 10011111b
-10011010b | 00100000b = 10111010b
-10011010b | 00100001b = 10111011b
-10011010b | 00100010b = 10111010b
-10011010b | 00100011b = 10111011b
-10011010b | 00100100b = 10111110b
-10011010b | 00100101b = 10111111b
-10011010b | 00100110b = 10111110b
-10011010b | 00100111b = 10111111b
-10011010b | 00101000b = 10111010b
-10011010b | 00101001b = 10111011b
-10011010b | 00101010b = 10111010b
-10011010b | 00101011b = 10111011b
-10011010b | 00101100b = 10111110b
-10011010b | 00101101b = 10111111b
-10011010b | 00101110b = 10111110b
-10011010b | 00101111b = 10111111b
-10011010b | 00110000b = 10111010b
-10011010b | 00110001b = 10111011b
-10011010b | 00110010b = 10111010b
-10011010b | 00110011b = 10111011b
-10011010b | 00110100b = 10111110b
-10011010b | 00110101b = 10111111b
-10011010b | 00110110b = 10111110b
-10011010b | 00110111b = 10111111b
-10011010b | 00111000b = 10111010b
-10011010b | 00111001b = 10111011b
-10011010b | 00111010b = 10111010b
-10011010b | 00111011b = 10111011b
-10011010b | 00111100b = 10111110b
-10011010b | 00111101b = 10111111b
-10011010b | 00111110b = 10111110b
-10011010b | 00111111b = 10111111b
-10011010b | 01000000b = 11011010b
-10011010b | 01000001b = 11011011b
-10011010b | 01000010b = 11011010b
-10011010b | 01000011b = 11011011b
-10011010b | 01000100b = 11011110b
-10011010b | 01000101b = 11011111b
-10011010b | 01000110b = 11011110b
-10011010b | 01000111b = 11011111b
-10011010b | 01001000b = 11011010b
-10011010b | 01001001b = 11011011b
-10011010b | 01001010b = 11011010b
-10011010b | 01001011b = 11011011b
-10011010b | 01001100b = 11011110b
-10011010b | 01001101b = 11011111b
-10011010b | 01001110b = 11011110b
-10011010b | 01001111b = 11011111b
-10011010b | 01010000b = 11011010b
-10011010b | 01010001b = 11011011b
-10011010b | 01010010b = 11011010b
-10011010b | 01010011b = 11011011b
-10011010b | 01010100b = 11011110b
-10011010b | 01010101b = 11011111b
-10011010b | 01010110b = 11011110b
-10011010b | 01010111b = 11011111b
-10011010b | 01011000b = 11011010b
-10011010b | 01011001b = 11011011b
-10011010b | 01011010b = 11011010b
-10011010b | 01011011b = 11011011b
-10011010b | 01011100b = 11011110b
-10011010b | 01011101b = 11011111b
-10011010b | 01011110b = 11011110b
-10011010b | 01011111b = 11011111b
-10011010b | 01100000b = 11111010b
-10011010b | 01100001b = 11111011b
-10011010b | 01100010b = 11111010b
-10011010b | 01100011b = 11111011b
-10011010b | 01100100b = 11111110b
-10011010b | 01100101b = 11111111b
-10011010b | 01100110b = 11111110b
-10011010b | 01100111b = 11111111b
-10011010b | 01101000b = 11111010b
-10011010b | 01101001b = 11111011b
-10011010b | 01101010b = 11111010b
-10011010b | 01101011b = 11111011b
-10011010b | 01101100b = 11111110b
-10011010b | 01101101b = 11111111b
-10011010b | 01101110b = 11111110b
-10011010b | 01101111b = 11111111b
-10011010b | 01110000b = 11111010b
-10011010b | 01110001b = 11111011b
-10011010b | 01110010b = 11111010b
-10011010b | 01110011b = 11111011b
-10011010b | 01110100b = 11111110b
-10011010b | 01110101b = 11111111b
-10011010b | 01110110b = 11111110b
-10011010b | 01110111b = 11111111b
-10011010b | 01111000b = 11111010b
-10011010b | 01111001b = 11111011b
-10011010b | 01111010b = 11111010b
-10011010b | 01111011b = 11111011b
-10011010b | 01111100b = 11111110b
-10011010b | 01111101b = 11111111b
-10011010b | 01111110b = 11111110b
-10011011b | 10000000b = 10011011b
-10011011b | 10000001b = 10011011b
-10011011b | 10000010b = 10011011b
-10011011b | 10000011b = 10011011b
-10011011b | 10000100b = 10011111b
-10011011b | 10000101b = 10011111b
-10011011b | 10000110b = 10011111b
-10011011b | 10000111b = 10011111b
-10011011b | 10001000b = 10011011b
-10011011b | 10001001b = 10011011b
-10011011b | 10001010b = 10011011b
-10011011b | 10001011b = 10011011b
-10011011b | 10001100b = 10011111b
-10011011b | 10001101b = 10011111b
-10011011b | 10001110b = 10011111b
-10011011b | 10001111b = 10011111b
-10011011b | 10010000b = 10011011b
-10011011b | 10010001b = 10011011b
-10011011b | 10010010b = 10011011b
-10011011b | 10010011b = 10011011b
-10011011b | 10010100b = 10011111b
-10011011b | 10010101b = 10011111b
-10011011b | 10010110b = 10011111b
-10011011b | 10010111b = 10011111b
-10011011b | 10011000b = 10011011b
-10011011b | 10011001b = 10011011b
-10011011b | 10011010b = 10011011b
-10011011b | 10011011b = 10011011b
-10011011b | 10011100b = 10011111b
-10011011b | 10011101b = 10011111b
-10011011b | 10011110b = 10011111b
-10011011b | 10011111b = 10011111b
-10011011b | 10100000b = 10111011b
-10011011b | 10100001b = 10111011b
-10011011b | 10100010b = 10111011b
-10011011b | 10100011b = 10111011b
-10011011b | 10100100b = 10111111b
-10011011b | 10100101b = 10111111b
-10011011b | 10100110b = 10111111b
-10011011b | 10100111b = 10111111b
-10011011b | 10101000b = 10111011b
-10011011b | 10101001b = 10111011b
-10011011b | 10101010b = 10111011b
-10011011b | 10101011b = 10111011b
-10011011b | 10101100b = 10111111b
-10011011b | 10101101b = 10111111b
-10011011b | 10101110b = 10111111b
-10011011b | 10101111b = 10111111b
-10011011b | 10110000b = 10111011b
-10011011b | 10110001b = 10111011b
-10011011b | 10110010b = 10111011b
-10011011b | 10110011b = 10111011b
-10011011b | 10110100b = 10111111b
-10011011b | 10110101b = 10111111b
-10011011b | 10110110b = 10111111b
-10011011b | 10110111b = 10111111b
-10011011b | 10111000b = 10111011b
-10011011b | 10111001b = 10111011b
-10011011b | 10111010b = 10111011b
-10011011b | 10111011b = 10111011b
-10011011b | 10111100b = 10111111b
-10011011b | 10111101b = 10111111b
-10011011b | 10111110b = 10111111b
-10011011b | 10111111b = 10111111b
-10011011b | 11000000b = 11011011b
-10011011b | 11000001b = 11011011b
-10011011b | 11000010b = 11011011b
-10011011b | 11000011b = 11011011b
-10011011b | 11000100b = 11011111b
-10011011b | 11000101b = 11011111b
-10011011b | 11000110b = 11011111b
-10011011b | 11000111b = 11011111b
-10011011b | 11001000b = 11011011b
-10011011b | 11001001b = 11011011b
-10011011b | 11001010b = 11011011b
-10011011b | 11001011b = 11011011b
-10011011b | 11001100b = 11011111b
-10011011b | 11001101b = 11011111b
-10011011b | 11001110b = 11011111b
-10011011b | 11001111b = 11011111b
-10011011b | 11010000b = 11011011b
-10011011b | 11010001b = 11011011b
-10011011b | 11010010b = 11011011b
-10011011b | 11010011b = 11011011b
-10011011b | 11010100b = 11011111b
-10011011b | 11010101b = 11011111b
-10011011b | 11010110b = 11011111b
-10011011b | 11010111b = 11011111b
-10011011b | 11011000b = 11011011b
-10011011b | 11011001b = 11011011b
-10011011b | 11011010b = 11011011b
-10011011b | 11011011b = 11011011b
-10011011b | 11011100b = 11011111b
-10011011b | 11011101b = 11011111b
-10011011b | 11011110b = 11011111b
-10011011b | 11011111b = 11011111b
-10011011b | 11100000b = 11111011b
-10011011b | 11100001b = 11111011b
-10011011b | 11100010b = 11111011b
-10011011b | 11100011b = 11111011b
-10011011b | 11100100b = 11111111b
-10011011b | 11100101b = 11111111b
-10011011b | 11100110b = 11111111b
-10011011b | 11100111b = 11111111b
-10011011b | 11101000b = 11111011b
-10011011b | 11101001b = 11111011b
-10011011b | 11101010b = 11111011b
-10011011b | 11101011b = 11111011b
-10011011b | 11101100b = 11111111b
-10011011b | 11101101b = 11111111b
-10011011b | 11101110b = 11111111b
-10011011b | 11101111b = 11111111b
-10011011b | 11110000b = 11111011b
-10011011b | 11110001b = 11111011b
-10011011b | 11110010b = 11111011b
-10011011b | 11110011b = 11111011b
-10011011b | 11110100b = 11111111b
-10011011b | 11110101b = 11111111b
-10011011b | 11110110b = 11111111b
-10011011b | 11110111b = 11111111b
-10011011b | 11111000b = 11111011b
-10011011b | 11111001b = 11111011b
-10011011b | 11111010b = 11111011b
-10011011b | 11111011b = 11111011b
-10011011b | 11111100b = 11111111b
-10011011b | 11111101b = 11111111b
-10011011b | 11111110b = 11111111b
-10011011b | 11111111b = 11111111b
-10011011b | 00000000b = 10011011b
-10011011b | 00000001b = 10011011b
-10011011b | 00000010b = 10011011b
-10011011b | 00000011b = 10011011b
-10011011b | 00000100b = 10011111b
-10011011b | 00000101b = 10011111b
-10011011b | 00000110b = 10011111b
-10011011b | 00000111b = 10011111b
-10011011b | 00001000b = 10011011b
-10011011b | 00001001b = 10011011b
-10011011b | 00001010b = 10011011b
-10011011b | 00001011b = 10011011b
-10011011b | 00001100b = 10011111b
-10011011b | 00001101b = 10011111b
-10011011b | 00001110b = 10011111b
-10011011b | 00001111b = 10011111b
-10011011b | 00010000b = 10011011b
-10011011b | 00010001b = 10011011b
-10011011b | 00010010b = 10011011b
-10011011b | 00010011b = 10011011b
-10011011b | 00010100b = 10011111b
-10011011b | 00010101b = 10011111b
-10011011b | 00010110b = 10011111b
-10011011b | 00010111b = 10011111b
-10011011b | 00011000b = 10011011b
-10011011b | 00011001b = 10011011b
-10011011b | 00011010b = 10011011b
-10011011b | 00011011b = 10011011b
-10011011b | 00011100b = 10011111b
-10011011b | 00011101b = 10011111b
-10011011b | 00011110b = 10011111b
-10011011b | 00011111b = 10011111b
-10011011b | 00100000b = 10111011b
-10011011b | 00100001b = 10111011b
-10011011b | 00100010b = 10111011b
-10011011b | 00100011b = 10111011b
-10011011b | 00100100b = 10111111b
-10011011b | 00100101b = 10111111b
-10011011b | 00100110b = 10111111b
-10011011b | 00100111b = 10111111b
-10011011b | 00101000b = 10111011b
-10011011b | 00101001b = 10111011b
-10011011b | 00101010b = 10111011b
-10011011b | 00101011b = 10111011b
-10011011b | 00101100b = 10111111b
-10011011b | 00101101b = 10111111b
-10011011b | 00101110b = 10111111b
-10011011b | 00101111b = 10111111b
-10011011b | 00110000b = 10111011b
-10011011b | 00110001b = 10111011b
-10011011b | 00110010b = 10111011b
-10011011b | 00110011b = 10111011b
-10011011b | 00110100b = 10111111b
-10011011b | 00110101b = 10111111b
-10011011b | 00110110b = 10111111b
-10011011b | 00110111b = 10111111b
-10011011b | 00111000b = 10111011b
-10011011b | 00111001b = 10111011b
-10011011b | 00111010b = 10111011b
-10011011b | 00111011b = 10111011b
-10011011b | 00111100b = 10111111b
-10011011b | 00111101b = 10111111b
-10011011b | 00111110b = 10111111b
-10011011b | 00111111b = 10111111b
-10011011b | 01000000b = 11011011b
-10011011b | 01000001b = 11011011b
-10011011b | 01000010b = 11011011b
-10011011b | 01000011b = 11011011b
-10011011b | 01000100b = 11011111b
-10011011b | 01000101b = 11011111b
-10011011b | 01000110b = 11011111b
-10011011b | 01000111b = 11011111b
-10011011b | 01001000b = 11011011b
-10011011b | 01001001b = 11011011b
-10011011b | 01001010b = 11011011b
-10011011b | 01001011b = 11011011b
-10011011b | 01001100b = 11011111b
-10011011b | 01001101b = 11011111b
-10011011b | 01001110b = 11011111b
-10011011b | 01001111b = 11011111b
-10011011b | 01010000b = 11011011b
-10011011b | 01010001b = 11011011b
-10011011b | 01010010b = 11011011b
-10011011b | 01010011b = 11011011b
-10011011b | 01010100b = 11011111b
-10011011b | 01010101b = 11011111b
-10011011b | 01010110b = 11011111b
-10011011b | 01010111b = 11011111b
-10011011b | 01011000b = 11011011b
-10011011b | 01011001b = 11011011b
-10011011b | 01011010b = 11011011b
-10011011b | 01011011b = 11011011b
-10011011b | 01011100b = 11011111b
-10011011b | 01011101b = 11011111b
-10011011b | 01011110b = 11011111b
-10011011b | 01011111b = 11011111b
-10011011b | 01100000b = 11111011b
-10011011b | 01100001b = 11111011b
-10011011b | 01100010b = 11111011b
-10011011b | 01100011b = 11111011b
-10011011b | 01100100b = 11111111b
-10011011b | 01100101b = 11111111b
-10011011b | 01100110b = 11111111b
-10011011b | 01100111b = 11111111b
-10011011b | 01101000b = 11111011b
-10011011b | 01101001b = 11111011b
-10011011b | 01101010b = 11111011b
-10011011b | 01101011b = 11111011b
-10011011b | 01101100b = 11111111b
-10011011b | 01101101b = 11111111b
-10011011b | 01101110b = 11111111b
-10011011b | 01101111b = 11111111b
-10011011b | 01110000b = 11111011b
-10011011b | 01110001b = 11111011b
-10011011b | 01110010b = 11111011b
-10011011b | 01110011b = 11111011b
-10011011b | 01110100b = 11111111b
-10011011b | 01110101b = 11111111b
-10011011b | 01110110b = 11111111b
-10011011b | 01110111b = 11111111b
-10011011b | 01111000b = 11111011b
-10011011b | 01111001b = 11111011b
-10011011b | 01111010b = 11111011b
-10011011b | 01111011b = 11111011b
-10011011b | 01111100b = 11111111b
-10011011b | 01111101b = 11111111b
-10011011b | 01111110b = 11111111b
-10011100b | 10000000b = 10011100b
-10011100b | 10000001b = 10011101b
-10011100b | 10000010b = 10011110b
-10011100b | 10000011b = 10011111b
-10011100b | 10000100b = 10011100b
-10011100b | 10000101b = 10011101b
-10011100b | 10000110b = 10011110b
-10011100b | 10000111b = 10011111b
-10011100b | 10001000b = 10011100b
-10011100b | 10001001b = 10011101b
-10011100b | 10001010b = 10011110b
-10011100b | 10001011b = 10011111b
-10011100b | 10001100b = 10011100b
-10011100b | 10001101b = 10011101b
-10011100b | 10001110b = 10011110b
-10011100b | 10001111b = 10011111b
-10011100b | 10010000b = 10011100b
-10011100b | 10010001b = 10011101b
-10011100b | 10010010b = 10011110b
-10011100b | 10010011b = 10011111b
-10011100b | 10010100b = 10011100b
-10011100b | 10010101b = 10011101b
-10011100b | 10010110b = 10011110b
-10011100b | 10010111b = 10011111b
-10011100b | 10011000b = 10011100b
-10011100b | 10011001b = 10011101b
-10011100b | 10011010b = 10011110b
-10011100b | 10011011b = 10011111b
-10011100b | 10011100b = 10011100b
-10011100b | 10011101b = 10011101b
-10011100b | 10011110b = 10011110b
-10011100b | 10011111b = 10011111b
-10011100b | 10100000b = 10111100b
-10011100b | 10100001b = 10111101b
-10011100b | 10100010b = 10111110b
-10011100b | 10100011b = 10111111b
-10011100b | 10100100b = 10111100b
-10011100b | 10100101b = 10111101b
-10011100b | 10100110b = 10111110b
-10011100b | 10100111b = 10111111b
-10011100b | 10101000b = 10111100b
-10011100b | 10101001b = 10111101b
-10011100b | 10101010b = 10111110b
-10011100b | 10101011b = 10111111b
-10011100b | 10101100b = 10111100b
-10011100b | 10101101b = 10111101b
-10011100b | 10101110b = 10111110b
-10011100b | 10101111b = 10111111b
-10011100b | 10110000b = 10111100b
-10011100b | 10110001b = 10111101b
-10011100b | 10110010b = 10111110b
-10011100b | 10110011b = 10111111b
-10011100b | 10110100b = 10111100b
-10011100b | 10110101b = 10111101b
-10011100b | 10110110b = 10111110b
-10011100b | 10110111b = 10111111b
-10011100b | 10111000b = 10111100b
-10011100b | 10111001b = 10111101b
-10011100b | 10111010b = 10111110b
-10011100b | 10111011b = 10111111b
-10011100b | 10111100b = 10111100b
-10011100b | 10111101b = 10111101b
-10011100b | 10111110b = 10111110b
-10011100b | 10111111b = 10111111b
-10011100b | 11000000b = 11011100b
-10011100b | 11000001b = 11011101b
-10011100b | 11000010b = 11011110b
-10011100b | 11000011b = 11011111b
-10011100b | 11000100b = 11011100b
-10011100b | 11000101b = 11011101b
-10011100b | 11000110b = 11011110b
-10011100b | 11000111b = 11011111b
-10011100b | 11001000b = 11011100b
-10011100b | 11001001b = 11011101b
-10011100b | 11001010b = 11011110b
-10011100b | 11001011b = 11011111b
-10011100b | 11001100b = 11011100b
-10011100b | 11001101b = 11011101b
-10011100b | 11001110b = 11011110b
-10011100b | 11001111b = 11011111b
-10011100b | 11010000b = 11011100b
-10011100b | 11010001b = 11011101b
-10011100b | 11010010b = 11011110b
-10011100b | 11010011b = 11011111b
-10011100b | 11010100b = 11011100b
-10011100b | 11010101b = 11011101b
-10011100b | 11010110b = 11011110b
-10011100b | 11010111b = 11011111b
-10011100b | 11011000b = 11011100b
-10011100b | 11011001b = 11011101b
-10011100b | 11011010b = 11011110b
-10011100b | 11011011b = 11011111b
-10011100b | 11011100b = 11011100b
-10011100b | 11011101b = 11011101b
-10011100b | 11011110b = 11011110b
-10011100b | 11011111b = 11011111b
-10011100b | 11100000b = 11111100b
-10011100b | 11100001b = 11111101b
-10011100b | 11100010b = 11111110b
-10011100b | 11100011b = 11111111b
-10011100b | 11100100b = 11111100b
-10011100b | 11100101b = 11111101b
-10011100b | 11100110b = 11111110b
-10011100b | 11100111b = 11111111b
-10011100b | 11101000b = 11111100b
-10011100b | 11101001b = 11111101b
-10011100b | 11101010b = 11111110b
-10011100b | 11101011b = 11111111b
-10011100b | 11101100b = 11111100b
-10011100b | 11101101b = 11111101b
-10011100b | 11101110b = 11111110b
-10011100b | 11101111b = 11111111b
-10011100b | 11110000b = 11111100b
-10011100b | 11110001b = 11111101b
-10011100b | 11110010b = 11111110b
-10011100b | 11110011b = 11111111b
-10011100b | 11110100b = 11111100b
-10011100b | 11110101b = 11111101b
-10011100b | 11110110b = 11111110b
-10011100b | 11110111b = 11111111b
-10011100b | 11111000b = 11111100b
-10011100b | 11111001b = 11111101b
-10011100b | 11111010b = 11111110b
-10011100b | 11111011b = 11111111b
-10011100b | 11111100b = 11111100b
-10011100b | 11111101b = 11111101b
-10011100b | 11111110b = 11111110b
-10011100b | 11111111b = 11111111b
-10011100b | 00000000b = 10011100b
-10011100b | 00000001b = 10011101b
-10011100b | 00000010b = 10011110b
-10011100b | 00000011b = 10011111b
-10011100b | 00000100b = 10011100b
-10011100b | 00000101b = 10011101b
-10011100b | 00000110b = 10011110b
-10011100b | 00000111b = 10011111b
-10011100b | 00001000b = 10011100b
-10011100b | 00001001b = 10011101b
-10011100b | 00001010b = 10011110b
-10011100b | 00001011b = 10011111b
-10011100b | 00001100b = 10011100b
-10011100b | 00001101b = 10011101b
-10011100b | 00001110b = 10011110b
-10011100b | 00001111b = 10011111b
-10011100b | 00010000b = 10011100b
-10011100b | 00010001b = 10011101b
-10011100b | 00010010b = 10011110b
-10011100b | 00010011b = 10011111b
-10011100b | 00010100b = 10011100b
-10011100b | 00010101b = 10011101b
-10011100b | 00010110b = 10011110b
-10011100b | 00010111b = 10011111b
-10011100b | 00011000b = 10011100b
-10011100b | 00011001b = 10011101b
-10011100b | 00011010b = 10011110b
-10011100b | 00011011b = 10011111b
-10011100b | 00011100b = 10011100b
-10011100b | 00011101b = 10011101b
-10011100b | 00011110b = 10011110b
-10011100b | 00011111b = 10011111b
-10011100b | 00100000b = 10111100b
-10011100b | 00100001b = 10111101b
-10011100b | 00100010b = 10111110b
-10011100b | 00100011b = 10111111b
-10011100b | 00100100b = 10111100b
-10011100b | 00100101b = 10111101b
-10011100b | 00100110b = 10111110b
-10011100b | 00100111b = 10111111b
-10011100b | 00101000b = 10111100b
-10011100b | 00101001b = 10111101b
-10011100b | 00101010b = 10111110b
-10011100b | 00101011b = 10111111b
-10011100b | 00101100b = 10111100b
-10011100b | 00101101b = 10111101b
-10011100b | 00101110b = 10111110b
-10011100b | 00101111b = 10111111b
-10011100b | 00110000b = 10111100b
-10011100b | 00110001b = 10111101b
-10011100b | 00110010b = 10111110b
-10011100b | 00110011b = 10111111b
-10011100b | 00110100b = 10111100b
-10011100b | 00110101b = 10111101b
-10011100b | 00110110b = 10111110b
-10011100b | 00110111b = 10111111b
-10011100b | 00111000b = 10111100b
-10011100b | 00111001b = 10111101b
-10011100b | 00111010b = 10111110b
-10011100b | 00111011b = 10111111b
-10011100b | 00111100b = 10111100b
-10011100b | 00111101b = 10111101b
-10011100b | 00111110b = 10111110b
-10011100b | 00111111b = 10111111b
-10011100b | 01000000b = 11011100b
-10011100b | 01000001b = 11011101b
-10011100b | 01000010b = 11011110b
-10011100b | 01000011b = 11011111b
-10011100b | 01000100b = 11011100b
-10011100b | 01000101b = 11011101b
-10011100b | 01000110b = 11011110b
-10011100b | 01000111b = 11011111b
-10011100b | 01001000b = 11011100b
-10011100b | 01001001b = 11011101b
-10011100b | 01001010b = 11011110b
-10011100b | 01001011b = 11011111b
-10011100b | 01001100b = 11011100b
-10011100b | 01001101b = 11011101b
-10011100b | 01001110b = 11011110b
-10011100b | 01001111b = 11011111b
-10011100b | 01010000b = 11011100b
-10011100b | 01010001b = 11011101b
-10011100b | 01010010b = 11011110b
-10011100b | 01010011b = 11011111b
-10011100b | 01010100b = 11011100b
-10011100b | 01010101b = 11011101b
-10011100b | 01010110b = 11011110b
-10011100b | 01010111b = 11011111b
-10011100b | 01011000b = 11011100b
-10011100b | 01011001b = 11011101b
-10011100b | 01011010b = 11011110b
-10011100b | 01011011b = 11011111b
-10011100b | 01011100b = 11011100b
-10011100b | 01011101b = 11011101b
-10011100b | 01011110b = 11011110b
-10011100b | 01011111b = 11011111b
-10011100b | 01100000b = 11111100b
-10011100b | 01100001b = 11111101b
-10011100b | 01100010b = 11111110b
-10011100b | 01100011b = 11111111b
-10011100b | 01100100b = 11111100b
-10011100b | 01100101b = 11111101b
-10011100b | 01100110b = 11111110b
-10011100b | 01100111b = 11111111b
-10011100b | 01101000b = 11111100b
-10011100b | 01101001b = 11111101b
-10011100b | 01101010b = 11111110b
-10011100b | 01101011b = 11111111b
-10011100b | 01101100b = 11111100b
-10011100b | 01101101b = 11111101b
-10011100b | 01101110b = 11111110b
-10011100b | 01101111b = 11111111b
-10011100b | 01110000b = 11111100b
-10011100b | 01110001b = 11111101b
-10011100b | 01110010b = 11111110b
-10011100b | 01110011b = 11111111b
-10011100b | 01110100b = 11111100b
-10011100b | 01110101b = 11111101b
-10011100b | 01110110b = 11111110b
-10011100b | 01110111b = 11111111b
-10011100b | 01111000b = 11111100b
-10011100b | 01111001b = 11111101b
-10011100b | 01111010b = 11111110b
-10011100b | 01111011b = 11111111b
-10011100b | 01111100b = 11111100b
-10011100b | 01111101b = 11111101b
-10011100b | 01111110b = 11111110b
-10011101b | 10000000b = 10011101b
-10011101b | 10000001b = 10011101b
-10011101b | 10000010b = 10011111b
-10011101b | 10000011b = 10011111b
-10011101b | 10000100b = 10011101b
-10011101b | 10000101b = 10011101b
-10011101b | 10000110b = 10011111b
-10011101b | 10000111b = 10011111b
-10011101b | 10001000b = 10011101b
-10011101b | 10001001b = 10011101b
-10011101b | 10001010b = 10011111b
-10011101b | 10001011b = 10011111b
-10011101b | 10001100b = 10011101b
-10011101b | 10001101b = 10011101b
-10011101b | 10001110b = 10011111b
-10011101b | 10001111b = 10011111b
-10011101b | 10010000b = 10011101b
-10011101b | 10010001b = 10011101b
-10011101b | 10010010b = 10011111b
-10011101b | 10010011b = 10011111b
-10011101b | 10010100b = 10011101b
-10011101b | 10010101b = 10011101b
-10011101b | 10010110b = 10011111b
-10011101b | 10010111b = 10011111b
-10011101b | 10011000b = 10011101b
-10011101b | 10011001b = 10011101b
-10011101b | 10011010b = 10011111b
-10011101b | 10011011b = 10011111b
-10011101b | 10011100b = 10011101b
-10011101b | 10011101b = 10011101b
-10011101b | 10011110b = 10011111b
-10011101b | 10011111b = 10011111b
-10011101b | 10100000b = 10111101b
-10011101b | 10100001b = 10111101b
-10011101b | 10100010b = 10111111b
-10011101b | 10100011b = 10111111b
-10011101b | 10100100b = 10111101b
-10011101b | 10100101b = 10111101b
-10011101b | 10100110b = 10111111b
-10011101b | 10100111b = 10111111b
-10011101b | 10101000b = 10111101b
-10011101b | 10101001b = 10111101b
-10011101b | 10101010b = 10111111b
-10011101b | 10101011b = 10111111b
-10011101b | 10101100b = 10111101b
-10011101b | 10101101b = 10111101b
-10011101b | 10101110b = 10111111b
-10011101b | 10101111b = 10111111b
-10011101b | 10110000b = 10111101b
-10011101b | 10110001b = 10111101b
-10011101b | 10110010b = 10111111b
-10011101b | 10110011b = 10111111b
-10011101b | 10110100b = 10111101b
-10011101b | 10110101b = 10111101b
-10011101b | 10110110b = 10111111b
-10011101b | 10110111b = 10111111b
-10011101b | 10111000b = 10111101b
-10011101b | 10111001b = 10111101b
-10011101b | 10111010b = 10111111b
-10011101b | 10111011b = 10111111b
-10011101b | 10111100b = 10111101b
-10011101b | 10111101b = 10111101b
-10011101b | 10111110b = 10111111b
-10011101b | 10111111b = 10111111b
-10011101b | 11000000b = 11011101b
-10011101b | 11000001b = 11011101b
-10011101b | 11000010b = 11011111b
-10011101b | 11000011b = 11011111b
-10011101b | 11000100b = 11011101b
-10011101b | 11000101b = 11011101b
-10011101b | 11000110b = 11011111b
-10011101b | 11000111b = 11011111b
-10011101b | 11001000b = 11011101b
-10011101b | 11001001b = 11011101b
-10011101b | 11001010b = 11011111b
-10011101b | 11001011b = 11011111b
-10011101b | 11001100b = 11011101b
-10011101b | 11001101b = 11011101b
-10011101b | 11001110b = 11011111b
-10011101b | 11001111b = 11011111b
-10011101b | 11010000b = 11011101b
-10011101b | 11010001b = 11011101b
-10011101b | 11010010b = 11011111b
-10011101b | 11010011b = 11011111b
-10011101b | 11010100b = 11011101b
-10011101b | 11010101b = 11011101b
-10011101b | 11010110b = 11011111b
-10011101b | 11010111b = 11011111b
-10011101b | 11011000b = 11011101b
-10011101b | 11011001b = 11011101b
-10011101b | 11011010b = 11011111b
-10011101b | 11011011b = 11011111b
-10011101b | 11011100b = 11011101b
-10011101b | 11011101b = 11011101b
-10011101b | 11011110b = 11011111b
-10011101b | 11011111b = 11011111b
-10011101b | 11100000b = 11111101b
-10011101b | 11100001b = 11111101b
-10011101b | 11100010b = 11111111b
-10011101b | 11100011b = 11111111b
-10011101b | 11100100b = 11111101b
-10011101b | 11100101b = 11111101b
-10011101b | 11100110b = 11111111b
-10011101b | 11100111b = 11111111b
-10011101b | 11101000b = 11111101b
-10011101b | 11101001b = 11111101b
-10011101b | 11101010b = 11111111b
-10011101b | 11101011b = 11111111b
-10011101b | 11101100b = 11111101b
-10011101b | 11101101b = 11111101b
-10011101b | 11101110b = 11111111b
-10011101b | 11101111b = 11111111b
-10011101b | 11110000b = 11111101b
-10011101b | 11110001b = 11111101b
-10011101b | 11110010b = 11111111b
-10011101b | 11110011b = 11111111b
-10011101b | 11110100b = 11111101b
-10011101b | 11110101b = 11111101b
-10011101b | 11110110b = 11111111b
-10011101b | 11110111b = 11111111b
-10011101b | 11111000b = 11111101b
-10011101b | 11111001b = 11111101b
-10011101b | 11111010b = 11111111b
-10011101b | 11111011b = 11111111b
-10011101b | 11111100b = 11111101b
-10011101b | 11111101b = 11111101b
-10011101b | 11111110b = 11111111b
-10011101b | 11111111b = 11111111b
-10011101b | 00000000b = 10011101b
-10011101b | 00000001b = 10011101b
-10011101b | 00000010b = 10011111b
-10011101b | 00000011b = 10011111b
-10011101b | 00000100b = 10011101b
-10011101b | 00000101b = 10011101b
-10011101b | 00000110b = 10011111b
-10011101b | 00000111b = 10011111b
-10011101b | 00001000b = 10011101b
-10011101b | 00001001b = 10011101b
-10011101b | 00001010b = 10011111b
-10011101b | 00001011b = 10011111b
-10011101b | 00001100b = 10011101b
-10011101b | 00001101b = 10011101b
-10011101b | 00001110b = 10011111b
-10011101b | 00001111b = 10011111b
-10011101b | 00010000b = 10011101b
-10011101b | 00010001b = 10011101b
-10011101b | 00010010b = 10011111b
-10011101b | 00010011b = 10011111b
-10011101b | 00010100b = 10011101b
-10011101b | 00010101b = 10011101b
-10011101b | 00010110b = 10011111b
-10011101b | 00010111b = 10011111b
-10011101b | 00011000b = 10011101b
-10011101b | 00011001b = 10011101b
-10011101b | 00011010b = 10011111b
-10011101b | 00011011b = 10011111b
-10011101b | 00011100b = 10011101b
-10011101b | 00011101b = 10011101b
-10011101b | 00011110b = 10011111b
-10011101b | 00011111b = 10011111b
-10011101b | 00100000b = 10111101b
-10011101b | 00100001b = 10111101b
-10011101b | 00100010b = 10111111b
-10011101b | 00100011b = 10111111b
-10011101b | 00100100b = 10111101b
-10011101b | 00100101b = 10111101b
-10011101b | 00100110b = 10111111b
-10011101b | 00100111b = 10111111b
-10011101b | 00101000b = 10111101b
-10011101b | 00101001b = 10111101b
-10011101b | 00101010b = 10111111b
-10011101b | 00101011b = 10111111b
-10011101b | 00101100b = 10111101b
-10011101b | 00101101b = 10111101b
-10011101b | 00101110b = 10111111b
-10011101b | 00101111b = 10111111b
-10011101b | 00110000b = 10111101b
-10011101b | 00110001b = 10111101b
-10011101b | 00110010b = 10111111b
-10011101b | 00110011b = 10111111b
-10011101b | 00110100b = 10111101b
-10011101b | 00110101b = 10111101b
-10011101b | 00110110b = 10111111b
-10011101b | 00110111b = 10111111b
-10011101b | 00111000b = 10111101b
-10011101b | 00111001b = 10111101b
-10011101b | 00111010b = 10111111b
-10011101b | 00111011b = 10111111b
-10011101b | 00111100b = 10111101b
-10011101b | 00111101b = 10111101b
-10011101b | 00111110b = 10111111b
-10011101b | 00111111b = 10111111b
-10011101b | 01000000b = 11011101b
-10011101b | 01000001b = 11011101b
-10011101b | 01000010b = 11011111b
-10011101b | 01000011b = 11011111b
-10011101b | 01000100b = 11011101b
-10011101b | 01000101b = 11011101b
-10011101b | 01000110b = 11011111b
-10011101b | 01000111b = 11011111b
-10011101b | 01001000b = 11011101b
-10011101b | 01001001b = 11011101b
-10011101b | 01001010b = 11011111b
-10011101b | 01001011b = 11011111b
-10011101b | 01001100b = 11011101b
-10011101b | 01001101b = 11011101b
-10011101b | 01001110b = 11011111b
-10011101b | 01001111b = 11011111b
-10011101b | 01010000b = 11011101b
-10011101b | 01010001b = 11011101b
-10011101b | 01010010b = 11011111b
-10011101b | 01010011b = 11011111b
-10011101b | 01010100b = 11011101b
-10011101b | 01010101b = 11011101b
-10011101b | 01010110b = 11011111b
-10011101b | 01010111b = 11011111b
-10011101b | 01011000b = 11011101b
-10011101b | 01011001b = 11011101b
-10011101b | 01011010b = 11011111b
-10011101b | 01011011b = 11011111b
-10011101b | 01011100b = 11011101b
-10011101b | 01011101b = 11011101b
-10011101b | 01011110b = 11011111b
-10011101b | 01011111b = 11011111b
-10011101b | 01100000b = 11111101b
-10011101b | 01100001b = 11111101b
-10011101b | 01100010b = 11111111b
-10011101b | 01100011b = 11111111b
-10011101b | 01100100b = 11111101b
-10011101b | 01100101b = 11111101b
-10011101b | 01100110b = 11111111b
-10011101b | 01100111b = 11111111b
-10011101b | 01101000b = 11111101b
-10011101b | 01101001b = 11111101b
-10011101b | 01101010b = 11111111b
-10011101b | 01101011b = 11111111b
-10011101b | 01101100b = 11111101b
-10011101b | 01101101b = 11111101b
-10011101b | 01101110b = 11111111b
-10011101b | 01101111b = 11111111b
-10011101b | 01110000b = 11111101b
-10011101b | 01110001b = 11111101b
-10011101b | 01110010b = 11111111b
-10011101b | 01110011b = 11111111b
-10011101b | 01110100b = 11111101b
-10011101b | 01110101b = 11111101b
-10011101b | 01110110b = 11111111b
-10011101b | 01110111b = 11111111b
-10011101b | 01111000b = 11111101b
-10011101b | 01111001b = 11111101b
-10011101b | 01111010b = 11111111b
-10011101b | 01111011b = 11111111b
-10011101b | 01111100b = 11111101b
-10011101b | 01111101b = 11111101b
-10011101b | 01111110b = 11111111b
-10011110b | 10000000b = 10011110b
-10011110b | 10000001b = 10011111b
-10011110b | 10000010b = 10011110b
-10011110b | 10000011b = 10011111b
-10011110b | 10000100b = 10011110b
-10011110b | 10000101b = 10011111b
-10011110b | 10000110b = 10011110b
-10011110b | 10000111b = 10011111b
-10011110b | 10001000b = 10011110b
-10011110b | 10001001b = 10011111b
-10011110b | 10001010b = 10011110b
-10011110b | 10001011b = 10011111b
-10011110b | 10001100b = 10011110b
-10011110b | 10001101b = 10011111b
-10011110b | 10001110b = 10011110b
-10011110b | 10001111b = 10011111b
-10011110b | 10010000b = 10011110b
-10011110b | 10010001b = 10011111b
-10011110b | 10010010b = 10011110b
-10011110b | 10010011b = 10011111b
-10011110b | 10010100b = 10011110b
-10011110b | 10010101b = 10011111b
-10011110b | 10010110b = 10011110b
-10011110b | 10010111b = 10011111b
-10011110b | 10011000b = 10011110b
-10011110b | 10011001b = 10011111b
-10011110b | 10011010b = 10011110b
-10011110b | 10011011b = 10011111b
-10011110b | 10011100b = 10011110b
-10011110b | 10011101b = 10011111b
-10011110b | 10011110b = 10011110b
-10011110b | 10011111b = 10011111b
-10011110b | 10100000b = 10111110b
-10011110b | 10100001b = 10111111b
-10011110b | 10100010b = 10111110b
-10011110b | 10100011b = 10111111b
-10011110b | 10100100b = 10111110b
-10011110b | 10100101b = 10111111b
-10011110b | 10100110b = 10111110b
-10011110b | 10100111b = 10111111b
-10011110b | 10101000b = 10111110b
-10011110b | 10101001b = 10111111b
-10011110b | 10101010b = 10111110b
-10011110b | 10101011b = 10111111b
-10011110b | 10101100b = 10111110b
-10011110b | 10101101b = 10111111b
-10011110b | 10101110b = 10111110b
-10011110b | 10101111b = 10111111b
-10011110b | 10110000b = 10111110b
-10011110b | 10110001b = 10111111b
-10011110b | 10110010b = 10111110b
-10011110b | 10110011b = 10111111b
-10011110b | 10110100b = 10111110b
-10011110b | 10110101b = 10111111b
-10011110b | 10110110b = 10111110b
-10011110b | 10110111b = 10111111b
-10011110b | 10111000b = 10111110b
-10011110b | 10111001b = 10111111b
-10011110b | 10111010b = 10111110b
-10011110b | 10111011b = 10111111b
-10011110b | 10111100b = 10111110b
-10011110b | 10111101b = 10111111b
-10011110b | 10111110b = 10111110b
-10011110b | 10111111b = 10111111b
-10011110b | 11000000b = 11011110b
-10011110b | 11000001b = 11011111b
-10011110b | 11000010b = 11011110b
-10011110b | 11000011b = 11011111b
-10011110b | 11000100b = 11011110b
-10011110b | 11000101b = 11011111b
-10011110b | 11000110b = 11011110b
-10011110b | 11000111b = 11011111b
-10011110b | 11001000b = 11011110b
-10011110b | 11001001b = 11011111b
-10011110b | 11001010b = 11011110b
-10011110b | 11001011b = 11011111b
-10011110b | 11001100b = 11011110b
-10011110b | 11001101b = 11011111b
-10011110b | 11001110b = 11011110b
-10011110b | 11001111b = 11011111b
-10011110b | 11010000b = 11011110b
-10011110b | 11010001b = 11011111b
-10011110b | 11010010b = 11011110b
-10011110b | 11010011b = 11011111b
-10011110b | 11010100b = 11011110b
-10011110b | 11010101b = 11011111b
-10011110b | 11010110b = 11011110b
-10011110b | 11010111b = 11011111b
-10011110b | 11011000b = 11011110b
-10011110b | 11011001b = 11011111b
-10011110b | 11011010b = 11011110b
-10011110b | 11011011b = 11011111b
-10011110b | 11011100b = 11011110b
-10011110b | 11011101b = 11011111b
-10011110b | 11011110b = 11011110b
-10011110b | 11011111b = 11011111b
-10011110b | 11100000b = 11111110b
-10011110b | 11100001b = 11111111b
-10011110b | 11100010b = 11111110b
-10011110b | 11100011b = 11111111b
-10011110b | 11100100b = 11111110b
-10011110b | 11100101b = 11111111b
-10011110b | 11100110b = 11111110b
-10011110b | 11100111b = 11111111b
-10011110b | 11101000b = 11111110b
-10011110b | 11101001b = 11111111b
-10011110b | 11101010b = 11111110b
-10011110b | 11101011b = 11111111b
-10011110b | 11101100b = 11111110b
-10011110b | 11101101b = 11111111b
-10011110b | 11101110b = 11111110b
-10011110b | 11101111b = 11111111b
-10011110b | 11110000b = 11111110b
-10011110b | 11110001b = 11111111b
-10011110b | 11110010b = 11111110b
-10011110b | 11110011b = 11111111b
-10011110b | 11110100b = 11111110b
-10011110b | 11110101b = 11111111b
-10011110b | 11110110b = 11111110b
-10011110b | 11110111b = 11111111b
-10011110b | 11111000b = 11111110b
-10011110b | 11111001b = 11111111b
-10011110b | 11111010b = 11111110b
-10011110b | 11111011b = 11111111b
-10011110b | 11111100b = 11111110b
-10011110b | 11111101b = 11111111b
-10011110b | 11111110b = 11111110b
-10011110b | 11111111b = 11111111b
-10011110b | 00000000b = 10011110b
-10011110b | 00000001b = 10011111b
-10011110b | 00000010b = 10011110b
-10011110b | 00000011b = 10011111b
-10011110b | 00000100b = 10011110b
-10011110b | 00000101b = 10011111b
-10011110b | 00000110b = 10011110b
-10011110b | 00000111b = 10011111b
-10011110b | 00001000b = 10011110b
-10011110b | 00001001b = 10011111b
-10011110b | 00001010b = 10011110b
-10011110b | 00001011b = 10011111b
-10011110b | 00001100b = 10011110b
-10011110b | 00001101b = 10011111b
-10011110b | 00001110b = 10011110b
-10011110b | 00001111b = 10011111b
-10011110b | 00010000b = 10011110b
-10011110b | 00010001b = 10011111b
-10011110b | 00010010b = 10011110b
-10011110b | 00010011b = 10011111b
-10011110b | 00010100b = 10011110b
-10011110b | 00010101b = 10011111b
-10011110b | 00010110b = 10011110b
-10011110b | 00010111b = 10011111b
-10011110b | 00011000b = 10011110b
-10011110b | 00011001b = 10011111b
-10011110b | 00011010b = 10011110b
-10011110b | 00011011b = 10011111b
-10011110b | 00011100b = 10011110b
-10011110b | 00011101b = 10011111b
-10011110b | 00011110b = 10011110b
-10011110b | 00011111b = 10011111b
-10011110b | 00100000b = 10111110b
-10011110b | 00100001b = 10111111b
-10011110b | 00100010b = 10111110b
-10011110b | 00100011b = 10111111b
-10011110b | 00100100b = 10111110b
-10011110b | 00100101b = 10111111b
-10011110b | 00100110b = 10111110b
-10011110b | 00100111b = 10111111b
-10011110b | 00101000b = 10111110b
-10011110b | 00101001b = 10111111b
-10011110b | 00101010b = 10111110b
-10011110b | 00101011b = 10111111b
-10011110b | 00101100b = 10111110b
-10011110b | 00101101b = 10111111b
-10011110b | 00101110b = 10111110b
-10011110b | 00101111b = 10111111b
-10011110b | 00110000b = 10111110b
-10011110b | 00110001b = 10111111b
-10011110b | 00110010b = 10111110b
-10011110b | 00110011b = 10111111b
-10011110b | 00110100b = 10111110b
-10011110b | 00110101b = 10111111b
-10011110b | 00110110b = 10111110b
-10011110b | 00110111b = 10111111b
-10011110b | 00111000b = 10111110b
-10011110b | 00111001b = 10111111b
-10011110b | 00111010b = 10111110b
-10011110b | 00111011b = 10111111b
-10011110b | 00111100b = 10111110b
-10011110b | 00111101b = 10111111b
-10011110b | 00111110b = 10111110b
-10011110b | 00111111b = 10111111b
-10011110b | 01000000b = 11011110b
-10011110b | 01000001b = 11011111b
-10011110b | 01000010b = 11011110b
-10011110b | 01000011b = 11011111b
-10011110b | 01000100b = 11011110b
-10011110b | 01000101b = 11011111b
-10011110b | 01000110b = 11011110b
-10011110b | 01000111b = 11011111b
-10011110b | 01001000b = 11011110b
-10011110b | 01001001b = 11011111b
-10011110b | 01001010b = 11011110b
-10011110b | 01001011b = 11011111b
-10011110b | 01001100b = 11011110b
-10011110b | 01001101b = 11011111b
-10011110b | 01001110b = 11011110b
-10011110b | 01001111b = 11011111b
-10011110b | 01010000b = 11011110b
-10011110b | 01010001b = 11011111b
-10011110b | 01010010b = 11011110b
-10011110b | 01010011b = 11011111b
-10011110b | 01010100b = 11011110b
-10011110b | 01010101b = 11011111b
-10011110b | 01010110b = 11011110b
-10011110b | 01010111b = 11011111b
-10011110b | 01011000b = 11011110b
-10011110b | 01011001b = 11011111b
-10011110b | 01011010b = 11011110b
-10011110b | 01011011b = 11011111b
-10011110b | 01011100b = 11011110b
-10011110b | 01011101b = 11011111b
-10011110b | 01011110b = 11011110b
-10011110b | 01011111b = 11011111b
-10011110b | 01100000b = 11111110b
-10011110b | 01100001b = 11111111b
-10011110b | 01100010b = 11111110b
-10011110b | 01100011b = 11111111b
-10011110b | 01100100b = 11111110b
-10011110b | 01100101b = 11111111b
-10011110b | 01100110b = 11111110b
-10011110b | 01100111b = 11111111b
-10011110b | 01101000b = 11111110b
-10011110b | 01101001b = 11111111b
-10011110b | 01101010b = 11111110b
-10011110b | 01101011b = 11111111b
-10011110b | 01101100b = 11111110b
-10011110b | 01101101b = 11111111b
-10011110b | 01101110b = 11111110b
-10011110b | 01101111b = 11111111b
-10011110b | 01110000b = 11111110b
-10011110b | 01110001b = 11111111b
-10011110b | 01110010b = 11111110b
-10011110b | 01110011b = 11111111b
-10011110b | 01110100b = 11111110b
-10011110b | 01110101b = 11111111b
-10011110b | 01110110b = 11111110b
-10011110b | 01110111b = 11111111b
-10011110b | 01111000b = 11111110b
-10011110b | 01111001b = 11111111b
-10011110b | 01111010b = 11111110b
-10011110b | 01111011b = 11111111b
-10011110b | 01111100b = 11111110b
-10011110b | 01111101b = 11111111b
-10011110b | 01111110b = 11111110b
-10011111b | 10000000b = 10011111b
-10011111b | 10000001b = 10011111b
-10011111b | 10000010b = 10011111b
-10011111b | 10000011b = 10011111b
-10011111b | 10000100b = 10011111b
-10011111b | 10000101b = 10011111b
-10011111b | 10000110b = 10011111b
-10011111b | 10000111b = 10011111b
-10011111b | 10001000b = 10011111b
-10011111b | 10001001b = 10011111b
-10011111b | 10001010b = 10011111b
-10011111b | 10001011b = 10011111b
-10011111b | 10001100b = 10011111b
-10011111b | 10001101b = 10011111b
-10011111b | 10001110b = 10011111b
-10011111b | 10001111b = 10011111b
-10011111b | 10010000b = 10011111b
-10011111b | 10010001b = 10011111b
-10011111b | 10010010b = 10011111b
-10011111b | 10010011b = 10011111b
-10011111b | 10010100b = 10011111b
-10011111b | 10010101b = 10011111b
-10011111b | 10010110b = 10011111b
-10011111b | 10010111b = 10011111b
-10011111b | 10011000b = 10011111b
-10011111b | 10011001b = 10011111b
-10011111b | 10011010b = 10011111b
-10011111b | 10011011b = 10011111b
-10011111b | 10011100b = 10011111b
-10011111b | 10011101b = 10011111b
-10011111b | 10011110b = 10011111b
-10011111b | 10011111b = 10011111b
-10011111b | 10100000b = 10111111b
-10011111b | 10100001b = 10111111b
-10011111b | 10100010b = 10111111b
-10011111b | 10100011b = 10111111b
-10011111b | 10100100b = 10111111b
-10011111b | 10100101b = 10111111b
-10011111b | 10100110b = 10111111b
-10011111b | 10100111b = 10111111b
-10011111b | 10101000b = 10111111b
-10011111b | 10101001b = 10111111b
-10011111b | 10101010b = 10111111b
-10011111b | 10101011b = 10111111b
-10011111b | 10101100b = 10111111b
-10011111b | 10101101b = 10111111b
-10011111b | 10101110b = 10111111b
-10011111b | 10101111b = 10111111b
-10011111b | 10110000b = 10111111b
-10011111b | 10110001b = 10111111b
-10011111b | 10110010b = 10111111b
-10011111b | 10110011b = 10111111b
-10011111b | 10110100b = 10111111b
-10011111b | 10110101b = 10111111b
-10011111b | 10110110b = 10111111b
-10011111b | 10110111b = 10111111b
-10011111b | 10111000b = 10111111b
-10011111b | 10111001b = 10111111b
-10011111b | 10111010b = 10111111b
-10011111b | 10111011b = 10111111b
-10011111b | 10111100b = 10111111b
-10011111b | 10111101b = 10111111b
-10011111b | 10111110b = 10111111b
-10011111b | 10111111b = 10111111b
-10011111b | 11000000b = 11011111b
-10011111b | 11000001b = 11011111b
-10011111b | 11000010b = 11011111b
-10011111b | 11000011b = 11011111b
-10011111b | 11000100b = 11011111b
-10011111b | 11000101b = 11011111b
-10011111b | 11000110b = 11011111b
-10011111b | 11000111b = 11011111b
-10011111b | 11001000b = 11011111b
-10011111b | 11001001b = 11011111b
-10011111b | 11001010b = 11011111b
-10011111b | 11001011b = 11011111b
-10011111b | 11001100b = 11011111b
-10011111b | 11001101b = 11011111b
-10011111b | 11001110b = 11011111b
-10011111b | 11001111b = 11011111b
-10011111b | 11010000b = 11011111b
-10011111b | 11010001b = 11011111b
-10011111b | 11010010b = 11011111b
-10011111b | 11010011b = 11011111b
-10011111b | 11010100b = 11011111b
-10011111b | 11010101b = 11011111b
-10011111b | 11010110b = 11011111b
-10011111b | 11010111b = 11011111b
-10011111b | 11011000b = 11011111b
-10011111b | 11011001b = 11011111b
-10011111b | 11011010b = 11011111b
-10011111b | 11011011b = 11011111b
-10011111b | 11011100b = 11011111b
-10011111b | 11011101b = 11011111b
-10011111b | 11011110b = 11011111b
-10011111b | 11011111b = 11011111b
-10011111b | 11100000b = 11111111b
-10011111b | 11100001b = 11111111b
-10011111b | 11100010b = 11111111b
-10011111b | 11100011b = 11111111b
-10011111b | 11100100b = 11111111b
-10011111b | 11100101b = 11111111b
-10011111b | 11100110b = 11111111b
-10011111b | 11100111b = 11111111b
-10011111b | 11101000b = 11111111b
-10011111b | 11101001b = 11111111b
-10011111b | 11101010b = 11111111b
-10011111b | 11101011b = 11111111b
-10011111b | 11101100b = 11111111b
-10011111b | 11101101b = 11111111b
-10011111b | 11101110b = 11111111b
-10011111b | 11101111b = 11111111b
-10011111b | 11110000b = 11111111b
-10011111b | 11110001b = 11111111b
-10011111b | 11110010b = 11111111b
-10011111b | 11110011b = 11111111b
-10011111b | 11110100b = 11111111b
-10011111b | 11110101b = 11111111b
-10011111b | 11110110b = 11111111b
-10011111b | 11110111b = 11111111b
-10011111b | 11111000b = 11111111b
-10011111b | 11111001b = 11111111b
-10011111b | 11111010b = 11111111b
-10011111b | 11111011b = 11111111b
-10011111b | 11111100b = 11111111b
-10011111b | 11111101b = 11111111b
-10011111b | 11111110b = 11111111b
-10011111b | 11111111b = 11111111b
-10011111b | 00000000b = 10011111b
-10011111b | 00000001b = 10011111b
-10011111b | 00000010b = 10011111b
-10011111b | 00000011b = 10011111b
-10011111b | 00000100b = 10011111b
-10011111b | 00000101b = 10011111b
-10011111b | 00000110b = 10011111b
-10011111b | 00000111b = 10011111b
-10011111b | 00001000b = 10011111b
-10011111b | 00001001b = 10011111b
-10011111b | 00001010b = 10011111b
-10011111b | 00001011b = 10011111b
-10011111b | 00001100b = 10011111b
-10011111b | 00001101b = 10011111b
-10011111b | 00001110b = 10011111b
-10011111b | 00001111b = 10011111b
-10011111b | 00010000b = 10011111b
-10011111b | 00010001b = 10011111b
-10011111b | 00010010b = 10011111b
-10011111b | 00010011b = 10011111b
-10011111b | 00010100b = 10011111b
-10011111b | 00010101b = 10011111b
-10011111b | 00010110b = 10011111b
-10011111b | 00010111b = 10011111b
-10011111b | 00011000b = 10011111b
-10011111b | 00011001b = 10011111b
-10011111b | 00011010b = 10011111b
-10011111b | 00011011b = 10011111b
-10011111b | 00011100b = 10011111b
-10011111b | 00011101b = 10011111b
-10011111b | 00011110b = 10011111b
-10011111b | 00011111b = 10011111b
-10011111b | 00100000b = 10111111b
-10011111b | 00100001b = 10111111b
-10011111b | 00100010b = 10111111b
-10011111b | 00100011b = 10111111b
-10011111b | 00100100b = 10111111b
-10011111b | 00100101b = 10111111b
-10011111b | 00100110b = 10111111b
-10011111b | 00100111b = 10111111b
-10011111b | 00101000b = 10111111b
-10011111b | 00101001b = 10111111b
-10011111b | 00101010b = 10111111b
-10011111b | 00101011b = 10111111b
-10011111b | 00101100b = 10111111b
-10011111b | 00101101b = 10111111b
-10011111b | 00101110b = 10111111b
-10011111b | 00101111b = 10111111b
-10011111b | 00110000b = 10111111b
-10011111b | 00110001b = 10111111b
-10011111b | 00110010b = 10111111b
-10011111b | 00110011b = 10111111b
-10011111b | 00110100b = 10111111b
-10011111b | 00110101b = 10111111b
-10011111b | 00110110b = 10111111b
-10011111b | 00110111b = 10111111b
-10011111b | 00111000b = 10111111b
-10011111b | 00111001b = 10111111b
-10011111b | 00111010b = 10111111b
-10011111b | 00111011b = 10111111b
-10011111b | 00111100b = 10111111b
-10011111b | 00111101b = 10111111b
-10011111b | 00111110b = 10111111b
-10011111b | 00111111b = 10111111b
-10011111b | 01000000b = 11011111b
-10011111b | 01000001b = 11011111b
-10011111b | 01000010b = 11011111b
-10011111b | 01000011b = 11011111b
-10011111b | 01000100b = 11011111b
-10011111b | 01000101b = 11011111b
-10011111b | 01000110b = 11011111b
-10011111b | 01000111b = 11011111b
-10011111b | 01001000b = 11011111b
-10011111b | 01001001b = 11011111b
-10011111b | 01001010b = 11011111b
-10011111b | 01001011b = 11011111b
-10011111b | 01001100b = 11011111b
-10011111b | 01001101b = 11011111b
-10011111b | 01001110b = 11011111b
-10011111b | 01001111b = 11011111b
-10011111b | 01010000b = 11011111b
-10011111b | 01010001b = 11011111b
-10011111b | 01010010b = 11011111b
-10011111b | 01010011b = 11011111b
-10011111b | 01010100b = 11011111b
-10011111b | 01010101b = 11011111b
-10011111b | 01010110b = 11011111b
-10011111b | 01010111b = 11011111b
-10011111b | 01011000b = 11011111b
-10011111b | 01011001b = 11011111b
-10011111b | 01011010b = 11011111b
-10011111b | 01011011b = 11011111b
-10011111b | 01011100b = 11011111b
-10011111b | 01011101b = 11011111b
-10011111b | 01011110b = 11011111b
-10011111b | 01011111b = 11011111b
-10011111b | 01100000b = 11111111b
-10011111b | 01100001b = 11111111b
-10011111b | 01100010b = 11111111b
-10011111b | 01100011b = 11111111b
-10011111b | 01100100b = 11111111b
-10011111b | 01100101b = 11111111b
-10011111b | 01100110b = 11111111b
-10011111b | 01100111b = 11111111b
-10011111b | 01101000b = 11111111b
-10011111b | 01101001b = 11111111b
-10011111b | 01101010b = 11111111b
-10011111b | 01101011b = 11111111b
-10011111b | 01101100b = 11111111b
-10011111b | 01101101b = 11111111b
-10011111b | 01101110b = 11111111b
-10011111b | 01101111b = 11111111b
-10011111b | 01110000b = 11111111b
-10011111b | 01110001b = 11111111b
-10011111b | 01110010b = 11111111b
-10011111b | 01110011b = 11111111b
-10011111b | 01110100b = 11111111b
-10011111b | 01110101b = 11111111b
-10011111b | 01110110b = 11111111b
-10011111b | 01110111b = 11111111b
-10011111b | 01111000b = 11111111b
-10011111b | 01111001b = 11111111b
-10011111b | 01111010b = 11111111b
-10011111b | 01111011b = 11111111b
-10011111b | 01111100b = 11111111b
-10011111b | 01111101b = 11111111b
-10011111b | 01111110b = 11111111b
-10100000b | 10000000b = 10100000b
-10100000b | 10000001b = 10100001b
-10100000b | 10000010b = 10100010b
-10100000b | 10000011b = 10100011b
-10100000b | 10000100b = 10100100b
-10100000b | 10000101b = 10100101b
-10100000b | 10000110b = 10100110b
-10100000b | 10000111b = 10100111b
-10100000b | 10001000b = 10101000b
-10100000b | 10001001b = 10101001b
-10100000b | 10001010b = 10101010b
-10100000b | 10001011b = 10101011b
-10100000b | 10001100b = 10101100b
-10100000b | 10001101b = 10101101b
-10100000b | 10001110b = 10101110b
-10100000b | 10001111b = 10101111b
-10100000b | 10010000b = 10110000b
-10100000b | 10010001b = 10110001b
-10100000b | 10010010b = 10110010b
-10100000b | 10010011b = 10110011b
-10100000b | 10010100b = 10110100b
-10100000b | 10010101b = 10110101b
-10100000b | 10010110b = 10110110b
-10100000b | 10010111b = 10110111b
-10100000b | 10011000b = 10111000b
-10100000b | 10011001b = 10111001b
-10100000b | 10011010b = 10111010b
-10100000b | 10011011b = 10111011b
-10100000b | 10011100b = 10111100b
-10100000b | 10011101b = 10111101b
-10100000b | 10011110b = 10111110b
-10100000b | 10011111b = 10111111b
-10100000b | 10100000b = 10100000b
-10100000b | 10100001b = 10100001b
-10100000b | 10100010b = 10100010b
-10100000b | 10100011b = 10100011b
-10100000b | 10100100b = 10100100b
-10100000b | 10100101b = 10100101b
-10100000b | 10100110b = 10100110b
-10100000b | 10100111b = 10100111b
-10100000b | 10101000b = 10101000b
-10100000b | 10101001b = 10101001b
-10100000b | 10101010b = 10101010b
-10100000b | 10101011b = 10101011b
-10100000b | 10101100b = 10101100b
-10100000b | 10101101b = 10101101b
-10100000b | 10101110b = 10101110b
-10100000b | 10101111b = 10101111b
-10100000b | 10110000b = 10110000b
-10100000b | 10110001b = 10110001b
-10100000b | 10110010b = 10110010b
-10100000b | 10110011b = 10110011b
-10100000b | 10110100b = 10110100b
-10100000b | 10110101b = 10110101b
-10100000b | 10110110b = 10110110b
-10100000b | 10110111b = 10110111b
-10100000b | 10111000b = 10111000b
-10100000b | 10111001b = 10111001b
-10100000b | 10111010b = 10111010b
-10100000b | 10111011b = 10111011b
-10100000b | 10111100b = 10111100b
-10100000b | 10111101b = 10111101b
-10100000b | 10111110b = 10111110b
-10100000b | 10111111b = 10111111b
-10100000b | 11000000b = 11100000b
-10100000b | 11000001b = 11100001b
-10100000b | 11000010b = 11100010b
-10100000b | 11000011b = 11100011b
-10100000b | 11000100b = 11100100b
-10100000b | 11000101b = 11100101b
-10100000b | 11000110b = 11100110b
-10100000b | 11000111b = 11100111b
-10100000b | 11001000b = 11101000b
-10100000b | 11001001b = 11101001b
-10100000b | 11001010b = 11101010b
-10100000b | 11001011b = 11101011b
-10100000b | 11001100b = 11101100b
-10100000b | 11001101b = 11101101b
-10100000b | 11001110b = 11101110b
-10100000b | 11001111b = 11101111b
-10100000b | 11010000b = 11110000b
-10100000b | 11010001b = 11110001b
-10100000b | 11010010b = 11110010b
-10100000b | 11010011b = 11110011b
-10100000b | 11010100b = 11110100b
-10100000b | 11010101b = 11110101b
-10100000b | 11010110b = 11110110b
-10100000b | 11010111b = 11110111b
-10100000b | 11011000b = 11111000b
-10100000b | 11011001b = 11111001b
-10100000b | 11011010b = 11111010b
-10100000b | 11011011b = 11111011b
-10100000b | 11011100b = 11111100b
-10100000b | 11011101b = 11111101b
-10100000b | 11011110b = 11111110b
-10100000b | 11011111b = 11111111b
-10100000b | 11100000b = 11100000b
-10100000b | 11100001b = 11100001b
-10100000b | 11100010b = 11100010b
-10100000b | 11100011b = 11100011b
-10100000b | 11100100b = 11100100b
-10100000b | 11100101b = 11100101b
-10100000b | 11100110b = 11100110b
-10100000b | 11100111b = 11100111b
-10100000b | 11101000b = 11101000b
-10100000b | 11101001b = 11101001b
-10100000b | 11101010b = 11101010b
-10100000b | 11101011b = 11101011b
-10100000b | 11101100b = 11101100b
-10100000b | 11101101b = 11101101b
-10100000b | 11101110b = 11101110b
-10100000b | 11101111b = 11101111b
-10100000b | 11110000b = 11110000b
-10100000b | 11110001b = 11110001b
-10100000b | 11110010b = 11110010b
-10100000b | 11110011b = 11110011b
-10100000b | 11110100b = 11110100b
-10100000b | 11110101b = 11110101b
-10100000b | 11110110b = 11110110b
-10100000b | 11110111b = 11110111b
-10100000b | 11111000b = 11111000b
-10100000b | 11111001b = 11111001b
-10100000b | 11111010b = 11111010b
-10100000b | 11111011b = 11111011b
-10100000b | 11111100b = 11111100b
-10100000b | 11111101b = 11111101b
-10100000b | 11111110b = 11111110b
-10100000b | 11111111b = 11111111b
-10100000b | 00000000b = 10100000b
-10100000b | 00000001b = 10100001b
-10100000b | 00000010b = 10100010b
-10100000b | 00000011b = 10100011b
-10100000b | 00000100b = 10100100b
-10100000b | 00000101b = 10100101b
-10100000b | 00000110b = 10100110b
-10100000b | 00000111b = 10100111b
-10100000b | 00001000b = 10101000b
-10100000b | 00001001b = 10101001b
-10100000b | 00001010b = 10101010b
-10100000b | 00001011b = 10101011b
-10100000b | 00001100b = 10101100b
-10100000b | 00001101b = 10101101b
-10100000b | 00001110b = 10101110b
-10100000b | 00001111b = 10101111b
-10100000b | 00010000b = 10110000b
-10100000b | 00010001b = 10110001b
-10100000b | 00010010b = 10110010b
-10100000b | 00010011b = 10110011b
-10100000b | 00010100b = 10110100b
-10100000b | 00010101b = 10110101b
-10100000b | 00010110b = 10110110b
-10100000b | 00010111b = 10110111b
-10100000b | 00011000b = 10111000b
-10100000b | 00011001b = 10111001b
-10100000b | 00011010b = 10111010b
-10100000b | 00011011b = 10111011b
-10100000b | 00011100b = 10111100b
-10100000b | 00011101b = 10111101b
-10100000b | 00011110b = 10111110b
-10100000b | 00011111b = 10111111b
-10100000b | 00100000b = 10100000b
-10100000b | 00100001b = 10100001b
-10100000b | 00100010b = 10100010b
-10100000b | 00100011b = 10100011b
-10100000b | 00100100b = 10100100b
-10100000b | 00100101b = 10100101b
-10100000b | 00100110b = 10100110b
-10100000b | 00100111b = 10100111b
-10100000b | 00101000b = 10101000b
-10100000b | 00101001b = 10101001b
-10100000b | 00101010b = 10101010b
-10100000b | 00101011b = 10101011b
-10100000b | 00101100b = 10101100b
-10100000b | 00101101b = 10101101b
-10100000b | 00101110b = 10101110b
-10100000b | 00101111b = 10101111b
-10100000b | 00110000b = 10110000b
-10100000b | 00110001b = 10110001b
-10100000b | 00110010b = 10110010b
-10100000b | 00110011b = 10110011b
-10100000b | 00110100b = 10110100b
-10100000b | 00110101b = 10110101b
-10100000b | 00110110b = 10110110b
-10100000b | 00110111b = 10110111b
-10100000b | 00111000b = 10111000b
-10100000b | 00111001b = 10111001b
-10100000b | 00111010b = 10111010b
-10100000b | 00111011b = 10111011b
-10100000b | 00111100b = 10111100b
-10100000b | 00111101b = 10111101b
-10100000b | 00111110b = 10111110b
-10100000b | 00111111b = 10111111b
-10100000b | 01000000b = 11100000b
-10100000b | 01000001b = 11100001b
-10100000b | 01000010b = 11100010b
-10100000b | 01000011b = 11100011b
-10100000b | 01000100b = 11100100b
-10100000b | 01000101b = 11100101b
-10100000b | 01000110b = 11100110b
-10100000b | 01000111b = 11100111b
-10100000b | 01001000b = 11101000b
-10100000b | 01001001b = 11101001b
-10100000b | 01001010b = 11101010b
-10100000b | 01001011b = 11101011b
-10100000b | 01001100b = 11101100b
-10100000b | 01001101b = 11101101b
-10100000b | 01001110b = 11101110b
-10100000b | 01001111b = 11101111b
-10100000b | 01010000b = 11110000b
-10100000b | 01010001b = 11110001b
-10100000b | 01010010b = 11110010b
-10100000b | 01010011b = 11110011b
-10100000b | 01010100b = 11110100b
-10100000b | 01010101b = 11110101b
-10100000b | 01010110b = 11110110b
-10100000b | 01010111b = 11110111b
-10100000b | 01011000b = 11111000b
-10100000b | 01011001b = 11111001b
-10100000b | 01011010b = 11111010b
-10100000b | 01011011b = 11111011b
-10100000b | 01011100b = 11111100b
-10100000b | 01011101b = 11111101b
-10100000b | 01011110b = 11111110b
-10100000b | 01011111b = 11111111b
-10100000b | 01100000b = 11100000b
-10100000b | 01100001b = 11100001b
-10100000b | 01100010b = 11100010b
-10100000b | 01100011b = 11100011b
-10100000b | 01100100b = 11100100b
-10100000b | 01100101b = 11100101b
-10100000b | 01100110b = 11100110b
-10100000b | 01100111b = 11100111b
-10100000b | 01101000b = 11101000b
-10100000b | 01101001b = 11101001b
-10100000b | 01101010b = 11101010b
-10100000b | 01101011b = 11101011b
-10100000b | 01101100b = 11101100b
-10100000b | 01101101b = 11101101b
-10100000b | 01101110b = 11101110b
-10100000b | 01101111b = 11101111b
-10100000b | 01110000b = 11110000b
-10100000b | 01110001b = 11110001b
-10100000b | 01110010b = 11110010b
-10100000b | 01110011b = 11110011b
-10100000b | 01110100b = 11110100b
-10100000b | 01110101b = 11110101b
-10100000b | 01110110b = 11110110b
-10100000b | 01110111b = 11110111b
-10100000b | 01111000b = 11111000b
-10100000b | 01111001b = 11111001b
-10100000b | 01111010b = 11111010b
-10100000b | 01111011b = 11111011b
-10100000b | 01111100b = 11111100b
-10100000b | 01111101b = 11111101b
-10100000b | 01111110b = 11111110b
-10100001b | 10000000b = 10100001b
-10100001b | 10000001b = 10100001b
-10100001b | 10000010b = 10100011b
-10100001b | 10000011b = 10100011b
-10100001b | 10000100b = 10100101b
-10100001b | 10000101b = 10100101b
-10100001b | 10000110b = 10100111b
-10100001b | 10000111b = 10100111b
-10100001b | 10001000b = 10101001b
-10100001b | 10001001b = 10101001b
-10100001b | 10001010b = 10101011b
-10100001b | 10001011b = 10101011b
-10100001b | 10001100b = 10101101b
-10100001b | 10001101b = 10101101b
-10100001b | 10001110b = 10101111b
-10100001b | 10001111b = 10101111b
-10100001b | 10010000b = 10110001b
-10100001b | 10010001b = 10110001b
-10100001b | 10010010b = 10110011b
-10100001b | 10010011b = 10110011b
-10100001b | 10010100b = 10110101b
-10100001b | 10010101b = 10110101b
-10100001b | 10010110b = 10110111b
-10100001b | 10010111b = 10110111b
-10100001b | 10011000b = 10111001b
-10100001b | 10011001b = 10111001b
-10100001b | 10011010b = 10111011b
-10100001b | 10011011b = 10111011b
-10100001b | 10011100b = 10111101b
-10100001b | 10011101b = 10111101b
-10100001b | 10011110b = 10111111b
-10100001b | 10011111b = 10111111b
-10100001b | 10100000b = 10100001b
-10100001b | 10100001b = 10100001b
-10100001b | 10100010b = 10100011b
-10100001b | 10100011b = 10100011b
-10100001b | 10100100b = 10100101b
-10100001b | 10100101b = 10100101b
-10100001b | 10100110b = 10100111b
-10100001b | 10100111b = 10100111b
-10100001b | 10101000b = 10101001b
-10100001b | 10101001b = 10101001b
-10100001b | 10101010b = 10101011b
-10100001b | 10101011b = 10101011b
-10100001b | 10101100b = 10101101b
-10100001b | 10101101b = 10101101b
-10100001b | 10101110b = 10101111b
-10100001b | 10101111b = 10101111b
-10100001b | 10110000b = 10110001b
-10100001b | 10110001b = 10110001b
-10100001b | 10110010b = 10110011b
-10100001b | 10110011b = 10110011b
-10100001b | 10110100b = 10110101b
-10100001b | 10110101b = 10110101b
-10100001b | 10110110b = 10110111b
-10100001b | 10110111b = 10110111b
-10100001b | 10111000b = 10111001b
-10100001b | 10111001b = 10111001b
-10100001b | 10111010b = 10111011b
-10100001b | 10111011b = 10111011b
-10100001b | 10111100b = 10111101b
-10100001b | 10111101b = 10111101b
-10100001b | 10111110b = 10111111b
-10100001b | 10111111b = 10111111b
-10100001b | 11000000b = 11100001b
-10100001b | 11000001b = 11100001b
-10100001b | 11000010b = 11100011b
-10100001b | 11000011b = 11100011b
-10100001b | 11000100b = 11100101b
-10100001b | 11000101b = 11100101b
-10100001b | 11000110b = 11100111b
-10100001b | 11000111b = 11100111b
-10100001b | 11001000b = 11101001b
-10100001b | 11001001b = 11101001b
-10100001b | 11001010b = 11101011b
-10100001b | 11001011b = 11101011b
-10100001b | 11001100b = 11101101b
-10100001b | 11001101b = 11101101b
-10100001b | 11001110b = 11101111b
-10100001b | 11001111b = 11101111b
-10100001b | 11010000b = 11110001b
-10100001b | 11010001b = 11110001b
-10100001b | 11010010b = 11110011b
-10100001b | 11010011b = 11110011b
-10100001b | 11010100b = 11110101b
-10100001b | 11010101b = 11110101b
-10100001b | 11010110b = 11110111b
-10100001b | 11010111b = 11110111b
-10100001b | 11011000b = 11111001b
-10100001b | 11011001b = 11111001b
-10100001b | 11011010b = 11111011b
-10100001b | 11011011b = 11111011b
-10100001b | 11011100b = 11111101b
-10100001b | 11011101b = 11111101b
-10100001b | 11011110b = 11111111b
-10100001b | 11011111b = 11111111b
-10100001b | 11100000b = 11100001b
-10100001b | 11100001b = 11100001b
-10100001b | 11100010b = 11100011b
-10100001b | 11100011b = 11100011b
-10100001b | 11100100b = 11100101b
-10100001b | 11100101b = 11100101b
-10100001b | 11100110b = 11100111b
-10100001b | 11100111b = 11100111b
-10100001b | 11101000b = 11101001b
-10100001b | 11101001b = 11101001b
-10100001b | 11101010b = 11101011b
-10100001b | 11101011b = 11101011b
-10100001b | 11101100b = 11101101b
-10100001b | 11101101b = 11101101b
-10100001b | 11101110b = 11101111b
-10100001b | 11101111b = 11101111b
-10100001b | 11110000b = 11110001b
-10100001b | 11110001b = 11110001b
-10100001b | 11110010b = 11110011b
-10100001b | 11110011b = 11110011b
-10100001b | 11110100b = 11110101b
-10100001b | 11110101b = 11110101b
-10100001b | 11110110b = 11110111b
-10100001b | 11110111b = 11110111b
-10100001b | 11111000b = 11111001b
-10100001b | 11111001b = 11111001b
-10100001b | 11111010b = 11111011b
-10100001b | 11111011b = 11111011b
-10100001b | 11111100b = 11111101b
-10100001b | 11111101b = 11111101b
-10100001b | 11111110b = 11111111b
-10100001b | 11111111b = 11111111b
-10100001b | 00000000b = 10100001b
-10100001b | 00000001b = 10100001b
-10100001b | 00000010b = 10100011b
-10100001b | 00000011b = 10100011b
-10100001b | 00000100b = 10100101b
-10100001b | 00000101b = 10100101b
-10100001b | 00000110b = 10100111b
-10100001b | 00000111b = 10100111b
-10100001b | 00001000b = 10101001b
-10100001b | 00001001b = 10101001b
-10100001b | 00001010b = 10101011b
-10100001b | 00001011b = 10101011b
-10100001b | 00001100b = 10101101b
-10100001b | 00001101b = 10101101b
-10100001b | 00001110b = 10101111b
-10100001b | 00001111b = 10101111b
-10100001b | 00010000b = 10110001b
-10100001b | 00010001b = 10110001b
-10100001b | 00010010b = 10110011b
-10100001b | 00010011b = 10110011b
-10100001b | 00010100b = 10110101b
-10100001b | 00010101b = 10110101b
-10100001b | 00010110b = 10110111b
-10100001b | 00010111b = 10110111b
-10100001b | 00011000b = 10111001b
-10100001b | 00011001b = 10111001b
-10100001b | 00011010b = 10111011b
-10100001b | 00011011b = 10111011b
-10100001b | 00011100b = 10111101b
-10100001b | 00011101b = 10111101b
-10100001b | 00011110b = 10111111b
-10100001b | 00011111b = 10111111b
-10100001b | 00100000b = 10100001b
-10100001b | 00100001b = 10100001b
-10100001b | 00100010b = 10100011b
-10100001b | 00100011b = 10100011b
-10100001b | 00100100b = 10100101b
-10100001b | 00100101b = 10100101b
-10100001b | 00100110b = 10100111b
-10100001b | 00100111b = 10100111b
-10100001b | 00101000b = 10101001b
-10100001b | 00101001b = 10101001b
-10100001b | 00101010b = 10101011b
-10100001b | 00101011b = 10101011b
-10100001b | 00101100b = 10101101b
-10100001b | 00101101b = 10101101b
-10100001b | 00101110b = 10101111b
-10100001b | 00101111b = 10101111b
-10100001b | 00110000b = 10110001b
-10100001b | 00110001b = 10110001b
-10100001b | 00110010b = 10110011b
-10100001b | 00110011b = 10110011b
-10100001b | 00110100b = 10110101b
-10100001b | 00110101b = 10110101b
-10100001b | 00110110b = 10110111b
-10100001b | 00110111b = 10110111b
-10100001b | 00111000b = 10111001b
-10100001b | 00111001b = 10111001b
-10100001b | 00111010b = 10111011b
-10100001b | 00111011b = 10111011b
-10100001b | 00111100b = 10111101b
-10100001b | 00111101b = 10111101b
-10100001b | 00111110b = 10111111b
-10100001b | 00111111b = 10111111b
-10100001b | 01000000b = 11100001b
-10100001b | 01000001b = 11100001b
-10100001b | 01000010b = 11100011b
-10100001b | 01000011b = 11100011b
-10100001b | 01000100b = 11100101b
-10100001b | 01000101b = 11100101b
-10100001b | 01000110b = 11100111b
-10100001b | 01000111b = 11100111b
-10100001b | 01001000b = 11101001b
-10100001b | 01001001b = 11101001b
-10100001b | 01001010b = 11101011b
-10100001b | 01001011b = 11101011b
-10100001b | 01001100b = 11101101b
-10100001b | 01001101b = 11101101b
-10100001b | 01001110b = 11101111b
-10100001b | 01001111b = 11101111b
-10100001b | 01010000b = 11110001b
-10100001b | 01010001b = 11110001b
-10100001b | 01010010b = 11110011b
-10100001b | 01010011b = 11110011b
-10100001b | 01010100b = 11110101b
-10100001b | 01010101b = 11110101b
-10100001b | 01010110b = 11110111b
-10100001b | 01010111b = 11110111b
-10100001b | 01011000b = 11111001b
-10100001b | 01011001b = 11111001b
-10100001b | 01011010b = 11111011b
-10100001b | 01011011b = 11111011b
-10100001b | 01011100b = 11111101b
-10100001b | 01011101b = 11111101b
-10100001b | 01011110b = 11111111b
-10100001b | 01011111b = 11111111b
-10100001b | 01100000b = 11100001b
-10100001b | 01100001b = 11100001b
-10100001b | 01100010b = 11100011b
-10100001b | 01100011b = 11100011b
-10100001b | 01100100b = 11100101b
-10100001b | 01100101b = 11100101b
-10100001b | 01100110b = 11100111b
-10100001b | 01100111b = 11100111b
-10100001b | 01101000b = 11101001b
-10100001b | 01101001b = 11101001b
-10100001b | 01101010b = 11101011b
-10100001b | 01101011b = 11101011b
-10100001b | 01101100b = 11101101b
-10100001b | 01101101b = 11101101b
-10100001b | 01101110b = 11101111b
-10100001b | 01101111b = 11101111b
-10100001b | 01110000b = 11110001b
-10100001b | 01110001b = 11110001b
-10100001b | 01110010b = 11110011b
-10100001b | 01110011b = 11110011b
-10100001b | 01110100b = 11110101b
-10100001b | 01110101b = 11110101b
-10100001b | 01110110b = 11110111b
-10100001b | 01110111b = 11110111b
-10100001b | 01111000b = 11111001b
-10100001b | 01111001b = 11111001b
-10100001b | 01111010b = 11111011b
-10100001b | 01111011b = 11111011b
-10100001b | 01111100b = 11111101b
-10100001b | 01111101b = 11111101b
-10100001b | 01111110b = 11111111b
-10100010b | 10000000b = 10100010b
-10100010b | 10000001b = 10100011b
-10100010b | 10000010b = 10100010b
-10100010b | 10000011b = 10100011b
-10100010b | 10000100b = 10100110b
-10100010b | 10000101b = 10100111b
-10100010b | 10000110b = 10100110b
-10100010b | 10000111b = 10100111b
-10100010b | 10001000b = 10101010b
-10100010b | 10001001b = 10101011b
-10100010b | 10001010b = 10101010b
-10100010b | 10001011b = 10101011b
-10100010b | 10001100b = 10101110b
-10100010b | 10001101b = 10101111b
-10100010b | 10001110b = 10101110b
-10100010b | 10001111b = 10101111b
-10100010b | 10010000b = 10110010b
-10100010b | 10010001b = 10110011b
-10100010b | 10010010b = 10110010b
-10100010b | 10010011b = 10110011b
-10100010b | 10010100b = 10110110b
-10100010b | 10010101b = 10110111b
-10100010b | 10010110b = 10110110b
-10100010b | 10010111b = 10110111b
-10100010b | 10011000b = 10111010b
-10100010b | 10011001b = 10111011b
-10100010b | 10011010b = 10111010b
-10100010b | 10011011b = 10111011b
-10100010b | 10011100b = 10111110b
-10100010b | 10011101b = 10111111b
-10100010b | 10011110b = 10111110b
-10100010b | 10011111b = 10111111b
-10100010b | 10100000b = 10100010b
-10100010b | 10100001b = 10100011b
-10100010b | 10100010b = 10100010b
-10100010b | 10100011b = 10100011b
-10100010b | 10100100b = 10100110b
-10100010b | 10100101b = 10100111b
-10100010b | 10100110b = 10100110b
-10100010b | 10100111b = 10100111b
-10100010b | 10101000b = 10101010b
-10100010b | 10101001b = 10101011b
-10100010b | 10101010b = 10101010b
-10100010b | 10101011b = 10101011b
-10100010b | 10101100b = 10101110b
-10100010b | 10101101b = 10101111b
-10100010b | 10101110b = 10101110b
-10100010b | 10101111b = 10101111b
-10100010b | 10110000b = 10110010b
-10100010b | 10110001b = 10110011b
-10100010b | 10110010b = 10110010b
-10100010b | 10110011b = 10110011b
-10100010b | 10110100b = 10110110b
-10100010b | 10110101b = 10110111b
-10100010b | 10110110b = 10110110b
-10100010b | 10110111b = 10110111b
-10100010b | 10111000b = 10111010b
-10100010b | 10111001b = 10111011b
-10100010b | 10111010b = 10111010b
-10100010b | 10111011b = 10111011b
-10100010b | 10111100b = 10111110b
-10100010b | 10111101b = 10111111b
-10100010b | 10111110b = 10111110b
-10100010b | 10111111b = 10111111b
-10100010b | 11000000b = 11100010b
-10100010b | 11000001b = 11100011b
-10100010b | 11000010b = 11100010b
-10100010b | 11000011b = 11100011b
-10100010b | 11000100b = 11100110b
-10100010b | 11000101b = 11100111b
-10100010b | 11000110b = 11100110b
-10100010b | 11000111b = 11100111b
-10100010b | 11001000b = 11101010b
-10100010b | 11001001b = 11101011b
-10100010b | 11001010b = 11101010b
-10100010b | 11001011b = 11101011b
-10100010b | 11001100b = 11101110b
-10100010b | 11001101b = 11101111b
-10100010b | 11001110b = 11101110b
-10100010b | 11001111b = 11101111b
-10100010b | 11010000b = 11110010b
-10100010b | 11010001b = 11110011b
-10100010b | 11010010b = 11110010b
-10100010b | 11010011b = 11110011b
-10100010b | 11010100b = 11110110b
-10100010b | 11010101b = 11110111b
-10100010b | 11010110b = 11110110b
-10100010b | 11010111b = 11110111b
-10100010b | 11011000b = 11111010b
-10100010b | 11011001b = 11111011b
-10100010b | 11011010b = 11111010b
-10100010b | 11011011b = 11111011b
-10100010b | 11011100b = 11111110b
-10100010b | 11011101b = 11111111b
-10100010b | 11011110b = 11111110b
-10100010b | 11011111b = 11111111b
-10100010b | 11100000b = 11100010b
-10100010b | 11100001b = 11100011b
-10100010b | 11100010b = 11100010b
-10100010b | 11100011b = 11100011b
-10100010b | 11100100b = 11100110b
-10100010b | 11100101b = 11100111b
-10100010b | 11100110b = 11100110b
-10100010b | 11100111b = 11100111b
-10100010b | 11101000b = 11101010b
-10100010b | 11101001b = 11101011b
-10100010b | 11101010b = 11101010b
-10100010b | 11101011b = 11101011b
-10100010b | 11101100b = 11101110b
-10100010b | 11101101b = 11101111b
-10100010b | 11101110b = 11101110b
-10100010b | 11101111b = 11101111b
-10100010b | 11110000b = 11110010b
-10100010b | 11110001b = 11110011b
-10100010b | 11110010b = 11110010b
-10100010b | 11110011b = 11110011b
-10100010b | 11110100b = 11110110b
-10100010b | 11110101b = 11110111b
-10100010b | 11110110b = 11110110b
-10100010b | 11110111b = 11110111b
-10100010b | 11111000b = 11111010b
-10100010b | 11111001b = 11111011b
-10100010b | 11111010b = 11111010b
-10100010b | 11111011b = 11111011b
-10100010b | 11111100b = 11111110b
-10100010b | 11111101b = 11111111b
-10100010b | 11111110b = 11111110b
-10100010b | 11111111b = 11111111b
-10100010b | 00000000b = 10100010b
-10100010b | 00000001b = 10100011b
-10100010b | 00000010b = 10100010b
-10100010b | 00000011b = 10100011b
-10100010b | 00000100b = 10100110b
-10100010b | 00000101b = 10100111b
-10100010b | 00000110b = 10100110b
-10100010b | 00000111b = 10100111b
-10100010b | 00001000b = 10101010b
-10100010b | 00001001b = 10101011b
-10100010b | 00001010b = 10101010b
-10100010b | 00001011b = 10101011b
-10100010b | 00001100b = 10101110b
-10100010b | 00001101b = 10101111b
-10100010b | 00001110b = 10101110b
-10100010b | 00001111b = 10101111b
-10100010b | 00010000b = 10110010b
-10100010b | 00010001b = 10110011b
-10100010b | 00010010b = 10110010b
-10100010b | 00010011b = 10110011b
-10100010b | 00010100b = 10110110b
-10100010b | 00010101b = 10110111b
-10100010b | 00010110b = 10110110b
-10100010b | 00010111b = 10110111b
-10100010b | 00011000b = 10111010b
-10100010b | 00011001b = 10111011b
-10100010b | 00011010b = 10111010b
-10100010b | 00011011b = 10111011b
-10100010b | 00011100b = 10111110b
-10100010b | 00011101b = 10111111b
-10100010b | 00011110b = 10111110b
-10100010b | 00011111b = 10111111b
-10100010b | 00100000b = 10100010b
-10100010b | 00100001b = 10100011b
-10100010b | 00100010b = 10100010b
-10100010b | 00100011b = 10100011b
-10100010b | 00100100b = 10100110b
-10100010b | 00100101b = 10100111b
-10100010b | 00100110b = 10100110b
-10100010b | 00100111b = 10100111b
-10100010b | 00101000b = 10101010b
-10100010b | 00101001b = 10101011b
-10100010b | 00101010b = 10101010b
-10100010b | 00101011b = 10101011b
-10100010b | 00101100b = 10101110b
-10100010b | 00101101b = 10101111b
-10100010b | 00101110b = 10101110b
-10100010b | 00101111b = 10101111b
-10100010b | 00110000b = 10110010b
-10100010b | 00110001b = 10110011b
-10100010b | 00110010b = 10110010b
-10100010b | 00110011b = 10110011b
-10100010b | 00110100b = 10110110b
-10100010b | 00110101b = 10110111b
-10100010b | 00110110b = 10110110b
-10100010b | 00110111b = 10110111b
-10100010b | 00111000b = 10111010b
-10100010b | 00111001b = 10111011b
-10100010b | 00111010b = 10111010b
-10100010b | 00111011b = 10111011b
-10100010b | 00111100b = 10111110b
-10100010b | 00111101b = 10111111b
-10100010b | 00111110b = 10111110b
-10100010b | 00111111b = 10111111b
-10100010b | 01000000b = 11100010b
-10100010b | 01000001b = 11100011b
-10100010b | 01000010b = 11100010b
-10100010b | 01000011b = 11100011b
-10100010b | 01000100b = 11100110b
-10100010b | 01000101b = 11100111b
-10100010b | 01000110b = 11100110b
-10100010b | 01000111b = 11100111b
-10100010b | 01001000b = 11101010b
-10100010b | 01001001b = 11101011b
-10100010b | 01001010b = 11101010b
-10100010b | 01001011b = 11101011b
-10100010b | 01001100b = 11101110b
-10100010b | 01001101b = 11101111b
-10100010b | 01001110b = 11101110b
-10100010b | 01001111b = 11101111b
-10100010b | 01010000b = 11110010b
-10100010b | 01010001b = 11110011b
-10100010b | 01010010b = 11110010b
-10100010b | 01010011b = 11110011b
-10100010b | 01010100b = 11110110b
-10100010b | 01010101b = 11110111b
-10100010b | 01010110b = 11110110b
-10100010b | 01010111b = 11110111b
-10100010b | 01011000b = 11111010b
-10100010b | 01011001b = 11111011b
-10100010b | 01011010b = 11111010b
-10100010b | 01011011b = 11111011b
-10100010b | 01011100b = 11111110b
-10100010b | 01011101b = 11111111b
-10100010b | 01011110b = 11111110b
-10100010b | 01011111b = 11111111b
-10100010b | 01100000b = 11100010b
-10100010b | 01100001b = 11100011b
-10100010b | 01100010b = 11100010b
-10100010b | 01100011b = 11100011b
-10100010b | 01100100b = 11100110b
-10100010b | 01100101b = 11100111b
-10100010b | 01100110b = 11100110b
-10100010b | 01100111b = 11100111b
-10100010b | 01101000b = 11101010b
-10100010b | 01101001b = 11101011b
-10100010b | 01101010b = 11101010b
-10100010b | 01101011b = 11101011b
-10100010b | 01101100b = 11101110b
-10100010b | 01101101b = 11101111b
-10100010b | 01101110b = 11101110b
-10100010b | 01101111b = 11101111b
-10100010b | 01110000b = 11110010b
-10100010b | 01110001b = 11110011b
-10100010b | 01110010b = 11110010b
-10100010b | 01110011b = 11110011b
-10100010b | 01110100b = 11110110b
-10100010b | 01110101b = 11110111b
-10100010b | 01110110b = 11110110b
-10100010b | 01110111b = 11110111b
-10100010b | 01111000b = 11111010b
-10100010b | 01111001b = 11111011b
-10100010b | 01111010b = 11111010b
-10100010b | 01111011b = 11111011b
-10100010b | 01111100b = 11111110b
-10100010b | 01111101b = 11111111b
-10100010b | 01111110b = 11111110b
-10100011b | 10000000b = 10100011b
-10100011b | 10000001b = 10100011b
-10100011b | 10000010b = 10100011b
-10100011b | 10000011b = 10100011b
-10100011b | 10000100b = 10100111b
-10100011b | 10000101b = 10100111b
-10100011b | 10000110b = 10100111b
-10100011b | 10000111b = 10100111b
-10100011b | 10001000b = 10101011b
-10100011b | 10001001b = 10101011b
-10100011b | 10001010b = 10101011b
-10100011b | 10001011b = 10101011b
-10100011b | 10001100b = 10101111b
-10100011b | 10001101b = 10101111b
-10100011b | 10001110b = 10101111b
-10100011b | 10001111b = 10101111b
-10100011b | 10010000b = 10110011b
-10100011b | 10010001b = 10110011b
-10100011b | 10010010b = 10110011b
-10100011b | 10010011b = 10110011b
-10100011b | 10010100b = 10110111b
-10100011b | 10010101b = 10110111b
-10100011b | 10010110b = 10110111b
-10100011b | 10010111b = 10110111b
-10100011b | 10011000b = 10111011b
-10100011b | 10011001b = 10111011b
-10100011b | 10011010b = 10111011b
-10100011b | 10011011b = 10111011b
-10100011b | 10011100b = 10111111b
-10100011b | 10011101b = 10111111b
-10100011b | 10011110b = 10111111b
-10100011b | 10011111b = 10111111b
-10100011b | 10100000b = 10100011b
-10100011b | 10100001b = 10100011b
-10100011b | 10100010b = 10100011b
-10100011b | 10100011b = 10100011b
-10100011b | 10100100b = 10100111b
-10100011b | 10100101b = 10100111b
-10100011b | 10100110b = 10100111b
-10100011b | 10100111b = 10100111b
-10100011b | 10101000b = 10101011b
-10100011b | 10101001b = 10101011b
-10100011b | 10101010b = 10101011b
-10100011b | 10101011b = 10101011b
-10100011b | 10101100b = 10101111b
-10100011b | 10101101b = 10101111b
-10100011b | 10101110b = 10101111b
-10100011b | 10101111b = 10101111b
-10100011b | 10110000b = 10110011b
-10100011b | 10110001b = 10110011b
-10100011b | 10110010b = 10110011b
-10100011b | 10110011b = 10110011b
-10100011b | 10110100b = 10110111b
-10100011b | 10110101b = 10110111b
-10100011b | 10110110b = 10110111b
-10100011b | 10110111b = 10110111b
-10100011b | 10111000b = 10111011b
-10100011b | 10111001b = 10111011b
-10100011b | 10111010b = 10111011b
-10100011b | 10111011b = 10111011b
-10100011b | 10111100b = 10111111b
-10100011b | 10111101b = 10111111b
-10100011b | 10111110b = 10111111b
-10100011b | 10111111b = 10111111b
-10100011b | 11000000b = 11100011b
-10100011b | 11000001b = 11100011b
-10100011b | 11000010b = 11100011b
-10100011b | 11000011b = 11100011b
-10100011b | 11000100b = 11100111b
-10100011b | 11000101b = 11100111b
-10100011b | 11000110b = 11100111b
-10100011b | 11000111b = 11100111b
-10100011b | 11001000b = 11101011b
-10100011b | 11001001b = 11101011b
-10100011b | 11001010b = 11101011b
-10100011b | 11001011b = 11101011b
-10100011b | 11001100b = 11101111b
-10100011b | 11001101b = 11101111b
-10100011b | 11001110b = 11101111b
-10100011b | 11001111b = 11101111b
-10100011b | 11010000b = 11110011b
-10100011b | 11010001b = 11110011b
-10100011b | 11010010b = 11110011b
-10100011b | 11010011b = 11110011b
-10100011b | 11010100b = 11110111b
-10100011b | 11010101b = 11110111b
-10100011b | 11010110b = 11110111b
-10100011b | 11010111b = 11110111b
-10100011b | 11011000b = 11111011b
-10100011b | 11011001b = 11111011b
-10100011b | 11011010b = 11111011b
-10100011b | 11011011b = 11111011b
-10100011b | 11011100b = 11111111b
-10100011b | 11011101b = 11111111b
-10100011b | 11011110b = 11111111b
-10100011b | 11011111b = 11111111b
-10100011b | 11100000b = 11100011b
-10100011b | 11100001b = 11100011b
-10100011b | 11100010b = 11100011b
-10100011b | 11100011b = 11100011b
-10100011b | 11100100b = 11100111b
-10100011b | 11100101b = 11100111b
-10100011b | 11100110b = 11100111b
-10100011b | 11100111b = 11100111b
-10100011b | 11101000b = 11101011b
-10100011b | 11101001b = 11101011b
-10100011b | 11101010b = 11101011b
-10100011b | 11101011b = 11101011b
-10100011b | 11101100b = 11101111b
-10100011b | 11101101b = 11101111b
-10100011b | 11101110b = 11101111b
-10100011b | 11101111b = 11101111b
-10100011b | 11110000b = 11110011b
-10100011b | 11110001b = 11110011b
-10100011b | 11110010b = 11110011b
-10100011b | 11110011b = 11110011b
-10100011b | 11110100b = 11110111b
-10100011b | 11110101b = 11110111b
-10100011b | 11110110b = 11110111b
-10100011b | 11110111b = 11110111b
-10100011b | 11111000b = 11111011b
-10100011b | 11111001b = 11111011b
-10100011b | 11111010b = 11111011b
-10100011b | 11111011b = 11111011b
-10100011b | 11111100b = 11111111b
-10100011b | 11111101b = 11111111b
-10100011b | 11111110b = 11111111b
-10100011b | 11111111b = 11111111b
-10100011b | 00000000b = 10100011b
-10100011b | 00000001b = 10100011b
-10100011b | 00000010b = 10100011b
-10100011b | 00000011b = 10100011b
-10100011b | 00000100b = 10100111b
-10100011b | 00000101b = 10100111b
-10100011b | 00000110b = 10100111b
-10100011b | 00000111b = 10100111b
-10100011b | 00001000b = 10101011b
-10100011b | 00001001b = 10101011b
-10100011b | 00001010b = 10101011b
-10100011b | 00001011b = 10101011b
-10100011b | 00001100b = 10101111b
-10100011b | 00001101b = 10101111b
-10100011b | 00001110b = 10101111b
-10100011b | 00001111b = 10101111b
-10100011b | 00010000b = 10110011b
-10100011b | 00010001b = 10110011b
-10100011b | 00010010b = 10110011b
-10100011b | 00010011b = 10110011b
-10100011b | 00010100b = 10110111b
-10100011b | 00010101b = 10110111b
-10100011b | 00010110b = 10110111b
-10100011b | 00010111b = 10110111b
-10100011b | 00011000b = 10111011b
-10100011b | 00011001b = 10111011b
-10100011b | 00011010b = 10111011b
-10100011b | 00011011b = 10111011b
-10100011b | 00011100b = 10111111b
-10100011b | 00011101b = 10111111b
-10100011b | 00011110b = 10111111b
-10100011b | 00011111b = 10111111b
-10100011b | 00100000b = 10100011b
-10100011b | 00100001b = 10100011b
-10100011b | 00100010b = 10100011b
-10100011b | 00100011b = 10100011b
-10100011b | 00100100b = 10100111b
-10100011b | 00100101b = 10100111b
-10100011b | 00100110b = 10100111b
-10100011b | 00100111b = 10100111b
-10100011b | 00101000b = 10101011b
-10100011b | 00101001b = 10101011b
-10100011b | 00101010b = 10101011b
-10100011b | 00101011b = 10101011b
-10100011b | 00101100b = 10101111b
-10100011b | 00101101b = 10101111b
-10100011b | 00101110b = 10101111b
-10100011b | 00101111b = 10101111b
-10100011b | 00110000b = 10110011b
-10100011b | 00110001b = 10110011b
-10100011b | 00110010b = 10110011b
-10100011b | 00110011b = 10110011b
-10100011b | 00110100b = 10110111b
-10100011b | 00110101b = 10110111b
-10100011b | 00110110b = 10110111b
-10100011b | 00110111b = 10110111b
-10100011b | 00111000b = 10111011b
-10100011b | 00111001b = 10111011b
-10100011b | 00111010b = 10111011b
-10100011b | 00111011b = 10111011b
-10100011b | 00111100b = 10111111b
-10100011b | 00111101b = 10111111b
-10100011b | 00111110b = 10111111b
-10100011b | 00111111b = 10111111b
-10100011b | 01000000b = 11100011b
-10100011b | 01000001b = 11100011b
-10100011b | 01000010b = 11100011b
-10100011b | 01000011b = 11100011b
-10100011b | 01000100b = 11100111b
-10100011b | 01000101b = 11100111b
-10100011b | 01000110b = 11100111b
-10100011b | 01000111b = 11100111b
-10100011b | 01001000b = 11101011b
-10100011b | 01001001b = 11101011b
-10100011b | 01001010b = 11101011b
-10100011b | 01001011b = 11101011b
-10100011b | 01001100b = 11101111b
-10100011b | 01001101b = 11101111b
-10100011b | 01001110b = 11101111b
-10100011b | 01001111b = 11101111b
-10100011b | 01010000b = 11110011b
-10100011b | 01010001b = 11110011b
-10100011b | 01010010b = 11110011b
-10100011b | 01010011b = 11110011b
-10100011b | 01010100b = 11110111b
-10100011b | 01010101b = 11110111b
-10100011b | 01010110b = 11110111b
-10100011b | 01010111b = 11110111b
-10100011b | 01011000b = 11111011b
-10100011b | 01011001b = 11111011b
-10100011b | 01011010b = 11111011b
-10100011b | 01011011b = 11111011b
-10100011b | 01011100b = 11111111b
-10100011b | 01011101b = 11111111b
-10100011b | 01011110b = 11111111b
-10100011b | 01011111b = 11111111b
-10100011b | 01100000b = 11100011b
-10100011b | 01100001b = 11100011b
-10100011b | 01100010b = 11100011b
-10100011b | 01100011b = 11100011b
-10100011b | 01100100b = 11100111b
-10100011b | 01100101b = 11100111b
-10100011b | 01100110b = 11100111b
-10100011b | 01100111b = 11100111b
-10100011b | 01101000b = 11101011b
-10100011b | 01101001b = 11101011b
-10100011b | 01101010b = 11101011b
-10100011b | 01101011b = 11101011b
-10100011b | 01101100b = 11101111b
-10100011b | 01101101b = 11101111b
-10100011b | 01101110b = 11101111b
-10100011b | 01101111b = 11101111b
-10100011b | 01110000b = 11110011b
-10100011b | 01110001b = 11110011b
-10100011b | 01110010b = 11110011b
-10100011b | 01110011b = 11110011b
-10100011b | 01110100b = 11110111b
-10100011b | 01110101b = 11110111b
-10100011b | 01110110b = 11110111b
-10100011b | 01110111b = 11110111b
-10100011b | 01111000b = 11111011b
-10100011b | 01111001b = 11111011b
-10100011b | 01111010b = 11111011b
-10100011b | 01111011b = 11111011b
-10100011b | 01111100b = 11111111b
-10100011b | 01111101b = 11111111b
-10100011b | 01111110b = 11111111b
-10100100b | 10000000b = 10100100b
-10100100b | 10000001b = 10100101b
-10100100b | 10000010b = 10100110b
-10100100b | 10000011b = 10100111b
-10100100b | 10000100b = 10100100b
-10100100b | 10000101b = 10100101b
-10100100b | 10000110b = 10100110b
-10100100b | 10000111b = 10100111b
-10100100b | 10001000b = 10101100b
-10100100b | 10001001b = 10101101b
-10100100b | 10001010b = 10101110b
-10100100b | 10001011b = 10101111b
-10100100b | 10001100b = 10101100b
-10100100b | 10001101b = 10101101b
-10100100b | 10001110b = 10101110b
-10100100b | 10001111b = 10101111b
-10100100b | 10010000b = 10110100b
-10100100b | 10010001b = 10110101b
-10100100b | 10010010b = 10110110b
-10100100b | 10010011b = 10110111b
-10100100b | 10010100b = 10110100b
-10100100b | 10010101b = 10110101b
-10100100b | 10010110b = 10110110b
-10100100b | 10010111b = 10110111b
-10100100b | 10011000b = 10111100b
-10100100b | 10011001b = 10111101b
-10100100b | 10011010b = 10111110b
-10100100b | 10011011b = 10111111b
-10100100b | 10011100b = 10111100b
-10100100b | 10011101b = 10111101b
-10100100b | 10011110b = 10111110b
-10100100b | 10011111b = 10111111b
-10100100b | 10100000b = 10100100b
-10100100b | 10100001b = 10100101b
-10100100b | 10100010b = 10100110b
-10100100b | 10100011b = 10100111b
-10100100b | 10100100b = 10100100b
-10100100b | 10100101b = 10100101b
-10100100b | 10100110b = 10100110b
-10100100b | 10100111b = 10100111b
-10100100b | 10101000b = 10101100b
-10100100b | 10101001b = 10101101b
-10100100b | 10101010b = 10101110b
-10100100b | 10101011b = 10101111b
-10100100b | 10101100b = 10101100b
-10100100b | 10101101b = 10101101b
-10100100b | 10101110b = 10101110b
-10100100b | 10101111b = 10101111b
-10100100b | 10110000b = 10110100b
-10100100b | 10110001b = 10110101b
-10100100b | 10110010b = 10110110b
-10100100b | 10110011b = 10110111b
-10100100b | 10110100b = 10110100b
-10100100b | 10110101b = 10110101b
-10100100b | 10110110b = 10110110b
-10100100b | 10110111b = 10110111b
-10100100b | 10111000b = 10111100b
-10100100b | 10111001b = 10111101b
-10100100b | 10111010b = 10111110b
-10100100b | 10111011b = 10111111b
-10100100b | 10111100b = 10111100b
-10100100b | 10111101b = 10111101b
-10100100b | 10111110b = 10111110b
-10100100b | 10111111b = 10111111b
-10100100b | 11000000b = 11100100b
-10100100b | 11000001b = 11100101b
-10100100b | 11000010b = 11100110b
-10100100b | 11000011b = 11100111b
-10100100b | 11000100b = 11100100b
-10100100b | 11000101b = 11100101b
-10100100b | 11000110b = 11100110b
-10100100b | 11000111b = 11100111b
-10100100b | 11001000b = 11101100b
-10100100b | 11001001b = 11101101b
-10100100b | 11001010b = 11101110b
-10100100b | 11001011b = 11101111b
-10100100b | 11001100b = 11101100b
-10100100b | 11001101b = 11101101b
-10100100b | 11001110b = 11101110b
-10100100b | 11001111b = 11101111b
-10100100b | 11010000b = 11110100b
-10100100b | 11010001b = 11110101b
-10100100b | 11010010b = 11110110b
-10100100b | 11010011b = 11110111b
-10100100b | 11010100b = 11110100b
-10100100b | 11010101b = 11110101b
-10100100b | 11010110b = 11110110b
-10100100b | 11010111b = 11110111b
-10100100b | 11011000b = 11111100b
-10100100b | 11011001b = 11111101b
-10100100b | 11011010b = 11111110b
-10100100b | 11011011b = 11111111b
-10100100b | 11011100b = 11111100b
-10100100b | 11011101b = 11111101b
-10100100b | 11011110b = 11111110b
-10100100b | 11011111b = 11111111b
-10100100b | 11100000b = 11100100b
-10100100b | 11100001b = 11100101b
-10100100b | 11100010b = 11100110b
-10100100b | 11100011b = 11100111b
-10100100b | 11100100b = 11100100b
-10100100b | 11100101b = 11100101b
-10100100b | 11100110b = 11100110b
-10100100b | 11100111b = 11100111b
-10100100b | 11101000b = 11101100b
-10100100b | 11101001b = 11101101b
-10100100b | 11101010b = 11101110b
-10100100b | 11101011b = 11101111b
-10100100b | 11101100b = 11101100b
-10100100b | 11101101b = 11101101b
-10100100b | 11101110b = 11101110b
-10100100b | 11101111b = 11101111b
-10100100b | 11110000b = 11110100b
-10100100b | 11110001b = 11110101b
-10100100b | 11110010b = 11110110b
-10100100b | 11110011b = 11110111b
-10100100b | 11110100b = 11110100b
-10100100b | 11110101b = 11110101b
-10100100b | 11110110b = 11110110b
-10100100b | 11110111b = 11110111b
-10100100b | 11111000b = 11111100b
-10100100b | 11111001b = 11111101b
-10100100b | 11111010b = 11111110b
-10100100b | 11111011b = 11111111b
-10100100b | 11111100b = 11111100b
-10100100b | 11111101b = 11111101b
-10100100b | 11111110b = 11111110b
-10100100b | 11111111b = 11111111b
-10100100b | 00000000b = 10100100b
-10100100b | 00000001b = 10100101b
-10100100b | 00000010b = 10100110b
-10100100b | 00000011b = 10100111b
-10100100b | 00000100b = 10100100b
-10100100b | 00000101b = 10100101b
-10100100b | 00000110b = 10100110b
-10100100b | 00000111b = 10100111b
-10100100b | 00001000b = 10101100b
-10100100b | 00001001b = 10101101b
-10100100b | 00001010b = 10101110b
-10100100b | 00001011b = 10101111b
-10100100b | 00001100b = 10101100b
-10100100b | 00001101b = 10101101b
-10100100b | 00001110b = 10101110b
-10100100b | 00001111b = 10101111b
-10100100b | 00010000b = 10110100b
-10100100b | 00010001b = 10110101b
-10100100b | 00010010b = 10110110b
-10100100b | 00010011b = 10110111b
-10100100b | 00010100b = 10110100b
-10100100b | 00010101b = 10110101b
-10100100b | 00010110b = 10110110b
-10100100b | 00010111b = 10110111b
-10100100b | 00011000b = 10111100b
-10100100b | 00011001b = 10111101b
-10100100b | 00011010b = 10111110b
-10100100b | 00011011b = 10111111b
-10100100b | 00011100b = 10111100b
-10100100b | 00011101b = 10111101b
-10100100b | 00011110b = 10111110b
-10100100b | 00011111b = 10111111b
-10100100b | 00100000b = 10100100b
-10100100b | 00100001b = 10100101b
-10100100b | 00100010b = 10100110b
-10100100b | 00100011b = 10100111b
-10100100b | 00100100b = 10100100b
-10100100b | 00100101b = 10100101b
-10100100b | 00100110b = 10100110b
-10100100b | 00100111b = 10100111b
-10100100b | 00101000b = 10101100b
-10100100b | 00101001b = 10101101b
-10100100b | 00101010b = 10101110b
-10100100b | 00101011b = 10101111b
-10100100b | 00101100b = 10101100b
-10100100b | 00101101b = 10101101b
-10100100b | 00101110b = 10101110b
-10100100b | 00101111b = 10101111b
-10100100b | 00110000b = 10110100b
-10100100b | 00110001b = 10110101b
-10100100b | 00110010b = 10110110b
-10100100b | 00110011b = 10110111b
-10100100b | 00110100b = 10110100b
-10100100b | 00110101b = 10110101b
-10100100b | 00110110b = 10110110b
-10100100b | 00110111b = 10110111b
-10100100b | 00111000b = 10111100b
-10100100b | 00111001b = 10111101b
-10100100b | 00111010b = 10111110b
-10100100b | 00111011b = 10111111b
-10100100b | 00111100b = 10111100b
-10100100b | 00111101b = 10111101b
-10100100b | 00111110b = 10111110b
-10100100b | 00111111b = 10111111b
-10100100b | 01000000b = 11100100b
-10100100b | 01000001b = 11100101b
-10100100b | 01000010b = 11100110b
-10100100b | 01000011b = 11100111b
-10100100b | 01000100b = 11100100b
-10100100b | 01000101b = 11100101b
-10100100b | 01000110b = 11100110b
-10100100b | 01000111b = 11100111b
-10100100b | 01001000b = 11101100b
-10100100b | 01001001b = 11101101b
-10100100b | 01001010b = 11101110b
-10100100b | 01001011b = 11101111b
-10100100b | 01001100b = 11101100b
-10100100b | 01001101b = 11101101b
-10100100b | 01001110b = 11101110b
-10100100b | 01001111b = 11101111b
-10100100b | 01010000b = 11110100b
-10100100b | 01010001b = 11110101b
-10100100b | 01010010b = 11110110b
-10100100b | 01010011b = 11110111b
-10100100b | 01010100b = 11110100b
-10100100b | 01010101b = 11110101b
-10100100b | 01010110b = 11110110b
-10100100b | 01010111b = 11110111b
-10100100b | 01011000b = 11111100b
-10100100b | 01011001b = 11111101b
-10100100b | 01011010b = 11111110b
-10100100b | 01011011b = 11111111b
-10100100b | 01011100b = 11111100b
-10100100b | 01011101b = 11111101b
-10100100b | 01011110b = 11111110b
-10100100b | 01011111b = 11111111b
-10100100b | 01100000b = 11100100b
-10100100b | 01100001b = 11100101b
-10100100b | 01100010b = 11100110b
-10100100b | 01100011b = 11100111b
-10100100b | 01100100b = 11100100b
-10100100b | 01100101b = 11100101b
-10100100b | 01100110b = 11100110b
-10100100b | 01100111b = 11100111b
-10100100b | 01101000b = 11101100b
-10100100b | 01101001b = 11101101b
-10100100b | 01101010b = 11101110b
-10100100b | 01101011b = 11101111b
-10100100b | 01101100b = 11101100b
-10100100b | 01101101b = 11101101b
-10100100b | 01101110b = 11101110b
-10100100b | 01101111b = 11101111b
-10100100b | 01110000b = 11110100b
-10100100b | 01110001b = 11110101b
-10100100b | 01110010b = 11110110b
-10100100b | 01110011b = 11110111b
-10100100b | 01110100b = 11110100b
-10100100b | 01110101b = 11110101b
-10100100b | 01110110b = 11110110b
-10100100b | 01110111b = 11110111b
-10100100b | 01111000b = 11111100b
-10100100b | 01111001b = 11111101b
-10100100b | 01111010b = 11111110b
-10100100b | 01111011b = 11111111b
-10100100b | 01111100b = 11111100b
-10100100b | 01111101b = 11111101b
-10100100b | 01111110b = 11111110b
-10100101b | 10000000b = 10100101b
-10100101b | 10000001b = 10100101b
-10100101b | 10000010b = 10100111b
-10100101b | 10000011b = 10100111b
-10100101b | 10000100b = 10100101b
-10100101b | 10000101b = 10100101b
-10100101b | 10000110b = 10100111b
-10100101b | 10000111b = 10100111b
-10100101b | 10001000b = 10101101b
-10100101b | 10001001b = 10101101b
-10100101b | 10001010b = 10101111b
-10100101b | 10001011b = 10101111b
-10100101b | 10001100b = 10101101b
-10100101b | 10001101b = 10101101b
-10100101b | 10001110b = 10101111b
-10100101b | 10001111b = 10101111b
-10100101b | 10010000b = 10110101b
-10100101b | 10010001b = 10110101b
-10100101b | 10010010b = 10110111b
-10100101b | 10010011b = 10110111b
-10100101b | 10010100b = 10110101b
-10100101b | 10010101b = 10110101b
-10100101b | 10010110b = 10110111b
-10100101b | 10010111b = 10110111b
-10100101b | 10011000b = 10111101b
-10100101b | 10011001b = 10111101b
-10100101b | 10011010b = 10111111b
-10100101b | 10011011b = 10111111b
-10100101b | 10011100b = 10111101b
-10100101b | 10011101b = 10111101b
-10100101b | 10011110b = 10111111b
-10100101b | 10011111b = 10111111b
-10100101b | 10100000b = 10100101b
-10100101b | 10100001b = 10100101b
-10100101b | 10100010b = 10100111b
-10100101b | 10100011b = 10100111b
-10100101b | 10100100b = 10100101b
-10100101b | 10100101b = 10100101b
-10100101b | 10100110b = 10100111b
-10100101b | 10100111b = 10100111b
-10100101b | 10101000b = 10101101b
-10100101b | 10101001b = 10101101b
-10100101b | 10101010b = 10101111b
-10100101b | 10101011b = 10101111b
-10100101b | 10101100b = 10101101b
-10100101b | 10101101b = 10101101b
-10100101b | 10101110b = 10101111b
-10100101b | 10101111b = 10101111b
-10100101b | 10110000b = 10110101b
-10100101b | 10110001b = 10110101b
-10100101b | 10110010b = 10110111b
-10100101b | 10110011b = 10110111b
-10100101b | 10110100b = 10110101b
-10100101b | 10110101b = 10110101b
-10100101b | 10110110b = 10110111b
-10100101b | 10110111b = 10110111b
-10100101b | 10111000b = 10111101b
-10100101b | 10111001b = 10111101b
-10100101b | 10111010b = 10111111b
-10100101b | 10111011b = 10111111b
-10100101b | 10111100b = 10111101b
-10100101b | 10111101b = 10111101b
-10100101b | 10111110b = 10111111b
-10100101b | 10111111b = 10111111b
-10100101b | 11000000b = 11100101b
-10100101b | 11000001b = 11100101b
-10100101b | 11000010b = 11100111b
-10100101b | 11000011b = 11100111b
-10100101b | 11000100b = 11100101b
-10100101b | 11000101b = 11100101b
-10100101b | 11000110b = 11100111b
-10100101b | 11000111b = 11100111b
-10100101b | 11001000b = 11101101b
-10100101b | 11001001b = 11101101b
-10100101b | 11001010b = 11101111b
-10100101b | 11001011b = 11101111b
-10100101b | 11001100b = 11101101b
-10100101b | 11001101b = 11101101b
-10100101b | 11001110b = 11101111b
-10100101b | 11001111b = 11101111b
-10100101b | 11010000b = 11110101b
-10100101b | 11010001b = 11110101b
-10100101b | 11010010b = 11110111b
-10100101b | 11010011b = 11110111b
-10100101b | 11010100b = 11110101b
-10100101b | 11010101b = 11110101b
-10100101b | 11010110b = 11110111b
-10100101b | 11010111b = 11110111b
-10100101b | 11011000b = 11111101b
-10100101b | 11011001b = 11111101b
-10100101b | 11011010b = 11111111b
-10100101b | 11011011b = 11111111b
-10100101b | 11011100b = 11111101b
-10100101b | 11011101b = 11111101b
-10100101b | 11011110b = 11111111b
-10100101b | 11011111b = 11111111b
-10100101b | 11100000b = 11100101b
-10100101b | 11100001b = 11100101b
-10100101b | 11100010b = 11100111b
-10100101b | 11100011b = 11100111b
-10100101b | 11100100b = 11100101b
-10100101b | 11100101b = 11100101b
-10100101b | 11100110b = 11100111b
-10100101b | 11100111b = 11100111b
-10100101b | 11101000b = 11101101b
-10100101b | 11101001b = 11101101b
-10100101b | 11101010b = 11101111b
-10100101b | 11101011b = 11101111b
-10100101b | 11101100b = 11101101b
-10100101b | 11101101b = 11101101b
-10100101b | 11101110b = 11101111b
-10100101b | 11101111b = 11101111b
-10100101b | 11110000b = 11110101b
-10100101b | 11110001b = 11110101b
-10100101b | 11110010b = 11110111b
-10100101b | 11110011b = 11110111b
-10100101b | 11110100b = 11110101b
-10100101b | 11110101b = 11110101b
-10100101b | 11110110b = 11110111b
-10100101b | 11110111b = 11110111b
-10100101b | 11111000b = 11111101b
-10100101b | 11111001b = 11111101b
-10100101b | 11111010b = 11111111b
-10100101b | 11111011b = 11111111b
-10100101b | 11111100b = 11111101b
-10100101b | 11111101b = 11111101b
-10100101b | 11111110b = 11111111b
-10100101b | 11111111b = 11111111b
-10100101b | 00000000b = 10100101b
-10100101b | 00000001b = 10100101b
-10100101b | 00000010b = 10100111b
-10100101b | 00000011b = 10100111b
-10100101b | 00000100b = 10100101b
-10100101b | 00000101b = 10100101b
-10100101b | 00000110b = 10100111b
-10100101b | 00000111b = 10100111b
-10100101b | 00001000b = 10101101b
-10100101b | 00001001b = 10101101b
-10100101b | 00001010b = 10101111b
-10100101b | 00001011b = 10101111b
-10100101b | 00001100b = 10101101b
-10100101b | 00001101b = 10101101b
-10100101b | 00001110b = 10101111b
-10100101b | 00001111b = 10101111b
-10100101b | 00010000b = 10110101b
-10100101b | 00010001b = 10110101b
-10100101b | 00010010b = 10110111b
-10100101b | 00010011b = 10110111b
-10100101b | 00010100b = 10110101b
-10100101b | 00010101b = 10110101b
-10100101b | 00010110b = 10110111b
-10100101b | 00010111b = 10110111b
-10100101b | 00011000b = 10111101b
-10100101b | 00011001b = 10111101b
-10100101b | 00011010b = 10111111b
-10100101b | 00011011b = 10111111b
-10100101b | 00011100b = 10111101b
-10100101b | 00011101b = 10111101b
-10100101b | 00011110b = 10111111b
-10100101b | 00011111b = 10111111b
-10100101b | 00100000b = 10100101b
-10100101b | 00100001b = 10100101b
-10100101b | 00100010b = 10100111b
-10100101b | 00100011b = 10100111b
-10100101b | 00100100b = 10100101b
-10100101b | 00100101b = 10100101b
-10100101b | 00100110b = 10100111b
-10100101b | 00100111b = 10100111b
-10100101b | 00101000b = 10101101b
-10100101b | 00101001b = 10101101b
-10100101b | 00101010b = 10101111b
-10100101b | 00101011b = 10101111b
-10100101b | 00101100b = 10101101b
-10100101b | 00101101b = 10101101b
-10100101b | 00101110b = 10101111b
-10100101b | 00101111b = 10101111b
-10100101b | 00110000b = 10110101b
-10100101b | 00110001b = 10110101b
-10100101b | 00110010b = 10110111b
-10100101b | 00110011b = 10110111b
-10100101b | 00110100b = 10110101b
-10100101b | 00110101b = 10110101b
-10100101b | 00110110b = 10110111b
-10100101b | 00110111b = 10110111b
-10100101b | 00111000b = 10111101b
-10100101b | 00111001b = 10111101b
-10100101b | 00111010b = 10111111b
-10100101b | 00111011b = 10111111b
-10100101b | 00111100b = 10111101b
-10100101b | 00111101b = 10111101b
-10100101b | 00111110b = 10111111b
-10100101b | 00111111b = 10111111b
-10100101b | 01000000b = 11100101b
-10100101b | 01000001b = 11100101b
-10100101b | 01000010b = 11100111b
-10100101b | 01000011b = 11100111b
-10100101b | 01000100b = 11100101b
-10100101b | 01000101b = 11100101b
-10100101b | 01000110b = 11100111b
-10100101b | 01000111b = 11100111b
-10100101b | 01001000b = 11101101b
-10100101b | 01001001b = 11101101b
-10100101b | 01001010b = 11101111b
-10100101b | 01001011b = 11101111b
-10100101b | 01001100b = 11101101b
-10100101b | 01001101b = 11101101b
-10100101b | 01001110b = 11101111b
-10100101b | 01001111b = 11101111b
-10100101b | 01010000b = 11110101b
-10100101b | 01010001b = 11110101b
-10100101b | 01010010b = 11110111b
-10100101b | 01010011b = 11110111b
-10100101b | 01010100b = 11110101b
-10100101b | 01010101b = 11110101b
-10100101b | 01010110b = 11110111b
-10100101b | 01010111b = 11110111b
-10100101b | 01011000b = 11111101b
-10100101b | 01011001b = 11111101b
-10100101b | 01011010b = 11111111b
-10100101b | 01011011b = 11111111b
-10100101b | 01011100b = 11111101b
-10100101b | 01011101b = 11111101b
-10100101b | 01011110b = 11111111b
-10100101b | 01011111b = 11111111b
-10100101b | 01100000b = 11100101b
-10100101b | 01100001b = 11100101b
-10100101b | 01100010b = 11100111b
-10100101b | 01100011b = 11100111b
-10100101b | 01100100b = 11100101b
-10100101b | 01100101b = 11100101b
-10100101b | 01100110b = 11100111b
-10100101b | 01100111b = 11100111b
-10100101b | 01101000b = 11101101b
-10100101b | 01101001b = 11101101b
-10100101b | 01101010b = 11101111b
-10100101b | 01101011b = 11101111b
-10100101b | 01101100b = 11101101b
-10100101b | 01101101b = 11101101b
-10100101b | 01101110b = 11101111b
-10100101b | 01101111b = 11101111b
-10100101b | 01110000b = 11110101b
-10100101b | 01110001b = 11110101b
-10100101b | 01110010b = 11110111b
-10100101b | 01110011b = 11110111b
-10100101b | 01110100b = 11110101b
-10100101b | 01110101b = 11110101b
-10100101b | 01110110b = 11110111b
-10100101b | 01110111b = 11110111b
-10100101b | 01111000b = 11111101b
-10100101b | 01111001b = 11111101b
-10100101b | 01111010b = 11111111b
-10100101b | 01111011b = 11111111b
-10100101b | 01111100b = 11111101b
-10100101b | 01111101b = 11111101b
-10100101b | 01111110b = 11111111b
-10100110b | 10000000b = 10100110b
-10100110b | 10000001b = 10100111b
-10100110b | 10000010b = 10100110b
-10100110b | 10000011b = 10100111b
-10100110b | 10000100b = 10100110b
-10100110b | 10000101b = 10100111b
-10100110b | 10000110b = 10100110b
-10100110b | 10000111b = 10100111b
-10100110b | 10001000b = 10101110b
-10100110b | 10001001b = 10101111b
-10100110b | 10001010b = 10101110b
-10100110b | 10001011b = 10101111b
-10100110b | 10001100b = 10101110b
-10100110b | 10001101b = 10101111b
-10100110b | 10001110b = 10101110b
-10100110b | 10001111b = 10101111b
-10100110b | 10010000b = 10110110b
-10100110b | 10010001b = 10110111b
-10100110b | 10010010b = 10110110b
-10100110b | 10010011b = 10110111b
-10100110b | 10010100b = 10110110b
-10100110b | 10010101b = 10110111b
-10100110b | 10010110b = 10110110b
-10100110b | 10010111b = 10110111b
-10100110b | 10011000b = 10111110b
-10100110b | 10011001b = 10111111b
-10100110b | 10011010b = 10111110b
-10100110b | 10011011b = 10111111b
-10100110b | 10011100b = 10111110b
-10100110b | 10011101b = 10111111b
-10100110b | 10011110b = 10111110b
-10100110b | 10011111b = 10111111b
-10100110b | 10100000b = 10100110b
-10100110b | 10100001b = 10100111b
-10100110b | 10100010b = 10100110b
-10100110b | 10100011b = 10100111b
-10100110b | 10100100b = 10100110b
-10100110b | 10100101b = 10100111b
-10100110b | 10100110b = 10100110b
-10100110b | 10100111b = 10100111b
-10100110b | 10101000b = 10101110b
-10100110b | 10101001b = 10101111b
-10100110b | 10101010b = 10101110b
-10100110b | 10101011b = 10101111b
-10100110b | 10101100b = 10101110b
-10100110b | 10101101b = 10101111b
-10100110b | 10101110b = 10101110b
-10100110b | 10101111b = 10101111b
-10100110b | 10110000b = 10110110b
-10100110b | 10110001b = 10110111b
-10100110b | 10110010b = 10110110b
-10100110b | 10110011b = 10110111b
-10100110b | 10110100b = 10110110b
-10100110b | 10110101b = 10110111b
-10100110b | 10110110b = 10110110b
-10100110b | 10110111b = 10110111b
-10100110b | 10111000b = 10111110b
-10100110b | 10111001b = 10111111b
-10100110b | 10111010b = 10111110b
-10100110b | 10111011b = 10111111b
-10100110b | 10111100b = 10111110b
-10100110b | 10111101b = 10111111b
-10100110b | 10111110b = 10111110b
-10100110b | 10111111b = 10111111b
-10100110b | 11000000b = 11100110b
-10100110b | 11000001b = 11100111b
-10100110b | 11000010b = 11100110b
-10100110b | 11000011b = 11100111b
-10100110b | 11000100b = 11100110b
-10100110b | 11000101b = 11100111b
-10100110b | 11000110b = 11100110b
-10100110b | 11000111b = 11100111b
-10100110b | 11001000b = 11101110b
-10100110b | 11001001b = 11101111b
-10100110b | 11001010b = 11101110b
-10100110b | 11001011b = 11101111b
-10100110b | 11001100b = 11101110b
-10100110b | 11001101b = 11101111b
-10100110b | 11001110b = 11101110b
-10100110b | 11001111b = 11101111b
-10100110b | 11010000b = 11110110b
-10100110b | 11010001b = 11110111b
-10100110b | 11010010b = 11110110b
-10100110b | 11010011b = 11110111b
-10100110b | 11010100b = 11110110b
-10100110b | 11010101b = 11110111b
-10100110b | 11010110b = 11110110b
-10100110b | 11010111b = 11110111b
-10100110b | 11011000b = 11111110b
-10100110b | 11011001b = 11111111b
-10100110b | 11011010b = 11111110b
-10100110b | 11011011b = 11111111b
-10100110b | 11011100b = 11111110b
-10100110b | 11011101b = 11111111b
-10100110b | 11011110b = 11111110b
-10100110b | 11011111b = 11111111b
-10100110b | 11100000b = 11100110b
-10100110b | 11100001b = 11100111b
-10100110b | 11100010b = 11100110b
-10100110b | 11100011b = 11100111b
-10100110b | 11100100b = 11100110b
-10100110b | 11100101b = 11100111b
-10100110b | 11100110b = 11100110b
-10100110b | 11100111b = 11100111b
-10100110b | 11101000b = 11101110b
-10100110b | 11101001b = 11101111b
-10100110b | 11101010b = 11101110b
-10100110b | 11101011b = 11101111b
-10100110b | 11101100b = 11101110b
-10100110b | 11101101b = 11101111b
-10100110b | 11101110b = 11101110b
-10100110b | 11101111b = 11101111b
-10100110b | 11110000b = 11110110b
-10100110b | 11110001b = 11110111b
-10100110b | 11110010b = 11110110b
-10100110b | 11110011b = 11110111b
-10100110b | 11110100b = 11110110b
-10100110b | 11110101b = 11110111b
-10100110b | 11110110b = 11110110b
-10100110b | 11110111b = 11110111b
-10100110b | 11111000b = 11111110b
-10100110b | 11111001b = 11111111b
-10100110b | 11111010b = 11111110b
-10100110b | 11111011b = 11111111b
-10100110b | 11111100b = 11111110b
-10100110b | 11111101b = 11111111b
-10100110b | 11111110b = 11111110b
-10100110b | 11111111b = 11111111b
-10100110b | 00000000b = 10100110b
-10100110b | 00000001b = 10100111b
-10100110b | 00000010b = 10100110b
-10100110b | 00000011b = 10100111b
-10100110b | 00000100b = 10100110b
-10100110b | 00000101b = 10100111b
-10100110b | 00000110b = 10100110b
-10100110b | 00000111b = 10100111b
-10100110b | 00001000b = 10101110b
-10100110b | 00001001b = 10101111b
-10100110b | 00001010b = 10101110b
-10100110b | 00001011b = 10101111b
-10100110b | 00001100b = 10101110b
-10100110b | 00001101b = 10101111b
-10100110b | 00001110b = 10101110b
-10100110b | 00001111b = 10101111b
-10100110b | 00010000b = 10110110b
-10100110b | 00010001b = 10110111b
-10100110b | 00010010b = 10110110b
-10100110b | 00010011b = 10110111b
-10100110b | 00010100b = 10110110b
-10100110b | 00010101b = 10110111b
-10100110b | 00010110b = 10110110b
-10100110b | 00010111b = 10110111b
-10100110b | 00011000b = 10111110b
-10100110b | 00011001b = 10111111b
-10100110b | 00011010b = 10111110b
-10100110b | 00011011b = 10111111b
-10100110b | 00011100b = 10111110b
-10100110b | 00011101b = 10111111b
-10100110b | 00011110b = 10111110b
-10100110b | 00011111b = 10111111b
-10100110b | 00100000b = 10100110b
-10100110b | 00100001b = 10100111b
-10100110b | 00100010b = 10100110b
-10100110b | 00100011b = 10100111b
-10100110b | 00100100b = 10100110b
-10100110b | 00100101b = 10100111b
-10100110b | 00100110b = 10100110b
-10100110b | 00100111b = 10100111b
-10100110b | 00101000b = 10101110b
-10100110b | 00101001b = 10101111b
-10100110b | 00101010b = 10101110b
-10100110b | 00101011b = 10101111b
-10100110b | 00101100b = 10101110b
-10100110b | 00101101b = 10101111b
-10100110b | 00101110b = 10101110b
-10100110b | 00101111b = 10101111b
-10100110b | 00110000b = 10110110b
-10100110b | 00110001b = 10110111b
-10100110b | 00110010b = 10110110b
-10100110b | 00110011b = 10110111b
-10100110b | 00110100b = 10110110b
-10100110b | 00110101b = 10110111b
-10100110b | 00110110b = 10110110b
-10100110b | 00110111b = 10110111b
-10100110b | 00111000b = 10111110b
-10100110b | 00111001b = 10111111b
-10100110b | 00111010b = 10111110b
-10100110b | 00111011b = 10111111b
-10100110b | 00111100b = 10111110b
-10100110b | 00111101b = 10111111b
-10100110b | 00111110b = 10111110b
-10100110b | 00111111b = 10111111b
-10100110b | 01000000b = 11100110b
-10100110b | 01000001b = 11100111b
-10100110b | 01000010b = 11100110b
-10100110b | 01000011b = 11100111b
-10100110b | 01000100b = 11100110b
-10100110b | 01000101b = 11100111b
-10100110b | 01000110b = 11100110b
-10100110b | 01000111b = 11100111b
-10100110b | 01001000b = 11101110b
-10100110b | 01001001b = 11101111b
-10100110b | 01001010b = 11101110b
-10100110b | 01001011b = 11101111b
-10100110b | 01001100b = 11101110b
-10100110b | 01001101b = 11101111b
-10100110b | 01001110b = 11101110b
-10100110b | 01001111b = 11101111b
-10100110b | 01010000b = 11110110b
-10100110b | 01010001b = 11110111b
-10100110b | 01010010b = 11110110b
-10100110b | 01010011b = 11110111b
-10100110b | 01010100b = 11110110b
-10100110b | 01010101b = 11110111b
-10100110b | 01010110b = 11110110b
-10100110b | 01010111b = 11110111b
-10100110b | 01011000b = 11111110b
-10100110b | 01011001b = 11111111b
-10100110b | 01011010b = 11111110b
-10100110b | 01011011b = 11111111b
-10100110b | 01011100b = 11111110b
-10100110b | 01011101b = 11111111b
-10100110b | 01011110b = 11111110b
-10100110b | 01011111b = 11111111b
-10100110b | 01100000b = 11100110b
-10100110b | 01100001b = 11100111b
-10100110b | 01100010b = 11100110b
-10100110b | 01100011b = 11100111b
-10100110b | 01100100b = 11100110b
-10100110b | 01100101b = 11100111b
-10100110b | 01100110b = 11100110b
-10100110b | 01100111b = 11100111b
-10100110b | 01101000b = 11101110b
-10100110b | 01101001b = 11101111b
-10100110b | 01101010b = 11101110b
-10100110b | 01101011b = 11101111b
-10100110b | 01101100b = 11101110b
-10100110b | 01101101b = 11101111b
-10100110b | 01101110b = 11101110b
-10100110b | 01101111b = 11101111b
-10100110b | 01110000b = 11110110b
-10100110b | 01110001b = 11110111b
-10100110b | 01110010b = 11110110b
-10100110b | 01110011b = 11110111b
-10100110b | 01110100b = 11110110b
-10100110b | 01110101b = 11110111b
-10100110b | 01110110b = 11110110b
-10100110b | 01110111b = 11110111b
-10100110b | 01111000b = 11111110b
-10100110b | 01111001b = 11111111b
-10100110b | 01111010b = 11111110b
-10100110b | 01111011b = 11111111b
-10100110b | 01111100b = 11111110b
-10100110b | 01111101b = 11111111b
-10100110b | 01111110b = 11111110b
-10100111b | 10000000b = 10100111b
-10100111b | 10000001b = 10100111b
-10100111b | 10000010b = 10100111b
-10100111b | 10000011b = 10100111b
-10100111b | 10000100b = 10100111b
-10100111b | 10000101b = 10100111b
-10100111b | 10000110b = 10100111b
-10100111b | 10000111b = 10100111b
-10100111b | 10001000b = 10101111b
-10100111b | 10001001b = 10101111b
-10100111b | 10001010b = 10101111b
-10100111b | 10001011b = 10101111b
-10100111b | 10001100b = 10101111b
-10100111b | 10001101b = 10101111b
-10100111b | 10001110b = 10101111b
-10100111b | 10001111b = 10101111b
-10100111b | 10010000b = 10110111b
-10100111b | 10010001b = 10110111b
-10100111b | 10010010b = 10110111b
-10100111b | 10010011b = 10110111b
-10100111b | 10010100b = 10110111b
-10100111b | 10010101b = 10110111b
-10100111b | 10010110b = 10110111b
-10100111b | 10010111b = 10110111b
-10100111b | 10011000b = 10111111b
-10100111b | 10011001b = 10111111b
-10100111b | 10011010b = 10111111b
-10100111b | 10011011b = 10111111b
-10100111b | 10011100b = 10111111b
-10100111b | 10011101b = 10111111b
-10100111b | 10011110b = 10111111b
-10100111b | 10011111b = 10111111b
-10100111b | 10100000b = 10100111b
-10100111b | 10100001b = 10100111b
-10100111b | 10100010b = 10100111b
-10100111b | 10100011b = 10100111b
-10100111b | 10100100b = 10100111b
-10100111b | 10100101b = 10100111b
-10100111b | 10100110b = 10100111b
-10100111b | 10100111b = 10100111b
-10100111b | 10101000b = 10101111b
-10100111b | 10101001b = 10101111b
-10100111b | 10101010b = 10101111b
-10100111b | 10101011b = 10101111b
-10100111b | 10101100b = 10101111b
-10100111b | 10101101b = 10101111b
-10100111b | 10101110b = 10101111b
-10100111b | 10101111b = 10101111b
-10100111b | 10110000b = 10110111b
-10100111b | 10110001b = 10110111b
-10100111b | 10110010b = 10110111b
-10100111b | 10110011b = 10110111b
-10100111b | 10110100b = 10110111b
-10100111b | 10110101b = 10110111b
-10100111b | 10110110b = 10110111b
-10100111b | 10110111b = 10110111b
-10100111b | 10111000b = 10111111b
-10100111b | 10111001b = 10111111b
-10100111b | 10111010b = 10111111b
-10100111b | 10111011b = 10111111b
-10100111b | 10111100b = 10111111b
-10100111b | 10111101b = 10111111b
-10100111b | 10111110b = 10111111b
-10100111b | 10111111b = 10111111b
-10100111b | 11000000b = 11100111b
-10100111b | 11000001b = 11100111b
-10100111b | 11000010b = 11100111b
-10100111b | 11000011b = 11100111b
-10100111b | 11000100b = 11100111b
-10100111b | 11000101b = 11100111b
-10100111b | 11000110b = 11100111b
-10100111b | 11000111b = 11100111b
-10100111b | 11001000b = 11101111b
-10100111b | 11001001b = 11101111b
-10100111b | 11001010b = 11101111b
-10100111b | 11001011b = 11101111b
-10100111b | 11001100b = 11101111b
-10100111b | 11001101b = 11101111b
-10100111b | 11001110b = 11101111b
-10100111b | 11001111b = 11101111b
-10100111b | 11010000b = 11110111b
-10100111b | 11010001b = 11110111b
-10100111b | 11010010b = 11110111b
-10100111b | 11010011b = 11110111b
-10100111b | 11010100b = 11110111b
-10100111b | 11010101b = 11110111b
-10100111b | 11010110b = 11110111b
-10100111b | 11010111b = 11110111b
-10100111b | 11011000b = 11111111b
-10100111b | 11011001b = 11111111b
-10100111b | 11011010b = 11111111b
-10100111b | 11011011b = 11111111b
-10100111b | 11011100b = 11111111b
-10100111b | 11011101b = 11111111b
-10100111b | 11011110b = 11111111b
-10100111b | 11011111b = 11111111b
-10100111b | 11100000b = 11100111b
-10100111b | 11100001b = 11100111b
-10100111b | 11100010b = 11100111b
-10100111b | 11100011b = 11100111b
-10100111b | 11100100b = 11100111b
-10100111b | 11100101b = 11100111b
-10100111b | 11100110b = 11100111b
-10100111b | 11100111b = 11100111b
-10100111b | 11101000b = 11101111b
-10100111b | 11101001b = 11101111b
-10100111b | 11101010b = 11101111b
-10100111b | 11101011b = 11101111b
-10100111b | 11101100b = 11101111b
-10100111b | 11101101b = 11101111b
-10100111b | 11101110b = 11101111b
-10100111b | 11101111b = 11101111b
-10100111b | 11110000b = 11110111b
-10100111b | 11110001b = 11110111b
-10100111b | 11110010b = 11110111b
-10100111b | 11110011b = 11110111b
-10100111b | 11110100b = 11110111b
-10100111b | 11110101b = 11110111b
-10100111b | 11110110b = 11110111b
-10100111b | 11110111b = 11110111b
-10100111b | 11111000b = 11111111b
-10100111b | 11111001b = 11111111b
-10100111b | 11111010b = 11111111b
-10100111b | 11111011b = 11111111b
-10100111b | 11111100b = 11111111b
-10100111b | 11111101b = 11111111b
-10100111b | 11111110b = 11111111b
-10100111b | 11111111b = 11111111b
-10100111b | 00000000b = 10100111b
-10100111b | 00000001b = 10100111b
-10100111b | 00000010b = 10100111b
-10100111b | 00000011b = 10100111b
-10100111b | 00000100b = 10100111b
-10100111b | 00000101b = 10100111b
-10100111b | 00000110b = 10100111b
-10100111b | 00000111b = 10100111b
-10100111b | 00001000b = 10101111b
-10100111b | 00001001b = 10101111b
-10100111b | 00001010b = 10101111b
-10100111b | 00001011b = 10101111b
-10100111b | 00001100b = 10101111b
-10100111b | 00001101b = 10101111b
-10100111b | 00001110b = 10101111b
-10100111b | 00001111b = 10101111b
-10100111b | 00010000b = 10110111b
-10100111b | 00010001b = 10110111b
-10100111b | 00010010b = 10110111b
-10100111b | 00010011b = 10110111b
-10100111b | 00010100b = 10110111b
-10100111b | 00010101b = 10110111b
-10100111b | 00010110b = 10110111b
-10100111b | 00010111b = 10110111b
-10100111b | 00011000b = 10111111b
-10100111b | 00011001b = 10111111b
-10100111b | 00011010b = 10111111b
-10100111b | 00011011b = 10111111b
-10100111b | 00011100b = 10111111b
-10100111b | 00011101b = 10111111b
-10100111b | 00011110b = 10111111b
-10100111b | 00011111b = 10111111b
-10100111b | 00100000b = 10100111b
-10100111b | 00100001b = 10100111b
-10100111b | 00100010b = 10100111b
-10100111b | 00100011b = 10100111b
-10100111b | 00100100b = 10100111b
-10100111b | 00100101b = 10100111b
-10100111b | 00100110b = 10100111b
-10100111b | 00100111b = 10100111b
-10100111b | 00101000b = 10101111b
-10100111b | 00101001b = 10101111b
-10100111b | 00101010b = 10101111b
-10100111b | 00101011b = 10101111b
-10100111b | 00101100b = 10101111b
-10100111b | 00101101b = 10101111b
-10100111b | 00101110b = 10101111b
-10100111b | 00101111b = 10101111b
-10100111b | 00110000b = 10110111b
-10100111b | 00110001b = 10110111b
-10100111b | 00110010b = 10110111b
-10100111b | 00110011b = 10110111b
-10100111b | 00110100b = 10110111b
-10100111b | 00110101b = 10110111b
-10100111b | 00110110b = 10110111b
-10100111b | 00110111b = 10110111b
-10100111b | 00111000b = 10111111b
-10100111b | 00111001b = 10111111b
-10100111b | 00111010b = 10111111b
-10100111b | 00111011b = 10111111b
-10100111b | 00111100b = 10111111b
-10100111b | 00111101b = 10111111b
-10100111b | 00111110b = 10111111b
-10100111b | 00111111b = 10111111b
-10100111b | 01000000b = 11100111b
-10100111b | 01000001b = 11100111b
-10100111b | 01000010b = 11100111b
-10100111b | 01000011b = 11100111b
-10100111b | 01000100b = 11100111b
-10100111b | 01000101b = 11100111b
-10100111b | 01000110b = 11100111b
-10100111b | 01000111b = 11100111b
-10100111b | 01001000b = 11101111b
-10100111b | 01001001b = 11101111b
-10100111b | 01001010b = 11101111b
-10100111b | 01001011b = 11101111b
-10100111b | 01001100b = 11101111b
-10100111b | 01001101b = 11101111b
-10100111b | 01001110b = 11101111b
-10100111b | 01001111b = 11101111b
-10100111b | 01010000b = 11110111b
-10100111b | 01010001b = 11110111b
-10100111b | 01010010b = 11110111b
-10100111b | 01010011b = 11110111b
-10100111b | 01010100b = 11110111b
-10100111b | 01010101b = 11110111b
-10100111b | 01010110b = 11110111b
-10100111b | 01010111b = 11110111b
-10100111b | 01011000b = 11111111b
-10100111b | 01011001b = 11111111b
-10100111b | 01011010b = 11111111b
-10100111b | 01011011b = 11111111b
-10100111b | 01011100b = 11111111b
-10100111b | 01011101b = 11111111b
-10100111b | 01011110b = 11111111b
-10100111b | 01011111b = 11111111b
-10100111b | 01100000b = 11100111b
-10100111b | 01100001b = 11100111b
-10100111b | 01100010b = 11100111b
-10100111b | 01100011b = 11100111b
-10100111b | 01100100b = 11100111b
-10100111b | 01100101b = 11100111b
-10100111b | 01100110b = 11100111b
-10100111b | 01100111b = 11100111b
-10100111b | 01101000b = 11101111b
-10100111b | 01101001b = 11101111b
-10100111b | 01101010b = 11101111b
-10100111b | 01101011b = 11101111b
-10100111b | 01101100b = 11101111b
-10100111b | 01101101b = 11101111b
-10100111b | 01101110b = 11101111b
-10100111b | 01101111b = 11101111b
-10100111b | 01110000b = 11110111b
-10100111b | 01110001b = 11110111b
-10100111b | 01110010b = 11110111b
-10100111b | 01110011b = 11110111b
-10100111b | 01110100b = 11110111b
-10100111b | 01110101b = 11110111b
-10100111b | 01110110b = 11110111b
-10100111b | 01110111b = 11110111b
-10100111b | 01111000b = 11111111b
-10100111b | 01111001b = 11111111b
-10100111b | 01111010b = 11111111b
-10100111b | 01111011b = 11111111b
-10100111b | 01111100b = 11111111b
-10100111b | 01111101b = 11111111b
-10100111b | 01111110b = 11111111b
-10101000b | 10000000b = 10101000b
-10101000b | 10000001b = 10101001b
-10101000b | 10000010b = 10101010b
-10101000b | 10000011b = 10101011b
-10101000b | 10000100b = 10101100b
-10101000b | 10000101b = 10101101b
-10101000b | 10000110b = 10101110b
-10101000b | 10000111b = 10101111b
-10101000b | 10001000b = 10101000b
-10101000b | 10001001b = 10101001b
-10101000b | 10001010b = 10101010b
-10101000b | 10001011b = 10101011b
-10101000b | 10001100b = 10101100b
-10101000b | 10001101b = 10101101b
-10101000b | 10001110b = 10101110b
-10101000b | 10001111b = 10101111b
-10101000b | 10010000b = 10111000b
-10101000b | 10010001b = 10111001b
-10101000b | 10010010b = 10111010b
-10101000b | 10010011b = 10111011b
-10101000b | 10010100b = 10111100b
-10101000b | 10010101b = 10111101b
-10101000b | 10010110b = 10111110b
-10101000b | 10010111b = 10111111b
-10101000b | 10011000b = 10111000b
-10101000b | 10011001b = 10111001b
-10101000b | 10011010b = 10111010b
-10101000b | 10011011b = 10111011b
-10101000b | 10011100b = 10111100b
-10101000b | 10011101b = 10111101b
-10101000b | 10011110b = 10111110b
-10101000b | 10011111b = 10111111b
-10101000b | 10100000b = 10101000b
-10101000b | 10100001b = 10101001b
-10101000b | 10100010b = 10101010b
-10101000b | 10100011b = 10101011b
-10101000b | 10100100b = 10101100b
-10101000b | 10100101b = 10101101b
-10101000b | 10100110b = 10101110b
-10101000b | 10100111b = 10101111b
-10101000b | 10101000b = 10101000b
-10101000b | 10101001b = 10101001b
-10101000b | 10101010b = 10101010b
-10101000b | 10101011b = 10101011b
-10101000b | 10101100b = 10101100b
-10101000b | 10101101b = 10101101b
-10101000b | 10101110b = 10101110b
-10101000b | 10101111b = 10101111b
-10101000b | 10110000b = 10111000b
-10101000b | 10110001b = 10111001b
-10101000b | 10110010b = 10111010b
-10101000b | 10110011b = 10111011b
-10101000b | 10110100b = 10111100b
-10101000b | 10110101b = 10111101b
-10101000b | 10110110b = 10111110b
-10101000b | 10110111b = 10111111b
-10101000b | 10111000b = 10111000b
-10101000b | 10111001b = 10111001b
-10101000b | 10111010b = 10111010b
-10101000b | 10111011b = 10111011b
-10101000b | 10111100b = 10111100b
-10101000b | 10111101b = 10111101b
-10101000b | 10111110b = 10111110b
-10101000b | 10111111b = 10111111b
-10101000b | 11000000b = 11101000b
-10101000b | 11000001b = 11101001b
-10101000b | 11000010b = 11101010b
-10101000b | 11000011b = 11101011b
-10101000b | 11000100b = 11101100b
-10101000b | 11000101b = 11101101b
-10101000b | 11000110b = 11101110b
-10101000b | 11000111b = 11101111b
-10101000b | 11001000b = 11101000b
-10101000b | 11001001b = 11101001b
-10101000b | 11001010b = 11101010b
-10101000b | 11001011b = 11101011b
-10101000b | 11001100b = 11101100b
-10101000b | 11001101b = 11101101b
-10101000b | 11001110b = 11101110b
-10101000b | 11001111b = 11101111b
-10101000b | 11010000b = 11111000b
-10101000b | 11010001b = 11111001b
-10101000b | 11010010b = 11111010b
-10101000b | 11010011b = 11111011b
-10101000b | 11010100b = 11111100b
-10101000b | 11010101b = 11111101b
-10101000b | 11010110b = 11111110b
-10101000b | 11010111b = 11111111b
-10101000b | 11011000b = 11111000b
-10101000b | 11011001b = 11111001b
-10101000b | 11011010b = 11111010b
-10101000b | 11011011b = 11111011b
-10101000b | 11011100b = 11111100b
-10101000b | 11011101b = 11111101b
-10101000b | 11011110b = 11111110b
-10101000b | 11011111b = 11111111b
-10101000b | 11100000b = 11101000b
-10101000b | 11100001b = 11101001b
-10101000b | 11100010b = 11101010b
-10101000b | 11100011b = 11101011b
-10101000b | 11100100b = 11101100b
-10101000b | 11100101b = 11101101b
-10101000b | 11100110b = 11101110b
-10101000b | 11100111b = 11101111b
-10101000b | 11101000b = 11101000b
-10101000b | 11101001b = 11101001b
-10101000b | 11101010b = 11101010b
-10101000b | 11101011b = 11101011b
-10101000b | 11101100b = 11101100b
-10101000b | 11101101b = 11101101b
-10101000b | 11101110b = 11101110b
-10101000b | 11101111b = 11101111b
-10101000b | 11110000b = 11111000b
-10101000b | 11110001b = 11111001b
-10101000b | 11110010b = 11111010b
-10101000b | 11110011b = 11111011b
-10101000b | 11110100b = 11111100b
-10101000b | 11110101b = 11111101b
-10101000b | 11110110b = 11111110b
-10101000b | 11110111b = 11111111b
-10101000b | 11111000b = 11111000b
-10101000b | 11111001b = 11111001b
-10101000b | 11111010b = 11111010b
-10101000b | 11111011b = 11111011b
-10101000b | 11111100b = 11111100b
-10101000b | 11111101b = 11111101b
-10101000b | 11111110b = 11111110b
-10101000b | 11111111b = 11111111b
-10101000b | 00000000b = 10101000b
-10101000b | 00000001b = 10101001b
-10101000b | 00000010b = 10101010b
-10101000b | 00000011b = 10101011b
-10101000b | 00000100b = 10101100b
-10101000b | 00000101b = 10101101b
-10101000b | 00000110b = 10101110b
-10101000b | 00000111b = 10101111b
-10101000b | 00001000b = 10101000b
-10101000b | 00001001b = 10101001b
-10101000b | 00001010b = 10101010b
-10101000b | 00001011b = 10101011b
-10101000b | 00001100b = 10101100b
-10101000b | 00001101b = 10101101b
-10101000b | 00001110b = 10101110b
-10101000b | 00001111b = 10101111b
-10101000b | 00010000b = 10111000b
-10101000b | 00010001b = 10111001b
-10101000b | 00010010b = 10111010b
-10101000b | 00010011b = 10111011b
-10101000b | 00010100b = 10111100b
-10101000b | 00010101b = 10111101b
-10101000b | 00010110b = 10111110b
-10101000b | 00010111b = 10111111b
-10101000b | 00011000b = 10111000b
-10101000b | 00011001b = 10111001b
-10101000b | 00011010b = 10111010b
-10101000b | 00011011b = 10111011b
-10101000b | 00011100b = 10111100b
-10101000b | 00011101b = 10111101b
-10101000b | 00011110b = 10111110b
-10101000b | 00011111b = 10111111b
-10101000b | 00100000b = 10101000b
-10101000b | 00100001b = 10101001b
-10101000b | 00100010b = 10101010b
-10101000b | 00100011b = 10101011b
-10101000b | 00100100b = 10101100b
-10101000b | 00100101b = 10101101b
-10101000b | 00100110b = 10101110b
-10101000b | 00100111b = 10101111b
-10101000b | 00101000b = 10101000b
-10101000b | 00101001b = 10101001b
-10101000b | 00101010b = 10101010b
-10101000b | 00101011b = 10101011b
-10101000b | 00101100b = 10101100b
-10101000b | 00101101b = 10101101b
-10101000b | 00101110b = 10101110b
-10101000b | 00101111b = 10101111b
-10101000b | 00110000b = 10111000b
-10101000b | 00110001b = 10111001b
-10101000b | 00110010b = 10111010b
-10101000b | 00110011b = 10111011b
-10101000b | 00110100b = 10111100b
-10101000b | 00110101b = 10111101b
-10101000b | 00110110b = 10111110b
-10101000b | 00110111b = 10111111b
-10101000b | 00111000b = 10111000b
-10101000b | 00111001b = 10111001b
-10101000b | 00111010b = 10111010b
-10101000b | 00111011b = 10111011b
-10101000b | 00111100b = 10111100b
-10101000b | 00111101b = 10111101b
-10101000b | 00111110b = 10111110b
-10101000b | 00111111b = 10111111b
-10101000b | 01000000b = 11101000b
-10101000b | 01000001b = 11101001b
-10101000b | 01000010b = 11101010b
-10101000b | 01000011b = 11101011b
-10101000b | 01000100b = 11101100b
-10101000b | 01000101b = 11101101b
-10101000b | 01000110b = 11101110b
-10101000b | 01000111b = 11101111b
-10101000b | 01001000b = 11101000b
-10101000b | 01001001b = 11101001b
-10101000b | 01001010b = 11101010b
-10101000b | 01001011b = 11101011b
-10101000b | 01001100b = 11101100b
-10101000b | 01001101b = 11101101b
-10101000b | 01001110b = 11101110b
-10101000b | 01001111b = 11101111b
-10101000b | 01010000b = 11111000b
-10101000b | 01010001b = 11111001b
-10101000b | 01010010b = 11111010b
-10101000b | 01010011b = 11111011b
-10101000b | 01010100b = 11111100b
-10101000b | 01010101b = 11111101b
-10101000b | 01010110b = 11111110b
-10101000b | 01010111b = 11111111b
-10101000b | 01011000b = 11111000b
-10101000b | 01011001b = 11111001b
-10101000b | 01011010b = 11111010b
-10101000b | 01011011b = 11111011b
-10101000b | 01011100b = 11111100b
-10101000b | 01011101b = 11111101b
-10101000b | 01011110b = 11111110b
-10101000b | 01011111b = 11111111b
-10101000b | 01100000b = 11101000b
-10101000b | 01100001b = 11101001b
-10101000b | 01100010b = 11101010b
-10101000b | 01100011b = 11101011b
-10101000b | 01100100b = 11101100b
-10101000b | 01100101b = 11101101b
-10101000b | 01100110b = 11101110b
-10101000b | 01100111b = 11101111b
-10101000b | 01101000b = 11101000b
-10101000b | 01101001b = 11101001b
-10101000b | 01101010b = 11101010b
-10101000b | 01101011b = 11101011b
-10101000b | 01101100b = 11101100b
-10101000b | 01101101b = 11101101b
-10101000b | 01101110b = 11101110b
-10101000b | 01101111b = 11101111b
-10101000b | 01110000b = 11111000b
-10101000b | 01110001b = 11111001b
-10101000b | 01110010b = 11111010b
-10101000b | 01110011b = 11111011b
-10101000b | 01110100b = 11111100b
-10101000b | 01110101b = 11111101b
-10101000b | 01110110b = 11111110b
-10101000b | 01110111b = 11111111b
-10101000b | 01111000b = 11111000b
-10101000b | 01111001b = 11111001b
-10101000b | 01111010b = 11111010b
-10101000b | 01111011b = 11111011b
-10101000b | 01111100b = 11111100b
-10101000b | 01111101b = 11111101b
-10101000b | 01111110b = 11111110b
-10101001b | 10000000b = 10101001b
-10101001b | 10000001b = 10101001b
-10101001b | 10000010b = 10101011b
-10101001b | 10000011b = 10101011b
-10101001b | 10000100b = 10101101b
-10101001b | 10000101b = 10101101b
-10101001b | 10000110b = 10101111b
-10101001b | 10000111b = 10101111b
-10101001b | 10001000b = 10101001b
-10101001b | 10001001b = 10101001b
-10101001b | 10001010b = 10101011b
-10101001b | 10001011b = 10101011b
-10101001b | 10001100b = 10101101b
-10101001b | 10001101b = 10101101b
-10101001b | 10001110b = 10101111b
-10101001b | 10001111b = 10101111b
-10101001b | 10010000b = 10111001b
-10101001b | 10010001b = 10111001b
-10101001b | 10010010b = 10111011b
-10101001b | 10010011b = 10111011b
-10101001b | 10010100b = 10111101b
-10101001b | 10010101b = 10111101b
-10101001b | 10010110b = 10111111b
-10101001b | 10010111b = 10111111b
-10101001b | 10011000b = 10111001b
-10101001b | 10011001b = 10111001b
-10101001b | 10011010b = 10111011b
-10101001b | 10011011b = 10111011b
-10101001b | 10011100b = 10111101b
-10101001b | 10011101b = 10111101b
-10101001b | 10011110b = 10111111b
-10101001b | 10011111b = 10111111b
-10101001b | 10100000b = 10101001b
-10101001b | 10100001b = 10101001b
-10101001b | 10100010b = 10101011b
-10101001b | 10100011b = 10101011b
-10101001b | 10100100b = 10101101b
-10101001b | 10100101b = 10101101b
-10101001b | 10100110b = 10101111b
-10101001b | 10100111b = 10101111b
-10101001b | 10101000b = 10101001b
-10101001b | 10101001b = 10101001b
-10101001b | 10101010b = 10101011b
-10101001b | 10101011b = 10101011b
-10101001b | 10101100b = 10101101b
-10101001b | 10101101b = 10101101b
-10101001b | 10101110b = 10101111b
-10101001b | 10101111b = 10101111b
-10101001b | 10110000b = 10111001b
-10101001b | 10110001b = 10111001b
-10101001b | 10110010b = 10111011b
-10101001b | 10110011b = 10111011b
-10101001b | 10110100b = 10111101b
-10101001b | 10110101b = 10111101b
-10101001b | 10110110b = 10111111b
-10101001b | 10110111b = 10111111b
-10101001b | 10111000b = 10111001b
-10101001b | 10111001b = 10111001b
-10101001b | 10111010b = 10111011b
-10101001b | 10111011b = 10111011b
-10101001b | 10111100b = 10111101b
-10101001b | 10111101b = 10111101b
-10101001b | 10111110b = 10111111b
-10101001b | 10111111b = 10111111b
-10101001b | 11000000b = 11101001b
-10101001b | 11000001b = 11101001b
-10101001b | 11000010b = 11101011b
-10101001b | 11000011b = 11101011b
-10101001b | 11000100b = 11101101b
-10101001b | 11000101b = 11101101b
-10101001b | 11000110b = 11101111b
-10101001b | 11000111b = 11101111b
-10101001b | 11001000b = 11101001b
-10101001b | 11001001b = 11101001b
-10101001b | 11001010b = 11101011b
-10101001b | 11001011b = 11101011b
-10101001b | 11001100b = 11101101b
-10101001b | 11001101b = 11101101b
-10101001b | 11001110b = 11101111b
-10101001b | 11001111b = 11101111b
-10101001b | 11010000b = 11111001b
-10101001b | 11010001b = 11111001b
-10101001b | 11010010b = 11111011b
-10101001b | 11010011b = 11111011b
-10101001b | 11010100b = 11111101b
-10101001b | 11010101b = 11111101b
-10101001b | 11010110b = 11111111b
-10101001b | 11010111b = 11111111b
-10101001b | 11011000b = 11111001b
-10101001b | 11011001b = 11111001b
-10101001b | 11011010b = 11111011b
-10101001b | 11011011b = 11111011b
-10101001b | 11011100b = 11111101b
-10101001b | 11011101b = 11111101b
-10101001b | 11011110b = 11111111b
-10101001b | 11011111b = 11111111b
-10101001b | 11100000b = 11101001b
-10101001b | 11100001b = 11101001b
-10101001b | 11100010b = 11101011b
-10101001b | 11100011b = 11101011b
-10101001b | 11100100b = 11101101b
-10101001b | 11100101b = 11101101b
-10101001b | 11100110b = 11101111b
-10101001b | 11100111b = 11101111b
-10101001b | 11101000b = 11101001b
-10101001b | 11101001b = 11101001b
-10101001b | 11101010b = 11101011b
-10101001b | 11101011b = 11101011b
-10101001b | 11101100b = 11101101b
-10101001b | 11101101b = 11101101b
-10101001b | 11101110b = 11101111b
-10101001b | 11101111b = 11101111b
-10101001b | 11110000b = 11111001b
-10101001b | 11110001b = 11111001b
-10101001b | 11110010b = 11111011b
-10101001b | 11110011b = 11111011b
-10101001b | 11110100b = 11111101b
-10101001b | 11110101b = 11111101b
-10101001b | 11110110b = 11111111b
-10101001b | 11110111b = 11111111b
-10101001b | 11111000b = 11111001b
-10101001b | 11111001b = 11111001b
-10101001b | 11111010b = 11111011b
-10101001b | 11111011b = 11111011b
-10101001b | 11111100b = 11111101b
-10101001b | 11111101b = 11111101b
-10101001b | 11111110b = 11111111b
-10101001b | 11111111b = 11111111b
-10101001b | 00000000b = 10101001b
-10101001b | 00000001b = 10101001b
-10101001b | 00000010b = 10101011b
-10101001b | 00000011b = 10101011b
-10101001b | 00000100b = 10101101b
-10101001b | 00000101b = 10101101b
-10101001b | 00000110b = 10101111b
-10101001b | 00000111b = 10101111b
-10101001b | 00001000b = 10101001b
-10101001b | 00001001b = 10101001b
-10101001b | 00001010b = 10101011b
-10101001b | 00001011b = 10101011b
-10101001b | 00001100b = 10101101b
-10101001b | 00001101b = 10101101b
-10101001b | 00001110b = 10101111b
-10101001b | 00001111b = 10101111b
-10101001b | 00010000b = 10111001b
-10101001b | 00010001b = 10111001b
-10101001b | 00010010b = 10111011b
-10101001b | 00010011b = 10111011b
-10101001b | 00010100b = 10111101b
-10101001b | 00010101b = 10111101b
-10101001b | 00010110b = 10111111b
-10101001b | 00010111b = 10111111b
-10101001b | 00011000b = 10111001b
-10101001b | 00011001b = 10111001b
-10101001b | 00011010b = 10111011b
-10101001b | 00011011b = 10111011b
-10101001b | 00011100b = 10111101b
-10101001b | 00011101b = 10111101b
-10101001b | 00011110b = 10111111b
-10101001b | 00011111b = 10111111b
-10101001b | 00100000b = 10101001b
-10101001b | 00100001b = 10101001b
-10101001b | 00100010b = 10101011b
-10101001b | 00100011b = 10101011b
-10101001b | 00100100b = 10101101b
-10101001b | 00100101b = 10101101b
-10101001b | 00100110b = 10101111b
-10101001b | 00100111b = 10101111b
-10101001b | 00101000b = 10101001b
-10101001b | 00101001b = 10101001b
-10101001b | 00101010b = 10101011b
-10101001b | 00101011b = 10101011b
-10101001b | 00101100b = 10101101b
-10101001b | 00101101b = 10101101b
-10101001b | 00101110b = 10101111b
-10101001b | 00101111b = 10101111b
-10101001b | 00110000b = 10111001b
-10101001b | 00110001b = 10111001b
-10101001b | 00110010b = 10111011b
-10101001b | 00110011b = 10111011b
-10101001b | 00110100b = 10111101b
-10101001b | 00110101b = 10111101b
-10101001b | 00110110b = 10111111b
-10101001b | 00110111b = 10111111b
-10101001b | 00111000b = 10111001b
-10101001b | 00111001b = 10111001b
-10101001b | 00111010b = 10111011b
-10101001b | 00111011b = 10111011b
-10101001b | 00111100b = 10111101b
-10101001b | 00111101b = 10111101b
-10101001b | 00111110b = 10111111b
-10101001b | 00111111b = 10111111b
-10101001b | 01000000b = 11101001b
-10101001b | 01000001b = 11101001b
-10101001b | 01000010b = 11101011b
-10101001b | 01000011b = 11101011b
-10101001b | 01000100b = 11101101b
-10101001b | 01000101b = 11101101b
-10101001b | 01000110b = 11101111b
-10101001b | 01000111b = 11101111b
-10101001b | 01001000b = 11101001b
-10101001b | 01001001b = 11101001b
-10101001b | 01001010b = 11101011b
-10101001b | 01001011b = 11101011b
-10101001b | 01001100b = 11101101b
-10101001b | 01001101b = 11101101b
-10101001b | 01001110b = 11101111b
-10101001b | 01001111b = 11101111b
-10101001b | 01010000b = 11111001b
-10101001b | 01010001b = 11111001b
-10101001b | 01010010b = 11111011b
-10101001b | 01010011b = 11111011b
-10101001b | 01010100b = 11111101b
-10101001b | 01010101b = 11111101b
-10101001b | 01010110b = 11111111b
-10101001b | 01010111b = 11111111b
-10101001b | 01011000b = 11111001b
-10101001b | 01011001b = 11111001b
-10101001b | 01011010b = 11111011b
-10101001b | 01011011b = 11111011b
-10101001b | 01011100b = 11111101b
-10101001b | 01011101b = 11111101b
-10101001b | 01011110b = 11111111b
-10101001b | 01011111b = 11111111b
-10101001b | 01100000b = 11101001b
-10101001b | 01100001b = 11101001b
-10101001b | 01100010b = 11101011b
-10101001b | 01100011b = 11101011b
-10101001b | 01100100b = 11101101b
-10101001b | 01100101b = 11101101b
-10101001b | 01100110b = 11101111b
-10101001b | 01100111b = 11101111b
-10101001b | 01101000b = 11101001b
-10101001b | 01101001b = 11101001b
-10101001b | 01101010b = 11101011b
-10101001b | 01101011b = 11101011b
-10101001b | 01101100b = 11101101b
-10101001b | 01101101b = 11101101b
-10101001b | 01101110b = 11101111b
-10101001b | 01101111b = 11101111b
-10101001b | 01110000b = 11111001b
-10101001b | 01110001b = 11111001b
-10101001b | 01110010b = 11111011b
-10101001b | 01110011b = 11111011b
-10101001b | 01110100b = 11111101b
-10101001b | 01110101b = 11111101b
-10101001b | 01110110b = 11111111b
-10101001b | 01110111b = 11111111b
-10101001b | 01111000b = 11111001b
-10101001b | 01111001b = 11111001b
-10101001b | 01111010b = 11111011b
-10101001b | 01111011b = 11111011b
-10101001b | 01111100b = 11111101b
-10101001b | 01111101b = 11111101b
-10101001b | 01111110b = 11111111b
-10101010b | 10000000b = 10101010b
-10101010b | 10000001b = 10101011b
-10101010b | 10000010b = 10101010b
-10101010b | 10000011b = 10101011b
-10101010b | 10000100b = 10101110b
-10101010b | 10000101b = 10101111b
-10101010b | 10000110b = 10101110b
-10101010b | 10000111b = 10101111b
-10101010b | 10001000b = 10101010b
-10101010b | 10001001b = 10101011b
-10101010b | 10001010b = 10101010b
-10101010b | 10001011b = 10101011b
-10101010b | 10001100b = 10101110b
-10101010b | 10001101b = 10101111b
-10101010b | 10001110b = 10101110b
-10101010b | 10001111b = 10101111b
-10101010b | 10010000b = 10111010b
-10101010b | 10010001b = 10111011b
-10101010b | 10010010b = 10111010b
-10101010b | 10010011b = 10111011b
-10101010b | 10010100b = 10111110b
-10101010b | 10010101b = 10111111b
-10101010b | 10010110b = 10111110b
-10101010b | 10010111b = 10111111b
-10101010b | 10011000b = 10111010b
-10101010b | 10011001b = 10111011b
-10101010b | 10011010b = 10111010b
-10101010b | 10011011b = 10111011b
-10101010b | 10011100b = 10111110b
-10101010b | 10011101b = 10111111b
-10101010b | 10011110b = 10111110b
-10101010b | 10011111b = 10111111b
-10101010b | 10100000b = 10101010b
-10101010b | 10100001b = 10101011b
-10101010b | 10100010b = 10101010b
-10101010b | 10100011b = 10101011b
-10101010b | 10100100b = 10101110b
-10101010b | 10100101b = 10101111b
-10101010b | 10100110b = 10101110b
-10101010b | 10100111b = 10101111b
-10101010b | 10101000b = 10101010b
-10101010b | 10101001b = 10101011b
-10101010b | 10101010b = 10101010b
-10101010b | 10101011b = 10101011b
-10101010b | 10101100b = 10101110b
-10101010b | 10101101b = 10101111b
-10101010b | 10101110b = 10101110b
-10101010b | 10101111b = 10101111b
-10101010b | 10110000b = 10111010b
-10101010b | 10110001b = 10111011b
-10101010b | 10110010b = 10111010b
-10101010b | 10110011b = 10111011b
-10101010b | 10110100b = 10111110b
-10101010b | 10110101b = 10111111b
-10101010b | 10110110b = 10111110b
-10101010b | 10110111b = 10111111b
-10101010b | 10111000b = 10111010b
-10101010b | 10111001b = 10111011b
-10101010b | 10111010b = 10111010b
-10101010b | 10111011b = 10111011b
-10101010b | 10111100b = 10111110b
-10101010b | 10111101b = 10111111b
-10101010b | 10111110b = 10111110b
-10101010b | 10111111b = 10111111b
-10101010b | 11000000b = 11101010b
-10101010b | 11000001b = 11101011b
-10101010b | 11000010b = 11101010b
-10101010b | 11000011b = 11101011b
-10101010b | 11000100b = 11101110b
-10101010b | 11000101b = 11101111b
-10101010b | 11000110b = 11101110b
-10101010b | 11000111b = 11101111b
-10101010b | 11001000b = 11101010b
-10101010b | 11001001b = 11101011b
-10101010b | 11001010b = 11101010b
-10101010b | 11001011b = 11101011b
-10101010b | 11001100b = 11101110b
-10101010b | 11001101b = 11101111b
-10101010b | 11001110b = 11101110b
-10101010b | 11001111b = 11101111b
-10101010b | 11010000b = 11111010b
-10101010b | 11010001b = 11111011b
-10101010b | 11010010b = 11111010b
-10101010b | 11010011b = 11111011b
-10101010b | 11010100b = 11111110b
-10101010b | 11010101b = 11111111b
-10101010b | 11010110b = 11111110b
-10101010b | 11010111b = 11111111b
-10101010b | 11011000b = 11111010b
-10101010b | 11011001b = 11111011b
-10101010b | 11011010b = 11111010b
-10101010b | 11011011b = 11111011b
-10101010b | 11011100b = 11111110b
-10101010b | 11011101b = 11111111b
-10101010b | 11011110b = 11111110b
-10101010b | 11011111b = 11111111b
-10101010b | 11100000b = 11101010b
-10101010b | 11100001b = 11101011b
-10101010b | 11100010b = 11101010b
-10101010b | 11100011b = 11101011b
-10101010b | 11100100b = 11101110b
-10101010b | 11100101b = 11101111b
-10101010b | 11100110b = 11101110b
-10101010b | 11100111b = 11101111b
-10101010b | 11101000b = 11101010b
-10101010b | 11101001b = 11101011b
-10101010b | 11101010b = 11101010b
-10101010b | 11101011b = 11101011b
-10101010b | 11101100b = 11101110b
-10101010b | 11101101b = 11101111b
-10101010b | 11101110b = 11101110b
-10101010b | 11101111b = 11101111b
-10101010b | 11110000b = 11111010b
-10101010b | 11110001b = 11111011b
-10101010b | 11110010b = 11111010b
-10101010b | 11110011b = 11111011b
-10101010b | 11110100b = 11111110b
-10101010b | 11110101b = 11111111b
-10101010b | 11110110b = 11111110b
-10101010b | 11110111b = 11111111b
-10101010b | 11111000b = 11111010b
-10101010b | 11111001b = 11111011b
-10101010b | 11111010b = 11111010b
-10101010b | 11111011b = 11111011b
-10101010b | 11111100b = 11111110b
-10101010b | 11111101b = 11111111b
-10101010b | 11111110b = 11111110b
-10101010b | 11111111b = 11111111b
-10101010b | 00000000b = 10101010b
-10101010b | 00000001b = 10101011b
-10101010b | 00000010b = 10101010b
-10101010b | 00000011b = 10101011b
-10101010b | 00000100b = 10101110b
-10101010b | 00000101b = 10101111b
-10101010b | 00000110b = 10101110b
-10101010b | 00000111b = 10101111b
-10101010b | 00001000b = 10101010b
-10101010b | 00001001b = 10101011b
-10101010b | 00001010b = 10101010b
-10101010b | 00001011b = 10101011b
-10101010b | 00001100b = 10101110b
-10101010b | 00001101b = 10101111b
-10101010b | 00001110b = 10101110b
-10101010b | 00001111b = 10101111b
-10101010b | 00010000b = 10111010b
-10101010b | 00010001b = 10111011b
-10101010b | 00010010b = 10111010b
-10101010b | 00010011b = 10111011b
-10101010b | 00010100b = 10111110b
-10101010b | 00010101b = 10111111b
-10101010b | 00010110b = 10111110b
-10101010b | 00010111b = 10111111b
-10101010b | 00011000b = 10111010b
-10101010b | 00011001b = 10111011b
-10101010b | 00011010b = 10111010b
-10101010b | 00011011b = 10111011b
-10101010b | 00011100b = 10111110b
-10101010b | 00011101b = 10111111b
-10101010b | 00011110b = 10111110b
-10101010b | 00011111b = 10111111b
-10101010b | 00100000b = 10101010b
-10101010b | 00100001b = 10101011b
-10101010b | 00100010b = 10101010b
-10101010b | 00100011b = 10101011b
-10101010b | 00100100b = 10101110b
-10101010b | 00100101b = 10101111b
-10101010b | 00100110b = 10101110b
-10101010b | 00100111b = 10101111b
-10101010b | 00101000b = 10101010b
-10101010b | 00101001b = 10101011b
-10101010b | 00101010b = 10101010b
-10101010b | 00101011b = 10101011b
-10101010b | 00101100b = 10101110b
-10101010b | 00101101b = 10101111b
-10101010b | 00101110b = 10101110b
-10101010b | 00101111b = 10101111b
-10101010b | 00110000b = 10111010b
-10101010b | 00110001b = 10111011b
-10101010b | 00110010b = 10111010b
-10101010b | 00110011b = 10111011b
-10101010b | 00110100b = 10111110b
-10101010b | 00110101b = 10111111b
-10101010b | 00110110b = 10111110b
-10101010b | 00110111b = 10111111b
-10101010b | 00111000b = 10111010b
-10101010b | 00111001b = 10111011b
-10101010b | 00111010b = 10111010b
-10101010b | 00111011b = 10111011b
-10101010b | 00111100b = 10111110b
-10101010b | 00111101b = 10111111b
-10101010b | 00111110b = 10111110b
-10101010b | 00111111b = 10111111b
-10101010b | 01000000b = 11101010b
-10101010b | 01000001b = 11101011b
-10101010b | 01000010b = 11101010b
-10101010b | 01000011b = 11101011b
-10101010b | 01000100b = 11101110b
-10101010b | 01000101b = 11101111b
-10101010b | 01000110b = 11101110b
-10101010b | 01000111b = 11101111b
-10101010b | 01001000b = 11101010b
-10101010b | 01001001b = 11101011b
-10101010b | 01001010b = 11101010b
-10101010b | 01001011b = 11101011b
-10101010b | 01001100b = 11101110b
-10101010b | 01001101b = 11101111b
-10101010b | 01001110b = 11101110b
-10101010b | 01001111b = 11101111b
-10101010b | 01010000b = 11111010b
-10101010b | 01010001b = 11111011b
-10101010b | 01010010b = 11111010b
-10101010b | 01010011b = 11111011b
-10101010b | 01010100b = 11111110b
-10101010b | 01010101b = 11111111b
-10101010b | 01010110b = 11111110b
-10101010b | 01010111b = 11111111b
-10101010b | 01011000b = 11111010b
-10101010b | 01011001b = 11111011b
-10101010b | 01011010b = 11111010b
-10101010b | 01011011b = 11111011b
-10101010b | 01011100b = 11111110b
-10101010b | 01011101b = 11111111b
-10101010b | 01011110b = 11111110b
-10101010b | 01011111b = 11111111b
-10101010b | 01100000b = 11101010b
-10101010b | 01100001b = 11101011b
-10101010b | 01100010b = 11101010b
-10101010b | 01100011b = 11101011b
-10101010b | 01100100b = 11101110b
-10101010b | 01100101b = 11101111b
-10101010b | 01100110b = 11101110b
-10101010b | 01100111b = 11101111b
-10101010b | 01101000b = 11101010b
-10101010b | 01101001b = 11101011b
-10101010b | 01101010b = 11101010b
-10101010b | 01101011b = 11101011b
-10101010b | 01101100b = 11101110b
-10101010b | 01101101b = 11101111b
-10101010b | 01101110b = 11101110b
-10101010b | 01101111b = 11101111b
-10101010b | 01110000b = 11111010b
-10101010b | 01110001b = 11111011b
-10101010b | 01110010b = 11111010b
-10101010b | 01110011b = 11111011b
-10101010b | 01110100b = 11111110b
-10101010b | 01110101b = 11111111b
-10101010b | 01110110b = 11111110b
-10101010b | 01110111b = 11111111b
-10101010b | 01111000b = 11111010b
-10101010b | 01111001b = 11111011b
-10101010b | 01111010b = 11111010b
-10101010b | 01111011b = 11111011b
-10101010b | 01111100b = 11111110b
-10101010b | 01111101b = 11111111b
-10101010b | 01111110b = 11111110b
-10101011b | 10000000b = 10101011b
-10101011b | 10000001b = 10101011b
-10101011b | 10000010b = 10101011b
-10101011b | 10000011b = 10101011b
-10101011b | 10000100b = 10101111b
-10101011b | 10000101b = 10101111b
-10101011b | 10000110b = 10101111b
-10101011b | 10000111b = 10101111b
-10101011b | 10001000b = 10101011b
-10101011b | 10001001b = 10101011b
-10101011b | 10001010b = 10101011b
-10101011b | 10001011b = 10101011b
-10101011b | 10001100b = 10101111b
-10101011b | 10001101b = 10101111b
-10101011b | 10001110b = 10101111b
-10101011b | 10001111b = 10101111b
-10101011b | 10010000b = 10111011b
-10101011b | 10010001b = 10111011b
-10101011b | 10010010b = 10111011b
-10101011b | 10010011b = 10111011b
-10101011b | 10010100b = 10111111b
-10101011b | 10010101b = 10111111b
-10101011b | 10010110b = 10111111b
-10101011b | 10010111b = 10111111b
-10101011b | 10011000b = 10111011b
-10101011b | 10011001b = 10111011b
-10101011b | 10011010b = 10111011b
-10101011b | 10011011b = 10111011b
-10101011b | 10011100b = 10111111b
-10101011b | 10011101b = 10111111b
-10101011b | 10011110b = 10111111b
-10101011b | 10011111b = 10111111b
-10101011b | 10100000b = 10101011b
-10101011b | 10100001b = 10101011b
-10101011b | 10100010b = 10101011b
-10101011b | 10100011b = 10101011b
-10101011b | 10100100b = 10101111b
-10101011b | 10100101b = 10101111b
-10101011b | 10100110b = 10101111b
-10101011b | 10100111b = 10101111b
-10101011b | 10101000b = 10101011b
-10101011b | 10101001b = 10101011b
-10101011b | 10101010b = 10101011b
-10101011b | 10101011b = 10101011b
-10101011b | 10101100b = 10101111b
-10101011b | 10101101b = 10101111b
-10101011b | 10101110b = 10101111b
-10101011b | 10101111b = 10101111b
-10101011b | 10110000b = 10111011b
-10101011b | 10110001b = 10111011b
-10101011b | 10110010b = 10111011b
-10101011b | 10110011b = 10111011b
-10101011b | 10110100b = 10111111b
-10101011b | 10110101b = 10111111b
-10101011b | 10110110b = 10111111b
-10101011b | 10110111b = 10111111b
-10101011b | 10111000b = 10111011b
-10101011b | 10111001b = 10111011b
-10101011b | 10111010b = 10111011b
-10101011b | 10111011b = 10111011b
-10101011b | 10111100b = 10111111b
-10101011b | 10111101b = 10111111b
-10101011b | 10111110b = 10111111b
-10101011b | 10111111b = 10111111b
-10101011b | 11000000b = 11101011b
-10101011b | 11000001b = 11101011b
-10101011b | 11000010b = 11101011b
-10101011b | 11000011b = 11101011b
-10101011b | 11000100b = 11101111b
-10101011b | 11000101b = 11101111b
-10101011b | 11000110b = 11101111b
-10101011b | 11000111b = 11101111b
-10101011b | 11001000b = 11101011b
-10101011b | 11001001b = 11101011b
-10101011b | 11001010b = 11101011b
-10101011b | 11001011b = 11101011b
-10101011b | 11001100b = 11101111b
-10101011b | 11001101b = 11101111b
-10101011b | 11001110b = 11101111b
-10101011b | 11001111b = 11101111b
-10101011b | 11010000b = 11111011b
-10101011b | 11010001b = 11111011b
-10101011b | 11010010b = 11111011b
-10101011b | 11010011b = 11111011b
-10101011b | 11010100b = 11111111b
-10101011b | 11010101b = 11111111b
-10101011b | 11010110b = 11111111b
-10101011b | 11010111b = 11111111b
-10101011b | 11011000b = 11111011b
-10101011b | 11011001b = 11111011b
-10101011b | 11011010b = 11111011b
-10101011b | 11011011b = 11111011b
-10101011b | 11011100b = 11111111b
-10101011b | 11011101b = 11111111b
-10101011b | 11011110b = 11111111b
-10101011b | 11011111b = 11111111b
-10101011b | 11100000b = 11101011b
-10101011b | 11100001b = 11101011b
-10101011b | 11100010b = 11101011b
-10101011b | 11100011b = 11101011b
-10101011b | 11100100b = 11101111b
-10101011b | 11100101b = 11101111b
-10101011b | 11100110b = 11101111b
-10101011b | 11100111b = 11101111b
-10101011b | 11101000b = 11101011b
-10101011b | 11101001b = 11101011b
-10101011b | 11101010b = 11101011b
-10101011b | 11101011b = 11101011b
-10101011b | 11101100b = 11101111b
-10101011b | 11101101b = 11101111b
-10101011b | 11101110b = 11101111b
-10101011b | 11101111b = 11101111b
-10101011b | 11110000b = 11111011b
-10101011b | 11110001b = 11111011b
-10101011b | 11110010b = 11111011b
-10101011b | 11110011b = 11111011b
-10101011b | 11110100b = 11111111b
-10101011b | 11110101b = 11111111b
-10101011b | 11110110b = 11111111b
-10101011b | 11110111b = 11111111b
-10101011b | 11111000b = 11111011b
-10101011b | 11111001b = 11111011b
-10101011b | 11111010b = 11111011b
-10101011b | 11111011b = 11111011b
-10101011b | 11111100b = 11111111b
-10101011b | 11111101b = 11111111b
-10101011b | 11111110b = 11111111b
-10101011b | 11111111b = 11111111b
-10101011b | 00000000b = 10101011b
-10101011b | 00000001b = 10101011b
-10101011b | 00000010b = 10101011b
-10101011b | 00000011b = 10101011b
-10101011b | 00000100b = 10101111b
-10101011b | 00000101b = 10101111b
-10101011b | 00000110b = 10101111b
-10101011b | 00000111b = 10101111b
-10101011b | 00001000b = 10101011b
-10101011b | 00001001b = 10101011b
-10101011b | 00001010b = 10101011b
-10101011b | 00001011b = 10101011b
-10101011b | 00001100b = 10101111b
-10101011b | 00001101b = 10101111b
-10101011b | 00001110b = 10101111b
-10101011b | 00001111b = 10101111b
-10101011b | 00010000b = 10111011b
-10101011b | 00010001b = 10111011b
-10101011b | 00010010b = 10111011b
-10101011b | 00010011b = 10111011b
-10101011b | 00010100b = 10111111b
-10101011b | 00010101b = 10111111b
-10101011b | 00010110b = 10111111b
-10101011b | 00010111b = 10111111b
-10101011b | 00011000b = 10111011b
-10101011b | 00011001b = 10111011b
-10101011b | 00011010b = 10111011b
-10101011b | 00011011b = 10111011b
-10101011b | 00011100b = 10111111b
-10101011b | 00011101b = 10111111b
-10101011b | 00011110b = 10111111b
-10101011b | 00011111b = 10111111b
-10101011b | 00100000b = 10101011b
-10101011b | 00100001b = 10101011b
-10101011b | 00100010b = 10101011b
-10101011b | 00100011b = 10101011b
-10101011b | 00100100b = 10101111b
-10101011b | 00100101b = 10101111b
-10101011b | 00100110b = 10101111b
-10101011b | 00100111b = 10101111b
-10101011b | 00101000b = 10101011b
-10101011b | 00101001b = 10101011b
-10101011b | 00101010b = 10101011b
-10101011b | 00101011b = 10101011b
-10101011b | 00101100b = 10101111b
-10101011b | 00101101b = 10101111b
-10101011b | 00101110b = 10101111b
-10101011b | 00101111b = 10101111b
-10101011b | 00110000b = 10111011b
-10101011b | 00110001b = 10111011b
-10101011b | 00110010b = 10111011b
-10101011b | 00110011b = 10111011b
-10101011b | 00110100b = 10111111b
-10101011b | 00110101b = 10111111b
-10101011b | 00110110b = 10111111b
-10101011b | 00110111b = 10111111b
-10101011b | 00111000b = 10111011b
-10101011b | 00111001b = 10111011b
-10101011b | 00111010b = 10111011b
-10101011b | 00111011b = 10111011b
-10101011b | 00111100b = 10111111b
-10101011b | 00111101b = 10111111b
-10101011b | 00111110b = 10111111b
-10101011b | 00111111b = 10111111b
-10101011b | 01000000b = 11101011b
-10101011b | 01000001b = 11101011b
-10101011b | 01000010b = 11101011b
-10101011b | 01000011b = 11101011b
-10101011b | 01000100b = 11101111b
-10101011b | 01000101b = 11101111b
-10101011b | 01000110b = 11101111b
-10101011b | 01000111b = 11101111b
-10101011b | 01001000b = 11101011b
-10101011b | 01001001b = 11101011b
-10101011b | 01001010b = 11101011b
-10101011b | 01001011b = 11101011b
-10101011b | 01001100b = 11101111b
-10101011b | 01001101b = 11101111b
-10101011b | 01001110b = 11101111b
-10101011b | 01001111b = 11101111b
-10101011b | 01010000b = 11111011b
-10101011b | 01010001b = 11111011b
-10101011b | 01010010b = 11111011b
-10101011b | 01010011b = 11111011b
-10101011b | 01010100b = 11111111b
-10101011b | 01010101b = 11111111b
-10101011b | 01010110b = 11111111b
-10101011b | 01010111b = 11111111b
-10101011b | 01011000b = 11111011b
-10101011b | 01011001b = 11111011b
-10101011b | 01011010b = 11111011b
-10101011b | 01011011b = 11111011b
-10101011b | 01011100b = 11111111b
-10101011b | 01011101b = 11111111b
-10101011b | 01011110b = 11111111b
-10101011b | 01011111b = 11111111b
-10101011b | 01100000b = 11101011b
-10101011b | 01100001b = 11101011b
-10101011b | 01100010b = 11101011b
-10101011b | 01100011b = 11101011b
-10101011b | 01100100b = 11101111b
-10101011b | 01100101b = 11101111b
-10101011b | 01100110b = 11101111b
-10101011b | 01100111b = 11101111b
-10101011b | 01101000b = 11101011b
-10101011b | 01101001b = 11101011b
-10101011b | 01101010b = 11101011b
-10101011b | 01101011b = 11101011b
-10101011b | 01101100b = 11101111b
-10101011b | 01101101b = 11101111b
-10101011b | 01101110b = 11101111b
-10101011b | 01101111b = 11101111b
-10101011b | 01110000b = 11111011b
-10101011b | 01110001b = 11111011b
-10101011b | 01110010b = 11111011b
-10101011b | 01110011b = 11111011b
-10101011b | 01110100b = 11111111b
-10101011b | 01110101b = 11111111b
-10101011b | 01110110b = 11111111b
-10101011b | 01110111b = 11111111b
-10101011b | 01111000b = 11111011b
-10101011b | 01111001b = 11111011b
-10101011b | 01111010b = 11111011b
-10101011b | 01111011b = 11111011b
-10101011b | 01111100b = 11111111b
-10101011b | 01111101b = 11111111b
-10101011b | 01111110b = 11111111b
-10101100b | 10000000b = 10101100b
-10101100b | 10000001b = 10101101b
-10101100b | 10000010b = 10101110b
-10101100b | 10000011b = 10101111b
-10101100b | 10000100b = 10101100b
-10101100b | 10000101b = 10101101b
-10101100b | 10000110b = 10101110b
-10101100b | 10000111b = 10101111b
-10101100b | 10001000b = 10101100b
-10101100b | 10001001b = 10101101b
-10101100b | 10001010b = 10101110b
-10101100b | 10001011b = 10101111b
-10101100b | 10001100b = 10101100b
-10101100b | 10001101b = 10101101b
-10101100b | 10001110b = 10101110b
-10101100b | 10001111b = 10101111b
-10101100b | 10010000b = 10111100b
-10101100b | 10010001b = 10111101b
-10101100b | 10010010b = 10111110b
-10101100b | 10010011b = 10111111b
-10101100b | 10010100b = 10111100b
-10101100b | 10010101b = 10111101b
-10101100b | 10010110b = 10111110b
-10101100b | 10010111b = 10111111b
-10101100b | 10011000b = 10111100b
-10101100b | 10011001b = 10111101b
-10101100b | 10011010b = 10111110b
-10101100b | 10011011b = 10111111b
-10101100b | 10011100b = 10111100b
-10101100b | 10011101b = 10111101b
-10101100b | 10011110b = 10111110b
-10101100b | 10011111b = 10111111b
-10101100b | 10100000b = 10101100b
-10101100b | 10100001b = 10101101b
-10101100b | 10100010b = 10101110b
-10101100b | 10100011b = 10101111b
-10101100b | 10100100b = 10101100b
-10101100b | 10100101b = 10101101b
-10101100b | 10100110b = 10101110b
-10101100b | 10100111b = 10101111b
-10101100b | 10101000b = 10101100b
-10101100b | 10101001b = 10101101b
-10101100b | 10101010b = 10101110b
-10101100b | 10101011b = 10101111b
-10101100b | 10101100b = 10101100b
-10101100b | 10101101b = 10101101b
-10101100b | 10101110b = 10101110b
-10101100b | 10101111b = 10101111b
-10101100b | 10110000b = 10111100b
-10101100b | 10110001b = 10111101b
-10101100b | 10110010b = 10111110b
-10101100b | 10110011b = 10111111b
-10101100b | 10110100b = 10111100b
-10101100b | 10110101b = 10111101b
-10101100b | 10110110b = 10111110b
-10101100b | 10110111b = 10111111b
-10101100b | 10111000b = 10111100b
-10101100b | 10111001b = 10111101b
-10101100b | 10111010b = 10111110b
-10101100b | 10111011b = 10111111b
-10101100b | 10111100b = 10111100b
-10101100b | 10111101b = 10111101b
-10101100b | 10111110b = 10111110b
-10101100b | 10111111b = 10111111b
-10101100b | 11000000b = 11101100b
-10101100b | 11000001b = 11101101b
-10101100b | 11000010b = 11101110b
-10101100b | 11000011b = 11101111b
-10101100b | 11000100b = 11101100b
-10101100b | 11000101b = 11101101b
-10101100b | 11000110b = 11101110b
-10101100b | 11000111b = 11101111b
-10101100b | 11001000b = 11101100b
-10101100b | 11001001b = 11101101b
-10101100b | 11001010b = 11101110b
-10101100b | 11001011b = 11101111b
-10101100b | 11001100b = 11101100b
-10101100b | 11001101b = 11101101b
-10101100b | 11001110b = 11101110b
-10101100b | 11001111b = 11101111b
-10101100b | 11010000b = 11111100b
-10101100b | 11010001b = 11111101b
-10101100b | 11010010b = 11111110b
-10101100b | 11010011b = 11111111b
-10101100b | 11010100b = 11111100b
-10101100b | 11010101b = 11111101b
-10101100b | 11010110b = 11111110b
-10101100b | 11010111b = 11111111b
-10101100b | 11011000b = 11111100b
-10101100b | 11011001b = 11111101b
-10101100b | 11011010b = 11111110b
-10101100b | 11011011b = 11111111b
-10101100b | 11011100b = 11111100b
-10101100b | 11011101b = 11111101b
-10101100b | 11011110b = 11111110b
-10101100b | 11011111b = 11111111b
-10101100b | 11100000b = 11101100b
-10101100b | 11100001b = 11101101b
-10101100b | 11100010b = 11101110b
-10101100b | 11100011b = 11101111b
-10101100b | 11100100b = 11101100b
-10101100b | 11100101b = 11101101b
-10101100b | 11100110b = 11101110b
-10101100b | 11100111b = 11101111b
-10101100b | 11101000b = 11101100b
-10101100b | 11101001b = 11101101b
-10101100b | 11101010b = 11101110b
-10101100b | 11101011b = 11101111b
-10101100b | 11101100b = 11101100b
-10101100b | 11101101b = 11101101b
-10101100b | 11101110b = 11101110b
-10101100b | 11101111b = 11101111b
-10101100b | 11110000b = 11111100b
-10101100b | 11110001b = 11111101b
-10101100b | 11110010b = 11111110b
-10101100b | 11110011b = 11111111b
-10101100b | 11110100b = 11111100b
-10101100b | 11110101b = 11111101b
-10101100b | 11110110b = 11111110b
-10101100b | 11110111b = 11111111b
-10101100b | 11111000b = 11111100b
-10101100b | 11111001b = 11111101b
-10101100b | 11111010b = 11111110b
-10101100b | 11111011b = 11111111b
-10101100b | 11111100b = 11111100b
-10101100b | 11111101b = 11111101b
-10101100b | 11111110b = 11111110b
-10101100b | 11111111b = 11111111b
-10101100b | 00000000b = 10101100b
-10101100b | 00000001b = 10101101b
-10101100b | 00000010b = 10101110b
-10101100b | 00000011b = 10101111b
-10101100b | 00000100b = 10101100b
-10101100b | 00000101b = 10101101b
-10101100b | 00000110b = 10101110b
-10101100b | 00000111b = 10101111b
-10101100b | 00001000b = 10101100b
-10101100b | 00001001b = 10101101b
-10101100b | 00001010b = 10101110b
-10101100b | 00001011b = 10101111b
-10101100b | 00001100b = 10101100b
-10101100b | 00001101b = 10101101b
-10101100b | 00001110b = 10101110b
-10101100b | 00001111b = 10101111b
-10101100b | 00010000b = 10111100b
-10101100b | 00010001b = 10111101b
-10101100b | 00010010b = 10111110b
-10101100b | 00010011b = 10111111b
-10101100b | 00010100b = 10111100b
-10101100b | 00010101b = 10111101b
-10101100b | 00010110b = 10111110b
-10101100b | 00010111b = 10111111b
-10101100b | 00011000b = 10111100b
-10101100b | 00011001b = 10111101b
-10101100b | 00011010b = 10111110b
-10101100b | 00011011b = 10111111b
-10101100b | 00011100b = 10111100b
-10101100b | 00011101b = 10111101b
-10101100b | 00011110b = 10111110b
-10101100b | 00011111b = 10111111b
-10101100b | 00100000b = 10101100b
-10101100b | 00100001b = 10101101b
-10101100b | 00100010b = 10101110b
-10101100b | 00100011b = 10101111b
-10101100b | 00100100b = 10101100b
-10101100b | 00100101b = 10101101b
-10101100b | 00100110b = 10101110b
-10101100b | 00100111b = 10101111b
-10101100b | 00101000b = 10101100b
-10101100b | 00101001b = 10101101b
-10101100b | 00101010b = 10101110b
-10101100b | 00101011b = 10101111b
-10101100b | 00101100b = 10101100b
-10101100b | 00101101b = 10101101b
-10101100b | 00101110b = 10101110b
-10101100b | 00101111b = 10101111b
-10101100b | 00110000b = 10111100b
-10101100b | 00110001b = 10111101b
-10101100b | 00110010b = 10111110b
-10101100b | 00110011b = 10111111b
-10101100b | 00110100b = 10111100b
-10101100b | 00110101b = 10111101b
-10101100b | 00110110b = 10111110b
-10101100b | 00110111b = 10111111b
-10101100b | 00111000b = 10111100b
-10101100b | 00111001b = 10111101b
-10101100b | 00111010b = 10111110b
-10101100b | 00111011b = 10111111b
-10101100b | 00111100b = 10111100b
-10101100b | 00111101b = 10111101b
-10101100b | 00111110b = 10111110b
-10101100b | 00111111b = 10111111b
-10101100b | 01000000b = 11101100b
-10101100b | 01000001b = 11101101b
-10101100b | 01000010b = 11101110b
-10101100b | 01000011b = 11101111b
-10101100b | 01000100b = 11101100b
-10101100b | 01000101b = 11101101b
-10101100b | 01000110b = 11101110b
-10101100b | 01000111b = 11101111b
-10101100b | 01001000b = 11101100b
-10101100b | 01001001b = 11101101b
-10101100b | 01001010b = 11101110b
-10101100b | 01001011b = 11101111b
-10101100b | 01001100b = 11101100b
-10101100b | 01001101b = 11101101b
-10101100b | 01001110b = 11101110b
-10101100b | 01001111b = 11101111b
-10101100b | 01010000b = 11111100b
-10101100b | 01010001b = 11111101b
-10101100b | 01010010b = 11111110b
-10101100b | 01010011b = 11111111b
-10101100b | 01010100b = 11111100b
-10101100b | 01010101b = 11111101b
-10101100b | 01010110b = 11111110b
-10101100b | 01010111b = 11111111b
-10101100b | 01011000b = 11111100b
-10101100b | 01011001b = 11111101b
-10101100b | 01011010b = 11111110b
-10101100b | 01011011b = 11111111b
-10101100b | 01011100b = 11111100b
-10101100b | 01011101b = 11111101b
-10101100b | 01011110b = 11111110b
-10101100b | 01011111b = 11111111b
-10101100b | 01100000b = 11101100b
-10101100b | 01100001b = 11101101b
-10101100b | 01100010b = 11101110b
-10101100b | 01100011b = 11101111b
-10101100b | 01100100b = 11101100b
-10101100b | 01100101b = 11101101b
-10101100b | 01100110b = 11101110b
-10101100b | 01100111b = 11101111b
-10101100b | 01101000b = 11101100b
-10101100b | 01101001b = 11101101b
-10101100b | 01101010b = 11101110b
-10101100b | 01101011b = 11101111b
-10101100b | 01101100b = 11101100b
-10101100b | 01101101b = 11101101b
-10101100b | 01101110b = 11101110b
-10101100b | 01101111b = 11101111b
-10101100b | 01110000b = 11111100b
-10101100b | 01110001b = 11111101b
-10101100b | 01110010b = 11111110b
-10101100b | 01110011b = 11111111b
-10101100b | 01110100b = 11111100b
-10101100b | 01110101b = 11111101b
-10101100b | 01110110b = 11111110b
-10101100b | 01110111b = 11111111b
-10101100b | 01111000b = 11111100b
-10101100b | 01111001b = 11111101b
-10101100b | 01111010b = 11111110b
-10101100b | 01111011b = 11111111b
-10101100b | 01111100b = 11111100b
-10101100b | 01111101b = 11111101b
-10101100b | 01111110b = 11111110b
-10101101b | 10000000b = 10101101b
-10101101b | 10000001b = 10101101b
-10101101b | 10000010b = 10101111b
-10101101b | 10000011b = 10101111b
-10101101b | 10000100b = 10101101b
-10101101b | 10000101b = 10101101b
-10101101b | 10000110b = 10101111b
-10101101b | 10000111b = 10101111b
-10101101b | 10001000b = 10101101b
-10101101b | 10001001b = 10101101b
-10101101b | 10001010b = 10101111b
-10101101b | 10001011b = 10101111b
-10101101b | 10001100b = 10101101b
-10101101b | 10001101b = 10101101b
-10101101b | 10001110b = 10101111b
-10101101b | 10001111b = 10101111b
-10101101b | 10010000b = 10111101b
-10101101b | 10010001b = 10111101b
-10101101b | 10010010b = 10111111b
-10101101b | 10010011b = 10111111b
-10101101b | 10010100b = 10111101b
-10101101b | 10010101b = 10111101b
-10101101b | 10010110b = 10111111b
-10101101b | 10010111b = 10111111b
-10101101b | 10011000b = 10111101b
-10101101b | 10011001b = 10111101b
-10101101b | 10011010b = 10111111b
-10101101b | 10011011b = 10111111b
-10101101b | 10011100b = 10111101b
-10101101b | 10011101b = 10111101b
-10101101b | 10011110b = 10111111b
-10101101b | 10011111b = 10111111b
-10101101b | 10100000b = 10101101b
-10101101b | 10100001b = 10101101b
-10101101b | 10100010b = 10101111b
-10101101b | 10100011b = 10101111b
-10101101b | 10100100b = 10101101b
-10101101b | 10100101b = 10101101b
-10101101b | 10100110b = 10101111b
-10101101b | 10100111b = 10101111b
-10101101b | 10101000b = 10101101b
-10101101b | 10101001b = 10101101b
-10101101b | 10101010b = 10101111b
-10101101b | 10101011b = 10101111b
-10101101b | 10101100b = 10101101b
-10101101b | 10101101b = 10101101b
-10101101b | 10101110b = 10101111b
-10101101b | 10101111b = 10101111b
-10101101b | 10110000b = 10111101b
-10101101b | 10110001b = 10111101b
-10101101b | 10110010b = 10111111b
-10101101b | 10110011b = 10111111b
-10101101b | 10110100b = 10111101b
-10101101b | 10110101b = 10111101b
-10101101b | 10110110b = 10111111b
-10101101b | 10110111b = 10111111b
-10101101b | 10111000b = 10111101b
-10101101b | 10111001b = 10111101b
-10101101b | 10111010b = 10111111b
-10101101b | 10111011b = 10111111b
-10101101b | 10111100b = 10111101b
-10101101b | 10111101b = 10111101b
-10101101b | 10111110b = 10111111b
-10101101b | 10111111b = 10111111b
-10101101b | 11000000b = 11101101b
-10101101b | 11000001b = 11101101b
-10101101b | 11000010b = 11101111b
-10101101b | 11000011b = 11101111b
-10101101b | 11000100b = 11101101b
-10101101b | 11000101b = 11101101b
-10101101b | 11000110b = 11101111b
-10101101b | 11000111b = 11101111b
-10101101b | 11001000b = 11101101b
-10101101b | 11001001b = 11101101b
-10101101b | 11001010b = 11101111b
-10101101b | 11001011b = 11101111b
-10101101b | 11001100b = 11101101b
-10101101b | 11001101b = 11101101b
-10101101b | 11001110b = 11101111b
-10101101b | 11001111b = 11101111b
-10101101b | 11010000b = 11111101b
-10101101b | 11010001b = 11111101b
-10101101b | 11010010b = 11111111b
-10101101b | 11010011b = 11111111b
-10101101b | 11010100b = 11111101b
-10101101b | 11010101b = 11111101b
-10101101b | 11010110b = 11111111b
-10101101b | 11010111b = 11111111b
-10101101b | 11011000b = 11111101b
-10101101b | 11011001b = 11111101b
-10101101b | 11011010b = 11111111b
-10101101b | 11011011b = 11111111b
-10101101b | 11011100b = 11111101b
-10101101b | 11011101b = 11111101b
-10101101b | 11011110b = 11111111b
-10101101b | 11011111b = 11111111b
-10101101b | 11100000b = 11101101b
-10101101b | 11100001b = 11101101b
-10101101b | 11100010b = 11101111b
-10101101b | 11100011b = 11101111b
-10101101b | 11100100b = 11101101b
-10101101b | 11100101b = 11101101b
-10101101b | 11100110b = 11101111b
-10101101b | 11100111b = 11101111b
-10101101b | 11101000b = 11101101b
-10101101b | 11101001b = 11101101b
-10101101b | 11101010b = 11101111b
-10101101b | 11101011b = 11101111b
-10101101b | 11101100b = 11101101b
-10101101b | 11101101b = 11101101b
-10101101b | 11101110b = 11101111b
-10101101b | 11101111b = 11101111b
-10101101b | 11110000b = 11111101b
-10101101b | 11110001b = 11111101b
-10101101b | 11110010b = 11111111b
-10101101b | 11110011b = 11111111b
-10101101b | 11110100b = 11111101b
-10101101b | 11110101b = 11111101b
-10101101b | 11110110b = 11111111b
-10101101b | 11110111b = 11111111b
-10101101b | 11111000b = 11111101b
-10101101b | 11111001b = 11111101b
-10101101b | 11111010b = 11111111b
-10101101b | 11111011b = 11111111b
-10101101b | 11111100b = 11111101b
-10101101b | 11111101b = 11111101b
-10101101b | 11111110b = 11111111b
-10101101b | 11111111b = 11111111b
-10101101b | 00000000b = 10101101b
-10101101b | 00000001b = 10101101b
-10101101b | 00000010b = 10101111b
-10101101b | 00000011b = 10101111b
-10101101b | 00000100b = 10101101b
-10101101b | 00000101b = 10101101b
-10101101b | 00000110b = 10101111b
-10101101b | 00000111b = 10101111b
-10101101b | 00001000b = 10101101b
-10101101b | 00001001b = 10101101b
-10101101b | 00001010b = 10101111b
-10101101b | 00001011b = 10101111b
-10101101b | 00001100b = 10101101b
-10101101b | 00001101b = 10101101b
-10101101b | 00001110b = 10101111b
-10101101b | 00001111b = 10101111b
-10101101b | 00010000b = 10111101b
-10101101b | 00010001b = 10111101b
-10101101b | 00010010b = 10111111b
-10101101b | 00010011b = 10111111b
-10101101b | 00010100b = 10111101b
-10101101b | 00010101b = 10111101b
-10101101b | 00010110b = 10111111b
-10101101b | 00010111b = 10111111b
-10101101b | 00011000b = 10111101b
-10101101b | 00011001b = 10111101b
-10101101b | 00011010b = 10111111b
-10101101b | 00011011b = 10111111b
-10101101b | 00011100b = 10111101b
-10101101b | 00011101b = 10111101b
-10101101b | 00011110b = 10111111b
-10101101b | 00011111b = 10111111b
-10101101b | 00100000b = 10101101b
-10101101b | 00100001b = 10101101b
-10101101b | 00100010b = 10101111b
-10101101b | 00100011b = 10101111b
-10101101b | 00100100b = 10101101b
-10101101b | 00100101b = 10101101b
-10101101b | 00100110b = 10101111b
-10101101b | 00100111b = 10101111b
-10101101b | 00101000b = 10101101b
-10101101b | 00101001b = 10101101b
-10101101b | 00101010b = 10101111b
-10101101b | 00101011b = 10101111b
-10101101b | 00101100b = 10101101b
-10101101b | 00101101b = 10101101b
-10101101b | 00101110b = 10101111b
-10101101b | 00101111b = 10101111b
-10101101b | 00110000b = 10111101b
-10101101b | 00110001b = 10111101b
-10101101b | 00110010b = 10111111b
-10101101b | 00110011b = 10111111b
-10101101b | 00110100b = 10111101b
-10101101b | 00110101b = 10111101b
-10101101b | 00110110b = 10111111b
-10101101b | 00110111b = 10111111b
-10101101b | 00111000b = 10111101b
-10101101b | 00111001b = 10111101b
-10101101b | 00111010b = 10111111b
-10101101b | 00111011b = 10111111b
-10101101b | 00111100b = 10111101b
-10101101b | 00111101b = 10111101b
-10101101b | 00111110b = 10111111b
-10101101b | 00111111b = 10111111b
-10101101b | 01000000b = 11101101b
-10101101b | 01000001b = 11101101b
-10101101b | 01000010b = 11101111b
-10101101b | 01000011b = 11101111b
-10101101b | 01000100b = 11101101b
-10101101b | 01000101b = 11101101b
-10101101b | 01000110b = 11101111b
-10101101b | 01000111b = 11101111b
-10101101b | 01001000b = 11101101b
-10101101b | 01001001b = 11101101b
-10101101b | 01001010b = 11101111b
-10101101b | 01001011b = 11101111b
-10101101b | 01001100b = 11101101b
-10101101b | 01001101b = 11101101b
-10101101b | 01001110b = 11101111b
-10101101b | 01001111b = 11101111b
-10101101b | 01010000b = 11111101b
-10101101b | 01010001b = 11111101b
-10101101b | 01010010b = 11111111b
-10101101b | 01010011b = 11111111b
-10101101b | 01010100b = 11111101b
-10101101b | 01010101b = 11111101b
-10101101b | 01010110b = 11111111b
-10101101b | 01010111b = 11111111b
-10101101b | 01011000b = 11111101b
-10101101b | 01011001b = 11111101b
-10101101b | 01011010b = 11111111b
-10101101b | 01011011b = 11111111b
-10101101b | 01011100b = 11111101b
-10101101b | 01011101b = 11111101b
-10101101b | 01011110b = 11111111b
-10101101b | 01011111b = 11111111b
-10101101b | 01100000b = 11101101b
-10101101b | 01100001b = 11101101b
-10101101b | 01100010b = 11101111b
-10101101b | 01100011b = 11101111b
-10101101b | 01100100b = 11101101b
-10101101b | 01100101b = 11101101b
-10101101b | 01100110b = 11101111b
-10101101b | 01100111b = 11101111b
-10101101b | 01101000b = 11101101b
-10101101b | 01101001b = 11101101b
-10101101b | 01101010b = 11101111b
-10101101b | 01101011b = 11101111b
-10101101b | 01101100b = 11101101b
-10101101b | 01101101b = 11101101b
-10101101b | 01101110b = 11101111b
-10101101b | 01101111b = 11101111b
-10101101b | 01110000b = 11111101b
-10101101b | 01110001b = 11111101b
-10101101b | 01110010b = 11111111b
-10101101b | 01110011b = 11111111b
-10101101b | 01110100b = 11111101b
-10101101b | 01110101b = 11111101b
-10101101b | 01110110b = 11111111b
-10101101b | 01110111b = 11111111b
-10101101b | 01111000b = 11111101b
-10101101b | 01111001b = 11111101b
-10101101b | 01111010b = 11111111b
-10101101b | 01111011b = 11111111b
-10101101b | 01111100b = 11111101b
-10101101b | 01111101b = 11111101b
-10101101b | 01111110b = 11111111b
-10101110b | 10000000b = 10101110b
-10101110b | 10000001b = 10101111b
-10101110b | 10000010b = 10101110b
-10101110b | 10000011b = 10101111b
-10101110b | 10000100b = 10101110b
-10101110b | 10000101b = 10101111b
-10101110b | 10000110b = 10101110b
-10101110b | 10000111b = 10101111b
-10101110b | 10001000b = 10101110b
-10101110b | 10001001b = 10101111b
-10101110b | 10001010b = 10101110b
-10101110b | 10001011b = 10101111b
-10101110b | 10001100b = 10101110b
-10101110b | 10001101b = 10101111b
-10101110b | 10001110b = 10101110b
-10101110b | 10001111b = 10101111b
-10101110b | 10010000b = 10111110b
-10101110b | 10010001b = 10111111b
-10101110b | 10010010b = 10111110b
-10101110b | 10010011b = 10111111b
-10101110b | 10010100b = 10111110b
-10101110b | 10010101b = 10111111b
-10101110b | 10010110b = 10111110b
-10101110b | 10010111b = 10111111b
-10101110b | 10011000b = 10111110b
-10101110b | 10011001b = 10111111b
-10101110b | 10011010b = 10111110b
-10101110b | 10011011b = 10111111b
-10101110b | 10011100b = 10111110b
-10101110b | 10011101b = 10111111b
-10101110b | 10011110b = 10111110b
-10101110b | 10011111b = 10111111b
-10101110b | 10100000b = 10101110b
-10101110b | 10100001b = 10101111b
-10101110b | 10100010b = 10101110b
-10101110b | 10100011b = 10101111b
-10101110b | 10100100b = 10101110b
-10101110b | 10100101b = 10101111b
-10101110b | 10100110b = 10101110b
-10101110b | 10100111b = 10101111b
-10101110b | 10101000b = 10101110b
-10101110b | 10101001b = 10101111b
-10101110b | 10101010b = 10101110b
-10101110b | 10101011b = 10101111b
-10101110b | 10101100b = 10101110b
-10101110b | 10101101b = 10101111b
-10101110b | 10101110b = 10101110b
-10101110b | 10101111b = 10101111b
-10101110b | 10110000b = 10111110b
-10101110b | 10110001b = 10111111b
-10101110b | 10110010b = 10111110b
-10101110b | 10110011b = 10111111b
-10101110b | 10110100b = 10111110b
-10101110b | 10110101b = 10111111b
-10101110b | 10110110b = 10111110b
-10101110b | 10110111b = 10111111b
-10101110b | 10111000b = 10111110b
-10101110b | 10111001b = 10111111b
-10101110b | 10111010b = 10111110b
-10101110b | 10111011b = 10111111b
-10101110b | 10111100b = 10111110b
-10101110b | 10111101b = 10111111b
-10101110b | 10111110b = 10111110b
-10101110b | 10111111b = 10111111b
-10101110b | 11000000b = 11101110b
-10101110b | 11000001b = 11101111b
-10101110b | 11000010b = 11101110b
-10101110b | 11000011b = 11101111b
-10101110b | 11000100b = 11101110b
-10101110b | 11000101b = 11101111b
-10101110b | 11000110b = 11101110b
-10101110b | 11000111b = 11101111b
-10101110b | 11001000b = 11101110b
-10101110b | 11001001b = 11101111b
-10101110b | 11001010b = 11101110b
-10101110b | 11001011b = 11101111b
-10101110b | 11001100b = 11101110b
-10101110b | 11001101b = 11101111b
-10101110b | 11001110b = 11101110b
-10101110b | 11001111b = 11101111b
-10101110b | 11010000b = 11111110b
-10101110b | 11010001b = 11111111b
-10101110b | 11010010b = 11111110b
-10101110b | 11010011b = 11111111b
-10101110b | 11010100b = 11111110b
-10101110b | 11010101b = 11111111b
-10101110b | 11010110b = 11111110b
-10101110b | 11010111b = 11111111b
-10101110b | 11011000b = 11111110b
-10101110b | 11011001b = 11111111b
-10101110b | 11011010b = 11111110b
-10101110b | 11011011b = 11111111b
-10101110b | 11011100b = 11111110b
-10101110b | 11011101b = 11111111b
-10101110b | 11011110b = 11111110b
-10101110b | 11011111b = 11111111b
-10101110b | 11100000b = 11101110b
-10101110b | 11100001b = 11101111b
-10101110b | 11100010b = 11101110b
-10101110b | 11100011b = 11101111b
-10101110b | 11100100b = 11101110b
-10101110b | 11100101b = 11101111b
-10101110b | 11100110b = 11101110b
-10101110b | 11100111b = 11101111b
-10101110b | 11101000b = 11101110b
-10101110b | 11101001b = 11101111b
-10101110b | 11101010b = 11101110b
-10101110b | 11101011b = 11101111b
-10101110b | 11101100b = 11101110b
-10101110b | 11101101b = 11101111b
-10101110b | 11101110b = 11101110b
-10101110b | 11101111b = 11101111b
-10101110b | 11110000b = 11111110b
-10101110b | 11110001b = 11111111b
-10101110b | 11110010b = 11111110b
-10101110b | 11110011b = 11111111b
-10101110b | 11110100b = 11111110b
-10101110b | 11110101b = 11111111b
-10101110b | 11110110b = 11111110b
-10101110b | 11110111b = 11111111b
-10101110b | 11111000b = 11111110b
-10101110b | 11111001b = 11111111b
-10101110b | 11111010b = 11111110b
-10101110b | 11111011b = 11111111b
-10101110b | 11111100b = 11111110b
-10101110b | 11111101b = 11111111b
-10101110b | 11111110b = 11111110b
-10101110b | 11111111b = 11111111b
-10101110b | 00000000b = 10101110b
-10101110b | 00000001b = 10101111b
-10101110b | 00000010b = 10101110b
-10101110b | 00000011b = 10101111b
-10101110b | 00000100b = 10101110b
-10101110b | 00000101b = 10101111b
-10101110b | 00000110b = 10101110b
-10101110b | 00000111b = 10101111b
-10101110b | 00001000b = 10101110b
-10101110b | 00001001b = 10101111b
-10101110b | 00001010b = 10101110b
-10101110b | 00001011b = 10101111b
-10101110b | 00001100b = 10101110b
-10101110b | 00001101b = 10101111b
-10101110b | 00001110b = 10101110b
-10101110b | 00001111b = 10101111b
-10101110b | 00010000b = 10111110b
-10101110b | 00010001b = 10111111b
-10101110b | 00010010b = 10111110b
-10101110b | 00010011b = 10111111b
-10101110b | 00010100b = 10111110b
-10101110b | 00010101b = 10111111b
-10101110b | 00010110b = 10111110b
-10101110b | 00010111b = 10111111b
-10101110b | 00011000b = 10111110b
-10101110b | 00011001b = 10111111b
-10101110b | 00011010b = 10111110b
-10101110b | 00011011b = 10111111b
-10101110b | 00011100b = 10111110b
-10101110b | 00011101b = 10111111b
-10101110b | 00011110b = 10111110b
-10101110b | 00011111b = 10111111b
-10101110b | 00100000b = 10101110b
-10101110b | 00100001b = 10101111b
-10101110b | 00100010b = 10101110b
-10101110b | 00100011b = 10101111b
-10101110b | 00100100b = 10101110b
-10101110b | 00100101b = 10101111b
-10101110b | 00100110b = 10101110b
-10101110b | 00100111b = 10101111b
-10101110b | 00101000b = 10101110b
-10101110b | 00101001b = 10101111b
-10101110b | 00101010b = 10101110b
-10101110b | 00101011b = 10101111b
-10101110b | 00101100b = 10101110b
-10101110b | 00101101b = 10101111b
-10101110b | 00101110b = 10101110b
-10101110b | 00101111b = 10101111b
-10101110b | 00110000b = 10111110b
-10101110b | 00110001b = 10111111b
-10101110b | 00110010b = 10111110b
-10101110b | 00110011b = 10111111b
-10101110b | 00110100b = 10111110b
-10101110b | 00110101b = 10111111b
-10101110b | 00110110b = 10111110b
-10101110b | 00110111b = 10111111b
-10101110b | 00111000b = 10111110b
-10101110b | 00111001b = 10111111b
-10101110b | 00111010b = 10111110b
-10101110b | 00111011b = 10111111b
-10101110b | 00111100b = 10111110b
-10101110b | 00111101b = 10111111b
-10101110b | 00111110b = 10111110b
-10101110b | 00111111b = 10111111b
-10101110b | 01000000b = 11101110b
-10101110b | 01000001b = 11101111b
-10101110b | 01000010b = 11101110b
-10101110b | 01000011b = 11101111b
-10101110b | 01000100b = 11101110b
-10101110b | 01000101b = 11101111b
-10101110b | 01000110b = 11101110b
-10101110b | 01000111b = 11101111b
-10101110b | 01001000b = 11101110b
-10101110b | 01001001b = 11101111b
-10101110b | 01001010b = 11101110b
-10101110b | 01001011b = 11101111b
-10101110b | 01001100b = 11101110b
-10101110b | 01001101b = 11101111b
-10101110b | 01001110b = 11101110b
-10101110b | 01001111b = 11101111b
-10101110b | 01010000b = 11111110b
-10101110b | 01010001b = 11111111b
-10101110b | 01010010b = 11111110b
-10101110b | 01010011b = 11111111b
-10101110b | 01010100b = 11111110b
-10101110b | 01010101b = 11111111b
-10101110b | 01010110b = 11111110b
-10101110b | 01010111b = 11111111b
-10101110b | 01011000b = 11111110b
-10101110b | 01011001b = 11111111b
-10101110b | 01011010b = 11111110b
-10101110b | 01011011b = 11111111b
-10101110b | 01011100b = 11111110b
-10101110b | 01011101b = 11111111b
-10101110b | 01011110b = 11111110b
-10101110b | 01011111b = 11111111b
-10101110b | 01100000b = 11101110b
-10101110b | 01100001b = 11101111b
-10101110b | 01100010b = 11101110b
-10101110b | 01100011b = 11101111b
-10101110b | 01100100b = 11101110b
-10101110b | 01100101b = 11101111b
-10101110b | 01100110b = 11101110b
-10101110b | 01100111b = 11101111b
-10101110b | 01101000b = 11101110b
-10101110b | 01101001b = 11101111b
-10101110b | 01101010b = 11101110b
-10101110b | 01101011b = 11101111b
-10101110b | 01101100b = 11101110b
-10101110b | 01101101b = 11101111b
-10101110b | 01101110b = 11101110b
-10101110b | 01101111b = 11101111b
-10101110b | 01110000b = 11111110b
-10101110b | 01110001b = 11111111b
-10101110b | 01110010b = 11111110b
-10101110b | 01110011b = 11111111b
-10101110b | 01110100b = 11111110b
-10101110b | 01110101b = 11111111b
-10101110b | 01110110b = 11111110b
-10101110b | 01110111b = 11111111b
-10101110b | 01111000b = 11111110b
-10101110b | 01111001b = 11111111b
-10101110b | 01111010b = 11111110b
-10101110b | 01111011b = 11111111b
-10101110b | 01111100b = 11111110b
-10101110b | 01111101b = 11111111b
-10101110b | 01111110b = 11111110b
-10101111b | 10000000b = 10101111b
-10101111b | 10000001b = 10101111b
-10101111b | 10000010b = 10101111b
-10101111b | 10000011b = 10101111b
-10101111b | 10000100b = 10101111b
-10101111b | 10000101b = 10101111b
-10101111b | 10000110b = 10101111b
-10101111b | 10000111b = 10101111b
-10101111b | 10001000b = 10101111b
-10101111b | 10001001b = 10101111b
-10101111b | 10001010b = 10101111b
-10101111b | 10001011b = 10101111b
-10101111b | 10001100b = 10101111b
-10101111b | 10001101b = 10101111b
-10101111b | 10001110b = 10101111b
-10101111b | 10001111b = 10101111b
-10101111b | 10010000b = 10111111b
-10101111b | 10010001b = 10111111b
-10101111b | 10010010b = 10111111b
-10101111b | 10010011b = 10111111b
-10101111b | 10010100b = 10111111b
-10101111b | 10010101b = 10111111b
-10101111b | 10010110b = 10111111b
-10101111b | 10010111b = 10111111b
-10101111b | 10011000b = 10111111b
-10101111b | 10011001b = 10111111b
-10101111b | 10011010b = 10111111b
-10101111b | 10011011b = 10111111b
-10101111b | 10011100b = 10111111b
-10101111b | 10011101b = 10111111b
-10101111b | 10011110b = 10111111b
-10101111b | 10011111b = 10111111b
-10101111b | 10100000b = 10101111b
-10101111b | 10100001b = 10101111b
-10101111b | 10100010b = 10101111b
-10101111b | 10100011b = 10101111b
-10101111b | 10100100b = 10101111b
-10101111b | 10100101b = 10101111b
-10101111b | 10100110b = 10101111b
-10101111b | 10100111b = 10101111b
-10101111b | 10101000b = 10101111b
-10101111b | 10101001b = 10101111b
-10101111b | 10101010b = 10101111b
-10101111b | 10101011b = 10101111b
-10101111b | 10101100b = 10101111b
-10101111b | 10101101b = 10101111b
-10101111b | 10101110b = 10101111b
-10101111b | 10101111b = 10101111b
-10101111b | 10110000b = 10111111b
-10101111b | 10110001b = 10111111b
-10101111b | 10110010b = 10111111b
-10101111b | 10110011b = 10111111b
-10101111b | 10110100b = 10111111b
-10101111b | 10110101b = 10111111b
-10101111b | 10110110b = 10111111b
-10101111b | 10110111b = 10111111b
-10101111b | 10111000b = 10111111b
-10101111b | 10111001b = 10111111b
-10101111b | 10111010b = 10111111b
-10101111b | 10111011b = 10111111b
-10101111b | 10111100b = 10111111b
-10101111b | 10111101b = 10111111b
-10101111b | 10111110b = 10111111b
-10101111b | 10111111b = 10111111b
-10101111b | 11000000b = 11101111b
-10101111b | 11000001b = 11101111b
-10101111b | 11000010b = 11101111b
-10101111b | 11000011b = 11101111b
-10101111b | 11000100b = 11101111b
-10101111b | 11000101b = 11101111b
-10101111b | 11000110b = 11101111b
-10101111b | 11000111b = 11101111b
-10101111b | 11001000b = 11101111b
-10101111b | 11001001b = 11101111b
-10101111b | 11001010b = 11101111b
-10101111b | 11001011b = 11101111b
-10101111b | 11001100b = 11101111b
-10101111b | 11001101b = 11101111b
-10101111b | 11001110b = 11101111b
-10101111b | 11001111b = 11101111b
-10101111b | 11010000b = 11111111b
-10101111b | 11010001b = 11111111b
-10101111b | 11010010b = 11111111b
-10101111b | 11010011b = 11111111b
-10101111b | 11010100b = 11111111b
-10101111b | 11010101b = 11111111b
-10101111b | 11010110b = 11111111b
-10101111b | 11010111b = 11111111b
-10101111b | 11011000b = 11111111b
-10101111b | 11011001b = 11111111b
-10101111b | 11011010b = 11111111b
-10101111b | 11011011b = 11111111b
-10101111b | 11011100b = 11111111b
-10101111b | 11011101b = 11111111b
-10101111b | 11011110b = 11111111b
-10101111b | 11011111b = 11111111b
-10101111b | 11100000b = 11101111b
-10101111b | 11100001b = 11101111b
-10101111b | 11100010b = 11101111b
-10101111b | 11100011b = 11101111b
-10101111b | 11100100b = 11101111b
-10101111b | 11100101b = 11101111b
-10101111b | 11100110b = 11101111b
-10101111b | 11100111b = 11101111b
-10101111b | 11101000b = 11101111b
-10101111b | 11101001b = 11101111b
-10101111b | 11101010b = 11101111b
-10101111b | 11101011b = 11101111b
-10101111b | 11101100b = 11101111b
-10101111b | 11101101b = 11101111b
-10101111b | 11101110b = 11101111b
-10101111b | 11101111b = 11101111b
-10101111b | 11110000b = 11111111b
-10101111b | 11110001b = 11111111b
-10101111b | 11110010b = 11111111b
-10101111b | 11110011b = 11111111b
-10101111b | 11110100b = 11111111b
-10101111b | 11110101b = 11111111b
-10101111b | 11110110b = 11111111b
-10101111b | 11110111b = 11111111b
-10101111b | 11111000b = 11111111b
-10101111b | 11111001b = 11111111b
-10101111b | 11111010b = 11111111b
-10101111b | 11111011b = 11111111b
-10101111b | 11111100b = 11111111b
-10101111b | 11111101b = 11111111b
-10101111b | 11111110b = 11111111b
-10101111b | 11111111b = 11111111b
-10101111b | 00000000b = 10101111b
-10101111b | 00000001b = 10101111b
-10101111b | 00000010b = 10101111b
-10101111b | 00000011b = 10101111b
-10101111b | 00000100b = 10101111b
-10101111b | 00000101b = 10101111b
-10101111b | 00000110b = 10101111b
-10101111b | 00000111b = 10101111b
-10101111b | 00001000b = 10101111b
-10101111b | 00001001b = 10101111b
-10101111b | 00001010b = 10101111b
-10101111b | 00001011b = 10101111b
-10101111b | 00001100b = 10101111b
-10101111b | 00001101b = 10101111b
-10101111b | 00001110b = 10101111b
-10101111b | 00001111b = 10101111b
-10101111b | 00010000b = 10111111b
-10101111b | 00010001b = 10111111b
-10101111b | 00010010b = 10111111b
-10101111b | 00010011b = 10111111b
-10101111b | 00010100b = 10111111b
-10101111b | 00010101b = 10111111b
-10101111b | 00010110b = 10111111b
-10101111b | 00010111b = 10111111b
-10101111b | 00011000b = 10111111b
-10101111b | 00011001b = 10111111b
-10101111b | 00011010b = 10111111b
-10101111b | 00011011b = 10111111b
-10101111b | 00011100b = 10111111b
-10101111b | 00011101b = 10111111b
-10101111b | 00011110b = 10111111b
-10101111b | 00011111b = 10111111b
-10101111b | 00100000b = 10101111b
-10101111b | 00100001b = 10101111b
-10101111b | 00100010b = 10101111b
-10101111b | 00100011b = 10101111b
-10101111b | 00100100b = 10101111b
-10101111b | 00100101b = 10101111b
-10101111b | 00100110b = 10101111b
-10101111b | 00100111b = 10101111b
-10101111b | 00101000b = 10101111b
-10101111b | 00101001b = 10101111b
-10101111b | 00101010b = 10101111b
-10101111b | 00101011b = 10101111b
-10101111b | 00101100b = 10101111b
-10101111b | 00101101b = 10101111b
-10101111b | 00101110b = 10101111b
-10101111b | 00101111b = 10101111b
-10101111b | 00110000b = 10111111b
-10101111b | 00110001b = 10111111b
-10101111b | 00110010b = 10111111b
-10101111b | 00110011b = 10111111b
-10101111b | 00110100b = 10111111b
-10101111b | 00110101b = 10111111b
-10101111b | 00110110b = 10111111b
-10101111b | 00110111b = 10111111b
-10101111b | 00111000b = 10111111b
-10101111b | 00111001b = 10111111b
-10101111b | 00111010b = 10111111b
-10101111b | 00111011b = 10111111b
-10101111b | 00111100b = 10111111b
-10101111b | 00111101b = 10111111b
-10101111b | 00111110b = 10111111b
-10101111b | 00111111b = 10111111b
-10101111b | 01000000b = 11101111b
-10101111b | 01000001b = 11101111b
-10101111b | 01000010b = 11101111b
-10101111b | 01000011b = 11101111b
-10101111b | 01000100b = 11101111b
-10101111b | 01000101b = 11101111b
-10101111b | 01000110b = 11101111b
-10101111b | 01000111b = 11101111b
-10101111b | 01001000b = 11101111b
-10101111b | 01001001b = 11101111b
-10101111b | 01001010b = 11101111b
-10101111b | 01001011b = 11101111b
-10101111b | 01001100b = 11101111b
-10101111b | 01001101b = 11101111b
-10101111b | 01001110b = 11101111b
-10101111b | 01001111b = 11101111b
-10101111b | 01010000b = 11111111b
-10101111b | 01010001b = 11111111b
-10101111b | 01010010b = 11111111b
-10101111b | 01010011b = 11111111b
-10101111b | 01010100b = 11111111b
-10101111b | 01010101b = 11111111b
-10101111b | 01010110b = 11111111b
-10101111b | 01010111b = 11111111b
-10101111b | 01011000b = 11111111b
-10101111b | 01011001b = 11111111b
-10101111b | 01011010b = 11111111b
-10101111b | 01011011b = 11111111b
-10101111b | 01011100b = 11111111b
-10101111b | 01011101b = 11111111b
-10101111b | 01011110b = 11111111b
-10101111b | 01011111b = 11111111b
-10101111b | 01100000b = 11101111b
-10101111b | 01100001b = 11101111b
-10101111b | 01100010b = 11101111b
-10101111b | 01100011b = 11101111b
-10101111b | 01100100b = 11101111b
-10101111b | 01100101b = 11101111b
-10101111b | 01100110b = 11101111b
-10101111b | 01100111b = 11101111b
-10101111b | 01101000b = 11101111b
-10101111b | 01101001b = 11101111b
-10101111b | 01101010b = 11101111b
-10101111b | 01101011b = 11101111b
-10101111b | 01101100b = 11101111b
-10101111b | 01101101b = 11101111b
-10101111b | 01101110b = 11101111b
-10101111b | 01101111b = 11101111b
-10101111b | 01110000b = 11111111b
-10101111b | 01110001b = 11111111b
-10101111b | 01110010b = 11111111b
-10101111b | 01110011b = 11111111b
-10101111b | 01110100b = 11111111b
-10101111b | 01110101b = 11111111b
-10101111b | 01110110b = 11111111b
-10101111b | 01110111b = 11111111b
-10101111b | 01111000b = 11111111b
-10101111b | 01111001b = 11111111b
-10101111b | 01111010b = 11111111b
-10101111b | 01111011b = 11111111b
-10101111b | 01111100b = 11111111b
-10101111b | 01111101b = 11111111b
-10101111b | 01111110b = 11111111b
-10110000b | 10000000b = 10110000b
-10110000b | 10000001b = 10110001b
-10110000b | 10000010b = 10110010b
-10110000b | 10000011b = 10110011b
-10110000b | 10000100b = 10110100b
-10110000b | 10000101b = 10110101b
-10110000b | 10000110b = 10110110b
-10110000b | 10000111b = 10110111b
-10110000b | 10001000b = 10111000b
-10110000b | 10001001b = 10111001b
-10110000b | 10001010b = 10111010b
-10110000b | 10001011b = 10111011b
-10110000b | 10001100b = 10111100b
-10110000b | 10001101b = 10111101b
-10110000b | 10001110b = 10111110b
-10110000b | 10001111b = 10111111b
-10110000b | 10010000b = 10110000b
-10110000b | 10010001b = 10110001b
-10110000b | 10010010b = 10110010b
-10110000b | 10010011b = 10110011b
-10110000b | 10010100b = 10110100b
-10110000b | 10010101b = 10110101b
-10110000b | 10010110b = 10110110b
-10110000b | 10010111b = 10110111b
-10110000b | 10011000b = 10111000b
-10110000b | 10011001b = 10111001b
-10110000b | 10011010b = 10111010b
-10110000b | 10011011b = 10111011b
-10110000b | 10011100b = 10111100b
-10110000b | 10011101b = 10111101b
-10110000b | 10011110b = 10111110b
-10110000b | 10011111b = 10111111b
-10110000b | 10100000b = 10110000b
-10110000b | 10100001b = 10110001b
-10110000b | 10100010b = 10110010b
-10110000b | 10100011b = 10110011b
-10110000b | 10100100b = 10110100b
-10110000b | 10100101b = 10110101b
-10110000b | 10100110b = 10110110b
-10110000b | 10100111b = 10110111b
-10110000b | 10101000b = 10111000b
-10110000b | 10101001b = 10111001b
-10110000b | 10101010b = 10111010b
-10110000b | 10101011b = 10111011b
-10110000b | 10101100b = 10111100b
-10110000b | 10101101b = 10111101b
-10110000b | 10101110b = 10111110b
-10110000b | 10101111b = 10111111b
-10110000b | 10110000b = 10110000b
-10110000b | 10110001b = 10110001b
-10110000b | 10110010b = 10110010b
-10110000b | 10110011b = 10110011b
-10110000b | 10110100b = 10110100b
-10110000b | 10110101b = 10110101b
-10110000b | 10110110b = 10110110b
-10110000b | 10110111b = 10110111b
-10110000b | 10111000b = 10111000b
-10110000b | 10111001b = 10111001b
-10110000b | 10111010b = 10111010b
-10110000b | 10111011b = 10111011b
-10110000b | 10111100b = 10111100b
-10110000b | 10111101b = 10111101b
-10110000b | 10111110b = 10111110b
-10110000b | 10111111b = 10111111b
-10110000b | 11000000b = 11110000b
-10110000b | 11000001b = 11110001b
-10110000b | 11000010b = 11110010b
-10110000b | 11000011b = 11110011b
-10110000b | 11000100b = 11110100b
-10110000b | 11000101b = 11110101b
-10110000b | 11000110b = 11110110b
-10110000b | 11000111b = 11110111b
-10110000b | 11001000b = 11111000b
-10110000b | 11001001b = 11111001b
-10110000b | 11001010b = 11111010b
-10110000b | 11001011b = 11111011b
-10110000b | 11001100b = 11111100b
-10110000b | 11001101b = 11111101b
-10110000b | 11001110b = 11111110b
-10110000b | 11001111b = 11111111b
-10110000b | 11010000b = 11110000b
-10110000b | 11010001b = 11110001b
-10110000b | 11010010b = 11110010b
-10110000b | 11010011b = 11110011b
-10110000b | 11010100b = 11110100b
-10110000b | 11010101b = 11110101b
-10110000b | 11010110b = 11110110b
-10110000b | 11010111b = 11110111b
-10110000b | 11011000b = 11111000b
-10110000b | 11011001b = 11111001b
-10110000b | 11011010b = 11111010b
-10110000b | 11011011b = 11111011b
-10110000b | 11011100b = 11111100b
-10110000b | 11011101b = 11111101b
-10110000b | 11011110b = 11111110b
-10110000b | 11011111b = 11111111b
-10110000b | 11100000b = 11110000b
-10110000b | 11100001b = 11110001b
-10110000b | 11100010b = 11110010b
-10110000b | 11100011b = 11110011b
-10110000b | 11100100b = 11110100b
-10110000b | 11100101b = 11110101b
-10110000b | 11100110b = 11110110b
-10110000b | 11100111b = 11110111b
-10110000b | 11101000b = 11111000b
-10110000b | 11101001b = 11111001b
-10110000b | 11101010b = 11111010b
-10110000b | 11101011b = 11111011b
-10110000b | 11101100b = 11111100b
-10110000b | 11101101b = 11111101b
-10110000b | 11101110b = 11111110b
-10110000b | 11101111b = 11111111b
-10110000b | 11110000b = 11110000b
-10110000b | 11110001b = 11110001b
-10110000b | 11110010b = 11110010b
-10110000b | 11110011b = 11110011b
-10110000b | 11110100b = 11110100b
-10110000b | 11110101b = 11110101b
-10110000b | 11110110b = 11110110b
-10110000b | 11110111b = 11110111b
-10110000b | 11111000b = 11111000b
-10110000b | 11111001b = 11111001b
-10110000b | 11111010b = 11111010b
-10110000b | 11111011b = 11111011b
-10110000b | 11111100b = 11111100b
-10110000b | 11111101b = 11111101b
-10110000b | 11111110b = 11111110b
-10110000b | 11111111b = 11111111b
-10110000b | 00000000b = 10110000b
-10110000b | 00000001b = 10110001b
-10110000b | 00000010b = 10110010b
-10110000b | 00000011b = 10110011b
-10110000b | 00000100b = 10110100b
-10110000b | 00000101b = 10110101b
-10110000b | 00000110b = 10110110b
-10110000b | 00000111b = 10110111b
-10110000b | 00001000b = 10111000b
-10110000b | 00001001b = 10111001b
-10110000b | 00001010b = 10111010b
-10110000b | 00001011b = 10111011b
-10110000b | 00001100b = 10111100b
-10110000b | 00001101b = 10111101b
-10110000b | 00001110b = 10111110b
-10110000b | 00001111b = 10111111b
-10110000b | 00010000b = 10110000b
-10110000b | 00010001b = 10110001b
-10110000b | 00010010b = 10110010b
-10110000b | 00010011b = 10110011b
-10110000b | 00010100b = 10110100b
-10110000b | 00010101b = 10110101b
-10110000b | 00010110b = 10110110b
-10110000b | 00010111b = 10110111b
-10110000b | 00011000b = 10111000b
-10110000b | 00011001b = 10111001b
-10110000b | 00011010b = 10111010b
-10110000b | 00011011b = 10111011b
-10110000b | 00011100b = 10111100b
-10110000b | 00011101b = 10111101b
-10110000b | 00011110b = 10111110b
-10110000b | 00011111b = 10111111b
-10110000b | 00100000b = 10110000b
-10110000b | 00100001b = 10110001b
-10110000b | 00100010b = 10110010b
-10110000b | 00100011b = 10110011b
-10110000b | 00100100b = 10110100b
-10110000b | 00100101b = 10110101b
-10110000b | 00100110b = 10110110b
-10110000b | 00100111b = 10110111b
-10110000b | 00101000b = 10111000b
-10110000b | 00101001b = 10111001b
-10110000b | 00101010b = 10111010b
-10110000b | 00101011b = 10111011b
-10110000b | 00101100b = 10111100b
-10110000b | 00101101b = 10111101b
-10110000b | 00101110b = 10111110b
-10110000b | 00101111b = 10111111b
-10110000b | 00110000b = 10110000b
-10110000b | 00110001b = 10110001b
-10110000b | 00110010b = 10110010b
-10110000b | 00110011b = 10110011b
-10110000b | 00110100b = 10110100b
-10110000b | 00110101b = 10110101b
-10110000b | 00110110b = 10110110b
-10110000b | 00110111b = 10110111b
-10110000b | 00111000b = 10111000b
-10110000b | 00111001b = 10111001b
-10110000b | 00111010b = 10111010b
-10110000b | 00111011b = 10111011b
-10110000b | 00111100b = 10111100b
-10110000b | 00111101b = 10111101b
-10110000b | 00111110b = 10111110b
-10110000b | 00111111b = 10111111b
-10110000b | 01000000b = 11110000b
-10110000b | 01000001b = 11110001b
-10110000b | 01000010b = 11110010b
-10110000b | 01000011b = 11110011b
-10110000b | 01000100b = 11110100b
-10110000b | 01000101b = 11110101b
-10110000b | 01000110b = 11110110b
-10110000b | 01000111b = 11110111b
-10110000b | 01001000b = 11111000b
-10110000b | 01001001b = 11111001b
-10110000b | 01001010b = 11111010b
-10110000b | 01001011b = 11111011b
-10110000b | 01001100b = 11111100b
-10110000b | 01001101b = 11111101b
-10110000b | 01001110b = 11111110b
-10110000b | 01001111b = 11111111b
-10110000b | 01010000b = 11110000b
-10110000b | 01010001b = 11110001b
-10110000b | 01010010b = 11110010b
-10110000b | 01010011b = 11110011b
-10110000b | 01010100b = 11110100b
-10110000b | 01010101b = 11110101b
-10110000b | 01010110b = 11110110b
-10110000b | 01010111b = 11110111b
-10110000b | 01011000b = 11111000b
-10110000b | 01011001b = 11111001b
-10110000b | 01011010b = 11111010b
-10110000b | 01011011b = 11111011b
-10110000b | 01011100b = 11111100b
-10110000b | 01011101b = 11111101b
-10110000b | 01011110b = 11111110b
-10110000b | 01011111b = 11111111b
-10110000b | 01100000b = 11110000b
-10110000b | 01100001b = 11110001b
-10110000b | 01100010b = 11110010b
-10110000b | 01100011b = 11110011b
-10110000b | 01100100b = 11110100b
-10110000b | 01100101b = 11110101b
-10110000b | 01100110b = 11110110b
-10110000b | 01100111b = 11110111b
-10110000b | 01101000b = 11111000b
-10110000b | 01101001b = 11111001b
-10110000b | 01101010b = 11111010b
-10110000b | 01101011b = 11111011b
-10110000b | 01101100b = 11111100b
-10110000b | 01101101b = 11111101b
-10110000b | 01101110b = 11111110b
-10110000b | 01101111b = 11111111b
-10110000b | 01110000b = 11110000b
-10110000b | 01110001b = 11110001b
-10110000b | 01110010b = 11110010b
-10110000b | 01110011b = 11110011b
-10110000b | 01110100b = 11110100b
-10110000b | 01110101b = 11110101b
-10110000b | 01110110b = 11110110b
-10110000b | 01110111b = 11110111b
-10110000b | 01111000b = 11111000b
-10110000b | 01111001b = 11111001b
-10110000b | 01111010b = 11111010b
-10110000b | 01111011b = 11111011b
-10110000b | 01111100b = 11111100b
-10110000b | 01111101b = 11111101b
-10110000b | 01111110b = 11111110b
-10110001b | 10000000b = 10110001b
-10110001b | 10000001b = 10110001b
-10110001b | 10000010b = 10110011b
-10110001b | 10000011b = 10110011b
-10110001b | 10000100b = 10110101b
-10110001b | 10000101b = 10110101b
-10110001b | 10000110b = 10110111b
-10110001b | 10000111b = 10110111b
-10110001b | 10001000b = 10111001b
-10110001b | 10001001b = 10111001b
-10110001b | 10001010b = 10111011b
-10110001b | 10001011b = 10111011b
-10110001b | 10001100b = 10111101b
-10110001b | 10001101b = 10111101b
-10110001b | 10001110b = 10111111b
-10110001b | 10001111b = 10111111b
-10110001b | 10010000b = 10110001b
-10110001b | 10010001b = 10110001b
-10110001b | 10010010b = 10110011b
-10110001b | 10010011b = 10110011b
-10110001b | 10010100b = 10110101b
-10110001b | 10010101b = 10110101b
-10110001b | 10010110b = 10110111b
-10110001b | 10010111b = 10110111b
-10110001b | 10011000b = 10111001b
-10110001b | 10011001b = 10111001b
-10110001b | 10011010b = 10111011b
-10110001b | 10011011b = 10111011b
-10110001b | 10011100b = 10111101b
-10110001b | 10011101b = 10111101b
-10110001b | 10011110b = 10111111b
-10110001b | 10011111b = 10111111b
-10110001b | 10100000b = 10110001b
-10110001b | 10100001b = 10110001b
-10110001b | 10100010b = 10110011b
-10110001b | 10100011b = 10110011b
-10110001b | 10100100b = 10110101b
-10110001b | 10100101b = 10110101b
-10110001b | 10100110b = 10110111b
-10110001b | 10100111b = 10110111b
-10110001b | 10101000b = 10111001b
-10110001b | 10101001b = 10111001b
-10110001b | 10101010b = 10111011b
-10110001b | 10101011b = 10111011b
-10110001b | 10101100b = 10111101b
-10110001b | 10101101b = 10111101b
-10110001b | 10101110b = 10111111b
-10110001b | 10101111b = 10111111b
-10110001b | 10110000b = 10110001b
-10110001b | 10110001b = 10110001b
-10110001b | 10110010b = 10110011b
-10110001b | 10110011b = 10110011b
-10110001b | 10110100b = 10110101b
-10110001b | 10110101b = 10110101b
-10110001b | 10110110b = 10110111b
-10110001b | 10110111b = 10110111b
-10110001b | 10111000b = 10111001b
-10110001b | 10111001b = 10111001b
-10110001b | 10111010b = 10111011b
-10110001b | 10111011b = 10111011b
-10110001b | 10111100b = 10111101b
-10110001b | 10111101b = 10111101b
-10110001b | 10111110b = 10111111b
-10110001b | 10111111b = 10111111b
-10110001b | 11000000b = 11110001b
-10110001b | 11000001b = 11110001b
-10110001b | 11000010b = 11110011b
-10110001b | 11000011b = 11110011b
-10110001b | 11000100b = 11110101b
-10110001b | 11000101b = 11110101b
-10110001b | 11000110b = 11110111b
-10110001b | 11000111b = 11110111b
-10110001b | 11001000b = 11111001b
-10110001b | 11001001b = 11111001b
-10110001b | 11001010b = 11111011b
-10110001b | 11001011b = 11111011b
-10110001b | 11001100b = 11111101b
-10110001b | 11001101b = 11111101b
-10110001b | 11001110b = 11111111b
-10110001b | 11001111b = 11111111b
-10110001b | 11010000b = 11110001b
-10110001b | 11010001b = 11110001b
-10110001b | 11010010b = 11110011b
-10110001b | 11010011b = 11110011b
-10110001b | 11010100b = 11110101b
-10110001b | 11010101b = 11110101b
-10110001b | 11010110b = 11110111b
-10110001b | 11010111b = 11110111b
-10110001b | 11011000b = 11111001b
-10110001b | 11011001b = 11111001b
-10110001b | 11011010b = 11111011b
-10110001b | 11011011b = 11111011b
-10110001b | 11011100b = 11111101b
-10110001b | 11011101b = 11111101b
-10110001b | 11011110b = 11111111b
-10110001b | 11011111b = 11111111b
-10110001b | 11100000b = 11110001b
-10110001b | 11100001b = 11110001b
-10110001b | 11100010b = 11110011b
-10110001b | 11100011b = 11110011b
-10110001b | 11100100b = 11110101b
-10110001b | 11100101b = 11110101b
-10110001b | 11100110b = 11110111b
-10110001b | 11100111b = 11110111b
-10110001b | 11101000b = 11111001b
-10110001b | 11101001b = 11111001b
-10110001b | 11101010b = 11111011b
-10110001b | 11101011b = 11111011b
-10110001b | 11101100b = 11111101b
-10110001b | 11101101b = 11111101b
-10110001b | 11101110b = 11111111b
-10110001b | 11101111b = 11111111b
-10110001b | 11110000b = 11110001b
-10110001b | 11110001b = 11110001b
-10110001b | 11110010b = 11110011b
-10110001b | 11110011b = 11110011b
-10110001b | 11110100b = 11110101b
-10110001b | 11110101b = 11110101b
-10110001b | 11110110b = 11110111b
-10110001b | 11110111b = 11110111b
-10110001b | 11111000b = 11111001b
-10110001b | 11111001b = 11111001b
-10110001b | 11111010b = 11111011b
-10110001b | 11111011b = 11111011b
-10110001b | 11111100b = 11111101b
-10110001b | 11111101b = 11111101b
-10110001b | 11111110b = 11111111b
-10110001b | 11111111b = 11111111b
-10110001b | 00000000b = 10110001b
-10110001b | 00000001b = 10110001b
-10110001b | 00000010b = 10110011b
-10110001b | 00000011b = 10110011b
-10110001b | 00000100b = 10110101b
-10110001b | 00000101b = 10110101b
-10110001b | 00000110b = 10110111b
-10110001b | 00000111b = 10110111b
-10110001b | 00001000b = 10111001b
-10110001b | 00001001b = 10111001b
-10110001b | 00001010b = 10111011b
-10110001b | 00001011b = 10111011b
-10110001b | 00001100b = 10111101b
-10110001b | 00001101b = 10111101b
-10110001b | 00001110b = 10111111b
-10110001b | 00001111b = 10111111b
-10110001b | 00010000b = 10110001b
-10110001b | 00010001b = 10110001b
-10110001b | 00010010b = 10110011b
-10110001b | 00010011b = 10110011b
-10110001b | 00010100b = 10110101b
-10110001b | 00010101b = 10110101b
-10110001b | 00010110b = 10110111b
-10110001b | 00010111b = 10110111b
-10110001b | 00011000b = 10111001b
-10110001b | 00011001b = 10111001b
-10110001b | 00011010b = 10111011b
-10110001b | 00011011b = 10111011b
-10110001b | 00011100b = 10111101b
-10110001b | 00011101b = 10111101b
-10110001b | 00011110b = 10111111b
-10110001b | 00011111b = 10111111b
-10110001b | 00100000b = 10110001b
-10110001b | 00100001b = 10110001b
-10110001b | 00100010b = 10110011b
-10110001b | 00100011b = 10110011b
-10110001b | 00100100b = 10110101b
-10110001b | 00100101b = 10110101b
-10110001b | 00100110b = 10110111b
-10110001b | 00100111b = 10110111b
-10110001b | 00101000b = 10111001b
-10110001b | 00101001b = 10111001b
-10110001b | 00101010b = 10111011b
-10110001b | 00101011b = 10111011b
-10110001b | 00101100b = 10111101b
-10110001b | 00101101b = 10111101b
-10110001b | 00101110b = 10111111b
-10110001b | 00101111b = 10111111b
-10110001b | 00110000b = 10110001b
-10110001b | 00110001b = 10110001b
-10110001b | 00110010b = 10110011b
-10110001b | 00110011b = 10110011b
-10110001b | 00110100b = 10110101b
-10110001b | 00110101b = 10110101b
-10110001b | 00110110b = 10110111b
-10110001b | 00110111b = 10110111b
-10110001b | 00111000b = 10111001b
-10110001b | 00111001b = 10111001b
-10110001b | 00111010b = 10111011b
-10110001b | 00111011b = 10111011b
-10110001b | 00111100b = 10111101b
-10110001b | 00111101b = 10111101b
-10110001b | 00111110b = 10111111b
-10110001b | 00111111b = 10111111b
-10110001b | 01000000b = 11110001b
-10110001b | 01000001b = 11110001b
-10110001b | 01000010b = 11110011b
-10110001b | 01000011b = 11110011b
-10110001b | 01000100b = 11110101b
-10110001b | 01000101b = 11110101b
-10110001b | 01000110b = 11110111b
-10110001b | 01000111b = 11110111b
-10110001b | 01001000b = 11111001b
-10110001b | 01001001b = 11111001b
-10110001b | 01001010b = 11111011b
-10110001b | 01001011b = 11111011b
-10110001b | 01001100b = 11111101b
-10110001b | 01001101b = 11111101b
-10110001b | 01001110b = 11111111b
-10110001b | 01001111b = 11111111b
-10110001b | 01010000b = 11110001b
-10110001b | 01010001b = 11110001b
-10110001b | 01010010b = 11110011b
-10110001b | 01010011b = 11110011b
-10110001b | 01010100b = 11110101b
-10110001b | 01010101b = 11110101b
-10110001b | 01010110b = 11110111b
-10110001b | 01010111b = 11110111b
-10110001b | 01011000b = 11111001b
-10110001b | 01011001b = 11111001b
-10110001b | 01011010b = 11111011b
-10110001b | 01011011b = 11111011b
-10110001b | 01011100b = 11111101b
-10110001b | 01011101b = 11111101b
-10110001b | 01011110b = 11111111b
-10110001b | 01011111b = 11111111b
-10110001b | 01100000b = 11110001b
-10110001b | 01100001b = 11110001b
-10110001b | 01100010b = 11110011b
-10110001b | 01100011b = 11110011b
-10110001b | 01100100b = 11110101b
-10110001b | 01100101b = 11110101b
-10110001b | 01100110b = 11110111b
-10110001b | 01100111b = 11110111b
-10110001b | 01101000b = 11111001b
-10110001b | 01101001b = 11111001b
-10110001b | 01101010b = 11111011b
-10110001b | 01101011b = 11111011b
-10110001b | 01101100b = 11111101b
-10110001b | 01101101b = 11111101b
-10110001b | 01101110b = 11111111b
-10110001b | 01101111b = 11111111b
-10110001b | 01110000b = 11110001b
-10110001b | 01110001b = 11110001b
-10110001b | 01110010b = 11110011b
-10110001b | 01110011b = 11110011b
-10110001b | 01110100b = 11110101b
-10110001b | 01110101b = 11110101b
-10110001b | 01110110b = 11110111b
-10110001b | 01110111b = 11110111b
-10110001b | 01111000b = 11111001b
-10110001b | 01111001b = 11111001b
-10110001b | 01111010b = 11111011b
-10110001b | 01111011b = 11111011b
-10110001b | 01111100b = 11111101b
-10110001b | 01111101b = 11111101b
-10110001b | 01111110b = 11111111b
-10110010b | 10000000b = 10110010b
-10110010b | 10000001b = 10110011b
-10110010b | 10000010b = 10110010b
-10110010b | 10000011b = 10110011b
-10110010b | 10000100b = 10110110b
-10110010b | 10000101b = 10110111b
-10110010b | 10000110b = 10110110b
-10110010b | 10000111b = 10110111b
-10110010b | 10001000b = 10111010b
-10110010b | 10001001b = 10111011b
-10110010b | 10001010b = 10111010b
-10110010b | 10001011b = 10111011b
-10110010b | 10001100b = 10111110b
-10110010b | 10001101b = 10111111b
-10110010b | 10001110b = 10111110b
-10110010b | 10001111b = 10111111b
-10110010b | 10010000b = 10110010b
-10110010b | 10010001b = 10110011b
-10110010b | 10010010b = 10110010b
-10110010b | 10010011b = 10110011b
-10110010b | 10010100b = 10110110b
-10110010b | 10010101b = 10110111b
-10110010b | 10010110b = 10110110b
-10110010b | 10010111b = 10110111b
-10110010b | 10011000b = 10111010b
-10110010b | 10011001b = 10111011b
-10110010b | 10011010b = 10111010b
-10110010b | 10011011b = 10111011b
-10110010b | 10011100b = 10111110b
-10110010b | 10011101b = 10111111b
-10110010b | 10011110b = 10111110b
-10110010b | 10011111b = 10111111b
-10110010b | 10100000b = 10110010b
-10110010b | 10100001b = 10110011b
-10110010b | 10100010b = 10110010b
-10110010b | 10100011b = 10110011b
-10110010b | 10100100b = 10110110b
-10110010b | 10100101b = 10110111b
-10110010b | 10100110b = 10110110b
-10110010b | 10100111b = 10110111b
-10110010b | 10101000b = 10111010b
-10110010b | 10101001b = 10111011b
-10110010b | 10101010b = 10111010b
-10110010b | 10101011b = 10111011b
-10110010b | 10101100b = 10111110b
-10110010b | 10101101b = 10111111b
-10110010b | 10101110b = 10111110b
-10110010b | 10101111b = 10111111b
-10110010b | 10110000b = 10110010b
-10110010b | 10110001b = 10110011b
-10110010b | 10110010b = 10110010b
-10110010b | 10110011b = 10110011b
-10110010b | 10110100b = 10110110b
-10110010b | 10110101b = 10110111b
-10110010b | 10110110b = 10110110b
-10110010b | 10110111b = 10110111b
-10110010b | 10111000b = 10111010b
-10110010b | 10111001b = 10111011b
-10110010b | 10111010b = 10111010b
-10110010b | 10111011b = 10111011b
-10110010b | 10111100b = 10111110b
-10110010b | 10111101b = 10111111b
-10110010b | 10111110b = 10111110b
-10110010b | 10111111b = 10111111b
-10110010b | 11000000b = 11110010b
-10110010b | 11000001b = 11110011b
-10110010b | 11000010b = 11110010b
-10110010b | 11000011b = 11110011b
-10110010b | 11000100b = 11110110b
-10110010b | 11000101b = 11110111b
-10110010b | 11000110b = 11110110b
-10110010b | 11000111b = 11110111b
-10110010b | 11001000b = 11111010b
-10110010b | 11001001b = 11111011b
-10110010b | 11001010b = 11111010b
-10110010b | 11001011b = 11111011b
-10110010b | 11001100b = 11111110b
-10110010b | 11001101b = 11111111b
-10110010b | 11001110b = 11111110b
-10110010b | 11001111b = 11111111b
-10110010b | 11010000b = 11110010b
-10110010b | 11010001b = 11110011b
-10110010b | 11010010b = 11110010b
-10110010b | 11010011b = 11110011b
-10110010b | 11010100b = 11110110b
-10110010b | 11010101b = 11110111b
-10110010b | 11010110b = 11110110b
-10110010b | 11010111b = 11110111b
-10110010b | 11011000b = 11111010b
-10110010b | 11011001b = 11111011b
-10110010b | 11011010b = 11111010b
-10110010b | 11011011b = 11111011b
-10110010b | 11011100b = 11111110b
-10110010b | 11011101b = 11111111b
-10110010b | 11011110b = 11111110b
-10110010b | 11011111b = 11111111b
-10110010b | 11100000b = 11110010b
-10110010b | 11100001b = 11110011b
-10110010b | 11100010b = 11110010b
-10110010b | 11100011b = 11110011b
-10110010b | 11100100b = 11110110b
-10110010b | 11100101b = 11110111b
-10110010b | 11100110b = 11110110b
-10110010b | 11100111b = 11110111b
-10110010b | 11101000b = 11111010b
-10110010b | 11101001b = 11111011b
-10110010b | 11101010b = 11111010b
-10110010b | 11101011b = 11111011b
-10110010b | 11101100b = 11111110b
-10110010b | 11101101b = 11111111b
-10110010b | 11101110b = 11111110b
-10110010b | 11101111b = 11111111b
-10110010b | 11110000b = 11110010b
-10110010b | 11110001b = 11110011b
-10110010b | 11110010b = 11110010b
-10110010b | 11110011b = 11110011b
-10110010b | 11110100b = 11110110b
-10110010b | 11110101b = 11110111b
-10110010b | 11110110b = 11110110b
-10110010b | 11110111b = 11110111b
-10110010b | 11111000b = 11111010b
-10110010b | 11111001b = 11111011b
-10110010b | 11111010b = 11111010b
-10110010b | 11111011b = 11111011b
-10110010b | 11111100b = 11111110b
-10110010b | 11111101b = 11111111b
-10110010b | 11111110b = 11111110b
-10110010b | 11111111b = 11111111b
-10110010b | 00000000b = 10110010b
-10110010b | 00000001b = 10110011b
-10110010b | 00000010b = 10110010b
-10110010b | 00000011b = 10110011b
-10110010b | 00000100b = 10110110b
-10110010b | 00000101b = 10110111b
-10110010b | 00000110b = 10110110b
-10110010b | 00000111b = 10110111b
-10110010b | 00001000b = 10111010b
-10110010b | 00001001b = 10111011b
-10110010b | 00001010b = 10111010b
-10110010b | 00001011b = 10111011b
-10110010b | 00001100b = 10111110b
-10110010b | 00001101b = 10111111b
-10110010b | 00001110b = 10111110b
-10110010b | 00001111b = 10111111b
-10110010b | 00010000b = 10110010b
-10110010b | 00010001b = 10110011b
-10110010b | 00010010b = 10110010b
-10110010b | 00010011b = 10110011b
-10110010b | 00010100b = 10110110b
-10110010b | 00010101b = 10110111b
-10110010b | 00010110b = 10110110b
-10110010b | 00010111b = 10110111b
-10110010b | 00011000b = 10111010b
-10110010b | 00011001b = 10111011b
-10110010b | 00011010b = 10111010b
-10110010b | 00011011b = 10111011b
-10110010b | 00011100b = 10111110b
-10110010b | 00011101b = 10111111b
-10110010b | 00011110b = 10111110b
-10110010b | 00011111b = 10111111b
-10110010b | 00100000b = 10110010b
-10110010b | 00100001b = 10110011b
-10110010b | 00100010b = 10110010b
-10110010b | 00100011b = 10110011b
-10110010b | 00100100b = 10110110b
-10110010b | 00100101b = 10110111b
-10110010b | 00100110b = 10110110b
-10110010b | 00100111b = 10110111b
-10110010b | 00101000b = 10111010b
-10110010b | 00101001b = 10111011b
-10110010b | 00101010b = 10111010b
-10110010b | 00101011b = 10111011b
-10110010b | 00101100b = 10111110b
-10110010b | 00101101b = 10111111b
-10110010b | 00101110b = 10111110b
-10110010b | 00101111b = 10111111b
-10110010b | 00110000b = 10110010b
-10110010b | 00110001b = 10110011b
-10110010b | 00110010b = 10110010b
-10110010b | 00110011b = 10110011b
-10110010b | 00110100b = 10110110b
-10110010b | 00110101b = 10110111b
-10110010b | 00110110b = 10110110b
-10110010b | 00110111b = 10110111b
-10110010b | 00111000b = 10111010b
-10110010b | 00111001b = 10111011b
-10110010b | 00111010b = 10111010b
-10110010b | 00111011b = 10111011b
-10110010b | 00111100b = 10111110b
-10110010b | 00111101b = 10111111b
-10110010b | 00111110b = 10111110b
-10110010b | 00111111b = 10111111b
-10110010b | 01000000b = 11110010b
-10110010b | 01000001b = 11110011b
-10110010b | 01000010b = 11110010b
-10110010b | 01000011b = 11110011b
-10110010b | 01000100b = 11110110b
-10110010b | 01000101b = 11110111b
-10110010b | 01000110b = 11110110b
-10110010b | 01000111b = 11110111b
-10110010b | 01001000b = 11111010b
-10110010b | 01001001b = 11111011b
-10110010b | 01001010b = 11111010b
-10110010b | 01001011b = 11111011b
-10110010b | 01001100b = 11111110b
-10110010b | 01001101b = 11111111b
-10110010b | 01001110b = 11111110b
-10110010b | 01001111b = 11111111b
-10110010b | 01010000b = 11110010b
-10110010b | 01010001b = 11110011b
-10110010b | 01010010b = 11110010b
-10110010b | 01010011b = 11110011b
-10110010b | 01010100b = 11110110b
-10110010b | 01010101b = 11110111b
-10110010b | 01010110b = 11110110b
-10110010b | 01010111b = 11110111b
-10110010b | 01011000b = 11111010b
-10110010b | 01011001b = 11111011b
-10110010b | 01011010b = 11111010b
-10110010b | 01011011b = 11111011b
-10110010b | 01011100b = 11111110b
-10110010b | 01011101b = 11111111b
-10110010b | 01011110b = 11111110b
-10110010b | 01011111b = 11111111b
-10110010b | 01100000b = 11110010b
-10110010b | 01100001b = 11110011b
-10110010b | 01100010b = 11110010b
-10110010b | 01100011b = 11110011b
-10110010b | 01100100b = 11110110b
-10110010b | 01100101b = 11110111b
-10110010b | 01100110b = 11110110b
-10110010b | 01100111b = 11110111b
-10110010b | 01101000b = 11111010b
-10110010b | 01101001b = 11111011b
-10110010b | 01101010b = 11111010b
-10110010b | 01101011b = 11111011b
-10110010b | 01101100b = 11111110b
-10110010b | 01101101b = 11111111b
-10110010b | 01101110b = 11111110b
-10110010b | 01101111b = 11111111b
-10110010b | 01110000b = 11110010b
-10110010b | 01110001b = 11110011b
-10110010b | 01110010b = 11110010b
-10110010b | 01110011b = 11110011b
-10110010b | 01110100b = 11110110b
-10110010b | 01110101b = 11110111b
-10110010b | 01110110b = 11110110b
-10110010b | 01110111b = 11110111b
-10110010b | 01111000b = 11111010b
-10110010b | 01111001b = 11111011b
-10110010b | 01111010b = 11111010b
-10110010b | 01111011b = 11111011b
-10110010b | 01111100b = 11111110b
-10110010b | 01111101b = 11111111b
-10110010b | 01111110b = 11111110b
-10110011b | 10000000b = 10110011b
-10110011b | 10000001b = 10110011b
-10110011b | 10000010b = 10110011b
-10110011b | 10000011b = 10110011b
-10110011b | 10000100b = 10110111b
-10110011b | 10000101b = 10110111b
-10110011b | 10000110b = 10110111b
-10110011b | 10000111b = 10110111b
-10110011b | 10001000b = 10111011b
-10110011b | 10001001b = 10111011b
-10110011b | 10001010b = 10111011b
-10110011b | 10001011b = 10111011b
-10110011b | 10001100b = 10111111b
-10110011b | 10001101b = 10111111b
-10110011b | 10001110b = 10111111b
-10110011b | 10001111b = 10111111b
-10110011b | 10010000b = 10110011b
-10110011b | 10010001b = 10110011b
-10110011b | 10010010b = 10110011b
-10110011b | 10010011b = 10110011b
-10110011b | 10010100b = 10110111b
-10110011b | 10010101b = 10110111b
-10110011b | 10010110b = 10110111b
-10110011b | 10010111b = 10110111b
-10110011b | 10011000b = 10111011b
-10110011b | 10011001b = 10111011b
-10110011b | 10011010b = 10111011b
-10110011b | 10011011b = 10111011b
-10110011b | 10011100b = 10111111b
-10110011b | 10011101b = 10111111b
-10110011b | 10011110b = 10111111b
-10110011b | 10011111b = 10111111b
-10110011b | 10100000b = 10110011b
-10110011b | 10100001b = 10110011b
-10110011b | 10100010b = 10110011b
-10110011b | 10100011b = 10110011b
-10110011b | 10100100b = 10110111b
-10110011b | 10100101b = 10110111b
-10110011b | 10100110b = 10110111b
-10110011b | 10100111b = 10110111b
-10110011b | 10101000b = 10111011b
-10110011b | 10101001b = 10111011b
-10110011b | 10101010b = 10111011b
-10110011b | 10101011b = 10111011b
-10110011b | 10101100b = 10111111b
-10110011b | 10101101b = 10111111b
-10110011b | 10101110b = 10111111b
-10110011b | 10101111b = 10111111b
-10110011b | 10110000b = 10110011b
-10110011b | 10110001b = 10110011b
-10110011b | 10110010b = 10110011b
-10110011b | 10110011b = 10110011b
-10110011b | 10110100b = 10110111b
-10110011b | 10110101b = 10110111b
-10110011b | 10110110b = 10110111b
-10110011b | 10110111b = 10110111b
-10110011b | 10111000b = 10111011b
-10110011b | 10111001b = 10111011b
-10110011b | 10111010b = 10111011b
-10110011b | 10111011b = 10111011b
-10110011b | 10111100b = 10111111b
-10110011b | 10111101b = 10111111b
-10110011b | 10111110b = 10111111b
-10110011b | 10111111b = 10111111b
-10110011b | 11000000b = 11110011b
-10110011b | 11000001b = 11110011b
-10110011b | 11000010b = 11110011b
-10110011b | 11000011b = 11110011b
-10110011b | 11000100b = 11110111b
-10110011b | 11000101b = 11110111b
-10110011b | 11000110b = 11110111b
-10110011b | 11000111b = 11110111b
-10110011b | 11001000b = 11111011b
-10110011b | 11001001b = 11111011b
-10110011b | 11001010b = 11111011b
-10110011b | 11001011b = 11111011b
-10110011b | 11001100b = 11111111b
-10110011b | 11001101b = 11111111b
-10110011b | 11001110b = 11111111b
-10110011b | 11001111b = 11111111b
-10110011b | 11010000b = 11110011b
-10110011b | 11010001b = 11110011b
-10110011b | 11010010b = 11110011b
-10110011b | 11010011b = 11110011b
-10110011b | 11010100b = 11110111b
-10110011b | 11010101b = 11110111b
-10110011b | 11010110b = 11110111b
-10110011b | 11010111b = 11110111b
-10110011b | 11011000b = 11111011b
-10110011b | 11011001b = 11111011b
-10110011b | 11011010b = 11111011b
-10110011b | 11011011b = 11111011b
-10110011b | 11011100b = 11111111b
-10110011b | 11011101b = 11111111b
-10110011b | 11011110b = 11111111b
-10110011b | 11011111b = 11111111b
-10110011b | 11100000b = 11110011b
-10110011b | 11100001b = 11110011b
-10110011b | 11100010b = 11110011b
-10110011b | 11100011b = 11110011b
-10110011b | 11100100b = 11110111b
-10110011b | 11100101b = 11110111b
-10110011b | 11100110b = 11110111b
-10110011b | 11100111b = 11110111b
-10110011b | 11101000b = 11111011b
-10110011b | 11101001b = 11111011b
-10110011b | 11101010b = 11111011b
-10110011b | 11101011b = 11111011b
-10110011b | 11101100b = 11111111b
-10110011b | 11101101b = 11111111b
-10110011b | 11101110b = 11111111b
-10110011b | 11101111b = 11111111b
-10110011b | 11110000b = 11110011b
-10110011b | 11110001b = 11110011b
-10110011b | 11110010b = 11110011b
-10110011b | 11110011b = 11110011b
-10110011b | 11110100b = 11110111b
-10110011b | 11110101b = 11110111b
-10110011b | 11110110b = 11110111b
-10110011b | 11110111b = 11110111b
-10110011b | 11111000b = 11111011b
-10110011b | 11111001b = 11111011b
-10110011b | 11111010b = 11111011b
-10110011b | 11111011b = 11111011b
-10110011b | 11111100b = 11111111b
-10110011b | 11111101b = 11111111b
-10110011b | 11111110b = 11111111b
-10110011b | 11111111b = 11111111b
-10110011b | 00000000b = 10110011b
-10110011b | 00000001b = 10110011b
-10110011b | 00000010b = 10110011b
-10110011b | 00000011b = 10110011b
-10110011b | 00000100b = 10110111b
-10110011b | 00000101b = 10110111b
-10110011b | 00000110b = 10110111b
-10110011b | 00000111b = 10110111b
-10110011b | 00001000b = 10111011b
-10110011b | 00001001b = 10111011b
-10110011b | 00001010b = 10111011b
-10110011b | 00001011b = 10111011b
-10110011b | 00001100b = 10111111b
-10110011b | 00001101b = 10111111b
-10110011b | 00001110b = 10111111b
-10110011b | 00001111b = 10111111b
-10110011b | 00010000b = 10110011b
-10110011b | 00010001b = 10110011b
-10110011b | 00010010b = 10110011b
-10110011b | 00010011b = 10110011b
-10110011b | 00010100b = 10110111b
-10110011b | 00010101b = 10110111b
-10110011b | 00010110b = 10110111b
-10110011b | 00010111b = 10110111b
-10110011b | 00011000b = 10111011b
-10110011b | 00011001b = 10111011b
-10110011b | 00011010b = 10111011b
-10110011b | 00011011b = 10111011b
-10110011b | 00011100b = 10111111b
-10110011b | 00011101b = 10111111b
-10110011b | 00011110b = 10111111b
-10110011b | 00011111b = 10111111b
-10110011b | 00100000b = 10110011b
-10110011b | 00100001b = 10110011b
-10110011b | 00100010b = 10110011b
-10110011b | 00100011b = 10110011b
-10110011b | 00100100b = 10110111b
-10110011b | 00100101b = 10110111b
-10110011b | 00100110b = 10110111b
-10110011b | 00100111b = 10110111b
-10110011b | 00101000b = 10111011b
-10110011b | 00101001b = 10111011b
-10110011b | 00101010b = 10111011b
-10110011b | 00101011b = 10111011b
-10110011b | 00101100b = 10111111b
-10110011b | 00101101b = 10111111b
-10110011b | 00101110b = 10111111b
-10110011b | 00101111b = 10111111b
-10110011b | 00110000b = 10110011b
-10110011b | 00110001b = 10110011b
-10110011b | 00110010b = 10110011b
-10110011b | 00110011b = 10110011b
-10110011b | 00110100b = 10110111b
-10110011b | 00110101b = 10110111b
-10110011b | 00110110b = 10110111b
-10110011b | 00110111b = 10110111b
-10110011b | 00111000b = 10111011b
-10110011b | 00111001b = 10111011b
-10110011b | 00111010b = 10111011b
-10110011b | 00111011b = 10111011b
-10110011b | 00111100b = 10111111b
-10110011b | 00111101b = 10111111b
-10110011b | 00111110b = 10111111b
-10110011b | 00111111b = 10111111b
-10110011b | 01000000b = 11110011b
-10110011b | 01000001b = 11110011b
-10110011b | 01000010b = 11110011b
-10110011b | 01000011b = 11110011b
-10110011b | 01000100b = 11110111b
-10110011b | 01000101b = 11110111b
-10110011b | 01000110b = 11110111b
-10110011b | 01000111b = 11110111b
-10110011b | 01001000b = 11111011b
-10110011b | 01001001b = 11111011b
-10110011b | 01001010b = 11111011b
-10110011b | 01001011b = 11111011b
-10110011b | 01001100b = 11111111b
-10110011b | 01001101b = 11111111b
-10110011b | 01001110b = 11111111b
-10110011b | 01001111b = 11111111b
-10110011b | 01010000b = 11110011b
-10110011b | 01010001b = 11110011b
-10110011b | 01010010b = 11110011b
-10110011b | 01010011b = 11110011b
-10110011b | 01010100b = 11110111b
-10110011b | 01010101b = 11110111b
-10110011b | 01010110b = 11110111b
-10110011b | 01010111b = 11110111b
-10110011b | 01011000b = 11111011b
-10110011b | 01011001b = 11111011b
-10110011b | 01011010b = 11111011b
-10110011b | 01011011b = 11111011b
-10110011b | 01011100b = 11111111b
-10110011b | 01011101b = 11111111b
-10110011b | 01011110b = 11111111b
-10110011b | 01011111b = 11111111b
-10110011b | 01100000b = 11110011b
-10110011b | 01100001b = 11110011b
-10110011b | 01100010b = 11110011b
-10110011b | 01100011b = 11110011b
-10110011b | 01100100b = 11110111b
-10110011b | 01100101b = 11110111b
-10110011b | 01100110b = 11110111b
-10110011b | 01100111b = 11110111b
-10110011b | 01101000b = 11111011b
-10110011b | 01101001b = 11111011b
-10110011b | 01101010b = 11111011b
-10110011b | 01101011b = 11111011b
-10110011b | 01101100b = 11111111b
-10110011b | 01101101b = 11111111b
-10110011b | 01101110b = 11111111b
-10110011b | 01101111b = 11111111b
-10110011b | 01110000b = 11110011b
-10110011b | 01110001b = 11110011b
-10110011b | 01110010b = 11110011b
-10110011b | 01110011b = 11110011b
-10110011b | 01110100b = 11110111b
-10110011b | 01110101b = 11110111b
-10110011b | 01110110b = 11110111b
-10110011b | 01110111b = 11110111b
-10110011b | 01111000b = 11111011b
-10110011b | 01111001b = 11111011b
-10110011b | 01111010b = 11111011b
-10110011b | 01111011b = 11111011b
-10110011b | 01111100b = 11111111b
-10110011b | 01111101b = 11111111b
-10110011b | 01111110b = 11111111b
-10110100b | 10000000b = 10110100b
-10110100b | 10000001b = 10110101b
-10110100b | 10000010b = 10110110b
-10110100b | 10000011b = 10110111b
-10110100b | 10000100b = 10110100b
-10110100b | 10000101b = 10110101b
-10110100b | 10000110b = 10110110b
-10110100b | 10000111b = 10110111b
-10110100b | 10001000b = 10111100b
-10110100b | 10001001b = 10111101b
-10110100b | 10001010b = 10111110b
-10110100b | 10001011b = 10111111b
-10110100b | 10001100b = 10111100b
-10110100b | 10001101b = 10111101b
-10110100b | 10001110b = 10111110b
-10110100b | 10001111b = 10111111b
-10110100b | 10010000b = 10110100b
-10110100b | 10010001b = 10110101b
-10110100b | 10010010b = 10110110b
-10110100b | 10010011b = 10110111b
-10110100b | 10010100b = 10110100b
-10110100b | 10010101b = 10110101b
-10110100b | 10010110b = 10110110b
-10110100b | 10010111b = 10110111b
-10110100b | 10011000b = 10111100b
-10110100b | 10011001b = 10111101b
-10110100b | 10011010b = 10111110b
-10110100b | 10011011b = 10111111b
-10110100b | 10011100b = 10111100b
-10110100b | 10011101b = 10111101b
-10110100b | 10011110b = 10111110b
-10110100b | 10011111b = 10111111b
-10110100b | 10100000b = 10110100b
-10110100b | 10100001b = 10110101b
-10110100b | 10100010b = 10110110b
-10110100b | 10100011b = 10110111b
-10110100b | 10100100b = 10110100b
-10110100b | 10100101b = 10110101b
-10110100b | 10100110b = 10110110b
-10110100b | 10100111b = 10110111b
-10110100b | 10101000b = 10111100b
-10110100b | 10101001b = 10111101b
-10110100b | 10101010b = 10111110b
-10110100b | 10101011b = 10111111b
-10110100b | 10101100b = 10111100b
-10110100b | 10101101b = 10111101b
-10110100b | 10101110b = 10111110b
-10110100b | 10101111b = 10111111b
-10110100b | 10110000b = 10110100b
-10110100b | 10110001b = 10110101b
-10110100b | 10110010b = 10110110b
-10110100b | 10110011b = 10110111b
-10110100b | 10110100b = 10110100b
-10110100b | 10110101b = 10110101b
-10110100b | 10110110b = 10110110b
-10110100b | 10110111b = 10110111b
-10110100b | 10111000b = 10111100b
-10110100b | 10111001b = 10111101b
-10110100b | 10111010b = 10111110b
-10110100b | 10111011b = 10111111b
-10110100b | 10111100b = 10111100b
-10110100b | 10111101b = 10111101b
-10110100b | 10111110b = 10111110b
-10110100b | 10111111b = 10111111b
-10110100b | 11000000b = 11110100b
-10110100b | 11000001b = 11110101b
-10110100b | 11000010b = 11110110b
-10110100b | 11000011b = 11110111b
-10110100b | 11000100b = 11110100b
-10110100b | 11000101b = 11110101b
-10110100b | 11000110b = 11110110b
-10110100b | 11000111b = 11110111b
-10110100b | 11001000b = 11111100b
-10110100b | 11001001b = 11111101b
-10110100b | 11001010b = 11111110b
-10110100b | 11001011b = 11111111b
-10110100b | 11001100b = 11111100b
-10110100b | 11001101b = 11111101b
-10110100b | 11001110b = 11111110b
-10110100b | 11001111b = 11111111b
-10110100b | 11010000b = 11110100b
-10110100b | 11010001b = 11110101b
-10110100b | 11010010b = 11110110b
-10110100b | 11010011b = 11110111b
-10110100b | 11010100b = 11110100b
-10110100b | 11010101b = 11110101b
-10110100b | 11010110b = 11110110b
-10110100b | 11010111b = 11110111b
-10110100b | 11011000b = 11111100b
-10110100b | 11011001b = 11111101b
-10110100b | 11011010b = 11111110b
-10110100b | 11011011b = 11111111b
-10110100b | 11011100b = 11111100b
-10110100b | 11011101b = 11111101b
-10110100b | 11011110b = 11111110b
-10110100b | 11011111b = 11111111b
-10110100b | 11100000b = 11110100b
-10110100b | 11100001b = 11110101b
-10110100b | 11100010b = 11110110b
-10110100b | 11100011b = 11110111b
-10110100b | 11100100b = 11110100b
-10110100b | 11100101b = 11110101b
-10110100b | 11100110b = 11110110b
-10110100b | 11100111b = 11110111b
-10110100b | 11101000b = 11111100b
-10110100b | 11101001b = 11111101b
-10110100b | 11101010b = 11111110b
-10110100b | 11101011b = 11111111b
-10110100b | 11101100b = 11111100b
-10110100b | 11101101b = 11111101b
-10110100b | 11101110b = 11111110b
-10110100b | 11101111b = 11111111b
-10110100b | 11110000b = 11110100b
-10110100b | 11110001b = 11110101b
-10110100b | 11110010b = 11110110b
-10110100b | 11110011b = 11110111b
-10110100b | 11110100b = 11110100b
-10110100b | 11110101b = 11110101b
-10110100b | 11110110b = 11110110b
-10110100b | 11110111b = 11110111b
-10110100b | 11111000b = 11111100b
-10110100b | 11111001b = 11111101b
-10110100b | 11111010b = 11111110b
-10110100b | 11111011b = 11111111b
-10110100b | 11111100b = 11111100b
-10110100b | 11111101b = 11111101b
-10110100b | 11111110b = 11111110b
-10110100b | 11111111b = 11111111b
-10110100b | 00000000b = 10110100b
-10110100b | 00000001b = 10110101b
-10110100b | 00000010b = 10110110b
-10110100b | 00000011b = 10110111b
-10110100b | 00000100b = 10110100b
-10110100b | 00000101b = 10110101b
-10110100b | 00000110b = 10110110b
-10110100b | 00000111b = 10110111b
-10110100b | 00001000b = 10111100b
-10110100b | 00001001b = 10111101b
-10110100b | 00001010b = 10111110b
-10110100b | 00001011b = 10111111b
-10110100b | 00001100b = 10111100b
-10110100b | 00001101b = 10111101b
-10110100b | 00001110b = 10111110b
-10110100b | 00001111b = 10111111b
-10110100b | 00010000b = 10110100b
-10110100b | 00010001b = 10110101b
-10110100b | 00010010b = 10110110b
-10110100b | 00010011b = 10110111b
-10110100b | 00010100b = 10110100b
-10110100b | 00010101b = 10110101b
-10110100b | 00010110b = 10110110b
-10110100b | 00010111b = 10110111b
-10110100b | 00011000b = 10111100b
-10110100b | 00011001b = 10111101b
-10110100b | 00011010b = 10111110b
-10110100b | 00011011b = 10111111b
-10110100b | 00011100b = 10111100b
-10110100b | 00011101b = 10111101b
-10110100b | 00011110b = 10111110b
-10110100b | 00011111b = 10111111b
-10110100b | 00100000b = 10110100b
-10110100b | 00100001b = 10110101b
-10110100b | 00100010b = 10110110b
-10110100b | 00100011b = 10110111b
-10110100b | 00100100b = 10110100b
-10110100b | 00100101b = 10110101b
-10110100b | 00100110b = 10110110b
-10110100b | 00100111b = 10110111b
-10110100b | 00101000b = 10111100b
-10110100b | 00101001b = 10111101b
-10110100b | 00101010b = 10111110b
-10110100b | 00101011b = 10111111b
-10110100b | 00101100b = 10111100b
-10110100b | 00101101b = 10111101b
-10110100b | 00101110b = 10111110b
-10110100b | 00101111b = 10111111b
-10110100b | 00110000b = 10110100b
-10110100b | 00110001b = 10110101b
-10110100b | 00110010b = 10110110b
-10110100b | 00110011b = 10110111b
-10110100b | 00110100b = 10110100b
-10110100b | 00110101b = 10110101b
-10110100b | 00110110b = 10110110b
-10110100b | 00110111b = 10110111b
-10110100b | 00111000b = 10111100b
-10110100b | 00111001b = 10111101b
-10110100b | 00111010b = 10111110b
-10110100b | 00111011b = 10111111b
-10110100b | 00111100b = 10111100b
-10110100b | 00111101b = 10111101b
-10110100b | 00111110b = 10111110b
-10110100b | 00111111b = 10111111b
-10110100b | 01000000b = 11110100b
-10110100b | 01000001b = 11110101b
-10110100b | 01000010b = 11110110b
-10110100b | 01000011b = 11110111b
-10110100b | 01000100b = 11110100b
-10110100b | 01000101b = 11110101b
-10110100b | 01000110b = 11110110b
-10110100b | 01000111b = 11110111b
-10110100b | 01001000b = 11111100b
-10110100b | 01001001b = 11111101b
-10110100b | 01001010b = 11111110b
-10110100b | 01001011b = 11111111b
-10110100b | 01001100b = 11111100b
-10110100b | 01001101b = 11111101b
-10110100b | 01001110b = 11111110b
-10110100b | 01001111b = 11111111b
-10110100b | 01010000b = 11110100b
-10110100b | 01010001b = 11110101b
-10110100b | 01010010b = 11110110b
-10110100b | 01010011b = 11110111b
-10110100b | 01010100b = 11110100b
-10110100b | 01010101b = 11110101b
-10110100b | 01010110b = 11110110b
-10110100b | 01010111b = 11110111b
-10110100b | 01011000b = 11111100b
-10110100b | 01011001b = 11111101b
-10110100b | 01011010b = 11111110b
-10110100b | 01011011b = 11111111b
-10110100b | 01011100b = 11111100b
-10110100b | 01011101b = 11111101b
-10110100b | 01011110b = 11111110b
-10110100b | 01011111b = 11111111b
-10110100b | 01100000b = 11110100b
-10110100b | 01100001b = 11110101b
-10110100b | 01100010b = 11110110b
-10110100b | 01100011b = 11110111b
-10110100b | 01100100b = 11110100b
-10110100b | 01100101b = 11110101b
-10110100b | 01100110b = 11110110b
-10110100b | 01100111b = 11110111b
-10110100b | 01101000b = 11111100b
-10110100b | 01101001b = 11111101b
-10110100b | 01101010b = 11111110b
-10110100b | 01101011b = 11111111b
-10110100b | 01101100b = 11111100b
-10110100b | 01101101b = 11111101b
-10110100b | 01101110b = 11111110b
-10110100b | 01101111b = 11111111b
-10110100b | 01110000b = 11110100b
-10110100b | 01110001b = 11110101b
-10110100b | 01110010b = 11110110b
-10110100b | 01110011b = 11110111b
-10110100b | 01110100b = 11110100b
-10110100b | 01110101b = 11110101b
-10110100b | 01110110b = 11110110b
-10110100b | 01110111b = 11110111b
-10110100b | 01111000b = 11111100b
-10110100b | 01111001b = 11111101b
-10110100b | 01111010b = 11111110b
-10110100b | 01111011b = 11111111b
-10110100b | 01111100b = 11111100b
-10110100b | 01111101b = 11111101b
-10110100b | 01111110b = 11111110b
-10110101b | 10000000b = 10110101b
-10110101b | 10000001b = 10110101b
-10110101b | 10000010b = 10110111b
-10110101b | 10000011b = 10110111b
-10110101b | 10000100b = 10110101b
-10110101b | 10000101b = 10110101b
-10110101b | 10000110b = 10110111b
-10110101b | 10000111b = 10110111b
-10110101b | 10001000b = 10111101b
-10110101b | 10001001b = 10111101b
-10110101b | 10001010b = 10111111b
-10110101b | 10001011b = 10111111b
-10110101b | 10001100b = 10111101b
-10110101b | 10001101b = 10111101b
-10110101b | 10001110b = 10111111b
-10110101b | 10001111b = 10111111b
-10110101b | 10010000b = 10110101b
-10110101b | 10010001b = 10110101b
-10110101b | 10010010b = 10110111b
-10110101b | 10010011b = 10110111b
-10110101b | 10010100b = 10110101b
-10110101b | 10010101b = 10110101b
-10110101b | 10010110b = 10110111b
-10110101b | 10010111b = 10110111b
-10110101b | 10011000b = 10111101b
-10110101b | 10011001b = 10111101b
-10110101b | 10011010b = 10111111b
-10110101b | 10011011b = 10111111b
-10110101b | 10011100b = 10111101b
-10110101b | 10011101b = 10111101b
-10110101b | 10011110b = 10111111b
-10110101b | 10011111b = 10111111b
-10110101b | 10100000b = 10110101b
-10110101b | 10100001b = 10110101b
-10110101b | 10100010b = 10110111b
-10110101b | 10100011b = 10110111b
-10110101b | 10100100b = 10110101b
-10110101b | 10100101b = 10110101b
-10110101b | 10100110b = 10110111b
-10110101b | 10100111b = 10110111b
-10110101b | 10101000b = 10111101b
-10110101b | 10101001b = 10111101b
-10110101b | 10101010b = 10111111b
-10110101b | 10101011b = 10111111b
-10110101b | 10101100b = 10111101b
-10110101b | 10101101b = 10111101b
-10110101b | 10101110b = 10111111b
-10110101b | 10101111b = 10111111b
-10110101b | 10110000b = 10110101b
-10110101b | 10110001b = 10110101b
-10110101b | 10110010b = 10110111b
-10110101b | 10110011b = 10110111b
-10110101b | 10110100b = 10110101b
-10110101b | 10110101b = 10110101b
-10110101b | 10110110b = 10110111b
-10110101b | 10110111b = 10110111b
-10110101b | 10111000b = 10111101b
-10110101b | 10111001b = 10111101b
-10110101b | 10111010b = 10111111b
-10110101b | 10111011b = 10111111b
-10110101b | 10111100b = 10111101b
-10110101b | 10111101b = 10111101b
-10110101b | 10111110b = 10111111b
-10110101b | 10111111b = 10111111b
-10110101b | 11000000b = 11110101b
-10110101b | 11000001b = 11110101b
-10110101b | 11000010b = 11110111b
-10110101b | 11000011b = 11110111b
-10110101b | 11000100b = 11110101b
-10110101b | 11000101b = 11110101b
-10110101b | 11000110b = 11110111b
-10110101b | 11000111b = 11110111b
-10110101b | 11001000b = 11111101b
-10110101b | 11001001b = 11111101b
-10110101b | 11001010b = 11111111b
-10110101b | 11001011b = 11111111b
-10110101b | 11001100b = 11111101b
-10110101b | 11001101b = 11111101b
-10110101b | 11001110b = 11111111b
-10110101b | 11001111b = 11111111b
-10110101b | 11010000b = 11110101b
-10110101b | 11010001b = 11110101b
-10110101b | 11010010b = 11110111b
-10110101b | 11010011b = 11110111b
-10110101b | 11010100b = 11110101b
-10110101b | 11010101b = 11110101b
-10110101b | 11010110b = 11110111b
-10110101b | 11010111b = 11110111b
-10110101b | 11011000b = 11111101b
-10110101b | 11011001b = 11111101b
-10110101b | 11011010b = 11111111b
-10110101b | 11011011b = 11111111b
-10110101b | 11011100b = 11111101b
-10110101b | 11011101b = 11111101b
-10110101b | 11011110b = 11111111b
-10110101b | 11011111b = 11111111b
-10110101b | 11100000b = 11110101b
-10110101b | 11100001b = 11110101b
-10110101b | 11100010b = 11110111b
-10110101b | 11100011b = 11110111b
-10110101b | 11100100b = 11110101b
-10110101b | 11100101b = 11110101b
-10110101b | 11100110b = 11110111b
-10110101b | 11100111b = 11110111b
-10110101b | 11101000b = 11111101b
-10110101b | 11101001b = 11111101b
-10110101b | 11101010b = 11111111b
-10110101b | 11101011b = 11111111b
-10110101b | 11101100b = 11111101b
-10110101b | 11101101b = 11111101b
-10110101b | 11101110b = 11111111b
-10110101b | 11101111b = 11111111b
-10110101b | 11110000b = 11110101b
-10110101b | 11110001b = 11110101b
-10110101b | 11110010b = 11110111b
-10110101b | 11110011b = 11110111b
-10110101b | 11110100b = 11110101b
-10110101b | 11110101b = 11110101b
-10110101b | 11110110b = 11110111b
-10110101b | 11110111b = 11110111b
-10110101b | 11111000b = 11111101b
-10110101b | 11111001b = 11111101b
-10110101b | 11111010b = 11111111b
-10110101b | 11111011b = 11111111b
-10110101b | 11111100b = 11111101b
-10110101b | 11111101b = 11111101b
-10110101b | 11111110b = 11111111b
-10110101b | 11111111b = 11111111b
-10110101b | 00000000b = 10110101b
-10110101b | 00000001b = 10110101b
-10110101b | 00000010b = 10110111b
-10110101b | 00000011b = 10110111b
-10110101b | 00000100b = 10110101b
-10110101b | 00000101b = 10110101b
-10110101b | 00000110b = 10110111b
-10110101b | 00000111b = 10110111b
-10110101b | 00001000b = 10111101b
-10110101b | 00001001b = 10111101b
-10110101b | 00001010b = 10111111b
-10110101b | 00001011b = 10111111b
-10110101b | 00001100b = 10111101b
-10110101b | 00001101b = 10111101b
-10110101b | 00001110b = 10111111b
-10110101b | 00001111b = 10111111b
-10110101b | 00010000b = 10110101b
-10110101b | 00010001b = 10110101b
-10110101b | 00010010b = 10110111b
-10110101b | 00010011b = 10110111b
-10110101b | 00010100b = 10110101b
-10110101b | 00010101b = 10110101b
-10110101b | 00010110b = 10110111b
-10110101b | 00010111b = 10110111b
-10110101b | 00011000b = 10111101b
-10110101b | 00011001b = 10111101b
-10110101b | 00011010b = 10111111b
-10110101b | 00011011b = 10111111b
-10110101b | 00011100b = 10111101b
-10110101b | 00011101b = 10111101b
-10110101b | 00011110b = 10111111b
-10110101b | 00011111b = 10111111b
-10110101b | 00100000b = 10110101b
-10110101b | 00100001b = 10110101b
-10110101b | 00100010b = 10110111b
-10110101b | 00100011b = 10110111b
-10110101b | 00100100b = 10110101b
-10110101b | 00100101b = 10110101b
-10110101b | 00100110b = 10110111b
-10110101b | 00100111b = 10110111b
-10110101b | 00101000b = 10111101b
-10110101b | 00101001b = 10111101b
-10110101b | 00101010b = 10111111b
-10110101b | 00101011b = 10111111b
-10110101b | 00101100b = 10111101b
-10110101b | 00101101b = 10111101b
-10110101b | 00101110b = 10111111b
-10110101b | 00101111b = 10111111b
-10110101b | 00110000b = 10110101b
-10110101b | 00110001b = 10110101b
-10110101b | 00110010b = 10110111b
-10110101b | 00110011b = 10110111b
-10110101b | 00110100b = 10110101b
-10110101b | 00110101b = 10110101b
-10110101b | 00110110b = 10110111b
-10110101b | 00110111b = 10110111b
-10110101b | 00111000b = 10111101b
-10110101b | 00111001b = 10111101b
-10110101b | 00111010b = 10111111b
-10110101b | 00111011b = 10111111b
-10110101b | 00111100b = 10111101b
-10110101b | 00111101b = 10111101b
-10110101b | 00111110b = 10111111b
-10110101b | 00111111b = 10111111b
-10110101b | 01000000b = 11110101b
-10110101b | 01000001b = 11110101b
-10110101b | 01000010b = 11110111b
-10110101b | 01000011b = 11110111b
-10110101b | 01000100b = 11110101b
-10110101b | 01000101b = 11110101b
-10110101b | 01000110b = 11110111b
-10110101b | 01000111b = 11110111b
-10110101b | 01001000b = 11111101b
-10110101b | 01001001b = 11111101b
-10110101b | 01001010b = 11111111b
-10110101b | 01001011b = 11111111b
-10110101b | 01001100b = 11111101b
-10110101b | 01001101b = 11111101b
-10110101b | 01001110b = 11111111b
-10110101b | 01001111b = 11111111b
-10110101b | 01010000b = 11110101b
-10110101b | 01010001b = 11110101b
-10110101b | 01010010b = 11110111b
-10110101b | 01010011b = 11110111b
-10110101b | 01010100b = 11110101b
-10110101b | 01010101b = 11110101b
-10110101b | 01010110b = 11110111b
-10110101b | 01010111b = 11110111b
-10110101b | 01011000b = 11111101b
-10110101b | 01011001b = 11111101b
-10110101b | 01011010b = 11111111b
-10110101b | 01011011b = 11111111b
-10110101b | 01011100b = 11111101b
-10110101b | 01011101b = 11111101b
-10110101b | 01011110b = 11111111b
-10110101b | 01011111b = 11111111b
-10110101b | 01100000b = 11110101b
-10110101b | 01100001b = 11110101b
-10110101b | 01100010b = 11110111b
-10110101b | 01100011b = 11110111b
-10110101b | 01100100b = 11110101b
-10110101b | 01100101b = 11110101b
-10110101b | 01100110b = 11110111b
-10110101b | 01100111b = 11110111b
-10110101b | 01101000b = 11111101b
-10110101b | 01101001b = 11111101b
-10110101b | 01101010b = 11111111b
-10110101b | 01101011b = 11111111b
-10110101b | 01101100b = 11111101b
-10110101b | 01101101b = 11111101b
-10110101b | 01101110b = 11111111b
-10110101b | 01101111b = 11111111b
-10110101b | 01110000b = 11110101b
-10110101b | 01110001b = 11110101b
-10110101b | 01110010b = 11110111b
-10110101b | 01110011b = 11110111b
-10110101b | 01110100b = 11110101b
-10110101b | 01110101b = 11110101b
-10110101b | 01110110b = 11110111b
-10110101b | 01110111b = 11110111b
-10110101b | 01111000b = 11111101b
-10110101b | 01111001b = 11111101b
-10110101b | 01111010b = 11111111b
-10110101b | 01111011b = 11111111b
-10110101b | 01111100b = 11111101b
-10110101b | 01111101b = 11111101b
-10110101b | 01111110b = 11111111b
-10110110b | 10000000b = 10110110b
-10110110b | 10000001b = 10110111b
-10110110b | 10000010b = 10110110b
-10110110b | 10000011b = 10110111b
-10110110b | 10000100b = 10110110b
-10110110b | 10000101b = 10110111b
-10110110b | 10000110b = 10110110b
-10110110b | 10000111b = 10110111b
-10110110b | 10001000b = 10111110b
-10110110b | 10001001b = 10111111b
-10110110b | 10001010b = 10111110b
-10110110b | 10001011b = 10111111b
-10110110b | 10001100b = 10111110b
-10110110b | 10001101b = 10111111b
-10110110b | 10001110b = 10111110b
-10110110b | 10001111b = 10111111b
-10110110b | 10010000b = 10110110b
-10110110b | 10010001b = 10110111b
-10110110b | 10010010b = 10110110b
-10110110b | 10010011b = 10110111b
-10110110b | 10010100b = 10110110b
-10110110b | 10010101b = 10110111b
-10110110b | 10010110b = 10110110b
-10110110b | 10010111b = 10110111b
-10110110b | 10011000b = 10111110b
-10110110b | 10011001b = 10111111b
-10110110b | 10011010b = 10111110b
-10110110b | 10011011b = 10111111b
-10110110b | 10011100b = 10111110b
-10110110b | 10011101b = 10111111b
-10110110b | 10011110b = 10111110b
-10110110b | 10011111b = 10111111b
-10110110b | 10100000b = 10110110b
-10110110b | 10100001b = 10110111b
-10110110b | 10100010b = 10110110b
-10110110b | 10100011b = 10110111b
-10110110b | 10100100b = 10110110b
-10110110b | 10100101b = 10110111b
-10110110b | 10100110b = 10110110b
-10110110b | 10100111b = 10110111b
-10110110b | 10101000b = 10111110b
-10110110b | 10101001b = 10111111b
-10110110b | 10101010b = 10111110b
-10110110b | 10101011b = 10111111b
-10110110b | 10101100b = 10111110b
-10110110b | 10101101b = 10111111b
-10110110b | 10101110b = 10111110b
-10110110b | 10101111b = 10111111b
-10110110b | 10110000b = 10110110b
-10110110b | 10110001b = 10110111b
-10110110b | 10110010b = 10110110b
-10110110b | 10110011b = 10110111b
-10110110b | 10110100b = 10110110b
-10110110b | 10110101b = 10110111b
-10110110b | 10110110b = 10110110b
-10110110b | 10110111b = 10110111b
-10110110b | 10111000b = 10111110b
-10110110b | 10111001b = 10111111b
-10110110b | 10111010b = 10111110b
-10110110b | 10111011b = 10111111b
-10110110b | 10111100b = 10111110b
-10110110b | 10111101b = 10111111b
-10110110b | 10111110b = 10111110b
-10110110b | 10111111b = 10111111b
-10110110b | 11000000b = 11110110b
-10110110b | 11000001b = 11110111b
-10110110b | 11000010b = 11110110b
-10110110b | 11000011b = 11110111b
-10110110b | 11000100b = 11110110b
-10110110b | 11000101b = 11110111b
-10110110b | 11000110b = 11110110b
-10110110b | 11000111b = 11110111b
-10110110b | 11001000b = 11111110b
-10110110b | 11001001b = 11111111b
-10110110b | 11001010b = 11111110b
-10110110b | 11001011b = 11111111b
-10110110b | 11001100b = 11111110b
-10110110b | 11001101b = 11111111b
-10110110b | 11001110b = 11111110b
-10110110b | 11001111b = 11111111b
-10110110b | 11010000b = 11110110b
-10110110b | 11010001b = 11110111b
-10110110b | 11010010b = 11110110b
-10110110b | 11010011b = 11110111b
-10110110b | 11010100b = 11110110b
-10110110b | 11010101b = 11110111b
-10110110b | 11010110b = 11110110b
-10110110b | 11010111b = 11110111b
-10110110b | 11011000b = 11111110b
-10110110b | 11011001b = 11111111b
-10110110b | 11011010b = 11111110b
-10110110b | 11011011b = 11111111b
-10110110b | 11011100b = 11111110b
-10110110b | 11011101b = 11111111b
-10110110b | 11011110b = 11111110b
-10110110b | 11011111b = 11111111b
-10110110b | 11100000b = 11110110b
-10110110b | 11100001b = 11110111b
-10110110b | 11100010b = 11110110b
-10110110b | 11100011b = 11110111b
-10110110b | 11100100b = 11110110b
-10110110b | 11100101b = 11110111b
-10110110b | 11100110b = 11110110b
-10110110b | 11100111b = 11110111b
-10110110b | 11101000b = 11111110b
-10110110b | 11101001b = 11111111b
-10110110b | 11101010b = 11111110b
-10110110b | 11101011b = 11111111b
-10110110b | 11101100b = 11111110b
-10110110b | 11101101b = 11111111b
-10110110b | 11101110b = 11111110b
-10110110b | 11101111b = 11111111b
-10110110b | 11110000b = 11110110b
-10110110b | 11110001b = 11110111b
-10110110b | 11110010b = 11110110b
-10110110b | 11110011b = 11110111b
-10110110b | 11110100b = 11110110b
-10110110b | 11110101b = 11110111b
-10110110b | 11110110b = 11110110b
-10110110b | 11110111b = 11110111b
-10110110b | 11111000b = 11111110b
-10110110b | 11111001b = 11111111b
-10110110b | 11111010b = 11111110b
-10110110b | 11111011b = 11111111b
-10110110b | 11111100b = 11111110b
-10110110b | 11111101b = 11111111b
-10110110b | 11111110b = 11111110b
-10110110b | 11111111b = 11111111b
-10110110b | 00000000b = 10110110b
-10110110b | 00000001b = 10110111b
-10110110b | 00000010b = 10110110b
-10110110b | 00000011b = 10110111b
-10110110b | 00000100b = 10110110b
-10110110b | 00000101b = 10110111b
-10110110b | 00000110b = 10110110b
-10110110b | 00000111b = 10110111b
-10110110b | 00001000b = 10111110b
-10110110b | 00001001b = 10111111b
-10110110b | 00001010b = 10111110b
-10110110b | 00001011b = 10111111b
-10110110b | 00001100b = 10111110b
-10110110b | 00001101b = 10111111b
-10110110b | 00001110b = 10111110b
-10110110b | 00001111b = 10111111b
-10110110b | 00010000b = 10110110b
-10110110b | 00010001b = 10110111b
-10110110b | 00010010b = 10110110b
-10110110b | 00010011b = 10110111b
-10110110b | 00010100b = 10110110b
-10110110b | 00010101b = 10110111b
-10110110b | 00010110b = 10110110b
-10110110b | 00010111b = 10110111b
-10110110b | 00011000b = 10111110b
-10110110b | 00011001b = 10111111b
-10110110b | 00011010b = 10111110b
-10110110b | 00011011b = 10111111b
-10110110b | 00011100b = 10111110b
-10110110b | 00011101b = 10111111b
-10110110b | 00011110b = 10111110b
-10110110b | 00011111b = 10111111b
-10110110b | 00100000b = 10110110b
-10110110b | 00100001b = 10110111b
-10110110b | 00100010b = 10110110b
-10110110b | 00100011b = 10110111b
-10110110b | 00100100b = 10110110b
-10110110b | 00100101b = 10110111b
-10110110b | 00100110b = 10110110b
-10110110b | 00100111b = 10110111b
-10110110b | 00101000b = 10111110b
-10110110b | 00101001b = 10111111b
-10110110b | 00101010b = 10111110b
-10110110b | 00101011b = 10111111b
-10110110b | 00101100b = 10111110b
-10110110b | 00101101b = 10111111b
-10110110b | 00101110b = 10111110b
-10110110b | 00101111b = 10111111b
-10110110b | 00110000b = 10110110b
-10110110b | 00110001b = 10110111b
-10110110b | 00110010b = 10110110b
-10110110b | 00110011b = 10110111b
-10110110b | 00110100b = 10110110b
-10110110b | 00110101b = 10110111b
-10110110b | 00110110b = 10110110b
-10110110b | 00110111b = 10110111b
-10110110b | 00111000b = 10111110b
-10110110b | 00111001b = 10111111b
-10110110b | 00111010b = 10111110b
-10110110b | 00111011b = 10111111b
-10110110b | 00111100b = 10111110b
-10110110b | 00111101b = 10111111b
-10110110b | 00111110b = 10111110b
-10110110b | 00111111b = 10111111b
-10110110b | 01000000b = 11110110b
-10110110b | 01000001b = 11110111b
-10110110b | 01000010b = 11110110b
-10110110b | 01000011b = 11110111b
-10110110b | 01000100b = 11110110b
-10110110b | 01000101b = 11110111b
-10110110b | 01000110b = 11110110b
-10110110b | 01000111b = 11110111b
-10110110b | 01001000b = 11111110b
-10110110b | 01001001b = 11111111b
-10110110b | 01001010b = 11111110b
-10110110b | 01001011b = 11111111b
-10110110b | 01001100b = 11111110b
-10110110b | 01001101b = 11111111b
-10110110b | 01001110b = 11111110b
-10110110b | 01001111b = 11111111b
-10110110b | 01010000b = 11110110b
-10110110b | 01010001b = 11110111b
-10110110b | 01010010b = 11110110b
-10110110b | 01010011b = 11110111b
-10110110b | 01010100b = 11110110b
-10110110b | 01010101b = 11110111b
-10110110b | 01010110b = 11110110b
-10110110b | 01010111b = 11110111b
-10110110b | 01011000b = 11111110b
-10110110b | 01011001b = 11111111b
-10110110b | 01011010b = 11111110b
-10110110b | 01011011b = 11111111b
-10110110b | 01011100b = 11111110b
-10110110b | 01011101b = 11111111b
-10110110b | 01011110b = 11111110b
-10110110b | 01011111b = 11111111b
-10110110b | 01100000b = 11110110b
-10110110b | 01100001b = 11110111b
-10110110b | 01100010b = 11110110b
-10110110b | 01100011b = 11110111b
-10110110b | 01100100b = 11110110b
-10110110b | 01100101b = 11110111b
-10110110b | 01100110b = 11110110b
-10110110b | 01100111b = 11110111b
-10110110b | 01101000b = 11111110b
-10110110b | 01101001b = 11111111b
-10110110b | 01101010b = 11111110b
-10110110b | 01101011b = 11111111b
-10110110b | 01101100b = 11111110b
-10110110b | 01101101b = 11111111b
-10110110b | 01101110b = 11111110b
-10110110b | 01101111b = 11111111b
-10110110b | 01110000b = 11110110b
-10110110b | 01110001b = 11110111b
-10110110b | 01110010b = 11110110b
-10110110b | 01110011b = 11110111b
-10110110b | 01110100b = 11110110b
-10110110b | 01110101b = 11110111b
-10110110b | 01110110b = 11110110b
-10110110b | 01110111b = 11110111b
-10110110b | 01111000b = 11111110b
-10110110b | 01111001b = 11111111b
-10110110b | 01111010b = 11111110b
-10110110b | 01111011b = 11111111b
-10110110b | 01111100b = 11111110b
-10110110b | 01111101b = 11111111b
-10110110b | 01111110b = 11111110b
-10110111b | 10000000b = 10110111b
-10110111b | 10000001b = 10110111b
-10110111b | 10000010b = 10110111b
-10110111b | 10000011b = 10110111b
-10110111b | 10000100b = 10110111b
-10110111b | 10000101b = 10110111b
-10110111b | 10000110b = 10110111b
-10110111b | 10000111b = 10110111b
-10110111b | 10001000b = 10111111b
-10110111b | 10001001b = 10111111b
-10110111b | 10001010b = 10111111b
-10110111b | 10001011b = 10111111b
-10110111b | 10001100b = 10111111b
-10110111b | 10001101b = 10111111b
-10110111b | 10001110b = 10111111b
-10110111b | 10001111b = 10111111b
-10110111b | 10010000b = 10110111b
-10110111b | 10010001b = 10110111b
-10110111b | 10010010b = 10110111b
-10110111b | 10010011b = 10110111b
-10110111b | 10010100b = 10110111b
-10110111b | 10010101b = 10110111b
-10110111b | 10010110b = 10110111b
-10110111b | 10010111b = 10110111b
-10110111b | 10011000b = 10111111b
-10110111b | 10011001b = 10111111b
-10110111b | 10011010b = 10111111b
-10110111b | 10011011b = 10111111b
-10110111b | 10011100b = 10111111b
-10110111b | 10011101b = 10111111b
-10110111b | 10011110b = 10111111b
-10110111b | 10011111b = 10111111b
-10110111b | 10100000b = 10110111b
-10110111b | 10100001b = 10110111b
-10110111b | 10100010b = 10110111b
-10110111b | 10100011b = 10110111b
-10110111b | 10100100b = 10110111b
-10110111b | 10100101b = 10110111b
-10110111b | 10100110b = 10110111b
-10110111b | 10100111b = 10110111b
-10110111b | 10101000b = 10111111b
-10110111b | 10101001b = 10111111b
-10110111b | 10101010b = 10111111b
-10110111b | 10101011b = 10111111b
-10110111b | 10101100b = 10111111b
-10110111b | 10101101b = 10111111b
-10110111b | 10101110b = 10111111b
-10110111b | 10101111b = 10111111b
-10110111b | 10110000b = 10110111b
-10110111b | 10110001b = 10110111b
-10110111b | 10110010b = 10110111b
-10110111b | 10110011b = 10110111b
-10110111b | 10110100b = 10110111b
-10110111b | 10110101b = 10110111b
-10110111b | 10110110b = 10110111b
-10110111b | 10110111b = 10110111b
-10110111b | 10111000b = 10111111b
-10110111b | 10111001b = 10111111b
-10110111b | 10111010b = 10111111b
-10110111b | 10111011b = 10111111b
-10110111b | 10111100b = 10111111b
-10110111b | 10111101b = 10111111b
-10110111b | 10111110b = 10111111b
-10110111b | 10111111b = 10111111b
-10110111b | 11000000b = 11110111b
-10110111b | 11000001b = 11110111b
-10110111b | 11000010b = 11110111b
-10110111b | 11000011b = 11110111b
-10110111b | 11000100b = 11110111b
-10110111b | 11000101b = 11110111b
-10110111b | 11000110b = 11110111b
-10110111b | 11000111b = 11110111b
-10110111b | 11001000b = 11111111b
-10110111b | 11001001b = 11111111b
-10110111b | 11001010b = 11111111b
-10110111b | 11001011b = 11111111b
-10110111b | 11001100b = 11111111b
-10110111b | 11001101b = 11111111b
-10110111b | 11001110b = 11111111b
-10110111b | 11001111b = 11111111b
-10110111b | 11010000b = 11110111b
-10110111b | 11010001b = 11110111b
-10110111b | 11010010b = 11110111b
-10110111b | 11010011b = 11110111b
-10110111b | 11010100b = 11110111b
-10110111b | 11010101b = 11110111b
-10110111b | 11010110b = 11110111b
-10110111b | 11010111b = 11110111b
-10110111b | 11011000b = 11111111b
-10110111b | 11011001b = 11111111b
-10110111b | 11011010b = 11111111b
-10110111b | 11011011b = 11111111b
-10110111b | 11011100b = 11111111b
-10110111b | 11011101b = 11111111b
-10110111b | 11011110b = 11111111b
-10110111b | 11011111b = 11111111b
-10110111b | 11100000b = 11110111b
-10110111b | 11100001b = 11110111b
-10110111b | 11100010b = 11110111b
-10110111b | 11100011b = 11110111b
-10110111b | 11100100b = 11110111b
-10110111b | 11100101b = 11110111b
-10110111b | 11100110b = 11110111b
-10110111b | 11100111b = 11110111b
-10110111b | 11101000b = 11111111b
-10110111b | 11101001b = 11111111b
-10110111b | 11101010b = 11111111b
-10110111b | 11101011b = 11111111b
-10110111b | 11101100b = 11111111b
-10110111b | 11101101b = 11111111b
-10110111b | 11101110b = 11111111b
-10110111b | 11101111b = 11111111b
-10110111b | 11110000b = 11110111b
-10110111b | 11110001b = 11110111b
-10110111b | 11110010b = 11110111b
-10110111b | 11110011b = 11110111b
-10110111b | 11110100b = 11110111b
-10110111b | 11110101b = 11110111b
-10110111b | 11110110b = 11110111b
-10110111b | 11110111b = 11110111b
-10110111b | 11111000b = 11111111b
-10110111b | 11111001b = 11111111b
-10110111b | 11111010b = 11111111b
-10110111b | 11111011b = 11111111b
-10110111b | 11111100b = 11111111b
-10110111b | 11111101b = 11111111b
-10110111b | 11111110b = 11111111b
-10110111b | 11111111b = 11111111b
-10110111b | 00000000b = 10110111b
-10110111b | 00000001b = 10110111b
-10110111b | 00000010b = 10110111b
-10110111b | 00000011b = 10110111b
-10110111b | 00000100b = 10110111b
-10110111b | 00000101b = 10110111b
-10110111b | 00000110b = 10110111b
-10110111b | 00000111b = 10110111b
-10110111b | 00001000b = 10111111b
-10110111b | 00001001b = 10111111b
-10110111b | 00001010b = 10111111b
-10110111b | 00001011b = 10111111b
-10110111b | 00001100b = 10111111b
-10110111b | 00001101b = 10111111b
-10110111b | 00001110b = 10111111b
-10110111b | 00001111b = 10111111b
-10110111b | 00010000b = 10110111b
-10110111b | 00010001b = 10110111b
-10110111b | 00010010b = 10110111b
-10110111b | 00010011b = 10110111b
-10110111b | 00010100b = 10110111b
-10110111b | 00010101b = 10110111b
-10110111b | 00010110b = 10110111b
-10110111b | 00010111b = 10110111b
-10110111b | 00011000b = 10111111b
-10110111b | 00011001b = 10111111b
-10110111b | 00011010b = 10111111b
-10110111b | 00011011b = 10111111b
-10110111b | 00011100b = 10111111b
-10110111b | 00011101b = 10111111b
-10110111b | 00011110b = 10111111b
-10110111b | 00011111b = 10111111b
-10110111b | 00100000b = 10110111b
-10110111b | 00100001b = 10110111b
-10110111b | 00100010b = 10110111b
-10110111b | 00100011b = 10110111b
-10110111b | 00100100b = 10110111b
-10110111b | 00100101b = 10110111b
-10110111b | 00100110b = 10110111b
-10110111b | 00100111b = 10110111b
-10110111b | 00101000b = 10111111b
-10110111b | 00101001b = 10111111b
-10110111b | 00101010b = 10111111b
-10110111b | 00101011b = 10111111b
-10110111b | 00101100b = 10111111b
-10110111b | 00101101b = 10111111b
-10110111b | 00101110b = 10111111b
-10110111b | 00101111b = 10111111b
-10110111b | 00110000b = 10110111b
-10110111b | 00110001b = 10110111b
-10110111b | 00110010b = 10110111b
-10110111b | 00110011b = 10110111b
-10110111b | 00110100b = 10110111b
-10110111b | 00110101b = 10110111b
-10110111b | 00110110b = 10110111b
-10110111b | 00110111b = 10110111b
-10110111b | 00111000b = 10111111b
-10110111b | 00111001b = 10111111b
-10110111b | 00111010b = 10111111b
-10110111b | 00111011b = 10111111b
-10110111b | 00111100b = 10111111b
-10110111b | 00111101b = 10111111b
-10110111b | 00111110b = 10111111b
-10110111b | 00111111b = 10111111b
-10110111b | 01000000b = 11110111b
-10110111b | 01000001b = 11110111b
-10110111b | 01000010b = 11110111b
-10110111b | 01000011b = 11110111b
-10110111b | 01000100b = 11110111b
-10110111b | 01000101b = 11110111b
-10110111b | 01000110b = 11110111b
-10110111b | 01000111b = 11110111b
-10110111b | 01001000b = 11111111b
-10110111b | 01001001b = 11111111b
-10110111b | 01001010b = 11111111b
-10110111b | 01001011b = 11111111b
-10110111b | 01001100b = 11111111b
-10110111b | 01001101b = 11111111b
-10110111b | 01001110b = 11111111b
-10110111b | 01001111b = 11111111b
-10110111b | 01010000b = 11110111b
-10110111b | 01010001b = 11110111b
-10110111b | 01010010b = 11110111b
-10110111b | 01010011b = 11110111b
-10110111b | 01010100b = 11110111b
-10110111b | 01010101b = 11110111b
-10110111b | 01010110b = 11110111b
-10110111b | 01010111b = 11110111b
-10110111b | 01011000b = 11111111b
-10110111b | 01011001b = 11111111b
-10110111b | 01011010b = 11111111b
-10110111b | 01011011b = 11111111b
-10110111b | 01011100b = 11111111b
-10110111b | 01011101b = 11111111b
-10110111b | 01011110b = 11111111b
-10110111b | 01011111b = 11111111b
-10110111b | 01100000b = 11110111b
-10110111b | 01100001b = 11110111b
-10110111b | 01100010b = 11110111b
-10110111b | 01100011b = 11110111b
-10110111b | 01100100b = 11110111b
-10110111b | 01100101b = 11110111b
-10110111b | 01100110b = 11110111b
-10110111b | 01100111b = 11110111b
-10110111b | 01101000b = 11111111b
-10110111b | 01101001b = 11111111b
-10110111b | 01101010b = 11111111b
-10110111b | 01101011b = 11111111b
-10110111b | 01101100b = 11111111b
-10110111b | 01101101b = 11111111b
-10110111b | 01101110b = 11111111b
-10110111b | 01101111b = 11111111b
-10110111b | 01110000b = 11110111b
-10110111b | 01110001b = 11110111b
-10110111b | 01110010b = 11110111b
-10110111b | 01110011b = 11110111b
-10110111b | 01110100b = 11110111b
-10110111b | 01110101b = 11110111b
-10110111b | 01110110b = 11110111b
-10110111b | 01110111b = 11110111b
-10110111b | 01111000b = 11111111b
-10110111b | 01111001b = 11111111b
-10110111b | 01111010b = 11111111b
-10110111b | 01111011b = 11111111b
-10110111b | 01111100b = 11111111b
-10110111b | 01111101b = 11111111b
-10110111b | 01111110b = 11111111b
-10111000b | 10000000b = 10111000b
-10111000b | 10000001b = 10111001b
-10111000b | 10000010b = 10111010b
-10111000b | 10000011b = 10111011b
-10111000b | 10000100b = 10111100b
-10111000b | 10000101b = 10111101b
-10111000b | 10000110b = 10111110b
-10111000b | 10000111b = 10111111b
-10111000b | 10001000b = 10111000b
-10111000b | 10001001b = 10111001b
-10111000b | 10001010b = 10111010b
-10111000b | 10001011b = 10111011b
-10111000b | 10001100b = 10111100b
-10111000b | 10001101b = 10111101b
-10111000b | 10001110b = 10111110b
-10111000b | 10001111b = 10111111b
-10111000b | 10010000b = 10111000b
-10111000b | 10010001b = 10111001b
-10111000b | 10010010b = 10111010b
-10111000b | 10010011b = 10111011b
-10111000b | 10010100b = 10111100b
-10111000b | 10010101b = 10111101b
-10111000b | 10010110b = 10111110b
-10111000b | 10010111b = 10111111b
-10111000b | 10011000b = 10111000b
-10111000b | 10011001b = 10111001b
-10111000b | 10011010b = 10111010b
-10111000b | 10011011b = 10111011b
-10111000b | 10011100b = 10111100b
-10111000b | 10011101b = 10111101b
-10111000b | 10011110b = 10111110b
-10111000b | 10011111b = 10111111b
-10111000b | 10100000b = 10111000b
-10111000b | 10100001b = 10111001b
-10111000b | 10100010b = 10111010b
-10111000b | 10100011b = 10111011b
-10111000b | 10100100b = 10111100b
-10111000b | 10100101b = 10111101b
-10111000b | 10100110b = 10111110b
-10111000b | 10100111b = 10111111b
-10111000b | 10101000b = 10111000b
-10111000b | 10101001b = 10111001b
-10111000b | 10101010b = 10111010b
-10111000b | 10101011b = 10111011b
-10111000b | 10101100b = 10111100b
-10111000b | 10101101b = 10111101b
-10111000b | 10101110b = 10111110b
-10111000b | 10101111b = 10111111b
-10111000b | 10110000b = 10111000b
-10111000b | 10110001b = 10111001b
-10111000b | 10110010b = 10111010b
-10111000b | 10110011b = 10111011b
-10111000b | 10110100b = 10111100b
-10111000b | 10110101b = 10111101b
-10111000b | 10110110b = 10111110b
-10111000b | 10110111b = 10111111b
-10111000b | 10111000b = 10111000b
-10111000b | 10111001b = 10111001b
-10111000b | 10111010b = 10111010b
-10111000b | 10111011b = 10111011b
-10111000b | 10111100b = 10111100b
-10111000b | 10111101b = 10111101b
-10111000b | 10111110b = 10111110b
-10111000b | 10111111b = 10111111b
-10111000b | 11000000b = 11111000b
-10111000b | 11000001b = 11111001b
-10111000b | 11000010b = 11111010b
-10111000b | 11000011b = 11111011b
-10111000b | 11000100b = 11111100b
-10111000b | 11000101b = 11111101b
-10111000b | 11000110b = 11111110b
-10111000b | 11000111b = 11111111b
-10111000b | 11001000b = 11111000b
-10111000b | 11001001b = 11111001b
-10111000b | 11001010b = 11111010b
-10111000b | 11001011b = 11111011b
-10111000b | 11001100b = 11111100b
-10111000b | 11001101b = 11111101b
-10111000b | 11001110b = 11111110b
-10111000b | 11001111b = 11111111b
-10111000b | 11010000b = 11111000b
-10111000b | 11010001b = 11111001b
-10111000b | 11010010b = 11111010b
-10111000b | 11010011b = 11111011b
-10111000b | 11010100b = 11111100b
-10111000b | 11010101b = 11111101b
-10111000b | 11010110b = 11111110b
-10111000b | 11010111b = 11111111b
-10111000b | 11011000b = 11111000b
-10111000b | 11011001b = 11111001b
-10111000b | 11011010b = 11111010b
-10111000b | 11011011b = 11111011b
-10111000b | 11011100b = 11111100b
-10111000b | 11011101b = 11111101b
-10111000b | 11011110b = 11111110b
-10111000b | 11011111b = 11111111b
-10111000b | 11100000b = 11111000b
-10111000b | 11100001b = 11111001b
-10111000b | 11100010b = 11111010b
-10111000b | 11100011b = 11111011b
-10111000b | 11100100b = 11111100b
-10111000b | 11100101b = 11111101b
-10111000b | 11100110b = 11111110b
-10111000b | 11100111b = 11111111b
-10111000b | 11101000b = 11111000b
-10111000b | 11101001b = 11111001b
-10111000b | 11101010b = 11111010b
-10111000b | 11101011b = 11111011b
-10111000b | 11101100b = 11111100b
-10111000b | 11101101b = 11111101b
-10111000b | 11101110b = 11111110b
-10111000b | 11101111b = 11111111b
-10111000b | 11110000b = 11111000b
-10111000b | 11110001b = 11111001b
-10111000b | 11110010b = 11111010b
-10111000b | 11110011b = 11111011b
-10111000b | 11110100b = 11111100b
-10111000b | 11110101b = 11111101b
-10111000b | 11110110b = 11111110b
-10111000b | 11110111b = 11111111b
-10111000b | 11111000b = 11111000b
-10111000b | 11111001b = 11111001b
-10111000b | 11111010b = 11111010b
-10111000b | 11111011b = 11111011b
-10111000b | 11111100b = 11111100b
-10111000b | 11111101b = 11111101b
-10111000b | 11111110b = 11111110b
-10111000b | 11111111b = 11111111b
-10111000b | 00000000b = 10111000b
-10111000b | 00000001b = 10111001b
-10111000b | 00000010b = 10111010b
-10111000b | 00000011b = 10111011b
-10111000b | 00000100b = 10111100b
-10111000b | 00000101b = 10111101b
-10111000b | 00000110b = 10111110b
-10111000b | 00000111b = 10111111b
-10111000b | 00001000b = 10111000b
-10111000b | 00001001b = 10111001b
-10111000b | 00001010b = 10111010b
-10111000b | 00001011b = 10111011b
-10111000b | 00001100b = 10111100b
-10111000b | 00001101b = 10111101b
-10111000b | 00001110b = 10111110b
-10111000b | 00001111b = 10111111b
-10111000b | 00010000b = 10111000b
-10111000b | 00010001b = 10111001b
-10111000b | 00010010b = 10111010b
-10111000b | 00010011b = 10111011b
-10111000b | 00010100b = 10111100b
-10111000b | 00010101b = 10111101b
-10111000b | 00010110b = 10111110b
-10111000b | 00010111b = 10111111b
-10111000b | 00011000b = 10111000b
-10111000b | 00011001b = 10111001b
-10111000b | 00011010b = 10111010b
-10111000b | 00011011b = 10111011b
-10111000b | 00011100b = 10111100b
-10111000b | 00011101b = 10111101b
-10111000b | 00011110b = 10111110b
-10111000b | 00011111b = 10111111b
-10111000b | 00100000b = 10111000b
-10111000b | 00100001b = 10111001b
-10111000b | 00100010b = 10111010b
-10111000b | 00100011b = 10111011b
-10111000b | 00100100b = 10111100b
-10111000b | 00100101b = 10111101b
-10111000b | 00100110b = 10111110b
-10111000b | 00100111b = 10111111b
-10111000b | 00101000b = 10111000b
-10111000b | 00101001b = 10111001b
-10111000b | 00101010b = 10111010b
-10111000b | 00101011b = 10111011b
-10111000b | 00101100b = 10111100b
-10111000b | 00101101b = 10111101b
-10111000b | 00101110b = 10111110b
-10111000b | 00101111b = 10111111b
-10111000b | 00110000b = 10111000b
-10111000b | 00110001b = 10111001b
-10111000b | 00110010b = 10111010b
-10111000b | 00110011b = 10111011b
-10111000b | 00110100b = 10111100b
-10111000b | 00110101b = 10111101b
-10111000b | 00110110b = 10111110b
-10111000b | 00110111b = 10111111b
-10111000b | 00111000b = 10111000b
-10111000b | 00111001b = 10111001b
-10111000b | 00111010b = 10111010b
-10111000b | 00111011b = 10111011b
-10111000b | 00111100b = 10111100b
-10111000b | 00111101b = 10111101b
-10111000b | 00111110b = 10111110b
-10111000b | 00111111b = 10111111b
-10111000b | 01000000b = 11111000b
-10111000b | 01000001b = 11111001b
-10111000b | 01000010b = 11111010b
-10111000b | 01000011b = 11111011b
-10111000b | 01000100b = 11111100b
-10111000b | 01000101b = 11111101b
-10111000b | 01000110b = 11111110b
-10111000b | 01000111b = 11111111b
-10111000b | 01001000b = 11111000b
-10111000b | 01001001b = 11111001b
-10111000b | 01001010b = 11111010b
-10111000b | 01001011b = 11111011b
-10111000b | 01001100b = 11111100b
-10111000b | 01001101b = 11111101b
-10111000b | 01001110b = 11111110b
-10111000b | 01001111b = 11111111b
-10111000b | 01010000b = 11111000b
-10111000b | 01010001b = 11111001b
-10111000b | 01010010b = 11111010b
-10111000b | 01010011b = 11111011b
-10111000b | 01010100b = 11111100b
-10111000b | 01010101b = 11111101b
-10111000b | 01010110b = 11111110b
-10111000b | 01010111b = 11111111b
-10111000b | 01011000b = 11111000b
-10111000b | 01011001b = 11111001b
-10111000b | 01011010b = 11111010b
-10111000b | 01011011b = 11111011b
-10111000b | 01011100b = 11111100b
-10111000b | 01011101b = 11111101b
-10111000b | 01011110b = 11111110b
-10111000b | 01011111b = 11111111b
-10111000b | 01100000b = 11111000b
-10111000b | 01100001b = 11111001b
-10111000b | 01100010b = 11111010b
-10111000b | 01100011b = 11111011b
-10111000b | 01100100b = 11111100b
-10111000b | 01100101b = 11111101b
-10111000b | 01100110b = 11111110b
-10111000b | 01100111b = 11111111b
-10111000b | 01101000b = 11111000b
-10111000b | 01101001b = 11111001b
-10111000b | 01101010b = 11111010b
-10111000b | 01101011b = 11111011b
-10111000b | 01101100b = 11111100b
-10111000b | 01101101b = 11111101b
-10111000b | 01101110b = 11111110b
-10111000b | 01101111b = 11111111b
-10111000b | 01110000b = 11111000b
-10111000b | 01110001b = 11111001b
-10111000b | 01110010b = 11111010b
-10111000b | 01110011b = 11111011b
-10111000b | 01110100b = 11111100b
-10111000b | 01110101b = 11111101b
-10111000b | 01110110b = 11111110b
-10111000b | 01110111b = 11111111b
-10111000b | 01111000b = 11111000b
-10111000b | 01111001b = 11111001b
-10111000b | 01111010b = 11111010b
-10111000b | 01111011b = 11111011b
-10111000b | 01111100b = 11111100b
-10111000b | 01111101b = 11111101b
-10111000b | 01111110b = 11111110b
-10111001b | 10000000b = 10111001b
-10111001b | 10000001b = 10111001b
-10111001b | 10000010b = 10111011b
-10111001b | 10000011b = 10111011b
-10111001b | 10000100b = 10111101b
-10111001b | 10000101b = 10111101b
-10111001b | 10000110b = 10111111b
-10111001b | 10000111b = 10111111b
-10111001b | 10001000b = 10111001b
-10111001b | 10001001b = 10111001b
-10111001b | 10001010b = 10111011b
-10111001b | 10001011b = 10111011b
-10111001b | 10001100b = 10111101b
-10111001b | 10001101b = 10111101b
-10111001b | 10001110b = 10111111b
-10111001b | 10001111b = 10111111b
-10111001b | 10010000b = 10111001b
-10111001b | 10010001b = 10111001b
-10111001b | 10010010b = 10111011b
-10111001b | 10010011b = 10111011b
-10111001b | 10010100b = 10111101b
-10111001b | 10010101b = 10111101b
-10111001b | 10010110b = 10111111b
-10111001b | 10010111b = 10111111b
-10111001b | 10011000b = 10111001b
-10111001b | 10011001b = 10111001b
-10111001b | 10011010b = 10111011b
-10111001b | 10011011b = 10111011b
-10111001b | 10011100b = 10111101b
-10111001b | 10011101b = 10111101b
-10111001b | 10011110b = 10111111b
-10111001b | 10011111b = 10111111b
-10111001b | 10100000b = 10111001b
-10111001b | 10100001b = 10111001b
-10111001b | 10100010b = 10111011b
-10111001b | 10100011b = 10111011b
-10111001b | 10100100b = 10111101b
-10111001b | 10100101b = 10111101b
-10111001b | 10100110b = 10111111b
-10111001b | 10100111b = 10111111b
-10111001b | 10101000b = 10111001b
-10111001b | 10101001b = 10111001b
-10111001b | 10101010b = 10111011b
-10111001b | 10101011b = 10111011b
-10111001b | 10101100b = 10111101b
-10111001b | 10101101b = 10111101b
-10111001b | 10101110b = 10111111b
-10111001b | 10101111b = 10111111b
-10111001b | 10110000b = 10111001b
-10111001b | 10110001b = 10111001b
-10111001b | 10110010b = 10111011b
-10111001b | 10110011b = 10111011b
-10111001b | 10110100b = 10111101b
-10111001b | 10110101b = 10111101b
-10111001b | 10110110b = 10111111b
-10111001b | 10110111b = 10111111b
-10111001b | 10111000b = 10111001b
-10111001b | 10111001b = 10111001b
-10111001b | 10111010b = 10111011b
-10111001b | 10111011b = 10111011b
-10111001b | 10111100b = 10111101b
-10111001b | 10111101b = 10111101b
-10111001b | 10111110b = 10111111b
-10111001b | 10111111b = 10111111b
-10111001b | 11000000b = 11111001b
-10111001b | 11000001b = 11111001b
-10111001b | 11000010b = 11111011b
-10111001b | 11000011b = 11111011b
-10111001b | 11000100b = 11111101b
-10111001b | 11000101b = 11111101b
-10111001b | 11000110b = 11111111b
-10111001b | 11000111b = 11111111b
-10111001b | 11001000b = 11111001b
-10111001b | 11001001b = 11111001b
-10111001b | 11001010b = 11111011b
-10111001b | 11001011b = 11111011b
-10111001b | 11001100b = 11111101b
-10111001b | 11001101b = 11111101b
-10111001b | 11001110b = 11111111b
-10111001b | 11001111b = 11111111b
-10111001b | 11010000b = 11111001b
-10111001b | 11010001b = 11111001b
-10111001b | 11010010b = 11111011b
-10111001b | 11010011b = 11111011b
-10111001b | 11010100b = 11111101b
-10111001b | 11010101b = 11111101b
-10111001b | 11010110b = 11111111b
-10111001b | 11010111b = 11111111b
-10111001b | 11011000b = 11111001b
-10111001b | 11011001b = 11111001b
-10111001b | 11011010b = 11111011b
-10111001b | 11011011b = 11111011b
-10111001b | 11011100b = 11111101b
-10111001b | 11011101b = 11111101b
-10111001b | 11011110b = 11111111b
-10111001b | 11011111b = 11111111b
-10111001b | 11100000b = 11111001b
-10111001b | 11100001b = 11111001b
-10111001b | 11100010b = 11111011b
-10111001b | 11100011b = 11111011b
-10111001b | 11100100b = 11111101b
-10111001b | 11100101b = 11111101b
-10111001b | 11100110b = 11111111b
-10111001b | 11100111b = 11111111b
-10111001b | 11101000b = 11111001b
-10111001b | 11101001b = 11111001b
-10111001b | 11101010b = 11111011b
-10111001b | 11101011b = 11111011b
-10111001b | 11101100b = 11111101b
-10111001b | 11101101b = 11111101b
-10111001b | 11101110b = 11111111b
-10111001b | 11101111b = 11111111b
-10111001b | 11110000b = 11111001b
-10111001b | 11110001b = 11111001b
-10111001b | 11110010b = 11111011b
-10111001b | 11110011b = 11111011b
-10111001b | 11110100b = 11111101b
-10111001b | 11110101b = 11111101b
-10111001b | 11110110b = 11111111b
-10111001b | 11110111b = 11111111b
-10111001b | 11111000b = 11111001b
-10111001b | 11111001b = 11111001b
-10111001b | 11111010b = 11111011b
-10111001b | 11111011b = 11111011b
-10111001b | 11111100b = 11111101b
-10111001b | 11111101b = 11111101b
-10111001b | 11111110b = 11111111b
-10111001b | 11111111b = 11111111b
-10111001b | 00000000b = 10111001b
-10111001b | 00000001b = 10111001b
-10111001b | 00000010b = 10111011b
-10111001b | 00000011b = 10111011b
-10111001b | 00000100b = 10111101b
-10111001b | 00000101b = 10111101b
-10111001b | 00000110b = 10111111b
-10111001b | 00000111b = 10111111b
-10111001b | 00001000b = 10111001b
-10111001b | 00001001b = 10111001b
-10111001b | 00001010b = 10111011b
-10111001b | 00001011b = 10111011b
-10111001b | 00001100b = 10111101b
-10111001b | 00001101b = 10111101b
-10111001b | 00001110b = 10111111b
-10111001b | 00001111b = 10111111b
-10111001b | 00010000b = 10111001b
-10111001b | 00010001b = 10111001b
-10111001b | 00010010b = 10111011b
-10111001b | 00010011b = 10111011b
-10111001b | 00010100b = 10111101b
-10111001b | 00010101b = 10111101b
-10111001b | 00010110b = 10111111b
-10111001b | 00010111b = 10111111b
-10111001b | 00011000b = 10111001b
-10111001b | 00011001b = 10111001b
-10111001b | 00011010b = 10111011b
-10111001b | 00011011b = 10111011b
-10111001b | 00011100b = 10111101b
-10111001b | 00011101b = 10111101b
-10111001b | 00011110b = 10111111b
-10111001b | 00011111b = 10111111b
-10111001b | 00100000b = 10111001b
-10111001b | 00100001b = 10111001b
-10111001b | 00100010b = 10111011b
-10111001b | 00100011b = 10111011b
-10111001b | 00100100b = 10111101b
-10111001b | 00100101b = 10111101b
-10111001b | 00100110b = 10111111b
-10111001b | 00100111b = 10111111b
-10111001b | 00101000b = 10111001b
-10111001b | 00101001b = 10111001b
-10111001b | 00101010b = 10111011b
-10111001b | 00101011b = 10111011b
-10111001b | 00101100b = 10111101b
-10111001b | 00101101b = 10111101b
-10111001b | 00101110b = 10111111b
-10111001b | 00101111b = 10111111b
-10111001b | 00110000b = 10111001b
-10111001b | 00110001b = 10111001b
-10111001b | 00110010b = 10111011b
-10111001b | 00110011b = 10111011b
-10111001b | 00110100b = 10111101b
-10111001b | 00110101b = 10111101b
-10111001b | 00110110b = 10111111b
-10111001b | 00110111b = 10111111b
-10111001b | 00111000b = 10111001b
-10111001b | 00111001b = 10111001b
-10111001b | 00111010b = 10111011b
-10111001b | 00111011b = 10111011b
-10111001b | 00111100b = 10111101b
-10111001b | 00111101b = 10111101b
-10111001b | 00111110b = 10111111b
-10111001b | 00111111b = 10111111b
-10111001b | 01000000b = 11111001b
-10111001b | 01000001b = 11111001b
-10111001b | 01000010b = 11111011b
-10111001b | 01000011b = 11111011b
-10111001b | 01000100b = 11111101b
-10111001b | 01000101b = 11111101b
-10111001b | 01000110b = 11111111b
-10111001b | 01000111b = 11111111b
-10111001b | 01001000b = 11111001b
-10111001b | 01001001b = 11111001b
-10111001b | 01001010b = 11111011b
-10111001b | 01001011b = 11111011b
-10111001b | 01001100b = 11111101b
-10111001b | 01001101b = 11111101b
-10111001b | 01001110b = 11111111b
-10111001b | 01001111b = 11111111b
-10111001b | 01010000b = 11111001b
-10111001b | 01010001b = 11111001b
-10111001b | 01010010b = 11111011b
-10111001b | 01010011b = 11111011b
-10111001b | 01010100b = 11111101b
-10111001b | 01010101b = 11111101b
-10111001b | 01010110b = 11111111b
-10111001b | 01010111b = 11111111b
-10111001b | 01011000b = 11111001b
-10111001b | 01011001b = 11111001b
-10111001b | 01011010b = 11111011b
-10111001b | 01011011b = 11111011b
-10111001b | 01011100b = 11111101b
-10111001b | 01011101b = 11111101b
-10111001b | 01011110b = 11111111b
-10111001b | 01011111b = 11111111b
-10111001b | 01100000b = 11111001b
-10111001b | 01100001b = 11111001b
-10111001b | 01100010b = 11111011b
-10111001b | 01100011b = 11111011b
-10111001b | 01100100b = 11111101b
-10111001b | 01100101b = 11111101b
-10111001b | 01100110b = 11111111b
-10111001b | 01100111b = 11111111b
-10111001b | 01101000b = 11111001b
-10111001b | 01101001b = 11111001b
-10111001b | 01101010b = 11111011b
-10111001b | 01101011b = 11111011b
-10111001b | 01101100b = 11111101b
-10111001b | 01101101b = 11111101b
-10111001b | 01101110b = 11111111b
-10111001b | 01101111b = 11111111b
-10111001b | 01110000b = 11111001b
-10111001b | 01110001b = 11111001b
-10111001b | 01110010b = 11111011b
-10111001b | 01110011b = 11111011b
-10111001b | 01110100b = 11111101b
-10111001b | 01110101b = 11111101b
-10111001b | 01110110b = 11111111b
-10111001b | 01110111b = 11111111b
-10111001b | 01111000b = 11111001b
-10111001b | 01111001b = 11111001b
-10111001b | 01111010b = 11111011b
-10111001b | 01111011b = 11111011b
-10111001b | 01111100b = 11111101b
-10111001b | 01111101b = 11111101b
-10111001b | 01111110b = 11111111b
-10111010b | 10000000b = 10111010b
-10111010b | 10000001b = 10111011b
-10111010b | 10000010b = 10111010b
-10111010b | 10000011b = 10111011b
-10111010b | 10000100b = 10111110b
-10111010b | 10000101b = 10111111b
-10111010b | 10000110b = 10111110b
-10111010b | 10000111b = 10111111b
-10111010b | 10001000b = 10111010b
-10111010b | 10001001b = 10111011b
-10111010b | 10001010b = 10111010b
-10111010b | 10001011b = 10111011b
-10111010b | 10001100b = 10111110b
-10111010b | 10001101b = 10111111b
-10111010b | 10001110b = 10111110b
-10111010b | 10001111b = 10111111b
-10111010b | 10010000b = 10111010b
-10111010b | 10010001b = 10111011b
-10111010b | 10010010b = 10111010b
-10111010b | 10010011b = 10111011b
-10111010b | 10010100b = 10111110b
-10111010b | 10010101b = 10111111b
-10111010b | 10010110b = 10111110b
-10111010b | 10010111b = 10111111b
-10111010b | 10011000b = 10111010b
-10111010b | 10011001b = 10111011b
-10111010b | 10011010b = 10111010b
-10111010b | 10011011b = 10111011b
-10111010b | 10011100b = 10111110b
-10111010b | 10011101b = 10111111b
-10111010b | 10011110b = 10111110b
-10111010b | 10011111b = 10111111b
-10111010b | 10100000b = 10111010b
-10111010b | 10100001b = 10111011b
-10111010b | 10100010b = 10111010b
-10111010b | 10100011b = 10111011b
-10111010b | 10100100b = 10111110b
-10111010b | 10100101b = 10111111b
-10111010b | 10100110b = 10111110b
-10111010b | 10100111b = 10111111b
-10111010b | 10101000b = 10111010b
-10111010b | 10101001b = 10111011b
-10111010b | 10101010b = 10111010b
-10111010b | 10101011b = 10111011b
-10111010b | 10101100b = 10111110b
-10111010b | 10101101b = 10111111b
-10111010b | 10101110b = 10111110b
-10111010b | 10101111b = 10111111b
-10111010b | 10110000b = 10111010b
-10111010b | 10110001b = 10111011b
-10111010b | 10110010b = 10111010b
-10111010b | 10110011b = 10111011b
-10111010b | 10110100b = 10111110b
-10111010b | 10110101b = 10111111b
-10111010b | 10110110b = 10111110b
-10111010b | 10110111b = 10111111b
-10111010b | 10111000b = 10111010b
-10111010b | 10111001b = 10111011b
-10111010b | 10111010b = 10111010b
-10111010b | 10111011b = 10111011b
-10111010b | 10111100b = 10111110b
-10111010b | 10111101b = 10111111b
-10111010b | 10111110b = 10111110b
-10111010b | 10111111b = 10111111b
-10111010b | 11000000b = 11111010b
-10111010b | 11000001b = 11111011b
-10111010b | 11000010b = 11111010b
-10111010b | 11000011b = 11111011b
-10111010b | 11000100b = 11111110b
-10111010b | 11000101b = 11111111b
-10111010b | 11000110b = 11111110b
-10111010b | 11000111b = 11111111b
-10111010b | 11001000b = 11111010b
-10111010b | 11001001b = 11111011b
-10111010b | 11001010b = 11111010b
-10111010b | 11001011b = 11111011b
-10111010b | 11001100b = 11111110b
-10111010b | 11001101b = 11111111b
-10111010b | 11001110b = 11111110b
-10111010b | 11001111b = 11111111b
-10111010b | 11010000b = 11111010b
-10111010b | 11010001b = 11111011b
-10111010b | 11010010b = 11111010b
-10111010b | 11010011b = 11111011b
-10111010b | 11010100b = 11111110b
-10111010b | 11010101b = 11111111b
-10111010b | 11010110b = 11111110b
-10111010b | 11010111b = 11111111b
-10111010b | 11011000b = 11111010b
-10111010b | 11011001b = 11111011b
-10111010b | 11011010b = 11111010b
-10111010b | 11011011b = 11111011b
-10111010b | 11011100b = 11111110b
-10111010b | 11011101b = 11111111b
-10111010b | 11011110b = 11111110b
-10111010b | 11011111b = 11111111b
-10111010b | 11100000b = 11111010b
-10111010b | 11100001b = 11111011b
-10111010b | 11100010b = 11111010b
-10111010b | 11100011b = 11111011b
-10111010b | 11100100b = 11111110b
-10111010b | 11100101b = 11111111b
-10111010b | 11100110b = 11111110b
-10111010b | 11100111b = 11111111b
-10111010b | 11101000b = 11111010b
-10111010b | 11101001b = 11111011b
-10111010b | 11101010b = 11111010b
-10111010b | 11101011b = 11111011b
-10111010b | 11101100b = 11111110b
-10111010b | 11101101b = 11111111b
-10111010b | 11101110b = 11111110b
-10111010b | 11101111b = 11111111b
-10111010b | 11110000b = 11111010b
-10111010b | 11110001b = 11111011b
-10111010b | 11110010b = 11111010b
-10111010b | 11110011b = 11111011b
-10111010b | 11110100b = 11111110b
-10111010b | 11110101b = 11111111b
-10111010b | 11110110b = 11111110b
-10111010b | 11110111b = 11111111b
-10111010b | 11111000b = 11111010b
-10111010b | 11111001b = 11111011b
-10111010b | 11111010b = 11111010b
-10111010b | 11111011b = 11111011b
-10111010b | 11111100b = 11111110b
-10111010b | 11111101b = 11111111b
-10111010b | 11111110b = 11111110b
-10111010b | 11111111b = 11111111b
-10111010b | 00000000b = 10111010b
-10111010b | 00000001b = 10111011b
-10111010b | 00000010b = 10111010b
-10111010b | 00000011b = 10111011b
-10111010b | 00000100b = 10111110b
-10111010b | 00000101b = 10111111b
-10111010b | 00000110b = 10111110b
-10111010b | 00000111b = 10111111b
-10111010b | 00001000b = 10111010b
-10111010b | 00001001b = 10111011b
-10111010b | 00001010b = 10111010b
-10111010b | 00001011b = 10111011b
-10111010b | 00001100b = 10111110b
-10111010b | 00001101b = 10111111b
-10111010b | 00001110b = 10111110b
-10111010b | 00001111b = 10111111b
-10111010b | 00010000b = 10111010b
-10111010b | 00010001b = 10111011b
-10111010b | 00010010b = 10111010b
-10111010b | 00010011b = 10111011b
-10111010b | 00010100b = 10111110b
-10111010b | 00010101b = 10111111b
-10111010b | 00010110b = 10111110b
-10111010b | 00010111b = 10111111b
-10111010b | 00011000b = 10111010b
-10111010b | 00011001b = 10111011b
-10111010b | 00011010b = 10111010b
-10111010b | 00011011b = 10111011b
-10111010b | 00011100b = 10111110b
-10111010b | 00011101b = 10111111b
-10111010b | 00011110b = 10111110b
-10111010b | 00011111b = 10111111b
-10111010b | 00100000b = 10111010b
-10111010b | 00100001b = 10111011b
-10111010b | 00100010b = 10111010b
-10111010b | 00100011b = 10111011b
-10111010b | 00100100b = 10111110b
-10111010b | 00100101b = 10111111b
-10111010b | 00100110b = 10111110b
-10111010b | 00100111b = 10111111b
-10111010b | 00101000b = 10111010b
-10111010b | 00101001b = 10111011b
-10111010b | 00101010b = 10111010b
-10111010b | 00101011b = 10111011b
-10111010b | 00101100b = 10111110b
-10111010b | 00101101b = 10111111b
-10111010b | 00101110b = 10111110b
-10111010b | 00101111b = 10111111b
-10111010b | 00110000b = 10111010b
-10111010b | 00110001b = 10111011b
-10111010b | 00110010b = 10111010b
-10111010b | 00110011b = 10111011b
-10111010b | 00110100b = 10111110b
-10111010b | 00110101b = 10111111b
-10111010b | 00110110b = 10111110b
-10111010b | 00110111b = 10111111b
-10111010b | 00111000b = 10111010b
-10111010b | 00111001b = 10111011b
-10111010b | 00111010b = 10111010b
-10111010b | 00111011b = 10111011b
-10111010b | 00111100b = 10111110b
-10111010b | 00111101b = 10111111b
-10111010b | 00111110b = 10111110b
-10111010b | 00111111b = 10111111b
-10111010b | 01000000b = 11111010b
-10111010b | 01000001b = 11111011b
-10111010b | 01000010b = 11111010b
-10111010b | 01000011b = 11111011b
-10111010b | 01000100b = 11111110b
-10111010b | 01000101b = 11111111b
-10111010b | 01000110b = 11111110b
-10111010b | 01000111b = 11111111b
-10111010b | 01001000b = 11111010b
-10111010b | 01001001b = 11111011b
-10111010b | 01001010b = 11111010b
-10111010b | 01001011b = 11111011b
-10111010b | 01001100b = 11111110b
-10111010b | 01001101b = 11111111b
-10111010b | 01001110b = 11111110b
-10111010b | 01001111b = 11111111b
-10111010b | 01010000b = 11111010b
-10111010b | 01010001b = 11111011b
-10111010b | 01010010b = 11111010b
-10111010b | 01010011b = 11111011b
-10111010b | 01010100b = 11111110b
-10111010b | 01010101b = 11111111b
-10111010b | 01010110b = 11111110b
-10111010b | 01010111b = 11111111b
-10111010b | 01011000b = 11111010b
-10111010b | 01011001b = 11111011b
-10111010b | 01011010b = 11111010b
-10111010b | 01011011b = 11111011b
-10111010b | 01011100b = 11111110b
-10111010b | 01011101b = 11111111b
-10111010b | 01011110b = 11111110b
-10111010b | 01011111b = 11111111b
-10111010b | 01100000b = 11111010b
-10111010b | 01100001b = 11111011b
-10111010b | 01100010b = 11111010b
-10111010b | 01100011b = 11111011b
-10111010b | 01100100b = 11111110b
-10111010b | 01100101b = 11111111b
-10111010b | 01100110b = 11111110b
-10111010b | 01100111b = 11111111b
-10111010b | 01101000b = 11111010b
-10111010b | 01101001b = 11111011b
-10111010b | 01101010b = 11111010b
-10111010b | 01101011b = 11111011b
-10111010b | 01101100b = 11111110b
-10111010b | 01101101b = 11111111b
-10111010b | 01101110b = 11111110b
-10111010b | 01101111b = 11111111b
-10111010b | 01110000b = 11111010b
-10111010b | 01110001b = 11111011b
-10111010b | 01110010b = 11111010b
-10111010b | 01110011b = 11111011b
-10111010b | 01110100b = 11111110b
-10111010b | 01110101b = 11111111b
-10111010b | 01110110b = 11111110b
-10111010b | 01110111b = 11111111b
-10111010b | 01111000b = 11111010b
-10111010b | 01111001b = 11111011b
-10111010b | 01111010b = 11111010b
-10111010b | 01111011b = 11111011b
-10111010b | 01111100b = 11111110b
-10111010b | 01111101b = 11111111b
-10111010b | 01111110b = 11111110b
-10111011b | 10000000b = 10111011b
-10111011b | 10000001b = 10111011b
-10111011b | 10000010b = 10111011b
-10111011b | 10000011b = 10111011b
-10111011b | 10000100b = 10111111b
-10111011b | 10000101b = 10111111b
-10111011b | 10000110b = 10111111b
-10111011b | 10000111b = 10111111b
-10111011b | 10001000b = 10111011b
-10111011b | 10001001b = 10111011b
-10111011b | 10001010b = 10111011b
-10111011b | 10001011b = 10111011b
-10111011b | 10001100b = 10111111b
-10111011b | 10001101b = 10111111b
-10111011b | 10001110b = 10111111b
-10111011b | 10001111b = 10111111b
-10111011b | 10010000b = 10111011b
-10111011b | 10010001b = 10111011b
-10111011b | 10010010b = 10111011b
-10111011b | 10010011b = 10111011b
-10111011b | 10010100b = 10111111b
-10111011b | 10010101b = 10111111b
-10111011b | 10010110b = 10111111b
-10111011b | 10010111b = 10111111b
-10111011b | 10011000b = 10111011b
-10111011b | 10011001b = 10111011b
-10111011b | 10011010b = 10111011b
-10111011b | 10011011b = 10111011b
-10111011b | 10011100b = 10111111b
-10111011b | 10011101b = 10111111b
-10111011b | 10011110b = 10111111b
-10111011b | 10011111b = 10111111b
-10111011b | 10100000b = 10111011b
-10111011b | 10100001b = 10111011b
-10111011b | 10100010b = 10111011b
-10111011b | 10100011b = 10111011b
-10111011b | 10100100b = 10111111b
-10111011b | 10100101b = 10111111b
-10111011b | 10100110b = 10111111b
-10111011b | 10100111b = 10111111b
-10111011b | 10101000b = 10111011b
-10111011b | 10101001b = 10111011b
-10111011b | 10101010b = 10111011b
-10111011b | 10101011b = 10111011b
-10111011b | 10101100b = 10111111b
-10111011b | 10101101b = 10111111b
-10111011b | 10101110b = 10111111b
-10111011b | 10101111b = 10111111b
-10111011b | 10110000b = 10111011b
-10111011b | 10110001b = 10111011b
-10111011b | 10110010b = 10111011b
-10111011b | 10110011b = 10111011b
-10111011b | 10110100b = 10111111b
-10111011b | 10110101b = 10111111b
-10111011b | 10110110b = 10111111b
-10111011b | 10110111b = 10111111b
-10111011b | 10111000b = 10111011b
-10111011b | 10111001b = 10111011b
-10111011b | 10111010b = 10111011b
-10111011b | 10111011b = 10111011b
-10111011b | 10111100b = 10111111b
-10111011b | 10111101b = 10111111b
-10111011b | 10111110b = 10111111b
-10111011b | 10111111b = 10111111b
-10111011b | 11000000b = 11111011b
-10111011b | 11000001b = 11111011b
-10111011b | 11000010b = 11111011b
-10111011b | 11000011b = 11111011b
-10111011b | 11000100b = 11111111b
-10111011b | 11000101b = 11111111b
-10111011b | 11000110b = 11111111b
-10111011b | 11000111b = 11111111b
-10111011b | 11001000b = 11111011b
-10111011b | 11001001b = 11111011b
-10111011b | 11001010b = 11111011b
-10111011b | 11001011b = 11111011b
-10111011b | 11001100b = 11111111b
-10111011b | 11001101b = 11111111b
-10111011b | 11001110b = 11111111b
-10111011b | 11001111b = 11111111b
-10111011b | 11010000b = 11111011b
-10111011b | 11010001b = 11111011b
-10111011b | 11010010b = 11111011b
-10111011b | 11010011b = 11111011b
-10111011b | 11010100b = 11111111b
-10111011b | 11010101b = 11111111b
-10111011b | 11010110b = 11111111b
-10111011b | 11010111b = 11111111b
-10111011b | 11011000b = 11111011b
-10111011b | 11011001b = 11111011b
-10111011b | 11011010b = 11111011b
-10111011b | 11011011b = 11111011b
-10111011b | 11011100b = 11111111b
-10111011b | 11011101b = 11111111b
-10111011b | 11011110b = 11111111b
-10111011b | 11011111b = 11111111b
-10111011b | 11100000b = 11111011b
-10111011b | 11100001b = 11111011b
-10111011b | 11100010b = 11111011b
-10111011b | 11100011b = 11111011b
-10111011b | 11100100b = 11111111b
-10111011b | 11100101b = 11111111b
-10111011b | 11100110b = 11111111b
-10111011b | 11100111b = 11111111b
-10111011b | 11101000b = 11111011b
-10111011b | 11101001b = 11111011b
-10111011b | 11101010b = 11111011b
-10111011b | 11101011b = 11111011b
-10111011b | 11101100b = 11111111b
-10111011b | 11101101b = 11111111b
-10111011b | 11101110b = 11111111b
-10111011b | 11101111b = 11111111b
-10111011b | 11110000b = 11111011b
-10111011b | 11110001b = 11111011b
-10111011b | 11110010b = 11111011b
-10111011b | 11110011b = 11111011b
-10111011b | 11110100b = 11111111b
-10111011b | 11110101b = 11111111b
-10111011b | 11110110b = 11111111b
-10111011b | 11110111b = 11111111b
-10111011b | 11111000b = 11111011b
-10111011b | 11111001b = 11111011b
-10111011b | 11111010b = 11111011b
-10111011b | 11111011b = 11111011b
-10111011b | 11111100b = 11111111b
-10111011b | 11111101b = 11111111b
-10111011b | 11111110b = 11111111b
-10111011b | 11111111b = 11111111b
-10111011b | 00000000b = 10111011b
-10111011b | 00000001b = 10111011b
-10111011b | 00000010b = 10111011b
-10111011b | 00000011b = 10111011b
-10111011b | 00000100b = 10111111b
-10111011b | 00000101b = 10111111b
-10111011b | 00000110b = 10111111b
-10111011b | 00000111b = 10111111b
-10111011b | 00001000b = 10111011b
-10111011b | 00001001b = 10111011b
-10111011b | 00001010b = 10111011b
-10111011b | 00001011b = 10111011b
-10111011b | 00001100b = 10111111b
-10111011b | 00001101b = 10111111b
-10111011b | 00001110b = 10111111b
-10111011b | 00001111b = 10111111b
-10111011b | 00010000b = 10111011b
-10111011b | 00010001b = 10111011b
-10111011b | 00010010b = 10111011b
-10111011b | 00010011b = 10111011b
-10111011b | 00010100b = 10111111b
-10111011b | 00010101b = 10111111b
-10111011b | 00010110b = 10111111b
-10111011b | 00010111b = 10111111b
-10111011b | 00011000b = 10111011b
-10111011b | 00011001b = 10111011b
-10111011b | 00011010b = 10111011b
-10111011b | 00011011b = 10111011b
-10111011b | 00011100b = 10111111b
-10111011b | 00011101b = 10111111b
-10111011b | 00011110b = 10111111b
-10111011b | 00011111b = 10111111b
-10111011b | 00100000b = 10111011b
-10111011b | 00100001b = 10111011b
-10111011b | 00100010b = 10111011b
-10111011b | 00100011b = 10111011b
-10111011b | 00100100b = 10111111b
-10111011b | 00100101b = 10111111b
-10111011b | 00100110b = 10111111b
-10111011b | 00100111b = 10111111b
-10111011b | 00101000b = 10111011b
-10111011b | 00101001b = 10111011b
-10111011b | 00101010b = 10111011b
-10111011b | 00101011b = 10111011b
-10111011b | 00101100b = 10111111b
-10111011b | 00101101b = 10111111b
-10111011b | 00101110b = 10111111b
-10111011b | 00101111b = 10111111b
-10111011b | 00110000b = 10111011b
-10111011b | 00110001b = 10111011b
-10111011b | 00110010b = 10111011b
-10111011b | 00110011b = 10111011b
-10111011b | 00110100b = 10111111b
-10111011b | 00110101b = 10111111b
-10111011b | 00110110b = 10111111b
-10111011b | 00110111b = 10111111b
-10111011b | 00111000b = 10111011b
-10111011b | 00111001b = 10111011b
-10111011b | 00111010b = 10111011b
-10111011b | 00111011b = 10111011b
-10111011b | 00111100b = 10111111b
-10111011b | 00111101b = 10111111b
-10111011b | 00111110b = 10111111b
-10111011b | 00111111b = 10111111b
-10111011b | 01000000b = 11111011b
-10111011b | 01000001b = 11111011b
-10111011b | 01000010b = 11111011b
-10111011b | 01000011b = 11111011b
-10111011b | 01000100b = 11111111b
-10111011b | 01000101b = 11111111b
-10111011b | 01000110b = 11111111b
-10111011b | 01000111b = 11111111b
-10111011b | 01001000b = 11111011b
-10111011b | 01001001b = 11111011b
-10111011b | 01001010b = 11111011b
-10111011b | 01001011b = 11111011b
-10111011b | 01001100b = 11111111b
-10111011b | 01001101b = 11111111b
-10111011b | 01001110b = 11111111b
-10111011b | 01001111b = 11111111b
-10111011b | 01010000b = 11111011b
-10111011b | 01010001b = 11111011b
-10111011b | 01010010b = 11111011b
-10111011b | 01010011b = 11111011b
-10111011b | 01010100b = 11111111b
-10111011b | 01010101b = 11111111b
-10111011b | 01010110b = 11111111b
-10111011b | 01010111b = 11111111b
-10111011b | 01011000b = 11111011b
-10111011b | 01011001b = 11111011b
-10111011b | 01011010b = 11111011b
-10111011b | 01011011b = 11111011b
-10111011b | 01011100b = 11111111b
-10111011b | 01011101b = 11111111b
-10111011b | 01011110b = 11111111b
-10111011b | 01011111b = 11111111b
-10111011b | 01100000b = 11111011b
-10111011b | 01100001b = 11111011b
-10111011b | 01100010b = 11111011b
-10111011b | 01100011b = 11111011b
-10111011b | 01100100b = 11111111b
-10111011b | 01100101b = 11111111b
-10111011b | 01100110b = 11111111b
-10111011b | 01100111b = 11111111b
-10111011b | 01101000b = 11111011b
-10111011b | 01101001b = 11111011b
-10111011b | 01101010b = 11111011b
-10111011b | 01101011b = 11111011b
-10111011b | 01101100b = 11111111b
-10111011b | 01101101b = 11111111b
-10111011b | 01101110b = 11111111b
-10111011b | 01101111b = 11111111b
-10111011b | 01110000b = 11111011b
-10111011b | 01110001b = 11111011b
-10111011b | 01110010b = 11111011b
-10111011b | 01110011b = 11111011b
-10111011b | 01110100b = 11111111b
-10111011b | 01110101b = 11111111b
-10111011b | 01110110b = 11111111b
-10111011b | 01110111b = 11111111b
-10111011b | 01111000b = 11111011b
-10111011b | 01111001b = 11111011b
-10111011b | 01111010b = 11111011b
-10111011b | 01111011b = 11111011b
-10111011b | 01111100b = 11111111b
-10111011b | 01111101b = 11111111b
-10111011b | 01111110b = 11111111b
-10111100b | 10000000b = 10111100b
-10111100b | 10000001b = 10111101b
-10111100b | 10000010b = 10111110b
-10111100b | 10000011b = 10111111b
-10111100b | 10000100b = 10111100b
-10111100b | 10000101b = 10111101b
-10111100b | 10000110b = 10111110b
-10111100b | 10000111b = 10111111b
-10111100b | 10001000b = 10111100b
-10111100b | 10001001b = 10111101b
-10111100b | 10001010b = 10111110b
-10111100b | 10001011b = 10111111b
-10111100b | 10001100b = 10111100b
-10111100b | 10001101b = 10111101b
-10111100b | 10001110b = 10111110b
-10111100b | 10001111b = 10111111b
-10111100b | 10010000b = 10111100b
-10111100b | 10010001b = 10111101b
-10111100b | 10010010b = 10111110b
-10111100b | 10010011b = 10111111b
-10111100b | 10010100b = 10111100b
-10111100b | 10010101b = 10111101b
-10111100b | 10010110b = 10111110b
-10111100b | 10010111b = 10111111b
-10111100b | 10011000b = 10111100b
-10111100b | 10011001b = 10111101b
-10111100b | 10011010b = 10111110b
-10111100b | 10011011b = 10111111b
-10111100b | 10011100b = 10111100b
-10111100b | 10011101b = 10111101b
-10111100b | 10011110b = 10111110b
-10111100b | 10011111b = 10111111b
-10111100b | 10100000b = 10111100b
-10111100b | 10100001b = 10111101b
-10111100b | 10100010b = 10111110b
-10111100b | 10100011b = 10111111b
-10111100b | 10100100b = 10111100b
-10111100b | 10100101b = 10111101b
-10111100b | 10100110b = 10111110b
-10111100b | 10100111b = 10111111b
-10111100b | 10101000b = 10111100b
-10111100b | 10101001b = 10111101b
-10111100b | 10101010b = 10111110b
-10111100b | 10101011b = 10111111b
-10111100b | 10101100b = 10111100b
-10111100b | 10101101b = 10111101b
-10111100b | 10101110b = 10111110b
-10111100b | 10101111b = 10111111b
-10111100b | 10110000b = 10111100b
-10111100b | 10110001b = 10111101b
-10111100b | 10110010b = 10111110b
-10111100b | 10110011b = 10111111b
-10111100b | 10110100b = 10111100b
-10111100b | 10110101b = 10111101b
-10111100b | 10110110b = 10111110b
-10111100b | 10110111b = 10111111b
-10111100b | 10111000b = 10111100b
-10111100b | 10111001b = 10111101b
-10111100b | 10111010b = 10111110b
-10111100b | 10111011b = 10111111b
-10111100b | 10111100b = 10111100b
-10111100b | 10111101b = 10111101b
-10111100b | 10111110b = 10111110b
-10111100b | 10111111b = 10111111b
-10111100b | 11000000b = 11111100b
-10111100b | 11000001b = 11111101b
-10111100b | 11000010b = 11111110b
-10111100b | 11000011b = 11111111b
-10111100b | 11000100b = 11111100b
-10111100b | 11000101b = 11111101b
-10111100b | 11000110b = 11111110b
-10111100b | 11000111b = 11111111b
-10111100b | 11001000b = 11111100b
-10111100b | 11001001b = 11111101b
-10111100b | 11001010b = 11111110b
-10111100b | 11001011b = 11111111b
-10111100b | 11001100b = 11111100b
-10111100b | 11001101b = 11111101b
-10111100b | 11001110b = 11111110b
-10111100b | 11001111b = 11111111b
-10111100b | 11010000b = 11111100b
-10111100b | 11010001b = 11111101b
-10111100b | 11010010b = 11111110b
-10111100b | 11010011b = 11111111b
-10111100b | 11010100b = 11111100b
-10111100b | 11010101b = 11111101b
-10111100b | 11010110b = 11111110b
-10111100b | 11010111b = 11111111b
-10111100b | 11011000b = 11111100b
-10111100b | 11011001b = 11111101b
-10111100b | 11011010b = 11111110b
-10111100b | 11011011b = 11111111b
-10111100b | 11011100b = 11111100b
-10111100b | 11011101b = 11111101b
-10111100b | 11011110b = 11111110b
-10111100b | 11011111b = 11111111b
-10111100b | 11100000b = 11111100b
-10111100b | 11100001b = 11111101b
-10111100b | 11100010b = 11111110b
-10111100b | 11100011b = 11111111b
-10111100b | 11100100b = 11111100b
-10111100b | 11100101b = 11111101b
-10111100b | 11100110b = 11111110b
-10111100b | 11100111b = 11111111b
-10111100b | 11101000b = 11111100b
-10111100b | 11101001b = 11111101b
-10111100b | 11101010b = 11111110b
-10111100b | 11101011b = 11111111b
-10111100b | 11101100b = 11111100b
-10111100b | 11101101b = 11111101b
-10111100b | 11101110b = 11111110b
-10111100b | 11101111b = 11111111b
-10111100b | 11110000b = 11111100b
-10111100b | 11110001b = 11111101b
-10111100b | 11110010b = 11111110b
-10111100b | 11110011b = 11111111b
-10111100b | 11110100b = 11111100b
-10111100b | 11110101b = 11111101b
-10111100b | 11110110b = 11111110b
-10111100b | 11110111b = 11111111b
-10111100b | 11111000b = 11111100b
-10111100b | 11111001b = 11111101b
-10111100b | 11111010b = 11111110b
-10111100b | 11111011b = 11111111b
-10111100b | 11111100b = 11111100b
-10111100b | 11111101b = 11111101b
-10111100b | 11111110b = 11111110b
-10111100b | 11111111b = 11111111b
-10111100b | 00000000b = 10111100b
-10111100b | 00000001b = 10111101b
-10111100b | 00000010b = 10111110b
-10111100b | 00000011b = 10111111b
-10111100b | 00000100b = 10111100b
-10111100b | 00000101b = 10111101b
-10111100b | 00000110b = 10111110b
-10111100b | 00000111b = 10111111b
-10111100b | 00001000b = 10111100b
-10111100b | 00001001b = 10111101b
-10111100b | 00001010b = 10111110b
-10111100b | 00001011b = 10111111b
-10111100b | 00001100b = 10111100b
-10111100b | 00001101b = 10111101b
-10111100b | 00001110b = 10111110b
-10111100b | 00001111b = 10111111b
-10111100b | 00010000b = 10111100b
-10111100b | 00010001b = 10111101b
-10111100b | 00010010b = 10111110b
-10111100b | 00010011b = 10111111b
-10111100b | 00010100b = 10111100b
-10111100b | 00010101b = 10111101b
-10111100b | 00010110b = 10111110b
-10111100b | 00010111b = 10111111b
-10111100b | 00011000b = 10111100b
-10111100b | 00011001b = 10111101b
-10111100b | 00011010b = 10111110b
-10111100b | 00011011b = 10111111b
-10111100b | 00011100b = 10111100b
-10111100b | 00011101b = 10111101b
-10111100b | 00011110b = 10111110b
-10111100b | 00011111b = 10111111b
-10111100b | 00100000b = 10111100b
-10111100b | 00100001b = 10111101b
-10111100b | 00100010b = 10111110b
-10111100b | 00100011b = 10111111b
-10111100b | 00100100b = 10111100b
-10111100b | 00100101b = 10111101b
-10111100b | 00100110b = 10111110b
-10111100b | 00100111b = 10111111b
-10111100b | 00101000b = 10111100b
-10111100b | 00101001b = 10111101b
-10111100b | 00101010b = 10111110b
-10111100b | 00101011b = 10111111b
-10111100b | 00101100b = 10111100b
-10111100b | 00101101b = 10111101b
-10111100b | 00101110b = 10111110b
-10111100b | 00101111b = 10111111b
-10111100b | 00110000b = 10111100b
-10111100b | 00110001b = 10111101b
-10111100b | 00110010b = 10111110b
-10111100b | 00110011b = 10111111b
-10111100b | 00110100b = 10111100b
-10111100b | 00110101b = 10111101b
-10111100b | 00110110b = 10111110b
-10111100b | 00110111b = 10111111b
-10111100b | 00111000b = 10111100b
-10111100b | 00111001b = 10111101b
-10111100b | 00111010b = 10111110b
-10111100b | 00111011b = 10111111b
-10111100b | 00111100b = 10111100b
-10111100b | 00111101b = 10111101b
-10111100b | 00111110b = 10111110b
-10111100b | 00111111b = 10111111b
-10111100b | 01000000b = 11111100b
-10111100b | 01000001b = 11111101b
-10111100b | 01000010b = 11111110b
-10111100b | 01000011b = 11111111b
-10111100b | 01000100b = 11111100b
-10111100b | 01000101b = 11111101b
-10111100b | 01000110b = 11111110b
-10111100b | 01000111b = 11111111b
-10111100b | 01001000b = 11111100b
-10111100b | 01001001b = 11111101b
-10111100b | 01001010b = 11111110b
-10111100b | 01001011b = 11111111b
-10111100b | 01001100b = 11111100b
-10111100b | 01001101b = 11111101b
-10111100b | 01001110b = 11111110b
-10111100b | 01001111b = 11111111b
-10111100b | 01010000b = 11111100b
-10111100b | 01010001b = 11111101b
-10111100b | 01010010b = 11111110b
-10111100b | 01010011b = 11111111b
-10111100b | 01010100b = 11111100b
-10111100b | 01010101b = 11111101b
-10111100b | 01010110b = 11111110b
-10111100b | 01010111b = 11111111b
-10111100b | 01011000b = 11111100b
-10111100b | 01011001b = 11111101b
-10111100b | 01011010b = 11111110b
-10111100b | 01011011b = 11111111b
-10111100b | 01011100b = 11111100b
-10111100b | 01011101b = 11111101b
-10111100b | 01011110b = 11111110b
-10111100b | 01011111b = 11111111b
-10111100b | 01100000b = 11111100b
-10111100b | 01100001b = 11111101b
-10111100b | 01100010b = 11111110b
-10111100b | 01100011b = 11111111b
-10111100b | 01100100b = 11111100b
-10111100b | 01100101b = 11111101b
-10111100b | 01100110b = 11111110b
-10111100b | 01100111b = 11111111b
-10111100b | 01101000b = 11111100b
-10111100b | 01101001b = 11111101b
-10111100b | 01101010b = 11111110b
-10111100b | 01101011b = 11111111b
-10111100b | 01101100b = 11111100b
-10111100b | 01101101b = 11111101b
-10111100b | 01101110b = 11111110b
-10111100b | 01101111b = 11111111b
-10111100b | 01110000b = 11111100b
-10111100b | 01110001b = 11111101b
-10111100b | 01110010b = 11111110b
-10111100b | 01110011b = 11111111b
-10111100b | 01110100b = 11111100b
-10111100b | 01110101b = 11111101b
-10111100b | 01110110b = 11111110b
-10111100b | 01110111b = 11111111b
-10111100b | 01111000b = 11111100b
-10111100b | 01111001b = 11111101b
-10111100b | 01111010b = 11111110b
-10111100b | 01111011b = 11111111b
-10111100b | 01111100b = 11111100b
-10111100b | 01111101b = 11111101b
-10111100b | 01111110b = 11111110b
-10111101b | 10000000b = 10111101b
-10111101b | 10000001b = 10111101b
-10111101b | 10000010b = 10111111b
-10111101b | 10000011b = 10111111b
-10111101b | 10000100b = 10111101b
-10111101b | 10000101b = 10111101b
-10111101b | 10000110b = 10111111b
-10111101b | 10000111b = 10111111b
-10111101b | 10001000b = 10111101b
-10111101b | 10001001b = 10111101b
-10111101b | 10001010b = 10111111b
-10111101b | 10001011b = 10111111b
-10111101b | 10001100b = 10111101b
-10111101b | 10001101b = 10111101b
-10111101b | 10001110b = 10111111b
-10111101b | 10001111b = 10111111b
-10111101b | 10010000b = 10111101b
-10111101b | 10010001b = 10111101b
-10111101b | 10010010b = 10111111b
-10111101b | 10010011b = 10111111b
-10111101b | 10010100b = 10111101b
-10111101b | 10010101b = 10111101b
-10111101b | 10010110b = 10111111b
-10111101b | 10010111b = 10111111b
-10111101b | 10011000b = 10111101b
-10111101b | 10011001b = 10111101b
-10111101b | 10011010b = 10111111b
-10111101b | 10011011b = 10111111b
-10111101b | 10011100b = 10111101b
-10111101b | 10011101b = 10111101b
-10111101b | 10011110b = 10111111b
-10111101b | 10011111b = 10111111b
-10111101b | 10100000b = 10111101b
-10111101b | 10100001b = 10111101b
-10111101b | 10100010b = 10111111b
-10111101b | 10100011b = 10111111b
-10111101b | 10100100b = 10111101b
-10111101b | 10100101b = 10111101b
-10111101b | 10100110b = 10111111b
-10111101b | 10100111b = 10111111b
-10111101b | 10101000b = 10111101b
-10111101b | 10101001b = 10111101b
-10111101b | 10101010b = 10111111b
-10111101b | 10101011b = 10111111b
-10111101b | 10101100b = 10111101b
-10111101b | 10101101b = 10111101b
-10111101b | 10101110b = 10111111b
-10111101b | 10101111b = 10111111b
-10111101b | 10110000b = 10111101b
-10111101b | 10110001b = 10111101b
-10111101b | 10110010b = 10111111b
-10111101b | 10110011b = 10111111b
-10111101b | 10110100b = 10111101b
-10111101b | 10110101b = 10111101b
-10111101b | 10110110b = 10111111b
-10111101b | 10110111b = 10111111b
-10111101b | 10111000b = 10111101b
-10111101b | 10111001b = 10111101b
-10111101b | 10111010b = 10111111b
-10111101b | 10111011b = 10111111b
-10111101b | 10111100b = 10111101b
-10111101b | 10111101b = 10111101b
-10111101b | 10111110b = 10111111b
-10111101b | 10111111b = 10111111b
-10111101b | 11000000b = 11111101b
-10111101b | 11000001b = 11111101b
-10111101b | 11000010b = 11111111b
-10111101b | 11000011b = 11111111b
-10111101b | 11000100b = 11111101b
-10111101b | 11000101b = 11111101b
-10111101b | 11000110b = 11111111b
-10111101b | 11000111b = 11111111b
-10111101b | 11001000b = 11111101b
-10111101b | 11001001b = 11111101b
-10111101b | 11001010b = 11111111b
-10111101b | 11001011b = 11111111b
-10111101b | 11001100b = 11111101b
-10111101b | 11001101b = 11111101b
-10111101b | 11001110b = 11111111b
-10111101b | 11001111b = 11111111b
-10111101b | 11010000b = 11111101b
-10111101b | 11010001b = 11111101b
-10111101b | 11010010b = 11111111b
-10111101b | 11010011b = 11111111b
-10111101b | 11010100b = 11111101b
-10111101b | 11010101b = 11111101b
-10111101b | 11010110b = 11111111b
-10111101b | 11010111b = 11111111b
-10111101b | 11011000b = 11111101b
-10111101b | 11011001b = 11111101b
-10111101b | 11011010b = 11111111b
-10111101b | 11011011b = 11111111b
-10111101b | 11011100b = 11111101b
-10111101b | 11011101b = 11111101b
-10111101b | 11011110b = 11111111b
-10111101b | 11011111b = 11111111b
-10111101b | 11100000b = 11111101b
-10111101b | 11100001b = 11111101b
-10111101b | 11100010b = 11111111b
-10111101b | 11100011b = 11111111b
-10111101b | 11100100b = 11111101b
-10111101b | 11100101b = 11111101b
-10111101b | 11100110b = 11111111b
-10111101b | 11100111b = 11111111b
-10111101b | 11101000b = 11111101b
-10111101b | 11101001b = 11111101b
-10111101b | 11101010b = 11111111b
-10111101b | 11101011b = 11111111b
-10111101b | 11101100b = 11111101b
-10111101b | 11101101b = 11111101b
-10111101b | 11101110b = 11111111b
-10111101b | 11101111b = 11111111b
-10111101b | 11110000b = 11111101b
-10111101b | 11110001b = 11111101b
-10111101b | 11110010b = 11111111b
-10111101b | 11110011b = 11111111b
-10111101b | 11110100b = 11111101b
-10111101b | 11110101b = 11111101b
-10111101b | 11110110b = 11111111b
-10111101b | 11110111b = 11111111b
-10111101b | 11111000b = 11111101b
-10111101b | 11111001b = 11111101b
-10111101b | 11111010b = 11111111b
-10111101b | 11111011b = 11111111b
-10111101b | 11111100b = 11111101b
-10111101b | 11111101b = 11111101b
-10111101b | 11111110b = 11111111b
-10111101b | 11111111b = 11111111b
-10111101b | 00000000b = 10111101b
-10111101b | 00000001b = 10111101b
-10111101b | 00000010b = 10111111b
-10111101b | 00000011b = 10111111b
-10111101b | 00000100b = 10111101b
-10111101b | 00000101b = 10111101b
-10111101b | 00000110b = 10111111b
-10111101b | 00000111b = 10111111b
-10111101b | 00001000b = 10111101b
-10111101b | 00001001b = 10111101b
-10111101b | 00001010b = 10111111b
-10111101b | 00001011b = 10111111b
-10111101b | 00001100b = 10111101b
-10111101b | 00001101b = 10111101b
-10111101b | 00001110b = 10111111b
-10111101b | 00001111b = 10111111b
-10111101b | 00010000b = 10111101b
-10111101b | 00010001b = 10111101b
-10111101b | 00010010b = 10111111b
-10111101b | 00010011b = 10111111b
-10111101b | 00010100b = 10111101b
-10111101b | 00010101b = 10111101b
-10111101b | 00010110b = 10111111b
-10111101b | 00010111b = 10111111b
-10111101b | 00011000b = 10111101b
-10111101b | 00011001b = 10111101b
-10111101b | 00011010b = 10111111b
-10111101b | 00011011b = 10111111b
-10111101b | 00011100b = 10111101b
-10111101b | 00011101b = 10111101b
-10111101b | 00011110b = 10111111b
-10111101b | 00011111b = 10111111b
-10111101b | 00100000b = 10111101b
-10111101b | 00100001b = 10111101b
-10111101b | 00100010b = 10111111b
-10111101b | 00100011b = 10111111b
-10111101b | 00100100b = 10111101b
-10111101b | 00100101b = 10111101b
-10111101b | 00100110b = 10111111b
-10111101b | 00100111b = 10111111b
-10111101b | 00101000b = 10111101b
-10111101b | 00101001b = 10111101b
-10111101b | 00101010b = 10111111b
-10111101b | 00101011b = 10111111b
-10111101b | 00101100b = 10111101b
-10111101b | 00101101b = 10111101b
-10111101b | 00101110b = 10111111b
-10111101b | 00101111b = 10111111b
-10111101b | 00110000b = 10111101b
-10111101b | 00110001b = 10111101b
-10111101b | 00110010b = 10111111b
-10111101b | 00110011b = 10111111b
-10111101b | 00110100b = 10111101b
-10111101b | 00110101b = 10111101b
-10111101b | 00110110b = 10111111b
-10111101b | 00110111b = 10111111b
-10111101b | 00111000b = 10111101b
-10111101b | 00111001b = 10111101b
-10111101b | 00111010b = 10111111b
-10111101b | 00111011b = 10111111b
-10111101b | 00111100b = 10111101b
-10111101b | 00111101b = 10111101b
-10111101b | 00111110b = 10111111b
-10111101b | 00111111b = 10111111b
-10111101b | 01000000b = 11111101b
-10111101b | 01000001b = 11111101b
-10111101b | 01000010b = 11111111b
-10111101b | 01000011b = 11111111b
-10111101b | 01000100b = 11111101b
-10111101b | 01000101b = 11111101b
-10111101b | 01000110b = 11111111b
-10111101b | 01000111b = 11111111b
-10111101b | 01001000b = 11111101b
-10111101b | 01001001b = 11111101b
-10111101b | 01001010b = 11111111b
-10111101b | 01001011b = 11111111b
-10111101b | 01001100b = 11111101b
-10111101b | 01001101b = 11111101b
-10111101b | 01001110b = 11111111b
-10111101b | 01001111b = 11111111b
-10111101b | 01010000b = 11111101b
-10111101b | 01010001b = 11111101b
-10111101b | 01010010b = 11111111b
-10111101b | 01010011b = 11111111b
-10111101b | 01010100b = 11111101b
-10111101b | 01010101b = 11111101b
-10111101b | 01010110b = 11111111b
-10111101b | 01010111b = 11111111b
-10111101b | 01011000b = 11111101b
-10111101b | 01011001b = 11111101b
-10111101b | 01011010b = 11111111b
-10111101b | 01011011b = 11111111b
-10111101b | 01011100b = 11111101b
-10111101b | 01011101b = 11111101b
-10111101b | 01011110b = 11111111b
-10111101b | 01011111b = 11111111b
-10111101b | 01100000b = 11111101b
-10111101b | 01100001b = 11111101b
-10111101b | 01100010b = 11111111b
-10111101b | 01100011b = 11111111b
-10111101b | 01100100b = 11111101b
-10111101b | 01100101b = 11111101b
-10111101b | 01100110b = 11111111b
-10111101b | 01100111b = 11111111b
-10111101b | 01101000b = 11111101b
-10111101b | 01101001b = 11111101b
-10111101b | 01101010b = 11111111b
-10111101b | 01101011b = 11111111b
-10111101b | 01101100b = 11111101b
-10111101b | 01101101b = 11111101b
-10111101b | 01101110b = 11111111b
-10111101b | 01101111b = 11111111b
-10111101b | 01110000b = 11111101b
-10111101b | 01110001b = 11111101b
-10111101b | 01110010b = 11111111b
-10111101b | 01110011b = 11111111b
-10111101b | 01110100b = 11111101b
-10111101b | 01110101b = 11111101b
-10111101b | 01110110b = 11111111b
-10111101b | 01110111b = 11111111b
-10111101b | 01111000b = 11111101b
-10111101b | 01111001b = 11111101b
-10111101b | 01111010b = 11111111b
-10111101b | 01111011b = 11111111b
-10111101b | 01111100b = 11111101b
-10111101b | 01111101b = 11111101b
-10111101b | 01111110b = 11111111b
-10111110b | 10000000b = 10111110b
-10111110b | 10000001b = 10111111b
-10111110b | 10000010b = 10111110b
-10111110b | 10000011b = 10111111b
-10111110b | 10000100b = 10111110b
-10111110b | 10000101b = 10111111b
-10111110b | 10000110b = 10111110b
-10111110b | 10000111b = 10111111b
-10111110b | 10001000b = 10111110b
-10111110b | 10001001b = 10111111b
-10111110b | 10001010b = 10111110b
-10111110b | 10001011b = 10111111b
-10111110b | 10001100b = 10111110b
-10111110b | 10001101b = 10111111b
-10111110b | 10001110b = 10111110b
-10111110b | 10001111b = 10111111b
-10111110b | 10010000b = 10111110b
-10111110b | 10010001b = 10111111b
-10111110b | 10010010b = 10111110b
-10111110b | 10010011b = 10111111b
-10111110b | 10010100b = 10111110b
-10111110b | 10010101b = 10111111b
-10111110b | 10010110b = 10111110b
-10111110b | 10010111b = 10111111b
-10111110b | 10011000b = 10111110b
-10111110b | 10011001b = 10111111b
-10111110b | 10011010b = 10111110b
-10111110b | 10011011b = 10111111b
-10111110b | 10011100b = 10111110b
-10111110b | 10011101b = 10111111b
-10111110b | 10011110b = 10111110b
-10111110b | 10011111b = 10111111b
-10111110b | 10100000b = 10111110b
-10111110b | 10100001b = 10111111b
-10111110b | 10100010b = 10111110b
-10111110b | 10100011b = 10111111b
-10111110b | 10100100b = 10111110b
-10111110b | 10100101b = 10111111b
-10111110b | 10100110b = 10111110b
-10111110b | 10100111b = 10111111b
-10111110b | 10101000b = 10111110b
-10111110b | 10101001b = 10111111b
-10111110b | 10101010b = 10111110b
-10111110b | 10101011b = 10111111b
-10111110b | 10101100b = 10111110b
-10111110b | 10101101b = 10111111b
-10111110b | 10101110b = 10111110b
-10111110b | 10101111b = 10111111b
-10111110b | 10110000b = 10111110b
-10111110b | 10110001b = 10111111b
-10111110b | 10110010b = 10111110b
-10111110b | 10110011b = 10111111b
-10111110b | 10110100b = 10111110b
-10111110b | 10110101b = 10111111b
-10111110b | 10110110b = 10111110b
-10111110b | 10110111b = 10111111b
-10111110b | 10111000b = 10111110b
-10111110b | 10111001b = 10111111b
-10111110b | 10111010b = 10111110b
-10111110b | 10111011b = 10111111b
-10111110b | 10111100b = 10111110b
-10111110b | 10111101b = 10111111b
-10111110b | 10111110b = 10111110b
-10111110b | 10111111b = 10111111b
-10111110b | 11000000b = 11111110b
-10111110b | 11000001b = 11111111b
-10111110b | 11000010b = 11111110b
-10111110b | 11000011b = 11111111b
-10111110b | 11000100b = 11111110b
-10111110b | 11000101b = 11111111b
-10111110b | 11000110b = 11111110b
-10111110b | 11000111b = 11111111b
-10111110b | 11001000b = 11111110b
-10111110b | 11001001b = 11111111b
-10111110b | 11001010b = 11111110b
-10111110b | 11001011b = 11111111b
-10111110b | 11001100b = 11111110b
-10111110b | 11001101b = 11111111b
-10111110b | 11001110b = 11111110b
-10111110b | 11001111b = 11111111b
-10111110b | 11010000b = 11111110b
-10111110b | 11010001b = 11111111b
-10111110b | 11010010b = 11111110b
-10111110b | 11010011b = 11111111b
-10111110b | 11010100b = 11111110b
-10111110b | 11010101b = 11111111b
-10111110b | 11010110b = 11111110b
-10111110b | 11010111b = 11111111b
-10111110b | 11011000b = 11111110b
-10111110b | 11011001b = 11111111b
-10111110b | 11011010b = 11111110b
-10111110b | 11011011b = 11111111b
-10111110b | 11011100b = 11111110b
-10111110b | 11011101b = 11111111b
-10111110b | 11011110b = 11111110b
-10111110b | 11011111b = 11111111b
-10111110b | 11100000b = 11111110b
-10111110b | 11100001b = 11111111b
-10111110b | 11100010b = 11111110b
-10111110b | 11100011b = 11111111b
-10111110b | 11100100b = 11111110b
-10111110b | 11100101b = 11111111b
-10111110b | 11100110b = 11111110b
-10111110b | 11100111b = 11111111b
-10111110b | 11101000b = 11111110b
-10111110b | 11101001b = 11111111b
-10111110b | 11101010b = 11111110b
-10111110b | 11101011b = 11111111b
-10111110b | 11101100b = 11111110b
-10111110b | 11101101b = 11111111b
-10111110b | 11101110b = 11111110b
-10111110b | 11101111b = 11111111b
-10111110b | 11110000b = 11111110b
-10111110b | 11110001b = 11111111b
-10111110b | 11110010b = 11111110b
-10111110b | 11110011b = 11111111b
-10111110b | 11110100b = 11111110b
-10111110b | 11110101b = 11111111b
-10111110b | 11110110b = 11111110b
-10111110b | 11110111b = 11111111b
-10111110b | 11111000b = 11111110b
-10111110b | 11111001b = 11111111b
-10111110b | 11111010b = 11111110b
-10111110b | 11111011b = 11111111b
-10111110b | 11111100b = 11111110b
-10111110b | 11111101b = 11111111b
-10111110b | 11111110b = 11111110b
-10111110b | 11111111b = 11111111b
-10111110b | 00000000b = 10111110b
-10111110b | 00000001b = 10111111b
-10111110b | 00000010b = 10111110b
-10111110b | 00000011b = 10111111b
-10111110b | 00000100b = 10111110b
-10111110b | 00000101b = 10111111b
-10111110b | 00000110b = 10111110b
-10111110b | 00000111b = 10111111b
-10111110b | 00001000b = 10111110b
-10111110b | 00001001b = 10111111b
-10111110b | 00001010b = 10111110b
-10111110b | 00001011b = 10111111b
-10111110b | 00001100b = 10111110b
-10111110b | 00001101b = 10111111b
-10111110b | 00001110b = 10111110b
-10111110b | 00001111b = 10111111b
-10111110b | 00010000b = 10111110b
-10111110b | 00010001b = 10111111b
-10111110b | 00010010b = 10111110b
-10111110b | 00010011b = 10111111b
-10111110b | 00010100b = 10111110b
-10111110b | 00010101b = 10111111b
-10111110b | 00010110b = 10111110b
-10111110b | 00010111b = 10111111b
-10111110b | 00011000b = 10111110b
-10111110b | 00011001b = 10111111b
-10111110b | 00011010b = 10111110b
-10111110b | 00011011b = 10111111b
-10111110b | 00011100b = 10111110b
-10111110b | 00011101b = 10111111b
-10111110b | 00011110b = 10111110b
-10111110b | 00011111b = 10111111b
-10111110b | 00100000b = 10111110b
-10111110b | 00100001b = 10111111b
-10111110b | 00100010b = 10111110b
-10111110b | 00100011b = 10111111b
-10111110b | 00100100b = 10111110b
-10111110b | 00100101b = 10111111b
-10111110b | 00100110b = 10111110b
-10111110b | 00100111b = 10111111b
-10111110b | 00101000b = 10111110b
-10111110b | 00101001b = 10111111b
-10111110b | 00101010b = 10111110b
-10111110b | 00101011b = 10111111b
-10111110b | 00101100b = 10111110b
-10111110b | 00101101b = 10111111b
-10111110b | 00101110b = 10111110b
-10111110b | 00101111b = 10111111b
-10111110b | 00110000b = 10111110b
-10111110b | 00110001b = 10111111b
-10111110b | 00110010b = 10111110b
-10111110b | 00110011b = 10111111b
-10111110b | 00110100b = 10111110b
-10111110b | 00110101b = 10111111b
-10111110b | 00110110b = 10111110b
-10111110b | 00110111b = 10111111b
-10111110b | 00111000b = 10111110b
-10111110b | 00111001b = 10111111b
-10111110b | 00111010b = 10111110b
-10111110b | 00111011b = 10111111b
-10111110b | 00111100b = 10111110b
-10111110b | 00111101b = 10111111b
-10111110b | 00111110b = 10111110b
-10111110b | 00111111b = 10111111b
-10111110b | 01000000b = 11111110b
-10111110b | 01000001b = 11111111b
-10111110b | 01000010b = 11111110b
-10111110b | 01000011b = 11111111b
-10111110b | 01000100b = 11111110b
-10111110b | 01000101b = 11111111b
-10111110b | 01000110b = 11111110b
-10111110b | 01000111b = 11111111b
-10111110b | 01001000b = 11111110b
-10111110b | 01001001b = 11111111b
-10111110b | 01001010b = 11111110b
-10111110b | 01001011b = 11111111b
-10111110b | 01001100b = 11111110b
-10111110b | 01001101b = 11111111b
-10111110b | 01001110b = 11111110b
-10111110b | 01001111b = 11111111b
-10111110b | 01010000b = 11111110b
-10111110b | 01010001b = 11111111b
-10111110b | 01010010b = 11111110b
-10111110b | 01010011b = 11111111b
-10111110b | 01010100b = 11111110b
-10111110b | 01010101b = 11111111b
-10111110b | 01010110b = 11111110b
-10111110b | 01010111b = 11111111b
-10111110b | 01011000b = 11111110b
-10111110b | 01011001b = 11111111b
-10111110b | 01011010b = 11111110b
-10111110b | 01011011b = 11111111b
-10111110b | 01011100b = 11111110b
-10111110b | 01011101b = 11111111b
-10111110b | 01011110b = 11111110b
-10111110b | 01011111b = 11111111b
-10111110b | 01100000b = 11111110b
-10111110b | 01100001b = 11111111b
-10111110b | 01100010b = 11111110b
-10111110b | 01100011b = 11111111b
-10111110b | 01100100b = 11111110b
-10111110b | 01100101b = 11111111b
-10111110b | 01100110b = 11111110b
-10111110b | 01100111b = 11111111b
-10111110b | 01101000b = 11111110b
-10111110b | 01101001b = 11111111b
-10111110b | 01101010b = 11111110b
-10111110b | 01101011b = 11111111b
-10111110b | 01101100b = 11111110b
-10111110b | 01101101b = 11111111b
-10111110b | 01101110b = 11111110b
-10111110b | 01101111b = 11111111b
-10111110b | 01110000b = 11111110b
-10111110b | 01110001b = 11111111b
-10111110b | 01110010b = 11111110b
-10111110b | 01110011b = 11111111b
-10111110b | 01110100b = 11111110b
-10111110b | 01110101b = 11111111b
-10111110b | 01110110b = 11111110b
-10111110b | 01110111b = 11111111b
-10111110b | 01111000b = 11111110b
-10111110b | 01111001b = 11111111b
-10111110b | 01111010b = 11111110b
-10111110b | 01111011b = 11111111b
-10111110b | 01111100b = 11111110b
-10111110b | 01111101b = 11111111b
-10111110b | 01111110b = 11111110b
-10111111b | 10000000b = 10111111b
-10111111b | 10000001b = 10111111b
-10111111b | 10000010b = 10111111b
-10111111b | 10000011b = 10111111b
-10111111b | 10000100b = 10111111b
-10111111b | 10000101b = 10111111b
-10111111b | 10000110b = 10111111b
-10111111b | 10000111b = 10111111b
-10111111b | 10001000b = 10111111b
-10111111b | 10001001b = 10111111b
-10111111b | 10001010b = 10111111b
-10111111b | 10001011b = 10111111b
-10111111b | 10001100b = 10111111b
-10111111b | 10001101b = 10111111b
-10111111b | 10001110b = 10111111b
-10111111b | 10001111b = 10111111b
-10111111b | 10010000b = 10111111b
-10111111b | 10010001b = 10111111b
-10111111b | 10010010b = 10111111b
-10111111b | 10010011b = 10111111b
-10111111b | 10010100b = 10111111b
-10111111b | 10010101b = 10111111b
-10111111b | 10010110b = 10111111b
-10111111b | 10010111b = 10111111b
-10111111b | 10011000b = 10111111b
-10111111b | 10011001b = 10111111b
-10111111b | 10011010b = 10111111b
-10111111b | 10011011b = 10111111b
-10111111b | 10011100b = 10111111b
-10111111b | 10011101b = 10111111b
-10111111b | 10011110b = 10111111b
-10111111b | 10011111b = 10111111b
-10111111b | 10100000b = 10111111b
-10111111b | 10100001b = 10111111b
-10111111b | 10100010b = 10111111b
-10111111b | 10100011b = 10111111b
-10111111b | 10100100b = 10111111b
-10111111b | 10100101b = 10111111b
-10111111b | 10100110b = 10111111b
-10111111b | 10100111b = 10111111b
-10111111b | 10101000b = 10111111b
-10111111b | 10101001b = 10111111b
-10111111b | 10101010b = 10111111b
-10111111b | 10101011b = 10111111b
-10111111b | 10101100b = 10111111b
-10111111b | 10101101b = 10111111b
-10111111b | 10101110b = 10111111b
-10111111b | 10101111b = 10111111b
-10111111b | 10110000b = 10111111b
-10111111b | 10110001b = 10111111b
-10111111b | 10110010b = 10111111b
-10111111b | 10110011b = 10111111b
-10111111b | 10110100b = 10111111b
-10111111b | 10110101b = 10111111b
-10111111b | 10110110b = 10111111b
-10111111b | 10110111b = 10111111b
-10111111b | 10111000b = 10111111b
-10111111b | 10111001b = 10111111b
-10111111b | 10111010b = 10111111b
-10111111b | 10111011b = 10111111b
-10111111b | 10111100b = 10111111b
-10111111b | 10111101b = 10111111b
-10111111b | 10111110b = 10111111b
-10111111b | 10111111b = 10111111b
-10111111b | 11000000b = 11111111b
-10111111b | 11000001b = 11111111b
-10111111b | 11000010b = 11111111b
-10111111b | 11000011b = 11111111b
-10111111b | 11000100b = 11111111b
-10111111b | 11000101b = 11111111b
-10111111b | 11000110b = 11111111b
-10111111b | 11000111b = 11111111b
-10111111b | 11001000b = 11111111b
-10111111b | 11001001b = 11111111b
-10111111b | 11001010b = 11111111b
-10111111b | 11001011b = 11111111b
-10111111b | 11001100b = 11111111b
-10111111b | 11001101b = 11111111b
-10111111b | 11001110b = 11111111b
-10111111b | 11001111b = 11111111b
-10111111b | 11010000b = 11111111b
-10111111b | 11010001b = 11111111b
-10111111b | 11010010b = 11111111b
-10111111b | 11010011b = 11111111b
-10111111b | 11010100b = 11111111b
-10111111b | 11010101b = 11111111b
-10111111b | 11010110b = 11111111b
-10111111b | 11010111b = 11111111b
-10111111b | 11011000b = 11111111b
-10111111b | 11011001b = 11111111b
-10111111b | 11011010b = 11111111b
-10111111b | 11011011b = 11111111b
-10111111b | 11011100b = 11111111b
-10111111b | 11011101b = 11111111b
-10111111b | 11011110b = 11111111b
-10111111b | 11011111b = 11111111b
-10111111b | 11100000b = 11111111b
-10111111b | 11100001b = 11111111b
-10111111b | 11100010b = 11111111b
-10111111b | 11100011b = 11111111b
-10111111b | 11100100b = 11111111b
-10111111b | 11100101b = 11111111b
-10111111b | 11100110b = 11111111b
-10111111b | 11100111b = 11111111b
-10111111b | 11101000b = 11111111b
-10111111b | 11101001b = 11111111b
-10111111b | 11101010b = 11111111b
-10111111b | 11101011b = 11111111b
-10111111b | 11101100b = 11111111b
-10111111b | 11101101b = 11111111b
-10111111b | 11101110b = 11111111b
-10111111b | 11101111b = 11111111b
-10111111b | 11110000b = 11111111b
-10111111b | 11110001b = 11111111b
-10111111b | 11110010b = 11111111b
-10111111b | 11110011b = 11111111b
-10111111b | 11110100b = 11111111b
-10111111b | 11110101b = 11111111b
-10111111b | 11110110b = 11111111b
-10111111b | 11110111b = 11111111b
-10111111b | 11111000b = 11111111b
-10111111b | 11111001b = 11111111b
-10111111b | 11111010b = 11111111b
-10111111b | 11111011b = 11111111b
-10111111b | 11111100b = 11111111b
-10111111b | 11111101b = 11111111b
-10111111b | 11111110b = 11111111b
-10111111b | 11111111b = 11111111b
-10111111b | 00000000b = 10111111b
-10111111b | 00000001b = 10111111b
-10111111b | 00000010b = 10111111b
-10111111b | 00000011b = 10111111b
-10111111b | 00000100b = 10111111b
-10111111b | 00000101b = 10111111b
-10111111b | 00000110b = 10111111b
-10111111b | 00000111b = 10111111b
-10111111b | 00001000b = 10111111b
-10111111b | 00001001b = 10111111b
-10111111b | 00001010b = 10111111b
-10111111b | 00001011b = 10111111b
-10111111b | 00001100b = 10111111b
-10111111b | 00001101b = 10111111b
-10111111b | 00001110b = 10111111b
-10111111b | 00001111b = 10111111b
-10111111b | 00010000b = 10111111b
-10111111b | 00010001b = 10111111b
-10111111b | 00010010b = 10111111b
-10111111b | 00010011b = 10111111b
-10111111b | 00010100b = 10111111b
-10111111b | 00010101b = 10111111b
-10111111b | 00010110b = 10111111b
-10111111b | 00010111b = 10111111b
-10111111b | 00011000b = 10111111b
-10111111b | 00011001b = 10111111b
-10111111b | 00011010b = 10111111b
-10111111b | 00011011b = 10111111b
-10111111b | 00011100b = 10111111b
-10111111b | 00011101b = 10111111b
-10111111b | 00011110b = 10111111b
-10111111b | 00011111b = 10111111b
-10111111b | 00100000b = 10111111b
-10111111b | 00100001b = 10111111b
-10111111b | 00100010b = 10111111b
-10111111b | 00100011b = 10111111b
-10111111b | 00100100b = 10111111b
-10111111b | 00100101b = 10111111b
-10111111b | 00100110b = 10111111b
-10111111b | 00100111b = 10111111b
-10111111b | 00101000b = 10111111b
-10111111b | 00101001b = 10111111b
-10111111b | 00101010b = 10111111b
-10111111b | 00101011b = 10111111b
-10111111b | 00101100b = 10111111b
-10111111b | 00101101b = 10111111b
-10111111b | 00101110b = 10111111b
-10111111b | 00101111b = 10111111b
-10111111b | 00110000b = 10111111b
-10111111b | 00110001b = 10111111b
-10111111b | 00110010b = 10111111b
-10111111b | 00110011b = 10111111b
-10111111b | 00110100b = 10111111b
-10111111b | 00110101b = 10111111b
-10111111b | 00110110b = 10111111b
-10111111b | 00110111b = 10111111b
-10111111b | 00111000b = 10111111b
-10111111b | 00111001b = 10111111b
-10111111b | 00111010b = 10111111b
-10111111b | 00111011b = 10111111b
-10111111b | 00111100b = 10111111b
-10111111b | 00111101b = 10111111b
-10111111b | 00111110b = 10111111b
-10111111b | 00111111b = 10111111b
-10111111b | 01000000b = 11111111b
-10111111b | 01000001b = 11111111b
-10111111b | 01000010b = 11111111b
-10111111b | 01000011b = 11111111b
-10111111b | 01000100b = 11111111b
-10111111b | 01000101b = 11111111b
-10111111b | 01000110b = 11111111b
-10111111b | 01000111b = 11111111b
-10111111b | 01001000b = 11111111b
-10111111b | 01001001b = 11111111b
-10111111b | 01001010b = 11111111b
-10111111b | 01001011b = 11111111b
-10111111b | 01001100b = 11111111b
-10111111b | 01001101b = 11111111b
-10111111b | 01001110b = 11111111b
-10111111b | 01001111b = 11111111b
-10111111b | 01010000b = 11111111b
-10111111b | 01010001b = 11111111b
-10111111b | 01010010b = 11111111b
-10111111b | 01010011b = 11111111b
-10111111b | 01010100b = 11111111b
-10111111b | 01010101b = 11111111b
-10111111b | 01010110b = 11111111b
-10111111b | 01010111b = 11111111b
-10111111b | 01011000b = 11111111b
-10111111b | 01011001b = 11111111b
-10111111b | 01011010b = 11111111b
-10111111b | 01011011b = 11111111b
-10111111b | 01011100b = 11111111b
-10111111b | 01011101b = 11111111b
-10111111b | 01011110b = 11111111b
-10111111b | 01011111b = 11111111b
-10111111b | 01100000b = 11111111b
-10111111b | 01100001b = 11111111b
-10111111b | 01100010b = 11111111b
-10111111b | 01100011b = 11111111b
-10111111b | 01100100b = 11111111b
-10111111b | 01100101b = 11111111b
-10111111b | 01100110b = 11111111b
-10111111b | 01100111b = 11111111b
-10111111b | 01101000b = 11111111b
-10111111b | 01101001b = 11111111b
-10111111b | 01101010b = 11111111b
-10111111b | 01101011b = 11111111b
-10111111b | 01101100b = 11111111b
-10111111b | 01101101b = 11111111b
-10111111b | 01101110b = 11111111b
-10111111b | 01101111b = 11111111b
-10111111b | 01110000b = 11111111b
-10111111b | 01110001b = 11111111b
-10111111b | 01110010b = 11111111b
-10111111b | 01110011b = 11111111b
-10111111b | 01110100b = 11111111b
-10111111b | 01110101b = 11111111b
-10111111b | 01110110b = 11111111b
-10111111b | 01110111b = 11111111b
-10111111b | 01111000b = 11111111b
-10111111b | 01111001b = 11111111b
-10111111b | 01111010b = 11111111b
-10111111b | 01111011b = 11111111b
-10111111b | 01111100b = 11111111b
-10111111b | 01111101b = 11111111b
-10111111b | 01111110b = 11111111b
-11000000b | 10000000b = 11000000b
-11000000b | 10000001b = 11000001b
-11000000b | 10000010b = 11000010b
-11000000b | 10000011b = 11000011b
-11000000b | 10000100b = 11000100b
-11000000b | 10000101b = 11000101b
-11000000b | 10000110b = 11000110b
-11000000b | 10000111b = 11000111b
-11000000b | 10001000b = 11001000b
-11000000b | 10001001b = 11001001b
-11000000b | 10001010b = 11001010b
-11000000b | 10001011b = 11001011b
-11000000b | 10001100b = 11001100b
-11000000b | 10001101b = 11001101b
-11000000b | 10001110b = 11001110b
-11000000b | 10001111b = 11001111b
-11000000b | 10010000b = 11010000b
-11000000b | 10010001b = 11010001b
-11000000b | 10010010b = 11010010b
-11000000b | 10010011b = 11010011b
-11000000b | 10010100b = 11010100b
-11000000b | 10010101b = 11010101b
-11000000b | 10010110b = 11010110b
-11000000b | 10010111b = 11010111b
-11000000b | 10011000b = 11011000b
-11000000b | 10011001b = 11011001b
-11000000b | 10011010b = 11011010b
-11000000b | 10011011b = 11011011b
-11000000b | 10011100b = 11011100b
-11000000b | 10011101b = 11011101b
-11000000b | 10011110b = 11011110b
-11000000b | 10011111b = 11011111b
-11000000b | 10100000b = 11100000b
-11000000b | 10100001b = 11100001b
-11000000b | 10100010b = 11100010b
-11000000b | 10100011b = 11100011b
-11000000b | 10100100b = 11100100b
-11000000b | 10100101b = 11100101b
-11000000b | 10100110b = 11100110b
-11000000b | 10100111b = 11100111b
-11000000b | 10101000b = 11101000b
-11000000b | 10101001b = 11101001b
-11000000b | 10101010b = 11101010b
-11000000b | 10101011b = 11101011b
-11000000b | 10101100b = 11101100b
-11000000b | 10101101b = 11101101b
-11000000b | 10101110b = 11101110b
-11000000b | 10101111b = 11101111b
-11000000b | 10110000b = 11110000b
-11000000b | 10110001b = 11110001b
-11000000b | 10110010b = 11110010b
-11000000b | 10110011b = 11110011b
-11000000b | 10110100b = 11110100b
-11000000b | 10110101b = 11110101b
-11000000b | 10110110b = 11110110b
-11000000b | 10110111b = 11110111b
-11000000b | 10111000b = 11111000b
-11000000b | 10111001b = 11111001b
-11000000b | 10111010b = 11111010b
-11000000b | 10111011b = 11111011b
-11000000b | 10111100b = 11111100b
-11000000b | 10111101b = 11111101b
-11000000b | 10111110b = 11111110b
-11000000b | 10111111b = 11111111b
-11000000b | 11000000b = 11000000b
-11000000b | 11000001b = 11000001b
-11000000b | 11000010b = 11000010b
-11000000b | 11000011b = 11000011b
-11000000b | 11000100b = 11000100b
-11000000b | 11000101b = 11000101b
-11000000b | 11000110b = 11000110b
-11000000b | 11000111b = 11000111b
-11000000b | 11001000b = 11001000b
-11000000b | 11001001b = 11001001b
-11000000b | 11001010b = 11001010b
-11000000b | 11001011b = 11001011b
-11000000b | 11001100b = 11001100b
-11000000b | 11001101b = 11001101b
-11000000b | 11001110b = 11001110b
-11000000b | 11001111b = 11001111b
-11000000b | 11010000b = 11010000b
-11000000b | 11010001b = 11010001b
-11000000b | 11010010b = 11010010b
-11000000b | 11010011b = 11010011b
-11000000b | 11010100b = 11010100b
-11000000b | 11010101b = 11010101b
-11000000b | 11010110b = 11010110b
-11000000b | 11010111b = 11010111b
-11000000b | 11011000b = 11011000b
-11000000b | 11011001b = 11011001b
-11000000b | 11011010b = 11011010b
-11000000b | 11011011b = 11011011b
-11000000b | 11011100b = 11011100b
-11000000b | 11011101b = 11011101b
-11000000b | 11011110b = 11011110b
-11000000b | 11011111b = 11011111b
-11000000b | 11100000b = 11100000b
-11000000b | 11100001b = 11100001b
-11000000b | 11100010b = 11100010b
-11000000b | 11100011b = 11100011b
-11000000b | 11100100b = 11100100b
-11000000b | 11100101b = 11100101b
-11000000b | 11100110b = 11100110b
-11000000b | 11100111b = 11100111b
-11000000b | 11101000b = 11101000b
-11000000b | 11101001b = 11101001b
-11000000b | 11101010b = 11101010b
-11000000b | 11101011b = 11101011b
-11000000b | 11101100b = 11101100b
-11000000b | 11101101b = 11101101b
-11000000b | 11101110b = 11101110b
-11000000b | 11101111b = 11101111b
-11000000b | 11110000b = 11110000b
-11000000b | 11110001b = 11110001b
-11000000b | 11110010b = 11110010b
-11000000b | 11110011b = 11110011b
-11000000b | 11110100b = 11110100b
-11000000b | 11110101b = 11110101b
-11000000b | 11110110b = 11110110b
-11000000b | 11110111b = 11110111b
-11000000b | 11111000b = 11111000b
-11000000b | 11111001b = 11111001b
-11000000b | 11111010b = 11111010b
-11000000b | 11111011b = 11111011b
-11000000b | 11111100b = 11111100b
-11000000b | 11111101b = 11111101b
-11000000b | 11111110b = 11111110b
-11000000b | 11111111b = 11111111b
-11000000b | 00000000b = 11000000b
-11000000b | 00000001b = 11000001b
-11000000b | 00000010b = 11000010b
-11000000b | 00000011b = 11000011b
-11000000b | 00000100b = 11000100b
-11000000b | 00000101b = 11000101b
-11000000b | 00000110b = 11000110b
-11000000b | 00000111b = 11000111b
-11000000b | 00001000b = 11001000b
-11000000b | 00001001b = 11001001b
-11000000b | 00001010b = 11001010b
-11000000b | 00001011b = 11001011b
-11000000b | 00001100b = 11001100b
-11000000b | 00001101b = 11001101b
-11000000b | 00001110b = 11001110b
-11000000b | 00001111b = 11001111b
-11000000b | 00010000b = 11010000b
-11000000b | 00010001b = 11010001b
-11000000b | 00010010b = 11010010b
-11000000b | 00010011b = 11010011b
-11000000b | 00010100b = 11010100b
-11000000b | 00010101b = 11010101b
-11000000b | 00010110b = 11010110b
-11000000b | 00010111b = 11010111b
-11000000b | 00011000b = 11011000b
-11000000b | 00011001b = 11011001b
-11000000b | 00011010b = 11011010b
-11000000b | 00011011b = 11011011b
-11000000b | 00011100b = 11011100b
-11000000b | 00011101b = 11011101b
-11000000b | 00011110b = 11011110b
-11000000b | 00011111b = 11011111b
-11000000b | 00100000b = 11100000b
-11000000b | 00100001b = 11100001b
-11000000b | 00100010b = 11100010b
-11000000b | 00100011b = 11100011b
-11000000b | 00100100b = 11100100b
-11000000b | 00100101b = 11100101b
-11000000b | 00100110b = 11100110b
-11000000b | 00100111b = 11100111b
-11000000b | 00101000b = 11101000b
-11000000b | 00101001b = 11101001b
-11000000b | 00101010b = 11101010b
-11000000b | 00101011b = 11101011b
-11000000b | 00101100b = 11101100b
-11000000b | 00101101b = 11101101b
-11000000b | 00101110b = 11101110b
-11000000b | 00101111b = 11101111b
-11000000b | 00110000b = 11110000b
-11000000b | 00110001b = 11110001b
-11000000b | 00110010b = 11110010b
-11000000b | 00110011b = 11110011b
-11000000b | 00110100b = 11110100b
-11000000b | 00110101b = 11110101b
-11000000b | 00110110b = 11110110b
-11000000b | 00110111b = 11110111b
-11000000b | 00111000b = 11111000b
-11000000b | 00111001b = 11111001b
-11000000b | 00111010b = 11111010b
-11000000b | 00111011b = 11111011b
-11000000b | 00111100b = 11111100b
-11000000b | 00111101b = 11111101b
-11000000b | 00111110b = 11111110b
-11000000b | 00111111b = 11111111b
-11000000b | 01000000b = 11000000b
-11000000b | 01000001b = 11000001b
-11000000b | 01000010b = 11000010b
-11000000b | 01000011b = 11000011b
-11000000b | 01000100b = 11000100b
-11000000b | 01000101b = 11000101b
-11000000b | 01000110b = 11000110b
-11000000b | 01000111b = 11000111b
-11000000b | 01001000b = 11001000b
-11000000b | 01001001b = 11001001b
-11000000b | 01001010b = 11001010b
-11000000b | 01001011b = 11001011b
-11000000b | 01001100b = 11001100b
-11000000b | 01001101b = 11001101b
-11000000b | 01001110b = 11001110b
-11000000b | 01001111b = 11001111b
-11000000b | 01010000b = 11010000b
-11000000b | 01010001b = 11010001b
-11000000b | 01010010b = 11010010b
-11000000b | 01010011b = 11010011b
-11000000b | 01010100b = 11010100b
-11000000b | 01010101b = 11010101b
-11000000b | 01010110b = 11010110b
-11000000b | 01010111b = 11010111b
-11000000b | 01011000b = 11011000b
-11000000b | 01011001b = 11011001b
-11000000b | 01011010b = 11011010b
-11000000b | 01011011b = 11011011b
-11000000b | 01011100b = 11011100b
-11000000b | 01011101b = 11011101b
-11000000b | 01011110b = 11011110b
-11000000b | 01011111b = 11011111b
-11000000b | 01100000b = 11100000b
-11000000b | 01100001b = 11100001b
-11000000b | 01100010b = 11100010b
-11000000b | 01100011b = 11100011b
-11000000b | 01100100b = 11100100b
-11000000b | 01100101b = 11100101b
-11000000b | 01100110b = 11100110b
-11000000b | 01100111b = 11100111b
-11000000b | 01101000b = 11101000b
-11000000b | 01101001b = 11101001b
-11000000b | 01101010b = 11101010b
-11000000b | 01101011b = 11101011b
-11000000b | 01101100b = 11101100b
-11000000b | 01101101b = 11101101b
-11000000b | 01101110b = 11101110b
-11000000b | 01101111b = 11101111b
-11000000b | 01110000b = 11110000b
-11000000b | 01110001b = 11110001b
-11000000b | 01110010b = 11110010b
-11000000b | 01110011b = 11110011b
-11000000b | 01110100b = 11110100b
-11000000b | 01110101b = 11110101b
-11000000b | 01110110b = 11110110b
-11000000b | 01110111b = 11110111b
-11000000b | 01111000b = 11111000b
-11000000b | 01111001b = 11111001b
-11000000b | 01111010b = 11111010b
-11000000b | 01111011b = 11111011b
-11000000b | 01111100b = 11111100b
-11000000b | 01111101b = 11111101b
-11000000b | 01111110b = 11111110b
-11000001b | 10000000b = 11000001b
-11000001b | 10000001b = 11000001b
-11000001b | 10000010b = 11000011b
-11000001b | 10000011b = 11000011b
-11000001b | 10000100b = 11000101b
-11000001b | 10000101b = 11000101b
-11000001b | 10000110b = 11000111b
-11000001b | 10000111b = 11000111b
-11000001b | 10001000b = 11001001b
-11000001b | 10001001b = 11001001b
-11000001b | 10001010b = 11001011b
-11000001b | 10001011b = 11001011b
-11000001b | 10001100b = 11001101b
-11000001b | 10001101b = 11001101b
-11000001b | 10001110b = 11001111b
-11000001b | 10001111b = 11001111b
-11000001b | 10010000b = 11010001b
-11000001b | 10010001b = 11010001b
-11000001b | 10010010b = 11010011b
-11000001b | 10010011b = 11010011b
-11000001b | 10010100b = 11010101b
-11000001b | 10010101b = 11010101b
-11000001b | 10010110b = 11010111b
-11000001b | 10010111b = 11010111b
-11000001b | 10011000b = 11011001b
-11000001b | 10011001b = 11011001b
-11000001b | 10011010b = 11011011b
-11000001b | 10011011b = 11011011b
-11000001b | 10011100b = 11011101b
-11000001b | 10011101b = 11011101b
-11000001b | 10011110b = 11011111b
-11000001b | 10011111b = 11011111b
-11000001b | 10100000b = 11100001b
-11000001b | 10100001b = 11100001b
-11000001b | 10100010b = 11100011b
-11000001b | 10100011b = 11100011b
-11000001b | 10100100b = 11100101b
-11000001b | 10100101b = 11100101b
-11000001b | 10100110b = 11100111b
-11000001b | 10100111b = 11100111b
-11000001b | 10101000b = 11101001b
-11000001b | 10101001b = 11101001b
-11000001b | 10101010b = 11101011b
-11000001b | 10101011b = 11101011b
-11000001b | 10101100b = 11101101b
-11000001b | 10101101b = 11101101b
-11000001b | 10101110b = 11101111b
-11000001b | 10101111b = 11101111b
-11000001b | 10110000b = 11110001b
-11000001b | 10110001b = 11110001b
-11000001b | 10110010b = 11110011b
-11000001b | 10110011b = 11110011b
-11000001b | 10110100b = 11110101b
-11000001b | 10110101b = 11110101b
-11000001b | 10110110b = 11110111b
-11000001b | 10110111b = 11110111b
-11000001b | 10111000b = 11111001b
-11000001b | 10111001b = 11111001b
-11000001b | 10111010b = 11111011b
-11000001b | 10111011b = 11111011b
-11000001b | 10111100b = 11111101b
-11000001b | 10111101b = 11111101b
-11000001b | 10111110b = 11111111b
-11000001b | 10111111b = 11111111b
-11000001b | 11000000b = 11000001b
-11000001b | 11000001b = 11000001b
-11000001b | 11000010b = 11000011b
-11000001b | 11000011b = 11000011b
-11000001b | 11000100b = 11000101b
-11000001b | 11000101b = 11000101b
-11000001b | 11000110b = 11000111b
-11000001b | 11000111b = 11000111b
-11000001b | 11001000b = 11001001b
-11000001b | 11001001b = 11001001b
-11000001b | 11001010b = 11001011b
-11000001b | 11001011b = 11001011b
-11000001b | 11001100b = 11001101b
-11000001b | 11001101b = 11001101b
-11000001b | 11001110b = 11001111b
-11000001b | 11001111b = 11001111b
-11000001b | 11010000b = 11010001b
-11000001b | 11010001b = 11010001b
-11000001b | 11010010b = 11010011b
-11000001b | 11010011b = 11010011b
-11000001b | 11010100b = 11010101b
-11000001b | 11010101b = 11010101b
-11000001b | 11010110b = 11010111b
-11000001b | 11010111b = 11010111b
-11000001b | 11011000b = 11011001b
-11000001b | 11011001b = 11011001b
-11000001b | 11011010b = 11011011b
-11000001b | 11011011b = 11011011b
-11000001b | 11011100b = 11011101b
-11000001b | 11011101b = 11011101b
-11000001b | 11011110b = 11011111b
-11000001b | 11011111b = 11011111b
-11000001b | 11100000b = 11100001b
-11000001b | 11100001b = 11100001b
-11000001b | 11100010b = 11100011b
-11000001b | 11100011b = 11100011b
-11000001b | 11100100b = 11100101b
-11000001b | 11100101b = 11100101b
-11000001b | 11100110b = 11100111b
-11000001b | 11100111b = 11100111b
-11000001b | 11101000b = 11101001b
-11000001b | 11101001b = 11101001b
-11000001b | 11101010b = 11101011b
-11000001b | 11101011b = 11101011b
-11000001b | 11101100b = 11101101b
-11000001b | 11101101b = 11101101b
-11000001b | 11101110b = 11101111b
-11000001b | 11101111b = 11101111b
-11000001b | 11110000b = 11110001b
-11000001b | 11110001b = 11110001b
-11000001b | 11110010b = 11110011b
-11000001b | 11110011b = 11110011b
-11000001b | 11110100b = 11110101b
-11000001b | 11110101b = 11110101b
-11000001b | 11110110b = 11110111b
-11000001b | 11110111b = 11110111b
-11000001b | 11111000b = 11111001b
-11000001b | 11111001b = 11111001b
-11000001b | 11111010b = 11111011b
-11000001b | 11111011b = 11111011b
-11000001b | 11111100b = 11111101b
-11000001b | 11111101b = 11111101b
-11000001b | 11111110b = 11111111b
-11000001b | 11111111b = 11111111b
-11000001b | 00000000b = 11000001b
-11000001b | 00000001b = 11000001b
-11000001b | 00000010b = 11000011b
-11000001b | 00000011b = 11000011b
-11000001b | 00000100b = 11000101b
-11000001b | 00000101b = 11000101b
-11000001b | 00000110b = 11000111b
-11000001b | 00000111b = 11000111b
-11000001b | 00001000b = 11001001b
-11000001b | 00001001b = 11001001b
-11000001b | 00001010b = 11001011b
-11000001b | 00001011b = 11001011b
-11000001b | 00001100b = 11001101b
-11000001b | 00001101b = 11001101b
-11000001b | 00001110b = 11001111b
-11000001b | 00001111b = 11001111b
-11000001b | 00010000b = 11010001b
-11000001b | 00010001b = 11010001b
-11000001b | 00010010b = 11010011b
-11000001b | 00010011b = 11010011b
-11000001b | 00010100b = 11010101b
-11000001b | 00010101b = 11010101b
-11000001b | 00010110b = 11010111b
-11000001b | 00010111b = 11010111b
-11000001b | 00011000b = 11011001b
-11000001b | 00011001b = 11011001b
-11000001b | 00011010b = 11011011b
-11000001b | 00011011b = 11011011b
-11000001b | 00011100b = 11011101b
-11000001b | 00011101b = 11011101b
-11000001b | 00011110b = 11011111b
-11000001b | 00011111b = 11011111b
-11000001b | 00100000b = 11100001b
-11000001b | 00100001b = 11100001b
-11000001b | 00100010b = 11100011b
-11000001b | 00100011b = 11100011b
-11000001b | 00100100b = 11100101b
-11000001b | 00100101b = 11100101b
-11000001b | 00100110b = 11100111b
-11000001b | 00100111b = 11100111b
-11000001b | 00101000b = 11101001b
-11000001b | 00101001b = 11101001b
-11000001b | 00101010b = 11101011b
-11000001b | 00101011b = 11101011b
-11000001b | 00101100b = 11101101b
-11000001b | 00101101b = 11101101b
-11000001b | 00101110b = 11101111b
-11000001b | 00101111b = 11101111b
-11000001b | 00110000b = 11110001b
-11000001b | 00110001b = 11110001b
-11000001b | 00110010b = 11110011b
-11000001b | 00110011b = 11110011b
-11000001b | 00110100b = 11110101b
-11000001b | 00110101b = 11110101b
-11000001b | 00110110b = 11110111b
-11000001b | 00110111b = 11110111b
-11000001b | 00111000b = 11111001b
-11000001b | 00111001b = 11111001b
-11000001b | 00111010b = 11111011b
-11000001b | 00111011b = 11111011b
-11000001b | 00111100b = 11111101b
-11000001b | 00111101b = 11111101b
-11000001b | 00111110b = 11111111b
-11000001b | 00111111b = 11111111b
-11000001b | 01000000b = 11000001b
-11000001b | 01000001b = 11000001b
-11000001b | 01000010b = 11000011b
-11000001b | 01000011b = 11000011b
-11000001b | 01000100b = 11000101b
-11000001b | 01000101b = 11000101b
-11000001b | 01000110b = 11000111b
-11000001b | 01000111b = 11000111b
-11000001b | 01001000b = 11001001b
-11000001b | 01001001b = 11001001b
-11000001b | 01001010b = 11001011b
-11000001b | 01001011b = 11001011b
-11000001b | 01001100b = 11001101b
-11000001b | 01001101b = 11001101b
-11000001b | 01001110b = 11001111b
-11000001b | 01001111b = 11001111b
-11000001b | 01010000b = 11010001b
-11000001b | 01010001b = 11010001b
-11000001b | 01010010b = 11010011b
-11000001b | 01010011b = 11010011b
-11000001b | 01010100b = 11010101b
-11000001b | 01010101b = 11010101b
-11000001b | 01010110b = 11010111b
-11000001b | 01010111b = 11010111b
-11000001b | 01011000b = 11011001b
-11000001b | 01011001b = 11011001b
-11000001b | 01011010b = 11011011b
-11000001b | 01011011b = 11011011b
-11000001b | 01011100b = 11011101b
-11000001b | 01011101b = 11011101b
-11000001b | 01011110b = 11011111b
-11000001b | 01011111b = 11011111b
-11000001b | 01100000b = 11100001b
-11000001b | 01100001b = 11100001b
-11000001b | 01100010b = 11100011b
-11000001b | 01100011b = 11100011b
-11000001b | 01100100b = 11100101b
-11000001b | 01100101b = 11100101b
-11000001b | 01100110b = 11100111b
-11000001b | 01100111b = 11100111b
-11000001b | 01101000b = 11101001b
-11000001b | 01101001b = 11101001b
-11000001b | 01101010b = 11101011b
-11000001b | 01101011b = 11101011b
-11000001b | 01101100b = 11101101b
-11000001b | 01101101b = 11101101b
-11000001b | 01101110b = 11101111b
-11000001b | 01101111b = 11101111b
-11000001b | 01110000b = 11110001b
-11000001b | 01110001b = 11110001b
-11000001b | 01110010b = 11110011b
-11000001b | 01110011b = 11110011b
-11000001b | 01110100b = 11110101b
-11000001b | 01110101b = 11110101b
-11000001b | 01110110b = 11110111b
-11000001b | 01110111b = 11110111b
-11000001b | 01111000b = 11111001b
-11000001b | 01111001b = 11111001b
-11000001b | 01111010b = 11111011b
-11000001b | 01111011b = 11111011b
-11000001b | 01111100b = 11111101b
-11000001b | 01111101b = 11111101b
-11000001b | 01111110b = 11111111b
-11000010b | 10000000b = 11000010b
-11000010b | 10000001b = 11000011b
-11000010b | 10000010b = 11000010b
-11000010b | 10000011b = 11000011b
-11000010b | 10000100b = 11000110b
-11000010b | 10000101b = 11000111b
-11000010b | 10000110b = 11000110b
-11000010b | 10000111b = 11000111b
-11000010b | 10001000b = 11001010b
-11000010b | 10001001b = 11001011b
-11000010b | 10001010b = 11001010b
-11000010b | 10001011b = 11001011b
-11000010b | 10001100b = 11001110b
-11000010b | 10001101b = 11001111b
-11000010b | 10001110b = 11001110b
-11000010b | 10001111b = 11001111b
-11000010b | 10010000b = 11010010b
-11000010b | 10010001b = 11010011b
-11000010b | 10010010b = 11010010b
-11000010b | 10010011b = 11010011b
-11000010b | 10010100b = 11010110b
-11000010b | 10010101b = 11010111b
-11000010b | 10010110b = 11010110b
-11000010b | 10010111b = 11010111b
-11000010b | 10011000b = 11011010b
-11000010b | 10011001b = 11011011b
-11000010b | 10011010b = 11011010b
-11000010b | 10011011b = 11011011b
-11000010b | 10011100b = 11011110b
-11000010b | 10011101b = 11011111b
-11000010b | 10011110b = 11011110b
-11000010b | 10011111b = 11011111b
-11000010b | 10100000b = 11100010b
-11000010b | 10100001b = 11100011b
-11000010b | 10100010b = 11100010b
-11000010b | 10100011b = 11100011b
-11000010b | 10100100b = 11100110b
-11000010b | 10100101b = 11100111b
-11000010b | 10100110b = 11100110b
-11000010b | 10100111b = 11100111b
-11000010b | 10101000b = 11101010b
-11000010b | 10101001b = 11101011b
-11000010b | 10101010b = 11101010b
-11000010b | 10101011b = 11101011b
-11000010b | 10101100b = 11101110b
-11000010b | 10101101b = 11101111b
-11000010b | 10101110b = 11101110b
-11000010b | 10101111b = 11101111b
-11000010b | 10110000b = 11110010b
-11000010b | 10110001b = 11110011b
-11000010b | 10110010b = 11110010b
-11000010b | 10110011b = 11110011b
-11000010b | 10110100b = 11110110b
-11000010b | 10110101b = 11110111b
-11000010b | 10110110b = 11110110b
-11000010b | 10110111b = 11110111b
-11000010b | 10111000b = 11111010b
-11000010b | 10111001b = 11111011b
-11000010b | 10111010b = 11111010b
-11000010b | 10111011b = 11111011b
-11000010b | 10111100b = 11111110b
-11000010b | 10111101b = 11111111b
-11000010b | 10111110b = 11111110b
-11000010b | 10111111b = 11111111b
-11000010b | 11000000b = 11000010b
-11000010b | 11000001b = 11000011b
-11000010b | 11000010b = 11000010b
-11000010b | 11000011b = 11000011b
-11000010b | 11000100b = 11000110b
-11000010b | 11000101b = 11000111b
-11000010b | 11000110b = 11000110b
-11000010b | 11000111b = 11000111b
-11000010b | 11001000b = 11001010b
-11000010b | 11001001b = 11001011b
-11000010b | 11001010b = 11001010b
-11000010b | 11001011b = 11001011b
-11000010b | 11001100b = 11001110b
-11000010b | 11001101b = 11001111b
-11000010b | 11001110b = 11001110b
-11000010b | 11001111b = 11001111b
-11000010b | 11010000b = 11010010b
-11000010b | 11010001b = 11010011b
-11000010b | 11010010b = 11010010b
-11000010b | 11010011b = 11010011b
-11000010b | 11010100b = 11010110b
-11000010b | 11010101b = 11010111b
-11000010b | 11010110b = 11010110b
-11000010b | 11010111b = 11010111b
-11000010b | 11011000b = 11011010b
-11000010b | 11011001b = 11011011b
-11000010b | 11011010b = 11011010b
-11000010b | 11011011b = 11011011b
-11000010b | 11011100b = 11011110b
-11000010b | 11011101b = 11011111b
-11000010b | 11011110b = 11011110b
-11000010b | 11011111b = 11011111b
-11000010b | 11100000b = 11100010b
-11000010b | 11100001b = 11100011b
-11000010b | 11100010b = 11100010b
-11000010b | 11100011b = 11100011b
-11000010b | 11100100b = 11100110b
-11000010b | 11100101b = 11100111b
-11000010b | 11100110b = 11100110b
-11000010b | 11100111b = 11100111b
-11000010b | 11101000b = 11101010b
-11000010b | 11101001b = 11101011b
-11000010b | 11101010b = 11101010b
-11000010b | 11101011b = 11101011b
-11000010b | 11101100b = 11101110b
-11000010b | 11101101b = 11101111b
-11000010b | 11101110b = 11101110b
-11000010b | 11101111b = 11101111b
-11000010b | 11110000b = 11110010b
-11000010b | 11110001b = 11110011b
-11000010b | 11110010b = 11110010b
-11000010b | 11110011b = 11110011b
-11000010b | 11110100b = 11110110b
-11000010b | 11110101b = 11110111b
-11000010b | 11110110b = 11110110b
-11000010b | 11110111b = 11110111b
-11000010b | 11111000b = 11111010b
-11000010b | 11111001b = 11111011b
-11000010b | 11111010b = 11111010b
-11000010b | 11111011b = 11111011b
-11000010b | 11111100b = 11111110b
-11000010b | 11111101b = 11111111b
-11000010b | 11111110b = 11111110b
-11000010b | 11111111b = 11111111b
-11000010b | 00000000b = 11000010b
-11000010b | 00000001b = 11000011b
-11000010b | 00000010b = 11000010b
-11000010b | 00000011b = 11000011b
-11000010b | 00000100b = 11000110b
-11000010b | 00000101b = 11000111b
-11000010b | 00000110b = 11000110b
-11000010b | 00000111b = 11000111b
-11000010b | 00001000b = 11001010b
-11000010b | 00001001b = 11001011b
-11000010b | 00001010b = 11001010b
-11000010b | 00001011b = 11001011b
-11000010b | 00001100b = 11001110b
-11000010b | 00001101b = 11001111b
-11000010b | 00001110b = 11001110b
-11000010b | 00001111b = 11001111b
-11000010b | 00010000b = 11010010b
-11000010b | 00010001b = 11010011b
-11000010b | 00010010b = 11010010b
-11000010b | 00010011b = 11010011b
-11000010b | 00010100b = 11010110b
-11000010b | 00010101b = 11010111b
-11000010b | 00010110b = 11010110b
-11000010b | 00010111b = 11010111b
-11000010b | 00011000b = 11011010b
-11000010b | 00011001b = 11011011b
-11000010b | 00011010b = 11011010b
-11000010b | 00011011b = 11011011b
-11000010b | 00011100b = 11011110b
-11000010b | 00011101b = 11011111b
-11000010b | 00011110b = 11011110b
-11000010b | 00011111b = 11011111b
-11000010b | 00100000b = 11100010b
-11000010b | 00100001b = 11100011b
-11000010b | 00100010b = 11100010b
-11000010b | 00100011b = 11100011b
-11000010b | 00100100b = 11100110b
-11000010b | 00100101b = 11100111b
-11000010b | 00100110b = 11100110b
-11000010b | 00100111b = 11100111b
-11000010b | 00101000b = 11101010b
-11000010b | 00101001b = 11101011b
-11000010b | 00101010b = 11101010b
-11000010b | 00101011b = 11101011b
-11000010b | 00101100b = 11101110b
-11000010b | 00101101b = 11101111b
-11000010b | 00101110b = 11101110b
-11000010b | 00101111b = 11101111b
-11000010b | 00110000b = 11110010b
-11000010b | 00110001b = 11110011b
-11000010b | 00110010b = 11110010b
-11000010b | 00110011b = 11110011b
-11000010b | 00110100b = 11110110b
-11000010b | 00110101b = 11110111b
-11000010b | 00110110b = 11110110b
-11000010b | 00110111b = 11110111b
-11000010b | 00111000b = 11111010b
-11000010b | 00111001b = 11111011b
-11000010b | 00111010b = 11111010b
-11000010b | 00111011b = 11111011b
-11000010b | 00111100b = 11111110b
-11000010b | 00111101b = 11111111b
-11000010b | 00111110b = 11111110b
-11000010b | 00111111b = 11111111b
-11000010b | 01000000b = 11000010b
-11000010b | 01000001b = 11000011b
-11000010b | 01000010b = 11000010b
-11000010b | 01000011b = 11000011b
-11000010b | 01000100b = 11000110b
-11000010b | 01000101b = 11000111b
-11000010b | 01000110b = 11000110b
-11000010b | 01000111b = 11000111b
-11000010b | 01001000b = 11001010b
-11000010b | 01001001b = 11001011b
-11000010b | 01001010b = 11001010b
-11000010b | 01001011b = 11001011b
-11000010b | 01001100b = 11001110b
-11000010b | 01001101b = 11001111b
-11000010b | 01001110b = 11001110b
-11000010b | 01001111b = 11001111b
-11000010b | 01010000b = 11010010b
-11000010b | 01010001b = 11010011b
-11000010b | 01010010b = 11010010b
-11000010b | 01010011b = 11010011b
-11000010b | 01010100b = 11010110b
-11000010b | 01010101b = 11010111b
-11000010b | 01010110b = 11010110b
-11000010b | 01010111b = 11010111b
-11000010b | 01011000b = 11011010b
-11000010b | 01011001b = 11011011b
-11000010b | 01011010b = 11011010b
-11000010b | 01011011b = 11011011b
-11000010b | 01011100b = 11011110b
-11000010b | 01011101b = 11011111b
-11000010b | 01011110b = 11011110b
-11000010b | 01011111b = 11011111b
-11000010b | 01100000b = 11100010b
-11000010b | 01100001b = 11100011b
-11000010b | 01100010b = 11100010b
-11000010b | 01100011b = 11100011b
-11000010b | 01100100b = 11100110b
-11000010b | 01100101b = 11100111b
-11000010b | 01100110b = 11100110b
-11000010b | 01100111b = 11100111b
-11000010b | 01101000b = 11101010b
-11000010b | 01101001b = 11101011b
-11000010b | 01101010b = 11101010b
-11000010b | 01101011b = 11101011b
-11000010b | 01101100b = 11101110b
-11000010b | 01101101b = 11101111b
-11000010b | 01101110b = 11101110b
-11000010b | 01101111b = 11101111b
-11000010b | 01110000b = 11110010b
-11000010b | 01110001b = 11110011b
-11000010b | 01110010b = 11110010b
-11000010b | 01110011b = 11110011b
-11000010b | 01110100b = 11110110b
-11000010b | 01110101b = 11110111b
-11000010b | 01110110b = 11110110b
-11000010b | 01110111b = 11110111b
-11000010b | 01111000b = 11111010b
-11000010b | 01111001b = 11111011b
-11000010b | 01111010b = 11111010b
-11000010b | 01111011b = 11111011b
-11000010b | 01111100b = 11111110b
-11000010b | 01111101b = 11111111b
-11000010b | 01111110b = 11111110b
-11000011b | 10000000b = 11000011b
-11000011b | 10000001b = 11000011b
-11000011b | 10000010b = 11000011b
-11000011b | 10000011b = 11000011b
-11000011b | 10000100b = 11000111b
-11000011b | 10000101b = 11000111b
-11000011b | 10000110b = 11000111b
-11000011b | 10000111b = 11000111b
-11000011b | 10001000b = 11001011b
-11000011b | 10001001b = 11001011b
-11000011b | 10001010b = 11001011b
-11000011b | 10001011b = 11001011b
-11000011b | 10001100b = 11001111b
-11000011b | 10001101b = 11001111b
-11000011b | 10001110b = 11001111b
-11000011b | 10001111b = 11001111b
-11000011b | 10010000b = 11010011b
-11000011b | 10010001b = 11010011b
-11000011b | 10010010b = 11010011b
-11000011b | 10010011b = 11010011b
-11000011b | 10010100b = 11010111b
-11000011b | 10010101b = 11010111b
-11000011b | 10010110b = 11010111b
-11000011b | 10010111b = 11010111b
-11000011b | 10011000b = 11011011b
-11000011b | 10011001b = 11011011b
-11000011b | 10011010b = 11011011b
-11000011b | 10011011b = 11011011b
-11000011b | 10011100b = 11011111b
-11000011b | 10011101b = 11011111b
-11000011b | 10011110b = 11011111b
-11000011b | 10011111b = 11011111b
-11000011b | 10100000b = 11100011b
-11000011b | 10100001b = 11100011b
-11000011b | 10100010b = 11100011b
-11000011b | 10100011b = 11100011b
-11000011b | 10100100b = 11100111b
-11000011b | 10100101b = 11100111b
-11000011b | 10100110b = 11100111b
-11000011b | 10100111b = 11100111b
-11000011b | 10101000b = 11101011b
-11000011b | 10101001b = 11101011b
-11000011b | 10101010b = 11101011b
-11000011b | 10101011b = 11101011b
-11000011b | 10101100b = 11101111b
-11000011b | 10101101b = 11101111b
-11000011b | 10101110b = 11101111b
-11000011b | 10101111b = 11101111b
-11000011b | 10110000b = 11110011b
-11000011b | 10110001b = 11110011b
-11000011b | 10110010b = 11110011b
-11000011b | 10110011b = 11110011b
-11000011b | 10110100b = 11110111b
-11000011b | 10110101b = 11110111b
-11000011b | 10110110b = 11110111b
-11000011b | 10110111b = 11110111b
-11000011b | 10111000b = 11111011b
-11000011b | 10111001b = 11111011b
-11000011b | 10111010b = 11111011b
-11000011b | 10111011b = 11111011b
-11000011b | 10111100b = 11111111b
-11000011b | 10111101b = 11111111b
-11000011b | 10111110b = 11111111b
-11000011b | 10111111b = 11111111b
-11000011b | 11000000b = 11000011b
-11000011b | 11000001b = 11000011b
-11000011b | 11000010b = 11000011b
-11000011b | 11000011b = 11000011b
-11000011b | 11000100b = 11000111b
-11000011b | 11000101b = 11000111b
-11000011b | 11000110b = 11000111b
-11000011b | 11000111b = 11000111b
-11000011b | 11001000b = 11001011b
-11000011b | 11001001b = 11001011b
-11000011b | 11001010b = 11001011b
-11000011b | 11001011b = 11001011b
-11000011b | 11001100b = 11001111b
-11000011b | 11001101b = 11001111b
-11000011b | 11001110b = 11001111b
-11000011b | 11001111b = 11001111b
-11000011b | 11010000b = 11010011b
-11000011b | 11010001b = 11010011b
-11000011b | 11010010b = 11010011b
-11000011b | 11010011b = 11010011b
-11000011b | 11010100b = 11010111b
-11000011b | 11010101b = 11010111b
-11000011b | 11010110b = 11010111b
-11000011b | 11010111b = 11010111b
-11000011b | 11011000b = 11011011b
-11000011b | 11011001b = 11011011b
-11000011b | 11011010b = 11011011b
-11000011b | 11011011b = 11011011b
-11000011b | 11011100b = 11011111b
-11000011b | 11011101b = 11011111b
-11000011b | 11011110b = 11011111b
-11000011b | 11011111b = 11011111b
-11000011b | 11100000b = 11100011b
-11000011b | 11100001b = 11100011b
-11000011b | 11100010b = 11100011b
-11000011b | 11100011b = 11100011b
-11000011b | 11100100b = 11100111b
-11000011b | 11100101b = 11100111b
-11000011b | 11100110b = 11100111b
-11000011b | 11100111b = 11100111b
-11000011b | 11101000b = 11101011b
-11000011b | 11101001b = 11101011b
-11000011b | 11101010b = 11101011b
-11000011b | 11101011b = 11101011b
-11000011b | 11101100b = 11101111b
-11000011b | 11101101b = 11101111b
-11000011b | 11101110b = 11101111b
-11000011b | 11101111b = 11101111b
-11000011b | 11110000b = 11110011b
-11000011b | 11110001b = 11110011b
-11000011b | 11110010b = 11110011b
-11000011b | 11110011b = 11110011b
-11000011b | 11110100b = 11110111b
-11000011b | 11110101b = 11110111b
-11000011b | 11110110b = 11110111b
-11000011b | 11110111b = 11110111b
-11000011b | 11111000b = 11111011b
-11000011b | 11111001b = 11111011b
-11000011b | 11111010b = 11111011b
-11000011b | 11111011b = 11111011b
-11000011b | 11111100b = 11111111b
-11000011b | 11111101b = 11111111b
-11000011b | 11111110b = 11111111b
-11000011b | 11111111b = 11111111b
-11000011b | 00000000b = 11000011b
-11000011b | 00000001b = 11000011b
-11000011b | 00000010b = 11000011b
-11000011b | 00000011b = 11000011b
-11000011b | 00000100b = 11000111b
-11000011b | 00000101b = 11000111b
-11000011b | 00000110b = 11000111b
-11000011b | 00000111b = 11000111b
-11000011b | 00001000b = 11001011b
-11000011b | 00001001b = 11001011b
-11000011b | 00001010b = 11001011b
-11000011b | 00001011b = 11001011b
-11000011b | 00001100b = 11001111b
-11000011b | 00001101b = 11001111b
-11000011b | 00001110b = 11001111b
-11000011b | 00001111b = 11001111b
-11000011b | 00010000b = 11010011b
-11000011b | 00010001b = 11010011b
-11000011b | 00010010b = 11010011b
-11000011b | 00010011b = 11010011b
-11000011b | 00010100b = 11010111b
-11000011b | 00010101b = 11010111b
-11000011b | 00010110b = 11010111b
-11000011b | 00010111b = 11010111b
-11000011b | 00011000b = 11011011b
-11000011b | 00011001b = 11011011b
-11000011b | 00011010b = 11011011b
-11000011b | 00011011b = 11011011b
-11000011b | 00011100b = 11011111b
-11000011b | 00011101b = 11011111b
-11000011b | 00011110b = 11011111b
-11000011b | 00011111b = 11011111b
-11000011b | 00100000b = 11100011b
-11000011b | 00100001b = 11100011b
-11000011b | 00100010b = 11100011b
-11000011b | 00100011b = 11100011b
-11000011b | 00100100b = 11100111b
-11000011b | 00100101b = 11100111b
-11000011b | 00100110b = 11100111b
-11000011b | 00100111b = 11100111b
-11000011b | 00101000b = 11101011b
-11000011b | 00101001b = 11101011b
-11000011b | 00101010b = 11101011b
-11000011b | 00101011b = 11101011b
-11000011b | 00101100b = 11101111b
-11000011b | 00101101b = 11101111b
-11000011b | 00101110b = 11101111b
-11000011b | 00101111b = 11101111b
-11000011b | 00110000b = 11110011b
-11000011b | 00110001b = 11110011b
-11000011b | 00110010b = 11110011b
-11000011b | 00110011b = 11110011b
-11000011b | 00110100b = 11110111b
-11000011b | 00110101b = 11110111b
-11000011b | 00110110b = 11110111b
-11000011b | 00110111b = 11110111b
-11000011b | 00111000b = 11111011b
-11000011b | 00111001b = 11111011b
-11000011b | 00111010b = 11111011b
-11000011b | 00111011b = 11111011b
-11000011b | 00111100b = 11111111b
-11000011b | 00111101b = 11111111b
-11000011b | 00111110b = 11111111b
-11000011b | 00111111b = 11111111b
-11000011b | 01000000b = 11000011b
-11000011b | 01000001b = 11000011b
-11000011b | 01000010b = 11000011b
-11000011b | 01000011b = 11000011b
-11000011b | 01000100b = 11000111b
-11000011b | 01000101b = 11000111b
-11000011b | 01000110b = 11000111b
-11000011b | 01000111b = 11000111b
-11000011b | 01001000b = 11001011b
-11000011b | 01001001b = 11001011b
-11000011b | 01001010b = 11001011b
-11000011b | 01001011b = 11001011b
-11000011b | 01001100b = 11001111b
-11000011b | 01001101b = 11001111b
-11000011b | 01001110b = 11001111b
-11000011b | 01001111b = 11001111b
-11000011b | 01010000b = 11010011b
-11000011b | 01010001b = 11010011b
-11000011b | 01010010b = 11010011b
-11000011b | 01010011b = 11010011b
-11000011b | 01010100b = 11010111b
-11000011b | 01010101b = 11010111b
-11000011b | 01010110b = 11010111b
-11000011b | 01010111b = 11010111b
-11000011b | 01011000b = 11011011b
-11000011b | 01011001b = 11011011b
-11000011b | 01011010b = 11011011b
-11000011b | 01011011b = 11011011b
-11000011b | 01011100b = 11011111b
-11000011b | 01011101b = 11011111b
-11000011b | 01011110b = 11011111b
-11000011b | 01011111b = 11011111b
-11000011b | 01100000b = 11100011b
-11000011b | 01100001b = 11100011b
-11000011b | 01100010b = 11100011b
-11000011b | 01100011b = 11100011b
-11000011b | 01100100b = 11100111b
-11000011b | 01100101b = 11100111b
-11000011b | 01100110b = 11100111b
-11000011b | 01100111b = 11100111b
-11000011b | 01101000b = 11101011b
-11000011b | 01101001b = 11101011b
-11000011b | 01101010b = 11101011b
-11000011b | 01101011b = 11101011b
-11000011b | 01101100b = 11101111b
-11000011b | 01101101b = 11101111b
-11000011b | 01101110b = 11101111b
-11000011b | 01101111b = 11101111b
-11000011b | 01110000b = 11110011b
-11000011b | 01110001b = 11110011b
-11000011b | 01110010b = 11110011b
-11000011b | 01110011b = 11110011b
-11000011b | 01110100b = 11110111b
-11000011b | 01110101b = 11110111b
-11000011b | 01110110b = 11110111b
-11000011b | 01110111b = 11110111b
-11000011b | 01111000b = 11111011b
-11000011b | 01111001b = 11111011b
-11000011b | 01111010b = 11111011b
-11000011b | 01111011b = 11111011b
-11000011b | 01111100b = 11111111b
-11000011b | 01111101b = 11111111b
-11000011b | 01111110b = 11111111b
-11000100b | 10000000b = 11000100b
-11000100b | 10000001b = 11000101b
-11000100b | 10000010b = 11000110b
-11000100b | 10000011b = 11000111b
-11000100b | 10000100b = 11000100b
-11000100b | 10000101b = 11000101b
-11000100b | 10000110b = 11000110b
-11000100b | 10000111b = 11000111b
-11000100b | 10001000b = 11001100b
-11000100b | 10001001b = 11001101b
-11000100b | 10001010b = 11001110b
-11000100b | 10001011b = 11001111b
-11000100b | 10001100b = 11001100b
-11000100b | 10001101b = 11001101b
-11000100b | 10001110b = 11001110b
-11000100b | 10001111b = 11001111b
-11000100b | 10010000b = 11010100b
-11000100b | 10010001b = 11010101b
-11000100b | 10010010b = 11010110b
-11000100b | 10010011b = 11010111b
-11000100b | 10010100b = 11010100b
-11000100b | 10010101b = 11010101b
-11000100b | 10010110b = 11010110b
-11000100b | 10010111b = 11010111b
-11000100b | 10011000b = 11011100b
-11000100b | 10011001b = 11011101b
-11000100b | 10011010b = 11011110b
-11000100b | 10011011b = 11011111b
-11000100b | 10011100b = 11011100b
-11000100b | 10011101b = 11011101b
-11000100b | 10011110b = 11011110b
-11000100b | 10011111b = 11011111b
-11000100b | 10100000b = 11100100b
-11000100b | 10100001b = 11100101b
-11000100b | 10100010b = 11100110b
-11000100b | 10100011b = 11100111b
-11000100b | 10100100b = 11100100b
-11000100b | 10100101b = 11100101b
-11000100b | 10100110b = 11100110b
-11000100b | 10100111b = 11100111b
-11000100b | 10101000b = 11101100b
-11000100b | 10101001b = 11101101b
-11000100b | 10101010b = 11101110b
-11000100b | 10101011b = 11101111b
-11000100b | 10101100b = 11101100b
-11000100b | 10101101b = 11101101b
-11000100b | 10101110b = 11101110b
-11000100b | 10101111b = 11101111b
-11000100b | 10110000b = 11110100b
-11000100b | 10110001b = 11110101b
-11000100b | 10110010b = 11110110b
-11000100b | 10110011b = 11110111b
-11000100b | 10110100b = 11110100b
-11000100b | 10110101b = 11110101b
-11000100b | 10110110b = 11110110b
-11000100b | 10110111b = 11110111b
-11000100b | 10111000b = 11111100b
-11000100b | 10111001b = 11111101b
-11000100b | 10111010b = 11111110b
-11000100b | 10111011b = 11111111b
-11000100b | 10111100b = 11111100b
-11000100b | 10111101b = 11111101b
-11000100b | 10111110b = 11111110b
-11000100b | 10111111b = 11111111b
-11000100b | 11000000b = 11000100b
-11000100b | 11000001b = 11000101b
-11000100b | 11000010b = 11000110b
-11000100b | 11000011b = 11000111b
-11000100b | 11000100b = 11000100b
-11000100b | 11000101b = 11000101b
-11000100b | 11000110b = 11000110b
-11000100b | 11000111b = 11000111b
-11000100b | 11001000b = 11001100b
-11000100b | 11001001b = 11001101b
-11000100b | 11001010b = 11001110b
-11000100b | 11001011b = 11001111b
-11000100b | 11001100b = 11001100b
-11000100b | 11001101b = 11001101b
-11000100b | 11001110b = 11001110b
-11000100b | 11001111b = 11001111b
-11000100b | 11010000b = 11010100b
-11000100b | 11010001b = 11010101b
-11000100b | 11010010b = 11010110b
-11000100b | 11010011b = 11010111b
-11000100b | 11010100b = 11010100b
-11000100b | 11010101b = 11010101b
-11000100b | 11010110b = 11010110b
-11000100b | 11010111b = 11010111b
-11000100b | 11011000b = 11011100b
-11000100b | 11011001b = 11011101b
-11000100b | 11011010b = 11011110b
-11000100b | 11011011b = 11011111b
-11000100b | 11011100b = 11011100b
-11000100b | 11011101b = 11011101b
-11000100b | 11011110b = 11011110b
-11000100b | 11011111b = 11011111b
-11000100b | 11100000b = 11100100b
-11000100b | 11100001b = 11100101b
-11000100b | 11100010b = 11100110b
-11000100b | 11100011b = 11100111b
-11000100b | 11100100b = 11100100b
-11000100b | 11100101b = 11100101b
-11000100b | 11100110b = 11100110b
-11000100b | 11100111b = 11100111b
-11000100b | 11101000b = 11101100b
-11000100b | 11101001b = 11101101b
-11000100b | 11101010b = 11101110b
-11000100b | 11101011b = 11101111b
-11000100b | 11101100b = 11101100b
-11000100b | 11101101b = 11101101b
-11000100b | 11101110b = 11101110b
-11000100b | 11101111b = 11101111b
-11000100b | 11110000b = 11110100b
-11000100b | 11110001b = 11110101b
-11000100b | 11110010b = 11110110b
-11000100b | 11110011b = 11110111b
-11000100b | 11110100b = 11110100b
-11000100b | 11110101b = 11110101b
-11000100b | 11110110b = 11110110b
-11000100b | 11110111b = 11110111b
-11000100b | 11111000b = 11111100b
-11000100b | 11111001b = 11111101b
-11000100b | 11111010b = 11111110b
-11000100b | 11111011b = 11111111b
-11000100b | 11111100b = 11111100b
-11000100b | 11111101b = 11111101b
-11000100b | 11111110b = 11111110b
-11000100b | 11111111b = 11111111b
-11000100b | 00000000b = 11000100b
-11000100b | 00000001b = 11000101b
-11000100b | 00000010b = 11000110b
-11000100b | 00000011b = 11000111b
-11000100b | 00000100b = 11000100b
-11000100b | 00000101b = 11000101b
-11000100b | 00000110b = 11000110b
-11000100b | 00000111b = 11000111b
-11000100b | 00001000b = 11001100b
-11000100b | 00001001b = 11001101b
-11000100b | 00001010b = 11001110b
-11000100b | 00001011b = 11001111b
-11000100b | 00001100b = 11001100b
-11000100b | 00001101b = 11001101b
-11000100b | 00001110b = 11001110b
-11000100b | 00001111b = 11001111b
-11000100b | 00010000b = 11010100b
-11000100b | 00010001b = 11010101b
-11000100b | 00010010b = 11010110b
-11000100b | 00010011b = 11010111b
-11000100b | 00010100b = 11010100b
-11000100b | 00010101b = 11010101b
-11000100b | 00010110b = 11010110b
-11000100b | 00010111b = 11010111b
-11000100b | 00011000b = 11011100b
-11000100b | 00011001b = 11011101b
-11000100b | 00011010b = 11011110b
-11000100b | 00011011b = 11011111b
-11000100b | 00011100b = 11011100b
-11000100b | 00011101b = 11011101b
-11000100b | 00011110b = 11011110b
-11000100b | 00011111b = 11011111b
-11000100b | 00100000b = 11100100b
-11000100b | 00100001b = 11100101b
-11000100b | 00100010b = 11100110b
-11000100b | 00100011b = 11100111b
-11000100b | 00100100b = 11100100b
-11000100b | 00100101b = 11100101b
-11000100b | 00100110b = 11100110b
-11000100b | 00100111b = 11100111b
-11000100b | 00101000b = 11101100b
-11000100b | 00101001b = 11101101b
-11000100b | 00101010b = 11101110b
-11000100b | 00101011b = 11101111b
-11000100b | 00101100b = 11101100b
-11000100b | 00101101b = 11101101b
-11000100b | 00101110b = 11101110b
-11000100b | 00101111b = 11101111b
-11000100b | 00110000b = 11110100b
-11000100b | 00110001b = 11110101b
-11000100b | 00110010b = 11110110b
-11000100b | 00110011b = 11110111b
-11000100b | 00110100b = 11110100b
-11000100b | 00110101b = 11110101b
-11000100b | 00110110b = 11110110b
-11000100b | 00110111b = 11110111b
-11000100b | 00111000b = 11111100b
-11000100b | 00111001b = 11111101b
-11000100b | 00111010b = 11111110b
-11000100b | 00111011b = 11111111b
-11000100b | 00111100b = 11111100b
-11000100b | 00111101b = 11111101b
-11000100b | 00111110b = 11111110b
-11000100b | 00111111b = 11111111b
-11000100b | 01000000b = 11000100b
-11000100b | 01000001b = 11000101b
-11000100b | 01000010b = 11000110b
-11000100b | 01000011b = 11000111b
-11000100b | 01000100b = 11000100b
-11000100b | 01000101b = 11000101b
-11000100b | 01000110b = 11000110b
-11000100b | 01000111b = 11000111b
-11000100b | 01001000b = 11001100b
-11000100b | 01001001b = 11001101b
-11000100b | 01001010b = 11001110b
-11000100b | 01001011b = 11001111b
-11000100b | 01001100b = 11001100b
-11000100b | 01001101b = 11001101b
-11000100b | 01001110b = 11001110b
-11000100b | 01001111b = 11001111b
-11000100b | 01010000b = 11010100b
-11000100b | 01010001b = 11010101b
-11000100b | 01010010b = 11010110b
-11000100b | 01010011b = 11010111b
-11000100b | 01010100b = 11010100b
-11000100b | 01010101b = 11010101b
-11000100b | 01010110b = 11010110b
-11000100b | 01010111b = 11010111b
-11000100b | 01011000b = 11011100b
-11000100b | 01011001b = 11011101b
-11000100b | 01011010b = 11011110b
-11000100b | 01011011b = 11011111b
-11000100b | 01011100b = 11011100b
-11000100b | 01011101b = 11011101b
-11000100b | 01011110b = 11011110b
-11000100b | 01011111b = 11011111b
-11000100b | 01100000b = 11100100b
-11000100b | 01100001b = 11100101b
-11000100b | 01100010b = 11100110b
-11000100b | 01100011b = 11100111b
-11000100b | 01100100b = 11100100b
-11000100b | 01100101b = 11100101b
-11000100b | 01100110b = 11100110b
-11000100b | 01100111b = 11100111b
-11000100b | 01101000b = 11101100b
-11000100b | 01101001b = 11101101b
-11000100b | 01101010b = 11101110b
-11000100b | 01101011b = 11101111b
-11000100b | 01101100b = 11101100b
-11000100b | 01101101b = 11101101b
-11000100b | 01101110b = 11101110b
-11000100b | 01101111b = 11101111b
-11000100b | 01110000b = 11110100b
-11000100b | 01110001b = 11110101b
-11000100b | 01110010b = 11110110b
-11000100b | 01110011b = 11110111b
-11000100b | 01110100b = 11110100b
-11000100b | 01110101b = 11110101b
-11000100b | 01110110b = 11110110b
-11000100b | 01110111b = 11110111b
-11000100b | 01111000b = 11111100b
-11000100b | 01111001b = 11111101b
-11000100b | 01111010b = 11111110b
-11000100b | 01111011b = 11111111b
-11000100b | 01111100b = 11111100b
-11000100b | 01111101b = 11111101b
-11000100b | 01111110b = 11111110b
-11000101b | 10000000b = 11000101b
-11000101b | 10000001b = 11000101b
-11000101b | 10000010b = 11000111b
-11000101b | 10000011b = 11000111b
-11000101b | 10000100b = 11000101b
-11000101b | 10000101b = 11000101b
-11000101b | 10000110b = 11000111b
-11000101b | 10000111b = 11000111b
-11000101b | 10001000b = 11001101b
-11000101b | 10001001b = 11001101b
-11000101b | 10001010b = 11001111b
-11000101b | 10001011b = 11001111b
-11000101b | 10001100b = 11001101b
-11000101b | 10001101b = 11001101b
-11000101b | 10001110b = 11001111b
-11000101b | 10001111b = 11001111b
-11000101b | 10010000b = 11010101b
-11000101b | 10010001b = 11010101b
-11000101b | 10010010b = 11010111b
-11000101b | 10010011b = 11010111b
-11000101b | 10010100b = 11010101b
-11000101b | 10010101b = 11010101b
-11000101b | 10010110b = 11010111b
-11000101b | 10010111b = 11010111b
-11000101b | 10011000b = 11011101b
-11000101b | 10011001b = 11011101b
-11000101b | 10011010b = 11011111b
-11000101b | 10011011b = 11011111b
-11000101b | 10011100b = 11011101b
-11000101b | 10011101b = 11011101b
-11000101b | 10011110b = 11011111b
-11000101b | 10011111b = 11011111b
-11000101b | 10100000b = 11100101b
-11000101b | 10100001b = 11100101b
-11000101b | 10100010b = 11100111b
-11000101b | 10100011b = 11100111b
-11000101b | 10100100b = 11100101b
-11000101b | 10100101b = 11100101b
-11000101b | 10100110b = 11100111b
-11000101b | 10100111b = 11100111b
-11000101b | 10101000b = 11101101b
-11000101b | 10101001b = 11101101b
-11000101b | 10101010b = 11101111b
-11000101b | 10101011b = 11101111b
-11000101b | 10101100b = 11101101b
-11000101b | 10101101b = 11101101b
-11000101b | 10101110b = 11101111b
-11000101b | 10101111b = 11101111b
-11000101b | 10110000b = 11110101b
-11000101b | 10110001b = 11110101b
-11000101b | 10110010b = 11110111b
-11000101b | 10110011b = 11110111b
-11000101b | 10110100b = 11110101b
-11000101b | 10110101b = 11110101b
-11000101b | 10110110b = 11110111b
-11000101b | 10110111b = 11110111b
-11000101b | 10111000b = 11111101b
-11000101b | 10111001b = 11111101b
-11000101b | 10111010b = 11111111b
-11000101b | 10111011b = 11111111b
-11000101b | 10111100b = 11111101b
-11000101b | 10111101b = 11111101b
-11000101b | 10111110b = 11111111b
-11000101b | 10111111b = 11111111b
-11000101b | 11000000b = 11000101b
-11000101b | 11000001b = 11000101b
-11000101b | 11000010b = 11000111b
-11000101b | 11000011b = 11000111b
-11000101b | 11000100b = 11000101b
-11000101b | 11000101b = 11000101b
-11000101b | 11000110b = 11000111b
-11000101b | 11000111b = 11000111b
-11000101b | 11001000b = 11001101b
-11000101b | 11001001b = 11001101b
-11000101b | 11001010b = 11001111b
-11000101b | 11001011b = 11001111b
-11000101b | 11001100b = 11001101b
-11000101b | 11001101b = 11001101b
-11000101b | 11001110b = 11001111b
-11000101b | 11001111b = 11001111b
-11000101b | 11010000b = 11010101b
-11000101b | 11010001b = 11010101b
-11000101b | 11010010b = 11010111b
-11000101b | 11010011b = 11010111b
-11000101b | 11010100b = 11010101b
-11000101b | 11010101b = 11010101b
-11000101b | 11010110b = 11010111b
-11000101b | 11010111b = 11010111b
-11000101b | 11011000b = 11011101b
-11000101b | 11011001b = 11011101b
-11000101b | 11011010b = 11011111b
-11000101b | 11011011b = 11011111b
-11000101b | 11011100b = 11011101b
-11000101b | 11011101b = 11011101b
-11000101b | 11011110b = 11011111b
-11000101b | 11011111b = 11011111b
-11000101b | 11100000b = 11100101b
-11000101b | 11100001b = 11100101b
-11000101b | 11100010b = 11100111b
-11000101b | 11100011b = 11100111b
-11000101b | 11100100b = 11100101b
-11000101b | 11100101b = 11100101b
-11000101b | 11100110b = 11100111b
-11000101b | 11100111b = 11100111b
-11000101b | 11101000b = 11101101b
-11000101b | 11101001b = 11101101b
-11000101b | 11101010b = 11101111b
-11000101b | 11101011b = 11101111b
-11000101b | 11101100b = 11101101b
-11000101b | 11101101b = 11101101b
-11000101b | 11101110b = 11101111b
-11000101b | 11101111b = 11101111b
-11000101b | 11110000b = 11110101b
-11000101b | 11110001b = 11110101b
-11000101b | 11110010b = 11110111b
-11000101b | 11110011b = 11110111b
-11000101b | 11110100b = 11110101b
-11000101b | 11110101b = 11110101b
-11000101b | 11110110b = 11110111b
-11000101b | 11110111b = 11110111b
-11000101b | 11111000b = 11111101b
-11000101b | 11111001b = 11111101b
-11000101b | 11111010b = 11111111b
-11000101b | 11111011b = 11111111b
-11000101b | 11111100b = 11111101b
-11000101b | 11111101b = 11111101b
-11000101b | 11111110b = 11111111b
-11000101b | 11111111b = 11111111b
-11000101b | 00000000b = 11000101b
-11000101b | 00000001b = 11000101b
-11000101b | 00000010b = 11000111b
-11000101b | 00000011b = 11000111b
-11000101b | 00000100b = 11000101b
-11000101b | 00000101b = 11000101b
-11000101b | 00000110b = 11000111b
-11000101b | 00000111b = 11000111b
-11000101b | 00001000b = 11001101b
-11000101b | 00001001b = 11001101b
-11000101b | 00001010b = 11001111b
-11000101b | 00001011b = 11001111b
-11000101b | 00001100b = 11001101b
-11000101b | 00001101b = 11001101b
-11000101b | 00001110b = 11001111b
-11000101b | 00001111b = 11001111b
-11000101b | 00010000b = 11010101b
-11000101b | 00010001b = 11010101b
-11000101b | 00010010b = 11010111b
-11000101b | 00010011b = 11010111b
-11000101b | 00010100b = 11010101b
-11000101b | 00010101b = 11010101b
-11000101b | 00010110b = 11010111b
-11000101b | 00010111b = 11010111b
-11000101b | 00011000b = 11011101b
-11000101b | 00011001b = 11011101b
-11000101b | 00011010b = 11011111b
-11000101b | 00011011b = 11011111b
-11000101b | 00011100b = 11011101b
-11000101b | 00011101b = 11011101b
-11000101b | 00011110b = 11011111b
-11000101b | 00011111b = 11011111b
-11000101b | 00100000b = 11100101b
-11000101b | 00100001b = 11100101b
-11000101b | 00100010b = 11100111b
-11000101b | 00100011b = 11100111b
-11000101b | 00100100b = 11100101b
-11000101b | 00100101b = 11100101b
-11000101b | 00100110b = 11100111b
-11000101b | 00100111b = 11100111b
-11000101b | 00101000b = 11101101b
-11000101b | 00101001b = 11101101b
-11000101b | 00101010b = 11101111b
-11000101b | 00101011b = 11101111b
-11000101b | 00101100b = 11101101b
-11000101b | 00101101b = 11101101b
-11000101b | 00101110b = 11101111b
-11000101b | 00101111b = 11101111b
-11000101b | 00110000b = 11110101b
-11000101b | 00110001b = 11110101b
-11000101b | 00110010b = 11110111b
-11000101b | 00110011b = 11110111b
-11000101b | 00110100b = 11110101b
-11000101b | 00110101b = 11110101b
-11000101b | 00110110b = 11110111b
-11000101b | 00110111b = 11110111b
-11000101b | 00111000b = 11111101b
-11000101b | 00111001b = 11111101b
-11000101b | 00111010b = 11111111b
-11000101b | 00111011b = 11111111b
-11000101b | 00111100b = 11111101b
-11000101b | 00111101b = 11111101b
-11000101b | 00111110b = 11111111b
-11000101b | 00111111b = 11111111b
-11000101b | 01000000b = 11000101b
-11000101b | 01000001b = 11000101b
-11000101b | 01000010b = 11000111b
-11000101b | 01000011b = 11000111b
-11000101b | 01000100b = 11000101b
-11000101b | 01000101b = 11000101b
-11000101b | 01000110b = 11000111b
-11000101b | 01000111b = 11000111b
-11000101b | 01001000b = 11001101b
-11000101b | 01001001b = 11001101b
-11000101b | 01001010b = 11001111b
-11000101b | 01001011b = 11001111b
-11000101b | 01001100b = 11001101b
-11000101b | 01001101b = 11001101b
-11000101b | 01001110b = 11001111b
-11000101b | 01001111b = 11001111b
-11000101b | 01010000b = 11010101b
-11000101b | 01010001b = 11010101b
-11000101b | 01010010b = 11010111b
-11000101b | 01010011b = 11010111b
-11000101b | 01010100b = 11010101b
-11000101b | 01010101b = 11010101b
-11000101b | 01010110b = 11010111b
-11000101b | 01010111b = 11010111b
-11000101b | 01011000b = 11011101b
-11000101b | 01011001b = 11011101b
-11000101b | 01011010b = 11011111b
-11000101b | 01011011b = 11011111b
-11000101b | 01011100b = 11011101b
-11000101b | 01011101b = 11011101b
-11000101b | 01011110b = 11011111b
-11000101b | 01011111b = 11011111b
-11000101b | 01100000b = 11100101b
-11000101b | 01100001b = 11100101b
-11000101b | 01100010b = 11100111b
-11000101b | 01100011b = 11100111b
-11000101b | 01100100b = 11100101b
-11000101b | 01100101b = 11100101b
-11000101b | 01100110b = 11100111b
-11000101b | 01100111b = 11100111b
-11000101b | 01101000b = 11101101b
-11000101b | 01101001b = 11101101b
-11000101b | 01101010b = 11101111b
-11000101b | 01101011b = 11101111b
-11000101b | 01101100b = 11101101b
-11000101b | 01101101b = 11101101b
-11000101b | 01101110b = 11101111b
-11000101b | 01101111b = 11101111b
-11000101b | 01110000b = 11110101b
-11000101b | 01110001b = 11110101b
-11000101b | 01110010b = 11110111b
-11000101b | 01110011b = 11110111b
-11000101b | 01110100b = 11110101b
-11000101b | 01110101b = 11110101b
-11000101b | 01110110b = 11110111b
-11000101b | 01110111b = 11110111b
-11000101b | 01111000b = 11111101b
-11000101b | 01111001b = 11111101b
-11000101b | 01111010b = 11111111b
-11000101b | 01111011b = 11111111b
-11000101b | 01111100b = 11111101b
-11000101b | 01111101b = 11111101b
-11000101b | 01111110b = 11111111b
-11000110b | 10000000b = 11000110b
-11000110b | 10000001b = 11000111b
-11000110b | 10000010b = 11000110b
-11000110b | 10000011b = 11000111b
-11000110b | 10000100b = 11000110b
-11000110b | 10000101b = 11000111b
-11000110b | 10000110b = 11000110b
-11000110b | 10000111b = 11000111b
-11000110b | 10001000b = 11001110b
-11000110b | 10001001b = 11001111b
-11000110b | 10001010b = 11001110b
-11000110b | 10001011b = 11001111b
-11000110b | 10001100b = 11001110b
-11000110b | 10001101b = 11001111b
-11000110b | 10001110b = 11001110b
-11000110b | 10001111b = 11001111b
-11000110b | 10010000b = 11010110b
-11000110b | 10010001b = 11010111b
-11000110b | 10010010b = 11010110b
-11000110b | 10010011b = 11010111b
-11000110b | 10010100b = 11010110b
-11000110b | 10010101b = 11010111b
-11000110b | 10010110b = 11010110b
-11000110b | 10010111b = 11010111b
-11000110b | 10011000b = 11011110b
-11000110b | 10011001b = 11011111b
-11000110b | 10011010b = 11011110b
-11000110b | 10011011b = 11011111b
-11000110b | 10011100b = 11011110b
-11000110b | 10011101b = 11011111b
-11000110b | 10011110b = 11011110b
-11000110b | 10011111b = 11011111b
-11000110b | 10100000b = 11100110b
-11000110b | 10100001b = 11100111b
-11000110b | 10100010b = 11100110b
-11000110b | 10100011b = 11100111b
-11000110b | 10100100b = 11100110b
-11000110b | 10100101b = 11100111b
-11000110b | 10100110b = 11100110b
-11000110b | 10100111b = 11100111b
-11000110b | 10101000b = 11101110b
-11000110b | 10101001b = 11101111b
-11000110b | 10101010b = 11101110b
-11000110b | 10101011b = 11101111b
-11000110b | 10101100b = 11101110b
-11000110b | 10101101b = 11101111b
-11000110b | 10101110b = 11101110b
-11000110b | 10101111b = 11101111b
-11000110b | 10110000b = 11110110b
-11000110b | 10110001b = 11110111b
-11000110b | 10110010b = 11110110b
-11000110b | 10110011b = 11110111b
-11000110b | 10110100b = 11110110b
-11000110b | 10110101b = 11110111b
-11000110b | 10110110b = 11110110b
-11000110b | 10110111b = 11110111b
-11000110b | 10111000b = 11111110b
-11000110b | 10111001b = 11111111b
-11000110b | 10111010b = 11111110b
-11000110b | 10111011b = 11111111b
-11000110b | 10111100b = 11111110b
-11000110b | 10111101b = 11111111b
-11000110b | 10111110b = 11111110b
-11000110b | 10111111b = 11111111b
-11000110b | 11000000b = 11000110b
-11000110b | 11000001b = 11000111b
-11000110b | 11000010b = 11000110b
-11000110b | 11000011b = 11000111b
-11000110b | 11000100b = 11000110b
-11000110b | 11000101b = 11000111b
-11000110b | 11000110b = 11000110b
-11000110b | 11000111b = 11000111b
-11000110b | 11001000b = 11001110b
-11000110b | 11001001b = 11001111b
-11000110b | 11001010b = 11001110b
-11000110b | 11001011b = 11001111b
-11000110b | 11001100b = 11001110b
-11000110b | 11001101b = 11001111b
-11000110b | 11001110b = 11001110b
-11000110b | 11001111b = 11001111b
-11000110b | 11010000b = 11010110b
-11000110b | 11010001b = 11010111b
-11000110b | 11010010b = 11010110b
-11000110b | 11010011b = 11010111b
-11000110b | 11010100b = 11010110b
-11000110b | 11010101b = 11010111b
-11000110b | 11010110b = 11010110b
-11000110b | 11010111b = 11010111b
-11000110b | 11011000b = 11011110b
-11000110b | 11011001b = 11011111b
-11000110b | 11011010b = 11011110b
-11000110b | 11011011b = 11011111b
-11000110b | 11011100b = 11011110b
-11000110b | 11011101b = 11011111b
-11000110b | 11011110b = 11011110b
-11000110b | 11011111b = 11011111b
-11000110b | 11100000b = 11100110b
-11000110b | 11100001b = 11100111b
-11000110b | 11100010b = 11100110b
-11000110b | 11100011b = 11100111b
-11000110b | 11100100b = 11100110b
-11000110b | 11100101b = 11100111b
-11000110b | 11100110b = 11100110b
-11000110b | 11100111b = 11100111b
-11000110b | 11101000b = 11101110b
-11000110b | 11101001b = 11101111b
-11000110b | 11101010b = 11101110b
-11000110b | 11101011b = 11101111b
-11000110b | 11101100b = 11101110b
-11000110b | 11101101b = 11101111b
-11000110b | 11101110b = 11101110b
-11000110b | 11101111b = 11101111b
-11000110b | 11110000b = 11110110b
-11000110b | 11110001b = 11110111b
-11000110b | 11110010b = 11110110b
-11000110b | 11110011b = 11110111b
-11000110b | 11110100b = 11110110b
-11000110b | 11110101b = 11110111b
-11000110b | 11110110b = 11110110b
-11000110b | 11110111b = 11110111b
-11000110b | 11111000b = 11111110b
-11000110b | 11111001b = 11111111b
-11000110b | 11111010b = 11111110b
-11000110b | 11111011b = 11111111b
-11000110b | 11111100b = 11111110b
-11000110b | 11111101b = 11111111b
-11000110b | 11111110b = 11111110b
-11000110b | 11111111b = 11111111b
-11000110b | 00000000b = 11000110b
-11000110b | 00000001b = 11000111b
-11000110b | 00000010b = 11000110b
-11000110b | 00000011b = 11000111b
-11000110b | 00000100b = 11000110b
-11000110b | 00000101b = 11000111b
-11000110b | 00000110b = 11000110b
-11000110b | 00000111b = 11000111b
-11000110b | 00001000b = 11001110b
-11000110b | 00001001b = 11001111b
-11000110b | 00001010b = 11001110b
-11000110b | 00001011b = 11001111b
-11000110b | 00001100b = 11001110b
-11000110b | 00001101b = 11001111b
-11000110b | 00001110b = 11001110b
-11000110b | 00001111b = 11001111b
-11000110b | 00010000b = 11010110b
-11000110b | 00010001b = 11010111b
-11000110b | 00010010b = 11010110b
-11000110b | 00010011b = 11010111b
-11000110b | 00010100b = 11010110b
-11000110b | 00010101b = 11010111b
-11000110b | 00010110b = 11010110b
-11000110b | 00010111b = 11010111b
-11000110b | 00011000b = 11011110b
-11000110b | 00011001b = 11011111b
-11000110b | 00011010b = 11011110b
-11000110b | 00011011b = 11011111b
-11000110b | 00011100b = 11011110b
-11000110b | 00011101b = 11011111b
-11000110b | 00011110b = 11011110b
-11000110b | 00011111b = 11011111b
-11000110b | 00100000b = 11100110b
-11000110b | 00100001b = 11100111b
-11000110b | 00100010b = 11100110b
-11000110b | 00100011b = 11100111b
-11000110b | 00100100b = 11100110b
-11000110b | 00100101b = 11100111b
-11000110b | 00100110b = 11100110b
-11000110b | 00100111b = 11100111b
-11000110b | 00101000b = 11101110b
-11000110b | 00101001b = 11101111b
-11000110b | 00101010b = 11101110b
-11000110b | 00101011b = 11101111b
-11000110b | 00101100b = 11101110b
-11000110b | 00101101b = 11101111b
-11000110b | 00101110b = 11101110b
-11000110b | 00101111b = 11101111b
-11000110b | 00110000b = 11110110b
-11000110b | 00110001b = 11110111b
-11000110b | 00110010b = 11110110b
-11000110b | 00110011b = 11110111b
-11000110b | 00110100b = 11110110b
-11000110b | 00110101b = 11110111b
-11000110b | 00110110b = 11110110b
-11000110b | 00110111b = 11110111b
-11000110b | 00111000b = 11111110b
-11000110b | 00111001b = 11111111b
-11000110b | 00111010b = 11111110b
-11000110b | 00111011b = 11111111b
-11000110b | 00111100b = 11111110b
-11000110b | 00111101b = 11111111b
-11000110b | 00111110b = 11111110b
-11000110b | 00111111b = 11111111b
-11000110b | 01000000b = 11000110b
-11000110b | 01000001b = 11000111b
-11000110b | 01000010b = 11000110b
-11000110b | 01000011b = 11000111b
-11000110b | 01000100b = 11000110b
-11000110b | 01000101b = 11000111b
-11000110b | 01000110b = 11000110b
-11000110b | 01000111b = 11000111b
-11000110b | 01001000b = 11001110b
-11000110b | 01001001b = 11001111b
-11000110b | 01001010b = 11001110b
-11000110b | 01001011b = 11001111b
-11000110b | 01001100b = 11001110b
-11000110b | 01001101b = 11001111b
-11000110b | 01001110b = 11001110b
-11000110b | 01001111b = 11001111b
-11000110b | 01010000b = 11010110b
-11000110b | 01010001b = 11010111b
-11000110b | 01010010b = 11010110b
-11000110b | 01010011b = 11010111b
-11000110b | 01010100b = 11010110b
-11000110b | 01010101b = 11010111b
-11000110b | 01010110b = 11010110b
-11000110b | 01010111b = 11010111b
-11000110b | 01011000b = 11011110b
-11000110b | 01011001b = 11011111b
-11000110b | 01011010b = 11011110b
-11000110b | 01011011b = 11011111b
-11000110b | 01011100b = 11011110b
-11000110b | 01011101b = 11011111b
-11000110b | 01011110b = 11011110b
-11000110b | 01011111b = 11011111b
-11000110b | 01100000b = 11100110b
-11000110b | 01100001b = 11100111b
-11000110b | 01100010b = 11100110b
-11000110b | 01100011b = 11100111b
-11000110b | 01100100b = 11100110b
-11000110b | 01100101b = 11100111b
-11000110b | 01100110b = 11100110b
-11000110b | 01100111b = 11100111b
-11000110b | 01101000b = 11101110b
-11000110b | 01101001b = 11101111b
-11000110b | 01101010b = 11101110b
-11000110b | 01101011b = 11101111b
-11000110b | 01101100b = 11101110b
-11000110b | 01101101b = 11101111b
-11000110b | 01101110b = 11101110b
-11000110b | 01101111b = 11101111b
-11000110b | 01110000b = 11110110b
-11000110b | 01110001b = 11110111b
-11000110b | 01110010b = 11110110b
-11000110b | 01110011b = 11110111b
-11000110b | 01110100b = 11110110b
-11000110b | 01110101b = 11110111b
-11000110b | 01110110b = 11110110b
-11000110b | 01110111b = 11110111b
-11000110b | 01111000b = 11111110b
-11000110b | 01111001b = 11111111b
-11000110b | 01111010b = 11111110b
-11000110b | 01111011b = 11111111b
-11000110b | 01111100b = 11111110b
-11000110b | 01111101b = 11111111b
-11000110b | 01111110b = 11111110b
-11000111b | 10000000b = 11000111b
-11000111b | 10000001b = 11000111b
-11000111b | 10000010b = 11000111b
-11000111b | 10000011b = 11000111b
-11000111b | 10000100b = 11000111b
-11000111b | 10000101b = 11000111b
-11000111b | 10000110b = 11000111b
-11000111b | 10000111b = 11000111b
-11000111b | 10001000b = 11001111b
-11000111b | 10001001b = 11001111b
-11000111b | 10001010b = 11001111b
-11000111b | 10001011b = 11001111b
-11000111b | 10001100b = 11001111b
-11000111b | 10001101b = 11001111b
-11000111b | 10001110b = 11001111b
-11000111b | 10001111b = 11001111b
-11000111b | 10010000b = 11010111b
-11000111b | 10010001b = 11010111b
-11000111b | 10010010b = 11010111b
-11000111b | 10010011b = 11010111b
-11000111b | 10010100b = 11010111b
-11000111b | 10010101b = 11010111b
-11000111b | 10010110b = 11010111b
-11000111b | 10010111b = 11010111b
-11000111b | 10011000b = 11011111b
-11000111b | 10011001b = 11011111b
-11000111b | 10011010b = 11011111b
-11000111b | 10011011b = 11011111b
-11000111b | 10011100b = 11011111b
-11000111b | 10011101b = 11011111b
-11000111b | 10011110b = 11011111b
-11000111b | 10011111b = 11011111b
-11000111b | 10100000b = 11100111b
-11000111b | 10100001b = 11100111b
-11000111b | 10100010b = 11100111b
-11000111b | 10100011b = 11100111b
-11000111b | 10100100b = 11100111b
-11000111b | 10100101b = 11100111b
-11000111b | 10100110b = 11100111b
-11000111b | 10100111b = 11100111b
-11000111b | 10101000b = 11101111b
-11000111b | 10101001b = 11101111b
-11000111b | 10101010b = 11101111b
-11000111b | 10101011b = 11101111b
-11000111b | 10101100b = 11101111b
-11000111b | 10101101b = 11101111b
-11000111b | 10101110b = 11101111b
-11000111b | 10101111b = 11101111b
-11000111b | 10110000b = 11110111b
-11000111b | 10110001b = 11110111b
-11000111b | 10110010b = 11110111b
-11000111b | 10110011b = 11110111b
-11000111b | 10110100b = 11110111b
-11000111b | 10110101b = 11110111b
-11000111b | 10110110b = 11110111b
-11000111b | 10110111b = 11110111b
-11000111b | 10111000b = 11111111b
-11000111b | 10111001b = 11111111b
-11000111b | 10111010b = 11111111b
-11000111b | 10111011b = 11111111b
-11000111b | 10111100b = 11111111b
-11000111b | 10111101b = 11111111b
-11000111b | 10111110b = 11111111b
-11000111b | 10111111b = 11111111b
-11000111b | 11000000b = 11000111b
-11000111b | 11000001b = 11000111b
-11000111b | 11000010b = 11000111b
-11000111b | 11000011b = 11000111b
-11000111b | 11000100b = 11000111b
-11000111b | 11000101b = 11000111b
-11000111b | 11000110b = 11000111b
-11000111b | 11000111b = 11000111b
-11000111b | 11001000b = 11001111b
-11000111b | 11001001b = 11001111b
-11000111b | 11001010b = 11001111b
-11000111b | 11001011b = 11001111b
-11000111b | 11001100b = 11001111b
-11000111b | 11001101b = 11001111b
-11000111b | 11001110b = 11001111b
-11000111b | 11001111b = 11001111b
-11000111b | 11010000b = 11010111b
-11000111b | 11010001b = 11010111b
-11000111b | 11010010b = 11010111b
-11000111b | 11010011b = 11010111b
-11000111b | 11010100b = 11010111b
-11000111b | 11010101b = 11010111b
-11000111b | 11010110b = 11010111b
-11000111b | 11010111b = 11010111b
-11000111b | 11011000b = 11011111b
-11000111b | 11011001b = 11011111b
-11000111b | 11011010b = 11011111b
-11000111b | 11011011b = 11011111b
-11000111b | 11011100b = 11011111b
-11000111b | 11011101b = 11011111b
-11000111b | 11011110b = 11011111b
-11000111b | 11011111b = 11011111b
-11000111b | 11100000b = 11100111b
-11000111b | 11100001b = 11100111b
-11000111b | 11100010b = 11100111b
-11000111b | 11100011b = 11100111b
-11000111b | 11100100b = 11100111b
-11000111b | 11100101b = 11100111b
-11000111b | 11100110b = 11100111b
-11000111b | 11100111b = 11100111b
-11000111b | 11101000b = 11101111b
-11000111b | 11101001b = 11101111b
-11000111b | 11101010b = 11101111b
-11000111b | 11101011b = 11101111b
-11000111b | 11101100b = 11101111b
-11000111b | 11101101b = 11101111b
-11000111b | 11101110b = 11101111b
-11000111b | 11101111b = 11101111b
-11000111b | 11110000b = 11110111b
-11000111b | 11110001b = 11110111b
-11000111b | 11110010b = 11110111b
-11000111b | 11110011b = 11110111b
-11000111b | 11110100b = 11110111b
-11000111b | 11110101b = 11110111b
-11000111b | 11110110b = 11110111b
-11000111b | 11110111b = 11110111b
-11000111b | 11111000b = 11111111b
-11000111b | 11111001b = 11111111b
-11000111b | 11111010b = 11111111b
-11000111b | 11111011b = 11111111b
-11000111b | 11111100b = 11111111b
-11000111b | 11111101b = 11111111b
-11000111b | 11111110b = 11111111b
-11000111b | 11111111b = 11111111b
-11000111b | 00000000b = 11000111b
-11000111b | 00000001b = 11000111b
-11000111b | 00000010b = 11000111b
-11000111b | 00000011b = 11000111b
-11000111b | 00000100b = 11000111b
-11000111b | 00000101b = 11000111b
-11000111b | 00000110b = 11000111b
-11000111b | 00000111b = 11000111b
-11000111b | 00001000b = 11001111b
-11000111b | 00001001b = 11001111b
-11000111b | 00001010b = 11001111b
-11000111b | 00001011b = 11001111b
-11000111b | 00001100b = 11001111b
-11000111b | 00001101b = 11001111b
-11000111b | 00001110b = 11001111b
-11000111b | 00001111b = 11001111b
-11000111b | 00010000b = 11010111b
-11000111b | 00010001b = 11010111b
-11000111b | 00010010b = 11010111b
-11000111b | 00010011b = 11010111b
-11000111b | 00010100b = 11010111b
-11000111b | 00010101b = 11010111b
-11000111b | 00010110b = 11010111b
-11000111b | 00010111b = 11010111b
-11000111b | 00011000b = 11011111b
-11000111b | 00011001b = 11011111b
-11000111b | 00011010b = 11011111b
-11000111b | 00011011b = 11011111b
-11000111b | 00011100b = 11011111b
-11000111b | 00011101b = 11011111b
-11000111b | 00011110b = 11011111b
-11000111b | 00011111b = 11011111b
-11000111b | 00100000b = 11100111b
-11000111b | 00100001b = 11100111b
-11000111b | 00100010b = 11100111b
-11000111b | 00100011b = 11100111b
-11000111b | 00100100b = 11100111b
-11000111b | 00100101b = 11100111b
-11000111b | 00100110b = 11100111b
-11000111b | 00100111b = 11100111b
-11000111b | 00101000b = 11101111b
-11000111b | 00101001b = 11101111b
-11000111b | 00101010b = 11101111b
-11000111b | 00101011b = 11101111b
-11000111b | 00101100b = 11101111b
-11000111b | 00101101b = 11101111b
-11000111b | 00101110b = 11101111b
-11000111b | 00101111b = 11101111b
-11000111b | 00110000b = 11110111b
-11000111b | 00110001b = 11110111b
-11000111b | 00110010b = 11110111b
-11000111b | 00110011b = 11110111b
-11000111b | 00110100b = 11110111b
-11000111b | 00110101b = 11110111b
-11000111b | 00110110b = 11110111b
-11000111b | 00110111b = 11110111b
-11000111b | 00111000b = 11111111b
-11000111b | 00111001b = 11111111b
-11000111b | 00111010b = 11111111b
-11000111b | 00111011b = 11111111b
-11000111b | 00111100b = 11111111b
-11000111b | 00111101b = 11111111b
-11000111b | 00111110b = 11111111b
-11000111b | 00111111b = 11111111b
-11000111b | 01000000b = 11000111b
-11000111b | 01000001b = 11000111b
-11000111b | 01000010b = 11000111b
-11000111b | 01000011b = 11000111b
-11000111b | 01000100b = 11000111b
-11000111b | 01000101b = 11000111b
-11000111b | 01000110b = 11000111b
-11000111b | 01000111b = 11000111b
-11000111b | 01001000b = 11001111b
-11000111b | 01001001b = 11001111b
-11000111b | 01001010b = 11001111b
-11000111b | 01001011b = 11001111b
-11000111b | 01001100b = 11001111b
-11000111b | 01001101b = 11001111b
-11000111b | 01001110b = 11001111b
-11000111b | 01001111b = 11001111b
-11000111b | 01010000b = 11010111b
-11000111b | 01010001b = 11010111b
-11000111b | 01010010b = 11010111b
-11000111b | 01010011b = 11010111b
-11000111b | 01010100b = 11010111b
-11000111b | 01010101b = 11010111b
-11000111b | 01010110b = 11010111b
-11000111b | 01010111b = 11010111b
-11000111b | 01011000b = 11011111b
-11000111b | 01011001b = 11011111b
-11000111b | 01011010b = 11011111b
-11000111b | 01011011b = 11011111b
-11000111b | 01011100b = 11011111b
-11000111b | 01011101b = 11011111b
-11000111b | 01011110b = 11011111b
-11000111b | 01011111b = 11011111b
-11000111b | 01100000b = 11100111b
-11000111b | 01100001b = 11100111b
-11000111b | 01100010b = 11100111b
-11000111b | 01100011b = 11100111b
-11000111b | 01100100b = 11100111b
-11000111b | 01100101b = 11100111b
-11000111b | 01100110b = 11100111b
-11000111b | 01100111b = 11100111b
-11000111b | 01101000b = 11101111b
-11000111b | 01101001b = 11101111b
-11000111b | 01101010b = 11101111b
-11000111b | 01101011b = 11101111b
-11000111b | 01101100b = 11101111b
-11000111b | 01101101b = 11101111b
-11000111b | 01101110b = 11101111b
-11000111b | 01101111b = 11101111b
-11000111b | 01110000b = 11110111b
-11000111b | 01110001b = 11110111b
-11000111b | 01110010b = 11110111b
-11000111b | 01110011b = 11110111b
-11000111b | 01110100b = 11110111b
-11000111b | 01110101b = 11110111b
-11000111b | 01110110b = 11110111b
-11000111b | 01110111b = 11110111b
-11000111b | 01111000b = 11111111b
-11000111b | 01111001b = 11111111b
-11000111b | 01111010b = 11111111b
-11000111b | 01111011b = 11111111b
-11000111b | 01111100b = 11111111b
-11000111b | 01111101b = 11111111b
-11000111b | 01111110b = 11111111b
-11001000b | 10000000b = 11001000b
-11001000b | 10000001b = 11001001b
-11001000b | 10000010b = 11001010b
-11001000b | 10000011b = 11001011b
-11001000b | 10000100b = 11001100b
-11001000b | 10000101b = 11001101b
-11001000b | 10000110b = 11001110b
-11001000b | 10000111b = 11001111b
-11001000b | 10001000b = 11001000b
-11001000b | 10001001b = 11001001b
-11001000b | 10001010b = 11001010b
-11001000b | 10001011b = 11001011b
-11001000b | 10001100b = 11001100b
-11001000b | 10001101b = 11001101b
-11001000b | 10001110b = 11001110b
-11001000b | 10001111b = 11001111b
-11001000b | 10010000b = 11011000b
-11001000b | 10010001b = 11011001b
-11001000b | 10010010b = 11011010b
-11001000b | 10010011b = 11011011b
-11001000b | 10010100b = 11011100b
-11001000b | 10010101b = 11011101b
-11001000b | 10010110b = 11011110b
-11001000b | 10010111b = 11011111b
-11001000b | 10011000b = 11011000b
-11001000b | 10011001b = 11011001b
-11001000b | 10011010b = 11011010b
-11001000b | 10011011b = 11011011b
-11001000b | 10011100b = 11011100b
-11001000b | 10011101b = 11011101b
-11001000b | 10011110b = 11011110b
-11001000b | 10011111b = 11011111b
-11001000b | 10100000b = 11101000b
-11001000b | 10100001b = 11101001b
-11001000b | 10100010b = 11101010b
-11001000b | 10100011b = 11101011b
-11001000b | 10100100b = 11101100b
-11001000b | 10100101b = 11101101b
-11001000b | 10100110b = 11101110b
-11001000b | 10100111b = 11101111b
-11001000b | 10101000b = 11101000b
-11001000b | 10101001b = 11101001b
-11001000b | 10101010b = 11101010b
-11001000b | 10101011b = 11101011b
-11001000b | 10101100b = 11101100b
-11001000b | 10101101b = 11101101b
-11001000b | 10101110b = 11101110b
-11001000b | 10101111b = 11101111b
-11001000b | 10110000b = 11111000b
-11001000b | 10110001b = 11111001b
-11001000b | 10110010b = 11111010b
-11001000b | 10110011b = 11111011b
-11001000b | 10110100b = 11111100b
-11001000b | 10110101b = 11111101b
-11001000b | 10110110b = 11111110b
-11001000b | 10110111b = 11111111b
-11001000b | 10111000b = 11111000b
-11001000b | 10111001b = 11111001b
-11001000b | 10111010b = 11111010b
-11001000b | 10111011b = 11111011b
-11001000b | 10111100b = 11111100b
-11001000b | 10111101b = 11111101b
-11001000b | 10111110b = 11111110b
-11001000b | 10111111b = 11111111b
-11001000b | 11000000b = 11001000b
-11001000b | 11000001b = 11001001b
-11001000b | 11000010b = 11001010b
-11001000b | 11000011b = 11001011b
-11001000b | 11000100b = 11001100b
-11001000b | 11000101b = 11001101b
-11001000b | 11000110b = 11001110b
-11001000b | 11000111b = 11001111b
-11001000b | 11001000b = 11001000b
-11001000b | 11001001b = 11001001b
-11001000b | 11001010b = 11001010b
-11001000b | 11001011b = 11001011b
-11001000b | 11001100b = 11001100b
-11001000b | 11001101b = 11001101b
-11001000b | 11001110b = 11001110b
-11001000b | 11001111b = 11001111b
-11001000b | 11010000b = 11011000b
-11001000b | 11010001b = 11011001b
-11001000b | 11010010b = 11011010b
-11001000b | 11010011b = 11011011b
-11001000b | 11010100b = 11011100b
-11001000b | 11010101b = 11011101b
-11001000b | 11010110b = 11011110b
-11001000b | 11010111b = 11011111b
-11001000b | 11011000b = 11011000b
-11001000b | 11011001b = 11011001b
-11001000b | 11011010b = 11011010b
-11001000b | 11011011b = 11011011b
-11001000b | 11011100b = 11011100b
-11001000b | 11011101b = 11011101b
-11001000b | 11011110b = 11011110b
-11001000b | 11011111b = 11011111b
-11001000b | 11100000b = 11101000b
-11001000b | 11100001b = 11101001b
-11001000b | 11100010b = 11101010b
-11001000b | 11100011b = 11101011b
-11001000b | 11100100b = 11101100b
-11001000b | 11100101b = 11101101b
-11001000b | 11100110b = 11101110b
-11001000b | 11100111b = 11101111b
-11001000b | 11101000b = 11101000b
-11001000b | 11101001b = 11101001b
-11001000b | 11101010b = 11101010b
-11001000b | 11101011b = 11101011b
-11001000b | 11101100b = 11101100b
-11001000b | 11101101b = 11101101b
-11001000b | 11101110b = 11101110b
-11001000b | 11101111b = 11101111b
-11001000b | 11110000b = 11111000b
-11001000b | 11110001b = 11111001b
-11001000b | 11110010b = 11111010b
-11001000b | 11110011b = 11111011b
-11001000b | 11110100b = 11111100b
-11001000b | 11110101b = 11111101b
-11001000b | 11110110b = 11111110b
-11001000b | 11110111b = 11111111b
-11001000b | 11111000b = 11111000b
-11001000b | 11111001b = 11111001b
-11001000b | 11111010b = 11111010b
-11001000b | 11111011b = 11111011b
-11001000b | 11111100b = 11111100b
-11001000b | 11111101b = 11111101b
-11001000b | 11111110b = 11111110b
-11001000b | 11111111b = 11111111b
-11001000b | 00000000b = 11001000b
-11001000b | 00000001b = 11001001b
-11001000b | 00000010b = 11001010b
-11001000b | 00000011b = 11001011b
-11001000b | 00000100b = 11001100b
-11001000b | 00000101b = 11001101b
-11001000b | 00000110b = 11001110b
-11001000b | 00000111b = 11001111b
-11001000b | 00001000b = 11001000b
-11001000b | 00001001b = 11001001b
-11001000b | 00001010b = 11001010b
-11001000b | 00001011b = 11001011b
-11001000b | 00001100b = 11001100b
-11001000b | 00001101b = 11001101b
-11001000b | 00001110b = 11001110b
-11001000b | 00001111b = 11001111b
-11001000b | 00010000b = 11011000b
-11001000b | 00010001b = 11011001b
-11001000b | 00010010b = 11011010b
-11001000b | 00010011b = 11011011b
-11001000b | 00010100b = 11011100b
-11001000b | 00010101b = 11011101b
-11001000b | 00010110b = 11011110b
-11001000b | 00010111b = 11011111b
-11001000b | 00011000b = 11011000b
-11001000b | 00011001b = 11011001b
-11001000b | 00011010b = 11011010b
-11001000b | 00011011b = 11011011b
-11001000b | 00011100b = 11011100b
-11001000b | 00011101b = 11011101b
-11001000b | 00011110b = 11011110b
-11001000b | 00011111b = 11011111b
-11001000b | 00100000b = 11101000b
-11001000b | 00100001b = 11101001b
-11001000b | 00100010b = 11101010b
-11001000b | 00100011b = 11101011b
-11001000b | 00100100b = 11101100b
-11001000b | 00100101b = 11101101b
-11001000b | 00100110b = 11101110b
-11001000b | 00100111b = 11101111b
-11001000b | 00101000b = 11101000b
-11001000b | 00101001b = 11101001b
-11001000b | 00101010b = 11101010b
-11001000b | 00101011b = 11101011b
-11001000b | 00101100b = 11101100b
-11001000b | 00101101b = 11101101b
-11001000b | 00101110b = 11101110b
-11001000b | 00101111b = 11101111b
-11001000b | 00110000b = 11111000b
-11001000b | 00110001b = 11111001b
-11001000b | 00110010b = 11111010b
-11001000b | 00110011b = 11111011b
-11001000b | 00110100b = 11111100b
-11001000b | 00110101b = 11111101b
-11001000b | 00110110b = 11111110b
-11001000b | 00110111b = 11111111b
-11001000b | 00111000b = 11111000b
-11001000b | 00111001b = 11111001b
-11001000b | 00111010b = 11111010b
-11001000b | 00111011b = 11111011b
-11001000b | 00111100b = 11111100b
-11001000b | 00111101b = 11111101b
-11001000b | 00111110b = 11111110b
-11001000b | 00111111b = 11111111b
-11001000b | 01000000b = 11001000b
-11001000b | 01000001b = 11001001b
-11001000b | 01000010b = 11001010b
-11001000b | 01000011b = 11001011b
-11001000b | 01000100b = 11001100b
-11001000b | 01000101b = 11001101b
-11001000b | 01000110b = 11001110b
-11001000b | 01000111b = 11001111b
-11001000b | 01001000b = 11001000b
-11001000b | 01001001b = 11001001b
-11001000b | 01001010b = 11001010b
-11001000b | 01001011b = 11001011b
-11001000b | 01001100b = 11001100b
-11001000b | 01001101b = 11001101b
-11001000b | 01001110b = 11001110b
-11001000b | 01001111b = 11001111b
-11001000b | 01010000b = 11011000b
-11001000b | 01010001b = 11011001b
-11001000b | 01010010b = 11011010b
-11001000b | 01010011b = 11011011b
-11001000b | 01010100b = 11011100b
-11001000b | 01010101b = 11011101b
-11001000b | 01010110b = 11011110b
-11001000b | 01010111b = 11011111b
-11001000b | 01011000b = 11011000b
-11001000b | 01011001b = 11011001b
-11001000b | 01011010b = 11011010b
-11001000b | 01011011b = 11011011b
-11001000b | 01011100b = 11011100b
-11001000b | 01011101b = 11011101b
-11001000b | 01011110b = 11011110b
-11001000b | 01011111b = 11011111b
-11001000b | 01100000b = 11101000b
-11001000b | 01100001b = 11101001b
-11001000b | 01100010b = 11101010b
-11001000b | 01100011b = 11101011b
-11001000b | 01100100b = 11101100b
-11001000b | 01100101b = 11101101b
-11001000b | 01100110b = 11101110b
-11001000b | 01100111b = 11101111b
-11001000b | 01101000b = 11101000b
-11001000b | 01101001b = 11101001b
-11001000b | 01101010b = 11101010b
-11001000b | 01101011b = 11101011b
-11001000b | 01101100b = 11101100b
-11001000b | 01101101b = 11101101b
-11001000b | 01101110b = 11101110b
-11001000b | 01101111b = 11101111b
-11001000b | 01110000b = 11111000b
-11001000b | 01110001b = 11111001b
-11001000b | 01110010b = 11111010b
-11001000b | 01110011b = 11111011b
-11001000b | 01110100b = 11111100b
-11001000b | 01110101b = 11111101b
-11001000b | 01110110b = 11111110b
-11001000b | 01110111b = 11111111b
-11001000b | 01111000b = 11111000b
-11001000b | 01111001b = 11111001b
-11001000b | 01111010b = 11111010b
-11001000b | 01111011b = 11111011b
-11001000b | 01111100b = 11111100b
-11001000b | 01111101b = 11111101b
-11001000b | 01111110b = 11111110b
-11001001b | 10000000b = 11001001b
-11001001b | 10000001b = 11001001b
-11001001b | 10000010b = 11001011b
-11001001b | 10000011b = 11001011b
-11001001b | 10000100b = 11001101b
-11001001b | 10000101b = 11001101b
-11001001b | 10000110b = 11001111b
-11001001b | 10000111b = 11001111b
-11001001b | 10001000b = 11001001b
-11001001b | 10001001b = 11001001b
-11001001b | 10001010b = 11001011b
-11001001b | 10001011b = 11001011b
-11001001b | 10001100b = 11001101b
-11001001b | 10001101b = 11001101b
-11001001b | 10001110b = 11001111b
-11001001b | 10001111b = 11001111b
-11001001b | 10010000b = 11011001b
-11001001b | 10010001b = 11011001b
-11001001b | 10010010b = 11011011b
-11001001b | 10010011b = 11011011b
-11001001b | 10010100b = 11011101b
-11001001b | 10010101b = 11011101b
-11001001b | 10010110b = 11011111b
-11001001b | 10010111b = 11011111b
-11001001b | 10011000b = 11011001b
-11001001b | 10011001b = 11011001b
-11001001b | 10011010b = 11011011b
-11001001b | 10011011b = 11011011b
-11001001b | 10011100b = 11011101b
-11001001b | 10011101b = 11011101b
-11001001b | 10011110b = 11011111b
-11001001b | 10011111b = 11011111b
-11001001b | 10100000b = 11101001b
-11001001b | 10100001b = 11101001b
-11001001b | 10100010b = 11101011b
-11001001b | 10100011b = 11101011b
-11001001b | 10100100b = 11101101b
-11001001b | 10100101b = 11101101b
-11001001b | 10100110b = 11101111b
-11001001b | 10100111b = 11101111b
-11001001b | 10101000b = 11101001b
-11001001b | 10101001b = 11101001b
-11001001b | 10101010b = 11101011b
-11001001b | 10101011b = 11101011b
-11001001b | 10101100b = 11101101b
-11001001b | 10101101b = 11101101b
-11001001b | 10101110b = 11101111b
-11001001b | 10101111b = 11101111b
-11001001b | 10110000b = 11111001b
-11001001b | 10110001b = 11111001b
-11001001b | 10110010b = 11111011b
-11001001b | 10110011b = 11111011b
-11001001b | 10110100b = 11111101b
-11001001b | 10110101b = 11111101b
-11001001b | 10110110b = 11111111b
-11001001b | 10110111b = 11111111b
-11001001b | 10111000b = 11111001b
-11001001b | 10111001b = 11111001b
-11001001b | 10111010b = 11111011b
-11001001b | 10111011b = 11111011b
-11001001b | 10111100b = 11111101b
-11001001b | 10111101b = 11111101b
-11001001b | 10111110b = 11111111b
-11001001b | 10111111b = 11111111b
-11001001b | 11000000b = 11001001b
-11001001b | 11000001b = 11001001b
-11001001b | 11000010b = 11001011b
-11001001b | 11000011b = 11001011b
-11001001b | 11000100b = 11001101b
-11001001b | 11000101b = 11001101b
-11001001b | 11000110b = 11001111b
-11001001b | 11000111b = 11001111b
-11001001b | 11001000b = 11001001b
-11001001b | 11001001b = 11001001b
-11001001b | 11001010b = 11001011b
-11001001b | 11001011b = 11001011b
-11001001b | 11001100b = 11001101b
-11001001b | 11001101b = 11001101b
-11001001b | 11001110b = 11001111b
-11001001b | 11001111b = 11001111b
-11001001b | 11010000b = 11011001b
-11001001b | 11010001b = 11011001b
-11001001b | 11010010b = 11011011b
-11001001b | 11010011b = 11011011b
-11001001b | 11010100b = 11011101b
-11001001b | 11010101b = 11011101b
-11001001b | 11010110b = 11011111b
-11001001b | 11010111b = 11011111b
-11001001b | 11011000b = 11011001b
-11001001b | 11011001b = 11011001b
-11001001b | 11011010b = 11011011b
-11001001b | 11011011b = 11011011b
-11001001b | 11011100b = 11011101b
-11001001b | 11011101b = 11011101b
-11001001b | 11011110b = 11011111b
-11001001b | 11011111b = 11011111b
-11001001b | 11100000b = 11101001b
-11001001b | 11100001b = 11101001b
-11001001b | 11100010b = 11101011b
-11001001b | 11100011b = 11101011b
-11001001b | 11100100b = 11101101b
-11001001b | 11100101b = 11101101b
-11001001b | 11100110b = 11101111b
-11001001b | 11100111b = 11101111b
-11001001b | 11101000b = 11101001b
-11001001b | 11101001b = 11101001b
-11001001b | 11101010b = 11101011b
-11001001b | 11101011b = 11101011b
-11001001b | 11101100b = 11101101b
-11001001b | 11101101b = 11101101b
-11001001b | 11101110b = 11101111b
-11001001b | 11101111b = 11101111b
-11001001b | 11110000b = 11111001b
-11001001b | 11110001b = 11111001b
-11001001b | 11110010b = 11111011b
-11001001b | 11110011b = 11111011b
-11001001b | 11110100b = 11111101b
-11001001b | 11110101b = 11111101b
-11001001b | 11110110b = 11111111b
-11001001b | 11110111b = 11111111b
-11001001b | 11111000b = 11111001b
-11001001b | 11111001b = 11111001b
-11001001b | 11111010b = 11111011b
-11001001b | 11111011b = 11111011b
-11001001b | 11111100b = 11111101b
-11001001b | 11111101b = 11111101b
-11001001b | 11111110b = 11111111b
-11001001b | 11111111b = 11111111b
-11001001b | 00000000b = 11001001b
-11001001b | 00000001b = 11001001b
-11001001b | 00000010b = 11001011b
-11001001b | 00000011b = 11001011b
-11001001b | 00000100b = 11001101b
-11001001b | 00000101b = 11001101b
-11001001b | 00000110b = 11001111b
-11001001b | 00000111b = 11001111b
-11001001b | 00001000b = 11001001b
-11001001b | 00001001b = 11001001b
-11001001b | 00001010b = 11001011b
-11001001b | 00001011b = 11001011b
-11001001b | 00001100b = 11001101b
-11001001b | 00001101b = 11001101b
-11001001b | 00001110b = 11001111b
-11001001b | 00001111b = 11001111b
-11001001b | 00010000b = 11011001b
-11001001b | 00010001b = 11011001b
-11001001b | 00010010b = 11011011b
-11001001b | 00010011b = 11011011b
-11001001b | 00010100b = 11011101b
-11001001b | 00010101b = 11011101b
-11001001b | 00010110b = 11011111b
-11001001b | 00010111b = 11011111b
-11001001b | 00011000b = 11011001b
-11001001b | 00011001b = 11011001b
-11001001b | 00011010b = 11011011b
-11001001b | 00011011b = 11011011b
-11001001b | 00011100b = 11011101b
-11001001b | 00011101b = 11011101b
-11001001b | 00011110b = 11011111b
-11001001b | 00011111b = 11011111b
-11001001b | 00100000b = 11101001b
-11001001b | 00100001b = 11101001b
-11001001b | 00100010b = 11101011b
-11001001b | 00100011b = 11101011b
-11001001b | 00100100b = 11101101b
-11001001b | 00100101b = 11101101b
-11001001b | 00100110b = 11101111b
-11001001b | 00100111b = 11101111b
-11001001b | 00101000b = 11101001b
-11001001b | 00101001b = 11101001b
-11001001b | 00101010b = 11101011b
-11001001b | 00101011b = 11101011b
-11001001b | 00101100b = 11101101b
-11001001b | 00101101b = 11101101b
-11001001b | 00101110b = 11101111b
-11001001b | 00101111b = 11101111b
-11001001b | 00110000b = 11111001b
-11001001b | 00110001b = 11111001b
-11001001b | 00110010b = 11111011b
-11001001b | 00110011b = 11111011b
-11001001b | 00110100b = 11111101b
-11001001b | 00110101b = 11111101b
-11001001b | 00110110b = 11111111b
-11001001b | 00110111b = 11111111b
-11001001b | 00111000b = 11111001b
-11001001b | 00111001b = 11111001b
-11001001b | 00111010b = 11111011b
-11001001b | 00111011b = 11111011b
-11001001b | 00111100b = 11111101b
-11001001b | 00111101b = 11111101b
-11001001b | 00111110b = 11111111b
-11001001b | 00111111b = 11111111b
-11001001b | 01000000b = 11001001b
-11001001b | 01000001b = 11001001b
-11001001b | 01000010b = 11001011b
-11001001b | 01000011b = 11001011b
-11001001b | 01000100b = 11001101b
-11001001b | 01000101b = 11001101b
-11001001b | 01000110b = 11001111b
-11001001b | 01000111b = 11001111b
-11001001b | 01001000b = 11001001b
-11001001b | 01001001b = 11001001b
-11001001b | 01001010b = 11001011b
-11001001b | 01001011b = 11001011b
-11001001b | 01001100b = 11001101b
-11001001b | 01001101b = 11001101b
-11001001b | 01001110b = 11001111b
-11001001b | 01001111b = 11001111b
-11001001b | 01010000b = 11011001b
-11001001b | 01010001b = 11011001b
-11001001b | 01010010b = 11011011b
-11001001b | 01010011b = 11011011b
-11001001b | 01010100b = 11011101b
-11001001b | 01010101b = 11011101b
-11001001b | 01010110b = 11011111b
-11001001b | 01010111b = 11011111b
-11001001b | 01011000b = 11011001b
-11001001b | 01011001b = 11011001b
-11001001b | 01011010b = 11011011b
-11001001b | 01011011b = 11011011b
-11001001b | 01011100b = 11011101b
-11001001b | 01011101b = 11011101b
-11001001b | 01011110b = 11011111b
-11001001b | 01011111b = 11011111b
-11001001b | 01100000b = 11101001b
-11001001b | 01100001b = 11101001b
-11001001b | 01100010b = 11101011b
-11001001b | 01100011b = 11101011b
-11001001b | 01100100b = 11101101b
-11001001b | 01100101b = 11101101b
-11001001b | 01100110b = 11101111b
-11001001b | 01100111b = 11101111b
-11001001b | 01101000b = 11101001b
-11001001b | 01101001b = 11101001b
-11001001b | 01101010b = 11101011b
-11001001b | 01101011b = 11101011b
-11001001b | 01101100b = 11101101b
-11001001b | 01101101b = 11101101b
-11001001b | 01101110b = 11101111b
-11001001b | 01101111b = 11101111b
-11001001b | 01110000b = 11111001b
-11001001b | 01110001b = 11111001b
-11001001b | 01110010b = 11111011b
-11001001b | 01110011b = 11111011b
-11001001b | 01110100b = 11111101b
-11001001b | 01110101b = 11111101b
-11001001b | 01110110b = 11111111b
-11001001b | 01110111b = 11111111b
-11001001b | 01111000b = 11111001b
-11001001b | 01111001b = 11111001b
-11001001b | 01111010b = 11111011b
-11001001b | 01111011b = 11111011b
-11001001b | 01111100b = 11111101b
-11001001b | 01111101b = 11111101b
-11001001b | 01111110b = 11111111b
-11001010b | 10000000b = 11001010b
-11001010b | 10000001b = 11001011b
-11001010b | 10000010b = 11001010b
-11001010b | 10000011b = 11001011b
-11001010b | 10000100b = 11001110b
-11001010b | 10000101b = 11001111b
-11001010b | 10000110b = 11001110b
-11001010b | 10000111b = 11001111b
-11001010b | 10001000b = 11001010b
-11001010b | 10001001b = 11001011b
-11001010b | 10001010b = 11001010b
-11001010b | 10001011b = 11001011b
-11001010b | 10001100b = 11001110b
-11001010b | 10001101b = 11001111b
-11001010b | 10001110b = 11001110b
-11001010b | 10001111b = 11001111b
-11001010b | 10010000b = 11011010b
-11001010b | 10010001b = 11011011b
-11001010b | 10010010b = 11011010b
-11001010b | 10010011b = 11011011b
-11001010b | 10010100b = 11011110b
-11001010b | 10010101b = 11011111b
-11001010b | 10010110b = 11011110b
-11001010b | 10010111b = 11011111b
-11001010b | 10011000b = 11011010b
-11001010b | 10011001b = 11011011b
-11001010b | 10011010b = 11011010b
-11001010b | 10011011b = 11011011b
-11001010b | 10011100b = 11011110b
-11001010b | 10011101b = 11011111b
-11001010b | 10011110b = 11011110b
-11001010b | 10011111b = 11011111b
-11001010b | 10100000b = 11101010b
-11001010b | 10100001b = 11101011b
-11001010b | 10100010b = 11101010b
-11001010b | 10100011b = 11101011b
-11001010b | 10100100b = 11101110b
-11001010b | 10100101b = 11101111b
-11001010b | 10100110b = 11101110b
-11001010b | 10100111b = 11101111b
-11001010b | 10101000b = 11101010b
-11001010b | 10101001b = 11101011b
-11001010b | 10101010b = 11101010b
-11001010b | 10101011b = 11101011b
-11001010b | 10101100b = 11101110b
-11001010b | 10101101b = 11101111b
-11001010b | 10101110b = 11101110b
-11001010b | 10101111b = 11101111b
-11001010b | 10110000b = 11111010b
-11001010b | 10110001b = 11111011b
-11001010b | 10110010b = 11111010b
-11001010b | 10110011b = 11111011b
-11001010b | 10110100b = 11111110b
-11001010b | 10110101b = 11111111b
-11001010b | 10110110b = 11111110b
-11001010b | 10110111b = 11111111b
-11001010b | 10111000b = 11111010b
-11001010b | 10111001b = 11111011b
-11001010b | 10111010b = 11111010b
-11001010b | 10111011b = 11111011b
-11001010b | 10111100b = 11111110b
-11001010b | 10111101b = 11111111b
-11001010b | 10111110b = 11111110b
-11001010b | 10111111b = 11111111b
-11001010b | 11000000b = 11001010b
-11001010b | 11000001b = 11001011b
-11001010b | 11000010b = 11001010b
-11001010b | 11000011b = 11001011b
-11001010b | 11000100b = 11001110b
-11001010b | 11000101b = 11001111b
-11001010b | 11000110b = 11001110b
-11001010b | 11000111b = 11001111b
-11001010b | 11001000b = 11001010b
-11001010b | 11001001b = 11001011b
-11001010b | 11001010b = 11001010b
-11001010b | 11001011b = 11001011b
-11001010b | 11001100b = 11001110b
-11001010b | 11001101b = 11001111b
-11001010b | 11001110b = 11001110b
-11001010b | 11001111b = 11001111b
-11001010b | 11010000b = 11011010b
-11001010b | 11010001b = 11011011b
-11001010b | 11010010b = 11011010b
-11001010b | 11010011b = 11011011b
-11001010b | 11010100b = 11011110b
-11001010b | 11010101b = 11011111b
-11001010b | 11010110b = 11011110b
-11001010b | 11010111b = 11011111b
-11001010b | 11011000b = 11011010b
-11001010b | 11011001b = 11011011b
-11001010b | 11011010b = 11011010b
-11001010b | 11011011b = 11011011b
-11001010b | 11011100b = 11011110b
-11001010b | 11011101b = 11011111b
-11001010b | 11011110b = 11011110b
-11001010b | 11011111b = 11011111b
-11001010b | 11100000b = 11101010b
-11001010b | 11100001b = 11101011b
-11001010b | 11100010b = 11101010b
-11001010b | 11100011b = 11101011b
-11001010b | 11100100b = 11101110b
-11001010b | 11100101b = 11101111b
-11001010b | 11100110b = 11101110b
-11001010b | 11100111b = 11101111b
-11001010b | 11101000b = 11101010b
-11001010b | 11101001b = 11101011b
-11001010b | 11101010b = 11101010b
-11001010b | 11101011b = 11101011b
-11001010b | 11101100b = 11101110b
-11001010b | 11101101b = 11101111b
-11001010b | 11101110b = 11101110b
-11001010b | 11101111b = 11101111b
-11001010b | 11110000b = 11111010b
-11001010b | 11110001b = 11111011b
-11001010b | 11110010b = 11111010b
-11001010b | 11110011b = 11111011b
-11001010b | 11110100b = 11111110b
-11001010b | 11110101b = 11111111b
-11001010b | 11110110b = 11111110b
-11001010b | 11110111b = 11111111b
-11001010b | 11111000b = 11111010b
-11001010b | 11111001b = 11111011b
-11001010b | 11111010b = 11111010b
-11001010b | 11111011b = 11111011b
-11001010b | 11111100b = 11111110b
-11001010b | 11111101b = 11111111b
-11001010b | 11111110b = 11111110b
-11001010b | 11111111b = 11111111b
-11001010b | 00000000b = 11001010b
-11001010b | 00000001b = 11001011b
-11001010b | 00000010b = 11001010b
-11001010b | 00000011b = 11001011b
-11001010b | 00000100b = 11001110b
-11001010b | 00000101b = 11001111b
-11001010b | 00000110b = 11001110b
-11001010b | 00000111b = 11001111b
-11001010b | 00001000b = 11001010b
-11001010b | 00001001b = 11001011b
-11001010b | 00001010b = 11001010b
-11001010b | 00001011b = 11001011b
-11001010b | 00001100b = 11001110b
-11001010b | 00001101b = 11001111b
-11001010b | 00001110b = 11001110b
-11001010b | 00001111b = 11001111b
-11001010b | 00010000b = 11011010b
-11001010b | 00010001b = 11011011b
-11001010b | 00010010b = 11011010b
-11001010b | 00010011b = 11011011b
-11001010b | 00010100b = 11011110b
-11001010b | 00010101b = 11011111b
-11001010b | 00010110b = 11011110b
-11001010b | 00010111b = 11011111b
-11001010b | 00011000b = 11011010b
-11001010b | 00011001b = 11011011b
-11001010b | 00011010b = 11011010b
-11001010b | 00011011b = 11011011b
-11001010b | 00011100b = 11011110b
-11001010b | 00011101b = 11011111b
-11001010b | 00011110b = 11011110b
-11001010b | 00011111b = 11011111b
-11001010b | 00100000b = 11101010b
-11001010b | 00100001b = 11101011b
-11001010b | 00100010b = 11101010b
-11001010b | 00100011b = 11101011b
-11001010b | 00100100b = 11101110b
-11001010b | 00100101b = 11101111b
-11001010b | 00100110b = 11101110b
-11001010b | 00100111b = 11101111b
-11001010b | 00101000b = 11101010b
-11001010b | 00101001b = 11101011b
-11001010b | 00101010b = 11101010b
-11001010b | 00101011b = 11101011b
-11001010b | 00101100b = 11101110b
-11001010b | 00101101b = 11101111b
-11001010b | 00101110b = 11101110b
-11001010b | 00101111b = 11101111b
-11001010b | 00110000b = 11111010b
-11001010b | 00110001b = 11111011b
-11001010b | 00110010b = 11111010b
-11001010b | 00110011b = 11111011b
-11001010b | 00110100b = 11111110b
-11001010b | 00110101b = 11111111b
-11001010b | 00110110b = 11111110b
-11001010b | 00110111b = 11111111b
-11001010b | 00111000b = 11111010b
-11001010b | 00111001b = 11111011b
-11001010b | 00111010b = 11111010b
-11001010b | 00111011b = 11111011b
-11001010b | 00111100b = 11111110b
-11001010b | 00111101b = 11111111b
-11001010b | 00111110b = 11111110b
-11001010b | 00111111b = 11111111b
-11001010b | 01000000b = 11001010b
-11001010b | 01000001b = 11001011b
-11001010b | 01000010b = 11001010b
-11001010b | 01000011b = 11001011b
-11001010b | 01000100b = 11001110b
-11001010b | 01000101b = 11001111b
-11001010b | 01000110b = 11001110b
-11001010b | 01000111b = 11001111b
-11001010b | 01001000b = 11001010b
-11001010b | 01001001b = 11001011b
-11001010b | 01001010b = 11001010b
-11001010b | 01001011b = 11001011b
-11001010b | 01001100b = 11001110b
-11001010b | 01001101b = 11001111b
-11001010b | 01001110b = 11001110b
-11001010b | 01001111b = 11001111b
-11001010b | 01010000b = 11011010b
-11001010b | 01010001b = 11011011b
-11001010b | 01010010b = 11011010b
-11001010b | 01010011b = 11011011b
-11001010b | 01010100b = 11011110b
-11001010b | 01010101b = 11011111b
-11001010b | 01010110b = 11011110b
-11001010b | 01010111b = 11011111b
-11001010b | 01011000b = 11011010b
-11001010b | 01011001b = 11011011b
-11001010b | 01011010b = 11011010b
-11001010b | 01011011b = 11011011b
-11001010b | 01011100b = 11011110b
-11001010b | 01011101b = 11011111b
-11001010b | 01011110b = 11011110b
-11001010b | 01011111b = 11011111b
-11001010b | 01100000b = 11101010b
-11001010b | 01100001b = 11101011b
-11001010b | 01100010b = 11101010b
-11001010b | 01100011b = 11101011b
-11001010b | 01100100b = 11101110b
-11001010b | 01100101b = 11101111b
-11001010b | 01100110b = 11101110b
-11001010b | 01100111b = 11101111b
-11001010b | 01101000b = 11101010b
-11001010b | 01101001b = 11101011b
-11001010b | 01101010b = 11101010b
-11001010b | 01101011b = 11101011b
-11001010b | 01101100b = 11101110b
-11001010b | 01101101b = 11101111b
-11001010b | 01101110b = 11101110b
-11001010b | 01101111b = 11101111b
-11001010b | 01110000b = 11111010b
-11001010b | 01110001b = 11111011b
-11001010b | 01110010b = 11111010b
-11001010b | 01110011b = 11111011b
-11001010b | 01110100b = 11111110b
-11001010b | 01110101b = 11111111b
-11001010b | 01110110b = 11111110b
-11001010b | 01110111b = 11111111b
-11001010b | 01111000b = 11111010b
-11001010b | 01111001b = 11111011b
-11001010b | 01111010b = 11111010b
-11001010b | 01111011b = 11111011b
-11001010b | 01111100b = 11111110b
-11001010b | 01111101b = 11111111b
-11001010b | 01111110b = 11111110b
-11001011b | 10000000b = 11001011b
-11001011b | 10000001b = 11001011b
-11001011b | 10000010b = 11001011b
-11001011b | 10000011b = 11001011b
-11001011b | 10000100b = 11001111b
-11001011b | 10000101b = 11001111b
-11001011b | 10000110b = 11001111b
-11001011b | 10000111b = 11001111b
-11001011b | 10001000b = 11001011b
-11001011b | 10001001b = 11001011b
-11001011b | 10001010b = 11001011b
-11001011b | 10001011b = 11001011b
-11001011b | 10001100b = 11001111b
-11001011b | 10001101b = 11001111b
-11001011b | 10001110b = 11001111b
-11001011b | 10001111b = 11001111b
-11001011b | 10010000b = 11011011b
-11001011b | 10010001b = 11011011b
-11001011b | 10010010b = 11011011b
-11001011b | 10010011b = 11011011b
-11001011b | 10010100b = 11011111b
-11001011b | 10010101b = 11011111b
-11001011b | 10010110b = 11011111b
-11001011b | 10010111b = 11011111b
-11001011b | 10011000b = 11011011b
-11001011b | 10011001b = 11011011b
-11001011b | 10011010b = 11011011b
-11001011b | 10011011b = 11011011b
-11001011b | 10011100b = 11011111b
-11001011b | 10011101b = 11011111b
-11001011b | 10011110b = 11011111b
-11001011b | 10011111b = 11011111b
-11001011b | 10100000b = 11101011b
-11001011b | 10100001b = 11101011b
-11001011b | 10100010b = 11101011b
-11001011b | 10100011b = 11101011b
-11001011b | 10100100b = 11101111b
-11001011b | 10100101b = 11101111b
-11001011b | 10100110b = 11101111b
-11001011b | 10100111b = 11101111b
-11001011b | 10101000b = 11101011b
-11001011b | 10101001b = 11101011b
-11001011b | 10101010b = 11101011b
-11001011b | 10101011b = 11101011b
-11001011b | 10101100b = 11101111b
-11001011b | 10101101b = 11101111b
-11001011b | 10101110b = 11101111b
-11001011b | 10101111b = 11101111b
-11001011b | 10110000b = 11111011b
-11001011b | 10110001b = 11111011b
-11001011b | 10110010b = 11111011b
-11001011b | 10110011b = 11111011b
-11001011b | 10110100b = 11111111b
-11001011b | 10110101b = 11111111b
-11001011b | 10110110b = 11111111b
-11001011b | 10110111b = 11111111b
-11001011b | 10111000b = 11111011b
-11001011b | 10111001b = 11111011b
-11001011b | 10111010b = 11111011b
-11001011b | 10111011b = 11111011b
-11001011b | 10111100b = 11111111b
-11001011b | 10111101b = 11111111b
-11001011b | 10111110b = 11111111b
-11001011b | 10111111b = 11111111b
-11001011b | 11000000b = 11001011b
-11001011b | 11000001b = 11001011b
-11001011b | 11000010b = 11001011b
-11001011b | 11000011b = 11001011b
-11001011b | 11000100b = 11001111b
-11001011b | 11000101b = 11001111b
-11001011b | 11000110b = 11001111b
-11001011b | 11000111b = 11001111b
-11001011b | 11001000b = 11001011b
-11001011b | 11001001b = 11001011b
-11001011b | 11001010b = 11001011b
-11001011b | 11001011b = 11001011b
-11001011b | 11001100b = 11001111b
-11001011b | 11001101b = 11001111b
-11001011b | 11001110b = 11001111b
-11001011b | 11001111b = 11001111b
-11001011b | 11010000b = 11011011b
-11001011b | 11010001b = 11011011b
-11001011b | 11010010b = 11011011b
-11001011b | 11010011b = 11011011b
-11001011b | 11010100b = 11011111b
-11001011b | 11010101b = 11011111b
-11001011b | 11010110b = 11011111b
-11001011b | 11010111b = 11011111b
-11001011b | 11011000b = 11011011b
-11001011b | 11011001b = 11011011b
-11001011b | 11011010b = 11011011b
-11001011b | 11011011b = 11011011b
-11001011b | 11011100b = 11011111b
-11001011b | 11011101b = 11011111b
-11001011b | 11011110b = 11011111b
-11001011b | 11011111b = 11011111b
-11001011b | 11100000b = 11101011b
-11001011b | 11100001b = 11101011b
-11001011b | 11100010b = 11101011b
-11001011b | 11100011b = 11101011b
-11001011b | 11100100b = 11101111b
-11001011b | 11100101b = 11101111b
-11001011b | 11100110b = 11101111b
-11001011b | 11100111b = 11101111b
-11001011b | 11101000b = 11101011b
-11001011b | 11101001b = 11101011b
-11001011b | 11101010b = 11101011b
-11001011b | 11101011b = 11101011b
-11001011b | 11101100b = 11101111b
-11001011b | 11101101b = 11101111b
-11001011b | 11101110b = 11101111b
-11001011b | 11101111b = 11101111b
-11001011b | 11110000b = 11111011b
-11001011b | 11110001b = 11111011b
-11001011b | 11110010b = 11111011b
-11001011b | 11110011b = 11111011b
-11001011b | 11110100b = 11111111b
-11001011b | 11110101b = 11111111b
-11001011b | 11110110b = 11111111b
-11001011b | 11110111b = 11111111b
-11001011b | 11111000b = 11111011b
-11001011b | 11111001b = 11111011b
-11001011b | 11111010b = 11111011b
-11001011b | 11111011b = 11111011b
-11001011b | 11111100b = 11111111b
-11001011b | 11111101b = 11111111b
-11001011b | 11111110b = 11111111b
-11001011b | 11111111b = 11111111b
-11001011b | 00000000b = 11001011b
-11001011b | 00000001b = 11001011b
-11001011b | 00000010b = 11001011b
-11001011b | 00000011b = 11001011b
-11001011b | 00000100b = 11001111b
-11001011b | 00000101b = 11001111b
-11001011b | 00000110b = 11001111b
-11001011b | 00000111b = 11001111b
-11001011b | 00001000b = 11001011b
-11001011b | 00001001b = 11001011b
-11001011b | 00001010b = 11001011b
-11001011b | 00001011b = 11001011b
-11001011b | 00001100b = 11001111b
-11001011b | 00001101b = 11001111b
-11001011b | 00001110b = 11001111b
-11001011b | 00001111b = 11001111b
-11001011b | 00010000b = 11011011b
-11001011b | 00010001b = 11011011b
-11001011b | 00010010b = 11011011b
-11001011b | 00010011b = 11011011b
-11001011b | 00010100b = 11011111b
-11001011b | 00010101b = 11011111b
-11001011b | 00010110b = 11011111b
-11001011b | 00010111b = 11011111b
-11001011b | 00011000b = 11011011b
-11001011b | 00011001b = 11011011b
-11001011b | 00011010b = 11011011b
-11001011b | 00011011b = 11011011b
-11001011b | 00011100b = 11011111b
-11001011b | 00011101b = 11011111b
-11001011b | 00011110b = 11011111b
-11001011b | 00011111b = 11011111b
-11001011b | 00100000b = 11101011b
-11001011b | 00100001b = 11101011b
-11001011b | 00100010b = 11101011b
-11001011b | 00100011b = 11101011b
-11001011b | 00100100b = 11101111b
-11001011b | 00100101b = 11101111b
-11001011b | 00100110b = 11101111b
-11001011b | 00100111b = 11101111b
-11001011b | 00101000b = 11101011b
-11001011b | 00101001b = 11101011b
-11001011b | 00101010b = 11101011b
-11001011b | 00101011b = 11101011b
-11001011b | 00101100b = 11101111b
-11001011b | 00101101b = 11101111b
-11001011b | 00101110b = 11101111b
-11001011b | 00101111b = 11101111b
-11001011b | 00110000b = 11111011b
-11001011b | 00110001b = 11111011b
-11001011b | 00110010b = 11111011b
-11001011b | 00110011b = 11111011b
-11001011b | 00110100b = 11111111b
-11001011b | 00110101b = 11111111b
-11001011b | 00110110b = 11111111b
-11001011b | 00110111b = 11111111b
-11001011b | 00111000b = 11111011b
-11001011b | 00111001b = 11111011b
-11001011b | 00111010b = 11111011b
-11001011b | 00111011b = 11111011b
-11001011b | 00111100b = 11111111b
-11001011b | 00111101b = 11111111b
-11001011b | 00111110b = 11111111b
-11001011b | 00111111b = 11111111b
-11001011b | 01000000b = 11001011b
-11001011b | 01000001b = 11001011b
-11001011b | 01000010b = 11001011b
-11001011b | 01000011b = 11001011b
-11001011b | 01000100b = 11001111b
-11001011b | 01000101b = 11001111b
-11001011b | 01000110b = 11001111b
-11001011b | 01000111b = 11001111b
-11001011b | 01001000b = 11001011b
-11001011b | 01001001b = 11001011b
-11001011b | 01001010b = 11001011b
-11001011b | 01001011b = 11001011b
-11001011b | 01001100b = 11001111b
-11001011b | 01001101b = 11001111b
-11001011b | 01001110b = 11001111b
-11001011b | 01001111b = 11001111b
-11001011b | 01010000b = 11011011b
-11001011b | 01010001b = 11011011b
-11001011b | 01010010b = 11011011b
-11001011b | 01010011b = 11011011b
-11001011b | 01010100b = 11011111b
-11001011b | 01010101b = 11011111b
-11001011b | 01010110b = 11011111b
-11001011b | 01010111b = 11011111b
-11001011b | 01011000b = 11011011b
-11001011b | 01011001b = 11011011b
-11001011b | 01011010b = 11011011b
-11001011b | 01011011b = 11011011b
-11001011b | 01011100b = 11011111b
-11001011b | 01011101b = 11011111b
-11001011b | 01011110b = 11011111b
-11001011b | 01011111b = 11011111b
-11001011b | 01100000b = 11101011b
-11001011b | 01100001b = 11101011b
-11001011b | 01100010b = 11101011b
-11001011b | 01100011b = 11101011b
-11001011b | 01100100b = 11101111b
-11001011b | 01100101b = 11101111b
-11001011b | 01100110b = 11101111b
-11001011b | 01100111b = 11101111b
-11001011b | 01101000b = 11101011b
-11001011b | 01101001b = 11101011b
-11001011b | 01101010b = 11101011b
-11001011b | 01101011b = 11101011b
-11001011b | 01101100b = 11101111b
-11001011b | 01101101b = 11101111b
-11001011b | 01101110b = 11101111b
-11001011b | 01101111b = 11101111b
-11001011b | 01110000b = 11111011b
-11001011b | 01110001b = 11111011b
-11001011b | 01110010b = 11111011b
-11001011b | 01110011b = 11111011b
-11001011b | 01110100b = 11111111b
-11001011b | 01110101b = 11111111b
-11001011b | 01110110b = 11111111b
-11001011b | 01110111b = 11111111b
-11001011b | 01111000b = 11111011b
-11001011b | 01111001b = 11111011b
-11001011b | 01111010b = 11111011b
-11001011b | 01111011b = 11111011b
-11001011b | 01111100b = 11111111b
-11001011b | 01111101b = 11111111b
-11001011b | 01111110b = 11111111b
-11001100b | 10000000b = 11001100b
-11001100b | 10000001b = 11001101b
-11001100b | 10000010b = 11001110b
-11001100b | 10000011b = 11001111b
-11001100b | 10000100b = 11001100b
-11001100b | 10000101b = 11001101b
-11001100b | 10000110b = 11001110b
-11001100b | 10000111b = 11001111b
-11001100b | 10001000b = 11001100b
-11001100b | 10001001b = 11001101b
-11001100b | 10001010b = 11001110b
-11001100b | 10001011b = 11001111b
-11001100b | 10001100b = 11001100b
-11001100b | 10001101b = 11001101b
-11001100b | 10001110b = 11001110b
-11001100b | 10001111b = 11001111b
-11001100b | 10010000b = 11011100b
-11001100b | 10010001b = 11011101b
-11001100b | 10010010b = 11011110b
-11001100b | 10010011b = 11011111b
-11001100b | 10010100b = 11011100b
-11001100b | 10010101b = 11011101b
-11001100b | 10010110b = 11011110b
-11001100b | 10010111b = 11011111b
-11001100b | 10011000b = 11011100b
-11001100b | 10011001b = 11011101b
-11001100b | 10011010b = 11011110b
-11001100b | 10011011b = 11011111b
-11001100b | 10011100b = 11011100b
-11001100b | 10011101b = 11011101b
-11001100b | 10011110b = 11011110b
-11001100b | 10011111b = 11011111b
-11001100b | 10100000b = 11101100b
-11001100b | 10100001b = 11101101b
-11001100b | 10100010b = 11101110b
-11001100b | 10100011b = 11101111b
-11001100b | 10100100b = 11101100b
-11001100b | 10100101b = 11101101b
-11001100b | 10100110b = 11101110b
-11001100b | 10100111b = 11101111b
-11001100b | 10101000b = 11101100b
-11001100b | 10101001b = 11101101b
-11001100b | 10101010b = 11101110b
-11001100b | 10101011b = 11101111b
-11001100b | 10101100b = 11101100b
-11001100b | 10101101b = 11101101b
-11001100b | 10101110b = 11101110b
-11001100b | 10101111b = 11101111b
-11001100b | 10110000b = 11111100b
-11001100b | 10110001b = 11111101b
-11001100b | 10110010b = 11111110b
-11001100b | 10110011b = 11111111b
-11001100b | 10110100b = 11111100b
-11001100b | 10110101b = 11111101b
-11001100b | 10110110b = 11111110b
-11001100b | 10110111b = 11111111b
-11001100b | 10111000b = 11111100b
-11001100b | 10111001b = 11111101b
-11001100b | 10111010b = 11111110b
-11001100b | 10111011b = 11111111b
-11001100b | 10111100b = 11111100b
-11001100b | 10111101b = 11111101b
-11001100b | 10111110b = 11111110b
-11001100b | 10111111b = 11111111b
-11001100b | 11000000b = 11001100b
-11001100b | 11000001b = 11001101b
-11001100b | 11000010b = 11001110b
-11001100b | 11000011b = 11001111b
-11001100b | 11000100b = 11001100b
-11001100b | 11000101b = 11001101b
-11001100b | 11000110b = 11001110b
-11001100b | 11000111b = 11001111b
-11001100b | 11001000b = 11001100b
-11001100b | 11001001b = 11001101b
-11001100b | 11001010b = 11001110b
-11001100b | 11001011b = 11001111b
-11001100b | 11001100b = 11001100b
-11001100b | 11001101b = 11001101b
-11001100b | 11001110b = 11001110b
-11001100b | 11001111b = 11001111b
-11001100b | 11010000b = 11011100b
-11001100b | 11010001b = 11011101b
-11001100b | 11010010b = 11011110b
-11001100b | 11010011b = 11011111b
-11001100b | 11010100b = 11011100b
-11001100b | 11010101b = 11011101b
-11001100b | 11010110b = 11011110b
-11001100b | 11010111b = 11011111b
-11001100b | 11011000b = 11011100b
-11001100b | 11011001b = 11011101b
-11001100b | 11011010b = 11011110b
-11001100b | 11011011b = 11011111b
-11001100b | 11011100b = 11011100b
-11001100b | 11011101b = 11011101b
-11001100b | 11011110b = 11011110b
-11001100b | 11011111b = 11011111b
-11001100b | 11100000b = 11101100b
-11001100b | 11100001b = 11101101b
-11001100b | 11100010b = 11101110b
-11001100b | 11100011b = 11101111b
-11001100b | 11100100b = 11101100b
-11001100b | 11100101b = 11101101b
-11001100b | 11100110b = 11101110b
-11001100b | 11100111b = 11101111b
-11001100b | 11101000b = 11101100b
-11001100b | 11101001b = 11101101b
-11001100b | 11101010b = 11101110b
-11001100b | 11101011b = 11101111b
-11001100b | 11101100b = 11101100b
-11001100b | 11101101b = 11101101b
-11001100b | 11101110b = 11101110b
-11001100b | 11101111b = 11101111b
-11001100b | 11110000b = 11111100b
-11001100b | 11110001b = 11111101b
-11001100b | 11110010b = 11111110b
-11001100b | 11110011b = 11111111b
-11001100b | 11110100b = 11111100b
-11001100b | 11110101b = 11111101b
-11001100b | 11110110b = 11111110b
-11001100b | 11110111b = 11111111b
-11001100b | 11111000b = 11111100b
-11001100b | 11111001b = 11111101b
-11001100b | 11111010b = 11111110b
-11001100b | 11111011b = 11111111b
-11001100b | 11111100b = 11111100b
-11001100b | 11111101b = 11111101b
-11001100b | 11111110b = 11111110b
-11001100b | 11111111b = 11111111b
-11001100b | 00000000b = 11001100b
-11001100b | 00000001b = 11001101b
-11001100b | 00000010b = 11001110b
-11001100b | 00000011b = 11001111b
-11001100b | 00000100b = 11001100b
-11001100b | 00000101b = 11001101b
-11001100b | 00000110b = 11001110b
-11001100b | 00000111b = 11001111b
-11001100b | 00001000b = 11001100b
-11001100b | 00001001b = 11001101b
-11001100b | 00001010b = 11001110b
-11001100b | 00001011b = 11001111b
-11001100b | 00001100b = 11001100b
-11001100b | 00001101b = 11001101b
-11001100b | 00001110b = 11001110b
-11001100b | 00001111b = 11001111b
-11001100b | 00010000b = 11011100b
-11001100b | 00010001b = 11011101b
-11001100b | 00010010b = 11011110b
-11001100b | 00010011b = 11011111b
-11001100b | 00010100b = 11011100b
-11001100b | 00010101b = 11011101b
-11001100b | 00010110b = 11011110b
-11001100b | 00010111b = 11011111b
-11001100b | 00011000b = 11011100b
-11001100b | 00011001b = 11011101b
-11001100b | 00011010b = 11011110b
-11001100b | 00011011b = 11011111b
-11001100b | 00011100b = 11011100b
-11001100b | 00011101b = 11011101b
-11001100b | 00011110b = 11011110b
-11001100b | 00011111b = 11011111b
-11001100b | 00100000b = 11101100b
-11001100b | 00100001b = 11101101b
-11001100b | 00100010b = 11101110b
-11001100b | 00100011b = 11101111b
-11001100b | 00100100b = 11101100b
-11001100b | 00100101b = 11101101b
-11001100b | 00100110b = 11101110b
-11001100b | 00100111b = 11101111b
-11001100b | 00101000b = 11101100b
-11001100b | 00101001b = 11101101b
-11001100b | 00101010b = 11101110b
-11001100b | 00101011b = 11101111b
-11001100b | 00101100b = 11101100b
-11001100b | 00101101b = 11101101b
-11001100b | 00101110b = 11101110b
-11001100b | 00101111b = 11101111b
-11001100b | 00110000b = 11111100b
-11001100b | 00110001b = 11111101b
-11001100b | 00110010b = 11111110b
-11001100b | 00110011b = 11111111b
-11001100b | 00110100b = 11111100b
-11001100b | 00110101b = 11111101b
-11001100b | 00110110b = 11111110b
-11001100b | 00110111b = 11111111b
-11001100b | 00111000b = 11111100b
-11001100b | 00111001b = 11111101b
-11001100b | 00111010b = 11111110b
-11001100b | 00111011b = 11111111b
-11001100b | 00111100b = 11111100b
-11001100b | 00111101b = 11111101b
-11001100b | 00111110b = 11111110b
-11001100b | 00111111b = 11111111b
-11001100b | 01000000b = 11001100b
-11001100b | 01000001b = 11001101b
-11001100b | 01000010b = 11001110b
-11001100b | 01000011b = 11001111b
-11001100b | 01000100b = 11001100b
-11001100b | 01000101b = 11001101b
-11001100b | 01000110b = 11001110b
-11001100b | 01000111b = 11001111b
-11001100b | 01001000b = 11001100b
-11001100b | 01001001b = 11001101b
-11001100b | 01001010b = 11001110b
-11001100b | 01001011b = 11001111b
-11001100b | 01001100b = 11001100b
-11001100b | 01001101b = 11001101b
-11001100b | 01001110b = 11001110b
-11001100b | 01001111b = 11001111b
-11001100b | 01010000b = 11011100b
-11001100b | 01010001b = 11011101b
-11001100b | 01010010b = 11011110b
-11001100b | 01010011b = 11011111b
-11001100b | 01010100b = 11011100b
-11001100b | 01010101b = 11011101b
-11001100b | 01010110b = 11011110b
-11001100b | 01010111b = 11011111b
-11001100b | 01011000b = 11011100b
-11001100b | 01011001b = 11011101b
-11001100b | 01011010b = 11011110b
-11001100b | 01011011b = 11011111b
-11001100b | 01011100b = 11011100b
-11001100b | 01011101b = 11011101b
-11001100b | 01011110b = 11011110b
-11001100b | 01011111b = 11011111b
-11001100b | 01100000b = 11101100b
-11001100b | 01100001b = 11101101b
-11001100b | 01100010b = 11101110b
-11001100b | 01100011b = 11101111b
-11001100b | 01100100b = 11101100b
-11001100b | 01100101b = 11101101b
-11001100b | 01100110b = 11101110b
-11001100b | 01100111b = 11101111b
-11001100b | 01101000b = 11101100b
-11001100b | 01101001b = 11101101b
-11001100b | 01101010b = 11101110b
-11001100b | 01101011b = 11101111b
-11001100b | 01101100b = 11101100b
-11001100b | 01101101b = 11101101b
-11001100b | 01101110b = 11101110b
-11001100b | 01101111b = 11101111b
-11001100b | 01110000b = 11111100b
-11001100b | 01110001b = 11111101b
-11001100b | 01110010b = 11111110b
-11001100b | 01110011b = 11111111b
-11001100b | 01110100b = 11111100b
-11001100b | 01110101b = 11111101b
-11001100b | 01110110b = 11111110b
-11001100b | 01110111b = 11111111b
-11001100b | 01111000b = 11111100b
-11001100b | 01111001b = 11111101b
-11001100b | 01111010b = 11111110b
-11001100b | 01111011b = 11111111b
-11001100b | 01111100b = 11111100b
-11001100b | 01111101b = 11111101b
-11001100b | 01111110b = 11111110b
-11001101b | 10000000b = 11001101b
-11001101b | 10000001b = 11001101b
-11001101b | 10000010b = 11001111b
-11001101b | 10000011b = 11001111b
-11001101b | 10000100b = 11001101b
-11001101b | 10000101b = 11001101b
-11001101b | 10000110b = 11001111b
-11001101b | 10000111b = 11001111b
-11001101b | 10001000b = 11001101b
-11001101b | 10001001b = 11001101b
-11001101b | 10001010b = 11001111b
-11001101b | 10001011b = 11001111b
-11001101b | 10001100b = 11001101b
-11001101b | 10001101b = 11001101b
-11001101b | 10001110b = 11001111b
-11001101b | 10001111b = 11001111b
-11001101b | 10010000b = 11011101b
-11001101b | 10010001b = 11011101b
-11001101b | 10010010b = 11011111b
-11001101b | 10010011b = 11011111b
-11001101b | 10010100b = 11011101b
-11001101b | 10010101b = 11011101b
-11001101b | 10010110b = 11011111b
-11001101b | 10010111b = 11011111b
-11001101b | 10011000b = 11011101b
-11001101b | 10011001b = 11011101b
-11001101b | 10011010b = 11011111b
-11001101b | 10011011b = 11011111b
-11001101b | 10011100b = 11011101b
-11001101b | 10011101b = 11011101b
-11001101b | 10011110b = 11011111b
-11001101b | 10011111b = 11011111b
-11001101b | 10100000b = 11101101b
-11001101b | 10100001b = 11101101b
-11001101b | 10100010b = 11101111b
-11001101b | 10100011b = 11101111b
-11001101b | 10100100b = 11101101b
-11001101b | 10100101b = 11101101b
-11001101b | 10100110b = 11101111b
-11001101b | 10100111b = 11101111b
-11001101b | 10101000b = 11101101b
-11001101b | 10101001b = 11101101b
-11001101b | 10101010b = 11101111b
-11001101b | 10101011b = 11101111b
-11001101b | 10101100b = 11101101b
-11001101b | 10101101b = 11101101b
-11001101b | 10101110b = 11101111b
-11001101b | 10101111b = 11101111b
-11001101b | 10110000b = 11111101b
-11001101b | 10110001b = 11111101b
-11001101b | 10110010b = 11111111b
-11001101b | 10110011b = 11111111b
-11001101b | 10110100b = 11111101b
-11001101b | 10110101b = 11111101b
-11001101b | 10110110b = 11111111b
-11001101b | 10110111b = 11111111b
-11001101b | 10111000b = 11111101b
-11001101b | 10111001b = 11111101b
-11001101b | 10111010b = 11111111b
-11001101b | 10111011b = 11111111b
-11001101b | 10111100b = 11111101b
-11001101b | 10111101b = 11111101b
-11001101b | 10111110b = 11111111b
-11001101b | 10111111b = 11111111b
-11001101b | 11000000b = 11001101b
-11001101b | 11000001b = 11001101b
-11001101b | 11000010b = 11001111b
-11001101b | 11000011b = 11001111b
-11001101b | 11000100b = 11001101b
-11001101b | 11000101b = 11001101b
-11001101b | 11000110b = 11001111b
-11001101b | 11000111b = 11001111b
-11001101b | 11001000b = 11001101b
-11001101b | 11001001b = 11001101b
-11001101b | 11001010b = 11001111b
-11001101b | 11001011b = 11001111b
-11001101b | 11001100b = 11001101b
-11001101b | 11001101b = 11001101b
-11001101b | 11001110b = 11001111b
-11001101b | 11001111b = 11001111b
-11001101b | 11010000b = 11011101b
-11001101b | 11010001b = 11011101b
-11001101b | 11010010b = 11011111b
-11001101b | 11010011b = 11011111b
-11001101b | 11010100b = 11011101b
-11001101b | 11010101b = 11011101b
-11001101b | 11010110b = 11011111b
-11001101b | 11010111b = 11011111b
-11001101b | 11011000b = 11011101b
-11001101b | 11011001b = 11011101b
-11001101b | 11011010b = 11011111b
-11001101b | 11011011b = 11011111b
-11001101b | 11011100b = 11011101b
-11001101b | 11011101b = 11011101b
-11001101b | 11011110b = 11011111b
-11001101b | 11011111b = 11011111b
-11001101b | 11100000b = 11101101b
-11001101b | 11100001b = 11101101b
-11001101b | 11100010b = 11101111b
-11001101b | 11100011b = 11101111b
-11001101b | 11100100b = 11101101b
-11001101b | 11100101b = 11101101b
-11001101b | 11100110b = 11101111b
-11001101b | 11100111b = 11101111b
-11001101b | 11101000b = 11101101b
-11001101b | 11101001b = 11101101b
-11001101b | 11101010b = 11101111b
-11001101b | 11101011b = 11101111b
-11001101b | 11101100b = 11101101b
-11001101b | 11101101b = 11101101b
-11001101b | 11101110b = 11101111b
-11001101b | 11101111b = 11101111b
-11001101b | 11110000b = 11111101b
-11001101b | 11110001b = 11111101b
-11001101b | 11110010b = 11111111b
-11001101b | 11110011b = 11111111b
-11001101b | 11110100b = 11111101b
-11001101b | 11110101b = 11111101b
-11001101b | 11110110b = 11111111b
-11001101b | 11110111b = 11111111b
-11001101b | 11111000b = 11111101b
-11001101b | 11111001b = 11111101b
-11001101b | 11111010b = 11111111b
-11001101b | 11111011b = 11111111b
-11001101b | 11111100b = 11111101b
-11001101b | 11111101b = 11111101b
-11001101b | 11111110b = 11111111b
-11001101b | 11111111b = 11111111b
-11001101b | 00000000b = 11001101b
-11001101b | 00000001b = 11001101b
-11001101b | 00000010b = 11001111b
-11001101b | 00000011b = 11001111b
-11001101b | 00000100b = 11001101b
-11001101b | 00000101b = 11001101b
-11001101b | 00000110b = 11001111b
-11001101b | 00000111b = 11001111b
-11001101b | 00001000b = 11001101b
-11001101b | 00001001b = 11001101b
-11001101b | 00001010b = 11001111b
-11001101b | 00001011b = 11001111b
-11001101b | 00001100b = 11001101b
-11001101b | 00001101b = 11001101b
-11001101b | 00001110b = 11001111b
-11001101b | 00001111b = 11001111b
-11001101b | 00010000b = 11011101b
-11001101b | 00010001b = 11011101b
-11001101b | 00010010b = 11011111b
-11001101b | 00010011b = 11011111b
-11001101b | 00010100b = 11011101b
-11001101b | 00010101b = 11011101b
-11001101b | 00010110b = 11011111b
-11001101b | 00010111b = 11011111b
-11001101b | 00011000b = 11011101b
-11001101b | 00011001b = 11011101b
-11001101b | 00011010b = 11011111b
-11001101b | 00011011b = 11011111b
-11001101b | 00011100b = 11011101b
-11001101b | 00011101b = 11011101b
-11001101b | 00011110b = 11011111b
-11001101b | 00011111b = 11011111b
-11001101b | 00100000b = 11101101b
-11001101b | 00100001b = 11101101b
-11001101b | 00100010b = 11101111b
-11001101b | 00100011b = 11101111b
-11001101b | 00100100b = 11101101b
-11001101b | 00100101b = 11101101b
-11001101b | 00100110b = 11101111b
-11001101b | 00100111b = 11101111b
-11001101b | 00101000b = 11101101b
-11001101b | 00101001b = 11101101b
-11001101b | 00101010b = 11101111b
-11001101b | 00101011b = 11101111b
-11001101b | 00101100b = 11101101b
-11001101b | 00101101b = 11101101b
-11001101b | 00101110b = 11101111b
-11001101b | 00101111b = 11101111b
-11001101b | 00110000b = 11111101b
-11001101b | 00110001b = 11111101b
-11001101b | 00110010b = 11111111b
-11001101b | 00110011b = 11111111b
-11001101b | 00110100b = 11111101b
-11001101b | 00110101b = 11111101b
-11001101b | 00110110b = 11111111b
-11001101b | 00110111b = 11111111b
-11001101b | 00111000b = 11111101b
-11001101b | 00111001b = 11111101b
-11001101b | 00111010b = 11111111b
-11001101b | 00111011b = 11111111b
-11001101b | 00111100b = 11111101b
-11001101b | 00111101b = 11111101b
-11001101b | 00111110b = 11111111b
-11001101b | 00111111b = 11111111b
-11001101b | 01000000b = 11001101b
-11001101b | 01000001b = 11001101b
-11001101b | 01000010b = 11001111b
-11001101b | 01000011b = 11001111b
-11001101b | 01000100b = 11001101b
-11001101b | 01000101b = 11001101b
-11001101b | 01000110b = 11001111b
-11001101b | 01000111b = 11001111b
-11001101b | 01001000b = 11001101b
-11001101b | 01001001b = 11001101b
-11001101b | 01001010b = 11001111b
-11001101b | 01001011b = 11001111b
-11001101b | 01001100b = 11001101b
-11001101b | 01001101b = 11001101b
-11001101b | 01001110b = 11001111b
-11001101b | 01001111b = 11001111b
-11001101b | 01010000b = 11011101b
-11001101b | 01010001b = 11011101b
-11001101b | 01010010b = 11011111b
-11001101b | 01010011b = 11011111b
-11001101b | 01010100b = 11011101b
-11001101b | 01010101b = 11011101b
-11001101b | 01010110b = 11011111b
-11001101b | 01010111b = 11011111b
-11001101b | 01011000b = 11011101b
-11001101b | 01011001b = 11011101b
-11001101b | 01011010b = 11011111b
-11001101b | 01011011b = 11011111b
-11001101b | 01011100b = 11011101b
-11001101b | 01011101b = 11011101b
-11001101b | 01011110b = 11011111b
-11001101b | 01011111b = 11011111b
-11001101b | 01100000b = 11101101b
-11001101b | 01100001b = 11101101b
-11001101b | 01100010b = 11101111b
-11001101b | 01100011b = 11101111b
-11001101b | 01100100b = 11101101b
-11001101b | 01100101b = 11101101b
-11001101b | 01100110b = 11101111b
-11001101b | 01100111b = 11101111b
-11001101b | 01101000b = 11101101b
-11001101b | 01101001b = 11101101b
-11001101b | 01101010b = 11101111b
-11001101b | 01101011b = 11101111b
-11001101b | 01101100b = 11101101b
-11001101b | 01101101b = 11101101b
-11001101b | 01101110b = 11101111b
-11001101b | 01101111b = 11101111b
-11001101b | 01110000b = 11111101b
-11001101b | 01110001b = 11111101b
-11001101b | 01110010b = 11111111b
-11001101b | 01110011b = 11111111b
-11001101b | 01110100b = 11111101b
-11001101b | 01110101b = 11111101b
-11001101b | 01110110b = 11111111b
-11001101b | 01110111b = 11111111b
-11001101b | 01111000b = 11111101b
-11001101b | 01111001b = 11111101b
-11001101b | 01111010b = 11111111b
-11001101b | 01111011b = 11111111b
-11001101b | 01111100b = 11111101b
-11001101b | 01111101b = 11111101b
-11001101b | 01111110b = 11111111b
-11001110b | 10000000b = 11001110b
-11001110b | 10000001b = 11001111b
-11001110b | 10000010b = 11001110b
-11001110b | 10000011b = 11001111b
-11001110b | 10000100b = 11001110b
-11001110b | 10000101b = 11001111b
-11001110b | 10000110b = 11001110b
-11001110b | 10000111b = 11001111b
-11001110b | 10001000b = 11001110b
-11001110b | 10001001b = 11001111b
-11001110b | 10001010b = 11001110b
-11001110b | 10001011b = 11001111b
-11001110b | 10001100b = 11001110b
-11001110b | 10001101b = 11001111b
-11001110b | 10001110b = 11001110b
-11001110b | 10001111b = 11001111b
-11001110b | 10010000b = 11011110b
-11001110b | 10010001b = 11011111b
-11001110b | 10010010b = 11011110b
-11001110b | 10010011b = 11011111b
-11001110b | 10010100b = 11011110b
-11001110b | 10010101b = 11011111b
-11001110b | 10010110b = 11011110b
-11001110b | 10010111b = 11011111b
-11001110b | 10011000b = 11011110b
-11001110b | 10011001b = 11011111b
-11001110b | 10011010b = 11011110b
-11001110b | 10011011b = 11011111b
-11001110b | 10011100b = 11011110b
-11001110b | 10011101b = 11011111b
-11001110b | 10011110b = 11011110b
-11001110b | 10011111b = 11011111b
-11001110b | 10100000b = 11101110b
-11001110b | 10100001b = 11101111b
-11001110b | 10100010b = 11101110b
-11001110b | 10100011b = 11101111b
-11001110b | 10100100b = 11101110b
-11001110b | 10100101b = 11101111b
-11001110b | 10100110b = 11101110b
-11001110b | 10100111b = 11101111b
-11001110b | 10101000b = 11101110b
-11001110b | 10101001b = 11101111b
-11001110b | 10101010b = 11101110b
-11001110b | 10101011b = 11101111b
-11001110b | 10101100b = 11101110b
-11001110b | 10101101b = 11101111b
-11001110b | 10101110b = 11101110b
-11001110b | 10101111b = 11101111b
-11001110b | 10110000b = 11111110b
-11001110b | 10110001b = 11111111b
-11001110b | 10110010b = 11111110b
-11001110b | 10110011b = 11111111b
-11001110b | 10110100b = 11111110b
-11001110b | 10110101b = 11111111b
-11001110b | 10110110b = 11111110b
-11001110b | 10110111b = 11111111b
-11001110b | 10111000b = 11111110b
-11001110b | 10111001b = 11111111b
-11001110b | 10111010b = 11111110b
-11001110b | 10111011b = 11111111b
-11001110b | 10111100b = 11111110b
-11001110b | 10111101b = 11111111b
-11001110b | 10111110b = 11111110b
-11001110b | 10111111b = 11111111b
-11001110b | 11000000b = 11001110b
-11001110b | 11000001b = 11001111b
-11001110b | 11000010b = 11001110b
-11001110b | 11000011b = 11001111b
-11001110b | 11000100b = 11001110b
-11001110b | 11000101b = 11001111b
-11001110b | 11000110b = 11001110b
-11001110b | 11000111b = 11001111b
-11001110b | 11001000b = 11001110b
-11001110b | 11001001b = 11001111b
-11001110b | 11001010b = 11001110b
-11001110b | 11001011b = 11001111b
-11001110b | 11001100b = 11001110b
-11001110b | 11001101b = 11001111b
-11001110b | 11001110b = 11001110b
-11001110b | 11001111b = 11001111b
-11001110b | 11010000b = 11011110b
-11001110b | 11010001b = 11011111b
-11001110b | 11010010b = 11011110b
-11001110b | 11010011b = 11011111b
-11001110b | 11010100b = 11011110b
-11001110b | 11010101b = 11011111b
-11001110b | 11010110b = 11011110b
-11001110b | 11010111b = 11011111b
-11001110b | 11011000b = 11011110b
-11001110b | 11011001b = 11011111b
-11001110b | 11011010b = 11011110b
-11001110b | 11011011b = 11011111b
-11001110b | 11011100b = 11011110b
-11001110b | 11011101b = 11011111b
-11001110b | 11011110b = 11011110b
-11001110b | 11011111b = 11011111b
-11001110b | 11100000b = 11101110b
-11001110b | 11100001b = 11101111b
-11001110b | 11100010b = 11101110b
-11001110b | 11100011b = 11101111b
-11001110b | 11100100b = 11101110b
-11001110b | 11100101b = 11101111b
-11001110b | 11100110b = 11101110b
-11001110b | 11100111b = 11101111b
-11001110b | 11101000b = 11101110b
-11001110b | 11101001b = 11101111b
-11001110b | 11101010b = 11101110b
-11001110b | 11101011b = 11101111b
-11001110b | 11101100b = 11101110b
-11001110b | 11101101b = 11101111b
-11001110b | 11101110b = 11101110b
-11001110b | 11101111b = 11101111b
-11001110b | 11110000b = 11111110b
-11001110b | 11110001b = 11111111b
-11001110b | 11110010b = 11111110b
-11001110b | 11110011b = 11111111b
-11001110b | 11110100b = 11111110b
-11001110b | 11110101b = 11111111b
-11001110b | 11110110b = 11111110b
-11001110b | 11110111b = 11111111b
-11001110b | 11111000b = 11111110b
-11001110b | 11111001b = 11111111b
-11001110b | 11111010b = 11111110b
-11001110b | 11111011b = 11111111b
-11001110b | 11111100b = 11111110b
-11001110b | 11111101b = 11111111b
-11001110b | 11111110b = 11111110b
-11001110b | 11111111b = 11111111b
-11001110b | 00000000b = 11001110b
-11001110b | 00000001b = 11001111b
-11001110b | 00000010b = 11001110b
-11001110b | 00000011b = 11001111b
-11001110b | 00000100b = 11001110b
-11001110b | 00000101b = 11001111b
-11001110b | 00000110b = 11001110b
-11001110b | 00000111b = 11001111b
-11001110b | 00001000b = 11001110b
-11001110b | 00001001b = 11001111b
-11001110b | 00001010b = 11001110b
-11001110b | 00001011b = 11001111b
-11001110b | 00001100b = 11001110b
-11001110b | 00001101b = 11001111b
-11001110b | 00001110b = 11001110b
-11001110b | 00001111b = 11001111b
-11001110b | 00010000b = 11011110b
-11001110b | 00010001b = 11011111b
-11001110b | 00010010b = 11011110b
-11001110b | 00010011b = 11011111b
-11001110b | 00010100b = 11011110b
-11001110b | 00010101b = 11011111b
-11001110b | 00010110b = 11011110b
-11001110b | 00010111b = 11011111b
-11001110b | 00011000b = 11011110b
-11001110b | 00011001b = 11011111b
-11001110b | 00011010b = 11011110b
-11001110b | 00011011b = 11011111b
-11001110b | 00011100b = 11011110b
-11001110b | 00011101b = 11011111b
-11001110b | 00011110b = 11011110b
-11001110b | 00011111b = 11011111b
-11001110b | 00100000b = 11101110b
-11001110b | 00100001b = 11101111b
-11001110b | 00100010b = 11101110b
-11001110b | 00100011b = 11101111b
-11001110b | 00100100b = 11101110b
-11001110b | 00100101b = 11101111b
-11001110b | 00100110b = 11101110b
-11001110b | 00100111b = 11101111b
-11001110b | 00101000b = 11101110b
-11001110b | 00101001b = 11101111b
-11001110b | 00101010b = 11101110b
-11001110b | 00101011b = 11101111b
-11001110b | 00101100b = 11101110b
-11001110b | 00101101b = 11101111b
-11001110b | 00101110b = 11101110b
-11001110b | 00101111b = 11101111b
-11001110b | 00110000b = 11111110b
-11001110b | 00110001b = 11111111b
-11001110b | 00110010b = 11111110b
-11001110b | 00110011b = 11111111b
-11001110b | 00110100b = 11111110b
-11001110b | 00110101b = 11111111b
-11001110b | 00110110b = 11111110b
-11001110b | 00110111b = 11111111b
-11001110b | 00111000b = 11111110b
-11001110b | 00111001b = 11111111b
-11001110b | 00111010b = 11111110b
-11001110b | 00111011b = 11111111b
-11001110b | 00111100b = 11111110b
-11001110b | 00111101b = 11111111b
-11001110b | 00111110b = 11111110b
-11001110b | 00111111b = 11111111b
-11001110b | 01000000b = 11001110b
-11001110b | 01000001b = 11001111b
-11001110b | 01000010b = 11001110b
-11001110b | 01000011b = 11001111b
-11001110b | 01000100b = 11001110b
-11001110b | 01000101b = 11001111b
-11001110b | 01000110b = 11001110b
-11001110b | 01000111b = 11001111b
-11001110b | 01001000b = 11001110b
-11001110b | 01001001b = 11001111b
-11001110b | 01001010b = 11001110b
-11001110b | 01001011b = 11001111b
-11001110b | 01001100b = 11001110b
-11001110b | 01001101b = 11001111b
-11001110b | 01001110b = 11001110b
-11001110b | 01001111b = 11001111b
-11001110b | 01010000b = 11011110b
-11001110b | 01010001b = 11011111b
-11001110b | 01010010b = 11011110b
-11001110b | 01010011b = 11011111b
-11001110b | 01010100b = 11011110b
-11001110b | 01010101b = 11011111b
-11001110b | 01010110b = 11011110b
-11001110b | 01010111b = 11011111b
-11001110b | 01011000b = 11011110b
-11001110b | 01011001b = 11011111b
-11001110b | 01011010b = 11011110b
-11001110b | 01011011b = 11011111b
-11001110b | 01011100b = 11011110b
-11001110b | 01011101b = 11011111b
-11001110b | 01011110b = 11011110b
-11001110b | 01011111b = 11011111b
-11001110b | 01100000b = 11101110b
-11001110b | 01100001b = 11101111b
-11001110b | 01100010b = 11101110b
-11001110b | 01100011b = 11101111b
-11001110b | 01100100b = 11101110b
-11001110b | 01100101b = 11101111b
-11001110b | 01100110b = 11101110b
-11001110b | 01100111b = 11101111b
-11001110b | 01101000b = 11101110b
-11001110b | 01101001b = 11101111b
-11001110b | 01101010b = 11101110b
-11001110b | 01101011b = 11101111b
-11001110b | 01101100b = 11101110b
-11001110b | 01101101b = 11101111b
-11001110b | 01101110b = 11101110b
-11001110b | 01101111b = 11101111b
-11001110b | 01110000b = 11111110b
-11001110b | 01110001b = 11111111b
-11001110b | 01110010b = 11111110b
-11001110b | 01110011b = 11111111b
-11001110b | 01110100b = 11111110b
-11001110b | 01110101b = 11111111b
-11001110b | 01110110b = 11111110b
-11001110b | 01110111b = 11111111b
-11001110b | 01111000b = 11111110b
-11001110b | 01111001b = 11111111b
-11001110b | 01111010b = 11111110b
-11001110b | 01111011b = 11111111b
-11001110b | 01111100b = 11111110b
-11001110b | 01111101b = 11111111b
-11001110b | 01111110b = 11111110b
-11001111b | 10000000b = 11001111b
-11001111b | 10000001b = 11001111b
-11001111b | 10000010b = 11001111b
-11001111b | 10000011b = 11001111b
-11001111b | 10000100b = 11001111b
-11001111b | 10000101b = 11001111b
-11001111b | 10000110b = 11001111b
-11001111b | 10000111b = 11001111b
-11001111b | 10001000b = 11001111b
-11001111b | 10001001b = 11001111b
-11001111b | 10001010b = 11001111b
-11001111b | 10001011b = 11001111b
-11001111b | 10001100b = 11001111b
-11001111b | 10001101b = 11001111b
-11001111b | 10001110b = 11001111b
-11001111b | 10001111b = 11001111b
-11001111b | 10010000b = 11011111b
-11001111b | 10010001b = 11011111b
-11001111b | 10010010b = 11011111b
-11001111b | 10010011b = 11011111b
-11001111b | 10010100b = 11011111b
-11001111b | 10010101b = 11011111b
-11001111b | 10010110b = 11011111b
-11001111b | 10010111b = 11011111b
-11001111b | 10011000b = 11011111b
-11001111b | 10011001b = 11011111b
-11001111b | 10011010b = 11011111b
-11001111b | 10011011b = 11011111b
-11001111b | 10011100b = 11011111b
-11001111b | 10011101b = 11011111b
-11001111b | 10011110b = 11011111b
-11001111b | 10011111b = 11011111b
-11001111b | 10100000b = 11101111b
-11001111b | 10100001b = 11101111b
-11001111b | 10100010b = 11101111b
-11001111b | 10100011b = 11101111b
-11001111b | 10100100b = 11101111b
-11001111b | 10100101b = 11101111b
-11001111b | 10100110b = 11101111b
-11001111b | 10100111b = 11101111b
-11001111b | 10101000b = 11101111b
-11001111b | 10101001b = 11101111b
-11001111b | 10101010b = 11101111b
-11001111b | 10101011b = 11101111b
-11001111b | 10101100b = 11101111b
-11001111b | 10101101b = 11101111b
-11001111b | 10101110b = 11101111b
-11001111b | 10101111b = 11101111b
-11001111b | 10110000b = 11111111b
-11001111b | 10110001b = 11111111b
-11001111b | 10110010b = 11111111b
-11001111b | 10110011b = 11111111b
-11001111b | 10110100b = 11111111b
-11001111b | 10110101b = 11111111b
-11001111b | 10110110b = 11111111b
-11001111b | 10110111b = 11111111b
-11001111b | 10111000b = 11111111b
-11001111b | 10111001b = 11111111b
-11001111b | 10111010b = 11111111b
-11001111b | 10111011b = 11111111b
-11001111b | 10111100b = 11111111b
-11001111b | 10111101b = 11111111b
-11001111b | 10111110b = 11111111b
-11001111b | 10111111b = 11111111b
-11001111b | 11000000b = 11001111b
-11001111b | 11000001b = 11001111b
-11001111b | 11000010b = 11001111b
-11001111b | 11000011b = 11001111b
-11001111b | 11000100b = 11001111b
-11001111b | 11000101b = 11001111b
-11001111b | 11000110b = 11001111b
-11001111b | 11000111b = 11001111b
-11001111b | 11001000b = 11001111b
-11001111b | 11001001b = 11001111b
-11001111b | 11001010b = 11001111b
-11001111b | 11001011b = 11001111b
-11001111b | 11001100b = 11001111b
-11001111b | 11001101b = 11001111b
-11001111b | 11001110b = 11001111b
-11001111b | 11001111b = 11001111b
-11001111b | 11010000b = 11011111b
-11001111b | 11010001b = 11011111b
-11001111b | 11010010b = 11011111b
-11001111b | 11010011b = 11011111b
-11001111b | 11010100b = 11011111b
-11001111b | 11010101b = 11011111b
-11001111b | 11010110b = 11011111b
-11001111b | 11010111b = 11011111b
-11001111b | 11011000b = 11011111b
-11001111b | 11011001b = 11011111b
-11001111b | 11011010b = 11011111b
-11001111b | 11011011b = 11011111b
-11001111b | 11011100b = 11011111b
-11001111b | 11011101b = 11011111b
-11001111b | 11011110b = 11011111b
-11001111b | 11011111b = 11011111b
-11001111b | 11100000b = 11101111b
-11001111b | 11100001b = 11101111b
-11001111b | 11100010b = 11101111b
-11001111b | 11100011b = 11101111b
-11001111b | 11100100b = 11101111b
-11001111b | 11100101b = 11101111b
-11001111b | 11100110b = 11101111b
-11001111b | 11100111b = 11101111b
-11001111b | 11101000b = 11101111b
-11001111b | 11101001b = 11101111b
-11001111b | 11101010b = 11101111b
-11001111b | 11101011b = 11101111b
-11001111b | 11101100b = 11101111b
-11001111b | 11101101b = 11101111b
-11001111b | 11101110b = 11101111b
-11001111b | 11101111b = 11101111b
-11001111b | 11110000b = 11111111b
-11001111b | 11110001b = 11111111b
-11001111b | 11110010b = 11111111b
-11001111b | 11110011b = 11111111b
-11001111b | 11110100b = 11111111b
-11001111b | 11110101b = 11111111b
-11001111b | 11110110b = 11111111b
-11001111b | 11110111b = 11111111b
-11001111b | 11111000b = 11111111b
-11001111b | 11111001b = 11111111b
-11001111b | 11111010b = 11111111b
-11001111b | 11111011b = 11111111b
-11001111b | 11111100b = 11111111b
-11001111b | 11111101b = 11111111b
-11001111b | 11111110b = 11111111b
-11001111b | 11111111b = 11111111b
-11001111b | 00000000b = 11001111b
-11001111b | 00000001b = 11001111b
-11001111b | 00000010b = 11001111b
-11001111b | 00000011b = 11001111b
-11001111b | 00000100b = 11001111b
-11001111b | 00000101b = 11001111b
-11001111b | 00000110b = 11001111b
-11001111b | 00000111b = 11001111b
-11001111b | 00001000b = 11001111b
-11001111b | 00001001b = 11001111b
-11001111b | 00001010b = 11001111b
-11001111b | 00001011b = 11001111b
-11001111b | 00001100b = 11001111b
-11001111b | 00001101b = 11001111b
-11001111b | 00001110b = 11001111b
-11001111b | 00001111b = 11001111b
-11001111b | 00010000b = 11011111b
-11001111b | 00010001b = 11011111b
-11001111b | 00010010b = 11011111b
-11001111b | 00010011b = 11011111b
-11001111b | 00010100b = 11011111b
-11001111b | 00010101b = 11011111b
-11001111b | 00010110b = 11011111b
-11001111b | 00010111b = 11011111b
-11001111b | 00011000b = 11011111b
-11001111b | 00011001b = 11011111b
-11001111b | 00011010b = 11011111b
-11001111b | 00011011b = 11011111b
-11001111b | 00011100b = 11011111b
-11001111b | 00011101b = 11011111b
-11001111b | 00011110b = 11011111b
-11001111b | 00011111b = 11011111b
-11001111b | 00100000b = 11101111b
-11001111b | 00100001b = 11101111b
-11001111b | 00100010b = 11101111b
-11001111b | 00100011b = 11101111b
-11001111b | 00100100b = 11101111b
-11001111b | 00100101b = 11101111b
-11001111b | 00100110b = 11101111b
-11001111b | 00100111b = 11101111b
-11001111b | 00101000b = 11101111b
-11001111b | 00101001b = 11101111b
-11001111b | 00101010b = 11101111b
-11001111b | 00101011b = 11101111b
-11001111b | 00101100b = 11101111b
-11001111b | 00101101b = 11101111b
-11001111b | 00101110b = 11101111b
-11001111b | 00101111b = 11101111b
-11001111b | 00110000b = 11111111b
-11001111b | 00110001b = 11111111b
-11001111b | 00110010b = 11111111b
-11001111b | 00110011b = 11111111b
-11001111b | 00110100b = 11111111b
-11001111b | 00110101b = 11111111b
-11001111b | 00110110b = 11111111b
-11001111b | 00110111b = 11111111b
-11001111b | 00111000b = 11111111b
-11001111b | 00111001b = 11111111b
-11001111b | 00111010b = 11111111b
-11001111b | 00111011b = 11111111b
-11001111b | 00111100b = 11111111b
-11001111b | 00111101b = 11111111b
-11001111b | 00111110b = 11111111b
-11001111b | 00111111b = 11111111b
-11001111b | 01000000b = 11001111b
-11001111b | 01000001b = 11001111b
-11001111b | 01000010b = 11001111b
-11001111b | 01000011b = 11001111b
-11001111b | 01000100b = 11001111b
-11001111b | 01000101b = 11001111b
-11001111b | 01000110b = 11001111b
-11001111b | 01000111b = 11001111b
-11001111b | 01001000b = 11001111b
-11001111b | 01001001b = 11001111b
-11001111b | 01001010b = 11001111b
-11001111b | 01001011b = 11001111b
-11001111b | 01001100b = 11001111b
-11001111b | 01001101b = 11001111b
-11001111b | 01001110b = 11001111b
-11001111b | 01001111b = 11001111b
-11001111b | 01010000b = 11011111b
-11001111b | 01010001b = 11011111b
-11001111b | 01010010b = 11011111b
-11001111b | 01010011b = 11011111b
-11001111b | 01010100b = 11011111b
-11001111b | 01010101b = 11011111b
-11001111b | 01010110b = 11011111b
-11001111b | 01010111b = 11011111b
-11001111b | 01011000b = 11011111b
-11001111b | 01011001b = 11011111b
-11001111b | 01011010b = 11011111b
-11001111b | 01011011b = 11011111b
-11001111b | 01011100b = 11011111b
-11001111b | 01011101b = 11011111b
-11001111b | 01011110b = 11011111b
-11001111b | 01011111b = 11011111b
-11001111b | 01100000b = 11101111b
-11001111b | 01100001b = 11101111b
-11001111b | 01100010b = 11101111b
-11001111b | 01100011b = 11101111b
-11001111b | 01100100b = 11101111b
-11001111b | 01100101b = 11101111b
-11001111b | 01100110b = 11101111b
-11001111b | 01100111b = 11101111b
-11001111b | 01101000b = 11101111b
-11001111b | 01101001b = 11101111b
-11001111b | 01101010b = 11101111b
-11001111b | 01101011b = 11101111b
-11001111b | 01101100b = 11101111b
-11001111b | 01101101b = 11101111b
-11001111b | 01101110b = 11101111b
-11001111b | 01101111b = 11101111b
-11001111b | 01110000b = 11111111b
-11001111b | 01110001b = 11111111b
-11001111b | 01110010b = 11111111b
-11001111b | 01110011b = 11111111b
-11001111b | 01110100b = 11111111b
-11001111b | 01110101b = 11111111b
-11001111b | 01110110b = 11111111b
-11001111b | 01110111b = 11111111b
-11001111b | 01111000b = 11111111b
-11001111b | 01111001b = 11111111b
-11001111b | 01111010b = 11111111b
-11001111b | 01111011b = 11111111b
-11001111b | 01111100b = 11111111b
-11001111b | 01111101b = 11111111b
-11001111b | 01111110b = 11111111b
-11010000b | 10000000b = 11010000b
-11010000b | 10000001b = 11010001b
-11010000b | 10000010b = 11010010b
-11010000b | 10000011b = 11010011b
-11010000b | 10000100b = 11010100b
-11010000b | 10000101b = 11010101b
-11010000b | 10000110b = 11010110b
-11010000b | 10000111b = 11010111b
-11010000b | 10001000b = 11011000b
-11010000b | 10001001b = 11011001b
-11010000b | 10001010b = 11011010b
-11010000b | 10001011b = 11011011b
-11010000b | 10001100b = 11011100b
-11010000b | 10001101b = 11011101b
-11010000b | 10001110b = 11011110b
-11010000b | 10001111b = 11011111b
-11010000b | 10010000b = 11010000b
-11010000b | 10010001b = 11010001b
-11010000b | 10010010b = 11010010b
-11010000b | 10010011b = 11010011b
-11010000b | 10010100b = 11010100b
-11010000b | 10010101b = 11010101b
-11010000b | 10010110b = 11010110b
-11010000b | 10010111b = 11010111b
-11010000b | 10011000b = 11011000b
-11010000b | 10011001b = 11011001b
-11010000b | 10011010b = 11011010b
-11010000b | 10011011b = 11011011b
-11010000b | 10011100b = 11011100b
-11010000b | 10011101b = 11011101b
-11010000b | 10011110b = 11011110b
-11010000b | 10011111b = 11011111b
-11010000b | 10100000b = 11110000b
-11010000b | 10100001b = 11110001b
-11010000b | 10100010b = 11110010b
-11010000b | 10100011b = 11110011b
-11010000b | 10100100b = 11110100b
-11010000b | 10100101b = 11110101b
-11010000b | 10100110b = 11110110b
-11010000b | 10100111b = 11110111b
-11010000b | 10101000b = 11111000b
-11010000b | 10101001b = 11111001b
-11010000b | 10101010b = 11111010b
-11010000b | 10101011b = 11111011b
-11010000b | 10101100b = 11111100b
-11010000b | 10101101b = 11111101b
-11010000b | 10101110b = 11111110b
-11010000b | 10101111b = 11111111b
-11010000b | 10110000b = 11110000b
-11010000b | 10110001b = 11110001b
-11010000b | 10110010b = 11110010b
-11010000b | 10110011b = 11110011b
-11010000b | 10110100b = 11110100b
-11010000b | 10110101b = 11110101b
-11010000b | 10110110b = 11110110b
-11010000b | 10110111b = 11110111b
-11010000b | 10111000b = 11111000b
-11010000b | 10111001b = 11111001b
-11010000b | 10111010b = 11111010b
-11010000b | 10111011b = 11111011b
-11010000b | 10111100b = 11111100b
-11010000b | 10111101b = 11111101b
-11010000b | 10111110b = 11111110b
-11010000b | 10111111b = 11111111b
-11010000b | 11000000b = 11010000b
-11010000b | 11000001b = 11010001b
-11010000b | 11000010b = 11010010b
-11010000b | 11000011b = 11010011b
-11010000b | 11000100b = 11010100b
-11010000b | 11000101b = 11010101b
-11010000b | 11000110b = 11010110b
-11010000b | 11000111b = 11010111b
-11010000b | 11001000b = 11011000b
-11010000b | 11001001b = 11011001b
-11010000b | 11001010b = 11011010b
-11010000b | 11001011b = 11011011b
-11010000b | 11001100b = 11011100b
-11010000b | 11001101b = 11011101b
-11010000b | 11001110b = 11011110b
-11010000b | 11001111b = 11011111b
-11010000b | 11010000b = 11010000b
-11010000b | 11010001b = 11010001b
-11010000b | 11010010b = 11010010b
-11010000b | 11010011b = 11010011b
-11010000b | 11010100b = 11010100b
-11010000b | 11010101b = 11010101b
-11010000b | 11010110b = 11010110b
-11010000b | 11010111b = 11010111b
-11010000b | 11011000b = 11011000b
-11010000b | 11011001b = 11011001b
-11010000b | 11011010b = 11011010b
-11010000b | 11011011b = 11011011b
-11010000b | 11011100b = 11011100b
-11010000b | 11011101b = 11011101b
-11010000b | 11011110b = 11011110b
-11010000b | 11011111b = 11011111b
-11010000b | 11100000b = 11110000b
-11010000b | 11100001b = 11110001b
-11010000b | 11100010b = 11110010b
-11010000b | 11100011b = 11110011b
-11010000b | 11100100b = 11110100b
-11010000b | 11100101b = 11110101b
-11010000b | 11100110b = 11110110b
-11010000b | 11100111b = 11110111b
-11010000b | 11101000b = 11111000b
-11010000b | 11101001b = 11111001b
-11010000b | 11101010b = 11111010b
-11010000b | 11101011b = 11111011b
-11010000b | 11101100b = 11111100b
-11010000b | 11101101b = 11111101b
-11010000b | 11101110b = 11111110b
-11010000b | 11101111b = 11111111b
-11010000b | 11110000b = 11110000b
-11010000b | 11110001b = 11110001b
-11010000b | 11110010b = 11110010b
-11010000b | 11110011b = 11110011b
-11010000b | 11110100b = 11110100b
-11010000b | 11110101b = 11110101b
-11010000b | 11110110b = 11110110b
-11010000b | 11110111b = 11110111b
-11010000b | 11111000b = 11111000b
-11010000b | 11111001b = 11111001b
-11010000b | 11111010b = 11111010b
-11010000b | 11111011b = 11111011b
-11010000b | 11111100b = 11111100b
-11010000b | 11111101b = 11111101b
-11010000b | 11111110b = 11111110b
-11010000b | 11111111b = 11111111b
-11010000b | 00000000b = 11010000b
-11010000b | 00000001b = 11010001b
-11010000b | 00000010b = 11010010b
-11010000b | 00000011b = 11010011b
-11010000b | 00000100b = 11010100b
-11010000b | 00000101b = 11010101b
-11010000b | 00000110b = 11010110b
-11010000b | 00000111b = 11010111b
-11010000b | 00001000b = 11011000b
-11010000b | 00001001b = 11011001b
-11010000b | 00001010b = 11011010b
-11010000b | 00001011b = 11011011b
-11010000b | 00001100b = 11011100b
-11010000b | 00001101b = 11011101b
-11010000b | 00001110b = 11011110b
-11010000b | 00001111b = 11011111b
-11010000b | 00010000b = 11010000b
-11010000b | 00010001b = 11010001b
-11010000b | 00010010b = 11010010b
-11010000b | 00010011b = 11010011b
-11010000b | 00010100b = 11010100b
-11010000b | 00010101b = 11010101b
-11010000b | 00010110b = 11010110b
-11010000b | 00010111b = 11010111b
-11010000b | 00011000b = 11011000b
-11010000b | 00011001b = 11011001b
-11010000b | 00011010b = 11011010b
-11010000b | 00011011b = 11011011b
-11010000b | 00011100b = 11011100b
-11010000b | 00011101b = 11011101b
-11010000b | 00011110b = 11011110b
-11010000b | 00011111b = 11011111b
-11010000b | 00100000b = 11110000b
-11010000b | 00100001b = 11110001b
-11010000b | 00100010b = 11110010b
-11010000b | 00100011b = 11110011b
-11010000b | 00100100b = 11110100b
-11010000b | 00100101b = 11110101b
-11010000b | 00100110b = 11110110b
-11010000b | 00100111b = 11110111b
-11010000b | 00101000b = 11111000b
-11010000b | 00101001b = 11111001b
-11010000b | 00101010b = 11111010b
-11010000b | 00101011b = 11111011b
-11010000b | 00101100b = 11111100b
-11010000b | 00101101b = 11111101b
-11010000b | 00101110b = 11111110b
-11010000b | 00101111b = 11111111b
-11010000b | 00110000b = 11110000b
-11010000b | 00110001b = 11110001b
-11010000b | 00110010b = 11110010b
-11010000b | 00110011b = 11110011b
-11010000b | 00110100b = 11110100b
-11010000b | 00110101b = 11110101b
-11010000b | 00110110b = 11110110b
-11010000b | 00110111b = 11110111b
-11010000b | 00111000b = 11111000b
-11010000b | 00111001b = 11111001b
-11010000b | 00111010b = 11111010b
-11010000b | 00111011b = 11111011b
-11010000b | 00111100b = 11111100b
-11010000b | 00111101b = 11111101b
-11010000b | 00111110b = 11111110b
-11010000b | 00111111b = 11111111b
-11010000b | 01000000b = 11010000b
-11010000b | 01000001b = 11010001b
-11010000b | 01000010b = 11010010b
-11010000b | 01000011b = 11010011b
-11010000b | 01000100b = 11010100b
-11010000b | 01000101b = 11010101b
-11010000b | 01000110b = 11010110b
-11010000b | 01000111b = 11010111b
-11010000b | 01001000b = 11011000b
-11010000b | 01001001b = 11011001b
-11010000b | 01001010b = 11011010b
-11010000b | 01001011b = 11011011b
-11010000b | 01001100b = 11011100b
-11010000b | 01001101b = 11011101b
-11010000b | 01001110b = 11011110b
-11010000b | 01001111b = 11011111b
-11010000b | 01010000b = 11010000b
-11010000b | 01010001b = 11010001b
-11010000b | 01010010b = 11010010b
-11010000b | 01010011b = 11010011b
-11010000b | 01010100b = 11010100b
-11010000b | 01010101b = 11010101b
-11010000b | 01010110b = 11010110b
-11010000b | 01010111b = 11010111b
-11010000b | 01011000b = 11011000b
-11010000b | 01011001b = 11011001b
-11010000b | 01011010b = 11011010b
-11010000b | 01011011b = 11011011b
-11010000b | 01011100b = 11011100b
-11010000b | 01011101b = 11011101b
-11010000b | 01011110b = 11011110b
-11010000b | 01011111b = 11011111b
-11010000b | 01100000b = 11110000b
-11010000b | 01100001b = 11110001b
-11010000b | 01100010b = 11110010b
-11010000b | 01100011b = 11110011b
-11010000b | 01100100b = 11110100b
-11010000b | 01100101b = 11110101b
-11010000b | 01100110b = 11110110b
-11010000b | 01100111b = 11110111b
-11010000b | 01101000b = 11111000b
-11010000b | 01101001b = 11111001b
-11010000b | 01101010b = 11111010b
-11010000b | 01101011b = 11111011b
-11010000b | 01101100b = 11111100b
-11010000b | 01101101b = 11111101b
-11010000b | 01101110b = 11111110b
-11010000b | 01101111b = 11111111b
-11010000b | 01110000b = 11110000b
-11010000b | 01110001b = 11110001b
-11010000b | 01110010b = 11110010b
-11010000b | 01110011b = 11110011b
-11010000b | 01110100b = 11110100b
-11010000b | 01110101b = 11110101b
-11010000b | 01110110b = 11110110b
-11010000b | 01110111b = 11110111b
-11010000b | 01111000b = 11111000b
-11010000b | 01111001b = 11111001b
-11010000b | 01111010b = 11111010b
-11010000b | 01111011b = 11111011b
-11010000b | 01111100b = 11111100b
-11010000b | 01111101b = 11111101b
-11010000b | 01111110b = 11111110b
-11010001b | 10000000b = 11010001b
-11010001b | 10000001b = 11010001b
-11010001b | 10000010b = 11010011b
-11010001b | 10000011b = 11010011b
-11010001b | 10000100b = 11010101b
-11010001b | 10000101b = 11010101b
-11010001b | 10000110b = 11010111b
-11010001b | 10000111b = 11010111b
-11010001b | 10001000b = 11011001b
-11010001b | 10001001b = 11011001b
-11010001b | 10001010b = 11011011b
-11010001b | 10001011b = 11011011b
-11010001b | 10001100b = 11011101b
-11010001b | 10001101b = 11011101b
-11010001b | 10001110b = 11011111b
-11010001b | 10001111b = 11011111b
-11010001b | 10010000b = 11010001b
-11010001b | 10010001b = 11010001b
-11010001b | 10010010b = 11010011b
-11010001b | 10010011b = 11010011b
-11010001b | 10010100b = 11010101b
-11010001b | 10010101b = 11010101b
-11010001b | 10010110b = 11010111b
-11010001b | 10010111b = 11010111b
-11010001b | 10011000b = 11011001b
-11010001b | 10011001b = 11011001b
-11010001b | 10011010b = 11011011b
-11010001b | 10011011b = 11011011b
-11010001b | 10011100b = 11011101b
-11010001b | 10011101b = 11011101b
-11010001b | 10011110b = 11011111b
-11010001b | 10011111b = 11011111b
-11010001b | 10100000b = 11110001b
-11010001b | 10100001b = 11110001b
-11010001b | 10100010b = 11110011b
-11010001b | 10100011b = 11110011b
-11010001b | 10100100b = 11110101b
-11010001b | 10100101b = 11110101b
-11010001b | 10100110b = 11110111b
-11010001b | 10100111b = 11110111b
-11010001b | 10101000b = 11111001b
-11010001b | 10101001b = 11111001b
-11010001b | 10101010b = 11111011b
-11010001b | 10101011b = 11111011b
-11010001b | 10101100b = 11111101b
-11010001b | 10101101b = 11111101b
-11010001b | 10101110b = 11111111b
-11010001b | 10101111b = 11111111b
-11010001b | 10110000b = 11110001b
-11010001b | 10110001b = 11110001b
-11010001b | 10110010b = 11110011b
-11010001b | 10110011b = 11110011b
-11010001b | 10110100b = 11110101b
-11010001b | 10110101b = 11110101b
-11010001b | 10110110b = 11110111b
-11010001b | 10110111b = 11110111b
-11010001b | 10111000b = 11111001b
-11010001b | 10111001b = 11111001b
-11010001b | 10111010b = 11111011b
-11010001b | 10111011b = 11111011b
-11010001b | 10111100b = 11111101b
-11010001b | 10111101b = 11111101b
-11010001b | 10111110b = 11111111b
-11010001b | 10111111b = 11111111b
-11010001b | 11000000b = 11010001b
-11010001b | 11000001b = 11010001b
-11010001b | 11000010b = 11010011b
-11010001b | 11000011b = 11010011b
-11010001b | 11000100b = 11010101b
-11010001b | 11000101b = 11010101b
-11010001b | 11000110b = 11010111b
-11010001b | 11000111b = 11010111b
-11010001b | 11001000b = 11011001b
-11010001b | 11001001b = 11011001b
-11010001b | 11001010b = 11011011b
-11010001b | 11001011b = 11011011b
-11010001b | 11001100b = 11011101b
-11010001b | 11001101b = 11011101b
-11010001b | 11001110b = 11011111b
-11010001b | 11001111b = 11011111b
-11010001b | 11010000b = 11010001b
-11010001b | 11010001b = 11010001b
-11010001b | 11010010b = 11010011b
-11010001b | 11010011b = 11010011b
-11010001b | 11010100b = 11010101b
-11010001b | 11010101b = 11010101b
-11010001b | 11010110b = 11010111b
-11010001b | 11010111b = 11010111b
-11010001b | 11011000b = 11011001b
-11010001b | 11011001b = 11011001b
-11010001b | 11011010b = 11011011b
-11010001b | 11011011b = 11011011b
-11010001b | 11011100b = 11011101b
-11010001b | 11011101b = 11011101b
-11010001b | 11011110b = 11011111b
-11010001b | 11011111b = 11011111b
-11010001b | 11100000b = 11110001b
-11010001b | 11100001b = 11110001b
-11010001b | 11100010b = 11110011b
-11010001b | 11100011b = 11110011b
-11010001b | 11100100b = 11110101b
-11010001b | 11100101b = 11110101b
-11010001b | 11100110b = 11110111b
-11010001b | 11100111b = 11110111b
-11010001b | 11101000b = 11111001b
-11010001b | 11101001b = 11111001b
-11010001b | 11101010b = 11111011b
-11010001b | 11101011b = 11111011b
-11010001b | 11101100b = 11111101b
-11010001b | 11101101b = 11111101b
-11010001b | 11101110b = 11111111b
-11010001b | 11101111b = 11111111b
-11010001b | 11110000b = 11110001b
-11010001b | 11110001b = 11110001b
-11010001b | 11110010b = 11110011b
-11010001b | 11110011b = 11110011b
-11010001b | 11110100b = 11110101b
-11010001b | 11110101b = 11110101b
-11010001b | 11110110b = 11110111b
-11010001b | 11110111b = 11110111b
-11010001b | 11111000b = 11111001b
-11010001b | 11111001b = 11111001b
-11010001b | 11111010b = 11111011b
-11010001b | 11111011b = 11111011b
-11010001b | 11111100b = 11111101b
-11010001b | 11111101b = 11111101b
-11010001b | 11111110b = 11111111b
-11010001b | 11111111b = 11111111b
-11010001b | 00000000b = 11010001b
-11010001b | 00000001b = 11010001b
-11010001b | 00000010b = 11010011b
-11010001b | 00000011b = 11010011b
-11010001b | 00000100b = 11010101b
-11010001b | 00000101b = 11010101b
-11010001b | 00000110b = 11010111b
-11010001b | 00000111b = 11010111b
-11010001b | 00001000b = 11011001b
-11010001b | 00001001b = 11011001b
-11010001b | 00001010b = 11011011b
-11010001b | 00001011b = 11011011b
-11010001b | 00001100b = 11011101b
-11010001b | 00001101b = 11011101b
-11010001b | 00001110b = 11011111b
-11010001b | 00001111b = 11011111b
-11010001b | 00010000b = 11010001b
-11010001b | 00010001b = 11010001b
-11010001b | 00010010b = 11010011b
-11010001b | 00010011b = 11010011b
-11010001b | 00010100b = 11010101b
-11010001b | 00010101b = 11010101b
-11010001b | 00010110b = 11010111b
-11010001b | 00010111b = 11010111b
-11010001b | 00011000b = 11011001b
-11010001b | 00011001b = 11011001b
-11010001b | 00011010b = 11011011b
-11010001b | 00011011b = 11011011b
-11010001b | 00011100b = 11011101b
-11010001b | 00011101b = 11011101b
-11010001b | 00011110b = 11011111b
-11010001b | 00011111b = 11011111b
-11010001b | 00100000b = 11110001b
-11010001b | 00100001b = 11110001b
-11010001b | 00100010b = 11110011b
-11010001b | 00100011b = 11110011b
-11010001b | 00100100b = 11110101b
-11010001b | 00100101b = 11110101b
-11010001b | 00100110b = 11110111b
-11010001b | 00100111b = 11110111b
-11010001b | 00101000b = 11111001b
-11010001b | 00101001b = 11111001b
-11010001b | 00101010b = 11111011b
-11010001b | 00101011b = 11111011b
-11010001b | 00101100b = 11111101b
-11010001b | 00101101b = 11111101b
-11010001b | 00101110b = 11111111b
-11010001b | 00101111b = 11111111b
-11010001b | 00110000b = 11110001b
-11010001b | 00110001b = 11110001b
-11010001b | 00110010b = 11110011b
-11010001b | 00110011b = 11110011b
-11010001b | 00110100b = 11110101b
-11010001b | 00110101b = 11110101b
-11010001b | 00110110b = 11110111b
-11010001b | 00110111b = 11110111b
-11010001b | 00111000b = 11111001b
-11010001b | 00111001b = 11111001b
-11010001b | 00111010b = 11111011b
-11010001b | 00111011b = 11111011b
-11010001b | 00111100b = 11111101b
-11010001b | 00111101b = 11111101b
-11010001b | 00111110b = 11111111b
-11010001b | 00111111b = 11111111b
-11010001b | 01000000b = 11010001b
-11010001b | 01000001b = 11010001b
-11010001b | 01000010b = 11010011b
-11010001b | 01000011b = 11010011b
-11010001b | 01000100b = 11010101b
-11010001b | 01000101b = 11010101b
-11010001b | 01000110b = 11010111b
-11010001b | 01000111b = 11010111b
-11010001b | 01001000b = 11011001b
-11010001b | 01001001b = 11011001b
-11010001b | 01001010b = 11011011b
-11010001b | 01001011b = 11011011b
-11010001b | 01001100b = 11011101b
-11010001b | 01001101b = 11011101b
-11010001b | 01001110b = 11011111b
-11010001b | 01001111b = 11011111b
-11010001b | 01010000b = 11010001b
-11010001b | 01010001b = 11010001b
-11010001b | 01010010b = 11010011b
-11010001b | 01010011b = 11010011b
-11010001b | 01010100b = 11010101b
-11010001b | 01010101b = 11010101b
-11010001b | 01010110b = 11010111b
-11010001b | 01010111b = 11010111b
-11010001b | 01011000b = 11011001b
-11010001b | 01011001b = 11011001b
-11010001b | 01011010b = 11011011b
-11010001b | 01011011b = 11011011b
-11010001b | 01011100b = 11011101b
-11010001b | 01011101b = 11011101b
-11010001b | 01011110b = 11011111b
-11010001b | 01011111b = 11011111b
-11010001b | 01100000b = 11110001b
-11010001b | 01100001b = 11110001b
-11010001b | 01100010b = 11110011b
-11010001b | 01100011b = 11110011b
-11010001b | 01100100b = 11110101b
-11010001b | 01100101b = 11110101b
-11010001b | 01100110b = 11110111b
-11010001b | 01100111b = 11110111b
-11010001b | 01101000b = 11111001b
-11010001b | 01101001b = 11111001b
-11010001b | 01101010b = 11111011b
-11010001b | 01101011b = 11111011b
-11010001b | 01101100b = 11111101b
-11010001b | 01101101b = 11111101b
-11010001b | 01101110b = 11111111b
-11010001b | 01101111b = 11111111b
-11010001b | 01110000b = 11110001b
-11010001b | 01110001b = 11110001b
-11010001b | 01110010b = 11110011b
-11010001b | 01110011b = 11110011b
-11010001b | 01110100b = 11110101b
-11010001b | 01110101b = 11110101b
-11010001b | 01110110b = 11110111b
-11010001b | 01110111b = 11110111b
-11010001b | 01111000b = 11111001b
-11010001b | 01111001b = 11111001b
-11010001b | 01111010b = 11111011b
-11010001b | 01111011b = 11111011b
-11010001b | 01111100b = 11111101b
-11010001b | 01111101b = 11111101b
-11010001b | 01111110b = 11111111b
-11010010b | 10000000b = 11010010b
-11010010b | 10000001b = 11010011b
-11010010b | 10000010b = 11010010b
-11010010b | 10000011b = 11010011b
-11010010b | 10000100b = 11010110b
-11010010b | 10000101b = 11010111b
-11010010b | 10000110b = 11010110b
-11010010b | 10000111b = 11010111b
-11010010b | 10001000b = 11011010b
-11010010b | 10001001b = 11011011b
-11010010b | 10001010b = 11011010b
-11010010b | 10001011b = 11011011b
-11010010b | 10001100b = 11011110b
-11010010b | 10001101b = 11011111b
-11010010b | 10001110b = 11011110b
-11010010b | 10001111b = 11011111b
-11010010b | 10010000b = 11010010b
-11010010b | 10010001b = 11010011b
-11010010b | 10010010b = 11010010b
-11010010b | 10010011b = 11010011b
-11010010b | 10010100b = 11010110b
-11010010b | 10010101b = 11010111b
-11010010b | 10010110b = 11010110b
-11010010b | 10010111b = 11010111b
-11010010b | 10011000b = 11011010b
-11010010b | 10011001b = 11011011b
-11010010b | 10011010b = 11011010b
-11010010b | 10011011b = 11011011b
-11010010b | 10011100b = 11011110b
-11010010b | 10011101b = 11011111b
-11010010b | 10011110b = 11011110b
-11010010b | 10011111b = 11011111b
-11010010b | 10100000b = 11110010b
-11010010b | 10100001b = 11110011b
-11010010b | 10100010b = 11110010b
-11010010b | 10100011b = 11110011b
-11010010b | 10100100b = 11110110b
-11010010b | 10100101b = 11110111b
-11010010b | 10100110b = 11110110b
-11010010b | 10100111b = 11110111b
-11010010b | 10101000b = 11111010b
-11010010b | 10101001b = 11111011b
-11010010b | 10101010b = 11111010b
-11010010b | 10101011b = 11111011b
-11010010b | 10101100b = 11111110b
-11010010b | 10101101b = 11111111b
-11010010b | 10101110b = 11111110b
-11010010b | 10101111b = 11111111b
-11010010b | 10110000b = 11110010b
-11010010b | 10110001b = 11110011b
-11010010b | 10110010b = 11110010b
-11010010b | 10110011b = 11110011b
-11010010b | 10110100b = 11110110b
-11010010b | 10110101b = 11110111b
-11010010b | 10110110b = 11110110b
-11010010b | 10110111b = 11110111b
-11010010b | 10111000b = 11111010b
-11010010b | 10111001b = 11111011b
-11010010b | 10111010b = 11111010b
-11010010b | 10111011b = 11111011b
-11010010b | 10111100b = 11111110b
-11010010b | 10111101b = 11111111b
-11010010b | 10111110b = 11111110b
-11010010b | 10111111b = 11111111b
-11010010b | 11000000b = 11010010b
-11010010b | 11000001b = 11010011b
-11010010b | 11000010b = 11010010b
-11010010b | 11000011b = 11010011b
-11010010b | 11000100b = 11010110b
-11010010b | 11000101b = 11010111b
-11010010b | 11000110b = 11010110b
-11010010b | 11000111b = 11010111b
-11010010b | 11001000b = 11011010b
-11010010b | 11001001b = 11011011b
-11010010b | 11001010b = 11011010b
-11010010b | 11001011b = 11011011b
-11010010b | 11001100b = 11011110b
-11010010b | 11001101b = 11011111b
-11010010b | 11001110b = 11011110b
-11010010b | 11001111b = 11011111b
-11010010b | 11010000b = 11010010b
-11010010b | 11010001b = 11010011b
-11010010b | 11010010b = 11010010b
-11010010b | 11010011b = 11010011b
-11010010b | 11010100b = 11010110b
-11010010b | 11010101b = 11010111b
-11010010b | 11010110b = 11010110b
-11010010b | 11010111b = 11010111b
-11010010b | 11011000b = 11011010b
-11010010b | 11011001b = 11011011b
-11010010b | 11011010b = 11011010b
-11010010b | 11011011b = 11011011b
-11010010b | 11011100b = 11011110b
-11010010b | 11011101b = 11011111b
-11010010b | 11011110b = 11011110b
-11010010b | 11011111b = 11011111b
-11010010b | 11100000b = 11110010b
-11010010b | 11100001b = 11110011b
-11010010b | 11100010b = 11110010b
-11010010b | 11100011b = 11110011b
-11010010b | 11100100b = 11110110b
-11010010b | 11100101b = 11110111b
-11010010b | 11100110b = 11110110b
-11010010b | 11100111b = 11110111b
-11010010b | 11101000b = 11111010b
-11010010b | 11101001b = 11111011b
-11010010b | 11101010b = 11111010b
-11010010b | 11101011b = 11111011b
-11010010b | 11101100b = 11111110b
-11010010b | 11101101b = 11111111b
-11010010b | 11101110b = 11111110b
-11010010b | 11101111b = 11111111b
-11010010b | 11110000b = 11110010b
-11010010b | 11110001b = 11110011b
-11010010b | 11110010b = 11110010b
-11010010b | 11110011b = 11110011b
-11010010b | 11110100b = 11110110b
-11010010b | 11110101b = 11110111b
-11010010b | 11110110b = 11110110b
-11010010b | 11110111b = 11110111b
-11010010b | 11111000b = 11111010b
-11010010b | 11111001b = 11111011b
-11010010b | 11111010b = 11111010b
-11010010b | 11111011b = 11111011b
-11010010b | 11111100b = 11111110b
-11010010b | 11111101b = 11111111b
-11010010b | 11111110b = 11111110b
-11010010b | 11111111b = 11111111b
-11010010b | 00000000b = 11010010b
-11010010b | 00000001b = 11010011b
-11010010b | 00000010b = 11010010b
-11010010b | 00000011b = 11010011b
-11010010b | 00000100b = 11010110b
-11010010b | 00000101b = 11010111b
-11010010b | 00000110b = 11010110b
-11010010b | 00000111b = 11010111b
-11010010b | 00001000b = 11011010b
-11010010b | 00001001b = 11011011b
-11010010b | 00001010b = 11011010b
-11010010b | 00001011b = 11011011b
-11010010b | 00001100b = 11011110b
-11010010b | 00001101b = 11011111b
-11010010b | 00001110b = 11011110b
-11010010b | 00001111b = 11011111b
-11010010b | 00010000b = 11010010b
-11010010b | 00010001b = 11010011b
-11010010b | 00010010b = 11010010b
-11010010b | 00010011b = 11010011b
-11010010b | 00010100b = 11010110b
-11010010b | 00010101b = 11010111b
-11010010b | 00010110b = 11010110b
-11010010b | 00010111b = 11010111b
-11010010b | 00011000b = 11011010b
-11010010b | 00011001b = 11011011b
-11010010b | 00011010b = 11011010b
-11010010b | 00011011b = 11011011b
-11010010b | 00011100b = 11011110b
-11010010b | 00011101b = 11011111b
-11010010b | 00011110b = 11011110b
-11010010b | 00011111b = 11011111b
-11010010b | 00100000b = 11110010b
-11010010b | 00100001b = 11110011b
-11010010b | 00100010b = 11110010b
-11010010b | 00100011b = 11110011b
-11010010b | 00100100b = 11110110b
-11010010b | 00100101b = 11110111b
-11010010b | 00100110b = 11110110b
-11010010b | 00100111b = 11110111b
-11010010b | 00101000b = 11111010b
-11010010b | 00101001b = 11111011b
-11010010b | 00101010b = 11111010b
-11010010b | 00101011b = 11111011b
-11010010b | 00101100b = 11111110b
-11010010b | 00101101b = 11111111b
-11010010b | 00101110b = 11111110b
-11010010b | 00101111b = 11111111b
-11010010b | 00110000b = 11110010b
-11010010b | 00110001b = 11110011b
-11010010b | 00110010b = 11110010b
-11010010b | 00110011b = 11110011b
-11010010b | 00110100b = 11110110b
-11010010b | 00110101b = 11110111b
-11010010b | 00110110b = 11110110b
-11010010b | 00110111b = 11110111b
-11010010b | 00111000b = 11111010b
-11010010b | 00111001b = 11111011b
-11010010b | 00111010b = 11111010b
-11010010b | 00111011b = 11111011b
-11010010b | 00111100b = 11111110b
-11010010b | 00111101b = 11111111b
-11010010b | 00111110b = 11111110b
-11010010b | 00111111b = 11111111b
-11010010b | 01000000b = 11010010b
-11010010b | 01000001b = 11010011b
-11010010b | 01000010b = 11010010b
-11010010b | 01000011b = 11010011b
-11010010b | 01000100b = 11010110b
-11010010b | 01000101b = 11010111b
-11010010b | 01000110b = 11010110b
-11010010b | 01000111b = 11010111b
-11010010b | 01001000b = 11011010b
-11010010b | 01001001b = 11011011b
-11010010b | 01001010b = 11011010b
-11010010b | 01001011b = 11011011b
-11010010b | 01001100b = 11011110b
-11010010b | 01001101b = 11011111b
-11010010b | 01001110b = 11011110b
-11010010b | 01001111b = 11011111b
-11010010b | 01010000b = 11010010b
-11010010b | 01010001b = 11010011b
-11010010b | 01010010b = 11010010b
-11010010b | 01010011b = 11010011b
-11010010b | 01010100b = 11010110b
-11010010b | 01010101b = 11010111b
-11010010b | 01010110b = 11010110b
-11010010b | 01010111b = 11010111b
-11010010b | 01011000b = 11011010b
-11010010b | 01011001b = 11011011b
-11010010b | 01011010b = 11011010b
-11010010b | 01011011b = 11011011b
-11010010b | 01011100b = 11011110b
-11010010b | 01011101b = 11011111b
-11010010b | 01011110b = 11011110b
-11010010b | 01011111b = 11011111b
-11010010b | 01100000b = 11110010b
-11010010b | 01100001b = 11110011b
-11010010b | 01100010b = 11110010b
-11010010b | 01100011b = 11110011b
-11010010b | 01100100b = 11110110b
-11010010b | 01100101b = 11110111b
-11010010b | 01100110b = 11110110b
-11010010b | 01100111b = 11110111b
-11010010b | 01101000b = 11111010b
-11010010b | 01101001b = 11111011b
-11010010b | 01101010b = 11111010b
-11010010b | 01101011b = 11111011b
-11010010b | 01101100b = 11111110b
-11010010b | 01101101b = 11111111b
-11010010b | 01101110b = 11111110b
-11010010b | 01101111b = 11111111b
-11010010b | 01110000b = 11110010b
-11010010b | 01110001b = 11110011b
-11010010b | 01110010b = 11110010b
-11010010b | 01110011b = 11110011b
-11010010b | 01110100b = 11110110b
-11010010b | 01110101b = 11110111b
-11010010b | 01110110b = 11110110b
-11010010b | 01110111b = 11110111b
-11010010b | 01111000b = 11111010b
-11010010b | 01111001b = 11111011b
-11010010b | 01111010b = 11111010b
-11010010b | 01111011b = 11111011b
-11010010b | 01111100b = 11111110b
-11010010b | 01111101b = 11111111b
-11010010b | 01111110b = 11111110b
-11010011b | 10000000b = 11010011b
-11010011b | 10000001b = 11010011b
-11010011b | 10000010b = 11010011b
-11010011b | 10000011b = 11010011b
-11010011b | 10000100b = 11010111b
-11010011b | 10000101b = 11010111b
-11010011b | 10000110b = 11010111b
-11010011b | 10000111b = 11010111b
-11010011b | 10001000b = 11011011b
-11010011b | 10001001b = 11011011b
-11010011b | 10001010b = 11011011b
-11010011b | 10001011b = 11011011b
-11010011b | 10001100b = 11011111b
-11010011b | 10001101b = 11011111b
-11010011b | 10001110b = 11011111b
-11010011b | 10001111b = 11011111b
-11010011b | 10010000b = 11010011b
-11010011b | 10010001b = 11010011b
-11010011b | 10010010b = 11010011b
-11010011b | 10010011b = 11010011b
-11010011b | 10010100b = 11010111b
-11010011b | 10010101b = 11010111b
-11010011b | 10010110b = 11010111b
-11010011b | 10010111b = 11010111b
-11010011b | 10011000b = 11011011b
-11010011b | 10011001b = 11011011b
-11010011b | 10011010b = 11011011b
-11010011b | 10011011b = 11011011b
-11010011b | 10011100b = 11011111b
-11010011b | 10011101b = 11011111b
-11010011b | 10011110b = 11011111b
-11010011b | 10011111b = 11011111b
-11010011b | 10100000b = 11110011b
-11010011b | 10100001b = 11110011b
-11010011b | 10100010b = 11110011b
-11010011b | 10100011b = 11110011b
-11010011b | 10100100b = 11110111b
-11010011b | 10100101b = 11110111b
-11010011b | 10100110b = 11110111b
-11010011b | 10100111b = 11110111b
-11010011b | 10101000b = 11111011b
-11010011b | 10101001b = 11111011b
-11010011b | 10101010b = 11111011b
-11010011b | 10101011b = 11111011b
-11010011b | 10101100b = 11111111b
-11010011b | 10101101b = 11111111b
-11010011b | 10101110b = 11111111b
-11010011b | 10101111b = 11111111b
-11010011b | 10110000b = 11110011b
-11010011b | 10110001b = 11110011b
-11010011b | 10110010b = 11110011b
-11010011b | 10110011b = 11110011b
-11010011b | 10110100b = 11110111b
-11010011b | 10110101b = 11110111b
-11010011b | 10110110b = 11110111b
-11010011b | 10110111b = 11110111b
-11010011b | 10111000b = 11111011b
-11010011b | 10111001b = 11111011b
-11010011b | 10111010b = 11111011b
-11010011b | 10111011b = 11111011b
-11010011b | 10111100b = 11111111b
-11010011b | 10111101b = 11111111b
-11010011b | 10111110b = 11111111b
-11010011b | 10111111b = 11111111b
-11010011b | 11000000b = 11010011b
-11010011b | 11000001b = 11010011b
-11010011b | 11000010b = 11010011b
-11010011b | 11000011b = 11010011b
-11010011b | 11000100b = 11010111b
-11010011b | 11000101b = 11010111b
-11010011b | 11000110b = 11010111b
-11010011b | 11000111b = 11010111b
-11010011b | 11001000b = 11011011b
-11010011b | 11001001b = 11011011b
-11010011b | 11001010b = 11011011b
-11010011b | 11001011b = 11011011b
-11010011b | 11001100b = 11011111b
-11010011b | 11001101b = 11011111b
-11010011b | 11001110b = 11011111b
-11010011b | 11001111b = 11011111b
-11010011b | 11010000b = 11010011b
-11010011b | 11010001b = 11010011b
-11010011b | 11010010b = 11010011b
-11010011b | 11010011b = 11010011b
-11010011b | 11010100b = 11010111b
-11010011b | 11010101b = 11010111b
-11010011b | 11010110b = 11010111b
-11010011b | 11010111b = 11010111b
-11010011b | 11011000b = 11011011b
-11010011b | 11011001b = 11011011b
-11010011b | 11011010b = 11011011b
-11010011b | 11011011b = 11011011b
-11010011b | 11011100b = 11011111b
-11010011b | 11011101b = 11011111b
-11010011b | 11011110b = 11011111b
-11010011b | 11011111b = 11011111b
-11010011b | 11100000b = 11110011b
-11010011b | 11100001b = 11110011b
-11010011b | 11100010b = 11110011b
-11010011b | 11100011b = 11110011b
-11010011b | 11100100b = 11110111b
-11010011b | 11100101b = 11110111b
-11010011b | 11100110b = 11110111b
-11010011b | 11100111b = 11110111b
-11010011b | 11101000b = 11111011b
-11010011b | 11101001b = 11111011b
-11010011b | 11101010b = 11111011b
-11010011b | 11101011b = 11111011b
-11010011b | 11101100b = 11111111b
-11010011b | 11101101b = 11111111b
-11010011b | 11101110b = 11111111b
-11010011b | 11101111b = 11111111b
-11010011b | 11110000b = 11110011b
-11010011b | 11110001b = 11110011b
-11010011b | 11110010b = 11110011b
-11010011b | 11110011b = 11110011b
-11010011b | 11110100b = 11110111b
-11010011b | 11110101b = 11110111b
-11010011b | 11110110b = 11110111b
-11010011b | 11110111b = 11110111b
-11010011b | 11111000b = 11111011b
-11010011b | 11111001b = 11111011b
-11010011b | 11111010b = 11111011b
-11010011b | 11111011b = 11111011b
-11010011b | 11111100b = 11111111b
-11010011b | 11111101b = 11111111b
-11010011b | 11111110b = 11111111b
-11010011b | 11111111b = 11111111b
-11010011b | 00000000b = 11010011b
-11010011b | 00000001b = 11010011b
-11010011b | 00000010b = 11010011b
-11010011b | 00000011b = 11010011b
-11010011b | 00000100b = 11010111b
-11010011b | 00000101b = 11010111b
-11010011b | 00000110b = 11010111b
-11010011b | 00000111b = 11010111b
-11010011b | 00001000b = 11011011b
-11010011b | 00001001b = 11011011b
-11010011b | 00001010b = 11011011b
-11010011b | 00001011b = 11011011b
-11010011b | 00001100b = 11011111b
-11010011b | 00001101b = 11011111b
-11010011b | 00001110b = 11011111b
-11010011b | 00001111b = 11011111b
-11010011b | 00010000b = 11010011b
-11010011b | 00010001b = 11010011b
-11010011b | 00010010b = 11010011b
-11010011b | 00010011b = 11010011b
-11010011b | 00010100b = 11010111b
-11010011b | 00010101b = 11010111b
-11010011b | 00010110b = 11010111b
-11010011b | 00010111b = 11010111b
-11010011b | 00011000b = 11011011b
-11010011b | 00011001b = 11011011b
-11010011b | 00011010b = 11011011b
-11010011b | 00011011b = 11011011b
-11010011b | 00011100b = 11011111b
-11010011b | 00011101b = 11011111b
-11010011b | 00011110b = 11011111b
-11010011b | 00011111b = 11011111b
-11010011b | 00100000b = 11110011b
-11010011b | 00100001b = 11110011b
-11010011b | 00100010b = 11110011b
-11010011b | 00100011b = 11110011b
-11010011b | 00100100b = 11110111b
-11010011b | 00100101b = 11110111b
-11010011b | 00100110b = 11110111b
-11010011b | 00100111b = 11110111b
-11010011b | 00101000b = 11111011b
-11010011b | 00101001b = 11111011b
-11010011b | 00101010b = 11111011b
-11010011b | 00101011b = 11111011b
-11010011b | 00101100b = 11111111b
-11010011b | 00101101b = 11111111b
-11010011b | 00101110b = 11111111b
-11010011b | 00101111b = 11111111b
-11010011b | 00110000b = 11110011b
-11010011b | 00110001b = 11110011b
-11010011b | 00110010b = 11110011b
-11010011b | 00110011b = 11110011b
-11010011b | 00110100b = 11110111b
-11010011b | 00110101b = 11110111b
-11010011b | 00110110b = 11110111b
-11010011b | 00110111b = 11110111b
-11010011b | 00111000b = 11111011b
-11010011b | 00111001b = 11111011b
-11010011b | 00111010b = 11111011b
-11010011b | 00111011b = 11111011b
-11010011b | 00111100b = 11111111b
-11010011b | 00111101b = 11111111b
-11010011b | 00111110b = 11111111b
-11010011b | 00111111b = 11111111b
-11010011b | 01000000b = 11010011b
-11010011b | 01000001b = 11010011b
-11010011b | 01000010b = 11010011b
-11010011b | 01000011b = 11010011b
-11010011b | 01000100b = 11010111b
-11010011b | 01000101b = 11010111b
-11010011b | 01000110b = 11010111b
-11010011b | 01000111b = 11010111b
-11010011b | 01001000b = 11011011b
-11010011b | 01001001b = 11011011b
-11010011b | 01001010b = 11011011b
-11010011b | 01001011b = 11011011b
-11010011b | 01001100b = 11011111b
-11010011b | 01001101b = 11011111b
-11010011b | 01001110b = 11011111b
-11010011b | 01001111b = 11011111b
-11010011b | 01010000b = 11010011b
-11010011b | 01010001b = 11010011b
-11010011b | 01010010b = 11010011b
-11010011b | 01010011b = 11010011b
-11010011b | 01010100b = 11010111b
-11010011b | 01010101b = 11010111b
-11010011b | 01010110b = 11010111b
-11010011b | 01010111b = 11010111b
-11010011b | 01011000b = 11011011b
-11010011b | 01011001b = 11011011b
-11010011b | 01011010b = 11011011b
-11010011b | 01011011b = 11011011b
-11010011b | 01011100b = 11011111b
-11010011b | 01011101b = 11011111b
-11010011b | 01011110b = 11011111b
-11010011b | 01011111b = 11011111b
-11010011b | 01100000b = 11110011b
-11010011b | 01100001b = 11110011b
-11010011b | 01100010b = 11110011b
-11010011b | 01100011b = 11110011b
-11010011b | 01100100b = 11110111b
-11010011b | 01100101b = 11110111b
-11010011b | 01100110b = 11110111b
-11010011b | 01100111b = 11110111b
-11010011b | 01101000b = 11111011b
-11010011b | 01101001b = 11111011b
-11010011b | 01101010b = 11111011b
-11010011b | 01101011b = 11111011b
-11010011b | 01101100b = 11111111b
-11010011b | 01101101b = 11111111b
-11010011b | 01101110b = 11111111b
-11010011b | 01101111b = 11111111b
-11010011b | 01110000b = 11110011b
-11010011b | 01110001b = 11110011b
-11010011b | 01110010b = 11110011b
-11010011b | 01110011b = 11110011b
-11010011b | 01110100b = 11110111b
-11010011b | 01110101b = 11110111b
-11010011b | 01110110b = 11110111b
-11010011b | 01110111b = 11110111b
-11010011b | 01111000b = 11111011b
-11010011b | 01111001b = 11111011b
-11010011b | 01111010b = 11111011b
-11010011b | 01111011b = 11111011b
-11010011b | 01111100b = 11111111b
-11010011b | 01111101b = 11111111b
-11010011b | 01111110b = 11111111b
-11010100b | 10000000b = 11010100b
-11010100b | 10000001b = 11010101b
-11010100b | 10000010b = 11010110b
-11010100b | 10000011b = 11010111b
-11010100b | 10000100b = 11010100b
-11010100b | 10000101b = 11010101b
-11010100b | 10000110b = 11010110b
-11010100b | 10000111b = 11010111b
-11010100b | 10001000b = 11011100b
-11010100b | 10001001b = 11011101b
-11010100b | 10001010b = 11011110b
-11010100b | 10001011b = 11011111b
-11010100b | 10001100b = 11011100b
-11010100b | 10001101b = 11011101b
-11010100b | 10001110b = 11011110b
-11010100b | 10001111b = 11011111b
-11010100b | 10010000b = 11010100b
-11010100b | 10010001b = 11010101b
-11010100b | 10010010b = 11010110b
-11010100b | 10010011b = 11010111b
-11010100b | 10010100b = 11010100b
-11010100b | 10010101b = 11010101b
-11010100b | 10010110b = 11010110b
-11010100b | 10010111b = 11010111b
-11010100b | 10011000b = 11011100b
-11010100b | 10011001b = 11011101b
-11010100b | 10011010b = 11011110b
-11010100b | 10011011b = 11011111b
-11010100b | 10011100b = 11011100b
-11010100b | 10011101b = 11011101b
-11010100b | 10011110b = 11011110b
-11010100b | 10011111b = 11011111b
-11010100b | 10100000b = 11110100b
-11010100b | 10100001b = 11110101b
-11010100b | 10100010b = 11110110b
-11010100b | 10100011b = 11110111b
-11010100b | 10100100b = 11110100b
-11010100b | 10100101b = 11110101b
-11010100b | 10100110b = 11110110b
-11010100b | 10100111b = 11110111b
-11010100b | 10101000b = 11111100b
-11010100b | 10101001b = 11111101b
-11010100b | 10101010b = 11111110b
-11010100b | 10101011b = 11111111b
-11010100b | 10101100b = 11111100b
-11010100b | 10101101b = 11111101b
-11010100b | 10101110b = 11111110b
-11010100b | 10101111b = 11111111b
-11010100b | 10110000b = 11110100b
-11010100b | 10110001b = 11110101b
-11010100b | 10110010b = 11110110b
-11010100b | 10110011b = 11110111b
-11010100b | 10110100b = 11110100b
-11010100b | 10110101b = 11110101b
-11010100b | 10110110b = 11110110b
-11010100b | 10110111b = 11110111b
-11010100b | 10111000b = 11111100b
-11010100b | 10111001b = 11111101b
-11010100b | 10111010b = 11111110b
-11010100b | 10111011b = 11111111b
-11010100b | 10111100b = 11111100b
-11010100b | 10111101b = 11111101b
-11010100b | 10111110b = 11111110b
-11010100b | 10111111b = 11111111b
-11010100b | 11000000b = 11010100b
-11010100b | 11000001b = 11010101b
-11010100b | 11000010b = 11010110b
-11010100b | 11000011b = 11010111b
-11010100b | 11000100b = 11010100b
-11010100b | 11000101b = 11010101b
-11010100b | 11000110b = 11010110b
-11010100b | 11000111b = 11010111b
-11010100b | 11001000b = 11011100b
-11010100b | 11001001b = 11011101b
-11010100b | 11001010b = 11011110b
-11010100b | 11001011b = 11011111b
-11010100b | 11001100b = 11011100b
-11010100b | 11001101b = 11011101b
-11010100b | 11001110b = 11011110b
-11010100b | 11001111b = 11011111b
-11010100b | 11010000b = 11010100b
-11010100b | 11010001b = 11010101b
-11010100b | 11010010b = 11010110b
-11010100b | 11010011b = 11010111b
-11010100b | 11010100b = 11010100b
-11010100b | 11010101b = 11010101b
-11010100b | 11010110b = 11010110b
-11010100b | 11010111b = 11010111b
-11010100b | 11011000b = 11011100b
-11010100b | 11011001b = 11011101b
-11010100b | 11011010b = 11011110b
-11010100b | 11011011b = 11011111b
-11010100b | 11011100b = 11011100b
-11010100b | 11011101b = 11011101b
-11010100b | 11011110b = 11011110b
-11010100b | 11011111b = 11011111b
-11010100b | 11100000b = 11110100b
-11010100b | 11100001b = 11110101b
-11010100b | 11100010b = 11110110b
-11010100b | 11100011b = 11110111b
-11010100b | 11100100b = 11110100b
-11010100b | 11100101b = 11110101b
-11010100b | 11100110b = 11110110b
-11010100b | 11100111b = 11110111b
-11010100b | 11101000b = 11111100b
-11010100b | 11101001b = 11111101b
-11010100b | 11101010b = 11111110b
-11010100b | 11101011b = 11111111b
-11010100b | 11101100b = 11111100b
-11010100b | 11101101b = 11111101b
-11010100b | 11101110b = 11111110b
-11010100b | 11101111b = 11111111b
-11010100b | 11110000b = 11110100b
-11010100b | 11110001b = 11110101b
-11010100b | 11110010b = 11110110b
-11010100b | 11110011b = 11110111b
-11010100b | 11110100b = 11110100b
-11010100b | 11110101b = 11110101b
-11010100b | 11110110b = 11110110b
-11010100b | 11110111b = 11110111b
-11010100b | 11111000b = 11111100b
-11010100b | 11111001b = 11111101b
-11010100b | 11111010b = 11111110b
-11010100b | 11111011b = 11111111b
-11010100b | 11111100b = 11111100b
-11010100b | 11111101b = 11111101b
-11010100b | 11111110b = 11111110b
-11010100b | 11111111b = 11111111b
-11010100b | 00000000b = 11010100b
-11010100b | 00000001b = 11010101b
-11010100b | 00000010b = 11010110b
-11010100b | 00000011b = 11010111b
-11010100b | 00000100b = 11010100b
-11010100b | 00000101b = 11010101b
-11010100b | 00000110b = 11010110b
-11010100b | 00000111b = 11010111b
-11010100b | 00001000b = 11011100b
-11010100b | 00001001b = 11011101b
-11010100b | 00001010b = 11011110b
-11010100b | 00001011b = 11011111b
-11010100b | 00001100b = 11011100b
-11010100b | 00001101b = 11011101b
-11010100b | 00001110b = 11011110b
-11010100b | 00001111b = 11011111b
-11010100b | 00010000b = 11010100b
-11010100b | 00010001b = 11010101b
-11010100b | 00010010b = 11010110b
-11010100b | 00010011b = 11010111b
-11010100b | 00010100b = 11010100b
-11010100b | 00010101b = 11010101b
-11010100b | 00010110b = 11010110b
-11010100b | 00010111b = 11010111b
-11010100b | 00011000b = 11011100b
-11010100b | 00011001b = 11011101b
-11010100b | 00011010b = 11011110b
-11010100b | 00011011b = 11011111b
-11010100b | 00011100b = 11011100b
-11010100b | 00011101b = 11011101b
-11010100b | 00011110b = 11011110b
-11010100b | 00011111b = 11011111b
-11010100b | 00100000b = 11110100b
-11010100b | 00100001b = 11110101b
-11010100b | 00100010b = 11110110b
-11010100b | 00100011b = 11110111b
-11010100b | 00100100b = 11110100b
-11010100b | 00100101b = 11110101b
-11010100b | 00100110b = 11110110b
-11010100b | 00100111b = 11110111b
-11010100b | 00101000b = 11111100b
-11010100b | 00101001b = 11111101b
-11010100b | 00101010b = 11111110b
-11010100b | 00101011b = 11111111b
-11010100b | 00101100b = 11111100b
-11010100b | 00101101b = 11111101b
-11010100b | 00101110b = 11111110b
-11010100b | 00101111b = 11111111b
-11010100b | 00110000b = 11110100b
-11010100b | 00110001b = 11110101b
-11010100b | 00110010b = 11110110b
-11010100b | 00110011b = 11110111b
-11010100b | 00110100b = 11110100b
-11010100b | 00110101b = 11110101b
-11010100b | 00110110b = 11110110b
-11010100b | 00110111b = 11110111b
-11010100b | 00111000b = 11111100b
-11010100b | 00111001b = 11111101b
-11010100b | 00111010b = 11111110b
-11010100b | 00111011b = 11111111b
-11010100b | 00111100b = 11111100b
-11010100b | 00111101b = 11111101b
-11010100b | 00111110b = 11111110b
-11010100b | 00111111b = 11111111b
-11010100b | 01000000b = 11010100b
-11010100b | 01000001b = 11010101b
-11010100b | 01000010b = 11010110b
-11010100b | 01000011b = 11010111b
-11010100b | 01000100b = 11010100b
-11010100b | 01000101b = 11010101b
-11010100b | 01000110b = 11010110b
-11010100b | 01000111b = 11010111b
-11010100b | 01001000b = 11011100b
-11010100b | 01001001b = 11011101b
-11010100b | 01001010b = 11011110b
-11010100b | 01001011b = 11011111b
-11010100b | 01001100b = 11011100b
-11010100b | 01001101b = 11011101b
-11010100b | 01001110b = 11011110b
-11010100b | 01001111b = 11011111b
-11010100b | 01010000b = 11010100b
-11010100b | 01010001b = 11010101b
-11010100b | 01010010b = 11010110b
-11010100b | 01010011b = 11010111b
-11010100b | 01010100b = 11010100b
-11010100b | 01010101b = 11010101b
-11010100b | 01010110b = 11010110b
-11010100b | 01010111b = 11010111b
-11010100b | 01011000b = 11011100b
-11010100b | 01011001b = 11011101b
-11010100b | 01011010b = 11011110b
-11010100b | 01011011b = 11011111b
-11010100b | 01011100b = 11011100b
-11010100b | 01011101b = 11011101b
-11010100b | 01011110b = 11011110b
-11010100b | 01011111b = 11011111b
-11010100b | 01100000b = 11110100b
-11010100b | 01100001b = 11110101b
-11010100b | 01100010b = 11110110b
-11010100b | 01100011b = 11110111b
-11010100b | 01100100b = 11110100b
-11010100b | 01100101b = 11110101b
-11010100b | 01100110b = 11110110b
-11010100b | 01100111b = 11110111b
-11010100b | 01101000b = 11111100b
-11010100b | 01101001b = 11111101b
-11010100b | 01101010b = 11111110b
-11010100b | 01101011b = 11111111b
-11010100b | 01101100b = 11111100b
-11010100b | 01101101b = 11111101b
-11010100b | 01101110b = 11111110b
-11010100b | 01101111b = 11111111b
-11010100b | 01110000b = 11110100b
-11010100b | 01110001b = 11110101b
-11010100b | 01110010b = 11110110b
-11010100b | 01110011b = 11110111b
-11010100b | 01110100b = 11110100b
-11010100b | 01110101b = 11110101b
-11010100b | 01110110b = 11110110b
-11010100b | 01110111b = 11110111b
-11010100b | 01111000b = 11111100b
-11010100b | 01111001b = 11111101b
-11010100b | 01111010b = 11111110b
-11010100b | 01111011b = 11111111b
-11010100b | 01111100b = 11111100b
-11010100b | 01111101b = 11111101b
-11010100b | 01111110b = 11111110b
-11010101b | 10000000b = 11010101b
-11010101b | 10000001b = 11010101b
-11010101b | 10000010b = 11010111b
-11010101b | 10000011b = 11010111b
-11010101b | 10000100b = 11010101b
-11010101b | 10000101b = 11010101b
-11010101b | 10000110b = 11010111b
-11010101b | 10000111b = 11010111b
-11010101b | 10001000b = 11011101b
-11010101b | 10001001b = 11011101b
-11010101b | 10001010b = 11011111b
-11010101b | 10001011b = 11011111b
-11010101b | 10001100b = 11011101b
-11010101b | 10001101b = 11011101b
-11010101b | 10001110b = 11011111b
-11010101b | 10001111b = 11011111b
-11010101b | 10010000b = 11010101b
-11010101b | 10010001b = 11010101b
-11010101b | 10010010b = 11010111b
-11010101b | 10010011b = 11010111b
-11010101b | 10010100b = 11010101b
-11010101b | 10010101b = 11010101b
-11010101b | 10010110b = 11010111b
-11010101b | 10010111b = 11010111b
-11010101b | 10011000b = 11011101b
-11010101b | 10011001b = 11011101b
-11010101b | 10011010b = 11011111b
-11010101b | 10011011b = 11011111b
-11010101b | 10011100b = 11011101b
-11010101b | 10011101b = 11011101b
-11010101b | 10011110b = 11011111b
-11010101b | 10011111b = 11011111b
-11010101b | 10100000b = 11110101b
-11010101b | 10100001b = 11110101b
-11010101b | 10100010b = 11110111b
-11010101b | 10100011b = 11110111b
-11010101b | 10100100b = 11110101b
-11010101b | 10100101b = 11110101b
-11010101b | 10100110b = 11110111b
-11010101b | 10100111b = 11110111b
-11010101b | 10101000b = 11111101b
-11010101b | 10101001b = 11111101b
-11010101b | 10101010b = 11111111b
-11010101b | 10101011b = 11111111b
-11010101b | 10101100b = 11111101b
-11010101b | 10101101b = 11111101b
-11010101b | 10101110b = 11111111b
-11010101b | 10101111b = 11111111b
-11010101b | 10110000b = 11110101b
-11010101b | 10110001b = 11110101b
-11010101b | 10110010b = 11110111b
-11010101b | 10110011b = 11110111b
-11010101b | 10110100b = 11110101b
-11010101b | 10110101b = 11110101b
-11010101b | 10110110b = 11110111b
-11010101b | 10110111b = 11110111b
-11010101b | 10111000b = 11111101b
-11010101b | 10111001b = 11111101b
-11010101b | 10111010b = 11111111b
-11010101b | 10111011b = 11111111b
-11010101b | 10111100b = 11111101b
-11010101b | 10111101b = 11111101b
-11010101b | 10111110b = 11111111b
-11010101b | 10111111b = 11111111b
-11010101b | 11000000b = 11010101b
-11010101b | 11000001b = 11010101b
-11010101b | 11000010b = 11010111b
-11010101b | 11000011b = 11010111b
-11010101b | 11000100b = 11010101b
-11010101b | 11000101b = 11010101b
-11010101b | 11000110b = 11010111b
-11010101b | 11000111b = 11010111b
-11010101b | 11001000b = 11011101b
-11010101b | 11001001b = 11011101b
-11010101b | 11001010b = 11011111b
-11010101b | 11001011b = 11011111b
-11010101b | 11001100b = 11011101b
-11010101b | 11001101b = 11011101b
-11010101b | 11001110b = 11011111b
-11010101b | 11001111b = 11011111b
-11010101b | 11010000b = 11010101b
-11010101b | 11010001b = 11010101b
-11010101b | 11010010b = 11010111b
-11010101b | 11010011b = 11010111b
-11010101b | 11010100b = 11010101b
-11010101b | 11010101b = 11010101b
-11010101b | 11010110b = 11010111b
-11010101b | 11010111b = 11010111b
-11010101b | 11011000b = 11011101b
-11010101b | 11011001b = 11011101b
-11010101b | 11011010b = 11011111b
-11010101b | 11011011b = 11011111b
-11010101b | 11011100b = 11011101b
-11010101b | 11011101b = 11011101b
-11010101b | 11011110b = 11011111b
-11010101b | 11011111b = 11011111b
-11010101b | 11100000b = 11110101b
-11010101b | 11100001b = 11110101b
-11010101b | 11100010b = 11110111b
-11010101b | 11100011b = 11110111b
-11010101b | 11100100b = 11110101b
-11010101b | 11100101b = 11110101b
-11010101b | 11100110b = 11110111b
-11010101b | 11100111b = 11110111b
-11010101b | 11101000b = 11111101b
-11010101b | 11101001b = 11111101b
-11010101b | 11101010b = 11111111b
-11010101b | 11101011b = 11111111b
-11010101b | 11101100b = 11111101b
-11010101b | 11101101b = 11111101b
-11010101b | 11101110b = 11111111b
-11010101b | 11101111b = 11111111b
-11010101b | 11110000b = 11110101b
-11010101b | 11110001b = 11110101b
-11010101b | 11110010b = 11110111b
-11010101b | 11110011b = 11110111b
-11010101b | 11110100b = 11110101b
-11010101b | 11110101b = 11110101b
-11010101b | 11110110b = 11110111b
-11010101b | 11110111b = 11110111b
-11010101b | 11111000b = 11111101b
-11010101b | 11111001b = 11111101b
-11010101b | 11111010b = 11111111b
-11010101b | 11111011b = 11111111b
-11010101b | 11111100b = 11111101b
-11010101b | 11111101b = 11111101b
-11010101b | 11111110b = 11111111b
-11010101b | 11111111b = 11111111b
-11010101b | 00000000b = 11010101b
-11010101b | 00000001b = 11010101b
-11010101b | 00000010b = 11010111b
-11010101b | 00000011b = 11010111b
-11010101b | 00000100b = 11010101b
-11010101b | 00000101b = 11010101b
-11010101b | 00000110b = 11010111b
-11010101b | 00000111b = 11010111b
-11010101b | 00001000b = 11011101b
-11010101b | 00001001b = 11011101b
-11010101b | 00001010b = 11011111b
-11010101b | 00001011b = 11011111b
-11010101b | 00001100b = 11011101b
-11010101b | 00001101b = 11011101b
-11010101b | 00001110b = 11011111b
-11010101b | 00001111b = 11011111b
-11010101b | 00010000b = 11010101b
-11010101b | 00010001b = 11010101b
-11010101b | 00010010b = 11010111b
-11010101b | 00010011b = 11010111b
-11010101b | 00010100b = 11010101b
-11010101b | 00010101b = 11010101b
-11010101b | 00010110b = 11010111b
-11010101b | 00010111b = 11010111b
-11010101b | 00011000b = 11011101b
-11010101b | 00011001b = 11011101b
-11010101b | 00011010b = 11011111b
-11010101b | 00011011b = 11011111b
-11010101b | 00011100b = 11011101b
-11010101b | 00011101b = 11011101b
-11010101b | 00011110b = 11011111b
-11010101b | 00011111b = 11011111b
-11010101b | 00100000b = 11110101b
-11010101b | 00100001b = 11110101b
-11010101b | 00100010b = 11110111b
-11010101b | 00100011b = 11110111b
-11010101b | 00100100b = 11110101b
-11010101b | 00100101b = 11110101b
-11010101b | 00100110b = 11110111b
-11010101b | 00100111b = 11110111b
-11010101b | 00101000b = 11111101b
-11010101b | 00101001b = 11111101b
-11010101b | 00101010b = 11111111b
-11010101b | 00101011b = 11111111b
-11010101b | 00101100b = 11111101b
-11010101b | 00101101b = 11111101b
-11010101b | 00101110b = 11111111b
-11010101b | 00101111b = 11111111b
-11010101b | 00110000b = 11110101b
-11010101b | 00110001b = 11110101b
-11010101b | 00110010b = 11110111b
-11010101b | 00110011b = 11110111b
-11010101b | 00110100b = 11110101b
-11010101b | 00110101b = 11110101b
-11010101b | 00110110b = 11110111b
-11010101b | 00110111b = 11110111b
-11010101b | 00111000b = 11111101b
-11010101b | 00111001b = 11111101b
-11010101b | 00111010b = 11111111b
-11010101b | 00111011b = 11111111b
-11010101b | 00111100b = 11111101b
-11010101b | 00111101b = 11111101b
-11010101b | 00111110b = 11111111b
-11010101b | 00111111b = 11111111b
-11010101b | 01000000b = 11010101b
-11010101b | 01000001b = 11010101b
-11010101b | 01000010b = 11010111b
-11010101b | 01000011b = 11010111b
-11010101b | 01000100b = 11010101b
-11010101b | 01000101b = 11010101b
-11010101b | 01000110b = 11010111b
-11010101b | 01000111b = 11010111b
-11010101b | 01001000b = 11011101b
-11010101b | 01001001b = 11011101b
-11010101b | 01001010b = 11011111b
-11010101b | 01001011b = 11011111b
-11010101b | 01001100b = 11011101b
-11010101b | 01001101b = 11011101b
-11010101b | 01001110b = 11011111b
-11010101b | 01001111b = 11011111b
-11010101b | 01010000b = 11010101b
-11010101b | 01010001b = 11010101b
-11010101b | 01010010b = 11010111b
-11010101b | 01010011b = 11010111b
-11010101b | 01010100b = 11010101b
-11010101b | 01010101b = 11010101b
-11010101b | 01010110b = 11010111b
-11010101b | 01010111b = 11010111b
-11010101b | 01011000b = 11011101b
-11010101b | 01011001b = 11011101b
-11010101b | 01011010b = 11011111b
-11010101b | 01011011b = 11011111b
-11010101b | 01011100b = 11011101b
-11010101b | 01011101b = 11011101b
-11010101b | 01011110b = 11011111b
-11010101b | 01011111b = 11011111b
-11010101b | 01100000b = 11110101b
-11010101b | 01100001b = 11110101b
-11010101b | 01100010b = 11110111b
-11010101b | 01100011b = 11110111b
-11010101b | 01100100b = 11110101b
-11010101b | 01100101b = 11110101b
-11010101b | 01100110b = 11110111b
-11010101b | 01100111b = 11110111b
-11010101b | 01101000b = 11111101b
-11010101b | 01101001b = 11111101b
-11010101b | 01101010b = 11111111b
-11010101b | 01101011b = 11111111b
-11010101b | 01101100b = 11111101b
-11010101b | 01101101b = 11111101b
-11010101b | 01101110b = 11111111b
-11010101b | 01101111b = 11111111b
-11010101b | 01110000b = 11110101b
-11010101b | 01110001b = 11110101b
-11010101b | 01110010b = 11110111b
-11010101b | 01110011b = 11110111b
-11010101b | 01110100b = 11110101b
-11010101b | 01110101b = 11110101b
-11010101b | 01110110b = 11110111b
-11010101b | 01110111b = 11110111b
-11010101b | 01111000b = 11111101b
-11010101b | 01111001b = 11111101b
-11010101b | 01111010b = 11111111b
-11010101b | 01111011b = 11111111b
-11010101b | 01111100b = 11111101b
-11010101b | 01111101b = 11111101b
-11010101b | 01111110b = 11111111b
-11010110b | 10000000b = 11010110b
-11010110b | 10000001b = 11010111b
-11010110b | 10000010b = 11010110b
-11010110b | 10000011b = 11010111b
-11010110b | 10000100b = 11010110b
-11010110b | 10000101b = 11010111b
-11010110b | 10000110b = 11010110b
-11010110b | 10000111b = 11010111b
-11010110b | 10001000b = 11011110b
-11010110b | 10001001b = 11011111b
-11010110b | 10001010b = 11011110b
-11010110b | 10001011b = 11011111b
-11010110b | 10001100b = 11011110b
-11010110b | 10001101b = 11011111b
-11010110b | 10001110b = 11011110b
-11010110b | 10001111b = 11011111b
-11010110b | 10010000b = 11010110b
-11010110b | 10010001b = 11010111b
-11010110b | 10010010b = 11010110b
-11010110b | 10010011b = 11010111b
-11010110b | 10010100b = 11010110b
-11010110b | 10010101b = 11010111b
-11010110b | 10010110b = 11010110b
-11010110b | 10010111b = 11010111b
-11010110b | 10011000b = 11011110b
-11010110b | 10011001b = 11011111b
-11010110b | 10011010b = 11011110b
-11010110b | 10011011b = 11011111b
-11010110b | 10011100b = 11011110b
-11010110b | 10011101b = 11011111b
-11010110b | 10011110b = 11011110b
-11010110b | 10011111b = 11011111b
-11010110b | 10100000b = 11110110b
-11010110b | 10100001b = 11110111b
-11010110b | 10100010b = 11110110b
-11010110b | 10100011b = 11110111b
-11010110b | 10100100b = 11110110b
-11010110b | 10100101b = 11110111b
-11010110b | 10100110b = 11110110b
-11010110b | 10100111b = 11110111b
-11010110b | 10101000b = 11111110b
-11010110b | 10101001b = 11111111b
-11010110b | 10101010b = 11111110b
-11010110b | 10101011b = 11111111b
-11010110b | 10101100b = 11111110b
-11010110b | 10101101b = 11111111b
-11010110b | 10101110b = 11111110b
-11010110b | 10101111b = 11111111b
-11010110b | 10110000b = 11110110b
-11010110b | 10110001b = 11110111b
-11010110b | 10110010b = 11110110b
-11010110b | 10110011b = 11110111b
-11010110b | 10110100b = 11110110b
-11010110b | 10110101b = 11110111b
-11010110b | 10110110b = 11110110b
-11010110b | 10110111b = 11110111b
-11010110b | 10111000b = 11111110b
-11010110b | 10111001b = 11111111b
-11010110b | 10111010b = 11111110b
-11010110b | 10111011b = 11111111b
-11010110b | 10111100b = 11111110b
-11010110b | 10111101b = 11111111b
-11010110b | 10111110b = 11111110b
-11010110b | 10111111b = 11111111b
-11010110b | 11000000b = 11010110b
-11010110b | 11000001b = 11010111b
-11010110b | 11000010b = 11010110b
-11010110b | 11000011b = 11010111b
-11010110b | 11000100b = 11010110b
-11010110b | 11000101b = 11010111b
-11010110b | 11000110b = 11010110b
-11010110b | 11000111b = 11010111b
-11010110b | 11001000b = 11011110b
-11010110b | 11001001b = 11011111b
-11010110b | 11001010b = 11011110b
-11010110b | 11001011b = 11011111b
-11010110b | 11001100b = 11011110b
-11010110b | 11001101b = 11011111b
-11010110b | 11001110b = 11011110b
-11010110b | 11001111b = 11011111b
-11010110b | 11010000b = 11010110b
-11010110b | 11010001b = 11010111b
-11010110b | 11010010b = 11010110b
-11010110b | 11010011b = 11010111b
-11010110b | 11010100b = 11010110b
-11010110b | 11010101b = 11010111b
-11010110b | 11010110b = 11010110b
-11010110b | 11010111b = 11010111b
-11010110b | 11011000b = 11011110b
-11010110b | 11011001b = 11011111b
-11010110b | 11011010b = 11011110b
-11010110b | 11011011b = 11011111b
-11010110b | 11011100b = 11011110b
-11010110b | 11011101b = 11011111b
-11010110b | 11011110b = 11011110b
-11010110b | 11011111b = 11011111b
-11010110b | 11100000b = 11110110b
-11010110b | 11100001b = 11110111b
-11010110b | 11100010b = 11110110b
-11010110b | 11100011b = 11110111b
-11010110b | 11100100b = 11110110b
-11010110b | 11100101b = 11110111b
-11010110b | 11100110b = 11110110b
-11010110b | 11100111b = 11110111b
-11010110b | 11101000b = 11111110b
-11010110b | 11101001b = 11111111b
-11010110b | 11101010b = 11111110b
-11010110b | 11101011b = 11111111b
-11010110b | 11101100b = 11111110b
-11010110b | 11101101b = 11111111b
-11010110b | 11101110b = 11111110b
-11010110b | 11101111b = 11111111b
-11010110b | 11110000b = 11110110b
-11010110b | 11110001b = 11110111b
-11010110b | 11110010b = 11110110b
-11010110b | 11110011b = 11110111b
-11010110b | 11110100b = 11110110b
-11010110b | 11110101b = 11110111b
-11010110b | 11110110b = 11110110b
-11010110b | 11110111b = 11110111b
-11010110b | 11111000b = 11111110b
-11010110b | 11111001b = 11111111b
-11010110b | 11111010b = 11111110b
-11010110b | 11111011b = 11111111b
-11010110b | 11111100b = 11111110b
-11010110b | 11111101b = 11111111b
-11010110b | 11111110b = 11111110b
-11010110b | 11111111b = 11111111b
-11010110b | 00000000b = 11010110b
-11010110b | 00000001b = 11010111b
-11010110b | 00000010b = 11010110b
-11010110b | 00000011b = 11010111b
-11010110b | 00000100b = 11010110b
-11010110b | 00000101b = 11010111b
-11010110b | 00000110b = 11010110b
-11010110b | 00000111b = 11010111b
-11010110b | 00001000b = 11011110b
-11010110b | 00001001b = 11011111b
-11010110b | 00001010b = 11011110b
-11010110b | 00001011b = 11011111b
-11010110b | 00001100b = 11011110b
-11010110b | 00001101b = 11011111b
-11010110b | 00001110b = 11011110b
-11010110b | 00001111b = 11011111b
-11010110b | 00010000b = 11010110b
-11010110b | 00010001b = 11010111b
-11010110b | 00010010b = 11010110b
-11010110b | 00010011b = 11010111b
-11010110b | 00010100b = 11010110b
-11010110b | 00010101b = 11010111b
-11010110b | 00010110b = 11010110b
-11010110b | 00010111b = 11010111b
-11010110b | 00011000b = 11011110b
-11010110b | 00011001b = 11011111b
-11010110b | 00011010b = 11011110b
-11010110b | 00011011b = 11011111b
-11010110b | 00011100b = 11011110b
-11010110b | 00011101b = 11011111b
-11010110b | 00011110b = 11011110b
-11010110b | 00011111b = 11011111b
-11010110b | 00100000b = 11110110b
-11010110b | 00100001b = 11110111b
-11010110b | 00100010b = 11110110b
-11010110b | 00100011b = 11110111b
-11010110b | 00100100b = 11110110b
-11010110b | 00100101b = 11110111b
-11010110b | 00100110b = 11110110b
-11010110b | 00100111b = 11110111b
-11010110b | 00101000b = 11111110b
-11010110b | 00101001b = 11111111b
-11010110b | 00101010b = 11111110b
-11010110b | 00101011b = 11111111b
-11010110b | 00101100b = 11111110b
-11010110b | 00101101b = 11111111b
-11010110b | 00101110b = 11111110b
-11010110b | 00101111b = 11111111b
-11010110b | 00110000b = 11110110b
-11010110b | 00110001b = 11110111b
-11010110b | 00110010b = 11110110b
-11010110b | 00110011b = 11110111b
-11010110b | 00110100b = 11110110b
-11010110b | 00110101b = 11110111b
-11010110b | 00110110b = 11110110b
-11010110b | 00110111b = 11110111b
-11010110b | 00111000b = 11111110b
-11010110b | 00111001b = 11111111b
-11010110b | 00111010b = 11111110b
-11010110b | 00111011b = 11111111b
-11010110b | 00111100b = 11111110b
-11010110b | 00111101b = 11111111b
-11010110b | 00111110b = 11111110b
-11010110b | 00111111b = 11111111b
-11010110b | 01000000b = 11010110b
-11010110b | 01000001b = 11010111b
-11010110b | 01000010b = 11010110b
-11010110b | 01000011b = 11010111b
-11010110b | 01000100b = 11010110b
-11010110b | 01000101b = 11010111b
-11010110b | 01000110b = 11010110b
-11010110b | 01000111b = 11010111b
-11010110b | 01001000b = 11011110b
-11010110b | 01001001b = 11011111b
-11010110b | 01001010b = 11011110b
-11010110b | 01001011b = 11011111b
-11010110b | 01001100b = 11011110b
-11010110b | 01001101b = 11011111b
-11010110b | 01001110b = 11011110b
-11010110b | 01001111b = 11011111b
-11010110b | 01010000b = 11010110b
-11010110b | 01010001b = 11010111b
-11010110b | 01010010b = 11010110b
-11010110b | 01010011b = 11010111b
-11010110b | 01010100b = 11010110b
-11010110b | 01010101b = 11010111b
-11010110b | 01010110b = 11010110b
-11010110b | 01010111b = 11010111b
-11010110b | 01011000b = 11011110b
-11010110b | 01011001b = 11011111b
-11010110b | 01011010b = 11011110b
-11010110b | 01011011b = 11011111b
-11010110b | 01011100b = 11011110b
-11010110b | 01011101b = 11011111b
-11010110b | 01011110b = 11011110b
-11010110b | 01011111b = 11011111b
-11010110b | 01100000b = 11110110b
-11010110b | 01100001b = 11110111b
-11010110b | 01100010b = 11110110b
-11010110b | 01100011b = 11110111b
-11010110b | 01100100b = 11110110b
-11010110b | 01100101b = 11110111b
-11010110b | 01100110b = 11110110b
-11010110b | 01100111b = 11110111b
-11010110b | 01101000b = 11111110b
-11010110b | 01101001b = 11111111b
-11010110b | 01101010b = 11111110b
-11010110b | 01101011b = 11111111b
-11010110b | 01101100b = 11111110b
-11010110b | 01101101b = 11111111b
-11010110b | 01101110b = 11111110b
-11010110b | 01101111b = 11111111b
-11010110b | 01110000b = 11110110b
-11010110b | 01110001b = 11110111b
-11010110b | 01110010b = 11110110b
-11010110b | 01110011b = 11110111b
-11010110b | 01110100b = 11110110b
-11010110b | 01110101b = 11110111b
-11010110b | 01110110b = 11110110b
-11010110b | 01110111b = 11110111b
-11010110b | 01111000b = 11111110b
-11010110b | 01111001b = 11111111b
-11010110b | 01111010b = 11111110b
-11010110b | 01111011b = 11111111b
-11010110b | 01111100b = 11111110b
-11010110b | 01111101b = 11111111b
-11010110b | 01111110b = 11111110b
-11010111b | 10000000b = 11010111b
-11010111b | 10000001b = 11010111b
-11010111b | 10000010b = 11010111b
-11010111b | 10000011b = 11010111b
-11010111b | 10000100b = 11010111b
-11010111b | 10000101b = 11010111b
-11010111b | 10000110b = 11010111b
-11010111b | 10000111b = 11010111b
-11010111b | 10001000b = 11011111b
-11010111b | 10001001b = 11011111b
-11010111b | 10001010b = 11011111b
-11010111b | 10001011b = 11011111b
-11010111b | 10001100b = 11011111b
-11010111b | 10001101b = 11011111b
-11010111b | 10001110b = 11011111b
-11010111b | 10001111b = 11011111b
-11010111b | 10010000b = 11010111b
-11010111b | 10010001b = 11010111b
-11010111b | 10010010b = 11010111b
-11010111b | 10010011b = 11010111b
-11010111b | 10010100b = 11010111b
-11010111b | 10010101b = 11010111b
-11010111b | 10010110b = 11010111b
-11010111b | 10010111b = 11010111b
-11010111b | 10011000b = 11011111b
-11010111b | 10011001b = 11011111b
-11010111b | 10011010b = 11011111b
-11010111b | 10011011b = 11011111b
-11010111b | 10011100b = 11011111b
-11010111b | 10011101b = 11011111b
-11010111b | 10011110b = 11011111b
-11010111b | 10011111b = 11011111b
-11010111b | 10100000b = 11110111b
-11010111b | 10100001b = 11110111b
-11010111b | 10100010b = 11110111b
-11010111b | 10100011b = 11110111b
-11010111b | 10100100b = 11110111b
-11010111b | 10100101b = 11110111b
-11010111b | 10100110b = 11110111b
-11010111b | 10100111b = 11110111b
-11010111b | 10101000b = 11111111b
-11010111b | 10101001b = 11111111b
-11010111b | 10101010b = 11111111b
-11010111b | 10101011b = 11111111b
-11010111b | 10101100b = 11111111b
-11010111b | 10101101b = 11111111b
-11010111b | 10101110b = 11111111b
-11010111b | 10101111b = 11111111b
-11010111b | 10110000b = 11110111b
-11010111b | 10110001b = 11110111b
-11010111b | 10110010b = 11110111b
-11010111b | 10110011b = 11110111b
-11010111b | 10110100b = 11110111b
-11010111b | 10110101b = 11110111b
-11010111b | 10110110b = 11110111b
-11010111b | 10110111b = 11110111b
-11010111b | 10111000b = 11111111b
-11010111b | 10111001b = 11111111b
-11010111b | 10111010b = 11111111b
-11010111b | 10111011b = 11111111b
-11010111b | 10111100b = 11111111b
-11010111b | 10111101b = 11111111b
-11010111b | 10111110b = 11111111b
-11010111b | 10111111b = 11111111b
-11010111b | 11000000b = 11010111b
-11010111b | 11000001b = 11010111b
-11010111b | 11000010b = 11010111b
-11010111b | 11000011b = 11010111b
-11010111b | 11000100b = 11010111b
-11010111b | 11000101b = 11010111b
-11010111b | 11000110b = 11010111b
-11010111b | 11000111b = 11010111b
-11010111b | 11001000b = 11011111b
-11010111b | 11001001b = 11011111b
-11010111b | 11001010b = 11011111b
-11010111b | 11001011b = 11011111b
-11010111b | 11001100b = 11011111b
-11010111b | 11001101b = 11011111b
-11010111b | 11001110b = 11011111b
-11010111b | 11001111b = 11011111b
-11010111b | 11010000b = 11010111b
-11010111b | 11010001b = 11010111b
-11010111b | 11010010b = 11010111b
-11010111b | 11010011b = 11010111b
-11010111b | 11010100b = 11010111b
-11010111b | 11010101b = 11010111b
-11010111b | 11010110b = 11010111b
-11010111b | 11010111b = 11010111b
-11010111b | 11011000b = 11011111b
-11010111b | 11011001b = 11011111b
-11010111b | 11011010b = 11011111b
-11010111b | 11011011b = 11011111b
-11010111b | 11011100b = 11011111b
-11010111b | 11011101b = 11011111b
-11010111b | 11011110b = 11011111b
-11010111b | 11011111b = 11011111b
-11010111b | 11100000b = 11110111b
-11010111b | 11100001b = 11110111b
-11010111b | 11100010b = 11110111b
-11010111b | 11100011b = 11110111b
-11010111b | 11100100b = 11110111b
-11010111b | 11100101b = 11110111b
-11010111b | 11100110b = 11110111b
-11010111b | 11100111b = 11110111b
-11010111b | 11101000b = 11111111b
-11010111b | 11101001b = 11111111b
-11010111b | 11101010b = 11111111b
-11010111b | 11101011b = 11111111b
-11010111b | 11101100b = 11111111b
-11010111b | 11101101b = 11111111b
-11010111b | 11101110b = 11111111b
-11010111b | 11101111b = 11111111b
-11010111b | 11110000b = 11110111b
-11010111b | 11110001b = 11110111b
-11010111b | 11110010b = 11110111b
-11010111b | 11110011b = 11110111b
-11010111b | 11110100b = 11110111b
-11010111b | 11110101b = 11110111b
-11010111b | 11110110b = 11110111b
-11010111b | 11110111b = 11110111b
-11010111b | 11111000b = 11111111b
-11010111b | 11111001b = 11111111b
-11010111b | 11111010b = 11111111b
-11010111b | 11111011b = 11111111b
-11010111b | 11111100b = 11111111b
-11010111b | 11111101b = 11111111b
-11010111b | 11111110b = 11111111b
-11010111b | 11111111b = 11111111b
-11010111b | 00000000b = 11010111b
-11010111b | 00000001b = 11010111b
-11010111b | 00000010b = 11010111b
-11010111b | 00000011b = 11010111b
-11010111b | 00000100b = 11010111b
-11010111b | 00000101b = 11010111b
-11010111b | 00000110b = 11010111b
-11010111b | 00000111b = 11010111b
-11010111b | 00001000b = 11011111b
-11010111b | 00001001b = 11011111b
-11010111b | 00001010b = 11011111b
-11010111b | 00001011b = 11011111b
-11010111b | 00001100b = 11011111b
-11010111b | 00001101b = 11011111b
-11010111b | 00001110b = 11011111b
-11010111b | 00001111b = 11011111b
-11010111b | 00010000b = 11010111b
-11010111b | 00010001b = 11010111b
-11010111b | 00010010b = 11010111b
-11010111b | 00010011b = 11010111b
-11010111b | 00010100b = 11010111b
-11010111b | 00010101b = 11010111b
-11010111b | 00010110b = 11010111b
-11010111b | 00010111b = 11010111b
-11010111b | 00011000b = 11011111b
-11010111b | 00011001b = 11011111b
-11010111b | 00011010b = 11011111b
-11010111b | 00011011b = 11011111b
-11010111b | 00011100b = 11011111b
-11010111b | 00011101b = 11011111b
-11010111b | 00011110b = 11011111b
-11010111b | 00011111b = 11011111b
-11010111b | 00100000b = 11110111b
-11010111b | 00100001b = 11110111b
-11010111b | 00100010b = 11110111b
-11010111b | 00100011b = 11110111b
-11010111b | 00100100b = 11110111b
-11010111b | 00100101b = 11110111b
-11010111b | 00100110b = 11110111b
-11010111b | 00100111b = 11110111b
-11010111b | 00101000b = 11111111b
-11010111b | 00101001b = 11111111b
-11010111b | 00101010b = 11111111b
-11010111b | 00101011b = 11111111b
-11010111b | 00101100b = 11111111b
-11010111b | 00101101b = 11111111b
-11010111b | 00101110b = 11111111b
-11010111b | 00101111b = 11111111b
-11010111b | 00110000b = 11110111b
-11010111b | 00110001b = 11110111b
-11010111b | 00110010b = 11110111b
-11010111b | 00110011b = 11110111b
-11010111b | 00110100b = 11110111b
-11010111b | 00110101b = 11110111b
-11010111b | 00110110b = 11110111b
-11010111b | 00110111b = 11110111b
-11010111b | 00111000b = 11111111b
-11010111b | 00111001b = 11111111b
-11010111b | 00111010b = 11111111b
-11010111b | 00111011b = 11111111b
-11010111b | 00111100b = 11111111b
-11010111b | 00111101b = 11111111b
-11010111b | 00111110b = 11111111b
-11010111b | 00111111b = 11111111b
-11010111b | 01000000b = 11010111b
-11010111b | 01000001b = 11010111b
-11010111b | 01000010b = 11010111b
-11010111b | 01000011b = 11010111b
-11010111b | 01000100b = 11010111b
-11010111b | 01000101b = 11010111b
-11010111b | 01000110b = 11010111b
-11010111b | 01000111b = 11010111b
-11010111b | 01001000b = 11011111b
-11010111b | 01001001b = 11011111b
-11010111b | 01001010b = 11011111b
-11010111b | 01001011b = 11011111b
-11010111b | 01001100b = 11011111b
-11010111b | 01001101b = 11011111b
-11010111b | 01001110b = 11011111b
-11010111b | 01001111b = 11011111b
-11010111b | 01010000b = 11010111b
-11010111b | 01010001b = 11010111b
-11010111b | 01010010b = 11010111b
-11010111b | 01010011b = 11010111b
-11010111b | 01010100b = 11010111b
-11010111b | 01010101b = 11010111b
-11010111b | 01010110b = 11010111b
-11010111b | 01010111b = 11010111b
-11010111b | 01011000b = 11011111b
-11010111b | 01011001b = 11011111b
-11010111b | 01011010b = 11011111b
-11010111b | 01011011b = 11011111b
-11010111b | 01011100b = 11011111b
-11010111b | 01011101b = 11011111b
-11010111b | 01011110b = 11011111b
-11010111b | 01011111b = 11011111b
-11010111b | 01100000b = 11110111b
-11010111b | 01100001b = 11110111b
-11010111b | 01100010b = 11110111b
-11010111b | 01100011b = 11110111b
-11010111b | 01100100b = 11110111b
-11010111b | 01100101b = 11110111b
-11010111b | 01100110b = 11110111b
-11010111b | 01100111b = 11110111b
-11010111b | 01101000b = 11111111b
-11010111b | 01101001b = 11111111b
-11010111b | 01101010b = 11111111b
-11010111b | 01101011b = 11111111b
-11010111b | 01101100b = 11111111b
-11010111b | 01101101b = 11111111b
-11010111b | 01101110b = 11111111b
-11010111b | 01101111b = 11111111b
-11010111b | 01110000b = 11110111b
-11010111b | 01110001b = 11110111b
-11010111b | 01110010b = 11110111b
-11010111b | 01110011b = 11110111b
-11010111b | 01110100b = 11110111b
-11010111b | 01110101b = 11110111b
-11010111b | 01110110b = 11110111b
-11010111b | 01110111b = 11110111b
-11010111b | 01111000b = 11111111b
-11010111b | 01111001b = 11111111b
-11010111b | 01111010b = 11111111b
-11010111b | 01111011b = 11111111b
-11010111b | 01111100b = 11111111b
-11010111b | 01111101b = 11111111b
-11010111b | 01111110b = 11111111b
-11011000b | 10000000b = 11011000b
-11011000b | 10000001b = 11011001b
-11011000b | 10000010b = 11011010b
-11011000b | 10000011b = 11011011b
-11011000b | 10000100b = 11011100b
-11011000b | 10000101b = 11011101b
-11011000b | 10000110b = 11011110b
-11011000b | 10000111b = 11011111b
-11011000b | 10001000b = 11011000b
-11011000b | 10001001b = 11011001b
-11011000b | 10001010b = 11011010b
-11011000b | 10001011b = 11011011b
-11011000b | 10001100b = 11011100b
-11011000b | 10001101b = 11011101b
-11011000b | 10001110b = 11011110b
-11011000b | 10001111b = 11011111b
-11011000b | 10010000b = 11011000b
-11011000b | 10010001b = 11011001b
-11011000b | 10010010b = 11011010b
-11011000b | 10010011b = 11011011b
-11011000b | 10010100b = 11011100b
-11011000b | 10010101b = 11011101b
-11011000b | 10010110b = 11011110b
-11011000b | 10010111b = 11011111b
-11011000b | 10011000b = 11011000b
-11011000b | 10011001b = 11011001b
-11011000b | 10011010b = 11011010b
-11011000b | 10011011b = 11011011b
-11011000b | 10011100b = 11011100b
-11011000b | 10011101b = 11011101b
-11011000b | 10011110b = 11011110b
-11011000b | 10011111b = 11011111b
-11011000b | 10100000b = 11111000b
-11011000b | 10100001b = 11111001b
-11011000b | 10100010b = 11111010b
-11011000b | 10100011b = 11111011b
-11011000b | 10100100b = 11111100b
-11011000b | 10100101b = 11111101b
-11011000b | 10100110b = 11111110b
-11011000b | 10100111b = 11111111b
-11011000b | 10101000b = 11111000b
-11011000b | 10101001b = 11111001b
-11011000b | 10101010b = 11111010b
-11011000b | 10101011b = 11111011b
-11011000b | 10101100b = 11111100b
-11011000b | 10101101b = 11111101b
-11011000b | 10101110b = 11111110b
-11011000b | 10101111b = 11111111b
-11011000b | 10110000b = 11111000b
-11011000b | 10110001b = 11111001b
-11011000b | 10110010b = 11111010b
-11011000b | 10110011b = 11111011b
-11011000b | 10110100b = 11111100b
-11011000b | 10110101b = 11111101b
-11011000b | 10110110b = 11111110b
-11011000b | 10110111b = 11111111b
-11011000b | 10111000b = 11111000b
-11011000b | 10111001b = 11111001b
-11011000b | 10111010b = 11111010b
-11011000b | 10111011b = 11111011b
-11011000b | 10111100b = 11111100b
-11011000b | 10111101b = 11111101b
-11011000b | 10111110b = 11111110b
-11011000b | 10111111b = 11111111b
-11011000b | 11000000b = 11011000b
-11011000b | 11000001b = 11011001b
-11011000b | 11000010b = 11011010b
-11011000b | 11000011b = 11011011b
-11011000b | 11000100b = 11011100b
-11011000b | 11000101b = 11011101b
-11011000b | 11000110b = 11011110b
-11011000b | 11000111b = 11011111b
-11011000b | 11001000b = 11011000b
-11011000b | 11001001b = 11011001b
-11011000b | 11001010b = 11011010b
-11011000b | 11001011b = 11011011b
-11011000b | 11001100b = 11011100b
-11011000b | 11001101b = 11011101b
-11011000b | 11001110b = 11011110b
-11011000b | 11001111b = 11011111b
-11011000b | 11010000b = 11011000b
-11011000b | 11010001b = 11011001b
-11011000b | 11010010b = 11011010b
-11011000b | 11010011b = 11011011b
-11011000b | 11010100b = 11011100b
-11011000b | 11010101b = 11011101b
-11011000b | 11010110b = 11011110b
-11011000b | 11010111b = 11011111b
-11011000b | 11011000b = 11011000b
-11011000b | 11011001b = 11011001b
-11011000b | 11011010b = 11011010b
-11011000b | 11011011b = 11011011b
-11011000b | 11011100b = 11011100b
-11011000b | 11011101b = 11011101b
-11011000b | 11011110b = 11011110b
-11011000b | 11011111b = 11011111b
-11011000b | 11100000b = 11111000b
-11011000b | 11100001b = 11111001b
-11011000b | 11100010b = 11111010b
-11011000b | 11100011b = 11111011b
-11011000b | 11100100b = 11111100b
-11011000b | 11100101b = 11111101b
-11011000b | 11100110b = 11111110b
-11011000b | 11100111b = 11111111b
-11011000b | 11101000b = 11111000b
-11011000b | 11101001b = 11111001b
-11011000b | 11101010b = 11111010b
-11011000b | 11101011b = 11111011b
-11011000b | 11101100b = 11111100b
-11011000b | 11101101b = 11111101b
-11011000b | 11101110b = 11111110b
-11011000b | 11101111b = 11111111b
-11011000b | 11110000b = 11111000b
-11011000b | 11110001b = 11111001b
-11011000b | 11110010b = 11111010b
-11011000b | 11110011b = 11111011b
-11011000b | 11110100b = 11111100b
-11011000b | 11110101b = 11111101b
-11011000b | 11110110b = 11111110b
-11011000b | 11110111b = 11111111b
-11011000b | 11111000b = 11111000b
-11011000b | 11111001b = 11111001b
-11011000b | 11111010b = 11111010b
-11011000b | 11111011b = 11111011b
-11011000b | 11111100b = 11111100b
-11011000b | 11111101b = 11111101b
-11011000b | 11111110b = 11111110b
-11011000b | 11111111b = 11111111b
-11011000b | 00000000b = 11011000b
-11011000b | 00000001b = 11011001b
-11011000b | 00000010b = 11011010b
-11011000b | 00000011b = 11011011b
-11011000b | 00000100b = 11011100b
-11011000b | 00000101b = 11011101b
-11011000b | 00000110b = 11011110b
-11011000b | 00000111b = 11011111b
-11011000b | 00001000b = 11011000b
-11011000b | 00001001b = 11011001b
-11011000b | 00001010b = 11011010b
-11011000b | 00001011b = 11011011b
-11011000b | 00001100b = 11011100b
-11011000b | 00001101b = 11011101b
-11011000b | 00001110b = 11011110b
-11011000b | 00001111b = 11011111b
-11011000b | 00010000b = 11011000b
-11011000b | 00010001b = 11011001b
-11011000b | 00010010b = 11011010b
-11011000b | 00010011b = 11011011b
-11011000b | 00010100b = 11011100b
-11011000b | 00010101b = 11011101b
-11011000b | 00010110b = 11011110b
-11011000b | 00010111b = 11011111b
-11011000b | 00011000b = 11011000b
-11011000b | 00011001b = 11011001b
-11011000b | 00011010b = 11011010b
-11011000b | 00011011b = 11011011b
-11011000b | 00011100b = 11011100b
-11011000b | 00011101b = 11011101b
-11011000b | 00011110b = 11011110b
-11011000b | 00011111b = 11011111b
-11011000b | 00100000b = 11111000b
-11011000b | 00100001b = 11111001b
-11011000b | 00100010b = 11111010b
-11011000b | 00100011b = 11111011b
-11011000b | 00100100b = 11111100b
-11011000b | 00100101b = 11111101b
-11011000b | 00100110b = 11111110b
-11011000b | 00100111b = 11111111b
-11011000b | 00101000b = 11111000b
-11011000b | 00101001b = 11111001b
-11011000b | 00101010b = 11111010b
-11011000b | 00101011b = 11111011b
-11011000b | 00101100b = 11111100b
-11011000b | 00101101b = 11111101b
-11011000b | 00101110b = 11111110b
-11011000b | 00101111b = 11111111b
-11011000b | 00110000b = 11111000b
-11011000b | 00110001b = 11111001b
-11011000b | 00110010b = 11111010b
-11011000b | 00110011b = 11111011b
-11011000b | 00110100b = 11111100b
-11011000b | 00110101b = 11111101b
-11011000b | 00110110b = 11111110b
-11011000b | 00110111b = 11111111b
-11011000b | 00111000b = 11111000b
-11011000b | 00111001b = 11111001b
-11011000b | 00111010b = 11111010b
-11011000b | 00111011b = 11111011b
-11011000b | 00111100b = 11111100b
-11011000b | 00111101b = 11111101b
-11011000b | 00111110b = 11111110b
-11011000b | 00111111b = 11111111b
-11011000b | 01000000b = 11011000b
-11011000b | 01000001b = 11011001b
-11011000b | 01000010b = 11011010b
-11011000b | 01000011b = 11011011b
-11011000b | 01000100b = 11011100b
-11011000b | 01000101b = 11011101b
-11011000b | 01000110b = 11011110b
-11011000b | 01000111b = 11011111b
-11011000b | 01001000b = 11011000b
-11011000b | 01001001b = 11011001b
-11011000b | 01001010b = 11011010b
-11011000b | 01001011b = 11011011b
-11011000b | 01001100b = 11011100b
-11011000b | 01001101b = 11011101b
-11011000b | 01001110b = 11011110b
-11011000b | 01001111b = 11011111b
-11011000b | 01010000b = 11011000b
-11011000b | 01010001b = 11011001b
-11011000b | 01010010b = 11011010b
-11011000b | 01010011b = 11011011b
-11011000b | 01010100b = 11011100b
-11011000b | 01010101b = 11011101b
-11011000b | 01010110b = 11011110b
-11011000b | 01010111b = 11011111b
-11011000b | 01011000b = 11011000b
-11011000b | 01011001b = 11011001b
-11011000b | 01011010b = 11011010b
-11011000b | 01011011b = 11011011b
-11011000b | 01011100b = 11011100b
-11011000b | 01011101b = 11011101b
-11011000b | 01011110b = 11011110b
-11011000b | 01011111b = 11011111b
-11011000b | 01100000b = 11111000b
-11011000b | 01100001b = 11111001b
-11011000b | 01100010b = 11111010b
-11011000b | 01100011b = 11111011b
-11011000b | 01100100b = 11111100b
-11011000b | 01100101b = 11111101b
-11011000b | 01100110b = 11111110b
-11011000b | 01100111b = 11111111b
-11011000b | 01101000b = 11111000b
-11011000b | 01101001b = 11111001b
-11011000b | 01101010b = 11111010b
-11011000b | 01101011b = 11111011b
-11011000b | 01101100b = 11111100b
-11011000b | 01101101b = 11111101b
-11011000b | 01101110b = 11111110b
-11011000b | 01101111b = 11111111b
-11011000b | 01110000b = 11111000b
-11011000b | 01110001b = 11111001b
-11011000b | 01110010b = 11111010b
-11011000b | 01110011b = 11111011b
-11011000b | 01110100b = 11111100b
-11011000b | 01110101b = 11111101b
-11011000b | 01110110b = 11111110b
-11011000b | 01110111b = 11111111b
-11011000b | 01111000b = 11111000b
-11011000b | 01111001b = 11111001b
-11011000b | 01111010b = 11111010b
-11011000b | 01111011b = 11111011b
-11011000b | 01111100b = 11111100b
-11011000b | 01111101b = 11111101b
-11011000b | 01111110b = 11111110b
-11011001b | 10000000b = 11011001b
-11011001b | 10000001b = 11011001b
-11011001b | 10000010b = 11011011b
-11011001b | 10000011b = 11011011b
-11011001b | 10000100b = 11011101b
-11011001b | 10000101b = 11011101b
-11011001b | 10000110b = 11011111b
-11011001b | 10000111b = 11011111b
-11011001b | 10001000b = 11011001b
-11011001b | 10001001b = 11011001b
-11011001b | 10001010b = 11011011b
-11011001b | 10001011b = 11011011b
-11011001b | 10001100b = 11011101b
-11011001b | 10001101b = 11011101b
-11011001b | 10001110b = 11011111b
-11011001b | 10001111b = 11011111b
-11011001b | 10010000b = 11011001b
-11011001b | 10010001b = 11011001b
-11011001b | 10010010b = 11011011b
-11011001b | 10010011b = 11011011b
-11011001b | 10010100b = 11011101b
-11011001b | 10010101b = 11011101b
-11011001b | 10010110b = 11011111b
-11011001b | 10010111b = 11011111b
-11011001b | 10011000b = 11011001b
-11011001b | 10011001b = 11011001b
-11011001b | 10011010b = 11011011b
-11011001b | 10011011b = 11011011b
-11011001b | 10011100b = 11011101b
-11011001b | 10011101b = 11011101b
-11011001b | 10011110b = 11011111b
-11011001b | 10011111b = 11011111b
-11011001b | 10100000b = 11111001b
-11011001b | 10100001b = 11111001b
-11011001b | 10100010b = 11111011b
-11011001b | 10100011b = 11111011b
-11011001b | 10100100b = 11111101b
-11011001b | 10100101b = 11111101b
-11011001b | 10100110b = 11111111b
-11011001b | 10100111b = 11111111b
-11011001b | 10101000b = 11111001b
-11011001b | 10101001b = 11111001b
-11011001b | 10101010b = 11111011b
-11011001b | 10101011b = 11111011b
-11011001b | 10101100b = 11111101b
-11011001b | 10101101b = 11111101b
-11011001b | 10101110b = 11111111b
-11011001b | 10101111b = 11111111b
-11011001b | 10110000b = 11111001b
-11011001b | 10110001b = 11111001b
-11011001b | 10110010b = 11111011b
-11011001b | 10110011b = 11111011b
-11011001b | 10110100b = 11111101b
-11011001b | 10110101b = 11111101b
-11011001b | 10110110b = 11111111b
-11011001b | 10110111b = 11111111b
-11011001b | 10111000b = 11111001b
-11011001b | 10111001b = 11111001b
-11011001b | 10111010b = 11111011b
-11011001b | 10111011b = 11111011b
-11011001b | 10111100b = 11111101b
-11011001b | 10111101b = 11111101b
-11011001b | 10111110b = 11111111b
-11011001b | 10111111b = 11111111b
-11011001b | 11000000b = 11011001b
-11011001b | 11000001b = 11011001b
-11011001b | 11000010b = 11011011b
-11011001b | 11000011b = 11011011b
-11011001b | 11000100b = 11011101b
-11011001b | 11000101b = 11011101b
-11011001b | 11000110b = 11011111b
-11011001b | 11000111b = 11011111b
-11011001b | 11001000b = 11011001b
-11011001b | 11001001b = 11011001b
-11011001b | 11001010b = 11011011b
-11011001b | 11001011b = 11011011b
-11011001b | 11001100b = 11011101b
-11011001b | 11001101b = 11011101b
-11011001b | 11001110b = 11011111b
-11011001b | 11001111b = 11011111b
-11011001b | 11010000b = 11011001b
-11011001b | 11010001b = 11011001b
-11011001b | 11010010b = 11011011b
-11011001b | 11010011b = 11011011b
-11011001b | 11010100b = 11011101b
-11011001b | 11010101b = 11011101b
-11011001b | 11010110b = 11011111b
-11011001b | 11010111b = 11011111b
-11011001b | 11011000b = 11011001b
-11011001b | 11011001b = 11011001b
-11011001b | 11011010b = 11011011b
-11011001b | 11011011b = 11011011b
-11011001b | 11011100b = 11011101b
-11011001b | 11011101b = 11011101b
-11011001b | 11011110b = 11011111b
-11011001b | 11011111b = 11011111b
-11011001b | 11100000b = 11111001b
-11011001b | 11100001b = 11111001b
-11011001b | 11100010b = 11111011b
-11011001b | 11100011b = 11111011b
-11011001b | 11100100b = 11111101b
-11011001b | 11100101b = 11111101b
-11011001b | 11100110b = 11111111b
-11011001b | 11100111b = 11111111b
-11011001b | 11101000b = 11111001b
-11011001b | 11101001b = 11111001b
-11011001b | 11101010b = 11111011b
-11011001b | 11101011b = 11111011b
-11011001b | 11101100b = 11111101b
-11011001b | 11101101b = 11111101b
-11011001b | 11101110b = 11111111b
-11011001b | 11101111b = 11111111b
-11011001b | 11110000b = 11111001b
-11011001b | 11110001b = 11111001b
-11011001b | 11110010b = 11111011b
-11011001b | 11110011b = 11111011b
-11011001b | 11110100b = 11111101b
-11011001b | 11110101b = 11111101b
-11011001b | 11110110b = 11111111b
-11011001b | 11110111b = 11111111b
-11011001b | 11111000b = 11111001b
-11011001b | 11111001b = 11111001b
-11011001b | 11111010b = 11111011b
-11011001b | 11111011b = 11111011b
-11011001b | 11111100b = 11111101b
-11011001b | 11111101b = 11111101b
-11011001b | 11111110b = 11111111b
-11011001b | 11111111b = 11111111b
-11011001b | 00000000b = 11011001b
-11011001b | 00000001b = 11011001b
-11011001b | 00000010b = 11011011b
-11011001b | 00000011b = 11011011b
-11011001b | 00000100b = 11011101b
-11011001b | 00000101b = 11011101b
-11011001b | 00000110b = 11011111b
-11011001b | 00000111b = 11011111b
-11011001b | 00001000b = 11011001b
-11011001b | 00001001b = 11011001b
-11011001b | 00001010b = 11011011b
-11011001b | 00001011b = 11011011b
-11011001b | 00001100b = 11011101b
-11011001b | 00001101b = 11011101b
-11011001b | 00001110b = 11011111b
-11011001b | 00001111b = 11011111b
-11011001b | 00010000b = 11011001b
-11011001b | 00010001b = 11011001b
-11011001b | 00010010b = 11011011b
-11011001b | 00010011b = 11011011b
-11011001b | 00010100b = 11011101b
-11011001b | 00010101b = 11011101b
-11011001b | 00010110b = 11011111b
-11011001b | 00010111b = 11011111b
-11011001b | 00011000b = 11011001b
-11011001b | 00011001b = 11011001b
-11011001b | 00011010b = 11011011b
-11011001b | 00011011b = 11011011b
-11011001b | 00011100b = 11011101b
-11011001b | 00011101b = 11011101b
-11011001b | 00011110b = 11011111b
-11011001b | 00011111b = 11011111b
-11011001b | 00100000b = 11111001b
-11011001b | 00100001b = 11111001b
-11011001b | 00100010b = 11111011b
-11011001b | 00100011b = 11111011b
-11011001b | 00100100b = 11111101b
-11011001b | 00100101b = 11111101b
-11011001b | 00100110b = 11111111b
-11011001b | 00100111b = 11111111b
-11011001b | 00101000b = 11111001b
-11011001b | 00101001b = 11111001b
-11011001b | 00101010b = 11111011b
-11011001b | 00101011b = 11111011b
-11011001b | 00101100b = 11111101b
-11011001b | 00101101b = 11111101b
-11011001b | 00101110b = 11111111b
-11011001b | 00101111b = 11111111b
-11011001b | 00110000b = 11111001b
-11011001b | 00110001b = 11111001b
-11011001b | 00110010b = 11111011b
-11011001b | 00110011b = 11111011b
-11011001b | 00110100b = 11111101b
-11011001b | 00110101b = 11111101b
-11011001b | 00110110b = 11111111b
-11011001b | 00110111b = 11111111b
-11011001b | 00111000b = 11111001b
-11011001b | 00111001b = 11111001b
-11011001b | 00111010b = 11111011b
-11011001b | 00111011b = 11111011b
-11011001b | 00111100b = 11111101b
-11011001b | 00111101b = 11111101b
-11011001b | 00111110b = 11111111b
-11011001b | 00111111b = 11111111b
-11011001b | 01000000b = 11011001b
-11011001b | 01000001b = 11011001b
-11011001b | 01000010b = 11011011b
-11011001b | 01000011b = 11011011b
-11011001b | 01000100b = 11011101b
-11011001b | 01000101b = 11011101b
-11011001b | 01000110b = 11011111b
-11011001b | 01000111b = 11011111b
-11011001b | 01001000b = 11011001b
-11011001b | 01001001b = 11011001b
-11011001b | 01001010b = 11011011b
-11011001b | 01001011b = 11011011b
-11011001b | 01001100b = 11011101b
-11011001b | 01001101b = 11011101b
-11011001b | 01001110b = 11011111b
-11011001b | 01001111b = 11011111b
-11011001b | 01010000b = 11011001b
-11011001b | 01010001b = 11011001b
-11011001b | 01010010b = 11011011b
-11011001b | 01010011b = 11011011b
-11011001b | 01010100b = 11011101b
-11011001b | 01010101b = 11011101b
-11011001b | 01010110b = 11011111b
-11011001b | 01010111b = 11011111b
-11011001b | 01011000b = 11011001b
-11011001b | 01011001b = 11011001b
-11011001b | 01011010b = 11011011b
-11011001b | 01011011b = 11011011b
-11011001b | 01011100b = 11011101b
-11011001b | 01011101b = 11011101b
-11011001b | 01011110b = 11011111b
-11011001b | 01011111b = 11011111b
-11011001b | 01100000b = 11111001b
-11011001b | 01100001b = 11111001b
-11011001b | 01100010b = 11111011b
-11011001b | 01100011b = 11111011b
-11011001b | 01100100b = 11111101b
-11011001b | 01100101b = 11111101b
-11011001b | 01100110b = 11111111b
-11011001b | 01100111b = 11111111b
-11011001b | 01101000b = 11111001b
-11011001b | 01101001b = 11111001b
-11011001b | 01101010b = 11111011b
-11011001b | 01101011b = 11111011b
-11011001b | 01101100b = 11111101b
-11011001b | 01101101b = 11111101b
-11011001b | 01101110b = 11111111b
-11011001b | 01101111b = 11111111b
-11011001b | 01110000b = 11111001b
-11011001b | 01110001b = 11111001b
-11011001b | 01110010b = 11111011b
-11011001b | 01110011b = 11111011b
-11011001b | 01110100b = 11111101b
-11011001b | 01110101b = 11111101b
-11011001b | 01110110b = 11111111b
-11011001b | 01110111b = 11111111b
-11011001b | 01111000b = 11111001b
-11011001b | 01111001b = 11111001b
-11011001b | 01111010b = 11111011b
-11011001b | 01111011b = 11111011b
-11011001b | 01111100b = 11111101b
-11011001b | 01111101b = 11111101b
-11011001b | 01111110b = 11111111b
-11011010b | 10000000b = 11011010b
-11011010b | 10000001b = 11011011b
-11011010b | 10000010b = 11011010b
-11011010b | 10000011b = 11011011b
-11011010b | 10000100b = 11011110b
-11011010b | 10000101b = 11011111b
-11011010b | 10000110b = 11011110b
-11011010b | 10000111b = 11011111b
-11011010b | 10001000b = 11011010b
-11011010b | 10001001b = 11011011b
-11011010b | 10001010b = 11011010b
-11011010b | 10001011b = 11011011b
-11011010b | 10001100b = 11011110b
-11011010b | 10001101b = 11011111b
-11011010b | 10001110b = 11011110b
-11011010b | 10001111b = 11011111b
-11011010b | 10010000b = 11011010b
-11011010b | 10010001b = 11011011b
-11011010b | 10010010b = 11011010b
-11011010b | 10010011b = 11011011b
-11011010b | 10010100b = 11011110b
-11011010b | 10010101b = 11011111b
-11011010b | 10010110b = 11011110b
-11011010b | 10010111b = 11011111b
-11011010b | 10011000b = 11011010b
-11011010b | 10011001b = 11011011b
-11011010b | 10011010b = 11011010b
-11011010b | 10011011b = 11011011b
-11011010b | 10011100b = 11011110b
-11011010b | 10011101b = 11011111b
-11011010b | 10011110b = 11011110b
-11011010b | 10011111b = 11011111b
-11011010b | 10100000b = 11111010b
-11011010b | 10100001b = 11111011b
-11011010b | 10100010b = 11111010b
-11011010b | 10100011b = 11111011b
-11011010b | 10100100b = 11111110b
-11011010b | 10100101b = 11111111b
-11011010b | 10100110b = 11111110b
-11011010b | 10100111b = 11111111b
-11011010b | 10101000b = 11111010b
-11011010b | 10101001b = 11111011b
-11011010b | 10101010b = 11111010b
-11011010b | 10101011b = 11111011b
-11011010b | 10101100b = 11111110b
-11011010b | 10101101b = 11111111b
-11011010b | 10101110b = 11111110b
-11011010b | 10101111b = 11111111b
-11011010b | 10110000b = 11111010b
-11011010b | 10110001b = 11111011b
-11011010b | 10110010b = 11111010b
-11011010b | 10110011b = 11111011b
-11011010b | 10110100b = 11111110b
-11011010b | 10110101b = 11111111b
-11011010b | 10110110b = 11111110b
-11011010b | 10110111b = 11111111b
-11011010b | 10111000b = 11111010b
-11011010b | 10111001b = 11111011b
-11011010b | 10111010b = 11111010b
-11011010b | 10111011b = 11111011b
-11011010b | 10111100b = 11111110b
-11011010b | 10111101b = 11111111b
-11011010b | 10111110b = 11111110b
-11011010b | 10111111b = 11111111b
-11011010b | 11000000b = 11011010b
-11011010b | 11000001b = 11011011b
-11011010b | 11000010b = 11011010b
-11011010b | 11000011b = 11011011b
-11011010b | 11000100b = 11011110b
-11011010b | 11000101b = 11011111b
-11011010b | 11000110b = 11011110b
-11011010b | 11000111b = 11011111b
-11011010b | 11001000b = 11011010b
-11011010b | 11001001b = 11011011b
-11011010b | 11001010b = 11011010b
-11011010b | 11001011b = 11011011b
-11011010b | 11001100b = 11011110b
-11011010b | 11001101b = 11011111b
-11011010b | 11001110b = 11011110b
-11011010b | 11001111b = 11011111b
-11011010b | 11010000b = 11011010b
-11011010b | 11010001b = 11011011b
-11011010b | 11010010b = 11011010b
-11011010b | 11010011b = 11011011b
-11011010b | 11010100b = 11011110b
-11011010b | 11010101b = 11011111b
-11011010b | 11010110b = 11011110b
-11011010b | 11010111b = 11011111b
-11011010b | 11011000b = 11011010b
-11011010b | 11011001b = 11011011b
-11011010b | 11011010b = 11011010b
-11011010b | 11011011b = 11011011b
-11011010b | 11011100b = 11011110b
-11011010b | 11011101b = 11011111b
-11011010b | 11011110b = 11011110b
-11011010b | 11011111b = 11011111b
-11011010b | 11100000b = 11111010b
-11011010b | 11100001b = 11111011b
-11011010b | 11100010b = 11111010b
-11011010b | 11100011b = 11111011b
-11011010b | 11100100b = 11111110b
-11011010b | 11100101b = 11111111b
-11011010b | 11100110b = 11111110b
-11011010b | 11100111b = 11111111b
-11011010b | 11101000b = 11111010b
-11011010b | 11101001b = 11111011b
-11011010b | 11101010b = 11111010b
-11011010b | 11101011b = 11111011b
-11011010b | 11101100b = 11111110b
-11011010b | 11101101b = 11111111b
-11011010b | 11101110b = 11111110b
-11011010b | 11101111b = 11111111b
-11011010b | 11110000b = 11111010b
-11011010b | 11110001b = 11111011b
-11011010b | 11110010b = 11111010b
-11011010b | 11110011b = 11111011b
-11011010b | 11110100b = 11111110b
-11011010b | 11110101b = 11111111b
-11011010b | 11110110b = 11111110b
-11011010b | 11110111b = 11111111b
-11011010b | 11111000b = 11111010b
-11011010b | 11111001b = 11111011b
-11011010b | 11111010b = 11111010b
-11011010b | 11111011b = 11111011b
-11011010b | 11111100b = 11111110b
-11011010b | 11111101b = 11111111b
-11011010b | 11111110b = 11111110b
-11011010b | 11111111b = 11111111b
-11011010b | 00000000b = 11011010b
-11011010b | 00000001b = 11011011b
-11011010b | 00000010b = 11011010b
-11011010b | 00000011b = 11011011b
-11011010b | 00000100b = 11011110b
-11011010b | 00000101b = 11011111b
-11011010b | 00000110b = 11011110b
-11011010b | 00000111b = 11011111b
-11011010b | 00001000b = 11011010b
-11011010b | 00001001b = 11011011b
-11011010b | 00001010b = 11011010b
-11011010b | 00001011b = 11011011b
-11011010b | 00001100b = 11011110b
-11011010b | 00001101b = 11011111b
-11011010b | 00001110b = 11011110b
-11011010b | 00001111b = 11011111b
-11011010b | 00010000b = 11011010b
-11011010b | 00010001b = 11011011b
-11011010b | 00010010b = 11011010b
-11011010b | 00010011b = 11011011b
-11011010b | 00010100b = 11011110b
-11011010b | 00010101b = 11011111b
-11011010b | 00010110b = 11011110b
-11011010b | 00010111b = 11011111b
-11011010b | 00011000b = 11011010b
-11011010b | 00011001b = 11011011b
-11011010b | 00011010b = 11011010b
-11011010b | 00011011b = 11011011b
-11011010b | 00011100b = 11011110b
-11011010b | 00011101b = 11011111b
-11011010b | 00011110b = 11011110b
-11011010b | 00011111b = 11011111b
-11011010b | 00100000b = 11111010b
-11011010b | 00100001b = 11111011b
-11011010b | 00100010b = 11111010b
-11011010b | 00100011b = 11111011b
-11011010b | 00100100b = 11111110b
-11011010b | 00100101b = 11111111b
-11011010b | 00100110b = 11111110b
-11011010b | 00100111b = 11111111b
-11011010b | 00101000b = 11111010b
-11011010b | 00101001b = 11111011b
-11011010b | 00101010b = 11111010b
-11011010b | 00101011b = 11111011b
-11011010b | 00101100b = 11111110b
-11011010b | 00101101b = 11111111b
-11011010b | 00101110b = 11111110b
-11011010b | 00101111b = 11111111b
-11011010b | 00110000b = 11111010b
-11011010b | 00110001b = 11111011b
-11011010b | 00110010b = 11111010b
-11011010b | 00110011b = 11111011b
-11011010b | 00110100b = 11111110b
-11011010b | 00110101b = 11111111b
-11011010b | 00110110b = 11111110b
-11011010b | 00110111b = 11111111b
-11011010b | 00111000b = 11111010b
-11011010b | 00111001b = 11111011b
-11011010b | 00111010b = 11111010b
-11011010b | 00111011b = 11111011b
-11011010b | 00111100b = 11111110b
-11011010b | 00111101b = 11111111b
-11011010b | 00111110b = 11111110b
-11011010b | 00111111b = 11111111b
-11011010b | 01000000b = 11011010b
-11011010b | 01000001b = 11011011b
-11011010b | 01000010b = 11011010b
-11011010b | 01000011b = 11011011b
-11011010b | 01000100b = 11011110b
-11011010b | 01000101b = 11011111b
-11011010b | 01000110b = 11011110b
-11011010b | 01000111b = 11011111b
-11011010b | 01001000b = 11011010b
-11011010b | 01001001b = 11011011b
-11011010b | 01001010b = 11011010b
-11011010b | 01001011b = 11011011b
-11011010b | 01001100b = 11011110b
-11011010b | 01001101b = 11011111b
-11011010b | 01001110b = 11011110b
-11011010b | 01001111b = 11011111b
-11011010b | 01010000b = 11011010b
-11011010b | 01010001b = 11011011b
-11011010b | 01010010b = 11011010b
-11011010b | 01010011b = 11011011b
-11011010b | 01010100b = 11011110b
-11011010b | 01010101b = 11011111b
-11011010b | 01010110b = 11011110b
-11011010b | 01010111b = 11011111b
-11011010b | 01011000b = 11011010b
-11011010b | 01011001b = 11011011b
-11011010b | 01011010b = 11011010b
-11011010b | 01011011b = 11011011b
-11011010b | 01011100b = 11011110b
-11011010b | 01011101b = 11011111b
-11011010b | 01011110b = 11011110b
-11011010b | 01011111b = 11011111b
-11011010b | 01100000b = 11111010b
-11011010b | 01100001b = 11111011b
-11011010b | 01100010b = 11111010b
-11011010b | 01100011b = 11111011b
-11011010b | 01100100b = 11111110b
-11011010b | 01100101b = 11111111b
-11011010b | 01100110b = 11111110b
-11011010b | 01100111b = 11111111b
-11011010b | 01101000b = 11111010b
-11011010b | 01101001b = 11111011b
-11011010b | 01101010b = 11111010b
-11011010b | 01101011b = 11111011b
-11011010b | 01101100b = 11111110b
-11011010b | 01101101b = 11111111b
-11011010b | 01101110b = 11111110b
-11011010b | 01101111b = 11111111b
-11011010b | 01110000b = 11111010b
-11011010b | 01110001b = 11111011b
-11011010b | 01110010b = 11111010b
-11011010b | 01110011b = 11111011b
-11011010b | 01110100b = 11111110b
-11011010b | 01110101b = 11111111b
-11011010b | 01110110b = 11111110b
-11011010b | 01110111b = 11111111b
-11011010b | 01111000b = 11111010b
-11011010b | 01111001b = 11111011b
-11011010b | 01111010b = 11111010b
-11011010b | 01111011b = 11111011b
-11011010b | 01111100b = 11111110b
-11011010b | 01111101b = 11111111b
-11011010b | 01111110b = 11111110b
-11011011b | 10000000b = 11011011b
-11011011b | 10000001b = 11011011b
-11011011b | 10000010b = 11011011b
-11011011b | 10000011b = 11011011b
-11011011b | 10000100b = 11011111b
-11011011b | 10000101b = 11011111b
-11011011b | 10000110b = 11011111b
-11011011b | 10000111b = 11011111b
-11011011b | 10001000b = 11011011b
-11011011b | 10001001b = 11011011b
-11011011b | 10001010b = 11011011b
-11011011b | 10001011b = 11011011b
-11011011b | 10001100b = 11011111b
-11011011b | 10001101b = 11011111b
-11011011b | 10001110b = 11011111b
-11011011b | 10001111b = 11011111b
-11011011b | 10010000b = 11011011b
-11011011b | 10010001b = 11011011b
-11011011b | 10010010b = 11011011b
-11011011b | 10010011b = 11011011b
-11011011b | 10010100b = 11011111b
-11011011b | 10010101b = 11011111b
-11011011b | 10010110b = 11011111b
-11011011b | 10010111b = 11011111b
-11011011b | 10011000b = 11011011b
-11011011b | 10011001b = 11011011b
-11011011b | 10011010b = 11011011b
-11011011b | 10011011b = 11011011b
-11011011b | 10011100b = 11011111b
-11011011b | 10011101b = 11011111b
-11011011b | 10011110b = 11011111b
-11011011b | 10011111b = 11011111b
-11011011b | 10100000b = 11111011b
-11011011b | 10100001b = 11111011b
-11011011b | 10100010b = 11111011b
-11011011b | 10100011b = 11111011b
-11011011b | 10100100b = 11111111b
-11011011b | 10100101b = 11111111b
-11011011b | 10100110b = 11111111b
-11011011b | 10100111b = 11111111b
-11011011b | 10101000b = 11111011b
-11011011b | 10101001b = 11111011b
-11011011b | 10101010b = 11111011b
-11011011b | 10101011b = 11111011b
-11011011b | 10101100b = 11111111b
-11011011b | 10101101b = 11111111b
-11011011b | 10101110b = 11111111b
-11011011b | 10101111b = 11111111b
-11011011b | 10110000b = 11111011b
-11011011b | 10110001b = 11111011b
-11011011b | 10110010b = 11111011b
-11011011b | 10110011b = 11111011b
-11011011b | 10110100b = 11111111b
-11011011b | 10110101b = 11111111b
-11011011b | 10110110b = 11111111b
-11011011b | 10110111b = 11111111b
-11011011b | 10111000b = 11111011b
-11011011b | 10111001b = 11111011b
-11011011b | 10111010b = 11111011b
-11011011b | 10111011b = 11111011b
-11011011b | 10111100b = 11111111b
-11011011b | 10111101b = 11111111b
-11011011b | 10111110b = 11111111b
-11011011b | 10111111b = 11111111b
-11011011b | 11000000b = 11011011b
-11011011b | 11000001b = 11011011b
-11011011b | 11000010b = 11011011b
-11011011b | 11000011b = 11011011b
-11011011b | 11000100b = 11011111b
-11011011b | 11000101b = 11011111b
-11011011b | 11000110b = 11011111b
-11011011b | 11000111b = 11011111b
-11011011b | 11001000b = 11011011b
-11011011b | 11001001b = 11011011b
-11011011b | 11001010b = 11011011b
-11011011b | 11001011b = 11011011b
-11011011b | 11001100b = 11011111b
-11011011b | 11001101b = 11011111b
-11011011b | 11001110b = 11011111b
-11011011b | 11001111b = 11011111b
-11011011b | 11010000b = 11011011b
-11011011b | 11010001b = 11011011b
-11011011b | 11010010b = 11011011b
-11011011b | 11010011b = 11011011b
-11011011b | 11010100b = 11011111b
-11011011b | 11010101b = 11011111b
-11011011b | 11010110b = 11011111b
-11011011b | 11010111b = 11011111b
-11011011b | 11011000b = 11011011b
-11011011b | 11011001b = 11011011b
-11011011b | 11011010b = 11011011b
-11011011b | 11011011b = 11011011b
-11011011b | 11011100b = 11011111b
-11011011b | 11011101b = 11011111b
-11011011b | 11011110b = 11011111b
-11011011b | 11011111b = 11011111b
-11011011b | 11100000b = 11111011b
-11011011b | 11100001b = 11111011b
-11011011b | 11100010b = 11111011b
-11011011b | 11100011b = 11111011b
-11011011b | 11100100b = 11111111b
-11011011b | 11100101b = 11111111b
-11011011b | 11100110b = 11111111b
-11011011b | 11100111b = 11111111b
-11011011b | 11101000b = 11111011b
-11011011b | 11101001b = 11111011b
-11011011b | 11101010b = 11111011b
-11011011b | 11101011b = 11111011b
-11011011b | 11101100b = 11111111b
-11011011b | 11101101b = 11111111b
-11011011b | 11101110b = 11111111b
-11011011b | 11101111b = 11111111b
-11011011b | 11110000b = 11111011b
-11011011b | 11110001b = 11111011b
-11011011b | 11110010b = 11111011b
-11011011b | 11110011b = 11111011b
-11011011b | 11110100b = 11111111b
-11011011b | 11110101b = 11111111b
-11011011b | 11110110b = 11111111b
-11011011b | 11110111b = 11111111b
-11011011b | 11111000b = 11111011b
-11011011b | 11111001b = 11111011b
-11011011b | 11111010b = 11111011b
-11011011b | 11111011b = 11111011b
-11011011b | 11111100b = 11111111b
-11011011b | 11111101b = 11111111b
-11011011b | 11111110b = 11111111b
-11011011b | 11111111b = 11111111b
-11011011b | 00000000b = 11011011b
-11011011b | 00000001b = 11011011b
-11011011b | 00000010b = 11011011b
-11011011b | 00000011b = 11011011b
-11011011b | 00000100b = 11011111b
-11011011b | 00000101b = 11011111b
-11011011b | 00000110b = 11011111b
-11011011b | 00000111b = 11011111b
-11011011b | 00001000b = 11011011b
-11011011b | 00001001b = 11011011b
-11011011b | 00001010b = 11011011b
-11011011b | 00001011b = 11011011b
-11011011b | 00001100b = 11011111b
-11011011b | 00001101b = 11011111b
-11011011b | 00001110b = 11011111b
-11011011b | 00001111b = 11011111b
-11011011b | 00010000b = 11011011b
-11011011b | 00010001b = 11011011b
-11011011b | 00010010b = 11011011b
-11011011b | 00010011b = 11011011b
-11011011b | 00010100b = 11011111b
-11011011b | 00010101b = 11011111b
-11011011b | 00010110b = 11011111b
-11011011b | 00010111b = 11011111b
-11011011b | 00011000b = 11011011b
-11011011b | 00011001b = 11011011b
-11011011b | 00011010b = 11011011b
-11011011b | 00011011b = 11011011b
-11011011b | 00011100b = 11011111b
-11011011b | 00011101b = 11011111b
-11011011b | 00011110b = 11011111b
-11011011b | 00011111b = 11011111b
-11011011b | 00100000b = 11111011b
-11011011b | 00100001b = 11111011b
-11011011b | 00100010b = 11111011b
-11011011b | 00100011b = 11111011b
-11011011b | 00100100b = 11111111b
-11011011b | 00100101b = 11111111b
-11011011b | 00100110b = 11111111b
-11011011b | 00100111b = 11111111b
-11011011b | 00101000b = 11111011b
-11011011b | 00101001b = 11111011b
-11011011b | 00101010b = 11111011b
-11011011b | 00101011b = 11111011b
-11011011b | 00101100b = 11111111b
-11011011b | 00101101b = 11111111b
-11011011b | 00101110b = 11111111b
-11011011b | 00101111b = 11111111b
-11011011b | 00110000b = 11111011b
-11011011b | 00110001b = 11111011b
-11011011b | 00110010b = 11111011b
-11011011b | 00110011b = 11111011b
-11011011b | 00110100b = 11111111b
-11011011b | 00110101b = 11111111b
-11011011b | 00110110b = 11111111b
-11011011b | 00110111b = 11111111b
-11011011b | 00111000b = 11111011b
-11011011b | 00111001b = 11111011b
-11011011b | 00111010b = 11111011b
-11011011b | 00111011b = 11111011b
-11011011b | 00111100b = 11111111b
-11011011b | 00111101b = 11111111b
-11011011b | 00111110b = 11111111b
-11011011b | 00111111b = 11111111b
-11011011b | 01000000b = 11011011b
-11011011b | 01000001b = 11011011b
-11011011b | 01000010b = 11011011b
-11011011b | 01000011b = 11011011b
-11011011b | 01000100b = 11011111b
-11011011b | 01000101b = 11011111b
-11011011b | 01000110b = 11011111b
-11011011b | 01000111b = 11011111b
-11011011b | 01001000b = 11011011b
-11011011b | 01001001b = 11011011b
-11011011b | 01001010b = 11011011b
-11011011b | 01001011b = 11011011b
-11011011b | 01001100b = 11011111b
-11011011b | 01001101b = 11011111b
-11011011b | 01001110b = 11011111b
-11011011b | 01001111b = 11011111b
-11011011b | 01010000b = 11011011b
-11011011b | 01010001b = 11011011b
-11011011b | 01010010b = 11011011b
-11011011b | 01010011b = 11011011b
-11011011b | 01010100b = 11011111b
-11011011b | 01010101b = 11011111b
-11011011b | 01010110b = 11011111b
-11011011b | 01010111b = 11011111b
-11011011b | 01011000b = 11011011b
-11011011b | 01011001b = 11011011b
-11011011b | 01011010b = 11011011b
-11011011b | 01011011b = 11011011b
-11011011b | 01011100b = 11011111b
-11011011b | 01011101b = 11011111b
-11011011b | 01011110b = 11011111b
-11011011b | 01011111b = 11011111b
-11011011b | 01100000b = 11111011b
-11011011b | 01100001b = 11111011b
-11011011b | 01100010b = 11111011b
-11011011b | 01100011b = 11111011b
-11011011b | 01100100b = 11111111b
-11011011b | 01100101b = 11111111b
-11011011b | 01100110b = 11111111b
-11011011b | 01100111b = 11111111b
-11011011b | 01101000b = 11111011b
-11011011b | 01101001b = 11111011b
-11011011b | 01101010b = 11111011b
-11011011b | 01101011b = 11111011b
-11011011b | 01101100b = 11111111b
-11011011b | 01101101b = 11111111b
-11011011b | 01101110b = 11111111b
-11011011b | 01101111b = 11111111b
-11011011b | 01110000b = 11111011b
-11011011b | 01110001b = 11111011b
-11011011b | 01110010b = 11111011b
-11011011b | 01110011b = 11111011b
-11011011b | 01110100b = 11111111b
-11011011b | 01110101b = 11111111b
-11011011b | 01110110b = 11111111b
-11011011b | 01110111b = 11111111b
-11011011b | 01111000b = 11111011b
-11011011b | 01111001b = 11111011b
-11011011b | 01111010b = 11111011b
-11011011b | 01111011b = 11111011b
-11011011b | 01111100b = 11111111b
-11011011b | 01111101b = 11111111b
-11011011b | 01111110b = 11111111b
-11011100b | 10000000b = 11011100b
-11011100b | 10000001b = 11011101b
-11011100b | 10000010b = 11011110b
-11011100b | 10000011b = 11011111b
-11011100b | 10000100b = 11011100b
-11011100b | 10000101b = 11011101b
-11011100b | 10000110b = 11011110b
-11011100b | 10000111b = 11011111b
-11011100b | 10001000b = 11011100b
-11011100b | 10001001b = 11011101b
-11011100b | 10001010b = 11011110b
-11011100b | 10001011b = 11011111b
-11011100b | 10001100b = 11011100b
-11011100b | 10001101b = 11011101b
-11011100b | 10001110b = 11011110b
-11011100b | 10001111b = 11011111b
-11011100b | 10010000b = 11011100b
-11011100b | 10010001b = 11011101b
-11011100b | 10010010b = 11011110b
-11011100b | 10010011b = 11011111b
-11011100b | 10010100b = 11011100b
-11011100b | 10010101b = 11011101b
-11011100b | 10010110b = 11011110b
-11011100b | 10010111b = 11011111b
-11011100b | 10011000b = 11011100b
-11011100b | 10011001b = 11011101b
-11011100b | 10011010b = 11011110b
-11011100b | 10011011b = 11011111b
-11011100b | 10011100b = 11011100b
-11011100b | 10011101b = 11011101b
-11011100b | 10011110b = 11011110b
-11011100b | 10011111b = 11011111b
-11011100b | 10100000b = 11111100b
-11011100b | 10100001b = 11111101b
-11011100b | 10100010b = 11111110b
-11011100b | 10100011b = 11111111b
-11011100b | 10100100b = 11111100b
-11011100b | 10100101b = 11111101b
-11011100b | 10100110b = 11111110b
-11011100b | 10100111b = 11111111b
-11011100b | 10101000b = 11111100b
-11011100b | 10101001b = 11111101b
-11011100b | 10101010b = 11111110b
-11011100b | 10101011b = 11111111b
-11011100b | 10101100b = 11111100b
-11011100b | 10101101b = 11111101b
-11011100b | 10101110b = 11111110b
-11011100b | 10101111b = 11111111b
-11011100b | 10110000b = 11111100b
-11011100b | 10110001b = 11111101b
-11011100b | 10110010b = 11111110b
-11011100b | 10110011b = 11111111b
-11011100b | 10110100b = 11111100b
-11011100b | 10110101b = 11111101b
-11011100b | 10110110b = 11111110b
-11011100b | 10110111b = 11111111b
-11011100b | 10111000b = 11111100b
-11011100b | 10111001b = 11111101b
-11011100b | 10111010b = 11111110b
-11011100b | 10111011b = 11111111b
-11011100b | 10111100b = 11111100b
-11011100b | 10111101b = 11111101b
-11011100b | 10111110b = 11111110b
-11011100b | 10111111b = 11111111b
-11011100b | 11000000b = 11011100b
-11011100b | 11000001b = 11011101b
-11011100b | 11000010b = 11011110b
-11011100b | 11000011b = 11011111b
-11011100b | 11000100b = 11011100b
-11011100b | 11000101b = 11011101b
-11011100b | 11000110b = 11011110b
-11011100b | 11000111b = 11011111b
-11011100b | 11001000b = 11011100b
-11011100b | 11001001b = 11011101b
-11011100b | 11001010b = 11011110b
-11011100b | 11001011b = 11011111b
-11011100b | 11001100b = 11011100b
-11011100b | 11001101b = 11011101b
-11011100b | 11001110b = 11011110b
-11011100b | 11001111b = 11011111b
-11011100b | 11010000b = 11011100b
-11011100b | 11010001b = 11011101b
-11011100b | 11010010b = 11011110b
-11011100b | 11010011b = 11011111b
-11011100b | 11010100b = 11011100b
-11011100b | 11010101b = 11011101b
-11011100b | 11010110b = 11011110b
-11011100b | 11010111b = 11011111b
-11011100b | 11011000b = 11011100b
-11011100b | 11011001b = 11011101b
-11011100b | 11011010b = 11011110b
-11011100b | 11011011b = 11011111b
-11011100b | 11011100b = 11011100b
-11011100b | 11011101b = 11011101b
-11011100b | 11011110b = 11011110b
-11011100b | 11011111b = 11011111b
-11011100b | 11100000b = 11111100b
-11011100b | 11100001b = 11111101b
-11011100b | 11100010b = 11111110b
-11011100b | 11100011b = 11111111b
-11011100b | 11100100b = 11111100b
-11011100b | 11100101b = 11111101b
-11011100b | 11100110b = 11111110b
-11011100b | 11100111b = 11111111b
-11011100b | 11101000b = 11111100b
-11011100b | 11101001b = 11111101b
-11011100b | 11101010b = 11111110b
-11011100b | 11101011b = 11111111b
-11011100b | 11101100b = 11111100b
-11011100b | 11101101b = 11111101b
-11011100b | 11101110b = 11111110b
-11011100b | 11101111b = 11111111b
-11011100b | 11110000b = 11111100b
-11011100b | 11110001b = 11111101b
-11011100b | 11110010b = 11111110b
-11011100b | 11110011b = 11111111b
-11011100b | 11110100b = 11111100b
-11011100b | 11110101b = 11111101b
-11011100b | 11110110b = 11111110b
-11011100b | 11110111b = 11111111b
-11011100b | 11111000b = 11111100b
-11011100b | 11111001b = 11111101b
-11011100b | 11111010b = 11111110b
-11011100b | 11111011b = 11111111b
-11011100b | 11111100b = 11111100b
-11011100b | 11111101b = 11111101b
-11011100b | 11111110b = 11111110b
-11011100b | 11111111b = 11111111b
-11011100b | 00000000b = 11011100b
-11011100b | 00000001b = 11011101b
-11011100b | 00000010b = 11011110b
-11011100b | 00000011b = 11011111b
-11011100b | 00000100b = 11011100b
-11011100b | 00000101b = 11011101b
-11011100b | 00000110b = 11011110b
-11011100b | 00000111b = 11011111b
-11011100b | 00001000b = 11011100b
-11011100b | 00001001b = 11011101b
-11011100b | 00001010b = 11011110b
-11011100b | 00001011b = 11011111b
-11011100b | 00001100b = 11011100b
-11011100b | 00001101b = 11011101b
-11011100b | 00001110b = 11011110b
-11011100b | 00001111b = 11011111b
-11011100b | 00010000b = 11011100b
-11011100b | 00010001b = 11011101b
-11011100b | 00010010b = 11011110b
-11011100b | 00010011b = 11011111b
-11011100b | 00010100b = 11011100b
-11011100b | 00010101b = 11011101b
-11011100b | 00010110b = 11011110b
-11011100b | 00010111b = 11011111b
-11011100b | 00011000b = 11011100b
-11011100b | 00011001b = 11011101b
-11011100b | 00011010b = 11011110b
-11011100b | 00011011b = 11011111b
-11011100b | 00011100b = 11011100b
-11011100b | 00011101b = 11011101b
-11011100b | 00011110b = 11011110b
-11011100b | 00011111b = 11011111b
-11011100b | 00100000b = 11111100b
-11011100b | 00100001b = 11111101b
-11011100b | 00100010b = 11111110b
-11011100b | 00100011b = 11111111b
-11011100b | 00100100b = 11111100b
-11011100b | 00100101b = 11111101b
-11011100b | 00100110b = 11111110b
-11011100b | 00100111b = 11111111b
-11011100b | 00101000b = 11111100b
-11011100b | 00101001b = 11111101b
-11011100b | 00101010b = 11111110b
-11011100b | 00101011b = 11111111b
-11011100b | 00101100b = 11111100b
-11011100b | 00101101b = 11111101b
-11011100b | 00101110b = 11111110b
-11011100b | 00101111b = 11111111b
-11011100b | 00110000b = 11111100b
-11011100b | 00110001b = 11111101b
-11011100b | 00110010b = 11111110b
-11011100b | 00110011b = 11111111b
-11011100b | 00110100b = 11111100b
-11011100b | 00110101b = 11111101b
-11011100b | 00110110b = 11111110b
-11011100b | 00110111b = 11111111b
-11011100b | 00111000b = 11111100b
-11011100b | 00111001b = 11111101b
-11011100b | 00111010b = 11111110b
-11011100b | 00111011b = 11111111b
-11011100b | 00111100b = 11111100b
-11011100b | 00111101b = 11111101b
-11011100b | 00111110b = 11111110b
-11011100b | 00111111b = 11111111b
-11011100b | 01000000b = 11011100b
-11011100b | 01000001b = 11011101b
-11011100b | 01000010b = 11011110b
-11011100b | 01000011b = 11011111b
-11011100b | 01000100b = 11011100b
-11011100b | 01000101b = 11011101b
-11011100b | 01000110b = 11011110b
-11011100b | 01000111b = 11011111b
-11011100b | 01001000b = 11011100b
-11011100b | 01001001b = 11011101b
-11011100b | 01001010b = 11011110b
-11011100b | 01001011b = 11011111b
-11011100b | 01001100b = 11011100b
-11011100b | 01001101b = 11011101b
-11011100b | 01001110b = 11011110b
-11011100b | 01001111b = 11011111b
-11011100b | 01010000b = 11011100b
-11011100b | 01010001b = 11011101b
-11011100b | 01010010b = 11011110b
-11011100b | 01010011b = 11011111b
-11011100b | 01010100b = 11011100b
-11011100b | 01010101b = 11011101b
-11011100b | 01010110b = 11011110b
-11011100b | 01010111b = 11011111b
-11011100b | 01011000b = 11011100b
-11011100b | 01011001b = 11011101b
-11011100b | 01011010b = 11011110b
-11011100b | 01011011b = 11011111b
-11011100b | 01011100b = 11011100b
-11011100b | 01011101b = 11011101b
-11011100b | 01011110b = 11011110b
-11011100b | 01011111b = 11011111b
-11011100b | 01100000b = 11111100b
-11011100b | 01100001b = 11111101b
-11011100b | 01100010b = 11111110b
-11011100b | 01100011b = 11111111b
-11011100b | 01100100b = 11111100b
-11011100b | 01100101b = 11111101b
-11011100b | 01100110b = 11111110b
-11011100b | 01100111b = 11111111b
-11011100b | 01101000b = 11111100b
-11011100b | 01101001b = 11111101b
-11011100b | 01101010b = 11111110b
-11011100b | 01101011b = 11111111b
-11011100b | 01101100b = 11111100b
-11011100b | 01101101b = 11111101b
-11011100b | 01101110b = 11111110b
-11011100b | 01101111b = 11111111b
-11011100b | 01110000b = 11111100b
-11011100b | 01110001b = 11111101b
-11011100b | 01110010b = 11111110b
-11011100b | 01110011b = 11111111b
-11011100b | 01110100b = 11111100b
-11011100b | 01110101b = 11111101b
-11011100b | 01110110b = 11111110b
-11011100b | 01110111b = 11111111b
-11011100b | 01111000b = 11111100b
-11011100b | 01111001b = 11111101b
-11011100b | 01111010b = 11111110b
-11011100b | 01111011b = 11111111b
-11011100b | 01111100b = 11111100b
-11011100b | 01111101b = 11111101b
-11011100b | 01111110b = 11111110b
-11011101b | 10000000b = 11011101b
-11011101b | 10000001b = 11011101b
-11011101b | 10000010b = 11011111b
-11011101b | 10000011b = 11011111b
-11011101b | 10000100b = 11011101b
-11011101b | 10000101b = 11011101b
-11011101b | 10000110b = 11011111b
-11011101b | 10000111b = 11011111b
-11011101b | 10001000b = 11011101b
-11011101b | 10001001b = 11011101b
-11011101b | 10001010b = 11011111b
-11011101b | 10001011b = 11011111b
-11011101b | 10001100b = 11011101b
-11011101b | 10001101b = 11011101b
-11011101b | 10001110b = 11011111b
-11011101b | 10001111b = 11011111b
-11011101b | 10010000b = 11011101b
-11011101b | 10010001b = 11011101b
-11011101b | 10010010b = 11011111b
-11011101b | 10010011b = 11011111b
-11011101b | 10010100b = 11011101b
-11011101b | 10010101b = 11011101b
-11011101b | 10010110b = 11011111b
-11011101b | 10010111b = 11011111b
-11011101b | 10011000b = 11011101b
-11011101b | 10011001b = 11011101b
-11011101b | 10011010b = 11011111b
-11011101b | 10011011b = 11011111b
-11011101b | 10011100b = 11011101b
-11011101b | 10011101b = 11011101b
-11011101b | 10011110b = 11011111b
-11011101b | 10011111b = 11011111b
-11011101b | 10100000b = 11111101b
-11011101b | 10100001b = 11111101b
-11011101b | 10100010b = 11111111b
-11011101b | 10100011b = 11111111b
-11011101b | 10100100b = 11111101b
-11011101b | 10100101b = 11111101b
-11011101b | 10100110b = 11111111b
-11011101b | 10100111b = 11111111b
-11011101b | 10101000b = 11111101b
-11011101b | 10101001b = 11111101b
-11011101b | 10101010b = 11111111b
-11011101b | 10101011b = 11111111b
-11011101b | 10101100b = 11111101b
-11011101b | 10101101b = 11111101b
-11011101b | 10101110b = 11111111b
-11011101b | 10101111b = 11111111b
-11011101b | 10110000b = 11111101b
-11011101b | 10110001b = 11111101b
-11011101b | 10110010b = 11111111b
-11011101b | 10110011b = 11111111b
-11011101b | 10110100b = 11111101b
-11011101b | 10110101b = 11111101b
-11011101b | 10110110b = 11111111b
-11011101b | 10110111b = 11111111b
-11011101b | 10111000b = 11111101b
-11011101b | 10111001b = 11111101b
-11011101b | 10111010b = 11111111b
-11011101b | 10111011b = 11111111b
-11011101b | 10111100b = 11111101b
-11011101b | 10111101b = 11111101b
-11011101b | 10111110b = 11111111b
-11011101b | 10111111b = 11111111b
-11011101b | 11000000b = 11011101b
-11011101b | 11000001b = 11011101b
-11011101b | 11000010b = 11011111b
-11011101b | 11000011b = 11011111b
-11011101b | 11000100b = 11011101b
-11011101b | 11000101b = 11011101b
-11011101b | 11000110b = 11011111b
-11011101b | 11000111b = 11011111b
-11011101b | 11001000b = 11011101b
-11011101b | 11001001b = 11011101b
-11011101b | 11001010b = 11011111b
-11011101b | 11001011b = 11011111b
-11011101b | 11001100b = 11011101b
-11011101b | 11001101b = 11011101b
-11011101b | 11001110b = 11011111b
-11011101b | 11001111b = 11011111b
-11011101b | 11010000b = 11011101b
-11011101b | 11010001b = 11011101b
-11011101b | 11010010b = 11011111b
-11011101b | 11010011b = 11011111b
-11011101b | 11010100b = 11011101b
-11011101b | 11010101b = 11011101b
-11011101b | 11010110b = 11011111b
-11011101b | 11010111b = 11011111b
-11011101b | 11011000b = 11011101b
-11011101b | 11011001b = 11011101b
-11011101b | 11011010b = 11011111b
-11011101b | 11011011b = 11011111b
-11011101b | 11011100b = 11011101b
-11011101b | 11011101b = 11011101b
-11011101b | 11011110b = 11011111b
-11011101b | 11011111b = 11011111b
-11011101b | 11100000b = 11111101b
-11011101b | 11100001b = 11111101b
-11011101b | 11100010b = 11111111b
-11011101b | 11100011b = 11111111b
-11011101b | 11100100b = 11111101b
-11011101b | 11100101b = 11111101b
-11011101b | 11100110b = 11111111b
-11011101b | 11100111b = 11111111b
-11011101b | 11101000b = 11111101b
-11011101b | 11101001b = 11111101b
-11011101b | 11101010b = 11111111b
-11011101b | 11101011b = 11111111b
-11011101b | 11101100b = 11111101b
-11011101b | 11101101b = 11111101b
-11011101b | 11101110b = 11111111b
-11011101b | 11101111b = 11111111b
-11011101b | 11110000b = 11111101b
-11011101b | 11110001b = 11111101b
-11011101b | 11110010b = 11111111b
-11011101b | 11110011b = 11111111b
-11011101b | 11110100b = 11111101b
-11011101b | 11110101b = 11111101b
-11011101b | 11110110b = 11111111b
-11011101b | 11110111b = 11111111b
-11011101b | 11111000b = 11111101b
-11011101b | 11111001b = 11111101b
-11011101b | 11111010b = 11111111b
-11011101b | 11111011b = 11111111b
-11011101b | 11111100b = 11111101b
-11011101b | 11111101b = 11111101b
-11011101b | 11111110b = 11111111b
-11011101b | 11111111b = 11111111b
-11011101b | 00000000b = 11011101b
-11011101b | 00000001b = 11011101b
-11011101b | 00000010b = 11011111b
-11011101b | 00000011b = 11011111b
-11011101b | 00000100b = 11011101b
-11011101b | 00000101b = 11011101b
-11011101b | 00000110b = 11011111b
-11011101b | 00000111b = 11011111b
-11011101b | 00001000b = 11011101b
-11011101b | 00001001b = 11011101b
-11011101b | 00001010b = 11011111b
-11011101b | 00001011b = 11011111b
-11011101b | 00001100b = 11011101b
-11011101b | 00001101b = 11011101b
-11011101b | 00001110b = 11011111b
-11011101b | 00001111b = 11011111b
-11011101b | 00010000b = 11011101b
-11011101b | 00010001b = 11011101b
-11011101b | 00010010b = 11011111b
-11011101b | 00010011b = 11011111b
-11011101b | 00010100b = 11011101b
-11011101b | 00010101b = 11011101b
-11011101b | 00010110b = 11011111b
-11011101b | 00010111b = 11011111b
-11011101b | 00011000b = 11011101b
-11011101b | 00011001b = 11011101b
-11011101b | 00011010b = 11011111b
-11011101b | 00011011b = 11011111b
-11011101b | 00011100b = 11011101b
-11011101b | 00011101b = 11011101b
-11011101b | 00011110b = 11011111b
-11011101b | 00011111b = 11011111b
-11011101b | 00100000b = 11111101b
-11011101b | 00100001b = 11111101b
-11011101b | 00100010b = 11111111b
-11011101b | 00100011b = 11111111b
-11011101b | 00100100b = 11111101b
-11011101b | 00100101b = 11111101b
-11011101b | 00100110b = 11111111b
-11011101b | 00100111b = 11111111b
-11011101b | 00101000b = 11111101b
-11011101b | 00101001b = 11111101b
-11011101b | 00101010b = 11111111b
-11011101b | 00101011b = 11111111b
-11011101b | 00101100b = 11111101b
-11011101b | 00101101b = 11111101b
-11011101b | 00101110b = 11111111b
-11011101b | 00101111b = 11111111b
-11011101b | 00110000b = 11111101b
-11011101b | 00110001b = 11111101b
-11011101b | 00110010b = 11111111b
-11011101b | 00110011b = 11111111b
-11011101b | 00110100b = 11111101b
-11011101b | 00110101b = 11111101b
-11011101b | 00110110b = 11111111b
-11011101b | 00110111b = 11111111b
-11011101b | 00111000b = 11111101b
-11011101b | 00111001b = 11111101b
-11011101b | 00111010b = 11111111b
-11011101b | 00111011b = 11111111b
-11011101b | 00111100b = 11111101b
-11011101b | 00111101b = 11111101b
-11011101b | 00111110b = 11111111b
-11011101b | 00111111b = 11111111b
-11011101b | 01000000b = 11011101b
-11011101b | 01000001b = 11011101b
-11011101b | 01000010b = 11011111b
-11011101b | 01000011b = 11011111b
-11011101b | 01000100b = 11011101b
-11011101b | 01000101b = 11011101b
-11011101b | 01000110b = 11011111b
-11011101b | 01000111b = 11011111b
-11011101b | 01001000b = 11011101b
-11011101b | 01001001b = 11011101b
-11011101b | 01001010b = 11011111b
-11011101b | 01001011b = 11011111b
-11011101b | 01001100b = 11011101b
-11011101b | 01001101b = 11011101b
-11011101b | 01001110b = 11011111b
-11011101b | 01001111b = 11011111b
-11011101b | 01010000b = 11011101b
-11011101b | 01010001b = 11011101b
-11011101b | 01010010b = 11011111b
-11011101b | 01010011b = 11011111b
-11011101b | 01010100b = 11011101b
-11011101b | 01010101b = 11011101b
-11011101b | 01010110b = 11011111b
-11011101b | 01010111b = 11011111b
-11011101b | 01011000b = 11011101b
-11011101b | 01011001b = 11011101b
-11011101b | 01011010b = 11011111b
-11011101b | 01011011b = 11011111b
-11011101b | 01011100b = 11011101b
-11011101b | 01011101b = 11011101b
-11011101b | 01011110b = 11011111b
-11011101b | 01011111b = 11011111b
-11011101b | 01100000b = 11111101b
-11011101b | 01100001b = 11111101b
-11011101b | 01100010b = 11111111b
-11011101b | 01100011b = 11111111b
-11011101b | 01100100b = 11111101b
-11011101b | 01100101b = 11111101b
-11011101b | 01100110b = 11111111b
-11011101b | 01100111b = 11111111b
-11011101b | 01101000b = 11111101b
-11011101b | 01101001b = 11111101b
-11011101b | 01101010b = 11111111b
-11011101b | 01101011b = 11111111b
-11011101b | 01101100b = 11111101b
-11011101b | 01101101b = 11111101b
-11011101b | 01101110b = 11111111b
-11011101b | 01101111b = 11111111b
-11011101b | 01110000b = 11111101b
-11011101b | 01110001b = 11111101b
-11011101b | 01110010b = 11111111b
-11011101b | 01110011b = 11111111b
-11011101b | 01110100b = 11111101b
-11011101b | 01110101b = 11111101b
-11011101b | 01110110b = 11111111b
-11011101b | 01110111b = 11111111b
-11011101b | 01111000b = 11111101b
-11011101b | 01111001b = 11111101b
-11011101b | 01111010b = 11111111b
-11011101b | 01111011b = 11111111b
-11011101b | 01111100b = 11111101b
-11011101b | 01111101b = 11111101b
-11011101b | 01111110b = 11111111b
-11011110b | 10000000b = 11011110b
-11011110b | 10000001b = 11011111b
-11011110b | 10000010b = 11011110b
-11011110b | 10000011b = 11011111b
-11011110b | 10000100b = 11011110b
-11011110b | 10000101b = 11011111b
-11011110b | 10000110b = 11011110b
-11011110b | 10000111b = 11011111b
-11011110b | 10001000b = 11011110b
-11011110b | 10001001b = 11011111b
-11011110b | 10001010b = 11011110b
-11011110b | 10001011b = 11011111b
-11011110b | 10001100b = 11011110b
-11011110b | 10001101b = 11011111b
-11011110b | 10001110b = 11011110b
-11011110b | 10001111b = 11011111b
-11011110b | 10010000b = 11011110b
-11011110b | 10010001b = 11011111b
-11011110b | 10010010b = 11011110b
-11011110b | 10010011b = 11011111b
-11011110b | 10010100b = 11011110b
-11011110b | 10010101b = 11011111b
-11011110b | 10010110b = 11011110b
-11011110b | 10010111b = 11011111b
-11011110b | 10011000b = 11011110b
-11011110b | 10011001b = 11011111b
-11011110b | 10011010b = 11011110b
-11011110b | 10011011b = 11011111b
-11011110b | 10011100b = 11011110b
-11011110b | 10011101b = 11011111b
-11011110b | 10011110b = 11011110b
-11011110b | 10011111b = 11011111b
-11011110b | 10100000b = 11111110b
-11011110b | 10100001b = 11111111b
-11011110b | 10100010b = 11111110b
-11011110b | 10100011b = 11111111b
-11011110b | 10100100b = 11111110b
-11011110b | 10100101b = 11111111b
-11011110b | 10100110b = 11111110b
-11011110b | 10100111b = 11111111b
-11011110b | 10101000b = 11111110b
-11011110b | 10101001b = 11111111b
-11011110b | 10101010b = 11111110b
-11011110b | 10101011b = 11111111b
-11011110b | 10101100b = 11111110b
-11011110b | 10101101b = 11111111b
-11011110b | 10101110b = 11111110b
-11011110b | 10101111b = 11111111b
-11011110b | 10110000b = 11111110b
-11011110b | 10110001b = 11111111b
-11011110b | 10110010b = 11111110b
-11011110b | 10110011b = 11111111b
-11011110b | 10110100b = 11111110b
-11011110b | 10110101b = 11111111b
-11011110b | 10110110b = 11111110b
-11011110b | 10110111b = 11111111b
-11011110b | 10111000b = 11111110b
-11011110b | 10111001b = 11111111b
-11011110b | 10111010b = 11111110b
-11011110b | 10111011b = 11111111b
-11011110b | 10111100b = 11111110b
-11011110b | 10111101b = 11111111b
-11011110b | 10111110b = 11111110b
-11011110b | 10111111b = 11111111b
-11011110b | 11000000b = 11011110b
-11011110b | 11000001b = 11011111b
-11011110b | 11000010b = 11011110b
-11011110b | 11000011b = 11011111b
-11011110b | 11000100b = 11011110b
-11011110b | 11000101b = 11011111b
-11011110b | 11000110b = 11011110b
-11011110b | 11000111b = 11011111b
-11011110b | 11001000b = 11011110b
-11011110b | 11001001b = 11011111b
-11011110b | 11001010b = 11011110b
-11011110b | 11001011b = 11011111b
-11011110b | 11001100b = 11011110b
-11011110b | 11001101b = 11011111b
-11011110b | 11001110b = 11011110b
-11011110b | 11001111b = 11011111b
-11011110b | 11010000b = 11011110b
-11011110b | 11010001b = 11011111b
-11011110b | 11010010b = 11011110b
-11011110b | 11010011b = 11011111b
-11011110b | 11010100b = 11011110b
-11011110b | 11010101b = 11011111b
-11011110b | 11010110b = 11011110b
-11011110b | 11010111b = 11011111b
-11011110b | 11011000b = 11011110b
-11011110b | 11011001b = 11011111b
-11011110b | 11011010b = 11011110b
-11011110b | 11011011b = 11011111b
-11011110b | 11011100b = 11011110b
-11011110b | 11011101b = 11011111b
-11011110b | 11011110b = 11011110b
-11011110b | 11011111b = 11011111b
-11011110b | 11100000b = 11111110b
-11011110b | 11100001b = 11111111b
-11011110b | 11100010b = 11111110b
-11011110b | 11100011b = 11111111b
-11011110b | 11100100b = 11111110b
-11011110b | 11100101b = 11111111b
-11011110b | 11100110b = 11111110b
-11011110b | 11100111b = 11111111b
-11011110b | 11101000b = 11111110b
-11011110b | 11101001b = 11111111b
-11011110b | 11101010b = 11111110b
-11011110b | 11101011b = 11111111b
-11011110b | 11101100b = 11111110b
-11011110b | 11101101b = 11111111b
-11011110b | 11101110b = 11111110b
-11011110b | 11101111b = 11111111b
-11011110b | 11110000b = 11111110b
-11011110b | 11110001b = 11111111b
-11011110b | 11110010b = 11111110b
-11011110b | 11110011b = 11111111b
-11011110b | 11110100b = 11111110b
-11011110b | 11110101b = 11111111b
-11011110b | 11110110b = 11111110b
-11011110b | 11110111b = 11111111b
-11011110b | 11111000b = 11111110b
-11011110b | 11111001b = 11111111b
-11011110b | 11111010b = 11111110b
-11011110b | 11111011b = 11111111b
-11011110b | 11111100b = 11111110b
-11011110b | 11111101b = 11111111b
-11011110b | 11111110b = 11111110b
-11011110b | 11111111b = 11111111b
-11011110b | 00000000b = 11011110b
-11011110b | 00000001b = 11011111b
-11011110b | 00000010b = 11011110b
-11011110b | 00000011b = 11011111b
-11011110b | 00000100b = 11011110b
-11011110b | 00000101b = 11011111b
-11011110b | 00000110b = 11011110b
-11011110b | 00000111b = 11011111b
-11011110b | 00001000b = 11011110b
-11011110b | 00001001b = 11011111b
-11011110b | 00001010b = 11011110b
-11011110b | 00001011b = 11011111b
-11011110b | 00001100b = 11011110b
-11011110b | 00001101b = 11011111b
-11011110b | 00001110b = 11011110b
-11011110b | 00001111b = 11011111b
-11011110b | 00010000b = 11011110b
-11011110b | 00010001b = 11011111b
-11011110b | 00010010b = 11011110b
-11011110b | 00010011b = 11011111b
-11011110b | 00010100b = 11011110b
-11011110b | 00010101b = 11011111b
-11011110b | 00010110b = 11011110b
-11011110b | 00010111b = 11011111b
-11011110b | 00011000b = 11011110b
-11011110b | 00011001b = 11011111b
-11011110b | 00011010b = 11011110b
-11011110b | 00011011b = 11011111b
-11011110b | 00011100b = 11011110b
-11011110b | 00011101b = 11011111b
-11011110b | 00011110b = 11011110b
-11011110b | 00011111b = 11011111b
-11011110b | 00100000b = 11111110b
-11011110b | 00100001b = 11111111b
-11011110b | 00100010b = 11111110b
-11011110b | 00100011b = 11111111b
-11011110b | 00100100b = 11111110b
-11011110b | 00100101b = 11111111b
-11011110b | 00100110b = 11111110b
-11011110b | 00100111b = 11111111b
-11011110b | 00101000b = 11111110b
-11011110b | 00101001b = 11111111b
-11011110b | 00101010b = 11111110b
-11011110b | 00101011b = 11111111b
-11011110b | 00101100b = 11111110b
-11011110b | 00101101b = 11111111b
-11011110b | 00101110b = 11111110b
-11011110b | 00101111b = 11111111b
-11011110b | 00110000b = 11111110b
-11011110b | 00110001b = 11111111b
-11011110b | 00110010b = 11111110b
-11011110b | 00110011b = 11111111b
-11011110b | 00110100b = 11111110b
-11011110b | 00110101b = 11111111b
-11011110b | 00110110b = 11111110b
-11011110b | 00110111b = 11111111b
-11011110b | 00111000b = 11111110b
-11011110b | 00111001b = 11111111b
-11011110b | 00111010b = 11111110b
-11011110b | 00111011b = 11111111b
-11011110b | 00111100b = 11111110b
-11011110b | 00111101b = 11111111b
-11011110b | 00111110b = 11111110b
-11011110b | 00111111b = 11111111b
-11011110b | 01000000b = 11011110b
-11011110b | 01000001b = 11011111b
-11011110b | 01000010b = 11011110b
-11011110b | 01000011b = 11011111b
-11011110b | 01000100b = 11011110b
-11011110b | 01000101b = 11011111b
-11011110b | 01000110b = 11011110b
-11011110b | 01000111b = 11011111b
-11011110b | 01001000b = 11011110b
-11011110b | 01001001b = 11011111b
-11011110b | 01001010b = 11011110b
-11011110b | 01001011b = 11011111b
-11011110b | 01001100b = 11011110b
-11011110b | 01001101b = 11011111b
-11011110b | 01001110b = 11011110b
-11011110b | 01001111b = 11011111b
-11011110b | 01010000b = 11011110b
-11011110b | 01010001b = 11011111b
-11011110b | 01010010b = 11011110b
-11011110b | 01010011b = 11011111b
-11011110b | 01010100b = 11011110b
-11011110b | 01010101b = 11011111b
-11011110b | 01010110b = 11011110b
-11011110b | 01010111b = 11011111b
-11011110b | 01011000b = 11011110b
-11011110b | 01011001b = 11011111b
-11011110b | 01011010b = 11011110b
-11011110b | 01011011b = 11011111b
-11011110b | 01011100b = 11011110b
-11011110b | 01011101b = 11011111b
-11011110b | 01011110b = 11011110b
-11011110b | 01011111b = 11011111b
-11011110b | 01100000b = 11111110b
-11011110b | 01100001b = 11111111b
-11011110b | 01100010b = 11111110b
-11011110b | 01100011b = 11111111b
-11011110b | 01100100b = 11111110b
-11011110b | 01100101b = 11111111b
-11011110b | 01100110b = 11111110b
-11011110b | 01100111b = 11111111b
-11011110b | 01101000b = 11111110b
-11011110b | 01101001b = 11111111b
-11011110b | 01101010b = 11111110b
-11011110b | 01101011b = 11111111b
-11011110b | 01101100b = 11111110b
-11011110b | 01101101b = 11111111b
-11011110b | 01101110b = 11111110b
-11011110b | 01101111b = 11111111b
-11011110b | 01110000b = 11111110b
-11011110b | 01110001b = 11111111b
-11011110b | 01110010b = 11111110b
-11011110b | 01110011b = 11111111b
-11011110b | 01110100b = 11111110b
-11011110b | 01110101b = 11111111b
-11011110b | 01110110b = 11111110b
-11011110b | 01110111b = 11111111b
-11011110b | 01111000b = 11111110b
-11011110b | 01111001b = 11111111b
-11011110b | 01111010b = 11111110b
-11011110b | 01111011b = 11111111b
-11011110b | 01111100b = 11111110b
-11011110b | 01111101b = 11111111b
-11011110b | 01111110b = 11111110b
-11011111b | 10000000b = 11011111b
-11011111b | 10000001b = 11011111b
-11011111b | 10000010b = 11011111b
-11011111b | 10000011b = 11011111b
-11011111b | 10000100b = 11011111b
-11011111b | 10000101b = 11011111b
-11011111b | 10000110b = 11011111b
-11011111b | 10000111b = 11011111b
-11011111b | 10001000b = 11011111b
-11011111b | 10001001b = 11011111b
-11011111b | 10001010b = 11011111b
-11011111b | 10001011b = 11011111b
-11011111b | 10001100b = 11011111b
-11011111b | 10001101b = 11011111b
-11011111b | 10001110b = 11011111b
-11011111b | 10001111b = 11011111b
-11011111b | 10010000b = 11011111b
-11011111b | 10010001b = 11011111b
-11011111b | 10010010b = 11011111b
-11011111b | 10010011b = 11011111b
-11011111b | 10010100b = 11011111b
-11011111b | 10010101b = 11011111b
-11011111b | 10010110b = 11011111b
-11011111b | 10010111b = 11011111b
-11011111b | 10011000b = 11011111b
-11011111b | 10011001b = 11011111b
-11011111b | 10011010b = 11011111b
-11011111b | 10011011b = 11011111b
-11011111b | 10011100b = 11011111b
-11011111b | 10011101b = 11011111b
-11011111b | 10011110b = 11011111b
-11011111b | 10011111b = 11011111b
-11011111b | 10100000b = 11111111b
-11011111b | 10100001b = 11111111b
-11011111b | 10100010b = 11111111b
-11011111b | 10100011b = 11111111b
-11011111b | 10100100b = 11111111b
-11011111b | 10100101b = 11111111b
-11011111b | 10100110b = 11111111b
-11011111b | 10100111b = 11111111b
-11011111b | 10101000b = 11111111b
-11011111b | 10101001b = 11111111b
-11011111b | 10101010b = 11111111b
-11011111b | 10101011b = 11111111b
-11011111b | 10101100b = 11111111b
-11011111b | 10101101b = 11111111b
-11011111b | 10101110b = 11111111b
-11011111b | 10101111b = 11111111b
-11011111b | 10110000b = 11111111b
-11011111b | 10110001b = 11111111b
-11011111b | 10110010b = 11111111b
-11011111b | 10110011b = 11111111b
-11011111b | 10110100b = 11111111b
-11011111b | 10110101b = 11111111b
-11011111b | 10110110b = 11111111b
-11011111b | 10110111b = 11111111b
-11011111b | 10111000b = 11111111b
-11011111b | 10111001b = 11111111b
-11011111b | 10111010b = 11111111b
-11011111b | 10111011b = 11111111b
-11011111b | 10111100b = 11111111b
-11011111b | 10111101b = 11111111b
-11011111b | 10111110b = 11111111b
-11011111b | 10111111b = 11111111b
-11011111b | 11000000b = 11011111b
-11011111b | 11000001b = 11011111b
-11011111b | 11000010b = 11011111b
-11011111b | 11000011b = 11011111b
-11011111b | 11000100b = 11011111b
-11011111b | 11000101b = 11011111b
-11011111b | 11000110b = 11011111b
-11011111b | 11000111b = 11011111b
-11011111b | 11001000b = 11011111b
-11011111b | 11001001b = 11011111b
-11011111b | 11001010b = 11011111b
-11011111b | 11001011b = 11011111b
-11011111b | 11001100b = 11011111b
-11011111b | 11001101b = 11011111b
-11011111b | 11001110b = 11011111b
-11011111b | 11001111b = 11011111b
-11011111b | 11010000b = 11011111b
-11011111b | 11010001b = 11011111b
-11011111b | 11010010b = 11011111b
-11011111b | 11010011b = 11011111b
-11011111b | 11010100b = 11011111b
-11011111b | 11010101b = 11011111b
-11011111b | 11010110b = 11011111b
-11011111b | 11010111b = 11011111b
-11011111b | 11011000b = 11011111b
-11011111b | 11011001b = 11011111b
-11011111b | 11011010b = 11011111b
-11011111b | 11011011b = 11011111b
-11011111b | 11011100b = 11011111b
-11011111b | 11011101b = 11011111b
-11011111b | 11011110b = 11011111b
-11011111b | 11011111b = 11011111b
-11011111b | 11100000b = 11111111b
-11011111b | 11100001b = 11111111b
-11011111b | 11100010b = 11111111b
-11011111b | 11100011b = 11111111b
-11011111b | 11100100b = 11111111b
-11011111b | 11100101b = 11111111b
-11011111b | 11100110b = 11111111b
-11011111b | 11100111b = 11111111b
-11011111b | 11101000b = 11111111b
-11011111b | 11101001b = 11111111b
-11011111b | 11101010b = 11111111b
-11011111b | 11101011b = 11111111b
-11011111b | 11101100b = 11111111b
-11011111b | 11101101b = 11111111b
-11011111b | 11101110b = 11111111b
-11011111b | 11101111b = 11111111b
-11011111b | 11110000b = 11111111b
-11011111b | 11110001b = 11111111b
-11011111b | 11110010b = 11111111b
-11011111b | 11110011b = 11111111b
-11011111b | 11110100b = 11111111b
-11011111b | 11110101b = 11111111b
-11011111b | 11110110b = 11111111b
-11011111b | 11110111b = 11111111b
-11011111b | 11111000b = 11111111b
-11011111b | 11111001b = 11111111b
-11011111b | 11111010b = 11111111b
-11011111b | 11111011b = 11111111b
-11011111b | 11111100b = 11111111b
-11011111b | 11111101b = 11111111b
-11011111b | 11111110b = 11111111b
-11011111b | 11111111b = 11111111b
-11011111b | 00000000b = 11011111b
-11011111b | 00000001b = 11011111b
-11011111b | 00000010b = 11011111b
-11011111b | 00000011b = 11011111b
-11011111b | 00000100b = 11011111b
-11011111b | 00000101b = 11011111b
-11011111b | 00000110b = 11011111b
-11011111b | 00000111b = 11011111b
-11011111b | 00001000b = 11011111b
-11011111b | 00001001b = 11011111b
-11011111b | 00001010b = 11011111b
-11011111b | 00001011b = 11011111b
-11011111b | 00001100b = 11011111b
-11011111b | 00001101b = 11011111b
-11011111b | 00001110b = 11011111b
-11011111b | 00001111b = 11011111b
-11011111b | 00010000b = 11011111b
-11011111b | 00010001b = 11011111b
-11011111b | 00010010b = 11011111b
-11011111b | 00010011b = 11011111b
-11011111b | 00010100b = 11011111b
-11011111b | 00010101b = 11011111b
-11011111b | 00010110b = 11011111b
-11011111b | 00010111b = 11011111b
-11011111b | 00011000b = 11011111b
-11011111b | 00011001b = 11011111b
-11011111b | 00011010b = 11011111b
-11011111b | 00011011b = 11011111b
-11011111b | 00011100b = 11011111b
-11011111b | 00011101b = 11011111b
-11011111b | 00011110b = 11011111b
-11011111b | 00011111b = 11011111b
-11011111b | 00100000b = 11111111b
-11011111b | 00100001b = 11111111b
-11011111b | 00100010b = 11111111b
-11011111b | 00100011b = 11111111b
-11011111b | 00100100b = 11111111b
-11011111b | 00100101b = 11111111b
-11011111b | 00100110b = 11111111b
-11011111b | 00100111b = 11111111b
-11011111b | 00101000b = 11111111b
-11011111b | 00101001b = 11111111b
-11011111b | 00101010b = 11111111b
-11011111b | 00101011b = 11111111b
-11011111b | 00101100b = 11111111b
-11011111b | 00101101b = 11111111b
-11011111b | 00101110b = 11111111b
-11011111b | 00101111b = 11111111b
-11011111b | 00110000b = 11111111b
-11011111b | 00110001b = 11111111b
-11011111b | 00110010b = 11111111b
-11011111b | 00110011b = 11111111b
-11011111b | 00110100b = 11111111b
-11011111b | 00110101b = 11111111b
-11011111b | 00110110b = 11111111b
-11011111b | 00110111b = 11111111b
-11011111b | 00111000b = 11111111b
-11011111b | 00111001b = 11111111b
-11011111b | 00111010b = 11111111b
-11011111b | 00111011b = 11111111b
-11011111b | 00111100b = 11111111b
-11011111b | 00111101b = 11111111b
-11011111b | 00111110b = 11111111b
-11011111b | 00111111b = 11111111b
-11011111b | 01000000b = 11011111b
-11011111b | 01000001b = 11011111b
-11011111b | 01000010b = 11011111b
-11011111b | 01000011b = 11011111b
-11011111b | 01000100b = 11011111b
-11011111b | 01000101b = 11011111b
-11011111b | 01000110b = 11011111b
-11011111b | 01000111b = 11011111b
-11011111b | 01001000b = 11011111b
-11011111b | 01001001b = 11011111b
-11011111b | 01001010b = 11011111b
-11011111b | 01001011b = 11011111b
-11011111b | 01001100b = 11011111b
-11011111b | 01001101b = 11011111b
-11011111b | 01001110b = 11011111b
-11011111b | 01001111b = 11011111b
-11011111b | 01010000b = 11011111b
-11011111b | 01010001b = 11011111b
-11011111b | 01010010b = 11011111b
-11011111b | 01010011b = 11011111b
-11011111b | 01010100b = 11011111b
-11011111b | 01010101b = 11011111b
-11011111b | 01010110b = 11011111b
-11011111b | 01010111b = 11011111b
-11011111b | 01011000b = 11011111b
-11011111b | 01011001b = 11011111b
-11011111b | 01011010b = 11011111b
-11011111b | 01011011b = 11011111b
-11011111b | 01011100b = 11011111b
-11011111b | 01011101b = 11011111b
-11011111b | 01011110b = 11011111b
-11011111b | 01011111b = 11011111b
-11011111b | 01100000b = 11111111b
-11011111b | 01100001b = 11111111b
-11011111b | 01100010b = 11111111b
-11011111b | 01100011b = 11111111b
-11011111b | 01100100b = 11111111b
-11011111b | 01100101b = 11111111b
-11011111b | 01100110b = 11111111b
-11011111b | 01100111b = 11111111b
-11011111b | 01101000b = 11111111b
-11011111b | 01101001b = 11111111b
-11011111b | 01101010b = 11111111b
-11011111b | 01101011b = 11111111b
-11011111b | 01101100b = 11111111b
-11011111b | 01101101b = 11111111b
-11011111b | 01101110b = 11111111b
-11011111b | 01101111b = 11111111b
-11011111b | 01110000b = 11111111b
-11011111b | 01110001b = 11111111b
-11011111b | 01110010b = 11111111b
-11011111b | 01110011b = 11111111b
-11011111b | 01110100b = 11111111b
-11011111b | 01110101b = 11111111b
-11011111b | 01110110b = 11111111b
-11011111b | 01110111b = 11111111b
-11011111b | 01111000b = 11111111b
-11011111b | 01111001b = 11111111b
-11011111b | 01111010b = 11111111b
-11011111b | 01111011b = 11111111b
-11011111b | 01111100b = 11111111b
-11011111b | 01111101b = 11111111b
-11011111b | 01111110b = 11111111b
-11100000b | 10000000b = 11100000b
-11100000b | 10000001b = 11100001b
-11100000b | 10000010b = 11100010b
-11100000b | 10000011b = 11100011b
-11100000b | 10000100b = 11100100b
-11100000b | 10000101b = 11100101b
-11100000b | 10000110b = 11100110b
-11100000b | 10000111b = 11100111b
-11100000b | 10001000b = 11101000b
-11100000b | 10001001b = 11101001b
-11100000b | 10001010b = 11101010b
-11100000b | 10001011b = 11101011b
-11100000b | 10001100b = 11101100b
-11100000b | 10001101b = 11101101b
-11100000b | 10001110b = 11101110b
-11100000b | 10001111b = 11101111b
-11100000b | 10010000b = 11110000b
-11100000b | 10010001b = 11110001b
-11100000b | 10010010b = 11110010b
-11100000b | 10010011b = 11110011b
-11100000b | 10010100b = 11110100b
-11100000b | 10010101b = 11110101b
-11100000b | 10010110b = 11110110b
-11100000b | 10010111b = 11110111b
-11100000b | 10011000b = 11111000b
-11100000b | 10011001b = 11111001b
-11100000b | 10011010b = 11111010b
-11100000b | 10011011b = 11111011b
-11100000b | 10011100b = 11111100b
-11100000b | 10011101b = 11111101b
-11100000b | 10011110b = 11111110b
-11100000b | 10011111b = 11111111b
-11100000b | 10100000b = 11100000b
-11100000b | 10100001b = 11100001b
-11100000b | 10100010b = 11100010b
-11100000b | 10100011b = 11100011b
-11100000b | 10100100b = 11100100b
-11100000b | 10100101b = 11100101b
-11100000b | 10100110b = 11100110b
-11100000b | 10100111b = 11100111b
-11100000b | 10101000b = 11101000b
-11100000b | 10101001b = 11101001b
-11100000b | 10101010b = 11101010b
-11100000b | 10101011b = 11101011b
-11100000b | 10101100b = 11101100b
-11100000b | 10101101b = 11101101b
-11100000b | 10101110b = 11101110b
-11100000b | 10101111b = 11101111b
-11100000b | 10110000b = 11110000b
-11100000b | 10110001b = 11110001b
-11100000b | 10110010b = 11110010b
-11100000b | 10110011b = 11110011b
-11100000b | 10110100b = 11110100b
-11100000b | 10110101b = 11110101b
-11100000b | 10110110b = 11110110b
-11100000b | 10110111b = 11110111b
-11100000b | 10111000b = 11111000b
-11100000b | 10111001b = 11111001b
-11100000b | 10111010b = 11111010b
-11100000b | 10111011b = 11111011b
-11100000b | 10111100b = 11111100b
-11100000b | 10111101b = 11111101b
-11100000b | 10111110b = 11111110b
-11100000b | 10111111b = 11111111b
-11100000b | 11000000b = 11100000b
-11100000b | 11000001b = 11100001b
-11100000b | 11000010b = 11100010b
-11100000b | 11000011b = 11100011b
-11100000b | 11000100b = 11100100b
-11100000b | 11000101b = 11100101b
-11100000b | 11000110b = 11100110b
-11100000b | 11000111b = 11100111b
-11100000b | 11001000b = 11101000b
-11100000b | 11001001b = 11101001b
-11100000b | 11001010b = 11101010b
-11100000b | 11001011b = 11101011b
-11100000b | 11001100b = 11101100b
-11100000b | 11001101b = 11101101b
-11100000b | 11001110b = 11101110b
-11100000b | 11001111b = 11101111b
-11100000b | 11010000b = 11110000b
-11100000b | 11010001b = 11110001b
-11100000b | 11010010b = 11110010b
-11100000b | 11010011b = 11110011b
-11100000b | 11010100b = 11110100b
-11100000b | 11010101b = 11110101b
-11100000b | 11010110b = 11110110b
-11100000b | 11010111b = 11110111b
-11100000b | 11011000b = 11111000b
-11100000b | 11011001b = 11111001b
-11100000b | 11011010b = 11111010b
-11100000b | 11011011b = 11111011b
-11100000b | 11011100b = 11111100b
-11100000b | 11011101b = 11111101b
-11100000b | 11011110b = 11111110b
-11100000b | 11011111b = 11111111b
-11100000b | 11100000b = 11100000b
-11100000b | 11100001b = 11100001b
-11100000b | 11100010b = 11100010b
-11100000b | 11100011b = 11100011b
-11100000b | 11100100b = 11100100b
-11100000b | 11100101b = 11100101b
-11100000b | 11100110b = 11100110b
-11100000b | 11100111b = 11100111b
-11100000b | 11101000b = 11101000b
-11100000b | 11101001b = 11101001b
-11100000b | 11101010b = 11101010b
-11100000b | 11101011b = 11101011b
-11100000b | 11101100b = 11101100b
-11100000b | 11101101b = 11101101b
-11100000b | 11101110b = 11101110b
-11100000b | 11101111b = 11101111b
-11100000b | 11110000b = 11110000b
-11100000b | 11110001b = 11110001b
-11100000b | 11110010b = 11110010b
-11100000b | 11110011b = 11110011b
-11100000b | 11110100b = 11110100b
-11100000b | 11110101b = 11110101b
-11100000b | 11110110b = 11110110b
-11100000b | 11110111b = 11110111b
-11100000b | 11111000b = 11111000b
-11100000b | 11111001b = 11111001b
-11100000b | 11111010b = 11111010b
-11100000b | 11111011b = 11111011b
-11100000b | 11111100b = 11111100b
-11100000b | 11111101b = 11111101b
-11100000b | 11111110b = 11111110b
-11100000b | 11111111b = 11111111b
-11100000b | 00000000b = 11100000b
-11100000b | 00000001b = 11100001b
-11100000b | 00000010b = 11100010b
-11100000b | 00000011b = 11100011b
-11100000b | 00000100b = 11100100b
-11100000b | 00000101b = 11100101b
-11100000b | 00000110b = 11100110b
-11100000b | 00000111b = 11100111b
-11100000b | 00001000b = 11101000b
-11100000b | 00001001b = 11101001b
-11100000b | 00001010b = 11101010b
-11100000b | 00001011b = 11101011b
-11100000b | 00001100b = 11101100b
-11100000b | 00001101b = 11101101b
-11100000b | 00001110b = 11101110b
-11100000b | 00001111b = 11101111b
-11100000b | 00010000b = 11110000b
-11100000b | 00010001b = 11110001b
-11100000b | 00010010b = 11110010b
-11100000b | 00010011b = 11110011b
-11100000b | 00010100b = 11110100b
-11100000b | 00010101b = 11110101b
-11100000b | 00010110b = 11110110b
-11100000b | 00010111b = 11110111b
-11100000b | 00011000b = 11111000b
-11100000b | 00011001b = 11111001b
-11100000b | 00011010b = 11111010b
-11100000b | 00011011b = 11111011b
-11100000b | 00011100b = 11111100b
-11100000b | 00011101b = 11111101b
-11100000b | 00011110b = 11111110b
-11100000b | 00011111b = 11111111b
-11100000b | 00100000b = 11100000b
-11100000b | 00100001b = 11100001b
-11100000b | 00100010b = 11100010b
-11100000b | 00100011b = 11100011b
-11100000b | 00100100b = 11100100b
-11100000b | 00100101b = 11100101b
-11100000b | 00100110b = 11100110b
-11100000b | 00100111b = 11100111b
-11100000b | 00101000b = 11101000b
-11100000b | 00101001b = 11101001b
-11100000b | 00101010b = 11101010b
-11100000b | 00101011b = 11101011b
-11100000b | 00101100b = 11101100b
-11100000b | 00101101b = 11101101b
-11100000b | 00101110b = 11101110b
-11100000b | 00101111b = 11101111b
-11100000b | 00110000b = 11110000b
-11100000b | 00110001b = 11110001b
-11100000b | 00110010b = 11110010b
-11100000b | 00110011b = 11110011b
-11100000b | 00110100b = 11110100b
-11100000b | 00110101b = 11110101b
-11100000b | 00110110b = 11110110b
-11100000b | 00110111b = 11110111b
-11100000b | 00111000b = 11111000b
-11100000b | 00111001b = 11111001b
-11100000b | 00111010b = 11111010b
-11100000b | 00111011b = 11111011b
-11100000b | 00111100b = 11111100b
-11100000b | 00111101b = 11111101b
-11100000b | 00111110b = 11111110b
-11100000b | 00111111b = 11111111b
-11100000b | 01000000b = 11100000b
-11100000b | 01000001b = 11100001b
-11100000b | 01000010b = 11100010b
-11100000b | 01000011b = 11100011b
-11100000b | 01000100b = 11100100b
-11100000b | 01000101b = 11100101b
-11100000b | 01000110b = 11100110b
-11100000b | 01000111b = 11100111b
-11100000b | 01001000b = 11101000b
-11100000b | 01001001b = 11101001b
-11100000b | 01001010b = 11101010b
-11100000b | 01001011b = 11101011b
-11100000b | 01001100b = 11101100b
-11100000b | 01001101b = 11101101b
-11100000b | 01001110b = 11101110b
-11100000b | 01001111b = 11101111b
-11100000b | 01010000b = 11110000b
-11100000b | 01010001b = 11110001b
-11100000b | 01010010b = 11110010b
-11100000b | 01010011b = 11110011b
-11100000b | 01010100b = 11110100b
-11100000b | 01010101b = 11110101b
-11100000b | 01010110b = 11110110b
-11100000b | 01010111b = 11110111b
-11100000b | 01011000b = 11111000b
-11100000b | 01011001b = 11111001b
-11100000b | 01011010b = 11111010b
-11100000b | 01011011b = 11111011b
-11100000b | 01011100b = 11111100b
-11100000b | 01011101b = 11111101b
-11100000b | 01011110b = 11111110b
-11100000b | 01011111b = 11111111b
-11100000b | 01100000b = 11100000b
-11100000b | 01100001b = 11100001b
-11100000b | 01100010b = 11100010b
-11100000b | 01100011b = 11100011b
-11100000b | 01100100b = 11100100b
-11100000b | 01100101b = 11100101b
-11100000b | 01100110b = 11100110b
-11100000b | 01100111b = 11100111b
-11100000b | 01101000b = 11101000b
-11100000b | 01101001b = 11101001b
-11100000b | 01101010b = 11101010b
-11100000b | 01101011b = 11101011b
-11100000b | 01101100b = 11101100b
-11100000b | 01101101b = 11101101b
-11100000b | 01101110b = 11101110b
-11100000b | 01101111b = 11101111b
-11100000b | 01110000b = 11110000b
-11100000b | 01110001b = 11110001b
-11100000b | 01110010b = 11110010b
-11100000b | 01110011b = 11110011b
-11100000b | 01110100b = 11110100b
-11100000b | 01110101b = 11110101b
-11100000b | 01110110b = 11110110b
-11100000b | 01110111b = 11110111b
-11100000b | 01111000b = 11111000b
-11100000b | 01111001b = 11111001b
-11100000b | 01111010b = 11111010b
-11100000b | 01111011b = 11111011b
-11100000b | 01111100b = 11111100b
-11100000b | 01111101b = 11111101b
-11100000b | 01111110b = 11111110b
-11100001b | 10000000b = 11100001b
-11100001b | 10000001b = 11100001b
-11100001b | 10000010b = 11100011b
-11100001b | 10000011b = 11100011b
-11100001b | 10000100b = 11100101b
-11100001b | 10000101b = 11100101b
-11100001b | 10000110b = 11100111b
-11100001b | 10000111b = 11100111b
-11100001b | 10001000b = 11101001b
-11100001b | 10001001b = 11101001b
-11100001b | 10001010b = 11101011b
-11100001b | 10001011b = 11101011b
-11100001b | 10001100b = 11101101b
-11100001b | 10001101b = 11101101b
-11100001b | 10001110b = 11101111b
-11100001b | 10001111b = 11101111b
-11100001b | 10010000b = 11110001b
-11100001b | 10010001b = 11110001b
-11100001b | 10010010b = 11110011b
-11100001b | 10010011b = 11110011b
-11100001b | 10010100b = 11110101b
-11100001b | 10010101b = 11110101b
-11100001b | 10010110b = 11110111b
-11100001b | 10010111b = 11110111b
-11100001b | 10011000b = 11111001b
-11100001b | 10011001b = 11111001b
-11100001b | 10011010b = 11111011b
-11100001b | 10011011b = 11111011b
-11100001b | 10011100b = 11111101b
-11100001b | 10011101b = 11111101b
-11100001b | 10011110b = 11111111b
-11100001b | 10011111b = 11111111b
-11100001b | 10100000b = 11100001b
-11100001b | 10100001b = 11100001b
-11100001b | 10100010b = 11100011b
-11100001b | 10100011b = 11100011b
-11100001b | 10100100b = 11100101b
-11100001b | 10100101b = 11100101b
-11100001b | 10100110b = 11100111b
-11100001b | 10100111b = 11100111b
-11100001b | 10101000b = 11101001b
-11100001b | 10101001b = 11101001b
-11100001b | 10101010b = 11101011b
-11100001b | 10101011b = 11101011b
-11100001b | 10101100b = 11101101b
-11100001b | 10101101b = 11101101b
-11100001b | 10101110b = 11101111b
-11100001b | 10101111b = 11101111b
-11100001b | 10110000b = 11110001b
-11100001b | 10110001b = 11110001b
-11100001b | 10110010b = 11110011b
-11100001b | 10110011b = 11110011b
-11100001b | 10110100b = 11110101b
-11100001b | 10110101b = 11110101b
-11100001b | 10110110b = 11110111b
-11100001b | 10110111b = 11110111b
-11100001b | 10111000b = 11111001b
-11100001b | 10111001b = 11111001b
-11100001b | 10111010b = 11111011b
-11100001b | 10111011b = 11111011b
-11100001b | 10111100b = 11111101b
-11100001b | 10111101b = 11111101b
-11100001b | 10111110b = 11111111b
-11100001b | 10111111b = 11111111b
-11100001b | 11000000b = 11100001b
-11100001b | 11000001b = 11100001b
-11100001b | 11000010b = 11100011b
-11100001b | 11000011b = 11100011b
-11100001b | 11000100b = 11100101b
-11100001b | 11000101b = 11100101b
-11100001b | 11000110b = 11100111b
-11100001b | 11000111b = 11100111b
-11100001b | 11001000b = 11101001b
-11100001b | 11001001b = 11101001b
-11100001b | 11001010b = 11101011b
-11100001b | 11001011b = 11101011b
-11100001b | 11001100b = 11101101b
-11100001b | 11001101b = 11101101b
-11100001b | 11001110b = 11101111b
-11100001b | 11001111b = 11101111b
-11100001b | 11010000b = 11110001b
-11100001b | 11010001b = 11110001b
-11100001b | 11010010b = 11110011b
-11100001b | 11010011b = 11110011b
-11100001b | 11010100b = 11110101b
-11100001b | 11010101b = 11110101b
-11100001b | 11010110b = 11110111b
-11100001b | 11010111b = 11110111b
-11100001b | 11011000b = 11111001b
-11100001b | 11011001b = 11111001b
-11100001b | 11011010b = 11111011b
-11100001b | 11011011b = 11111011b
-11100001b | 11011100b = 11111101b
-11100001b | 11011101b = 11111101b
-11100001b | 11011110b = 11111111b
-11100001b | 11011111b = 11111111b
-11100001b | 11100000b = 11100001b
-11100001b | 11100001b = 11100001b
-11100001b | 11100010b = 11100011b
-11100001b | 11100011b = 11100011b
-11100001b | 11100100b = 11100101b
-11100001b | 11100101b = 11100101b
-11100001b | 11100110b = 11100111b
-11100001b | 11100111b = 11100111b
-11100001b | 11101000b = 11101001b
-11100001b | 11101001b = 11101001b
-11100001b | 11101010b = 11101011b
-11100001b | 11101011b = 11101011b
-11100001b | 11101100b = 11101101b
-11100001b | 11101101b = 11101101b
-11100001b | 11101110b = 11101111b
-11100001b | 11101111b = 11101111b
-11100001b | 11110000b = 11110001b
-11100001b | 11110001b = 11110001b
-11100001b | 11110010b = 11110011b
-11100001b | 11110011b = 11110011b
-11100001b | 11110100b = 11110101b
-11100001b | 11110101b = 11110101b
-11100001b | 11110110b = 11110111b
-11100001b | 11110111b = 11110111b
-11100001b | 11111000b = 11111001b
-11100001b | 11111001b = 11111001b
-11100001b | 11111010b = 11111011b
-11100001b | 11111011b = 11111011b
-11100001b | 11111100b = 11111101b
-11100001b | 11111101b = 11111101b
-11100001b | 11111110b = 11111111b
-11100001b | 11111111b = 11111111b
-11100001b | 00000000b = 11100001b
-11100001b | 00000001b = 11100001b
-11100001b | 00000010b = 11100011b
-11100001b | 00000011b = 11100011b
-11100001b | 00000100b = 11100101b
-11100001b | 00000101b = 11100101b
-11100001b | 00000110b = 11100111b
-11100001b | 00000111b = 11100111b
-11100001b | 00001000b = 11101001b
-11100001b | 00001001b = 11101001b
-11100001b | 00001010b = 11101011b
-11100001b | 00001011b = 11101011b
-11100001b | 00001100b = 11101101b
-11100001b | 00001101b = 11101101b
-11100001b | 00001110b = 11101111b
-11100001b | 00001111b = 11101111b
-11100001b | 00010000b = 11110001b
-11100001b | 00010001b = 11110001b
-11100001b | 00010010b = 11110011b
-11100001b | 00010011b = 11110011b
-11100001b | 00010100b = 11110101b
-11100001b | 00010101b = 11110101b
-11100001b | 00010110b = 11110111b
-11100001b | 00010111b = 11110111b
-11100001b | 00011000b = 11111001b
-11100001b | 00011001b = 11111001b
-11100001b | 00011010b = 11111011b
-11100001b | 00011011b = 11111011b
-11100001b | 00011100b = 11111101b
-11100001b | 00011101b = 11111101b
-11100001b | 00011110b = 11111111b
-11100001b | 00011111b = 11111111b
-11100001b | 00100000b = 11100001b
-11100001b | 00100001b = 11100001b
-11100001b | 00100010b = 11100011b
-11100001b | 00100011b = 11100011b
-11100001b | 00100100b = 11100101b
-11100001b | 00100101b = 11100101b
-11100001b | 00100110b = 11100111b
-11100001b | 00100111b = 11100111b
-11100001b | 00101000b = 11101001b
-11100001b | 00101001b = 11101001b
-11100001b | 00101010b = 11101011b
-11100001b | 00101011b = 11101011b
-11100001b | 00101100b = 11101101b
-11100001b | 00101101b = 11101101b
-11100001b | 00101110b = 11101111b
-11100001b | 00101111b = 11101111b
-11100001b | 00110000b = 11110001b
-11100001b | 00110001b = 11110001b
-11100001b | 00110010b = 11110011b
-11100001b | 00110011b = 11110011b
-11100001b | 00110100b = 11110101b
-11100001b | 00110101b = 11110101b
-11100001b | 00110110b = 11110111b
-11100001b | 00110111b = 11110111b
-11100001b | 00111000b = 11111001b
-11100001b | 00111001b = 11111001b
-11100001b | 00111010b = 11111011b
-11100001b | 00111011b = 11111011b
-11100001b | 00111100b = 11111101b
-11100001b | 00111101b = 11111101b
-11100001b | 00111110b = 11111111b
-11100001b | 00111111b = 11111111b
-11100001b | 01000000b = 11100001b
-11100001b | 01000001b = 11100001b
-11100001b | 01000010b = 11100011b
-11100001b | 01000011b = 11100011b
-11100001b | 01000100b = 11100101b
-11100001b | 01000101b = 11100101b
-11100001b | 01000110b = 11100111b
-11100001b | 01000111b = 11100111b
-11100001b | 01001000b = 11101001b
-11100001b | 01001001b = 11101001b
-11100001b | 01001010b = 11101011b
-11100001b | 01001011b = 11101011b
-11100001b | 01001100b = 11101101b
-11100001b | 01001101b = 11101101b
-11100001b | 01001110b = 11101111b
-11100001b | 01001111b = 11101111b
-11100001b | 01010000b = 11110001b
-11100001b | 01010001b = 11110001b
-11100001b | 01010010b = 11110011b
-11100001b | 01010011b = 11110011b
-11100001b | 01010100b = 11110101b
-11100001b | 01010101b = 11110101b
-11100001b | 01010110b = 11110111b
-11100001b | 01010111b = 11110111b
-11100001b | 01011000b = 11111001b
-11100001b | 01011001b = 11111001b
-11100001b | 01011010b = 11111011b
-11100001b | 01011011b = 11111011b
-11100001b | 01011100b = 11111101b
-11100001b | 01011101b = 11111101b
-11100001b | 01011110b = 11111111b
-11100001b | 01011111b = 11111111b
-11100001b | 01100000b = 11100001b
-11100001b | 01100001b = 11100001b
-11100001b | 01100010b = 11100011b
-11100001b | 01100011b = 11100011b
-11100001b | 01100100b = 11100101b
-11100001b | 01100101b = 11100101b
-11100001b | 01100110b = 11100111b
-11100001b | 01100111b = 11100111b
-11100001b | 01101000b = 11101001b
-11100001b | 01101001b = 11101001b
-11100001b | 01101010b = 11101011b
-11100001b | 01101011b = 11101011b
-11100001b | 01101100b = 11101101b
-11100001b | 01101101b = 11101101b
-11100001b | 01101110b = 11101111b
-11100001b | 01101111b = 11101111b
-11100001b | 01110000b = 11110001b
-11100001b | 01110001b = 11110001b
-11100001b | 01110010b = 11110011b
-11100001b | 01110011b = 11110011b
-11100001b | 01110100b = 11110101b
-11100001b | 01110101b = 11110101b
-11100001b | 01110110b = 11110111b
-11100001b | 01110111b = 11110111b
-11100001b | 01111000b = 11111001b
-11100001b | 01111001b = 11111001b
-11100001b | 01111010b = 11111011b
-11100001b | 01111011b = 11111011b
-11100001b | 01111100b = 11111101b
-11100001b | 01111101b = 11111101b
-11100001b | 01111110b = 11111111b
-11100010b | 10000000b = 11100010b
-11100010b | 10000001b = 11100011b
-11100010b | 10000010b = 11100010b
-11100010b | 10000011b = 11100011b
-11100010b | 10000100b = 11100110b
-11100010b | 10000101b = 11100111b
-11100010b | 10000110b = 11100110b
-11100010b | 10000111b = 11100111b
-11100010b | 10001000b = 11101010b
-11100010b | 10001001b = 11101011b
-11100010b | 10001010b = 11101010b
-11100010b | 10001011b = 11101011b
-11100010b | 10001100b = 11101110b
-11100010b | 10001101b = 11101111b
-11100010b | 10001110b = 11101110b
-11100010b | 10001111b = 11101111b
-11100010b | 10010000b = 11110010b
-11100010b | 10010001b = 11110011b
-11100010b | 10010010b = 11110010b
-11100010b | 10010011b = 11110011b
-11100010b | 10010100b = 11110110b
-11100010b | 10010101b = 11110111b
-11100010b | 10010110b = 11110110b
-11100010b | 10010111b = 11110111b
-11100010b | 10011000b = 11111010b
-11100010b | 10011001b = 11111011b
-11100010b | 10011010b = 11111010b
-11100010b | 10011011b = 11111011b
-11100010b | 10011100b = 11111110b
-11100010b | 10011101b = 11111111b
-11100010b | 10011110b = 11111110b
-11100010b | 10011111b = 11111111b
-11100010b | 10100000b = 11100010b
-11100010b | 10100001b = 11100011b
-11100010b | 10100010b = 11100010b
-11100010b | 10100011b = 11100011b
-11100010b | 10100100b = 11100110b
-11100010b | 10100101b = 11100111b
-11100010b | 10100110b = 11100110b
-11100010b | 10100111b = 11100111b
-11100010b | 10101000b = 11101010b
-11100010b | 10101001b = 11101011b
-11100010b | 10101010b = 11101010b
-11100010b | 10101011b = 11101011b
-11100010b | 10101100b = 11101110b
-11100010b | 10101101b = 11101111b
-11100010b | 10101110b = 11101110b
-11100010b | 10101111b = 11101111b
-11100010b | 10110000b = 11110010b
-11100010b | 10110001b = 11110011b
-11100010b | 10110010b = 11110010b
-11100010b | 10110011b = 11110011b
-11100010b | 10110100b = 11110110b
-11100010b | 10110101b = 11110111b
-11100010b | 10110110b = 11110110b
-11100010b | 10110111b = 11110111b
-11100010b | 10111000b = 11111010b
-11100010b | 10111001b = 11111011b
-11100010b | 10111010b = 11111010b
-11100010b | 10111011b = 11111011b
-11100010b | 10111100b = 11111110b
-11100010b | 10111101b = 11111111b
-11100010b | 10111110b = 11111110b
-11100010b | 10111111b = 11111111b
-11100010b | 11000000b = 11100010b
-11100010b | 11000001b = 11100011b
-11100010b | 11000010b = 11100010b
-11100010b | 11000011b = 11100011b
-11100010b | 11000100b = 11100110b
-11100010b | 11000101b = 11100111b
-11100010b | 11000110b = 11100110b
-11100010b | 11000111b = 11100111b
-11100010b | 11001000b = 11101010b
-11100010b | 11001001b = 11101011b
-11100010b | 11001010b = 11101010b
-11100010b | 11001011b = 11101011b
-11100010b | 11001100b = 11101110b
-11100010b | 11001101b = 11101111b
-11100010b | 11001110b = 11101110b
-11100010b | 11001111b = 11101111b
-11100010b | 11010000b = 11110010b
-11100010b | 11010001b = 11110011b
-11100010b | 11010010b = 11110010b
-11100010b | 11010011b = 11110011b
-11100010b | 11010100b = 11110110b
-11100010b | 11010101b = 11110111b
-11100010b | 11010110b = 11110110b
-11100010b | 11010111b = 11110111b
-11100010b | 11011000b = 11111010b
-11100010b | 11011001b = 11111011b
-11100010b | 11011010b = 11111010b
-11100010b | 11011011b = 11111011b
-11100010b | 11011100b = 11111110b
-11100010b | 11011101b = 11111111b
-11100010b | 11011110b = 11111110b
-11100010b | 11011111b = 11111111b
-11100010b | 11100000b = 11100010b
-11100010b | 11100001b = 11100011b
-11100010b | 11100010b = 11100010b
-11100010b | 11100011b = 11100011b
-11100010b | 11100100b = 11100110b
-11100010b | 11100101b = 11100111b
-11100010b | 11100110b = 11100110b
-11100010b | 11100111b = 11100111b
-11100010b | 11101000b = 11101010b
-11100010b | 11101001b = 11101011b
-11100010b | 11101010b = 11101010b
-11100010b | 11101011b = 11101011b
-11100010b | 11101100b = 11101110b
-11100010b | 11101101b = 11101111b
-11100010b | 11101110b = 11101110b
-11100010b | 11101111b = 11101111b
-11100010b | 11110000b = 11110010b
-11100010b | 11110001b = 11110011b
-11100010b | 11110010b = 11110010b
-11100010b | 11110011b = 11110011b
-11100010b | 11110100b = 11110110b
-11100010b | 11110101b = 11110111b
-11100010b | 11110110b = 11110110b
-11100010b | 11110111b = 11110111b
-11100010b | 11111000b = 11111010b
-11100010b | 11111001b = 11111011b
-11100010b | 11111010b = 11111010b
-11100010b | 11111011b = 11111011b
-11100010b | 11111100b = 11111110b
-11100010b | 11111101b = 11111111b
-11100010b | 11111110b = 11111110b
-11100010b | 11111111b = 11111111b
-11100010b | 00000000b = 11100010b
-11100010b | 00000001b = 11100011b
-11100010b | 00000010b = 11100010b
-11100010b | 00000011b = 11100011b
-11100010b | 00000100b = 11100110b
-11100010b | 00000101b = 11100111b
-11100010b | 00000110b = 11100110b
-11100010b | 00000111b = 11100111b
-11100010b | 00001000b = 11101010b
-11100010b | 00001001b = 11101011b
-11100010b | 00001010b = 11101010b
-11100010b | 00001011b = 11101011b
-11100010b | 00001100b = 11101110b
-11100010b | 00001101b = 11101111b
-11100010b | 00001110b = 11101110b
-11100010b | 00001111b = 11101111b
-11100010b | 00010000b = 11110010b
-11100010b | 00010001b = 11110011b
-11100010b | 00010010b = 11110010b
-11100010b | 00010011b = 11110011b
-11100010b | 00010100b = 11110110b
-11100010b | 00010101b = 11110111b
-11100010b | 00010110b = 11110110b
-11100010b | 00010111b = 11110111b
-11100010b | 00011000b = 11111010b
-11100010b | 00011001b = 11111011b
-11100010b | 00011010b = 11111010b
-11100010b | 00011011b = 11111011b
-11100010b | 00011100b = 11111110b
-11100010b | 00011101b = 11111111b
-11100010b | 00011110b = 11111110b
-11100010b | 00011111b = 11111111b
-11100010b | 00100000b = 11100010b
-11100010b | 00100001b = 11100011b
-11100010b | 00100010b = 11100010b
-11100010b | 00100011b = 11100011b
-11100010b | 00100100b = 11100110b
-11100010b | 00100101b = 11100111b
-11100010b | 00100110b = 11100110b
-11100010b | 00100111b = 11100111b
-11100010b | 00101000b = 11101010b
-11100010b | 00101001b = 11101011b
-11100010b | 00101010b = 11101010b
-11100010b | 00101011b = 11101011b
-11100010b | 00101100b = 11101110b
-11100010b | 00101101b = 11101111b
-11100010b | 00101110b = 11101110b
-11100010b | 00101111b = 11101111b
-11100010b | 00110000b = 11110010b
-11100010b | 00110001b = 11110011b
-11100010b | 00110010b = 11110010b
-11100010b | 00110011b = 11110011b
-11100010b | 00110100b = 11110110b
-11100010b | 00110101b = 11110111b
-11100010b | 00110110b = 11110110b
-11100010b | 00110111b = 11110111b
-11100010b | 00111000b = 11111010b
-11100010b | 00111001b = 11111011b
-11100010b | 00111010b = 11111010b
-11100010b | 00111011b = 11111011b
-11100010b | 00111100b = 11111110b
-11100010b | 00111101b = 11111111b
-11100010b | 00111110b = 11111110b
-11100010b | 00111111b = 11111111b
-11100010b | 01000000b = 11100010b
-11100010b | 01000001b = 11100011b
-11100010b | 01000010b = 11100010b
-11100010b | 01000011b = 11100011b
-11100010b | 01000100b = 11100110b
-11100010b | 01000101b = 11100111b
-11100010b | 01000110b = 11100110b
-11100010b | 01000111b = 11100111b
-11100010b | 01001000b = 11101010b
-11100010b | 01001001b = 11101011b
-11100010b | 01001010b = 11101010b
-11100010b | 01001011b = 11101011b
-11100010b | 01001100b = 11101110b
-11100010b | 01001101b = 11101111b
-11100010b | 01001110b = 11101110b
-11100010b | 01001111b = 11101111b
-11100010b | 01010000b = 11110010b
-11100010b | 01010001b = 11110011b
-11100010b | 01010010b = 11110010b
-11100010b | 01010011b = 11110011b
-11100010b | 01010100b = 11110110b
-11100010b | 01010101b = 11110111b
-11100010b | 01010110b = 11110110b
-11100010b | 01010111b = 11110111b
-11100010b | 01011000b = 11111010b
-11100010b | 01011001b = 11111011b
-11100010b | 01011010b = 11111010b
-11100010b | 01011011b = 11111011b
-11100010b | 01011100b = 11111110b
-11100010b | 01011101b = 11111111b
-11100010b | 01011110b = 11111110b
-11100010b | 01011111b = 11111111b
-11100010b | 01100000b = 11100010b
-11100010b | 01100001b = 11100011b
-11100010b | 01100010b = 11100010b
-11100010b | 01100011b = 11100011b
-11100010b | 01100100b = 11100110b
-11100010b | 01100101b = 11100111b
-11100010b | 01100110b = 11100110b
-11100010b | 01100111b = 11100111b
-11100010b | 01101000b = 11101010b
-11100010b | 01101001b = 11101011b
-11100010b | 01101010b = 11101010b
-11100010b | 01101011b = 11101011b
-11100010b | 01101100b = 11101110b
-11100010b | 01101101b = 11101111b
-11100010b | 01101110b = 11101110b
-11100010b | 01101111b = 11101111b
-11100010b | 01110000b = 11110010b
-11100010b | 01110001b = 11110011b
-11100010b | 01110010b = 11110010b
-11100010b | 01110011b = 11110011b
-11100010b | 01110100b = 11110110b
-11100010b | 01110101b = 11110111b
-11100010b | 01110110b = 11110110b
-11100010b | 01110111b = 11110111b
-11100010b | 01111000b = 11111010b
-11100010b | 01111001b = 11111011b
-11100010b | 01111010b = 11111010b
-11100010b | 01111011b = 11111011b
-11100010b | 01111100b = 11111110b
-11100010b | 01111101b = 11111111b
-11100010b | 01111110b = 11111110b
-11100011b | 10000000b = 11100011b
-11100011b | 10000001b = 11100011b
-11100011b | 10000010b = 11100011b
-11100011b | 10000011b = 11100011b
-11100011b | 10000100b = 11100111b
-11100011b | 10000101b = 11100111b
-11100011b | 10000110b = 11100111b
-11100011b | 10000111b = 11100111b
-11100011b | 10001000b = 11101011b
-11100011b | 10001001b = 11101011b
-11100011b | 10001010b = 11101011b
-11100011b | 10001011b = 11101011b
-11100011b | 10001100b = 11101111b
-11100011b | 10001101b = 11101111b
-11100011b | 10001110b = 11101111b
-11100011b | 10001111b = 11101111b
-11100011b | 10010000b = 11110011b
-11100011b | 10010001b = 11110011b
-11100011b | 10010010b = 11110011b
-11100011b | 10010011b = 11110011b
-11100011b | 10010100b = 11110111b
-11100011b | 10010101b = 11110111b
-11100011b | 10010110b = 11110111b
-11100011b | 10010111b = 11110111b
-11100011b | 10011000b = 11111011b
-11100011b | 10011001b = 11111011b
-11100011b | 10011010b = 11111011b
-11100011b | 10011011b = 11111011b
-11100011b | 10011100b = 11111111b
-11100011b | 10011101b = 11111111b
-11100011b | 10011110b = 11111111b
-11100011b | 10011111b = 11111111b
-11100011b | 10100000b = 11100011b
-11100011b | 10100001b = 11100011b
-11100011b | 10100010b = 11100011b
-11100011b | 10100011b = 11100011b
-11100011b | 10100100b = 11100111b
-11100011b | 10100101b = 11100111b
-11100011b | 10100110b = 11100111b
-11100011b | 10100111b = 11100111b
-11100011b | 10101000b = 11101011b
-11100011b | 10101001b = 11101011b
-11100011b | 10101010b = 11101011b
-11100011b | 10101011b = 11101011b
-11100011b | 10101100b = 11101111b
-11100011b | 10101101b = 11101111b
-11100011b | 10101110b = 11101111b
-11100011b | 10101111b = 11101111b
-11100011b | 10110000b = 11110011b
-11100011b | 10110001b = 11110011b
-11100011b | 10110010b = 11110011b
-11100011b | 10110011b = 11110011b
-11100011b | 10110100b = 11110111b
-11100011b | 10110101b = 11110111b
-11100011b | 10110110b = 11110111b
-11100011b | 10110111b = 11110111b
-11100011b | 10111000b = 11111011b
-11100011b | 10111001b = 11111011b
-11100011b | 10111010b = 11111011b
-11100011b | 10111011b = 11111011b
-11100011b | 10111100b = 11111111b
-11100011b | 10111101b = 11111111b
-11100011b | 10111110b = 11111111b
-11100011b | 10111111b = 11111111b
-11100011b | 11000000b = 11100011b
-11100011b | 11000001b = 11100011b
-11100011b | 11000010b = 11100011b
-11100011b | 11000011b = 11100011b
-11100011b | 11000100b = 11100111b
-11100011b | 11000101b = 11100111b
-11100011b | 11000110b = 11100111b
-11100011b | 11000111b = 11100111b
-11100011b | 11001000b = 11101011b
-11100011b | 11001001b = 11101011b
-11100011b | 11001010b = 11101011b
-11100011b | 11001011b = 11101011b
-11100011b | 11001100b = 11101111b
-11100011b | 11001101b = 11101111b
-11100011b | 11001110b = 11101111b
-11100011b | 11001111b = 11101111b
-11100011b | 11010000b = 11110011b
-11100011b | 11010001b = 11110011b
-11100011b | 11010010b = 11110011b
-11100011b | 11010011b = 11110011b
-11100011b | 11010100b = 11110111b
-11100011b | 11010101b = 11110111b
-11100011b | 11010110b = 11110111b
-11100011b | 11010111b = 11110111b
-11100011b | 11011000b = 11111011b
-11100011b | 11011001b = 11111011b
-11100011b | 11011010b = 11111011b
-11100011b | 11011011b = 11111011b
-11100011b | 11011100b = 11111111b
-11100011b | 11011101b = 11111111b
-11100011b | 11011110b = 11111111b
-11100011b | 11011111b = 11111111b
-11100011b | 11100000b = 11100011b
-11100011b | 11100001b = 11100011b
-11100011b | 11100010b = 11100011b
-11100011b | 11100011b = 11100011b
-11100011b | 11100100b = 11100111b
-11100011b | 11100101b = 11100111b
-11100011b | 11100110b = 11100111b
-11100011b | 11100111b = 11100111b
-11100011b | 11101000b = 11101011b
-11100011b | 11101001b = 11101011b
-11100011b | 11101010b = 11101011b
-11100011b | 11101011b = 11101011b
-11100011b | 11101100b = 11101111b
-11100011b | 11101101b = 11101111b
-11100011b | 11101110b = 11101111b
-11100011b | 11101111b = 11101111b
-11100011b | 11110000b = 11110011b
-11100011b | 11110001b = 11110011b
-11100011b | 11110010b = 11110011b
-11100011b | 11110011b = 11110011b
-11100011b | 11110100b = 11110111b
-11100011b | 11110101b = 11110111b
-11100011b | 11110110b = 11110111b
-11100011b | 11110111b = 11110111b
-11100011b | 11111000b = 11111011b
-11100011b | 11111001b = 11111011b
-11100011b | 11111010b = 11111011b
-11100011b | 11111011b = 11111011b
-11100011b | 11111100b = 11111111b
-11100011b | 11111101b = 11111111b
-11100011b | 11111110b = 11111111b
-11100011b | 11111111b = 11111111b
-11100011b | 00000000b = 11100011b
-11100011b | 00000001b = 11100011b
-11100011b | 00000010b = 11100011b
-11100011b | 00000011b = 11100011b
-11100011b | 00000100b = 11100111b
-11100011b | 00000101b = 11100111b
-11100011b | 00000110b = 11100111b
-11100011b | 00000111b = 11100111b
-11100011b | 00001000b = 11101011b
-11100011b | 00001001b = 11101011b
-11100011b | 00001010b = 11101011b
-11100011b | 00001011b = 11101011b
-11100011b | 00001100b = 11101111b
-11100011b | 00001101b = 11101111b
-11100011b | 00001110b = 11101111b
-11100011b | 00001111b = 11101111b
-11100011b | 00010000b = 11110011b
-11100011b | 00010001b = 11110011b
-11100011b | 00010010b = 11110011b
-11100011b | 00010011b = 11110011b
-11100011b | 00010100b = 11110111b
-11100011b | 00010101b = 11110111b
-11100011b | 00010110b = 11110111b
-11100011b | 00010111b = 11110111b
-11100011b | 00011000b = 11111011b
-11100011b | 00011001b = 11111011b
-11100011b | 00011010b = 11111011b
-11100011b | 00011011b = 11111011b
-11100011b | 00011100b = 11111111b
-11100011b | 00011101b = 11111111b
-11100011b | 00011110b = 11111111b
-11100011b | 00011111b = 11111111b
-11100011b | 00100000b = 11100011b
-11100011b | 00100001b = 11100011b
-11100011b | 00100010b = 11100011b
-11100011b | 00100011b = 11100011b
-11100011b | 00100100b = 11100111b
-11100011b | 00100101b = 11100111b
-11100011b | 00100110b = 11100111b
-11100011b | 00100111b = 11100111b
-11100011b | 00101000b = 11101011b
-11100011b | 00101001b = 11101011b
-11100011b | 00101010b = 11101011b
-11100011b | 00101011b = 11101011b
-11100011b | 00101100b = 11101111b
-11100011b | 00101101b = 11101111b
-11100011b | 00101110b = 11101111b
-11100011b | 00101111b = 11101111b
-11100011b | 00110000b = 11110011b
-11100011b | 00110001b = 11110011b
-11100011b | 00110010b = 11110011b
-11100011b | 00110011b = 11110011b
-11100011b | 00110100b = 11110111b
-11100011b | 00110101b = 11110111b
-11100011b | 00110110b = 11110111b
-11100011b | 00110111b = 11110111b
-11100011b | 00111000b = 11111011b
-11100011b | 00111001b = 11111011b
-11100011b | 00111010b = 11111011b
-11100011b | 00111011b = 11111011b
-11100011b | 00111100b = 11111111b
-11100011b | 00111101b = 11111111b
-11100011b | 00111110b = 11111111b
-11100011b | 00111111b = 11111111b
-11100011b | 01000000b = 11100011b
-11100011b | 01000001b = 11100011b
-11100011b | 01000010b = 11100011b
-11100011b | 01000011b = 11100011b
-11100011b | 01000100b = 11100111b
-11100011b | 01000101b = 11100111b
-11100011b | 01000110b = 11100111b
-11100011b | 01000111b = 11100111b
-11100011b | 01001000b = 11101011b
-11100011b | 01001001b = 11101011b
-11100011b | 01001010b = 11101011b
-11100011b | 01001011b = 11101011b
-11100011b | 01001100b = 11101111b
-11100011b | 01001101b = 11101111b
-11100011b | 01001110b = 11101111b
-11100011b | 01001111b = 11101111b
-11100011b | 01010000b = 11110011b
-11100011b | 01010001b = 11110011b
-11100011b | 01010010b = 11110011b
-11100011b | 01010011b = 11110011b
-11100011b | 01010100b = 11110111b
-11100011b | 01010101b = 11110111b
-11100011b | 01010110b = 11110111b
-11100011b | 01010111b = 11110111b
-11100011b | 01011000b = 11111011b
-11100011b | 01011001b = 11111011b
-11100011b | 01011010b = 11111011b
-11100011b | 01011011b = 11111011b
-11100011b | 01011100b = 11111111b
-11100011b | 01011101b = 11111111b
-11100011b | 01011110b = 11111111b
-11100011b | 01011111b = 11111111b
-11100011b | 01100000b = 11100011b
-11100011b | 01100001b = 11100011b
-11100011b | 01100010b = 11100011b
-11100011b | 01100011b = 11100011b
-11100011b | 01100100b = 11100111b
-11100011b | 01100101b = 11100111b
-11100011b | 01100110b = 11100111b
-11100011b | 01100111b = 11100111b
-11100011b | 01101000b = 11101011b
-11100011b | 01101001b = 11101011b
-11100011b | 01101010b = 11101011b
-11100011b | 01101011b = 11101011b
-11100011b | 01101100b = 11101111b
-11100011b | 01101101b = 11101111b
-11100011b | 01101110b = 11101111b
-11100011b | 01101111b = 11101111b
-11100011b | 01110000b = 11110011b
-11100011b | 01110001b = 11110011b
-11100011b | 01110010b = 11110011b
-11100011b | 01110011b = 11110011b
-11100011b | 01110100b = 11110111b
-11100011b | 01110101b = 11110111b
-11100011b | 01110110b = 11110111b
-11100011b | 01110111b = 11110111b
-11100011b | 01111000b = 11111011b
-11100011b | 01111001b = 11111011b
-11100011b | 01111010b = 11111011b
-11100011b | 01111011b = 11111011b
-11100011b | 01111100b = 11111111b
-11100011b | 01111101b = 11111111b
-11100011b | 01111110b = 11111111b
-11100100b | 10000000b = 11100100b
-11100100b | 10000001b = 11100101b
-11100100b | 10000010b = 11100110b
-11100100b | 10000011b = 11100111b
-11100100b | 10000100b = 11100100b
-11100100b | 10000101b = 11100101b
-11100100b | 10000110b = 11100110b
-11100100b | 10000111b = 11100111b
-11100100b | 10001000b = 11101100b
-11100100b | 10001001b = 11101101b
-11100100b | 10001010b = 11101110b
-11100100b | 10001011b = 11101111b
-11100100b | 10001100b = 11101100b
-11100100b | 10001101b = 11101101b
-11100100b | 10001110b = 11101110b
-11100100b | 10001111b = 11101111b
-11100100b | 10010000b = 11110100b
-11100100b | 10010001b = 11110101b
-11100100b | 10010010b = 11110110b
-11100100b | 10010011b = 11110111b
-11100100b | 10010100b = 11110100b
-11100100b | 10010101b = 11110101b
-11100100b | 10010110b = 11110110b
-11100100b | 10010111b = 11110111b
-11100100b | 10011000b = 11111100b
-11100100b | 10011001b = 11111101b
-11100100b | 10011010b = 11111110b
-11100100b | 10011011b = 11111111b
-11100100b | 10011100b = 11111100b
-11100100b | 10011101b = 11111101b
-11100100b | 10011110b = 11111110b
-11100100b | 10011111b = 11111111b
-11100100b | 10100000b = 11100100b
-11100100b | 10100001b = 11100101b
-11100100b | 10100010b = 11100110b
-11100100b | 10100011b = 11100111b
-11100100b | 10100100b = 11100100b
-11100100b | 10100101b = 11100101b
-11100100b | 10100110b = 11100110b
-11100100b | 10100111b = 11100111b
-11100100b | 10101000b = 11101100b
-11100100b | 10101001b = 11101101b
-11100100b | 10101010b = 11101110b
-11100100b | 10101011b = 11101111b
-11100100b | 10101100b = 11101100b
-11100100b | 10101101b = 11101101b
-11100100b | 10101110b = 11101110b
-11100100b | 10101111b = 11101111b
-11100100b | 10110000b = 11110100b
-11100100b | 10110001b = 11110101b
-11100100b | 10110010b = 11110110b
-11100100b | 10110011b = 11110111b
-11100100b | 10110100b = 11110100b
-11100100b | 10110101b = 11110101b
-11100100b | 10110110b = 11110110b
-11100100b | 10110111b = 11110111b
-11100100b | 10111000b = 11111100b
-11100100b | 10111001b = 11111101b
-11100100b | 10111010b = 11111110b
-11100100b | 10111011b = 11111111b
-11100100b | 10111100b = 11111100b
-11100100b | 10111101b = 11111101b
-11100100b | 10111110b = 11111110b
-11100100b | 10111111b = 11111111b
-11100100b | 11000000b = 11100100b
-11100100b | 11000001b = 11100101b
-11100100b | 11000010b = 11100110b
-11100100b | 11000011b = 11100111b
-11100100b | 11000100b = 11100100b
-11100100b | 11000101b = 11100101b
-11100100b | 11000110b = 11100110b
-11100100b | 11000111b = 11100111b
-11100100b | 11001000b = 11101100b
-11100100b | 11001001b = 11101101b
-11100100b | 11001010b = 11101110b
-11100100b | 11001011b = 11101111b
-11100100b | 11001100b = 11101100b
-11100100b | 11001101b = 11101101b
-11100100b | 11001110b = 11101110b
-11100100b | 11001111b = 11101111b
-11100100b | 11010000b = 11110100b
-11100100b | 11010001b = 11110101b
-11100100b | 11010010b = 11110110b
-11100100b | 11010011b = 11110111b
-11100100b | 11010100b = 11110100b
-11100100b | 11010101b = 11110101b
-11100100b | 11010110b = 11110110b
-11100100b | 11010111b = 11110111b
-11100100b | 11011000b = 11111100b
-11100100b | 11011001b = 11111101b
-11100100b | 11011010b = 11111110b
-11100100b | 11011011b = 11111111b
-11100100b | 11011100b = 11111100b
-11100100b | 11011101b = 11111101b
-11100100b | 11011110b = 11111110b
-11100100b | 11011111b = 11111111b
-11100100b | 11100000b = 11100100b
-11100100b | 11100001b = 11100101b
-11100100b | 11100010b = 11100110b
-11100100b | 11100011b = 11100111b
-11100100b | 11100100b = 11100100b
-11100100b | 11100101b = 11100101b
-11100100b | 11100110b = 11100110b
-11100100b | 11100111b = 11100111b
-11100100b | 11101000b = 11101100b
-11100100b | 11101001b = 11101101b
-11100100b | 11101010b = 11101110b
-11100100b | 11101011b = 11101111b
-11100100b | 11101100b = 11101100b
-11100100b | 11101101b = 11101101b
-11100100b | 11101110b = 11101110b
-11100100b | 11101111b = 11101111b
-11100100b | 11110000b = 11110100b
-11100100b | 11110001b = 11110101b
-11100100b | 11110010b = 11110110b
-11100100b | 11110011b = 11110111b
-11100100b | 11110100b = 11110100b
-11100100b | 11110101b = 11110101b
-11100100b | 11110110b = 11110110b
-11100100b | 11110111b = 11110111b
-11100100b | 11111000b = 11111100b
-11100100b | 11111001b = 11111101b
-11100100b | 11111010b = 11111110b
-11100100b | 11111011b = 11111111b
-11100100b | 11111100b = 11111100b
-11100100b | 11111101b = 11111101b
-11100100b | 11111110b = 11111110b
-11100100b | 11111111b = 11111111b
-11100100b | 00000000b = 11100100b
-11100100b | 00000001b = 11100101b
-11100100b | 00000010b = 11100110b
-11100100b | 00000011b = 11100111b
-11100100b | 00000100b = 11100100b
-11100100b | 00000101b = 11100101b
-11100100b | 00000110b = 11100110b
-11100100b | 00000111b = 11100111b
-11100100b | 00001000b = 11101100b
-11100100b | 00001001b = 11101101b
-11100100b | 00001010b = 11101110b
-11100100b | 00001011b = 11101111b
-11100100b | 00001100b = 11101100b
-11100100b | 00001101b = 11101101b
-11100100b | 00001110b = 11101110b
-11100100b | 00001111b = 11101111b
-11100100b | 00010000b = 11110100b
-11100100b | 00010001b = 11110101b
-11100100b | 00010010b = 11110110b
-11100100b | 00010011b = 11110111b
-11100100b | 00010100b = 11110100b
-11100100b | 00010101b = 11110101b
-11100100b | 00010110b = 11110110b
-11100100b | 00010111b = 11110111b
-11100100b | 00011000b = 11111100b
-11100100b | 00011001b = 11111101b
-11100100b | 00011010b = 11111110b
-11100100b | 00011011b = 11111111b
-11100100b | 00011100b = 11111100b
-11100100b | 00011101b = 11111101b
-11100100b | 00011110b = 11111110b
-11100100b | 00011111b = 11111111b
-11100100b | 00100000b = 11100100b
-11100100b | 00100001b = 11100101b
-11100100b | 00100010b = 11100110b
-11100100b | 00100011b = 11100111b
-11100100b | 00100100b = 11100100b
-11100100b | 00100101b = 11100101b
-11100100b | 00100110b = 11100110b
-11100100b | 00100111b = 11100111b
-11100100b | 00101000b = 11101100b
-11100100b | 00101001b = 11101101b
-11100100b | 00101010b = 11101110b
-11100100b | 00101011b = 11101111b
-11100100b | 00101100b = 11101100b
-11100100b | 00101101b = 11101101b
-11100100b | 00101110b = 11101110b
-11100100b | 00101111b = 11101111b
-11100100b | 00110000b = 11110100b
-11100100b | 00110001b = 11110101b
-11100100b | 00110010b = 11110110b
-11100100b | 00110011b = 11110111b
-11100100b | 00110100b = 11110100b
-11100100b | 00110101b = 11110101b
-11100100b | 00110110b = 11110110b
-11100100b | 00110111b = 11110111b
-11100100b | 00111000b = 11111100b
-11100100b | 00111001b = 11111101b
-11100100b | 00111010b = 11111110b
-11100100b | 00111011b = 11111111b
-11100100b | 00111100b = 11111100b
-11100100b | 00111101b = 11111101b
-11100100b | 00111110b = 11111110b
-11100100b | 00111111b = 11111111b
-11100100b | 01000000b = 11100100b
-11100100b | 01000001b = 11100101b
-11100100b | 01000010b = 11100110b
-11100100b | 01000011b = 11100111b
-11100100b | 01000100b = 11100100b
-11100100b | 01000101b = 11100101b
-11100100b | 01000110b = 11100110b
-11100100b | 01000111b = 11100111b
-11100100b | 01001000b = 11101100b
-11100100b | 01001001b = 11101101b
-11100100b | 01001010b = 11101110b
-11100100b | 01001011b = 11101111b
-11100100b | 01001100b = 11101100b
-11100100b | 01001101b = 11101101b
-11100100b | 01001110b = 11101110b
-11100100b | 01001111b = 11101111b
-11100100b | 01010000b = 11110100b
-11100100b | 01010001b = 11110101b
-11100100b | 01010010b = 11110110b
-11100100b | 01010011b = 11110111b
-11100100b | 01010100b = 11110100b
-11100100b | 01010101b = 11110101b
-11100100b | 01010110b = 11110110b
-11100100b | 01010111b = 11110111b
-11100100b | 01011000b = 11111100b
-11100100b | 01011001b = 11111101b
-11100100b | 01011010b = 11111110b
-11100100b | 01011011b = 11111111b
-11100100b | 01011100b = 11111100b
-11100100b | 01011101b = 11111101b
-11100100b | 01011110b = 11111110b
-11100100b | 01011111b = 11111111b
-11100100b | 01100000b = 11100100b
-11100100b | 01100001b = 11100101b
-11100100b | 01100010b = 11100110b
-11100100b | 01100011b = 11100111b
-11100100b | 01100100b = 11100100b
-11100100b | 01100101b = 11100101b
-11100100b | 01100110b = 11100110b
-11100100b | 01100111b = 11100111b
-11100100b | 01101000b = 11101100b
-11100100b | 01101001b = 11101101b
-11100100b | 01101010b = 11101110b
-11100100b | 01101011b = 11101111b
-11100100b | 01101100b = 11101100b
-11100100b | 01101101b = 11101101b
-11100100b | 01101110b = 11101110b
-11100100b | 01101111b = 11101111b
-11100100b | 01110000b = 11110100b
-11100100b | 01110001b = 11110101b
-11100100b | 01110010b = 11110110b
-11100100b | 01110011b = 11110111b
-11100100b | 01110100b = 11110100b
-11100100b | 01110101b = 11110101b
-11100100b | 01110110b = 11110110b
-11100100b | 01110111b = 11110111b
-11100100b | 01111000b = 11111100b
-11100100b | 01111001b = 11111101b
-11100100b | 01111010b = 11111110b
-11100100b | 01111011b = 11111111b
-11100100b | 01111100b = 11111100b
-11100100b | 01111101b = 11111101b
-11100100b | 01111110b = 11111110b
-11100101b | 10000000b = 11100101b
-11100101b | 10000001b = 11100101b
-11100101b | 10000010b = 11100111b
-11100101b | 10000011b = 11100111b
-11100101b | 10000100b = 11100101b
-11100101b | 10000101b = 11100101b
-11100101b | 10000110b = 11100111b
-11100101b | 10000111b = 11100111b
-11100101b | 10001000b = 11101101b
-11100101b | 10001001b = 11101101b
-11100101b | 10001010b = 11101111b
-11100101b | 10001011b = 11101111b
-11100101b | 10001100b = 11101101b
-11100101b | 10001101b = 11101101b
-11100101b | 10001110b = 11101111b
-11100101b | 10001111b = 11101111b
-11100101b | 10010000b = 11110101b
-11100101b | 10010001b = 11110101b
-11100101b | 10010010b = 11110111b
-11100101b | 10010011b = 11110111b
-11100101b | 10010100b = 11110101b
-11100101b | 10010101b = 11110101b
-11100101b | 10010110b = 11110111b
-11100101b | 10010111b = 11110111b
-11100101b | 10011000b = 11111101b
-11100101b | 10011001b = 11111101b
-11100101b | 10011010b = 11111111b
-11100101b | 10011011b = 11111111b
-11100101b | 10011100b = 11111101b
-11100101b | 10011101b = 11111101b
-11100101b | 10011110b = 11111111b
-11100101b | 10011111b = 11111111b
-11100101b | 10100000b = 11100101b
-11100101b | 10100001b = 11100101b
-11100101b | 10100010b = 11100111b
-11100101b | 10100011b = 11100111b
-11100101b | 10100100b = 11100101b
-11100101b | 10100101b = 11100101b
-11100101b | 10100110b = 11100111b
-11100101b | 10100111b = 11100111b
-11100101b | 10101000b = 11101101b
-11100101b | 10101001b = 11101101b
-11100101b | 10101010b = 11101111b
-11100101b | 10101011b = 11101111b
-11100101b | 10101100b = 11101101b
-11100101b | 10101101b = 11101101b
-11100101b | 10101110b = 11101111b
-11100101b | 10101111b = 11101111b
-11100101b | 10110000b = 11110101b
-11100101b | 10110001b = 11110101b
-11100101b | 10110010b = 11110111b
-11100101b | 10110011b = 11110111b
-11100101b | 10110100b = 11110101b
-11100101b | 10110101b = 11110101b
-11100101b | 10110110b = 11110111b
-11100101b | 10110111b = 11110111b
-11100101b | 10111000b = 11111101b
-11100101b | 10111001b = 11111101b
-11100101b | 10111010b = 11111111b
-11100101b | 10111011b = 11111111b
-11100101b | 10111100b = 11111101b
-11100101b | 10111101b = 11111101b
-11100101b | 10111110b = 11111111b
-11100101b | 10111111b = 11111111b
-11100101b | 11000000b = 11100101b
-11100101b | 11000001b = 11100101b
-11100101b | 11000010b = 11100111b
-11100101b | 11000011b = 11100111b
-11100101b | 11000100b = 11100101b
-11100101b | 11000101b = 11100101b
-11100101b | 11000110b = 11100111b
-11100101b | 11000111b = 11100111b
-11100101b | 11001000b = 11101101b
-11100101b | 11001001b = 11101101b
-11100101b | 11001010b = 11101111b
-11100101b | 11001011b = 11101111b
-11100101b | 11001100b = 11101101b
-11100101b | 11001101b = 11101101b
-11100101b | 11001110b = 11101111b
-11100101b | 11001111b = 11101111b
-11100101b | 11010000b = 11110101b
-11100101b | 11010001b = 11110101b
-11100101b | 11010010b = 11110111b
-11100101b | 11010011b = 11110111b
-11100101b | 11010100b = 11110101b
-11100101b | 11010101b = 11110101b
-11100101b | 11010110b = 11110111b
-11100101b | 11010111b = 11110111b
-11100101b | 11011000b = 11111101b
-11100101b | 11011001b = 11111101b
-11100101b | 11011010b = 11111111b
-11100101b | 11011011b = 11111111b
-11100101b | 11011100b = 11111101b
-11100101b | 11011101b = 11111101b
-11100101b | 11011110b = 11111111b
-11100101b | 11011111b = 11111111b
-11100101b | 11100000b = 11100101b
-11100101b | 11100001b = 11100101b
-11100101b | 11100010b = 11100111b
-11100101b | 11100011b = 11100111b
-11100101b | 11100100b = 11100101b
-11100101b | 11100101b = 11100101b
-11100101b | 11100110b = 11100111b
-11100101b | 11100111b = 11100111b
-11100101b | 11101000b = 11101101b
-11100101b | 11101001b = 11101101b
-11100101b | 11101010b = 11101111b
-11100101b | 11101011b = 11101111b
-11100101b | 11101100b = 11101101b
-11100101b | 11101101b = 11101101b
-11100101b | 11101110b = 11101111b
-11100101b | 11101111b = 11101111b
-11100101b | 11110000b = 11110101b
-11100101b | 11110001b = 11110101b
-11100101b | 11110010b = 11110111b
-11100101b | 11110011b = 11110111b
-11100101b | 11110100b = 11110101b
-11100101b | 11110101b = 11110101b
-11100101b | 11110110b = 11110111b
-11100101b | 11110111b = 11110111b
-11100101b | 11111000b = 11111101b
-11100101b | 11111001b = 11111101b
-11100101b | 11111010b = 11111111b
-11100101b | 11111011b = 11111111b
-11100101b | 11111100b = 11111101b
-11100101b | 11111101b = 11111101b
-11100101b | 11111110b = 11111111b
-11100101b | 11111111b = 11111111b
-11100101b | 00000000b = 11100101b
-11100101b | 00000001b = 11100101b
-11100101b | 00000010b = 11100111b
-11100101b | 00000011b = 11100111b
-11100101b | 00000100b = 11100101b
-11100101b | 00000101b = 11100101b
-11100101b | 00000110b = 11100111b
-11100101b | 00000111b = 11100111b
-11100101b | 00001000b = 11101101b
-11100101b | 00001001b = 11101101b
-11100101b | 00001010b = 11101111b
-11100101b | 00001011b = 11101111b
-11100101b | 00001100b = 11101101b
-11100101b | 00001101b = 11101101b
-11100101b | 00001110b = 11101111b
-11100101b | 00001111b = 11101111b
-11100101b | 00010000b = 11110101b
-11100101b | 00010001b = 11110101b
-11100101b | 00010010b = 11110111b
-11100101b | 00010011b = 11110111b
-11100101b | 00010100b = 11110101b
-11100101b | 00010101b = 11110101b
-11100101b | 00010110b = 11110111b
-11100101b | 00010111b = 11110111b
-11100101b | 00011000b = 11111101b
-11100101b | 00011001b = 11111101b
-11100101b | 00011010b = 11111111b
-11100101b | 00011011b = 11111111b
-11100101b | 00011100b = 11111101b
-11100101b | 00011101b = 11111101b
-11100101b | 00011110b = 11111111b
-11100101b | 00011111b = 11111111b
-11100101b | 00100000b = 11100101b
-11100101b | 00100001b = 11100101b
-11100101b | 00100010b = 11100111b
-11100101b | 00100011b = 11100111b
-11100101b | 00100100b = 11100101b
-11100101b | 00100101b = 11100101b
-11100101b | 00100110b = 11100111b
-11100101b | 00100111b = 11100111b
-11100101b | 00101000b = 11101101b
-11100101b | 00101001b = 11101101b
-11100101b | 00101010b = 11101111b
-11100101b | 00101011b = 11101111b
-11100101b | 00101100b = 11101101b
-11100101b | 00101101b = 11101101b
-11100101b | 00101110b = 11101111b
-11100101b | 00101111b = 11101111b
-11100101b | 00110000b = 11110101b
-11100101b | 00110001b = 11110101b
-11100101b | 00110010b = 11110111b
-11100101b | 00110011b = 11110111b
-11100101b | 00110100b = 11110101b
-11100101b | 00110101b = 11110101b
-11100101b | 00110110b = 11110111b
-11100101b | 00110111b = 11110111b
-11100101b | 00111000b = 11111101b
-11100101b | 00111001b = 11111101b
-11100101b | 00111010b = 11111111b
-11100101b | 00111011b = 11111111b
-11100101b | 00111100b = 11111101b
-11100101b | 00111101b = 11111101b
-11100101b | 00111110b = 11111111b
-11100101b | 00111111b = 11111111b
-11100101b | 01000000b = 11100101b
-11100101b | 01000001b = 11100101b
-11100101b | 01000010b = 11100111b
-11100101b | 01000011b = 11100111b
-11100101b | 01000100b = 11100101b
-11100101b | 01000101b = 11100101b
-11100101b | 01000110b = 11100111b
-11100101b | 01000111b = 11100111b
-11100101b | 01001000b = 11101101b
-11100101b | 01001001b = 11101101b
-11100101b | 01001010b = 11101111b
-11100101b | 01001011b = 11101111b
-11100101b | 01001100b = 11101101b
-11100101b | 01001101b = 11101101b
-11100101b | 01001110b = 11101111b
-11100101b | 01001111b = 11101111b
-11100101b | 01010000b = 11110101b
-11100101b | 01010001b = 11110101b
-11100101b | 01010010b = 11110111b
-11100101b | 01010011b = 11110111b
-11100101b | 01010100b = 11110101b
-11100101b | 01010101b = 11110101b
-11100101b | 01010110b = 11110111b
-11100101b | 01010111b = 11110111b
-11100101b | 01011000b = 11111101b
-11100101b | 01011001b = 11111101b
-11100101b | 01011010b = 11111111b
-11100101b | 01011011b = 11111111b
-11100101b | 01011100b = 11111101b
-11100101b | 01011101b = 11111101b
-11100101b | 01011110b = 11111111b
-11100101b | 01011111b = 11111111b
-11100101b | 01100000b = 11100101b
-11100101b | 01100001b = 11100101b
-11100101b | 01100010b = 11100111b
-11100101b | 01100011b = 11100111b
-11100101b | 01100100b = 11100101b
-11100101b | 01100101b = 11100101b
-11100101b | 01100110b = 11100111b
-11100101b | 01100111b = 11100111b
-11100101b | 01101000b = 11101101b
-11100101b | 01101001b = 11101101b
-11100101b | 01101010b = 11101111b
-11100101b | 01101011b = 11101111b
-11100101b | 01101100b = 11101101b
-11100101b | 01101101b = 11101101b
-11100101b | 01101110b = 11101111b
-11100101b | 01101111b = 11101111b
-11100101b | 01110000b = 11110101b
-11100101b | 01110001b = 11110101b
-11100101b | 01110010b = 11110111b
-11100101b | 01110011b = 11110111b
-11100101b | 01110100b = 11110101b
-11100101b | 01110101b = 11110101b
-11100101b | 01110110b = 11110111b
-11100101b | 01110111b = 11110111b
-11100101b | 01111000b = 11111101b
-11100101b | 01111001b = 11111101b
-11100101b | 01111010b = 11111111b
-11100101b | 01111011b = 11111111b
-11100101b | 01111100b = 11111101b
-11100101b | 01111101b = 11111101b
-11100101b | 01111110b = 11111111b
-11100110b | 10000000b = 11100110b
-11100110b | 10000001b = 11100111b
-11100110b | 10000010b = 11100110b
-11100110b | 10000011b = 11100111b
-11100110b | 10000100b = 11100110b
-11100110b | 10000101b = 11100111b
-11100110b | 10000110b = 11100110b
-11100110b | 10000111b = 11100111b
-11100110b | 10001000b = 11101110b
-11100110b | 10001001b = 11101111b
-11100110b | 10001010b = 11101110b
-11100110b | 10001011b = 11101111b
-11100110b | 10001100b = 11101110b
-11100110b | 10001101b = 11101111b
-11100110b | 10001110b = 11101110b
-11100110b | 10001111b = 11101111b
-11100110b | 10010000b = 11110110b
-11100110b | 10010001b = 11110111b
-11100110b | 10010010b = 11110110b
-11100110b | 10010011b = 11110111b
-11100110b | 10010100b = 11110110b
-11100110b | 10010101b = 11110111b
-11100110b | 10010110b = 11110110b
-11100110b | 10010111b = 11110111b
-11100110b | 10011000b = 11111110b
-11100110b | 10011001b = 11111111b
-11100110b | 10011010b = 11111110b
-11100110b | 10011011b = 11111111b
-11100110b | 10011100b = 11111110b
-11100110b | 10011101b = 11111111b
-11100110b | 10011110b = 11111110b
-11100110b | 10011111b = 11111111b
-11100110b | 10100000b = 11100110b
-11100110b | 10100001b = 11100111b
-11100110b | 10100010b = 11100110b
-11100110b | 10100011b = 11100111b
-11100110b | 10100100b = 11100110b
-11100110b | 10100101b = 11100111b
-11100110b | 10100110b = 11100110b
-11100110b | 10100111b = 11100111b
-11100110b | 10101000b = 11101110b
-11100110b | 10101001b = 11101111b
-11100110b | 10101010b = 11101110b
-11100110b | 10101011b = 11101111b
-11100110b | 10101100b = 11101110b
-11100110b | 10101101b = 11101111b
-11100110b | 10101110b = 11101110b
-11100110b | 10101111b = 11101111b
-11100110b | 10110000b = 11110110b
-11100110b | 10110001b = 11110111b
-11100110b | 10110010b = 11110110b
-11100110b | 10110011b = 11110111b
-11100110b | 10110100b = 11110110b
-11100110b | 10110101b = 11110111b
-11100110b | 10110110b = 11110110b
-11100110b | 10110111b = 11110111b
-11100110b | 10111000b = 11111110b
-11100110b | 10111001b = 11111111b
-11100110b | 10111010b = 11111110b
-11100110b | 10111011b = 11111111b
-11100110b | 10111100b = 11111110b
-11100110b | 10111101b = 11111111b
-11100110b | 10111110b = 11111110b
-11100110b | 10111111b = 11111111b
-11100110b | 11000000b = 11100110b
-11100110b | 11000001b = 11100111b
-11100110b | 11000010b = 11100110b
-11100110b | 11000011b = 11100111b
-11100110b | 11000100b = 11100110b
-11100110b | 11000101b = 11100111b
-11100110b | 11000110b = 11100110b
-11100110b | 11000111b = 11100111b
-11100110b | 11001000b = 11101110b
-11100110b | 11001001b = 11101111b
-11100110b | 11001010b = 11101110b
-11100110b | 11001011b = 11101111b
-11100110b | 11001100b = 11101110b
-11100110b | 11001101b = 11101111b
-11100110b | 11001110b = 11101110b
-11100110b | 11001111b = 11101111b
-11100110b | 11010000b = 11110110b
-11100110b | 11010001b = 11110111b
-11100110b | 11010010b = 11110110b
-11100110b | 11010011b = 11110111b
-11100110b | 11010100b = 11110110b
-11100110b | 11010101b = 11110111b
-11100110b | 11010110b = 11110110b
-11100110b | 11010111b = 11110111b
-11100110b | 11011000b = 11111110b
-11100110b | 11011001b = 11111111b
-11100110b | 11011010b = 11111110b
-11100110b | 11011011b = 11111111b
-11100110b | 11011100b = 11111110b
-11100110b | 11011101b = 11111111b
-11100110b | 11011110b = 11111110b
-11100110b | 11011111b = 11111111b
-11100110b | 11100000b = 11100110b
-11100110b | 11100001b = 11100111b
-11100110b | 11100010b = 11100110b
-11100110b | 11100011b = 11100111b
-11100110b | 11100100b = 11100110b
-11100110b | 11100101b = 11100111b
-11100110b | 11100110b = 11100110b
-11100110b | 11100111b = 11100111b
-11100110b | 11101000b = 11101110b
-11100110b | 11101001b = 11101111b
-11100110b | 11101010b = 11101110b
-11100110b | 11101011b = 11101111b
-11100110b | 11101100b = 11101110b
-11100110b | 11101101b = 11101111b
-11100110b | 11101110b = 11101110b
-11100110b | 11101111b = 11101111b
-11100110b | 11110000b = 11110110b
-11100110b | 11110001b = 11110111b
-11100110b | 11110010b = 11110110b
-11100110b | 11110011b = 11110111b
-11100110b | 11110100b = 11110110b
-11100110b | 11110101b = 11110111b
-11100110b | 11110110b = 11110110b
-11100110b | 11110111b = 11110111b
-11100110b | 11111000b = 11111110b
-11100110b | 11111001b = 11111111b
-11100110b | 11111010b = 11111110b
-11100110b | 11111011b = 11111111b
-11100110b | 11111100b = 11111110b
-11100110b | 11111101b = 11111111b
-11100110b | 11111110b = 11111110b
-11100110b | 11111111b = 11111111b
-11100110b | 00000000b = 11100110b
-11100110b | 00000001b = 11100111b
-11100110b | 00000010b = 11100110b
-11100110b | 00000011b = 11100111b
-11100110b | 00000100b = 11100110b
-11100110b | 00000101b = 11100111b
-11100110b | 00000110b = 11100110b
-11100110b | 00000111b = 11100111b
-11100110b | 00001000b = 11101110b
-11100110b | 00001001b = 11101111b
-11100110b | 00001010b = 11101110b
-11100110b | 00001011b = 11101111b
-11100110b | 00001100b = 11101110b
-11100110b | 00001101b = 11101111b
-11100110b | 00001110b = 11101110b
-11100110b | 00001111b = 11101111b
-11100110b | 00010000b = 11110110b
-11100110b | 00010001b = 11110111b
-11100110b | 00010010b = 11110110b
-11100110b | 00010011b = 11110111b
-11100110b | 00010100b = 11110110b
-11100110b | 00010101b = 11110111b
-11100110b | 00010110b = 11110110b
-11100110b | 00010111b = 11110111b
-11100110b | 00011000b = 11111110b
-11100110b | 00011001b = 11111111b
-11100110b | 00011010b = 11111110b
-11100110b | 00011011b = 11111111b
-11100110b | 00011100b = 11111110b
-11100110b | 00011101b = 11111111b
-11100110b | 00011110b = 11111110b
-11100110b | 00011111b = 11111111b
-11100110b | 00100000b = 11100110b
-11100110b | 00100001b = 11100111b
-11100110b | 00100010b = 11100110b
-11100110b | 00100011b = 11100111b
-11100110b | 00100100b = 11100110b
-11100110b | 00100101b = 11100111b
-11100110b | 00100110b = 11100110b
-11100110b | 00100111b = 11100111b
-11100110b | 00101000b = 11101110b
-11100110b | 00101001b = 11101111b
-11100110b | 00101010b = 11101110b
-11100110b | 00101011b = 11101111b
-11100110b | 00101100b = 11101110b
-11100110b | 00101101b = 11101111b
-11100110b | 00101110b = 11101110b
-11100110b | 00101111b = 11101111b
-11100110b | 00110000b = 11110110b
-11100110b | 00110001b = 11110111b
-11100110b | 00110010b = 11110110b
-11100110b | 00110011b = 11110111b
-11100110b | 00110100b = 11110110b
-11100110b | 00110101b = 11110111b
-11100110b | 00110110b = 11110110b
-11100110b | 00110111b = 11110111b
-11100110b | 00111000b = 11111110b
-11100110b | 00111001b = 11111111b
-11100110b | 00111010b = 11111110b
-11100110b | 00111011b = 11111111b
-11100110b | 00111100b = 11111110b
-11100110b | 00111101b = 11111111b
-11100110b | 00111110b = 11111110b
-11100110b | 00111111b = 11111111b
-11100110b | 01000000b = 11100110b
-11100110b | 01000001b = 11100111b
-11100110b | 01000010b = 11100110b
-11100110b | 01000011b = 11100111b
-11100110b | 01000100b = 11100110b
-11100110b | 01000101b = 11100111b
-11100110b | 01000110b = 11100110b
-11100110b | 01000111b = 11100111b
-11100110b | 01001000b = 11101110b
-11100110b | 01001001b = 11101111b
-11100110b | 01001010b = 11101110b
-11100110b | 01001011b = 11101111b
-11100110b | 01001100b = 11101110b
-11100110b | 01001101b = 11101111b
-11100110b | 01001110b = 11101110b
-11100110b | 01001111b = 11101111b
-11100110b | 01010000b = 11110110b
-11100110b | 01010001b = 11110111b
-11100110b | 01010010b = 11110110b
-11100110b | 01010011b = 11110111b
-11100110b | 01010100b = 11110110b
-11100110b | 01010101b = 11110111b
-11100110b | 01010110b = 11110110b
-11100110b | 01010111b = 11110111b
-11100110b | 01011000b = 11111110b
-11100110b | 01011001b = 11111111b
-11100110b | 01011010b = 11111110b
-11100110b | 01011011b = 11111111b
-11100110b | 01011100b = 11111110b
-11100110b | 01011101b = 11111111b
-11100110b | 01011110b = 11111110b
-11100110b | 01011111b = 11111111b
-11100110b | 01100000b = 11100110b
-11100110b | 01100001b = 11100111b
-11100110b | 01100010b = 11100110b
-11100110b | 01100011b = 11100111b
-11100110b | 01100100b = 11100110b
-11100110b | 01100101b = 11100111b
-11100110b | 01100110b = 11100110b
-11100110b | 01100111b = 11100111b
-11100110b | 01101000b = 11101110b
-11100110b | 01101001b = 11101111b
-11100110b | 01101010b = 11101110b
-11100110b | 01101011b = 11101111b
-11100110b | 01101100b = 11101110b
-11100110b | 01101101b = 11101111b
-11100110b | 01101110b = 11101110b
-11100110b | 01101111b = 11101111b
-11100110b | 01110000b = 11110110b
-11100110b | 01110001b = 11110111b
-11100110b | 01110010b = 11110110b
-11100110b | 01110011b = 11110111b
-11100110b | 01110100b = 11110110b
-11100110b | 01110101b = 11110111b
-11100110b | 01110110b = 11110110b
-11100110b | 01110111b = 11110111b
-11100110b | 01111000b = 11111110b
-11100110b | 01111001b = 11111111b
-11100110b | 01111010b = 11111110b
-11100110b | 01111011b = 11111111b
-11100110b | 01111100b = 11111110b
-11100110b | 01111101b = 11111111b
-11100110b | 01111110b = 11111110b
-11100111b | 10000000b = 11100111b
-11100111b | 10000001b = 11100111b
-11100111b | 10000010b = 11100111b
-11100111b | 10000011b = 11100111b
-11100111b | 10000100b = 11100111b
-11100111b | 10000101b = 11100111b
-11100111b | 10000110b = 11100111b
-11100111b | 10000111b = 11100111b
-11100111b | 10001000b = 11101111b
-11100111b | 10001001b = 11101111b
-11100111b | 10001010b = 11101111b
-11100111b | 10001011b = 11101111b
-11100111b | 10001100b = 11101111b
-11100111b | 10001101b = 11101111b
-11100111b | 10001110b = 11101111b
-11100111b | 10001111b = 11101111b
-11100111b | 10010000b = 11110111b
-11100111b | 10010001b = 11110111b
-11100111b | 10010010b = 11110111b
-11100111b | 10010011b = 11110111b
-11100111b | 10010100b = 11110111b
-11100111b | 10010101b = 11110111b
-11100111b | 10010110b = 11110111b
-11100111b | 10010111b = 11110111b
-11100111b | 10011000b = 11111111b
-11100111b | 10011001b = 11111111b
-11100111b | 10011010b = 11111111b
-11100111b | 10011011b = 11111111b
-11100111b | 10011100b = 11111111b
-11100111b | 10011101b = 11111111b
-11100111b | 10011110b = 11111111b
-11100111b | 10011111b = 11111111b
-11100111b | 10100000b = 11100111b
-11100111b | 10100001b = 11100111b
-11100111b | 10100010b = 11100111b
-11100111b | 10100011b = 11100111b
-11100111b | 10100100b = 11100111b
-11100111b | 10100101b = 11100111b
-11100111b | 10100110b = 11100111b
-11100111b | 10100111b = 11100111b
-11100111b | 10101000b = 11101111b
-11100111b | 10101001b = 11101111b
-11100111b | 10101010b = 11101111b
-11100111b | 10101011b = 11101111b
-11100111b | 10101100b = 11101111b
-11100111b | 10101101b = 11101111b
-11100111b | 10101110b = 11101111b
-11100111b | 10101111b = 11101111b
-11100111b | 10110000b = 11110111b
-11100111b | 10110001b = 11110111b
-11100111b | 10110010b = 11110111b
-11100111b | 10110011b = 11110111b
-11100111b | 10110100b = 11110111b
-11100111b | 10110101b = 11110111b
-11100111b | 10110110b = 11110111b
-11100111b | 10110111b = 11110111b
-11100111b | 10111000b = 11111111b
-11100111b | 10111001b = 11111111b
-11100111b | 10111010b = 11111111b
-11100111b | 10111011b = 11111111b
-11100111b | 10111100b = 11111111b
-11100111b | 10111101b = 11111111b
-11100111b | 10111110b = 11111111b
-11100111b | 10111111b = 11111111b
-11100111b | 11000000b = 11100111b
-11100111b | 11000001b = 11100111b
-11100111b | 11000010b = 11100111b
-11100111b | 11000011b = 11100111b
-11100111b | 11000100b = 11100111b
-11100111b | 11000101b = 11100111b
-11100111b | 11000110b = 11100111b
-11100111b | 11000111b = 11100111b
-11100111b | 11001000b = 11101111b
-11100111b | 11001001b = 11101111b
-11100111b | 11001010b = 11101111b
-11100111b | 11001011b = 11101111b
-11100111b | 11001100b = 11101111b
-11100111b | 11001101b = 11101111b
-11100111b | 11001110b = 11101111b
-11100111b | 11001111b = 11101111b
-11100111b | 11010000b = 11110111b
-11100111b | 11010001b = 11110111b
-11100111b | 11010010b = 11110111b
-11100111b | 11010011b = 11110111b
-11100111b | 11010100b = 11110111b
-11100111b | 11010101b = 11110111b
-11100111b | 11010110b = 11110111b
-11100111b | 11010111b = 11110111b
-11100111b | 11011000b = 11111111b
-11100111b | 11011001b = 11111111b
-11100111b | 11011010b = 11111111b
-11100111b | 11011011b = 11111111b
-11100111b | 11011100b = 11111111b
-11100111b | 11011101b = 11111111b
-11100111b | 11011110b = 11111111b
-11100111b | 11011111b = 11111111b
-11100111b | 11100000b = 11100111b
-11100111b | 11100001b = 11100111b
-11100111b | 11100010b = 11100111b
-11100111b | 11100011b = 11100111b
-11100111b | 11100100b = 11100111b
-11100111b | 11100101b = 11100111b
-11100111b | 11100110b = 11100111b
-11100111b | 11100111b = 11100111b
-11100111b | 11101000b = 11101111b
-11100111b | 11101001b = 11101111b
-11100111b | 11101010b = 11101111b
-11100111b | 11101011b = 11101111b
-11100111b | 11101100b = 11101111b
-11100111b | 11101101b = 11101111b
-11100111b | 11101110b = 11101111b
-11100111b | 11101111b = 11101111b
-11100111b | 11110000b = 11110111b
-11100111b | 11110001b = 11110111b
-11100111b | 11110010b = 11110111b
-11100111b | 11110011b = 11110111b
-11100111b | 11110100b = 11110111b
-11100111b | 11110101b = 11110111b
-11100111b | 11110110b = 11110111b
-11100111b | 11110111b = 11110111b
-11100111b | 11111000b = 11111111b
-11100111b | 11111001b = 11111111b
-11100111b | 11111010b = 11111111b
-11100111b | 11111011b = 11111111b
-11100111b | 11111100b = 11111111b
-11100111b | 11111101b = 11111111b
-11100111b | 11111110b = 11111111b
-11100111b | 11111111b = 11111111b
-11100111b | 00000000b = 11100111b
-11100111b | 00000001b = 11100111b
-11100111b | 00000010b = 11100111b
-11100111b | 00000011b = 11100111b
-11100111b | 00000100b = 11100111b
-11100111b | 00000101b = 11100111b
-11100111b | 00000110b = 11100111b
-11100111b | 00000111b = 11100111b
-11100111b | 00001000b = 11101111b
-11100111b | 00001001b = 11101111b
-11100111b | 00001010b = 11101111b
-11100111b | 00001011b = 11101111b
-11100111b | 00001100b = 11101111b
-11100111b | 00001101b = 11101111b
-11100111b | 00001110b = 11101111b
-11100111b | 00001111b = 11101111b
-11100111b | 00010000b = 11110111b
-11100111b | 00010001b = 11110111b
-11100111b | 00010010b = 11110111b
-11100111b | 00010011b = 11110111b
-11100111b | 00010100b = 11110111b
-11100111b | 00010101b = 11110111b
-11100111b | 00010110b = 11110111b
-11100111b | 00010111b = 11110111b
-11100111b | 00011000b = 11111111b
-11100111b | 00011001b = 11111111b
-11100111b | 00011010b = 11111111b
-11100111b | 00011011b = 11111111b
-11100111b | 00011100b = 11111111b
-11100111b | 00011101b = 11111111b
-11100111b | 00011110b = 11111111b
-11100111b | 00011111b = 11111111b
-11100111b | 00100000b = 11100111b
-11100111b | 00100001b = 11100111b
-11100111b | 00100010b = 11100111b
-11100111b | 00100011b = 11100111b
-11100111b | 00100100b = 11100111b
-11100111b | 00100101b = 11100111b
-11100111b | 00100110b = 11100111b
-11100111b | 00100111b = 11100111b
-11100111b | 00101000b = 11101111b
-11100111b | 00101001b = 11101111b
-11100111b | 00101010b = 11101111b
-11100111b | 00101011b = 11101111b
-11100111b | 00101100b = 11101111b
-11100111b | 00101101b = 11101111b
-11100111b | 00101110b = 11101111b
-11100111b | 00101111b = 11101111b
-11100111b | 00110000b = 11110111b
-11100111b | 00110001b = 11110111b
-11100111b | 00110010b = 11110111b
-11100111b | 00110011b = 11110111b
-11100111b | 00110100b = 11110111b
-11100111b | 00110101b = 11110111b
-11100111b | 00110110b = 11110111b
-11100111b | 00110111b = 11110111b
-11100111b | 00111000b = 11111111b
-11100111b | 00111001b = 11111111b
-11100111b | 00111010b = 11111111b
-11100111b | 00111011b = 11111111b
-11100111b | 00111100b = 11111111b
-11100111b | 00111101b = 11111111b
-11100111b | 00111110b = 11111111b
-11100111b | 00111111b = 11111111b
-11100111b | 01000000b = 11100111b
-11100111b | 01000001b = 11100111b
-11100111b | 01000010b = 11100111b
-11100111b | 01000011b = 11100111b
-11100111b | 01000100b = 11100111b
-11100111b | 01000101b = 11100111b
-11100111b | 01000110b = 11100111b
-11100111b | 01000111b = 11100111b
-11100111b | 01001000b = 11101111b
-11100111b | 01001001b = 11101111b
-11100111b | 01001010b = 11101111b
-11100111b | 01001011b = 11101111b
-11100111b | 01001100b = 11101111b
-11100111b | 01001101b = 11101111b
-11100111b | 01001110b = 11101111b
-11100111b | 01001111b = 11101111b
-11100111b | 01010000b = 11110111b
-11100111b | 01010001b = 11110111b
-11100111b | 01010010b = 11110111b
-11100111b | 01010011b = 11110111b
-11100111b | 01010100b = 11110111b
-11100111b | 01010101b = 11110111b
-11100111b | 01010110b = 11110111b
-11100111b | 01010111b = 11110111b
-11100111b | 01011000b = 11111111b
-11100111b | 01011001b = 11111111b
-11100111b | 01011010b = 11111111b
-11100111b | 01011011b = 11111111b
-11100111b | 01011100b = 11111111b
-11100111b | 01011101b = 11111111b
-11100111b | 01011110b = 11111111b
-11100111b | 01011111b = 11111111b
-11100111b | 01100000b = 11100111b
-11100111b | 01100001b = 11100111b
-11100111b | 01100010b = 11100111b
-11100111b | 01100011b = 11100111b
-11100111b | 01100100b = 11100111b
-11100111b | 01100101b = 11100111b
-11100111b | 01100110b = 11100111b
-11100111b | 01100111b = 11100111b
-11100111b | 01101000b = 11101111b
-11100111b | 01101001b = 11101111b
-11100111b | 01101010b = 11101111b
-11100111b | 01101011b = 11101111b
-11100111b | 01101100b = 11101111b
-11100111b | 01101101b = 11101111b
-11100111b | 01101110b = 11101111b
-11100111b | 01101111b = 11101111b
-11100111b | 01110000b = 11110111b
-11100111b | 01110001b = 11110111b
-11100111b | 01110010b = 11110111b
-11100111b | 01110011b = 11110111b
-11100111b | 01110100b = 11110111b
-11100111b | 01110101b = 11110111b
-11100111b | 01110110b = 11110111b
-11100111b | 01110111b = 11110111b
-11100111b | 01111000b = 11111111b
-11100111b | 01111001b = 11111111b
-11100111b | 01111010b = 11111111b
-11100111b | 01111011b = 11111111b
-11100111b | 01111100b = 11111111b
-11100111b | 01111101b = 11111111b
-11100111b | 01111110b = 11111111b
-11101000b | 10000000b = 11101000b
-11101000b | 10000001b = 11101001b
-11101000b | 10000010b = 11101010b
-11101000b | 10000011b = 11101011b
-11101000b | 10000100b = 11101100b
-11101000b | 10000101b = 11101101b
-11101000b | 10000110b = 11101110b
-11101000b | 10000111b = 11101111b
-11101000b | 10001000b = 11101000b
-11101000b | 10001001b = 11101001b
-11101000b | 10001010b = 11101010b
-11101000b | 10001011b = 11101011b
-11101000b | 10001100b = 11101100b
-11101000b | 10001101b = 11101101b
-11101000b | 10001110b = 11101110b
-11101000b | 10001111b = 11101111b
-11101000b | 10010000b = 11111000b
-11101000b | 10010001b = 11111001b
-11101000b | 10010010b = 11111010b
-11101000b | 10010011b = 11111011b
-11101000b | 10010100b = 11111100b
-11101000b | 10010101b = 11111101b
-11101000b | 10010110b = 11111110b
-11101000b | 10010111b = 11111111b
-11101000b | 10011000b = 11111000b
-11101000b | 10011001b = 11111001b
-11101000b | 10011010b = 11111010b
-11101000b | 10011011b = 11111011b
-11101000b | 10011100b = 11111100b
-11101000b | 10011101b = 11111101b
-11101000b | 10011110b = 11111110b
-11101000b | 10011111b = 11111111b
-11101000b | 10100000b = 11101000b
-11101000b | 10100001b = 11101001b
-11101000b | 10100010b = 11101010b
-11101000b | 10100011b = 11101011b
-11101000b | 10100100b = 11101100b
-11101000b | 10100101b = 11101101b
-11101000b | 10100110b = 11101110b
-11101000b | 10100111b = 11101111b
-11101000b | 10101000b = 11101000b
-11101000b | 10101001b = 11101001b
-11101000b | 10101010b = 11101010b
-11101000b | 10101011b = 11101011b
-11101000b | 10101100b = 11101100b
-11101000b | 10101101b = 11101101b
-11101000b | 10101110b = 11101110b
-11101000b | 10101111b = 11101111b
-11101000b | 10110000b = 11111000b
-11101000b | 10110001b = 11111001b
-11101000b | 10110010b = 11111010b
-11101000b | 10110011b = 11111011b
-11101000b | 10110100b = 11111100b
-11101000b | 10110101b = 11111101b
-11101000b | 10110110b = 11111110b
-11101000b | 10110111b = 11111111b
-11101000b | 10111000b = 11111000b
-11101000b | 10111001b = 11111001b
-11101000b | 10111010b = 11111010b
-11101000b | 10111011b = 11111011b
-11101000b | 10111100b = 11111100b
-11101000b | 10111101b = 11111101b
-11101000b | 10111110b = 11111110b
-11101000b | 10111111b = 11111111b
-11101000b | 11000000b = 11101000b
-11101000b | 11000001b = 11101001b
-11101000b | 11000010b = 11101010b
-11101000b | 11000011b = 11101011b
-11101000b | 11000100b = 11101100b
-11101000b | 11000101b = 11101101b
-11101000b | 11000110b = 11101110b
-11101000b | 11000111b = 11101111b
-11101000b | 11001000b = 11101000b
-11101000b | 11001001b = 11101001b
-11101000b | 11001010b = 11101010b
-11101000b | 11001011b = 11101011b
-11101000b | 11001100b = 11101100b
-11101000b | 11001101b = 11101101b
-11101000b | 11001110b = 11101110b
-11101000b | 11001111b = 11101111b
-11101000b | 11010000b = 11111000b
-11101000b | 11010001b = 11111001b
-11101000b | 11010010b = 11111010b
-11101000b | 11010011b = 11111011b
-11101000b | 11010100b = 11111100b
-11101000b | 11010101b = 11111101b
-11101000b | 11010110b = 11111110b
-11101000b | 11010111b = 11111111b
-11101000b | 11011000b = 11111000b
-11101000b | 11011001b = 11111001b
-11101000b | 11011010b = 11111010b
-11101000b | 11011011b = 11111011b
-11101000b | 11011100b = 11111100b
-11101000b | 11011101b = 11111101b
-11101000b | 11011110b = 11111110b
-11101000b | 11011111b = 11111111b
-11101000b | 11100000b = 11101000b
-11101000b | 11100001b = 11101001b
-11101000b | 11100010b = 11101010b
-11101000b | 11100011b = 11101011b
-11101000b | 11100100b = 11101100b
-11101000b | 11100101b = 11101101b
-11101000b | 11100110b = 11101110b
-11101000b | 11100111b = 11101111b
-11101000b | 11101000b = 11101000b
-11101000b | 11101001b = 11101001b
-11101000b | 11101010b = 11101010b
-11101000b | 11101011b = 11101011b
-11101000b | 11101100b = 11101100b
-11101000b | 11101101b = 11101101b
-11101000b | 11101110b = 11101110b
-11101000b | 11101111b = 11101111b
-11101000b | 11110000b = 11111000b
-11101000b | 11110001b = 11111001b
-11101000b | 11110010b = 11111010b
-11101000b | 11110011b = 11111011b
-11101000b | 11110100b = 11111100b
-11101000b | 11110101b = 11111101b
-11101000b | 11110110b = 11111110b
-11101000b | 11110111b = 11111111b
-11101000b | 11111000b = 11111000b
-11101000b | 11111001b = 11111001b
-11101000b | 11111010b = 11111010b
-11101000b | 11111011b = 11111011b
-11101000b | 11111100b = 11111100b
-11101000b | 11111101b = 11111101b
-11101000b | 11111110b = 11111110b
-11101000b | 11111111b = 11111111b
-11101000b | 00000000b = 11101000b
-11101000b | 00000001b = 11101001b
-11101000b | 00000010b = 11101010b
-11101000b | 00000011b = 11101011b
-11101000b | 00000100b = 11101100b
-11101000b | 00000101b = 11101101b
-11101000b | 00000110b = 11101110b
-11101000b | 00000111b = 11101111b
-11101000b | 00001000b = 11101000b
-11101000b | 00001001b = 11101001b
-11101000b | 00001010b = 11101010b
-11101000b | 00001011b = 11101011b
-11101000b | 00001100b = 11101100b
-11101000b | 00001101b = 11101101b
-11101000b | 00001110b = 11101110b
-11101000b | 00001111b = 11101111b
-11101000b | 00010000b = 11111000b
-11101000b | 00010001b = 11111001b
-11101000b | 00010010b = 11111010b
-11101000b | 00010011b = 11111011b
-11101000b | 00010100b = 11111100b
-11101000b | 00010101b = 11111101b
-11101000b | 00010110b = 11111110b
-11101000b | 00010111b = 11111111b
-11101000b | 00011000b = 11111000b
-11101000b | 00011001b = 11111001b
-11101000b | 00011010b = 11111010b
-11101000b | 00011011b = 11111011b
-11101000b | 00011100b = 11111100b
-11101000b | 00011101b = 11111101b
-11101000b | 00011110b = 11111110b
-11101000b | 00011111b = 11111111b
-11101000b | 00100000b = 11101000b
-11101000b | 00100001b = 11101001b
-11101000b | 00100010b = 11101010b
-11101000b | 00100011b = 11101011b
-11101000b | 00100100b = 11101100b
-11101000b | 00100101b = 11101101b
-11101000b | 00100110b = 11101110b
-11101000b | 00100111b = 11101111b
-11101000b | 00101000b = 11101000b
-11101000b | 00101001b = 11101001b
-11101000b | 00101010b = 11101010b
-11101000b | 00101011b = 11101011b
-11101000b | 00101100b = 11101100b
-11101000b | 00101101b = 11101101b
-11101000b | 00101110b = 11101110b
-11101000b | 00101111b = 11101111b
-11101000b | 00110000b = 11111000b
-11101000b | 00110001b = 11111001b
-11101000b | 00110010b = 11111010b
-11101000b | 00110011b = 11111011b
-11101000b | 00110100b = 11111100b
-11101000b | 00110101b = 11111101b
-11101000b | 00110110b = 11111110b
-11101000b | 00110111b = 11111111b
-11101000b | 00111000b = 11111000b
-11101000b | 00111001b = 11111001b
-11101000b | 00111010b = 11111010b
-11101000b | 00111011b = 11111011b
-11101000b | 00111100b = 11111100b
-11101000b | 00111101b = 11111101b
-11101000b | 00111110b = 11111110b
-11101000b | 00111111b = 11111111b
-11101000b | 01000000b = 11101000b
-11101000b | 01000001b = 11101001b
-11101000b | 01000010b = 11101010b
-11101000b | 01000011b = 11101011b
-11101000b | 01000100b = 11101100b
-11101000b | 01000101b = 11101101b
-11101000b | 01000110b = 11101110b
-11101000b | 01000111b = 11101111b
-11101000b | 01001000b = 11101000b
-11101000b | 01001001b = 11101001b
-11101000b | 01001010b = 11101010b
-11101000b | 01001011b = 11101011b
-11101000b | 01001100b = 11101100b
-11101000b | 01001101b = 11101101b
-11101000b | 01001110b = 11101110b
-11101000b | 01001111b = 11101111b
-11101000b | 01010000b = 11111000b
-11101000b | 01010001b = 11111001b
-11101000b | 01010010b = 11111010b
-11101000b | 01010011b = 11111011b
-11101000b | 01010100b = 11111100b
-11101000b | 01010101b = 11111101b
-11101000b | 01010110b = 11111110b
-11101000b | 01010111b = 11111111b
-11101000b | 01011000b = 11111000b
-11101000b | 01011001b = 11111001b
-11101000b | 01011010b = 11111010b
-11101000b | 01011011b = 11111011b
-11101000b | 01011100b = 11111100b
-11101000b | 01011101b = 11111101b
-11101000b | 01011110b = 11111110b
-11101000b | 01011111b = 11111111b
-11101000b | 01100000b = 11101000b
-11101000b | 01100001b = 11101001b
-11101000b | 01100010b = 11101010b
-11101000b | 01100011b = 11101011b
-11101000b | 01100100b = 11101100b
-11101000b | 01100101b = 11101101b
-11101000b | 01100110b = 11101110b
-11101000b | 01100111b = 11101111b
-11101000b | 01101000b = 11101000b
-11101000b | 01101001b = 11101001b
-11101000b | 01101010b = 11101010b
-11101000b | 01101011b = 11101011b
-11101000b | 01101100b = 11101100b
-11101000b | 01101101b = 11101101b
-11101000b | 01101110b = 11101110b
-11101000b | 01101111b = 11101111b
-11101000b | 01110000b = 11111000b
-11101000b | 01110001b = 11111001b
-11101000b | 01110010b = 11111010b
-11101000b | 01110011b = 11111011b
-11101000b | 01110100b = 11111100b
-11101000b | 01110101b = 11111101b
-11101000b | 01110110b = 11111110b
-11101000b | 01110111b = 11111111b
-11101000b | 01111000b = 11111000b
-11101000b | 01111001b = 11111001b
-11101000b | 01111010b = 11111010b
-11101000b | 01111011b = 11111011b
-11101000b | 01111100b = 11111100b
-11101000b | 01111101b = 11111101b
-11101000b | 01111110b = 11111110b
-11101001b | 10000000b = 11101001b
-11101001b | 10000001b = 11101001b
-11101001b | 10000010b = 11101011b
-11101001b | 10000011b = 11101011b
-11101001b | 10000100b = 11101101b
-11101001b | 10000101b = 11101101b
-11101001b | 10000110b = 11101111b
-11101001b | 10000111b = 11101111b
-11101001b | 10001000b = 11101001b
-11101001b | 10001001b = 11101001b
-11101001b | 10001010b = 11101011b
-11101001b | 10001011b = 11101011b
-11101001b | 10001100b = 11101101b
-11101001b | 10001101b = 11101101b
-11101001b | 10001110b = 11101111b
-11101001b | 10001111b = 11101111b
-11101001b | 10010000b = 11111001b
-11101001b | 10010001b = 11111001b
-11101001b | 10010010b = 11111011b
-11101001b | 10010011b = 11111011b
-11101001b | 10010100b = 11111101b
-11101001b | 10010101b = 11111101b
-11101001b | 10010110b = 11111111b
-11101001b | 10010111b = 11111111b
-11101001b | 10011000b = 11111001b
-11101001b | 10011001b = 11111001b
-11101001b | 10011010b = 11111011b
-11101001b | 10011011b = 11111011b
-11101001b | 10011100b = 11111101b
-11101001b | 10011101b = 11111101b
-11101001b | 10011110b = 11111111b
-11101001b | 10011111b = 11111111b
-11101001b | 10100000b = 11101001b
-11101001b | 10100001b = 11101001b
-11101001b | 10100010b = 11101011b
-11101001b | 10100011b = 11101011b
-11101001b | 10100100b = 11101101b
-11101001b | 10100101b = 11101101b
-11101001b | 10100110b = 11101111b
-11101001b | 10100111b = 11101111b
-11101001b | 10101000b = 11101001b
-11101001b | 10101001b = 11101001b
-11101001b | 10101010b = 11101011b
-11101001b | 10101011b = 11101011b
-11101001b | 10101100b = 11101101b
-11101001b | 10101101b = 11101101b
-11101001b | 10101110b = 11101111b
-11101001b | 10101111b = 11101111b
-11101001b | 10110000b = 11111001b
-11101001b | 10110001b = 11111001b
-11101001b | 10110010b = 11111011b
-11101001b | 10110011b = 11111011b
-11101001b | 10110100b = 11111101b
-11101001b | 10110101b = 11111101b
-11101001b | 10110110b = 11111111b
-11101001b | 10110111b = 11111111b
-11101001b | 10111000b = 11111001b
-11101001b | 10111001b = 11111001b
-11101001b | 10111010b = 11111011b
-11101001b | 10111011b = 11111011b
-11101001b | 10111100b = 11111101b
-11101001b | 10111101b = 11111101b
-11101001b | 10111110b = 11111111b
-11101001b | 10111111b = 11111111b
-11101001b | 11000000b = 11101001b
-11101001b | 11000001b = 11101001b
-11101001b | 11000010b = 11101011b
-11101001b | 11000011b = 11101011b
-11101001b | 11000100b = 11101101b
-11101001b | 11000101b = 11101101b
-11101001b | 11000110b = 11101111b
-11101001b | 11000111b = 11101111b
-11101001b | 11001000b = 11101001b
-11101001b | 11001001b = 11101001b
-11101001b | 11001010b = 11101011b
-11101001b | 11001011b = 11101011b
-11101001b | 11001100b = 11101101b
-11101001b | 11001101b = 11101101b
-11101001b | 11001110b = 11101111b
-11101001b | 11001111b = 11101111b
-11101001b | 11010000b = 11111001b
-11101001b | 11010001b = 11111001b
-11101001b | 11010010b = 11111011b
-11101001b | 11010011b = 11111011b
-11101001b | 11010100b = 11111101b
-11101001b | 11010101b = 11111101b
-11101001b | 11010110b = 11111111b
-11101001b | 11010111b = 11111111b
-11101001b | 11011000b = 11111001b
-11101001b | 11011001b = 11111001b
-11101001b | 11011010b = 11111011b
-11101001b | 11011011b = 11111011b
-11101001b | 11011100b = 11111101b
-11101001b | 11011101b = 11111101b
-11101001b | 11011110b = 11111111b
-11101001b | 11011111b = 11111111b
-11101001b | 11100000b = 11101001b
-11101001b | 11100001b = 11101001b
-11101001b | 11100010b = 11101011b
-11101001b | 11100011b = 11101011b
-11101001b | 11100100b = 11101101b
-11101001b | 11100101b = 11101101b
-11101001b | 11100110b = 11101111b
-11101001b | 11100111b = 11101111b
-11101001b | 11101000b = 11101001b
-11101001b | 11101001b = 11101001b
-11101001b | 11101010b = 11101011b
-11101001b | 11101011b = 11101011b
-11101001b | 11101100b = 11101101b
-11101001b | 11101101b = 11101101b
-11101001b | 11101110b = 11101111b
-11101001b | 11101111b = 11101111b
-11101001b | 11110000b = 11111001b
-11101001b | 11110001b = 11111001b
-11101001b | 11110010b = 11111011b
-11101001b | 11110011b = 11111011b
-11101001b | 11110100b = 11111101b
-11101001b | 11110101b = 11111101b
-11101001b | 11110110b = 11111111b
-11101001b | 11110111b = 11111111b
-11101001b | 11111000b = 11111001b
-11101001b | 11111001b = 11111001b
-11101001b | 11111010b = 11111011b
-11101001b | 11111011b = 11111011b
-11101001b | 11111100b = 11111101b
-11101001b | 11111101b = 11111101b
-11101001b | 11111110b = 11111111b
-11101001b | 11111111b = 11111111b
-11101001b | 00000000b = 11101001b
-11101001b | 00000001b = 11101001b
-11101001b | 00000010b = 11101011b
-11101001b | 00000011b = 11101011b
-11101001b | 00000100b = 11101101b
-11101001b | 00000101b = 11101101b
-11101001b | 00000110b = 11101111b
-11101001b | 00000111b = 11101111b
-11101001b | 00001000b = 11101001b
-11101001b | 00001001b = 11101001b
-11101001b | 00001010b = 11101011b
-11101001b | 00001011b = 11101011b
-11101001b | 00001100b = 11101101b
-11101001b | 00001101b = 11101101b
-11101001b | 00001110b = 11101111b
-11101001b | 00001111b = 11101111b
-11101001b | 00010000b = 11111001b
-11101001b | 00010001b = 11111001b
-11101001b | 00010010b = 11111011b
-11101001b | 00010011b = 11111011b
-11101001b | 00010100b = 11111101b
-11101001b | 00010101b = 11111101b
-11101001b | 00010110b = 11111111b
-11101001b | 00010111b = 11111111b
-11101001b | 00011000b = 11111001b
-11101001b | 00011001b = 11111001b
-11101001b | 00011010b = 11111011b
-11101001b | 00011011b = 11111011b
-11101001b | 00011100b = 11111101b
-11101001b | 00011101b = 11111101b
-11101001b | 00011110b = 11111111b
-11101001b | 00011111b = 11111111b
-11101001b | 00100000b = 11101001b
-11101001b | 00100001b = 11101001b
-11101001b | 00100010b = 11101011b
-11101001b | 00100011b = 11101011b
-11101001b | 00100100b = 11101101b
-11101001b | 00100101b = 11101101b
-11101001b | 00100110b = 11101111b
-11101001b | 00100111b = 11101111b
-11101001b | 00101000b = 11101001b
-11101001b | 00101001b = 11101001b
-11101001b | 00101010b = 11101011b
-11101001b | 00101011b = 11101011b
-11101001b | 00101100b = 11101101b
-11101001b | 00101101b = 11101101b
-11101001b | 00101110b = 11101111b
-11101001b | 00101111b = 11101111b
-11101001b | 00110000b = 11111001b
-11101001b | 00110001b = 11111001b
-11101001b | 00110010b = 11111011b
-11101001b | 00110011b = 11111011b
-11101001b | 00110100b = 11111101b
-11101001b | 00110101b = 11111101b
-11101001b | 00110110b = 11111111b
-11101001b | 00110111b = 11111111b
-11101001b | 00111000b = 11111001b
-11101001b | 00111001b = 11111001b
-11101001b | 00111010b = 11111011b
-11101001b | 00111011b = 11111011b
-11101001b | 00111100b = 11111101b
-11101001b | 00111101b = 11111101b
-11101001b | 00111110b = 11111111b
-11101001b | 00111111b = 11111111b
-11101001b | 01000000b = 11101001b
-11101001b | 01000001b = 11101001b
-11101001b | 01000010b = 11101011b
-11101001b | 01000011b = 11101011b
-11101001b | 01000100b = 11101101b
-11101001b | 01000101b = 11101101b
-11101001b | 01000110b = 11101111b
-11101001b | 01000111b = 11101111b
-11101001b | 01001000b = 11101001b
-11101001b | 01001001b = 11101001b
-11101001b | 01001010b = 11101011b
-11101001b | 01001011b = 11101011b
-11101001b | 01001100b = 11101101b
-11101001b | 01001101b = 11101101b
-11101001b | 01001110b = 11101111b
-11101001b | 01001111b = 11101111b
-11101001b | 01010000b = 11111001b
-11101001b | 01010001b = 11111001b
-11101001b | 01010010b = 11111011b
-11101001b | 01010011b = 11111011b
-11101001b | 01010100b = 11111101b
-11101001b | 01010101b = 11111101b
-11101001b | 01010110b = 11111111b
-11101001b | 01010111b = 11111111b
-11101001b | 01011000b = 11111001b
-11101001b | 01011001b = 11111001b
-11101001b | 01011010b = 11111011b
-11101001b | 01011011b = 11111011b
-11101001b | 01011100b = 11111101b
-11101001b | 01011101b = 11111101b
-11101001b | 01011110b = 11111111b
-11101001b | 01011111b = 11111111b
-11101001b | 01100000b = 11101001b
-11101001b | 01100001b = 11101001b
-11101001b | 01100010b = 11101011b
-11101001b | 01100011b = 11101011b
-11101001b | 01100100b = 11101101b
-11101001b | 01100101b = 11101101b
-11101001b | 01100110b = 11101111b
-11101001b | 01100111b = 11101111b
-11101001b | 01101000b = 11101001b
-11101001b | 01101001b = 11101001b
-11101001b | 01101010b = 11101011b
-11101001b | 01101011b = 11101011b
-11101001b | 01101100b = 11101101b
-11101001b | 01101101b = 11101101b
-11101001b | 01101110b = 11101111b
-11101001b | 01101111b = 11101111b
-11101001b | 01110000b = 11111001b
-11101001b | 01110001b = 11111001b
-11101001b | 01110010b = 11111011b
-11101001b | 01110011b = 11111011b
-11101001b | 01110100b = 11111101b
-11101001b | 01110101b = 11111101b
-11101001b | 01110110b = 11111111b
-11101001b | 01110111b = 11111111b
-11101001b | 01111000b = 11111001b
-11101001b | 01111001b = 11111001b
-11101001b | 01111010b = 11111011b
-11101001b | 01111011b = 11111011b
-11101001b | 01111100b = 11111101b
-11101001b | 01111101b = 11111101b
-11101001b | 01111110b = 11111111b
-11101010b | 10000000b = 11101010b
-11101010b | 10000001b = 11101011b
-11101010b | 10000010b = 11101010b
-11101010b | 10000011b = 11101011b
-11101010b | 10000100b = 11101110b
-11101010b | 10000101b = 11101111b
-11101010b | 10000110b = 11101110b
-11101010b | 10000111b = 11101111b
-11101010b | 10001000b = 11101010b
-11101010b | 10001001b = 11101011b
-11101010b | 10001010b = 11101010b
-11101010b | 10001011b = 11101011b
-11101010b | 10001100b = 11101110b
-11101010b | 10001101b = 11101111b
-11101010b | 10001110b = 11101110b
-11101010b | 10001111b = 11101111b
-11101010b | 10010000b = 11111010b
-11101010b | 10010001b = 11111011b
-11101010b | 10010010b = 11111010b
-11101010b | 10010011b = 11111011b
-11101010b | 10010100b = 11111110b
-11101010b | 10010101b = 11111111b
-11101010b | 10010110b = 11111110b
-11101010b | 10010111b = 11111111b
-11101010b | 10011000b = 11111010b
-11101010b | 10011001b = 11111011b
-11101010b | 10011010b = 11111010b
-11101010b | 10011011b = 11111011b
-11101010b | 10011100b = 11111110b
-11101010b | 10011101b = 11111111b
-11101010b | 10011110b = 11111110b
-11101010b | 10011111b = 11111111b
-11101010b | 10100000b = 11101010b
-11101010b | 10100001b = 11101011b
-11101010b | 10100010b = 11101010b
-11101010b | 10100011b = 11101011b
-11101010b | 10100100b = 11101110b
-11101010b | 10100101b = 11101111b
-11101010b | 10100110b = 11101110b
-11101010b | 10100111b = 11101111b
-11101010b | 10101000b = 11101010b
-11101010b | 10101001b = 11101011b
-11101010b | 10101010b = 11101010b
-11101010b | 10101011b = 11101011b
-11101010b | 10101100b = 11101110b
-11101010b | 10101101b = 11101111b
-11101010b | 10101110b = 11101110b
-11101010b | 10101111b = 11101111b
-11101010b | 10110000b = 11111010b
-11101010b | 10110001b = 11111011b
-11101010b | 10110010b = 11111010b
-11101010b | 10110011b = 11111011b
-11101010b | 10110100b = 11111110b
-11101010b | 10110101b = 11111111b
-11101010b | 10110110b = 11111110b
-11101010b | 10110111b = 11111111b
-11101010b | 10111000b = 11111010b
-11101010b | 10111001b = 11111011b
-11101010b | 10111010b = 11111010b
-11101010b | 10111011b = 11111011b
-11101010b | 10111100b = 11111110b
-11101010b | 10111101b = 11111111b
-11101010b | 10111110b = 11111110b
-11101010b | 10111111b = 11111111b
-11101010b | 11000000b = 11101010b
-11101010b | 11000001b = 11101011b
-11101010b | 11000010b = 11101010b
-11101010b | 11000011b = 11101011b
-11101010b | 11000100b = 11101110b
-11101010b | 11000101b = 11101111b
-11101010b | 11000110b = 11101110b
-11101010b | 11000111b = 11101111b
-11101010b | 11001000b = 11101010b
-11101010b | 11001001b = 11101011b
-11101010b | 11001010b = 11101010b
-11101010b | 11001011b = 11101011b
-11101010b | 11001100b = 11101110b
-11101010b | 11001101b = 11101111b
-11101010b | 11001110b = 11101110b
-11101010b | 11001111b = 11101111b
-11101010b | 11010000b = 11111010b
-11101010b | 11010001b = 11111011b
-11101010b | 11010010b = 11111010b
-11101010b | 11010011b = 11111011b
-11101010b | 11010100b = 11111110b
-11101010b | 11010101b = 11111111b
-11101010b | 11010110b = 11111110b
-11101010b | 11010111b = 11111111b
-11101010b | 11011000b = 11111010b
-11101010b | 11011001b = 11111011b
-11101010b | 11011010b = 11111010b
-11101010b | 11011011b = 11111011b
-11101010b | 11011100b = 11111110b
-11101010b | 11011101b = 11111111b
-11101010b | 11011110b = 11111110b
-11101010b | 11011111b = 11111111b
-11101010b | 11100000b = 11101010b
-11101010b | 11100001b = 11101011b
-11101010b | 11100010b = 11101010b
-11101010b | 11100011b = 11101011b
-11101010b | 11100100b = 11101110b
-11101010b | 11100101b = 11101111b
-11101010b | 11100110b = 11101110b
-11101010b | 11100111b = 11101111b
-11101010b | 11101000b = 11101010b
-11101010b | 11101001b = 11101011b
-11101010b | 11101010b = 11101010b
-11101010b | 11101011b = 11101011b
-11101010b | 11101100b = 11101110b
-11101010b | 11101101b = 11101111b
-11101010b | 11101110b = 11101110b
-11101010b | 11101111b = 11101111b
-11101010b | 11110000b = 11111010b
-11101010b | 11110001b = 11111011b
-11101010b | 11110010b = 11111010b
-11101010b | 11110011b = 11111011b
-11101010b | 11110100b = 11111110b
-11101010b | 11110101b = 11111111b
-11101010b | 11110110b = 11111110b
-11101010b | 11110111b = 11111111b
-11101010b | 11111000b = 11111010b
-11101010b | 11111001b = 11111011b
-11101010b | 11111010b = 11111010b
-11101010b | 11111011b = 11111011b
-11101010b | 11111100b = 11111110b
-11101010b | 11111101b = 11111111b
-11101010b | 11111110b = 11111110b
-11101010b | 11111111b = 11111111b
-11101010b | 00000000b = 11101010b
-11101010b | 00000001b = 11101011b
-11101010b | 00000010b = 11101010b
-11101010b | 00000011b = 11101011b
-11101010b | 00000100b = 11101110b
-11101010b | 00000101b = 11101111b
-11101010b | 00000110b = 11101110b
-11101010b | 00000111b = 11101111b
-11101010b | 00001000b = 11101010b
-11101010b | 00001001b = 11101011b
-11101010b | 00001010b = 11101010b
-11101010b | 00001011b = 11101011b
-11101010b | 00001100b = 11101110b
-11101010b | 00001101b = 11101111b
-11101010b | 00001110b = 11101110b
-11101010b | 00001111b = 11101111b
-11101010b | 00010000b = 11111010b
-11101010b | 00010001b = 11111011b
-11101010b | 00010010b = 11111010b
-11101010b | 00010011b = 11111011b
-11101010b | 00010100b = 11111110b
-11101010b | 00010101b = 11111111b
-11101010b | 00010110b = 11111110b
-11101010b | 00010111b = 11111111b
-11101010b | 00011000b = 11111010b
-11101010b | 00011001b = 11111011b
-11101010b | 00011010b = 11111010b
-11101010b | 00011011b = 11111011b
-11101010b | 00011100b = 11111110b
-11101010b | 00011101b = 11111111b
-11101010b | 00011110b = 11111110b
-11101010b | 00011111b = 11111111b
-11101010b | 00100000b = 11101010b
-11101010b | 00100001b = 11101011b
-11101010b | 00100010b = 11101010b
-11101010b | 00100011b = 11101011b
-11101010b | 00100100b = 11101110b
-11101010b | 00100101b = 11101111b
-11101010b | 00100110b = 11101110b
-11101010b | 00100111b = 11101111b
-11101010b | 00101000b = 11101010b
-11101010b | 00101001b = 11101011b
-11101010b | 00101010b = 11101010b
-11101010b | 00101011b = 11101011b
-11101010b | 00101100b = 11101110b
-11101010b | 00101101b = 11101111b
-11101010b | 00101110b = 11101110b
-11101010b | 00101111b = 11101111b
-11101010b | 00110000b = 11111010b
-11101010b | 00110001b = 11111011b
-11101010b | 00110010b = 11111010b
-11101010b | 00110011b = 11111011b
-11101010b | 00110100b = 11111110b
-11101010b | 00110101b = 11111111b
-11101010b | 00110110b = 11111110b
-11101010b | 00110111b = 11111111b
-11101010b | 00111000b = 11111010b
-11101010b | 00111001b = 11111011b
-11101010b | 00111010b = 11111010b
-11101010b | 00111011b = 11111011b
-11101010b | 00111100b = 11111110b
-11101010b | 00111101b = 11111111b
-11101010b | 00111110b = 11111110b
-11101010b | 00111111b = 11111111b
-11101010b | 01000000b = 11101010b
-11101010b | 01000001b = 11101011b
-11101010b | 01000010b = 11101010b
-11101010b | 01000011b = 11101011b
-11101010b | 01000100b = 11101110b
-11101010b | 01000101b = 11101111b
-11101010b | 01000110b = 11101110b
-11101010b | 01000111b = 11101111b
-11101010b | 01001000b = 11101010b
-11101010b | 01001001b = 11101011b
-11101010b | 01001010b = 11101010b
-11101010b | 01001011b = 11101011b
-11101010b | 01001100b = 11101110b
-11101010b | 01001101b = 11101111b
-11101010b | 01001110b = 11101110b
-11101010b | 01001111b = 11101111b
-11101010b | 01010000b = 11111010b
-11101010b | 01010001b = 11111011b
-11101010b | 01010010b = 11111010b
-11101010b | 01010011b = 11111011b
-11101010b | 01010100b = 11111110b
-11101010b | 01010101b = 11111111b
-11101010b | 01010110b = 11111110b
-11101010b | 01010111b = 11111111b
-11101010b | 01011000b = 11111010b
-11101010b | 01011001b = 11111011b
-11101010b | 01011010b = 11111010b
-11101010b | 01011011b = 11111011b
-11101010b | 01011100b = 11111110b
-11101010b | 01011101b = 11111111b
-11101010b | 01011110b = 11111110b
-11101010b | 01011111b = 11111111b
-11101010b | 01100000b = 11101010b
-11101010b | 01100001b = 11101011b
-11101010b | 01100010b = 11101010b
-11101010b | 01100011b = 11101011b
-11101010b | 01100100b = 11101110b
-11101010b | 01100101b = 11101111b
-11101010b | 01100110b = 11101110b
-11101010b | 01100111b = 11101111b
-11101010b | 01101000b = 11101010b
-11101010b | 01101001b = 11101011b
-11101010b | 01101010b = 11101010b
-11101010b | 01101011b = 11101011b
-11101010b | 01101100b = 11101110b
-11101010b | 01101101b = 11101111b
-11101010b | 01101110b = 11101110b
-11101010b | 01101111b = 11101111b
-11101010b | 01110000b = 11111010b
-11101010b | 01110001b = 11111011b
-11101010b | 01110010b = 11111010b
-11101010b | 01110011b = 11111011b
-11101010b | 01110100b = 11111110b
-11101010b | 01110101b = 11111111b
-11101010b | 01110110b = 11111110b
-11101010b | 01110111b = 11111111b
-11101010b | 01111000b = 11111010b
-11101010b | 01111001b = 11111011b
-11101010b | 01111010b = 11111010b
-11101010b | 01111011b = 11111011b
-11101010b | 01111100b = 11111110b
-11101010b | 01111101b = 11111111b
-11101010b | 01111110b = 11111110b
-11101011b | 10000000b = 11101011b
-11101011b | 10000001b = 11101011b
-11101011b | 10000010b = 11101011b
-11101011b | 10000011b = 11101011b
-11101011b | 10000100b = 11101111b
-11101011b | 10000101b = 11101111b
-11101011b | 10000110b = 11101111b
-11101011b | 10000111b = 11101111b
-11101011b | 10001000b = 11101011b
-11101011b | 10001001b = 11101011b
-11101011b | 10001010b = 11101011b
-11101011b | 10001011b = 11101011b
-11101011b | 10001100b = 11101111b
-11101011b | 10001101b = 11101111b
-11101011b | 10001110b = 11101111b
-11101011b | 10001111b = 11101111b
-11101011b | 10010000b = 11111011b
-11101011b | 10010001b = 11111011b
-11101011b | 10010010b = 11111011b
-11101011b | 10010011b = 11111011b
-11101011b | 10010100b = 11111111b
-11101011b | 10010101b = 11111111b
-11101011b | 10010110b = 11111111b
-11101011b | 10010111b = 11111111b
-11101011b | 10011000b = 11111011b
-11101011b | 10011001b = 11111011b
-11101011b | 10011010b = 11111011b
-11101011b | 10011011b = 11111011b
-11101011b | 10011100b = 11111111b
-11101011b | 10011101b = 11111111b
-11101011b | 10011110b = 11111111b
-11101011b | 10011111b = 11111111b
-11101011b | 10100000b = 11101011b
-11101011b | 10100001b = 11101011b
-11101011b | 10100010b = 11101011b
-11101011b | 10100011b = 11101011b
-11101011b | 10100100b = 11101111b
-11101011b | 10100101b = 11101111b
-11101011b | 10100110b = 11101111b
-11101011b | 10100111b = 11101111b
-11101011b | 10101000b = 11101011b
-11101011b | 10101001b = 11101011b
-11101011b | 10101010b = 11101011b
-11101011b | 10101011b = 11101011b
-11101011b | 10101100b = 11101111b
-11101011b | 10101101b = 11101111b
-11101011b | 10101110b = 11101111b
-11101011b | 10101111b = 11101111b
-11101011b | 10110000b = 11111011b
-11101011b | 10110001b = 11111011b
-11101011b | 10110010b = 11111011b
-11101011b | 10110011b = 11111011b
-11101011b | 10110100b = 11111111b
-11101011b | 10110101b = 11111111b
-11101011b | 10110110b = 11111111b
-11101011b | 10110111b = 11111111b
-11101011b | 10111000b = 11111011b
-11101011b | 10111001b = 11111011b
-11101011b | 10111010b = 11111011b
-11101011b | 10111011b = 11111011b
-11101011b | 10111100b = 11111111b
-11101011b | 10111101b = 11111111b
-11101011b | 10111110b = 11111111b
-11101011b | 10111111b = 11111111b
-11101011b | 11000000b = 11101011b
-11101011b | 11000001b = 11101011b
-11101011b | 11000010b = 11101011b
-11101011b | 11000011b = 11101011b
-11101011b | 11000100b = 11101111b
-11101011b | 11000101b = 11101111b
-11101011b | 11000110b = 11101111b
-11101011b | 11000111b = 11101111b
-11101011b | 11001000b = 11101011b
-11101011b | 11001001b = 11101011b
-11101011b | 11001010b = 11101011b
-11101011b | 11001011b = 11101011b
-11101011b | 11001100b = 11101111b
-11101011b | 11001101b = 11101111b
-11101011b | 11001110b = 11101111b
-11101011b | 11001111b = 11101111b
-11101011b | 11010000b = 11111011b
-11101011b | 11010001b = 11111011b
-11101011b | 11010010b = 11111011b
-11101011b | 11010011b = 11111011b
-11101011b | 11010100b = 11111111b
-11101011b | 11010101b = 11111111b
-11101011b | 11010110b = 11111111b
-11101011b | 11010111b = 11111111b
-11101011b | 11011000b = 11111011b
-11101011b | 11011001b = 11111011b
-11101011b | 11011010b = 11111011b
-11101011b | 11011011b = 11111011b
-11101011b | 11011100b = 11111111b
-11101011b | 11011101b = 11111111b
-11101011b | 11011110b = 11111111b
-11101011b | 11011111b = 11111111b
-11101011b | 11100000b = 11101011b
-11101011b | 11100001b = 11101011b
-11101011b | 11100010b = 11101011b
-11101011b | 11100011b = 11101011b
-11101011b | 11100100b = 11101111b
-11101011b | 11100101b = 11101111b
-11101011b | 11100110b = 11101111b
-11101011b | 11100111b = 11101111b
-11101011b | 11101000b = 11101011b
-11101011b | 11101001b = 11101011b
-11101011b | 11101010b = 11101011b
-11101011b | 11101011b = 11101011b
-11101011b | 11101100b = 11101111b
-11101011b | 11101101b = 11101111b
-11101011b | 11101110b = 11101111b
-11101011b | 11101111b = 11101111b
-11101011b | 11110000b = 11111011b
-11101011b | 11110001b = 11111011b
-11101011b | 11110010b = 11111011b
-11101011b | 11110011b = 11111011b
-11101011b | 11110100b = 11111111b
-11101011b | 11110101b = 11111111b
-11101011b | 11110110b = 11111111b
-11101011b | 11110111b = 11111111b
-11101011b | 11111000b = 11111011b
-11101011b | 11111001b = 11111011b
-11101011b | 11111010b = 11111011b
-11101011b | 11111011b = 11111011b
-11101011b | 11111100b = 11111111b
-11101011b | 11111101b = 11111111b
-11101011b | 11111110b = 11111111b
-11101011b | 11111111b = 11111111b
-11101011b | 00000000b = 11101011b
-11101011b | 00000001b = 11101011b
-11101011b | 00000010b = 11101011b
-11101011b | 00000011b = 11101011b
-11101011b | 00000100b = 11101111b
-11101011b | 00000101b = 11101111b
-11101011b | 00000110b = 11101111b
-11101011b | 00000111b = 11101111b
-11101011b | 00001000b = 11101011b
-11101011b | 00001001b = 11101011b
-11101011b | 00001010b = 11101011b
-11101011b | 00001011b = 11101011b
-11101011b | 00001100b = 11101111b
-11101011b | 00001101b = 11101111b
-11101011b | 00001110b = 11101111b
-11101011b | 00001111b = 11101111b
-11101011b | 00010000b = 11111011b
-11101011b | 00010001b = 11111011b
-11101011b | 00010010b = 11111011b
-11101011b | 00010011b = 11111011b
-11101011b | 00010100b = 11111111b
-11101011b | 00010101b = 11111111b
-11101011b | 00010110b = 11111111b
-11101011b | 00010111b = 11111111b
-11101011b | 00011000b = 11111011b
-11101011b | 00011001b = 11111011b
-11101011b | 00011010b = 11111011b
-11101011b | 00011011b = 11111011b
-11101011b | 00011100b = 11111111b
-11101011b | 00011101b = 11111111b
-11101011b | 00011110b = 11111111b
-11101011b | 00011111b = 11111111b
-11101011b | 00100000b = 11101011b
-11101011b | 00100001b = 11101011b
-11101011b | 00100010b = 11101011b
-11101011b | 00100011b = 11101011b
-11101011b | 00100100b = 11101111b
-11101011b | 00100101b = 11101111b
-11101011b | 00100110b = 11101111b
-11101011b | 00100111b = 11101111b
-11101011b | 00101000b = 11101011b
-11101011b | 00101001b = 11101011b
-11101011b | 00101010b = 11101011b
-11101011b | 00101011b = 11101011b
-11101011b | 00101100b = 11101111b
-11101011b | 00101101b = 11101111b
-11101011b | 00101110b = 11101111b
-11101011b | 00101111b = 11101111b
-11101011b | 00110000b = 11111011b
-11101011b | 00110001b = 11111011b
-11101011b | 00110010b = 11111011b
-11101011b | 00110011b = 11111011b
-11101011b | 00110100b = 11111111b
-11101011b | 00110101b = 11111111b
-11101011b | 00110110b = 11111111b
-11101011b | 00110111b = 11111111b
-11101011b | 00111000b = 11111011b
-11101011b | 00111001b = 11111011b
-11101011b | 00111010b = 11111011b
-11101011b | 00111011b = 11111011b
-11101011b | 00111100b = 11111111b
-11101011b | 00111101b = 11111111b
-11101011b | 00111110b = 11111111b
-11101011b | 00111111b = 11111111b
-11101011b | 01000000b = 11101011b
-11101011b | 01000001b = 11101011b
-11101011b | 01000010b = 11101011b
-11101011b | 01000011b = 11101011b
-11101011b | 01000100b = 11101111b
-11101011b | 01000101b = 11101111b
-11101011b | 01000110b = 11101111b
-11101011b | 01000111b = 11101111b
-11101011b | 01001000b = 11101011b
-11101011b | 01001001b = 11101011b
-11101011b | 01001010b = 11101011b
-11101011b | 01001011b = 11101011b
-11101011b | 01001100b = 11101111b
-11101011b | 01001101b = 11101111b
-11101011b | 01001110b = 11101111b
-11101011b | 01001111b = 11101111b
-11101011b | 01010000b = 11111011b
-11101011b | 01010001b = 11111011b
-11101011b | 01010010b = 11111011b
-11101011b | 01010011b = 11111011b
-11101011b | 01010100b = 11111111b
-11101011b | 01010101b = 11111111b
-11101011b | 01010110b = 11111111b
-11101011b | 01010111b = 11111111b
-11101011b | 01011000b = 11111011b
-11101011b | 01011001b = 11111011b
-11101011b | 01011010b = 11111011b
-11101011b | 01011011b = 11111011b
-11101011b | 01011100b = 11111111b
-11101011b | 01011101b = 11111111b
-11101011b | 01011110b = 11111111b
-11101011b | 01011111b = 11111111b
-11101011b | 01100000b = 11101011b
-11101011b | 01100001b = 11101011b
-11101011b | 01100010b = 11101011b
-11101011b | 01100011b = 11101011b
-11101011b | 01100100b = 11101111b
-11101011b | 01100101b = 11101111b
-11101011b | 01100110b = 11101111b
-11101011b | 01100111b = 11101111b
-11101011b | 01101000b = 11101011b
-11101011b | 01101001b = 11101011b
-11101011b | 01101010b = 11101011b
-11101011b | 01101011b = 11101011b
-11101011b | 01101100b = 11101111b
-11101011b | 01101101b = 11101111b
-11101011b | 01101110b = 11101111b
-11101011b | 01101111b = 11101111b
-11101011b | 01110000b = 11111011b
-11101011b | 01110001b = 11111011b
-11101011b | 01110010b = 11111011b
-11101011b | 01110011b = 11111011b
-11101011b | 01110100b = 11111111b
-11101011b | 01110101b = 11111111b
-11101011b | 01110110b = 11111111b
-11101011b | 01110111b = 11111111b
-11101011b | 01111000b = 11111011b
-11101011b | 01111001b = 11111011b
-11101011b | 01111010b = 11111011b
-11101011b | 01111011b = 11111011b
-11101011b | 01111100b = 11111111b
-11101011b | 01111101b = 11111111b
-11101011b | 01111110b = 11111111b
-11101100b | 10000000b = 11101100b
-11101100b | 10000001b = 11101101b
-11101100b | 10000010b = 11101110b
-11101100b | 10000011b = 11101111b
-11101100b | 10000100b = 11101100b
-11101100b | 10000101b = 11101101b
-11101100b | 10000110b = 11101110b
-11101100b | 10000111b = 11101111b
-11101100b | 10001000b = 11101100b
-11101100b | 10001001b = 11101101b
-11101100b | 10001010b = 11101110b
-11101100b | 10001011b = 11101111b
-11101100b | 10001100b = 11101100b
-11101100b | 10001101b = 11101101b
-11101100b | 10001110b = 11101110b
-11101100b | 10001111b = 11101111b
-11101100b | 10010000b = 11111100b
-11101100b | 10010001b = 11111101b
-11101100b | 10010010b = 11111110b
-11101100b | 10010011b = 11111111b
-11101100b | 10010100b = 11111100b
-11101100b | 10010101b = 11111101b
-11101100b | 10010110b = 11111110b
-11101100b | 10010111b = 11111111b
-11101100b | 10011000b = 11111100b
-11101100b | 10011001b = 11111101b
-11101100b | 10011010b = 11111110b
-11101100b | 10011011b = 11111111b
-11101100b | 10011100b = 11111100b
-11101100b | 10011101b = 11111101b
-11101100b | 10011110b = 11111110b
-11101100b | 10011111b = 11111111b
-11101100b | 10100000b = 11101100b
-11101100b | 10100001b = 11101101b
-11101100b | 10100010b = 11101110b
-11101100b | 10100011b = 11101111b
-11101100b | 10100100b = 11101100b
-11101100b | 10100101b = 11101101b
-11101100b | 10100110b = 11101110b
-11101100b | 10100111b = 11101111b
-11101100b | 10101000b = 11101100b
-11101100b | 10101001b = 11101101b
-11101100b | 10101010b = 11101110b
-11101100b | 10101011b = 11101111b
-11101100b | 10101100b = 11101100b
-11101100b | 10101101b = 11101101b
-11101100b | 10101110b = 11101110b
-11101100b | 10101111b = 11101111b
-11101100b | 10110000b = 11111100b
-11101100b | 10110001b = 11111101b
-11101100b | 10110010b = 11111110b
-11101100b | 10110011b = 11111111b
-11101100b | 10110100b = 11111100b
-11101100b | 10110101b = 11111101b
-11101100b | 10110110b = 11111110b
-11101100b | 10110111b = 11111111b
-11101100b | 10111000b = 11111100b
-11101100b | 10111001b = 11111101b
-11101100b | 10111010b = 11111110b
-11101100b | 10111011b = 11111111b
-11101100b | 10111100b = 11111100b
-11101100b | 10111101b = 11111101b
-11101100b | 10111110b = 11111110b
-11101100b | 10111111b = 11111111b
-11101100b | 11000000b = 11101100b
-11101100b | 11000001b = 11101101b
-11101100b | 11000010b = 11101110b
-11101100b | 11000011b = 11101111b
-11101100b | 11000100b = 11101100b
-11101100b | 11000101b = 11101101b
-11101100b | 11000110b = 11101110b
-11101100b | 11000111b = 11101111b
-11101100b | 11001000b = 11101100b
-11101100b | 11001001b = 11101101b
-11101100b | 11001010b = 11101110b
-11101100b | 11001011b = 11101111b
-11101100b | 11001100b = 11101100b
-11101100b | 11001101b = 11101101b
-11101100b | 11001110b = 11101110b
-11101100b | 11001111b = 11101111b
-11101100b | 11010000b = 11111100b
-11101100b | 11010001b = 11111101b
-11101100b | 11010010b = 11111110b
-11101100b | 11010011b = 11111111b
-11101100b | 11010100b = 11111100b
-11101100b | 11010101b = 11111101b
-11101100b | 11010110b = 11111110b
-11101100b | 11010111b = 11111111b
-11101100b | 11011000b = 11111100b
-11101100b | 11011001b = 11111101b
-11101100b | 11011010b = 11111110b
-11101100b | 11011011b = 11111111b
-11101100b | 11011100b = 11111100b
-11101100b | 11011101b = 11111101b
-11101100b | 11011110b = 11111110b
-11101100b | 11011111b = 11111111b
-11101100b | 11100000b = 11101100b
-11101100b | 11100001b = 11101101b
-11101100b | 11100010b = 11101110b
-11101100b | 11100011b = 11101111b
-11101100b | 11100100b = 11101100b
-11101100b | 11100101b = 11101101b
-11101100b | 11100110b = 11101110b
-11101100b | 11100111b = 11101111b
-11101100b | 11101000b = 11101100b
-11101100b | 11101001b = 11101101b
-11101100b | 11101010b = 11101110b
-11101100b | 11101011b = 11101111b
-11101100b | 11101100b = 11101100b
-11101100b | 11101101b = 11101101b
-11101100b | 11101110b = 11101110b
-11101100b | 11101111b = 11101111b
-11101100b | 11110000b = 11111100b
-11101100b | 11110001b = 11111101b
-11101100b | 11110010b = 11111110b
-11101100b | 11110011b = 11111111b
-11101100b | 11110100b = 11111100b
-11101100b | 11110101b = 11111101b
-11101100b | 11110110b = 11111110b
-11101100b | 11110111b = 11111111b
-11101100b | 11111000b = 11111100b
-11101100b | 11111001b = 11111101b
-11101100b | 11111010b = 11111110b
-11101100b | 11111011b = 11111111b
-11101100b | 11111100b = 11111100b
-11101100b | 11111101b = 11111101b
-11101100b | 11111110b = 11111110b
-11101100b | 11111111b = 11111111b
-11101100b | 00000000b = 11101100b
-11101100b | 00000001b = 11101101b
-11101100b | 00000010b = 11101110b
-11101100b | 00000011b = 11101111b
-11101100b | 00000100b = 11101100b
-11101100b | 00000101b = 11101101b
-11101100b | 00000110b = 11101110b
-11101100b | 00000111b = 11101111b
-11101100b | 00001000b = 11101100b
-11101100b | 00001001b = 11101101b
-11101100b | 00001010b = 11101110b
-11101100b | 00001011b = 11101111b
-11101100b | 00001100b = 11101100b
-11101100b | 00001101b = 11101101b
-11101100b | 00001110b = 11101110b
-11101100b | 00001111b = 11101111b
-11101100b | 00010000b = 11111100b
-11101100b | 00010001b = 11111101b
-11101100b | 00010010b = 11111110b
-11101100b | 00010011b = 11111111b
-11101100b | 00010100b = 11111100b
-11101100b | 00010101b = 11111101b
-11101100b | 00010110b = 11111110b
-11101100b | 00010111b = 11111111b
-11101100b | 00011000b = 11111100b
-11101100b | 00011001b = 11111101b
-11101100b | 00011010b = 11111110b
-11101100b | 00011011b = 11111111b
-11101100b | 00011100b = 11111100b
-11101100b | 00011101b = 11111101b
-11101100b | 00011110b = 11111110b
-11101100b | 00011111b = 11111111b
-11101100b | 00100000b = 11101100b
-11101100b | 00100001b = 11101101b
-11101100b | 00100010b = 11101110b
-11101100b | 00100011b = 11101111b
-11101100b | 00100100b = 11101100b
-11101100b | 00100101b = 11101101b
-11101100b | 00100110b = 11101110b
-11101100b | 00100111b = 11101111b
-11101100b | 00101000b = 11101100b
-11101100b | 00101001b = 11101101b
-11101100b | 00101010b = 11101110b
-11101100b | 00101011b = 11101111b
-11101100b | 00101100b = 11101100b
-11101100b | 00101101b = 11101101b
-11101100b | 00101110b = 11101110b
-11101100b | 00101111b = 11101111b
-11101100b | 00110000b = 11111100b
-11101100b | 00110001b = 11111101b
-11101100b | 00110010b = 11111110b
-11101100b | 00110011b = 11111111b
-11101100b | 00110100b = 11111100b
-11101100b | 00110101b = 11111101b
-11101100b | 00110110b = 11111110b
-11101100b | 00110111b = 11111111b
-11101100b | 00111000b = 11111100b
-11101100b | 00111001b = 11111101b
-11101100b | 00111010b = 11111110b
-11101100b | 00111011b = 11111111b
-11101100b | 00111100b = 11111100b
-11101100b | 00111101b = 11111101b
-11101100b | 00111110b = 11111110b
-11101100b | 00111111b = 11111111b
-11101100b | 01000000b = 11101100b
-11101100b | 01000001b = 11101101b
-11101100b | 01000010b = 11101110b
-11101100b | 01000011b = 11101111b
-11101100b | 01000100b = 11101100b
-11101100b | 01000101b = 11101101b
-11101100b | 01000110b = 11101110b
-11101100b | 01000111b = 11101111b
-11101100b | 01001000b = 11101100b
-11101100b | 01001001b = 11101101b
-11101100b | 01001010b = 11101110b
-11101100b | 01001011b = 11101111b
-11101100b | 01001100b = 11101100b
-11101100b | 01001101b = 11101101b
-11101100b | 01001110b = 11101110b
-11101100b | 01001111b = 11101111b
-11101100b | 01010000b = 11111100b
-11101100b | 01010001b = 11111101b
-11101100b | 01010010b = 11111110b
-11101100b | 01010011b = 11111111b
-11101100b | 01010100b = 11111100b
-11101100b | 01010101b = 11111101b
-11101100b | 01010110b = 11111110b
-11101100b | 01010111b = 11111111b
-11101100b | 01011000b = 11111100b
-11101100b | 01011001b = 11111101b
-11101100b | 01011010b = 11111110b
-11101100b | 01011011b = 11111111b
-11101100b | 01011100b = 11111100b
-11101100b | 01011101b = 11111101b
-11101100b | 01011110b = 11111110b
-11101100b | 01011111b = 11111111b
-11101100b | 01100000b = 11101100b
-11101100b | 01100001b = 11101101b
-11101100b | 01100010b = 11101110b
-11101100b | 01100011b = 11101111b
-11101100b | 01100100b = 11101100b
-11101100b | 01100101b = 11101101b
-11101100b | 01100110b = 11101110b
-11101100b | 01100111b = 11101111b
-11101100b | 01101000b = 11101100b
-11101100b | 01101001b = 11101101b
-11101100b | 01101010b = 11101110b
-11101100b | 01101011b = 11101111b
-11101100b | 01101100b = 11101100b
-11101100b | 01101101b = 11101101b
-11101100b | 01101110b = 11101110b
-11101100b | 01101111b = 11101111b
-11101100b | 01110000b = 11111100b
-11101100b | 01110001b = 11111101b
-11101100b | 01110010b = 11111110b
-11101100b | 01110011b = 11111111b
-11101100b | 01110100b = 11111100b
-11101100b | 01110101b = 11111101b
-11101100b | 01110110b = 11111110b
-11101100b | 01110111b = 11111111b
-11101100b | 01111000b = 11111100b
-11101100b | 01111001b = 11111101b
-11101100b | 01111010b = 11111110b
-11101100b | 01111011b = 11111111b
-11101100b | 01111100b = 11111100b
-11101100b | 01111101b = 11111101b
-11101100b | 01111110b = 11111110b
-11101101b | 10000000b = 11101101b
-11101101b | 10000001b = 11101101b
-11101101b | 10000010b = 11101111b
-11101101b | 10000011b = 11101111b
-11101101b | 10000100b = 11101101b
-11101101b | 10000101b = 11101101b
-11101101b | 10000110b = 11101111b
-11101101b | 10000111b = 11101111b
-11101101b | 10001000b = 11101101b
-11101101b | 10001001b = 11101101b
-11101101b | 10001010b = 11101111b
-11101101b | 10001011b = 11101111b
-11101101b | 10001100b = 11101101b
-11101101b | 10001101b = 11101101b
-11101101b | 10001110b = 11101111b
-11101101b | 10001111b = 11101111b
-11101101b | 10010000b = 11111101b
-11101101b | 10010001b = 11111101b
-11101101b | 10010010b = 11111111b
-11101101b | 10010011b = 11111111b
-11101101b | 10010100b = 11111101b
-11101101b | 10010101b = 11111101b
-11101101b | 10010110b = 11111111b
-11101101b | 10010111b = 11111111b
-11101101b | 10011000b = 11111101b
-11101101b | 10011001b = 11111101b
-11101101b | 10011010b = 11111111b
-11101101b | 10011011b = 11111111b
-11101101b | 10011100b = 11111101b
-11101101b | 10011101b = 11111101b
-11101101b | 10011110b = 11111111b
-11101101b | 10011111b = 11111111b
-11101101b | 10100000b = 11101101b
-11101101b | 10100001b = 11101101b
-11101101b | 10100010b = 11101111b
-11101101b | 10100011b = 11101111b
-11101101b | 10100100b = 11101101b
-11101101b | 10100101b = 11101101b
-11101101b | 10100110b = 11101111b
-11101101b | 10100111b = 11101111b
-11101101b | 10101000b = 11101101b
-11101101b | 10101001b = 11101101b
-11101101b | 10101010b = 11101111b
-11101101b | 10101011b = 11101111b
-11101101b | 10101100b = 11101101b
-11101101b | 10101101b = 11101101b
-11101101b | 10101110b = 11101111b
-11101101b | 10101111b = 11101111b
-11101101b | 10110000b = 11111101b
-11101101b | 10110001b = 11111101b
-11101101b | 10110010b = 11111111b
-11101101b | 10110011b = 11111111b
-11101101b | 10110100b = 11111101b
-11101101b | 10110101b = 11111101b
-11101101b | 10110110b = 11111111b
-11101101b | 10110111b = 11111111b
-11101101b | 10111000b = 11111101b
-11101101b | 10111001b = 11111101b
-11101101b | 10111010b = 11111111b
-11101101b | 10111011b = 11111111b
-11101101b | 10111100b = 11111101b
-11101101b | 10111101b = 11111101b
-11101101b | 10111110b = 11111111b
-11101101b | 10111111b = 11111111b
-11101101b | 11000000b = 11101101b
-11101101b | 11000001b = 11101101b
-11101101b | 11000010b = 11101111b
-11101101b | 11000011b = 11101111b
-11101101b | 11000100b = 11101101b
-11101101b | 11000101b = 11101101b
-11101101b | 11000110b = 11101111b
-11101101b | 11000111b = 11101111b
-11101101b | 11001000b = 11101101b
-11101101b | 11001001b = 11101101b
-11101101b | 11001010b = 11101111b
-11101101b | 11001011b = 11101111b
-11101101b | 11001100b = 11101101b
-11101101b | 11001101b = 11101101b
-11101101b | 11001110b = 11101111b
-11101101b | 11001111b = 11101111b
-11101101b | 11010000b = 11111101b
-11101101b | 11010001b = 11111101b
-11101101b | 11010010b = 11111111b
-11101101b | 11010011b = 11111111b
-11101101b | 11010100b = 11111101b
-11101101b | 11010101b = 11111101b
-11101101b | 11010110b = 11111111b
-11101101b | 11010111b = 11111111b
-11101101b | 11011000b = 11111101b
-11101101b | 11011001b = 11111101b
-11101101b | 11011010b = 11111111b
-11101101b | 11011011b = 11111111b
-11101101b | 11011100b = 11111101b
-11101101b | 11011101b = 11111101b
-11101101b | 11011110b = 11111111b
-11101101b | 11011111b = 11111111b
-11101101b | 11100000b = 11101101b
-11101101b | 11100001b = 11101101b
-11101101b | 11100010b = 11101111b
-11101101b | 11100011b = 11101111b
-11101101b | 11100100b = 11101101b
-11101101b | 11100101b = 11101101b
-11101101b | 11100110b = 11101111b
-11101101b | 11100111b = 11101111b
-11101101b | 11101000b = 11101101b
-11101101b | 11101001b = 11101101b
-11101101b | 11101010b = 11101111b
-11101101b | 11101011b = 11101111b
-11101101b | 11101100b = 11101101b
-11101101b | 11101101b = 11101101b
-11101101b | 11101110b = 11101111b
-11101101b | 11101111b = 11101111b
-11101101b | 11110000b = 11111101b
-11101101b | 11110001b = 11111101b
-11101101b | 11110010b = 11111111b
-11101101b | 11110011b = 11111111b
-11101101b | 11110100b = 11111101b
-11101101b | 11110101b = 11111101b
-11101101b | 11110110b = 11111111b
-11101101b | 11110111b = 11111111b
-11101101b | 11111000b = 11111101b
-11101101b | 11111001b = 11111101b
-11101101b | 11111010b = 11111111b
-11101101b | 11111011b = 11111111b
-11101101b | 11111100b = 11111101b
-11101101b | 11111101b = 11111101b
-11101101b | 11111110b = 11111111b
-11101101b | 11111111b = 11111111b
-11101101b | 00000000b = 11101101b
-11101101b | 00000001b = 11101101b
-11101101b | 00000010b = 11101111b
-11101101b | 00000011b = 11101111b
-11101101b | 00000100b = 11101101b
-11101101b | 00000101b = 11101101b
-11101101b | 00000110b = 11101111b
-11101101b | 00000111b = 11101111b
-11101101b | 00001000b = 11101101b
-11101101b | 00001001b = 11101101b
-11101101b | 00001010b = 11101111b
-11101101b | 00001011b = 11101111b
-11101101b | 00001100b = 11101101b
-11101101b | 00001101b = 11101101b
-11101101b | 00001110b = 11101111b
-11101101b | 00001111b = 11101111b
-11101101b | 00010000b = 11111101b
-11101101b | 00010001b = 11111101b
-11101101b | 00010010b = 11111111b
-11101101b | 00010011b = 11111111b
-11101101b | 00010100b = 11111101b
-11101101b | 00010101b = 11111101b
-11101101b | 00010110b = 11111111b
-11101101b | 00010111b = 11111111b
-11101101b | 00011000b = 11111101b
-11101101b | 00011001b = 11111101b
-11101101b | 00011010b = 11111111b
-11101101b | 00011011b = 11111111b
-11101101b | 00011100b = 11111101b
-11101101b | 00011101b = 11111101b
-11101101b | 00011110b = 11111111b
-11101101b | 00011111b = 11111111b
-11101101b | 00100000b = 11101101b
-11101101b | 00100001b = 11101101b
-11101101b | 00100010b = 11101111b
-11101101b | 00100011b = 11101111b
-11101101b | 00100100b = 11101101b
-11101101b | 00100101b = 11101101b
-11101101b | 00100110b = 11101111b
-11101101b | 00100111b = 11101111b
-11101101b | 00101000b = 11101101b
-11101101b | 00101001b = 11101101b
-11101101b | 00101010b = 11101111b
-11101101b | 00101011b = 11101111b
-11101101b | 00101100b = 11101101b
-11101101b | 00101101b = 11101101b
-11101101b | 00101110b = 11101111b
-11101101b | 00101111b = 11101111b
-11101101b | 00110000b = 11111101b
-11101101b | 00110001b = 11111101b
-11101101b | 00110010b = 11111111b
-11101101b | 00110011b = 11111111b
-11101101b | 00110100b = 11111101b
-11101101b | 00110101b = 11111101b
-11101101b | 00110110b = 11111111b
-11101101b | 00110111b = 11111111b
-11101101b | 00111000b = 11111101b
-11101101b | 00111001b = 11111101b
-11101101b | 00111010b = 11111111b
-11101101b | 00111011b = 11111111b
-11101101b | 00111100b = 11111101b
-11101101b | 00111101b = 11111101b
-11101101b | 00111110b = 11111111b
-11101101b | 00111111b = 11111111b
-11101101b | 01000000b = 11101101b
-11101101b | 01000001b = 11101101b
-11101101b | 01000010b = 11101111b
-11101101b | 01000011b = 11101111b
-11101101b | 01000100b = 11101101b
-11101101b | 01000101b = 11101101b
-11101101b | 01000110b = 11101111b
-11101101b | 01000111b = 11101111b
-11101101b | 01001000b = 11101101b
-11101101b | 01001001b = 11101101b
-11101101b | 01001010b = 11101111b
-11101101b | 01001011b = 11101111b
-11101101b | 01001100b = 11101101b
-11101101b | 01001101b = 11101101b
-11101101b | 01001110b = 11101111b
-11101101b | 01001111b = 11101111b
-11101101b | 01010000b = 11111101b
-11101101b | 01010001b = 11111101b
-11101101b | 01010010b = 11111111b
-11101101b | 01010011b = 11111111b
-11101101b | 01010100b = 11111101b
-11101101b | 01010101b = 11111101b
-11101101b | 01010110b = 11111111b
-11101101b | 01010111b = 11111111b
-11101101b | 01011000b = 11111101b
-11101101b | 01011001b = 11111101b
-11101101b | 01011010b = 11111111b
-11101101b | 01011011b = 11111111b
-11101101b | 01011100b = 11111101b
-11101101b | 01011101b = 11111101b
-11101101b | 01011110b = 11111111b
-11101101b | 01011111b = 11111111b
-11101101b | 01100000b = 11101101b
-11101101b | 01100001b = 11101101b
-11101101b | 01100010b = 11101111b
-11101101b | 01100011b = 11101111b
-11101101b | 01100100b = 11101101b
-11101101b | 01100101b = 11101101b
-11101101b | 01100110b = 11101111b
-11101101b | 01100111b = 11101111b
-11101101b | 01101000b = 11101101b
-11101101b | 01101001b = 11101101b
-11101101b | 01101010b = 11101111b
-11101101b | 01101011b = 11101111b
-11101101b | 01101100b = 11101101b
-11101101b | 01101101b = 11101101b
-11101101b | 01101110b = 11101111b
-11101101b | 01101111b = 11101111b
-11101101b | 01110000b = 11111101b
-11101101b | 01110001b = 11111101b
-11101101b | 01110010b = 11111111b
-11101101b | 01110011b = 11111111b
-11101101b | 01110100b = 11111101b
-11101101b | 01110101b = 11111101b
-11101101b | 01110110b = 11111111b
-11101101b | 01110111b = 11111111b
-11101101b | 01111000b = 11111101b
-11101101b | 01111001b = 11111101b
-11101101b | 01111010b = 11111111b
-11101101b | 01111011b = 11111111b
-11101101b | 01111100b = 11111101b
-11101101b | 01111101b = 11111101b
-11101101b | 01111110b = 11111111b
-11101110b | 10000000b = 11101110b
-11101110b | 10000001b = 11101111b
-11101110b | 10000010b = 11101110b
-11101110b | 10000011b = 11101111b
-11101110b | 10000100b = 11101110b
-11101110b | 10000101b = 11101111b
-11101110b | 10000110b = 11101110b
-11101110b | 10000111b = 11101111b
-11101110b | 10001000b = 11101110b
-11101110b | 10001001b = 11101111b
-11101110b | 10001010b = 11101110b
-11101110b | 10001011b = 11101111b
-11101110b | 10001100b = 11101110b
-11101110b | 10001101b = 11101111b
-11101110b | 10001110b = 11101110b
-11101110b | 10001111b = 11101111b
-11101110b | 10010000b = 11111110b
-11101110b | 10010001b = 11111111b
-11101110b | 10010010b = 11111110b
-11101110b | 10010011b = 11111111b
-11101110b | 10010100b = 11111110b
-11101110b | 10010101b = 11111111b
-11101110b | 10010110b = 11111110b
-11101110b | 10010111b = 11111111b
-11101110b | 10011000b = 11111110b
-11101110b | 10011001b = 11111111b
-11101110b | 10011010b = 11111110b
-11101110b | 10011011b = 11111111b
-11101110b | 10011100b = 11111110b
-11101110b | 10011101b = 11111111b
-11101110b | 10011110b = 11111110b
-11101110b | 10011111b = 11111111b
-11101110b | 10100000b = 11101110b
-11101110b | 10100001b = 11101111b
-11101110b | 10100010b = 11101110b
-11101110b | 10100011b = 11101111b
-11101110b | 10100100b = 11101110b
-11101110b | 10100101b = 11101111b
-11101110b | 10100110b = 11101110b
-11101110b | 10100111b = 11101111b
-11101110b | 10101000b = 11101110b
-11101110b | 10101001b = 11101111b
-11101110b | 10101010b = 11101110b
-11101110b | 10101011b = 11101111b
-11101110b | 10101100b = 11101110b
-11101110b | 10101101b = 11101111b
-11101110b | 10101110b = 11101110b
-11101110b | 10101111b = 11101111b
-11101110b | 10110000b = 11111110b
-11101110b | 10110001b = 11111111b
-11101110b | 10110010b = 11111110b
-11101110b | 10110011b = 11111111b
-11101110b | 10110100b = 11111110b
-11101110b | 10110101b = 11111111b
-11101110b | 10110110b = 11111110b
-11101110b | 10110111b = 11111111b
-11101110b | 10111000b = 11111110b
-11101110b | 10111001b = 11111111b
-11101110b | 10111010b = 11111110b
-11101110b | 10111011b = 11111111b
-11101110b | 10111100b = 11111110b
-11101110b | 10111101b = 11111111b
-11101110b | 10111110b = 11111110b
-11101110b | 10111111b = 11111111b
-11101110b | 11000000b = 11101110b
-11101110b | 11000001b = 11101111b
-11101110b | 11000010b = 11101110b
-11101110b | 11000011b = 11101111b
-11101110b | 11000100b = 11101110b
-11101110b | 11000101b = 11101111b
-11101110b | 11000110b = 11101110b
-11101110b | 11000111b = 11101111b
-11101110b | 11001000b = 11101110b
-11101110b | 11001001b = 11101111b
-11101110b | 11001010b = 11101110b
-11101110b | 11001011b = 11101111b
-11101110b | 11001100b = 11101110b
-11101110b | 11001101b = 11101111b
-11101110b | 11001110b = 11101110b
-11101110b | 11001111b = 11101111b
-11101110b | 11010000b = 11111110b
-11101110b | 11010001b = 11111111b
-11101110b | 11010010b = 11111110b
-11101110b | 11010011b = 11111111b
-11101110b | 11010100b = 11111110b
-11101110b | 11010101b = 11111111b
-11101110b | 11010110b = 11111110b
-11101110b | 11010111b = 11111111b
-11101110b | 11011000b = 11111110b
-11101110b | 11011001b = 11111111b
-11101110b | 11011010b = 11111110b
-11101110b | 11011011b = 11111111b
-11101110b | 11011100b = 11111110b
-11101110b | 11011101b = 11111111b
-11101110b | 11011110b = 11111110b
-11101110b | 11011111b = 11111111b
-11101110b | 11100000b = 11101110b
-11101110b | 11100001b = 11101111b
-11101110b | 11100010b = 11101110b
-11101110b | 11100011b = 11101111b
-11101110b | 11100100b = 11101110b
-11101110b | 11100101b = 11101111b
-11101110b | 11100110b = 11101110b
-11101110b | 11100111b = 11101111b
-11101110b | 11101000b = 11101110b
-11101110b | 11101001b = 11101111b
-11101110b | 11101010b = 11101110b
-11101110b | 11101011b = 11101111b
-11101110b | 11101100b = 11101110b
-11101110b | 11101101b = 11101111b
-11101110b | 11101110b = 11101110b
-11101110b | 11101111b = 11101111b
-11101110b | 11110000b = 11111110b
-11101110b | 11110001b = 11111111b
-11101110b | 11110010b = 11111110b
-11101110b | 11110011b = 11111111b
-11101110b | 11110100b = 11111110b
-11101110b | 11110101b = 11111111b
-11101110b | 11110110b = 11111110b
-11101110b | 11110111b = 11111111b
-11101110b | 11111000b = 11111110b
-11101110b | 11111001b = 11111111b
-11101110b | 11111010b = 11111110b
-11101110b | 11111011b = 11111111b
-11101110b | 11111100b = 11111110b
-11101110b | 11111101b = 11111111b
-11101110b | 11111110b = 11111110b
-11101110b | 11111111b = 11111111b
-11101110b | 00000000b = 11101110b
-11101110b | 00000001b = 11101111b
-11101110b | 00000010b = 11101110b
-11101110b | 00000011b = 11101111b
-11101110b | 00000100b = 11101110b
-11101110b | 00000101b = 11101111b
-11101110b | 00000110b = 11101110b
-11101110b | 00000111b = 11101111b
-11101110b | 00001000b = 11101110b
-11101110b | 00001001b = 11101111b
-11101110b | 00001010b = 11101110b
-11101110b | 00001011b = 11101111b
-11101110b | 00001100b = 11101110b
-11101110b | 00001101b = 11101111b
-11101110b | 00001110b = 11101110b
-11101110b | 00001111b = 11101111b
-11101110b | 00010000b = 11111110b
-11101110b | 00010001b = 11111111b
-11101110b | 00010010b = 11111110b
-11101110b | 00010011b = 11111111b
-11101110b | 00010100b = 11111110b
-11101110b | 00010101b = 11111111b
-11101110b | 00010110b = 11111110b
-11101110b | 00010111b = 11111111b
-11101110b | 00011000b = 11111110b
-11101110b | 00011001b = 11111111b
-11101110b | 00011010b = 11111110b
-11101110b | 00011011b = 11111111b
-11101110b | 00011100b = 11111110b
-11101110b | 00011101b = 11111111b
-11101110b | 00011110b = 11111110b
-11101110b | 00011111b = 11111111b
-11101110b | 00100000b = 11101110b
-11101110b | 00100001b = 11101111b
-11101110b | 00100010b = 11101110b
-11101110b | 00100011b = 11101111b
-11101110b | 00100100b = 11101110b
-11101110b | 00100101b = 11101111b
-11101110b | 00100110b = 11101110b
-11101110b | 00100111b = 11101111b
-11101110b | 00101000b = 11101110b
-11101110b | 00101001b = 11101111b
-11101110b | 00101010b = 11101110b
-11101110b | 00101011b = 11101111b
-11101110b | 00101100b = 11101110b
-11101110b | 00101101b = 11101111b
-11101110b | 00101110b = 11101110b
-11101110b | 00101111b = 11101111b
-11101110b | 00110000b = 11111110b
-11101110b | 00110001b = 11111111b
-11101110b | 00110010b = 11111110b
-11101110b | 00110011b = 11111111b
-11101110b | 00110100b = 11111110b
-11101110b | 00110101b = 11111111b
-11101110b | 00110110b = 11111110b
-11101110b | 00110111b = 11111111b
-11101110b | 00111000b = 11111110b
-11101110b | 00111001b = 11111111b
-11101110b | 00111010b = 11111110b
-11101110b | 00111011b = 11111111b
-11101110b | 00111100b = 11111110b
-11101110b | 00111101b = 11111111b
-11101110b | 00111110b = 11111110b
-11101110b | 00111111b = 11111111b
-11101110b | 01000000b = 11101110b
-11101110b | 01000001b = 11101111b
-11101110b | 01000010b = 11101110b
-11101110b | 01000011b = 11101111b
-11101110b | 01000100b = 11101110b
-11101110b | 01000101b = 11101111b
-11101110b | 01000110b = 11101110b
-11101110b | 01000111b = 11101111b
-11101110b | 01001000b = 11101110b
-11101110b | 01001001b = 11101111b
-11101110b | 01001010b = 11101110b
-11101110b | 01001011b = 11101111b
-11101110b | 01001100b = 11101110b
-11101110b | 01001101b = 11101111b
-11101110b | 01001110b = 11101110b
-11101110b | 01001111b = 11101111b
-11101110b | 01010000b = 11111110b
-11101110b | 01010001b = 11111111b
-11101110b | 01010010b = 11111110b
-11101110b | 01010011b = 11111111b
-11101110b | 01010100b = 11111110b
-11101110b | 01010101b = 11111111b
-11101110b | 01010110b = 11111110b
-11101110b | 01010111b = 11111111b
-11101110b | 01011000b = 11111110b
-11101110b | 01011001b = 11111111b
-11101110b | 01011010b = 11111110b
-11101110b | 01011011b = 11111111b
-11101110b | 01011100b = 11111110b
-11101110b | 01011101b = 11111111b
-11101110b | 01011110b = 11111110b
-11101110b | 01011111b = 11111111b
-11101110b | 01100000b = 11101110b
-11101110b | 01100001b = 11101111b
-11101110b | 01100010b = 11101110b
-11101110b | 01100011b = 11101111b
-11101110b | 01100100b = 11101110b
-11101110b | 01100101b = 11101111b
-11101110b | 01100110b = 11101110b
-11101110b | 01100111b = 11101111b
-11101110b | 01101000b = 11101110b
-11101110b | 01101001b = 11101111b
-11101110b | 01101010b = 11101110b
-11101110b | 01101011b = 11101111b
-11101110b | 01101100b = 11101110b
-11101110b | 01101101b = 11101111b
-11101110b | 01101110b = 11101110b
-11101110b | 01101111b = 11101111b
-11101110b | 01110000b = 11111110b
-11101110b | 01110001b = 11111111b
-11101110b | 01110010b = 11111110b
-11101110b | 01110011b = 11111111b
-11101110b | 01110100b = 11111110b
-11101110b | 01110101b = 11111111b
-11101110b | 01110110b = 11111110b
-11101110b | 01110111b = 11111111b
-11101110b | 01111000b = 11111110b
-11101110b | 01111001b = 11111111b
-11101110b | 01111010b = 11111110b
-11101110b | 01111011b = 11111111b
-11101110b | 01111100b = 11111110b
-11101110b | 01111101b = 11111111b
-11101110b | 01111110b = 11111110b
-11101111b | 10000000b = 11101111b
-11101111b | 10000001b = 11101111b
-11101111b | 10000010b = 11101111b
-11101111b | 10000011b = 11101111b
-11101111b | 10000100b = 11101111b
-11101111b | 10000101b = 11101111b
-11101111b | 10000110b = 11101111b
-11101111b | 10000111b = 11101111b
-11101111b | 10001000b = 11101111b
-11101111b | 10001001b = 11101111b
-11101111b | 10001010b = 11101111b
-11101111b | 10001011b = 11101111b
-11101111b | 10001100b = 11101111b
-11101111b | 10001101b = 11101111b
-11101111b | 10001110b = 11101111b
-11101111b | 10001111b = 11101111b
-11101111b | 10010000b = 11111111b
-11101111b | 10010001b = 11111111b
-11101111b | 10010010b = 11111111b
-11101111b | 10010011b = 11111111b
-11101111b | 10010100b = 11111111b
-11101111b | 10010101b = 11111111b
-11101111b | 10010110b = 11111111b
-11101111b | 10010111b = 11111111b
-11101111b | 10011000b = 11111111b
-11101111b | 10011001b = 11111111b
-11101111b | 10011010b = 11111111b
-11101111b | 10011011b = 11111111b
-11101111b | 10011100b = 11111111b
-11101111b | 10011101b = 11111111b
-11101111b | 10011110b = 11111111b
-11101111b | 10011111b = 11111111b
-11101111b | 10100000b = 11101111b
-11101111b | 10100001b = 11101111b
-11101111b | 10100010b = 11101111b
-11101111b | 10100011b = 11101111b
-11101111b | 10100100b = 11101111b
-11101111b | 10100101b = 11101111b
-11101111b | 10100110b = 11101111b
-11101111b | 10100111b = 11101111b
-11101111b | 10101000b = 11101111b
-11101111b | 10101001b = 11101111b
-11101111b | 10101010b = 11101111b
-11101111b | 10101011b = 11101111b
-11101111b | 10101100b = 11101111b
-11101111b | 10101101b = 11101111b
-11101111b | 10101110b = 11101111b
-11101111b | 10101111b = 11101111b
-11101111b | 10110000b = 11111111b
-11101111b | 10110001b = 11111111b
-11101111b | 10110010b = 11111111b
-11101111b | 10110011b = 11111111b
-11101111b | 10110100b = 11111111b
-11101111b | 10110101b = 11111111b
-11101111b | 10110110b = 11111111b
-11101111b | 10110111b = 11111111b
-11101111b | 10111000b = 11111111b
-11101111b | 10111001b = 11111111b
-11101111b | 10111010b = 11111111b
-11101111b | 10111011b = 11111111b
-11101111b | 10111100b = 11111111b
-11101111b | 10111101b = 11111111b
-11101111b | 10111110b = 11111111b
-11101111b | 10111111b = 11111111b
-11101111b | 11000000b = 11101111b
-11101111b | 11000001b = 11101111b
-11101111b | 11000010b = 11101111b
-11101111b | 11000011b = 11101111b
-11101111b | 11000100b = 11101111b
-11101111b | 11000101b = 11101111b
-11101111b | 11000110b = 11101111b
-11101111b | 11000111b = 11101111b
-11101111b | 11001000b = 11101111b
-11101111b | 11001001b = 11101111b
-11101111b | 11001010b = 11101111b
-11101111b | 11001011b = 11101111b
-11101111b | 11001100b = 11101111b
-11101111b | 11001101b = 11101111b
-11101111b | 11001110b = 11101111b
-11101111b | 11001111b = 11101111b
-11101111b | 11010000b = 11111111b
-11101111b | 11010001b = 11111111b
-11101111b | 11010010b = 11111111b
-11101111b | 11010011b = 11111111b
-11101111b | 11010100b = 11111111b
-11101111b | 11010101b = 11111111b
-11101111b | 11010110b = 11111111b
-11101111b | 11010111b = 11111111b
-11101111b | 11011000b = 11111111b
-11101111b | 11011001b = 11111111b
-11101111b | 11011010b = 11111111b
-11101111b | 11011011b = 11111111b
-11101111b | 11011100b = 11111111b
-11101111b | 11011101b = 11111111b
-11101111b | 11011110b = 11111111b
-11101111b | 11011111b = 11111111b
-11101111b | 11100000b = 11101111b
-11101111b | 11100001b = 11101111b
-11101111b | 11100010b = 11101111b
-11101111b | 11100011b = 11101111b
-11101111b | 11100100b = 11101111b
-11101111b | 11100101b = 11101111b
-11101111b | 11100110b = 11101111b
-11101111b | 11100111b = 11101111b
-11101111b | 11101000b = 11101111b
-11101111b | 11101001b = 11101111b
-11101111b | 11101010b = 11101111b
-11101111b | 11101011b = 11101111b
-11101111b | 11101100b = 11101111b
-11101111b | 11101101b = 11101111b
-11101111b | 11101110b = 11101111b
-11101111b | 11101111b = 11101111b
-11101111b | 11110000b = 11111111b
-11101111b | 11110001b = 11111111b
-11101111b | 11110010b = 11111111b
-11101111b | 11110011b = 11111111b
-11101111b | 11110100b = 11111111b
-11101111b | 11110101b = 11111111b
-11101111b | 11110110b = 11111111b
-11101111b | 11110111b = 11111111b
-11101111b | 11111000b = 11111111b
-11101111b | 11111001b = 11111111b
-11101111b | 11111010b = 11111111b
-11101111b | 11111011b = 11111111b
-11101111b | 11111100b = 11111111b
-11101111b | 11111101b = 11111111b
-11101111b | 11111110b = 11111111b
-11101111b | 11111111b = 11111111b
-11101111b | 00000000b = 11101111b
-11101111b | 00000001b = 11101111b
-11101111b | 00000010b = 11101111b
-11101111b | 00000011b = 11101111b
-11101111b | 00000100b = 11101111b
-11101111b | 00000101b = 11101111b
-11101111b | 00000110b = 11101111b
-11101111b | 00000111b = 11101111b
-11101111b | 00001000b = 11101111b
-11101111b | 00001001b = 11101111b
-11101111b | 00001010b = 11101111b
-11101111b | 00001011b = 11101111b
-11101111b | 00001100b = 11101111b
-11101111b | 00001101b = 11101111b
-11101111b | 00001110b = 11101111b
-11101111b | 00001111b = 11101111b
-11101111b | 00010000b = 11111111b
-11101111b | 00010001b = 11111111b
-11101111b | 00010010b = 11111111b
-11101111b | 00010011b = 11111111b
-11101111b | 00010100b = 11111111b
-11101111b | 00010101b = 11111111b
-11101111b | 00010110b = 11111111b
-11101111b | 00010111b = 11111111b
-11101111b | 00011000b = 11111111b
-11101111b | 00011001b = 11111111b
-11101111b | 00011010b = 11111111b
-11101111b | 00011011b = 11111111b
-11101111b | 00011100b = 11111111b
-11101111b | 00011101b = 11111111b
-11101111b | 00011110b = 11111111b
-11101111b | 00011111b = 11111111b
-11101111b | 00100000b = 11101111b
-11101111b | 00100001b = 11101111b
-11101111b | 00100010b = 11101111b
-11101111b | 00100011b = 11101111b
-11101111b | 00100100b = 11101111b
-11101111b | 00100101b = 11101111b
-11101111b | 00100110b = 11101111b
-11101111b | 00100111b = 11101111b
-11101111b | 00101000b = 11101111b
-11101111b | 00101001b = 11101111b
-11101111b | 00101010b = 11101111b
-11101111b | 00101011b = 11101111b
-11101111b | 00101100b = 11101111b
-11101111b | 00101101b = 11101111b
-11101111b | 00101110b = 11101111b
-11101111b | 00101111b = 11101111b
-11101111b | 00110000b = 11111111b
-11101111b | 00110001b = 11111111b
-11101111b | 00110010b = 11111111b
-11101111b | 00110011b = 11111111b
-11101111b | 00110100b = 11111111b
-11101111b | 00110101b = 11111111b
-11101111b | 00110110b = 11111111b
-11101111b | 00110111b = 11111111b
-11101111b | 00111000b = 11111111b
-11101111b | 00111001b = 11111111b
-11101111b | 00111010b = 11111111b
-11101111b | 00111011b = 11111111b
-11101111b | 00111100b = 11111111b
-11101111b | 00111101b = 11111111b
-11101111b | 00111110b = 11111111b
-11101111b | 00111111b = 11111111b
-11101111b | 01000000b = 11101111b
-11101111b | 01000001b = 11101111b
-11101111b | 01000010b = 11101111b
-11101111b | 01000011b = 11101111b
-11101111b | 01000100b = 11101111b
-11101111b | 01000101b = 11101111b
-11101111b | 01000110b = 11101111b
-11101111b | 01000111b = 11101111b
-11101111b | 01001000b = 11101111b
-11101111b | 01001001b = 11101111b
-11101111b | 01001010b = 11101111b
-11101111b | 01001011b = 11101111b
-11101111b | 01001100b = 11101111b
-11101111b | 01001101b = 11101111b
-11101111b | 01001110b = 11101111b
-11101111b | 01001111b = 11101111b
-11101111b | 01010000b = 11111111b
-11101111b | 01010001b = 11111111b
-11101111b | 01010010b = 11111111b
-11101111b | 01010011b = 11111111b
-11101111b | 01010100b = 11111111b
-11101111b | 01010101b = 11111111b
-11101111b | 01010110b = 11111111b
-11101111b | 01010111b = 11111111b
-11101111b | 01011000b = 11111111b
-11101111b | 01011001b = 11111111b
-11101111b | 01011010b = 11111111b
-11101111b | 01011011b = 11111111b
-11101111b | 01011100b = 11111111b
-11101111b | 01011101b = 11111111b
-11101111b | 01011110b = 11111111b
-11101111b | 01011111b = 11111111b
-11101111b | 01100000b = 11101111b
-11101111b | 01100001b = 11101111b
-11101111b | 01100010b = 11101111b
-11101111b | 01100011b = 11101111b
-11101111b | 01100100b = 11101111b
-11101111b | 01100101b = 11101111b
-11101111b | 01100110b = 11101111b
-11101111b | 01100111b = 11101111b
-11101111b | 01101000b = 11101111b
-11101111b | 01101001b = 11101111b
-11101111b | 01101010b = 11101111b
-11101111b | 01101011b = 11101111b
-11101111b | 01101100b = 11101111b
-11101111b | 01101101b = 11101111b
-11101111b | 01101110b = 11101111b
-11101111b | 01101111b = 11101111b
-11101111b | 01110000b = 11111111b
-11101111b | 01110001b = 11111111b
-11101111b | 01110010b = 11111111b
-11101111b | 01110011b = 11111111b
-11101111b | 01110100b = 11111111b
-11101111b | 01110101b = 11111111b
-11101111b | 01110110b = 11111111b
-11101111b | 01110111b = 11111111b
-11101111b | 01111000b = 11111111b
-11101111b | 01111001b = 11111111b
-11101111b | 01111010b = 11111111b
-11101111b | 01111011b = 11111111b
-11101111b | 01111100b = 11111111b
-11101111b | 01111101b = 11111111b
-11101111b | 01111110b = 11111111b
-11110000b | 10000000b = 11110000b
-11110000b | 10000001b = 11110001b
-11110000b | 10000010b = 11110010b
-11110000b | 10000011b = 11110011b
-11110000b | 10000100b = 11110100b
-11110000b | 10000101b = 11110101b
-11110000b | 10000110b = 11110110b
-11110000b | 10000111b = 11110111b
-11110000b | 10001000b = 11111000b
-11110000b | 10001001b = 11111001b
-11110000b | 10001010b = 11111010b
-11110000b | 10001011b = 11111011b
-11110000b | 10001100b = 11111100b
-11110000b | 10001101b = 11111101b
-11110000b | 10001110b = 11111110b
-11110000b | 10001111b = 11111111b
-11110000b | 10010000b = 11110000b
-11110000b | 10010001b = 11110001b
-11110000b | 10010010b = 11110010b
-11110000b | 10010011b = 11110011b
-11110000b | 10010100b = 11110100b
-11110000b | 10010101b = 11110101b
-11110000b | 10010110b = 11110110b
-11110000b | 10010111b = 11110111b
-11110000b | 10011000b = 11111000b
-11110000b | 10011001b = 11111001b
-11110000b | 10011010b = 11111010b
-11110000b | 10011011b = 11111011b
-11110000b | 10011100b = 11111100b
-11110000b | 10011101b = 11111101b
-11110000b | 10011110b = 11111110b
-11110000b | 10011111b = 11111111b
-11110000b | 10100000b = 11110000b
-11110000b | 10100001b = 11110001b
-11110000b | 10100010b = 11110010b
-11110000b | 10100011b = 11110011b
-11110000b | 10100100b = 11110100b
-11110000b | 10100101b = 11110101b
-11110000b | 10100110b = 11110110b
-11110000b | 10100111b = 11110111b
-11110000b | 10101000b = 11111000b
-11110000b | 10101001b = 11111001b
-11110000b | 10101010b = 11111010b
-11110000b | 10101011b = 11111011b
-11110000b | 10101100b = 11111100b
-11110000b | 10101101b = 11111101b
-11110000b | 10101110b = 11111110b
-11110000b | 10101111b = 11111111b
-11110000b | 10110000b = 11110000b
-11110000b | 10110001b = 11110001b
-11110000b | 10110010b = 11110010b
-11110000b | 10110011b = 11110011b
-11110000b | 10110100b = 11110100b
-11110000b | 10110101b = 11110101b
-11110000b | 10110110b = 11110110b
-11110000b | 10110111b = 11110111b
-11110000b | 10111000b = 11111000b
-11110000b | 10111001b = 11111001b
-11110000b | 10111010b = 11111010b
-11110000b | 10111011b = 11111011b
-11110000b | 10111100b = 11111100b
-11110000b | 10111101b = 11111101b
-11110000b | 10111110b = 11111110b
-11110000b | 10111111b = 11111111b
-11110000b | 11000000b = 11110000b
-11110000b | 11000001b = 11110001b
-11110000b | 11000010b = 11110010b
-11110000b | 11000011b = 11110011b
-11110000b | 11000100b = 11110100b
-11110000b | 11000101b = 11110101b
-11110000b | 11000110b = 11110110b
-11110000b | 11000111b = 11110111b
-11110000b | 11001000b = 11111000b
-11110000b | 11001001b = 11111001b
-11110000b | 11001010b = 11111010b
-11110000b | 11001011b = 11111011b
-11110000b | 11001100b = 11111100b
-11110000b | 11001101b = 11111101b
-11110000b | 11001110b = 11111110b
-11110000b | 11001111b = 11111111b
-11110000b | 11010000b = 11110000b
-11110000b | 11010001b = 11110001b
-11110000b | 11010010b = 11110010b
-11110000b | 11010011b = 11110011b
-11110000b | 11010100b = 11110100b
-11110000b | 11010101b = 11110101b
-11110000b | 11010110b = 11110110b
-11110000b | 11010111b = 11110111b
-11110000b | 11011000b = 11111000b
-11110000b | 11011001b = 11111001b
-11110000b | 11011010b = 11111010b
-11110000b | 11011011b = 11111011b
-11110000b | 11011100b = 11111100b
-11110000b | 11011101b = 11111101b
-11110000b | 11011110b = 11111110b
-11110000b | 11011111b = 11111111b
-11110000b | 11100000b = 11110000b
-11110000b | 11100001b = 11110001b
-11110000b | 11100010b = 11110010b
-11110000b | 11100011b = 11110011b
-11110000b | 11100100b = 11110100b
-11110000b | 11100101b = 11110101b
-11110000b | 11100110b = 11110110b
-11110000b | 11100111b = 11110111b
-11110000b | 11101000b = 11111000b
-11110000b | 11101001b = 11111001b
-11110000b | 11101010b = 11111010b
-11110000b | 11101011b = 11111011b
-11110000b | 11101100b = 11111100b
-11110000b | 11101101b = 11111101b
-11110000b | 11101110b = 11111110b
-11110000b | 11101111b = 11111111b
-11110000b | 11110000b = 11110000b
-11110000b | 11110001b = 11110001b
-11110000b | 11110010b = 11110010b
-11110000b | 11110011b = 11110011b
-11110000b | 11110100b = 11110100b
-11110000b | 11110101b = 11110101b
-11110000b | 11110110b = 11110110b
-11110000b | 11110111b = 11110111b
-11110000b | 11111000b = 11111000b
-11110000b | 11111001b = 11111001b
-11110000b | 11111010b = 11111010b
-11110000b | 11111011b = 11111011b
-11110000b | 11111100b = 11111100b
-11110000b | 11111101b = 11111101b
-11110000b | 11111110b = 11111110b
-11110000b | 11111111b = 11111111b
-11110000b | 00000000b = 11110000b
-11110000b | 00000001b = 11110001b
-11110000b | 00000010b = 11110010b
-11110000b | 00000011b = 11110011b
-11110000b | 00000100b = 11110100b
-11110000b | 00000101b = 11110101b
-11110000b | 00000110b = 11110110b
-11110000b | 00000111b = 11110111b
-11110000b | 00001000b = 11111000b
-11110000b | 00001001b = 11111001b
-11110000b | 00001010b = 11111010b
-11110000b | 00001011b = 11111011b
-11110000b | 00001100b = 11111100b
-11110000b | 00001101b = 11111101b
-11110000b | 00001110b = 11111110b
-11110000b | 00001111b = 11111111b
-11110000b | 00010000b = 11110000b
-11110000b | 00010001b = 11110001b
-11110000b | 00010010b = 11110010b
-11110000b | 00010011b = 11110011b
-11110000b | 00010100b = 11110100b
-11110000b | 00010101b = 11110101b
-11110000b | 00010110b = 11110110b
-11110000b | 00010111b = 11110111b
-11110000b | 00011000b = 11111000b
-11110000b | 00011001b = 11111001b
-11110000b | 00011010b = 11111010b
-11110000b | 00011011b = 11111011b
-11110000b | 00011100b = 11111100b
-11110000b | 00011101b = 11111101b
-11110000b | 00011110b = 11111110b
-11110000b | 00011111b = 11111111b
-11110000b | 00100000b = 11110000b
-11110000b | 00100001b = 11110001b
-11110000b | 00100010b = 11110010b
-11110000b | 00100011b = 11110011b
-11110000b | 00100100b = 11110100b
-11110000b | 00100101b = 11110101b
-11110000b | 00100110b = 11110110b
-11110000b | 00100111b = 11110111b
-11110000b | 00101000b = 11111000b
-11110000b | 00101001b = 11111001b
-11110000b | 00101010b = 11111010b
-11110000b | 00101011b = 11111011b
-11110000b | 00101100b = 11111100b
-11110000b | 00101101b = 11111101b
-11110000b | 00101110b = 11111110b
-11110000b | 00101111b = 11111111b
-11110000b | 00110000b = 11110000b
-11110000b | 00110001b = 11110001b
-11110000b | 00110010b = 11110010b
-11110000b | 00110011b = 11110011b
-11110000b | 00110100b = 11110100b
-11110000b | 00110101b = 11110101b
-11110000b | 00110110b = 11110110b
-11110000b | 00110111b = 11110111b
-11110000b | 00111000b = 11111000b
-11110000b | 00111001b = 11111001b
-11110000b | 00111010b = 11111010b
-11110000b | 00111011b = 11111011b
-11110000b | 00111100b = 11111100b
-11110000b | 00111101b = 11111101b
-11110000b | 00111110b = 11111110b
-11110000b | 00111111b = 11111111b
-11110000b | 01000000b = 11110000b
-11110000b | 01000001b = 11110001b
-11110000b | 01000010b = 11110010b
-11110000b | 01000011b = 11110011b
-11110000b | 01000100b = 11110100b
-11110000b | 01000101b = 11110101b
-11110000b | 01000110b = 11110110b
-11110000b | 01000111b = 11110111b
-11110000b | 01001000b = 11111000b
-11110000b | 01001001b = 11111001b
-11110000b | 01001010b = 11111010b
-11110000b | 01001011b = 11111011b
-11110000b | 01001100b = 11111100b
-11110000b | 01001101b = 11111101b
-11110000b | 01001110b = 11111110b
-11110000b | 01001111b = 11111111b
-11110000b | 01010000b = 11110000b
-11110000b | 01010001b = 11110001b
-11110000b | 01010010b = 11110010b
-11110000b | 01010011b = 11110011b
-11110000b | 01010100b = 11110100b
-11110000b | 01010101b = 11110101b
-11110000b | 01010110b = 11110110b
-11110000b | 01010111b = 11110111b
-11110000b | 01011000b = 11111000b
-11110000b | 01011001b = 11111001b
-11110000b | 01011010b = 11111010b
-11110000b | 01011011b = 11111011b
-11110000b | 01011100b = 11111100b
-11110000b | 01011101b = 11111101b
-11110000b | 01011110b = 11111110b
-11110000b | 01011111b = 11111111b
-11110000b | 01100000b = 11110000b
-11110000b | 01100001b = 11110001b
-11110000b | 01100010b = 11110010b
-11110000b | 01100011b = 11110011b
-11110000b | 01100100b = 11110100b
-11110000b | 01100101b = 11110101b
-11110000b | 01100110b = 11110110b
-11110000b | 01100111b = 11110111b
-11110000b | 01101000b = 11111000b
-11110000b | 01101001b = 11111001b
-11110000b | 01101010b = 11111010b
-11110000b | 01101011b = 11111011b
-11110000b | 01101100b = 11111100b
-11110000b | 01101101b = 11111101b
-11110000b | 01101110b = 11111110b
-11110000b | 01101111b = 11111111b
-11110000b | 01110000b = 11110000b
-11110000b | 01110001b = 11110001b
-11110000b | 01110010b = 11110010b
-11110000b | 01110011b = 11110011b
-11110000b | 01110100b = 11110100b
-11110000b | 01110101b = 11110101b
-11110000b | 01110110b = 11110110b
-11110000b | 01110111b = 11110111b
-11110000b | 01111000b = 11111000b
-11110000b | 01111001b = 11111001b
-11110000b | 01111010b = 11111010b
-11110000b | 01111011b = 11111011b
-11110000b | 01111100b = 11111100b
-11110000b | 01111101b = 11111101b
-11110000b | 01111110b = 11111110b
-11110001b | 10000000b = 11110001b
-11110001b | 10000001b = 11110001b
-11110001b | 10000010b = 11110011b
-11110001b | 10000011b = 11110011b
-11110001b | 10000100b = 11110101b
-11110001b | 10000101b = 11110101b
-11110001b | 10000110b = 11110111b
-11110001b | 10000111b = 11110111b
-11110001b | 10001000b = 11111001b
-11110001b | 10001001b = 11111001b
-11110001b | 10001010b = 11111011b
-11110001b | 10001011b = 11111011b
-11110001b | 10001100b = 11111101b
-11110001b | 10001101b = 11111101b
-11110001b | 10001110b = 11111111b
-11110001b | 10001111b = 11111111b
-11110001b | 10010000b = 11110001b
-11110001b | 10010001b = 11110001b
-11110001b | 10010010b = 11110011b
-11110001b | 10010011b = 11110011b
-11110001b | 10010100b = 11110101b
-11110001b | 10010101b = 11110101b
-11110001b | 10010110b = 11110111b
-11110001b | 10010111b = 11110111b
-11110001b | 10011000b = 11111001b
-11110001b | 10011001b = 11111001b
-11110001b | 10011010b = 11111011b
-11110001b | 10011011b = 11111011b
-11110001b | 10011100b = 11111101b
-11110001b | 10011101b = 11111101b
-11110001b | 10011110b = 11111111b
-11110001b | 10011111b = 11111111b
-11110001b | 10100000b = 11110001b
-11110001b | 10100001b = 11110001b
-11110001b | 10100010b = 11110011b
-11110001b | 10100011b = 11110011b
-11110001b | 10100100b = 11110101b
-11110001b | 10100101b = 11110101b
-11110001b | 10100110b = 11110111b
-11110001b | 10100111b = 11110111b
-11110001b | 10101000b = 11111001b
-11110001b | 10101001b = 11111001b
-11110001b | 10101010b = 11111011b
-11110001b | 10101011b = 11111011b
-11110001b | 10101100b = 11111101b
-11110001b | 10101101b = 11111101b
-11110001b | 10101110b = 11111111b
-11110001b | 10101111b = 11111111b
-11110001b | 10110000b = 11110001b
-11110001b | 10110001b = 11110001b
-11110001b | 10110010b = 11110011b
-11110001b | 10110011b = 11110011b
-11110001b | 10110100b = 11110101b
-11110001b | 10110101b = 11110101b
-11110001b | 10110110b = 11110111b
-11110001b | 10110111b = 11110111b
-11110001b | 10111000b = 11111001b
-11110001b | 10111001b = 11111001b
-11110001b | 10111010b = 11111011b
-11110001b | 10111011b = 11111011b
-11110001b | 10111100b = 11111101b
-11110001b | 10111101b = 11111101b
-11110001b | 10111110b = 11111111b
-11110001b | 10111111b = 11111111b
-11110001b | 11000000b = 11110001b
-11110001b | 11000001b = 11110001b
-11110001b | 11000010b = 11110011b
-11110001b | 11000011b = 11110011b
-11110001b | 11000100b = 11110101b
-11110001b | 11000101b = 11110101b
-11110001b | 11000110b = 11110111b
-11110001b | 11000111b = 11110111b
-11110001b | 11001000b = 11111001b
-11110001b | 11001001b = 11111001b
-11110001b | 11001010b = 11111011b
-11110001b | 11001011b = 11111011b
-11110001b | 11001100b = 11111101b
-11110001b | 11001101b = 11111101b
-11110001b | 11001110b = 11111111b
-11110001b | 11001111b = 11111111b
-11110001b | 11010000b = 11110001b
-11110001b | 11010001b = 11110001b
-11110001b | 11010010b = 11110011b
-11110001b | 11010011b = 11110011b
-11110001b | 11010100b = 11110101b
-11110001b | 11010101b = 11110101b
-11110001b | 11010110b = 11110111b
-11110001b | 11010111b = 11110111b
-11110001b | 11011000b = 11111001b
-11110001b | 11011001b = 11111001b
-11110001b | 11011010b = 11111011b
-11110001b | 11011011b = 11111011b
-11110001b | 11011100b = 11111101b
-11110001b | 11011101b = 11111101b
-11110001b | 11011110b = 11111111b
-11110001b | 11011111b = 11111111b
-11110001b | 11100000b = 11110001b
-11110001b | 11100001b = 11110001b
-11110001b | 11100010b = 11110011b
-11110001b | 11100011b = 11110011b
-11110001b | 11100100b = 11110101b
-11110001b | 11100101b = 11110101b
-11110001b | 11100110b = 11110111b
-11110001b | 11100111b = 11110111b
-11110001b | 11101000b = 11111001b
-11110001b | 11101001b = 11111001b
-11110001b | 11101010b = 11111011b
-11110001b | 11101011b = 11111011b
-11110001b | 11101100b = 11111101b
-11110001b | 11101101b = 11111101b
-11110001b | 11101110b = 11111111b
-11110001b | 11101111b = 11111111b
-11110001b | 11110000b = 11110001b
-11110001b | 11110001b = 11110001b
-11110001b | 11110010b = 11110011b
-11110001b | 11110011b = 11110011b
-11110001b | 11110100b = 11110101b
-11110001b | 11110101b = 11110101b
-11110001b | 11110110b = 11110111b
-11110001b | 11110111b = 11110111b
-11110001b | 11111000b = 11111001b
-11110001b | 11111001b = 11111001b
-11110001b | 11111010b = 11111011b
-11110001b | 11111011b = 11111011b
-11110001b | 11111100b = 11111101b
-11110001b | 11111101b = 11111101b
-11110001b | 11111110b = 11111111b
-11110001b | 11111111b = 11111111b
-11110001b | 00000000b = 11110001b
-11110001b | 00000001b = 11110001b
-11110001b | 00000010b = 11110011b
-11110001b | 00000011b = 11110011b
-11110001b | 00000100b = 11110101b
-11110001b | 00000101b = 11110101b
-11110001b | 00000110b = 11110111b
-11110001b | 00000111b = 11110111b
-11110001b | 00001000b = 11111001b
-11110001b | 00001001b = 11111001b
-11110001b | 00001010b = 11111011b
-11110001b | 00001011b = 11111011b
-11110001b | 00001100b = 11111101b
-11110001b | 00001101b = 11111101b
-11110001b | 00001110b = 11111111b
-11110001b | 00001111b = 11111111b
-11110001b | 00010000b = 11110001b
-11110001b | 00010001b = 11110001b
-11110001b | 00010010b = 11110011b
-11110001b | 00010011b = 11110011b
-11110001b | 00010100b = 11110101b
-11110001b | 00010101b = 11110101b
-11110001b | 00010110b = 11110111b
-11110001b | 00010111b = 11110111b
-11110001b | 00011000b = 11111001b
-11110001b | 00011001b = 11111001b
-11110001b | 00011010b = 11111011b
-11110001b | 00011011b = 11111011b
-11110001b | 00011100b = 11111101b
-11110001b | 00011101b = 11111101b
-11110001b | 00011110b = 11111111b
-11110001b | 00011111b = 11111111b
-11110001b | 00100000b = 11110001b
-11110001b | 00100001b = 11110001b
-11110001b | 00100010b = 11110011b
-11110001b | 00100011b = 11110011b
-11110001b | 00100100b = 11110101b
-11110001b | 00100101b = 11110101b
-11110001b | 00100110b = 11110111b
-11110001b | 00100111b = 11110111b
-11110001b | 00101000b = 11111001b
-11110001b | 00101001b = 11111001b
-11110001b | 00101010b = 11111011b
-11110001b | 00101011b = 11111011b
-11110001b | 00101100b = 11111101b
-11110001b | 00101101b = 11111101b
-11110001b | 00101110b = 11111111b
-11110001b | 00101111b = 11111111b
-11110001b | 00110000b = 11110001b
-11110001b | 00110001b = 11110001b
-11110001b | 00110010b = 11110011b
-11110001b | 00110011b = 11110011b
-11110001b | 00110100b = 11110101b
-11110001b | 00110101b = 11110101b
-11110001b | 00110110b = 11110111b
-11110001b | 00110111b = 11110111b
-11110001b | 00111000b = 11111001b
-11110001b | 00111001b = 11111001b
-11110001b | 00111010b = 11111011b
-11110001b | 00111011b = 11111011b
-11110001b | 00111100b = 11111101b
-11110001b | 00111101b = 11111101b
-11110001b | 00111110b = 11111111b
-11110001b | 00111111b = 11111111b
-11110001b | 01000000b = 11110001b
-11110001b | 01000001b = 11110001b
-11110001b | 01000010b = 11110011b
-11110001b | 01000011b = 11110011b
-11110001b | 01000100b = 11110101b
-11110001b | 01000101b = 11110101b
-11110001b | 01000110b = 11110111b
-11110001b | 01000111b = 11110111b
-11110001b | 01001000b = 11111001b
-11110001b | 01001001b = 11111001b
-11110001b | 01001010b = 11111011b
-11110001b | 01001011b = 11111011b
-11110001b | 01001100b = 11111101b
-11110001b | 01001101b = 11111101b
-11110001b | 01001110b = 11111111b
-11110001b | 01001111b = 11111111b
-11110001b | 01010000b = 11110001b
-11110001b | 01010001b = 11110001b
-11110001b | 01010010b = 11110011b
-11110001b | 01010011b = 11110011b
-11110001b | 01010100b = 11110101b
-11110001b | 01010101b = 11110101b
-11110001b | 01010110b = 11110111b
-11110001b | 01010111b = 11110111b
-11110001b | 01011000b = 11111001b
-11110001b | 01011001b = 11111001b
-11110001b | 01011010b = 11111011b
-11110001b | 01011011b = 11111011b
-11110001b | 01011100b = 11111101b
-11110001b | 01011101b = 11111101b
-11110001b | 01011110b = 11111111b
-11110001b | 01011111b = 11111111b
-11110001b | 01100000b = 11110001b
-11110001b | 01100001b = 11110001b
-11110001b | 01100010b = 11110011b
-11110001b | 01100011b = 11110011b
-11110001b | 01100100b = 11110101b
-11110001b | 01100101b = 11110101b
-11110001b | 01100110b = 11110111b
-11110001b | 01100111b = 11110111b
-11110001b | 01101000b = 11111001b
-11110001b | 01101001b = 11111001b
-11110001b | 01101010b = 11111011b
-11110001b | 01101011b = 11111011b
-11110001b | 01101100b = 11111101b
-11110001b | 01101101b = 11111101b
-11110001b | 01101110b = 11111111b
-11110001b | 01101111b = 11111111b
-11110001b | 01110000b = 11110001b
-11110001b | 01110001b = 11110001b
-11110001b | 01110010b = 11110011b
-11110001b | 01110011b = 11110011b
-11110001b | 01110100b = 11110101b
-11110001b | 01110101b = 11110101b
-11110001b | 01110110b = 11110111b
-11110001b | 01110111b = 11110111b
-11110001b | 01111000b = 11111001b
-11110001b | 01111001b = 11111001b
-11110001b | 01111010b = 11111011b
-11110001b | 01111011b = 11111011b
-11110001b | 01111100b = 11111101b
-11110001b | 01111101b = 11111101b
-11110001b | 01111110b = 11111111b
-11110010b | 10000000b = 11110010b
-11110010b | 10000001b = 11110011b
-11110010b | 10000010b = 11110010b
-11110010b | 10000011b = 11110011b
-11110010b | 10000100b = 11110110b
-11110010b | 10000101b = 11110111b
-11110010b | 10000110b = 11110110b
-11110010b | 10000111b = 11110111b
-11110010b | 10001000b = 11111010b
-11110010b | 10001001b = 11111011b
-11110010b | 10001010b = 11111010b
-11110010b | 10001011b = 11111011b
-11110010b | 10001100b = 11111110b
-11110010b | 10001101b = 11111111b
-11110010b | 10001110b = 11111110b
-11110010b | 10001111b = 11111111b
-11110010b | 10010000b = 11110010b
-11110010b | 10010001b = 11110011b
-11110010b | 10010010b = 11110010b
-11110010b | 10010011b = 11110011b
-11110010b | 10010100b = 11110110b
-11110010b | 10010101b = 11110111b
-11110010b | 10010110b = 11110110b
-11110010b | 10010111b = 11110111b
-11110010b | 10011000b = 11111010b
-11110010b | 10011001b = 11111011b
-11110010b | 10011010b = 11111010b
-11110010b | 10011011b = 11111011b
-11110010b | 10011100b = 11111110b
-11110010b | 10011101b = 11111111b
-11110010b | 10011110b = 11111110b
-11110010b | 10011111b = 11111111b
-11110010b | 10100000b = 11110010b
-11110010b | 10100001b = 11110011b
-11110010b | 10100010b = 11110010b
-11110010b | 10100011b = 11110011b
-11110010b | 10100100b = 11110110b
-11110010b | 10100101b = 11110111b
-11110010b | 10100110b = 11110110b
-11110010b | 10100111b = 11110111b
-11110010b | 10101000b = 11111010b
-11110010b | 10101001b = 11111011b
-11110010b | 10101010b = 11111010b
-11110010b | 10101011b = 11111011b
-11110010b | 10101100b = 11111110b
-11110010b | 10101101b = 11111111b
-11110010b | 10101110b = 11111110b
-11110010b | 10101111b = 11111111b
-11110010b | 10110000b = 11110010b
-11110010b | 10110001b = 11110011b
-11110010b | 10110010b = 11110010b
-11110010b | 10110011b = 11110011b
-11110010b | 10110100b = 11110110b
-11110010b | 10110101b = 11110111b
-11110010b | 10110110b = 11110110b
-11110010b | 10110111b = 11110111b
-11110010b | 10111000b = 11111010b
-11110010b | 10111001b = 11111011b
-11110010b | 10111010b = 11111010b
-11110010b | 10111011b = 11111011b
-11110010b | 10111100b = 11111110b
-11110010b | 10111101b = 11111111b
-11110010b | 10111110b = 11111110b
-11110010b | 10111111b = 11111111b
-11110010b | 11000000b = 11110010b
-11110010b | 11000001b = 11110011b
-11110010b | 11000010b = 11110010b
-11110010b | 11000011b = 11110011b
-11110010b | 11000100b = 11110110b
-11110010b | 11000101b = 11110111b
-11110010b | 11000110b = 11110110b
-11110010b | 11000111b = 11110111b
-11110010b | 11001000b = 11111010b
-11110010b | 11001001b = 11111011b
-11110010b | 11001010b = 11111010b
-11110010b | 11001011b = 11111011b
-11110010b | 11001100b = 11111110b
-11110010b | 11001101b = 11111111b
-11110010b | 11001110b = 11111110b
-11110010b | 11001111b = 11111111b
-11110010b | 11010000b = 11110010b
-11110010b | 11010001b = 11110011b
-11110010b | 11010010b = 11110010b
-11110010b | 11010011b = 11110011b
-11110010b | 11010100b = 11110110b
-11110010b | 11010101b = 11110111b
-11110010b | 11010110b = 11110110b
-11110010b | 11010111b = 11110111b
-11110010b | 11011000b = 11111010b
-11110010b | 11011001b = 11111011b
-11110010b | 11011010b = 11111010b
-11110010b | 11011011b = 11111011b
-11110010b | 11011100b = 11111110b
-11110010b | 11011101b = 11111111b
-11110010b | 11011110b = 11111110b
-11110010b | 11011111b = 11111111b
-11110010b | 11100000b = 11110010b
-11110010b | 11100001b = 11110011b
-11110010b | 11100010b = 11110010b
-11110010b | 11100011b = 11110011b
-11110010b | 11100100b = 11110110b
-11110010b | 11100101b = 11110111b
-11110010b | 11100110b = 11110110b
-11110010b | 11100111b = 11110111b
-11110010b | 11101000b = 11111010b
-11110010b | 11101001b = 11111011b
-11110010b | 11101010b = 11111010b
-11110010b | 11101011b = 11111011b
-11110010b | 11101100b = 11111110b
-11110010b | 11101101b = 11111111b
-11110010b | 11101110b = 11111110b
-11110010b | 11101111b = 11111111b
-11110010b | 11110000b = 11110010b
-11110010b | 11110001b = 11110011b
-11110010b | 11110010b = 11110010b
-11110010b | 11110011b = 11110011b
-11110010b | 11110100b = 11110110b
-11110010b | 11110101b = 11110111b
-11110010b | 11110110b = 11110110b
-11110010b | 11110111b = 11110111b
-11110010b | 11111000b = 11111010b
-11110010b | 11111001b = 11111011b
-11110010b | 11111010b = 11111010b
-11110010b | 11111011b = 11111011b
-11110010b | 11111100b = 11111110b
-11110010b | 11111101b = 11111111b
-11110010b | 11111110b = 11111110b
-11110010b | 11111111b = 11111111b
-11110010b | 00000000b = 11110010b
-11110010b | 00000001b = 11110011b
-11110010b | 00000010b = 11110010b
-11110010b | 00000011b = 11110011b
-11110010b | 00000100b = 11110110b
-11110010b | 00000101b = 11110111b
-11110010b | 00000110b = 11110110b
-11110010b | 00000111b = 11110111b
-11110010b | 00001000b = 11111010b
-11110010b | 00001001b = 11111011b
-11110010b | 00001010b = 11111010b
-11110010b | 00001011b = 11111011b
-11110010b | 00001100b = 11111110b
-11110010b | 00001101b = 11111111b
-11110010b | 00001110b = 11111110b
-11110010b | 00001111b = 11111111b
-11110010b | 00010000b = 11110010b
-11110010b | 00010001b = 11110011b
-11110010b | 00010010b = 11110010b
-11110010b | 00010011b = 11110011b
-11110010b | 00010100b = 11110110b
-11110010b | 00010101b = 11110111b
-11110010b | 00010110b = 11110110b
-11110010b | 00010111b = 11110111b
-11110010b | 00011000b = 11111010b
-11110010b | 00011001b = 11111011b
-11110010b | 00011010b = 11111010b
-11110010b | 00011011b = 11111011b
-11110010b | 00011100b = 11111110b
-11110010b | 00011101b = 11111111b
-11110010b | 00011110b = 11111110b
-11110010b | 00011111b = 11111111b
-11110010b | 00100000b = 11110010b
-11110010b | 00100001b = 11110011b
-11110010b | 00100010b = 11110010b
-11110010b | 00100011b = 11110011b
-11110010b | 00100100b = 11110110b
-11110010b | 00100101b = 11110111b
-11110010b | 00100110b = 11110110b
-11110010b | 00100111b = 11110111b
-11110010b | 00101000b = 11111010b
-11110010b | 00101001b = 11111011b
-11110010b | 00101010b = 11111010b
-11110010b | 00101011b = 11111011b
-11110010b | 00101100b = 11111110b
-11110010b | 00101101b = 11111111b
-11110010b | 00101110b = 11111110b
-11110010b | 00101111b = 11111111b
-11110010b | 00110000b = 11110010b
-11110010b | 00110001b = 11110011b
-11110010b | 00110010b = 11110010b
-11110010b | 00110011b = 11110011b
-11110010b | 00110100b = 11110110b
-11110010b | 00110101b = 11110111b
-11110010b | 00110110b = 11110110b
-11110010b | 00110111b = 11110111b
-11110010b | 00111000b = 11111010b
-11110010b | 00111001b = 11111011b
-11110010b | 00111010b = 11111010b
-11110010b | 00111011b = 11111011b
-11110010b | 00111100b = 11111110b
-11110010b | 00111101b = 11111111b
-11110010b | 00111110b = 11111110b
-11110010b | 00111111b = 11111111b
-11110010b | 01000000b = 11110010b
-11110010b | 01000001b = 11110011b
-11110010b | 01000010b = 11110010b
-11110010b | 01000011b = 11110011b
-11110010b | 01000100b = 11110110b
-11110010b | 01000101b = 11110111b
-11110010b | 01000110b = 11110110b
-11110010b | 01000111b = 11110111b
-11110010b | 01001000b = 11111010b
-11110010b | 01001001b = 11111011b
-11110010b | 01001010b = 11111010b
-11110010b | 01001011b = 11111011b
-11110010b | 01001100b = 11111110b
-11110010b | 01001101b = 11111111b
-11110010b | 01001110b = 11111110b
-11110010b | 01001111b = 11111111b
-11110010b | 01010000b = 11110010b
-11110010b | 01010001b = 11110011b
-11110010b | 01010010b = 11110010b
-11110010b | 01010011b = 11110011b
-11110010b | 01010100b = 11110110b
-11110010b | 01010101b = 11110111b
-11110010b | 01010110b = 11110110b
-11110010b | 01010111b = 11110111b
-11110010b | 01011000b = 11111010b
-11110010b | 01011001b = 11111011b
-11110010b | 01011010b = 11111010b
-11110010b | 01011011b = 11111011b
-11110010b | 01011100b = 11111110b
-11110010b | 01011101b = 11111111b
-11110010b | 01011110b = 11111110b
-11110010b | 01011111b = 11111111b
-11110010b | 01100000b = 11110010b
-11110010b | 01100001b = 11110011b
-11110010b | 01100010b = 11110010b
-11110010b | 01100011b = 11110011b
-11110010b | 01100100b = 11110110b
-11110010b | 01100101b = 11110111b
-11110010b | 01100110b = 11110110b
-11110010b | 01100111b = 11110111b
-11110010b | 01101000b = 11111010b
-11110010b | 01101001b = 11111011b
-11110010b | 01101010b = 11111010b
-11110010b | 01101011b = 11111011b
-11110010b | 01101100b = 11111110b
-11110010b | 01101101b = 11111111b
-11110010b | 01101110b = 11111110b
-11110010b | 01101111b = 11111111b
-11110010b | 01110000b = 11110010b
-11110010b | 01110001b = 11110011b
-11110010b | 01110010b = 11110010b
-11110010b | 01110011b = 11110011b
-11110010b | 01110100b = 11110110b
-11110010b | 01110101b = 11110111b
-11110010b | 01110110b = 11110110b
-11110010b | 01110111b = 11110111b
-11110010b | 01111000b = 11111010b
-11110010b | 01111001b = 11111011b
-11110010b | 01111010b = 11111010b
-11110010b | 01111011b = 11111011b
-11110010b | 01111100b = 11111110b
-11110010b | 01111101b = 11111111b
-11110010b | 01111110b = 11111110b
-11110011b | 10000000b = 11110011b
-11110011b | 10000001b = 11110011b
-11110011b | 10000010b = 11110011b
-11110011b | 10000011b = 11110011b
-11110011b | 10000100b = 11110111b
-11110011b | 10000101b = 11110111b
-11110011b | 10000110b = 11110111b
-11110011b | 10000111b = 11110111b
-11110011b | 10001000b = 11111011b
-11110011b | 10001001b = 11111011b
-11110011b | 10001010b = 11111011b
-11110011b | 10001011b = 11111011b
-11110011b | 10001100b = 11111111b
-11110011b | 10001101b = 11111111b
-11110011b | 10001110b = 11111111b
-11110011b | 10001111b = 11111111b
-11110011b | 10010000b = 11110011b
-11110011b | 10010001b = 11110011b
-11110011b | 10010010b = 11110011b
-11110011b | 10010011b = 11110011b
-11110011b | 10010100b = 11110111b
-11110011b | 10010101b = 11110111b
-11110011b | 10010110b = 11110111b
-11110011b | 10010111b = 11110111b
-11110011b | 10011000b = 11111011b
-11110011b | 10011001b = 11111011b
-11110011b | 10011010b = 11111011b
-11110011b | 10011011b = 11111011b
-11110011b | 10011100b = 11111111b
-11110011b | 10011101b = 11111111b
-11110011b | 10011110b = 11111111b
-11110011b | 10011111b = 11111111b
-11110011b | 10100000b = 11110011b
-11110011b | 10100001b = 11110011b
-11110011b | 10100010b = 11110011b
-11110011b | 10100011b = 11110011b
-11110011b | 10100100b = 11110111b
-11110011b | 10100101b = 11110111b
-11110011b | 10100110b = 11110111b
-11110011b | 10100111b = 11110111b
-11110011b | 10101000b = 11111011b
-11110011b | 10101001b = 11111011b
-11110011b | 10101010b = 11111011b
-11110011b | 10101011b = 11111011b
-11110011b | 10101100b = 11111111b
-11110011b | 10101101b = 11111111b
-11110011b | 10101110b = 11111111b
-11110011b | 10101111b = 11111111b
-11110011b | 10110000b = 11110011b
-11110011b | 10110001b = 11110011b
-11110011b | 10110010b = 11110011b
-11110011b | 10110011b = 11110011b
-11110011b | 10110100b = 11110111b
-11110011b | 10110101b = 11110111b
-11110011b | 10110110b = 11110111b
-11110011b | 10110111b = 11110111b
-11110011b | 10111000b = 11111011b
-11110011b | 10111001b = 11111011b
-11110011b | 10111010b = 11111011b
-11110011b | 10111011b = 11111011b
-11110011b | 10111100b = 11111111b
-11110011b | 10111101b = 11111111b
-11110011b | 10111110b = 11111111b
-11110011b | 10111111b = 11111111b
-11110011b | 11000000b = 11110011b
-11110011b | 11000001b = 11110011b
-11110011b | 11000010b = 11110011b
-11110011b | 11000011b = 11110011b
-11110011b | 11000100b = 11110111b
-11110011b | 11000101b = 11110111b
-11110011b | 11000110b = 11110111b
-11110011b | 11000111b = 11110111b
-11110011b | 11001000b = 11111011b
-11110011b | 11001001b = 11111011b
-11110011b | 11001010b = 11111011b
-11110011b | 11001011b = 11111011b
-11110011b | 11001100b = 11111111b
-11110011b | 11001101b = 11111111b
-11110011b | 11001110b = 11111111b
-11110011b | 11001111b = 11111111b
-11110011b | 11010000b = 11110011b
-11110011b | 11010001b = 11110011b
-11110011b | 11010010b = 11110011b
-11110011b | 11010011b = 11110011b
-11110011b | 11010100b = 11110111b
-11110011b | 11010101b = 11110111b
-11110011b | 11010110b = 11110111b
-11110011b | 11010111b = 11110111b
-11110011b | 11011000b = 11111011b
-11110011b | 11011001b = 11111011b
-11110011b | 11011010b = 11111011b
-11110011b | 11011011b = 11111011b
-11110011b | 11011100b = 11111111b
-11110011b | 11011101b = 11111111b
-11110011b | 11011110b = 11111111b
-11110011b | 11011111b = 11111111b
-11110011b | 11100000b = 11110011b
-11110011b | 11100001b = 11110011b
-11110011b | 11100010b = 11110011b
-11110011b | 11100011b = 11110011b
-11110011b | 11100100b = 11110111b
-11110011b | 11100101b = 11110111b
-11110011b | 11100110b = 11110111b
-11110011b | 11100111b = 11110111b
-11110011b | 11101000b = 11111011b
-11110011b | 11101001b = 11111011b
-11110011b | 11101010b = 11111011b
-11110011b | 11101011b = 11111011b
-11110011b | 11101100b = 11111111b
-11110011b | 11101101b = 11111111b
-11110011b | 11101110b = 11111111b
-11110011b | 11101111b = 11111111b
-11110011b | 11110000b = 11110011b
-11110011b | 11110001b = 11110011b
-11110011b | 11110010b = 11110011b
-11110011b | 11110011b = 11110011b
-11110011b | 11110100b = 11110111b
-11110011b | 11110101b = 11110111b
-11110011b | 11110110b = 11110111b
-11110011b | 11110111b = 11110111b
-11110011b | 11111000b = 11111011b
-11110011b | 11111001b = 11111011b
-11110011b | 11111010b = 11111011b
-11110011b | 11111011b = 11111011b
-11110011b | 11111100b = 11111111b
-11110011b | 11111101b = 11111111b
-11110011b | 11111110b = 11111111b
-11110011b | 11111111b = 11111111b
-11110011b | 00000000b = 11110011b
-11110011b | 00000001b = 11110011b
-11110011b | 00000010b = 11110011b
-11110011b | 00000011b = 11110011b
-11110011b | 00000100b = 11110111b
-11110011b | 00000101b = 11110111b
-11110011b | 00000110b = 11110111b
-11110011b | 00000111b = 11110111b
-11110011b | 00001000b = 11111011b
-11110011b | 00001001b = 11111011b
-11110011b | 00001010b = 11111011b
-11110011b | 00001011b = 11111011b
-11110011b | 00001100b = 11111111b
-11110011b | 00001101b = 11111111b
-11110011b | 00001110b = 11111111b
-11110011b | 00001111b = 11111111b
-11110011b | 00010000b = 11110011b
-11110011b | 00010001b = 11110011b
-11110011b | 00010010b = 11110011b
-11110011b | 00010011b = 11110011b
-11110011b | 00010100b = 11110111b
-11110011b | 00010101b = 11110111b
-11110011b | 00010110b = 11110111b
-11110011b | 00010111b = 11110111b
-11110011b | 00011000b = 11111011b
-11110011b | 00011001b = 11111011b
-11110011b | 00011010b = 11111011b
-11110011b | 00011011b = 11111011b
-11110011b | 00011100b = 11111111b
-11110011b | 00011101b = 11111111b
-11110011b | 00011110b = 11111111b
-11110011b | 00011111b = 11111111b
-11110011b | 00100000b = 11110011b
-11110011b | 00100001b = 11110011b
-11110011b | 00100010b = 11110011b
-11110011b | 00100011b = 11110011b
-11110011b | 00100100b = 11110111b
-11110011b | 00100101b = 11110111b
-11110011b | 00100110b = 11110111b
-11110011b | 00100111b = 11110111b
-11110011b | 00101000b = 11111011b
-11110011b | 00101001b = 11111011b
-11110011b | 00101010b = 11111011b
-11110011b | 00101011b = 11111011b
-11110011b | 00101100b = 11111111b
-11110011b | 00101101b = 11111111b
-11110011b | 00101110b = 11111111b
-11110011b | 00101111b = 11111111b
-11110011b | 00110000b = 11110011b
-11110011b | 00110001b = 11110011b
-11110011b | 00110010b = 11110011b
-11110011b | 00110011b = 11110011b
-11110011b | 00110100b = 11110111b
-11110011b | 00110101b = 11110111b
-11110011b | 00110110b = 11110111b
-11110011b | 00110111b = 11110111b
-11110011b | 00111000b = 11111011b
-11110011b | 00111001b = 11111011b
-11110011b | 00111010b = 11111011b
-11110011b | 00111011b = 11111011b
-11110011b | 00111100b = 11111111b
-11110011b | 00111101b = 11111111b
-11110011b | 00111110b = 11111111b
-11110011b | 00111111b = 11111111b
-11110011b | 01000000b = 11110011b
-11110011b | 01000001b = 11110011b
-11110011b | 01000010b = 11110011b
-11110011b | 01000011b = 11110011b
-11110011b | 01000100b = 11110111b
-11110011b | 01000101b = 11110111b
-11110011b | 01000110b = 11110111b
-11110011b | 01000111b = 11110111b
-11110011b | 01001000b = 11111011b
-11110011b | 01001001b = 11111011b
-11110011b | 01001010b = 11111011b
-11110011b | 01001011b = 11111011b
-11110011b | 01001100b = 11111111b
-11110011b | 01001101b = 11111111b
-11110011b | 01001110b = 11111111b
-11110011b | 01001111b = 11111111b
-11110011b | 01010000b = 11110011b
-11110011b | 01010001b = 11110011b
-11110011b | 01010010b = 11110011b
-11110011b | 01010011b = 11110011b
-11110011b | 01010100b = 11110111b
-11110011b | 01010101b = 11110111b
-11110011b | 01010110b = 11110111b
-11110011b | 01010111b = 11110111b
-11110011b | 01011000b = 11111011b
-11110011b | 01011001b = 11111011b
-11110011b | 01011010b = 11111011b
-11110011b | 01011011b = 11111011b
-11110011b | 01011100b = 11111111b
-11110011b | 01011101b = 11111111b
-11110011b | 01011110b = 11111111b
-11110011b | 01011111b = 11111111b
-11110011b | 01100000b = 11110011b
-11110011b | 01100001b = 11110011b
-11110011b | 01100010b = 11110011b
-11110011b | 01100011b = 11110011b
-11110011b | 01100100b = 11110111b
-11110011b | 01100101b = 11110111b
-11110011b | 01100110b = 11110111b
-11110011b | 01100111b = 11110111b
-11110011b | 01101000b = 11111011b
-11110011b | 01101001b = 11111011b
-11110011b | 01101010b = 11111011b
-11110011b | 01101011b = 11111011b
-11110011b | 01101100b = 11111111b
-11110011b | 01101101b = 11111111b
-11110011b | 01101110b = 11111111b
-11110011b | 01101111b = 11111111b
-11110011b | 01110000b = 11110011b
-11110011b | 01110001b = 11110011b
-11110011b | 01110010b = 11110011b
-11110011b | 01110011b = 11110011b
-11110011b | 01110100b = 11110111b
-11110011b | 01110101b = 11110111b
-11110011b | 01110110b = 11110111b
-11110011b | 01110111b = 11110111b
-11110011b | 01111000b = 11111011b
-11110011b | 01111001b = 11111011b
-11110011b | 01111010b = 11111011b
-11110011b | 01111011b = 11111011b
-11110011b | 01111100b = 11111111b
-11110011b | 01111101b = 11111111b
-11110011b | 01111110b = 11111111b
-11110100b | 10000000b = 11110100b
-11110100b | 10000001b = 11110101b
-11110100b | 10000010b = 11110110b
-11110100b | 10000011b = 11110111b
-11110100b | 10000100b = 11110100b
-11110100b | 10000101b = 11110101b
-11110100b | 10000110b = 11110110b
-11110100b | 10000111b = 11110111b
-11110100b | 10001000b = 11111100b
-11110100b | 10001001b = 11111101b
-11110100b | 10001010b = 11111110b
-11110100b | 10001011b = 11111111b
-11110100b | 10001100b = 11111100b
-11110100b | 10001101b = 11111101b
-11110100b | 10001110b = 11111110b
-11110100b | 10001111b = 11111111b
-11110100b | 10010000b = 11110100b
-11110100b | 10010001b = 11110101b
-11110100b | 10010010b = 11110110b
-11110100b | 10010011b = 11110111b
-11110100b | 10010100b = 11110100b
-11110100b | 10010101b = 11110101b
-11110100b | 10010110b = 11110110b
-11110100b | 10010111b = 11110111b
-11110100b | 10011000b = 11111100b
-11110100b | 10011001b = 11111101b
-11110100b | 10011010b = 11111110b
-11110100b | 10011011b = 11111111b
-11110100b | 10011100b = 11111100b
-11110100b | 10011101b = 11111101b
-11110100b | 10011110b = 11111110b
-11110100b | 10011111b = 11111111b
-11110100b | 10100000b = 11110100b
-11110100b | 10100001b = 11110101b
-11110100b | 10100010b = 11110110b
-11110100b | 10100011b = 11110111b
-11110100b | 10100100b = 11110100b
-11110100b | 10100101b = 11110101b
-11110100b | 10100110b = 11110110b
-11110100b | 10100111b = 11110111b
-11110100b | 10101000b = 11111100b
-11110100b | 10101001b = 11111101b
-11110100b | 10101010b = 11111110b
-11110100b | 10101011b = 11111111b
-11110100b | 10101100b = 11111100b
-11110100b | 10101101b = 11111101b
-11110100b | 10101110b = 11111110b
-11110100b | 10101111b = 11111111b
-11110100b | 10110000b = 11110100b
-11110100b | 10110001b = 11110101b
-11110100b | 10110010b = 11110110b
-11110100b | 10110011b = 11110111b
-11110100b | 10110100b = 11110100b
-11110100b | 10110101b = 11110101b
-11110100b | 10110110b = 11110110b
-11110100b | 10110111b = 11110111b
-11110100b | 10111000b = 11111100b
-11110100b | 10111001b = 11111101b
-11110100b | 10111010b = 11111110b
-11110100b | 10111011b = 11111111b
-11110100b | 10111100b = 11111100b
-11110100b | 10111101b = 11111101b
-11110100b | 10111110b = 11111110b
-11110100b | 10111111b = 11111111b
-11110100b | 11000000b = 11110100b
-11110100b | 11000001b = 11110101b
-11110100b | 11000010b = 11110110b
-11110100b | 11000011b = 11110111b
-11110100b | 11000100b = 11110100b
-11110100b | 11000101b = 11110101b
-11110100b | 11000110b = 11110110b
-11110100b | 11000111b = 11110111b
-11110100b | 11001000b = 11111100b
-11110100b | 11001001b = 11111101b
-11110100b | 11001010b = 11111110b
-11110100b | 11001011b = 11111111b
-11110100b | 11001100b = 11111100b
-11110100b | 11001101b = 11111101b
-11110100b | 11001110b = 11111110b
-11110100b | 11001111b = 11111111b
-11110100b | 11010000b = 11110100b
-11110100b | 11010001b = 11110101b
-11110100b | 11010010b = 11110110b
-11110100b | 11010011b = 11110111b
-11110100b | 11010100b = 11110100b
-11110100b | 11010101b = 11110101b
-11110100b | 11010110b = 11110110b
-11110100b | 11010111b = 11110111b
-11110100b | 11011000b = 11111100b
-11110100b | 11011001b = 11111101b
-11110100b | 11011010b = 11111110b
-11110100b | 11011011b = 11111111b
-11110100b | 11011100b = 11111100b
-11110100b | 11011101b = 11111101b
-11110100b | 11011110b = 11111110b
-11110100b | 11011111b = 11111111b
-11110100b | 11100000b = 11110100b
-11110100b | 11100001b = 11110101b
-11110100b | 11100010b = 11110110b
-11110100b | 11100011b = 11110111b
-11110100b | 11100100b = 11110100b
-11110100b | 11100101b = 11110101b
-11110100b | 11100110b = 11110110b
-11110100b | 11100111b = 11110111b
-11110100b | 11101000b = 11111100b
-11110100b | 11101001b = 11111101b
-11110100b | 11101010b = 11111110b
-11110100b | 11101011b = 11111111b
-11110100b | 11101100b = 11111100b
-11110100b | 11101101b = 11111101b
-11110100b | 11101110b = 11111110b
-11110100b | 11101111b = 11111111b
-11110100b | 11110000b = 11110100b
-11110100b | 11110001b = 11110101b
-11110100b | 11110010b = 11110110b
-11110100b | 11110011b = 11110111b
-11110100b | 11110100b = 11110100b
-11110100b | 11110101b = 11110101b
-11110100b | 11110110b = 11110110b
-11110100b | 11110111b = 11110111b
-11110100b | 11111000b = 11111100b
-11110100b | 11111001b = 11111101b
-11110100b | 11111010b = 11111110b
-11110100b | 11111011b = 11111111b
-11110100b | 11111100b = 11111100b
-11110100b | 11111101b = 11111101b
-11110100b | 11111110b = 11111110b
-11110100b | 11111111b = 11111111b
-11110100b | 00000000b = 11110100b
-11110100b | 00000001b = 11110101b
-11110100b | 00000010b = 11110110b
-11110100b | 00000011b = 11110111b
-11110100b | 00000100b = 11110100b
-11110100b | 00000101b = 11110101b
-11110100b | 00000110b = 11110110b
-11110100b | 00000111b = 11110111b
-11110100b | 00001000b = 11111100b
-11110100b | 00001001b = 11111101b
-11110100b | 00001010b = 11111110b
-11110100b | 00001011b = 11111111b
-11110100b | 00001100b = 11111100b
-11110100b | 00001101b = 11111101b
-11110100b | 00001110b = 11111110b
-11110100b | 00001111b = 11111111b
-11110100b | 00010000b = 11110100b
-11110100b | 00010001b = 11110101b
-11110100b | 00010010b = 11110110b
-11110100b | 00010011b = 11110111b
-11110100b | 00010100b = 11110100b
-11110100b | 00010101b = 11110101b
-11110100b | 00010110b = 11110110b
-11110100b | 00010111b = 11110111b
-11110100b | 00011000b = 11111100b
-11110100b | 00011001b = 11111101b
-11110100b | 00011010b = 11111110b
-11110100b | 00011011b = 11111111b
-11110100b | 00011100b = 11111100b
-11110100b | 00011101b = 11111101b
-11110100b | 00011110b = 11111110b
-11110100b | 00011111b = 11111111b
-11110100b | 00100000b = 11110100b
-11110100b | 00100001b = 11110101b
-11110100b | 00100010b = 11110110b
-11110100b | 00100011b = 11110111b
-11110100b | 00100100b = 11110100b
-11110100b | 00100101b = 11110101b
-11110100b | 00100110b = 11110110b
-11110100b | 00100111b = 11110111b
-11110100b | 00101000b = 11111100b
-11110100b | 00101001b = 11111101b
-11110100b | 00101010b = 11111110b
-11110100b | 00101011b = 11111111b
-11110100b | 00101100b = 11111100b
-11110100b | 00101101b = 11111101b
-11110100b | 00101110b = 11111110b
-11110100b | 00101111b = 11111111b
-11110100b | 00110000b = 11110100b
-11110100b | 00110001b = 11110101b
-11110100b | 00110010b = 11110110b
-11110100b | 00110011b = 11110111b
-11110100b | 00110100b = 11110100b
-11110100b | 00110101b = 11110101b
-11110100b | 00110110b = 11110110b
-11110100b | 00110111b = 11110111b
-11110100b | 00111000b = 11111100b
-11110100b | 00111001b = 11111101b
-11110100b | 00111010b = 11111110b
-11110100b | 00111011b = 11111111b
-11110100b | 00111100b = 11111100b
-11110100b | 00111101b = 11111101b
-11110100b | 00111110b = 11111110b
-11110100b | 00111111b = 11111111b
-11110100b | 01000000b = 11110100b
-11110100b | 01000001b = 11110101b
-11110100b | 01000010b = 11110110b
-11110100b | 01000011b = 11110111b
-11110100b | 01000100b = 11110100b
-11110100b | 01000101b = 11110101b
-11110100b | 01000110b = 11110110b
-11110100b | 01000111b = 11110111b
-11110100b | 01001000b = 11111100b
-11110100b | 01001001b = 11111101b
-11110100b | 01001010b = 11111110b
-11110100b | 01001011b = 11111111b
-11110100b | 01001100b = 11111100b
-11110100b | 01001101b = 11111101b
-11110100b | 01001110b = 11111110b
-11110100b | 01001111b = 11111111b
-11110100b | 01010000b = 11110100b
-11110100b | 01010001b = 11110101b
-11110100b | 01010010b = 11110110b
-11110100b | 01010011b = 11110111b
-11110100b | 01010100b = 11110100b
-11110100b | 01010101b = 11110101b
-11110100b | 01010110b = 11110110b
-11110100b | 01010111b = 11110111b
-11110100b | 01011000b = 11111100b
-11110100b | 01011001b = 11111101b
-11110100b | 01011010b = 11111110b
-11110100b | 01011011b = 11111111b
-11110100b | 01011100b = 11111100b
-11110100b | 01011101b = 11111101b
-11110100b | 01011110b = 11111110b
-11110100b | 01011111b = 11111111b
-11110100b | 01100000b = 11110100b
-11110100b | 01100001b = 11110101b
-11110100b | 01100010b = 11110110b
-11110100b | 01100011b = 11110111b
-11110100b | 01100100b = 11110100b
-11110100b | 01100101b = 11110101b
-11110100b | 01100110b = 11110110b
-11110100b | 01100111b = 11110111b
-11110100b | 01101000b = 11111100b
-11110100b | 01101001b = 11111101b
-11110100b | 01101010b = 11111110b
-11110100b | 01101011b = 11111111b
-11110100b | 01101100b = 11111100b
-11110100b | 01101101b = 11111101b
-11110100b | 01101110b = 11111110b
-11110100b | 01101111b = 11111111b
-11110100b | 01110000b = 11110100b
-11110100b | 01110001b = 11110101b
-11110100b | 01110010b = 11110110b
-11110100b | 01110011b = 11110111b
-11110100b | 01110100b = 11110100b
-11110100b | 01110101b = 11110101b
-11110100b | 01110110b = 11110110b
-11110100b | 01110111b = 11110111b
-11110100b | 01111000b = 11111100b
-11110100b | 01111001b = 11111101b
-11110100b | 01111010b = 11111110b
-11110100b | 01111011b = 11111111b
-11110100b | 01111100b = 11111100b
-11110100b | 01111101b = 11111101b
-11110100b | 01111110b = 11111110b
-11110101b | 10000000b = 11110101b
-11110101b | 10000001b = 11110101b
-11110101b | 10000010b = 11110111b
-11110101b | 10000011b = 11110111b
-11110101b | 10000100b = 11110101b
-11110101b | 10000101b = 11110101b
-11110101b | 10000110b = 11110111b
-11110101b | 10000111b = 11110111b
-11110101b | 10001000b = 11111101b
-11110101b | 10001001b = 11111101b
-11110101b | 10001010b = 11111111b
-11110101b | 10001011b = 11111111b
-11110101b | 10001100b = 11111101b
-11110101b | 10001101b = 11111101b
-11110101b | 10001110b = 11111111b
-11110101b | 10001111b = 11111111b
-11110101b | 10010000b = 11110101b
-11110101b | 10010001b = 11110101b
-11110101b | 10010010b = 11110111b
-11110101b | 10010011b = 11110111b
-11110101b | 10010100b = 11110101b
-11110101b | 10010101b = 11110101b
-11110101b | 10010110b = 11110111b
-11110101b | 10010111b = 11110111b
-11110101b | 10011000b = 11111101b
-11110101b | 10011001b = 11111101b
-11110101b | 10011010b = 11111111b
-11110101b | 10011011b = 11111111b
-11110101b | 10011100b = 11111101b
-11110101b | 10011101b = 11111101b
-11110101b | 10011110b = 11111111b
-11110101b | 10011111b = 11111111b
-11110101b | 10100000b = 11110101b
-11110101b | 10100001b = 11110101b
-11110101b | 10100010b = 11110111b
-11110101b | 10100011b = 11110111b
-11110101b | 10100100b = 11110101b
-11110101b | 10100101b = 11110101b
-11110101b | 10100110b = 11110111b
-11110101b | 10100111b = 11110111b
-11110101b | 10101000b = 11111101b
-11110101b | 10101001b = 11111101b
-11110101b | 10101010b = 11111111b
-11110101b | 10101011b = 11111111b
-11110101b | 10101100b = 11111101b
-11110101b | 10101101b = 11111101b
-11110101b | 10101110b = 11111111b
-11110101b | 10101111b = 11111111b
-11110101b | 10110000b = 11110101b
-11110101b | 10110001b = 11110101b
-11110101b | 10110010b = 11110111b
-11110101b | 10110011b = 11110111b
-11110101b | 10110100b = 11110101b
-11110101b | 10110101b = 11110101b
-11110101b | 10110110b = 11110111b
-11110101b | 10110111b = 11110111b
-11110101b | 10111000b = 11111101b
-11110101b | 10111001b = 11111101b
-11110101b | 10111010b = 11111111b
-11110101b | 10111011b = 11111111b
-11110101b | 10111100b = 11111101b
-11110101b | 10111101b = 11111101b
-11110101b | 10111110b = 11111111b
-11110101b | 10111111b = 11111111b
-11110101b | 11000000b = 11110101b
-11110101b | 11000001b = 11110101b
-11110101b | 11000010b = 11110111b
-11110101b | 11000011b = 11110111b
-11110101b | 11000100b = 11110101b
-11110101b | 11000101b = 11110101b
-11110101b | 11000110b = 11110111b
-11110101b | 11000111b = 11110111b
-11110101b | 11001000b = 11111101b
-11110101b | 11001001b = 11111101b
-11110101b | 11001010b = 11111111b
-11110101b | 11001011b = 11111111b
-11110101b | 11001100b = 11111101b
-11110101b | 11001101b = 11111101b
-11110101b | 11001110b = 11111111b
-11110101b | 11001111b = 11111111b
-11110101b | 11010000b = 11110101b
-11110101b | 11010001b = 11110101b
-11110101b | 11010010b = 11110111b
-11110101b | 11010011b = 11110111b
-11110101b | 11010100b = 11110101b
-11110101b | 11010101b = 11110101b
-11110101b | 11010110b = 11110111b
-11110101b | 11010111b = 11110111b
-11110101b | 11011000b = 11111101b
-11110101b | 11011001b = 11111101b
-11110101b | 11011010b = 11111111b
-11110101b | 11011011b = 11111111b
-11110101b | 11011100b = 11111101b
-11110101b | 11011101b = 11111101b
-11110101b | 11011110b = 11111111b
-11110101b | 11011111b = 11111111b
-11110101b | 11100000b = 11110101b
-11110101b | 11100001b = 11110101b
-11110101b | 11100010b = 11110111b
-11110101b | 11100011b = 11110111b
-11110101b | 11100100b = 11110101b
-11110101b | 11100101b = 11110101b
-11110101b | 11100110b = 11110111b
-11110101b | 11100111b = 11110111b
-11110101b | 11101000b = 11111101b
-11110101b | 11101001b = 11111101b
-11110101b | 11101010b = 11111111b
-11110101b | 11101011b = 11111111b
-11110101b | 11101100b = 11111101b
-11110101b | 11101101b = 11111101b
-11110101b | 11101110b = 11111111b
-11110101b | 11101111b = 11111111b
-11110101b | 11110000b = 11110101b
-11110101b | 11110001b = 11110101b
-11110101b | 11110010b = 11110111b
-11110101b | 11110011b = 11110111b
-11110101b | 11110100b = 11110101b
-11110101b | 11110101b = 11110101b
-11110101b | 11110110b = 11110111b
-11110101b | 11110111b = 11110111b
-11110101b | 11111000b = 11111101b
-11110101b | 11111001b = 11111101b
-11110101b | 11111010b = 11111111b
-11110101b | 11111011b = 11111111b
-11110101b | 11111100b = 11111101b
-11110101b | 11111101b = 11111101b
-11110101b | 11111110b = 11111111b
-11110101b | 11111111b = 11111111b
-11110101b | 00000000b = 11110101b
-11110101b | 00000001b = 11110101b
-11110101b | 00000010b = 11110111b
-11110101b | 00000011b = 11110111b
-11110101b | 00000100b = 11110101b
-11110101b | 00000101b = 11110101b
-11110101b | 00000110b = 11110111b
-11110101b | 00000111b = 11110111b
-11110101b | 00001000b = 11111101b
-11110101b | 00001001b = 11111101b
-11110101b | 00001010b = 11111111b
-11110101b | 00001011b = 11111111b
-11110101b | 00001100b = 11111101b
-11110101b | 00001101b = 11111101b
-11110101b | 00001110b = 11111111b
-11110101b | 00001111b = 11111111b
-11110101b | 00010000b = 11110101b
-11110101b | 00010001b = 11110101b
-11110101b | 00010010b = 11110111b
-11110101b | 00010011b = 11110111b
-11110101b | 00010100b = 11110101b
-11110101b | 00010101b = 11110101b
-11110101b | 00010110b = 11110111b
-11110101b | 00010111b = 11110111b
-11110101b | 00011000b = 11111101b
-11110101b | 00011001b = 11111101b
-11110101b | 00011010b = 11111111b
-11110101b | 00011011b = 11111111b
-11110101b | 00011100b = 11111101b
-11110101b | 00011101b = 11111101b
-11110101b | 00011110b = 11111111b
-11110101b | 00011111b = 11111111b
-11110101b | 00100000b = 11110101b
-11110101b | 00100001b = 11110101b
-11110101b | 00100010b = 11110111b
-11110101b | 00100011b = 11110111b
-11110101b | 00100100b = 11110101b
-11110101b | 00100101b = 11110101b
-11110101b | 00100110b = 11110111b
-11110101b | 00100111b = 11110111b
-11110101b | 00101000b = 11111101b
-11110101b | 00101001b = 11111101b
-11110101b | 00101010b = 11111111b
-11110101b | 00101011b = 11111111b
-11110101b | 00101100b = 11111101b
-11110101b | 00101101b = 11111101b
-11110101b | 00101110b = 11111111b
-11110101b | 00101111b = 11111111b
-11110101b | 00110000b = 11110101b
-11110101b | 00110001b = 11110101b
-11110101b | 00110010b = 11110111b
-11110101b | 00110011b = 11110111b
-11110101b | 00110100b = 11110101b
-11110101b | 00110101b = 11110101b
-11110101b | 00110110b = 11110111b
-11110101b | 00110111b = 11110111b
-11110101b | 00111000b = 11111101b
-11110101b | 00111001b = 11111101b
-11110101b | 00111010b = 11111111b
-11110101b | 00111011b = 11111111b
-11110101b | 00111100b = 11111101b
-11110101b | 00111101b = 11111101b
-11110101b | 00111110b = 11111111b
-11110101b | 00111111b = 11111111b
-11110101b | 01000000b = 11110101b
-11110101b | 01000001b = 11110101b
-11110101b | 01000010b = 11110111b
-11110101b | 01000011b = 11110111b
-11110101b | 01000100b = 11110101b
-11110101b | 01000101b = 11110101b
-11110101b | 01000110b = 11110111b
-11110101b | 01000111b = 11110111b
-11110101b | 01001000b = 11111101b
-11110101b | 01001001b = 11111101b
-11110101b | 01001010b = 11111111b
-11110101b | 01001011b = 11111111b
-11110101b | 01001100b = 11111101b
-11110101b | 01001101b = 11111101b
-11110101b | 01001110b = 11111111b
-11110101b | 01001111b = 11111111b
-11110101b | 01010000b = 11110101b
-11110101b | 01010001b = 11110101b
-11110101b | 01010010b = 11110111b
-11110101b | 01010011b = 11110111b
-11110101b | 01010100b = 11110101b
-11110101b | 01010101b = 11110101b
-11110101b | 01010110b = 11110111b
-11110101b | 01010111b = 11110111b
-11110101b | 01011000b = 11111101b
-11110101b | 01011001b = 11111101b
-11110101b | 01011010b = 11111111b
-11110101b | 01011011b = 11111111b
-11110101b | 01011100b = 11111101b
-11110101b | 01011101b = 11111101b
-11110101b | 01011110b = 11111111b
-11110101b | 01011111b = 11111111b
-11110101b | 01100000b = 11110101b
-11110101b | 01100001b = 11110101b
-11110101b | 01100010b = 11110111b
-11110101b | 01100011b = 11110111b
-11110101b | 01100100b = 11110101b
-11110101b | 01100101b = 11110101b
-11110101b | 01100110b = 11110111b
-11110101b | 01100111b = 11110111b
-11110101b | 01101000b = 11111101b
-11110101b | 01101001b = 11111101b
-11110101b | 01101010b = 11111111b
-11110101b | 01101011b = 11111111b
-11110101b | 01101100b = 11111101b
-11110101b | 01101101b = 11111101b
-11110101b | 01101110b = 11111111b
-11110101b | 01101111b = 11111111b
-11110101b | 01110000b = 11110101b
-11110101b | 01110001b = 11110101b
-11110101b | 01110010b = 11110111b
-11110101b | 01110011b = 11110111b
-11110101b | 01110100b = 11110101b
-11110101b | 01110101b = 11110101b
-11110101b | 01110110b = 11110111b
-11110101b | 01110111b = 11110111b
-11110101b | 01111000b = 11111101b
-11110101b | 01111001b = 11111101b
-11110101b | 01111010b = 11111111b
-11110101b | 01111011b = 11111111b
-11110101b | 01111100b = 11111101b
-11110101b | 01111101b = 11111101b
-11110101b | 01111110b = 11111111b
-11110110b | 10000000b = 11110110b
-11110110b | 10000001b = 11110111b
-11110110b | 10000010b = 11110110b
-11110110b | 10000011b = 11110111b
-11110110b | 10000100b = 11110110b
-11110110b | 10000101b = 11110111b
-11110110b | 10000110b = 11110110b
-11110110b | 10000111b = 11110111b
-11110110b | 10001000b = 11111110b
-11110110b | 10001001b = 11111111b
-11110110b | 10001010b = 11111110b
-11110110b | 10001011b = 11111111b
-11110110b | 10001100b = 11111110b
-11110110b | 10001101b = 11111111b
-11110110b | 10001110b = 11111110b
-11110110b | 10001111b = 11111111b
-11110110b | 10010000b = 11110110b
-11110110b | 10010001b = 11110111b
-11110110b | 10010010b = 11110110b
-11110110b | 10010011b = 11110111b
-11110110b | 10010100b = 11110110b
-11110110b | 10010101b = 11110111b
-11110110b | 10010110b = 11110110b
-11110110b | 10010111b = 11110111b
-11110110b | 10011000b = 11111110b
-11110110b | 10011001b = 11111111b
-11110110b | 10011010b = 11111110b
-11110110b | 10011011b = 11111111b
-11110110b | 10011100b = 11111110b
-11110110b | 10011101b = 11111111b
-11110110b | 10011110b = 11111110b
-11110110b | 10011111b = 11111111b
-11110110b | 10100000b = 11110110b
-11110110b | 10100001b = 11110111b
-11110110b | 10100010b = 11110110b
-11110110b | 10100011b = 11110111b
-11110110b | 10100100b = 11110110b
-11110110b | 10100101b = 11110111b
-11110110b | 10100110b = 11110110b
-11110110b | 10100111b = 11110111b
-11110110b | 10101000b = 11111110b
-11110110b | 10101001b = 11111111b
-11110110b | 10101010b = 11111110b
-11110110b | 10101011b = 11111111b
-11110110b | 10101100b = 11111110b
-11110110b | 10101101b = 11111111b
-11110110b | 10101110b = 11111110b
-11110110b | 10101111b = 11111111b
-11110110b | 10110000b = 11110110b
-11110110b | 10110001b = 11110111b
-11110110b | 10110010b = 11110110b
-11110110b | 10110011b = 11110111b
-11110110b | 10110100b = 11110110b
-11110110b | 10110101b = 11110111b
-11110110b | 10110110b = 11110110b
-11110110b | 10110111b = 11110111b
-11110110b | 10111000b = 11111110b
-11110110b | 10111001b = 11111111b
-11110110b | 10111010b = 11111110b
-11110110b | 10111011b = 11111111b
-11110110b | 10111100b = 11111110b
-11110110b | 10111101b = 11111111b
-11110110b | 10111110b = 11111110b
-11110110b | 10111111b = 11111111b
-11110110b | 11000000b = 11110110b
-11110110b | 11000001b = 11110111b
-11110110b | 11000010b = 11110110b
-11110110b | 11000011b = 11110111b
-11110110b | 11000100b = 11110110b
-11110110b | 11000101b = 11110111b
-11110110b | 11000110b = 11110110b
-11110110b | 11000111b = 11110111b
-11110110b | 11001000b = 11111110b
-11110110b | 11001001b = 11111111b
-11110110b | 11001010b = 11111110b
-11110110b | 11001011b = 11111111b
-11110110b | 11001100b = 11111110b
-11110110b | 11001101b = 11111111b
-11110110b | 11001110b = 11111110b
-11110110b | 11001111b = 11111111b
-11110110b | 11010000b = 11110110b
-11110110b | 11010001b = 11110111b
-11110110b | 11010010b = 11110110b
-11110110b | 11010011b = 11110111b
-11110110b | 11010100b = 11110110b
-11110110b | 11010101b = 11110111b
-11110110b | 11010110b = 11110110b
-11110110b | 11010111b = 11110111b
-11110110b | 11011000b = 11111110b
-11110110b | 11011001b = 11111111b
-11110110b | 11011010b = 11111110b
-11110110b | 11011011b = 11111111b
-11110110b | 11011100b = 11111110b
-11110110b | 11011101b = 11111111b
-11110110b | 11011110b = 11111110b
-11110110b | 11011111b = 11111111b
-11110110b | 11100000b = 11110110b
-11110110b | 11100001b = 11110111b
-11110110b | 11100010b = 11110110b
-11110110b | 11100011b = 11110111b
-11110110b | 11100100b = 11110110b
-11110110b | 11100101b = 11110111b
-11110110b | 11100110b = 11110110b
-11110110b | 11100111b = 11110111b
-11110110b | 11101000b = 11111110b
-11110110b | 11101001b = 11111111b
-11110110b | 11101010b = 11111110b
-11110110b | 11101011b = 11111111b
-11110110b | 11101100b = 11111110b
-11110110b | 11101101b = 11111111b
-11110110b | 11101110b = 11111110b
-11110110b | 11101111b = 11111111b
-11110110b | 11110000b = 11110110b
-11110110b | 11110001b = 11110111b
-11110110b | 11110010b = 11110110b
-11110110b | 11110011b = 11110111b
-11110110b | 11110100b = 11110110b
-11110110b | 11110101b = 11110111b
-11110110b | 11110110b = 11110110b
-11110110b | 11110111b = 11110111b
-11110110b | 11111000b = 11111110b
-11110110b | 11111001b = 11111111b
-11110110b | 11111010b = 11111110b
-11110110b | 11111011b = 11111111b
-11110110b | 11111100b = 11111110b
-11110110b | 11111101b = 11111111b
-11110110b | 11111110b = 11111110b
-11110110b | 11111111b = 11111111b
-11110110b | 00000000b = 11110110b
-11110110b | 00000001b = 11110111b
-11110110b | 00000010b = 11110110b
-11110110b | 00000011b = 11110111b
-11110110b | 00000100b = 11110110b
-11110110b | 00000101b = 11110111b
-11110110b | 00000110b = 11110110b
-11110110b | 00000111b = 11110111b
-11110110b | 00001000b = 11111110b
-11110110b | 00001001b = 11111111b
-11110110b | 00001010b = 11111110b
-11110110b | 00001011b = 11111111b
-11110110b | 00001100b = 11111110b
-11110110b | 00001101b = 11111111b
-11110110b | 00001110b = 11111110b
-11110110b | 00001111b = 11111111b
-11110110b | 00010000b = 11110110b
-11110110b | 00010001b = 11110111b
-11110110b | 00010010b = 11110110b
-11110110b | 00010011b = 11110111b
-11110110b | 00010100b = 11110110b
-11110110b | 00010101b = 11110111b
-11110110b | 00010110b = 11110110b
-11110110b | 00010111b = 11110111b
-11110110b | 00011000b = 11111110b
-11110110b | 00011001b = 11111111b
-11110110b | 00011010b = 11111110b
-11110110b | 00011011b = 11111111b
-11110110b | 00011100b = 11111110b
-11110110b | 00011101b = 11111111b
-11110110b | 00011110b = 11111110b
-11110110b | 00011111b = 11111111b
-11110110b | 00100000b = 11110110b
-11110110b | 00100001b = 11110111b
-11110110b | 00100010b = 11110110b
-11110110b | 00100011b = 11110111b
-11110110b | 00100100b = 11110110b
-11110110b | 00100101b = 11110111b
-11110110b | 00100110b = 11110110b
-11110110b | 00100111b = 11110111b
-11110110b | 00101000b = 11111110b
-11110110b | 00101001b = 11111111b
-11110110b | 00101010b = 11111110b
-11110110b | 00101011b = 11111111b
-11110110b | 00101100b = 11111110b
-11110110b | 00101101b = 11111111b
-11110110b | 00101110b = 11111110b
-11110110b | 00101111b = 11111111b
-11110110b | 00110000b = 11110110b
-11110110b | 00110001b = 11110111b
-11110110b | 00110010b = 11110110b
-11110110b | 00110011b = 11110111b
-11110110b | 00110100b = 11110110b
-11110110b | 00110101b = 11110111b
-11110110b | 00110110b = 11110110b
-11110110b | 00110111b = 11110111b
-11110110b | 00111000b = 11111110b
-11110110b | 00111001b = 11111111b
-11110110b | 00111010b = 11111110b
-11110110b | 00111011b = 11111111b
-11110110b | 00111100b = 11111110b
-11110110b | 00111101b = 11111111b
-11110110b | 00111110b = 11111110b
-11110110b | 00111111b = 11111111b
-11110110b | 01000000b = 11110110b
-11110110b | 01000001b = 11110111b
-11110110b | 01000010b = 11110110b
-11110110b | 01000011b = 11110111b
-11110110b | 01000100b = 11110110b
-11110110b | 01000101b = 11110111b
-11110110b | 01000110b = 11110110b
-11110110b | 01000111b = 11110111b
-11110110b | 01001000b = 11111110b
-11110110b | 01001001b = 11111111b
-11110110b | 01001010b = 11111110b
-11110110b | 01001011b = 11111111b
-11110110b | 01001100b = 11111110b
-11110110b | 01001101b = 11111111b
-11110110b | 01001110b = 11111110b
-11110110b | 01001111b = 11111111b
-11110110b | 01010000b = 11110110b
-11110110b | 01010001b = 11110111b
-11110110b | 01010010b = 11110110b
-11110110b | 01010011b = 11110111b
-11110110b | 01010100b = 11110110b
-11110110b | 01010101b = 11110111b
-11110110b | 01010110b = 11110110b
-11110110b | 01010111b = 11110111b
-11110110b | 01011000b = 11111110b
-11110110b | 01011001b = 11111111b
-11110110b | 01011010b = 11111110b
-11110110b | 01011011b = 11111111b
-11110110b | 01011100b = 11111110b
-11110110b | 01011101b = 11111111b
-11110110b | 01011110b = 11111110b
-11110110b | 01011111b = 11111111b
-11110110b | 01100000b = 11110110b
-11110110b | 01100001b = 11110111b
-11110110b | 01100010b = 11110110b
-11110110b | 01100011b = 11110111b
-11110110b | 01100100b = 11110110b
-11110110b | 01100101b = 11110111b
-11110110b | 01100110b = 11110110b
-11110110b | 01100111b = 11110111b
-11110110b | 01101000b = 11111110b
-11110110b | 01101001b = 11111111b
-11110110b | 01101010b = 11111110b
-11110110b | 01101011b = 11111111b
-11110110b | 01101100b = 11111110b
-11110110b | 01101101b = 11111111b
-11110110b | 01101110b = 11111110b
-11110110b | 01101111b = 11111111b
-11110110b | 01110000b = 11110110b
-11110110b | 01110001b = 11110111b
-11110110b | 01110010b = 11110110b
-11110110b | 01110011b = 11110111b
-11110110b | 01110100b = 11110110b
-11110110b | 01110101b = 11110111b
-11110110b | 01110110b = 11110110b
-11110110b | 01110111b = 11110111b
-11110110b | 01111000b = 11111110b
-11110110b | 01111001b = 11111111b
-11110110b | 01111010b = 11111110b
-11110110b | 01111011b = 11111111b
-11110110b | 01111100b = 11111110b
-11110110b | 01111101b = 11111111b
-11110110b | 01111110b = 11111110b
-11110111b | 10000000b = 11110111b
-11110111b | 10000001b = 11110111b
-11110111b | 10000010b = 11110111b
-11110111b | 10000011b = 11110111b
-11110111b | 10000100b = 11110111b
-11110111b | 10000101b = 11110111b
-11110111b | 10000110b = 11110111b
-11110111b | 10000111b = 11110111b
-11110111b | 10001000b = 11111111b
-11110111b | 10001001b = 11111111b
-11110111b | 10001010b = 11111111b
-11110111b | 10001011b = 11111111b
-11110111b | 10001100b = 11111111b
-11110111b | 10001101b = 11111111b
-11110111b | 10001110b = 11111111b
-11110111b | 10001111b = 11111111b
-11110111b | 10010000b = 11110111b
-11110111b | 10010001b = 11110111b
-11110111b | 10010010b = 11110111b
-11110111b | 10010011b = 11110111b
-11110111b | 10010100b = 11110111b
-11110111b | 10010101b = 11110111b
-11110111b | 10010110b = 11110111b
-11110111b | 10010111b = 11110111b
-11110111b | 10011000b = 11111111b
-11110111b | 10011001b = 11111111b
-11110111b | 10011010b = 11111111b
-11110111b | 10011011b = 11111111b
-11110111b | 10011100b = 11111111b
-11110111b | 10011101b = 11111111b
-11110111b | 10011110b = 11111111b
-11110111b | 10011111b = 11111111b
-11110111b | 10100000b = 11110111b
-11110111b | 10100001b = 11110111b
-11110111b | 10100010b = 11110111b
-11110111b | 10100011b = 11110111b
-11110111b | 10100100b = 11110111b
-11110111b | 10100101b = 11110111b
-11110111b | 10100110b = 11110111b
-11110111b | 10100111b = 11110111b
-11110111b | 10101000b = 11111111b
-11110111b | 10101001b = 11111111b
-11110111b | 10101010b = 11111111b
-11110111b | 10101011b = 11111111b
-11110111b | 10101100b = 11111111b
-11110111b | 10101101b = 11111111b
-11110111b | 10101110b = 11111111b
-11110111b | 10101111b = 11111111b
-11110111b | 10110000b = 11110111b
-11110111b | 10110001b = 11110111b
-11110111b | 10110010b = 11110111b
-11110111b | 10110011b = 11110111b
-11110111b | 10110100b = 11110111b
-11110111b | 10110101b = 11110111b
-11110111b | 10110110b = 11110111b
-11110111b | 10110111b = 11110111b
-11110111b | 10111000b = 11111111b
-11110111b | 10111001b = 11111111b
-11110111b | 10111010b = 11111111b
-11110111b | 10111011b = 11111111b
-11110111b | 10111100b = 11111111b
-11110111b | 10111101b = 11111111b
-11110111b | 10111110b = 11111111b
-11110111b | 10111111b = 11111111b
-11110111b | 11000000b = 11110111b
-11110111b | 11000001b = 11110111b
-11110111b | 11000010b = 11110111b
-11110111b | 11000011b = 11110111b
-11110111b | 11000100b = 11110111b
-11110111b | 11000101b = 11110111b
-11110111b | 11000110b = 11110111b
-11110111b | 11000111b = 11110111b
-11110111b | 11001000b = 11111111b
-11110111b | 11001001b = 11111111b
-11110111b | 11001010b = 11111111b
-11110111b | 11001011b = 11111111b
-11110111b | 11001100b = 11111111b
-11110111b | 11001101b = 11111111b
-11110111b | 11001110b = 11111111b
-11110111b | 11001111b = 11111111b
-11110111b | 11010000b = 11110111b
-11110111b | 11010001b = 11110111b
-11110111b | 11010010b = 11110111b
-11110111b | 11010011b = 11110111b
-11110111b | 11010100b = 11110111b
-11110111b | 11010101b = 11110111b
-11110111b | 11010110b = 11110111b
-11110111b | 11010111b = 11110111b
-11110111b | 11011000b = 11111111b
-11110111b | 11011001b = 11111111b
-11110111b | 11011010b = 11111111b
-11110111b | 11011011b = 11111111b
-11110111b | 11011100b = 11111111b
-11110111b | 11011101b = 11111111b
-11110111b | 11011110b = 11111111b
-11110111b | 11011111b = 11111111b
-11110111b | 11100000b = 11110111b
-11110111b | 11100001b = 11110111b
-11110111b | 11100010b = 11110111b
-11110111b | 11100011b = 11110111b
-11110111b | 11100100b = 11110111b
-11110111b | 11100101b = 11110111b
-11110111b | 11100110b = 11110111b
-11110111b | 11100111b = 11110111b
-11110111b | 11101000b = 11111111b
-11110111b | 11101001b = 11111111b
-11110111b | 11101010b = 11111111b
-11110111b | 11101011b = 11111111b
-11110111b | 11101100b = 11111111b
-11110111b | 11101101b = 11111111b
-11110111b | 11101110b = 11111111b
-11110111b | 11101111b = 11111111b
-11110111b | 11110000b = 11110111b
-11110111b | 11110001b = 11110111b
-11110111b | 11110010b = 11110111b
-11110111b | 11110011b = 11110111b
-11110111b | 11110100b = 11110111b
-11110111b | 11110101b = 11110111b
-11110111b | 11110110b = 11110111b
-11110111b | 11110111b = 11110111b
-11110111b | 11111000b = 11111111b
-11110111b | 11111001b = 11111111b
-11110111b | 11111010b = 11111111b
-11110111b | 11111011b = 11111111b
-11110111b | 11111100b = 11111111b
-11110111b | 11111101b = 11111111b
-11110111b | 11111110b = 11111111b
-11110111b | 11111111b = 11111111b
-11110111b | 00000000b = 11110111b
-11110111b | 00000001b = 11110111b
-11110111b | 00000010b = 11110111b
-11110111b | 00000011b = 11110111b
-11110111b | 00000100b = 11110111b
-11110111b | 00000101b = 11110111b
-11110111b | 00000110b = 11110111b
-11110111b | 00000111b = 11110111b
-11110111b | 00001000b = 11111111b
-11110111b | 00001001b = 11111111b
-11110111b | 00001010b = 11111111b
-11110111b | 00001011b = 11111111b
-11110111b | 00001100b = 11111111b
-11110111b | 00001101b = 11111111b
-11110111b | 00001110b = 11111111b
-11110111b | 00001111b = 11111111b
-11110111b | 00010000b = 11110111b
-11110111b | 00010001b = 11110111b
-11110111b | 00010010b = 11110111b
-11110111b | 00010011b = 11110111b
-11110111b | 00010100b = 11110111b
-11110111b | 00010101b = 11110111b
-11110111b | 00010110b = 11110111b
-11110111b | 00010111b = 11110111b
-11110111b | 00011000b = 11111111b
-11110111b | 00011001b = 11111111b
-11110111b | 00011010b = 11111111b
-11110111b | 00011011b = 11111111b
-11110111b | 00011100b = 11111111b
-11110111b | 00011101b = 11111111b
-11110111b | 00011110b = 11111111b
-11110111b | 00011111b = 11111111b
-11110111b | 00100000b = 11110111b
-11110111b | 00100001b = 11110111b
-11110111b | 00100010b = 11110111b
-11110111b | 00100011b = 11110111b
-11110111b | 00100100b = 11110111b
-11110111b | 00100101b = 11110111b
-11110111b | 00100110b = 11110111b
-11110111b | 00100111b = 11110111b
-11110111b | 00101000b = 11111111b
-11110111b | 00101001b = 11111111b
-11110111b | 00101010b = 11111111b
-11110111b | 00101011b = 11111111b
-11110111b | 00101100b = 11111111b
-11110111b | 00101101b = 11111111b
-11110111b | 00101110b = 11111111b
-11110111b | 00101111b = 11111111b
-11110111b | 00110000b = 11110111b
-11110111b | 00110001b = 11110111b
-11110111b | 00110010b = 11110111b
-11110111b | 00110011b = 11110111b
-11110111b | 00110100b = 11110111b
-11110111b | 00110101b = 11110111b
-11110111b | 00110110b = 11110111b
-11110111b | 00110111b = 11110111b
-11110111b | 00111000b = 11111111b
-11110111b | 00111001b = 11111111b
-11110111b | 00111010b = 11111111b
-11110111b | 00111011b = 11111111b
-11110111b | 00111100b = 11111111b
-11110111b | 00111101b = 11111111b
-11110111b | 00111110b = 11111111b
-11110111b | 00111111b = 11111111b
-11110111b | 01000000b = 11110111b
-11110111b | 01000001b = 11110111b
-11110111b | 01000010b = 11110111b
-11110111b | 01000011b = 11110111b
-11110111b | 01000100b = 11110111b
-11110111b | 01000101b = 11110111b
-11110111b | 01000110b = 11110111b
-11110111b | 01000111b = 11110111b
-11110111b | 01001000b = 11111111b
-11110111b | 01001001b = 11111111b
-11110111b | 01001010b = 11111111b
-11110111b | 01001011b = 11111111b
-11110111b | 01001100b = 11111111b
-11110111b | 01001101b = 11111111b
-11110111b | 01001110b = 11111111b
-11110111b | 01001111b = 11111111b
-11110111b | 01010000b = 11110111b
-11110111b | 01010001b = 11110111b
-11110111b | 01010010b = 11110111b
-11110111b | 01010011b = 11110111b
-11110111b | 01010100b = 11110111b
-11110111b | 01010101b = 11110111b
-11110111b | 01010110b = 11110111b
-11110111b | 01010111b = 11110111b
-11110111b | 01011000b = 11111111b
-11110111b | 01011001b = 11111111b
-11110111b | 01011010b = 11111111b
-11110111b | 01011011b = 11111111b
-11110111b | 01011100b = 11111111b
-11110111b | 01011101b = 11111111b
-11110111b | 01011110b = 11111111b
-11110111b | 01011111b = 11111111b
-11110111b | 01100000b = 11110111b
-11110111b | 01100001b = 11110111b
-11110111b | 01100010b = 11110111b
-11110111b | 01100011b = 11110111b
-11110111b | 01100100b = 11110111b
-11110111b | 01100101b = 11110111b
-11110111b | 01100110b = 11110111b
-11110111b | 01100111b = 11110111b
-11110111b | 01101000b = 11111111b
-11110111b | 01101001b = 11111111b
-11110111b | 01101010b = 11111111b
-11110111b | 01101011b = 11111111b
-11110111b | 01101100b = 11111111b
-11110111b | 01101101b = 11111111b
-11110111b | 01101110b = 11111111b
-11110111b | 01101111b = 11111111b
-11110111b | 01110000b = 11110111b
-11110111b | 01110001b = 11110111b
-11110111b | 01110010b = 11110111b
-11110111b | 01110011b = 11110111b
-11110111b | 01110100b = 11110111b
-11110111b | 01110101b = 11110111b
-11110111b | 01110110b = 11110111b
-11110111b | 01110111b = 11110111b
-11110111b | 01111000b = 11111111b
-11110111b | 01111001b = 11111111b
-11110111b | 01111010b = 11111111b
-11110111b | 01111011b = 11111111b
-11110111b | 01111100b = 11111111b
-11110111b | 01111101b = 11111111b
-11110111b | 01111110b = 11111111b
-11111000b | 10000000b = 11111000b
-11111000b | 10000001b = 11111001b
-11111000b | 10000010b = 11111010b
-11111000b | 10000011b = 11111011b
-11111000b | 10000100b = 11111100b
-11111000b | 10000101b = 11111101b
-11111000b | 10000110b = 11111110b
-11111000b | 10000111b = 11111111b
-11111000b | 10001000b = 11111000b
-11111000b | 10001001b = 11111001b
-11111000b | 10001010b = 11111010b
-11111000b | 10001011b = 11111011b
-11111000b | 10001100b = 11111100b
-11111000b | 10001101b = 11111101b
-11111000b | 10001110b = 11111110b
-11111000b | 10001111b = 11111111b
-11111000b | 10010000b = 11111000b
-11111000b | 10010001b = 11111001b
-11111000b | 10010010b = 11111010b
-11111000b | 10010011b = 11111011b
-11111000b | 10010100b = 11111100b
-11111000b | 10010101b = 11111101b
-11111000b | 10010110b = 11111110b
-11111000b | 10010111b = 11111111b
-11111000b | 10011000b = 11111000b
-11111000b | 10011001b = 11111001b
-11111000b | 10011010b = 11111010b
-11111000b | 10011011b = 11111011b
-11111000b | 10011100b = 11111100b
-11111000b | 10011101b = 11111101b
-11111000b | 10011110b = 11111110b
-11111000b | 10011111b = 11111111b
-11111000b | 10100000b = 11111000b
-11111000b | 10100001b = 11111001b
-11111000b | 10100010b = 11111010b
-11111000b | 10100011b = 11111011b
-11111000b | 10100100b = 11111100b
-11111000b | 10100101b = 11111101b
-11111000b | 10100110b = 11111110b
-11111000b | 10100111b = 11111111b
-11111000b | 10101000b = 11111000b
-11111000b | 10101001b = 11111001b
-11111000b | 10101010b = 11111010b
-11111000b | 10101011b = 11111011b
-11111000b | 10101100b = 11111100b
-11111000b | 10101101b = 11111101b
-11111000b | 10101110b = 11111110b
-11111000b | 10101111b = 11111111b
-11111000b | 10110000b = 11111000b
-11111000b | 10110001b = 11111001b
-11111000b | 10110010b = 11111010b
-11111000b | 10110011b = 11111011b
-11111000b | 10110100b = 11111100b
-11111000b | 10110101b = 11111101b
-11111000b | 10110110b = 11111110b
-11111000b | 10110111b = 11111111b
-11111000b | 10111000b = 11111000b
-11111000b | 10111001b = 11111001b
-11111000b | 10111010b = 11111010b
-11111000b | 10111011b = 11111011b
-11111000b | 10111100b = 11111100b
-11111000b | 10111101b = 11111101b
-11111000b | 10111110b = 11111110b
-11111000b | 10111111b = 11111111b
-11111000b | 11000000b = 11111000b
-11111000b | 11000001b = 11111001b
-11111000b | 11000010b = 11111010b
-11111000b | 11000011b = 11111011b
-11111000b | 11000100b = 11111100b
-11111000b | 11000101b = 11111101b
-11111000b | 11000110b = 11111110b
-11111000b | 11000111b = 11111111b
-11111000b | 11001000b = 11111000b
-11111000b | 11001001b = 11111001b
-11111000b | 11001010b = 11111010b
-11111000b | 11001011b = 11111011b
-11111000b | 11001100b = 11111100b
-11111000b | 11001101b = 11111101b
-11111000b | 11001110b = 11111110b
-11111000b | 11001111b = 11111111b
-11111000b | 11010000b = 11111000b
-11111000b | 11010001b = 11111001b
-11111000b | 11010010b = 11111010b
-11111000b | 11010011b = 11111011b
-11111000b | 11010100b = 11111100b
-11111000b | 11010101b = 11111101b
-11111000b | 11010110b = 11111110b
-11111000b | 11010111b = 11111111b
-11111000b | 11011000b = 11111000b
-11111000b | 11011001b = 11111001b
-11111000b | 11011010b = 11111010b
-11111000b | 11011011b = 11111011b
-11111000b | 11011100b = 11111100b
-11111000b | 11011101b = 11111101b
-11111000b | 11011110b = 11111110b
-11111000b | 11011111b = 11111111b
-11111000b | 11100000b = 11111000b
-11111000b | 11100001b = 11111001b
-11111000b | 11100010b = 11111010b
-11111000b | 11100011b = 11111011b
-11111000b | 11100100b = 11111100b
-11111000b | 11100101b = 11111101b
-11111000b | 11100110b = 11111110b
-11111000b | 11100111b = 11111111b
-11111000b | 11101000b = 11111000b
-11111000b | 11101001b = 11111001b
-11111000b | 11101010b = 11111010b
-11111000b | 11101011b = 11111011b
-11111000b | 11101100b = 11111100b
-11111000b | 11101101b = 11111101b
-11111000b | 11101110b = 11111110b
-11111000b | 11101111b = 11111111b
-11111000b | 11110000b = 11111000b
-11111000b | 11110001b = 11111001b
-11111000b | 11110010b = 11111010b
-11111000b | 11110011b = 11111011b
-11111000b | 11110100b = 11111100b
-11111000b | 11110101b = 11111101b
-11111000b | 11110110b = 11111110b
-11111000b | 11110111b = 11111111b
-11111000b | 11111000b = 11111000b
-11111000b | 11111001b = 11111001b
-11111000b | 11111010b = 11111010b
-11111000b | 11111011b = 11111011b
-11111000b | 11111100b = 11111100b
-11111000b | 11111101b = 11111101b
-11111000b | 11111110b = 11111110b
-11111000b | 11111111b = 11111111b
-11111000b | 00000000b = 11111000b
-11111000b | 00000001b = 11111001b
-11111000b | 00000010b = 11111010b
-11111000b | 00000011b = 11111011b
-11111000b | 00000100b = 11111100b
-11111000b | 00000101b = 11111101b
-11111000b | 00000110b = 11111110b
-11111000b | 00000111b = 11111111b
-11111000b | 00001000b = 11111000b
-11111000b | 00001001b = 11111001b
-11111000b | 00001010b = 11111010b
-11111000b | 00001011b = 11111011b
-11111000b | 00001100b = 11111100b
-11111000b | 00001101b = 11111101b
-11111000b | 00001110b = 11111110b
-11111000b | 00001111b = 11111111b
-11111000b | 00010000b = 11111000b
-11111000b | 00010001b = 11111001b
-11111000b | 00010010b = 11111010b
-11111000b | 00010011b = 11111011b
-11111000b | 00010100b = 11111100b
-11111000b | 00010101b = 11111101b
-11111000b | 00010110b = 11111110b
-11111000b | 00010111b = 11111111b
-11111000b | 00011000b = 11111000b
-11111000b | 00011001b = 11111001b
-11111000b | 00011010b = 11111010b
-11111000b | 00011011b = 11111011b
-11111000b | 00011100b = 11111100b
-11111000b | 00011101b = 11111101b
-11111000b | 00011110b = 11111110b
-11111000b | 00011111b = 11111111b
-11111000b | 00100000b = 11111000b
-11111000b | 00100001b = 11111001b
-11111000b | 00100010b = 11111010b
-11111000b | 00100011b = 11111011b
-11111000b | 00100100b = 11111100b
-11111000b | 00100101b = 11111101b
-11111000b | 00100110b = 11111110b
-11111000b | 00100111b = 11111111b
-11111000b | 00101000b = 11111000b
-11111000b | 00101001b = 11111001b
-11111000b | 00101010b = 11111010b
-11111000b | 00101011b = 11111011b
-11111000b | 00101100b = 11111100b
-11111000b | 00101101b = 11111101b
-11111000b | 00101110b = 11111110b
-11111000b | 00101111b = 11111111b
-11111000b | 00110000b = 11111000b
-11111000b | 00110001b = 11111001b
-11111000b | 00110010b = 11111010b
-11111000b | 00110011b = 11111011b
-11111000b | 00110100b = 11111100b
-11111000b | 00110101b = 11111101b
-11111000b | 00110110b = 11111110b
-11111000b | 00110111b = 11111111b
-11111000b | 00111000b = 11111000b
-11111000b | 00111001b = 11111001b
-11111000b | 00111010b = 11111010b
-11111000b | 00111011b = 11111011b
-11111000b | 00111100b = 11111100b
-11111000b | 00111101b = 11111101b
-11111000b | 00111110b = 11111110b
-11111000b | 00111111b = 11111111b
-11111000b | 01000000b = 11111000b
-11111000b | 01000001b = 11111001b
-11111000b | 01000010b = 11111010b
-11111000b | 01000011b = 11111011b
-11111000b | 01000100b = 11111100b
-11111000b | 01000101b = 11111101b
-11111000b | 01000110b = 11111110b
-11111000b | 01000111b = 11111111b
-11111000b | 01001000b = 11111000b
-11111000b | 01001001b = 11111001b
-11111000b | 01001010b = 11111010b
-11111000b | 01001011b = 11111011b
-11111000b | 01001100b = 11111100b
-11111000b | 01001101b = 11111101b
-11111000b | 01001110b = 11111110b
-11111000b | 01001111b = 11111111b
-11111000b | 01010000b = 11111000b
-11111000b | 01010001b = 11111001b
-11111000b | 01010010b = 11111010b
-11111000b | 01010011b = 11111011b
-11111000b | 01010100b = 11111100b
-11111000b | 01010101b = 11111101b
-11111000b | 01010110b = 11111110b
-11111000b | 01010111b = 11111111b
-11111000b | 01011000b = 11111000b
-11111000b | 01011001b = 11111001b
-11111000b | 01011010b = 11111010b
-11111000b | 01011011b = 11111011b
-11111000b | 01011100b = 11111100b
-11111000b | 01011101b = 11111101b
-11111000b | 01011110b = 11111110b
-11111000b | 01011111b = 11111111b
-11111000b | 01100000b = 11111000b
-11111000b | 01100001b = 11111001b
-11111000b | 01100010b = 11111010b
-11111000b | 01100011b = 11111011b
-11111000b | 01100100b = 11111100b
-11111000b | 01100101b = 11111101b
-11111000b | 01100110b = 11111110b
-11111000b | 01100111b = 11111111b
-11111000b | 01101000b = 11111000b
-11111000b | 01101001b = 11111001b
-11111000b | 01101010b = 11111010b
-11111000b | 01101011b = 11111011b
-11111000b | 01101100b = 11111100b
-11111000b | 01101101b = 11111101b
-11111000b | 01101110b = 11111110b
-11111000b | 01101111b = 11111111b
-11111000b | 01110000b = 11111000b
-11111000b | 01110001b = 11111001b
-11111000b | 01110010b = 11111010b
-11111000b | 01110011b = 11111011b
-11111000b | 01110100b = 11111100b
-11111000b | 01110101b = 11111101b
-11111000b | 01110110b = 11111110b
-11111000b | 01110111b = 11111111b
-11111000b | 01111000b = 11111000b
-11111000b | 01111001b = 11111001b
-11111000b | 01111010b = 11111010b
-11111000b | 01111011b = 11111011b
-11111000b | 01111100b = 11111100b
-11111000b | 01111101b = 11111101b
-11111000b | 01111110b = 11111110b
-11111001b | 10000000b = 11111001b
-11111001b | 10000001b = 11111001b
-11111001b | 10000010b = 11111011b
-11111001b | 10000011b = 11111011b
-11111001b | 10000100b = 11111101b
-11111001b | 10000101b = 11111101b
-11111001b | 10000110b = 11111111b
-11111001b | 10000111b = 11111111b
-11111001b | 10001000b = 11111001b
-11111001b | 10001001b = 11111001b
-11111001b | 10001010b = 11111011b
-11111001b | 10001011b = 11111011b
-11111001b | 10001100b = 11111101b
-11111001b | 10001101b = 11111101b
-11111001b | 10001110b = 11111111b
-11111001b | 10001111b = 11111111b
-11111001b | 10010000b = 11111001b
-11111001b | 10010001b = 11111001b
-11111001b | 10010010b = 11111011b
-11111001b | 10010011b = 11111011b
-11111001b | 10010100b = 11111101b
-11111001b | 10010101b = 11111101b
-11111001b | 10010110b = 11111111b
-11111001b | 10010111b = 11111111b
-11111001b | 10011000b = 11111001b
-11111001b | 10011001b = 11111001b
-11111001b | 10011010b = 11111011b
-11111001b | 10011011b = 11111011b
-11111001b | 10011100b = 11111101b
-11111001b | 10011101b = 11111101b
-11111001b | 10011110b = 11111111b
-11111001b | 10011111b = 11111111b
-11111001b | 10100000b = 11111001b
-11111001b | 10100001b = 11111001b
-11111001b | 10100010b = 11111011b
-11111001b | 10100011b = 11111011b
-11111001b | 10100100b = 11111101b
-11111001b | 10100101b = 11111101b
-11111001b | 10100110b = 11111111b
-11111001b | 10100111b = 11111111b
-11111001b | 10101000b = 11111001b
-11111001b | 10101001b = 11111001b
-11111001b | 10101010b = 11111011b
-11111001b | 10101011b = 11111011b
-11111001b | 10101100b = 11111101b
-11111001b | 10101101b = 11111101b
-11111001b | 10101110b = 11111111b
-11111001b | 10101111b = 11111111b
-11111001b | 10110000b = 11111001b
-11111001b | 10110001b = 11111001b
-11111001b | 10110010b = 11111011b
-11111001b | 10110011b = 11111011b
-11111001b | 10110100b = 11111101b
-11111001b | 10110101b = 11111101b
-11111001b | 10110110b = 11111111b
-11111001b | 10110111b = 11111111b
-11111001b | 10111000b = 11111001b
-11111001b | 10111001b = 11111001b
-11111001b | 10111010b = 11111011b
-11111001b | 10111011b = 11111011b
-11111001b | 10111100b = 11111101b
-11111001b | 10111101b = 11111101b
-11111001b | 10111110b = 11111111b
-11111001b | 10111111b = 11111111b
-11111001b | 11000000b = 11111001b
-11111001b | 11000001b = 11111001b
-11111001b | 11000010b = 11111011b
-11111001b | 11000011b = 11111011b
-11111001b | 11000100b = 11111101b
-11111001b | 11000101b = 11111101b
-11111001b | 11000110b = 11111111b
-11111001b | 11000111b = 11111111b
-11111001b | 11001000b = 11111001b
-11111001b | 11001001b = 11111001b
-11111001b | 11001010b = 11111011b
-11111001b | 11001011b = 11111011b
-11111001b | 11001100b = 11111101b
-11111001b | 11001101b = 11111101b
-11111001b | 11001110b = 11111111b
-11111001b | 11001111b = 11111111b
-11111001b | 11010000b = 11111001b
-11111001b | 11010001b = 11111001b
-11111001b | 11010010b = 11111011b
-11111001b | 11010011b = 11111011b
-11111001b | 11010100b = 11111101b
-11111001b | 11010101b = 11111101b
-11111001b | 11010110b = 11111111b
-11111001b | 11010111b = 11111111b
-11111001b | 11011000b = 11111001b
-11111001b | 11011001b = 11111001b
-11111001b | 11011010b = 11111011b
-11111001b | 11011011b = 11111011b
-11111001b | 11011100b = 11111101b
-11111001b | 11011101b = 11111101b
-11111001b | 11011110b = 11111111b
-11111001b | 11011111b = 11111111b
-11111001b | 11100000b = 11111001b
-11111001b | 11100001b = 11111001b
-11111001b | 11100010b = 11111011b
-11111001b | 11100011b = 11111011b
-11111001b | 11100100b = 11111101b
-11111001b | 11100101b = 11111101b
-11111001b | 11100110b = 11111111b
-11111001b | 11100111b = 11111111b
-11111001b | 11101000b = 11111001b
-11111001b | 11101001b = 11111001b
-11111001b | 11101010b = 11111011b
-11111001b | 11101011b = 11111011b
-11111001b | 11101100b = 11111101b
-11111001b | 11101101b = 11111101b
-11111001b | 11101110b = 11111111b
-11111001b | 11101111b = 11111111b
-11111001b | 11110000b = 11111001b
-11111001b | 11110001b = 11111001b
-11111001b | 11110010b = 11111011b
-11111001b | 11110011b = 11111011b
-11111001b | 11110100b = 11111101b
-11111001b | 11110101b = 11111101b
-11111001b | 11110110b = 11111111b
-11111001b | 11110111b = 11111111b
-11111001b | 11111000b = 11111001b
-11111001b | 11111001b = 11111001b
-11111001b | 11111010b = 11111011b
-11111001b | 11111011b = 11111011b
-11111001b | 11111100b = 11111101b
-11111001b | 11111101b = 11111101b
-11111001b | 11111110b = 11111111b
-11111001b | 11111111b = 11111111b
-11111001b | 00000000b = 11111001b
-11111001b | 00000001b = 11111001b
-11111001b | 00000010b = 11111011b
-11111001b | 00000011b = 11111011b
-11111001b | 00000100b = 11111101b
-11111001b | 00000101b = 11111101b
-11111001b | 00000110b = 11111111b
-11111001b | 00000111b = 11111111b
-11111001b | 00001000b = 11111001b
-11111001b | 00001001b = 11111001b
-11111001b | 00001010b = 11111011b
-11111001b | 00001011b = 11111011b
-11111001b | 00001100b = 11111101b
-11111001b | 00001101b = 11111101b
-11111001b | 00001110b = 11111111b
-11111001b | 00001111b = 11111111b
-11111001b | 00010000b = 11111001b
-11111001b | 00010001b = 11111001b
-11111001b | 00010010b = 11111011b
-11111001b | 00010011b = 11111011b
-11111001b | 00010100b = 11111101b
-11111001b | 00010101b = 11111101b
-11111001b | 00010110b = 11111111b
-11111001b | 00010111b = 11111111b
-11111001b | 00011000b = 11111001b
-11111001b | 00011001b = 11111001b
-11111001b | 00011010b = 11111011b
-11111001b | 00011011b = 11111011b
-11111001b | 00011100b = 11111101b
-11111001b | 00011101b = 11111101b
-11111001b | 00011110b = 11111111b
-11111001b | 00011111b = 11111111b
-11111001b | 00100000b = 11111001b
-11111001b | 00100001b = 11111001b
-11111001b | 00100010b = 11111011b
-11111001b | 00100011b = 11111011b
-11111001b | 00100100b = 11111101b
-11111001b | 00100101b = 11111101b
-11111001b | 00100110b = 11111111b
-11111001b | 00100111b = 11111111b
-11111001b | 00101000b = 11111001b
-11111001b | 00101001b = 11111001b
-11111001b | 00101010b = 11111011b
-11111001b | 00101011b = 11111011b
-11111001b | 00101100b = 11111101b
-11111001b | 00101101b = 11111101b
-11111001b | 00101110b = 11111111b
-11111001b | 00101111b = 11111111b
-11111001b | 00110000b = 11111001b
-11111001b | 00110001b = 11111001b
-11111001b | 00110010b = 11111011b
-11111001b | 00110011b = 11111011b
-11111001b | 00110100b = 11111101b
-11111001b | 00110101b = 11111101b
-11111001b | 00110110b = 11111111b
-11111001b | 00110111b = 11111111b
-11111001b | 00111000b = 11111001b
-11111001b | 00111001b = 11111001b
-11111001b | 00111010b = 11111011b
-11111001b | 00111011b = 11111011b
-11111001b | 00111100b = 11111101b
-11111001b | 00111101b = 11111101b
-11111001b | 00111110b = 11111111b
-11111001b | 00111111b = 11111111b
-11111001b | 01000000b = 11111001b
-11111001b | 01000001b = 11111001b
-11111001b | 01000010b = 11111011b
-11111001b | 01000011b = 11111011b
-11111001b | 01000100b = 11111101b
-11111001b | 01000101b = 11111101b
-11111001b | 01000110b = 11111111b
-11111001b | 01000111b = 11111111b
-11111001b | 01001000b = 11111001b
-11111001b | 01001001b = 11111001b
-11111001b | 01001010b = 11111011b
-11111001b | 01001011b = 11111011b
-11111001b | 01001100b = 11111101b
-11111001b | 01001101b = 11111101b
-11111001b | 01001110b = 11111111b
-11111001b | 01001111b = 11111111b
-11111001b | 01010000b = 11111001b
-11111001b | 01010001b = 11111001b
-11111001b | 01010010b = 11111011b
-11111001b | 01010011b = 11111011b
-11111001b | 01010100b = 11111101b
-11111001b | 01010101b = 11111101b
-11111001b | 01010110b = 11111111b
-11111001b | 01010111b = 11111111b
-11111001b | 01011000b = 11111001b
-11111001b | 01011001b = 11111001b
-11111001b | 01011010b = 11111011b
-11111001b | 01011011b = 11111011b
-11111001b | 01011100b = 11111101b
-11111001b | 01011101b = 11111101b
-11111001b | 01011110b = 11111111b
-11111001b | 01011111b = 11111111b
-11111001b | 01100000b = 11111001b
-11111001b | 01100001b = 11111001b
-11111001b | 01100010b = 11111011b
-11111001b | 01100011b = 11111011b
-11111001b | 01100100b = 11111101b
-11111001b | 01100101b = 11111101b
-11111001b | 01100110b = 11111111b
-11111001b | 01100111b = 11111111b
-11111001b | 01101000b = 11111001b
-11111001b | 01101001b = 11111001b
-11111001b | 01101010b = 11111011b
-11111001b | 01101011b = 11111011b
-11111001b | 01101100b = 11111101b
-11111001b | 01101101b = 11111101b
-11111001b | 01101110b = 11111111b
-11111001b | 01101111b = 11111111b
-11111001b | 01110000b = 11111001b
-11111001b | 01110001b = 11111001b
-11111001b | 01110010b = 11111011b
-11111001b | 01110011b = 11111011b
-11111001b | 01110100b = 11111101b
-11111001b | 01110101b = 11111101b
-11111001b | 01110110b = 11111111b
-11111001b | 01110111b = 11111111b
-11111001b | 01111000b = 11111001b
-11111001b | 01111001b = 11111001b
-11111001b | 01111010b = 11111011b
-11111001b | 01111011b = 11111011b
-11111001b | 01111100b = 11111101b
-11111001b | 01111101b = 11111101b
-11111001b | 01111110b = 11111111b
-11111010b | 10000000b = 11111010b
-11111010b | 10000001b = 11111011b
-11111010b | 10000010b = 11111010b
-11111010b | 10000011b = 11111011b
-11111010b | 10000100b = 11111110b
-11111010b | 10000101b = 11111111b
-11111010b | 10000110b = 11111110b
-11111010b | 10000111b = 11111111b
-11111010b | 10001000b = 11111010b
-11111010b | 10001001b = 11111011b
-11111010b | 10001010b = 11111010b
-11111010b | 10001011b = 11111011b
-11111010b | 10001100b = 11111110b
-11111010b | 10001101b = 11111111b
-11111010b | 10001110b = 11111110b
-11111010b | 10001111b = 11111111b
-11111010b | 10010000b = 11111010b
-11111010b | 10010001b = 11111011b
-11111010b | 10010010b = 11111010b
-11111010b | 10010011b = 11111011b
-11111010b | 10010100b = 11111110b
-11111010b | 10010101b = 11111111b
-11111010b | 10010110b = 11111110b
-11111010b | 10010111b = 11111111b
-11111010b | 10011000b = 11111010b
-11111010b | 10011001b = 11111011b
-11111010b | 10011010b = 11111010b
-11111010b | 10011011b = 11111011b
-11111010b | 10011100b = 11111110b
-11111010b | 10011101b = 11111111b
-11111010b | 10011110b = 11111110b
-11111010b | 10011111b = 11111111b
-11111010b | 10100000b = 11111010b
-11111010b | 10100001b = 11111011b
-11111010b | 10100010b = 11111010b
-11111010b | 10100011b = 11111011b
-11111010b | 10100100b = 11111110b
-11111010b | 10100101b = 11111111b
-11111010b | 10100110b = 11111110b
-11111010b | 10100111b = 11111111b
-11111010b | 10101000b = 11111010b
-11111010b | 10101001b = 11111011b
-11111010b | 10101010b = 11111010b
-11111010b | 10101011b = 11111011b
-11111010b | 10101100b = 11111110b
-11111010b | 10101101b = 11111111b
-11111010b | 10101110b = 11111110b
-11111010b | 10101111b = 11111111b
-11111010b | 10110000b = 11111010b
-11111010b | 10110001b = 11111011b
-11111010b | 10110010b = 11111010b
-11111010b | 10110011b = 11111011b
-11111010b | 10110100b = 11111110b
-11111010b | 10110101b = 11111111b
-11111010b | 10110110b = 11111110b
-11111010b | 10110111b = 11111111b
-11111010b | 10111000b = 11111010b
-11111010b | 10111001b = 11111011b
-11111010b | 10111010b = 11111010b
-11111010b | 10111011b = 11111011b
-11111010b | 10111100b = 11111110b
-11111010b | 10111101b = 11111111b
-11111010b | 10111110b = 11111110b
-11111010b | 10111111b = 11111111b
-11111010b | 11000000b = 11111010b
-11111010b | 11000001b = 11111011b
-11111010b | 11000010b = 11111010b
-11111010b | 11000011b = 11111011b
-11111010b | 11000100b = 11111110b
-11111010b | 11000101b = 11111111b
-11111010b | 11000110b = 11111110b
-11111010b | 11000111b = 11111111b
-11111010b | 11001000b = 11111010b
-11111010b | 11001001b = 11111011b
-11111010b | 11001010b = 11111010b
-11111010b | 11001011b = 11111011b
-11111010b | 11001100b = 11111110b
-11111010b | 11001101b = 11111111b
-11111010b | 11001110b = 11111110b
-11111010b | 11001111b = 11111111b
-11111010b | 11010000b = 11111010b
-11111010b | 11010001b = 11111011b
-11111010b | 11010010b = 11111010b
-11111010b | 11010011b = 11111011b
-11111010b | 11010100b = 11111110b
-11111010b | 11010101b = 11111111b
-11111010b | 11010110b = 11111110b
-11111010b | 11010111b = 11111111b
-11111010b | 11011000b = 11111010b
-11111010b | 11011001b = 11111011b
-11111010b | 11011010b = 11111010b
-11111010b | 11011011b = 11111011b
-11111010b | 11011100b = 11111110b
-11111010b | 11011101b = 11111111b
-11111010b | 11011110b = 11111110b
-11111010b | 11011111b = 11111111b
-11111010b | 11100000b = 11111010b
-11111010b | 11100001b = 11111011b
-11111010b | 11100010b = 11111010b
-11111010b | 11100011b = 11111011b
-11111010b | 11100100b = 11111110b
-11111010b | 11100101b = 11111111b
-11111010b | 11100110b = 11111110b
-11111010b | 11100111b = 11111111b
-11111010b | 11101000b = 11111010b
-11111010b | 11101001b = 11111011b
-11111010b | 11101010b = 11111010b
-11111010b | 11101011b = 11111011b
-11111010b | 11101100b = 11111110b
-11111010b | 11101101b = 11111111b
-11111010b | 11101110b = 11111110b
-11111010b | 11101111b = 11111111b
-11111010b | 11110000b = 11111010b
-11111010b | 11110001b = 11111011b
-11111010b | 11110010b = 11111010b
-11111010b | 11110011b = 11111011b
-11111010b | 11110100b = 11111110b
-11111010b | 11110101b = 11111111b
-11111010b | 11110110b = 11111110b
-11111010b | 11110111b = 11111111b
-11111010b | 11111000b = 11111010b
-11111010b | 11111001b = 11111011b
-11111010b | 11111010b = 11111010b
-11111010b | 11111011b = 11111011b
-11111010b | 11111100b = 11111110b
-11111010b | 11111101b = 11111111b
-11111010b | 11111110b = 11111110b
-11111010b | 11111111b = 11111111b
-11111010b | 00000000b = 11111010b
-11111010b | 00000001b = 11111011b
-11111010b | 00000010b = 11111010b
-11111010b | 00000011b = 11111011b
-11111010b | 00000100b = 11111110b
-11111010b | 00000101b = 11111111b
-11111010b | 00000110b = 11111110b
-11111010b | 00000111b = 11111111b
-11111010b | 00001000b = 11111010b
-11111010b | 00001001b = 11111011b
-11111010b | 00001010b = 11111010b
-11111010b | 00001011b = 11111011b
-11111010b | 00001100b = 11111110b
-11111010b | 00001101b = 11111111b
-11111010b | 00001110b = 11111110b
-11111010b | 00001111b = 11111111b
-11111010b | 00010000b = 11111010b
-11111010b | 00010001b = 11111011b
-11111010b | 00010010b = 11111010b
-11111010b | 00010011b = 11111011b
-11111010b | 00010100b = 11111110b
-11111010b | 00010101b = 11111111b
-11111010b | 00010110b = 11111110b
-11111010b | 00010111b = 11111111b
-11111010b | 00011000b = 11111010b
-11111010b | 00011001b = 11111011b
-11111010b | 00011010b = 11111010b
-11111010b | 00011011b = 11111011b
-11111010b | 00011100b = 11111110b
-11111010b | 00011101b = 11111111b
-11111010b | 00011110b = 11111110b
-11111010b | 00011111b = 11111111b
-11111010b | 00100000b = 11111010b
-11111010b | 00100001b = 11111011b
-11111010b | 00100010b = 11111010b
-11111010b | 00100011b = 11111011b
-11111010b | 00100100b = 11111110b
-11111010b | 00100101b = 11111111b
-11111010b | 00100110b = 11111110b
-11111010b | 00100111b = 11111111b
-11111010b | 00101000b = 11111010b
-11111010b | 00101001b = 11111011b
-11111010b | 00101010b = 11111010b
-11111010b | 00101011b = 11111011b
-11111010b | 00101100b = 11111110b
-11111010b | 00101101b = 11111111b
-11111010b | 00101110b = 11111110b
-11111010b | 00101111b = 11111111b
-11111010b | 00110000b = 11111010b
-11111010b | 00110001b = 11111011b
-11111010b | 00110010b = 11111010b
-11111010b | 00110011b = 11111011b
-11111010b | 00110100b = 11111110b
-11111010b | 00110101b = 11111111b
-11111010b | 00110110b = 11111110b
-11111010b | 00110111b = 11111111b
-11111010b | 00111000b = 11111010b
-11111010b | 00111001b = 11111011b
-11111010b | 00111010b = 11111010b
-11111010b | 00111011b = 11111011b
-11111010b | 00111100b = 11111110b
-11111010b | 00111101b = 11111111b
-11111010b | 00111110b = 11111110b
-11111010b | 00111111b = 11111111b
-11111010b | 01000000b = 11111010b
-11111010b | 01000001b = 11111011b
-11111010b | 01000010b = 11111010b
-11111010b | 01000011b = 11111011b
-11111010b | 01000100b = 11111110b
-11111010b | 01000101b = 11111111b
-11111010b | 01000110b = 11111110b
-11111010b | 01000111b = 11111111b
-11111010b | 01001000b = 11111010b
-11111010b | 01001001b = 11111011b
-11111010b | 01001010b = 11111010b
-11111010b | 01001011b = 11111011b
-11111010b | 01001100b = 11111110b
-11111010b | 01001101b = 11111111b
-11111010b | 01001110b = 11111110b
-11111010b | 01001111b = 11111111b
-11111010b | 01010000b = 11111010b
-11111010b | 01010001b = 11111011b
-11111010b | 01010010b = 11111010b
-11111010b | 01010011b = 11111011b
-11111010b | 01010100b = 11111110b
-11111010b | 01010101b = 11111111b
-11111010b | 01010110b = 11111110b
-11111010b | 01010111b = 11111111b
-11111010b | 01011000b = 11111010b
-11111010b | 01011001b = 11111011b
-11111010b | 01011010b = 11111010b
-11111010b | 01011011b = 11111011b
-11111010b | 01011100b = 11111110b
-11111010b | 01011101b = 11111111b
-11111010b | 01011110b = 11111110b
-11111010b | 01011111b = 11111111b
-11111010b | 01100000b = 11111010b
-11111010b | 01100001b = 11111011b
-11111010b | 01100010b = 11111010b
-11111010b | 01100011b = 11111011b
-11111010b | 01100100b = 11111110b
-11111010b | 01100101b = 11111111b
-11111010b | 01100110b = 11111110b
-11111010b | 01100111b = 11111111b
-11111010b | 01101000b = 11111010b
-11111010b | 01101001b = 11111011b
-11111010b | 01101010b = 11111010b
-11111010b | 01101011b = 11111011b
-11111010b | 01101100b = 11111110b
-11111010b | 01101101b = 11111111b
-11111010b | 01101110b = 11111110b
-11111010b | 01101111b = 11111111b
-11111010b | 01110000b = 11111010b
-11111010b | 01110001b = 11111011b
-11111010b | 01110010b = 11111010b
-11111010b | 01110011b = 11111011b
-11111010b | 01110100b = 11111110b
-11111010b | 01110101b = 11111111b
-11111010b | 01110110b = 11111110b
-11111010b | 01110111b = 11111111b
-11111010b | 01111000b = 11111010b
-11111010b | 01111001b = 11111011b
-11111010b | 01111010b = 11111010b
-11111010b | 01111011b = 11111011b
-11111010b | 01111100b = 11111110b
-11111010b | 01111101b = 11111111b
-11111010b | 01111110b = 11111110b
-11111011b | 10000000b = 11111011b
-11111011b | 10000001b = 11111011b
-11111011b | 10000010b = 11111011b
-11111011b | 10000011b = 11111011b
-11111011b | 10000100b = 11111111b
-11111011b | 10000101b = 11111111b
-11111011b | 10000110b = 11111111b
-11111011b | 10000111b = 11111111b
-11111011b | 10001000b = 11111011b
-11111011b | 10001001b = 11111011b
-11111011b | 10001010b = 11111011b
-11111011b | 10001011b = 11111011b
-11111011b | 10001100b = 11111111b
-11111011b | 10001101b = 11111111b
-11111011b | 10001110b = 11111111b
-11111011b | 10001111b = 11111111b
-11111011b | 10010000b = 11111011b
-11111011b | 10010001b = 11111011b
-11111011b | 10010010b = 11111011b
-11111011b | 10010011b = 11111011b
-11111011b | 10010100b = 11111111b
-11111011b | 10010101b = 11111111b
-11111011b | 10010110b = 11111111b
-11111011b | 10010111b = 11111111b
-11111011b | 10011000b = 11111011b
-11111011b | 10011001b = 11111011b
-11111011b | 10011010b = 11111011b
-11111011b | 10011011b = 11111011b
-11111011b | 10011100b = 11111111b
-11111011b | 10011101b = 11111111b
-11111011b | 10011110b = 11111111b
-11111011b | 10011111b = 11111111b
-11111011b | 10100000b = 11111011b
-11111011b | 10100001b = 11111011b
-11111011b | 10100010b = 11111011b
-11111011b | 10100011b = 11111011b
-11111011b | 10100100b = 11111111b
-11111011b | 10100101b = 11111111b
-11111011b | 10100110b = 11111111b
-11111011b | 10100111b = 11111111b
-11111011b | 10101000b = 11111011b
-11111011b | 10101001b = 11111011b
-11111011b | 10101010b = 11111011b
-11111011b | 10101011b = 11111011b
-11111011b | 10101100b = 11111111b
-11111011b | 10101101b = 11111111b
-11111011b | 10101110b = 11111111b
-11111011b | 10101111b = 11111111b
-11111011b | 10110000b = 11111011b
-11111011b | 10110001b = 11111011b
-11111011b | 10110010b = 11111011b
-11111011b | 10110011b = 11111011b
-11111011b | 10110100b = 11111111b
-11111011b | 10110101b = 11111111b
-11111011b | 10110110b = 11111111b
-11111011b | 10110111b = 11111111b
-11111011b | 10111000b = 11111011b
-11111011b | 10111001b = 11111011b
-11111011b | 10111010b = 11111011b
-11111011b | 10111011b = 11111011b
-11111011b | 10111100b = 11111111b
-11111011b | 10111101b = 11111111b
-11111011b | 10111110b = 11111111b
-11111011b | 10111111b = 11111111b
-11111011b | 11000000b = 11111011b
-11111011b | 11000001b = 11111011b
-11111011b | 11000010b = 11111011b
-11111011b | 11000011b = 11111011b
-11111011b | 11000100b = 11111111b
-11111011b | 11000101b = 11111111b
-11111011b | 11000110b = 11111111b
-11111011b | 11000111b = 11111111b
-11111011b | 11001000b = 11111011b
-11111011b | 11001001b = 11111011b
-11111011b | 11001010b = 11111011b
-11111011b | 11001011b = 11111011b
-11111011b | 11001100b = 11111111b
-11111011b | 11001101b = 11111111b
-11111011b | 11001110b = 11111111b
-11111011b | 11001111b = 11111111b
-11111011b | 11010000b = 11111011b
-11111011b | 11010001b = 11111011b
-11111011b | 11010010b = 11111011b
-11111011b | 11010011b = 11111011b
-11111011b | 11010100b = 11111111b
-11111011b | 11010101b = 11111111b
-11111011b | 11010110b = 11111111b
-11111011b | 11010111b = 11111111b
-11111011b | 11011000b = 11111011b
-11111011b | 11011001b = 11111011b
-11111011b | 11011010b = 11111011b
-11111011b | 11011011b = 11111011b
-11111011b | 11011100b = 11111111b
-11111011b | 11011101b = 11111111b
-11111011b | 11011110b = 11111111b
-11111011b | 11011111b = 11111111b
-11111011b | 11100000b = 11111011b
-11111011b | 11100001b = 11111011b
-11111011b | 11100010b = 11111011b
-11111011b | 11100011b = 11111011b
-11111011b | 11100100b = 11111111b
-11111011b | 11100101b = 11111111b
-11111011b | 11100110b = 11111111b
-11111011b | 11100111b = 11111111b
-11111011b | 11101000b = 11111011b
-11111011b | 11101001b = 11111011b
-11111011b | 11101010b = 11111011b
-11111011b | 11101011b = 11111011b
-11111011b | 11101100b = 11111111b
-11111011b | 11101101b = 11111111b
-11111011b | 11101110b = 11111111b
-11111011b | 11101111b = 11111111b
-11111011b | 11110000b = 11111011b
-11111011b | 11110001b = 11111011b
-11111011b | 11110010b = 11111011b
-11111011b | 11110011b = 11111011b
-11111011b | 11110100b = 11111111b
-11111011b | 11110101b = 11111111b
-11111011b | 11110110b = 11111111b
-11111011b | 11110111b = 11111111b
-11111011b | 11111000b = 11111011b
-11111011b | 11111001b = 11111011b
-11111011b | 11111010b = 11111011b
-11111011b | 11111011b = 11111011b
-11111011b | 11111100b = 11111111b
-11111011b | 11111101b = 11111111b
-11111011b | 11111110b = 11111111b
-11111011b | 11111111b = 11111111b
-11111011b | 00000000b = 11111011b
-11111011b | 00000001b = 11111011b
-11111011b | 00000010b = 11111011b
-11111011b | 00000011b = 11111011b
-11111011b | 00000100b = 11111111b
-11111011b | 00000101b = 11111111b
-11111011b | 00000110b = 11111111b
-11111011b | 00000111b = 11111111b
-11111011b | 00001000b = 11111011b
-11111011b | 00001001b = 11111011b
-11111011b | 00001010b = 11111011b
-11111011b | 00001011b = 11111011b
-11111011b | 00001100b = 11111111b
-11111011b | 00001101b = 11111111b
-11111011b | 00001110b = 11111111b
-11111011b | 00001111b = 11111111b
-11111011b | 00010000b = 11111011b
-11111011b | 00010001b = 11111011b
-11111011b | 00010010b = 11111011b
-11111011b | 00010011b = 11111011b
-11111011b | 00010100b = 11111111b
-11111011b | 00010101b = 11111111b
-11111011b | 00010110b = 11111111b
-11111011b | 00010111b = 11111111b
-11111011b | 00011000b = 11111011b
-11111011b | 00011001b = 11111011b
-11111011b | 00011010b = 11111011b
-11111011b | 00011011b = 11111011b
-11111011b | 00011100b = 11111111b
-11111011b | 00011101b = 11111111b
-11111011b | 00011110b = 11111111b
-11111011b | 00011111b = 11111111b
-11111011b | 00100000b = 11111011b
-11111011b | 00100001b = 11111011b
-11111011b | 00100010b = 11111011b
-11111011b | 00100011b = 11111011b
-11111011b | 00100100b = 11111111b
-11111011b | 00100101b = 11111111b
-11111011b | 00100110b = 11111111b
-11111011b | 00100111b = 11111111b
-11111011b | 00101000b = 11111011b
-11111011b | 00101001b = 11111011b
-11111011b | 00101010b = 11111011b
-11111011b | 00101011b = 11111011b
-11111011b | 00101100b = 11111111b
-11111011b | 00101101b = 11111111b
-11111011b | 00101110b = 11111111b
-11111011b | 00101111b = 11111111b
-11111011b | 00110000b = 11111011b
-11111011b | 00110001b = 11111011b
-11111011b | 00110010b = 11111011b
-11111011b | 00110011b = 11111011b
-11111011b | 00110100b = 11111111b
-11111011b | 00110101b = 11111111b
-11111011b | 00110110b = 11111111b
-11111011b | 00110111b = 11111111b
-11111011b | 00111000b = 11111011b
-11111011b | 00111001b = 11111011b
-11111011b | 00111010b = 11111011b
-11111011b | 00111011b = 11111011b
-11111011b | 00111100b = 11111111b
-11111011b | 00111101b = 11111111b
-11111011b | 00111110b = 11111111b
-11111011b | 00111111b = 11111111b
-11111011b | 01000000b = 11111011b
-11111011b | 01000001b = 11111011b
-11111011b | 01000010b = 11111011b
-11111011b | 01000011b = 11111011b
-11111011b | 01000100b = 11111111b
-11111011b | 01000101b = 11111111b
-11111011b | 01000110b = 11111111b
-11111011b | 01000111b = 11111111b
-11111011b | 01001000b = 11111011b
-11111011b | 01001001b = 11111011b
-11111011b | 01001010b = 11111011b
-11111011b | 01001011b = 11111011b
-11111011b | 01001100b = 11111111b
-11111011b | 01001101b = 11111111b
-11111011b | 01001110b = 11111111b
-11111011b | 01001111b = 11111111b
-11111011b | 01010000b = 11111011b
-11111011b | 01010001b = 11111011b
-11111011b | 01010010b = 11111011b
-11111011b | 01010011b = 11111011b
-11111011b | 01010100b = 11111111b
-11111011b | 01010101b = 11111111b
-11111011b | 01010110b = 11111111b
-11111011b | 01010111b = 11111111b
-11111011b | 01011000b = 11111011b
-11111011b | 01011001b = 11111011b
-11111011b | 01011010b = 11111011b
-11111011b | 01011011b = 11111011b
-11111011b | 01011100b = 11111111b
-11111011b | 01011101b = 11111111b
-11111011b | 01011110b = 11111111b
-11111011b | 01011111b = 11111111b
-11111011b | 01100000b = 11111011b
-11111011b | 01100001b = 11111011b
-11111011b | 01100010b = 11111011b
-11111011b | 01100011b = 11111011b
-11111011b | 01100100b = 11111111b
-11111011b | 01100101b = 11111111b
-11111011b | 01100110b = 11111111b
-11111011b | 01100111b = 11111111b
-11111011b | 01101000b = 11111011b
-11111011b | 01101001b = 11111011b
-11111011b | 01101010b = 11111011b
-11111011b | 01101011b = 11111011b
-11111011b | 01101100b = 11111111b
-11111011b | 01101101b = 11111111b
-11111011b | 01101110b = 11111111b
-11111011b | 01101111b = 11111111b
-11111011b | 01110000b = 11111011b
-11111011b | 01110001b = 11111011b
-11111011b | 01110010b = 11111011b
-11111011b | 01110011b = 11111011b
-11111011b | 01110100b = 11111111b
-11111011b | 01110101b = 11111111b
-11111011b | 01110110b = 11111111b
-11111011b | 01110111b = 11111111b
-11111011b | 01111000b = 11111011b
-11111011b | 01111001b = 11111011b
-11111011b | 01111010b = 11111011b
-11111011b | 01111011b = 11111011b
-11111011b | 01111100b = 11111111b
-11111011b | 01111101b = 11111111b
-11111011b | 01111110b = 11111111b
-11111100b | 10000000b = 11111100b
-11111100b | 10000001b = 11111101b
-11111100b | 10000010b = 11111110b
-11111100b | 10000011b = 11111111b
-11111100b | 10000100b = 11111100b
-11111100b | 10000101b = 11111101b
-11111100b | 10000110b = 11111110b
-11111100b | 10000111b = 11111111b
-11111100b | 10001000b = 11111100b
-11111100b | 10001001b = 11111101b
-11111100b | 10001010b = 11111110b
-11111100b | 10001011b = 11111111b
-11111100b | 10001100b = 11111100b
-11111100b | 10001101b = 11111101b
-11111100b | 10001110b = 11111110b
-11111100b | 10001111b = 11111111b
-11111100b | 10010000b = 11111100b
-11111100b | 10010001b = 11111101b
-11111100b | 10010010b = 11111110b
-11111100b | 10010011b = 11111111b
-11111100b | 10010100b = 11111100b
-11111100b | 10010101b = 11111101b
-11111100b | 10010110b = 11111110b
-11111100b | 10010111b = 11111111b
-11111100b | 10011000b = 11111100b
-11111100b | 10011001b = 11111101b
-11111100b | 10011010b = 11111110b
-11111100b | 10011011b = 11111111b
-11111100b | 10011100b = 11111100b
-11111100b | 10011101b = 11111101b
-11111100b | 10011110b = 11111110b
-11111100b | 10011111b = 11111111b
-11111100b | 10100000b = 11111100b
-11111100b | 10100001b = 11111101b
-11111100b | 10100010b = 11111110b
-11111100b | 10100011b = 11111111b
-11111100b | 10100100b = 11111100b
-11111100b | 10100101b = 11111101b
-11111100b | 10100110b = 11111110b
-11111100b | 10100111b = 11111111b
-11111100b | 10101000b = 11111100b
-11111100b | 10101001b = 11111101b
-11111100b | 10101010b = 11111110b
-11111100b | 10101011b = 11111111b
-11111100b | 10101100b = 11111100b
-11111100b | 10101101b = 11111101b
-11111100b | 10101110b = 11111110b
-11111100b | 10101111b = 11111111b
-11111100b | 10110000b = 11111100b
-11111100b | 10110001b = 11111101b
-11111100b | 10110010b = 11111110b
-11111100b | 10110011b = 11111111b
-11111100b | 10110100b = 11111100b
-11111100b | 10110101b = 11111101b
-11111100b | 10110110b = 11111110b
-11111100b | 10110111b = 11111111b
-11111100b | 10111000b = 11111100b
-11111100b | 10111001b = 11111101b
-11111100b | 10111010b = 11111110b
-11111100b | 10111011b = 11111111b
-11111100b | 10111100b = 11111100b
-11111100b | 10111101b = 11111101b
-11111100b | 10111110b = 11111110b
-11111100b | 10111111b = 11111111b
-11111100b | 11000000b = 11111100b
-11111100b | 11000001b = 11111101b
-11111100b | 11000010b = 11111110b
-11111100b | 11000011b = 11111111b
-11111100b | 11000100b = 11111100b
-11111100b | 11000101b = 11111101b
-11111100b | 11000110b = 11111110b
-11111100b | 11000111b = 11111111b
-11111100b | 11001000b = 11111100b
-11111100b | 11001001b = 11111101b
-11111100b | 11001010b = 11111110b
-11111100b | 11001011b = 11111111b
-11111100b | 11001100b = 11111100b
-11111100b | 11001101b = 11111101b
-11111100b | 11001110b = 11111110b
-11111100b | 11001111b = 11111111b
-11111100b | 11010000b = 11111100b
-11111100b | 11010001b = 11111101b
-11111100b | 11010010b = 11111110b
-11111100b | 11010011b = 11111111b
-11111100b | 11010100b = 11111100b
-11111100b | 11010101b = 11111101b
-11111100b | 11010110b = 11111110b
-11111100b | 11010111b = 11111111b
-11111100b | 11011000b = 11111100b
-11111100b | 11011001b = 11111101b
-11111100b | 11011010b = 11111110b
-11111100b | 11011011b = 11111111b
-11111100b | 11011100b = 11111100b
-11111100b | 11011101b = 11111101b
-11111100b | 11011110b = 11111110b
-11111100b | 11011111b = 11111111b
-11111100b | 11100000b = 11111100b
-11111100b | 11100001b = 11111101b
-11111100b | 11100010b = 11111110b
-11111100b | 11100011b = 11111111b
-11111100b | 11100100b = 11111100b
-11111100b | 11100101b = 11111101b
-11111100b | 11100110b = 11111110b
-11111100b | 11100111b = 11111111b
-11111100b | 11101000b = 11111100b
-11111100b | 11101001b = 11111101b
-11111100b | 11101010b = 11111110b
-11111100b | 11101011b = 11111111b
-11111100b | 11101100b = 11111100b
-11111100b | 11101101b = 11111101b
-11111100b | 11101110b = 11111110b
-11111100b | 11101111b = 11111111b
-11111100b | 11110000b = 11111100b
-11111100b | 11110001b = 11111101b
-11111100b | 11110010b = 11111110b
-11111100b | 11110011b = 11111111b
-11111100b | 11110100b = 11111100b
-11111100b | 11110101b = 11111101b
-11111100b | 11110110b = 11111110b
-11111100b | 11110111b = 11111111b
-11111100b | 11111000b = 11111100b
-11111100b | 11111001b = 11111101b
-11111100b | 11111010b = 11111110b
-11111100b | 11111011b = 11111111b
-11111100b | 11111100b = 11111100b
-11111100b | 11111101b = 11111101b
-11111100b | 11111110b = 11111110b
-11111100b | 11111111b = 11111111b
-11111100b | 00000000b = 11111100b
-11111100b | 00000001b = 11111101b
-11111100b | 00000010b = 11111110b
-11111100b | 00000011b = 11111111b
-11111100b | 00000100b = 11111100b
-11111100b | 00000101b = 11111101b
-11111100b | 00000110b = 11111110b
-11111100b | 00000111b = 11111111b
-11111100b | 00001000b = 11111100b
-11111100b | 00001001b = 11111101b
-11111100b | 00001010b = 11111110b
-11111100b | 00001011b = 11111111b
-11111100b | 00001100b = 11111100b
-11111100b | 00001101b = 11111101b
-11111100b | 00001110b = 11111110b
-11111100b | 00001111b = 11111111b
-11111100b | 00010000b = 11111100b
-11111100b | 00010001b = 11111101b
-11111100b | 00010010b = 11111110b
-11111100b | 00010011b = 11111111b
-11111100b | 00010100b = 11111100b
-11111100b | 00010101b = 11111101b
-11111100b | 00010110b = 11111110b
-11111100b | 00010111b = 11111111b
-11111100b | 00011000b = 11111100b
-11111100b | 00011001b = 11111101b
-11111100b | 00011010b = 11111110b
-11111100b | 00011011b = 11111111b
-11111100b | 00011100b = 11111100b
-11111100b | 00011101b = 11111101b
-11111100b | 00011110b = 11111110b
-11111100b | 00011111b = 11111111b
-11111100b | 00100000b = 11111100b
-11111100b | 00100001b = 11111101b
-11111100b | 00100010b = 11111110b
-11111100b | 00100011b = 11111111b
-11111100b | 00100100b = 11111100b
-11111100b | 00100101b = 11111101b
-11111100b | 00100110b = 11111110b
-11111100b | 00100111b = 11111111b
-11111100b | 00101000b = 11111100b
-11111100b | 00101001b = 11111101b
-11111100b | 00101010b = 11111110b
-11111100b | 00101011b = 11111111b
-11111100b | 00101100b = 11111100b
-11111100b | 00101101b = 11111101b
-11111100b | 00101110b = 11111110b
-11111100b | 00101111b = 11111111b
-11111100b | 00110000b = 11111100b
-11111100b | 00110001b = 11111101b
-11111100b | 00110010b = 11111110b
-11111100b | 00110011b = 11111111b
-11111100b | 00110100b = 11111100b
-11111100b | 00110101b = 11111101b
-11111100b | 00110110b = 11111110b
-11111100b | 00110111b = 11111111b
-11111100b | 00111000b = 11111100b
-11111100b | 00111001b = 11111101b
-11111100b | 00111010b = 11111110b
-11111100b | 00111011b = 11111111b
-11111100b | 00111100b = 11111100b
-11111100b | 00111101b = 11111101b
-11111100b | 00111110b = 11111110b
-11111100b | 00111111b = 11111111b
-11111100b | 01000000b = 11111100b
-11111100b | 01000001b = 11111101b
-11111100b | 01000010b = 11111110b
-11111100b | 01000011b = 11111111b
-11111100b | 01000100b = 11111100b
-11111100b | 01000101b = 11111101b
-11111100b | 01000110b = 11111110b
-11111100b | 01000111b = 11111111b
-11111100b | 01001000b = 11111100b
-11111100b | 01001001b = 11111101b
-11111100b | 01001010b = 11111110b
-11111100b | 01001011b = 11111111b
-11111100b | 01001100b = 11111100b
-11111100b | 01001101b = 11111101b
-11111100b | 01001110b = 11111110b
-11111100b | 01001111b = 11111111b
-11111100b | 01010000b = 11111100b
-11111100b | 01010001b = 11111101b
-11111100b | 01010010b = 11111110b
-11111100b | 01010011b = 11111111b
-11111100b | 01010100b = 11111100b
-11111100b | 01010101b = 11111101b
-11111100b | 01010110b = 11111110b
-11111100b | 01010111b = 11111111b
-11111100b | 01011000b = 11111100b
-11111100b | 01011001b = 11111101b
-11111100b | 01011010b = 11111110b
-11111100b | 01011011b = 11111111b
-11111100b | 01011100b = 11111100b
-11111100b | 01011101b = 11111101b
-11111100b | 01011110b = 11111110b
-11111100b | 01011111b = 11111111b
-11111100b | 01100000b = 11111100b
-11111100b | 01100001b = 11111101b
-11111100b | 01100010b = 11111110b
-11111100b | 01100011b = 11111111b
-11111100b | 01100100b = 11111100b
-11111100b | 01100101b = 11111101b
-11111100b | 01100110b = 11111110b
-11111100b | 01100111b = 11111111b
-11111100b | 01101000b = 11111100b
-11111100b | 01101001b = 11111101b
-11111100b | 01101010b = 11111110b
-11111100b | 01101011b = 11111111b
-11111100b | 01101100b = 11111100b
-11111100b | 01101101b = 11111101b
-11111100b | 01101110b = 11111110b
-11111100b | 01101111b = 11111111b
-11111100b | 01110000b = 11111100b
-11111100b | 01110001b = 11111101b
-11111100b | 01110010b = 11111110b
-11111100b | 01110011b = 11111111b
-11111100b | 01110100b = 11111100b
-11111100b | 01110101b = 11111101b
-11111100b | 01110110b = 11111110b
-11111100b | 01110111b = 11111111b
-11111100b | 01111000b = 11111100b
-11111100b | 01111001b = 11111101b
-11111100b | 01111010b = 11111110b
-11111100b | 01111011b = 11111111b
-11111100b | 01111100b = 11111100b
-11111100b | 01111101b = 11111101b
-11111100b | 01111110b = 11111110b
-11111101b | 10000000b = 11111101b
-11111101b | 10000001b = 11111101b
-11111101b | 10000010b = 11111111b
-11111101b | 10000011b = 11111111b
-11111101b | 10000100b = 11111101b
-11111101b | 10000101b = 11111101b
-11111101b | 10000110b = 11111111b
-11111101b | 10000111b = 11111111b
-11111101b | 10001000b = 11111101b
-11111101b | 10001001b = 11111101b
-11111101b | 10001010b = 11111111b
-11111101b | 10001011b = 11111111b
-11111101b | 10001100b = 11111101b
-11111101b | 10001101b = 11111101b
-11111101b | 10001110b = 11111111b
-11111101b | 10001111b = 11111111b
-11111101b | 10010000b = 11111101b
-11111101b | 10010001b = 11111101b
-11111101b | 10010010b = 11111111b
-11111101b | 10010011b = 11111111b
-11111101b | 10010100b = 11111101b
-11111101b | 10010101b = 11111101b
-11111101b | 10010110b = 11111111b
-11111101b | 10010111b = 11111111b
-11111101b | 10011000b = 11111101b
-11111101b | 10011001b = 11111101b
-11111101b | 10011010b = 11111111b
-11111101b | 10011011b = 11111111b
-11111101b | 10011100b = 11111101b
-11111101b | 10011101b = 11111101b
-11111101b | 10011110b = 11111111b
-11111101b | 10011111b = 11111111b
-11111101b | 10100000b = 11111101b
-11111101b | 10100001b = 11111101b
-11111101b | 10100010b = 11111111b
-11111101b | 10100011b = 11111111b
-11111101b | 10100100b = 11111101b
-11111101b | 10100101b = 11111101b
-11111101b | 10100110b = 11111111b
-11111101b | 10100111b = 11111111b
-11111101b | 10101000b = 11111101b
-11111101b | 10101001b = 11111101b
-11111101b | 10101010b = 11111111b
-11111101b | 10101011b = 11111111b
-11111101b | 10101100b = 11111101b
-11111101b | 10101101b = 11111101b
-11111101b | 10101110b = 11111111b
-11111101b | 10101111b = 11111111b
-11111101b | 10110000b = 11111101b
-11111101b | 10110001b = 11111101b
-11111101b | 10110010b = 11111111b
-11111101b | 10110011b = 11111111b
-11111101b | 10110100b = 11111101b
-11111101b | 10110101b = 11111101b
-11111101b | 10110110b = 11111111b
-11111101b | 10110111b = 11111111b
-11111101b | 10111000b = 11111101b
-11111101b | 10111001b = 11111101b
-11111101b | 10111010b = 11111111b
-11111101b | 10111011b = 11111111b
-11111101b | 10111100b = 11111101b
-11111101b | 10111101b = 11111101b
-11111101b | 10111110b = 11111111b
-11111101b | 10111111b = 11111111b
-11111101b | 11000000b = 11111101b
-11111101b | 11000001b = 11111101b
-11111101b | 11000010b = 11111111b
-11111101b | 11000011b = 11111111b
-11111101b | 11000100b = 11111101b
-11111101b | 11000101b = 11111101b
-11111101b | 11000110b = 11111111b
-11111101b | 11000111b = 11111111b
-11111101b | 11001000b = 11111101b
-11111101b | 11001001b = 11111101b
-11111101b | 11001010b = 11111111b
-11111101b | 11001011b = 11111111b
-11111101b | 11001100b = 11111101b
-11111101b | 11001101b = 11111101b
-11111101b | 11001110b = 11111111b
-11111101b | 11001111b = 11111111b
-11111101b | 11010000b = 11111101b
-11111101b | 11010001b = 11111101b
-11111101b | 11010010b = 11111111b
-11111101b | 11010011b = 11111111b
-11111101b | 11010100b = 11111101b
-11111101b | 11010101b = 11111101b
-11111101b | 11010110b = 11111111b
-11111101b | 11010111b = 11111111b
-11111101b | 11011000b = 11111101b
-11111101b | 11011001b = 11111101b
-11111101b | 11011010b = 11111111b
-11111101b | 11011011b = 11111111b
-11111101b | 11011100b = 11111101b
-11111101b | 11011101b = 11111101b
-11111101b | 11011110b = 11111111b
-11111101b | 11011111b = 11111111b
-11111101b | 11100000b = 11111101b
-11111101b | 11100001b = 11111101b
-11111101b | 11100010b = 11111111b
-11111101b | 11100011b = 11111111b
-11111101b | 11100100b = 11111101b
-11111101b | 11100101b = 11111101b
-11111101b | 11100110b = 11111111b
-11111101b | 11100111b = 11111111b
-11111101b | 11101000b = 11111101b
-11111101b | 11101001b = 11111101b
-11111101b | 11101010b = 11111111b
-11111101b | 11101011b = 11111111b
-11111101b | 11101100b = 11111101b
-11111101b | 11101101b = 11111101b
-11111101b | 11101110b = 11111111b
-11111101b | 11101111b = 11111111b
-11111101b | 11110000b = 11111101b
-11111101b | 11110001b = 11111101b
-11111101b | 11110010b = 11111111b
-11111101b | 11110011b = 11111111b
-11111101b | 11110100b = 11111101b
-11111101b | 11110101b = 11111101b
-11111101b | 11110110b = 11111111b
-11111101b | 11110111b = 11111111b
-11111101b | 11111000b = 11111101b
-11111101b | 11111001b = 11111101b
-11111101b | 11111010b = 11111111b
-11111101b | 11111011b = 11111111b
-11111101b | 11111100b = 11111101b
-11111101b | 11111101b = 11111101b
-11111101b | 11111110b = 11111111b
-11111101b | 11111111b = 11111111b
-11111101b | 00000000b = 11111101b
-11111101b | 00000001b = 11111101b
-11111101b | 00000010b = 11111111b
-11111101b | 00000011b = 11111111b
-11111101b | 00000100b = 11111101b
-11111101b | 00000101b = 11111101b
-11111101b | 00000110b = 11111111b
-11111101b | 00000111b = 11111111b
-11111101b | 00001000b = 11111101b
-11111101b | 00001001b = 11111101b
-11111101b | 00001010b = 11111111b
-11111101b | 00001011b = 11111111b
-11111101b | 00001100b = 11111101b
-11111101b | 00001101b = 11111101b
-11111101b | 00001110b = 11111111b
-11111101b | 00001111b = 11111111b
-11111101b | 00010000b = 11111101b
-11111101b | 00010001b = 11111101b
-11111101b | 00010010b = 11111111b
-11111101b | 00010011b = 11111111b
-11111101b | 00010100b = 11111101b
-11111101b | 00010101b = 11111101b
-11111101b | 00010110b = 11111111b
-11111101b | 00010111b = 11111111b
-11111101b | 00011000b = 11111101b
-11111101b | 00011001b = 11111101b
-11111101b | 00011010b = 11111111b
-11111101b | 00011011b = 11111111b
-11111101b | 00011100b = 11111101b
-11111101b | 00011101b = 11111101b
-11111101b | 00011110b = 11111111b
-11111101b | 00011111b = 11111111b
-11111101b | 00100000b = 11111101b
-11111101b | 00100001b = 11111101b
-11111101b | 00100010b = 11111111b
-11111101b | 00100011b = 11111111b
-11111101b | 00100100b = 11111101b
-11111101b | 00100101b = 11111101b
-11111101b | 00100110b = 11111111b
-11111101b | 00100111b = 11111111b
-11111101b | 00101000b = 11111101b
-11111101b | 00101001b = 11111101b
-11111101b | 00101010b = 11111111b
-11111101b | 00101011b = 11111111b
-11111101b | 00101100b = 11111101b
-11111101b | 00101101b = 11111101b
-11111101b | 00101110b = 11111111b
-11111101b | 00101111b = 11111111b
-11111101b | 00110000b = 11111101b
-11111101b | 00110001b = 11111101b
-11111101b | 00110010b = 11111111b
-11111101b | 00110011b = 11111111b
-11111101b | 00110100b = 11111101b
-11111101b | 00110101b = 11111101b
-11111101b | 00110110b = 11111111b
-11111101b | 00110111b = 11111111b
-11111101b | 00111000b = 11111101b
-11111101b | 00111001b = 11111101b
-11111101b | 00111010b = 11111111b
-11111101b | 00111011b = 11111111b
-11111101b | 00111100b = 11111101b
-11111101b | 00111101b = 11111101b
-11111101b | 00111110b = 11111111b
-11111101b | 00111111b = 11111111b
-11111101b | 01000000b = 11111101b
-11111101b | 01000001b = 11111101b
-11111101b | 01000010b = 11111111b
-11111101b | 01000011b = 11111111b
-11111101b | 01000100b = 11111101b
-11111101b | 01000101b = 11111101b
-11111101b | 01000110b = 11111111b
-11111101b | 01000111b = 11111111b
-11111101b | 01001000b = 11111101b
-11111101b | 01001001b = 11111101b
-11111101b | 01001010b = 11111111b
-11111101b | 01001011b = 11111111b
-11111101b | 01001100b = 11111101b
-11111101b | 01001101b = 11111101b
-11111101b | 01001110b = 11111111b
-11111101b | 01001111b = 11111111b
-11111101b | 01010000b = 11111101b
-11111101b | 01010001b = 11111101b
-11111101b | 01010010b = 11111111b
-11111101b | 01010011b = 11111111b
-11111101b | 01010100b = 11111101b
-11111101b | 01010101b = 11111101b
-11111101b | 01010110b = 11111111b
-11111101b | 01010111b = 11111111b
-11111101b | 01011000b = 11111101b
-11111101b | 01011001b = 11111101b
-11111101b | 01011010b = 11111111b
-11111101b | 01011011b = 11111111b
-11111101b | 01011100b = 11111101b
-11111101b | 01011101b = 11111101b
-11111101b | 01011110b = 11111111b
-11111101b | 01011111b = 11111111b
-11111101b | 01100000b = 11111101b
-11111101b | 01100001b = 11111101b
-11111101b | 01100010b = 11111111b
-11111101b | 01100011b = 11111111b
-11111101b | 01100100b = 11111101b
-11111101b | 01100101b = 11111101b
-11111101b | 01100110b = 11111111b
-11111101b | 01100111b = 11111111b
-11111101b | 01101000b = 11111101b
-11111101b | 01101001b = 11111101b
-11111101b | 01101010b = 11111111b
-11111101b | 01101011b = 11111111b
-11111101b | 01101100b = 11111101b
-11111101b | 01101101b = 11111101b
-11111101b | 01101110b = 11111111b
-11111101b | 01101111b = 11111111b
-11111101b | 01110000b = 11111101b
-11111101b | 01110001b = 11111101b
-11111101b | 01110010b = 11111111b
-11111101b | 01110011b = 11111111b
-11111101b | 01110100b = 11111101b
-11111101b | 01110101b = 11111101b
-11111101b | 01110110b = 11111111b
-11111101b | 01110111b = 11111111b
-11111101b | 01111000b = 11111101b
-11111101b | 01111001b = 11111101b
-11111101b | 01111010b = 11111111b
-11111101b | 01111011b = 11111111b
-11111101b | 01111100b = 11111101b
-11111101b | 01111101b = 11111101b
-11111101b | 01111110b = 11111111b
-11111110b | 10000000b = 11111110b
-11111110b | 10000001b = 11111111b
-11111110b | 10000010b = 11111110b
-11111110b | 10000011b = 11111111b
-11111110b | 10000100b = 11111110b
-11111110b | 10000101b = 11111111b
-11111110b | 10000110b = 11111110b
-11111110b | 10000111b = 11111111b
-11111110b | 10001000b = 11111110b
-11111110b | 10001001b = 11111111b
-11111110b | 10001010b = 11111110b
-11111110b | 10001011b = 11111111b
-11111110b | 10001100b = 11111110b
-11111110b | 10001101b = 11111111b
-11111110b | 10001110b = 11111110b
-11111110b | 10001111b = 11111111b
-11111110b | 10010000b = 11111110b
-11111110b | 10010001b = 11111111b
-11111110b | 10010010b = 11111110b
-11111110b | 10010011b = 11111111b
-11111110b | 10010100b = 11111110b
-11111110b | 10010101b = 11111111b
-11111110b | 10010110b = 11111110b
-11111110b | 10010111b = 11111111b
-11111110b | 10011000b = 11111110b
-11111110b | 10011001b = 11111111b
-11111110b | 10011010b = 11111110b
-11111110b | 10011011b = 11111111b
-11111110b | 10011100b = 11111110b
-11111110b | 10011101b = 11111111b
-11111110b | 10011110b = 11111110b
-11111110b | 10011111b = 11111111b
-11111110b | 10100000b = 11111110b
-11111110b | 10100001b = 11111111b
-11111110b | 10100010b = 11111110b
-11111110b | 10100011b = 11111111b
-11111110b | 10100100b = 11111110b
-11111110b | 10100101b = 11111111b
-11111110b | 10100110b = 11111110b
-11111110b | 10100111b = 11111111b
-11111110b | 10101000b = 11111110b
-11111110b | 10101001b = 11111111b
-11111110b | 10101010b = 11111110b
-11111110b | 10101011b = 11111111b
-11111110b | 10101100b = 11111110b
-11111110b | 10101101b = 11111111b
-11111110b | 10101110b = 11111110b
-11111110b | 10101111b = 11111111b
-11111110b | 10110000b = 11111110b
-11111110b | 10110001b = 11111111b
-11111110b | 10110010b = 11111110b
-11111110b | 10110011b = 11111111b
-11111110b | 10110100b = 11111110b
-11111110b | 10110101b = 11111111b
-11111110b | 10110110b = 11111110b
-11111110b | 10110111b = 11111111b
-11111110b | 10111000b = 11111110b
-11111110b | 10111001b = 11111111b
-11111110b | 10111010b = 11111110b
-11111110b | 10111011b = 11111111b
-11111110b | 10111100b = 11111110b
-11111110b | 10111101b = 11111111b
-11111110b | 10111110b = 11111110b
-11111110b | 10111111b = 11111111b
-11111110b | 11000000b = 11111110b
-11111110b | 11000001b = 11111111b
-11111110b | 11000010b = 11111110b
-11111110b | 11000011b = 11111111b
-11111110b | 11000100b = 11111110b
-11111110b | 11000101b = 11111111b
-11111110b | 11000110b = 11111110b
-11111110b | 11000111b = 11111111b
-11111110b | 11001000b = 11111110b
-11111110b | 11001001b = 11111111b
-11111110b | 11001010b = 11111110b
-11111110b | 11001011b = 11111111b
-11111110b | 11001100b = 11111110b
-11111110b | 11001101b = 11111111b
-11111110b | 11001110b = 11111110b
-11111110b | 11001111b = 11111111b
-11111110b | 11010000b = 11111110b
-11111110b | 11010001b = 11111111b
-11111110b | 11010010b = 11111110b
-11111110b | 11010011b = 11111111b
-11111110b | 11010100b = 11111110b
-11111110b | 11010101b = 11111111b
-11111110b | 11010110b = 11111110b
-11111110b | 11010111b = 11111111b
-11111110b | 11011000b = 11111110b
-11111110b | 11011001b = 11111111b
-11111110b | 11011010b = 11111110b
-11111110b | 11011011b = 11111111b
-11111110b | 11011100b = 11111110b
-11111110b | 11011101b = 11111111b
-11111110b | 11011110b = 11111110b
-11111110b | 11011111b = 11111111b
-11111110b | 11100000b = 11111110b
-11111110b | 11100001b = 11111111b
-11111110b | 11100010b = 11111110b
-11111110b | 11100011b = 11111111b
-11111110b | 11100100b = 11111110b
-11111110b | 11100101b = 11111111b
-11111110b | 11100110b = 11111110b
-11111110b | 11100111b = 11111111b
-11111110b | 11101000b = 11111110b
-11111110b | 11101001b = 11111111b
-11111110b | 11101010b = 11111110b
-11111110b | 11101011b = 11111111b
-11111110b | 11101100b = 11111110b
-11111110b | 11101101b = 11111111b
-11111110b | 11101110b = 11111110b
-11111110b | 11101111b = 11111111b
-11111110b | 11110000b = 11111110b
-11111110b | 11110001b = 11111111b
-11111110b | 11110010b = 11111110b
-11111110b | 11110011b = 11111111b
-11111110b | 11110100b = 11111110b
-11111110b | 11110101b = 11111111b
-11111110b | 11110110b = 11111110b
-11111110b | 11110111b = 11111111b
-11111110b | 11111000b = 11111110b
-11111110b | 11111001b = 11111111b
-11111110b | 11111010b = 11111110b
-11111110b | 11111011b = 11111111b
-11111110b | 11111100b = 11111110b
-11111110b | 11111101b = 11111111b
-11111110b | 11111110b = 11111110b
-11111110b | 11111111b = 11111111b
-11111110b | 00000000b = 11111110b
-11111110b | 00000001b = 11111111b
-11111110b | 00000010b = 11111110b
-11111110b | 00000011b = 11111111b
-11111110b | 00000100b = 11111110b
-11111110b | 00000101b = 11111111b
-11111110b | 00000110b = 11111110b
-11111110b | 00000111b = 11111111b
-11111110b | 00001000b = 11111110b
-11111110b | 00001001b = 11111111b
-11111110b | 00001010b = 11111110b
-11111110b | 00001011b = 11111111b
-11111110b | 00001100b = 11111110b
-11111110b | 00001101b = 11111111b
-11111110b | 00001110b = 11111110b
-11111110b | 00001111b = 11111111b
-11111110b | 00010000b = 11111110b
-11111110b | 00010001b = 11111111b
-11111110b | 00010010b = 11111110b
-11111110b | 00010011b = 11111111b
-11111110b | 00010100b = 11111110b
-11111110b | 00010101b = 11111111b
-11111110b | 00010110b = 11111110b
-11111110b | 00010111b = 11111111b
-11111110b | 00011000b = 11111110b
-11111110b | 00011001b = 11111111b
-11111110b | 00011010b = 11111110b
-11111110b | 00011011b = 11111111b
-11111110b | 00011100b = 11111110b
-11111110b | 00011101b = 11111111b
-11111110b | 00011110b = 11111110b
-11111110b | 00011111b = 11111111b
-11111110b | 00100000b = 11111110b
-11111110b | 00100001b = 11111111b
-11111110b | 00100010b = 11111110b
-11111110b | 00100011b = 11111111b
-11111110b | 00100100b = 11111110b
-11111110b | 00100101b = 11111111b
-11111110b | 00100110b = 11111110b
-11111110b | 00100111b = 11111111b
-11111110b | 00101000b = 11111110b
-11111110b | 00101001b = 11111111b
-11111110b | 00101010b = 11111110b
-11111110b | 00101011b = 11111111b
-11111110b | 00101100b = 11111110b
-11111110b | 00101101b = 11111111b
-11111110b | 00101110b = 11111110b
-11111110b | 00101111b = 11111111b
-11111110b | 00110000b = 11111110b
-11111110b | 00110001b = 11111111b
-11111110b | 00110010b = 11111110b
-11111110b | 00110011b = 11111111b
-11111110b | 00110100b = 11111110b
-11111110b | 00110101b = 11111111b
-11111110b | 00110110b = 11111110b
-11111110b | 00110111b = 11111111b
-11111110b | 00111000b = 11111110b
-11111110b | 00111001b = 11111111b
-11111110b | 00111010b = 11111110b
-11111110b | 00111011b = 11111111b
-11111110b | 00111100b = 11111110b
-11111110b | 00111101b = 11111111b
-11111110b | 00111110b = 11111110b
-11111110b | 00111111b = 11111111b
-11111110b | 01000000b = 11111110b
-11111110b | 01000001b = 11111111b
-11111110b | 01000010b = 11111110b
-11111110b | 01000011b = 11111111b
-11111110b | 01000100b = 11111110b
-11111110b | 01000101b = 11111111b
-11111110b | 01000110b = 11111110b
-11111110b | 01000111b = 11111111b
-11111110b | 01001000b = 11111110b
-11111110b | 01001001b = 11111111b
-11111110b | 01001010b = 11111110b
-11111110b | 01001011b = 11111111b
-11111110b | 01001100b = 11111110b
-11111110b | 01001101b = 11111111b
-11111110b | 01001110b = 11111110b
-11111110b | 01001111b = 11111111b
-11111110b | 01010000b = 11111110b
-11111110b | 01010001b = 11111111b
-11111110b | 01010010b = 11111110b
-11111110b | 01010011b = 11111111b
-11111110b | 01010100b = 11111110b
-11111110b | 01010101b = 11111111b
-11111110b | 01010110b = 11111110b
-11111110b | 01010111b = 11111111b
-11111110b | 01011000b = 11111110b
-11111110b | 01011001b = 11111111b
-11111110b | 01011010b = 11111110b
-11111110b | 01011011b = 11111111b
-11111110b | 01011100b = 11111110b
-11111110b | 01011101b = 11111111b
-11111110b | 01011110b = 11111110b
-11111110b | 01011111b = 11111111b
-11111110b | 01100000b = 11111110b
-11111110b | 01100001b = 11111111b
-11111110b | 01100010b = 11111110b
-11111110b | 01100011b = 11111111b
-11111110b | 01100100b = 11111110b
-11111110b | 01100101b = 11111111b
-11111110b | 01100110b = 11111110b
-11111110b | 01100111b = 11111111b
-11111110b | 01101000b = 11111110b
-11111110b | 01101001b = 11111111b
-11111110b | 01101010b = 11111110b
-11111110b | 01101011b = 11111111b
-11111110b | 01101100b = 11111110b
-11111110b | 01101101b = 11111111b
-11111110b | 01101110b = 11111110b
-11111110b | 01101111b = 11111111b
-11111110b | 01110000b = 11111110b
-11111110b | 01110001b = 11111111b
-11111110b | 01110010b = 11111110b
-11111110b | 01110011b = 11111111b
-11111110b | 01110100b = 11111110b
-11111110b | 01110101b = 11111111b
-11111110b | 01110110b = 11111110b
-11111110b | 01110111b = 11111111b
-11111110b | 01111000b = 11111110b
-11111110b | 01111001b = 11111111b
-11111110b | 01111010b = 11111110b
-11111110b | 01111011b = 11111111b
-11111110b | 01111100b = 11111110b
-11111110b | 01111101b = 11111111b
-11111110b | 01111110b = 11111110b
-11111111b | 10000000b = 11111111b
-11111111b | 10000001b = 11111111b
-11111111b | 10000010b = 11111111b
-11111111b | 10000011b = 11111111b
-11111111b | 10000100b = 11111111b
-11111111b | 10000101b = 11111111b
-11111111b | 10000110b = 11111111b
-11111111b | 10000111b = 11111111b
-11111111b | 10001000b = 11111111b
-11111111b | 10001001b = 11111111b
-11111111b | 10001010b = 11111111b
-11111111b | 10001011b = 11111111b
-11111111b | 10001100b = 11111111b
-11111111b | 10001101b = 11111111b
-11111111b | 10001110b = 11111111b
-11111111b | 10001111b = 11111111b
-11111111b | 10010000b = 11111111b
-11111111b | 10010001b = 11111111b
-11111111b | 10010010b = 11111111b
-11111111b | 10010011b = 11111111b
-11111111b | 10010100b = 11111111b
-11111111b | 10010101b = 11111111b
-11111111b | 10010110b = 11111111b
-11111111b | 10010111b = 11111111b
-11111111b | 10011000b = 11111111b
-11111111b | 10011001b = 11111111b
-11111111b | 10011010b = 11111111b
-11111111b | 10011011b = 11111111b
-11111111b | 10011100b = 11111111b
-11111111b | 10011101b = 11111111b
-11111111b | 10011110b = 11111111b
-11111111b | 10011111b = 11111111b
-11111111b | 10100000b = 11111111b
-11111111b | 10100001b = 11111111b
-11111111b | 10100010b = 11111111b
-11111111b | 10100011b = 11111111b
-11111111b | 10100100b = 11111111b
-11111111b | 10100101b = 11111111b
-11111111b | 10100110b = 11111111b
-11111111b | 10100111b = 11111111b
-11111111b | 10101000b = 11111111b
-11111111b | 10101001b = 11111111b
-11111111b | 10101010b = 11111111b
-11111111b | 10101011b = 11111111b
-11111111b | 10101100b = 11111111b
-11111111b | 10101101b = 11111111b
-11111111b | 10101110b = 11111111b
-11111111b | 10101111b = 11111111b
-11111111b | 10110000b = 11111111b
-11111111b | 10110001b = 11111111b
-11111111b | 10110010b = 11111111b
-11111111b | 10110011b = 11111111b
-11111111b | 10110100b = 11111111b
-11111111b | 10110101b = 11111111b
-11111111b | 10110110b = 11111111b
-11111111b | 10110111b = 11111111b
-11111111b | 10111000b = 11111111b
-11111111b | 10111001b = 11111111b
-11111111b | 10111010b = 11111111b
-11111111b | 10111011b = 11111111b
-11111111b | 10111100b = 11111111b
-11111111b | 10111101b = 11111111b
-11111111b | 10111110b = 11111111b
-11111111b | 10111111b = 11111111b
-11111111b | 11000000b = 11111111b
-11111111b | 11000001b = 11111111b
-11111111b | 11000010b = 11111111b
-11111111b | 11000011b = 11111111b
-11111111b | 11000100b = 11111111b
-11111111b | 11000101b = 11111111b
-11111111b | 11000110b = 11111111b
-11111111b | 11000111b = 11111111b
-11111111b | 11001000b = 11111111b
-11111111b | 11001001b = 11111111b
-11111111b | 11001010b = 11111111b
-11111111b | 11001011b = 11111111b
-11111111b | 11001100b = 11111111b
-11111111b | 11001101b = 11111111b
-11111111b | 11001110b = 11111111b
-11111111b | 11001111b = 11111111b
-11111111b | 11010000b = 11111111b
-11111111b | 11010001b = 11111111b
-11111111b | 11010010b = 11111111b
-11111111b | 11010011b = 11111111b
-11111111b | 11010100b = 11111111b
-11111111b | 11010101b = 11111111b
-11111111b | 11010110b = 11111111b
-11111111b | 11010111b = 11111111b
-11111111b | 11011000b = 11111111b
-11111111b | 11011001b = 11111111b
-11111111b | 11011010b = 11111111b
-11111111b | 11011011b = 11111111b
-11111111b | 11011100b = 11111111b
-11111111b | 11011101b = 11111111b
-11111111b | 11011110b = 11111111b
-11111111b | 11011111b = 11111111b
-11111111b | 11100000b = 11111111b
-11111111b | 11100001b = 11111111b
-11111111b | 11100010b = 11111111b
-11111111b | 11100011b = 11111111b
-11111111b | 11100100b = 11111111b
-11111111b | 11100101b = 11111111b
-11111111b | 11100110b = 11111111b
-11111111b | 11100111b = 11111111b
-11111111b | 11101000b = 11111111b
-11111111b | 11101001b = 11111111b
-11111111b | 11101010b = 11111111b
-11111111b | 11101011b = 11111111b
-11111111b | 11101100b = 11111111b
-11111111b | 11101101b = 11111111b
-11111111b | 11101110b = 11111111b
-11111111b | 11101111b = 11111111b
-11111111b | 11110000b = 11111111b
-11111111b | 11110001b = 11111111b
-11111111b | 11110010b = 11111111b
-11111111b | 11110011b = 11111111b
-11111111b | 11110100b = 11111111b
-11111111b | 11110101b = 11111111b
-11111111b | 11110110b = 11111111b
-11111111b | 11110111b = 11111111b
-11111111b | 11111000b = 11111111b
-11111111b | 11111001b = 11111111b
-11111111b | 11111010b = 11111111b
-11111111b | 11111011b = 11111111b
-11111111b | 11111100b = 11111111b
-11111111b | 11111101b = 11111111b
-11111111b | 11111110b = 11111111b
-11111111b | 11111111b = 11111111b
-11111111b | 00000000b = 11111111b
-11111111b | 00000001b = 11111111b
-11111111b | 00000010b = 11111111b
-11111111b | 00000011b = 11111111b
-11111111b | 00000100b = 11111111b
-11111111b | 00000101b = 11111111b
-11111111b | 00000110b = 11111111b
-11111111b | 00000111b = 11111111b
-11111111b | 00001000b = 11111111b
-11111111b | 00001001b = 11111111b
-11111111b | 00001010b = 11111111b
-11111111b | 00001011b = 11111111b
-11111111b | 00001100b = 11111111b
-11111111b | 00001101b = 11111111b
-11111111b | 00001110b = 11111111b
-11111111b | 00001111b = 11111111b
-11111111b | 00010000b = 11111111b
-11111111b | 00010001b = 11111111b
-11111111b | 00010010b = 11111111b
-11111111b | 00010011b = 11111111b
-11111111b | 00010100b = 11111111b
-11111111b | 00010101b = 11111111b
-11111111b | 00010110b = 11111111b
-11111111b | 00010111b = 11111111b
-11111111b | 00011000b = 11111111b
-11111111b | 00011001b = 11111111b
-11111111b | 00011010b = 11111111b
-11111111b | 00011011b = 11111111b
-11111111b | 00011100b = 11111111b
-11111111b | 00011101b = 11111111b
-11111111b | 00011110b = 11111111b
-11111111b | 00011111b = 11111111b
-11111111b | 00100000b = 11111111b
-11111111b | 00100001b = 11111111b
-11111111b | 00100010b = 11111111b
-11111111b | 00100011b = 11111111b
-11111111b | 00100100b = 11111111b
-11111111b | 00100101b = 11111111b
-11111111b | 00100110b = 11111111b
-11111111b | 00100111b = 11111111b
-11111111b | 00101000b = 11111111b
-11111111b | 00101001b = 11111111b
-11111111b | 00101010b = 11111111b
-11111111b | 00101011b = 11111111b
-11111111b | 00101100b = 11111111b
-11111111b | 00101101b = 11111111b
-11111111b | 00101110b = 11111111b
-11111111b | 00101111b = 11111111b
-11111111b | 00110000b = 11111111b
-11111111b | 00110001b = 11111111b
-11111111b | 00110010b = 11111111b
-11111111b | 00110011b = 11111111b
-11111111b | 00110100b = 11111111b
-11111111b | 00110101b = 11111111b
-11111111b | 00110110b = 11111111b
-11111111b | 00110111b = 11111111b
-11111111b | 00111000b = 11111111b
-11111111b | 00111001b = 11111111b
-11111111b | 00111010b = 11111111b
-11111111b | 00111011b = 11111111b
-11111111b | 00111100b = 11111111b
-11111111b | 00111101b = 11111111b
-11111111b | 00111110b = 11111111b
-11111111b | 00111111b = 11111111b
-11111111b | 01000000b = 11111111b
-11111111b | 01000001b = 11111111b
-11111111b | 01000010b = 11111111b
-11111111b | 01000011b = 11111111b
-11111111b | 01000100b = 11111111b
-11111111b | 01000101b = 11111111b
-11111111b | 01000110b = 11111111b
-11111111b | 01000111b = 11111111b
-11111111b | 01001000b = 11111111b
-11111111b | 01001001b = 11111111b
-11111111b | 01001010b = 11111111b
-11111111b | 01001011b = 11111111b
-11111111b | 01001100b = 11111111b
-11111111b | 01001101b = 11111111b
-11111111b | 01001110b = 11111111b
-11111111b | 01001111b = 11111111b
-11111111b | 01010000b = 11111111b
-11111111b | 01010001b = 11111111b
-11111111b | 01010010b = 11111111b
-11111111b | 01010011b = 11111111b
-11111111b | 01010100b = 11111111b
-11111111b | 01010101b = 11111111b
-11111111b | 01010110b = 11111111b
-11111111b | 01010111b = 11111111b
-11111111b | 01011000b = 11111111b
-11111111b | 01011001b = 11111111b
-11111111b | 01011010b = 11111111b
-11111111b | 01011011b = 11111111b
-11111111b | 01011100b = 11111111b
-11111111b | 01011101b = 11111111b
-11111111b | 01011110b = 11111111b
-11111111b | 01011111b = 11111111b
-11111111b | 01100000b = 11111111b
-11111111b | 01100001b = 11111111b
-11111111b | 01100010b = 11111111b
-11111111b | 01100011b = 11111111b
-11111111b | 01100100b = 11111111b
-11111111b | 01100101b = 11111111b
-11111111b | 01100110b = 11111111b
-11111111b | 01100111b = 11111111b
-11111111b | 01101000b = 11111111b
-11111111b | 01101001b = 11111111b
-11111111b | 01101010b = 11111111b
-11111111b | 01101011b = 11111111b
-11111111b | 01101100b = 11111111b
-11111111b | 01101101b = 11111111b
-11111111b | 01101110b = 11111111b
-11111111b | 01101111b = 11111111b
-11111111b | 01110000b = 11111111b
-11111111b | 01110001b = 11111111b
-11111111b | 01110010b = 11111111b
-11111111b | 01110011b = 11111111b
-11111111b | 01110100b = 11111111b
-11111111b | 01110101b = 11111111b
-11111111b | 01110110b = 11111111b
-11111111b | 01110111b = 11111111b
-11111111b | 01111000b = 11111111b
-11111111b | 01111001b = 11111111b
-11111111b | 01111010b = 11111111b
-11111111b | 01111011b = 11111111b
-11111111b | 01111100b = 11111111b
-11111111b | 01111101b = 11111111b
-11111111b | 01111110b = 11111111b
-00000000b | 10000000b = 10000000b
-00000000b | 10000001b = 10000001b
-00000000b | 10000010b = 10000010b
-00000000b | 10000011b = 10000011b
-00000000b | 10000100b = 10000100b
-00000000b | 10000101b = 10000101b
-00000000b | 10000110b = 10000110b
-00000000b | 10000111b = 10000111b
-00000000b | 10001000b = 10001000b
-00000000b | 10001001b = 10001001b
-00000000b | 10001010b = 10001010b
-00000000b | 10001011b = 10001011b
-00000000b | 10001100b = 10001100b
-00000000b | 10001101b = 10001101b
-00000000b | 10001110b = 10001110b
-00000000b | 10001111b = 10001111b
-00000000b | 10010000b = 10010000b
-00000000b | 10010001b = 10010001b
-00000000b | 10010010b = 10010010b
-00000000b | 10010011b = 10010011b
-00000000b | 10010100b = 10010100b
-00000000b | 10010101b = 10010101b
-00000000b | 10010110b = 10010110b
-00000000b | 10010111b = 10010111b
-00000000b | 10011000b = 10011000b
-00000000b | 10011001b = 10011001b
-00000000b | 10011010b = 10011010b
-00000000b | 10011011b = 10011011b
-00000000b | 10011100b = 10011100b
-00000000b | 10011101b = 10011101b
-00000000b | 10011110b = 10011110b
-00000000b | 10011111b = 10011111b
-00000000b | 10100000b = 10100000b
-00000000b | 10100001b = 10100001b
-00000000b | 10100010b = 10100010b
-00000000b | 10100011b = 10100011b
-00000000b | 10100100b = 10100100b
-00000000b | 10100101b = 10100101b
-00000000b | 10100110b = 10100110b
-00000000b | 10100111b = 10100111b
-00000000b | 10101000b = 10101000b
-00000000b | 10101001b = 10101001b
-00000000b | 10101010b = 10101010b
-00000000b | 10101011b = 10101011b
-00000000b | 10101100b = 10101100b
-00000000b | 10101101b = 10101101b
-00000000b | 10101110b = 10101110b
-00000000b | 10101111b = 10101111b
-00000000b | 10110000b = 10110000b
-00000000b | 10110001b = 10110001b
-00000000b | 10110010b = 10110010b
-00000000b | 10110011b = 10110011b
-00000000b | 10110100b = 10110100b
-00000000b | 10110101b = 10110101b
-00000000b | 10110110b = 10110110b
-00000000b | 10110111b = 10110111b
-00000000b | 10111000b = 10111000b
-00000000b | 10111001b = 10111001b
-00000000b | 10111010b = 10111010b
-00000000b | 10111011b = 10111011b
-00000000b | 10111100b = 10111100b
-00000000b | 10111101b = 10111101b
-00000000b | 10111110b = 10111110b
-00000000b | 10111111b = 10111111b
-00000000b | 11000000b = 11000000b
-00000000b | 11000001b = 11000001b
-00000000b | 11000010b = 11000010b
-00000000b | 11000011b = 11000011b
-00000000b | 11000100b = 11000100b
-00000000b | 11000101b = 11000101b
-00000000b | 11000110b = 11000110b
-00000000b | 11000111b = 11000111b
-00000000b | 11001000b = 11001000b
-00000000b | 11001001b = 11001001b
-00000000b | 11001010b = 11001010b
-00000000b | 11001011b = 11001011b
-00000000b | 11001100b = 11001100b
-00000000b | 11001101b = 11001101b
-00000000b | 11001110b = 11001110b
-00000000b | 11001111b = 11001111b
-00000000b | 11010000b = 11010000b
-00000000b | 11010001b = 11010001b
-00000000b | 11010010b = 11010010b
-00000000b | 11010011b = 11010011b
-00000000b | 11010100b = 11010100b
-00000000b | 11010101b = 11010101b
-00000000b | 11010110b = 11010110b
-00000000b | 11010111b = 11010111b
-00000000b | 11011000b = 11011000b
-00000000b | 11011001b = 11011001b
-00000000b | 11011010b = 11011010b
-00000000b | 11011011b = 11011011b
-00000000b | 11011100b = 11011100b
-00000000b | 11011101b = 11011101b
-00000000b | 11011110b = 11011110b
-00000000b | 11011111b = 11011111b
-00000000b | 11100000b = 11100000b
-00000000b | 11100001b = 11100001b
-00000000b | 11100010b = 11100010b
-00000000b | 11100011b = 11100011b
-00000000b | 11100100b = 11100100b
-00000000b | 11100101b = 11100101b
-00000000b | 11100110b = 11100110b
-00000000b | 11100111b = 11100111b
-00000000b | 11101000b = 11101000b
-00000000b | 11101001b = 11101001b
-00000000b | 11101010b = 11101010b
-00000000b | 11101011b = 11101011b
-00000000b | 11101100b = 11101100b
-00000000b | 11101101b = 11101101b
-00000000b | 11101110b = 11101110b
-00000000b | 11101111b = 11101111b
-00000000b | 11110000b = 11110000b
-00000000b | 11110001b = 11110001b
-00000000b | 11110010b = 11110010b
-00000000b | 11110011b = 11110011b
-00000000b | 11110100b = 11110100b
-00000000b | 11110101b = 11110101b
-00000000b | 11110110b = 11110110b
-00000000b | 11110111b = 11110111b
-00000000b | 11111000b = 11111000b
-00000000b | 11111001b = 11111001b
-00000000b | 11111010b = 11111010b
-00000000b | 11111011b = 11111011b
-00000000b | 11111100b = 11111100b
-00000000b | 11111101b = 11111101b
-00000000b | 11111110b = 11111110b
-00000000b | 11111111b = 11111111b
-00000000b | 00000000b = 00000000b
-00000000b | 00000001b = 00000001b
-00000000b | 00000010b = 00000010b
-00000000b | 00000011b = 00000011b
-00000000b | 00000100b = 00000100b
-00000000b | 00000101b = 00000101b
-00000000b | 00000110b = 00000110b
-00000000b | 00000111b = 00000111b
-00000000b | 00001000b = 00001000b
-00000000b | 00001001b = 00001001b
-00000000b | 00001010b = 00001010b
-00000000b | 00001011b = 00001011b
-00000000b | 00001100b = 00001100b
-00000000b | 00001101b = 00001101b
-00000000b | 00001110b = 00001110b
-00000000b | 00001111b = 00001111b
-00000000b | 00010000b = 00010000b
-00000000b | 00010001b = 00010001b
-00000000b | 00010010b = 00010010b
-00000000b | 00010011b = 00010011b
-00000000b | 00010100b = 00010100b
-00000000b | 00010101b = 00010101b
-00000000b | 00010110b = 00010110b
-00000000b | 00010111b = 00010111b
-00000000b | 00011000b = 00011000b
-00000000b | 00011001b = 00011001b
-00000000b | 00011010b = 00011010b
-00000000b | 00011011b = 00011011b
-00000000b | 00011100b = 00011100b
-00000000b | 00011101b = 00011101b
-00000000b | 00011110b = 00011110b
-00000000b | 00011111b = 00011111b
-00000000b | 00100000b = 00100000b
-00000000b | 00100001b = 00100001b
-00000000b | 00100010b = 00100010b
-00000000b | 00100011b = 00100011b
-00000000b | 00100100b = 00100100b
-00000000b | 00100101b = 00100101b
-00000000b | 00100110b = 00100110b
-00000000b | 00100111b = 00100111b
-00000000b | 00101000b = 00101000b
-00000000b | 00101001b = 00101001b
-00000000b | 00101010b = 00101010b
-00000000b | 00101011b = 00101011b
-00000000b | 00101100b = 00101100b
-00000000b | 00101101b = 00101101b
-00000000b | 00101110b = 00101110b
-00000000b | 00101111b = 00101111b
-00000000b | 00110000b = 00110000b
-00000000b | 00110001b = 00110001b
-00000000b | 00110010b = 00110010b
-00000000b | 00110011b = 00110011b
-00000000b | 00110100b = 00110100b
-00000000b | 00110101b = 00110101b
-00000000b | 00110110b = 00110110b
-00000000b | 00110111b = 00110111b
-00000000b | 00111000b = 00111000b
-00000000b | 00111001b = 00111001b
-00000000b | 00111010b = 00111010b
-00000000b | 00111011b = 00111011b
-00000000b | 00111100b = 00111100b
-00000000b | 00111101b = 00111101b
-00000000b | 00111110b = 00111110b
-00000000b | 00111111b = 00111111b
-00000000b | 01000000b = 01000000b
-00000000b | 01000001b = 01000001b
-00000000b | 01000010b = 01000010b
-00000000b | 01000011b = 01000011b
-00000000b | 01000100b = 01000100b
-00000000b | 01000101b = 01000101b
-00000000b | 01000110b = 01000110b
-00000000b | 01000111b = 01000111b
-00000000b | 01001000b = 01001000b
-00000000b | 01001001b = 01001001b
-00000000b | 01001010b = 01001010b
-00000000b | 01001011b = 01001011b
-00000000b | 01001100b = 01001100b
-00000000b | 01001101b = 01001101b
-00000000b | 01001110b = 01001110b
-00000000b | 01001111b = 01001111b
-00000000b | 01010000b = 01010000b
-00000000b | 01010001b = 01010001b
-00000000b | 01010010b = 01010010b
-00000000b | 01010011b = 01010011b
-00000000b | 01010100b = 01010100b
-00000000b | 01010101b = 01010101b
-00000000b | 01010110b = 01010110b
-00000000b | 01010111b = 01010111b
-00000000b | 01011000b = 01011000b
-00000000b | 01011001b = 01011001b
-00000000b | 01011010b = 01011010b
-00000000b | 01011011b = 01011011b
-00000000b | 01011100b = 01011100b
-00000000b | 01011101b = 01011101b
-00000000b | 01011110b = 01011110b
-00000000b | 01011111b = 01011111b
-00000000b | 01100000b = 01100000b
-00000000b | 01100001b = 01100001b
-00000000b | 01100010b = 01100010b
-00000000b | 01100011b = 01100011b
-00000000b | 01100100b = 01100100b
-00000000b | 01100101b = 01100101b
-00000000b | 01100110b = 01100110b
-00000000b | 01100111b = 01100111b
-00000000b | 01101000b = 01101000b
-00000000b | 01101001b = 01101001b
-00000000b | 01101010b = 01101010b
-00000000b | 01101011b = 01101011b
-00000000b | 01101100b = 01101100b
-00000000b | 01101101b = 01101101b
-00000000b | 01101110b = 01101110b
-00000000b | 01101111b = 01101111b
-00000000b | 01110000b = 01110000b
-00000000b | 01110001b = 01110001b
-00000000b | 01110010b = 01110010b
-00000000b | 01110011b = 01110011b
-00000000b | 01110100b = 01110100b
-00000000b | 01110101b = 01110101b
-00000000b | 01110110b = 01110110b
-00000000b | 01110111b = 01110111b
-00000000b | 01111000b = 01111000b
-00000000b | 01111001b = 01111001b
-00000000b | 01111010b = 01111010b
-00000000b | 01111011b = 01111011b
-00000000b | 01111100b = 01111100b
-00000000b | 01111101b = 01111101b
-00000000b | 01111110b = 01111110b
-00000001b | 10000000b = 10000001b
-00000001b | 10000001b = 10000001b
-00000001b | 10000010b = 10000011b
-00000001b | 10000011b = 10000011b
-00000001b | 10000100b = 10000101b
-00000001b | 10000101b = 10000101b
-00000001b | 10000110b = 10000111b
-00000001b | 10000111b = 10000111b
-00000001b | 10001000b = 10001001b
-00000001b | 10001001b = 10001001b
-00000001b | 10001010b = 10001011b
-00000001b | 10001011b = 10001011b
-00000001b | 10001100b = 10001101b
-00000001b | 10001101b = 10001101b
-00000001b | 10001110b = 10001111b
-00000001b | 10001111b = 10001111b
-00000001b | 10010000b = 10010001b
-00000001b | 10010001b = 10010001b
-00000001b | 10010010b = 10010011b
-00000001b | 10010011b = 10010011b
-00000001b | 10010100b = 10010101b
-00000001b | 10010101b = 10010101b
-00000001b | 10010110b = 10010111b
-00000001b | 10010111b = 10010111b
-00000001b | 10011000b = 10011001b
-00000001b | 10011001b = 10011001b
-00000001b | 10011010b = 10011011b
-00000001b | 10011011b = 10011011b
-00000001b | 10011100b = 10011101b
-00000001b | 10011101b = 10011101b
-00000001b | 10011110b = 10011111b
-00000001b | 10011111b = 10011111b
-00000001b | 10100000b = 10100001b
-00000001b | 10100001b = 10100001b
-00000001b | 10100010b = 10100011b
-00000001b | 10100011b = 10100011b
-00000001b | 10100100b = 10100101b
-00000001b | 10100101b = 10100101b
-00000001b | 10100110b = 10100111b
-00000001b | 10100111b = 10100111b
-00000001b | 10101000b = 10101001b
-00000001b | 10101001b = 10101001b
-00000001b | 10101010b = 10101011b
-00000001b | 10101011b = 10101011b
-00000001b | 10101100b = 10101101b
-00000001b | 10101101b = 10101101b
-00000001b | 10101110b = 10101111b
-00000001b | 10101111b = 10101111b
-00000001b | 10110000b = 10110001b
-00000001b | 10110001b = 10110001b
-00000001b | 10110010b = 10110011b
-00000001b | 10110011b = 10110011b
-00000001b | 10110100b = 10110101b
-00000001b | 10110101b = 10110101b
-00000001b | 10110110b = 10110111b
-00000001b | 10110111b = 10110111b
-00000001b | 10111000b = 10111001b
-00000001b | 10111001b = 10111001b
-00000001b | 10111010b = 10111011b
-00000001b | 10111011b = 10111011b
-00000001b | 10111100b = 10111101b
-00000001b | 10111101b = 10111101b
-00000001b | 10111110b = 10111111b
-00000001b | 10111111b = 10111111b
-00000001b | 11000000b = 11000001b
-00000001b | 11000001b = 11000001b
-00000001b | 11000010b = 11000011b
-00000001b | 11000011b = 11000011b
-00000001b | 11000100b = 11000101b
-00000001b | 11000101b = 11000101b
-00000001b | 11000110b = 11000111b
-00000001b | 11000111b = 11000111b
-00000001b | 11001000b = 11001001b
-00000001b | 11001001b = 11001001b
-00000001b | 11001010b = 11001011b
-00000001b | 11001011b = 11001011b
-00000001b | 11001100b = 11001101b
-00000001b | 11001101b = 11001101b
-00000001b | 11001110b = 11001111b
-00000001b | 11001111b = 11001111b
-00000001b | 11010000b = 11010001b
-00000001b | 11010001b = 11010001b
-00000001b | 11010010b = 11010011b
-00000001b | 11010011b = 11010011b
-00000001b | 11010100b = 11010101b
-00000001b | 11010101b = 11010101b
-00000001b | 11010110b = 11010111b
-00000001b | 11010111b = 11010111b
-00000001b | 11011000b = 11011001b
-00000001b | 11011001b = 11011001b
-00000001b | 11011010b = 11011011b
-00000001b | 11011011b = 11011011b
-00000001b | 11011100b = 11011101b
-00000001b | 11011101b = 11011101b
-00000001b | 11011110b = 11011111b
-00000001b | 11011111b = 11011111b
-00000001b | 11100000b = 11100001b
-00000001b | 11100001b = 11100001b
-00000001b | 11100010b = 11100011b
-00000001b | 11100011b = 11100011b
-00000001b | 11100100b = 11100101b
-00000001b | 11100101b = 11100101b
-00000001b | 11100110b = 11100111b
-00000001b | 11100111b = 11100111b
-00000001b | 11101000b = 11101001b
-00000001b | 11101001b = 11101001b
-00000001b | 11101010b = 11101011b
-00000001b | 11101011b = 11101011b
-00000001b | 11101100b = 11101101b
-00000001b | 11101101b = 11101101b
-00000001b | 11101110b = 11101111b
-00000001b | 11101111b = 11101111b
-00000001b | 11110000b = 11110001b
-00000001b | 11110001b = 11110001b
-00000001b | 11110010b = 11110011b
-00000001b | 11110011b = 11110011b
-00000001b | 11110100b = 11110101b
-00000001b | 11110101b = 11110101b
-00000001b | 11110110b = 11110111b
-00000001b | 11110111b = 11110111b
-00000001b | 11111000b = 11111001b
-00000001b | 11111001b = 11111001b
-00000001b | 11111010b = 11111011b
-00000001b | 11111011b = 11111011b
-00000001b | 11111100b = 11111101b
-00000001b | 11111101b = 11111101b
-00000001b | 11111110b = 11111111b
-00000001b | 11111111b = 11111111b
-00000001b | 00000000b = 00000001b
-00000001b | 00000001b = 00000001b
-00000001b | 00000010b = 00000011b
-00000001b | 00000011b = 00000011b
-00000001b | 00000100b = 00000101b
-00000001b | 00000101b = 00000101b
-00000001b | 00000110b = 00000111b
-00000001b | 00000111b = 00000111b
-00000001b | 00001000b = 00001001b
-00000001b | 00001001b = 00001001b
-00000001b | 00001010b = 00001011b
-00000001b | 00001011b = 00001011b
-00000001b | 00001100b = 00001101b
-00000001b | 00001101b = 00001101b
-00000001b | 00001110b = 00001111b
-00000001b | 00001111b = 00001111b
-00000001b | 00010000b = 00010001b
-00000001b | 00010001b = 00010001b
-00000001b | 00010010b = 00010011b
-00000001b | 00010011b = 00010011b
-00000001b | 00010100b = 00010101b
-00000001b | 00010101b = 00010101b
-00000001b | 00010110b = 00010111b
-00000001b | 00010111b = 00010111b
-00000001b | 00011000b = 00011001b
-00000001b | 00011001b = 00011001b
-00000001b | 00011010b = 00011011b
-00000001b | 00011011b = 00011011b
-00000001b | 00011100b = 00011101b
-00000001b | 00011101b = 00011101b
-00000001b | 00011110b = 00011111b
-00000001b | 00011111b = 00011111b
-00000001b | 00100000b = 00100001b
-00000001b | 00100001b = 00100001b
-00000001b | 00100010b = 00100011b
-00000001b | 00100011b = 00100011b
-00000001b | 00100100b = 00100101b
-00000001b | 00100101b = 00100101b
-00000001b | 00100110b = 00100111b
-00000001b | 00100111b = 00100111b
-00000001b | 00101000b = 00101001b
-00000001b | 00101001b = 00101001b
-00000001b | 00101010b = 00101011b
-00000001b | 00101011b = 00101011b
-00000001b | 00101100b = 00101101b
-00000001b | 00101101b = 00101101b
-00000001b | 00101110b = 00101111b
-00000001b | 00101111b = 00101111b
-00000001b | 00110000b = 00110001b
-00000001b | 00110001b = 00110001b
-00000001b | 00110010b = 00110011b
-00000001b | 00110011b = 00110011b
-00000001b | 00110100b = 00110101b
-00000001b | 00110101b = 00110101b
-00000001b | 00110110b = 00110111b
-00000001b | 00110111b = 00110111b
-00000001b | 00111000b = 00111001b
-00000001b | 00111001b = 00111001b
-00000001b | 00111010b = 00111011b
-00000001b | 00111011b = 00111011b
-00000001b | 00111100b = 00111101b
-00000001b | 00111101b = 00111101b
-00000001b | 00111110b = 00111111b
-00000001b | 00111111b = 00111111b
-00000001b | 01000000b = 01000001b
-00000001b | 01000001b = 01000001b
-00000001b | 01000010b = 01000011b
-00000001b | 01000011b = 01000011b
-00000001b | 01000100b = 01000101b
-00000001b | 01000101b = 01000101b
-00000001b | 01000110b = 01000111b
-00000001b | 01000111b = 01000111b
-00000001b | 01001000b = 01001001b
-00000001b | 01001001b = 01001001b
-00000001b | 01001010b = 01001011b
-00000001b | 01001011b = 01001011b
-00000001b | 01001100b = 01001101b
-00000001b | 01001101b = 01001101b
-00000001b | 01001110b = 01001111b
-00000001b | 01001111b = 01001111b
-00000001b | 01010000b = 01010001b
-00000001b | 01010001b = 01010001b
-00000001b | 01010010b = 01010011b
-00000001b | 01010011b = 01010011b
-00000001b | 01010100b = 01010101b
-00000001b | 01010101b = 01010101b
-00000001b | 01010110b = 01010111b
-00000001b | 01010111b = 01010111b
-00000001b | 01011000b = 01011001b
-00000001b | 01011001b = 01011001b
-00000001b | 01011010b = 01011011b
-00000001b | 01011011b = 01011011b
-00000001b | 01011100b = 01011101b
-00000001b | 01011101b = 01011101b
-00000001b | 01011110b = 01011111b
-00000001b | 01011111b = 01011111b
-00000001b | 01100000b = 01100001b
-00000001b | 01100001b = 01100001b
-00000001b | 01100010b = 01100011b
-00000001b | 01100011b = 01100011b
-00000001b | 01100100b = 01100101b
-00000001b | 01100101b = 01100101b
-00000001b | 01100110b = 01100111b
-00000001b | 01100111b = 01100111b
-00000001b | 01101000b = 01101001b
-00000001b | 01101001b = 01101001b
-00000001b | 01101010b = 01101011b
-00000001b | 01101011b = 01101011b
-00000001b | 01101100b = 01101101b
-00000001b | 01101101b = 01101101b
-00000001b | 01101110b = 01101111b
-00000001b | 01101111b = 01101111b
-00000001b | 01110000b = 01110001b
-00000001b | 01110001b = 01110001b
-00000001b | 01110010b = 01110011b
-00000001b | 01110011b = 01110011b
-00000001b | 01110100b = 01110101b
-00000001b | 01110101b = 01110101b
-00000001b | 01110110b = 01110111b
-00000001b | 01110111b = 01110111b
-00000001b | 01111000b = 01111001b
-00000001b | 01111001b = 01111001b
-00000001b | 01111010b = 01111011b
-00000001b | 01111011b = 01111011b
-00000001b | 01111100b = 01111101b
-00000001b | 01111101b = 01111101b
-00000001b | 01111110b = 01111111b
-00000010b | 10000000b = 10000010b
-00000010b | 10000001b = 10000011b
-00000010b | 10000010b = 10000010b
-00000010b | 10000011b = 10000011b
-00000010b | 10000100b = 10000110b
-00000010b | 10000101b = 10000111b
-00000010b | 10000110b = 10000110b
-00000010b | 10000111b = 10000111b
-00000010b | 10001000b = 10001010b
-00000010b | 10001001b = 10001011b
-00000010b | 10001010b = 10001010b
-00000010b | 10001011b = 10001011b
-00000010b | 10001100b = 10001110b
-00000010b | 10001101b = 10001111b
-00000010b | 10001110b = 10001110b
-00000010b | 10001111b = 10001111b
-00000010b | 10010000b = 10010010b
-00000010b | 10010001b = 10010011b
-00000010b | 10010010b = 10010010b
-00000010b | 10010011b = 10010011b
-00000010b | 10010100b = 10010110b
-00000010b | 10010101b = 10010111b
-00000010b | 10010110b = 10010110b
-00000010b | 10010111b = 10010111b
-00000010b | 10011000b = 10011010b
-00000010b | 10011001b = 10011011b
-00000010b | 10011010b = 10011010b
-00000010b | 10011011b = 10011011b
-00000010b | 10011100b = 10011110b
-00000010b | 10011101b = 10011111b
-00000010b | 10011110b = 10011110b
-00000010b | 10011111b = 10011111b
-00000010b | 10100000b = 10100010b
-00000010b | 10100001b = 10100011b
-00000010b | 10100010b = 10100010b
-00000010b | 10100011b = 10100011b
-00000010b | 10100100b = 10100110b
-00000010b | 10100101b = 10100111b
-00000010b | 10100110b = 10100110b
-00000010b | 10100111b = 10100111b
-00000010b | 10101000b = 10101010b
-00000010b | 10101001b = 10101011b
-00000010b | 10101010b = 10101010b
-00000010b | 10101011b = 10101011b
-00000010b | 10101100b = 10101110b
-00000010b | 10101101b = 10101111b
-00000010b | 10101110b = 10101110b
-00000010b | 10101111b = 10101111b
-00000010b | 10110000b = 10110010b
-00000010b | 10110001b = 10110011b
-00000010b | 10110010b = 10110010b
-00000010b | 10110011b = 10110011b
-00000010b | 10110100b = 10110110b
-00000010b | 10110101b = 10110111b
-00000010b | 10110110b = 10110110b
-00000010b | 10110111b = 10110111b
-00000010b | 10111000b = 10111010b
-00000010b | 10111001b = 10111011b
-00000010b | 10111010b = 10111010b
-00000010b | 10111011b = 10111011b
-00000010b | 10111100b = 10111110b
-00000010b | 10111101b = 10111111b
-00000010b | 10111110b = 10111110b
-00000010b | 10111111b = 10111111b
-00000010b | 11000000b = 11000010b
-00000010b | 11000001b = 11000011b
-00000010b | 11000010b = 11000010b
-00000010b | 11000011b = 11000011b
-00000010b | 11000100b = 11000110b
-00000010b | 11000101b = 11000111b
-00000010b | 11000110b = 11000110b
-00000010b | 11000111b = 11000111b
-00000010b | 11001000b = 11001010b
-00000010b | 11001001b = 11001011b
-00000010b | 11001010b = 11001010b
-00000010b | 11001011b = 11001011b
-00000010b | 11001100b = 11001110b
-00000010b | 11001101b = 11001111b
-00000010b | 11001110b = 11001110b
-00000010b | 11001111b = 11001111b
-00000010b | 11010000b = 11010010b
-00000010b | 11010001b = 11010011b
-00000010b | 11010010b = 11010010b
-00000010b | 11010011b = 11010011b
-00000010b | 11010100b = 11010110b
-00000010b | 11010101b = 11010111b
-00000010b | 11010110b = 11010110b
-00000010b | 11010111b = 11010111b
-00000010b | 11011000b = 11011010b
-00000010b | 11011001b = 11011011b
-00000010b | 11011010b = 11011010b
-00000010b | 11011011b = 11011011b
-00000010b | 11011100b = 11011110b
-00000010b | 11011101b = 11011111b
-00000010b | 11011110b = 11011110b
-00000010b | 11011111b = 11011111b
-00000010b | 11100000b = 11100010b
-00000010b | 11100001b = 11100011b
-00000010b | 11100010b = 11100010b
-00000010b | 11100011b = 11100011b
-00000010b | 11100100b = 11100110b
-00000010b | 11100101b = 11100111b
-00000010b | 11100110b = 11100110b
-00000010b | 11100111b = 11100111b
-00000010b | 11101000b = 11101010b
-00000010b | 11101001b = 11101011b
-00000010b | 11101010b = 11101010b
-00000010b | 11101011b = 11101011b
-00000010b | 11101100b = 11101110b
-00000010b | 11101101b = 11101111b
-00000010b | 11101110b = 11101110b
-00000010b | 11101111b = 11101111b
-00000010b | 11110000b = 11110010b
-00000010b | 11110001b = 11110011b
-00000010b | 11110010b = 11110010b
-00000010b | 11110011b = 11110011b
-00000010b | 11110100b = 11110110b
-00000010b | 11110101b = 11110111b
-00000010b | 11110110b = 11110110b
-00000010b | 11110111b = 11110111b
-00000010b | 11111000b = 11111010b
-00000010b | 11111001b = 11111011b
-00000010b | 11111010b = 11111010b
-00000010b | 11111011b = 11111011b
-00000010b | 11111100b = 11111110b
-00000010b | 11111101b = 11111111b
-00000010b | 11111110b = 11111110b
-00000010b | 11111111b = 11111111b
-00000010b | 00000000b = 00000010b
-00000010b | 00000001b = 00000011b
-00000010b | 00000010b = 00000010b
-00000010b | 00000011b = 00000011b
-00000010b | 00000100b = 00000110b
-00000010b | 00000101b = 00000111b
-00000010b | 00000110b = 00000110b
-00000010b | 00000111b = 00000111b
-00000010b | 00001000b = 00001010b
-00000010b | 00001001b = 00001011b
-00000010b | 00001010b = 00001010b
-00000010b | 00001011b = 00001011b
-00000010b | 00001100b = 00001110b
-00000010b | 00001101b = 00001111b
-00000010b | 00001110b = 00001110b
-00000010b | 00001111b = 00001111b
-00000010b | 00010000b = 00010010b
-00000010b | 00010001b = 00010011b
-00000010b | 00010010b = 00010010b
-00000010b | 00010011b = 00010011b
-00000010b | 00010100b = 00010110b
-00000010b | 00010101b = 00010111b
-00000010b | 00010110b = 00010110b
-00000010b | 00010111b = 00010111b
-00000010b | 00011000b = 00011010b
-00000010b | 00011001b = 00011011b
-00000010b | 00011010b = 00011010b
-00000010b | 00011011b = 00011011b
-00000010b | 00011100b = 00011110b
-00000010b | 00011101b = 00011111b
-00000010b | 00011110b = 00011110b
-00000010b | 00011111b = 00011111b
-00000010b | 00100000b = 00100010b
-00000010b | 00100001b = 00100011b
-00000010b | 00100010b = 00100010b
-00000010b | 00100011b = 00100011b
-00000010b | 00100100b = 00100110b
-00000010b | 00100101b = 00100111b
-00000010b | 00100110b = 00100110b
-00000010b | 00100111b = 00100111b
-00000010b | 00101000b = 00101010b
-00000010b | 00101001b = 00101011b
-00000010b | 00101010b = 00101010b
-00000010b | 00101011b = 00101011b
-00000010b | 00101100b = 00101110b
-00000010b | 00101101b = 00101111b
-00000010b | 00101110b = 00101110b
-00000010b | 00101111b = 00101111b
-00000010b | 00110000b = 00110010b
-00000010b | 00110001b = 00110011b
-00000010b | 00110010b = 00110010b
-00000010b | 00110011b = 00110011b
-00000010b | 00110100b = 00110110b
-00000010b | 00110101b = 00110111b
-00000010b | 00110110b = 00110110b
-00000010b | 00110111b = 00110111b
-00000010b | 00111000b = 00111010b
-00000010b | 00111001b = 00111011b
-00000010b | 00111010b = 00111010b
-00000010b | 00111011b = 00111011b
-00000010b | 00111100b = 00111110b
-00000010b | 00111101b = 00111111b
-00000010b | 00111110b = 00111110b
-00000010b | 00111111b = 00111111b
-00000010b | 01000000b = 01000010b
-00000010b | 01000001b = 01000011b
-00000010b | 01000010b = 01000010b
-00000010b | 01000011b = 01000011b
-00000010b | 01000100b = 01000110b
-00000010b | 01000101b = 01000111b
-00000010b | 01000110b = 01000110b
-00000010b | 01000111b = 01000111b
-00000010b | 01001000b = 01001010b
-00000010b | 01001001b = 01001011b
-00000010b | 01001010b = 01001010b
-00000010b | 01001011b = 01001011b
-00000010b | 01001100b = 01001110b
-00000010b | 01001101b = 01001111b
-00000010b | 01001110b = 01001110b
-00000010b | 01001111b = 01001111b
-00000010b | 01010000b = 01010010b
-00000010b | 01010001b = 01010011b
-00000010b | 01010010b = 01010010b
-00000010b | 01010011b = 01010011b
-00000010b | 01010100b = 01010110b
-00000010b | 01010101b = 01010111b
-00000010b | 01010110b = 01010110b
-00000010b | 01010111b = 01010111b
-00000010b | 01011000b = 01011010b
-00000010b | 01011001b = 01011011b
-00000010b | 01011010b = 01011010b
-00000010b | 01011011b = 01011011b
-00000010b | 01011100b = 01011110b
-00000010b | 01011101b = 01011111b
-00000010b | 01011110b = 01011110b
-00000010b | 01011111b = 01011111b
-00000010b | 01100000b = 01100010b
-00000010b | 01100001b = 01100011b
-00000010b | 01100010b = 01100010b
-00000010b | 01100011b = 01100011b
-00000010b | 01100100b = 01100110b
-00000010b | 01100101b = 01100111b
-00000010b | 01100110b = 01100110b
-00000010b | 01100111b = 01100111b
-00000010b | 01101000b = 01101010b
-00000010b | 01101001b = 01101011b
-00000010b | 01101010b = 01101010b
-00000010b | 01101011b = 01101011b
-00000010b | 01101100b = 01101110b
-00000010b | 01101101b = 01101111b
-00000010b | 01101110b = 01101110b
-00000010b | 01101111b = 01101111b
-00000010b | 01110000b = 01110010b
-00000010b | 01110001b = 01110011b
-00000010b | 01110010b = 01110010b
-00000010b | 01110011b = 01110011b
-00000010b | 01110100b = 01110110b
-00000010b | 01110101b = 01110111b
-00000010b | 01110110b = 01110110b
-00000010b | 01110111b = 01110111b
-00000010b | 01111000b = 01111010b
-00000010b | 01111001b = 01111011b
-00000010b | 01111010b = 01111010b
-00000010b | 01111011b = 01111011b
-00000010b | 01111100b = 01111110b
-00000010b | 01111101b = 01111111b
-00000010b | 01111110b = 01111110b
-00000011b | 10000000b = 10000011b
-00000011b | 10000001b = 10000011b
-00000011b | 10000010b = 10000011b
-00000011b | 10000011b = 10000011b
-00000011b | 10000100b = 10000111b
-00000011b | 10000101b = 10000111b
-00000011b | 10000110b = 10000111b
-00000011b | 10000111b = 10000111b
-00000011b | 10001000b = 10001011b
-00000011b | 10001001b = 10001011b
-00000011b | 10001010b = 10001011b
-00000011b | 10001011b = 10001011b
-00000011b | 10001100b = 10001111b
-00000011b | 10001101b = 10001111b
-00000011b | 10001110b = 10001111b
-00000011b | 10001111b = 10001111b
-00000011b | 10010000b = 10010011b
-00000011b | 10010001b = 10010011b
-00000011b | 10010010b = 10010011b
-00000011b | 10010011b = 10010011b
-00000011b | 10010100b = 10010111b
-00000011b | 10010101b = 10010111b
-00000011b | 10010110b = 10010111b
-00000011b | 10010111b = 10010111b
-00000011b | 10011000b = 10011011b
-00000011b | 10011001b = 10011011b
-00000011b | 10011010b = 10011011b
-00000011b | 10011011b = 10011011b
-00000011b | 10011100b = 10011111b
-00000011b | 10011101b = 10011111b
-00000011b | 10011110b = 10011111b
-00000011b | 10011111b = 10011111b
-00000011b | 10100000b = 10100011b
-00000011b | 10100001b = 10100011b
-00000011b | 10100010b = 10100011b
-00000011b | 10100011b = 10100011b
-00000011b | 10100100b = 10100111b
-00000011b | 10100101b = 10100111b
-00000011b | 10100110b = 10100111b
-00000011b | 10100111b = 10100111b
-00000011b | 10101000b = 10101011b
-00000011b | 10101001b = 10101011b
-00000011b | 10101010b = 10101011b
-00000011b | 10101011b = 10101011b
-00000011b | 10101100b = 10101111b
-00000011b | 10101101b = 10101111b
-00000011b | 10101110b = 10101111b
-00000011b | 10101111b = 10101111b
-00000011b | 10110000b = 10110011b
-00000011b | 10110001b = 10110011b
-00000011b | 10110010b = 10110011b
-00000011b | 10110011b = 10110011b
-00000011b | 10110100b = 10110111b
-00000011b | 10110101b = 10110111b
-00000011b | 10110110b = 10110111b
-00000011b | 10110111b = 10110111b
-00000011b | 10111000b = 10111011b
-00000011b | 10111001b = 10111011b
-00000011b | 10111010b = 10111011b
-00000011b | 10111011b = 10111011b
-00000011b | 10111100b = 10111111b
-00000011b | 10111101b = 10111111b
-00000011b | 10111110b = 10111111b
-00000011b | 10111111b = 10111111b
-00000011b | 11000000b = 11000011b
-00000011b | 11000001b = 11000011b
-00000011b | 11000010b = 11000011b
-00000011b | 11000011b = 11000011b
-00000011b | 11000100b = 11000111b
-00000011b | 11000101b = 11000111b
-00000011b | 11000110b = 11000111b
-00000011b | 11000111b = 11000111b
-00000011b | 11001000b = 11001011b
-00000011b | 11001001b = 11001011b
-00000011b | 11001010b = 11001011b
-00000011b | 11001011b = 11001011b
-00000011b | 11001100b = 11001111b
-00000011b | 11001101b = 11001111b
-00000011b | 11001110b = 11001111b
-00000011b | 11001111b = 11001111b
-00000011b | 11010000b = 11010011b
-00000011b | 11010001b = 11010011b
-00000011b | 11010010b = 11010011b
-00000011b | 11010011b = 11010011b
-00000011b | 11010100b = 11010111b
-00000011b | 11010101b = 11010111b
-00000011b | 11010110b = 11010111b
-00000011b | 11010111b = 11010111b
-00000011b | 11011000b = 11011011b
-00000011b | 11011001b = 11011011b
-00000011b | 11011010b = 11011011b
-00000011b | 11011011b = 11011011b
-00000011b | 11011100b = 11011111b
-00000011b | 11011101b = 11011111b
-00000011b | 11011110b = 11011111b
-00000011b | 11011111b = 11011111b
-00000011b | 11100000b = 11100011b
-00000011b | 11100001b = 11100011b
-00000011b | 11100010b = 11100011b
-00000011b | 11100011b = 11100011b
-00000011b | 11100100b = 11100111b
-00000011b | 11100101b = 11100111b
-00000011b | 11100110b = 11100111b
-00000011b | 11100111b = 11100111b
-00000011b | 11101000b = 11101011b
-00000011b | 11101001b = 11101011b
-00000011b | 11101010b = 11101011b
-00000011b | 11101011b = 11101011b
-00000011b | 11101100b = 11101111b
-00000011b | 11101101b = 11101111b
-00000011b | 11101110b = 11101111b
-00000011b | 11101111b = 11101111b
-00000011b | 11110000b = 11110011b
-00000011b | 11110001b = 11110011b
-00000011b | 11110010b = 11110011b
-00000011b | 11110011b = 11110011b
-00000011b | 11110100b = 11110111b
-00000011b | 11110101b = 11110111b
-00000011b | 11110110b = 11110111b
-00000011b | 11110111b = 11110111b
-00000011b | 11111000b = 11111011b
-00000011b | 11111001b = 11111011b
-00000011b | 11111010b = 11111011b
-00000011b | 11111011b = 11111011b
-00000011b | 11111100b = 11111111b
-00000011b | 11111101b = 11111111b
-00000011b | 11111110b = 11111111b
-00000011b | 11111111b = 11111111b
-00000011b | 00000000b = 00000011b
-00000011b | 00000001b = 00000011b
-00000011b | 00000010b = 00000011b
-00000011b | 00000011b = 00000011b
-00000011b | 00000100b = 00000111b
-00000011b | 00000101b = 00000111b
-00000011b | 00000110b = 00000111b
-00000011b | 00000111b = 00000111b
-00000011b | 00001000b = 00001011b
-00000011b | 00001001b = 00001011b
-00000011b | 00001010b = 00001011b
-00000011b | 00001011b = 00001011b
-00000011b | 00001100b = 00001111b
-00000011b | 00001101b = 00001111b
-00000011b | 00001110b = 00001111b
-00000011b | 00001111b = 00001111b
-00000011b | 00010000b = 00010011b
-00000011b | 00010001b = 00010011b
-00000011b | 00010010b = 00010011b
-00000011b | 00010011b = 00010011b
-00000011b | 00010100b = 00010111b
-00000011b | 00010101b = 00010111b
-00000011b | 00010110b = 00010111b
-00000011b | 00010111b = 00010111b
-00000011b | 00011000b = 00011011b
-00000011b | 00011001b = 00011011b
-00000011b | 00011010b = 00011011b
-00000011b | 00011011b = 00011011b
-00000011b | 00011100b = 00011111b
-00000011b | 00011101b = 00011111b
-00000011b | 00011110b = 00011111b
-00000011b | 00011111b = 00011111b
-00000011b | 00100000b = 00100011b
-00000011b | 00100001b = 00100011b
-00000011b | 00100010b = 00100011b
-00000011b | 00100011b = 00100011b
-00000011b | 00100100b = 00100111b
-00000011b | 00100101b = 00100111b
-00000011b | 00100110b = 00100111b
-00000011b | 00100111b = 00100111b
-00000011b | 00101000b = 00101011b
-00000011b | 00101001b = 00101011b
-00000011b | 00101010b = 00101011b
-00000011b | 00101011b = 00101011b
-00000011b | 00101100b = 00101111b
-00000011b | 00101101b = 00101111b
-00000011b | 00101110b = 00101111b
-00000011b | 00101111b = 00101111b
-00000011b | 00110000b = 00110011b
-00000011b | 00110001b = 00110011b
-00000011b | 00110010b = 00110011b
-00000011b | 00110011b = 00110011b
-00000011b | 00110100b = 00110111b
-00000011b | 00110101b = 00110111b
-00000011b | 00110110b = 00110111b
-00000011b | 00110111b = 00110111b
-00000011b | 00111000b = 00111011b
-00000011b | 00111001b = 00111011b
-00000011b | 00111010b = 00111011b
-00000011b | 00111011b = 00111011b
-00000011b | 00111100b = 00111111b
-00000011b | 00111101b = 00111111b
-00000011b | 00111110b = 00111111b
-00000011b | 00111111b = 00111111b
-00000011b | 01000000b = 01000011b
-00000011b | 01000001b = 01000011b
-00000011b | 01000010b = 01000011b
-00000011b | 01000011b = 01000011b
-00000011b | 01000100b = 01000111b
-00000011b | 01000101b = 01000111b
-00000011b | 01000110b = 01000111b
-00000011b | 01000111b = 01000111b
-00000011b | 01001000b = 01001011b
-00000011b | 01001001b = 01001011b
-00000011b | 01001010b = 01001011b
-00000011b | 01001011b = 01001011b
-00000011b | 01001100b = 01001111b
-00000011b | 01001101b = 01001111b
-00000011b | 01001110b = 01001111b
-00000011b | 01001111b = 01001111b
-00000011b | 01010000b = 01010011b
-00000011b | 01010001b = 01010011b
-00000011b | 01010010b = 01010011b
-00000011b | 01010011b = 01010011b
-00000011b | 01010100b = 01010111b
-00000011b | 01010101b = 01010111b
-00000011b | 01010110b = 01010111b
-00000011b | 01010111b = 01010111b
-00000011b | 01011000b = 01011011b
-00000011b | 01011001b = 01011011b
-00000011b | 01011010b = 01011011b
-00000011b | 01011011b = 01011011b
-00000011b | 01011100b = 01011111b
-00000011b | 01011101b = 01011111b
-00000011b | 01011110b = 01011111b
-00000011b | 01011111b = 01011111b
-00000011b | 01100000b = 01100011b
-00000011b | 01100001b = 01100011b
-00000011b | 01100010b = 01100011b
-00000011b | 01100011b = 01100011b
-00000011b | 01100100b = 01100111b
-00000011b | 01100101b = 01100111b
-00000011b | 01100110b = 01100111b
-00000011b | 01100111b = 01100111b
-00000011b | 01101000b = 01101011b
-00000011b | 01101001b = 01101011b
-00000011b | 01101010b = 01101011b
-00000011b | 01101011b = 01101011b
-00000011b | 01101100b = 01101111b
-00000011b | 01101101b = 01101111b
-00000011b | 01101110b = 01101111b
-00000011b | 01101111b = 01101111b
-00000011b | 01110000b = 01110011b
-00000011b | 01110001b = 01110011b
-00000011b | 01110010b = 01110011b
-00000011b | 01110011b = 01110011b
-00000011b | 01110100b = 01110111b
-00000011b | 01110101b = 01110111b
-00000011b | 01110110b = 01110111b
-00000011b | 01110111b = 01110111b
-00000011b | 01111000b = 01111011b
-00000011b | 01111001b = 01111011b
-00000011b | 01111010b = 01111011b
-00000011b | 01111011b = 01111011b
-00000011b | 01111100b = 01111111b
-00000011b | 01111101b = 01111111b
-00000011b | 01111110b = 01111111b
-00000100b | 10000000b = 10000100b
-00000100b | 10000001b = 10000101b
-00000100b | 10000010b = 10000110b
-00000100b | 10000011b = 10000111b
-00000100b | 10000100b = 10000100b
-00000100b | 10000101b = 10000101b
-00000100b | 10000110b = 10000110b
-00000100b | 10000111b = 10000111b
-00000100b | 10001000b = 10001100b
-00000100b | 10001001b = 10001101b
-00000100b | 10001010b = 10001110b
-00000100b | 10001011b = 10001111b
-00000100b | 10001100b = 10001100b
-00000100b | 10001101b = 10001101b
-00000100b | 10001110b = 10001110b
-00000100b | 10001111b = 10001111b
-00000100b | 10010000b = 10010100b
-00000100b | 10010001b = 10010101b
-00000100b | 10010010b = 10010110b
-00000100b | 10010011b = 10010111b
-00000100b | 10010100b = 10010100b
-00000100b | 10010101b = 10010101b
-00000100b | 10010110b = 10010110b
-00000100b | 10010111b = 10010111b
-00000100b | 10011000b = 10011100b
-00000100b | 10011001b = 10011101b
-00000100b | 10011010b = 10011110b
-00000100b | 10011011b = 10011111b
-00000100b | 10011100b = 10011100b
-00000100b | 10011101b = 10011101b
-00000100b | 10011110b = 10011110b
-00000100b | 10011111b = 10011111b
-00000100b | 10100000b = 10100100b
-00000100b | 10100001b = 10100101b
-00000100b | 10100010b = 10100110b
-00000100b | 10100011b = 10100111b
-00000100b | 10100100b = 10100100b
-00000100b | 10100101b = 10100101b
-00000100b | 10100110b = 10100110b
-00000100b | 10100111b = 10100111b
-00000100b | 10101000b = 10101100b
-00000100b | 10101001b = 10101101b
-00000100b | 10101010b = 10101110b
-00000100b | 10101011b = 10101111b
-00000100b | 10101100b = 10101100b
-00000100b | 10101101b = 10101101b
-00000100b | 10101110b = 10101110b
-00000100b | 10101111b = 10101111b
-00000100b | 10110000b = 10110100b
-00000100b | 10110001b = 10110101b
-00000100b | 10110010b = 10110110b
-00000100b | 10110011b = 10110111b
-00000100b | 10110100b = 10110100b
-00000100b | 10110101b = 10110101b
-00000100b | 10110110b = 10110110b
-00000100b | 10110111b = 10110111b
-00000100b | 10111000b = 10111100b
-00000100b | 10111001b = 10111101b
-00000100b | 10111010b = 10111110b
-00000100b | 10111011b = 10111111b
-00000100b | 10111100b = 10111100b
-00000100b | 10111101b = 10111101b
-00000100b | 10111110b = 10111110b
-00000100b | 10111111b = 10111111b
-00000100b | 11000000b = 11000100b
-00000100b | 11000001b = 11000101b
-00000100b | 11000010b = 11000110b
-00000100b | 11000011b = 11000111b
-00000100b | 11000100b = 11000100b
-00000100b | 11000101b = 11000101b
-00000100b | 11000110b = 11000110b
-00000100b | 11000111b = 11000111b
-00000100b | 11001000b = 11001100b
-00000100b | 11001001b = 11001101b
-00000100b | 11001010b = 11001110b
-00000100b | 11001011b = 11001111b
-00000100b | 11001100b = 11001100b
-00000100b | 11001101b = 11001101b
-00000100b | 11001110b = 11001110b
-00000100b | 11001111b = 11001111b
-00000100b | 11010000b = 11010100b
-00000100b | 11010001b = 11010101b
-00000100b | 11010010b = 11010110b
-00000100b | 11010011b = 11010111b
-00000100b | 11010100b = 11010100b
-00000100b | 11010101b = 11010101b
-00000100b | 11010110b = 11010110b
-00000100b | 11010111b = 11010111b
-00000100b | 11011000b = 11011100b
-00000100b | 11011001b = 11011101b
-00000100b | 11011010b = 11011110b
-00000100b | 11011011b = 11011111b
-00000100b | 11011100b = 11011100b
-00000100b | 11011101b = 11011101b
-00000100b | 11011110b = 11011110b
-00000100b | 11011111b = 11011111b
-00000100b | 11100000b = 11100100b
-00000100b | 11100001b = 11100101b
-00000100b | 11100010b = 11100110b
-00000100b | 11100011b = 11100111b
-00000100b | 11100100b = 11100100b
-00000100b | 11100101b = 11100101b
-00000100b | 11100110b = 11100110b
-00000100b | 11100111b = 11100111b
-00000100b | 11101000b = 11101100b
-00000100b | 11101001b = 11101101b
-00000100b | 11101010b = 11101110b
-00000100b | 11101011b = 11101111b
-00000100b | 11101100b = 11101100b
-00000100b | 11101101b = 11101101b
-00000100b | 11101110b = 11101110b
-00000100b | 11101111b = 11101111b
-00000100b | 11110000b = 11110100b
-00000100b | 11110001b = 11110101b
-00000100b | 11110010b = 11110110b
-00000100b | 11110011b = 11110111b
-00000100b | 11110100b = 11110100b
-00000100b | 11110101b = 11110101b
-00000100b | 11110110b = 11110110b
-00000100b | 11110111b = 11110111b
-00000100b | 11111000b = 11111100b
-00000100b | 11111001b = 11111101b
-00000100b | 11111010b = 11111110b
-00000100b | 11111011b = 11111111b
-00000100b | 11111100b = 11111100b
-00000100b | 11111101b = 11111101b
-00000100b | 11111110b = 11111110b
-00000100b | 11111111b = 11111111b
-00000100b | 00000000b = 00000100b
-00000100b | 00000001b = 00000101b
-00000100b | 00000010b = 00000110b
-00000100b | 00000011b = 00000111b
-00000100b | 00000100b = 00000100b
-00000100b | 00000101b = 00000101b
-00000100b | 00000110b = 00000110b
-00000100b | 00000111b = 00000111b
-00000100b | 00001000b = 00001100b
-00000100b | 00001001b = 00001101b
-00000100b | 00001010b = 00001110b
-00000100b | 00001011b = 00001111b
-00000100b | 00001100b = 00001100b
-00000100b | 00001101b = 00001101b
-00000100b | 00001110b = 00001110b
-00000100b | 00001111b = 00001111b
-00000100b | 00010000b = 00010100b
-00000100b | 00010001b = 00010101b
-00000100b | 00010010b = 00010110b
-00000100b | 00010011b = 00010111b
-00000100b | 00010100b = 00010100b
-00000100b | 00010101b = 00010101b
-00000100b | 00010110b = 00010110b
-00000100b | 00010111b = 00010111b
-00000100b | 00011000b = 00011100b
-00000100b | 00011001b = 00011101b
-00000100b | 00011010b = 00011110b
-00000100b | 00011011b = 00011111b
-00000100b | 00011100b = 00011100b
-00000100b | 00011101b = 00011101b
-00000100b | 00011110b = 00011110b
-00000100b | 00011111b = 00011111b
-00000100b | 00100000b = 00100100b
-00000100b | 00100001b = 00100101b
-00000100b | 00100010b = 00100110b
-00000100b | 00100011b = 00100111b
-00000100b | 00100100b = 00100100b
-00000100b | 00100101b = 00100101b
-00000100b | 00100110b = 00100110b
-00000100b | 00100111b = 00100111b
-00000100b | 00101000b = 00101100b
-00000100b | 00101001b = 00101101b
-00000100b | 00101010b = 00101110b
-00000100b | 00101011b = 00101111b
-00000100b | 00101100b = 00101100b
-00000100b | 00101101b = 00101101b
-00000100b | 00101110b = 00101110b
-00000100b | 00101111b = 00101111b
-00000100b | 00110000b = 00110100b
-00000100b | 00110001b = 00110101b
-00000100b | 00110010b = 00110110b
-00000100b | 00110011b = 00110111b
-00000100b | 00110100b = 00110100b
-00000100b | 00110101b = 00110101b
-00000100b | 00110110b = 00110110b
-00000100b | 00110111b = 00110111b
-00000100b | 00111000b = 00111100b
-00000100b | 00111001b = 00111101b
-00000100b | 00111010b = 00111110b
-00000100b | 00111011b = 00111111b
-00000100b | 00111100b = 00111100b
-00000100b | 00111101b = 00111101b
-00000100b | 00111110b = 00111110b
-00000100b | 00111111b = 00111111b
-00000100b | 01000000b = 01000100b
-00000100b | 01000001b = 01000101b
-00000100b | 01000010b = 01000110b
-00000100b | 01000011b = 01000111b
-00000100b | 01000100b = 01000100b
-00000100b | 01000101b = 01000101b
-00000100b | 01000110b = 01000110b
-00000100b | 01000111b = 01000111b
-00000100b | 01001000b = 01001100b
-00000100b | 01001001b = 01001101b
-00000100b | 01001010b = 01001110b
-00000100b | 01001011b = 01001111b
-00000100b | 01001100b = 01001100b
-00000100b | 01001101b = 01001101b
-00000100b | 01001110b = 01001110b
-00000100b | 01001111b = 01001111b
-00000100b | 01010000b = 01010100b
-00000100b | 01010001b = 01010101b
-00000100b | 01010010b = 01010110b
-00000100b | 01010011b = 01010111b
-00000100b | 01010100b = 01010100b
-00000100b | 01010101b = 01010101b
-00000100b | 01010110b = 01010110b
-00000100b | 01010111b = 01010111b
-00000100b | 01011000b = 01011100b
-00000100b | 01011001b = 01011101b
-00000100b | 01011010b = 01011110b
-00000100b | 01011011b = 01011111b
-00000100b | 01011100b = 01011100b
-00000100b | 01011101b = 01011101b
-00000100b | 01011110b = 01011110b
-00000100b | 01011111b = 01011111b
-00000100b | 01100000b = 01100100b
-00000100b | 01100001b = 01100101b
-00000100b | 01100010b = 01100110b
-00000100b | 01100011b = 01100111b
-00000100b | 01100100b = 01100100b
-00000100b | 01100101b = 01100101b
-00000100b | 01100110b = 01100110b
-00000100b | 01100111b = 01100111b
-00000100b | 01101000b = 01101100b
-00000100b | 01101001b = 01101101b
-00000100b | 01101010b = 01101110b
-00000100b | 01101011b = 01101111b
-00000100b | 01101100b = 01101100b
-00000100b | 01101101b = 01101101b
-00000100b | 01101110b = 01101110b
-00000100b | 01101111b = 01101111b
-00000100b | 01110000b = 01110100b
-00000100b | 01110001b = 01110101b
-00000100b | 01110010b = 01110110b
-00000100b | 01110011b = 01110111b
-00000100b | 01110100b = 01110100b
-00000100b | 01110101b = 01110101b
-00000100b | 01110110b = 01110110b
-00000100b | 01110111b = 01110111b
-00000100b | 01111000b = 01111100b
-00000100b | 01111001b = 01111101b
-00000100b | 01111010b = 01111110b
-00000100b | 01111011b = 01111111b
-00000100b | 01111100b = 01111100b
-00000100b | 01111101b = 01111101b
-00000100b | 01111110b = 01111110b
-00000101b | 10000000b = 10000101b
-00000101b | 10000001b = 10000101b
-00000101b | 10000010b = 10000111b
-00000101b | 10000011b = 10000111b
-00000101b | 10000100b = 10000101b
-00000101b | 10000101b = 10000101b
-00000101b | 10000110b = 10000111b
-00000101b | 10000111b = 10000111b
-00000101b | 10001000b = 10001101b
-00000101b | 10001001b = 10001101b
-00000101b | 10001010b = 10001111b
-00000101b | 10001011b = 10001111b
-00000101b | 10001100b = 10001101b
-00000101b | 10001101b = 10001101b
-00000101b | 10001110b = 10001111b
-00000101b | 10001111b = 10001111b
-00000101b | 10010000b = 10010101b
-00000101b | 10010001b = 10010101b
-00000101b | 10010010b = 10010111b
-00000101b | 10010011b = 10010111b
-00000101b | 10010100b = 10010101b
-00000101b | 10010101b = 10010101b
-00000101b | 10010110b = 10010111b
-00000101b | 10010111b = 10010111b
-00000101b | 10011000b = 10011101b
-00000101b | 10011001b = 10011101b
-00000101b | 10011010b = 10011111b
-00000101b | 10011011b = 10011111b
-00000101b | 10011100b = 10011101b
-00000101b | 10011101b = 10011101b
-00000101b | 10011110b = 10011111b
-00000101b | 10011111b = 10011111b
-00000101b | 10100000b = 10100101b
-00000101b | 10100001b = 10100101b
-00000101b | 10100010b = 10100111b
-00000101b | 10100011b = 10100111b
-00000101b | 10100100b = 10100101b
-00000101b | 10100101b = 10100101b
-00000101b | 10100110b = 10100111b
-00000101b | 10100111b = 10100111b
-00000101b | 10101000b = 10101101b
-00000101b | 10101001b = 10101101b
-00000101b | 10101010b = 10101111b
-00000101b | 10101011b = 10101111b
-00000101b | 10101100b = 10101101b
-00000101b | 10101101b = 10101101b
-00000101b | 10101110b = 10101111b
-00000101b | 10101111b = 10101111b
-00000101b | 10110000b = 10110101b
-00000101b | 10110001b = 10110101b
-00000101b | 10110010b = 10110111b
-00000101b | 10110011b = 10110111b
-00000101b | 10110100b = 10110101b
-00000101b | 10110101b = 10110101b
-00000101b | 10110110b = 10110111b
-00000101b | 10110111b = 10110111b
-00000101b | 10111000b = 10111101b
-00000101b | 10111001b = 10111101b
-00000101b | 10111010b = 10111111b
-00000101b | 10111011b = 10111111b
-00000101b | 10111100b = 10111101b
-00000101b | 10111101b = 10111101b
-00000101b | 10111110b = 10111111b
-00000101b | 10111111b = 10111111b
-00000101b | 11000000b = 11000101b
-00000101b | 11000001b = 11000101b
-00000101b | 11000010b = 11000111b
-00000101b | 11000011b = 11000111b
-00000101b | 11000100b = 11000101b
-00000101b | 11000101b = 11000101b
-00000101b | 11000110b = 11000111b
-00000101b | 11000111b = 11000111b
-00000101b | 11001000b = 11001101b
-00000101b | 11001001b = 11001101b
-00000101b | 11001010b = 11001111b
-00000101b | 11001011b = 11001111b
-00000101b | 11001100b = 11001101b
-00000101b | 11001101b = 11001101b
-00000101b | 11001110b = 11001111b
-00000101b | 11001111b = 11001111b
-00000101b | 11010000b = 11010101b
-00000101b | 11010001b = 11010101b
-00000101b | 11010010b = 11010111b
-00000101b | 11010011b = 11010111b
-00000101b | 11010100b = 11010101b
-00000101b | 11010101b = 11010101b
-00000101b | 11010110b = 11010111b
-00000101b | 11010111b = 11010111b
-00000101b | 11011000b = 11011101b
-00000101b | 11011001b = 11011101b
-00000101b | 11011010b = 11011111b
-00000101b | 11011011b = 11011111b
-00000101b | 11011100b = 11011101b
-00000101b | 11011101b = 11011101b
-00000101b | 11011110b = 11011111b
-00000101b | 11011111b = 11011111b
-00000101b | 11100000b = 11100101b
-00000101b | 11100001b = 11100101b
-00000101b | 11100010b = 11100111b
-00000101b | 11100011b = 11100111b
-00000101b | 11100100b = 11100101b
-00000101b | 11100101b = 11100101b
-00000101b | 11100110b = 11100111b
-00000101b | 11100111b = 11100111b
-00000101b | 11101000b = 11101101b
-00000101b | 11101001b = 11101101b
-00000101b | 11101010b = 11101111b
-00000101b | 11101011b = 11101111b
-00000101b | 11101100b = 11101101b
-00000101b | 11101101b = 11101101b
-00000101b | 11101110b = 11101111b
-00000101b | 11101111b = 11101111b
-00000101b | 11110000b = 11110101b
-00000101b | 11110001b = 11110101b
-00000101b | 11110010b = 11110111b
-00000101b | 11110011b = 11110111b
-00000101b | 11110100b = 11110101b
-00000101b | 11110101b = 11110101b
-00000101b | 11110110b = 11110111b
-00000101b | 11110111b = 11110111b
-00000101b | 11111000b = 11111101b
-00000101b | 11111001b = 11111101b
-00000101b | 11111010b = 11111111b
-00000101b | 11111011b = 11111111b
-00000101b | 11111100b = 11111101b
-00000101b | 11111101b = 11111101b
-00000101b | 11111110b = 11111111b
-00000101b | 11111111b = 11111111b
-00000101b | 00000000b = 00000101b
-00000101b | 00000001b = 00000101b
-00000101b | 00000010b = 00000111b
-00000101b | 00000011b = 00000111b
-00000101b | 00000100b = 00000101b
-00000101b | 00000101b = 00000101b
-00000101b | 00000110b = 00000111b
-00000101b | 00000111b = 00000111b
-00000101b | 00001000b = 00001101b
-00000101b | 00001001b = 00001101b
-00000101b | 00001010b = 00001111b
-00000101b | 00001011b = 00001111b
-00000101b | 00001100b = 00001101b
-00000101b | 00001101b = 00001101b
-00000101b | 00001110b = 00001111b
-00000101b | 00001111b = 00001111b
-00000101b | 00010000b = 00010101b
-00000101b | 00010001b = 00010101b
-00000101b | 00010010b = 00010111b
-00000101b | 00010011b = 00010111b
-00000101b | 00010100b = 00010101b
-00000101b | 00010101b = 00010101b
-00000101b | 00010110b = 00010111b
-00000101b | 00010111b = 00010111b
-00000101b | 00011000b = 00011101b
-00000101b | 00011001b = 00011101b
-00000101b | 00011010b = 00011111b
-00000101b | 00011011b = 00011111b
-00000101b | 00011100b = 00011101b
-00000101b | 00011101b = 00011101b
-00000101b | 00011110b = 00011111b
-00000101b | 00011111b = 00011111b
-00000101b | 00100000b = 00100101b
-00000101b | 00100001b = 00100101b
-00000101b | 00100010b = 00100111b
-00000101b | 00100011b = 00100111b
-00000101b | 00100100b = 00100101b
-00000101b | 00100101b = 00100101b
-00000101b | 00100110b = 00100111b
-00000101b | 00100111b = 00100111b
-00000101b | 00101000b = 00101101b
-00000101b | 00101001b = 00101101b
-00000101b | 00101010b = 00101111b
-00000101b | 00101011b = 00101111b
-00000101b | 00101100b = 00101101b
-00000101b | 00101101b = 00101101b
-00000101b | 00101110b = 00101111b
-00000101b | 00101111b = 00101111b
-00000101b | 00110000b = 00110101b
-00000101b | 00110001b = 00110101b
-00000101b | 00110010b = 00110111b
-00000101b | 00110011b = 00110111b
-00000101b | 00110100b = 00110101b
-00000101b | 00110101b = 00110101b
-00000101b | 00110110b = 00110111b
-00000101b | 00110111b = 00110111b
-00000101b | 00111000b = 00111101b
-00000101b | 00111001b = 00111101b
-00000101b | 00111010b = 00111111b
-00000101b | 00111011b = 00111111b
-00000101b | 00111100b = 00111101b
-00000101b | 00111101b = 00111101b
-00000101b | 00111110b = 00111111b
-00000101b | 00111111b = 00111111b
-00000101b | 01000000b = 01000101b
-00000101b | 01000001b = 01000101b
-00000101b | 01000010b = 01000111b
-00000101b | 01000011b = 01000111b
-00000101b | 01000100b = 01000101b
-00000101b | 01000101b = 01000101b
-00000101b | 01000110b = 01000111b
-00000101b | 01000111b = 01000111b
-00000101b | 01001000b = 01001101b
-00000101b | 01001001b = 01001101b
-00000101b | 01001010b = 01001111b
-00000101b | 01001011b = 01001111b
-00000101b | 01001100b = 01001101b
-00000101b | 01001101b = 01001101b
-00000101b | 01001110b = 01001111b
-00000101b | 01001111b = 01001111b
-00000101b | 01010000b = 01010101b
-00000101b | 01010001b = 01010101b
-00000101b | 01010010b = 01010111b
-00000101b | 01010011b = 01010111b
-00000101b | 01010100b = 01010101b
-00000101b | 01010101b = 01010101b
-00000101b | 01010110b = 01010111b
-00000101b | 01010111b = 01010111b
-00000101b | 01011000b = 01011101b
-00000101b | 01011001b = 01011101b
-00000101b | 01011010b = 01011111b
-00000101b | 01011011b = 01011111b
-00000101b | 01011100b = 01011101b
-00000101b | 01011101b = 01011101b
-00000101b | 01011110b = 01011111b
-00000101b | 01011111b = 01011111b
-00000101b | 01100000b = 01100101b
-00000101b | 01100001b = 01100101b
-00000101b | 01100010b = 01100111b
-00000101b | 01100011b = 01100111b
-00000101b | 01100100b = 01100101b
-00000101b | 01100101b = 01100101b
-00000101b | 01100110b = 01100111b
-00000101b | 01100111b = 01100111b
-00000101b | 01101000b = 01101101b
-00000101b | 01101001b = 01101101b
-00000101b | 01101010b = 01101111b
-00000101b | 01101011b = 01101111b
-00000101b | 01101100b = 01101101b
-00000101b | 01101101b = 01101101b
-00000101b | 01101110b = 01101111b
-00000101b | 01101111b = 01101111b
-00000101b | 01110000b = 01110101b
-00000101b | 01110001b = 01110101b
-00000101b | 01110010b = 01110111b
-00000101b | 01110011b = 01110111b
-00000101b | 01110100b = 01110101b
-00000101b | 01110101b = 01110101b
-00000101b | 01110110b = 01110111b
-00000101b | 01110111b = 01110111b
-00000101b | 01111000b = 01111101b
-00000101b | 01111001b = 01111101b
-00000101b | 01111010b = 01111111b
-00000101b | 01111011b = 01111111b
-00000101b | 01111100b = 01111101b
-00000101b | 01111101b = 01111101b
-00000101b | 01111110b = 01111111b
-00000110b | 10000000b = 10000110b
-00000110b | 10000001b = 10000111b
-00000110b | 10000010b = 10000110b
-00000110b | 10000011b = 10000111b
-00000110b | 10000100b = 10000110b
-00000110b | 10000101b = 10000111b
-00000110b | 10000110b = 10000110b
-00000110b | 10000111b = 10000111b
-00000110b | 10001000b = 10001110b
-00000110b | 10001001b = 10001111b
-00000110b | 10001010b = 10001110b
-00000110b | 10001011b = 10001111b
-00000110b | 10001100b = 10001110b
-00000110b | 10001101b = 10001111b
-00000110b | 10001110b = 10001110b
-00000110b | 10001111b = 10001111b
-00000110b | 10010000b = 10010110b
-00000110b | 10010001b = 10010111b
-00000110b | 10010010b = 10010110b
-00000110b | 10010011b = 10010111b
-00000110b | 10010100b = 10010110b
-00000110b | 10010101b = 10010111b
-00000110b | 10010110b = 10010110b
-00000110b | 10010111b = 10010111b
-00000110b | 10011000b = 10011110b
-00000110b | 10011001b = 10011111b
-00000110b | 10011010b = 10011110b
-00000110b | 10011011b = 10011111b
-00000110b | 10011100b = 10011110b
-00000110b | 10011101b = 10011111b
-00000110b | 10011110b = 10011110b
-00000110b | 10011111b = 10011111b
-00000110b | 10100000b = 10100110b
-00000110b | 10100001b = 10100111b
-00000110b | 10100010b = 10100110b
-00000110b | 10100011b = 10100111b
-00000110b | 10100100b = 10100110b
-00000110b | 10100101b = 10100111b
-00000110b | 10100110b = 10100110b
-00000110b | 10100111b = 10100111b
-00000110b | 10101000b = 10101110b
-00000110b | 10101001b = 10101111b
-00000110b | 10101010b = 10101110b
-00000110b | 10101011b = 10101111b
-00000110b | 10101100b = 10101110b
-00000110b | 10101101b = 10101111b
-00000110b | 10101110b = 10101110b
-00000110b | 10101111b = 10101111b
-00000110b | 10110000b = 10110110b
-00000110b | 10110001b = 10110111b
-00000110b | 10110010b = 10110110b
-00000110b | 10110011b = 10110111b
-00000110b | 10110100b = 10110110b
-00000110b | 10110101b = 10110111b
-00000110b | 10110110b = 10110110b
-00000110b | 10110111b = 10110111b
-00000110b | 10111000b = 10111110b
-00000110b | 10111001b = 10111111b
-00000110b | 10111010b = 10111110b
-00000110b | 10111011b = 10111111b
-00000110b | 10111100b = 10111110b
-00000110b | 10111101b = 10111111b
-00000110b | 10111110b = 10111110b
-00000110b | 10111111b = 10111111b
-00000110b | 11000000b = 11000110b
-00000110b | 11000001b = 11000111b
-00000110b | 11000010b = 11000110b
-00000110b | 11000011b = 11000111b
-00000110b | 11000100b = 11000110b
-00000110b | 11000101b = 11000111b
-00000110b | 11000110b = 11000110b
-00000110b | 11000111b = 11000111b
-00000110b | 11001000b = 11001110b
-00000110b | 11001001b = 11001111b
-00000110b | 11001010b = 11001110b
-00000110b | 11001011b = 11001111b
-00000110b | 11001100b = 11001110b
-00000110b | 11001101b = 11001111b
-00000110b | 11001110b = 11001110b
-00000110b | 11001111b = 11001111b
-00000110b | 11010000b = 11010110b
-00000110b | 11010001b = 11010111b
-00000110b | 11010010b = 11010110b
-00000110b | 11010011b = 11010111b
-00000110b | 11010100b = 11010110b
-00000110b | 11010101b = 11010111b
-00000110b | 11010110b = 11010110b
-00000110b | 11010111b = 11010111b
-00000110b | 11011000b = 11011110b
-00000110b | 11011001b = 11011111b
-00000110b | 11011010b = 11011110b
-00000110b | 11011011b = 11011111b
-00000110b | 11011100b = 11011110b
-00000110b | 11011101b = 11011111b
-00000110b | 11011110b = 11011110b
-00000110b | 11011111b = 11011111b
-00000110b | 11100000b = 11100110b
-00000110b | 11100001b = 11100111b
-00000110b | 11100010b = 11100110b
-00000110b | 11100011b = 11100111b
-00000110b | 11100100b = 11100110b
-00000110b | 11100101b = 11100111b
-00000110b | 11100110b = 11100110b
-00000110b | 11100111b = 11100111b
-00000110b | 11101000b = 11101110b
-00000110b | 11101001b = 11101111b
-00000110b | 11101010b = 11101110b
-00000110b | 11101011b = 11101111b
-00000110b | 11101100b = 11101110b
-00000110b | 11101101b = 11101111b
-00000110b | 11101110b = 11101110b
-00000110b | 11101111b = 11101111b
-00000110b | 11110000b = 11110110b
-00000110b | 11110001b = 11110111b
-00000110b | 11110010b = 11110110b
-00000110b | 11110011b = 11110111b
-00000110b | 11110100b = 11110110b
-00000110b | 11110101b = 11110111b
-00000110b | 11110110b = 11110110b
-00000110b | 11110111b = 11110111b
-00000110b | 11111000b = 11111110b
-00000110b | 11111001b = 11111111b
-00000110b | 11111010b = 11111110b
-00000110b | 11111011b = 11111111b
-00000110b | 11111100b = 11111110b
-00000110b | 11111101b = 11111111b
-00000110b | 11111110b = 11111110b
-00000110b | 11111111b = 11111111b
-00000110b | 00000000b = 00000110b
-00000110b | 00000001b = 00000111b
-00000110b | 00000010b = 00000110b
-00000110b | 00000011b = 00000111b
-00000110b | 00000100b = 00000110b
-00000110b | 00000101b = 00000111b
-00000110b | 00000110b = 00000110b
-00000110b | 00000111b = 00000111b
-00000110b | 00001000b = 00001110b
-00000110b | 00001001b = 00001111b
-00000110b | 00001010b = 00001110b
-00000110b | 00001011b = 00001111b
-00000110b | 00001100b = 00001110b
-00000110b | 00001101b = 00001111b
-00000110b | 00001110b = 00001110b
-00000110b | 00001111b = 00001111b
-00000110b | 00010000b = 00010110b
-00000110b | 00010001b = 00010111b
-00000110b | 00010010b = 00010110b
-00000110b | 00010011b = 00010111b
-00000110b | 00010100b = 00010110b
-00000110b | 00010101b = 00010111b
-00000110b | 00010110b = 00010110b
-00000110b | 00010111b = 00010111b
-00000110b | 00011000b = 00011110b
-00000110b | 00011001b = 00011111b
-00000110b | 00011010b = 00011110b
-00000110b | 00011011b = 00011111b
-00000110b | 00011100b = 00011110b
-00000110b | 00011101b = 00011111b
-00000110b | 00011110b = 00011110b
-00000110b | 00011111b = 00011111b
-00000110b | 00100000b = 00100110b
-00000110b | 00100001b = 00100111b
-00000110b | 00100010b = 00100110b
-00000110b | 00100011b = 00100111b
-00000110b | 00100100b = 00100110b
-00000110b | 00100101b = 00100111b
-00000110b | 00100110b = 00100110b
-00000110b | 00100111b = 00100111b
-00000110b | 00101000b = 00101110b
-00000110b | 00101001b = 00101111b
-00000110b | 00101010b = 00101110b
-00000110b | 00101011b = 00101111b
-00000110b | 00101100b = 00101110b
-00000110b | 00101101b = 00101111b
-00000110b | 00101110b = 00101110b
-00000110b | 00101111b = 00101111b
-00000110b | 00110000b = 00110110b
-00000110b | 00110001b = 00110111b
-00000110b | 00110010b = 00110110b
-00000110b | 00110011b = 00110111b
-00000110b | 00110100b = 00110110b
-00000110b | 00110101b = 00110111b
-00000110b | 00110110b = 00110110b
-00000110b | 00110111b = 00110111b
-00000110b | 00111000b = 00111110b
-00000110b | 00111001b = 00111111b
-00000110b | 00111010b = 00111110b
-00000110b | 00111011b = 00111111b
-00000110b | 00111100b = 00111110b
-00000110b | 00111101b = 00111111b
-00000110b | 00111110b = 00111110b
-00000110b | 00111111b = 00111111b
-00000110b | 01000000b = 01000110b
-00000110b | 01000001b = 01000111b
-00000110b | 01000010b = 01000110b
-00000110b | 01000011b = 01000111b
-00000110b | 01000100b = 01000110b
-00000110b | 01000101b = 01000111b
-00000110b | 01000110b = 01000110b
-00000110b | 01000111b = 01000111b
-00000110b | 01001000b = 01001110b
-00000110b | 01001001b = 01001111b
-00000110b | 01001010b = 01001110b
-00000110b | 01001011b = 01001111b
-00000110b | 01001100b = 01001110b
-00000110b | 01001101b = 01001111b
-00000110b | 01001110b = 01001110b
-00000110b | 01001111b = 01001111b
-00000110b | 01010000b = 01010110b
-00000110b | 01010001b = 01010111b
-00000110b | 01010010b = 01010110b
-00000110b | 01010011b = 01010111b
-00000110b | 01010100b = 01010110b
-00000110b | 01010101b = 01010111b
-00000110b | 01010110b = 01010110b
-00000110b | 01010111b = 01010111b
-00000110b | 01011000b = 01011110b
-00000110b | 01011001b = 01011111b
-00000110b | 01011010b = 01011110b
-00000110b | 01011011b = 01011111b
-00000110b | 01011100b = 01011110b
-00000110b | 01011101b = 01011111b
-00000110b | 01011110b = 01011110b
-00000110b | 01011111b = 01011111b
-00000110b | 01100000b = 01100110b
-00000110b | 01100001b = 01100111b
-00000110b | 01100010b = 01100110b
-00000110b | 01100011b = 01100111b
-00000110b | 01100100b = 01100110b
-00000110b | 01100101b = 01100111b
-00000110b | 01100110b = 01100110b
-00000110b | 01100111b = 01100111b
-00000110b | 01101000b = 01101110b
-00000110b | 01101001b = 01101111b
-00000110b | 01101010b = 01101110b
-00000110b | 01101011b = 01101111b
-00000110b | 01101100b = 01101110b
-00000110b | 01101101b = 01101111b
-00000110b | 01101110b = 01101110b
-00000110b | 01101111b = 01101111b
-00000110b | 01110000b = 01110110b
-00000110b | 01110001b = 01110111b
-00000110b | 01110010b = 01110110b
-00000110b | 01110011b = 01110111b
-00000110b | 01110100b = 01110110b
-00000110b | 01110101b = 01110111b
-00000110b | 01110110b = 01110110b
-00000110b | 01110111b = 01110111b
-00000110b | 01111000b = 01111110b
-00000110b | 01111001b = 01111111b
-00000110b | 01111010b = 01111110b
-00000110b | 01111011b = 01111111b
-00000110b | 01111100b = 01111110b
-00000110b | 01111101b = 01111111b
-00000110b | 01111110b = 01111110b
-00000111b | 10000000b = 10000111b
-00000111b | 10000001b = 10000111b
-00000111b | 10000010b = 10000111b
-00000111b | 10000011b = 10000111b
-00000111b | 10000100b = 10000111b
-00000111b | 10000101b = 10000111b
-00000111b | 10000110b = 10000111b
-00000111b | 10000111b = 10000111b
-00000111b | 10001000b = 10001111b
-00000111b | 10001001b = 10001111b
-00000111b | 10001010b = 10001111b
-00000111b | 10001011b = 10001111b
-00000111b | 10001100b = 10001111b
-00000111b | 10001101b = 10001111b
-00000111b | 10001110b = 10001111b
-00000111b | 10001111b = 10001111b
-00000111b | 10010000b = 10010111b
-00000111b | 10010001b = 10010111b
-00000111b | 10010010b = 10010111b
-00000111b | 10010011b = 10010111b
-00000111b | 10010100b = 10010111b
-00000111b | 10010101b = 10010111b
-00000111b | 10010110b = 10010111b
-00000111b | 10010111b = 10010111b
-00000111b | 10011000b = 10011111b
-00000111b | 10011001b = 10011111b
-00000111b | 10011010b = 10011111b
-00000111b | 10011011b = 10011111b
-00000111b | 10011100b = 10011111b
-00000111b | 10011101b = 10011111b
-00000111b | 10011110b = 10011111b
-00000111b | 10011111b = 10011111b
-00000111b | 10100000b = 10100111b
-00000111b | 10100001b = 10100111b
-00000111b | 10100010b = 10100111b
-00000111b | 10100011b = 10100111b
-00000111b | 10100100b = 10100111b
-00000111b | 10100101b = 10100111b
-00000111b | 10100110b = 10100111b
-00000111b | 10100111b = 10100111b
-00000111b | 10101000b = 10101111b
-00000111b | 10101001b = 10101111b
-00000111b | 10101010b = 10101111b
-00000111b | 10101011b = 10101111b
-00000111b | 10101100b = 10101111b
-00000111b | 10101101b = 10101111b
-00000111b | 10101110b = 10101111b
-00000111b | 10101111b = 10101111b
-00000111b | 10110000b = 10110111b
-00000111b | 10110001b = 10110111b
-00000111b | 10110010b = 10110111b
-00000111b | 10110011b = 10110111b
-00000111b | 10110100b = 10110111b
-00000111b | 10110101b = 10110111b
-00000111b | 10110110b = 10110111b
-00000111b | 10110111b = 10110111b
-00000111b | 10111000b = 10111111b
-00000111b | 10111001b = 10111111b
-00000111b | 10111010b = 10111111b
-00000111b | 10111011b = 10111111b
-00000111b | 10111100b = 10111111b
-00000111b | 10111101b = 10111111b
-00000111b | 10111110b = 10111111b
-00000111b | 10111111b = 10111111b
-00000111b | 11000000b = 11000111b
-00000111b | 11000001b = 11000111b
-00000111b | 11000010b = 11000111b
-00000111b | 11000011b = 11000111b
-00000111b | 11000100b = 11000111b
-00000111b | 11000101b = 11000111b
-00000111b | 11000110b = 11000111b
-00000111b | 11000111b = 11000111b
-00000111b | 11001000b = 11001111b
-00000111b | 11001001b = 11001111b
-00000111b | 11001010b = 11001111b
-00000111b | 11001011b = 11001111b
-00000111b | 11001100b = 11001111b
-00000111b | 11001101b = 11001111b
-00000111b | 11001110b = 11001111b
-00000111b | 11001111b = 11001111b
-00000111b | 11010000b = 11010111b
-00000111b | 11010001b = 11010111b
-00000111b | 11010010b = 11010111b
-00000111b | 11010011b = 11010111b
-00000111b | 11010100b = 11010111b
-00000111b | 11010101b = 11010111b
-00000111b | 11010110b = 11010111b
-00000111b | 11010111b = 11010111b
-00000111b | 11011000b = 11011111b
-00000111b | 11011001b = 11011111b
-00000111b | 11011010b = 11011111b
-00000111b | 11011011b = 11011111b
-00000111b | 11011100b = 11011111b
-00000111b | 11011101b = 11011111b
-00000111b | 11011110b = 11011111b
-00000111b | 11011111b = 11011111b
-00000111b | 11100000b = 11100111b
-00000111b | 11100001b = 11100111b
-00000111b | 11100010b = 11100111b
-00000111b | 11100011b = 11100111b
-00000111b | 11100100b = 11100111b
-00000111b | 11100101b = 11100111b
-00000111b | 11100110b = 11100111b
-00000111b | 11100111b = 11100111b
-00000111b | 11101000b = 11101111b
-00000111b | 11101001b = 11101111b
-00000111b | 11101010b = 11101111b
-00000111b | 11101011b = 11101111b
-00000111b | 11101100b = 11101111b
-00000111b | 11101101b = 11101111b
-00000111b | 11101110b = 11101111b
-00000111b | 11101111b = 11101111b
-00000111b | 11110000b = 11110111b
-00000111b | 11110001b = 11110111b
-00000111b | 11110010b = 11110111b
-00000111b | 11110011b = 11110111b
-00000111b | 11110100b = 11110111b
-00000111b | 11110101b = 11110111b
-00000111b | 11110110b = 11110111b
-00000111b | 11110111b = 11110111b
-00000111b | 11111000b = 11111111b
-00000111b | 11111001b = 11111111b
-00000111b | 11111010b = 11111111b
-00000111b | 11111011b = 11111111b
-00000111b | 11111100b = 11111111b
-00000111b | 11111101b = 11111111b
-00000111b | 11111110b = 11111111b
-00000111b | 11111111b = 11111111b
-00000111b | 00000000b = 00000111b
-00000111b | 00000001b = 00000111b
-00000111b | 00000010b = 00000111b
-00000111b | 00000011b = 00000111b
-00000111b | 00000100b = 00000111b
-00000111b | 00000101b = 00000111b
-00000111b | 00000110b = 00000111b
-00000111b | 00000111b = 00000111b
-00000111b | 00001000b = 00001111b
-00000111b | 00001001b = 00001111b
-00000111b | 00001010b = 00001111b
-00000111b | 00001011b = 00001111b
-00000111b | 00001100b = 00001111b
-00000111b | 00001101b = 00001111b
-00000111b | 00001110b = 00001111b
-00000111b | 00001111b = 00001111b
-00000111b | 00010000b = 00010111b
-00000111b | 00010001b = 00010111b
-00000111b | 00010010b = 00010111b
-00000111b | 00010011b = 00010111b
-00000111b | 00010100b = 00010111b
-00000111b | 00010101b = 00010111b
-00000111b | 00010110b = 00010111b
-00000111b | 00010111b = 00010111b
-00000111b | 00011000b = 00011111b
-00000111b | 00011001b = 00011111b
-00000111b | 00011010b = 00011111b
-00000111b | 00011011b = 00011111b
-00000111b | 00011100b = 00011111b
-00000111b | 00011101b = 00011111b
-00000111b | 00011110b = 00011111b
-00000111b | 00011111b = 00011111b
-00000111b | 00100000b = 00100111b
-00000111b | 00100001b = 00100111b
-00000111b | 00100010b = 00100111b
-00000111b | 00100011b = 00100111b
-00000111b | 00100100b = 00100111b
-00000111b | 00100101b = 00100111b
-00000111b | 00100110b = 00100111b
-00000111b | 00100111b = 00100111b
-00000111b | 00101000b = 00101111b
-00000111b | 00101001b = 00101111b
-00000111b | 00101010b = 00101111b
-00000111b | 00101011b = 00101111b
-00000111b | 00101100b = 00101111b
-00000111b | 00101101b = 00101111b
-00000111b | 00101110b = 00101111b
-00000111b | 00101111b = 00101111b
-00000111b | 00110000b = 00110111b
-00000111b | 00110001b = 00110111b
-00000111b | 00110010b = 00110111b
-00000111b | 00110011b = 00110111b
-00000111b | 00110100b = 00110111b
-00000111b | 00110101b = 00110111b
-00000111b | 00110110b = 00110111b
-00000111b | 00110111b = 00110111b
-00000111b | 00111000b = 00111111b
-00000111b | 00111001b = 00111111b
-00000111b | 00111010b = 00111111b
-00000111b | 00111011b = 00111111b
-00000111b | 00111100b = 00111111b
-00000111b | 00111101b = 00111111b
-00000111b | 00111110b = 00111111b
-00000111b | 00111111b = 00111111b
-00000111b | 01000000b = 01000111b
-00000111b | 01000001b = 01000111b
-00000111b | 01000010b = 01000111b
-00000111b | 01000011b = 01000111b
-00000111b | 01000100b = 01000111b
-00000111b | 01000101b = 01000111b
-00000111b | 01000110b = 01000111b
-00000111b | 01000111b = 01000111b
-00000111b | 01001000b = 01001111b
-00000111b | 01001001b = 01001111b
-00000111b | 01001010b = 01001111b
-00000111b | 01001011b = 01001111b
-00000111b | 01001100b = 01001111b
-00000111b | 01001101b = 01001111b
-00000111b | 01001110b = 01001111b
-00000111b | 01001111b = 01001111b
-00000111b | 01010000b = 01010111b
-00000111b | 01010001b = 01010111b
-00000111b | 01010010b = 01010111b
-00000111b | 01010011b = 01010111b
-00000111b | 01010100b = 01010111b
-00000111b | 01010101b = 01010111b
-00000111b | 01010110b = 01010111b
-00000111b | 01010111b = 01010111b
-00000111b | 01011000b = 01011111b
-00000111b | 01011001b = 01011111b
-00000111b | 01011010b = 01011111b
-00000111b | 01011011b = 01011111b
-00000111b | 01011100b = 01011111b
-00000111b | 01011101b = 01011111b
-00000111b | 01011110b = 01011111b
-00000111b | 01011111b = 01011111b
-00000111b | 01100000b = 01100111b
-00000111b | 01100001b = 01100111b
-00000111b | 01100010b = 01100111b
-00000111b | 01100011b = 01100111b
-00000111b | 01100100b = 01100111b
-00000111b | 01100101b = 01100111b
-00000111b | 01100110b = 01100111b
-00000111b | 01100111b = 01100111b
-00000111b | 01101000b = 01101111b
-00000111b | 01101001b = 01101111b
-00000111b | 01101010b = 01101111b
-00000111b | 01101011b = 01101111b
-00000111b | 01101100b = 01101111b
-00000111b | 01101101b = 01101111b
-00000111b | 01101110b = 01101111b
-00000111b | 01101111b = 01101111b
-00000111b | 01110000b = 01110111b
-00000111b | 01110001b = 01110111b
-00000111b | 01110010b = 01110111b
-00000111b | 01110011b = 01110111b
-00000111b | 01110100b = 01110111b
-00000111b | 01110101b = 01110111b
-00000111b | 01110110b = 01110111b
-00000111b | 01110111b = 01110111b
-00000111b | 01111000b = 01111111b
-00000111b | 01111001b = 01111111b
-00000111b | 01111010b = 01111111b
-00000111b | 01111011b = 01111111b
-00000111b | 01111100b = 01111111b
-00000111b | 01111101b = 01111111b
-00000111b | 01111110b = 01111111b
-00001000b | 10000000b = 10001000b
-00001000b | 10000001b = 10001001b
-00001000b | 10000010b = 10001010b
-00001000b | 10000011b = 10001011b
-00001000b | 10000100b = 10001100b
-00001000b | 10000101b = 10001101b
-00001000b | 10000110b = 10001110b
-00001000b | 10000111b = 10001111b
-00001000b | 10001000b = 10001000b
-00001000b | 10001001b = 10001001b
-00001000b | 10001010b = 10001010b
-00001000b | 10001011b = 10001011b
-00001000b | 10001100b = 10001100b
-00001000b | 10001101b = 10001101b
-00001000b | 10001110b = 10001110b
-00001000b | 10001111b = 10001111b
-00001000b | 10010000b = 10011000b
-00001000b | 10010001b = 10011001b
-00001000b | 10010010b = 10011010b
-00001000b | 10010011b = 10011011b
-00001000b | 10010100b = 10011100b
-00001000b | 10010101b = 10011101b
-00001000b | 10010110b = 10011110b
-00001000b | 10010111b = 10011111b
-00001000b | 10011000b = 10011000b
-00001000b | 10011001b = 10011001b
-00001000b | 10011010b = 10011010b
-00001000b | 10011011b = 10011011b
-00001000b | 10011100b = 10011100b
-00001000b | 10011101b = 10011101b
-00001000b | 10011110b = 10011110b
-00001000b | 10011111b = 10011111b
-00001000b | 10100000b = 10101000b
-00001000b | 10100001b = 10101001b
-00001000b | 10100010b = 10101010b
-00001000b | 10100011b = 10101011b
-00001000b | 10100100b = 10101100b
-00001000b | 10100101b = 10101101b
-00001000b | 10100110b = 10101110b
-00001000b | 10100111b = 10101111b
-00001000b | 10101000b = 10101000b
-00001000b | 10101001b = 10101001b
-00001000b | 10101010b = 10101010b
-00001000b | 10101011b = 10101011b
-00001000b | 10101100b = 10101100b
-00001000b | 10101101b = 10101101b
-00001000b | 10101110b = 10101110b
-00001000b | 10101111b = 10101111b
-00001000b | 10110000b = 10111000b
-00001000b | 10110001b = 10111001b
-00001000b | 10110010b = 10111010b
-00001000b | 10110011b = 10111011b
-00001000b | 10110100b = 10111100b
-00001000b | 10110101b = 10111101b
-00001000b | 10110110b = 10111110b
-00001000b | 10110111b = 10111111b
-00001000b | 10111000b = 10111000b
-00001000b | 10111001b = 10111001b
-00001000b | 10111010b = 10111010b
-00001000b | 10111011b = 10111011b
-00001000b | 10111100b = 10111100b
-00001000b | 10111101b = 10111101b
-00001000b | 10111110b = 10111110b
-00001000b | 10111111b = 10111111b
-00001000b | 11000000b = 11001000b
-00001000b | 11000001b = 11001001b
-00001000b | 11000010b = 11001010b
-00001000b | 11000011b = 11001011b
-00001000b | 11000100b = 11001100b
-00001000b | 11000101b = 11001101b
-00001000b | 11000110b = 11001110b
-00001000b | 11000111b = 11001111b
-00001000b | 11001000b = 11001000b
-00001000b | 11001001b = 11001001b
-00001000b | 11001010b = 11001010b
-00001000b | 11001011b = 11001011b
-00001000b | 11001100b = 11001100b
-00001000b | 11001101b = 11001101b
-00001000b | 11001110b = 11001110b
-00001000b | 11001111b = 11001111b
-00001000b | 11010000b = 11011000b
-00001000b | 11010001b = 11011001b
-00001000b | 11010010b = 11011010b
-00001000b | 11010011b = 11011011b
-00001000b | 11010100b = 11011100b
-00001000b | 11010101b = 11011101b
-00001000b | 11010110b = 11011110b
-00001000b | 11010111b = 11011111b
-00001000b | 11011000b = 11011000b
-00001000b | 11011001b = 11011001b
-00001000b | 11011010b = 11011010b
-00001000b | 11011011b = 11011011b
-00001000b | 11011100b = 11011100b
-00001000b | 11011101b = 11011101b
-00001000b | 11011110b = 11011110b
-00001000b | 11011111b = 11011111b
-00001000b | 11100000b = 11101000b
-00001000b | 11100001b = 11101001b
-00001000b | 11100010b = 11101010b
-00001000b | 11100011b = 11101011b
-00001000b | 11100100b = 11101100b
-00001000b | 11100101b = 11101101b
-00001000b | 11100110b = 11101110b
-00001000b | 11100111b = 11101111b
-00001000b | 11101000b = 11101000b
-00001000b | 11101001b = 11101001b
-00001000b | 11101010b = 11101010b
-00001000b | 11101011b = 11101011b
-00001000b | 11101100b = 11101100b
-00001000b | 11101101b = 11101101b
-00001000b | 11101110b = 11101110b
-00001000b | 11101111b = 11101111b
-00001000b | 11110000b = 11111000b
-00001000b | 11110001b = 11111001b
-00001000b | 11110010b = 11111010b
-00001000b | 11110011b = 11111011b
-00001000b | 11110100b = 11111100b
-00001000b | 11110101b = 11111101b
-00001000b | 11110110b = 11111110b
-00001000b | 11110111b = 11111111b
-00001000b | 11111000b = 11111000b
-00001000b | 11111001b = 11111001b
-00001000b | 11111010b = 11111010b
-00001000b | 11111011b = 11111011b
-00001000b | 11111100b = 11111100b
-00001000b | 11111101b = 11111101b
-00001000b | 11111110b = 11111110b
-00001000b | 11111111b = 11111111b
-00001000b | 00000000b = 00001000b
-00001000b | 00000001b = 00001001b
-00001000b | 00000010b = 00001010b
-00001000b | 00000011b = 00001011b
-00001000b | 00000100b = 00001100b
-00001000b | 00000101b = 00001101b
-00001000b | 00000110b = 00001110b
-00001000b | 00000111b = 00001111b
-00001000b | 00001000b = 00001000b
-00001000b | 00001001b = 00001001b
-00001000b | 00001010b = 00001010b
-00001000b | 00001011b = 00001011b
-00001000b | 00001100b = 00001100b
-00001000b | 00001101b = 00001101b
-00001000b | 00001110b = 00001110b
-00001000b | 00001111b = 00001111b
-00001000b | 00010000b = 00011000b
-00001000b | 00010001b = 00011001b
-00001000b | 00010010b = 00011010b
-00001000b | 00010011b = 00011011b
-00001000b | 00010100b = 00011100b
-00001000b | 00010101b = 00011101b
-00001000b | 00010110b = 00011110b
-00001000b | 00010111b = 00011111b
-00001000b | 00011000b = 00011000b
-00001000b | 00011001b = 00011001b
-00001000b | 00011010b = 00011010b
-00001000b | 00011011b = 00011011b
-00001000b | 00011100b = 00011100b
-00001000b | 00011101b = 00011101b
-00001000b | 00011110b = 00011110b
-00001000b | 00011111b = 00011111b
-00001000b | 00100000b = 00101000b
-00001000b | 00100001b = 00101001b
-00001000b | 00100010b = 00101010b
-00001000b | 00100011b = 00101011b
-00001000b | 00100100b = 00101100b
-00001000b | 00100101b = 00101101b
-00001000b | 00100110b = 00101110b
-00001000b | 00100111b = 00101111b
-00001000b | 00101000b = 00101000b
-00001000b | 00101001b = 00101001b
-00001000b | 00101010b = 00101010b
-00001000b | 00101011b = 00101011b
-00001000b | 00101100b = 00101100b
-00001000b | 00101101b = 00101101b
-00001000b | 00101110b = 00101110b
-00001000b | 00101111b = 00101111b
-00001000b | 00110000b = 00111000b
-00001000b | 00110001b = 00111001b
-00001000b | 00110010b = 00111010b
-00001000b | 00110011b = 00111011b
-00001000b | 00110100b = 00111100b
-00001000b | 00110101b = 00111101b
-00001000b | 00110110b = 00111110b
-00001000b | 00110111b = 00111111b
-00001000b | 00111000b = 00111000b
-00001000b | 00111001b = 00111001b
-00001000b | 00111010b = 00111010b
-00001000b | 00111011b = 00111011b
-00001000b | 00111100b = 00111100b
-00001000b | 00111101b = 00111101b
-00001000b | 00111110b = 00111110b
-00001000b | 00111111b = 00111111b
-00001000b | 01000000b = 01001000b
-00001000b | 01000001b = 01001001b
-00001000b | 01000010b = 01001010b
-00001000b | 01000011b = 01001011b
-00001000b | 01000100b = 01001100b
-00001000b | 01000101b = 01001101b
-00001000b | 01000110b = 01001110b
-00001000b | 01000111b = 01001111b
-00001000b | 01001000b = 01001000b
-00001000b | 01001001b = 01001001b
-00001000b | 01001010b = 01001010b
-00001000b | 01001011b = 01001011b
-00001000b | 01001100b = 01001100b
-00001000b | 01001101b = 01001101b
-00001000b | 01001110b = 01001110b
-00001000b | 01001111b = 01001111b
-00001000b | 01010000b = 01011000b
-00001000b | 01010001b = 01011001b
-00001000b | 01010010b = 01011010b
-00001000b | 01010011b = 01011011b
-00001000b | 01010100b = 01011100b
-00001000b | 01010101b = 01011101b
-00001000b | 01010110b = 01011110b
-00001000b | 01010111b = 01011111b
-00001000b | 01011000b = 01011000b
-00001000b | 01011001b = 01011001b
-00001000b | 01011010b = 01011010b
-00001000b | 01011011b = 01011011b
-00001000b | 01011100b = 01011100b
-00001000b | 01011101b = 01011101b
-00001000b | 01011110b = 01011110b
-00001000b | 01011111b = 01011111b
-00001000b | 01100000b = 01101000b
-00001000b | 01100001b = 01101001b
-00001000b | 01100010b = 01101010b
-00001000b | 01100011b = 01101011b
-00001000b | 01100100b = 01101100b
-00001000b | 01100101b = 01101101b
-00001000b | 01100110b = 01101110b
-00001000b | 01100111b = 01101111b
-00001000b | 01101000b = 01101000b
-00001000b | 01101001b = 01101001b
-00001000b | 01101010b = 01101010b
-00001000b | 01101011b = 01101011b
-00001000b | 01101100b = 01101100b
-00001000b | 01101101b = 01101101b
-00001000b | 01101110b = 01101110b
-00001000b | 01101111b = 01101111b
-00001000b | 01110000b = 01111000b
-00001000b | 01110001b = 01111001b
-00001000b | 01110010b = 01111010b
-00001000b | 01110011b = 01111011b
-00001000b | 01110100b = 01111100b
-00001000b | 01110101b = 01111101b
-00001000b | 01110110b = 01111110b
-00001000b | 01110111b = 01111111b
-00001000b | 01111000b = 01111000b
-00001000b | 01111001b = 01111001b
-00001000b | 01111010b = 01111010b
-00001000b | 01111011b = 01111011b
-00001000b | 01111100b = 01111100b
-00001000b | 01111101b = 01111101b
-00001000b | 01111110b = 01111110b
-00001001b | 10000000b = 10001001b
-00001001b | 10000001b = 10001001b
-00001001b | 10000010b = 10001011b
-00001001b | 10000011b = 10001011b
-00001001b | 10000100b = 10001101b
-00001001b | 10000101b = 10001101b
-00001001b | 10000110b = 10001111b
-00001001b | 10000111b = 10001111b
-00001001b | 10001000b = 10001001b
-00001001b | 10001001b = 10001001b
-00001001b | 10001010b = 10001011b
-00001001b | 10001011b = 10001011b
-00001001b | 10001100b = 10001101b
-00001001b | 10001101b = 10001101b
-00001001b | 10001110b = 10001111b
-00001001b | 10001111b = 10001111b
-00001001b | 10010000b = 10011001b
-00001001b | 10010001b = 10011001b
-00001001b | 10010010b = 10011011b
-00001001b | 10010011b = 10011011b
-00001001b | 10010100b = 10011101b
-00001001b | 10010101b = 10011101b
-00001001b | 10010110b = 10011111b
-00001001b | 10010111b = 10011111b
-00001001b | 10011000b = 10011001b
-00001001b | 10011001b = 10011001b
-00001001b | 10011010b = 10011011b
-00001001b | 10011011b = 10011011b
-00001001b | 10011100b = 10011101b
-00001001b | 10011101b = 10011101b
-00001001b | 10011110b = 10011111b
-00001001b | 10011111b = 10011111b
-00001001b | 10100000b = 10101001b
-00001001b | 10100001b = 10101001b
-00001001b | 10100010b = 10101011b
-00001001b | 10100011b = 10101011b
-00001001b | 10100100b = 10101101b
-00001001b | 10100101b = 10101101b
-00001001b | 10100110b = 10101111b
-00001001b | 10100111b = 10101111b
-00001001b | 10101000b = 10101001b
-00001001b | 10101001b = 10101001b
-00001001b | 10101010b = 10101011b
-00001001b | 10101011b = 10101011b
-00001001b | 10101100b = 10101101b
-00001001b | 10101101b = 10101101b
-00001001b | 10101110b = 10101111b
-00001001b | 10101111b = 10101111b
-00001001b | 10110000b = 10111001b
-00001001b | 10110001b = 10111001b
-00001001b | 10110010b = 10111011b
-00001001b | 10110011b = 10111011b
-00001001b | 10110100b = 10111101b
-00001001b | 10110101b = 10111101b
-00001001b | 10110110b = 10111111b
-00001001b | 10110111b = 10111111b
-00001001b | 10111000b = 10111001b
-00001001b | 10111001b = 10111001b
-00001001b | 10111010b = 10111011b
-00001001b | 10111011b = 10111011b
-00001001b | 10111100b = 10111101b
-00001001b | 10111101b = 10111101b
-00001001b | 10111110b = 10111111b
-00001001b | 10111111b = 10111111b
-00001001b | 11000000b = 11001001b
-00001001b | 11000001b = 11001001b
-00001001b | 11000010b = 11001011b
-00001001b | 11000011b = 11001011b
-00001001b | 11000100b = 11001101b
-00001001b | 11000101b = 11001101b
-00001001b | 11000110b = 11001111b
-00001001b | 11000111b = 11001111b
-00001001b | 11001000b = 11001001b
-00001001b | 11001001b = 11001001b
-00001001b | 11001010b = 11001011b
-00001001b | 11001011b = 11001011b
-00001001b | 11001100b = 11001101b
-00001001b | 11001101b = 11001101b
-00001001b | 11001110b = 11001111b
-00001001b | 11001111b = 11001111b
-00001001b | 11010000b = 11011001b
-00001001b | 11010001b = 11011001b
-00001001b | 11010010b = 11011011b
-00001001b | 11010011b = 11011011b
-00001001b | 11010100b = 11011101b
-00001001b | 11010101b = 11011101b
-00001001b | 11010110b = 11011111b
-00001001b | 11010111b = 11011111b
-00001001b | 11011000b = 11011001b
-00001001b | 11011001b = 11011001b
-00001001b | 11011010b = 11011011b
-00001001b | 11011011b = 11011011b
-00001001b | 11011100b = 11011101b
-00001001b | 11011101b = 11011101b
-00001001b | 11011110b = 11011111b
-00001001b | 11011111b = 11011111b
-00001001b | 11100000b = 11101001b
-00001001b | 11100001b = 11101001b
-00001001b | 11100010b = 11101011b
-00001001b | 11100011b = 11101011b
-00001001b | 11100100b = 11101101b
-00001001b | 11100101b = 11101101b
-00001001b | 11100110b = 11101111b
-00001001b | 11100111b = 11101111b
-00001001b | 11101000b = 11101001b
-00001001b | 11101001b = 11101001b
-00001001b | 11101010b = 11101011b
-00001001b | 11101011b = 11101011b
-00001001b | 11101100b = 11101101b
-00001001b | 11101101b = 11101101b
-00001001b | 11101110b = 11101111b
-00001001b | 11101111b = 11101111b
-00001001b | 11110000b = 11111001b
-00001001b | 11110001b = 11111001b
-00001001b | 11110010b = 11111011b
-00001001b | 11110011b = 11111011b
-00001001b | 11110100b = 11111101b
-00001001b | 11110101b = 11111101b
-00001001b | 11110110b = 11111111b
-00001001b | 11110111b = 11111111b
-00001001b | 11111000b = 11111001b
-00001001b | 11111001b = 11111001b
-00001001b | 11111010b = 11111011b
-00001001b | 11111011b = 11111011b
-00001001b | 11111100b = 11111101b
-00001001b | 11111101b = 11111101b
-00001001b | 11111110b = 11111111b
-00001001b | 11111111b = 11111111b
-00001001b | 00000000b = 00001001b
-00001001b | 00000001b = 00001001b
-00001001b | 00000010b = 00001011b
-00001001b | 00000011b = 00001011b
-00001001b | 00000100b = 00001101b
-00001001b | 00000101b = 00001101b
-00001001b | 00000110b = 00001111b
-00001001b | 00000111b = 00001111b
-00001001b | 00001000b = 00001001b
-00001001b | 00001001b = 00001001b
-00001001b | 00001010b = 00001011b
-00001001b | 00001011b = 00001011b
-00001001b | 00001100b = 00001101b
-00001001b | 00001101b = 00001101b
-00001001b | 00001110b = 00001111b
-00001001b | 00001111b = 00001111b
-00001001b | 00010000b = 00011001b
-00001001b | 00010001b = 00011001b
-00001001b | 00010010b = 00011011b
-00001001b | 00010011b = 00011011b
-00001001b | 00010100b = 00011101b
-00001001b | 00010101b = 00011101b
-00001001b | 00010110b = 00011111b
-00001001b | 00010111b = 00011111b
-00001001b | 00011000b = 00011001b
-00001001b | 00011001b = 00011001b
-00001001b | 00011010b = 00011011b
-00001001b | 00011011b = 00011011b
-00001001b | 00011100b = 00011101b
-00001001b | 00011101b = 00011101b
-00001001b | 00011110b = 00011111b
-00001001b | 00011111b = 00011111b
-00001001b | 00100000b = 00101001b
-00001001b | 00100001b = 00101001b
-00001001b | 00100010b = 00101011b
-00001001b | 00100011b = 00101011b
-00001001b | 00100100b = 00101101b
-00001001b | 00100101b = 00101101b
-00001001b | 00100110b = 00101111b
-00001001b | 00100111b = 00101111b
-00001001b | 00101000b = 00101001b
-00001001b | 00101001b = 00101001b
-00001001b | 00101010b = 00101011b
-00001001b | 00101011b = 00101011b
-00001001b | 00101100b = 00101101b
-00001001b | 00101101b = 00101101b
-00001001b | 00101110b = 00101111b
-00001001b | 00101111b = 00101111b
-00001001b | 00110000b = 00111001b
-00001001b | 00110001b = 00111001b
-00001001b | 00110010b = 00111011b
-00001001b | 00110011b = 00111011b
-00001001b | 00110100b = 00111101b
-00001001b | 00110101b = 00111101b
-00001001b | 00110110b = 00111111b
-00001001b | 00110111b = 00111111b
-00001001b | 00111000b = 00111001b
-00001001b | 00111001b = 00111001b
-00001001b | 00111010b = 00111011b
-00001001b | 00111011b = 00111011b
-00001001b | 00111100b = 00111101b
-00001001b | 00111101b = 00111101b
-00001001b | 00111110b = 00111111b
-00001001b | 00111111b = 00111111b
-00001001b | 01000000b = 01001001b
-00001001b | 01000001b = 01001001b
-00001001b | 01000010b = 01001011b
-00001001b | 01000011b = 01001011b
-00001001b | 01000100b = 01001101b
-00001001b | 01000101b = 01001101b
-00001001b | 01000110b = 01001111b
-00001001b | 01000111b = 01001111b
-00001001b | 01001000b = 01001001b
-00001001b | 01001001b = 01001001b
-00001001b | 01001010b = 01001011b
-00001001b | 01001011b = 01001011b
-00001001b | 01001100b = 01001101b
-00001001b | 01001101b = 01001101b
-00001001b | 01001110b = 01001111b
-00001001b | 01001111b = 01001111b
-00001001b | 01010000b = 01011001b
-00001001b | 01010001b = 01011001b
-00001001b | 01010010b = 01011011b
-00001001b | 01010011b = 01011011b
-00001001b | 01010100b = 01011101b
-00001001b | 01010101b = 01011101b
-00001001b | 01010110b = 01011111b
-00001001b | 01010111b = 01011111b
-00001001b | 01011000b = 01011001b
-00001001b | 01011001b = 01011001b
-00001001b | 01011010b = 01011011b
-00001001b | 01011011b = 01011011b
-00001001b | 01011100b = 01011101b
-00001001b | 01011101b = 01011101b
-00001001b | 01011110b = 01011111b
-00001001b | 01011111b = 01011111b
-00001001b | 01100000b = 01101001b
-00001001b | 01100001b = 01101001b
-00001001b | 01100010b = 01101011b
-00001001b | 01100011b = 01101011b
-00001001b | 01100100b = 01101101b
-00001001b | 01100101b = 01101101b
-00001001b | 01100110b = 01101111b
-00001001b | 01100111b = 01101111b
-00001001b | 01101000b = 01101001b
-00001001b | 01101001b = 01101001b
-00001001b | 01101010b = 01101011b
-00001001b | 01101011b = 01101011b
-00001001b | 01101100b = 01101101b
-00001001b | 01101101b = 01101101b
-00001001b | 01101110b = 01101111b
-00001001b | 01101111b = 01101111b
-00001001b | 01110000b = 01111001b
-00001001b | 01110001b = 01111001b
-00001001b | 01110010b = 01111011b
-00001001b | 01110011b = 01111011b
-00001001b | 01110100b = 01111101b
-00001001b | 01110101b = 01111101b
-00001001b | 01110110b = 01111111b
-00001001b | 01110111b = 01111111b
-00001001b | 01111000b = 01111001b
-00001001b | 01111001b = 01111001b
-00001001b | 01111010b = 01111011b
-00001001b | 01111011b = 01111011b
-00001001b | 01111100b = 01111101b
-00001001b | 01111101b = 01111101b
-00001001b | 01111110b = 01111111b
-00001010b | 10000000b = 10001010b
-00001010b | 10000001b = 10001011b
-00001010b | 10000010b = 10001010b
-00001010b | 10000011b = 10001011b
-00001010b | 10000100b = 10001110b
-00001010b | 10000101b = 10001111b
-00001010b | 10000110b = 10001110b
-00001010b | 10000111b = 10001111b
-00001010b | 10001000b = 10001010b
-00001010b | 10001001b = 10001011b
-00001010b | 10001010b = 10001010b
-00001010b | 10001011b = 10001011b
-00001010b | 10001100b = 10001110b
-00001010b | 10001101b = 10001111b
-00001010b | 10001110b = 10001110b
-00001010b | 10001111b = 10001111b
-00001010b | 10010000b = 10011010b
-00001010b | 10010001b = 10011011b
-00001010b | 10010010b = 10011010b
-00001010b | 10010011b = 10011011b
-00001010b | 10010100b = 10011110b
-00001010b | 10010101b = 10011111b
-00001010b | 10010110b = 10011110b
-00001010b | 10010111b = 10011111b
-00001010b | 10011000b = 10011010b
-00001010b | 10011001b = 10011011b
-00001010b | 10011010b = 10011010b
-00001010b | 10011011b = 10011011b
-00001010b | 10011100b = 10011110b
-00001010b | 10011101b = 10011111b
-00001010b | 10011110b = 10011110b
-00001010b | 10011111b = 10011111b
-00001010b | 10100000b = 10101010b
-00001010b | 10100001b = 10101011b
-00001010b | 10100010b = 10101010b
-00001010b | 10100011b = 10101011b
-00001010b | 10100100b = 10101110b
-00001010b | 10100101b = 10101111b
-00001010b | 10100110b = 10101110b
-00001010b | 10100111b = 10101111b
-00001010b | 10101000b = 10101010b
-00001010b | 10101001b = 10101011b
-00001010b | 10101010b = 10101010b
-00001010b | 10101011b = 10101011b
-00001010b | 10101100b = 10101110b
-00001010b | 10101101b = 10101111b
-00001010b | 10101110b = 10101110b
-00001010b | 10101111b = 10101111b
-00001010b | 10110000b = 10111010b
-00001010b | 10110001b = 10111011b
-00001010b | 10110010b = 10111010b
-00001010b | 10110011b = 10111011b
-00001010b | 10110100b = 10111110b
-00001010b | 10110101b = 10111111b
-00001010b | 10110110b = 10111110b
-00001010b | 10110111b = 10111111b
-00001010b | 10111000b = 10111010b
-00001010b | 10111001b = 10111011b
-00001010b | 10111010b = 10111010b
-00001010b | 10111011b = 10111011b
-00001010b | 10111100b = 10111110b
-00001010b | 10111101b = 10111111b
-00001010b | 10111110b = 10111110b
-00001010b | 10111111b = 10111111b
-00001010b | 11000000b = 11001010b
-00001010b | 11000001b = 11001011b
-00001010b | 11000010b = 11001010b
-00001010b | 11000011b = 11001011b
-00001010b | 11000100b = 11001110b
-00001010b | 11000101b = 11001111b
-00001010b | 11000110b = 11001110b
-00001010b | 11000111b = 11001111b
-00001010b | 11001000b = 11001010b
-00001010b | 11001001b = 11001011b
-00001010b | 11001010b = 11001010b
-00001010b | 11001011b = 11001011b
-00001010b | 11001100b = 11001110b
-00001010b | 11001101b = 11001111b
-00001010b | 11001110b = 11001110b
-00001010b | 11001111b = 11001111b
-00001010b | 11010000b = 11011010b
-00001010b | 11010001b = 11011011b
-00001010b | 11010010b = 11011010b
-00001010b | 11010011b = 11011011b
-00001010b | 11010100b = 11011110b
-00001010b | 11010101b = 11011111b
-00001010b | 11010110b = 11011110b
-00001010b | 11010111b = 11011111b
-00001010b | 11011000b = 11011010b
-00001010b | 11011001b = 11011011b
-00001010b | 11011010b = 11011010b
-00001010b | 11011011b = 11011011b
-00001010b | 11011100b = 11011110b
-00001010b | 11011101b = 11011111b
-00001010b | 11011110b = 11011110b
-00001010b | 11011111b = 11011111b
-00001010b | 11100000b = 11101010b
-00001010b | 11100001b = 11101011b
-00001010b | 11100010b = 11101010b
-00001010b | 11100011b = 11101011b
-00001010b | 11100100b = 11101110b
-00001010b | 11100101b = 11101111b
-00001010b | 11100110b = 11101110b
-00001010b | 11100111b = 11101111b
-00001010b | 11101000b = 11101010b
-00001010b | 11101001b = 11101011b
-00001010b | 11101010b = 11101010b
-00001010b | 11101011b = 11101011b
-00001010b | 11101100b = 11101110b
-00001010b | 11101101b = 11101111b
-00001010b | 11101110b = 11101110b
-00001010b | 11101111b = 11101111b
-00001010b | 11110000b = 11111010b
-00001010b | 11110001b = 11111011b
-00001010b | 11110010b = 11111010b
-00001010b | 11110011b = 11111011b
-00001010b | 11110100b = 11111110b
-00001010b | 11110101b = 11111111b
-00001010b | 11110110b = 11111110b
-00001010b | 11110111b = 11111111b
-00001010b | 11111000b = 11111010b
-00001010b | 11111001b = 11111011b
-00001010b | 11111010b = 11111010b
-00001010b | 11111011b = 11111011b
-00001010b | 11111100b = 11111110b
-00001010b | 11111101b = 11111111b
-00001010b | 11111110b = 11111110b
-00001010b | 11111111b = 11111111b
-00001010b | 00000000b = 00001010b
-00001010b | 00000001b = 00001011b
-00001010b | 00000010b = 00001010b
-00001010b | 00000011b = 00001011b
-00001010b | 00000100b = 00001110b
-00001010b | 00000101b = 00001111b
-00001010b | 00000110b = 00001110b
-00001010b | 00000111b = 00001111b
-00001010b | 00001000b = 00001010b
-00001010b | 00001001b = 00001011b
-00001010b | 00001010b = 00001010b
-00001010b | 00001011b = 00001011b
-00001010b | 00001100b = 00001110b
-00001010b | 00001101b = 00001111b
-00001010b | 00001110b = 00001110b
-00001010b | 00001111b = 00001111b
-00001010b | 00010000b = 00011010b
-00001010b | 00010001b = 00011011b
-00001010b | 00010010b = 00011010b
-00001010b | 00010011b = 00011011b
-00001010b | 00010100b = 00011110b
-00001010b | 00010101b = 00011111b
-00001010b | 00010110b = 00011110b
-00001010b | 00010111b = 00011111b
-00001010b | 00011000b = 00011010b
-00001010b | 00011001b = 00011011b
-00001010b | 00011010b = 00011010b
-00001010b | 00011011b = 00011011b
-00001010b | 00011100b = 00011110b
-00001010b | 00011101b = 00011111b
-00001010b | 00011110b = 00011110b
-00001010b | 00011111b = 00011111b
-00001010b | 00100000b = 00101010b
-00001010b | 00100001b = 00101011b
-00001010b | 00100010b = 00101010b
-00001010b | 00100011b = 00101011b
-00001010b | 00100100b = 00101110b
-00001010b | 00100101b = 00101111b
-00001010b | 00100110b = 00101110b
-00001010b | 00100111b = 00101111b
-00001010b | 00101000b = 00101010b
-00001010b | 00101001b = 00101011b
-00001010b | 00101010b = 00101010b
-00001010b | 00101011b = 00101011b
-00001010b | 00101100b = 00101110b
-00001010b | 00101101b = 00101111b
-00001010b | 00101110b = 00101110b
-00001010b | 00101111b = 00101111b
-00001010b | 00110000b = 00111010b
-00001010b | 00110001b = 00111011b
-00001010b | 00110010b = 00111010b
-00001010b | 00110011b = 00111011b
-00001010b | 00110100b = 00111110b
-00001010b | 00110101b = 00111111b
-00001010b | 00110110b = 00111110b
-00001010b | 00110111b = 00111111b
-00001010b | 00111000b = 00111010b
-00001010b | 00111001b = 00111011b
-00001010b | 00111010b = 00111010b
-00001010b | 00111011b = 00111011b
-00001010b | 00111100b = 00111110b
-00001010b | 00111101b = 00111111b
-00001010b | 00111110b = 00111110b
-00001010b | 00111111b = 00111111b
-00001010b | 01000000b = 01001010b
-00001010b | 01000001b = 01001011b
-00001010b | 01000010b = 01001010b
-00001010b | 01000011b = 01001011b
-00001010b | 01000100b = 01001110b
-00001010b | 01000101b = 01001111b
-00001010b | 01000110b = 01001110b
-00001010b | 01000111b = 01001111b
-00001010b | 01001000b = 01001010b
-00001010b | 01001001b = 01001011b
-00001010b | 01001010b = 01001010b
-00001010b | 01001011b = 01001011b
-00001010b | 01001100b = 01001110b
-00001010b | 01001101b = 01001111b
-00001010b | 01001110b = 01001110b
-00001010b | 01001111b = 01001111b
-00001010b | 01010000b = 01011010b
-00001010b | 01010001b = 01011011b
-00001010b | 01010010b = 01011010b
-00001010b | 01010011b = 01011011b
-00001010b | 01010100b = 01011110b
-00001010b | 01010101b = 01011111b
-00001010b | 01010110b = 01011110b
-00001010b | 01010111b = 01011111b
-00001010b | 01011000b = 01011010b
-00001010b | 01011001b = 01011011b
-00001010b | 01011010b = 01011010b
-00001010b | 01011011b = 01011011b
-00001010b | 01011100b = 01011110b
-00001010b | 01011101b = 01011111b
-00001010b | 01011110b = 01011110b
-00001010b | 01011111b = 01011111b
-00001010b | 01100000b = 01101010b
-00001010b | 01100001b = 01101011b
-00001010b | 01100010b = 01101010b
-00001010b | 01100011b = 01101011b
-00001010b | 01100100b = 01101110b
-00001010b | 01100101b = 01101111b
-00001010b | 01100110b = 01101110b
-00001010b | 01100111b = 01101111b
-00001010b | 01101000b = 01101010b
-00001010b | 01101001b = 01101011b
-00001010b | 01101010b = 01101010b
-00001010b | 01101011b = 01101011b
-00001010b | 01101100b = 01101110b
-00001010b | 01101101b = 01101111b
-00001010b | 01101110b = 01101110b
-00001010b | 01101111b = 01101111b
-00001010b | 01110000b = 01111010b
-00001010b | 01110001b = 01111011b
-00001010b | 01110010b = 01111010b
-00001010b | 01110011b = 01111011b
-00001010b | 01110100b = 01111110b
-00001010b | 01110101b = 01111111b
-00001010b | 01110110b = 01111110b
-00001010b | 01110111b = 01111111b
-00001010b | 01111000b = 01111010b
-00001010b | 01111001b = 01111011b
-00001010b | 01111010b = 01111010b
-00001010b | 01111011b = 01111011b
-00001010b | 01111100b = 01111110b
-00001010b | 01111101b = 01111111b
-00001010b | 01111110b = 01111110b
-00001011b | 10000000b = 10001011b
-00001011b | 10000001b = 10001011b
-00001011b | 10000010b = 10001011b
-00001011b | 10000011b = 10001011b
-00001011b | 10000100b = 10001111b
-00001011b | 10000101b = 10001111b
-00001011b | 10000110b = 10001111b
-00001011b | 10000111b = 10001111b
-00001011b | 10001000b = 10001011b
-00001011b | 10001001b = 10001011b
-00001011b | 10001010b = 10001011b
-00001011b | 10001011b = 10001011b
-00001011b | 10001100b = 10001111b
-00001011b | 10001101b = 10001111b
-00001011b | 10001110b = 10001111b
-00001011b | 10001111b = 10001111b
-00001011b | 10010000b = 10011011b
-00001011b | 10010001b = 10011011b
-00001011b | 10010010b = 10011011b
-00001011b | 10010011b = 10011011b
-00001011b | 10010100b = 10011111b
-00001011b | 10010101b = 10011111b
-00001011b | 10010110b = 10011111b
-00001011b | 10010111b = 10011111b
-00001011b | 10011000b = 10011011b
-00001011b | 10011001b = 10011011b
-00001011b | 10011010b = 10011011b
-00001011b | 10011011b = 10011011b
-00001011b | 10011100b = 10011111b
-00001011b | 10011101b = 10011111b
-00001011b | 10011110b = 10011111b
-00001011b | 10011111b = 10011111b
-00001011b | 10100000b = 10101011b
-00001011b | 10100001b = 10101011b
-00001011b | 10100010b = 10101011b
-00001011b | 10100011b = 10101011b
-00001011b | 10100100b = 10101111b
-00001011b | 10100101b = 10101111b
-00001011b | 10100110b = 10101111b
-00001011b | 10100111b = 10101111b
-00001011b | 10101000b = 10101011b
-00001011b | 10101001b = 10101011b
-00001011b | 10101010b = 10101011b
-00001011b | 10101011b = 10101011b
-00001011b | 10101100b = 10101111b
-00001011b | 10101101b = 10101111b
-00001011b | 10101110b = 10101111b
-00001011b | 10101111b = 10101111b
-00001011b | 10110000b = 10111011b
-00001011b | 10110001b = 10111011b
-00001011b | 10110010b = 10111011b
-00001011b | 10110011b = 10111011b
-00001011b | 10110100b = 10111111b
-00001011b | 10110101b = 10111111b
-00001011b | 10110110b = 10111111b
-00001011b | 10110111b = 10111111b
-00001011b | 10111000b = 10111011b
-00001011b | 10111001b = 10111011b
-00001011b | 10111010b = 10111011b
-00001011b | 10111011b = 10111011b
-00001011b | 10111100b = 10111111b
-00001011b | 10111101b = 10111111b
-00001011b | 10111110b = 10111111b
-00001011b | 10111111b = 10111111b
-00001011b | 11000000b = 11001011b
-00001011b | 11000001b = 11001011b
-00001011b | 11000010b = 11001011b
-00001011b | 11000011b = 11001011b
-00001011b | 11000100b = 11001111b
-00001011b | 11000101b = 11001111b
-00001011b | 11000110b = 11001111b
-00001011b | 11000111b = 11001111b
-00001011b | 11001000b = 11001011b
-00001011b | 11001001b = 11001011b
-00001011b | 11001010b = 11001011b
-00001011b | 11001011b = 11001011b
-00001011b | 11001100b = 11001111b
-00001011b | 11001101b = 11001111b
-00001011b | 11001110b = 11001111b
-00001011b | 11001111b = 11001111b
-00001011b | 11010000b = 11011011b
-00001011b | 11010001b = 11011011b
-00001011b | 11010010b = 11011011b
-00001011b | 11010011b = 11011011b
-00001011b | 11010100b = 11011111b
-00001011b | 11010101b = 11011111b
-00001011b | 11010110b = 11011111b
-00001011b | 11010111b = 11011111b
-00001011b | 11011000b = 11011011b
-00001011b | 11011001b = 11011011b
-00001011b | 11011010b = 11011011b
-00001011b | 11011011b = 11011011b
-00001011b | 11011100b = 11011111b
-00001011b | 11011101b = 11011111b
-00001011b | 11011110b = 11011111b
-00001011b | 11011111b = 11011111b
-00001011b | 11100000b = 11101011b
-00001011b | 11100001b = 11101011b
-00001011b | 11100010b = 11101011b
-00001011b | 11100011b = 11101011b
-00001011b | 11100100b = 11101111b
-00001011b | 11100101b = 11101111b
-00001011b | 11100110b = 11101111b
-00001011b | 11100111b = 11101111b
-00001011b | 11101000b = 11101011b
-00001011b | 11101001b = 11101011b
-00001011b | 11101010b = 11101011b
-00001011b | 11101011b = 11101011b
-00001011b | 11101100b = 11101111b
-00001011b | 11101101b = 11101111b
-00001011b | 11101110b = 11101111b
-00001011b | 11101111b = 11101111b
-00001011b | 11110000b = 11111011b
-00001011b | 11110001b = 11111011b
-00001011b | 11110010b = 11111011b
-00001011b | 11110011b = 11111011b
-00001011b | 11110100b = 11111111b
-00001011b | 11110101b = 11111111b
-00001011b | 11110110b = 11111111b
-00001011b | 11110111b = 11111111b
-00001011b | 11111000b = 11111011b
-00001011b | 11111001b = 11111011b
-00001011b | 11111010b = 11111011b
-00001011b | 11111011b = 11111011b
-00001011b | 11111100b = 11111111b
-00001011b | 11111101b = 11111111b
-00001011b | 11111110b = 11111111b
-00001011b | 11111111b = 11111111b
-00001011b | 00000000b = 00001011b
-00001011b | 00000001b = 00001011b
-00001011b | 00000010b = 00001011b
-00001011b | 00000011b = 00001011b
-00001011b | 00000100b = 00001111b
-00001011b | 00000101b = 00001111b
-00001011b | 00000110b = 00001111b
-00001011b | 00000111b = 00001111b
-00001011b | 00001000b = 00001011b
-00001011b | 00001001b = 00001011b
-00001011b | 00001010b = 00001011b
-00001011b | 00001011b = 00001011b
-00001011b | 00001100b = 00001111b
-00001011b | 00001101b = 00001111b
-00001011b | 00001110b = 00001111b
-00001011b | 00001111b = 00001111b
-00001011b | 00010000b = 00011011b
-00001011b | 00010001b = 00011011b
-00001011b | 00010010b = 00011011b
-00001011b | 00010011b = 00011011b
-00001011b | 00010100b = 00011111b
-00001011b | 00010101b = 00011111b
-00001011b | 00010110b = 00011111b
-00001011b | 00010111b = 00011111b
-00001011b | 00011000b = 00011011b
-00001011b | 00011001b = 00011011b
-00001011b | 00011010b = 00011011b
-00001011b | 00011011b = 00011011b
-00001011b | 00011100b = 00011111b
-00001011b | 00011101b = 00011111b
-00001011b | 00011110b = 00011111b
-00001011b | 00011111b = 00011111b
-00001011b | 00100000b = 00101011b
-00001011b | 00100001b = 00101011b
-00001011b | 00100010b = 00101011b
-00001011b | 00100011b = 00101011b
-00001011b | 00100100b = 00101111b
-00001011b | 00100101b = 00101111b
-00001011b | 00100110b = 00101111b
-00001011b | 00100111b = 00101111b
-00001011b | 00101000b = 00101011b
-00001011b | 00101001b = 00101011b
-00001011b | 00101010b = 00101011b
-00001011b | 00101011b = 00101011b
-00001011b | 00101100b = 00101111b
-00001011b | 00101101b = 00101111b
-00001011b | 00101110b = 00101111b
-00001011b | 00101111b = 00101111b
-00001011b | 00110000b = 00111011b
-00001011b | 00110001b = 00111011b
-00001011b | 00110010b = 00111011b
-00001011b | 00110011b = 00111011b
-00001011b | 00110100b = 00111111b
-00001011b | 00110101b = 00111111b
-00001011b | 00110110b = 00111111b
-00001011b | 00110111b = 00111111b
-00001011b | 00111000b = 00111011b
-00001011b | 00111001b = 00111011b
-00001011b | 00111010b = 00111011b
-00001011b | 00111011b = 00111011b
-00001011b | 00111100b = 00111111b
-00001011b | 00111101b = 00111111b
-00001011b | 00111110b = 00111111b
-00001011b | 00111111b = 00111111b
-00001011b | 01000000b = 01001011b
-00001011b | 01000001b = 01001011b
-00001011b | 01000010b = 01001011b
-00001011b | 01000011b = 01001011b
-00001011b | 01000100b = 01001111b
-00001011b | 01000101b = 01001111b
-00001011b | 01000110b = 01001111b
-00001011b | 01000111b = 01001111b
-00001011b | 01001000b = 01001011b
-00001011b | 01001001b = 01001011b
-00001011b | 01001010b = 01001011b
-00001011b | 01001011b = 01001011b
-00001011b | 01001100b = 01001111b
-00001011b | 01001101b = 01001111b
-00001011b | 01001110b = 01001111b
-00001011b | 01001111b = 01001111b
-00001011b | 01010000b = 01011011b
-00001011b | 01010001b = 01011011b
-00001011b | 01010010b = 01011011b
-00001011b | 01010011b = 01011011b
-00001011b | 01010100b = 01011111b
-00001011b | 01010101b = 01011111b
-00001011b | 01010110b = 01011111b
-00001011b | 01010111b = 01011111b
-00001011b | 01011000b = 01011011b
-00001011b | 01011001b = 01011011b
-00001011b | 01011010b = 01011011b
-00001011b | 01011011b = 01011011b
-00001011b | 01011100b = 01011111b
-00001011b | 01011101b = 01011111b
-00001011b | 01011110b = 01011111b
-00001011b | 01011111b = 01011111b
-00001011b | 01100000b = 01101011b
-00001011b | 01100001b = 01101011b
-00001011b | 01100010b = 01101011b
-00001011b | 01100011b = 01101011b
-00001011b | 01100100b = 01101111b
-00001011b | 01100101b = 01101111b
-00001011b | 01100110b = 01101111b
-00001011b | 01100111b = 01101111b
-00001011b | 01101000b = 01101011b
-00001011b | 01101001b = 01101011b
-00001011b | 01101010b = 01101011b
-00001011b | 01101011b = 01101011b
-00001011b | 01101100b = 01101111b
-00001011b | 01101101b = 01101111b
-00001011b | 01101110b = 01101111b
-00001011b | 01101111b = 01101111b
-00001011b | 01110000b = 01111011b
-00001011b | 01110001b = 01111011b
-00001011b | 01110010b = 01111011b
-00001011b | 01110011b = 01111011b
-00001011b | 01110100b = 01111111b
-00001011b | 01110101b = 01111111b
-00001011b | 01110110b = 01111111b
-00001011b | 01110111b = 01111111b
-00001011b | 01111000b = 01111011b
-00001011b | 01111001b = 01111011b
-00001011b | 01111010b = 01111011b
-00001011b | 01111011b = 01111011b
-00001011b | 01111100b = 01111111b
-00001011b | 01111101b = 01111111b
-00001011b | 01111110b = 01111111b
-00001100b | 10000000b = 10001100b
-00001100b | 10000001b = 10001101b
-00001100b | 10000010b = 10001110b
-00001100b | 10000011b = 10001111b
-00001100b | 10000100b = 10001100b
-00001100b | 10000101b = 10001101b
-00001100b | 10000110b = 10001110b
-00001100b | 10000111b = 10001111b
-00001100b | 10001000b = 10001100b
-00001100b | 10001001b = 10001101b
-00001100b | 10001010b = 10001110b
-00001100b | 10001011b = 10001111b
-00001100b | 10001100b = 10001100b
-00001100b | 10001101b = 10001101b
-00001100b | 10001110b = 10001110b
-00001100b | 10001111b = 10001111b
-00001100b | 10010000b = 10011100b
-00001100b | 10010001b = 10011101b
-00001100b | 10010010b = 10011110b
-00001100b | 10010011b = 10011111b
-00001100b | 10010100b = 10011100b
-00001100b | 10010101b = 10011101b
-00001100b | 10010110b = 10011110b
-00001100b | 10010111b = 10011111b
-00001100b | 10011000b = 10011100b
-00001100b | 10011001b = 10011101b
-00001100b | 10011010b = 10011110b
-00001100b | 10011011b = 10011111b
-00001100b | 10011100b = 10011100b
-00001100b | 10011101b = 10011101b
-00001100b | 10011110b = 10011110b
-00001100b | 10011111b = 10011111b
-00001100b | 10100000b = 10101100b
-00001100b | 10100001b = 10101101b
-00001100b | 10100010b = 10101110b
-00001100b | 10100011b = 10101111b
-00001100b | 10100100b = 10101100b
-00001100b | 10100101b = 10101101b
-00001100b | 10100110b = 10101110b
-00001100b | 10100111b = 10101111b
-00001100b | 10101000b = 10101100b
-00001100b | 10101001b = 10101101b
-00001100b | 10101010b = 10101110b
-00001100b | 10101011b = 10101111b
-00001100b | 10101100b = 10101100b
-00001100b | 10101101b = 10101101b
-00001100b | 10101110b = 10101110b
-00001100b | 10101111b = 10101111b
-00001100b | 10110000b = 10111100b
-00001100b | 10110001b = 10111101b
-00001100b | 10110010b = 10111110b
-00001100b | 10110011b = 10111111b
-00001100b | 10110100b = 10111100b
-00001100b | 10110101b = 10111101b
-00001100b | 10110110b = 10111110b
-00001100b | 10110111b = 10111111b
-00001100b | 10111000b = 10111100b
-00001100b | 10111001b = 10111101b
-00001100b | 10111010b = 10111110b
-00001100b | 10111011b = 10111111b
-00001100b | 10111100b = 10111100b
-00001100b | 10111101b = 10111101b
-00001100b | 10111110b = 10111110b
-00001100b | 10111111b = 10111111b
-00001100b | 11000000b = 11001100b
-00001100b | 11000001b = 11001101b
-00001100b | 11000010b = 11001110b
-00001100b | 11000011b = 11001111b
-00001100b | 11000100b = 11001100b
-00001100b | 11000101b = 11001101b
-00001100b | 11000110b = 11001110b
-00001100b | 11000111b = 11001111b
-00001100b | 11001000b = 11001100b
-00001100b | 11001001b = 11001101b
-00001100b | 11001010b = 11001110b
-00001100b | 11001011b = 11001111b
-00001100b | 11001100b = 11001100b
-00001100b | 11001101b = 11001101b
-00001100b | 11001110b = 11001110b
-00001100b | 11001111b = 11001111b
-00001100b | 11010000b = 11011100b
-00001100b | 11010001b = 11011101b
-00001100b | 11010010b = 11011110b
-00001100b | 11010011b = 11011111b
-00001100b | 11010100b = 11011100b
-00001100b | 11010101b = 11011101b
-00001100b | 11010110b = 11011110b
-00001100b | 11010111b = 11011111b
-00001100b | 11011000b = 11011100b
-00001100b | 11011001b = 11011101b
-00001100b | 11011010b = 11011110b
-00001100b | 11011011b = 11011111b
-00001100b | 11011100b = 11011100b
-00001100b | 11011101b = 11011101b
-00001100b | 11011110b = 11011110b
-00001100b | 11011111b = 11011111b
-00001100b | 11100000b = 11101100b
-00001100b | 11100001b = 11101101b
-00001100b | 11100010b = 11101110b
-00001100b | 11100011b = 11101111b
-00001100b | 11100100b = 11101100b
-00001100b | 11100101b = 11101101b
-00001100b | 11100110b = 11101110b
-00001100b | 11100111b = 11101111b
-00001100b | 11101000b = 11101100b
-00001100b | 11101001b = 11101101b
-00001100b | 11101010b = 11101110b
-00001100b | 11101011b = 11101111b
-00001100b | 11101100b = 11101100b
-00001100b | 11101101b = 11101101b
-00001100b | 11101110b = 11101110b
-00001100b | 11101111b = 11101111b
-00001100b | 11110000b = 11111100b
-00001100b | 11110001b = 11111101b
-00001100b | 11110010b = 11111110b
-00001100b | 11110011b = 11111111b
-00001100b | 11110100b = 11111100b
-00001100b | 11110101b = 11111101b
-00001100b | 11110110b = 11111110b
-00001100b | 11110111b = 11111111b
-00001100b | 11111000b = 11111100b
-00001100b | 11111001b = 11111101b
-00001100b | 11111010b = 11111110b
-00001100b | 11111011b = 11111111b
-00001100b | 11111100b = 11111100b
-00001100b | 11111101b = 11111101b
-00001100b | 11111110b = 11111110b
-00001100b | 11111111b = 11111111b
-00001100b | 00000000b = 00001100b
-00001100b | 00000001b = 00001101b
-00001100b | 00000010b = 00001110b
-00001100b | 00000011b = 00001111b
-00001100b | 00000100b = 00001100b
-00001100b | 00000101b = 00001101b
-00001100b | 00000110b = 00001110b
-00001100b | 00000111b = 00001111b
-00001100b | 00001000b = 00001100b
-00001100b | 00001001b = 00001101b
-00001100b | 00001010b = 00001110b
-00001100b | 00001011b = 00001111b
-00001100b | 00001100b = 00001100b
-00001100b | 00001101b = 00001101b
-00001100b | 00001110b = 00001110b
-00001100b | 00001111b = 00001111b
-00001100b | 00010000b = 00011100b
-00001100b | 00010001b = 00011101b
-00001100b | 00010010b = 00011110b
-00001100b | 00010011b = 00011111b
-00001100b | 00010100b = 00011100b
-00001100b | 00010101b = 00011101b
-00001100b | 00010110b = 00011110b
-00001100b | 00010111b = 00011111b
-00001100b | 00011000b = 00011100b
-00001100b | 00011001b = 00011101b
-00001100b | 00011010b = 00011110b
-00001100b | 00011011b = 00011111b
-00001100b | 00011100b = 00011100b
-00001100b | 00011101b = 00011101b
-00001100b | 00011110b = 00011110b
-00001100b | 00011111b = 00011111b
-00001100b | 00100000b = 00101100b
-00001100b | 00100001b = 00101101b
-00001100b | 00100010b = 00101110b
-00001100b | 00100011b = 00101111b
-00001100b | 00100100b = 00101100b
-00001100b | 00100101b = 00101101b
-00001100b | 00100110b = 00101110b
-00001100b | 00100111b = 00101111b
-00001100b | 00101000b = 00101100b
-00001100b | 00101001b = 00101101b
-00001100b | 00101010b = 00101110b
-00001100b | 00101011b = 00101111b
-00001100b | 00101100b = 00101100b
-00001100b | 00101101b = 00101101b
-00001100b | 00101110b = 00101110b
-00001100b | 00101111b = 00101111b
-00001100b | 00110000b = 00111100b
-00001100b | 00110001b = 00111101b
-00001100b | 00110010b = 00111110b
-00001100b | 00110011b = 00111111b
-00001100b | 00110100b = 00111100b
-00001100b | 00110101b = 00111101b
-00001100b | 00110110b = 00111110b
-00001100b | 00110111b = 00111111b
-00001100b | 00111000b = 00111100b
-00001100b | 00111001b = 00111101b
-00001100b | 00111010b = 00111110b
-00001100b | 00111011b = 00111111b
-00001100b | 00111100b = 00111100b
-00001100b | 00111101b = 00111101b
-00001100b | 00111110b = 00111110b
-00001100b | 00111111b = 00111111b
-00001100b | 01000000b = 01001100b
-00001100b | 01000001b = 01001101b
-00001100b | 01000010b = 01001110b
-00001100b | 01000011b = 01001111b
-00001100b | 01000100b = 01001100b
-00001100b | 01000101b = 01001101b
-00001100b | 01000110b = 01001110b
-00001100b | 01000111b = 01001111b
-00001100b | 01001000b = 01001100b
-00001100b | 01001001b = 01001101b
-00001100b | 01001010b = 01001110b
-00001100b | 01001011b = 01001111b
-00001100b | 01001100b = 01001100b
-00001100b | 01001101b = 01001101b
-00001100b | 01001110b = 01001110b
-00001100b | 01001111b = 01001111b
-00001100b | 01010000b = 01011100b
-00001100b | 01010001b = 01011101b
-00001100b | 01010010b = 01011110b
-00001100b | 01010011b = 01011111b
-00001100b | 01010100b = 01011100b
-00001100b | 01010101b = 01011101b
-00001100b | 01010110b = 01011110b
-00001100b | 01010111b = 01011111b
-00001100b | 01011000b = 01011100b
-00001100b | 01011001b = 01011101b
-00001100b | 01011010b = 01011110b
-00001100b | 01011011b = 01011111b
-00001100b | 01011100b = 01011100b
-00001100b | 01011101b = 01011101b
-00001100b | 01011110b = 01011110b
-00001100b | 01011111b = 01011111b
-00001100b | 01100000b = 01101100b
-00001100b | 01100001b = 01101101b
-00001100b | 01100010b = 01101110b
-00001100b | 01100011b = 01101111b
-00001100b | 01100100b = 01101100b
-00001100b | 01100101b = 01101101b
-00001100b | 01100110b = 01101110b
-00001100b | 01100111b = 01101111b
-00001100b | 01101000b = 01101100b
-00001100b | 01101001b = 01101101b
-00001100b | 01101010b = 01101110b
-00001100b | 01101011b = 01101111b
-00001100b | 01101100b = 01101100b
-00001100b | 01101101b = 01101101b
-00001100b | 01101110b = 01101110b
-00001100b | 01101111b = 01101111b
-00001100b | 01110000b = 01111100b
-00001100b | 01110001b = 01111101b
-00001100b | 01110010b = 01111110b
-00001100b | 01110011b = 01111111b
-00001100b | 01110100b = 01111100b
-00001100b | 01110101b = 01111101b
-00001100b | 01110110b = 01111110b
-00001100b | 01110111b = 01111111b
-00001100b | 01111000b = 01111100b
-00001100b | 01111001b = 01111101b
-00001100b | 01111010b = 01111110b
-00001100b | 01111011b = 01111111b
-00001100b | 01111100b = 01111100b
-00001100b | 01111101b = 01111101b
-00001100b | 01111110b = 01111110b
-00001101b | 10000000b = 10001101b
-00001101b | 10000001b = 10001101b
-00001101b | 10000010b = 10001111b
-00001101b | 10000011b = 10001111b
-00001101b | 10000100b = 10001101b
-00001101b | 10000101b = 10001101b
-00001101b | 10000110b = 10001111b
-00001101b | 10000111b = 10001111b
-00001101b | 10001000b = 10001101b
-00001101b | 10001001b = 10001101b
-00001101b | 10001010b = 10001111b
-00001101b | 10001011b = 10001111b
-00001101b | 10001100b = 10001101b
-00001101b | 10001101b = 10001101b
-00001101b | 10001110b = 10001111b
-00001101b | 10001111b = 10001111b
-00001101b | 10010000b = 10011101b
-00001101b | 10010001b = 10011101b
-00001101b | 10010010b = 10011111b
-00001101b | 10010011b = 10011111b
-00001101b | 10010100b = 10011101b
-00001101b | 10010101b = 10011101b
-00001101b | 10010110b = 10011111b
-00001101b | 10010111b = 10011111b
-00001101b | 10011000b = 10011101b
-00001101b | 10011001b = 10011101b
-00001101b | 10011010b = 10011111b
-00001101b | 10011011b = 10011111b
-00001101b | 10011100b = 10011101b
-00001101b | 10011101b = 10011101b
-00001101b | 10011110b = 10011111b
-00001101b | 10011111b = 10011111b
-00001101b | 10100000b = 10101101b
-00001101b | 10100001b = 10101101b
-00001101b | 10100010b = 10101111b
-00001101b | 10100011b = 10101111b
-00001101b | 10100100b = 10101101b
-00001101b | 10100101b = 10101101b
-00001101b | 10100110b = 10101111b
-00001101b | 10100111b = 10101111b
-00001101b | 10101000b = 10101101b
-00001101b | 10101001b = 10101101b
-00001101b | 10101010b = 10101111b
-00001101b | 10101011b = 10101111b
-00001101b | 10101100b = 10101101b
-00001101b | 10101101b = 10101101b
-00001101b | 10101110b = 10101111b
-00001101b | 10101111b = 10101111b
-00001101b | 10110000b = 10111101b
-00001101b | 10110001b = 10111101b
-00001101b | 10110010b = 10111111b
-00001101b | 10110011b = 10111111b
-00001101b | 10110100b = 10111101b
-00001101b | 10110101b = 10111101b
-00001101b | 10110110b = 10111111b
-00001101b | 10110111b = 10111111b
-00001101b | 10111000b = 10111101b
-00001101b | 10111001b = 10111101b
-00001101b | 10111010b = 10111111b
-00001101b | 10111011b = 10111111b
-00001101b | 10111100b = 10111101b
-00001101b | 10111101b = 10111101b
-00001101b | 10111110b = 10111111b
-00001101b | 10111111b = 10111111b
-00001101b | 11000000b = 11001101b
-00001101b | 11000001b = 11001101b
-00001101b | 11000010b = 11001111b
-00001101b | 11000011b = 11001111b
-00001101b | 11000100b = 11001101b
-00001101b | 11000101b = 11001101b
-00001101b | 11000110b = 11001111b
-00001101b | 11000111b = 11001111b
-00001101b | 11001000b = 11001101b
-00001101b | 11001001b = 11001101b
-00001101b | 11001010b = 11001111b
-00001101b | 11001011b = 11001111b
-00001101b | 11001100b = 11001101b
-00001101b | 11001101b = 11001101b
-00001101b | 11001110b = 11001111b
-00001101b | 11001111b = 11001111b
-00001101b | 11010000b = 11011101b
-00001101b | 11010001b = 11011101b
-00001101b | 11010010b = 11011111b
-00001101b | 11010011b = 11011111b
-00001101b | 11010100b = 11011101b
-00001101b | 11010101b = 11011101b
-00001101b | 11010110b = 11011111b
-00001101b | 11010111b = 11011111b
-00001101b | 11011000b = 11011101b
-00001101b | 11011001b = 11011101b
-00001101b | 11011010b = 11011111b
-00001101b | 11011011b = 11011111b
-00001101b | 11011100b = 11011101b
-00001101b | 11011101b = 11011101b
-00001101b | 11011110b = 11011111b
-00001101b | 11011111b = 11011111b
-00001101b | 11100000b = 11101101b
-00001101b | 11100001b = 11101101b
-00001101b | 11100010b = 11101111b
-00001101b | 11100011b = 11101111b
-00001101b | 11100100b = 11101101b
-00001101b | 11100101b = 11101101b
-00001101b | 11100110b = 11101111b
-00001101b | 11100111b = 11101111b
-00001101b | 11101000b = 11101101b
-00001101b | 11101001b = 11101101b
-00001101b | 11101010b = 11101111b
-00001101b | 11101011b = 11101111b
-00001101b | 11101100b = 11101101b
-00001101b | 11101101b = 11101101b
-00001101b | 11101110b = 11101111b
-00001101b | 11101111b = 11101111b
-00001101b | 11110000b = 11111101b
-00001101b | 11110001b = 11111101b
-00001101b | 11110010b = 11111111b
-00001101b | 11110011b = 11111111b
-00001101b | 11110100b = 11111101b
-00001101b | 11110101b = 11111101b
-00001101b | 11110110b = 11111111b
-00001101b | 11110111b = 11111111b
-00001101b | 11111000b = 11111101b
-00001101b | 11111001b = 11111101b
-00001101b | 11111010b = 11111111b
-00001101b | 11111011b = 11111111b
-00001101b | 11111100b = 11111101b
-00001101b | 11111101b = 11111101b
-00001101b | 11111110b = 11111111b
-00001101b | 11111111b = 11111111b
-00001101b | 00000000b = 00001101b
-00001101b | 00000001b = 00001101b
-00001101b | 00000010b = 00001111b
-00001101b | 00000011b = 00001111b
-00001101b | 00000100b = 00001101b
-00001101b | 00000101b = 00001101b
-00001101b | 00000110b = 00001111b
-00001101b | 00000111b = 00001111b
-00001101b | 00001000b = 00001101b
-00001101b | 00001001b = 00001101b
-00001101b | 00001010b = 00001111b
-00001101b | 00001011b = 00001111b
-00001101b | 00001100b = 00001101b
-00001101b | 00001101b = 00001101b
-00001101b | 00001110b = 00001111b
-00001101b | 00001111b = 00001111b
-00001101b | 00010000b = 00011101b
-00001101b | 00010001b = 00011101b
-00001101b | 00010010b = 00011111b
-00001101b | 00010011b = 00011111b
-00001101b | 00010100b = 00011101b
-00001101b | 00010101b = 00011101b
-00001101b | 00010110b = 00011111b
-00001101b | 00010111b = 00011111b
-00001101b | 00011000b = 00011101b
-00001101b | 00011001b = 00011101b
-00001101b | 00011010b = 00011111b
-00001101b | 00011011b = 00011111b
-00001101b | 00011100b = 00011101b
-00001101b | 00011101b = 00011101b
-00001101b | 00011110b = 00011111b
-00001101b | 00011111b = 00011111b
-00001101b | 00100000b = 00101101b
-00001101b | 00100001b = 00101101b
-00001101b | 00100010b = 00101111b
-00001101b | 00100011b = 00101111b
-00001101b | 00100100b = 00101101b
-00001101b | 00100101b = 00101101b
-00001101b | 00100110b = 00101111b
-00001101b | 00100111b = 00101111b
-00001101b | 00101000b = 00101101b
-00001101b | 00101001b = 00101101b
-00001101b | 00101010b = 00101111b
-00001101b | 00101011b = 00101111b
-00001101b | 00101100b = 00101101b
-00001101b | 00101101b = 00101101b
-00001101b | 00101110b = 00101111b
-00001101b | 00101111b = 00101111b
-00001101b | 00110000b = 00111101b
-00001101b | 00110001b = 00111101b
-00001101b | 00110010b = 00111111b
-00001101b | 00110011b = 00111111b
-00001101b | 00110100b = 00111101b
-00001101b | 00110101b = 00111101b
-00001101b | 00110110b = 00111111b
-00001101b | 00110111b = 00111111b
-00001101b | 00111000b = 00111101b
-00001101b | 00111001b = 00111101b
-00001101b | 00111010b = 00111111b
-00001101b | 00111011b = 00111111b
-00001101b | 00111100b = 00111101b
-00001101b | 00111101b = 00111101b
-00001101b | 00111110b = 00111111b
-00001101b | 00111111b = 00111111b
-00001101b | 01000000b = 01001101b
-00001101b | 01000001b = 01001101b
-00001101b | 01000010b = 01001111b
-00001101b | 01000011b = 01001111b
-00001101b | 01000100b = 01001101b
-00001101b | 01000101b = 01001101b
-00001101b | 01000110b = 01001111b
-00001101b | 01000111b = 01001111b
-00001101b | 01001000b = 01001101b
-00001101b | 01001001b = 01001101b
-00001101b | 01001010b = 01001111b
-00001101b | 01001011b = 01001111b
-00001101b | 01001100b = 01001101b
-00001101b | 01001101b = 01001101b
-00001101b | 01001110b = 01001111b
-00001101b | 01001111b = 01001111b
-00001101b | 01010000b = 01011101b
-00001101b | 01010001b = 01011101b
-00001101b | 01010010b = 01011111b
-00001101b | 01010011b = 01011111b
-00001101b | 01010100b = 01011101b
-00001101b | 01010101b = 01011101b
-00001101b | 01010110b = 01011111b
-00001101b | 01010111b = 01011111b
-00001101b | 01011000b = 01011101b
-00001101b | 01011001b = 01011101b
-00001101b | 01011010b = 01011111b
-00001101b | 01011011b = 01011111b
-00001101b | 01011100b = 01011101b
-00001101b | 01011101b = 01011101b
-00001101b | 01011110b = 01011111b
-00001101b | 01011111b = 01011111b
-00001101b | 01100000b = 01101101b
-00001101b | 01100001b = 01101101b
-00001101b | 01100010b = 01101111b
-00001101b | 01100011b = 01101111b
-00001101b | 01100100b = 01101101b
-00001101b | 01100101b = 01101101b
-00001101b | 01100110b = 01101111b
-00001101b | 01100111b = 01101111b
-00001101b | 01101000b = 01101101b
-00001101b | 01101001b = 01101101b
-00001101b | 01101010b = 01101111b
-00001101b | 01101011b = 01101111b
-00001101b | 01101100b = 01101101b
-00001101b | 01101101b = 01101101b
-00001101b | 01101110b = 01101111b
-00001101b | 01101111b = 01101111b
-00001101b | 01110000b = 01111101b
-00001101b | 01110001b = 01111101b
-00001101b | 01110010b = 01111111b
-00001101b | 01110011b = 01111111b
-00001101b | 01110100b = 01111101b
-00001101b | 01110101b = 01111101b
-00001101b | 01110110b = 01111111b
-00001101b | 01110111b = 01111111b
-00001101b | 01111000b = 01111101b
-00001101b | 01111001b = 01111101b
-00001101b | 01111010b = 01111111b
-00001101b | 01111011b = 01111111b
-00001101b | 01111100b = 01111101b
-00001101b | 01111101b = 01111101b
-00001101b | 01111110b = 01111111b
-00001110b | 10000000b = 10001110b
-00001110b | 10000001b = 10001111b
-00001110b | 10000010b = 10001110b
-00001110b | 10000011b = 10001111b
-00001110b | 10000100b = 10001110b
-00001110b | 10000101b = 10001111b
-00001110b | 10000110b = 10001110b
-00001110b | 10000111b = 10001111b
-00001110b | 10001000b = 10001110b
-00001110b | 10001001b = 10001111b
-00001110b | 10001010b = 10001110b
-00001110b | 10001011b = 10001111b
-00001110b | 10001100b = 10001110b
-00001110b | 10001101b = 10001111b
-00001110b | 10001110b = 10001110b
-00001110b | 10001111b = 10001111b
-00001110b | 10010000b = 10011110b
-00001110b | 10010001b = 10011111b
-00001110b | 10010010b = 10011110b
-00001110b | 10010011b = 10011111b
-00001110b | 10010100b = 10011110b
-00001110b | 10010101b = 10011111b
-00001110b | 10010110b = 10011110b
-00001110b | 10010111b = 10011111b
-00001110b | 10011000b = 10011110b
-00001110b | 10011001b = 10011111b
-00001110b | 10011010b = 10011110b
-00001110b | 10011011b = 10011111b
-00001110b | 10011100b = 10011110b
-00001110b | 10011101b = 10011111b
-00001110b | 10011110b = 10011110b
-00001110b | 10011111b = 10011111b
-00001110b | 10100000b = 10101110b
-00001110b | 10100001b = 10101111b
-00001110b | 10100010b = 10101110b
-00001110b | 10100011b = 10101111b
-00001110b | 10100100b = 10101110b
-00001110b | 10100101b = 10101111b
-00001110b | 10100110b = 10101110b
-00001110b | 10100111b = 10101111b
-00001110b | 10101000b = 10101110b
-00001110b | 10101001b = 10101111b
-00001110b | 10101010b = 10101110b
-00001110b | 10101011b = 10101111b
-00001110b | 10101100b = 10101110b
-00001110b | 10101101b = 10101111b
-00001110b | 10101110b = 10101110b
-00001110b | 10101111b = 10101111b
-00001110b | 10110000b = 10111110b
-00001110b | 10110001b = 10111111b
-00001110b | 10110010b = 10111110b
-00001110b | 10110011b = 10111111b
-00001110b | 10110100b = 10111110b
-00001110b | 10110101b = 10111111b
-00001110b | 10110110b = 10111110b
-00001110b | 10110111b = 10111111b
-00001110b | 10111000b = 10111110b
-00001110b | 10111001b = 10111111b
-00001110b | 10111010b = 10111110b
-00001110b | 10111011b = 10111111b
-00001110b | 10111100b = 10111110b
-00001110b | 10111101b = 10111111b
-00001110b | 10111110b = 10111110b
-00001110b | 10111111b = 10111111b
-00001110b | 11000000b = 11001110b
-00001110b | 11000001b = 11001111b
-00001110b | 11000010b = 11001110b
-00001110b | 11000011b = 11001111b
-00001110b | 11000100b = 11001110b
-00001110b | 11000101b = 11001111b
-00001110b | 11000110b = 11001110b
-00001110b | 11000111b = 11001111b
-00001110b | 11001000b = 11001110b
-00001110b | 11001001b = 11001111b
-00001110b | 11001010b = 11001110b
-00001110b | 11001011b = 11001111b
-00001110b | 11001100b = 11001110b
-00001110b | 11001101b = 11001111b
-00001110b | 11001110b = 11001110b
-00001110b | 11001111b = 11001111b
-00001110b | 11010000b = 11011110b
-00001110b | 11010001b = 11011111b
-00001110b | 11010010b = 11011110b
-00001110b | 11010011b = 11011111b
-00001110b | 11010100b = 11011110b
-00001110b | 11010101b = 11011111b
-00001110b | 11010110b = 11011110b
-00001110b | 11010111b = 11011111b
-00001110b | 11011000b = 11011110b
-00001110b | 11011001b = 11011111b
-00001110b | 11011010b = 11011110b
-00001110b | 11011011b = 11011111b
-00001110b | 11011100b = 11011110b
-00001110b | 11011101b = 11011111b
-00001110b | 11011110b = 11011110b
-00001110b | 11011111b = 11011111b
-00001110b | 11100000b = 11101110b
-00001110b | 11100001b = 11101111b
-00001110b | 11100010b = 11101110b
-00001110b | 11100011b = 11101111b
-00001110b | 11100100b = 11101110b
-00001110b | 11100101b = 11101111b
-00001110b | 11100110b = 11101110b
-00001110b | 11100111b = 11101111b
-00001110b | 11101000b = 11101110b
-00001110b | 11101001b = 11101111b
-00001110b | 11101010b = 11101110b
-00001110b | 11101011b = 11101111b
-00001110b | 11101100b = 11101110b
-00001110b | 11101101b = 11101111b
-00001110b | 11101110b = 11101110b
-00001110b | 11101111b = 11101111b
-00001110b | 11110000b = 11111110b
-00001110b | 11110001b = 11111111b
-00001110b | 11110010b = 11111110b
-00001110b | 11110011b = 11111111b
-00001110b | 11110100b = 11111110b
-00001110b | 11110101b = 11111111b
-00001110b | 11110110b = 11111110b
-00001110b | 11110111b = 11111111b
-00001110b | 11111000b = 11111110b
-00001110b | 11111001b = 11111111b
-00001110b | 11111010b = 11111110b
-00001110b | 11111011b = 11111111b
-00001110b | 11111100b = 11111110b
-00001110b | 11111101b = 11111111b
-00001110b | 11111110b = 11111110b
-00001110b | 11111111b = 11111111b
-00001110b | 00000000b = 00001110b
-00001110b | 00000001b = 00001111b
-00001110b | 00000010b = 00001110b
-00001110b | 00000011b = 00001111b
-00001110b | 00000100b = 00001110b
-00001110b | 00000101b = 00001111b
-00001110b | 00000110b = 00001110b
-00001110b | 00000111b = 00001111b
-00001110b | 00001000b = 00001110b
-00001110b | 00001001b = 00001111b
-00001110b | 00001010b = 00001110b
-00001110b | 00001011b = 00001111b
-00001110b | 00001100b = 00001110b
-00001110b | 00001101b = 00001111b
-00001110b | 00001110b = 00001110b
-00001110b | 00001111b = 00001111b
-00001110b | 00010000b = 00011110b
-00001110b | 00010001b = 00011111b
-00001110b | 00010010b = 00011110b
-00001110b | 00010011b = 00011111b
-00001110b | 00010100b = 00011110b
-00001110b | 00010101b = 00011111b
-00001110b | 00010110b = 00011110b
-00001110b | 00010111b = 00011111b
-00001110b | 00011000b = 00011110b
-00001110b | 00011001b = 00011111b
-00001110b | 00011010b = 00011110b
-00001110b | 00011011b = 00011111b
-00001110b | 00011100b = 00011110b
-00001110b | 00011101b = 00011111b
-00001110b | 00011110b = 00011110b
-00001110b | 00011111b = 00011111b
-00001110b | 00100000b = 00101110b
-00001110b | 00100001b = 00101111b
-00001110b | 00100010b = 00101110b
-00001110b | 00100011b = 00101111b
-00001110b | 00100100b = 00101110b
-00001110b | 00100101b = 00101111b
-00001110b | 00100110b = 00101110b
-00001110b | 00100111b = 00101111b
-00001110b | 00101000b = 00101110b
-00001110b | 00101001b = 00101111b
-00001110b | 00101010b = 00101110b
-00001110b | 00101011b = 00101111b
-00001110b | 00101100b = 00101110b
-00001110b | 00101101b = 00101111b
-00001110b | 00101110b = 00101110b
-00001110b | 00101111b = 00101111b
-00001110b | 00110000b = 00111110b
-00001110b | 00110001b = 00111111b
-00001110b | 00110010b = 00111110b
-00001110b | 00110011b = 00111111b
-00001110b | 00110100b = 00111110b
-00001110b | 00110101b = 00111111b
-00001110b | 00110110b = 00111110b
-00001110b | 00110111b = 00111111b
-00001110b | 00111000b = 00111110b
-00001110b | 00111001b = 00111111b
-00001110b | 00111010b = 00111110b
-00001110b | 00111011b = 00111111b
-00001110b | 00111100b = 00111110b
-00001110b | 00111101b = 00111111b
-00001110b | 00111110b = 00111110b
-00001110b | 00111111b = 00111111b
-00001110b | 01000000b = 01001110b
-00001110b | 01000001b = 01001111b
-00001110b | 01000010b = 01001110b
-00001110b | 01000011b = 01001111b
-00001110b | 01000100b = 01001110b
-00001110b | 01000101b = 01001111b
-00001110b | 01000110b = 01001110b
-00001110b | 01000111b = 01001111b
-00001110b | 01001000b = 01001110b
-00001110b | 01001001b = 01001111b
-00001110b | 01001010b = 01001110b
-00001110b | 01001011b = 01001111b
-00001110b | 01001100b = 01001110b
-00001110b | 01001101b = 01001111b
-00001110b | 01001110b = 01001110b
-00001110b | 01001111b = 01001111b
-00001110b | 01010000b = 01011110b
-00001110b | 01010001b = 01011111b
-00001110b | 01010010b = 01011110b
-00001110b | 01010011b = 01011111b
-00001110b | 01010100b = 01011110b
-00001110b | 01010101b = 01011111b
-00001110b | 01010110b = 01011110b
-00001110b | 01010111b = 01011111b
-00001110b | 01011000b = 01011110b
-00001110b | 01011001b = 01011111b
-00001110b | 01011010b = 01011110b
-00001110b | 01011011b = 01011111b
-00001110b | 01011100b = 01011110b
-00001110b | 01011101b = 01011111b
-00001110b | 01011110b = 01011110b
-00001110b | 01011111b = 01011111b
-00001110b | 01100000b = 01101110b
-00001110b | 01100001b = 01101111b
-00001110b | 01100010b = 01101110b
-00001110b | 01100011b = 01101111b
-00001110b | 01100100b = 01101110b
-00001110b | 01100101b = 01101111b
-00001110b | 01100110b = 01101110b
-00001110b | 01100111b = 01101111b
-00001110b | 01101000b = 01101110b
-00001110b | 01101001b = 01101111b
-00001110b | 01101010b = 01101110b
-00001110b | 01101011b = 01101111b
-00001110b | 01101100b = 01101110b
-00001110b | 01101101b = 01101111b
-00001110b | 01101110b = 01101110b
-00001110b | 01101111b = 01101111b
-00001110b | 01110000b = 01111110b
-00001110b | 01110001b = 01111111b
-00001110b | 01110010b = 01111110b
-00001110b | 01110011b = 01111111b
-00001110b | 01110100b = 01111110b
-00001110b | 01110101b = 01111111b
-00001110b | 01110110b = 01111110b
-00001110b | 01110111b = 01111111b
-00001110b | 01111000b = 01111110b
-00001110b | 01111001b = 01111111b
-00001110b | 01111010b = 01111110b
-00001110b | 01111011b = 01111111b
-00001110b | 01111100b = 01111110b
-00001110b | 01111101b = 01111111b
-00001110b | 01111110b = 01111110b
-00001111b | 10000000b = 10001111b
-00001111b | 10000001b = 10001111b
-00001111b | 10000010b = 10001111b
-00001111b | 10000011b = 10001111b
-00001111b | 10000100b = 10001111b
-00001111b | 10000101b = 10001111b
-00001111b | 10000110b = 10001111b
-00001111b | 10000111b = 10001111b
-00001111b | 10001000b = 10001111b
-00001111b | 10001001b = 10001111b
-00001111b | 10001010b = 10001111b
-00001111b | 10001011b = 10001111b
-00001111b | 10001100b = 10001111b
-00001111b | 10001101b = 10001111b
-00001111b | 10001110b = 10001111b
-00001111b | 10001111b = 10001111b
-00001111b | 10010000b = 10011111b
-00001111b | 10010001b = 10011111b
-00001111b | 10010010b = 10011111b
-00001111b | 10010011b = 10011111b
-00001111b | 10010100b = 10011111b
-00001111b | 10010101b = 10011111b
-00001111b | 10010110b = 10011111b
-00001111b | 10010111b = 10011111b
-00001111b | 10011000b = 10011111b
-00001111b | 10011001b = 10011111b
-00001111b | 10011010b = 10011111b
-00001111b | 10011011b = 10011111b
-00001111b | 10011100b = 10011111b
-00001111b | 10011101b = 10011111b
-00001111b | 10011110b = 10011111b
-00001111b | 10011111b = 10011111b
-00001111b | 10100000b = 10101111b
-00001111b | 10100001b = 10101111b
-00001111b | 10100010b = 10101111b
-00001111b | 10100011b = 10101111b
-00001111b | 10100100b = 10101111b
-00001111b | 10100101b = 10101111b
-00001111b | 10100110b = 10101111b
-00001111b | 10100111b = 10101111b
-00001111b | 10101000b = 10101111b
-00001111b | 10101001b = 10101111b
-00001111b | 10101010b = 10101111b
-00001111b | 10101011b = 10101111b
-00001111b | 10101100b = 10101111b
-00001111b | 10101101b = 10101111b
-00001111b | 10101110b = 10101111b
-00001111b | 10101111b = 10101111b
-00001111b | 10110000b = 10111111b
-00001111b | 10110001b = 10111111b
-00001111b | 10110010b = 10111111b
-00001111b | 10110011b = 10111111b
-00001111b | 10110100b = 10111111b
-00001111b | 10110101b = 10111111b
-00001111b | 10110110b = 10111111b
-00001111b | 10110111b = 10111111b
-00001111b | 10111000b = 10111111b
-00001111b | 10111001b = 10111111b
-00001111b | 10111010b = 10111111b
-00001111b | 10111011b = 10111111b
-00001111b | 10111100b = 10111111b
-00001111b | 10111101b = 10111111b
-00001111b | 10111110b = 10111111b
-00001111b | 10111111b = 10111111b
-00001111b | 11000000b = 11001111b
-00001111b | 11000001b = 11001111b
-00001111b | 11000010b = 11001111b
-00001111b | 11000011b = 11001111b
-00001111b | 11000100b = 11001111b
-00001111b | 11000101b = 11001111b
-00001111b | 11000110b = 11001111b
-00001111b | 11000111b = 11001111b
-00001111b | 11001000b = 11001111b
-00001111b | 11001001b = 11001111b
-00001111b | 11001010b = 11001111b
-00001111b | 11001011b = 11001111b
-00001111b | 11001100b = 11001111b
-00001111b | 11001101b = 11001111b
-00001111b | 11001110b = 11001111b
-00001111b | 11001111b = 11001111b
-00001111b | 11010000b = 11011111b
-00001111b | 11010001b = 11011111b
-00001111b | 11010010b = 11011111b
-00001111b | 11010011b = 11011111b
-00001111b | 11010100b = 11011111b
-00001111b | 11010101b = 11011111b
-00001111b | 11010110b = 11011111b
-00001111b | 11010111b = 11011111b
-00001111b | 11011000b = 11011111b
-00001111b | 11011001b = 11011111b
-00001111b | 11011010b = 11011111b
-00001111b | 11011011b = 11011111b
-00001111b | 11011100b = 11011111b
-00001111b | 11011101b = 11011111b
-00001111b | 11011110b = 11011111b
-00001111b | 11011111b = 11011111b
-00001111b | 11100000b = 11101111b
-00001111b | 11100001b = 11101111b
-00001111b | 11100010b = 11101111b
-00001111b | 11100011b = 11101111b
-00001111b | 11100100b = 11101111b
-00001111b | 11100101b = 11101111b
-00001111b | 11100110b = 11101111b
-00001111b | 11100111b = 11101111b
-00001111b | 11101000b = 11101111b
-00001111b | 11101001b = 11101111b
-00001111b | 11101010b = 11101111b
-00001111b | 11101011b = 11101111b
-00001111b | 11101100b = 11101111b
-00001111b | 11101101b = 11101111b
-00001111b | 11101110b = 11101111b
-00001111b | 11101111b = 11101111b
-00001111b | 11110000b = 11111111b
-00001111b | 11110001b = 11111111b
-00001111b | 11110010b = 11111111b
-00001111b | 11110011b = 11111111b
-00001111b | 11110100b = 11111111b
-00001111b | 11110101b = 11111111b
-00001111b | 11110110b = 11111111b
-00001111b | 11110111b = 11111111b
-00001111b | 11111000b = 11111111b
-00001111b | 11111001b = 11111111b
-00001111b | 11111010b = 11111111b
-00001111b | 11111011b = 11111111b
-00001111b | 11111100b = 11111111b
-00001111b | 11111101b = 11111111b
-00001111b | 11111110b = 11111111b
-00001111b | 11111111b = 11111111b
-00001111b | 00000000b = 00001111b
-00001111b | 00000001b = 00001111b
-00001111b | 00000010b = 00001111b
-00001111b | 00000011b = 00001111b
-00001111b | 00000100b = 00001111b
-00001111b | 00000101b = 00001111b
-00001111b | 00000110b = 00001111b
-00001111b | 00000111b = 00001111b
-00001111b | 00001000b = 00001111b
-00001111b | 00001001b = 00001111b
-00001111b | 00001010b = 00001111b
-00001111b | 00001011b = 00001111b
-00001111b | 00001100b = 00001111b
-00001111b | 00001101b = 00001111b
-00001111b | 00001110b = 00001111b
-00001111b | 00001111b = 00001111b
-00001111b | 00010000b = 00011111b
-00001111b | 00010001b = 00011111b
-00001111b | 00010010b = 00011111b
-00001111b | 00010011b = 00011111b
-00001111b | 00010100b = 00011111b
-00001111b | 00010101b = 00011111b
-00001111b | 00010110b = 00011111b
-00001111b | 00010111b = 00011111b
-00001111b | 00011000b = 00011111b
-00001111b | 00011001b = 00011111b
-00001111b | 00011010b = 00011111b
-00001111b | 00011011b = 00011111b
-00001111b | 00011100b = 00011111b
-00001111b | 00011101b = 00011111b
-00001111b | 00011110b = 00011111b
-00001111b | 00011111b = 00011111b
-00001111b | 00100000b = 00101111b
-00001111b | 00100001b = 00101111b
-00001111b | 00100010b = 00101111b
-00001111b | 00100011b = 00101111b
-00001111b | 00100100b = 00101111b
-00001111b | 00100101b = 00101111b
-00001111b | 00100110b = 00101111b
-00001111b | 00100111b = 00101111b
-00001111b | 00101000b = 00101111b
-00001111b | 00101001b = 00101111b
-00001111b | 00101010b = 00101111b
-00001111b | 00101011b = 00101111b
-00001111b | 00101100b = 00101111b
-00001111b | 00101101b = 00101111b
-00001111b | 00101110b = 00101111b
-00001111b | 00101111b = 00101111b
-00001111b | 00110000b = 00111111b
-00001111b | 00110001b = 00111111b
-00001111b | 00110010b = 00111111b
-00001111b | 00110011b = 00111111b
-00001111b | 00110100b = 00111111b
-00001111b | 00110101b = 00111111b
-00001111b | 00110110b = 00111111b
-00001111b | 00110111b = 00111111b
-00001111b | 00111000b = 00111111b
-00001111b | 00111001b = 00111111b
-00001111b | 00111010b = 00111111b
-00001111b | 00111011b = 00111111b
-00001111b | 00111100b = 00111111b
-00001111b | 00111101b = 00111111b
-00001111b | 00111110b = 00111111b
-00001111b | 00111111b = 00111111b
-00001111b | 01000000b = 01001111b
-00001111b | 01000001b = 01001111b
-00001111b | 01000010b = 01001111b
-00001111b | 01000011b = 01001111b
-00001111b | 01000100b = 01001111b
-00001111b | 01000101b = 01001111b
-00001111b | 01000110b = 01001111b
-00001111b | 01000111b = 01001111b
-00001111b | 01001000b = 01001111b
-00001111b | 01001001b = 01001111b
-00001111b | 01001010b = 01001111b
-00001111b | 01001011b = 01001111b
-00001111b | 01001100b = 01001111b
-00001111b | 01001101b = 01001111b
-00001111b | 01001110b = 01001111b
-00001111b | 01001111b = 01001111b
-00001111b | 01010000b = 01011111b
-00001111b | 01010001b = 01011111b
-00001111b | 01010010b = 01011111b
-00001111b | 01010011b = 01011111b
-00001111b | 01010100b = 01011111b
-00001111b | 01010101b = 01011111b
-00001111b | 01010110b = 01011111b
-00001111b | 01010111b = 01011111b
-00001111b | 01011000b = 01011111b
-00001111b | 01011001b = 01011111b
-00001111b | 01011010b = 01011111b
-00001111b | 01011011b = 01011111b
-00001111b | 01011100b = 01011111b
-00001111b | 01011101b = 01011111b
-00001111b | 01011110b = 01011111b
-00001111b | 01011111b = 01011111b
-00001111b | 01100000b = 01101111b
-00001111b | 01100001b = 01101111b
-00001111b | 01100010b = 01101111b
-00001111b | 01100011b = 01101111b
-00001111b | 01100100b = 01101111b
-00001111b | 01100101b = 01101111b
-00001111b | 01100110b = 01101111b
-00001111b | 01100111b = 01101111b
-00001111b | 01101000b = 01101111b
-00001111b | 01101001b = 01101111b
-00001111b | 01101010b = 01101111b
-00001111b | 01101011b = 01101111b
-00001111b | 01101100b = 01101111b
-00001111b | 01101101b = 01101111b
-00001111b | 01101110b = 01101111b
-00001111b | 01101111b = 01101111b
-00001111b | 01110000b = 01111111b
-00001111b | 01110001b = 01111111b
-00001111b | 01110010b = 01111111b
-00001111b | 01110011b = 01111111b
-00001111b | 01110100b = 01111111b
-00001111b | 01110101b = 01111111b
-00001111b | 01110110b = 01111111b
-00001111b | 01110111b = 01111111b
-00001111b | 01111000b = 01111111b
-00001111b | 01111001b = 01111111b
-00001111b | 01111010b = 01111111b
-00001111b | 01111011b = 01111111b
-00001111b | 01111100b = 01111111b
-00001111b | 01111101b = 01111111b
-00001111b | 01111110b = 01111111b
-00010000b | 10000000b = 10010000b
-00010000b | 10000001b = 10010001b
-00010000b | 10000010b = 10010010b
-00010000b | 10000011b = 10010011b
-00010000b | 10000100b = 10010100b
-00010000b | 10000101b = 10010101b
-00010000b | 10000110b = 10010110b
-00010000b | 10000111b = 10010111b
-00010000b | 10001000b = 10011000b
-00010000b | 10001001b = 10011001b
-00010000b | 10001010b = 10011010b
-00010000b | 10001011b = 10011011b
-00010000b | 10001100b = 10011100b
-00010000b | 10001101b = 10011101b
-00010000b | 10001110b = 10011110b
-00010000b | 10001111b = 10011111b
-00010000b | 10010000b = 10010000b
-00010000b | 10010001b = 10010001b
-00010000b | 10010010b = 10010010b
-00010000b | 10010011b = 10010011b
-00010000b | 10010100b = 10010100b
-00010000b | 10010101b = 10010101b
-00010000b | 10010110b = 10010110b
-00010000b | 10010111b = 10010111b
-00010000b | 10011000b = 10011000b
-00010000b | 10011001b = 10011001b
-00010000b | 10011010b = 10011010b
-00010000b | 10011011b = 10011011b
-00010000b | 10011100b = 10011100b
-00010000b | 10011101b = 10011101b
-00010000b | 10011110b = 10011110b
-00010000b | 10011111b = 10011111b
-00010000b | 10100000b = 10110000b
-00010000b | 10100001b = 10110001b
-00010000b | 10100010b = 10110010b
-00010000b | 10100011b = 10110011b
-00010000b | 10100100b = 10110100b
-00010000b | 10100101b = 10110101b
-00010000b | 10100110b = 10110110b
-00010000b | 10100111b = 10110111b
-00010000b | 10101000b = 10111000b
-00010000b | 10101001b = 10111001b
-00010000b | 10101010b = 10111010b
-00010000b | 10101011b = 10111011b
-00010000b | 10101100b = 10111100b
-00010000b | 10101101b = 10111101b
-00010000b | 10101110b = 10111110b
-00010000b | 10101111b = 10111111b
-00010000b | 10110000b = 10110000b
-00010000b | 10110001b = 10110001b
-00010000b | 10110010b = 10110010b
-00010000b | 10110011b = 10110011b
-00010000b | 10110100b = 10110100b
-00010000b | 10110101b = 10110101b
-00010000b | 10110110b = 10110110b
-00010000b | 10110111b = 10110111b
-00010000b | 10111000b = 10111000b
-00010000b | 10111001b = 10111001b
-00010000b | 10111010b = 10111010b
-00010000b | 10111011b = 10111011b
-00010000b | 10111100b = 10111100b
-00010000b | 10111101b = 10111101b
-00010000b | 10111110b = 10111110b
-00010000b | 10111111b = 10111111b
-00010000b | 11000000b = 11010000b
-00010000b | 11000001b = 11010001b
-00010000b | 11000010b = 11010010b
-00010000b | 11000011b = 11010011b
-00010000b | 11000100b = 11010100b
-00010000b | 11000101b = 11010101b
-00010000b | 11000110b = 11010110b
-00010000b | 11000111b = 11010111b
-00010000b | 11001000b = 11011000b
-00010000b | 11001001b = 11011001b
-00010000b | 11001010b = 11011010b
-00010000b | 11001011b = 11011011b
-00010000b | 11001100b = 11011100b
-00010000b | 11001101b = 11011101b
-00010000b | 11001110b = 11011110b
-00010000b | 11001111b = 11011111b
-00010000b | 11010000b = 11010000b
-00010000b | 11010001b = 11010001b
-00010000b | 11010010b = 11010010b
-00010000b | 11010011b = 11010011b
-00010000b | 11010100b = 11010100b
-00010000b | 11010101b = 11010101b
-00010000b | 11010110b = 11010110b
-00010000b | 11010111b = 11010111b
-00010000b | 11011000b = 11011000b
-00010000b | 11011001b = 11011001b
-00010000b | 11011010b = 11011010b
-00010000b | 11011011b = 11011011b
-00010000b | 11011100b = 11011100b
-00010000b | 11011101b = 11011101b
-00010000b | 11011110b = 11011110b
-00010000b | 11011111b = 11011111b
-00010000b | 11100000b = 11110000b
-00010000b | 11100001b = 11110001b
-00010000b | 11100010b = 11110010b
-00010000b | 11100011b = 11110011b
-00010000b | 11100100b = 11110100b
-00010000b | 11100101b = 11110101b
-00010000b | 11100110b = 11110110b
-00010000b | 11100111b = 11110111b
-00010000b | 11101000b = 11111000b
-00010000b | 11101001b = 11111001b
-00010000b | 11101010b = 11111010b
-00010000b | 11101011b = 11111011b
-00010000b | 11101100b = 11111100b
-00010000b | 11101101b = 11111101b
-00010000b | 11101110b = 11111110b
-00010000b | 11101111b = 11111111b
-00010000b | 11110000b = 11110000b
-00010000b | 11110001b = 11110001b
-00010000b | 11110010b = 11110010b
-00010000b | 11110011b = 11110011b
-00010000b | 11110100b = 11110100b
-00010000b | 11110101b = 11110101b
-00010000b | 11110110b = 11110110b
-00010000b | 11110111b = 11110111b
-00010000b | 11111000b = 11111000b
-00010000b | 11111001b = 11111001b
-00010000b | 11111010b = 11111010b
-00010000b | 11111011b = 11111011b
-00010000b | 11111100b = 11111100b
-00010000b | 11111101b = 11111101b
-00010000b | 11111110b = 11111110b
-00010000b | 11111111b = 11111111b
-00010000b | 00000000b = 00010000b
-00010000b | 00000001b = 00010001b
-00010000b | 00000010b = 00010010b
-00010000b | 00000011b = 00010011b
-00010000b | 00000100b = 00010100b
-00010000b | 00000101b = 00010101b
-00010000b | 00000110b = 00010110b
-00010000b | 00000111b = 00010111b
-00010000b | 00001000b = 00011000b
-00010000b | 00001001b = 00011001b
-00010000b | 00001010b = 00011010b
-00010000b | 00001011b = 00011011b
-00010000b | 00001100b = 00011100b
-00010000b | 00001101b = 00011101b
-00010000b | 00001110b = 00011110b
-00010000b | 00001111b = 00011111b
-00010000b | 00010000b = 00010000b
-00010000b | 00010001b = 00010001b
-00010000b | 00010010b = 00010010b
-00010000b | 00010011b = 00010011b
-00010000b | 00010100b = 00010100b
-00010000b | 00010101b = 00010101b
-00010000b | 00010110b = 00010110b
-00010000b | 00010111b = 00010111b
-00010000b | 00011000b = 00011000b
-00010000b | 00011001b = 00011001b
-00010000b | 00011010b = 00011010b
-00010000b | 00011011b = 00011011b
-00010000b | 00011100b = 00011100b
-00010000b | 00011101b = 00011101b
-00010000b | 00011110b = 00011110b
-00010000b | 00011111b = 00011111b
-00010000b | 00100000b = 00110000b
-00010000b | 00100001b = 00110001b
-00010000b | 00100010b = 00110010b
-00010000b | 00100011b = 00110011b
-00010000b | 00100100b = 00110100b
-00010000b | 00100101b = 00110101b
-00010000b | 00100110b = 00110110b
-00010000b | 00100111b = 00110111b
-00010000b | 00101000b = 00111000b
-00010000b | 00101001b = 00111001b
-00010000b | 00101010b = 00111010b
-00010000b | 00101011b = 00111011b
-00010000b | 00101100b = 00111100b
-00010000b | 00101101b = 00111101b
-00010000b | 00101110b = 00111110b
-00010000b | 00101111b = 00111111b
-00010000b | 00110000b = 00110000b
-00010000b | 00110001b = 00110001b
-00010000b | 00110010b = 00110010b
-00010000b | 00110011b = 00110011b
-00010000b | 00110100b = 00110100b
-00010000b | 00110101b = 00110101b
-00010000b | 00110110b = 00110110b
-00010000b | 00110111b = 00110111b
-00010000b | 00111000b = 00111000b
-00010000b | 00111001b = 00111001b
-00010000b | 00111010b = 00111010b
-00010000b | 00111011b = 00111011b
-00010000b | 00111100b = 00111100b
-00010000b | 00111101b = 00111101b
-00010000b | 00111110b = 00111110b
-00010000b | 00111111b = 00111111b
-00010000b | 01000000b = 01010000b
-00010000b | 01000001b = 01010001b
-00010000b | 01000010b = 01010010b
-00010000b | 01000011b = 01010011b
-00010000b | 01000100b = 01010100b
-00010000b | 01000101b = 01010101b
-00010000b | 01000110b = 01010110b
-00010000b | 01000111b = 01010111b
-00010000b | 01001000b = 01011000b
-00010000b | 01001001b = 01011001b
-00010000b | 01001010b = 01011010b
-00010000b | 01001011b = 01011011b
-00010000b | 01001100b = 01011100b
-00010000b | 01001101b = 01011101b
-00010000b | 01001110b = 01011110b
-00010000b | 01001111b = 01011111b
-00010000b | 01010000b = 01010000b
-00010000b | 01010001b = 01010001b
-00010000b | 01010010b = 01010010b
-00010000b | 01010011b = 01010011b
-00010000b | 01010100b = 01010100b
-00010000b | 01010101b = 01010101b
-00010000b | 01010110b = 01010110b
-00010000b | 01010111b = 01010111b
-00010000b | 01011000b = 01011000b
-00010000b | 01011001b = 01011001b
-00010000b | 01011010b = 01011010b
-00010000b | 01011011b = 01011011b
-00010000b | 01011100b = 01011100b
-00010000b | 01011101b = 01011101b
-00010000b | 01011110b = 01011110b
-00010000b | 01011111b = 01011111b
-00010000b | 01100000b = 01110000b
-00010000b | 01100001b = 01110001b
-00010000b | 01100010b = 01110010b
-00010000b | 01100011b = 01110011b
-00010000b | 01100100b = 01110100b
-00010000b | 01100101b = 01110101b
-00010000b | 01100110b = 01110110b
-00010000b | 01100111b = 01110111b
-00010000b | 01101000b = 01111000b
-00010000b | 01101001b = 01111001b
-00010000b | 01101010b = 01111010b
-00010000b | 01101011b = 01111011b
-00010000b | 01101100b = 01111100b
-00010000b | 01101101b = 01111101b
-00010000b | 01101110b = 01111110b
-00010000b | 01101111b = 01111111b
-00010000b | 01110000b = 01110000b
-00010000b | 01110001b = 01110001b
-00010000b | 01110010b = 01110010b
-00010000b | 01110011b = 01110011b
-00010000b | 01110100b = 01110100b
-00010000b | 01110101b = 01110101b
-00010000b | 01110110b = 01110110b
-00010000b | 01110111b = 01110111b
-00010000b | 01111000b = 01111000b
-00010000b | 01111001b = 01111001b
-00010000b | 01111010b = 01111010b
-00010000b | 01111011b = 01111011b
-00010000b | 01111100b = 01111100b
-00010000b | 01111101b = 01111101b
-00010000b | 01111110b = 01111110b
-00010001b | 10000000b = 10010001b
-00010001b | 10000001b = 10010001b
-00010001b | 10000010b = 10010011b
-00010001b | 10000011b = 10010011b
-00010001b | 10000100b = 10010101b
-00010001b | 10000101b = 10010101b
-00010001b | 10000110b = 10010111b
-00010001b | 10000111b = 10010111b
-00010001b | 10001000b = 10011001b
-00010001b | 10001001b = 10011001b
-00010001b | 10001010b = 10011011b
-00010001b | 10001011b = 10011011b
-00010001b | 10001100b = 10011101b
-00010001b | 10001101b = 10011101b
-00010001b | 10001110b = 10011111b
-00010001b | 10001111b = 10011111b
-00010001b | 10010000b = 10010001b
-00010001b | 10010001b = 10010001b
-00010001b | 10010010b = 10010011b
-00010001b | 10010011b = 10010011b
-00010001b | 10010100b = 10010101b
-00010001b | 10010101b = 10010101b
-00010001b | 10010110b = 10010111b
-00010001b | 10010111b = 10010111b
-00010001b | 10011000b = 10011001b
-00010001b | 10011001b = 10011001b
-00010001b | 10011010b = 10011011b
-00010001b | 10011011b = 10011011b
-00010001b | 10011100b = 10011101b
-00010001b | 10011101b = 10011101b
-00010001b | 10011110b = 10011111b
-00010001b | 10011111b = 10011111b
-00010001b | 10100000b = 10110001b
-00010001b | 10100001b = 10110001b
-00010001b | 10100010b = 10110011b
-00010001b | 10100011b = 10110011b
-00010001b | 10100100b = 10110101b
-00010001b | 10100101b = 10110101b
-00010001b | 10100110b = 10110111b
-00010001b | 10100111b = 10110111b
-00010001b | 10101000b = 10111001b
-00010001b | 10101001b = 10111001b
-00010001b | 10101010b = 10111011b
-00010001b | 10101011b = 10111011b
-00010001b | 10101100b = 10111101b
-00010001b | 10101101b = 10111101b
-00010001b | 10101110b = 10111111b
-00010001b | 10101111b = 10111111b
-00010001b | 10110000b = 10110001b
-00010001b | 10110001b = 10110001b
-00010001b | 10110010b = 10110011b
-00010001b | 10110011b = 10110011b
-00010001b | 10110100b = 10110101b
-00010001b | 10110101b = 10110101b
-00010001b | 10110110b = 10110111b
-00010001b | 10110111b = 10110111b
-00010001b | 10111000b = 10111001b
-00010001b | 10111001b = 10111001b
-00010001b | 10111010b = 10111011b
-00010001b | 10111011b = 10111011b
-00010001b | 10111100b = 10111101b
-00010001b | 10111101b = 10111101b
-00010001b | 10111110b = 10111111b
-00010001b | 10111111b = 10111111b
-00010001b | 11000000b = 11010001b
-00010001b | 11000001b = 11010001b
-00010001b | 11000010b = 11010011b
-00010001b | 11000011b = 11010011b
-00010001b | 11000100b = 11010101b
-00010001b | 11000101b = 11010101b
-00010001b | 11000110b = 11010111b
-00010001b | 11000111b = 11010111b
-00010001b | 11001000b = 11011001b
-00010001b | 11001001b = 11011001b
-00010001b | 11001010b = 11011011b
-00010001b | 11001011b = 11011011b
-00010001b | 11001100b = 11011101b
-00010001b | 11001101b = 11011101b
-00010001b | 11001110b = 11011111b
-00010001b | 11001111b = 11011111b
-00010001b | 11010000b = 11010001b
-00010001b | 11010001b = 11010001b
-00010001b | 11010010b = 11010011b
-00010001b | 11010011b = 11010011b
-00010001b | 11010100b = 11010101b
-00010001b | 11010101b = 11010101b
-00010001b | 11010110b = 11010111b
-00010001b | 11010111b = 11010111b
-00010001b | 11011000b = 11011001b
-00010001b | 11011001b = 11011001b
-00010001b | 11011010b = 11011011b
-00010001b | 11011011b = 11011011b
-00010001b | 11011100b = 11011101b
-00010001b | 11011101b = 11011101b
-00010001b | 11011110b = 11011111b
-00010001b | 11011111b = 11011111b
-00010001b | 11100000b = 11110001b
-00010001b | 11100001b = 11110001b
-00010001b | 11100010b = 11110011b
-00010001b | 11100011b = 11110011b
-00010001b | 11100100b = 11110101b
-00010001b | 11100101b = 11110101b
-00010001b | 11100110b = 11110111b
-00010001b | 11100111b = 11110111b
-00010001b | 11101000b = 11111001b
-00010001b | 11101001b = 11111001b
-00010001b | 11101010b = 11111011b
-00010001b | 11101011b = 11111011b
-00010001b | 11101100b = 11111101b
-00010001b | 11101101b = 11111101b
-00010001b | 11101110b = 11111111b
-00010001b | 11101111b = 11111111b
-00010001b | 11110000b = 11110001b
-00010001b | 11110001b = 11110001b
-00010001b | 11110010b = 11110011b
-00010001b | 11110011b = 11110011b
-00010001b | 11110100b = 11110101b
-00010001b | 11110101b = 11110101b
-00010001b | 11110110b = 11110111b
-00010001b | 11110111b = 11110111b
-00010001b | 11111000b = 11111001b
-00010001b | 11111001b = 11111001b
-00010001b | 11111010b = 11111011b
-00010001b | 11111011b = 11111011b
-00010001b | 11111100b = 11111101b
-00010001b | 11111101b = 11111101b
-00010001b | 11111110b = 11111111b
-00010001b | 11111111b = 11111111b
-00010001b | 00000000b = 00010001b
-00010001b | 00000001b = 00010001b
-00010001b | 00000010b = 00010011b
-00010001b | 00000011b = 00010011b
-00010001b | 00000100b = 00010101b
-00010001b | 00000101b = 00010101b
-00010001b | 00000110b = 00010111b
-00010001b | 00000111b = 00010111b
-00010001b | 00001000b = 00011001b
-00010001b | 00001001b = 00011001b
-00010001b | 00001010b = 00011011b
-00010001b | 00001011b = 00011011b
-00010001b | 00001100b = 00011101b
-00010001b | 00001101b = 00011101b
-00010001b | 00001110b = 00011111b
-00010001b | 00001111b = 00011111b
-00010001b | 00010000b = 00010001b
-00010001b | 00010001b = 00010001b
-00010001b | 00010010b = 00010011b
-00010001b | 00010011b = 00010011b
-00010001b | 00010100b = 00010101b
-00010001b | 00010101b = 00010101b
-00010001b | 00010110b = 00010111b
-00010001b | 00010111b = 00010111b
-00010001b | 00011000b = 00011001b
-00010001b | 00011001b = 00011001b
-00010001b | 00011010b = 00011011b
-00010001b | 00011011b = 00011011b
-00010001b | 00011100b = 00011101b
-00010001b | 00011101b = 00011101b
-00010001b | 00011110b = 00011111b
-00010001b | 00011111b = 00011111b
-00010001b | 00100000b = 00110001b
-00010001b | 00100001b = 00110001b
-00010001b | 00100010b = 00110011b
-00010001b | 00100011b = 00110011b
-00010001b | 00100100b = 00110101b
-00010001b | 00100101b = 00110101b
-00010001b | 00100110b = 00110111b
-00010001b | 00100111b = 00110111b
-00010001b | 00101000b = 00111001b
-00010001b | 00101001b = 00111001b
-00010001b | 00101010b = 00111011b
-00010001b | 00101011b = 00111011b
-00010001b | 00101100b = 00111101b
-00010001b | 00101101b = 00111101b
-00010001b | 00101110b = 00111111b
-00010001b | 00101111b = 00111111b
-00010001b | 00110000b = 00110001b
-00010001b | 00110001b = 00110001b
-00010001b | 00110010b = 00110011b
-00010001b | 00110011b = 00110011b
-00010001b | 00110100b = 00110101b
-00010001b | 00110101b = 00110101b
-00010001b | 00110110b = 00110111b
-00010001b | 00110111b = 00110111b
-00010001b | 00111000b = 00111001b
-00010001b | 00111001b = 00111001b
-00010001b | 00111010b = 00111011b
-00010001b | 00111011b = 00111011b
-00010001b | 00111100b = 00111101b
-00010001b | 00111101b = 00111101b
-00010001b | 00111110b = 00111111b
-00010001b | 00111111b = 00111111b
-00010001b | 01000000b = 01010001b
-00010001b | 01000001b = 01010001b
-00010001b | 01000010b = 01010011b
-00010001b | 01000011b = 01010011b
-00010001b | 01000100b = 01010101b
-00010001b | 01000101b = 01010101b
-00010001b | 01000110b = 01010111b
-00010001b | 01000111b = 01010111b
-00010001b | 01001000b = 01011001b
-00010001b | 01001001b = 01011001b
-00010001b | 01001010b = 01011011b
-00010001b | 01001011b = 01011011b
-00010001b | 01001100b = 01011101b
-00010001b | 01001101b = 01011101b
-00010001b | 01001110b = 01011111b
-00010001b | 01001111b = 01011111b
-00010001b | 01010000b = 01010001b
-00010001b | 01010001b = 01010001b
-00010001b | 01010010b = 01010011b
-00010001b | 01010011b = 01010011b
-00010001b | 01010100b = 01010101b
-00010001b | 01010101b = 01010101b
-00010001b | 01010110b = 01010111b
-00010001b | 01010111b = 01010111b
-00010001b | 01011000b = 01011001b
-00010001b | 01011001b = 01011001b
-00010001b | 01011010b = 01011011b
-00010001b | 01011011b = 01011011b
-00010001b | 01011100b = 01011101b
-00010001b | 01011101b = 01011101b
-00010001b | 01011110b = 01011111b
-00010001b | 01011111b = 01011111b
-00010001b | 01100000b = 01110001b
-00010001b | 01100001b = 01110001b
-00010001b | 01100010b = 01110011b
-00010001b | 01100011b = 01110011b
-00010001b | 01100100b = 01110101b
-00010001b | 01100101b = 01110101b
-00010001b | 01100110b = 01110111b
-00010001b | 01100111b = 01110111b
-00010001b | 01101000b = 01111001b
-00010001b | 01101001b = 01111001b
-00010001b | 01101010b = 01111011b
-00010001b | 01101011b = 01111011b
-00010001b | 01101100b = 01111101b
-00010001b | 01101101b = 01111101b
-00010001b | 01101110b = 01111111b
-00010001b | 01101111b = 01111111b
-00010001b | 01110000b = 01110001b
-00010001b | 01110001b = 01110001b
-00010001b | 01110010b = 01110011b
-00010001b | 01110011b = 01110011b
-00010001b | 01110100b = 01110101b
-00010001b | 01110101b = 01110101b
-00010001b | 01110110b = 01110111b
-00010001b | 01110111b = 01110111b
-00010001b | 01111000b = 01111001b
-00010001b | 01111001b = 01111001b
-00010001b | 01111010b = 01111011b
-00010001b | 01111011b = 01111011b
-00010001b | 01111100b = 01111101b
-00010001b | 01111101b = 01111101b
-00010001b | 01111110b = 01111111b
-00010010b | 10000000b = 10010010b
-00010010b | 10000001b = 10010011b
-00010010b | 10000010b = 10010010b
-00010010b | 10000011b = 10010011b
-00010010b | 10000100b = 10010110b
-00010010b | 10000101b = 10010111b
-00010010b | 10000110b = 10010110b
-00010010b | 10000111b = 10010111b
-00010010b | 10001000b = 10011010b
-00010010b | 10001001b = 10011011b
-00010010b | 10001010b = 10011010b
-00010010b | 10001011b = 10011011b
-00010010b | 10001100b = 10011110b
-00010010b | 10001101b = 10011111b
-00010010b | 10001110b = 10011110b
-00010010b | 10001111b = 10011111b
-00010010b | 10010000b = 10010010b
-00010010b | 10010001b = 10010011b
-00010010b | 10010010b = 10010010b
-00010010b | 10010011b = 10010011b
-00010010b | 10010100b = 10010110b
-00010010b | 10010101b = 10010111b
-00010010b | 10010110b = 10010110b
-00010010b | 10010111b = 10010111b
-00010010b | 10011000b = 10011010b
-00010010b | 10011001b = 10011011b
-00010010b | 10011010b = 10011010b
-00010010b | 10011011b = 10011011b
-00010010b | 10011100b = 10011110b
-00010010b | 10011101b = 10011111b
-00010010b | 10011110b = 10011110b
-00010010b | 10011111b = 10011111b
-00010010b | 10100000b = 10110010b
-00010010b | 10100001b = 10110011b
-00010010b | 10100010b = 10110010b
-00010010b | 10100011b = 10110011b
-00010010b | 10100100b = 10110110b
-00010010b | 10100101b = 10110111b
-00010010b | 10100110b = 10110110b
-00010010b | 10100111b = 10110111b
-00010010b | 10101000b = 10111010b
-00010010b | 10101001b = 10111011b
-00010010b | 10101010b = 10111010b
-00010010b | 10101011b = 10111011b
-00010010b | 10101100b = 10111110b
-00010010b | 10101101b = 10111111b
-00010010b | 10101110b = 10111110b
-00010010b | 10101111b = 10111111b
-00010010b | 10110000b = 10110010b
-00010010b | 10110001b = 10110011b
-00010010b | 10110010b = 10110010b
-00010010b | 10110011b = 10110011b
-00010010b | 10110100b = 10110110b
-00010010b | 10110101b = 10110111b
-00010010b | 10110110b = 10110110b
-00010010b | 10110111b = 10110111b
-00010010b | 10111000b = 10111010b
-00010010b | 10111001b = 10111011b
-00010010b | 10111010b = 10111010b
-00010010b | 10111011b = 10111011b
-00010010b | 10111100b = 10111110b
-00010010b | 10111101b = 10111111b
-00010010b | 10111110b = 10111110b
-00010010b | 10111111b = 10111111b
-00010010b | 11000000b = 11010010b
-00010010b | 11000001b = 11010011b
-00010010b | 11000010b = 11010010b
-00010010b | 11000011b = 11010011b
-00010010b | 11000100b = 11010110b
-00010010b | 11000101b = 11010111b
-00010010b | 11000110b = 11010110b
-00010010b | 11000111b = 11010111b
-00010010b | 11001000b = 11011010b
-00010010b | 11001001b = 11011011b
-00010010b | 11001010b = 11011010b
-00010010b | 11001011b = 11011011b
-00010010b | 11001100b = 11011110b
-00010010b | 11001101b = 11011111b
-00010010b | 11001110b = 11011110b
-00010010b | 11001111b = 11011111b
-00010010b | 11010000b = 11010010b
-00010010b | 11010001b = 11010011b
-00010010b | 11010010b = 11010010b
-00010010b | 11010011b = 11010011b
-00010010b | 11010100b = 11010110b
-00010010b | 11010101b = 11010111b
-00010010b | 11010110b = 11010110b
-00010010b | 11010111b = 11010111b
-00010010b | 11011000b = 11011010b
-00010010b | 11011001b = 11011011b
-00010010b | 11011010b = 11011010b
-00010010b | 11011011b = 11011011b
-00010010b | 11011100b = 11011110b
-00010010b | 11011101b = 11011111b
-00010010b | 11011110b = 11011110b
-00010010b | 11011111b = 11011111b
-00010010b | 11100000b = 11110010b
-00010010b | 11100001b = 11110011b
-00010010b | 11100010b = 11110010b
-00010010b | 11100011b = 11110011b
-00010010b | 11100100b = 11110110b
-00010010b | 11100101b = 11110111b
-00010010b | 11100110b = 11110110b
-00010010b | 11100111b = 11110111b
-00010010b | 11101000b = 11111010b
-00010010b | 11101001b = 11111011b
-00010010b | 11101010b = 11111010b
-00010010b | 11101011b = 11111011b
-00010010b | 11101100b = 11111110b
-00010010b | 11101101b = 11111111b
-00010010b | 11101110b = 11111110b
-00010010b | 11101111b = 11111111b
-00010010b | 11110000b = 11110010b
-00010010b | 11110001b = 11110011b
-00010010b | 11110010b = 11110010b
-00010010b | 11110011b = 11110011b
-00010010b | 11110100b = 11110110b
-00010010b | 11110101b = 11110111b
-00010010b | 11110110b = 11110110b
-00010010b | 11110111b = 11110111b
-00010010b | 11111000b = 11111010b
-00010010b | 11111001b = 11111011b
-00010010b | 11111010b = 11111010b
-00010010b | 11111011b = 11111011b
-00010010b | 11111100b = 11111110b
-00010010b | 11111101b = 11111111b
-00010010b | 11111110b = 11111110b
-00010010b | 11111111b = 11111111b
-00010010b | 00000000b = 00010010b
-00010010b | 00000001b = 00010011b
-00010010b | 00000010b = 00010010b
-00010010b | 00000011b = 00010011b
-00010010b | 00000100b = 00010110b
-00010010b | 00000101b = 00010111b
-00010010b | 00000110b = 00010110b
-00010010b | 00000111b = 00010111b
-00010010b | 00001000b = 00011010b
-00010010b | 00001001b = 00011011b
-00010010b | 00001010b = 00011010b
-00010010b | 00001011b = 00011011b
-00010010b | 00001100b = 00011110b
-00010010b | 00001101b = 00011111b
-00010010b | 00001110b = 00011110b
-00010010b | 00001111b = 00011111b
-00010010b | 00010000b = 00010010b
-00010010b | 00010001b = 00010011b
-00010010b | 00010010b = 00010010b
-00010010b | 00010011b = 00010011b
-00010010b | 00010100b = 00010110b
-00010010b | 00010101b = 00010111b
-00010010b | 00010110b = 00010110b
-00010010b | 00010111b = 00010111b
-00010010b | 00011000b = 00011010b
-00010010b | 00011001b = 00011011b
-00010010b | 00011010b = 00011010b
-00010010b | 00011011b = 00011011b
-00010010b | 00011100b = 00011110b
-00010010b | 00011101b = 00011111b
-00010010b | 00011110b = 00011110b
-00010010b | 00011111b = 00011111b
-00010010b | 00100000b = 00110010b
-00010010b | 00100001b = 00110011b
-00010010b | 00100010b = 00110010b
-00010010b | 00100011b = 00110011b
-00010010b | 00100100b = 00110110b
-00010010b | 00100101b = 00110111b
-00010010b | 00100110b = 00110110b
-00010010b | 00100111b = 00110111b
-00010010b | 00101000b = 00111010b
-00010010b | 00101001b = 00111011b
-00010010b | 00101010b = 00111010b
-00010010b | 00101011b = 00111011b
-00010010b | 00101100b = 00111110b
-00010010b | 00101101b = 00111111b
-00010010b | 00101110b = 00111110b
-00010010b | 00101111b = 00111111b
-00010010b | 00110000b = 00110010b
-00010010b | 00110001b = 00110011b
-00010010b | 00110010b = 00110010b
-00010010b | 00110011b = 00110011b
-00010010b | 00110100b = 00110110b
-00010010b | 00110101b = 00110111b
-00010010b | 00110110b = 00110110b
-00010010b | 00110111b = 00110111b
-00010010b | 00111000b = 00111010b
-00010010b | 00111001b = 00111011b
-00010010b | 00111010b = 00111010b
-00010010b | 00111011b = 00111011b
-00010010b | 00111100b = 00111110b
-00010010b | 00111101b = 00111111b
-00010010b | 00111110b = 00111110b
-00010010b | 00111111b = 00111111b
-00010010b | 01000000b = 01010010b
-00010010b | 01000001b = 01010011b
-00010010b | 01000010b = 01010010b
-00010010b | 01000011b = 01010011b
-00010010b | 01000100b = 01010110b
-00010010b | 01000101b = 01010111b
-00010010b | 01000110b = 01010110b
-00010010b | 01000111b = 01010111b
-00010010b | 01001000b = 01011010b
-00010010b | 01001001b = 01011011b
-00010010b | 01001010b = 01011010b
-00010010b | 01001011b = 01011011b
-00010010b | 01001100b = 01011110b
-00010010b | 01001101b = 01011111b
-00010010b | 01001110b = 01011110b
-00010010b | 01001111b = 01011111b
-00010010b | 01010000b = 01010010b
-00010010b | 01010001b = 01010011b
-00010010b | 01010010b = 01010010b
-00010010b | 01010011b = 01010011b
-00010010b | 01010100b = 01010110b
-00010010b | 01010101b = 01010111b
-00010010b | 01010110b = 01010110b
-00010010b | 01010111b = 01010111b
-00010010b | 01011000b = 01011010b
-00010010b | 01011001b = 01011011b
-00010010b | 01011010b = 01011010b
-00010010b | 01011011b = 01011011b
-00010010b | 01011100b = 01011110b
-00010010b | 01011101b = 01011111b
-00010010b | 01011110b = 01011110b
-00010010b | 01011111b = 01011111b
-00010010b | 01100000b = 01110010b
-00010010b | 01100001b = 01110011b
-00010010b | 01100010b = 01110010b
-00010010b | 01100011b = 01110011b
-00010010b | 01100100b = 01110110b
-00010010b | 01100101b = 01110111b
-00010010b | 01100110b = 01110110b
-00010010b | 01100111b = 01110111b
-00010010b | 01101000b = 01111010b
-00010010b | 01101001b = 01111011b
-00010010b | 01101010b = 01111010b
-00010010b | 01101011b = 01111011b
-00010010b | 01101100b = 01111110b
-00010010b | 01101101b = 01111111b
-00010010b | 01101110b = 01111110b
-00010010b | 01101111b = 01111111b
-00010010b | 01110000b = 01110010b
-00010010b | 01110001b = 01110011b
-00010010b | 01110010b = 01110010b
-00010010b | 01110011b = 01110011b
-00010010b | 01110100b = 01110110b
-00010010b | 01110101b = 01110111b
-00010010b | 01110110b = 01110110b
-00010010b | 01110111b = 01110111b
-00010010b | 01111000b = 01111010b
-00010010b | 01111001b = 01111011b
-00010010b | 01111010b = 01111010b
-00010010b | 01111011b = 01111011b
-00010010b | 01111100b = 01111110b
-00010010b | 01111101b = 01111111b
-00010010b | 01111110b = 01111110b
-00010011b | 10000000b = 10010011b
-00010011b | 10000001b = 10010011b
-00010011b | 10000010b = 10010011b
-00010011b | 10000011b = 10010011b
-00010011b | 10000100b = 10010111b
-00010011b | 10000101b = 10010111b
-00010011b | 10000110b = 10010111b
-00010011b | 10000111b = 10010111b
-00010011b | 10001000b = 10011011b
-00010011b | 10001001b = 10011011b
-00010011b | 10001010b = 10011011b
-00010011b | 10001011b = 10011011b
-00010011b | 10001100b = 10011111b
-00010011b | 10001101b = 10011111b
-00010011b | 10001110b = 10011111b
-00010011b | 10001111b = 10011111b
-00010011b | 10010000b = 10010011b
-00010011b | 10010001b = 10010011b
-00010011b | 10010010b = 10010011b
-00010011b | 10010011b = 10010011b
-00010011b | 10010100b = 10010111b
-00010011b | 10010101b = 10010111b
-00010011b | 10010110b = 10010111b
-00010011b | 10010111b = 10010111b
-00010011b | 10011000b = 10011011b
-00010011b | 10011001b = 10011011b
-00010011b | 10011010b = 10011011b
-00010011b | 10011011b = 10011011b
-00010011b | 10011100b = 10011111b
-00010011b | 10011101b = 10011111b
-00010011b | 10011110b = 10011111b
-00010011b | 10011111b = 10011111b
-00010011b | 10100000b = 10110011b
-00010011b | 10100001b = 10110011b
-00010011b | 10100010b = 10110011b
-00010011b | 10100011b = 10110011b
-00010011b | 10100100b = 10110111b
-00010011b | 10100101b = 10110111b
-00010011b | 10100110b = 10110111b
-00010011b | 10100111b = 10110111b
-00010011b | 10101000b = 10111011b
-00010011b | 10101001b = 10111011b
-00010011b | 10101010b = 10111011b
-00010011b | 10101011b = 10111011b
-00010011b | 10101100b = 10111111b
-00010011b | 10101101b = 10111111b
-00010011b | 10101110b = 10111111b
-00010011b | 10101111b = 10111111b
-00010011b | 10110000b = 10110011b
-00010011b | 10110001b = 10110011b
-00010011b | 10110010b = 10110011b
-00010011b | 10110011b = 10110011b
-00010011b | 10110100b = 10110111b
-00010011b | 10110101b = 10110111b
-00010011b | 10110110b = 10110111b
-00010011b | 10110111b = 10110111b
-00010011b | 10111000b = 10111011b
-00010011b | 10111001b = 10111011b
-00010011b | 10111010b = 10111011b
-00010011b | 10111011b = 10111011b
-00010011b | 10111100b = 10111111b
-00010011b | 10111101b = 10111111b
-00010011b | 10111110b = 10111111b
-00010011b | 10111111b = 10111111b
-00010011b | 11000000b = 11010011b
-00010011b | 11000001b = 11010011b
-00010011b | 11000010b = 11010011b
-00010011b | 11000011b = 11010011b
-00010011b | 11000100b = 11010111b
-00010011b | 11000101b = 11010111b
-00010011b | 11000110b = 11010111b
-00010011b | 11000111b = 11010111b
-00010011b | 11001000b = 11011011b
-00010011b | 11001001b = 11011011b
-00010011b | 11001010b = 11011011b
-00010011b | 11001011b = 11011011b
-00010011b | 11001100b = 11011111b
-00010011b | 11001101b = 11011111b
-00010011b | 11001110b = 11011111b
-00010011b | 11001111b = 11011111b
-00010011b | 11010000b = 11010011b
-00010011b | 11010001b = 11010011b
-00010011b | 11010010b = 11010011b
-00010011b | 11010011b = 11010011b
-00010011b | 11010100b = 11010111b
-00010011b | 11010101b = 11010111b
-00010011b | 11010110b = 11010111b
-00010011b | 11010111b = 11010111b
-00010011b | 11011000b = 11011011b
-00010011b | 11011001b = 11011011b
-00010011b | 11011010b = 11011011b
-00010011b | 11011011b = 11011011b
-00010011b | 11011100b = 11011111b
-00010011b | 11011101b = 11011111b
-00010011b | 11011110b = 11011111b
-00010011b | 11011111b = 11011111b
-00010011b | 11100000b = 11110011b
-00010011b | 11100001b = 11110011b
-00010011b | 11100010b = 11110011b
-00010011b | 11100011b = 11110011b
-00010011b | 11100100b = 11110111b
-00010011b | 11100101b = 11110111b
-00010011b | 11100110b = 11110111b
-00010011b | 11100111b = 11110111b
-00010011b | 11101000b = 11111011b
-00010011b | 11101001b = 11111011b
-00010011b | 11101010b = 11111011b
-00010011b | 11101011b = 11111011b
-00010011b | 11101100b = 11111111b
-00010011b | 11101101b = 11111111b
-00010011b | 11101110b = 11111111b
-00010011b | 11101111b = 11111111b
-00010011b | 11110000b = 11110011b
-00010011b | 11110001b = 11110011b
-00010011b | 11110010b = 11110011b
-00010011b | 11110011b = 11110011b
-00010011b | 11110100b = 11110111b
-00010011b | 11110101b = 11110111b
-00010011b | 11110110b = 11110111b
-00010011b | 11110111b = 11110111b
-00010011b | 11111000b = 11111011b
-00010011b | 11111001b = 11111011b
-00010011b | 11111010b = 11111011b
-00010011b | 11111011b = 11111011b
-00010011b | 11111100b = 11111111b
-00010011b | 11111101b = 11111111b
-00010011b | 11111110b = 11111111b
-00010011b | 11111111b = 11111111b
-00010011b | 00000000b = 00010011b
-00010011b | 00000001b = 00010011b
-00010011b | 00000010b = 00010011b
-00010011b | 00000011b = 00010011b
-00010011b | 00000100b = 00010111b
-00010011b | 00000101b = 00010111b
-00010011b | 00000110b = 00010111b
-00010011b | 00000111b = 00010111b
-00010011b | 00001000b = 00011011b
-00010011b | 00001001b = 00011011b
-00010011b | 00001010b = 00011011b
-00010011b | 00001011b = 00011011b
-00010011b | 00001100b = 00011111b
-00010011b | 00001101b = 00011111b
-00010011b | 00001110b = 00011111b
-00010011b | 00001111b = 00011111b
-00010011b | 00010000b = 00010011b
-00010011b | 00010001b = 00010011b
-00010011b | 00010010b = 00010011b
-00010011b | 00010011b = 00010011b
-00010011b | 00010100b = 00010111b
-00010011b | 00010101b = 00010111b
-00010011b | 00010110b = 00010111b
-00010011b | 00010111b = 00010111b
-00010011b | 00011000b = 00011011b
-00010011b | 00011001b = 00011011b
-00010011b | 00011010b = 00011011b
-00010011b | 00011011b = 00011011b
-00010011b | 00011100b = 00011111b
-00010011b | 00011101b = 00011111b
-00010011b | 00011110b = 00011111b
-00010011b | 00011111b = 00011111b
-00010011b | 00100000b = 00110011b
-00010011b | 00100001b = 00110011b
-00010011b | 00100010b = 00110011b
-00010011b | 00100011b = 00110011b
-00010011b | 00100100b = 00110111b
-00010011b | 00100101b = 00110111b
-00010011b | 00100110b = 00110111b
-00010011b | 00100111b = 00110111b
-00010011b | 00101000b = 00111011b
-00010011b | 00101001b = 00111011b
-00010011b | 00101010b = 00111011b
-00010011b | 00101011b = 00111011b
-00010011b | 00101100b = 00111111b
-00010011b | 00101101b = 00111111b
-00010011b | 00101110b = 00111111b
-00010011b | 00101111b = 00111111b
-00010011b | 00110000b = 00110011b
-00010011b | 00110001b = 00110011b
-00010011b | 00110010b = 00110011b
-00010011b | 00110011b = 00110011b
-00010011b | 00110100b = 00110111b
-00010011b | 00110101b = 00110111b
-00010011b | 00110110b = 00110111b
-00010011b | 00110111b = 00110111b
-00010011b | 00111000b = 00111011b
-00010011b | 00111001b = 00111011b
-00010011b | 00111010b = 00111011b
-00010011b | 00111011b = 00111011b
-00010011b | 00111100b = 00111111b
-00010011b | 00111101b = 00111111b
-00010011b | 00111110b = 00111111b
-00010011b | 00111111b = 00111111b
-00010011b | 01000000b = 01010011b
-00010011b | 01000001b = 01010011b
-00010011b | 01000010b = 01010011b
-00010011b | 01000011b = 01010011b
-00010011b | 01000100b = 01010111b
-00010011b | 01000101b = 01010111b
-00010011b | 01000110b = 01010111b
-00010011b | 01000111b = 01010111b
-00010011b | 01001000b = 01011011b
-00010011b | 01001001b = 01011011b
-00010011b | 01001010b = 01011011b
-00010011b | 01001011b = 01011011b
-00010011b | 01001100b = 01011111b
-00010011b | 01001101b = 01011111b
-00010011b | 01001110b = 01011111b
-00010011b | 01001111b = 01011111b
-00010011b | 01010000b = 01010011b
-00010011b | 01010001b = 01010011b
-00010011b | 01010010b = 01010011b
-00010011b | 01010011b = 01010011b
-00010011b | 01010100b = 01010111b
-00010011b | 01010101b = 01010111b
-00010011b | 01010110b = 01010111b
-00010011b | 01010111b = 01010111b
-00010011b | 01011000b = 01011011b
-00010011b | 01011001b = 01011011b
-00010011b | 01011010b = 01011011b
-00010011b | 01011011b = 01011011b
-00010011b | 01011100b = 01011111b
-00010011b | 01011101b = 01011111b
-00010011b | 01011110b = 01011111b
-00010011b | 01011111b = 01011111b
-00010011b | 01100000b = 01110011b
-00010011b | 01100001b = 01110011b
-00010011b | 01100010b = 01110011b
-00010011b | 01100011b = 01110011b
-00010011b | 01100100b = 01110111b
-00010011b | 01100101b = 01110111b
-00010011b | 01100110b = 01110111b
-00010011b | 01100111b = 01110111b
-00010011b | 01101000b = 01111011b
-00010011b | 01101001b = 01111011b
-00010011b | 01101010b = 01111011b
-00010011b | 01101011b = 01111011b
-00010011b | 01101100b = 01111111b
-00010011b | 01101101b = 01111111b
-00010011b | 01101110b = 01111111b
-00010011b | 01101111b = 01111111b
-00010011b | 01110000b = 01110011b
-00010011b | 01110001b = 01110011b
-00010011b | 01110010b = 01110011b
-00010011b | 01110011b = 01110011b
-00010011b | 01110100b = 01110111b
-00010011b | 01110101b = 01110111b
-00010011b | 01110110b = 01110111b
-00010011b | 01110111b = 01110111b
-00010011b | 01111000b = 01111011b
-00010011b | 01111001b = 01111011b
-00010011b | 01111010b = 01111011b
-00010011b | 01111011b = 01111011b
-00010011b | 01111100b = 01111111b
-00010011b | 01111101b = 01111111b
-00010011b | 01111110b = 01111111b
-00010100b | 10000000b = 10010100b
-00010100b | 10000001b = 10010101b
-00010100b | 10000010b = 10010110b
-00010100b | 10000011b = 10010111b
-00010100b | 10000100b = 10010100b
-00010100b | 10000101b = 10010101b
-00010100b | 10000110b = 10010110b
-00010100b | 10000111b = 10010111b
-00010100b | 10001000b = 10011100b
-00010100b | 10001001b = 10011101b
-00010100b | 10001010b = 10011110b
-00010100b | 10001011b = 10011111b
-00010100b | 10001100b = 10011100b
-00010100b | 10001101b = 10011101b
-00010100b | 10001110b = 10011110b
-00010100b | 10001111b = 10011111b
-00010100b | 10010000b = 10010100b
-00010100b | 10010001b = 10010101b
-00010100b | 10010010b = 10010110b
-00010100b | 10010011b = 10010111b
-00010100b | 10010100b = 10010100b
-00010100b | 10010101b = 10010101b
-00010100b | 10010110b = 10010110b
-00010100b | 10010111b = 10010111b
-00010100b | 10011000b = 10011100b
-00010100b | 10011001b = 10011101b
-00010100b | 10011010b = 10011110b
-00010100b | 10011011b = 10011111b
-00010100b | 10011100b = 10011100b
-00010100b | 10011101b = 10011101b
-00010100b | 10011110b = 10011110b
-00010100b | 10011111b = 10011111b
-00010100b | 10100000b = 10110100b
-00010100b | 10100001b = 10110101b
-00010100b | 10100010b = 10110110b
-00010100b | 10100011b = 10110111b
-00010100b | 10100100b = 10110100b
-00010100b | 10100101b = 10110101b
-00010100b | 10100110b = 10110110b
-00010100b | 10100111b = 10110111b
-00010100b | 10101000b = 10111100b
-00010100b | 10101001b = 10111101b
-00010100b | 10101010b = 10111110b
-00010100b | 10101011b = 10111111b
-00010100b | 10101100b = 10111100b
-00010100b | 10101101b = 10111101b
-00010100b | 10101110b = 10111110b
-00010100b | 10101111b = 10111111b
-00010100b | 10110000b = 10110100b
-00010100b | 10110001b = 10110101b
-00010100b | 10110010b = 10110110b
-00010100b | 10110011b = 10110111b
-00010100b | 10110100b = 10110100b
-00010100b | 10110101b = 10110101b
-00010100b | 10110110b = 10110110b
-00010100b | 10110111b = 10110111b
-00010100b | 10111000b = 10111100b
-00010100b | 10111001b = 10111101b
-00010100b | 10111010b = 10111110b
-00010100b | 10111011b = 10111111b
-00010100b | 10111100b = 10111100b
-00010100b | 10111101b = 10111101b
-00010100b | 10111110b = 10111110b
-00010100b | 10111111b = 10111111b
-00010100b | 11000000b = 11010100b
-00010100b | 11000001b = 11010101b
-00010100b | 11000010b = 11010110b
-00010100b | 11000011b = 11010111b
-00010100b | 11000100b = 11010100b
-00010100b | 11000101b = 11010101b
-00010100b | 11000110b = 11010110b
-00010100b | 11000111b = 11010111b
-00010100b | 11001000b = 11011100b
-00010100b | 11001001b = 11011101b
-00010100b | 11001010b = 11011110b
-00010100b | 11001011b = 11011111b
-00010100b | 11001100b = 11011100b
-00010100b | 11001101b = 11011101b
-00010100b | 11001110b = 11011110b
-00010100b | 11001111b = 11011111b
-00010100b | 11010000b = 11010100b
-00010100b | 11010001b = 11010101b
-00010100b | 11010010b = 11010110b
-00010100b | 11010011b = 11010111b
-00010100b | 11010100b = 11010100b
-00010100b | 11010101b = 11010101b
-00010100b | 11010110b = 11010110b
-00010100b | 11010111b = 11010111b
-00010100b | 11011000b = 11011100b
-00010100b | 11011001b = 11011101b
-00010100b | 11011010b = 11011110b
-00010100b | 11011011b = 11011111b
-00010100b | 11011100b = 11011100b
-00010100b | 11011101b = 11011101b
-00010100b | 11011110b = 11011110b
-00010100b | 11011111b = 11011111b
-00010100b | 11100000b = 11110100b
-00010100b | 11100001b = 11110101b
-00010100b | 11100010b = 11110110b
-00010100b | 11100011b = 11110111b
-00010100b | 11100100b = 11110100b
-00010100b | 11100101b = 11110101b
-00010100b | 11100110b = 11110110b
-00010100b | 11100111b = 11110111b
-00010100b | 11101000b = 11111100b
-00010100b | 11101001b = 11111101b
-00010100b | 11101010b = 11111110b
-00010100b | 11101011b = 11111111b
-00010100b | 11101100b = 11111100b
-00010100b | 11101101b = 11111101b
-00010100b | 11101110b = 11111110b
-00010100b | 11101111b = 11111111b
-00010100b | 11110000b = 11110100b
-00010100b | 11110001b = 11110101b
-00010100b | 11110010b = 11110110b
-00010100b | 11110011b = 11110111b
-00010100b | 11110100b = 11110100b
-00010100b | 11110101b = 11110101b
-00010100b | 11110110b = 11110110b
-00010100b | 11110111b = 11110111b
-00010100b | 11111000b = 11111100b
-00010100b | 11111001b = 11111101b
-00010100b | 11111010b = 11111110b
-00010100b | 11111011b = 11111111b
-00010100b | 11111100b = 11111100b
-00010100b | 11111101b = 11111101b
-00010100b | 11111110b = 11111110b
-00010100b | 11111111b = 11111111b
-00010100b | 00000000b = 00010100b
-00010100b | 00000001b = 00010101b
-00010100b | 00000010b = 00010110b
-00010100b | 00000011b = 00010111b
-00010100b | 00000100b = 00010100b
-00010100b | 00000101b = 00010101b
-00010100b | 00000110b = 00010110b
-00010100b | 00000111b = 00010111b
-00010100b | 00001000b = 00011100b
-00010100b | 00001001b = 00011101b
-00010100b | 00001010b = 00011110b
-00010100b | 00001011b = 00011111b
-00010100b | 00001100b = 00011100b
-00010100b | 00001101b = 00011101b
-00010100b | 00001110b = 00011110b
-00010100b | 00001111b = 00011111b
-00010100b | 00010000b = 00010100b
-00010100b | 00010001b = 00010101b
-00010100b | 00010010b = 00010110b
-00010100b | 00010011b = 00010111b
-00010100b | 00010100b = 00010100b
-00010100b | 00010101b = 00010101b
-00010100b | 00010110b = 00010110b
-00010100b | 00010111b = 00010111b
-00010100b | 00011000b = 00011100b
-00010100b | 00011001b = 00011101b
-00010100b | 00011010b = 00011110b
-00010100b | 00011011b = 00011111b
-00010100b | 00011100b = 00011100b
-00010100b | 00011101b = 00011101b
-00010100b | 00011110b = 00011110b
-00010100b | 00011111b = 00011111b
-00010100b | 00100000b = 00110100b
-00010100b | 00100001b = 00110101b
-00010100b | 00100010b = 00110110b
-00010100b | 00100011b = 00110111b
-00010100b | 00100100b = 00110100b
-00010100b | 00100101b = 00110101b
-00010100b | 00100110b = 00110110b
-00010100b | 00100111b = 00110111b
-00010100b | 00101000b = 00111100b
-00010100b | 00101001b = 00111101b
-00010100b | 00101010b = 00111110b
-00010100b | 00101011b = 00111111b
-00010100b | 00101100b = 00111100b
-00010100b | 00101101b = 00111101b
-00010100b | 00101110b = 00111110b
-00010100b | 00101111b = 00111111b
-00010100b | 00110000b = 00110100b
-00010100b | 00110001b = 00110101b
-00010100b | 00110010b = 00110110b
-00010100b | 00110011b = 00110111b
-00010100b | 00110100b = 00110100b
-00010100b | 00110101b = 00110101b
-00010100b | 00110110b = 00110110b
-00010100b | 00110111b = 00110111b
-00010100b | 00111000b = 00111100b
-00010100b | 00111001b = 00111101b
-00010100b | 00111010b = 00111110b
-00010100b | 00111011b = 00111111b
-00010100b | 00111100b = 00111100b
-00010100b | 00111101b = 00111101b
-00010100b | 00111110b = 00111110b
-00010100b | 00111111b = 00111111b
-00010100b | 01000000b = 01010100b
-00010100b | 01000001b = 01010101b
-00010100b | 01000010b = 01010110b
-00010100b | 01000011b = 01010111b
-00010100b | 01000100b = 01010100b
-00010100b | 01000101b = 01010101b
-00010100b | 01000110b = 01010110b
-00010100b | 01000111b = 01010111b
-00010100b | 01001000b = 01011100b
-00010100b | 01001001b = 01011101b
-00010100b | 01001010b = 01011110b
-00010100b | 01001011b = 01011111b
-00010100b | 01001100b = 01011100b
-00010100b | 01001101b = 01011101b
-00010100b | 01001110b = 01011110b
-00010100b | 01001111b = 01011111b
-00010100b | 01010000b = 01010100b
-00010100b | 01010001b = 01010101b
-00010100b | 01010010b = 01010110b
-00010100b | 01010011b = 01010111b
-00010100b | 01010100b = 01010100b
-00010100b | 01010101b = 01010101b
-00010100b | 01010110b = 01010110b
-00010100b | 01010111b = 01010111b
-00010100b | 01011000b = 01011100b
-00010100b | 01011001b = 01011101b
-00010100b | 01011010b = 01011110b
-00010100b | 01011011b = 01011111b
-00010100b | 01011100b = 01011100b
-00010100b | 01011101b = 01011101b
-00010100b | 01011110b = 01011110b
-00010100b | 01011111b = 01011111b
-00010100b | 01100000b = 01110100b
-00010100b | 01100001b = 01110101b
-00010100b | 01100010b = 01110110b
-00010100b | 01100011b = 01110111b
-00010100b | 01100100b = 01110100b
-00010100b | 01100101b = 01110101b
-00010100b | 01100110b = 01110110b
-00010100b | 01100111b = 01110111b
-00010100b | 01101000b = 01111100b
-00010100b | 01101001b = 01111101b
-00010100b | 01101010b = 01111110b
-00010100b | 01101011b = 01111111b
-00010100b | 01101100b = 01111100b
-00010100b | 01101101b = 01111101b
-00010100b | 01101110b = 01111110b
-00010100b | 01101111b = 01111111b
-00010100b | 01110000b = 01110100b
-00010100b | 01110001b = 01110101b
-00010100b | 01110010b = 01110110b
-00010100b | 01110011b = 01110111b
-00010100b | 01110100b = 01110100b
-00010100b | 01110101b = 01110101b
-00010100b | 01110110b = 01110110b
-00010100b | 01110111b = 01110111b
-00010100b | 01111000b = 01111100b
-00010100b | 01111001b = 01111101b
-00010100b | 01111010b = 01111110b
-00010100b | 01111011b = 01111111b
-00010100b | 01111100b = 01111100b
-00010100b | 01111101b = 01111101b
-00010100b | 01111110b = 01111110b
-00010101b | 10000000b = 10010101b
-00010101b | 10000001b = 10010101b
-00010101b | 10000010b = 10010111b
-00010101b | 10000011b = 10010111b
-00010101b | 10000100b = 10010101b
-00010101b | 10000101b = 10010101b
-00010101b | 10000110b = 10010111b
-00010101b | 10000111b = 10010111b
-00010101b | 10001000b = 10011101b
-00010101b | 10001001b = 10011101b
-00010101b | 10001010b = 10011111b
-00010101b | 10001011b = 10011111b
-00010101b | 10001100b = 10011101b
-00010101b | 10001101b = 10011101b
-00010101b | 10001110b = 10011111b
-00010101b | 10001111b = 10011111b
-00010101b | 10010000b = 10010101b
-00010101b | 10010001b = 10010101b
-00010101b | 10010010b = 10010111b
-00010101b | 10010011b = 10010111b
-00010101b | 10010100b = 10010101b
-00010101b | 10010101b = 10010101b
-00010101b | 10010110b = 10010111b
-00010101b | 10010111b = 10010111b
-00010101b | 10011000b = 10011101b
-00010101b | 10011001b = 10011101b
-00010101b | 10011010b = 10011111b
-00010101b | 10011011b = 10011111b
-00010101b | 10011100b = 10011101b
-00010101b | 10011101b = 10011101b
-00010101b | 10011110b = 10011111b
-00010101b | 10011111b = 10011111b
-00010101b | 10100000b = 10110101b
-00010101b | 10100001b = 10110101b
-00010101b | 10100010b = 10110111b
-00010101b | 10100011b = 10110111b
-00010101b | 10100100b = 10110101b
-00010101b | 10100101b = 10110101b
-00010101b | 10100110b = 10110111b
-00010101b | 10100111b = 10110111b
-00010101b | 10101000b = 10111101b
-00010101b | 10101001b = 10111101b
-00010101b | 10101010b = 10111111b
-00010101b | 10101011b = 10111111b
-00010101b | 10101100b = 10111101b
-00010101b | 10101101b = 10111101b
-00010101b | 10101110b = 10111111b
-00010101b | 10101111b = 10111111b
-00010101b | 10110000b = 10110101b
-00010101b | 10110001b = 10110101b
-00010101b | 10110010b = 10110111b
-00010101b | 10110011b = 10110111b
-00010101b | 10110100b = 10110101b
-00010101b | 10110101b = 10110101b
-00010101b | 10110110b = 10110111b
-00010101b | 10110111b = 10110111b
-00010101b | 10111000b = 10111101b
-00010101b | 10111001b = 10111101b
-00010101b | 10111010b = 10111111b
-00010101b | 10111011b = 10111111b
-00010101b | 10111100b = 10111101b
-00010101b | 10111101b = 10111101b
-00010101b | 10111110b = 10111111b
-00010101b | 10111111b = 10111111b
-00010101b | 11000000b = 11010101b
-00010101b | 11000001b = 11010101b
-00010101b | 11000010b = 11010111b
-00010101b | 11000011b = 11010111b
-00010101b | 11000100b = 11010101b
-00010101b | 11000101b = 11010101b
-00010101b | 11000110b = 11010111b
-00010101b | 11000111b = 11010111b
-00010101b | 11001000b = 11011101b
-00010101b | 11001001b = 11011101b
-00010101b | 11001010b = 11011111b
-00010101b | 11001011b = 11011111b
-00010101b | 11001100b = 11011101b
-00010101b | 11001101b = 11011101b
-00010101b | 11001110b = 11011111b
-00010101b | 11001111b = 11011111b
-00010101b | 11010000b = 11010101b
-00010101b | 11010001b = 11010101b
-00010101b | 11010010b = 11010111b
-00010101b | 11010011b = 11010111b
-00010101b | 11010100b = 11010101b
-00010101b | 11010101b = 11010101b
-00010101b | 11010110b = 11010111b
-00010101b | 11010111b = 11010111b
-00010101b | 11011000b = 11011101b
-00010101b | 11011001b = 11011101b
-00010101b | 11011010b = 11011111b
-00010101b | 11011011b = 11011111b
-00010101b | 11011100b = 11011101b
-00010101b | 11011101b = 11011101b
-00010101b | 11011110b = 11011111b
-00010101b | 11011111b = 11011111b
-00010101b | 11100000b = 11110101b
-00010101b | 11100001b = 11110101b
-00010101b | 11100010b = 11110111b
-00010101b | 11100011b = 11110111b
-00010101b | 11100100b = 11110101b
-00010101b | 11100101b = 11110101b
-00010101b | 11100110b = 11110111b
-00010101b | 11100111b = 11110111b
-00010101b | 11101000b = 11111101b
-00010101b | 11101001b = 11111101b
-00010101b | 11101010b = 11111111b
-00010101b | 11101011b = 11111111b
-00010101b | 11101100b = 11111101b
-00010101b | 11101101b = 11111101b
-00010101b | 11101110b = 11111111b
-00010101b | 11101111b = 11111111b
-00010101b | 11110000b = 11110101b
-00010101b | 11110001b = 11110101b
-00010101b | 11110010b = 11110111b
-00010101b | 11110011b = 11110111b
-00010101b | 11110100b = 11110101b
-00010101b | 11110101b = 11110101b
-00010101b | 11110110b = 11110111b
-00010101b | 11110111b = 11110111b
-00010101b | 11111000b = 11111101b
-00010101b | 11111001b = 11111101b
-00010101b | 11111010b = 11111111b
-00010101b | 11111011b = 11111111b
-00010101b | 11111100b = 11111101b
-00010101b | 11111101b = 11111101b
-00010101b | 11111110b = 11111111b
-00010101b | 11111111b = 11111111b
-00010101b | 00000000b = 00010101b
-00010101b | 00000001b = 00010101b
-00010101b | 00000010b = 00010111b
-00010101b | 00000011b = 00010111b
-00010101b | 00000100b = 00010101b
-00010101b | 00000101b = 00010101b
-00010101b | 00000110b = 00010111b
-00010101b | 00000111b = 00010111b
-00010101b | 00001000b = 00011101b
-00010101b | 00001001b = 00011101b
-00010101b | 00001010b = 00011111b
-00010101b | 00001011b = 00011111b
-00010101b | 00001100b = 00011101b
-00010101b | 00001101b = 00011101b
-00010101b | 00001110b = 00011111b
-00010101b | 00001111b = 00011111b
-00010101b | 00010000b = 00010101b
-00010101b | 00010001b = 00010101b
-00010101b | 00010010b = 00010111b
-00010101b | 00010011b = 00010111b
-00010101b | 00010100b = 00010101b
-00010101b | 00010101b = 00010101b
-00010101b | 00010110b = 00010111b
-00010101b | 00010111b = 00010111b
-00010101b | 00011000b = 00011101b
-00010101b | 00011001b = 00011101b
-00010101b | 00011010b = 00011111b
-00010101b | 00011011b = 00011111b
-00010101b | 00011100b = 00011101b
-00010101b | 00011101b = 00011101b
-00010101b | 00011110b = 00011111b
-00010101b | 00011111b = 00011111b
-00010101b | 00100000b = 00110101b
-00010101b | 00100001b = 00110101b
-00010101b | 00100010b = 00110111b
-00010101b | 00100011b = 00110111b
-00010101b | 00100100b = 00110101b
-00010101b | 00100101b = 00110101b
-00010101b | 00100110b = 00110111b
-00010101b | 00100111b = 00110111b
-00010101b | 00101000b = 00111101b
-00010101b | 00101001b = 00111101b
-00010101b | 00101010b = 00111111b
-00010101b | 00101011b = 00111111b
-00010101b | 00101100b = 00111101b
-00010101b | 00101101b = 00111101b
-00010101b | 00101110b = 00111111b
-00010101b | 00101111b = 00111111b
-00010101b | 00110000b = 00110101b
-00010101b | 00110001b = 00110101b
-00010101b | 00110010b = 00110111b
-00010101b | 00110011b = 00110111b
-00010101b | 00110100b = 00110101b
-00010101b | 00110101b = 00110101b
-00010101b | 00110110b = 00110111b
-00010101b | 00110111b = 00110111b
-00010101b | 00111000b = 00111101b
-00010101b | 00111001b = 00111101b
-00010101b | 00111010b = 00111111b
-00010101b | 00111011b = 00111111b
-00010101b | 00111100b = 00111101b
-00010101b | 00111101b = 00111101b
-00010101b | 00111110b = 00111111b
-00010101b | 00111111b = 00111111b
-00010101b | 01000000b = 01010101b
-00010101b | 01000001b = 01010101b
-00010101b | 01000010b = 01010111b
-00010101b | 01000011b = 01010111b
-00010101b | 01000100b = 01010101b
-00010101b | 01000101b = 01010101b
-00010101b | 01000110b = 01010111b
-00010101b | 01000111b = 01010111b
-00010101b | 01001000b = 01011101b
-00010101b | 01001001b = 01011101b
-00010101b | 01001010b = 01011111b
-00010101b | 01001011b = 01011111b
-00010101b | 01001100b = 01011101b
-00010101b | 01001101b = 01011101b
-00010101b | 01001110b = 01011111b
-00010101b | 01001111b = 01011111b
-00010101b | 01010000b = 01010101b
-00010101b | 01010001b = 01010101b
-00010101b | 01010010b = 01010111b
-00010101b | 01010011b = 01010111b
-00010101b | 01010100b = 01010101b
-00010101b | 01010101b = 01010101b
-00010101b | 01010110b = 01010111b
-00010101b | 01010111b = 01010111b
-00010101b | 01011000b = 01011101b
-00010101b | 01011001b = 01011101b
-00010101b | 01011010b = 01011111b
-00010101b | 01011011b = 01011111b
-00010101b | 01011100b = 01011101b
-00010101b | 01011101b = 01011101b
-00010101b | 01011110b = 01011111b
-00010101b | 01011111b = 01011111b
-00010101b | 01100000b = 01110101b
-00010101b | 01100001b = 01110101b
-00010101b | 01100010b = 01110111b
-00010101b | 01100011b = 01110111b
-00010101b | 01100100b = 01110101b
-00010101b | 01100101b = 01110101b
-00010101b | 01100110b = 01110111b
-00010101b | 01100111b = 01110111b
-00010101b | 01101000b = 01111101b
-00010101b | 01101001b = 01111101b
-00010101b | 01101010b = 01111111b
-00010101b | 01101011b = 01111111b
-00010101b | 01101100b = 01111101b
-00010101b | 01101101b = 01111101b
-00010101b | 01101110b = 01111111b
-00010101b | 01101111b = 01111111b
-00010101b | 01110000b = 01110101b
-00010101b | 01110001b = 01110101b
-00010101b | 01110010b = 01110111b
-00010101b | 01110011b = 01110111b
-00010101b | 01110100b = 01110101b
-00010101b | 01110101b = 01110101b
-00010101b | 01110110b = 01110111b
-00010101b | 01110111b = 01110111b
-00010101b | 01111000b = 01111101b
-00010101b | 01111001b = 01111101b
-00010101b | 01111010b = 01111111b
-00010101b | 01111011b = 01111111b
-00010101b | 01111100b = 01111101b
-00010101b | 01111101b = 01111101b
-00010101b | 01111110b = 01111111b
-00010110b | 10000000b = 10010110b
-00010110b | 10000001b = 10010111b
-00010110b | 10000010b = 10010110b
-00010110b | 10000011b = 10010111b
-00010110b | 10000100b = 10010110b
-00010110b | 10000101b = 10010111b
-00010110b | 10000110b = 10010110b
-00010110b | 10000111b = 10010111b
-00010110b | 10001000b = 10011110b
-00010110b | 10001001b = 10011111b
-00010110b | 10001010b = 10011110b
-00010110b | 10001011b = 10011111b
-00010110b | 10001100b = 10011110b
-00010110b | 10001101b = 10011111b
-00010110b | 10001110b = 10011110b
-00010110b | 10001111b = 10011111b
-00010110b | 10010000b = 10010110b
-00010110b | 10010001b = 10010111b
-00010110b | 10010010b = 10010110b
-00010110b | 10010011b = 10010111b
-00010110b | 10010100b = 10010110b
-00010110b | 10010101b = 10010111b
-00010110b | 10010110b = 10010110b
-00010110b | 10010111b = 10010111b
-00010110b | 10011000b = 10011110b
-00010110b | 10011001b = 10011111b
-00010110b | 10011010b = 10011110b
-00010110b | 10011011b = 10011111b
-00010110b | 10011100b = 10011110b
-00010110b | 10011101b = 10011111b
-00010110b | 10011110b = 10011110b
-00010110b | 10011111b = 10011111b
-00010110b | 10100000b = 10110110b
-00010110b | 10100001b = 10110111b
-00010110b | 10100010b = 10110110b
-00010110b | 10100011b = 10110111b
-00010110b | 10100100b = 10110110b
-00010110b | 10100101b = 10110111b
-00010110b | 10100110b = 10110110b
-00010110b | 10100111b = 10110111b
-00010110b | 10101000b = 10111110b
-00010110b | 10101001b = 10111111b
-00010110b | 10101010b = 10111110b
-00010110b | 10101011b = 10111111b
-00010110b | 10101100b = 10111110b
-00010110b | 10101101b = 10111111b
-00010110b | 10101110b = 10111110b
-00010110b | 10101111b = 10111111b
-00010110b | 10110000b = 10110110b
-00010110b | 10110001b = 10110111b
-00010110b | 10110010b = 10110110b
-00010110b | 10110011b = 10110111b
-00010110b | 10110100b = 10110110b
-00010110b | 10110101b = 10110111b
-00010110b | 10110110b = 10110110b
-00010110b | 10110111b = 10110111b
-00010110b | 10111000b = 10111110b
-00010110b | 10111001b = 10111111b
-00010110b | 10111010b = 10111110b
-00010110b | 10111011b = 10111111b
-00010110b | 10111100b = 10111110b
-00010110b | 10111101b = 10111111b
-00010110b | 10111110b = 10111110b
-00010110b | 10111111b = 10111111b
-00010110b | 11000000b = 11010110b
-00010110b | 11000001b = 11010111b
-00010110b | 11000010b = 11010110b
-00010110b | 11000011b = 11010111b
-00010110b | 11000100b = 11010110b
-00010110b | 11000101b = 11010111b
-00010110b | 11000110b = 11010110b
-00010110b | 11000111b = 11010111b
-00010110b | 11001000b = 11011110b
-00010110b | 11001001b = 11011111b
-00010110b | 11001010b = 11011110b
-00010110b | 11001011b = 11011111b
-00010110b | 11001100b = 11011110b
-00010110b | 11001101b = 11011111b
-00010110b | 11001110b = 11011110b
-00010110b | 11001111b = 11011111b
-00010110b | 11010000b = 11010110b
-00010110b | 11010001b = 11010111b
-00010110b | 11010010b = 11010110b
-00010110b | 11010011b = 11010111b
-00010110b | 11010100b = 11010110b
-00010110b | 11010101b = 11010111b
-00010110b | 11010110b = 11010110b
-00010110b | 11010111b = 11010111b
-00010110b | 11011000b = 11011110b
-00010110b | 11011001b = 11011111b
-00010110b | 11011010b = 11011110b
-00010110b | 11011011b = 11011111b
-00010110b | 11011100b = 11011110b
-00010110b | 11011101b = 11011111b
-00010110b | 11011110b = 11011110b
-00010110b | 11011111b = 11011111b
-00010110b | 11100000b = 11110110b
-00010110b | 11100001b = 11110111b
-00010110b | 11100010b = 11110110b
-00010110b | 11100011b = 11110111b
-00010110b | 11100100b = 11110110b
-00010110b | 11100101b = 11110111b
-00010110b | 11100110b = 11110110b
-00010110b | 11100111b = 11110111b
-00010110b | 11101000b = 11111110b
-00010110b | 11101001b = 11111111b
-00010110b | 11101010b = 11111110b
-00010110b | 11101011b = 11111111b
-00010110b | 11101100b = 11111110b
-00010110b | 11101101b = 11111111b
-00010110b | 11101110b = 11111110b
-00010110b | 11101111b = 11111111b
-00010110b | 11110000b = 11110110b
-00010110b | 11110001b = 11110111b
-00010110b | 11110010b = 11110110b
-00010110b | 11110011b = 11110111b
-00010110b | 11110100b = 11110110b
-00010110b | 11110101b = 11110111b
-00010110b | 11110110b = 11110110b
-00010110b | 11110111b = 11110111b
-00010110b | 11111000b = 11111110b
-00010110b | 11111001b = 11111111b
-00010110b | 11111010b = 11111110b
-00010110b | 11111011b = 11111111b
-00010110b | 11111100b = 11111110b
-00010110b | 11111101b = 11111111b
-00010110b | 11111110b = 11111110b
-00010110b | 11111111b = 11111111b
-00010110b | 00000000b = 00010110b
-00010110b | 00000001b = 00010111b
-00010110b | 00000010b = 00010110b
-00010110b | 00000011b = 00010111b
-00010110b | 00000100b = 00010110b
-00010110b | 00000101b = 00010111b
-00010110b | 00000110b = 00010110b
-00010110b | 00000111b = 00010111b
-00010110b | 00001000b = 00011110b
-00010110b | 00001001b = 00011111b
-00010110b | 00001010b = 00011110b
-00010110b | 00001011b = 00011111b
-00010110b | 00001100b = 00011110b
-00010110b | 00001101b = 00011111b
-00010110b | 00001110b = 00011110b
-00010110b | 00001111b = 00011111b
-00010110b | 00010000b = 00010110b
-00010110b | 00010001b = 00010111b
-00010110b | 00010010b = 00010110b
-00010110b | 00010011b = 00010111b
-00010110b | 00010100b = 00010110b
-00010110b | 00010101b = 00010111b
-00010110b | 00010110b = 00010110b
-00010110b | 00010111b = 00010111b
-00010110b | 00011000b = 00011110b
-00010110b | 00011001b = 00011111b
-00010110b | 00011010b = 00011110b
-00010110b | 00011011b = 00011111b
-00010110b | 00011100b = 00011110b
-00010110b | 00011101b = 00011111b
-00010110b | 00011110b = 00011110b
-00010110b | 00011111b = 00011111b
-00010110b | 00100000b = 00110110b
-00010110b | 00100001b = 00110111b
-00010110b | 00100010b = 00110110b
-00010110b | 00100011b = 00110111b
-00010110b | 00100100b = 00110110b
-00010110b | 00100101b = 00110111b
-00010110b | 00100110b = 00110110b
-00010110b | 00100111b = 00110111b
-00010110b | 00101000b = 00111110b
-00010110b | 00101001b = 00111111b
-00010110b | 00101010b = 00111110b
-00010110b | 00101011b = 00111111b
-00010110b | 00101100b = 00111110b
-00010110b | 00101101b = 00111111b
-00010110b | 00101110b = 00111110b
-00010110b | 00101111b = 00111111b
-00010110b | 00110000b = 00110110b
-00010110b | 00110001b = 00110111b
-00010110b | 00110010b = 00110110b
-00010110b | 00110011b = 00110111b
-00010110b | 00110100b = 00110110b
-00010110b | 00110101b = 00110111b
-00010110b | 00110110b = 00110110b
-00010110b | 00110111b = 00110111b
-00010110b | 00111000b = 00111110b
-00010110b | 00111001b = 00111111b
-00010110b | 00111010b = 00111110b
-00010110b | 00111011b = 00111111b
-00010110b | 00111100b = 00111110b
-00010110b | 00111101b = 00111111b
-00010110b | 00111110b = 00111110b
-00010110b | 00111111b = 00111111b
-00010110b | 01000000b = 01010110b
-00010110b | 01000001b = 01010111b
-00010110b | 01000010b = 01010110b
-00010110b | 01000011b = 01010111b
-00010110b | 01000100b = 01010110b
-00010110b | 01000101b = 01010111b
-00010110b | 01000110b = 01010110b
-00010110b | 01000111b = 01010111b
-00010110b | 01001000b = 01011110b
-00010110b | 01001001b = 01011111b
-00010110b | 01001010b = 01011110b
-00010110b | 01001011b = 01011111b
-00010110b | 01001100b = 01011110b
-00010110b | 01001101b = 01011111b
-00010110b | 01001110b = 01011110b
-00010110b | 01001111b = 01011111b
-00010110b | 01010000b = 01010110b
-00010110b | 01010001b = 01010111b
-00010110b | 01010010b = 01010110b
-00010110b | 01010011b = 01010111b
-00010110b | 01010100b = 01010110b
-00010110b | 01010101b = 01010111b
-00010110b | 01010110b = 01010110b
-00010110b | 01010111b = 01010111b
-00010110b | 01011000b = 01011110b
-00010110b | 01011001b = 01011111b
-00010110b | 01011010b = 01011110b
-00010110b | 01011011b = 01011111b
-00010110b | 01011100b = 01011110b
-00010110b | 01011101b = 01011111b
-00010110b | 01011110b = 01011110b
-00010110b | 01011111b = 01011111b
-00010110b | 01100000b = 01110110b
-00010110b | 01100001b = 01110111b
-00010110b | 01100010b = 01110110b
-00010110b | 01100011b = 01110111b
-00010110b | 01100100b = 01110110b
-00010110b | 01100101b = 01110111b
-00010110b | 01100110b = 01110110b
-00010110b | 01100111b = 01110111b
-00010110b | 01101000b = 01111110b
-00010110b | 01101001b = 01111111b
-00010110b | 01101010b = 01111110b
-00010110b | 01101011b = 01111111b
-00010110b | 01101100b = 01111110b
-00010110b | 01101101b = 01111111b
-00010110b | 01101110b = 01111110b
-00010110b | 01101111b = 01111111b
-00010110b | 01110000b = 01110110b
-00010110b | 01110001b = 01110111b
-00010110b | 01110010b = 01110110b
-00010110b | 01110011b = 01110111b
-00010110b | 01110100b = 01110110b
-00010110b | 01110101b = 01110111b
-00010110b | 01110110b = 01110110b
-00010110b | 01110111b = 01110111b
-00010110b | 01111000b = 01111110b
-00010110b | 01111001b = 01111111b
-00010110b | 01111010b = 01111110b
-00010110b | 01111011b = 01111111b
-00010110b | 01111100b = 01111110b
-00010110b | 01111101b = 01111111b
-00010110b | 01111110b = 01111110b
-00010111b | 10000000b = 10010111b
-00010111b | 10000001b = 10010111b
-00010111b | 10000010b = 10010111b
-00010111b | 10000011b = 10010111b
-00010111b | 10000100b = 10010111b
-00010111b | 10000101b = 10010111b
-00010111b | 10000110b = 10010111b
-00010111b | 10000111b = 10010111b
-00010111b | 10001000b = 10011111b
-00010111b | 10001001b = 10011111b
-00010111b | 10001010b = 10011111b
-00010111b | 10001011b = 10011111b
-00010111b | 10001100b = 10011111b
-00010111b | 10001101b = 10011111b
-00010111b | 10001110b = 10011111b
-00010111b | 10001111b = 10011111b
-00010111b | 10010000b = 10010111b
-00010111b | 10010001b = 10010111b
-00010111b | 10010010b = 10010111b
-00010111b | 10010011b = 10010111b
-00010111b | 10010100b = 10010111b
-00010111b | 10010101b = 10010111b
-00010111b | 10010110b = 10010111b
-00010111b | 10010111b = 10010111b
-00010111b | 10011000b = 10011111b
-00010111b | 10011001b = 10011111b
-00010111b | 10011010b = 10011111b
-00010111b | 10011011b = 10011111b
-00010111b | 10011100b = 10011111b
-00010111b | 10011101b = 10011111b
-00010111b | 10011110b = 10011111b
-00010111b | 10011111b = 10011111b
-00010111b | 10100000b = 10110111b
-00010111b | 10100001b = 10110111b
-00010111b | 10100010b = 10110111b
-00010111b | 10100011b = 10110111b
-00010111b | 10100100b = 10110111b
-00010111b | 10100101b = 10110111b
-00010111b | 10100110b = 10110111b
-00010111b | 10100111b = 10110111b
-00010111b | 10101000b = 10111111b
-00010111b | 10101001b = 10111111b
-00010111b | 10101010b = 10111111b
-00010111b | 10101011b = 10111111b
-00010111b | 10101100b = 10111111b
-00010111b | 10101101b = 10111111b
-00010111b | 10101110b = 10111111b
-00010111b | 10101111b = 10111111b
-00010111b | 10110000b = 10110111b
-00010111b | 10110001b = 10110111b
-00010111b | 10110010b = 10110111b
-00010111b | 10110011b = 10110111b
-00010111b | 10110100b = 10110111b
-00010111b | 10110101b = 10110111b
-00010111b | 10110110b = 10110111b
-00010111b | 10110111b = 10110111b
-00010111b | 10111000b = 10111111b
-00010111b | 10111001b = 10111111b
-00010111b | 10111010b = 10111111b
-00010111b | 10111011b = 10111111b
-00010111b | 10111100b = 10111111b
-00010111b | 10111101b = 10111111b
-00010111b | 10111110b = 10111111b
-00010111b | 10111111b = 10111111b
-00010111b | 11000000b = 11010111b
-00010111b | 11000001b = 11010111b
-00010111b | 11000010b = 11010111b
-00010111b | 11000011b = 11010111b
-00010111b | 11000100b = 11010111b
-00010111b | 11000101b = 11010111b
-00010111b | 11000110b = 11010111b
-00010111b | 11000111b = 11010111b
-00010111b | 11001000b = 11011111b
-00010111b | 11001001b = 11011111b
-00010111b | 11001010b = 11011111b
-00010111b | 11001011b = 11011111b
-00010111b | 11001100b = 11011111b
-00010111b | 11001101b = 11011111b
-00010111b | 11001110b = 11011111b
-00010111b | 11001111b = 11011111b
-00010111b | 11010000b = 11010111b
-00010111b | 11010001b = 11010111b
-00010111b | 11010010b = 11010111b
-00010111b | 11010011b = 11010111b
-00010111b | 11010100b = 11010111b
-00010111b | 11010101b = 11010111b
-00010111b | 11010110b = 11010111b
-00010111b | 11010111b = 11010111b
-00010111b | 11011000b = 11011111b
-00010111b | 11011001b = 11011111b
-00010111b | 11011010b = 11011111b
-00010111b | 11011011b = 11011111b
-00010111b | 11011100b = 11011111b
-00010111b | 11011101b = 11011111b
-00010111b | 11011110b = 11011111b
-00010111b | 11011111b = 11011111b
-00010111b | 11100000b = 11110111b
-00010111b | 11100001b = 11110111b
-00010111b | 11100010b = 11110111b
-00010111b | 11100011b = 11110111b
-00010111b | 11100100b = 11110111b
-00010111b | 11100101b = 11110111b
-00010111b | 11100110b = 11110111b
-00010111b | 11100111b = 11110111b
-00010111b | 11101000b = 11111111b
-00010111b | 11101001b = 11111111b
-00010111b | 11101010b = 11111111b
-00010111b | 11101011b = 11111111b
-00010111b | 11101100b = 11111111b
-00010111b | 11101101b = 11111111b
-00010111b | 11101110b = 11111111b
-00010111b | 11101111b = 11111111b
-00010111b | 11110000b = 11110111b
-00010111b | 11110001b = 11110111b
-00010111b | 11110010b = 11110111b
-00010111b | 11110011b = 11110111b
-00010111b | 11110100b = 11110111b
-00010111b | 11110101b = 11110111b
-00010111b | 11110110b = 11110111b
-00010111b | 11110111b = 11110111b
-00010111b | 11111000b = 11111111b
-00010111b | 11111001b = 11111111b
-00010111b | 11111010b = 11111111b
-00010111b | 11111011b = 11111111b
-00010111b | 11111100b = 11111111b
-00010111b | 11111101b = 11111111b
-00010111b | 11111110b = 11111111b
-00010111b | 11111111b = 11111111b
-00010111b | 00000000b = 00010111b
-00010111b | 00000001b = 00010111b
-00010111b | 00000010b = 00010111b
-00010111b | 00000011b = 00010111b
-00010111b | 00000100b = 00010111b
-00010111b | 00000101b = 00010111b
-00010111b | 00000110b = 00010111b
-00010111b | 00000111b = 00010111b
-00010111b | 00001000b = 00011111b
-00010111b | 00001001b = 00011111b
-00010111b | 00001010b = 00011111b
-00010111b | 00001011b = 00011111b
-00010111b | 00001100b = 00011111b
-00010111b | 00001101b = 00011111b
-00010111b | 00001110b = 00011111b
-00010111b | 00001111b = 00011111b
-00010111b | 00010000b = 00010111b
-00010111b | 00010001b = 00010111b
-00010111b | 00010010b = 00010111b
-00010111b | 00010011b = 00010111b
-00010111b | 00010100b = 00010111b
-00010111b | 00010101b = 00010111b
-00010111b | 00010110b = 00010111b
-00010111b | 00010111b = 00010111b
-00010111b | 00011000b = 00011111b
-00010111b | 00011001b = 00011111b
-00010111b | 00011010b = 00011111b
-00010111b | 00011011b = 00011111b
-00010111b | 00011100b = 00011111b
-00010111b | 00011101b = 00011111b
-00010111b | 00011110b = 00011111b
-00010111b | 00011111b = 00011111b
-00010111b | 00100000b = 00110111b
-00010111b | 00100001b = 00110111b
-00010111b | 00100010b = 00110111b
-00010111b | 00100011b = 00110111b
-00010111b | 00100100b = 00110111b
-00010111b | 00100101b = 00110111b
-00010111b | 00100110b = 00110111b
-00010111b | 00100111b = 00110111b
-00010111b | 00101000b = 00111111b
-00010111b | 00101001b = 00111111b
-00010111b | 00101010b = 00111111b
-00010111b | 00101011b = 00111111b
-00010111b | 00101100b = 00111111b
-00010111b | 00101101b = 00111111b
-00010111b | 00101110b = 00111111b
-00010111b | 00101111b = 00111111b
-00010111b | 00110000b = 00110111b
-00010111b | 00110001b = 00110111b
-00010111b | 00110010b = 00110111b
-00010111b | 00110011b = 00110111b
-00010111b | 00110100b = 00110111b
-00010111b | 00110101b = 00110111b
-00010111b | 00110110b = 00110111b
-00010111b | 00110111b = 00110111b
-00010111b | 00111000b = 00111111b
-00010111b | 00111001b = 00111111b
-00010111b | 00111010b = 00111111b
-00010111b | 00111011b = 00111111b
-00010111b | 00111100b = 00111111b
-00010111b | 00111101b = 00111111b
-00010111b | 00111110b = 00111111b
-00010111b | 00111111b = 00111111b
-00010111b | 01000000b = 01010111b
-00010111b | 01000001b = 01010111b
-00010111b | 01000010b = 01010111b
-00010111b | 01000011b = 01010111b
-00010111b | 01000100b = 01010111b
-00010111b | 01000101b = 01010111b
-00010111b | 01000110b = 01010111b
-00010111b | 01000111b = 01010111b
-00010111b | 01001000b = 01011111b
-00010111b | 01001001b = 01011111b
-00010111b | 01001010b = 01011111b
-00010111b | 01001011b = 01011111b
-00010111b | 01001100b = 01011111b
-00010111b | 01001101b = 01011111b
-00010111b | 01001110b = 01011111b
-00010111b | 01001111b = 01011111b
-00010111b | 01010000b = 01010111b
-00010111b | 01010001b = 01010111b
-00010111b | 01010010b = 01010111b
-00010111b | 01010011b = 01010111b
-00010111b | 01010100b = 01010111b
-00010111b | 01010101b = 01010111b
-00010111b | 01010110b = 01010111b
-00010111b | 01010111b = 01010111b
-00010111b | 01011000b = 01011111b
-00010111b | 01011001b = 01011111b
-00010111b | 01011010b = 01011111b
-00010111b | 01011011b = 01011111b
-00010111b | 01011100b = 01011111b
-00010111b | 01011101b = 01011111b
-00010111b | 01011110b = 01011111b
-00010111b | 01011111b = 01011111b
-00010111b | 01100000b = 01110111b
-00010111b | 01100001b = 01110111b
-00010111b | 01100010b = 01110111b
-00010111b | 01100011b = 01110111b
-00010111b | 01100100b = 01110111b
-00010111b | 01100101b = 01110111b
-00010111b | 01100110b = 01110111b
-00010111b | 01100111b = 01110111b
-00010111b | 01101000b = 01111111b
-00010111b | 01101001b = 01111111b
-00010111b | 01101010b = 01111111b
-00010111b | 01101011b = 01111111b
-00010111b | 01101100b = 01111111b
-00010111b | 01101101b = 01111111b
-00010111b | 01101110b = 01111111b
-00010111b | 01101111b = 01111111b
-00010111b | 01110000b = 01110111b
-00010111b | 01110001b = 01110111b
-00010111b | 01110010b = 01110111b
-00010111b | 01110011b = 01110111b
-00010111b | 01110100b = 01110111b
-00010111b | 01110101b = 01110111b
-00010111b | 01110110b = 01110111b
-00010111b | 01110111b = 01110111b
-00010111b | 01111000b = 01111111b
-00010111b | 01111001b = 01111111b
-00010111b | 01111010b = 01111111b
-00010111b | 01111011b = 01111111b
-00010111b | 01111100b = 01111111b
-00010111b | 01111101b = 01111111b
-00010111b | 01111110b = 01111111b
-00011000b | 10000000b = 10011000b
-00011000b | 10000001b = 10011001b
-00011000b | 10000010b = 10011010b
-00011000b | 10000011b = 10011011b
-00011000b | 10000100b = 10011100b
-00011000b | 10000101b = 10011101b
-00011000b | 10000110b = 10011110b
-00011000b | 10000111b = 10011111b
-00011000b | 10001000b = 10011000b
-00011000b | 10001001b = 10011001b
-00011000b | 10001010b = 10011010b
-00011000b | 10001011b = 10011011b
-00011000b | 10001100b = 10011100b
-00011000b | 10001101b = 10011101b
-00011000b | 10001110b = 10011110b
-00011000b | 10001111b = 10011111b
-00011000b | 10010000b = 10011000b
-00011000b | 10010001b = 10011001b
-00011000b | 10010010b = 10011010b
-00011000b | 10010011b = 10011011b
-00011000b | 10010100b = 10011100b
-00011000b | 10010101b = 10011101b
-00011000b | 10010110b = 10011110b
-00011000b | 10010111b = 10011111b
-00011000b | 10011000b = 10011000b
-00011000b | 10011001b = 10011001b
-00011000b | 10011010b = 10011010b
-00011000b | 10011011b = 10011011b
-00011000b | 10011100b = 10011100b
-00011000b | 10011101b = 10011101b
-00011000b | 10011110b = 10011110b
-00011000b | 10011111b = 10011111b
-00011000b | 10100000b = 10111000b
-00011000b | 10100001b = 10111001b
-00011000b | 10100010b = 10111010b
-00011000b | 10100011b = 10111011b
-00011000b | 10100100b = 10111100b
-00011000b | 10100101b = 10111101b
-00011000b | 10100110b = 10111110b
-00011000b | 10100111b = 10111111b
-00011000b | 10101000b = 10111000b
-00011000b | 10101001b = 10111001b
-00011000b | 10101010b = 10111010b
-00011000b | 10101011b = 10111011b
-00011000b | 10101100b = 10111100b
-00011000b | 10101101b = 10111101b
-00011000b | 10101110b = 10111110b
-00011000b | 10101111b = 10111111b
-00011000b | 10110000b = 10111000b
-00011000b | 10110001b = 10111001b
-00011000b | 10110010b = 10111010b
-00011000b | 10110011b = 10111011b
-00011000b | 10110100b = 10111100b
-00011000b | 10110101b = 10111101b
-00011000b | 10110110b = 10111110b
-00011000b | 10110111b = 10111111b
-00011000b | 10111000b = 10111000b
-00011000b | 10111001b = 10111001b
-00011000b | 10111010b = 10111010b
-00011000b | 10111011b = 10111011b
-00011000b | 10111100b = 10111100b
-00011000b | 10111101b = 10111101b
-00011000b | 10111110b = 10111110b
-00011000b | 10111111b = 10111111b
-00011000b | 11000000b = 11011000b
-00011000b | 11000001b = 11011001b
-00011000b | 11000010b = 11011010b
-00011000b | 11000011b = 11011011b
-00011000b | 11000100b = 11011100b
-00011000b | 11000101b = 11011101b
-00011000b | 11000110b = 11011110b
-00011000b | 11000111b = 11011111b
-00011000b | 11001000b = 11011000b
-00011000b | 11001001b = 11011001b
-00011000b | 11001010b = 11011010b
-00011000b | 11001011b = 11011011b
-00011000b | 11001100b = 11011100b
-00011000b | 11001101b = 11011101b
-00011000b | 11001110b = 11011110b
-00011000b | 11001111b = 11011111b
-00011000b | 11010000b = 11011000b
-00011000b | 11010001b = 11011001b
-00011000b | 11010010b = 11011010b
-00011000b | 11010011b = 11011011b
-00011000b | 11010100b = 11011100b
-00011000b | 11010101b = 11011101b
-00011000b | 11010110b = 11011110b
-00011000b | 11010111b = 11011111b
-00011000b | 11011000b = 11011000b
-00011000b | 11011001b = 11011001b
-00011000b | 11011010b = 11011010b
-00011000b | 11011011b = 11011011b
-00011000b | 11011100b = 11011100b
-00011000b | 11011101b = 11011101b
-00011000b | 11011110b = 11011110b
-00011000b | 11011111b = 11011111b
-00011000b | 11100000b = 11111000b
-00011000b | 11100001b = 11111001b
-00011000b | 11100010b = 11111010b
-00011000b | 11100011b = 11111011b
-00011000b | 11100100b = 11111100b
-00011000b | 11100101b = 11111101b
-00011000b | 11100110b = 11111110b
-00011000b | 11100111b = 11111111b
-00011000b | 11101000b = 11111000b
-00011000b | 11101001b = 11111001b
-00011000b | 11101010b = 11111010b
-00011000b | 11101011b = 11111011b
-00011000b | 11101100b = 11111100b
-00011000b | 11101101b = 11111101b
-00011000b | 11101110b = 11111110b
-00011000b | 11101111b = 11111111b
-00011000b | 11110000b = 11111000b
-00011000b | 11110001b = 11111001b
-00011000b | 11110010b = 11111010b
-00011000b | 11110011b = 11111011b
-00011000b | 11110100b = 11111100b
-00011000b | 11110101b = 11111101b
-00011000b | 11110110b = 11111110b
-00011000b | 11110111b = 11111111b
-00011000b | 11111000b = 11111000b
-00011000b | 11111001b = 11111001b
-00011000b | 11111010b = 11111010b
-00011000b | 11111011b = 11111011b
-00011000b | 11111100b = 11111100b
-00011000b | 11111101b = 11111101b
-00011000b | 11111110b = 11111110b
-00011000b | 11111111b = 11111111b
-00011000b | 00000000b = 00011000b
-00011000b | 00000001b = 00011001b
-00011000b | 00000010b = 00011010b
-00011000b | 00000011b = 00011011b
-00011000b | 00000100b = 00011100b
-00011000b | 00000101b = 00011101b
-00011000b | 00000110b = 00011110b
-00011000b | 00000111b = 00011111b
-00011000b | 00001000b = 00011000b
-00011000b | 00001001b = 00011001b
-00011000b | 00001010b = 00011010b
-00011000b | 00001011b = 00011011b
-00011000b | 00001100b = 00011100b
-00011000b | 00001101b = 00011101b
-00011000b | 00001110b = 00011110b
-00011000b | 00001111b = 00011111b
-00011000b | 00010000b = 00011000b
-00011000b | 00010001b = 00011001b
-00011000b | 00010010b = 00011010b
-00011000b | 00010011b = 00011011b
-00011000b | 00010100b = 00011100b
-00011000b | 00010101b = 00011101b
-00011000b | 00010110b = 00011110b
-00011000b | 00010111b = 00011111b
-00011000b | 00011000b = 00011000b
-00011000b | 00011001b = 00011001b
-00011000b | 00011010b = 00011010b
-00011000b | 00011011b = 00011011b
-00011000b | 00011100b = 00011100b
-00011000b | 00011101b = 00011101b
-00011000b | 00011110b = 00011110b
-00011000b | 00011111b = 00011111b
-00011000b | 00100000b = 00111000b
-00011000b | 00100001b = 00111001b
-00011000b | 00100010b = 00111010b
-00011000b | 00100011b = 00111011b
-00011000b | 00100100b = 00111100b
-00011000b | 00100101b = 00111101b
-00011000b | 00100110b = 00111110b
-00011000b | 00100111b = 00111111b
-00011000b | 00101000b = 00111000b
-00011000b | 00101001b = 00111001b
-00011000b | 00101010b = 00111010b
-00011000b | 00101011b = 00111011b
-00011000b | 00101100b = 00111100b
-00011000b | 00101101b = 00111101b
-00011000b | 00101110b = 00111110b
-00011000b | 00101111b = 00111111b
-00011000b | 00110000b = 00111000b
-00011000b | 00110001b = 00111001b
-00011000b | 00110010b = 00111010b
-00011000b | 00110011b = 00111011b
-00011000b | 00110100b = 00111100b
-00011000b | 00110101b = 00111101b
-00011000b | 00110110b = 00111110b
-00011000b | 00110111b = 00111111b
-00011000b | 00111000b = 00111000b
-00011000b | 00111001b = 00111001b
-00011000b | 00111010b = 00111010b
-00011000b | 00111011b = 00111011b
-00011000b | 00111100b = 00111100b
-00011000b | 00111101b = 00111101b
-00011000b | 00111110b = 00111110b
-00011000b | 00111111b = 00111111b
-00011000b | 01000000b = 01011000b
-00011000b | 01000001b = 01011001b
-00011000b | 01000010b = 01011010b
-00011000b | 01000011b = 01011011b
-00011000b | 01000100b = 01011100b
-00011000b | 01000101b = 01011101b
-00011000b | 01000110b = 01011110b
-00011000b | 01000111b = 01011111b
-00011000b | 01001000b = 01011000b
-00011000b | 01001001b = 01011001b
-00011000b | 01001010b = 01011010b
-00011000b | 01001011b = 01011011b
-00011000b | 01001100b = 01011100b
-00011000b | 01001101b = 01011101b
-00011000b | 01001110b = 01011110b
-00011000b | 01001111b = 01011111b
-00011000b | 01010000b = 01011000b
-00011000b | 01010001b = 01011001b
-00011000b | 01010010b = 01011010b
-00011000b | 01010011b = 01011011b
-00011000b | 01010100b = 01011100b
-00011000b | 01010101b = 01011101b
-00011000b | 01010110b = 01011110b
-00011000b | 01010111b = 01011111b
-00011000b | 01011000b = 01011000b
-00011000b | 01011001b = 01011001b
-00011000b | 01011010b = 01011010b
-00011000b | 01011011b = 01011011b
-00011000b | 01011100b = 01011100b
-00011000b | 01011101b = 01011101b
-00011000b | 01011110b = 01011110b
-00011000b | 01011111b = 01011111b
-00011000b | 01100000b = 01111000b
-00011000b | 01100001b = 01111001b
-00011000b | 01100010b = 01111010b
-00011000b | 01100011b = 01111011b
-00011000b | 01100100b = 01111100b
-00011000b | 01100101b = 01111101b
-00011000b | 01100110b = 01111110b
-00011000b | 01100111b = 01111111b
-00011000b | 01101000b = 01111000b
-00011000b | 01101001b = 01111001b
-00011000b | 01101010b = 01111010b
-00011000b | 01101011b = 01111011b
-00011000b | 01101100b = 01111100b
-00011000b | 01101101b = 01111101b
-00011000b | 01101110b = 01111110b
-00011000b | 01101111b = 01111111b
-00011000b | 01110000b = 01111000b
-00011000b | 01110001b = 01111001b
-00011000b | 01110010b = 01111010b
-00011000b | 01110011b = 01111011b
-00011000b | 01110100b = 01111100b
-00011000b | 01110101b = 01111101b
-00011000b | 01110110b = 01111110b
-00011000b | 01110111b = 01111111b
-00011000b | 01111000b = 01111000b
-00011000b | 01111001b = 01111001b
-00011000b | 01111010b = 01111010b
-00011000b | 01111011b = 01111011b
-00011000b | 01111100b = 01111100b
-00011000b | 01111101b = 01111101b
-00011000b | 01111110b = 01111110b
-00011001b | 10000000b = 10011001b
-00011001b | 10000001b = 10011001b
-00011001b | 10000010b = 10011011b
-00011001b | 10000011b = 10011011b
-00011001b | 10000100b = 10011101b
-00011001b | 10000101b = 10011101b
-00011001b | 10000110b = 10011111b
-00011001b | 10000111b = 10011111b
-00011001b | 10001000b = 10011001b
-00011001b | 10001001b = 10011001b
-00011001b | 10001010b = 10011011b
-00011001b | 10001011b = 10011011b
-00011001b | 10001100b = 10011101b
-00011001b | 10001101b = 10011101b
-00011001b | 10001110b = 10011111b
-00011001b | 10001111b = 10011111b
-00011001b | 10010000b = 10011001b
-00011001b | 10010001b = 10011001b
-00011001b | 10010010b = 10011011b
-00011001b | 10010011b = 10011011b
-00011001b | 10010100b = 10011101b
-00011001b | 10010101b = 10011101b
-00011001b | 10010110b = 10011111b
-00011001b | 10010111b = 10011111b
-00011001b | 10011000b = 10011001b
-00011001b | 10011001b = 10011001b
-00011001b | 10011010b = 10011011b
-00011001b | 10011011b = 10011011b
-00011001b | 10011100b = 10011101b
-00011001b | 10011101b = 10011101b
-00011001b | 10011110b = 10011111b
-00011001b | 10011111b = 10011111b
-00011001b | 10100000b = 10111001b
-00011001b | 10100001b = 10111001b
-00011001b | 10100010b = 10111011b
-00011001b | 10100011b = 10111011b
-00011001b | 10100100b = 10111101b
-00011001b | 10100101b = 10111101b
-00011001b | 10100110b = 10111111b
-00011001b | 10100111b = 10111111b
-00011001b | 10101000b = 10111001b
-00011001b | 10101001b = 10111001b
-00011001b | 10101010b = 10111011b
-00011001b | 10101011b = 10111011b
-00011001b | 10101100b = 10111101b
-00011001b | 10101101b = 10111101b
-00011001b | 10101110b = 10111111b
-00011001b | 10101111b = 10111111b
-00011001b | 10110000b = 10111001b
-00011001b | 10110001b = 10111001b
-00011001b | 10110010b = 10111011b
-00011001b | 10110011b = 10111011b
-00011001b | 10110100b = 10111101b
-00011001b | 10110101b = 10111101b
-00011001b | 10110110b = 10111111b
-00011001b | 10110111b = 10111111b
-00011001b | 10111000b = 10111001b
-00011001b | 10111001b = 10111001b
-00011001b | 10111010b = 10111011b
-00011001b | 10111011b = 10111011b
-00011001b | 10111100b = 10111101b
-00011001b | 10111101b = 10111101b
-00011001b | 10111110b = 10111111b
-00011001b | 10111111b = 10111111b
-00011001b | 11000000b = 11011001b
-00011001b | 11000001b = 11011001b
-00011001b | 11000010b = 11011011b
-00011001b | 11000011b = 11011011b
-00011001b | 11000100b = 11011101b
-00011001b | 11000101b = 11011101b
-00011001b | 11000110b = 11011111b
-00011001b | 11000111b = 11011111b
-00011001b | 11001000b = 11011001b
-00011001b | 11001001b = 11011001b
-00011001b | 11001010b = 11011011b
-00011001b | 11001011b = 11011011b
-00011001b | 11001100b = 11011101b
-00011001b | 11001101b = 11011101b
-00011001b | 11001110b = 11011111b
-00011001b | 11001111b = 11011111b
-00011001b | 11010000b = 11011001b
-00011001b | 11010001b = 11011001b
-00011001b | 11010010b = 11011011b
-00011001b | 11010011b = 11011011b
-00011001b | 11010100b = 11011101b
-00011001b | 11010101b = 11011101b
-00011001b | 11010110b = 11011111b
-00011001b | 11010111b = 11011111b
-00011001b | 11011000b = 11011001b
-00011001b | 11011001b = 11011001b
-00011001b | 11011010b = 11011011b
-00011001b | 11011011b = 11011011b
-00011001b | 11011100b = 11011101b
-00011001b | 11011101b = 11011101b
-00011001b | 11011110b = 11011111b
-00011001b | 11011111b = 11011111b
-00011001b | 11100000b = 11111001b
-00011001b | 11100001b = 11111001b
-00011001b | 11100010b = 11111011b
-00011001b | 11100011b = 11111011b
-00011001b | 11100100b = 11111101b
-00011001b | 11100101b = 11111101b
-00011001b | 11100110b = 11111111b
-00011001b | 11100111b = 11111111b
-00011001b | 11101000b = 11111001b
-00011001b | 11101001b = 11111001b
-00011001b | 11101010b = 11111011b
-00011001b | 11101011b = 11111011b
-00011001b | 11101100b = 11111101b
-00011001b | 11101101b = 11111101b
-00011001b | 11101110b = 11111111b
-00011001b | 11101111b = 11111111b
-00011001b | 11110000b = 11111001b
-00011001b | 11110001b = 11111001b
-00011001b | 11110010b = 11111011b
-00011001b | 11110011b = 11111011b
-00011001b | 11110100b = 11111101b
-00011001b | 11110101b = 11111101b
-00011001b | 11110110b = 11111111b
-00011001b | 11110111b = 11111111b
-00011001b | 11111000b = 11111001b
-00011001b | 11111001b = 11111001b
-00011001b | 11111010b = 11111011b
-00011001b | 11111011b = 11111011b
-00011001b | 11111100b = 11111101b
-00011001b | 11111101b = 11111101b
-00011001b | 11111110b = 11111111b
-00011001b | 11111111b = 11111111b
-00011001b | 00000000b = 00011001b
-00011001b | 00000001b = 00011001b
-00011001b | 00000010b = 00011011b
-00011001b | 00000011b = 00011011b
-00011001b | 00000100b = 00011101b
-00011001b | 00000101b = 00011101b
-00011001b | 00000110b = 00011111b
-00011001b | 00000111b = 00011111b
-00011001b | 00001000b = 00011001b
-00011001b | 00001001b = 00011001b
-00011001b | 00001010b = 00011011b
-00011001b | 00001011b = 00011011b
-00011001b | 00001100b = 00011101b
-00011001b | 00001101b = 00011101b
-00011001b | 00001110b = 00011111b
-00011001b | 00001111b = 00011111b
-00011001b | 00010000b = 00011001b
-00011001b | 00010001b = 00011001b
-00011001b | 00010010b = 00011011b
-00011001b | 00010011b = 00011011b
-00011001b | 00010100b = 00011101b
-00011001b | 00010101b = 00011101b
-00011001b | 00010110b = 00011111b
-00011001b | 00010111b = 00011111b
-00011001b | 00011000b = 00011001b
-00011001b | 00011001b = 00011001b
-00011001b | 00011010b = 00011011b
-00011001b | 00011011b = 00011011b
-00011001b | 00011100b = 00011101b
-00011001b | 00011101b = 00011101b
-00011001b | 00011110b = 00011111b
-00011001b | 00011111b = 00011111b
-00011001b | 00100000b = 00111001b
-00011001b | 00100001b = 00111001b
-00011001b | 00100010b = 00111011b
-00011001b | 00100011b = 00111011b
-00011001b | 00100100b = 00111101b
-00011001b | 00100101b = 00111101b
-00011001b | 00100110b = 00111111b
-00011001b | 00100111b = 00111111b
-00011001b | 00101000b = 00111001b
-00011001b | 00101001b = 00111001b
-00011001b | 00101010b = 00111011b
-00011001b | 00101011b = 00111011b
-00011001b | 00101100b = 00111101b
-00011001b | 00101101b = 00111101b
-00011001b | 00101110b = 00111111b
-00011001b | 00101111b = 00111111b
-00011001b | 00110000b = 00111001b
-00011001b | 00110001b = 00111001b
-00011001b | 00110010b = 00111011b
-00011001b | 00110011b = 00111011b
-00011001b | 00110100b = 00111101b
-00011001b | 00110101b = 00111101b
-00011001b | 00110110b = 00111111b
-00011001b | 00110111b = 00111111b
-00011001b | 00111000b = 00111001b
-00011001b | 00111001b = 00111001b
-00011001b | 00111010b = 00111011b
-00011001b | 00111011b = 00111011b
-00011001b | 00111100b = 00111101b
-00011001b | 00111101b = 00111101b
-00011001b | 00111110b = 00111111b
-00011001b | 00111111b = 00111111b
-00011001b | 01000000b = 01011001b
-00011001b | 01000001b = 01011001b
-00011001b | 01000010b = 01011011b
-00011001b | 01000011b = 01011011b
-00011001b | 01000100b = 01011101b
-00011001b | 01000101b = 01011101b
-00011001b | 01000110b = 01011111b
-00011001b | 01000111b = 01011111b
-00011001b | 01001000b = 01011001b
-00011001b | 01001001b = 01011001b
-00011001b | 01001010b = 01011011b
-00011001b | 01001011b = 01011011b
-00011001b | 01001100b = 01011101b
-00011001b | 01001101b = 01011101b
-00011001b | 01001110b = 01011111b
-00011001b | 01001111b = 01011111b
-00011001b | 01010000b = 01011001b
-00011001b | 01010001b = 01011001b
-00011001b | 01010010b = 01011011b
-00011001b | 01010011b = 01011011b
-00011001b | 01010100b = 01011101b
-00011001b | 01010101b = 01011101b
-00011001b | 01010110b = 01011111b
-00011001b | 01010111b = 01011111b
-00011001b | 01011000b = 01011001b
-00011001b | 01011001b = 01011001b
-00011001b | 01011010b = 01011011b
-00011001b | 01011011b = 01011011b
-00011001b | 01011100b = 01011101b
-00011001b | 01011101b = 01011101b
-00011001b | 01011110b = 01011111b
-00011001b | 01011111b = 01011111b
-00011001b | 01100000b = 01111001b
-00011001b | 01100001b = 01111001b
-00011001b | 01100010b = 01111011b
-00011001b | 01100011b = 01111011b
-00011001b | 01100100b = 01111101b
-00011001b | 01100101b = 01111101b
-00011001b | 01100110b = 01111111b
-00011001b | 01100111b = 01111111b
-00011001b | 01101000b = 01111001b
-00011001b | 01101001b = 01111001b
-00011001b | 01101010b = 01111011b
-00011001b | 01101011b = 01111011b
-00011001b | 01101100b = 01111101b
-00011001b | 01101101b = 01111101b
-00011001b | 01101110b = 01111111b
-00011001b | 01101111b = 01111111b
-00011001b | 01110000b = 01111001b
-00011001b | 01110001b = 01111001b
-00011001b | 01110010b = 01111011b
-00011001b | 01110011b = 01111011b
-00011001b | 01110100b = 01111101b
-00011001b | 01110101b = 01111101b
-00011001b | 01110110b = 01111111b
-00011001b | 01110111b = 01111111b
-00011001b | 01111000b = 01111001b
-00011001b | 01111001b = 01111001b
-00011001b | 01111010b = 01111011b
-00011001b | 01111011b = 01111011b
-00011001b | 01111100b = 01111101b
-00011001b | 01111101b = 01111101b
-00011001b | 01111110b = 01111111b
-00011010b | 10000000b = 10011010b
-00011010b | 10000001b = 10011011b
-00011010b | 10000010b = 10011010b
-00011010b | 10000011b = 10011011b
-00011010b | 10000100b = 10011110b
-00011010b | 10000101b = 10011111b
-00011010b | 10000110b = 10011110b
-00011010b | 10000111b = 10011111b
-00011010b | 10001000b = 10011010b
-00011010b | 10001001b = 10011011b
-00011010b | 10001010b = 10011010b
-00011010b | 10001011b = 10011011b
-00011010b | 10001100b = 10011110b
-00011010b | 10001101b = 10011111b
-00011010b | 10001110b = 10011110b
-00011010b | 10001111b = 10011111b
-00011010b | 10010000b = 10011010b
-00011010b | 10010001b = 10011011b
-00011010b | 10010010b = 10011010b
-00011010b | 10010011b = 10011011b
-00011010b | 10010100b = 10011110b
-00011010b | 10010101b = 10011111b
-00011010b | 10010110b = 10011110b
-00011010b | 10010111b = 10011111b
-00011010b | 10011000b = 10011010b
-00011010b | 10011001b = 10011011b
-00011010b | 10011010b = 10011010b
-00011010b | 10011011b = 10011011b
-00011010b | 10011100b = 10011110b
-00011010b | 10011101b = 10011111b
-00011010b | 10011110b = 10011110b
-00011010b | 10011111b = 10011111b
-00011010b | 10100000b = 10111010b
-00011010b | 10100001b = 10111011b
-00011010b | 10100010b = 10111010b
-00011010b | 10100011b = 10111011b
-00011010b | 10100100b = 10111110b
-00011010b | 10100101b = 10111111b
-00011010b | 10100110b = 10111110b
-00011010b | 10100111b = 10111111b
-00011010b | 10101000b = 10111010b
-00011010b | 10101001b = 10111011b
-00011010b | 10101010b = 10111010b
-00011010b | 10101011b = 10111011b
-00011010b | 10101100b = 10111110b
-00011010b | 10101101b = 10111111b
-00011010b | 10101110b = 10111110b
-00011010b | 10101111b = 10111111b
-00011010b | 10110000b = 10111010b
-00011010b | 10110001b = 10111011b
-00011010b | 10110010b = 10111010b
-00011010b | 10110011b = 10111011b
-00011010b | 10110100b = 10111110b
-00011010b | 10110101b = 10111111b
-00011010b | 10110110b = 10111110b
-00011010b | 10110111b = 10111111b
-00011010b | 10111000b = 10111010b
-00011010b | 10111001b = 10111011b
-00011010b | 10111010b = 10111010b
-00011010b | 10111011b = 10111011b
-00011010b | 10111100b = 10111110b
-00011010b | 10111101b = 10111111b
-00011010b | 10111110b = 10111110b
-00011010b | 10111111b = 10111111b
-00011010b | 11000000b = 11011010b
-00011010b | 11000001b = 11011011b
-00011010b | 11000010b = 11011010b
-00011010b | 11000011b = 11011011b
-00011010b | 11000100b = 11011110b
-00011010b | 11000101b = 11011111b
-00011010b | 11000110b = 11011110b
-00011010b | 11000111b = 11011111b
-00011010b | 11001000b = 11011010b
-00011010b | 11001001b = 11011011b
-00011010b | 11001010b = 11011010b
-00011010b | 11001011b = 11011011b
-00011010b | 11001100b = 11011110b
-00011010b | 11001101b = 11011111b
-00011010b | 11001110b = 11011110b
-00011010b | 11001111b = 11011111b
-00011010b | 11010000b = 11011010b
-00011010b | 11010001b = 11011011b
-00011010b | 11010010b = 11011010b
-00011010b | 11010011b = 11011011b
-00011010b | 11010100b = 11011110b
-00011010b | 11010101b = 11011111b
-00011010b | 11010110b = 11011110b
-00011010b | 11010111b = 11011111b
-00011010b | 11011000b = 11011010b
-00011010b | 11011001b = 11011011b
-00011010b | 11011010b = 11011010b
-00011010b | 11011011b = 11011011b
-00011010b | 11011100b = 11011110b
-00011010b | 11011101b = 11011111b
-00011010b | 11011110b = 11011110b
-00011010b | 11011111b = 11011111b
-00011010b | 11100000b = 11111010b
-00011010b | 11100001b = 11111011b
-00011010b | 11100010b = 11111010b
-00011010b | 11100011b = 11111011b
-00011010b | 11100100b = 11111110b
-00011010b | 11100101b = 11111111b
-00011010b | 11100110b = 11111110b
-00011010b | 11100111b = 11111111b
-00011010b | 11101000b = 11111010b
-00011010b | 11101001b = 11111011b
-00011010b | 11101010b = 11111010b
-00011010b | 11101011b = 11111011b
-00011010b | 11101100b = 11111110b
-00011010b | 11101101b = 11111111b
-00011010b | 11101110b = 11111110b
-00011010b | 11101111b = 11111111b
-00011010b | 11110000b = 11111010b
-00011010b | 11110001b = 11111011b
-00011010b | 11110010b = 11111010b
-00011010b | 11110011b = 11111011b
-00011010b | 11110100b = 11111110b
-00011010b | 11110101b = 11111111b
-00011010b | 11110110b = 11111110b
-00011010b | 11110111b = 11111111b
-00011010b | 11111000b = 11111010b
-00011010b | 11111001b = 11111011b
-00011010b | 11111010b = 11111010b
-00011010b | 11111011b = 11111011b
-00011010b | 11111100b = 11111110b
-00011010b | 11111101b = 11111111b
-00011010b | 11111110b = 11111110b
-00011010b | 11111111b = 11111111b
-00011010b | 00000000b = 00011010b
-00011010b | 00000001b = 00011011b
-00011010b | 00000010b = 00011010b
-00011010b | 00000011b = 00011011b
-00011010b | 00000100b = 00011110b
-00011010b | 00000101b = 00011111b
-00011010b | 00000110b = 00011110b
-00011010b | 00000111b = 00011111b
-00011010b | 00001000b = 00011010b
-00011010b | 00001001b = 00011011b
-00011010b | 00001010b = 00011010b
-00011010b | 00001011b = 00011011b
-00011010b | 00001100b = 00011110b
-00011010b | 00001101b = 00011111b
-00011010b | 00001110b = 00011110b
-00011010b | 00001111b = 00011111b
-00011010b | 00010000b = 00011010b
-00011010b | 00010001b = 00011011b
-00011010b | 00010010b = 00011010b
-00011010b | 00010011b = 00011011b
-00011010b | 00010100b = 00011110b
-00011010b | 00010101b = 00011111b
-00011010b | 00010110b = 00011110b
-00011010b | 00010111b = 00011111b
-00011010b | 00011000b = 00011010b
-00011010b | 00011001b = 00011011b
-00011010b | 00011010b = 00011010b
-00011010b | 00011011b = 00011011b
-00011010b | 00011100b = 00011110b
-00011010b | 00011101b = 00011111b
-00011010b | 00011110b = 00011110b
-00011010b | 00011111b = 00011111b
-00011010b | 00100000b = 00111010b
-00011010b | 00100001b = 00111011b
-00011010b | 00100010b = 00111010b
-00011010b | 00100011b = 00111011b
-00011010b | 00100100b = 00111110b
-00011010b | 00100101b = 00111111b
-00011010b | 00100110b = 00111110b
-00011010b | 00100111b = 00111111b
-00011010b | 00101000b = 00111010b
-00011010b | 00101001b = 00111011b
-00011010b | 00101010b = 00111010b
-00011010b | 00101011b = 00111011b
-00011010b | 00101100b = 00111110b
-00011010b | 00101101b = 00111111b
-00011010b | 00101110b = 00111110b
-00011010b | 00101111b = 00111111b
-00011010b | 00110000b = 00111010b
-00011010b | 00110001b = 00111011b
-00011010b | 00110010b = 00111010b
-00011010b | 00110011b = 00111011b
-00011010b | 00110100b = 00111110b
-00011010b | 00110101b = 00111111b
-00011010b | 00110110b = 00111110b
-00011010b | 00110111b = 00111111b
-00011010b | 00111000b = 00111010b
-00011010b | 00111001b = 00111011b
-00011010b | 00111010b = 00111010b
-00011010b | 00111011b = 00111011b
-00011010b | 00111100b = 00111110b
-00011010b | 00111101b = 00111111b
-00011010b | 00111110b = 00111110b
-00011010b | 00111111b = 00111111b
-00011010b | 01000000b = 01011010b
-00011010b | 01000001b = 01011011b
-00011010b | 01000010b = 01011010b
-00011010b | 01000011b = 01011011b
-00011010b | 01000100b = 01011110b
-00011010b | 01000101b = 01011111b
-00011010b | 01000110b = 01011110b
-00011010b | 01000111b = 01011111b
-00011010b | 01001000b = 01011010b
-00011010b | 01001001b = 01011011b
-00011010b | 01001010b = 01011010b
-00011010b | 01001011b = 01011011b
-00011010b | 01001100b = 01011110b
-00011010b | 01001101b = 01011111b
-00011010b | 01001110b = 01011110b
-00011010b | 01001111b = 01011111b
-00011010b | 01010000b = 01011010b
-00011010b | 01010001b = 01011011b
-00011010b | 01010010b = 01011010b
-00011010b | 01010011b = 01011011b
-00011010b | 01010100b = 01011110b
-00011010b | 01010101b = 01011111b
-00011010b | 01010110b = 01011110b
-00011010b | 01010111b = 01011111b
-00011010b | 01011000b = 01011010b
-00011010b | 01011001b = 01011011b
-00011010b | 01011010b = 01011010b
-00011010b | 01011011b = 01011011b
-00011010b | 01011100b = 01011110b
-00011010b | 01011101b = 01011111b
-00011010b | 01011110b = 01011110b
-00011010b | 01011111b = 01011111b
-00011010b | 01100000b = 01111010b
-00011010b | 01100001b = 01111011b
-00011010b | 01100010b = 01111010b
-00011010b | 01100011b = 01111011b
-00011010b | 01100100b = 01111110b
-00011010b | 01100101b = 01111111b
-00011010b | 01100110b = 01111110b
-00011010b | 01100111b = 01111111b
-00011010b | 01101000b = 01111010b
-00011010b | 01101001b = 01111011b
-00011010b | 01101010b = 01111010b
-00011010b | 01101011b = 01111011b
-00011010b | 01101100b = 01111110b
-00011010b | 01101101b = 01111111b
-00011010b | 01101110b = 01111110b
-00011010b | 01101111b = 01111111b
-00011010b | 01110000b = 01111010b
-00011010b | 01110001b = 01111011b
-00011010b | 01110010b = 01111010b
-00011010b | 01110011b = 01111011b
-00011010b | 01110100b = 01111110b
-00011010b | 01110101b = 01111111b
-00011010b | 01110110b = 01111110b
-00011010b | 01110111b = 01111111b
-00011010b | 01111000b = 01111010b
-00011010b | 01111001b = 01111011b
-00011010b | 01111010b = 01111010b
-00011010b | 01111011b = 01111011b
-00011010b | 01111100b = 01111110b
-00011010b | 01111101b = 01111111b
-00011010b | 01111110b = 01111110b
-00011011b | 10000000b = 10011011b
-00011011b | 10000001b = 10011011b
-00011011b | 10000010b = 10011011b
-00011011b | 10000011b = 10011011b
-00011011b | 10000100b = 10011111b
-00011011b | 10000101b = 10011111b
-00011011b | 10000110b = 10011111b
-00011011b | 10000111b = 10011111b
-00011011b | 10001000b = 10011011b
-00011011b | 10001001b = 10011011b
-00011011b | 10001010b = 10011011b
-00011011b | 10001011b = 10011011b
-00011011b | 10001100b = 10011111b
-00011011b | 10001101b = 10011111b
-00011011b | 10001110b = 10011111b
-00011011b | 10001111b = 10011111b
-00011011b | 10010000b = 10011011b
-00011011b | 10010001b = 10011011b
-00011011b | 10010010b = 10011011b
-00011011b | 10010011b = 10011011b
-00011011b | 10010100b = 10011111b
-00011011b | 10010101b = 10011111b
-00011011b | 10010110b = 10011111b
-00011011b | 10010111b = 10011111b
-00011011b | 10011000b = 10011011b
-00011011b | 10011001b = 10011011b
-00011011b | 10011010b = 10011011b
-00011011b | 10011011b = 10011011b
-00011011b | 10011100b = 10011111b
-00011011b | 10011101b = 10011111b
-00011011b | 10011110b = 10011111b
-00011011b | 10011111b = 10011111b
-00011011b | 10100000b = 10111011b
-00011011b | 10100001b = 10111011b
-00011011b | 10100010b = 10111011b
-00011011b | 10100011b = 10111011b
-00011011b | 10100100b = 10111111b
-00011011b | 10100101b = 10111111b
-00011011b | 10100110b = 10111111b
-00011011b | 10100111b = 10111111b
-00011011b | 10101000b = 10111011b
-00011011b | 10101001b = 10111011b
-00011011b | 10101010b = 10111011b
-00011011b | 10101011b = 10111011b
-00011011b | 10101100b = 10111111b
-00011011b | 10101101b = 10111111b
-00011011b | 10101110b = 10111111b
-00011011b | 10101111b = 10111111b
-00011011b | 10110000b = 10111011b
-00011011b | 10110001b = 10111011b
-00011011b | 10110010b = 10111011b
-00011011b | 10110011b = 10111011b
-00011011b | 10110100b = 10111111b
-00011011b | 10110101b = 10111111b
-00011011b | 10110110b = 10111111b
-00011011b | 10110111b = 10111111b
-00011011b | 10111000b = 10111011b
-00011011b | 10111001b = 10111011b
-00011011b | 10111010b = 10111011b
-00011011b | 10111011b = 10111011b
-00011011b | 10111100b = 10111111b
-00011011b | 10111101b = 10111111b
-00011011b | 10111110b = 10111111b
-00011011b | 10111111b = 10111111b
-00011011b | 11000000b = 11011011b
-00011011b | 11000001b = 11011011b
-00011011b | 11000010b = 11011011b
-00011011b | 11000011b = 11011011b
-00011011b | 11000100b = 11011111b
-00011011b | 11000101b = 11011111b
-00011011b | 11000110b = 11011111b
-00011011b | 11000111b = 11011111b
-00011011b | 11001000b = 11011011b
-00011011b | 11001001b = 11011011b
-00011011b | 11001010b = 11011011b
-00011011b | 11001011b = 11011011b
-00011011b | 11001100b = 11011111b
-00011011b | 11001101b = 11011111b
-00011011b | 11001110b = 11011111b
-00011011b | 11001111b = 11011111b
-00011011b | 11010000b = 11011011b
-00011011b | 11010001b = 11011011b
-00011011b | 11010010b = 11011011b
-00011011b | 11010011b = 11011011b
-00011011b | 11010100b = 11011111b
-00011011b | 11010101b = 11011111b
-00011011b | 11010110b = 11011111b
-00011011b | 11010111b = 11011111b
-00011011b | 11011000b = 11011011b
-00011011b | 11011001b = 11011011b
-00011011b | 11011010b = 11011011b
-00011011b | 11011011b = 11011011b
-00011011b | 11011100b = 11011111b
-00011011b | 11011101b = 11011111b
-00011011b | 11011110b = 11011111b
-00011011b | 11011111b = 11011111b
-00011011b | 11100000b = 11111011b
-00011011b | 11100001b = 11111011b
-00011011b | 11100010b = 11111011b
-00011011b | 11100011b = 11111011b
-00011011b | 11100100b = 11111111b
-00011011b | 11100101b = 11111111b
-00011011b | 11100110b = 11111111b
-00011011b | 11100111b = 11111111b
-00011011b | 11101000b = 11111011b
-00011011b | 11101001b = 11111011b
-00011011b | 11101010b = 11111011b
-00011011b | 11101011b = 11111011b
-00011011b | 11101100b = 11111111b
-00011011b | 11101101b = 11111111b
-00011011b | 11101110b = 11111111b
-00011011b | 11101111b = 11111111b
-00011011b | 11110000b = 11111011b
-00011011b | 11110001b = 11111011b
-00011011b | 11110010b = 11111011b
-00011011b | 11110011b = 11111011b
-00011011b | 11110100b = 11111111b
-00011011b | 11110101b = 11111111b
-00011011b | 11110110b = 11111111b
-00011011b | 11110111b = 11111111b
-00011011b | 11111000b = 11111011b
-00011011b | 11111001b = 11111011b
-00011011b | 11111010b = 11111011b
-00011011b | 11111011b = 11111011b
-00011011b | 11111100b = 11111111b
-00011011b | 11111101b = 11111111b
-00011011b | 11111110b = 11111111b
-00011011b | 11111111b = 11111111b
-00011011b | 00000000b = 00011011b
-00011011b | 00000001b = 00011011b
-00011011b | 00000010b = 00011011b
-00011011b | 00000011b = 00011011b
-00011011b | 00000100b = 00011111b
-00011011b | 00000101b = 00011111b
-00011011b | 00000110b = 00011111b
-00011011b | 00000111b = 00011111b
-00011011b | 00001000b = 00011011b
-00011011b | 00001001b = 00011011b
-00011011b | 00001010b = 00011011b
-00011011b | 00001011b = 00011011b
-00011011b | 00001100b = 00011111b
-00011011b | 00001101b = 00011111b
-00011011b | 00001110b = 00011111b
-00011011b | 00001111b = 00011111b
-00011011b | 00010000b = 00011011b
-00011011b | 00010001b = 00011011b
-00011011b | 00010010b = 00011011b
-00011011b | 00010011b = 00011011b
-00011011b | 00010100b = 00011111b
-00011011b | 00010101b = 00011111b
-00011011b | 00010110b = 00011111b
-00011011b | 00010111b = 00011111b
-00011011b | 00011000b = 00011011b
-00011011b | 00011001b = 00011011b
-00011011b | 00011010b = 00011011b
-00011011b | 00011011b = 00011011b
-00011011b | 00011100b = 00011111b
-00011011b | 00011101b = 00011111b
-00011011b | 00011110b = 00011111b
-00011011b | 00011111b = 00011111b
-00011011b | 00100000b = 00111011b
-00011011b | 00100001b = 00111011b
-00011011b | 00100010b = 00111011b
-00011011b | 00100011b = 00111011b
-00011011b | 00100100b = 00111111b
-00011011b | 00100101b = 00111111b
-00011011b | 00100110b = 00111111b
-00011011b | 00100111b = 00111111b
-00011011b | 00101000b = 00111011b
-00011011b | 00101001b = 00111011b
-00011011b | 00101010b = 00111011b
-00011011b | 00101011b = 00111011b
-00011011b | 00101100b = 00111111b
-00011011b | 00101101b = 00111111b
-00011011b | 00101110b = 00111111b
-00011011b | 00101111b = 00111111b
-00011011b | 00110000b = 00111011b
-00011011b | 00110001b = 00111011b
-00011011b | 00110010b = 00111011b
-00011011b | 00110011b = 00111011b
-00011011b | 00110100b = 00111111b
-00011011b | 00110101b = 00111111b
-00011011b | 00110110b = 00111111b
-00011011b | 00110111b = 00111111b
-00011011b | 00111000b = 00111011b
-00011011b | 00111001b = 00111011b
-00011011b | 00111010b = 00111011b
-00011011b | 00111011b = 00111011b
-00011011b | 00111100b = 00111111b
-00011011b | 00111101b = 00111111b
-00011011b | 00111110b = 00111111b
-00011011b | 00111111b = 00111111b
-00011011b | 01000000b = 01011011b
-00011011b | 01000001b = 01011011b
-00011011b | 01000010b = 01011011b
-00011011b | 01000011b = 01011011b
-00011011b | 01000100b = 01011111b
-00011011b | 01000101b = 01011111b
-00011011b | 01000110b = 01011111b
-00011011b | 01000111b = 01011111b
-00011011b | 01001000b = 01011011b
-00011011b | 01001001b = 01011011b
-00011011b | 01001010b = 01011011b
-00011011b | 01001011b = 01011011b
-00011011b | 01001100b = 01011111b
-00011011b | 01001101b = 01011111b
-00011011b | 01001110b = 01011111b
-00011011b | 01001111b = 01011111b
-00011011b | 01010000b = 01011011b
-00011011b | 01010001b = 01011011b
-00011011b | 01010010b = 01011011b
-00011011b | 01010011b = 01011011b
-00011011b | 01010100b = 01011111b
-00011011b | 01010101b = 01011111b
-00011011b | 01010110b = 01011111b
-00011011b | 01010111b = 01011111b
-00011011b | 01011000b = 01011011b
-00011011b | 01011001b = 01011011b
-00011011b | 01011010b = 01011011b
-00011011b | 01011011b = 01011011b
-00011011b | 01011100b = 01011111b
-00011011b | 01011101b = 01011111b
-00011011b | 01011110b = 01011111b
-00011011b | 01011111b = 01011111b
-00011011b | 01100000b = 01111011b
-00011011b | 01100001b = 01111011b
-00011011b | 01100010b = 01111011b
-00011011b | 01100011b = 01111011b
-00011011b | 01100100b = 01111111b
-00011011b | 01100101b = 01111111b
-00011011b | 01100110b = 01111111b
-00011011b | 01100111b = 01111111b
-00011011b | 01101000b = 01111011b
-00011011b | 01101001b = 01111011b
-00011011b | 01101010b = 01111011b
-00011011b | 01101011b = 01111011b
-00011011b | 01101100b = 01111111b
-00011011b | 01101101b = 01111111b
-00011011b | 01101110b = 01111111b
-00011011b | 01101111b = 01111111b
-00011011b | 01110000b = 01111011b
-00011011b | 01110001b = 01111011b
-00011011b | 01110010b = 01111011b
-00011011b | 01110011b = 01111011b
-00011011b | 01110100b = 01111111b
-00011011b | 01110101b = 01111111b
-00011011b | 01110110b = 01111111b
-00011011b | 01110111b = 01111111b
-00011011b | 01111000b = 01111011b
-00011011b | 01111001b = 01111011b
-00011011b | 01111010b = 01111011b
-00011011b | 01111011b = 01111011b
-00011011b | 01111100b = 01111111b
-00011011b | 01111101b = 01111111b
-00011011b | 01111110b = 01111111b
-00011100b | 10000000b = 10011100b
-00011100b | 10000001b = 10011101b
-00011100b | 10000010b = 10011110b
-00011100b | 10000011b = 10011111b
-00011100b | 10000100b = 10011100b
-00011100b | 10000101b = 10011101b
-00011100b | 10000110b = 10011110b
-00011100b | 10000111b = 10011111b
-00011100b | 10001000b = 10011100b
-00011100b | 10001001b = 10011101b
-00011100b | 10001010b = 10011110b
-00011100b | 10001011b = 10011111b
-00011100b | 10001100b = 10011100b
-00011100b | 10001101b = 10011101b
-00011100b | 10001110b = 10011110b
-00011100b | 10001111b = 10011111b
-00011100b | 10010000b = 10011100b
-00011100b | 10010001b = 10011101b
-00011100b | 10010010b = 10011110b
-00011100b | 10010011b = 10011111b
-00011100b | 10010100b = 10011100b
-00011100b | 10010101b = 10011101b
-00011100b | 10010110b = 10011110b
-00011100b | 10010111b = 10011111b
-00011100b | 10011000b = 10011100b
-00011100b | 10011001b = 10011101b
-00011100b | 10011010b = 10011110b
-00011100b | 10011011b = 10011111b
-00011100b | 10011100b = 10011100b
-00011100b | 10011101b = 10011101b
-00011100b | 10011110b = 10011110b
-00011100b | 10011111b = 10011111b
-00011100b | 10100000b = 10111100b
-00011100b | 10100001b = 10111101b
-00011100b | 10100010b = 10111110b
-00011100b | 10100011b = 10111111b
-00011100b | 10100100b = 10111100b
-00011100b | 10100101b = 10111101b
-00011100b | 10100110b = 10111110b
-00011100b | 10100111b = 10111111b
-00011100b | 10101000b = 10111100b
-00011100b | 10101001b = 10111101b
-00011100b | 10101010b = 10111110b
-00011100b | 10101011b = 10111111b
-00011100b | 10101100b = 10111100b
-00011100b | 10101101b = 10111101b
-00011100b | 10101110b = 10111110b
-00011100b | 10101111b = 10111111b
-00011100b | 10110000b = 10111100b
-00011100b | 10110001b = 10111101b
-00011100b | 10110010b = 10111110b
-00011100b | 10110011b = 10111111b
-00011100b | 10110100b = 10111100b
-00011100b | 10110101b = 10111101b
-00011100b | 10110110b = 10111110b
-00011100b | 10110111b = 10111111b
-00011100b | 10111000b = 10111100b
-00011100b | 10111001b = 10111101b
-00011100b | 10111010b = 10111110b
-00011100b | 10111011b = 10111111b
-00011100b | 10111100b = 10111100b
-00011100b | 10111101b = 10111101b
-00011100b | 10111110b = 10111110b
-00011100b | 10111111b = 10111111b
-00011100b | 11000000b = 11011100b
-00011100b | 11000001b = 11011101b
-00011100b | 11000010b = 11011110b
-00011100b | 11000011b = 11011111b
-00011100b | 11000100b = 11011100b
-00011100b | 11000101b = 11011101b
-00011100b | 11000110b = 11011110b
-00011100b | 11000111b = 11011111b
-00011100b | 11001000b = 11011100b
-00011100b | 11001001b = 11011101b
-00011100b | 11001010b = 11011110b
-00011100b | 11001011b = 11011111b
-00011100b | 11001100b = 11011100b
-00011100b | 11001101b = 11011101b
-00011100b | 11001110b = 11011110b
-00011100b | 11001111b = 11011111b
-00011100b | 11010000b = 11011100b
-00011100b | 11010001b = 11011101b
-00011100b | 11010010b = 11011110b
-00011100b | 11010011b = 11011111b
-00011100b | 11010100b = 11011100b
-00011100b | 11010101b = 11011101b
-00011100b | 11010110b = 11011110b
-00011100b | 11010111b = 11011111b
-00011100b | 11011000b = 11011100b
-00011100b | 11011001b = 11011101b
-00011100b | 11011010b = 11011110b
-00011100b | 11011011b = 11011111b
-00011100b | 11011100b = 11011100b
-00011100b | 11011101b = 11011101b
-00011100b | 11011110b = 11011110b
-00011100b | 11011111b = 11011111b
-00011100b | 11100000b = 11111100b
-00011100b | 11100001b = 11111101b
-00011100b | 11100010b = 11111110b
-00011100b | 11100011b = 11111111b
-00011100b | 11100100b = 11111100b
-00011100b | 11100101b = 11111101b
-00011100b | 11100110b = 11111110b
-00011100b | 11100111b = 11111111b
-00011100b | 11101000b = 11111100b
-00011100b | 11101001b = 11111101b
-00011100b | 11101010b = 11111110b
-00011100b | 11101011b = 11111111b
-00011100b | 11101100b = 11111100b
-00011100b | 11101101b = 11111101b
-00011100b | 11101110b = 11111110b
-00011100b | 11101111b = 11111111b
-00011100b | 11110000b = 11111100b
-00011100b | 11110001b = 11111101b
-00011100b | 11110010b = 11111110b
-00011100b | 11110011b = 11111111b
-00011100b | 11110100b = 11111100b
-00011100b | 11110101b = 11111101b
-00011100b | 11110110b = 11111110b
-00011100b | 11110111b = 11111111b
-00011100b | 11111000b = 11111100b
-00011100b | 11111001b = 11111101b
-00011100b | 11111010b = 11111110b
-00011100b | 11111011b = 11111111b
-00011100b | 11111100b = 11111100b
-00011100b | 11111101b = 11111101b
-00011100b | 11111110b = 11111110b
-00011100b | 11111111b = 11111111b
-00011100b | 00000000b = 00011100b
-00011100b | 00000001b = 00011101b
-00011100b | 00000010b = 00011110b
-00011100b | 00000011b = 00011111b
-00011100b | 00000100b = 00011100b
-00011100b | 00000101b = 00011101b
-00011100b | 00000110b = 00011110b
-00011100b | 00000111b = 00011111b
-00011100b | 00001000b = 00011100b
-00011100b | 00001001b = 00011101b
-00011100b | 00001010b = 00011110b
-00011100b | 00001011b = 00011111b
-00011100b | 00001100b = 00011100b
-00011100b | 00001101b = 00011101b
-00011100b | 00001110b = 00011110b
-00011100b | 00001111b = 00011111b
-00011100b | 00010000b = 00011100b
-00011100b | 00010001b = 00011101b
-00011100b | 00010010b = 00011110b
-00011100b | 00010011b = 00011111b
-00011100b | 00010100b = 00011100b
-00011100b | 00010101b = 00011101b
-00011100b | 00010110b = 00011110b
-00011100b | 00010111b = 00011111b
-00011100b | 00011000b = 00011100b
-00011100b | 00011001b = 00011101b
-00011100b | 00011010b = 00011110b
-00011100b | 00011011b = 00011111b
-00011100b | 00011100b = 00011100b
-00011100b | 00011101b = 00011101b
-00011100b | 00011110b = 00011110b
-00011100b | 00011111b = 00011111b
-00011100b | 00100000b = 00111100b
-00011100b | 00100001b = 00111101b
-00011100b | 00100010b = 00111110b
-00011100b | 00100011b = 00111111b
-00011100b | 00100100b = 00111100b
-00011100b | 00100101b = 00111101b
-00011100b | 00100110b = 00111110b
-00011100b | 00100111b = 00111111b
-00011100b | 00101000b = 00111100b
-00011100b | 00101001b = 00111101b
-00011100b | 00101010b = 00111110b
-00011100b | 00101011b = 00111111b
-00011100b | 00101100b = 00111100b
-00011100b | 00101101b = 00111101b
-00011100b | 00101110b = 00111110b
-00011100b | 00101111b = 00111111b
-00011100b | 00110000b = 00111100b
-00011100b | 00110001b = 00111101b
-00011100b | 00110010b = 00111110b
-00011100b | 00110011b = 00111111b
-00011100b | 00110100b = 00111100b
-00011100b | 00110101b = 00111101b
-00011100b | 00110110b = 00111110b
-00011100b | 00110111b = 00111111b
-00011100b | 00111000b = 00111100b
-00011100b | 00111001b = 00111101b
-00011100b | 00111010b = 00111110b
-00011100b | 00111011b = 00111111b
-00011100b | 00111100b = 00111100b
-00011100b | 00111101b = 00111101b
-00011100b | 00111110b = 00111110b
-00011100b | 00111111b = 00111111b
-00011100b | 01000000b = 01011100b
-00011100b | 01000001b = 01011101b
-00011100b | 01000010b = 01011110b
-00011100b | 01000011b = 01011111b
-00011100b | 01000100b = 01011100b
-00011100b | 01000101b = 01011101b
-00011100b | 01000110b = 01011110b
-00011100b | 01000111b = 01011111b
-00011100b | 01001000b = 01011100b
-00011100b | 01001001b = 01011101b
-00011100b | 01001010b = 01011110b
-00011100b | 01001011b = 01011111b
-00011100b | 01001100b = 01011100b
-00011100b | 01001101b = 01011101b
-00011100b | 01001110b = 01011110b
-00011100b | 01001111b = 01011111b
-00011100b | 01010000b = 01011100b
-00011100b | 01010001b = 01011101b
-00011100b | 01010010b = 01011110b
-00011100b | 01010011b = 01011111b
-00011100b | 01010100b = 01011100b
-00011100b | 01010101b = 01011101b
-00011100b | 01010110b = 01011110b
-00011100b | 01010111b = 01011111b
-00011100b | 01011000b = 01011100b
-00011100b | 01011001b = 01011101b
-00011100b | 01011010b = 01011110b
-00011100b | 01011011b = 01011111b
-00011100b | 01011100b = 01011100b
-00011100b | 01011101b = 01011101b
-00011100b | 01011110b = 01011110b
-00011100b | 01011111b = 01011111b
-00011100b | 01100000b = 01111100b
-00011100b | 01100001b = 01111101b
-00011100b | 01100010b = 01111110b
-00011100b | 01100011b = 01111111b
-00011100b | 01100100b = 01111100b
-00011100b | 01100101b = 01111101b
-00011100b | 01100110b = 01111110b
-00011100b | 01100111b = 01111111b
-00011100b | 01101000b = 01111100b
-00011100b | 01101001b = 01111101b
-00011100b | 01101010b = 01111110b
-00011100b | 01101011b = 01111111b
-00011100b | 01101100b = 01111100b
-00011100b | 01101101b = 01111101b
-00011100b | 01101110b = 01111110b
-00011100b | 01101111b = 01111111b
-00011100b | 01110000b = 01111100b
-00011100b | 01110001b = 01111101b
-00011100b | 01110010b = 01111110b
-00011100b | 01110011b = 01111111b
-00011100b | 01110100b = 01111100b
-00011100b | 01110101b = 01111101b
-00011100b | 01110110b = 01111110b
-00011100b | 01110111b = 01111111b
-00011100b | 01111000b = 01111100b
-00011100b | 01111001b = 01111101b
-00011100b | 01111010b = 01111110b
-00011100b | 01111011b = 01111111b
-00011100b | 01111100b = 01111100b
-00011100b | 01111101b = 01111101b
-00011100b | 01111110b = 01111110b
-00011101b | 10000000b = 10011101b
-00011101b | 10000001b = 10011101b
-00011101b | 10000010b = 10011111b
-00011101b | 10000011b = 10011111b
-00011101b | 10000100b = 10011101b
-00011101b | 10000101b = 10011101b
-00011101b | 10000110b = 10011111b
-00011101b | 10000111b = 10011111b
-00011101b | 10001000b = 10011101b
-00011101b | 10001001b = 10011101b
-00011101b | 10001010b = 10011111b
-00011101b | 10001011b = 10011111b
-00011101b | 10001100b = 10011101b
-00011101b | 10001101b = 10011101b
-00011101b | 10001110b = 10011111b
-00011101b | 10001111b = 10011111b
-00011101b | 10010000b = 10011101b
-00011101b | 10010001b = 10011101b
-00011101b | 10010010b = 10011111b
-00011101b | 10010011b = 10011111b
-00011101b | 10010100b = 10011101b
-00011101b | 10010101b = 10011101b
-00011101b | 10010110b = 10011111b
-00011101b | 10010111b = 10011111b
-00011101b | 10011000b = 10011101b
-00011101b | 10011001b = 10011101b
-00011101b | 10011010b = 10011111b
-00011101b | 10011011b = 10011111b
-00011101b | 10011100b = 10011101b
-00011101b | 10011101b = 10011101b
-00011101b | 10011110b = 10011111b
-00011101b | 10011111b = 10011111b
-00011101b | 10100000b = 10111101b
-00011101b | 10100001b = 10111101b
-00011101b | 10100010b = 10111111b
-00011101b | 10100011b = 10111111b
-00011101b | 10100100b = 10111101b
-00011101b | 10100101b = 10111101b
-00011101b | 10100110b = 10111111b
-00011101b | 10100111b = 10111111b
-00011101b | 10101000b = 10111101b
-00011101b | 10101001b = 10111101b
-00011101b | 10101010b = 10111111b
-00011101b | 10101011b = 10111111b
-00011101b | 10101100b = 10111101b
-00011101b | 10101101b = 10111101b
-00011101b | 10101110b = 10111111b
-00011101b | 10101111b = 10111111b
-00011101b | 10110000b = 10111101b
-00011101b | 10110001b = 10111101b
-00011101b | 10110010b = 10111111b
-00011101b | 10110011b = 10111111b
-00011101b | 10110100b = 10111101b
-00011101b | 10110101b = 10111101b
-00011101b | 10110110b = 10111111b
-00011101b | 10110111b = 10111111b
-00011101b | 10111000b = 10111101b
-00011101b | 10111001b = 10111101b
-00011101b | 10111010b = 10111111b
-00011101b | 10111011b = 10111111b
-00011101b | 10111100b = 10111101b
-00011101b | 10111101b = 10111101b
-00011101b | 10111110b = 10111111b
-00011101b | 10111111b = 10111111b
-00011101b | 11000000b = 11011101b
-00011101b | 11000001b = 11011101b
-00011101b | 11000010b = 11011111b
-00011101b | 11000011b = 11011111b
-00011101b | 11000100b = 11011101b
-00011101b | 11000101b = 11011101b
-00011101b | 11000110b = 11011111b
-00011101b | 11000111b = 11011111b
-00011101b | 11001000b = 11011101b
-00011101b | 11001001b = 11011101b
-00011101b | 11001010b = 11011111b
-00011101b | 11001011b = 11011111b
-00011101b | 11001100b = 11011101b
-00011101b | 11001101b = 11011101b
-00011101b | 11001110b = 11011111b
-00011101b | 11001111b = 11011111b
-00011101b | 11010000b = 11011101b
-00011101b | 11010001b = 11011101b
-00011101b | 11010010b = 11011111b
-00011101b | 11010011b = 11011111b
-00011101b | 11010100b = 11011101b
-00011101b | 11010101b = 11011101b
-00011101b | 11010110b = 11011111b
-00011101b | 11010111b = 11011111b
-00011101b | 11011000b = 11011101b
-00011101b | 11011001b = 11011101b
-00011101b | 11011010b = 11011111b
-00011101b | 11011011b = 11011111b
-00011101b | 11011100b = 11011101b
-00011101b | 11011101b = 11011101b
-00011101b | 11011110b = 11011111b
-00011101b | 11011111b = 11011111b
-00011101b | 11100000b = 11111101b
-00011101b | 11100001b = 11111101b
-00011101b | 11100010b = 11111111b
-00011101b | 11100011b = 11111111b
-00011101b | 11100100b = 11111101b
-00011101b | 11100101b = 11111101b
-00011101b | 11100110b = 11111111b
-00011101b | 11100111b = 11111111b
-00011101b | 11101000b = 11111101b
-00011101b | 11101001b = 11111101b
-00011101b | 11101010b = 11111111b
-00011101b | 11101011b = 11111111b
-00011101b | 11101100b = 11111101b
-00011101b | 11101101b = 11111101b
-00011101b | 11101110b = 11111111b
-00011101b | 11101111b = 11111111b
-00011101b | 11110000b = 11111101b
-00011101b | 11110001b = 11111101b
-00011101b | 11110010b = 11111111b
-00011101b | 11110011b = 11111111b
-00011101b | 11110100b = 11111101b
-00011101b | 11110101b = 11111101b
-00011101b | 11110110b = 11111111b
-00011101b | 11110111b = 11111111b
-00011101b | 11111000b = 11111101b
-00011101b | 11111001b = 11111101b
-00011101b | 11111010b = 11111111b
-00011101b | 11111011b = 11111111b
-00011101b | 11111100b = 11111101b
-00011101b | 11111101b = 11111101b
-00011101b | 11111110b = 11111111b
-00011101b | 11111111b = 11111111b
-00011101b | 00000000b = 00011101b
-00011101b | 00000001b = 00011101b
-00011101b | 00000010b = 00011111b
-00011101b | 00000011b = 00011111b
-00011101b | 00000100b = 00011101b
-00011101b | 00000101b = 00011101b
-00011101b | 00000110b = 00011111b
-00011101b | 00000111b = 00011111b
-00011101b | 00001000b = 00011101b
-00011101b | 00001001b = 00011101b
-00011101b | 00001010b = 00011111b
-00011101b | 00001011b = 00011111b
-00011101b | 00001100b = 00011101b
-00011101b | 00001101b = 00011101b
-00011101b | 00001110b = 00011111b
-00011101b | 00001111b = 00011111b
-00011101b | 00010000b = 00011101b
-00011101b | 00010001b = 00011101b
-00011101b | 00010010b = 00011111b
-00011101b | 00010011b = 00011111b
-00011101b | 00010100b = 00011101b
-00011101b | 00010101b = 00011101b
-00011101b | 00010110b = 00011111b
-00011101b | 00010111b = 00011111b
-00011101b | 00011000b = 00011101b
-00011101b | 00011001b = 00011101b
-00011101b | 00011010b = 00011111b
-00011101b | 00011011b = 00011111b
-00011101b | 00011100b = 00011101b
-00011101b | 00011101b = 00011101b
-00011101b | 00011110b = 00011111b
-00011101b | 00011111b = 00011111b
-00011101b | 00100000b = 00111101b
-00011101b | 00100001b = 00111101b
-00011101b | 00100010b = 00111111b
-00011101b | 00100011b = 00111111b
-00011101b | 00100100b = 00111101b
-00011101b | 00100101b = 00111101b
-00011101b | 00100110b = 00111111b
-00011101b | 00100111b = 00111111b
-00011101b | 00101000b = 00111101b
-00011101b | 00101001b = 00111101b
-00011101b | 00101010b = 00111111b
-00011101b | 00101011b = 00111111b
-00011101b | 00101100b = 00111101b
-00011101b | 00101101b = 00111101b
-00011101b | 00101110b = 00111111b
-00011101b | 00101111b = 00111111b
-00011101b | 00110000b = 00111101b
-00011101b | 00110001b = 00111101b
-00011101b | 00110010b = 00111111b
-00011101b | 00110011b = 00111111b
-00011101b | 00110100b = 00111101b
-00011101b | 00110101b = 00111101b
-00011101b | 00110110b = 00111111b
-00011101b | 00110111b = 00111111b
-00011101b | 00111000b = 00111101b
-00011101b | 00111001b = 00111101b
-00011101b | 00111010b = 00111111b
-00011101b | 00111011b = 00111111b
-00011101b | 00111100b = 00111101b
-00011101b | 00111101b = 00111101b
-00011101b | 00111110b = 00111111b
-00011101b | 00111111b = 00111111b
-00011101b | 01000000b = 01011101b
-00011101b | 01000001b = 01011101b
-00011101b | 01000010b = 01011111b
-00011101b | 01000011b = 01011111b
-00011101b | 01000100b = 01011101b
-00011101b | 01000101b = 01011101b
-00011101b | 01000110b = 01011111b
-00011101b | 01000111b = 01011111b
-00011101b | 01001000b = 01011101b
-00011101b | 01001001b = 01011101b
-00011101b | 01001010b = 01011111b
-00011101b | 01001011b = 01011111b
-00011101b | 01001100b = 01011101b
-00011101b | 01001101b = 01011101b
-00011101b | 01001110b = 01011111b
-00011101b | 01001111b = 01011111b
-00011101b | 01010000b = 01011101b
-00011101b | 01010001b = 01011101b
-00011101b | 01010010b = 01011111b
-00011101b | 01010011b = 01011111b
-00011101b | 01010100b = 01011101b
-00011101b | 01010101b = 01011101b
-00011101b | 01010110b = 01011111b
-00011101b | 01010111b = 01011111b
-00011101b | 01011000b = 01011101b
-00011101b | 01011001b = 01011101b
-00011101b | 01011010b = 01011111b
-00011101b | 01011011b = 01011111b
-00011101b | 01011100b = 01011101b
-00011101b | 01011101b = 01011101b
-00011101b | 01011110b = 01011111b
-00011101b | 01011111b = 01011111b
-00011101b | 01100000b = 01111101b
-00011101b | 01100001b = 01111101b
-00011101b | 01100010b = 01111111b
-00011101b | 01100011b = 01111111b
-00011101b | 01100100b = 01111101b
-00011101b | 01100101b = 01111101b
-00011101b | 01100110b = 01111111b
-00011101b | 01100111b = 01111111b
-00011101b | 01101000b = 01111101b
-00011101b | 01101001b = 01111101b
-00011101b | 01101010b = 01111111b
-00011101b | 01101011b = 01111111b
-00011101b | 01101100b = 01111101b
-00011101b | 01101101b = 01111101b
-00011101b | 01101110b = 01111111b
-00011101b | 01101111b = 01111111b
-00011101b | 01110000b = 01111101b
-00011101b | 01110001b = 01111101b
-00011101b | 01110010b = 01111111b
-00011101b | 01110011b = 01111111b
-00011101b | 01110100b = 01111101b
-00011101b | 01110101b = 01111101b
-00011101b | 01110110b = 01111111b
-00011101b | 01110111b = 01111111b
-00011101b | 01111000b = 01111101b
-00011101b | 01111001b = 01111101b
-00011101b | 01111010b = 01111111b
-00011101b | 01111011b = 01111111b
-00011101b | 01111100b = 01111101b
-00011101b | 01111101b = 01111101b
-00011101b | 01111110b = 01111111b
-00011110b | 10000000b = 10011110b
-00011110b | 10000001b = 10011111b
-00011110b | 10000010b = 10011110b
-00011110b | 10000011b = 10011111b
-00011110b | 10000100b = 10011110b
-00011110b | 10000101b = 10011111b
-00011110b | 10000110b = 10011110b
-00011110b | 10000111b = 10011111b
-00011110b | 10001000b = 10011110b
-00011110b | 10001001b = 10011111b
-00011110b | 10001010b = 10011110b
-00011110b | 10001011b = 10011111b
-00011110b | 10001100b = 10011110b
-00011110b | 10001101b = 10011111b
-00011110b | 10001110b = 10011110b
-00011110b | 10001111b = 10011111b
-00011110b | 10010000b = 10011110b
-00011110b | 10010001b = 10011111b
-00011110b | 10010010b = 10011110b
-00011110b | 10010011b = 10011111b
-00011110b | 10010100b = 10011110b
-00011110b | 10010101b = 10011111b
-00011110b | 10010110b = 10011110b
-00011110b | 10010111b = 10011111b
-00011110b | 10011000b = 10011110b
-00011110b | 10011001b = 10011111b
-00011110b | 10011010b = 10011110b
-00011110b | 10011011b = 10011111b
-00011110b | 10011100b = 10011110b
-00011110b | 10011101b = 10011111b
-00011110b | 10011110b = 10011110b
-00011110b | 10011111b = 10011111b
-00011110b | 10100000b = 10111110b
-00011110b | 10100001b = 10111111b
-00011110b | 10100010b = 10111110b
-00011110b | 10100011b = 10111111b
-00011110b | 10100100b = 10111110b
-00011110b | 10100101b = 10111111b
-00011110b | 10100110b = 10111110b
-00011110b | 10100111b = 10111111b
-00011110b | 10101000b = 10111110b
-00011110b | 10101001b = 10111111b
-00011110b | 10101010b = 10111110b
-00011110b | 10101011b = 10111111b
-00011110b | 10101100b = 10111110b
-00011110b | 10101101b = 10111111b
-00011110b | 10101110b = 10111110b
-00011110b | 10101111b = 10111111b
-00011110b | 10110000b = 10111110b
-00011110b | 10110001b = 10111111b
-00011110b | 10110010b = 10111110b
-00011110b | 10110011b = 10111111b
-00011110b | 10110100b = 10111110b
-00011110b | 10110101b = 10111111b
-00011110b | 10110110b = 10111110b
-00011110b | 10110111b = 10111111b
-00011110b | 10111000b = 10111110b
-00011110b | 10111001b = 10111111b
-00011110b | 10111010b = 10111110b
-00011110b | 10111011b = 10111111b
-00011110b | 10111100b = 10111110b
-00011110b | 10111101b = 10111111b
-00011110b | 10111110b = 10111110b
-00011110b | 10111111b = 10111111b
-00011110b | 11000000b = 11011110b
-00011110b | 11000001b = 11011111b
-00011110b | 11000010b = 11011110b
-00011110b | 11000011b = 11011111b
-00011110b | 11000100b = 11011110b
-00011110b | 11000101b = 11011111b
-00011110b | 11000110b = 11011110b
-00011110b | 11000111b = 11011111b
-00011110b | 11001000b = 11011110b
-00011110b | 11001001b = 11011111b
-00011110b | 11001010b = 11011110b
-00011110b | 11001011b = 11011111b
-00011110b | 11001100b = 11011110b
-00011110b | 11001101b = 11011111b
-00011110b | 11001110b = 11011110b
-00011110b | 11001111b = 11011111b
-00011110b | 11010000b = 11011110b
-00011110b | 11010001b = 11011111b
-00011110b | 11010010b = 11011110b
-00011110b | 11010011b = 11011111b
-00011110b | 11010100b = 11011110b
-00011110b | 11010101b = 11011111b
-00011110b | 11010110b = 11011110b
-00011110b | 11010111b = 11011111b
-00011110b | 11011000b = 11011110b
-00011110b | 11011001b = 11011111b
-00011110b | 11011010b = 11011110b
-00011110b | 11011011b = 11011111b
-00011110b | 11011100b = 11011110b
-00011110b | 11011101b = 11011111b
-00011110b | 11011110b = 11011110b
-00011110b | 11011111b = 11011111b
-00011110b | 11100000b = 11111110b
-00011110b | 11100001b = 11111111b
-00011110b | 11100010b = 11111110b
-00011110b | 11100011b = 11111111b
-00011110b | 11100100b = 11111110b
-00011110b | 11100101b = 11111111b
-00011110b | 11100110b = 11111110b
-00011110b | 11100111b = 11111111b
-00011110b | 11101000b = 11111110b
-00011110b | 11101001b = 11111111b
-00011110b | 11101010b = 11111110b
-00011110b | 11101011b = 11111111b
-00011110b | 11101100b = 11111110b
-00011110b | 11101101b = 11111111b
-00011110b | 11101110b = 11111110b
-00011110b | 11101111b = 11111111b
-00011110b | 11110000b = 11111110b
-00011110b | 11110001b = 11111111b
-00011110b | 11110010b = 11111110b
-00011110b | 11110011b = 11111111b
-00011110b | 11110100b = 11111110b
-00011110b | 11110101b = 11111111b
-00011110b | 11110110b = 11111110b
-00011110b | 11110111b = 11111111b
-00011110b | 11111000b = 11111110b
-00011110b | 11111001b = 11111111b
-00011110b | 11111010b = 11111110b
-00011110b | 11111011b = 11111111b
-00011110b | 11111100b = 11111110b
-00011110b | 11111101b = 11111111b
-00011110b | 11111110b = 11111110b
-00011110b | 11111111b = 11111111b
-00011110b | 00000000b = 00011110b
-00011110b | 00000001b = 00011111b
-00011110b | 00000010b = 00011110b
-00011110b | 00000011b = 00011111b
-00011110b | 00000100b = 00011110b
-00011110b | 00000101b = 00011111b
-00011110b | 00000110b = 00011110b
-00011110b | 00000111b = 00011111b
-00011110b | 00001000b = 00011110b
-00011110b | 00001001b = 00011111b
-00011110b | 00001010b = 00011110b
-00011110b | 00001011b = 00011111b
-00011110b | 00001100b = 00011110b
-00011110b | 00001101b = 00011111b
-00011110b | 00001110b = 00011110b
-00011110b | 00001111b = 00011111b
-00011110b | 00010000b = 00011110b
-00011110b | 00010001b = 00011111b
-00011110b | 00010010b = 00011110b
-00011110b | 00010011b = 00011111b
-00011110b | 00010100b = 00011110b
-00011110b | 00010101b = 00011111b
-00011110b | 00010110b = 00011110b
-00011110b | 00010111b = 00011111b
-00011110b | 00011000b = 00011110b
-00011110b | 00011001b = 00011111b
-00011110b | 00011010b = 00011110b
-00011110b | 00011011b = 00011111b
-00011110b | 00011100b = 00011110b
-00011110b | 00011101b = 00011111b
-00011110b | 00011110b = 00011110b
-00011110b | 00011111b = 00011111b
-00011110b | 00100000b = 00111110b
-00011110b | 00100001b = 00111111b
-00011110b | 00100010b = 00111110b
-00011110b | 00100011b = 00111111b
-00011110b | 00100100b = 00111110b
-00011110b | 00100101b = 00111111b
-00011110b | 00100110b = 00111110b
-00011110b | 00100111b = 00111111b
-00011110b | 00101000b = 00111110b
-00011110b | 00101001b = 00111111b
-00011110b | 00101010b = 00111110b
-00011110b | 00101011b = 00111111b
-00011110b | 00101100b = 00111110b
-00011110b | 00101101b = 00111111b
-00011110b | 00101110b = 00111110b
-00011110b | 00101111b = 00111111b
-00011110b | 00110000b = 00111110b
-00011110b | 00110001b = 00111111b
-00011110b | 00110010b = 00111110b
-00011110b | 00110011b = 00111111b
-00011110b | 00110100b = 00111110b
-00011110b | 00110101b = 00111111b
-00011110b | 00110110b = 00111110b
-00011110b | 00110111b = 00111111b
-00011110b | 00111000b = 00111110b
-00011110b | 00111001b = 00111111b
-00011110b | 00111010b = 00111110b
-00011110b | 00111011b = 00111111b
-00011110b | 00111100b = 00111110b
-00011110b | 00111101b = 00111111b
-00011110b | 00111110b = 00111110b
-00011110b | 00111111b = 00111111b
-00011110b | 01000000b = 01011110b
-00011110b | 01000001b = 01011111b
-00011110b | 01000010b = 01011110b
-00011110b | 01000011b = 01011111b
-00011110b | 01000100b = 01011110b
-00011110b | 01000101b = 01011111b
-00011110b | 01000110b = 01011110b
-00011110b | 01000111b = 01011111b
-00011110b | 01001000b = 01011110b
-00011110b | 01001001b = 01011111b
-00011110b | 01001010b = 01011110b
-00011110b | 01001011b = 01011111b
-00011110b | 01001100b = 01011110b
-00011110b | 01001101b = 01011111b
-00011110b | 01001110b = 01011110b
-00011110b | 01001111b = 01011111b
-00011110b | 01010000b = 01011110b
-00011110b | 01010001b = 01011111b
-00011110b | 01010010b = 01011110b
-00011110b | 01010011b = 01011111b
-00011110b | 01010100b = 01011110b
-00011110b | 01010101b = 01011111b
-00011110b | 01010110b = 01011110b
-00011110b | 01010111b = 01011111b
-00011110b | 01011000b = 01011110b
-00011110b | 01011001b = 01011111b
-00011110b | 01011010b = 01011110b
-00011110b | 01011011b = 01011111b
-00011110b | 01011100b = 01011110b
-00011110b | 01011101b = 01011111b
-00011110b | 01011110b = 01011110b
-00011110b | 01011111b = 01011111b
-00011110b | 01100000b = 01111110b
-00011110b | 01100001b = 01111111b
-00011110b | 01100010b = 01111110b
-00011110b | 01100011b = 01111111b
-00011110b | 01100100b = 01111110b
-00011110b | 01100101b = 01111111b
-00011110b | 01100110b = 01111110b
-00011110b | 01100111b = 01111111b
-00011110b | 01101000b = 01111110b
-00011110b | 01101001b = 01111111b
-00011110b | 01101010b = 01111110b
-00011110b | 01101011b = 01111111b
-00011110b | 01101100b = 01111110b
-00011110b | 01101101b = 01111111b
-00011110b | 01101110b = 01111110b
-00011110b | 01101111b = 01111111b
-00011110b | 01110000b = 01111110b
-00011110b | 01110001b = 01111111b
-00011110b | 01110010b = 01111110b
-00011110b | 01110011b = 01111111b
-00011110b | 01110100b = 01111110b
-00011110b | 01110101b = 01111111b
-00011110b | 01110110b = 01111110b
-00011110b | 01110111b = 01111111b
-00011110b | 01111000b = 01111110b
-00011110b | 01111001b = 01111111b
-00011110b | 01111010b = 01111110b
-00011110b | 01111011b = 01111111b
-00011110b | 01111100b = 01111110b
-00011110b | 01111101b = 01111111b
-00011110b | 01111110b = 01111110b
-00011111b | 10000000b = 10011111b
-00011111b | 10000001b = 10011111b
-00011111b | 10000010b = 10011111b
-00011111b | 10000011b = 10011111b
-00011111b | 10000100b = 10011111b
-00011111b | 10000101b = 10011111b
-00011111b | 10000110b = 10011111b
-00011111b | 10000111b = 10011111b
-00011111b | 10001000b = 10011111b
-00011111b | 10001001b = 10011111b
-00011111b | 10001010b = 10011111b
-00011111b | 10001011b = 10011111b
-00011111b | 10001100b = 10011111b
-00011111b | 10001101b = 10011111b
-00011111b | 10001110b = 10011111b
-00011111b | 10001111b = 10011111b
-00011111b | 10010000b = 10011111b
-00011111b | 10010001b = 10011111b
-00011111b | 10010010b = 10011111b
-00011111b | 10010011b = 10011111b
-00011111b | 10010100b = 10011111b
-00011111b | 10010101b = 10011111b
-00011111b | 10010110b = 10011111b
-00011111b | 10010111b = 10011111b
-00011111b | 10011000b = 10011111b
-00011111b | 10011001b = 10011111b
-00011111b | 10011010b = 10011111b
-00011111b | 10011011b = 10011111b
-00011111b | 10011100b = 10011111b
-00011111b | 10011101b = 10011111b
-00011111b | 10011110b = 10011111b
-00011111b | 10011111b = 10011111b
-00011111b | 10100000b = 10111111b
-00011111b | 10100001b = 10111111b
-00011111b | 10100010b = 10111111b
-00011111b | 10100011b = 10111111b
-00011111b | 10100100b = 10111111b
-00011111b | 10100101b = 10111111b
-00011111b | 10100110b = 10111111b
-00011111b | 10100111b = 10111111b
-00011111b | 10101000b = 10111111b
-00011111b | 10101001b = 10111111b
-00011111b | 10101010b = 10111111b
-00011111b | 10101011b = 10111111b
-00011111b | 10101100b = 10111111b
-00011111b | 10101101b = 10111111b
-00011111b | 10101110b = 10111111b
-00011111b | 10101111b = 10111111b
-00011111b | 10110000b = 10111111b
-00011111b | 10110001b = 10111111b
-00011111b | 10110010b = 10111111b
-00011111b | 10110011b = 10111111b
-00011111b | 10110100b = 10111111b
-00011111b | 10110101b = 10111111b
-00011111b | 10110110b = 10111111b
-00011111b | 10110111b = 10111111b
-00011111b | 10111000b = 10111111b
-00011111b | 10111001b = 10111111b
-00011111b | 10111010b = 10111111b
-00011111b | 10111011b = 10111111b
-00011111b | 10111100b = 10111111b
-00011111b | 10111101b = 10111111b
-00011111b | 10111110b = 10111111b
-00011111b | 10111111b = 10111111b
-00011111b | 11000000b = 11011111b
-00011111b | 11000001b = 11011111b
-00011111b | 11000010b = 11011111b
-00011111b | 11000011b = 11011111b
-00011111b | 11000100b = 11011111b
-00011111b | 11000101b = 11011111b
-00011111b | 11000110b = 11011111b
-00011111b | 11000111b = 11011111b
-00011111b | 11001000b = 11011111b
-00011111b | 11001001b = 11011111b
-00011111b | 11001010b = 11011111b
-00011111b | 11001011b = 11011111b
-00011111b | 11001100b = 11011111b
-00011111b | 11001101b = 11011111b
-00011111b | 11001110b = 11011111b
-00011111b | 11001111b = 11011111b
-00011111b | 11010000b = 11011111b
-00011111b | 11010001b = 11011111b
-00011111b | 11010010b = 11011111b
-00011111b | 11010011b = 11011111b
-00011111b | 11010100b = 11011111b
-00011111b | 11010101b = 11011111b
-00011111b | 11010110b = 11011111b
-00011111b | 11010111b = 11011111b
-00011111b | 11011000b = 11011111b
-00011111b | 11011001b = 11011111b
-00011111b | 11011010b = 11011111b
-00011111b | 11011011b = 11011111b
-00011111b | 11011100b = 11011111b
-00011111b | 11011101b = 11011111b
-00011111b | 11011110b = 11011111b
-00011111b | 11011111b = 11011111b
-00011111b | 11100000b = 11111111b
-00011111b | 11100001b = 11111111b
-00011111b | 11100010b = 11111111b
-00011111b | 11100011b = 11111111b
-00011111b | 11100100b = 11111111b
-00011111b | 11100101b = 11111111b
-00011111b | 11100110b = 11111111b
-00011111b | 11100111b = 11111111b
-00011111b | 11101000b = 11111111b
-00011111b | 11101001b = 11111111b
-00011111b | 11101010b = 11111111b
-00011111b | 11101011b = 11111111b
-00011111b | 11101100b = 11111111b
-00011111b | 11101101b = 11111111b
-00011111b | 11101110b = 11111111b
-00011111b | 11101111b = 11111111b
-00011111b | 11110000b = 11111111b
-00011111b | 11110001b = 11111111b
-00011111b | 11110010b = 11111111b
-00011111b | 11110011b = 11111111b
-00011111b | 11110100b = 11111111b
-00011111b | 11110101b = 11111111b
-00011111b | 11110110b = 11111111b
-00011111b | 11110111b = 11111111b
-00011111b | 11111000b = 11111111b
-00011111b | 11111001b = 11111111b
-00011111b | 11111010b = 11111111b
-00011111b | 11111011b = 11111111b
-00011111b | 11111100b = 11111111b
-00011111b | 11111101b = 11111111b
-00011111b | 11111110b = 11111111b
-00011111b | 11111111b = 11111111b
-00011111b | 00000000b = 00011111b
-00011111b | 00000001b = 00011111b
-00011111b | 00000010b = 00011111b
-00011111b | 00000011b = 00011111b
-00011111b | 00000100b = 00011111b
-00011111b | 00000101b = 00011111b
-00011111b | 00000110b = 00011111b
-00011111b | 00000111b = 00011111b
-00011111b | 00001000b = 00011111b
-00011111b | 00001001b = 00011111b
-00011111b | 00001010b = 00011111b
-00011111b | 00001011b = 00011111b
-00011111b | 00001100b = 00011111b
-00011111b | 00001101b = 00011111b
-00011111b | 00001110b = 00011111b
-00011111b | 00001111b = 00011111b
-00011111b | 00010000b = 00011111b
-00011111b | 00010001b = 00011111b
-00011111b | 00010010b = 00011111b
-00011111b | 00010011b = 00011111b
-00011111b | 00010100b = 00011111b
-00011111b | 00010101b = 00011111b
-00011111b | 00010110b = 00011111b
-00011111b | 00010111b = 00011111b
-00011111b | 00011000b = 00011111b
-00011111b | 00011001b = 00011111b
-00011111b | 00011010b = 00011111b
-00011111b | 00011011b = 00011111b
-00011111b | 00011100b = 00011111b
-00011111b | 00011101b = 00011111b
-00011111b | 00011110b = 00011111b
-00011111b | 00011111b = 00011111b
-00011111b | 00100000b = 00111111b
-00011111b | 00100001b = 00111111b
-00011111b | 00100010b = 00111111b
-00011111b | 00100011b = 00111111b
-00011111b | 00100100b = 00111111b
-00011111b | 00100101b = 00111111b
-00011111b | 00100110b = 00111111b
-00011111b | 00100111b = 00111111b
-00011111b | 00101000b = 00111111b
-00011111b | 00101001b = 00111111b
-00011111b | 00101010b = 00111111b
-00011111b | 00101011b = 00111111b
-00011111b | 00101100b = 00111111b
-00011111b | 00101101b = 00111111b
-00011111b | 00101110b = 00111111b
-00011111b | 00101111b = 00111111b
-00011111b | 00110000b = 00111111b
-00011111b | 00110001b = 00111111b
-00011111b | 00110010b = 00111111b
-00011111b | 00110011b = 00111111b
-00011111b | 00110100b = 00111111b
-00011111b | 00110101b = 00111111b
-00011111b | 00110110b = 00111111b
-00011111b | 00110111b = 00111111b
-00011111b | 00111000b = 00111111b
-00011111b | 00111001b = 00111111b
-00011111b | 00111010b = 00111111b
-00011111b | 00111011b = 00111111b
-00011111b | 00111100b = 00111111b
-00011111b | 00111101b = 00111111b
-00011111b | 00111110b = 00111111b
-00011111b | 00111111b = 00111111b
-00011111b | 01000000b = 01011111b
-00011111b | 01000001b = 01011111b
-00011111b | 01000010b = 01011111b
-00011111b | 01000011b = 01011111b
-00011111b | 01000100b = 01011111b
-00011111b | 01000101b = 01011111b
-00011111b | 01000110b = 01011111b
-00011111b | 01000111b = 01011111b
-00011111b | 01001000b = 01011111b
-00011111b | 01001001b = 01011111b
-00011111b | 01001010b = 01011111b
-00011111b | 01001011b = 01011111b
-00011111b | 01001100b = 01011111b
-00011111b | 01001101b = 01011111b
-00011111b | 01001110b = 01011111b
-00011111b | 01001111b = 01011111b
-00011111b | 01010000b = 01011111b
-00011111b | 01010001b = 01011111b
-00011111b | 01010010b = 01011111b
-00011111b | 01010011b = 01011111b
-00011111b | 01010100b = 01011111b
-00011111b | 01010101b = 01011111b
-00011111b | 01010110b = 01011111b
-00011111b | 01010111b = 01011111b
-00011111b | 01011000b = 01011111b
-00011111b | 01011001b = 01011111b
-00011111b | 01011010b = 01011111b
-00011111b | 01011011b = 01011111b
-00011111b | 01011100b = 01011111b
-00011111b | 01011101b = 01011111b
-00011111b | 01011110b = 01011111b
-00011111b | 01011111b = 01011111b
-00011111b | 01100000b = 01111111b
-00011111b | 01100001b = 01111111b
-00011111b | 01100010b = 01111111b
-00011111b | 01100011b = 01111111b
-00011111b | 01100100b = 01111111b
-00011111b | 01100101b = 01111111b
-00011111b | 01100110b = 01111111b
-00011111b | 01100111b = 01111111b
-00011111b | 01101000b = 01111111b
-00011111b | 01101001b = 01111111b
-00011111b | 01101010b = 01111111b
-00011111b | 01101011b = 01111111b
-00011111b | 01101100b = 01111111b
-00011111b | 01101101b = 01111111b
-00011111b | 01101110b = 01111111b
-00011111b | 01101111b = 01111111b
-00011111b | 01110000b = 01111111b
-00011111b | 01110001b = 01111111b
-00011111b | 01110010b = 01111111b
-00011111b | 01110011b = 01111111b
-00011111b | 01110100b = 01111111b
-00011111b | 01110101b = 01111111b
-00011111b | 01110110b = 01111111b
-00011111b | 01110111b = 01111111b
-00011111b | 01111000b = 01111111b
-00011111b | 01111001b = 01111111b
-00011111b | 01111010b = 01111111b
-00011111b | 01111011b = 01111111b
-00011111b | 01111100b = 01111111b
-00011111b | 01111101b = 01111111b
-00011111b | 01111110b = 01111111b
-00100000b | 10000000b = 10100000b
-00100000b | 10000001b = 10100001b
-00100000b | 10000010b = 10100010b
-00100000b | 10000011b = 10100011b
-00100000b | 10000100b = 10100100b
-00100000b | 10000101b = 10100101b
-00100000b | 10000110b = 10100110b
-00100000b | 10000111b = 10100111b
-00100000b | 10001000b = 10101000b
-00100000b | 10001001b = 10101001b
-00100000b | 10001010b = 10101010b
-00100000b | 10001011b = 10101011b
-00100000b | 10001100b = 10101100b
-00100000b | 10001101b = 10101101b
-00100000b | 10001110b = 10101110b
-00100000b | 10001111b = 10101111b
-00100000b | 10010000b = 10110000b
-00100000b | 10010001b = 10110001b
-00100000b | 10010010b = 10110010b
-00100000b | 10010011b = 10110011b
-00100000b | 10010100b = 10110100b
-00100000b | 10010101b = 10110101b
-00100000b | 10010110b = 10110110b
-00100000b | 10010111b = 10110111b
-00100000b | 10011000b = 10111000b
-00100000b | 10011001b = 10111001b
-00100000b | 10011010b = 10111010b
-00100000b | 10011011b = 10111011b
-00100000b | 10011100b = 10111100b
-00100000b | 10011101b = 10111101b
-00100000b | 10011110b = 10111110b
-00100000b | 10011111b = 10111111b
-00100000b | 10100000b = 10100000b
-00100000b | 10100001b = 10100001b
-00100000b | 10100010b = 10100010b
-00100000b | 10100011b = 10100011b
-00100000b | 10100100b = 10100100b
-00100000b | 10100101b = 10100101b
-00100000b | 10100110b = 10100110b
-00100000b | 10100111b = 10100111b
-00100000b | 10101000b = 10101000b
-00100000b | 10101001b = 10101001b
-00100000b | 10101010b = 10101010b
-00100000b | 10101011b = 10101011b
-00100000b | 10101100b = 10101100b
-00100000b | 10101101b = 10101101b
-00100000b | 10101110b = 10101110b
-00100000b | 10101111b = 10101111b
-00100000b | 10110000b = 10110000b
-00100000b | 10110001b = 10110001b
-00100000b | 10110010b = 10110010b
-00100000b | 10110011b = 10110011b
-00100000b | 10110100b = 10110100b
-00100000b | 10110101b = 10110101b
-00100000b | 10110110b = 10110110b
-00100000b | 10110111b = 10110111b
-00100000b | 10111000b = 10111000b
-00100000b | 10111001b = 10111001b
-00100000b | 10111010b = 10111010b
-00100000b | 10111011b = 10111011b
-00100000b | 10111100b = 10111100b
-00100000b | 10111101b = 10111101b
-00100000b | 10111110b = 10111110b
-00100000b | 10111111b = 10111111b
-00100000b | 11000000b = 11100000b
-00100000b | 11000001b = 11100001b
-00100000b | 11000010b = 11100010b
-00100000b | 11000011b = 11100011b
-00100000b | 11000100b = 11100100b
-00100000b | 11000101b = 11100101b
-00100000b | 11000110b = 11100110b
-00100000b | 11000111b = 11100111b
-00100000b | 11001000b = 11101000b
-00100000b | 11001001b = 11101001b
-00100000b | 11001010b = 11101010b
-00100000b | 11001011b = 11101011b
-00100000b | 11001100b = 11101100b
-00100000b | 11001101b = 11101101b
-00100000b | 11001110b = 11101110b
-00100000b | 11001111b = 11101111b
-00100000b | 11010000b = 11110000b
-00100000b | 11010001b = 11110001b
-00100000b | 11010010b = 11110010b
-00100000b | 11010011b = 11110011b
-00100000b | 11010100b = 11110100b
-00100000b | 11010101b = 11110101b
-00100000b | 11010110b = 11110110b
-00100000b | 11010111b = 11110111b
-00100000b | 11011000b = 11111000b
-00100000b | 11011001b = 11111001b
-00100000b | 11011010b = 11111010b
-00100000b | 11011011b = 11111011b
-00100000b | 11011100b = 11111100b
-00100000b | 11011101b = 11111101b
-00100000b | 11011110b = 11111110b
-00100000b | 11011111b = 11111111b
-00100000b | 11100000b = 11100000b
-00100000b | 11100001b = 11100001b
-00100000b | 11100010b = 11100010b
-00100000b | 11100011b = 11100011b
-00100000b | 11100100b = 11100100b
-00100000b | 11100101b = 11100101b
-00100000b | 11100110b = 11100110b
-00100000b | 11100111b = 11100111b
-00100000b | 11101000b = 11101000b
-00100000b | 11101001b = 11101001b
-00100000b | 11101010b = 11101010b
-00100000b | 11101011b = 11101011b
-00100000b | 11101100b = 11101100b
-00100000b | 11101101b = 11101101b
-00100000b | 11101110b = 11101110b
-00100000b | 11101111b = 11101111b
-00100000b | 11110000b = 11110000b
-00100000b | 11110001b = 11110001b
-00100000b | 11110010b = 11110010b
-00100000b | 11110011b = 11110011b
-00100000b | 11110100b = 11110100b
-00100000b | 11110101b = 11110101b
-00100000b | 11110110b = 11110110b
-00100000b | 11110111b = 11110111b
-00100000b | 11111000b = 11111000b
-00100000b | 11111001b = 11111001b
-00100000b | 11111010b = 11111010b
-00100000b | 11111011b = 11111011b
-00100000b | 11111100b = 11111100b
-00100000b | 11111101b = 11111101b
-00100000b | 11111110b = 11111110b
-00100000b | 11111111b = 11111111b
-00100000b | 00000000b = 00100000b
-00100000b | 00000001b = 00100001b
-00100000b | 00000010b = 00100010b
-00100000b | 00000011b = 00100011b
-00100000b | 00000100b = 00100100b
-00100000b | 00000101b = 00100101b
-00100000b | 00000110b = 00100110b
-00100000b | 00000111b = 00100111b
-00100000b | 00001000b = 00101000b
-00100000b | 00001001b = 00101001b
-00100000b | 00001010b = 00101010b
-00100000b | 00001011b = 00101011b
-00100000b | 00001100b = 00101100b
-00100000b | 00001101b = 00101101b
-00100000b | 00001110b = 00101110b
-00100000b | 00001111b = 00101111b
-00100000b | 00010000b = 00110000b
-00100000b | 00010001b = 00110001b
-00100000b | 00010010b = 00110010b
-00100000b | 00010011b = 00110011b
-00100000b | 00010100b = 00110100b
-00100000b | 00010101b = 00110101b
-00100000b | 00010110b = 00110110b
-00100000b | 00010111b = 00110111b
-00100000b | 00011000b = 00111000b
-00100000b | 00011001b = 00111001b
-00100000b | 00011010b = 00111010b
-00100000b | 00011011b = 00111011b
-00100000b | 00011100b = 00111100b
-00100000b | 00011101b = 00111101b
-00100000b | 00011110b = 00111110b
-00100000b | 00011111b = 00111111b
-00100000b | 00100000b = 00100000b
-00100000b | 00100001b = 00100001b
-00100000b | 00100010b = 00100010b
-00100000b | 00100011b = 00100011b
-00100000b | 00100100b = 00100100b
-00100000b | 00100101b = 00100101b
-00100000b | 00100110b = 00100110b
-00100000b | 00100111b = 00100111b
-00100000b | 00101000b = 00101000b
-00100000b | 00101001b = 00101001b
-00100000b | 00101010b = 00101010b
-00100000b | 00101011b = 00101011b
-00100000b | 00101100b = 00101100b
-00100000b | 00101101b = 00101101b
-00100000b | 00101110b = 00101110b
-00100000b | 00101111b = 00101111b
-00100000b | 00110000b = 00110000b
-00100000b | 00110001b = 00110001b
-00100000b | 00110010b = 00110010b
-00100000b | 00110011b = 00110011b
-00100000b | 00110100b = 00110100b
-00100000b | 00110101b = 00110101b
-00100000b | 00110110b = 00110110b
-00100000b | 00110111b = 00110111b
-00100000b | 00111000b = 00111000b
-00100000b | 00111001b = 00111001b
-00100000b | 00111010b = 00111010b
-00100000b | 00111011b = 00111011b
-00100000b | 00111100b = 00111100b
-00100000b | 00111101b = 00111101b
-00100000b | 00111110b = 00111110b
-00100000b | 00111111b = 00111111b
-00100000b | 01000000b = 01100000b
-00100000b | 01000001b = 01100001b
-00100000b | 01000010b = 01100010b
-00100000b | 01000011b = 01100011b
-00100000b | 01000100b = 01100100b
-00100000b | 01000101b = 01100101b
-00100000b | 01000110b = 01100110b
-00100000b | 01000111b = 01100111b
-00100000b | 01001000b = 01101000b
-00100000b | 01001001b = 01101001b
-00100000b | 01001010b = 01101010b
-00100000b | 01001011b = 01101011b
-00100000b | 01001100b = 01101100b
-00100000b | 01001101b = 01101101b
-00100000b | 01001110b = 01101110b
-00100000b | 01001111b = 01101111b
-00100000b | 01010000b = 01110000b
-00100000b | 01010001b = 01110001b
-00100000b | 01010010b = 01110010b
-00100000b | 01010011b = 01110011b
-00100000b | 01010100b = 01110100b
-00100000b | 01010101b = 01110101b
-00100000b | 01010110b = 01110110b
-00100000b | 01010111b = 01110111b
-00100000b | 01011000b = 01111000b
-00100000b | 01011001b = 01111001b
-00100000b | 01011010b = 01111010b
-00100000b | 01011011b = 01111011b
-00100000b | 01011100b = 01111100b
-00100000b | 01011101b = 01111101b
-00100000b | 01011110b = 01111110b
-00100000b | 01011111b = 01111111b
-00100000b | 01100000b = 01100000b
-00100000b | 01100001b = 01100001b
-00100000b | 01100010b = 01100010b
-00100000b | 01100011b = 01100011b
-00100000b | 01100100b = 01100100b
-00100000b | 01100101b = 01100101b
-00100000b | 01100110b = 01100110b
-00100000b | 01100111b = 01100111b
-00100000b | 01101000b = 01101000b
-00100000b | 01101001b = 01101001b
-00100000b | 01101010b = 01101010b
-00100000b | 01101011b = 01101011b
-00100000b | 01101100b = 01101100b
-00100000b | 01101101b = 01101101b
-00100000b | 01101110b = 01101110b
-00100000b | 01101111b = 01101111b
-00100000b | 01110000b = 01110000b
-00100000b | 01110001b = 01110001b
-00100000b | 01110010b = 01110010b
-00100000b | 01110011b = 01110011b
-00100000b | 01110100b = 01110100b
-00100000b | 01110101b = 01110101b
-00100000b | 01110110b = 01110110b
-00100000b | 01110111b = 01110111b
-00100000b | 01111000b = 01111000b
-00100000b | 01111001b = 01111001b
-00100000b | 01111010b = 01111010b
-00100000b | 01111011b = 01111011b
-00100000b | 01111100b = 01111100b
-00100000b | 01111101b = 01111101b
-00100000b | 01111110b = 01111110b
-00100001b | 10000000b = 10100001b
-00100001b | 10000001b = 10100001b
-00100001b | 10000010b = 10100011b
-00100001b | 10000011b = 10100011b
-00100001b | 10000100b = 10100101b
-00100001b | 10000101b = 10100101b
-00100001b | 10000110b = 10100111b
-00100001b | 10000111b = 10100111b
-00100001b | 10001000b = 10101001b
-00100001b | 10001001b = 10101001b
-00100001b | 10001010b = 10101011b
-00100001b | 10001011b = 10101011b
-00100001b | 10001100b = 10101101b
-00100001b | 10001101b = 10101101b
-00100001b | 10001110b = 10101111b
-00100001b | 10001111b = 10101111b
-00100001b | 10010000b = 10110001b
-00100001b | 10010001b = 10110001b
-00100001b | 10010010b = 10110011b
-00100001b | 10010011b = 10110011b
-00100001b | 10010100b = 10110101b
-00100001b | 10010101b = 10110101b
-00100001b | 10010110b = 10110111b
-00100001b | 10010111b = 10110111b
-00100001b | 10011000b = 10111001b
-00100001b | 10011001b = 10111001b
-00100001b | 10011010b = 10111011b
-00100001b | 10011011b = 10111011b
-00100001b | 10011100b = 10111101b
-00100001b | 10011101b = 10111101b
-00100001b | 10011110b = 10111111b
-00100001b | 10011111b = 10111111b
-00100001b | 10100000b = 10100001b
-00100001b | 10100001b = 10100001b
-00100001b | 10100010b = 10100011b
-00100001b | 10100011b = 10100011b
-00100001b | 10100100b = 10100101b
-00100001b | 10100101b = 10100101b
-00100001b | 10100110b = 10100111b
-00100001b | 10100111b = 10100111b
-00100001b | 10101000b = 10101001b
-00100001b | 10101001b = 10101001b
-00100001b | 10101010b = 10101011b
-00100001b | 10101011b = 10101011b
-00100001b | 10101100b = 10101101b
-00100001b | 10101101b = 10101101b
-00100001b | 10101110b = 10101111b
-00100001b | 10101111b = 10101111b
-00100001b | 10110000b = 10110001b
-00100001b | 10110001b = 10110001b
-00100001b | 10110010b = 10110011b
-00100001b | 10110011b = 10110011b
-00100001b | 10110100b = 10110101b
-00100001b | 10110101b = 10110101b
-00100001b | 10110110b = 10110111b
-00100001b | 10110111b = 10110111b
-00100001b | 10111000b = 10111001b
-00100001b | 10111001b = 10111001b
-00100001b | 10111010b = 10111011b
-00100001b | 10111011b = 10111011b
-00100001b | 10111100b = 10111101b
-00100001b | 10111101b = 10111101b
-00100001b | 10111110b = 10111111b
-00100001b | 10111111b = 10111111b
-00100001b | 11000000b = 11100001b
-00100001b | 11000001b = 11100001b
-00100001b | 11000010b = 11100011b
-00100001b | 11000011b = 11100011b
-00100001b | 11000100b = 11100101b
-00100001b | 11000101b = 11100101b
-00100001b | 11000110b = 11100111b
-00100001b | 11000111b = 11100111b
-00100001b | 11001000b = 11101001b
-00100001b | 11001001b = 11101001b
-00100001b | 11001010b = 11101011b
-00100001b | 11001011b = 11101011b
-00100001b | 11001100b = 11101101b
-00100001b | 11001101b = 11101101b
-00100001b | 11001110b = 11101111b
-00100001b | 11001111b = 11101111b
-00100001b | 11010000b = 11110001b
-00100001b | 11010001b = 11110001b
-00100001b | 11010010b = 11110011b
-00100001b | 11010011b = 11110011b
-00100001b | 11010100b = 11110101b
-00100001b | 11010101b = 11110101b
-00100001b | 11010110b = 11110111b
-00100001b | 11010111b = 11110111b
-00100001b | 11011000b = 11111001b
-00100001b | 11011001b = 11111001b
-00100001b | 11011010b = 11111011b
-00100001b | 11011011b = 11111011b
-00100001b | 11011100b = 11111101b
-00100001b | 11011101b = 11111101b
-00100001b | 11011110b = 11111111b
-00100001b | 11011111b = 11111111b
-00100001b | 11100000b = 11100001b
-00100001b | 11100001b = 11100001b
-00100001b | 11100010b = 11100011b
-00100001b | 11100011b = 11100011b
-00100001b | 11100100b = 11100101b
-00100001b | 11100101b = 11100101b
-00100001b | 11100110b = 11100111b
-00100001b | 11100111b = 11100111b
-00100001b | 11101000b = 11101001b
-00100001b | 11101001b = 11101001b
-00100001b | 11101010b = 11101011b
-00100001b | 11101011b = 11101011b
-00100001b | 11101100b = 11101101b
-00100001b | 11101101b = 11101101b
-00100001b | 11101110b = 11101111b
-00100001b | 11101111b = 11101111b
-00100001b | 11110000b = 11110001b
-00100001b | 11110001b = 11110001b
-00100001b | 11110010b = 11110011b
-00100001b | 11110011b = 11110011b
-00100001b | 11110100b = 11110101b
-00100001b | 11110101b = 11110101b
-00100001b | 11110110b = 11110111b
-00100001b | 11110111b = 11110111b
-00100001b | 11111000b = 11111001b
-00100001b | 11111001b = 11111001b
-00100001b | 11111010b = 11111011b
-00100001b | 11111011b = 11111011b
-00100001b | 11111100b = 11111101b
-00100001b | 11111101b = 11111101b
-00100001b | 11111110b = 11111111b
-00100001b | 11111111b = 11111111b
-00100001b | 00000000b = 00100001b
-00100001b | 00000001b = 00100001b
-00100001b | 00000010b = 00100011b
-00100001b | 00000011b = 00100011b
-00100001b | 00000100b = 00100101b
-00100001b | 00000101b = 00100101b
-00100001b | 00000110b = 00100111b
-00100001b | 00000111b = 00100111b
-00100001b | 00001000b = 00101001b
-00100001b | 00001001b = 00101001b
-00100001b | 00001010b = 00101011b
-00100001b | 00001011b = 00101011b
-00100001b | 00001100b = 00101101b
-00100001b | 00001101b = 00101101b
-00100001b | 00001110b = 00101111b
-00100001b | 00001111b = 00101111b
-00100001b | 00010000b = 00110001b
-00100001b | 00010001b = 00110001b
-00100001b | 00010010b = 00110011b
-00100001b | 00010011b = 00110011b
-00100001b | 00010100b = 00110101b
-00100001b | 00010101b = 00110101b
-00100001b | 00010110b = 00110111b
-00100001b | 00010111b = 00110111b
-00100001b | 00011000b = 00111001b
-00100001b | 00011001b = 00111001b
-00100001b | 00011010b = 00111011b
-00100001b | 00011011b = 00111011b
-00100001b | 00011100b = 00111101b
-00100001b | 00011101b = 00111101b
-00100001b | 00011110b = 00111111b
-00100001b | 00011111b = 00111111b
-00100001b | 00100000b = 00100001b
-00100001b | 00100001b = 00100001b
-00100001b | 00100010b = 00100011b
-00100001b | 00100011b = 00100011b
-00100001b | 00100100b = 00100101b
-00100001b | 00100101b = 00100101b
-00100001b | 00100110b = 00100111b
-00100001b | 00100111b = 00100111b
-00100001b | 00101000b = 00101001b
-00100001b | 00101001b = 00101001b
-00100001b | 00101010b = 00101011b
-00100001b | 00101011b = 00101011b
-00100001b | 00101100b = 00101101b
-00100001b | 00101101b = 00101101b
-00100001b | 00101110b = 00101111b
-00100001b | 00101111b = 00101111b
-00100001b | 00110000b = 00110001b
-00100001b | 00110001b = 00110001b
-00100001b | 00110010b = 00110011b
-00100001b | 00110011b = 00110011b
-00100001b | 00110100b = 00110101b
-00100001b | 00110101b = 00110101b
-00100001b | 00110110b = 00110111b
-00100001b | 00110111b = 00110111b
-00100001b | 00111000b = 00111001b
-00100001b | 00111001b = 00111001b
-00100001b | 00111010b = 00111011b
-00100001b | 00111011b = 00111011b
-00100001b | 00111100b = 00111101b
-00100001b | 00111101b = 00111101b
-00100001b | 00111110b = 00111111b
-00100001b | 00111111b = 00111111b
-00100001b | 01000000b = 01100001b
-00100001b | 01000001b = 01100001b
-00100001b | 01000010b = 01100011b
-00100001b | 01000011b = 01100011b
-00100001b | 01000100b = 01100101b
-00100001b | 01000101b = 01100101b
-00100001b | 01000110b = 01100111b
-00100001b | 01000111b = 01100111b
-00100001b | 01001000b = 01101001b
-00100001b | 01001001b = 01101001b
-00100001b | 01001010b = 01101011b
-00100001b | 01001011b = 01101011b
-00100001b | 01001100b = 01101101b
-00100001b | 01001101b = 01101101b
-00100001b | 01001110b = 01101111b
-00100001b | 01001111b = 01101111b
-00100001b | 01010000b = 01110001b
-00100001b | 01010001b = 01110001b
-00100001b | 01010010b = 01110011b
-00100001b | 01010011b = 01110011b
-00100001b | 01010100b = 01110101b
-00100001b | 01010101b = 01110101b
-00100001b | 01010110b = 01110111b
-00100001b | 01010111b = 01110111b
-00100001b | 01011000b = 01111001b
-00100001b | 01011001b = 01111001b
-00100001b | 01011010b = 01111011b
-00100001b | 01011011b = 01111011b
-00100001b | 01011100b = 01111101b
-00100001b | 01011101b = 01111101b
-00100001b | 01011110b = 01111111b
-00100001b | 01011111b = 01111111b
-00100001b | 01100000b = 01100001b
-00100001b | 01100001b = 01100001b
-00100001b | 01100010b = 01100011b
-00100001b | 01100011b = 01100011b
-00100001b | 01100100b = 01100101b
-00100001b | 01100101b = 01100101b
-00100001b | 01100110b = 01100111b
-00100001b | 01100111b = 01100111b
-00100001b | 01101000b = 01101001b
-00100001b | 01101001b = 01101001b
-00100001b | 01101010b = 01101011b
-00100001b | 01101011b = 01101011b
-00100001b | 01101100b = 01101101b
-00100001b | 01101101b = 01101101b
-00100001b | 01101110b = 01101111b
-00100001b | 01101111b = 01101111b
-00100001b | 01110000b = 01110001b
-00100001b | 01110001b = 01110001b
-00100001b | 01110010b = 01110011b
-00100001b | 01110011b = 01110011b
-00100001b | 01110100b = 01110101b
-00100001b | 01110101b = 01110101b
-00100001b | 01110110b = 01110111b
-00100001b | 01110111b = 01110111b
-00100001b | 01111000b = 01111001b
-00100001b | 01111001b = 01111001b
-00100001b | 01111010b = 01111011b
-00100001b | 01111011b = 01111011b
-00100001b | 01111100b = 01111101b
-00100001b | 01111101b = 01111101b
-00100001b | 01111110b = 01111111b
-00100010b | 10000000b = 10100010b
-00100010b | 10000001b = 10100011b
-00100010b | 10000010b = 10100010b
-00100010b | 10000011b = 10100011b
-00100010b | 10000100b = 10100110b
-00100010b | 10000101b = 10100111b
-00100010b | 10000110b = 10100110b
-00100010b | 10000111b = 10100111b
-00100010b | 10001000b = 10101010b
-00100010b | 10001001b = 10101011b
-00100010b | 10001010b = 10101010b
-00100010b | 10001011b = 10101011b
-00100010b | 10001100b = 10101110b
-00100010b | 10001101b = 10101111b
-00100010b | 10001110b = 10101110b
-00100010b | 10001111b = 10101111b
-00100010b | 10010000b = 10110010b
-00100010b | 10010001b = 10110011b
-00100010b | 10010010b = 10110010b
-00100010b | 10010011b = 10110011b
-00100010b | 10010100b = 10110110b
-00100010b | 10010101b = 10110111b
-00100010b | 10010110b = 10110110b
-00100010b | 10010111b = 10110111b
-00100010b | 10011000b = 10111010b
-00100010b | 10011001b = 10111011b
-00100010b | 10011010b = 10111010b
-00100010b | 10011011b = 10111011b
-00100010b | 10011100b = 10111110b
-00100010b | 10011101b = 10111111b
-00100010b | 10011110b = 10111110b
-00100010b | 10011111b = 10111111b
-00100010b | 10100000b = 10100010b
-00100010b | 10100001b = 10100011b
-00100010b | 10100010b = 10100010b
-00100010b | 10100011b = 10100011b
-00100010b | 10100100b = 10100110b
-00100010b | 10100101b = 10100111b
-00100010b | 10100110b = 10100110b
-00100010b | 10100111b = 10100111b
-00100010b | 10101000b = 10101010b
-00100010b | 10101001b = 10101011b
-00100010b | 10101010b = 10101010b
-00100010b | 10101011b = 10101011b
-00100010b | 10101100b = 10101110b
-00100010b | 10101101b = 10101111b
-00100010b | 10101110b = 10101110b
-00100010b | 10101111b = 10101111b
-00100010b | 10110000b = 10110010b
-00100010b | 10110001b = 10110011b
-00100010b | 10110010b = 10110010b
-00100010b | 10110011b = 10110011b
-00100010b | 10110100b = 10110110b
-00100010b | 10110101b = 10110111b
-00100010b | 10110110b = 10110110b
-00100010b | 10110111b = 10110111b
-00100010b | 10111000b = 10111010b
-00100010b | 10111001b = 10111011b
-00100010b | 10111010b = 10111010b
-00100010b | 10111011b = 10111011b
-00100010b | 10111100b = 10111110b
-00100010b | 10111101b = 10111111b
-00100010b | 10111110b = 10111110b
-00100010b | 10111111b = 10111111b
-00100010b | 11000000b = 11100010b
-00100010b | 11000001b = 11100011b
-00100010b | 11000010b = 11100010b
-00100010b | 11000011b = 11100011b
-00100010b | 11000100b = 11100110b
-00100010b | 11000101b = 11100111b
-00100010b | 11000110b = 11100110b
-00100010b | 11000111b = 11100111b
-00100010b | 11001000b = 11101010b
-00100010b | 11001001b = 11101011b
-00100010b | 11001010b = 11101010b
-00100010b | 11001011b = 11101011b
-00100010b | 11001100b = 11101110b
-00100010b | 11001101b = 11101111b
-00100010b | 11001110b = 11101110b
-00100010b | 11001111b = 11101111b
-00100010b | 11010000b = 11110010b
-00100010b | 11010001b = 11110011b
-00100010b | 11010010b = 11110010b
-00100010b | 11010011b = 11110011b
-00100010b | 11010100b = 11110110b
-00100010b | 11010101b = 11110111b
-00100010b | 11010110b = 11110110b
-00100010b | 11010111b = 11110111b
-00100010b | 11011000b = 11111010b
-00100010b | 11011001b = 11111011b
-00100010b | 11011010b = 11111010b
-00100010b | 11011011b = 11111011b
-00100010b | 11011100b = 11111110b
-00100010b | 11011101b = 11111111b
-00100010b | 11011110b = 11111110b
-00100010b | 11011111b = 11111111b
-00100010b | 11100000b = 11100010b
-00100010b | 11100001b = 11100011b
-00100010b | 11100010b = 11100010b
-00100010b | 11100011b = 11100011b
-00100010b | 11100100b = 11100110b
-00100010b | 11100101b = 11100111b
-00100010b | 11100110b = 11100110b
-00100010b | 11100111b = 11100111b
-00100010b | 11101000b = 11101010b
-00100010b | 11101001b = 11101011b
-00100010b | 11101010b = 11101010b
-00100010b | 11101011b = 11101011b
-00100010b | 11101100b = 11101110b
-00100010b | 11101101b = 11101111b
-00100010b | 11101110b = 11101110b
-00100010b | 11101111b = 11101111b
-00100010b | 11110000b = 11110010b
-00100010b | 11110001b = 11110011b
-00100010b | 11110010b = 11110010b
-00100010b | 11110011b = 11110011b
-00100010b | 11110100b = 11110110b
-00100010b | 11110101b = 11110111b
-00100010b | 11110110b = 11110110b
-00100010b | 11110111b = 11110111b
-00100010b | 11111000b = 11111010b
-00100010b | 11111001b = 11111011b
-00100010b | 11111010b = 11111010b
-00100010b | 11111011b = 11111011b
-00100010b | 11111100b = 11111110b
-00100010b | 11111101b = 11111111b
-00100010b | 11111110b = 11111110b
-00100010b | 11111111b = 11111111b
-00100010b | 00000000b = 00100010b
-00100010b | 00000001b = 00100011b
-00100010b | 00000010b = 00100010b
-00100010b | 00000011b = 00100011b
-00100010b | 00000100b = 00100110b
-00100010b | 00000101b = 00100111b
-00100010b | 00000110b = 00100110b
-00100010b | 00000111b = 00100111b
-00100010b | 00001000b = 00101010b
-00100010b | 00001001b = 00101011b
-00100010b | 00001010b = 00101010b
-00100010b | 00001011b = 00101011b
-00100010b | 00001100b = 00101110b
-00100010b | 00001101b = 00101111b
-00100010b | 00001110b = 00101110b
-00100010b | 00001111b = 00101111b
-00100010b | 00010000b = 00110010b
-00100010b | 00010001b = 00110011b
-00100010b | 00010010b = 00110010b
-00100010b | 00010011b = 00110011b
-00100010b | 00010100b = 00110110b
-00100010b | 00010101b = 00110111b
-00100010b | 00010110b = 00110110b
-00100010b | 00010111b = 00110111b
-00100010b | 00011000b = 00111010b
-00100010b | 00011001b = 00111011b
-00100010b | 00011010b = 00111010b
-00100010b | 00011011b = 00111011b
-00100010b | 00011100b = 00111110b
-00100010b | 00011101b = 00111111b
-00100010b | 00011110b = 00111110b
-00100010b | 00011111b = 00111111b
-00100010b | 00100000b = 00100010b
-00100010b | 00100001b = 00100011b
-00100010b | 00100010b = 00100010b
-00100010b | 00100011b = 00100011b
-00100010b | 00100100b = 00100110b
-00100010b | 00100101b = 00100111b
-00100010b | 00100110b = 00100110b
-00100010b | 00100111b = 00100111b
-00100010b | 00101000b = 00101010b
-00100010b | 00101001b = 00101011b
-00100010b | 00101010b = 00101010b
-00100010b | 00101011b = 00101011b
-00100010b | 00101100b = 00101110b
-00100010b | 00101101b = 00101111b
-00100010b | 00101110b = 00101110b
-00100010b | 00101111b = 00101111b
-00100010b | 00110000b = 00110010b
-00100010b | 00110001b = 00110011b
-00100010b | 00110010b = 00110010b
-00100010b | 00110011b = 00110011b
-00100010b | 00110100b = 00110110b
-00100010b | 00110101b = 00110111b
-00100010b | 00110110b = 00110110b
-00100010b | 00110111b = 00110111b
-00100010b | 00111000b = 00111010b
-00100010b | 00111001b = 00111011b
-00100010b | 00111010b = 00111010b
-00100010b | 00111011b = 00111011b
-00100010b | 00111100b = 00111110b
-00100010b | 00111101b = 00111111b
-00100010b | 00111110b = 00111110b
-00100010b | 00111111b = 00111111b
-00100010b | 01000000b = 01100010b
-00100010b | 01000001b = 01100011b
-00100010b | 01000010b = 01100010b
-00100010b | 01000011b = 01100011b
-00100010b | 01000100b = 01100110b
-00100010b | 01000101b = 01100111b
-00100010b | 01000110b = 01100110b
-00100010b | 01000111b = 01100111b
-00100010b | 01001000b = 01101010b
-00100010b | 01001001b = 01101011b
-00100010b | 01001010b = 01101010b
-00100010b | 01001011b = 01101011b
-00100010b | 01001100b = 01101110b
-00100010b | 01001101b = 01101111b
-00100010b | 01001110b = 01101110b
-00100010b | 01001111b = 01101111b
-00100010b | 01010000b = 01110010b
-00100010b | 01010001b = 01110011b
-00100010b | 01010010b = 01110010b
-00100010b | 01010011b = 01110011b
-00100010b | 01010100b = 01110110b
-00100010b | 01010101b = 01110111b
-00100010b | 01010110b = 01110110b
-00100010b | 01010111b = 01110111b
-00100010b | 01011000b = 01111010b
-00100010b | 01011001b = 01111011b
-00100010b | 01011010b = 01111010b
-00100010b | 01011011b = 01111011b
-00100010b | 01011100b = 01111110b
-00100010b | 01011101b = 01111111b
-00100010b | 01011110b = 01111110b
-00100010b | 01011111b = 01111111b
-00100010b | 01100000b = 01100010b
-00100010b | 01100001b = 01100011b
-00100010b | 01100010b = 01100010b
-00100010b | 01100011b = 01100011b
-00100010b | 01100100b = 01100110b
-00100010b | 01100101b = 01100111b
-00100010b | 01100110b = 01100110b
-00100010b | 01100111b = 01100111b
-00100010b | 01101000b = 01101010b
-00100010b | 01101001b = 01101011b
-00100010b | 01101010b = 01101010b
-00100010b | 01101011b = 01101011b
-00100010b | 01101100b = 01101110b
-00100010b | 01101101b = 01101111b
-00100010b | 01101110b = 01101110b
-00100010b | 01101111b = 01101111b
-00100010b | 01110000b = 01110010b
-00100010b | 01110001b = 01110011b
-00100010b | 01110010b = 01110010b
-00100010b | 01110011b = 01110011b
-00100010b | 01110100b = 01110110b
-00100010b | 01110101b = 01110111b
-00100010b | 01110110b = 01110110b
-00100010b | 01110111b = 01110111b
-00100010b | 01111000b = 01111010b
-00100010b | 01111001b = 01111011b
-00100010b | 01111010b = 01111010b
-00100010b | 01111011b = 01111011b
-00100010b | 01111100b = 01111110b
-00100010b | 01111101b = 01111111b
-00100010b | 01111110b = 01111110b
-00100011b | 10000000b = 10100011b
-00100011b | 10000001b = 10100011b
-00100011b | 10000010b = 10100011b
-00100011b | 10000011b = 10100011b
-00100011b | 10000100b = 10100111b
-00100011b | 10000101b = 10100111b
-00100011b | 10000110b = 10100111b
-00100011b | 10000111b = 10100111b
-00100011b | 10001000b = 10101011b
-00100011b | 10001001b = 10101011b
-00100011b | 10001010b = 10101011b
-00100011b | 10001011b = 10101011b
-00100011b | 10001100b = 10101111b
-00100011b | 10001101b = 10101111b
-00100011b | 10001110b = 10101111b
-00100011b | 10001111b = 10101111b
-00100011b | 10010000b = 10110011b
-00100011b | 10010001b = 10110011b
-00100011b | 10010010b = 10110011b
-00100011b | 10010011b = 10110011b
-00100011b | 10010100b = 10110111b
-00100011b | 10010101b = 10110111b
-00100011b | 10010110b = 10110111b
-00100011b | 10010111b = 10110111b
-00100011b | 10011000b = 10111011b
-00100011b | 10011001b = 10111011b
-00100011b | 10011010b = 10111011b
-00100011b | 10011011b = 10111011b
-00100011b | 10011100b = 10111111b
-00100011b | 10011101b = 10111111b
-00100011b | 10011110b = 10111111b
-00100011b | 10011111b = 10111111b
-00100011b | 10100000b = 10100011b
-00100011b | 10100001b = 10100011b
-00100011b | 10100010b = 10100011b
-00100011b | 10100011b = 10100011b
-00100011b | 10100100b = 10100111b
-00100011b | 10100101b = 10100111b
-00100011b | 10100110b = 10100111b
-00100011b | 10100111b = 10100111b
-00100011b | 10101000b = 10101011b
-00100011b | 10101001b = 10101011b
-00100011b | 10101010b = 10101011b
-00100011b | 10101011b = 10101011b
-00100011b | 10101100b = 10101111b
-00100011b | 10101101b = 10101111b
-00100011b | 10101110b = 10101111b
-00100011b | 10101111b = 10101111b
-00100011b | 10110000b = 10110011b
-00100011b | 10110001b = 10110011b
-00100011b | 10110010b = 10110011b
-00100011b | 10110011b = 10110011b
-00100011b | 10110100b = 10110111b
-00100011b | 10110101b = 10110111b
-00100011b | 10110110b = 10110111b
-00100011b | 10110111b = 10110111b
-00100011b | 10111000b = 10111011b
-00100011b | 10111001b = 10111011b
-00100011b | 10111010b = 10111011b
-00100011b | 10111011b = 10111011b
-00100011b | 10111100b = 10111111b
-00100011b | 10111101b = 10111111b
-00100011b | 10111110b = 10111111b
-00100011b | 10111111b = 10111111b
-00100011b | 11000000b = 11100011b
-00100011b | 11000001b = 11100011b
-00100011b | 11000010b = 11100011b
-00100011b | 11000011b = 11100011b
-00100011b | 11000100b = 11100111b
-00100011b | 11000101b = 11100111b
-00100011b | 11000110b = 11100111b
-00100011b | 11000111b = 11100111b
-00100011b | 11001000b = 11101011b
-00100011b | 11001001b = 11101011b
-00100011b | 11001010b = 11101011b
-00100011b | 11001011b = 11101011b
-00100011b | 11001100b = 11101111b
-00100011b | 11001101b = 11101111b
-00100011b | 11001110b = 11101111b
-00100011b | 11001111b = 11101111b
-00100011b | 11010000b = 11110011b
-00100011b | 11010001b = 11110011b
-00100011b | 11010010b = 11110011b
-00100011b | 11010011b = 11110011b
-00100011b | 11010100b = 11110111b
-00100011b | 11010101b = 11110111b
-00100011b | 11010110b = 11110111b
-00100011b | 11010111b = 11110111b
-00100011b | 11011000b = 11111011b
-00100011b | 11011001b = 11111011b
-00100011b | 11011010b = 11111011b
-00100011b | 11011011b = 11111011b
-00100011b | 11011100b = 11111111b
-00100011b | 11011101b = 11111111b
-00100011b | 11011110b = 11111111b
-00100011b | 11011111b = 11111111b
-00100011b | 11100000b = 11100011b
-00100011b | 11100001b = 11100011b
-00100011b | 11100010b = 11100011b
-00100011b | 11100011b = 11100011b
-00100011b | 11100100b = 11100111b
-00100011b | 11100101b = 11100111b
-00100011b | 11100110b = 11100111b
-00100011b | 11100111b = 11100111b
-00100011b | 11101000b = 11101011b
-00100011b | 11101001b = 11101011b
-00100011b | 11101010b = 11101011b
-00100011b | 11101011b = 11101011b
-00100011b | 11101100b = 11101111b
-00100011b | 11101101b = 11101111b
-00100011b | 11101110b = 11101111b
-00100011b | 11101111b = 11101111b
-00100011b | 11110000b = 11110011b
-00100011b | 11110001b = 11110011b
-00100011b | 11110010b = 11110011b
-00100011b | 11110011b = 11110011b
-00100011b | 11110100b = 11110111b
-00100011b | 11110101b = 11110111b
-00100011b | 11110110b = 11110111b
-00100011b | 11110111b = 11110111b
-00100011b | 11111000b = 11111011b
-00100011b | 11111001b = 11111011b
-00100011b | 11111010b = 11111011b
-00100011b | 11111011b = 11111011b
-00100011b | 11111100b = 11111111b
-00100011b | 11111101b = 11111111b
-00100011b | 11111110b = 11111111b
-00100011b | 11111111b = 11111111b
-00100011b | 00000000b = 00100011b
-00100011b | 00000001b = 00100011b
-00100011b | 00000010b = 00100011b
-00100011b | 00000011b = 00100011b
-00100011b | 00000100b = 00100111b
-00100011b | 00000101b = 00100111b
-00100011b | 00000110b = 00100111b
-00100011b | 00000111b = 00100111b
-00100011b | 00001000b = 00101011b
-00100011b | 00001001b = 00101011b
-00100011b | 00001010b = 00101011b
-00100011b | 00001011b = 00101011b
-00100011b | 00001100b = 00101111b
-00100011b | 00001101b = 00101111b
-00100011b | 00001110b = 00101111b
-00100011b | 00001111b = 00101111b
-00100011b | 00010000b = 00110011b
-00100011b | 00010001b = 00110011b
-00100011b | 00010010b = 00110011b
-00100011b | 00010011b = 00110011b
-00100011b | 00010100b = 00110111b
-00100011b | 00010101b = 00110111b
-00100011b | 00010110b = 00110111b
-00100011b | 00010111b = 00110111b
-00100011b | 00011000b = 00111011b
-00100011b | 00011001b = 00111011b
-00100011b | 00011010b = 00111011b
-00100011b | 00011011b = 00111011b
-00100011b | 00011100b = 00111111b
-00100011b | 00011101b = 00111111b
-00100011b | 00011110b = 00111111b
-00100011b | 00011111b = 00111111b
-00100011b | 00100000b = 00100011b
-00100011b | 00100001b = 00100011b
-00100011b | 00100010b = 00100011b
-00100011b | 00100011b = 00100011b
-00100011b | 00100100b = 00100111b
-00100011b | 00100101b = 00100111b
-00100011b | 00100110b = 00100111b
-00100011b | 00100111b = 00100111b
-00100011b | 00101000b = 00101011b
-00100011b | 00101001b = 00101011b
-00100011b | 00101010b = 00101011b
-00100011b | 00101011b = 00101011b
-00100011b | 00101100b = 00101111b
-00100011b | 00101101b = 00101111b
-00100011b | 00101110b = 00101111b
-00100011b | 00101111b = 00101111b
-00100011b | 00110000b = 00110011b
-00100011b | 00110001b = 00110011b
-00100011b | 00110010b = 00110011b
-00100011b | 00110011b = 00110011b
-00100011b | 00110100b = 00110111b
-00100011b | 00110101b = 00110111b
-00100011b | 00110110b = 00110111b
-00100011b | 00110111b = 00110111b
-00100011b | 00111000b = 00111011b
-00100011b | 00111001b = 00111011b
-00100011b | 00111010b = 00111011b
-00100011b | 00111011b = 00111011b
-00100011b | 00111100b = 00111111b
-00100011b | 00111101b = 00111111b
-00100011b | 00111110b = 00111111b
-00100011b | 00111111b = 00111111b
-00100011b | 01000000b = 01100011b
-00100011b | 01000001b = 01100011b
-00100011b | 01000010b = 01100011b
-00100011b | 01000011b = 01100011b
-00100011b | 01000100b = 01100111b
-00100011b | 01000101b = 01100111b
-00100011b | 01000110b = 01100111b
-00100011b | 01000111b = 01100111b
-00100011b | 01001000b = 01101011b
-00100011b | 01001001b = 01101011b
-00100011b | 01001010b = 01101011b
-00100011b | 01001011b = 01101011b
-00100011b | 01001100b = 01101111b
-00100011b | 01001101b = 01101111b
-00100011b | 01001110b = 01101111b
-00100011b | 01001111b = 01101111b
-00100011b | 01010000b = 01110011b
-00100011b | 01010001b = 01110011b
-00100011b | 01010010b = 01110011b
-00100011b | 01010011b = 01110011b
-00100011b | 01010100b = 01110111b
-00100011b | 01010101b = 01110111b
-00100011b | 01010110b = 01110111b
-00100011b | 01010111b = 01110111b
-00100011b | 01011000b = 01111011b
-00100011b | 01011001b = 01111011b
-00100011b | 01011010b = 01111011b
-00100011b | 01011011b = 01111011b
-00100011b | 01011100b = 01111111b
-00100011b | 01011101b = 01111111b
-00100011b | 01011110b = 01111111b
-00100011b | 01011111b = 01111111b
-00100011b | 01100000b = 01100011b
-00100011b | 01100001b = 01100011b
-00100011b | 01100010b = 01100011b
-00100011b | 01100011b = 01100011b
-00100011b | 01100100b = 01100111b
-00100011b | 01100101b = 01100111b
-00100011b | 01100110b = 01100111b
-00100011b | 01100111b = 01100111b
-00100011b | 01101000b = 01101011b
-00100011b | 01101001b = 01101011b
-00100011b | 01101010b = 01101011b
-00100011b | 01101011b = 01101011b
-00100011b | 01101100b = 01101111b
-00100011b | 01101101b = 01101111b
-00100011b | 01101110b = 01101111b
-00100011b | 01101111b = 01101111b
-00100011b | 01110000b = 01110011b
-00100011b | 01110001b = 01110011b
-00100011b | 01110010b = 01110011b
-00100011b | 01110011b = 01110011b
-00100011b | 01110100b = 01110111b
-00100011b | 01110101b = 01110111b
-00100011b | 01110110b = 01110111b
-00100011b | 01110111b = 01110111b
-00100011b | 01111000b = 01111011b
-00100011b | 01111001b = 01111011b
-00100011b | 01111010b = 01111011b
-00100011b | 01111011b = 01111011b
-00100011b | 01111100b = 01111111b
-00100011b | 01111101b = 01111111b
-00100011b | 01111110b = 01111111b
-00100100b | 10000000b = 10100100b
-00100100b | 10000001b = 10100101b
-00100100b | 10000010b = 10100110b
-00100100b | 10000011b = 10100111b
-00100100b | 10000100b = 10100100b
-00100100b | 10000101b = 10100101b
-00100100b | 10000110b = 10100110b
-00100100b | 10000111b = 10100111b
-00100100b | 10001000b = 10101100b
-00100100b | 10001001b = 10101101b
-00100100b | 10001010b = 10101110b
-00100100b | 10001011b = 10101111b
-00100100b | 10001100b = 10101100b
-00100100b | 10001101b = 10101101b
-00100100b | 10001110b = 10101110b
-00100100b | 10001111b = 10101111b
-00100100b | 10010000b = 10110100b
-00100100b | 10010001b = 10110101b
-00100100b | 10010010b = 10110110b
-00100100b | 10010011b = 10110111b
-00100100b | 10010100b = 10110100b
-00100100b | 10010101b = 10110101b
-00100100b | 10010110b = 10110110b
-00100100b | 10010111b = 10110111b
-00100100b | 10011000b = 10111100b
-00100100b | 10011001b = 10111101b
-00100100b | 10011010b = 10111110b
-00100100b | 10011011b = 10111111b
-00100100b | 10011100b = 10111100b
-00100100b | 10011101b = 10111101b
-00100100b | 10011110b = 10111110b
-00100100b | 10011111b = 10111111b
-00100100b | 10100000b = 10100100b
-00100100b | 10100001b = 10100101b
-00100100b | 10100010b = 10100110b
-00100100b | 10100011b = 10100111b
-00100100b | 10100100b = 10100100b
-00100100b | 10100101b = 10100101b
-00100100b | 10100110b = 10100110b
-00100100b | 10100111b = 10100111b
-00100100b | 10101000b = 10101100b
-00100100b | 10101001b = 10101101b
-00100100b | 10101010b = 10101110b
-00100100b | 10101011b = 10101111b
-00100100b | 10101100b = 10101100b
-00100100b | 10101101b = 10101101b
-00100100b | 10101110b = 10101110b
-00100100b | 10101111b = 10101111b
-00100100b | 10110000b = 10110100b
-00100100b | 10110001b = 10110101b
-00100100b | 10110010b = 10110110b
-00100100b | 10110011b = 10110111b
-00100100b | 10110100b = 10110100b
-00100100b | 10110101b = 10110101b
-00100100b | 10110110b = 10110110b
-00100100b | 10110111b = 10110111b
-00100100b | 10111000b = 10111100b
-00100100b | 10111001b = 10111101b
-00100100b | 10111010b = 10111110b
-00100100b | 10111011b = 10111111b
-00100100b | 10111100b = 10111100b
-00100100b | 10111101b = 10111101b
-00100100b | 10111110b = 10111110b
-00100100b | 10111111b = 10111111b
-00100100b | 11000000b = 11100100b
-00100100b | 11000001b = 11100101b
-00100100b | 11000010b = 11100110b
-00100100b | 11000011b = 11100111b
-00100100b | 11000100b = 11100100b
-00100100b | 11000101b = 11100101b
-00100100b | 11000110b = 11100110b
-00100100b | 11000111b = 11100111b
-00100100b | 11001000b = 11101100b
-00100100b | 11001001b = 11101101b
-00100100b | 11001010b = 11101110b
-00100100b | 11001011b = 11101111b
-00100100b | 11001100b = 11101100b
-00100100b | 11001101b = 11101101b
-00100100b | 11001110b = 11101110b
-00100100b | 11001111b = 11101111b
-00100100b | 11010000b = 11110100b
-00100100b | 11010001b = 11110101b
-00100100b | 11010010b = 11110110b
-00100100b | 11010011b = 11110111b
-00100100b | 11010100b = 11110100b
-00100100b | 11010101b = 11110101b
-00100100b | 11010110b = 11110110b
-00100100b | 11010111b = 11110111b
-00100100b | 11011000b = 11111100b
-00100100b | 11011001b = 11111101b
-00100100b | 11011010b = 11111110b
-00100100b | 11011011b = 11111111b
-00100100b | 11011100b = 11111100b
-00100100b | 11011101b = 11111101b
-00100100b | 11011110b = 11111110b
-00100100b | 11011111b = 11111111b
-00100100b | 11100000b = 11100100b
-00100100b | 11100001b = 11100101b
-00100100b | 11100010b = 11100110b
-00100100b | 11100011b = 11100111b
-00100100b | 11100100b = 11100100b
-00100100b | 11100101b = 11100101b
-00100100b | 11100110b = 11100110b
-00100100b | 11100111b = 11100111b
-00100100b | 11101000b = 11101100b
-00100100b | 11101001b = 11101101b
-00100100b | 11101010b = 11101110b
-00100100b | 11101011b = 11101111b
-00100100b | 11101100b = 11101100b
-00100100b | 11101101b = 11101101b
-00100100b | 11101110b = 11101110b
-00100100b | 11101111b = 11101111b
-00100100b | 11110000b = 11110100b
-00100100b | 11110001b = 11110101b
-00100100b | 11110010b = 11110110b
-00100100b | 11110011b = 11110111b
-00100100b | 11110100b = 11110100b
-00100100b | 11110101b = 11110101b
-00100100b | 11110110b = 11110110b
-00100100b | 11110111b = 11110111b
-00100100b | 11111000b = 11111100b
-00100100b | 11111001b = 11111101b
-00100100b | 11111010b = 11111110b
-00100100b | 11111011b = 11111111b
-00100100b | 11111100b = 11111100b
-00100100b | 11111101b = 11111101b
-00100100b | 11111110b = 11111110b
-00100100b | 11111111b = 11111111b
-00100100b | 00000000b = 00100100b
-00100100b | 00000001b = 00100101b
-00100100b | 00000010b = 00100110b
-00100100b | 00000011b = 00100111b
-00100100b | 00000100b = 00100100b
-00100100b | 00000101b = 00100101b
-00100100b | 00000110b = 00100110b
-00100100b | 00000111b = 00100111b
-00100100b | 00001000b = 00101100b
-00100100b | 00001001b = 00101101b
-00100100b | 00001010b = 00101110b
-00100100b | 00001011b = 00101111b
-00100100b | 00001100b = 00101100b
-00100100b | 00001101b = 00101101b
-00100100b | 00001110b = 00101110b
-00100100b | 00001111b = 00101111b
-00100100b | 00010000b = 00110100b
-00100100b | 00010001b = 00110101b
-00100100b | 00010010b = 00110110b
-00100100b | 00010011b = 00110111b
-00100100b | 00010100b = 00110100b
-00100100b | 00010101b = 00110101b
-00100100b | 00010110b = 00110110b
-00100100b | 00010111b = 00110111b
-00100100b | 00011000b = 00111100b
-00100100b | 00011001b = 00111101b
-00100100b | 00011010b = 00111110b
-00100100b | 00011011b = 00111111b
-00100100b | 00011100b = 00111100b
-00100100b | 00011101b = 00111101b
-00100100b | 00011110b = 00111110b
-00100100b | 00011111b = 00111111b
-00100100b | 00100000b = 00100100b
-00100100b | 00100001b = 00100101b
-00100100b | 00100010b = 00100110b
-00100100b | 00100011b = 00100111b
-00100100b | 00100100b = 00100100b
-00100100b | 00100101b = 00100101b
-00100100b | 00100110b = 00100110b
-00100100b | 00100111b = 00100111b
-00100100b | 00101000b = 00101100b
-00100100b | 00101001b = 00101101b
-00100100b | 00101010b = 00101110b
-00100100b | 00101011b = 00101111b
-00100100b | 00101100b = 00101100b
-00100100b | 00101101b = 00101101b
-00100100b | 00101110b = 00101110b
-00100100b | 00101111b = 00101111b
-00100100b | 00110000b = 00110100b
-00100100b | 00110001b = 00110101b
-00100100b | 00110010b = 00110110b
-00100100b | 00110011b = 00110111b
-00100100b | 00110100b = 00110100b
-00100100b | 00110101b = 00110101b
-00100100b | 00110110b = 00110110b
-00100100b | 00110111b = 00110111b
-00100100b | 00111000b = 00111100b
-00100100b | 00111001b = 00111101b
-00100100b | 00111010b = 00111110b
-00100100b | 00111011b = 00111111b
-00100100b | 00111100b = 00111100b
-00100100b | 00111101b = 00111101b
-00100100b | 00111110b = 00111110b
-00100100b | 00111111b = 00111111b
-00100100b | 01000000b = 01100100b
-00100100b | 01000001b = 01100101b
-00100100b | 01000010b = 01100110b
-00100100b | 01000011b = 01100111b
-00100100b | 01000100b = 01100100b
-00100100b | 01000101b = 01100101b
-00100100b | 01000110b = 01100110b
-00100100b | 01000111b = 01100111b
-00100100b | 01001000b = 01101100b
-00100100b | 01001001b = 01101101b
-00100100b | 01001010b = 01101110b
-00100100b | 01001011b = 01101111b
-00100100b | 01001100b = 01101100b
-00100100b | 01001101b = 01101101b
-00100100b | 01001110b = 01101110b
-00100100b | 01001111b = 01101111b
-00100100b | 01010000b = 01110100b
-00100100b | 01010001b = 01110101b
-00100100b | 01010010b = 01110110b
-00100100b | 01010011b = 01110111b
-00100100b | 01010100b = 01110100b
-00100100b | 01010101b = 01110101b
-00100100b | 01010110b = 01110110b
-00100100b | 01010111b = 01110111b
-00100100b | 01011000b = 01111100b
-00100100b | 01011001b = 01111101b
-00100100b | 01011010b = 01111110b
-00100100b | 01011011b = 01111111b
-00100100b | 01011100b = 01111100b
-00100100b | 01011101b = 01111101b
-00100100b | 01011110b = 01111110b
-00100100b | 01011111b = 01111111b
-00100100b | 01100000b = 01100100b
-00100100b | 01100001b = 01100101b
-00100100b | 01100010b = 01100110b
-00100100b | 01100011b = 01100111b
-00100100b | 01100100b = 01100100b
-00100100b | 01100101b = 01100101b
-00100100b | 01100110b = 01100110b
-00100100b | 01100111b = 01100111b
-00100100b | 01101000b = 01101100b
-00100100b | 01101001b = 01101101b
-00100100b | 01101010b = 01101110b
-00100100b | 01101011b = 01101111b
-00100100b | 01101100b = 01101100b
-00100100b | 01101101b = 01101101b
-00100100b | 01101110b = 01101110b
-00100100b | 01101111b = 01101111b
-00100100b | 01110000b = 01110100b
-00100100b | 01110001b = 01110101b
-00100100b | 01110010b = 01110110b
-00100100b | 01110011b = 01110111b
-00100100b | 01110100b = 01110100b
-00100100b | 01110101b = 01110101b
-00100100b | 01110110b = 01110110b
-00100100b | 01110111b = 01110111b
-00100100b | 01111000b = 01111100b
-00100100b | 01111001b = 01111101b
-00100100b | 01111010b = 01111110b
-00100100b | 01111011b = 01111111b
-00100100b | 01111100b = 01111100b
-00100100b | 01111101b = 01111101b
-00100100b | 01111110b = 01111110b
-00100101b | 10000000b = 10100101b
-00100101b | 10000001b = 10100101b
-00100101b | 10000010b = 10100111b
-00100101b | 10000011b = 10100111b
-00100101b | 10000100b = 10100101b
-00100101b | 10000101b = 10100101b
-00100101b | 10000110b = 10100111b
-00100101b | 10000111b = 10100111b
-00100101b | 10001000b = 10101101b
-00100101b | 10001001b = 10101101b
-00100101b | 10001010b = 10101111b
-00100101b | 10001011b = 10101111b
-00100101b | 10001100b = 10101101b
-00100101b | 10001101b = 10101101b
-00100101b | 10001110b = 10101111b
-00100101b | 10001111b = 10101111b
-00100101b | 10010000b = 10110101b
-00100101b | 10010001b = 10110101b
-00100101b | 10010010b = 10110111b
-00100101b | 10010011b = 10110111b
-00100101b | 10010100b = 10110101b
-00100101b | 10010101b = 10110101b
-00100101b | 10010110b = 10110111b
-00100101b | 10010111b = 10110111b
-00100101b | 10011000b = 10111101b
-00100101b | 10011001b = 10111101b
-00100101b | 10011010b = 10111111b
-00100101b | 10011011b = 10111111b
-00100101b | 10011100b = 10111101b
-00100101b | 10011101b = 10111101b
-00100101b | 10011110b = 10111111b
-00100101b | 10011111b = 10111111b
-00100101b | 10100000b = 10100101b
-00100101b | 10100001b = 10100101b
-00100101b | 10100010b = 10100111b
-00100101b | 10100011b = 10100111b
-00100101b | 10100100b = 10100101b
-00100101b | 10100101b = 10100101b
-00100101b | 10100110b = 10100111b
-00100101b | 10100111b = 10100111b
-00100101b | 10101000b = 10101101b
-00100101b | 10101001b = 10101101b
-00100101b | 10101010b = 10101111b
-00100101b | 10101011b = 10101111b
-00100101b | 10101100b = 10101101b
-00100101b | 10101101b = 10101101b
-00100101b | 10101110b = 10101111b
-00100101b | 10101111b = 10101111b
-00100101b | 10110000b = 10110101b
-00100101b | 10110001b = 10110101b
-00100101b | 10110010b = 10110111b
-00100101b | 10110011b = 10110111b
-00100101b | 10110100b = 10110101b
-00100101b | 10110101b = 10110101b
-00100101b | 10110110b = 10110111b
-00100101b | 10110111b = 10110111b
-00100101b | 10111000b = 10111101b
-00100101b | 10111001b = 10111101b
-00100101b | 10111010b = 10111111b
-00100101b | 10111011b = 10111111b
-00100101b | 10111100b = 10111101b
-00100101b | 10111101b = 10111101b
-00100101b | 10111110b = 10111111b
-00100101b | 10111111b = 10111111b
-00100101b | 11000000b = 11100101b
-00100101b | 11000001b = 11100101b
-00100101b | 11000010b = 11100111b
-00100101b | 11000011b = 11100111b
-00100101b | 11000100b = 11100101b
-00100101b | 11000101b = 11100101b
-00100101b | 11000110b = 11100111b
-00100101b | 11000111b = 11100111b
-00100101b | 11001000b = 11101101b
-00100101b | 11001001b = 11101101b
-00100101b | 11001010b = 11101111b
-00100101b | 11001011b = 11101111b
-00100101b | 11001100b = 11101101b
-00100101b | 11001101b = 11101101b
-00100101b | 11001110b = 11101111b
-00100101b | 11001111b = 11101111b
-00100101b | 11010000b = 11110101b
-00100101b | 11010001b = 11110101b
-00100101b | 11010010b = 11110111b
-00100101b | 11010011b = 11110111b
-00100101b | 11010100b = 11110101b
-00100101b | 11010101b = 11110101b
-00100101b | 11010110b = 11110111b
-00100101b | 11010111b = 11110111b
-00100101b | 11011000b = 11111101b
-00100101b | 11011001b = 11111101b
-00100101b | 11011010b = 11111111b
-00100101b | 11011011b = 11111111b
-00100101b | 11011100b = 11111101b
-00100101b | 11011101b = 11111101b
-00100101b | 11011110b = 11111111b
-00100101b | 11011111b = 11111111b
-00100101b | 11100000b = 11100101b
-00100101b | 11100001b = 11100101b
-00100101b | 11100010b = 11100111b
-00100101b | 11100011b = 11100111b
-00100101b | 11100100b = 11100101b
-00100101b | 11100101b = 11100101b
-00100101b | 11100110b = 11100111b
-00100101b | 11100111b = 11100111b
-00100101b | 11101000b = 11101101b
-00100101b | 11101001b = 11101101b
-00100101b | 11101010b = 11101111b
-00100101b | 11101011b = 11101111b
-00100101b | 11101100b = 11101101b
-00100101b | 11101101b = 11101101b
-00100101b | 11101110b = 11101111b
-00100101b | 11101111b = 11101111b
-00100101b | 11110000b = 11110101b
-00100101b | 11110001b = 11110101b
-00100101b | 11110010b = 11110111b
-00100101b | 11110011b = 11110111b
-00100101b | 11110100b = 11110101b
-00100101b | 11110101b = 11110101b
-00100101b | 11110110b = 11110111b
-00100101b | 11110111b = 11110111b
-00100101b | 11111000b = 11111101b
-00100101b | 11111001b = 11111101b
-00100101b | 11111010b = 11111111b
-00100101b | 11111011b = 11111111b
-00100101b | 11111100b = 11111101b
-00100101b | 11111101b = 11111101b
-00100101b | 11111110b = 11111111b
-00100101b | 11111111b = 11111111b
-00100101b | 00000000b = 00100101b
-00100101b | 00000001b = 00100101b
-00100101b | 00000010b = 00100111b
-00100101b | 00000011b = 00100111b
-00100101b | 00000100b = 00100101b
-00100101b | 00000101b = 00100101b
-00100101b | 00000110b = 00100111b
-00100101b | 00000111b = 00100111b
-00100101b | 00001000b = 00101101b
-00100101b | 00001001b = 00101101b
-00100101b | 00001010b = 00101111b
-00100101b | 00001011b = 00101111b
-00100101b | 00001100b = 00101101b
-00100101b | 00001101b = 00101101b
-00100101b | 00001110b = 00101111b
-00100101b | 00001111b = 00101111b
-00100101b | 00010000b = 00110101b
-00100101b | 00010001b = 00110101b
-00100101b | 00010010b = 00110111b
-00100101b | 00010011b = 00110111b
-00100101b | 00010100b = 00110101b
-00100101b | 00010101b = 00110101b
-00100101b | 00010110b = 00110111b
-00100101b | 00010111b = 00110111b
-00100101b | 00011000b = 00111101b
-00100101b | 00011001b = 00111101b
-00100101b | 00011010b = 00111111b
-00100101b | 00011011b = 00111111b
-00100101b | 00011100b = 00111101b
-00100101b | 00011101b = 00111101b
-00100101b | 00011110b = 00111111b
-00100101b | 00011111b = 00111111b
-00100101b | 00100000b = 00100101b
-00100101b | 00100001b = 00100101b
-00100101b | 00100010b = 00100111b
-00100101b | 00100011b = 00100111b
-00100101b | 00100100b = 00100101b
-00100101b | 00100101b = 00100101b
-00100101b | 00100110b = 00100111b
-00100101b | 00100111b = 00100111b
-00100101b | 00101000b = 00101101b
-00100101b | 00101001b = 00101101b
-00100101b | 00101010b = 00101111b
-00100101b | 00101011b = 00101111b
-00100101b | 00101100b = 00101101b
-00100101b | 00101101b = 00101101b
-00100101b | 00101110b = 00101111b
-00100101b | 00101111b = 00101111b
-00100101b | 00110000b = 00110101b
-00100101b | 00110001b = 00110101b
-00100101b | 00110010b = 00110111b
-00100101b | 00110011b = 00110111b
-00100101b | 00110100b = 00110101b
-00100101b | 00110101b = 00110101b
-00100101b | 00110110b = 00110111b
-00100101b | 00110111b = 00110111b
-00100101b | 00111000b = 00111101b
-00100101b | 00111001b = 00111101b
-00100101b | 00111010b = 00111111b
-00100101b | 00111011b = 00111111b
-00100101b | 00111100b = 00111101b
-00100101b | 00111101b = 00111101b
-00100101b | 00111110b = 00111111b
-00100101b | 00111111b = 00111111b
-00100101b | 01000000b = 01100101b
-00100101b | 01000001b = 01100101b
-00100101b | 01000010b = 01100111b
-00100101b | 01000011b = 01100111b
-00100101b | 01000100b = 01100101b
-00100101b | 01000101b = 01100101b
-00100101b | 01000110b = 01100111b
-00100101b | 01000111b = 01100111b
-00100101b | 01001000b = 01101101b
-00100101b | 01001001b = 01101101b
-00100101b | 01001010b = 01101111b
-00100101b | 01001011b = 01101111b
-00100101b | 01001100b = 01101101b
-00100101b | 01001101b = 01101101b
-00100101b | 01001110b = 01101111b
-00100101b | 01001111b = 01101111b
-00100101b | 01010000b = 01110101b
-00100101b | 01010001b = 01110101b
-00100101b | 01010010b = 01110111b
-00100101b | 01010011b = 01110111b
-00100101b | 01010100b = 01110101b
-00100101b | 01010101b = 01110101b
-00100101b | 01010110b = 01110111b
-00100101b | 01010111b = 01110111b
-00100101b | 01011000b = 01111101b
-00100101b | 01011001b = 01111101b
-00100101b | 01011010b = 01111111b
-00100101b | 01011011b = 01111111b
-00100101b | 01011100b = 01111101b
-00100101b | 01011101b = 01111101b
-00100101b | 01011110b = 01111111b
-00100101b | 01011111b = 01111111b
-00100101b | 01100000b = 01100101b
-00100101b | 01100001b = 01100101b
-00100101b | 01100010b = 01100111b
-00100101b | 01100011b = 01100111b
-00100101b | 01100100b = 01100101b
-00100101b | 01100101b = 01100101b
-00100101b | 01100110b = 01100111b
-00100101b | 01100111b = 01100111b
-00100101b | 01101000b = 01101101b
-00100101b | 01101001b = 01101101b
-00100101b | 01101010b = 01101111b
-00100101b | 01101011b = 01101111b
-00100101b | 01101100b = 01101101b
-00100101b | 01101101b = 01101101b
-00100101b | 01101110b = 01101111b
-00100101b | 01101111b = 01101111b
-00100101b | 01110000b = 01110101b
-00100101b | 01110001b = 01110101b
-00100101b | 01110010b = 01110111b
-00100101b | 01110011b = 01110111b
-00100101b | 01110100b = 01110101b
-00100101b | 01110101b = 01110101b
-00100101b | 01110110b = 01110111b
-00100101b | 01110111b = 01110111b
-00100101b | 01111000b = 01111101b
-00100101b | 01111001b = 01111101b
-00100101b | 01111010b = 01111111b
-00100101b | 01111011b = 01111111b
-00100101b | 01111100b = 01111101b
-00100101b | 01111101b = 01111101b
-00100101b | 01111110b = 01111111b
-00100110b | 10000000b = 10100110b
-00100110b | 10000001b = 10100111b
-00100110b | 10000010b = 10100110b
-00100110b | 10000011b = 10100111b
-00100110b | 10000100b = 10100110b
-00100110b | 10000101b = 10100111b
-00100110b | 10000110b = 10100110b
-00100110b | 10000111b = 10100111b
-00100110b | 10001000b = 10101110b
-00100110b | 10001001b = 10101111b
-00100110b | 10001010b = 10101110b
-00100110b | 10001011b = 10101111b
-00100110b | 10001100b = 10101110b
-00100110b | 10001101b = 10101111b
-00100110b | 10001110b = 10101110b
-00100110b | 10001111b = 10101111b
-00100110b | 10010000b = 10110110b
-00100110b | 10010001b = 10110111b
-00100110b | 10010010b = 10110110b
-00100110b | 10010011b = 10110111b
-00100110b | 10010100b = 10110110b
-00100110b | 10010101b = 10110111b
-00100110b | 10010110b = 10110110b
-00100110b | 10010111b = 10110111b
-00100110b | 10011000b = 10111110b
-00100110b | 10011001b = 10111111b
-00100110b | 10011010b = 10111110b
-00100110b | 10011011b = 10111111b
-00100110b | 10011100b = 10111110b
-00100110b | 10011101b = 10111111b
-00100110b | 10011110b = 10111110b
-00100110b | 10011111b = 10111111b
-00100110b | 10100000b = 10100110b
-00100110b | 10100001b = 10100111b
-00100110b | 10100010b = 10100110b
-00100110b | 10100011b = 10100111b
-00100110b | 10100100b = 10100110b
-00100110b | 10100101b = 10100111b
-00100110b | 10100110b = 10100110b
-00100110b | 10100111b = 10100111b
-00100110b | 10101000b = 10101110b
-00100110b | 10101001b = 10101111b
-00100110b | 10101010b = 10101110b
-00100110b | 10101011b = 10101111b
-00100110b | 10101100b = 10101110b
-00100110b | 10101101b = 10101111b
-00100110b | 10101110b = 10101110b
-00100110b | 10101111b = 10101111b
-00100110b | 10110000b = 10110110b
-00100110b | 10110001b = 10110111b
-00100110b | 10110010b = 10110110b
-00100110b | 10110011b = 10110111b
-00100110b | 10110100b = 10110110b
-00100110b | 10110101b = 10110111b
-00100110b | 10110110b = 10110110b
-00100110b | 10110111b = 10110111b
-00100110b | 10111000b = 10111110b
-00100110b | 10111001b = 10111111b
-00100110b | 10111010b = 10111110b
-00100110b | 10111011b = 10111111b
-00100110b | 10111100b = 10111110b
-00100110b | 10111101b = 10111111b
-00100110b | 10111110b = 10111110b
-00100110b | 10111111b = 10111111b
-00100110b | 11000000b = 11100110b
-00100110b | 11000001b = 11100111b
-00100110b | 11000010b = 11100110b
-00100110b | 11000011b = 11100111b
-00100110b | 11000100b = 11100110b
-00100110b | 11000101b = 11100111b
-00100110b | 11000110b = 11100110b
-00100110b | 11000111b = 11100111b
-00100110b | 11001000b = 11101110b
-00100110b | 11001001b = 11101111b
-00100110b | 11001010b = 11101110b
-00100110b | 11001011b = 11101111b
-00100110b | 11001100b = 11101110b
-00100110b | 11001101b = 11101111b
-00100110b | 11001110b = 11101110b
-00100110b | 11001111b = 11101111b
-00100110b | 11010000b = 11110110b
-00100110b | 11010001b = 11110111b
-00100110b | 11010010b = 11110110b
-00100110b | 11010011b = 11110111b
-00100110b | 11010100b = 11110110b
-00100110b | 11010101b = 11110111b
-00100110b | 11010110b = 11110110b
-00100110b | 11010111b = 11110111b
-00100110b | 11011000b = 11111110b
-00100110b | 11011001b = 11111111b
-00100110b | 11011010b = 11111110b
-00100110b | 11011011b = 11111111b
-00100110b | 11011100b = 11111110b
-00100110b | 11011101b = 11111111b
-00100110b | 11011110b = 11111110b
-00100110b | 11011111b = 11111111b
-00100110b | 11100000b = 11100110b
-00100110b | 11100001b = 11100111b
-00100110b | 11100010b = 11100110b
-00100110b | 11100011b = 11100111b
-00100110b | 11100100b = 11100110b
-00100110b | 11100101b = 11100111b
-00100110b | 11100110b = 11100110b
-00100110b | 11100111b = 11100111b
-00100110b | 11101000b = 11101110b
-00100110b | 11101001b = 11101111b
-00100110b | 11101010b = 11101110b
-00100110b | 11101011b = 11101111b
-00100110b | 11101100b = 11101110b
-00100110b | 11101101b = 11101111b
-00100110b | 11101110b = 11101110b
-00100110b | 11101111b = 11101111b
-00100110b | 11110000b = 11110110b
-00100110b | 11110001b = 11110111b
-00100110b | 11110010b = 11110110b
-00100110b | 11110011b = 11110111b
-00100110b | 11110100b = 11110110b
-00100110b | 11110101b = 11110111b
-00100110b | 11110110b = 11110110b
-00100110b | 11110111b = 11110111b
-00100110b | 11111000b = 11111110b
-00100110b | 11111001b = 11111111b
-00100110b | 11111010b = 11111110b
-00100110b | 11111011b = 11111111b
-00100110b | 11111100b = 11111110b
-00100110b | 11111101b = 11111111b
-00100110b | 11111110b = 11111110b
-00100110b | 11111111b = 11111111b
-00100110b | 00000000b = 00100110b
-00100110b | 00000001b = 00100111b
-00100110b | 00000010b = 00100110b
-00100110b | 00000011b = 00100111b
-00100110b | 00000100b = 00100110b
-00100110b | 00000101b = 00100111b
-00100110b | 00000110b = 00100110b
-00100110b | 00000111b = 00100111b
-00100110b | 00001000b = 00101110b
-00100110b | 00001001b = 00101111b
-00100110b | 00001010b = 00101110b
-00100110b | 00001011b = 00101111b
-00100110b | 00001100b = 00101110b
-00100110b | 00001101b = 00101111b
-00100110b | 00001110b = 00101110b
-00100110b | 00001111b = 00101111b
-00100110b | 00010000b = 00110110b
-00100110b | 00010001b = 00110111b
-00100110b | 00010010b = 00110110b
-00100110b | 00010011b = 00110111b
-00100110b | 00010100b = 00110110b
-00100110b | 00010101b = 00110111b
-00100110b | 00010110b = 00110110b
-00100110b | 00010111b = 00110111b
-00100110b | 00011000b = 00111110b
-00100110b | 00011001b = 00111111b
-00100110b | 00011010b = 00111110b
-00100110b | 00011011b = 00111111b
-00100110b | 00011100b = 00111110b
-00100110b | 00011101b = 00111111b
-00100110b | 00011110b = 00111110b
-00100110b | 00011111b = 00111111b
-00100110b | 00100000b = 00100110b
-00100110b | 00100001b = 00100111b
-00100110b | 00100010b = 00100110b
-00100110b | 00100011b = 00100111b
-00100110b | 00100100b = 00100110b
-00100110b | 00100101b = 00100111b
-00100110b | 00100110b = 00100110b
-00100110b | 00100111b = 00100111b
-00100110b | 00101000b = 00101110b
-00100110b | 00101001b = 00101111b
-00100110b | 00101010b = 00101110b
-00100110b | 00101011b = 00101111b
-00100110b | 00101100b = 00101110b
-00100110b | 00101101b = 00101111b
-00100110b | 00101110b = 00101110b
-00100110b | 00101111b = 00101111b
-00100110b | 00110000b = 00110110b
-00100110b | 00110001b = 00110111b
-00100110b | 00110010b = 00110110b
-00100110b | 00110011b = 00110111b
-00100110b | 00110100b = 00110110b
-00100110b | 00110101b = 00110111b
-00100110b | 00110110b = 00110110b
-00100110b | 00110111b = 00110111b
-00100110b | 00111000b = 00111110b
-00100110b | 00111001b = 00111111b
-00100110b | 00111010b = 00111110b
-00100110b | 00111011b = 00111111b
-00100110b | 00111100b = 00111110b
-00100110b | 00111101b = 00111111b
-00100110b | 00111110b = 00111110b
-00100110b | 00111111b = 00111111b
-00100110b | 01000000b = 01100110b
-00100110b | 01000001b = 01100111b
-00100110b | 01000010b = 01100110b
-00100110b | 01000011b = 01100111b
-00100110b | 01000100b = 01100110b
-00100110b | 01000101b = 01100111b
-00100110b | 01000110b = 01100110b
-00100110b | 01000111b = 01100111b
-00100110b | 01001000b = 01101110b
-00100110b | 01001001b = 01101111b
-00100110b | 01001010b = 01101110b
-00100110b | 01001011b = 01101111b
-00100110b | 01001100b = 01101110b
-00100110b | 01001101b = 01101111b
-00100110b | 01001110b = 01101110b
-00100110b | 01001111b = 01101111b
-00100110b | 01010000b = 01110110b
-00100110b | 01010001b = 01110111b
-00100110b | 01010010b = 01110110b
-00100110b | 01010011b = 01110111b
-00100110b | 01010100b = 01110110b
-00100110b | 01010101b = 01110111b
-00100110b | 01010110b = 01110110b
-00100110b | 01010111b = 01110111b
-00100110b | 01011000b = 01111110b
-00100110b | 01011001b = 01111111b
-00100110b | 01011010b = 01111110b
-00100110b | 01011011b = 01111111b
-00100110b | 01011100b = 01111110b
-00100110b | 01011101b = 01111111b
-00100110b | 01011110b = 01111110b
-00100110b | 01011111b = 01111111b
-00100110b | 01100000b = 01100110b
-00100110b | 01100001b = 01100111b
-00100110b | 01100010b = 01100110b
-00100110b | 01100011b = 01100111b
-00100110b | 01100100b = 01100110b
-00100110b | 01100101b = 01100111b
-00100110b | 01100110b = 01100110b
-00100110b | 01100111b = 01100111b
-00100110b | 01101000b = 01101110b
-00100110b | 01101001b = 01101111b
-00100110b | 01101010b = 01101110b
-00100110b | 01101011b = 01101111b
-00100110b | 01101100b = 01101110b
-00100110b | 01101101b = 01101111b
-00100110b | 01101110b = 01101110b
-00100110b | 01101111b = 01101111b
-00100110b | 01110000b = 01110110b
-00100110b | 01110001b = 01110111b
-00100110b | 01110010b = 01110110b
-00100110b | 01110011b = 01110111b
-00100110b | 01110100b = 01110110b
-00100110b | 01110101b = 01110111b
-00100110b | 01110110b = 01110110b
-00100110b | 01110111b = 01110111b
-00100110b | 01111000b = 01111110b
-00100110b | 01111001b = 01111111b
-00100110b | 01111010b = 01111110b
-00100110b | 01111011b = 01111111b
-00100110b | 01111100b = 01111110b
-00100110b | 01111101b = 01111111b
-00100110b | 01111110b = 01111110b
-00100111b | 10000000b = 10100111b
-00100111b | 10000001b = 10100111b
-00100111b | 10000010b = 10100111b
-00100111b | 10000011b = 10100111b
-00100111b | 10000100b = 10100111b
-00100111b | 10000101b = 10100111b
-00100111b | 10000110b = 10100111b
-00100111b | 10000111b = 10100111b
-00100111b | 10001000b = 10101111b
-00100111b | 10001001b = 10101111b
-00100111b | 10001010b = 10101111b
-00100111b | 10001011b = 10101111b
-00100111b | 10001100b = 10101111b
-00100111b | 10001101b = 10101111b
-00100111b | 10001110b = 10101111b
-00100111b | 10001111b = 10101111b
-00100111b | 10010000b = 10110111b
-00100111b | 10010001b = 10110111b
-00100111b | 10010010b = 10110111b
-00100111b | 10010011b = 10110111b
-00100111b | 10010100b = 10110111b
-00100111b | 10010101b = 10110111b
-00100111b | 10010110b = 10110111b
-00100111b | 10010111b = 10110111b
-00100111b | 10011000b = 10111111b
-00100111b | 10011001b = 10111111b
-00100111b | 10011010b = 10111111b
-00100111b | 10011011b = 10111111b
-00100111b | 10011100b = 10111111b
-00100111b | 10011101b = 10111111b
-00100111b | 10011110b = 10111111b
-00100111b | 10011111b = 10111111b
-00100111b | 10100000b = 10100111b
-00100111b | 10100001b = 10100111b
-00100111b | 10100010b = 10100111b
-00100111b | 10100011b = 10100111b
-00100111b | 10100100b = 10100111b
-00100111b | 10100101b = 10100111b
-00100111b | 10100110b = 10100111b
-00100111b | 10100111b = 10100111b
-00100111b | 10101000b = 10101111b
-00100111b | 10101001b = 10101111b
-00100111b | 10101010b = 10101111b
-00100111b | 10101011b = 10101111b
-00100111b | 10101100b = 10101111b
-00100111b | 10101101b = 10101111b
-00100111b | 10101110b = 10101111b
-00100111b | 10101111b = 10101111b
-00100111b | 10110000b = 10110111b
-00100111b | 10110001b = 10110111b
-00100111b | 10110010b = 10110111b
-00100111b | 10110011b = 10110111b
-00100111b | 10110100b = 10110111b
-00100111b | 10110101b = 10110111b
-00100111b | 10110110b = 10110111b
-00100111b | 10110111b = 10110111b
-00100111b | 10111000b = 10111111b
-00100111b | 10111001b = 10111111b
-00100111b | 10111010b = 10111111b
-00100111b | 10111011b = 10111111b
-00100111b | 10111100b = 10111111b
-00100111b | 10111101b = 10111111b
-00100111b | 10111110b = 10111111b
-00100111b | 10111111b = 10111111b
-00100111b | 11000000b = 11100111b
-00100111b | 11000001b = 11100111b
-00100111b | 11000010b = 11100111b
-00100111b | 11000011b = 11100111b
-00100111b | 11000100b = 11100111b
-00100111b | 11000101b = 11100111b
-00100111b | 11000110b = 11100111b
-00100111b | 11000111b = 11100111b
-00100111b | 11001000b = 11101111b
-00100111b | 11001001b = 11101111b
-00100111b | 11001010b = 11101111b
-00100111b | 11001011b = 11101111b
-00100111b | 11001100b = 11101111b
-00100111b | 11001101b = 11101111b
-00100111b | 11001110b = 11101111b
-00100111b | 11001111b = 11101111b
-00100111b | 11010000b = 11110111b
-00100111b | 11010001b = 11110111b
-00100111b | 11010010b = 11110111b
-00100111b | 11010011b = 11110111b
-00100111b | 11010100b = 11110111b
-00100111b | 11010101b = 11110111b
-00100111b | 11010110b = 11110111b
-00100111b | 11010111b = 11110111b
-00100111b | 11011000b = 11111111b
-00100111b | 11011001b = 11111111b
-00100111b | 11011010b = 11111111b
-00100111b | 11011011b = 11111111b
-00100111b | 11011100b = 11111111b
-00100111b | 11011101b = 11111111b
-00100111b | 11011110b = 11111111b
-00100111b | 11011111b = 11111111b
-00100111b | 11100000b = 11100111b
-00100111b | 11100001b = 11100111b
-00100111b | 11100010b = 11100111b
-00100111b | 11100011b = 11100111b
-00100111b | 11100100b = 11100111b
-00100111b | 11100101b = 11100111b
-00100111b | 11100110b = 11100111b
-00100111b | 11100111b = 11100111b
-00100111b | 11101000b = 11101111b
-00100111b | 11101001b = 11101111b
-00100111b | 11101010b = 11101111b
-00100111b | 11101011b = 11101111b
-00100111b | 11101100b = 11101111b
-00100111b | 11101101b = 11101111b
-00100111b | 11101110b = 11101111b
-00100111b | 11101111b = 11101111b
-00100111b | 11110000b = 11110111b
-00100111b | 11110001b = 11110111b
-00100111b | 11110010b = 11110111b
-00100111b | 11110011b = 11110111b
-00100111b | 11110100b = 11110111b
-00100111b | 11110101b = 11110111b
-00100111b | 11110110b = 11110111b
-00100111b | 11110111b = 11110111b
-00100111b | 11111000b = 11111111b
-00100111b | 11111001b = 11111111b
-00100111b | 11111010b = 11111111b
-00100111b | 11111011b = 11111111b
-00100111b | 11111100b = 11111111b
-00100111b | 11111101b = 11111111b
-00100111b | 11111110b = 11111111b
-00100111b | 11111111b = 11111111b
-00100111b | 00000000b = 00100111b
-00100111b | 00000001b = 00100111b
-00100111b | 00000010b = 00100111b
-00100111b | 00000011b = 00100111b
-00100111b | 00000100b = 00100111b
-00100111b | 00000101b = 00100111b
-00100111b | 00000110b = 00100111b
-00100111b | 00000111b = 00100111b
-00100111b | 00001000b = 00101111b
-00100111b | 00001001b = 00101111b
-00100111b | 00001010b = 00101111b
-00100111b | 00001011b = 00101111b
-00100111b | 00001100b = 00101111b
-00100111b | 00001101b = 00101111b
-00100111b | 00001110b = 00101111b
-00100111b | 00001111b = 00101111b
-00100111b | 00010000b = 00110111b
-00100111b | 00010001b = 00110111b
-00100111b | 00010010b = 00110111b
-00100111b | 00010011b = 00110111b
-00100111b | 00010100b = 00110111b
-00100111b | 00010101b = 00110111b
-00100111b | 00010110b = 00110111b
-00100111b | 00010111b = 00110111b
-00100111b | 00011000b = 00111111b
-00100111b | 00011001b = 00111111b
-00100111b | 00011010b = 00111111b
-00100111b | 00011011b = 00111111b
-00100111b | 00011100b = 00111111b
-00100111b | 00011101b = 00111111b
-00100111b | 00011110b = 00111111b
-00100111b | 00011111b = 00111111b
-00100111b | 00100000b = 00100111b
-00100111b | 00100001b = 00100111b
-00100111b | 00100010b = 00100111b
-00100111b | 00100011b = 00100111b
-00100111b | 00100100b = 00100111b
-00100111b | 00100101b = 00100111b
-00100111b | 00100110b = 00100111b
-00100111b | 00100111b = 00100111b
-00100111b | 00101000b = 00101111b
-00100111b | 00101001b = 00101111b
-00100111b | 00101010b = 00101111b
-00100111b | 00101011b = 00101111b
-00100111b | 00101100b = 00101111b
-00100111b | 00101101b = 00101111b
-00100111b | 00101110b = 00101111b
-00100111b | 00101111b = 00101111b
-00100111b | 00110000b = 00110111b
-00100111b | 00110001b = 00110111b
-00100111b | 00110010b = 00110111b
-00100111b | 00110011b = 00110111b
-00100111b | 00110100b = 00110111b
-00100111b | 00110101b = 00110111b
-00100111b | 00110110b = 00110111b
-00100111b | 00110111b = 00110111b
-00100111b | 00111000b = 00111111b
-00100111b | 00111001b = 00111111b
-00100111b | 00111010b = 00111111b
-00100111b | 00111011b = 00111111b
-00100111b | 00111100b = 00111111b
-00100111b | 00111101b = 00111111b
-00100111b | 00111110b = 00111111b
-00100111b | 00111111b = 00111111b
-00100111b | 01000000b = 01100111b
-00100111b | 01000001b = 01100111b
-00100111b | 01000010b = 01100111b
-00100111b | 01000011b = 01100111b
-00100111b | 01000100b = 01100111b
-00100111b | 01000101b = 01100111b
-00100111b | 01000110b = 01100111b
-00100111b | 01000111b = 01100111b
-00100111b | 01001000b = 01101111b
-00100111b | 01001001b = 01101111b
-00100111b | 01001010b = 01101111b
-00100111b | 01001011b = 01101111b
-00100111b | 01001100b = 01101111b
-00100111b | 01001101b = 01101111b
-00100111b | 01001110b = 01101111b
-00100111b | 01001111b = 01101111b
-00100111b | 01010000b = 01110111b
-00100111b | 01010001b = 01110111b
-00100111b | 01010010b = 01110111b
-00100111b | 01010011b = 01110111b
-00100111b | 01010100b = 01110111b
-00100111b | 01010101b = 01110111b
-00100111b | 01010110b = 01110111b
-00100111b | 01010111b = 01110111b
-00100111b | 01011000b = 01111111b
-00100111b | 01011001b = 01111111b
-00100111b | 01011010b = 01111111b
-00100111b | 01011011b = 01111111b
-00100111b | 01011100b = 01111111b
-00100111b | 01011101b = 01111111b
-00100111b | 01011110b = 01111111b
-00100111b | 01011111b = 01111111b
-00100111b | 01100000b = 01100111b
-00100111b | 01100001b = 01100111b
-00100111b | 01100010b = 01100111b
-00100111b | 01100011b = 01100111b
-00100111b | 01100100b = 01100111b
-00100111b | 01100101b = 01100111b
-00100111b | 01100110b = 01100111b
-00100111b | 01100111b = 01100111b
-00100111b | 01101000b = 01101111b
-00100111b | 01101001b = 01101111b
-00100111b | 01101010b = 01101111b
-00100111b | 01101011b = 01101111b
-00100111b | 01101100b = 01101111b
-00100111b | 01101101b = 01101111b
-00100111b | 01101110b = 01101111b
-00100111b | 01101111b = 01101111b
-00100111b | 01110000b = 01110111b
-00100111b | 01110001b = 01110111b
-00100111b | 01110010b = 01110111b
-00100111b | 01110011b = 01110111b
-00100111b | 01110100b = 01110111b
-00100111b | 01110101b = 01110111b
-00100111b | 01110110b = 01110111b
-00100111b | 01110111b = 01110111b
-00100111b | 01111000b = 01111111b
-00100111b | 01111001b = 01111111b
-00100111b | 01111010b = 01111111b
-00100111b | 01111011b = 01111111b
-00100111b | 01111100b = 01111111b
-00100111b | 01111101b = 01111111b
-00100111b | 01111110b = 01111111b
-00101000b | 10000000b = 10101000b
-00101000b | 10000001b = 10101001b
-00101000b | 10000010b = 10101010b
-00101000b | 10000011b = 10101011b
-00101000b | 10000100b = 10101100b
-00101000b | 10000101b = 10101101b
-00101000b | 10000110b = 10101110b
-00101000b | 10000111b = 10101111b
-00101000b | 10001000b = 10101000b
-00101000b | 10001001b = 10101001b
-00101000b | 10001010b = 10101010b
-00101000b | 10001011b = 10101011b
-00101000b | 10001100b = 10101100b
-00101000b | 10001101b = 10101101b
-00101000b | 10001110b = 10101110b
-00101000b | 10001111b = 10101111b
-00101000b | 10010000b = 10111000b
-00101000b | 10010001b = 10111001b
-00101000b | 10010010b = 10111010b
-00101000b | 10010011b = 10111011b
-00101000b | 10010100b = 10111100b
-00101000b | 10010101b = 10111101b
-00101000b | 10010110b = 10111110b
-00101000b | 10010111b = 10111111b
-00101000b | 10011000b = 10111000b
-00101000b | 10011001b = 10111001b
-00101000b | 10011010b = 10111010b
-00101000b | 10011011b = 10111011b
-00101000b | 10011100b = 10111100b
-00101000b | 10011101b = 10111101b
-00101000b | 10011110b = 10111110b
-00101000b | 10011111b = 10111111b
-00101000b | 10100000b = 10101000b
-00101000b | 10100001b = 10101001b
-00101000b | 10100010b = 10101010b
-00101000b | 10100011b = 10101011b
-00101000b | 10100100b = 10101100b
-00101000b | 10100101b = 10101101b
-00101000b | 10100110b = 10101110b
-00101000b | 10100111b = 10101111b
-00101000b | 10101000b = 10101000b
-00101000b | 10101001b = 10101001b
-00101000b | 10101010b = 10101010b
-00101000b | 10101011b = 10101011b
-00101000b | 10101100b = 10101100b
-00101000b | 10101101b = 10101101b
-00101000b | 10101110b = 10101110b
-00101000b | 10101111b = 10101111b
-00101000b | 10110000b = 10111000b
-00101000b | 10110001b = 10111001b
-00101000b | 10110010b = 10111010b
-00101000b | 10110011b = 10111011b
-00101000b | 10110100b = 10111100b
-00101000b | 10110101b = 10111101b
-00101000b | 10110110b = 10111110b
-00101000b | 10110111b = 10111111b
-00101000b | 10111000b = 10111000b
-00101000b | 10111001b = 10111001b
-00101000b | 10111010b = 10111010b
-00101000b | 10111011b = 10111011b
-00101000b | 10111100b = 10111100b
-00101000b | 10111101b = 10111101b
-00101000b | 10111110b = 10111110b
-00101000b | 10111111b = 10111111b
-00101000b | 11000000b = 11101000b
-00101000b | 11000001b = 11101001b
-00101000b | 11000010b = 11101010b
-00101000b | 11000011b = 11101011b
-00101000b | 11000100b = 11101100b
-00101000b | 11000101b = 11101101b
-00101000b | 11000110b = 11101110b
-00101000b | 11000111b = 11101111b
-00101000b | 11001000b = 11101000b
-00101000b | 11001001b = 11101001b
-00101000b | 11001010b = 11101010b
-00101000b | 11001011b = 11101011b
-00101000b | 11001100b = 11101100b
-00101000b | 11001101b = 11101101b
-00101000b | 11001110b = 11101110b
-00101000b | 11001111b = 11101111b
-00101000b | 11010000b = 11111000b
-00101000b | 11010001b = 11111001b
-00101000b | 11010010b = 11111010b
-00101000b | 11010011b = 11111011b
-00101000b | 11010100b = 11111100b
-00101000b | 11010101b = 11111101b
-00101000b | 11010110b = 11111110b
-00101000b | 11010111b = 11111111b
-00101000b | 11011000b = 11111000b
-00101000b | 11011001b = 11111001b
-00101000b | 11011010b = 11111010b
-00101000b | 11011011b = 11111011b
-00101000b | 11011100b = 11111100b
-00101000b | 11011101b = 11111101b
-00101000b | 11011110b = 11111110b
-00101000b | 11011111b = 11111111b
-00101000b | 11100000b = 11101000b
-00101000b | 11100001b = 11101001b
-00101000b | 11100010b = 11101010b
-00101000b | 11100011b = 11101011b
-00101000b | 11100100b = 11101100b
-00101000b | 11100101b = 11101101b
-00101000b | 11100110b = 11101110b
-00101000b | 11100111b = 11101111b
-00101000b | 11101000b = 11101000b
-00101000b | 11101001b = 11101001b
-00101000b | 11101010b = 11101010b
-00101000b | 11101011b = 11101011b
-00101000b | 11101100b = 11101100b
-00101000b | 11101101b = 11101101b
-00101000b | 11101110b = 11101110b
-00101000b | 11101111b = 11101111b
-00101000b | 11110000b = 11111000b
-00101000b | 11110001b = 11111001b
-00101000b | 11110010b = 11111010b
-00101000b | 11110011b = 11111011b
-00101000b | 11110100b = 11111100b
-00101000b | 11110101b = 11111101b
-00101000b | 11110110b = 11111110b
-00101000b | 11110111b = 11111111b
-00101000b | 11111000b = 11111000b
-00101000b | 11111001b = 11111001b
-00101000b | 11111010b = 11111010b
-00101000b | 11111011b = 11111011b
-00101000b | 11111100b = 11111100b
-00101000b | 11111101b = 11111101b
-00101000b | 11111110b = 11111110b
-00101000b | 11111111b = 11111111b
-00101000b | 00000000b = 00101000b
-00101000b | 00000001b = 00101001b
-00101000b | 00000010b = 00101010b
-00101000b | 00000011b = 00101011b
-00101000b | 00000100b = 00101100b
-00101000b | 00000101b = 00101101b
-00101000b | 00000110b = 00101110b
-00101000b | 00000111b = 00101111b
-00101000b | 00001000b = 00101000b
-00101000b | 00001001b = 00101001b
-00101000b | 00001010b = 00101010b
-00101000b | 00001011b = 00101011b
-00101000b | 00001100b = 00101100b
-00101000b | 00001101b = 00101101b
-00101000b | 00001110b = 00101110b
-00101000b | 00001111b = 00101111b
-00101000b | 00010000b = 00111000b
-00101000b | 00010001b = 00111001b
-00101000b | 00010010b = 00111010b
-00101000b | 00010011b = 00111011b
-00101000b | 00010100b = 00111100b
-00101000b | 00010101b = 00111101b
-00101000b | 00010110b = 00111110b
-00101000b | 00010111b = 00111111b
-00101000b | 00011000b = 00111000b
-00101000b | 00011001b = 00111001b
-00101000b | 00011010b = 00111010b
-00101000b | 00011011b = 00111011b
-00101000b | 00011100b = 00111100b
-00101000b | 00011101b = 00111101b
-00101000b | 00011110b = 00111110b
-00101000b | 00011111b = 00111111b
-00101000b | 00100000b = 00101000b
-00101000b | 00100001b = 00101001b
-00101000b | 00100010b = 00101010b
-00101000b | 00100011b = 00101011b
-00101000b | 00100100b = 00101100b
-00101000b | 00100101b = 00101101b
-00101000b | 00100110b = 00101110b
-00101000b | 00100111b = 00101111b
-00101000b | 00101000b = 00101000b
-00101000b | 00101001b = 00101001b
-00101000b | 00101010b = 00101010b
-00101000b | 00101011b = 00101011b
-00101000b | 00101100b = 00101100b
-00101000b | 00101101b = 00101101b
-00101000b | 00101110b = 00101110b
-00101000b | 00101111b = 00101111b
-00101000b | 00110000b = 00111000b
-00101000b | 00110001b = 00111001b
-00101000b | 00110010b = 00111010b
-00101000b | 00110011b = 00111011b
-00101000b | 00110100b = 00111100b
-00101000b | 00110101b = 00111101b
-00101000b | 00110110b = 00111110b
-00101000b | 00110111b = 00111111b
-00101000b | 00111000b = 00111000b
-00101000b | 00111001b = 00111001b
-00101000b | 00111010b = 00111010b
-00101000b | 00111011b = 00111011b
-00101000b | 00111100b = 00111100b
-00101000b | 00111101b = 00111101b
-00101000b | 00111110b = 00111110b
-00101000b | 00111111b = 00111111b
-00101000b | 01000000b = 01101000b
-00101000b | 01000001b = 01101001b
-00101000b | 01000010b = 01101010b
-00101000b | 01000011b = 01101011b
-00101000b | 01000100b = 01101100b
-00101000b | 01000101b = 01101101b
-00101000b | 01000110b = 01101110b
-00101000b | 01000111b = 01101111b
-00101000b | 01001000b = 01101000b
-00101000b | 01001001b = 01101001b
-00101000b | 01001010b = 01101010b
-00101000b | 01001011b = 01101011b
-00101000b | 01001100b = 01101100b
-00101000b | 01001101b = 01101101b
-00101000b | 01001110b = 01101110b
-00101000b | 01001111b = 01101111b
-00101000b | 01010000b = 01111000b
-00101000b | 01010001b = 01111001b
-00101000b | 01010010b = 01111010b
-00101000b | 01010011b = 01111011b
-00101000b | 01010100b = 01111100b
-00101000b | 01010101b = 01111101b
-00101000b | 01010110b = 01111110b
-00101000b | 01010111b = 01111111b
-00101000b | 01011000b = 01111000b
-00101000b | 01011001b = 01111001b
-00101000b | 01011010b = 01111010b
-00101000b | 01011011b = 01111011b
-00101000b | 01011100b = 01111100b
-00101000b | 01011101b = 01111101b
-00101000b | 01011110b = 01111110b
-00101000b | 01011111b = 01111111b
-00101000b | 01100000b = 01101000b
-00101000b | 01100001b = 01101001b
-00101000b | 01100010b = 01101010b
-00101000b | 01100011b = 01101011b
-00101000b | 01100100b = 01101100b
-00101000b | 01100101b = 01101101b
-00101000b | 01100110b = 01101110b
-00101000b | 01100111b = 01101111b
-00101000b | 01101000b = 01101000b
-00101000b | 01101001b = 01101001b
-00101000b | 01101010b = 01101010b
-00101000b | 01101011b = 01101011b
-00101000b | 01101100b = 01101100b
-00101000b | 01101101b = 01101101b
-00101000b | 01101110b = 01101110b
-00101000b | 01101111b = 01101111b
-00101000b | 01110000b = 01111000b
-00101000b | 01110001b = 01111001b
-00101000b | 01110010b = 01111010b
-00101000b | 01110011b = 01111011b
-00101000b | 01110100b = 01111100b
-00101000b | 01110101b = 01111101b
-00101000b | 01110110b = 01111110b
-00101000b | 01110111b = 01111111b
-00101000b | 01111000b = 01111000b
-00101000b | 01111001b = 01111001b
-00101000b | 01111010b = 01111010b
-00101000b | 01111011b = 01111011b
-00101000b | 01111100b = 01111100b
-00101000b | 01111101b = 01111101b
-00101000b | 01111110b = 01111110b
-00101001b | 10000000b = 10101001b
-00101001b | 10000001b = 10101001b
-00101001b | 10000010b = 10101011b
-00101001b | 10000011b = 10101011b
-00101001b | 10000100b = 10101101b
-00101001b | 10000101b = 10101101b
-00101001b | 10000110b = 10101111b
-00101001b | 10000111b = 10101111b
-00101001b | 10001000b = 10101001b
-00101001b | 10001001b = 10101001b
-00101001b | 10001010b = 10101011b
-00101001b | 10001011b = 10101011b
-00101001b | 10001100b = 10101101b
-00101001b | 10001101b = 10101101b
-00101001b | 10001110b = 10101111b
-00101001b | 10001111b = 10101111b
-00101001b | 10010000b = 10111001b
-00101001b | 10010001b = 10111001b
-00101001b | 10010010b = 10111011b
-00101001b | 10010011b = 10111011b
-00101001b | 10010100b = 10111101b
-00101001b | 10010101b = 10111101b
-00101001b | 10010110b = 10111111b
-00101001b | 10010111b = 10111111b
-00101001b | 10011000b = 10111001b
-00101001b | 10011001b = 10111001b
-00101001b | 10011010b = 10111011b
-00101001b | 10011011b = 10111011b
-00101001b | 10011100b = 10111101b
-00101001b | 10011101b = 10111101b
-00101001b | 10011110b = 10111111b
-00101001b | 10011111b = 10111111b
-00101001b | 10100000b = 10101001b
-00101001b | 10100001b = 10101001b
-00101001b | 10100010b = 10101011b
-00101001b | 10100011b = 10101011b
-00101001b | 10100100b = 10101101b
-00101001b | 10100101b = 10101101b
-00101001b | 10100110b = 10101111b
-00101001b | 10100111b = 10101111b
-00101001b | 10101000b = 10101001b
-00101001b | 10101001b = 10101001b
-00101001b | 10101010b = 10101011b
-00101001b | 10101011b = 10101011b
-00101001b | 10101100b = 10101101b
-00101001b | 10101101b = 10101101b
-00101001b | 10101110b = 10101111b
-00101001b | 10101111b = 10101111b
-00101001b | 10110000b = 10111001b
-00101001b | 10110001b = 10111001b
-00101001b | 10110010b = 10111011b
-00101001b | 10110011b = 10111011b
-00101001b | 10110100b = 10111101b
-00101001b | 10110101b = 10111101b
-00101001b | 10110110b = 10111111b
-00101001b | 10110111b = 10111111b
-00101001b | 10111000b = 10111001b
-00101001b | 10111001b = 10111001b
-00101001b | 10111010b = 10111011b
-00101001b | 10111011b = 10111011b
-00101001b | 10111100b = 10111101b
-00101001b | 10111101b = 10111101b
-00101001b | 10111110b = 10111111b
-00101001b | 10111111b = 10111111b
-00101001b | 11000000b = 11101001b
-00101001b | 11000001b = 11101001b
-00101001b | 11000010b = 11101011b
-00101001b | 11000011b = 11101011b
-00101001b | 11000100b = 11101101b
-00101001b | 11000101b = 11101101b
-00101001b | 11000110b = 11101111b
-00101001b | 11000111b = 11101111b
-00101001b | 11001000b = 11101001b
-00101001b | 11001001b = 11101001b
-00101001b | 11001010b = 11101011b
-00101001b | 11001011b = 11101011b
-00101001b | 11001100b = 11101101b
-00101001b | 11001101b = 11101101b
-00101001b | 11001110b = 11101111b
-00101001b | 11001111b = 11101111b
-00101001b | 11010000b = 11111001b
-00101001b | 11010001b = 11111001b
-00101001b | 11010010b = 11111011b
-00101001b | 11010011b = 11111011b
-00101001b | 11010100b = 11111101b
-00101001b | 11010101b = 11111101b
-00101001b | 11010110b = 11111111b
-00101001b | 11010111b = 11111111b
-00101001b | 11011000b = 11111001b
-00101001b | 11011001b = 11111001b
-00101001b | 11011010b = 11111011b
-00101001b | 11011011b = 11111011b
-00101001b | 11011100b = 11111101b
-00101001b | 11011101b = 11111101b
-00101001b | 11011110b = 11111111b
-00101001b | 11011111b = 11111111b
-00101001b | 11100000b = 11101001b
-00101001b | 11100001b = 11101001b
-00101001b | 11100010b = 11101011b
-00101001b | 11100011b = 11101011b
-00101001b | 11100100b = 11101101b
-00101001b | 11100101b = 11101101b
-00101001b | 11100110b = 11101111b
-00101001b | 11100111b = 11101111b
-00101001b | 11101000b = 11101001b
-00101001b | 11101001b = 11101001b
-00101001b | 11101010b = 11101011b
-00101001b | 11101011b = 11101011b
-00101001b | 11101100b = 11101101b
-00101001b | 11101101b = 11101101b
-00101001b | 11101110b = 11101111b
-00101001b | 11101111b = 11101111b
-00101001b | 11110000b = 11111001b
-00101001b | 11110001b = 11111001b
-00101001b | 11110010b = 11111011b
-00101001b | 11110011b = 11111011b
-00101001b | 11110100b = 11111101b
-00101001b | 11110101b = 11111101b
-00101001b | 11110110b = 11111111b
-00101001b | 11110111b = 11111111b
-00101001b | 11111000b = 11111001b
-00101001b | 11111001b = 11111001b
-00101001b | 11111010b = 11111011b
-00101001b | 11111011b = 11111011b
-00101001b | 11111100b = 11111101b
-00101001b | 11111101b = 11111101b
-00101001b | 11111110b = 11111111b
-00101001b | 11111111b = 11111111b
-00101001b | 00000000b = 00101001b
-00101001b | 00000001b = 00101001b
-00101001b | 00000010b = 00101011b
-00101001b | 00000011b = 00101011b
-00101001b | 00000100b = 00101101b
-00101001b | 00000101b = 00101101b
-00101001b | 00000110b = 00101111b
-00101001b | 00000111b = 00101111b
-00101001b | 00001000b = 00101001b
-00101001b | 00001001b = 00101001b
-00101001b | 00001010b = 00101011b
-00101001b | 00001011b = 00101011b
-00101001b | 00001100b = 00101101b
-00101001b | 00001101b = 00101101b
-00101001b | 00001110b = 00101111b
-00101001b | 00001111b = 00101111b
-00101001b | 00010000b = 00111001b
-00101001b | 00010001b = 00111001b
-00101001b | 00010010b = 00111011b
-00101001b | 00010011b = 00111011b
-00101001b | 00010100b = 00111101b
-00101001b | 00010101b = 00111101b
-00101001b | 00010110b = 00111111b
-00101001b | 00010111b = 00111111b
-00101001b | 00011000b = 00111001b
-00101001b | 00011001b = 00111001b
-00101001b | 00011010b = 00111011b
-00101001b | 00011011b = 00111011b
-00101001b | 00011100b = 00111101b
-00101001b | 00011101b = 00111101b
-00101001b | 00011110b = 00111111b
-00101001b | 00011111b = 00111111b
-00101001b | 00100000b = 00101001b
-00101001b | 00100001b = 00101001b
-00101001b | 00100010b = 00101011b
-00101001b | 00100011b = 00101011b
-00101001b | 00100100b = 00101101b
-00101001b | 00100101b = 00101101b
-00101001b | 00100110b = 00101111b
-00101001b | 00100111b = 00101111b
-00101001b | 00101000b = 00101001b
-00101001b | 00101001b = 00101001b
-00101001b | 00101010b = 00101011b
-00101001b | 00101011b = 00101011b
-00101001b | 00101100b = 00101101b
-00101001b | 00101101b = 00101101b
-00101001b | 00101110b = 00101111b
-00101001b | 00101111b = 00101111b
-00101001b | 00110000b = 00111001b
-00101001b | 00110001b = 00111001b
-00101001b | 00110010b = 00111011b
-00101001b | 00110011b = 00111011b
-00101001b | 00110100b = 00111101b
-00101001b | 00110101b = 00111101b
-00101001b | 00110110b = 00111111b
-00101001b | 00110111b = 00111111b
-00101001b | 00111000b = 00111001b
-00101001b | 00111001b = 00111001b
-00101001b | 00111010b = 00111011b
-00101001b | 00111011b = 00111011b
-00101001b | 00111100b = 00111101b
-00101001b | 00111101b = 00111101b
-00101001b | 00111110b = 00111111b
-00101001b | 00111111b = 00111111b
-00101001b | 01000000b = 01101001b
-00101001b | 01000001b = 01101001b
-00101001b | 01000010b = 01101011b
-00101001b | 01000011b = 01101011b
-00101001b | 01000100b = 01101101b
-00101001b | 01000101b = 01101101b
-00101001b | 01000110b = 01101111b
-00101001b | 01000111b = 01101111b
-00101001b | 01001000b = 01101001b
-00101001b | 01001001b = 01101001b
-00101001b | 01001010b = 01101011b
-00101001b | 01001011b = 01101011b
-00101001b | 01001100b = 01101101b
-00101001b | 01001101b = 01101101b
-00101001b | 01001110b = 01101111b
-00101001b | 01001111b = 01101111b
-00101001b | 01010000b = 01111001b
-00101001b | 01010001b = 01111001b
-00101001b | 01010010b = 01111011b
-00101001b | 01010011b = 01111011b
-00101001b | 01010100b = 01111101b
-00101001b | 01010101b = 01111101b
-00101001b | 01010110b = 01111111b
-00101001b | 01010111b = 01111111b
-00101001b | 01011000b = 01111001b
-00101001b | 01011001b = 01111001b
-00101001b | 01011010b = 01111011b
-00101001b | 01011011b = 01111011b
-00101001b | 01011100b = 01111101b
-00101001b | 01011101b = 01111101b
-00101001b | 01011110b = 01111111b
-00101001b | 01011111b = 01111111b
-00101001b | 01100000b = 01101001b
-00101001b | 01100001b = 01101001b
-00101001b | 01100010b = 01101011b
-00101001b | 01100011b = 01101011b
-00101001b | 01100100b = 01101101b
-00101001b | 01100101b = 01101101b
-00101001b | 01100110b = 01101111b
-00101001b | 01100111b = 01101111b
-00101001b | 01101000b = 01101001b
-00101001b | 01101001b = 01101001b
-00101001b | 01101010b = 01101011b
-00101001b | 01101011b = 01101011b
-00101001b | 01101100b = 01101101b
-00101001b | 01101101b = 01101101b
-00101001b | 01101110b = 01101111b
-00101001b | 01101111b = 01101111b
-00101001b | 01110000b = 01111001b
-00101001b | 01110001b = 01111001b
-00101001b | 01110010b = 01111011b
-00101001b | 01110011b = 01111011b
-00101001b | 01110100b = 01111101b
-00101001b | 01110101b = 01111101b
-00101001b | 01110110b = 01111111b
-00101001b | 01110111b = 01111111b
-00101001b | 01111000b = 01111001b
-00101001b | 01111001b = 01111001b
-00101001b | 01111010b = 01111011b
-00101001b | 01111011b = 01111011b
-00101001b | 01111100b = 01111101b
-00101001b | 01111101b = 01111101b
-00101001b | 01111110b = 01111111b
-00101010b | 10000000b = 10101010b
-00101010b | 10000001b = 10101011b
-00101010b | 10000010b = 10101010b
-00101010b | 10000011b = 10101011b
-00101010b | 10000100b = 10101110b
-00101010b | 10000101b = 10101111b
-00101010b | 10000110b = 10101110b
-00101010b | 10000111b = 10101111b
-00101010b | 10001000b = 10101010b
-00101010b | 10001001b = 10101011b
-00101010b | 10001010b = 10101010b
-00101010b | 10001011b = 10101011b
-00101010b | 10001100b = 10101110b
-00101010b | 10001101b = 10101111b
-00101010b | 10001110b = 10101110b
-00101010b | 10001111b = 10101111b
-00101010b | 10010000b = 10111010b
-00101010b | 10010001b = 10111011b
-00101010b | 10010010b = 10111010b
-00101010b | 10010011b = 10111011b
-00101010b | 10010100b = 10111110b
-00101010b | 10010101b = 10111111b
-00101010b | 10010110b = 10111110b
-00101010b | 10010111b = 10111111b
-00101010b | 10011000b = 10111010b
-00101010b | 10011001b = 10111011b
-00101010b | 10011010b = 10111010b
-00101010b | 10011011b = 10111011b
-00101010b | 10011100b = 10111110b
-00101010b | 10011101b = 10111111b
-00101010b | 10011110b = 10111110b
-00101010b | 10011111b = 10111111b
-00101010b | 10100000b = 10101010b
-00101010b | 10100001b = 10101011b
-00101010b | 10100010b = 10101010b
-00101010b | 10100011b = 10101011b
-00101010b | 10100100b = 10101110b
-00101010b | 10100101b = 10101111b
-00101010b | 10100110b = 10101110b
-00101010b | 10100111b = 10101111b
-00101010b | 10101000b = 10101010b
-00101010b | 10101001b = 10101011b
-00101010b | 10101010b = 10101010b
-00101010b | 10101011b = 10101011b
-00101010b | 10101100b = 10101110b
-00101010b | 10101101b = 10101111b
-00101010b | 10101110b = 10101110b
-00101010b | 10101111b = 10101111b
-00101010b | 10110000b = 10111010b
-00101010b | 10110001b = 10111011b
-00101010b | 10110010b = 10111010b
-00101010b | 10110011b = 10111011b
-00101010b | 10110100b = 10111110b
-00101010b | 10110101b = 10111111b
-00101010b | 10110110b = 10111110b
-00101010b | 10110111b = 10111111b
-00101010b | 10111000b = 10111010b
-00101010b | 10111001b = 10111011b
-00101010b | 10111010b = 10111010b
-00101010b | 10111011b = 10111011b
-00101010b | 10111100b = 10111110b
-00101010b | 10111101b = 10111111b
-00101010b | 10111110b = 10111110b
-00101010b | 10111111b = 10111111b
-00101010b | 11000000b = 11101010b
-00101010b | 11000001b = 11101011b
-00101010b | 11000010b = 11101010b
-00101010b | 11000011b = 11101011b
-00101010b | 11000100b = 11101110b
-00101010b | 11000101b = 11101111b
-00101010b | 11000110b = 11101110b
-00101010b | 11000111b = 11101111b
-00101010b | 11001000b = 11101010b
-00101010b | 11001001b = 11101011b
-00101010b | 11001010b = 11101010b
-00101010b | 11001011b = 11101011b
-00101010b | 11001100b = 11101110b
-00101010b | 11001101b = 11101111b
-00101010b | 11001110b = 11101110b
-00101010b | 11001111b = 11101111b
-00101010b | 11010000b = 11111010b
-00101010b | 11010001b = 11111011b
-00101010b | 11010010b = 11111010b
-00101010b | 11010011b = 11111011b
-00101010b | 11010100b = 11111110b
-00101010b | 11010101b = 11111111b
-00101010b | 11010110b = 11111110b
-00101010b | 11010111b = 11111111b
-00101010b | 11011000b = 11111010b
-00101010b | 11011001b = 11111011b
-00101010b | 11011010b = 11111010b
-00101010b | 11011011b = 11111011b
-00101010b | 11011100b = 11111110b
-00101010b | 11011101b = 11111111b
-00101010b | 11011110b = 11111110b
-00101010b | 11011111b = 11111111b
-00101010b | 11100000b = 11101010b
-00101010b | 11100001b = 11101011b
-00101010b | 11100010b = 11101010b
-00101010b | 11100011b = 11101011b
-00101010b | 11100100b = 11101110b
-00101010b | 11100101b = 11101111b
-00101010b | 11100110b = 11101110b
-00101010b | 11100111b = 11101111b
-00101010b | 11101000b = 11101010b
-00101010b | 11101001b = 11101011b
-00101010b | 11101010b = 11101010b
-00101010b | 11101011b = 11101011b
-00101010b | 11101100b = 11101110b
-00101010b | 11101101b = 11101111b
-00101010b | 11101110b = 11101110b
-00101010b | 11101111b = 11101111b
-00101010b | 11110000b = 11111010b
-00101010b | 11110001b = 11111011b
-00101010b | 11110010b = 11111010b
-00101010b | 11110011b = 11111011b
-00101010b | 11110100b = 11111110b
-00101010b | 11110101b = 11111111b
-00101010b | 11110110b = 11111110b
-00101010b | 11110111b = 11111111b
-00101010b | 11111000b = 11111010b
-00101010b | 11111001b = 11111011b
-00101010b | 11111010b = 11111010b
-00101010b | 11111011b = 11111011b
-00101010b | 11111100b = 11111110b
-00101010b | 11111101b = 11111111b
-00101010b | 11111110b = 11111110b
-00101010b | 11111111b = 11111111b
-00101010b | 00000000b = 00101010b
-00101010b | 00000001b = 00101011b
-00101010b | 00000010b = 00101010b
-00101010b | 00000011b = 00101011b
-00101010b | 00000100b = 00101110b
-00101010b | 00000101b = 00101111b
-00101010b | 00000110b = 00101110b
-00101010b | 00000111b = 00101111b
-00101010b | 00001000b = 00101010b
-00101010b | 00001001b = 00101011b
-00101010b | 00001010b = 00101010b
-00101010b | 00001011b = 00101011b
-00101010b | 00001100b = 00101110b
-00101010b | 00001101b = 00101111b
-00101010b | 00001110b = 00101110b
-00101010b | 00001111b = 00101111b
-00101010b | 00010000b = 00111010b
-00101010b | 00010001b = 00111011b
-00101010b | 00010010b = 00111010b
-00101010b | 00010011b = 00111011b
-00101010b | 00010100b = 00111110b
-00101010b | 00010101b = 00111111b
-00101010b | 00010110b = 00111110b
-00101010b | 00010111b = 00111111b
-00101010b | 00011000b = 00111010b
-00101010b | 00011001b = 00111011b
-00101010b | 00011010b = 00111010b
-00101010b | 00011011b = 00111011b
-00101010b | 00011100b = 00111110b
-00101010b | 00011101b = 00111111b
-00101010b | 00011110b = 00111110b
-00101010b | 00011111b = 00111111b
-00101010b | 00100000b = 00101010b
-00101010b | 00100001b = 00101011b
-00101010b | 00100010b = 00101010b
-00101010b | 00100011b = 00101011b
-00101010b | 00100100b = 00101110b
-00101010b | 00100101b = 00101111b
-00101010b | 00100110b = 00101110b
-00101010b | 00100111b = 00101111b
-00101010b | 00101000b = 00101010b
-00101010b | 00101001b = 00101011b
-00101010b | 00101010b = 00101010b
-00101010b | 00101011b = 00101011b
-00101010b | 00101100b = 00101110b
-00101010b | 00101101b = 00101111b
-00101010b | 00101110b = 00101110b
-00101010b | 00101111b = 00101111b
-00101010b | 00110000b = 00111010b
-00101010b | 00110001b = 00111011b
-00101010b | 00110010b = 00111010b
-00101010b | 00110011b = 00111011b
-00101010b | 00110100b = 00111110b
-00101010b | 00110101b = 00111111b
-00101010b | 00110110b = 00111110b
-00101010b | 00110111b = 00111111b
-00101010b | 00111000b = 00111010b
-00101010b | 00111001b = 00111011b
-00101010b | 00111010b = 00111010b
-00101010b | 00111011b = 00111011b
-00101010b | 00111100b = 00111110b
-00101010b | 00111101b = 00111111b
-00101010b | 00111110b = 00111110b
-00101010b | 00111111b = 00111111b
-00101010b | 01000000b = 01101010b
-00101010b | 01000001b = 01101011b
-00101010b | 01000010b = 01101010b
-00101010b | 01000011b = 01101011b
-00101010b | 01000100b = 01101110b
-00101010b | 01000101b = 01101111b
-00101010b | 01000110b = 01101110b
-00101010b | 01000111b = 01101111b
-00101010b | 01001000b = 01101010b
-00101010b | 01001001b = 01101011b
-00101010b | 01001010b = 01101010b
-00101010b | 01001011b = 01101011b
-00101010b | 01001100b = 01101110b
-00101010b | 01001101b = 01101111b
-00101010b | 01001110b = 01101110b
-00101010b | 01001111b = 01101111b
-00101010b | 01010000b = 01111010b
-00101010b | 01010001b = 01111011b
-00101010b | 01010010b = 01111010b
-00101010b | 01010011b = 01111011b
-00101010b | 01010100b = 01111110b
-00101010b | 01010101b = 01111111b
-00101010b | 01010110b = 01111110b
-00101010b | 01010111b = 01111111b
-00101010b | 01011000b = 01111010b
-00101010b | 01011001b = 01111011b
-00101010b | 01011010b = 01111010b
-00101010b | 01011011b = 01111011b
-00101010b | 01011100b = 01111110b
-00101010b | 01011101b = 01111111b
-00101010b | 01011110b = 01111110b
-00101010b | 01011111b = 01111111b
-00101010b | 01100000b = 01101010b
-00101010b | 01100001b = 01101011b
-00101010b | 01100010b = 01101010b
-00101010b | 01100011b = 01101011b
-00101010b | 01100100b = 01101110b
-00101010b | 01100101b = 01101111b
-00101010b | 01100110b = 01101110b
-00101010b | 01100111b = 01101111b
-00101010b | 01101000b = 01101010b
-00101010b | 01101001b = 01101011b
-00101010b | 01101010b = 01101010b
-00101010b | 01101011b = 01101011b
-00101010b | 01101100b = 01101110b
-00101010b | 01101101b = 01101111b
-00101010b | 01101110b = 01101110b
-00101010b | 01101111b = 01101111b
-00101010b | 01110000b = 01111010b
-00101010b | 01110001b = 01111011b
-00101010b | 01110010b = 01111010b
-00101010b | 01110011b = 01111011b
-00101010b | 01110100b = 01111110b
-00101010b | 01110101b = 01111111b
-00101010b | 01110110b = 01111110b
-00101010b | 01110111b = 01111111b
-00101010b | 01111000b = 01111010b
-00101010b | 01111001b = 01111011b
-00101010b | 01111010b = 01111010b
-00101010b | 01111011b = 01111011b
-00101010b | 01111100b = 01111110b
-00101010b | 01111101b = 01111111b
-00101010b | 01111110b = 01111110b
-00101011b | 10000000b = 10101011b
-00101011b | 10000001b = 10101011b
-00101011b | 10000010b = 10101011b
-00101011b | 10000011b = 10101011b
-00101011b | 10000100b = 10101111b
-00101011b | 10000101b = 10101111b
-00101011b | 10000110b = 10101111b
-00101011b | 10000111b = 10101111b
-00101011b | 10001000b = 10101011b
-00101011b | 10001001b = 10101011b
-00101011b | 10001010b = 10101011b
-00101011b | 10001011b = 10101011b
-00101011b | 10001100b = 10101111b
-00101011b | 10001101b = 10101111b
-00101011b | 10001110b = 10101111b
-00101011b | 10001111b = 10101111b
-00101011b | 10010000b = 10111011b
-00101011b | 10010001b = 10111011b
-00101011b | 10010010b = 10111011b
-00101011b | 10010011b = 10111011b
-00101011b | 10010100b = 10111111b
-00101011b | 10010101b = 10111111b
-00101011b | 10010110b = 10111111b
-00101011b | 10010111b = 10111111b
-00101011b | 10011000b = 10111011b
-00101011b | 10011001b = 10111011b
-00101011b | 10011010b = 10111011b
-00101011b | 10011011b = 10111011b
-00101011b | 10011100b = 10111111b
-00101011b | 10011101b = 10111111b
-00101011b | 10011110b = 10111111b
-00101011b | 10011111b = 10111111b
-00101011b | 10100000b = 10101011b
-00101011b | 10100001b = 10101011b
-00101011b | 10100010b = 10101011b
-00101011b | 10100011b = 10101011b
-00101011b | 10100100b = 10101111b
-00101011b | 10100101b = 10101111b
-00101011b | 10100110b = 10101111b
-00101011b | 10100111b = 10101111b
-00101011b | 10101000b = 10101011b
-00101011b | 10101001b = 10101011b
-00101011b | 10101010b = 10101011b
-00101011b | 10101011b = 10101011b
-00101011b | 10101100b = 10101111b
-00101011b | 10101101b = 10101111b
-00101011b | 10101110b = 10101111b
-00101011b | 10101111b = 10101111b
-00101011b | 10110000b = 10111011b
-00101011b | 10110001b = 10111011b
-00101011b | 10110010b = 10111011b
-00101011b | 10110011b = 10111011b
-00101011b | 10110100b = 10111111b
-00101011b | 10110101b = 10111111b
-00101011b | 10110110b = 10111111b
-00101011b | 10110111b = 10111111b
-00101011b | 10111000b = 10111011b
-00101011b | 10111001b = 10111011b
-00101011b | 10111010b = 10111011b
-00101011b | 10111011b = 10111011b
-00101011b | 10111100b = 10111111b
-00101011b | 10111101b = 10111111b
-00101011b | 10111110b = 10111111b
-00101011b | 10111111b = 10111111b
-00101011b | 11000000b = 11101011b
-00101011b | 11000001b = 11101011b
-00101011b | 11000010b = 11101011b
-00101011b | 11000011b = 11101011b
-00101011b | 11000100b = 11101111b
-00101011b | 11000101b = 11101111b
-00101011b | 11000110b = 11101111b
-00101011b | 11000111b = 11101111b
-00101011b | 11001000b = 11101011b
-00101011b | 11001001b = 11101011b
-00101011b | 11001010b = 11101011b
-00101011b | 11001011b = 11101011b
-00101011b | 11001100b = 11101111b
-00101011b | 11001101b = 11101111b
-00101011b | 11001110b = 11101111b
-00101011b | 11001111b = 11101111b
-00101011b | 11010000b = 11111011b
-00101011b | 11010001b = 11111011b
-00101011b | 11010010b = 11111011b
-00101011b | 11010011b = 11111011b
-00101011b | 11010100b = 11111111b
-00101011b | 11010101b = 11111111b
-00101011b | 11010110b = 11111111b
-00101011b | 11010111b = 11111111b
-00101011b | 11011000b = 11111011b
-00101011b | 11011001b = 11111011b
-00101011b | 11011010b = 11111011b
-00101011b | 11011011b = 11111011b
-00101011b | 11011100b = 11111111b
-00101011b | 11011101b = 11111111b
-00101011b | 11011110b = 11111111b
-00101011b | 11011111b = 11111111b
-00101011b | 11100000b = 11101011b
-00101011b | 11100001b = 11101011b
-00101011b | 11100010b = 11101011b
-00101011b | 11100011b = 11101011b
-00101011b | 11100100b = 11101111b
-00101011b | 11100101b = 11101111b
-00101011b | 11100110b = 11101111b
-00101011b | 11100111b = 11101111b
-00101011b | 11101000b = 11101011b
-00101011b | 11101001b = 11101011b
-00101011b | 11101010b = 11101011b
-00101011b | 11101011b = 11101011b
-00101011b | 11101100b = 11101111b
-00101011b | 11101101b = 11101111b
-00101011b | 11101110b = 11101111b
-00101011b | 11101111b = 11101111b
-00101011b | 11110000b = 11111011b
-00101011b | 11110001b = 11111011b
-00101011b | 11110010b = 11111011b
-00101011b | 11110011b = 11111011b
-00101011b | 11110100b = 11111111b
-00101011b | 11110101b = 11111111b
-00101011b | 11110110b = 11111111b
-00101011b | 11110111b = 11111111b
-00101011b | 11111000b = 11111011b
-00101011b | 11111001b = 11111011b
-00101011b | 11111010b = 11111011b
-00101011b | 11111011b = 11111011b
-00101011b | 11111100b = 11111111b
-00101011b | 11111101b = 11111111b
-00101011b | 11111110b = 11111111b
-00101011b | 11111111b = 11111111b
-00101011b | 00000000b = 00101011b
-00101011b | 00000001b = 00101011b
-00101011b | 00000010b = 00101011b
-00101011b | 00000011b = 00101011b
-00101011b | 00000100b = 00101111b
-00101011b | 00000101b = 00101111b
-00101011b | 00000110b = 00101111b
-00101011b | 00000111b = 00101111b
-00101011b | 00001000b = 00101011b
-00101011b | 00001001b = 00101011b
-00101011b | 00001010b = 00101011b
-00101011b | 00001011b = 00101011b
-00101011b | 00001100b = 00101111b
-00101011b | 00001101b = 00101111b
-00101011b | 00001110b = 00101111b
-00101011b | 00001111b = 00101111b
-00101011b | 00010000b = 00111011b
-00101011b | 00010001b = 00111011b
-00101011b | 00010010b = 00111011b
-00101011b | 00010011b = 00111011b
-00101011b | 00010100b = 00111111b
-00101011b | 00010101b = 00111111b
-00101011b | 00010110b = 00111111b
-00101011b | 00010111b = 00111111b
-00101011b | 00011000b = 00111011b
-00101011b | 00011001b = 00111011b
-00101011b | 00011010b = 00111011b
-00101011b | 00011011b = 00111011b
-00101011b | 00011100b = 00111111b
-00101011b | 00011101b = 00111111b
-00101011b | 00011110b = 00111111b
-00101011b | 00011111b = 00111111b
-00101011b | 00100000b = 00101011b
-00101011b | 00100001b = 00101011b
-00101011b | 00100010b = 00101011b
-00101011b | 00100011b = 00101011b
-00101011b | 00100100b = 00101111b
-00101011b | 00100101b = 00101111b
-00101011b | 00100110b = 00101111b
-00101011b | 00100111b = 00101111b
-00101011b | 00101000b = 00101011b
-00101011b | 00101001b = 00101011b
-00101011b | 00101010b = 00101011b
-00101011b | 00101011b = 00101011b
-00101011b | 00101100b = 00101111b
-00101011b | 00101101b = 00101111b
-00101011b | 00101110b = 00101111b
-00101011b | 00101111b = 00101111b
-00101011b | 00110000b = 00111011b
-00101011b | 00110001b = 00111011b
-00101011b | 00110010b = 00111011b
-00101011b | 00110011b = 00111011b
-00101011b | 00110100b = 00111111b
-00101011b | 00110101b = 00111111b
-00101011b | 00110110b = 00111111b
-00101011b | 00110111b = 00111111b
-00101011b | 00111000b = 00111011b
-00101011b | 00111001b = 00111011b
-00101011b | 00111010b = 00111011b
-00101011b | 00111011b = 00111011b
-00101011b | 00111100b = 00111111b
-00101011b | 00111101b = 00111111b
-00101011b | 00111110b = 00111111b
-00101011b | 00111111b = 00111111b
-00101011b | 01000000b = 01101011b
-00101011b | 01000001b = 01101011b
-00101011b | 01000010b = 01101011b
-00101011b | 01000011b = 01101011b
-00101011b | 01000100b = 01101111b
-00101011b | 01000101b = 01101111b
-00101011b | 01000110b = 01101111b
-00101011b | 01000111b = 01101111b
-00101011b | 01001000b = 01101011b
-00101011b | 01001001b = 01101011b
-00101011b | 01001010b = 01101011b
-00101011b | 01001011b = 01101011b
-00101011b | 01001100b = 01101111b
-00101011b | 01001101b = 01101111b
-00101011b | 01001110b = 01101111b
-00101011b | 01001111b = 01101111b
-00101011b | 01010000b = 01111011b
-00101011b | 01010001b = 01111011b
-00101011b | 01010010b = 01111011b
-00101011b | 01010011b = 01111011b
-00101011b | 01010100b = 01111111b
-00101011b | 01010101b = 01111111b
-00101011b | 01010110b = 01111111b
-00101011b | 01010111b = 01111111b
-00101011b | 01011000b = 01111011b
-00101011b | 01011001b = 01111011b
-00101011b | 01011010b = 01111011b
-00101011b | 01011011b = 01111011b
-00101011b | 01011100b = 01111111b
-00101011b | 01011101b = 01111111b
-00101011b | 01011110b = 01111111b
-00101011b | 01011111b = 01111111b
-00101011b | 01100000b = 01101011b
-00101011b | 01100001b = 01101011b
-00101011b | 01100010b = 01101011b
-00101011b | 01100011b = 01101011b
-00101011b | 01100100b = 01101111b
-00101011b | 01100101b = 01101111b
-00101011b | 01100110b = 01101111b
-00101011b | 01100111b = 01101111b
-00101011b | 01101000b = 01101011b
-00101011b | 01101001b = 01101011b
-00101011b | 01101010b = 01101011b
-00101011b | 01101011b = 01101011b
-00101011b | 01101100b = 01101111b
-00101011b | 01101101b = 01101111b
-00101011b | 01101110b = 01101111b
-00101011b | 01101111b = 01101111b
-00101011b | 01110000b = 01111011b
-00101011b | 01110001b = 01111011b
-00101011b | 01110010b = 01111011b
-00101011b | 01110011b = 01111011b
-00101011b | 01110100b = 01111111b
-00101011b | 01110101b = 01111111b
-00101011b | 01110110b = 01111111b
-00101011b | 01110111b = 01111111b
-00101011b | 01111000b = 01111011b
-00101011b | 01111001b = 01111011b
-00101011b | 01111010b = 01111011b
-00101011b | 01111011b = 01111011b
-00101011b | 01111100b = 01111111b
-00101011b | 01111101b = 01111111b
-00101011b | 01111110b = 01111111b
-00101100b | 10000000b = 10101100b
-00101100b | 10000001b = 10101101b
-00101100b | 10000010b = 10101110b
-00101100b | 10000011b = 10101111b
-00101100b | 10000100b = 10101100b
-00101100b | 10000101b = 10101101b
-00101100b | 10000110b = 10101110b
-00101100b | 10000111b = 10101111b
-00101100b | 10001000b = 10101100b
-00101100b | 10001001b = 10101101b
-00101100b | 10001010b = 10101110b
-00101100b | 10001011b = 10101111b
-00101100b | 10001100b = 10101100b
-00101100b | 10001101b = 10101101b
-00101100b | 10001110b = 10101110b
-00101100b | 10001111b = 10101111b
-00101100b | 10010000b = 10111100b
-00101100b | 10010001b = 10111101b
-00101100b | 10010010b = 10111110b
-00101100b | 10010011b = 10111111b
-00101100b | 10010100b = 10111100b
-00101100b | 10010101b = 10111101b
-00101100b | 10010110b = 10111110b
-00101100b | 10010111b = 10111111b
-00101100b | 10011000b = 10111100b
-00101100b | 10011001b = 10111101b
-00101100b | 10011010b = 10111110b
-00101100b | 10011011b = 10111111b
-00101100b | 10011100b = 10111100b
-00101100b | 10011101b = 10111101b
-00101100b | 10011110b = 10111110b
-00101100b | 10011111b = 10111111b
-00101100b | 10100000b = 10101100b
-00101100b | 10100001b = 10101101b
-00101100b | 10100010b = 10101110b
-00101100b | 10100011b = 10101111b
-00101100b | 10100100b = 10101100b
-00101100b | 10100101b = 10101101b
-00101100b | 10100110b = 10101110b
-00101100b | 10100111b = 10101111b
-00101100b | 10101000b = 10101100b
-00101100b | 10101001b = 10101101b
-00101100b | 10101010b = 10101110b
-00101100b | 10101011b = 10101111b
-00101100b | 10101100b = 10101100b
-00101100b | 10101101b = 10101101b
-00101100b | 10101110b = 10101110b
-00101100b | 10101111b = 10101111b
-00101100b | 10110000b = 10111100b
-00101100b | 10110001b = 10111101b
-00101100b | 10110010b = 10111110b
-00101100b | 10110011b = 10111111b
-00101100b | 10110100b = 10111100b
-00101100b | 10110101b = 10111101b
-00101100b | 10110110b = 10111110b
-00101100b | 10110111b = 10111111b
-00101100b | 10111000b = 10111100b
-00101100b | 10111001b = 10111101b
-00101100b | 10111010b = 10111110b
-00101100b | 10111011b = 10111111b
-00101100b | 10111100b = 10111100b
-00101100b | 10111101b = 10111101b
-00101100b | 10111110b = 10111110b
-00101100b | 10111111b = 10111111b
-00101100b | 11000000b = 11101100b
-00101100b | 11000001b = 11101101b
-00101100b | 11000010b = 11101110b
-00101100b | 11000011b = 11101111b
-00101100b | 11000100b = 11101100b
-00101100b | 11000101b = 11101101b
-00101100b | 11000110b = 11101110b
-00101100b | 11000111b = 11101111b
-00101100b | 11001000b = 11101100b
-00101100b | 11001001b = 11101101b
-00101100b | 11001010b = 11101110b
-00101100b | 11001011b = 11101111b
-00101100b | 11001100b = 11101100b
-00101100b | 11001101b = 11101101b
-00101100b | 11001110b = 11101110b
-00101100b | 11001111b = 11101111b
-00101100b | 11010000b = 11111100b
-00101100b | 11010001b = 11111101b
-00101100b | 11010010b = 11111110b
-00101100b | 11010011b = 11111111b
-00101100b | 11010100b = 11111100b
-00101100b | 11010101b = 11111101b
-00101100b | 11010110b = 11111110b
-00101100b | 11010111b = 11111111b
-00101100b | 11011000b = 11111100b
-00101100b | 11011001b = 11111101b
-00101100b | 11011010b = 11111110b
-00101100b | 11011011b = 11111111b
-00101100b | 11011100b = 11111100b
-00101100b | 11011101b = 11111101b
-00101100b | 11011110b = 11111110b
-00101100b | 11011111b = 11111111b
-00101100b | 11100000b = 11101100b
-00101100b | 11100001b = 11101101b
-00101100b | 11100010b = 11101110b
-00101100b | 11100011b = 11101111b
-00101100b | 11100100b = 11101100b
-00101100b | 11100101b = 11101101b
-00101100b | 11100110b = 11101110b
-00101100b | 11100111b = 11101111b
-00101100b | 11101000b = 11101100b
-00101100b | 11101001b = 11101101b
-00101100b | 11101010b = 11101110b
-00101100b | 11101011b = 11101111b
-00101100b | 11101100b = 11101100b
-00101100b | 11101101b = 11101101b
-00101100b | 11101110b = 11101110b
-00101100b | 11101111b = 11101111b
-00101100b | 11110000b = 11111100b
-00101100b | 11110001b = 11111101b
-00101100b | 11110010b = 11111110b
-00101100b | 11110011b = 11111111b
-00101100b | 11110100b = 11111100b
-00101100b | 11110101b = 11111101b
-00101100b | 11110110b = 11111110b
-00101100b | 11110111b = 11111111b
-00101100b | 11111000b = 11111100b
-00101100b | 11111001b = 11111101b
-00101100b | 11111010b = 11111110b
-00101100b | 11111011b = 11111111b
-00101100b | 11111100b = 11111100b
-00101100b | 11111101b = 11111101b
-00101100b | 11111110b = 11111110b
-00101100b | 11111111b = 11111111b
-00101100b | 00000000b = 00101100b
-00101100b | 00000001b = 00101101b
-00101100b | 00000010b = 00101110b
-00101100b | 00000011b = 00101111b
-00101100b | 00000100b = 00101100b
-00101100b | 00000101b = 00101101b
-00101100b | 00000110b = 00101110b
-00101100b | 00000111b = 00101111b
-00101100b | 00001000b = 00101100b
-00101100b | 00001001b = 00101101b
-00101100b | 00001010b = 00101110b
-00101100b | 00001011b = 00101111b
-00101100b | 00001100b = 00101100b
-00101100b | 00001101b = 00101101b
-00101100b | 00001110b = 00101110b
-00101100b | 00001111b = 00101111b
-00101100b | 00010000b = 00111100b
-00101100b | 00010001b = 00111101b
-00101100b | 00010010b = 00111110b
-00101100b | 00010011b = 00111111b
-00101100b | 00010100b = 00111100b
-00101100b | 00010101b = 00111101b
-00101100b | 00010110b = 00111110b
-00101100b | 00010111b = 00111111b
-00101100b | 00011000b = 00111100b
-00101100b | 00011001b = 00111101b
-00101100b | 00011010b = 00111110b
-00101100b | 00011011b = 00111111b
-00101100b | 00011100b = 00111100b
-00101100b | 00011101b = 00111101b
-00101100b | 00011110b = 00111110b
-00101100b | 00011111b = 00111111b
-00101100b | 00100000b = 00101100b
-00101100b | 00100001b = 00101101b
-00101100b | 00100010b = 00101110b
-00101100b | 00100011b = 00101111b
-00101100b | 00100100b = 00101100b
-00101100b | 00100101b = 00101101b
-00101100b | 00100110b = 00101110b
-00101100b | 00100111b = 00101111b
-00101100b | 00101000b = 00101100b
-00101100b | 00101001b = 00101101b
-00101100b | 00101010b = 00101110b
-00101100b | 00101011b = 00101111b
-00101100b | 00101100b = 00101100b
-00101100b | 00101101b = 00101101b
-00101100b | 00101110b = 00101110b
-00101100b | 00101111b = 00101111b
-00101100b | 00110000b = 00111100b
-00101100b | 00110001b = 00111101b
-00101100b | 00110010b = 00111110b
-00101100b | 00110011b = 00111111b
-00101100b | 00110100b = 00111100b
-00101100b | 00110101b = 00111101b
-00101100b | 00110110b = 00111110b
-00101100b | 00110111b = 00111111b
-00101100b | 00111000b = 00111100b
-00101100b | 00111001b = 00111101b
-00101100b | 00111010b = 00111110b
-00101100b | 00111011b = 00111111b
-00101100b | 00111100b = 00111100b
-00101100b | 00111101b = 00111101b
-00101100b | 00111110b = 00111110b
-00101100b | 00111111b = 00111111b
-00101100b | 01000000b = 01101100b
-00101100b | 01000001b = 01101101b
-00101100b | 01000010b = 01101110b
-00101100b | 01000011b = 01101111b
-00101100b | 01000100b = 01101100b
-00101100b | 01000101b = 01101101b
-00101100b | 01000110b = 01101110b
-00101100b | 01000111b = 01101111b
-00101100b | 01001000b = 01101100b
-00101100b | 01001001b = 01101101b
-00101100b | 01001010b = 01101110b
-00101100b | 01001011b = 01101111b
-00101100b | 01001100b = 01101100b
-00101100b | 01001101b = 01101101b
-00101100b | 01001110b = 01101110b
-00101100b | 01001111b = 01101111b
-00101100b | 01010000b = 01111100b
-00101100b | 01010001b = 01111101b
-00101100b | 01010010b = 01111110b
-00101100b | 01010011b = 01111111b
-00101100b | 01010100b = 01111100b
-00101100b | 01010101b = 01111101b
-00101100b | 01010110b = 01111110b
-00101100b | 01010111b = 01111111b
-00101100b | 01011000b = 01111100b
-00101100b | 01011001b = 01111101b
-00101100b | 01011010b = 01111110b
-00101100b | 01011011b = 01111111b
-00101100b | 01011100b = 01111100b
-00101100b | 01011101b = 01111101b
-00101100b | 01011110b = 01111110b
-00101100b | 01011111b = 01111111b
-00101100b | 01100000b = 01101100b
-00101100b | 01100001b = 01101101b
-00101100b | 01100010b = 01101110b
-00101100b | 01100011b = 01101111b
-00101100b | 01100100b = 01101100b
-00101100b | 01100101b = 01101101b
-00101100b | 01100110b = 01101110b
-00101100b | 01100111b = 01101111b
-00101100b | 01101000b = 01101100b
-00101100b | 01101001b = 01101101b
-00101100b | 01101010b = 01101110b
-00101100b | 01101011b = 01101111b
-00101100b | 01101100b = 01101100b
-00101100b | 01101101b = 01101101b
-00101100b | 01101110b = 01101110b
-00101100b | 01101111b = 01101111b
-00101100b | 01110000b = 01111100b
-00101100b | 01110001b = 01111101b
-00101100b | 01110010b = 01111110b
-00101100b | 01110011b = 01111111b
-00101100b | 01110100b = 01111100b
-00101100b | 01110101b = 01111101b
-00101100b | 01110110b = 01111110b
-00101100b | 01110111b = 01111111b
-00101100b | 01111000b = 01111100b
-00101100b | 01111001b = 01111101b
-00101100b | 01111010b = 01111110b
-00101100b | 01111011b = 01111111b
-00101100b | 01111100b = 01111100b
-00101100b | 01111101b = 01111101b
-00101100b | 01111110b = 01111110b
-00101101b | 10000000b = 10101101b
-00101101b | 10000001b = 10101101b
-00101101b | 10000010b = 10101111b
-00101101b | 10000011b = 10101111b
-00101101b | 10000100b = 10101101b
-00101101b | 10000101b = 10101101b
-00101101b | 10000110b = 10101111b
-00101101b | 10000111b = 10101111b
-00101101b | 10001000b = 10101101b
-00101101b | 10001001b = 10101101b
-00101101b | 10001010b = 10101111b
-00101101b | 10001011b = 10101111b
-00101101b | 10001100b = 10101101b
-00101101b | 10001101b = 10101101b
-00101101b | 10001110b = 10101111b
-00101101b | 10001111b = 10101111b
-00101101b | 10010000b = 10111101b
-00101101b | 10010001b = 10111101b
-00101101b | 10010010b = 10111111b
-00101101b | 10010011b = 10111111b
-00101101b | 10010100b = 10111101b
-00101101b | 10010101b = 10111101b
-00101101b | 10010110b = 10111111b
-00101101b | 10010111b = 10111111b
-00101101b | 10011000b = 10111101b
-00101101b | 10011001b = 10111101b
-00101101b | 10011010b = 10111111b
-00101101b | 10011011b = 10111111b
-00101101b | 10011100b = 10111101b
-00101101b | 10011101b = 10111101b
-00101101b | 10011110b = 10111111b
-00101101b | 10011111b = 10111111b
-00101101b | 10100000b = 10101101b
-00101101b | 10100001b = 10101101b
-00101101b | 10100010b = 10101111b
-00101101b | 10100011b = 10101111b
-00101101b | 10100100b = 10101101b
-00101101b | 10100101b = 10101101b
-00101101b | 10100110b = 10101111b
-00101101b | 10100111b = 10101111b
-00101101b | 10101000b = 10101101b
-00101101b | 10101001b = 10101101b
-00101101b | 10101010b = 10101111b
-00101101b | 10101011b = 10101111b
-00101101b | 10101100b = 10101101b
-00101101b | 10101101b = 10101101b
-00101101b | 10101110b = 10101111b
-00101101b | 10101111b = 10101111b
-00101101b | 10110000b = 10111101b
-00101101b | 10110001b = 10111101b
-00101101b | 10110010b = 10111111b
-00101101b | 10110011b = 10111111b
-00101101b | 10110100b = 10111101b
-00101101b | 10110101b = 10111101b
-00101101b | 10110110b = 10111111b
-00101101b | 10110111b = 10111111b
-00101101b | 10111000b = 10111101b
-00101101b | 10111001b = 10111101b
-00101101b | 10111010b = 10111111b
-00101101b | 10111011b = 10111111b
-00101101b | 10111100b = 10111101b
-00101101b | 10111101b = 10111101b
-00101101b | 10111110b = 10111111b
-00101101b | 10111111b = 10111111b
-00101101b | 11000000b = 11101101b
-00101101b | 11000001b = 11101101b
-00101101b | 11000010b = 11101111b
-00101101b | 11000011b = 11101111b
-00101101b | 11000100b = 11101101b
-00101101b | 11000101b = 11101101b
-00101101b | 11000110b = 11101111b
-00101101b | 11000111b = 11101111b
-00101101b | 11001000b = 11101101b
-00101101b | 11001001b = 11101101b
-00101101b | 11001010b = 11101111b
-00101101b | 11001011b = 11101111b
-00101101b | 11001100b = 11101101b
-00101101b | 11001101b = 11101101b
-00101101b | 11001110b = 11101111b
-00101101b | 11001111b = 11101111b
-00101101b | 11010000b = 11111101b
-00101101b | 11010001b = 11111101b
-00101101b | 11010010b = 11111111b
-00101101b | 11010011b = 11111111b
-00101101b | 11010100b = 11111101b
-00101101b | 11010101b = 11111101b
-00101101b | 11010110b = 11111111b
-00101101b | 11010111b = 11111111b
-00101101b | 11011000b = 11111101b
-00101101b | 11011001b = 11111101b
-00101101b | 11011010b = 11111111b
-00101101b | 11011011b = 11111111b
-00101101b | 11011100b = 11111101b
-00101101b | 11011101b = 11111101b
-00101101b | 11011110b = 11111111b
-00101101b | 11011111b = 11111111b
-00101101b | 11100000b = 11101101b
-00101101b | 11100001b = 11101101b
-00101101b | 11100010b = 11101111b
-00101101b | 11100011b = 11101111b
-00101101b | 11100100b = 11101101b
-00101101b | 11100101b = 11101101b
-00101101b | 11100110b = 11101111b
-00101101b | 11100111b = 11101111b
-00101101b | 11101000b = 11101101b
-00101101b | 11101001b = 11101101b
-00101101b | 11101010b = 11101111b
-00101101b | 11101011b = 11101111b
-00101101b | 11101100b = 11101101b
-00101101b | 11101101b = 11101101b
-00101101b | 11101110b = 11101111b
-00101101b | 11101111b = 11101111b
-00101101b | 11110000b = 11111101b
-00101101b | 11110001b = 11111101b
-00101101b | 11110010b = 11111111b
-00101101b | 11110011b = 11111111b
-00101101b | 11110100b = 11111101b
-00101101b | 11110101b = 11111101b
-00101101b | 11110110b = 11111111b
-00101101b | 11110111b = 11111111b
-00101101b | 11111000b = 11111101b
-00101101b | 11111001b = 11111101b
-00101101b | 11111010b = 11111111b
-00101101b | 11111011b = 11111111b
-00101101b | 11111100b = 11111101b
-00101101b | 11111101b = 11111101b
-00101101b | 11111110b = 11111111b
-00101101b | 11111111b = 11111111b
-00101101b | 00000000b = 00101101b
-00101101b | 00000001b = 00101101b
-00101101b | 00000010b = 00101111b
-00101101b | 00000011b = 00101111b
-00101101b | 00000100b = 00101101b
-00101101b | 00000101b = 00101101b
-00101101b | 00000110b = 00101111b
-00101101b | 00000111b = 00101111b
-00101101b | 00001000b = 00101101b
-00101101b | 00001001b = 00101101b
-00101101b | 00001010b = 00101111b
-00101101b | 00001011b = 00101111b
-00101101b | 00001100b = 00101101b
-00101101b | 00001101b = 00101101b
-00101101b | 00001110b = 00101111b
-00101101b | 00001111b = 00101111b
-00101101b | 00010000b = 00111101b
-00101101b | 00010001b = 00111101b
-00101101b | 00010010b = 00111111b
-00101101b | 00010011b = 00111111b
-00101101b | 00010100b = 00111101b
-00101101b | 00010101b = 00111101b
-00101101b | 00010110b = 00111111b
-00101101b | 00010111b = 00111111b
-00101101b | 00011000b = 00111101b
-00101101b | 00011001b = 00111101b
-00101101b | 00011010b = 00111111b
-00101101b | 00011011b = 00111111b
-00101101b | 00011100b = 00111101b
-00101101b | 00011101b = 00111101b
-00101101b | 00011110b = 00111111b
-00101101b | 00011111b = 00111111b
-00101101b | 00100000b = 00101101b
-00101101b | 00100001b = 00101101b
-00101101b | 00100010b = 00101111b
-00101101b | 00100011b = 00101111b
-00101101b | 00100100b = 00101101b
-00101101b | 00100101b = 00101101b
-00101101b | 00100110b = 00101111b
-00101101b | 00100111b = 00101111b
-00101101b | 00101000b = 00101101b
-00101101b | 00101001b = 00101101b
-00101101b | 00101010b = 00101111b
-00101101b | 00101011b = 00101111b
-00101101b | 00101100b = 00101101b
-00101101b | 00101101b = 00101101b
-00101101b | 00101110b = 00101111b
-00101101b | 00101111b = 00101111b
-00101101b | 00110000b = 00111101b
-00101101b | 00110001b = 00111101b
-00101101b | 00110010b = 00111111b
-00101101b | 00110011b = 00111111b
-00101101b | 00110100b = 00111101b
-00101101b | 00110101b = 00111101b
-00101101b | 00110110b = 00111111b
-00101101b | 00110111b = 00111111b
-00101101b | 00111000b = 00111101b
-00101101b | 00111001b = 00111101b
-00101101b | 00111010b = 00111111b
-00101101b | 00111011b = 00111111b
-00101101b | 00111100b = 00111101b
-00101101b | 00111101b = 00111101b
-00101101b | 00111110b = 00111111b
-00101101b | 00111111b = 00111111b
-00101101b | 01000000b = 01101101b
-00101101b | 01000001b = 01101101b
-00101101b | 01000010b = 01101111b
-00101101b | 01000011b = 01101111b
-00101101b | 01000100b = 01101101b
-00101101b | 01000101b = 01101101b
-00101101b | 01000110b = 01101111b
-00101101b | 01000111b = 01101111b
-00101101b | 01001000b = 01101101b
-00101101b | 01001001b = 01101101b
-00101101b | 01001010b = 01101111b
-00101101b | 01001011b = 01101111b
-00101101b | 01001100b = 01101101b
-00101101b | 01001101b = 01101101b
-00101101b | 01001110b = 01101111b
-00101101b | 01001111b = 01101111b
-00101101b | 01010000b = 01111101b
-00101101b | 01010001b = 01111101b
-00101101b | 01010010b = 01111111b
-00101101b | 01010011b = 01111111b
-00101101b | 01010100b = 01111101b
-00101101b | 01010101b = 01111101b
-00101101b | 01010110b = 01111111b
-00101101b | 01010111b = 01111111b
-00101101b | 01011000b = 01111101b
-00101101b | 01011001b = 01111101b
-00101101b | 01011010b = 01111111b
-00101101b | 01011011b = 01111111b
-00101101b | 01011100b = 01111101b
-00101101b | 01011101b = 01111101b
-00101101b | 01011110b = 01111111b
-00101101b | 01011111b = 01111111b
-00101101b | 01100000b = 01101101b
-00101101b | 01100001b = 01101101b
-00101101b | 01100010b = 01101111b
-00101101b | 01100011b = 01101111b
-00101101b | 01100100b = 01101101b
-00101101b | 01100101b = 01101101b
-00101101b | 01100110b = 01101111b
-00101101b | 01100111b = 01101111b
-00101101b | 01101000b = 01101101b
-00101101b | 01101001b = 01101101b
-00101101b | 01101010b = 01101111b
-00101101b | 01101011b = 01101111b
-00101101b | 01101100b = 01101101b
-00101101b | 01101101b = 01101101b
-00101101b | 01101110b = 01101111b
-00101101b | 01101111b = 01101111b
-00101101b | 01110000b = 01111101b
-00101101b | 01110001b = 01111101b
-00101101b | 01110010b = 01111111b
-00101101b | 01110011b = 01111111b
-00101101b | 01110100b = 01111101b
-00101101b | 01110101b = 01111101b
-00101101b | 01110110b = 01111111b
-00101101b | 01110111b = 01111111b
-00101101b | 01111000b = 01111101b
-00101101b | 01111001b = 01111101b
-00101101b | 01111010b = 01111111b
-00101101b | 01111011b = 01111111b
-00101101b | 01111100b = 01111101b
-00101101b | 01111101b = 01111101b
-00101101b | 01111110b = 01111111b
-00101110b | 10000000b = 10101110b
-00101110b | 10000001b = 10101111b
-00101110b | 10000010b = 10101110b
-00101110b | 10000011b = 10101111b
-00101110b | 10000100b = 10101110b
-00101110b | 10000101b = 10101111b
-00101110b | 10000110b = 10101110b
-00101110b | 10000111b = 10101111b
-00101110b | 10001000b = 10101110b
-00101110b | 10001001b = 10101111b
-00101110b | 10001010b = 10101110b
-00101110b | 10001011b = 10101111b
-00101110b | 10001100b = 10101110b
-00101110b | 10001101b = 10101111b
-00101110b | 10001110b = 10101110b
-00101110b | 10001111b = 10101111b
-00101110b | 10010000b = 10111110b
-00101110b | 10010001b = 10111111b
-00101110b | 10010010b = 10111110b
-00101110b | 10010011b = 10111111b
-00101110b | 10010100b = 10111110b
-00101110b | 10010101b = 10111111b
-00101110b | 10010110b = 10111110b
-00101110b | 10010111b = 10111111b
-00101110b | 10011000b = 10111110b
-00101110b | 10011001b = 10111111b
-00101110b | 10011010b = 10111110b
-00101110b | 10011011b = 10111111b
-00101110b | 10011100b = 10111110b
-00101110b | 10011101b = 10111111b
-00101110b | 10011110b = 10111110b
-00101110b | 10011111b = 10111111b
-00101110b | 10100000b = 10101110b
-00101110b | 10100001b = 10101111b
-00101110b | 10100010b = 10101110b
-00101110b | 10100011b = 10101111b
-00101110b | 10100100b = 10101110b
-00101110b | 10100101b = 10101111b
-00101110b | 10100110b = 10101110b
-00101110b | 10100111b = 10101111b
-00101110b | 10101000b = 10101110b
-00101110b | 10101001b = 10101111b
-00101110b | 10101010b = 10101110b
-00101110b | 10101011b = 10101111b
-00101110b | 10101100b = 10101110b
-00101110b | 10101101b = 10101111b
-00101110b | 10101110b = 10101110b
-00101110b | 10101111b = 10101111b
-00101110b | 10110000b = 10111110b
-00101110b | 10110001b = 10111111b
-00101110b | 10110010b = 10111110b
-00101110b | 10110011b = 10111111b
-00101110b | 10110100b = 10111110b
-00101110b | 10110101b = 10111111b
-00101110b | 10110110b = 10111110b
-00101110b | 10110111b = 10111111b
-00101110b | 10111000b = 10111110b
-00101110b | 10111001b = 10111111b
-00101110b | 10111010b = 10111110b
-00101110b | 10111011b = 10111111b
-00101110b | 10111100b = 10111110b
-00101110b | 10111101b = 10111111b
-00101110b | 10111110b = 10111110b
-00101110b | 10111111b = 10111111b
-00101110b | 11000000b = 11101110b
-00101110b | 11000001b = 11101111b
-00101110b | 11000010b = 11101110b
-00101110b | 11000011b = 11101111b
-00101110b | 11000100b = 11101110b
-00101110b | 11000101b = 11101111b
-00101110b | 11000110b = 11101110b
-00101110b | 11000111b = 11101111b
-00101110b | 11001000b = 11101110b
-00101110b | 11001001b = 11101111b
-00101110b | 11001010b = 11101110b
-00101110b | 11001011b = 11101111b
-00101110b | 11001100b = 11101110b
-00101110b | 11001101b = 11101111b
-00101110b | 11001110b = 11101110b
-00101110b | 11001111b = 11101111b
-00101110b | 11010000b = 11111110b
-00101110b | 11010001b = 11111111b
-00101110b | 11010010b = 11111110b
-00101110b | 11010011b = 11111111b
-00101110b | 11010100b = 11111110b
-00101110b | 11010101b = 11111111b
-00101110b | 11010110b = 11111110b
-00101110b | 11010111b = 11111111b
-00101110b | 11011000b = 11111110b
-00101110b | 11011001b = 11111111b
-00101110b | 11011010b = 11111110b
-00101110b | 11011011b = 11111111b
-00101110b | 11011100b = 11111110b
-00101110b | 11011101b = 11111111b
-00101110b | 11011110b = 11111110b
-00101110b | 11011111b = 11111111b
-00101110b | 11100000b = 11101110b
-00101110b | 11100001b = 11101111b
-00101110b | 11100010b = 11101110b
-00101110b | 11100011b = 11101111b
-00101110b | 11100100b = 11101110b
-00101110b | 11100101b = 11101111b
-00101110b | 11100110b = 11101110b
-00101110b | 11100111b = 11101111b
-00101110b | 11101000b = 11101110b
-00101110b | 11101001b = 11101111b
-00101110b | 11101010b = 11101110b
-00101110b | 11101011b = 11101111b
-00101110b | 11101100b = 11101110b
-00101110b | 11101101b = 11101111b
-00101110b | 11101110b = 11101110b
-00101110b | 11101111b = 11101111b
-00101110b | 11110000b = 11111110b
-00101110b | 11110001b = 11111111b
-00101110b | 11110010b = 11111110b
-00101110b | 11110011b = 11111111b
-00101110b | 11110100b = 11111110b
-00101110b | 11110101b = 11111111b
-00101110b | 11110110b = 11111110b
-00101110b | 11110111b = 11111111b
-00101110b | 11111000b = 11111110b
-00101110b | 11111001b = 11111111b
-00101110b | 11111010b = 11111110b
-00101110b | 11111011b = 11111111b
-00101110b | 11111100b = 11111110b
-00101110b | 11111101b = 11111111b
-00101110b | 11111110b = 11111110b
-00101110b | 11111111b = 11111111b
-00101110b | 00000000b = 00101110b
-00101110b | 00000001b = 00101111b
-00101110b | 00000010b = 00101110b
-00101110b | 00000011b = 00101111b
-00101110b | 00000100b = 00101110b
-00101110b | 00000101b = 00101111b
-00101110b | 00000110b = 00101110b
-00101110b | 00000111b = 00101111b
-00101110b | 00001000b = 00101110b
-00101110b | 00001001b = 00101111b
-00101110b | 00001010b = 00101110b
-00101110b | 00001011b = 00101111b
-00101110b | 00001100b = 00101110b
-00101110b | 00001101b = 00101111b
-00101110b | 00001110b = 00101110b
-00101110b | 00001111b = 00101111b
-00101110b | 00010000b = 00111110b
-00101110b | 00010001b = 00111111b
-00101110b | 00010010b = 00111110b
-00101110b | 00010011b = 00111111b
-00101110b | 00010100b = 00111110b
-00101110b | 00010101b = 00111111b
-00101110b | 00010110b = 00111110b
-00101110b | 00010111b = 00111111b
-00101110b | 00011000b = 00111110b
-00101110b | 00011001b = 00111111b
-00101110b | 00011010b = 00111110b
-00101110b | 00011011b = 00111111b
-00101110b | 00011100b = 00111110b
-00101110b | 00011101b = 00111111b
-00101110b | 00011110b = 00111110b
-00101110b | 00011111b = 00111111b
-00101110b | 00100000b = 00101110b
-00101110b | 00100001b = 00101111b
-00101110b | 00100010b = 00101110b
-00101110b | 00100011b = 00101111b
-00101110b | 00100100b = 00101110b
-00101110b | 00100101b = 00101111b
-00101110b | 00100110b = 00101110b
-00101110b | 00100111b = 00101111b
-00101110b | 00101000b = 00101110b
-00101110b | 00101001b = 00101111b
-00101110b | 00101010b = 00101110b
-00101110b | 00101011b = 00101111b
-00101110b | 00101100b = 00101110b
-00101110b | 00101101b = 00101111b
-00101110b | 00101110b = 00101110b
-00101110b | 00101111b = 00101111b
-00101110b | 00110000b = 00111110b
-00101110b | 00110001b = 00111111b
-00101110b | 00110010b = 00111110b
-00101110b | 00110011b = 00111111b
-00101110b | 00110100b = 00111110b
-00101110b | 00110101b = 00111111b
-00101110b | 00110110b = 00111110b
-00101110b | 00110111b = 00111111b
-00101110b | 00111000b = 00111110b
-00101110b | 00111001b = 00111111b
-00101110b | 00111010b = 00111110b
-00101110b | 00111011b = 00111111b
-00101110b | 00111100b = 00111110b
-00101110b | 00111101b = 00111111b
-00101110b | 00111110b = 00111110b
-00101110b | 00111111b = 00111111b
-00101110b | 01000000b = 01101110b
-00101110b | 01000001b = 01101111b
-00101110b | 01000010b = 01101110b
-00101110b | 01000011b = 01101111b
-00101110b | 01000100b = 01101110b
-00101110b | 01000101b = 01101111b
-00101110b | 01000110b = 01101110b
-00101110b | 01000111b = 01101111b
-00101110b | 01001000b = 01101110b
-00101110b | 01001001b = 01101111b
-00101110b | 01001010b = 01101110b
-00101110b | 01001011b = 01101111b
-00101110b | 01001100b = 01101110b
-00101110b | 01001101b = 01101111b
-00101110b | 01001110b = 01101110b
-00101110b | 01001111b = 01101111b
-00101110b | 01010000b = 01111110b
-00101110b | 01010001b = 01111111b
-00101110b | 01010010b = 01111110b
-00101110b | 01010011b = 01111111b
-00101110b | 01010100b = 01111110b
-00101110b | 01010101b = 01111111b
-00101110b | 01010110b = 01111110b
-00101110b | 01010111b = 01111111b
-00101110b | 01011000b = 01111110b
-00101110b | 01011001b = 01111111b
-00101110b | 01011010b = 01111110b
-00101110b | 01011011b = 01111111b
-00101110b | 01011100b = 01111110b
-00101110b | 01011101b = 01111111b
-00101110b | 01011110b = 01111110b
-00101110b | 01011111b = 01111111b
-00101110b | 01100000b = 01101110b
-00101110b | 01100001b = 01101111b
-00101110b | 01100010b = 01101110b
-00101110b | 01100011b = 01101111b
-00101110b | 01100100b = 01101110b
-00101110b | 01100101b = 01101111b
-00101110b | 01100110b = 01101110b
-00101110b | 01100111b = 01101111b
-00101110b | 01101000b = 01101110b
-00101110b | 01101001b = 01101111b
-00101110b | 01101010b = 01101110b
-00101110b | 01101011b = 01101111b
-00101110b | 01101100b = 01101110b
-00101110b | 01101101b = 01101111b
-00101110b | 01101110b = 01101110b
-00101110b | 01101111b = 01101111b
-00101110b | 01110000b = 01111110b
-00101110b | 01110001b = 01111111b
-00101110b | 01110010b = 01111110b
-00101110b | 01110011b = 01111111b
-00101110b | 01110100b = 01111110b
-00101110b | 01110101b = 01111111b
-00101110b | 01110110b = 01111110b
-00101110b | 01110111b = 01111111b
-00101110b | 01111000b = 01111110b
-00101110b | 01111001b = 01111111b
-00101110b | 01111010b = 01111110b
-00101110b | 01111011b = 01111111b
-00101110b | 01111100b = 01111110b
-00101110b | 01111101b = 01111111b
-00101110b | 01111110b = 01111110b
-00101111b | 10000000b = 10101111b
-00101111b | 10000001b = 10101111b
-00101111b | 10000010b = 10101111b
-00101111b | 10000011b = 10101111b
-00101111b | 10000100b = 10101111b
-00101111b | 10000101b = 10101111b
-00101111b | 10000110b = 10101111b
-00101111b | 10000111b = 10101111b
-00101111b | 10001000b = 10101111b
-00101111b | 10001001b = 10101111b
-00101111b | 10001010b = 10101111b
-00101111b | 10001011b = 10101111b
-00101111b | 10001100b = 10101111b
-00101111b | 10001101b = 10101111b
-00101111b | 10001110b = 10101111b
-00101111b | 10001111b = 10101111b
-00101111b | 10010000b = 10111111b
-00101111b | 10010001b = 10111111b
-00101111b | 10010010b = 10111111b
-00101111b | 10010011b = 10111111b
-00101111b | 10010100b = 10111111b
-00101111b | 10010101b = 10111111b
-00101111b | 10010110b = 10111111b
-00101111b | 10010111b = 10111111b
-00101111b | 10011000b = 10111111b
-00101111b | 10011001b = 10111111b
-00101111b | 10011010b = 10111111b
-00101111b | 10011011b = 10111111b
-00101111b | 10011100b = 10111111b
-00101111b | 10011101b = 10111111b
-00101111b | 10011110b = 10111111b
-00101111b | 10011111b = 10111111b
-00101111b | 10100000b = 10101111b
-00101111b | 10100001b = 10101111b
-00101111b | 10100010b = 10101111b
-00101111b | 10100011b = 10101111b
-00101111b | 10100100b = 10101111b
-00101111b | 10100101b = 10101111b
-00101111b | 10100110b = 10101111b
-00101111b | 10100111b = 10101111b
-00101111b | 10101000b = 10101111b
-00101111b | 10101001b = 10101111b
-00101111b | 10101010b = 10101111b
-00101111b | 10101011b = 10101111b
-00101111b | 10101100b = 10101111b
-00101111b | 10101101b = 10101111b
-00101111b | 10101110b = 10101111b
-00101111b | 10101111b = 10101111b
-00101111b | 10110000b = 10111111b
-00101111b | 10110001b = 10111111b
-00101111b | 10110010b = 10111111b
-00101111b | 10110011b = 10111111b
-00101111b | 10110100b = 10111111b
-00101111b | 10110101b = 10111111b
-00101111b | 10110110b = 10111111b
-00101111b | 10110111b = 10111111b
-00101111b | 10111000b = 10111111b
-00101111b | 10111001b = 10111111b
-00101111b | 10111010b = 10111111b
-00101111b | 10111011b = 10111111b
-00101111b | 10111100b = 10111111b
-00101111b | 10111101b = 10111111b
-00101111b | 10111110b = 10111111b
-00101111b | 10111111b = 10111111b
-00101111b | 11000000b = 11101111b
-00101111b | 11000001b = 11101111b
-00101111b | 11000010b = 11101111b
-00101111b | 11000011b = 11101111b
-00101111b | 11000100b = 11101111b
-00101111b | 11000101b = 11101111b
-00101111b | 11000110b = 11101111b
-00101111b | 11000111b = 11101111b
-00101111b | 11001000b = 11101111b
-00101111b | 11001001b = 11101111b
-00101111b | 11001010b = 11101111b
-00101111b | 11001011b = 11101111b
-00101111b | 11001100b = 11101111b
-00101111b | 11001101b = 11101111b
-00101111b | 11001110b = 11101111b
-00101111b | 11001111b = 11101111b
-00101111b | 11010000b = 11111111b
-00101111b | 11010001b = 11111111b
-00101111b | 11010010b = 11111111b
-00101111b | 11010011b = 11111111b
-00101111b | 11010100b = 11111111b
-00101111b | 11010101b = 11111111b
-00101111b | 11010110b = 11111111b
-00101111b | 11010111b = 11111111b
-00101111b | 11011000b = 11111111b
-00101111b | 11011001b = 11111111b
-00101111b | 11011010b = 11111111b
-00101111b | 11011011b = 11111111b
-00101111b | 11011100b = 11111111b
-00101111b | 11011101b = 11111111b
-00101111b | 11011110b = 11111111b
-00101111b | 11011111b = 11111111b
-00101111b | 11100000b = 11101111b
-00101111b | 11100001b = 11101111b
-00101111b | 11100010b = 11101111b
-00101111b | 11100011b = 11101111b
-00101111b | 11100100b = 11101111b
-00101111b | 11100101b = 11101111b
-00101111b | 11100110b = 11101111b
-00101111b | 11100111b = 11101111b
-00101111b | 11101000b = 11101111b
-00101111b | 11101001b = 11101111b
-00101111b | 11101010b = 11101111b
-00101111b | 11101011b = 11101111b
-00101111b | 11101100b = 11101111b
-00101111b | 11101101b = 11101111b
-00101111b | 11101110b = 11101111b
-00101111b | 11101111b = 11101111b
-00101111b | 11110000b = 11111111b
-00101111b | 11110001b = 11111111b
-00101111b | 11110010b = 11111111b
-00101111b | 11110011b = 11111111b
-00101111b | 11110100b = 11111111b
-00101111b | 11110101b = 11111111b
-00101111b | 11110110b = 11111111b
-00101111b | 11110111b = 11111111b
-00101111b | 11111000b = 11111111b
-00101111b | 11111001b = 11111111b
-00101111b | 11111010b = 11111111b
-00101111b | 11111011b = 11111111b
-00101111b | 11111100b = 11111111b
-00101111b | 11111101b = 11111111b
-00101111b | 11111110b = 11111111b
-00101111b | 11111111b = 11111111b
-00101111b | 00000000b = 00101111b
-00101111b | 00000001b = 00101111b
-00101111b | 00000010b = 00101111b
-00101111b | 00000011b = 00101111b
-00101111b | 00000100b = 00101111b
-00101111b | 00000101b = 00101111b
-00101111b | 00000110b = 00101111b
-00101111b | 00000111b = 00101111b
-00101111b | 00001000b = 00101111b
-00101111b | 00001001b = 00101111b
-00101111b | 00001010b = 00101111b
-00101111b | 00001011b = 00101111b
-00101111b | 00001100b = 00101111b
-00101111b | 00001101b = 00101111b
-00101111b | 00001110b = 00101111b
-00101111b | 00001111b = 00101111b
-00101111b | 00010000b = 00111111b
-00101111b | 00010001b = 00111111b
-00101111b | 00010010b = 00111111b
-00101111b | 00010011b = 00111111b
-00101111b | 00010100b = 00111111b
-00101111b | 00010101b = 00111111b
-00101111b | 00010110b = 00111111b
-00101111b | 00010111b = 00111111b
-00101111b | 00011000b = 00111111b
-00101111b | 00011001b = 00111111b
-00101111b | 00011010b = 00111111b
-00101111b | 00011011b = 00111111b
-00101111b | 00011100b = 00111111b
-00101111b | 00011101b = 00111111b
-00101111b | 00011110b = 00111111b
-00101111b | 00011111b = 00111111b
-00101111b | 00100000b = 00101111b
-00101111b | 00100001b = 00101111b
-00101111b | 00100010b = 00101111b
-00101111b | 00100011b = 00101111b
-00101111b | 00100100b = 00101111b
-00101111b | 00100101b = 00101111b
-00101111b | 00100110b = 00101111b
-00101111b | 00100111b = 00101111b
-00101111b | 00101000b = 00101111b
-00101111b | 00101001b = 00101111b
-00101111b | 00101010b = 00101111b
-00101111b | 00101011b = 00101111b
-00101111b | 00101100b = 00101111b
-00101111b | 00101101b = 00101111b
-00101111b | 00101110b = 00101111b
-00101111b | 00101111b = 00101111b
-00101111b | 00110000b = 00111111b
-00101111b | 00110001b = 00111111b
-00101111b | 00110010b = 00111111b
-00101111b | 00110011b = 00111111b
-00101111b | 00110100b = 00111111b
-00101111b | 00110101b = 00111111b
-00101111b | 00110110b = 00111111b
-00101111b | 00110111b = 00111111b
-00101111b | 00111000b = 00111111b
-00101111b | 00111001b = 00111111b
-00101111b | 00111010b = 00111111b
-00101111b | 00111011b = 00111111b
-00101111b | 00111100b = 00111111b
-00101111b | 00111101b = 00111111b
-00101111b | 00111110b = 00111111b
-00101111b | 00111111b = 00111111b
-00101111b | 01000000b = 01101111b
-00101111b | 01000001b = 01101111b
-00101111b | 01000010b = 01101111b
-00101111b | 01000011b = 01101111b
-00101111b | 01000100b = 01101111b
-00101111b | 01000101b = 01101111b
-00101111b | 01000110b = 01101111b
-00101111b | 01000111b = 01101111b
-00101111b | 01001000b = 01101111b
-00101111b | 01001001b = 01101111b
-00101111b | 01001010b = 01101111b
-00101111b | 01001011b = 01101111b
-00101111b | 01001100b = 01101111b
-00101111b | 01001101b = 01101111b
-00101111b | 01001110b = 01101111b
-00101111b | 01001111b = 01101111b
-00101111b | 01010000b = 01111111b
-00101111b | 01010001b = 01111111b
-00101111b | 01010010b = 01111111b
-00101111b | 01010011b = 01111111b
-00101111b | 01010100b = 01111111b
-00101111b | 01010101b = 01111111b
-00101111b | 01010110b = 01111111b
-00101111b | 01010111b = 01111111b
-00101111b | 01011000b = 01111111b
-00101111b | 01011001b = 01111111b
-00101111b | 01011010b = 01111111b
-00101111b | 01011011b = 01111111b
-00101111b | 01011100b = 01111111b
-00101111b | 01011101b = 01111111b
-00101111b | 01011110b = 01111111b
-00101111b | 01011111b = 01111111b
-00101111b | 01100000b = 01101111b
-00101111b | 01100001b = 01101111b
-00101111b | 01100010b = 01101111b
-00101111b | 01100011b = 01101111b
-00101111b | 01100100b = 01101111b
-00101111b | 01100101b = 01101111b
-00101111b | 01100110b = 01101111b
-00101111b | 01100111b = 01101111b
-00101111b | 01101000b = 01101111b
-00101111b | 01101001b = 01101111b
-00101111b | 01101010b = 01101111b
-00101111b | 01101011b = 01101111b
-00101111b | 01101100b = 01101111b
-00101111b | 01101101b = 01101111b
-00101111b | 01101110b = 01101111b
-00101111b | 01101111b = 01101111b
-00101111b | 01110000b = 01111111b
-00101111b | 01110001b = 01111111b
-00101111b | 01110010b = 01111111b
-00101111b | 01110011b = 01111111b
-00101111b | 01110100b = 01111111b
-00101111b | 01110101b = 01111111b
-00101111b | 01110110b = 01111111b
-00101111b | 01110111b = 01111111b
-00101111b | 01111000b = 01111111b
-00101111b | 01111001b = 01111111b
-00101111b | 01111010b = 01111111b
-00101111b | 01111011b = 01111111b
-00101111b | 01111100b = 01111111b
-00101111b | 01111101b = 01111111b
-00101111b | 01111110b = 01111111b
-00110000b | 10000000b = 10110000b
-00110000b | 10000001b = 10110001b
-00110000b | 10000010b = 10110010b
-00110000b | 10000011b = 10110011b
-00110000b | 10000100b = 10110100b
-00110000b | 10000101b = 10110101b
-00110000b | 10000110b = 10110110b
-00110000b | 10000111b = 10110111b
-00110000b | 10001000b = 10111000b
-00110000b | 10001001b = 10111001b
-00110000b | 10001010b = 10111010b
-00110000b | 10001011b = 10111011b
-00110000b | 10001100b = 10111100b
-00110000b | 10001101b = 10111101b
-00110000b | 10001110b = 10111110b
-00110000b | 10001111b = 10111111b
-00110000b | 10010000b = 10110000b
-00110000b | 10010001b = 10110001b
-00110000b | 10010010b = 10110010b
-00110000b | 10010011b = 10110011b
-00110000b | 10010100b = 10110100b
-00110000b | 10010101b = 10110101b
-00110000b | 10010110b = 10110110b
-00110000b | 10010111b = 10110111b
-00110000b | 10011000b = 10111000b
-00110000b | 10011001b = 10111001b
-00110000b | 10011010b = 10111010b
-00110000b | 10011011b = 10111011b
-00110000b | 10011100b = 10111100b
-00110000b | 10011101b = 10111101b
-00110000b | 10011110b = 10111110b
-00110000b | 10011111b = 10111111b
-00110000b | 10100000b = 10110000b
-00110000b | 10100001b = 10110001b
-00110000b | 10100010b = 10110010b
-00110000b | 10100011b = 10110011b
-00110000b | 10100100b = 10110100b
-00110000b | 10100101b = 10110101b
-00110000b | 10100110b = 10110110b
-00110000b | 10100111b = 10110111b
-00110000b | 10101000b = 10111000b
-00110000b | 10101001b = 10111001b
-00110000b | 10101010b = 10111010b
-00110000b | 10101011b = 10111011b
-00110000b | 10101100b = 10111100b
-00110000b | 10101101b = 10111101b
-00110000b | 10101110b = 10111110b
-00110000b | 10101111b = 10111111b
-00110000b | 10110000b = 10110000b
-00110000b | 10110001b = 10110001b
-00110000b | 10110010b = 10110010b
-00110000b | 10110011b = 10110011b
-00110000b | 10110100b = 10110100b
-00110000b | 10110101b = 10110101b
-00110000b | 10110110b = 10110110b
-00110000b | 10110111b = 10110111b
-00110000b | 10111000b = 10111000b
-00110000b | 10111001b = 10111001b
-00110000b | 10111010b = 10111010b
-00110000b | 10111011b = 10111011b
-00110000b | 10111100b = 10111100b
-00110000b | 10111101b = 10111101b
-00110000b | 10111110b = 10111110b
-00110000b | 10111111b = 10111111b
-00110000b | 11000000b = 11110000b
-00110000b | 11000001b = 11110001b
-00110000b | 11000010b = 11110010b
-00110000b | 11000011b = 11110011b
-00110000b | 11000100b = 11110100b
-00110000b | 11000101b = 11110101b
-00110000b | 11000110b = 11110110b
-00110000b | 11000111b = 11110111b
-00110000b | 11001000b = 11111000b
-00110000b | 11001001b = 11111001b
-00110000b | 11001010b = 11111010b
-00110000b | 11001011b = 11111011b
-00110000b | 11001100b = 11111100b
-00110000b | 11001101b = 11111101b
-00110000b | 11001110b = 11111110b
-00110000b | 11001111b = 11111111b
-00110000b | 11010000b = 11110000b
-00110000b | 11010001b = 11110001b
-00110000b | 11010010b = 11110010b
-00110000b | 11010011b = 11110011b
-00110000b | 11010100b = 11110100b
-00110000b | 11010101b = 11110101b
-00110000b | 11010110b = 11110110b
-00110000b | 11010111b = 11110111b
-00110000b | 11011000b = 11111000b
-00110000b | 11011001b = 11111001b
-00110000b | 11011010b = 11111010b
-00110000b | 11011011b = 11111011b
-00110000b | 11011100b = 11111100b
-00110000b | 11011101b = 11111101b
-00110000b | 11011110b = 11111110b
-00110000b | 11011111b = 11111111b
-00110000b | 11100000b = 11110000b
-00110000b | 11100001b = 11110001b
-00110000b | 11100010b = 11110010b
-00110000b | 11100011b = 11110011b
-00110000b | 11100100b = 11110100b
-00110000b | 11100101b = 11110101b
-00110000b | 11100110b = 11110110b
-00110000b | 11100111b = 11110111b
-00110000b | 11101000b = 11111000b
-00110000b | 11101001b = 11111001b
-00110000b | 11101010b = 11111010b
-00110000b | 11101011b = 11111011b
-00110000b | 11101100b = 11111100b
-00110000b | 11101101b = 11111101b
-00110000b | 11101110b = 11111110b
-00110000b | 11101111b = 11111111b
-00110000b | 11110000b = 11110000b
-00110000b | 11110001b = 11110001b
-00110000b | 11110010b = 11110010b
-00110000b | 11110011b = 11110011b
-00110000b | 11110100b = 11110100b
-00110000b | 11110101b = 11110101b
-00110000b | 11110110b = 11110110b
-00110000b | 11110111b = 11110111b
-00110000b | 11111000b = 11111000b
-00110000b | 11111001b = 11111001b
-00110000b | 11111010b = 11111010b
-00110000b | 11111011b = 11111011b
-00110000b | 11111100b = 11111100b
-00110000b | 11111101b = 11111101b
-00110000b | 11111110b = 11111110b
-00110000b | 11111111b = 11111111b
-00110000b | 00000000b = 00110000b
-00110000b | 00000001b = 00110001b
-00110000b | 00000010b = 00110010b
-00110000b | 00000011b = 00110011b
-00110000b | 00000100b = 00110100b
-00110000b | 00000101b = 00110101b
-00110000b | 00000110b = 00110110b
-00110000b | 00000111b = 00110111b
-00110000b | 00001000b = 00111000b
-00110000b | 00001001b = 00111001b
-00110000b | 00001010b = 00111010b
-00110000b | 00001011b = 00111011b
-00110000b | 00001100b = 00111100b
-00110000b | 00001101b = 00111101b
-00110000b | 00001110b = 00111110b
-00110000b | 00001111b = 00111111b
-00110000b | 00010000b = 00110000b
-00110000b | 00010001b = 00110001b
-00110000b | 00010010b = 00110010b
-00110000b | 00010011b = 00110011b
-00110000b | 00010100b = 00110100b
-00110000b | 00010101b = 00110101b
-00110000b | 00010110b = 00110110b
-00110000b | 00010111b = 00110111b
-00110000b | 00011000b = 00111000b
-00110000b | 00011001b = 00111001b
-00110000b | 00011010b = 00111010b
-00110000b | 00011011b = 00111011b
-00110000b | 00011100b = 00111100b
-00110000b | 00011101b = 00111101b
-00110000b | 00011110b = 00111110b
-00110000b | 00011111b = 00111111b
-00110000b | 00100000b = 00110000b
-00110000b | 00100001b = 00110001b
-00110000b | 00100010b = 00110010b
-00110000b | 00100011b = 00110011b
-00110000b | 00100100b = 00110100b
-00110000b | 00100101b = 00110101b
-00110000b | 00100110b = 00110110b
-00110000b | 00100111b = 00110111b
-00110000b | 00101000b = 00111000b
-00110000b | 00101001b = 00111001b
-00110000b | 00101010b = 00111010b
-00110000b | 00101011b = 00111011b
-00110000b | 00101100b = 00111100b
-00110000b | 00101101b = 00111101b
-00110000b | 00101110b = 00111110b
-00110000b | 00101111b = 00111111b
-00110000b | 00110000b = 00110000b
-00110000b | 00110001b = 00110001b
-00110000b | 00110010b = 00110010b
-00110000b | 00110011b = 00110011b
-00110000b | 00110100b = 00110100b
-00110000b | 00110101b = 00110101b
-00110000b | 00110110b = 00110110b
-00110000b | 00110111b = 00110111b
-00110000b | 00111000b = 00111000b
-00110000b | 00111001b = 00111001b
-00110000b | 00111010b = 00111010b
-00110000b | 00111011b = 00111011b
-00110000b | 00111100b = 00111100b
-00110000b | 00111101b = 00111101b
-00110000b | 00111110b = 00111110b
-00110000b | 00111111b = 00111111b
-00110000b | 01000000b = 01110000b
-00110000b | 01000001b = 01110001b
-00110000b | 01000010b = 01110010b
-00110000b | 01000011b = 01110011b
-00110000b | 01000100b = 01110100b
-00110000b | 01000101b = 01110101b
-00110000b | 01000110b = 01110110b
-00110000b | 01000111b = 01110111b
-00110000b | 01001000b = 01111000b
-00110000b | 01001001b = 01111001b
-00110000b | 01001010b = 01111010b
-00110000b | 01001011b = 01111011b
-00110000b | 01001100b = 01111100b
-00110000b | 01001101b = 01111101b
-00110000b | 01001110b = 01111110b
-00110000b | 01001111b = 01111111b
-00110000b | 01010000b = 01110000b
-00110000b | 01010001b = 01110001b
-00110000b | 01010010b = 01110010b
-00110000b | 01010011b = 01110011b
-00110000b | 01010100b = 01110100b
-00110000b | 01010101b = 01110101b
-00110000b | 01010110b = 01110110b
-00110000b | 01010111b = 01110111b
-00110000b | 01011000b = 01111000b
-00110000b | 01011001b = 01111001b
-00110000b | 01011010b = 01111010b
-00110000b | 01011011b = 01111011b
-00110000b | 01011100b = 01111100b
-00110000b | 01011101b = 01111101b
-00110000b | 01011110b = 01111110b
-00110000b | 01011111b = 01111111b
-00110000b | 01100000b = 01110000b
-00110000b | 01100001b = 01110001b
-00110000b | 01100010b = 01110010b
-00110000b | 01100011b = 01110011b
-00110000b | 01100100b = 01110100b
-00110000b | 01100101b = 01110101b
-00110000b | 01100110b = 01110110b
-00110000b | 01100111b = 01110111b
-00110000b | 01101000b = 01111000b
-00110000b | 01101001b = 01111001b
-00110000b | 01101010b = 01111010b
-00110000b | 01101011b = 01111011b
-00110000b | 01101100b = 01111100b
-00110000b | 01101101b = 01111101b
-00110000b | 01101110b = 01111110b
-00110000b | 01101111b = 01111111b
-00110000b | 01110000b = 01110000b
-00110000b | 01110001b = 01110001b
-00110000b | 01110010b = 01110010b
-00110000b | 01110011b = 01110011b
-00110000b | 01110100b = 01110100b
-00110000b | 01110101b = 01110101b
-00110000b | 01110110b = 01110110b
-00110000b | 01110111b = 01110111b
-00110000b | 01111000b = 01111000b
-00110000b | 01111001b = 01111001b
-00110000b | 01111010b = 01111010b
-00110000b | 01111011b = 01111011b
-00110000b | 01111100b = 01111100b
-00110000b | 01111101b = 01111101b
-00110000b | 01111110b = 01111110b
-00110001b | 10000000b = 10110001b
-00110001b | 10000001b = 10110001b
-00110001b | 10000010b = 10110011b
-00110001b | 10000011b = 10110011b
-00110001b | 10000100b = 10110101b
-00110001b | 10000101b = 10110101b
-00110001b | 10000110b = 10110111b
-00110001b | 10000111b = 10110111b
-00110001b | 10001000b = 10111001b
-00110001b | 10001001b = 10111001b
-00110001b | 10001010b = 10111011b
-00110001b | 10001011b = 10111011b
-00110001b | 10001100b = 10111101b
-00110001b | 10001101b = 10111101b
-00110001b | 10001110b = 10111111b
-00110001b | 10001111b = 10111111b
-00110001b | 10010000b = 10110001b
-00110001b | 10010001b = 10110001b
-00110001b | 10010010b = 10110011b
-00110001b | 10010011b = 10110011b
-00110001b | 10010100b = 10110101b
-00110001b | 10010101b = 10110101b
-00110001b | 10010110b = 10110111b
-00110001b | 10010111b = 10110111b
-00110001b | 10011000b = 10111001b
-00110001b | 10011001b = 10111001b
-00110001b | 10011010b = 10111011b
-00110001b | 10011011b = 10111011b
-00110001b | 10011100b = 10111101b
-00110001b | 10011101b = 10111101b
-00110001b | 10011110b = 10111111b
-00110001b | 10011111b = 10111111b
-00110001b | 10100000b = 10110001b
-00110001b | 10100001b = 10110001b
-00110001b | 10100010b = 10110011b
-00110001b | 10100011b = 10110011b
-00110001b | 10100100b = 10110101b
-00110001b | 10100101b = 10110101b
-00110001b | 10100110b = 10110111b
-00110001b | 10100111b = 10110111b
-00110001b | 10101000b = 10111001b
-00110001b | 10101001b = 10111001b
-00110001b | 10101010b = 10111011b
-00110001b | 10101011b = 10111011b
-00110001b | 10101100b = 10111101b
-00110001b | 10101101b = 10111101b
-00110001b | 10101110b = 10111111b
-00110001b | 10101111b = 10111111b
-00110001b | 10110000b = 10110001b
-00110001b | 10110001b = 10110001b
-00110001b | 10110010b = 10110011b
-00110001b | 10110011b = 10110011b
-00110001b | 10110100b = 10110101b
-00110001b | 10110101b = 10110101b
-00110001b | 10110110b = 10110111b
-00110001b | 10110111b = 10110111b
-00110001b | 10111000b = 10111001b
-00110001b | 10111001b = 10111001b
-00110001b | 10111010b = 10111011b
-00110001b | 10111011b = 10111011b
-00110001b | 10111100b = 10111101b
-00110001b | 10111101b = 10111101b
-00110001b | 10111110b = 10111111b
-00110001b | 10111111b = 10111111b
-00110001b | 11000000b = 11110001b
-00110001b | 11000001b = 11110001b
-00110001b | 11000010b = 11110011b
-00110001b | 11000011b = 11110011b
-00110001b | 11000100b = 11110101b
-00110001b | 11000101b = 11110101b
-00110001b | 11000110b = 11110111b
-00110001b | 11000111b = 11110111b
-00110001b | 11001000b = 11111001b
-00110001b | 11001001b = 11111001b
-00110001b | 11001010b = 11111011b
-00110001b | 11001011b = 11111011b
-00110001b | 11001100b = 11111101b
-00110001b | 11001101b = 11111101b
-00110001b | 11001110b = 11111111b
-00110001b | 11001111b = 11111111b
-00110001b | 11010000b = 11110001b
-00110001b | 11010001b = 11110001b
-00110001b | 11010010b = 11110011b
-00110001b | 11010011b = 11110011b
-00110001b | 11010100b = 11110101b
-00110001b | 11010101b = 11110101b
-00110001b | 11010110b = 11110111b
-00110001b | 11010111b = 11110111b
-00110001b | 11011000b = 11111001b
-00110001b | 11011001b = 11111001b
-00110001b | 11011010b = 11111011b
-00110001b | 11011011b = 11111011b
-00110001b | 11011100b = 11111101b
-00110001b | 11011101b = 11111101b
-00110001b | 11011110b = 11111111b
-00110001b | 11011111b = 11111111b
-00110001b | 11100000b = 11110001b
-00110001b | 11100001b = 11110001b
-00110001b | 11100010b = 11110011b
-00110001b | 11100011b = 11110011b
-00110001b | 11100100b = 11110101b
-00110001b | 11100101b = 11110101b
-00110001b | 11100110b = 11110111b
-00110001b | 11100111b = 11110111b
-00110001b | 11101000b = 11111001b
-00110001b | 11101001b = 11111001b
-00110001b | 11101010b = 11111011b
-00110001b | 11101011b = 11111011b
-00110001b | 11101100b = 11111101b
-00110001b | 11101101b = 11111101b
-00110001b | 11101110b = 11111111b
-00110001b | 11101111b = 11111111b
-00110001b | 11110000b = 11110001b
-00110001b | 11110001b = 11110001b
-00110001b | 11110010b = 11110011b
-00110001b | 11110011b = 11110011b
-00110001b | 11110100b = 11110101b
-00110001b | 11110101b = 11110101b
-00110001b | 11110110b = 11110111b
-00110001b | 11110111b = 11110111b
-00110001b | 11111000b = 11111001b
-00110001b | 11111001b = 11111001b
-00110001b | 11111010b = 11111011b
-00110001b | 11111011b = 11111011b
-00110001b | 11111100b = 11111101b
-00110001b | 11111101b = 11111101b
-00110001b | 11111110b = 11111111b
-00110001b | 11111111b = 11111111b
-00110001b | 00000000b = 00110001b
-00110001b | 00000001b = 00110001b
-00110001b | 00000010b = 00110011b
-00110001b | 00000011b = 00110011b
-00110001b | 00000100b = 00110101b
-00110001b | 00000101b = 00110101b
-00110001b | 00000110b = 00110111b
-00110001b | 00000111b = 00110111b
-00110001b | 00001000b = 00111001b
-00110001b | 00001001b = 00111001b
-00110001b | 00001010b = 00111011b
-00110001b | 00001011b = 00111011b
-00110001b | 00001100b = 00111101b
-00110001b | 00001101b = 00111101b
-00110001b | 00001110b = 00111111b
-00110001b | 00001111b = 00111111b
-00110001b | 00010000b = 00110001b
-00110001b | 00010001b = 00110001b
-00110001b | 00010010b = 00110011b
-00110001b | 00010011b = 00110011b
-00110001b | 00010100b = 00110101b
-00110001b | 00010101b = 00110101b
-00110001b | 00010110b = 00110111b
-00110001b | 00010111b = 00110111b
-00110001b | 00011000b = 00111001b
-00110001b | 00011001b = 00111001b
-00110001b | 00011010b = 00111011b
-00110001b | 00011011b = 00111011b
-00110001b | 00011100b = 00111101b
-00110001b | 00011101b = 00111101b
-00110001b | 00011110b = 00111111b
-00110001b | 00011111b = 00111111b
-00110001b | 00100000b = 00110001b
-00110001b | 00100001b = 00110001b
-00110001b | 00100010b = 00110011b
-00110001b | 00100011b = 00110011b
-00110001b | 00100100b = 00110101b
-00110001b | 00100101b = 00110101b
-00110001b | 00100110b = 00110111b
-00110001b | 00100111b = 00110111b
-00110001b | 00101000b = 00111001b
-00110001b | 00101001b = 00111001b
-00110001b | 00101010b = 00111011b
-00110001b | 00101011b = 00111011b
-00110001b | 00101100b = 00111101b
-00110001b | 00101101b = 00111101b
-00110001b | 00101110b = 00111111b
-00110001b | 00101111b = 00111111b
-00110001b | 00110000b = 00110001b
-00110001b | 00110001b = 00110001b
-00110001b | 00110010b = 00110011b
-00110001b | 00110011b = 00110011b
-00110001b | 00110100b = 00110101b
-00110001b | 00110101b = 00110101b
-00110001b | 00110110b = 00110111b
-00110001b | 00110111b = 00110111b
-00110001b | 00111000b = 00111001b
-00110001b | 00111001b = 00111001b
-00110001b | 00111010b = 00111011b
-00110001b | 00111011b = 00111011b
-00110001b | 00111100b = 00111101b
-00110001b | 00111101b = 00111101b
-00110001b | 00111110b = 00111111b
-00110001b | 00111111b = 00111111b
-00110001b | 01000000b = 01110001b
-00110001b | 01000001b = 01110001b
-00110001b | 01000010b = 01110011b
-00110001b | 01000011b = 01110011b
-00110001b | 01000100b = 01110101b
-00110001b | 01000101b = 01110101b
-00110001b | 01000110b = 01110111b
-00110001b | 01000111b = 01110111b
-00110001b | 01001000b = 01111001b
-00110001b | 01001001b = 01111001b
-00110001b | 01001010b = 01111011b
-00110001b | 01001011b = 01111011b
-00110001b | 01001100b = 01111101b
-00110001b | 01001101b = 01111101b
-00110001b | 01001110b = 01111111b
-00110001b | 01001111b = 01111111b
-00110001b | 01010000b = 01110001b
-00110001b | 01010001b = 01110001b
-00110001b | 01010010b = 01110011b
-00110001b | 01010011b = 01110011b
-00110001b | 01010100b = 01110101b
-00110001b | 01010101b = 01110101b
-00110001b | 01010110b = 01110111b
-00110001b | 01010111b = 01110111b
-00110001b | 01011000b = 01111001b
-00110001b | 01011001b = 01111001b
-00110001b | 01011010b = 01111011b
-00110001b | 01011011b = 01111011b
-00110001b | 01011100b = 01111101b
-00110001b | 01011101b = 01111101b
-00110001b | 01011110b = 01111111b
-00110001b | 01011111b = 01111111b
-00110001b | 01100000b = 01110001b
-00110001b | 01100001b = 01110001b
-00110001b | 01100010b = 01110011b
-00110001b | 01100011b = 01110011b
-00110001b | 01100100b = 01110101b
-00110001b | 01100101b = 01110101b
-00110001b | 01100110b = 01110111b
-00110001b | 01100111b = 01110111b
-00110001b | 01101000b = 01111001b
-00110001b | 01101001b = 01111001b
-00110001b | 01101010b = 01111011b
-00110001b | 01101011b = 01111011b
-00110001b | 01101100b = 01111101b
-00110001b | 01101101b = 01111101b
-00110001b | 01101110b = 01111111b
-00110001b | 01101111b = 01111111b
-00110001b | 01110000b = 01110001b
-00110001b | 01110001b = 01110001b
-00110001b | 01110010b = 01110011b
-00110001b | 01110011b = 01110011b
-00110001b | 01110100b = 01110101b
-00110001b | 01110101b = 01110101b
-00110001b | 01110110b = 01110111b
-00110001b | 01110111b = 01110111b
-00110001b | 01111000b = 01111001b
-00110001b | 01111001b = 01111001b
-00110001b | 01111010b = 01111011b
-00110001b | 01111011b = 01111011b
-00110001b | 01111100b = 01111101b
-00110001b | 01111101b = 01111101b
-00110001b | 01111110b = 01111111b
-00110010b | 10000000b = 10110010b
-00110010b | 10000001b = 10110011b
-00110010b | 10000010b = 10110010b
-00110010b | 10000011b = 10110011b
-00110010b | 10000100b = 10110110b
-00110010b | 10000101b = 10110111b
-00110010b | 10000110b = 10110110b
-00110010b | 10000111b = 10110111b
-00110010b | 10001000b = 10111010b
-00110010b | 10001001b = 10111011b
-00110010b | 10001010b = 10111010b
-00110010b | 10001011b = 10111011b
-00110010b | 10001100b = 10111110b
-00110010b | 10001101b = 10111111b
-00110010b | 10001110b = 10111110b
-00110010b | 10001111b = 10111111b
-00110010b | 10010000b = 10110010b
-00110010b | 10010001b = 10110011b
-00110010b | 10010010b = 10110010b
-00110010b | 10010011b = 10110011b
-00110010b | 10010100b = 10110110b
-00110010b | 10010101b = 10110111b
-00110010b | 10010110b = 10110110b
-00110010b | 10010111b = 10110111b
-00110010b | 10011000b = 10111010b
-00110010b | 10011001b = 10111011b
-00110010b | 10011010b = 10111010b
-00110010b | 10011011b = 10111011b
-00110010b | 10011100b = 10111110b
-00110010b | 10011101b = 10111111b
-00110010b | 10011110b = 10111110b
-00110010b | 10011111b = 10111111b
-00110010b | 10100000b = 10110010b
-00110010b | 10100001b = 10110011b
-00110010b | 10100010b = 10110010b
-00110010b | 10100011b = 10110011b
-00110010b | 10100100b = 10110110b
-00110010b | 10100101b = 10110111b
-00110010b | 10100110b = 10110110b
-00110010b | 10100111b = 10110111b
-00110010b | 10101000b = 10111010b
-00110010b | 10101001b = 10111011b
-00110010b | 10101010b = 10111010b
-00110010b | 10101011b = 10111011b
-00110010b | 10101100b = 10111110b
-00110010b | 10101101b = 10111111b
-00110010b | 10101110b = 10111110b
-00110010b | 10101111b = 10111111b
-00110010b | 10110000b = 10110010b
-00110010b | 10110001b = 10110011b
-00110010b | 10110010b = 10110010b
-00110010b | 10110011b = 10110011b
-00110010b | 10110100b = 10110110b
-00110010b | 10110101b = 10110111b
-00110010b | 10110110b = 10110110b
-00110010b | 10110111b = 10110111b
-00110010b | 10111000b = 10111010b
-00110010b | 10111001b = 10111011b
-00110010b | 10111010b = 10111010b
-00110010b | 10111011b = 10111011b
-00110010b | 10111100b = 10111110b
-00110010b | 10111101b = 10111111b
-00110010b | 10111110b = 10111110b
-00110010b | 10111111b = 10111111b
-00110010b | 11000000b = 11110010b
-00110010b | 11000001b = 11110011b
-00110010b | 11000010b = 11110010b
-00110010b | 11000011b = 11110011b
-00110010b | 11000100b = 11110110b
-00110010b | 11000101b = 11110111b
-00110010b | 11000110b = 11110110b
-00110010b | 11000111b = 11110111b
-00110010b | 11001000b = 11111010b
-00110010b | 11001001b = 11111011b
-00110010b | 11001010b = 11111010b
-00110010b | 11001011b = 11111011b
-00110010b | 11001100b = 11111110b
-00110010b | 11001101b = 11111111b
-00110010b | 11001110b = 11111110b
-00110010b | 11001111b = 11111111b
-00110010b | 11010000b = 11110010b
-00110010b | 11010001b = 11110011b
-00110010b | 11010010b = 11110010b
-00110010b | 11010011b = 11110011b
-00110010b | 11010100b = 11110110b
-00110010b | 11010101b = 11110111b
-00110010b | 11010110b = 11110110b
-00110010b | 11010111b = 11110111b
-00110010b | 11011000b = 11111010b
-00110010b | 11011001b = 11111011b
-00110010b | 11011010b = 11111010b
-00110010b | 11011011b = 11111011b
-00110010b | 11011100b = 11111110b
-00110010b | 11011101b = 11111111b
-00110010b | 11011110b = 11111110b
-00110010b | 11011111b = 11111111b
-00110010b | 11100000b = 11110010b
-00110010b | 11100001b = 11110011b
-00110010b | 11100010b = 11110010b
-00110010b | 11100011b = 11110011b
-00110010b | 11100100b = 11110110b
-00110010b | 11100101b = 11110111b
-00110010b | 11100110b = 11110110b
-00110010b | 11100111b = 11110111b
-00110010b | 11101000b = 11111010b
-00110010b | 11101001b = 11111011b
-00110010b | 11101010b = 11111010b
-00110010b | 11101011b = 11111011b
-00110010b | 11101100b = 11111110b
-00110010b | 11101101b = 11111111b
-00110010b | 11101110b = 11111110b
-00110010b | 11101111b = 11111111b
-00110010b | 11110000b = 11110010b
-00110010b | 11110001b = 11110011b
-00110010b | 11110010b = 11110010b
-00110010b | 11110011b = 11110011b
-00110010b | 11110100b = 11110110b
-00110010b | 11110101b = 11110111b
-00110010b | 11110110b = 11110110b
-00110010b | 11110111b = 11110111b
-00110010b | 11111000b = 11111010b
-00110010b | 11111001b = 11111011b
-00110010b | 11111010b = 11111010b
-00110010b | 11111011b = 11111011b
-00110010b | 11111100b = 11111110b
-00110010b | 11111101b = 11111111b
-00110010b | 11111110b = 11111110b
-00110010b | 11111111b = 11111111b
-00110010b | 00000000b = 00110010b
-00110010b | 00000001b = 00110011b
-00110010b | 00000010b = 00110010b
-00110010b | 00000011b = 00110011b
-00110010b | 00000100b = 00110110b
-00110010b | 00000101b = 00110111b
-00110010b | 00000110b = 00110110b
-00110010b | 00000111b = 00110111b
-00110010b | 00001000b = 00111010b
-00110010b | 00001001b = 00111011b
-00110010b | 00001010b = 00111010b
-00110010b | 00001011b = 00111011b
-00110010b | 00001100b = 00111110b
-00110010b | 00001101b = 00111111b
-00110010b | 00001110b = 00111110b
-00110010b | 00001111b = 00111111b
-00110010b | 00010000b = 00110010b
-00110010b | 00010001b = 00110011b
-00110010b | 00010010b = 00110010b
-00110010b | 00010011b = 00110011b
-00110010b | 00010100b = 00110110b
-00110010b | 00010101b = 00110111b
-00110010b | 00010110b = 00110110b
-00110010b | 00010111b = 00110111b
-00110010b | 00011000b = 00111010b
-00110010b | 00011001b = 00111011b
-00110010b | 00011010b = 00111010b
-00110010b | 00011011b = 00111011b
-00110010b | 00011100b = 00111110b
-00110010b | 00011101b = 00111111b
-00110010b | 00011110b = 00111110b
-00110010b | 00011111b = 00111111b
-00110010b | 00100000b = 00110010b
-00110010b | 00100001b = 00110011b
-00110010b | 00100010b = 00110010b
-00110010b | 00100011b = 00110011b
-00110010b | 00100100b = 00110110b
-00110010b | 00100101b = 00110111b
-00110010b | 00100110b = 00110110b
-00110010b | 00100111b = 00110111b
-00110010b | 00101000b = 00111010b
-00110010b | 00101001b = 00111011b
-00110010b | 00101010b = 00111010b
-00110010b | 00101011b = 00111011b
-00110010b | 00101100b = 00111110b
-00110010b | 00101101b = 00111111b
-00110010b | 00101110b = 00111110b
-00110010b | 00101111b = 00111111b
-00110010b | 00110000b = 00110010b
-00110010b | 00110001b = 00110011b
-00110010b | 00110010b = 00110010b
-00110010b | 00110011b = 00110011b
-00110010b | 00110100b = 00110110b
-00110010b | 00110101b = 00110111b
-00110010b | 00110110b = 00110110b
-00110010b | 00110111b = 00110111b
-00110010b | 00111000b = 00111010b
-00110010b | 00111001b = 00111011b
-00110010b | 00111010b = 00111010b
-00110010b | 00111011b = 00111011b
-00110010b | 00111100b = 00111110b
-00110010b | 00111101b = 00111111b
-00110010b | 00111110b = 00111110b
-00110010b | 00111111b = 00111111b
-00110010b | 01000000b = 01110010b
-00110010b | 01000001b = 01110011b
-00110010b | 01000010b = 01110010b
-00110010b | 01000011b = 01110011b
-00110010b | 01000100b = 01110110b
-00110010b | 01000101b = 01110111b
-00110010b | 01000110b = 01110110b
-00110010b | 01000111b = 01110111b
-00110010b | 01001000b = 01111010b
-00110010b | 01001001b = 01111011b
-00110010b | 01001010b = 01111010b
-00110010b | 01001011b = 01111011b
-00110010b | 01001100b = 01111110b
-00110010b | 01001101b = 01111111b
-00110010b | 01001110b = 01111110b
-00110010b | 01001111b = 01111111b
-00110010b | 01010000b = 01110010b
-00110010b | 01010001b = 01110011b
-00110010b | 01010010b = 01110010b
-00110010b | 01010011b = 01110011b
-00110010b | 01010100b = 01110110b
-00110010b | 01010101b = 01110111b
-00110010b | 01010110b = 01110110b
-00110010b | 01010111b = 01110111b
-00110010b | 01011000b = 01111010b
-00110010b | 01011001b = 01111011b
-00110010b | 01011010b = 01111010b
-00110010b | 01011011b = 01111011b
-00110010b | 01011100b = 01111110b
-00110010b | 01011101b = 01111111b
-00110010b | 01011110b = 01111110b
-00110010b | 01011111b = 01111111b
-00110010b | 01100000b = 01110010b
-00110010b | 01100001b = 01110011b
-00110010b | 01100010b = 01110010b
-00110010b | 01100011b = 01110011b
-00110010b | 01100100b = 01110110b
-00110010b | 01100101b = 01110111b
-00110010b | 01100110b = 01110110b
-00110010b | 01100111b = 01110111b
-00110010b | 01101000b = 01111010b
-00110010b | 01101001b = 01111011b
-00110010b | 01101010b = 01111010b
-00110010b | 01101011b = 01111011b
-00110010b | 01101100b = 01111110b
-00110010b | 01101101b = 01111111b
-00110010b | 01101110b = 01111110b
-00110010b | 01101111b = 01111111b
-00110010b | 01110000b = 01110010b
-00110010b | 01110001b = 01110011b
-00110010b | 01110010b = 01110010b
-00110010b | 01110011b = 01110011b
-00110010b | 01110100b = 01110110b
-00110010b | 01110101b = 01110111b
-00110010b | 01110110b = 01110110b
-00110010b | 01110111b = 01110111b
-00110010b | 01111000b = 01111010b
-00110010b | 01111001b = 01111011b
-00110010b | 01111010b = 01111010b
-00110010b | 01111011b = 01111011b
-00110010b | 01111100b = 01111110b
-00110010b | 01111101b = 01111111b
-00110010b | 01111110b = 01111110b
-00110011b | 10000000b = 10110011b
-00110011b | 10000001b = 10110011b
-00110011b | 10000010b = 10110011b
-00110011b | 10000011b = 10110011b
-00110011b | 10000100b = 10110111b
-00110011b | 10000101b = 10110111b
-00110011b | 10000110b = 10110111b
-00110011b | 10000111b = 10110111b
-00110011b | 10001000b = 10111011b
-00110011b | 10001001b = 10111011b
-00110011b | 10001010b = 10111011b
-00110011b | 10001011b = 10111011b
-00110011b | 10001100b = 10111111b
-00110011b | 10001101b = 10111111b
-00110011b | 10001110b = 10111111b
-00110011b | 10001111b = 10111111b
-00110011b | 10010000b = 10110011b
-00110011b | 10010001b = 10110011b
-00110011b | 10010010b = 10110011b
-00110011b | 10010011b = 10110011b
-00110011b | 10010100b = 10110111b
-00110011b | 10010101b = 10110111b
-00110011b | 10010110b = 10110111b
-00110011b | 10010111b = 10110111b
-00110011b | 10011000b = 10111011b
-00110011b | 10011001b = 10111011b
-00110011b | 10011010b = 10111011b
-00110011b | 10011011b = 10111011b
-00110011b | 10011100b = 10111111b
-00110011b | 10011101b = 10111111b
-00110011b | 10011110b = 10111111b
-00110011b | 10011111b = 10111111b
-00110011b | 10100000b = 10110011b
-00110011b | 10100001b = 10110011b
-00110011b | 10100010b = 10110011b
-00110011b | 10100011b = 10110011b
-00110011b | 10100100b = 10110111b
-00110011b | 10100101b = 10110111b
-00110011b | 10100110b = 10110111b
-00110011b | 10100111b = 10110111b
-00110011b | 10101000b = 10111011b
-00110011b | 10101001b = 10111011b
-00110011b | 10101010b = 10111011b
-00110011b | 10101011b = 10111011b
-00110011b | 10101100b = 10111111b
-00110011b | 10101101b = 10111111b
-00110011b | 10101110b = 10111111b
-00110011b | 10101111b = 10111111b
-00110011b | 10110000b = 10110011b
-00110011b | 10110001b = 10110011b
-00110011b | 10110010b = 10110011b
-00110011b | 10110011b = 10110011b
-00110011b | 10110100b = 10110111b
-00110011b | 10110101b = 10110111b
-00110011b | 10110110b = 10110111b
-00110011b | 10110111b = 10110111b
-00110011b | 10111000b = 10111011b
-00110011b | 10111001b = 10111011b
-00110011b | 10111010b = 10111011b
-00110011b | 10111011b = 10111011b
-00110011b | 10111100b = 10111111b
-00110011b | 10111101b = 10111111b
-00110011b | 10111110b = 10111111b
-00110011b | 10111111b = 10111111b
-00110011b | 11000000b = 11110011b
-00110011b | 11000001b = 11110011b
-00110011b | 11000010b = 11110011b
-00110011b | 11000011b = 11110011b
-00110011b | 11000100b = 11110111b
-00110011b | 11000101b = 11110111b
-00110011b | 11000110b = 11110111b
-00110011b | 11000111b = 11110111b
-00110011b | 11001000b = 11111011b
-00110011b | 11001001b = 11111011b
-00110011b | 11001010b = 11111011b
-00110011b | 11001011b = 11111011b
-00110011b | 11001100b = 11111111b
-00110011b | 11001101b = 11111111b
-00110011b | 11001110b = 11111111b
-00110011b | 11001111b = 11111111b
-00110011b | 11010000b = 11110011b
-00110011b | 11010001b = 11110011b
-00110011b | 11010010b = 11110011b
-00110011b | 11010011b = 11110011b
-00110011b | 11010100b = 11110111b
-00110011b | 11010101b = 11110111b
-00110011b | 11010110b = 11110111b
-00110011b | 11010111b = 11110111b
-00110011b | 11011000b = 11111011b
-00110011b | 11011001b = 11111011b
-00110011b | 11011010b = 11111011b
-00110011b | 11011011b = 11111011b
-00110011b | 11011100b = 11111111b
-00110011b | 11011101b = 11111111b
-00110011b | 11011110b = 11111111b
-00110011b | 11011111b = 11111111b
-00110011b | 11100000b = 11110011b
-00110011b | 11100001b = 11110011b
-00110011b | 11100010b = 11110011b
-00110011b | 11100011b = 11110011b
-00110011b | 11100100b = 11110111b
-00110011b | 11100101b = 11110111b
-00110011b | 11100110b = 11110111b
-00110011b | 11100111b = 11110111b
-00110011b | 11101000b = 11111011b
-00110011b | 11101001b = 11111011b
-00110011b | 11101010b = 11111011b
-00110011b | 11101011b = 11111011b
-00110011b | 11101100b = 11111111b
-00110011b | 11101101b = 11111111b
-00110011b | 11101110b = 11111111b
-00110011b | 11101111b = 11111111b
-00110011b | 11110000b = 11110011b
-00110011b | 11110001b = 11110011b
-00110011b | 11110010b = 11110011b
-00110011b | 11110011b = 11110011b
-00110011b | 11110100b = 11110111b
-00110011b | 11110101b = 11110111b
-00110011b | 11110110b = 11110111b
-00110011b | 11110111b = 11110111b
-00110011b | 11111000b = 11111011b
-00110011b | 11111001b = 11111011b
-00110011b | 11111010b = 11111011b
-00110011b | 11111011b = 11111011b
-00110011b | 11111100b = 11111111b
-00110011b | 11111101b = 11111111b
-00110011b | 11111110b = 11111111b
-00110011b | 11111111b = 11111111b
-00110011b | 00000000b = 00110011b
-00110011b | 00000001b = 00110011b
-00110011b | 00000010b = 00110011b
-00110011b | 00000011b = 00110011b
-00110011b | 00000100b = 00110111b
-00110011b | 00000101b = 00110111b
-00110011b | 00000110b = 00110111b
-00110011b | 00000111b = 00110111b
-00110011b | 00001000b = 00111011b
-00110011b | 00001001b = 00111011b
-00110011b | 00001010b = 00111011b
-00110011b | 00001011b = 00111011b
-00110011b | 00001100b = 00111111b
-00110011b | 00001101b = 00111111b
-00110011b | 00001110b = 00111111b
-00110011b | 00001111b = 00111111b
-00110011b | 00010000b = 00110011b
-00110011b | 00010001b = 00110011b
-00110011b | 00010010b = 00110011b
-00110011b | 00010011b = 00110011b
-00110011b | 00010100b = 00110111b
-00110011b | 00010101b = 00110111b
-00110011b | 00010110b = 00110111b
-00110011b | 00010111b = 00110111b
-00110011b | 00011000b = 00111011b
-00110011b | 00011001b = 00111011b
-00110011b | 00011010b = 00111011b
-00110011b | 00011011b = 00111011b
-00110011b | 00011100b = 00111111b
-00110011b | 00011101b = 00111111b
-00110011b | 00011110b = 00111111b
-00110011b | 00011111b = 00111111b
-00110011b | 00100000b = 00110011b
-00110011b | 00100001b = 00110011b
-00110011b | 00100010b = 00110011b
-00110011b | 00100011b = 00110011b
-00110011b | 00100100b = 00110111b
-00110011b | 00100101b = 00110111b
-00110011b | 00100110b = 00110111b
-00110011b | 00100111b = 00110111b
-00110011b | 00101000b = 00111011b
-00110011b | 00101001b = 00111011b
-00110011b | 00101010b = 00111011b
-00110011b | 00101011b = 00111011b
-00110011b | 00101100b = 00111111b
-00110011b | 00101101b = 00111111b
-00110011b | 00101110b = 00111111b
-00110011b | 00101111b = 00111111b
-00110011b | 00110000b = 00110011b
-00110011b | 00110001b = 00110011b
-00110011b | 00110010b = 00110011b
-00110011b | 00110011b = 00110011b
-00110011b | 00110100b = 00110111b
-00110011b | 00110101b = 00110111b
-00110011b | 00110110b = 00110111b
-00110011b | 00110111b = 00110111b
-00110011b | 00111000b = 00111011b
-00110011b | 00111001b = 00111011b
-00110011b | 00111010b = 00111011b
-00110011b | 00111011b = 00111011b
-00110011b | 00111100b = 00111111b
-00110011b | 00111101b = 00111111b
-00110011b | 00111110b = 00111111b
-00110011b | 00111111b = 00111111b
-00110011b | 01000000b = 01110011b
-00110011b | 01000001b = 01110011b
-00110011b | 01000010b = 01110011b
-00110011b | 01000011b = 01110011b
-00110011b | 01000100b = 01110111b
-00110011b | 01000101b = 01110111b
-00110011b | 01000110b = 01110111b
-00110011b | 01000111b = 01110111b
-00110011b | 01001000b = 01111011b
-00110011b | 01001001b = 01111011b
-00110011b | 01001010b = 01111011b
-00110011b | 01001011b = 01111011b
-00110011b | 01001100b = 01111111b
-00110011b | 01001101b = 01111111b
-00110011b | 01001110b = 01111111b
-00110011b | 01001111b = 01111111b
-00110011b | 01010000b = 01110011b
-00110011b | 01010001b = 01110011b
-00110011b | 01010010b = 01110011b
-00110011b | 01010011b = 01110011b
-00110011b | 01010100b = 01110111b
-00110011b | 01010101b = 01110111b
-00110011b | 01010110b = 01110111b
-00110011b | 01010111b = 01110111b
-00110011b | 01011000b = 01111011b
-00110011b | 01011001b = 01111011b
-00110011b | 01011010b = 01111011b
-00110011b | 01011011b = 01111011b
-00110011b | 01011100b = 01111111b
-00110011b | 01011101b = 01111111b
-00110011b | 01011110b = 01111111b
-00110011b | 01011111b = 01111111b
-00110011b | 01100000b = 01110011b
-00110011b | 01100001b = 01110011b
-00110011b | 01100010b = 01110011b
-00110011b | 01100011b = 01110011b
-00110011b | 01100100b = 01110111b
-00110011b | 01100101b = 01110111b
-00110011b | 01100110b = 01110111b
-00110011b | 01100111b = 01110111b
-00110011b | 01101000b = 01111011b
-00110011b | 01101001b = 01111011b
-00110011b | 01101010b = 01111011b
-00110011b | 01101011b = 01111011b
-00110011b | 01101100b = 01111111b
-00110011b | 01101101b = 01111111b
-00110011b | 01101110b = 01111111b
-00110011b | 01101111b = 01111111b
-00110011b | 01110000b = 01110011b
-00110011b | 01110001b = 01110011b
-00110011b | 01110010b = 01110011b
-00110011b | 01110011b = 01110011b
-00110011b | 01110100b = 01110111b
-00110011b | 01110101b = 01110111b
-00110011b | 01110110b = 01110111b
-00110011b | 01110111b = 01110111b
-00110011b | 01111000b = 01111011b
-00110011b | 01111001b = 01111011b
-00110011b | 01111010b = 01111011b
-00110011b | 01111011b = 01111011b
-00110011b | 01111100b = 01111111b
-00110011b | 01111101b = 01111111b
-00110011b | 01111110b = 01111111b
-00110100b | 10000000b = 10110100b
-00110100b | 10000001b = 10110101b
-00110100b | 10000010b = 10110110b
-00110100b | 10000011b = 10110111b
-00110100b | 10000100b = 10110100b
-00110100b | 10000101b = 10110101b
-00110100b | 10000110b = 10110110b
-00110100b | 10000111b = 10110111b
-00110100b | 10001000b = 10111100b
-00110100b | 10001001b = 10111101b
-00110100b | 10001010b = 10111110b
-00110100b | 10001011b = 10111111b
-00110100b | 10001100b = 10111100b
-00110100b | 10001101b = 10111101b
-00110100b | 10001110b = 10111110b
-00110100b | 10001111b = 10111111b
-00110100b | 10010000b = 10110100b
-00110100b | 10010001b = 10110101b
-00110100b | 10010010b = 10110110b
-00110100b | 10010011b = 10110111b
-00110100b | 10010100b = 10110100b
-00110100b | 10010101b = 10110101b
-00110100b | 10010110b = 10110110b
-00110100b | 10010111b = 10110111b
-00110100b | 10011000b = 10111100b
-00110100b | 10011001b = 10111101b
-00110100b | 10011010b = 10111110b
-00110100b | 10011011b = 10111111b
-00110100b | 10011100b = 10111100b
-00110100b | 10011101b = 10111101b
-00110100b | 10011110b = 10111110b
-00110100b | 10011111b = 10111111b
-00110100b | 10100000b = 10110100b
-00110100b | 10100001b = 10110101b
-00110100b | 10100010b = 10110110b
-00110100b | 10100011b = 10110111b
-00110100b | 10100100b = 10110100b
-00110100b | 10100101b = 10110101b
-00110100b | 10100110b = 10110110b
-00110100b | 10100111b = 10110111b
-00110100b | 10101000b = 10111100b
-00110100b | 10101001b = 10111101b
-00110100b | 10101010b = 10111110b
-00110100b | 10101011b = 10111111b
-00110100b | 10101100b = 10111100b
-00110100b | 10101101b = 10111101b
-00110100b | 10101110b = 10111110b
-00110100b | 10101111b = 10111111b
-00110100b | 10110000b = 10110100b
-00110100b | 10110001b = 10110101b
-00110100b | 10110010b = 10110110b
-00110100b | 10110011b = 10110111b
-00110100b | 10110100b = 10110100b
-00110100b | 10110101b = 10110101b
-00110100b | 10110110b = 10110110b
-00110100b | 10110111b = 10110111b
-00110100b | 10111000b = 10111100b
-00110100b | 10111001b = 10111101b
-00110100b | 10111010b = 10111110b
-00110100b | 10111011b = 10111111b
-00110100b | 10111100b = 10111100b
-00110100b | 10111101b = 10111101b
-00110100b | 10111110b = 10111110b
-00110100b | 10111111b = 10111111b
-00110100b | 11000000b = 11110100b
-00110100b | 11000001b = 11110101b
-00110100b | 11000010b = 11110110b
-00110100b | 11000011b = 11110111b
-00110100b | 11000100b = 11110100b
-00110100b | 11000101b = 11110101b
-00110100b | 11000110b = 11110110b
-00110100b | 11000111b = 11110111b
-00110100b | 11001000b = 11111100b
-00110100b | 11001001b = 11111101b
-00110100b | 11001010b = 11111110b
-00110100b | 11001011b = 11111111b
-00110100b | 11001100b = 11111100b
-00110100b | 11001101b = 11111101b
-00110100b | 11001110b = 11111110b
-00110100b | 11001111b = 11111111b
-00110100b | 11010000b = 11110100b
-00110100b | 11010001b = 11110101b
-00110100b | 11010010b = 11110110b
-00110100b | 11010011b = 11110111b
-00110100b | 11010100b = 11110100b
-00110100b | 11010101b = 11110101b
-00110100b | 11010110b = 11110110b
-00110100b | 11010111b = 11110111b
-00110100b | 11011000b = 11111100b
-00110100b | 11011001b = 11111101b
-00110100b | 11011010b = 11111110b
-00110100b | 11011011b = 11111111b
-00110100b | 11011100b = 11111100b
-00110100b | 11011101b = 11111101b
-00110100b | 11011110b = 11111110b
-00110100b | 11011111b = 11111111b
-00110100b | 11100000b = 11110100b
-00110100b | 11100001b = 11110101b
-00110100b | 11100010b = 11110110b
-00110100b | 11100011b = 11110111b
-00110100b | 11100100b = 11110100b
-00110100b | 11100101b = 11110101b
-00110100b | 11100110b = 11110110b
-00110100b | 11100111b = 11110111b
-00110100b | 11101000b = 11111100b
-00110100b | 11101001b = 11111101b
-00110100b | 11101010b = 11111110b
-00110100b | 11101011b = 11111111b
-00110100b | 11101100b = 11111100b
-00110100b | 11101101b = 11111101b
-00110100b | 11101110b = 11111110b
-00110100b | 11101111b = 11111111b
-00110100b | 11110000b = 11110100b
-00110100b | 11110001b = 11110101b
-00110100b | 11110010b = 11110110b
-00110100b | 11110011b = 11110111b
-00110100b | 11110100b = 11110100b
-00110100b | 11110101b = 11110101b
-00110100b | 11110110b = 11110110b
-00110100b | 11110111b = 11110111b
-00110100b | 11111000b = 11111100b
-00110100b | 11111001b = 11111101b
-00110100b | 11111010b = 11111110b
-00110100b | 11111011b = 11111111b
-00110100b | 11111100b = 11111100b
-00110100b | 11111101b = 11111101b
-00110100b | 11111110b = 11111110b
-00110100b | 11111111b = 11111111b
-00110100b | 00000000b = 00110100b
-00110100b | 00000001b = 00110101b
-00110100b | 00000010b = 00110110b
-00110100b | 00000011b = 00110111b
-00110100b | 00000100b = 00110100b
-00110100b | 00000101b = 00110101b
-00110100b | 00000110b = 00110110b
-00110100b | 00000111b = 00110111b
-00110100b | 00001000b = 00111100b
-00110100b | 00001001b = 00111101b
-00110100b | 00001010b = 00111110b
-00110100b | 00001011b = 00111111b
-00110100b | 00001100b = 00111100b
-00110100b | 00001101b = 00111101b
-00110100b | 00001110b = 00111110b
-00110100b | 00001111b = 00111111b
-00110100b | 00010000b = 00110100b
-00110100b | 00010001b = 00110101b
-00110100b | 00010010b = 00110110b
-00110100b | 00010011b = 00110111b
-00110100b | 00010100b = 00110100b
-00110100b | 00010101b = 00110101b
-00110100b | 00010110b = 00110110b
-00110100b | 00010111b = 00110111b
-00110100b | 00011000b = 00111100b
-00110100b | 00011001b = 00111101b
-00110100b | 00011010b = 00111110b
-00110100b | 00011011b = 00111111b
-00110100b | 00011100b = 00111100b
-00110100b | 00011101b = 00111101b
-00110100b | 00011110b = 00111110b
-00110100b | 00011111b = 00111111b
-00110100b | 00100000b = 00110100b
-00110100b | 00100001b = 00110101b
-00110100b | 00100010b = 00110110b
-00110100b | 00100011b = 00110111b
-00110100b | 00100100b = 00110100b
-00110100b | 00100101b = 00110101b
-00110100b | 00100110b = 00110110b
-00110100b | 00100111b = 00110111b
-00110100b | 00101000b = 00111100b
-00110100b | 00101001b = 00111101b
-00110100b | 00101010b = 00111110b
-00110100b | 00101011b = 00111111b
-00110100b | 00101100b = 00111100b
-00110100b | 00101101b = 00111101b
-00110100b | 00101110b = 00111110b
-00110100b | 00101111b = 00111111b
-00110100b | 00110000b = 00110100b
-00110100b | 00110001b = 00110101b
-00110100b | 00110010b = 00110110b
-00110100b | 00110011b = 00110111b
-00110100b | 00110100b = 00110100b
-00110100b | 00110101b = 00110101b
-00110100b | 00110110b = 00110110b
-00110100b | 00110111b = 00110111b
-00110100b | 00111000b = 00111100b
-00110100b | 00111001b = 00111101b
-00110100b | 00111010b = 00111110b
-00110100b | 00111011b = 00111111b
-00110100b | 00111100b = 00111100b
-00110100b | 00111101b = 00111101b
-00110100b | 00111110b = 00111110b
-00110100b | 00111111b = 00111111b
-00110100b | 01000000b = 01110100b
-00110100b | 01000001b = 01110101b
-00110100b | 01000010b = 01110110b
-00110100b | 01000011b = 01110111b
-00110100b | 01000100b = 01110100b
-00110100b | 01000101b = 01110101b
-00110100b | 01000110b = 01110110b
-00110100b | 01000111b = 01110111b
-00110100b | 01001000b = 01111100b
-00110100b | 01001001b = 01111101b
-00110100b | 01001010b = 01111110b
-00110100b | 01001011b = 01111111b
-00110100b | 01001100b = 01111100b
-00110100b | 01001101b = 01111101b
-00110100b | 01001110b = 01111110b
-00110100b | 01001111b = 01111111b
-00110100b | 01010000b = 01110100b
-00110100b | 01010001b = 01110101b
-00110100b | 01010010b = 01110110b
-00110100b | 01010011b = 01110111b
-00110100b | 01010100b = 01110100b
-00110100b | 01010101b = 01110101b
-00110100b | 01010110b = 01110110b
-00110100b | 01010111b = 01110111b
-00110100b | 01011000b = 01111100b
-00110100b | 01011001b = 01111101b
-00110100b | 01011010b = 01111110b
-00110100b | 01011011b = 01111111b
-00110100b | 01011100b = 01111100b
-00110100b | 01011101b = 01111101b
-00110100b | 01011110b = 01111110b
-00110100b | 01011111b = 01111111b
-00110100b | 01100000b = 01110100b
-00110100b | 01100001b = 01110101b
-00110100b | 01100010b = 01110110b
-00110100b | 01100011b = 01110111b
-00110100b | 01100100b = 01110100b
-00110100b | 01100101b = 01110101b
-00110100b | 01100110b = 01110110b
-00110100b | 01100111b = 01110111b
-00110100b | 01101000b = 01111100b
-00110100b | 01101001b = 01111101b
-00110100b | 01101010b = 01111110b
-00110100b | 01101011b = 01111111b
-00110100b | 01101100b = 01111100b
-00110100b | 01101101b = 01111101b
-00110100b | 01101110b = 01111110b
-00110100b | 01101111b = 01111111b
-00110100b | 01110000b = 01110100b
-00110100b | 01110001b = 01110101b
-00110100b | 01110010b = 01110110b
-00110100b | 01110011b = 01110111b
-00110100b | 01110100b = 01110100b
-00110100b | 01110101b = 01110101b
-00110100b | 01110110b = 01110110b
-00110100b | 01110111b = 01110111b
-00110100b | 01111000b = 01111100b
-00110100b | 01111001b = 01111101b
-00110100b | 01111010b = 01111110b
-00110100b | 01111011b = 01111111b
-00110100b | 01111100b = 01111100b
-00110100b | 01111101b = 01111101b
-00110100b | 01111110b = 01111110b
-00110101b | 10000000b = 10110101b
-00110101b | 10000001b = 10110101b
-00110101b | 10000010b = 10110111b
-00110101b | 10000011b = 10110111b
-00110101b | 10000100b = 10110101b
-00110101b | 10000101b = 10110101b
-00110101b | 10000110b = 10110111b
-00110101b | 10000111b = 10110111b
-00110101b | 10001000b = 10111101b
-00110101b | 10001001b = 10111101b
-00110101b | 10001010b = 10111111b
-00110101b | 10001011b = 10111111b
-00110101b | 10001100b = 10111101b
-00110101b | 10001101b = 10111101b
-00110101b | 10001110b = 10111111b
-00110101b | 10001111b = 10111111b
-00110101b | 10010000b = 10110101b
-00110101b | 10010001b = 10110101b
-00110101b | 10010010b = 10110111b
-00110101b | 10010011b = 10110111b
-00110101b | 10010100b = 10110101b
-00110101b | 10010101b = 10110101b
-00110101b | 10010110b = 10110111b
-00110101b | 10010111b = 10110111b
-00110101b | 10011000b = 10111101b
-00110101b | 10011001b = 10111101b
-00110101b | 10011010b = 10111111b
-00110101b | 10011011b = 10111111b
-00110101b | 10011100b = 10111101b
-00110101b | 10011101b = 10111101b
-00110101b | 10011110b = 10111111b
-00110101b | 10011111b = 10111111b
-00110101b | 10100000b = 10110101b
-00110101b | 10100001b = 10110101b
-00110101b | 10100010b = 10110111b
-00110101b | 10100011b = 10110111b
-00110101b | 10100100b = 10110101b
-00110101b | 10100101b = 10110101b
-00110101b | 10100110b = 10110111b
-00110101b | 10100111b = 10110111b
-00110101b | 10101000b = 10111101b
-00110101b | 10101001b = 10111101b
-00110101b | 10101010b = 10111111b
-00110101b | 10101011b = 10111111b
-00110101b | 10101100b = 10111101b
-00110101b | 10101101b = 10111101b
-00110101b | 10101110b = 10111111b
-00110101b | 10101111b = 10111111b
-00110101b | 10110000b = 10110101b
-00110101b | 10110001b = 10110101b
-00110101b | 10110010b = 10110111b
-00110101b | 10110011b = 10110111b
-00110101b | 10110100b = 10110101b
-00110101b | 10110101b = 10110101b
-00110101b | 10110110b = 10110111b
-00110101b | 10110111b = 10110111b
-00110101b | 10111000b = 10111101b
-00110101b | 10111001b = 10111101b
-00110101b | 10111010b = 10111111b
-00110101b | 10111011b = 10111111b
-00110101b | 10111100b = 10111101b
-00110101b | 10111101b = 10111101b
-00110101b | 10111110b = 10111111b
-00110101b | 10111111b = 10111111b
-00110101b | 11000000b = 11110101b
-00110101b | 11000001b = 11110101b
-00110101b | 11000010b = 11110111b
-00110101b | 11000011b = 11110111b
-00110101b | 11000100b = 11110101b
-00110101b | 11000101b = 11110101b
-00110101b | 11000110b = 11110111b
-00110101b | 11000111b = 11110111b
-00110101b | 11001000b = 11111101b
-00110101b | 11001001b = 11111101b
-00110101b | 11001010b = 11111111b
-00110101b | 11001011b = 11111111b
-00110101b | 11001100b = 11111101b
-00110101b | 11001101b = 11111101b
-00110101b | 11001110b = 11111111b
-00110101b | 11001111b = 11111111b
-00110101b | 11010000b = 11110101b
-00110101b | 11010001b = 11110101b
-00110101b | 11010010b = 11110111b
-00110101b | 11010011b = 11110111b
-00110101b | 11010100b = 11110101b
-00110101b | 11010101b = 11110101b
-00110101b | 11010110b = 11110111b
-00110101b | 11010111b = 11110111b
-00110101b | 11011000b = 11111101b
-00110101b | 11011001b = 11111101b
-00110101b | 11011010b = 11111111b
-00110101b | 11011011b = 11111111b
-00110101b | 11011100b = 11111101b
-00110101b | 11011101b = 11111101b
-00110101b | 11011110b = 11111111b
-00110101b | 11011111b = 11111111b
-00110101b | 11100000b = 11110101b
-00110101b | 11100001b = 11110101b
-00110101b | 11100010b = 11110111b
-00110101b | 11100011b = 11110111b
-00110101b | 11100100b = 11110101b
-00110101b | 11100101b = 11110101b
-00110101b | 11100110b = 11110111b
-00110101b | 11100111b = 11110111b
-00110101b | 11101000b = 11111101b
-00110101b | 11101001b = 11111101b
-00110101b | 11101010b = 11111111b
-00110101b | 11101011b = 11111111b
-00110101b | 11101100b = 11111101b
-00110101b | 11101101b = 11111101b
-00110101b | 11101110b = 11111111b
-00110101b | 11101111b = 11111111b
-00110101b | 11110000b = 11110101b
-00110101b | 11110001b = 11110101b
-00110101b | 11110010b = 11110111b
-00110101b | 11110011b = 11110111b
-00110101b | 11110100b = 11110101b
-00110101b | 11110101b = 11110101b
-00110101b | 11110110b = 11110111b
-00110101b | 11110111b = 11110111b
-00110101b | 11111000b = 11111101b
-00110101b | 11111001b = 11111101b
-00110101b | 11111010b = 11111111b
-00110101b | 11111011b = 11111111b
-00110101b | 11111100b = 11111101b
-00110101b | 11111101b = 11111101b
-00110101b | 11111110b = 11111111b
-00110101b | 11111111b = 11111111b
-00110101b | 00000000b = 00110101b
-00110101b | 00000001b = 00110101b
-00110101b | 00000010b = 00110111b
-00110101b | 00000011b = 00110111b
-00110101b | 00000100b = 00110101b
-00110101b | 00000101b = 00110101b
-00110101b | 00000110b = 00110111b
-00110101b | 00000111b = 00110111b
-00110101b | 00001000b = 00111101b
-00110101b | 00001001b = 00111101b
-00110101b | 00001010b = 00111111b
-00110101b | 00001011b = 00111111b
-00110101b | 00001100b = 00111101b
-00110101b | 00001101b = 00111101b
-00110101b | 00001110b = 00111111b
-00110101b | 00001111b = 00111111b
-00110101b | 00010000b = 00110101b
-00110101b | 00010001b = 00110101b
-00110101b | 00010010b = 00110111b
-00110101b | 00010011b = 00110111b
-00110101b | 00010100b = 00110101b
-00110101b | 00010101b = 00110101b
-00110101b | 00010110b = 00110111b
-00110101b | 00010111b = 00110111b
-00110101b | 00011000b = 00111101b
-00110101b | 00011001b = 00111101b
-00110101b | 00011010b = 00111111b
-00110101b | 00011011b = 00111111b
-00110101b | 00011100b = 00111101b
-00110101b | 00011101b = 00111101b
-00110101b | 00011110b = 00111111b
-00110101b | 00011111b = 00111111b
-00110101b | 00100000b = 00110101b
-00110101b | 00100001b = 00110101b
-00110101b | 00100010b = 00110111b
-00110101b | 00100011b = 00110111b
-00110101b | 00100100b = 00110101b
-00110101b | 00100101b = 00110101b
-00110101b | 00100110b = 00110111b
-00110101b | 00100111b = 00110111b
-00110101b | 00101000b = 00111101b
-00110101b | 00101001b = 00111101b
-00110101b | 00101010b = 00111111b
-00110101b | 00101011b = 00111111b
-00110101b | 00101100b = 00111101b
-00110101b | 00101101b = 00111101b
-00110101b | 00101110b = 00111111b
-00110101b | 00101111b = 00111111b
-00110101b | 00110000b = 00110101b
-00110101b | 00110001b = 00110101b
-00110101b | 00110010b = 00110111b
-00110101b | 00110011b = 00110111b
-00110101b | 00110100b = 00110101b
-00110101b | 00110101b = 00110101b
-00110101b | 00110110b = 00110111b
-00110101b | 00110111b = 00110111b
-00110101b | 00111000b = 00111101b
-00110101b | 00111001b = 00111101b
-00110101b | 00111010b = 00111111b
-00110101b | 00111011b = 00111111b
-00110101b | 00111100b = 00111101b
-00110101b | 00111101b = 00111101b
-00110101b | 00111110b = 00111111b
-00110101b | 00111111b = 00111111b
-00110101b | 01000000b = 01110101b
-00110101b | 01000001b = 01110101b
-00110101b | 01000010b = 01110111b
-00110101b | 01000011b = 01110111b
-00110101b | 01000100b = 01110101b
-00110101b | 01000101b = 01110101b
-00110101b | 01000110b = 01110111b
-00110101b | 01000111b = 01110111b
-00110101b | 01001000b = 01111101b
-00110101b | 01001001b = 01111101b
-00110101b | 01001010b = 01111111b
-00110101b | 01001011b = 01111111b
-00110101b | 01001100b = 01111101b
-00110101b | 01001101b = 01111101b
-00110101b | 01001110b = 01111111b
-00110101b | 01001111b = 01111111b
-00110101b | 01010000b = 01110101b
-00110101b | 01010001b = 01110101b
-00110101b | 01010010b = 01110111b
-00110101b | 01010011b = 01110111b
-00110101b | 01010100b = 01110101b
-00110101b | 01010101b = 01110101b
-00110101b | 01010110b = 01110111b
-00110101b | 01010111b = 01110111b
-00110101b | 01011000b = 01111101b
-00110101b | 01011001b = 01111101b
-00110101b | 01011010b = 01111111b
-00110101b | 01011011b = 01111111b
-00110101b | 01011100b = 01111101b
-00110101b | 01011101b = 01111101b
-00110101b | 01011110b = 01111111b
-00110101b | 01011111b = 01111111b
-00110101b | 01100000b = 01110101b
-00110101b | 01100001b = 01110101b
-00110101b | 01100010b = 01110111b
-00110101b | 01100011b = 01110111b
-00110101b | 01100100b = 01110101b
-00110101b | 01100101b = 01110101b
-00110101b | 01100110b = 01110111b
-00110101b | 01100111b = 01110111b
-00110101b | 01101000b = 01111101b
-00110101b | 01101001b = 01111101b
-00110101b | 01101010b = 01111111b
-00110101b | 01101011b = 01111111b
-00110101b | 01101100b = 01111101b
-00110101b | 01101101b = 01111101b
-00110101b | 01101110b = 01111111b
-00110101b | 01101111b = 01111111b
-00110101b | 01110000b = 01110101b
-00110101b | 01110001b = 01110101b
-00110101b | 01110010b = 01110111b
-00110101b | 01110011b = 01110111b
-00110101b | 01110100b = 01110101b
-00110101b | 01110101b = 01110101b
-00110101b | 01110110b = 01110111b
-00110101b | 01110111b = 01110111b
-00110101b | 01111000b = 01111101b
-00110101b | 01111001b = 01111101b
-00110101b | 01111010b = 01111111b
-00110101b | 01111011b = 01111111b
-00110101b | 01111100b = 01111101b
-00110101b | 01111101b = 01111101b
-00110101b | 01111110b = 01111111b
-00110110b | 10000000b = 10110110b
-00110110b | 10000001b = 10110111b
-00110110b | 10000010b = 10110110b
-00110110b | 10000011b = 10110111b
-00110110b | 10000100b = 10110110b
-00110110b | 10000101b = 10110111b
-00110110b | 10000110b = 10110110b
-00110110b | 10000111b = 10110111b
-00110110b | 10001000b = 10111110b
-00110110b | 10001001b = 10111111b
-00110110b | 10001010b = 10111110b
-00110110b | 10001011b = 10111111b
-00110110b | 10001100b = 10111110b
-00110110b | 10001101b = 10111111b
-00110110b | 10001110b = 10111110b
-00110110b | 10001111b = 10111111b
-00110110b | 10010000b = 10110110b
-00110110b | 10010001b = 10110111b
-00110110b | 10010010b = 10110110b
-00110110b | 10010011b = 10110111b
-00110110b | 10010100b = 10110110b
-00110110b | 10010101b = 10110111b
-00110110b | 10010110b = 10110110b
-00110110b | 10010111b = 10110111b
-00110110b | 10011000b = 10111110b
-00110110b | 10011001b = 10111111b
-00110110b | 10011010b = 10111110b
-00110110b | 10011011b = 10111111b
-00110110b | 10011100b = 10111110b
-00110110b | 10011101b = 10111111b
-00110110b | 10011110b = 10111110b
-00110110b | 10011111b = 10111111b
-00110110b | 10100000b = 10110110b
-00110110b | 10100001b = 10110111b
-00110110b | 10100010b = 10110110b
-00110110b | 10100011b = 10110111b
-00110110b | 10100100b = 10110110b
-00110110b | 10100101b = 10110111b
-00110110b | 10100110b = 10110110b
-00110110b | 10100111b = 10110111b
-00110110b | 10101000b = 10111110b
-00110110b | 10101001b = 10111111b
-00110110b | 10101010b = 10111110b
-00110110b | 10101011b = 10111111b
-00110110b | 10101100b = 10111110b
-00110110b | 10101101b = 10111111b
-00110110b | 10101110b = 10111110b
-00110110b | 10101111b = 10111111b
-00110110b | 10110000b = 10110110b
-00110110b | 10110001b = 10110111b
-00110110b | 10110010b = 10110110b
-00110110b | 10110011b = 10110111b
-00110110b | 10110100b = 10110110b
-00110110b | 10110101b = 10110111b
-00110110b | 10110110b = 10110110b
-00110110b | 10110111b = 10110111b
-00110110b | 10111000b = 10111110b
-00110110b | 10111001b = 10111111b
-00110110b | 10111010b = 10111110b
-00110110b | 10111011b = 10111111b
-00110110b | 10111100b = 10111110b
-00110110b | 10111101b = 10111111b
-00110110b | 10111110b = 10111110b
-00110110b | 10111111b = 10111111b
-00110110b | 11000000b = 11110110b
-00110110b | 11000001b = 11110111b
-00110110b | 11000010b = 11110110b
-00110110b | 11000011b = 11110111b
-00110110b | 11000100b = 11110110b
-00110110b | 11000101b = 11110111b
-00110110b | 11000110b = 11110110b
-00110110b | 11000111b = 11110111b
-00110110b | 11001000b = 11111110b
-00110110b | 11001001b = 11111111b
-00110110b | 11001010b = 11111110b
-00110110b | 11001011b = 11111111b
-00110110b | 11001100b = 11111110b
-00110110b | 11001101b = 11111111b
-00110110b | 11001110b = 11111110b
-00110110b | 11001111b = 11111111b
-00110110b | 11010000b = 11110110b
-00110110b | 11010001b = 11110111b
-00110110b | 11010010b = 11110110b
-00110110b | 11010011b = 11110111b
-00110110b | 11010100b = 11110110b
-00110110b | 11010101b = 11110111b
-00110110b | 11010110b = 11110110b
-00110110b | 11010111b = 11110111b
-00110110b | 11011000b = 11111110b
-00110110b | 11011001b = 11111111b
-00110110b | 11011010b = 11111110b
-00110110b | 11011011b = 11111111b
-00110110b | 11011100b = 11111110b
-00110110b | 11011101b = 11111111b
-00110110b | 11011110b = 11111110b
-00110110b | 11011111b = 11111111b
-00110110b | 11100000b = 11110110b
-00110110b | 11100001b = 11110111b
-00110110b | 11100010b = 11110110b
-00110110b | 11100011b = 11110111b
-00110110b | 11100100b = 11110110b
-00110110b | 11100101b = 11110111b
-00110110b | 11100110b = 11110110b
-00110110b | 11100111b = 11110111b
-00110110b | 11101000b = 11111110b
-00110110b | 11101001b = 11111111b
-00110110b | 11101010b = 11111110b
-00110110b | 11101011b = 11111111b
-00110110b | 11101100b = 11111110b
-00110110b | 11101101b = 11111111b
-00110110b | 11101110b = 11111110b
-00110110b | 11101111b = 11111111b
-00110110b | 11110000b = 11110110b
-00110110b | 11110001b = 11110111b
-00110110b | 11110010b = 11110110b
-00110110b | 11110011b = 11110111b
-00110110b | 11110100b = 11110110b
-00110110b | 11110101b = 11110111b
-00110110b | 11110110b = 11110110b
-00110110b | 11110111b = 11110111b
-00110110b | 11111000b = 11111110b
-00110110b | 11111001b = 11111111b
-00110110b | 11111010b = 11111110b
-00110110b | 11111011b = 11111111b
-00110110b | 11111100b = 11111110b
-00110110b | 11111101b = 11111111b
-00110110b | 11111110b = 11111110b
-00110110b | 11111111b = 11111111b
-00110110b | 00000000b = 00110110b
-00110110b | 00000001b = 00110111b
-00110110b | 00000010b = 00110110b
-00110110b | 00000011b = 00110111b
-00110110b | 00000100b = 00110110b
-00110110b | 00000101b = 00110111b
-00110110b | 00000110b = 00110110b
-00110110b | 00000111b = 00110111b
-00110110b | 00001000b = 00111110b
-00110110b | 00001001b = 00111111b
-00110110b | 00001010b = 00111110b
-00110110b | 00001011b = 00111111b
-00110110b | 00001100b = 00111110b
-00110110b | 00001101b = 00111111b
-00110110b | 00001110b = 00111110b
-00110110b | 00001111b = 00111111b
-00110110b | 00010000b = 00110110b
-00110110b | 00010001b = 00110111b
-00110110b | 00010010b = 00110110b
-00110110b | 00010011b = 00110111b
-00110110b | 00010100b = 00110110b
-00110110b | 00010101b = 00110111b
-00110110b | 00010110b = 00110110b
-00110110b | 00010111b = 00110111b
-00110110b | 00011000b = 00111110b
-00110110b | 00011001b = 00111111b
-00110110b | 00011010b = 00111110b
-00110110b | 00011011b = 00111111b
-00110110b | 00011100b = 00111110b
-00110110b | 00011101b = 00111111b
-00110110b | 00011110b = 00111110b
-00110110b | 00011111b = 00111111b
-00110110b | 00100000b = 00110110b
-00110110b | 00100001b = 00110111b
-00110110b | 00100010b = 00110110b
-00110110b | 00100011b = 00110111b
-00110110b | 00100100b = 00110110b
-00110110b | 00100101b = 00110111b
-00110110b | 00100110b = 00110110b
-00110110b | 00100111b = 00110111b
-00110110b | 00101000b = 00111110b
-00110110b | 00101001b = 00111111b
-00110110b | 00101010b = 00111110b
-00110110b | 00101011b = 00111111b
-00110110b | 00101100b = 00111110b
-00110110b | 00101101b = 00111111b
-00110110b | 00101110b = 00111110b
-00110110b | 00101111b = 00111111b
-00110110b | 00110000b = 00110110b
-00110110b | 00110001b = 00110111b
-00110110b | 00110010b = 00110110b
-00110110b | 00110011b = 00110111b
-00110110b | 00110100b = 00110110b
-00110110b | 00110101b = 00110111b
-00110110b | 00110110b = 00110110b
-00110110b | 00110111b = 00110111b
-00110110b | 00111000b = 00111110b
-00110110b | 00111001b = 00111111b
-00110110b | 00111010b = 00111110b
-00110110b | 00111011b = 00111111b
-00110110b | 00111100b = 00111110b
-00110110b | 00111101b = 00111111b
-00110110b | 00111110b = 00111110b
-00110110b | 00111111b = 00111111b
-00110110b | 01000000b = 01110110b
-00110110b | 01000001b = 01110111b
-00110110b | 01000010b = 01110110b
-00110110b | 01000011b = 01110111b
-00110110b | 01000100b = 01110110b
-00110110b | 01000101b = 01110111b
-00110110b | 01000110b = 01110110b
-00110110b | 01000111b = 01110111b
-00110110b | 01001000b = 01111110b
-00110110b | 01001001b = 01111111b
-00110110b | 01001010b = 01111110b
-00110110b | 01001011b = 01111111b
-00110110b | 01001100b = 01111110b
-00110110b | 01001101b = 01111111b
-00110110b | 01001110b = 01111110b
-00110110b | 01001111b = 01111111b
-00110110b | 01010000b = 01110110b
-00110110b | 01010001b = 01110111b
-00110110b | 01010010b = 01110110b
-00110110b | 01010011b = 01110111b
-00110110b | 01010100b = 01110110b
-00110110b | 01010101b = 01110111b
-00110110b | 01010110b = 01110110b
-00110110b | 01010111b = 01110111b
-00110110b | 01011000b = 01111110b
-00110110b | 01011001b = 01111111b
-00110110b | 01011010b = 01111110b
-00110110b | 01011011b = 01111111b
-00110110b | 01011100b = 01111110b
-00110110b | 01011101b = 01111111b
-00110110b | 01011110b = 01111110b
-00110110b | 01011111b = 01111111b
-00110110b | 01100000b = 01110110b
-00110110b | 01100001b = 01110111b
-00110110b | 01100010b = 01110110b
-00110110b | 01100011b = 01110111b
-00110110b | 01100100b = 01110110b
-00110110b | 01100101b = 01110111b
-00110110b | 01100110b = 01110110b
-00110110b | 01100111b = 01110111b
-00110110b | 01101000b = 01111110b
-00110110b | 01101001b = 01111111b
-00110110b | 01101010b = 01111110b
-00110110b | 01101011b = 01111111b
-00110110b | 01101100b = 01111110b
-00110110b | 01101101b = 01111111b
-00110110b | 01101110b = 01111110b
-00110110b | 01101111b = 01111111b
-00110110b | 01110000b = 01110110b
-00110110b | 01110001b = 01110111b
-00110110b | 01110010b = 01110110b
-00110110b | 01110011b = 01110111b
-00110110b | 01110100b = 01110110b
-00110110b | 01110101b = 01110111b
-00110110b | 01110110b = 01110110b
-00110110b | 01110111b = 01110111b
-00110110b | 01111000b = 01111110b
-00110110b | 01111001b = 01111111b
-00110110b | 01111010b = 01111110b
-00110110b | 01111011b = 01111111b
-00110110b | 01111100b = 01111110b
-00110110b | 01111101b = 01111111b
-00110110b | 01111110b = 01111110b
-00110111b | 10000000b = 10110111b
-00110111b | 10000001b = 10110111b
-00110111b | 10000010b = 10110111b
-00110111b | 10000011b = 10110111b
-00110111b | 10000100b = 10110111b
-00110111b | 10000101b = 10110111b
-00110111b | 10000110b = 10110111b
-00110111b | 10000111b = 10110111b
-00110111b | 10001000b = 10111111b
-00110111b | 10001001b = 10111111b
-00110111b | 10001010b = 10111111b
-00110111b | 10001011b = 10111111b
-00110111b | 10001100b = 10111111b
-00110111b | 10001101b = 10111111b
-00110111b | 10001110b = 10111111b
-00110111b | 10001111b = 10111111b
-00110111b | 10010000b = 10110111b
-00110111b | 10010001b = 10110111b
-00110111b | 10010010b = 10110111b
-00110111b | 10010011b = 10110111b
-00110111b | 10010100b = 10110111b
-00110111b | 10010101b = 10110111b
-00110111b | 10010110b = 10110111b
-00110111b | 10010111b = 10110111b
-00110111b | 10011000b = 10111111b
-00110111b | 10011001b = 10111111b
-00110111b | 10011010b = 10111111b
-00110111b | 10011011b = 10111111b
-00110111b | 10011100b = 10111111b
-00110111b | 10011101b = 10111111b
-00110111b | 10011110b = 10111111b
-00110111b | 10011111b = 10111111b
-00110111b | 10100000b = 10110111b
-00110111b | 10100001b = 10110111b
-00110111b | 10100010b = 10110111b
-00110111b | 10100011b = 10110111b
-00110111b | 10100100b = 10110111b
-00110111b | 10100101b = 10110111b
-00110111b | 10100110b = 10110111b
-00110111b | 10100111b = 10110111b
-00110111b | 10101000b = 10111111b
-00110111b | 10101001b = 10111111b
-00110111b | 10101010b = 10111111b
-00110111b | 10101011b = 10111111b
-00110111b | 10101100b = 10111111b
-00110111b | 10101101b = 10111111b
-00110111b | 10101110b = 10111111b
-00110111b | 10101111b = 10111111b
-00110111b | 10110000b = 10110111b
-00110111b | 10110001b = 10110111b
-00110111b | 10110010b = 10110111b
-00110111b | 10110011b = 10110111b
-00110111b | 10110100b = 10110111b
-00110111b | 10110101b = 10110111b
-00110111b | 10110110b = 10110111b
-00110111b | 10110111b = 10110111b
-00110111b | 10111000b = 10111111b
-00110111b | 10111001b = 10111111b
-00110111b | 10111010b = 10111111b
-00110111b | 10111011b = 10111111b
-00110111b | 10111100b = 10111111b
-00110111b | 10111101b = 10111111b
-00110111b | 10111110b = 10111111b
-00110111b | 10111111b = 10111111b
-00110111b | 11000000b = 11110111b
-00110111b | 11000001b = 11110111b
-00110111b | 11000010b = 11110111b
-00110111b | 11000011b = 11110111b
-00110111b | 11000100b = 11110111b
-00110111b | 11000101b = 11110111b
-00110111b | 11000110b = 11110111b
-00110111b | 11000111b = 11110111b
-00110111b | 11001000b = 11111111b
-00110111b | 11001001b = 11111111b
-00110111b | 11001010b = 11111111b
-00110111b | 11001011b = 11111111b
-00110111b | 11001100b = 11111111b
-00110111b | 11001101b = 11111111b
-00110111b | 11001110b = 11111111b
-00110111b | 11001111b = 11111111b
-00110111b | 11010000b = 11110111b
-00110111b | 11010001b = 11110111b
-00110111b | 11010010b = 11110111b
-00110111b | 11010011b = 11110111b
-00110111b | 11010100b = 11110111b
-00110111b | 11010101b = 11110111b
-00110111b | 11010110b = 11110111b
-00110111b | 11010111b = 11110111b
-00110111b | 11011000b = 11111111b
-00110111b | 11011001b = 11111111b
-00110111b | 11011010b = 11111111b
-00110111b | 11011011b = 11111111b
-00110111b | 11011100b = 11111111b
-00110111b | 11011101b = 11111111b
-00110111b | 11011110b = 11111111b
-00110111b | 11011111b = 11111111b
-00110111b | 11100000b = 11110111b
-00110111b | 11100001b = 11110111b
-00110111b | 11100010b = 11110111b
-00110111b | 11100011b = 11110111b
-00110111b | 11100100b = 11110111b
-00110111b | 11100101b = 11110111b
-00110111b | 11100110b = 11110111b
-00110111b | 11100111b = 11110111b
-00110111b | 11101000b = 11111111b
-00110111b | 11101001b = 11111111b
-00110111b | 11101010b = 11111111b
-00110111b | 11101011b = 11111111b
-00110111b | 11101100b = 11111111b
-00110111b | 11101101b = 11111111b
-00110111b | 11101110b = 11111111b
-00110111b | 11101111b = 11111111b
-00110111b | 11110000b = 11110111b
-00110111b | 11110001b = 11110111b
-00110111b | 11110010b = 11110111b
-00110111b | 11110011b = 11110111b
-00110111b | 11110100b = 11110111b
-00110111b | 11110101b = 11110111b
-00110111b | 11110110b = 11110111b
-00110111b | 11110111b = 11110111b
-00110111b | 11111000b = 11111111b
-00110111b | 11111001b = 11111111b
-00110111b | 11111010b = 11111111b
-00110111b | 11111011b = 11111111b
-00110111b | 11111100b = 11111111b
-00110111b | 11111101b = 11111111b
-00110111b | 11111110b = 11111111b
-00110111b | 11111111b = 11111111b
-00110111b | 00000000b = 00110111b
-00110111b | 00000001b = 00110111b
-00110111b | 00000010b = 00110111b
-00110111b | 00000011b = 00110111b
-00110111b | 00000100b = 00110111b
-00110111b | 00000101b = 00110111b
-00110111b | 00000110b = 00110111b
-00110111b | 00000111b = 00110111b
-00110111b | 00001000b = 00111111b
-00110111b | 00001001b = 00111111b
-00110111b | 00001010b = 00111111b
-00110111b | 00001011b = 00111111b
-00110111b | 00001100b = 00111111b
-00110111b | 00001101b = 00111111b
-00110111b | 00001110b = 00111111b
-00110111b | 00001111b = 00111111b
-00110111b | 00010000b = 00110111b
-00110111b | 00010001b = 00110111b
-00110111b | 00010010b = 00110111b
-00110111b | 00010011b = 00110111b
-00110111b | 00010100b = 00110111b
-00110111b | 00010101b = 00110111b
-00110111b | 00010110b = 00110111b
-00110111b | 00010111b = 00110111b
-00110111b | 00011000b = 00111111b
-00110111b | 00011001b = 00111111b
-00110111b | 00011010b = 00111111b
-00110111b | 00011011b = 00111111b
-00110111b | 00011100b = 00111111b
-00110111b | 00011101b = 00111111b
-00110111b | 00011110b = 00111111b
-00110111b | 00011111b = 00111111b
-00110111b | 00100000b = 00110111b
-00110111b | 00100001b = 00110111b
-00110111b | 00100010b = 00110111b
-00110111b | 00100011b = 00110111b
-00110111b | 00100100b = 00110111b
-00110111b | 00100101b = 00110111b
-00110111b | 00100110b = 00110111b
-00110111b | 00100111b = 00110111b
-00110111b | 00101000b = 00111111b
-00110111b | 00101001b = 00111111b
-00110111b | 00101010b = 00111111b
-00110111b | 00101011b = 00111111b
-00110111b | 00101100b = 00111111b
-00110111b | 00101101b = 00111111b
-00110111b | 00101110b = 00111111b
-00110111b | 00101111b = 00111111b
-00110111b | 00110000b = 00110111b
-00110111b | 00110001b = 00110111b
-00110111b | 00110010b = 00110111b
-00110111b | 00110011b = 00110111b
-00110111b | 00110100b = 00110111b
-00110111b | 00110101b = 00110111b
-00110111b | 00110110b = 00110111b
-00110111b | 00110111b = 00110111b
-00110111b | 00111000b = 00111111b
-00110111b | 00111001b = 00111111b
-00110111b | 00111010b = 00111111b
-00110111b | 00111011b = 00111111b
-00110111b | 00111100b = 00111111b
-00110111b | 00111101b = 00111111b
-00110111b | 00111110b = 00111111b
-00110111b | 00111111b = 00111111b
-00110111b | 01000000b = 01110111b
-00110111b | 01000001b = 01110111b
-00110111b | 01000010b = 01110111b
-00110111b | 01000011b = 01110111b
-00110111b | 01000100b = 01110111b
-00110111b | 01000101b = 01110111b
-00110111b | 01000110b = 01110111b
-00110111b | 01000111b = 01110111b
-00110111b | 01001000b = 01111111b
-00110111b | 01001001b = 01111111b
-00110111b | 01001010b = 01111111b
-00110111b | 01001011b = 01111111b
-00110111b | 01001100b = 01111111b
-00110111b | 01001101b = 01111111b
-00110111b | 01001110b = 01111111b
-00110111b | 01001111b = 01111111b
-00110111b | 01010000b = 01110111b
-00110111b | 01010001b = 01110111b
-00110111b | 01010010b = 01110111b
-00110111b | 01010011b = 01110111b
-00110111b | 01010100b = 01110111b
-00110111b | 01010101b = 01110111b
-00110111b | 01010110b = 01110111b
-00110111b | 01010111b = 01110111b
-00110111b | 01011000b = 01111111b
-00110111b | 01011001b = 01111111b
-00110111b | 01011010b = 01111111b
-00110111b | 01011011b = 01111111b
-00110111b | 01011100b = 01111111b
-00110111b | 01011101b = 01111111b
-00110111b | 01011110b = 01111111b
-00110111b | 01011111b = 01111111b
-00110111b | 01100000b = 01110111b
-00110111b | 01100001b = 01110111b
-00110111b | 01100010b = 01110111b
-00110111b | 01100011b = 01110111b
-00110111b | 01100100b = 01110111b
-00110111b | 01100101b = 01110111b
-00110111b | 01100110b = 01110111b
-00110111b | 01100111b = 01110111b
-00110111b | 01101000b = 01111111b
-00110111b | 01101001b = 01111111b
-00110111b | 01101010b = 01111111b
-00110111b | 01101011b = 01111111b
-00110111b | 01101100b = 01111111b
-00110111b | 01101101b = 01111111b
-00110111b | 01101110b = 01111111b
-00110111b | 01101111b = 01111111b
-00110111b | 01110000b = 01110111b
-00110111b | 01110001b = 01110111b
-00110111b | 01110010b = 01110111b
-00110111b | 01110011b = 01110111b
-00110111b | 01110100b = 01110111b
-00110111b | 01110101b = 01110111b
-00110111b | 01110110b = 01110111b
-00110111b | 01110111b = 01110111b
-00110111b | 01111000b = 01111111b
-00110111b | 01111001b = 01111111b
-00110111b | 01111010b = 01111111b
-00110111b | 01111011b = 01111111b
-00110111b | 01111100b = 01111111b
-00110111b | 01111101b = 01111111b
-00110111b | 01111110b = 01111111b
-00111000b | 10000000b = 10111000b
-00111000b | 10000001b = 10111001b
-00111000b | 10000010b = 10111010b
-00111000b | 10000011b = 10111011b
-00111000b | 10000100b = 10111100b
-00111000b | 10000101b = 10111101b
-00111000b | 10000110b = 10111110b
-00111000b | 10000111b = 10111111b
-00111000b | 10001000b = 10111000b
-00111000b | 10001001b = 10111001b
-00111000b | 10001010b = 10111010b
-00111000b | 10001011b = 10111011b
-00111000b | 10001100b = 10111100b
-00111000b | 10001101b = 10111101b
-00111000b | 10001110b = 10111110b
-00111000b | 10001111b = 10111111b
-00111000b | 10010000b = 10111000b
-00111000b | 10010001b = 10111001b
-00111000b | 10010010b = 10111010b
-00111000b | 10010011b = 10111011b
-00111000b | 10010100b = 10111100b
-00111000b | 10010101b = 10111101b
-00111000b | 10010110b = 10111110b
-00111000b | 10010111b = 10111111b
-00111000b | 10011000b = 10111000b
-00111000b | 10011001b = 10111001b
-00111000b | 10011010b = 10111010b
-00111000b | 10011011b = 10111011b
-00111000b | 10011100b = 10111100b
-00111000b | 10011101b = 10111101b
-00111000b | 10011110b = 10111110b
-00111000b | 10011111b = 10111111b
-00111000b | 10100000b = 10111000b
-00111000b | 10100001b = 10111001b
-00111000b | 10100010b = 10111010b
-00111000b | 10100011b = 10111011b
-00111000b | 10100100b = 10111100b
-00111000b | 10100101b = 10111101b
-00111000b | 10100110b = 10111110b
-00111000b | 10100111b = 10111111b
-00111000b | 10101000b = 10111000b
-00111000b | 10101001b = 10111001b
-00111000b | 10101010b = 10111010b
-00111000b | 10101011b = 10111011b
-00111000b | 10101100b = 10111100b
-00111000b | 10101101b = 10111101b
-00111000b | 10101110b = 10111110b
-00111000b | 10101111b = 10111111b
-00111000b | 10110000b = 10111000b
-00111000b | 10110001b = 10111001b
-00111000b | 10110010b = 10111010b
-00111000b | 10110011b = 10111011b
-00111000b | 10110100b = 10111100b
-00111000b | 10110101b = 10111101b
-00111000b | 10110110b = 10111110b
-00111000b | 10110111b = 10111111b
-00111000b | 10111000b = 10111000b
-00111000b | 10111001b = 10111001b
-00111000b | 10111010b = 10111010b
-00111000b | 10111011b = 10111011b
-00111000b | 10111100b = 10111100b
-00111000b | 10111101b = 10111101b
-00111000b | 10111110b = 10111110b
-00111000b | 10111111b = 10111111b
-00111000b | 11000000b = 11111000b
-00111000b | 11000001b = 11111001b
-00111000b | 11000010b = 11111010b
-00111000b | 11000011b = 11111011b
-00111000b | 11000100b = 11111100b
-00111000b | 11000101b = 11111101b
-00111000b | 11000110b = 11111110b
-00111000b | 11000111b = 11111111b
-00111000b | 11001000b = 11111000b
-00111000b | 11001001b = 11111001b
-00111000b | 11001010b = 11111010b
-00111000b | 11001011b = 11111011b
-00111000b | 11001100b = 11111100b
-00111000b | 11001101b = 11111101b
-00111000b | 11001110b = 11111110b
-00111000b | 11001111b = 11111111b
-00111000b | 11010000b = 11111000b
-00111000b | 11010001b = 11111001b
-00111000b | 11010010b = 11111010b
-00111000b | 11010011b = 11111011b
-00111000b | 11010100b = 11111100b
-00111000b | 11010101b = 11111101b
-00111000b | 11010110b = 11111110b
-00111000b | 11010111b = 11111111b
-00111000b | 11011000b = 11111000b
-00111000b | 11011001b = 11111001b
-00111000b | 11011010b = 11111010b
-00111000b | 11011011b = 11111011b
-00111000b | 11011100b = 11111100b
-00111000b | 11011101b = 11111101b
-00111000b | 11011110b = 11111110b
-00111000b | 11011111b = 11111111b
-00111000b | 11100000b = 11111000b
-00111000b | 11100001b = 11111001b
-00111000b | 11100010b = 11111010b
-00111000b | 11100011b = 11111011b
-00111000b | 11100100b = 11111100b
-00111000b | 11100101b = 11111101b
-00111000b | 11100110b = 11111110b
-00111000b | 11100111b = 11111111b
-00111000b | 11101000b = 11111000b
-00111000b | 11101001b = 11111001b
-00111000b | 11101010b = 11111010b
-00111000b | 11101011b = 11111011b
-00111000b | 11101100b = 11111100b
-00111000b | 11101101b = 11111101b
-00111000b | 11101110b = 11111110b
-00111000b | 11101111b = 11111111b
-00111000b | 11110000b = 11111000b
-00111000b | 11110001b = 11111001b
-00111000b | 11110010b = 11111010b
-00111000b | 11110011b = 11111011b
-00111000b | 11110100b = 11111100b
-00111000b | 11110101b = 11111101b
-00111000b | 11110110b = 11111110b
-00111000b | 11110111b = 11111111b
-00111000b | 11111000b = 11111000b
-00111000b | 11111001b = 11111001b
-00111000b | 11111010b = 11111010b
-00111000b | 11111011b = 11111011b
-00111000b | 11111100b = 11111100b
-00111000b | 11111101b = 11111101b
-00111000b | 11111110b = 11111110b
-00111000b | 11111111b = 11111111b
-00111000b | 00000000b = 00111000b
-00111000b | 00000001b = 00111001b
-00111000b | 00000010b = 00111010b
-00111000b | 00000011b = 00111011b
-00111000b | 00000100b = 00111100b
-00111000b | 00000101b = 00111101b
-00111000b | 00000110b = 00111110b
-00111000b | 00000111b = 00111111b
-00111000b | 00001000b = 00111000b
-00111000b | 00001001b = 00111001b
-00111000b | 00001010b = 00111010b
-00111000b | 00001011b = 00111011b
-00111000b | 00001100b = 00111100b
-00111000b | 00001101b = 00111101b
-00111000b | 00001110b = 00111110b
-00111000b | 00001111b = 00111111b
-00111000b | 00010000b = 00111000b
-00111000b | 00010001b = 00111001b
-00111000b | 00010010b = 00111010b
-00111000b | 00010011b = 00111011b
-00111000b | 00010100b = 00111100b
-00111000b | 00010101b = 00111101b
-00111000b | 00010110b = 00111110b
-00111000b | 00010111b = 00111111b
-00111000b | 00011000b = 00111000b
-00111000b | 00011001b = 00111001b
-00111000b | 00011010b = 00111010b
-00111000b | 00011011b = 00111011b
-00111000b | 00011100b = 00111100b
-00111000b | 00011101b = 00111101b
-00111000b | 00011110b = 00111110b
-00111000b | 00011111b = 00111111b
-00111000b | 00100000b = 00111000b
-00111000b | 00100001b = 00111001b
-00111000b | 00100010b = 00111010b
-00111000b | 00100011b = 00111011b
-00111000b | 00100100b = 00111100b
-00111000b | 00100101b = 00111101b
-00111000b | 00100110b = 00111110b
-00111000b | 00100111b = 00111111b
-00111000b | 00101000b = 00111000b
-00111000b | 00101001b = 00111001b
-00111000b | 00101010b = 00111010b
-00111000b | 00101011b = 00111011b
-00111000b | 00101100b = 00111100b
-00111000b | 00101101b = 00111101b
-00111000b | 00101110b = 00111110b
-00111000b | 00101111b = 00111111b
-00111000b | 00110000b = 00111000b
-00111000b | 00110001b = 00111001b
-00111000b | 00110010b = 00111010b
-00111000b | 00110011b = 00111011b
-00111000b | 00110100b = 00111100b
-00111000b | 00110101b = 00111101b
-00111000b | 00110110b = 00111110b
-00111000b | 00110111b = 00111111b
-00111000b | 00111000b = 00111000b
-00111000b | 00111001b = 00111001b
-00111000b | 00111010b = 00111010b
-00111000b | 00111011b = 00111011b
-00111000b | 00111100b = 00111100b
-00111000b | 00111101b = 00111101b
-00111000b | 00111110b = 00111110b
-00111000b | 00111111b = 00111111b
-00111000b | 01000000b = 01111000b
-00111000b | 01000001b = 01111001b
-00111000b | 01000010b = 01111010b
-00111000b | 01000011b = 01111011b
-00111000b | 01000100b = 01111100b
-00111000b | 01000101b = 01111101b
-00111000b | 01000110b = 01111110b
-00111000b | 01000111b = 01111111b
-00111000b | 01001000b = 01111000b
-00111000b | 01001001b = 01111001b
-00111000b | 01001010b = 01111010b
-00111000b | 01001011b = 01111011b
-00111000b | 01001100b = 01111100b
-00111000b | 01001101b = 01111101b
-00111000b | 01001110b = 01111110b
-00111000b | 01001111b = 01111111b
-00111000b | 01010000b = 01111000b
-00111000b | 01010001b = 01111001b
-00111000b | 01010010b = 01111010b
-00111000b | 01010011b = 01111011b
-00111000b | 01010100b = 01111100b
-00111000b | 01010101b = 01111101b
-00111000b | 01010110b = 01111110b
-00111000b | 01010111b = 01111111b
-00111000b | 01011000b = 01111000b
-00111000b | 01011001b = 01111001b
-00111000b | 01011010b = 01111010b
-00111000b | 01011011b = 01111011b
-00111000b | 01011100b = 01111100b
-00111000b | 01011101b = 01111101b
-00111000b | 01011110b = 01111110b
-00111000b | 01011111b = 01111111b
-00111000b | 01100000b = 01111000b
-00111000b | 01100001b = 01111001b
-00111000b | 01100010b = 01111010b
-00111000b | 01100011b = 01111011b
-00111000b | 01100100b = 01111100b
-00111000b | 01100101b = 01111101b
-00111000b | 01100110b = 01111110b
-00111000b | 01100111b = 01111111b
-00111000b | 01101000b = 01111000b
-00111000b | 01101001b = 01111001b
-00111000b | 01101010b = 01111010b
-00111000b | 01101011b = 01111011b
-00111000b | 01101100b = 01111100b
-00111000b | 01101101b = 01111101b
-00111000b | 01101110b = 01111110b
-00111000b | 01101111b = 01111111b
-00111000b | 01110000b = 01111000b
-00111000b | 01110001b = 01111001b
-00111000b | 01110010b = 01111010b
-00111000b | 01110011b = 01111011b
-00111000b | 01110100b = 01111100b
-00111000b | 01110101b = 01111101b
-00111000b | 01110110b = 01111110b
-00111000b | 01110111b = 01111111b
-00111000b | 01111000b = 01111000b
-00111000b | 01111001b = 01111001b
-00111000b | 01111010b = 01111010b
-00111000b | 01111011b = 01111011b
-00111000b | 01111100b = 01111100b
-00111000b | 01111101b = 01111101b
-00111000b | 01111110b = 01111110b
-00111001b | 10000000b = 10111001b
-00111001b | 10000001b = 10111001b
-00111001b | 10000010b = 10111011b
-00111001b | 10000011b = 10111011b
-00111001b | 10000100b = 10111101b
-00111001b | 10000101b = 10111101b
-00111001b | 10000110b = 10111111b
-00111001b | 10000111b = 10111111b
-00111001b | 10001000b = 10111001b
-00111001b | 10001001b = 10111001b
-00111001b | 10001010b = 10111011b
-00111001b | 10001011b = 10111011b
-00111001b | 10001100b = 10111101b
-00111001b | 10001101b = 10111101b
-00111001b | 10001110b = 10111111b
-00111001b | 10001111b = 10111111b
-00111001b | 10010000b = 10111001b
-00111001b | 10010001b = 10111001b
-00111001b | 10010010b = 10111011b
-00111001b | 10010011b = 10111011b
-00111001b | 10010100b = 10111101b
-00111001b | 10010101b = 10111101b
-00111001b | 10010110b = 10111111b
-00111001b | 10010111b = 10111111b
-00111001b | 10011000b = 10111001b
-00111001b | 10011001b = 10111001b
-00111001b | 10011010b = 10111011b
-00111001b | 10011011b = 10111011b
-00111001b | 10011100b = 10111101b
-00111001b | 10011101b = 10111101b
-00111001b | 10011110b = 10111111b
-00111001b | 10011111b = 10111111b
-00111001b | 10100000b = 10111001b
-00111001b | 10100001b = 10111001b
-00111001b | 10100010b = 10111011b
-00111001b | 10100011b = 10111011b
-00111001b | 10100100b = 10111101b
-00111001b | 10100101b = 10111101b
-00111001b | 10100110b = 10111111b
-00111001b | 10100111b = 10111111b
-00111001b | 10101000b = 10111001b
-00111001b | 10101001b = 10111001b
-00111001b | 10101010b = 10111011b
-00111001b | 10101011b = 10111011b
-00111001b | 10101100b = 10111101b
-00111001b | 10101101b = 10111101b
-00111001b | 10101110b = 10111111b
-00111001b | 10101111b = 10111111b
-00111001b | 10110000b = 10111001b
-00111001b | 10110001b = 10111001b
-00111001b | 10110010b = 10111011b
-00111001b | 10110011b = 10111011b
-00111001b | 10110100b = 10111101b
-00111001b | 10110101b = 10111101b
-00111001b | 10110110b = 10111111b
-00111001b | 10110111b = 10111111b
-00111001b | 10111000b = 10111001b
-00111001b | 10111001b = 10111001b
-00111001b | 10111010b = 10111011b
-00111001b | 10111011b = 10111011b
-00111001b | 10111100b = 10111101b
-00111001b | 10111101b = 10111101b
-00111001b | 10111110b = 10111111b
-00111001b | 10111111b = 10111111b
-00111001b | 11000000b = 11111001b
-00111001b | 11000001b = 11111001b
-00111001b | 11000010b = 11111011b
-00111001b | 11000011b = 11111011b
-00111001b | 11000100b = 11111101b
-00111001b | 11000101b = 11111101b
-00111001b | 11000110b = 11111111b
-00111001b | 11000111b = 11111111b
-00111001b | 11001000b = 11111001b
-00111001b | 11001001b = 11111001b
-00111001b | 11001010b = 11111011b
-00111001b | 11001011b = 11111011b
-00111001b | 11001100b = 11111101b
-00111001b | 11001101b = 11111101b
-00111001b | 11001110b = 11111111b
-00111001b | 11001111b = 11111111b
-00111001b | 11010000b = 11111001b
-00111001b | 11010001b = 11111001b
-00111001b | 11010010b = 11111011b
-00111001b | 11010011b = 11111011b
-00111001b | 11010100b = 11111101b
-00111001b | 11010101b = 11111101b
-00111001b | 11010110b = 11111111b
-00111001b | 11010111b = 11111111b
-00111001b | 11011000b = 11111001b
-00111001b | 11011001b = 11111001b
-00111001b | 11011010b = 11111011b
-00111001b | 11011011b = 11111011b
-00111001b | 11011100b = 11111101b
-00111001b | 11011101b = 11111101b
-00111001b | 11011110b = 11111111b
-00111001b | 11011111b = 11111111b
-00111001b | 11100000b = 11111001b
-00111001b | 11100001b = 11111001b
-00111001b | 11100010b = 11111011b
-00111001b | 11100011b = 11111011b
-00111001b | 11100100b = 11111101b
-00111001b | 11100101b = 11111101b
-00111001b | 11100110b = 11111111b
-00111001b | 11100111b = 11111111b
-00111001b | 11101000b = 11111001b
-00111001b | 11101001b = 11111001b
-00111001b | 11101010b = 11111011b
-00111001b | 11101011b = 11111011b
-00111001b | 11101100b = 11111101b
-00111001b | 11101101b = 11111101b
-00111001b | 11101110b = 11111111b
-00111001b | 11101111b = 11111111b
-00111001b | 11110000b = 11111001b
-00111001b | 11110001b = 11111001b
-00111001b | 11110010b = 11111011b
-00111001b | 11110011b = 11111011b
-00111001b | 11110100b = 11111101b
-00111001b | 11110101b = 11111101b
-00111001b | 11110110b = 11111111b
-00111001b | 11110111b = 11111111b
-00111001b | 11111000b = 11111001b
-00111001b | 11111001b = 11111001b
-00111001b | 11111010b = 11111011b
-00111001b | 11111011b = 11111011b
-00111001b | 11111100b = 11111101b
-00111001b | 11111101b = 11111101b
-00111001b | 11111110b = 11111111b
-00111001b | 11111111b = 11111111b
-00111001b | 00000000b = 00111001b
-00111001b | 00000001b = 00111001b
-00111001b | 00000010b = 00111011b
-00111001b | 00000011b = 00111011b
-00111001b | 00000100b = 00111101b
-00111001b | 00000101b = 00111101b
-00111001b | 00000110b = 00111111b
-00111001b | 00000111b = 00111111b
-00111001b | 00001000b = 00111001b
-00111001b | 00001001b = 00111001b
-00111001b | 00001010b = 00111011b
-00111001b | 00001011b = 00111011b
-00111001b | 00001100b = 00111101b
-00111001b | 00001101b = 00111101b
-00111001b | 00001110b = 00111111b
-00111001b | 00001111b = 00111111b
-00111001b | 00010000b = 00111001b
-00111001b | 00010001b = 00111001b
-00111001b | 00010010b = 00111011b
-00111001b | 00010011b = 00111011b
-00111001b | 00010100b = 00111101b
-00111001b | 00010101b = 00111101b
-00111001b | 00010110b = 00111111b
-00111001b | 00010111b = 00111111b
-00111001b | 00011000b = 00111001b
-00111001b | 00011001b = 00111001b
-00111001b | 00011010b = 00111011b
-00111001b | 00011011b = 00111011b
-00111001b | 00011100b = 00111101b
-00111001b | 00011101b = 00111101b
-00111001b | 00011110b = 00111111b
-00111001b | 00011111b = 00111111b
-00111001b | 00100000b = 00111001b
-00111001b | 00100001b = 00111001b
-00111001b | 00100010b = 00111011b
-00111001b | 00100011b = 00111011b
-00111001b | 00100100b = 00111101b
-00111001b | 00100101b = 00111101b
-00111001b | 00100110b = 00111111b
-00111001b | 00100111b = 00111111b
-00111001b | 00101000b = 00111001b
-00111001b | 00101001b = 00111001b
-00111001b | 00101010b = 00111011b
-00111001b | 00101011b = 00111011b
-00111001b | 00101100b = 00111101b
-00111001b | 00101101b = 00111101b
-00111001b | 00101110b = 00111111b
-00111001b | 00101111b = 00111111b
-00111001b | 00110000b = 00111001b
-00111001b | 00110001b = 00111001b
-00111001b | 00110010b = 00111011b
-00111001b | 00110011b = 00111011b
-00111001b | 00110100b = 00111101b
-00111001b | 00110101b = 00111101b
-00111001b | 00110110b = 00111111b
-00111001b | 00110111b = 00111111b
-00111001b | 00111000b = 00111001b
-00111001b | 00111001b = 00111001b
-00111001b | 00111010b = 00111011b
-00111001b | 00111011b = 00111011b
-00111001b | 00111100b = 00111101b
-00111001b | 00111101b = 00111101b
-00111001b | 00111110b = 00111111b
-00111001b | 00111111b = 00111111b
-00111001b | 01000000b = 01111001b
-00111001b | 01000001b = 01111001b
-00111001b | 01000010b = 01111011b
-00111001b | 01000011b = 01111011b
-00111001b | 01000100b = 01111101b
-00111001b | 01000101b = 01111101b
-00111001b | 01000110b = 01111111b
-00111001b | 01000111b = 01111111b
-00111001b | 01001000b = 01111001b
-00111001b | 01001001b = 01111001b
-00111001b | 01001010b = 01111011b
-00111001b | 01001011b = 01111011b
-00111001b | 01001100b = 01111101b
-00111001b | 01001101b = 01111101b
-00111001b | 01001110b = 01111111b
-00111001b | 01001111b = 01111111b
-00111001b | 01010000b = 01111001b
-00111001b | 01010001b = 01111001b
-00111001b | 01010010b = 01111011b
-00111001b | 01010011b = 01111011b
-00111001b | 01010100b = 01111101b
-00111001b | 01010101b = 01111101b
-00111001b | 01010110b = 01111111b
-00111001b | 01010111b = 01111111b
-00111001b | 01011000b = 01111001b
-00111001b | 01011001b = 01111001b
-00111001b | 01011010b = 01111011b
-00111001b | 01011011b = 01111011b
-00111001b | 01011100b = 01111101b
-00111001b | 01011101b = 01111101b
-00111001b | 01011110b = 01111111b
-00111001b | 01011111b = 01111111b
-00111001b | 01100000b = 01111001b
-00111001b | 01100001b = 01111001b
-00111001b | 01100010b = 01111011b
-00111001b | 01100011b = 01111011b
-00111001b | 01100100b = 01111101b
-00111001b | 01100101b = 01111101b
-00111001b | 01100110b = 01111111b
-00111001b | 01100111b = 01111111b
-00111001b | 01101000b = 01111001b
-00111001b | 01101001b = 01111001b
-00111001b | 01101010b = 01111011b
-00111001b | 01101011b = 01111011b
-00111001b | 01101100b = 01111101b
-00111001b | 01101101b = 01111101b
-00111001b | 01101110b = 01111111b
-00111001b | 01101111b = 01111111b
-00111001b | 01110000b = 01111001b
-00111001b | 01110001b = 01111001b
-00111001b | 01110010b = 01111011b
-00111001b | 01110011b = 01111011b
-00111001b | 01110100b = 01111101b
-00111001b | 01110101b = 01111101b
-00111001b | 01110110b = 01111111b
-00111001b | 01110111b = 01111111b
-00111001b | 01111000b = 01111001b
-00111001b | 01111001b = 01111001b
-00111001b | 01111010b = 01111011b
-00111001b | 01111011b = 01111011b
-00111001b | 01111100b = 01111101b
-00111001b | 01111101b = 01111101b
-00111001b | 01111110b = 01111111b
-00111010b | 10000000b = 10111010b
-00111010b | 10000001b = 10111011b
-00111010b | 10000010b = 10111010b
-00111010b | 10000011b = 10111011b
-00111010b | 10000100b = 10111110b
-00111010b | 10000101b = 10111111b
-00111010b | 10000110b = 10111110b
-00111010b | 10000111b = 10111111b
-00111010b | 10001000b = 10111010b
-00111010b | 10001001b = 10111011b
-00111010b | 10001010b = 10111010b
-00111010b | 10001011b = 10111011b
-00111010b | 10001100b = 10111110b
-00111010b | 10001101b = 10111111b
-00111010b | 10001110b = 10111110b
-00111010b | 10001111b = 10111111b
-00111010b | 10010000b = 10111010b
-00111010b | 10010001b = 10111011b
-00111010b | 10010010b = 10111010b
-00111010b | 10010011b = 10111011b
-00111010b | 10010100b = 10111110b
-00111010b | 10010101b = 10111111b
-00111010b | 10010110b = 10111110b
-00111010b | 10010111b = 10111111b
-00111010b | 10011000b = 10111010b
-00111010b | 10011001b = 10111011b
-00111010b | 10011010b = 10111010b
-00111010b | 10011011b = 10111011b
-00111010b | 10011100b = 10111110b
-00111010b | 10011101b = 10111111b
-00111010b | 10011110b = 10111110b
-00111010b | 10011111b = 10111111b
-00111010b | 10100000b = 10111010b
-00111010b | 10100001b = 10111011b
-00111010b | 10100010b = 10111010b
-00111010b | 10100011b = 10111011b
-00111010b | 10100100b = 10111110b
-00111010b | 10100101b = 10111111b
-00111010b | 10100110b = 10111110b
-00111010b | 10100111b = 10111111b
-00111010b | 10101000b = 10111010b
-00111010b | 10101001b = 10111011b
-00111010b | 10101010b = 10111010b
-00111010b | 10101011b = 10111011b
-00111010b | 10101100b = 10111110b
-00111010b | 10101101b = 10111111b
-00111010b | 10101110b = 10111110b
-00111010b | 10101111b = 10111111b
-00111010b | 10110000b = 10111010b
-00111010b | 10110001b = 10111011b
-00111010b | 10110010b = 10111010b
-00111010b | 10110011b = 10111011b
-00111010b | 10110100b = 10111110b
-00111010b | 10110101b = 10111111b
-00111010b | 10110110b = 10111110b
-00111010b | 10110111b = 10111111b
-00111010b | 10111000b = 10111010b
-00111010b | 10111001b = 10111011b
-00111010b | 10111010b = 10111010b
-00111010b | 10111011b = 10111011b
-00111010b | 10111100b = 10111110b
-00111010b | 10111101b = 10111111b
-00111010b | 10111110b = 10111110b
-00111010b | 10111111b = 10111111b
-00111010b | 11000000b = 11111010b
-00111010b | 11000001b = 11111011b
-00111010b | 11000010b = 11111010b
-00111010b | 11000011b = 11111011b
-00111010b | 11000100b = 11111110b
-00111010b | 11000101b = 11111111b
-00111010b | 11000110b = 11111110b
-00111010b | 11000111b = 11111111b
-00111010b | 11001000b = 11111010b
-00111010b | 11001001b = 11111011b
-00111010b | 11001010b = 11111010b
-00111010b | 11001011b = 11111011b
-00111010b | 11001100b = 11111110b
-00111010b | 11001101b = 11111111b
-00111010b | 11001110b = 11111110b
-00111010b | 11001111b = 11111111b
-00111010b | 11010000b = 11111010b
-00111010b | 11010001b = 11111011b
-00111010b | 11010010b = 11111010b
-00111010b | 11010011b = 11111011b
-00111010b | 11010100b = 11111110b
-00111010b | 11010101b = 11111111b
-00111010b | 11010110b = 11111110b
-00111010b | 11010111b = 11111111b
-00111010b | 11011000b = 11111010b
-00111010b | 11011001b = 11111011b
-00111010b | 11011010b = 11111010b
-00111010b | 11011011b = 11111011b
-00111010b | 11011100b = 11111110b
-00111010b | 11011101b = 11111111b
-00111010b | 11011110b = 11111110b
-00111010b | 11011111b = 11111111b
-00111010b | 11100000b = 11111010b
-00111010b | 11100001b = 11111011b
-00111010b | 11100010b = 11111010b
-00111010b | 11100011b = 11111011b
-00111010b | 11100100b = 11111110b
-00111010b | 11100101b = 11111111b
-00111010b | 11100110b = 11111110b
-00111010b | 11100111b = 11111111b
-00111010b | 11101000b = 11111010b
-00111010b | 11101001b = 11111011b
-00111010b | 11101010b = 11111010b
-00111010b | 11101011b = 11111011b
-00111010b | 11101100b = 11111110b
-00111010b | 11101101b = 11111111b
-00111010b | 11101110b = 11111110b
-00111010b | 11101111b = 11111111b
-00111010b | 11110000b = 11111010b
-00111010b | 11110001b = 11111011b
-00111010b | 11110010b = 11111010b
-00111010b | 11110011b = 11111011b
-00111010b | 11110100b = 11111110b
-00111010b | 11110101b = 11111111b
-00111010b | 11110110b = 11111110b
-00111010b | 11110111b = 11111111b
-00111010b | 11111000b = 11111010b
-00111010b | 11111001b = 11111011b
-00111010b | 11111010b = 11111010b
-00111010b | 11111011b = 11111011b
-00111010b | 11111100b = 11111110b
-00111010b | 11111101b = 11111111b
-00111010b | 11111110b = 11111110b
-00111010b | 11111111b = 11111111b
-00111010b | 00000000b = 00111010b
-00111010b | 00000001b = 00111011b
-00111010b | 00000010b = 00111010b
-00111010b | 00000011b = 00111011b
-00111010b | 00000100b = 00111110b
-00111010b | 00000101b = 00111111b
-00111010b | 00000110b = 00111110b
-00111010b | 00000111b = 00111111b
-00111010b | 00001000b = 00111010b
-00111010b | 00001001b = 00111011b
-00111010b | 00001010b = 00111010b
-00111010b | 00001011b = 00111011b
-00111010b | 00001100b = 00111110b
-00111010b | 00001101b = 00111111b
-00111010b | 00001110b = 00111110b
-00111010b | 00001111b = 00111111b
-00111010b | 00010000b = 00111010b
-00111010b | 00010001b = 00111011b
-00111010b | 00010010b = 00111010b
-00111010b | 00010011b = 00111011b
-00111010b | 00010100b = 00111110b
-00111010b | 00010101b = 00111111b
-00111010b | 00010110b = 00111110b
-00111010b | 00010111b = 00111111b
-00111010b | 00011000b = 00111010b
-00111010b | 00011001b = 00111011b
-00111010b | 00011010b = 00111010b
-00111010b | 00011011b = 00111011b
-00111010b | 00011100b = 00111110b
-00111010b | 00011101b = 00111111b
-00111010b | 00011110b = 00111110b
-00111010b | 00011111b = 00111111b
-00111010b | 00100000b = 00111010b
-00111010b | 00100001b = 00111011b
-00111010b | 00100010b = 00111010b
-00111010b | 00100011b = 00111011b
-00111010b | 00100100b = 00111110b
-00111010b | 00100101b = 00111111b
-00111010b | 00100110b = 00111110b
-00111010b | 00100111b = 00111111b
-00111010b | 00101000b = 00111010b
-00111010b | 00101001b = 00111011b
-00111010b | 00101010b = 00111010b
-00111010b | 00101011b = 00111011b
-00111010b | 00101100b = 00111110b
-00111010b | 00101101b = 00111111b
-00111010b | 00101110b = 00111110b
-00111010b | 00101111b = 00111111b
-00111010b | 00110000b = 00111010b
-00111010b | 00110001b = 00111011b
-00111010b | 00110010b = 00111010b
-00111010b | 00110011b = 00111011b
-00111010b | 00110100b = 00111110b
-00111010b | 00110101b = 00111111b
-00111010b | 00110110b = 00111110b
-00111010b | 00110111b = 00111111b
-00111010b | 00111000b = 00111010b
-00111010b | 00111001b = 00111011b
-00111010b | 00111010b = 00111010b
-00111010b | 00111011b = 00111011b
-00111010b | 00111100b = 00111110b
-00111010b | 00111101b = 00111111b
-00111010b | 00111110b = 00111110b
-00111010b | 00111111b = 00111111b
-00111010b | 01000000b = 01111010b
-00111010b | 01000001b = 01111011b
-00111010b | 01000010b = 01111010b
-00111010b | 01000011b = 01111011b
-00111010b | 01000100b = 01111110b
-00111010b | 01000101b = 01111111b
-00111010b | 01000110b = 01111110b
-00111010b | 01000111b = 01111111b
-00111010b | 01001000b = 01111010b
-00111010b | 01001001b = 01111011b
-00111010b | 01001010b = 01111010b
-00111010b | 01001011b = 01111011b
-00111010b | 01001100b = 01111110b
-00111010b | 01001101b = 01111111b
-00111010b | 01001110b = 01111110b
-00111010b | 01001111b = 01111111b
-00111010b | 01010000b = 01111010b
-00111010b | 01010001b = 01111011b
-00111010b | 01010010b = 01111010b
-00111010b | 01010011b = 01111011b
-00111010b | 01010100b = 01111110b
-00111010b | 01010101b = 01111111b
-00111010b | 01010110b = 01111110b
-00111010b | 01010111b = 01111111b
-00111010b | 01011000b = 01111010b
-00111010b | 01011001b = 01111011b
-00111010b | 01011010b = 01111010b
-00111010b | 01011011b = 01111011b
-00111010b | 01011100b = 01111110b
-00111010b | 01011101b = 01111111b
-00111010b | 01011110b = 01111110b
-00111010b | 01011111b = 01111111b
-00111010b | 01100000b = 01111010b
-00111010b | 01100001b = 01111011b
-00111010b | 01100010b = 01111010b
-00111010b | 01100011b = 01111011b
-00111010b | 01100100b = 01111110b
-00111010b | 01100101b = 01111111b
-00111010b | 01100110b = 01111110b
-00111010b | 01100111b = 01111111b
-00111010b | 01101000b = 01111010b
-00111010b | 01101001b = 01111011b
-00111010b | 01101010b = 01111010b
-00111010b | 01101011b = 01111011b
-00111010b | 01101100b = 01111110b
-00111010b | 01101101b = 01111111b
-00111010b | 01101110b = 01111110b
-00111010b | 01101111b = 01111111b
-00111010b | 01110000b = 01111010b
-00111010b | 01110001b = 01111011b
-00111010b | 01110010b = 01111010b
-00111010b | 01110011b = 01111011b
-00111010b | 01110100b = 01111110b
-00111010b | 01110101b = 01111111b
-00111010b | 01110110b = 01111110b
-00111010b | 01110111b = 01111111b
-00111010b | 01111000b = 01111010b
-00111010b | 01111001b = 01111011b
-00111010b | 01111010b = 01111010b
-00111010b | 01111011b = 01111011b
-00111010b | 01111100b = 01111110b
-00111010b | 01111101b = 01111111b
-00111010b | 01111110b = 01111110b
-00111011b | 10000000b = 10111011b
-00111011b | 10000001b = 10111011b
-00111011b | 10000010b = 10111011b
-00111011b | 10000011b = 10111011b
-00111011b | 10000100b = 10111111b
-00111011b | 10000101b = 10111111b
-00111011b | 10000110b = 10111111b
-00111011b | 10000111b = 10111111b
-00111011b | 10001000b = 10111011b
-00111011b | 10001001b = 10111011b
-00111011b | 10001010b = 10111011b
-00111011b | 10001011b = 10111011b
-00111011b | 10001100b = 10111111b
-00111011b | 10001101b = 10111111b
-00111011b | 10001110b = 10111111b
-00111011b | 10001111b = 10111111b
-00111011b | 10010000b = 10111011b
-00111011b | 10010001b = 10111011b
-00111011b | 10010010b = 10111011b
-00111011b | 10010011b = 10111011b
-00111011b | 10010100b = 10111111b
-00111011b | 10010101b = 10111111b
-00111011b | 10010110b = 10111111b
-00111011b | 10010111b = 10111111b
-00111011b | 10011000b = 10111011b
-00111011b | 10011001b = 10111011b
-00111011b | 10011010b = 10111011b
-00111011b | 10011011b = 10111011b
-00111011b | 10011100b = 10111111b
-00111011b | 10011101b = 10111111b
-00111011b | 10011110b = 10111111b
-00111011b | 10011111b = 10111111b
-00111011b | 10100000b = 10111011b
-00111011b | 10100001b = 10111011b
-00111011b | 10100010b = 10111011b
-00111011b | 10100011b = 10111011b
-00111011b | 10100100b = 10111111b
-00111011b | 10100101b = 10111111b
-00111011b | 10100110b = 10111111b
-00111011b | 10100111b = 10111111b
-00111011b | 10101000b = 10111011b
-00111011b | 10101001b = 10111011b
-00111011b | 10101010b = 10111011b
-00111011b | 10101011b = 10111011b
-00111011b | 10101100b = 10111111b
-00111011b | 10101101b = 10111111b
-00111011b | 10101110b = 10111111b
-00111011b | 10101111b = 10111111b
-00111011b | 10110000b = 10111011b
-00111011b | 10110001b = 10111011b
-00111011b | 10110010b = 10111011b
-00111011b | 10110011b = 10111011b
-00111011b | 10110100b = 10111111b
-00111011b | 10110101b = 10111111b
-00111011b | 10110110b = 10111111b
-00111011b | 10110111b = 10111111b
-00111011b | 10111000b = 10111011b
-00111011b | 10111001b = 10111011b
-00111011b | 10111010b = 10111011b
-00111011b | 10111011b = 10111011b
-00111011b | 10111100b = 10111111b
-00111011b | 10111101b = 10111111b
-00111011b | 10111110b = 10111111b
-00111011b | 10111111b = 10111111b
-00111011b | 11000000b = 11111011b
-00111011b | 11000001b = 11111011b
-00111011b | 11000010b = 11111011b
-00111011b | 11000011b = 11111011b
-00111011b | 11000100b = 11111111b
-00111011b | 11000101b = 11111111b
-00111011b | 11000110b = 11111111b
-00111011b | 11000111b = 11111111b
-00111011b | 11001000b = 11111011b
-00111011b | 11001001b = 11111011b
-00111011b | 11001010b = 11111011b
-00111011b | 11001011b = 11111011b
-00111011b | 11001100b = 11111111b
-00111011b | 11001101b = 11111111b
-00111011b | 11001110b = 11111111b
-00111011b | 11001111b = 11111111b
-00111011b | 11010000b = 11111011b
-00111011b | 11010001b = 11111011b
-00111011b | 11010010b = 11111011b
-00111011b | 11010011b = 11111011b
-00111011b | 11010100b = 11111111b
-00111011b | 11010101b = 11111111b
-00111011b | 11010110b = 11111111b
-00111011b | 11010111b = 11111111b
-00111011b | 11011000b = 11111011b
-00111011b | 11011001b = 11111011b
-00111011b | 11011010b = 11111011b
-00111011b | 11011011b = 11111011b
-00111011b | 11011100b = 11111111b
-00111011b | 11011101b = 11111111b
-00111011b | 11011110b = 11111111b
-00111011b | 11011111b = 11111111b
-00111011b | 11100000b = 11111011b
-00111011b | 11100001b = 11111011b
-00111011b | 11100010b = 11111011b
-00111011b | 11100011b = 11111011b
-00111011b | 11100100b = 11111111b
-00111011b | 11100101b = 11111111b
-00111011b | 11100110b = 11111111b
-00111011b | 11100111b = 11111111b
-00111011b | 11101000b = 11111011b
-00111011b | 11101001b = 11111011b
-00111011b | 11101010b = 11111011b
-00111011b | 11101011b = 11111011b
-00111011b | 11101100b = 11111111b
-00111011b | 11101101b = 11111111b
-00111011b | 11101110b = 11111111b
-00111011b | 11101111b = 11111111b
-00111011b | 11110000b = 11111011b
-00111011b | 11110001b = 11111011b
-00111011b | 11110010b = 11111011b
-00111011b | 11110011b = 11111011b
-00111011b | 11110100b = 11111111b
-00111011b | 11110101b = 11111111b
-00111011b | 11110110b = 11111111b
-00111011b | 11110111b = 11111111b
-00111011b | 11111000b = 11111011b
-00111011b | 11111001b = 11111011b
-00111011b | 11111010b = 11111011b
-00111011b | 11111011b = 11111011b
-00111011b | 11111100b = 11111111b
-00111011b | 11111101b = 11111111b
-00111011b | 11111110b = 11111111b
-00111011b | 11111111b = 11111111b
-00111011b | 00000000b = 00111011b
-00111011b | 00000001b = 00111011b
-00111011b | 00000010b = 00111011b
-00111011b | 00000011b = 00111011b
-00111011b | 00000100b = 00111111b
-00111011b | 00000101b = 00111111b
-00111011b | 00000110b = 00111111b
-00111011b | 00000111b = 00111111b
-00111011b | 00001000b = 00111011b
-00111011b | 00001001b = 00111011b
-00111011b | 00001010b = 00111011b
-00111011b | 00001011b = 00111011b
-00111011b | 00001100b = 00111111b
-00111011b | 00001101b = 00111111b
-00111011b | 00001110b = 00111111b
-00111011b | 00001111b = 00111111b
-00111011b | 00010000b = 00111011b
-00111011b | 00010001b = 00111011b
-00111011b | 00010010b = 00111011b
-00111011b | 00010011b = 00111011b
-00111011b | 00010100b = 00111111b
-00111011b | 00010101b = 00111111b
-00111011b | 00010110b = 00111111b
-00111011b | 00010111b = 00111111b
-00111011b | 00011000b = 00111011b
-00111011b | 00011001b = 00111011b
-00111011b | 00011010b = 00111011b
-00111011b | 00011011b = 00111011b
-00111011b | 00011100b = 00111111b
-00111011b | 00011101b = 00111111b
-00111011b | 00011110b = 00111111b
-00111011b | 00011111b = 00111111b
-00111011b | 00100000b = 00111011b
-00111011b | 00100001b = 00111011b
-00111011b | 00100010b = 00111011b
-00111011b | 00100011b = 00111011b
-00111011b | 00100100b = 00111111b
-00111011b | 00100101b = 00111111b
-00111011b | 00100110b = 00111111b
-00111011b | 00100111b = 00111111b
-00111011b | 00101000b = 00111011b
-00111011b | 00101001b = 00111011b
-00111011b | 00101010b = 00111011b
-00111011b | 00101011b = 00111011b
-00111011b | 00101100b = 00111111b
-00111011b | 00101101b = 00111111b
-00111011b | 00101110b = 00111111b
-00111011b | 00101111b = 00111111b
-00111011b | 00110000b = 00111011b
-00111011b | 00110001b = 00111011b
-00111011b | 00110010b = 00111011b
-00111011b | 00110011b = 00111011b
-00111011b | 00110100b = 00111111b
-00111011b | 00110101b = 00111111b
-00111011b | 00110110b = 00111111b
-00111011b | 00110111b = 00111111b
-00111011b | 00111000b = 00111011b
-00111011b | 00111001b = 00111011b
-00111011b | 00111010b = 00111011b
-00111011b | 00111011b = 00111011b
-00111011b | 00111100b = 00111111b
-00111011b | 00111101b = 00111111b
-00111011b | 00111110b = 00111111b
-00111011b | 00111111b = 00111111b
-00111011b | 01000000b = 01111011b
-00111011b | 01000001b = 01111011b
-00111011b | 01000010b = 01111011b
-00111011b | 01000011b = 01111011b
-00111011b | 01000100b = 01111111b
-00111011b | 01000101b = 01111111b
-00111011b | 01000110b = 01111111b
-00111011b | 01000111b = 01111111b
-00111011b | 01001000b = 01111011b
-00111011b | 01001001b = 01111011b
-00111011b | 01001010b = 01111011b
-00111011b | 01001011b = 01111011b
-00111011b | 01001100b = 01111111b
-00111011b | 01001101b = 01111111b
-00111011b | 01001110b = 01111111b
-00111011b | 01001111b = 01111111b
-00111011b | 01010000b = 01111011b
-00111011b | 01010001b = 01111011b
-00111011b | 01010010b = 01111011b
-00111011b | 01010011b = 01111011b
-00111011b | 01010100b = 01111111b
-00111011b | 01010101b = 01111111b
-00111011b | 01010110b = 01111111b
-00111011b | 01010111b = 01111111b
-00111011b | 01011000b = 01111011b
-00111011b | 01011001b = 01111011b
-00111011b | 01011010b = 01111011b
-00111011b | 01011011b = 01111011b
-00111011b | 01011100b = 01111111b
-00111011b | 01011101b = 01111111b
-00111011b | 01011110b = 01111111b
-00111011b | 01011111b = 01111111b
-00111011b | 01100000b = 01111011b
-00111011b | 01100001b = 01111011b
-00111011b | 01100010b = 01111011b
-00111011b | 01100011b = 01111011b
-00111011b | 01100100b = 01111111b
-00111011b | 01100101b = 01111111b
-00111011b | 01100110b = 01111111b
-00111011b | 01100111b = 01111111b
-00111011b | 01101000b = 01111011b
-00111011b | 01101001b = 01111011b
-00111011b | 01101010b = 01111011b
-00111011b | 01101011b = 01111011b
-00111011b | 01101100b = 01111111b
-00111011b | 01101101b = 01111111b
-00111011b | 01101110b = 01111111b
-00111011b | 01101111b = 01111111b
-00111011b | 01110000b = 01111011b
-00111011b | 01110001b = 01111011b
-00111011b | 01110010b = 01111011b
-00111011b | 01110011b = 01111011b
-00111011b | 01110100b = 01111111b
-00111011b | 01110101b = 01111111b
-00111011b | 01110110b = 01111111b
-00111011b | 01110111b = 01111111b
-00111011b | 01111000b = 01111011b
-00111011b | 01111001b = 01111011b
-00111011b | 01111010b = 01111011b
-00111011b | 01111011b = 01111011b
-00111011b | 01111100b = 01111111b
-00111011b | 01111101b = 01111111b
-00111011b | 01111110b = 01111111b
-00111100b | 10000000b = 10111100b
-00111100b | 10000001b = 10111101b
-00111100b | 10000010b = 10111110b
-00111100b | 10000011b = 10111111b
-00111100b | 10000100b = 10111100b
-00111100b | 10000101b = 10111101b
-00111100b | 10000110b = 10111110b
-00111100b | 10000111b = 10111111b
-00111100b | 10001000b = 10111100b
-00111100b | 10001001b = 10111101b
-00111100b | 10001010b = 10111110b
-00111100b | 10001011b = 10111111b
-00111100b | 10001100b = 10111100b
-00111100b | 10001101b = 10111101b
-00111100b | 10001110b = 10111110b
-00111100b | 10001111b = 10111111b
-00111100b | 10010000b = 10111100b
-00111100b | 10010001b = 10111101b
-00111100b | 10010010b = 10111110b
-00111100b | 10010011b = 10111111b
-00111100b | 10010100b = 10111100b
-00111100b | 10010101b = 10111101b
-00111100b | 10010110b = 10111110b
-00111100b | 10010111b = 10111111b
-00111100b | 10011000b = 10111100b
-00111100b | 10011001b = 10111101b
-00111100b | 10011010b = 10111110b
-00111100b | 10011011b = 10111111b
-00111100b | 10011100b = 10111100b
-00111100b | 10011101b = 10111101b
-00111100b | 10011110b = 10111110b
-00111100b | 10011111b = 10111111b
-00111100b | 10100000b = 10111100b
-00111100b | 10100001b = 10111101b
-00111100b | 10100010b = 10111110b
-00111100b | 10100011b = 10111111b
-00111100b | 10100100b = 10111100b
-00111100b | 10100101b = 10111101b
-00111100b | 10100110b = 10111110b
-00111100b | 10100111b = 10111111b
-00111100b | 10101000b = 10111100b
-00111100b | 10101001b = 10111101b
-00111100b | 10101010b = 10111110b
-00111100b | 10101011b = 10111111b
-00111100b | 10101100b = 10111100b
-00111100b | 10101101b = 10111101b
-00111100b | 10101110b = 10111110b
-00111100b | 10101111b = 10111111b
-00111100b | 10110000b = 10111100b
-00111100b | 10110001b = 10111101b
-00111100b | 10110010b = 10111110b
-00111100b | 10110011b = 10111111b
-00111100b | 10110100b = 10111100b
-00111100b | 10110101b = 10111101b
-00111100b | 10110110b = 10111110b
-00111100b | 10110111b = 10111111b
-00111100b | 10111000b = 10111100b
-00111100b | 10111001b = 10111101b
-00111100b | 10111010b = 10111110b
-00111100b | 10111011b = 10111111b
-00111100b | 10111100b = 10111100b
-00111100b | 10111101b = 10111101b
-00111100b | 10111110b = 10111110b
-00111100b | 10111111b = 10111111b
-00111100b | 11000000b = 11111100b
-00111100b | 11000001b = 11111101b
-00111100b | 11000010b = 11111110b
-00111100b | 11000011b = 11111111b
-00111100b | 11000100b = 11111100b
-00111100b | 11000101b = 11111101b
-00111100b | 11000110b = 11111110b
-00111100b | 11000111b = 11111111b
-00111100b | 11001000b = 11111100b
-00111100b | 11001001b = 11111101b
-00111100b | 11001010b = 11111110b
-00111100b | 11001011b = 11111111b
-00111100b | 11001100b = 11111100b
-00111100b | 11001101b = 11111101b
-00111100b | 11001110b = 11111110b
-00111100b | 11001111b = 11111111b
-00111100b | 11010000b = 11111100b
-00111100b | 11010001b = 11111101b
-00111100b | 11010010b = 11111110b
-00111100b | 11010011b = 11111111b
-00111100b | 11010100b = 11111100b
-00111100b | 11010101b = 11111101b
-00111100b | 11010110b = 11111110b
-00111100b | 11010111b = 11111111b
-00111100b | 11011000b = 11111100b
-00111100b | 11011001b = 11111101b
-00111100b | 11011010b = 11111110b
-00111100b | 11011011b = 11111111b
-00111100b | 11011100b = 11111100b
-00111100b | 11011101b = 11111101b
-00111100b | 11011110b = 11111110b
-00111100b | 11011111b = 11111111b
-00111100b | 11100000b = 11111100b
-00111100b | 11100001b = 11111101b
-00111100b | 11100010b = 11111110b
-00111100b | 11100011b = 11111111b
-00111100b | 11100100b = 11111100b
-00111100b | 11100101b = 11111101b
-00111100b | 11100110b = 11111110b
-00111100b | 11100111b = 11111111b
-00111100b | 11101000b = 11111100b
-00111100b | 11101001b = 11111101b
-00111100b | 11101010b = 11111110b
-00111100b | 11101011b = 11111111b
-00111100b | 11101100b = 11111100b
-00111100b | 11101101b = 11111101b
-00111100b | 11101110b = 11111110b
-00111100b | 11101111b = 11111111b
-00111100b | 11110000b = 11111100b
-00111100b | 11110001b = 11111101b
-00111100b | 11110010b = 11111110b
-00111100b | 11110011b = 11111111b
-00111100b | 11110100b = 11111100b
-00111100b | 11110101b = 11111101b
-00111100b | 11110110b = 11111110b
-00111100b | 11110111b = 11111111b
-00111100b | 11111000b = 11111100b
-00111100b | 11111001b = 11111101b
-00111100b | 11111010b = 11111110b
-00111100b | 11111011b = 11111111b
-00111100b | 11111100b = 11111100b
-00111100b | 11111101b = 11111101b
-00111100b | 11111110b = 11111110b
-00111100b | 11111111b = 11111111b
-00111100b | 00000000b = 00111100b
-00111100b | 00000001b = 00111101b
-00111100b | 00000010b = 00111110b
-00111100b | 00000011b = 00111111b
-00111100b | 00000100b = 00111100b
-00111100b | 00000101b = 00111101b
-00111100b | 00000110b = 00111110b
-00111100b | 00000111b = 00111111b
-00111100b | 00001000b = 00111100b
-00111100b | 00001001b = 00111101b
-00111100b | 00001010b = 00111110b
-00111100b | 00001011b = 00111111b
-00111100b | 00001100b = 00111100b
-00111100b | 00001101b = 00111101b
-00111100b | 00001110b = 00111110b
-00111100b | 00001111b = 00111111b
-00111100b | 00010000b = 00111100b
-00111100b | 00010001b = 00111101b
-00111100b | 00010010b = 00111110b
-00111100b | 00010011b = 00111111b
-00111100b | 00010100b = 00111100b
-00111100b | 00010101b = 00111101b
-00111100b | 00010110b = 00111110b
-00111100b | 00010111b = 00111111b
-00111100b | 00011000b = 00111100b
-00111100b | 00011001b = 00111101b
-00111100b | 00011010b = 00111110b
-00111100b | 00011011b = 00111111b
-00111100b | 00011100b = 00111100b
-00111100b | 00011101b = 00111101b
-00111100b | 00011110b = 00111110b
-00111100b | 00011111b = 00111111b
-00111100b | 00100000b = 00111100b
-00111100b | 00100001b = 00111101b
-00111100b | 00100010b = 00111110b
-00111100b | 00100011b = 00111111b
-00111100b | 00100100b = 00111100b
-00111100b | 00100101b = 00111101b
-00111100b | 00100110b = 00111110b
-00111100b | 00100111b = 00111111b
-00111100b | 00101000b = 00111100b
-00111100b | 00101001b = 00111101b
-00111100b | 00101010b = 00111110b
-00111100b | 00101011b = 00111111b
-00111100b | 00101100b = 00111100b
-00111100b | 00101101b = 00111101b
-00111100b | 00101110b = 00111110b
-00111100b | 00101111b = 00111111b
-00111100b | 00110000b = 00111100b
-00111100b | 00110001b = 00111101b
-00111100b | 00110010b = 00111110b
-00111100b | 00110011b = 00111111b
-00111100b | 00110100b = 00111100b
-00111100b | 00110101b = 00111101b
-00111100b | 00110110b = 00111110b
-00111100b | 00110111b = 00111111b
-00111100b | 00111000b = 00111100b
-00111100b | 00111001b = 00111101b
-00111100b | 00111010b = 00111110b
-00111100b | 00111011b = 00111111b
-00111100b | 00111100b = 00111100b
-00111100b | 00111101b = 00111101b
-00111100b | 00111110b = 00111110b
-00111100b | 00111111b = 00111111b
-00111100b | 01000000b = 01111100b
-00111100b | 01000001b = 01111101b
-00111100b | 01000010b = 01111110b
-00111100b | 01000011b = 01111111b
-00111100b | 01000100b = 01111100b
-00111100b | 01000101b = 01111101b
-00111100b | 01000110b = 01111110b
-00111100b | 01000111b = 01111111b
-00111100b | 01001000b = 01111100b
-00111100b | 01001001b = 01111101b
-00111100b | 01001010b = 01111110b
-00111100b | 01001011b = 01111111b
-00111100b | 01001100b = 01111100b
-00111100b | 01001101b = 01111101b
-00111100b | 01001110b = 01111110b
-00111100b | 01001111b = 01111111b
-00111100b | 01010000b = 01111100b
-00111100b | 01010001b = 01111101b
-00111100b | 01010010b = 01111110b
-00111100b | 01010011b = 01111111b
-00111100b | 01010100b = 01111100b
-00111100b | 01010101b = 01111101b
-00111100b | 01010110b = 01111110b
-00111100b | 01010111b = 01111111b
-00111100b | 01011000b = 01111100b
-00111100b | 01011001b = 01111101b
-00111100b | 01011010b = 01111110b
-00111100b | 01011011b = 01111111b
-00111100b | 01011100b = 01111100b
-00111100b | 01011101b = 01111101b
-00111100b | 01011110b = 01111110b
-00111100b | 01011111b = 01111111b
-00111100b | 01100000b = 01111100b
-00111100b | 01100001b = 01111101b
-00111100b | 01100010b = 01111110b
-00111100b | 01100011b = 01111111b
-00111100b | 01100100b = 01111100b
-00111100b | 01100101b = 01111101b
-00111100b | 01100110b = 01111110b
-00111100b | 01100111b = 01111111b
-00111100b | 01101000b = 01111100b
-00111100b | 01101001b = 01111101b
-00111100b | 01101010b = 01111110b
-00111100b | 01101011b = 01111111b
-00111100b | 01101100b = 01111100b
-00111100b | 01101101b = 01111101b
-00111100b | 01101110b = 01111110b
-00111100b | 01101111b = 01111111b
-00111100b | 01110000b = 01111100b
-00111100b | 01110001b = 01111101b
-00111100b | 01110010b = 01111110b
-00111100b | 01110011b = 01111111b
-00111100b | 01110100b = 01111100b
-00111100b | 01110101b = 01111101b
-00111100b | 01110110b = 01111110b
-00111100b | 01110111b = 01111111b
-00111100b | 01111000b = 01111100b
-00111100b | 01111001b = 01111101b
-00111100b | 01111010b = 01111110b
-00111100b | 01111011b = 01111111b
-00111100b | 01111100b = 01111100b
-00111100b | 01111101b = 01111101b
-00111100b | 01111110b = 01111110b
-00111101b | 10000000b = 10111101b
-00111101b | 10000001b = 10111101b
-00111101b | 10000010b = 10111111b
-00111101b | 10000011b = 10111111b
-00111101b | 10000100b = 10111101b
-00111101b | 10000101b = 10111101b
-00111101b | 10000110b = 10111111b
-00111101b | 10000111b = 10111111b
-00111101b | 10001000b = 10111101b
-00111101b | 10001001b = 10111101b
-00111101b | 10001010b = 10111111b
-00111101b | 10001011b = 10111111b
-00111101b | 10001100b = 10111101b
-00111101b | 10001101b = 10111101b
-00111101b | 10001110b = 10111111b
-00111101b | 10001111b = 10111111b
-00111101b | 10010000b = 10111101b
-00111101b | 10010001b = 10111101b
-00111101b | 10010010b = 10111111b
-00111101b | 10010011b = 10111111b
-00111101b | 10010100b = 10111101b
-00111101b | 10010101b = 10111101b
-00111101b | 10010110b = 10111111b
-00111101b | 10010111b = 10111111b
-00111101b | 10011000b = 10111101b
-00111101b | 10011001b = 10111101b
-00111101b | 10011010b = 10111111b
-00111101b | 10011011b = 10111111b
-00111101b | 10011100b = 10111101b
-00111101b | 10011101b = 10111101b
-00111101b | 10011110b = 10111111b
-00111101b | 10011111b = 10111111b
-00111101b | 10100000b = 10111101b
-00111101b | 10100001b = 10111101b
-00111101b | 10100010b = 10111111b
-00111101b | 10100011b = 10111111b
-00111101b | 10100100b = 10111101b
-00111101b | 10100101b = 10111101b
-00111101b | 10100110b = 10111111b
-00111101b | 10100111b = 10111111b
-00111101b | 10101000b = 10111101b
-00111101b | 10101001b = 10111101b
-00111101b | 10101010b = 10111111b
-00111101b | 10101011b = 10111111b
-00111101b | 10101100b = 10111101b
-00111101b | 10101101b = 10111101b
-00111101b | 10101110b = 10111111b
-00111101b | 10101111b = 10111111b
-00111101b | 10110000b = 10111101b
-00111101b | 10110001b = 10111101b
-00111101b | 10110010b = 10111111b
-00111101b | 10110011b = 10111111b
-00111101b | 10110100b = 10111101b
-00111101b | 10110101b = 10111101b
-00111101b | 10110110b = 10111111b
-00111101b | 10110111b = 10111111b
-00111101b | 10111000b = 10111101b
-00111101b | 10111001b = 10111101b
-00111101b | 10111010b = 10111111b
-00111101b | 10111011b = 10111111b
-00111101b | 10111100b = 10111101b
-00111101b | 10111101b = 10111101b
-00111101b | 10111110b = 10111111b
-00111101b | 10111111b = 10111111b
-00111101b | 11000000b = 11111101b
-00111101b | 11000001b = 11111101b
-00111101b | 11000010b = 11111111b
-00111101b | 11000011b = 11111111b
-00111101b | 11000100b = 11111101b
-00111101b | 11000101b = 11111101b
-00111101b | 11000110b = 11111111b
-00111101b | 11000111b = 11111111b
-00111101b | 11001000b = 11111101b
-00111101b | 11001001b = 11111101b
-00111101b | 11001010b = 11111111b
-00111101b | 11001011b = 11111111b
-00111101b | 11001100b = 11111101b
-00111101b | 11001101b = 11111101b
-00111101b | 11001110b = 11111111b
-00111101b | 11001111b = 11111111b
-00111101b | 11010000b = 11111101b
-00111101b | 11010001b = 11111101b
-00111101b | 11010010b = 11111111b
-00111101b | 11010011b = 11111111b
-00111101b | 11010100b = 11111101b
-00111101b | 11010101b = 11111101b
-00111101b | 11010110b = 11111111b
-00111101b | 11010111b = 11111111b
-00111101b | 11011000b = 11111101b
-00111101b | 11011001b = 11111101b
-00111101b | 11011010b = 11111111b
-00111101b | 11011011b = 11111111b
-00111101b | 11011100b = 11111101b
-00111101b | 11011101b = 11111101b
-00111101b | 11011110b = 11111111b
-00111101b | 11011111b = 11111111b
-00111101b | 11100000b = 11111101b
-00111101b | 11100001b = 11111101b
-00111101b | 11100010b = 11111111b
-00111101b | 11100011b = 11111111b
-00111101b | 11100100b = 11111101b
-00111101b | 11100101b = 11111101b
-00111101b | 11100110b = 11111111b
-00111101b | 11100111b = 11111111b
-00111101b | 11101000b = 11111101b
-00111101b | 11101001b = 11111101b
-00111101b | 11101010b = 11111111b
-00111101b | 11101011b = 11111111b
-00111101b | 11101100b = 11111101b
-00111101b | 11101101b = 11111101b
-00111101b | 11101110b = 11111111b
-00111101b | 11101111b = 11111111b
-00111101b | 11110000b = 11111101b
-00111101b | 11110001b = 11111101b
-00111101b | 11110010b = 11111111b
-00111101b | 11110011b = 11111111b
-00111101b | 11110100b = 11111101b
-00111101b | 11110101b = 11111101b
-00111101b | 11110110b = 11111111b
-00111101b | 11110111b = 11111111b
-00111101b | 11111000b = 11111101b
-00111101b | 11111001b = 11111101b
-00111101b | 11111010b = 11111111b
-00111101b | 11111011b = 11111111b
-00111101b | 11111100b = 11111101b
-00111101b | 11111101b = 11111101b
-00111101b | 11111110b = 11111111b
-00111101b | 11111111b = 11111111b
-00111101b | 00000000b = 00111101b
-00111101b | 00000001b = 00111101b
-00111101b | 00000010b = 00111111b
-00111101b | 00000011b = 00111111b
-00111101b | 00000100b = 00111101b
-00111101b | 00000101b = 00111101b
-00111101b | 00000110b = 00111111b
-00111101b | 00000111b = 00111111b
-00111101b | 00001000b = 00111101b
-00111101b | 00001001b = 00111101b
-00111101b | 00001010b = 00111111b
-00111101b | 00001011b = 00111111b
-00111101b | 00001100b = 00111101b
-00111101b | 00001101b = 00111101b
-00111101b | 00001110b = 00111111b
-00111101b | 00001111b = 00111111b
-00111101b | 00010000b = 00111101b
-00111101b | 00010001b = 00111101b
-00111101b | 00010010b = 00111111b
-00111101b | 00010011b = 00111111b
-00111101b | 00010100b = 00111101b
-00111101b | 00010101b = 00111101b
-00111101b | 00010110b = 00111111b
-00111101b | 00010111b = 00111111b
-00111101b | 00011000b = 00111101b
-00111101b | 00011001b = 00111101b
-00111101b | 00011010b = 00111111b
-00111101b | 00011011b = 00111111b
-00111101b | 00011100b = 00111101b
-00111101b | 00011101b = 00111101b
-00111101b | 00011110b = 00111111b
-00111101b | 00011111b = 00111111b
-00111101b | 00100000b = 00111101b
-00111101b | 00100001b = 00111101b
-00111101b | 00100010b = 00111111b
-00111101b | 00100011b = 00111111b
-00111101b | 00100100b = 00111101b
-00111101b | 00100101b = 00111101b
-00111101b | 00100110b = 00111111b
-00111101b | 00100111b = 00111111b
-00111101b | 00101000b = 00111101b
-00111101b | 00101001b = 00111101b
-00111101b | 00101010b = 00111111b
-00111101b | 00101011b = 00111111b
-00111101b | 00101100b = 00111101b
-00111101b | 00101101b = 00111101b
-00111101b | 00101110b = 00111111b
-00111101b | 00101111b = 00111111b
-00111101b | 00110000b = 00111101b
-00111101b | 00110001b = 00111101b
-00111101b | 00110010b = 00111111b
-00111101b | 00110011b = 00111111b
-00111101b | 00110100b = 00111101b
-00111101b | 00110101b = 00111101b
-00111101b | 00110110b = 00111111b
-00111101b | 00110111b = 00111111b
-00111101b | 00111000b = 00111101b
-00111101b | 00111001b = 00111101b
-00111101b | 00111010b = 00111111b
-00111101b | 00111011b = 00111111b
-00111101b | 00111100b = 00111101b
-00111101b | 00111101b = 00111101b
-00111101b | 00111110b = 00111111b
-00111101b | 00111111b = 00111111b
-00111101b | 01000000b = 01111101b
-00111101b | 01000001b = 01111101b
-00111101b | 01000010b = 01111111b
-00111101b | 01000011b = 01111111b
-00111101b | 01000100b = 01111101b
-00111101b | 01000101b = 01111101b
-00111101b | 01000110b = 01111111b
-00111101b | 01000111b = 01111111b
-00111101b | 01001000b = 01111101b
-00111101b | 01001001b = 01111101b
-00111101b | 01001010b = 01111111b
-00111101b | 01001011b = 01111111b
-00111101b | 01001100b = 01111101b
-00111101b | 01001101b = 01111101b
-00111101b | 01001110b = 01111111b
-00111101b | 01001111b = 01111111b
-00111101b | 01010000b = 01111101b
-00111101b | 01010001b = 01111101b
-00111101b | 01010010b = 01111111b
-00111101b | 01010011b = 01111111b
-00111101b | 01010100b = 01111101b
-00111101b | 01010101b = 01111101b
-00111101b | 01010110b = 01111111b
-00111101b | 01010111b = 01111111b
-00111101b | 01011000b = 01111101b
-00111101b | 01011001b = 01111101b
-00111101b | 01011010b = 01111111b
-00111101b | 01011011b = 01111111b
-00111101b | 01011100b = 01111101b
-00111101b | 01011101b = 01111101b
-00111101b | 01011110b = 01111111b
-00111101b | 01011111b = 01111111b
-00111101b | 01100000b = 01111101b
-00111101b | 01100001b = 01111101b
-00111101b | 01100010b = 01111111b
-00111101b | 01100011b = 01111111b
-00111101b | 01100100b = 01111101b
-00111101b | 01100101b = 01111101b
-00111101b | 01100110b = 01111111b
-00111101b | 01100111b = 01111111b
-00111101b | 01101000b = 01111101b
-00111101b | 01101001b = 01111101b
-00111101b | 01101010b = 01111111b
-00111101b | 01101011b = 01111111b
-00111101b | 01101100b = 01111101b
-00111101b | 01101101b = 01111101b
-00111101b | 01101110b = 01111111b
-00111101b | 01101111b = 01111111b
-00111101b | 01110000b = 01111101b
-00111101b | 01110001b = 01111101b
-00111101b | 01110010b = 01111111b
-00111101b | 01110011b = 01111111b
-00111101b | 01110100b = 01111101b
-00111101b | 01110101b = 01111101b
-00111101b | 01110110b = 01111111b
-00111101b | 01110111b = 01111111b
-00111101b | 01111000b = 01111101b
-00111101b | 01111001b = 01111101b
-00111101b | 01111010b = 01111111b
-00111101b | 01111011b = 01111111b
-00111101b | 01111100b = 01111101b
-00111101b | 01111101b = 01111101b
-00111101b | 01111110b = 01111111b
-00111110b | 10000000b = 10111110b
-00111110b | 10000001b = 10111111b
-00111110b | 10000010b = 10111110b
-00111110b | 10000011b = 10111111b
-00111110b | 10000100b = 10111110b
-00111110b | 10000101b = 10111111b
-00111110b | 10000110b = 10111110b
-00111110b | 10000111b = 10111111b
-00111110b | 10001000b = 10111110b
-00111110b | 10001001b = 10111111b
-00111110b | 10001010b = 10111110b
-00111110b | 10001011b = 10111111b
-00111110b | 10001100b = 10111110b
-00111110b | 10001101b = 10111111b
-00111110b | 10001110b = 10111110b
-00111110b | 10001111b = 10111111b
-00111110b | 10010000b = 10111110b
-00111110b | 10010001b = 10111111b
-00111110b | 10010010b = 10111110b
-00111110b | 10010011b = 10111111b
-00111110b | 10010100b = 10111110b
-00111110b | 10010101b = 10111111b
-00111110b | 10010110b = 10111110b
-00111110b | 10010111b = 10111111b
-00111110b | 10011000b = 10111110b
-00111110b | 10011001b = 10111111b
-00111110b | 10011010b = 10111110b
-00111110b | 10011011b = 10111111b
-00111110b | 10011100b = 10111110b
-00111110b | 10011101b = 10111111b
-00111110b | 10011110b = 10111110b
-00111110b | 10011111b = 10111111b
-00111110b | 10100000b = 10111110b
-00111110b | 10100001b = 10111111b
-00111110b | 10100010b = 10111110b
-00111110b | 10100011b = 10111111b
-00111110b | 10100100b = 10111110b
-00111110b | 10100101b = 10111111b
-00111110b | 10100110b = 10111110b
-00111110b | 10100111b = 10111111b
-00111110b | 10101000b = 10111110b
-00111110b | 10101001b = 10111111b
-00111110b | 10101010b = 10111110b
-00111110b | 10101011b = 10111111b
-00111110b | 10101100b = 10111110b
-00111110b | 10101101b = 10111111b
-00111110b | 10101110b = 10111110b
-00111110b | 10101111b = 10111111b
-00111110b | 10110000b = 10111110b
-00111110b | 10110001b = 10111111b
-00111110b | 10110010b = 10111110b
-00111110b | 10110011b = 10111111b
-00111110b | 10110100b = 10111110b
-00111110b | 10110101b = 10111111b
-00111110b | 10110110b = 10111110b
-00111110b | 10110111b = 10111111b
-00111110b | 10111000b = 10111110b
-00111110b | 10111001b = 10111111b
-00111110b | 10111010b = 10111110b
-00111110b | 10111011b = 10111111b
-00111110b | 10111100b = 10111110b
-00111110b | 10111101b = 10111111b
-00111110b | 10111110b = 10111110b
-00111110b | 10111111b = 10111111b
-00111110b | 11000000b = 11111110b
-00111110b | 11000001b = 11111111b
-00111110b | 11000010b = 11111110b
-00111110b | 11000011b = 11111111b
-00111110b | 11000100b = 11111110b
-00111110b | 11000101b = 11111111b
-00111110b | 11000110b = 11111110b
-00111110b | 11000111b = 11111111b
-00111110b | 11001000b = 11111110b
-00111110b | 11001001b = 11111111b
-00111110b | 11001010b = 11111110b
-00111110b | 11001011b = 11111111b
-00111110b | 11001100b = 11111110b
-00111110b | 11001101b = 11111111b
-00111110b | 11001110b = 11111110b
-00111110b | 11001111b = 11111111b
-00111110b | 11010000b = 11111110b
-00111110b | 11010001b = 11111111b
-00111110b | 11010010b = 11111110b
-00111110b | 11010011b = 11111111b
-00111110b | 11010100b = 11111110b
-00111110b | 11010101b = 11111111b
-00111110b | 11010110b = 11111110b
-00111110b | 11010111b = 11111111b
-00111110b | 11011000b = 11111110b
-00111110b | 11011001b = 11111111b
-00111110b | 11011010b = 11111110b
-00111110b | 11011011b = 11111111b
-00111110b | 11011100b = 11111110b
-00111110b | 11011101b = 11111111b
-00111110b | 11011110b = 11111110b
-00111110b | 11011111b = 11111111b
-00111110b | 11100000b = 11111110b
-00111110b | 11100001b = 11111111b
-00111110b | 11100010b = 11111110b
-00111110b | 11100011b = 11111111b
-00111110b | 11100100b = 11111110b
-00111110b | 11100101b = 11111111b
-00111110b | 11100110b = 11111110b
-00111110b | 11100111b = 11111111b
-00111110b | 11101000b = 11111110b
-00111110b | 11101001b = 11111111b
-00111110b | 11101010b = 11111110b
-00111110b | 11101011b = 11111111b
-00111110b | 11101100b = 11111110b
-00111110b | 11101101b = 11111111b
-00111110b | 11101110b = 11111110b
-00111110b | 11101111b = 11111111b
-00111110b | 11110000b = 11111110b
-00111110b | 11110001b = 11111111b
-00111110b | 11110010b = 11111110b
-00111110b | 11110011b = 11111111b
-00111110b | 11110100b = 11111110b
-00111110b | 11110101b = 11111111b
-00111110b | 11110110b = 11111110b
-00111110b | 11110111b = 11111111b
-00111110b | 11111000b = 11111110b
-00111110b | 11111001b = 11111111b
-00111110b | 11111010b = 11111110b
-00111110b | 11111011b = 11111111b
-00111110b | 11111100b = 11111110b
-00111110b | 11111101b = 11111111b
-00111110b | 11111110b = 11111110b
-00111110b | 11111111b = 11111111b
-00111110b | 00000000b = 00111110b
-00111110b | 00000001b = 00111111b
-00111110b | 00000010b = 00111110b
-00111110b | 00000011b = 00111111b
-00111110b | 00000100b = 00111110b
-00111110b | 00000101b = 00111111b
-00111110b | 00000110b = 00111110b
-00111110b | 00000111b = 00111111b
-00111110b | 00001000b = 00111110b
-00111110b | 00001001b = 00111111b
-00111110b | 00001010b = 00111110b
-00111110b | 00001011b = 00111111b
-00111110b | 00001100b = 00111110b
-00111110b | 00001101b = 00111111b
-00111110b | 00001110b = 00111110b
-00111110b | 00001111b = 00111111b
-00111110b | 00010000b = 00111110b
-00111110b | 00010001b = 00111111b
-00111110b | 00010010b = 00111110b
-00111110b | 00010011b = 00111111b
-00111110b | 00010100b = 00111110b
-00111110b | 00010101b = 00111111b
-00111110b | 00010110b = 00111110b
-00111110b | 00010111b = 00111111b
-00111110b | 00011000b = 00111110b
-00111110b | 00011001b = 00111111b
-00111110b | 00011010b = 00111110b
-00111110b | 00011011b = 00111111b
-00111110b | 00011100b = 00111110b
-00111110b | 00011101b = 00111111b
-00111110b | 00011110b = 00111110b
-00111110b | 00011111b = 00111111b
-00111110b | 00100000b = 00111110b
-00111110b | 00100001b = 00111111b
-00111110b | 00100010b = 00111110b
-00111110b | 00100011b = 00111111b
-00111110b | 00100100b = 00111110b
-00111110b | 00100101b = 00111111b
-00111110b | 00100110b = 00111110b
-00111110b | 00100111b = 00111111b
-00111110b | 00101000b = 00111110b
-00111110b | 00101001b = 00111111b
-00111110b | 00101010b = 00111110b
-00111110b | 00101011b = 00111111b
-00111110b | 00101100b = 00111110b
-00111110b | 00101101b = 00111111b
-00111110b | 00101110b = 00111110b
-00111110b | 00101111b = 00111111b
-00111110b | 00110000b = 00111110b
-00111110b | 00110001b = 00111111b
-00111110b | 00110010b = 00111110b
-00111110b | 00110011b = 00111111b
-00111110b | 00110100b = 00111110b
-00111110b | 00110101b = 00111111b
-00111110b | 00110110b = 00111110b
-00111110b | 00110111b = 00111111b
-00111110b | 00111000b = 00111110b
-00111110b | 00111001b = 00111111b
-00111110b | 00111010b = 00111110b
-00111110b | 00111011b = 00111111b
-00111110b | 00111100b = 00111110b
-00111110b | 00111101b = 00111111b
-00111110b | 00111110b = 00111110b
-00111110b | 00111111b = 00111111b
-00111110b | 01000000b = 01111110b
-00111110b | 01000001b = 01111111b
-00111110b | 01000010b = 01111110b
-00111110b | 01000011b = 01111111b
-00111110b | 01000100b = 01111110b
-00111110b | 01000101b = 01111111b
-00111110b | 01000110b = 01111110b
-00111110b | 01000111b = 01111111b
-00111110b | 01001000b = 01111110b
-00111110b | 01001001b = 01111111b
-00111110b | 01001010b = 01111110b
-00111110b | 01001011b = 01111111b
-00111110b | 01001100b = 01111110b
-00111110b | 01001101b = 01111111b
-00111110b | 01001110b = 01111110b
-00111110b | 01001111b = 01111111b
-00111110b | 01010000b = 01111110b
-00111110b | 01010001b = 01111111b
-00111110b | 01010010b = 01111110b
-00111110b | 01010011b = 01111111b
-00111110b | 01010100b = 01111110b
-00111110b | 01010101b = 01111111b
-00111110b | 01010110b = 01111110b
-00111110b | 01010111b = 01111111b
-00111110b | 01011000b = 01111110b
-00111110b | 01011001b = 01111111b
-00111110b | 01011010b = 01111110b
-00111110b | 01011011b = 01111111b
-00111110b | 01011100b = 01111110b
-00111110b | 01011101b = 01111111b
-00111110b | 01011110b = 01111110b
-00111110b | 01011111b = 01111111b
-00111110b | 01100000b = 01111110b
-00111110b | 01100001b = 01111111b
-00111110b | 01100010b = 01111110b
-00111110b | 01100011b = 01111111b
-00111110b | 01100100b = 01111110b
-00111110b | 01100101b = 01111111b
-00111110b | 01100110b = 01111110b
-00111110b | 01100111b = 01111111b
-00111110b | 01101000b = 01111110b
-00111110b | 01101001b = 01111111b
-00111110b | 01101010b = 01111110b
-00111110b | 01101011b = 01111111b
-00111110b | 01101100b = 01111110b
-00111110b | 01101101b = 01111111b
-00111110b | 01101110b = 01111110b
-00111110b | 01101111b = 01111111b
-00111110b | 01110000b = 01111110b
-00111110b | 01110001b = 01111111b
-00111110b | 01110010b = 01111110b
-00111110b | 01110011b = 01111111b
-00111110b | 01110100b = 01111110b
-00111110b | 01110101b = 01111111b
-00111110b | 01110110b = 01111110b
-00111110b | 01110111b = 01111111b
-00111110b | 01111000b = 01111110b
-00111110b | 01111001b = 01111111b
-00111110b | 01111010b = 01111110b
-00111110b | 01111011b = 01111111b
-00111110b | 01111100b = 01111110b
-00111110b | 01111101b = 01111111b
-00111110b | 01111110b = 01111110b
-00111111b | 10000000b = 10111111b
-00111111b | 10000001b = 10111111b
-00111111b | 10000010b = 10111111b
-00111111b | 10000011b = 10111111b
-00111111b | 10000100b = 10111111b
-00111111b | 10000101b = 10111111b
-00111111b | 10000110b = 10111111b
-00111111b | 10000111b = 10111111b
-00111111b | 10001000b = 10111111b
-00111111b | 10001001b = 10111111b
-00111111b | 10001010b = 10111111b
-00111111b | 10001011b = 10111111b
-00111111b | 10001100b = 10111111b
-00111111b | 10001101b = 10111111b
-00111111b | 10001110b = 10111111b
-00111111b | 10001111b = 10111111b
-00111111b | 10010000b = 10111111b
-00111111b | 10010001b = 10111111b
-00111111b | 10010010b = 10111111b
-00111111b | 10010011b = 10111111b
-00111111b | 10010100b = 10111111b
-00111111b | 10010101b = 10111111b
-00111111b | 10010110b = 10111111b
-00111111b | 10010111b = 10111111b
-00111111b | 10011000b = 10111111b
-00111111b | 10011001b = 10111111b
-00111111b | 10011010b = 10111111b
-00111111b | 10011011b = 10111111b
-00111111b | 10011100b = 10111111b
-00111111b | 10011101b = 10111111b
-00111111b | 10011110b = 10111111b
-00111111b | 10011111b = 10111111b
-00111111b | 10100000b = 10111111b
-00111111b | 10100001b = 10111111b
-00111111b | 10100010b = 10111111b
-00111111b | 10100011b = 10111111b
-00111111b | 10100100b = 10111111b
-00111111b | 10100101b = 10111111b
-00111111b | 10100110b = 10111111b
-00111111b | 10100111b = 10111111b
-00111111b | 10101000b = 10111111b
-00111111b | 10101001b = 10111111b
-00111111b | 10101010b = 10111111b
-00111111b | 10101011b = 10111111b
-00111111b | 10101100b = 10111111b
-00111111b | 10101101b = 10111111b
-00111111b | 10101110b = 10111111b
-00111111b | 10101111b = 10111111b
-00111111b | 10110000b = 10111111b
-00111111b | 10110001b = 10111111b
-00111111b | 10110010b = 10111111b
-00111111b | 10110011b = 10111111b
-00111111b | 10110100b = 10111111b
-00111111b | 10110101b = 10111111b
-00111111b | 10110110b = 10111111b
-00111111b | 10110111b = 10111111b
-00111111b | 10111000b = 10111111b
-00111111b | 10111001b = 10111111b
-00111111b | 10111010b = 10111111b
-00111111b | 10111011b = 10111111b
-00111111b | 10111100b = 10111111b
-00111111b | 10111101b = 10111111b
-00111111b | 10111110b = 10111111b
-00111111b | 10111111b = 10111111b
-00111111b | 11000000b = 11111111b
-00111111b | 11000001b = 11111111b
-00111111b | 11000010b = 11111111b
-00111111b | 11000011b = 11111111b
-00111111b | 11000100b = 11111111b
-00111111b | 11000101b = 11111111b
-00111111b | 11000110b = 11111111b
-00111111b | 11000111b = 11111111b
-00111111b | 11001000b = 11111111b
-00111111b | 11001001b = 11111111b
-00111111b | 11001010b = 11111111b
-00111111b | 11001011b = 11111111b
-00111111b | 11001100b = 11111111b
-00111111b | 11001101b = 11111111b
-00111111b | 11001110b = 11111111b
-00111111b | 11001111b = 11111111b
-00111111b | 11010000b = 11111111b
-00111111b | 11010001b = 11111111b
-00111111b | 11010010b = 11111111b
-00111111b | 11010011b = 11111111b
-00111111b | 11010100b = 11111111b
-00111111b | 11010101b = 11111111b
-00111111b | 11010110b = 11111111b
-00111111b | 11010111b = 11111111b
-00111111b | 11011000b = 11111111b
-00111111b | 11011001b = 11111111b
-00111111b | 11011010b = 11111111b
-00111111b | 11011011b = 11111111b
-00111111b | 11011100b = 11111111b
-00111111b | 11011101b = 11111111b
-00111111b | 11011110b = 11111111b
-00111111b | 11011111b = 11111111b
-00111111b | 11100000b = 11111111b
-00111111b | 11100001b = 11111111b
-00111111b | 11100010b = 11111111b
-00111111b | 11100011b = 11111111b
-00111111b | 11100100b = 11111111b
-00111111b | 11100101b = 11111111b
-00111111b | 11100110b = 11111111b
-00111111b | 11100111b = 11111111b
-00111111b | 11101000b = 11111111b
-00111111b | 11101001b = 11111111b
-00111111b | 11101010b = 11111111b
-00111111b | 11101011b = 11111111b
-00111111b | 11101100b = 11111111b
-00111111b | 11101101b = 11111111b
-00111111b | 11101110b = 11111111b
-00111111b | 11101111b = 11111111b
-00111111b | 11110000b = 11111111b
-00111111b | 11110001b = 11111111b
-00111111b | 11110010b = 11111111b
-00111111b | 11110011b = 11111111b
-00111111b | 11110100b = 11111111b
-00111111b | 11110101b = 11111111b
-00111111b | 11110110b = 11111111b
-00111111b | 11110111b = 11111111b
-00111111b | 11111000b = 11111111b
-00111111b | 11111001b = 11111111b
-00111111b | 11111010b = 11111111b
-00111111b | 11111011b = 11111111b
-00111111b | 11111100b = 11111111b
-00111111b | 11111101b = 11111111b
-00111111b | 11111110b = 11111111b
-00111111b | 11111111b = 11111111b
-00111111b | 00000000b = 00111111b
-00111111b | 00000001b = 00111111b
-00111111b | 00000010b = 00111111b
-00111111b | 00000011b = 00111111b
-00111111b | 00000100b = 00111111b
-00111111b | 00000101b = 00111111b
-00111111b | 00000110b = 00111111b
-00111111b | 00000111b = 00111111b
-00111111b | 00001000b = 00111111b
-00111111b | 00001001b = 00111111b
-00111111b | 00001010b = 00111111b
-00111111b | 00001011b = 00111111b
-00111111b | 00001100b = 00111111b
-00111111b | 00001101b = 00111111b
-00111111b | 00001110b = 00111111b
-00111111b | 00001111b = 00111111b
-00111111b | 00010000b = 00111111b
-00111111b | 00010001b = 00111111b
-00111111b | 00010010b = 00111111b
-00111111b | 00010011b = 00111111b
-00111111b | 00010100b = 00111111b
-00111111b | 00010101b = 00111111b
-00111111b | 00010110b = 00111111b
-00111111b | 00010111b = 00111111b
-00111111b | 00011000b = 00111111b
-00111111b | 00011001b = 00111111b
-00111111b | 00011010b = 00111111b
-00111111b | 00011011b = 00111111b
-00111111b | 00011100b = 00111111b
-00111111b | 00011101b = 00111111b
-00111111b | 00011110b = 00111111b
-00111111b | 00011111b = 00111111b
-00111111b | 00100000b = 00111111b
-00111111b | 00100001b = 00111111b
-00111111b | 00100010b = 00111111b
-00111111b | 00100011b = 00111111b
-00111111b | 00100100b = 00111111b
-00111111b | 00100101b = 00111111b
-00111111b | 00100110b = 00111111b
-00111111b | 00100111b = 00111111b
-00111111b | 00101000b = 00111111b
-00111111b | 00101001b = 00111111b
-00111111b | 00101010b = 00111111b
-00111111b | 00101011b = 00111111b
-00111111b | 00101100b = 00111111b
-00111111b | 00101101b = 00111111b
-00111111b | 00101110b = 00111111b
-00111111b | 00101111b = 00111111b
-00111111b | 00110000b = 00111111b
-00111111b | 00110001b = 00111111b
-00111111b | 00110010b = 00111111b
-00111111b | 00110011b = 00111111b
-00111111b | 00110100b = 00111111b
-00111111b | 00110101b = 00111111b
-00111111b | 00110110b = 00111111b
-00111111b | 00110111b = 00111111b
-00111111b | 00111000b = 00111111b
-00111111b | 00111001b = 00111111b
-00111111b | 00111010b = 00111111b
-00111111b | 00111011b = 00111111b
-00111111b | 00111100b = 00111111b
-00111111b | 00111101b = 00111111b
-00111111b | 00111110b = 00111111b
-00111111b | 00111111b = 00111111b
-00111111b | 01000000b = 01111111b
-00111111b | 01000001b = 01111111b
-00111111b | 01000010b = 01111111b
-00111111b | 01000011b = 01111111b
-00111111b | 01000100b = 01111111b
-00111111b | 01000101b = 01111111b
-00111111b | 01000110b = 01111111b
-00111111b | 01000111b = 01111111b
-00111111b | 01001000b = 01111111b
-00111111b | 01001001b = 01111111b
-00111111b | 01001010b = 01111111b
-00111111b | 01001011b = 01111111b
-00111111b | 01001100b = 01111111b
-00111111b | 01001101b = 01111111b
-00111111b | 01001110b = 01111111b
-00111111b | 01001111b = 01111111b
-00111111b | 01010000b = 01111111b
-00111111b | 01010001b = 01111111b
-00111111b | 01010010b = 01111111b
-00111111b | 01010011b = 01111111b
-00111111b | 01010100b = 01111111b
-00111111b | 01010101b = 01111111b
-00111111b | 01010110b = 01111111b
-00111111b | 01010111b = 01111111b
-00111111b | 01011000b = 01111111b
-00111111b | 01011001b = 01111111b
-00111111b | 01011010b = 01111111b
-00111111b | 01011011b = 01111111b
-00111111b | 01011100b = 01111111b
-00111111b | 01011101b = 01111111b
-00111111b | 01011110b = 01111111b
-00111111b | 01011111b = 01111111b
-00111111b | 01100000b = 01111111b
-00111111b | 01100001b = 01111111b
-00111111b | 01100010b = 01111111b
-00111111b | 01100011b = 01111111b
-00111111b | 01100100b = 01111111b
-00111111b | 01100101b = 01111111b
-00111111b | 01100110b = 01111111b
-00111111b | 01100111b = 01111111b
-00111111b | 01101000b = 01111111b
-00111111b | 01101001b = 01111111b
-00111111b | 01101010b = 01111111b
-00111111b | 01101011b = 01111111b
-00111111b | 01101100b = 01111111b
-00111111b | 01101101b = 01111111b
-00111111b | 01101110b = 01111111b
-00111111b | 01101111b = 01111111b
-00111111b | 01110000b = 01111111b
-00111111b | 01110001b = 01111111b
-00111111b | 01110010b = 01111111b
-00111111b | 01110011b = 01111111b
-00111111b | 01110100b = 01111111b
-00111111b | 01110101b = 01111111b
-00111111b | 01110110b = 01111111b
-00111111b | 01110111b = 01111111b
-00111111b | 01111000b = 01111111b
-00111111b | 01111001b = 01111111b
-00111111b | 01111010b = 01111111b
-00111111b | 01111011b = 01111111b
-00111111b | 01111100b = 01111111b
-00111111b | 01111101b = 01111111b
-00111111b | 01111110b = 01111111b
-01000000b | 10000000b = 11000000b
-01000000b | 10000001b = 11000001b
-01000000b | 10000010b = 11000010b
-01000000b | 10000011b = 11000011b
-01000000b | 10000100b = 11000100b
-01000000b | 10000101b = 11000101b
-01000000b | 10000110b = 11000110b
-01000000b | 10000111b = 11000111b
-01000000b | 10001000b = 11001000b
-01000000b | 10001001b = 11001001b
-01000000b | 10001010b = 11001010b
-01000000b | 10001011b = 11001011b
-01000000b | 10001100b = 11001100b
-01000000b | 10001101b = 11001101b
-01000000b | 10001110b = 11001110b
-01000000b | 10001111b = 11001111b
-01000000b | 10010000b = 11010000b
-01000000b | 10010001b = 11010001b
-01000000b | 10010010b = 11010010b
-01000000b | 10010011b = 11010011b
-01000000b | 10010100b = 11010100b
-01000000b | 10010101b = 11010101b
-01000000b | 10010110b = 11010110b
-01000000b | 10010111b = 11010111b
-01000000b | 10011000b = 11011000b
-01000000b | 10011001b = 11011001b
-01000000b | 10011010b = 11011010b
-01000000b | 10011011b = 11011011b
-01000000b | 10011100b = 11011100b
-01000000b | 10011101b = 11011101b
-01000000b | 10011110b = 11011110b
-01000000b | 10011111b = 11011111b
-01000000b | 10100000b = 11100000b
-01000000b | 10100001b = 11100001b
-01000000b | 10100010b = 11100010b
-01000000b | 10100011b = 11100011b
-01000000b | 10100100b = 11100100b
-01000000b | 10100101b = 11100101b
-01000000b | 10100110b = 11100110b
-01000000b | 10100111b = 11100111b
-01000000b | 10101000b = 11101000b
-01000000b | 10101001b = 11101001b
-01000000b | 10101010b = 11101010b
-01000000b | 10101011b = 11101011b
-01000000b | 10101100b = 11101100b
-01000000b | 10101101b = 11101101b
-01000000b | 10101110b = 11101110b
-01000000b | 10101111b = 11101111b
-01000000b | 10110000b = 11110000b
-01000000b | 10110001b = 11110001b
-01000000b | 10110010b = 11110010b
-01000000b | 10110011b = 11110011b
-01000000b | 10110100b = 11110100b
-01000000b | 10110101b = 11110101b
-01000000b | 10110110b = 11110110b
-01000000b | 10110111b = 11110111b
-01000000b | 10111000b = 11111000b
-01000000b | 10111001b = 11111001b
-01000000b | 10111010b = 11111010b
-01000000b | 10111011b = 11111011b
-01000000b | 10111100b = 11111100b
-01000000b | 10111101b = 11111101b
-01000000b | 10111110b = 11111110b
-01000000b | 10111111b = 11111111b
-01000000b | 11000000b = 11000000b
-01000000b | 11000001b = 11000001b
-01000000b | 11000010b = 11000010b
-01000000b | 11000011b = 11000011b
-01000000b | 11000100b = 11000100b
-01000000b | 11000101b = 11000101b
-01000000b | 11000110b = 11000110b
-01000000b | 11000111b = 11000111b
-01000000b | 11001000b = 11001000b
-01000000b | 11001001b = 11001001b
-01000000b | 11001010b = 11001010b
-01000000b | 11001011b = 11001011b
-01000000b | 11001100b = 11001100b
-01000000b | 11001101b = 11001101b
-01000000b | 11001110b = 11001110b
-01000000b | 11001111b = 11001111b
-01000000b | 11010000b = 11010000b
-01000000b | 11010001b = 11010001b
-01000000b | 11010010b = 11010010b
-01000000b | 11010011b = 11010011b
-01000000b | 11010100b = 11010100b
-01000000b | 11010101b = 11010101b
-01000000b | 11010110b = 11010110b
-01000000b | 11010111b = 11010111b
-01000000b | 11011000b = 11011000b
-01000000b | 11011001b = 11011001b
-01000000b | 11011010b = 11011010b
-01000000b | 11011011b = 11011011b
-01000000b | 11011100b = 11011100b
-01000000b | 11011101b = 11011101b
-01000000b | 11011110b = 11011110b
-01000000b | 11011111b = 11011111b
-01000000b | 11100000b = 11100000b
-01000000b | 11100001b = 11100001b
-01000000b | 11100010b = 11100010b
-01000000b | 11100011b = 11100011b
-01000000b | 11100100b = 11100100b
-01000000b | 11100101b = 11100101b
-01000000b | 11100110b = 11100110b
-01000000b | 11100111b = 11100111b
-01000000b | 11101000b = 11101000b
-01000000b | 11101001b = 11101001b
-01000000b | 11101010b = 11101010b
-01000000b | 11101011b = 11101011b
-01000000b | 11101100b = 11101100b
-01000000b | 11101101b = 11101101b
-01000000b | 11101110b = 11101110b
-01000000b | 11101111b = 11101111b
-01000000b | 11110000b = 11110000b
-01000000b | 11110001b = 11110001b
-01000000b | 11110010b = 11110010b
-01000000b | 11110011b = 11110011b
-01000000b | 11110100b = 11110100b
-01000000b | 11110101b = 11110101b
-01000000b | 11110110b = 11110110b
-01000000b | 11110111b = 11110111b
-01000000b | 11111000b = 11111000b
-01000000b | 11111001b = 11111001b
-01000000b | 11111010b = 11111010b
-01000000b | 11111011b = 11111011b
-01000000b | 11111100b = 11111100b
-01000000b | 11111101b = 11111101b
-01000000b | 11111110b = 11111110b
-01000000b | 11111111b = 11111111b
-01000000b | 00000000b = 01000000b
-01000000b | 00000001b = 01000001b
-01000000b | 00000010b = 01000010b
-01000000b | 00000011b = 01000011b
-01000000b | 00000100b = 01000100b
-01000000b | 00000101b = 01000101b
-01000000b | 00000110b = 01000110b
-01000000b | 00000111b = 01000111b
-01000000b | 00001000b = 01001000b
-01000000b | 00001001b = 01001001b
-01000000b | 00001010b = 01001010b
-01000000b | 00001011b = 01001011b
-01000000b | 00001100b = 01001100b
-01000000b | 00001101b = 01001101b
-01000000b | 00001110b = 01001110b
-01000000b | 00001111b = 01001111b
-01000000b | 00010000b = 01010000b
-01000000b | 00010001b = 01010001b
-01000000b | 00010010b = 01010010b
-01000000b | 00010011b = 01010011b
-01000000b | 00010100b = 01010100b
-01000000b | 00010101b = 01010101b
-01000000b | 00010110b = 01010110b
-01000000b | 00010111b = 01010111b
-01000000b | 00011000b = 01011000b
-01000000b | 00011001b = 01011001b
-01000000b | 00011010b = 01011010b
-01000000b | 00011011b = 01011011b
-01000000b | 00011100b = 01011100b
-01000000b | 00011101b = 01011101b
-01000000b | 00011110b = 01011110b
-01000000b | 00011111b = 01011111b
-01000000b | 00100000b = 01100000b
-01000000b | 00100001b = 01100001b
-01000000b | 00100010b = 01100010b
-01000000b | 00100011b = 01100011b
-01000000b | 00100100b = 01100100b
-01000000b | 00100101b = 01100101b
-01000000b | 00100110b = 01100110b
-01000000b | 00100111b = 01100111b
-01000000b | 00101000b = 01101000b
-01000000b | 00101001b = 01101001b
-01000000b | 00101010b = 01101010b
-01000000b | 00101011b = 01101011b
-01000000b | 00101100b = 01101100b
-01000000b | 00101101b = 01101101b
-01000000b | 00101110b = 01101110b
-01000000b | 00101111b = 01101111b
-01000000b | 00110000b = 01110000b
-01000000b | 00110001b = 01110001b
-01000000b | 00110010b = 01110010b
-01000000b | 00110011b = 01110011b
-01000000b | 00110100b = 01110100b
-01000000b | 00110101b = 01110101b
-01000000b | 00110110b = 01110110b
-01000000b | 00110111b = 01110111b
-01000000b | 00111000b = 01111000b
-01000000b | 00111001b = 01111001b
-01000000b | 00111010b = 01111010b
-01000000b | 00111011b = 01111011b
-01000000b | 00111100b = 01111100b
-01000000b | 00111101b = 01111101b
-01000000b | 00111110b = 01111110b
-01000000b | 00111111b = 01111111b
-01000000b | 01000000b = 01000000b
-01000000b | 01000001b = 01000001b
-01000000b | 01000010b = 01000010b
-01000000b | 01000011b = 01000011b
-01000000b | 01000100b = 01000100b
-01000000b | 01000101b = 01000101b
-01000000b | 01000110b = 01000110b
-01000000b | 01000111b = 01000111b
-01000000b | 01001000b = 01001000b
-01000000b | 01001001b = 01001001b
-01000000b | 01001010b = 01001010b
-01000000b | 01001011b = 01001011b
-01000000b | 01001100b = 01001100b
-01000000b | 01001101b = 01001101b
-01000000b | 01001110b = 01001110b
-01000000b | 01001111b = 01001111b
-01000000b | 01010000b = 01010000b
-01000000b | 01010001b = 01010001b
-01000000b | 01010010b = 01010010b
-01000000b | 01010011b = 01010011b
-01000000b | 01010100b = 01010100b
-01000000b | 01010101b = 01010101b
-01000000b | 01010110b = 01010110b
-01000000b | 01010111b = 01010111b
-01000000b | 01011000b = 01011000b
-01000000b | 01011001b = 01011001b
-01000000b | 01011010b = 01011010b
-01000000b | 01011011b = 01011011b
-01000000b | 01011100b = 01011100b
-01000000b | 01011101b = 01011101b
-01000000b | 01011110b = 01011110b
-01000000b | 01011111b = 01011111b
-01000000b | 01100000b = 01100000b
-01000000b | 01100001b = 01100001b
-01000000b | 01100010b = 01100010b
-01000000b | 01100011b = 01100011b
-01000000b | 01100100b = 01100100b
-01000000b | 01100101b = 01100101b
-01000000b | 01100110b = 01100110b
-01000000b | 01100111b = 01100111b
-01000000b | 01101000b = 01101000b
-01000000b | 01101001b = 01101001b
-01000000b | 01101010b = 01101010b
-01000000b | 01101011b = 01101011b
-01000000b | 01101100b = 01101100b
-01000000b | 01101101b = 01101101b
-01000000b | 01101110b = 01101110b
-01000000b | 01101111b = 01101111b
-01000000b | 01110000b = 01110000b
-01000000b | 01110001b = 01110001b
-01000000b | 01110010b = 01110010b
-01000000b | 01110011b = 01110011b
-01000000b | 01110100b = 01110100b
-01000000b | 01110101b = 01110101b
-01000000b | 01110110b = 01110110b
-01000000b | 01110111b = 01110111b
-01000000b | 01111000b = 01111000b
-01000000b | 01111001b = 01111001b
-01000000b | 01111010b = 01111010b
-01000000b | 01111011b = 01111011b
-01000000b | 01111100b = 01111100b
-01000000b | 01111101b = 01111101b
-01000000b | 01111110b = 01111110b
-01000001b | 10000000b = 11000001b
-01000001b | 10000001b = 11000001b
-01000001b | 10000010b = 11000011b
-01000001b | 10000011b = 11000011b
-01000001b | 10000100b = 11000101b
-01000001b | 10000101b = 11000101b
-01000001b | 10000110b = 11000111b
-01000001b | 10000111b = 11000111b
-01000001b | 10001000b = 11001001b
-01000001b | 10001001b = 11001001b
-01000001b | 10001010b = 11001011b
-01000001b | 10001011b = 11001011b
-01000001b | 10001100b = 11001101b
-01000001b | 10001101b = 11001101b
-01000001b | 10001110b = 11001111b
-01000001b | 10001111b = 11001111b
-01000001b | 10010000b = 11010001b
-01000001b | 10010001b = 11010001b
-01000001b | 10010010b = 11010011b
-01000001b | 10010011b = 11010011b
-01000001b | 10010100b = 11010101b
-01000001b | 10010101b = 11010101b
-01000001b | 10010110b = 11010111b
-01000001b | 10010111b = 11010111b
-01000001b | 10011000b = 11011001b
-01000001b | 10011001b = 11011001b
-01000001b | 10011010b = 11011011b
-01000001b | 10011011b = 11011011b
-01000001b | 10011100b = 11011101b
-01000001b | 10011101b = 11011101b
-01000001b | 10011110b = 11011111b
-01000001b | 10011111b = 11011111b
-01000001b | 10100000b = 11100001b
-01000001b | 10100001b = 11100001b
-01000001b | 10100010b = 11100011b
-01000001b | 10100011b = 11100011b
-01000001b | 10100100b = 11100101b
-01000001b | 10100101b = 11100101b
-01000001b | 10100110b = 11100111b
-01000001b | 10100111b = 11100111b
-01000001b | 10101000b = 11101001b
-01000001b | 10101001b = 11101001b
-01000001b | 10101010b = 11101011b
-01000001b | 10101011b = 11101011b
-01000001b | 10101100b = 11101101b
-01000001b | 10101101b = 11101101b
-01000001b | 10101110b = 11101111b
-01000001b | 10101111b = 11101111b
-01000001b | 10110000b = 11110001b
-01000001b | 10110001b = 11110001b
-01000001b | 10110010b = 11110011b
-01000001b | 10110011b = 11110011b
-01000001b | 10110100b = 11110101b
-01000001b | 10110101b = 11110101b
-01000001b | 10110110b = 11110111b
-01000001b | 10110111b = 11110111b
-01000001b | 10111000b = 11111001b
-01000001b | 10111001b = 11111001b
-01000001b | 10111010b = 11111011b
-01000001b | 10111011b = 11111011b
-01000001b | 10111100b = 11111101b
-01000001b | 10111101b = 11111101b
-01000001b | 10111110b = 11111111b
-01000001b | 10111111b = 11111111b
-01000001b | 11000000b = 11000001b
-01000001b | 11000001b = 11000001b
-01000001b | 11000010b = 11000011b
-01000001b | 11000011b = 11000011b
-01000001b | 11000100b = 11000101b
-01000001b | 11000101b = 11000101b
-01000001b | 11000110b = 11000111b
-01000001b | 11000111b = 11000111b
-01000001b | 11001000b = 11001001b
-01000001b | 11001001b = 11001001b
-01000001b | 11001010b = 11001011b
-01000001b | 11001011b = 11001011b
-01000001b | 11001100b = 11001101b
-01000001b | 11001101b = 11001101b
-01000001b | 11001110b = 11001111b
-01000001b | 11001111b = 11001111b
-01000001b | 11010000b = 11010001b
-01000001b | 11010001b = 11010001b
-01000001b | 11010010b = 11010011b
-01000001b | 11010011b = 11010011b
-01000001b | 11010100b = 11010101b
-01000001b | 11010101b = 11010101b
-01000001b | 11010110b = 11010111b
-01000001b | 11010111b = 11010111b
-01000001b | 11011000b = 11011001b
-01000001b | 11011001b = 11011001b
-01000001b | 11011010b = 11011011b
-01000001b | 11011011b = 11011011b
-01000001b | 11011100b = 11011101b
-01000001b | 11011101b = 11011101b
-01000001b | 11011110b = 11011111b
-01000001b | 11011111b = 11011111b
-01000001b | 11100000b = 11100001b
-01000001b | 11100001b = 11100001b
-01000001b | 11100010b = 11100011b
-01000001b | 11100011b = 11100011b
-01000001b | 11100100b = 11100101b
-01000001b | 11100101b = 11100101b
-01000001b | 11100110b = 11100111b
-01000001b | 11100111b = 11100111b
-01000001b | 11101000b = 11101001b
-01000001b | 11101001b = 11101001b
-01000001b | 11101010b = 11101011b
-01000001b | 11101011b = 11101011b
-01000001b | 11101100b = 11101101b
-01000001b | 11101101b = 11101101b
-01000001b | 11101110b = 11101111b
-01000001b | 11101111b = 11101111b
-01000001b | 11110000b = 11110001b
-01000001b | 11110001b = 11110001b
-01000001b | 11110010b = 11110011b
-01000001b | 11110011b = 11110011b
-01000001b | 11110100b = 11110101b
-01000001b | 11110101b = 11110101b
-01000001b | 11110110b = 11110111b
-01000001b | 11110111b = 11110111b
-01000001b | 11111000b = 11111001b
-01000001b | 11111001b = 11111001b
-01000001b | 11111010b = 11111011b
-01000001b | 11111011b = 11111011b
-01000001b | 11111100b = 11111101b
-01000001b | 11111101b = 11111101b
-01000001b | 11111110b = 11111111b
-01000001b | 11111111b = 11111111b
-01000001b | 00000000b = 01000001b
-01000001b | 00000001b = 01000001b
-01000001b | 00000010b = 01000011b
-01000001b | 00000011b = 01000011b
-01000001b | 00000100b = 01000101b
-01000001b | 00000101b = 01000101b
-01000001b | 00000110b = 01000111b
-01000001b | 00000111b = 01000111b
-01000001b | 00001000b = 01001001b
-01000001b | 00001001b = 01001001b
-01000001b | 00001010b = 01001011b
-01000001b | 00001011b = 01001011b
-01000001b | 00001100b = 01001101b
-01000001b | 00001101b = 01001101b
-01000001b | 00001110b = 01001111b
-01000001b | 00001111b = 01001111b
-01000001b | 00010000b = 01010001b
-01000001b | 00010001b = 01010001b
-01000001b | 00010010b = 01010011b
-01000001b | 00010011b = 01010011b
-01000001b | 00010100b = 01010101b
-01000001b | 00010101b = 01010101b
-01000001b | 00010110b = 01010111b
-01000001b | 00010111b = 01010111b
-01000001b | 00011000b = 01011001b
-01000001b | 00011001b = 01011001b
-01000001b | 00011010b = 01011011b
-01000001b | 00011011b = 01011011b
-01000001b | 00011100b = 01011101b
-01000001b | 00011101b = 01011101b
-01000001b | 00011110b = 01011111b
-01000001b | 00011111b = 01011111b
-01000001b | 00100000b = 01100001b
-01000001b | 00100001b = 01100001b
-01000001b | 00100010b = 01100011b
-01000001b | 00100011b = 01100011b
-01000001b | 00100100b = 01100101b
-01000001b | 00100101b = 01100101b
-01000001b | 00100110b = 01100111b
-01000001b | 00100111b = 01100111b
-01000001b | 00101000b = 01101001b
-01000001b | 00101001b = 01101001b
-01000001b | 00101010b = 01101011b
-01000001b | 00101011b = 01101011b
-01000001b | 00101100b = 01101101b
-01000001b | 00101101b = 01101101b
-01000001b | 00101110b = 01101111b
-01000001b | 00101111b = 01101111b
-01000001b | 00110000b = 01110001b
-01000001b | 00110001b = 01110001b
-01000001b | 00110010b = 01110011b
-01000001b | 00110011b = 01110011b
-01000001b | 00110100b = 01110101b
-01000001b | 00110101b = 01110101b
-01000001b | 00110110b = 01110111b
-01000001b | 00110111b = 01110111b
-01000001b | 00111000b = 01111001b
-01000001b | 00111001b = 01111001b
-01000001b | 00111010b = 01111011b
-01000001b | 00111011b = 01111011b
-01000001b | 00111100b = 01111101b
-01000001b | 00111101b = 01111101b
-01000001b | 00111110b = 01111111b
-01000001b | 00111111b = 01111111b
-01000001b | 01000000b = 01000001b
-01000001b | 01000001b = 01000001b
-01000001b | 01000010b = 01000011b
-01000001b | 01000011b = 01000011b
-01000001b | 01000100b = 01000101b
-01000001b | 01000101b = 01000101b
-01000001b | 01000110b = 01000111b
-01000001b | 01000111b = 01000111b
-01000001b | 01001000b = 01001001b
-01000001b | 01001001b = 01001001b
-01000001b | 01001010b = 01001011b
-01000001b | 01001011b = 01001011b
-01000001b | 01001100b = 01001101b
-01000001b | 01001101b = 01001101b
-01000001b | 01001110b = 01001111b
-01000001b | 01001111b = 01001111b
-01000001b | 01010000b = 01010001b
-01000001b | 01010001b = 01010001b
-01000001b | 01010010b = 01010011b
-01000001b | 01010011b = 01010011b
-01000001b | 01010100b = 01010101b
-01000001b | 01010101b = 01010101b
-01000001b | 01010110b = 01010111b
-01000001b | 01010111b = 01010111b
-01000001b | 01011000b = 01011001b
-01000001b | 01011001b = 01011001b
-01000001b | 01011010b = 01011011b
-01000001b | 01011011b = 01011011b
-01000001b | 01011100b = 01011101b
-01000001b | 01011101b = 01011101b
-01000001b | 01011110b = 01011111b
-01000001b | 01011111b = 01011111b
-01000001b | 01100000b = 01100001b
-01000001b | 01100001b = 01100001b
-01000001b | 01100010b = 01100011b
-01000001b | 01100011b = 01100011b
-01000001b | 01100100b = 01100101b
-01000001b | 01100101b = 01100101b
-01000001b | 01100110b = 01100111b
-01000001b | 01100111b = 01100111b
-01000001b | 01101000b = 01101001b
-01000001b | 01101001b = 01101001b
-01000001b | 01101010b = 01101011b
-01000001b | 01101011b = 01101011b
-01000001b | 01101100b = 01101101b
-01000001b | 01101101b = 01101101b
-01000001b | 01101110b = 01101111b
-01000001b | 01101111b = 01101111b
-01000001b | 01110000b = 01110001b
-01000001b | 01110001b = 01110001b
-01000001b | 01110010b = 01110011b
-01000001b | 01110011b = 01110011b
-01000001b | 01110100b = 01110101b
-01000001b | 01110101b = 01110101b
-01000001b | 01110110b = 01110111b
-01000001b | 01110111b = 01110111b
-01000001b | 01111000b = 01111001b
-01000001b | 01111001b = 01111001b
-01000001b | 01111010b = 01111011b
-01000001b | 01111011b = 01111011b
-01000001b | 01111100b = 01111101b
-01000001b | 01111101b = 01111101b
-01000001b | 01111110b = 01111111b
-01000010b | 10000000b = 11000010b
-01000010b | 10000001b = 11000011b
-01000010b | 10000010b = 11000010b
-01000010b | 10000011b = 11000011b
-01000010b | 10000100b = 11000110b
-01000010b | 10000101b = 11000111b
-01000010b | 10000110b = 11000110b
-01000010b | 10000111b = 11000111b
-01000010b | 10001000b = 11001010b
-01000010b | 10001001b = 11001011b
-01000010b | 10001010b = 11001010b
-01000010b | 10001011b = 11001011b
-01000010b | 10001100b = 11001110b
-01000010b | 10001101b = 11001111b
-01000010b | 10001110b = 11001110b
-01000010b | 10001111b = 11001111b
-01000010b | 10010000b = 11010010b
-01000010b | 10010001b = 11010011b
-01000010b | 10010010b = 11010010b
-01000010b | 10010011b = 11010011b
-01000010b | 10010100b = 11010110b
-01000010b | 10010101b = 11010111b
-01000010b | 10010110b = 11010110b
-01000010b | 10010111b = 11010111b
-01000010b | 10011000b = 11011010b
-01000010b | 10011001b = 11011011b
-01000010b | 10011010b = 11011010b
-01000010b | 10011011b = 11011011b
-01000010b | 10011100b = 11011110b
-01000010b | 10011101b = 11011111b
-01000010b | 10011110b = 11011110b
-01000010b | 10011111b = 11011111b
-01000010b | 10100000b = 11100010b
-01000010b | 10100001b = 11100011b
-01000010b | 10100010b = 11100010b
-01000010b | 10100011b = 11100011b
-01000010b | 10100100b = 11100110b
-01000010b | 10100101b = 11100111b
-01000010b | 10100110b = 11100110b
-01000010b | 10100111b = 11100111b
-01000010b | 10101000b = 11101010b
-01000010b | 10101001b = 11101011b
-01000010b | 10101010b = 11101010b
-01000010b | 10101011b = 11101011b
-01000010b | 10101100b = 11101110b
-01000010b | 10101101b = 11101111b
-01000010b | 10101110b = 11101110b
-01000010b | 10101111b = 11101111b
-01000010b | 10110000b = 11110010b
-01000010b | 10110001b = 11110011b
-01000010b | 10110010b = 11110010b
-01000010b | 10110011b = 11110011b
-01000010b | 10110100b = 11110110b
-01000010b | 10110101b = 11110111b
-01000010b | 10110110b = 11110110b
-01000010b | 10110111b = 11110111b
-01000010b | 10111000b = 11111010b
-01000010b | 10111001b = 11111011b
-01000010b | 10111010b = 11111010b
-01000010b | 10111011b = 11111011b
-01000010b | 10111100b = 11111110b
-01000010b | 10111101b = 11111111b
-01000010b | 10111110b = 11111110b
-01000010b | 10111111b = 11111111b
-01000010b | 11000000b = 11000010b
-01000010b | 11000001b = 11000011b
-01000010b | 11000010b = 11000010b
-01000010b | 11000011b = 11000011b
-01000010b | 11000100b = 11000110b
-01000010b | 11000101b = 11000111b
-01000010b | 11000110b = 11000110b
-01000010b | 11000111b = 11000111b
-01000010b | 11001000b = 11001010b
-01000010b | 11001001b = 11001011b
-01000010b | 11001010b = 11001010b
-01000010b | 11001011b = 11001011b
-01000010b | 11001100b = 11001110b
-01000010b | 11001101b = 11001111b
-01000010b | 11001110b = 11001110b
-01000010b | 11001111b = 11001111b
-01000010b | 11010000b = 11010010b
-01000010b | 11010001b = 11010011b
-01000010b | 11010010b = 11010010b
-01000010b | 11010011b = 11010011b
-01000010b | 11010100b = 11010110b
-01000010b | 11010101b = 11010111b
-01000010b | 11010110b = 11010110b
-01000010b | 11010111b = 11010111b
-01000010b | 11011000b = 11011010b
-01000010b | 11011001b = 11011011b
-01000010b | 11011010b = 11011010b
-01000010b | 11011011b = 11011011b
-01000010b | 11011100b = 11011110b
-01000010b | 11011101b = 11011111b
-01000010b | 11011110b = 11011110b
-01000010b | 11011111b = 11011111b
-01000010b | 11100000b = 11100010b
-01000010b | 11100001b = 11100011b
-01000010b | 11100010b = 11100010b
-01000010b | 11100011b = 11100011b
-01000010b | 11100100b = 11100110b
-01000010b | 11100101b = 11100111b
-01000010b | 11100110b = 11100110b
-01000010b | 11100111b = 11100111b
-01000010b | 11101000b = 11101010b
-01000010b | 11101001b = 11101011b
-01000010b | 11101010b = 11101010b
-01000010b | 11101011b = 11101011b
-01000010b | 11101100b = 11101110b
-01000010b | 11101101b = 11101111b
-01000010b | 11101110b = 11101110b
-01000010b | 11101111b = 11101111b
-01000010b | 11110000b = 11110010b
-01000010b | 11110001b = 11110011b
-01000010b | 11110010b = 11110010b
-01000010b | 11110011b = 11110011b
-01000010b | 11110100b = 11110110b
-01000010b | 11110101b = 11110111b
-01000010b | 11110110b = 11110110b
-01000010b | 11110111b = 11110111b
-01000010b | 11111000b = 11111010b
-01000010b | 11111001b = 11111011b
-01000010b | 11111010b = 11111010b
-01000010b | 11111011b = 11111011b
-01000010b | 11111100b = 11111110b
-01000010b | 11111101b = 11111111b
-01000010b | 11111110b = 11111110b
-01000010b | 11111111b = 11111111b
-01000010b | 00000000b = 01000010b
-01000010b | 00000001b = 01000011b
-01000010b | 00000010b = 01000010b
-01000010b | 00000011b = 01000011b
-01000010b | 00000100b = 01000110b
-01000010b | 00000101b = 01000111b
-01000010b | 00000110b = 01000110b
-01000010b | 00000111b = 01000111b
-01000010b | 00001000b = 01001010b
-01000010b | 00001001b = 01001011b
-01000010b | 00001010b = 01001010b
-01000010b | 00001011b = 01001011b
-01000010b | 00001100b = 01001110b
-01000010b | 00001101b = 01001111b
-01000010b | 00001110b = 01001110b
-01000010b | 00001111b = 01001111b
-01000010b | 00010000b = 01010010b
-01000010b | 00010001b = 01010011b
-01000010b | 00010010b = 01010010b
-01000010b | 00010011b = 01010011b
-01000010b | 00010100b = 01010110b
-01000010b | 00010101b = 01010111b
-01000010b | 00010110b = 01010110b
-01000010b | 00010111b = 01010111b
-01000010b | 00011000b = 01011010b
-01000010b | 00011001b = 01011011b
-01000010b | 00011010b = 01011010b
-01000010b | 00011011b = 01011011b
-01000010b | 00011100b = 01011110b
-01000010b | 00011101b = 01011111b
-01000010b | 00011110b = 01011110b
-01000010b | 00011111b = 01011111b
-01000010b | 00100000b = 01100010b
-01000010b | 00100001b = 01100011b
-01000010b | 00100010b = 01100010b
-01000010b | 00100011b = 01100011b
-01000010b | 00100100b = 01100110b
-01000010b | 00100101b = 01100111b
-01000010b | 00100110b = 01100110b
-01000010b | 00100111b = 01100111b
-01000010b | 00101000b = 01101010b
-01000010b | 00101001b = 01101011b
-01000010b | 00101010b = 01101010b
-01000010b | 00101011b = 01101011b
-01000010b | 00101100b = 01101110b
-01000010b | 00101101b = 01101111b
-01000010b | 00101110b = 01101110b
-01000010b | 00101111b = 01101111b
-01000010b | 00110000b = 01110010b
-01000010b | 00110001b = 01110011b
-01000010b | 00110010b = 01110010b
-01000010b | 00110011b = 01110011b
-01000010b | 00110100b = 01110110b
-01000010b | 00110101b = 01110111b
-01000010b | 00110110b = 01110110b
-01000010b | 00110111b = 01110111b
-01000010b | 00111000b = 01111010b
-01000010b | 00111001b = 01111011b
-01000010b | 00111010b = 01111010b
-01000010b | 00111011b = 01111011b
-01000010b | 00111100b = 01111110b
-01000010b | 00111101b = 01111111b
-01000010b | 00111110b = 01111110b
-01000010b | 00111111b = 01111111b
-01000010b | 01000000b = 01000010b
-01000010b | 01000001b = 01000011b
-01000010b | 01000010b = 01000010b
-01000010b | 01000011b = 01000011b
-01000010b | 01000100b = 01000110b
-01000010b | 01000101b = 01000111b
-01000010b | 01000110b = 01000110b
-01000010b | 01000111b = 01000111b
-01000010b | 01001000b = 01001010b
-01000010b | 01001001b = 01001011b
-01000010b | 01001010b = 01001010b
-01000010b | 01001011b = 01001011b
-01000010b | 01001100b = 01001110b
-01000010b | 01001101b = 01001111b
-01000010b | 01001110b = 01001110b
-01000010b | 01001111b = 01001111b
-01000010b | 01010000b = 01010010b
-01000010b | 01010001b = 01010011b
-01000010b | 01010010b = 01010010b
-01000010b | 01010011b = 01010011b
-01000010b | 01010100b = 01010110b
-01000010b | 01010101b = 01010111b
-01000010b | 01010110b = 01010110b
-01000010b | 01010111b = 01010111b
-01000010b | 01011000b = 01011010b
-01000010b | 01011001b = 01011011b
-01000010b | 01011010b = 01011010b
-01000010b | 01011011b = 01011011b
-01000010b | 01011100b = 01011110b
-01000010b | 01011101b = 01011111b
-01000010b | 01011110b = 01011110b
-01000010b | 01011111b = 01011111b
-01000010b | 01100000b = 01100010b
-01000010b | 01100001b = 01100011b
-01000010b | 01100010b = 01100010b
-01000010b | 01100011b = 01100011b
-01000010b | 01100100b = 01100110b
-01000010b | 01100101b = 01100111b
-01000010b | 01100110b = 01100110b
-01000010b | 01100111b = 01100111b
-01000010b | 01101000b = 01101010b
-01000010b | 01101001b = 01101011b
-01000010b | 01101010b = 01101010b
-01000010b | 01101011b = 01101011b
-01000010b | 01101100b = 01101110b
-01000010b | 01101101b = 01101111b
-01000010b | 01101110b = 01101110b
-01000010b | 01101111b = 01101111b
-01000010b | 01110000b = 01110010b
-01000010b | 01110001b = 01110011b
-01000010b | 01110010b = 01110010b
-01000010b | 01110011b = 01110011b
-01000010b | 01110100b = 01110110b
-01000010b | 01110101b = 01110111b
-01000010b | 01110110b = 01110110b
-01000010b | 01110111b = 01110111b
-01000010b | 01111000b = 01111010b
-01000010b | 01111001b = 01111011b
-01000010b | 01111010b = 01111010b
-01000010b | 01111011b = 01111011b
-01000010b | 01111100b = 01111110b
-01000010b | 01111101b = 01111111b
-01000010b | 01111110b = 01111110b
-01000011b | 10000000b = 11000011b
-01000011b | 10000001b = 11000011b
-01000011b | 10000010b = 11000011b
-01000011b | 10000011b = 11000011b
-01000011b | 10000100b = 11000111b
-01000011b | 10000101b = 11000111b
-01000011b | 10000110b = 11000111b
-01000011b | 10000111b = 11000111b
-01000011b | 10001000b = 11001011b
-01000011b | 10001001b = 11001011b
-01000011b | 10001010b = 11001011b
-01000011b | 10001011b = 11001011b
-01000011b | 10001100b = 11001111b
-01000011b | 10001101b = 11001111b
-01000011b | 10001110b = 11001111b
-01000011b | 10001111b = 11001111b
-01000011b | 10010000b = 11010011b
-01000011b | 10010001b = 11010011b
-01000011b | 10010010b = 11010011b
-01000011b | 10010011b = 11010011b
-01000011b | 10010100b = 11010111b
-01000011b | 10010101b = 11010111b
-01000011b | 10010110b = 11010111b
-01000011b | 10010111b = 11010111b
-01000011b | 10011000b = 11011011b
-01000011b | 10011001b = 11011011b
-01000011b | 10011010b = 11011011b
-01000011b | 10011011b = 11011011b
-01000011b | 10011100b = 11011111b
-01000011b | 10011101b = 11011111b
-01000011b | 10011110b = 11011111b
-01000011b | 10011111b = 11011111b
-01000011b | 10100000b = 11100011b
-01000011b | 10100001b = 11100011b
-01000011b | 10100010b = 11100011b
-01000011b | 10100011b = 11100011b
-01000011b | 10100100b = 11100111b
-01000011b | 10100101b = 11100111b
-01000011b | 10100110b = 11100111b
-01000011b | 10100111b = 11100111b
-01000011b | 10101000b = 11101011b
-01000011b | 10101001b = 11101011b
-01000011b | 10101010b = 11101011b
-01000011b | 10101011b = 11101011b
-01000011b | 10101100b = 11101111b
-01000011b | 10101101b = 11101111b
-01000011b | 10101110b = 11101111b
-01000011b | 10101111b = 11101111b
-01000011b | 10110000b = 11110011b
-01000011b | 10110001b = 11110011b
-01000011b | 10110010b = 11110011b
-01000011b | 10110011b = 11110011b
-01000011b | 10110100b = 11110111b
-01000011b | 10110101b = 11110111b
-01000011b | 10110110b = 11110111b
-01000011b | 10110111b = 11110111b
-01000011b | 10111000b = 11111011b
-01000011b | 10111001b = 11111011b
-01000011b | 10111010b = 11111011b
-01000011b | 10111011b = 11111011b
-01000011b | 10111100b = 11111111b
-01000011b | 10111101b = 11111111b
-01000011b | 10111110b = 11111111b
-01000011b | 10111111b = 11111111b
-01000011b | 11000000b = 11000011b
-01000011b | 11000001b = 11000011b
-01000011b | 11000010b = 11000011b
-01000011b | 11000011b = 11000011b
-01000011b | 11000100b = 11000111b
-01000011b | 11000101b = 11000111b
-01000011b | 11000110b = 11000111b
-01000011b | 11000111b = 11000111b
-01000011b | 11001000b = 11001011b
-01000011b | 11001001b = 11001011b
-01000011b | 11001010b = 11001011b
-01000011b | 11001011b = 11001011b
-01000011b | 11001100b = 11001111b
-01000011b | 11001101b = 11001111b
-01000011b | 11001110b = 11001111b
-01000011b | 11001111b = 11001111b
-01000011b | 11010000b = 11010011b
-01000011b | 11010001b = 11010011b
-01000011b | 11010010b = 11010011b
-01000011b | 11010011b = 11010011b
-01000011b | 11010100b = 11010111b
-01000011b | 11010101b = 11010111b
-01000011b | 11010110b = 11010111b
-01000011b | 11010111b = 11010111b
-01000011b | 11011000b = 11011011b
-01000011b | 11011001b = 11011011b
-01000011b | 11011010b = 11011011b
-01000011b | 11011011b = 11011011b
-01000011b | 11011100b = 11011111b
-01000011b | 11011101b = 11011111b
-01000011b | 11011110b = 11011111b
-01000011b | 11011111b = 11011111b
-01000011b | 11100000b = 11100011b
-01000011b | 11100001b = 11100011b
-01000011b | 11100010b = 11100011b
-01000011b | 11100011b = 11100011b
-01000011b | 11100100b = 11100111b
-01000011b | 11100101b = 11100111b
-01000011b | 11100110b = 11100111b
-01000011b | 11100111b = 11100111b
-01000011b | 11101000b = 11101011b
-01000011b | 11101001b = 11101011b
-01000011b | 11101010b = 11101011b
-01000011b | 11101011b = 11101011b
-01000011b | 11101100b = 11101111b
-01000011b | 11101101b = 11101111b
-01000011b | 11101110b = 11101111b
-01000011b | 11101111b = 11101111b
-01000011b | 11110000b = 11110011b
-01000011b | 11110001b = 11110011b
-01000011b | 11110010b = 11110011b
-01000011b | 11110011b = 11110011b
-01000011b | 11110100b = 11110111b
-01000011b | 11110101b = 11110111b
-01000011b | 11110110b = 11110111b
-01000011b | 11110111b = 11110111b
-01000011b | 11111000b = 11111011b
-01000011b | 11111001b = 11111011b
-01000011b | 11111010b = 11111011b
-01000011b | 11111011b = 11111011b
-01000011b | 11111100b = 11111111b
-01000011b | 11111101b = 11111111b
-01000011b | 11111110b = 11111111b
-01000011b | 11111111b = 11111111b
-01000011b | 00000000b = 01000011b
-01000011b | 00000001b = 01000011b
-01000011b | 00000010b = 01000011b
-01000011b | 00000011b = 01000011b
-01000011b | 00000100b = 01000111b
-01000011b | 00000101b = 01000111b
-01000011b | 00000110b = 01000111b
-01000011b | 00000111b = 01000111b
-01000011b | 00001000b = 01001011b
-01000011b | 00001001b = 01001011b
-01000011b | 00001010b = 01001011b
-01000011b | 00001011b = 01001011b
-01000011b | 00001100b = 01001111b
-01000011b | 00001101b = 01001111b
-01000011b | 00001110b = 01001111b
-01000011b | 00001111b = 01001111b
-01000011b | 00010000b = 01010011b
-01000011b | 00010001b = 01010011b
-01000011b | 00010010b = 01010011b
-01000011b | 00010011b = 01010011b
-01000011b | 00010100b = 01010111b
-01000011b | 00010101b = 01010111b
-01000011b | 00010110b = 01010111b
-01000011b | 00010111b = 01010111b
-01000011b | 00011000b = 01011011b
-01000011b | 00011001b = 01011011b
-01000011b | 00011010b = 01011011b
-01000011b | 00011011b = 01011011b
-01000011b | 00011100b = 01011111b
-01000011b | 00011101b = 01011111b
-01000011b | 00011110b = 01011111b
-01000011b | 00011111b = 01011111b
-01000011b | 00100000b = 01100011b
-01000011b | 00100001b = 01100011b
-01000011b | 00100010b = 01100011b
-01000011b | 00100011b = 01100011b
-01000011b | 00100100b = 01100111b
-01000011b | 00100101b = 01100111b
-01000011b | 00100110b = 01100111b
-01000011b | 00100111b = 01100111b
-01000011b | 00101000b = 01101011b
-01000011b | 00101001b = 01101011b
-01000011b | 00101010b = 01101011b
-01000011b | 00101011b = 01101011b
-01000011b | 00101100b = 01101111b
-01000011b | 00101101b = 01101111b
-01000011b | 00101110b = 01101111b
-01000011b | 00101111b = 01101111b
-01000011b | 00110000b = 01110011b
-01000011b | 00110001b = 01110011b
-01000011b | 00110010b = 01110011b
-01000011b | 00110011b = 01110011b
-01000011b | 00110100b = 01110111b
-01000011b | 00110101b = 01110111b
-01000011b | 00110110b = 01110111b
-01000011b | 00110111b = 01110111b
-01000011b | 00111000b = 01111011b
-01000011b | 00111001b = 01111011b
-01000011b | 00111010b = 01111011b
-01000011b | 00111011b = 01111011b
-01000011b | 00111100b = 01111111b
-01000011b | 00111101b = 01111111b
-01000011b | 00111110b = 01111111b
-01000011b | 00111111b = 01111111b
-01000011b | 01000000b = 01000011b
-01000011b | 01000001b = 01000011b
-01000011b | 01000010b = 01000011b
-01000011b | 01000011b = 01000011b
-01000011b | 01000100b = 01000111b
-01000011b | 01000101b = 01000111b
-01000011b | 01000110b = 01000111b
-01000011b | 01000111b = 01000111b
-01000011b | 01001000b = 01001011b
-01000011b | 01001001b = 01001011b
-01000011b | 01001010b = 01001011b
-01000011b | 01001011b = 01001011b
-01000011b | 01001100b = 01001111b
-01000011b | 01001101b = 01001111b
-01000011b | 01001110b = 01001111b
-01000011b | 01001111b = 01001111b
-01000011b | 01010000b = 01010011b
-01000011b | 01010001b = 01010011b
-01000011b | 01010010b = 01010011b
-01000011b | 01010011b = 01010011b
-01000011b | 01010100b = 01010111b
-01000011b | 01010101b = 01010111b
-01000011b | 01010110b = 01010111b
-01000011b | 01010111b = 01010111b
-01000011b | 01011000b = 01011011b
-01000011b | 01011001b = 01011011b
-01000011b | 01011010b = 01011011b
-01000011b | 01011011b = 01011011b
-01000011b | 01011100b = 01011111b
-01000011b | 01011101b = 01011111b
-01000011b | 01011110b = 01011111b
-01000011b | 01011111b = 01011111b
-01000011b | 01100000b = 01100011b
-01000011b | 01100001b = 01100011b
-01000011b | 01100010b = 01100011b
-01000011b | 01100011b = 01100011b
-01000011b | 01100100b = 01100111b
-01000011b | 01100101b = 01100111b
-01000011b | 01100110b = 01100111b
-01000011b | 01100111b = 01100111b
-01000011b | 01101000b = 01101011b
-01000011b | 01101001b = 01101011b
-01000011b | 01101010b = 01101011b
-01000011b | 01101011b = 01101011b
-01000011b | 01101100b = 01101111b
-01000011b | 01101101b = 01101111b
-01000011b | 01101110b = 01101111b
-01000011b | 01101111b = 01101111b
-01000011b | 01110000b = 01110011b
-01000011b | 01110001b = 01110011b
-01000011b | 01110010b = 01110011b
-01000011b | 01110011b = 01110011b
-01000011b | 01110100b = 01110111b
-01000011b | 01110101b = 01110111b
-01000011b | 01110110b = 01110111b
-01000011b | 01110111b = 01110111b
-01000011b | 01111000b = 01111011b
-01000011b | 01111001b = 01111011b
-01000011b | 01111010b = 01111011b
-01000011b | 01111011b = 01111011b
-01000011b | 01111100b = 01111111b
-01000011b | 01111101b = 01111111b
-01000011b | 01111110b = 01111111b
-01000100b | 10000000b = 11000100b
-01000100b | 10000001b = 11000101b
-01000100b | 10000010b = 11000110b
-01000100b | 10000011b = 11000111b
-01000100b | 10000100b = 11000100b
-01000100b | 10000101b = 11000101b
-01000100b | 10000110b = 11000110b
-01000100b | 10000111b = 11000111b
-01000100b | 10001000b = 11001100b
-01000100b | 10001001b = 11001101b
-01000100b | 10001010b = 11001110b
-01000100b | 10001011b = 11001111b
-01000100b | 10001100b = 11001100b
-01000100b | 10001101b = 11001101b
-01000100b | 10001110b = 11001110b
-01000100b | 10001111b = 11001111b
-01000100b | 10010000b = 11010100b
-01000100b | 10010001b = 11010101b
-01000100b | 10010010b = 11010110b
-01000100b | 10010011b = 11010111b
-01000100b | 10010100b = 11010100b
-01000100b | 10010101b = 11010101b
-01000100b | 10010110b = 11010110b
-01000100b | 10010111b = 11010111b
-01000100b | 10011000b = 11011100b
-01000100b | 10011001b = 11011101b
-01000100b | 10011010b = 11011110b
-01000100b | 10011011b = 11011111b
-01000100b | 10011100b = 11011100b
-01000100b | 10011101b = 11011101b
-01000100b | 10011110b = 11011110b
-01000100b | 10011111b = 11011111b
-01000100b | 10100000b = 11100100b
-01000100b | 10100001b = 11100101b
-01000100b | 10100010b = 11100110b
-01000100b | 10100011b = 11100111b
-01000100b | 10100100b = 11100100b
-01000100b | 10100101b = 11100101b
-01000100b | 10100110b = 11100110b
-01000100b | 10100111b = 11100111b
-01000100b | 10101000b = 11101100b
-01000100b | 10101001b = 11101101b
-01000100b | 10101010b = 11101110b
-01000100b | 10101011b = 11101111b
-01000100b | 10101100b = 11101100b
-01000100b | 10101101b = 11101101b
-01000100b | 10101110b = 11101110b
-01000100b | 10101111b = 11101111b
-01000100b | 10110000b = 11110100b
-01000100b | 10110001b = 11110101b
-01000100b | 10110010b = 11110110b
-01000100b | 10110011b = 11110111b
-01000100b | 10110100b = 11110100b
-01000100b | 10110101b = 11110101b
-01000100b | 10110110b = 11110110b
-01000100b | 10110111b = 11110111b
-01000100b | 10111000b = 11111100b
-01000100b | 10111001b = 11111101b
-01000100b | 10111010b = 11111110b
-01000100b | 10111011b = 11111111b
-01000100b | 10111100b = 11111100b
-01000100b | 10111101b = 11111101b
-01000100b | 10111110b = 11111110b
-01000100b | 10111111b = 11111111b
-01000100b | 11000000b = 11000100b
-01000100b | 11000001b = 11000101b
-01000100b | 11000010b = 11000110b
-01000100b | 11000011b = 11000111b
-01000100b | 11000100b = 11000100b
-01000100b | 11000101b = 11000101b
-01000100b | 11000110b = 11000110b
-01000100b | 11000111b = 11000111b
-01000100b | 11001000b = 11001100b
-01000100b | 11001001b = 11001101b
-01000100b | 11001010b = 11001110b
-01000100b | 11001011b = 11001111b
-01000100b | 11001100b = 11001100b
-01000100b | 11001101b = 11001101b
-01000100b | 11001110b = 11001110b
-01000100b | 11001111b = 11001111b
-01000100b | 11010000b = 11010100b
-01000100b | 11010001b = 11010101b
-01000100b | 11010010b = 11010110b
-01000100b | 11010011b = 11010111b
-01000100b | 11010100b = 11010100b
-01000100b | 11010101b = 11010101b
-01000100b | 11010110b = 11010110b
-01000100b | 11010111b = 11010111b
-01000100b | 11011000b = 11011100b
-01000100b | 11011001b = 11011101b
-01000100b | 11011010b = 11011110b
-01000100b | 11011011b = 11011111b
-01000100b | 11011100b = 11011100b
-01000100b | 11011101b = 11011101b
-01000100b | 11011110b = 11011110b
-01000100b | 11011111b = 11011111b
-01000100b | 11100000b = 11100100b
-01000100b | 11100001b = 11100101b
-01000100b | 11100010b = 11100110b
-01000100b | 11100011b = 11100111b
-01000100b | 11100100b = 11100100b
-01000100b | 11100101b = 11100101b
-01000100b | 11100110b = 11100110b
-01000100b | 11100111b = 11100111b
-01000100b | 11101000b = 11101100b
-01000100b | 11101001b = 11101101b
-01000100b | 11101010b = 11101110b
-01000100b | 11101011b = 11101111b
-01000100b | 11101100b = 11101100b
-01000100b | 11101101b = 11101101b
-01000100b | 11101110b = 11101110b
-01000100b | 11101111b = 11101111b
-01000100b | 11110000b = 11110100b
-01000100b | 11110001b = 11110101b
-01000100b | 11110010b = 11110110b
-01000100b | 11110011b = 11110111b
-01000100b | 11110100b = 11110100b
-01000100b | 11110101b = 11110101b
-01000100b | 11110110b = 11110110b
-01000100b | 11110111b = 11110111b
-01000100b | 11111000b = 11111100b
-01000100b | 11111001b = 11111101b
-01000100b | 11111010b = 11111110b
-01000100b | 11111011b = 11111111b
-01000100b | 11111100b = 11111100b
-01000100b | 11111101b = 11111101b
-01000100b | 11111110b = 11111110b
-01000100b | 11111111b = 11111111b
-01000100b | 00000000b = 01000100b
-01000100b | 00000001b = 01000101b
-01000100b | 00000010b = 01000110b
-01000100b | 00000011b = 01000111b
-01000100b | 00000100b = 01000100b
-01000100b | 00000101b = 01000101b
-01000100b | 00000110b = 01000110b
-01000100b | 00000111b = 01000111b
-01000100b | 00001000b = 01001100b
-01000100b | 00001001b = 01001101b
-01000100b | 00001010b = 01001110b
-01000100b | 00001011b = 01001111b
-01000100b | 00001100b = 01001100b
-01000100b | 00001101b = 01001101b
-01000100b | 00001110b = 01001110b
-01000100b | 00001111b = 01001111b
-01000100b | 00010000b = 01010100b
-01000100b | 00010001b = 01010101b
-01000100b | 00010010b = 01010110b
-01000100b | 00010011b = 01010111b
-01000100b | 00010100b = 01010100b
-01000100b | 00010101b = 01010101b
-01000100b | 00010110b = 01010110b
-01000100b | 00010111b = 01010111b
-01000100b | 00011000b = 01011100b
-01000100b | 00011001b = 01011101b
-01000100b | 00011010b = 01011110b
-01000100b | 00011011b = 01011111b
-01000100b | 00011100b = 01011100b
-01000100b | 00011101b = 01011101b
-01000100b | 00011110b = 01011110b
-01000100b | 00011111b = 01011111b
-01000100b | 00100000b = 01100100b
-01000100b | 00100001b = 01100101b
-01000100b | 00100010b = 01100110b
-01000100b | 00100011b = 01100111b
-01000100b | 00100100b = 01100100b
-01000100b | 00100101b = 01100101b
-01000100b | 00100110b = 01100110b
-01000100b | 00100111b = 01100111b
-01000100b | 00101000b = 01101100b
-01000100b | 00101001b = 01101101b
-01000100b | 00101010b = 01101110b
-01000100b | 00101011b = 01101111b
-01000100b | 00101100b = 01101100b
-01000100b | 00101101b = 01101101b
-01000100b | 00101110b = 01101110b
-01000100b | 00101111b = 01101111b
-01000100b | 00110000b = 01110100b
-01000100b | 00110001b = 01110101b
-01000100b | 00110010b = 01110110b
-01000100b | 00110011b = 01110111b
-01000100b | 00110100b = 01110100b
-01000100b | 00110101b = 01110101b
-01000100b | 00110110b = 01110110b
-01000100b | 00110111b = 01110111b
-01000100b | 00111000b = 01111100b
-01000100b | 00111001b = 01111101b
-01000100b | 00111010b = 01111110b
-01000100b | 00111011b = 01111111b
-01000100b | 00111100b = 01111100b
-01000100b | 00111101b = 01111101b
-01000100b | 00111110b = 01111110b
-01000100b | 00111111b = 01111111b
-01000100b | 01000000b = 01000100b
-01000100b | 01000001b = 01000101b
-01000100b | 01000010b = 01000110b
-01000100b | 01000011b = 01000111b
-01000100b | 01000100b = 01000100b
-01000100b | 01000101b = 01000101b
-01000100b | 01000110b = 01000110b
-01000100b | 01000111b = 01000111b
-01000100b | 01001000b = 01001100b
-01000100b | 01001001b = 01001101b
-01000100b | 01001010b = 01001110b
-01000100b | 01001011b = 01001111b
-01000100b | 01001100b = 01001100b
-01000100b | 01001101b = 01001101b
-01000100b | 01001110b = 01001110b
-01000100b | 01001111b = 01001111b
-01000100b | 01010000b = 01010100b
-01000100b | 01010001b = 01010101b
-01000100b | 01010010b = 01010110b
-01000100b | 01010011b = 01010111b
-01000100b | 01010100b = 01010100b
-01000100b | 01010101b = 01010101b
-01000100b | 01010110b = 01010110b
-01000100b | 01010111b = 01010111b
-01000100b | 01011000b = 01011100b
-01000100b | 01011001b = 01011101b
-01000100b | 01011010b = 01011110b
-01000100b | 01011011b = 01011111b
-01000100b | 01011100b = 01011100b
-01000100b | 01011101b = 01011101b
-01000100b | 01011110b = 01011110b
-01000100b | 01011111b = 01011111b
-01000100b | 01100000b = 01100100b
-01000100b | 01100001b = 01100101b
-01000100b | 01100010b = 01100110b
-01000100b | 01100011b = 01100111b
-01000100b | 01100100b = 01100100b
-01000100b | 01100101b = 01100101b
-01000100b | 01100110b = 01100110b
-01000100b | 01100111b = 01100111b
-01000100b | 01101000b = 01101100b
-01000100b | 01101001b = 01101101b
-01000100b | 01101010b = 01101110b
-01000100b | 01101011b = 01101111b
-01000100b | 01101100b = 01101100b
-01000100b | 01101101b = 01101101b
-01000100b | 01101110b = 01101110b
-01000100b | 01101111b = 01101111b
-01000100b | 01110000b = 01110100b
-01000100b | 01110001b = 01110101b
-01000100b | 01110010b = 01110110b
-01000100b | 01110011b = 01110111b
-01000100b | 01110100b = 01110100b
-01000100b | 01110101b = 01110101b
-01000100b | 01110110b = 01110110b
-01000100b | 01110111b = 01110111b
-01000100b | 01111000b = 01111100b
-01000100b | 01111001b = 01111101b
-01000100b | 01111010b = 01111110b
-01000100b | 01111011b = 01111111b
-01000100b | 01111100b = 01111100b
-01000100b | 01111101b = 01111101b
-01000100b | 01111110b = 01111110b
-01000101b | 10000000b = 11000101b
-01000101b | 10000001b = 11000101b
-01000101b | 10000010b = 11000111b
-01000101b | 10000011b = 11000111b
-01000101b | 10000100b = 11000101b
-01000101b | 10000101b = 11000101b
-01000101b | 10000110b = 11000111b
-01000101b | 10000111b = 11000111b
-01000101b | 10001000b = 11001101b
-01000101b | 10001001b = 11001101b
-01000101b | 10001010b = 11001111b
-01000101b | 10001011b = 11001111b
-01000101b | 10001100b = 11001101b
-01000101b | 10001101b = 11001101b
-01000101b | 10001110b = 11001111b
-01000101b | 10001111b = 11001111b
-01000101b | 10010000b = 11010101b
-01000101b | 10010001b = 11010101b
-01000101b | 10010010b = 11010111b
-01000101b | 10010011b = 11010111b
-01000101b | 10010100b = 11010101b
-01000101b | 10010101b = 11010101b
-01000101b | 10010110b = 11010111b
-01000101b | 10010111b = 11010111b
-01000101b | 10011000b = 11011101b
-01000101b | 10011001b = 11011101b
-01000101b | 10011010b = 11011111b
-01000101b | 10011011b = 11011111b
-01000101b | 10011100b = 11011101b
-01000101b | 10011101b = 11011101b
-01000101b | 10011110b = 11011111b
-01000101b | 10011111b = 11011111b
-01000101b | 10100000b = 11100101b
-01000101b | 10100001b = 11100101b
-01000101b | 10100010b = 11100111b
-01000101b | 10100011b = 11100111b
-01000101b | 10100100b = 11100101b
-01000101b | 10100101b = 11100101b
-01000101b | 10100110b = 11100111b
-01000101b | 10100111b = 11100111b
-01000101b | 10101000b = 11101101b
-01000101b | 10101001b = 11101101b
-01000101b | 10101010b = 11101111b
-01000101b | 10101011b = 11101111b
-01000101b | 10101100b = 11101101b
-01000101b | 10101101b = 11101101b
-01000101b | 10101110b = 11101111b
-01000101b | 10101111b = 11101111b
-01000101b | 10110000b = 11110101b
-01000101b | 10110001b = 11110101b
-01000101b | 10110010b = 11110111b
-01000101b | 10110011b = 11110111b
-01000101b | 10110100b = 11110101b
-01000101b | 10110101b = 11110101b
-01000101b | 10110110b = 11110111b
-01000101b | 10110111b = 11110111b
-01000101b | 10111000b = 11111101b
-01000101b | 10111001b = 11111101b
-01000101b | 10111010b = 11111111b
-01000101b | 10111011b = 11111111b
-01000101b | 10111100b = 11111101b
-01000101b | 10111101b = 11111101b
-01000101b | 10111110b = 11111111b
-01000101b | 10111111b = 11111111b
-01000101b | 11000000b = 11000101b
-01000101b | 11000001b = 11000101b
-01000101b | 11000010b = 11000111b
-01000101b | 11000011b = 11000111b
-01000101b | 11000100b = 11000101b
-01000101b | 11000101b = 11000101b
-01000101b | 11000110b = 11000111b
-01000101b | 11000111b = 11000111b
-01000101b | 11001000b = 11001101b
-01000101b | 11001001b = 11001101b
-01000101b | 11001010b = 11001111b
-01000101b | 11001011b = 11001111b
-01000101b | 11001100b = 11001101b
-01000101b | 11001101b = 11001101b
-01000101b | 11001110b = 11001111b
-01000101b | 11001111b = 11001111b
-01000101b | 11010000b = 11010101b
-01000101b | 11010001b = 11010101b
-01000101b | 11010010b = 11010111b
-01000101b | 11010011b = 11010111b
-01000101b | 11010100b = 11010101b
-01000101b | 11010101b = 11010101b
-01000101b | 11010110b = 11010111b
-01000101b | 11010111b = 11010111b
-01000101b | 11011000b = 11011101b
-01000101b | 11011001b = 11011101b
-01000101b | 11011010b = 11011111b
-01000101b | 11011011b = 11011111b
-01000101b | 11011100b = 11011101b
-01000101b | 11011101b = 11011101b
-01000101b | 11011110b = 11011111b
-01000101b | 11011111b = 11011111b
-01000101b | 11100000b = 11100101b
-01000101b | 11100001b = 11100101b
-01000101b | 11100010b = 11100111b
-01000101b | 11100011b = 11100111b
-01000101b | 11100100b = 11100101b
-01000101b | 11100101b = 11100101b
-01000101b | 11100110b = 11100111b
-01000101b | 11100111b = 11100111b
-01000101b | 11101000b = 11101101b
-01000101b | 11101001b = 11101101b
-01000101b | 11101010b = 11101111b
-01000101b | 11101011b = 11101111b
-01000101b | 11101100b = 11101101b
-01000101b | 11101101b = 11101101b
-01000101b | 11101110b = 11101111b
-01000101b | 11101111b = 11101111b
-01000101b | 11110000b = 11110101b
-01000101b | 11110001b = 11110101b
-01000101b | 11110010b = 11110111b
-01000101b | 11110011b = 11110111b
-01000101b | 11110100b = 11110101b
-01000101b | 11110101b = 11110101b
-01000101b | 11110110b = 11110111b
-01000101b | 11110111b = 11110111b
-01000101b | 11111000b = 11111101b
-01000101b | 11111001b = 11111101b
-01000101b | 11111010b = 11111111b
-01000101b | 11111011b = 11111111b
-01000101b | 11111100b = 11111101b
-01000101b | 11111101b = 11111101b
-01000101b | 11111110b = 11111111b
-01000101b | 11111111b = 11111111b
-01000101b | 00000000b = 01000101b
-01000101b | 00000001b = 01000101b
-01000101b | 00000010b = 01000111b
-01000101b | 00000011b = 01000111b
-01000101b | 00000100b = 01000101b
-01000101b | 00000101b = 01000101b
-01000101b | 00000110b = 01000111b
-01000101b | 00000111b = 01000111b
-01000101b | 00001000b = 01001101b
-01000101b | 00001001b = 01001101b
-01000101b | 00001010b = 01001111b
-01000101b | 00001011b = 01001111b
-01000101b | 00001100b = 01001101b
-01000101b | 00001101b = 01001101b
-01000101b | 00001110b = 01001111b
-01000101b | 00001111b = 01001111b
-01000101b | 00010000b = 01010101b
-01000101b | 00010001b = 01010101b
-01000101b | 00010010b = 01010111b
-01000101b | 00010011b = 01010111b
-01000101b | 00010100b = 01010101b
-01000101b | 00010101b = 01010101b
-01000101b | 00010110b = 01010111b
-01000101b | 00010111b = 01010111b
-01000101b | 00011000b = 01011101b
-01000101b | 00011001b = 01011101b
-01000101b | 00011010b = 01011111b
-01000101b | 00011011b = 01011111b
-01000101b | 00011100b = 01011101b
-01000101b | 00011101b = 01011101b
-01000101b | 00011110b = 01011111b
-01000101b | 00011111b = 01011111b
-01000101b | 00100000b = 01100101b
-01000101b | 00100001b = 01100101b
-01000101b | 00100010b = 01100111b
-01000101b | 00100011b = 01100111b
-01000101b | 00100100b = 01100101b
-01000101b | 00100101b = 01100101b
-01000101b | 00100110b = 01100111b
-01000101b | 00100111b = 01100111b
-01000101b | 00101000b = 01101101b
-01000101b | 00101001b = 01101101b
-01000101b | 00101010b = 01101111b
-01000101b | 00101011b = 01101111b
-01000101b | 00101100b = 01101101b
-01000101b | 00101101b = 01101101b
-01000101b | 00101110b = 01101111b
-01000101b | 00101111b = 01101111b
-01000101b | 00110000b = 01110101b
-01000101b | 00110001b = 01110101b
-01000101b | 00110010b = 01110111b
-01000101b | 00110011b = 01110111b
-01000101b | 00110100b = 01110101b
-01000101b | 00110101b = 01110101b
-01000101b | 00110110b = 01110111b
-01000101b | 00110111b = 01110111b
-01000101b | 00111000b = 01111101b
-01000101b | 00111001b = 01111101b
-01000101b | 00111010b = 01111111b
-01000101b | 00111011b = 01111111b
-01000101b | 00111100b = 01111101b
-01000101b | 00111101b = 01111101b
-01000101b | 00111110b = 01111111b
-01000101b | 00111111b = 01111111b
-01000101b | 01000000b = 01000101b
-01000101b | 01000001b = 01000101b
-01000101b | 01000010b = 01000111b
-01000101b | 01000011b = 01000111b
-01000101b | 01000100b = 01000101b
-01000101b | 01000101b = 01000101b
-01000101b | 01000110b = 01000111b
-01000101b | 01000111b = 01000111b
-01000101b | 01001000b = 01001101b
-01000101b | 01001001b = 01001101b
-01000101b | 01001010b = 01001111b
-01000101b | 01001011b = 01001111b
-01000101b | 01001100b = 01001101b
-01000101b | 01001101b = 01001101b
-01000101b | 01001110b = 01001111b
-01000101b | 01001111b = 01001111b
-01000101b | 01010000b = 01010101b
-01000101b | 01010001b = 01010101b
-01000101b | 01010010b = 01010111b
-01000101b | 01010011b = 01010111b
-01000101b | 01010100b = 01010101b
-01000101b | 01010101b = 01010101b
-01000101b | 01010110b = 01010111b
-01000101b | 01010111b = 01010111b
-01000101b | 01011000b = 01011101b
-01000101b | 01011001b = 01011101b
-01000101b | 01011010b = 01011111b
-01000101b | 01011011b = 01011111b
-01000101b | 01011100b = 01011101b
-01000101b | 01011101b = 01011101b
-01000101b | 01011110b = 01011111b
-01000101b | 01011111b = 01011111b
-01000101b | 01100000b = 01100101b
-01000101b | 01100001b = 01100101b
-01000101b | 01100010b = 01100111b
-01000101b | 01100011b = 01100111b
-01000101b | 01100100b = 01100101b
-01000101b | 01100101b = 01100101b
-01000101b | 01100110b = 01100111b
-01000101b | 01100111b = 01100111b
-01000101b | 01101000b = 01101101b
-01000101b | 01101001b = 01101101b
-01000101b | 01101010b = 01101111b
-01000101b | 01101011b = 01101111b
-01000101b | 01101100b = 01101101b
-01000101b | 01101101b = 01101101b
-01000101b | 01101110b = 01101111b
-01000101b | 01101111b = 01101111b
-01000101b | 01110000b = 01110101b
-01000101b | 01110001b = 01110101b
-01000101b | 01110010b = 01110111b
-01000101b | 01110011b = 01110111b
-01000101b | 01110100b = 01110101b
-01000101b | 01110101b = 01110101b
-01000101b | 01110110b = 01110111b
-01000101b | 01110111b = 01110111b
-01000101b | 01111000b = 01111101b
-01000101b | 01111001b = 01111101b
-01000101b | 01111010b = 01111111b
-01000101b | 01111011b = 01111111b
-01000101b | 01111100b = 01111101b
-01000101b | 01111101b = 01111101b
-01000101b | 01111110b = 01111111b
-01000110b | 10000000b = 11000110b
-01000110b | 10000001b = 11000111b
-01000110b | 10000010b = 11000110b
-01000110b | 10000011b = 11000111b
-01000110b | 10000100b = 11000110b
-01000110b | 10000101b = 11000111b
-01000110b | 10000110b = 11000110b
-01000110b | 10000111b = 11000111b
-01000110b | 10001000b = 11001110b
-01000110b | 10001001b = 11001111b
-01000110b | 10001010b = 11001110b
-01000110b | 10001011b = 11001111b
-01000110b | 10001100b = 11001110b
-01000110b | 10001101b = 11001111b
-01000110b | 10001110b = 11001110b
-01000110b | 10001111b = 11001111b
-01000110b | 10010000b = 11010110b
-01000110b | 10010001b = 11010111b
-01000110b | 10010010b = 11010110b
-01000110b | 10010011b = 11010111b
-01000110b | 10010100b = 11010110b
-01000110b | 10010101b = 11010111b
-01000110b | 10010110b = 11010110b
-01000110b | 10010111b = 11010111b
-01000110b | 10011000b = 11011110b
-01000110b | 10011001b = 11011111b
-01000110b | 10011010b = 11011110b
-01000110b | 10011011b = 11011111b
-01000110b | 10011100b = 11011110b
-01000110b | 10011101b = 11011111b
-01000110b | 10011110b = 11011110b
-01000110b | 10011111b = 11011111b
-01000110b | 10100000b = 11100110b
-01000110b | 10100001b = 11100111b
-01000110b | 10100010b = 11100110b
-01000110b | 10100011b = 11100111b
-01000110b | 10100100b = 11100110b
-01000110b | 10100101b = 11100111b
-01000110b | 10100110b = 11100110b
-01000110b | 10100111b = 11100111b
-01000110b | 10101000b = 11101110b
-01000110b | 10101001b = 11101111b
-01000110b | 10101010b = 11101110b
-01000110b | 10101011b = 11101111b
-01000110b | 10101100b = 11101110b
-01000110b | 10101101b = 11101111b
-01000110b | 10101110b = 11101110b
-01000110b | 10101111b = 11101111b
-01000110b | 10110000b = 11110110b
-01000110b | 10110001b = 11110111b
-01000110b | 10110010b = 11110110b
-01000110b | 10110011b = 11110111b
-01000110b | 10110100b = 11110110b
-01000110b | 10110101b = 11110111b
-01000110b | 10110110b = 11110110b
-01000110b | 10110111b = 11110111b
-01000110b | 10111000b = 11111110b
-01000110b | 10111001b = 11111111b
-01000110b | 10111010b = 11111110b
-01000110b | 10111011b = 11111111b
-01000110b | 10111100b = 11111110b
-01000110b | 10111101b = 11111111b
-01000110b | 10111110b = 11111110b
-01000110b | 10111111b = 11111111b
-01000110b | 11000000b = 11000110b
-01000110b | 11000001b = 11000111b
-01000110b | 11000010b = 11000110b
-01000110b | 11000011b = 11000111b
-01000110b | 11000100b = 11000110b
-01000110b | 11000101b = 11000111b
-01000110b | 11000110b = 11000110b
-01000110b | 11000111b = 11000111b
-01000110b | 11001000b = 11001110b
-01000110b | 11001001b = 11001111b
-01000110b | 11001010b = 11001110b
-01000110b | 11001011b = 11001111b
-01000110b | 11001100b = 11001110b
-01000110b | 11001101b = 11001111b
-01000110b | 11001110b = 11001110b
-01000110b | 11001111b = 11001111b
-01000110b | 11010000b = 11010110b
-01000110b | 11010001b = 11010111b
-01000110b | 11010010b = 11010110b
-01000110b | 11010011b = 11010111b
-01000110b | 11010100b = 11010110b
-01000110b | 11010101b = 11010111b
-01000110b | 11010110b = 11010110b
-01000110b | 11010111b = 11010111b
-01000110b | 11011000b = 11011110b
-01000110b | 11011001b = 11011111b
-01000110b | 11011010b = 11011110b
-01000110b | 11011011b = 11011111b
-01000110b | 11011100b = 11011110b
-01000110b | 11011101b = 11011111b
-01000110b | 11011110b = 11011110b
-01000110b | 11011111b = 11011111b
-01000110b | 11100000b = 11100110b
-01000110b | 11100001b = 11100111b
-01000110b | 11100010b = 11100110b
-01000110b | 11100011b = 11100111b
-01000110b | 11100100b = 11100110b
-01000110b | 11100101b = 11100111b
-01000110b | 11100110b = 11100110b
-01000110b | 11100111b = 11100111b
-01000110b | 11101000b = 11101110b
-01000110b | 11101001b = 11101111b
-01000110b | 11101010b = 11101110b
-01000110b | 11101011b = 11101111b
-01000110b | 11101100b = 11101110b
-01000110b | 11101101b = 11101111b
-01000110b | 11101110b = 11101110b
-01000110b | 11101111b = 11101111b
-01000110b | 11110000b = 11110110b
-01000110b | 11110001b = 11110111b
-01000110b | 11110010b = 11110110b
-01000110b | 11110011b = 11110111b
-01000110b | 11110100b = 11110110b
-01000110b | 11110101b = 11110111b
-01000110b | 11110110b = 11110110b
-01000110b | 11110111b = 11110111b
-01000110b | 11111000b = 11111110b
-01000110b | 11111001b = 11111111b
-01000110b | 11111010b = 11111110b
-01000110b | 11111011b = 11111111b
-01000110b | 11111100b = 11111110b
-01000110b | 11111101b = 11111111b
-01000110b | 11111110b = 11111110b
-01000110b | 11111111b = 11111111b
-01000110b | 00000000b = 01000110b
-01000110b | 00000001b = 01000111b
-01000110b | 00000010b = 01000110b
-01000110b | 00000011b = 01000111b
-01000110b | 00000100b = 01000110b
-01000110b | 00000101b = 01000111b
-01000110b | 00000110b = 01000110b
-01000110b | 00000111b = 01000111b
-01000110b | 00001000b = 01001110b
-01000110b | 00001001b = 01001111b
-01000110b | 00001010b = 01001110b
-01000110b | 00001011b = 01001111b
-01000110b | 00001100b = 01001110b
-01000110b | 00001101b = 01001111b
-01000110b | 00001110b = 01001110b
-01000110b | 00001111b = 01001111b
-01000110b | 00010000b = 01010110b
-01000110b | 00010001b = 01010111b
-01000110b | 00010010b = 01010110b
-01000110b | 00010011b = 01010111b
-01000110b | 00010100b = 01010110b
-01000110b | 00010101b = 01010111b
-01000110b | 00010110b = 01010110b
-01000110b | 00010111b = 01010111b
-01000110b | 00011000b = 01011110b
-01000110b | 00011001b = 01011111b
-01000110b | 00011010b = 01011110b
-01000110b | 00011011b = 01011111b
-01000110b | 00011100b = 01011110b
-01000110b | 00011101b = 01011111b
-01000110b | 00011110b = 01011110b
-01000110b | 00011111b = 01011111b
-01000110b | 00100000b = 01100110b
-01000110b | 00100001b = 01100111b
-01000110b | 00100010b = 01100110b
-01000110b | 00100011b = 01100111b
-01000110b | 00100100b = 01100110b
-01000110b | 00100101b = 01100111b
-01000110b | 00100110b = 01100110b
-01000110b | 00100111b = 01100111b
-01000110b | 00101000b = 01101110b
-01000110b | 00101001b = 01101111b
-01000110b | 00101010b = 01101110b
-01000110b | 00101011b = 01101111b
-01000110b | 00101100b = 01101110b
-01000110b | 00101101b = 01101111b
-01000110b | 00101110b = 01101110b
-01000110b | 00101111b = 01101111b
-01000110b | 00110000b = 01110110b
-01000110b | 00110001b = 01110111b
-01000110b | 00110010b = 01110110b
-01000110b | 00110011b = 01110111b
-01000110b | 00110100b = 01110110b
-01000110b | 00110101b = 01110111b
-01000110b | 00110110b = 01110110b
-01000110b | 00110111b = 01110111b
-01000110b | 00111000b = 01111110b
-01000110b | 00111001b = 01111111b
-01000110b | 00111010b = 01111110b
-01000110b | 00111011b = 01111111b
-01000110b | 00111100b = 01111110b
-01000110b | 00111101b = 01111111b
-01000110b | 00111110b = 01111110b
-01000110b | 00111111b = 01111111b
-01000110b | 01000000b = 01000110b
-01000110b | 01000001b = 01000111b
-01000110b | 01000010b = 01000110b
-01000110b | 01000011b = 01000111b
-01000110b | 01000100b = 01000110b
-01000110b | 01000101b = 01000111b
-01000110b | 01000110b = 01000110b
-01000110b | 01000111b = 01000111b
-01000110b | 01001000b = 01001110b
-01000110b | 01001001b = 01001111b
-01000110b | 01001010b = 01001110b
-01000110b | 01001011b = 01001111b
-01000110b | 01001100b = 01001110b
-01000110b | 01001101b = 01001111b
-01000110b | 01001110b = 01001110b
-01000110b | 01001111b = 01001111b
-01000110b | 01010000b = 01010110b
-01000110b | 01010001b = 01010111b
-01000110b | 01010010b = 01010110b
-01000110b | 01010011b = 01010111b
-01000110b | 01010100b = 01010110b
-01000110b | 01010101b = 01010111b
-01000110b | 01010110b = 01010110b
-01000110b | 01010111b = 01010111b
-01000110b | 01011000b = 01011110b
-01000110b | 01011001b = 01011111b
-01000110b | 01011010b = 01011110b
-01000110b | 01011011b = 01011111b
-01000110b | 01011100b = 01011110b
-01000110b | 01011101b = 01011111b
-01000110b | 01011110b = 01011110b
-01000110b | 01011111b = 01011111b
-01000110b | 01100000b = 01100110b
-01000110b | 01100001b = 01100111b
-01000110b | 01100010b = 01100110b
-01000110b | 01100011b = 01100111b
-01000110b | 01100100b = 01100110b
-01000110b | 01100101b = 01100111b
-01000110b | 01100110b = 01100110b
-01000110b | 01100111b = 01100111b
-01000110b | 01101000b = 01101110b
-01000110b | 01101001b = 01101111b
-01000110b | 01101010b = 01101110b
-01000110b | 01101011b = 01101111b
-01000110b | 01101100b = 01101110b
-01000110b | 01101101b = 01101111b
-01000110b | 01101110b = 01101110b
-01000110b | 01101111b = 01101111b
-01000110b | 01110000b = 01110110b
-01000110b | 01110001b = 01110111b
-01000110b | 01110010b = 01110110b
-01000110b | 01110011b = 01110111b
-01000110b | 01110100b = 01110110b
-01000110b | 01110101b = 01110111b
-01000110b | 01110110b = 01110110b
-01000110b | 01110111b = 01110111b
-01000110b | 01111000b = 01111110b
-01000110b | 01111001b = 01111111b
-01000110b | 01111010b = 01111110b
-01000110b | 01111011b = 01111111b
-01000110b | 01111100b = 01111110b
-01000110b | 01111101b = 01111111b
-01000110b | 01111110b = 01111110b
-01000111b | 10000000b = 11000111b
-01000111b | 10000001b = 11000111b
-01000111b | 10000010b = 11000111b
-01000111b | 10000011b = 11000111b
-01000111b | 10000100b = 11000111b
-01000111b | 10000101b = 11000111b
-01000111b | 10000110b = 11000111b
-01000111b | 10000111b = 11000111b
-01000111b | 10001000b = 11001111b
-01000111b | 10001001b = 11001111b
-01000111b | 10001010b = 11001111b
-01000111b | 10001011b = 11001111b
-01000111b | 10001100b = 11001111b
-01000111b | 10001101b = 11001111b
-01000111b | 10001110b = 11001111b
-01000111b | 10001111b = 11001111b
-01000111b | 10010000b = 11010111b
-01000111b | 10010001b = 11010111b
-01000111b | 10010010b = 11010111b
-01000111b | 10010011b = 11010111b
-01000111b | 10010100b = 11010111b
-01000111b | 10010101b = 11010111b
-01000111b | 10010110b = 11010111b
-01000111b | 10010111b = 11010111b
-01000111b | 10011000b = 11011111b
-01000111b | 10011001b = 11011111b
-01000111b | 10011010b = 11011111b
-01000111b | 10011011b = 11011111b
-01000111b | 10011100b = 11011111b
-01000111b | 10011101b = 11011111b
-01000111b | 10011110b = 11011111b
-01000111b | 10011111b = 11011111b
-01000111b | 10100000b = 11100111b
-01000111b | 10100001b = 11100111b
-01000111b | 10100010b = 11100111b
-01000111b | 10100011b = 11100111b
-01000111b | 10100100b = 11100111b
-01000111b | 10100101b = 11100111b
-01000111b | 10100110b = 11100111b
-01000111b | 10100111b = 11100111b
-01000111b | 10101000b = 11101111b
-01000111b | 10101001b = 11101111b
-01000111b | 10101010b = 11101111b
-01000111b | 10101011b = 11101111b
-01000111b | 10101100b = 11101111b
-01000111b | 10101101b = 11101111b
-01000111b | 10101110b = 11101111b
-01000111b | 10101111b = 11101111b
-01000111b | 10110000b = 11110111b
-01000111b | 10110001b = 11110111b
-01000111b | 10110010b = 11110111b
-01000111b | 10110011b = 11110111b
-01000111b | 10110100b = 11110111b
-01000111b | 10110101b = 11110111b
-01000111b | 10110110b = 11110111b
-01000111b | 10110111b = 11110111b
-01000111b | 10111000b = 11111111b
-01000111b | 10111001b = 11111111b
-01000111b | 10111010b = 11111111b
-01000111b | 10111011b = 11111111b
-01000111b | 10111100b = 11111111b
-01000111b | 10111101b = 11111111b
-01000111b | 10111110b = 11111111b
-01000111b | 10111111b = 11111111b
-01000111b | 11000000b = 11000111b
-01000111b | 11000001b = 11000111b
-01000111b | 11000010b = 11000111b
-01000111b | 11000011b = 11000111b
-01000111b | 11000100b = 11000111b
-01000111b | 11000101b = 11000111b
-01000111b | 11000110b = 11000111b
-01000111b | 11000111b = 11000111b
-01000111b | 11001000b = 11001111b
-01000111b | 11001001b = 11001111b
-01000111b | 11001010b = 11001111b
-01000111b | 11001011b = 11001111b
-01000111b | 11001100b = 11001111b
-01000111b | 11001101b = 11001111b
-01000111b | 11001110b = 11001111b
-01000111b | 11001111b = 11001111b
-01000111b | 11010000b = 11010111b
-01000111b | 11010001b = 11010111b
-01000111b | 11010010b = 11010111b
-01000111b | 11010011b = 11010111b
-01000111b | 11010100b = 11010111b
-01000111b | 11010101b = 11010111b
-01000111b | 11010110b = 11010111b
-01000111b | 11010111b = 11010111b
-01000111b | 11011000b = 11011111b
-01000111b | 11011001b = 11011111b
-01000111b | 11011010b = 11011111b
-01000111b | 11011011b = 11011111b
-01000111b | 11011100b = 11011111b
-01000111b | 11011101b = 11011111b
-01000111b | 11011110b = 11011111b
-01000111b | 11011111b = 11011111b
-01000111b | 11100000b = 11100111b
-01000111b | 11100001b = 11100111b
-01000111b | 11100010b = 11100111b
-01000111b | 11100011b = 11100111b
-01000111b | 11100100b = 11100111b
-01000111b | 11100101b = 11100111b
-01000111b | 11100110b = 11100111b
-01000111b | 11100111b = 11100111b
-01000111b | 11101000b = 11101111b
-01000111b | 11101001b = 11101111b
-01000111b | 11101010b = 11101111b
-01000111b | 11101011b = 11101111b
-01000111b | 11101100b = 11101111b
-01000111b | 11101101b = 11101111b
-01000111b | 11101110b = 11101111b
-01000111b | 11101111b = 11101111b
-01000111b | 11110000b = 11110111b
-01000111b | 11110001b = 11110111b
-01000111b | 11110010b = 11110111b
-01000111b | 11110011b = 11110111b
-01000111b | 11110100b = 11110111b
-01000111b | 11110101b = 11110111b
-01000111b | 11110110b = 11110111b
-01000111b | 11110111b = 11110111b
-01000111b | 11111000b = 11111111b
-01000111b | 11111001b = 11111111b
-01000111b | 11111010b = 11111111b
-01000111b | 11111011b = 11111111b
-01000111b | 11111100b = 11111111b
-01000111b | 11111101b = 11111111b
-01000111b | 11111110b = 11111111b
-01000111b | 11111111b = 11111111b
-01000111b | 00000000b = 01000111b
-01000111b | 00000001b = 01000111b
-01000111b | 00000010b = 01000111b
-01000111b | 00000011b = 01000111b
-01000111b | 00000100b = 01000111b
-01000111b | 00000101b = 01000111b
-01000111b | 00000110b = 01000111b
-01000111b | 00000111b = 01000111b
-01000111b | 00001000b = 01001111b
-01000111b | 00001001b = 01001111b
-01000111b | 00001010b = 01001111b
-01000111b | 00001011b = 01001111b
-01000111b | 00001100b = 01001111b
-01000111b | 00001101b = 01001111b
-01000111b | 00001110b = 01001111b
-01000111b | 00001111b = 01001111b
-01000111b | 00010000b = 01010111b
-01000111b | 00010001b = 01010111b
-01000111b | 00010010b = 01010111b
-01000111b | 00010011b = 01010111b
-01000111b | 00010100b = 01010111b
-01000111b | 00010101b = 01010111b
-01000111b | 00010110b = 01010111b
-01000111b | 00010111b = 01010111b
-01000111b | 00011000b = 01011111b
-01000111b | 00011001b = 01011111b
-01000111b | 00011010b = 01011111b
-01000111b | 00011011b = 01011111b
-01000111b | 00011100b = 01011111b
-01000111b | 00011101b = 01011111b
-01000111b | 00011110b = 01011111b
-01000111b | 00011111b = 01011111b
-01000111b | 00100000b = 01100111b
-01000111b | 00100001b = 01100111b
-01000111b | 00100010b = 01100111b
-01000111b | 00100011b = 01100111b
-01000111b | 00100100b = 01100111b
-01000111b | 00100101b = 01100111b
-01000111b | 00100110b = 01100111b
-01000111b | 00100111b = 01100111b
-01000111b | 00101000b = 01101111b
-01000111b | 00101001b = 01101111b
-01000111b | 00101010b = 01101111b
-01000111b | 00101011b = 01101111b
-01000111b | 00101100b = 01101111b
-01000111b | 00101101b = 01101111b
-01000111b | 00101110b = 01101111b
-01000111b | 00101111b = 01101111b
-01000111b | 00110000b = 01110111b
-01000111b | 00110001b = 01110111b
-01000111b | 00110010b = 01110111b
-01000111b | 00110011b = 01110111b
-01000111b | 00110100b = 01110111b
-01000111b | 00110101b = 01110111b
-01000111b | 00110110b = 01110111b
-01000111b | 00110111b = 01110111b
-01000111b | 00111000b = 01111111b
-01000111b | 00111001b = 01111111b
-01000111b | 00111010b = 01111111b
-01000111b | 00111011b = 01111111b
-01000111b | 00111100b = 01111111b
-01000111b | 00111101b = 01111111b
-01000111b | 00111110b = 01111111b
-01000111b | 00111111b = 01111111b
-01000111b | 01000000b = 01000111b
-01000111b | 01000001b = 01000111b
-01000111b | 01000010b = 01000111b
-01000111b | 01000011b = 01000111b
-01000111b | 01000100b = 01000111b
-01000111b | 01000101b = 01000111b
-01000111b | 01000110b = 01000111b
-01000111b | 01000111b = 01000111b
-01000111b | 01001000b = 01001111b
-01000111b | 01001001b = 01001111b
-01000111b | 01001010b = 01001111b
-01000111b | 01001011b = 01001111b
-01000111b | 01001100b = 01001111b
-01000111b | 01001101b = 01001111b
-01000111b | 01001110b = 01001111b
-01000111b | 01001111b = 01001111b
-01000111b | 01010000b = 01010111b
-01000111b | 01010001b = 01010111b
-01000111b | 01010010b = 01010111b
-01000111b | 01010011b = 01010111b
-01000111b | 01010100b = 01010111b
-01000111b | 01010101b = 01010111b
-01000111b | 01010110b = 01010111b
-01000111b | 01010111b = 01010111b
-01000111b | 01011000b = 01011111b
-01000111b | 01011001b = 01011111b
-01000111b | 01011010b = 01011111b
-01000111b | 01011011b = 01011111b
-01000111b | 01011100b = 01011111b
-01000111b | 01011101b = 01011111b
-01000111b | 01011110b = 01011111b
-01000111b | 01011111b = 01011111b
-01000111b | 01100000b = 01100111b
-01000111b | 01100001b = 01100111b
-01000111b | 01100010b = 01100111b
-01000111b | 01100011b = 01100111b
-01000111b | 01100100b = 01100111b
-01000111b | 01100101b = 01100111b
-01000111b | 01100110b = 01100111b
-01000111b | 01100111b = 01100111b
-01000111b | 01101000b = 01101111b
-01000111b | 01101001b = 01101111b
-01000111b | 01101010b = 01101111b
-01000111b | 01101011b = 01101111b
-01000111b | 01101100b = 01101111b
-01000111b | 01101101b = 01101111b
-01000111b | 01101110b = 01101111b
-01000111b | 01101111b = 01101111b
-01000111b | 01110000b = 01110111b
-01000111b | 01110001b = 01110111b
-01000111b | 01110010b = 01110111b
-01000111b | 01110011b = 01110111b
-01000111b | 01110100b = 01110111b
-01000111b | 01110101b = 01110111b
-01000111b | 01110110b = 01110111b
-01000111b | 01110111b = 01110111b
-01000111b | 01111000b = 01111111b
-01000111b | 01111001b = 01111111b
-01000111b | 01111010b = 01111111b
-01000111b | 01111011b = 01111111b
-01000111b | 01111100b = 01111111b
-01000111b | 01111101b = 01111111b
-01000111b | 01111110b = 01111111b
-01001000b | 10000000b = 11001000b
-01001000b | 10000001b = 11001001b
-01001000b | 10000010b = 11001010b
-01001000b | 10000011b = 11001011b
-01001000b | 10000100b = 11001100b
-01001000b | 10000101b = 11001101b
-01001000b | 10000110b = 11001110b
-01001000b | 10000111b = 11001111b
-01001000b | 10001000b = 11001000b
-01001000b | 10001001b = 11001001b
-01001000b | 10001010b = 11001010b
-01001000b | 10001011b = 11001011b
-01001000b | 10001100b = 11001100b
-01001000b | 10001101b = 11001101b
-01001000b | 10001110b = 11001110b
-01001000b | 10001111b = 11001111b
-01001000b | 10010000b = 11011000b
-01001000b | 10010001b = 11011001b
-01001000b | 10010010b = 11011010b
-01001000b | 10010011b = 11011011b
-01001000b | 10010100b = 11011100b
-01001000b | 10010101b = 11011101b
-01001000b | 10010110b = 11011110b
-01001000b | 10010111b = 11011111b
-01001000b | 10011000b = 11011000b
-01001000b | 10011001b = 11011001b
-01001000b | 10011010b = 11011010b
-01001000b | 10011011b = 11011011b
-01001000b | 10011100b = 11011100b
-01001000b | 10011101b = 11011101b
-01001000b | 10011110b = 11011110b
-01001000b | 10011111b = 11011111b
-01001000b | 10100000b = 11101000b
-01001000b | 10100001b = 11101001b
-01001000b | 10100010b = 11101010b
-01001000b | 10100011b = 11101011b
-01001000b | 10100100b = 11101100b
-01001000b | 10100101b = 11101101b
-01001000b | 10100110b = 11101110b
-01001000b | 10100111b = 11101111b
-01001000b | 10101000b = 11101000b
-01001000b | 10101001b = 11101001b
-01001000b | 10101010b = 11101010b
-01001000b | 10101011b = 11101011b
-01001000b | 10101100b = 11101100b
-01001000b | 10101101b = 11101101b
-01001000b | 10101110b = 11101110b
-01001000b | 10101111b = 11101111b
-01001000b | 10110000b = 11111000b
-01001000b | 10110001b = 11111001b
-01001000b | 10110010b = 11111010b
-01001000b | 10110011b = 11111011b
-01001000b | 10110100b = 11111100b
-01001000b | 10110101b = 11111101b
-01001000b | 10110110b = 11111110b
-01001000b | 10110111b = 11111111b
-01001000b | 10111000b = 11111000b
-01001000b | 10111001b = 11111001b
-01001000b | 10111010b = 11111010b
-01001000b | 10111011b = 11111011b
-01001000b | 10111100b = 11111100b
-01001000b | 10111101b = 11111101b
-01001000b | 10111110b = 11111110b
-01001000b | 10111111b = 11111111b
-01001000b | 11000000b = 11001000b
-01001000b | 11000001b = 11001001b
-01001000b | 11000010b = 11001010b
-01001000b | 11000011b = 11001011b
-01001000b | 11000100b = 11001100b
-01001000b | 11000101b = 11001101b
-01001000b | 11000110b = 11001110b
-01001000b | 11000111b = 11001111b
-01001000b | 11001000b = 11001000b
-01001000b | 11001001b = 11001001b
-01001000b | 11001010b = 11001010b
-01001000b | 11001011b = 11001011b
-01001000b | 11001100b = 11001100b
-01001000b | 11001101b = 11001101b
-01001000b | 11001110b = 11001110b
-01001000b | 11001111b = 11001111b
-01001000b | 11010000b = 11011000b
-01001000b | 11010001b = 11011001b
-01001000b | 11010010b = 11011010b
-01001000b | 11010011b = 11011011b
-01001000b | 11010100b = 11011100b
-01001000b | 11010101b = 11011101b
-01001000b | 11010110b = 11011110b
-01001000b | 11010111b = 11011111b
-01001000b | 11011000b = 11011000b
-01001000b | 11011001b = 11011001b
-01001000b | 11011010b = 11011010b
-01001000b | 11011011b = 11011011b
-01001000b | 11011100b = 11011100b
-01001000b | 11011101b = 11011101b
-01001000b | 11011110b = 11011110b
-01001000b | 11011111b = 11011111b
-01001000b | 11100000b = 11101000b
-01001000b | 11100001b = 11101001b
-01001000b | 11100010b = 11101010b
-01001000b | 11100011b = 11101011b
-01001000b | 11100100b = 11101100b
-01001000b | 11100101b = 11101101b
-01001000b | 11100110b = 11101110b
-01001000b | 11100111b = 11101111b
-01001000b | 11101000b = 11101000b
-01001000b | 11101001b = 11101001b
-01001000b | 11101010b = 11101010b
-01001000b | 11101011b = 11101011b
-01001000b | 11101100b = 11101100b
-01001000b | 11101101b = 11101101b
-01001000b | 11101110b = 11101110b
-01001000b | 11101111b = 11101111b
-01001000b | 11110000b = 11111000b
-01001000b | 11110001b = 11111001b
-01001000b | 11110010b = 11111010b
-01001000b | 11110011b = 11111011b
-01001000b | 11110100b = 11111100b
-01001000b | 11110101b = 11111101b
-01001000b | 11110110b = 11111110b
-01001000b | 11110111b = 11111111b
-01001000b | 11111000b = 11111000b
-01001000b | 11111001b = 11111001b
-01001000b | 11111010b = 11111010b
-01001000b | 11111011b = 11111011b
-01001000b | 11111100b = 11111100b
-01001000b | 11111101b = 11111101b
-01001000b | 11111110b = 11111110b
-01001000b | 11111111b = 11111111b
-01001000b | 00000000b = 01001000b
-01001000b | 00000001b = 01001001b
-01001000b | 00000010b = 01001010b
-01001000b | 00000011b = 01001011b
-01001000b | 00000100b = 01001100b
-01001000b | 00000101b = 01001101b
-01001000b | 00000110b = 01001110b
-01001000b | 00000111b = 01001111b
-01001000b | 00001000b = 01001000b
-01001000b | 00001001b = 01001001b
-01001000b | 00001010b = 01001010b
-01001000b | 00001011b = 01001011b
-01001000b | 00001100b = 01001100b
-01001000b | 00001101b = 01001101b
-01001000b | 00001110b = 01001110b
-01001000b | 00001111b = 01001111b
-01001000b | 00010000b = 01011000b
-01001000b | 00010001b = 01011001b
-01001000b | 00010010b = 01011010b
-01001000b | 00010011b = 01011011b
-01001000b | 00010100b = 01011100b
-01001000b | 00010101b = 01011101b
-01001000b | 00010110b = 01011110b
-01001000b | 00010111b = 01011111b
-01001000b | 00011000b = 01011000b
-01001000b | 00011001b = 01011001b
-01001000b | 00011010b = 01011010b
-01001000b | 00011011b = 01011011b
-01001000b | 00011100b = 01011100b
-01001000b | 00011101b = 01011101b
-01001000b | 00011110b = 01011110b
-01001000b | 00011111b = 01011111b
-01001000b | 00100000b = 01101000b
-01001000b | 00100001b = 01101001b
-01001000b | 00100010b = 01101010b
-01001000b | 00100011b = 01101011b
-01001000b | 00100100b = 01101100b
-01001000b | 00100101b = 01101101b
-01001000b | 00100110b = 01101110b
-01001000b | 00100111b = 01101111b
-01001000b | 00101000b = 01101000b
-01001000b | 00101001b = 01101001b
-01001000b | 00101010b = 01101010b
-01001000b | 00101011b = 01101011b
-01001000b | 00101100b = 01101100b
-01001000b | 00101101b = 01101101b
-01001000b | 00101110b = 01101110b
-01001000b | 00101111b = 01101111b
-01001000b | 00110000b = 01111000b
-01001000b | 00110001b = 01111001b
-01001000b | 00110010b = 01111010b
-01001000b | 00110011b = 01111011b
-01001000b | 00110100b = 01111100b
-01001000b | 00110101b = 01111101b
-01001000b | 00110110b = 01111110b
-01001000b | 00110111b = 01111111b
-01001000b | 00111000b = 01111000b
-01001000b | 00111001b = 01111001b
-01001000b | 00111010b = 01111010b
-01001000b | 00111011b = 01111011b
-01001000b | 00111100b = 01111100b
-01001000b | 00111101b = 01111101b
-01001000b | 00111110b = 01111110b
-01001000b | 00111111b = 01111111b
-01001000b | 01000000b = 01001000b
-01001000b | 01000001b = 01001001b
-01001000b | 01000010b = 01001010b
-01001000b | 01000011b = 01001011b
-01001000b | 01000100b = 01001100b
-01001000b | 01000101b = 01001101b
-01001000b | 01000110b = 01001110b
-01001000b | 01000111b = 01001111b
-01001000b | 01001000b = 01001000b
-01001000b | 01001001b = 01001001b
-01001000b | 01001010b = 01001010b
-01001000b | 01001011b = 01001011b
-01001000b | 01001100b = 01001100b
-01001000b | 01001101b = 01001101b
-01001000b | 01001110b = 01001110b
-01001000b | 01001111b = 01001111b
-01001000b | 01010000b = 01011000b
-01001000b | 01010001b = 01011001b
-01001000b | 01010010b = 01011010b
-01001000b | 01010011b = 01011011b
-01001000b | 01010100b = 01011100b
-01001000b | 01010101b = 01011101b
-01001000b | 01010110b = 01011110b
-01001000b | 01010111b = 01011111b
-01001000b | 01011000b = 01011000b
-01001000b | 01011001b = 01011001b
-01001000b | 01011010b = 01011010b
-01001000b | 01011011b = 01011011b
-01001000b | 01011100b = 01011100b
-01001000b | 01011101b = 01011101b
-01001000b | 01011110b = 01011110b
-01001000b | 01011111b = 01011111b
-01001000b | 01100000b = 01101000b
-01001000b | 01100001b = 01101001b
-01001000b | 01100010b = 01101010b
-01001000b | 01100011b = 01101011b
-01001000b | 01100100b = 01101100b
-01001000b | 01100101b = 01101101b
-01001000b | 01100110b = 01101110b
-01001000b | 01100111b = 01101111b
-01001000b | 01101000b = 01101000b
-01001000b | 01101001b = 01101001b
-01001000b | 01101010b = 01101010b
-01001000b | 01101011b = 01101011b
-01001000b | 01101100b = 01101100b
-01001000b | 01101101b = 01101101b
-01001000b | 01101110b = 01101110b
-01001000b | 01101111b = 01101111b
-01001000b | 01110000b = 01111000b
-01001000b | 01110001b = 01111001b
-01001000b | 01110010b = 01111010b
-01001000b | 01110011b = 01111011b
-01001000b | 01110100b = 01111100b
-01001000b | 01110101b = 01111101b
-01001000b | 01110110b = 01111110b
-01001000b | 01110111b = 01111111b
-01001000b | 01111000b = 01111000b
-01001000b | 01111001b = 01111001b
-01001000b | 01111010b = 01111010b
-01001000b | 01111011b = 01111011b
-01001000b | 01111100b = 01111100b
-01001000b | 01111101b = 01111101b
-01001000b | 01111110b = 01111110b
-01001001b | 10000000b = 11001001b
-01001001b | 10000001b = 11001001b
-01001001b | 10000010b = 11001011b
-01001001b | 10000011b = 11001011b
-01001001b | 10000100b = 11001101b
-01001001b | 10000101b = 11001101b
-01001001b | 10000110b = 11001111b
-01001001b | 10000111b = 11001111b
-01001001b | 10001000b = 11001001b
-01001001b | 10001001b = 11001001b
-01001001b | 10001010b = 11001011b
-01001001b | 10001011b = 11001011b
-01001001b | 10001100b = 11001101b
-01001001b | 10001101b = 11001101b
-01001001b | 10001110b = 11001111b
-01001001b | 10001111b = 11001111b
-01001001b | 10010000b = 11011001b
-01001001b | 10010001b = 11011001b
-01001001b | 10010010b = 11011011b
-01001001b | 10010011b = 11011011b
-01001001b | 10010100b = 11011101b
-01001001b | 10010101b = 11011101b
-01001001b | 10010110b = 11011111b
-01001001b | 10010111b = 11011111b
-01001001b | 10011000b = 11011001b
-01001001b | 10011001b = 11011001b
-01001001b | 10011010b = 11011011b
-01001001b | 10011011b = 11011011b
-01001001b | 10011100b = 11011101b
-01001001b | 10011101b = 11011101b
-01001001b | 10011110b = 11011111b
-01001001b | 10011111b = 11011111b
-01001001b | 10100000b = 11101001b
-01001001b | 10100001b = 11101001b
-01001001b | 10100010b = 11101011b
-01001001b | 10100011b = 11101011b
-01001001b | 10100100b = 11101101b
-01001001b | 10100101b = 11101101b
-01001001b | 10100110b = 11101111b
-01001001b | 10100111b = 11101111b
-01001001b | 10101000b = 11101001b
-01001001b | 10101001b = 11101001b
-01001001b | 10101010b = 11101011b
-01001001b | 10101011b = 11101011b
-01001001b | 10101100b = 11101101b
-01001001b | 10101101b = 11101101b
-01001001b | 10101110b = 11101111b
-01001001b | 10101111b = 11101111b
-01001001b | 10110000b = 11111001b
-01001001b | 10110001b = 11111001b
-01001001b | 10110010b = 11111011b
-01001001b | 10110011b = 11111011b
-01001001b | 10110100b = 11111101b
-01001001b | 10110101b = 11111101b
-01001001b | 10110110b = 11111111b
-01001001b | 10110111b = 11111111b
-01001001b | 10111000b = 11111001b
-01001001b | 10111001b = 11111001b
-01001001b | 10111010b = 11111011b
-01001001b | 10111011b = 11111011b
-01001001b | 10111100b = 11111101b
-01001001b | 10111101b = 11111101b
-01001001b | 10111110b = 11111111b
-01001001b | 10111111b = 11111111b
-01001001b | 11000000b = 11001001b
-01001001b | 11000001b = 11001001b
-01001001b | 11000010b = 11001011b
-01001001b | 11000011b = 11001011b
-01001001b | 11000100b = 11001101b
-01001001b | 11000101b = 11001101b
-01001001b | 11000110b = 11001111b
-01001001b | 11000111b = 11001111b
-01001001b | 11001000b = 11001001b
-01001001b | 11001001b = 11001001b
-01001001b | 11001010b = 11001011b
-01001001b | 11001011b = 11001011b
-01001001b | 11001100b = 11001101b
-01001001b | 11001101b = 11001101b
-01001001b | 11001110b = 11001111b
-01001001b | 11001111b = 11001111b
-01001001b | 11010000b = 11011001b
-01001001b | 11010001b = 11011001b
-01001001b | 11010010b = 11011011b
-01001001b | 11010011b = 11011011b
-01001001b | 11010100b = 11011101b
-01001001b | 11010101b = 11011101b
-01001001b | 11010110b = 11011111b
-01001001b | 11010111b = 11011111b
-01001001b | 11011000b = 11011001b
-01001001b | 11011001b = 11011001b
-01001001b | 11011010b = 11011011b
-01001001b | 11011011b = 11011011b
-01001001b | 11011100b = 11011101b
-01001001b | 11011101b = 11011101b
-01001001b | 11011110b = 11011111b
-01001001b | 11011111b = 11011111b
-01001001b | 11100000b = 11101001b
-01001001b | 11100001b = 11101001b
-01001001b | 11100010b = 11101011b
-01001001b | 11100011b = 11101011b
-01001001b | 11100100b = 11101101b
-01001001b | 11100101b = 11101101b
-01001001b | 11100110b = 11101111b
-01001001b | 11100111b = 11101111b
-01001001b | 11101000b = 11101001b
-01001001b | 11101001b = 11101001b
-01001001b | 11101010b = 11101011b
-01001001b | 11101011b = 11101011b
-01001001b | 11101100b = 11101101b
-01001001b | 11101101b = 11101101b
-01001001b | 11101110b = 11101111b
-01001001b | 11101111b = 11101111b
-01001001b | 11110000b = 11111001b
-01001001b | 11110001b = 11111001b
-01001001b | 11110010b = 11111011b
-01001001b | 11110011b = 11111011b
-01001001b | 11110100b = 11111101b
-01001001b | 11110101b = 11111101b
-01001001b | 11110110b = 11111111b
-01001001b | 11110111b = 11111111b
-01001001b | 11111000b = 11111001b
-01001001b | 11111001b = 11111001b
-01001001b | 11111010b = 11111011b
-01001001b | 11111011b = 11111011b
-01001001b | 11111100b = 11111101b
-01001001b | 11111101b = 11111101b
-01001001b | 11111110b = 11111111b
-01001001b | 11111111b = 11111111b
-01001001b | 00000000b = 01001001b
-01001001b | 00000001b = 01001001b
-01001001b | 00000010b = 01001011b
-01001001b | 00000011b = 01001011b
-01001001b | 00000100b = 01001101b
-01001001b | 00000101b = 01001101b
-01001001b | 00000110b = 01001111b
-01001001b | 00000111b = 01001111b
-01001001b | 00001000b = 01001001b
-01001001b | 00001001b = 01001001b
-01001001b | 00001010b = 01001011b
-01001001b | 00001011b = 01001011b
-01001001b | 00001100b = 01001101b
-01001001b | 00001101b = 01001101b
-01001001b | 00001110b = 01001111b
-01001001b | 00001111b = 01001111b
-01001001b | 00010000b = 01011001b
-01001001b | 00010001b = 01011001b
-01001001b | 00010010b = 01011011b
-01001001b | 00010011b = 01011011b
-01001001b | 00010100b = 01011101b
-01001001b | 00010101b = 01011101b
-01001001b | 00010110b = 01011111b
-01001001b | 00010111b = 01011111b
-01001001b | 00011000b = 01011001b
-01001001b | 00011001b = 01011001b
-01001001b | 00011010b = 01011011b
-01001001b | 00011011b = 01011011b
-01001001b | 00011100b = 01011101b
-01001001b | 00011101b = 01011101b
-01001001b | 00011110b = 01011111b
-01001001b | 00011111b = 01011111b
-01001001b | 00100000b = 01101001b
-01001001b | 00100001b = 01101001b
-01001001b | 00100010b = 01101011b
-01001001b | 00100011b = 01101011b
-01001001b | 00100100b = 01101101b
-01001001b | 00100101b = 01101101b
-01001001b | 00100110b = 01101111b
-01001001b | 00100111b = 01101111b
-01001001b | 00101000b = 01101001b
-01001001b | 00101001b = 01101001b
-01001001b | 00101010b = 01101011b
-01001001b | 00101011b = 01101011b
-01001001b | 00101100b = 01101101b
-01001001b | 00101101b = 01101101b
-01001001b | 00101110b = 01101111b
-01001001b | 00101111b = 01101111b
-01001001b | 00110000b = 01111001b
-01001001b | 00110001b = 01111001b
-01001001b | 00110010b = 01111011b
-01001001b | 00110011b = 01111011b
-01001001b | 00110100b = 01111101b
-01001001b | 00110101b = 01111101b
-01001001b | 00110110b = 01111111b
-01001001b | 00110111b = 01111111b
-01001001b | 00111000b = 01111001b
-01001001b | 00111001b = 01111001b
-01001001b | 00111010b = 01111011b
-01001001b | 00111011b = 01111011b
-01001001b | 00111100b = 01111101b
-01001001b | 00111101b = 01111101b
-01001001b | 00111110b = 01111111b
-01001001b | 00111111b = 01111111b
-01001001b | 01000000b = 01001001b
-01001001b | 01000001b = 01001001b
-01001001b | 01000010b = 01001011b
-01001001b | 01000011b = 01001011b
-01001001b | 01000100b = 01001101b
-01001001b | 01000101b = 01001101b
-01001001b | 01000110b = 01001111b
-01001001b | 01000111b = 01001111b
-01001001b | 01001000b = 01001001b
-01001001b | 01001001b = 01001001b
-01001001b | 01001010b = 01001011b
-01001001b | 01001011b = 01001011b
-01001001b | 01001100b = 01001101b
-01001001b | 01001101b = 01001101b
-01001001b | 01001110b = 01001111b
-01001001b | 01001111b = 01001111b
-01001001b | 01010000b = 01011001b
-01001001b | 01010001b = 01011001b
-01001001b | 01010010b = 01011011b
-01001001b | 01010011b = 01011011b
-01001001b | 01010100b = 01011101b
-01001001b | 01010101b = 01011101b
-01001001b | 01010110b = 01011111b
-01001001b | 01010111b = 01011111b
-01001001b | 01011000b = 01011001b
-01001001b | 01011001b = 01011001b
-01001001b | 01011010b = 01011011b
-01001001b | 01011011b = 01011011b
-01001001b | 01011100b = 01011101b
-01001001b | 01011101b = 01011101b
-01001001b | 01011110b = 01011111b
-01001001b | 01011111b = 01011111b
-01001001b | 01100000b = 01101001b
-01001001b | 01100001b = 01101001b
-01001001b | 01100010b = 01101011b
-01001001b | 01100011b = 01101011b
-01001001b | 01100100b = 01101101b
-01001001b | 01100101b = 01101101b
-01001001b | 01100110b = 01101111b
-01001001b | 01100111b = 01101111b
-01001001b | 01101000b = 01101001b
-01001001b | 01101001b = 01101001b
-01001001b | 01101010b = 01101011b
-01001001b | 01101011b = 01101011b
-01001001b | 01101100b = 01101101b
-01001001b | 01101101b = 01101101b
-01001001b | 01101110b = 01101111b
-01001001b | 01101111b = 01101111b
-01001001b | 01110000b = 01111001b
-01001001b | 01110001b = 01111001b
-01001001b | 01110010b = 01111011b
-01001001b | 01110011b = 01111011b
-01001001b | 01110100b = 01111101b
-01001001b | 01110101b = 01111101b
-01001001b | 01110110b = 01111111b
-01001001b | 01110111b = 01111111b
-01001001b | 01111000b = 01111001b
-01001001b | 01111001b = 01111001b
-01001001b | 01111010b = 01111011b
-01001001b | 01111011b = 01111011b
-01001001b | 01111100b = 01111101b
-01001001b | 01111101b = 01111101b
-01001001b | 01111110b = 01111111b
-01001010b | 10000000b = 11001010b
-01001010b | 10000001b = 11001011b
-01001010b | 10000010b = 11001010b
-01001010b | 10000011b = 11001011b
-01001010b | 10000100b = 11001110b
-01001010b | 10000101b = 11001111b
-01001010b | 10000110b = 11001110b
-01001010b | 10000111b = 11001111b
-01001010b | 10001000b = 11001010b
-01001010b | 10001001b = 11001011b
-01001010b | 10001010b = 11001010b
-01001010b | 10001011b = 11001011b
-01001010b | 10001100b = 11001110b
-01001010b | 10001101b = 11001111b
-01001010b | 10001110b = 11001110b
-01001010b | 10001111b = 11001111b
-01001010b | 10010000b = 11011010b
-01001010b | 10010001b = 11011011b
-01001010b | 10010010b = 11011010b
-01001010b | 10010011b = 11011011b
-01001010b | 10010100b = 11011110b
-01001010b | 10010101b = 11011111b
-01001010b | 10010110b = 11011110b
-01001010b | 10010111b = 11011111b
-01001010b | 10011000b = 11011010b
-01001010b | 10011001b = 11011011b
-01001010b | 10011010b = 11011010b
-01001010b | 10011011b = 11011011b
-01001010b | 10011100b = 11011110b
-01001010b | 10011101b = 11011111b
-01001010b | 10011110b = 11011110b
-01001010b | 10011111b = 11011111b
-01001010b | 10100000b = 11101010b
-01001010b | 10100001b = 11101011b
-01001010b | 10100010b = 11101010b
-01001010b | 10100011b = 11101011b
-01001010b | 10100100b = 11101110b
-01001010b | 10100101b = 11101111b
-01001010b | 10100110b = 11101110b
-01001010b | 10100111b = 11101111b
-01001010b | 10101000b = 11101010b
-01001010b | 10101001b = 11101011b
-01001010b | 10101010b = 11101010b
-01001010b | 10101011b = 11101011b
-01001010b | 10101100b = 11101110b
-01001010b | 10101101b = 11101111b
-01001010b | 10101110b = 11101110b
-01001010b | 10101111b = 11101111b
-01001010b | 10110000b = 11111010b
-01001010b | 10110001b = 11111011b
-01001010b | 10110010b = 11111010b
-01001010b | 10110011b = 11111011b
-01001010b | 10110100b = 11111110b
-01001010b | 10110101b = 11111111b
-01001010b | 10110110b = 11111110b
-01001010b | 10110111b = 11111111b
-01001010b | 10111000b = 11111010b
-01001010b | 10111001b = 11111011b
-01001010b | 10111010b = 11111010b
-01001010b | 10111011b = 11111011b
-01001010b | 10111100b = 11111110b
-01001010b | 10111101b = 11111111b
-01001010b | 10111110b = 11111110b
-01001010b | 10111111b = 11111111b
-01001010b | 11000000b = 11001010b
-01001010b | 11000001b = 11001011b
-01001010b | 11000010b = 11001010b
-01001010b | 11000011b = 11001011b
-01001010b | 11000100b = 11001110b
-01001010b | 11000101b = 11001111b
-01001010b | 11000110b = 11001110b
-01001010b | 11000111b = 11001111b
-01001010b | 11001000b = 11001010b
-01001010b | 11001001b = 11001011b
-01001010b | 11001010b = 11001010b
-01001010b | 11001011b = 11001011b
-01001010b | 11001100b = 11001110b
-01001010b | 11001101b = 11001111b
-01001010b | 11001110b = 11001110b
-01001010b | 11001111b = 11001111b
-01001010b | 11010000b = 11011010b
-01001010b | 11010001b = 11011011b
-01001010b | 11010010b = 11011010b
-01001010b | 11010011b = 11011011b
-01001010b | 11010100b = 11011110b
-01001010b | 11010101b = 11011111b
-01001010b | 11010110b = 11011110b
-01001010b | 11010111b = 11011111b
-01001010b | 11011000b = 11011010b
-01001010b | 11011001b = 11011011b
-01001010b | 11011010b = 11011010b
-01001010b | 11011011b = 11011011b
-01001010b | 11011100b = 11011110b
-01001010b | 11011101b = 11011111b
-01001010b | 11011110b = 11011110b
-01001010b | 11011111b = 11011111b
-01001010b | 11100000b = 11101010b
-01001010b | 11100001b = 11101011b
-01001010b | 11100010b = 11101010b
-01001010b | 11100011b = 11101011b
-01001010b | 11100100b = 11101110b
-01001010b | 11100101b = 11101111b
-01001010b | 11100110b = 11101110b
-01001010b | 11100111b = 11101111b
-01001010b | 11101000b = 11101010b
-01001010b | 11101001b = 11101011b
-01001010b | 11101010b = 11101010b
-01001010b | 11101011b = 11101011b
-01001010b | 11101100b = 11101110b
-01001010b | 11101101b = 11101111b
-01001010b | 11101110b = 11101110b
-01001010b | 11101111b = 11101111b
-01001010b | 11110000b = 11111010b
-01001010b | 11110001b = 11111011b
-01001010b | 11110010b = 11111010b
-01001010b | 11110011b = 11111011b
-01001010b | 11110100b = 11111110b
-01001010b | 11110101b = 11111111b
-01001010b | 11110110b = 11111110b
-01001010b | 11110111b = 11111111b
-01001010b | 11111000b = 11111010b
-01001010b | 11111001b = 11111011b
-01001010b | 11111010b = 11111010b
-01001010b | 11111011b = 11111011b
-01001010b | 11111100b = 11111110b
-01001010b | 11111101b = 11111111b
-01001010b | 11111110b = 11111110b
-01001010b | 11111111b = 11111111b
-01001010b | 00000000b = 01001010b
-01001010b | 00000001b = 01001011b
-01001010b | 00000010b = 01001010b
-01001010b | 00000011b = 01001011b
-01001010b | 00000100b = 01001110b
-01001010b | 00000101b = 01001111b
-01001010b | 00000110b = 01001110b
-01001010b | 00000111b = 01001111b
-01001010b | 00001000b = 01001010b
-01001010b | 00001001b = 01001011b
-01001010b | 00001010b = 01001010b
-01001010b | 00001011b = 01001011b
-01001010b | 00001100b = 01001110b
-01001010b | 00001101b = 01001111b
-01001010b | 00001110b = 01001110b
-01001010b | 00001111b = 01001111b
-01001010b | 00010000b = 01011010b
-01001010b | 00010001b = 01011011b
-01001010b | 00010010b = 01011010b
-01001010b | 00010011b = 01011011b
-01001010b | 00010100b = 01011110b
-01001010b | 00010101b = 01011111b
-01001010b | 00010110b = 01011110b
-01001010b | 00010111b = 01011111b
-01001010b | 00011000b = 01011010b
-01001010b | 00011001b = 01011011b
-01001010b | 00011010b = 01011010b
-01001010b | 00011011b = 01011011b
-01001010b | 00011100b = 01011110b
-01001010b | 00011101b = 01011111b
-01001010b | 00011110b = 01011110b
-01001010b | 00011111b = 01011111b
-01001010b | 00100000b = 01101010b
-01001010b | 00100001b = 01101011b
-01001010b | 00100010b = 01101010b
-01001010b | 00100011b = 01101011b
-01001010b | 00100100b = 01101110b
-01001010b | 00100101b = 01101111b
-01001010b | 00100110b = 01101110b
-01001010b | 00100111b = 01101111b
-01001010b | 00101000b = 01101010b
-01001010b | 00101001b = 01101011b
-01001010b | 00101010b = 01101010b
-01001010b | 00101011b = 01101011b
-01001010b | 00101100b = 01101110b
-01001010b | 00101101b = 01101111b
-01001010b | 00101110b = 01101110b
-01001010b | 00101111b = 01101111b
-01001010b | 00110000b = 01111010b
-01001010b | 00110001b = 01111011b
-01001010b | 00110010b = 01111010b
-01001010b | 00110011b = 01111011b
-01001010b | 00110100b = 01111110b
-01001010b | 00110101b = 01111111b
-01001010b | 00110110b = 01111110b
-01001010b | 00110111b = 01111111b
-01001010b | 00111000b = 01111010b
-01001010b | 00111001b = 01111011b
-01001010b | 00111010b = 01111010b
-01001010b | 00111011b = 01111011b
-01001010b | 00111100b = 01111110b
-01001010b | 00111101b = 01111111b
-01001010b | 00111110b = 01111110b
-01001010b | 00111111b = 01111111b
-01001010b | 01000000b = 01001010b
-01001010b | 01000001b = 01001011b
-01001010b | 01000010b = 01001010b
-01001010b | 01000011b = 01001011b
-01001010b | 01000100b = 01001110b
-01001010b | 01000101b = 01001111b
-01001010b | 01000110b = 01001110b
-01001010b | 01000111b = 01001111b
-01001010b | 01001000b = 01001010b
-01001010b | 01001001b = 01001011b
-01001010b | 01001010b = 01001010b
-01001010b | 01001011b = 01001011b
-01001010b | 01001100b = 01001110b
-01001010b | 01001101b = 01001111b
-01001010b | 01001110b = 01001110b
-01001010b | 01001111b = 01001111b
-01001010b | 01010000b = 01011010b
-01001010b | 01010001b = 01011011b
-01001010b | 01010010b = 01011010b
-01001010b | 01010011b = 01011011b
-01001010b | 01010100b = 01011110b
-01001010b | 01010101b = 01011111b
-01001010b | 01010110b = 01011110b
-01001010b | 01010111b = 01011111b
-01001010b | 01011000b = 01011010b
-01001010b | 01011001b = 01011011b
-01001010b | 01011010b = 01011010b
-01001010b | 01011011b = 01011011b
-01001010b | 01011100b = 01011110b
-01001010b | 01011101b = 01011111b
-01001010b | 01011110b = 01011110b
-01001010b | 01011111b = 01011111b
-01001010b | 01100000b = 01101010b
-01001010b | 01100001b = 01101011b
-01001010b | 01100010b = 01101010b
-01001010b | 01100011b = 01101011b
-01001010b | 01100100b = 01101110b
-01001010b | 01100101b = 01101111b
-01001010b | 01100110b = 01101110b
-01001010b | 01100111b = 01101111b
-01001010b | 01101000b = 01101010b
-01001010b | 01101001b = 01101011b
-01001010b | 01101010b = 01101010b
-01001010b | 01101011b = 01101011b
-01001010b | 01101100b = 01101110b
-01001010b | 01101101b = 01101111b
-01001010b | 01101110b = 01101110b
-01001010b | 01101111b = 01101111b
-01001010b | 01110000b = 01111010b
-01001010b | 01110001b = 01111011b
-01001010b | 01110010b = 01111010b
-01001010b | 01110011b = 01111011b
-01001010b | 01110100b = 01111110b
-01001010b | 01110101b = 01111111b
-01001010b | 01110110b = 01111110b
-01001010b | 01110111b = 01111111b
-01001010b | 01111000b = 01111010b
-01001010b | 01111001b = 01111011b
-01001010b | 01111010b = 01111010b
-01001010b | 01111011b = 01111011b
-01001010b | 01111100b = 01111110b
-01001010b | 01111101b = 01111111b
-01001010b | 01111110b = 01111110b
-01001011b | 10000000b = 11001011b
-01001011b | 10000001b = 11001011b
-01001011b | 10000010b = 11001011b
-01001011b | 10000011b = 11001011b
-01001011b | 10000100b = 11001111b
-01001011b | 10000101b = 11001111b
-01001011b | 10000110b = 11001111b
-01001011b | 10000111b = 11001111b
-01001011b | 10001000b = 11001011b
-01001011b | 10001001b = 11001011b
-01001011b | 10001010b = 11001011b
-01001011b | 10001011b = 11001011b
-01001011b | 10001100b = 11001111b
-01001011b | 10001101b = 11001111b
-01001011b | 10001110b = 11001111b
-01001011b | 10001111b = 11001111b
-01001011b | 10010000b = 11011011b
-01001011b | 10010001b = 11011011b
-01001011b | 10010010b = 11011011b
-01001011b | 10010011b = 11011011b
-01001011b | 10010100b = 11011111b
-01001011b | 10010101b = 11011111b
-01001011b | 10010110b = 11011111b
-01001011b | 10010111b = 11011111b
-01001011b | 10011000b = 11011011b
-01001011b | 10011001b = 11011011b
-01001011b | 10011010b = 11011011b
-01001011b | 10011011b = 11011011b
-01001011b | 10011100b = 11011111b
-01001011b | 10011101b = 11011111b
-01001011b | 10011110b = 11011111b
-01001011b | 10011111b = 11011111b
-01001011b | 10100000b = 11101011b
-01001011b | 10100001b = 11101011b
-01001011b | 10100010b = 11101011b
-01001011b | 10100011b = 11101011b
-01001011b | 10100100b = 11101111b
-01001011b | 10100101b = 11101111b
-01001011b | 10100110b = 11101111b
-01001011b | 10100111b = 11101111b
-01001011b | 10101000b = 11101011b
-01001011b | 10101001b = 11101011b
-01001011b | 10101010b = 11101011b
-01001011b | 10101011b = 11101011b
-01001011b | 10101100b = 11101111b
-01001011b | 10101101b = 11101111b
-01001011b | 10101110b = 11101111b
-01001011b | 10101111b = 11101111b
-01001011b | 10110000b = 11111011b
-01001011b | 10110001b = 11111011b
-01001011b | 10110010b = 11111011b
-01001011b | 10110011b = 11111011b
-01001011b | 10110100b = 11111111b
-01001011b | 10110101b = 11111111b
-01001011b | 10110110b = 11111111b
-01001011b | 10110111b = 11111111b
-01001011b | 10111000b = 11111011b
-01001011b | 10111001b = 11111011b
-01001011b | 10111010b = 11111011b
-01001011b | 10111011b = 11111011b
-01001011b | 10111100b = 11111111b
-01001011b | 10111101b = 11111111b
-01001011b | 10111110b = 11111111b
-01001011b | 10111111b = 11111111b
-01001011b | 11000000b = 11001011b
-01001011b | 11000001b = 11001011b
-01001011b | 11000010b = 11001011b
-01001011b | 11000011b = 11001011b
-01001011b | 11000100b = 11001111b
-01001011b | 11000101b = 11001111b
-01001011b | 11000110b = 11001111b
-01001011b | 11000111b = 11001111b
-01001011b | 11001000b = 11001011b
-01001011b | 11001001b = 11001011b
-01001011b | 11001010b = 11001011b
-01001011b | 11001011b = 11001011b
-01001011b | 11001100b = 11001111b
-01001011b | 11001101b = 11001111b
-01001011b | 11001110b = 11001111b
-01001011b | 11001111b = 11001111b
-01001011b | 11010000b = 11011011b
-01001011b | 11010001b = 11011011b
-01001011b | 11010010b = 11011011b
-01001011b | 11010011b = 11011011b
-01001011b | 11010100b = 11011111b
-01001011b | 11010101b = 11011111b
-01001011b | 11010110b = 11011111b
-01001011b | 11010111b = 11011111b
-01001011b | 11011000b = 11011011b
-01001011b | 11011001b = 11011011b
-01001011b | 11011010b = 11011011b
-01001011b | 11011011b = 11011011b
-01001011b | 11011100b = 11011111b
-01001011b | 11011101b = 11011111b
-01001011b | 11011110b = 11011111b
-01001011b | 11011111b = 11011111b
-01001011b | 11100000b = 11101011b
-01001011b | 11100001b = 11101011b
-01001011b | 11100010b = 11101011b
-01001011b | 11100011b = 11101011b
-01001011b | 11100100b = 11101111b
-01001011b | 11100101b = 11101111b
-01001011b | 11100110b = 11101111b
-01001011b | 11100111b = 11101111b
-01001011b | 11101000b = 11101011b
-01001011b | 11101001b = 11101011b
-01001011b | 11101010b = 11101011b
-01001011b | 11101011b = 11101011b
-01001011b | 11101100b = 11101111b
-01001011b | 11101101b = 11101111b
-01001011b | 11101110b = 11101111b
-01001011b | 11101111b = 11101111b
-01001011b | 11110000b = 11111011b
-01001011b | 11110001b = 11111011b
-01001011b | 11110010b = 11111011b
-01001011b | 11110011b = 11111011b
-01001011b | 11110100b = 11111111b
-01001011b | 11110101b = 11111111b
-01001011b | 11110110b = 11111111b
-01001011b | 11110111b = 11111111b
-01001011b | 11111000b = 11111011b
-01001011b | 11111001b = 11111011b
-01001011b | 11111010b = 11111011b
-01001011b | 11111011b = 11111011b
-01001011b | 11111100b = 11111111b
-01001011b | 11111101b = 11111111b
-01001011b | 11111110b = 11111111b
-01001011b | 11111111b = 11111111b
-01001011b | 00000000b = 01001011b
-01001011b | 00000001b = 01001011b
-01001011b | 00000010b = 01001011b
-01001011b | 00000011b = 01001011b
-01001011b | 00000100b = 01001111b
-01001011b | 00000101b = 01001111b
-01001011b | 00000110b = 01001111b
-01001011b | 00000111b = 01001111b
-01001011b | 00001000b = 01001011b
-01001011b | 00001001b = 01001011b
-01001011b | 00001010b = 01001011b
-01001011b | 00001011b = 01001011b
-01001011b | 00001100b = 01001111b
-01001011b | 00001101b = 01001111b
-01001011b | 00001110b = 01001111b
-01001011b | 00001111b = 01001111b
-01001011b | 00010000b = 01011011b
-01001011b | 00010001b = 01011011b
-01001011b | 00010010b = 01011011b
-01001011b | 00010011b = 01011011b
-01001011b | 00010100b = 01011111b
-01001011b | 00010101b = 01011111b
-01001011b | 00010110b = 01011111b
-01001011b | 00010111b = 01011111b
-01001011b | 00011000b = 01011011b
-01001011b | 00011001b = 01011011b
-01001011b | 00011010b = 01011011b
-01001011b | 00011011b = 01011011b
-01001011b | 00011100b = 01011111b
-01001011b | 00011101b = 01011111b
-01001011b | 00011110b = 01011111b
-01001011b | 00011111b = 01011111b
-01001011b | 00100000b = 01101011b
-01001011b | 00100001b = 01101011b
-01001011b | 00100010b = 01101011b
-01001011b | 00100011b = 01101011b
-01001011b | 00100100b = 01101111b
-01001011b | 00100101b = 01101111b
-01001011b | 00100110b = 01101111b
-01001011b | 00100111b = 01101111b
-01001011b | 00101000b = 01101011b
-01001011b | 00101001b = 01101011b
-01001011b | 00101010b = 01101011b
-01001011b | 00101011b = 01101011b
-01001011b | 00101100b = 01101111b
-01001011b | 00101101b = 01101111b
-01001011b | 00101110b = 01101111b
-01001011b | 00101111b = 01101111b
-01001011b | 00110000b = 01111011b
-01001011b | 00110001b = 01111011b
-01001011b | 00110010b = 01111011b
-01001011b | 00110011b = 01111011b
-01001011b | 00110100b = 01111111b
-01001011b | 00110101b = 01111111b
-01001011b | 00110110b = 01111111b
-01001011b | 00110111b = 01111111b
-01001011b | 00111000b = 01111011b
-01001011b | 00111001b = 01111011b
-01001011b | 00111010b = 01111011b
-01001011b | 00111011b = 01111011b
-01001011b | 00111100b = 01111111b
-01001011b | 00111101b = 01111111b
-01001011b | 00111110b = 01111111b
-01001011b | 00111111b = 01111111b
-01001011b | 01000000b = 01001011b
-01001011b | 01000001b = 01001011b
-01001011b | 01000010b = 01001011b
-01001011b | 01000011b = 01001011b
-01001011b | 01000100b = 01001111b
-01001011b | 01000101b = 01001111b
-01001011b | 01000110b = 01001111b
-01001011b | 01000111b = 01001111b
-01001011b | 01001000b = 01001011b
-01001011b | 01001001b = 01001011b
-01001011b | 01001010b = 01001011b
-01001011b | 01001011b = 01001011b
-01001011b | 01001100b = 01001111b
-01001011b | 01001101b = 01001111b
-01001011b | 01001110b = 01001111b
-01001011b | 01001111b = 01001111b
-01001011b | 01010000b = 01011011b
-01001011b | 01010001b = 01011011b
-01001011b | 01010010b = 01011011b
-01001011b | 01010011b = 01011011b
-01001011b | 01010100b = 01011111b
-01001011b | 01010101b = 01011111b
-01001011b | 01010110b = 01011111b
-01001011b | 01010111b = 01011111b
-01001011b | 01011000b = 01011011b
-01001011b | 01011001b = 01011011b
-01001011b | 01011010b = 01011011b
-01001011b | 01011011b = 01011011b
-01001011b | 01011100b = 01011111b
-01001011b | 01011101b = 01011111b
-01001011b | 01011110b = 01011111b
-01001011b | 01011111b = 01011111b
-01001011b | 01100000b = 01101011b
-01001011b | 01100001b = 01101011b
-01001011b | 01100010b = 01101011b
-01001011b | 01100011b = 01101011b
-01001011b | 01100100b = 01101111b
-01001011b | 01100101b = 01101111b
-01001011b | 01100110b = 01101111b
-01001011b | 01100111b = 01101111b
-01001011b | 01101000b = 01101011b
-01001011b | 01101001b = 01101011b
-01001011b | 01101010b = 01101011b
-01001011b | 01101011b = 01101011b
-01001011b | 01101100b = 01101111b
-01001011b | 01101101b = 01101111b
-01001011b | 01101110b = 01101111b
-01001011b | 01101111b = 01101111b
-01001011b | 01110000b = 01111011b
-01001011b | 01110001b = 01111011b
-01001011b | 01110010b = 01111011b
-01001011b | 01110011b = 01111011b
-01001011b | 01110100b = 01111111b
-01001011b | 01110101b = 01111111b
-01001011b | 01110110b = 01111111b
-01001011b | 01110111b = 01111111b
-01001011b | 01111000b = 01111011b
-01001011b | 01111001b = 01111011b
-01001011b | 01111010b = 01111011b
-01001011b | 01111011b = 01111011b
-01001011b | 01111100b = 01111111b
-01001011b | 01111101b = 01111111b
-01001011b | 01111110b = 01111111b
-01001100b | 10000000b = 11001100b
-01001100b | 10000001b = 11001101b
-01001100b | 10000010b = 11001110b
-01001100b | 10000011b = 11001111b
-01001100b | 10000100b = 11001100b
-01001100b | 10000101b = 11001101b
-01001100b | 10000110b = 11001110b
-01001100b | 10000111b = 11001111b
-01001100b | 10001000b = 11001100b
-01001100b | 10001001b = 11001101b
-01001100b | 10001010b = 11001110b
-01001100b | 10001011b = 11001111b
-01001100b | 10001100b = 11001100b
-01001100b | 10001101b = 11001101b
-01001100b | 10001110b = 11001110b
-01001100b | 10001111b = 11001111b
-01001100b | 10010000b = 11011100b
-01001100b | 10010001b = 11011101b
-01001100b | 10010010b = 11011110b
-01001100b | 10010011b = 11011111b
-01001100b | 10010100b = 11011100b
-01001100b | 10010101b = 11011101b
-01001100b | 10010110b = 11011110b
-01001100b | 10010111b = 11011111b
-01001100b | 10011000b = 11011100b
-01001100b | 10011001b = 11011101b
-01001100b | 10011010b = 11011110b
-01001100b | 10011011b = 11011111b
-01001100b | 10011100b = 11011100b
-01001100b | 10011101b = 11011101b
-01001100b | 10011110b = 11011110b
-01001100b | 10011111b = 11011111b
-01001100b | 10100000b = 11101100b
-01001100b | 10100001b = 11101101b
-01001100b | 10100010b = 11101110b
-01001100b | 10100011b = 11101111b
-01001100b | 10100100b = 11101100b
-01001100b | 10100101b = 11101101b
-01001100b | 10100110b = 11101110b
-01001100b | 10100111b = 11101111b
-01001100b | 10101000b = 11101100b
-01001100b | 10101001b = 11101101b
-01001100b | 10101010b = 11101110b
-01001100b | 10101011b = 11101111b
-01001100b | 10101100b = 11101100b
-01001100b | 10101101b = 11101101b
-01001100b | 10101110b = 11101110b
-01001100b | 10101111b = 11101111b
-01001100b | 10110000b = 11111100b
-01001100b | 10110001b = 11111101b
-01001100b | 10110010b = 11111110b
-01001100b | 10110011b = 11111111b
-01001100b | 10110100b = 11111100b
-01001100b | 10110101b = 11111101b
-01001100b | 10110110b = 11111110b
-01001100b | 10110111b = 11111111b
-01001100b | 10111000b = 11111100b
-01001100b | 10111001b = 11111101b
-01001100b | 10111010b = 11111110b
-01001100b | 10111011b = 11111111b
-01001100b | 10111100b = 11111100b
-01001100b | 10111101b = 11111101b
-01001100b | 10111110b = 11111110b
-01001100b | 10111111b = 11111111b
-01001100b | 11000000b = 11001100b
-01001100b | 11000001b = 11001101b
-01001100b | 11000010b = 11001110b
-01001100b | 11000011b = 11001111b
-01001100b | 11000100b = 11001100b
-01001100b | 11000101b = 11001101b
-01001100b | 11000110b = 11001110b
-01001100b | 11000111b = 11001111b
-01001100b | 11001000b = 11001100b
-01001100b | 11001001b = 11001101b
-01001100b | 11001010b = 11001110b
-01001100b | 11001011b = 11001111b
-01001100b | 11001100b = 11001100b
-01001100b | 11001101b = 11001101b
-01001100b | 11001110b = 11001110b
-01001100b | 11001111b = 11001111b
-01001100b | 11010000b = 11011100b
-01001100b | 11010001b = 11011101b
-01001100b | 11010010b = 11011110b
-01001100b | 11010011b = 11011111b
-01001100b | 11010100b = 11011100b
-01001100b | 11010101b = 11011101b
-01001100b | 11010110b = 11011110b
-01001100b | 11010111b = 11011111b
-01001100b | 11011000b = 11011100b
-01001100b | 11011001b = 11011101b
-01001100b | 11011010b = 11011110b
-01001100b | 11011011b = 11011111b
-01001100b | 11011100b = 11011100b
-01001100b | 11011101b = 11011101b
-01001100b | 11011110b = 11011110b
-01001100b | 11011111b = 11011111b
-01001100b | 11100000b = 11101100b
-01001100b | 11100001b = 11101101b
-01001100b | 11100010b = 11101110b
-01001100b | 11100011b = 11101111b
-01001100b | 11100100b = 11101100b
-01001100b | 11100101b = 11101101b
-01001100b | 11100110b = 11101110b
-01001100b | 11100111b = 11101111b
-01001100b | 11101000b = 11101100b
-01001100b | 11101001b = 11101101b
-01001100b | 11101010b = 11101110b
-01001100b | 11101011b = 11101111b
-01001100b | 11101100b = 11101100b
-01001100b | 11101101b = 11101101b
-01001100b | 11101110b = 11101110b
-01001100b | 11101111b = 11101111b
-01001100b | 11110000b = 11111100b
-01001100b | 11110001b = 11111101b
-01001100b | 11110010b = 11111110b
-01001100b | 11110011b = 11111111b
-01001100b | 11110100b = 11111100b
-01001100b | 11110101b = 11111101b
-01001100b | 11110110b = 11111110b
-01001100b | 11110111b = 11111111b
-01001100b | 11111000b = 11111100b
-01001100b | 11111001b = 11111101b
-01001100b | 11111010b = 11111110b
-01001100b | 11111011b = 11111111b
-01001100b | 11111100b = 11111100b
-01001100b | 11111101b = 11111101b
-01001100b | 11111110b = 11111110b
-01001100b | 11111111b = 11111111b
-01001100b | 00000000b = 01001100b
-01001100b | 00000001b = 01001101b
-01001100b | 00000010b = 01001110b
-01001100b | 00000011b = 01001111b
-01001100b | 00000100b = 01001100b
-01001100b | 00000101b = 01001101b
-01001100b | 00000110b = 01001110b
-01001100b | 00000111b = 01001111b
-01001100b | 00001000b = 01001100b
-01001100b | 00001001b = 01001101b
-01001100b | 00001010b = 01001110b
-01001100b | 00001011b = 01001111b
-01001100b | 00001100b = 01001100b
-01001100b | 00001101b = 01001101b
-01001100b | 00001110b = 01001110b
-01001100b | 00001111b = 01001111b
-01001100b | 00010000b = 01011100b
-01001100b | 00010001b = 01011101b
-01001100b | 00010010b = 01011110b
-01001100b | 00010011b = 01011111b
-01001100b | 00010100b = 01011100b
-01001100b | 00010101b = 01011101b
-01001100b | 00010110b = 01011110b
-01001100b | 00010111b = 01011111b
-01001100b | 00011000b = 01011100b
-01001100b | 00011001b = 01011101b
-01001100b | 00011010b = 01011110b
-01001100b | 00011011b = 01011111b
-01001100b | 00011100b = 01011100b
-01001100b | 00011101b = 01011101b
-01001100b | 00011110b = 01011110b
-01001100b | 00011111b = 01011111b
-01001100b | 00100000b = 01101100b
-01001100b | 00100001b = 01101101b
-01001100b | 00100010b = 01101110b
-01001100b | 00100011b = 01101111b
-01001100b | 00100100b = 01101100b
-01001100b | 00100101b = 01101101b
-01001100b | 00100110b = 01101110b
-01001100b | 00100111b = 01101111b
-01001100b | 00101000b = 01101100b
-01001100b | 00101001b = 01101101b
-01001100b | 00101010b = 01101110b
-01001100b | 00101011b = 01101111b
-01001100b | 00101100b = 01101100b
-01001100b | 00101101b = 01101101b
-01001100b | 00101110b = 01101110b
-01001100b | 00101111b = 01101111b
-01001100b | 00110000b = 01111100b
-01001100b | 00110001b = 01111101b
-01001100b | 00110010b = 01111110b
-01001100b | 00110011b = 01111111b
-01001100b | 00110100b = 01111100b
-01001100b | 00110101b = 01111101b
-01001100b | 00110110b = 01111110b
-01001100b | 00110111b = 01111111b
-01001100b | 00111000b = 01111100b
-01001100b | 00111001b = 01111101b
-01001100b | 00111010b = 01111110b
-01001100b | 00111011b = 01111111b
-01001100b | 00111100b = 01111100b
-01001100b | 00111101b = 01111101b
-01001100b | 00111110b = 01111110b
-01001100b | 00111111b = 01111111b
-01001100b | 01000000b = 01001100b
-01001100b | 01000001b = 01001101b
-01001100b | 01000010b = 01001110b
-01001100b | 01000011b = 01001111b
-01001100b | 01000100b = 01001100b
-01001100b | 01000101b = 01001101b
-01001100b | 01000110b = 01001110b
-01001100b | 01000111b = 01001111b
-01001100b | 01001000b = 01001100b
-01001100b | 01001001b = 01001101b
-01001100b | 01001010b = 01001110b
-01001100b | 01001011b = 01001111b
-01001100b | 01001100b = 01001100b
-01001100b | 01001101b = 01001101b
-01001100b | 01001110b = 01001110b
-01001100b | 01001111b = 01001111b
-01001100b | 01010000b = 01011100b
-01001100b | 01010001b = 01011101b
-01001100b | 01010010b = 01011110b
-01001100b | 01010011b = 01011111b
-01001100b | 01010100b = 01011100b
-01001100b | 01010101b = 01011101b
-01001100b | 01010110b = 01011110b
-01001100b | 01010111b = 01011111b
-01001100b | 01011000b = 01011100b
-01001100b | 01011001b = 01011101b
-01001100b | 01011010b = 01011110b
-01001100b | 01011011b = 01011111b
-01001100b | 01011100b = 01011100b
-01001100b | 01011101b = 01011101b
-01001100b | 01011110b = 01011110b
-01001100b | 01011111b = 01011111b
-01001100b | 01100000b = 01101100b
-01001100b | 01100001b = 01101101b
-01001100b | 01100010b = 01101110b
-01001100b | 01100011b = 01101111b
-01001100b | 01100100b = 01101100b
-01001100b | 01100101b = 01101101b
-01001100b | 01100110b = 01101110b
-01001100b | 01100111b = 01101111b
-01001100b | 01101000b = 01101100b
-01001100b | 01101001b = 01101101b
-01001100b | 01101010b = 01101110b
-01001100b | 01101011b = 01101111b
-01001100b | 01101100b = 01101100b
-01001100b | 01101101b = 01101101b
-01001100b | 01101110b = 01101110b
-01001100b | 01101111b = 01101111b
-01001100b | 01110000b = 01111100b
-01001100b | 01110001b = 01111101b
-01001100b | 01110010b = 01111110b
-01001100b | 01110011b = 01111111b
-01001100b | 01110100b = 01111100b
-01001100b | 01110101b = 01111101b
-01001100b | 01110110b = 01111110b
-01001100b | 01110111b = 01111111b
-01001100b | 01111000b = 01111100b
-01001100b | 01111001b = 01111101b
-01001100b | 01111010b = 01111110b
-01001100b | 01111011b = 01111111b
-01001100b | 01111100b = 01111100b
-01001100b | 01111101b = 01111101b
-01001100b | 01111110b = 01111110b
-01001101b | 10000000b = 11001101b
-01001101b | 10000001b = 11001101b
-01001101b | 10000010b = 11001111b
-01001101b | 10000011b = 11001111b
-01001101b | 10000100b = 11001101b
-01001101b | 10000101b = 11001101b
-01001101b | 10000110b = 11001111b
-01001101b | 10000111b = 11001111b
-01001101b | 10001000b = 11001101b
-01001101b | 10001001b = 11001101b
-01001101b | 10001010b = 11001111b
-01001101b | 10001011b = 11001111b
-01001101b | 10001100b = 11001101b
-01001101b | 10001101b = 11001101b
-01001101b | 10001110b = 11001111b
-01001101b | 10001111b = 11001111b
-01001101b | 10010000b = 11011101b
-01001101b | 10010001b = 11011101b
-01001101b | 10010010b = 11011111b
-01001101b | 10010011b = 11011111b
-01001101b | 10010100b = 11011101b
-01001101b | 10010101b = 11011101b
-01001101b | 10010110b = 11011111b
-01001101b | 10010111b = 11011111b
-01001101b | 10011000b = 11011101b
-01001101b | 10011001b = 11011101b
-01001101b | 10011010b = 11011111b
-01001101b | 10011011b = 11011111b
-01001101b | 10011100b = 11011101b
-01001101b | 10011101b = 11011101b
-01001101b | 10011110b = 11011111b
-01001101b | 10011111b = 11011111b
-01001101b | 10100000b = 11101101b
-01001101b | 10100001b = 11101101b
-01001101b | 10100010b = 11101111b
-01001101b | 10100011b = 11101111b
-01001101b | 10100100b = 11101101b
-01001101b | 10100101b = 11101101b
-01001101b | 10100110b = 11101111b
-01001101b | 10100111b = 11101111b
-01001101b | 10101000b = 11101101b
-01001101b | 10101001b = 11101101b
-01001101b | 10101010b = 11101111b
-01001101b | 10101011b = 11101111b
-01001101b | 10101100b = 11101101b
-01001101b | 10101101b = 11101101b
-01001101b | 10101110b = 11101111b
-01001101b | 10101111b = 11101111b
-01001101b | 10110000b = 11111101b
-01001101b | 10110001b = 11111101b
-01001101b | 10110010b = 11111111b
-01001101b | 10110011b = 11111111b
-01001101b | 10110100b = 11111101b
-01001101b | 10110101b = 11111101b
-01001101b | 10110110b = 11111111b
-01001101b | 10110111b = 11111111b
-01001101b | 10111000b = 11111101b
-01001101b | 10111001b = 11111101b
-01001101b | 10111010b = 11111111b
-01001101b | 10111011b = 11111111b
-01001101b | 10111100b = 11111101b
-01001101b | 10111101b = 11111101b
-01001101b | 10111110b = 11111111b
-01001101b | 10111111b = 11111111b
-01001101b | 11000000b = 11001101b
-01001101b | 11000001b = 11001101b
-01001101b | 11000010b = 11001111b
-01001101b | 11000011b = 11001111b
-01001101b | 11000100b = 11001101b
-01001101b | 11000101b = 11001101b
-01001101b | 11000110b = 11001111b
-01001101b | 11000111b = 11001111b
-01001101b | 11001000b = 11001101b
-01001101b | 11001001b = 11001101b
-01001101b | 11001010b = 11001111b
-01001101b | 11001011b = 11001111b
-01001101b | 11001100b = 11001101b
-01001101b | 11001101b = 11001101b
-01001101b | 11001110b = 11001111b
-01001101b | 11001111b = 11001111b
-01001101b | 11010000b = 11011101b
-01001101b | 11010001b = 11011101b
-01001101b | 11010010b = 11011111b
-01001101b | 11010011b = 11011111b
-01001101b | 11010100b = 11011101b
-01001101b | 11010101b = 11011101b
-01001101b | 11010110b = 11011111b
-01001101b | 11010111b = 11011111b
-01001101b | 11011000b = 11011101b
-01001101b | 11011001b = 11011101b
-01001101b | 11011010b = 11011111b
-01001101b | 11011011b = 11011111b
-01001101b | 11011100b = 11011101b
-01001101b | 11011101b = 11011101b
-01001101b | 11011110b = 11011111b
-01001101b | 11011111b = 11011111b
-01001101b | 11100000b = 11101101b
-01001101b | 11100001b = 11101101b
-01001101b | 11100010b = 11101111b
-01001101b | 11100011b = 11101111b
-01001101b | 11100100b = 11101101b
-01001101b | 11100101b = 11101101b
-01001101b | 11100110b = 11101111b
-01001101b | 11100111b = 11101111b
-01001101b | 11101000b = 11101101b
-01001101b | 11101001b = 11101101b
-01001101b | 11101010b = 11101111b
-01001101b | 11101011b = 11101111b
-01001101b | 11101100b = 11101101b
-01001101b | 11101101b = 11101101b
-01001101b | 11101110b = 11101111b
-01001101b | 11101111b = 11101111b
-01001101b | 11110000b = 11111101b
-01001101b | 11110001b = 11111101b
-01001101b | 11110010b = 11111111b
-01001101b | 11110011b = 11111111b
-01001101b | 11110100b = 11111101b
-01001101b | 11110101b = 11111101b
-01001101b | 11110110b = 11111111b
-01001101b | 11110111b = 11111111b
-01001101b | 11111000b = 11111101b
-01001101b | 11111001b = 11111101b
-01001101b | 11111010b = 11111111b
-01001101b | 11111011b = 11111111b
-01001101b | 11111100b = 11111101b
-01001101b | 11111101b = 11111101b
-01001101b | 11111110b = 11111111b
-01001101b | 11111111b = 11111111b
-01001101b | 00000000b = 01001101b
-01001101b | 00000001b = 01001101b
-01001101b | 00000010b = 01001111b
-01001101b | 00000011b = 01001111b
-01001101b | 00000100b = 01001101b
-01001101b | 00000101b = 01001101b
-01001101b | 00000110b = 01001111b
-01001101b | 00000111b = 01001111b
-01001101b | 00001000b = 01001101b
-01001101b | 00001001b = 01001101b
-01001101b | 00001010b = 01001111b
-01001101b | 00001011b = 01001111b
-01001101b | 00001100b = 01001101b
-01001101b | 00001101b = 01001101b
-01001101b | 00001110b = 01001111b
-01001101b | 00001111b = 01001111b
-01001101b | 00010000b = 01011101b
-01001101b | 00010001b = 01011101b
-01001101b | 00010010b = 01011111b
-01001101b | 00010011b = 01011111b
-01001101b | 00010100b = 01011101b
-01001101b | 00010101b = 01011101b
-01001101b | 00010110b = 01011111b
-01001101b | 00010111b = 01011111b
-01001101b | 00011000b = 01011101b
-01001101b | 00011001b = 01011101b
-01001101b | 00011010b = 01011111b
-01001101b | 00011011b = 01011111b
-01001101b | 00011100b = 01011101b
-01001101b | 00011101b = 01011101b
-01001101b | 00011110b = 01011111b
-01001101b | 00011111b = 01011111b
-01001101b | 00100000b = 01101101b
-01001101b | 00100001b = 01101101b
-01001101b | 00100010b = 01101111b
-01001101b | 00100011b = 01101111b
-01001101b | 00100100b = 01101101b
-01001101b | 00100101b = 01101101b
-01001101b | 00100110b = 01101111b
-01001101b | 00100111b = 01101111b
-01001101b | 00101000b = 01101101b
-01001101b | 00101001b = 01101101b
-01001101b | 00101010b = 01101111b
-01001101b | 00101011b = 01101111b
-01001101b | 00101100b = 01101101b
-01001101b | 00101101b = 01101101b
-01001101b | 00101110b = 01101111b
-01001101b | 00101111b = 01101111b
-01001101b | 00110000b = 01111101b
-01001101b | 00110001b = 01111101b
-01001101b | 00110010b = 01111111b
-01001101b | 00110011b = 01111111b
-01001101b | 00110100b = 01111101b
-01001101b | 00110101b = 01111101b
-01001101b | 00110110b = 01111111b
-01001101b | 00110111b = 01111111b
-01001101b | 00111000b = 01111101b
-01001101b | 00111001b = 01111101b
-01001101b | 00111010b = 01111111b
-01001101b | 00111011b = 01111111b
-01001101b | 00111100b = 01111101b
-01001101b | 00111101b = 01111101b
-01001101b | 00111110b = 01111111b
-01001101b | 00111111b = 01111111b
-01001101b | 01000000b = 01001101b
-01001101b | 01000001b = 01001101b
-01001101b | 01000010b = 01001111b
-01001101b | 01000011b = 01001111b
-01001101b | 01000100b = 01001101b
-01001101b | 01000101b = 01001101b
-01001101b | 01000110b = 01001111b
-01001101b | 01000111b = 01001111b
-01001101b | 01001000b = 01001101b
-01001101b | 01001001b = 01001101b
-01001101b | 01001010b = 01001111b
-01001101b | 01001011b = 01001111b
-01001101b | 01001100b = 01001101b
-01001101b | 01001101b = 01001101b
-01001101b | 01001110b = 01001111b
-01001101b | 01001111b = 01001111b
-01001101b | 01010000b = 01011101b
-01001101b | 01010001b = 01011101b
-01001101b | 01010010b = 01011111b
-01001101b | 01010011b = 01011111b
-01001101b | 01010100b = 01011101b
-01001101b | 01010101b = 01011101b
-01001101b | 01010110b = 01011111b
-01001101b | 01010111b = 01011111b
-01001101b | 01011000b = 01011101b
-01001101b | 01011001b = 01011101b
-01001101b | 01011010b = 01011111b
-01001101b | 01011011b = 01011111b
-01001101b | 01011100b = 01011101b
-01001101b | 01011101b = 01011101b
-01001101b | 01011110b = 01011111b
-01001101b | 01011111b = 01011111b
-01001101b | 01100000b = 01101101b
-01001101b | 01100001b = 01101101b
-01001101b | 01100010b = 01101111b
-01001101b | 01100011b = 01101111b
-01001101b | 01100100b = 01101101b
-01001101b | 01100101b = 01101101b
-01001101b | 01100110b = 01101111b
-01001101b | 01100111b = 01101111b
-01001101b | 01101000b = 01101101b
-01001101b | 01101001b = 01101101b
-01001101b | 01101010b = 01101111b
-01001101b | 01101011b = 01101111b
-01001101b | 01101100b = 01101101b
-01001101b | 01101101b = 01101101b
-01001101b | 01101110b = 01101111b
-01001101b | 01101111b = 01101111b
-01001101b | 01110000b = 01111101b
-01001101b | 01110001b = 01111101b
-01001101b | 01110010b = 01111111b
-01001101b | 01110011b = 01111111b
-01001101b | 01110100b = 01111101b
-01001101b | 01110101b = 01111101b
-01001101b | 01110110b = 01111111b
-01001101b | 01110111b = 01111111b
-01001101b | 01111000b = 01111101b
-01001101b | 01111001b = 01111101b
-01001101b | 01111010b = 01111111b
-01001101b | 01111011b = 01111111b
-01001101b | 01111100b = 01111101b
-01001101b | 01111101b = 01111101b
-01001101b | 01111110b = 01111111b
-01001110b | 10000000b = 11001110b
-01001110b | 10000001b = 11001111b
-01001110b | 10000010b = 11001110b
-01001110b | 10000011b = 11001111b
-01001110b | 10000100b = 11001110b
-01001110b | 10000101b = 11001111b
-01001110b | 10000110b = 11001110b
-01001110b | 10000111b = 11001111b
-01001110b | 10001000b = 11001110b
-01001110b | 10001001b = 11001111b
-01001110b | 10001010b = 11001110b
-01001110b | 10001011b = 11001111b
-01001110b | 10001100b = 11001110b
-01001110b | 10001101b = 11001111b
-01001110b | 10001110b = 11001110b
-01001110b | 10001111b = 11001111b
-01001110b | 10010000b = 11011110b
-01001110b | 10010001b = 11011111b
-01001110b | 10010010b = 11011110b
-01001110b | 10010011b = 11011111b
-01001110b | 10010100b = 11011110b
-01001110b | 10010101b = 11011111b
-01001110b | 10010110b = 11011110b
-01001110b | 10010111b = 11011111b
-01001110b | 10011000b = 11011110b
-01001110b | 10011001b = 11011111b
-01001110b | 10011010b = 11011110b
-01001110b | 10011011b = 11011111b
-01001110b | 10011100b = 11011110b
-01001110b | 10011101b = 11011111b
-01001110b | 10011110b = 11011110b
-01001110b | 10011111b = 11011111b
-01001110b | 10100000b = 11101110b
-01001110b | 10100001b = 11101111b
-01001110b | 10100010b = 11101110b
-01001110b | 10100011b = 11101111b
-01001110b | 10100100b = 11101110b
-01001110b | 10100101b = 11101111b
-01001110b | 10100110b = 11101110b
-01001110b | 10100111b = 11101111b
-01001110b | 10101000b = 11101110b
-01001110b | 10101001b = 11101111b
-01001110b | 10101010b = 11101110b
-01001110b | 10101011b = 11101111b
-01001110b | 10101100b = 11101110b
-01001110b | 10101101b = 11101111b
-01001110b | 10101110b = 11101110b
-01001110b | 10101111b = 11101111b
-01001110b | 10110000b = 11111110b
-01001110b | 10110001b = 11111111b
-01001110b | 10110010b = 11111110b
-01001110b | 10110011b = 11111111b
-01001110b | 10110100b = 11111110b
-01001110b | 10110101b = 11111111b
-01001110b | 10110110b = 11111110b
-01001110b | 10110111b = 11111111b
-01001110b | 10111000b = 11111110b
-01001110b | 10111001b = 11111111b
-01001110b | 10111010b = 11111110b
-01001110b | 10111011b = 11111111b
-01001110b | 10111100b = 11111110b
-01001110b | 10111101b = 11111111b
-01001110b | 10111110b = 11111110b
-01001110b | 10111111b = 11111111b
-01001110b | 11000000b = 11001110b
-01001110b | 11000001b = 11001111b
-01001110b | 11000010b = 11001110b
-01001110b | 11000011b = 11001111b
-01001110b | 11000100b = 11001110b
-01001110b | 11000101b = 11001111b
-01001110b | 11000110b = 11001110b
-01001110b | 11000111b = 11001111b
-01001110b | 11001000b = 11001110b
-01001110b | 11001001b = 11001111b
-01001110b | 11001010b = 11001110b
-01001110b | 11001011b = 11001111b
-01001110b | 11001100b = 11001110b
-01001110b | 11001101b = 11001111b
-01001110b | 11001110b = 11001110b
-01001110b | 11001111b = 11001111b
-01001110b | 11010000b = 11011110b
-01001110b | 11010001b = 11011111b
-01001110b | 11010010b = 11011110b
-01001110b | 11010011b = 11011111b
-01001110b | 11010100b = 11011110b
-01001110b | 11010101b = 11011111b
-01001110b | 11010110b = 11011110b
-01001110b | 11010111b = 11011111b
-01001110b | 11011000b = 11011110b
-01001110b | 11011001b = 11011111b
-01001110b | 11011010b = 11011110b
-01001110b | 11011011b = 11011111b
-01001110b | 11011100b = 11011110b
-01001110b | 11011101b = 11011111b
-01001110b | 11011110b = 11011110b
-01001110b | 11011111b = 11011111b
-01001110b | 11100000b = 11101110b
-01001110b | 11100001b = 11101111b
-01001110b | 11100010b = 11101110b
-01001110b | 11100011b = 11101111b
-01001110b | 11100100b = 11101110b
-01001110b | 11100101b = 11101111b
-01001110b | 11100110b = 11101110b
-01001110b | 11100111b = 11101111b
-01001110b | 11101000b = 11101110b
-01001110b | 11101001b = 11101111b
-01001110b | 11101010b = 11101110b
-01001110b | 11101011b = 11101111b
-01001110b | 11101100b = 11101110b
-01001110b | 11101101b = 11101111b
-01001110b | 11101110b = 11101110b
-01001110b | 11101111b = 11101111b
-01001110b | 11110000b = 11111110b
-01001110b | 11110001b = 11111111b
-01001110b | 11110010b = 11111110b
-01001110b | 11110011b = 11111111b
-01001110b | 11110100b = 11111110b
-01001110b | 11110101b = 11111111b
-01001110b | 11110110b = 11111110b
-01001110b | 11110111b = 11111111b
-01001110b | 11111000b = 11111110b
-01001110b | 11111001b = 11111111b
-01001110b | 11111010b = 11111110b
-01001110b | 11111011b = 11111111b
-01001110b | 11111100b = 11111110b
-01001110b | 11111101b = 11111111b
-01001110b | 11111110b = 11111110b
-01001110b | 11111111b = 11111111b
-01001110b | 00000000b = 01001110b
-01001110b | 00000001b = 01001111b
-01001110b | 00000010b = 01001110b
-01001110b | 00000011b = 01001111b
-01001110b | 00000100b = 01001110b
-01001110b | 00000101b = 01001111b
-01001110b | 00000110b = 01001110b
-01001110b | 00000111b = 01001111b
-01001110b | 00001000b = 01001110b
-01001110b | 00001001b = 01001111b
-01001110b | 00001010b = 01001110b
-01001110b | 00001011b = 01001111b
-01001110b | 00001100b = 01001110b
-01001110b | 00001101b = 01001111b
-01001110b | 00001110b = 01001110b
-01001110b | 00001111b = 01001111b
-01001110b | 00010000b = 01011110b
-01001110b | 00010001b = 01011111b
-01001110b | 00010010b = 01011110b
-01001110b | 00010011b = 01011111b
-01001110b | 00010100b = 01011110b
-01001110b | 00010101b = 01011111b
-01001110b | 00010110b = 01011110b
-01001110b | 00010111b = 01011111b
-01001110b | 00011000b = 01011110b
-01001110b | 00011001b = 01011111b
-01001110b | 00011010b = 01011110b
-01001110b | 00011011b = 01011111b
-01001110b | 00011100b = 01011110b
-01001110b | 00011101b = 01011111b
-01001110b | 00011110b = 01011110b
-01001110b | 00011111b = 01011111b
-01001110b | 00100000b = 01101110b
-01001110b | 00100001b = 01101111b
-01001110b | 00100010b = 01101110b
-01001110b | 00100011b = 01101111b
-01001110b | 00100100b = 01101110b
-01001110b | 00100101b = 01101111b
-01001110b | 00100110b = 01101110b
-01001110b | 00100111b = 01101111b
-01001110b | 00101000b = 01101110b
-01001110b | 00101001b = 01101111b
-01001110b | 00101010b = 01101110b
-01001110b | 00101011b = 01101111b
-01001110b | 00101100b = 01101110b
-01001110b | 00101101b = 01101111b
-01001110b | 00101110b = 01101110b
-01001110b | 00101111b = 01101111b
-01001110b | 00110000b = 01111110b
-01001110b | 00110001b = 01111111b
-01001110b | 00110010b = 01111110b
-01001110b | 00110011b = 01111111b
-01001110b | 00110100b = 01111110b
-01001110b | 00110101b = 01111111b
-01001110b | 00110110b = 01111110b
-01001110b | 00110111b = 01111111b
-01001110b | 00111000b = 01111110b
-01001110b | 00111001b = 01111111b
-01001110b | 00111010b = 01111110b
-01001110b | 00111011b = 01111111b
-01001110b | 00111100b = 01111110b
-01001110b | 00111101b = 01111111b
-01001110b | 00111110b = 01111110b
-01001110b | 00111111b = 01111111b
-01001110b | 01000000b = 01001110b
-01001110b | 01000001b = 01001111b
-01001110b | 01000010b = 01001110b
-01001110b | 01000011b = 01001111b
-01001110b | 01000100b = 01001110b
-01001110b | 01000101b = 01001111b
-01001110b | 01000110b = 01001110b
-01001110b | 01000111b = 01001111b
-01001110b | 01001000b = 01001110b
-01001110b | 01001001b = 01001111b
-01001110b | 01001010b = 01001110b
-01001110b | 01001011b = 01001111b
-01001110b | 01001100b = 01001110b
-01001110b | 01001101b = 01001111b
-01001110b | 01001110b = 01001110b
-01001110b | 01001111b = 01001111b
-01001110b | 01010000b = 01011110b
-01001110b | 01010001b = 01011111b
-01001110b | 01010010b = 01011110b
-01001110b | 01010011b = 01011111b
-01001110b | 01010100b = 01011110b
-01001110b | 01010101b = 01011111b
-01001110b | 01010110b = 01011110b
-01001110b | 01010111b = 01011111b
-01001110b | 01011000b = 01011110b
-01001110b | 01011001b = 01011111b
-01001110b | 01011010b = 01011110b
-01001110b | 01011011b = 01011111b
-01001110b | 01011100b = 01011110b
-01001110b | 01011101b = 01011111b
-01001110b | 01011110b = 01011110b
-01001110b | 01011111b = 01011111b
-01001110b | 01100000b = 01101110b
-01001110b | 01100001b = 01101111b
-01001110b | 01100010b = 01101110b
-01001110b | 01100011b = 01101111b
-01001110b | 01100100b = 01101110b
-01001110b | 01100101b = 01101111b
-01001110b | 01100110b = 01101110b
-01001110b | 01100111b = 01101111b
-01001110b | 01101000b = 01101110b
-01001110b | 01101001b = 01101111b
-01001110b | 01101010b = 01101110b
-01001110b | 01101011b = 01101111b
-01001110b | 01101100b = 01101110b
-01001110b | 01101101b = 01101111b
-01001110b | 01101110b = 01101110b
-01001110b | 01101111b = 01101111b
-01001110b | 01110000b = 01111110b
-01001110b | 01110001b = 01111111b
-01001110b | 01110010b = 01111110b
-01001110b | 01110011b = 01111111b
-01001110b | 01110100b = 01111110b
-01001110b | 01110101b = 01111111b
-01001110b | 01110110b = 01111110b
-01001110b | 01110111b = 01111111b
-01001110b | 01111000b = 01111110b
-01001110b | 01111001b = 01111111b
-01001110b | 01111010b = 01111110b
-01001110b | 01111011b = 01111111b
-01001110b | 01111100b = 01111110b
-01001110b | 01111101b = 01111111b
-01001110b | 01111110b = 01111110b
-01001111b | 10000000b = 11001111b
-01001111b | 10000001b = 11001111b
-01001111b | 10000010b = 11001111b
-01001111b | 10000011b = 11001111b
-01001111b | 10000100b = 11001111b
-01001111b | 10000101b = 11001111b
-01001111b | 10000110b = 11001111b
-01001111b | 10000111b = 11001111b
-01001111b | 10001000b = 11001111b
-01001111b | 10001001b = 11001111b
-01001111b | 10001010b = 11001111b
-01001111b | 10001011b = 11001111b
-01001111b | 10001100b = 11001111b
-01001111b | 10001101b = 11001111b
-01001111b | 10001110b = 11001111b
-01001111b | 10001111b = 11001111b
-01001111b | 10010000b = 11011111b
-01001111b | 10010001b = 11011111b
-01001111b | 10010010b = 11011111b
-01001111b | 10010011b = 11011111b
-01001111b | 10010100b = 11011111b
-01001111b | 10010101b = 11011111b
-01001111b | 10010110b = 11011111b
-01001111b | 10010111b = 11011111b
-01001111b | 10011000b = 11011111b
-01001111b | 10011001b = 11011111b
-01001111b | 10011010b = 11011111b
-01001111b | 10011011b = 11011111b
-01001111b | 10011100b = 11011111b
-01001111b | 10011101b = 11011111b
-01001111b | 10011110b = 11011111b
-01001111b | 10011111b = 11011111b
-01001111b | 10100000b = 11101111b
-01001111b | 10100001b = 11101111b
-01001111b | 10100010b = 11101111b
-01001111b | 10100011b = 11101111b
-01001111b | 10100100b = 11101111b
-01001111b | 10100101b = 11101111b
-01001111b | 10100110b = 11101111b
-01001111b | 10100111b = 11101111b
-01001111b | 10101000b = 11101111b
-01001111b | 10101001b = 11101111b
-01001111b | 10101010b = 11101111b
-01001111b | 10101011b = 11101111b
-01001111b | 10101100b = 11101111b
-01001111b | 10101101b = 11101111b
-01001111b | 10101110b = 11101111b
-01001111b | 10101111b = 11101111b
-01001111b | 10110000b = 11111111b
-01001111b | 10110001b = 11111111b
-01001111b | 10110010b = 11111111b
-01001111b | 10110011b = 11111111b
-01001111b | 10110100b = 11111111b
-01001111b | 10110101b = 11111111b
-01001111b | 10110110b = 11111111b
-01001111b | 10110111b = 11111111b
-01001111b | 10111000b = 11111111b
-01001111b | 10111001b = 11111111b
-01001111b | 10111010b = 11111111b
-01001111b | 10111011b = 11111111b
-01001111b | 10111100b = 11111111b
-01001111b | 10111101b = 11111111b
-01001111b | 10111110b = 11111111b
-01001111b | 10111111b = 11111111b
-01001111b | 11000000b = 11001111b
-01001111b | 11000001b = 11001111b
-01001111b | 11000010b = 11001111b
-01001111b | 11000011b = 11001111b
-01001111b | 11000100b = 11001111b
-01001111b | 11000101b = 11001111b
-01001111b | 11000110b = 11001111b
-01001111b | 11000111b = 11001111b
-01001111b | 11001000b = 11001111b
-01001111b | 11001001b = 11001111b
-01001111b | 11001010b = 11001111b
-01001111b | 11001011b = 11001111b
-01001111b | 11001100b = 11001111b
-01001111b | 11001101b = 11001111b
-01001111b | 11001110b = 11001111b
-01001111b | 11001111b = 11001111b
-01001111b | 11010000b = 11011111b
-01001111b | 11010001b = 11011111b
-01001111b | 11010010b = 11011111b
-01001111b | 11010011b = 11011111b
-01001111b | 11010100b = 11011111b
-01001111b | 11010101b = 11011111b
-01001111b | 11010110b = 11011111b
-01001111b | 11010111b = 11011111b
-01001111b | 11011000b = 11011111b
-01001111b | 11011001b = 11011111b
-01001111b | 11011010b = 11011111b
-01001111b | 11011011b = 11011111b
-01001111b | 11011100b = 11011111b
-01001111b | 11011101b = 11011111b
-01001111b | 11011110b = 11011111b
-01001111b | 11011111b = 11011111b
-01001111b | 11100000b = 11101111b
-01001111b | 11100001b = 11101111b
-01001111b | 11100010b = 11101111b
-01001111b | 11100011b = 11101111b
-01001111b | 11100100b = 11101111b
-01001111b | 11100101b = 11101111b
-01001111b | 11100110b = 11101111b
-01001111b | 11100111b = 11101111b
-01001111b | 11101000b = 11101111b
-01001111b | 11101001b = 11101111b
-01001111b | 11101010b = 11101111b
-01001111b | 11101011b = 11101111b
-01001111b | 11101100b = 11101111b
-01001111b | 11101101b = 11101111b
-01001111b | 11101110b = 11101111b
-01001111b | 11101111b = 11101111b
-01001111b | 11110000b = 11111111b
-01001111b | 11110001b = 11111111b
-01001111b | 11110010b = 11111111b
-01001111b | 11110011b = 11111111b
-01001111b | 11110100b = 11111111b
-01001111b | 11110101b = 11111111b
-01001111b | 11110110b = 11111111b
-01001111b | 11110111b = 11111111b
-01001111b | 11111000b = 11111111b
-01001111b | 11111001b = 11111111b
-01001111b | 11111010b = 11111111b
-01001111b | 11111011b = 11111111b
-01001111b | 11111100b = 11111111b
-01001111b | 11111101b = 11111111b
-01001111b | 11111110b = 11111111b
-01001111b | 11111111b = 11111111b
-01001111b | 00000000b = 01001111b
-01001111b | 00000001b = 01001111b
-01001111b | 00000010b = 01001111b
-01001111b | 00000011b = 01001111b
-01001111b | 00000100b = 01001111b
-01001111b | 00000101b = 01001111b
-01001111b | 00000110b = 01001111b
-01001111b | 00000111b = 01001111b
-01001111b | 00001000b = 01001111b
-01001111b | 00001001b = 01001111b
-01001111b | 00001010b = 01001111b
-01001111b | 00001011b = 01001111b
-01001111b | 00001100b = 01001111b
-01001111b | 00001101b = 01001111b
-01001111b | 00001110b = 01001111b
-01001111b | 00001111b = 01001111b
-01001111b | 00010000b = 01011111b
-01001111b | 00010001b = 01011111b
-01001111b | 00010010b = 01011111b
-01001111b | 00010011b = 01011111b
-01001111b | 00010100b = 01011111b
-01001111b | 00010101b = 01011111b
-01001111b | 00010110b = 01011111b
-01001111b | 00010111b = 01011111b
-01001111b | 00011000b = 01011111b
-01001111b | 00011001b = 01011111b
-01001111b | 00011010b = 01011111b
-01001111b | 00011011b = 01011111b
-01001111b | 00011100b = 01011111b
-01001111b | 00011101b = 01011111b
-01001111b | 00011110b = 01011111b
-01001111b | 00011111b = 01011111b
-01001111b | 00100000b = 01101111b
-01001111b | 00100001b = 01101111b
-01001111b | 00100010b = 01101111b
-01001111b | 00100011b = 01101111b
-01001111b | 00100100b = 01101111b
-01001111b | 00100101b = 01101111b
-01001111b | 00100110b = 01101111b
-01001111b | 00100111b = 01101111b
-01001111b | 00101000b = 01101111b
-01001111b | 00101001b = 01101111b
-01001111b | 00101010b = 01101111b
-01001111b | 00101011b = 01101111b
-01001111b | 00101100b = 01101111b
-01001111b | 00101101b = 01101111b
-01001111b | 00101110b = 01101111b
-01001111b | 00101111b = 01101111b
-01001111b | 00110000b = 01111111b
-01001111b | 00110001b = 01111111b
-01001111b | 00110010b = 01111111b
-01001111b | 00110011b = 01111111b
-01001111b | 00110100b = 01111111b
-01001111b | 00110101b = 01111111b
-01001111b | 00110110b = 01111111b
-01001111b | 00110111b = 01111111b
-01001111b | 00111000b = 01111111b
-01001111b | 00111001b = 01111111b
-01001111b | 00111010b = 01111111b
-01001111b | 00111011b = 01111111b
-01001111b | 00111100b = 01111111b
-01001111b | 00111101b = 01111111b
-01001111b | 00111110b = 01111111b
-01001111b | 00111111b = 01111111b
-01001111b | 01000000b = 01001111b
-01001111b | 01000001b = 01001111b
-01001111b | 01000010b = 01001111b
-01001111b | 01000011b = 01001111b
-01001111b | 01000100b = 01001111b
-01001111b | 01000101b = 01001111b
-01001111b | 01000110b = 01001111b
-01001111b | 01000111b = 01001111b
-01001111b | 01001000b = 01001111b
-01001111b | 01001001b = 01001111b
-01001111b | 01001010b = 01001111b
-01001111b | 01001011b = 01001111b
-01001111b | 01001100b = 01001111b
-01001111b | 01001101b = 01001111b
-01001111b | 01001110b = 01001111b
-01001111b | 01001111b = 01001111b
-01001111b | 01010000b = 01011111b
-01001111b | 01010001b = 01011111b
-01001111b | 01010010b = 01011111b
-01001111b | 01010011b = 01011111b
-01001111b | 01010100b = 01011111b
-01001111b | 01010101b = 01011111b
-01001111b | 01010110b = 01011111b
-01001111b | 01010111b = 01011111b
-01001111b | 01011000b = 01011111b
-01001111b | 01011001b = 01011111b
-01001111b | 01011010b = 01011111b
-01001111b | 01011011b = 01011111b
-01001111b | 01011100b = 01011111b
-01001111b | 01011101b = 01011111b
-01001111b | 01011110b = 01011111b
-01001111b | 01011111b = 01011111b
-01001111b | 01100000b = 01101111b
-01001111b | 01100001b = 01101111b
-01001111b | 01100010b = 01101111b
-01001111b | 01100011b = 01101111b
-01001111b | 01100100b = 01101111b
-01001111b | 01100101b = 01101111b
-01001111b | 01100110b = 01101111b
-01001111b | 01100111b = 01101111b
-01001111b | 01101000b = 01101111b
-01001111b | 01101001b = 01101111b
-01001111b | 01101010b = 01101111b
-01001111b | 01101011b = 01101111b
-01001111b | 01101100b = 01101111b
-01001111b | 01101101b = 01101111b
-01001111b | 01101110b = 01101111b
-01001111b | 01101111b = 01101111b
-01001111b | 01110000b = 01111111b
-01001111b | 01110001b = 01111111b
-01001111b | 01110010b = 01111111b
-01001111b | 01110011b = 01111111b
-01001111b | 01110100b = 01111111b
-01001111b | 01110101b = 01111111b
-01001111b | 01110110b = 01111111b
-01001111b | 01110111b = 01111111b
-01001111b | 01111000b = 01111111b
-01001111b | 01111001b = 01111111b
-01001111b | 01111010b = 01111111b
-01001111b | 01111011b = 01111111b
-01001111b | 01111100b = 01111111b
-01001111b | 01111101b = 01111111b
-01001111b | 01111110b = 01111111b
-01010000b | 10000000b = 11010000b
-01010000b | 10000001b = 11010001b
-01010000b | 10000010b = 11010010b
-01010000b | 10000011b = 11010011b
-01010000b | 10000100b = 11010100b
-01010000b | 10000101b = 11010101b
-01010000b | 10000110b = 11010110b
-01010000b | 10000111b = 11010111b
-01010000b | 10001000b = 11011000b
-01010000b | 10001001b = 11011001b
-01010000b | 10001010b = 11011010b
-01010000b | 10001011b = 11011011b
-01010000b | 10001100b = 11011100b
-01010000b | 10001101b = 11011101b
-01010000b | 10001110b = 11011110b
-01010000b | 10001111b = 11011111b
-01010000b | 10010000b = 11010000b
-01010000b | 10010001b = 11010001b
-01010000b | 10010010b = 11010010b
-01010000b | 10010011b = 11010011b
-01010000b | 10010100b = 11010100b
-01010000b | 10010101b = 11010101b
-01010000b | 10010110b = 11010110b
-01010000b | 10010111b = 11010111b
-01010000b | 10011000b = 11011000b
-01010000b | 10011001b = 11011001b
-01010000b | 10011010b = 11011010b
-01010000b | 10011011b = 11011011b
-01010000b | 10011100b = 11011100b
-01010000b | 10011101b = 11011101b
-01010000b | 10011110b = 11011110b
-01010000b | 10011111b = 11011111b
-01010000b | 10100000b = 11110000b
-01010000b | 10100001b = 11110001b
-01010000b | 10100010b = 11110010b
-01010000b | 10100011b = 11110011b
-01010000b | 10100100b = 11110100b
-01010000b | 10100101b = 11110101b
-01010000b | 10100110b = 11110110b
-01010000b | 10100111b = 11110111b
-01010000b | 10101000b = 11111000b
-01010000b | 10101001b = 11111001b
-01010000b | 10101010b = 11111010b
-01010000b | 10101011b = 11111011b
-01010000b | 10101100b = 11111100b
-01010000b | 10101101b = 11111101b
-01010000b | 10101110b = 11111110b
-01010000b | 10101111b = 11111111b
-01010000b | 10110000b = 11110000b
-01010000b | 10110001b = 11110001b
-01010000b | 10110010b = 11110010b
-01010000b | 10110011b = 11110011b
-01010000b | 10110100b = 11110100b
-01010000b | 10110101b = 11110101b
-01010000b | 10110110b = 11110110b
-01010000b | 10110111b = 11110111b
-01010000b | 10111000b = 11111000b
-01010000b | 10111001b = 11111001b
-01010000b | 10111010b = 11111010b
-01010000b | 10111011b = 11111011b
-01010000b | 10111100b = 11111100b
-01010000b | 10111101b = 11111101b
-01010000b | 10111110b = 11111110b
-01010000b | 10111111b = 11111111b
-01010000b | 11000000b = 11010000b
-01010000b | 11000001b = 11010001b
-01010000b | 11000010b = 11010010b
-01010000b | 11000011b = 11010011b
-01010000b | 11000100b = 11010100b
-01010000b | 11000101b = 11010101b
-01010000b | 11000110b = 11010110b
-01010000b | 11000111b = 11010111b
-01010000b | 11001000b = 11011000b
-01010000b | 11001001b = 11011001b
-01010000b | 11001010b = 11011010b
-01010000b | 11001011b = 11011011b
-01010000b | 11001100b = 11011100b
-01010000b | 11001101b = 11011101b
-01010000b | 11001110b = 11011110b
-01010000b | 11001111b = 11011111b
-01010000b | 11010000b = 11010000b
-01010000b | 11010001b = 11010001b
-01010000b | 11010010b = 11010010b
-01010000b | 11010011b = 11010011b
-01010000b | 11010100b = 11010100b
-01010000b | 11010101b = 11010101b
-01010000b | 11010110b = 11010110b
-01010000b | 11010111b = 11010111b
-01010000b | 11011000b = 11011000b
-01010000b | 11011001b = 11011001b
-01010000b | 11011010b = 11011010b
-01010000b | 11011011b = 11011011b
-01010000b | 11011100b = 11011100b
-01010000b | 11011101b = 11011101b
-01010000b | 11011110b = 11011110b
-01010000b | 11011111b = 11011111b
-01010000b | 11100000b = 11110000b
-01010000b | 11100001b = 11110001b
-01010000b | 11100010b = 11110010b
-01010000b | 11100011b = 11110011b
-01010000b | 11100100b = 11110100b
-01010000b | 11100101b = 11110101b
-01010000b | 11100110b = 11110110b
-01010000b | 11100111b = 11110111b
-01010000b | 11101000b = 11111000b
-01010000b | 11101001b = 11111001b
-01010000b | 11101010b = 11111010b
-01010000b | 11101011b = 11111011b
-01010000b | 11101100b = 11111100b
-01010000b | 11101101b = 11111101b
-01010000b | 11101110b = 11111110b
-01010000b | 11101111b = 11111111b
-01010000b | 11110000b = 11110000b
-01010000b | 11110001b = 11110001b
-01010000b | 11110010b = 11110010b
-01010000b | 11110011b = 11110011b
-01010000b | 11110100b = 11110100b
-01010000b | 11110101b = 11110101b
-01010000b | 11110110b = 11110110b
-01010000b | 11110111b = 11110111b
-01010000b | 11111000b = 11111000b
-01010000b | 11111001b = 11111001b
-01010000b | 11111010b = 11111010b
-01010000b | 11111011b = 11111011b
-01010000b | 11111100b = 11111100b
-01010000b | 11111101b = 11111101b
-01010000b | 11111110b = 11111110b
-01010000b | 11111111b = 11111111b
-01010000b | 00000000b = 01010000b
-01010000b | 00000001b = 01010001b
-01010000b | 00000010b = 01010010b
-01010000b | 00000011b = 01010011b
-01010000b | 00000100b = 01010100b
-01010000b | 00000101b = 01010101b
-01010000b | 00000110b = 01010110b
-01010000b | 00000111b = 01010111b
-01010000b | 00001000b = 01011000b
-01010000b | 00001001b = 01011001b
-01010000b | 00001010b = 01011010b
-01010000b | 00001011b = 01011011b
-01010000b | 00001100b = 01011100b
-01010000b | 00001101b = 01011101b
-01010000b | 00001110b = 01011110b
-01010000b | 00001111b = 01011111b
-01010000b | 00010000b = 01010000b
-01010000b | 00010001b = 01010001b
-01010000b | 00010010b = 01010010b
-01010000b | 00010011b = 01010011b
-01010000b | 00010100b = 01010100b
-01010000b | 00010101b = 01010101b
-01010000b | 00010110b = 01010110b
-01010000b | 00010111b = 01010111b
-01010000b | 00011000b = 01011000b
-01010000b | 00011001b = 01011001b
-01010000b | 00011010b = 01011010b
-01010000b | 00011011b = 01011011b
-01010000b | 00011100b = 01011100b
-01010000b | 00011101b = 01011101b
-01010000b | 00011110b = 01011110b
-01010000b | 00011111b = 01011111b
-01010000b | 00100000b = 01110000b
-01010000b | 00100001b = 01110001b
-01010000b | 00100010b = 01110010b
-01010000b | 00100011b = 01110011b
-01010000b | 00100100b = 01110100b
-01010000b | 00100101b = 01110101b
-01010000b | 00100110b = 01110110b
-01010000b | 00100111b = 01110111b
-01010000b | 00101000b = 01111000b
-01010000b | 00101001b = 01111001b
-01010000b | 00101010b = 01111010b
-01010000b | 00101011b = 01111011b
-01010000b | 00101100b = 01111100b
-01010000b | 00101101b = 01111101b
-01010000b | 00101110b = 01111110b
-01010000b | 00101111b = 01111111b
-01010000b | 00110000b = 01110000b
-01010000b | 00110001b = 01110001b
-01010000b | 00110010b = 01110010b
-01010000b | 00110011b = 01110011b
-01010000b | 00110100b = 01110100b
-01010000b | 00110101b = 01110101b
-01010000b | 00110110b = 01110110b
-01010000b | 00110111b = 01110111b
-01010000b | 00111000b = 01111000b
-01010000b | 00111001b = 01111001b
-01010000b | 00111010b = 01111010b
-01010000b | 00111011b = 01111011b
-01010000b | 00111100b = 01111100b
-01010000b | 00111101b = 01111101b
-01010000b | 00111110b = 01111110b
-01010000b | 00111111b = 01111111b
-01010000b | 01000000b = 01010000b
-01010000b | 01000001b = 01010001b
-01010000b | 01000010b = 01010010b
-01010000b | 01000011b = 01010011b
-01010000b | 01000100b = 01010100b
-01010000b | 01000101b = 01010101b
-01010000b | 01000110b = 01010110b
-01010000b | 01000111b = 01010111b
-01010000b | 01001000b = 01011000b
-01010000b | 01001001b = 01011001b
-01010000b | 01001010b = 01011010b
-01010000b | 01001011b = 01011011b
-01010000b | 01001100b = 01011100b
-01010000b | 01001101b = 01011101b
-01010000b | 01001110b = 01011110b
-01010000b | 01001111b = 01011111b
-01010000b | 01010000b = 01010000b
-01010000b | 01010001b = 01010001b
-01010000b | 01010010b = 01010010b
-01010000b | 01010011b = 01010011b
-01010000b | 01010100b = 01010100b
-01010000b | 01010101b = 01010101b
-01010000b | 01010110b = 01010110b
-01010000b | 01010111b = 01010111b
-01010000b | 01011000b = 01011000b
-01010000b | 01011001b = 01011001b
-01010000b | 01011010b = 01011010b
-01010000b | 01011011b = 01011011b
-01010000b | 01011100b = 01011100b
-01010000b | 01011101b = 01011101b
-01010000b | 01011110b = 01011110b
-01010000b | 01011111b = 01011111b
-01010000b | 01100000b = 01110000b
-01010000b | 01100001b = 01110001b
-01010000b | 01100010b = 01110010b
-01010000b | 01100011b = 01110011b
-01010000b | 01100100b = 01110100b
-01010000b | 01100101b = 01110101b
-01010000b | 01100110b = 01110110b
-01010000b | 01100111b = 01110111b
-01010000b | 01101000b = 01111000b
-01010000b | 01101001b = 01111001b
-01010000b | 01101010b = 01111010b
-01010000b | 01101011b = 01111011b
-01010000b | 01101100b = 01111100b
-01010000b | 01101101b = 01111101b
-01010000b | 01101110b = 01111110b
-01010000b | 01101111b = 01111111b
-01010000b | 01110000b = 01110000b
-01010000b | 01110001b = 01110001b
-01010000b | 01110010b = 01110010b
-01010000b | 01110011b = 01110011b
-01010000b | 01110100b = 01110100b
-01010000b | 01110101b = 01110101b
-01010000b | 01110110b = 01110110b
-01010000b | 01110111b = 01110111b
-01010000b | 01111000b = 01111000b
-01010000b | 01111001b = 01111001b
-01010000b | 01111010b = 01111010b
-01010000b | 01111011b = 01111011b
-01010000b | 01111100b = 01111100b
-01010000b | 01111101b = 01111101b
-01010000b | 01111110b = 01111110b
-01010001b | 10000000b = 11010001b
-01010001b | 10000001b = 11010001b
-01010001b | 10000010b = 11010011b
-01010001b | 10000011b = 11010011b
-01010001b | 10000100b = 11010101b
-01010001b | 10000101b = 11010101b
-01010001b | 10000110b = 11010111b
-01010001b | 10000111b = 11010111b
-01010001b | 10001000b = 11011001b
-01010001b | 10001001b = 11011001b
-01010001b | 10001010b = 11011011b
-01010001b | 10001011b = 11011011b
-01010001b | 10001100b = 11011101b
-01010001b | 10001101b = 11011101b
-01010001b | 10001110b = 11011111b
-01010001b | 10001111b = 11011111b
-01010001b | 10010000b = 11010001b
-01010001b | 10010001b = 11010001b
-01010001b | 10010010b = 11010011b
-01010001b | 10010011b = 11010011b
-01010001b | 10010100b = 11010101b
-01010001b | 10010101b = 11010101b
-01010001b | 10010110b = 11010111b
-01010001b | 10010111b = 11010111b
-01010001b | 10011000b = 11011001b
-01010001b | 10011001b = 11011001b
-01010001b | 10011010b = 11011011b
-01010001b | 10011011b = 11011011b
-01010001b | 10011100b = 11011101b
-01010001b | 10011101b = 11011101b
-01010001b | 10011110b = 11011111b
-01010001b | 10011111b = 11011111b
-01010001b | 10100000b = 11110001b
-01010001b | 10100001b = 11110001b
-01010001b | 10100010b = 11110011b
-01010001b | 10100011b = 11110011b
-01010001b | 10100100b = 11110101b
-01010001b | 10100101b = 11110101b
-01010001b | 10100110b = 11110111b
-01010001b | 10100111b = 11110111b
-01010001b | 10101000b = 11111001b
-01010001b | 10101001b = 11111001b
-01010001b | 10101010b = 11111011b
-01010001b | 10101011b = 11111011b
-01010001b | 10101100b = 11111101b
-01010001b | 10101101b = 11111101b
-01010001b | 10101110b = 11111111b
-01010001b | 10101111b = 11111111b
-01010001b | 10110000b = 11110001b
-01010001b | 10110001b = 11110001b
-01010001b | 10110010b = 11110011b
-01010001b | 10110011b = 11110011b
-01010001b | 10110100b = 11110101b
-01010001b | 10110101b = 11110101b
-01010001b | 10110110b = 11110111b
-01010001b | 10110111b = 11110111b
-01010001b | 10111000b = 11111001b
-01010001b | 10111001b = 11111001b
-01010001b | 10111010b = 11111011b
-01010001b | 10111011b = 11111011b
-01010001b | 10111100b = 11111101b
-01010001b | 10111101b = 11111101b
-01010001b | 10111110b = 11111111b
-01010001b | 10111111b = 11111111b
-01010001b | 11000000b = 11010001b
-01010001b | 11000001b = 11010001b
-01010001b | 11000010b = 11010011b
-01010001b | 11000011b = 11010011b
-01010001b | 11000100b = 11010101b
-01010001b | 11000101b = 11010101b
-01010001b | 11000110b = 11010111b
-01010001b | 11000111b = 11010111b
-01010001b | 11001000b = 11011001b
-01010001b | 11001001b = 11011001b
-01010001b | 11001010b = 11011011b
-01010001b | 11001011b = 11011011b
-01010001b | 11001100b = 11011101b
-01010001b | 11001101b = 11011101b
-01010001b | 11001110b = 11011111b
-01010001b | 11001111b = 11011111b
-01010001b | 11010000b = 11010001b
-01010001b | 11010001b = 11010001b
-01010001b | 11010010b = 11010011b
-01010001b | 11010011b = 11010011b
-01010001b | 11010100b = 11010101b
-01010001b | 11010101b = 11010101b
-01010001b | 11010110b = 11010111b
-01010001b | 11010111b = 11010111b
-01010001b | 11011000b = 11011001b
-01010001b | 11011001b = 11011001b
-01010001b | 11011010b = 11011011b
-01010001b | 11011011b = 11011011b
-01010001b | 11011100b = 11011101b
-01010001b | 11011101b = 11011101b
-01010001b | 11011110b = 11011111b
-01010001b | 11011111b = 11011111b
-01010001b | 11100000b = 11110001b
-01010001b | 11100001b = 11110001b
-01010001b | 11100010b = 11110011b
-01010001b | 11100011b = 11110011b
-01010001b | 11100100b = 11110101b
-01010001b | 11100101b = 11110101b
-01010001b | 11100110b = 11110111b
-01010001b | 11100111b = 11110111b
-01010001b | 11101000b = 11111001b
-01010001b | 11101001b = 11111001b
-01010001b | 11101010b = 11111011b
-01010001b | 11101011b = 11111011b
-01010001b | 11101100b = 11111101b
-01010001b | 11101101b = 11111101b
-01010001b | 11101110b = 11111111b
-01010001b | 11101111b = 11111111b
-01010001b | 11110000b = 11110001b
-01010001b | 11110001b = 11110001b
-01010001b | 11110010b = 11110011b
-01010001b | 11110011b = 11110011b
-01010001b | 11110100b = 11110101b
-01010001b | 11110101b = 11110101b
-01010001b | 11110110b = 11110111b
-01010001b | 11110111b = 11110111b
-01010001b | 11111000b = 11111001b
-01010001b | 11111001b = 11111001b
-01010001b | 11111010b = 11111011b
-01010001b | 11111011b = 11111011b
-01010001b | 11111100b = 11111101b
-01010001b | 11111101b = 11111101b
-01010001b | 11111110b = 11111111b
-01010001b | 11111111b = 11111111b
-01010001b | 00000000b = 01010001b
-01010001b | 00000001b = 01010001b
-01010001b | 00000010b = 01010011b
-01010001b | 00000011b = 01010011b
-01010001b | 00000100b = 01010101b
-01010001b | 00000101b = 01010101b
-01010001b | 00000110b = 01010111b
-01010001b | 00000111b = 01010111b
-01010001b | 00001000b = 01011001b
-01010001b | 00001001b = 01011001b
-01010001b | 00001010b = 01011011b
-01010001b | 00001011b = 01011011b
-01010001b | 00001100b = 01011101b
-01010001b | 00001101b = 01011101b
-01010001b | 00001110b = 01011111b
-01010001b | 00001111b = 01011111b
-01010001b | 00010000b = 01010001b
-01010001b | 00010001b = 01010001b
-01010001b | 00010010b = 01010011b
-01010001b | 00010011b = 01010011b
-01010001b | 00010100b = 01010101b
-01010001b | 00010101b = 01010101b
-01010001b | 00010110b = 01010111b
-01010001b | 00010111b = 01010111b
-01010001b | 00011000b = 01011001b
-01010001b | 00011001b = 01011001b
-01010001b | 00011010b = 01011011b
-01010001b | 00011011b = 01011011b
-01010001b | 00011100b = 01011101b
-01010001b | 00011101b = 01011101b
-01010001b | 00011110b = 01011111b
-01010001b | 00011111b = 01011111b
-01010001b | 00100000b = 01110001b
-01010001b | 00100001b = 01110001b
-01010001b | 00100010b = 01110011b
-01010001b | 00100011b = 01110011b
-01010001b | 00100100b = 01110101b
-01010001b | 00100101b = 01110101b
-01010001b | 00100110b = 01110111b
-01010001b | 00100111b = 01110111b
-01010001b | 00101000b = 01111001b
-01010001b | 00101001b = 01111001b
-01010001b | 00101010b = 01111011b
-01010001b | 00101011b = 01111011b
-01010001b | 00101100b = 01111101b
-01010001b | 00101101b = 01111101b
-01010001b | 00101110b = 01111111b
-01010001b | 00101111b = 01111111b
-01010001b | 00110000b = 01110001b
-01010001b | 00110001b = 01110001b
-01010001b | 00110010b = 01110011b
-01010001b | 00110011b = 01110011b
-01010001b | 00110100b = 01110101b
-01010001b | 00110101b = 01110101b
-01010001b | 00110110b = 01110111b
-01010001b | 00110111b = 01110111b
-01010001b | 00111000b = 01111001b
-01010001b | 00111001b = 01111001b
-01010001b | 00111010b = 01111011b
-01010001b | 00111011b = 01111011b
-01010001b | 00111100b = 01111101b
-01010001b | 00111101b = 01111101b
-01010001b | 00111110b = 01111111b
-01010001b | 00111111b = 01111111b
-01010001b | 01000000b = 01010001b
-01010001b | 01000001b = 01010001b
-01010001b | 01000010b = 01010011b
-01010001b | 01000011b = 01010011b
-01010001b | 01000100b = 01010101b
-01010001b | 01000101b = 01010101b
-01010001b | 01000110b = 01010111b
-01010001b | 01000111b = 01010111b
-01010001b | 01001000b = 01011001b
-01010001b | 01001001b = 01011001b
-01010001b | 01001010b = 01011011b
-01010001b | 01001011b = 01011011b
-01010001b | 01001100b = 01011101b
-01010001b | 01001101b = 01011101b
-01010001b | 01001110b = 01011111b
-01010001b | 01001111b = 01011111b
-01010001b | 01010000b = 01010001b
-01010001b | 01010001b = 01010001b
-01010001b | 01010010b = 01010011b
-01010001b | 01010011b = 01010011b
-01010001b | 01010100b = 01010101b
-01010001b | 01010101b = 01010101b
-01010001b | 01010110b = 01010111b
-01010001b | 01010111b = 01010111b
-01010001b | 01011000b = 01011001b
-01010001b | 01011001b = 01011001b
-01010001b | 01011010b = 01011011b
-01010001b | 01011011b = 01011011b
-01010001b | 01011100b = 01011101b
-01010001b | 01011101b = 01011101b
-01010001b | 01011110b = 01011111b
-01010001b | 01011111b = 01011111b
-01010001b | 01100000b = 01110001b
-01010001b | 01100001b = 01110001b
-01010001b | 01100010b = 01110011b
-01010001b | 01100011b = 01110011b
-01010001b | 01100100b = 01110101b
-01010001b | 01100101b = 01110101b
-01010001b | 01100110b = 01110111b
-01010001b | 01100111b = 01110111b
-01010001b | 01101000b = 01111001b
-01010001b | 01101001b = 01111001b
-01010001b | 01101010b = 01111011b
-01010001b | 01101011b = 01111011b
-01010001b | 01101100b = 01111101b
-01010001b | 01101101b = 01111101b
-01010001b | 01101110b = 01111111b
-01010001b | 01101111b = 01111111b
-01010001b | 01110000b = 01110001b
-01010001b | 01110001b = 01110001b
-01010001b | 01110010b = 01110011b
-01010001b | 01110011b = 01110011b
-01010001b | 01110100b = 01110101b
-01010001b | 01110101b = 01110101b
-01010001b | 01110110b = 01110111b
-01010001b | 01110111b = 01110111b
-01010001b | 01111000b = 01111001b
-01010001b | 01111001b = 01111001b
-01010001b | 01111010b = 01111011b
-01010001b | 01111011b = 01111011b
-01010001b | 01111100b = 01111101b
-01010001b | 01111101b = 01111101b
-01010001b | 01111110b = 01111111b
-01010010b | 10000000b = 11010010b
-01010010b | 10000001b = 11010011b
-01010010b | 10000010b = 11010010b
-01010010b | 10000011b = 11010011b
-01010010b | 10000100b = 11010110b
-01010010b | 10000101b = 11010111b
-01010010b | 10000110b = 11010110b
-01010010b | 10000111b = 11010111b
-01010010b | 10001000b = 11011010b
-01010010b | 10001001b = 11011011b
-01010010b | 10001010b = 11011010b
-01010010b | 10001011b = 11011011b
-01010010b | 10001100b = 11011110b
-01010010b | 10001101b = 11011111b
-01010010b | 10001110b = 11011110b
-01010010b | 10001111b = 11011111b
-01010010b | 10010000b = 11010010b
-01010010b | 10010001b = 11010011b
-01010010b | 10010010b = 11010010b
-01010010b | 10010011b = 11010011b
-01010010b | 10010100b = 11010110b
-01010010b | 10010101b = 11010111b
-01010010b | 10010110b = 11010110b
-01010010b | 10010111b = 11010111b
-01010010b | 10011000b = 11011010b
-01010010b | 10011001b = 11011011b
-01010010b | 10011010b = 11011010b
-01010010b | 10011011b = 11011011b
-01010010b | 10011100b = 11011110b
-01010010b | 10011101b = 11011111b
-01010010b | 10011110b = 11011110b
-01010010b | 10011111b = 11011111b
-01010010b | 10100000b = 11110010b
-01010010b | 10100001b = 11110011b
-01010010b | 10100010b = 11110010b
-01010010b | 10100011b = 11110011b
-01010010b | 10100100b = 11110110b
-01010010b | 10100101b = 11110111b
-01010010b | 10100110b = 11110110b
-01010010b | 10100111b = 11110111b
-01010010b | 10101000b = 11111010b
-01010010b | 10101001b = 11111011b
-01010010b | 10101010b = 11111010b
-01010010b | 10101011b = 11111011b
-01010010b | 10101100b = 11111110b
-01010010b | 10101101b = 11111111b
-01010010b | 10101110b = 11111110b
-01010010b | 10101111b = 11111111b
-01010010b | 10110000b = 11110010b
-01010010b | 10110001b = 11110011b
-01010010b | 10110010b = 11110010b
-01010010b | 10110011b = 11110011b
-01010010b | 10110100b = 11110110b
-01010010b | 10110101b = 11110111b
-01010010b | 10110110b = 11110110b
-01010010b | 10110111b = 11110111b
-01010010b | 10111000b = 11111010b
-01010010b | 10111001b = 11111011b
-01010010b | 10111010b = 11111010b
-01010010b | 10111011b = 11111011b
-01010010b | 10111100b = 11111110b
-01010010b | 10111101b = 11111111b
-01010010b | 10111110b = 11111110b
-01010010b | 10111111b = 11111111b
-01010010b | 11000000b = 11010010b
-01010010b | 11000001b = 11010011b
-01010010b | 11000010b = 11010010b
-01010010b | 11000011b = 11010011b
-01010010b | 11000100b = 11010110b
-01010010b | 11000101b = 11010111b
-01010010b | 11000110b = 11010110b
-01010010b | 11000111b = 11010111b
-01010010b | 11001000b = 11011010b
-01010010b | 11001001b = 11011011b
-01010010b | 11001010b = 11011010b
-01010010b | 11001011b = 11011011b
-01010010b | 11001100b = 11011110b
-01010010b | 11001101b = 11011111b
-01010010b | 11001110b = 11011110b
-01010010b | 11001111b = 11011111b
-01010010b | 11010000b = 11010010b
-01010010b | 11010001b = 11010011b
-01010010b | 11010010b = 11010010b
-01010010b | 11010011b = 11010011b
-01010010b | 11010100b = 11010110b
-01010010b | 11010101b = 11010111b
-01010010b | 11010110b = 11010110b
-01010010b | 11010111b = 11010111b
-01010010b | 11011000b = 11011010b
-01010010b | 11011001b = 11011011b
-01010010b | 11011010b = 11011010b
-01010010b | 11011011b = 11011011b
-01010010b | 11011100b = 11011110b
-01010010b | 11011101b = 11011111b
-01010010b | 11011110b = 11011110b
-01010010b | 11011111b = 11011111b
-01010010b | 11100000b = 11110010b
-01010010b | 11100001b = 11110011b
-01010010b | 11100010b = 11110010b
-01010010b | 11100011b = 11110011b
-01010010b | 11100100b = 11110110b
-01010010b | 11100101b = 11110111b
-01010010b | 11100110b = 11110110b
-01010010b | 11100111b = 11110111b
-01010010b | 11101000b = 11111010b
-01010010b | 11101001b = 11111011b
-01010010b | 11101010b = 11111010b
-01010010b | 11101011b = 11111011b
-01010010b | 11101100b = 11111110b
-01010010b | 11101101b = 11111111b
-01010010b | 11101110b = 11111110b
-01010010b | 11101111b = 11111111b
-01010010b | 11110000b = 11110010b
-01010010b | 11110001b = 11110011b
-01010010b | 11110010b = 11110010b
-01010010b | 11110011b = 11110011b
-01010010b | 11110100b = 11110110b
-01010010b | 11110101b = 11110111b
-01010010b | 11110110b = 11110110b
-01010010b | 11110111b = 11110111b
-01010010b | 11111000b = 11111010b
-01010010b | 11111001b = 11111011b
-01010010b | 11111010b = 11111010b
-01010010b | 11111011b = 11111011b
-01010010b | 11111100b = 11111110b
-01010010b | 11111101b = 11111111b
-01010010b | 11111110b = 11111110b
-01010010b | 11111111b = 11111111b
-01010010b | 00000000b = 01010010b
-01010010b | 00000001b = 01010011b
-01010010b | 00000010b = 01010010b
-01010010b | 00000011b = 01010011b
-01010010b | 00000100b = 01010110b
-01010010b | 00000101b = 01010111b
-01010010b | 00000110b = 01010110b
-01010010b | 00000111b = 01010111b
-01010010b | 00001000b = 01011010b
-01010010b | 00001001b = 01011011b
-01010010b | 00001010b = 01011010b
-01010010b | 00001011b = 01011011b
-01010010b | 00001100b = 01011110b
-01010010b | 00001101b = 01011111b
-01010010b | 00001110b = 01011110b
-01010010b | 00001111b = 01011111b
-01010010b | 00010000b = 01010010b
-01010010b | 00010001b = 01010011b
-01010010b | 00010010b = 01010010b
-01010010b | 00010011b = 01010011b
-01010010b | 00010100b = 01010110b
-01010010b | 00010101b = 01010111b
-01010010b | 00010110b = 01010110b
-01010010b | 00010111b = 01010111b
-01010010b | 00011000b = 01011010b
-01010010b | 00011001b = 01011011b
-01010010b | 00011010b = 01011010b
-01010010b | 00011011b = 01011011b
-01010010b | 00011100b = 01011110b
-01010010b | 00011101b = 01011111b
-01010010b | 00011110b = 01011110b
-01010010b | 00011111b = 01011111b
-01010010b | 00100000b = 01110010b
-01010010b | 00100001b = 01110011b
-01010010b | 00100010b = 01110010b
-01010010b | 00100011b = 01110011b
-01010010b | 00100100b = 01110110b
-01010010b | 00100101b = 01110111b
-01010010b | 00100110b = 01110110b
-01010010b | 00100111b = 01110111b
-01010010b | 00101000b = 01111010b
-01010010b | 00101001b = 01111011b
-01010010b | 00101010b = 01111010b
-01010010b | 00101011b = 01111011b
-01010010b | 00101100b = 01111110b
-01010010b | 00101101b = 01111111b
-01010010b | 00101110b = 01111110b
-01010010b | 00101111b = 01111111b
-01010010b | 00110000b = 01110010b
-01010010b | 00110001b = 01110011b
-01010010b | 00110010b = 01110010b
-01010010b | 00110011b = 01110011b
-01010010b | 00110100b = 01110110b
-01010010b | 00110101b = 01110111b
-01010010b | 00110110b = 01110110b
-01010010b | 00110111b = 01110111b
-01010010b | 00111000b = 01111010b
-01010010b | 00111001b = 01111011b
-01010010b | 00111010b = 01111010b
-01010010b | 00111011b = 01111011b
-01010010b | 00111100b = 01111110b
-01010010b | 00111101b = 01111111b
-01010010b | 00111110b = 01111110b
-01010010b | 00111111b = 01111111b
-01010010b | 01000000b = 01010010b
-01010010b | 01000001b = 01010011b
-01010010b | 01000010b = 01010010b
-01010010b | 01000011b = 01010011b
-01010010b | 01000100b = 01010110b
-01010010b | 01000101b = 01010111b
-01010010b | 01000110b = 01010110b
-01010010b | 01000111b = 01010111b
-01010010b | 01001000b = 01011010b
-01010010b | 01001001b = 01011011b
-01010010b | 01001010b = 01011010b
-01010010b | 01001011b = 01011011b
-01010010b | 01001100b = 01011110b
-01010010b | 01001101b = 01011111b
-01010010b | 01001110b = 01011110b
-01010010b | 01001111b = 01011111b
-01010010b | 01010000b = 01010010b
-01010010b | 01010001b = 01010011b
-01010010b | 01010010b = 01010010b
-01010010b | 01010011b = 01010011b
-01010010b | 01010100b = 01010110b
-01010010b | 01010101b = 01010111b
-01010010b | 01010110b = 01010110b
-01010010b | 01010111b = 01010111b
-01010010b | 01011000b = 01011010b
-01010010b | 01011001b = 01011011b
-01010010b | 01011010b = 01011010b
-01010010b | 01011011b = 01011011b
-01010010b | 01011100b = 01011110b
-01010010b | 01011101b = 01011111b
-01010010b | 01011110b = 01011110b
-01010010b | 01011111b = 01011111b
-01010010b | 01100000b = 01110010b
-01010010b | 01100001b = 01110011b
-01010010b | 01100010b = 01110010b
-01010010b | 01100011b = 01110011b
-01010010b | 01100100b = 01110110b
-01010010b | 01100101b = 01110111b
-01010010b | 01100110b = 01110110b
-01010010b | 01100111b = 01110111b
-01010010b | 01101000b = 01111010b
-01010010b | 01101001b = 01111011b
-01010010b | 01101010b = 01111010b
-01010010b | 01101011b = 01111011b
-01010010b | 01101100b = 01111110b
-01010010b | 01101101b = 01111111b
-01010010b | 01101110b = 01111110b
-01010010b | 01101111b = 01111111b
-01010010b | 01110000b = 01110010b
-01010010b | 01110001b = 01110011b
-01010010b | 01110010b = 01110010b
-01010010b | 01110011b = 01110011b
-01010010b | 01110100b = 01110110b
-01010010b | 01110101b = 01110111b
-01010010b | 01110110b = 01110110b
-01010010b | 01110111b = 01110111b
-01010010b | 01111000b = 01111010b
-01010010b | 01111001b = 01111011b
-01010010b | 01111010b = 01111010b
-01010010b | 01111011b = 01111011b
-01010010b | 01111100b = 01111110b
-01010010b | 01111101b = 01111111b
-01010010b | 01111110b = 01111110b
-01010011b | 10000000b = 11010011b
-01010011b | 10000001b = 11010011b
-01010011b | 10000010b = 11010011b
-01010011b | 10000011b = 11010011b
-01010011b | 10000100b = 11010111b
-01010011b | 10000101b = 11010111b
-01010011b | 10000110b = 11010111b
-01010011b | 10000111b = 11010111b
-01010011b | 10001000b = 11011011b
-01010011b | 10001001b = 11011011b
-01010011b | 10001010b = 11011011b
-01010011b | 10001011b = 11011011b
-01010011b | 10001100b = 11011111b
-01010011b | 10001101b = 11011111b
-01010011b | 10001110b = 11011111b
-01010011b | 10001111b = 11011111b
-01010011b | 10010000b = 11010011b
-01010011b | 10010001b = 11010011b
-01010011b | 10010010b = 11010011b
-01010011b | 10010011b = 11010011b
-01010011b | 10010100b = 11010111b
-01010011b | 10010101b = 11010111b
-01010011b | 10010110b = 11010111b
-01010011b | 10010111b = 11010111b
-01010011b | 10011000b = 11011011b
-01010011b | 10011001b = 11011011b
-01010011b | 10011010b = 11011011b
-01010011b | 10011011b = 11011011b
-01010011b | 10011100b = 11011111b
-01010011b | 10011101b = 11011111b
-01010011b | 10011110b = 11011111b
-01010011b | 10011111b = 11011111b
-01010011b | 10100000b = 11110011b
-01010011b | 10100001b = 11110011b
-01010011b | 10100010b = 11110011b
-01010011b | 10100011b = 11110011b
-01010011b | 10100100b = 11110111b
-01010011b | 10100101b = 11110111b
-01010011b | 10100110b = 11110111b
-01010011b | 10100111b = 11110111b
-01010011b | 10101000b = 11111011b
-01010011b | 10101001b = 11111011b
-01010011b | 10101010b = 11111011b
-01010011b | 10101011b = 11111011b
-01010011b | 10101100b = 11111111b
-01010011b | 10101101b = 11111111b
-01010011b | 10101110b = 11111111b
-01010011b | 10101111b = 11111111b
-01010011b | 10110000b = 11110011b
-01010011b | 10110001b = 11110011b
-01010011b | 10110010b = 11110011b
-01010011b | 10110011b = 11110011b
-01010011b | 10110100b = 11110111b
-01010011b | 10110101b = 11110111b
-01010011b | 10110110b = 11110111b
-01010011b | 10110111b = 11110111b
-01010011b | 10111000b = 11111011b
-01010011b | 10111001b = 11111011b
-01010011b | 10111010b = 11111011b
-01010011b | 10111011b = 11111011b
-01010011b | 10111100b = 11111111b
-01010011b | 10111101b = 11111111b
-01010011b | 10111110b = 11111111b
-01010011b | 10111111b = 11111111b
-01010011b | 11000000b = 11010011b
-01010011b | 11000001b = 11010011b
-01010011b | 11000010b = 11010011b
-01010011b | 11000011b = 11010011b
-01010011b | 11000100b = 11010111b
-01010011b | 11000101b = 11010111b
-01010011b | 11000110b = 11010111b
-01010011b | 11000111b = 11010111b
-01010011b | 11001000b = 11011011b
-01010011b | 11001001b = 11011011b
-01010011b | 11001010b = 11011011b
-01010011b | 11001011b = 11011011b
-01010011b | 11001100b = 11011111b
-01010011b | 11001101b = 11011111b
-01010011b | 11001110b = 11011111b
-01010011b | 11001111b = 11011111b
-01010011b | 11010000b = 11010011b
-01010011b | 11010001b = 11010011b
-01010011b | 11010010b = 11010011b
-01010011b | 11010011b = 11010011b
-01010011b | 11010100b = 11010111b
-01010011b | 11010101b = 11010111b
-01010011b | 11010110b = 11010111b
-01010011b | 11010111b = 11010111b
-01010011b | 11011000b = 11011011b
-01010011b | 11011001b = 11011011b
-01010011b | 11011010b = 11011011b
-01010011b | 11011011b = 11011011b
-01010011b | 11011100b = 11011111b
-01010011b | 11011101b = 11011111b
-01010011b | 11011110b = 11011111b
-01010011b | 11011111b = 11011111b
-01010011b | 11100000b = 11110011b
-01010011b | 11100001b = 11110011b
-01010011b | 11100010b = 11110011b
-01010011b | 11100011b = 11110011b
-01010011b | 11100100b = 11110111b
-01010011b | 11100101b = 11110111b
-01010011b | 11100110b = 11110111b
-01010011b | 11100111b = 11110111b
-01010011b | 11101000b = 11111011b
-01010011b | 11101001b = 11111011b
-01010011b | 11101010b = 11111011b
-01010011b | 11101011b = 11111011b
-01010011b | 11101100b = 11111111b
-01010011b | 11101101b = 11111111b
-01010011b | 11101110b = 11111111b
-01010011b | 11101111b = 11111111b
-01010011b | 11110000b = 11110011b
-01010011b | 11110001b = 11110011b
-01010011b | 11110010b = 11110011b
-01010011b | 11110011b = 11110011b
-01010011b | 11110100b = 11110111b
-01010011b | 11110101b = 11110111b
-01010011b | 11110110b = 11110111b
-01010011b | 11110111b = 11110111b
-01010011b | 11111000b = 11111011b
-01010011b | 11111001b = 11111011b
-01010011b | 11111010b = 11111011b
-01010011b | 11111011b = 11111011b
-01010011b | 11111100b = 11111111b
-01010011b | 11111101b = 11111111b
-01010011b | 11111110b = 11111111b
-01010011b | 11111111b = 11111111b
-01010011b | 00000000b = 01010011b
-01010011b | 00000001b = 01010011b
-01010011b | 00000010b = 01010011b
-01010011b | 00000011b = 01010011b
-01010011b | 00000100b = 01010111b
-01010011b | 00000101b = 01010111b
-01010011b | 00000110b = 01010111b
-01010011b | 00000111b = 01010111b
-01010011b | 00001000b = 01011011b
-01010011b | 00001001b = 01011011b
-01010011b | 00001010b = 01011011b
-01010011b | 00001011b = 01011011b
-01010011b | 00001100b = 01011111b
-01010011b | 00001101b = 01011111b
-01010011b | 00001110b = 01011111b
-01010011b | 00001111b = 01011111b
-01010011b | 00010000b = 01010011b
-01010011b | 00010001b = 01010011b
-01010011b | 00010010b = 01010011b
-01010011b | 00010011b = 01010011b
-01010011b | 00010100b = 01010111b
-01010011b | 00010101b = 01010111b
-01010011b | 00010110b = 01010111b
-01010011b | 00010111b = 01010111b
-01010011b | 00011000b = 01011011b
-01010011b | 00011001b = 01011011b
-01010011b | 00011010b = 01011011b
-01010011b | 00011011b = 01011011b
-01010011b | 00011100b = 01011111b
-01010011b | 00011101b = 01011111b
-01010011b | 00011110b = 01011111b
-01010011b | 00011111b = 01011111b
-01010011b | 00100000b = 01110011b
-01010011b | 00100001b = 01110011b
-01010011b | 00100010b = 01110011b
-01010011b | 00100011b = 01110011b
-01010011b | 00100100b = 01110111b
-01010011b | 00100101b = 01110111b
-01010011b | 00100110b = 01110111b
-01010011b | 00100111b = 01110111b
-01010011b | 00101000b = 01111011b
-01010011b | 00101001b = 01111011b
-01010011b | 00101010b = 01111011b
-01010011b | 00101011b = 01111011b
-01010011b | 00101100b = 01111111b
-01010011b | 00101101b = 01111111b
-01010011b | 00101110b = 01111111b
-01010011b | 00101111b = 01111111b
-01010011b | 00110000b = 01110011b
-01010011b | 00110001b = 01110011b
-01010011b | 00110010b = 01110011b
-01010011b | 00110011b = 01110011b
-01010011b | 00110100b = 01110111b
-01010011b | 00110101b = 01110111b
-01010011b | 00110110b = 01110111b
-01010011b | 00110111b = 01110111b
-01010011b | 00111000b = 01111011b
-01010011b | 00111001b = 01111011b
-01010011b | 00111010b = 01111011b
-01010011b | 00111011b = 01111011b
-01010011b | 00111100b = 01111111b
-01010011b | 00111101b = 01111111b
-01010011b | 00111110b = 01111111b
-01010011b | 00111111b = 01111111b
-01010011b | 01000000b = 01010011b
-01010011b | 01000001b = 01010011b
-01010011b | 01000010b = 01010011b
-01010011b | 01000011b = 01010011b
-01010011b | 01000100b = 01010111b
-01010011b | 01000101b = 01010111b
-01010011b | 01000110b = 01010111b
-01010011b | 01000111b = 01010111b
-01010011b | 01001000b = 01011011b
-01010011b | 01001001b = 01011011b
-01010011b | 01001010b = 01011011b
-01010011b | 01001011b = 01011011b
-01010011b | 01001100b = 01011111b
-01010011b | 01001101b = 01011111b
-01010011b | 01001110b = 01011111b
-01010011b | 01001111b = 01011111b
-01010011b | 01010000b = 01010011b
-01010011b | 01010001b = 01010011b
-01010011b | 01010010b = 01010011b
-01010011b | 01010011b = 01010011b
-01010011b | 01010100b = 01010111b
-01010011b | 01010101b = 01010111b
-01010011b | 01010110b = 01010111b
-01010011b | 01010111b = 01010111b
-01010011b | 01011000b = 01011011b
-01010011b | 01011001b = 01011011b
-01010011b | 01011010b = 01011011b
-01010011b | 01011011b = 01011011b
-01010011b | 01011100b = 01011111b
-01010011b | 01011101b = 01011111b
-01010011b | 01011110b = 01011111b
-01010011b | 01011111b = 01011111b
-01010011b | 01100000b = 01110011b
-01010011b | 01100001b = 01110011b
-01010011b | 01100010b = 01110011b
-01010011b | 01100011b = 01110011b
-01010011b | 01100100b = 01110111b
-01010011b | 01100101b = 01110111b
-01010011b | 01100110b = 01110111b
-01010011b | 01100111b = 01110111b
-01010011b | 01101000b = 01111011b
-01010011b | 01101001b = 01111011b
-01010011b | 01101010b = 01111011b
-01010011b | 01101011b = 01111011b
-01010011b | 01101100b = 01111111b
-01010011b | 01101101b = 01111111b
-01010011b | 01101110b = 01111111b
-01010011b | 01101111b = 01111111b
-01010011b | 01110000b = 01110011b
-01010011b | 01110001b = 01110011b
-01010011b | 01110010b = 01110011b
-01010011b | 01110011b = 01110011b
-01010011b | 01110100b = 01110111b
-01010011b | 01110101b = 01110111b
-01010011b | 01110110b = 01110111b
-01010011b | 01110111b = 01110111b
-01010011b | 01111000b = 01111011b
-01010011b | 01111001b = 01111011b
-01010011b | 01111010b = 01111011b
-01010011b | 01111011b = 01111011b
-01010011b | 01111100b = 01111111b
-01010011b | 01111101b = 01111111b
-01010011b | 01111110b = 01111111b
-01010100b | 10000000b = 11010100b
-01010100b | 10000001b = 11010101b
-01010100b | 10000010b = 11010110b
-01010100b | 10000011b = 11010111b
-01010100b | 10000100b = 11010100b
-01010100b | 10000101b = 11010101b
-01010100b | 10000110b = 11010110b
-01010100b | 10000111b = 11010111b
-01010100b | 10001000b = 11011100b
-01010100b | 10001001b = 11011101b
-01010100b | 10001010b = 11011110b
-01010100b | 10001011b = 11011111b
-01010100b | 10001100b = 11011100b
-01010100b | 10001101b = 11011101b
-01010100b | 10001110b = 11011110b
-01010100b | 10001111b = 11011111b
-01010100b | 10010000b = 11010100b
-01010100b | 10010001b = 11010101b
-01010100b | 10010010b = 11010110b
-01010100b | 10010011b = 11010111b
-01010100b | 10010100b = 11010100b
-01010100b | 10010101b = 11010101b
-01010100b | 10010110b = 11010110b
-01010100b | 10010111b = 11010111b
-01010100b | 10011000b = 11011100b
-01010100b | 10011001b = 11011101b
-01010100b | 10011010b = 11011110b
-01010100b | 10011011b = 11011111b
-01010100b | 10011100b = 11011100b
-01010100b | 10011101b = 11011101b
-01010100b | 10011110b = 11011110b
-01010100b | 10011111b = 11011111b
-01010100b | 10100000b = 11110100b
-01010100b | 10100001b = 11110101b
-01010100b | 10100010b = 11110110b
-01010100b | 10100011b = 11110111b
-01010100b | 10100100b = 11110100b
-01010100b | 10100101b = 11110101b
-01010100b | 10100110b = 11110110b
-01010100b | 10100111b = 11110111b
-01010100b | 10101000b = 11111100b
-01010100b | 10101001b = 11111101b
-01010100b | 10101010b = 11111110b
-01010100b | 10101011b = 11111111b
-01010100b | 10101100b = 11111100b
-01010100b | 10101101b = 11111101b
-01010100b | 10101110b = 11111110b
-01010100b | 10101111b = 11111111b
-01010100b | 10110000b = 11110100b
-01010100b | 10110001b = 11110101b
-01010100b | 10110010b = 11110110b
-01010100b | 10110011b = 11110111b
-01010100b | 10110100b = 11110100b
-01010100b | 10110101b = 11110101b
-01010100b | 10110110b = 11110110b
-01010100b | 10110111b = 11110111b
-01010100b | 10111000b = 11111100b
-01010100b | 10111001b = 11111101b
-01010100b | 10111010b = 11111110b
-01010100b | 10111011b = 11111111b
-01010100b | 10111100b = 11111100b
-01010100b | 10111101b = 11111101b
-01010100b | 10111110b = 11111110b
-01010100b | 10111111b = 11111111b
-01010100b | 11000000b = 11010100b
-01010100b | 11000001b = 11010101b
-01010100b | 11000010b = 11010110b
-01010100b | 11000011b = 11010111b
-01010100b | 11000100b = 11010100b
-01010100b | 11000101b = 11010101b
-01010100b | 11000110b = 11010110b
-01010100b | 11000111b = 11010111b
-01010100b | 11001000b = 11011100b
-01010100b | 11001001b = 11011101b
-01010100b | 11001010b = 11011110b
-01010100b | 11001011b = 11011111b
-01010100b | 11001100b = 11011100b
-01010100b | 11001101b = 11011101b
-01010100b | 11001110b = 11011110b
-01010100b | 11001111b = 11011111b
-01010100b | 11010000b = 11010100b
-01010100b | 11010001b = 11010101b
-01010100b | 11010010b = 11010110b
-01010100b | 11010011b = 11010111b
-01010100b | 11010100b = 11010100b
-01010100b | 11010101b = 11010101b
-01010100b | 11010110b = 11010110b
-01010100b | 11010111b = 11010111b
-01010100b | 11011000b = 11011100b
-01010100b | 11011001b = 11011101b
-01010100b | 11011010b = 11011110b
-01010100b | 11011011b = 11011111b
-01010100b | 11011100b = 11011100b
-01010100b | 11011101b = 11011101b
-01010100b | 11011110b = 11011110b
-01010100b | 11011111b = 11011111b
-01010100b | 11100000b = 11110100b
-01010100b | 11100001b = 11110101b
-01010100b | 11100010b = 11110110b
-01010100b | 11100011b = 11110111b
-01010100b | 11100100b = 11110100b
-01010100b | 11100101b = 11110101b
-01010100b | 11100110b = 11110110b
-01010100b | 11100111b = 11110111b
-01010100b | 11101000b = 11111100b
-01010100b | 11101001b = 11111101b
-01010100b | 11101010b = 11111110b
-01010100b | 11101011b = 11111111b
-01010100b | 11101100b = 11111100b
-01010100b | 11101101b = 11111101b
-01010100b | 11101110b = 11111110b
-01010100b | 11101111b = 11111111b
-01010100b | 11110000b = 11110100b
-01010100b | 11110001b = 11110101b
-01010100b | 11110010b = 11110110b
-01010100b | 11110011b = 11110111b
-01010100b | 11110100b = 11110100b
-01010100b | 11110101b = 11110101b
-01010100b | 11110110b = 11110110b
-01010100b | 11110111b = 11110111b
-01010100b | 11111000b = 11111100b
-01010100b | 11111001b = 11111101b
-01010100b | 11111010b = 11111110b
-01010100b | 11111011b = 11111111b
-01010100b | 11111100b = 11111100b
-01010100b | 11111101b = 11111101b
-01010100b | 11111110b = 11111110b
-01010100b | 11111111b = 11111111b
-01010100b | 00000000b = 01010100b
-01010100b | 00000001b = 01010101b
-01010100b | 00000010b = 01010110b
-01010100b | 00000011b = 01010111b
-01010100b | 00000100b = 01010100b
-01010100b | 00000101b = 01010101b
-01010100b | 00000110b = 01010110b
-01010100b | 00000111b = 01010111b
-01010100b | 00001000b = 01011100b
-01010100b | 00001001b = 01011101b
-01010100b | 00001010b = 01011110b
-01010100b | 00001011b = 01011111b
-01010100b | 00001100b = 01011100b
-01010100b | 00001101b = 01011101b
-01010100b | 00001110b = 01011110b
-01010100b | 00001111b = 01011111b
-01010100b | 00010000b = 01010100b
-01010100b | 00010001b = 01010101b
-01010100b | 00010010b = 01010110b
-01010100b | 00010011b = 01010111b
-01010100b | 00010100b = 01010100b
-01010100b | 00010101b = 01010101b
-01010100b | 00010110b = 01010110b
-01010100b | 00010111b = 01010111b
-01010100b | 00011000b = 01011100b
-01010100b | 00011001b = 01011101b
-01010100b | 00011010b = 01011110b
-01010100b | 00011011b = 01011111b
-01010100b | 00011100b = 01011100b
-01010100b | 00011101b = 01011101b
-01010100b | 00011110b = 01011110b
-01010100b | 00011111b = 01011111b
-01010100b | 00100000b = 01110100b
-01010100b | 00100001b = 01110101b
-01010100b | 00100010b = 01110110b
-01010100b | 00100011b = 01110111b
-01010100b | 00100100b = 01110100b
-01010100b | 00100101b = 01110101b
-01010100b | 00100110b = 01110110b
-01010100b | 00100111b = 01110111b
-01010100b | 00101000b = 01111100b
-01010100b | 00101001b = 01111101b
-01010100b | 00101010b = 01111110b
-01010100b | 00101011b = 01111111b
-01010100b | 00101100b = 01111100b
-01010100b | 00101101b = 01111101b
-01010100b | 00101110b = 01111110b
-01010100b | 00101111b = 01111111b
-01010100b | 00110000b = 01110100b
-01010100b | 00110001b = 01110101b
-01010100b | 00110010b = 01110110b
-01010100b | 00110011b = 01110111b
-01010100b | 00110100b = 01110100b
-01010100b | 00110101b = 01110101b
-01010100b | 00110110b = 01110110b
-01010100b | 00110111b = 01110111b
-01010100b | 00111000b = 01111100b
-01010100b | 00111001b = 01111101b
-01010100b | 00111010b = 01111110b
-01010100b | 00111011b = 01111111b
-01010100b | 00111100b = 01111100b
-01010100b | 00111101b = 01111101b
-01010100b | 00111110b = 01111110b
-01010100b | 00111111b = 01111111b
-01010100b | 01000000b = 01010100b
-01010100b | 01000001b = 01010101b
-01010100b | 01000010b = 01010110b
-01010100b | 01000011b = 01010111b
-01010100b | 01000100b = 01010100b
-01010100b | 01000101b = 01010101b
-01010100b | 01000110b = 01010110b
-01010100b | 01000111b = 01010111b
-01010100b | 01001000b = 01011100b
-01010100b | 01001001b = 01011101b
-01010100b | 01001010b = 01011110b
-01010100b | 01001011b = 01011111b
-01010100b | 01001100b = 01011100b
-01010100b | 01001101b = 01011101b
-01010100b | 01001110b = 01011110b
-01010100b | 01001111b = 01011111b
-01010100b | 01010000b = 01010100b
-01010100b | 01010001b = 01010101b
-01010100b | 01010010b = 01010110b
-01010100b | 01010011b = 01010111b
-01010100b | 01010100b = 01010100b
-01010100b | 01010101b = 01010101b
-01010100b | 01010110b = 01010110b
-01010100b | 01010111b = 01010111b
-01010100b | 01011000b = 01011100b
-01010100b | 01011001b = 01011101b
-01010100b | 01011010b = 01011110b
-01010100b | 01011011b = 01011111b
-01010100b | 01011100b = 01011100b
-01010100b | 01011101b = 01011101b
-01010100b | 01011110b = 01011110b
-01010100b | 01011111b = 01011111b
-01010100b | 01100000b = 01110100b
-01010100b | 01100001b = 01110101b
-01010100b | 01100010b = 01110110b
-01010100b | 01100011b = 01110111b
-01010100b | 01100100b = 01110100b
-01010100b | 01100101b = 01110101b
-01010100b | 01100110b = 01110110b
-01010100b | 01100111b = 01110111b
-01010100b | 01101000b = 01111100b
-01010100b | 01101001b = 01111101b
-01010100b | 01101010b = 01111110b
-01010100b | 01101011b = 01111111b
-01010100b | 01101100b = 01111100b
-01010100b | 01101101b = 01111101b
-01010100b | 01101110b = 01111110b
-01010100b | 01101111b = 01111111b
-01010100b | 01110000b = 01110100b
-01010100b | 01110001b = 01110101b
-01010100b | 01110010b = 01110110b
-01010100b | 01110011b = 01110111b
-01010100b | 01110100b = 01110100b
-01010100b | 01110101b = 01110101b
-01010100b | 01110110b = 01110110b
-01010100b | 01110111b = 01110111b
-01010100b | 01111000b = 01111100b
-01010100b | 01111001b = 01111101b
-01010100b | 01111010b = 01111110b
-01010100b | 01111011b = 01111111b
-01010100b | 01111100b = 01111100b
-01010100b | 01111101b = 01111101b
-01010100b | 01111110b = 01111110b
-01010101b | 10000000b = 11010101b
-01010101b | 10000001b = 11010101b
-01010101b | 10000010b = 11010111b
-01010101b | 10000011b = 11010111b
-01010101b | 10000100b = 11010101b
-01010101b | 10000101b = 11010101b
-01010101b | 10000110b = 11010111b
-01010101b | 10000111b = 11010111b
-01010101b | 10001000b = 11011101b
-01010101b | 10001001b = 11011101b
-01010101b | 10001010b = 11011111b
-01010101b | 10001011b = 11011111b
-01010101b | 10001100b = 11011101b
-01010101b | 10001101b = 11011101b
-01010101b | 10001110b = 11011111b
-01010101b | 10001111b = 11011111b
-01010101b | 10010000b = 11010101b
-01010101b | 10010001b = 11010101b
-01010101b | 10010010b = 11010111b
-01010101b | 10010011b = 11010111b
-01010101b | 10010100b = 11010101b
-01010101b | 10010101b = 11010101b
-01010101b | 10010110b = 11010111b
-01010101b | 10010111b = 11010111b
-01010101b | 10011000b = 11011101b
-01010101b | 10011001b = 11011101b
-01010101b | 10011010b = 11011111b
-01010101b | 10011011b = 11011111b
-01010101b | 10011100b = 11011101b
-01010101b | 10011101b = 11011101b
-01010101b | 10011110b = 11011111b
-01010101b | 10011111b = 11011111b
-01010101b | 10100000b = 11110101b
-01010101b | 10100001b = 11110101b
-01010101b | 10100010b = 11110111b
-01010101b | 10100011b = 11110111b
-01010101b | 10100100b = 11110101b
-01010101b | 10100101b = 11110101b
-01010101b | 10100110b = 11110111b
-01010101b | 10100111b = 11110111b
-01010101b | 10101000b = 11111101b
-01010101b | 10101001b = 11111101b
-01010101b | 10101010b = 11111111b
-01010101b | 10101011b = 11111111b
-01010101b | 10101100b = 11111101b
-01010101b | 10101101b = 11111101b
-01010101b | 10101110b = 11111111b
-01010101b | 10101111b = 11111111b
-01010101b | 10110000b = 11110101b
-01010101b | 10110001b = 11110101b
-01010101b | 10110010b = 11110111b
-01010101b | 10110011b = 11110111b
-01010101b | 10110100b = 11110101b
-01010101b | 10110101b = 11110101b
-01010101b | 10110110b = 11110111b
-01010101b | 10110111b = 11110111b
-01010101b | 10111000b = 11111101b
-01010101b | 10111001b = 11111101b
-01010101b | 10111010b = 11111111b
-01010101b | 10111011b = 11111111b
-01010101b | 10111100b = 11111101b
-01010101b | 10111101b = 11111101b
-01010101b | 10111110b = 11111111b
-01010101b | 10111111b = 11111111b
-01010101b | 11000000b = 11010101b
-01010101b | 11000001b = 11010101b
-01010101b | 11000010b = 11010111b
-01010101b | 11000011b = 11010111b
-01010101b | 11000100b = 11010101b
-01010101b | 11000101b = 11010101b
-01010101b | 11000110b = 11010111b
-01010101b | 11000111b = 11010111b
-01010101b | 11001000b = 11011101b
-01010101b | 11001001b = 11011101b
-01010101b | 11001010b = 11011111b
-01010101b | 11001011b = 11011111b
-01010101b | 11001100b = 11011101b
-01010101b | 11001101b = 11011101b
-01010101b | 11001110b = 11011111b
-01010101b | 11001111b = 11011111b
-01010101b | 11010000b = 11010101b
-01010101b | 11010001b = 11010101b
-01010101b | 11010010b = 11010111b
-01010101b | 11010011b = 11010111b
-01010101b | 11010100b = 11010101b
-01010101b | 11010101b = 11010101b
-01010101b | 11010110b = 11010111b
-01010101b | 11010111b = 11010111b
-01010101b | 11011000b = 11011101b
-01010101b | 11011001b = 11011101b
-01010101b | 11011010b = 11011111b
-01010101b | 11011011b = 11011111b
-01010101b | 11011100b = 11011101b
-01010101b | 11011101b = 11011101b
-01010101b | 11011110b = 11011111b
-01010101b | 11011111b = 11011111b
-01010101b | 11100000b = 11110101b
-01010101b | 11100001b = 11110101b
-01010101b | 11100010b = 11110111b
-01010101b | 11100011b = 11110111b
-01010101b | 11100100b = 11110101b
-01010101b | 11100101b = 11110101b
-01010101b | 11100110b = 11110111b
-01010101b | 11100111b = 11110111b
-01010101b | 11101000b = 11111101b
-01010101b | 11101001b = 11111101b
-01010101b | 11101010b = 11111111b
-01010101b | 11101011b = 11111111b
-01010101b | 11101100b = 11111101b
-01010101b | 11101101b = 11111101b
-01010101b | 11101110b = 11111111b
-01010101b | 11101111b = 11111111b
-01010101b | 11110000b = 11110101b
-01010101b | 11110001b = 11110101b
-01010101b | 11110010b = 11110111b
-01010101b | 11110011b = 11110111b
-01010101b | 11110100b = 11110101b
-01010101b | 11110101b = 11110101b
-01010101b | 11110110b = 11110111b
-01010101b | 11110111b = 11110111b
-01010101b | 11111000b = 11111101b
-01010101b | 11111001b = 11111101b
-01010101b | 11111010b = 11111111b
-01010101b | 11111011b = 11111111b
-01010101b | 11111100b = 11111101b
-01010101b | 11111101b = 11111101b
-01010101b | 11111110b = 11111111b
-01010101b | 11111111b = 11111111b
-01010101b | 00000000b = 01010101b
-01010101b | 00000001b = 01010101b
-01010101b | 00000010b = 01010111b
-01010101b | 00000011b = 01010111b
-01010101b | 00000100b = 01010101b
-01010101b | 00000101b = 01010101b
-01010101b | 00000110b = 01010111b
-01010101b | 00000111b = 01010111b
-01010101b | 00001000b = 01011101b
-01010101b | 00001001b = 01011101b
-01010101b | 00001010b = 01011111b
-01010101b | 00001011b = 01011111b
-01010101b | 00001100b = 01011101b
-01010101b | 00001101b = 01011101b
-01010101b | 00001110b = 01011111b
-01010101b | 00001111b = 01011111b
-01010101b | 00010000b = 01010101b
-01010101b | 00010001b = 01010101b
-01010101b | 00010010b = 01010111b
-01010101b | 00010011b = 01010111b
-01010101b | 00010100b = 01010101b
-01010101b | 00010101b = 01010101b
-01010101b | 00010110b = 01010111b
-01010101b | 00010111b = 01010111b
-01010101b | 00011000b = 01011101b
-01010101b | 00011001b = 01011101b
-01010101b | 00011010b = 01011111b
-01010101b | 00011011b = 01011111b
-01010101b | 00011100b = 01011101b
-01010101b | 00011101b = 01011101b
-01010101b | 00011110b = 01011111b
-01010101b | 00011111b = 01011111b
-01010101b | 00100000b = 01110101b
-01010101b | 00100001b = 01110101b
-01010101b | 00100010b = 01110111b
-01010101b | 00100011b = 01110111b
-01010101b | 00100100b = 01110101b
-01010101b | 00100101b = 01110101b
-01010101b | 00100110b = 01110111b
-01010101b | 00100111b = 01110111b
-01010101b | 00101000b = 01111101b
-01010101b | 00101001b = 01111101b
-01010101b | 00101010b = 01111111b
-01010101b | 00101011b = 01111111b
-01010101b | 00101100b = 01111101b
-01010101b | 00101101b = 01111101b
-01010101b | 00101110b = 01111111b
-01010101b | 00101111b = 01111111b
-01010101b | 00110000b = 01110101b
-01010101b | 00110001b = 01110101b
-01010101b | 00110010b = 01110111b
-01010101b | 00110011b = 01110111b
-01010101b | 00110100b = 01110101b
-01010101b | 00110101b = 01110101b
-01010101b | 00110110b = 01110111b
-01010101b | 00110111b = 01110111b
-01010101b | 00111000b = 01111101b
-01010101b | 00111001b = 01111101b
-01010101b | 00111010b = 01111111b
-01010101b | 00111011b = 01111111b
-01010101b | 00111100b = 01111101b
-01010101b | 00111101b = 01111101b
-01010101b | 00111110b = 01111111b
-01010101b | 00111111b = 01111111b
-01010101b | 01000000b = 01010101b
-01010101b | 01000001b = 01010101b
-01010101b | 01000010b = 01010111b
-01010101b | 01000011b = 01010111b
-01010101b | 01000100b = 01010101b
-01010101b | 01000101b = 01010101b
-01010101b | 01000110b = 01010111b
-01010101b | 01000111b = 01010111b
-01010101b | 01001000b = 01011101b
-01010101b | 01001001b = 01011101b
-01010101b | 01001010b = 01011111b
-01010101b | 01001011b = 01011111b
-01010101b | 01001100b = 01011101b
-01010101b | 01001101b = 01011101b
-01010101b | 01001110b = 01011111b
-01010101b | 01001111b = 01011111b
-01010101b | 01010000b = 01010101b
-01010101b | 01010001b = 01010101b
-01010101b | 01010010b = 01010111b
-01010101b | 01010011b = 01010111b
-01010101b | 01010100b = 01010101b
-01010101b | 01010101b = 01010101b
-01010101b | 01010110b = 01010111b
-01010101b | 01010111b = 01010111b
-01010101b | 01011000b = 01011101b
-01010101b | 01011001b = 01011101b
-01010101b | 01011010b = 01011111b
-01010101b | 01011011b = 01011111b
-01010101b | 01011100b = 01011101b
-01010101b | 01011101b = 01011101b
-01010101b | 01011110b = 01011111b
-01010101b | 01011111b = 01011111b
-01010101b | 01100000b = 01110101b
-01010101b | 01100001b = 01110101b
-01010101b | 01100010b = 01110111b
-01010101b | 01100011b = 01110111b
-01010101b | 01100100b = 01110101b
-01010101b | 01100101b = 01110101b
-01010101b | 01100110b = 01110111b
-01010101b | 01100111b = 01110111b
-01010101b | 01101000b = 01111101b
-01010101b | 01101001b = 01111101b
-01010101b | 01101010b = 01111111b
-01010101b | 01101011b = 01111111b
-01010101b | 01101100b = 01111101b
-01010101b | 01101101b = 01111101b
-01010101b | 01101110b = 01111111b
-01010101b | 01101111b = 01111111b
-01010101b | 01110000b = 01110101b
-01010101b | 01110001b = 01110101b
-01010101b | 01110010b = 01110111b
-01010101b | 01110011b = 01110111b
-01010101b | 01110100b = 01110101b
-01010101b | 01110101b = 01110101b
-01010101b | 01110110b = 01110111b
-01010101b | 01110111b = 01110111b
-01010101b | 01111000b = 01111101b
-01010101b | 01111001b = 01111101b
-01010101b | 01111010b = 01111111b
-01010101b | 01111011b = 01111111b
-01010101b | 01111100b = 01111101b
-01010101b | 01111101b = 01111101b
-01010101b | 01111110b = 01111111b
-01010110b | 10000000b = 11010110b
-01010110b | 10000001b = 11010111b
-01010110b | 10000010b = 11010110b
-01010110b | 10000011b = 11010111b
-01010110b | 10000100b = 11010110b
-01010110b | 10000101b = 11010111b
-01010110b | 10000110b = 11010110b
-01010110b | 10000111b = 11010111b
-01010110b | 10001000b = 11011110b
-01010110b | 10001001b = 11011111b
-01010110b | 10001010b = 11011110b
-01010110b | 10001011b = 11011111b
-01010110b | 10001100b = 11011110b
-01010110b | 10001101b = 11011111b
-01010110b | 10001110b = 11011110b
-01010110b | 10001111b = 11011111b
-01010110b | 10010000b = 11010110b
-01010110b | 10010001b = 11010111b
-01010110b | 10010010b = 11010110b
-01010110b | 10010011b = 11010111b
-01010110b | 10010100b = 11010110b
-01010110b | 10010101b = 11010111b
-01010110b | 10010110b = 11010110b
-01010110b | 10010111b = 11010111b
-01010110b | 10011000b = 11011110b
-01010110b | 10011001b = 11011111b
-01010110b | 10011010b = 11011110b
-01010110b | 10011011b = 11011111b
-01010110b | 10011100b = 11011110b
-01010110b | 10011101b = 11011111b
-01010110b | 10011110b = 11011110b
-01010110b | 10011111b = 11011111b
-01010110b | 10100000b = 11110110b
-01010110b | 10100001b = 11110111b
-01010110b | 10100010b = 11110110b
-01010110b | 10100011b = 11110111b
-01010110b | 10100100b = 11110110b
-01010110b | 10100101b = 11110111b
-01010110b | 10100110b = 11110110b
-01010110b | 10100111b = 11110111b
-01010110b | 10101000b = 11111110b
-01010110b | 10101001b = 11111111b
-01010110b | 10101010b = 11111110b
-01010110b | 10101011b = 11111111b
-01010110b | 10101100b = 11111110b
-01010110b | 10101101b = 11111111b
-01010110b | 10101110b = 11111110b
-01010110b | 10101111b = 11111111b
-01010110b | 10110000b = 11110110b
-01010110b | 10110001b = 11110111b
-01010110b | 10110010b = 11110110b
-01010110b | 10110011b = 11110111b
-01010110b | 10110100b = 11110110b
-01010110b | 10110101b = 11110111b
-01010110b | 10110110b = 11110110b
-01010110b | 10110111b = 11110111b
-01010110b | 10111000b = 11111110b
-01010110b | 10111001b = 11111111b
-01010110b | 10111010b = 11111110b
-01010110b | 10111011b = 11111111b
-01010110b | 10111100b = 11111110b
-01010110b | 10111101b = 11111111b
-01010110b | 10111110b = 11111110b
-01010110b | 10111111b = 11111111b
-01010110b | 11000000b = 11010110b
-01010110b | 11000001b = 11010111b
-01010110b | 11000010b = 11010110b
-01010110b | 11000011b = 11010111b
-01010110b | 11000100b = 11010110b
-01010110b | 11000101b = 11010111b
-01010110b | 11000110b = 11010110b
-01010110b | 11000111b = 11010111b
-01010110b | 11001000b = 11011110b
-01010110b | 11001001b = 11011111b
-01010110b | 11001010b = 11011110b
-01010110b | 11001011b = 11011111b
-01010110b | 11001100b = 11011110b
-01010110b | 11001101b = 11011111b
-01010110b | 11001110b = 11011110b
-01010110b | 11001111b = 11011111b
-01010110b | 11010000b = 11010110b
-01010110b | 11010001b = 11010111b
-01010110b | 11010010b = 11010110b
-01010110b | 11010011b = 11010111b
-01010110b | 11010100b = 11010110b
-01010110b | 11010101b = 11010111b
-01010110b | 11010110b = 11010110b
-01010110b | 11010111b = 11010111b
-01010110b | 11011000b = 11011110b
-01010110b | 11011001b = 11011111b
-01010110b | 11011010b = 11011110b
-01010110b | 11011011b = 11011111b
-01010110b | 11011100b = 11011110b
-01010110b | 11011101b = 11011111b
-01010110b | 11011110b = 11011110b
-01010110b | 11011111b = 11011111b
-01010110b | 11100000b = 11110110b
-01010110b | 11100001b = 11110111b
-01010110b | 11100010b = 11110110b
-01010110b | 11100011b = 11110111b
-01010110b | 11100100b = 11110110b
-01010110b | 11100101b = 11110111b
-01010110b | 11100110b = 11110110b
-01010110b | 11100111b = 11110111b
-01010110b | 11101000b = 11111110b
-01010110b | 11101001b = 11111111b
-01010110b | 11101010b = 11111110b
-01010110b | 11101011b = 11111111b
-01010110b | 11101100b = 11111110b
-01010110b | 11101101b = 11111111b
-01010110b | 11101110b = 11111110b
-01010110b | 11101111b = 11111111b
-01010110b | 11110000b = 11110110b
-01010110b | 11110001b = 11110111b
-01010110b | 11110010b = 11110110b
-01010110b | 11110011b = 11110111b
-01010110b | 11110100b = 11110110b
-01010110b | 11110101b = 11110111b
-01010110b | 11110110b = 11110110b
-01010110b | 11110111b = 11110111b
-01010110b | 11111000b = 11111110b
-01010110b | 11111001b = 11111111b
-01010110b | 11111010b = 11111110b
-01010110b | 11111011b = 11111111b
-01010110b | 11111100b = 11111110b
-01010110b | 11111101b = 11111111b
-01010110b | 11111110b = 11111110b
-01010110b | 11111111b = 11111111b
-01010110b | 00000000b = 01010110b
-01010110b | 00000001b = 01010111b
-01010110b | 00000010b = 01010110b
-01010110b | 00000011b = 01010111b
-01010110b | 00000100b = 01010110b
-01010110b | 00000101b = 01010111b
-01010110b | 00000110b = 01010110b
-01010110b | 00000111b = 01010111b
-01010110b | 00001000b = 01011110b
-01010110b | 00001001b = 01011111b
-01010110b | 00001010b = 01011110b
-01010110b | 00001011b = 01011111b
-01010110b | 00001100b = 01011110b
-01010110b | 00001101b = 01011111b
-01010110b | 00001110b = 01011110b
-01010110b | 00001111b = 01011111b
-01010110b | 00010000b = 01010110b
-01010110b | 00010001b = 01010111b
-01010110b | 00010010b = 01010110b
-01010110b | 00010011b = 01010111b
-01010110b | 00010100b = 01010110b
-01010110b | 00010101b = 01010111b
-01010110b | 00010110b = 01010110b
-01010110b | 00010111b = 01010111b
-01010110b | 00011000b = 01011110b
-01010110b | 00011001b = 01011111b
-01010110b | 00011010b = 01011110b
-01010110b | 00011011b = 01011111b
-01010110b | 00011100b = 01011110b
-01010110b | 00011101b = 01011111b
-01010110b | 00011110b = 01011110b
-01010110b | 00011111b = 01011111b
-01010110b | 00100000b = 01110110b
-01010110b | 00100001b = 01110111b
-01010110b | 00100010b = 01110110b
-01010110b | 00100011b = 01110111b
-01010110b | 00100100b = 01110110b
-01010110b | 00100101b = 01110111b
-01010110b | 00100110b = 01110110b
-01010110b | 00100111b = 01110111b
-01010110b | 00101000b = 01111110b
-01010110b | 00101001b = 01111111b
-01010110b | 00101010b = 01111110b
-01010110b | 00101011b = 01111111b
-01010110b | 00101100b = 01111110b
-01010110b | 00101101b = 01111111b
-01010110b | 00101110b = 01111110b
-01010110b | 00101111b = 01111111b
-01010110b | 00110000b = 01110110b
-01010110b | 00110001b = 01110111b
-01010110b | 00110010b = 01110110b
-01010110b | 00110011b = 01110111b
-01010110b | 00110100b = 01110110b
-01010110b | 00110101b = 01110111b
-01010110b | 00110110b = 01110110b
-01010110b | 00110111b = 01110111b
-01010110b | 00111000b = 01111110b
-01010110b | 00111001b = 01111111b
-01010110b | 00111010b = 01111110b
-01010110b | 00111011b = 01111111b
-01010110b | 00111100b = 01111110b
-01010110b | 00111101b = 01111111b
-01010110b | 00111110b = 01111110b
-01010110b | 00111111b = 01111111b
-01010110b | 01000000b = 01010110b
-01010110b | 01000001b = 01010111b
-01010110b | 01000010b = 01010110b
-01010110b | 01000011b = 01010111b
-01010110b | 01000100b = 01010110b
-01010110b | 01000101b = 01010111b
-01010110b | 01000110b = 01010110b
-01010110b | 01000111b = 01010111b
-01010110b | 01001000b = 01011110b
-01010110b | 01001001b = 01011111b
-01010110b | 01001010b = 01011110b
-01010110b | 01001011b = 01011111b
-01010110b | 01001100b = 01011110b
-01010110b | 01001101b = 01011111b
-01010110b | 01001110b = 01011110b
-01010110b | 01001111b = 01011111b
-01010110b | 01010000b = 01010110b
-01010110b | 01010001b = 01010111b
-01010110b | 01010010b = 01010110b
-01010110b | 01010011b = 01010111b
-01010110b | 01010100b = 01010110b
-01010110b | 01010101b = 01010111b
-01010110b | 01010110b = 01010110b
-01010110b | 01010111b = 01010111b
-01010110b | 01011000b = 01011110b
-01010110b | 01011001b = 01011111b
-01010110b | 01011010b = 01011110b
-01010110b | 01011011b = 01011111b
-01010110b | 01011100b = 01011110b
-01010110b | 01011101b = 01011111b
-01010110b | 01011110b = 01011110b
-01010110b | 01011111b = 01011111b
-01010110b | 01100000b = 01110110b
-01010110b | 01100001b = 01110111b
-01010110b | 01100010b = 01110110b
-01010110b | 01100011b = 01110111b
-01010110b | 01100100b = 01110110b
-01010110b | 01100101b = 01110111b
-01010110b | 01100110b = 01110110b
-01010110b | 01100111b = 01110111b
-01010110b | 01101000b = 01111110b
-01010110b | 01101001b = 01111111b
-01010110b | 01101010b = 01111110b
-01010110b | 01101011b = 01111111b
-01010110b | 01101100b = 01111110b
-01010110b | 01101101b = 01111111b
-01010110b | 01101110b = 01111110b
-01010110b | 01101111b = 01111111b
-01010110b | 01110000b = 01110110b
-01010110b | 01110001b = 01110111b
-01010110b | 01110010b = 01110110b
-01010110b | 01110011b = 01110111b
-01010110b | 01110100b = 01110110b
-01010110b | 01110101b = 01110111b
-01010110b | 01110110b = 01110110b
-01010110b | 01110111b = 01110111b
-01010110b | 01111000b = 01111110b
-01010110b | 01111001b = 01111111b
-01010110b | 01111010b = 01111110b
-01010110b | 01111011b = 01111111b
-01010110b | 01111100b = 01111110b
-01010110b | 01111101b = 01111111b
-01010110b | 01111110b = 01111110b
-01010111b | 10000000b = 11010111b
-01010111b | 10000001b = 11010111b
-01010111b | 10000010b = 11010111b
-01010111b | 10000011b = 11010111b
-01010111b | 10000100b = 11010111b
-01010111b | 10000101b = 11010111b
-01010111b | 10000110b = 11010111b
-01010111b | 10000111b = 11010111b
-01010111b | 10001000b = 11011111b
-01010111b | 10001001b = 11011111b
-01010111b | 10001010b = 11011111b
-01010111b | 10001011b = 11011111b
-01010111b | 10001100b = 11011111b
-01010111b | 10001101b = 11011111b
-01010111b | 10001110b = 11011111b
-01010111b | 10001111b = 11011111b
-01010111b | 10010000b = 11010111b
-01010111b | 10010001b = 11010111b
-01010111b | 10010010b = 11010111b
-01010111b | 10010011b = 11010111b
-01010111b | 10010100b = 11010111b
-01010111b | 10010101b = 11010111b
-01010111b | 10010110b = 11010111b
-01010111b | 10010111b = 11010111b
-01010111b | 10011000b = 11011111b
-01010111b | 10011001b = 11011111b
-01010111b | 10011010b = 11011111b
-01010111b | 10011011b = 11011111b
-01010111b | 10011100b = 11011111b
-01010111b | 10011101b = 11011111b
-01010111b | 10011110b = 11011111b
-01010111b | 10011111b = 11011111b
-01010111b | 10100000b = 11110111b
-01010111b | 10100001b = 11110111b
-01010111b | 10100010b = 11110111b
-01010111b | 10100011b = 11110111b
-01010111b | 10100100b = 11110111b
-01010111b | 10100101b = 11110111b
-01010111b | 10100110b = 11110111b
-01010111b | 10100111b = 11110111b
-01010111b | 10101000b = 11111111b
-01010111b | 10101001b = 11111111b
-01010111b | 10101010b = 11111111b
-01010111b | 10101011b = 11111111b
-01010111b | 10101100b = 11111111b
-01010111b | 10101101b = 11111111b
-01010111b | 10101110b = 11111111b
-01010111b | 10101111b = 11111111b
-01010111b | 10110000b = 11110111b
-01010111b | 10110001b = 11110111b
-01010111b | 10110010b = 11110111b
-01010111b | 10110011b = 11110111b
-01010111b | 10110100b = 11110111b
-01010111b | 10110101b = 11110111b
-01010111b | 10110110b = 11110111b
-01010111b | 10110111b = 11110111b
-01010111b | 10111000b = 11111111b
-01010111b | 10111001b = 11111111b
-01010111b | 10111010b = 11111111b
-01010111b | 10111011b = 11111111b
-01010111b | 10111100b = 11111111b
-01010111b | 10111101b = 11111111b
-01010111b | 10111110b = 11111111b
-01010111b | 10111111b = 11111111b
-01010111b | 11000000b = 11010111b
-01010111b | 11000001b = 11010111b
-01010111b | 11000010b = 11010111b
-01010111b | 11000011b = 11010111b
-01010111b | 11000100b = 11010111b
-01010111b | 11000101b = 11010111b
-01010111b | 11000110b = 11010111b
-01010111b | 11000111b = 11010111b
-01010111b | 11001000b = 11011111b
-01010111b | 11001001b = 11011111b
-01010111b | 11001010b = 11011111b
-01010111b | 11001011b = 11011111b
-01010111b | 11001100b = 11011111b
-01010111b | 11001101b = 11011111b
-01010111b | 11001110b = 11011111b
-01010111b | 11001111b = 11011111b
-01010111b | 11010000b = 11010111b
-01010111b | 11010001b = 11010111b
-01010111b | 11010010b = 11010111b
-01010111b | 11010011b = 11010111b
-01010111b | 11010100b = 11010111b
-01010111b | 11010101b = 11010111b
-01010111b | 11010110b = 11010111b
-01010111b | 11010111b = 11010111b
-01010111b | 11011000b = 11011111b
-01010111b | 11011001b = 11011111b
-01010111b | 11011010b = 11011111b
-01010111b | 11011011b = 11011111b
-01010111b | 11011100b = 11011111b
-01010111b | 11011101b = 11011111b
-01010111b | 11011110b = 11011111b
-01010111b | 11011111b = 11011111b
-01010111b | 11100000b = 11110111b
-01010111b | 11100001b = 11110111b
-01010111b | 11100010b = 11110111b
-01010111b | 11100011b = 11110111b
-01010111b | 11100100b = 11110111b
-01010111b | 11100101b = 11110111b
-01010111b | 11100110b = 11110111b
-01010111b | 11100111b = 11110111b
-01010111b | 11101000b = 11111111b
-01010111b | 11101001b = 11111111b
-01010111b | 11101010b = 11111111b
-01010111b | 11101011b = 11111111b
-01010111b | 11101100b = 11111111b
-01010111b | 11101101b = 11111111b
-01010111b | 11101110b = 11111111b
-01010111b | 11101111b = 11111111b
-01010111b | 11110000b = 11110111b
-01010111b | 11110001b = 11110111b
-01010111b | 11110010b = 11110111b
-01010111b | 11110011b = 11110111b
-01010111b | 11110100b = 11110111b
-01010111b | 11110101b = 11110111b
-01010111b | 11110110b = 11110111b
-01010111b | 11110111b = 11110111b
-01010111b | 11111000b = 11111111b
-01010111b | 11111001b = 11111111b
-01010111b | 11111010b = 11111111b
-01010111b | 11111011b = 11111111b
-01010111b | 11111100b = 11111111b
-01010111b | 11111101b = 11111111b
-01010111b | 11111110b = 11111111b
-01010111b | 11111111b = 11111111b
-01010111b | 00000000b = 01010111b
-01010111b | 00000001b = 01010111b
-01010111b | 00000010b = 01010111b
-01010111b | 00000011b = 01010111b
-01010111b | 00000100b = 01010111b
-01010111b | 00000101b = 01010111b
-01010111b | 00000110b = 01010111b
-01010111b | 00000111b = 01010111b
-01010111b | 00001000b = 01011111b
-01010111b | 00001001b = 01011111b
-01010111b | 00001010b = 01011111b
-01010111b | 00001011b = 01011111b
-01010111b | 00001100b = 01011111b
-01010111b | 00001101b = 01011111b
-01010111b | 00001110b = 01011111b
-01010111b | 00001111b = 01011111b
-01010111b | 00010000b = 01010111b
-01010111b | 00010001b = 01010111b
-01010111b | 00010010b = 01010111b
-01010111b | 00010011b = 01010111b
-01010111b | 00010100b = 01010111b
-01010111b | 00010101b = 01010111b
-01010111b | 00010110b = 01010111b
-01010111b | 00010111b = 01010111b
-01010111b | 00011000b = 01011111b
-01010111b | 00011001b = 01011111b
-01010111b | 00011010b = 01011111b
-01010111b | 00011011b = 01011111b
-01010111b | 00011100b = 01011111b
-01010111b | 00011101b = 01011111b
-01010111b | 00011110b = 01011111b
-01010111b | 00011111b = 01011111b
-01010111b | 00100000b = 01110111b
-01010111b | 00100001b = 01110111b
-01010111b | 00100010b = 01110111b
-01010111b | 00100011b = 01110111b
-01010111b | 00100100b = 01110111b
-01010111b | 00100101b = 01110111b
-01010111b | 00100110b = 01110111b
-01010111b | 00100111b = 01110111b
-01010111b | 00101000b = 01111111b
-01010111b | 00101001b = 01111111b
-01010111b | 00101010b = 01111111b
-01010111b | 00101011b = 01111111b
-01010111b | 00101100b = 01111111b
-01010111b | 00101101b = 01111111b
-01010111b | 00101110b = 01111111b
-01010111b | 00101111b = 01111111b
-01010111b | 00110000b = 01110111b
-01010111b | 00110001b = 01110111b
-01010111b | 00110010b = 01110111b
-01010111b | 00110011b = 01110111b
-01010111b | 00110100b = 01110111b
-01010111b | 00110101b = 01110111b
-01010111b | 00110110b = 01110111b
-01010111b | 00110111b = 01110111b
-01010111b | 00111000b = 01111111b
-01010111b | 00111001b = 01111111b
-01010111b | 00111010b = 01111111b
-01010111b | 00111011b = 01111111b
-01010111b | 00111100b = 01111111b
-01010111b | 00111101b = 01111111b
-01010111b | 00111110b = 01111111b
-01010111b | 00111111b = 01111111b
-01010111b | 01000000b = 01010111b
-01010111b | 01000001b = 01010111b
-01010111b | 01000010b = 01010111b
-01010111b | 01000011b = 01010111b
-01010111b | 01000100b = 01010111b
-01010111b | 01000101b = 01010111b
-01010111b | 01000110b = 01010111b
-01010111b | 01000111b = 01010111b
-01010111b | 01001000b = 01011111b
-01010111b | 01001001b = 01011111b
-01010111b | 01001010b = 01011111b
-01010111b | 01001011b = 01011111b
-01010111b | 01001100b = 01011111b
-01010111b | 01001101b = 01011111b
-01010111b | 01001110b = 01011111b
-01010111b | 01001111b = 01011111b
-01010111b | 01010000b = 01010111b
-01010111b | 01010001b = 01010111b
-01010111b | 01010010b = 01010111b
-01010111b | 01010011b = 01010111b
-01010111b | 01010100b = 01010111b
-01010111b | 01010101b = 01010111b
-01010111b | 01010110b = 01010111b
-01010111b | 01010111b = 01010111b
-01010111b | 01011000b = 01011111b
-01010111b | 01011001b = 01011111b
-01010111b | 01011010b = 01011111b
-01010111b | 01011011b = 01011111b
-01010111b | 01011100b = 01011111b
-01010111b | 01011101b = 01011111b
-01010111b | 01011110b = 01011111b
-01010111b | 01011111b = 01011111b
-01010111b | 01100000b = 01110111b
-01010111b | 01100001b = 01110111b
-01010111b | 01100010b = 01110111b
-01010111b | 01100011b = 01110111b
-01010111b | 01100100b = 01110111b
-01010111b | 01100101b = 01110111b
-01010111b | 01100110b = 01110111b
-01010111b | 01100111b = 01110111b
-01010111b | 01101000b = 01111111b
-01010111b | 01101001b = 01111111b
-01010111b | 01101010b = 01111111b
-01010111b | 01101011b = 01111111b
-01010111b | 01101100b = 01111111b
-01010111b | 01101101b = 01111111b
-01010111b | 01101110b = 01111111b
-01010111b | 01101111b = 01111111b
-01010111b | 01110000b = 01110111b
-01010111b | 01110001b = 01110111b
-01010111b | 01110010b = 01110111b
-01010111b | 01110011b = 01110111b
-01010111b | 01110100b = 01110111b
-01010111b | 01110101b = 01110111b
-01010111b | 01110110b = 01110111b
-01010111b | 01110111b = 01110111b
-01010111b | 01111000b = 01111111b
-01010111b | 01111001b = 01111111b
-01010111b | 01111010b = 01111111b
-01010111b | 01111011b = 01111111b
-01010111b | 01111100b = 01111111b
-01010111b | 01111101b = 01111111b
-01010111b | 01111110b = 01111111b
-01011000b | 10000000b = 11011000b
-01011000b | 10000001b = 11011001b
-01011000b | 10000010b = 11011010b
-01011000b | 10000011b = 11011011b
-01011000b | 10000100b = 11011100b
-01011000b | 10000101b = 11011101b
-01011000b | 10000110b = 11011110b
-01011000b | 10000111b = 11011111b
-01011000b | 10001000b = 11011000b
-01011000b | 10001001b = 11011001b
-01011000b | 10001010b = 11011010b
-01011000b | 10001011b = 11011011b
-01011000b | 10001100b = 11011100b
-01011000b | 10001101b = 11011101b
-01011000b | 10001110b = 11011110b
-01011000b | 10001111b = 11011111b
-01011000b | 10010000b = 11011000b
-01011000b | 10010001b = 11011001b
-01011000b | 10010010b = 11011010b
-01011000b | 10010011b = 11011011b
-01011000b | 10010100b = 11011100b
-01011000b | 10010101b = 11011101b
-01011000b | 10010110b = 11011110b
-01011000b | 10010111b = 11011111b
-01011000b | 10011000b = 11011000b
-01011000b | 10011001b = 11011001b
-01011000b | 10011010b = 11011010b
-01011000b | 10011011b = 11011011b
-01011000b | 10011100b = 11011100b
-01011000b | 10011101b = 11011101b
-01011000b | 10011110b = 11011110b
-01011000b | 10011111b = 11011111b
-01011000b | 10100000b = 11111000b
-01011000b | 10100001b = 11111001b
-01011000b | 10100010b = 11111010b
-01011000b | 10100011b = 11111011b
-01011000b | 10100100b = 11111100b
-01011000b | 10100101b = 11111101b
-01011000b | 10100110b = 11111110b
-01011000b | 10100111b = 11111111b
-01011000b | 10101000b = 11111000b
-01011000b | 10101001b = 11111001b
-01011000b | 10101010b = 11111010b
-01011000b | 10101011b = 11111011b
-01011000b | 10101100b = 11111100b
-01011000b | 10101101b = 11111101b
-01011000b | 10101110b = 11111110b
-01011000b | 10101111b = 11111111b
-01011000b | 10110000b = 11111000b
-01011000b | 10110001b = 11111001b
-01011000b | 10110010b = 11111010b
-01011000b | 10110011b = 11111011b
-01011000b | 10110100b = 11111100b
-01011000b | 10110101b = 11111101b
-01011000b | 10110110b = 11111110b
-01011000b | 10110111b = 11111111b
-01011000b | 10111000b = 11111000b
-01011000b | 10111001b = 11111001b
-01011000b | 10111010b = 11111010b
-01011000b | 10111011b = 11111011b
-01011000b | 10111100b = 11111100b
-01011000b | 10111101b = 11111101b
-01011000b | 10111110b = 11111110b
-01011000b | 10111111b = 11111111b
-01011000b | 11000000b = 11011000b
-01011000b | 11000001b = 11011001b
-01011000b | 11000010b = 11011010b
-01011000b | 11000011b = 11011011b
-01011000b | 11000100b = 11011100b
-01011000b | 11000101b = 11011101b
-01011000b | 11000110b = 11011110b
-01011000b | 11000111b = 11011111b
-01011000b | 11001000b = 11011000b
-01011000b | 11001001b = 11011001b
-01011000b | 11001010b = 11011010b
-01011000b | 11001011b = 11011011b
-01011000b | 11001100b = 11011100b
-01011000b | 11001101b = 11011101b
-01011000b | 11001110b = 11011110b
-01011000b | 11001111b = 11011111b
-01011000b | 11010000b = 11011000b
-01011000b | 11010001b = 11011001b
-01011000b | 11010010b = 11011010b
-01011000b | 11010011b = 11011011b
-01011000b | 11010100b = 11011100b
-01011000b | 11010101b = 11011101b
-01011000b | 11010110b = 11011110b
-01011000b | 11010111b = 11011111b
-01011000b | 11011000b = 11011000b
-01011000b | 11011001b = 11011001b
-01011000b | 11011010b = 11011010b
-01011000b | 11011011b = 11011011b
-01011000b | 11011100b = 11011100b
-01011000b | 11011101b = 11011101b
-01011000b | 11011110b = 11011110b
-01011000b | 11011111b = 11011111b
-01011000b | 11100000b = 11111000b
-01011000b | 11100001b = 11111001b
-01011000b | 11100010b = 11111010b
-01011000b | 11100011b = 11111011b
-01011000b | 11100100b = 11111100b
-01011000b | 11100101b = 11111101b
-01011000b | 11100110b = 11111110b
-01011000b | 11100111b = 11111111b
-01011000b | 11101000b = 11111000b
-01011000b | 11101001b = 11111001b
-01011000b | 11101010b = 11111010b
-01011000b | 11101011b = 11111011b
-01011000b | 11101100b = 11111100b
-01011000b | 11101101b = 11111101b
-01011000b | 11101110b = 11111110b
-01011000b | 11101111b = 11111111b
-01011000b | 11110000b = 11111000b
-01011000b | 11110001b = 11111001b
-01011000b | 11110010b = 11111010b
-01011000b | 11110011b = 11111011b
-01011000b | 11110100b = 11111100b
-01011000b | 11110101b = 11111101b
-01011000b | 11110110b = 11111110b
-01011000b | 11110111b = 11111111b
-01011000b | 11111000b = 11111000b
-01011000b | 11111001b = 11111001b
-01011000b | 11111010b = 11111010b
-01011000b | 11111011b = 11111011b
-01011000b | 11111100b = 11111100b
-01011000b | 11111101b = 11111101b
-01011000b | 11111110b = 11111110b
-01011000b | 11111111b = 11111111b
-01011000b | 00000000b = 01011000b
-01011000b | 00000001b = 01011001b
-01011000b | 00000010b = 01011010b
-01011000b | 00000011b = 01011011b
-01011000b | 00000100b = 01011100b
-01011000b | 00000101b = 01011101b
-01011000b | 00000110b = 01011110b
-01011000b | 00000111b = 01011111b
-01011000b | 00001000b = 01011000b
-01011000b | 00001001b = 01011001b
-01011000b | 00001010b = 01011010b
-01011000b | 00001011b = 01011011b
-01011000b | 00001100b = 01011100b
-01011000b | 00001101b = 01011101b
-01011000b | 00001110b = 01011110b
-01011000b | 00001111b = 01011111b
-01011000b | 00010000b = 01011000b
-01011000b | 00010001b = 01011001b
-01011000b | 00010010b = 01011010b
-01011000b | 00010011b = 01011011b
-01011000b | 00010100b = 01011100b
-01011000b | 00010101b = 01011101b
-01011000b | 00010110b = 01011110b
-01011000b | 00010111b = 01011111b
-01011000b | 00011000b = 01011000b
-01011000b | 00011001b = 01011001b
-01011000b | 00011010b = 01011010b
-01011000b | 00011011b = 01011011b
-01011000b | 00011100b = 01011100b
-01011000b | 00011101b = 01011101b
-01011000b | 00011110b = 01011110b
-01011000b | 00011111b = 01011111b
-01011000b | 00100000b = 01111000b
-01011000b | 00100001b = 01111001b
-01011000b | 00100010b = 01111010b
-01011000b | 00100011b = 01111011b
-01011000b | 00100100b = 01111100b
-01011000b | 00100101b = 01111101b
-01011000b | 00100110b = 01111110b
-01011000b | 00100111b = 01111111b
-01011000b | 00101000b = 01111000b
-01011000b | 00101001b = 01111001b
-01011000b | 00101010b = 01111010b
-01011000b | 00101011b = 01111011b
-01011000b | 00101100b = 01111100b
-01011000b | 00101101b = 01111101b
-01011000b | 00101110b = 01111110b
-01011000b | 00101111b = 01111111b
-01011000b | 00110000b = 01111000b
-01011000b | 00110001b = 01111001b
-01011000b | 00110010b = 01111010b
-01011000b | 00110011b = 01111011b
-01011000b | 00110100b = 01111100b
-01011000b | 00110101b = 01111101b
-01011000b | 00110110b = 01111110b
-01011000b | 00110111b = 01111111b
-01011000b | 00111000b = 01111000b
-01011000b | 00111001b = 01111001b
-01011000b | 00111010b = 01111010b
-01011000b | 00111011b = 01111011b
-01011000b | 00111100b = 01111100b
-01011000b | 00111101b = 01111101b
-01011000b | 00111110b = 01111110b
-01011000b | 00111111b = 01111111b
-01011000b | 01000000b = 01011000b
-01011000b | 01000001b = 01011001b
-01011000b | 01000010b = 01011010b
-01011000b | 01000011b = 01011011b
-01011000b | 01000100b = 01011100b
-01011000b | 01000101b = 01011101b
-01011000b | 01000110b = 01011110b
-01011000b | 01000111b = 01011111b
-01011000b | 01001000b = 01011000b
-01011000b | 01001001b = 01011001b
-01011000b | 01001010b = 01011010b
-01011000b | 01001011b = 01011011b
-01011000b | 01001100b = 01011100b
-01011000b | 01001101b = 01011101b
-01011000b | 01001110b = 01011110b
-01011000b | 01001111b = 01011111b
-01011000b | 01010000b = 01011000b
-01011000b | 01010001b = 01011001b
-01011000b | 01010010b = 01011010b
-01011000b | 01010011b = 01011011b
-01011000b | 01010100b = 01011100b
-01011000b | 01010101b = 01011101b
-01011000b | 01010110b = 01011110b
-01011000b | 01010111b = 01011111b
-01011000b | 01011000b = 01011000b
-01011000b | 01011001b = 01011001b
-01011000b | 01011010b = 01011010b
-01011000b | 01011011b = 01011011b
-01011000b | 01011100b = 01011100b
-01011000b | 01011101b = 01011101b
-01011000b | 01011110b = 01011110b
-01011000b | 01011111b = 01011111b
-01011000b | 01100000b = 01111000b
-01011000b | 01100001b = 01111001b
-01011000b | 01100010b = 01111010b
-01011000b | 01100011b = 01111011b
-01011000b | 01100100b = 01111100b
-01011000b | 01100101b = 01111101b
-01011000b | 01100110b = 01111110b
-01011000b | 01100111b = 01111111b
-01011000b | 01101000b = 01111000b
-01011000b | 01101001b = 01111001b
-01011000b | 01101010b = 01111010b
-01011000b | 01101011b = 01111011b
-01011000b | 01101100b = 01111100b
-01011000b | 01101101b = 01111101b
-01011000b | 01101110b = 01111110b
-01011000b | 01101111b = 01111111b
-01011000b | 01110000b = 01111000b
-01011000b | 01110001b = 01111001b
-01011000b | 01110010b = 01111010b
-01011000b | 01110011b = 01111011b
-01011000b | 01110100b = 01111100b
-01011000b | 01110101b = 01111101b
-01011000b | 01110110b = 01111110b
-01011000b | 01110111b = 01111111b
-01011000b | 01111000b = 01111000b
-01011000b | 01111001b = 01111001b
-01011000b | 01111010b = 01111010b
-01011000b | 01111011b = 01111011b
-01011000b | 01111100b = 01111100b
-01011000b | 01111101b = 01111101b
-01011000b | 01111110b = 01111110b
-01011001b | 10000000b = 11011001b
-01011001b | 10000001b = 11011001b
-01011001b | 10000010b = 11011011b
-01011001b | 10000011b = 11011011b
-01011001b | 10000100b = 11011101b
-01011001b | 10000101b = 11011101b
-01011001b | 10000110b = 11011111b
-01011001b | 10000111b = 11011111b
-01011001b | 10001000b = 11011001b
-01011001b | 10001001b = 11011001b
-01011001b | 10001010b = 11011011b
-01011001b | 10001011b = 11011011b
-01011001b | 10001100b = 11011101b
-01011001b | 10001101b = 11011101b
-01011001b | 10001110b = 11011111b
-01011001b | 10001111b = 11011111b
-01011001b | 10010000b = 11011001b
-01011001b | 10010001b = 11011001b
-01011001b | 10010010b = 11011011b
-01011001b | 10010011b = 11011011b
-01011001b | 10010100b = 11011101b
-01011001b | 10010101b = 11011101b
-01011001b | 10010110b = 11011111b
-01011001b | 10010111b = 11011111b
-01011001b | 10011000b = 11011001b
-01011001b | 10011001b = 11011001b
-01011001b | 10011010b = 11011011b
-01011001b | 10011011b = 11011011b
-01011001b | 10011100b = 11011101b
-01011001b | 10011101b = 11011101b
-01011001b | 10011110b = 11011111b
-01011001b | 10011111b = 11011111b
-01011001b | 10100000b = 11111001b
-01011001b | 10100001b = 11111001b
-01011001b | 10100010b = 11111011b
-01011001b | 10100011b = 11111011b
-01011001b | 10100100b = 11111101b
-01011001b | 10100101b = 11111101b
-01011001b | 10100110b = 11111111b
-01011001b | 10100111b = 11111111b
-01011001b | 10101000b = 11111001b
-01011001b | 10101001b = 11111001b
-01011001b | 10101010b = 11111011b
-01011001b | 10101011b = 11111011b
-01011001b | 10101100b = 11111101b
-01011001b | 10101101b = 11111101b
-01011001b | 10101110b = 11111111b
-01011001b | 10101111b = 11111111b
-01011001b | 10110000b = 11111001b
-01011001b | 10110001b = 11111001b
-01011001b | 10110010b = 11111011b
-01011001b | 10110011b = 11111011b
-01011001b | 10110100b = 11111101b
-01011001b | 10110101b = 11111101b
-01011001b | 10110110b = 11111111b
-01011001b | 10110111b = 11111111b
-01011001b | 10111000b = 11111001b
-01011001b | 10111001b = 11111001b
-01011001b | 10111010b = 11111011b
-01011001b | 10111011b = 11111011b
-01011001b | 10111100b = 11111101b
-01011001b | 10111101b = 11111101b
-01011001b | 10111110b = 11111111b
-01011001b | 10111111b = 11111111b
-01011001b | 11000000b = 11011001b
-01011001b | 11000001b = 11011001b
-01011001b | 11000010b = 11011011b
-01011001b | 11000011b = 11011011b
-01011001b | 11000100b = 11011101b
-01011001b | 11000101b = 11011101b
-01011001b | 11000110b = 11011111b
-01011001b | 11000111b = 11011111b
-01011001b | 11001000b = 11011001b
-01011001b | 11001001b = 11011001b
-01011001b | 11001010b = 11011011b
-01011001b | 11001011b = 11011011b
-01011001b | 11001100b = 11011101b
-01011001b | 11001101b = 11011101b
-01011001b | 11001110b = 11011111b
-01011001b | 11001111b = 11011111b
-01011001b | 11010000b = 11011001b
-01011001b | 11010001b = 11011001b
-01011001b | 11010010b = 11011011b
-01011001b | 11010011b = 11011011b
-01011001b | 11010100b = 11011101b
-01011001b | 11010101b = 11011101b
-01011001b | 11010110b = 11011111b
-01011001b | 11010111b = 11011111b
-01011001b | 11011000b = 11011001b
-01011001b | 11011001b = 11011001b
-01011001b | 11011010b = 11011011b
-01011001b | 11011011b = 11011011b
-01011001b | 11011100b = 11011101b
-01011001b | 11011101b = 11011101b
-01011001b | 11011110b = 11011111b
-01011001b | 11011111b = 11011111b
-01011001b | 11100000b = 11111001b
-01011001b | 11100001b = 11111001b
-01011001b | 11100010b = 11111011b
-01011001b | 11100011b = 11111011b
-01011001b | 11100100b = 11111101b
-01011001b | 11100101b = 11111101b
-01011001b | 11100110b = 11111111b
-01011001b | 11100111b = 11111111b
-01011001b | 11101000b = 11111001b
-01011001b | 11101001b = 11111001b
-01011001b | 11101010b = 11111011b
-01011001b | 11101011b = 11111011b
-01011001b | 11101100b = 11111101b
-01011001b | 11101101b = 11111101b
-01011001b | 11101110b = 11111111b
-01011001b | 11101111b = 11111111b
-01011001b | 11110000b = 11111001b
-01011001b | 11110001b = 11111001b
-01011001b | 11110010b = 11111011b
-01011001b | 11110011b = 11111011b
-01011001b | 11110100b = 11111101b
-01011001b | 11110101b = 11111101b
-01011001b | 11110110b = 11111111b
-01011001b | 11110111b = 11111111b
-01011001b | 11111000b = 11111001b
-01011001b | 11111001b = 11111001b
-01011001b | 11111010b = 11111011b
-01011001b | 11111011b = 11111011b
-01011001b | 11111100b = 11111101b
-01011001b | 11111101b = 11111101b
-01011001b | 11111110b = 11111111b
-01011001b | 11111111b = 11111111b
-01011001b | 00000000b = 01011001b
-01011001b | 00000001b = 01011001b
-01011001b | 00000010b = 01011011b
-01011001b | 00000011b = 01011011b
-01011001b | 00000100b = 01011101b
-01011001b | 00000101b = 01011101b
-01011001b | 00000110b = 01011111b
-01011001b | 00000111b = 01011111b
-01011001b | 00001000b = 01011001b
-01011001b | 00001001b = 01011001b
-01011001b | 00001010b = 01011011b
-01011001b | 00001011b = 01011011b
-01011001b | 00001100b = 01011101b
-01011001b | 00001101b = 01011101b
-01011001b | 00001110b = 01011111b
-01011001b | 00001111b = 01011111b
-01011001b | 00010000b = 01011001b
-01011001b | 00010001b = 01011001b
-01011001b | 00010010b = 01011011b
-01011001b | 00010011b = 01011011b
-01011001b | 00010100b = 01011101b
-01011001b | 00010101b = 01011101b
-01011001b | 00010110b = 01011111b
-01011001b | 00010111b = 01011111b
-01011001b | 00011000b = 01011001b
-01011001b | 00011001b = 01011001b
-01011001b | 00011010b = 01011011b
-01011001b | 00011011b = 01011011b
-01011001b | 00011100b = 01011101b
-01011001b | 00011101b = 01011101b
-01011001b | 00011110b = 01011111b
-01011001b | 00011111b = 01011111b
-01011001b | 00100000b = 01111001b
-01011001b | 00100001b = 01111001b
-01011001b | 00100010b = 01111011b
-01011001b | 00100011b = 01111011b
-01011001b | 00100100b = 01111101b
-01011001b | 00100101b = 01111101b
-01011001b | 00100110b = 01111111b
-01011001b | 00100111b = 01111111b
-01011001b | 00101000b = 01111001b
-01011001b | 00101001b = 01111001b
-01011001b | 00101010b = 01111011b
-01011001b | 00101011b = 01111011b
-01011001b | 00101100b = 01111101b
-01011001b | 00101101b = 01111101b
-01011001b | 00101110b = 01111111b
-01011001b | 00101111b = 01111111b
-01011001b | 00110000b = 01111001b
-01011001b | 00110001b = 01111001b
-01011001b | 00110010b = 01111011b
-01011001b | 00110011b = 01111011b
-01011001b | 00110100b = 01111101b
-01011001b | 00110101b = 01111101b
-01011001b | 00110110b = 01111111b
-01011001b | 00110111b = 01111111b
-01011001b | 00111000b = 01111001b
-01011001b | 00111001b = 01111001b
-01011001b | 00111010b = 01111011b
-01011001b | 00111011b = 01111011b
-01011001b | 00111100b = 01111101b
-01011001b | 00111101b = 01111101b
-01011001b | 00111110b = 01111111b
-01011001b | 00111111b = 01111111b
-01011001b | 01000000b = 01011001b
-01011001b | 01000001b = 01011001b
-01011001b | 01000010b = 01011011b
-01011001b | 01000011b = 01011011b
-01011001b | 01000100b = 01011101b
-01011001b | 01000101b = 01011101b
-01011001b | 01000110b = 01011111b
-01011001b | 01000111b = 01011111b
-01011001b | 01001000b = 01011001b
-01011001b | 01001001b = 01011001b
-01011001b | 01001010b = 01011011b
-01011001b | 01001011b = 01011011b
-01011001b | 01001100b = 01011101b
-01011001b | 01001101b = 01011101b
-01011001b | 01001110b = 01011111b
-01011001b | 01001111b = 01011111b
-01011001b | 01010000b = 01011001b
-01011001b | 01010001b = 01011001b
-01011001b | 01010010b = 01011011b
-01011001b | 01010011b = 01011011b
-01011001b | 01010100b = 01011101b
-01011001b | 01010101b = 01011101b
-01011001b | 01010110b = 01011111b
-01011001b | 01010111b = 01011111b
-01011001b | 01011000b = 01011001b
-01011001b | 01011001b = 01011001b
-01011001b | 01011010b = 01011011b
-01011001b | 01011011b = 01011011b
-01011001b | 01011100b = 01011101b
-01011001b | 01011101b = 01011101b
-01011001b | 01011110b = 01011111b
-01011001b | 01011111b = 01011111b
-01011001b | 01100000b = 01111001b
-01011001b | 01100001b = 01111001b
-01011001b | 01100010b = 01111011b
-01011001b | 01100011b = 01111011b
-01011001b | 01100100b = 01111101b
-01011001b | 01100101b = 01111101b
-01011001b | 01100110b = 01111111b
-01011001b | 01100111b = 01111111b
-01011001b | 01101000b = 01111001b
-01011001b | 01101001b = 01111001b
-01011001b | 01101010b = 01111011b
-01011001b | 01101011b = 01111011b
-01011001b | 01101100b = 01111101b
-01011001b | 01101101b = 01111101b
-01011001b | 01101110b = 01111111b
-01011001b | 01101111b = 01111111b
-01011001b | 01110000b = 01111001b
-01011001b | 01110001b = 01111001b
-01011001b | 01110010b = 01111011b
-01011001b | 01110011b = 01111011b
-01011001b | 01110100b = 01111101b
-01011001b | 01110101b = 01111101b
-01011001b | 01110110b = 01111111b
-01011001b | 01110111b = 01111111b
-01011001b | 01111000b = 01111001b
-01011001b | 01111001b = 01111001b
-01011001b | 01111010b = 01111011b
-01011001b | 01111011b = 01111011b
-01011001b | 01111100b = 01111101b
-01011001b | 01111101b = 01111101b
-01011001b | 01111110b = 01111111b
-01011010b | 10000000b = 11011010b
-01011010b | 10000001b = 11011011b
-01011010b | 10000010b = 11011010b
-01011010b | 10000011b = 11011011b
-01011010b | 10000100b = 11011110b
-01011010b | 10000101b = 11011111b
-01011010b | 10000110b = 11011110b
-01011010b | 10000111b = 11011111b
-01011010b | 10001000b = 11011010b
-01011010b | 10001001b = 11011011b
-01011010b | 10001010b = 11011010b
-01011010b | 10001011b = 11011011b
-01011010b | 10001100b = 11011110b
-01011010b | 10001101b = 11011111b
-01011010b | 10001110b = 11011110b
-01011010b | 10001111b = 11011111b
-01011010b | 10010000b = 11011010b
-01011010b | 10010001b = 11011011b
-01011010b | 10010010b = 11011010b
-01011010b | 10010011b = 11011011b
-01011010b | 10010100b = 11011110b
-01011010b | 10010101b = 11011111b
-01011010b | 10010110b = 11011110b
-01011010b | 10010111b = 11011111b
-01011010b | 10011000b = 11011010b
-01011010b | 10011001b = 11011011b
-01011010b | 10011010b = 11011010b
-01011010b | 10011011b = 11011011b
-01011010b | 10011100b = 11011110b
-01011010b | 10011101b = 11011111b
-01011010b | 10011110b = 11011110b
-01011010b | 10011111b = 11011111b
-01011010b | 10100000b = 11111010b
-01011010b | 10100001b = 11111011b
-01011010b | 10100010b = 11111010b
-01011010b | 10100011b = 11111011b
-01011010b | 10100100b = 11111110b
-01011010b | 10100101b = 11111111b
-01011010b | 10100110b = 11111110b
-01011010b | 10100111b = 11111111b
-01011010b | 10101000b = 11111010b
-01011010b | 10101001b = 11111011b
-01011010b | 10101010b = 11111010b
-01011010b | 10101011b = 11111011b
-01011010b | 10101100b = 11111110b
-01011010b | 10101101b = 11111111b
-01011010b | 10101110b = 11111110b
-01011010b | 10101111b = 11111111b
-01011010b | 10110000b = 11111010b
-01011010b | 10110001b = 11111011b
-01011010b | 10110010b = 11111010b
-01011010b | 10110011b = 11111011b
-01011010b | 10110100b = 11111110b
-01011010b | 10110101b = 11111111b
-01011010b | 10110110b = 11111110b
-01011010b | 10110111b = 11111111b
-01011010b | 10111000b = 11111010b
-01011010b | 10111001b = 11111011b
-01011010b | 10111010b = 11111010b
-01011010b | 10111011b = 11111011b
-01011010b | 10111100b = 11111110b
-01011010b | 10111101b = 11111111b
-01011010b | 10111110b = 11111110b
-01011010b | 10111111b = 11111111b
-01011010b | 11000000b = 11011010b
-01011010b | 11000001b = 11011011b
-01011010b | 11000010b = 11011010b
-01011010b | 11000011b = 11011011b
-01011010b | 11000100b = 11011110b
-01011010b | 11000101b = 11011111b
-01011010b | 11000110b = 11011110b
-01011010b | 11000111b = 11011111b
-01011010b | 11001000b = 11011010b
-01011010b | 11001001b = 11011011b
-01011010b | 11001010b = 11011010b
-01011010b | 11001011b = 11011011b
-01011010b | 11001100b = 11011110b
-01011010b | 11001101b = 11011111b
-01011010b | 11001110b = 11011110b
-01011010b | 11001111b = 11011111b
-01011010b | 11010000b = 11011010b
-01011010b | 11010001b = 11011011b
-01011010b | 11010010b = 11011010b
-01011010b | 11010011b = 11011011b
-01011010b | 11010100b = 11011110b
-01011010b | 11010101b = 11011111b
-01011010b | 11010110b = 11011110b
-01011010b | 11010111b = 11011111b
-01011010b | 11011000b = 11011010b
-01011010b | 11011001b = 11011011b
-01011010b | 11011010b = 11011010b
-01011010b | 11011011b = 11011011b
-01011010b | 11011100b = 11011110b
-01011010b | 11011101b = 11011111b
-01011010b | 11011110b = 11011110b
-01011010b | 11011111b = 11011111b
-01011010b | 11100000b = 11111010b
-01011010b | 11100001b = 11111011b
-01011010b | 11100010b = 11111010b
-01011010b | 11100011b = 11111011b
-01011010b | 11100100b = 11111110b
-01011010b | 11100101b = 11111111b
-01011010b | 11100110b = 11111110b
-01011010b | 11100111b = 11111111b
-01011010b | 11101000b = 11111010b
-01011010b | 11101001b = 11111011b
-01011010b | 11101010b = 11111010b
-01011010b | 11101011b = 11111011b
-01011010b | 11101100b = 11111110b
-01011010b | 11101101b = 11111111b
-01011010b | 11101110b = 11111110b
-01011010b | 11101111b = 11111111b
-01011010b | 11110000b = 11111010b
-01011010b | 11110001b = 11111011b
-01011010b | 11110010b = 11111010b
-01011010b | 11110011b = 11111011b
-01011010b | 11110100b = 11111110b
-01011010b | 11110101b = 11111111b
-01011010b | 11110110b = 11111110b
-01011010b | 11110111b = 11111111b
-01011010b | 11111000b = 11111010b
-01011010b | 11111001b = 11111011b
-01011010b | 11111010b = 11111010b
-01011010b | 11111011b = 11111011b
-01011010b | 11111100b = 11111110b
-01011010b | 11111101b = 11111111b
-01011010b | 11111110b = 11111110b
-01011010b | 11111111b = 11111111b
-01011010b | 00000000b = 01011010b
-01011010b | 00000001b = 01011011b
-01011010b | 00000010b = 01011010b
-01011010b | 00000011b = 01011011b
-01011010b | 00000100b = 01011110b
-01011010b | 00000101b = 01011111b
-01011010b | 00000110b = 01011110b
-01011010b | 00000111b = 01011111b
-01011010b | 00001000b = 01011010b
-01011010b | 00001001b = 01011011b
-01011010b | 00001010b = 01011010b
-01011010b | 00001011b = 01011011b
-01011010b | 00001100b = 01011110b
-01011010b | 00001101b = 01011111b
-01011010b | 00001110b = 01011110b
-01011010b | 00001111b = 01011111b
-01011010b | 00010000b = 01011010b
-01011010b | 00010001b = 01011011b
-01011010b | 00010010b = 01011010b
-01011010b | 00010011b = 01011011b
-01011010b | 00010100b = 01011110b
-01011010b | 00010101b = 01011111b
-01011010b | 00010110b = 01011110b
-01011010b | 00010111b = 01011111b
-01011010b | 00011000b = 01011010b
-01011010b | 00011001b = 01011011b
-01011010b | 00011010b = 01011010b
-01011010b | 00011011b = 01011011b
-01011010b | 00011100b = 01011110b
-01011010b | 00011101b = 01011111b
-01011010b | 00011110b = 01011110b
-01011010b | 00011111b = 01011111b
-01011010b | 00100000b = 01111010b
-01011010b | 00100001b = 01111011b
-01011010b | 00100010b = 01111010b
-01011010b | 00100011b = 01111011b
-01011010b | 00100100b = 01111110b
-01011010b | 00100101b = 01111111b
-01011010b | 00100110b = 01111110b
-01011010b | 00100111b = 01111111b
-01011010b | 00101000b = 01111010b
-01011010b | 00101001b = 01111011b
-01011010b | 00101010b = 01111010b
-01011010b | 00101011b = 01111011b
-01011010b | 00101100b = 01111110b
-01011010b | 00101101b = 01111111b
-01011010b | 00101110b = 01111110b
-01011010b | 00101111b = 01111111b
-01011010b | 00110000b = 01111010b
-01011010b | 00110001b = 01111011b
-01011010b | 00110010b = 01111010b
-01011010b | 00110011b = 01111011b
-01011010b | 00110100b = 01111110b
-01011010b | 00110101b = 01111111b
-01011010b | 00110110b = 01111110b
-01011010b | 00110111b = 01111111b
-01011010b | 00111000b = 01111010b
-01011010b | 00111001b = 01111011b
-01011010b | 00111010b = 01111010b
-01011010b | 00111011b = 01111011b
-01011010b | 00111100b = 01111110b
-01011010b | 00111101b = 01111111b
-01011010b | 00111110b = 01111110b
-01011010b | 00111111b = 01111111b
-01011010b | 01000000b = 01011010b
-01011010b | 01000001b = 01011011b
-01011010b | 01000010b = 01011010b
-01011010b | 01000011b = 01011011b
-01011010b | 01000100b = 01011110b
-01011010b | 01000101b = 01011111b
-01011010b | 01000110b = 01011110b
-01011010b | 01000111b = 01011111b
-01011010b | 01001000b = 01011010b
-01011010b | 01001001b = 01011011b
-01011010b | 01001010b = 01011010b
-01011010b | 01001011b = 01011011b
-01011010b | 01001100b = 01011110b
-01011010b | 01001101b = 01011111b
-01011010b | 01001110b = 01011110b
-01011010b | 01001111b = 01011111b
-01011010b | 01010000b = 01011010b
-01011010b | 01010001b = 01011011b
-01011010b | 01010010b = 01011010b
-01011010b | 01010011b = 01011011b
-01011010b | 01010100b = 01011110b
-01011010b | 01010101b = 01011111b
-01011010b | 01010110b = 01011110b
-01011010b | 01010111b = 01011111b
-01011010b | 01011000b = 01011010b
-01011010b | 01011001b = 01011011b
-01011010b | 01011010b = 01011010b
-01011010b | 01011011b = 01011011b
-01011010b | 01011100b = 01011110b
-01011010b | 01011101b = 01011111b
-01011010b | 01011110b = 01011110b
-01011010b | 01011111b = 01011111b
-01011010b | 01100000b = 01111010b
-01011010b | 01100001b = 01111011b
-01011010b | 01100010b = 01111010b
-01011010b | 01100011b = 01111011b
-01011010b | 01100100b = 01111110b
-01011010b | 01100101b = 01111111b
-01011010b | 01100110b = 01111110b
-01011010b | 01100111b = 01111111b
-01011010b | 01101000b = 01111010b
-01011010b | 01101001b = 01111011b
-01011010b | 01101010b = 01111010b
-01011010b | 01101011b = 01111011b
-01011010b | 01101100b = 01111110b
-01011010b | 01101101b = 01111111b
-01011010b | 01101110b = 01111110b
-01011010b | 01101111b = 01111111b
-01011010b | 01110000b = 01111010b
-01011010b | 01110001b = 01111011b
-01011010b | 01110010b = 01111010b
-01011010b | 01110011b = 01111011b
-01011010b | 01110100b = 01111110b
-01011010b | 01110101b = 01111111b
-01011010b | 01110110b = 01111110b
-01011010b | 01110111b = 01111111b
-01011010b | 01111000b = 01111010b
-01011010b | 01111001b = 01111011b
-01011010b | 01111010b = 01111010b
-01011010b | 01111011b = 01111011b
-01011010b | 01111100b = 01111110b
-01011010b | 01111101b = 01111111b
-01011010b | 01111110b = 01111110b
-01011011b | 10000000b = 11011011b
-01011011b | 10000001b = 11011011b
-01011011b | 10000010b = 11011011b
-01011011b | 10000011b = 11011011b
-01011011b | 10000100b = 11011111b
-01011011b | 10000101b = 11011111b
-01011011b | 10000110b = 11011111b
-01011011b | 10000111b = 11011111b
-01011011b | 10001000b = 11011011b
-01011011b | 10001001b = 11011011b
-01011011b | 10001010b = 11011011b
-01011011b | 10001011b = 11011011b
-01011011b | 10001100b = 11011111b
-01011011b | 10001101b = 11011111b
-01011011b | 10001110b = 11011111b
-01011011b | 10001111b = 11011111b
-01011011b | 10010000b = 11011011b
-01011011b | 10010001b = 11011011b
-01011011b | 10010010b = 11011011b
-01011011b | 10010011b = 11011011b
-01011011b | 10010100b = 11011111b
-01011011b | 10010101b = 11011111b
-01011011b | 10010110b = 11011111b
-01011011b | 10010111b = 11011111b
-01011011b | 10011000b = 11011011b
-01011011b | 10011001b = 11011011b
-01011011b | 10011010b = 11011011b
-01011011b | 10011011b = 11011011b
-01011011b | 10011100b = 11011111b
-01011011b | 10011101b = 11011111b
-01011011b | 10011110b = 11011111b
-01011011b | 10011111b = 11011111b
-01011011b | 10100000b = 11111011b
-01011011b | 10100001b = 11111011b
-01011011b | 10100010b = 11111011b
-01011011b | 10100011b = 11111011b
-01011011b | 10100100b = 11111111b
-01011011b | 10100101b = 11111111b
-01011011b | 10100110b = 11111111b
-01011011b | 10100111b = 11111111b
-01011011b | 10101000b = 11111011b
-01011011b | 10101001b = 11111011b
-01011011b | 10101010b = 11111011b
-01011011b | 10101011b = 11111011b
-01011011b | 10101100b = 11111111b
-01011011b | 10101101b = 11111111b
-01011011b | 10101110b = 11111111b
-01011011b | 10101111b = 11111111b
-01011011b | 10110000b = 11111011b
-01011011b | 10110001b = 11111011b
-01011011b | 10110010b = 11111011b
-01011011b | 10110011b = 11111011b
-01011011b | 10110100b = 11111111b
-01011011b | 10110101b = 11111111b
-01011011b | 10110110b = 11111111b
-01011011b | 10110111b = 11111111b
-01011011b | 10111000b = 11111011b
-01011011b | 10111001b = 11111011b
-01011011b | 10111010b = 11111011b
-01011011b | 10111011b = 11111011b
-01011011b | 10111100b = 11111111b
-01011011b | 10111101b = 11111111b
-01011011b | 10111110b = 11111111b
-01011011b | 10111111b = 11111111b
-01011011b | 11000000b = 11011011b
-01011011b | 11000001b = 11011011b
-01011011b | 11000010b = 11011011b
-01011011b | 11000011b = 11011011b
-01011011b | 11000100b = 11011111b
-01011011b | 11000101b = 11011111b
-01011011b | 11000110b = 11011111b
-01011011b | 11000111b = 11011111b
-01011011b | 11001000b = 11011011b
-01011011b | 11001001b = 11011011b
-01011011b | 11001010b = 11011011b
-01011011b | 11001011b = 11011011b
-01011011b | 11001100b = 11011111b
-01011011b | 11001101b = 11011111b
-01011011b | 11001110b = 11011111b
-01011011b | 11001111b = 11011111b
-01011011b | 11010000b = 11011011b
-01011011b | 11010001b = 11011011b
-01011011b | 11010010b = 11011011b
-01011011b | 11010011b = 11011011b
-01011011b | 11010100b = 11011111b
-01011011b | 11010101b = 11011111b
-01011011b | 11010110b = 11011111b
-01011011b | 11010111b = 11011111b
-01011011b | 11011000b = 11011011b
-01011011b | 11011001b = 11011011b
-01011011b | 11011010b = 11011011b
-01011011b | 11011011b = 11011011b
-01011011b | 11011100b = 11011111b
-01011011b | 11011101b = 11011111b
-01011011b | 11011110b = 11011111b
-01011011b | 11011111b = 11011111b
-01011011b | 11100000b = 11111011b
-01011011b | 11100001b = 11111011b
-01011011b | 11100010b = 11111011b
-01011011b | 11100011b = 11111011b
-01011011b | 11100100b = 11111111b
-01011011b | 11100101b = 11111111b
-01011011b | 11100110b = 11111111b
-01011011b | 11100111b = 11111111b
-01011011b | 11101000b = 11111011b
-01011011b | 11101001b = 11111011b
-01011011b | 11101010b = 11111011b
-01011011b | 11101011b = 11111011b
-01011011b | 11101100b = 11111111b
-01011011b | 11101101b = 11111111b
-01011011b | 11101110b = 11111111b
-01011011b | 11101111b = 11111111b
-01011011b | 11110000b = 11111011b
-01011011b | 11110001b = 11111011b
-01011011b | 11110010b = 11111011b
-01011011b | 11110011b = 11111011b
-01011011b | 11110100b = 11111111b
-01011011b | 11110101b = 11111111b
-01011011b | 11110110b = 11111111b
-01011011b | 11110111b = 11111111b
-01011011b | 11111000b = 11111011b
-01011011b | 11111001b = 11111011b
-01011011b | 11111010b = 11111011b
-01011011b | 11111011b = 11111011b
-01011011b | 11111100b = 11111111b
-01011011b | 11111101b = 11111111b
-01011011b | 11111110b = 11111111b
-01011011b | 11111111b = 11111111b
-01011011b | 00000000b = 01011011b
-01011011b | 00000001b = 01011011b
-01011011b | 00000010b = 01011011b
-01011011b | 00000011b = 01011011b
-01011011b | 00000100b = 01011111b
-01011011b | 00000101b = 01011111b
-01011011b | 00000110b = 01011111b
-01011011b | 00000111b = 01011111b
-01011011b | 00001000b = 01011011b
-01011011b | 00001001b = 01011011b
-01011011b | 00001010b = 01011011b
-01011011b | 00001011b = 01011011b
-01011011b | 00001100b = 01011111b
-01011011b | 00001101b = 01011111b
-01011011b | 00001110b = 01011111b
-01011011b | 00001111b = 01011111b
-01011011b | 00010000b = 01011011b
-01011011b | 00010001b = 01011011b
-01011011b | 00010010b = 01011011b
-01011011b | 00010011b = 01011011b
-01011011b | 00010100b = 01011111b
-01011011b | 00010101b = 01011111b
-01011011b | 00010110b = 01011111b
-01011011b | 00010111b = 01011111b
-01011011b | 00011000b = 01011011b
-01011011b | 00011001b = 01011011b
-01011011b | 00011010b = 01011011b
-01011011b | 00011011b = 01011011b
-01011011b | 00011100b = 01011111b
-01011011b | 00011101b = 01011111b
-01011011b | 00011110b = 01011111b
-01011011b | 00011111b = 01011111b
-01011011b | 00100000b = 01111011b
-01011011b | 00100001b = 01111011b
-01011011b | 00100010b = 01111011b
-01011011b | 00100011b = 01111011b
-01011011b | 00100100b = 01111111b
-01011011b | 00100101b = 01111111b
-01011011b | 00100110b = 01111111b
-01011011b | 00100111b = 01111111b
-01011011b | 00101000b = 01111011b
-01011011b | 00101001b = 01111011b
-01011011b | 00101010b = 01111011b
-01011011b | 00101011b = 01111011b
-01011011b | 00101100b = 01111111b
-01011011b | 00101101b = 01111111b
-01011011b | 00101110b = 01111111b
-01011011b | 00101111b = 01111111b
-01011011b | 00110000b = 01111011b
-01011011b | 00110001b = 01111011b
-01011011b | 00110010b = 01111011b
-01011011b | 00110011b = 01111011b
-01011011b | 00110100b = 01111111b
-01011011b | 00110101b = 01111111b
-01011011b | 00110110b = 01111111b
-01011011b | 00110111b = 01111111b
-01011011b | 00111000b = 01111011b
-01011011b | 00111001b = 01111011b
-01011011b | 00111010b = 01111011b
-01011011b | 00111011b = 01111011b
-01011011b | 00111100b = 01111111b
-01011011b | 00111101b = 01111111b
-01011011b | 00111110b = 01111111b
-01011011b | 00111111b = 01111111b
-01011011b | 01000000b = 01011011b
-01011011b | 01000001b = 01011011b
-01011011b | 01000010b = 01011011b
-01011011b | 01000011b = 01011011b
-01011011b | 01000100b = 01011111b
-01011011b | 01000101b = 01011111b
-01011011b | 01000110b = 01011111b
-01011011b | 01000111b = 01011111b
-01011011b | 01001000b = 01011011b
-01011011b | 01001001b = 01011011b
-01011011b | 01001010b = 01011011b
-01011011b | 01001011b = 01011011b
-01011011b | 01001100b = 01011111b
-01011011b | 01001101b = 01011111b
-01011011b | 01001110b = 01011111b
-01011011b | 01001111b = 01011111b
-01011011b | 01010000b = 01011011b
-01011011b | 01010001b = 01011011b
-01011011b | 01010010b = 01011011b
-01011011b | 01010011b = 01011011b
-01011011b | 01010100b = 01011111b
-01011011b | 01010101b = 01011111b
-01011011b | 01010110b = 01011111b
-01011011b | 01010111b = 01011111b
-01011011b | 01011000b = 01011011b
-01011011b | 01011001b = 01011011b
-01011011b | 01011010b = 01011011b
-01011011b | 01011011b = 01011011b
-01011011b | 01011100b = 01011111b
-01011011b | 01011101b = 01011111b
-01011011b | 01011110b = 01011111b
-01011011b | 01011111b = 01011111b
-01011011b | 01100000b = 01111011b
-01011011b | 01100001b = 01111011b
-01011011b | 01100010b = 01111011b
-01011011b | 01100011b = 01111011b
-01011011b | 01100100b = 01111111b
-01011011b | 01100101b = 01111111b
-01011011b | 01100110b = 01111111b
-01011011b | 01100111b = 01111111b
-01011011b | 01101000b = 01111011b
-01011011b | 01101001b = 01111011b
-01011011b | 01101010b = 01111011b
-01011011b | 01101011b = 01111011b
-01011011b | 01101100b = 01111111b
-01011011b | 01101101b = 01111111b
-01011011b | 01101110b = 01111111b
-01011011b | 01101111b = 01111111b
-01011011b | 01110000b = 01111011b
-01011011b | 01110001b = 01111011b
-01011011b | 01110010b = 01111011b
-01011011b | 01110011b = 01111011b
-01011011b | 01110100b = 01111111b
-01011011b | 01110101b = 01111111b
-01011011b | 01110110b = 01111111b
-01011011b | 01110111b = 01111111b
-01011011b | 01111000b = 01111011b
-01011011b | 01111001b = 01111011b
-01011011b | 01111010b = 01111011b
-01011011b | 01111011b = 01111011b
-01011011b | 01111100b = 01111111b
-01011011b | 01111101b = 01111111b
-01011011b | 01111110b = 01111111b
-01011100b | 10000000b = 11011100b
-01011100b | 10000001b = 11011101b
-01011100b | 10000010b = 11011110b
-01011100b | 10000011b = 11011111b
-01011100b | 10000100b = 11011100b
-01011100b | 10000101b = 11011101b
-01011100b | 10000110b = 11011110b
-01011100b | 10000111b = 11011111b
-01011100b | 10001000b = 11011100b
-01011100b | 10001001b = 11011101b
-01011100b | 10001010b = 11011110b
-01011100b | 10001011b = 11011111b
-01011100b | 10001100b = 11011100b
-01011100b | 10001101b = 11011101b
-01011100b | 10001110b = 11011110b
-01011100b | 10001111b = 11011111b
-01011100b | 10010000b = 11011100b
-01011100b | 10010001b = 11011101b
-01011100b | 10010010b = 11011110b
-01011100b | 10010011b = 11011111b
-01011100b | 10010100b = 11011100b
-01011100b | 10010101b = 11011101b
-01011100b | 10010110b = 11011110b
-01011100b | 10010111b = 11011111b
-01011100b | 10011000b = 11011100b
-01011100b | 10011001b = 11011101b
-01011100b | 10011010b = 11011110b
-01011100b | 10011011b = 11011111b
-01011100b | 10011100b = 11011100b
-01011100b | 10011101b = 11011101b
-01011100b | 10011110b = 11011110b
-01011100b | 10011111b = 11011111b
-01011100b | 10100000b = 11111100b
-01011100b | 10100001b = 11111101b
-01011100b | 10100010b = 11111110b
-01011100b | 10100011b = 11111111b
-01011100b | 10100100b = 11111100b
-01011100b | 10100101b = 11111101b
-01011100b | 10100110b = 11111110b
-01011100b | 10100111b = 11111111b
-01011100b | 10101000b = 11111100b
-01011100b | 10101001b = 11111101b
-01011100b | 10101010b = 11111110b
-01011100b | 10101011b = 11111111b
-01011100b | 10101100b = 11111100b
-01011100b | 10101101b = 11111101b
-01011100b | 10101110b = 11111110b
-01011100b | 10101111b = 11111111b
-01011100b | 10110000b = 11111100b
-01011100b | 10110001b = 11111101b
-01011100b | 10110010b = 11111110b
-01011100b | 10110011b = 11111111b
-01011100b | 10110100b = 11111100b
-01011100b | 10110101b = 11111101b
-01011100b | 10110110b = 11111110b
-01011100b | 10110111b = 11111111b
-01011100b | 10111000b = 11111100b
-01011100b | 10111001b = 11111101b
-01011100b | 10111010b = 11111110b
-01011100b | 10111011b = 11111111b
-01011100b | 10111100b = 11111100b
-01011100b | 10111101b = 11111101b
-01011100b | 10111110b = 11111110b
-01011100b | 10111111b = 11111111b
-01011100b | 11000000b = 11011100b
-01011100b | 11000001b = 11011101b
-01011100b | 11000010b = 11011110b
-01011100b | 11000011b = 11011111b
-01011100b | 11000100b = 11011100b
-01011100b | 11000101b = 11011101b
-01011100b | 11000110b = 11011110b
-01011100b | 11000111b = 11011111b
-01011100b | 11001000b = 11011100b
-01011100b | 11001001b = 11011101b
-01011100b | 11001010b = 11011110b
-01011100b | 11001011b = 11011111b
-01011100b | 11001100b = 11011100b
-01011100b | 11001101b = 11011101b
-01011100b | 11001110b = 11011110b
-01011100b | 11001111b = 11011111b
-01011100b | 11010000b = 11011100b
-01011100b | 11010001b = 11011101b
-01011100b | 11010010b = 11011110b
-01011100b | 11010011b = 11011111b
-01011100b | 11010100b = 11011100b
-01011100b | 11010101b = 11011101b
-01011100b | 11010110b = 11011110b
-01011100b | 11010111b = 11011111b
-01011100b | 11011000b = 11011100b
-01011100b | 11011001b = 11011101b
-01011100b | 11011010b = 11011110b
-01011100b | 11011011b = 11011111b
-01011100b | 11011100b = 11011100b
-01011100b | 11011101b = 11011101b
-01011100b | 11011110b = 11011110b
-01011100b | 11011111b = 11011111b
-01011100b | 11100000b = 11111100b
-01011100b | 11100001b = 11111101b
-01011100b | 11100010b = 11111110b
-01011100b | 11100011b = 11111111b
-01011100b | 11100100b = 11111100b
-01011100b | 11100101b = 11111101b
-01011100b | 11100110b = 11111110b
-01011100b | 11100111b = 11111111b
-01011100b | 11101000b = 11111100b
-01011100b | 11101001b = 11111101b
-01011100b | 11101010b = 11111110b
-01011100b | 11101011b = 11111111b
-01011100b | 11101100b = 11111100b
-01011100b | 11101101b = 11111101b
-01011100b | 11101110b = 11111110b
-01011100b | 11101111b = 11111111b
-01011100b | 11110000b = 11111100b
-01011100b | 11110001b = 11111101b
-01011100b | 11110010b = 11111110b
-01011100b | 11110011b = 11111111b
-01011100b | 11110100b = 11111100b
-01011100b | 11110101b = 11111101b
-01011100b | 11110110b = 11111110b
-01011100b | 11110111b = 11111111b
-01011100b | 11111000b = 11111100b
-01011100b | 11111001b = 11111101b
-01011100b | 11111010b = 11111110b
-01011100b | 11111011b = 11111111b
-01011100b | 11111100b = 11111100b
-01011100b | 11111101b = 11111101b
-01011100b | 11111110b = 11111110b
-01011100b | 11111111b = 11111111b
-01011100b | 00000000b = 01011100b
-01011100b | 00000001b = 01011101b
-01011100b | 00000010b = 01011110b
-01011100b | 00000011b = 01011111b
-01011100b | 00000100b = 01011100b
-01011100b | 00000101b = 01011101b
-01011100b | 00000110b = 01011110b
-01011100b | 00000111b = 01011111b
-01011100b | 00001000b = 01011100b
-01011100b | 00001001b = 01011101b
-01011100b | 00001010b = 01011110b
-01011100b | 00001011b = 01011111b
-01011100b | 00001100b = 01011100b
-01011100b | 00001101b = 01011101b
-01011100b | 00001110b = 01011110b
-01011100b | 00001111b = 01011111b
-01011100b | 00010000b = 01011100b
-01011100b | 00010001b = 01011101b
-01011100b | 00010010b = 01011110b
-01011100b | 00010011b = 01011111b
-01011100b | 00010100b = 01011100b
-01011100b | 00010101b = 01011101b
-01011100b | 00010110b = 01011110b
-01011100b | 00010111b = 01011111b
-01011100b | 00011000b = 01011100b
-01011100b | 00011001b = 01011101b
-01011100b | 00011010b = 01011110b
-01011100b | 00011011b = 01011111b
-01011100b | 00011100b = 01011100b
-01011100b | 00011101b = 01011101b
-01011100b | 00011110b = 01011110b
-01011100b | 00011111b = 01011111b
-01011100b | 00100000b = 01111100b
-01011100b | 00100001b = 01111101b
-01011100b | 00100010b = 01111110b
-01011100b | 00100011b = 01111111b
-01011100b | 00100100b = 01111100b
-01011100b | 00100101b = 01111101b
-01011100b | 00100110b = 01111110b
-01011100b | 00100111b = 01111111b
-01011100b | 00101000b = 01111100b
-01011100b | 00101001b = 01111101b
-01011100b | 00101010b = 01111110b
-01011100b | 00101011b = 01111111b
-01011100b | 00101100b = 01111100b
-01011100b | 00101101b = 01111101b
-01011100b | 00101110b = 01111110b
-01011100b | 00101111b = 01111111b
-01011100b | 00110000b = 01111100b
-01011100b | 00110001b = 01111101b
-01011100b | 00110010b = 01111110b
-01011100b | 00110011b = 01111111b
-01011100b | 00110100b = 01111100b
-01011100b | 00110101b = 01111101b
-01011100b | 00110110b = 01111110b
-01011100b | 00110111b = 01111111b
-01011100b | 00111000b = 01111100b
-01011100b | 00111001b = 01111101b
-01011100b | 00111010b = 01111110b
-01011100b | 00111011b = 01111111b
-01011100b | 00111100b = 01111100b
-01011100b | 00111101b = 01111101b
-01011100b | 00111110b = 01111110b
-01011100b | 00111111b = 01111111b
-01011100b | 01000000b = 01011100b
-01011100b | 01000001b = 01011101b
-01011100b | 01000010b = 01011110b
-01011100b | 01000011b = 01011111b
-01011100b | 01000100b = 01011100b
-01011100b | 01000101b = 01011101b
-01011100b | 01000110b = 01011110b
-01011100b | 01000111b = 01011111b
-01011100b | 01001000b = 01011100b
-01011100b | 01001001b = 01011101b
-01011100b | 01001010b = 01011110b
-01011100b | 01001011b = 01011111b
-01011100b | 01001100b = 01011100b
-01011100b | 01001101b = 01011101b
-01011100b | 01001110b = 01011110b
-01011100b | 01001111b = 01011111b
-01011100b | 01010000b = 01011100b
-01011100b | 01010001b = 01011101b
-01011100b | 01010010b = 01011110b
-01011100b | 01010011b = 01011111b
-01011100b | 01010100b = 01011100b
-01011100b | 01010101b = 01011101b
-01011100b | 01010110b = 01011110b
-01011100b | 01010111b = 01011111b
-01011100b | 01011000b = 01011100b
-01011100b | 01011001b = 01011101b
-01011100b | 01011010b = 01011110b
-01011100b | 01011011b = 01011111b
-01011100b | 01011100b = 01011100b
-01011100b | 01011101b = 01011101b
-01011100b | 01011110b = 01011110b
-01011100b | 01011111b = 01011111b
-01011100b | 01100000b = 01111100b
-01011100b | 01100001b = 01111101b
-01011100b | 01100010b = 01111110b
-01011100b | 01100011b = 01111111b
-01011100b | 01100100b = 01111100b
-01011100b | 01100101b = 01111101b
-01011100b | 01100110b = 01111110b
-01011100b | 01100111b = 01111111b
-01011100b | 01101000b = 01111100b
-01011100b | 01101001b = 01111101b
-01011100b | 01101010b = 01111110b
-01011100b | 01101011b = 01111111b
-01011100b | 01101100b = 01111100b
-01011100b | 01101101b = 01111101b
-01011100b | 01101110b = 01111110b
-01011100b | 01101111b = 01111111b
-01011100b | 01110000b = 01111100b
-01011100b | 01110001b = 01111101b
-01011100b | 01110010b = 01111110b
-01011100b | 01110011b = 01111111b
-01011100b | 01110100b = 01111100b
-01011100b | 01110101b = 01111101b
-01011100b | 01110110b = 01111110b
-01011100b | 01110111b = 01111111b
-01011100b | 01111000b = 01111100b
-01011100b | 01111001b = 01111101b
-01011100b | 01111010b = 01111110b
-01011100b | 01111011b = 01111111b
-01011100b | 01111100b = 01111100b
-01011100b | 01111101b = 01111101b
-01011100b | 01111110b = 01111110b
-01011101b | 10000000b = 11011101b
-01011101b | 10000001b = 11011101b
-01011101b | 10000010b = 11011111b
-01011101b | 10000011b = 11011111b
-01011101b | 10000100b = 11011101b
-01011101b | 10000101b = 11011101b
-01011101b | 10000110b = 11011111b
-01011101b | 10000111b = 11011111b
-01011101b | 10001000b = 11011101b
-01011101b | 10001001b = 11011101b
-01011101b | 10001010b = 11011111b
-01011101b | 10001011b = 11011111b
-01011101b | 10001100b = 11011101b
-01011101b | 10001101b = 11011101b
-01011101b | 10001110b = 11011111b
-01011101b | 10001111b = 11011111b
-01011101b | 10010000b = 11011101b
-01011101b | 10010001b = 11011101b
-01011101b | 10010010b = 11011111b
-01011101b | 10010011b = 11011111b
-01011101b | 10010100b = 11011101b
-01011101b | 10010101b = 11011101b
-01011101b | 10010110b = 11011111b
-01011101b | 10010111b = 11011111b
-01011101b | 10011000b = 11011101b
-01011101b | 10011001b = 11011101b
-01011101b | 10011010b = 11011111b
-01011101b | 10011011b = 11011111b
-01011101b | 10011100b = 11011101b
-01011101b | 10011101b = 11011101b
-01011101b | 10011110b = 11011111b
-01011101b | 10011111b = 11011111b
-01011101b | 10100000b = 11111101b
-01011101b | 10100001b = 11111101b
-01011101b | 10100010b = 11111111b
-01011101b | 10100011b = 11111111b
-01011101b | 10100100b = 11111101b
-01011101b | 10100101b = 11111101b
-01011101b | 10100110b = 11111111b
-01011101b | 10100111b = 11111111b
-01011101b | 10101000b = 11111101b
-01011101b | 10101001b = 11111101b
-01011101b | 10101010b = 11111111b
-01011101b | 10101011b = 11111111b
-01011101b | 10101100b = 11111101b
-01011101b | 10101101b = 11111101b
-01011101b | 10101110b = 11111111b
-01011101b | 10101111b = 11111111b
-01011101b | 10110000b = 11111101b
-01011101b | 10110001b = 11111101b
-01011101b | 10110010b = 11111111b
-01011101b | 10110011b = 11111111b
-01011101b | 10110100b = 11111101b
-01011101b | 10110101b = 11111101b
-01011101b | 10110110b = 11111111b
-01011101b | 10110111b = 11111111b
-01011101b | 10111000b = 11111101b
-01011101b | 10111001b = 11111101b
-01011101b | 10111010b = 11111111b
-01011101b | 10111011b = 11111111b
-01011101b | 10111100b = 11111101b
-01011101b | 10111101b = 11111101b
-01011101b | 10111110b = 11111111b
-01011101b | 10111111b = 11111111b
-01011101b | 11000000b = 11011101b
-01011101b | 11000001b = 11011101b
-01011101b | 11000010b = 11011111b
-01011101b | 11000011b = 11011111b
-01011101b | 11000100b = 11011101b
-01011101b | 11000101b = 11011101b
-01011101b | 11000110b = 11011111b
-01011101b | 11000111b = 11011111b
-01011101b | 11001000b = 11011101b
-01011101b | 11001001b = 11011101b
-01011101b | 11001010b = 11011111b
-01011101b | 11001011b = 11011111b
-01011101b | 11001100b = 11011101b
-01011101b | 11001101b = 11011101b
-01011101b | 11001110b = 11011111b
-01011101b | 11001111b = 11011111b
-01011101b | 11010000b = 11011101b
-01011101b | 11010001b = 11011101b
-01011101b | 11010010b = 11011111b
-01011101b | 11010011b = 11011111b
-01011101b | 11010100b = 11011101b
-01011101b | 11010101b = 11011101b
-01011101b | 11010110b = 11011111b
-01011101b | 11010111b = 11011111b
-01011101b | 11011000b = 11011101b
-01011101b | 11011001b = 11011101b
-01011101b | 11011010b = 11011111b
-01011101b | 11011011b = 11011111b
-01011101b | 11011100b = 11011101b
-01011101b | 11011101b = 11011101b
-01011101b | 11011110b = 11011111b
-01011101b | 11011111b = 11011111b
-01011101b | 11100000b = 11111101b
-01011101b | 11100001b = 11111101b
-01011101b | 11100010b = 11111111b
-01011101b | 11100011b = 11111111b
-01011101b | 11100100b = 11111101b
-01011101b | 11100101b = 11111101b
-01011101b | 11100110b = 11111111b
-01011101b | 11100111b = 11111111b
-01011101b | 11101000b = 11111101b
-01011101b | 11101001b = 11111101b
-01011101b | 11101010b = 11111111b
-01011101b | 11101011b = 11111111b
-01011101b | 11101100b = 11111101b
-01011101b | 11101101b = 11111101b
-01011101b | 11101110b = 11111111b
-01011101b | 11101111b = 11111111b
-01011101b | 11110000b = 11111101b
-01011101b | 11110001b = 11111101b
-01011101b | 11110010b = 11111111b
-01011101b | 11110011b = 11111111b
-01011101b | 11110100b = 11111101b
-01011101b | 11110101b = 11111101b
-01011101b | 11110110b = 11111111b
-01011101b | 11110111b = 11111111b
-01011101b | 11111000b = 11111101b
-01011101b | 11111001b = 11111101b
-01011101b | 11111010b = 11111111b
-01011101b | 11111011b = 11111111b
-01011101b | 11111100b = 11111101b
-01011101b | 11111101b = 11111101b
-01011101b | 11111110b = 11111111b
-01011101b | 11111111b = 11111111b
-01011101b | 00000000b = 01011101b
-01011101b | 00000001b = 01011101b
-01011101b | 00000010b = 01011111b
-01011101b | 00000011b = 01011111b
-01011101b | 00000100b = 01011101b
-01011101b | 00000101b = 01011101b
-01011101b | 00000110b = 01011111b
-01011101b | 00000111b = 01011111b
-01011101b | 00001000b = 01011101b
-01011101b | 00001001b = 01011101b
-01011101b | 00001010b = 01011111b
-01011101b | 00001011b = 01011111b
-01011101b | 00001100b = 01011101b
-01011101b | 00001101b = 01011101b
-01011101b | 00001110b = 01011111b
-01011101b | 00001111b = 01011111b
-01011101b | 00010000b = 01011101b
-01011101b | 00010001b = 01011101b
-01011101b | 00010010b = 01011111b
-01011101b | 00010011b = 01011111b
-01011101b | 00010100b = 01011101b
-01011101b | 00010101b = 01011101b
-01011101b | 00010110b = 01011111b
-01011101b | 00010111b = 01011111b
-01011101b | 00011000b = 01011101b
-01011101b | 00011001b = 01011101b
-01011101b | 00011010b = 01011111b
-01011101b | 00011011b = 01011111b
-01011101b | 00011100b = 01011101b
-01011101b | 00011101b = 01011101b
-01011101b | 00011110b = 01011111b
-01011101b | 00011111b = 01011111b
-01011101b | 00100000b = 01111101b
-01011101b | 00100001b = 01111101b
-01011101b | 00100010b = 01111111b
-01011101b | 00100011b = 01111111b
-01011101b | 00100100b = 01111101b
-01011101b | 00100101b = 01111101b
-01011101b | 00100110b = 01111111b
-01011101b | 00100111b = 01111111b
-01011101b | 00101000b = 01111101b
-01011101b | 00101001b = 01111101b
-01011101b | 00101010b = 01111111b
-01011101b | 00101011b = 01111111b
-01011101b | 00101100b = 01111101b
-01011101b | 00101101b = 01111101b
-01011101b | 00101110b = 01111111b
-01011101b | 00101111b = 01111111b
-01011101b | 00110000b = 01111101b
-01011101b | 00110001b = 01111101b
-01011101b | 00110010b = 01111111b
-01011101b | 00110011b = 01111111b
-01011101b | 00110100b = 01111101b
-01011101b | 00110101b = 01111101b
-01011101b | 00110110b = 01111111b
-01011101b | 00110111b = 01111111b
-01011101b | 00111000b = 01111101b
-01011101b | 00111001b = 01111101b
-01011101b | 00111010b = 01111111b
-01011101b | 00111011b = 01111111b
-01011101b | 00111100b = 01111101b
-01011101b | 00111101b = 01111101b
-01011101b | 00111110b = 01111111b
-01011101b | 00111111b = 01111111b
-01011101b | 01000000b = 01011101b
-01011101b | 01000001b = 01011101b
-01011101b | 01000010b = 01011111b
-01011101b | 01000011b = 01011111b
-01011101b | 01000100b = 01011101b
-01011101b | 01000101b = 01011101b
-01011101b | 01000110b = 01011111b
-01011101b | 01000111b = 01011111b
-01011101b | 01001000b = 01011101b
-01011101b | 01001001b = 01011101b
-01011101b | 01001010b = 01011111b
-01011101b | 01001011b = 01011111b
-01011101b | 01001100b = 01011101b
-01011101b | 01001101b = 01011101b
-01011101b | 01001110b = 01011111b
-01011101b | 01001111b = 01011111b
-01011101b | 01010000b = 01011101b
-01011101b | 01010001b = 01011101b
-01011101b | 01010010b = 01011111b
-01011101b | 01010011b = 01011111b
-01011101b | 01010100b = 01011101b
-01011101b | 01010101b = 01011101b
-01011101b | 01010110b = 01011111b
-01011101b | 01010111b = 01011111b
-01011101b | 01011000b = 01011101b
-01011101b | 01011001b = 01011101b
-01011101b | 01011010b = 01011111b
-01011101b | 01011011b = 01011111b
-01011101b | 01011100b = 01011101b
-01011101b | 01011101b = 01011101b
-01011101b | 01011110b = 01011111b
-01011101b | 01011111b = 01011111b
-01011101b | 01100000b = 01111101b
-01011101b | 01100001b = 01111101b
-01011101b | 01100010b = 01111111b
-01011101b | 01100011b = 01111111b
-01011101b | 01100100b = 01111101b
-01011101b | 01100101b = 01111101b
-01011101b | 01100110b = 01111111b
-01011101b | 01100111b = 01111111b
-01011101b | 01101000b = 01111101b
-01011101b | 01101001b = 01111101b
-01011101b | 01101010b = 01111111b
-01011101b | 01101011b = 01111111b
-01011101b | 01101100b = 01111101b
-01011101b | 01101101b = 01111101b
-01011101b | 01101110b = 01111111b
-01011101b | 01101111b = 01111111b
-01011101b | 01110000b = 01111101b
-01011101b | 01110001b = 01111101b
-01011101b | 01110010b = 01111111b
-01011101b | 01110011b = 01111111b
-01011101b | 01110100b = 01111101b
-01011101b | 01110101b = 01111101b
-01011101b | 01110110b = 01111111b
-01011101b | 01110111b = 01111111b
-01011101b | 01111000b = 01111101b
-01011101b | 01111001b = 01111101b
-01011101b | 01111010b = 01111111b
-01011101b | 01111011b = 01111111b
-01011101b | 01111100b = 01111101b
-01011101b | 01111101b = 01111101b
-01011101b | 01111110b = 01111111b
-01011110b | 10000000b = 11011110b
-01011110b | 10000001b = 11011111b
-01011110b | 10000010b = 11011110b
-01011110b | 10000011b = 11011111b
-01011110b | 10000100b = 11011110b
-01011110b | 10000101b = 11011111b
-01011110b | 10000110b = 11011110b
-01011110b | 10000111b = 11011111b
-01011110b | 10001000b = 11011110b
-01011110b | 10001001b = 11011111b
-01011110b | 10001010b = 11011110b
-01011110b | 10001011b = 11011111b
-01011110b | 10001100b = 11011110b
-01011110b | 10001101b = 11011111b
-01011110b | 10001110b = 11011110b
-01011110b | 10001111b = 11011111b
-01011110b | 10010000b = 11011110b
-01011110b | 10010001b = 11011111b
-01011110b | 10010010b = 11011110b
-01011110b | 10010011b = 11011111b
-01011110b | 10010100b = 11011110b
-01011110b | 10010101b = 11011111b
-01011110b | 10010110b = 11011110b
-01011110b | 10010111b = 11011111b
-01011110b | 10011000b = 11011110b
-01011110b | 10011001b = 11011111b
-01011110b | 10011010b = 11011110b
-01011110b | 10011011b = 11011111b
-01011110b | 10011100b = 11011110b
-01011110b | 10011101b = 11011111b
-01011110b | 10011110b = 11011110b
-01011110b | 10011111b = 11011111b
-01011110b | 10100000b = 11111110b
-01011110b | 10100001b = 11111111b
-01011110b | 10100010b = 11111110b
-01011110b | 10100011b = 11111111b
-01011110b | 10100100b = 11111110b
-01011110b | 10100101b = 11111111b
-01011110b | 10100110b = 11111110b
-01011110b | 10100111b = 11111111b
-01011110b | 10101000b = 11111110b
-01011110b | 10101001b = 11111111b
-01011110b | 10101010b = 11111110b
-01011110b | 10101011b = 11111111b
-01011110b | 10101100b = 11111110b
-01011110b | 10101101b = 11111111b
-01011110b | 10101110b = 11111110b
-01011110b | 10101111b = 11111111b
-01011110b | 10110000b = 11111110b
-01011110b | 10110001b = 11111111b
-01011110b | 10110010b = 11111110b
-01011110b | 10110011b = 11111111b
-01011110b | 10110100b = 11111110b
-01011110b | 10110101b = 11111111b
-01011110b | 10110110b = 11111110b
-01011110b | 10110111b = 11111111b
-01011110b | 10111000b = 11111110b
-01011110b | 10111001b = 11111111b
-01011110b | 10111010b = 11111110b
-01011110b | 10111011b = 11111111b
-01011110b | 10111100b = 11111110b
-01011110b | 10111101b = 11111111b
-01011110b | 10111110b = 11111110b
-01011110b | 10111111b = 11111111b
-01011110b | 11000000b = 11011110b
-01011110b | 11000001b = 11011111b
-01011110b | 11000010b = 11011110b
-01011110b | 11000011b = 11011111b
-01011110b | 11000100b = 11011110b
-01011110b | 11000101b = 11011111b
-01011110b | 11000110b = 11011110b
-01011110b | 11000111b = 11011111b
-01011110b | 11001000b = 11011110b
-01011110b | 11001001b = 11011111b
-01011110b | 11001010b = 11011110b
-01011110b | 11001011b = 11011111b
-01011110b | 11001100b = 11011110b
-01011110b | 11001101b = 11011111b
-01011110b | 11001110b = 11011110b
-01011110b | 11001111b = 11011111b
-01011110b | 11010000b = 11011110b
-01011110b | 11010001b = 11011111b
-01011110b | 11010010b = 11011110b
-01011110b | 11010011b = 11011111b
-01011110b | 11010100b = 11011110b
-01011110b | 11010101b = 11011111b
-01011110b | 11010110b = 11011110b
-01011110b | 11010111b = 11011111b
-01011110b | 11011000b = 11011110b
-01011110b | 11011001b = 11011111b
-01011110b | 11011010b = 11011110b
-01011110b | 11011011b = 11011111b
-01011110b | 11011100b = 11011110b
-01011110b | 11011101b = 11011111b
-01011110b | 11011110b = 11011110b
-01011110b | 11011111b = 11011111b
-01011110b | 11100000b = 11111110b
-01011110b | 11100001b = 11111111b
-01011110b | 11100010b = 11111110b
-01011110b | 11100011b = 11111111b
-01011110b | 11100100b = 11111110b
-01011110b | 11100101b = 11111111b
-01011110b | 11100110b = 11111110b
-01011110b | 11100111b = 11111111b
-01011110b | 11101000b = 11111110b
-01011110b | 11101001b = 11111111b
-01011110b | 11101010b = 11111110b
-01011110b | 11101011b = 11111111b
-01011110b | 11101100b = 11111110b
-01011110b | 11101101b = 11111111b
-01011110b | 11101110b = 11111110b
-01011110b | 11101111b = 11111111b
-01011110b | 11110000b = 11111110b
-01011110b | 11110001b = 11111111b
-01011110b | 11110010b = 11111110b
-01011110b | 11110011b = 11111111b
-01011110b | 11110100b = 11111110b
-01011110b | 11110101b = 11111111b
-01011110b | 11110110b = 11111110b
-01011110b | 11110111b = 11111111b
-01011110b | 11111000b = 11111110b
-01011110b | 11111001b = 11111111b
-01011110b | 11111010b = 11111110b
-01011110b | 11111011b = 11111111b
-01011110b | 11111100b = 11111110b
-01011110b | 11111101b = 11111111b
-01011110b | 11111110b = 11111110b
-01011110b | 11111111b = 11111111b
-01011110b | 00000000b = 01011110b
-01011110b | 00000001b = 01011111b
-01011110b | 00000010b = 01011110b
-01011110b | 00000011b = 01011111b
-01011110b | 00000100b = 01011110b
-01011110b | 00000101b = 01011111b
-01011110b | 00000110b = 01011110b
-01011110b | 00000111b = 01011111b
-01011110b | 00001000b = 01011110b
-01011110b | 00001001b = 01011111b
-01011110b | 00001010b = 01011110b
-01011110b | 00001011b = 01011111b
-01011110b | 00001100b = 01011110b
-01011110b | 00001101b = 01011111b
-01011110b | 00001110b = 01011110b
-01011110b | 00001111b = 01011111b
-01011110b | 00010000b = 01011110b
-01011110b | 00010001b = 01011111b
-01011110b | 00010010b = 01011110b
-01011110b | 00010011b = 01011111b
-01011110b | 00010100b = 01011110b
-01011110b | 00010101b = 01011111b
-01011110b | 00010110b = 01011110b
-01011110b | 00010111b = 01011111b
-01011110b | 00011000b = 01011110b
-01011110b | 00011001b = 01011111b
-01011110b | 00011010b = 01011110b
-01011110b | 00011011b = 01011111b
-01011110b | 00011100b = 01011110b
-01011110b | 00011101b = 01011111b
-01011110b | 00011110b = 01011110b
-01011110b | 00011111b = 01011111b
-01011110b | 00100000b = 01111110b
-01011110b | 00100001b = 01111111b
-01011110b | 00100010b = 01111110b
-01011110b | 00100011b = 01111111b
-01011110b | 00100100b = 01111110b
-01011110b | 00100101b = 01111111b
-01011110b | 00100110b = 01111110b
-01011110b | 00100111b = 01111111b
-01011110b | 00101000b = 01111110b
-01011110b | 00101001b = 01111111b
-01011110b | 00101010b = 01111110b
-01011110b | 00101011b = 01111111b
-01011110b | 00101100b = 01111110b
-01011110b | 00101101b = 01111111b
-01011110b | 00101110b = 01111110b
-01011110b | 00101111b = 01111111b
-01011110b | 00110000b = 01111110b
-01011110b | 00110001b = 01111111b
-01011110b | 00110010b = 01111110b
-01011110b | 00110011b = 01111111b
-01011110b | 00110100b = 01111110b
-01011110b | 00110101b = 01111111b
-01011110b | 00110110b = 01111110b
-01011110b | 00110111b = 01111111b
-01011110b | 00111000b = 01111110b
-01011110b | 00111001b = 01111111b
-01011110b | 00111010b = 01111110b
-01011110b | 00111011b = 01111111b
-01011110b | 00111100b = 01111110b
-01011110b | 00111101b = 01111111b
-01011110b | 00111110b = 01111110b
-01011110b | 00111111b = 01111111b
-01011110b | 01000000b = 01011110b
-01011110b | 01000001b = 01011111b
-01011110b | 01000010b = 01011110b
-01011110b | 01000011b = 01011111b
-01011110b | 01000100b = 01011110b
-01011110b | 01000101b = 01011111b
-01011110b | 01000110b = 01011110b
-01011110b | 01000111b = 01011111b
-01011110b | 01001000b = 01011110b
-01011110b | 01001001b = 01011111b
-01011110b | 01001010b = 01011110b
-01011110b | 01001011b = 01011111b
-01011110b | 01001100b = 01011110b
-01011110b | 01001101b = 01011111b
-01011110b | 01001110b = 01011110b
-01011110b | 01001111b = 01011111b
-01011110b | 01010000b = 01011110b
-01011110b | 01010001b = 01011111b
-01011110b | 01010010b = 01011110b
-01011110b | 01010011b = 01011111b
-01011110b | 01010100b = 01011110b
-01011110b | 01010101b = 01011111b
-01011110b | 01010110b = 01011110b
-01011110b | 01010111b = 01011111b
-01011110b | 01011000b = 01011110b
-01011110b | 01011001b = 01011111b
-01011110b | 01011010b = 01011110b
-01011110b | 01011011b = 01011111b
-01011110b | 01011100b = 01011110b
-01011110b | 01011101b = 01011111b
-01011110b | 01011110b = 01011110b
-01011110b | 01011111b = 01011111b
-01011110b | 01100000b = 01111110b
-01011110b | 01100001b = 01111111b
-01011110b | 01100010b = 01111110b
-01011110b | 01100011b = 01111111b
-01011110b | 01100100b = 01111110b
-01011110b | 01100101b = 01111111b
-01011110b | 01100110b = 01111110b
-01011110b | 01100111b = 01111111b
-01011110b | 01101000b = 01111110b
-01011110b | 01101001b = 01111111b
-01011110b | 01101010b = 01111110b
-01011110b | 01101011b = 01111111b
-01011110b | 01101100b = 01111110b
-01011110b | 01101101b = 01111111b
-01011110b | 01101110b = 01111110b
-01011110b | 01101111b = 01111111b
-01011110b | 01110000b = 01111110b
-01011110b | 01110001b = 01111111b
-01011110b | 01110010b = 01111110b
-01011110b | 01110011b = 01111111b
-01011110b | 01110100b = 01111110b
-01011110b | 01110101b = 01111111b
-01011110b | 01110110b = 01111110b
-01011110b | 01110111b = 01111111b
-01011110b | 01111000b = 01111110b
-01011110b | 01111001b = 01111111b
-01011110b | 01111010b = 01111110b
-01011110b | 01111011b = 01111111b
-01011110b | 01111100b = 01111110b
-01011110b | 01111101b = 01111111b
-01011110b | 01111110b = 01111110b
-01011111b | 10000000b = 11011111b
-01011111b | 10000001b = 11011111b
-01011111b | 10000010b = 11011111b
-01011111b | 10000011b = 11011111b
-01011111b | 10000100b = 11011111b
-01011111b | 10000101b = 11011111b
-01011111b | 10000110b = 11011111b
-01011111b | 10000111b = 11011111b
-01011111b | 10001000b = 11011111b
-01011111b | 10001001b = 11011111b
-01011111b | 10001010b = 11011111b
-01011111b | 10001011b = 11011111b
-01011111b | 10001100b = 11011111b
-01011111b | 10001101b = 11011111b
-01011111b | 10001110b = 11011111b
-01011111b | 10001111b = 11011111b
-01011111b | 10010000b = 11011111b
-01011111b | 10010001b = 11011111b
-01011111b | 10010010b = 11011111b
-01011111b | 10010011b = 11011111b
-01011111b | 10010100b = 11011111b
-01011111b | 10010101b = 11011111b
-01011111b | 10010110b = 11011111b
-01011111b | 10010111b = 11011111b
-01011111b | 10011000b = 11011111b
-01011111b | 10011001b = 11011111b
-01011111b | 10011010b = 11011111b
-01011111b | 10011011b = 11011111b
-01011111b | 10011100b = 11011111b
-01011111b | 10011101b = 11011111b
-01011111b | 10011110b = 11011111b
-01011111b | 10011111b = 11011111b
-01011111b | 10100000b = 11111111b
-01011111b | 10100001b = 11111111b
-01011111b | 10100010b = 11111111b
-01011111b | 10100011b = 11111111b
-01011111b | 10100100b = 11111111b
-01011111b | 10100101b = 11111111b
-01011111b | 10100110b = 11111111b
-01011111b | 10100111b = 11111111b
-01011111b | 10101000b = 11111111b
-01011111b | 10101001b = 11111111b
-01011111b | 10101010b = 11111111b
-01011111b | 10101011b = 11111111b
-01011111b | 10101100b = 11111111b
-01011111b | 10101101b = 11111111b
-01011111b | 10101110b = 11111111b
-01011111b | 10101111b = 11111111b
-01011111b | 10110000b = 11111111b
-01011111b | 10110001b = 11111111b
-01011111b | 10110010b = 11111111b
-01011111b | 10110011b = 11111111b
-01011111b | 10110100b = 11111111b
-01011111b | 10110101b = 11111111b
-01011111b | 10110110b = 11111111b
-01011111b | 10110111b = 11111111b
-01011111b | 10111000b = 11111111b
-01011111b | 10111001b = 11111111b
-01011111b | 10111010b = 11111111b
-01011111b | 10111011b = 11111111b
-01011111b | 10111100b = 11111111b
-01011111b | 10111101b = 11111111b
-01011111b | 10111110b = 11111111b
-01011111b | 10111111b = 11111111b
-01011111b | 11000000b = 11011111b
-01011111b | 11000001b = 11011111b
-01011111b | 11000010b = 11011111b
-01011111b | 11000011b = 11011111b
-01011111b | 11000100b = 11011111b
-01011111b | 11000101b = 11011111b
-01011111b | 11000110b = 11011111b
-01011111b | 11000111b = 11011111b
-01011111b | 11001000b = 11011111b
-01011111b | 11001001b = 11011111b
-01011111b | 11001010b = 11011111b
-01011111b | 11001011b = 11011111b
-01011111b | 11001100b = 11011111b
-01011111b | 11001101b = 11011111b
-01011111b | 11001110b = 11011111b
-01011111b | 11001111b = 11011111b
-01011111b | 11010000b = 11011111b
-01011111b | 11010001b = 11011111b
-01011111b | 11010010b = 11011111b
-01011111b | 11010011b = 11011111b
-01011111b | 11010100b = 11011111b
-01011111b | 11010101b = 11011111b
-01011111b | 11010110b = 11011111b
-01011111b | 11010111b = 11011111b
-01011111b | 11011000b = 11011111b
-01011111b | 11011001b = 11011111b
-01011111b | 11011010b = 11011111b
-01011111b | 11011011b = 11011111b
-01011111b | 11011100b = 11011111b
-01011111b | 11011101b = 11011111b
-01011111b | 11011110b = 11011111b
-01011111b | 11011111b = 11011111b
-01011111b | 11100000b = 11111111b
-01011111b | 11100001b = 11111111b
-01011111b | 11100010b = 11111111b
-01011111b | 11100011b = 11111111b
-01011111b | 11100100b = 11111111b
-01011111b | 11100101b = 11111111b
-01011111b | 11100110b = 11111111b
-01011111b | 11100111b = 11111111b
-01011111b | 11101000b = 11111111b
-01011111b | 11101001b = 11111111b
-01011111b | 11101010b = 11111111b
-01011111b | 11101011b = 11111111b
-01011111b | 11101100b = 11111111b
-01011111b | 11101101b = 11111111b
-01011111b | 11101110b = 11111111b
-01011111b | 11101111b = 11111111b
-01011111b | 11110000b = 11111111b
-01011111b | 11110001b = 11111111b
-01011111b | 11110010b = 11111111b
-01011111b | 11110011b = 11111111b
-01011111b | 11110100b = 11111111b
-01011111b | 11110101b = 11111111b
-01011111b | 11110110b = 11111111b
-01011111b | 11110111b = 11111111b
-01011111b | 11111000b = 11111111b
-01011111b | 11111001b = 11111111b
-01011111b | 11111010b = 11111111b
-01011111b | 11111011b = 11111111b
-01011111b | 11111100b = 11111111b
-01011111b | 11111101b = 11111111b
-01011111b | 11111110b = 11111111b
-01011111b | 11111111b = 11111111b
-01011111b | 00000000b = 01011111b
-01011111b | 00000001b = 01011111b
-01011111b | 00000010b = 01011111b
-01011111b | 00000011b = 01011111b
-01011111b | 00000100b = 01011111b
-01011111b | 00000101b = 01011111b
-01011111b | 00000110b = 01011111b
-01011111b | 00000111b = 01011111b
-01011111b | 00001000b = 01011111b
-01011111b | 00001001b = 01011111b
-01011111b | 00001010b = 01011111b
-01011111b | 00001011b = 01011111b
-01011111b | 00001100b = 01011111b
-01011111b | 00001101b = 01011111b
-01011111b | 00001110b = 01011111b
-01011111b | 00001111b = 01011111b
-01011111b | 00010000b = 01011111b
-01011111b | 00010001b = 01011111b
-01011111b | 00010010b = 01011111b
-01011111b | 00010011b = 01011111b
-01011111b | 00010100b = 01011111b
-01011111b | 00010101b = 01011111b
-01011111b | 00010110b = 01011111b
-01011111b | 00010111b = 01011111b
-01011111b | 00011000b = 01011111b
-01011111b | 00011001b = 01011111b
-01011111b | 00011010b = 01011111b
-01011111b | 00011011b = 01011111b
-01011111b | 00011100b = 01011111b
-01011111b | 00011101b = 01011111b
-01011111b | 00011110b = 01011111b
-01011111b | 00011111b = 01011111b
-01011111b | 00100000b = 01111111b
-01011111b | 00100001b = 01111111b
-01011111b | 00100010b = 01111111b
-01011111b | 00100011b = 01111111b
-01011111b | 00100100b = 01111111b
-01011111b | 00100101b = 01111111b
-01011111b | 00100110b = 01111111b
-01011111b | 00100111b = 01111111b
-01011111b | 00101000b = 01111111b
-01011111b | 00101001b = 01111111b
-01011111b | 00101010b = 01111111b
-01011111b | 00101011b = 01111111b
-01011111b | 00101100b = 01111111b
-01011111b | 00101101b = 01111111b
-01011111b | 00101110b = 01111111b
-01011111b | 00101111b = 01111111b
-01011111b | 00110000b = 01111111b
-01011111b | 00110001b = 01111111b
-01011111b | 00110010b = 01111111b
-01011111b | 00110011b = 01111111b
-01011111b | 00110100b = 01111111b
-01011111b | 00110101b = 01111111b
-01011111b | 00110110b = 01111111b
-01011111b | 00110111b = 01111111b
-01011111b | 00111000b = 01111111b
-01011111b | 00111001b = 01111111b
-01011111b | 00111010b = 01111111b
-01011111b | 00111011b = 01111111b
-01011111b | 00111100b = 01111111b
-01011111b | 00111101b = 01111111b
-01011111b | 00111110b = 01111111b
-01011111b | 00111111b = 01111111b
-01011111b | 01000000b = 01011111b
-01011111b | 01000001b = 01011111b
-01011111b | 01000010b = 01011111b
-01011111b | 01000011b = 01011111b
-01011111b | 01000100b = 01011111b
-01011111b | 01000101b = 01011111b
-01011111b | 01000110b = 01011111b
-01011111b | 01000111b = 01011111b
-01011111b | 01001000b = 01011111b
-01011111b | 01001001b = 01011111b
-01011111b | 01001010b = 01011111b
-01011111b | 01001011b = 01011111b
-01011111b | 01001100b = 01011111b
-01011111b | 01001101b = 01011111b
-01011111b | 01001110b = 01011111b
-01011111b | 01001111b = 01011111b
-01011111b | 01010000b = 01011111b
-01011111b | 01010001b = 01011111b
-01011111b | 01010010b = 01011111b
-01011111b | 01010011b = 01011111b
-01011111b | 01010100b = 01011111b
-01011111b | 01010101b = 01011111b
-01011111b | 01010110b = 01011111b
-01011111b | 01010111b = 01011111b
-01011111b | 01011000b = 01011111b
-01011111b | 01011001b = 01011111b
-01011111b | 01011010b = 01011111b
-01011111b | 01011011b = 01011111b
-01011111b | 01011100b = 01011111b
-01011111b | 01011101b = 01011111b
-01011111b | 01011110b = 01011111b
-01011111b | 01011111b = 01011111b
-01011111b | 01100000b = 01111111b
-01011111b | 01100001b = 01111111b
-01011111b | 01100010b = 01111111b
-01011111b | 01100011b = 01111111b
-01011111b | 01100100b = 01111111b
-01011111b | 01100101b = 01111111b
-01011111b | 01100110b = 01111111b
-01011111b | 01100111b = 01111111b
-01011111b | 01101000b = 01111111b
-01011111b | 01101001b = 01111111b
-01011111b | 01101010b = 01111111b
-01011111b | 01101011b = 01111111b
-01011111b | 01101100b = 01111111b
-01011111b | 01101101b = 01111111b
-01011111b | 01101110b = 01111111b
-01011111b | 01101111b = 01111111b
-01011111b | 01110000b = 01111111b
-01011111b | 01110001b = 01111111b
-01011111b | 01110010b = 01111111b
-01011111b | 01110011b = 01111111b
-01011111b | 01110100b = 01111111b
-01011111b | 01110101b = 01111111b
-01011111b | 01110110b = 01111111b
-01011111b | 01110111b = 01111111b
-01011111b | 01111000b = 01111111b
-01011111b | 01111001b = 01111111b
-01011111b | 01111010b = 01111111b
-01011111b | 01111011b = 01111111b
-01011111b | 01111100b = 01111111b
-01011111b | 01111101b = 01111111b
-01011111b | 01111110b = 01111111b
-01100000b | 10000000b = 11100000b
-01100000b | 10000001b = 11100001b
-01100000b | 10000010b = 11100010b
-01100000b | 10000011b = 11100011b
-01100000b | 10000100b = 11100100b
-01100000b | 10000101b = 11100101b
-01100000b | 10000110b = 11100110b
-01100000b | 10000111b = 11100111b
-01100000b | 10001000b = 11101000b
-01100000b | 10001001b = 11101001b
-01100000b | 10001010b = 11101010b
-01100000b | 10001011b = 11101011b
-01100000b | 10001100b = 11101100b
-01100000b | 10001101b = 11101101b
-01100000b | 10001110b = 11101110b
-01100000b | 10001111b = 11101111b
-01100000b | 10010000b = 11110000b
-01100000b | 10010001b = 11110001b
-01100000b | 10010010b = 11110010b
-01100000b | 10010011b = 11110011b
-01100000b | 10010100b = 11110100b
-01100000b | 10010101b = 11110101b
-01100000b | 10010110b = 11110110b
-01100000b | 10010111b = 11110111b
-01100000b | 10011000b = 11111000b
-01100000b | 10011001b = 11111001b
-01100000b | 10011010b = 11111010b
-01100000b | 10011011b = 11111011b
-01100000b | 10011100b = 11111100b
-01100000b | 10011101b = 11111101b
-01100000b | 10011110b = 11111110b
-01100000b | 10011111b = 11111111b
-01100000b | 10100000b = 11100000b
-01100000b | 10100001b = 11100001b
-01100000b | 10100010b = 11100010b
-01100000b | 10100011b = 11100011b
-01100000b | 10100100b = 11100100b
-01100000b | 10100101b = 11100101b
-01100000b | 10100110b = 11100110b
-01100000b | 10100111b = 11100111b
-01100000b | 10101000b = 11101000b
-01100000b | 10101001b = 11101001b
-01100000b | 10101010b = 11101010b
-01100000b | 10101011b = 11101011b
-01100000b | 10101100b = 11101100b
-01100000b | 10101101b = 11101101b
-01100000b | 10101110b = 11101110b
-01100000b | 10101111b = 11101111b
-01100000b | 10110000b = 11110000b
-01100000b | 10110001b = 11110001b
-01100000b | 10110010b = 11110010b
-01100000b | 10110011b = 11110011b
-01100000b | 10110100b = 11110100b
-01100000b | 10110101b = 11110101b
-01100000b | 10110110b = 11110110b
-01100000b | 10110111b = 11110111b
-01100000b | 10111000b = 11111000b
-01100000b | 10111001b = 11111001b
-01100000b | 10111010b = 11111010b
-01100000b | 10111011b = 11111011b
-01100000b | 10111100b = 11111100b
-01100000b | 10111101b = 11111101b
-01100000b | 10111110b = 11111110b
-01100000b | 10111111b = 11111111b
-01100000b | 11000000b = 11100000b
-01100000b | 11000001b = 11100001b
-01100000b | 11000010b = 11100010b
-01100000b | 11000011b = 11100011b
-01100000b | 11000100b = 11100100b
-01100000b | 11000101b = 11100101b
-01100000b | 11000110b = 11100110b
-01100000b | 11000111b = 11100111b
-01100000b | 11001000b = 11101000b
-01100000b | 11001001b = 11101001b
-01100000b | 11001010b = 11101010b
-01100000b | 11001011b = 11101011b
-01100000b | 11001100b = 11101100b
-01100000b | 11001101b = 11101101b
-01100000b | 11001110b = 11101110b
-01100000b | 11001111b = 11101111b
-01100000b | 11010000b = 11110000b
-01100000b | 11010001b = 11110001b
-01100000b | 11010010b = 11110010b
-01100000b | 11010011b = 11110011b
-01100000b | 11010100b = 11110100b
-01100000b | 11010101b = 11110101b
-01100000b | 11010110b = 11110110b
-01100000b | 11010111b = 11110111b
-01100000b | 11011000b = 11111000b
-01100000b | 11011001b = 11111001b
-01100000b | 11011010b = 11111010b
-01100000b | 11011011b = 11111011b
-01100000b | 11011100b = 11111100b
-01100000b | 11011101b = 11111101b
-01100000b | 11011110b = 11111110b
-01100000b | 11011111b = 11111111b
-01100000b | 11100000b = 11100000b
-01100000b | 11100001b = 11100001b
-01100000b | 11100010b = 11100010b
-01100000b | 11100011b = 11100011b
-01100000b | 11100100b = 11100100b
-01100000b | 11100101b = 11100101b
-01100000b | 11100110b = 11100110b
-01100000b | 11100111b = 11100111b
-01100000b | 11101000b = 11101000b
-01100000b | 11101001b = 11101001b
-01100000b | 11101010b = 11101010b
-01100000b | 11101011b = 11101011b
-01100000b | 11101100b = 11101100b
-01100000b | 11101101b = 11101101b
-01100000b | 11101110b = 11101110b
-01100000b | 11101111b = 11101111b
-01100000b | 11110000b = 11110000b
-01100000b | 11110001b = 11110001b
-01100000b | 11110010b = 11110010b
-01100000b | 11110011b = 11110011b
-01100000b | 11110100b = 11110100b
-01100000b | 11110101b = 11110101b
-01100000b | 11110110b = 11110110b
-01100000b | 11110111b = 11110111b
-01100000b | 11111000b = 11111000b
-01100000b | 11111001b = 11111001b
-01100000b | 11111010b = 11111010b
-01100000b | 11111011b = 11111011b
-01100000b | 11111100b = 11111100b
-01100000b | 11111101b = 11111101b
-01100000b | 11111110b = 11111110b
-01100000b | 11111111b = 11111111b
-01100000b | 00000000b = 01100000b
-01100000b | 00000001b = 01100001b
-01100000b | 00000010b = 01100010b
-01100000b | 00000011b = 01100011b
-01100000b | 00000100b = 01100100b
-01100000b | 00000101b = 01100101b
-01100000b | 00000110b = 01100110b
-01100000b | 00000111b = 01100111b
-01100000b | 00001000b = 01101000b
-01100000b | 00001001b = 01101001b
-01100000b | 00001010b = 01101010b
-01100000b | 00001011b = 01101011b
-01100000b | 00001100b = 01101100b
-01100000b | 00001101b = 01101101b
-01100000b | 00001110b = 01101110b
-01100000b | 00001111b = 01101111b
-01100000b | 00010000b = 01110000b
-01100000b | 00010001b = 01110001b
-01100000b | 00010010b = 01110010b
-01100000b | 00010011b = 01110011b
-01100000b | 00010100b = 01110100b
-01100000b | 00010101b = 01110101b
-01100000b | 00010110b = 01110110b
-01100000b | 00010111b = 01110111b
-01100000b | 00011000b = 01111000b
-01100000b | 00011001b = 01111001b
-01100000b | 00011010b = 01111010b
-01100000b | 00011011b = 01111011b
-01100000b | 00011100b = 01111100b
-01100000b | 00011101b = 01111101b
-01100000b | 00011110b = 01111110b
-01100000b | 00011111b = 01111111b
-01100000b | 00100000b = 01100000b
-01100000b | 00100001b = 01100001b
-01100000b | 00100010b = 01100010b
-01100000b | 00100011b = 01100011b
-01100000b | 00100100b = 01100100b
-01100000b | 00100101b = 01100101b
-01100000b | 00100110b = 01100110b
-01100000b | 00100111b = 01100111b
-01100000b | 00101000b = 01101000b
-01100000b | 00101001b = 01101001b
-01100000b | 00101010b = 01101010b
-01100000b | 00101011b = 01101011b
-01100000b | 00101100b = 01101100b
-01100000b | 00101101b = 01101101b
-01100000b | 00101110b = 01101110b
-01100000b | 00101111b = 01101111b
-01100000b | 00110000b = 01110000b
-01100000b | 00110001b = 01110001b
-01100000b | 00110010b = 01110010b
-01100000b | 00110011b = 01110011b
-01100000b | 00110100b = 01110100b
-01100000b | 00110101b = 01110101b
-01100000b | 00110110b = 01110110b
-01100000b | 00110111b = 01110111b
-01100000b | 00111000b = 01111000b
-01100000b | 00111001b = 01111001b
-01100000b | 00111010b = 01111010b
-01100000b | 00111011b = 01111011b
-01100000b | 00111100b = 01111100b
-01100000b | 00111101b = 01111101b
-01100000b | 00111110b = 01111110b
-01100000b | 00111111b = 01111111b
-01100000b | 01000000b = 01100000b
-01100000b | 01000001b = 01100001b
-01100000b | 01000010b = 01100010b
-01100000b | 01000011b = 01100011b
-01100000b | 01000100b = 01100100b
-01100000b | 01000101b = 01100101b
-01100000b | 01000110b = 01100110b
-01100000b | 01000111b = 01100111b
-01100000b | 01001000b = 01101000b
-01100000b | 01001001b = 01101001b
-01100000b | 01001010b = 01101010b
-01100000b | 01001011b = 01101011b
-01100000b | 01001100b = 01101100b
-01100000b | 01001101b = 01101101b
-01100000b | 01001110b = 01101110b
-01100000b | 01001111b = 01101111b
-01100000b | 01010000b = 01110000b
-01100000b | 01010001b = 01110001b
-01100000b | 01010010b = 01110010b
-01100000b | 01010011b = 01110011b
-01100000b | 01010100b = 01110100b
-01100000b | 01010101b = 01110101b
-01100000b | 01010110b = 01110110b
-01100000b | 01010111b = 01110111b
-01100000b | 01011000b = 01111000b
-01100000b | 01011001b = 01111001b
-01100000b | 01011010b = 01111010b
-01100000b | 01011011b = 01111011b
-01100000b | 01011100b = 01111100b
-01100000b | 01011101b = 01111101b
-01100000b | 01011110b = 01111110b
-01100000b | 01011111b = 01111111b
-01100000b | 01100000b = 01100000b
-01100000b | 01100001b = 01100001b
-01100000b | 01100010b = 01100010b
-01100000b | 01100011b = 01100011b
-01100000b | 01100100b = 01100100b
-01100000b | 01100101b = 01100101b
-01100000b | 01100110b = 01100110b
-01100000b | 01100111b = 01100111b
-01100000b | 01101000b = 01101000b
-01100000b | 01101001b = 01101001b
-01100000b | 01101010b = 01101010b
-01100000b | 01101011b = 01101011b
-01100000b | 01101100b = 01101100b
-01100000b | 01101101b = 01101101b
-01100000b | 01101110b = 01101110b
-01100000b | 01101111b = 01101111b
-01100000b | 01110000b = 01110000b
-01100000b | 01110001b = 01110001b
-01100000b | 01110010b = 01110010b
-01100000b | 01110011b = 01110011b
-01100000b | 01110100b = 01110100b
-01100000b | 01110101b = 01110101b
-01100000b | 01110110b = 01110110b
-01100000b | 01110111b = 01110111b
-01100000b | 01111000b = 01111000b
-01100000b | 01111001b = 01111001b
-01100000b | 01111010b = 01111010b
-01100000b | 01111011b = 01111011b
-01100000b | 01111100b = 01111100b
-01100000b | 01111101b = 01111101b
-01100000b | 01111110b = 01111110b
-01100001b | 10000000b = 11100001b
-01100001b | 10000001b = 11100001b
-01100001b | 10000010b = 11100011b
-01100001b | 10000011b = 11100011b
-01100001b | 10000100b = 11100101b
-01100001b | 10000101b = 11100101b
-01100001b | 10000110b = 11100111b
-01100001b | 10000111b = 11100111b
-01100001b | 10001000b = 11101001b
-01100001b | 10001001b = 11101001b
-01100001b | 10001010b = 11101011b
-01100001b | 10001011b = 11101011b
-01100001b | 10001100b = 11101101b
-01100001b | 10001101b = 11101101b
-01100001b | 10001110b = 11101111b
-01100001b | 10001111b = 11101111b
-01100001b | 10010000b = 11110001b
-01100001b | 10010001b = 11110001b
-01100001b | 10010010b = 11110011b
-01100001b | 10010011b = 11110011b
-01100001b | 10010100b = 11110101b
-01100001b | 10010101b = 11110101b
-01100001b | 10010110b = 11110111b
-01100001b | 10010111b = 11110111b
-01100001b | 10011000b = 11111001b
-01100001b | 10011001b = 11111001b
-01100001b | 10011010b = 11111011b
-01100001b | 10011011b = 11111011b
-01100001b | 10011100b = 11111101b
-01100001b | 10011101b = 11111101b
-01100001b | 10011110b = 11111111b
-01100001b | 10011111b = 11111111b
-01100001b | 10100000b = 11100001b
-01100001b | 10100001b = 11100001b
-01100001b | 10100010b = 11100011b
-01100001b | 10100011b = 11100011b
-01100001b | 10100100b = 11100101b
-01100001b | 10100101b = 11100101b
-01100001b | 10100110b = 11100111b
-01100001b | 10100111b = 11100111b
-01100001b | 10101000b = 11101001b
-01100001b | 10101001b = 11101001b
-01100001b | 10101010b = 11101011b
-01100001b | 10101011b = 11101011b
-01100001b | 10101100b = 11101101b
-01100001b | 10101101b = 11101101b
-01100001b | 10101110b = 11101111b
-01100001b | 10101111b = 11101111b
-01100001b | 10110000b = 11110001b
-01100001b | 10110001b = 11110001b
-01100001b | 10110010b = 11110011b
-01100001b | 10110011b = 11110011b
-01100001b | 10110100b = 11110101b
-01100001b | 10110101b = 11110101b
-01100001b | 10110110b = 11110111b
-01100001b | 10110111b = 11110111b
-01100001b | 10111000b = 11111001b
-01100001b | 10111001b = 11111001b
-01100001b | 10111010b = 11111011b
-01100001b | 10111011b = 11111011b
-01100001b | 10111100b = 11111101b
-01100001b | 10111101b = 11111101b
-01100001b | 10111110b = 11111111b
-01100001b | 10111111b = 11111111b
-01100001b | 11000000b = 11100001b
-01100001b | 11000001b = 11100001b
-01100001b | 11000010b = 11100011b
-01100001b | 11000011b = 11100011b
-01100001b | 11000100b = 11100101b
-01100001b | 11000101b = 11100101b
-01100001b | 11000110b = 11100111b
-01100001b | 11000111b = 11100111b
-01100001b | 11001000b = 11101001b
-01100001b | 11001001b = 11101001b
-01100001b | 11001010b = 11101011b
-01100001b | 11001011b = 11101011b
-01100001b | 11001100b = 11101101b
-01100001b | 11001101b = 11101101b
-01100001b | 11001110b = 11101111b
-01100001b | 11001111b = 11101111b
-01100001b | 11010000b = 11110001b
-01100001b | 11010001b = 11110001b
-01100001b | 11010010b = 11110011b
-01100001b | 11010011b = 11110011b
-01100001b | 11010100b = 11110101b
-01100001b | 11010101b = 11110101b
-01100001b | 11010110b = 11110111b
-01100001b | 11010111b = 11110111b
-01100001b | 11011000b = 11111001b
-01100001b | 11011001b = 11111001b
-01100001b | 11011010b = 11111011b
-01100001b | 11011011b = 11111011b
-01100001b | 11011100b = 11111101b
-01100001b | 11011101b = 11111101b
-01100001b | 11011110b = 11111111b
-01100001b | 11011111b = 11111111b
-01100001b | 11100000b = 11100001b
-01100001b | 11100001b = 11100001b
-01100001b | 11100010b = 11100011b
-01100001b | 11100011b = 11100011b
-01100001b | 11100100b = 11100101b
-01100001b | 11100101b = 11100101b
-01100001b | 11100110b = 11100111b
-01100001b | 11100111b = 11100111b
-01100001b | 11101000b = 11101001b
-01100001b | 11101001b = 11101001b
-01100001b | 11101010b = 11101011b
-01100001b | 11101011b = 11101011b
-01100001b | 11101100b = 11101101b
-01100001b | 11101101b = 11101101b
-01100001b | 11101110b = 11101111b
-01100001b | 11101111b = 11101111b
-01100001b | 11110000b = 11110001b
-01100001b | 11110001b = 11110001b
-01100001b | 11110010b = 11110011b
-01100001b | 11110011b = 11110011b
-01100001b | 11110100b = 11110101b
-01100001b | 11110101b = 11110101b
-01100001b | 11110110b = 11110111b
-01100001b | 11110111b = 11110111b
-01100001b | 11111000b = 11111001b
-01100001b | 11111001b = 11111001b
-01100001b | 11111010b = 11111011b
-01100001b | 11111011b = 11111011b
-01100001b | 11111100b = 11111101b
-01100001b | 11111101b = 11111101b
-01100001b | 11111110b = 11111111b
-01100001b | 11111111b = 11111111b
-01100001b | 00000000b = 01100001b
-01100001b | 00000001b = 01100001b
-01100001b | 00000010b = 01100011b
-01100001b | 00000011b = 01100011b
-01100001b | 00000100b = 01100101b
-01100001b | 00000101b = 01100101b
-01100001b | 00000110b = 01100111b
-01100001b | 00000111b = 01100111b
-01100001b | 00001000b = 01101001b
-01100001b | 00001001b = 01101001b
-01100001b | 00001010b = 01101011b
-01100001b | 00001011b = 01101011b
-01100001b | 00001100b = 01101101b
-01100001b | 00001101b = 01101101b
-01100001b | 00001110b = 01101111b
-01100001b | 00001111b = 01101111b
-01100001b | 00010000b = 01110001b
-01100001b | 00010001b = 01110001b
-01100001b | 00010010b = 01110011b
-01100001b | 00010011b = 01110011b
-01100001b | 00010100b = 01110101b
-01100001b | 00010101b = 01110101b
-01100001b | 00010110b = 01110111b
-01100001b | 00010111b = 01110111b
-01100001b | 00011000b = 01111001b
-01100001b | 00011001b = 01111001b
-01100001b | 00011010b = 01111011b
-01100001b | 00011011b = 01111011b
-01100001b | 00011100b = 01111101b
-01100001b | 00011101b = 01111101b
-01100001b | 00011110b = 01111111b
-01100001b | 00011111b = 01111111b
-01100001b | 00100000b = 01100001b
-01100001b | 00100001b = 01100001b
-01100001b | 00100010b = 01100011b
-01100001b | 00100011b = 01100011b
-01100001b | 00100100b = 01100101b
-01100001b | 00100101b = 01100101b
-01100001b | 00100110b = 01100111b
-01100001b | 00100111b = 01100111b
-01100001b | 00101000b = 01101001b
-01100001b | 00101001b = 01101001b
-01100001b | 00101010b = 01101011b
-01100001b | 00101011b = 01101011b
-01100001b | 00101100b = 01101101b
-01100001b | 00101101b = 01101101b
-01100001b | 00101110b = 01101111b
-01100001b | 00101111b = 01101111b
-01100001b | 00110000b = 01110001b
-01100001b | 00110001b = 01110001b
-01100001b | 00110010b = 01110011b
-01100001b | 00110011b = 01110011b
-01100001b | 00110100b = 01110101b
-01100001b | 00110101b = 01110101b
-01100001b | 00110110b = 01110111b
-01100001b | 00110111b = 01110111b
-01100001b | 00111000b = 01111001b
-01100001b | 00111001b = 01111001b
-01100001b | 00111010b = 01111011b
-01100001b | 00111011b = 01111011b
-01100001b | 00111100b = 01111101b
-01100001b | 00111101b = 01111101b
-01100001b | 00111110b = 01111111b
-01100001b | 00111111b = 01111111b
-01100001b | 01000000b = 01100001b
-01100001b | 01000001b = 01100001b
-01100001b | 01000010b = 01100011b
-01100001b | 01000011b = 01100011b
-01100001b | 01000100b = 01100101b
-01100001b | 01000101b = 01100101b
-01100001b | 01000110b = 01100111b
-01100001b | 01000111b = 01100111b
-01100001b | 01001000b = 01101001b
-01100001b | 01001001b = 01101001b
-01100001b | 01001010b = 01101011b
-01100001b | 01001011b = 01101011b
-01100001b | 01001100b = 01101101b
-01100001b | 01001101b = 01101101b
-01100001b | 01001110b = 01101111b
-01100001b | 01001111b = 01101111b
-01100001b | 01010000b = 01110001b
-01100001b | 01010001b = 01110001b
-01100001b | 01010010b = 01110011b
-01100001b | 01010011b = 01110011b
-01100001b | 01010100b = 01110101b
-01100001b | 01010101b = 01110101b
-01100001b | 01010110b = 01110111b
-01100001b | 01010111b = 01110111b
-01100001b | 01011000b = 01111001b
-01100001b | 01011001b = 01111001b
-01100001b | 01011010b = 01111011b
-01100001b | 01011011b = 01111011b
-01100001b | 01011100b = 01111101b
-01100001b | 01011101b = 01111101b
-01100001b | 01011110b = 01111111b
-01100001b | 01011111b = 01111111b
-01100001b | 01100000b = 01100001b
-01100001b | 01100001b = 01100001b
-01100001b | 01100010b = 01100011b
-01100001b | 01100011b = 01100011b
-01100001b | 01100100b = 01100101b
-01100001b | 01100101b = 01100101b
-01100001b | 01100110b = 01100111b
-01100001b | 01100111b = 01100111b
-01100001b | 01101000b = 01101001b
-01100001b | 01101001b = 01101001b
-01100001b | 01101010b = 01101011b
-01100001b | 01101011b = 01101011b
-01100001b | 01101100b = 01101101b
-01100001b | 01101101b = 01101101b
-01100001b | 01101110b = 01101111b
-01100001b | 01101111b = 01101111b
-01100001b | 01110000b = 01110001b
-01100001b | 01110001b = 01110001b
-01100001b | 01110010b = 01110011b
-01100001b | 01110011b = 01110011b
-01100001b | 01110100b = 01110101b
-01100001b | 01110101b = 01110101b
-01100001b | 01110110b = 01110111b
-01100001b | 01110111b = 01110111b
-01100001b | 01111000b = 01111001b
-01100001b | 01111001b = 01111001b
-01100001b | 01111010b = 01111011b
-01100001b | 01111011b = 01111011b
-01100001b | 01111100b = 01111101b
-01100001b | 01111101b = 01111101b
-01100001b | 01111110b = 01111111b
-01100010b | 10000000b = 11100010b
-01100010b | 10000001b = 11100011b
-01100010b | 10000010b = 11100010b
-01100010b | 10000011b = 11100011b
-01100010b | 10000100b = 11100110b
-01100010b | 10000101b = 11100111b
-01100010b | 10000110b = 11100110b
-01100010b | 10000111b = 11100111b
-01100010b | 10001000b = 11101010b
-01100010b | 10001001b = 11101011b
-01100010b | 10001010b = 11101010b
-01100010b | 10001011b = 11101011b
-01100010b | 10001100b = 11101110b
-01100010b | 10001101b = 11101111b
-01100010b | 10001110b = 11101110b
-01100010b | 10001111b = 11101111b
-01100010b | 10010000b = 11110010b
-01100010b | 10010001b = 11110011b
-01100010b | 10010010b = 11110010b
-01100010b | 10010011b = 11110011b
-01100010b | 10010100b = 11110110b
-01100010b | 10010101b = 11110111b
-01100010b | 10010110b = 11110110b
-01100010b | 10010111b = 11110111b
-01100010b | 10011000b = 11111010b
-01100010b | 10011001b = 11111011b
-01100010b | 10011010b = 11111010b
-01100010b | 10011011b = 11111011b
-01100010b | 10011100b = 11111110b
-01100010b | 10011101b = 11111111b
-01100010b | 10011110b = 11111110b
-01100010b | 10011111b = 11111111b
-01100010b | 10100000b = 11100010b
-01100010b | 10100001b = 11100011b
-01100010b | 10100010b = 11100010b
-01100010b | 10100011b = 11100011b
-01100010b | 10100100b = 11100110b
-01100010b | 10100101b = 11100111b
-01100010b | 10100110b = 11100110b
-01100010b | 10100111b = 11100111b
-01100010b | 10101000b = 11101010b
-01100010b | 10101001b = 11101011b
-01100010b | 10101010b = 11101010b
-01100010b | 10101011b = 11101011b
-01100010b | 10101100b = 11101110b
-01100010b | 10101101b = 11101111b
-01100010b | 10101110b = 11101110b
-01100010b | 10101111b = 11101111b
-01100010b | 10110000b = 11110010b
-01100010b | 10110001b = 11110011b
-01100010b | 10110010b = 11110010b
-01100010b | 10110011b = 11110011b
-01100010b | 10110100b = 11110110b
-01100010b | 10110101b = 11110111b
-01100010b | 10110110b = 11110110b
-01100010b | 10110111b = 11110111b
-01100010b | 10111000b = 11111010b
-01100010b | 10111001b = 11111011b
-01100010b | 10111010b = 11111010b
-01100010b | 10111011b = 11111011b
-01100010b | 10111100b = 11111110b
-01100010b | 10111101b = 11111111b
-01100010b | 10111110b = 11111110b
-01100010b | 10111111b = 11111111b
-01100010b | 11000000b = 11100010b
-01100010b | 11000001b = 11100011b
-01100010b | 11000010b = 11100010b
-01100010b | 11000011b = 11100011b
-01100010b | 11000100b = 11100110b
-01100010b | 11000101b = 11100111b
-01100010b | 11000110b = 11100110b
-01100010b | 11000111b = 11100111b
-01100010b | 11001000b = 11101010b
-01100010b | 11001001b = 11101011b
-01100010b | 11001010b = 11101010b
-01100010b | 11001011b = 11101011b
-01100010b | 11001100b = 11101110b
-01100010b | 11001101b = 11101111b
-01100010b | 11001110b = 11101110b
-01100010b | 11001111b = 11101111b
-01100010b | 11010000b = 11110010b
-01100010b | 11010001b = 11110011b
-01100010b | 11010010b = 11110010b
-01100010b | 11010011b = 11110011b
-01100010b | 11010100b = 11110110b
-01100010b | 11010101b = 11110111b
-01100010b | 11010110b = 11110110b
-01100010b | 11010111b = 11110111b
-01100010b | 11011000b = 11111010b
-01100010b | 11011001b = 11111011b
-01100010b | 11011010b = 11111010b
-01100010b | 11011011b = 11111011b
-01100010b | 11011100b = 11111110b
-01100010b | 11011101b = 11111111b
-01100010b | 11011110b = 11111110b
-01100010b | 11011111b = 11111111b
-01100010b | 11100000b = 11100010b
-01100010b | 11100001b = 11100011b
-01100010b | 11100010b = 11100010b
-01100010b | 11100011b = 11100011b
-01100010b | 11100100b = 11100110b
-01100010b | 11100101b = 11100111b
-01100010b | 11100110b = 11100110b
-01100010b | 11100111b = 11100111b
-01100010b | 11101000b = 11101010b
-01100010b | 11101001b = 11101011b
-01100010b | 11101010b = 11101010b
-01100010b | 11101011b = 11101011b
-01100010b | 11101100b = 11101110b
-01100010b | 11101101b = 11101111b
-01100010b | 11101110b = 11101110b
-01100010b | 11101111b = 11101111b
-01100010b | 11110000b = 11110010b
-01100010b | 11110001b = 11110011b
-01100010b | 11110010b = 11110010b
-01100010b | 11110011b = 11110011b
-01100010b | 11110100b = 11110110b
-01100010b | 11110101b = 11110111b
-01100010b | 11110110b = 11110110b
-01100010b | 11110111b = 11110111b
-01100010b | 11111000b = 11111010b
-01100010b | 11111001b = 11111011b
-01100010b | 11111010b = 11111010b
-01100010b | 11111011b = 11111011b
-01100010b | 11111100b = 11111110b
-01100010b | 11111101b = 11111111b
-01100010b | 11111110b = 11111110b
-01100010b | 11111111b = 11111111b
-01100010b | 00000000b = 01100010b
-01100010b | 00000001b = 01100011b
-01100010b | 00000010b = 01100010b
-01100010b | 00000011b = 01100011b
-01100010b | 00000100b = 01100110b
-01100010b | 00000101b = 01100111b
-01100010b | 00000110b = 01100110b
-01100010b | 00000111b = 01100111b
-01100010b | 00001000b = 01101010b
-01100010b | 00001001b = 01101011b
-01100010b | 00001010b = 01101010b
-01100010b | 00001011b = 01101011b
-01100010b | 00001100b = 01101110b
-01100010b | 00001101b = 01101111b
-01100010b | 00001110b = 01101110b
-01100010b | 00001111b = 01101111b
-01100010b | 00010000b = 01110010b
-01100010b | 00010001b = 01110011b
-01100010b | 00010010b = 01110010b
-01100010b | 00010011b = 01110011b
-01100010b | 00010100b = 01110110b
-01100010b | 00010101b = 01110111b
-01100010b | 00010110b = 01110110b
-01100010b | 00010111b = 01110111b
-01100010b | 00011000b = 01111010b
-01100010b | 00011001b = 01111011b
-01100010b | 00011010b = 01111010b
-01100010b | 00011011b = 01111011b
-01100010b | 00011100b = 01111110b
-01100010b | 00011101b = 01111111b
-01100010b | 00011110b = 01111110b
-01100010b | 00011111b = 01111111b
-01100010b | 00100000b = 01100010b
-01100010b | 00100001b = 01100011b
-01100010b | 00100010b = 01100010b
-01100010b | 00100011b = 01100011b
-01100010b | 00100100b = 01100110b
-01100010b | 00100101b = 01100111b
-01100010b | 00100110b = 01100110b
-01100010b | 00100111b = 01100111b
-01100010b | 00101000b = 01101010b
-01100010b | 00101001b = 01101011b
-01100010b | 00101010b = 01101010b
-01100010b | 00101011b = 01101011b
-01100010b | 00101100b = 01101110b
-01100010b | 00101101b = 01101111b
-01100010b | 00101110b = 01101110b
-01100010b | 00101111b = 01101111b
-01100010b | 00110000b = 01110010b
-01100010b | 00110001b = 01110011b
-01100010b | 00110010b = 01110010b
-01100010b | 00110011b = 01110011b
-01100010b | 00110100b = 01110110b
-01100010b | 00110101b = 01110111b
-01100010b | 00110110b = 01110110b
-01100010b | 00110111b = 01110111b
-01100010b | 00111000b = 01111010b
-01100010b | 00111001b = 01111011b
-01100010b | 00111010b = 01111010b
-01100010b | 00111011b = 01111011b
-01100010b | 00111100b = 01111110b
-01100010b | 00111101b = 01111111b
-01100010b | 00111110b = 01111110b
-01100010b | 00111111b = 01111111b
-01100010b | 01000000b = 01100010b
-01100010b | 01000001b = 01100011b
-01100010b | 01000010b = 01100010b
-01100010b | 01000011b = 01100011b
-01100010b | 01000100b = 01100110b
-01100010b | 01000101b = 01100111b
-01100010b | 01000110b = 01100110b
-01100010b | 01000111b = 01100111b
-01100010b | 01001000b = 01101010b
-01100010b | 01001001b = 01101011b
-01100010b | 01001010b = 01101010b
-01100010b | 01001011b = 01101011b
-01100010b | 01001100b = 01101110b
-01100010b | 01001101b = 01101111b
-01100010b | 01001110b = 01101110b
-01100010b | 01001111b = 01101111b
-01100010b | 01010000b = 01110010b
-01100010b | 01010001b = 01110011b
-01100010b | 01010010b = 01110010b
-01100010b | 01010011b = 01110011b
-01100010b | 01010100b = 01110110b
-01100010b | 01010101b = 01110111b
-01100010b | 01010110b = 01110110b
-01100010b | 01010111b = 01110111b
-01100010b | 01011000b = 01111010b
-01100010b | 01011001b = 01111011b
-01100010b | 01011010b = 01111010b
-01100010b | 01011011b = 01111011b
-01100010b | 01011100b = 01111110b
-01100010b | 01011101b = 01111111b
-01100010b | 01011110b = 01111110b
-01100010b | 01011111b = 01111111b
-01100010b | 01100000b = 01100010b
-01100010b | 01100001b = 01100011b
-01100010b | 01100010b = 01100010b
-01100010b | 01100011b = 01100011b
-01100010b | 01100100b = 01100110b
-01100010b | 01100101b = 01100111b
-01100010b | 01100110b = 01100110b
-01100010b | 01100111b = 01100111b
-01100010b | 01101000b = 01101010b
-01100010b | 01101001b = 01101011b
-01100010b | 01101010b = 01101010b
-01100010b | 01101011b = 01101011b
-01100010b | 01101100b = 01101110b
-01100010b | 01101101b = 01101111b
-01100010b | 01101110b = 01101110b
-01100010b | 01101111b = 01101111b
-01100010b | 01110000b = 01110010b
-01100010b | 01110001b = 01110011b
-01100010b | 01110010b = 01110010b
-01100010b | 01110011b = 01110011b
-01100010b | 01110100b = 01110110b
-01100010b | 01110101b = 01110111b
-01100010b | 01110110b = 01110110b
-01100010b | 01110111b = 01110111b
-01100010b | 01111000b = 01111010b
-01100010b | 01111001b = 01111011b
-01100010b | 01111010b = 01111010b
-01100010b | 01111011b = 01111011b
-01100010b | 01111100b = 01111110b
-01100010b | 01111101b = 01111111b
-01100010b | 01111110b = 01111110b
-01100011b | 10000000b = 11100011b
-01100011b | 10000001b = 11100011b
-01100011b | 10000010b = 11100011b
-01100011b | 10000011b = 11100011b
-01100011b | 10000100b = 11100111b
-01100011b | 10000101b = 11100111b
-01100011b | 10000110b = 11100111b
-01100011b | 10000111b = 11100111b
-01100011b | 10001000b = 11101011b
-01100011b | 10001001b = 11101011b
-01100011b | 10001010b = 11101011b
-01100011b | 10001011b = 11101011b
-01100011b | 10001100b = 11101111b
-01100011b | 10001101b = 11101111b
-01100011b | 10001110b = 11101111b
-01100011b | 10001111b = 11101111b
-01100011b | 10010000b = 11110011b
-01100011b | 10010001b = 11110011b
-01100011b | 10010010b = 11110011b
-01100011b | 10010011b = 11110011b
-01100011b | 10010100b = 11110111b
-01100011b | 10010101b = 11110111b
-01100011b | 10010110b = 11110111b
-01100011b | 10010111b = 11110111b
-01100011b | 10011000b = 11111011b
-01100011b | 10011001b = 11111011b
-01100011b | 10011010b = 11111011b
-01100011b | 10011011b = 11111011b
-01100011b | 10011100b = 11111111b
-01100011b | 10011101b = 11111111b
-01100011b | 10011110b = 11111111b
-01100011b | 10011111b = 11111111b
-01100011b | 10100000b = 11100011b
-01100011b | 10100001b = 11100011b
-01100011b | 10100010b = 11100011b
-01100011b | 10100011b = 11100011b
-01100011b | 10100100b = 11100111b
-01100011b | 10100101b = 11100111b
-01100011b | 10100110b = 11100111b
-01100011b | 10100111b = 11100111b
-01100011b | 10101000b = 11101011b
-01100011b | 10101001b = 11101011b
-01100011b | 10101010b = 11101011b
-01100011b | 10101011b = 11101011b
-01100011b | 10101100b = 11101111b
-01100011b | 10101101b = 11101111b
-01100011b | 10101110b = 11101111b
-01100011b | 10101111b = 11101111b
-01100011b | 10110000b = 11110011b
-01100011b | 10110001b = 11110011b
-01100011b | 10110010b = 11110011b
-01100011b | 10110011b = 11110011b
-01100011b | 10110100b = 11110111b
-01100011b | 10110101b = 11110111b
-01100011b | 10110110b = 11110111b
-01100011b | 10110111b = 11110111b
-01100011b | 10111000b = 11111011b
-01100011b | 10111001b = 11111011b
-01100011b | 10111010b = 11111011b
-01100011b | 10111011b = 11111011b
-01100011b | 10111100b = 11111111b
-01100011b | 10111101b = 11111111b
-01100011b | 10111110b = 11111111b
-01100011b | 10111111b = 11111111b
-01100011b | 11000000b = 11100011b
-01100011b | 11000001b = 11100011b
-01100011b | 11000010b = 11100011b
-01100011b | 11000011b = 11100011b
-01100011b | 11000100b = 11100111b
-01100011b | 11000101b = 11100111b
-01100011b | 11000110b = 11100111b
-01100011b | 11000111b = 11100111b
-01100011b | 11001000b = 11101011b
-01100011b | 11001001b = 11101011b
-01100011b | 11001010b = 11101011b
-01100011b | 11001011b = 11101011b
-01100011b | 11001100b = 11101111b
-01100011b | 11001101b = 11101111b
-01100011b | 11001110b = 11101111b
-01100011b | 11001111b = 11101111b
-01100011b | 11010000b = 11110011b
-01100011b | 11010001b = 11110011b
-01100011b | 11010010b = 11110011b
-01100011b | 11010011b = 11110011b
-01100011b | 11010100b = 11110111b
-01100011b | 11010101b = 11110111b
-01100011b | 11010110b = 11110111b
-01100011b | 11010111b = 11110111b
-01100011b | 11011000b = 11111011b
-01100011b | 11011001b = 11111011b
-01100011b | 11011010b = 11111011b
-01100011b | 11011011b = 11111011b
-01100011b | 11011100b = 11111111b
-01100011b | 11011101b = 11111111b
-01100011b | 11011110b = 11111111b
-01100011b | 11011111b = 11111111b
-01100011b | 11100000b = 11100011b
-01100011b | 11100001b = 11100011b
-01100011b | 11100010b = 11100011b
-01100011b | 11100011b = 11100011b
-01100011b | 11100100b = 11100111b
-01100011b | 11100101b = 11100111b
-01100011b | 11100110b = 11100111b
-01100011b | 11100111b = 11100111b
-01100011b | 11101000b = 11101011b
-01100011b | 11101001b = 11101011b
-01100011b | 11101010b = 11101011b
-01100011b | 11101011b = 11101011b
-01100011b | 11101100b = 11101111b
-01100011b | 11101101b = 11101111b
-01100011b | 11101110b = 11101111b
-01100011b | 11101111b = 11101111b
-01100011b | 11110000b = 11110011b
-01100011b | 11110001b = 11110011b
-01100011b | 11110010b = 11110011b
-01100011b | 11110011b = 11110011b
-01100011b | 11110100b = 11110111b
-01100011b | 11110101b = 11110111b
-01100011b | 11110110b = 11110111b
-01100011b | 11110111b = 11110111b
-01100011b | 11111000b = 11111011b
-01100011b | 11111001b = 11111011b
-01100011b | 11111010b = 11111011b
-01100011b | 11111011b = 11111011b
-01100011b | 11111100b = 11111111b
-01100011b | 11111101b = 11111111b
-01100011b | 11111110b = 11111111b
-01100011b | 11111111b = 11111111b
-01100011b | 00000000b = 01100011b
-01100011b | 00000001b = 01100011b
-01100011b | 00000010b = 01100011b
-01100011b | 00000011b = 01100011b
-01100011b | 00000100b = 01100111b
-01100011b | 00000101b = 01100111b
-01100011b | 00000110b = 01100111b
-01100011b | 00000111b = 01100111b
-01100011b | 00001000b = 01101011b
-01100011b | 00001001b = 01101011b
-01100011b | 00001010b = 01101011b
-01100011b | 00001011b = 01101011b
-01100011b | 00001100b = 01101111b
-01100011b | 00001101b = 01101111b
-01100011b | 00001110b = 01101111b
-01100011b | 00001111b = 01101111b
-01100011b | 00010000b = 01110011b
-01100011b | 00010001b = 01110011b
-01100011b | 00010010b = 01110011b
-01100011b | 00010011b = 01110011b
-01100011b | 00010100b = 01110111b
-01100011b | 00010101b = 01110111b
-01100011b | 00010110b = 01110111b
-01100011b | 00010111b = 01110111b
-01100011b | 00011000b = 01111011b
-01100011b | 00011001b = 01111011b
-01100011b | 00011010b = 01111011b
-01100011b | 00011011b = 01111011b
-01100011b | 00011100b = 01111111b
-01100011b | 00011101b = 01111111b
-01100011b | 00011110b = 01111111b
-01100011b | 00011111b = 01111111b
-01100011b | 00100000b = 01100011b
-01100011b | 00100001b = 01100011b
-01100011b | 00100010b = 01100011b
-01100011b | 00100011b = 01100011b
-01100011b | 00100100b = 01100111b
-01100011b | 00100101b = 01100111b
-01100011b | 00100110b = 01100111b
-01100011b | 00100111b = 01100111b
-01100011b | 00101000b = 01101011b
-01100011b | 00101001b = 01101011b
-01100011b | 00101010b = 01101011b
-01100011b | 00101011b = 01101011b
-01100011b | 00101100b = 01101111b
-01100011b | 00101101b = 01101111b
-01100011b | 00101110b = 01101111b
-01100011b | 00101111b = 01101111b
-01100011b | 00110000b = 01110011b
-01100011b | 00110001b = 01110011b
-01100011b | 00110010b = 01110011b
-01100011b | 00110011b = 01110011b
-01100011b | 00110100b = 01110111b
-01100011b | 00110101b = 01110111b
-01100011b | 00110110b = 01110111b
-01100011b | 00110111b = 01110111b
-01100011b | 00111000b = 01111011b
-01100011b | 00111001b = 01111011b
-01100011b | 00111010b = 01111011b
-01100011b | 00111011b = 01111011b
-01100011b | 00111100b = 01111111b
-01100011b | 00111101b = 01111111b
-01100011b | 00111110b = 01111111b
-01100011b | 00111111b = 01111111b
-01100011b | 01000000b = 01100011b
-01100011b | 01000001b = 01100011b
-01100011b | 01000010b = 01100011b
-01100011b | 01000011b = 01100011b
-01100011b | 01000100b = 01100111b
-01100011b | 01000101b = 01100111b
-01100011b | 01000110b = 01100111b
-01100011b | 01000111b = 01100111b
-01100011b | 01001000b = 01101011b
-01100011b | 01001001b = 01101011b
-01100011b | 01001010b = 01101011b
-01100011b | 01001011b = 01101011b
-01100011b | 01001100b = 01101111b
-01100011b | 01001101b = 01101111b
-01100011b | 01001110b = 01101111b
-01100011b | 01001111b = 01101111b
-01100011b | 01010000b = 01110011b
-01100011b | 01010001b = 01110011b
-01100011b | 01010010b = 01110011b
-01100011b | 01010011b = 01110011b
-01100011b | 01010100b = 01110111b
-01100011b | 01010101b = 01110111b
-01100011b | 01010110b = 01110111b
-01100011b | 01010111b = 01110111b
-01100011b | 01011000b = 01111011b
-01100011b | 01011001b = 01111011b
-01100011b | 01011010b = 01111011b
-01100011b | 01011011b = 01111011b
-01100011b | 01011100b = 01111111b
-01100011b | 01011101b = 01111111b
-01100011b | 01011110b = 01111111b
-01100011b | 01011111b = 01111111b
-01100011b | 01100000b = 01100011b
-01100011b | 01100001b = 01100011b
-01100011b | 01100010b = 01100011b
-01100011b | 01100011b = 01100011b
-01100011b | 01100100b = 01100111b
-01100011b | 01100101b = 01100111b
-01100011b | 01100110b = 01100111b
-01100011b | 01100111b = 01100111b
-01100011b | 01101000b = 01101011b
-01100011b | 01101001b = 01101011b
-01100011b | 01101010b = 01101011b
-01100011b | 01101011b = 01101011b
-01100011b | 01101100b = 01101111b
-01100011b | 01101101b = 01101111b
-01100011b | 01101110b = 01101111b
-01100011b | 01101111b = 01101111b
-01100011b | 01110000b = 01110011b
-01100011b | 01110001b = 01110011b
-01100011b | 01110010b = 01110011b
-01100011b | 01110011b = 01110011b
-01100011b | 01110100b = 01110111b
-01100011b | 01110101b = 01110111b
-01100011b | 01110110b = 01110111b
-01100011b | 01110111b = 01110111b
-01100011b | 01111000b = 01111011b
-01100011b | 01111001b = 01111011b
-01100011b | 01111010b = 01111011b
-01100011b | 01111011b = 01111011b
-01100011b | 01111100b = 01111111b
-01100011b | 01111101b = 01111111b
-01100011b | 01111110b = 01111111b
-01100100b | 10000000b = 11100100b
-01100100b | 10000001b = 11100101b
-01100100b | 10000010b = 11100110b
-01100100b | 10000011b = 11100111b
-01100100b | 10000100b = 11100100b
-01100100b | 10000101b = 11100101b
-01100100b | 10000110b = 11100110b
-01100100b | 10000111b = 11100111b
-01100100b | 10001000b = 11101100b
-01100100b | 10001001b = 11101101b
-01100100b | 10001010b = 11101110b
-01100100b | 10001011b = 11101111b
-01100100b | 10001100b = 11101100b
-01100100b | 10001101b = 11101101b
-01100100b | 10001110b = 11101110b
-01100100b | 10001111b = 11101111b
-01100100b | 10010000b = 11110100b
-01100100b | 10010001b = 11110101b
-01100100b | 10010010b = 11110110b
-01100100b | 10010011b = 11110111b
-01100100b | 10010100b = 11110100b
-01100100b | 10010101b = 11110101b
-01100100b | 10010110b = 11110110b
-01100100b | 10010111b = 11110111b
-01100100b | 10011000b = 11111100b
-01100100b | 10011001b = 11111101b
-01100100b | 10011010b = 11111110b
-01100100b | 10011011b = 11111111b
-01100100b | 10011100b = 11111100b
-01100100b | 10011101b = 11111101b
-01100100b | 10011110b = 11111110b
-01100100b | 10011111b = 11111111b
-01100100b | 10100000b = 11100100b
-01100100b | 10100001b = 11100101b
-01100100b | 10100010b = 11100110b
-01100100b | 10100011b = 11100111b
-01100100b | 10100100b = 11100100b
-01100100b | 10100101b = 11100101b
-01100100b | 10100110b = 11100110b
-01100100b | 10100111b = 11100111b
-01100100b | 10101000b = 11101100b
-01100100b | 10101001b = 11101101b
-01100100b | 10101010b = 11101110b
-01100100b | 10101011b = 11101111b
-01100100b | 10101100b = 11101100b
-01100100b | 10101101b = 11101101b
-01100100b | 10101110b = 11101110b
-01100100b | 10101111b = 11101111b
-01100100b | 10110000b = 11110100b
-01100100b | 10110001b = 11110101b
-01100100b | 10110010b = 11110110b
-01100100b | 10110011b = 11110111b
-01100100b | 10110100b = 11110100b
-01100100b | 10110101b = 11110101b
-01100100b | 10110110b = 11110110b
-01100100b | 10110111b = 11110111b
-01100100b | 10111000b = 11111100b
-01100100b | 10111001b = 11111101b
-01100100b | 10111010b = 11111110b
-01100100b | 10111011b = 11111111b
-01100100b | 10111100b = 11111100b
-01100100b | 10111101b = 11111101b
-01100100b | 10111110b = 11111110b
-01100100b | 10111111b = 11111111b
-01100100b | 11000000b = 11100100b
-01100100b | 11000001b = 11100101b
-01100100b | 11000010b = 11100110b
-01100100b | 11000011b = 11100111b
-01100100b | 11000100b = 11100100b
-01100100b | 11000101b = 11100101b
-01100100b | 11000110b = 11100110b
-01100100b | 11000111b = 11100111b
-01100100b | 11001000b = 11101100b
-01100100b | 11001001b = 11101101b
-01100100b | 11001010b = 11101110b
-01100100b | 11001011b = 11101111b
-01100100b | 11001100b = 11101100b
-01100100b | 11001101b = 11101101b
-01100100b | 11001110b = 11101110b
-01100100b | 11001111b = 11101111b
-01100100b | 11010000b = 11110100b
-01100100b | 11010001b = 11110101b
-01100100b | 11010010b = 11110110b
-01100100b | 11010011b = 11110111b
-01100100b | 11010100b = 11110100b
-01100100b | 11010101b = 11110101b
-01100100b | 11010110b = 11110110b
-01100100b | 11010111b = 11110111b
-01100100b | 11011000b = 11111100b
-01100100b | 11011001b = 11111101b
-01100100b | 11011010b = 11111110b
-01100100b | 11011011b = 11111111b
-01100100b | 11011100b = 11111100b
-01100100b | 11011101b = 11111101b
-01100100b | 11011110b = 11111110b
-01100100b | 11011111b = 11111111b
-01100100b | 11100000b = 11100100b
-01100100b | 11100001b = 11100101b
-01100100b | 11100010b = 11100110b
-01100100b | 11100011b = 11100111b
-01100100b | 11100100b = 11100100b
-01100100b | 11100101b = 11100101b
-01100100b | 11100110b = 11100110b
-01100100b | 11100111b = 11100111b
-01100100b | 11101000b = 11101100b
-01100100b | 11101001b = 11101101b
-01100100b | 11101010b = 11101110b
-01100100b | 11101011b = 11101111b
-01100100b | 11101100b = 11101100b
-01100100b | 11101101b = 11101101b
-01100100b | 11101110b = 11101110b
-01100100b | 11101111b = 11101111b
-01100100b | 11110000b = 11110100b
-01100100b | 11110001b = 11110101b
-01100100b | 11110010b = 11110110b
-01100100b | 11110011b = 11110111b
-01100100b | 11110100b = 11110100b
-01100100b | 11110101b = 11110101b
-01100100b | 11110110b = 11110110b
-01100100b | 11110111b = 11110111b
-01100100b | 11111000b = 11111100b
-01100100b | 11111001b = 11111101b
-01100100b | 11111010b = 11111110b
-01100100b | 11111011b = 11111111b
-01100100b | 11111100b = 11111100b
-01100100b | 11111101b = 11111101b
-01100100b | 11111110b = 11111110b
-01100100b | 11111111b = 11111111b
-01100100b | 00000000b = 01100100b
-01100100b | 00000001b = 01100101b
-01100100b | 00000010b = 01100110b
-01100100b | 00000011b = 01100111b
-01100100b | 00000100b = 01100100b
-01100100b | 00000101b = 01100101b
-01100100b | 00000110b = 01100110b
-01100100b | 00000111b = 01100111b
-01100100b | 00001000b = 01101100b
-01100100b | 00001001b = 01101101b
-01100100b | 00001010b = 01101110b
-01100100b | 00001011b = 01101111b
-01100100b | 00001100b = 01101100b
-01100100b | 00001101b = 01101101b
-01100100b | 00001110b = 01101110b
-01100100b | 00001111b = 01101111b
-01100100b | 00010000b = 01110100b
-01100100b | 00010001b = 01110101b
-01100100b | 00010010b = 01110110b
-01100100b | 00010011b = 01110111b
-01100100b | 00010100b = 01110100b
-01100100b | 00010101b = 01110101b
-01100100b | 00010110b = 01110110b
-01100100b | 00010111b = 01110111b
-01100100b | 00011000b = 01111100b
-01100100b | 00011001b = 01111101b
-01100100b | 00011010b = 01111110b
-01100100b | 00011011b = 01111111b
-01100100b | 00011100b = 01111100b
-01100100b | 00011101b = 01111101b
-01100100b | 00011110b = 01111110b
-01100100b | 00011111b = 01111111b
-01100100b | 00100000b = 01100100b
-01100100b | 00100001b = 01100101b
-01100100b | 00100010b = 01100110b
-01100100b | 00100011b = 01100111b
-01100100b | 00100100b = 01100100b
-01100100b | 00100101b = 01100101b
-01100100b | 00100110b = 01100110b
-01100100b | 00100111b = 01100111b
-01100100b | 00101000b = 01101100b
-01100100b | 00101001b = 01101101b
-01100100b | 00101010b = 01101110b
-01100100b | 00101011b = 01101111b
-01100100b | 00101100b = 01101100b
-01100100b | 00101101b = 01101101b
-01100100b | 00101110b = 01101110b
-01100100b | 00101111b = 01101111b
-01100100b | 00110000b = 01110100b
-01100100b | 00110001b = 01110101b
-01100100b | 00110010b = 01110110b
-01100100b | 00110011b = 01110111b
-01100100b | 00110100b = 01110100b
-01100100b | 00110101b = 01110101b
-01100100b | 00110110b = 01110110b
-01100100b | 00110111b = 01110111b
-01100100b | 00111000b = 01111100b
-01100100b | 00111001b = 01111101b
-01100100b | 00111010b = 01111110b
-01100100b | 00111011b = 01111111b
-01100100b | 00111100b = 01111100b
-01100100b | 00111101b = 01111101b
-01100100b | 00111110b = 01111110b
-01100100b | 00111111b = 01111111b
-01100100b | 01000000b = 01100100b
-01100100b | 01000001b = 01100101b
-01100100b | 01000010b = 01100110b
-01100100b | 01000011b = 01100111b
-01100100b | 01000100b = 01100100b
-01100100b | 01000101b = 01100101b
-01100100b | 01000110b = 01100110b
-01100100b | 01000111b = 01100111b
-01100100b | 01001000b = 01101100b
-01100100b | 01001001b = 01101101b
-01100100b | 01001010b = 01101110b
-01100100b | 01001011b = 01101111b
-01100100b | 01001100b = 01101100b
-01100100b | 01001101b = 01101101b
-01100100b | 01001110b = 01101110b
-01100100b | 01001111b = 01101111b
-01100100b | 01010000b = 01110100b
-01100100b | 01010001b = 01110101b
-01100100b | 01010010b = 01110110b
-01100100b | 01010011b = 01110111b
-01100100b | 01010100b = 01110100b
-01100100b | 01010101b = 01110101b
-01100100b | 01010110b = 01110110b
-01100100b | 01010111b = 01110111b
-01100100b | 01011000b = 01111100b
-01100100b | 01011001b = 01111101b
-01100100b | 01011010b = 01111110b
-01100100b | 01011011b = 01111111b
-01100100b | 01011100b = 01111100b
-01100100b | 01011101b = 01111101b
-01100100b | 01011110b = 01111110b
-01100100b | 01011111b = 01111111b
-01100100b | 01100000b = 01100100b
-01100100b | 01100001b = 01100101b
-01100100b | 01100010b = 01100110b
-01100100b | 01100011b = 01100111b
-01100100b | 01100100b = 01100100b
-01100100b | 01100101b = 01100101b
-01100100b | 01100110b = 01100110b
-01100100b | 01100111b = 01100111b
-01100100b | 01101000b = 01101100b
-01100100b | 01101001b = 01101101b
-01100100b | 01101010b = 01101110b
-01100100b | 01101011b = 01101111b
-01100100b | 01101100b = 01101100b
-01100100b | 01101101b = 01101101b
-01100100b | 01101110b = 01101110b
-01100100b | 01101111b = 01101111b
-01100100b | 01110000b = 01110100b
-01100100b | 01110001b = 01110101b
-01100100b | 01110010b = 01110110b
-01100100b | 01110011b = 01110111b
-01100100b | 01110100b = 01110100b
-01100100b | 01110101b = 01110101b
-01100100b | 01110110b = 01110110b
-01100100b | 01110111b = 01110111b
-01100100b | 01111000b = 01111100b
-01100100b | 01111001b = 01111101b
-01100100b | 01111010b = 01111110b
-01100100b | 01111011b = 01111111b
-01100100b | 01111100b = 01111100b
-01100100b | 01111101b = 01111101b
-01100100b | 01111110b = 01111110b
-01100101b | 10000000b = 11100101b
-01100101b | 10000001b = 11100101b
-01100101b | 10000010b = 11100111b
-01100101b | 10000011b = 11100111b
-01100101b | 10000100b = 11100101b
-01100101b | 10000101b = 11100101b
-01100101b | 10000110b = 11100111b
-01100101b | 10000111b = 11100111b
-01100101b | 10001000b = 11101101b
-01100101b | 10001001b = 11101101b
-01100101b | 10001010b = 11101111b
-01100101b | 10001011b = 11101111b
-01100101b | 10001100b = 11101101b
-01100101b | 10001101b = 11101101b
-01100101b | 10001110b = 11101111b
-01100101b | 10001111b = 11101111b
-01100101b | 10010000b = 11110101b
-01100101b | 10010001b = 11110101b
-01100101b | 10010010b = 11110111b
-01100101b | 10010011b = 11110111b
-01100101b | 10010100b = 11110101b
-01100101b | 10010101b = 11110101b
-01100101b | 10010110b = 11110111b
-01100101b | 10010111b = 11110111b
-01100101b | 10011000b = 11111101b
-01100101b | 10011001b = 11111101b
-01100101b | 10011010b = 11111111b
-01100101b | 10011011b = 11111111b
-01100101b | 10011100b = 11111101b
-01100101b | 10011101b = 11111101b
-01100101b | 10011110b = 11111111b
-01100101b | 10011111b = 11111111b
-01100101b | 10100000b = 11100101b
-01100101b | 10100001b = 11100101b
-01100101b | 10100010b = 11100111b
-01100101b | 10100011b = 11100111b
-01100101b | 10100100b = 11100101b
-01100101b | 10100101b = 11100101b
-01100101b | 10100110b = 11100111b
-01100101b | 10100111b = 11100111b
-01100101b | 10101000b = 11101101b
-01100101b | 10101001b = 11101101b
-01100101b | 10101010b = 11101111b
-01100101b | 10101011b = 11101111b
-01100101b | 10101100b = 11101101b
-01100101b | 10101101b = 11101101b
-01100101b | 10101110b = 11101111b
-01100101b | 10101111b = 11101111b
-01100101b | 10110000b = 11110101b
-01100101b | 10110001b = 11110101b
-01100101b | 10110010b = 11110111b
-01100101b | 10110011b = 11110111b
-01100101b | 10110100b = 11110101b
-01100101b | 10110101b = 11110101b
-01100101b | 10110110b = 11110111b
-01100101b | 10110111b = 11110111b
-01100101b | 10111000b = 11111101b
-01100101b | 10111001b = 11111101b
-01100101b | 10111010b = 11111111b
-01100101b | 10111011b = 11111111b
-01100101b | 10111100b = 11111101b
-01100101b | 10111101b = 11111101b
-01100101b | 10111110b = 11111111b
-01100101b | 10111111b = 11111111b
-01100101b | 11000000b = 11100101b
-01100101b | 11000001b = 11100101b
-01100101b | 11000010b = 11100111b
-01100101b | 11000011b = 11100111b
-01100101b | 11000100b = 11100101b
-01100101b | 11000101b = 11100101b
-01100101b | 11000110b = 11100111b
-01100101b | 11000111b = 11100111b
-01100101b | 11001000b = 11101101b
-01100101b | 11001001b = 11101101b
-01100101b | 11001010b = 11101111b
-01100101b | 11001011b = 11101111b
-01100101b | 11001100b = 11101101b
-01100101b | 11001101b = 11101101b
-01100101b | 11001110b = 11101111b
-01100101b | 11001111b = 11101111b
-01100101b | 11010000b = 11110101b
-01100101b | 11010001b = 11110101b
-01100101b | 11010010b = 11110111b
-01100101b | 11010011b = 11110111b
-01100101b | 11010100b = 11110101b
-01100101b | 11010101b = 11110101b
-01100101b | 11010110b = 11110111b
-01100101b | 11010111b = 11110111b
-01100101b | 11011000b = 11111101b
-01100101b | 11011001b = 11111101b
-01100101b | 11011010b = 11111111b
-01100101b | 11011011b = 11111111b
-01100101b | 11011100b = 11111101b
-01100101b | 11011101b = 11111101b
-01100101b | 11011110b = 11111111b
-01100101b | 11011111b = 11111111b
-01100101b | 11100000b = 11100101b
-01100101b | 11100001b = 11100101b
-01100101b | 11100010b = 11100111b
-01100101b | 11100011b = 11100111b
-01100101b | 11100100b = 11100101b
-01100101b | 11100101b = 11100101b
-01100101b | 11100110b = 11100111b
-01100101b | 11100111b = 11100111b
-01100101b | 11101000b = 11101101b
-01100101b | 11101001b = 11101101b
-01100101b | 11101010b = 11101111b
-01100101b | 11101011b = 11101111b
-01100101b | 11101100b = 11101101b
-01100101b | 11101101b = 11101101b
-01100101b | 11101110b = 11101111b
-01100101b | 11101111b = 11101111b
-01100101b | 11110000b = 11110101b
-01100101b | 11110001b = 11110101b
-01100101b | 11110010b = 11110111b
-01100101b | 11110011b = 11110111b
-01100101b | 11110100b = 11110101b
-01100101b | 11110101b = 11110101b
-01100101b | 11110110b = 11110111b
-01100101b | 11110111b = 11110111b
-01100101b | 11111000b = 11111101b
-01100101b | 11111001b = 11111101b
-01100101b | 11111010b = 11111111b
-01100101b | 11111011b = 11111111b
-01100101b | 11111100b = 11111101b
-01100101b | 11111101b = 11111101b
-01100101b | 11111110b = 11111111b
-01100101b | 11111111b = 11111111b
-01100101b | 00000000b = 01100101b
-01100101b | 00000001b = 01100101b
-01100101b | 00000010b = 01100111b
-01100101b | 00000011b = 01100111b
-01100101b | 00000100b = 01100101b
-01100101b | 00000101b = 01100101b
-01100101b | 00000110b = 01100111b
-01100101b | 00000111b = 01100111b
-01100101b | 00001000b = 01101101b
-01100101b | 00001001b = 01101101b
-01100101b | 00001010b = 01101111b
-01100101b | 00001011b = 01101111b
-01100101b | 00001100b = 01101101b
-01100101b | 00001101b = 01101101b
-01100101b | 00001110b = 01101111b
-01100101b | 00001111b = 01101111b
-01100101b | 00010000b = 01110101b
-01100101b | 00010001b = 01110101b
-01100101b | 00010010b = 01110111b
-01100101b | 00010011b = 01110111b
-01100101b | 00010100b = 01110101b
-01100101b | 00010101b = 01110101b
-01100101b | 00010110b = 01110111b
-01100101b | 00010111b = 01110111b
-01100101b | 00011000b = 01111101b
-01100101b | 00011001b = 01111101b
-01100101b | 00011010b = 01111111b
-01100101b | 00011011b = 01111111b
-01100101b | 00011100b = 01111101b
-01100101b | 00011101b = 01111101b
-01100101b | 00011110b = 01111111b
-01100101b | 00011111b = 01111111b
-01100101b | 00100000b = 01100101b
-01100101b | 00100001b = 01100101b
-01100101b | 00100010b = 01100111b
-01100101b | 00100011b = 01100111b
-01100101b | 00100100b = 01100101b
-01100101b | 00100101b = 01100101b
-01100101b | 00100110b = 01100111b
-01100101b | 00100111b = 01100111b
-01100101b | 00101000b = 01101101b
-01100101b | 00101001b = 01101101b
-01100101b | 00101010b = 01101111b
-01100101b | 00101011b = 01101111b
-01100101b | 00101100b = 01101101b
-01100101b | 00101101b = 01101101b
-01100101b | 00101110b = 01101111b
-01100101b | 00101111b = 01101111b
-01100101b | 00110000b = 01110101b
-01100101b | 00110001b = 01110101b
-01100101b | 00110010b = 01110111b
-01100101b | 00110011b = 01110111b
-01100101b | 00110100b = 01110101b
-01100101b | 00110101b = 01110101b
-01100101b | 00110110b = 01110111b
-01100101b | 00110111b = 01110111b
-01100101b | 00111000b = 01111101b
-01100101b | 00111001b = 01111101b
-01100101b | 00111010b = 01111111b
-01100101b | 00111011b = 01111111b
-01100101b | 00111100b = 01111101b
-01100101b | 00111101b = 01111101b
-01100101b | 00111110b = 01111111b
-01100101b | 00111111b = 01111111b
-01100101b | 01000000b = 01100101b
-01100101b | 01000001b = 01100101b
-01100101b | 01000010b = 01100111b
-01100101b | 01000011b = 01100111b
-01100101b | 01000100b = 01100101b
-01100101b | 01000101b = 01100101b
-01100101b | 01000110b = 01100111b
-01100101b | 01000111b = 01100111b
-01100101b | 01001000b = 01101101b
-01100101b | 01001001b = 01101101b
-01100101b | 01001010b = 01101111b
-01100101b | 01001011b = 01101111b
-01100101b | 01001100b = 01101101b
-01100101b | 01001101b = 01101101b
-01100101b | 01001110b = 01101111b
-01100101b | 01001111b = 01101111b
-01100101b | 01010000b = 01110101b
-01100101b | 01010001b = 01110101b
-01100101b | 01010010b = 01110111b
-01100101b | 01010011b = 01110111b
-01100101b | 01010100b = 01110101b
-01100101b | 01010101b = 01110101b
-01100101b | 01010110b = 01110111b
-01100101b | 01010111b = 01110111b
-01100101b | 01011000b = 01111101b
-01100101b | 01011001b = 01111101b
-01100101b | 01011010b = 01111111b
-01100101b | 01011011b = 01111111b
-01100101b | 01011100b = 01111101b
-01100101b | 01011101b = 01111101b
-01100101b | 01011110b = 01111111b
-01100101b | 01011111b = 01111111b
-01100101b | 01100000b = 01100101b
-01100101b | 01100001b = 01100101b
-01100101b | 01100010b = 01100111b
-01100101b | 01100011b = 01100111b
-01100101b | 01100100b = 01100101b
-01100101b | 01100101b = 01100101b
-01100101b | 01100110b = 01100111b
-01100101b | 01100111b = 01100111b
-01100101b | 01101000b = 01101101b
-01100101b | 01101001b = 01101101b
-01100101b | 01101010b = 01101111b
-01100101b | 01101011b = 01101111b
-01100101b | 01101100b = 01101101b
-01100101b | 01101101b = 01101101b
-01100101b | 01101110b = 01101111b
-01100101b | 01101111b = 01101111b
-01100101b | 01110000b = 01110101b
-01100101b | 01110001b = 01110101b
-01100101b | 01110010b = 01110111b
-01100101b | 01110011b = 01110111b
-01100101b | 01110100b = 01110101b
-01100101b | 01110101b = 01110101b
-01100101b | 01110110b = 01110111b
-01100101b | 01110111b = 01110111b
-01100101b | 01111000b = 01111101b
-01100101b | 01111001b = 01111101b
-01100101b | 01111010b = 01111111b
-01100101b | 01111011b = 01111111b
-01100101b | 01111100b = 01111101b
-01100101b | 01111101b = 01111101b
-01100101b | 01111110b = 01111111b
-01100110b | 10000000b = 11100110b
-01100110b | 10000001b = 11100111b
-01100110b | 10000010b = 11100110b
-01100110b | 10000011b = 11100111b
-01100110b | 10000100b = 11100110b
-01100110b | 10000101b = 11100111b
-01100110b | 10000110b = 11100110b
-01100110b | 10000111b = 11100111b
-01100110b | 10001000b = 11101110b
-01100110b | 10001001b = 11101111b
-01100110b | 10001010b = 11101110b
-01100110b | 10001011b = 11101111b
-01100110b | 10001100b = 11101110b
-01100110b | 10001101b = 11101111b
-01100110b | 10001110b = 11101110b
-01100110b | 10001111b = 11101111b
-01100110b | 10010000b = 11110110b
-01100110b | 10010001b = 11110111b
-01100110b | 10010010b = 11110110b
-01100110b | 10010011b = 11110111b
-01100110b | 10010100b = 11110110b
-01100110b | 10010101b = 11110111b
-01100110b | 10010110b = 11110110b
-01100110b | 10010111b = 11110111b
-01100110b | 10011000b = 11111110b
-01100110b | 10011001b = 11111111b
-01100110b | 10011010b = 11111110b
-01100110b | 10011011b = 11111111b
-01100110b | 10011100b = 11111110b
-01100110b | 10011101b = 11111111b
-01100110b | 10011110b = 11111110b
-01100110b | 10011111b = 11111111b
-01100110b | 10100000b = 11100110b
-01100110b | 10100001b = 11100111b
-01100110b | 10100010b = 11100110b
-01100110b | 10100011b = 11100111b
-01100110b | 10100100b = 11100110b
-01100110b | 10100101b = 11100111b
-01100110b | 10100110b = 11100110b
-01100110b | 10100111b = 11100111b
-01100110b | 10101000b = 11101110b
-01100110b | 10101001b = 11101111b
-01100110b | 10101010b = 11101110b
-01100110b | 10101011b = 11101111b
-01100110b | 10101100b = 11101110b
-01100110b | 10101101b = 11101111b
-01100110b | 10101110b = 11101110b
-01100110b | 10101111b = 11101111b
-01100110b | 10110000b = 11110110b
-01100110b | 10110001b = 11110111b
-01100110b | 10110010b = 11110110b
-01100110b | 10110011b = 11110111b
-01100110b | 10110100b = 11110110b
-01100110b | 10110101b = 11110111b
-01100110b | 10110110b = 11110110b
-01100110b | 10110111b = 11110111b
-01100110b | 10111000b = 11111110b
-01100110b | 10111001b = 11111111b
-01100110b | 10111010b = 11111110b
-01100110b | 10111011b = 11111111b
-01100110b | 10111100b = 11111110b
-01100110b | 10111101b = 11111111b
-01100110b | 10111110b = 11111110b
-01100110b | 10111111b = 11111111b
-01100110b | 11000000b = 11100110b
-01100110b | 11000001b = 11100111b
-01100110b | 11000010b = 11100110b
-01100110b | 11000011b = 11100111b
-01100110b | 11000100b = 11100110b
-01100110b | 11000101b = 11100111b
-01100110b | 11000110b = 11100110b
-01100110b | 11000111b = 11100111b
-01100110b | 11001000b = 11101110b
-01100110b | 11001001b = 11101111b
-01100110b | 11001010b = 11101110b
-01100110b | 11001011b = 11101111b
-01100110b | 11001100b = 11101110b
-01100110b | 11001101b = 11101111b
-01100110b | 11001110b = 11101110b
-01100110b | 11001111b = 11101111b
-01100110b | 11010000b = 11110110b
-01100110b | 11010001b = 11110111b
-01100110b | 11010010b = 11110110b
-01100110b | 11010011b = 11110111b
-01100110b | 11010100b = 11110110b
-01100110b | 11010101b = 11110111b
-01100110b | 11010110b = 11110110b
-01100110b | 11010111b = 11110111b
-01100110b | 11011000b = 11111110b
-01100110b | 11011001b = 11111111b
-01100110b | 11011010b = 11111110b
-01100110b | 11011011b = 11111111b
-01100110b | 11011100b = 11111110b
-01100110b | 11011101b = 11111111b
-01100110b | 11011110b = 11111110b
-01100110b | 11011111b = 11111111b
-01100110b | 11100000b = 11100110b
-01100110b | 11100001b = 11100111b
-01100110b | 11100010b = 11100110b
-01100110b | 11100011b = 11100111b
-01100110b | 11100100b = 11100110b
-01100110b | 11100101b = 11100111b
-01100110b | 11100110b = 11100110b
-01100110b | 11100111b = 11100111b
-01100110b | 11101000b = 11101110b
-01100110b | 11101001b = 11101111b
-01100110b | 11101010b = 11101110b
-01100110b | 11101011b = 11101111b
-01100110b | 11101100b = 11101110b
-01100110b | 11101101b = 11101111b
-01100110b | 11101110b = 11101110b
-01100110b | 11101111b = 11101111b
-01100110b | 11110000b = 11110110b
-01100110b | 11110001b = 11110111b
-01100110b | 11110010b = 11110110b
-01100110b | 11110011b = 11110111b
-01100110b | 11110100b = 11110110b
-01100110b | 11110101b = 11110111b
-01100110b | 11110110b = 11110110b
-01100110b | 11110111b = 11110111b
-01100110b | 11111000b = 11111110b
-01100110b | 11111001b = 11111111b
-01100110b | 11111010b = 11111110b
-01100110b | 11111011b = 11111111b
-01100110b | 11111100b = 11111110b
-01100110b | 11111101b = 11111111b
-01100110b | 11111110b = 11111110b
-01100110b | 11111111b = 11111111b
-01100110b | 00000000b = 01100110b
-01100110b | 00000001b = 01100111b
-01100110b | 00000010b = 01100110b
-01100110b | 00000011b = 01100111b
-01100110b | 00000100b = 01100110b
-01100110b | 00000101b = 01100111b
-01100110b | 00000110b = 01100110b
-01100110b | 00000111b = 01100111b
-01100110b | 00001000b = 01101110b
-01100110b | 00001001b = 01101111b
-01100110b | 00001010b = 01101110b
-01100110b | 00001011b = 01101111b
-01100110b | 00001100b = 01101110b
-01100110b | 00001101b = 01101111b
-01100110b | 00001110b = 01101110b
-01100110b | 00001111b = 01101111b
-01100110b | 00010000b = 01110110b
-01100110b | 00010001b = 01110111b
-01100110b | 00010010b = 01110110b
-01100110b | 00010011b = 01110111b
-01100110b | 00010100b = 01110110b
-01100110b | 00010101b = 01110111b
-01100110b | 00010110b = 01110110b
-01100110b | 00010111b = 01110111b
-01100110b | 00011000b = 01111110b
-01100110b | 00011001b = 01111111b
-01100110b | 00011010b = 01111110b
-01100110b | 00011011b = 01111111b
-01100110b | 00011100b = 01111110b
-01100110b | 00011101b = 01111111b
-01100110b | 00011110b = 01111110b
-01100110b | 00011111b = 01111111b
-01100110b | 00100000b = 01100110b
-01100110b | 00100001b = 01100111b
-01100110b | 00100010b = 01100110b
-01100110b | 00100011b = 01100111b
-01100110b | 00100100b = 01100110b
-01100110b | 00100101b = 01100111b
-01100110b | 00100110b = 01100110b
-01100110b | 00100111b = 01100111b
-01100110b | 00101000b = 01101110b
-01100110b | 00101001b = 01101111b
-01100110b | 00101010b = 01101110b
-01100110b | 00101011b = 01101111b
-01100110b | 00101100b = 01101110b
-01100110b | 00101101b = 01101111b
-01100110b | 00101110b = 01101110b
-01100110b | 00101111b = 01101111b
-01100110b | 00110000b = 01110110b
-01100110b | 00110001b = 01110111b
-01100110b | 00110010b = 01110110b
-01100110b | 00110011b = 01110111b
-01100110b | 00110100b = 01110110b
-01100110b | 00110101b = 01110111b
-01100110b | 00110110b = 01110110b
-01100110b | 00110111b = 01110111b
-01100110b | 00111000b = 01111110b
-01100110b | 00111001b = 01111111b
-01100110b | 00111010b = 01111110b
-01100110b | 00111011b = 01111111b
-01100110b | 00111100b = 01111110b
-01100110b | 00111101b = 01111111b
-01100110b | 00111110b = 01111110b
-01100110b | 00111111b = 01111111b
-01100110b | 01000000b = 01100110b
-01100110b | 01000001b = 01100111b
-01100110b | 01000010b = 01100110b
-01100110b | 01000011b = 01100111b
-01100110b | 01000100b = 01100110b
-01100110b | 01000101b = 01100111b
-01100110b | 01000110b = 01100110b
-01100110b | 01000111b = 01100111b
-01100110b | 01001000b = 01101110b
-01100110b | 01001001b = 01101111b
-01100110b | 01001010b = 01101110b
-01100110b | 01001011b = 01101111b
-01100110b | 01001100b = 01101110b
-01100110b | 01001101b = 01101111b
-01100110b | 01001110b = 01101110b
-01100110b | 01001111b = 01101111b
-01100110b | 01010000b = 01110110b
-01100110b | 01010001b = 01110111b
-01100110b | 01010010b = 01110110b
-01100110b | 01010011b = 01110111b
-01100110b | 01010100b = 01110110b
-01100110b | 01010101b = 01110111b
-01100110b | 01010110b = 01110110b
-01100110b | 01010111b = 01110111b
-01100110b | 01011000b = 01111110b
-01100110b | 01011001b = 01111111b
-01100110b | 01011010b = 01111110b
-01100110b | 01011011b = 01111111b
-01100110b | 01011100b = 01111110b
-01100110b | 01011101b = 01111111b
-01100110b | 01011110b = 01111110b
-01100110b | 01011111b = 01111111b
-01100110b | 01100000b = 01100110b
-01100110b | 01100001b = 01100111b
-01100110b | 01100010b = 01100110b
-01100110b | 01100011b = 01100111b
-01100110b | 01100100b = 01100110b
-01100110b | 01100101b = 01100111b
-01100110b | 01100110b = 01100110b
-01100110b | 01100111b = 01100111b
-01100110b | 01101000b = 01101110b
-01100110b | 01101001b = 01101111b
-01100110b | 01101010b = 01101110b
-01100110b | 01101011b = 01101111b
-01100110b | 01101100b = 01101110b
-01100110b | 01101101b = 01101111b
-01100110b | 01101110b = 01101110b
-01100110b | 01101111b = 01101111b
-01100110b | 01110000b = 01110110b
-01100110b | 01110001b = 01110111b
-01100110b | 01110010b = 01110110b
-01100110b | 01110011b = 01110111b
-01100110b | 01110100b = 01110110b
-01100110b | 01110101b = 01110111b
-01100110b | 01110110b = 01110110b
-01100110b | 01110111b = 01110111b
-01100110b | 01111000b = 01111110b
-01100110b | 01111001b = 01111111b
-01100110b | 01111010b = 01111110b
-01100110b | 01111011b = 01111111b
-01100110b | 01111100b = 01111110b
-01100110b | 01111101b = 01111111b
-01100110b | 01111110b = 01111110b
-01100111b | 10000000b = 11100111b
-01100111b | 10000001b = 11100111b
-01100111b | 10000010b = 11100111b
-01100111b | 10000011b = 11100111b
-01100111b | 10000100b = 11100111b
-01100111b | 10000101b = 11100111b
-01100111b | 10000110b = 11100111b
-01100111b | 10000111b = 11100111b
-01100111b | 10001000b = 11101111b
-01100111b | 10001001b = 11101111b
-01100111b | 10001010b = 11101111b
-01100111b | 10001011b = 11101111b
-01100111b | 10001100b = 11101111b
-01100111b | 10001101b = 11101111b
-01100111b | 10001110b = 11101111b
-01100111b | 10001111b = 11101111b
-01100111b | 10010000b = 11110111b
-01100111b | 10010001b = 11110111b
-01100111b | 10010010b = 11110111b
-01100111b | 10010011b = 11110111b
-01100111b | 10010100b = 11110111b
-01100111b | 10010101b = 11110111b
-01100111b | 10010110b = 11110111b
-01100111b | 10010111b = 11110111b
-01100111b | 10011000b = 11111111b
-01100111b | 10011001b = 11111111b
-01100111b | 10011010b = 11111111b
-01100111b | 10011011b = 11111111b
-01100111b | 10011100b = 11111111b
-01100111b | 10011101b = 11111111b
-01100111b | 10011110b = 11111111b
-01100111b | 10011111b = 11111111b
-01100111b | 10100000b = 11100111b
-01100111b | 10100001b = 11100111b
-01100111b | 10100010b = 11100111b
-01100111b | 10100011b = 11100111b
-01100111b | 10100100b = 11100111b
-01100111b | 10100101b = 11100111b
-01100111b | 10100110b = 11100111b
-01100111b | 10100111b = 11100111b
-01100111b | 10101000b = 11101111b
-01100111b | 10101001b = 11101111b
-01100111b | 10101010b = 11101111b
-01100111b | 10101011b = 11101111b
-01100111b | 10101100b = 11101111b
-01100111b | 10101101b = 11101111b
-01100111b | 10101110b = 11101111b
-01100111b | 10101111b = 11101111b
-01100111b | 10110000b = 11110111b
-01100111b | 10110001b = 11110111b
-01100111b | 10110010b = 11110111b
-01100111b | 10110011b = 11110111b
-01100111b | 10110100b = 11110111b
-01100111b | 10110101b = 11110111b
-01100111b | 10110110b = 11110111b
-01100111b | 10110111b = 11110111b
-01100111b | 10111000b = 11111111b
-01100111b | 10111001b = 11111111b
-01100111b | 10111010b = 11111111b
-01100111b | 10111011b = 11111111b
-01100111b | 10111100b = 11111111b
-01100111b | 10111101b = 11111111b
-01100111b | 10111110b = 11111111b
-01100111b | 10111111b = 11111111b
-01100111b | 11000000b = 11100111b
-01100111b | 11000001b = 11100111b
-01100111b | 11000010b = 11100111b
-01100111b | 11000011b = 11100111b
-01100111b | 11000100b = 11100111b
-01100111b | 11000101b = 11100111b
-01100111b | 11000110b = 11100111b
-01100111b | 11000111b = 11100111b
-01100111b | 11001000b = 11101111b
-01100111b | 11001001b = 11101111b
-01100111b | 11001010b = 11101111b
-01100111b | 11001011b = 11101111b
-01100111b | 11001100b = 11101111b
-01100111b | 11001101b = 11101111b
-01100111b | 11001110b = 11101111b
-01100111b | 11001111b = 11101111b
-01100111b | 11010000b = 11110111b
-01100111b | 11010001b = 11110111b
-01100111b | 11010010b = 11110111b
-01100111b | 11010011b = 11110111b
-01100111b | 11010100b = 11110111b
-01100111b | 11010101b = 11110111b
-01100111b | 11010110b = 11110111b
-01100111b | 11010111b = 11110111b
-01100111b | 11011000b = 11111111b
-01100111b | 11011001b = 11111111b
-01100111b | 11011010b = 11111111b
-01100111b | 11011011b = 11111111b
-01100111b | 11011100b = 11111111b
-01100111b | 11011101b = 11111111b
-01100111b | 11011110b = 11111111b
-01100111b | 11011111b = 11111111b
-01100111b | 11100000b = 11100111b
-01100111b | 11100001b = 11100111b
-01100111b | 11100010b = 11100111b
-01100111b | 11100011b = 11100111b
-01100111b | 11100100b = 11100111b
-01100111b | 11100101b = 11100111b
-01100111b | 11100110b = 11100111b
-01100111b | 11100111b = 11100111b
-01100111b | 11101000b = 11101111b
-01100111b | 11101001b = 11101111b
-01100111b | 11101010b = 11101111b
-01100111b | 11101011b = 11101111b
-01100111b | 11101100b = 11101111b
-01100111b | 11101101b = 11101111b
-01100111b | 11101110b = 11101111b
-01100111b | 11101111b = 11101111b
-01100111b | 11110000b = 11110111b
-01100111b | 11110001b = 11110111b
-01100111b | 11110010b = 11110111b
-01100111b | 11110011b = 11110111b
-01100111b | 11110100b = 11110111b
-01100111b | 11110101b = 11110111b
-01100111b | 11110110b = 11110111b
-01100111b | 11110111b = 11110111b
-01100111b | 11111000b = 11111111b
-01100111b | 11111001b = 11111111b
-01100111b | 11111010b = 11111111b
-01100111b | 11111011b = 11111111b
-01100111b | 11111100b = 11111111b
-01100111b | 11111101b = 11111111b
-01100111b | 11111110b = 11111111b
-01100111b | 11111111b = 11111111b
-01100111b | 00000000b = 01100111b
-01100111b | 00000001b = 01100111b
-01100111b | 00000010b = 01100111b
-01100111b | 00000011b = 01100111b
-01100111b | 00000100b = 01100111b
-01100111b | 00000101b = 01100111b
-01100111b | 00000110b = 01100111b
-01100111b | 00000111b = 01100111b
-01100111b | 00001000b = 01101111b
-01100111b | 00001001b = 01101111b
-01100111b | 00001010b = 01101111b
-01100111b | 00001011b = 01101111b
-01100111b | 00001100b = 01101111b
-01100111b | 00001101b = 01101111b
-01100111b | 00001110b = 01101111b
-01100111b | 00001111b = 01101111b
-01100111b | 00010000b = 01110111b
-01100111b | 00010001b = 01110111b
-01100111b | 00010010b = 01110111b
-01100111b | 00010011b = 01110111b
-01100111b | 00010100b = 01110111b
-01100111b | 00010101b = 01110111b
-01100111b | 00010110b = 01110111b
-01100111b | 00010111b = 01110111b
-01100111b | 00011000b = 01111111b
-01100111b | 00011001b = 01111111b
-01100111b | 00011010b = 01111111b
-01100111b | 00011011b = 01111111b
-01100111b | 00011100b = 01111111b
-01100111b | 00011101b = 01111111b
-01100111b | 00011110b = 01111111b
-01100111b | 00011111b = 01111111b
-01100111b | 00100000b = 01100111b
-01100111b | 00100001b = 01100111b
-01100111b | 00100010b = 01100111b
-01100111b | 00100011b = 01100111b
-01100111b | 00100100b = 01100111b
-01100111b | 00100101b = 01100111b
-01100111b | 00100110b = 01100111b
-01100111b | 00100111b = 01100111b
-01100111b | 00101000b = 01101111b
-01100111b | 00101001b = 01101111b
-01100111b | 00101010b = 01101111b
-01100111b | 00101011b = 01101111b
-01100111b | 00101100b = 01101111b
-01100111b | 00101101b = 01101111b
-01100111b | 00101110b = 01101111b
-01100111b | 00101111b = 01101111b
-01100111b | 00110000b = 01110111b
-01100111b | 00110001b = 01110111b
-01100111b | 00110010b = 01110111b
-01100111b | 00110011b = 01110111b
-01100111b | 00110100b = 01110111b
-01100111b | 00110101b = 01110111b
-01100111b | 00110110b = 01110111b
-01100111b | 00110111b = 01110111b
-01100111b | 00111000b = 01111111b
-01100111b | 00111001b = 01111111b
-01100111b | 00111010b = 01111111b
-01100111b | 00111011b = 01111111b
-01100111b | 00111100b = 01111111b
-01100111b | 00111101b = 01111111b
-01100111b | 00111110b = 01111111b
-01100111b | 00111111b = 01111111b
-01100111b | 01000000b = 01100111b
-01100111b | 01000001b = 01100111b
-01100111b | 01000010b = 01100111b
-01100111b | 01000011b = 01100111b
-01100111b | 01000100b = 01100111b
-01100111b | 01000101b = 01100111b
-01100111b | 01000110b = 01100111b
-01100111b | 01000111b = 01100111b
-01100111b | 01001000b = 01101111b
-01100111b | 01001001b = 01101111b
-01100111b | 01001010b = 01101111b
-01100111b | 01001011b = 01101111b
-01100111b | 01001100b = 01101111b
-01100111b | 01001101b = 01101111b
-01100111b | 01001110b = 01101111b
-01100111b | 01001111b = 01101111b
-01100111b | 01010000b = 01110111b
-01100111b | 01010001b = 01110111b
-01100111b | 01010010b = 01110111b
-01100111b | 01010011b = 01110111b
-01100111b | 01010100b = 01110111b
-01100111b | 01010101b = 01110111b
-01100111b | 01010110b = 01110111b
-01100111b | 01010111b = 01110111b
-01100111b | 01011000b = 01111111b
-01100111b | 01011001b = 01111111b
-01100111b | 01011010b = 01111111b
-01100111b | 01011011b = 01111111b
-01100111b | 01011100b = 01111111b
-01100111b | 01011101b = 01111111b
-01100111b | 01011110b = 01111111b
-01100111b | 01011111b = 01111111b
-01100111b | 01100000b = 01100111b
-01100111b | 01100001b = 01100111b
-01100111b | 01100010b = 01100111b
-01100111b | 01100011b = 01100111b
-01100111b | 01100100b = 01100111b
-01100111b | 01100101b = 01100111b
-01100111b | 01100110b = 01100111b
-01100111b | 01100111b = 01100111b
-01100111b | 01101000b = 01101111b
-01100111b | 01101001b = 01101111b
-01100111b | 01101010b = 01101111b
-01100111b | 01101011b = 01101111b
-01100111b | 01101100b = 01101111b
-01100111b | 01101101b = 01101111b
-01100111b | 01101110b = 01101111b
-01100111b | 01101111b = 01101111b
-01100111b | 01110000b = 01110111b
-01100111b | 01110001b = 01110111b
-01100111b | 01110010b = 01110111b
-01100111b | 01110011b = 01110111b
-01100111b | 01110100b = 01110111b
-01100111b | 01110101b = 01110111b
-01100111b | 01110110b = 01110111b
-01100111b | 01110111b = 01110111b
-01100111b | 01111000b = 01111111b
-01100111b | 01111001b = 01111111b
-01100111b | 01111010b = 01111111b
-01100111b | 01111011b = 01111111b
-01100111b | 01111100b = 01111111b
-01100111b | 01111101b = 01111111b
-01100111b | 01111110b = 01111111b
-01101000b | 10000000b = 11101000b
-01101000b | 10000001b = 11101001b
-01101000b | 10000010b = 11101010b
-01101000b | 10000011b = 11101011b
-01101000b | 10000100b = 11101100b
-01101000b | 10000101b = 11101101b
-01101000b | 10000110b = 11101110b
-01101000b | 10000111b = 11101111b
-01101000b | 10001000b = 11101000b
-01101000b | 10001001b = 11101001b
-01101000b | 10001010b = 11101010b
-01101000b | 10001011b = 11101011b
-01101000b | 10001100b = 11101100b
-01101000b | 10001101b = 11101101b
-01101000b | 10001110b = 11101110b
-01101000b | 10001111b = 11101111b
-01101000b | 10010000b = 11111000b
-01101000b | 10010001b = 11111001b
-01101000b | 10010010b = 11111010b
-01101000b | 10010011b = 11111011b
-01101000b | 10010100b = 11111100b
-01101000b | 10010101b = 11111101b
-01101000b | 10010110b = 11111110b
-01101000b | 10010111b = 11111111b
-01101000b | 10011000b = 11111000b
-01101000b | 10011001b = 11111001b
-01101000b | 10011010b = 11111010b
-01101000b | 10011011b = 11111011b
-01101000b | 10011100b = 11111100b
-01101000b | 10011101b = 11111101b
-01101000b | 10011110b = 11111110b
-01101000b | 10011111b = 11111111b
-01101000b | 10100000b = 11101000b
-01101000b | 10100001b = 11101001b
-01101000b | 10100010b = 11101010b
-01101000b | 10100011b = 11101011b
-01101000b | 10100100b = 11101100b
-01101000b | 10100101b = 11101101b
-01101000b | 10100110b = 11101110b
-01101000b | 10100111b = 11101111b
-01101000b | 10101000b = 11101000b
-01101000b | 10101001b = 11101001b
-01101000b | 10101010b = 11101010b
-01101000b | 10101011b = 11101011b
-01101000b | 10101100b = 11101100b
-01101000b | 10101101b = 11101101b
-01101000b | 10101110b = 11101110b
-01101000b | 10101111b = 11101111b
-01101000b | 10110000b = 11111000b
-01101000b | 10110001b = 11111001b
-01101000b | 10110010b = 11111010b
-01101000b | 10110011b = 11111011b
-01101000b | 10110100b = 11111100b
-01101000b | 10110101b = 11111101b
-01101000b | 10110110b = 11111110b
-01101000b | 10110111b = 11111111b
-01101000b | 10111000b = 11111000b
-01101000b | 10111001b = 11111001b
-01101000b | 10111010b = 11111010b
-01101000b | 10111011b = 11111011b
-01101000b | 10111100b = 11111100b
-01101000b | 10111101b = 11111101b
-01101000b | 10111110b = 11111110b
-01101000b | 10111111b = 11111111b
-01101000b | 11000000b = 11101000b
-01101000b | 11000001b = 11101001b
-01101000b | 11000010b = 11101010b
-01101000b | 11000011b = 11101011b
-01101000b | 11000100b = 11101100b
-01101000b | 11000101b = 11101101b
-01101000b | 11000110b = 11101110b
-01101000b | 11000111b = 11101111b
-01101000b | 11001000b = 11101000b
-01101000b | 11001001b = 11101001b
-01101000b | 11001010b = 11101010b
-01101000b | 11001011b = 11101011b
-01101000b | 11001100b = 11101100b
-01101000b | 11001101b = 11101101b
-01101000b | 11001110b = 11101110b
-01101000b | 11001111b = 11101111b
-01101000b | 11010000b = 11111000b
-01101000b | 11010001b = 11111001b
-01101000b | 11010010b = 11111010b
-01101000b | 11010011b = 11111011b
-01101000b | 11010100b = 11111100b
-01101000b | 11010101b = 11111101b
-01101000b | 11010110b = 11111110b
-01101000b | 11010111b = 11111111b
-01101000b | 11011000b = 11111000b
-01101000b | 11011001b = 11111001b
-01101000b | 11011010b = 11111010b
-01101000b | 11011011b = 11111011b
-01101000b | 11011100b = 11111100b
-01101000b | 11011101b = 11111101b
-01101000b | 11011110b = 11111110b
-01101000b | 11011111b = 11111111b
-01101000b | 11100000b = 11101000b
-01101000b | 11100001b = 11101001b
-01101000b | 11100010b = 11101010b
-01101000b | 11100011b = 11101011b
-01101000b | 11100100b = 11101100b
-01101000b | 11100101b = 11101101b
-01101000b | 11100110b = 11101110b
-01101000b | 11100111b = 11101111b
-01101000b | 11101000b = 11101000b
-01101000b | 11101001b = 11101001b
-01101000b | 11101010b = 11101010b
-01101000b | 11101011b = 11101011b
-01101000b | 11101100b = 11101100b
-01101000b | 11101101b = 11101101b
-01101000b | 11101110b = 11101110b
-01101000b | 11101111b = 11101111b
-01101000b | 11110000b = 11111000b
-01101000b | 11110001b = 11111001b
-01101000b | 11110010b = 11111010b
-01101000b | 11110011b = 11111011b
-01101000b | 11110100b = 11111100b
-01101000b | 11110101b = 11111101b
-01101000b | 11110110b = 11111110b
-01101000b | 11110111b = 11111111b
-01101000b | 11111000b = 11111000b
-01101000b | 11111001b = 11111001b
-01101000b | 11111010b = 11111010b
-01101000b | 11111011b = 11111011b
-01101000b | 11111100b = 11111100b
-01101000b | 11111101b = 11111101b
-01101000b | 11111110b = 11111110b
-01101000b | 11111111b = 11111111b
-01101000b | 00000000b = 01101000b
-01101000b | 00000001b = 01101001b
-01101000b | 00000010b = 01101010b
-01101000b | 00000011b = 01101011b
-01101000b | 00000100b = 01101100b
-01101000b | 00000101b = 01101101b
-01101000b | 00000110b = 01101110b
-01101000b | 00000111b = 01101111b
-01101000b | 00001000b = 01101000b
-01101000b | 00001001b = 01101001b
-01101000b | 00001010b = 01101010b
-01101000b | 00001011b = 01101011b
-01101000b | 00001100b = 01101100b
-01101000b | 00001101b = 01101101b
-01101000b | 00001110b = 01101110b
-01101000b | 00001111b = 01101111b
-01101000b | 00010000b = 01111000b
-01101000b | 00010001b = 01111001b
-01101000b | 00010010b = 01111010b
-01101000b | 00010011b = 01111011b
-01101000b | 00010100b = 01111100b
-01101000b | 00010101b = 01111101b
-01101000b | 00010110b = 01111110b
-01101000b | 00010111b = 01111111b
-01101000b | 00011000b = 01111000b
-01101000b | 00011001b = 01111001b
-01101000b | 00011010b = 01111010b
-01101000b | 00011011b = 01111011b
-01101000b | 00011100b = 01111100b
-01101000b | 00011101b = 01111101b
-01101000b | 00011110b = 01111110b
-01101000b | 00011111b = 01111111b
-01101000b | 00100000b = 01101000b
-01101000b | 00100001b = 01101001b
-01101000b | 00100010b = 01101010b
-01101000b | 00100011b = 01101011b
-01101000b | 00100100b = 01101100b
-01101000b | 00100101b = 01101101b
-01101000b | 00100110b = 01101110b
-01101000b | 00100111b = 01101111b
-01101000b | 00101000b = 01101000b
-01101000b | 00101001b = 01101001b
-01101000b | 00101010b = 01101010b
-01101000b | 00101011b = 01101011b
-01101000b | 00101100b = 01101100b
-01101000b | 00101101b = 01101101b
-01101000b | 00101110b = 01101110b
-01101000b | 00101111b = 01101111b
-01101000b | 00110000b = 01111000b
-01101000b | 00110001b = 01111001b
-01101000b | 00110010b = 01111010b
-01101000b | 00110011b = 01111011b
-01101000b | 00110100b = 01111100b
-01101000b | 00110101b = 01111101b
-01101000b | 00110110b = 01111110b
-01101000b | 00110111b = 01111111b
-01101000b | 00111000b = 01111000b
-01101000b | 00111001b = 01111001b
-01101000b | 00111010b = 01111010b
-01101000b | 00111011b = 01111011b
-01101000b | 00111100b = 01111100b
-01101000b | 00111101b = 01111101b
-01101000b | 00111110b = 01111110b
-01101000b | 00111111b = 01111111b
-01101000b | 01000000b = 01101000b
-01101000b | 01000001b = 01101001b
-01101000b | 01000010b = 01101010b
-01101000b | 01000011b = 01101011b
-01101000b | 01000100b = 01101100b
-01101000b | 01000101b = 01101101b
-01101000b | 01000110b = 01101110b
-01101000b | 01000111b = 01101111b
-01101000b | 01001000b = 01101000b
-01101000b | 01001001b = 01101001b
-01101000b | 01001010b = 01101010b
-01101000b | 01001011b = 01101011b
-01101000b | 01001100b = 01101100b
-01101000b | 01001101b = 01101101b
-01101000b | 01001110b = 01101110b
-01101000b | 01001111b = 01101111b
-01101000b | 01010000b = 01111000b
-01101000b | 01010001b = 01111001b
-01101000b | 01010010b = 01111010b
-01101000b | 01010011b = 01111011b
-01101000b | 01010100b = 01111100b
-01101000b | 01010101b = 01111101b
-01101000b | 01010110b = 01111110b
-01101000b | 01010111b = 01111111b
-01101000b | 01011000b = 01111000b
-01101000b | 01011001b = 01111001b
-01101000b | 01011010b = 01111010b
-01101000b | 01011011b = 01111011b
-01101000b | 01011100b = 01111100b
-01101000b | 01011101b = 01111101b
-01101000b | 01011110b = 01111110b
-01101000b | 01011111b = 01111111b
-01101000b | 01100000b = 01101000b
-01101000b | 01100001b = 01101001b
-01101000b | 01100010b = 01101010b
-01101000b | 01100011b = 01101011b
-01101000b | 01100100b = 01101100b
-01101000b | 01100101b = 01101101b
-01101000b | 01100110b = 01101110b
-01101000b | 01100111b = 01101111b
-01101000b | 01101000b = 01101000b
-01101000b | 01101001b = 01101001b
-01101000b | 01101010b = 01101010b
-01101000b | 01101011b = 01101011b
-01101000b | 01101100b = 01101100b
-01101000b | 01101101b = 01101101b
-01101000b | 01101110b = 01101110b
-01101000b | 01101111b = 01101111b
-01101000b | 01110000b = 01111000b
-01101000b | 01110001b = 01111001b
-01101000b | 01110010b = 01111010b
-01101000b | 01110011b = 01111011b
-01101000b | 01110100b = 01111100b
-01101000b | 01110101b = 01111101b
-01101000b | 01110110b = 01111110b
-01101000b | 01110111b = 01111111b
-01101000b | 01111000b = 01111000b
-01101000b | 01111001b = 01111001b
-01101000b | 01111010b = 01111010b
-01101000b | 01111011b = 01111011b
-01101000b | 01111100b = 01111100b
-01101000b | 01111101b = 01111101b
-01101000b | 01111110b = 01111110b
-01101001b | 10000000b = 11101001b
-01101001b | 10000001b = 11101001b
-01101001b | 10000010b = 11101011b
-01101001b | 10000011b = 11101011b
-01101001b | 10000100b = 11101101b
-01101001b | 10000101b = 11101101b
-01101001b | 10000110b = 11101111b
-01101001b | 10000111b = 11101111b
-01101001b | 10001000b = 11101001b
-01101001b | 10001001b = 11101001b
-01101001b | 10001010b = 11101011b
-01101001b | 10001011b = 11101011b
-01101001b | 10001100b = 11101101b
-01101001b | 10001101b = 11101101b
-01101001b | 10001110b = 11101111b
-01101001b | 10001111b = 11101111b
-01101001b | 10010000b = 11111001b
-01101001b | 10010001b = 11111001b
-01101001b | 10010010b = 11111011b
-01101001b | 10010011b = 11111011b
-01101001b | 10010100b = 11111101b
-01101001b | 10010101b = 11111101b
-01101001b | 10010110b = 11111111b
-01101001b | 10010111b = 11111111b
-01101001b | 10011000b = 11111001b
-01101001b | 10011001b = 11111001b
-01101001b | 10011010b = 11111011b
-01101001b | 10011011b = 11111011b
-01101001b | 10011100b = 11111101b
-01101001b | 10011101b = 11111101b
-01101001b | 10011110b = 11111111b
-01101001b | 10011111b = 11111111b
-01101001b | 10100000b = 11101001b
-01101001b | 10100001b = 11101001b
-01101001b | 10100010b = 11101011b
-01101001b | 10100011b = 11101011b
-01101001b | 10100100b = 11101101b
-01101001b | 10100101b = 11101101b
-01101001b | 10100110b = 11101111b
-01101001b | 10100111b = 11101111b
-01101001b | 10101000b = 11101001b
-01101001b | 10101001b = 11101001b
-01101001b | 10101010b = 11101011b
-01101001b | 10101011b = 11101011b
-01101001b | 10101100b = 11101101b
-01101001b | 10101101b = 11101101b
-01101001b | 10101110b = 11101111b
-01101001b | 10101111b = 11101111b
-01101001b | 10110000b = 11111001b
-01101001b | 10110001b = 11111001b
-01101001b | 10110010b = 11111011b
-01101001b | 10110011b = 11111011b
-01101001b | 10110100b = 11111101b
-01101001b | 10110101b = 11111101b
-01101001b | 10110110b = 11111111b
-01101001b | 10110111b = 11111111b
-01101001b | 10111000b = 11111001b
-01101001b | 10111001b = 11111001b
-01101001b | 10111010b = 11111011b
-01101001b | 10111011b = 11111011b
-01101001b | 10111100b = 11111101b
-01101001b | 10111101b = 11111101b
-01101001b | 10111110b = 11111111b
-01101001b | 10111111b = 11111111b
-01101001b | 11000000b = 11101001b
-01101001b | 11000001b = 11101001b
-01101001b | 11000010b = 11101011b
-01101001b | 11000011b = 11101011b
-01101001b | 11000100b = 11101101b
-01101001b | 11000101b = 11101101b
-01101001b | 11000110b = 11101111b
-01101001b | 11000111b = 11101111b
-01101001b | 11001000b = 11101001b
-01101001b | 11001001b = 11101001b
-01101001b | 11001010b = 11101011b
-01101001b | 11001011b = 11101011b
-01101001b | 11001100b = 11101101b
-01101001b | 11001101b = 11101101b
-01101001b | 11001110b = 11101111b
-01101001b | 11001111b = 11101111b
-01101001b | 11010000b = 11111001b
-01101001b | 11010001b = 11111001b
-01101001b | 11010010b = 11111011b
-01101001b | 11010011b = 11111011b
-01101001b | 11010100b = 11111101b
-01101001b | 11010101b = 11111101b
-01101001b | 11010110b = 11111111b
-01101001b | 11010111b = 11111111b
-01101001b | 11011000b = 11111001b
-01101001b | 11011001b = 11111001b
-01101001b | 11011010b = 11111011b
-01101001b | 11011011b = 11111011b
-01101001b | 11011100b = 11111101b
-01101001b | 11011101b = 11111101b
-01101001b | 11011110b = 11111111b
-01101001b | 11011111b = 11111111b
-01101001b | 11100000b = 11101001b
-01101001b | 11100001b = 11101001b
-01101001b | 11100010b = 11101011b
-01101001b | 11100011b = 11101011b
-01101001b | 11100100b = 11101101b
-01101001b | 11100101b = 11101101b
-01101001b | 11100110b = 11101111b
-01101001b | 11100111b = 11101111b
-01101001b | 11101000b = 11101001b
-01101001b | 11101001b = 11101001b
-01101001b | 11101010b = 11101011b
-01101001b | 11101011b = 11101011b
-01101001b | 11101100b = 11101101b
-01101001b | 11101101b = 11101101b
-01101001b | 11101110b = 11101111b
-01101001b | 11101111b = 11101111b
-01101001b | 11110000b = 11111001b
-01101001b | 11110001b = 11111001b
-01101001b | 11110010b = 11111011b
-01101001b | 11110011b = 11111011b
-01101001b | 11110100b = 11111101b
-01101001b | 11110101b = 11111101b
-01101001b | 11110110b = 11111111b
-01101001b | 11110111b = 11111111b
-01101001b | 11111000b = 11111001b
-01101001b | 11111001b = 11111001b
-01101001b | 11111010b = 11111011b
-01101001b | 11111011b = 11111011b
-01101001b | 11111100b = 11111101b
-01101001b | 11111101b = 11111101b
-01101001b | 11111110b = 11111111b
-01101001b | 11111111b = 11111111b
-01101001b | 00000000b = 01101001b
-01101001b | 00000001b = 01101001b
-01101001b | 00000010b = 01101011b
-01101001b | 00000011b = 01101011b
-01101001b | 00000100b = 01101101b
-01101001b | 00000101b = 01101101b
-01101001b | 00000110b = 01101111b
-01101001b | 00000111b = 01101111b
-01101001b | 00001000b = 01101001b
-01101001b | 00001001b = 01101001b
-01101001b | 00001010b = 01101011b
-01101001b | 00001011b = 01101011b
-01101001b | 00001100b = 01101101b
-01101001b | 00001101b = 01101101b
-01101001b | 00001110b = 01101111b
-01101001b | 00001111b = 01101111b
-01101001b | 00010000b = 01111001b
-01101001b | 00010001b = 01111001b
-01101001b | 00010010b = 01111011b
-01101001b | 00010011b = 01111011b
-01101001b | 00010100b = 01111101b
-01101001b | 00010101b = 01111101b
-01101001b | 00010110b = 01111111b
-01101001b | 00010111b = 01111111b
-01101001b | 00011000b = 01111001b
-01101001b | 00011001b = 01111001b
-01101001b | 00011010b = 01111011b
-01101001b | 00011011b = 01111011b
-01101001b | 00011100b = 01111101b
-01101001b | 00011101b = 01111101b
-01101001b | 00011110b = 01111111b
-01101001b | 00011111b = 01111111b
-01101001b | 00100000b = 01101001b
-01101001b | 00100001b = 01101001b
-01101001b | 00100010b = 01101011b
-01101001b | 00100011b = 01101011b
-01101001b | 00100100b = 01101101b
-01101001b | 00100101b = 01101101b
-01101001b | 00100110b = 01101111b
-01101001b | 00100111b = 01101111b
-01101001b | 00101000b = 01101001b
-01101001b | 00101001b = 01101001b
-01101001b | 00101010b = 01101011b
-01101001b | 00101011b = 01101011b
-01101001b | 00101100b = 01101101b
-01101001b | 00101101b = 01101101b
-01101001b | 00101110b = 01101111b
-01101001b | 00101111b = 01101111b
-01101001b | 00110000b = 01111001b
-01101001b | 00110001b = 01111001b
-01101001b | 00110010b = 01111011b
-01101001b | 00110011b = 01111011b
-01101001b | 00110100b = 01111101b
-01101001b | 00110101b = 01111101b
-01101001b | 00110110b = 01111111b
-01101001b | 00110111b = 01111111b
-01101001b | 00111000b = 01111001b
-01101001b | 00111001b = 01111001b
-01101001b | 00111010b = 01111011b
-01101001b | 00111011b = 01111011b
-01101001b | 00111100b = 01111101b
-01101001b | 00111101b = 01111101b
-01101001b | 00111110b = 01111111b
-01101001b | 00111111b = 01111111b
-01101001b | 01000000b = 01101001b
-01101001b | 01000001b = 01101001b
-01101001b | 01000010b = 01101011b
-01101001b | 01000011b = 01101011b
-01101001b | 01000100b = 01101101b
-01101001b | 01000101b = 01101101b
-01101001b | 01000110b = 01101111b
-01101001b | 01000111b = 01101111b
-01101001b | 01001000b = 01101001b
-01101001b | 01001001b = 01101001b
-01101001b | 01001010b = 01101011b
-01101001b | 01001011b = 01101011b
-01101001b | 01001100b = 01101101b
-01101001b | 01001101b = 01101101b
-01101001b | 01001110b = 01101111b
-01101001b | 01001111b = 01101111b
-01101001b | 01010000b = 01111001b
-01101001b | 01010001b = 01111001b
-01101001b | 01010010b = 01111011b
-01101001b | 01010011b = 01111011b
-01101001b | 01010100b = 01111101b
-01101001b | 01010101b = 01111101b
-01101001b | 01010110b = 01111111b
-01101001b | 01010111b = 01111111b
-01101001b | 01011000b = 01111001b
-01101001b | 01011001b = 01111001b
-01101001b | 01011010b = 01111011b
-01101001b | 01011011b = 01111011b
-01101001b | 01011100b = 01111101b
-01101001b | 01011101b = 01111101b
-01101001b | 01011110b = 01111111b
-01101001b | 01011111b = 01111111b
-01101001b | 01100000b = 01101001b
-01101001b | 01100001b = 01101001b
-01101001b | 01100010b = 01101011b
-01101001b | 01100011b = 01101011b
-01101001b | 01100100b = 01101101b
-01101001b | 01100101b = 01101101b
-01101001b | 01100110b = 01101111b
-01101001b | 01100111b = 01101111b
-01101001b | 01101000b = 01101001b
-01101001b | 01101001b = 01101001b
-01101001b | 01101010b = 01101011b
-01101001b | 01101011b = 01101011b
-01101001b | 01101100b = 01101101b
-01101001b | 01101101b = 01101101b
-01101001b | 01101110b = 01101111b
-01101001b | 01101111b = 01101111b
-01101001b | 01110000b = 01111001b
-01101001b | 01110001b = 01111001b
-01101001b | 01110010b = 01111011b
-01101001b | 01110011b = 01111011b
-01101001b | 01110100b = 01111101b
-01101001b | 01110101b = 01111101b
-01101001b | 01110110b = 01111111b
-01101001b | 01110111b = 01111111b
-01101001b | 01111000b = 01111001b
-01101001b | 01111001b = 01111001b
-01101001b | 01111010b = 01111011b
-01101001b | 01111011b = 01111011b
-01101001b | 01111100b = 01111101b
-01101001b | 01111101b = 01111101b
-01101001b | 01111110b = 01111111b
-01101010b | 10000000b = 11101010b
-01101010b | 10000001b = 11101011b
-01101010b | 10000010b = 11101010b
-01101010b | 10000011b = 11101011b
-01101010b | 10000100b = 11101110b
-01101010b | 10000101b = 11101111b
-01101010b | 10000110b = 11101110b
-01101010b | 10000111b = 11101111b
-01101010b | 10001000b = 11101010b
-01101010b | 10001001b = 11101011b
-01101010b | 10001010b = 11101010b
-01101010b | 10001011b = 11101011b
-01101010b | 10001100b = 11101110b
-01101010b | 10001101b = 11101111b
-01101010b | 10001110b = 11101110b
-01101010b | 10001111b = 11101111b
-01101010b | 10010000b = 11111010b
-01101010b | 10010001b = 11111011b
-01101010b | 10010010b = 11111010b
-01101010b | 10010011b = 11111011b
-01101010b | 10010100b = 11111110b
-01101010b | 10010101b = 11111111b
-01101010b | 10010110b = 11111110b
-01101010b | 10010111b = 11111111b
-01101010b | 10011000b = 11111010b
-01101010b | 10011001b = 11111011b
-01101010b | 10011010b = 11111010b
-01101010b | 10011011b = 11111011b
-01101010b | 10011100b = 11111110b
-01101010b | 10011101b = 11111111b
-01101010b | 10011110b = 11111110b
-01101010b | 10011111b = 11111111b
-01101010b | 10100000b = 11101010b
-01101010b | 10100001b = 11101011b
-01101010b | 10100010b = 11101010b
-01101010b | 10100011b = 11101011b
-01101010b | 10100100b = 11101110b
-01101010b | 10100101b = 11101111b
-01101010b | 10100110b = 11101110b
-01101010b | 10100111b = 11101111b
-01101010b | 10101000b = 11101010b
-01101010b | 10101001b = 11101011b
-01101010b | 10101010b = 11101010b
-01101010b | 10101011b = 11101011b
-01101010b | 10101100b = 11101110b
-01101010b | 10101101b = 11101111b
-01101010b | 10101110b = 11101110b
-01101010b | 10101111b = 11101111b
-01101010b | 10110000b = 11111010b
-01101010b | 10110001b = 11111011b
-01101010b | 10110010b = 11111010b
-01101010b | 10110011b = 11111011b
-01101010b | 10110100b = 11111110b
-01101010b | 10110101b = 11111111b
-01101010b | 10110110b = 11111110b
-01101010b | 10110111b = 11111111b
-01101010b | 10111000b = 11111010b
-01101010b | 10111001b = 11111011b
-01101010b | 10111010b = 11111010b
-01101010b | 10111011b = 11111011b
-01101010b | 10111100b = 11111110b
-01101010b | 10111101b = 11111111b
-01101010b | 10111110b = 11111110b
-01101010b | 10111111b = 11111111b
-01101010b | 11000000b = 11101010b
-01101010b | 11000001b = 11101011b
-01101010b | 11000010b = 11101010b
-01101010b | 11000011b = 11101011b
-01101010b | 11000100b = 11101110b
-01101010b | 11000101b = 11101111b
-01101010b | 11000110b = 11101110b
-01101010b | 11000111b = 11101111b
-01101010b | 11001000b = 11101010b
-01101010b | 11001001b = 11101011b
-01101010b | 11001010b = 11101010b
-01101010b | 11001011b = 11101011b
-01101010b | 11001100b = 11101110b
-01101010b | 11001101b = 11101111b
-01101010b | 11001110b = 11101110b
-01101010b | 11001111b = 11101111b
-01101010b | 11010000b = 11111010b
-01101010b | 11010001b = 11111011b
-01101010b | 11010010b = 11111010b
-01101010b | 11010011b = 11111011b
-01101010b | 11010100b = 11111110b
-01101010b | 11010101b = 11111111b
-01101010b | 11010110b = 11111110b
-01101010b | 11010111b = 11111111b
-01101010b | 11011000b = 11111010b
-01101010b | 11011001b = 11111011b
-01101010b | 11011010b = 11111010b
-01101010b | 11011011b = 11111011b
-01101010b | 11011100b = 11111110b
-01101010b | 11011101b = 11111111b
-01101010b | 11011110b = 11111110b
-01101010b | 11011111b = 11111111b
-01101010b | 11100000b = 11101010b
-01101010b | 11100001b = 11101011b
-01101010b | 11100010b = 11101010b
-01101010b | 11100011b = 11101011b
-01101010b | 11100100b = 11101110b
-01101010b | 11100101b = 11101111b
-01101010b | 11100110b = 11101110b
-01101010b | 11100111b = 11101111b
-01101010b | 11101000b = 11101010b
-01101010b | 11101001b = 11101011b
-01101010b | 11101010b = 11101010b
-01101010b | 11101011b = 11101011b
-01101010b | 11101100b = 11101110b
-01101010b | 11101101b = 11101111b
-01101010b | 11101110b = 11101110b
-01101010b | 11101111b = 11101111b
-01101010b | 11110000b = 11111010b
-01101010b | 11110001b = 11111011b
-01101010b | 11110010b = 11111010b
-01101010b | 11110011b = 11111011b
-01101010b | 11110100b = 11111110b
-01101010b | 11110101b = 11111111b
-01101010b | 11110110b = 11111110b
-01101010b | 11110111b = 11111111b
-01101010b | 11111000b = 11111010b
-01101010b | 11111001b = 11111011b
-01101010b | 11111010b = 11111010b
-01101010b | 11111011b = 11111011b
-01101010b | 11111100b = 11111110b
-01101010b | 11111101b = 11111111b
-01101010b | 11111110b = 11111110b
-01101010b | 11111111b = 11111111b
-01101010b | 00000000b = 01101010b
-01101010b | 00000001b = 01101011b
-01101010b | 00000010b = 01101010b
-01101010b | 00000011b = 01101011b
-01101010b | 00000100b = 01101110b
-01101010b | 00000101b = 01101111b
-01101010b | 00000110b = 01101110b
-01101010b | 00000111b = 01101111b
-01101010b | 00001000b = 01101010b
-01101010b | 00001001b = 01101011b
-01101010b | 00001010b = 01101010b
-01101010b | 00001011b = 01101011b
-01101010b | 00001100b = 01101110b
-01101010b | 00001101b = 01101111b
-01101010b | 00001110b = 01101110b
-01101010b | 00001111b = 01101111b
-01101010b | 00010000b = 01111010b
-01101010b | 00010001b = 01111011b
-01101010b | 00010010b = 01111010b
-01101010b | 00010011b = 01111011b
-01101010b | 00010100b = 01111110b
-01101010b | 00010101b = 01111111b
-01101010b | 00010110b = 01111110b
-01101010b | 00010111b = 01111111b
-01101010b | 00011000b = 01111010b
-01101010b | 00011001b = 01111011b
-01101010b | 00011010b = 01111010b
-01101010b | 00011011b = 01111011b
-01101010b | 00011100b = 01111110b
-01101010b | 00011101b = 01111111b
-01101010b | 00011110b = 01111110b
-01101010b | 00011111b = 01111111b
-01101010b | 00100000b = 01101010b
-01101010b | 00100001b = 01101011b
-01101010b | 00100010b = 01101010b
-01101010b | 00100011b = 01101011b
-01101010b | 00100100b = 01101110b
-01101010b | 00100101b = 01101111b
-01101010b | 00100110b = 01101110b
-01101010b | 00100111b = 01101111b
-01101010b | 00101000b = 01101010b
-01101010b | 00101001b = 01101011b
-01101010b | 00101010b = 01101010b
-01101010b | 00101011b = 01101011b
-01101010b | 00101100b = 01101110b
-01101010b | 00101101b = 01101111b
-01101010b | 00101110b = 01101110b
-01101010b | 00101111b = 01101111b
-01101010b | 00110000b = 01111010b
-01101010b | 00110001b = 01111011b
-01101010b | 00110010b = 01111010b
-01101010b | 00110011b = 01111011b
-01101010b | 00110100b = 01111110b
-01101010b | 00110101b = 01111111b
-01101010b | 00110110b = 01111110b
-01101010b | 00110111b = 01111111b
-01101010b | 00111000b = 01111010b
-01101010b | 00111001b = 01111011b
-01101010b | 00111010b = 01111010b
-01101010b | 00111011b = 01111011b
-01101010b | 00111100b = 01111110b
-01101010b | 00111101b = 01111111b
-01101010b | 00111110b = 01111110b
-01101010b | 00111111b = 01111111b
-01101010b | 01000000b = 01101010b
-01101010b | 01000001b = 01101011b
-01101010b | 01000010b = 01101010b
-01101010b | 01000011b = 01101011b
-01101010b | 01000100b = 01101110b
-01101010b | 01000101b = 01101111b
-01101010b | 01000110b = 01101110b
-01101010b | 01000111b = 01101111b
-01101010b | 01001000b = 01101010b
-01101010b | 01001001b = 01101011b
-01101010b | 01001010b = 01101010b
-01101010b | 01001011b = 01101011b
-01101010b | 01001100b = 01101110b
-01101010b | 01001101b = 01101111b
-01101010b | 01001110b = 01101110b
-01101010b | 01001111b = 01101111b
-01101010b | 01010000b = 01111010b
-01101010b | 01010001b = 01111011b
-01101010b | 01010010b = 01111010b
-01101010b | 01010011b = 01111011b
-01101010b | 01010100b = 01111110b
-01101010b | 01010101b = 01111111b
-01101010b | 01010110b = 01111110b
-01101010b | 01010111b = 01111111b
-01101010b | 01011000b = 01111010b
-01101010b | 01011001b = 01111011b
-01101010b | 01011010b = 01111010b
-01101010b | 01011011b = 01111011b
-01101010b | 01011100b = 01111110b
-01101010b | 01011101b = 01111111b
-01101010b | 01011110b = 01111110b
-01101010b | 01011111b = 01111111b
-01101010b | 01100000b = 01101010b
-01101010b | 01100001b = 01101011b
-01101010b | 01100010b = 01101010b
-01101010b | 01100011b = 01101011b
-01101010b | 01100100b = 01101110b
-01101010b | 01100101b = 01101111b
-01101010b | 01100110b = 01101110b
-01101010b | 01100111b = 01101111b
-01101010b | 01101000b = 01101010b
-01101010b | 01101001b = 01101011b
-01101010b | 01101010b = 01101010b
-01101010b | 01101011b = 01101011b
-01101010b | 01101100b = 01101110b
-01101010b | 01101101b = 01101111b
-01101010b | 01101110b = 01101110b
-01101010b | 01101111b = 01101111b
-01101010b | 01110000b = 01111010b
-01101010b | 01110001b = 01111011b
-01101010b | 01110010b = 01111010b
-01101010b | 01110011b = 01111011b
-01101010b | 01110100b = 01111110b
-01101010b | 01110101b = 01111111b
-01101010b | 01110110b = 01111110b
-01101010b | 01110111b = 01111111b
-01101010b | 01111000b = 01111010b
-01101010b | 01111001b = 01111011b
-01101010b | 01111010b = 01111010b
-01101010b | 01111011b = 01111011b
-01101010b | 01111100b = 01111110b
-01101010b | 01111101b = 01111111b
-01101010b | 01111110b = 01111110b
-01101011b | 10000000b = 11101011b
-01101011b | 10000001b = 11101011b
-01101011b | 10000010b = 11101011b
-01101011b | 10000011b = 11101011b
-01101011b | 10000100b = 11101111b
-01101011b | 10000101b = 11101111b
-01101011b | 10000110b = 11101111b
-01101011b | 10000111b = 11101111b
-01101011b | 10001000b = 11101011b
-01101011b | 10001001b = 11101011b
-01101011b | 10001010b = 11101011b
-01101011b | 10001011b = 11101011b
-01101011b | 10001100b = 11101111b
-01101011b | 10001101b = 11101111b
-01101011b | 10001110b = 11101111b
-01101011b | 10001111b = 11101111b
-01101011b | 10010000b = 11111011b
-01101011b | 10010001b = 11111011b
-01101011b | 10010010b = 11111011b
-01101011b | 10010011b = 11111011b
-01101011b | 10010100b = 11111111b
-01101011b | 10010101b = 11111111b
-01101011b | 10010110b = 11111111b
-01101011b | 10010111b = 11111111b
-01101011b | 10011000b = 11111011b
-01101011b | 10011001b = 11111011b
-01101011b | 10011010b = 11111011b
-01101011b | 10011011b = 11111011b
-01101011b | 10011100b = 11111111b
-01101011b | 10011101b = 11111111b
-01101011b | 10011110b = 11111111b
-01101011b | 10011111b = 11111111b
-01101011b | 10100000b = 11101011b
-01101011b | 10100001b = 11101011b
-01101011b | 10100010b = 11101011b
-01101011b | 10100011b = 11101011b
-01101011b | 10100100b = 11101111b
-01101011b | 10100101b = 11101111b
-01101011b | 10100110b = 11101111b
-01101011b | 10100111b = 11101111b
-01101011b | 10101000b = 11101011b
-01101011b | 10101001b = 11101011b
-01101011b | 10101010b = 11101011b
-01101011b | 10101011b = 11101011b
-01101011b | 10101100b = 11101111b
-01101011b | 10101101b = 11101111b
-01101011b | 10101110b = 11101111b
-01101011b | 10101111b = 11101111b
-01101011b | 10110000b = 11111011b
-01101011b | 10110001b = 11111011b
-01101011b | 10110010b = 11111011b
-01101011b | 10110011b = 11111011b
-01101011b | 10110100b = 11111111b
-01101011b | 10110101b = 11111111b
-01101011b | 10110110b = 11111111b
-01101011b | 10110111b = 11111111b
-01101011b | 10111000b = 11111011b
-01101011b | 10111001b = 11111011b
-01101011b | 10111010b = 11111011b
-01101011b | 10111011b = 11111011b
-01101011b | 10111100b = 11111111b
-01101011b | 10111101b = 11111111b
-01101011b | 10111110b = 11111111b
-01101011b | 10111111b = 11111111b
-01101011b | 11000000b = 11101011b
-01101011b | 11000001b = 11101011b
-01101011b | 11000010b = 11101011b
-01101011b | 11000011b = 11101011b
-01101011b | 11000100b = 11101111b
-01101011b | 11000101b = 11101111b
-01101011b | 11000110b = 11101111b
-01101011b | 11000111b = 11101111b
-01101011b | 11001000b = 11101011b
-01101011b | 11001001b = 11101011b
-01101011b | 11001010b = 11101011b
-01101011b | 11001011b = 11101011b
-01101011b | 11001100b = 11101111b
-01101011b | 11001101b = 11101111b
-01101011b | 11001110b = 11101111b
-01101011b | 11001111b = 11101111b
-01101011b | 11010000b = 11111011b
-01101011b | 11010001b = 11111011b
-01101011b | 11010010b = 11111011b
-01101011b | 11010011b = 11111011b
-01101011b | 11010100b = 11111111b
-01101011b | 11010101b = 11111111b
-01101011b | 11010110b = 11111111b
-01101011b | 11010111b = 11111111b
-01101011b | 11011000b = 11111011b
-01101011b | 11011001b = 11111011b
-01101011b | 11011010b = 11111011b
-01101011b | 11011011b = 11111011b
-01101011b | 11011100b = 11111111b
-01101011b | 11011101b = 11111111b
-01101011b | 11011110b = 11111111b
-01101011b | 11011111b = 11111111b
-01101011b | 11100000b = 11101011b
-01101011b | 11100001b = 11101011b
-01101011b | 11100010b = 11101011b
-01101011b | 11100011b = 11101011b
-01101011b | 11100100b = 11101111b
-01101011b | 11100101b = 11101111b
-01101011b | 11100110b = 11101111b
-01101011b | 11100111b = 11101111b
-01101011b | 11101000b = 11101011b
-01101011b | 11101001b = 11101011b
-01101011b | 11101010b = 11101011b
-01101011b | 11101011b = 11101011b
-01101011b | 11101100b = 11101111b
-01101011b | 11101101b = 11101111b
-01101011b | 11101110b = 11101111b
-01101011b | 11101111b = 11101111b
-01101011b | 11110000b = 11111011b
-01101011b | 11110001b = 11111011b
-01101011b | 11110010b = 11111011b
-01101011b | 11110011b = 11111011b
-01101011b | 11110100b = 11111111b
-01101011b | 11110101b = 11111111b
-01101011b | 11110110b = 11111111b
-01101011b | 11110111b = 11111111b
-01101011b | 11111000b = 11111011b
-01101011b | 11111001b = 11111011b
-01101011b | 11111010b = 11111011b
-01101011b | 11111011b = 11111011b
-01101011b | 11111100b = 11111111b
-01101011b | 11111101b = 11111111b
-01101011b | 11111110b = 11111111b
-01101011b | 11111111b = 11111111b
-01101011b | 00000000b = 01101011b
-01101011b | 00000001b = 01101011b
-01101011b | 00000010b = 01101011b
-01101011b | 00000011b = 01101011b
-01101011b | 00000100b = 01101111b
-01101011b | 00000101b = 01101111b
-01101011b | 00000110b = 01101111b
-01101011b | 00000111b = 01101111b
-01101011b | 00001000b = 01101011b
-01101011b | 00001001b = 01101011b
-01101011b | 00001010b = 01101011b
-01101011b | 00001011b = 01101011b
-01101011b | 00001100b = 01101111b
-01101011b | 00001101b = 01101111b
-01101011b | 00001110b = 01101111b
-01101011b | 00001111b = 01101111b
-01101011b | 00010000b = 01111011b
-01101011b | 00010001b = 01111011b
-01101011b | 00010010b = 01111011b
-01101011b | 00010011b = 01111011b
-01101011b | 00010100b = 01111111b
-01101011b | 00010101b = 01111111b
-01101011b | 00010110b = 01111111b
-01101011b | 00010111b = 01111111b
-01101011b | 00011000b = 01111011b
-01101011b | 00011001b = 01111011b
-01101011b | 00011010b = 01111011b
-01101011b | 00011011b = 01111011b
-01101011b | 00011100b = 01111111b
-01101011b | 00011101b = 01111111b
-01101011b | 00011110b = 01111111b
-01101011b | 00011111b = 01111111b
-01101011b | 00100000b = 01101011b
-01101011b | 00100001b = 01101011b
-01101011b | 00100010b = 01101011b
-01101011b | 00100011b = 01101011b
-01101011b | 00100100b = 01101111b
-01101011b | 00100101b = 01101111b
-01101011b | 00100110b = 01101111b
-01101011b | 00100111b = 01101111b
-01101011b | 00101000b = 01101011b
-01101011b | 00101001b = 01101011b
-01101011b | 00101010b = 01101011b
-01101011b | 00101011b = 01101011b
-01101011b | 00101100b = 01101111b
-01101011b | 00101101b = 01101111b
-01101011b | 00101110b = 01101111b
-01101011b | 00101111b = 01101111b
-01101011b | 00110000b = 01111011b
-01101011b | 00110001b = 01111011b
-01101011b | 00110010b = 01111011b
-01101011b | 00110011b = 01111011b
-01101011b | 00110100b = 01111111b
-01101011b | 00110101b = 01111111b
-01101011b | 00110110b = 01111111b
-01101011b | 00110111b = 01111111b
-01101011b | 00111000b = 01111011b
-01101011b | 00111001b = 01111011b
-01101011b | 00111010b = 01111011b
-01101011b | 00111011b = 01111011b
-01101011b | 00111100b = 01111111b
-01101011b | 00111101b = 01111111b
-01101011b | 00111110b = 01111111b
-01101011b | 00111111b = 01111111b
-01101011b | 01000000b = 01101011b
-01101011b | 01000001b = 01101011b
-01101011b | 01000010b = 01101011b
-01101011b | 01000011b = 01101011b
-01101011b | 01000100b = 01101111b
-01101011b | 01000101b = 01101111b
-01101011b | 01000110b = 01101111b
-01101011b | 01000111b = 01101111b
-01101011b | 01001000b = 01101011b
-01101011b | 01001001b = 01101011b
-01101011b | 01001010b = 01101011b
-01101011b | 01001011b = 01101011b
-01101011b | 01001100b = 01101111b
-01101011b | 01001101b = 01101111b
-01101011b | 01001110b = 01101111b
-01101011b | 01001111b = 01101111b
-01101011b | 01010000b = 01111011b
-01101011b | 01010001b = 01111011b
-01101011b | 01010010b = 01111011b
-01101011b | 01010011b = 01111011b
-01101011b | 01010100b = 01111111b
-01101011b | 01010101b = 01111111b
-01101011b | 01010110b = 01111111b
-01101011b | 01010111b = 01111111b
-01101011b | 01011000b = 01111011b
-01101011b | 01011001b = 01111011b
-01101011b | 01011010b = 01111011b
-01101011b | 01011011b = 01111011b
-01101011b | 01011100b = 01111111b
-01101011b | 01011101b = 01111111b
-01101011b | 01011110b = 01111111b
-01101011b | 01011111b = 01111111b
-01101011b | 01100000b = 01101011b
-01101011b | 01100001b = 01101011b
-01101011b | 01100010b = 01101011b
-01101011b | 01100011b = 01101011b
-01101011b | 01100100b = 01101111b
-01101011b | 01100101b = 01101111b
-01101011b | 01100110b = 01101111b
-01101011b | 01100111b = 01101111b
-01101011b | 01101000b = 01101011b
-01101011b | 01101001b = 01101011b
-01101011b | 01101010b = 01101011b
-01101011b | 01101011b = 01101011b
-01101011b | 01101100b = 01101111b
-01101011b | 01101101b = 01101111b
-01101011b | 01101110b = 01101111b
-01101011b | 01101111b = 01101111b
-01101011b | 01110000b = 01111011b
-01101011b | 01110001b = 01111011b
-01101011b | 01110010b = 01111011b
-01101011b | 01110011b = 01111011b
-01101011b | 01110100b = 01111111b
-01101011b | 01110101b = 01111111b
-01101011b | 01110110b = 01111111b
-01101011b | 01110111b = 01111111b
-01101011b | 01111000b = 01111011b
-01101011b | 01111001b = 01111011b
-01101011b | 01111010b = 01111011b
-01101011b | 01111011b = 01111011b
-01101011b | 01111100b = 01111111b
-01101011b | 01111101b = 01111111b
-01101011b | 01111110b = 01111111b
-01101100b | 10000000b = 11101100b
-01101100b | 10000001b = 11101101b
-01101100b | 10000010b = 11101110b
-01101100b | 10000011b = 11101111b
-01101100b | 10000100b = 11101100b
-01101100b | 10000101b = 11101101b
-01101100b | 10000110b = 11101110b
-01101100b | 10000111b = 11101111b
-01101100b | 10001000b = 11101100b
-01101100b | 10001001b = 11101101b
-01101100b | 10001010b = 11101110b
-01101100b | 10001011b = 11101111b
-01101100b | 10001100b = 11101100b
-01101100b | 10001101b = 11101101b
-01101100b | 10001110b = 11101110b
-01101100b | 10001111b = 11101111b
-01101100b | 10010000b = 11111100b
-01101100b | 10010001b = 11111101b
-01101100b | 10010010b = 11111110b
-01101100b | 10010011b = 11111111b
-01101100b | 10010100b = 11111100b
-01101100b | 10010101b = 11111101b
-01101100b | 10010110b = 11111110b
-01101100b | 10010111b = 11111111b
-01101100b | 10011000b = 11111100b
-01101100b | 10011001b = 11111101b
-01101100b | 10011010b = 11111110b
-01101100b | 10011011b = 11111111b
-01101100b | 10011100b = 11111100b
-01101100b | 10011101b = 11111101b
-01101100b | 10011110b = 11111110b
-01101100b | 10011111b = 11111111b
-01101100b | 10100000b = 11101100b
-01101100b | 10100001b = 11101101b
-01101100b | 10100010b = 11101110b
-01101100b | 10100011b = 11101111b
-01101100b | 10100100b = 11101100b
-01101100b | 10100101b = 11101101b
-01101100b | 10100110b = 11101110b
-01101100b | 10100111b = 11101111b
-01101100b | 10101000b = 11101100b
-01101100b | 10101001b = 11101101b
-01101100b | 10101010b = 11101110b
-01101100b | 10101011b = 11101111b
-01101100b | 10101100b = 11101100b
-01101100b | 10101101b = 11101101b
-01101100b | 10101110b = 11101110b
-01101100b | 10101111b = 11101111b
-01101100b | 10110000b = 11111100b
-01101100b | 10110001b = 11111101b
-01101100b | 10110010b = 11111110b
-01101100b | 10110011b = 11111111b
-01101100b | 10110100b = 11111100b
-01101100b | 10110101b = 11111101b
-01101100b | 10110110b = 11111110b
-01101100b | 10110111b = 11111111b
-01101100b | 10111000b = 11111100b
-01101100b | 10111001b = 11111101b
-01101100b | 10111010b = 11111110b
-01101100b | 10111011b = 11111111b
-01101100b | 10111100b = 11111100b
-01101100b | 10111101b = 11111101b
-01101100b | 10111110b = 11111110b
-01101100b | 10111111b = 11111111b
-01101100b | 11000000b = 11101100b
-01101100b | 11000001b = 11101101b
-01101100b | 11000010b = 11101110b
-01101100b | 11000011b = 11101111b
-01101100b | 11000100b = 11101100b
-01101100b | 11000101b = 11101101b
-01101100b | 11000110b = 11101110b
-01101100b | 11000111b = 11101111b
-01101100b | 11001000b = 11101100b
-01101100b | 11001001b = 11101101b
-01101100b | 11001010b = 11101110b
-01101100b | 11001011b = 11101111b
-01101100b | 11001100b = 11101100b
-01101100b | 11001101b = 11101101b
-01101100b | 11001110b = 11101110b
-01101100b | 11001111b = 11101111b
-01101100b | 11010000b = 11111100b
-01101100b | 11010001b = 11111101b
-01101100b | 11010010b = 11111110b
-01101100b | 11010011b = 11111111b
-01101100b | 11010100b = 11111100b
-01101100b | 11010101b = 11111101b
-01101100b | 11010110b = 11111110b
-01101100b | 11010111b = 11111111b
-01101100b | 11011000b = 11111100b
-01101100b | 11011001b = 11111101b
-01101100b | 11011010b = 11111110b
-01101100b | 11011011b = 11111111b
-01101100b | 11011100b = 11111100b
-01101100b | 11011101b = 11111101b
-01101100b | 11011110b = 11111110b
-01101100b | 11011111b = 11111111b
-01101100b | 11100000b = 11101100b
-01101100b | 11100001b = 11101101b
-01101100b | 11100010b = 11101110b
-01101100b | 11100011b = 11101111b
-01101100b | 11100100b = 11101100b
-01101100b | 11100101b = 11101101b
-01101100b | 11100110b = 11101110b
-01101100b | 11100111b = 11101111b
-01101100b | 11101000b = 11101100b
-01101100b | 11101001b = 11101101b
-01101100b | 11101010b = 11101110b
-01101100b | 11101011b = 11101111b
-01101100b | 11101100b = 11101100b
-01101100b | 11101101b = 11101101b
-01101100b | 11101110b = 11101110b
-01101100b | 11101111b = 11101111b
-01101100b | 11110000b = 11111100b
-01101100b | 11110001b = 11111101b
-01101100b | 11110010b = 11111110b
-01101100b | 11110011b = 11111111b
-01101100b | 11110100b = 11111100b
-01101100b | 11110101b = 11111101b
-01101100b | 11110110b = 11111110b
-01101100b | 11110111b = 11111111b
-01101100b | 11111000b = 11111100b
-01101100b | 11111001b = 11111101b
-01101100b | 11111010b = 11111110b
-01101100b | 11111011b = 11111111b
-01101100b | 11111100b = 11111100b
-01101100b | 11111101b = 11111101b
-01101100b | 11111110b = 11111110b
-01101100b | 11111111b = 11111111b
-01101100b | 00000000b = 01101100b
-01101100b | 00000001b = 01101101b
-01101100b | 00000010b = 01101110b
-01101100b | 00000011b = 01101111b
-01101100b | 00000100b = 01101100b
-01101100b | 00000101b = 01101101b
-01101100b | 00000110b = 01101110b
-01101100b | 00000111b = 01101111b
-01101100b | 00001000b = 01101100b
-01101100b | 00001001b = 01101101b
-01101100b | 00001010b = 01101110b
-01101100b | 00001011b = 01101111b
-01101100b | 00001100b = 01101100b
-01101100b | 00001101b = 01101101b
-01101100b | 00001110b = 01101110b
-01101100b | 00001111b = 01101111b
-01101100b | 00010000b = 01111100b
-01101100b | 00010001b = 01111101b
-01101100b | 00010010b = 01111110b
-01101100b | 00010011b = 01111111b
-01101100b | 00010100b = 01111100b
-01101100b | 00010101b = 01111101b
-01101100b | 00010110b = 01111110b
-01101100b | 00010111b = 01111111b
-01101100b | 00011000b = 01111100b
-01101100b | 00011001b = 01111101b
-01101100b | 00011010b = 01111110b
-01101100b | 00011011b = 01111111b
-01101100b | 00011100b = 01111100b
-01101100b | 00011101b = 01111101b
-01101100b | 00011110b = 01111110b
-01101100b | 00011111b = 01111111b
-01101100b | 00100000b = 01101100b
-01101100b | 00100001b = 01101101b
-01101100b | 00100010b = 01101110b
-01101100b | 00100011b = 01101111b
-01101100b | 00100100b = 01101100b
-01101100b | 00100101b = 01101101b
-01101100b | 00100110b = 01101110b
-01101100b | 00100111b = 01101111b
-01101100b | 00101000b = 01101100b
-01101100b | 00101001b = 01101101b
-01101100b | 00101010b = 01101110b
-01101100b | 00101011b = 01101111b
-01101100b | 00101100b = 01101100b
-01101100b | 00101101b = 01101101b
-01101100b | 00101110b = 01101110b
-01101100b | 00101111b = 01101111b
-01101100b | 00110000b = 01111100b
-01101100b | 00110001b = 01111101b
-01101100b | 00110010b = 01111110b
-01101100b | 00110011b = 01111111b
-01101100b | 00110100b = 01111100b
-01101100b | 00110101b = 01111101b
-01101100b | 00110110b = 01111110b
-01101100b | 00110111b = 01111111b
-01101100b | 00111000b = 01111100b
-01101100b | 00111001b = 01111101b
-01101100b | 00111010b = 01111110b
-01101100b | 00111011b = 01111111b
-01101100b | 00111100b = 01111100b
-01101100b | 00111101b = 01111101b
-01101100b | 00111110b = 01111110b
-01101100b | 00111111b = 01111111b
-01101100b | 01000000b = 01101100b
-01101100b | 01000001b = 01101101b
-01101100b | 01000010b = 01101110b
-01101100b | 01000011b = 01101111b
-01101100b | 01000100b = 01101100b
-01101100b | 01000101b = 01101101b
-01101100b | 01000110b = 01101110b
-01101100b | 01000111b = 01101111b
-01101100b | 01001000b = 01101100b
-01101100b | 01001001b = 01101101b
-01101100b | 01001010b = 01101110b
-01101100b | 01001011b = 01101111b
-01101100b | 01001100b = 01101100b
-01101100b | 01001101b = 01101101b
-01101100b | 01001110b = 01101110b
-01101100b | 01001111b = 01101111b
-01101100b | 01010000b = 01111100b
-01101100b | 01010001b = 01111101b
-01101100b | 01010010b = 01111110b
-01101100b | 01010011b = 01111111b
-01101100b | 01010100b = 01111100b
-01101100b | 01010101b = 01111101b
-01101100b | 01010110b = 01111110b
-01101100b | 01010111b = 01111111b
-01101100b | 01011000b = 01111100b
-01101100b | 01011001b = 01111101b
-01101100b | 01011010b = 01111110b
-01101100b | 01011011b = 01111111b
-01101100b | 01011100b = 01111100b
-01101100b | 01011101b = 01111101b
-01101100b | 01011110b = 01111110b
-01101100b | 01011111b = 01111111b
-01101100b | 01100000b = 01101100b
-01101100b | 01100001b = 01101101b
-01101100b | 01100010b = 01101110b
-01101100b | 01100011b = 01101111b
-01101100b | 01100100b = 01101100b
-01101100b | 01100101b = 01101101b
-01101100b | 01100110b = 01101110b
-01101100b | 01100111b = 01101111b
-01101100b | 01101000b = 01101100b
-01101100b | 01101001b = 01101101b
-01101100b | 01101010b = 01101110b
-01101100b | 01101011b = 01101111b
-01101100b | 01101100b = 01101100b
-01101100b | 01101101b = 01101101b
-01101100b | 01101110b = 01101110b
-01101100b | 01101111b = 01101111b
-01101100b | 01110000b = 01111100b
-01101100b | 01110001b = 01111101b
-01101100b | 01110010b = 01111110b
-01101100b | 01110011b = 01111111b
-01101100b | 01110100b = 01111100b
-01101100b | 01110101b = 01111101b
-01101100b | 01110110b = 01111110b
-01101100b | 01110111b = 01111111b
-01101100b | 01111000b = 01111100b
-01101100b | 01111001b = 01111101b
-01101100b | 01111010b = 01111110b
-01101100b | 01111011b = 01111111b
-01101100b | 01111100b = 01111100b
-01101100b | 01111101b = 01111101b
-01101100b | 01111110b = 01111110b
-01101101b | 10000000b = 11101101b
-01101101b | 10000001b = 11101101b
-01101101b | 10000010b = 11101111b
-01101101b | 10000011b = 11101111b
-01101101b | 10000100b = 11101101b
-01101101b | 10000101b = 11101101b
-01101101b | 10000110b = 11101111b
-01101101b | 10000111b = 11101111b
-01101101b | 10001000b = 11101101b
-01101101b | 10001001b = 11101101b
-01101101b | 10001010b = 11101111b
-01101101b | 10001011b = 11101111b
-01101101b | 10001100b = 11101101b
-01101101b | 10001101b = 11101101b
-01101101b | 10001110b = 11101111b
-01101101b | 10001111b = 11101111b
-01101101b | 10010000b = 11111101b
-01101101b | 10010001b = 11111101b
-01101101b | 10010010b = 11111111b
-01101101b | 10010011b = 11111111b
-01101101b | 10010100b = 11111101b
-01101101b | 10010101b = 11111101b
-01101101b | 10010110b = 11111111b
-01101101b | 10010111b = 11111111b
-01101101b | 10011000b = 11111101b
-01101101b | 10011001b = 11111101b
-01101101b | 10011010b = 11111111b
-01101101b | 10011011b = 11111111b
-01101101b | 10011100b = 11111101b
-01101101b | 10011101b = 11111101b
-01101101b | 10011110b = 11111111b
-01101101b | 10011111b = 11111111b
-01101101b | 10100000b = 11101101b
-01101101b | 10100001b = 11101101b
-01101101b | 10100010b = 11101111b
-01101101b | 10100011b = 11101111b
-01101101b | 10100100b = 11101101b
-01101101b | 10100101b = 11101101b
-01101101b | 10100110b = 11101111b
-01101101b | 10100111b = 11101111b
-01101101b | 10101000b = 11101101b
-01101101b | 10101001b = 11101101b
-01101101b | 10101010b = 11101111b
-01101101b | 10101011b = 11101111b
-01101101b | 10101100b = 11101101b
-01101101b | 10101101b = 11101101b
-01101101b | 10101110b = 11101111b
-01101101b | 10101111b = 11101111b
-01101101b | 10110000b = 11111101b
-01101101b | 10110001b = 11111101b
-01101101b | 10110010b = 11111111b
-01101101b | 10110011b = 11111111b
-01101101b | 10110100b = 11111101b
-01101101b | 10110101b = 11111101b
-01101101b | 10110110b = 11111111b
-01101101b | 10110111b = 11111111b
-01101101b | 10111000b = 11111101b
-01101101b | 10111001b = 11111101b
-01101101b | 10111010b = 11111111b
-01101101b | 10111011b = 11111111b
-01101101b | 10111100b = 11111101b
-01101101b | 10111101b = 11111101b
-01101101b | 10111110b = 11111111b
-01101101b | 10111111b = 11111111b
-01101101b | 11000000b = 11101101b
-01101101b | 11000001b = 11101101b
-01101101b | 11000010b = 11101111b
-01101101b | 11000011b = 11101111b
-01101101b | 11000100b = 11101101b
-01101101b | 11000101b = 11101101b
-01101101b | 11000110b = 11101111b
-01101101b | 11000111b = 11101111b
-01101101b | 11001000b = 11101101b
-01101101b | 11001001b = 11101101b
-01101101b | 11001010b = 11101111b
-01101101b | 11001011b = 11101111b
-01101101b | 11001100b = 11101101b
-01101101b | 11001101b = 11101101b
-01101101b | 11001110b = 11101111b
-01101101b | 11001111b = 11101111b
-01101101b | 11010000b = 11111101b
-01101101b | 11010001b = 11111101b
-01101101b | 11010010b = 11111111b
-01101101b | 11010011b = 11111111b
-01101101b | 11010100b = 11111101b
-01101101b | 11010101b = 11111101b
-01101101b | 11010110b = 11111111b
-01101101b | 11010111b = 11111111b
-01101101b | 11011000b = 11111101b
-01101101b | 11011001b = 11111101b
-01101101b | 11011010b = 11111111b
-01101101b | 11011011b = 11111111b
-01101101b | 11011100b = 11111101b
-01101101b | 11011101b = 11111101b
-01101101b | 11011110b = 11111111b
-01101101b | 11011111b = 11111111b
-01101101b | 11100000b = 11101101b
-01101101b | 11100001b = 11101101b
-01101101b | 11100010b = 11101111b
-01101101b | 11100011b = 11101111b
-01101101b | 11100100b = 11101101b
-01101101b | 11100101b = 11101101b
-01101101b | 11100110b = 11101111b
-01101101b | 11100111b = 11101111b
-01101101b | 11101000b = 11101101b
-01101101b | 11101001b = 11101101b
-01101101b | 11101010b = 11101111b
-01101101b | 11101011b = 11101111b
-01101101b | 11101100b = 11101101b
-01101101b | 11101101b = 11101101b
-01101101b | 11101110b = 11101111b
-01101101b | 11101111b = 11101111b
-01101101b | 11110000b = 11111101b
-01101101b | 11110001b = 11111101b
-01101101b | 11110010b = 11111111b
-01101101b | 11110011b = 11111111b
-01101101b | 11110100b = 11111101b
-01101101b | 11110101b = 11111101b
-01101101b | 11110110b = 11111111b
-01101101b | 11110111b = 11111111b
-01101101b | 11111000b = 11111101b
-01101101b | 11111001b = 11111101b
-01101101b | 11111010b = 11111111b
-01101101b | 11111011b = 11111111b
-01101101b | 11111100b = 11111101b
-01101101b | 11111101b = 11111101b
-01101101b | 11111110b = 11111111b
-01101101b | 11111111b = 11111111b
-01101101b | 00000000b = 01101101b
-01101101b | 00000001b = 01101101b
-01101101b | 00000010b = 01101111b
-01101101b | 00000011b = 01101111b
-01101101b | 00000100b = 01101101b
-01101101b | 00000101b = 01101101b
-01101101b | 00000110b = 01101111b
-01101101b | 00000111b = 01101111b
-01101101b | 00001000b = 01101101b
-01101101b | 00001001b = 01101101b
-01101101b | 00001010b = 01101111b
-01101101b | 00001011b = 01101111b
-01101101b | 00001100b = 01101101b
-01101101b | 00001101b = 01101101b
-01101101b | 00001110b = 01101111b
-01101101b | 00001111b = 01101111b
-01101101b | 00010000b = 01111101b
-01101101b | 00010001b = 01111101b
-01101101b | 00010010b = 01111111b
-01101101b | 00010011b = 01111111b
-01101101b | 00010100b = 01111101b
-01101101b | 00010101b = 01111101b
-01101101b | 00010110b = 01111111b
-01101101b | 00010111b = 01111111b
-01101101b | 00011000b = 01111101b
-01101101b | 00011001b = 01111101b
-01101101b | 00011010b = 01111111b
-01101101b | 00011011b = 01111111b
-01101101b | 00011100b = 01111101b
-01101101b | 00011101b = 01111101b
-01101101b | 00011110b = 01111111b
-01101101b | 00011111b = 01111111b
-01101101b | 00100000b = 01101101b
-01101101b | 00100001b = 01101101b
-01101101b | 00100010b = 01101111b
-01101101b | 00100011b = 01101111b
-01101101b | 00100100b = 01101101b
-01101101b | 00100101b = 01101101b
-01101101b | 00100110b = 01101111b
-01101101b | 00100111b = 01101111b
-01101101b | 00101000b = 01101101b
-01101101b | 00101001b = 01101101b
-01101101b | 00101010b = 01101111b
-01101101b | 00101011b = 01101111b
-01101101b | 00101100b = 01101101b
-01101101b | 00101101b = 01101101b
-01101101b | 00101110b = 01101111b
-01101101b | 00101111b = 01101111b
-01101101b | 00110000b = 01111101b
-01101101b | 00110001b = 01111101b
-01101101b | 00110010b = 01111111b
-01101101b | 00110011b = 01111111b
-01101101b | 00110100b = 01111101b
-01101101b | 00110101b = 01111101b
-01101101b | 00110110b = 01111111b
-01101101b | 00110111b = 01111111b
-01101101b | 00111000b = 01111101b
-01101101b | 00111001b = 01111101b
-01101101b | 00111010b = 01111111b
-01101101b | 00111011b = 01111111b
-01101101b | 00111100b = 01111101b
-01101101b | 00111101b = 01111101b
-01101101b | 00111110b = 01111111b
-01101101b | 00111111b = 01111111b
-01101101b | 01000000b = 01101101b
-01101101b | 01000001b = 01101101b
-01101101b | 01000010b = 01101111b
-01101101b | 01000011b = 01101111b
-01101101b | 01000100b = 01101101b
-01101101b | 01000101b = 01101101b
-01101101b | 01000110b = 01101111b
-01101101b | 01000111b = 01101111b
-01101101b | 01001000b = 01101101b
-01101101b | 01001001b = 01101101b
-01101101b | 01001010b = 01101111b
-01101101b | 01001011b = 01101111b
-01101101b | 01001100b = 01101101b
-01101101b | 01001101b = 01101101b
-01101101b | 01001110b = 01101111b
-01101101b | 01001111b = 01101111b
-01101101b | 01010000b = 01111101b
-01101101b | 01010001b = 01111101b
-01101101b | 01010010b = 01111111b
-01101101b | 01010011b = 01111111b
-01101101b | 01010100b = 01111101b
-01101101b | 01010101b = 01111101b
-01101101b | 01010110b = 01111111b
-01101101b | 01010111b = 01111111b
-01101101b | 01011000b = 01111101b
-01101101b | 01011001b = 01111101b
-01101101b | 01011010b = 01111111b
-01101101b | 01011011b = 01111111b
-01101101b | 01011100b = 01111101b
-01101101b | 01011101b = 01111101b
-01101101b | 01011110b = 01111111b
-01101101b | 01011111b = 01111111b
-01101101b | 01100000b = 01101101b
-01101101b | 01100001b = 01101101b
-01101101b | 01100010b = 01101111b
-01101101b | 01100011b = 01101111b
-01101101b | 01100100b = 01101101b
-01101101b | 01100101b = 01101101b
-01101101b | 01100110b = 01101111b
-01101101b | 01100111b = 01101111b
-01101101b | 01101000b = 01101101b
-01101101b | 01101001b = 01101101b
-01101101b | 01101010b = 01101111b
-01101101b | 01101011b = 01101111b
-01101101b | 01101100b = 01101101b
-01101101b | 01101101b = 01101101b
-01101101b | 01101110b = 01101111b
-01101101b | 01101111b = 01101111b
-01101101b | 01110000b = 01111101b
-01101101b | 01110001b = 01111101b
-01101101b | 01110010b = 01111111b
-01101101b | 01110011b = 01111111b
-01101101b | 01110100b = 01111101b
-01101101b | 01110101b = 01111101b
-01101101b | 01110110b = 01111111b
-01101101b | 01110111b = 01111111b
-01101101b | 01111000b = 01111101b
-01101101b | 01111001b = 01111101b
-01101101b | 01111010b = 01111111b
-01101101b | 01111011b = 01111111b
-01101101b | 01111100b = 01111101b
-01101101b | 01111101b = 01111101b
-01101101b | 01111110b = 01111111b
-01101110b | 10000000b = 11101110b
-01101110b | 10000001b = 11101111b
-01101110b | 10000010b = 11101110b
-01101110b | 10000011b = 11101111b
-01101110b | 10000100b = 11101110b
-01101110b | 10000101b = 11101111b
-01101110b | 10000110b = 11101110b
-01101110b | 10000111b = 11101111b
-01101110b | 10001000b = 11101110b
-01101110b | 10001001b = 11101111b
-01101110b | 10001010b = 11101110b
-01101110b | 10001011b = 11101111b
-01101110b | 10001100b = 11101110b
-01101110b | 10001101b = 11101111b
-01101110b | 10001110b = 11101110b
-01101110b | 10001111b = 11101111b
-01101110b | 10010000b = 11111110b
-01101110b | 10010001b = 11111111b
-01101110b | 10010010b = 11111110b
-01101110b | 10010011b = 11111111b
-01101110b | 10010100b = 11111110b
-01101110b | 10010101b = 11111111b
-01101110b | 10010110b = 11111110b
-01101110b | 10010111b = 11111111b
-01101110b | 10011000b = 11111110b
-01101110b | 10011001b = 11111111b
-01101110b | 10011010b = 11111110b
-01101110b | 10011011b = 11111111b
-01101110b | 10011100b = 11111110b
-01101110b | 10011101b = 11111111b
-01101110b | 10011110b = 11111110b
-01101110b | 10011111b = 11111111b
-01101110b | 10100000b = 11101110b
-01101110b | 10100001b = 11101111b
-01101110b | 10100010b = 11101110b
-01101110b | 10100011b = 11101111b
-01101110b | 10100100b = 11101110b
-01101110b | 10100101b = 11101111b
-01101110b | 10100110b = 11101110b
-01101110b | 10100111b = 11101111b
-01101110b | 10101000b = 11101110b
-01101110b | 10101001b = 11101111b
-01101110b | 10101010b = 11101110b
-01101110b | 10101011b = 11101111b
-01101110b | 10101100b = 11101110b
-01101110b | 10101101b = 11101111b
-01101110b | 10101110b = 11101110b
-01101110b | 10101111b = 11101111b
-01101110b | 10110000b = 11111110b
-01101110b | 10110001b = 11111111b
-01101110b | 10110010b = 11111110b
-01101110b | 10110011b = 11111111b
-01101110b | 10110100b = 11111110b
-01101110b | 10110101b = 11111111b
-01101110b | 10110110b = 11111110b
-01101110b | 10110111b = 11111111b
-01101110b | 10111000b = 11111110b
-01101110b | 10111001b = 11111111b
-01101110b | 10111010b = 11111110b
-01101110b | 10111011b = 11111111b
-01101110b | 10111100b = 11111110b
-01101110b | 10111101b = 11111111b
-01101110b | 10111110b = 11111110b
-01101110b | 10111111b = 11111111b
-01101110b | 11000000b = 11101110b
-01101110b | 11000001b = 11101111b
-01101110b | 11000010b = 11101110b
-01101110b | 11000011b = 11101111b
-01101110b | 11000100b = 11101110b
-01101110b | 11000101b = 11101111b
-01101110b | 11000110b = 11101110b
-01101110b | 11000111b = 11101111b
-01101110b | 11001000b = 11101110b
-01101110b | 11001001b = 11101111b
-01101110b | 11001010b = 11101110b
-01101110b | 11001011b = 11101111b
-01101110b | 11001100b = 11101110b
-01101110b | 11001101b = 11101111b
-01101110b | 11001110b = 11101110b
-01101110b | 11001111b = 11101111b
-01101110b | 11010000b = 11111110b
-01101110b | 11010001b = 11111111b
-01101110b | 11010010b = 11111110b
-01101110b | 11010011b = 11111111b
-01101110b | 11010100b = 11111110b
-01101110b | 11010101b = 11111111b
-01101110b | 11010110b = 11111110b
-01101110b | 11010111b = 11111111b
-01101110b | 11011000b = 11111110b
-01101110b | 11011001b = 11111111b
-01101110b | 11011010b = 11111110b
-01101110b | 11011011b = 11111111b
-01101110b | 11011100b = 11111110b
-01101110b | 11011101b = 11111111b
-01101110b | 11011110b = 11111110b
-01101110b | 11011111b = 11111111b
-01101110b | 11100000b = 11101110b
-01101110b | 11100001b = 11101111b
-01101110b | 11100010b = 11101110b
-01101110b | 11100011b = 11101111b
-01101110b | 11100100b = 11101110b
-01101110b | 11100101b = 11101111b
-01101110b | 11100110b = 11101110b
-01101110b | 11100111b = 11101111b
-01101110b | 11101000b = 11101110b
-01101110b | 11101001b = 11101111b
-01101110b | 11101010b = 11101110b
-01101110b | 11101011b = 11101111b
-01101110b | 11101100b = 11101110b
-01101110b | 11101101b = 11101111b
-01101110b | 11101110b = 11101110b
-01101110b | 11101111b = 11101111b
-01101110b | 11110000b = 11111110b
-01101110b | 11110001b = 11111111b
-01101110b | 11110010b = 11111110b
-01101110b | 11110011b = 11111111b
-01101110b | 11110100b = 11111110b
-01101110b | 11110101b = 11111111b
-01101110b | 11110110b = 11111110b
-01101110b | 11110111b = 11111111b
-01101110b | 11111000b = 11111110b
-01101110b | 11111001b = 11111111b
-01101110b | 11111010b = 11111110b
-01101110b | 11111011b = 11111111b
-01101110b | 11111100b = 11111110b
-01101110b | 11111101b = 11111111b
-01101110b | 11111110b = 11111110b
-01101110b | 11111111b = 11111111b
-01101110b | 00000000b = 01101110b
-01101110b | 00000001b = 01101111b
-01101110b | 00000010b = 01101110b
-01101110b | 00000011b = 01101111b
-01101110b | 00000100b = 01101110b
-01101110b | 00000101b = 01101111b
-01101110b | 00000110b = 01101110b
-01101110b | 00000111b = 01101111b
-01101110b | 00001000b = 01101110b
-01101110b | 00001001b = 01101111b
-01101110b | 00001010b = 01101110b
-01101110b | 00001011b = 01101111b
-01101110b | 00001100b = 01101110b
-01101110b | 00001101b = 01101111b
-01101110b | 00001110b = 01101110b
-01101110b | 00001111b = 01101111b
-01101110b | 00010000b = 01111110b
-01101110b | 00010001b = 01111111b
-01101110b | 00010010b = 01111110b
-01101110b | 00010011b = 01111111b
-01101110b | 00010100b = 01111110b
-01101110b | 00010101b = 01111111b
-01101110b | 00010110b = 01111110b
-01101110b | 00010111b = 01111111b
-01101110b | 00011000b = 01111110b
-01101110b | 00011001b = 01111111b
-01101110b | 00011010b = 01111110b
-01101110b | 00011011b = 01111111b
-01101110b | 00011100b = 01111110b
-01101110b | 00011101b = 01111111b
-01101110b | 00011110b = 01111110b
-01101110b | 00011111b = 01111111b
-01101110b | 00100000b = 01101110b
-01101110b | 00100001b = 01101111b
-01101110b | 00100010b = 01101110b
-01101110b | 00100011b = 01101111b
-01101110b | 00100100b = 01101110b
-01101110b | 00100101b = 01101111b
-01101110b | 00100110b = 01101110b
-01101110b | 00100111b = 01101111b
-01101110b | 00101000b = 01101110b
-01101110b | 00101001b = 01101111b
-01101110b | 00101010b = 01101110b
-01101110b | 00101011b = 01101111b
-01101110b | 00101100b = 01101110b
-01101110b | 00101101b = 01101111b
-01101110b | 00101110b = 01101110b
-01101110b | 00101111b = 01101111b
-01101110b | 00110000b = 01111110b
-01101110b | 00110001b = 01111111b
-01101110b | 00110010b = 01111110b
-01101110b | 00110011b = 01111111b
-01101110b | 00110100b = 01111110b
-01101110b | 00110101b = 01111111b
-01101110b | 00110110b = 01111110b
-01101110b | 00110111b = 01111111b
-01101110b | 00111000b = 01111110b
-01101110b | 00111001b = 01111111b
-01101110b | 00111010b = 01111110b
-01101110b | 00111011b = 01111111b
-01101110b | 00111100b = 01111110b
-01101110b | 00111101b = 01111111b
-01101110b | 00111110b = 01111110b
-01101110b | 00111111b = 01111111b
-01101110b | 01000000b = 01101110b
-01101110b | 01000001b = 01101111b
-01101110b | 01000010b = 01101110b
-01101110b | 01000011b = 01101111b
-01101110b | 01000100b = 01101110b
-01101110b | 01000101b = 01101111b
-01101110b | 01000110b = 01101110b
-01101110b | 01000111b = 01101111b
-01101110b | 01001000b = 01101110b
-01101110b | 01001001b = 01101111b
-01101110b | 01001010b = 01101110b
-01101110b | 01001011b = 01101111b
-01101110b | 01001100b = 01101110b
-01101110b | 01001101b = 01101111b
-01101110b | 01001110b = 01101110b
-01101110b | 01001111b = 01101111b
-01101110b | 01010000b = 01111110b
-01101110b | 01010001b = 01111111b
-01101110b | 01010010b = 01111110b
-01101110b | 01010011b = 01111111b
-01101110b | 01010100b = 01111110b
-01101110b | 01010101b = 01111111b
-01101110b | 01010110b = 01111110b
-01101110b | 01010111b = 01111111b
-01101110b | 01011000b = 01111110b
-01101110b | 01011001b = 01111111b
-01101110b | 01011010b = 01111110b
-01101110b | 01011011b = 01111111b
-01101110b | 01011100b = 01111110b
-01101110b | 01011101b = 01111111b
-01101110b | 01011110b = 01111110b
-01101110b | 01011111b = 01111111b
-01101110b | 01100000b = 01101110b
-01101110b | 01100001b = 01101111b
-01101110b | 01100010b = 01101110b
-01101110b | 01100011b = 01101111b
-01101110b | 01100100b = 01101110b
-01101110b | 01100101b = 01101111b
-01101110b | 01100110b = 01101110b
-01101110b | 01100111b = 01101111b
-01101110b | 01101000b = 01101110b
-01101110b | 01101001b = 01101111b
-01101110b | 01101010b = 01101110b
-01101110b | 01101011b = 01101111b
-01101110b | 01101100b = 01101110b
-01101110b | 01101101b = 01101111b
-01101110b | 01101110b = 01101110b
-01101110b | 01101111b = 01101111b
-01101110b | 01110000b = 01111110b
-01101110b | 01110001b = 01111111b
-01101110b | 01110010b = 01111110b
-01101110b | 01110011b = 01111111b
-01101110b | 01110100b = 01111110b
-01101110b | 01110101b = 01111111b
-01101110b | 01110110b = 01111110b
-01101110b | 01110111b = 01111111b
-01101110b | 01111000b = 01111110b
-01101110b | 01111001b = 01111111b
-01101110b | 01111010b = 01111110b
-01101110b | 01111011b = 01111111b
-01101110b | 01111100b = 01111110b
-01101110b | 01111101b = 01111111b
-01101110b | 01111110b = 01111110b
-01101111b | 10000000b = 11101111b
-01101111b | 10000001b = 11101111b
-01101111b | 10000010b = 11101111b
-01101111b | 10000011b = 11101111b
-01101111b | 10000100b = 11101111b
-01101111b | 10000101b = 11101111b
-01101111b | 10000110b = 11101111b
-01101111b | 10000111b = 11101111b
-01101111b | 10001000b = 11101111b
-01101111b | 10001001b = 11101111b
-01101111b | 10001010b = 11101111b
-01101111b | 10001011b = 11101111b
-01101111b | 10001100b = 11101111b
-01101111b | 10001101b = 11101111b
-01101111b | 10001110b = 11101111b
-01101111b | 10001111b = 11101111b
-01101111b | 10010000b = 11111111b
-01101111b | 10010001b = 11111111b
-01101111b | 10010010b = 11111111b
-01101111b | 10010011b = 11111111b
-01101111b | 10010100b = 11111111b
-01101111b | 10010101b = 11111111b
-01101111b | 10010110b = 11111111b
-01101111b | 10010111b = 11111111b
-01101111b | 10011000b = 11111111b
-01101111b | 10011001b = 11111111b
-01101111b | 10011010b = 11111111b
-01101111b | 10011011b = 11111111b
-01101111b | 10011100b = 11111111b
-01101111b | 10011101b = 11111111b
-01101111b | 10011110b = 11111111b
-01101111b | 10011111b = 11111111b
-01101111b | 10100000b = 11101111b
-01101111b | 10100001b = 11101111b
-01101111b | 10100010b = 11101111b
-01101111b | 10100011b = 11101111b
-01101111b | 10100100b = 11101111b
-01101111b | 10100101b = 11101111b
-01101111b | 10100110b = 11101111b
-01101111b | 10100111b = 11101111b
-01101111b | 10101000b = 11101111b
-01101111b | 10101001b = 11101111b
-01101111b | 10101010b = 11101111b
-01101111b | 10101011b = 11101111b
-01101111b | 10101100b = 11101111b
-01101111b | 10101101b = 11101111b
-01101111b | 10101110b = 11101111b
-01101111b | 10101111b = 11101111b
-01101111b | 10110000b = 11111111b
-01101111b | 10110001b = 11111111b
-01101111b | 10110010b = 11111111b
-01101111b | 10110011b = 11111111b
-01101111b | 10110100b = 11111111b
-01101111b | 10110101b = 11111111b
-01101111b | 10110110b = 11111111b
-01101111b | 10110111b = 11111111b
-01101111b | 10111000b = 11111111b
-01101111b | 10111001b = 11111111b
-01101111b | 10111010b = 11111111b
-01101111b | 10111011b = 11111111b
-01101111b | 10111100b = 11111111b
-01101111b | 10111101b = 11111111b
-01101111b | 10111110b = 11111111b
-01101111b | 10111111b = 11111111b
-01101111b | 11000000b = 11101111b
-01101111b | 11000001b = 11101111b
-01101111b | 11000010b = 11101111b
-01101111b | 11000011b = 11101111b
-01101111b | 11000100b = 11101111b
-01101111b | 11000101b = 11101111b
-01101111b | 11000110b = 11101111b
-01101111b | 11000111b = 11101111b
-01101111b | 11001000b = 11101111b
-01101111b | 11001001b = 11101111b
-01101111b | 11001010b = 11101111b
-01101111b | 11001011b = 11101111b
-01101111b | 11001100b = 11101111b
-01101111b | 11001101b = 11101111b
-01101111b | 11001110b = 11101111b
-01101111b | 11001111b = 11101111b
-01101111b | 11010000b = 11111111b
-01101111b | 11010001b = 11111111b
-01101111b | 11010010b = 11111111b
-01101111b | 11010011b = 11111111b
-01101111b | 11010100b = 11111111b
-01101111b | 11010101b = 11111111b
-01101111b | 11010110b = 11111111b
-01101111b | 11010111b = 11111111b
-01101111b | 11011000b = 11111111b
-01101111b | 11011001b = 11111111b
-01101111b | 11011010b = 11111111b
-01101111b | 11011011b = 11111111b
-01101111b | 11011100b = 11111111b
-01101111b | 11011101b = 11111111b
-01101111b | 11011110b = 11111111b
-01101111b | 11011111b = 11111111b
-01101111b | 11100000b = 11101111b
-01101111b | 11100001b = 11101111b
-01101111b | 11100010b = 11101111b
-01101111b | 11100011b = 11101111b
-01101111b | 11100100b = 11101111b
-01101111b | 11100101b = 11101111b
-01101111b | 11100110b = 11101111b
-01101111b | 11100111b = 11101111b
-01101111b | 11101000b = 11101111b
-01101111b | 11101001b = 11101111b
-01101111b | 11101010b = 11101111b
-01101111b | 11101011b = 11101111b
-01101111b | 11101100b = 11101111b
-01101111b | 11101101b = 11101111b
-01101111b | 11101110b = 11101111b
-01101111b | 11101111b = 11101111b
-01101111b | 11110000b = 11111111b
-01101111b | 11110001b = 11111111b
-01101111b | 11110010b = 11111111b
-01101111b | 11110011b = 11111111b
-01101111b | 11110100b = 11111111b
-01101111b | 11110101b = 11111111b
-01101111b | 11110110b = 11111111b
-01101111b | 11110111b = 11111111b
-01101111b | 11111000b = 11111111b
-01101111b | 11111001b = 11111111b
-01101111b | 11111010b = 11111111b
-01101111b | 11111011b = 11111111b
-01101111b | 11111100b = 11111111b
-01101111b | 11111101b = 11111111b
-01101111b | 11111110b = 11111111b
-01101111b | 11111111b = 11111111b
-01101111b | 00000000b = 01101111b
-01101111b | 00000001b = 01101111b
-01101111b | 00000010b = 01101111b
-01101111b | 00000011b = 01101111b
-01101111b | 00000100b = 01101111b
-01101111b | 00000101b = 01101111b
-01101111b | 00000110b = 01101111b
-01101111b | 00000111b = 01101111b
-01101111b | 00001000b = 01101111b
-01101111b | 00001001b = 01101111b
-01101111b | 00001010b = 01101111b
-01101111b | 00001011b = 01101111b
-01101111b | 00001100b = 01101111b
-01101111b | 00001101b = 01101111b
-01101111b | 00001110b = 01101111b
-01101111b | 00001111b = 01101111b
-01101111b | 00010000b = 01111111b
-01101111b | 00010001b = 01111111b
-01101111b | 00010010b = 01111111b
-01101111b | 00010011b = 01111111b
-01101111b | 00010100b = 01111111b
-01101111b | 00010101b = 01111111b
-01101111b | 00010110b = 01111111b
-01101111b | 00010111b = 01111111b
-01101111b | 00011000b = 01111111b
-01101111b | 00011001b = 01111111b
-01101111b | 00011010b = 01111111b
-01101111b | 00011011b = 01111111b
-01101111b | 00011100b = 01111111b
-01101111b | 00011101b = 01111111b
-01101111b | 00011110b = 01111111b
-01101111b | 00011111b = 01111111b
-01101111b | 00100000b = 01101111b
-01101111b | 00100001b = 01101111b
-01101111b | 00100010b = 01101111b
-01101111b | 00100011b = 01101111b
-01101111b | 00100100b = 01101111b
-01101111b | 00100101b = 01101111b
-01101111b | 00100110b = 01101111b
-01101111b | 00100111b = 01101111b
-01101111b | 00101000b = 01101111b
-01101111b | 00101001b = 01101111b
-01101111b | 00101010b = 01101111b
-01101111b | 00101011b = 01101111b
-01101111b | 00101100b = 01101111b
-01101111b | 00101101b = 01101111b
-01101111b | 00101110b = 01101111b
-01101111b | 00101111b = 01101111b
-01101111b | 00110000b = 01111111b
-01101111b | 00110001b = 01111111b
-01101111b | 00110010b = 01111111b
-01101111b | 00110011b = 01111111b
-01101111b | 00110100b = 01111111b
-01101111b | 00110101b = 01111111b
-01101111b | 00110110b = 01111111b
-01101111b | 00110111b = 01111111b
-01101111b | 00111000b = 01111111b
-01101111b | 00111001b = 01111111b
-01101111b | 00111010b = 01111111b
-01101111b | 00111011b = 01111111b
-01101111b | 00111100b = 01111111b
-01101111b | 00111101b = 01111111b
-01101111b | 00111110b = 01111111b
-01101111b | 00111111b = 01111111b
-01101111b | 01000000b = 01101111b
-01101111b | 01000001b = 01101111b
-01101111b | 01000010b = 01101111b
-01101111b | 01000011b = 01101111b
-01101111b | 01000100b = 01101111b
-01101111b | 01000101b = 01101111b
-01101111b | 01000110b = 01101111b
-01101111b | 01000111b = 01101111b
-01101111b | 01001000b = 01101111b
-01101111b | 01001001b = 01101111b
-01101111b | 01001010b = 01101111b
-01101111b | 01001011b = 01101111b
-01101111b | 01001100b = 01101111b
-01101111b | 01001101b = 01101111b
-01101111b | 01001110b = 01101111b
-01101111b | 01001111b = 01101111b
-01101111b | 01010000b = 01111111b
-01101111b | 01010001b = 01111111b
-01101111b | 01010010b = 01111111b
-01101111b | 01010011b = 01111111b
-01101111b | 01010100b = 01111111b
-01101111b | 01010101b = 01111111b
-01101111b | 01010110b = 01111111b
-01101111b | 01010111b = 01111111b
-01101111b | 01011000b = 01111111b
-01101111b | 01011001b = 01111111b
-01101111b | 01011010b = 01111111b
-01101111b | 01011011b = 01111111b
-01101111b | 01011100b = 01111111b
-01101111b | 01011101b = 01111111b
-01101111b | 01011110b = 01111111b
-01101111b | 01011111b = 01111111b
-01101111b | 01100000b = 01101111b
-01101111b | 01100001b = 01101111b
-01101111b | 01100010b = 01101111b
-01101111b | 01100011b = 01101111b
-01101111b | 01100100b = 01101111b
-01101111b | 01100101b = 01101111b
-01101111b | 01100110b = 01101111b
-01101111b | 01100111b = 01101111b
-01101111b | 01101000b = 01101111b
-01101111b | 01101001b = 01101111b
-01101111b | 01101010b = 01101111b
-01101111b | 01101011b = 01101111b
-01101111b | 01101100b = 01101111b
-01101111b | 01101101b = 01101111b
-01101111b | 01101110b = 01101111b
-01101111b | 01101111b = 01101111b
-01101111b | 01110000b = 01111111b
-01101111b | 01110001b = 01111111b
-01101111b | 01110010b = 01111111b
-01101111b | 01110011b = 01111111b
-01101111b | 01110100b = 01111111b
-01101111b | 01110101b = 01111111b
-01101111b | 01110110b = 01111111b
-01101111b | 01110111b = 01111111b
-01101111b | 01111000b = 01111111b
-01101111b | 01111001b = 01111111b
-01101111b | 01111010b = 01111111b
-01101111b | 01111011b = 01111111b
-01101111b | 01111100b = 01111111b
-01101111b | 01111101b = 01111111b
-01101111b | 01111110b = 01111111b
-01110000b | 10000000b = 11110000b
-01110000b | 10000001b = 11110001b
-01110000b | 10000010b = 11110010b
-01110000b | 10000011b = 11110011b
-01110000b | 10000100b = 11110100b
-01110000b | 10000101b = 11110101b
-01110000b | 10000110b = 11110110b
-01110000b | 10000111b = 11110111b
-01110000b | 10001000b = 11111000b
-01110000b | 10001001b = 11111001b
-01110000b | 10001010b = 11111010b
-01110000b | 10001011b = 11111011b
-01110000b | 10001100b = 11111100b
-01110000b | 10001101b = 11111101b
-01110000b | 10001110b = 11111110b
-01110000b | 10001111b = 11111111b
-01110000b | 10010000b = 11110000b
-01110000b | 10010001b = 11110001b
-01110000b | 10010010b = 11110010b
-01110000b | 10010011b = 11110011b
-01110000b | 10010100b = 11110100b
-01110000b | 10010101b = 11110101b
-01110000b | 10010110b = 11110110b
-01110000b | 10010111b = 11110111b
-01110000b | 10011000b = 11111000b
-01110000b | 10011001b = 11111001b
-01110000b | 10011010b = 11111010b
-01110000b | 10011011b = 11111011b
-01110000b | 10011100b = 11111100b
-01110000b | 10011101b = 11111101b
-01110000b | 10011110b = 11111110b
-01110000b | 10011111b = 11111111b
-01110000b | 10100000b = 11110000b
-01110000b | 10100001b = 11110001b
-01110000b | 10100010b = 11110010b
-01110000b | 10100011b = 11110011b
-01110000b | 10100100b = 11110100b
-01110000b | 10100101b = 11110101b
-01110000b | 10100110b = 11110110b
-01110000b | 10100111b = 11110111b
-01110000b | 10101000b = 11111000b
-01110000b | 10101001b = 11111001b
-01110000b | 10101010b = 11111010b
-01110000b | 10101011b = 11111011b
-01110000b | 10101100b = 11111100b
-01110000b | 10101101b = 11111101b
-01110000b | 10101110b = 11111110b
-01110000b | 10101111b = 11111111b
-01110000b | 10110000b = 11110000b
-01110000b | 10110001b = 11110001b
-01110000b | 10110010b = 11110010b
-01110000b | 10110011b = 11110011b
-01110000b | 10110100b = 11110100b
-01110000b | 10110101b = 11110101b
-01110000b | 10110110b = 11110110b
-01110000b | 10110111b = 11110111b
-01110000b | 10111000b = 11111000b
-01110000b | 10111001b = 11111001b
-01110000b | 10111010b = 11111010b
-01110000b | 10111011b = 11111011b
-01110000b | 10111100b = 11111100b
-01110000b | 10111101b = 11111101b
-01110000b | 10111110b = 11111110b
-01110000b | 10111111b = 11111111b
-01110000b | 11000000b = 11110000b
-01110000b | 11000001b = 11110001b
-01110000b | 11000010b = 11110010b
-01110000b | 11000011b = 11110011b
-01110000b | 11000100b = 11110100b
-01110000b | 11000101b = 11110101b
-01110000b | 11000110b = 11110110b
-01110000b | 11000111b = 11110111b
-01110000b | 11001000b = 11111000b
-01110000b | 11001001b = 11111001b
-01110000b | 11001010b = 11111010b
-01110000b | 11001011b = 11111011b
-01110000b | 11001100b = 11111100b
-01110000b | 11001101b = 11111101b
-01110000b | 11001110b = 11111110b
-01110000b | 11001111b = 11111111b
-01110000b | 11010000b = 11110000b
-01110000b | 11010001b = 11110001b
-01110000b | 11010010b = 11110010b
-01110000b | 11010011b = 11110011b
-01110000b | 11010100b = 11110100b
-01110000b | 11010101b = 11110101b
-01110000b | 11010110b = 11110110b
-01110000b | 11010111b = 11110111b
-01110000b | 11011000b = 11111000b
-01110000b | 11011001b = 11111001b
-01110000b | 11011010b = 11111010b
-01110000b | 11011011b = 11111011b
-01110000b | 11011100b = 11111100b
-01110000b | 11011101b = 11111101b
-01110000b | 11011110b = 11111110b
-01110000b | 11011111b = 11111111b
-01110000b | 11100000b = 11110000b
-01110000b | 11100001b = 11110001b
-01110000b | 11100010b = 11110010b
-01110000b | 11100011b = 11110011b
-01110000b | 11100100b = 11110100b
-01110000b | 11100101b = 11110101b
-01110000b | 11100110b = 11110110b
-01110000b | 11100111b = 11110111b
-01110000b | 11101000b = 11111000b
-01110000b | 11101001b = 11111001b
-01110000b | 11101010b = 11111010b
-01110000b | 11101011b = 11111011b
-01110000b | 11101100b = 11111100b
-01110000b | 11101101b = 11111101b
-01110000b | 11101110b = 11111110b
-01110000b | 11101111b = 11111111b
-01110000b | 11110000b = 11110000b
-01110000b | 11110001b = 11110001b
-01110000b | 11110010b = 11110010b
-01110000b | 11110011b = 11110011b
-01110000b | 11110100b = 11110100b
-01110000b | 11110101b = 11110101b
-01110000b | 11110110b = 11110110b
-01110000b | 11110111b = 11110111b
-01110000b | 11111000b = 11111000b
-01110000b | 11111001b = 11111001b
-01110000b | 11111010b = 11111010b
-01110000b | 11111011b = 11111011b
-01110000b | 11111100b = 11111100b
-01110000b | 11111101b = 11111101b
-01110000b | 11111110b = 11111110b
-01110000b | 11111111b = 11111111b
-01110000b | 00000000b = 01110000b
-01110000b | 00000001b = 01110001b
-01110000b | 00000010b = 01110010b
-01110000b | 00000011b = 01110011b
-01110000b | 00000100b = 01110100b
-01110000b | 00000101b = 01110101b
-01110000b | 00000110b = 01110110b
-01110000b | 00000111b = 01110111b
-01110000b | 00001000b = 01111000b
-01110000b | 00001001b = 01111001b
-01110000b | 00001010b = 01111010b
-01110000b | 00001011b = 01111011b
-01110000b | 00001100b = 01111100b
-01110000b | 00001101b = 01111101b
-01110000b | 00001110b = 01111110b
-01110000b | 00001111b = 01111111b
-01110000b | 00010000b = 01110000b
-01110000b | 00010001b = 01110001b
-01110000b | 00010010b = 01110010b
-01110000b | 00010011b = 01110011b
-01110000b | 00010100b = 01110100b
-01110000b | 00010101b = 01110101b
-01110000b | 00010110b = 01110110b
-01110000b | 00010111b = 01110111b
-01110000b | 00011000b = 01111000b
-01110000b | 00011001b = 01111001b
-01110000b | 00011010b = 01111010b
-01110000b | 00011011b = 01111011b
-01110000b | 00011100b = 01111100b
-01110000b | 00011101b = 01111101b
-01110000b | 00011110b = 01111110b
-01110000b | 00011111b = 01111111b
-01110000b | 00100000b = 01110000b
-01110000b | 00100001b = 01110001b
-01110000b | 00100010b = 01110010b
-01110000b | 00100011b = 01110011b
-01110000b | 00100100b = 01110100b
-01110000b | 00100101b = 01110101b
-01110000b | 00100110b = 01110110b
-01110000b | 00100111b = 01110111b
-01110000b | 00101000b = 01111000b
-01110000b | 00101001b = 01111001b
-01110000b | 00101010b = 01111010b
-01110000b | 00101011b = 01111011b
-01110000b | 00101100b = 01111100b
-01110000b | 00101101b = 01111101b
-01110000b | 00101110b = 01111110b
-01110000b | 00101111b = 01111111b
-01110000b | 00110000b = 01110000b
-01110000b | 00110001b = 01110001b
-01110000b | 00110010b = 01110010b
-01110000b | 00110011b = 01110011b
-01110000b | 00110100b = 01110100b
-01110000b | 00110101b = 01110101b
-01110000b | 00110110b = 01110110b
-01110000b | 00110111b = 01110111b
-01110000b | 00111000b = 01111000b
-01110000b | 00111001b = 01111001b
-01110000b | 00111010b = 01111010b
-01110000b | 00111011b = 01111011b
-01110000b | 00111100b = 01111100b
-01110000b | 00111101b = 01111101b
-01110000b | 00111110b = 01111110b
-01110000b | 00111111b = 01111111b
-01110000b | 01000000b = 01110000b
-01110000b | 01000001b = 01110001b
-01110000b | 01000010b = 01110010b
-01110000b | 01000011b = 01110011b
-01110000b | 01000100b = 01110100b
-01110000b | 01000101b = 01110101b
-01110000b | 01000110b = 01110110b
-01110000b | 01000111b = 01110111b
-01110000b | 01001000b = 01111000b
-01110000b | 01001001b = 01111001b
-01110000b | 01001010b = 01111010b
-01110000b | 01001011b = 01111011b
-01110000b | 01001100b = 01111100b
-01110000b | 01001101b = 01111101b
-01110000b | 01001110b = 01111110b
-01110000b | 01001111b = 01111111b
-01110000b | 01010000b = 01110000b
-01110000b | 01010001b = 01110001b
-01110000b | 01010010b = 01110010b
-01110000b | 01010011b = 01110011b
-01110000b | 01010100b = 01110100b
-01110000b | 01010101b = 01110101b
-01110000b | 01010110b = 01110110b
-01110000b | 01010111b = 01110111b
-01110000b | 01011000b = 01111000b
-01110000b | 01011001b = 01111001b
-01110000b | 01011010b = 01111010b
-01110000b | 01011011b = 01111011b
-01110000b | 01011100b = 01111100b
-01110000b | 01011101b = 01111101b
-01110000b | 01011110b = 01111110b
-01110000b | 01011111b = 01111111b
-01110000b | 01100000b = 01110000b
-01110000b | 01100001b = 01110001b
-01110000b | 01100010b = 01110010b
-01110000b | 01100011b = 01110011b
-01110000b | 01100100b = 01110100b
-01110000b | 01100101b = 01110101b
-01110000b | 01100110b = 01110110b
-01110000b | 01100111b = 01110111b
-01110000b | 01101000b = 01111000b
-01110000b | 01101001b = 01111001b
-01110000b | 01101010b = 01111010b
-01110000b | 01101011b = 01111011b
-01110000b | 01101100b = 01111100b
-01110000b | 01101101b = 01111101b
-01110000b | 01101110b = 01111110b
-01110000b | 01101111b = 01111111b
-01110000b | 01110000b = 01110000b
-01110000b | 01110001b = 01110001b
-01110000b | 01110010b = 01110010b
-01110000b | 01110011b = 01110011b
-01110000b | 01110100b = 01110100b
-01110000b | 01110101b = 01110101b
-01110000b | 01110110b = 01110110b
-01110000b | 01110111b = 01110111b
-01110000b | 01111000b = 01111000b
-01110000b | 01111001b = 01111001b
-01110000b | 01111010b = 01111010b
-01110000b | 01111011b = 01111011b
-01110000b | 01111100b = 01111100b
-01110000b | 01111101b = 01111101b
-01110000b | 01111110b = 01111110b
-01110001b | 10000000b = 11110001b
-01110001b | 10000001b = 11110001b
-01110001b | 10000010b = 11110011b
-01110001b | 10000011b = 11110011b
-01110001b | 10000100b = 11110101b
-01110001b | 10000101b = 11110101b
-01110001b | 10000110b = 11110111b
-01110001b | 10000111b = 11110111b
-01110001b | 10001000b = 11111001b
-01110001b | 10001001b = 11111001b
-01110001b | 10001010b = 11111011b
-01110001b | 10001011b = 11111011b
-01110001b | 10001100b = 11111101b
-01110001b | 10001101b = 11111101b
-01110001b | 10001110b = 11111111b
-01110001b | 10001111b = 11111111b
-01110001b | 10010000b = 11110001b
-01110001b | 10010001b = 11110001b
-01110001b | 10010010b = 11110011b
-01110001b | 10010011b = 11110011b
-01110001b | 10010100b = 11110101b
-01110001b | 10010101b = 11110101b
-01110001b | 10010110b = 11110111b
-01110001b | 10010111b = 11110111b
-01110001b | 10011000b = 11111001b
-01110001b | 10011001b = 11111001b
-01110001b | 10011010b = 11111011b
-01110001b | 10011011b = 11111011b
-01110001b | 10011100b = 11111101b
-01110001b | 10011101b = 11111101b
-01110001b | 10011110b = 11111111b
-01110001b | 10011111b = 11111111b
-01110001b | 10100000b = 11110001b
-01110001b | 10100001b = 11110001b
-01110001b | 10100010b = 11110011b
-01110001b | 10100011b = 11110011b
-01110001b | 10100100b = 11110101b
-01110001b | 10100101b = 11110101b
-01110001b | 10100110b = 11110111b
-01110001b | 10100111b = 11110111b
-01110001b | 10101000b = 11111001b
-01110001b | 10101001b = 11111001b
-01110001b | 10101010b = 11111011b
-01110001b | 10101011b = 11111011b
-01110001b | 10101100b = 11111101b
-01110001b | 10101101b = 11111101b
-01110001b | 10101110b = 11111111b
-01110001b | 10101111b = 11111111b
-01110001b | 10110000b = 11110001b
-01110001b | 10110001b = 11110001b
-01110001b | 10110010b = 11110011b
-01110001b | 10110011b = 11110011b
-01110001b | 10110100b = 11110101b
-01110001b | 10110101b = 11110101b
-01110001b | 10110110b = 11110111b
-01110001b | 10110111b = 11110111b
-01110001b | 10111000b = 11111001b
-01110001b | 10111001b = 11111001b
-01110001b | 10111010b = 11111011b
-01110001b | 10111011b = 11111011b
-01110001b | 10111100b = 11111101b
-01110001b | 10111101b = 11111101b
-01110001b | 10111110b = 11111111b
-01110001b | 10111111b = 11111111b
-01110001b | 11000000b = 11110001b
-01110001b | 11000001b = 11110001b
-01110001b | 11000010b = 11110011b
-01110001b | 11000011b = 11110011b
-01110001b | 11000100b = 11110101b
-01110001b | 11000101b = 11110101b
-01110001b | 11000110b = 11110111b
-01110001b | 11000111b = 11110111b
-01110001b | 11001000b = 11111001b
-01110001b | 11001001b = 11111001b
-01110001b | 11001010b = 11111011b
-01110001b | 11001011b = 11111011b
-01110001b | 11001100b = 11111101b
-01110001b | 11001101b = 11111101b
-01110001b | 11001110b = 11111111b
-01110001b | 11001111b = 11111111b
-01110001b | 11010000b = 11110001b
-01110001b | 11010001b = 11110001b
-01110001b | 11010010b = 11110011b
-01110001b | 11010011b = 11110011b
-01110001b | 11010100b = 11110101b
-01110001b | 11010101b = 11110101b
-01110001b | 11010110b = 11110111b
-01110001b | 11010111b = 11110111b
-01110001b | 11011000b = 11111001b
-01110001b | 11011001b = 11111001b
-01110001b | 11011010b = 11111011b
-01110001b | 11011011b = 11111011b
-01110001b | 11011100b = 11111101b
-01110001b | 11011101b = 11111101b
-01110001b | 11011110b = 11111111b
-01110001b | 11011111b = 11111111b
-01110001b | 11100000b = 11110001b
-01110001b | 11100001b = 11110001b
-01110001b | 11100010b = 11110011b
-01110001b | 11100011b = 11110011b
-01110001b | 11100100b = 11110101b
-01110001b | 11100101b = 11110101b
-01110001b | 11100110b = 11110111b
-01110001b | 11100111b = 11110111b
-01110001b | 11101000b = 11111001b
-01110001b | 11101001b = 11111001b
-01110001b | 11101010b = 11111011b
-01110001b | 11101011b = 11111011b
-01110001b | 11101100b = 11111101b
-01110001b | 11101101b = 11111101b
-01110001b | 11101110b = 11111111b
-01110001b | 11101111b = 11111111b
-01110001b | 11110000b = 11110001b
-01110001b | 11110001b = 11110001b
-01110001b | 11110010b = 11110011b
-01110001b | 11110011b = 11110011b
-01110001b | 11110100b = 11110101b
-01110001b | 11110101b = 11110101b
-01110001b | 11110110b = 11110111b
-01110001b | 11110111b = 11110111b
-01110001b | 11111000b = 11111001b
-01110001b | 11111001b = 11111001b
-01110001b | 11111010b = 11111011b
-01110001b | 11111011b = 11111011b
-01110001b | 11111100b = 11111101b
-01110001b | 11111101b = 11111101b
-01110001b | 11111110b = 11111111b
-01110001b | 11111111b = 11111111b
-01110001b | 00000000b = 01110001b
-01110001b | 00000001b = 01110001b
-01110001b | 00000010b = 01110011b
-01110001b | 00000011b = 01110011b
-01110001b | 00000100b = 01110101b
-01110001b | 00000101b = 01110101b
-01110001b | 00000110b = 01110111b
-01110001b | 00000111b = 01110111b
-01110001b | 00001000b = 01111001b
-01110001b | 00001001b = 01111001b
-01110001b | 00001010b = 01111011b
-01110001b | 00001011b = 01111011b
-01110001b | 00001100b = 01111101b
-01110001b | 00001101b = 01111101b
-01110001b | 00001110b = 01111111b
-01110001b | 00001111b = 01111111b
-01110001b | 00010000b = 01110001b
-01110001b | 00010001b = 01110001b
-01110001b | 00010010b = 01110011b
-01110001b | 00010011b = 01110011b
-01110001b | 00010100b = 01110101b
-01110001b | 00010101b = 01110101b
-01110001b | 00010110b = 01110111b
-01110001b | 00010111b = 01110111b
-01110001b | 00011000b = 01111001b
-01110001b | 00011001b = 01111001b
-01110001b | 00011010b = 01111011b
-01110001b | 00011011b = 01111011b
-01110001b | 00011100b = 01111101b
-01110001b | 00011101b = 01111101b
-01110001b | 00011110b = 01111111b
-01110001b | 00011111b = 01111111b
-01110001b | 00100000b = 01110001b
-01110001b | 00100001b = 01110001b
-01110001b | 00100010b = 01110011b
-01110001b | 00100011b = 01110011b
-01110001b | 00100100b = 01110101b
-01110001b | 00100101b = 01110101b
-01110001b | 00100110b = 01110111b
-01110001b | 00100111b = 01110111b
-01110001b | 00101000b = 01111001b
-01110001b | 00101001b = 01111001b
-01110001b | 00101010b = 01111011b
-01110001b | 00101011b = 01111011b
-01110001b | 00101100b = 01111101b
-01110001b | 00101101b = 01111101b
-01110001b | 00101110b = 01111111b
-01110001b | 00101111b = 01111111b
-01110001b | 00110000b = 01110001b
-01110001b | 00110001b = 01110001b
-01110001b | 00110010b = 01110011b
-01110001b | 00110011b = 01110011b
-01110001b | 00110100b = 01110101b
-01110001b | 00110101b = 01110101b
-01110001b | 00110110b = 01110111b
-01110001b | 00110111b = 01110111b
-01110001b | 00111000b = 01111001b
-01110001b | 00111001b = 01111001b
-01110001b | 00111010b = 01111011b
-01110001b | 00111011b = 01111011b
-01110001b | 00111100b = 01111101b
-01110001b | 00111101b = 01111101b
-01110001b | 00111110b = 01111111b
-01110001b | 00111111b = 01111111b
-01110001b | 01000000b = 01110001b
-01110001b | 01000001b = 01110001b
-01110001b | 01000010b = 01110011b
-01110001b | 01000011b = 01110011b
-01110001b | 01000100b = 01110101b
-01110001b | 01000101b = 01110101b
-01110001b | 01000110b = 01110111b
-01110001b | 01000111b = 01110111b
-01110001b | 01001000b = 01111001b
-01110001b | 01001001b = 01111001b
-01110001b | 01001010b = 01111011b
-01110001b | 01001011b = 01111011b
-01110001b | 01001100b = 01111101b
-01110001b | 01001101b = 01111101b
-01110001b | 01001110b = 01111111b
-01110001b | 01001111b = 01111111b
-01110001b | 01010000b = 01110001b
-01110001b | 01010001b = 01110001b
-01110001b | 01010010b = 01110011b
-01110001b | 01010011b = 01110011b
-01110001b | 01010100b = 01110101b
-01110001b | 01010101b = 01110101b
-01110001b | 01010110b = 01110111b
-01110001b | 01010111b = 01110111b
-01110001b | 01011000b = 01111001b
-01110001b | 01011001b = 01111001b
-01110001b | 01011010b = 01111011b
-01110001b | 01011011b = 01111011b
-01110001b | 01011100b = 01111101b
-01110001b | 01011101b = 01111101b
-01110001b | 01011110b = 01111111b
-01110001b | 01011111b = 01111111b
-01110001b | 01100000b = 01110001b
-01110001b | 01100001b = 01110001b
-01110001b | 01100010b = 01110011b
-01110001b | 01100011b = 01110011b
-01110001b | 01100100b = 01110101b
-01110001b | 01100101b = 01110101b
-01110001b | 01100110b = 01110111b
-01110001b | 01100111b = 01110111b
-01110001b | 01101000b = 01111001b
-01110001b | 01101001b = 01111001b
-01110001b | 01101010b = 01111011b
-01110001b | 01101011b = 01111011b
-01110001b | 01101100b = 01111101b
-01110001b | 01101101b = 01111101b
-01110001b | 01101110b = 01111111b
-01110001b | 01101111b = 01111111b
-01110001b | 01110000b = 01110001b
-01110001b | 01110001b = 01110001b
-01110001b | 01110010b = 01110011b
-01110001b | 01110011b = 01110011b
-01110001b | 01110100b = 01110101b
-01110001b | 01110101b = 01110101b
-01110001b | 01110110b = 01110111b
-01110001b | 01110111b = 01110111b
-01110001b | 01111000b = 01111001b
-01110001b | 01111001b = 01111001b
-01110001b | 01111010b = 01111011b
-01110001b | 01111011b = 01111011b
-01110001b | 01111100b = 01111101b
-01110001b | 01111101b = 01111101b
-01110001b | 01111110b = 01111111b
-01110010b | 10000000b = 11110010b
-01110010b | 10000001b = 11110011b
-01110010b | 10000010b = 11110010b
-01110010b | 10000011b = 11110011b
-01110010b | 10000100b = 11110110b
-01110010b | 10000101b = 11110111b
-01110010b | 10000110b = 11110110b
-01110010b | 10000111b = 11110111b
-01110010b | 10001000b = 11111010b
-01110010b | 10001001b = 11111011b
-01110010b | 10001010b = 11111010b
-01110010b | 10001011b = 11111011b
-01110010b | 10001100b = 11111110b
-01110010b | 10001101b = 11111111b
-01110010b | 10001110b = 11111110b
-01110010b | 10001111b = 11111111b
-01110010b | 10010000b = 11110010b
-01110010b | 10010001b = 11110011b
-01110010b | 10010010b = 11110010b
-01110010b | 10010011b = 11110011b
-01110010b | 10010100b = 11110110b
-01110010b | 10010101b = 11110111b
-01110010b | 10010110b = 11110110b
-01110010b | 10010111b = 11110111b
-01110010b | 10011000b = 11111010b
-01110010b | 10011001b = 11111011b
-01110010b | 10011010b = 11111010b
-01110010b | 10011011b = 11111011b
-01110010b | 10011100b = 11111110b
-01110010b | 10011101b = 11111111b
-01110010b | 10011110b = 11111110b
-01110010b | 10011111b = 11111111b
-01110010b | 10100000b = 11110010b
-01110010b | 10100001b = 11110011b
-01110010b | 10100010b = 11110010b
-01110010b | 10100011b = 11110011b
-01110010b | 10100100b = 11110110b
-01110010b | 10100101b = 11110111b
-01110010b | 10100110b = 11110110b
-01110010b | 10100111b = 11110111b
-01110010b | 10101000b = 11111010b
-01110010b | 10101001b = 11111011b
-01110010b | 10101010b = 11111010b
-01110010b | 10101011b = 11111011b
-01110010b | 10101100b = 11111110b
-01110010b | 10101101b = 11111111b
-01110010b | 10101110b = 11111110b
-01110010b | 10101111b = 11111111b
-01110010b | 10110000b = 11110010b
-01110010b | 10110001b = 11110011b
-01110010b | 10110010b = 11110010b
-01110010b | 10110011b = 11110011b
-01110010b | 10110100b = 11110110b
-01110010b | 10110101b = 11110111b
-01110010b | 10110110b = 11110110b
-01110010b | 10110111b = 11110111b
-01110010b | 10111000b = 11111010b
-01110010b | 10111001b = 11111011b
-01110010b | 10111010b = 11111010b
-01110010b | 10111011b = 11111011b
-01110010b | 10111100b = 11111110b
-01110010b | 10111101b = 11111111b
-01110010b | 10111110b = 11111110b
-01110010b | 10111111b = 11111111b
-01110010b | 11000000b = 11110010b
-01110010b | 11000001b = 11110011b
-01110010b | 11000010b = 11110010b
-01110010b | 11000011b = 11110011b
-01110010b | 11000100b = 11110110b
-01110010b | 11000101b = 11110111b
-01110010b | 11000110b = 11110110b
-01110010b | 11000111b = 11110111b
-01110010b | 11001000b = 11111010b
-01110010b | 11001001b = 11111011b
-01110010b | 11001010b = 11111010b
-01110010b | 11001011b = 11111011b
-01110010b | 11001100b = 11111110b
-01110010b | 11001101b = 11111111b
-01110010b | 11001110b = 11111110b
-01110010b | 11001111b = 11111111b
-01110010b | 11010000b = 11110010b
-01110010b | 11010001b = 11110011b
-01110010b | 11010010b = 11110010b
-01110010b | 11010011b = 11110011b
-01110010b | 11010100b = 11110110b
-01110010b | 11010101b = 11110111b
-01110010b | 11010110b = 11110110b
-01110010b | 11010111b = 11110111b
-01110010b | 11011000b = 11111010b
-01110010b | 11011001b = 11111011b
-01110010b | 11011010b = 11111010b
-01110010b | 11011011b = 11111011b
-01110010b | 11011100b = 11111110b
-01110010b | 11011101b = 11111111b
-01110010b | 11011110b = 11111110b
-01110010b | 11011111b = 11111111b
-01110010b | 11100000b = 11110010b
-01110010b | 11100001b = 11110011b
-01110010b | 11100010b = 11110010b
-01110010b | 11100011b = 11110011b
-01110010b | 11100100b = 11110110b
-01110010b | 11100101b = 11110111b
-01110010b | 11100110b = 11110110b
-01110010b | 11100111b = 11110111b
-01110010b | 11101000b = 11111010b
-01110010b | 11101001b = 11111011b
-01110010b | 11101010b = 11111010b
-01110010b | 11101011b = 11111011b
-01110010b | 11101100b = 11111110b
-01110010b | 11101101b = 11111111b
-01110010b | 11101110b = 11111110b
-01110010b | 11101111b = 11111111b
-01110010b | 11110000b = 11110010b
-01110010b | 11110001b = 11110011b
-01110010b | 11110010b = 11110010b
-01110010b | 11110011b = 11110011b
-01110010b | 11110100b = 11110110b
-01110010b | 11110101b = 11110111b
-01110010b | 11110110b = 11110110b
-01110010b | 11110111b = 11110111b
-01110010b | 11111000b = 11111010b
-01110010b | 11111001b = 11111011b
-01110010b | 11111010b = 11111010b
-01110010b | 11111011b = 11111011b
-01110010b | 11111100b = 11111110b
-01110010b | 11111101b = 11111111b
-01110010b | 11111110b = 11111110b
-01110010b | 11111111b = 11111111b
-01110010b | 00000000b = 01110010b
-01110010b | 00000001b = 01110011b
-01110010b | 00000010b = 01110010b
-01110010b | 00000011b = 01110011b
-01110010b | 00000100b = 01110110b
-01110010b | 00000101b = 01110111b
-01110010b | 00000110b = 01110110b
-01110010b | 00000111b = 01110111b
-01110010b | 00001000b = 01111010b
-01110010b | 00001001b = 01111011b
-01110010b | 00001010b = 01111010b
-01110010b | 00001011b = 01111011b
-01110010b | 00001100b = 01111110b
-01110010b | 00001101b = 01111111b
-01110010b | 00001110b = 01111110b
-01110010b | 00001111b = 01111111b
-01110010b | 00010000b = 01110010b
-01110010b | 00010001b = 01110011b
-01110010b | 00010010b = 01110010b
-01110010b | 00010011b = 01110011b
-01110010b | 00010100b = 01110110b
-01110010b | 00010101b = 01110111b
-01110010b | 00010110b = 01110110b
-01110010b | 00010111b = 01110111b
-01110010b | 00011000b = 01111010b
-01110010b | 00011001b = 01111011b
-01110010b | 00011010b = 01111010b
-01110010b | 00011011b = 01111011b
-01110010b | 00011100b = 01111110b
-01110010b | 00011101b = 01111111b
-01110010b | 00011110b = 01111110b
-01110010b | 00011111b = 01111111b
-01110010b | 00100000b = 01110010b
-01110010b | 00100001b = 01110011b
-01110010b | 00100010b = 01110010b
-01110010b | 00100011b = 01110011b
-01110010b | 00100100b = 01110110b
-01110010b | 00100101b = 01110111b
-01110010b | 00100110b = 01110110b
-01110010b | 00100111b = 01110111b
-01110010b | 00101000b = 01111010b
-01110010b | 00101001b = 01111011b
-01110010b | 00101010b = 01111010b
-01110010b | 00101011b = 01111011b
-01110010b | 00101100b = 01111110b
-01110010b | 00101101b = 01111111b
-01110010b | 00101110b = 01111110b
-01110010b | 00101111b = 01111111b
-01110010b | 00110000b = 01110010b
-01110010b | 00110001b = 01110011b
-01110010b | 00110010b = 01110010b
-01110010b | 00110011b = 01110011b
-01110010b | 00110100b = 01110110b
-01110010b | 00110101b = 01110111b
-01110010b | 00110110b = 01110110b
-01110010b | 00110111b = 01110111b
-01110010b | 00111000b = 01111010b
-01110010b | 00111001b = 01111011b
-01110010b | 00111010b = 01111010b
-01110010b | 00111011b = 01111011b
-01110010b | 00111100b = 01111110b
-01110010b | 00111101b = 01111111b
-01110010b | 00111110b = 01111110b
-01110010b | 00111111b = 01111111b
-01110010b | 01000000b = 01110010b
-01110010b | 01000001b = 01110011b
-01110010b | 01000010b = 01110010b
-01110010b | 01000011b = 01110011b
-01110010b | 01000100b = 01110110b
-01110010b | 01000101b = 01110111b
-01110010b | 01000110b = 01110110b
-01110010b | 01000111b = 01110111b
-01110010b | 01001000b = 01111010b
-01110010b | 01001001b = 01111011b
-01110010b | 01001010b = 01111010b
-01110010b | 01001011b = 01111011b
-01110010b | 01001100b = 01111110b
-01110010b | 01001101b = 01111111b
-01110010b | 01001110b = 01111110b
-01110010b | 01001111b = 01111111b
-01110010b | 01010000b = 01110010b
-01110010b | 01010001b = 01110011b
-01110010b | 01010010b = 01110010b
-01110010b | 01010011b = 01110011b
-01110010b | 01010100b = 01110110b
-01110010b | 01010101b = 01110111b
-01110010b | 01010110b = 01110110b
-01110010b | 01010111b = 01110111b
-01110010b | 01011000b = 01111010b
-01110010b | 01011001b = 01111011b
-01110010b | 01011010b = 01111010b
-01110010b | 01011011b = 01111011b
-01110010b | 01011100b = 01111110b
-01110010b | 01011101b = 01111111b
-01110010b | 01011110b = 01111110b
-01110010b | 01011111b = 01111111b
-01110010b | 01100000b = 01110010b
-01110010b | 01100001b = 01110011b
-01110010b | 01100010b = 01110010b
-01110010b | 01100011b = 01110011b
-01110010b | 01100100b = 01110110b
-01110010b | 01100101b = 01110111b
-01110010b | 01100110b = 01110110b
-01110010b | 01100111b = 01110111b
-01110010b | 01101000b = 01111010b
-01110010b | 01101001b = 01111011b
-01110010b | 01101010b = 01111010b
-01110010b | 01101011b = 01111011b
-01110010b | 01101100b = 01111110b
-01110010b | 01101101b = 01111111b
-01110010b | 01101110b = 01111110b
-01110010b | 01101111b = 01111111b
-01110010b | 01110000b = 01110010b
-01110010b | 01110001b = 01110011b
-01110010b | 01110010b = 01110010b
-01110010b | 01110011b = 01110011b
-01110010b | 01110100b = 01110110b
-01110010b | 01110101b = 01110111b
-01110010b | 01110110b = 01110110b
-01110010b | 01110111b = 01110111b
-01110010b | 01111000b = 01111010b
-01110010b | 01111001b = 01111011b
-01110010b | 01111010b = 01111010b
-01110010b | 01111011b = 01111011b
-01110010b | 01111100b = 01111110b
-01110010b | 01111101b = 01111111b
-01110010b | 01111110b = 01111110b
-01110011b | 10000000b = 11110011b
-01110011b | 10000001b = 11110011b
-01110011b | 10000010b = 11110011b
-01110011b | 10000011b = 11110011b
-01110011b | 10000100b = 11110111b
-01110011b | 10000101b = 11110111b
-01110011b | 10000110b = 11110111b
-01110011b | 10000111b = 11110111b
-01110011b | 10001000b = 11111011b
-01110011b | 10001001b = 11111011b
-01110011b | 10001010b = 11111011b
-01110011b | 10001011b = 11111011b
-01110011b | 10001100b = 11111111b
-01110011b | 10001101b = 11111111b
-01110011b | 10001110b = 11111111b
-01110011b | 10001111b = 11111111b
-01110011b | 10010000b = 11110011b
-01110011b | 10010001b = 11110011b
-01110011b | 10010010b = 11110011b
-01110011b | 10010011b = 11110011b
-01110011b | 10010100b = 11110111b
-01110011b | 10010101b = 11110111b
-01110011b | 10010110b = 11110111b
-01110011b | 10010111b = 11110111b
-01110011b | 10011000b = 11111011b
-01110011b | 10011001b = 11111011b
-01110011b | 10011010b = 11111011b
-01110011b | 10011011b = 11111011b
-01110011b | 10011100b = 11111111b
-01110011b | 10011101b = 11111111b
-01110011b | 10011110b = 11111111b
-01110011b | 10011111b = 11111111b
-01110011b | 10100000b = 11110011b
-01110011b | 10100001b = 11110011b
-01110011b | 10100010b = 11110011b
-01110011b | 10100011b = 11110011b
-01110011b | 10100100b = 11110111b
-01110011b | 10100101b = 11110111b
-01110011b | 10100110b = 11110111b
-01110011b | 10100111b = 11110111b
-01110011b | 10101000b = 11111011b
-01110011b | 10101001b = 11111011b
-01110011b | 10101010b = 11111011b
-01110011b | 10101011b = 11111011b
-01110011b | 10101100b = 11111111b
-01110011b | 10101101b = 11111111b
-01110011b | 10101110b = 11111111b
-01110011b | 10101111b = 11111111b
-01110011b | 10110000b = 11110011b
-01110011b | 10110001b = 11110011b
-01110011b | 10110010b = 11110011b
-01110011b | 10110011b = 11110011b
-01110011b | 10110100b = 11110111b
-01110011b | 10110101b = 11110111b
-01110011b | 10110110b = 11110111b
-01110011b | 10110111b = 11110111b
-01110011b | 10111000b = 11111011b
-01110011b | 10111001b = 11111011b
-01110011b | 10111010b = 11111011b
-01110011b | 10111011b = 11111011b
-01110011b | 10111100b = 11111111b
-01110011b | 10111101b = 11111111b
-01110011b | 10111110b = 11111111b
-01110011b | 10111111b = 11111111b
-01110011b | 11000000b = 11110011b
-01110011b | 11000001b = 11110011b
-01110011b | 11000010b = 11110011b
-01110011b | 11000011b = 11110011b
-01110011b | 11000100b = 11110111b
-01110011b | 11000101b = 11110111b
-01110011b | 11000110b = 11110111b
-01110011b | 11000111b = 11110111b
-01110011b | 11001000b = 11111011b
-01110011b | 11001001b = 11111011b
-01110011b | 11001010b = 11111011b
-01110011b | 11001011b = 11111011b
-01110011b | 11001100b = 11111111b
-01110011b | 11001101b = 11111111b
-01110011b | 11001110b = 11111111b
-01110011b | 11001111b = 11111111b
-01110011b | 11010000b = 11110011b
-01110011b | 11010001b = 11110011b
-01110011b | 11010010b = 11110011b
-01110011b | 11010011b = 11110011b
-01110011b | 11010100b = 11110111b
-01110011b | 11010101b = 11110111b
-01110011b | 11010110b = 11110111b
-01110011b | 11010111b = 11110111b
-01110011b | 11011000b = 11111011b
-01110011b | 11011001b = 11111011b
-01110011b | 11011010b = 11111011b
-01110011b | 11011011b = 11111011b
-01110011b | 11011100b = 11111111b
-01110011b | 11011101b = 11111111b
-01110011b | 11011110b = 11111111b
-01110011b | 11011111b = 11111111b
-01110011b | 11100000b = 11110011b
-01110011b | 11100001b = 11110011b
-01110011b | 11100010b = 11110011b
-01110011b | 11100011b = 11110011b
-01110011b | 11100100b = 11110111b
-01110011b | 11100101b = 11110111b
-01110011b | 11100110b = 11110111b
-01110011b | 11100111b = 11110111b
-01110011b | 11101000b = 11111011b
-01110011b | 11101001b = 11111011b
-01110011b | 11101010b = 11111011b
-01110011b | 11101011b = 11111011b
-01110011b | 11101100b = 11111111b
-01110011b | 11101101b = 11111111b
-01110011b | 11101110b = 11111111b
-01110011b | 11101111b = 11111111b
-01110011b | 11110000b = 11110011b
-01110011b | 11110001b = 11110011b
-01110011b | 11110010b = 11110011b
-01110011b | 11110011b = 11110011b
-01110011b | 11110100b = 11110111b
-01110011b | 11110101b = 11110111b
-01110011b | 11110110b = 11110111b
-01110011b | 11110111b = 11110111b
-01110011b | 11111000b = 11111011b
-01110011b | 11111001b = 11111011b
-01110011b | 11111010b = 11111011b
-01110011b | 11111011b = 11111011b
-01110011b | 11111100b = 11111111b
-01110011b | 11111101b = 11111111b
-01110011b | 11111110b = 11111111b
-01110011b | 11111111b = 11111111b
-01110011b | 00000000b = 01110011b
-01110011b | 00000001b = 01110011b
-01110011b | 00000010b = 01110011b
-01110011b | 00000011b = 01110011b
-01110011b | 00000100b = 01110111b
-01110011b | 00000101b = 01110111b
-01110011b | 00000110b = 01110111b
-01110011b | 00000111b = 01110111b
-01110011b | 00001000b = 01111011b
-01110011b | 00001001b = 01111011b
-01110011b | 00001010b = 01111011b
-01110011b | 00001011b = 01111011b
-01110011b | 00001100b = 01111111b
-01110011b | 00001101b = 01111111b
-01110011b | 00001110b = 01111111b
-01110011b | 00001111b = 01111111b
-01110011b | 00010000b = 01110011b
-01110011b | 00010001b = 01110011b
-01110011b | 00010010b = 01110011b
-01110011b | 00010011b = 01110011b
-01110011b | 00010100b = 01110111b
-01110011b | 00010101b = 01110111b
-01110011b | 00010110b = 01110111b
-01110011b | 00010111b = 01110111b
-01110011b | 00011000b = 01111011b
-01110011b | 00011001b = 01111011b
-01110011b | 00011010b = 01111011b
-01110011b | 00011011b = 01111011b
-01110011b | 00011100b = 01111111b
-01110011b | 00011101b = 01111111b
-01110011b | 00011110b = 01111111b
-01110011b | 00011111b = 01111111b
-01110011b | 00100000b = 01110011b
-01110011b | 00100001b = 01110011b
-01110011b | 00100010b = 01110011b
-01110011b | 00100011b = 01110011b
-01110011b | 00100100b = 01110111b
-01110011b | 00100101b = 01110111b
-01110011b | 00100110b = 01110111b
-01110011b | 00100111b = 01110111b
-01110011b | 00101000b = 01111011b
-01110011b | 00101001b = 01111011b
-01110011b | 00101010b = 01111011b
-01110011b | 00101011b = 01111011b
-01110011b | 00101100b = 01111111b
-01110011b | 00101101b = 01111111b
-01110011b | 00101110b = 01111111b
-01110011b | 00101111b = 01111111b
-01110011b | 00110000b = 01110011b
-01110011b | 00110001b = 01110011b
-01110011b | 00110010b = 01110011b
-01110011b | 00110011b = 01110011b
-01110011b | 00110100b = 01110111b
-01110011b | 00110101b = 01110111b
-01110011b | 00110110b = 01110111b
-01110011b | 00110111b = 01110111b
-01110011b | 00111000b = 01111011b
-01110011b | 00111001b = 01111011b
-01110011b | 00111010b = 01111011b
-01110011b | 00111011b = 01111011b
-01110011b | 00111100b = 01111111b
-01110011b | 00111101b = 01111111b
-01110011b | 00111110b = 01111111b
-01110011b | 00111111b = 01111111b
-01110011b | 01000000b = 01110011b
-01110011b | 01000001b = 01110011b
-01110011b | 01000010b = 01110011b
-01110011b | 01000011b = 01110011b
-01110011b | 01000100b = 01110111b
-01110011b | 01000101b = 01110111b
-01110011b | 01000110b = 01110111b
-01110011b | 01000111b = 01110111b
-01110011b | 01001000b = 01111011b
-01110011b | 01001001b = 01111011b
-01110011b | 01001010b = 01111011b
-01110011b | 01001011b = 01111011b
-01110011b | 01001100b = 01111111b
-01110011b | 01001101b = 01111111b
-01110011b | 01001110b = 01111111b
-01110011b | 01001111b = 01111111b
-01110011b | 01010000b = 01110011b
-01110011b | 01010001b = 01110011b
-01110011b | 01010010b = 01110011b
-01110011b | 01010011b = 01110011b
-01110011b | 01010100b = 01110111b
-01110011b | 01010101b = 01110111b
-01110011b | 01010110b = 01110111b
-01110011b | 01010111b = 01110111b
-01110011b | 01011000b = 01111011b
-01110011b | 01011001b = 01111011b
-01110011b | 01011010b = 01111011b
-01110011b | 01011011b = 01111011b
-01110011b | 01011100b = 01111111b
-01110011b | 01011101b = 01111111b
-01110011b | 01011110b = 01111111b
-01110011b | 01011111b = 01111111b
-01110011b | 01100000b = 01110011b
-01110011b | 01100001b = 01110011b
-01110011b | 01100010b = 01110011b
-01110011b | 01100011b = 01110011b
-01110011b | 01100100b = 01110111b
-01110011b | 01100101b = 01110111b
-01110011b | 01100110b = 01110111b
-01110011b | 01100111b = 01110111b
-01110011b | 01101000b = 01111011b
-01110011b | 01101001b = 01111011b
-01110011b | 01101010b = 01111011b
-01110011b | 01101011b = 01111011b
-01110011b | 01101100b = 01111111b
-01110011b | 01101101b = 01111111b
-01110011b | 01101110b = 01111111b
-01110011b | 01101111b = 01111111b
-01110011b | 01110000b = 01110011b
-01110011b | 01110001b = 01110011b
-01110011b | 01110010b = 01110011b
-01110011b | 01110011b = 01110011b
-01110011b | 01110100b = 01110111b
-01110011b | 01110101b = 01110111b
-01110011b | 01110110b = 01110111b
-01110011b | 01110111b = 01110111b
-01110011b | 01111000b = 01111011b
-01110011b | 01111001b = 01111011b
-01110011b | 01111010b = 01111011b
-01110011b | 01111011b = 01111011b
-01110011b | 01111100b = 01111111b
-01110011b | 01111101b = 01111111b
-01110011b | 01111110b = 01111111b
-01110100b | 10000000b = 11110100b
-01110100b | 10000001b = 11110101b
-01110100b | 10000010b = 11110110b
-01110100b | 10000011b = 11110111b
-01110100b | 10000100b = 11110100b
-01110100b | 10000101b = 11110101b
-01110100b | 10000110b = 11110110b
-01110100b | 10000111b = 11110111b
-01110100b | 10001000b = 11111100b
-01110100b | 10001001b = 11111101b
-01110100b | 10001010b = 11111110b
-01110100b | 10001011b = 11111111b
-01110100b | 10001100b = 11111100b
-01110100b | 10001101b = 11111101b
-01110100b | 10001110b = 11111110b
-01110100b | 10001111b = 11111111b
-01110100b | 10010000b = 11110100b
-01110100b | 10010001b = 11110101b
-01110100b | 10010010b = 11110110b
-01110100b | 10010011b = 11110111b
-01110100b | 10010100b = 11110100b
-01110100b | 10010101b = 11110101b
-01110100b | 10010110b = 11110110b
-01110100b | 10010111b = 11110111b
-01110100b | 10011000b = 11111100b
-01110100b | 10011001b = 11111101b
-01110100b | 10011010b = 11111110b
-01110100b | 10011011b = 11111111b
-01110100b | 10011100b = 11111100b
-01110100b | 10011101b = 11111101b
-01110100b | 10011110b = 11111110b
-01110100b | 10011111b = 11111111b
-01110100b | 10100000b = 11110100b
-01110100b | 10100001b = 11110101b
-01110100b | 10100010b = 11110110b
-01110100b | 10100011b = 11110111b
-01110100b | 10100100b = 11110100b
-01110100b | 10100101b = 11110101b
-01110100b | 10100110b = 11110110b
-01110100b | 10100111b = 11110111b
-01110100b | 10101000b = 11111100b
-01110100b | 10101001b = 11111101b
-01110100b | 10101010b = 11111110b
-01110100b | 10101011b = 11111111b
-01110100b | 10101100b = 11111100b
-01110100b | 10101101b = 11111101b
-01110100b | 10101110b = 11111110b
-01110100b | 10101111b = 11111111b
-01110100b | 10110000b = 11110100b
-01110100b | 10110001b = 11110101b
-01110100b | 10110010b = 11110110b
-01110100b | 10110011b = 11110111b
-01110100b | 10110100b = 11110100b
-01110100b | 10110101b = 11110101b
-01110100b | 10110110b = 11110110b
-01110100b | 10110111b = 11110111b
-01110100b | 10111000b = 11111100b
-01110100b | 10111001b = 11111101b
-01110100b | 10111010b = 11111110b
-01110100b | 10111011b = 11111111b
-01110100b | 10111100b = 11111100b
-01110100b | 10111101b = 11111101b
-01110100b | 10111110b = 11111110b
-01110100b | 10111111b = 11111111b
-01110100b | 11000000b = 11110100b
-01110100b | 11000001b = 11110101b
-01110100b | 11000010b = 11110110b
-01110100b | 11000011b = 11110111b
-01110100b | 11000100b = 11110100b
-01110100b | 11000101b = 11110101b
-01110100b | 11000110b = 11110110b
-01110100b | 11000111b = 11110111b
-01110100b | 11001000b = 11111100b
-01110100b | 11001001b = 11111101b
-01110100b | 11001010b = 11111110b
-01110100b | 11001011b = 11111111b
-01110100b | 11001100b = 11111100b
-01110100b | 11001101b = 11111101b
-01110100b | 11001110b = 11111110b
-01110100b | 11001111b = 11111111b
-01110100b | 11010000b = 11110100b
-01110100b | 11010001b = 11110101b
-01110100b | 11010010b = 11110110b
-01110100b | 11010011b = 11110111b
-01110100b | 11010100b = 11110100b
-01110100b | 11010101b = 11110101b
-01110100b | 11010110b = 11110110b
-01110100b | 11010111b = 11110111b
-01110100b | 11011000b = 11111100b
-01110100b | 11011001b = 11111101b
-01110100b | 11011010b = 11111110b
-01110100b | 11011011b = 11111111b
-01110100b | 11011100b = 11111100b
-01110100b | 11011101b = 11111101b
-01110100b | 11011110b = 11111110b
-01110100b | 11011111b = 11111111b
-01110100b | 11100000b = 11110100b
-01110100b | 11100001b = 11110101b
-01110100b | 11100010b = 11110110b
-01110100b | 11100011b = 11110111b
-01110100b | 11100100b = 11110100b
-01110100b | 11100101b = 11110101b
-01110100b | 11100110b = 11110110b
-01110100b | 11100111b = 11110111b
-01110100b | 11101000b = 11111100b
-01110100b | 11101001b = 11111101b
-01110100b | 11101010b = 11111110b
-01110100b | 11101011b = 11111111b
-01110100b | 11101100b = 11111100b
-01110100b | 11101101b = 11111101b
-01110100b | 11101110b = 11111110b
-01110100b | 11101111b = 11111111b
-01110100b | 11110000b = 11110100b
-01110100b | 11110001b = 11110101b
-01110100b | 11110010b = 11110110b
-01110100b | 11110011b = 11110111b
-01110100b | 11110100b = 11110100b
-01110100b | 11110101b = 11110101b
-01110100b | 11110110b = 11110110b
-01110100b | 11110111b = 11110111b
-01110100b | 11111000b = 11111100b
-01110100b | 11111001b = 11111101b
-01110100b | 11111010b = 11111110b
-01110100b | 11111011b = 11111111b
-01110100b | 11111100b = 11111100b
-01110100b | 11111101b = 11111101b
-01110100b | 11111110b = 11111110b
-01110100b | 11111111b = 11111111b
-01110100b | 00000000b = 01110100b
-01110100b | 00000001b = 01110101b
-01110100b | 00000010b = 01110110b
-01110100b | 00000011b = 01110111b
-01110100b | 00000100b = 01110100b
-01110100b | 00000101b = 01110101b
-01110100b | 00000110b = 01110110b
-01110100b | 00000111b = 01110111b
-01110100b | 00001000b = 01111100b
-01110100b | 00001001b = 01111101b
-01110100b | 00001010b = 01111110b
-01110100b | 00001011b = 01111111b
-01110100b | 00001100b = 01111100b
-01110100b | 00001101b = 01111101b
-01110100b | 00001110b = 01111110b
-01110100b | 00001111b = 01111111b
-01110100b | 00010000b = 01110100b
-01110100b | 00010001b = 01110101b
-01110100b | 00010010b = 01110110b
-01110100b | 00010011b = 01110111b
-01110100b | 00010100b = 01110100b
-01110100b | 00010101b = 01110101b
-01110100b | 00010110b = 01110110b
-01110100b | 00010111b = 01110111b
-01110100b | 00011000b = 01111100b
-01110100b | 00011001b = 01111101b
-01110100b | 00011010b = 01111110b
-01110100b | 00011011b = 01111111b
-01110100b | 00011100b = 01111100b
-01110100b | 00011101b = 01111101b
-01110100b | 00011110b = 01111110b
-01110100b | 00011111b = 01111111b
-01110100b | 00100000b = 01110100b
-01110100b | 00100001b = 01110101b
-01110100b | 00100010b = 01110110b
-01110100b | 00100011b = 01110111b
-01110100b | 00100100b = 01110100b
-01110100b | 00100101b = 01110101b
-01110100b | 00100110b = 01110110b
-01110100b | 00100111b = 01110111b
-01110100b | 00101000b = 01111100b
-01110100b | 00101001b = 01111101b
-01110100b | 00101010b = 01111110b
-01110100b | 00101011b = 01111111b
-01110100b | 00101100b = 01111100b
-01110100b | 00101101b = 01111101b
-01110100b | 00101110b = 01111110b
-01110100b | 00101111b = 01111111b
-01110100b | 00110000b = 01110100b
-01110100b | 00110001b = 01110101b
-01110100b | 00110010b = 01110110b
-01110100b | 00110011b = 01110111b
-01110100b | 00110100b = 01110100b
-01110100b | 00110101b = 01110101b
-01110100b | 00110110b = 01110110b
-01110100b | 00110111b = 01110111b
-01110100b | 00111000b = 01111100b
-01110100b | 00111001b = 01111101b
-01110100b | 00111010b = 01111110b
-01110100b | 00111011b = 01111111b
-01110100b | 00111100b = 01111100b
-01110100b | 00111101b = 01111101b
-01110100b | 00111110b = 01111110b
-01110100b | 00111111b = 01111111b
-01110100b | 01000000b = 01110100b
-01110100b | 01000001b = 01110101b
-01110100b | 01000010b = 01110110b
-01110100b | 01000011b = 01110111b
-01110100b | 01000100b = 01110100b
-01110100b | 01000101b = 01110101b
-01110100b | 01000110b = 01110110b
-01110100b | 01000111b = 01110111b
-01110100b | 01001000b = 01111100b
-01110100b | 01001001b = 01111101b
-01110100b | 01001010b = 01111110b
-01110100b | 01001011b = 01111111b
-01110100b | 01001100b = 01111100b
-01110100b | 01001101b = 01111101b
-01110100b | 01001110b = 01111110b
-01110100b | 01001111b = 01111111b
-01110100b | 01010000b = 01110100b
-01110100b | 01010001b = 01110101b
-01110100b | 01010010b = 01110110b
-01110100b | 01010011b = 01110111b
-01110100b | 01010100b = 01110100b
-01110100b | 01010101b = 01110101b
-01110100b | 01010110b = 01110110b
-01110100b | 01010111b = 01110111b
-01110100b | 01011000b = 01111100b
-01110100b | 01011001b = 01111101b
-01110100b | 01011010b = 01111110b
-01110100b | 01011011b = 01111111b
-01110100b | 01011100b = 01111100b
-01110100b | 01011101b = 01111101b
-01110100b | 01011110b = 01111110b
-01110100b | 01011111b = 01111111b
-01110100b | 01100000b = 01110100b
-01110100b | 01100001b = 01110101b
-01110100b | 01100010b = 01110110b
-01110100b | 01100011b = 01110111b
-01110100b | 01100100b = 01110100b
-01110100b | 01100101b = 01110101b
-01110100b | 01100110b = 01110110b
-01110100b | 01100111b = 01110111b
-01110100b | 01101000b = 01111100b
-01110100b | 01101001b = 01111101b
-01110100b | 01101010b = 01111110b
-01110100b | 01101011b = 01111111b
-01110100b | 01101100b = 01111100b
-01110100b | 01101101b = 01111101b
-01110100b | 01101110b = 01111110b
-01110100b | 01101111b = 01111111b
-01110100b | 01110000b = 01110100b
-01110100b | 01110001b = 01110101b
-01110100b | 01110010b = 01110110b
-01110100b | 01110011b = 01110111b
-01110100b | 01110100b = 01110100b
-01110100b | 01110101b = 01110101b
-01110100b | 01110110b = 01110110b
-01110100b | 01110111b = 01110111b
-01110100b | 01111000b = 01111100b
-01110100b | 01111001b = 01111101b
-01110100b | 01111010b = 01111110b
-01110100b | 01111011b = 01111111b
-01110100b | 01111100b = 01111100b
-01110100b | 01111101b = 01111101b
-01110100b | 01111110b = 01111110b
-01110101b | 10000000b = 11110101b
-01110101b | 10000001b = 11110101b
-01110101b | 10000010b = 11110111b
-01110101b | 10000011b = 11110111b
-01110101b | 10000100b = 11110101b
-01110101b | 10000101b = 11110101b
-01110101b | 10000110b = 11110111b
-01110101b | 10000111b = 11110111b
-01110101b | 10001000b = 11111101b
-01110101b | 10001001b = 11111101b
-01110101b | 10001010b = 11111111b
-01110101b | 10001011b = 11111111b
-01110101b | 10001100b = 11111101b
-01110101b | 10001101b = 11111101b
-01110101b | 10001110b = 11111111b
-01110101b | 10001111b = 11111111b
-01110101b | 10010000b = 11110101b
-01110101b | 10010001b = 11110101b
-01110101b | 10010010b = 11110111b
-01110101b | 10010011b = 11110111b
-01110101b | 10010100b = 11110101b
-01110101b | 10010101b = 11110101b
-01110101b | 10010110b = 11110111b
-01110101b | 10010111b = 11110111b
-01110101b | 10011000b = 11111101b
-01110101b | 10011001b = 11111101b
-01110101b | 10011010b = 11111111b
-01110101b | 10011011b = 11111111b
-01110101b | 10011100b = 11111101b
-01110101b | 10011101b = 11111101b
-01110101b | 10011110b = 11111111b
-01110101b | 10011111b = 11111111b
-01110101b | 10100000b = 11110101b
-01110101b | 10100001b = 11110101b
-01110101b | 10100010b = 11110111b
-01110101b | 10100011b = 11110111b
-01110101b | 10100100b = 11110101b
-01110101b | 10100101b = 11110101b
-01110101b | 10100110b = 11110111b
-01110101b | 10100111b = 11110111b
-01110101b | 10101000b = 11111101b
-01110101b | 10101001b = 11111101b
-01110101b | 10101010b = 11111111b
-01110101b | 10101011b = 11111111b
-01110101b | 10101100b = 11111101b
-01110101b | 10101101b = 11111101b
-01110101b | 10101110b = 11111111b
-01110101b | 10101111b = 11111111b
-01110101b | 10110000b = 11110101b
-01110101b | 10110001b = 11110101b
-01110101b | 10110010b = 11110111b
-01110101b | 10110011b = 11110111b
-01110101b | 10110100b = 11110101b
-01110101b | 10110101b = 11110101b
-01110101b | 10110110b = 11110111b
-01110101b | 10110111b = 11110111b
-01110101b | 10111000b = 11111101b
-01110101b | 10111001b = 11111101b
-01110101b | 10111010b = 11111111b
-01110101b | 10111011b = 11111111b
-01110101b | 10111100b = 11111101b
-01110101b | 10111101b = 11111101b
-01110101b | 10111110b = 11111111b
-01110101b | 10111111b = 11111111b
-01110101b | 11000000b = 11110101b
-01110101b | 11000001b = 11110101b
-01110101b | 11000010b = 11110111b
-01110101b | 11000011b = 11110111b
-01110101b | 11000100b = 11110101b
-01110101b | 11000101b = 11110101b
-01110101b | 11000110b = 11110111b
-01110101b | 11000111b = 11110111b
-01110101b | 11001000b = 11111101b
-01110101b | 11001001b = 11111101b
-01110101b | 11001010b = 11111111b
-01110101b | 11001011b = 11111111b
-01110101b | 11001100b = 11111101b
-01110101b | 11001101b = 11111101b
-01110101b | 11001110b = 11111111b
-01110101b | 11001111b = 11111111b
-01110101b | 11010000b = 11110101b
-01110101b | 11010001b = 11110101b
-01110101b | 11010010b = 11110111b
-01110101b | 11010011b = 11110111b
-01110101b | 11010100b = 11110101b
-01110101b | 11010101b = 11110101b
-01110101b | 11010110b = 11110111b
-01110101b | 11010111b = 11110111b
-01110101b | 11011000b = 11111101b
-01110101b | 11011001b = 11111101b
-01110101b | 11011010b = 11111111b
-01110101b | 11011011b = 11111111b
-01110101b | 11011100b = 11111101b
-01110101b | 11011101b = 11111101b
-01110101b | 11011110b = 11111111b
-01110101b | 11011111b = 11111111b
-01110101b | 11100000b = 11110101b
-01110101b | 11100001b = 11110101b
-01110101b | 11100010b = 11110111b
-01110101b | 11100011b = 11110111b
-01110101b | 11100100b = 11110101b
-01110101b | 11100101b = 11110101b
-01110101b | 11100110b = 11110111b
-01110101b | 11100111b = 11110111b
-01110101b | 11101000b = 11111101b
-01110101b | 11101001b = 11111101b
-01110101b | 11101010b = 11111111b
-01110101b | 11101011b = 11111111b
-01110101b | 11101100b = 11111101b
-01110101b | 11101101b = 11111101b
-01110101b | 11101110b = 11111111b
-01110101b | 11101111b = 11111111b
-01110101b | 11110000b = 11110101b
-01110101b | 11110001b = 11110101b
-01110101b | 11110010b = 11110111b
-01110101b | 11110011b = 11110111b
-01110101b | 11110100b = 11110101b
-01110101b | 11110101b = 11110101b
-01110101b | 11110110b = 11110111b
-01110101b | 11110111b = 11110111b
-01110101b | 11111000b = 11111101b
-01110101b | 11111001b = 11111101b
-01110101b | 11111010b = 11111111b
-01110101b | 11111011b = 11111111b
-01110101b | 11111100b = 11111101b
-01110101b | 11111101b = 11111101b
-01110101b | 11111110b = 11111111b
-01110101b | 11111111b = 11111111b
-01110101b | 00000000b = 01110101b
-01110101b | 00000001b = 01110101b
-01110101b | 00000010b = 01110111b
-01110101b | 00000011b = 01110111b
-01110101b | 00000100b = 01110101b
-01110101b | 00000101b = 01110101b
-01110101b | 00000110b = 01110111b
-01110101b | 00000111b = 01110111b
-01110101b | 00001000b = 01111101b
-01110101b | 00001001b = 01111101b
-01110101b | 00001010b = 01111111b
-01110101b | 00001011b = 01111111b
-01110101b | 00001100b = 01111101b
-01110101b | 00001101b = 01111101b
-01110101b | 00001110b = 01111111b
-01110101b | 00001111b = 01111111b
-01110101b | 00010000b = 01110101b
-01110101b | 00010001b = 01110101b
-01110101b | 00010010b = 01110111b
-01110101b | 00010011b = 01110111b
-01110101b | 00010100b = 01110101b
-01110101b | 00010101b = 01110101b
-01110101b | 00010110b = 01110111b
-01110101b | 00010111b = 01110111b
-01110101b | 00011000b = 01111101b
-01110101b | 00011001b = 01111101b
-01110101b | 00011010b = 01111111b
-01110101b | 00011011b = 01111111b
-01110101b | 00011100b = 01111101b
-01110101b | 00011101b = 01111101b
-01110101b | 00011110b = 01111111b
-01110101b | 00011111b = 01111111b
-01110101b | 00100000b = 01110101b
-01110101b | 00100001b = 01110101b
-01110101b | 00100010b = 01110111b
-01110101b | 00100011b = 01110111b
-01110101b | 00100100b = 01110101b
-01110101b | 00100101b = 01110101b
-01110101b | 00100110b = 01110111b
-01110101b | 00100111b = 01110111b
-01110101b | 00101000b = 01111101b
-01110101b | 00101001b = 01111101b
-01110101b | 00101010b = 01111111b
-01110101b | 00101011b = 01111111b
-01110101b | 00101100b = 01111101b
-01110101b | 00101101b = 01111101b
-01110101b | 00101110b = 01111111b
-01110101b | 00101111b = 01111111b
-01110101b | 00110000b = 01110101b
-01110101b | 00110001b = 01110101b
-01110101b | 00110010b = 01110111b
-01110101b | 00110011b = 01110111b
-01110101b | 00110100b = 01110101b
-01110101b | 00110101b = 01110101b
-01110101b | 00110110b = 01110111b
-01110101b | 00110111b = 01110111b
-01110101b | 00111000b = 01111101b
-01110101b | 00111001b = 01111101b
-01110101b | 00111010b = 01111111b
-01110101b | 00111011b = 01111111b
-01110101b | 00111100b = 01111101b
-01110101b | 00111101b = 01111101b
-01110101b | 00111110b = 01111111b
-01110101b | 00111111b = 01111111b
-01110101b | 01000000b = 01110101b
-01110101b | 01000001b = 01110101b
-01110101b | 01000010b = 01110111b
-01110101b | 01000011b = 01110111b
-01110101b | 01000100b = 01110101b
-01110101b | 01000101b = 01110101b
-01110101b | 01000110b = 01110111b
-01110101b | 01000111b = 01110111b
-01110101b | 01001000b = 01111101b
-01110101b | 01001001b = 01111101b
-01110101b | 01001010b = 01111111b
-01110101b | 01001011b = 01111111b
-01110101b | 01001100b = 01111101b
-01110101b | 01001101b = 01111101b
-01110101b | 01001110b = 01111111b
-01110101b | 01001111b = 01111111b
-01110101b | 01010000b = 01110101b
-01110101b | 01010001b = 01110101b
-01110101b | 01010010b = 01110111b
-01110101b | 01010011b = 01110111b
-01110101b | 01010100b = 01110101b
-01110101b | 01010101b = 01110101b
-01110101b | 01010110b = 01110111b
-01110101b | 01010111b = 01110111b
-01110101b | 01011000b = 01111101b
-01110101b | 01011001b = 01111101b
-01110101b | 01011010b = 01111111b
-01110101b | 01011011b = 01111111b
-01110101b | 01011100b = 01111101b
-01110101b | 01011101b = 01111101b
-01110101b | 01011110b = 01111111b
-01110101b | 01011111b = 01111111b
-01110101b | 01100000b = 01110101b
-01110101b | 01100001b = 01110101b
-01110101b | 01100010b = 01110111b
-01110101b | 01100011b = 01110111b
-01110101b | 01100100b = 01110101b
-01110101b | 01100101b = 01110101b
-01110101b | 01100110b = 01110111b
-01110101b | 01100111b = 01110111b
-01110101b | 01101000b = 01111101b
-01110101b | 01101001b = 01111101b
-01110101b | 01101010b = 01111111b
-01110101b | 01101011b = 01111111b
-01110101b | 01101100b = 01111101b
-01110101b | 01101101b = 01111101b
-01110101b | 01101110b = 01111111b
-01110101b | 01101111b = 01111111b
-01110101b | 01110000b = 01110101b
-01110101b | 01110001b = 01110101b
-01110101b | 01110010b = 01110111b
-01110101b | 01110011b = 01110111b
-01110101b | 01110100b = 01110101b
-01110101b | 01110101b = 01110101b
-01110101b | 01110110b = 01110111b
-01110101b | 01110111b = 01110111b
-01110101b | 01111000b = 01111101b
-01110101b | 01111001b = 01111101b
-01110101b | 01111010b = 01111111b
-01110101b | 01111011b = 01111111b
-01110101b | 01111100b = 01111101b
-01110101b | 01111101b = 01111101b
-01110101b | 01111110b = 01111111b
-01110110b | 10000000b = 11110110b
-01110110b | 10000001b = 11110111b
-01110110b | 10000010b = 11110110b
-01110110b | 10000011b = 11110111b
-01110110b | 10000100b = 11110110b
-01110110b | 10000101b = 11110111b
-01110110b | 10000110b = 11110110b
-01110110b | 10000111b = 11110111b
-01110110b | 10001000b = 11111110b
-01110110b | 10001001b = 11111111b
-01110110b | 10001010b = 11111110b
-01110110b | 10001011b = 11111111b
-01110110b | 10001100b = 11111110b
-01110110b | 10001101b = 11111111b
-01110110b | 10001110b = 11111110b
-01110110b | 10001111b = 11111111b
-01110110b | 10010000b = 11110110b
-01110110b | 10010001b = 11110111b
-01110110b | 10010010b = 11110110b
-01110110b | 10010011b = 11110111b
-01110110b | 10010100b = 11110110b
-01110110b | 10010101b = 11110111b
-01110110b | 10010110b = 11110110b
-01110110b | 10010111b = 11110111b
-01110110b | 10011000b = 11111110b
-01110110b | 10011001b = 11111111b
-01110110b | 10011010b = 11111110b
-01110110b | 10011011b = 11111111b
-01110110b | 10011100b = 11111110b
-01110110b | 10011101b = 11111111b
-01110110b | 10011110b = 11111110b
-01110110b | 10011111b = 11111111b
-01110110b | 10100000b = 11110110b
-01110110b | 10100001b = 11110111b
-01110110b | 10100010b = 11110110b
-01110110b | 10100011b = 11110111b
-01110110b | 10100100b = 11110110b
-01110110b | 10100101b = 11110111b
-01110110b | 10100110b = 11110110b
-01110110b | 10100111b = 11110111b
-01110110b | 10101000b = 11111110b
-01110110b | 10101001b = 11111111b
-01110110b | 10101010b = 11111110b
-01110110b | 10101011b = 11111111b
-01110110b | 10101100b = 11111110b
-01110110b | 10101101b = 11111111b
-01110110b | 10101110b = 11111110b
-01110110b | 10101111b = 11111111b
-01110110b | 10110000b = 11110110b
-01110110b | 10110001b = 11110111b
-01110110b | 10110010b = 11110110b
-01110110b | 10110011b = 11110111b
-01110110b | 10110100b = 11110110b
-01110110b | 10110101b = 11110111b
-01110110b | 10110110b = 11110110b
-01110110b | 10110111b = 11110111b
-01110110b | 10111000b = 11111110b
-01110110b | 10111001b = 11111111b
-01110110b | 10111010b = 11111110b
-01110110b | 10111011b = 11111111b
-01110110b | 10111100b = 11111110b
-01110110b | 10111101b = 11111111b
-01110110b | 10111110b = 11111110b
-01110110b | 10111111b = 11111111b
-01110110b | 11000000b = 11110110b
-01110110b | 11000001b = 11110111b
-01110110b | 11000010b = 11110110b
-01110110b | 11000011b = 11110111b
-01110110b | 11000100b = 11110110b
-01110110b | 11000101b = 11110111b
-01110110b | 11000110b = 11110110b
-01110110b | 11000111b = 11110111b
-01110110b | 11001000b = 11111110b
-01110110b | 11001001b = 11111111b
-01110110b | 11001010b = 11111110b
-01110110b | 11001011b = 11111111b
-01110110b | 11001100b = 11111110b
-01110110b | 11001101b = 11111111b
-01110110b | 11001110b = 11111110b
-01110110b | 11001111b = 11111111b
-01110110b | 11010000b = 11110110b
-01110110b | 11010001b = 11110111b
-01110110b | 11010010b = 11110110b
-01110110b | 11010011b = 11110111b
-01110110b | 11010100b = 11110110b
-01110110b | 11010101b = 11110111b
-01110110b | 11010110b = 11110110b
-01110110b | 11010111b = 11110111b
-01110110b | 11011000b = 11111110b
-01110110b | 11011001b = 11111111b
-01110110b | 11011010b = 11111110b
-01110110b | 11011011b = 11111111b
-01110110b | 11011100b = 11111110b
-01110110b | 11011101b = 11111111b
-01110110b | 11011110b = 11111110b
-01110110b | 11011111b = 11111111b
-01110110b | 11100000b = 11110110b
-01110110b | 11100001b = 11110111b
-01110110b | 11100010b = 11110110b
-01110110b | 11100011b = 11110111b
-01110110b | 11100100b = 11110110b
-01110110b | 11100101b = 11110111b
-01110110b | 11100110b = 11110110b
-01110110b | 11100111b = 11110111b
-01110110b | 11101000b = 11111110b
-01110110b | 11101001b = 11111111b
-01110110b | 11101010b = 11111110b
-01110110b | 11101011b = 11111111b
-01110110b | 11101100b = 11111110b
-01110110b | 11101101b = 11111111b
-01110110b | 11101110b = 11111110b
-01110110b | 11101111b = 11111111b
-01110110b | 11110000b = 11110110b
-01110110b | 11110001b = 11110111b
-01110110b | 11110010b = 11110110b
-01110110b | 11110011b = 11110111b
-01110110b | 11110100b = 11110110b
-01110110b | 11110101b = 11110111b
-01110110b | 11110110b = 11110110b
-01110110b | 11110111b = 11110111b
-01110110b | 11111000b = 11111110b
-01110110b | 11111001b = 11111111b
-01110110b | 11111010b = 11111110b
-01110110b | 11111011b = 11111111b
-01110110b | 11111100b = 11111110b
-01110110b | 11111101b = 11111111b
-01110110b | 11111110b = 11111110b
-01110110b | 11111111b = 11111111b
-01110110b | 00000000b = 01110110b
-01110110b | 00000001b = 01110111b
-01110110b | 00000010b = 01110110b
-01110110b | 00000011b = 01110111b
-01110110b | 00000100b = 01110110b
-01110110b | 00000101b = 01110111b
-01110110b | 00000110b = 01110110b
-01110110b | 00000111b = 01110111b
-01110110b | 00001000b = 01111110b
-01110110b | 00001001b = 01111111b
-01110110b | 00001010b = 01111110b
-01110110b | 00001011b = 01111111b
-01110110b | 00001100b = 01111110b
-01110110b | 00001101b = 01111111b
-01110110b | 00001110b = 01111110b
-01110110b | 00001111b = 01111111b
-01110110b | 00010000b = 01110110b
-01110110b | 00010001b = 01110111b
-01110110b | 00010010b = 01110110b
-01110110b | 00010011b = 01110111b
-01110110b | 00010100b = 01110110b
-01110110b | 00010101b = 01110111b
-01110110b | 00010110b = 01110110b
-01110110b | 00010111b = 01110111b
-01110110b | 00011000b = 01111110b
-01110110b | 00011001b = 01111111b
-01110110b | 00011010b = 01111110b
-01110110b | 00011011b = 01111111b
-01110110b | 00011100b = 01111110b
-01110110b | 00011101b = 01111111b
-01110110b | 00011110b = 01111110b
-01110110b | 00011111b = 01111111b
-01110110b | 00100000b = 01110110b
-01110110b | 00100001b = 01110111b
-01110110b | 00100010b = 01110110b
-01110110b | 00100011b = 01110111b
-01110110b | 00100100b = 01110110b
-01110110b | 00100101b = 01110111b
-01110110b | 00100110b = 01110110b
-01110110b | 00100111b = 01110111b
-01110110b | 00101000b = 01111110b
-01110110b | 00101001b = 01111111b
-01110110b | 00101010b = 01111110b
-01110110b | 00101011b = 01111111b
-01110110b | 00101100b = 01111110b
-01110110b | 00101101b = 01111111b
-01110110b | 00101110b = 01111110b
-01110110b | 00101111b = 01111111b
-01110110b | 00110000b = 01110110b
-01110110b | 00110001b = 01110111b
-01110110b | 00110010b = 01110110b
-01110110b | 00110011b = 01110111b
-01110110b | 00110100b = 01110110b
-01110110b | 00110101b = 01110111b
-01110110b | 00110110b = 01110110b
-01110110b | 00110111b = 01110111b
-01110110b | 00111000b = 01111110b
-01110110b | 00111001b = 01111111b
-01110110b | 00111010b = 01111110b
-01110110b | 00111011b = 01111111b
-01110110b | 00111100b = 01111110b
-01110110b | 00111101b = 01111111b
-01110110b | 00111110b = 01111110b
-01110110b | 00111111b = 01111111b
-01110110b | 01000000b = 01110110b
-01110110b | 01000001b = 01110111b
-01110110b | 01000010b = 01110110b
-01110110b | 01000011b = 01110111b
-01110110b | 01000100b = 01110110b
-01110110b | 01000101b = 01110111b
-01110110b | 01000110b = 01110110b
-01110110b | 01000111b = 01110111b
-01110110b | 01001000b = 01111110b
-01110110b | 01001001b = 01111111b
-01110110b | 01001010b = 01111110b
-01110110b | 01001011b = 01111111b
-01110110b | 01001100b = 01111110b
-01110110b | 01001101b = 01111111b
-01110110b | 01001110b = 01111110b
-01110110b | 01001111b = 01111111b
-01110110b | 01010000b = 01110110b
-01110110b | 01010001b = 01110111b
-01110110b | 01010010b = 01110110b
-01110110b | 01010011b = 01110111b
-01110110b | 01010100b = 01110110b
-01110110b | 01010101b = 01110111b
-01110110b | 01010110b = 01110110b
-01110110b | 01010111b = 01110111b
-01110110b | 01011000b = 01111110b
-01110110b | 01011001b = 01111111b
-01110110b | 01011010b = 01111110b
-01110110b | 01011011b = 01111111b
-01110110b | 01011100b = 01111110b
-01110110b | 01011101b = 01111111b
-01110110b | 01011110b = 01111110b
-01110110b | 01011111b = 01111111b
-01110110b | 01100000b = 01110110b
-01110110b | 01100001b = 01110111b
-01110110b | 01100010b = 01110110b
-01110110b | 01100011b = 01110111b
-01110110b | 01100100b = 01110110b
-01110110b | 01100101b = 01110111b
-01110110b | 01100110b = 01110110b
-01110110b | 01100111b = 01110111b
-01110110b | 01101000b = 01111110b
-01110110b | 01101001b = 01111111b
-01110110b | 01101010b = 01111110b
-01110110b | 01101011b = 01111111b
-01110110b | 01101100b = 01111110b
-01110110b | 01101101b = 01111111b
-01110110b | 01101110b = 01111110b
-01110110b | 01101111b = 01111111b
-01110110b | 01110000b = 01110110b
-01110110b | 01110001b = 01110111b
-01110110b | 01110010b = 01110110b
-01110110b | 01110011b = 01110111b
-01110110b | 01110100b = 01110110b
-01110110b | 01110101b = 01110111b
-01110110b | 01110110b = 01110110b
-01110110b | 01110111b = 01110111b
-01110110b | 01111000b = 01111110b
-01110110b | 01111001b = 01111111b
-01110110b | 01111010b = 01111110b
-01110110b | 01111011b = 01111111b
-01110110b | 01111100b = 01111110b
-01110110b | 01111101b = 01111111b
-01110110b | 01111110b = 01111110b
-01110111b | 10000000b = 11110111b
-01110111b | 10000001b = 11110111b
-01110111b | 10000010b = 11110111b
-01110111b | 10000011b = 11110111b
-01110111b | 10000100b = 11110111b
-01110111b | 10000101b = 11110111b
-01110111b | 10000110b = 11110111b
-01110111b | 10000111b = 11110111b
-01110111b | 10001000b = 11111111b
-01110111b | 10001001b = 11111111b
-01110111b | 10001010b = 11111111b
-01110111b | 10001011b = 11111111b
-01110111b | 10001100b = 11111111b
-01110111b | 10001101b = 11111111b
-01110111b | 10001110b = 11111111b
-01110111b | 10001111b = 11111111b
-01110111b | 10010000b = 11110111b
-01110111b | 10010001b = 11110111b
-01110111b | 10010010b = 11110111b
-01110111b | 10010011b = 11110111b
-01110111b | 10010100b = 11110111b
-01110111b | 10010101b = 11110111b
-01110111b | 10010110b = 11110111b
-01110111b | 10010111b = 11110111b
-01110111b | 10011000b = 11111111b
-01110111b | 10011001b = 11111111b
-01110111b | 10011010b = 11111111b
-01110111b | 10011011b = 11111111b
-01110111b | 10011100b = 11111111b
-01110111b | 10011101b = 11111111b
-01110111b | 10011110b = 11111111b
-01110111b | 10011111b = 11111111b
-01110111b | 10100000b = 11110111b
-01110111b | 10100001b = 11110111b
-01110111b | 10100010b = 11110111b
-01110111b | 10100011b = 11110111b
-01110111b | 10100100b = 11110111b
-01110111b | 10100101b = 11110111b
-01110111b | 10100110b = 11110111b
-01110111b | 10100111b = 11110111b
-01110111b | 10101000b = 11111111b
-01110111b | 10101001b = 11111111b
-01110111b | 10101010b = 11111111b
-01110111b | 10101011b = 11111111b
-01110111b | 10101100b = 11111111b
-01110111b | 10101101b = 11111111b
-01110111b | 10101110b = 11111111b
-01110111b | 10101111b = 11111111b
-01110111b | 10110000b = 11110111b
-01110111b | 10110001b = 11110111b
-01110111b | 10110010b = 11110111b
-01110111b | 10110011b = 11110111b
-01110111b | 10110100b = 11110111b
-01110111b | 10110101b = 11110111b
-01110111b | 10110110b = 11110111b
-01110111b | 10110111b = 11110111b
-01110111b | 10111000b = 11111111b
-01110111b | 10111001b = 11111111b
-01110111b | 10111010b = 11111111b
-01110111b | 10111011b = 11111111b
-01110111b | 10111100b = 11111111b
-01110111b | 10111101b = 11111111b
-01110111b | 10111110b = 11111111b
-01110111b | 10111111b = 11111111b
-01110111b | 11000000b = 11110111b
-01110111b | 11000001b = 11110111b
-01110111b | 11000010b = 11110111b
-01110111b | 11000011b = 11110111b
-01110111b | 11000100b = 11110111b
-01110111b | 11000101b = 11110111b
-01110111b | 11000110b = 11110111b
-01110111b | 11000111b = 11110111b
-01110111b | 11001000b = 11111111b
-01110111b | 11001001b = 11111111b
-01110111b | 11001010b = 11111111b
-01110111b | 11001011b = 11111111b
-01110111b | 11001100b = 11111111b
-01110111b | 11001101b = 11111111b
-01110111b | 11001110b = 11111111b
-01110111b | 11001111b = 11111111b
-01110111b | 11010000b = 11110111b
-01110111b | 11010001b = 11110111b
-01110111b | 11010010b = 11110111b
-01110111b | 11010011b = 11110111b
-01110111b | 11010100b = 11110111b
-01110111b | 11010101b = 11110111b
-01110111b | 11010110b = 11110111b
-01110111b | 11010111b = 11110111b
-01110111b | 11011000b = 11111111b
-01110111b | 11011001b = 11111111b
-01110111b | 11011010b = 11111111b
-01110111b | 11011011b = 11111111b
-01110111b | 11011100b = 11111111b
-01110111b | 11011101b = 11111111b
-01110111b | 11011110b = 11111111b
-01110111b | 11011111b = 11111111b
-01110111b | 11100000b = 11110111b
-01110111b | 11100001b = 11110111b
-01110111b | 11100010b = 11110111b
-01110111b | 11100011b = 11110111b
-01110111b | 11100100b = 11110111b
-01110111b | 11100101b = 11110111b
-01110111b | 11100110b = 11110111b
-01110111b | 11100111b = 11110111b
-01110111b | 11101000b = 11111111b
-01110111b | 11101001b = 11111111b
-01110111b | 11101010b = 11111111b
-01110111b | 11101011b = 11111111b
-01110111b | 11101100b = 11111111b
-01110111b | 11101101b = 11111111b
-01110111b | 11101110b = 11111111b
-01110111b | 11101111b = 11111111b
-01110111b | 11110000b = 11110111b
-01110111b | 11110001b = 11110111b
-01110111b | 11110010b = 11110111b
-01110111b | 11110011b = 11110111b
-01110111b | 11110100b = 11110111b
-01110111b | 11110101b = 11110111b
-01110111b | 11110110b = 11110111b
-01110111b | 11110111b = 11110111b
-01110111b | 11111000b = 11111111b
-01110111b | 11111001b = 11111111b
-01110111b | 11111010b = 11111111b
-01110111b | 11111011b = 11111111b
-01110111b | 11111100b = 11111111b
-01110111b | 11111101b = 11111111b
-01110111b | 11111110b = 11111111b
-01110111b | 11111111b = 11111111b
-01110111b | 00000000b = 01110111b
-01110111b | 00000001b = 01110111b
-01110111b | 00000010b = 01110111b
-01110111b | 00000011b = 01110111b
-01110111b | 00000100b = 01110111b
-01110111b | 00000101b = 01110111b
-01110111b | 00000110b = 01110111b
-01110111b | 00000111b = 01110111b
-01110111b | 00001000b = 01111111b
-01110111b | 00001001b = 01111111b
-01110111b | 00001010b = 01111111b
-01110111b | 00001011b = 01111111b
-01110111b | 00001100b = 01111111b
-01110111b | 00001101b = 01111111b
-01110111b | 00001110b = 01111111b
-01110111b | 00001111b = 01111111b
-01110111b | 00010000b = 01110111b
-01110111b | 00010001b = 01110111b
-01110111b | 00010010b = 01110111b
-01110111b | 00010011b = 01110111b
-01110111b | 00010100b = 01110111b
-01110111b | 00010101b = 01110111b
-01110111b | 00010110b = 01110111b
-01110111b | 00010111b = 01110111b
-01110111b | 00011000b = 01111111b
-01110111b | 00011001b = 01111111b
-01110111b | 00011010b = 01111111b
-01110111b | 00011011b = 01111111b
-01110111b | 00011100b = 01111111b
-01110111b | 00011101b = 01111111b
-01110111b | 00011110b = 01111111b
-01110111b | 00011111b = 01111111b
-01110111b | 00100000b = 01110111b
-01110111b | 00100001b = 01110111b
-01110111b | 00100010b = 01110111b
-01110111b | 00100011b = 01110111b
-01110111b | 00100100b = 01110111b
-01110111b | 00100101b = 01110111b
-01110111b | 00100110b = 01110111b
-01110111b | 00100111b = 01110111b
-01110111b | 00101000b = 01111111b
-01110111b | 00101001b = 01111111b
-01110111b | 00101010b = 01111111b
-01110111b | 00101011b = 01111111b
-01110111b | 00101100b = 01111111b
-01110111b | 00101101b = 01111111b
-01110111b | 00101110b = 01111111b
-01110111b | 00101111b = 01111111b
-01110111b | 00110000b = 01110111b
-01110111b | 00110001b = 01110111b
-01110111b | 00110010b = 01110111b
-01110111b | 00110011b = 01110111b
-01110111b | 00110100b = 01110111b
-01110111b | 00110101b = 01110111b
-01110111b | 00110110b = 01110111b
-01110111b | 00110111b = 01110111b
-01110111b | 00111000b = 01111111b
-01110111b | 00111001b = 01111111b
-01110111b | 00111010b = 01111111b
-01110111b | 00111011b = 01111111b
-01110111b | 00111100b = 01111111b
-01110111b | 00111101b = 01111111b
-01110111b | 00111110b = 01111111b
-01110111b | 00111111b = 01111111b
-01110111b | 01000000b = 01110111b
-01110111b | 01000001b = 01110111b
-01110111b | 01000010b = 01110111b
-01110111b | 01000011b = 01110111b
-01110111b | 01000100b = 01110111b
-01110111b | 01000101b = 01110111b
-01110111b | 01000110b = 01110111b
-01110111b | 01000111b = 01110111b
-01110111b | 01001000b = 01111111b
-01110111b | 01001001b = 01111111b
-01110111b | 01001010b = 01111111b
-01110111b | 01001011b = 01111111b
-01110111b | 01001100b = 01111111b
-01110111b | 01001101b = 01111111b
-01110111b | 01001110b = 01111111b
-01110111b | 01001111b = 01111111b
-01110111b | 01010000b = 01110111b
-01110111b | 01010001b = 01110111b
-01110111b | 01010010b = 01110111b
-01110111b | 01010011b = 01110111b
-01110111b | 01010100b = 01110111b
-01110111b | 01010101b = 01110111b
-01110111b | 01010110b = 01110111b
-01110111b | 01010111b = 01110111b
-01110111b | 01011000b = 01111111b
-01110111b | 01011001b = 01111111b
-01110111b | 01011010b = 01111111b
-01110111b | 01011011b = 01111111b
-01110111b | 01011100b = 01111111b
-01110111b | 01011101b = 01111111b
-01110111b | 01011110b = 01111111b
-01110111b | 01011111b = 01111111b
-01110111b | 01100000b = 01110111b
-01110111b | 01100001b = 01110111b
-01110111b | 01100010b = 01110111b
-01110111b | 01100011b = 01110111b
-01110111b | 01100100b = 01110111b
-01110111b | 01100101b = 01110111b
-01110111b | 01100110b = 01110111b
-01110111b | 01100111b = 01110111b
-01110111b | 01101000b = 01111111b
-01110111b | 01101001b = 01111111b
-01110111b | 01101010b = 01111111b
-01110111b | 01101011b = 01111111b
-01110111b | 01101100b = 01111111b
-01110111b | 01101101b = 01111111b
-01110111b | 01101110b = 01111111b
-01110111b | 01101111b = 01111111b
-01110111b | 01110000b = 01110111b
-01110111b | 01110001b = 01110111b
-01110111b | 01110010b = 01110111b
-01110111b | 01110011b = 01110111b
-01110111b | 01110100b = 01110111b
-01110111b | 01110101b = 01110111b
-01110111b | 01110110b = 01110111b
-01110111b | 01110111b = 01110111b
-01110111b | 01111000b = 01111111b
-01110111b | 01111001b = 01111111b
-01110111b | 01111010b = 01111111b
-01110111b | 01111011b = 01111111b
-01110111b | 01111100b = 01111111b
-01110111b | 01111101b = 01111111b
-01110111b | 01111110b = 01111111b
-01111000b | 10000000b = 11111000b
-01111000b | 10000001b = 11111001b
-01111000b | 10000010b = 11111010b
-01111000b | 10000011b = 11111011b
-01111000b | 10000100b = 11111100b
-01111000b | 10000101b = 11111101b
-01111000b | 10000110b = 11111110b
-01111000b | 10000111b = 11111111b
-01111000b | 10001000b = 11111000b
-01111000b | 10001001b = 11111001b
-01111000b | 10001010b = 11111010b
-01111000b | 10001011b = 11111011b
-01111000b | 10001100b = 11111100b
-01111000b | 10001101b = 11111101b
-01111000b | 10001110b = 11111110b
-01111000b | 10001111b = 11111111b
-01111000b | 10010000b = 11111000b
-01111000b | 10010001b = 11111001b
-01111000b | 10010010b = 11111010b
-01111000b | 10010011b = 11111011b
-01111000b | 10010100b = 11111100b
-01111000b | 10010101b = 11111101b
-01111000b | 10010110b = 11111110b
-01111000b | 10010111b = 11111111b
-01111000b | 10011000b = 11111000b
-01111000b | 10011001b = 11111001b
-01111000b | 10011010b = 11111010b
-01111000b | 10011011b = 11111011b
-01111000b | 10011100b = 11111100b
-01111000b | 10011101b = 11111101b
-01111000b | 10011110b = 11111110b
-01111000b | 10011111b = 11111111b
-01111000b | 10100000b = 11111000b
-01111000b | 10100001b = 11111001b
-01111000b | 10100010b = 11111010b
-01111000b | 10100011b = 11111011b
-01111000b | 10100100b = 11111100b
-01111000b | 10100101b = 11111101b
-01111000b | 10100110b = 11111110b
-01111000b | 10100111b = 11111111b
-01111000b | 10101000b = 11111000b
-01111000b | 10101001b = 11111001b
-01111000b | 10101010b = 11111010b
-01111000b | 10101011b = 11111011b
-01111000b | 10101100b = 11111100b
-01111000b | 10101101b = 11111101b
-01111000b | 10101110b = 11111110b
-01111000b | 10101111b = 11111111b
-01111000b | 10110000b = 11111000b
-01111000b | 10110001b = 11111001b
-01111000b | 10110010b = 11111010b
-01111000b | 10110011b = 11111011b
-01111000b | 10110100b = 11111100b
-01111000b | 10110101b = 11111101b
-01111000b | 10110110b = 11111110b
-01111000b | 10110111b = 11111111b
-01111000b | 10111000b = 11111000b
-01111000b | 10111001b = 11111001b
-01111000b | 10111010b = 11111010b
-01111000b | 10111011b = 11111011b
-01111000b | 10111100b = 11111100b
-01111000b | 10111101b = 11111101b
-01111000b | 10111110b = 11111110b
-01111000b | 10111111b = 11111111b
-01111000b | 11000000b = 11111000b
-01111000b | 11000001b = 11111001b
-01111000b | 11000010b = 11111010b
-01111000b | 11000011b = 11111011b
-01111000b | 11000100b = 11111100b
-01111000b | 11000101b = 11111101b
-01111000b | 11000110b = 11111110b
-01111000b | 11000111b = 11111111b
-01111000b | 11001000b = 11111000b
-01111000b | 11001001b = 11111001b
-01111000b | 11001010b = 11111010b
-01111000b | 11001011b = 11111011b
-01111000b | 11001100b = 11111100b
-01111000b | 11001101b = 11111101b
-01111000b | 11001110b = 11111110b
-01111000b | 11001111b = 11111111b
-01111000b | 11010000b = 11111000b
-01111000b | 11010001b = 11111001b
-01111000b | 11010010b = 11111010b
-01111000b | 11010011b = 11111011b
-01111000b | 11010100b = 11111100b
-01111000b | 11010101b = 11111101b
-01111000b | 11010110b = 11111110b
-01111000b | 11010111b = 11111111b
-01111000b | 11011000b = 11111000b
-01111000b | 11011001b = 11111001b
-01111000b | 11011010b = 11111010b
-01111000b | 11011011b = 11111011b
-01111000b | 11011100b = 11111100b
-01111000b | 11011101b = 11111101b
-01111000b | 11011110b = 11111110b
-01111000b | 11011111b = 11111111b
-01111000b | 11100000b = 11111000b
-01111000b | 11100001b = 11111001b
-01111000b | 11100010b = 11111010b
-01111000b | 11100011b = 11111011b
-01111000b | 11100100b = 11111100b
-01111000b | 11100101b = 11111101b
-01111000b | 11100110b = 11111110b
-01111000b | 11100111b = 11111111b
-01111000b | 11101000b = 11111000b
-01111000b | 11101001b = 11111001b
-01111000b | 11101010b = 11111010b
-01111000b | 11101011b = 11111011b
-01111000b | 11101100b = 11111100b
-01111000b | 11101101b = 11111101b
-01111000b | 11101110b = 11111110b
-01111000b | 11101111b = 11111111b
-01111000b | 11110000b = 11111000b
-01111000b | 11110001b = 11111001b
-01111000b | 11110010b = 11111010b
-01111000b | 11110011b = 11111011b
-01111000b | 11110100b = 11111100b
-01111000b | 11110101b = 11111101b
-01111000b | 11110110b = 11111110b
-01111000b | 11110111b = 11111111b
-01111000b | 11111000b = 11111000b
-01111000b | 11111001b = 11111001b
-01111000b | 11111010b = 11111010b
-01111000b | 11111011b = 11111011b
-01111000b | 11111100b = 11111100b
-01111000b | 11111101b = 11111101b
-01111000b | 11111110b = 11111110b
-01111000b | 11111111b = 11111111b
-01111000b | 00000000b = 01111000b
-01111000b | 00000001b = 01111001b
-01111000b | 00000010b = 01111010b
-01111000b | 00000011b = 01111011b
-01111000b | 00000100b = 01111100b
-01111000b | 00000101b = 01111101b
-01111000b | 00000110b = 01111110b
-01111000b | 00000111b = 01111111b
-01111000b | 00001000b = 01111000b
-01111000b | 00001001b = 01111001b
-01111000b | 00001010b = 01111010b
-01111000b | 00001011b = 01111011b
-01111000b | 00001100b = 01111100b
-01111000b | 00001101b = 01111101b
-01111000b | 00001110b = 01111110b
-01111000b | 00001111b = 01111111b
-01111000b | 00010000b = 01111000b
-01111000b | 00010001b = 01111001b
-01111000b | 00010010b = 01111010b
-01111000b | 00010011b = 01111011b
-01111000b | 00010100b = 01111100b
-01111000b | 00010101b = 01111101b
-01111000b | 00010110b = 01111110b
-01111000b | 00010111b = 01111111b
-01111000b | 00011000b = 01111000b
-01111000b | 00011001b = 01111001b
-01111000b | 00011010b = 01111010b
-01111000b | 00011011b = 01111011b
-01111000b | 00011100b = 01111100b
-01111000b | 00011101b = 01111101b
-01111000b | 00011110b = 01111110b
-01111000b | 00011111b = 01111111b
-01111000b | 00100000b = 01111000b
-01111000b | 00100001b = 01111001b
-01111000b | 00100010b = 01111010b
-01111000b | 00100011b = 01111011b
-01111000b | 00100100b = 01111100b
-01111000b | 00100101b = 01111101b
-01111000b | 00100110b = 01111110b
-01111000b | 00100111b = 01111111b
-01111000b | 00101000b = 01111000b
-01111000b | 00101001b = 01111001b
-01111000b | 00101010b = 01111010b
-01111000b | 00101011b = 01111011b
-01111000b | 00101100b = 01111100b
-01111000b | 00101101b = 01111101b
-01111000b | 00101110b = 01111110b
-01111000b | 00101111b = 01111111b
-01111000b | 00110000b = 01111000b
-01111000b | 00110001b = 01111001b
-01111000b | 00110010b = 01111010b
-01111000b | 00110011b = 01111011b
-01111000b | 00110100b = 01111100b
-01111000b | 00110101b = 01111101b
-01111000b | 00110110b = 01111110b
-01111000b | 00110111b = 01111111b
-01111000b | 00111000b = 01111000b
-01111000b | 00111001b = 01111001b
-01111000b | 00111010b = 01111010b
-01111000b | 00111011b = 01111011b
-01111000b | 00111100b = 01111100b
-01111000b | 00111101b = 01111101b
-01111000b | 00111110b = 01111110b
-01111000b | 00111111b = 01111111b
-01111000b | 01000000b = 01111000b
-01111000b | 01000001b = 01111001b
-01111000b | 01000010b = 01111010b
-01111000b | 01000011b = 01111011b
-01111000b | 01000100b = 01111100b
-01111000b | 01000101b = 01111101b
-01111000b | 01000110b = 01111110b
-01111000b | 01000111b = 01111111b
-01111000b | 01001000b = 01111000b
-01111000b | 01001001b = 01111001b
-01111000b | 01001010b = 01111010b
-01111000b | 01001011b = 01111011b
-01111000b | 01001100b = 01111100b
-01111000b | 01001101b = 01111101b
-01111000b | 01001110b = 01111110b
-01111000b | 01001111b = 01111111b
-01111000b | 01010000b = 01111000b
-01111000b | 01010001b = 01111001b
-01111000b | 01010010b = 01111010b
-01111000b | 01010011b = 01111011b
-01111000b | 01010100b = 01111100b
-01111000b | 01010101b = 01111101b
-01111000b | 01010110b = 01111110b
-01111000b | 01010111b = 01111111b
-01111000b | 01011000b = 01111000b
-01111000b | 01011001b = 01111001b
-01111000b | 01011010b = 01111010b
-01111000b | 01011011b = 01111011b
-01111000b | 01011100b = 01111100b
-01111000b | 01011101b = 01111101b
-01111000b | 01011110b = 01111110b
-01111000b | 01011111b = 01111111b
-01111000b | 01100000b = 01111000b
-01111000b | 01100001b = 01111001b
-01111000b | 01100010b = 01111010b
-01111000b | 01100011b = 01111011b
-01111000b | 01100100b = 01111100b
-01111000b | 01100101b = 01111101b
-01111000b | 01100110b = 01111110b
-01111000b | 01100111b = 01111111b
-01111000b | 01101000b = 01111000b
-01111000b | 01101001b = 01111001b
-01111000b | 01101010b = 01111010b
-01111000b | 01101011b = 01111011b
-01111000b | 01101100b = 01111100b
-01111000b | 01101101b = 01111101b
-01111000b | 01101110b = 01111110b
-01111000b | 01101111b = 01111111b
-01111000b | 01110000b = 01111000b
-01111000b | 01110001b = 01111001b
-01111000b | 01110010b = 01111010b
-01111000b | 01110011b = 01111011b
-01111000b | 01110100b = 01111100b
-01111000b | 01110101b = 01111101b
-01111000b | 01110110b = 01111110b
-01111000b | 01110111b = 01111111b
-01111000b | 01111000b = 01111000b
-01111000b | 01111001b = 01111001b
-01111000b | 01111010b = 01111010b
-01111000b | 01111011b = 01111011b
-01111000b | 01111100b = 01111100b
-01111000b | 01111101b = 01111101b
-01111000b | 01111110b = 01111110b
-01111001b | 10000000b = 11111001b
-01111001b | 10000001b = 11111001b
-01111001b | 10000010b = 11111011b
-01111001b | 10000011b = 11111011b
-01111001b | 10000100b = 11111101b
-01111001b | 10000101b = 11111101b
-01111001b | 10000110b = 11111111b
-01111001b | 10000111b = 11111111b
-01111001b | 10001000b = 11111001b
-01111001b | 10001001b = 11111001b
-01111001b | 10001010b = 11111011b
-01111001b | 10001011b = 11111011b
-01111001b | 10001100b = 11111101b
-01111001b | 10001101b = 11111101b
-01111001b | 10001110b = 11111111b
-01111001b | 10001111b = 11111111b
-01111001b | 10010000b = 11111001b
-01111001b | 10010001b = 11111001b
-01111001b | 10010010b = 11111011b
-01111001b | 10010011b = 11111011b
-01111001b | 10010100b = 11111101b
-01111001b | 10010101b = 11111101b
-01111001b | 10010110b = 11111111b
-01111001b | 10010111b = 11111111b
-01111001b | 10011000b = 11111001b
-01111001b | 10011001b = 11111001b
-01111001b | 10011010b = 11111011b
-01111001b | 10011011b = 11111011b
-01111001b | 10011100b = 11111101b
-01111001b | 10011101b = 11111101b
-01111001b | 10011110b = 11111111b
-01111001b | 10011111b = 11111111b
-01111001b | 10100000b = 11111001b
-01111001b | 10100001b = 11111001b
-01111001b | 10100010b = 11111011b
-01111001b | 10100011b = 11111011b
-01111001b | 10100100b = 11111101b
-01111001b | 10100101b = 11111101b
-01111001b | 10100110b = 11111111b
-01111001b | 10100111b = 11111111b
-01111001b | 10101000b = 11111001b
-01111001b | 10101001b = 11111001b
-01111001b | 10101010b = 11111011b
-01111001b | 10101011b = 11111011b
-01111001b | 10101100b = 11111101b
-01111001b | 10101101b = 11111101b
-01111001b | 10101110b = 11111111b
-01111001b | 10101111b = 11111111b
-01111001b | 10110000b = 11111001b
-01111001b | 10110001b = 11111001b
-01111001b | 10110010b = 11111011b
-01111001b | 10110011b = 11111011b
-01111001b | 10110100b = 11111101b
-01111001b | 10110101b = 11111101b
-01111001b | 10110110b = 11111111b
-01111001b | 10110111b = 11111111b
-01111001b | 10111000b = 11111001b
-01111001b | 10111001b = 11111001b
-01111001b | 10111010b = 11111011b
-01111001b | 10111011b = 11111011b
-01111001b | 10111100b = 11111101b
-01111001b | 10111101b = 11111101b
-01111001b | 10111110b = 11111111b
-01111001b | 10111111b = 11111111b
-01111001b | 11000000b = 11111001b
-01111001b | 11000001b = 11111001b
-01111001b | 11000010b = 11111011b
-01111001b | 11000011b = 11111011b
-01111001b | 11000100b = 11111101b
-01111001b | 11000101b = 11111101b
-01111001b | 11000110b = 11111111b
-01111001b | 11000111b = 11111111b
-01111001b | 11001000b = 11111001b
-01111001b | 11001001b = 11111001b
-01111001b | 11001010b = 11111011b
-01111001b | 11001011b = 11111011b
-01111001b | 11001100b = 11111101b
-01111001b | 11001101b = 11111101b
-01111001b | 11001110b = 11111111b
-01111001b | 11001111b = 11111111b
-01111001b | 11010000b = 11111001b
-01111001b | 11010001b = 11111001b
-01111001b | 11010010b = 11111011b
-01111001b | 11010011b = 11111011b
-01111001b | 11010100b = 11111101b
-01111001b | 11010101b = 11111101b
-01111001b | 11010110b = 11111111b
-01111001b | 11010111b = 11111111b
-01111001b | 11011000b = 11111001b
-01111001b | 11011001b = 11111001b
-01111001b | 11011010b = 11111011b
-01111001b | 11011011b = 11111011b
-01111001b | 11011100b = 11111101b
-01111001b | 11011101b = 11111101b
-01111001b | 11011110b = 11111111b
-01111001b | 11011111b = 11111111b
-01111001b | 11100000b = 11111001b
-01111001b | 11100001b = 11111001b
-01111001b | 11100010b = 11111011b
-01111001b | 11100011b = 11111011b
-01111001b | 11100100b = 11111101b
-01111001b | 11100101b = 11111101b
-01111001b | 11100110b = 11111111b
-01111001b | 11100111b = 11111111b
-01111001b | 11101000b = 11111001b
-01111001b | 11101001b = 11111001b
-01111001b | 11101010b = 11111011b
-01111001b | 11101011b = 11111011b
-01111001b | 11101100b = 11111101b
-01111001b | 11101101b = 11111101b
-01111001b | 11101110b = 11111111b
-01111001b | 11101111b = 11111111b
-01111001b | 11110000b = 11111001b
-01111001b | 11110001b = 11111001b
-01111001b | 11110010b = 11111011b
-01111001b | 11110011b = 11111011b
-01111001b | 11110100b = 11111101b
-01111001b | 11110101b = 11111101b
-01111001b | 11110110b = 11111111b
-01111001b | 11110111b = 11111111b
-01111001b | 11111000b = 11111001b
-01111001b | 11111001b = 11111001b
-01111001b | 11111010b = 11111011b
-01111001b | 11111011b = 11111011b
-01111001b | 11111100b = 11111101b
-01111001b | 11111101b = 11111101b
-01111001b | 11111110b = 11111111b
-01111001b | 11111111b = 11111111b
-01111001b | 00000000b = 01111001b
-01111001b | 00000001b = 01111001b
-01111001b | 00000010b = 01111011b
-01111001b | 00000011b = 01111011b
-01111001b | 00000100b = 01111101b
-01111001b | 00000101b = 01111101b
-01111001b | 00000110b = 01111111b
-01111001b | 00000111b = 01111111b
-01111001b | 00001000b = 01111001b
-01111001b | 00001001b = 01111001b
-01111001b | 00001010b = 01111011b
-01111001b | 00001011b = 01111011b
-01111001b | 00001100b = 01111101b
-01111001b | 00001101b = 01111101b
-01111001b | 00001110b = 01111111b
-01111001b | 00001111b = 01111111b
-01111001b | 00010000b = 01111001b
-01111001b | 00010001b = 01111001b
-01111001b | 00010010b = 01111011b
-01111001b | 00010011b = 01111011b
-01111001b | 00010100b = 01111101b
-01111001b | 00010101b = 01111101b
-01111001b | 00010110b = 01111111b
-01111001b | 00010111b = 01111111b
-01111001b | 00011000b = 01111001b
-01111001b | 00011001b = 01111001b
-01111001b | 00011010b = 01111011b
-01111001b | 00011011b = 01111011b
-01111001b | 00011100b = 01111101b
-01111001b | 00011101b = 01111101b
-01111001b | 00011110b = 01111111b
-01111001b | 00011111b = 01111111b
-01111001b | 00100000b = 01111001b
-01111001b | 00100001b = 01111001b
-01111001b | 00100010b = 01111011b
-01111001b | 00100011b = 01111011b
-01111001b | 00100100b = 01111101b
-01111001b | 00100101b = 01111101b
-01111001b | 00100110b = 01111111b
-01111001b | 00100111b = 01111111b
-01111001b | 00101000b = 01111001b
-01111001b | 00101001b = 01111001b
-01111001b | 00101010b = 01111011b
-01111001b | 00101011b = 01111011b
-01111001b | 00101100b = 01111101b
-01111001b | 00101101b = 01111101b
-01111001b | 00101110b = 01111111b
-01111001b | 00101111b = 01111111b
-01111001b | 00110000b = 01111001b
-01111001b | 00110001b = 01111001b
-01111001b | 00110010b = 01111011b
-01111001b | 00110011b = 01111011b
-01111001b | 00110100b = 01111101b
-01111001b | 00110101b = 01111101b
-01111001b | 00110110b = 01111111b
-01111001b | 00110111b = 01111111b
-01111001b | 00111000b = 01111001b
-01111001b | 00111001b = 01111001b
-01111001b | 00111010b = 01111011b
-01111001b | 00111011b = 01111011b
-01111001b | 00111100b = 01111101b
-01111001b | 00111101b = 01111101b
-01111001b | 00111110b = 01111111b
-01111001b | 00111111b = 01111111b
-01111001b | 01000000b = 01111001b
-01111001b | 01000001b = 01111001b
-01111001b | 01000010b = 01111011b
-01111001b | 01000011b = 01111011b
-01111001b | 01000100b = 01111101b
-01111001b | 01000101b = 01111101b
-01111001b | 01000110b = 01111111b
-01111001b | 01000111b = 01111111b
-01111001b | 01001000b = 01111001b
-01111001b | 01001001b = 01111001b
-01111001b | 01001010b = 01111011b
-01111001b | 01001011b = 01111011b
-01111001b | 01001100b = 01111101b
-01111001b | 01001101b = 01111101b
-01111001b | 01001110b = 01111111b
-01111001b | 01001111b = 01111111b
-01111001b | 01010000b = 01111001b
-01111001b | 01010001b = 01111001b
-01111001b | 01010010b = 01111011b
-01111001b | 01010011b = 01111011b
-01111001b | 01010100b = 01111101b
-01111001b | 01010101b = 01111101b
-01111001b | 01010110b = 01111111b
-01111001b | 01010111b = 01111111b
-01111001b | 01011000b = 01111001b
-01111001b | 01011001b = 01111001b
-01111001b | 01011010b = 01111011b
-01111001b | 01011011b = 01111011b
-01111001b | 01011100b = 01111101b
-01111001b | 01011101b = 01111101b
-01111001b | 01011110b = 01111111b
-01111001b | 01011111b = 01111111b
-01111001b | 01100000b = 01111001b
-01111001b | 01100001b = 01111001b
-01111001b | 01100010b = 01111011b
-01111001b | 01100011b = 01111011b
-01111001b | 01100100b = 01111101b
-01111001b | 01100101b = 01111101b
-01111001b | 01100110b = 01111111b
-01111001b | 01100111b = 01111111b
-01111001b | 01101000b = 01111001b
-01111001b | 01101001b = 01111001b
-01111001b | 01101010b = 01111011b
-01111001b | 01101011b = 01111011b
-01111001b | 01101100b = 01111101b
-01111001b | 01101101b = 01111101b
-01111001b | 01101110b = 01111111b
-01111001b | 01101111b = 01111111b
-01111001b | 01110000b = 01111001b
-01111001b | 01110001b = 01111001b
-01111001b | 01110010b = 01111011b
-01111001b | 01110011b = 01111011b
-01111001b | 01110100b = 01111101b
-01111001b | 01110101b = 01111101b
-01111001b | 01110110b = 01111111b
-01111001b | 01110111b = 01111111b
-01111001b | 01111000b = 01111001b
-01111001b | 01111001b = 01111001b
-01111001b | 01111010b = 01111011b
-01111001b | 01111011b = 01111011b
-01111001b | 01111100b = 01111101b
-01111001b | 01111101b = 01111101b
-01111001b | 01111110b = 01111111b
-01111010b | 10000000b = 11111010b
-01111010b | 10000001b = 11111011b
-01111010b | 10000010b = 11111010b
-01111010b | 10000011b = 11111011b
-01111010b | 10000100b = 11111110b
-01111010b | 10000101b = 11111111b
-01111010b | 10000110b = 11111110b
-01111010b | 10000111b = 11111111b
-01111010b | 10001000b = 11111010b
-01111010b | 10001001b = 11111011b
-01111010b | 10001010b = 11111010b
-01111010b | 10001011b = 11111011b
-01111010b | 10001100b = 11111110b
-01111010b | 10001101b = 11111111b
-01111010b | 10001110b = 11111110b
-01111010b | 10001111b = 11111111b
-01111010b | 10010000b = 11111010b
-01111010b | 10010001b = 11111011b
-01111010b | 10010010b = 11111010b
-01111010b | 10010011b = 11111011b
-01111010b | 10010100b = 11111110b
-01111010b | 10010101b = 11111111b
-01111010b | 10010110b = 11111110b
-01111010b | 10010111b = 11111111b
-01111010b | 10011000b = 11111010b
-01111010b | 10011001b = 11111011b
-01111010b | 10011010b = 11111010b
-01111010b | 10011011b = 11111011b
-01111010b | 10011100b = 11111110b
-01111010b | 10011101b = 11111111b
-01111010b | 10011110b = 11111110b
-01111010b | 10011111b = 11111111b
-01111010b | 10100000b = 11111010b
-01111010b | 10100001b = 11111011b
-01111010b | 10100010b = 11111010b
-01111010b | 10100011b = 11111011b
-01111010b | 10100100b = 11111110b
-01111010b | 10100101b = 11111111b
-01111010b | 10100110b = 11111110b
-01111010b | 10100111b = 11111111b
-01111010b | 10101000b = 11111010b
-01111010b | 10101001b = 11111011b
-01111010b | 10101010b = 11111010b
-01111010b | 10101011b = 11111011b
-01111010b | 10101100b = 11111110b
-01111010b | 10101101b = 11111111b
-01111010b | 10101110b = 11111110b
-01111010b | 10101111b = 11111111b
-01111010b | 10110000b = 11111010b
-01111010b | 10110001b = 11111011b
-01111010b | 10110010b = 11111010b
-01111010b | 10110011b = 11111011b
-01111010b | 10110100b = 11111110b
-01111010b | 10110101b = 11111111b
-01111010b | 10110110b = 11111110b
-01111010b | 10110111b = 11111111b
-01111010b | 10111000b = 11111010b
-01111010b | 10111001b = 11111011b
-01111010b | 10111010b = 11111010b
-01111010b | 10111011b = 11111011b
-01111010b | 10111100b = 11111110b
-01111010b | 10111101b = 11111111b
-01111010b | 10111110b = 11111110b
-01111010b | 10111111b = 11111111b
-01111010b | 11000000b = 11111010b
-01111010b | 11000001b = 11111011b
-01111010b | 11000010b = 11111010b
-01111010b | 11000011b = 11111011b
-01111010b | 11000100b = 11111110b
-01111010b | 11000101b = 11111111b
-01111010b | 11000110b = 11111110b
-01111010b | 11000111b = 11111111b
-01111010b | 11001000b = 11111010b
-01111010b | 11001001b = 11111011b
-01111010b | 11001010b = 11111010b
-01111010b | 11001011b = 11111011b
-01111010b | 11001100b = 11111110b
-01111010b | 11001101b = 11111111b
-01111010b | 11001110b = 11111110b
-01111010b | 11001111b = 11111111b
-01111010b | 11010000b = 11111010b
-01111010b | 11010001b = 11111011b
-01111010b | 11010010b = 11111010b
-01111010b | 11010011b = 11111011b
-01111010b | 11010100b = 11111110b
-01111010b | 11010101b = 11111111b
-01111010b | 11010110b = 11111110b
-01111010b | 11010111b = 11111111b
-01111010b | 11011000b = 11111010b
-01111010b | 11011001b = 11111011b
-01111010b | 11011010b = 11111010b
-01111010b | 11011011b = 11111011b
-01111010b | 11011100b = 11111110b
-01111010b | 11011101b = 11111111b
-01111010b | 11011110b = 11111110b
-01111010b | 11011111b = 11111111b
-01111010b | 11100000b = 11111010b
-01111010b | 11100001b = 11111011b
-01111010b | 11100010b = 11111010b
-01111010b | 11100011b = 11111011b
-01111010b | 11100100b = 11111110b
-01111010b | 11100101b = 11111111b
-01111010b | 11100110b = 11111110b
-01111010b | 11100111b = 11111111b
-01111010b | 11101000b = 11111010b
-01111010b | 11101001b = 11111011b
-01111010b | 11101010b = 11111010b
-01111010b | 11101011b = 11111011b
-01111010b | 11101100b = 11111110b
-01111010b | 11101101b = 11111111b
-01111010b | 11101110b = 11111110b
-01111010b | 11101111b = 11111111b
-01111010b | 11110000b = 11111010b
-01111010b | 11110001b = 11111011b
-01111010b | 11110010b = 11111010b
-01111010b | 11110011b = 11111011b
-01111010b | 11110100b = 11111110b
-01111010b | 11110101b = 11111111b
-01111010b | 11110110b = 11111110b
-01111010b | 11110111b = 11111111b
-01111010b | 11111000b = 11111010b
-01111010b | 11111001b = 11111011b
-01111010b | 11111010b = 11111010b
-01111010b | 11111011b = 11111011b
-01111010b | 11111100b = 11111110b
-01111010b | 11111101b = 11111111b
-01111010b | 11111110b = 11111110b
-01111010b | 11111111b = 11111111b
-01111010b | 00000000b = 01111010b
-01111010b | 00000001b = 01111011b
-01111010b | 00000010b = 01111010b
-01111010b | 00000011b = 01111011b
-01111010b | 00000100b = 01111110b
-01111010b | 00000101b = 01111111b
-01111010b | 00000110b = 01111110b
-01111010b | 00000111b = 01111111b
-01111010b | 00001000b = 01111010b
-01111010b | 00001001b = 01111011b
-01111010b | 00001010b = 01111010b
-01111010b | 00001011b = 01111011b
-01111010b | 00001100b = 01111110b
-01111010b | 00001101b = 01111111b
-01111010b | 00001110b = 01111110b
-01111010b | 00001111b = 01111111b
-01111010b | 00010000b = 01111010b
-01111010b | 00010001b = 01111011b
-01111010b | 00010010b = 01111010b
-01111010b | 00010011b = 01111011b
-01111010b | 00010100b = 01111110b
-01111010b | 00010101b = 01111111b
-01111010b | 00010110b = 01111110b
-01111010b | 00010111b = 01111111b
-01111010b | 00011000b = 01111010b
-01111010b | 00011001b = 01111011b
-01111010b | 00011010b = 01111010b
-01111010b | 00011011b = 01111011b
-01111010b | 00011100b = 01111110b
-01111010b | 00011101b = 01111111b
-01111010b | 00011110b = 01111110b
-01111010b | 00011111b = 01111111b
-01111010b | 00100000b = 01111010b
-01111010b | 00100001b = 01111011b
-01111010b | 00100010b = 01111010b
-01111010b | 00100011b = 01111011b
-01111010b | 00100100b = 01111110b
-01111010b | 00100101b = 01111111b
-01111010b | 00100110b = 01111110b
-01111010b | 00100111b = 01111111b
-01111010b | 00101000b = 01111010b
-01111010b | 00101001b = 01111011b
-01111010b | 00101010b = 01111010b
-01111010b | 00101011b = 01111011b
-01111010b | 00101100b = 01111110b
-01111010b | 00101101b = 01111111b
-01111010b | 00101110b = 01111110b
-01111010b | 00101111b = 01111111b
-01111010b | 00110000b = 01111010b
-01111010b | 00110001b = 01111011b
-01111010b | 00110010b = 01111010b
-01111010b | 00110011b = 01111011b
-01111010b | 00110100b = 01111110b
-01111010b | 00110101b = 01111111b
-01111010b | 00110110b = 01111110b
-01111010b | 00110111b = 01111111b
-01111010b | 00111000b = 01111010b
-01111010b | 00111001b = 01111011b
-01111010b | 00111010b = 01111010b
-01111010b | 00111011b = 01111011b
-01111010b | 00111100b = 01111110b
-01111010b | 00111101b = 01111111b
-01111010b | 00111110b = 01111110b
-01111010b | 00111111b = 01111111b
-01111010b | 01000000b = 01111010b
-01111010b | 01000001b = 01111011b
-01111010b | 01000010b = 01111010b
-01111010b | 01000011b = 01111011b
-01111010b | 01000100b = 01111110b
-01111010b | 01000101b = 01111111b
-01111010b | 01000110b = 01111110b
-01111010b | 01000111b = 01111111b
-01111010b | 01001000b = 01111010b
-01111010b | 01001001b = 01111011b
-01111010b | 01001010b = 01111010b
-01111010b | 01001011b = 01111011b
-01111010b | 01001100b = 01111110b
-01111010b | 01001101b = 01111111b
-01111010b | 01001110b = 01111110b
-01111010b | 01001111b = 01111111b
-01111010b | 01010000b = 01111010b
-01111010b | 01010001b = 01111011b
-01111010b | 01010010b = 01111010b
-01111010b | 01010011b = 01111011b
-01111010b | 01010100b = 01111110b
-01111010b | 01010101b = 01111111b
-01111010b | 01010110b = 01111110b
-01111010b | 01010111b = 01111111b
-01111010b | 01011000b = 01111010b
-01111010b | 01011001b = 01111011b
-01111010b | 01011010b = 01111010b
-01111010b | 01011011b = 01111011b
-01111010b | 01011100b = 01111110b
-01111010b | 01011101b = 01111111b
-01111010b | 01011110b = 01111110b
-01111010b | 01011111b = 01111111b
-01111010b | 01100000b = 01111010b
-01111010b | 01100001b = 01111011b
-01111010b | 01100010b = 01111010b
-01111010b | 01100011b = 01111011b
-01111010b | 01100100b = 01111110b
-01111010b | 01100101b = 01111111b
-01111010b | 01100110b = 01111110b
-01111010b | 01100111b = 01111111b
-01111010b | 01101000b = 01111010b
-01111010b | 01101001b = 01111011b
-01111010b | 01101010b = 01111010b
-01111010b | 01101011b = 01111011b
-01111010b | 01101100b = 01111110b
-01111010b | 01101101b = 01111111b
-01111010b | 01101110b = 01111110b
-01111010b | 01101111b = 01111111b
-01111010b | 01110000b = 01111010b
-01111010b | 01110001b = 01111011b
-01111010b | 01110010b = 01111010b
-01111010b | 01110011b = 01111011b
-01111010b | 01110100b = 01111110b
-01111010b | 01110101b = 01111111b
-01111010b | 01110110b = 01111110b
-01111010b | 01110111b = 01111111b
-01111010b | 01111000b = 01111010b
-01111010b | 01111001b = 01111011b
-01111010b | 01111010b = 01111010b
-01111010b | 01111011b = 01111011b
-01111010b | 01111100b = 01111110b
-01111010b | 01111101b = 01111111b
-01111010b | 01111110b = 01111110b
-01111011b | 10000000b = 11111011b
-01111011b | 10000001b = 11111011b
-01111011b | 10000010b = 11111011b
-01111011b | 10000011b = 11111011b
-01111011b | 10000100b = 11111111b
-01111011b | 10000101b = 11111111b
-01111011b | 10000110b = 11111111b
-01111011b | 10000111b = 11111111b
-01111011b | 10001000b = 11111011b
-01111011b | 10001001b = 11111011b
-01111011b | 10001010b = 11111011b
-01111011b | 10001011b = 11111011b
-01111011b | 10001100b = 11111111b
-01111011b | 10001101b = 11111111b
-01111011b | 10001110b = 11111111b
-01111011b | 10001111b = 11111111b
-01111011b | 10010000b = 11111011b
-01111011b | 10010001b = 11111011b
-01111011b | 10010010b = 11111011b
-01111011b | 10010011b = 11111011b
-01111011b | 10010100b = 11111111b
-01111011b | 10010101b = 11111111b
-01111011b | 10010110b = 11111111b
-01111011b | 10010111b = 11111111b
-01111011b | 10011000b = 11111011b
-01111011b | 10011001b = 11111011b
-01111011b | 10011010b = 11111011b
-01111011b | 10011011b = 11111011b
-01111011b | 10011100b = 11111111b
-01111011b | 10011101b = 11111111b
-01111011b | 10011110b = 11111111b
-01111011b | 10011111b = 11111111b
-01111011b | 10100000b = 11111011b
-01111011b | 10100001b = 11111011b
-01111011b | 10100010b = 11111011b
-01111011b | 10100011b = 11111011b
-01111011b | 10100100b = 11111111b
-01111011b | 10100101b = 11111111b
-01111011b | 10100110b = 11111111b
-01111011b | 10100111b = 11111111b
-01111011b | 10101000b = 11111011b
-01111011b | 10101001b = 11111011b
-01111011b | 10101010b = 11111011b
-01111011b | 10101011b = 11111011b
-01111011b | 10101100b = 11111111b
-01111011b | 10101101b = 11111111b
-01111011b | 10101110b = 11111111b
-01111011b | 10101111b = 11111111b
-01111011b | 10110000b = 11111011b
-01111011b | 10110001b = 11111011b
-01111011b | 10110010b = 11111011b
-01111011b | 10110011b = 11111011b
-01111011b | 10110100b = 11111111b
-01111011b | 10110101b = 11111111b
-01111011b | 10110110b = 11111111b
-01111011b | 10110111b = 11111111b
-01111011b | 10111000b = 11111011b
-01111011b | 10111001b = 11111011b
-01111011b | 10111010b = 11111011b
-01111011b | 10111011b = 11111011b
-01111011b | 10111100b = 11111111b
-01111011b | 10111101b = 11111111b
-01111011b | 10111110b = 11111111b
-01111011b | 10111111b = 11111111b
-01111011b | 11000000b = 11111011b
-01111011b | 11000001b = 11111011b
-01111011b | 11000010b = 11111011b
-01111011b | 11000011b = 11111011b
-01111011b | 11000100b = 11111111b
-01111011b | 11000101b = 11111111b
-01111011b | 11000110b = 11111111b
-01111011b | 11000111b = 11111111b
-01111011b | 11001000b = 11111011b
-01111011b | 11001001b = 11111011b
-01111011b | 11001010b = 11111011b
-01111011b | 11001011b = 11111011b
-01111011b | 11001100b = 11111111b
-01111011b | 11001101b = 11111111b
-01111011b | 11001110b = 11111111b
-01111011b | 11001111b = 11111111b
-01111011b | 11010000b = 11111011b
-01111011b | 11010001b = 11111011b
-01111011b | 11010010b = 11111011b
-01111011b | 11010011b = 11111011b
-01111011b | 11010100b = 11111111b
-01111011b | 11010101b = 11111111b
-01111011b | 11010110b = 11111111b
-01111011b | 11010111b = 11111111b
-01111011b | 11011000b = 11111011b
-01111011b | 11011001b = 11111011b
-01111011b | 11011010b = 11111011b
-01111011b | 11011011b = 11111011b
-01111011b | 11011100b = 11111111b
-01111011b | 11011101b = 11111111b
-01111011b | 11011110b = 11111111b
-01111011b | 11011111b = 11111111b
-01111011b | 11100000b = 11111011b
-01111011b | 11100001b = 11111011b
-01111011b | 11100010b = 11111011b
-01111011b | 11100011b = 11111011b
-01111011b | 11100100b = 11111111b
-01111011b | 11100101b = 11111111b
-01111011b | 11100110b = 11111111b
-01111011b | 11100111b = 11111111b
-01111011b | 11101000b = 11111011b
-01111011b | 11101001b = 11111011b
-01111011b | 11101010b = 11111011b
-01111011b | 11101011b = 11111011b
-01111011b | 11101100b = 11111111b
-01111011b | 11101101b = 11111111b
-01111011b | 11101110b = 11111111b
-01111011b | 11101111b = 11111111b
-01111011b | 11110000b = 11111011b
-01111011b | 11110001b = 11111011b
-01111011b | 11110010b = 11111011b
-01111011b | 11110011b = 11111011b
-01111011b | 11110100b = 11111111b
-01111011b | 11110101b = 11111111b
-01111011b | 11110110b = 11111111b
-01111011b | 11110111b = 11111111b
-01111011b | 11111000b = 11111011b
-01111011b | 11111001b = 11111011b
-01111011b | 11111010b = 11111011b
-01111011b | 11111011b = 11111011b
-01111011b | 11111100b = 11111111b
-01111011b | 11111101b = 11111111b
-01111011b | 11111110b = 11111111b
-01111011b | 11111111b = 11111111b
-01111011b | 00000000b = 01111011b
-01111011b | 00000001b = 01111011b
-01111011b | 00000010b = 01111011b
-01111011b | 00000011b = 01111011b
-01111011b | 00000100b = 01111111b
-01111011b | 00000101b = 01111111b
-01111011b | 00000110b = 01111111b
-01111011b | 00000111b = 01111111b
-01111011b | 00001000b = 01111011b
-01111011b | 00001001b = 01111011b
-01111011b | 00001010b = 01111011b
-01111011b | 00001011b = 01111011b
-01111011b | 00001100b = 01111111b
-01111011b | 00001101b = 01111111b
-01111011b | 00001110b = 01111111b
-01111011b | 00001111b = 01111111b
-01111011b | 00010000b = 01111011b
-01111011b | 00010001b = 01111011b
-01111011b | 00010010b = 01111011b
-01111011b | 00010011b = 01111011b
-01111011b | 00010100b = 01111111b
-01111011b | 00010101b = 01111111b
-01111011b | 00010110b = 01111111b
-01111011b | 00010111b = 01111111b
-01111011b | 00011000b = 01111011b
-01111011b | 00011001b = 01111011b
-01111011b | 00011010b = 01111011b
-01111011b | 00011011b = 01111011b
-01111011b | 00011100b = 01111111b
-01111011b | 00011101b = 01111111b
-01111011b | 00011110b = 01111111b
-01111011b | 00011111b = 01111111b
-01111011b | 00100000b = 01111011b
-01111011b | 00100001b = 01111011b
-01111011b | 00100010b = 01111011b
-01111011b | 00100011b = 01111011b
-01111011b | 00100100b = 01111111b
-01111011b | 00100101b = 01111111b
-01111011b | 00100110b = 01111111b
-01111011b | 00100111b = 01111111b
-01111011b | 00101000b = 01111011b
-01111011b | 00101001b = 01111011b
-01111011b | 00101010b = 01111011b
-01111011b | 00101011b = 01111011b
-01111011b | 00101100b = 01111111b
-01111011b | 00101101b = 01111111b
-01111011b | 00101110b = 01111111b
-01111011b | 00101111b = 01111111b
-01111011b | 00110000b = 01111011b
-01111011b | 00110001b = 01111011b
-01111011b | 00110010b = 01111011b
-01111011b | 00110011b = 01111011b
-01111011b | 00110100b = 01111111b
-01111011b | 00110101b = 01111111b
-01111011b | 00110110b = 01111111b
-01111011b | 00110111b = 01111111b
-01111011b | 00111000b = 01111011b
-01111011b | 00111001b = 01111011b
-01111011b | 00111010b = 01111011b
-01111011b | 00111011b = 01111011b
-01111011b | 00111100b = 01111111b
-01111011b | 00111101b = 01111111b
-01111011b | 00111110b = 01111111b
-01111011b | 00111111b = 01111111b
-01111011b | 01000000b = 01111011b
-01111011b | 01000001b = 01111011b
-01111011b | 01000010b = 01111011b
-01111011b | 01000011b = 01111011b
-01111011b | 01000100b = 01111111b
-01111011b | 01000101b = 01111111b
-01111011b | 01000110b = 01111111b
-01111011b | 01000111b = 01111111b
-01111011b | 01001000b = 01111011b
-01111011b | 01001001b = 01111011b
-01111011b | 01001010b = 01111011b
-01111011b | 01001011b = 01111011b
-01111011b | 01001100b = 01111111b
-01111011b | 01001101b = 01111111b
-01111011b | 01001110b = 01111111b
-01111011b | 01001111b = 01111111b
-01111011b | 01010000b = 01111011b
-01111011b | 01010001b = 01111011b
-01111011b | 01010010b = 01111011b
-01111011b | 01010011b = 01111011b
-01111011b | 01010100b = 01111111b
-01111011b | 01010101b = 01111111b
-01111011b | 01010110b = 01111111b
-01111011b | 01010111b = 01111111b
-01111011b | 01011000b = 01111011b
-01111011b | 01011001b = 01111011b
-01111011b | 01011010b = 01111011b
-01111011b | 01011011b = 01111011b
-01111011b | 01011100b = 01111111b
-01111011b | 01011101b = 01111111b
-01111011b | 01011110b = 01111111b
-01111011b | 01011111b = 01111111b
-01111011b | 01100000b = 01111011b
-01111011b | 01100001b = 01111011b
-01111011b | 01100010b = 01111011b
-01111011b | 01100011b = 01111011b
-01111011b | 01100100b = 01111111b
-01111011b | 01100101b = 01111111b
-01111011b | 01100110b = 01111111b
-01111011b | 01100111b = 01111111b
-01111011b | 01101000b = 01111011b
-01111011b | 01101001b = 01111011b
-01111011b | 01101010b = 01111011b
-01111011b | 01101011b = 01111011b
-01111011b | 01101100b = 01111111b
-01111011b | 01101101b = 01111111b
-01111011b | 01101110b = 01111111b
-01111011b | 01101111b = 01111111b
-01111011b | 01110000b = 01111011b
-01111011b | 01110001b = 01111011b
-01111011b | 01110010b = 01111011b
-01111011b | 01110011b = 01111011b
-01111011b | 01110100b = 01111111b
-01111011b | 01110101b = 01111111b
-01111011b | 01110110b = 01111111b
-01111011b | 01110111b = 01111111b
-01111011b | 01111000b = 01111011b
-01111011b | 01111001b = 01111011b
-01111011b | 01111010b = 01111011b
-01111011b | 01111011b = 01111011b
-01111011b | 01111100b = 01111111b
-01111011b | 01111101b = 01111111b
-01111011b | 01111110b = 01111111b
-01111100b | 10000000b = 11111100b
-01111100b | 10000001b = 11111101b
-01111100b | 10000010b = 11111110b
-01111100b | 10000011b = 11111111b
-01111100b | 10000100b = 11111100b
-01111100b | 10000101b = 11111101b
-01111100b | 10000110b = 11111110b
-01111100b | 10000111b = 11111111b
-01111100b | 10001000b = 11111100b
-01111100b | 10001001b = 11111101b
-01111100b | 10001010b = 11111110b
-01111100b | 10001011b = 11111111b
-01111100b | 10001100b = 11111100b
-01111100b | 10001101b = 11111101b
-01111100b | 10001110b = 11111110b
-01111100b | 10001111b = 11111111b
-01111100b | 10010000b = 11111100b
-01111100b | 10010001b = 11111101b
-01111100b | 10010010b = 11111110b
-01111100b | 10010011b = 11111111b
-01111100b | 10010100b = 11111100b
-01111100b | 10010101b = 11111101b
-01111100b | 10010110b = 11111110b
-01111100b | 10010111b = 11111111b
-01111100b | 10011000b = 11111100b
-01111100b | 10011001b = 11111101b
-01111100b | 10011010b = 11111110b
-01111100b | 10011011b = 11111111b
-01111100b | 10011100b = 11111100b
-01111100b | 10011101b = 11111101b
-01111100b | 10011110b = 11111110b
-01111100b | 10011111b = 11111111b
-01111100b | 10100000b = 11111100b
-01111100b | 10100001b = 11111101b
-01111100b | 10100010b = 11111110b
-01111100b | 10100011b = 11111111b
-01111100b | 10100100b = 11111100b
-01111100b | 10100101b = 11111101b
-01111100b | 10100110b = 11111110b
-01111100b | 10100111b = 11111111b
-01111100b | 10101000b = 11111100b
-01111100b | 10101001b = 11111101b
-01111100b | 10101010b = 11111110b
-01111100b | 10101011b = 11111111b
-01111100b | 10101100b = 11111100b
-01111100b | 10101101b = 11111101b
-01111100b | 10101110b = 11111110b
-01111100b | 10101111b = 11111111b
-01111100b | 10110000b = 11111100b
-01111100b | 10110001b = 11111101b
-01111100b | 10110010b = 11111110b
-01111100b | 10110011b = 11111111b
-01111100b | 10110100b = 11111100b
-01111100b | 10110101b = 11111101b
-01111100b | 10110110b = 11111110b
-01111100b | 10110111b = 11111111b
-01111100b | 10111000b = 11111100b
-01111100b | 10111001b = 11111101b
-01111100b | 10111010b = 11111110b
-01111100b | 10111011b = 11111111b
-01111100b | 10111100b = 11111100b
-01111100b | 10111101b = 11111101b
-01111100b | 10111110b = 11111110b
-01111100b | 10111111b = 11111111b
-01111100b | 11000000b = 11111100b
-01111100b | 11000001b = 11111101b
-01111100b | 11000010b = 11111110b
-01111100b | 11000011b = 11111111b
-01111100b | 11000100b = 11111100b
-01111100b | 11000101b = 11111101b
-01111100b | 11000110b = 11111110b
-01111100b | 11000111b = 11111111b
-01111100b | 11001000b = 11111100b
-01111100b | 11001001b = 11111101b
-01111100b | 11001010b = 11111110b
-01111100b | 11001011b = 11111111b
-01111100b | 11001100b = 11111100b
-01111100b | 11001101b = 11111101b
-01111100b | 11001110b = 11111110b
-01111100b | 11001111b = 11111111b
-01111100b | 11010000b = 11111100b
-01111100b | 11010001b = 11111101b
-01111100b | 11010010b = 11111110b
-01111100b | 11010011b = 11111111b
-01111100b | 11010100b = 11111100b
-01111100b | 11010101b = 11111101b
-01111100b | 11010110b = 11111110b
-01111100b | 11010111b = 11111111b
-01111100b | 11011000b = 11111100b
-01111100b | 11011001b = 11111101b
-01111100b | 11011010b = 11111110b
-01111100b | 11011011b = 11111111b
-01111100b | 11011100b = 11111100b
-01111100b | 11011101b = 11111101b
-01111100b | 11011110b = 11111110b
-01111100b | 11011111b = 11111111b
-01111100b | 11100000b = 11111100b
-01111100b | 11100001b = 11111101b
-01111100b | 11100010b = 11111110b
-01111100b | 11100011b = 11111111b
-01111100b | 11100100b = 11111100b
-01111100b | 11100101b = 11111101b
-01111100b | 11100110b = 11111110b
-01111100b | 11100111b = 11111111b
-01111100b | 11101000b = 11111100b
-01111100b | 11101001b = 11111101b
-01111100b | 11101010b = 11111110b
-01111100b | 11101011b = 11111111b
-01111100b | 11101100b = 11111100b
-01111100b | 11101101b = 11111101b
-01111100b | 11101110b = 11111110b
-01111100b | 11101111b = 11111111b
-01111100b | 11110000b = 11111100b
-01111100b | 11110001b = 11111101b
-01111100b | 11110010b = 11111110b
-01111100b | 11110011b = 11111111b
-01111100b | 11110100b = 11111100b
-01111100b | 11110101b = 11111101b
-01111100b | 11110110b = 11111110b
-01111100b | 11110111b = 11111111b
-01111100b | 11111000b = 11111100b
-01111100b | 11111001b = 11111101b
-01111100b | 11111010b = 11111110b
-01111100b | 11111011b = 11111111b
-01111100b | 11111100b = 11111100b
-01111100b | 11111101b = 11111101b
-01111100b | 11111110b = 11111110b
-01111100b | 11111111b = 11111111b
-01111100b | 00000000b = 01111100b
-01111100b | 00000001b = 01111101b
-01111100b | 00000010b = 01111110b
-01111100b | 00000011b = 01111111b
-01111100b | 00000100b = 01111100b
-01111100b | 00000101b = 01111101b
-01111100b | 00000110b = 01111110b
-01111100b | 00000111b = 01111111b
-01111100b | 00001000b = 01111100b
-01111100b | 00001001b = 01111101b
-01111100b | 00001010b = 01111110b
-01111100b | 00001011b = 01111111b
-01111100b | 00001100b = 01111100b
-01111100b | 00001101b = 01111101b
-01111100b | 00001110b = 01111110b
-01111100b | 00001111b = 01111111b
-01111100b | 00010000b = 01111100b
-01111100b | 00010001b = 01111101b
-01111100b | 00010010b = 01111110b
-01111100b | 00010011b = 01111111b
-01111100b | 00010100b = 01111100b
-01111100b | 00010101b = 01111101b
-01111100b | 00010110b = 01111110b
-01111100b | 00010111b = 01111111b
-01111100b | 00011000b = 01111100b
-01111100b | 00011001b = 01111101b
-01111100b | 00011010b = 01111110b
-01111100b | 00011011b = 01111111b
-01111100b | 00011100b = 01111100b
-01111100b | 00011101b = 01111101b
-01111100b | 00011110b = 01111110b
-01111100b | 00011111b = 01111111b
-01111100b | 00100000b = 01111100b
-01111100b | 00100001b = 01111101b
-01111100b | 00100010b = 01111110b
-01111100b | 00100011b = 01111111b
-01111100b | 00100100b = 01111100b
-01111100b | 00100101b = 01111101b
-01111100b | 00100110b = 01111110b
-01111100b | 00100111b = 01111111b
-01111100b | 00101000b = 01111100b
-01111100b | 00101001b = 01111101b
-01111100b | 00101010b = 01111110b
-01111100b | 00101011b = 01111111b
-01111100b | 00101100b = 01111100b
-01111100b | 00101101b = 01111101b
-01111100b | 00101110b = 01111110b
-01111100b | 00101111b = 01111111b
-01111100b | 00110000b = 01111100b
-01111100b | 00110001b = 01111101b
-01111100b | 00110010b = 01111110b
-01111100b | 00110011b = 01111111b
-01111100b | 00110100b = 01111100b
-01111100b | 00110101b = 01111101b
-01111100b | 00110110b = 01111110b
-01111100b | 00110111b = 01111111b
-01111100b | 00111000b = 01111100b
-01111100b | 00111001b = 01111101b
-01111100b | 00111010b = 01111110b
-01111100b | 00111011b = 01111111b
-01111100b | 00111100b = 01111100b
-01111100b | 00111101b = 01111101b
-01111100b | 00111110b = 01111110b
-01111100b | 00111111b = 01111111b
-01111100b | 01000000b = 01111100b
-01111100b | 01000001b = 01111101b
-01111100b | 01000010b = 01111110b
-01111100b | 01000011b = 01111111b
-01111100b | 01000100b = 01111100b
-01111100b | 01000101b = 01111101b
-01111100b | 01000110b = 01111110b
-01111100b | 01000111b = 01111111b
-01111100b | 01001000b = 01111100b
-01111100b | 01001001b = 01111101b
-01111100b | 01001010b = 01111110b
-01111100b | 01001011b = 01111111b
-01111100b | 01001100b = 01111100b
-01111100b | 01001101b = 01111101b
-01111100b | 01001110b = 01111110b
-01111100b | 01001111b = 01111111b
-01111100b | 01010000b = 01111100b
-01111100b | 01010001b = 01111101b
-01111100b | 01010010b = 01111110b
-01111100b | 01010011b = 01111111b
-01111100b | 01010100b = 01111100b
-01111100b | 01010101b = 01111101b
-01111100b | 01010110b = 01111110b
-01111100b | 01010111b = 01111111b
-01111100b | 01011000b = 01111100b
-01111100b | 01011001b = 01111101b
-01111100b | 01011010b = 01111110b
-01111100b | 01011011b = 01111111b
-01111100b | 01011100b = 01111100b
-01111100b | 01011101b = 01111101b
-01111100b | 01011110b = 01111110b
-01111100b | 01011111b = 01111111b
-01111100b | 01100000b = 01111100b
-01111100b | 01100001b = 01111101b
-01111100b | 01100010b = 01111110b
-01111100b | 01100011b = 01111111b
-01111100b | 01100100b = 01111100b
-01111100b | 01100101b = 01111101b
-01111100b | 01100110b = 01111110b
-01111100b | 01100111b = 01111111b
-01111100b | 01101000b = 01111100b
-01111100b | 01101001b = 01111101b
-01111100b | 01101010b = 01111110b
-01111100b | 01101011b = 01111111b
-01111100b | 01101100b = 01111100b
-01111100b | 01101101b = 01111101b
-01111100b | 01101110b = 01111110b
-01111100b | 01101111b = 01111111b
-01111100b | 01110000b = 01111100b
-01111100b | 01110001b = 01111101b
-01111100b | 01110010b = 01111110b
-01111100b | 01110011b = 01111111b
-01111100b | 01110100b = 01111100b
-01111100b | 01110101b = 01111101b
-01111100b | 01110110b = 01111110b
-01111100b | 01110111b = 01111111b
-01111100b | 01111000b = 01111100b
-01111100b | 01111001b = 01111101b
-01111100b | 01111010b = 01111110b
-01111100b | 01111011b = 01111111b
-01111100b | 01111100b = 01111100b
-01111100b | 01111101b = 01111101b
-01111100b | 01111110b = 01111110b
-01111101b | 10000000b = 11111101b
-01111101b | 10000001b = 11111101b
-01111101b | 10000010b = 11111111b
-01111101b | 10000011b = 11111111b
-01111101b | 10000100b = 11111101b
-01111101b | 10000101b = 11111101b
-01111101b | 10000110b = 11111111b
-01111101b | 10000111b = 11111111b
-01111101b | 10001000b = 11111101b
-01111101b | 10001001b = 11111101b
-01111101b | 10001010b = 11111111b
-01111101b | 10001011b = 11111111b
-01111101b | 10001100b = 11111101b
-01111101b | 10001101b = 11111101b
-01111101b | 10001110b = 11111111b
-01111101b | 10001111b = 11111111b
-01111101b | 10010000b = 11111101b
-01111101b | 10010001b = 11111101b
-01111101b | 10010010b = 11111111b
-01111101b | 10010011b = 11111111b
-01111101b | 10010100b = 11111101b
-01111101b | 10010101b = 11111101b
-01111101b | 10010110b = 11111111b
-01111101b | 10010111b = 11111111b
-01111101b | 10011000b = 11111101b
-01111101b | 10011001b = 11111101b
-01111101b | 10011010b = 11111111b
-01111101b | 10011011b = 11111111b
-01111101b | 10011100b = 11111101b
-01111101b | 10011101b = 11111101b
-01111101b | 10011110b = 11111111b
-01111101b | 10011111b = 11111111b
-01111101b | 10100000b = 11111101b
-01111101b | 10100001b = 11111101b
-01111101b | 10100010b = 11111111b
-01111101b | 10100011b = 11111111b
-01111101b | 10100100b = 11111101b
-01111101b | 10100101b = 11111101b
-01111101b | 10100110b = 11111111b
-01111101b | 10100111b = 11111111b
-01111101b | 10101000b = 11111101b
-01111101b | 10101001b = 11111101b
-01111101b | 10101010b = 11111111b
-01111101b | 10101011b = 11111111b
-01111101b | 10101100b = 11111101b
-01111101b | 10101101b = 11111101b
-01111101b | 10101110b = 11111111b
-01111101b | 10101111b = 11111111b
-01111101b | 10110000b = 11111101b
-01111101b | 10110001b = 11111101b
-01111101b | 10110010b = 11111111b
-01111101b | 10110011b = 11111111b
-01111101b | 10110100b = 11111101b
-01111101b | 10110101b = 11111101b
-01111101b | 10110110b = 11111111b
-01111101b | 10110111b = 11111111b
-01111101b | 10111000b = 11111101b
-01111101b | 10111001b = 11111101b
-01111101b | 10111010b = 11111111b
-01111101b | 10111011b = 11111111b
-01111101b | 10111100b = 11111101b
-01111101b | 10111101b = 11111101b
-01111101b | 10111110b = 11111111b
-01111101b | 10111111b = 11111111b
-01111101b | 11000000b = 11111101b
-01111101b | 11000001b = 11111101b
-01111101b | 11000010b = 11111111b
-01111101b | 11000011b = 11111111b
-01111101b | 11000100b = 11111101b
-01111101b | 11000101b = 11111101b
-01111101b | 11000110b = 11111111b
-01111101b | 11000111b = 11111111b
-01111101b | 11001000b = 11111101b
-01111101b | 11001001b = 11111101b
-01111101b | 11001010b = 11111111b
-01111101b | 11001011b = 11111111b
-01111101b | 11001100b = 11111101b
-01111101b | 11001101b = 11111101b
-01111101b | 11001110b = 11111111b
-01111101b | 11001111b = 11111111b
-01111101b | 11010000b = 11111101b
-01111101b | 11010001b = 11111101b
-01111101b | 11010010b = 11111111b
-01111101b | 11010011b = 11111111b
-01111101b | 11010100b = 11111101b
-01111101b | 11010101b = 11111101b
-01111101b | 11010110b = 11111111b
-01111101b | 11010111b = 11111111b
-01111101b | 11011000b = 11111101b
-01111101b | 11011001b = 11111101b
-01111101b | 11011010b = 11111111b
-01111101b | 11011011b = 11111111b
-01111101b | 11011100b = 11111101b
-01111101b | 11011101b = 11111101b
-01111101b | 11011110b = 11111111b
-01111101b | 11011111b = 11111111b
-01111101b | 11100000b = 11111101b
-01111101b | 11100001b = 11111101b
-01111101b | 11100010b = 11111111b
-01111101b | 11100011b = 11111111b
-01111101b | 11100100b = 11111101b
-01111101b | 11100101b = 11111101b
-01111101b | 11100110b = 11111111b
-01111101b | 11100111b = 11111111b
-01111101b | 11101000b = 11111101b
-01111101b | 11101001b = 11111101b
-01111101b | 11101010b = 11111111b
-01111101b | 11101011b = 11111111b
-01111101b | 11101100b = 11111101b
-01111101b | 11101101b = 11111101b
-01111101b | 11101110b = 11111111b
-01111101b | 11101111b = 11111111b
-01111101b | 11110000b = 11111101b
-01111101b | 11110001b = 11111101b
-01111101b | 11110010b = 11111111b
-01111101b | 11110011b = 11111111b
-01111101b | 11110100b = 11111101b
-01111101b | 11110101b = 11111101b
-01111101b | 11110110b = 11111111b
-01111101b | 11110111b = 11111111b
-01111101b | 11111000b = 11111101b
-01111101b | 11111001b = 11111101b
-01111101b | 11111010b = 11111111b
-01111101b | 11111011b = 11111111b
-01111101b | 11111100b = 11111101b
-01111101b | 11111101b = 11111101b
-01111101b | 11111110b = 11111111b
-01111101b | 11111111b = 11111111b
-01111101b | 00000000b = 01111101b
-01111101b | 00000001b = 01111101b
-01111101b | 00000010b = 01111111b
-01111101b | 00000011b = 01111111b
-01111101b | 00000100b = 01111101b
-01111101b | 00000101b = 01111101b
-01111101b | 00000110b = 01111111b
-01111101b | 00000111b = 01111111b
-01111101b | 00001000b = 01111101b
-01111101b | 00001001b = 01111101b
-01111101b | 00001010b = 01111111b
-01111101b | 00001011b = 01111111b
-01111101b | 00001100b = 01111101b
-01111101b | 00001101b = 01111101b
-01111101b | 00001110b = 01111111b
-01111101b | 00001111b = 01111111b
-01111101b | 00010000b = 01111101b
-01111101b | 00010001b = 01111101b
-01111101b | 00010010b = 01111111b
-01111101b | 00010011b = 01111111b
-01111101b | 00010100b = 01111101b
-01111101b | 00010101b = 01111101b
-01111101b | 00010110b = 01111111b
-01111101b | 00010111b = 01111111b
-01111101b | 00011000b = 01111101b
-01111101b | 00011001b = 01111101b
-01111101b | 00011010b = 01111111b
-01111101b | 00011011b = 01111111b
-01111101b | 00011100b = 01111101b
-01111101b | 00011101b = 01111101b
-01111101b | 00011110b = 01111111b
-01111101b | 00011111b = 01111111b
-01111101b | 00100000b = 01111101b
-01111101b | 00100001b = 01111101b
-01111101b | 00100010b = 01111111b
-01111101b | 00100011b = 01111111b
-01111101b | 00100100b = 01111101b
-01111101b | 00100101b = 01111101b
-01111101b | 00100110b = 01111111b
-01111101b | 00100111b = 01111111b
-01111101b | 00101000b = 01111101b
-01111101b | 00101001b = 01111101b
-01111101b | 00101010b = 01111111b
-01111101b | 00101011b = 01111111b
-01111101b | 00101100b = 01111101b
-01111101b | 00101101b = 01111101b
-01111101b | 00101110b = 01111111b
-01111101b | 00101111b = 01111111b
-01111101b | 00110000b = 01111101b
-01111101b | 00110001b = 01111101b
-01111101b | 00110010b = 01111111b
-01111101b | 00110011b = 01111111b
-01111101b | 00110100b = 01111101b
-01111101b | 00110101b = 01111101b
-01111101b | 00110110b = 01111111b
-01111101b | 00110111b = 01111111b
-01111101b | 00111000b = 01111101b
-01111101b | 00111001b = 01111101b
-01111101b | 00111010b = 01111111b
-01111101b | 00111011b = 01111111b
-01111101b | 00111100b = 01111101b
-01111101b | 00111101b = 01111101b
-01111101b | 00111110b = 01111111b
-01111101b | 00111111b = 01111111b
-01111101b | 01000000b = 01111101b
-01111101b | 01000001b = 01111101b
-01111101b | 01000010b = 01111111b
-01111101b | 01000011b = 01111111b
-01111101b | 01000100b = 01111101b
-01111101b | 01000101b = 01111101b
-01111101b | 01000110b = 01111111b
-01111101b | 01000111b = 01111111b
-01111101b | 01001000b = 01111101b
-01111101b | 01001001b = 01111101b
-01111101b | 01001010b = 01111111b
-01111101b | 01001011b = 01111111b
-01111101b | 01001100b = 01111101b
-01111101b | 01001101b = 01111101b
-01111101b | 01001110b = 01111111b
-01111101b | 01001111b = 01111111b
-01111101b | 01010000b = 01111101b
-01111101b | 01010001b = 01111101b
-01111101b | 01010010b = 01111111b
-01111101b | 01010011b = 01111111b
-01111101b | 01010100b = 01111101b
-01111101b | 01010101b = 01111101b
-01111101b | 01010110b = 01111111b
-01111101b | 01010111b = 01111111b
-01111101b | 01011000b = 01111101b
-01111101b | 01011001b = 01111101b
-01111101b | 01011010b = 01111111b
-01111101b | 01011011b = 01111111b
-01111101b | 01011100b = 01111101b
-01111101b | 01011101b = 01111101b
-01111101b | 01011110b = 01111111b
-01111101b | 01011111b = 01111111b
-01111101b | 01100000b = 01111101b
-01111101b | 01100001b = 01111101b
-01111101b | 01100010b = 01111111b
-01111101b | 01100011b = 01111111b
-01111101b | 01100100b = 01111101b
-01111101b | 01100101b = 01111101b
-01111101b | 01100110b = 01111111b
-01111101b | 01100111b = 01111111b
-01111101b | 01101000b = 01111101b
-01111101b | 01101001b = 01111101b
-01111101b | 01101010b = 01111111b
-01111101b | 01101011b = 01111111b
-01111101b | 01101100b = 01111101b
-01111101b | 01101101b = 01111101b
-01111101b | 01101110b = 01111111b
-01111101b | 01101111b = 01111111b
-01111101b | 01110000b = 01111101b
-01111101b | 01110001b = 01111101b
-01111101b | 01110010b = 01111111b
-01111101b | 01110011b = 01111111b
-01111101b | 01110100b = 01111101b
-01111101b | 01110101b = 01111101b
-01111101b | 01110110b = 01111111b
-01111101b | 01110111b = 01111111b
-01111101b | 01111000b = 01111101b
-01111101b | 01111001b = 01111101b
-01111101b | 01111010b = 01111111b
-01111101b | 01111011b = 01111111b
-01111101b | 01111100b = 01111101b
-01111101b | 01111101b = 01111101b
-01111101b | 01111110b = 01111111b
-01111110b | 10000000b = 11111110b
-01111110b | 10000001b = 11111111b
-01111110b | 10000010b = 11111110b
-01111110b | 10000011b = 11111111b
-01111110b | 10000100b = 11111110b
-01111110b | 10000101b = 11111111b
-01111110b | 10000110b = 11111110b
-01111110b | 10000111b = 11111111b
-01111110b | 10001000b = 11111110b
-01111110b | 10001001b = 11111111b
-01111110b | 10001010b = 11111110b
-01111110b | 10001011b = 11111111b
-01111110b | 10001100b = 11111110b
-01111110b | 10001101b = 11111111b
-01111110b | 10001110b = 11111110b
-01111110b | 10001111b = 11111111b
-01111110b | 10010000b = 11111110b
-01111110b | 10010001b = 11111111b
-01111110b | 10010010b = 11111110b
-01111110b | 10010011b = 11111111b
-01111110b | 10010100b = 11111110b
-01111110b | 10010101b = 11111111b
-01111110b | 10010110b = 11111110b
-01111110b | 10010111b = 11111111b
-01111110b | 10011000b = 11111110b
-01111110b | 10011001b = 11111111b
-01111110b | 10011010b = 11111110b
-01111110b | 10011011b = 11111111b
-01111110b | 10011100b = 11111110b
-01111110b | 10011101b = 11111111b
-01111110b | 10011110b = 11111110b
-01111110b | 10011111b = 11111111b
-01111110b | 10100000b = 11111110b
-01111110b | 10100001b = 11111111b
-01111110b | 10100010b = 11111110b
-01111110b | 10100011b = 11111111b
-01111110b | 10100100b = 11111110b
-01111110b | 10100101b = 11111111b
-01111110b | 10100110b = 11111110b
-01111110b | 10100111b = 11111111b
-01111110b | 10101000b = 11111110b
-01111110b | 10101001b = 11111111b
-01111110b | 10101010b = 11111110b
-01111110b | 10101011b = 11111111b
-01111110b | 10101100b = 11111110b
-01111110b | 10101101b = 11111111b
-01111110b | 10101110b = 11111110b
-01111110b | 10101111b = 11111111b
-01111110b | 10110000b = 11111110b
-01111110b | 10110001b = 11111111b
-01111110b | 10110010b = 11111110b
-01111110b | 10110011b = 11111111b
-01111110b | 10110100b = 11111110b
-01111110b | 10110101b = 11111111b
-01111110b | 10110110b = 11111110b
-01111110b | 10110111b = 11111111b
-01111110b | 10111000b = 11111110b
-01111110b | 10111001b = 11111111b
-01111110b | 10111010b = 11111110b
-01111110b | 10111011b = 11111111b
-01111110b | 10111100b = 11111110b
-01111110b | 10111101b = 11111111b
-01111110b | 10111110b = 11111110b
-01111110b | 10111111b = 11111111b
-01111110b | 11000000b = 11111110b
-01111110b | 11000001b = 11111111b
-01111110b | 11000010b = 11111110b
-01111110b | 11000011b = 11111111b
-01111110b | 11000100b = 11111110b
-01111110b | 11000101b = 11111111b
-01111110b | 11000110b = 11111110b
-01111110b | 11000111b = 11111111b
-01111110b | 11001000b = 11111110b
-01111110b | 11001001b = 11111111b
-01111110b | 11001010b = 11111110b
-01111110b | 11001011b = 11111111b
-01111110b | 11001100b = 11111110b
-01111110b | 11001101b = 11111111b
-01111110b | 11001110b = 11111110b
-01111110b | 11001111b = 11111111b
-01111110b | 11010000b = 11111110b
-01111110b | 11010001b = 11111111b
-01111110b | 11010010b = 11111110b
-01111110b | 11010011b = 11111111b
-01111110b | 11010100b = 11111110b
-01111110b | 11010101b = 11111111b
-01111110b | 11010110b = 11111110b
-01111110b | 11010111b = 11111111b
-01111110b | 11011000b = 11111110b
-01111110b | 11011001b = 11111111b
-01111110b | 11011010b = 11111110b
-01111110b | 11011011b = 11111111b
-01111110b | 11011100b = 11111110b
-01111110b | 11011101b = 11111111b
-01111110b | 11011110b = 11111110b
-01111110b | 11011111b = 11111111b
-01111110b | 11100000b = 11111110b
-01111110b | 11100001b = 11111111b
-01111110b | 11100010b = 11111110b
-01111110b | 11100011b = 11111111b
-01111110b | 11100100b = 11111110b
-01111110b | 11100101b = 11111111b
-01111110b | 11100110b = 11111110b
-01111110b | 11100111b = 11111111b
-01111110b | 11101000b = 11111110b
-01111110b | 11101001b = 11111111b
-01111110b | 11101010b = 11111110b
-01111110b | 11101011b = 11111111b
-01111110b | 11101100b = 11111110b
-01111110b | 11101101b = 11111111b
-01111110b | 11101110b = 11111110b
-01111110b | 11101111b = 11111111b
-01111110b | 11110000b = 11111110b
-01111110b | 11110001b = 11111111b
-01111110b | 11110010b = 11111110b
-01111110b | 11110011b = 11111111b
-01111110b | 11110100b = 11111110b
-01111110b | 11110101b = 11111111b
-01111110b | 11110110b = 11111110b
-01111110b | 11110111b = 11111111b
-01111110b | 11111000b = 11111110b
-01111110b | 11111001b = 11111111b
-01111110b | 11111010b = 11111110b
-01111110b | 11111011b = 11111111b
-01111110b | 11111100b = 11111110b
-01111110b | 11111101b = 11111111b
-01111110b | 11111110b = 11111110b
-01111110b | 11111111b = 11111111b
-01111110b | 00000000b = 01111110b
-01111110b | 00000001b = 01111111b
-01111110b | 00000010b = 01111110b
-01111110b | 00000011b = 01111111b
-01111110b | 00000100b = 01111110b
-01111110b | 00000101b = 01111111b
-01111110b | 00000110b = 01111110b
-01111110b | 00000111b = 01111111b
-01111110b | 00001000b = 01111110b
-01111110b | 00001001b = 01111111b
-01111110b | 00001010b = 01111110b
-01111110b | 00001011b = 01111111b
-01111110b | 00001100b = 01111110b
-01111110b | 00001101b = 01111111b
-01111110b | 00001110b = 01111110b
-01111110b | 00001111b = 01111111b
-01111110b | 00010000b = 01111110b
-01111110b | 00010001b = 01111111b
-01111110b | 00010010b = 01111110b
-01111110b | 00010011b = 01111111b
-01111110b | 00010100b = 01111110b
-01111110b | 00010101b = 01111111b
-01111110b | 00010110b = 01111110b
-01111110b | 00010111b = 01111111b
-01111110b | 00011000b = 01111110b
-01111110b | 00011001b = 01111111b
-01111110b | 00011010b = 01111110b
-01111110b | 00011011b = 01111111b
-01111110b | 00011100b = 01111110b
-01111110b | 00011101b = 01111111b
-01111110b | 00011110b = 01111110b
-01111110b | 00011111b = 01111111b
-01111110b | 00100000b = 01111110b
-01111110b | 00100001b = 01111111b
-01111110b | 00100010b = 01111110b
-01111110b | 00100011b = 01111111b
-01111110b | 00100100b = 01111110b
-01111110b | 00100101b = 01111111b
-01111110b | 00100110b = 01111110b
-01111110b | 00100111b = 01111111b
-01111110b | 00101000b = 01111110b
-01111110b | 00101001b = 01111111b
-01111110b | 00101010b = 01111110b
-01111110b | 00101011b = 01111111b
-01111110b | 00101100b = 01111110b
-01111110b | 00101101b = 01111111b
-01111110b | 00101110b = 01111110b
-01111110b | 00101111b = 01111111b
-01111110b | 00110000b = 01111110b
-01111110b | 00110001b = 01111111b
-01111110b | 00110010b = 01111110b
-01111110b | 00110011b = 01111111b
-01111110b | 00110100b = 01111110b
-01111110b | 00110101b = 01111111b
-01111110b | 00110110b = 01111110b
-01111110b | 00110111b = 01111111b
-01111110b | 00111000b = 01111110b
-01111110b | 00111001b = 01111111b
-01111110b | 00111010b = 01111110b
-01111110b | 00111011b = 01111111b
-01111110b | 00111100b = 01111110b
-01111110b | 00111101b = 01111111b
-01111110b | 00111110b = 01111110b
-01111110b | 00111111b = 01111111b
-01111110b | 01000000b = 01111110b
-01111110b | 01000001b = 01111111b
-01111110b | 01000010b = 01111110b
-01111110b | 01000011b = 01111111b
-01111110b | 01000100b = 01111110b
-01111110b | 01000101b = 01111111b
-01111110b | 01000110b = 01111110b
-01111110b | 01000111b = 01111111b
-01111110b | 01001000b = 01111110b
-01111110b | 01001001b = 01111111b
-01111110b | 01001010b = 01111110b
-01111110b | 01001011b = 01111111b
-01111110b | 01001100b = 01111110b
-01111110b | 01001101b = 01111111b
-01111110b | 01001110b = 01111110b
-01111110b | 01001111b = 01111111b
-01111110b | 01010000b = 01111110b
-01111110b | 01010001b = 01111111b
-01111110b | 01010010b = 01111110b
-01111110b | 01010011b = 01111111b
-01111110b | 01010100b = 01111110b
-01111110b | 01010101b = 01111111b
-01111110b | 01010110b = 01111110b
-01111110b | 01010111b = 01111111b
-01111110b | 01011000b = 01111110b
-01111110b | 01011001b = 01111111b
-01111110b | 01011010b = 01111110b
-01111110b | 01011011b = 01111111b
-01111110b | 01011100b = 01111110b
-01111110b | 01011101b = 01111111b
-01111110b | 01011110b = 01111110b
-01111110b | 01011111b = 01111111b
-01111110b | 01100000b = 01111110b
-01111110b | 01100001b = 01111111b
-01111110b | 01100010b = 01111110b
-01111110b | 01100011b = 01111111b
-01111110b | 01100100b = 01111110b
-01111110b | 01100101b = 01111111b
-01111110b | 01100110b = 01111110b
-01111110b | 01100111b = 01111111b
-01111110b | 01101000b = 01111110b
-01111110b | 01101001b = 01111111b
-01111110b | 01101010b = 01111110b
-01111110b | 01101011b = 01111111b
-01111110b | 01101100b = 01111110b
-01111110b | 01101101b = 01111111b
-01111110b | 01101110b = 01111110b
-01111110b | 01101111b = 01111111b
-01111110b | 01110000b = 01111110b
-01111110b | 01110001b = 01111111b
-01111110b | 01110010b = 01111110b
-01111110b | 01110011b = 01111111b
-01111110b | 01110100b = 01111110b
-01111110b | 01110101b = 01111111b
-01111110b | 01110110b = 01111110b
-01111110b | 01110111b = 01111111b
-01111110b | 01111000b = 01111110b
-01111110b | 01111001b = 01111111b
-01111110b | 01111010b = 01111110b
-01111110b | 01111011b = 01111111b
-01111110b | 01111100b = 01111110b
-01111110b | 01111101b = 01111111b
-01111110b | 01111110b = 01111110b
diff --git a/tests/valid/Byte_Valid_3.whiley b/tests/valid/Byte_Valid_3.whiley
index 315ea566e4..b081c81c68 100644
--- a/tests/valid/Byte_Valid_3.whiley
+++ b/tests/valid/Byte_Valid_3.whiley
@@ -1,11 +1,31 @@
-import whiley.lang.*
-import print from whiley.lang.*
+
constant constants is [10000000b, 10000001b, 10000010b, 10000011b, 10000100b, 10000101b, 10000110b, 10000111b, 10001000b, 10001001b, 10001010b, 10001011b, 10001100b, 10001101b, 10001110b, 10001111b, 10010000b, 10010001b, 10010010b, 10010011b, 10010100b, 10010101b, 10010110b, 10010111b, 10011000b, 10011001b, 10011010b, 10011011b, 10011100b, 10011101b, 10011110b, 10011111b, 10100000b, 10100001b, 10100010b, 10100011b, 10100100b, 10100101b, 10100110b, 10100111b, 10101000b, 10101001b, 10101010b, 10101011b, 10101100b, 10101101b, 10101110b, 10101111b, 10110000b, 10110001b, 10110010b, 10110011b, 10110100b, 10110101b, 10110110b, 10110111b, 10111000b, 10111001b, 10111010b, 10111011b, 10111100b, 10111101b, 10111110b, 10111111b, 11000000b, 11000001b, 11000010b, 11000011b, 11000100b, 11000101b, 11000110b, 11000111b, 11001000b, 11001001b, 11001010b, 11001011b, 11001100b, 11001101b, 11001110b, 11001111b, 11010000b, 11010001b, 11010010b, 11010011b, 11010100b, 11010101b, 11010110b, 11010111b, 11011000b, 11011001b, 11011010b, 11011011b, 11011100b, 11011101b, 11011110b, 11011111b, 11100000b, 11100001b, 11100010b, 11100011b, 11100100b, 11100101b, 11100110b, 11100111b, 11101000b, 11101001b, 11101010b, 11101011b, 11101100b, 11101101b, 11101110b, 11101111b, 11110000b, 11110001b, 11110010b, 11110011b, 11110100b, 11110101b, 11110110b, 11110111b, 11111000b, 11111001b, 11111010b, 11111011b, 11111100b, 11111101b, 11111110b, 11111111b, 00000000b, 00000001b, 00000010b, 00000011b, 00000100b, 00000101b, 00000110b, 00000111b, 00001000b, 00001001b, 00001010b, 00001011b, 00001100b, 00001101b, 00001110b, 00001111b, 00010000b, 00010001b, 00010010b, 00010011b, 00010100b, 00010101b, 00010110b, 00010111b, 00011000b, 00011001b, 00011010b, 00011011b, 00011100b, 00011101b, 00011110b, 00011111b, 00100000b, 00100001b, 00100010b, 00100011b, 00100100b, 00100101b, 00100110b, 00100111b, 00101000b, 00101001b, 00101010b, 00101011b, 00101100b, 00101101b, 00101110b, 00101111b, 00110000b, 00110001b, 00110010b, 00110011b, 00110100b, 00110101b, 00110110b, 00110111b, 00111000b, 00111001b, 00111010b, 00111011b, 00111100b, 00111101b, 00111110b, 00111111b, 01000000b, 01000001b, 01000010b, 01000011b, 01000100b, 01000101b, 01000110b, 01000111b, 01001000b, 01001001b, 01001010b, 01001011b, 01001100b, 01001101b, 01001110b, 01001111b, 01010000b, 01010001b, 01010010b, 01010011b, 01010100b, 01010101b, 01010110b, 01010111b, 01011000b, 01011001b, 01011010b, 01011011b, 01011100b, 01011101b, 01011110b, 01011111b, 01100000b, 01100001b, 01100010b, 01100011b, 01100100b, 01100101b, 01100110b, 01100111b, 01101000b, 01101001b, 01101010b, 01101011b, 01101100b, 01101101b, 01101110b, 01101111b, 01110000b, 01110001b, 01110010b, 01110011b, 01110100b, 01110101b, 01110110b, 01110111b, 01111000b, 01111001b, 01111010b, 01111011b, 01111100b, 01111101b, 01111110b]
-public method main(System.Console sys) -> void:
- for i in constants:
- for j in constants:
- sys.out.print_s(Any.toString(i) ++ " | ")
- sys.out.print_s(Any.toString(j) ++ " = ")
- sys.out.println_s(Any.toString(i | j))
+function set(byte b, int i) -> bool:
+ byte mask = 1b << i
+ return (b&mask) == mask
+
+function or(byte b1, byte b2) -> byte:
+ byte mask = 1b
+ byte r = 0b
+ int i = 0
+ while i < 8:
+ if set(b1,i) || set(b2,i):
+ r = r | mask
+ mask = mask << 1
+ i = i + 1
+ //
+ return r
+
+public export method test() -> void:
+ int i = 0
+ while i < |constants|:
+ byte constant_i = constants[i]
+ int j = 0
+ while j < |constants|:
+ byte constant_j = constants[j]
+ assume (constant_i | constant_j) == or(constant_i,constant_j)
+ j = j + 1
+ //
+ i = i + 1
diff --git a/tests/valid/Byte_Valid_4.sysout b/tests/valid/Byte_Valid_4.sysout
deleted file mode 100644
index 50045bd701..0000000000
--- a/tests/valid/Byte_Valid_4.sysout
+++ /dev/null
@@ -1,65025 +0,0 @@
-10000000b ^ 10000000b = 00000000b
-10000000b ^ 10000001b = 00000001b
-10000000b ^ 10000010b = 00000010b
-10000000b ^ 10000011b = 00000011b
-10000000b ^ 10000100b = 00000100b
-10000000b ^ 10000101b = 00000101b
-10000000b ^ 10000110b = 00000110b
-10000000b ^ 10000111b = 00000111b
-10000000b ^ 10001000b = 00001000b
-10000000b ^ 10001001b = 00001001b
-10000000b ^ 10001010b = 00001010b
-10000000b ^ 10001011b = 00001011b
-10000000b ^ 10001100b = 00001100b
-10000000b ^ 10001101b = 00001101b
-10000000b ^ 10001110b = 00001110b
-10000000b ^ 10001111b = 00001111b
-10000000b ^ 10010000b = 00010000b
-10000000b ^ 10010001b = 00010001b
-10000000b ^ 10010010b = 00010010b
-10000000b ^ 10010011b = 00010011b
-10000000b ^ 10010100b = 00010100b
-10000000b ^ 10010101b = 00010101b
-10000000b ^ 10010110b = 00010110b
-10000000b ^ 10010111b = 00010111b
-10000000b ^ 10011000b = 00011000b
-10000000b ^ 10011001b = 00011001b
-10000000b ^ 10011010b = 00011010b
-10000000b ^ 10011011b = 00011011b
-10000000b ^ 10011100b = 00011100b
-10000000b ^ 10011101b = 00011101b
-10000000b ^ 10011110b = 00011110b
-10000000b ^ 10011111b = 00011111b
-10000000b ^ 10100000b = 00100000b
-10000000b ^ 10100001b = 00100001b
-10000000b ^ 10100010b = 00100010b
-10000000b ^ 10100011b = 00100011b
-10000000b ^ 10100100b = 00100100b
-10000000b ^ 10100101b = 00100101b
-10000000b ^ 10100110b = 00100110b
-10000000b ^ 10100111b = 00100111b
-10000000b ^ 10101000b = 00101000b
-10000000b ^ 10101001b = 00101001b
-10000000b ^ 10101010b = 00101010b
-10000000b ^ 10101011b = 00101011b
-10000000b ^ 10101100b = 00101100b
-10000000b ^ 10101101b = 00101101b
-10000000b ^ 10101110b = 00101110b
-10000000b ^ 10101111b = 00101111b
-10000000b ^ 10110000b = 00110000b
-10000000b ^ 10110001b = 00110001b
-10000000b ^ 10110010b = 00110010b
-10000000b ^ 10110011b = 00110011b
-10000000b ^ 10110100b = 00110100b
-10000000b ^ 10110101b = 00110101b
-10000000b ^ 10110110b = 00110110b
-10000000b ^ 10110111b = 00110111b
-10000000b ^ 10111000b = 00111000b
-10000000b ^ 10111001b = 00111001b
-10000000b ^ 10111010b = 00111010b
-10000000b ^ 10111011b = 00111011b
-10000000b ^ 10111100b = 00111100b
-10000000b ^ 10111101b = 00111101b
-10000000b ^ 10111110b = 00111110b
-10000000b ^ 10111111b = 00111111b
-10000000b ^ 11000000b = 01000000b
-10000000b ^ 11000001b = 01000001b
-10000000b ^ 11000010b = 01000010b
-10000000b ^ 11000011b = 01000011b
-10000000b ^ 11000100b = 01000100b
-10000000b ^ 11000101b = 01000101b
-10000000b ^ 11000110b = 01000110b
-10000000b ^ 11000111b = 01000111b
-10000000b ^ 11001000b = 01001000b
-10000000b ^ 11001001b = 01001001b
-10000000b ^ 11001010b = 01001010b
-10000000b ^ 11001011b = 01001011b
-10000000b ^ 11001100b = 01001100b
-10000000b ^ 11001101b = 01001101b
-10000000b ^ 11001110b = 01001110b
-10000000b ^ 11001111b = 01001111b
-10000000b ^ 11010000b = 01010000b
-10000000b ^ 11010001b = 01010001b
-10000000b ^ 11010010b = 01010010b
-10000000b ^ 11010011b = 01010011b
-10000000b ^ 11010100b = 01010100b
-10000000b ^ 11010101b = 01010101b
-10000000b ^ 11010110b = 01010110b
-10000000b ^ 11010111b = 01010111b
-10000000b ^ 11011000b = 01011000b
-10000000b ^ 11011001b = 01011001b
-10000000b ^ 11011010b = 01011010b
-10000000b ^ 11011011b = 01011011b
-10000000b ^ 11011100b = 01011100b
-10000000b ^ 11011101b = 01011101b
-10000000b ^ 11011110b = 01011110b
-10000000b ^ 11011111b = 01011111b
-10000000b ^ 11100000b = 01100000b
-10000000b ^ 11100001b = 01100001b
-10000000b ^ 11100010b = 01100010b
-10000000b ^ 11100011b = 01100011b
-10000000b ^ 11100100b = 01100100b
-10000000b ^ 11100101b = 01100101b
-10000000b ^ 11100110b = 01100110b
-10000000b ^ 11100111b = 01100111b
-10000000b ^ 11101000b = 01101000b
-10000000b ^ 11101001b = 01101001b
-10000000b ^ 11101010b = 01101010b
-10000000b ^ 11101011b = 01101011b
-10000000b ^ 11101100b = 01101100b
-10000000b ^ 11101101b = 01101101b
-10000000b ^ 11101110b = 01101110b
-10000000b ^ 11101111b = 01101111b
-10000000b ^ 11110000b = 01110000b
-10000000b ^ 11110001b = 01110001b
-10000000b ^ 11110010b = 01110010b
-10000000b ^ 11110011b = 01110011b
-10000000b ^ 11110100b = 01110100b
-10000000b ^ 11110101b = 01110101b
-10000000b ^ 11110110b = 01110110b
-10000000b ^ 11110111b = 01110111b
-10000000b ^ 11111000b = 01111000b
-10000000b ^ 11111001b = 01111001b
-10000000b ^ 11111010b = 01111010b
-10000000b ^ 11111011b = 01111011b
-10000000b ^ 11111100b = 01111100b
-10000000b ^ 11111101b = 01111101b
-10000000b ^ 11111110b = 01111110b
-10000000b ^ 11111111b = 01111111b
-10000000b ^ 00000000b = 10000000b
-10000000b ^ 00000001b = 10000001b
-10000000b ^ 00000010b = 10000010b
-10000000b ^ 00000011b = 10000011b
-10000000b ^ 00000100b = 10000100b
-10000000b ^ 00000101b = 10000101b
-10000000b ^ 00000110b = 10000110b
-10000000b ^ 00000111b = 10000111b
-10000000b ^ 00001000b = 10001000b
-10000000b ^ 00001001b = 10001001b
-10000000b ^ 00001010b = 10001010b
-10000000b ^ 00001011b = 10001011b
-10000000b ^ 00001100b = 10001100b
-10000000b ^ 00001101b = 10001101b
-10000000b ^ 00001110b = 10001110b
-10000000b ^ 00001111b = 10001111b
-10000000b ^ 00010000b = 10010000b
-10000000b ^ 00010001b = 10010001b
-10000000b ^ 00010010b = 10010010b
-10000000b ^ 00010011b = 10010011b
-10000000b ^ 00010100b = 10010100b
-10000000b ^ 00010101b = 10010101b
-10000000b ^ 00010110b = 10010110b
-10000000b ^ 00010111b = 10010111b
-10000000b ^ 00011000b = 10011000b
-10000000b ^ 00011001b = 10011001b
-10000000b ^ 00011010b = 10011010b
-10000000b ^ 00011011b = 10011011b
-10000000b ^ 00011100b = 10011100b
-10000000b ^ 00011101b = 10011101b
-10000000b ^ 00011110b = 10011110b
-10000000b ^ 00011111b = 10011111b
-10000000b ^ 00100000b = 10100000b
-10000000b ^ 00100001b = 10100001b
-10000000b ^ 00100010b = 10100010b
-10000000b ^ 00100011b = 10100011b
-10000000b ^ 00100100b = 10100100b
-10000000b ^ 00100101b = 10100101b
-10000000b ^ 00100110b = 10100110b
-10000000b ^ 00100111b = 10100111b
-10000000b ^ 00101000b = 10101000b
-10000000b ^ 00101001b = 10101001b
-10000000b ^ 00101010b = 10101010b
-10000000b ^ 00101011b = 10101011b
-10000000b ^ 00101100b = 10101100b
-10000000b ^ 00101101b = 10101101b
-10000000b ^ 00101110b = 10101110b
-10000000b ^ 00101111b = 10101111b
-10000000b ^ 00110000b = 10110000b
-10000000b ^ 00110001b = 10110001b
-10000000b ^ 00110010b = 10110010b
-10000000b ^ 00110011b = 10110011b
-10000000b ^ 00110100b = 10110100b
-10000000b ^ 00110101b = 10110101b
-10000000b ^ 00110110b = 10110110b
-10000000b ^ 00110111b = 10110111b
-10000000b ^ 00111000b = 10111000b
-10000000b ^ 00111001b = 10111001b
-10000000b ^ 00111010b = 10111010b
-10000000b ^ 00111011b = 10111011b
-10000000b ^ 00111100b = 10111100b
-10000000b ^ 00111101b = 10111101b
-10000000b ^ 00111110b = 10111110b
-10000000b ^ 00111111b = 10111111b
-10000000b ^ 01000000b = 11000000b
-10000000b ^ 01000001b = 11000001b
-10000000b ^ 01000010b = 11000010b
-10000000b ^ 01000011b = 11000011b
-10000000b ^ 01000100b = 11000100b
-10000000b ^ 01000101b = 11000101b
-10000000b ^ 01000110b = 11000110b
-10000000b ^ 01000111b = 11000111b
-10000000b ^ 01001000b = 11001000b
-10000000b ^ 01001001b = 11001001b
-10000000b ^ 01001010b = 11001010b
-10000000b ^ 01001011b = 11001011b
-10000000b ^ 01001100b = 11001100b
-10000000b ^ 01001101b = 11001101b
-10000000b ^ 01001110b = 11001110b
-10000000b ^ 01001111b = 11001111b
-10000000b ^ 01010000b = 11010000b
-10000000b ^ 01010001b = 11010001b
-10000000b ^ 01010010b = 11010010b
-10000000b ^ 01010011b = 11010011b
-10000000b ^ 01010100b = 11010100b
-10000000b ^ 01010101b = 11010101b
-10000000b ^ 01010110b = 11010110b
-10000000b ^ 01010111b = 11010111b
-10000000b ^ 01011000b = 11011000b
-10000000b ^ 01011001b = 11011001b
-10000000b ^ 01011010b = 11011010b
-10000000b ^ 01011011b = 11011011b
-10000000b ^ 01011100b = 11011100b
-10000000b ^ 01011101b = 11011101b
-10000000b ^ 01011110b = 11011110b
-10000000b ^ 01011111b = 11011111b
-10000000b ^ 01100000b = 11100000b
-10000000b ^ 01100001b = 11100001b
-10000000b ^ 01100010b = 11100010b
-10000000b ^ 01100011b = 11100011b
-10000000b ^ 01100100b = 11100100b
-10000000b ^ 01100101b = 11100101b
-10000000b ^ 01100110b = 11100110b
-10000000b ^ 01100111b = 11100111b
-10000000b ^ 01101000b = 11101000b
-10000000b ^ 01101001b = 11101001b
-10000000b ^ 01101010b = 11101010b
-10000000b ^ 01101011b = 11101011b
-10000000b ^ 01101100b = 11101100b
-10000000b ^ 01101101b = 11101101b
-10000000b ^ 01101110b = 11101110b
-10000000b ^ 01101111b = 11101111b
-10000000b ^ 01110000b = 11110000b
-10000000b ^ 01110001b = 11110001b
-10000000b ^ 01110010b = 11110010b
-10000000b ^ 01110011b = 11110011b
-10000000b ^ 01110100b = 11110100b
-10000000b ^ 01110101b = 11110101b
-10000000b ^ 01110110b = 11110110b
-10000000b ^ 01110111b = 11110111b
-10000000b ^ 01111000b = 11111000b
-10000000b ^ 01111001b = 11111001b
-10000000b ^ 01111010b = 11111010b
-10000000b ^ 01111011b = 11111011b
-10000000b ^ 01111100b = 11111100b
-10000000b ^ 01111101b = 11111101b
-10000000b ^ 01111110b = 11111110b
-10000001b ^ 10000000b = 00000001b
-10000001b ^ 10000001b = 00000000b
-10000001b ^ 10000010b = 00000011b
-10000001b ^ 10000011b = 00000010b
-10000001b ^ 10000100b = 00000101b
-10000001b ^ 10000101b = 00000100b
-10000001b ^ 10000110b = 00000111b
-10000001b ^ 10000111b = 00000110b
-10000001b ^ 10001000b = 00001001b
-10000001b ^ 10001001b = 00001000b
-10000001b ^ 10001010b = 00001011b
-10000001b ^ 10001011b = 00001010b
-10000001b ^ 10001100b = 00001101b
-10000001b ^ 10001101b = 00001100b
-10000001b ^ 10001110b = 00001111b
-10000001b ^ 10001111b = 00001110b
-10000001b ^ 10010000b = 00010001b
-10000001b ^ 10010001b = 00010000b
-10000001b ^ 10010010b = 00010011b
-10000001b ^ 10010011b = 00010010b
-10000001b ^ 10010100b = 00010101b
-10000001b ^ 10010101b = 00010100b
-10000001b ^ 10010110b = 00010111b
-10000001b ^ 10010111b = 00010110b
-10000001b ^ 10011000b = 00011001b
-10000001b ^ 10011001b = 00011000b
-10000001b ^ 10011010b = 00011011b
-10000001b ^ 10011011b = 00011010b
-10000001b ^ 10011100b = 00011101b
-10000001b ^ 10011101b = 00011100b
-10000001b ^ 10011110b = 00011111b
-10000001b ^ 10011111b = 00011110b
-10000001b ^ 10100000b = 00100001b
-10000001b ^ 10100001b = 00100000b
-10000001b ^ 10100010b = 00100011b
-10000001b ^ 10100011b = 00100010b
-10000001b ^ 10100100b = 00100101b
-10000001b ^ 10100101b = 00100100b
-10000001b ^ 10100110b = 00100111b
-10000001b ^ 10100111b = 00100110b
-10000001b ^ 10101000b = 00101001b
-10000001b ^ 10101001b = 00101000b
-10000001b ^ 10101010b = 00101011b
-10000001b ^ 10101011b = 00101010b
-10000001b ^ 10101100b = 00101101b
-10000001b ^ 10101101b = 00101100b
-10000001b ^ 10101110b = 00101111b
-10000001b ^ 10101111b = 00101110b
-10000001b ^ 10110000b = 00110001b
-10000001b ^ 10110001b = 00110000b
-10000001b ^ 10110010b = 00110011b
-10000001b ^ 10110011b = 00110010b
-10000001b ^ 10110100b = 00110101b
-10000001b ^ 10110101b = 00110100b
-10000001b ^ 10110110b = 00110111b
-10000001b ^ 10110111b = 00110110b
-10000001b ^ 10111000b = 00111001b
-10000001b ^ 10111001b = 00111000b
-10000001b ^ 10111010b = 00111011b
-10000001b ^ 10111011b = 00111010b
-10000001b ^ 10111100b = 00111101b
-10000001b ^ 10111101b = 00111100b
-10000001b ^ 10111110b = 00111111b
-10000001b ^ 10111111b = 00111110b
-10000001b ^ 11000000b = 01000001b
-10000001b ^ 11000001b = 01000000b
-10000001b ^ 11000010b = 01000011b
-10000001b ^ 11000011b = 01000010b
-10000001b ^ 11000100b = 01000101b
-10000001b ^ 11000101b = 01000100b
-10000001b ^ 11000110b = 01000111b
-10000001b ^ 11000111b = 01000110b
-10000001b ^ 11001000b = 01001001b
-10000001b ^ 11001001b = 01001000b
-10000001b ^ 11001010b = 01001011b
-10000001b ^ 11001011b = 01001010b
-10000001b ^ 11001100b = 01001101b
-10000001b ^ 11001101b = 01001100b
-10000001b ^ 11001110b = 01001111b
-10000001b ^ 11001111b = 01001110b
-10000001b ^ 11010000b = 01010001b
-10000001b ^ 11010001b = 01010000b
-10000001b ^ 11010010b = 01010011b
-10000001b ^ 11010011b = 01010010b
-10000001b ^ 11010100b = 01010101b
-10000001b ^ 11010101b = 01010100b
-10000001b ^ 11010110b = 01010111b
-10000001b ^ 11010111b = 01010110b
-10000001b ^ 11011000b = 01011001b
-10000001b ^ 11011001b = 01011000b
-10000001b ^ 11011010b = 01011011b
-10000001b ^ 11011011b = 01011010b
-10000001b ^ 11011100b = 01011101b
-10000001b ^ 11011101b = 01011100b
-10000001b ^ 11011110b = 01011111b
-10000001b ^ 11011111b = 01011110b
-10000001b ^ 11100000b = 01100001b
-10000001b ^ 11100001b = 01100000b
-10000001b ^ 11100010b = 01100011b
-10000001b ^ 11100011b = 01100010b
-10000001b ^ 11100100b = 01100101b
-10000001b ^ 11100101b = 01100100b
-10000001b ^ 11100110b = 01100111b
-10000001b ^ 11100111b = 01100110b
-10000001b ^ 11101000b = 01101001b
-10000001b ^ 11101001b = 01101000b
-10000001b ^ 11101010b = 01101011b
-10000001b ^ 11101011b = 01101010b
-10000001b ^ 11101100b = 01101101b
-10000001b ^ 11101101b = 01101100b
-10000001b ^ 11101110b = 01101111b
-10000001b ^ 11101111b = 01101110b
-10000001b ^ 11110000b = 01110001b
-10000001b ^ 11110001b = 01110000b
-10000001b ^ 11110010b = 01110011b
-10000001b ^ 11110011b = 01110010b
-10000001b ^ 11110100b = 01110101b
-10000001b ^ 11110101b = 01110100b
-10000001b ^ 11110110b = 01110111b
-10000001b ^ 11110111b = 01110110b
-10000001b ^ 11111000b = 01111001b
-10000001b ^ 11111001b = 01111000b
-10000001b ^ 11111010b = 01111011b
-10000001b ^ 11111011b = 01111010b
-10000001b ^ 11111100b = 01111101b
-10000001b ^ 11111101b = 01111100b
-10000001b ^ 11111110b = 01111111b
-10000001b ^ 11111111b = 01111110b
-10000001b ^ 00000000b = 10000001b
-10000001b ^ 00000001b = 10000000b
-10000001b ^ 00000010b = 10000011b
-10000001b ^ 00000011b = 10000010b
-10000001b ^ 00000100b = 10000101b
-10000001b ^ 00000101b = 10000100b
-10000001b ^ 00000110b = 10000111b
-10000001b ^ 00000111b = 10000110b
-10000001b ^ 00001000b = 10001001b
-10000001b ^ 00001001b = 10001000b
-10000001b ^ 00001010b = 10001011b
-10000001b ^ 00001011b = 10001010b
-10000001b ^ 00001100b = 10001101b
-10000001b ^ 00001101b = 10001100b
-10000001b ^ 00001110b = 10001111b
-10000001b ^ 00001111b = 10001110b
-10000001b ^ 00010000b = 10010001b
-10000001b ^ 00010001b = 10010000b
-10000001b ^ 00010010b = 10010011b
-10000001b ^ 00010011b = 10010010b
-10000001b ^ 00010100b = 10010101b
-10000001b ^ 00010101b = 10010100b
-10000001b ^ 00010110b = 10010111b
-10000001b ^ 00010111b = 10010110b
-10000001b ^ 00011000b = 10011001b
-10000001b ^ 00011001b = 10011000b
-10000001b ^ 00011010b = 10011011b
-10000001b ^ 00011011b = 10011010b
-10000001b ^ 00011100b = 10011101b
-10000001b ^ 00011101b = 10011100b
-10000001b ^ 00011110b = 10011111b
-10000001b ^ 00011111b = 10011110b
-10000001b ^ 00100000b = 10100001b
-10000001b ^ 00100001b = 10100000b
-10000001b ^ 00100010b = 10100011b
-10000001b ^ 00100011b = 10100010b
-10000001b ^ 00100100b = 10100101b
-10000001b ^ 00100101b = 10100100b
-10000001b ^ 00100110b = 10100111b
-10000001b ^ 00100111b = 10100110b
-10000001b ^ 00101000b = 10101001b
-10000001b ^ 00101001b = 10101000b
-10000001b ^ 00101010b = 10101011b
-10000001b ^ 00101011b = 10101010b
-10000001b ^ 00101100b = 10101101b
-10000001b ^ 00101101b = 10101100b
-10000001b ^ 00101110b = 10101111b
-10000001b ^ 00101111b = 10101110b
-10000001b ^ 00110000b = 10110001b
-10000001b ^ 00110001b = 10110000b
-10000001b ^ 00110010b = 10110011b
-10000001b ^ 00110011b = 10110010b
-10000001b ^ 00110100b = 10110101b
-10000001b ^ 00110101b = 10110100b
-10000001b ^ 00110110b = 10110111b
-10000001b ^ 00110111b = 10110110b
-10000001b ^ 00111000b = 10111001b
-10000001b ^ 00111001b = 10111000b
-10000001b ^ 00111010b = 10111011b
-10000001b ^ 00111011b = 10111010b
-10000001b ^ 00111100b = 10111101b
-10000001b ^ 00111101b = 10111100b
-10000001b ^ 00111110b = 10111111b
-10000001b ^ 00111111b = 10111110b
-10000001b ^ 01000000b = 11000001b
-10000001b ^ 01000001b = 11000000b
-10000001b ^ 01000010b = 11000011b
-10000001b ^ 01000011b = 11000010b
-10000001b ^ 01000100b = 11000101b
-10000001b ^ 01000101b = 11000100b
-10000001b ^ 01000110b = 11000111b
-10000001b ^ 01000111b = 11000110b
-10000001b ^ 01001000b = 11001001b
-10000001b ^ 01001001b = 11001000b
-10000001b ^ 01001010b = 11001011b
-10000001b ^ 01001011b = 11001010b
-10000001b ^ 01001100b = 11001101b
-10000001b ^ 01001101b = 11001100b
-10000001b ^ 01001110b = 11001111b
-10000001b ^ 01001111b = 11001110b
-10000001b ^ 01010000b = 11010001b
-10000001b ^ 01010001b = 11010000b
-10000001b ^ 01010010b = 11010011b
-10000001b ^ 01010011b = 11010010b
-10000001b ^ 01010100b = 11010101b
-10000001b ^ 01010101b = 11010100b
-10000001b ^ 01010110b = 11010111b
-10000001b ^ 01010111b = 11010110b
-10000001b ^ 01011000b = 11011001b
-10000001b ^ 01011001b = 11011000b
-10000001b ^ 01011010b = 11011011b
-10000001b ^ 01011011b = 11011010b
-10000001b ^ 01011100b = 11011101b
-10000001b ^ 01011101b = 11011100b
-10000001b ^ 01011110b = 11011111b
-10000001b ^ 01011111b = 11011110b
-10000001b ^ 01100000b = 11100001b
-10000001b ^ 01100001b = 11100000b
-10000001b ^ 01100010b = 11100011b
-10000001b ^ 01100011b = 11100010b
-10000001b ^ 01100100b = 11100101b
-10000001b ^ 01100101b = 11100100b
-10000001b ^ 01100110b = 11100111b
-10000001b ^ 01100111b = 11100110b
-10000001b ^ 01101000b = 11101001b
-10000001b ^ 01101001b = 11101000b
-10000001b ^ 01101010b = 11101011b
-10000001b ^ 01101011b = 11101010b
-10000001b ^ 01101100b = 11101101b
-10000001b ^ 01101101b = 11101100b
-10000001b ^ 01101110b = 11101111b
-10000001b ^ 01101111b = 11101110b
-10000001b ^ 01110000b = 11110001b
-10000001b ^ 01110001b = 11110000b
-10000001b ^ 01110010b = 11110011b
-10000001b ^ 01110011b = 11110010b
-10000001b ^ 01110100b = 11110101b
-10000001b ^ 01110101b = 11110100b
-10000001b ^ 01110110b = 11110111b
-10000001b ^ 01110111b = 11110110b
-10000001b ^ 01111000b = 11111001b
-10000001b ^ 01111001b = 11111000b
-10000001b ^ 01111010b = 11111011b
-10000001b ^ 01111011b = 11111010b
-10000001b ^ 01111100b = 11111101b
-10000001b ^ 01111101b = 11111100b
-10000001b ^ 01111110b = 11111111b
-10000010b ^ 10000000b = 00000010b
-10000010b ^ 10000001b = 00000011b
-10000010b ^ 10000010b = 00000000b
-10000010b ^ 10000011b = 00000001b
-10000010b ^ 10000100b = 00000110b
-10000010b ^ 10000101b = 00000111b
-10000010b ^ 10000110b = 00000100b
-10000010b ^ 10000111b = 00000101b
-10000010b ^ 10001000b = 00001010b
-10000010b ^ 10001001b = 00001011b
-10000010b ^ 10001010b = 00001000b
-10000010b ^ 10001011b = 00001001b
-10000010b ^ 10001100b = 00001110b
-10000010b ^ 10001101b = 00001111b
-10000010b ^ 10001110b = 00001100b
-10000010b ^ 10001111b = 00001101b
-10000010b ^ 10010000b = 00010010b
-10000010b ^ 10010001b = 00010011b
-10000010b ^ 10010010b = 00010000b
-10000010b ^ 10010011b = 00010001b
-10000010b ^ 10010100b = 00010110b
-10000010b ^ 10010101b = 00010111b
-10000010b ^ 10010110b = 00010100b
-10000010b ^ 10010111b = 00010101b
-10000010b ^ 10011000b = 00011010b
-10000010b ^ 10011001b = 00011011b
-10000010b ^ 10011010b = 00011000b
-10000010b ^ 10011011b = 00011001b
-10000010b ^ 10011100b = 00011110b
-10000010b ^ 10011101b = 00011111b
-10000010b ^ 10011110b = 00011100b
-10000010b ^ 10011111b = 00011101b
-10000010b ^ 10100000b = 00100010b
-10000010b ^ 10100001b = 00100011b
-10000010b ^ 10100010b = 00100000b
-10000010b ^ 10100011b = 00100001b
-10000010b ^ 10100100b = 00100110b
-10000010b ^ 10100101b = 00100111b
-10000010b ^ 10100110b = 00100100b
-10000010b ^ 10100111b = 00100101b
-10000010b ^ 10101000b = 00101010b
-10000010b ^ 10101001b = 00101011b
-10000010b ^ 10101010b = 00101000b
-10000010b ^ 10101011b = 00101001b
-10000010b ^ 10101100b = 00101110b
-10000010b ^ 10101101b = 00101111b
-10000010b ^ 10101110b = 00101100b
-10000010b ^ 10101111b = 00101101b
-10000010b ^ 10110000b = 00110010b
-10000010b ^ 10110001b = 00110011b
-10000010b ^ 10110010b = 00110000b
-10000010b ^ 10110011b = 00110001b
-10000010b ^ 10110100b = 00110110b
-10000010b ^ 10110101b = 00110111b
-10000010b ^ 10110110b = 00110100b
-10000010b ^ 10110111b = 00110101b
-10000010b ^ 10111000b = 00111010b
-10000010b ^ 10111001b = 00111011b
-10000010b ^ 10111010b = 00111000b
-10000010b ^ 10111011b = 00111001b
-10000010b ^ 10111100b = 00111110b
-10000010b ^ 10111101b = 00111111b
-10000010b ^ 10111110b = 00111100b
-10000010b ^ 10111111b = 00111101b
-10000010b ^ 11000000b = 01000010b
-10000010b ^ 11000001b = 01000011b
-10000010b ^ 11000010b = 01000000b
-10000010b ^ 11000011b = 01000001b
-10000010b ^ 11000100b = 01000110b
-10000010b ^ 11000101b = 01000111b
-10000010b ^ 11000110b = 01000100b
-10000010b ^ 11000111b = 01000101b
-10000010b ^ 11001000b = 01001010b
-10000010b ^ 11001001b = 01001011b
-10000010b ^ 11001010b = 01001000b
-10000010b ^ 11001011b = 01001001b
-10000010b ^ 11001100b = 01001110b
-10000010b ^ 11001101b = 01001111b
-10000010b ^ 11001110b = 01001100b
-10000010b ^ 11001111b = 01001101b
-10000010b ^ 11010000b = 01010010b
-10000010b ^ 11010001b = 01010011b
-10000010b ^ 11010010b = 01010000b
-10000010b ^ 11010011b = 01010001b
-10000010b ^ 11010100b = 01010110b
-10000010b ^ 11010101b = 01010111b
-10000010b ^ 11010110b = 01010100b
-10000010b ^ 11010111b = 01010101b
-10000010b ^ 11011000b = 01011010b
-10000010b ^ 11011001b = 01011011b
-10000010b ^ 11011010b = 01011000b
-10000010b ^ 11011011b = 01011001b
-10000010b ^ 11011100b = 01011110b
-10000010b ^ 11011101b = 01011111b
-10000010b ^ 11011110b = 01011100b
-10000010b ^ 11011111b = 01011101b
-10000010b ^ 11100000b = 01100010b
-10000010b ^ 11100001b = 01100011b
-10000010b ^ 11100010b = 01100000b
-10000010b ^ 11100011b = 01100001b
-10000010b ^ 11100100b = 01100110b
-10000010b ^ 11100101b = 01100111b
-10000010b ^ 11100110b = 01100100b
-10000010b ^ 11100111b = 01100101b
-10000010b ^ 11101000b = 01101010b
-10000010b ^ 11101001b = 01101011b
-10000010b ^ 11101010b = 01101000b
-10000010b ^ 11101011b = 01101001b
-10000010b ^ 11101100b = 01101110b
-10000010b ^ 11101101b = 01101111b
-10000010b ^ 11101110b = 01101100b
-10000010b ^ 11101111b = 01101101b
-10000010b ^ 11110000b = 01110010b
-10000010b ^ 11110001b = 01110011b
-10000010b ^ 11110010b = 01110000b
-10000010b ^ 11110011b = 01110001b
-10000010b ^ 11110100b = 01110110b
-10000010b ^ 11110101b = 01110111b
-10000010b ^ 11110110b = 01110100b
-10000010b ^ 11110111b = 01110101b
-10000010b ^ 11111000b = 01111010b
-10000010b ^ 11111001b = 01111011b
-10000010b ^ 11111010b = 01111000b
-10000010b ^ 11111011b = 01111001b
-10000010b ^ 11111100b = 01111110b
-10000010b ^ 11111101b = 01111111b
-10000010b ^ 11111110b = 01111100b
-10000010b ^ 11111111b = 01111101b
-10000010b ^ 00000000b = 10000010b
-10000010b ^ 00000001b = 10000011b
-10000010b ^ 00000010b = 10000000b
-10000010b ^ 00000011b = 10000001b
-10000010b ^ 00000100b = 10000110b
-10000010b ^ 00000101b = 10000111b
-10000010b ^ 00000110b = 10000100b
-10000010b ^ 00000111b = 10000101b
-10000010b ^ 00001000b = 10001010b
-10000010b ^ 00001001b = 10001011b
-10000010b ^ 00001010b = 10001000b
-10000010b ^ 00001011b = 10001001b
-10000010b ^ 00001100b = 10001110b
-10000010b ^ 00001101b = 10001111b
-10000010b ^ 00001110b = 10001100b
-10000010b ^ 00001111b = 10001101b
-10000010b ^ 00010000b = 10010010b
-10000010b ^ 00010001b = 10010011b
-10000010b ^ 00010010b = 10010000b
-10000010b ^ 00010011b = 10010001b
-10000010b ^ 00010100b = 10010110b
-10000010b ^ 00010101b = 10010111b
-10000010b ^ 00010110b = 10010100b
-10000010b ^ 00010111b = 10010101b
-10000010b ^ 00011000b = 10011010b
-10000010b ^ 00011001b = 10011011b
-10000010b ^ 00011010b = 10011000b
-10000010b ^ 00011011b = 10011001b
-10000010b ^ 00011100b = 10011110b
-10000010b ^ 00011101b = 10011111b
-10000010b ^ 00011110b = 10011100b
-10000010b ^ 00011111b = 10011101b
-10000010b ^ 00100000b = 10100010b
-10000010b ^ 00100001b = 10100011b
-10000010b ^ 00100010b = 10100000b
-10000010b ^ 00100011b = 10100001b
-10000010b ^ 00100100b = 10100110b
-10000010b ^ 00100101b = 10100111b
-10000010b ^ 00100110b = 10100100b
-10000010b ^ 00100111b = 10100101b
-10000010b ^ 00101000b = 10101010b
-10000010b ^ 00101001b = 10101011b
-10000010b ^ 00101010b = 10101000b
-10000010b ^ 00101011b = 10101001b
-10000010b ^ 00101100b = 10101110b
-10000010b ^ 00101101b = 10101111b
-10000010b ^ 00101110b = 10101100b
-10000010b ^ 00101111b = 10101101b
-10000010b ^ 00110000b = 10110010b
-10000010b ^ 00110001b = 10110011b
-10000010b ^ 00110010b = 10110000b
-10000010b ^ 00110011b = 10110001b
-10000010b ^ 00110100b = 10110110b
-10000010b ^ 00110101b = 10110111b
-10000010b ^ 00110110b = 10110100b
-10000010b ^ 00110111b = 10110101b
-10000010b ^ 00111000b = 10111010b
-10000010b ^ 00111001b = 10111011b
-10000010b ^ 00111010b = 10111000b
-10000010b ^ 00111011b = 10111001b
-10000010b ^ 00111100b = 10111110b
-10000010b ^ 00111101b = 10111111b
-10000010b ^ 00111110b = 10111100b
-10000010b ^ 00111111b = 10111101b
-10000010b ^ 01000000b = 11000010b
-10000010b ^ 01000001b = 11000011b
-10000010b ^ 01000010b = 11000000b
-10000010b ^ 01000011b = 11000001b
-10000010b ^ 01000100b = 11000110b
-10000010b ^ 01000101b = 11000111b
-10000010b ^ 01000110b = 11000100b
-10000010b ^ 01000111b = 11000101b
-10000010b ^ 01001000b = 11001010b
-10000010b ^ 01001001b = 11001011b
-10000010b ^ 01001010b = 11001000b
-10000010b ^ 01001011b = 11001001b
-10000010b ^ 01001100b = 11001110b
-10000010b ^ 01001101b = 11001111b
-10000010b ^ 01001110b = 11001100b
-10000010b ^ 01001111b = 11001101b
-10000010b ^ 01010000b = 11010010b
-10000010b ^ 01010001b = 11010011b
-10000010b ^ 01010010b = 11010000b
-10000010b ^ 01010011b = 11010001b
-10000010b ^ 01010100b = 11010110b
-10000010b ^ 01010101b = 11010111b
-10000010b ^ 01010110b = 11010100b
-10000010b ^ 01010111b = 11010101b
-10000010b ^ 01011000b = 11011010b
-10000010b ^ 01011001b = 11011011b
-10000010b ^ 01011010b = 11011000b
-10000010b ^ 01011011b = 11011001b
-10000010b ^ 01011100b = 11011110b
-10000010b ^ 01011101b = 11011111b
-10000010b ^ 01011110b = 11011100b
-10000010b ^ 01011111b = 11011101b
-10000010b ^ 01100000b = 11100010b
-10000010b ^ 01100001b = 11100011b
-10000010b ^ 01100010b = 11100000b
-10000010b ^ 01100011b = 11100001b
-10000010b ^ 01100100b = 11100110b
-10000010b ^ 01100101b = 11100111b
-10000010b ^ 01100110b = 11100100b
-10000010b ^ 01100111b = 11100101b
-10000010b ^ 01101000b = 11101010b
-10000010b ^ 01101001b = 11101011b
-10000010b ^ 01101010b = 11101000b
-10000010b ^ 01101011b = 11101001b
-10000010b ^ 01101100b = 11101110b
-10000010b ^ 01101101b = 11101111b
-10000010b ^ 01101110b = 11101100b
-10000010b ^ 01101111b = 11101101b
-10000010b ^ 01110000b = 11110010b
-10000010b ^ 01110001b = 11110011b
-10000010b ^ 01110010b = 11110000b
-10000010b ^ 01110011b = 11110001b
-10000010b ^ 01110100b = 11110110b
-10000010b ^ 01110101b = 11110111b
-10000010b ^ 01110110b = 11110100b
-10000010b ^ 01110111b = 11110101b
-10000010b ^ 01111000b = 11111010b
-10000010b ^ 01111001b = 11111011b
-10000010b ^ 01111010b = 11111000b
-10000010b ^ 01111011b = 11111001b
-10000010b ^ 01111100b = 11111110b
-10000010b ^ 01111101b = 11111111b
-10000010b ^ 01111110b = 11111100b
-10000011b ^ 10000000b = 00000011b
-10000011b ^ 10000001b = 00000010b
-10000011b ^ 10000010b = 00000001b
-10000011b ^ 10000011b = 00000000b
-10000011b ^ 10000100b = 00000111b
-10000011b ^ 10000101b = 00000110b
-10000011b ^ 10000110b = 00000101b
-10000011b ^ 10000111b = 00000100b
-10000011b ^ 10001000b = 00001011b
-10000011b ^ 10001001b = 00001010b
-10000011b ^ 10001010b = 00001001b
-10000011b ^ 10001011b = 00001000b
-10000011b ^ 10001100b = 00001111b
-10000011b ^ 10001101b = 00001110b
-10000011b ^ 10001110b = 00001101b
-10000011b ^ 10001111b = 00001100b
-10000011b ^ 10010000b = 00010011b
-10000011b ^ 10010001b = 00010010b
-10000011b ^ 10010010b = 00010001b
-10000011b ^ 10010011b = 00010000b
-10000011b ^ 10010100b = 00010111b
-10000011b ^ 10010101b = 00010110b
-10000011b ^ 10010110b = 00010101b
-10000011b ^ 10010111b = 00010100b
-10000011b ^ 10011000b = 00011011b
-10000011b ^ 10011001b = 00011010b
-10000011b ^ 10011010b = 00011001b
-10000011b ^ 10011011b = 00011000b
-10000011b ^ 10011100b = 00011111b
-10000011b ^ 10011101b = 00011110b
-10000011b ^ 10011110b = 00011101b
-10000011b ^ 10011111b = 00011100b
-10000011b ^ 10100000b = 00100011b
-10000011b ^ 10100001b = 00100010b
-10000011b ^ 10100010b = 00100001b
-10000011b ^ 10100011b = 00100000b
-10000011b ^ 10100100b = 00100111b
-10000011b ^ 10100101b = 00100110b
-10000011b ^ 10100110b = 00100101b
-10000011b ^ 10100111b = 00100100b
-10000011b ^ 10101000b = 00101011b
-10000011b ^ 10101001b = 00101010b
-10000011b ^ 10101010b = 00101001b
-10000011b ^ 10101011b = 00101000b
-10000011b ^ 10101100b = 00101111b
-10000011b ^ 10101101b = 00101110b
-10000011b ^ 10101110b = 00101101b
-10000011b ^ 10101111b = 00101100b
-10000011b ^ 10110000b = 00110011b
-10000011b ^ 10110001b = 00110010b
-10000011b ^ 10110010b = 00110001b
-10000011b ^ 10110011b = 00110000b
-10000011b ^ 10110100b = 00110111b
-10000011b ^ 10110101b = 00110110b
-10000011b ^ 10110110b = 00110101b
-10000011b ^ 10110111b = 00110100b
-10000011b ^ 10111000b = 00111011b
-10000011b ^ 10111001b = 00111010b
-10000011b ^ 10111010b = 00111001b
-10000011b ^ 10111011b = 00111000b
-10000011b ^ 10111100b = 00111111b
-10000011b ^ 10111101b = 00111110b
-10000011b ^ 10111110b = 00111101b
-10000011b ^ 10111111b = 00111100b
-10000011b ^ 11000000b = 01000011b
-10000011b ^ 11000001b = 01000010b
-10000011b ^ 11000010b = 01000001b
-10000011b ^ 11000011b = 01000000b
-10000011b ^ 11000100b = 01000111b
-10000011b ^ 11000101b = 01000110b
-10000011b ^ 11000110b = 01000101b
-10000011b ^ 11000111b = 01000100b
-10000011b ^ 11001000b = 01001011b
-10000011b ^ 11001001b = 01001010b
-10000011b ^ 11001010b = 01001001b
-10000011b ^ 11001011b = 01001000b
-10000011b ^ 11001100b = 01001111b
-10000011b ^ 11001101b = 01001110b
-10000011b ^ 11001110b = 01001101b
-10000011b ^ 11001111b = 01001100b
-10000011b ^ 11010000b = 01010011b
-10000011b ^ 11010001b = 01010010b
-10000011b ^ 11010010b = 01010001b
-10000011b ^ 11010011b = 01010000b
-10000011b ^ 11010100b = 01010111b
-10000011b ^ 11010101b = 01010110b
-10000011b ^ 11010110b = 01010101b
-10000011b ^ 11010111b = 01010100b
-10000011b ^ 11011000b = 01011011b
-10000011b ^ 11011001b = 01011010b
-10000011b ^ 11011010b = 01011001b
-10000011b ^ 11011011b = 01011000b
-10000011b ^ 11011100b = 01011111b
-10000011b ^ 11011101b = 01011110b
-10000011b ^ 11011110b = 01011101b
-10000011b ^ 11011111b = 01011100b
-10000011b ^ 11100000b = 01100011b
-10000011b ^ 11100001b = 01100010b
-10000011b ^ 11100010b = 01100001b
-10000011b ^ 11100011b = 01100000b
-10000011b ^ 11100100b = 01100111b
-10000011b ^ 11100101b = 01100110b
-10000011b ^ 11100110b = 01100101b
-10000011b ^ 11100111b = 01100100b
-10000011b ^ 11101000b = 01101011b
-10000011b ^ 11101001b = 01101010b
-10000011b ^ 11101010b = 01101001b
-10000011b ^ 11101011b = 01101000b
-10000011b ^ 11101100b = 01101111b
-10000011b ^ 11101101b = 01101110b
-10000011b ^ 11101110b = 01101101b
-10000011b ^ 11101111b = 01101100b
-10000011b ^ 11110000b = 01110011b
-10000011b ^ 11110001b = 01110010b
-10000011b ^ 11110010b = 01110001b
-10000011b ^ 11110011b = 01110000b
-10000011b ^ 11110100b = 01110111b
-10000011b ^ 11110101b = 01110110b
-10000011b ^ 11110110b = 01110101b
-10000011b ^ 11110111b = 01110100b
-10000011b ^ 11111000b = 01111011b
-10000011b ^ 11111001b = 01111010b
-10000011b ^ 11111010b = 01111001b
-10000011b ^ 11111011b = 01111000b
-10000011b ^ 11111100b = 01111111b
-10000011b ^ 11111101b = 01111110b
-10000011b ^ 11111110b = 01111101b
-10000011b ^ 11111111b = 01111100b
-10000011b ^ 00000000b = 10000011b
-10000011b ^ 00000001b = 10000010b
-10000011b ^ 00000010b = 10000001b
-10000011b ^ 00000011b = 10000000b
-10000011b ^ 00000100b = 10000111b
-10000011b ^ 00000101b = 10000110b
-10000011b ^ 00000110b = 10000101b
-10000011b ^ 00000111b = 10000100b
-10000011b ^ 00001000b = 10001011b
-10000011b ^ 00001001b = 10001010b
-10000011b ^ 00001010b = 10001001b
-10000011b ^ 00001011b = 10001000b
-10000011b ^ 00001100b = 10001111b
-10000011b ^ 00001101b = 10001110b
-10000011b ^ 00001110b = 10001101b
-10000011b ^ 00001111b = 10001100b
-10000011b ^ 00010000b = 10010011b
-10000011b ^ 00010001b = 10010010b
-10000011b ^ 00010010b = 10010001b
-10000011b ^ 00010011b = 10010000b
-10000011b ^ 00010100b = 10010111b
-10000011b ^ 00010101b = 10010110b
-10000011b ^ 00010110b = 10010101b
-10000011b ^ 00010111b = 10010100b
-10000011b ^ 00011000b = 10011011b
-10000011b ^ 00011001b = 10011010b
-10000011b ^ 00011010b = 10011001b
-10000011b ^ 00011011b = 10011000b
-10000011b ^ 00011100b = 10011111b
-10000011b ^ 00011101b = 10011110b
-10000011b ^ 00011110b = 10011101b
-10000011b ^ 00011111b = 10011100b
-10000011b ^ 00100000b = 10100011b
-10000011b ^ 00100001b = 10100010b
-10000011b ^ 00100010b = 10100001b
-10000011b ^ 00100011b = 10100000b
-10000011b ^ 00100100b = 10100111b
-10000011b ^ 00100101b = 10100110b
-10000011b ^ 00100110b = 10100101b
-10000011b ^ 00100111b = 10100100b
-10000011b ^ 00101000b = 10101011b
-10000011b ^ 00101001b = 10101010b
-10000011b ^ 00101010b = 10101001b
-10000011b ^ 00101011b = 10101000b
-10000011b ^ 00101100b = 10101111b
-10000011b ^ 00101101b = 10101110b
-10000011b ^ 00101110b = 10101101b
-10000011b ^ 00101111b = 10101100b
-10000011b ^ 00110000b = 10110011b
-10000011b ^ 00110001b = 10110010b
-10000011b ^ 00110010b = 10110001b
-10000011b ^ 00110011b = 10110000b
-10000011b ^ 00110100b = 10110111b
-10000011b ^ 00110101b = 10110110b
-10000011b ^ 00110110b = 10110101b
-10000011b ^ 00110111b = 10110100b
-10000011b ^ 00111000b = 10111011b
-10000011b ^ 00111001b = 10111010b
-10000011b ^ 00111010b = 10111001b
-10000011b ^ 00111011b = 10111000b
-10000011b ^ 00111100b = 10111111b
-10000011b ^ 00111101b = 10111110b
-10000011b ^ 00111110b = 10111101b
-10000011b ^ 00111111b = 10111100b
-10000011b ^ 01000000b = 11000011b
-10000011b ^ 01000001b = 11000010b
-10000011b ^ 01000010b = 11000001b
-10000011b ^ 01000011b = 11000000b
-10000011b ^ 01000100b = 11000111b
-10000011b ^ 01000101b = 11000110b
-10000011b ^ 01000110b = 11000101b
-10000011b ^ 01000111b = 11000100b
-10000011b ^ 01001000b = 11001011b
-10000011b ^ 01001001b = 11001010b
-10000011b ^ 01001010b = 11001001b
-10000011b ^ 01001011b = 11001000b
-10000011b ^ 01001100b = 11001111b
-10000011b ^ 01001101b = 11001110b
-10000011b ^ 01001110b = 11001101b
-10000011b ^ 01001111b = 11001100b
-10000011b ^ 01010000b = 11010011b
-10000011b ^ 01010001b = 11010010b
-10000011b ^ 01010010b = 11010001b
-10000011b ^ 01010011b = 11010000b
-10000011b ^ 01010100b = 11010111b
-10000011b ^ 01010101b = 11010110b
-10000011b ^ 01010110b = 11010101b
-10000011b ^ 01010111b = 11010100b
-10000011b ^ 01011000b = 11011011b
-10000011b ^ 01011001b = 11011010b
-10000011b ^ 01011010b = 11011001b
-10000011b ^ 01011011b = 11011000b
-10000011b ^ 01011100b = 11011111b
-10000011b ^ 01011101b = 11011110b
-10000011b ^ 01011110b = 11011101b
-10000011b ^ 01011111b = 11011100b
-10000011b ^ 01100000b = 11100011b
-10000011b ^ 01100001b = 11100010b
-10000011b ^ 01100010b = 11100001b
-10000011b ^ 01100011b = 11100000b
-10000011b ^ 01100100b = 11100111b
-10000011b ^ 01100101b = 11100110b
-10000011b ^ 01100110b = 11100101b
-10000011b ^ 01100111b = 11100100b
-10000011b ^ 01101000b = 11101011b
-10000011b ^ 01101001b = 11101010b
-10000011b ^ 01101010b = 11101001b
-10000011b ^ 01101011b = 11101000b
-10000011b ^ 01101100b = 11101111b
-10000011b ^ 01101101b = 11101110b
-10000011b ^ 01101110b = 11101101b
-10000011b ^ 01101111b = 11101100b
-10000011b ^ 01110000b = 11110011b
-10000011b ^ 01110001b = 11110010b
-10000011b ^ 01110010b = 11110001b
-10000011b ^ 01110011b = 11110000b
-10000011b ^ 01110100b = 11110111b
-10000011b ^ 01110101b = 11110110b
-10000011b ^ 01110110b = 11110101b
-10000011b ^ 01110111b = 11110100b
-10000011b ^ 01111000b = 11111011b
-10000011b ^ 01111001b = 11111010b
-10000011b ^ 01111010b = 11111001b
-10000011b ^ 01111011b = 11111000b
-10000011b ^ 01111100b = 11111111b
-10000011b ^ 01111101b = 11111110b
-10000011b ^ 01111110b = 11111101b
-10000100b ^ 10000000b = 00000100b
-10000100b ^ 10000001b = 00000101b
-10000100b ^ 10000010b = 00000110b
-10000100b ^ 10000011b = 00000111b
-10000100b ^ 10000100b = 00000000b
-10000100b ^ 10000101b = 00000001b
-10000100b ^ 10000110b = 00000010b
-10000100b ^ 10000111b = 00000011b
-10000100b ^ 10001000b = 00001100b
-10000100b ^ 10001001b = 00001101b
-10000100b ^ 10001010b = 00001110b
-10000100b ^ 10001011b = 00001111b
-10000100b ^ 10001100b = 00001000b
-10000100b ^ 10001101b = 00001001b
-10000100b ^ 10001110b = 00001010b
-10000100b ^ 10001111b = 00001011b
-10000100b ^ 10010000b = 00010100b
-10000100b ^ 10010001b = 00010101b
-10000100b ^ 10010010b = 00010110b
-10000100b ^ 10010011b = 00010111b
-10000100b ^ 10010100b = 00010000b
-10000100b ^ 10010101b = 00010001b
-10000100b ^ 10010110b = 00010010b
-10000100b ^ 10010111b = 00010011b
-10000100b ^ 10011000b = 00011100b
-10000100b ^ 10011001b = 00011101b
-10000100b ^ 10011010b = 00011110b
-10000100b ^ 10011011b = 00011111b
-10000100b ^ 10011100b = 00011000b
-10000100b ^ 10011101b = 00011001b
-10000100b ^ 10011110b = 00011010b
-10000100b ^ 10011111b = 00011011b
-10000100b ^ 10100000b = 00100100b
-10000100b ^ 10100001b = 00100101b
-10000100b ^ 10100010b = 00100110b
-10000100b ^ 10100011b = 00100111b
-10000100b ^ 10100100b = 00100000b
-10000100b ^ 10100101b = 00100001b
-10000100b ^ 10100110b = 00100010b
-10000100b ^ 10100111b = 00100011b
-10000100b ^ 10101000b = 00101100b
-10000100b ^ 10101001b = 00101101b
-10000100b ^ 10101010b = 00101110b
-10000100b ^ 10101011b = 00101111b
-10000100b ^ 10101100b = 00101000b
-10000100b ^ 10101101b = 00101001b
-10000100b ^ 10101110b = 00101010b
-10000100b ^ 10101111b = 00101011b
-10000100b ^ 10110000b = 00110100b
-10000100b ^ 10110001b = 00110101b
-10000100b ^ 10110010b = 00110110b
-10000100b ^ 10110011b = 00110111b
-10000100b ^ 10110100b = 00110000b
-10000100b ^ 10110101b = 00110001b
-10000100b ^ 10110110b = 00110010b
-10000100b ^ 10110111b = 00110011b
-10000100b ^ 10111000b = 00111100b
-10000100b ^ 10111001b = 00111101b
-10000100b ^ 10111010b = 00111110b
-10000100b ^ 10111011b = 00111111b
-10000100b ^ 10111100b = 00111000b
-10000100b ^ 10111101b = 00111001b
-10000100b ^ 10111110b = 00111010b
-10000100b ^ 10111111b = 00111011b
-10000100b ^ 11000000b = 01000100b
-10000100b ^ 11000001b = 01000101b
-10000100b ^ 11000010b = 01000110b
-10000100b ^ 11000011b = 01000111b
-10000100b ^ 11000100b = 01000000b
-10000100b ^ 11000101b = 01000001b
-10000100b ^ 11000110b = 01000010b
-10000100b ^ 11000111b = 01000011b
-10000100b ^ 11001000b = 01001100b
-10000100b ^ 11001001b = 01001101b
-10000100b ^ 11001010b = 01001110b
-10000100b ^ 11001011b = 01001111b
-10000100b ^ 11001100b = 01001000b
-10000100b ^ 11001101b = 01001001b
-10000100b ^ 11001110b = 01001010b
-10000100b ^ 11001111b = 01001011b
-10000100b ^ 11010000b = 01010100b
-10000100b ^ 11010001b = 01010101b
-10000100b ^ 11010010b = 01010110b
-10000100b ^ 11010011b = 01010111b
-10000100b ^ 11010100b = 01010000b
-10000100b ^ 11010101b = 01010001b
-10000100b ^ 11010110b = 01010010b
-10000100b ^ 11010111b = 01010011b
-10000100b ^ 11011000b = 01011100b
-10000100b ^ 11011001b = 01011101b
-10000100b ^ 11011010b = 01011110b
-10000100b ^ 11011011b = 01011111b
-10000100b ^ 11011100b = 01011000b
-10000100b ^ 11011101b = 01011001b
-10000100b ^ 11011110b = 01011010b
-10000100b ^ 11011111b = 01011011b
-10000100b ^ 11100000b = 01100100b
-10000100b ^ 11100001b = 01100101b
-10000100b ^ 11100010b = 01100110b
-10000100b ^ 11100011b = 01100111b
-10000100b ^ 11100100b = 01100000b
-10000100b ^ 11100101b = 01100001b
-10000100b ^ 11100110b = 01100010b
-10000100b ^ 11100111b = 01100011b
-10000100b ^ 11101000b = 01101100b
-10000100b ^ 11101001b = 01101101b
-10000100b ^ 11101010b = 01101110b
-10000100b ^ 11101011b = 01101111b
-10000100b ^ 11101100b = 01101000b
-10000100b ^ 11101101b = 01101001b
-10000100b ^ 11101110b = 01101010b
-10000100b ^ 11101111b = 01101011b
-10000100b ^ 11110000b = 01110100b
-10000100b ^ 11110001b = 01110101b
-10000100b ^ 11110010b = 01110110b
-10000100b ^ 11110011b = 01110111b
-10000100b ^ 11110100b = 01110000b
-10000100b ^ 11110101b = 01110001b
-10000100b ^ 11110110b = 01110010b
-10000100b ^ 11110111b = 01110011b
-10000100b ^ 11111000b = 01111100b
-10000100b ^ 11111001b = 01111101b
-10000100b ^ 11111010b = 01111110b
-10000100b ^ 11111011b = 01111111b
-10000100b ^ 11111100b = 01111000b
-10000100b ^ 11111101b = 01111001b
-10000100b ^ 11111110b = 01111010b
-10000100b ^ 11111111b = 01111011b
-10000100b ^ 00000000b = 10000100b
-10000100b ^ 00000001b = 10000101b
-10000100b ^ 00000010b = 10000110b
-10000100b ^ 00000011b = 10000111b
-10000100b ^ 00000100b = 10000000b
-10000100b ^ 00000101b = 10000001b
-10000100b ^ 00000110b = 10000010b
-10000100b ^ 00000111b = 10000011b
-10000100b ^ 00001000b = 10001100b
-10000100b ^ 00001001b = 10001101b
-10000100b ^ 00001010b = 10001110b
-10000100b ^ 00001011b = 10001111b
-10000100b ^ 00001100b = 10001000b
-10000100b ^ 00001101b = 10001001b
-10000100b ^ 00001110b = 10001010b
-10000100b ^ 00001111b = 10001011b
-10000100b ^ 00010000b = 10010100b
-10000100b ^ 00010001b = 10010101b
-10000100b ^ 00010010b = 10010110b
-10000100b ^ 00010011b = 10010111b
-10000100b ^ 00010100b = 10010000b
-10000100b ^ 00010101b = 10010001b
-10000100b ^ 00010110b = 10010010b
-10000100b ^ 00010111b = 10010011b
-10000100b ^ 00011000b = 10011100b
-10000100b ^ 00011001b = 10011101b
-10000100b ^ 00011010b = 10011110b
-10000100b ^ 00011011b = 10011111b
-10000100b ^ 00011100b = 10011000b
-10000100b ^ 00011101b = 10011001b
-10000100b ^ 00011110b = 10011010b
-10000100b ^ 00011111b = 10011011b
-10000100b ^ 00100000b = 10100100b
-10000100b ^ 00100001b = 10100101b
-10000100b ^ 00100010b = 10100110b
-10000100b ^ 00100011b = 10100111b
-10000100b ^ 00100100b = 10100000b
-10000100b ^ 00100101b = 10100001b
-10000100b ^ 00100110b = 10100010b
-10000100b ^ 00100111b = 10100011b
-10000100b ^ 00101000b = 10101100b
-10000100b ^ 00101001b = 10101101b
-10000100b ^ 00101010b = 10101110b
-10000100b ^ 00101011b = 10101111b
-10000100b ^ 00101100b = 10101000b
-10000100b ^ 00101101b = 10101001b
-10000100b ^ 00101110b = 10101010b
-10000100b ^ 00101111b = 10101011b
-10000100b ^ 00110000b = 10110100b
-10000100b ^ 00110001b = 10110101b
-10000100b ^ 00110010b = 10110110b
-10000100b ^ 00110011b = 10110111b
-10000100b ^ 00110100b = 10110000b
-10000100b ^ 00110101b = 10110001b
-10000100b ^ 00110110b = 10110010b
-10000100b ^ 00110111b = 10110011b
-10000100b ^ 00111000b = 10111100b
-10000100b ^ 00111001b = 10111101b
-10000100b ^ 00111010b = 10111110b
-10000100b ^ 00111011b = 10111111b
-10000100b ^ 00111100b = 10111000b
-10000100b ^ 00111101b = 10111001b
-10000100b ^ 00111110b = 10111010b
-10000100b ^ 00111111b = 10111011b
-10000100b ^ 01000000b = 11000100b
-10000100b ^ 01000001b = 11000101b
-10000100b ^ 01000010b = 11000110b
-10000100b ^ 01000011b = 11000111b
-10000100b ^ 01000100b = 11000000b
-10000100b ^ 01000101b = 11000001b
-10000100b ^ 01000110b = 11000010b
-10000100b ^ 01000111b = 11000011b
-10000100b ^ 01001000b = 11001100b
-10000100b ^ 01001001b = 11001101b
-10000100b ^ 01001010b = 11001110b
-10000100b ^ 01001011b = 11001111b
-10000100b ^ 01001100b = 11001000b
-10000100b ^ 01001101b = 11001001b
-10000100b ^ 01001110b = 11001010b
-10000100b ^ 01001111b = 11001011b
-10000100b ^ 01010000b = 11010100b
-10000100b ^ 01010001b = 11010101b
-10000100b ^ 01010010b = 11010110b
-10000100b ^ 01010011b = 11010111b
-10000100b ^ 01010100b = 11010000b
-10000100b ^ 01010101b = 11010001b
-10000100b ^ 01010110b = 11010010b
-10000100b ^ 01010111b = 11010011b
-10000100b ^ 01011000b = 11011100b
-10000100b ^ 01011001b = 11011101b
-10000100b ^ 01011010b = 11011110b
-10000100b ^ 01011011b = 11011111b
-10000100b ^ 01011100b = 11011000b
-10000100b ^ 01011101b = 11011001b
-10000100b ^ 01011110b = 11011010b
-10000100b ^ 01011111b = 11011011b
-10000100b ^ 01100000b = 11100100b
-10000100b ^ 01100001b = 11100101b
-10000100b ^ 01100010b = 11100110b
-10000100b ^ 01100011b = 11100111b
-10000100b ^ 01100100b = 11100000b
-10000100b ^ 01100101b = 11100001b
-10000100b ^ 01100110b = 11100010b
-10000100b ^ 01100111b = 11100011b
-10000100b ^ 01101000b = 11101100b
-10000100b ^ 01101001b = 11101101b
-10000100b ^ 01101010b = 11101110b
-10000100b ^ 01101011b = 11101111b
-10000100b ^ 01101100b = 11101000b
-10000100b ^ 01101101b = 11101001b
-10000100b ^ 01101110b = 11101010b
-10000100b ^ 01101111b = 11101011b
-10000100b ^ 01110000b = 11110100b
-10000100b ^ 01110001b = 11110101b
-10000100b ^ 01110010b = 11110110b
-10000100b ^ 01110011b = 11110111b
-10000100b ^ 01110100b = 11110000b
-10000100b ^ 01110101b = 11110001b
-10000100b ^ 01110110b = 11110010b
-10000100b ^ 01110111b = 11110011b
-10000100b ^ 01111000b = 11111100b
-10000100b ^ 01111001b = 11111101b
-10000100b ^ 01111010b = 11111110b
-10000100b ^ 01111011b = 11111111b
-10000100b ^ 01111100b = 11111000b
-10000100b ^ 01111101b = 11111001b
-10000100b ^ 01111110b = 11111010b
-10000101b ^ 10000000b = 00000101b
-10000101b ^ 10000001b = 00000100b
-10000101b ^ 10000010b = 00000111b
-10000101b ^ 10000011b = 00000110b
-10000101b ^ 10000100b = 00000001b
-10000101b ^ 10000101b = 00000000b
-10000101b ^ 10000110b = 00000011b
-10000101b ^ 10000111b = 00000010b
-10000101b ^ 10001000b = 00001101b
-10000101b ^ 10001001b = 00001100b
-10000101b ^ 10001010b = 00001111b
-10000101b ^ 10001011b = 00001110b
-10000101b ^ 10001100b = 00001001b
-10000101b ^ 10001101b = 00001000b
-10000101b ^ 10001110b = 00001011b
-10000101b ^ 10001111b = 00001010b
-10000101b ^ 10010000b = 00010101b
-10000101b ^ 10010001b = 00010100b
-10000101b ^ 10010010b = 00010111b
-10000101b ^ 10010011b = 00010110b
-10000101b ^ 10010100b = 00010001b
-10000101b ^ 10010101b = 00010000b
-10000101b ^ 10010110b = 00010011b
-10000101b ^ 10010111b = 00010010b
-10000101b ^ 10011000b = 00011101b
-10000101b ^ 10011001b = 00011100b
-10000101b ^ 10011010b = 00011111b
-10000101b ^ 10011011b = 00011110b
-10000101b ^ 10011100b = 00011001b
-10000101b ^ 10011101b = 00011000b
-10000101b ^ 10011110b = 00011011b
-10000101b ^ 10011111b = 00011010b
-10000101b ^ 10100000b = 00100101b
-10000101b ^ 10100001b = 00100100b
-10000101b ^ 10100010b = 00100111b
-10000101b ^ 10100011b = 00100110b
-10000101b ^ 10100100b = 00100001b
-10000101b ^ 10100101b = 00100000b
-10000101b ^ 10100110b = 00100011b
-10000101b ^ 10100111b = 00100010b
-10000101b ^ 10101000b = 00101101b
-10000101b ^ 10101001b = 00101100b
-10000101b ^ 10101010b = 00101111b
-10000101b ^ 10101011b = 00101110b
-10000101b ^ 10101100b = 00101001b
-10000101b ^ 10101101b = 00101000b
-10000101b ^ 10101110b = 00101011b
-10000101b ^ 10101111b = 00101010b
-10000101b ^ 10110000b = 00110101b
-10000101b ^ 10110001b = 00110100b
-10000101b ^ 10110010b = 00110111b
-10000101b ^ 10110011b = 00110110b
-10000101b ^ 10110100b = 00110001b
-10000101b ^ 10110101b = 00110000b
-10000101b ^ 10110110b = 00110011b
-10000101b ^ 10110111b = 00110010b
-10000101b ^ 10111000b = 00111101b
-10000101b ^ 10111001b = 00111100b
-10000101b ^ 10111010b = 00111111b
-10000101b ^ 10111011b = 00111110b
-10000101b ^ 10111100b = 00111001b
-10000101b ^ 10111101b = 00111000b
-10000101b ^ 10111110b = 00111011b
-10000101b ^ 10111111b = 00111010b
-10000101b ^ 11000000b = 01000101b
-10000101b ^ 11000001b = 01000100b
-10000101b ^ 11000010b = 01000111b
-10000101b ^ 11000011b = 01000110b
-10000101b ^ 11000100b = 01000001b
-10000101b ^ 11000101b = 01000000b
-10000101b ^ 11000110b = 01000011b
-10000101b ^ 11000111b = 01000010b
-10000101b ^ 11001000b = 01001101b
-10000101b ^ 11001001b = 01001100b
-10000101b ^ 11001010b = 01001111b
-10000101b ^ 11001011b = 01001110b
-10000101b ^ 11001100b = 01001001b
-10000101b ^ 11001101b = 01001000b
-10000101b ^ 11001110b = 01001011b
-10000101b ^ 11001111b = 01001010b
-10000101b ^ 11010000b = 01010101b
-10000101b ^ 11010001b = 01010100b
-10000101b ^ 11010010b = 01010111b
-10000101b ^ 11010011b = 01010110b
-10000101b ^ 11010100b = 01010001b
-10000101b ^ 11010101b = 01010000b
-10000101b ^ 11010110b = 01010011b
-10000101b ^ 11010111b = 01010010b
-10000101b ^ 11011000b = 01011101b
-10000101b ^ 11011001b = 01011100b
-10000101b ^ 11011010b = 01011111b
-10000101b ^ 11011011b = 01011110b
-10000101b ^ 11011100b = 01011001b
-10000101b ^ 11011101b = 01011000b
-10000101b ^ 11011110b = 01011011b
-10000101b ^ 11011111b = 01011010b
-10000101b ^ 11100000b = 01100101b
-10000101b ^ 11100001b = 01100100b
-10000101b ^ 11100010b = 01100111b
-10000101b ^ 11100011b = 01100110b
-10000101b ^ 11100100b = 01100001b
-10000101b ^ 11100101b = 01100000b
-10000101b ^ 11100110b = 01100011b
-10000101b ^ 11100111b = 01100010b
-10000101b ^ 11101000b = 01101101b
-10000101b ^ 11101001b = 01101100b
-10000101b ^ 11101010b = 01101111b
-10000101b ^ 11101011b = 01101110b
-10000101b ^ 11101100b = 01101001b
-10000101b ^ 11101101b = 01101000b
-10000101b ^ 11101110b = 01101011b
-10000101b ^ 11101111b = 01101010b
-10000101b ^ 11110000b = 01110101b
-10000101b ^ 11110001b = 01110100b
-10000101b ^ 11110010b = 01110111b
-10000101b ^ 11110011b = 01110110b
-10000101b ^ 11110100b = 01110001b
-10000101b ^ 11110101b = 01110000b
-10000101b ^ 11110110b = 01110011b
-10000101b ^ 11110111b = 01110010b
-10000101b ^ 11111000b = 01111101b
-10000101b ^ 11111001b = 01111100b
-10000101b ^ 11111010b = 01111111b
-10000101b ^ 11111011b = 01111110b
-10000101b ^ 11111100b = 01111001b
-10000101b ^ 11111101b = 01111000b
-10000101b ^ 11111110b = 01111011b
-10000101b ^ 11111111b = 01111010b
-10000101b ^ 00000000b = 10000101b
-10000101b ^ 00000001b = 10000100b
-10000101b ^ 00000010b = 10000111b
-10000101b ^ 00000011b = 10000110b
-10000101b ^ 00000100b = 10000001b
-10000101b ^ 00000101b = 10000000b
-10000101b ^ 00000110b = 10000011b
-10000101b ^ 00000111b = 10000010b
-10000101b ^ 00001000b = 10001101b
-10000101b ^ 00001001b = 10001100b
-10000101b ^ 00001010b = 10001111b
-10000101b ^ 00001011b = 10001110b
-10000101b ^ 00001100b = 10001001b
-10000101b ^ 00001101b = 10001000b
-10000101b ^ 00001110b = 10001011b
-10000101b ^ 00001111b = 10001010b
-10000101b ^ 00010000b = 10010101b
-10000101b ^ 00010001b = 10010100b
-10000101b ^ 00010010b = 10010111b
-10000101b ^ 00010011b = 10010110b
-10000101b ^ 00010100b = 10010001b
-10000101b ^ 00010101b = 10010000b
-10000101b ^ 00010110b = 10010011b
-10000101b ^ 00010111b = 10010010b
-10000101b ^ 00011000b = 10011101b
-10000101b ^ 00011001b = 10011100b
-10000101b ^ 00011010b = 10011111b
-10000101b ^ 00011011b = 10011110b
-10000101b ^ 00011100b = 10011001b
-10000101b ^ 00011101b = 10011000b
-10000101b ^ 00011110b = 10011011b
-10000101b ^ 00011111b = 10011010b
-10000101b ^ 00100000b = 10100101b
-10000101b ^ 00100001b = 10100100b
-10000101b ^ 00100010b = 10100111b
-10000101b ^ 00100011b = 10100110b
-10000101b ^ 00100100b = 10100001b
-10000101b ^ 00100101b = 10100000b
-10000101b ^ 00100110b = 10100011b
-10000101b ^ 00100111b = 10100010b
-10000101b ^ 00101000b = 10101101b
-10000101b ^ 00101001b = 10101100b
-10000101b ^ 00101010b = 10101111b
-10000101b ^ 00101011b = 10101110b
-10000101b ^ 00101100b = 10101001b
-10000101b ^ 00101101b = 10101000b
-10000101b ^ 00101110b = 10101011b
-10000101b ^ 00101111b = 10101010b
-10000101b ^ 00110000b = 10110101b
-10000101b ^ 00110001b = 10110100b
-10000101b ^ 00110010b = 10110111b
-10000101b ^ 00110011b = 10110110b
-10000101b ^ 00110100b = 10110001b
-10000101b ^ 00110101b = 10110000b
-10000101b ^ 00110110b = 10110011b
-10000101b ^ 00110111b = 10110010b
-10000101b ^ 00111000b = 10111101b
-10000101b ^ 00111001b = 10111100b
-10000101b ^ 00111010b = 10111111b
-10000101b ^ 00111011b = 10111110b
-10000101b ^ 00111100b = 10111001b
-10000101b ^ 00111101b = 10111000b
-10000101b ^ 00111110b = 10111011b
-10000101b ^ 00111111b = 10111010b
-10000101b ^ 01000000b = 11000101b
-10000101b ^ 01000001b = 11000100b
-10000101b ^ 01000010b = 11000111b
-10000101b ^ 01000011b = 11000110b
-10000101b ^ 01000100b = 11000001b
-10000101b ^ 01000101b = 11000000b
-10000101b ^ 01000110b = 11000011b
-10000101b ^ 01000111b = 11000010b
-10000101b ^ 01001000b = 11001101b
-10000101b ^ 01001001b = 11001100b
-10000101b ^ 01001010b = 11001111b
-10000101b ^ 01001011b = 11001110b
-10000101b ^ 01001100b = 11001001b
-10000101b ^ 01001101b = 11001000b
-10000101b ^ 01001110b = 11001011b
-10000101b ^ 01001111b = 11001010b
-10000101b ^ 01010000b = 11010101b
-10000101b ^ 01010001b = 11010100b
-10000101b ^ 01010010b = 11010111b
-10000101b ^ 01010011b = 11010110b
-10000101b ^ 01010100b = 11010001b
-10000101b ^ 01010101b = 11010000b
-10000101b ^ 01010110b = 11010011b
-10000101b ^ 01010111b = 11010010b
-10000101b ^ 01011000b = 11011101b
-10000101b ^ 01011001b = 11011100b
-10000101b ^ 01011010b = 11011111b
-10000101b ^ 01011011b = 11011110b
-10000101b ^ 01011100b = 11011001b
-10000101b ^ 01011101b = 11011000b
-10000101b ^ 01011110b = 11011011b
-10000101b ^ 01011111b = 11011010b
-10000101b ^ 01100000b = 11100101b
-10000101b ^ 01100001b = 11100100b
-10000101b ^ 01100010b = 11100111b
-10000101b ^ 01100011b = 11100110b
-10000101b ^ 01100100b = 11100001b
-10000101b ^ 01100101b = 11100000b
-10000101b ^ 01100110b = 11100011b
-10000101b ^ 01100111b = 11100010b
-10000101b ^ 01101000b = 11101101b
-10000101b ^ 01101001b = 11101100b
-10000101b ^ 01101010b = 11101111b
-10000101b ^ 01101011b = 11101110b
-10000101b ^ 01101100b = 11101001b
-10000101b ^ 01101101b = 11101000b
-10000101b ^ 01101110b = 11101011b
-10000101b ^ 01101111b = 11101010b
-10000101b ^ 01110000b = 11110101b
-10000101b ^ 01110001b = 11110100b
-10000101b ^ 01110010b = 11110111b
-10000101b ^ 01110011b = 11110110b
-10000101b ^ 01110100b = 11110001b
-10000101b ^ 01110101b = 11110000b
-10000101b ^ 01110110b = 11110011b
-10000101b ^ 01110111b = 11110010b
-10000101b ^ 01111000b = 11111101b
-10000101b ^ 01111001b = 11111100b
-10000101b ^ 01111010b = 11111111b
-10000101b ^ 01111011b = 11111110b
-10000101b ^ 01111100b = 11111001b
-10000101b ^ 01111101b = 11111000b
-10000101b ^ 01111110b = 11111011b
-10000110b ^ 10000000b = 00000110b
-10000110b ^ 10000001b = 00000111b
-10000110b ^ 10000010b = 00000100b
-10000110b ^ 10000011b = 00000101b
-10000110b ^ 10000100b = 00000010b
-10000110b ^ 10000101b = 00000011b
-10000110b ^ 10000110b = 00000000b
-10000110b ^ 10000111b = 00000001b
-10000110b ^ 10001000b = 00001110b
-10000110b ^ 10001001b = 00001111b
-10000110b ^ 10001010b = 00001100b
-10000110b ^ 10001011b = 00001101b
-10000110b ^ 10001100b = 00001010b
-10000110b ^ 10001101b = 00001011b
-10000110b ^ 10001110b = 00001000b
-10000110b ^ 10001111b = 00001001b
-10000110b ^ 10010000b = 00010110b
-10000110b ^ 10010001b = 00010111b
-10000110b ^ 10010010b = 00010100b
-10000110b ^ 10010011b = 00010101b
-10000110b ^ 10010100b = 00010010b
-10000110b ^ 10010101b = 00010011b
-10000110b ^ 10010110b = 00010000b
-10000110b ^ 10010111b = 00010001b
-10000110b ^ 10011000b = 00011110b
-10000110b ^ 10011001b = 00011111b
-10000110b ^ 10011010b = 00011100b
-10000110b ^ 10011011b = 00011101b
-10000110b ^ 10011100b = 00011010b
-10000110b ^ 10011101b = 00011011b
-10000110b ^ 10011110b = 00011000b
-10000110b ^ 10011111b = 00011001b
-10000110b ^ 10100000b = 00100110b
-10000110b ^ 10100001b = 00100111b
-10000110b ^ 10100010b = 00100100b
-10000110b ^ 10100011b = 00100101b
-10000110b ^ 10100100b = 00100010b
-10000110b ^ 10100101b = 00100011b
-10000110b ^ 10100110b = 00100000b
-10000110b ^ 10100111b = 00100001b
-10000110b ^ 10101000b = 00101110b
-10000110b ^ 10101001b = 00101111b
-10000110b ^ 10101010b = 00101100b
-10000110b ^ 10101011b = 00101101b
-10000110b ^ 10101100b = 00101010b
-10000110b ^ 10101101b = 00101011b
-10000110b ^ 10101110b = 00101000b
-10000110b ^ 10101111b = 00101001b
-10000110b ^ 10110000b = 00110110b
-10000110b ^ 10110001b = 00110111b
-10000110b ^ 10110010b = 00110100b
-10000110b ^ 10110011b = 00110101b
-10000110b ^ 10110100b = 00110010b
-10000110b ^ 10110101b = 00110011b
-10000110b ^ 10110110b = 00110000b
-10000110b ^ 10110111b = 00110001b
-10000110b ^ 10111000b = 00111110b
-10000110b ^ 10111001b = 00111111b
-10000110b ^ 10111010b = 00111100b
-10000110b ^ 10111011b = 00111101b
-10000110b ^ 10111100b = 00111010b
-10000110b ^ 10111101b = 00111011b
-10000110b ^ 10111110b = 00111000b
-10000110b ^ 10111111b = 00111001b
-10000110b ^ 11000000b = 01000110b
-10000110b ^ 11000001b = 01000111b
-10000110b ^ 11000010b = 01000100b
-10000110b ^ 11000011b = 01000101b
-10000110b ^ 11000100b = 01000010b
-10000110b ^ 11000101b = 01000011b
-10000110b ^ 11000110b = 01000000b
-10000110b ^ 11000111b = 01000001b
-10000110b ^ 11001000b = 01001110b
-10000110b ^ 11001001b = 01001111b
-10000110b ^ 11001010b = 01001100b
-10000110b ^ 11001011b = 01001101b
-10000110b ^ 11001100b = 01001010b
-10000110b ^ 11001101b = 01001011b
-10000110b ^ 11001110b = 01001000b
-10000110b ^ 11001111b = 01001001b
-10000110b ^ 11010000b = 01010110b
-10000110b ^ 11010001b = 01010111b
-10000110b ^ 11010010b = 01010100b
-10000110b ^ 11010011b = 01010101b
-10000110b ^ 11010100b = 01010010b
-10000110b ^ 11010101b = 01010011b
-10000110b ^ 11010110b = 01010000b
-10000110b ^ 11010111b = 01010001b
-10000110b ^ 11011000b = 01011110b
-10000110b ^ 11011001b = 01011111b
-10000110b ^ 11011010b = 01011100b
-10000110b ^ 11011011b = 01011101b
-10000110b ^ 11011100b = 01011010b
-10000110b ^ 11011101b = 01011011b
-10000110b ^ 11011110b = 01011000b
-10000110b ^ 11011111b = 01011001b
-10000110b ^ 11100000b = 01100110b
-10000110b ^ 11100001b = 01100111b
-10000110b ^ 11100010b = 01100100b
-10000110b ^ 11100011b = 01100101b
-10000110b ^ 11100100b = 01100010b
-10000110b ^ 11100101b = 01100011b
-10000110b ^ 11100110b = 01100000b
-10000110b ^ 11100111b = 01100001b
-10000110b ^ 11101000b = 01101110b
-10000110b ^ 11101001b = 01101111b
-10000110b ^ 11101010b = 01101100b
-10000110b ^ 11101011b = 01101101b
-10000110b ^ 11101100b = 01101010b
-10000110b ^ 11101101b = 01101011b
-10000110b ^ 11101110b = 01101000b
-10000110b ^ 11101111b = 01101001b
-10000110b ^ 11110000b = 01110110b
-10000110b ^ 11110001b = 01110111b
-10000110b ^ 11110010b = 01110100b
-10000110b ^ 11110011b = 01110101b
-10000110b ^ 11110100b = 01110010b
-10000110b ^ 11110101b = 01110011b
-10000110b ^ 11110110b = 01110000b
-10000110b ^ 11110111b = 01110001b
-10000110b ^ 11111000b = 01111110b
-10000110b ^ 11111001b = 01111111b
-10000110b ^ 11111010b = 01111100b
-10000110b ^ 11111011b = 01111101b
-10000110b ^ 11111100b = 01111010b
-10000110b ^ 11111101b = 01111011b
-10000110b ^ 11111110b = 01111000b
-10000110b ^ 11111111b = 01111001b
-10000110b ^ 00000000b = 10000110b
-10000110b ^ 00000001b = 10000111b
-10000110b ^ 00000010b = 10000100b
-10000110b ^ 00000011b = 10000101b
-10000110b ^ 00000100b = 10000010b
-10000110b ^ 00000101b = 10000011b
-10000110b ^ 00000110b = 10000000b
-10000110b ^ 00000111b = 10000001b
-10000110b ^ 00001000b = 10001110b
-10000110b ^ 00001001b = 10001111b
-10000110b ^ 00001010b = 10001100b
-10000110b ^ 00001011b = 10001101b
-10000110b ^ 00001100b = 10001010b
-10000110b ^ 00001101b = 10001011b
-10000110b ^ 00001110b = 10001000b
-10000110b ^ 00001111b = 10001001b
-10000110b ^ 00010000b = 10010110b
-10000110b ^ 00010001b = 10010111b
-10000110b ^ 00010010b = 10010100b
-10000110b ^ 00010011b = 10010101b
-10000110b ^ 00010100b = 10010010b
-10000110b ^ 00010101b = 10010011b
-10000110b ^ 00010110b = 10010000b
-10000110b ^ 00010111b = 10010001b
-10000110b ^ 00011000b = 10011110b
-10000110b ^ 00011001b = 10011111b
-10000110b ^ 00011010b = 10011100b
-10000110b ^ 00011011b = 10011101b
-10000110b ^ 00011100b = 10011010b
-10000110b ^ 00011101b = 10011011b
-10000110b ^ 00011110b = 10011000b
-10000110b ^ 00011111b = 10011001b
-10000110b ^ 00100000b = 10100110b
-10000110b ^ 00100001b = 10100111b
-10000110b ^ 00100010b = 10100100b
-10000110b ^ 00100011b = 10100101b
-10000110b ^ 00100100b = 10100010b
-10000110b ^ 00100101b = 10100011b
-10000110b ^ 00100110b = 10100000b
-10000110b ^ 00100111b = 10100001b
-10000110b ^ 00101000b = 10101110b
-10000110b ^ 00101001b = 10101111b
-10000110b ^ 00101010b = 10101100b
-10000110b ^ 00101011b = 10101101b
-10000110b ^ 00101100b = 10101010b
-10000110b ^ 00101101b = 10101011b
-10000110b ^ 00101110b = 10101000b
-10000110b ^ 00101111b = 10101001b
-10000110b ^ 00110000b = 10110110b
-10000110b ^ 00110001b = 10110111b
-10000110b ^ 00110010b = 10110100b
-10000110b ^ 00110011b = 10110101b
-10000110b ^ 00110100b = 10110010b
-10000110b ^ 00110101b = 10110011b
-10000110b ^ 00110110b = 10110000b
-10000110b ^ 00110111b = 10110001b
-10000110b ^ 00111000b = 10111110b
-10000110b ^ 00111001b = 10111111b
-10000110b ^ 00111010b = 10111100b
-10000110b ^ 00111011b = 10111101b
-10000110b ^ 00111100b = 10111010b
-10000110b ^ 00111101b = 10111011b
-10000110b ^ 00111110b = 10111000b
-10000110b ^ 00111111b = 10111001b
-10000110b ^ 01000000b = 11000110b
-10000110b ^ 01000001b = 11000111b
-10000110b ^ 01000010b = 11000100b
-10000110b ^ 01000011b = 11000101b
-10000110b ^ 01000100b = 11000010b
-10000110b ^ 01000101b = 11000011b
-10000110b ^ 01000110b = 11000000b
-10000110b ^ 01000111b = 11000001b
-10000110b ^ 01001000b = 11001110b
-10000110b ^ 01001001b = 11001111b
-10000110b ^ 01001010b = 11001100b
-10000110b ^ 01001011b = 11001101b
-10000110b ^ 01001100b = 11001010b
-10000110b ^ 01001101b = 11001011b
-10000110b ^ 01001110b = 11001000b
-10000110b ^ 01001111b = 11001001b
-10000110b ^ 01010000b = 11010110b
-10000110b ^ 01010001b = 11010111b
-10000110b ^ 01010010b = 11010100b
-10000110b ^ 01010011b = 11010101b
-10000110b ^ 01010100b = 11010010b
-10000110b ^ 01010101b = 11010011b
-10000110b ^ 01010110b = 11010000b
-10000110b ^ 01010111b = 11010001b
-10000110b ^ 01011000b = 11011110b
-10000110b ^ 01011001b = 11011111b
-10000110b ^ 01011010b = 11011100b
-10000110b ^ 01011011b = 11011101b
-10000110b ^ 01011100b = 11011010b
-10000110b ^ 01011101b = 11011011b
-10000110b ^ 01011110b = 11011000b
-10000110b ^ 01011111b = 11011001b
-10000110b ^ 01100000b = 11100110b
-10000110b ^ 01100001b = 11100111b
-10000110b ^ 01100010b = 11100100b
-10000110b ^ 01100011b = 11100101b
-10000110b ^ 01100100b = 11100010b
-10000110b ^ 01100101b = 11100011b
-10000110b ^ 01100110b = 11100000b
-10000110b ^ 01100111b = 11100001b
-10000110b ^ 01101000b = 11101110b
-10000110b ^ 01101001b = 11101111b
-10000110b ^ 01101010b = 11101100b
-10000110b ^ 01101011b = 11101101b
-10000110b ^ 01101100b = 11101010b
-10000110b ^ 01101101b = 11101011b
-10000110b ^ 01101110b = 11101000b
-10000110b ^ 01101111b = 11101001b
-10000110b ^ 01110000b = 11110110b
-10000110b ^ 01110001b = 11110111b
-10000110b ^ 01110010b = 11110100b
-10000110b ^ 01110011b = 11110101b
-10000110b ^ 01110100b = 11110010b
-10000110b ^ 01110101b = 11110011b
-10000110b ^ 01110110b = 11110000b
-10000110b ^ 01110111b = 11110001b
-10000110b ^ 01111000b = 11111110b
-10000110b ^ 01111001b = 11111111b
-10000110b ^ 01111010b = 11111100b
-10000110b ^ 01111011b = 11111101b
-10000110b ^ 01111100b = 11111010b
-10000110b ^ 01111101b = 11111011b
-10000110b ^ 01111110b = 11111000b
-10000111b ^ 10000000b = 00000111b
-10000111b ^ 10000001b = 00000110b
-10000111b ^ 10000010b = 00000101b
-10000111b ^ 10000011b = 00000100b
-10000111b ^ 10000100b = 00000011b
-10000111b ^ 10000101b = 00000010b
-10000111b ^ 10000110b = 00000001b
-10000111b ^ 10000111b = 00000000b
-10000111b ^ 10001000b = 00001111b
-10000111b ^ 10001001b = 00001110b
-10000111b ^ 10001010b = 00001101b
-10000111b ^ 10001011b = 00001100b
-10000111b ^ 10001100b = 00001011b
-10000111b ^ 10001101b = 00001010b
-10000111b ^ 10001110b = 00001001b
-10000111b ^ 10001111b = 00001000b
-10000111b ^ 10010000b = 00010111b
-10000111b ^ 10010001b = 00010110b
-10000111b ^ 10010010b = 00010101b
-10000111b ^ 10010011b = 00010100b
-10000111b ^ 10010100b = 00010011b
-10000111b ^ 10010101b = 00010010b
-10000111b ^ 10010110b = 00010001b
-10000111b ^ 10010111b = 00010000b
-10000111b ^ 10011000b = 00011111b
-10000111b ^ 10011001b = 00011110b
-10000111b ^ 10011010b = 00011101b
-10000111b ^ 10011011b = 00011100b
-10000111b ^ 10011100b = 00011011b
-10000111b ^ 10011101b = 00011010b
-10000111b ^ 10011110b = 00011001b
-10000111b ^ 10011111b = 00011000b
-10000111b ^ 10100000b = 00100111b
-10000111b ^ 10100001b = 00100110b
-10000111b ^ 10100010b = 00100101b
-10000111b ^ 10100011b = 00100100b
-10000111b ^ 10100100b = 00100011b
-10000111b ^ 10100101b = 00100010b
-10000111b ^ 10100110b = 00100001b
-10000111b ^ 10100111b = 00100000b
-10000111b ^ 10101000b = 00101111b
-10000111b ^ 10101001b = 00101110b
-10000111b ^ 10101010b = 00101101b
-10000111b ^ 10101011b = 00101100b
-10000111b ^ 10101100b = 00101011b
-10000111b ^ 10101101b = 00101010b
-10000111b ^ 10101110b = 00101001b
-10000111b ^ 10101111b = 00101000b
-10000111b ^ 10110000b = 00110111b
-10000111b ^ 10110001b = 00110110b
-10000111b ^ 10110010b = 00110101b
-10000111b ^ 10110011b = 00110100b
-10000111b ^ 10110100b = 00110011b
-10000111b ^ 10110101b = 00110010b
-10000111b ^ 10110110b = 00110001b
-10000111b ^ 10110111b = 00110000b
-10000111b ^ 10111000b = 00111111b
-10000111b ^ 10111001b = 00111110b
-10000111b ^ 10111010b = 00111101b
-10000111b ^ 10111011b = 00111100b
-10000111b ^ 10111100b = 00111011b
-10000111b ^ 10111101b = 00111010b
-10000111b ^ 10111110b = 00111001b
-10000111b ^ 10111111b = 00111000b
-10000111b ^ 11000000b = 01000111b
-10000111b ^ 11000001b = 01000110b
-10000111b ^ 11000010b = 01000101b
-10000111b ^ 11000011b = 01000100b
-10000111b ^ 11000100b = 01000011b
-10000111b ^ 11000101b = 01000010b
-10000111b ^ 11000110b = 01000001b
-10000111b ^ 11000111b = 01000000b
-10000111b ^ 11001000b = 01001111b
-10000111b ^ 11001001b = 01001110b
-10000111b ^ 11001010b = 01001101b
-10000111b ^ 11001011b = 01001100b
-10000111b ^ 11001100b = 01001011b
-10000111b ^ 11001101b = 01001010b
-10000111b ^ 11001110b = 01001001b
-10000111b ^ 11001111b = 01001000b
-10000111b ^ 11010000b = 01010111b
-10000111b ^ 11010001b = 01010110b
-10000111b ^ 11010010b = 01010101b
-10000111b ^ 11010011b = 01010100b
-10000111b ^ 11010100b = 01010011b
-10000111b ^ 11010101b = 01010010b
-10000111b ^ 11010110b = 01010001b
-10000111b ^ 11010111b = 01010000b
-10000111b ^ 11011000b = 01011111b
-10000111b ^ 11011001b = 01011110b
-10000111b ^ 11011010b = 01011101b
-10000111b ^ 11011011b = 01011100b
-10000111b ^ 11011100b = 01011011b
-10000111b ^ 11011101b = 01011010b
-10000111b ^ 11011110b = 01011001b
-10000111b ^ 11011111b = 01011000b
-10000111b ^ 11100000b = 01100111b
-10000111b ^ 11100001b = 01100110b
-10000111b ^ 11100010b = 01100101b
-10000111b ^ 11100011b = 01100100b
-10000111b ^ 11100100b = 01100011b
-10000111b ^ 11100101b = 01100010b
-10000111b ^ 11100110b = 01100001b
-10000111b ^ 11100111b = 01100000b
-10000111b ^ 11101000b = 01101111b
-10000111b ^ 11101001b = 01101110b
-10000111b ^ 11101010b = 01101101b
-10000111b ^ 11101011b = 01101100b
-10000111b ^ 11101100b = 01101011b
-10000111b ^ 11101101b = 01101010b
-10000111b ^ 11101110b = 01101001b
-10000111b ^ 11101111b = 01101000b
-10000111b ^ 11110000b = 01110111b
-10000111b ^ 11110001b = 01110110b
-10000111b ^ 11110010b = 01110101b
-10000111b ^ 11110011b = 01110100b
-10000111b ^ 11110100b = 01110011b
-10000111b ^ 11110101b = 01110010b
-10000111b ^ 11110110b = 01110001b
-10000111b ^ 11110111b = 01110000b
-10000111b ^ 11111000b = 01111111b
-10000111b ^ 11111001b = 01111110b
-10000111b ^ 11111010b = 01111101b
-10000111b ^ 11111011b = 01111100b
-10000111b ^ 11111100b = 01111011b
-10000111b ^ 11111101b = 01111010b
-10000111b ^ 11111110b = 01111001b
-10000111b ^ 11111111b = 01111000b
-10000111b ^ 00000000b = 10000111b
-10000111b ^ 00000001b = 10000110b
-10000111b ^ 00000010b = 10000101b
-10000111b ^ 00000011b = 10000100b
-10000111b ^ 00000100b = 10000011b
-10000111b ^ 00000101b = 10000010b
-10000111b ^ 00000110b = 10000001b
-10000111b ^ 00000111b = 10000000b
-10000111b ^ 00001000b = 10001111b
-10000111b ^ 00001001b = 10001110b
-10000111b ^ 00001010b = 10001101b
-10000111b ^ 00001011b = 10001100b
-10000111b ^ 00001100b = 10001011b
-10000111b ^ 00001101b = 10001010b
-10000111b ^ 00001110b = 10001001b
-10000111b ^ 00001111b = 10001000b
-10000111b ^ 00010000b = 10010111b
-10000111b ^ 00010001b = 10010110b
-10000111b ^ 00010010b = 10010101b
-10000111b ^ 00010011b = 10010100b
-10000111b ^ 00010100b = 10010011b
-10000111b ^ 00010101b = 10010010b
-10000111b ^ 00010110b = 10010001b
-10000111b ^ 00010111b = 10010000b
-10000111b ^ 00011000b = 10011111b
-10000111b ^ 00011001b = 10011110b
-10000111b ^ 00011010b = 10011101b
-10000111b ^ 00011011b = 10011100b
-10000111b ^ 00011100b = 10011011b
-10000111b ^ 00011101b = 10011010b
-10000111b ^ 00011110b = 10011001b
-10000111b ^ 00011111b = 10011000b
-10000111b ^ 00100000b = 10100111b
-10000111b ^ 00100001b = 10100110b
-10000111b ^ 00100010b = 10100101b
-10000111b ^ 00100011b = 10100100b
-10000111b ^ 00100100b = 10100011b
-10000111b ^ 00100101b = 10100010b
-10000111b ^ 00100110b = 10100001b
-10000111b ^ 00100111b = 10100000b
-10000111b ^ 00101000b = 10101111b
-10000111b ^ 00101001b = 10101110b
-10000111b ^ 00101010b = 10101101b
-10000111b ^ 00101011b = 10101100b
-10000111b ^ 00101100b = 10101011b
-10000111b ^ 00101101b = 10101010b
-10000111b ^ 00101110b = 10101001b
-10000111b ^ 00101111b = 10101000b
-10000111b ^ 00110000b = 10110111b
-10000111b ^ 00110001b = 10110110b
-10000111b ^ 00110010b = 10110101b
-10000111b ^ 00110011b = 10110100b
-10000111b ^ 00110100b = 10110011b
-10000111b ^ 00110101b = 10110010b
-10000111b ^ 00110110b = 10110001b
-10000111b ^ 00110111b = 10110000b
-10000111b ^ 00111000b = 10111111b
-10000111b ^ 00111001b = 10111110b
-10000111b ^ 00111010b = 10111101b
-10000111b ^ 00111011b = 10111100b
-10000111b ^ 00111100b = 10111011b
-10000111b ^ 00111101b = 10111010b
-10000111b ^ 00111110b = 10111001b
-10000111b ^ 00111111b = 10111000b
-10000111b ^ 01000000b = 11000111b
-10000111b ^ 01000001b = 11000110b
-10000111b ^ 01000010b = 11000101b
-10000111b ^ 01000011b = 11000100b
-10000111b ^ 01000100b = 11000011b
-10000111b ^ 01000101b = 11000010b
-10000111b ^ 01000110b = 11000001b
-10000111b ^ 01000111b = 11000000b
-10000111b ^ 01001000b = 11001111b
-10000111b ^ 01001001b = 11001110b
-10000111b ^ 01001010b = 11001101b
-10000111b ^ 01001011b = 11001100b
-10000111b ^ 01001100b = 11001011b
-10000111b ^ 01001101b = 11001010b
-10000111b ^ 01001110b = 11001001b
-10000111b ^ 01001111b = 11001000b
-10000111b ^ 01010000b = 11010111b
-10000111b ^ 01010001b = 11010110b
-10000111b ^ 01010010b = 11010101b
-10000111b ^ 01010011b = 11010100b
-10000111b ^ 01010100b = 11010011b
-10000111b ^ 01010101b = 11010010b
-10000111b ^ 01010110b = 11010001b
-10000111b ^ 01010111b = 11010000b
-10000111b ^ 01011000b = 11011111b
-10000111b ^ 01011001b = 11011110b
-10000111b ^ 01011010b = 11011101b
-10000111b ^ 01011011b = 11011100b
-10000111b ^ 01011100b = 11011011b
-10000111b ^ 01011101b = 11011010b
-10000111b ^ 01011110b = 11011001b
-10000111b ^ 01011111b = 11011000b
-10000111b ^ 01100000b = 11100111b
-10000111b ^ 01100001b = 11100110b
-10000111b ^ 01100010b = 11100101b
-10000111b ^ 01100011b = 11100100b
-10000111b ^ 01100100b = 11100011b
-10000111b ^ 01100101b = 11100010b
-10000111b ^ 01100110b = 11100001b
-10000111b ^ 01100111b = 11100000b
-10000111b ^ 01101000b = 11101111b
-10000111b ^ 01101001b = 11101110b
-10000111b ^ 01101010b = 11101101b
-10000111b ^ 01101011b = 11101100b
-10000111b ^ 01101100b = 11101011b
-10000111b ^ 01101101b = 11101010b
-10000111b ^ 01101110b = 11101001b
-10000111b ^ 01101111b = 11101000b
-10000111b ^ 01110000b = 11110111b
-10000111b ^ 01110001b = 11110110b
-10000111b ^ 01110010b = 11110101b
-10000111b ^ 01110011b = 11110100b
-10000111b ^ 01110100b = 11110011b
-10000111b ^ 01110101b = 11110010b
-10000111b ^ 01110110b = 11110001b
-10000111b ^ 01110111b = 11110000b
-10000111b ^ 01111000b = 11111111b
-10000111b ^ 01111001b = 11111110b
-10000111b ^ 01111010b = 11111101b
-10000111b ^ 01111011b = 11111100b
-10000111b ^ 01111100b = 11111011b
-10000111b ^ 01111101b = 11111010b
-10000111b ^ 01111110b = 11111001b
-10001000b ^ 10000000b = 00001000b
-10001000b ^ 10000001b = 00001001b
-10001000b ^ 10000010b = 00001010b
-10001000b ^ 10000011b = 00001011b
-10001000b ^ 10000100b = 00001100b
-10001000b ^ 10000101b = 00001101b
-10001000b ^ 10000110b = 00001110b
-10001000b ^ 10000111b = 00001111b
-10001000b ^ 10001000b = 00000000b
-10001000b ^ 10001001b = 00000001b
-10001000b ^ 10001010b = 00000010b
-10001000b ^ 10001011b = 00000011b
-10001000b ^ 10001100b = 00000100b
-10001000b ^ 10001101b = 00000101b
-10001000b ^ 10001110b = 00000110b
-10001000b ^ 10001111b = 00000111b
-10001000b ^ 10010000b = 00011000b
-10001000b ^ 10010001b = 00011001b
-10001000b ^ 10010010b = 00011010b
-10001000b ^ 10010011b = 00011011b
-10001000b ^ 10010100b = 00011100b
-10001000b ^ 10010101b = 00011101b
-10001000b ^ 10010110b = 00011110b
-10001000b ^ 10010111b = 00011111b
-10001000b ^ 10011000b = 00010000b
-10001000b ^ 10011001b = 00010001b
-10001000b ^ 10011010b = 00010010b
-10001000b ^ 10011011b = 00010011b
-10001000b ^ 10011100b = 00010100b
-10001000b ^ 10011101b = 00010101b
-10001000b ^ 10011110b = 00010110b
-10001000b ^ 10011111b = 00010111b
-10001000b ^ 10100000b = 00101000b
-10001000b ^ 10100001b = 00101001b
-10001000b ^ 10100010b = 00101010b
-10001000b ^ 10100011b = 00101011b
-10001000b ^ 10100100b = 00101100b
-10001000b ^ 10100101b = 00101101b
-10001000b ^ 10100110b = 00101110b
-10001000b ^ 10100111b = 00101111b
-10001000b ^ 10101000b = 00100000b
-10001000b ^ 10101001b = 00100001b
-10001000b ^ 10101010b = 00100010b
-10001000b ^ 10101011b = 00100011b
-10001000b ^ 10101100b = 00100100b
-10001000b ^ 10101101b = 00100101b
-10001000b ^ 10101110b = 00100110b
-10001000b ^ 10101111b = 00100111b
-10001000b ^ 10110000b = 00111000b
-10001000b ^ 10110001b = 00111001b
-10001000b ^ 10110010b = 00111010b
-10001000b ^ 10110011b = 00111011b
-10001000b ^ 10110100b = 00111100b
-10001000b ^ 10110101b = 00111101b
-10001000b ^ 10110110b = 00111110b
-10001000b ^ 10110111b = 00111111b
-10001000b ^ 10111000b = 00110000b
-10001000b ^ 10111001b = 00110001b
-10001000b ^ 10111010b = 00110010b
-10001000b ^ 10111011b = 00110011b
-10001000b ^ 10111100b = 00110100b
-10001000b ^ 10111101b = 00110101b
-10001000b ^ 10111110b = 00110110b
-10001000b ^ 10111111b = 00110111b
-10001000b ^ 11000000b = 01001000b
-10001000b ^ 11000001b = 01001001b
-10001000b ^ 11000010b = 01001010b
-10001000b ^ 11000011b = 01001011b
-10001000b ^ 11000100b = 01001100b
-10001000b ^ 11000101b = 01001101b
-10001000b ^ 11000110b = 01001110b
-10001000b ^ 11000111b = 01001111b
-10001000b ^ 11001000b = 01000000b
-10001000b ^ 11001001b = 01000001b
-10001000b ^ 11001010b = 01000010b
-10001000b ^ 11001011b = 01000011b
-10001000b ^ 11001100b = 01000100b
-10001000b ^ 11001101b = 01000101b
-10001000b ^ 11001110b = 01000110b
-10001000b ^ 11001111b = 01000111b
-10001000b ^ 11010000b = 01011000b
-10001000b ^ 11010001b = 01011001b
-10001000b ^ 11010010b = 01011010b
-10001000b ^ 11010011b = 01011011b
-10001000b ^ 11010100b = 01011100b
-10001000b ^ 11010101b = 01011101b
-10001000b ^ 11010110b = 01011110b
-10001000b ^ 11010111b = 01011111b
-10001000b ^ 11011000b = 01010000b
-10001000b ^ 11011001b = 01010001b
-10001000b ^ 11011010b = 01010010b
-10001000b ^ 11011011b = 01010011b
-10001000b ^ 11011100b = 01010100b
-10001000b ^ 11011101b = 01010101b
-10001000b ^ 11011110b = 01010110b
-10001000b ^ 11011111b = 01010111b
-10001000b ^ 11100000b = 01101000b
-10001000b ^ 11100001b = 01101001b
-10001000b ^ 11100010b = 01101010b
-10001000b ^ 11100011b = 01101011b
-10001000b ^ 11100100b = 01101100b
-10001000b ^ 11100101b = 01101101b
-10001000b ^ 11100110b = 01101110b
-10001000b ^ 11100111b = 01101111b
-10001000b ^ 11101000b = 01100000b
-10001000b ^ 11101001b = 01100001b
-10001000b ^ 11101010b = 01100010b
-10001000b ^ 11101011b = 01100011b
-10001000b ^ 11101100b = 01100100b
-10001000b ^ 11101101b = 01100101b
-10001000b ^ 11101110b = 01100110b
-10001000b ^ 11101111b = 01100111b
-10001000b ^ 11110000b = 01111000b
-10001000b ^ 11110001b = 01111001b
-10001000b ^ 11110010b = 01111010b
-10001000b ^ 11110011b = 01111011b
-10001000b ^ 11110100b = 01111100b
-10001000b ^ 11110101b = 01111101b
-10001000b ^ 11110110b = 01111110b
-10001000b ^ 11110111b = 01111111b
-10001000b ^ 11111000b = 01110000b
-10001000b ^ 11111001b = 01110001b
-10001000b ^ 11111010b = 01110010b
-10001000b ^ 11111011b = 01110011b
-10001000b ^ 11111100b = 01110100b
-10001000b ^ 11111101b = 01110101b
-10001000b ^ 11111110b = 01110110b
-10001000b ^ 11111111b = 01110111b
-10001000b ^ 00000000b = 10001000b
-10001000b ^ 00000001b = 10001001b
-10001000b ^ 00000010b = 10001010b
-10001000b ^ 00000011b = 10001011b
-10001000b ^ 00000100b = 10001100b
-10001000b ^ 00000101b = 10001101b
-10001000b ^ 00000110b = 10001110b
-10001000b ^ 00000111b = 10001111b
-10001000b ^ 00001000b = 10000000b
-10001000b ^ 00001001b = 10000001b
-10001000b ^ 00001010b = 10000010b
-10001000b ^ 00001011b = 10000011b
-10001000b ^ 00001100b = 10000100b
-10001000b ^ 00001101b = 10000101b
-10001000b ^ 00001110b = 10000110b
-10001000b ^ 00001111b = 10000111b
-10001000b ^ 00010000b = 10011000b
-10001000b ^ 00010001b = 10011001b
-10001000b ^ 00010010b = 10011010b
-10001000b ^ 00010011b = 10011011b
-10001000b ^ 00010100b = 10011100b
-10001000b ^ 00010101b = 10011101b
-10001000b ^ 00010110b = 10011110b
-10001000b ^ 00010111b = 10011111b
-10001000b ^ 00011000b = 10010000b
-10001000b ^ 00011001b = 10010001b
-10001000b ^ 00011010b = 10010010b
-10001000b ^ 00011011b = 10010011b
-10001000b ^ 00011100b = 10010100b
-10001000b ^ 00011101b = 10010101b
-10001000b ^ 00011110b = 10010110b
-10001000b ^ 00011111b = 10010111b
-10001000b ^ 00100000b = 10101000b
-10001000b ^ 00100001b = 10101001b
-10001000b ^ 00100010b = 10101010b
-10001000b ^ 00100011b = 10101011b
-10001000b ^ 00100100b = 10101100b
-10001000b ^ 00100101b = 10101101b
-10001000b ^ 00100110b = 10101110b
-10001000b ^ 00100111b = 10101111b
-10001000b ^ 00101000b = 10100000b
-10001000b ^ 00101001b = 10100001b
-10001000b ^ 00101010b = 10100010b
-10001000b ^ 00101011b = 10100011b
-10001000b ^ 00101100b = 10100100b
-10001000b ^ 00101101b = 10100101b
-10001000b ^ 00101110b = 10100110b
-10001000b ^ 00101111b = 10100111b
-10001000b ^ 00110000b = 10111000b
-10001000b ^ 00110001b = 10111001b
-10001000b ^ 00110010b = 10111010b
-10001000b ^ 00110011b = 10111011b
-10001000b ^ 00110100b = 10111100b
-10001000b ^ 00110101b = 10111101b
-10001000b ^ 00110110b = 10111110b
-10001000b ^ 00110111b = 10111111b
-10001000b ^ 00111000b = 10110000b
-10001000b ^ 00111001b = 10110001b
-10001000b ^ 00111010b = 10110010b
-10001000b ^ 00111011b = 10110011b
-10001000b ^ 00111100b = 10110100b
-10001000b ^ 00111101b = 10110101b
-10001000b ^ 00111110b = 10110110b
-10001000b ^ 00111111b = 10110111b
-10001000b ^ 01000000b = 11001000b
-10001000b ^ 01000001b = 11001001b
-10001000b ^ 01000010b = 11001010b
-10001000b ^ 01000011b = 11001011b
-10001000b ^ 01000100b = 11001100b
-10001000b ^ 01000101b = 11001101b
-10001000b ^ 01000110b = 11001110b
-10001000b ^ 01000111b = 11001111b
-10001000b ^ 01001000b = 11000000b
-10001000b ^ 01001001b = 11000001b
-10001000b ^ 01001010b = 11000010b
-10001000b ^ 01001011b = 11000011b
-10001000b ^ 01001100b = 11000100b
-10001000b ^ 01001101b = 11000101b
-10001000b ^ 01001110b = 11000110b
-10001000b ^ 01001111b = 11000111b
-10001000b ^ 01010000b = 11011000b
-10001000b ^ 01010001b = 11011001b
-10001000b ^ 01010010b = 11011010b
-10001000b ^ 01010011b = 11011011b
-10001000b ^ 01010100b = 11011100b
-10001000b ^ 01010101b = 11011101b
-10001000b ^ 01010110b = 11011110b
-10001000b ^ 01010111b = 11011111b
-10001000b ^ 01011000b = 11010000b
-10001000b ^ 01011001b = 11010001b
-10001000b ^ 01011010b = 11010010b
-10001000b ^ 01011011b = 11010011b
-10001000b ^ 01011100b = 11010100b
-10001000b ^ 01011101b = 11010101b
-10001000b ^ 01011110b = 11010110b
-10001000b ^ 01011111b = 11010111b
-10001000b ^ 01100000b = 11101000b
-10001000b ^ 01100001b = 11101001b
-10001000b ^ 01100010b = 11101010b
-10001000b ^ 01100011b = 11101011b
-10001000b ^ 01100100b = 11101100b
-10001000b ^ 01100101b = 11101101b
-10001000b ^ 01100110b = 11101110b
-10001000b ^ 01100111b = 11101111b
-10001000b ^ 01101000b = 11100000b
-10001000b ^ 01101001b = 11100001b
-10001000b ^ 01101010b = 11100010b
-10001000b ^ 01101011b = 11100011b
-10001000b ^ 01101100b = 11100100b
-10001000b ^ 01101101b = 11100101b
-10001000b ^ 01101110b = 11100110b
-10001000b ^ 01101111b = 11100111b
-10001000b ^ 01110000b = 11111000b
-10001000b ^ 01110001b = 11111001b
-10001000b ^ 01110010b = 11111010b
-10001000b ^ 01110011b = 11111011b
-10001000b ^ 01110100b = 11111100b
-10001000b ^ 01110101b = 11111101b
-10001000b ^ 01110110b = 11111110b
-10001000b ^ 01110111b = 11111111b
-10001000b ^ 01111000b = 11110000b
-10001000b ^ 01111001b = 11110001b
-10001000b ^ 01111010b = 11110010b
-10001000b ^ 01111011b = 11110011b
-10001000b ^ 01111100b = 11110100b
-10001000b ^ 01111101b = 11110101b
-10001000b ^ 01111110b = 11110110b
-10001001b ^ 10000000b = 00001001b
-10001001b ^ 10000001b = 00001000b
-10001001b ^ 10000010b = 00001011b
-10001001b ^ 10000011b = 00001010b
-10001001b ^ 10000100b = 00001101b
-10001001b ^ 10000101b = 00001100b
-10001001b ^ 10000110b = 00001111b
-10001001b ^ 10000111b = 00001110b
-10001001b ^ 10001000b = 00000001b
-10001001b ^ 10001001b = 00000000b
-10001001b ^ 10001010b = 00000011b
-10001001b ^ 10001011b = 00000010b
-10001001b ^ 10001100b = 00000101b
-10001001b ^ 10001101b = 00000100b
-10001001b ^ 10001110b = 00000111b
-10001001b ^ 10001111b = 00000110b
-10001001b ^ 10010000b = 00011001b
-10001001b ^ 10010001b = 00011000b
-10001001b ^ 10010010b = 00011011b
-10001001b ^ 10010011b = 00011010b
-10001001b ^ 10010100b = 00011101b
-10001001b ^ 10010101b = 00011100b
-10001001b ^ 10010110b = 00011111b
-10001001b ^ 10010111b = 00011110b
-10001001b ^ 10011000b = 00010001b
-10001001b ^ 10011001b = 00010000b
-10001001b ^ 10011010b = 00010011b
-10001001b ^ 10011011b = 00010010b
-10001001b ^ 10011100b = 00010101b
-10001001b ^ 10011101b = 00010100b
-10001001b ^ 10011110b = 00010111b
-10001001b ^ 10011111b = 00010110b
-10001001b ^ 10100000b = 00101001b
-10001001b ^ 10100001b = 00101000b
-10001001b ^ 10100010b = 00101011b
-10001001b ^ 10100011b = 00101010b
-10001001b ^ 10100100b = 00101101b
-10001001b ^ 10100101b = 00101100b
-10001001b ^ 10100110b = 00101111b
-10001001b ^ 10100111b = 00101110b
-10001001b ^ 10101000b = 00100001b
-10001001b ^ 10101001b = 00100000b
-10001001b ^ 10101010b = 00100011b
-10001001b ^ 10101011b = 00100010b
-10001001b ^ 10101100b = 00100101b
-10001001b ^ 10101101b = 00100100b
-10001001b ^ 10101110b = 00100111b
-10001001b ^ 10101111b = 00100110b
-10001001b ^ 10110000b = 00111001b
-10001001b ^ 10110001b = 00111000b
-10001001b ^ 10110010b = 00111011b
-10001001b ^ 10110011b = 00111010b
-10001001b ^ 10110100b = 00111101b
-10001001b ^ 10110101b = 00111100b
-10001001b ^ 10110110b = 00111111b
-10001001b ^ 10110111b = 00111110b
-10001001b ^ 10111000b = 00110001b
-10001001b ^ 10111001b = 00110000b
-10001001b ^ 10111010b = 00110011b
-10001001b ^ 10111011b = 00110010b
-10001001b ^ 10111100b = 00110101b
-10001001b ^ 10111101b = 00110100b
-10001001b ^ 10111110b = 00110111b
-10001001b ^ 10111111b = 00110110b
-10001001b ^ 11000000b = 01001001b
-10001001b ^ 11000001b = 01001000b
-10001001b ^ 11000010b = 01001011b
-10001001b ^ 11000011b = 01001010b
-10001001b ^ 11000100b = 01001101b
-10001001b ^ 11000101b = 01001100b
-10001001b ^ 11000110b = 01001111b
-10001001b ^ 11000111b = 01001110b
-10001001b ^ 11001000b = 01000001b
-10001001b ^ 11001001b = 01000000b
-10001001b ^ 11001010b = 01000011b
-10001001b ^ 11001011b = 01000010b
-10001001b ^ 11001100b = 01000101b
-10001001b ^ 11001101b = 01000100b
-10001001b ^ 11001110b = 01000111b
-10001001b ^ 11001111b = 01000110b
-10001001b ^ 11010000b = 01011001b
-10001001b ^ 11010001b = 01011000b
-10001001b ^ 11010010b = 01011011b
-10001001b ^ 11010011b = 01011010b
-10001001b ^ 11010100b = 01011101b
-10001001b ^ 11010101b = 01011100b
-10001001b ^ 11010110b = 01011111b
-10001001b ^ 11010111b = 01011110b
-10001001b ^ 11011000b = 01010001b
-10001001b ^ 11011001b = 01010000b
-10001001b ^ 11011010b = 01010011b
-10001001b ^ 11011011b = 01010010b
-10001001b ^ 11011100b = 01010101b
-10001001b ^ 11011101b = 01010100b
-10001001b ^ 11011110b = 01010111b
-10001001b ^ 11011111b = 01010110b
-10001001b ^ 11100000b = 01101001b
-10001001b ^ 11100001b = 01101000b
-10001001b ^ 11100010b = 01101011b
-10001001b ^ 11100011b = 01101010b
-10001001b ^ 11100100b = 01101101b
-10001001b ^ 11100101b = 01101100b
-10001001b ^ 11100110b = 01101111b
-10001001b ^ 11100111b = 01101110b
-10001001b ^ 11101000b = 01100001b
-10001001b ^ 11101001b = 01100000b
-10001001b ^ 11101010b = 01100011b
-10001001b ^ 11101011b = 01100010b
-10001001b ^ 11101100b = 01100101b
-10001001b ^ 11101101b = 01100100b
-10001001b ^ 11101110b = 01100111b
-10001001b ^ 11101111b = 01100110b
-10001001b ^ 11110000b = 01111001b
-10001001b ^ 11110001b = 01111000b
-10001001b ^ 11110010b = 01111011b
-10001001b ^ 11110011b = 01111010b
-10001001b ^ 11110100b = 01111101b
-10001001b ^ 11110101b = 01111100b
-10001001b ^ 11110110b = 01111111b
-10001001b ^ 11110111b = 01111110b
-10001001b ^ 11111000b = 01110001b
-10001001b ^ 11111001b = 01110000b
-10001001b ^ 11111010b = 01110011b
-10001001b ^ 11111011b = 01110010b
-10001001b ^ 11111100b = 01110101b
-10001001b ^ 11111101b = 01110100b
-10001001b ^ 11111110b = 01110111b
-10001001b ^ 11111111b = 01110110b
-10001001b ^ 00000000b = 10001001b
-10001001b ^ 00000001b = 10001000b
-10001001b ^ 00000010b = 10001011b
-10001001b ^ 00000011b = 10001010b
-10001001b ^ 00000100b = 10001101b
-10001001b ^ 00000101b = 10001100b
-10001001b ^ 00000110b = 10001111b
-10001001b ^ 00000111b = 10001110b
-10001001b ^ 00001000b = 10000001b
-10001001b ^ 00001001b = 10000000b
-10001001b ^ 00001010b = 10000011b
-10001001b ^ 00001011b = 10000010b
-10001001b ^ 00001100b = 10000101b
-10001001b ^ 00001101b = 10000100b
-10001001b ^ 00001110b = 10000111b
-10001001b ^ 00001111b = 10000110b
-10001001b ^ 00010000b = 10011001b
-10001001b ^ 00010001b = 10011000b
-10001001b ^ 00010010b = 10011011b
-10001001b ^ 00010011b = 10011010b
-10001001b ^ 00010100b = 10011101b
-10001001b ^ 00010101b = 10011100b
-10001001b ^ 00010110b = 10011111b
-10001001b ^ 00010111b = 10011110b
-10001001b ^ 00011000b = 10010001b
-10001001b ^ 00011001b = 10010000b
-10001001b ^ 00011010b = 10010011b
-10001001b ^ 00011011b = 10010010b
-10001001b ^ 00011100b = 10010101b
-10001001b ^ 00011101b = 10010100b
-10001001b ^ 00011110b = 10010111b
-10001001b ^ 00011111b = 10010110b
-10001001b ^ 00100000b = 10101001b
-10001001b ^ 00100001b = 10101000b
-10001001b ^ 00100010b = 10101011b
-10001001b ^ 00100011b = 10101010b
-10001001b ^ 00100100b = 10101101b
-10001001b ^ 00100101b = 10101100b
-10001001b ^ 00100110b = 10101111b
-10001001b ^ 00100111b = 10101110b
-10001001b ^ 00101000b = 10100001b
-10001001b ^ 00101001b = 10100000b
-10001001b ^ 00101010b = 10100011b
-10001001b ^ 00101011b = 10100010b
-10001001b ^ 00101100b = 10100101b
-10001001b ^ 00101101b = 10100100b
-10001001b ^ 00101110b = 10100111b
-10001001b ^ 00101111b = 10100110b
-10001001b ^ 00110000b = 10111001b
-10001001b ^ 00110001b = 10111000b
-10001001b ^ 00110010b = 10111011b
-10001001b ^ 00110011b = 10111010b
-10001001b ^ 00110100b = 10111101b
-10001001b ^ 00110101b = 10111100b
-10001001b ^ 00110110b = 10111111b
-10001001b ^ 00110111b = 10111110b
-10001001b ^ 00111000b = 10110001b
-10001001b ^ 00111001b = 10110000b
-10001001b ^ 00111010b = 10110011b
-10001001b ^ 00111011b = 10110010b
-10001001b ^ 00111100b = 10110101b
-10001001b ^ 00111101b = 10110100b
-10001001b ^ 00111110b = 10110111b
-10001001b ^ 00111111b = 10110110b
-10001001b ^ 01000000b = 11001001b
-10001001b ^ 01000001b = 11001000b
-10001001b ^ 01000010b = 11001011b
-10001001b ^ 01000011b = 11001010b
-10001001b ^ 01000100b = 11001101b
-10001001b ^ 01000101b = 11001100b
-10001001b ^ 01000110b = 11001111b
-10001001b ^ 01000111b = 11001110b
-10001001b ^ 01001000b = 11000001b
-10001001b ^ 01001001b = 11000000b
-10001001b ^ 01001010b = 11000011b
-10001001b ^ 01001011b = 11000010b
-10001001b ^ 01001100b = 11000101b
-10001001b ^ 01001101b = 11000100b
-10001001b ^ 01001110b = 11000111b
-10001001b ^ 01001111b = 11000110b
-10001001b ^ 01010000b = 11011001b
-10001001b ^ 01010001b = 11011000b
-10001001b ^ 01010010b = 11011011b
-10001001b ^ 01010011b = 11011010b
-10001001b ^ 01010100b = 11011101b
-10001001b ^ 01010101b = 11011100b
-10001001b ^ 01010110b = 11011111b
-10001001b ^ 01010111b = 11011110b
-10001001b ^ 01011000b = 11010001b
-10001001b ^ 01011001b = 11010000b
-10001001b ^ 01011010b = 11010011b
-10001001b ^ 01011011b = 11010010b
-10001001b ^ 01011100b = 11010101b
-10001001b ^ 01011101b = 11010100b
-10001001b ^ 01011110b = 11010111b
-10001001b ^ 01011111b = 11010110b
-10001001b ^ 01100000b = 11101001b
-10001001b ^ 01100001b = 11101000b
-10001001b ^ 01100010b = 11101011b
-10001001b ^ 01100011b = 11101010b
-10001001b ^ 01100100b = 11101101b
-10001001b ^ 01100101b = 11101100b
-10001001b ^ 01100110b = 11101111b
-10001001b ^ 01100111b = 11101110b
-10001001b ^ 01101000b = 11100001b
-10001001b ^ 01101001b = 11100000b
-10001001b ^ 01101010b = 11100011b
-10001001b ^ 01101011b = 11100010b
-10001001b ^ 01101100b = 11100101b
-10001001b ^ 01101101b = 11100100b
-10001001b ^ 01101110b = 11100111b
-10001001b ^ 01101111b = 11100110b
-10001001b ^ 01110000b = 11111001b
-10001001b ^ 01110001b = 11111000b
-10001001b ^ 01110010b = 11111011b
-10001001b ^ 01110011b = 11111010b
-10001001b ^ 01110100b = 11111101b
-10001001b ^ 01110101b = 11111100b
-10001001b ^ 01110110b = 11111111b
-10001001b ^ 01110111b = 11111110b
-10001001b ^ 01111000b = 11110001b
-10001001b ^ 01111001b = 11110000b
-10001001b ^ 01111010b = 11110011b
-10001001b ^ 01111011b = 11110010b
-10001001b ^ 01111100b = 11110101b
-10001001b ^ 01111101b = 11110100b
-10001001b ^ 01111110b = 11110111b
-10001010b ^ 10000000b = 00001010b
-10001010b ^ 10000001b = 00001011b
-10001010b ^ 10000010b = 00001000b
-10001010b ^ 10000011b = 00001001b
-10001010b ^ 10000100b = 00001110b
-10001010b ^ 10000101b = 00001111b
-10001010b ^ 10000110b = 00001100b
-10001010b ^ 10000111b = 00001101b
-10001010b ^ 10001000b = 00000010b
-10001010b ^ 10001001b = 00000011b
-10001010b ^ 10001010b = 00000000b
-10001010b ^ 10001011b = 00000001b
-10001010b ^ 10001100b = 00000110b
-10001010b ^ 10001101b = 00000111b
-10001010b ^ 10001110b = 00000100b
-10001010b ^ 10001111b = 00000101b
-10001010b ^ 10010000b = 00011010b
-10001010b ^ 10010001b = 00011011b
-10001010b ^ 10010010b = 00011000b
-10001010b ^ 10010011b = 00011001b
-10001010b ^ 10010100b = 00011110b
-10001010b ^ 10010101b = 00011111b
-10001010b ^ 10010110b = 00011100b
-10001010b ^ 10010111b = 00011101b
-10001010b ^ 10011000b = 00010010b
-10001010b ^ 10011001b = 00010011b
-10001010b ^ 10011010b = 00010000b
-10001010b ^ 10011011b = 00010001b
-10001010b ^ 10011100b = 00010110b
-10001010b ^ 10011101b = 00010111b
-10001010b ^ 10011110b = 00010100b
-10001010b ^ 10011111b = 00010101b
-10001010b ^ 10100000b = 00101010b
-10001010b ^ 10100001b = 00101011b
-10001010b ^ 10100010b = 00101000b
-10001010b ^ 10100011b = 00101001b
-10001010b ^ 10100100b = 00101110b
-10001010b ^ 10100101b = 00101111b
-10001010b ^ 10100110b = 00101100b
-10001010b ^ 10100111b = 00101101b
-10001010b ^ 10101000b = 00100010b
-10001010b ^ 10101001b = 00100011b
-10001010b ^ 10101010b = 00100000b
-10001010b ^ 10101011b = 00100001b
-10001010b ^ 10101100b = 00100110b
-10001010b ^ 10101101b = 00100111b
-10001010b ^ 10101110b = 00100100b
-10001010b ^ 10101111b = 00100101b
-10001010b ^ 10110000b = 00111010b
-10001010b ^ 10110001b = 00111011b
-10001010b ^ 10110010b = 00111000b
-10001010b ^ 10110011b = 00111001b
-10001010b ^ 10110100b = 00111110b
-10001010b ^ 10110101b = 00111111b
-10001010b ^ 10110110b = 00111100b
-10001010b ^ 10110111b = 00111101b
-10001010b ^ 10111000b = 00110010b
-10001010b ^ 10111001b = 00110011b
-10001010b ^ 10111010b = 00110000b
-10001010b ^ 10111011b = 00110001b
-10001010b ^ 10111100b = 00110110b
-10001010b ^ 10111101b = 00110111b
-10001010b ^ 10111110b = 00110100b
-10001010b ^ 10111111b = 00110101b
-10001010b ^ 11000000b = 01001010b
-10001010b ^ 11000001b = 01001011b
-10001010b ^ 11000010b = 01001000b
-10001010b ^ 11000011b = 01001001b
-10001010b ^ 11000100b = 01001110b
-10001010b ^ 11000101b = 01001111b
-10001010b ^ 11000110b = 01001100b
-10001010b ^ 11000111b = 01001101b
-10001010b ^ 11001000b = 01000010b
-10001010b ^ 11001001b = 01000011b
-10001010b ^ 11001010b = 01000000b
-10001010b ^ 11001011b = 01000001b
-10001010b ^ 11001100b = 01000110b
-10001010b ^ 11001101b = 01000111b
-10001010b ^ 11001110b = 01000100b
-10001010b ^ 11001111b = 01000101b
-10001010b ^ 11010000b = 01011010b
-10001010b ^ 11010001b = 01011011b
-10001010b ^ 11010010b = 01011000b
-10001010b ^ 11010011b = 01011001b
-10001010b ^ 11010100b = 01011110b
-10001010b ^ 11010101b = 01011111b
-10001010b ^ 11010110b = 01011100b
-10001010b ^ 11010111b = 01011101b
-10001010b ^ 11011000b = 01010010b
-10001010b ^ 11011001b = 01010011b
-10001010b ^ 11011010b = 01010000b
-10001010b ^ 11011011b = 01010001b
-10001010b ^ 11011100b = 01010110b
-10001010b ^ 11011101b = 01010111b
-10001010b ^ 11011110b = 01010100b
-10001010b ^ 11011111b = 01010101b
-10001010b ^ 11100000b = 01101010b
-10001010b ^ 11100001b = 01101011b
-10001010b ^ 11100010b = 01101000b
-10001010b ^ 11100011b = 01101001b
-10001010b ^ 11100100b = 01101110b
-10001010b ^ 11100101b = 01101111b
-10001010b ^ 11100110b = 01101100b
-10001010b ^ 11100111b = 01101101b
-10001010b ^ 11101000b = 01100010b
-10001010b ^ 11101001b = 01100011b
-10001010b ^ 11101010b = 01100000b
-10001010b ^ 11101011b = 01100001b
-10001010b ^ 11101100b = 01100110b
-10001010b ^ 11101101b = 01100111b
-10001010b ^ 11101110b = 01100100b
-10001010b ^ 11101111b = 01100101b
-10001010b ^ 11110000b = 01111010b
-10001010b ^ 11110001b = 01111011b
-10001010b ^ 11110010b = 01111000b
-10001010b ^ 11110011b = 01111001b
-10001010b ^ 11110100b = 01111110b
-10001010b ^ 11110101b = 01111111b
-10001010b ^ 11110110b = 01111100b
-10001010b ^ 11110111b = 01111101b
-10001010b ^ 11111000b = 01110010b
-10001010b ^ 11111001b = 01110011b
-10001010b ^ 11111010b = 01110000b
-10001010b ^ 11111011b = 01110001b
-10001010b ^ 11111100b = 01110110b
-10001010b ^ 11111101b = 01110111b
-10001010b ^ 11111110b = 01110100b
-10001010b ^ 11111111b = 01110101b
-10001010b ^ 00000000b = 10001010b
-10001010b ^ 00000001b = 10001011b
-10001010b ^ 00000010b = 10001000b
-10001010b ^ 00000011b = 10001001b
-10001010b ^ 00000100b = 10001110b
-10001010b ^ 00000101b = 10001111b
-10001010b ^ 00000110b = 10001100b
-10001010b ^ 00000111b = 10001101b
-10001010b ^ 00001000b = 10000010b
-10001010b ^ 00001001b = 10000011b
-10001010b ^ 00001010b = 10000000b
-10001010b ^ 00001011b = 10000001b
-10001010b ^ 00001100b = 10000110b
-10001010b ^ 00001101b = 10000111b
-10001010b ^ 00001110b = 10000100b
-10001010b ^ 00001111b = 10000101b
-10001010b ^ 00010000b = 10011010b
-10001010b ^ 00010001b = 10011011b
-10001010b ^ 00010010b = 10011000b
-10001010b ^ 00010011b = 10011001b
-10001010b ^ 00010100b = 10011110b
-10001010b ^ 00010101b = 10011111b
-10001010b ^ 00010110b = 10011100b
-10001010b ^ 00010111b = 10011101b
-10001010b ^ 00011000b = 10010010b
-10001010b ^ 00011001b = 10010011b
-10001010b ^ 00011010b = 10010000b
-10001010b ^ 00011011b = 10010001b
-10001010b ^ 00011100b = 10010110b
-10001010b ^ 00011101b = 10010111b
-10001010b ^ 00011110b = 10010100b
-10001010b ^ 00011111b = 10010101b
-10001010b ^ 00100000b = 10101010b
-10001010b ^ 00100001b = 10101011b
-10001010b ^ 00100010b = 10101000b
-10001010b ^ 00100011b = 10101001b
-10001010b ^ 00100100b = 10101110b
-10001010b ^ 00100101b = 10101111b
-10001010b ^ 00100110b = 10101100b
-10001010b ^ 00100111b = 10101101b
-10001010b ^ 00101000b = 10100010b
-10001010b ^ 00101001b = 10100011b
-10001010b ^ 00101010b = 10100000b
-10001010b ^ 00101011b = 10100001b
-10001010b ^ 00101100b = 10100110b
-10001010b ^ 00101101b = 10100111b
-10001010b ^ 00101110b = 10100100b
-10001010b ^ 00101111b = 10100101b
-10001010b ^ 00110000b = 10111010b
-10001010b ^ 00110001b = 10111011b
-10001010b ^ 00110010b = 10111000b
-10001010b ^ 00110011b = 10111001b
-10001010b ^ 00110100b = 10111110b
-10001010b ^ 00110101b = 10111111b
-10001010b ^ 00110110b = 10111100b
-10001010b ^ 00110111b = 10111101b
-10001010b ^ 00111000b = 10110010b
-10001010b ^ 00111001b = 10110011b
-10001010b ^ 00111010b = 10110000b
-10001010b ^ 00111011b = 10110001b
-10001010b ^ 00111100b = 10110110b
-10001010b ^ 00111101b = 10110111b
-10001010b ^ 00111110b = 10110100b
-10001010b ^ 00111111b = 10110101b
-10001010b ^ 01000000b = 11001010b
-10001010b ^ 01000001b = 11001011b
-10001010b ^ 01000010b = 11001000b
-10001010b ^ 01000011b = 11001001b
-10001010b ^ 01000100b = 11001110b
-10001010b ^ 01000101b = 11001111b
-10001010b ^ 01000110b = 11001100b
-10001010b ^ 01000111b = 11001101b
-10001010b ^ 01001000b = 11000010b
-10001010b ^ 01001001b = 11000011b
-10001010b ^ 01001010b = 11000000b
-10001010b ^ 01001011b = 11000001b
-10001010b ^ 01001100b = 11000110b
-10001010b ^ 01001101b = 11000111b
-10001010b ^ 01001110b = 11000100b
-10001010b ^ 01001111b = 11000101b
-10001010b ^ 01010000b = 11011010b
-10001010b ^ 01010001b = 11011011b
-10001010b ^ 01010010b = 11011000b
-10001010b ^ 01010011b = 11011001b
-10001010b ^ 01010100b = 11011110b
-10001010b ^ 01010101b = 11011111b
-10001010b ^ 01010110b = 11011100b
-10001010b ^ 01010111b = 11011101b
-10001010b ^ 01011000b = 11010010b
-10001010b ^ 01011001b = 11010011b
-10001010b ^ 01011010b = 11010000b
-10001010b ^ 01011011b = 11010001b
-10001010b ^ 01011100b = 11010110b
-10001010b ^ 01011101b = 11010111b
-10001010b ^ 01011110b = 11010100b
-10001010b ^ 01011111b = 11010101b
-10001010b ^ 01100000b = 11101010b
-10001010b ^ 01100001b = 11101011b
-10001010b ^ 01100010b = 11101000b
-10001010b ^ 01100011b = 11101001b
-10001010b ^ 01100100b = 11101110b
-10001010b ^ 01100101b = 11101111b
-10001010b ^ 01100110b = 11101100b
-10001010b ^ 01100111b = 11101101b
-10001010b ^ 01101000b = 11100010b
-10001010b ^ 01101001b = 11100011b
-10001010b ^ 01101010b = 11100000b
-10001010b ^ 01101011b = 11100001b
-10001010b ^ 01101100b = 11100110b
-10001010b ^ 01101101b = 11100111b
-10001010b ^ 01101110b = 11100100b
-10001010b ^ 01101111b = 11100101b
-10001010b ^ 01110000b = 11111010b
-10001010b ^ 01110001b = 11111011b
-10001010b ^ 01110010b = 11111000b
-10001010b ^ 01110011b = 11111001b
-10001010b ^ 01110100b = 11111110b
-10001010b ^ 01110101b = 11111111b
-10001010b ^ 01110110b = 11111100b
-10001010b ^ 01110111b = 11111101b
-10001010b ^ 01111000b = 11110010b
-10001010b ^ 01111001b = 11110011b
-10001010b ^ 01111010b = 11110000b
-10001010b ^ 01111011b = 11110001b
-10001010b ^ 01111100b = 11110110b
-10001010b ^ 01111101b = 11110111b
-10001010b ^ 01111110b = 11110100b
-10001011b ^ 10000000b = 00001011b
-10001011b ^ 10000001b = 00001010b
-10001011b ^ 10000010b = 00001001b
-10001011b ^ 10000011b = 00001000b
-10001011b ^ 10000100b = 00001111b
-10001011b ^ 10000101b = 00001110b
-10001011b ^ 10000110b = 00001101b
-10001011b ^ 10000111b = 00001100b
-10001011b ^ 10001000b = 00000011b
-10001011b ^ 10001001b = 00000010b
-10001011b ^ 10001010b = 00000001b
-10001011b ^ 10001011b = 00000000b
-10001011b ^ 10001100b = 00000111b
-10001011b ^ 10001101b = 00000110b
-10001011b ^ 10001110b = 00000101b
-10001011b ^ 10001111b = 00000100b
-10001011b ^ 10010000b = 00011011b
-10001011b ^ 10010001b = 00011010b
-10001011b ^ 10010010b = 00011001b
-10001011b ^ 10010011b = 00011000b
-10001011b ^ 10010100b = 00011111b
-10001011b ^ 10010101b = 00011110b
-10001011b ^ 10010110b = 00011101b
-10001011b ^ 10010111b = 00011100b
-10001011b ^ 10011000b = 00010011b
-10001011b ^ 10011001b = 00010010b
-10001011b ^ 10011010b = 00010001b
-10001011b ^ 10011011b = 00010000b
-10001011b ^ 10011100b = 00010111b
-10001011b ^ 10011101b = 00010110b
-10001011b ^ 10011110b = 00010101b
-10001011b ^ 10011111b = 00010100b
-10001011b ^ 10100000b = 00101011b
-10001011b ^ 10100001b = 00101010b
-10001011b ^ 10100010b = 00101001b
-10001011b ^ 10100011b = 00101000b
-10001011b ^ 10100100b = 00101111b
-10001011b ^ 10100101b = 00101110b
-10001011b ^ 10100110b = 00101101b
-10001011b ^ 10100111b = 00101100b
-10001011b ^ 10101000b = 00100011b
-10001011b ^ 10101001b = 00100010b
-10001011b ^ 10101010b = 00100001b
-10001011b ^ 10101011b = 00100000b
-10001011b ^ 10101100b = 00100111b
-10001011b ^ 10101101b = 00100110b
-10001011b ^ 10101110b = 00100101b
-10001011b ^ 10101111b = 00100100b
-10001011b ^ 10110000b = 00111011b
-10001011b ^ 10110001b = 00111010b
-10001011b ^ 10110010b = 00111001b
-10001011b ^ 10110011b = 00111000b
-10001011b ^ 10110100b = 00111111b
-10001011b ^ 10110101b = 00111110b
-10001011b ^ 10110110b = 00111101b
-10001011b ^ 10110111b = 00111100b
-10001011b ^ 10111000b = 00110011b
-10001011b ^ 10111001b = 00110010b
-10001011b ^ 10111010b = 00110001b
-10001011b ^ 10111011b = 00110000b
-10001011b ^ 10111100b = 00110111b
-10001011b ^ 10111101b = 00110110b
-10001011b ^ 10111110b = 00110101b
-10001011b ^ 10111111b = 00110100b
-10001011b ^ 11000000b = 01001011b
-10001011b ^ 11000001b = 01001010b
-10001011b ^ 11000010b = 01001001b
-10001011b ^ 11000011b = 01001000b
-10001011b ^ 11000100b = 01001111b
-10001011b ^ 11000101b = 01001110b
-10001011b ^ 11000110b = 01001101b
-10001011b ^ 11000111b = 01001100b
-10001011b ^ 11001000b = 01000011b
-10001011b ^ 11001001b = 01000010b
-10001011b ^ 11001010b = 01000001b
-10001011b ^ 11001011b = 01000000b
-10001011b ^ 11001100b = 01000111b
-10001011b ^ 11001101b = 01000110b
-10001011b ^ 11001110b = 01000101b
-10001011b ^ 11001111b = 01000100b
-10001011b ^ 11010000b = 01011011b
-10001011b ^ 11010001b = 01011010b
-10001011b ^ 11010010b = 01011001b
-10001011b ^ 11010011b = 01011000b
-10001011b ^ 11010100b = 01011111b
-10001011b ^ 11010101b = 01011110b
-10001011b ^ 11010110b = 01011101b
-10001011b ^ 11010111b = 01011100b
-10001011b ^ 11011000b = 01010011b
-10001011b ^ 11011001b = 01010010b
-10001011b ^ 11011010b = 01010001b
-10001011b ^ 11011011b = 01010000b
-10001011b ^ 11011100b = 01010111b
-10001011b ^ 11011101b = 01010110b
-10001011b ^ 11011110b = 01010101b
-10001011b ^ 11011111b = 01010100b
-10001011b ^ 11100000b = 01101011b
-10001011b ^ 11100001b = 01101010b
-10001011b ^ 11100010b = 01101001b
-10001011b ^ 11100011b = 01101000b
-10001011b ^ 11100100b = 01101111b
-10001011b ^ 11100101b = 01101110b
-10001011b ^ 11100110b = 01101101b
-10001011b ^ 11100111b = 01101100b
-10001011b ^ 11101000b = 01100011b
-10001011b ^ 11101001b = 01100010b
-10001011b ^ 11101010b = 01100001b
-10001011b ^ 11101011b = 01100000b
-10001011b ^ 11101100b = 01100111b
-10001011b ^ 11101101b = 01100110b
-10001011b ^ 11101110b = 01100101b
-10001011b ^ 11101111b = 01100100b
-10001011b ^ 11110000b = 01111011b
-10001011b ^ 11110001b = 01111010b
-10001011b ^ 11110010b = 01111001b
-10001011b ^ 11110011b = 01111000b
-10001011b ^ 11110100b = 01111111b
-10001011b ^ 11110101b = 01111110b
-10001011b ^ 11110110b = 01111101b
-10001011b ^ 11110111b = 01111100b
-10001011b ^ 11111000b = 01110011b
-10001011b ^ 11111001b = 01110010b
-10001011b ^ 11111010b = 01110001b
-10001011b ^ 11111011b = 01110000b
-10001011b ^ 11111100b = 01110111b
-10001011b ^ 11111101b = 01110110b
-10001011b ^ 11111110b = 01110101b
-10001011b ^ 11111111b = 01110100b
-10001011b ^ 00000000b = 10001011b
-10001011b ^ 00000001b = 10001010b
-10001011b ^ 00000010b = 10001001b
-10001011b ^ 00000011b = 10001000b
-10001011b ^ 00000100b = 10001111b
-10001011b ^ 00000101b = 10001110b
-10001011b ^ 00000110b = 10001101b
-10001011b ^ 00000111b = 10001100b
-10001011b ^ 00001000b = 10000011b
-10001011b ^ 00001001b = 10000010b
-10001011b ^ 00001010b = 10000001b
-10001011b ^ 00001011b = 10000000b
-10001011b ^ 00001100b = 10000111b
-10001011b ^ 00001101b = 10000110b
-10001011b ^ 00001110b = 10000101b
-10001011b ^ 00001111b = 10000100b
-10001011b ^ 00010000b = 10011011b
-10001011b ^ 00010001b = 10011010b
-10001011b ^ 00010010b = 10011001b
-10001011b ^ 00010011b = 10011000b
-10001011b ^ 00010100b = 10011111b
-10001011b ^ 00010101b = 10011110b
-10001011b ^ 00010110b = 10011101b
-10001011b ^ 00010111b = 10011100b
-10001011b ^ 00011000b = 10010011b
-10001011b ^ 00011001b = 10010010b
-10001011b ^ 00011010b = 10010001b
-10001011b ^ 00011011b = 10010000b
-10001011b ^ 00011100b = 10010111b
-10001011b ^ 00011101b = 10010110b
-10001011b ^ 00011110b = 10010101b
-10001011b ^ 00011111b = 10010100b
-10001011b ^ 00100000b = 10101011b
-10001011b ^ 00100001b = 10101010b
-10001011b ^ 00100010b = 10101001b
-10001011b ^ 00100011b = 10101000b
-10001011b ^ 00100100b = 10101111b
-10001011b ^ 00100101b = 10101110b
-10001011b ^ 00100110b = 10101101b
-10001011b ^ 00100111b = 10101100b
-10001011b ^ 00101000b = 10100011b
-10001011b ^ 00101001b = 10100010b
-10001011b ^ 00101010b = 10100001b
-10001011b ^ 00101011b = 10100000b
-10001011b ^ 00101100b = 10100111b
-10001011b ^ 00101101b = 10100110b
-10001011b ^ 00101110b = 10100101b
-10001011b ^ 00101111b = 10100100b
-10001011b ^ 00110000b = 10111011b
-10001011b ^ 00110001b = 10111010b
-10001011b ^ 00110010b = 10111001b
-10001011b ^ 00110011b = 10111000b
-10001011b ^ 00110100b = 10111111b
-10001011b ^ 00110101b = 10111110b
-10001011b ^ 00110110b = 10111101b
-10001011b ^ 00110111b = 10111100b
-10001011b ^ 00111000b = 10110011b
-10001011b ^ 00111001b = 10110010b
-10001011b ^ 00111010b = 10110001b
-10001011b ^ 00111011b = 10110000b
-10001011b ^ 00111100b = 10110111b
-10001011b ^ 00111101b = 10110110b
-10001011b ^ 00111110b = 10110101b
-10001011b ^ 00111111b = 10110100b
-10001011b ^ 01000000b = 11001011b
-10001011b ^ 01000001b = 11001010b
-10001011b ^ 01000010b = 11001001b
-10001011b ^ 01000011b = 11001000b
-10001011b ^ 01000100b = 11001111b
-10001011b ^ 01000101b = 11001110b
-10001011b ^ 01000110b = 11001101b
-10001011b ^ 01000111b = 11001100b
-10001011b ^ 01001000b = 11000011b
-10001011b ^ 01001001b = 11000010b
-10001011b ^ 01001010b = 11000001b
-10001011b ^ 01001011b = 11000000b
-10001011b ^ 01001100b = 11000111b
-10001011b ^ 01001101b = 11000110b
-10001011b ^ 01001110b = 11000101b
-10001011b ^ 01001111b = 11000100b
-10001011b ^ 01010000b = 11011011b
-10001011b ^ 01010001b = 11011010b
-10001011b ^ 01010010b = 11011001b
-10001011b ^ 01010011b = 11011000b
-10001011b ^ 01010100b = 11011111b
-10001011b ^ 01010101b = 11011110b
-10001011b ^ 01010110b = 11011101b
-10001011b ^ 01010111b = 11011100b
-10001011b ^ 01011000b = 11010011b
-10001011b ^ 01011001b = 11010010b
-10001011b ^ 01011010b = 11010001b
-10001011b ^ 01011011b = 11010000b
-10001011b ^ 01011100b = 11010111b
-10001011b ^ 01011101b = 11010110b
-10001011b ^ 01011110b = 11010101b
-10001011b ^ 01011111b = 11010100b
-10001011b ^ 01100000b = 11101011b
-10001011b ^ 01100001b = 11101010b
-10001011b ^ 01100010b = 11101001b
-10001011b ^ 01100011b = 11101000b
-10001011b ^ 01100100b = 11101111b
-10001011b ^ 01100101b = 11101110b
-10001011b ^ 01100110b = 11101101b
-10001011b ^ 01100111b = 11101100b
-10001011b ^ 01101000b = 11100011b
-10001011b ^ 01101001b = 11100010b
-10001011b ^ 01101010b = 11100001b
-10001011b ^ 01101011b = 11100000b
-10001011b ^ 01101100b = 11100111b
-10001011b ^ 01101101b = 11100110b
-10001011b ^ 01101110b = 11100101b
-10001011b ^ 01101111b = 11100100b
-10001011b ^ 01110000b = 11111011b
-10001011b ^ 01110001b = 11111010b
-10001011b ^ 01110010b = 11111001b
-10001011b ^ 01110011b = 11111000b
-10001011b ^ 01110100b = 11111111b
-10001011b ^ 01110101b = 11111110b
-10001011b ^ 01110110b = 11111101b
-10001011b ^ 01110111b = 11111100b
-10001011b ^ 01111000b = 11110011b
-10001011b ^ 01111001b = 11110010b
-10001011b ^ 01111010b = 11110001b
-10001011b ^ 01111011b = 11110000b
-10001011b ^ 01111100b = 11110111b
-10001011b ^ 01111101b = 11110110b
-10001011b ^ 01111110b = 11110101b
-10001100b ^ 10000000b = 00001100b
-10001100b ^ 10000001b = 00001101b
-10001100b ^ 10000010b = 00001110b
-10001100b ^ 10000011b = 00001111b
-10001100b ^ 10000100b = 00001000b
-10001100b ^ 10000101b = 00001001b
-10001100b ^ 10000110b = 00001010b
-10001100b ^ 10000111b = 00001011b
-10001100b ^ 10001000b = 00000100b
-10001100b ^ 10001001b = 00000101b
-10001100b ^ 10001010b = 00000110b
-10001100b ^ 10001011b = 00000111b
-10001100b ^ 10001100b = 00000000b
-10001100b ^ 10001101b = 00000001b
-10001100b ^ 10001110b = 00000010b
-10001100b ^ 10001111b = 00000011b
-10001100b ^ 10010000b = 00011100b
-10001100b ^ 10010001b = 00011101b
-10001100b ^ 10010010b = 00011110b
-10001100b ^ 10010011b = 00011111b
-10001100b ^ 10010100b = 00011000b
-10001100b ^ 10010101b = 00011001b
-10001100b ^ 10010110b = 00011010b
-10001100b ^ 10010111b = 00011011b
-10001100b ^ 10011000b = 00010100b
-10001100b ^ 10011001b = 00010101b
-10001100b ^ 10011010b = 00010110b
-10001100b ^ 10011011b = 00010111b
-10001100b ^ 10011100b = 00010000b
-10001100b ^ 10011101b = 00010001b
-10001100b ^ 10011110b = 00010010b
-10001100b ^ 10011111b = 00010011b
-10001100b ^ 10100000b = 00101100b
-10001100b ^ 10100001b = 00101101b
-10001100b ^ 10100010b = 00101110b
-10001100b ^ 10100011b = 00101111b
-10001100b ^ 10100100b = 00101000b
-10001100b ^ 10100101b = 00101001b
-10001100b ^ 10100110b = 00101010b
-10001100b ^ 10100111b = 00101011b
-10001100b ^ 10101000b = 00100100b
-10001100b ^ 10101001b = 00100101b
-10001100b ^ 10101010b = 00100110b
-10001100b ^ 10101011b = 00100111b
-10001100b ^ 10101100b = 00100000b
-10001100b ^ 10101101b = 00100001b
-10001100b ^ 10101110b = 00100010b
-10001100b ^ 10101111b = 00100011b
-10001100b ^ 10110000b = 00111100b
-10001100b ^ 10110001b = 00111101b
-10001100b ^ 10110010b = 00111110b
-10001100b ^ 10110011b = 00111111b
-10001100b ^ 10110100b = 00111000b
-10001100b ^ 10110101b = 00111001b
-10001100b ^ 10110110b = 00111010b
-10001100b ^ 10110111b = 00111011b
-10001100b ^ 10111000b = 00110100b
-10001100b ^ 10111001b = 00110101b
-10001100b ^ 10111010b = 00110110b
-10001100b ^ 10111011b = 00110111b
-10001100b ^ 10111100b = 00110000b
-10001100b ^ 10111101b = 00110001b
-10001100b ^ 10111110b = 00110010b
-10001100b ^ 10111111b = 00110011b
-10001100b ^ 11000000b = 01001100b
-10001100b ^ 11000001b = 01001101b
-10001100b ^ 11000010b = 01001110b
-10001100b ^ 11000011b = 01001111b
-10001100b ^ 11000100b = 01001000b
-10001100b ^ 11000101b = 01001001b
-10001100b ^ 11000110b = 01001010b
-10001100b ^ 11000111b = 01001011b
-10001100b ^ 11001000b = 01000100b
-10001100b ^ 11001001b = 01000101b
-10001100b ^ 11001010b = 01000110b
-10001100b ^ 11001011b = 01000111b
-10001100b ^ 11001100b = 01000000b
-10001100b ^ 11001101b = 01000001b
-10001100b ^ 11001110b = 01000010b
-10001100b ^ 11001111b = 01000011b
-10001100b ^ 11010000b = 01011100b
-10001100b ^ 11010001b = 01011101b
-10001100b ^ 11010010b = 01011110b
-10001100b ^ 11010011b = 01011111b
-10001100b ^ 11010100b = 01011000b
-10001100b ^ 11010101b = 01011001b
-10001100b ^ 11010110b = 01011010b
-10001100b ^ 11010111b = 01011011b
-10001100b ^ 11011000b = 01010100b
-10001100b ^ 11011001b = 01010101b
-10001100b ^ 11011010b = 01010110b
-10001100b ^ 11011011b = 01010111b
-10001100b ^ 11011100b = 01010000b
-10001100b ^ 11011101b = 01010001b
-10001100b ^ 11011110b = 01010010b
-10001100b ^ 11011111b = 01010011b
-10001100b ^ 11100000b = 01101100b
-10001100b ^ 11100001b = 01101101b
-10001100b ^ 11100010b = 01101110b
-10001100b ^ 11100011b = 01101111b
-10001100b ^ 11100100b = 01101000b
-10001100b ^ 11100101b = 01101001b
-10001100b ^ 11100110b = 01101010b
-10001100b ^ 11100111b = 01101011b
-10001100b ^ 11101000b = 01100100b
-10001100b ^ 11101001b = 01100101b
-10001100b ^ 11101010b = 01100110b
-10001100b ^ 11101011b = 01100111b
-10001100b ^ 11101100b = 01100000b
-10001100b ^ 11101101b = 01100001b
-10001100b ^ 11101110b = 01100010b
-10001100b ^ 11101111b = 01100011b
-10001100b ^ 11110000b = 01111100b
-10001100b ^ 11110001b = 01111101b
-10001100b ^ 11110010b = 01111110b
-10001100b ^ 11110011b = 01111111b
-10001100b ^ 11110100b = 01111000b
-10001100b ^ 11110101b = 01111001b
-10001100b ^ 11110110b = 01111010b
-10001100b ^ 11110111b = 01111011b
-10001100b ^ 11111000b = 01110100b
-10001100b ^ 11111001b = 01110101b
-10001100b ^ 11111010b = 01110110b
-10001100b ^ 11111011b = 01110111b
-10001100b ^ 11111100b = 01110000b
-10001100b ^ 11111101b = 01110001b
-10001100b ^ 11111110b = 01110010b
-10001100b ^ 11111111b = 01110011b
-10001100b ^ 00000000b = 10001100b
-10001100b ^ 00000001b = 10001101b
-10001100b ^ 00000010b = 10001110b
-10001100b ^ 00000011b = 10001111b
-10001100b ^ 00000100b = 10001000b
-10001100b ^ 00000101b = 10001001b
-10001100b ^ 00000110b = 10001010b
-10001100b ^ 00000111b = 10001011b
-10001100b ^ 00001000b = 10000100b
-10001100b ^ 00001001b = 10000101b
-10001100b ^ 00001010b = 10000110b
-10001100b ^ 00001011b = 10000111b
-10001100b ^ 00001100b = 10000000b
-10001100b ^ 00001101b = 10000001b
-10001100b ^ 00001110b = 10000010b
-10001100b ^ 00001111b = 10000011b
-10001100b ^ 00010000b = 10011100b
-10001100b ^ 00010001b = 10011101b
-10001100b ^ 00010010b = 10011110b
-10001100b ^ 00010011b = 10011111b
-10001100b ^ 00010100b = 10011000b
-10001100b ^ 00010101b = 10011001b
-10001100b ^ 00010110b = 10011010b
-10001100b ^ 00010111b = 10011011b
-10001100b ^ 00011000b = 10010100b
-10001100b ^ 00011001b = 10010101b
-10001100b ^ 00011010b = 10010110b
-10001100b ^ 00011011b = 10010111b
-10001100b ^ 00011100b = 10010000b
-10001100b ^ 00011101b = 10010001b
-10001100b ^ 00011110b = 10010010b
-10001100b ^ 00011111b = 10010011b
-10001100b ^ 00100000b = 10101100b
-10001100b ^ 00100001b = 10101101b
-10001100b ^ 00100010b = 10101110b
-10001100b ^ 00100011b = 10101111b
-10001100b ^ 00100100b = 10101000b
-10001100b ^ 00100101b = 10101001b
-10001100b ^ 00100110b = 10101010b
-10001100b ^ 00100111b = 10101011b
-10001100b ^ 00101000b = 10100100b
-10001100b ^ 00101001b = 10100101b
-10001100b ^ 00101010b = 10100110b
-10001100b ^ 00101011b = 10100111b
-10001100b ^ 00101100b = 10100000b
-10001100b ^ 00101101b = 10100001b
-10001100b ^ 00101110b = 10100010b
-10001100b ^ 00101111b = 10100011b
-10001100b ^ 00110000b = 10111100b
-10001100b ^ 00110001b = 10111101b
-10001100b ^ 00110010b = 10111110b
-10001100b ^ 00110011b = 10111111b
-10001100b ^ 00110100b = 10111000b
-10001100b ^ 00110101b = 10111001b
-10001100b ^ 00110110b = 10111010b
-10001100b ^ 00110111b = 10111011b
-10001100b ^ 00111000b = 10110100b
-10001100b ^ 00111001b = 10110101b
-10001100b ^ 00111010b = 10110110b
-10001100b ^ 00111011b = 10110111b
-10001100b ^ 00111100b = 10110000b
-10001100b ^ 00111101b = 10110001b
-10001100b ^ 00111110b = 10110010b
-10001100b ^ 00111111b = 10110011b
-10001100b ^ 01000000b = 11001100b
-10001100b ^ 01000001b = 11001101b
-10001100b ^ 01000010b = 11001110b
-10001100b ^ 01000011b = 11001111b
-10001100b ^ 01000100b = 11001000b
-10001100b ^ 01000101b = 11001001b
-10001100b ^ 01000110b = 11001010b
-10001100b ^ 01000111b = 11001011b
-10001100b ^ 01001000b = 11000100b
-10001100b ^ 01001001b = 11000101b
-10001100b ^ 01001010b = 11000110b
-10001100b ^ 01001011b = 11000111b
-10001100b ^ 01001100b = 11000000b
-10001100b ^ 01001101b = 11000001b
-10001100b ^ 01001110b = 11000010b
-10001100b ^ 01001111b = 11000011b
-10001100b ^ 01010000b = 11011100b
-10001100b ^ 01010001b = 11011101b
-10001100b ^ 01010010b = 11011110b
-10001100b ^ 01010011b = 11011111b
-10001100b ^ 01010100b = 11011000b
-10001100b ^ 01010101b = 11011001b
-10001100b ^ 01010110b = 11011010b
-10001100b ^ 01010111b = 11011011b
-10001100b ^ 01011000b = 11010100b
-10001100b ^ 01011001b = 11010101b
-10001100b ^ 01011010b = 11010110b
-10001100b ^ 01011011b = 11010111b
-10001100b ^ 01011100b = 11010000b
-10001100b ^ 01011101b = 11010001b
-10001100b ^ 01011110b = 11010010b
-10001100b ^ 01011111b = 11010011b
-10001100b ^ 01100000b = 11101100b
-10001100b ^ 01100001b = 11101101b
-10001100b ^ 01100010b = 11101110b
-10001100b ^ 01100011b = 11101111b
-10001100b ^ 01100100b = 11101000b
-10001100b ^ 01100101b = 11101001b
-10001100b ^ 01100110b = 11101010b
-10001100b ^ 01100111b = 11101011b
-10001100b ^ 01101000b = 11100100b
-10001100b ^ 01101001b = 11100101b
-10001100b ^ 01101010b = 11100110b
-10001100b ^ 01101011b = 11100111b
-10001100b ^ 01101100b = 11100000b
-10001100b ^ 01101101b = 11100001b
-10001100b ^ 01101110b = 11100010b
-10001100b ^ 01101111b = 11100011b
-10001100b ^ 01110000b = 11111100b
-10001100b ^ 01110001b = 11111101b
-10001100b ^ 01110010b = 11111110b
-10001100b ^ 01110011b = 11111111b
-10001100b ^ 01110100b = 11111000b
-10001100b ^ 01110101b = 11111001b
-10001100b ^ 01110110b = 11111010b
-10001100b ^ 01110111b = 11111011b
-10001100b ^ 01111000b = 11110100b
-10001100b ^ 01111001b = 11110101b
-10001100b ^ 01111010b = 11110110b
-10001100b ^ 01111011b = 11110111b
-10001100b ^ 01111100b = 11110000b
-10001100b ^ 01111101b = 11110001b
-10001100b ^ 01111110b = 11110010b
-10001101b ^ 10000000b = 00001101b
-10001101b ^ 10000001b = 00001100b
-10001101b ^ 10000010b = 00001111b
-10001101b ^ 10000011b = 00001110b
-10001101b ^ 10000100b = 00001001b
-10001101b ^ 10000101b = 00001000b
-10001101b ^ 10000110b = 00001011b
-10001101b ^ 10000111b = 00001010b
-10001101b ^ 10001000b = 00000101b
-10001101b ^ 10001001b = 00000100b
-10001101b ^ 10001010b = 00000111b
-10001101b ^ 10001011b = 00000110b
-10001101b ^ 10001100b = 00000001b
-10001101b ^ 10001101b = 00000000b
-10001101b ^ 10001110b = 00000011b
-10001101b ^ 10001111b = 00000010b
-10001101b ^ 10010000b = 00011101b
-10001101b ^ 10010001b = 00011100b
-10001101b ^ 10010010b = 00011111b
-10001101b ^ 10010011b = 00011110b
-10001101b ^ 10010100b = 00011001b
-10001101b ^ 10010101b = 00011000b
-10001101b ^ 10010110b = 00011011b
-10001101b ^ 10010111b = 00011010b
-10001101b ^ 10011000b = 00010101b
-10001101b ^ 10011001b = 00010100b
-10001101b ^ 10011010b = 00010111b
-10001101b ^ 10011011b = 00010110b
-10001101b ^ 10011100b = 00010001b
-10001101b ^ 10011101b = 00010000b
-10001101b ^ 10011110b = 00010011b
-10001101b ^ 10011111b = 00010010b
-10001101b ^ 10100000b = 00101101b
-10001101b ^ 10100001b = 00101100b
-10001101b ^ 10100010b = 00101111b
-10001101b ^ 10100011b = 00101110b
-10001101b ^ 10100100b = 00101001b
-10001101b ^ 10100101b = 00101000b
-10001101b ^ 10100110b = 00101011b
-10001101b ^ 10100111b = 00101010b
-10001101b ^ 10101000b = 00100101b
-10001101b ^ 10101001b = 00100100b
-10001101b ^ 10101010b = 00100111b
-10001101b ^ 10101011b = 00100110b
-10001101b ^ 10101100b = 00100001b
-10001101b ^ 10101101b = 00100000b
-10001101b ^ 10101110b = 00100011b
-10001101b ^ 10101111b = 00100010b
-10001101b ^ 10110000b = 00111101b
-10001101b ^ 10110001b = 00111100b
-10001101b ^ 10110010b = 00111111b
-10001101b ^ 10110011b = 00111110b
-10001101b ^ 10110100b = 00111001b
-10001101b ^ 10110101b = 00111000b
-10001101b ^ 10110110b = 00111011b
-10001101b ^ 10110111b = 00111010b
-10001101b ^ 10111000b = 00110101b
-10001101b ^ 10111001b = 00110100b
-10001101b ^ 10111010b = 00110111b
-10001101b ^ 10111011b = 00110110b
-10001101b ^ 10111100b = 00110001b
-10001101b ^ 10111101b = 00110000b
-10001101b ^ 10111110b = 00110011b
-10001101b ^ 10111111b = 00110010b
-10001101b ^ 11000000b = 01001101b
-10001101b ^ 11000001b = 01001100b
-10001101b ^ 11000010b = 01001111b
-10001101b ^ 11000011b = 01001110b
-10001101b ^ 11000100b = 01001001b
-10001101b ^ 11000101b = 01001000b
-10001101b ^ 11000110b = 01001011b
-10001101b ^ 11000111b = 01001010b
-10001101b ^ 11001000b = 01000101b
-10001101b ^ 11001001b = 01000100b
-10001101b ^ 11001010b = 01000111b
-10001101b ^ 11001011b = 01000110b
-10001101b ^ 11001100b = 01000001b
-10001101b ^ 11001101b = 01000000b
-10001101b ^ 11001110b = 01000011b
-10001101b ^ 11001111b = 01000010b
-10001101b ^ 11010000b = 01011101b
-10001101b ^ 11010001b = 01011100b
-10001101b ^ 11010010b = 01011111b
-10001101b ^ 11010011b = 01011110b
-10001101b ^ 11010100b = 01011001b
-10001101b ^ 11010101b = 01011000b
-10001101b ^ 11010110b = 01011011b
-10001101b ^ 11010111b = 01011010b
-10001101b ^ 11011000b = 01010101b
-10001101b ^ 11011001b = 01010100b
-10001101b ^ 11011010b = 01010111b
-10001101b ^ 11011011b = 01010110b
-10001101b ^ 11011100b = 01010001b
-10001101b ^ 11011101b = 01010000b
-10001101b ^ 11011110b = 01010011b
-10001101b ^ 11011111b = 01010010b
-10001101b ^ 11100000b = 01101101b
-10001101b ^ 11100001b = 01101100b
-10001101b ^ 11100010b = 01101111b
-10001101b ^ 11100011b = 01101110b
-10001101b ^ 11100100b = 01101001b
-10001101b ^ 11100101b = 01101000b
-10001101b ^ 11100110b = 01101011b
-10001101b ^ 11100111b = 01101010b
-10001101b ^ 11101000b = 01100101b
-10001101b ^ 11101001b = 01100100b
-10001101b ^ 11101010b = 01100111b
-10001101b ^ 11101011b = 01100110b
-10001101b ^ 11101100b = 01100001b
-10001101b ^ 11101101b = 01100000b
-10001101b ^ 11101110b = 01100011b
-10001101b ^ 11101111b = 01100010b
-10001101b ^ 11110000b = 01111101b
-10001101b ^ 11110001b = 01111100b
-10001101b ^ 11110010b = 01111111b
-10001101b ^ 11110011b = 01111110b
-10001101b ^ 11110100b = 01111001b
-10001101b ^ 11110101b = 01111000b
-10001101b ^ 11110110b = 01111011b
-10001101b ^ 11110111b = 01111010b
-10001101b ^ 11111000b = 01110101b
-10001101b ^ 11111001b = 01110100b
-10001101b ^ 11111010b = 01110111b
-10001101b ^ 11111011b = 01110110b
-10001101b ^ 11111100b = 01110001b
-10001101b ^ 11111101b = 01110000b
-10001101b ^ 11111110b = 01110011b
-10001101b ^ 11111111b = 01110010b
-10001101b ^ 00000000b = 10001101b
-10001101b ^ 00000001b = 10001100b
-10001101b ^ 00000010b = 10001111b
-10001101b ^ 00000011b = 10001110b
-10001101b ^ 00000100b = 10001001b
-10001101b ^ 00000101b = 10001000b
-10001101b ^ 00000110b = 10001011b
-10001101b ^ 00000111b = 10001010b
-10001101b ^ 00001000b = 10000101b
-10001101b ^ 00001001b = 10000100b
-10001101b ^ 00001010b = 10000111b
-10001101b ^ 00001011b = 10000110b
-10001101b ^ 00001100b = 10000001b
-10001101b ^ 00001101b = 10000000b
-10001101b ^ 00001110b = 10000011b
-10001101b ^ 00001111b = 10000010b
-10001101b ^ 00010000b = 10011101b
-10001101b ^ 00010001b = 10011100b
-10001101b ^ 00010010b = 10011111b
-10001101b ^ 00010011b = 10011110b
-10001101b ^ 00010100b = 10011001b
-10001101b ^ 00010101b = 10011000b
-10001101b ^ 00010110b = 10011011b
-10001101b ^ 00010111b = 10011010b
-10001101b ^ 00011000b = 10010101b
-10001101b ^ 00011001b = 10010100b
-10001101b ^ 00011010b = 10010111b
-10001101b ^ 00011011b = 10010110b
-10001101b ^ 00011100b = 10010001b
-10001101b ^ 00011101b = 10010000b
-10001101b ^ 00011110b = 10010011b
-10001101b ^ 00011111b = 10010010b
-10001101b ^ 00100000b = 10101101b
-10001101b ^ 00100001b = 10101100b
-10001101b ^ 00100010b = 10101111b
-10001101b ^ 00100011b = 10101110b
-10001101b ^ 00100100b = 10101001b
-10001101b ^ 00100101b = 10101000b
-10001101b ^ 00100110b = 10101011b
-10001101b ^ 00100111b = 10101010b
-10001101b ^ 00101000b = 10100101b
-10001101b ^ 00101001b = 10100100b
-10001101b ^ 00101010b = 10100111b
-10001101b ^ 00101011b = 10100110b
-10001101b ^ 00101100b = 10100001b
-10001101b ^ 00101101b = 10100000b
-10001101b ^ 00101110b = 10100011b
-10001101b ^ 00101111b = 10100010b
-10001101b ^ 00110000b = 10111101b
-10001101b ^ 00110001b = 10111100b
-10001101b ^ 00110010b = 10111111b
-10001101b ^ 00110011b = 10111110b
-10001101b ^ 00110100b = 10111001b
-10001101b ^ 00110101b = 10111000b
-10001101b ^ 00110110b = 10111011b
-10001101b ^ 00110111b = 10111010b
-10001101b ^ 00111000b = 10110101b
-10001101b ^ 00111001b = 10110100b
-10001101b ^ 00111010b = 10110111b
-10001101b ^ 00111011b = 10110110b
-10001101b ^ 00111100b = 10110001b
-10001101b ^ 00111101b = 10110000b
-10001101b ^ 00111110b = 10110011b
-10001101b ^ 00111111b = 10110010b
-10001101b ^ 01000000b = 11001101b
-10001101b ^ 01000001b = 11001100b
-10001101b ^ 01000010b = 11001111b
-10001101b ^ 01000011b = 11001110b
-10001101b ^ 01000100b = 11001001b
-10001101b ^ 01000101b = 11001000b
-10001101b ^ 01000110b = 11001011b
-10001101b ^ 01000111b = 11001010b
-10001101b ^ 01001000b = 11000101b
-10001101b ^ 01001001b = 11000100b
-10001101b ^ 01001010b = 11000111b
-10001101b ^ 01001011b = 11000110b
-10001101b ^ 01001100b = 11000001b
-10001101b ^ 01001101b = 11000000b
-10001101b ^ 01001110b = 11000011b
-10001101b ^ 01001111b = 11000010b
-10001101b ^ 01010000b = 11011101b
-10001101b ^ 01010001b = 11011100b
-10001101b ^ 01010010b = 11011111b
-10001101b ^ 01010011b = 11011110b
-10001101b ^ 01010100b = 11011001b
-10001101b ^ 01010101b = 11011000b
-10001101b ^ 01010110b = 11011011b
-10001101b ^ 01010111b = 11011010b
-10001101b ^ 01011000b = 11010101b
-10001101b ^ 01011001b = 11010100b
-10001101b ^ 01011010b = 11010111b
-10001101b ^ 01011011b = 11010110b
-10001101b ^ 01011100b = 11010001b
-10001101b ^ 01011101b = 11010000b
-10001101b ^ 01011110b = 11010011b
-10001101b ^ 01011111b = 11010010b
-10001101b ^ 01100000b = 11101101b
-10001101b ^ 01100001b = 11101100b
-10001101b ^ 01100010b = 11101111b
-10001101b ^ 01100011b = 11101110b
-10001101b ^ 01100100b = 11101001b
-10001101b ^ 01100101b = 11101000b
-10001101b ^ 01100110b = 11101011b
-10001101b ^ 01100111b = 11101010b
-10001101b ^ 01101000b = 11100101b
-10001101b ^ 01101001b = 11100100b
-10001101b ^ 01101010b = 11100111b
-10001101b ^ 01101011b = 11100110b
-10001101b ^ 01101100b = 11100001b
-10001101b ^ 01101101b = 11100000b
-10001101b ^ 01101110b = 11100011b
-10001101b ^ 01101111b = 11100010b
-10001101b ^ 01110000b = 11111101b
-10001101b ^ 01110001b = 11111100b
-10001101b ^ 01110010b = 11111111b
-10001101b ^ 01110011b = 11111110b
-10001101b ^ 01110100b = 11111001b
-10001101b ^ 01110101b = 11111000b
-10001101b ^ 01110110b = 11111011b
-10001101b ^ 01110111b = 11111010b
-10001101b ^ 01111000b = 11110101b
-10001101b ^ 01111001b = 11110100b
-10001101b ^ 01111010b = 11110111b
-10001101b ^ 01111011b = 11110110b
-10001101b ^ 01111100b = 11110001b
-10001101b ^ 01111101b = 11110000b
-10001101b ^ 01111110b = 11110011b
-10001110b ^ 10000000b = 00001110b
-10001110b ^ 10000001b = 00001111b
-10001110b ^ 10000010b = 00001100b
-10001110b ^ 10000011b = 00001101b
-10001110b ^ 10000100b = 00001010b
-10001110b ^ 10000101b = 00001011b
-10001110b ^ 10000110b = 00001000b
-10001110b ^ 10000111b = 00001001b
-10001110b ^ 10001000b = 00000110b
-10001110b ^ 10001001b = 00000111b
-10001110b ^ 10001010b = 00000100b
-10001110b ^ 10001011b = 00000101b
-10001110b ^ 10001100b = 00000010b
-10001110b ^ 10001101b = 00000011b
-10001110b ^ 10001110b = 00000000b
-10001110b ^ 10001111b = 00000001b
-10001110b ^ 10010000b = 00011110b
-10001110b ^ 10010001b = 00011111b
-10001110b ^ 10010010b = 00011100b
-10001110b ^ 10010011b = 00011101b
-10001110b ^ 10010100b = 00011010b
-10001110b ^ 10010101b = 00011011b
-10001110b ^ 10010110b = 00011000b
-10001110b ^ 10010111b = 00011001b
-10001110b ^ 10011000b = 00010110b
-10001110b ^ 10011001b = 00010111b
-10001110b ^ 10011010b = 00010100b
-10001110b ^ 10011011b = 00010101b
-10001110b ^ 10011100b = 00010010b
-10001110b ^ 10011101b = 00010011b
-10001110b ^ 10011110b = 00010000b
-10001110b ^ 10011111b = 00010001b
-10001110b ^ 10100000b = 00101110b
-10001110b ^ 10100001b = 00101111b
-10001110b ^ 10100010b = 00101100b
-10001110b ^ 10100011b = 00101101b
-10001110b ^ 10100100b = 00101010b
-10001110b ^ 10100101b = 00101011b
-10001110b ^ 10100110b = 00101000b
-10001110b ^ 10100111b = 00101001b
-10001110b ^ 10101000b = 00100110b
-10001110b ^ 10101001b = 00100111b
-10001110b ^ 10101010b = 00100100b
-10001110b ^ 10101011b = 00100101b
-10001110b ^ 10101100b = 00100010b
-10001110b ^ 10101101b = 00100011b
-10001110b ^ 10101110b = 00100000b
-10001110b ^ 10101111b = 00100001b
-10001110b ^ 10110000b = 00111110b
-10001110b ^ 10110001b = 00111111b
-10001110b ^ 10110010b = 00111100b
-10001110b ^ 10110011b = 00111101b
-10001110b ^ 10110100b = 00111010b
-10001110b ^ 10110101b = 00111011b
-10001110b ^ 10110110b = 00111000b
-10001110b ^ 10110111b = 00111001b
-10001110b ^ 10111000b = 00110110b
-10001110b ^ 10111001b = 00110111b
-10001110b ^ 10111010b = 00110100b
-10001110b ^ 10111011b = 00110101b
-10001110b ^ 10111100b = 00110010b
-10001110b ^ 10111101b = 00110011b
-10001110b ^ 10111110b = 00110000b
-10001110b ^ 10111111b = 00110001b
-10001110b ^ 11000000b = 01001110b
-10001110b ^ 11000001b = 01001111b
-10001110b ^ 11000010b = 01001100b
-10001110b ^ 11000011b = 01001101b
-10001110b ^ 11000100b = 01001010b
-10001110b ^ 11000101b = 01001011b
-10001110b ^ 11000110b = 01001000b
-10001110b ^ 11000111b = 01001001b
-10001110b ^ 11001000b = 01000110b
-10001110b ^ 11001001b = 01000111b
-10001110b ^ 11001010b = 01000100b
-10001110b ^ 11001011b = 01000101b
-10001110b ^ 11001100b = 01000010b
-10001110b ^ 11001101b = 01000011b
-10001110b ^ 11001110b = 01000000b
-10001110b ^ 11001111b = 01000001b
-10001110b ^ 11010000b = 01011110b
-10001110b ^ 11010001b = 01011111b
-10001110b ^ 11010010b = 01011100b
-10001110b ^ 11010011b = 01011101b
-10001110b ^ 11010100b = 01011010b
-10001110b ^ 11010101b = 01011011b
-10001110b ^ 11010110b = 01011000b
-10001110b ^ 11010111b = 01011001b
-10001110b ^ 11011000b = 01010110b
-10001110b ^ 11011001b = 01010111b
-10001110b ^ 11011010b = 01010100b
-10001110b ^ 11011011b = 01010101b
-10001110b ^ 11011100b = 01010010b
-10001110b ^ 11011101b = 01010011b
-10001110b ^ 11011110b = 01010000b
-10001110b ^ 11011111b = 01010001b
-10001110b ^ 11100000b = 01101110b
-10001110b ^ 11100001b = 01101111b
-10001110b ^ 11100010b = 01101100b
-10001110b ^ 11100011b = 01101101b
-10001110b ^ 11100100b = 01101010b
-10001110b ^ 11100101b = 01101011b
-10001110b ^ 11100110b = 01101000b
-10001110b ^ 11100111b = 01101001b
-10001110b ^ 11101000b = 01100110b
-10001110b ^ 11101001b = 01100111b
-10001110b ^ 11101010b = 01100100b
-10001110b ^ 11101011b = 01100101b
-10001110b ^ 11101100b = 01100010b
-10001110b ^ 11101101b = 01100011b
-10001110b ^ 11101110b = 01100000b
-10001110b ^ 11101111b = 01100001b
-10001110b ^ 11110000b = 01111110b
-10001110b ^ 11110001b = 01111111b
-10001110b ^ 11110010b = 01111100b
-10001110b ^ 11110011b = 01111101b
-10001110b ^ 11110100b = 01111010b
-10001110b ^ 11110101b = 01111011b
-10001110b ^ 11110110b = 01111000b
-10001110b ^ 11110111b = 01111001b
-10001110b ^ 11111000b = 01110110b
-10001110b ^ 11111001b = 01110111b
-10001110b ^ 11111010b = 01110100b
-10001110b ^ 11111011b = 01110101b
-10001110b ^ 11111100b = 01110010b
-10001110b ^ 11111101b = 01110011b
-10001110b ^ 11111110b = 01110000b
-10001110b ^ 11111111b = 01110001b
-10001110b ^ 00000000b = 10001110b
-10001110b ^ 00000001b = 10001111b
-10001110b ^ 00000010b = 10001100b
-10001110b ^ 00000011b = 10001101b
-10001110b ^ 00000100b = 10001010b
-10001110b ^ 00000101b = 10001011b
-10001110b ^ 00000110b = 10001000b
-10001110b ^ 00000111b = 10001001b
-10001110b ^ 00001000b = 10000110b
-10001110b ^ 00001001b = 10000111b
-10001110b ^ 00001010b = 10000100b
-10001110b ^ 00001011b = 10000101b
-10001110b ^ 00001100b = 10000010b
-10001110b ^ 00001101b = 10000011b
-10001110b ^ 00001110b = 10000000b
-10001110b ^ 00001111b = 10000001b
-10001110b ^ 00010000b = 10011110b
-10001110b ^ 00010001b = 10011111b
-10001110b ^ 00010010b = 10011100b
-10001110b ^ 00010011b = 10011101b
-10001110b ^ 00010100b = 10011010b
-10001110b ^ 00010101b = 10011011b
-10001110b ^ 00010110b = 10011000b
-10001110b ^ 00010111b = 10011001b
-10001110b ^ 00011000b = 10010110b
-10001110b ^ 00011001b = 10010111b
-10001110b ^ 00011010b = 10010100b
-10001110b ^ 00011011b = 10010101b
-10001110b ^ 00011100b = 10010010b
-10001110b ^ 00011101b = 10010011b
-10001110b ^ 00011110b = 10010000b
-10001110b ^ 00011111b = 10010001b
-10001110b ^ 00100000b = 10101110b
-10001110b ^ 00100001b = 10101111b
-10001110b ^ 00100010b = 10101100b
-10001110b ^ 00100011b = 10101101b
-10001110b ^ 00100100b = 10101010b
-10001110b ^ 00100101b = 10101011b
-10001110b ^ 00100110b = 10101000b
-10001110b ^ 00100111b = 10101001b
-10001110b ^ 00101000b = 10100110b
-10001110b ^ 00101001b = 10100111b
-10001110b ^ 00101010b = 10100100b
-10001110b ^ 00101011b = 10100101b
-10001110b ^ 00101100b = 10100010b
-10001110b ^ 00101101b = 10100011b
-10001110b ^ 00101110b = 10100000b
-10001110b ^ 00101111b = 10100001b
-10001110b ^ 00110000b = 10111110b
-10001110b ^ 00110001b = 10111111b
-10001110b ^ 00110010b = 10111100b
-10001110b ^ 00110011b = 10111101b
-10001110b ^ 00110100b = 10111010b
-10001110b ^ 00110101b = 10111011b
-10001110b ^ 00110110b = 10111000b
-10001110b ^ 00110111b = 10111001b
-10001110b ^ 00111000b = 10110110b
-10001110b ^ 00111001b = 10110111b
-10001110b ^ 00111010b = 10110100b
-10001110b ^ 00111011b = 10110101b
-10001110b ^ 00111100b = 10110010b
-10001110b ^ 00111101b = 10110011b
-10001110b ^ 00111110b = 10110000b
-10001110b ^ 00111111b = 10110001b
-10001110b ^ 01000000b = 11001110b
-10001110b ^ 01000001b = 11001111b
-10001110b ^ 01000010b = 11001100b
-10001110b ^ 01000011b = 11001101b
-10001110b ^ 01000100b = 11001010b
-10001110b ^ 01000101b = 11001011b
-10001110b ^ 01000110b = 11001000b
-10001110b ^ 01000111b = 11001001b
-10001110b ^ 01001000b = 11000110b
-10001110b ^ 01001001b = 11000111b
-10001110b ^ 01001010b = 11000100b
-10001110b ^ 01001011b = 11000101b
-10001110b ^ 01001100b = 11000010b
-10001110b ^ 01001101b = 11000011b
-10001110b ^ 01001110b = 11000000b
-10001110b ^ 01001111b = 11000001b
-10001110b ^ 01010000b = 11011110b
-10001110b ^ 01010001b = 11011111b
-10001110b ^ 01010010b = 11011100b
-10001110b ^ 01010011b = 11011101b
-10001110b ^ 01010100b = 11011010b
-10001110b ^ 01010101b = 11011011b
-10001110b ^ 01010110b = 11011000b
-10001110b ^ 01010111b = 11011001b
-10001110b ^ 01011000b = 11010110b
-10001110b ^ 01011001b = 11010111b
-10001110b ^ 01011010b = 11010100b
-10001110b ^ 01011011b = 11010101b
-10001110b ^ 01011100b = 11010010b
-10001110b ^ 01011101b = 11010011b
-10001110b ^ 01011110b = 11010000b
-10001110b ^ 01011111b = 11010001b
-10001110b ^ 01100000b = 11101110b
-10001110b ^ 01100001b = 11101111b
-10001110b ^ 01100010b = 11101100b
-10001110b ^ 01100011b = 11101101b
-10001110b ^ 01100100b = 11101010b
-10001110b ^ 01100101b = 11101011b
-10001110b ^ 01100110b = 11101000b
-10001110b ^ 01100111b = 11101001b
-10001110b ^ 01101000b = 11100110b
-10001110b ^ 01101001b = 11100111b
-10001110b ^ 01101010b = 11100100b
-10001110b ^ 01101011b = 11100101b
-10001110b ^ 01101100b = 11100010b
-10001110b ^ 01101101b = 11100011b
-10001110b ^ 01101110b = 11100000b
-10001110b ^ 01101111b = 11100001b
-10001110b ^ 01110000b = 11111110b
-10001110b ^ 01110001b = 11111111b
-10001110b ^ 01110010b = 11111100b
-10001110b ^ 01110011b = 11111101b
-10001110b ^ 01110100b = 11111010b
-10001110b ^ 01110101b = 11111011b
-10001110b ^ 01110110b = 11111000b
-10001110b ^ 01110111b = 11111001b
-10001110b ^ 01111000b = 11110110b
-10001110b ^ 01111001b = 11110111b
-10001110b ^ 01111010b = 11110100b
-10001110b ^ 01111011b = 11110101b
-10001110b ^ 01111100b = 11110010b
-10001110b ^ 01111101b = 11110011b
-10001110b ^ 01111110b = 11110000b
-10001111b ^ 10000000b = 00001111b
-10001111b ^ 10000001b = 00001110b
-10001111b ^ 10000010b = 00001101b
-10001111b ^ 10000011b = 00001100b
-10001111b ^ 10000100b = 00001011b
-10001111b ^ 10000101b = 00001010b
-10001111b ^ 10000110b = 00001001b
-10001111b ^ 10000111b = 00001000b
-10001111b ^ 10001000b = 00000111b
-10001111b ^ 10001001b = 00000110b
-10001111b ^ 10001010b = 00000101b
-10001111b ^ 10001011b = 00000100b
-10001111b ^ 10001100b = 00000011b
-10001111b ^ 10001101b = 00000010b
-10001111b ^ 10001110b = 00000001b
-10001111b ^ 10001111b = 00000000b
-10001111b ^ 10010000b = 00011111b
-10001111b ^ 10010001b = 00011110b
-10001111b ^ 10010010b = 00011101b
-10001111b ^ 10010011b = 00011100b
-10001111b ^ 10010100b = 00011011b
-10001111b ^ 10010101b = 00011010b
-10001111b ^ 10010110b = 00011001b
-10001111b ^ 10010111b = 00011000b
-10001111b ^ 10011000b = 00010111b
-10001111b ^ 10011001b = 00010110b
-10001111b ^ 10011010b = 00010101b
-10001111b ^ 10011011b = 00010100b
-10001111b ^ 10011100b = 00010011b
-10001111b ^ 10011101b = 00010010b
-10001111b ^ 10011110b = 00010001b
-10001111b ^ 10011111b = 00010000b
-10001111b ^ 10100000b = 00101111b
-10001111b ^ 10100001b = 00101110b
-10001111b ^ 10100010b = 00101101b
-10001111b ^ 10100011b = 00101100b
-10001111b ^ 10100100b = 00101011b
-10001111b ^ 10100101b = 00101010b
-10001111b ^ 10100110b = 00101001b
-10001111b ^ 10100111b = 00101000b
-10001111b ^ 10101000b = 00100111b
-10001111b ^ 10101001b = 00100110b
-10001111b ^ 10101010b = 00100101b
-10001111b ^ 10101011b = 00100100b
-10001111b ^ 10101100b = 00100011b
-10001111b ^ 10101101b = 00100010b
-10001111b ^ 10101110b = 00100001b
-10001111b ^ 10101111b = 00100000b
-10001111b ^ 10110000b = 00111111b
-10001111b ^ 10110001b = 00111110b
-10001111b ^ 10110010b = 00111101b
-10001111b ^ 10110011b = 00111100b
-10001111b ^ 10110100b = 00111011b
-10001111b ^ 10110101b = 00111010b
-10001111b ^ 10110110b = 00111001b
-10001111b ^ 10110111b = 00111000b
-10001111b ^ 10111000b = 00110111b
-10001111b ^ 10111001b = 00110110b
-10001111b ^ 10111010b = 00110101b
-10001111b ^ 10111011b = 00110100b
-10001111b ^ 10111100b = 00110011b
-10001111b ^ 10111101b = 00110010b
-10001111b ^ 10111110b = 00110001b
-10001111b ^ 10111111b = 00110000b
-10001111b ^ 11000000b = 01001111b
-10001111b ^ 11000001b = 01001110b
-10001111b ^ 11000010b = 01001101b
-10001111b ^ 11000011b = 01001100b
-10001111b ^ 11000100b = 01001011b
-10001111b ^ 11000101b = 01001010b
-10001111b ^ 11000110b = 01001001b
-10001111b ^ 11000111b = 01001000b
-10001111b ^ 11001000b = 01000111b
-10001111b ^ 11001001b = 01000110b
-10001111b ^ 11001010b = 01000101b
-10001111b ^ 11001011b = 01000100b
-10001111b ^ 11001100b = 01000011b
-10001111b ^ 11001101b = 01000010b
-10001111b ^ 11001110b = 01000001b
-10001111b ^ 11001111b = 01000000b
-10001111b ^ 11010000b = 01011111b
-10001111b ^ 11010001b = 01011110b
-10001111b ^ 11010010b = 01011101b
-10001111b ^ 11010011b = 01011100b
-10001111b ^ 11010100b = 01011011b
-10001111b ^ 11010101b = 01011010b
-10001111b ^ 11010110b = 01011001b
-10001111b ^ 11010111b = 01011000b
-10001111b ^ 11011000b = 01010111b
-10001111b ^ 11011001b = 01010110b
-10001111b ^ 11011010b = 01010101b
-10001111b ^ 11011011b = 01010100b
-10001111b ^ 11011100b = 01010011b
-10001111b ^ 11011101b = 01010010b
-10001111b ^ 11011110b = 01010001b
-10001111b ^ 11011111b = 01010000b
-10001111b ^ 11100000b = 01101111b
-10001111b ^ 11100001b = 01101110b
-10001111b ^ 11100010b = 01101101b
-10001111b ^ 11100011b = 01101100b
-10001111b ^ 11100100b = 01101011b
-10001111b ^ 11100101b = 01101010b
-10001111b ^ 11100110b = 01101001b
-10001111b ^ 11100111b = 01101000b
-10001111b ^ 11101000b = 01100111b
-10001111b ^ 11101001b = 01100110b
-10001111b ^ 11101010b = 01100101b
-10001111b ^ 11101011b = 01100100b
-10001111b ^ 11101100b = 01100011b
-10001111b ^ 11101101b = 01100010b
-10001111b ^ 11101110b = 01100001b
-10001111b ^ 11101111b = 01100000b
-10001111b ^ 11110000b = 01111111b
-10001111b ^ 11110001b = 01111110b
-10001111b ^ 11110010b = 01111101b
-10001111b ^ 11110011b = 01111100b
-10001111b ^ 11110100b = 01111011b
-10001111b ^ 11110101b = 01111010b
-10001111b ^ 11110110b = 01111001b
-10001111b ^ 11110111b = 01111000b
-10001111b ^ 11111000b = 01110111b
-10001111b ^ 11111001b = 01110110b
-10001111b ^ 11111010b = 01110101b
-10001111b ^ 11111011b = 01110100b
-10001111b ^ 11111100b = 01110011b
-10001111b ^ 11111101b = 01110010b
-10001111b ^ 11111110b = 01110001b
-10001111b ^ 11111111b = 01110000b
-10001111b ^ 00000000b = 10001111b
-10001111b ^ 00000001b = 10001110b
-10001111b ^ 00000010b = 10001101b
-10001111b ^ 00000011b = 10001100b
-10001111b ^ 00000100b = 10001011b
-10001111b ^ 00000101b = 10001010b
-10001111b ^ 00000110b = 10001001b
-10001111b ^ 00000111b = 10001000b
-10001111b ^ 00001000b = 10000111b
-10001111b ^ 00001001b = 10000110b
-10001111b ^ 00001010b = 10000101b
-10001111b ^ 00001011b = 10000100b
-10001111b ^ 00001100b = 10000011b
-10001111b ^ 00001101b = 10000010b
-10001111b ^ 00001110b = 10000001b
-10001111b ^ 00001111b = 10000000b
-10001111b ^ 00010000b = 10011111b
-10001111b ^ 00010001b = 10011110b
-10001111b ^ 00010010b = 10011101b
-10001111b ^ 00010011b = 10011100b
-10001111b ^ 00010100b = 10011011b
-10001111b ^ 00010101b = 10011010b
-10001111b ^ 00010110b = 10011001b
-10001111b ^ 00010111b = 10011000b
-10001111b ^ 00011000b = 10010111b
-10001111b ^ 00011001b = 10010110b
-10001111b ^ 00011010b = 10010101b
-10001111b ^ 00011011b = 10010100b
-10001111b ^ 00011100b = 10010011b
-10001111b ^ 00011101b = 10010010b
-10001111b ^ 00011110b = 10010001b
-10001111b ^ 00011111b = 10010000b
-10001111b ^ 00100000b = 10101111b
-10001111b ^ 00100001b = 10101110b
-10001111b ^ 00100010b = 10101101b
-10001111b ^ 00100011b = 10101100b
-10001111b ^ 00100100b = 10101011b
-10001111b ^ 00100101b = 10101010b
-10001111b ^ 00100110b = 10101001b
-10001111b ^ 00100111b = 10101000b
-10001111b ^ 00101000b = 10100111b
-10001111b ^ 00101001b = 10100110b
-10001111b ^ 00101010b = 10100101b
-10001111b ^ 00101011b = 10100100b
-10001111b ^ 00101100b = 10100011b
-10001111b ^ 00101101b = 10100010b
-10001111b ^ 00101110b = 10100001b
-10001111b ^ 00101111b = 10100000b
-10001111b ^ 00110000b = 10111111b
-10001111b ^ 00110001b = 10111110b
-10001111b ^ 00110010b = 10111101b
-10001111b ^ 00110011b = 10111100b
-10001111b ^ 00110100b = 10111011b
-10001111b ^ 00110101b = 10111010b
-10001111b ^ 00110110b = 10111001b
-10001111b ^ 00110111b = 10111000b
-10001111b ^ 00111000b = 10110111b
-10001111b ^ 00111001b = 10110110b
-10001111b ^ 00111010b = 10110101b
-10001111b ^ 00111011b = 10110100b
-10001111b ^ 00111100b = 10110011b
-10001111b ^ 00111101b = 10110010b
-10001111b ^ 00111110b = 10110001b
-10001111b ^ 00111111b = 10110000b
-10001111b ^ 01000000b = 11001111b
-10001111b ^ 01000001b = 11001110b
-10001111b ^ 01000010b = 11001101b
-10001111b ^ 01000011b = 11001100b
-10001111b ^ 01000100b = 11001011b
-10001111b ^ 01000101b = 11001010b
-10001111b ^ 01000110b = 11001001b
-10001111b ^ 01000111b = 11001000b
-10001111b ^ 01001000b = 11000111b
-10001111b ^ 01001001b = 11000110b
-10001111b ^ 01001010b = 11000101b
-10001111b ^ 01001011b = 11000100b
-10001111b ^ 01001100b = 11000011b
-10001111b ^ 01001101b = 11000010b
-10001111b ^ 01001110b = 11000001b
-10001111b ^ 01001111b = 11000000b
-10001111b ^ 01010000b = 11011111b
-10001111b ^ 01010001b = 11011110b
-10001111b ^ 01010010b = 11011101b
-10001111b ^ 01010011b = 11011100b
-10001111b ^ 01010100b = 11011011b
-10001111b ^ 01010101b = 11011010b
-10001111b ^ 01010110b = 11011001b
-10001111b ^ 01010111b = 11011000b
-10001111b ^ 01011000b = 11010111b
-10001111b ^ 01011001b = 11010110b
-10001111b ^ 01011010b = 11010101b
-10001111b ^ 01011011b = 11010100b
-10001111b ^ 01011100b = 11010011b
-10001111b ^ 01011101b = 11010010b
-10001111b ^ 01011110b = 11010001b
-10001111b ^ 01011111b = 11010000b
-10001111b ^ 01100000b = 11101111b
-10001111b ^ 01100001b = 11101110b
-10001111b ^ 01100010b = 11101101b
-10001111b ^ 01100011b = 11101100b
-10001111b ^ 01100100b = 11101011b
-10001111b ^ 01100101b = 11101010b
-10001111b ^ 01100110b = 11101001b
-10001111b ^ 01100111b = 11101000b
-10001111b ^ 01101000b = 11100111b
-10001111b ^ 01101001b = 11100110b
-10001111b ^ 01101010b = 11100101b
-10001111b ^ 01101011b = 11100100b
-10001111b ^ 01101100b = 11100011b
-10001111b ^ 01101101b = 11100010b
-10001111b ^ 01101110b = 11100001b
-10001111b ^ 01101111b = 11100000b
-10001111b ^ 01110000b = 11111111b
-10001111b ^ 01110001b = 11111110b
-10001111b ^ 01110010b = 11111101b
-10001111b ^ 01110011b = 11111100b
-10001111b ^ 01110100b = 11111011b
-10001111b ^ 01110101b = 11111010b
-10001111b ^ 01110110b = 11111001b
-10001111b ^ 01110111b = 11111000b
-10001111b ^ 01111000b = 11110111b
-10001111b ^ 01111001b = 11110110b
-10001111b ^ 01111010b = 11110101b
-10001111b ^ 01111011b = 11110100b
-10001111b ^ 01111100b = 11110011b
-10001111b ^ 01111101b = 11110010b
-10001111b ^ 01111110b = 11110001b
-10010000b ^ 10000000b = 00010000b
-10010000b ^ 10000001b = 00010001b
-10010000b ^ 10000010b = 00010010b
-10010000b ^ 10000011b = 00010011b
-10010000b ^ 10000100b = 00010100b
-10010000b ^ 10000101b = 00010101b
-10010000b ^ 10000110b = 00010110b
-10010000b ^ 10000111b = 00010111b
-10010000b ^ 10001000b = 00011000b
-10010000b ^ 10001001b = 00011001b
-10010000b ^ 10001010b = 00011010b
-10010000b ^ 10001011b = 00011011b
-10010000b ^ 10001100b = 00011100b
-10010000b ^ 10001101b = 00011101b
-10010000b ^ 10001110b = 00011110b
-10010000b ^ 10001111b = 00011111b
-10010000b ^ 10010000b = 00000000b
-10010000b ^ 10010001b = 00000001b
-10010000b ^ 10010010b = 00000010b
-10010000b ^ 10010011b = 00000011b
-10010000b ^ 10010100b = 00000100b
-10010000b ^ 10010101b = 00000101b
-10010000b ^ 10010110b = 00000110b
-10010000b ^ 10010111b = 00000111b
-10010000b ^ 10011000b = 00001000b
-10010000b ^ 10011001b = 00001001b
-10010000b ^ 10011010b = 00001010b
-10010000b ^ 10011011b = 00001011b
-10010000b ^ 10011100b = 00001100b
-10010000b ^ 10011101b = 00001101b
-10010000b ^ 10011110b = 00001110b
-10010000b ^ 10011111b = 00001111b
-10010000b ^ 10100000b = 00110000b
-10010000b ^ 10100001b = 00110001b
-10010000b ^ 10100010b = 00110010b
-10010000b ^ 10100011b = 00110011b
-10010000b ^ 10100100b = 00110100b
-10010000b ^ 10100101b = 00110101b
-10010000b ^ 10100110b = 00110110b
-10010000b ^ 10100111b = 00110111b
-10010000b ^ 10101000b = 00111000b
-10010000b ^ 10101001b = 00111001b
-10010000b ^ 10101010b = 00111010b
-10010000b ^ 10101011b = 00111011b
-10010000b ^ 10101100b = 00111100b
-10010000b ^ 10101101b = 00111101b
-10010000b ^ 10101110b = 00111110b
-10010000b ^ 10101111b = 00111111b
-10010000b ^ 10110000b = 00100000b
-10010000b ^ 10110001b = 00100001b
-10010000b ^ 10110010b = 00100010b
-10010000b ^ 10110011b = 00100011b
-10010000b ^ 10110100b = 00100100b
-10010000b ^ 10110101b = 00100101b
-10010000b ^ 10110110b = 00100110b
-10010000b ^ 10110111b = 00100111b
-10010000b ^ 10111000b = 00101000b
-10010000b ^ 10111001b = 00101001b
-10010000b ^ 10111010b = 00101010b
-10010000b ^ 10111011b = 00101011b
-10010000b ^ 10111100b = 00101100b
-10010000b ^ 10111101b = 00101101b
-10010000b ^ 10111110b = 00101110b
-10010000b ^ 10111111b = 00101111b
-10010000b ^ 11000000b = 01010000b
-10010000b ^ 11000001b = 01010001b
-10010000b ^ 11000010b = 01010010b
-10010000b ^ 11000011b = 01010011b
-10010000b ^ 11000100b = 01010100b
-10010000b ^ 11000101b = 01010101b
-10010000b ^ 11000110b = 01010110b
-10010000b ^ 11000111b = 01010111b
-10010000b ^ 11001000b = 01011000b
-10010000b ^ 11001001b = 01011001b
-10010000b ^ 11001010b = 01011010b
-10010000b ^ 11001011b = 01011011b
-10010000b ^ 11001100b = 01011100b
-10010000b ^ 11001101b = 01011101b
-10010000b ^ 11001110b = 01011110b
-10010000b ^ 11001111b = 01011111b
-10010000b ^ 11010000b = 01000000b
-10010000b ^ 11010001b = 01000001b
-10010000b ^ 11010010b = 01000010b
-10010000b ^ 11010011b = 01000011b
-10010000b ^ 11010100b = 01000100b
-10010000b ^ 11010101b = 01000101b
-10010000b ^ 11010110b = 01000110b
-10010000b ^ 11010111b = 01000111b
-10010000b ^ 11011000b = 01001000b
-10010000b ^ 11011001b = 01001001b
-10010000b ^ 11011010b = 01001010b
-10010000b ^ 11011011b = 01001011b
-10010000b ^ 11011100b = 01001100b
-10010000b ^ 11011101b = 01001101b
-10010000b ^ 11011110b = 01001110b
-10010000b ^ 11011111b = 01001111b
-10010000b ^ 11100000b = 01110000b
-10010000b ^ 11100001b = 01110001b
-10010000b ^ 11100010b = 01110010b
-10010000b ^ 11100011b = 01110011b
-10010000b ^ 11100100b = 01110100b
-10010000b ^ 11100101b = 01110101b
-10010000b ^ 11100110b = 01110110b
-10010000b ^ 11100111b = 01110111b
-10010000b ^ 11101000b = 01111000b
-10010000b ^ 11101001b = 01111001b
-10010000b ^ 11101010b = 01111010b
-10010000b ^ 11101011b = 01111011b
-10010000b ^ 11101100b = 01111100b
-10010000b ^ 11101101b = 01111101b
-10010000b ^ 11101110b = 01111110b
-10010000b ^ 11101111b = 01111111b
-10010000b ^ 11110000b = 01100000b
-10010000b ^ 11110001b = 01100001b
-10010000b ^ 11110010b = 01100010b
-10010000b ^ 11110011b = 01100011b
-10010000b ^ 11110100b = 01100100b
-10010000b ^ 11110101b = 01100101b
-10010000b ^ 11110110b = 01100110b
-10010000b ^ 11110111b = 01100111b
-10010000b ^ 11111000b = 01101000b
-10010000b ^ 11111001b = 01101001b
-10010000b ^ 11111010b = 01101010b
-10010000b ^ 11111011b = 01101011b
-10010000b ^ 11111100b = 01101100b
-10010000b ^ 11111101b = 01101101b
-10010000b ^ 11111110b = 01101110b
-10010000b ^ 11111111b = 01101111b
-10010000b ^ 00000000b = 10010000b
-10010000b ^ 00000001b = 10010001b
-10010000b ^ 00000010b = 10010010b
-10010000b ^ 00000011b = 10010011b
-10010000b ^ 00000100b = 10010100b
-10010000b ^ 00000101b = 10010101b
-10010000b ^ 00000110b = 10010110b
-10010000b ^ 00000111b = 10010111b
-10010000b ^ 00001000b = 10011000b
-10010000b ^ 00001001b = 10011001b
-10010000b ^ 00001010b = 10011010b
-10010000b ^ 00001011b = 10011011b
-10010000b ^ 00001100b = 10011100b
-10010000b ^ 00001101b = 10011101b
-10010000b ^ 00001110b = 10011110b
-10010000b ^ 00001111b = 10011111b
-10010000b ^ 00010000b = 10000000b
-10010000b ^ 00010001b = 10000001b
-10010000b ^ 00010010b = 10000010b
-10010000b ^ 00010011b = 10000011b
-10010000b ^ 00010100b = 10000100b
-10010000b ^ 00010101b = 10000101b
-10010000b ^ 00010110b = 10000110b
-10010000b ^ 00010111b = 10000111b
-10010000b ^ 00011000b = 10001000b
-10010000b ^ 00011001b = 10001001b
-10010000b ^ 00011010b = 10001010b
-10010000b ^ 00011011b = 10001011b
-10010000b ^ 00011100b = 10001100b
-10010000b ^ 00011101b = 10001101b
-10010000b ^ 00011110b = 10001110b
-10010000b ^ 00011111b = 10001111b
-10010000b ^ 00100000b = 10110000b
-10010000b ^ 00100001b = 10110001b
-10010000b ^ 00100010b = 10110010b
-10010000b ^ 00100011b = 10110011b
-10010000b ^ 00100100b = 10110100b
-10010000b ^ 00100101b = 10110101b
-10010000b ^ 00100110b = 10110110b
-10010000b ^ 00100111b = 10110111b
-10010000b ^ 00101000b = 10111000b
-10010000b ^ 00101001b = 10111001b
-10010000b ^ 00101010b = 10111010b
-10010000b ^ 00101011b = 10111011b
-10010000b ^ 00101100b = 10111100b
-10010000b ^ 00101101b = 10111101b
-10010000b ^ 00101110b = 10111110b
-10010000b ^ 00101111b = 10111111b
-10010000b ^ 00110000b = 10100000b
-10010000b ^ 00110001b = 10100001b
-10010000b ^ 00110010b = 10100010b
-10010000b ^ 00110011b = 10100011b
-10010000b ^ 00110100b = 10100100b
-10010000b ^ 00110101b = 10100101b
-10010000b ^ 00110110b = 10100110b
-10010000b ^ 00110111b = 10100111b
-10010000b ^ 00111000b = 10101000b
-10010000b ^ 00111001b = 10101001b
-10010000b ^ 00111010b = 10101010b
-10010000b ^ 00111011b = 10101011b
-10010000b ^ 00111100b = 10101100b
-10010000b ^ 00111101b = 10101101b
-10010000b ^ 00111110b = 10101110b
-10010000b ^ 00111111b = 10101111b
-10010000b ^ 01000000b = 11010000b
-10010000b ^ 01000001b = 11010001b
-10010000b ^ 01000010b = 11010010b
-10010000b ^ 01000011b = 11010011b
-10010000b ^ 01000100b = 11010100b
-10010000b ^ 01000101b = 11010101b
-10010000b ^ 01000110b = 11010110b
-10010000b ^ 01000111b = 11010111b
-10010000b ^ 01001000b = 11011000b
-10010000b ^ 01001001b = 11011001b
-10010000b ^ 01001010b = 11011010b
-10010000b ^ 01001011b = 11011011b
-10010000b ^ 01001100b = 11011100b
-10010000b ^ 01001101b = 11011101b
-10010000b ^ 01001110b = 11011110b
-10010000b ^ 01001111b = 11011111b
-10010000b ^ 01010000b = 11000000b
-10010000b ^ 01010001b = 11000001b
-10010000b ^ 01010010b = 11000010b
-10010000b ^ 01010011b = 11000011b
-10010000b ^ 01010100b = 11000100b
-10010000b ^ 01010101b = 11000101b
-10010000b ^ 01010110b = 11000110b
-10010000b ^ 01010111b = 11000111b
-10010000b ^ 01011000b = 11001000b
-10010000b ^ 01011001b = 11001001b
-10010000b ^ 01011010b = 11001010b
-10010000b ^ 01011011b = 11001011b
-10010000b ^ 01011100b = 11001100b
-10010000b ^ 01011101b = 11001101b
-10010000b ^ 01011110b = 11001110b
-10010000b ^ 01011111b = 11001111b
-10010000b ^ 01100000b = 11110000b
-10010000b ^ 01100001b = 11110001b
-10010000b ^ 01100010b = 11110010b
-10010000b ^ 01100011b = 11110011b
-10010000b ^ 01100100b = 11110100b
-10010000b ^ 01100101b = 11110101b
-10010000b ^ 01100110b = 11110110b
-10010000b ^ 01100111b = 11110111b
-10010000b ^ 01101000b = 11111000b
-10010000b ^ 01101001b = 11111001b
-10010000b ^ 01101010b = 11111010b
-10010000b ^ 01101011b = 11111011b
-10010000b ^ 01101100b = 11111100b
-10010000b ^ 01101101b = 11111101b
-10010000b ^ 01101110b = 11111110b
-10010000b ^ 01101111b = 11111111b
-10010000b ^ 01110000b = 11100000b
-10010000b ^ 01110001b = 11100001b
-10010000b ^ 01110010b = 11100010b
-10010000b ^ 01110011b = 11100011b
-10010000b ^ 01110100b = 11100100b
-10010000b ^ 01110101b = 11100101b
-10010000b ^ 01110110b = 11100110b
-10010000b ^ 01110111b = 11100111b
-10010000b ^ 01111000b = 11101000b
-10010000b ^ 01111001b = 11101001b
-10010000b ^ 01111010b = 11101010b
-10010000b ^ 01111011b = 11101011b
-10010000b ^ 01111100b = 11101100b
-10010000b ^ 01111101b = 11101101b
-10010000b ^ 01111110b = 11101110b
-10010001b ^ 10000000b = 00010001b
-10010001b ^ 10000001b = 00010000b
-10010001b ^ 10000010b = 00010011b
-10010001b ^ 10000011b = 00010010b
-10010001b ^ 10000100b = 00010101b
-10010001b ^ 10000101b = 00010100b
-10010001b ^ 10000110b = 00010111b
-10010001b ^ 10000111b = 00010110b
-10010001b ^ 10001000b = 00011001b
-10010001b ^ 10001001b = 00011000b
-10010001b ^ 10001010b = 00011011b
-10010001b ^ 10001011b = 00011010b
-10010001b ^ 10001100b = 00011101b
-10010001b ^ 10001101b = 00011100b
-10010001b ^ 10001110b = 00011111b
-10010001b ^ 10001111b = 00011110b
-10010001b ^ 10010000b = 00000001b
-10010001b ^ 10010001b = 00000000b
-10010001b ^ 10010010b = 00000011b
-10010001b ^ 10010011b = 00000010b
-10010001b ^ 10010100b = 00000101b
-10010001b ^ 10010101b = 00000100b
-10010001b ^ 10010110b = 00000111b
-10010001b ^ 10010111b = 00000110b
-10010001b ^ 10011000b = 00001001b
-10010001b ^ 10011001b = 00001000b
-10010001b ^ 10011010b = 00001011b
-10010001b ^ 10011011b = 00001010b
-10010001b ^ 10011100b = 00001101b
-10010001b ^ 10011101b = 00001100b
-10010001b ^ 10011110b = 00001111b
-10010001b ^ 10011111b = 00001110b
-10010001b ^ 10100000b = 00110001b
-10010001b ^ 10100001b = 00110000b
-10010001b ^ 10100010b = 00110011b
-10010001b ^ 10100011b = 00110010b
-10010001b ^ 10100100b = 00110101b
-10010001b ^ 10100101b = 00110100b
-10010001b ^ 10100110b = 00110111b
-10010001b ^ 10100111b = 00110110b
-10010001b ^ 10101000b = 00111001b
-10010001b ^ 10101001b = 00111000b
-10010001b ^ 10101010b = 00111011b
-10010001b ^ 10101011b = 00111010b
-10010001b ^ 10101100b = 00111101b
-10010001b ^ 10101101b = 00111100b
-10010001b ^ 10101110b = 00111111b
-10010001b ^ 10101111b = 00111110b
-10010001b ^ 10110000b = 00100001b
-10010001b ^ 10110001b = 00100000b
-10010001b ^ 10110010b = 00100011b
-10010001b ^ 10110011b = 00100010b
-10010001b ^ 10110100b = 00100101b
-10010001b ^ 10110101b = 00100100b
-10010001b ^ 10110110b = 00100111b
-10010001b ^ 10110111b = 00100110b
-10010001b ^ 10111000b = 00101001b
-10010001b ^ 10111001b = 00101000b
-10010001b ^ 10111010b = 00101011b
-10010001b ^ 10111011b = 00101010b
-10010001b ^ 10111100b = 00101101b
-10010001b ^ 10111101b = 00101100b
-10010001b ^ 10111110b = 00101111b
-10010001b ^ 10111111b = 00101110b
-10010001b ^ 11000000b = 01010001b
-10010001b ^ 11000001b = 01010000b
-10010001b ^ 11000010b = 01010011b
-10010001b ^ 11000011b = 01010010b
-10010001b ^ 11000100b = 01010101b
-10010001b ^ 11000101b = 01010100b
-10010001b ^ 11000110b = 01010111b
-10010001b ^ 11000111b = 01010110b
-10010001b ^ 11001000b = 01011001b
-10010001b ^ 11001001b = 01011000b
-10010001b ^ 11001010b = 01011011b
-10010001b ^ 11001011b = 01011010b
-10010001b ^ 11001100b = 01011101b
-10010001b ^ 11001101b = 01011100b
-10010001b ^ 11001110b = 01011111b
-10010001b ^ 11001111b = 01011110b
-10010001b ^ 11010000b = 01000001b
-10010001b ^ 11010001b = 01000000b
-10010001b ^ 11010010b = 01000011b
-10010001b ^ 11010011b = 01000010b
-10010001b ^ 11010100b = 01000101b
-10010001b ^ 11010101b = 01000100b
-10010001b ^ 11010110b = 01000111b
-10010001b ^ 11010111b = 01000110b
-10010001b ^ 11011000b = 01001001b
-10010001b ^ 11011001b = 01001000b
-10010001b ^ 11011010b = 01001011b
-10010001b ^ 11011011b = 01001010b
-10010001b ^ 11011100b = 01001101b
-10010001b ^ 11011101b = 01001100b
-10010001b ^ 11011110b = 01001111b
-10010001b ^ 11011111b = 01001110b
-10010001b ^ 11100000b = 01110001b
-10010001b ^ 11100001b = 01110000b
-10010001b ^ 11100010b = 01110011b
-10010001b ^ 11100011b = 01110010b
-10010001b ^ 11100100b = 01110101b
-10010001b ^ 11100101b = 01110100b
-10010001b ^ 11100110b = 01110111b
-10010001b ^ 11100111b = 01110110b
-10010001b ^ 11101000b = 01111001b
-10010001b ^ 11101001b = 01111000b
-10010001b ^ 11101010b = 01111011b
-10010001b ^ 11101011b = 01111010b
-10010001b ^ 11101100b = 01111101b
-10010001b ^ 11101101b = 01111100b
-10010001b ^ 11101110b = 01111111b
-10010001b ^ 11101111b = 01111110b
-10010001b ^ 11110000b = 01100001b
-10010001b ^ 11110001b = 01100000b
-10010001b ^ 11110010b = 01100011b
-10010001b ^ 11110011b = 01100010b
-10010001b ^ 11110100b = 01100101b
-10010001b ^ 11110101b = 01100100b
-10010001b ^ 11110110b = 01100111b
-10010001b ^ 11110111b = 01100110b
-10010001b ^ 11111000b = 01101001b
-10010001b ^ 11111001b = 01101000b
-10010001b ^ 11111010b = 01101011b
-10010001b ^ 11111011b = 01101010b
-10010001b ^ 11111100b = 01101101b
-10010001b ^ 11111101b = 01101100b
-10010001b ^ 11111110b = 01101111b
-10010001b ^ 11111111b = 01101110b
-10010001b ^ 00000000b = 10010001b
-10010001b ^ 00000001b = 10010000b
-10010001b ^ 00000010b = 10010011b
-10010001b ^ 00000011b = 10010010b
-10010001b ^ 00000100b = 10010101b
-10010001b ^ 00000101b = 10010100b
-10010001b ^ 00000110b = 10010111b
-10010001b ^ 00000111b = 10010110b
-10010001b ^ 00001000b = 10011001b
-10010001b ^ 00001001b = 10011000b
-10010001b ^ 00001010b = 10011011b
-10010001b ^ 00001011b = 10011010b
-10010001b ^ 00001100b = 10011101b
-10010001b ^ 00001101b = 10011100b
-10010001b ^ 00001110b = 10011111b
-10010001b ^ 00001111b = 10011110b
-10010001b ^ 00010000b = 10000001b
-10010001b ^ 00010001b = 10000000b
-10010001b ^ 00010010b = 10000011b
-10010001b ^ 00010011b = 10000010b
-10010001b ^ 00010100b = 10000101b
-10010001b ^ 00010101b = 10000100b
-10010001b ^ 00010110b = 10000111b
-10010001b ^ 00010111b = 10000110b
-10010001b ^ 00011000b = 10001001b
-10010001b ^ 00011001b = 10001000b
-10010001b ^ 00011010b = 10001011b
-10010001b ^ 00011011b = 10001010b
-10010001b ^ 00011100b = 10001101b
-10010001b ^ 00011101b = 10001100b
-10010001b ^ 00011110b = 10001111b
-10010001b ^ 00011111b = 10001110b
-10010001b ^ 00100000b = 10110001b
-10010001b ^ 00100001b = 10110000b
-10010001b ^ 00100010b = 10110011b
-10010001b ^ 00100011b = 10110010b
-10010001b ^ 00100100b = 10110101b
-10010001b ^ 00100101b = 10110100b
-10010001b ^ 00100110b = 10110111b
-10010001b ^ 00100111b = 10110110b
-10010001b ^ 00101000b = 10111001b
-10010001b ^ 00101001b = 10111000b
-10010001b ^ 00101010b = 10111011b
-10010001b ^ 00101011b = 10111010b
-10010001b ^ 00101100b = 10111101b
-10010001b ^ 00101101b = 10111100b
-10010001b ^ 00101110b = 10111111b
-10010001b ^ 00101111b = 10111110b
-10010001b ^ 00110000b = 10100001b
-10010001b ^ 00110001b = 10100000b
-10010001b ^ 00110010b = 10100011b
-10010001b ^ 00110011b = 10100010b
-10010001b ^ 00110100b = 10100101b
-10010001b ^ 00110101b = 10100100b
-10010001b ^ 00110110b = 10100111b
-10010001b ^ 00110111b = 10100110b
-10010001b ^ 00111000b = 10101001b
-10010001b ^ 00111001b = 10101000b
-10010001b ^ 00111010b = 10101011b
-10010001b ^ 00111011b = 10101010b
-10010001b ^ 00111100b = 10101101b
-10010001b ^ 00111101b = 10101100b
-10010001b ^ 00111110b = 10101111b
-10010001b ^ 00111111b = 10101110b
-10010001b ^ 01000000b = 11010001b
-10010001b ^ 01000001b = 11010000b
-10010001b ^ 01000010b = 11010011b
-10010001b ^ 01000011b = 11010010b
-10010001b ^ 01000100b = 11010101b
-10010001b ^ 01000101b = 11010100b
-10010001b ^ 01000110b = 11010111b
-10010001b ^ 01000111b = 11010110b
-10010001b ^ 01001000b = 11011001b
-10010001b ^ 01001001b = 11011000b
-10010001b ^ 01001010b = 11011011b
-10010001b ^ 01001011b = 11011010b
-10010001b ^ 01001100b = 11011101b
-10010001b ^ 01001101b = 11011100b
-10010001b ^ 01001110b = 11011111b
-10010001b ^ 01001111b = 11011110b
-10010001b ^ 01010000b = 11000001b
-10010001b ^ 01010001b = 11000000b
-10010001b ^ 01010010b = 11000011b
-10010001b ^ 01010011b = 11000010b
-10010001b ^ 01010100b = 11000101b
-10010001b ^ 01010101b = 11000100b
-10010001b ^ 01010110b = 11000111b
-10010001b ^ 01010111b = 11000110b
-10010001b ^ 01011000b = 11001001b
-10010001b ^ 01011001b = 11001000b
-10010001b ^ 01011010b = 11001011b
-10010001b ^ 01011011b = 11001010b
-10010001b ^ 01011100b = 11001101b
-10010001b ^ 01011101b = 11001100b
-10010001b ^ 01011110b = 11001111b
-10010001b ^ 01011111b = 11001110b
-10010001b ^ 01100000b = 11110001b
-10010001b ^ 01100001b = 11110000b
-10010001b ^ 01100010b = 11110011b
-10010001b ^ 01100011b = 11110010b
-10010001b ^ 01100100b = 11110101b
-10010001b ^ 01100101b = 11110100b
-10010001b ^ 01100110b = 11110111b
-10010001b ^ 01100111b = 11110110b
-10010001b ^ 01101000b = 11111001b
-10010001b ^ 01101001b = 11111000b
-10010001b ^ 01101010b = 11111011b
-10010001b ^ 01101011b = 11111010b
-10010001b ^ 01101100b = 11111101b
-10010001b ^ 01101101b = 11111100b
-10010001b ^ 01101110b = 11111111b
-10010001b ^ 01101111b = 11111110b
-10010001b ^ 01110000b = 11100001b
-10010001b ^ 01110001b = 11100000b
-10010001b ^ 01110010b = 11100011b
-10010001b ^ 01110011b = 11100010b
-10010001b ^ 01110100b = 11100101b
-10010001b ^ 01110101b = 11100100b
-10010001b ^ 01110110b = 11100111b
-10010001b ^ 01110111b = 11100110b
-10010001b ^ 01111000b = 11101001b
-10010001b ^ 01111001b = 11101000b
-10010001b ^ 01111010b = 11101011b
-10010001b ^ 01111011b = 11101010b
-10010001b ^ 01111100b = 11101101b
-10010001b ^ 01111101b = 11101100b
-10010001b ^ 01111110b = 11101111b
-10010010b ^ 10000000b = 00010010b
-10010010b ^ 10000001b = 00010011b
-10010010b ^ 10000010b = 00010000b
-10010010b ^ 10000011b = 00010001b
-10010010b ^ 10000100b = 00010110b
-10010010b ^ 10000101b = 00010111b
-10010010b ^ 10000110b = 00010100b
-10010010b ^ 10000111b = 00010101b
-10010010b ^ 10001000b = 00011010b
-10010010b ^ 10001001b = 00011011b
-10010010b ^ 10001010b = 00011000b
-10010010b ^ 10001011b = 00011001b
-10010010b ^ 10001100b = 00011110b
-10010010b ^ 10001101b = 00011111b
-10010010b ^ 10001110b = 00011100b
-10010010b ^ 10001111b = 00011101b
-10010010b ^ 10010000b = 00000010b
-10010010b ^ 10010001b = 00000011b
-10010010b ^ 10010010b = 00000000b
-10010010b ^ 10010011b = 00000001b
-10010010b ^ 10010100b = 00000110b
-10010010b ^ 10010101b = 00000111b
-10010010b ^ 10010110b = 00000100b
-10010010b ^ 10010111b = 00000101b
-10010010b ^ 10011000b = 00001010b
-10010010b ^ 10011001b = 00001011b
-10010010b ^ 10011010b = 00001000b
-10010010b ^ 10011011b = 00001001b
-10010010b ^ 10011100b = 00001110b
-10010010b ^ 10011101b = 00001111b
-10010010b ^ 10011110b = 00001100b
-10010010b ^ 10011111b = 00001101b
-10010010b ^ 10100000b = 00110010b
-10010010b ^ 10100001b = 00110011b
-10010010b ^ 10100010b = 00110000b
-10010010b ^ 10100011b = 00110001b
-10010010b ^ 10100100b = 00110110b
-10010010b ^ 10100101b = 00110111b
-10010010b ^ 10100110b = 00110100b
-10010010b ^ 10100111b = 00110101b
-10010010b ^ 10101000b = 00111010b
-10010010b ^ 10101001b = 00111011b
-10010010b ^ 10101010b = 00111000b
-10010010b ^ 10101011b = 00111001b
-10010010b ^ 10101100b = 00111110b
-10010010b ^ 10101101b = 00111111b
-10010010b ^ 10101110b = 00111100b
-10010010b ^ 10101111b = 00111101b
-10010010b ^ 10110000b = 00100010b
-10010010b ^ 10110001b = 00100011b
-10010010b ^ 10110010b = 00100000b
-10010010b ^ 10110011b = 00100001b
-10010010b ^ 10110100b = 00100110b
-10010010b ^ 10110101b = 00100111b
-10010010b ^ 10110110b = 00100100b
-10010010b ^ 10110111b = 00100101b
-10010010b ^ 10111000b = 00101010b
-10010010b ^ 10111001b = 00101011b
-10010010b ^ 10111010b = 00101000b
-10010010b ^ 10111011b = 00101001b
-10010010b ^ 10111100b = 00101110b
-10010010b ^ 10111101b = 00101111b
-10010010b ^ 10111110b = 00101100b
-10010010b ^ 10111111b = 00101101b
-10010010b ^ 11000000b = 01010010b
-10010010b ^ 11000001b = 01010011b
-10010010b ^ 11000010b = 01010000b
-10010010b ^ 11000011b = 01010001b
-10010010b ^ 11000100b = 01010110b
-10010010b ^ 11000101b = 01010111b
-10010010b ^ 11000110b = 01010100b
-10010010b ^ 11000111b = 01010101b
-10010010b ^ 11001000b = 01011010b
-10010010b ^ 11001001b = 01011011b
-10010010b ^ 11001010b = 01011000b
-10010010b ^ 11001011b = 01011001b
-10010010b ^ 11001100b = 01011110b
-10010010b ^ 11001101b = 01011111b
-10010010b ^ 11001110b = 01011100b
-10010010b ^ 11001111b = 01011101b
-10010010b ^ 11010000b = 01000010b
-10010010b ^ 11010001b = 01000011b
-10010010b ^ 11010010b = 01000000b
-10010010b ^ 11010011b = 01000001b
-10010010b ^ 11010100b = 01000110b
-10010010b ^ 11010101b = 01000111b
-10010010b ^ 11010110b = 01000100b
-10010010b ^ 11010111b = 01000101b
-10010010b ^ 11011000b = 01001010b
-10010010b ^ 11011001b = 01001011b
-10010010b ^ 11011010b = 01001000b
-10010010b ^ 11011011b = 01001001b
-10010010b ^ 11011100b = 01001110b
-10010010b ^ 11011101b = 01001111b
-10010010b ^ 11011110b = 01001100b
-10010010b ^ 11011111b = 01001101b
-10010010b ^ 11100000b = 01110010b
-10010010b ^ 11100001b = 01110011b
-10010010b ^ 11100010b = 01110000b
-10010010b ^ 11100011b = 01110001b
-10010010b ^ 11100100b = 01110110b
-10010010b ^ 11100101b = 01110111b
-10010010b ^ 11100110b = 01110100b
-10010010b ^ 11100111b = 01110101b
-10010010b ^ 11101000b = 01111010b
-10010010b ^ 11101001b = 01111011b
-10010010b ^ 11101010b = 01111000b
-10010010b ^ 11101011b = 01111001b
-10010010b ^ 11101100b = 01111110b
-10010010b ^ 11101101b = 01111111b
-10010010b ^ 11101110b = 01111100b
-10010010b ^ 11101111b = 01111101b
-10010010b ^ 11110000b = 01100010b
-10010010b ^ 11110001b = 01100011b
-10010010b ^ 11110010b = 01100000b
-10010010b ^ 11110011b = 01100001b
-10010010b ^ 11110100b = 01100110b
-10010010b ^ 11110101b = 01100111b
-10010010b ^ 11110110b = 01100100b
-10010010b ^ 11110111b = 01100101b
-10010010b ^ 11111000b = 01101010b
-10010010b ^ 11111001b = 01101011b
-10010010b ^ 11111010b = 01101000b
-10010010b ^ 11111011b = 01101001b
-10010010b ^ 11111100b = 01101110b
-10010010b ^ 11111101b = 01101111b
-10010010b ^ 11111110b = 01101100b
-10010010b ^ 11111111b = 01101101b
-10010010b ^ 00000000b = 10010010b
-10010010b ^ 00000001b = 10010011b
-10010010b ^ 00000010b = 10010000b
-10010010b ^ 00000011b = 10010001b
-10010010b ^ 00000100b = 10010110b
-10010010b ^ 00000101b = 10010111b
-10010010b ^ 00000110b = 10010100b
-10010010b ^ 00000111b = 10010101b
-10010010b ^ 00001000b = 10011010b
-10010010b ^ 00001001b = 10011011b
-10010010b ^ 00001010b = 10011000b
-10010010b ^ 00001011b = 10011001b
-10010010b ^ 00001100b = 10011110b
-10010010b ^ 00001101b = 10011111b
-10010010b ^ 00001110b = 10011100b
-10010010b ^ 00001111b = 10011101b
-10010010b ^ 00010000b = 10000010b
-10010010b ^ 00010001b = 10000011b
-10010010b ^ 00010010b = 10000000b
-10010010b ^ 00010011b = 10000001b
-10010010b ^ 00010100b = 10000110b
-10010010b ^ 00010101b = 10000111b
-10010010b ^ 00010110b = 10000100b
-10010010b ^ 00010111b = 10000101b
-10010010b ^ 00011000b = 10001010b
-10010010b ^ 00011001b = 10001011b
-10010010b ^ 00011010b = 10001000b
-10010010b ^ 00011011b = 10001001b
-10010010b ^ 00011100b = 10001110b
-10010010b ^ 00011101b = 10001111b
-10010010b ^ 00011110b = 10001100b
-10010010b ^ 00011111b = 10001101b
-10010010b ^ 00100000b = 10110010b
-10010010b ^ 00100001b = 10110011b
-10010010b ^ 00100010b = 10110000b
-10010010b ^ 00100011b = 10110001b
-10010010b ^ 00100100b = 10110110b
-10010010b ^ 00100101b = 10110111b
-10010010b ^ 00100110b = 10110100b
-10010010b ^ 00100111b = 10110101b
-10010010b ^ 00101000b = 10111010b
-10010010b ^ 00101001b = 10111011b
-10010010b ^ 00101010b = 10111000b
-10010010b ^ 00101011b = 10111001b
-10010010b ^ 00101100b = 10111110b
-10010010b ^ 00101101b = 10111111b
-10010010b ^ 00101110b = 10111100b
-10010010b ^ 00101111b = 10111101b
-10010010b ^ 00110000b = 10100010b
-10010010b ^ 00110001b = 10100011b
-10010010b ^ 00110010b = 10100000b
-10010010b ^ 00110011b = 10100001b
-10010010b ^ 00110100b = 10100110b
-10010010b ^ 00110101b = 10100111b
-10010010b ^ 00110110b = 10100100b
-10010010b ^ 00110111b = 10100101b
-10010010b ^ 00111000b = 10101010b
-10010010b ^ 00111001b = 10101011b
-10010010b ^ 00111010b = 10101000b
-10010010b ^ 00111011b = 10101001b
-10010010b ^ 00111100b = 10101110b
-10010010b ^ 00111101b = 10101111b
-10010010b ^ 00111110b = 10101100b
-10010010b ^ 00111111b = 10101101b
-10010010b ^ 01000000b = 11010010b
-10010010b ^ 01000001b = 11010011b
-10010010b ^ 01000010b = 11010000b
-10010010b ^ 01000011b = 11010001b
-10010010b ^ 01000100b = 11010110b
-10010010b ^ 01000101b = 11010111b
-10010010b ^ 01000110b = 11010100b
-10010010b ^ 01000111b = 11010101b
-10010010b ^ 01001000b = 11011010b
-10010010b ^ 01001001b = 11011011b
-10010010b ^ 01001010b = 11011000b
-10010010b ^ 01001011b = 11011001b
-10010010b ^ 01001100b = 11011110b
-10010010b ^ 01001101b = 11011111b
-10010010b ^ 01001110b = 11011100b
-10010010b ^ 01001111b = 11011101b
-10010010b ^ 01010000b = 11000010b
-10010010b ^ 01010001b = 11000011b
-10010010b ^ 01010010b = 11000000b
-10010010b ^ 01010011b = 11000001b
-10010010b ^ 01010100b = 11000110b
-10010010b ^ 01010101b = 11000111b
-10010010b ^ 01010110b = 11000100b
-10010010b ^ 01010111b = 11000101b
-10010010b ^ 01011000b = 11001010b
-10010010b ^ 01011001b = 11001011b
-10010010b ^ 01011010b = 11001000b
-10010010b ^ 01011011b = 11001001b
-10010010b ^ 01011100b = 11001110b
-10010010b ^ 01011101b = 11001111b
-10010010b ^ 01011110b = 11001100b
-10010010b ^ 01011111b = 11001101b
-10010010b ^ 01100000b = 11110010b
-10010010b ^ 01100001b = 11110011b
-10010010b ^ 01100010b = 11110000b
-10010010b ^ 01100011b = 11110001b
-10010010b ^ 01100100b = 11110110b
-10010010b ^ 01100101b = 11110111b
-10010010b ^ 01100110b = 11110100b
-10010010b ^ 01100111b = 11110101b
-10010010b ^ 01101000b = 11111010b
-10010010b ^ 01101001b = 11111011b
-10010010b ^ 01101010b = 11111000b
-10010010b ^ 01101011b = 11111001b
-10010010b ^ 01101100b = 11111110b
-10010010b ^ 01101101b = 11111111b
-10010010b ^ 01101110b = 11111100b
-10010010b ^ 01101111b = 11111101b
-10010010b ^ 01110000b = 11100010b
-10010010b ^ 01110001b = 11100011b
-10010010b ^ 01110010b = 11100000b
-10010010b ^ 01110011b = 11100001b
-10010010b ^ 01110100b = 11100110b
-10010010b ^ 01110101b = 11100111b
-10010010b ^ 01110110b = 11100100b
-10010010b ^ 01110111b = 11100101b
-10010010b ^ 01111000b = 11101010b
-10010010b ^ 01111001b = 11101011b
-10010010b ^ 01111010b = 11101000b
-10010010b ^ 01111011b = 11101001b
-10010010b ^ 01111100b = 11101110b
-10010010b ^ 01111101b = 11101111b
-10010010b ^ 01111110b = 11101100b
-10010011b ^ 10000000b = 00010011b
-10010011b ^ 10000001b = 00010010b
-10010011b ^ 10000010b = 00010001b
-10010011b ^ 10000011b = 00010000b
-10010011b ^ 10000100b = 00010111b
-10010011b ^ 10000101b = 00010110b
-10010011b ^ 10000110b = 00010101b
-10010011b ^ 10000111b = 00010100b
-10010011b ^ 10001000b = 00011011b
-10010011b ^ 10001001b = 00011010b
-10010011b ^ 10001010b = 00011001b
-10010011b ^ 10001011b = 00011000b
-10010011b ^ 10001100b = 00011111b
-10010011b ^ 10001101b = 00011110b
-10010011b ^ 10001110b = 00011101b
-10010011b ^ 10001111b = 00011100b
-10010011b ^ 10010000b = 00000011b
-10010011b ^ 10010001b = 00000010b
-10010011b ^ 10010010b = 00000001b
-10010011b ^ 10010011b = 00000000b
-10010011b ^ 10010100b = 00000111b
-10010011b ^ 10010101b = 00000110b
-10010011b ^ 10010110b = 00000101b
-10010011b ^ 10010111b = 00000100b
-10010011b ^ 10011000b = 00001011b
-10010011b ^ 10011001b = 00001010b
-10010011b ^ 10011010b = 00001001b
-10010011b ^ 10011011b = 00001000b
-10010011b ^ 10011100b = 00001111b
-10010011b ^ 10011101b = 00001110b
-10010011b ^ 10011110b = 00001101b
-10010011b ^ 10011111b = 00001100b
-10010011b ^ 10100000b = 00110011b
-10010011b ^ 10100001b = 00110010b
-10010011b ^ 10100010b = 00110001b
-10010011b ^ 10100011b = 00110000b
-10010011b ^ 10100100b = 00110111b
-10010011b ^ 10100101b = 00110110b
-10010011b ^ 10100110b = 00110101b
-10010011b ^ 10100111b = 00110100b
-10010011b ^ 10101000b = 00111011b
-10010011b ^ 10101001b = 00111010b
-10010011b ^ 10101010b = 00111001b
-10010011b ^ 10101011b = 00111000b
-10010011b ^ 10101100b = 00111111b
-10010011b ^ 10101101b = 00111110b
-10010011b ^ 10101110b = 00111101b
-10010011b ^ 10101111b = 00111100b
-10010011b ^ 10110000b = 00100011b
-10010011b ^ 10110001b = 00100010b
-10010011b ^ 10110010b = 00100001b
-10010011b ^ 10110011b = 00100000b
-10010011b ^ 10110100b = 00100111b
-10010011b ^ 10110101b = 00100110b
-10010011b ^ 10110110b = 00100101b
-10010011b ^ 10110111b = 00100100b
-10010011b ^ 10111000b = 00101011b
-10010011b ^ 10111001b = 00101010b
-10010011b ^ 10111010b = 00101001b
-10010011b ^ 10111011b = 00101000b
-10010011b ^ 10111100b = 00101111b
-10010011b ^ 10111101b = 00101110b
-10010011b ^ 10111110b = 00101101b
-10010011b ^ 10111111b = 00101100b
-10010011b ^ 11000000b = 01010011b
-10010011b ^ 11000001b = 01010010b
-10010011b ^ 11000010b = 01010001b
-10010011b ^ 11000011b = 01010000b
-10010011b ^ 11000100b = 01010111b
-10010011b ^ 11000101b = 01010110b
-10010011b ^ 11000110b = 01010101b
-10010011b ^ 11000111b = 01010100b
-10010011b ^ 11001000b = 01011011b
-10010011b ^ 11001001b = 01011010b
-10010011b ^ 11001010b = 01011001b
-10010011b ^ 11001011b = 01011000b
-10010011b ^ 11001100b = 01011111b
-10010011b ^ 11001101b = 01011110b
-10010011b ^ 11001110b = 01011101b
-10010011b ^ 11001111b = 01011100b
-10010011b ^ 11010000b = 01000011b
-10010011b ^ 11010001b = 01000010b
-10010011b ^ 11010010b = 01000001b
-10010011b ^ 11010011b = 01000000b
-10010011b ^ 11010100b = 01000111b
-10010011b ^ 11010101b = 01000110b
-10010011b ^ 11010110b = 01000101b
-10010011b ^ 11010111b = 01000100b
-10010011b ^ 11011000b = 01001011b
-10010011b ^ 11011001b = 01001010b
-10010011b ^ 11011010b = 01001001b
-10010011b ^ 11011011b = 01001000b
-10010011b ^ 11011100b = 01001111b
-10010011b ^ 11011101b = 01001110b
-10010011b ^ 11011110b = 01001101b
-10010011b ^ 11011111b = 01001100b
-10010011b ^ 11100000b = 01110011b
-10010011b ^ 11100001b = 01110010b
-10010011b ^ 11100010b = 01110001b
-10010011b ^ 11100011b = 01110000b
-10010011b ^ 11100100b = 01110111b
-10010011b ^ 11100101b = 01110110b
-10010011b ^ 11100110b = 01110101b
-10010011b ^ 11100111b = 01110100b
-10010011b ^ 11101000b = 01111011b
-10010011b ^ 11101001b = 01111010b
-10010011b ^ 11101010b = 01111001b
-10010011b ^ 11101011b = 01111000b
-10010011b ^ 11101100b = 01111111b
-10010011b ^ 11101101b = 01111110b
-10010011b ^ 11101110b = 01111101b
-10010011b ^ 11101111b = 01111100b
-10010011b ^ 11110000b = 01100011b
-10010011b ^ 11110001b = 01100010b
-10010011b ^ 11110010b = 01100001b
-10010011b ^ 11110011b = 01100000b
-10010011b ^ 11110100b = 01100111b
-10010011b ^ 11110101b = 01100110b
-10010011b ^ 11110110b = 01100101b
-10010011b ^ 11110111b = 01100100b
-10010011b ^ 11111000b = 01101011b
-10010011b ^ 11111001b = 01101010b
-10010011b ^ 11111010b = 01101001b
-10010011b ^ 11111011b = 01101000b
-10010011b ^ 11111100b = 01101111b
-10010011b ^ 11111101b = 01101110b
-10010011b ^ 11111110b = 01101101b
-10010011b ^ 11111111b = 01101100b
-10010011b ^ 00000000b = 10010011b
-10010011b ^ 00000001b = 10010010b
-10010011b ^ 00000010b = 10010001b
-10010011b ^ 00000011b = 10010000b
-10010011b ^ 00000100b = 10010111b
-10010011b ^ 00000101b = 10010110b
-10010011b ^ 00000110b = 10010101b
-10010011b ^ 00000111b = 10010100b
-10010011b ^ 00001000b = 10011011b
-10010011b ^ 00001001b = 10011010b
-10010011b ^ 00001010b = 10011001b
-10010011b ^ 00001011b = 10011000b
-10010011b ^ 00001100b = 10011111b
-10010011b ^ 00001101b = 10011110b
-10010011b ^ 00001110b = 10011101b
-10010011b ^ 00001111b = 10011100b
-10010011b ^ 00010000b = 10000011b
-10010011b ^ 00010001b = 10000010b
-10010011b ^ 00010010b = 10000001b
-10010011b ^ 00010011b = 10000000b
-10010011b ^ 00010100b = 10000111b
-10010011b ^ 00010101b = 10000110b
-10010011b ^ 00010110b = 10000101b
-10010011b ^ 00010111b = 10000100b
-10010011b ^ 00011000b = 10001011b
-10010011b ^ 00011001b = 10001010b
-10010011b ^ 00011010b = 10001001b
-10010011b ^ 00011011b = 10001000b
-10010011b ^ 00011100b = 10001111b
-10010011b ^ 00011101b = 10001110b
-10010011b ^ 00011110b = 10001101b
-10010011b ^ 00011111b = 10001100b
-10010011b ^ 00100000b = 10110011b
-10010011b ^ 00100001b = 10110010b
-10010011b ^ 00100010b = 10110001b
-10010011b ^ 00100011b = 10110000b
-10010011b ^ 00100100b = 10110111b
-10010011b ^ 00100101b = 10110110b
-10010011b ^ 00100110b = 10110101b
-10010011b ^ 00100111b = 10110100b
-10010011b ^ 00101000b = 10111011b
-10010011b ^ 00101001b = 10111010b
-10010011b ^ 00101010b = 10111001b
-10010011b ^ 00101011b = 10111000b
-10010011b ^ 00101100b = 10111111b
-10010011b ^ 00101101b = 10111110b
-10010011b ^ 00101110b = 10111101b
-10010011b ^ 00101111b = 10111100b
-10010011b ^ 00110000b = 10100011b
-10010011b ^ 00110001b = 10100010b
-10010011b ^ 00110010b = 10100001b
-10010011b ^ 00110011b = 10100000b
-10010011b ^ 00110100b = 10100111b
-10010011b ^ 00110101b = 10100110b
-10010011b ^ 00110110b = 10100101b
-10010011b ^ 00110111b = 10100100b
-10010011b ^ 00111000b = 10101011b
-10010011b ^ 00111001b = 10101010b
-10010011b ^ 00111010b = 10101001b
-10010011b ^ 00111011b = 10101000b
-10010011b ^ 00111100b = 10101111b
-10010011b ^ 00111101b = 10101110b
-10010011b ^ 00111110b = 10101101b
-10010011b ^ 00111111b = 10101100b
-10010011b ^ 01000000b = 11010011b
-10010011b ^ 01000001b = 11010010b
-10010011b ^ 01000010b = 11010001b
-10010011b ^ 01000011b = 11010000b
-10010011b ^ 01000100b = 11010111b
-10010011b ^ 01000101b = 11010110b
-10010011b ^ 01000110b = 11010101b
-10010011b ^ 01000111b = 11010100b
-10010011b ^ 01001000b = 11011011b
-10010011b ^ 01001001b = 11011010b
-10010011b ^ 01001010b = 11011001b
-10010011b ^ 01001011b = 11011000b
-10010011b ^ 01001100b = 11011111b
-10010011b ^ 01001101b = 11011110b
-10010011b ^ 01001110b = 11011101b
-10010011b ^ 01001111b = 11011100b
-10010011b ^ 01010000b = 11000011b
-10010011b ^ 01010001b = 11000010b
-10010011b ^ 01010010b = 11000001b
-10010011b ^ 01010011b = 11000000b
-10010011b ^ 01010100b = 11000111b
-10010011b ^ 01010101b = 11000110b
-10010011b ^ 01010110b = 11000101b
-10010011b ^ 01010111b = 11000100b
-10010011b ^ 01011000b = 11001011b
-10010011b ^ 01011001b = 11001010b
-10010011b ^ 01011010b = 11001001b
-10010011b ^ 01011011b = 11001000b
-10010011b ^ 01011100b = 11001111b
-10010011b ^ 01011101b = 11001110b
-10010011b ^ 01011110b = 11001101b
-10010011b ^ 01011111b = 11001100b
-10010011b ^ 01100000b = 11110011b
-10010011b ^ 01100001b = 11110010b
-10010011b ^ 01100010b = 11110001b
-10010011b ^ 01100011b = 11110000b
-10010011b ^ 01100100b = 11110111b
-10010011b ^ 01100101b = 11110110b
-10010011b ^ 01100110b = 11110101b
-10010011b ^ 01100111b = 11110100b
-10010011b ^ 01101000b = 11111011b
-10010011b ^ 01101001b = 11111010b
-10010011b ^ 01101010b = 11111001b
-10010011b ^ 01101011b = 11111000b
-10010011b ^ 01101100b = 11111111b
-10010011b ^ 01101101b = 11111110b
-10010011b ^ 01101110b = 11111101b
-10010011b ^ 01101111b = 11111100b
-10010011b ^ 01110000b = 11100011b
-10010011b ^ 01110001b = 11100010b
-10010011b ^ 01110010b = 11100001b
-10010011b ^ 01110011b = 11100000b
-10010011b ^ 01110100b = 11100111b
-10010011b ^ 01110101b = 11100110b
-10010011b ^ 01110110b = 11100101b
-10010011b ^ 01110111b = 11100100b
-10010011b ^ 01111000b = 11101011b
-10010011b ^ 01111001b = 11101010b
-10010011b ^ 01111010b = 11101001b
-10010011b ^ 01111011b = 11101000b
-10010011b ^ 01111100b = 11101111b
-10010011b ^ 01111101b = 11101110b
-10010011b ^ 01111110b = 11101101b
-10010100b ^ 10000000b = 00010100b
-10010100b ^ 10000001b = 00010101b
-10010100b ^ 10000010b = 00010110b
-10010100b ^ 10000011b = 00010111b
-10010100b ^ 10000100b = 00010000b
-10010100b ^ 10000101b = 00010001b
-10010100b ^ 10000110b = 00010010b
-10010100b ^ 10000111b = 00010011b
-10010100b ^ 10001000b = 00011100b
-10010100b ^ 10001001b = 00011101b
-10010100b ^ 10001010b = 00011110b
-10010100b ^ 10001011b = 00011111b
-10010100b ^ 10001100b = 00011000b
-10010100b ^ 10001101b = 00011001b
-10010100b ^ 10001110b = 00011010b
-10010100b ^ 10001111b = 00011011b
-10010100b ^ 10010000b = 00000100b
-10010100b ^ 10010001b = 00000101b
-10010100b ^ 10010010b = 00000110b
-10010100b ^ 10010011b = 00000111b
-10010100b ^ 10010100b = 00000000b
-10010100b ^ 10010101b = 00000001b
-10010100b ^ 10010110b = 00000010b
-10010100b ^ 10010111b = 00000011b
-10010100b ^ 10011000b = 00001100b
-10010100b ^ 10011001b = 00001101b
-10010100b ^ 10011010b = 00001110b
-10010100b ^ 10011011b = 00001111b
-10010100b ^ 10011100b = 00001000b
-10010100b ^ 10011101b = 00001001b
-10010100b ^ 10011110b = 00001010b
-10010100b ^ 10011111b = 00001011b
-10010100b ^ 10100000b = 00110100b
-10010100b ^ 10100001b = 00110101b
-10010100b ^ 10100010b = 00110110b
-10010100b ^ 10100011b = 00110111b
-10010100b ^ 10100100b = 00110000b
-10010100b ^ 10100101b = 00110001b
-10010100b ^ 10100110b = 00110010b
-10010100b ^ 10100111b = 00110011b
-10010100b ^ 10101000b = 00111100b
-10010100b ^ 10101001b = 00111101b
-10010100b ^ 10101010b = 00111110b
-10010100b ^ 10101011b = 00111111b
-10010100b ^ 10101100b = 00111000b
-10010100b ^ 10101101b = 00111001b
-10010100b ^ 10101110b = 00111010b
-10010100b ^ 10101111b = 00111011b
-10010100b ^ 10110000b = 00100100b
-10010100b ^ 10110001b = 00100101b
-10010100b ^ 10110010b = 00100110b
-10010100b ^ 10110011b = 00100111b
-10010100b ^ 10110100b = 00100000b
-10010100b ^ 10110101b = 00100001b
-10010100b ^ 10110110b = 00100010b
-10010100b ^ 10110111b = 00100011b
-10010100b ^ 10111000b = 00101100b
-10010100b ^ 10111001b = 00101101b
-10010100b ^ 10111010b = 00101110b
-10010100b ^ 10111011b = 00101111b
-10010100b ^ 10111100b = 00101000b
-10010100b ^ 10111101b = 00101001b
-10010100b ^ 10111110b = 00101010b
-10010100b ^ 10111111b = 00101011b
-10010100b ^ 11000000b = 01010100b
-10010100b ^ 11000001b = 01010101b
-10010100b ^ 11000010b = 01010110b
-10010100b ^ 11000011b = 01010111b
-10010100b ^ 11000100b = 01010000b
-10010100b ^ 11000101b = 01010001b
-10010100b ^ 11000110b = 01010010b
-10010100b ^ 11000111b = 01010011b
-10010100b ^ 11001000b = 01011100b
-10010100b ^ 11001001b = 01011101b
-10010100b ^ 11001010b = 01011110b
-10010100b ^ 11001011b = 01011111b
-10010100b ^ 11001100b = 01011000b
-10010100b ^ 11001101b = 01011001b
-10010100b ^ 11001110b = 01011010b
-10010100b ^ 11001111b = 01011011b
-10010100b ^ 11010000b = 01000100b
-10010100b ^ 11010001b = 01000101b
-10010100b ^ 11010010b = 01000110b
-10010100b ^ 11010011b = 01000111b
-10010100b ^ 11010100b = 01000000b
-10010100b ^ 11010101b = 01000001b
-10010100b ^ 11010110b = 01000010b
-10010100b ^ 11010111b = 01000011b
-10010100b ^ 11011000b = 01001100b
-10010100b ^ 11011001b = 01001101b
-10010100b ^ 11011010b = 01001110b
-10010100b ^ 11011011b = 01001111b
-10010100b ^ 11011100b = 01001000b
-10010100b ^ 11011101b = 01001001b
-10010100b ^ 11011110b = 01001010b
-10010100b ^ 11011111b = 01001011b
-10010100b ^ 11100000b = 01110100b
-10010100b ^ 11100001b = 01110101b
-10010100b ^ 11100010b = 01110110b
-10010100b ^ 11100011b = 01110111b
-10010100b ^ 11100100b = 01110000b
-10010100b ^ 11100101b = 01110001b
-10010100b ^ 11100110b = 01110010b
-10010100b ^ 11100111b = 01110011b
-10010100b ^ 11101000b = 01111100b
-10010100b ^ 11101001b = 01111101b
-10010100b ^ 11101010b = 01111110b
-10010100b ^ 11101011b = 01111111b
-10010100b ^ 11101100b = 01111000b
-10010100b ^ 11101101b = 01111001b
-10010100b ^ 11101110b = 01111010b
-10010100b ^ 11101111b = 01111011b
-10010100b ^ 11110000b = 01100100b
-10010100b ^ 11110001b = 01100101b
-10010100b ^ 11110010b = 01100110b
-10010100b ^ 11110011b = 01100111b
-10010100b ^ 11110100b = 01100000b
-10010100b ^ 11110101b = 01100001b
-10010100b ^ 11110110b = 01100010b
-10010100b ^ 11110111b = 01100011b
-10010100b ^ 11111000b = 01101100b
-10010100b ^ 11111001b = 01101101b
-10010100b ^ 11111010b = 01101110b
-10010100b ^ 11111011b = 01101111b
-10010100b ^ 11111100b = 01101000b
-10010100b ^ 11111101b = 01101001b
-10010100b ^ 11111110b = 01101010b
-10010100b ^ 11111111b = 01101011b
-10010100b ^ 00000000b = 10010100b
-10010100b ^ 00000001b = 10010101b
-10010100b ^ 00000010b = 10010110b
-10010100b ^ 00000011b = 10010111b
-10010100b ^ 00000100b = 10010000b
-10010100b ^ 00000101b = 10010001b
-10010100b ^ 00000110b = 10010010b
-10010100b ^ 00000111b = 10010011b
-10010100b ^ 00001000b = 10011100b
-10010100b ^ 00001001b = 10011101b
-10010100b ^ 00001010b = 10011110b
-10010100b ^ 00001011b = 10011111b
-10010100b ^ 00001100b = 10011000b
-10010100b ^ 00001101b = 10011001b
-10010100b ^ 00001110b = 10011010b
-10010100b ^ 00001111b = 10011011b
-10010100b ^ 00010000b = 10000100b
-10010100b ^ 00010001b = 10000101b
-10010100b ^ 00010010b = 10000110b
-10010100b ^ 00010011b = 10000111b
-10010100b ^ 00010100b = 10000000b
-10010100b ^ 00010101b = 10000001b
-10010100b ^ 00010110b = 10000010b
-10010100b ^ 00010111b = 10000011b
-10010100b ^ 00011000b = 10001100b
-10010100b ^ 00011001b = 10001101b
-10010100b ^ 00011010b = 10001110b
-10010100b ^ 00011011b = 10001111b
-10010100b ^ 00011100b = 10001000b
-10010100b ^ 00011101b = 10001001b
-10010100b ^ 00011110b = 10001010b
-10010100b ^ 00011111b = 10001011b
-10010100b ^ 00100000b = 10110100b
-10010100b ^ 00100001b = 10110101b
-10010100b ^ 00100010b = 10110110b
-10010100b ^ 00100011b = 10110111b
-10010100b ^ 00100100b = 10110000b
-10010100b ^ 00100101b = 10110001b
-10010100b ^ 00100110b = 10110010b
-10010100b ^ 00100111b = 10110011b
-10010100b ^ 00101000b = 10111100b
-10010100b ^ 00101001b = 10111101b
-10010100b ^ 00101010b = 10111110b
-10010100b ^ 00101011b = 10111111b
-10010100b ^ 00101100b = 10111000b
-10010100b ^ 00101101b = 10111001b
-10010100b ^ 00101110b = 10111010b
-10010100b ^ 00101111b = 10111011b
-10010100b ^ 00110000b = 10100100b
-10010100b ^ 00110001b = 10100101b
-10010100b ^ 00110010b = 10100110b
-10010100b ^ 00110011b = 10100111b
-10010100b ^ 00110100b = 10100000b
-10010100b ^ 00110101b = 10100001b
-10010100b ^ 00110110b = 10100010b
-10010100b ^ 00110111b = 10100011b
-10010100b ^ 00111000b = 10101100b
-10010100b ^ 00111001b = 10101101b
-10010100b ^ 00111010b = 10101110b
-10010100b ^ 00111011b = 10101111b
-10010100b ^ 00111100b = 10101000b
-10010100b ^ 00111101b = 10101001b
-10010100b ^ 00111110b = 10101010b
-10010100b ^ 00111111b = 10101011b
-10010100b ^ 01000000b = 11010100b
-10010100b ^ 01000001b = 11010101b
-10010100b ^ 01000010b = 11010110b
-10010100b ^ 01000011b = 11010111b
-10010100b ^ 01000100b = 11010000b
-10010100b ^ 01000101b = 11010001b
-10010100b ^ 01000110b = 11010010b
-10010100b ^ 01000111b = 11010011b
-10010100b ^ 01001000b = 11011100b
-10010100b ^ 01001001b = 11011101b
-10010100b ^ 01001010b = 11011110b
-10010100b ^ 01001011b = 11011111b
-10010100b ^ 01001100b = 11011000b
-10010100b ^ 01001101b = 11011001b
-10010100b ^ 01001110b = 11011010b
-10010100b ^ 01001111b = 11011011b
-10010100b ^ 01010000b = 11000100b
-10010100b ^ 01010001b = 11000101b
-10010100b ^ 01010010b = 11000110b
-10010100b ^ 01010011b = 11000111b
-10010100b ^ 01010100b = 11000000b
-10010100b ^ 01010101b = 11000001b
-10010100b ^ 01010110b = 11000010b
-10010100b ^ 01010111b = 11000011b
-10010100b ^ 01011000b = 11001100b
-10010100b ^ 01011001b = 11001101b
-10010100b ^ 01011010b = 11001110b
-10010100b ^ 01011011b = 11001111b
-10010100b ^ 01011100b = 11001000b
-10010100b ^ 01011101b = 11001001b
-10010100b ^ 01011110b = 11001010b
-10010100b ^ 01011111b = 11001011b
-10010100b ^ 01100000b = 11110100b
-10010100b ^ 01100001b = 11110101b
-10010100b ^ 01100010b = 11110110b
-10010100b ^ 01100011b = 11110111b
-10010100b ^ 01100100b = 11110000b
-10010100b ^ 01100101b = 11110001b
-10010100b ^ 01100110b = 11110010b
-10010100b ^ 01100111b = 11110011b
-10010100b ^ 01101000b = 11111100b
-10010100b ^ 01101001b = 11111101b
-10010100b ^ 01101010b = 11111110b
-10010100b ^ 01101011b = 11111111b
-10010100b ^ 01101100b = 11111000b
-10010100b ^ 01101101b = 11111001b
-10010100b ^ 01101110b = 11111010b
-10010100b ^ 01101111b = 11111011b
-10010100b ^ 01110000b = 11100100b
-10010100b ^ 01110001b = 11100101b
-10010100b ^ 01110010b = 11100110b
-10010100b ^ 01110011b = 11100111b
-10010100b ^ 01110100b = 11100000b
-10010100b ^ 01110101b = 11100001b
-10010100b ^ 01110110b = 11100010b
-10010100b ^ 01110111b = 11100011b
-10010100b ^ 01111000b = 11101100b
-10010100b ^ 01111001b = 11101101b
-10010100b ^ 01111010b = 11101110b
-10010100b ^ 01111011b = 11101111b
-10010100b ^ 01111100b = 11101000b
-10010100b ^ 01111101b = 11101001b
-10010100b ^ 01111110b = 11101010b
-10010101b ^ 10000000b = 00010101b
-10010101b ^ 10000001b = 00010100b
-10010101b ^ 10000010b = 00010111b
-10010101b ^ 10000011b = 00010110b
-10010101b ^ 10000100b = 00010001b
-10010101b ^ 10000101b = 00010000b
-10010101b ^ 10000110b = 00010011b
-10010101b ^ 10000111b = 00010010b
-10010101b ^ 10001000b = 00011101b
-10010101b ^ 10001001b = 00011100b
-10010101b ^ 10001010b = 00011111b
-10010101b ^ 10001011b = 00011110b
-10010101b ^ 10001100b = 00011001b
-10010101b ^ 10001101b = 00011000b
-10010101b ^ 10001110b = 00011011b
-10010101b ^ 10001111b = 00011010b
-10010101b ^ 10010000b = 00000101b
-10010101b ^ 10010001b = 00000100b
-10010101b ^ 10010010b = 00000111b
-10010101b ^ 10010011b = 00000110b
-10010101b ^ 10010100b = 00000001b
-10010101b ^ 10010101b = 00000000b
-10010101b ^ 10010110b = 00000011b
-10010101b ^ 10010111b = 00000010b
-10010101b ^ 10011000b = 00001101b
-10010101b ^ 10011001b = 00001100b
-10010101b ^ 10011010b = 00001111b
-10010101b ^ 10011011b = 00001110b
-10010101b ^ 10011100b = 00001001b
-10010101b ^ 10011101b = 00001000b
-10010101b ^ 10011110b = 00001011b
-10010101b ^ 10011111b = 00001010b
-10010101b ^ 10100000b = 00110101b
-10010101b ^ 10100001b = 00110100b
-10010101b ^ 10100010b = 00110111b
-10010101b ^ 10100011b = 00110110b
-10010101b ^ 10100100b = 00110001b
-10010101b ^ 10100101b = 00110000b
-10010101b ^ 10100110b = 00110011b
-10010101b ^ 10100111b = 00110010b
-10010101b ^ 10101000b = 00111101b
-10010101b ^ 10101001b = 00111100b
-10010101b ^ 10101010b = 00111111b
-10010101b ^ 10101011b = 00111110b
-10010101b ^ 10101100b = 00111001b
-10010101b ^ 10101101b = 00111000b
-10010101b ^ 10101110b = 00111011b
-10010101b ^ 10101111b = 00111010b
-10010101b ^ 10110000b = 00100101b
-10010101b ^ 10110001b = 00100100b
-10010101b ^ 10110010b = 00100111b
-10010101b ^ 10110011b = 00100110b
-10010101b ^ 10110100b = 00100001b
-10010101b ^ 10110101b = 00100000b
-10010101b ^ 10110110b = 00100011b
-10010101b ^ 10110111b = 00100010b
-10010101b ^ 10111000b = 00101101b
-10010101b ^ 10111001b = 00101100b
-10010101b ^ 10111010b = 00101111b
-10010101b ^ 10111011b = 00101110b
-10010101b ^ 10111100b = 00101001b
-10010101b ^ 10111101b = 00101000b
-10010101b ^ 10111110b = 00101011b
-10010101b ^ 10111111b = 00101010b
-10010101b ^ 11000000b = 01010101b
-10010101b ^ 11000001b = 01010100b
-10010101b ^ 11000010b = 01010111b
-10010101b ^ 11000011b = 01010110b
-10010101b ^ 11000100b = 01010001b
-10010101b ^ 11000101b = 01010000b
-10010101b ^ 11000110b = 01010011b
-10010101b ^ 11000111b = 01010010b
-10010101b ^ 11001000b = 01011101b
-10010101b ^ 11001001b = 01011100b
-10010101b ^ 11001010b = 01011111b
-10010101b ^ 11001011b = 01011110b
-10010101b ^ 11001100b = 01011001b
-10010101b ^ 11001101b = 01011000b
-10010101b ^ 11001110b = 01011011b
-10010101b ^ 11001111b = 01011010b
-10010101b ^ 11010000b = 01000101b
-10010101b ^ 11010001b = 01000100b
-10010101b ^ 11010010b = 01000111b
-10010101b ^ 11010011b = 01000110b
-10010101b ^ 11010100b = 01000001b
-10010101b ^ 11010101b = 01000000b
-10010101b ^ 11010110b = 01000011b
-10010101b ^ 11010111b = 01000010b
-10010101b ^ 11011000b = 01001101b
-10010101b ^ 11011001b = 01001100b
-10010101b ^ 11011010b = 01001111b
-10010101b ^ 11011011b = 01001110b
-10010101b ^ 11011100b = 01001001b
-10010101b ^ 11011101b = 01001000b
-10010101b ^ 11011110b = 01001011b
-10010101b ^ 11011111b = 01001010b
-10010101b ^ 11100000b = 01110101b
-10010101b ^ 11100001b = 01110100b
-10010101b ^ 11100010b = 01110111b
-10010101b ^ 11100011b = 01110110b
-10010101b ^ 11100100b = 01110001b
-10010101b ^ 11100101b = 01110000b
-10010101b ^ 11100110b = 01110011b
-10010101b ^ 11100111b = 01110010b
-10010101b ^ 11101000b = 01111101b
-10010101b ^ 11101001b = 01111100b
-10010101b ^ 11101010b = 01111111b
-10010101b ^ 11101011b = 01111110b
-10010101b ^ 11101100b = 01111001b
-10010101b ^ 11101101b = 01111000b
-10010101b ^ 11101110b = 01111011b
-10010101b ^ 11101111b = 01111010b
-10010101b ^ 11110000b = 01100101b
-10010101b ^ 11110001b = 01100100b
-10010101b ^ 11110010b = 01100111b
-10010101b ^ 11110011b = 01100110b
-10010101b ^ 11110100b = 01100001b
-10010101b ^ 11110101b = 01100000b
-10010101b ^ 11110110b = 01100011b
-10010101b ^ 11110111b = 01100010b
-10010101b ^ 11111000b = 01101101b
-10010101b ^ 11111001b = 01101100b
-10010101b ^ 11111010b = 01101111b
-10010101b ^ 11111011b = 01101110b
-10010101b ^ 11111100b = 01101001b
-10010101b ^ 11111101b = 01101000b
-10010101b ^ 11111110b = 01101011b
-10010101b ^ 11111111b = 01101010b
-10010101b ^ 00000000b = 10010101b
-10010101b ^ 00000001b = 10010100b
-10010101b ^ 00000010b = 10010111b
-10010101b ^ 00000011b = 10010110b
-10010101b ^ 00000100b = 10010001b
-10010101b ^ 00000101b = 10010000b
-10010101b ^ 00000110b = 10010011b
-10010101b ^ 00000111b = 10010010b
-10010101b ^ 00001000b = 10011101b
-10010101b ^ 00001001b = 10011100b
-10010101b ^ 00001010b = 10011111b
-10010101b ^ 00001011b = 10011110b
-10010101b ^ 00001100b = 10011001b
-10010101b ^ 00001101b = 10011000b
-10010101b ^ 00001110b = 10011011b
-10010101b ^ 00001111b = 10011010b
-10010101b ^ 00010000b = 10000101b
-10010101b ^ 00010001b = 10000100b
-10010101b ^ 00010010b = 10000111b
-10010101b ^ 00010011b = 10000110b
-10010101b ^ 00010100b = 10000001b
-10010101b ^ 00010101b = 10000000b
-10010101b ^ 00010110b = 10000011b
-10010101b ^ 00010111b = 10000010b
-10010101b ^ 00011000b = 10001101b
-10010101b ^ 00011001b = 10001100b
-10010101b ^ 00011010b = 10001111b
-10010101b ^ 00011011b = 10001110b
-10010101b ^ 00011100b = 10001001b
-10010101b ^ 00011101b = 10001000b
-10010101b ^ 00011110b = 10001011b
-10010101b ^ 00011111b = 10001010b
-10010101b ^ 00100000b = 10110101b
-10010101b ^ 00100001b = 10110100b
-10010101b ^ 00100010b = 10110111b
-10010101b ^ 00100011b = 10110110b
-10010101b ^ 00100100b = 10110001b
-10010101b ^ 00100101b = 10110000b
-10010101b ^ 00100110b = 10110011b
-10010101b ^ 00100111b = 10110010b
-10010101b ^ 00101000b = 10111101b
-10010101b ^ 00101001b = 10111100b
-10010101b ^ 00101010b = 10111111b
-10010101b ^ 00101011b = 10111110b
-10010101b ^ 00101100b = 10111001b
-10010101b ^ 00101101b = 10111000b
-10010101b ^ 00101110b = 10111011b
-10010101b ^ 00101111b = 10111010b
-10010101b ^ 00110000b = 10100101b
-10010101b ^ 00110001b = 10100100b
-10010101b ^ 00110010b = 10100111b
-10010101b ^ 00110011b = 10100110b
-10010101b ^ 00110100b = 10100001b
-10010101b ^ 00110101b = 10100000b
-10010101b ^ 00110110b = 10100011b
-10010101b ^ 00110111b = 10100010b
-10010101b ^ 00111000b = 10101101b
-10010101b ^ 00111001b = 10101100b
-10010101b ^ 00111010b = 10101111b
-10010101b ^ 00111011b = 10101110b
-10010101b ^ 00111100b = 10101001b
-10010101b ^ 00111101b = 10101000b
-10010101b ^ 00111110b = 10101011b
-10010101b ^ 00111111b = 10101010b
-10010101b ^ 01000000b = 11010101b
-10010101b ^ 01000001b = 11010100b
-10010101b ^ 01000010b = 11010111b
-10010101b ^ 01000011b = 11010110b
-10010101b ^ 01000100b = 11010001b
-10010101b ^ 01000101b = 11010000b
-10010101b ^ 01000110b = 11010011b
-10010101b ^ 01000111b = 11010010b
-10010101b ^ 01001000b = 11011101b
-10010101b ^ 01001001b = 11011100b
-10010101b ^ 01001010b = 11011111b
-10010101b ^ 01001011b = 11011110b
-10010101b ^ 01001100b = 11011001b
-10010101b ^ 01001101b = 11011000b
-10010101b ^ 01001110b = 11011011b
-10010101b ^ 01001111b = 11011010b
-10010101b ^ 01010000b = 11000101b
-10010101b ^ 01010001b = 11000100b
-10010101b ^ 01010010b = 11000111b
-10010101b ^ 01010011b = 11000110b
-10010101b ^ 01010100b = 11000001b
-10010101b ^ 01010101b = 11000000b
-10010101b ^ 01010110b = 11000011b
-10010101b ^ 01010111b = 11000010b
-10010101b ^ 01011000b = 11001101b
-10010101b ^ 01011001b = 11001100b
-10010101b ^ 01011010b = 11001111b
-10010101b ^ 01011011b = 11001110b
-10010101b ^ 01011100b = 11001001b
-10010101b ^ 01011101b = 11001000b
-10010101b ^ 01011110b = 11001011b
-10010101b ^ 01011111b = 11001010b
-10010101b ^ 01100000b = 11110101b
-10010101b ^ 01100001b = 11110100b
-10010101b ^ 01100010b = 11110111b
-10010101b ^ 01100011b = 11110110b
-10010101b ^ 01100100b = 11110001b
-10010101b ^ 01100101b = 11110000b
-10010101b ^ 01100110b = 11110011b
-10010101b ^ 01100111b = 11110010b
-10010101b ^ 01101000b = 11111101b
-10010101b ^ 01101001b = 11111100b
-10010101b ^ 01101010b = 11111111b
-10010101b ^ 01101011b = 11111110b
-10010101b ^ 01101100b = 11111001b
-10010101b ^ 01101101b = 11111000b
-10010101b ^ 01101110b = 11111011b
-10010101b ^ 01101111b = 11111010b
-10010101b ^ 01110000b = 11100101b
-10010101b ^ 01110001b = 11100100b
-10010101b ^ 01110010b = 11100111b
-10010101b ^ 01110011b = 11100110b
-10010101b ^ 01110100b = 11100001b
-10010101b ^ 01110101b = 11100000b
-10010101b ^ 01110110b = 11100011b
-10010101b ^ 01110111b = 11100010b
-10010101b ^ 01111000b = 11101101b
-10010101b ^ 01111001b = 11101100b
-10010101b ^ 01111010b = 11101111b
-10010101b ^ 01111011b = 11101110b
-10010101b ^ 01111100b = 11101001b
-10010101b ^ 01111101b = 11101000b
-10010101b ^ 01111110b = 11101011b
-10010110b ^ 10000000b = 00010110b
-10010110b ^ 10000001b = 00010111b
-10010110b ^ 10000010b = 00010100b
-10010110b ^ 10000011b = 00010101b
-10010110b ^ 10000100b = 00010010b
-10010110b ^ 10000101b = 00010011b
-10010110b ^ 10000110b = 00010000b
-10010110b ^ 10000111b = 00010001b
-10010110b ^ 10001000b = 00011110b
-10010110b ^ 10001001b = 00011111b
-10010110b ^ 10001010b = 00011100b
-10010110b ^ 10001011b = 00011101b
-10010110b ^ 10001100b = 00011010b
-10010110b ^ 10001101b = 00011011b
-10010110b ^ 10001110b = 00011000b
-10010110b ^ 10001111b = 00011001b
-10010110b ^ 10010000b = 00000110b
-10010110b ^ 10010001b = 00000111b
-10010110b ^ 10010010b = 00000100b
-10010110b ^ 10010011b = 00000101b
-10010110b ^ 10010100b = 00000010b
-10010110b ^ 10010101b = 00000011b
-10010110b ^ 10010110b = 00000000b
-10010110b ^ 10010111b = 00000001b
-10010110b ^ 10011000b = 00001110b
-10010110b ^ 10011001b = 00001111b
-10010110b ^ 10011010b = 00001100b
-10010110b ^ 10011011b = 00001101b
-10010110b ^ 10011100b = 00001010b
-10010110b ^ 10011101b = 00001011b
-10010110b ^ 10011110b = 00001000b
-10010110b ^ 10011111b = 00001001b
-10010110b ^ 10100000b = 00110110b
-10010110b ^ 10100001b = 00110111b
-10010110b ^ 10100010b = 00110100b
-10010110b ^ 10100011b = 00110101b
-10010110b ^ 10100100b = 00110010b
-10010110b ^ 10100101b = 00110011b
-10010110b ^ 10100110b = 00110000b
-10010110b ^ 10100111b = 00110001b
-10010110b ^ 10101000b = 00111110b
-10010110b ^ 10101001b = 00111111b
-10010110b ^ 10101010b = 00111100b
-10010110b ^ 10101011b = 00111101b
-10010110b ^ 10101100b = 00111010b
-10010110b ^ 10101101b = 00111011b
-10010110b ^ 10101110b = 00111000b
-10010110b ^ 10101111b = 00111001b
-10010110b ^ 10110000b = 00100110b
-10010110b ^ 10110001b = 00100111b
-10010110b ^ 10110010b = 00100100b
-10010110b ^ 10110011b = 00100101b
-10010110b ^ 10110100b = 00100010b
-10010110b ^ 10110101b = 00100011b
-10010110b ^ 10110110b = 00100000b
-10010110b ^ 10110111b = 00100001b
-10010110b ^ 10111000b = 00101110b
-10010110b ^ 10111001b = 00101111b
-10010110b ^ 10111010b = 00101100b
-10010110b ^ 10111011b = 00101101b
-10010110b ^ 10111100b = 00101010b
-10010110b ^ 10111101b = 00101011b
-10010110b ^ 10111110b = 00101000b
-10010110b ^ 10111111b = 00101001b
-10010110b ^ 11000000b = 01010110b
-10010110b ^ 11000001b = 01010111b
-10010110b ^ 11000010b = 01010100b
-10010110b ^ 11000011b = 01010101b
-10010110b ^ 11000100b = 01010010b
-10010110b ^ 11000101b = 01010011b
-10010110b ^ 11000110b = 01010000b
-10010110b ^ 11000111b = 01010001b
-10010110b ^ 11001000b = 01011110b
-10010110b ^ 11001001b = 01011111b
-10010110b ^ 11001010b = 01011100b
-10010110b ^ 11001011b = 01011101b
-10010110b ^ 11001100b = 01011010b
-10010110b ^ 11001101b = 01011011b
-10010110b ^ 11001110b = 01011000b
-10010110b ^ 11001111b = 01011001b
-10010110b ^ 11010000b = 01000110b
-10010110b ^ 11010001b = 01000111b
-10010110b ^ 11010010b = 01000100b
-10010110b ^ 11010011b = 01000101b
-10010110b ^ 11010100b = 01000010b
-10010110b ^ 11010101b = 01000011b
-10010110b ^ 11010110b = 01000000b
-10010110b ^ 11010111b = 01000001b
-10010110b ^ 11011000b = 01001110b
-10010110b ^ 11011001b = 01001111b
-10010110b ^ 11011010b = 01001100b
-10010110b ^ 11011011b = 01001101b
-10010110b ^ 11011100b = 01001010b
-10010110b ^ 11011101b = 01001011b
-10010110b ^ 11011110b = 01001000b
-10010110b ^ 11011111b = 01001001b
-10010110b ^ 11100000b = 01110110b
-10010110b ^ 11100001b = 01110111b
-10010110b ^ 11100010b = 01110100b
-10010110b ^ 11100011b = 01110101b
-10010110b ^ 11100100b = 01110010b
-10010110b ^ 11100101b = 01110011b
-10010110b ^ 11100110b = 01110000b
-10010110b ^ 11100111b = 01110001b
-10010110b ^ 11101000b = 01111110b
-10010110b ^ 11101001b = 01111111b
-10010110b ^ 11101010b = 01111100b
-10010110b ^ 11101011b = 01111101b
-10010110b ^ 11101100b = 01111010b
-10010110b ^ 11101101b = 01111011b
-10010110b ^ 11101110b = 01111000b
-10010110b ^ 11101111b = 01111001b
-10010110b ^ 11110000b = 01100110b
-10010110b ^ 11110001b = 01100111b
-10010110b ^ 11110010b = 01100100b
-10010110b ^ 11110011b = 01100101b
-10010110b ^ 11110100b = 01100010b
-10010110b ^ 11110101b = 01100011b
-10010110b ^ 11110110b = 01100000b
-10010110b ^ 11110111b = 01100001b
-10010110b ^ 11111000b = 01101110b
-10010110b ^ 11111001b = 01101111b
-10010110b ^ 11111010b = 01101100b
-10010110b ^ 11111011b = 01101101b
-10010110b ^ 11111100b = 01101010b
-10010110b ^ 11111101b = 01101011b
-10010110b ^ 11111110b = 01101000b
-10010110b ^ 11111111b = 01101001b
-10010110b ^ 00000000b = 10010110b
-10010110b ^ 00000001b = 10010111b
-10010110b ^ 00000010b = 10010100b
-10010110b ^ 00000011b = 10010101b
-10010110b ^ 00000100b = 10010010b
-10010110b ^ 00000101b = 10010011b
-10010110b ^ 00000110b = 10010000b
-10010110b ^ 00000111b = 10010001b
-10010110b ^ 00001000b = 10011110b
-10010110b ^ 00001001b = 10011111b
-10010110b ^ 00001010b = 10011100b
-10010110b ^ 00001011b = 10011101b
-10010110b ^ 00001100b = 10011010b
-10010110b ^ 00001101b = 10011011b
-10010110b ^ 00001110b = 10011000b
-10010110b ^ 00001111b = 10011001b
-10010110b ^ 00010000b = 10000110b
-10010110b ^ 00010001b = 10000111b
-10010110b ^ 00010010b = 10000100b
-10010110b ^ 00010011b = 10000101b
-10010110b ^ 00010100b = 10000010b
-10010110b ^ 00010101b = 10000011b
-10010110b ^ 00010110b = 10000000b
-10010110b ^ 00010111b = 10000001b
-10010110b ^ 00011000b = 10001110b
-10010110b ^ 00011001b = 10001111b
-10010110b ^ 00011010b = 10001100b
-10010110b ^ 00011011b = 10001101b
-10010110b ^ 00011100b = 10001010b
-10010110b ^ 00011101b = 10001011b
-10010110b ^ 00011110b = 10001000b
-10010110b ^ 00011111b = 10001001b
-10010110b ^ 00100000b = 10110110b
-10010110b ^ 00100001b = 10110111b
-10010110b ^ 00100010b = 10110100b
-10010110b ^ 00100011b = 10110101b
-10010110b ^ 00100100b = 10110010b
-10010110b ^ 00100101b = 10110011b
-10010110b ^ 00100110b = 10110000b
-10010110b ^ 00100111b = 10110001b
-10010110b ^ 00101000b = 10111110b
-10010110b ^ 00101001b = 10111111b
-10010110b ^ 00101010b = 10111100b
-10010110b ^ 00101011b = 10111101b
-10010110b ^ 00101100b = 10111010b
-10010110b ^ 00101101b = 10111011b
-10010110b ^ 00101110b = 10111000b
-10010110b ^ 00101111b = 10111001b
-10010110b ^ 00110000b = 10100110b
-10010110b ^ 00110001b = 10100111b
-10010110b ^ 00110010b = 10100100b
-10010110b ^ 00110011b = 10100101b
-10010110b ^ 00110100b = 10100010b
-10010110b ^ 00110101b = 10100011b
-10010110b ^ 00110110b = 10100000b
-10010110b ^ 00110111b = 10100001b
-10010110b ^ 00111000b = 10101110b
-10010110b ^ 00111001b = 10101111b
-10010110b ^ 00111010b = 10101100b
-10010110b ^ 00111011b = 10101101b
-10010110b ^ 00111100b = 10101010b
-10010110b ^ 00111101b = 10101011b
-10010110b ^ 00111110b = 10101000b
-10010110b ^ 00111111b = 10101001b
-10010110b ^ 01000000b = 11010110b
-10010110b ^ 01000001b = 11010111b
-10010110b ^ 01000010b = 11010100b
-10010110b ^ 01000011b = 11010101b
-10010110b ^ 01000100b = 11010010b
-10010110b ^ 01000101b = 11010011b
-10010110b ^ 01000110b = 11010000b
-10010110b ^ 01000111b = 11010001b
-10010110b ^ 01001000b = 11011110b
-10010110b ^ 01001001b = 11011111b
-10010110b ^ 01001010b = 11011100b
-10010110b ^ 01001011b = 11011101b
-10010110b ^ 01001100b = 11011010b
-10010110b ^ 01001101b = 11011011b
-10010110b ^ 01001110b = 11011000b
-10010110b ^ 01001111b = 11011001b
-10010110b ^ 01010000b = 11000110b
-10010110b ^ 01010001b = 11000111b
-10010110b ^ 01010010b = 11000100b
-10010110b ^ 01010011b = 11000101b
-10010110b ^ 01010100b = 11000010b
-10010110b ^ 01010101b = 11000011b
-10010110b ^ 01010110b = 11000000b
-10010110b ^ 01010111b = 11000001b
-10010110b ^ 01011000b = 11001110b
-10010110b ^ 01011001b = 11001111b
-10010110b ^ 01011010b = 11001100b
-10010110b ^ 01011011b = 11001101b
-10010110b ^ 01011100b = 11001010b
-10010110b ^ 01011101b = 11001011b
-10010110b ^ 01011110b = 11001000b
-10010110b ^ 01011111b = 11001001b
-10010110b ^ 01100000b = 11110110b
-10010110b ^ 01100001b = 11110111b
-10010110b ^ 01100010b = 11110100b
-10010110b ^ 01100011b = 11110101b
-10010110b ^ 01100100b = 11110010b
-10010110b ^ 01100101b = 11110011b
-10010110b ^ 01100110b = 11110000b
-10010110b ^ 01100111b = 11110001b
-10010110b ^ 01101000b = 11111110b
-10010110b ^ 01101001b = 11111111b
-10010110b ^ 01101010b = 11111100b
-10010110b ^ 01101011b = 11111101b
-10010110b ^ 01101100b = 11111010b
-10010110b ^ 01101101b = 11111011b
-10010110b ^ 01101110b = 11111000b
-10010110b ^ 01101111b = 11111001b
-10010110b ^ 01110000b = 11100110b
-10010110b ^ 01110001b = 11100111b
-10010110b ^ 01110010b = 11100100b
-10010110b ^ 01110011b = 11100101b
-10010110b ^ 01110100b = 11100010b
-10010110b ^ 01110101b = 11100011b
-10010110b ^ 01110110b = 11100000b
-10010110b ^ 01110111b = 11100001b
-10010110b ^ 01111000b = 11101110b
-10010110b ^ 01111001b = 11101111b
-10010110b ^ 01111010b = 11101100b
-10010110b ^ 01111011b = 11101101b
-10010110b ^ 01111100b = 11101010b
-10010110b ^ 01111101b = 11101011b
-10010110b ^ 01111110b = 11101000b
-10010111b ^ 10000000b = 00010111b
-10010111b ^ 10000001b = 00010110b
-10010111b ^ 10000010b = 00010101b
-10010111b ^ 10000011b = 00010100b
-10010111b ^ 10000100b = 00010011b
-10010111b ^ 10000101b = 00010010b
-10010111b ^ 10000110b = 00010001b
-10010111b ^ 10000111b = 00010000b
-10010111b ^ 10001000b = 00011111b
-10010111b ^ 10001001b = 00011110b
-10010111b ^ 10001010b = 00011101b
-10010111b ^ 10001011b = 00011100b
-10010111b ^ 10001100b = 00011011b
-10010111b ^ 10001101b = 00011010b
-10010111b ^ 10001110b = 00011001b
-10010111b ^ 10001111b = 00011000b
-10010111b ^ 10010000b = 00000111b
-10010111b ^ 10010001b = 00000110b
-10010111b ^ 10010010b = 00000101b
-10010111b ^ 10010011b = 00000100b
-10010111b ^ 10010100b = 00000011b
-10010111b ^ 10010101b = 00000010b
-10010111b ^ 10010110b = 00000001b
-10010111b ^ 10010111b = 00000000b
-10010111b ^ 10011000b = 00001111b
-10010111b ^ 10011001b = 00001110b
-10010111b ^ 10011010b = 00001101b
-10010111b ^ 10011011b = 00001100b
-10010111b ^ 10011100b = 00001011b
-10010111b ^ 10011101b = 00001010b
-10010111b ^ 10011110b = 00001001b
-10010111b ^ 10011111b = 00001000b
-10010111b ^ 10100000b = 00110111b
-10010111b ^ 10100001b = 00110110b
-10010111b ^ 10100010b = 00110101b
-10010111b ^ 10100011b = 00110100b
-10010111b ^ 10100100b = 00110011b
-10010111b ^ 10100101b = 00110010b
-10010111b ^ 10100110b = 00110001b
-10010111b ^ 10100111b = 00110000b
-10010111b ^ 10101000b = 00111111b
-10010111b ^ 10101001b = 00111110b
-10010111b ^ 10101010b = 00111101b
-10010111b ^ 10101011b = 00111100b
-10010111b ^ 10101100b = 00111011b
-10010111b ^ 10101101b = 00111010b
-10010111b ^ 10101110b = 00111001b
-10010111b ^ 10101111b = 00111000b
-10010111b ^ 10110000b = 00100111b
-10010111b ^ 10110001b = 00100110b
-10010111b ^ 10110010b = 00100101b
-10010111b ^ 10110011b = 00100100b
-10010111b ^ 10110100b = 00100011b
-10010111b ^ 10110101b = 00100010b
-10010111b ^ 10110110b = 00100001b
-10010111b ^ 10110111b = 00100000b
-10010111b ^ 10111000b = 00101111b
-10010111b ^ 10111001b = 00101110b
-10010111b ^ 10111010b = 00101101b
-10010111b ^ 10111011b = 00101100b
-10010111b ^ 10111100b = 00101011b
-10010111b ^ 10111101b = 00101010b
-10010111b ^ 10111110b = 00101001b
-10010111b ^ 10111111b = 00101000b
-10010111b ^ 11000000b = 01010111b
-10010111b ^ 11000001b = 01010110b
-10010111b ^ 11000010b = 01010101b
-10010111b ^ 11000011b = 01010100b
-10010111b ^ 11000100b = 01010011b
-10010111b ^ 11000101b = 01010010b
-10010111b ^ 11000110b = 01010001b
-10010111b ^ 11000111b = 01010000b
-10010111b ^ 11001000b = 01011111b
-10010111b ^ 11001001b = 01011110b
-10010111b ^ 11001010b = 01011101b
-10010111b ^ 11001011b = 01011100b
-10010111b ^ 11001100b = 01011011b
-10010111b ^ 11001101b = 01011010b
-10010111b ^ 11001110b = 01011001b
-10010111b ^ 11001111b = 01011000b
-10010111b ^ 11010000b = 01000111b
-10010111b ^ 11010001b = 01000110b
-10010111b ^ 11010010b = 01000101b
-10010111b ^ 11010011b = 01000100b
-10010111b ^ 11010100b = 01000011b
-10010111b ^ 11010101b = 01000010b
-10010111b ^ 11010110b = 01000001b
-10010111b ^ 11010111b = 01000000b
-10010111b ^ 11011000b = 01001111b
-10010111b ^ 11011001b = 01001110b
-10010111b ^ 11011010b = 01001101b
-10010111b ^ 11011011b = 01001100b
-10010111b ^ 11011100b = 01001011b
-10010111b ^ 11011101b = 01001010b
-10010111b ^ 11011110b = 01001001b
-10010111b ^ 11011111b = 01001000b
-10010111b ^ 11100000b = 01110111b
-10010111b ^ 11100001b = 01110110b
-10010111b ^ 11100010b = 01110101b
-10010111b ^ 11100011b = 01110100b
-10010111b ^ 11100100b = 01110011b
-10010111b ^ 11100101b = 01110010b
-10010111b ^ 11100110b = 01110001b
-10010111b ^ 11100111b = 01110000b
-10010111b ^ 11101000b = 01111111b
-10010111b ^ 11101001b = 01111110b
-10010111b ^ 11101010b = 01111101b
-10010111b ^ 11101011b = 01111100b
-10010111b ^ 11101100b = 01111011b
-10010111b ^ 11101101b = 01111010b
-10010111b ^ 11101110b = 01111001b
-10010111b ^ 11101111b = 01111000b
-10010111b ^ 11110000b = 01100111b
-10010111b ^ 11110001b = 01100110b
-10010111b ^ 11110010b = 01100101b
-10010111b ^ 11110011b = 01100100b
-10010111b ^ 11110100b = 01100011b
-10010111b ^ 11110101b = 01100010b
-10010111b ^ 11110110b = 01100001b
-10010111b ^ 11110111b = 01100000b
-10010111b ^ 11111000b = 01101111b
-10010111b ^ 11111001b = 01101110b
-10010111b ^ 11111010b = 01101101b
-10010111b ^ 11111011b = 01101100b
-10010111b ^ 11111100b = 01101011b
-10010111b ^ 11111101b = 01101010b
-10010111b ^ 11111110b = 01101001b
-10010111b ^ 11111111b = 01101000b
-10010111b ^ 00000000b = 10010111b
-10010111b ^ 00000001b = 10010110b
-10010111b ^ 00000010b = 10010101b
-10010111b ^ 00000011b = 10010100b
-10010111b ^ 00000100b = 10010011b
-10010111b ^ 00000101b = 10010010b
-10010111b ^ 00000110b = 10010001b
-10010111b ^ 00000111b = 10010000b
-10010111b ^ 00001000b = 10011111b
-10010111b ^ 00001001b = 10011110b
-10010111b ^ 00001010b = 10011101b
-10010111b ^ 00001011b = 10011100b
-10010111b ^ 00001100b = 10011011b
-10010111b ^ 00001101b = 10011010b
-10010111b ^ 00001110b = 10011001b
-10010111b ^ 00001111b = 10011000b
-10010111b ^ 00010000b = 10000111b
-10010111b ^ 00010001b = 10000110b
-10010111b ^ 00010010b = 10000101b
-10010111b ^ 00010011b = 10000100b
-10010111b ^ 00010100b = 10000011b
-10010111b ^ 00010101b = 10000010b
-10010111b ^ 00010110b = 10000001b
-10010111b ^ 00010111b = 10000000b
-10010111b ^ 00011000b = 10001111b
-10010111b ^ 00011001b = 10001110b
-10010111b ^ 00011010b = 10001101b
-10010111b ^ 00011011b = 10001100b
-10010111b ^ 00011100b = 10001011b
-10010111b ^ 00011101b = 10001010b
-10010111b ^ 00011110b = 10001001b
-10010111b ^ 00011111b = 10001000b
-10010111b ^ 00100000b = 10110111b
-10010111b ^ 00100001b = 10110110b
-10010111b ^ 00100010b = 10110101b
-10010111b ^ 00100011b = 10110100b
-10010111b ^ 00100100b = 10110011b
-10010111b ^ 00100101b = 10110010b
-10010111b ^ 00100110b = 10110001b
-10010111b ^ 00100111b = 10110000b
-10010111b ^ 00101000b = 10111111b
-10010111b ^ 00101001b = 10111110b
-10010111b ^ 00101010b = 10111101b
-10010111b ^ 00101011b = 10111100b
-10010111b ^ 00101100b = 10111011b
-10010111b ^ 00101101b = 10111010b
-10010111b ^ 00101110b = 10111001b
-10010111b ^ 00101111b = 10111000b
-10010111b ^ 00110000b = 10100111b
-10010111b ^ 00110001b = 10100110b
-10010111b ^ 00110010b = 10100101b
-10010111b ^ 00110011b = 10100100b
-10010111b ^ 00110100b = 10100011b
-10010111b ^ 00110101b = 10100010b
-10010111b ^ 00110110b = 10100001b
-10010111b ^ 00110111b = 10100000b
-10010111b ^ 00111000b = 10101111b
-10010111b ^ 00111001b = 10101110b
-10010111b ^ 00111010b = 10101101b
-10010111b ^ 00111011b = 10101100b
-10010111b ^ 00111100b = 10101011b
-10010111b ^ 00111101b = 10101010b
-10010111b ^ 00111110b = 10101001b
-10010111b ^ 00111111b = 10101000b
-10010111b ^ 01000000b = 11010111b
-10010111b ^ 01000001b = 11010110b
-10010111b ^ 01000010b = 11010101b
-10010111b ^ 01000011b = 11010100b
-10010111b ^ 01000100b = 11010011b
-10010111b ^ 01000101b = 11010010b
-10010111b ^ 01000110b = 11010001b
-10010111b ^ 01000111b = 11010000b
-10010111b ^ 01001000b = 11011111b
-10010111b ^ 01001001b = 11011110b
-10010111b ^ 01001010b = 11011101b
-10010111b ^ 01001011b = 11011100b
-10010111b ^ 01001100b = 11011011b
-10010111b ^ 01001101b = 11011010b
-10010111b ^ 01001110b = 11011001b
-10010111b ^ 01001111b = 11011000b
-10010111b ^ 01010000b = 11000111b
-10010111b ^ 01010001b = 11000110b
-10010111b ^ 01010010b = 11000101b
-10010111b ^ 01010011b = 11000100b
-10010111b ^ 01010100b = 11000011b
-10010111b ^ 01010101b = 11000010b
-10010111b ^ 01010110b = 11000001b
-10010111b ^ 01010111b = 11000000b
-10010111b ^ 01011000b = 11001111b
-10010111b ^ 01011001b = 11001110b
-10010111b ^ 01011010b = 11001101b
-10010111b ^ 01011011b = 11001100b
-10010111b ^ 01011100b = 11001011b
-10010111b ^ 01011101b = 11001010b
-10010111b ^ 01011110b = 11001001b
-10010111b ^ 01011111b = 11001000b
-10010111b ^ 01100000b = 11110111b
-10010111b ^ 01100001b = 11110110b
-10010111b ^ 01100010b = 11110101b
-10010111b ^ 01100011b = 11110100b
-10010111b ^ 01100100b = 11110011b
-10010111b ^ 01100101b = 11110010b
-10010111b ^ 01100110b = 11110001b
-10010111b ^ 01100111b = 11110000b
-10010111b ^ 01101000b = 11111111b
-10010111b ^ 01101001b = 11111110b
-10010111b ^ 01101010b = 11111101b
-10010111b ^ 01101011b = 11111100b
-10010111b ^ 01101100b = 11111011b
-10010111b ^ 01101101b = 11111010b
-10010111b ^ 01101110b = 11111001b
-10010111b ^ 01101111b = 11111000b
-10010111b ^ 01110000b = 11100111b
-10010111b ^ 01110001b = 11100110b
-10010111b ^ 01110010b = 11100101b
-10010111b ^ 01110011b = 11100100b
-10010111b ^ 01110100b = 11100011b
-10010111b ^ 01110101b = 11100010b
-10010111b ^ 01110110b = 11100001b
-10010111b ^ 01110111b = 11100000b
-10010111b ^ 01111000b = 11101111b
-10010111b ^ 01111001b = 11101110b
-10010111b ^ 01111010b = 11101101b
-10010111b ^ 01111011b = 11101100b
-10010111b ^ 01111100b = 11101011b
-10010111b ^ 01111101b = 11101010b
-10010111b ^ 01111110b = 11101001b
-10011000b ^ 10000000b = 00011000b
-10011000b ^ 10000001b = 00011001b
-10011000b ^ 10000010b = 00011010b
-10011000b ^ 10000011b = 00011011b
-10011000b ^ 10000100b = 00011100b
-10011000b ^ 10000101b = 00011101b
-10011000b ^ 10000110b = 00011110b
-10011000b ^ 10000111b = 00011111b
-10011000b ^ 10001000b = 00010000b
-10011000b ^ 10001001b = 00010001b
-10011000b ^ 10001010b = 00010010b
-10011000b ^ 10001011b = 00010011b
-10011000b ^ 10001100b = 00010100b
-10011000b ^ 10001101b = 00010101b
-10011000b ^ 10001110b = 00010110b
-10011000b ^ 10001111b = 00010111b
-10011000b ^ 10010000b = 00001000b
-10011000b ^ 10010001b = 00001001b
-10011000b ^ 10010010b = 00001010b
-10011000b ^ 10010011b = 00001011b
-10011000b ^ 10010100b = 00001100b
-10011000b ^ 10010101b = 00001101b
-10011000b ^ 10010110b = 00001110b
-10011000b ^ 10010111b = 00001111b
-10011000b ^ 10011000b = 00000000b
-10011000b ^ 10011001b = 00000001b
-10011000b ^ 10011010b = 00000010b
-10011000b ^ 10011011b = 00000011b
-10011000b ^ 10011100b = 00000100b
-10011000b ^ 10011101b = 00000101b
-10011000b ^ 10011110b = 00000110b
-10011000b ^ 10011111b = 00000111b
-10011000b ^ 10100000b = 00111000b
-10011000b ^ 10100001b = 00111001b
-10011000b ^ 10100010b = 00111010b
-10011000b ^ 10100011b = 00111011b
-10011000b ^ 10100100b = 00111100b
-10011000b ^ 10100101b = 00111101b
-10011000b ^ 10100110b = 00111110b
-10011000b ^ 10100111b = 00111111b
-10011000b ^ 10101000b = 00110000b
-10011000b ^ 10101001b = 00110001b
-10011000b ^ 10101010b = 00110010b
-10011000b ^ 10101011b = 00110011b
-10011000b ^ 10101100b = 00110100b
-10011000b ^ 10101101b = 00110101b
-10011000b ^ 10101110b = 00110110b
-10011000b ^ 10101111b = 00110111b
-10011000b ^ 10110000b = 00101000b
-10011000b ^ 10110001b = 00101001b
-10011000b ^ 10110010b = 00101010b
-10011000b ^ 10110011b = 00101011b
-10011000b ^ 10110100b = 00101100b
-10011000b ^ 10110101b = 00101101b
-10011000b ^ 10110110b = 00101110b
-10011000b ^ 10110111b = 00101111b
-10011000b ^ 10111000b = 00100000b
-10011000b ^ 10111001b = 00100001b
-10011000b ^ 10111010b = 00100010b
-10011000b ^ 10111011b = 00100011b
-10011000b ^ 10111100b = 00100100b
-10011000b ^ 10111101b = 00100101b
-10011000b ^ 10111110b = 00100110b
-10011000b ^ 10111111b = 00100111b
-10011000b ^ 11000000b = 01011000b
-10011000b ^ 11000001b = 01011001b
-10011000b ^ 11000010b = 01011010b
-10011000b ^ 11000011b = 01011011b
-10011000b ^ 11000100b = 01011100b
-10011000b ^ 11000101b = 01011101b
-10011000b ^ 11000110b = 01011110b
-10011000b ^ 11000111b = 01011111b
-10011000b ^ 11001000b = 01010000b
-10011000b ^ 11001001b = 01010001b
-10011000b ^ 11001010b = 01010010b
-10011000b ^ 11001011b = 01010011b
-10011000b ^ 11001100b = 01010100b
-10011000b ^ 11001101b = 01010101b
-10011000b ^ 11001110b = 01010110b
-10011000b ^ 11001111b = 01010111b
-10011000b ^ 11010000b = 01001000b
-10011000b ^ 11010001b = 01001001b
-10011000b ^ 11010010b = 01001010b
-10011000b ^ 11010011b = 01001011b
-10011000b ^ 11010100b = 01001100b
-10011000b ^ 11010101b = 01001101b
-10011000b ^ 11010110b = 01001110b
-10011000b ^ 11010111b = 01001111b
-10011000b ^ 11011000b = 01000000b
-10011000b ^ 11011001b = 01000001b
-10011000b ^ 11011010b = 01000010b
-10011000b ^ 11011011b = 01000011b
-10011000b ^ 11011100b = 01000100b
-10011000b ^ 11011101b = 01000101b
-10011000b ^ 11011110b = 01000110b
-10011000b ^ 11011111b = 01000111b
-10011000b ^ 11100000b = 01111000b
-10011000b ^ 11100001b = 01111001b
-10011000b ^ 11100010b = 01111010b
-10011000b ^ 11100011b = 01111011b
-10011000b ^ 11100100b = 01111100b
-10011000b ^ 11100101b = 01111101b
-10011000b ^ 11100110b = 01111110b
-10011000b ^ 11100111b = 01111111b
-10011000b ^ 11101000b = 01110000b
-10011000b ^ 11101001b = 01110001b
-10011000b ^ 11101010b = 01110010b
-10011000b ^ 11101011b = 01110011b
-10011000b ^ 11101100b = 01110100b
-10011000b ^ 11101101b = 01110101b
-10011000b ^ 11101110b = 01110110b
-10011000b ^ 11101111b = 01110111b
-10011000b ^ 11110000b = 01101000b
-10011000b ^ 11110001b = 01101001b
-10011000b ^ 11110010b = 01101010b
-10011000b ^ 11110011b = 01101011b
-10011000b ^ 11110100b = 01101100b
-10011000b ^ 11110101b = 01101101b
-10011000b ^ 11110110b = 01101110b
-10011000b ^ 11110111b = 01101111b
-10011000b ^ 11111000b = 01100000b
-10011000b ^ 11111001b = 01100001b
-10011000b ^ 11111010b = 01100010b
-10011000b ^ 11111011b = 01100011b
-10011000b ^ 11111100b = 01100100b
-10011000b ^ 11111101b = 01100101b
-10011000b ^ 11111110b = 01100110b
-10011000b ^ 11111111b = 01100111b
-10011000b ^ 00000000b = 10011000b
-10011000b ^ 00000001b = 10011001b
-10011000b ^ 00000010b = 10011010b
-10011000b ^ 00000011b = 10011011b
-10011000b ^ 00000100b = 10011100b
-10011000b ^ 00000101b = 10011101b
-10011000b ^ 00000110b = 10011110b
-10011000b ^ 00000111b = 10011111b
-10011000b ^ 00001000b = 10010000b
-10011000b ^ 00001001b = 10010001b
-10011000b ^ 00001010b = 10010010b
-10011000b ^ 00001011b = 10010011b
-10011000b ^ 00001100b = 10010100b
-10011000b ^ 00001101b = 10010101b
-10011000b ^ 00001110b = 10010110b
-10011000b ^ 00001111b = 10010111b
-10011000b ^ 00010000b = 10001000b
-10011000b ^ 00010001b = 10001001b
-10011000b ^ 00010010b = 10001010b
-10011000b ^ 00010011b = 10001011b
-10011000b ^ 00010100b = 10001100b
-10011000b ^ 00010101b = 10001101b
-10011000b ^ 00010110b = 10001110b
-10011000b ^ 00010111b = 10001111b
-10011000b ^ 00011000b = 10000000b
-10011000b ^ 00011001b = 10000001b
-10011000b ^ 00011010b = 10000010b
-10011000b ^ 00011011b = 10000011b
-10011000b ^ 00011100b = 10000100b
-10011000b ^ 00011101b = 10000101b
-10011000b ^ 00011110b = 10000110b
-10011000b ^ 00011111b = 10000111b
-10011000b ^ 00100000b = 10111000b
-10011000b ^ 00100001b = 10111001b
-10011000b ^ 00100010b = 10111010b
-10011000b ^ 00100011b = 10111011b
-10011000b ^ 00100100b = 10111100b
-10011000b ^ 00100101b = 10111101b
-10011000b ^ 00100110b = 10111110b
-10011000b ^ 00100111b = 10111111b
-10011000b ^ 00101000b = 10110000b
-10011000b ^ 00101001b = 10110001b
-10011000b ^ 00101010b = 10110010b
-10011000b ^ 00101011b = 10110011b
-10011000b ^ 00101100b = 10110100b
-10011000b ^ 00101101b = 10110101b
-10011000b ^ 00101110b = 10110110b
-10011000b ^ 00101111b = 10110111b
-10011000b ^ 00110000b = 10101000b
-10011000b ^ 00110001b = 10101001b
-10011000b ^ 00110010b = 10101010b
-10011000b ^ 00110011b = 10101011b
-10011000b ^ 00110100b = 10101100b
-10011000b ^ 00110101b = 10101101b
-10011000b ^ 00110110b = 10101110b
-10011000b ^ 00110111b = 10101111b
-10011000b ^ 00111000b = 10100000b
-10011000b ^ 00111001b = 10100001b
-10011000b ^ 00111010b = 10100010b
-10011000b ^ 00111011b = 10100011b
-10011000b ^ 00111100b = 10100100b
-10011000b ^ 00111101b = 10100101b
-10011000b ^ 00111110b = 10100110b
-10011000b ^ 00111111b = 10100111b
-10011000b ^ 01000000b = 11011000b
-10011000b ^ 01000001b = 11011001b
-10011000b ^ 01000010b = 11011010b
-10011000b ^ 01000011b = 11011011b
-10011000b ^ 01000100b = 11011100b
-10011000b ^ 01000101b = 11011101b
-10011000b ^ 01000110b = 11011110b
-10011000b ^ 01000111b = 11011111b
-10011000b ^ 01001000b = 11010000b
-10011000b ^ 01001001b = 11010001b
-10011000b ^ 01001010b = 11010010b
-10011000b ^ 01001011b = 11010011b
-10011000b ^ 01001100b = 11010100b
-10011000b ^ 01001101b = 11010101b
-10011000b ^ 01001110b = 11010110b
-10011000b ^ 01001111b = 11010111b
-10011000b ^ 01010000b = 11001000b
-10011000b ^ 01010001b = 11001001b
-10011000b ^ 01010010b = 11001010b
-10011000b ^ 01010011b = 11001011b
-10011000b ^ 01010100b = 11001100b
-10011000b ^ 01010101b = 11001101b
-10011000b ^ 01010110b = 11001110b
-10011000b ^ 01010111b = 11001111b
-10011000b ^ 01011000b = 11000000b
-10011000b ^ 01011001b = 11000001b
-10011000b ^ 01011010b = 11000010b
-10011000b ^ 01011011b = 11000011b
-10011000b ^ 01011100b = 11000100b
-10011000b ^ 01011101b = 11000101b
-10011000b ^ 01011110b = 11000110b
-10011000b ^ 01011111b = 11000111b
-10011000b ^ 01100000b = 11111000b
-10011000b ^ 01100001b = 11111001b
-10011000b ^ 01100010b = 11111010b
-10011000b ^ 01100011b = 11111011b
-10011000b ^ 01100100b = 11111100b
-10011000b ^ 01100101b = 11111101b
-10011000b ^ 01100110b = 11111110b
-10011000b ^ 01100111b = 11111111b
-10011000b ^ 01101000b = 11110000b
-10011000b ^ 01101001b = 11110001b
-10011000b ^ 01101010b = 11110010b
-10011000b ^ 01101011b = 11110011b
-10011000b ^ 01101100b = 11110100b
-10011000b ^ 01101101b = 11110101b
-10011000b ^ 01101110b = 11110110b
-10011000b ^ 01101111b = 11110111b
-10011000b ^ 01110000b = 11101000b
-10011000b ^ 01110001b = 11101001b
-10011000b ^ 01110010b = 11101010b
-10011000b ^ 01110011b = 11101011b
-10011000b ^ 01110100b = 11101100b
-10011000b ^ 01110101b = 11101101b
-10011000b ^ 01110110b = 11101110b
-10011000b ^ 01110111b = 11101111b
-10011000b ^ 01111000b = 11100000b
-10011000b ^ 01111001b = 11100001b
-10011000b ^ 01111010b = 11100010b
-10011000b ^ 01111011b = 11100011b
-10011000b ^ 01111100b = 11100100b
-10011000b ^ 01111101b = 11100101b
-10011000b ^ 01111110b = 11100110b
-10011001b ^ 10000000b = 00011001b
-10011001b ^ 10000001b = 00011000b
-10011001b ^ 10000010b = 00011011b
-10011001b ^ 10000011b = 00011010b
-10011001b ^ 10000100b = 00011101b
-10011001b ^ 10000101b = 00011100b
-10011001b ^ 10000110b = 00011111b
-10011001b ^ 10000111b = 00011110b
-10011001b ^ 10001000b = 00010001b
-10011001b ^ 10001001b = 00010000b
-10011001b ^ 10001010b = 00010011b
-10011001b ^ 10001011b = 00010010b
-10011001b ^ 10001100b = 00010101b
-10011001b ^ 10001101b = 00010100b
-10011001b ^ 10001110b = 00010111b
-10011001b ^ 10001111b = 00010110b
-10011001b ^ 10010000b = 00001001b
-10011001b ^ 10010001b = 00001000b
-10011001b ^ 10010010b = 00001011b
-10011001b ^ 10010011b = 00001010b
-10011001b ^ 10010100b = 00001101b
-10011001b ^ 10010101b = 00001100b
-10011001b ^ 10010110b = 00001111b
-10011001b ^ 10010111b = 00001110b
-10011001b ^ 10011000b = 00000001b
-10011001b ^ 10011001b = 00000000b
-10011001b ^ 10011010b = 00000011b
-10011001b ^ 10011011b = 00000010b
-10011001b ^ 10011100b = 00000101b
-10011001b ^ 10011101b = 00000100b
-10011001b ^ 10011110b = 00000111b
-10011001b ^ 10011111b = 00000110b
-10011001b ^ 10100000b = 00111001b
-10011001b ^ 10100001b = 00111000b
-10011001b ^ 10100010b = 00111011b
-10011001b ^ 10100011b = 00111010b
-10011001b ^ 10100100b = 00111101b
-10011001b ^ 10100101b = 00111100b
-10011001b ^ 10100110b = 00111111b
-10011001b ^ 10100111b = 00111110b
-10011001b ^ 10101000b = 00110001b
-10011001b ^ 10101001b = 00110000b
-10011001b ^ 10101010b = 00110011b
-10011001b ^ 10101011b = 00110010b
-10011001b ^ 10101100b = 00110101b
-10011001b ^ 10101101b = 00110100b
-10011001b ^ 10101110b = 00110111b
-10011001b ^ 10101111b = 00110110b
-10011001b ^ 10110000b = 00101001b
-10011001b ^ 10110001b = 00101000b
-10011001b ^ 10110010b = 00101011b
-10011001b ^ 10110011b = 00101010b
-10011001b ^ 10110100b = 00101101b
-10011001b ^ 10110101b = 00101100b
-10011001b ^ 10110110b = 00101111b
-10011001b ^ 10110111b = 00101110b
-10011001b ^ 10111000b = 00100001b
-10011001b ^ 10111001b = 00100000b
-10011001b ^ 10111010b = 00100011b
-10011001b ^ 10111011b = 00100010b
-10011001b ^ 10111100b = 00100101b
-10011001b ^ 10111101b = 00100100b
-10011001b ^ 10111110b = 00100111b
-10011001b ^ 10111111b = 00100110b
-10011001b ^ 11000000b = 01011001b
-10011001b ^ 11000001b = 01011000b
-10011001b ^ 11000010b = 01011011b
-10011001b ^ 11000011b = 01011010b
-10011001b ^ 11000100b = 01011101b
-10011001b ^ 11000101b = 01011100b
-10011001b ^ 11000110b = 01011111b
-10011001b ^ 11000111b = 01011110b
-10011001b ^ 11001000b = 01010001b
-10011001b ^ 11001001b = 01010000b
-10011001b ^ 11001010b = 01010011b
-10011001b ^ 11001011b = 01010010b
-10011001b ^ 11001100b = 01010101b
-10011001b ^ 11001101b = 01010100b
-10011001b ^ 11001110b = 01010111b
-10011001b ^ 11001111b = 01010110b
-10011001b ^ 11010000b = 01001001b
-10011001b ^ 11010001b = 01001000b
-10011001b ^ 11010010b = 01001011b
-10011001b ^ 11010011b = 01001010b
-10011001b ^ 11010100b = 01001101b
-10011001b ^ 11010101b = 01001100b
-10011001b ^ 11010110b = 01001111b
-10011001b ^ 11010111b = 01001110b
-10011001b ^ 11011000b = 01000001b
-10011001b ^ 11011001b = 01000000b
-10011001b ^ 11011010b = 01000011b
-10011001b ^ 11011011b = 01000010b
-10011001b ^ 11011100b = 01000101b
-10011001b ^ 11011101b = 01000100b
-10011001b ^ 11011110b = 01000111b
-10011001b ^ 11011111b = 01000110b
-10011001b ^ 11100000b = 01111001b
-10011001b ^ 11100001b = 01111000b
-10011001b ^ 11100010b = 01111011b
-10011001b ^ 11100011b = 01111010b
-10011001b ^ 11100100b = 01111101b
-10011001b ^ 11100101b = 01111100b
-10011001b ^ 11100110b = 01111111b
-10011001b ^ 11100111b = 01111110b
-10011001b ^ 11101000b = 01110001b
-10011001b ^ 11101001b = 01110000b
-10011001b ^ 11101010b = 01110011b
-10011001b ^ 11101011b = 01110010b
-10011001b ^ 11101100b = 01110101b
-10011001b ^ 11101101b = 01110100b
-10011001b ^ 11101110b = 01110111b
-10011001b ^ 11101111b = 01110110b
-10011001b ^ 11110000b = 01101001b
-10011001b ^ 11110001b = 01101000b
-10011001b ^ 11110010b = 01101011b
-10011001b ^ 11110011b = 01101010b
-10011001b ^ 11110100b = 01101101b
-10011001b ^ 11110101b = 01101100b
-10011001b ^ 11110110b = 01101111b
-10011001b ^ 11110111b = 01101110b
-10011001b ^ 11111000b = 01100001b
-10011001b ^ 11111001b = 01100000b
-10011001b ^ 11111010b = 01100011b
-10011001b ^ 11111011b = 01100010b
-10011001b ^ 11111100b = 01100101b
-10011001b ^ 11111101b = 01100100b
-10011001b ^ 11111110b = 01100111b
-10011001b ^ 11111111b = 01100110b
-10011001b ^ 00000000b = 10011001b
-10011001b ^ 00000001b = 10011000b
-10011001b ^ 00000010b = 10011011b
-10011001b ^ 00000011b = 10011010b
-10011001b ^ 00000100b = 10011101b
-10011001b ^ 00000101b = 10011100b
-10011001b ^ 00000110b = 10011111b
-10011001b ^ 00000111b = 10011110b
-10011001b ^ 00001000b = 10010001b
-10011001b ^ 00001001b = 10010000b
-10011001b ^ 00001010b = 10010011b
-10011001b ^ 00001011b = 10010010b
-10011001b ^ 00001100b = 10010101b
-10011001b ^ 00001101b = 10010100b
-10011001b ^ 00001110b = 10010111b
-10011001b ^ 00001111b = 10010110b
-10011001b ^ 00010000b = 10001001b
-10011001b ^ 00010001b = 10001000b
-10011001b ^ 00010010b = 10001011b
-10011001b ^ 00010011b = 10001010b
-10011001b ^ 00010100b = 10001101b
-10011001b ^ 00010101b = 10001100b
-10011001b ^ 00010110b = 10001111b
-10011001b ^ 00010111b = 10001110b
-10011001b ^ 00011000b = 10000001b
-10011001b ^ 00011001b = 10000000b
-10011001b ^ 00011010b = 10000011b
-10011001b ^ 00011011b = 10000010b
-10011001b ^ 00011100b = 10000101b
-10011001b ^ 00011101b = 10000100b
-10011001b ^ 00011110b = 10000111b
-10011001b ^ 00011111b = 10000110b
-10011001b ^ 00100000b = 10111001b
-10011001b ^ 00100001b = 10111000b
-10011001b ^ 00100010b = 10111011b
-10011001b ^ 00100011b = 10111010b
-10011001b ^ 00100100b = 10111101b
-10011001b ^ 00100101b = 10111100b
-10011001b ^ 00100110b = 10111111b
-10011001b ^ 00100111b = 10111110b
-10011001b ^ 00101000b = 10110001b
-10011001b ^ 00101001b = 10110000b
-10011001b ^ 00101010b = 10110011b
-10011001b ^ 00101011b = 10110010b
-10011001b ^ 00101100b = 10110101b
-10011001b ^ 00101101b = 10110100b
-10011001b ^ 00101110b = 10110111b
-10011001b ^ 00101111b = 10110110b
-10011001b ^ 00110000b = 10101001b
-10011001b ^ 00110001b = 10101000b
-10011001b ^ 00110010b = 10101011b
-10011001b ^ 00110011b = 10101010b
-10011001b ^ 00110100b = 10101101b
-10011001b ^ 00110101b = 10101100b
-10011001b ^ 00110110b = 10101111b
-10011001b ^ 00110111b = 10101110b
-10011001b ^ 00111000b = 10100001b
-10011001b ^ 00111001b = 10100000b
-10011001b ^ 00111010b = 10100011b
-10011001b ^ 00111011b = 10100010b
-10011001b ^ 00111100b = 10100101b
-10011001b ^ 00111101b = 10100100b
-10011001b ^ 00111110b = 10100111b
-10011001b ^ 00111111b = 10100110b
-10011001b ^ 01000000b = 11011001b
-10011001b ^ 01000001b = 11011000b
-10011001b ^ 01000010b = 11011011b
-10011001b ^ 01000011b = 11011010b
-10011001b ^ 01000100b = 11011101b
-10011001b ^ 01000101b = 11011100b
-10011001b ^ 01000110b = 11011111b
-10011001b ^ 01000111b = 11011110b
-10011001b ^ 01001000b = 11010001b
-10011001b ^ 01001001b = 11010000b
-10011001b ^ 01001010b = 11010011b
-10011001b ^ 01001011b = 11010010b
-10011001b ^ 01001100b = 11010101b
-10011001b ^ 01001101b = 11010100b
-10011001b ^ 01001110b = 11010111b
-10011001b ^ 01001111b = 11010110b
-10011001b ^ 01010000b = 11001001b
-10011001b ^ 01010001b = 11001000b
-10011001b ^ 01010010b = 11001011b
-10011001b ^ 01010011b = 11001010b
-10011001b ^ 01010100b = 11001101b
-10011001b ^ 01010101b = 11001100b
-10011001b ^ 01010110b = 11001111b
-10011001b ^ 01010111b = 11001110b
-10011001b ^ 01011000b = 11000001b
-10011001b ^ 01011001b = 11000000b
-10011001b ^ 01011010b = 11000011b
-10011001b ^ 01011011b = 11000010b
-10011001b ^ 01011100b = 11000101b
-10011001b ^ 01011101b = 11000100b
-10011001b ^ 01011110b = 11000111b
-10011001b ^ 01011111b = 11000110b
-10011001b ^ 01100000b = 11111001b
-10011001b ^ 01100001b = 11111000b
-10011001b ^ 01100010b = 11111011b
-10011001b ^ 01100011b = 11111010b
-10011001b ^ 01100100b = 11111101b
-10011001b ^ 01100101b = 11111100b
-10011001b ^ 01100110b = 11111111b
-10011001b ^ 01100111b = 11111110b
-10011001b ^ 01101000b = 11110001b
-10011001b ^ 01101001b = 11110000b
-10011001b ^ 01101010b = 11110011b
-10011001b ^ 01101011b = 11110010b
-10011001b ^ 01101100b = 11110101b
-10011001b ^ 01101101b = 11110100b
-10011001b ^ 01101110b = 11110111b
-10011001b ^ 01101111b = 11110110b
-10011001b ^ 01110000b = 11101001b
-10011001b ^ 01110001b = 11101000b
-10011001b ^ 01110010b = 11101011b
-10011001b ^ 01110011b = 11101010b
-10011001b ^ 01110100b = 11101101b
-10011001b ^ 01110101b = 11101100b
-10011001b ^ 01110110b = 11101111b
-10011001b ^ 01110111b = 11101110b
-10011001b ^ 01111000b = 11100001b
-10011001b ^ 01111001b = 11100000b
-10011001b ^ 01111010b = 11100011b
-10011001b ^ 01111011b = 11100010b
-10011001b ^ 01111100b = 11100101b
-10011001b ^ 01111101b = 11100100b
-10011001b ^ 01111110b = 11100111b
-10011010b ^ 10000000b = 00011010b
-10011010b ^ 10000001b = 00011011b
-10011010b ^ 10000010b = 00011000b
-10011010b ^ 10000011b = 00011001b
-10011010b ^ 10000100b = 00011110b
-10011010b ^ 10000101b = 00011111b
-10011010b ^ 10000110b = 00011100b
-10011010b ^ 10000111b = 00011101b
-10011010b ^ 10001000b = 00010010b
-10011010b ^ 10001001b = 00010011b
-10011010b ^ 10001010b = 00010000b
-10011010b ^ 10001011b = 00010001b
-10011010b ^ 10001100b = 00010110b
-10011010b ^ 10001101b = 00010111b
-10011010b ^ 10001110b = 00010100b
-10011010b ^ 10001111b = 00010101b
-10011010b ^ 10010000b = 00001010b
-10011010b ^ 10010001b = 00001011b
-10011010b ^ 10010010b = 00001000b
-10011010b ^ 10010011b = 00001001b
-10011010b ^ 10010100b = 00001110b
-10011010b ^ 10010101b = 00001111b
-10011010b ^ 10010110b = 00001100b
-10011010b ^ 10010111b = 00001101b
-10011010b ^ 10011000b = 00000010b
-10011010b ^ 10011001b = 00000011b
-10011010b ^ 10011010b = 00000000b
-10011010b ^ 10011011b = 00000001b
-10011010b ^ 10011100b = 00000110b
-10011010b ^ 10011101b = 00000111b
-10011010b ^ 10011110b = 00000100b
-10011010b ^ 10011111b = 00000101b
-10011010b ^ 10100000b = 00111010b
-10011010b ^ 10100001b = 00111011b
-10011010b ^ 10100010b = 00111000b
-10011010b ^ 10100011b = 00111001b
-10011010b ^ 10100100b = 00111110b
-10011010b ^ 10100101b = 00111111b
-10011010b ^ 10100110b = 00111100b
-10011010b ^ 10100111b = 00111101b
-10011010b ^ 10101000b = 00110010b
-10011010b ^ 10101001b = 00110011b
-10011010b ^ 10101010b = 00110000b
-10011010b ^ 10101011b = 00110001b
-10011010b ^ 10101100b = 00110110b
-10011010b ^ 10101101b = 00110111b
-10011010b ^ 10101110b = 00110100b
-10011010b ^ 10101111b = 00110101b
-10011010b ^ 10110000b = 00101010b
-10011010b ^ 10110001b = 00101011b
-10011010b ^ 10110010b = 00101000b
-10011010b ^ 10110011b = 00101001b
-10011010b ^ 10110100b = 00101110b
-10011010b ^ 10110101b = 00101111b
-10011010b ^ 10110110b = 00101100b
-10011010b ^ 10110111b = 00101101b
-10011010b ^ 10111000b = 00100010b
-10011010b ^ 10111001b = 00100011b
-10011010b ^ 10111010b = 00100000b
-10011010b ^ 10111011b = 00100001b
-10011010b ^ 10111100b = 00100110b
-10011010b ^ 10111101b = 00100111b
-10011010b ^ 10111110b = 00100100b
-10011010b ^ 10111111b = 00100101b
-10011010b ^ 11000000b = 01011010b
-10011010b ^ 11000001b = 01011011b
-10011010b ^ 11000010b = 01011000b
-10011010b ^ 11000011b = 01011001b
-10011010b ^ 11000100b = 01011110b
-10011010b ^ 11000101b = 01011111b
-10011010b ^ 11000110b = 01011100b
-10011010b ^ 11000111b = 01011101b
-10011010b ^ 11001000b = 01010010b
-10011010b ^ 11001001b = 01010011b
-10011010b ^ 11001010b = 01010000b
-10011010b ^ 11001011b = 01010001b
-10011010b ^ 11001100b = 01010110b
-10011010b ^ 11001101b = 01010111b
-10011010b ^ 11001110b = 01010100b
-10011010b ^ 11001111b = 01010101b
-10011010b ^ 11010000b = 01001010b
-10011010b ^ 11010001b = 01001011b
-10011010b ^ 11010010b = 01001000b
-10011010b ^ 11010011b = 01001001b
-10011010b ^ 11010100b = 01001110b
-10011010b ^ 11010101b = 01001111b
-10011010b ^ 11010110b = 01001100b
-10011010b ^ 11010111b = 01001101b
-10011010b ^ 11011000b = 01000010b
-10011010b ^ 11011001b = 01000011b
-10011010b ^ 11011010b = 01000000b
-10011010b ^ 11011011b = 01000001b
-10011010b ^ 11011100b = 01000110b
-10011010b ^ 11011101b = 01000111b
-10011010b ^ 11011110b = 01000100b
-10011010b ^ 11011111b = 01000101b
-10011010b ^ 11100000b = 01111010b
-10011010b ^ 11100001b = 01111011b
-10011010b ^ 11100010b = 01111000b
-10011010b ^ 11100011b = 01111001b
-10011010b ^ 11100100b = 01111110b
-10011010b ^ 11100101b = 01111111b
-10011010b ^ 11100110b = 01111100b
-10011010b ^ 11100111b = 01111101b
-10011010b ^ 11101000b = 01110010b
-10011010b ^ 11101001b = 01110011b
-10011010b ^ 11101010b = 01110000b
-10011010b ^ 11101011b = 01110001b
-10011010b ^ 11101100b = 01110110b
-10011010b ^ 11101101b = 01110111b
-10011010b ^ 11101110b = 01110100b
-10011010b ^ 11101111b = 01110101b
-10011010b ^ 11110000b = 01101010b
-10011010b ^ 11110001b = 01101011b
-10011010b ^ 11110010b = 01101000b
-10011010b ^ 11110011b = 01101001b
-10011010b ^ 11110100b = 01101110b
-10011010b ^ 11110101b = 01101111b
-10011010b ^ 11110110b = 01101100b
-10011010b ^ 11110111b = 01101101b
-10011010b ^ 11111000b = 01100010b
-10011010b ^ 11111001b = 01100011b
-10011010b ^ 11111010b = 01100000b
-10011010b ^ 11111011b = 01100001b
-10011010b ^ 11111100b = 01100110b
-10011010b ^ 11111101b = 01100111b
-10011010b ^ 11111110b = 01100100b
-10011010b ^ 11111111b = 01100101b
-10011010b ^ 00000000b = 10011010b
-10011010b ^ 00000001b = 10011011b
-10011010b ^ 00000010b = 10011000b
-10011010b ^ 00000011b = 10011001b
-10011010b ^ 00000100b = 10011110b
-10011010b ^ 00000101b = 10011111b
-10011010b ^ 00000110b = 10011100b
-10011010b ^ 00000111b = 10011101b
-10011010b ^ 00001000b = 10010010b
-10011010b ^ 00001001b = 10010011b
-10011010b ^ 00001010b = 10010000b
-10011010b ^ 00001011b = 10010001b
-10011010b ^ 00001100b = 10010110b
-10011010b ^ 00001101b = 10010111b
-10011010b ^ 00001110b = 10010100b
-10011010b ^ 00001111b = 10010101b
-10011010b ^ 00010000b = 10001010b
-10011010b ^ 00010001b = 10001011b
-10011010b ^ 00010010b = 10001000b
-10011010b ^ 00010011b = 10001001b
-10011010b ^ 00010100b = 10001110b
-10011010b ^ 00010101b = 10001111b
-10011010b ^ 00010110b = 10001100b
-10011010b ^ 00010111b = 10001101b
-10011010b ^ 00011000b = 10000010b
-10011010b ^ 00011001b = 10000011b
-10011010b ^ 00011010b = 10000000b
-10011010b ^ 00011011b = 10000001b
-10011010b ^ 00011100b = 10000110b
-10011010b ^ 00011101b = 10000111b
-10011010b ^ 00011110b = 10000100b
-10011010b ^ 00011111b = 10000101b
-10011010b ^ 00100000b = 10111010b
-10011010b ^ 00100001b = 10111011b
-10011010b ^ 00100010b = 10111000b
-10011010b ^ 00100011b = 10111001b
-10011010b ^ 00100100b = 10111110b
-10011010b ^ 00100101b = 10111111b
-10011010b ^ 00100110b = 10111100b
-10011010b ^ 00100111b = 10111101b
-10011010b ^ 00101000b = 10110010b
-10011010b ^ 00101001b = 10110011b
-10011010b ^ 00101010b = 10110000b
-10011010b ^ 00101011b = 10110001b
-10011010b ^ 00101100b = 10110110b
-10011010b ^ 00101101b = 10110111b
-10011010b ^ 00101110b = 10110100b
-10011010b ^ 00101111b = 10110101b
-10011010b ^ 00110000b = 10101010b
-10011010b ^ 00110001b = 10101011b
-10011010b ^ 00110010b = 10101000b
-10011010b ^ 00110011b = 10101001b
-10011010b ^ 00110100b = 10101110b
-10011010b ^ 00110101b = 10101111b
-10011010b ^ 00110110b = 10101100b
-10011010b ^ 00110111b = 10101101b
-10011010b ^ 00111000b = 10100010b
-10011010b ^ 00111001b = 10100011b
-10011010b ^ 00111010b = 10100000b
-10011010b ^ 00111011b = 10100001b
-10011010b ^ 00111100b = 10100110b
-10011010b ^ 00111101b = 10100111b
-10011010b ^ 00111110b = 10100100b
-10011010b ^ 00111111b = 10100101b
-10011010b ^ 01000000b = 11011010b
-10011010b ^ 01000001b = 11011011b
-10011010b ^ 01000010b = 11011000b
-10011010b ^ 01000011b = 11011001b
-10011010b ^ 01000100b = 11011110b
-10011010b ^ 01000101b = 11011111b
-10011010b ^ 01000110b = 11011100b
-10011010b ^ 01000111b = 11011101b
-10011010b ^ 01001000b = 11010010b
-10011010b ^ 01001001b = 11010011b
-10011010b ^ 01001010b = 11010000b
-10011010b ^ 01001011b = 11010001b
-10011010b ^ 01001100b = 11010110b
-10011010b ^ 01001101b = 11010111b
-10011010b ^ 01001110b = 11010100b
-10011010b ^ 01001111b = 11010101b
-10011010b ^ 01010000b = 11001010b
-10011010b ^ 01010001b = 11001011b
-10011010b ^ 01010010b = 11001000b
-10011010b ^ 01010011b = 11001001b
-10011010b ^ 01010100b = 11001110b
-10011010b ^ 01010101b = 11001111b
-10011010b ^ 01010110b = 11001100b
-10011010b ^ 01010111b = 11001101b
-10011010b ^ 01011000b = 11000010b
-10011010b ^ 01011001b = 11000011b
-10011010b ^ 01011010b = 11000000b
-10011010b ^ 01011011b = 11000001b
-10011010b ^ 01011100b = 11000110b
-10011010b ^ 01011101b = 11000111b
-10011010b ^ 01011110b = 11000100b
-10011010b ^ 01011111b = 11000101b
-10011010b ^ 01100000b = 11111010b
-10011010b ^ 01100001b = 11111011b
-10011010b ^ 01100010b = 11111000b
-10011010b ^ 01100011b = 11111001b
-10011010b ^ 01100100b = 11111110b
-10011010b ^ 01100101b = 11111111b
-10011010b ^ 01100110b = 11111100b
-10011010b ^ 01100111b = 11111101b
-10011010b ^ 01101000b = 11110010b
-10011010b ^ 01101001b = 11110011b
-10011010b ^ 01101010b = 11110000b
-10011010b ^ 01101011b = 11110001b
-10011010b ^ 01101100b = 11110110b
-10011010b ^ 01101101b = 11110111b
-10011010b ^ 01101110b = 11110100b
-10011010b ^ 01101111b = 11110101b
-10011010b ^ 01110000b = 11101010b
-10011010b ^ 01110001b = 11101011b
-10011010b ^ 01110010b = 11101000b
-10011010b ^ 01110011b = 11101001b
-10011010b ^ 01110100b = 11101110b
-10011010b ^ 01110101b = 11101111b
-10011010b ^ 01110110b = 11101100b
-10011010b ^ 01110111b = 11101101b
-10011010b ^ 01111000b = 11100010b
-10011010b ^ 01111001b = 11100011b
-10011010b ^ 01111010b = 11100000b
-10011010b ^ 01111011b = 11100001b
-10011010b ^ 01111100b = 11100110b
-10011010b ^ 01111101b = 11100111b
-10011010b ^ 01111110b = 11100100b
-10011011b ^ 10000000b = 00011011b
-10011011b ^ 10000001b = 00011010b
-10011011b ^ 10000010b = 00011001b
-10011011b ^ 10000011b = 00011000b
-10011011b ^ 10000100b = 00011111b
-10011011b ^ 10000101b = 00011110b
-10011011b ^ 10000110b = 00011101b
-10011011b ^ 10000111b = 00011100b
-10011011b ^ 10001000b = 00010011b
-10011011b ^ 10001001b = 00010010b
-10011011b ^ 10001010b = 00010001b
-10011011b ^ 10001011b = 00010000b
-10011011b ^ 10001100b = 00010111b
-10011011b ^ 10001101b = 00010110b
-10011011b ^ 10001110b = 00010101b
-10011011b ^ 10001111b = 00010100b
-10011011b ^ 10010000b = 00001011b
-10011011b ^ 10010001b = 00001010b
-10011011b ^ 10010010b = 00001001b
-10011011b ^ 10010011b = 00001000b
-10011011b ^ 10010100b = 00001111b
-10011011b ^ 10010101b = 00001110b
-10011011b ^ 10010110b = 00001101b
-10011011b ^ 10010111b = 00001100b
-10011011b ^ 10011000b = 00000011b
-10011011b ^ 10011001b = 00000010b
-10011011b ^ 10011010b = 00000001b
-10011011b ^ 10011011b = 00000000b
-10011011b ^ 10011100b = 00000111b
-10011011b ^ 10011101b = 00000110b
-10011011b ^ 10011110b = 00000101b
-10011011b ^ 10011111b = 00000100b
-10011011b ^ 10100000b = 00111011b
-10011011b ^ 10100001b = 00111010b
-10011011b ^ 10100010b = 00111001b
-10011011b ^ 10100011b = 00111000b
-10011011b ^ 10100100b = 00111111b
-10011011b ^ 10100101b = 00111110b
-10011011b ^ 10100110b = 00111101b
-10011011b ^ 10100111b = 00111100b
-10011011b ^ 10101000b = 00110011b
-10011011b ^ 10101001b = 00110010b
-10011011b ^ 10101010b = 00110001b
-10011011b ^ 10101011b = 00110000b
-10011011b ^ 10101100b = 00110111b
-10011011b ^ 10101101b = 00110110b
-10011011b ^ 10101110b = 00110101b
-10011011b ^ 10101111b = 00110100b
-10011011b ^ 10110000b = 00101011b
-10011011b ^ 10110001b = 00101010b
-10011011b ^ 10110010b = 00101001b
-10011011b ^ 10110011b = 00101000b
-10011011b ^ 10110100b = 00101111b
-10011011b ^ 10110101b = 00101110b
-10011011b ^ 10110110b = 00101101b
-10011011b ^ 10110111b = 00101100b
-10011011b ^ 10111000b = 00100011b
-10011011b ^ 10111001b = 00100010b
-10011011b ^ 10111010b = 00100001b
-10011011b ^ 10111011b = 00100000b
-10011011b ^ 10111100b = 00100111b
-10011011b ^ 10111101b = 00100110b
-10011011b ^ 10111110b = 00100101b
-10011011b ^ 10111111b = 00100100b
-10011011b ^ 11000000b = 01011011b
-10011011b ^ 11000001b = 01011010b
-10011011b ^ 11000010b = 01011001b
-10011011b ^ 11000011b = 01011000b
-10011011b ^ 11000100b = 01011111b
-10011011b ^ 11000101b = 01011110b
-10011011b ^ 11000110b = 01011101b
-10011011b ^ 11000111b = 01011100b
-10011011b ^ 11001000b = 01010011b
-10011011b ^ 11001001b = 01010010b
-10011011b ^ 11001010b = 01010001b
-10011011b ^ 11001011b = 01010000b
-10011011b ^ 11001100b = 01010111b
-10011011b ^ 11001101b = 01010110b
-10011011b ^ 11001110b = 01010101b
-10011011b ^ 11001111b = 01010100b
-10011011b ^ 11010000b = 01001011b
-10011011b ^ 11010001b = 01001010b
-10011011b ^ 11010010b = 01001001b
-10011011b ^ 11010011b = 01001000b
-10011011b ^ 11010100b = 01001111b
-10011011b ^ 11010101b = 01001110b
-10011011b ^ 11010110b = 01001101b
-10011011b ^ 11010111b = 01001100b
-10011011b ^ 11011000b = 01000011b
-10011011b ^ 11011001b = 01000010b
-10011011b ^ 11011010b = 01000001b
-10011011b ^ 11011011b = 01000000b
-10011011b ^ 11011100b = 01000111b
-10011011b ^ 11011101b = 01000110b
-10011011b ^ 11011110b = 01000101b
-10011011b ^ 11011111b = 01000100b
-10011011b ^ 11100000b = 01111011b
-10011011b ^ 11100001b = 01111010b
-10011011b ^ 11100010b = 01111001b
-10011011b ^ 11100011b = 01111000b
-10011011b ^ 11100100b = 01111111b
-10011011b ^ 11100101b = 01111110b
-10011011b ^ 11100110b = 01111101b
-10011011b ^ 11100111b = 01111100b
-10011011b ^ 11101000b = 01110011b
-10011011b ^ 11101001b = 01110010b
-10011011b ^ 11101010b = 01110001b
-10011011b ^ 11101011b = 01110000b
-10011011b ^ 11101100b = 01110111b
-10011011b ^ 11101101b = 01110110b
-10011011b ^ 11101110b = 01110101b
-10011011b ^ 11101111b = 01110100b
-10011011b ^ 11110000b = 01101011b
-10011011b ^ 11110001b = 01101010b
-10011011b ^ 11110010b = 01101001b
-10011011b ^ 11110011b = 01101000b
-10011011b ^ 11110100b = 01101111b
-10011011b ^ 11110101b = 01101110b
-10011011b ^ 11110110b = 01101101b
-10011011b ^ 11110111b = 01101100b
-10011011b ^ 11111000b = 01100011b
-10011011b ^ 11111001b = 01100010b
-10011011b ^ 11111010b = 01100001b
-10011011b ^ 11111011b = 01100000b
-10011011b ^ 11111100b = 01100111b
-10011011b ^ 11111101b = 01100110b
-10011011b ^ 11111110b = 01100101b
-10011011b ^ 11111111b = 01100100b
-10011011b ^ 00000000b = 10011011b
-10011011b ^ 00000001b = 10011010b
-10011011b ^ 00000010b = 10011001b
-10011011b ^ 00000011b = 10011000b
-10011011b ^ 00000100b = 10011111b
-10011011b ^ 00000101b = 10011110b
-10011011b ^ 00000110b = 10011101b
-10011011b ^ 00000111b = 10011100b
-10011011b ^ 00001000b = 10010011b
-10011011b ^ 00001001b = 10010010b
-10011011b ^ 00001010b = 10010001b
-10011011b ^ 00001011b = 10010000b
-10011011b ^ 00001100b = 10010111b
-10011011b ^ 00001101b = 10010110b
-10011011b ^ 00001110b = 10010101b
-10011011b ^ 00001111b = 10010100b
-10011011b ^ 00010000b = 10001011b
-10011011b ^ 00010001b = 10001010b
-10011011b ^ 00010010b = 10001001b
-10011011b ^ 00010011b = 10001000b
-10011011b ^ 00010100b = 10001111b
-10011011b ^ 00010101b = 10001110b
-10011011b ^ 00010110b = 10001101b
-10011011b ^ 00010111b = 10001100b
-10011011b ^ 00011000b = 10000011b
-10011011b ^ 00011001b = 10000010b
-10011011b ^ 00011010b = 10000001b
-10011011b ^ 00011011b = 10000000b
-10011011b ^ 00011100b = 10000111b
-10011011b ^ 00011101b = 10000110b
-10011011b ^ 00011110b = 10000101b
-10011011b ^ 00011111b = 10000100b
-10011011b ^ 00100000b = 10111011b
-10011011b ^ 00100001b = 10111010b
-10011011b ^ 00100010b = 10111001b
-10011011b ^ 00100011b = 10111000b
-10011011b ^ 00100100b = 10111111b
-10011011b ^ 00100101b = 10111110b
-10011011b ^ 00100110b = 10111101b
-10011011b ^ 00100111b = 10111100b
-10011011b ^ 00101000b = 10110011b
-10011011b ^ 00101001b = 10110010b
-10011011b ^ 00101010b = 10110001b
-10011011b ^ 00101011b = 10110000b
-10011011b ^ 00101100b = 10110111b
-10011011b ^ 00101101b = 10110110b
-10011011b ^ 00101110b = 10110101b
-10011011b ^ 00101111b = 10110100b
-10011011b ^ 00110000b = 10101011b
-10011011b ^ 00110001b = 10101010b
-10011011b ^ 00110010b = 10101001b
-10011011b ^ 00110011b = 10101000b
-10011011b ^ 00110100b = 10101111b
-10011011b ^ 00110101b = 10101110b
-10011011b ^ 00110110b = 10101101b
-10011011b ^ 00110111b = 10101100b
-10011011b ^ 00111000b = 10100011b
-10011011b ^ 00111001b = 10100010b
-10011011b ^ 00111010b = 10100001b
-10011011b ^ 00111011b = 10100000b
-10011011b ^ 00111100b = 10100111b
-10011011b ^ 00111101b = 10100110b
-10011011b ^ 00111110b = 10100101b
-10011011b ^ 00111111b = 10100100b
-10011011b ^ 01000000b = 11011011b
-10011011b ^ 01000001b = 11011010b
-10011011b ^ 01000010b = 11011001b
-10011011b ^ 01000011b = 11011000b
-10011011b ^ 01000100b = 11011111b
-10011011b ^ 01000101b = 11011110b
-10011011b ^ 01000110b = 11011101b
-10011011b ^ 01000111b = 11011100b
-10011011b ^ 01001000b = 11010011b
-10011011b ^ 01001001b = 11010010b
-10011011b ^ 01001010b = 11010001b
-10011011b ^ 01001011b = 11010000b
-10011011b ^ 01001100b = 11010111b
-10011011b ^ 01001101b = 11010110b
-10011011b ^ 01001110b = 11010101b
-10011011b ^ 01001111b = 11010100b
-10011011b ^ 01010000b = 11001011b
-10011011b ^ 01010001b = 11001010b
-10011011b ^ 01010010b = 11001001b
-10011011b ^ 01010011b = 11001000b
-10011011b ^ 01010100b = 11001111b
-10011011b ^ 01010101b = 11001110b
-10011011b ^ 01010110b = 11001101b
-10011011b ^ 01010111b = 11001100b
-10011011b ^ 01011000b = 11000011b
-10011011b ^ 01011001b = 11000010b
-10011011b ^ 01011010b = 11000001b
-10011011b ^ 01011011b = 11000000b
-10011011b ^ 01011100b = 11000111b
-10011011b ^ 01011101b = 11000110b
-10011011b ^ 01011110b = 11000101b
-10011011b ^ 01011111b = 11000100b
-10011011b ^ 01100000b = 11111011b
-10011011b ^ 01100001b = 11111010b
-10011011b ^ 01100010b = 11111001b
-10011011b ^ 01100011b = 11111000b
-10011011b ^ 01100100b = 11111111b
-10011011b ^ 01100101b = 11111110b
-10011011b ^ 01100110b = 11111101b
-10011011b ^ 01100111b = 11111100b
-10011011b ^ 01101000b = 11110011b
-10011011b ^ 01101001b = 11110010b
-10011011b ^ 01101010b = 11110001b
-10011011b ^ 01101011b = 11110000b
-10011011b ^ 01101100b = 11110111b
-10011011b ^ 01101101b = 11110110b
-10011011b ^ 01101110b = 11110101b
-10011011b ^ 01101111b = 11110100b
-10011011b ^ 01110000b = 11101011b
-10011011b ^ 01110001b = 11101010b
-10011011b ^ 01110010b = 11101001b
-10011011b ^ 01110011b = 11101000b
-10011011b ^ 01110100b = 11101111b
-10011011b ^ 01110101b = 11101110b
-10011011b ^ 01110110b = 11101101b
-10011011b ^ 01110111b = 11101100b
-10011011b ^ 01111000b = 11100011b
-10011011b ^ 01111001b = 11100010b
-10011011b ^ 01111010b = 11100001b
-10011011b ^ 01111011b = 11100000b
-10011011b ^ 01111100b = 11100111b
-10011011b ^ 01111101b = 11100110b
-10011011b ^ 01111110b = 11100101b
-10011100b ^ 10000000b = 00011100b
-10011100b ^ 10000001b = 00011101b
-10011100b ^ 10000010b = 00011110b
-10011100b ^ 10000011b = 00011111b
-10011100b ^ 10000100b = 00011000b
-10011100b ^ 10000101b = 00011001b
-10011100b ^ 10000110b = 00011010b
-10011100b ^ 10000111b = 00011011b
-10011100b ^ 10001000b = 00010100b
-10011100b ^ 10001001b = 00010101b
-10011100b ^ 10001010b = 00010110b
-10011100b ^ 10001011b = 00010111b
-10011100b ^ 10001100b = 00010000b
-10011100b ^ 10001101b = 00010001b
-10011100b ^ 10001110b = 00010010b
-10011100b ^ 10001111b = 00010011b
-10011100b ^ 10010000b = 00001100b
-10011100b ^ 10010001b = 00001101b
-10011100b ^ 10010010b = 00001110b
-10011100b ^ 10010011b = 00001111b
-10011100b ^ 10010100b = 00001000b
-10011100b ^ 10010101b = 00001001b
-10011100b ^ 10010110b = 00001010b
-10011100b ^ 10010111b = 00001011b
-10011100b ^ 10011000b = 00000100b
-10011100b ^ 10011001b = 00000101b
-10011100b ^ 10011010b = 00000110b
-10011100b ^ 10011011b = 00000111b
-10011100b ^ 10011100b = 00000000b
-10011100b ^ 10011101b = 00000001b
-10011100b ^ 10011110b = 00000010b
-10011100b ^ 10011111b = 00000011b
-10011100b ^ 10100000b = 00111100b
-10011100b ^ 10100001b = 00111101b
-10011100b ^ 10100010b = 00111110b
-10011100b ^ 10100011b = 00111111b
-10011100b ^ 10100100b = 00111000b
-10011100b ^ 10100101b = 00111001b
-10011100b ^ 10100110b = 00111010b
-10011100b ^ 10100111b = 00111011b
-10011100b ^ 10101000b = 00110100b
-10011100b ^ 10101001b = 00110101b
-10011100b ^ 10101010b = 00110110b
-10011100b ^ 10101011b = 00110111b
-10011100b ^ 10101100b = 00110000b
-10011100b ^ 10101101b = 00110001b
-10011100b ^ 10101110b = 00110010b
-10011100b ^ 10101111b = 00110011b
-10011100b ^ 10110000b = 00101100b
-10011100b ^ 10110001b = 00101101b
-10011100b ^ 10110010b = 00101110b
-10011100b ^ 10110011b = 00101111b
-10011100b ^ 10110100b = 00101000b
-10011100b ^ 10110101b = 00101001b
-10011100b ^ 10110110b = 00101010b
-10011100b ^ 10110111b = 00101011b
-10011100b ^ 10111000b = 00100100b
-10011100b ^ 10111001b = 00100101b
-10011100b ^ 10111010b = 00100110b
-10011100b ^ 10111011b = 00100111b
-10011100b ^ 10111100b = 00100000b
-10011100b ^ 10111101b = 00100001b
-10011100b ^ 10111110b = 00100010b
-10011100b ^ 10111111b = 00100011b
-10011100b ^ 11000000b = 01011100b
-10011100b ^ 11000001b = 01011101b
-10011100b ^ 11000010b = 01011110b
-10011100b ^ 11000011b = 01011111b
-10011100b ^ 11000100b = 01011000b
-10011100b ^ 11000101b = 01011001b
-10011100b ^ 11000110b = 01011010b
-10011100b ^ 11000111b = 01011011b
-10011100b ^ 11001000b = 01010100b
-10011100b ^ 11001001b = 01010101b
-10011100b ^ 11001010b = 01010110b
-10011100b ^ 11001011b = 01010111b
-10011100b ^ 11001100b = 01010000b
-10011100b ^ 11001101b = 01010001b
-10011100b ^ 11001110b = 01010010b
-10011100b ^ 11001111b = 01010011b
-10011100b ^ 11010000b = 01001100b
-10011100b ^ 11010001b = 01001101b
-10011100b ^ 11010010b = 01001110b
-10011100b ^ 11010011b = 01001111b
-10011100b ^ 11010100b = 01001000b
-10011100b ^ 11010101b = 01001001b
-10011100b ^ 11010110b = 01001010b
-10011100b ^ 11010111b = 01001011b
-10011100b ^ 11011000b = 01000100b
-10011100b ^ 11011001b = 01000101b
-10011100b ^ 11011010b = 01000110b
-10011100b ^ 11011011b = 01000111b
-10011100b ^ 11011100b = 01000000b
-10011100b ^ 11011101b = 01000001b
-10011100b ^ 11011110b = 01000010b
-10011100b ^ 11011111b = 01000011b
-10011100b ^ 11100000b = 01111100b
-10011100b ^ 11100001b = 01111101b
-10011100b ^ 11100010b = 01111110b
-10011100b ^ 11100011b = 01111111b
-10011100b ^ 11100100b = 01111000b
-10011100b ^ 11100101b = 01111001b
-10011100b ^ 11100110b = 01111010b
-10011100b ^ 11100111b = 01111011b
-10011100b ^ 11101000b = 01110100b
-10011100b ^ 11101001b = 01110101b
-10011100b ^ 11101010b = 01110110b
-10011100b ^ 11101011b = 01110111b
-10011100b ^ 11101100b = 01110000b
-10011100b ^ 11101101b = 01110001b
-10011100b ^ 11101110b = 01110010b
-10011100b ^ 11101111b = 01110011b
-10011100b ^ 11110000b = 01101100b
-10011100b ^ 11110001b = 01101101b
-10011100b ^ 11110010b = 01101110b
-10011100b ^ 11110011b = 01101111b
-10011100b ^ 11110100b = 01101000b
-10011100b ^ 11110101b = 01101001b
-10011100b ^ 11110110b = 01101010b
-10011100b ^ 11110111b = 01101011b
-10011100b ^ 11111000b = 01100100b
-10011100b ^ 11111001b = 01100101b
-10011100b ^ 11111010b = 01100110b
-10011100b ^ 11111011b = 01100111b
-10011100b ^ 11111100b = 01100000b
-10011100b ^ 11111101b = 01100001b
-10011100b ^ 11111110b = 01100010b
-10011100b ^ 11111111b = 01100011b
-10011100b ^ 00000000b = 10011100b
-10011100b ^ 00000001b = 10011101b
-10011100b ^ 00000010b = 10011110b
-10011100b ^ 00000011b = 10011111b
-10011100b ^ 00000100b = 10011000b
-10011100b ^ 00000101b = 10011001b
-10011100b ^ 00000110b = 10011010b
-10011100b ^ 00000111b = 10011011b
-10011100b ^ 00001000b = 10010100b
-10011100b ^ 00001001b = 10010101b
-10011100b ^ 00001010b = 10010110b
-10011100b ^ 00001011b = 10010111b
-10011100b ^ 00001100b = 10010000b
-10011100b ^ 00001101b = 10010001b
-10011100b ^ 00001110b = 10010010b
-10011100b ^ 00001111b = 10010011b
-10011100b ^ 00010000b = 10001100b
-10011100b ^ 00010001b = 10001101b
-10011100b ^ 00010010b = 10001110b
-10011100b ^ 00010011b = 10001111b
-10011100b ^ 00010100b = 10001000b
-10011100b ^ 00010101b = 10001001b
-10011100b ^ 00010110b = 10001010b
-10011100b ^ 00010111b = 10001011b
-10011100b ^ 00011000b = 10000100b
-10011100b ^ 00011001b = 10000101b
-10011100b ^ 00011010b = 10000110b
-10011100b ^ 00011011b = 10000111b
-10011100b ^ 00011100b = 10000000b
-10011100b ^ 00011101b = 10000001b
-10011100b ^ 00011110b = 10000010b
-10011100b ^ 00011111b = 10000011b
-10011100b ^ 00100000b = 10111100b
-10011100b ^ 00100001b = 10111101b
-10011100b ^ 00100010b = 10111110b
-10011100b ^ 00100011b = 10111111b
-10011100b ^ 00100100b = 10111000b
-10011100b ^ 00100101b = 10111001b
-10011100b ^ 00100110b = 10111010b
-10011100b ^ 00100111b = 10111011b
-10011100b ^ 00101000b = 10110100b
-10011100b ^ 00101001b = 10110101b
-10011100b ^ 00101010b = 10110110b
-10011100b ^ 00101011b = 10110111b
-10011100b ^ 00101100b = 10110000b
-10011100b ^ 00101101b = 10110001b
-10011100b ^ 00101110b = 10110010b
-10011100b ^ 00101111b = 10110011b
-10011100b ^ 00110000b = 10101100b
-10011100b ^ 00110001b = 10101101b
-10011100b ^ 00110010b = 10101110b
-10011100b ^ 00110011b = 10101111b
-10011100b ^ 00110100b = 10101000b
-10011100b ^ 00110101b = 10101001b
-10011100b ^ 00110110b = 10101010b
-10011100b ^ 00110111b = 10101011b
-10011100b ^ 00111000b = 10100100b
-10011100b ^ 00111001b = 10100101b
-10011100b ^ 00111010b = 10100110b
-10011100b ^ 00111011b = 10100111b
-10011100b ^ 00111100b = 10100000b
-10011100b ^ 00111101b = 10100001b
-10011100b ^ 00111110b = 10100010b
-10011100b ^ 00111111b = 10100011b
-10011100b ^ 01000000b = 11011100b
-10011100b ^ 01000001b = 11011101b
-10011100b ^ 01000010b = 11011110b
-10011100b ^ 01000011b = 11011111b
-10011100b ^ 01000100b = 11011000b
-10011100b ^ 01000101b = 11011001b
-10011100b ^ 01000110b = 11011010b
-10011100b ^ 01000111b = 11011011b
-10011100b ^ 01001000b = 11010100b
-10011100b ^ 01001001b = 11010101b
-10011100b ^ 01001010b = 11010110b
-10011100b ^ 01001011b = 11010111b
-10011100b ^ 01001100b = 11010000b
-10011100b ^ 01001101b = 11010001b
-10011100b ^ 01001110b = 11010010b
-10011100b ^ 01001111b = 11010011b
-10011100b ^ 01010000b = 11001100b
-10011100b ^ 01010001b = 11001101b
-10011100b ^ 01010010b = 11001110b
-10011100b ^ 01010011b = 11001111b
-10011100b ^ 01010100b = 11001000b
-10011100b ^ 01010101b = 11001001b
-10011100b ^ 01010110b = 11001010b
-10011100b ^ 01010111b = 11001011b
-10011100b ^ 01011000b = 11000100b
-10011100b ^ 01011001b = 11000101b
-10011100b ^ 01011010b = 11000110b
-10011100b ^ 01011011b = 11000111b
-10011100b ^ 01011100b = 11000000b
-10011100b ^ 01011101b = 11000001b
-10011100b ^ 01011110b = 11000010b
-10011100b ^ 01011111b = 11000011b
-10011100b ^ 01100000b = 11111100b
-10011100b ^ 01100001b = 11111101b
-10011100b ^ 01100010b = 11111110b
-10011100b ^ 01100011b = 11111111b
-10011100b ^ 01100100b = 11111000b
-10011100b ^ 01100101b = 11111001b
-10011100b ^ 01100110b = 11111010b
-10011100b ^ 01100111b = 11111011b
-10011100b ^ 01101000b = 11110100b
-10011100b ^ 01101001b = 11110101b
-10011100b ^ 01101010b = 11110110b
-10011100b ^ 01101011b = 11110111b
-10011100b ^ 01101100b = 11110000b
-10011100b ^ 01101101b = 11110001b
-10011100b ^ 01101110b = 11110010b
-10011100b ^ 01101111b = 11110011b
-10011100b ^ 01110000b = 11101100b
-10011100b ^ 01110001b = 11101101b
-10011100b ^ 01110010b = 11101110b
-10011100b ^ 01110011b = 11101111b
-10011100b ^ 01110100b = 11101000b
-10011100b ^ 01110101b = 11101001b
-10011100b ^ 01110110b = 11101010b
-10011100b ^ 01110111b = 11101011b
-10011100b ^ 01111000b = 11100100b
-10011100b ^ 01111001b = 11100101b
-10011100b ^ 01111010b = 11100110b
-10011100b ^ 01111011b = 11100111b
-10011100b ^ 01111100b = 11100000b
-10011100b ^ 01111101b = 11100001b
-10011100b ^ 01111110b = 11100010b
-10011101b ^ 10000000b = 00011101b
-10011101b ^ 10000001b = 00011100b
-10011101b ^ 10000010b = 00011111b
-10011101b ^ 10000011b = 00011110b
-10011101b ^ 10000100b = 00011001b
-10011101b ^ 10000101b = 00011000b
-10011101b ^ 10000110b = 00011011b
-10011101b ^ 10000111b = 00011010b
-10011101b ^ 10001000b = 00010101b
-10011101b ^ 10001001b = 00010100b
-10011101b ^ 10001010b = 00010111b
-10011101b ^ 10001011b = 00010110b
-10011101b ^ 10001100b = 00010001b
-10011101b ^ 10001101b = 00010000b
-10011101b ^ 10001110b = 00010011b
-10011101b ^ 10001111b = 00010010b
-10011101b ^ 10010000b = 00001101b
-10011101b ^ 10010001b = 00001100b
-10011101b ^ 10010010b = 00001111b
-10011101b ^ 10010011b = 00001110b
-10011101b ^ 10010100b = 00001001b
-10011101b ^ 10010101b = 00001000b
-10011101b ^ 10010110b = 00001011b
-10011101b ^ 10010111b = 00001010b
-10011101b ^ 10011000b = 00000101b
-10011101b ^ 10011001b = 00000100b
-10011101b ^ 10011010b = 00000111b
-10011101b ^ 10011011b = 00000110b
-10011101b ^ 10011100b = 00000001b
-10011101b ^ 10011101b = 00000000b
-10011101b ^ 10011110b = 00000011b
-10011101b ^ 10011111b = 00000010b
-10011101b ^ 10100000b = 00111101b
-10011101b ^ 10100001b = 00111100b
-10011101b ^ 10100010b = 00111111b
-10011101b ^ 10100011b = 00111110b
-10011101b ^ 10100100b = 00111001b
-10011101b ^ 10100101b = 00111000b
-10011101b ^ 10100110b = 00111011b
-10011101b ^ 10100111b = 00111010b
-10011101b ^ 10101000b = 00110101b
-10011101b ^ 10101001b = 00110100b
-10011101b ^ 10101010b = 00110111b
-10011101b ^ 10101011b = 00110110b
-10011101b ^ 10101100b = 00110001b
-10011101b ^ 10101101b = 00110000b
-10011101b ^ 10101110b = 00110011b
-10011101b ^ 10101111b = 00110010b
-10011101b ^ 10110000b = 00101101b
-10011101b ^ 10110001b = 00101100b
-10011101b ^ 10110010b = 00101111b
-10011101b ^ 10110011b = 00101110b
-10011101b ^ 10110100b = 00101001b
-10011101b ^ 10110101b = 00101000b
-10011101b ^ 10110110b = 00101011b
-10011101b ^ 10110111b = 00101010b
-10011101b ^ 10111000b = 00100101b
-10011101b ^ 10111001b = 00100100b
-10011101b ^ 10111010b = 00100111b
-10011101b ^ 10111011b = 00100110b
-10011101b ^ 10111100b = 00100001b
-10011101b ^ 10111101b = 00100000b
-10011101b ^ 10111110b = 00100011b
-10011101b ^ 10111111b = 00100010b
-10011101b ^ 11000000b = 01011101b
-10011101b ^ 11000001b = 01011100b
-10011101b ^ 11000010b = 01011111b
-10011101b ^ 11000011b = 01011110b
-10011101b ^ 11000100b = 01011001b
-10011101b ^ 11000101b = 01011000b
-10011101b ^ 11000110b = 01011011b
-10011101b ^ 11000111b = 01011010b
-10011101b ^ 11001000b = 01010101b
-10011101b ^ 11001001b = 01010100b
-10011101b ^ 11001010b = 01010111b
-10011101b ^ 11001011b = 01010110b
-10011101b ^ 11001100b = 01010001b
-10011101b ^ 11001101b = 01010000b
-10011101b ^ 11001110b = 01010011b
-10011101b ^ 11001111b = 01010010b
-10011101b ^ 11010000b = 01001101b
-10011101b ^ 11010001b = 01001100b
-10011101b ^ 11010010b = 01001111b
-10011101b ^ 11010011b = 01001110b
-10011101b ^ 11010100b = 01001001b
-10011101b ^ 11010101b = 01001000b
-10011101b ^ 11010110b = 01001011b
-10011101b ^ 11010111b = 01001010b
-10011101b ^ 11011000b = 01000101b
-10011101b ^ 11011001b = 01000100b
-10011101b ^ 11011010b = 01000111b
-10011101b ^ 11011011b = 01000110b
-10011101b ^ 11011100b = 01000001b
-10011101b ^ 11011101b = 01000000b
-10011101b ^ 11011110b = 01000011b
-10011101b ^ 11011111b = 01000010b
-10011101b ^ 11100000b = 01111101b
-10011101b ^ 11100001b = 01111100b
-10011101b ^ 11100010b = 01111111b
-10011101b ^ 11100011b = 01111110b
-10011101b ^ 11100100b = 01111001b
-10011101b ^ 11100101b = 01111000b
-10011101b ^ 11100110b = 01111011b
-10011101b ^ 11100111b = 01111010b
-10011101b ^ 11101000b = 01110101b
-10011101b ^ 11101001b = 01110100b
-10011101b ^ 11101010b = 01110111b
-10011101b ^ 11101011b = 01110110b
-10011101b ^ 11101100b = 01110001b
-10011101b ^ 11101101b = 01110000b
-10011101b ^ 11101110b = 01110011b
-10011101b ^ 11101111b = 01110010b
-10011101b ^ 11110000b = 01101101b
-10011101b ^ 11110001b = 01101100b
-10011101b ^ 11110010b = 01101111b
-10011101b ^ 11110011b = 01101110b
-10011101b ^ 11110100b = 01101001b
-10011101b ^ 11110101b = 01101000b
-10011101b ^ 11110110b = 01101011b
-10011101b ^ 11110111b = 01101010b
-10011101b ^ 11111000b = 01100101b
-10011101b ^ 11111001b = 01100100b
-10011101b ^ 11111010b = 01100111b
-10011101b ^ 11111011b = 01100110b
-10011101b ^ 11111100b = 01100001b
-10011101b ^ 11111101b = 01100000b
-10011101b ^ 11111110b = 01100011b
-10011101b ^ 11111111b = 01100010b
-10011101b ^ 00000000b = 10011101b
-10011101b ^ 00000001b = 10011100b
-10011101b ^ 00000010b = 10011111b
-10011101b ^ 00000011b = 10011110b
-10011101b ^ 00000100b = 10011001b
-10011101b ^ 00000101b = 10011000b
-10011101b ^ 00000110b = 10011011b
-10011101b ^ 00000111b = 10011010b
-10011101b ^ 00001000b = 10010101b
-10011101b ^ 00001001b = 10010100b
-10011101b ^ 00001010b = 10010111b
-10011101b ^ 00001011b = 10010110b
-10011101b ^ 00001100b = 10010001b
-10011101b ^ 00001101b = 10010000b
-10011101b ^ 00001110b = 10010011b
-10011101b ^ 00001111b = 10010010b
-10011101b ^ 00010000b = 10001101b
-10011101b ^ 00010001b = 10001100b
-10011101b ^ 00010010b = 10001111b
-10011101b ^ 00010011b = 10001110b
-10011101b ^ 00010100b = 10001001b
-10011101b ^ 00010101b = 10001000b
-10011101b ^ 00010110b = 10001011b
-10011101b ^ 00010111b = 10001010b
-10011101b ^ 00011000b = 10000101b
-10011101b ^ 00011001b = 10000100b
-10011101b ^ 00011010b = 10000111b
-10011101b ^ 00011011b = 10000110b
-10011101b ^ 00011100b = 10000001b
-10011101b ^ 00011101b = 10000000b
-10011101b ^ 00011110b = 10000011b
-10011101b ^ 00011111b = 10000010b
-10011101b ^ 00100000b = 10111101b
-10011101b ^ 00100001b = 10111100b
-10011101b ^ 00100010b = 10111111b
-10011101b ^ 00100011b = 10111110b
-10011101b ^ 00100100b = 10111001b
-10011101b ^ 00100101b = 10111000b
-10011101b ^ 00100110b = 10111011b
-10011101b ^ 00100111b = 10111010b
-10011101b ^ 00101000b = 10110101b
-10011101b ^ 00101001b = 10110100b
-10011101b ^ 00101010b = 10110111b
-10011101b ^ 00101011b = 10110110b
-10011101b ^ 00101100b = 10110001b
-10011101b ^ 00101101b = 10110000b
-10011101b ^ 00101110b = 10110011b
-10011101b ^ 00101111b = 10110010b
-10011101b ^ 00110000b = 10101101b
-10011101b ^ 00110001b = 10101100b
-10011101b ^ 00110010b = 10101111b
-10011101b ^ 00110011b = 10101110b
-10011101b ^ 00110100b = 10101001b
-10011101b ^ 00110101b = 10101000b
-10011101b ^ 00110110b = 10101011b
-10011101b ^ 00110111b = 10101010b
-10011101b ^ 00111000b = 10100101b
-10011101b ^ 00111001b = 10100100b
-10011101b ^ 00111010b = 10100111b
-10011101b ^ 00111011b = 10100110b
-10011101b ^ 00111100b = 10100001b
-10011101b ^ 00111101b = 10100000b
-10011101b ^ 00111110b = 10100011b
-10011101b ^ 00111111b = 10100010b
-10011101b ^ 01000000b = 11011101b
-10011101b ^ 01000001b = 11011100b
-10011101b ^ 01000010b = 11011111b
-10011101b ^ 01000011b = 11011110b
-10011101b ^ 01000100b = 11011001b
-10011101b ^ 01000101b = 11011000b
-10011101b ^ 01000110b = 11011011b
-10011101b ^ 01000111b = 11011010b
-10011101b ^ 01001000b = 11010101b
-10011101b ^ 01001001b = 11010100b
-10011101b ^ 01001010b = 11010111b
-10011101b ^ 01001011b = 11010110b
-10011101b ^ 01001100b = 11010001b
-10011101b ^ 01001101b = 11010000b
-10011101b ^ 01001110b = 11010011b
-10011101b ^ 01001111b = 11010010b
-10011101b ^ 01010000b = 11001101b
-10011101b ^ 01010001b = 11001100b
-10011101b ^ 01010010b = 11001111b
-10011101b ^ 01010011b = 11001110b
-10011101b ^ 01010100b = 11001001b
-10011101b ^ 01010101b = 11001000b
-10011101b ^ 01010110b = 11001011b
-10011101b ^ 01010111b = 11001010b
-10011101b ^ 01011000b = 11000101b
-10011101b ^ 01011001b = 11000100b
-10011101b ^ 01011010b = 11000111b
-10011101b ^ 01011011b = 11000110b
-10011101b ^ 01011100b = 11000001b
-10011101b ^ 01011101b = 11000000b
-10011101b ^ 01011110b = 11000011b
-10011101b ^ 01011111b = 11000010b
-10011101b ^ 01100000b = 11111101b
-10011101b ^ 01100001b = 11111100b
-10011101b ^ 01100010b = 11111111b
-10011101b ^ 01100011b = 11111110b
-10011101b ^ 01100100b = 11111001b
-10011101b ^ 01100101b = 11111000b
-10011101b ^ 01100110b = 11111011b
-10011101b ^ 01100111b = 11111010b
-10011101b ^ 01101000b = 11110101b
-10011101b ^ 01101001b = 11110100b
-10011101b ^ 01101010b = 11110111b
-10011101b ^ 01101011b = 11110110b
-10011101b ^ 01101100b = 11110001b
-10011101b ^ 01101101b = 11110000b
-10011101b ^ 01101110b = 11110011b
-10011101b ^ 01101111b = 11110010b
-10011101b ^ 01110000b = 11101101b
-10011101b ^ 01110001b = 11101100b
-10011101b ^ 01110010b = 11101111b
-10011101b ^ 01110011b = 11101110b
-10011101b ^ 01110100b = 11101001b
-10011101b ^ 01110101b = 11101000b
-10011101b ^ 01110110b = 11101011b
-10011101b ^ 01110111b = 11101010b
-10011101b ^ 01111000b = 11100101b
-10011101b ^ 01111001b = 11100100b
-10011101b ^ 01111010b = 11100111b
-10011101b ^ 01111011b = 11100110b
-10011101b ^ 01111100b = 11100001b
-10011101b ^ 01111101b = 11100000b
-10011101b ^ 01111110b = 11100011b
-10011110b ^ 10000000b = 00011110b
-10011110b ^ 10000001b = 00011111b
-10011110b ^ 10000010b = 00011100b
-10011110b ^ 10000011b = 00011101b
-10011110b ^ 10000100b = 00011010b
-10011110b ^ 10000101b = 00011011b
-10011110b ^ 10000110b = 00011000b
-10011110b ^ 10000111b = 00011001b
-10011110b ^ 10001000b = 00010110b
-10011110b ^ 10001001b = 00010111b
-10011110b ^ 10001010b = 00010100b
-10011110b ^ 10001011b = 00010101b
-10011110b ^ 10001100b = 00010010b
-10011110b ^ 10001101b = 00010011b
-10011110b ^ 10001110b = 00010000b
-10011110b ^ 10001111b = 00010001b
-10011110b ^ 10010000b = 00001110b
-10011110b ^ 10010001b = 00001111b
-10011110b ^ 10010010b = 00001100b
-10011110b ^ 10010011b = 00001101b
-10011110b ^ 10010100b = 00001010b
-10011110b ^ 10010101b = 00001011b
-10011110b ^ 10010110b = 00001000b
-10011110b ^ 10010111b = 00001001b
-10011110b ^ 10011000b = 00000110b
-10011110b ^ 10011001b = 00000111b
-10011110b ^ 10011010b = 00000100b
-10011110b ^ 10011011b = 00000101b
-10011110b ^ 10011100b = 00000010b
-10011110b ^ 10011101b = 00000011b
-10011110b ^ 10011110b = 00000000b
-10011110b ^ 10011111b = 00000001b
-10011110b ^ 10100000b = 00111110b
-10011110b ^ 10100001b = 00111111b
-10011110b ^ 10100010b = 00111100b
-10011110b ^ 10100011b = 00111101b
-10011110b ^ 10100100b = 00111010b
-10011110b ^ 10100101b = 00111011b
-10011110b ^ 10100110b = 00111000b
-10011110b ^ 10100111b = 00111001b
-10011110b ^ 10101000b = 00110110b
-10011110b ^ 10101001b = 00110111b
-10011110b ^ 10101010b = 00110100b
-10011110b ^ 10101011b = 00110101b
-10011110b ^ 10101100b = 00110010b
-10011110b ^ 10101101b = 00110011b
-10011110b ^ 10101110b = 00110000b
-10011110b ^ 10101111b = 00110001b
-10011110b ^ 10110000b = 00101110b
-10011110b ^ 10110001b = 00101111b
-10011110b ^ 10110010b = 00101100b
-10011110b ^ 10110011b = 00101101b
-10011110b ^ 10110100b = 00101010b
-10011110b ^ 10110101b = 00101011b
-10011110b ^ 10110110b = 00101000b
-10011110b ^ 10110111b = 00101001b
-10011110b ^ 10111000b = 00100110b
-10011110b ^ 10111001b = 00100111b
-10011110b ^ 10111010b = 00100100b
-10011110b ^ 10111011b = 00100101b
-10011110b ^ 10111100b = 00100010b
-10011110b ^ 10111101b = 00100011b
-10011110b ^ 10111110b = 00100000b
-10011110b ^ 10111111b = 00100001b
-10011110b ^ 11000000b = 01011110b
-10011110b ^ 11000001b = 01011111b
-10011110b ^ 11000010b = 01011100b
-10011110b ^ 11000011b = 01011101b
-10011110b ^ 11000100b = 01011010b
-10011110b ^ 11000101b = 01011011b
-10011110b ^ 11000110b = 01011000b
-10011110b ^ 11000111b = 01011001b
-10011110b ^ 11001000b = 01010110b
-10011110b ^ 11001001b = 01010111b
-10011110b ^ 11001010b = 01010100b
-10011110b ^ 11001011b = 01010101b
-10011110b ^ 11001100b = 01010010b
-10011110b ^ 11001101b = 01010011b
-10011110b ^ 11001110b = 01010000b
-10011110b ^ 11001111b = 01010001b
-10011110b ^ 11010000b = 01001110b
-10011110b ^ 11010001b = 01001111b
-10011110b ^ 11010010b = 01001100b
-10011110b ^ 11010011b = 01001101b
-10011110b ^ 11010100b = 01001010b
-10011110b ^ 11010101b = 01001011b
-10011110b ^ 11010110b = 01001000b
-10011110b ^ 11010111b = 01001001b
-10011110b ^ 11011000b = 01000110b
-10011110b ^ 11011001b = 01000111b
-10011110b ^ 11011010b = 01000100b
-10011110b ^ 11011011b = 01000101b
-10011110b ^ 11011100b = 01000010b
-10011110b ^ 11011101b = 01000011b
-10011110b ^ 11011110b = 01000000b
-10011110b ^ 11011111b = 01000001b
-10011110b ^ 11100000b = 01111110b
-10011110b ^ 11100001b = 01111111b
-10011110b ^ 11100010b = 01111100b
-10011110b ^ 11100011b = 01111101b
-10011110b ^ 11100100b = 01111010b
-10011110b ^ 11100101b = 01111011b
-10011110b ^ 11100110b = 01111000b
-10011110b ^ 11100111b = 01111001b
-10011110b ^ 11101000b = 01110110b
-10011110b ^ 11101001b = 01110111b
-10011110b ^ 11101010b = 01110100b
-10011110b ^ 11101011b = 01110101b
-10011110b ^ 11101100b = 01110010b
-10011110b ^ 11101101b = 01110011b
-10011110b ^ 11101110b = 01110000b
-10011110b ^ 11101111b = 01110001b
-10011110b ^ 11110000b = 01101110b
-10011110b ^ 11110001b = 01101111b
-10011110b ^ 11110010b = 01101100b
-10011110b ^ 11110011b = 01101101b
-10011110b ^ 11110100b = 01101010b
-10011110b ^ 11110101b = 01101011b
-10011110b ^ 11110110b = 01101000b
-10011110b ^ 11110111b = 01101001b
-10011110b ^ 11111000b = 01100110b
-10011110b ^ 11111001b = 01100111b
-10011110b ^ 11111010b = 01100100b
-10011110b ^ 11111011b = 01100101b
-10011110b ^ 11111100b = 01100010b
-10011110b ^ 11111101b = 01100011b
-10011110b ^ 11111110b = 01100000b
-10011110b ^ 11111111b = 01100001b
-10011110b ^ 00000000b = 10011110b
-10011110b ^ 00000001b = 10011111b
-10011110b ^ 00000010b = 10011100b
-10011110b ^ 00000011b = 10011101b
-10011110b ^ 00000100b = 10011010b
-10011110b ^ 00000101b = 10011011b
-10011110b ^ 00000110b = 10011000b
-10011110b ^ 00000111b = 10011001b
-10011110b ^ 00001000b = 10010110b
-10011110b ^ 00001001b = 10010111b
-10011110b ^ 00001010b = 10010100b
-10011110b ^ 00001011b = 10010101b
-10011110b ^ 00001100b = 10010010b
-10011110b ^ 00001101b = 10010011b
-10011110b ^ 00001110b = 10010000b
-10011110b ^ 00001111b = 10010001b
-10011110b ^ 00010000b = 10001110b
-10011110b ^ 00010001b = 10001111b
-10011110b ^ 00010010b = 10001100b
-10011110b ^ 00010011b = 10001101b
-10011110b ^ 00010100b = 10001010b
-10011110b ^ 00010101b = 10001011b
-10011110b ^ 00010110b = 10001000b
-10011110b ^ 00010111b = 10001001b
-10011110b ^ 00011000b = 10000110b
-10011110b ^ 00011001b = 10000111b
-10011110b ^ 00011010b = 10000100b
-10011110b ^ 00011011b = 10000101b
-10011110b ^ 00011100b = 10000010b
-10011110b ^ 00011101b = 10000011b
-10011110b ^ 00011110b = 10000000b
-10011110b ^ 00011111b = 10000001b
-10011110b ^ 00100000b = 10111110b
-10011110b ^ 00100001b = 10111111b
-10011110b ^ 00100010b = 10111100b
-10011110b ^ 00100011b = 10111101b
-10011110b ^ 00100100b = 10111010b
-10011110b ^ 00100101b = 10111011b
-10011110b ^ 00100110b = 10111000b
-10011110b ^ 00100111b = 10111001b
-10011110b ^ 00101000b = 10110110b
-10011110b ^ 00101001b = 10110111b
-10011110b ^ 00101010b = 10110100b
-10011110b ^ 00101011b = 10110101b
-10011110b ^ 00101100b = 10110010b
-10011110b ^ 00101101b = 10110011b
-10011110b ^ 00101110b = 10110000b
-10011110b ^ 00101111b = 10110001b
-10011110b ^ 00110000b = 10101110b
-10011110b ^ 00110001b = 10101111b
-10011110b ^ 00110010b = 10101100b
-10011110b ^ 00110011b = 10101101b
-10011110b ^ 00110100b = 10101010b
-10011110b ^ 00110101b = 10101011b
-10011110b ^ 00110110b = 10101000b
-10011110b ^ 00110111b = 10101001b
-10011110b ^ 00111000b = 10100110b
-10011110b ^ 00111001b = 10100111b
-10011110b ^ 00111010b = 10100100b
-10011110b ^ 00111011b = 10100101b
-10011110b ^ 00111100b = 10100010b
-10011110b ^ 00111101b = 10100011b
-10011110b ^ 00111110b = 10100000b
-10011110b ^ 00111111b = 10100001b
-10011110b ^ 01000000b = 11011110b
-10011110b ^ 01000001b = 11011111b
-10011110b ^ 01000010b = 11011100b
-10011110b ^ 01000011b = 11011101b
-10011110b ^ 01000100b = 11011010b
-10011110b ^ 01000101b = 11011011b
-10011110b ^ 01000110b = 11011000b
-10011110b ^ 01000111b = 11011001b
-10011110b ^ 01001000b = 11010110b
-10011110b ^ 01001001b = 11010111b
-10011110b ^ 01001010b = 11010100b
-10011110b ^ 01001011b = 11010101b
-10011110b ^ 01001100b = 11010010b
-10011110b ^ 01001101b = 11010011b
-10011110b ^ 01001110b = 11010000b
-10011110b ^ 01001111b = 11010001b
-10011110b ^ 01010000b = 11001110b
-10011110b ^ 01010001b = 11001111b
-10011110b ^ 01010010b = 11001100b
-10011110b ^ 01010011b = 11001101b
-10011110b ^ 01010100b = 11001010b
-10011110b ^ 01010101b = 11001011b
-10011110b ^ 01010110b = 11001000b
-10011110b ^ 01010111b = 11001001b
-10011110b ^ 01011000b = 11000110b
-10011110b ^ 01011001b = 11000111b
-10011110b ^ 01011010b = 11000100b
-10011110b ^ 01011011b = 11000101b
-10011110b ^ 01011100b = 11000010b
-10011110b ^ 01011101b = 11000011b
-10011110b ^ 01011110b = 11000000b
-10011110b ^ 01011111b = 11000001b
-10011110b ^ 01100000b = 11111110b
-10011110b ^ 01100001b = 11111111b
-10011110b ^ 01100010b = 11111100b
-10011110b ^ 01100011b = 11111101b
-10011110b ^ 01100100b = 11111010b
-10011110b ^ 01100101b = 11111011b
-10011110b ^ 01100110b = 11111000b
-10011110b ^ 01100111b = 11111001b
-10011110b ^ 01101000b = 11110110b
-10011110b ^ 01101001b = 11110111b
-10011110b ^ 01101010b = 11110100b
-10011110b ^ 01101011b = 11110101b
-10011110b ^ 01101100b = 11110010b
-10011110b ^ 01101101b = 11110011b
-10011110b ^ 01101110b = 11110000b
-10011110b ^ 01101111b = 11110001b
-10011110b ^ 01110000b = 11101110b
-10011110b ^ 01110001b = 11101111b
-10011110b ^ 01110010b = 11101100b
-10011110b ^ 01110011b = 11101101b
-10011110b ^ 01110100b = 11101010b
-10011110b ^ 01110101b = 11101011b
-10011110b ^ 01110110b = 11101000b
-10011110b ^ 01110111b = 11101001b
-10011110b ^ 01111000b = 11100110b
-10011110b ^ 01111001b = 11100111b
-10011110b ^ 01111010b = 11100100b
-10011110b ^ 01111011b = 11100101b
-10011110b ^ 01111100b = 11100010b
-10011110b ^ 01111101b = 11100011b
-10011110b ^ 01111110b = 11100000b
-10011111b ^ 10000000b = 00011111b
-10011111b ^ 10000001b = 00011110b
-10011111b ^ 10000010b = 00011101b
-10011111b ^ 10000011b = 00011100b
-10011111b ^ 10000100b = 00011011b
-10011111b ^ 10000101b = 00011010b
-10011111b ^ 10000110b = 00011001b
-10011111b ^ 10000111b = 00011000b
-10011111b ^ 10001000b = 00010111b
-10011111b ^ 10001001b = 00010110b
-10011111b ^ 10001010b = 00010101b
-10011111b ^ 10001011b = 00010100b
-10011111b ^ 10001100b = 00010011b
-10011111b ^ 10001101b = 00010010b
-10011111b ^ 10001110b = 00010001b
-10011111b ^ 10001111b = 00010000b
-10011111b ^ 10010000b = 00001111b
-10011111b ^ 10010001b = 00001110b
-10011111b ^ 10010010b = 00001101b
-10011111b ^ 10010011b = 00001100b
-10011111b ^ 10010100b = 00001011b
-10011111b ^ 10010101b = 00001010b
-10011111b ^ 10010110b = 00001001b
-10011111b ^ 10010111b = 00001000b
-10011111b ^ 10011000b = 00000111b
-10011111b ^ 10011001b = 00000110b
-10011111b ^ 10011010b = 00000101b
-10011111b ^ 10011011b = 00000100b
-10011111b ^ 10011100b = 00000011b
-10011111b ^ 10011101b = 00000010b
-10011111b ^ 10011110b = 00000001b
-10011111b ^ 10011111b = 00000000b
-10011111b ^ 10100000b = 00111111b
-10011111b ^ 10100001b = 00111110b
-10011111b ^ 10100010b = 00111101b
-10011111b ^ 10100011b = 00111100b
-10011111b ^ 10100100b = 00111011b
-10011111b ^ 10100101b = 00111010b
-10011111b ^ 10100110b = 00111001b
-10011111b ^ 10100111b = 00111000b
-10011111b ^ 10101000b = 00110111b
-10011111b ^ 10101001b = 00110110b
-10011111b ^ 10101010b = 00110101b
-10011111b ^ 10101011b = 00110100b
-10011111b ^ 10101100b = 00110011b
-10011111b ^ 10101101b = 00110010b
-10011111b ^ 10101110b = 00110001b
-10011111b ^ 10101111b = 00110000b
-10011111b ^ 10110000b = 00101111b
-10011111b ^ 10110001b = 00101110b
-10011111b ^ 10110010b = 00101101b
-10011111b ^ 10110011b = 00101100b
-10011111b ^ 10110100b = 00101011b
-10011111b ^ 10110101b = 00101010b
-10011111b ^ 10110110b = 00101001b
-10011111b ^ 10110111b = 00101000b
-10011111b ^ 10111000b = 00100111b
-10011111b ^ 10111001b = 00100110b
-10011111b ^ 10111010b = 00100101b
-10011111b ^ 10111011b = 00100100b
-10011111b ^ 10111100b = 00100011b
-10011111b ^ 10111101b = 00100010b
-10011111b ^ 10111110b = 00100001b
-10011111b ^ 10111111b = 00100000b
-10011111b ^ 11000000b = 01011111b
-10011111b ^ 11000001b = 01011110b
-10011111b ^ 11000010b = 01011101b
-10011111b ^ 11000011b = 01011100b
-10011111b ^ 11000100b = 01011011b
-10011111b ^ 11000101b = 01011010b
-10011111b ^ 11000110b = 01011001b
-10011111b ^ 11000111b = 01011000b
-10011111b ^ 11001000b = 01010111b
-10011111b ^ 11001001b = 01010110b
-10011111b ^ 11001010b = 01010101b
-10011111b ^ 11001011b = 01010100b
-10011111b ^ 11001100b = 01010011b
-10011111b ^ 11001101b = 01010010b
-10011111b ^ 11001110b = 01010001b
-10011111b ^ 11001111b = 01010000b
-10011111b ^ 11010000b = 01001111b
-10011111b ^ 11010001b = 01001110b
-10011111b ^ 11010010b = 01001101b
-10011111b ^ 11010011b = 01001100b
-10011111b ^ 11010100b = 01001011b
-10011111b ^ 11010101b = 01001010b
-10011111b ^ 11010110b = 01001001b
-10011111b ^ 11010111b = 01001000b
-10011111b ^ 11011000b = 01000111b
-10011111b ^ 11011001b = 01000110b
-10011111b ^ 11011010b = 01000101b
-10011111b ^ 11011011b = 01000100b
-10011111b ^ 11011100b = 01000011b
-10011111b ^ 11011101b = 01000010b
-10011111b ^ 11011110b = 01000001b
-10011111b ^ 11011111b = 01000000b
-10011111b ^ 11100000b = 01111111b
-10011111b ^ 11100001b = 01111110b
-10011111b ^ 11100010b = 01111101b
-10011111b ^ 11100011b = 01111100b
-10011111b ^ 11100100b = 01111011b
-10011111b ^ 11100101b = 01111010b
-10011111b ^ 11100110b = 01111001b
-10011111b ^ 11100111b = 01111000b
-10011111b ^ 11101000b = 01110111b
-10011111b ^ 11101001b = 01110110b
-10011111b ^ 11101010b = 01110101b
-10011111b ^ 11101011b = 01110100b
-10011111b ^ 11101100b = 01110011b
-10011111b ^ 11101101b = 01110010b
-10011111b ^ 11101110b = 01110001b
-10011111b ^ 11101111b = 01110000b
-10011111b ^ 11110000b = 01101111b
-10011111b ^ 11110001b = 01101110b
-10011111b ^ 11110010b = 01101101b
-10011111b ^ 11110011b = 01101100b
-10011111b ^ 11110100b = 01101011b
-10011111b ^ 11110101b = 01101010b
-10011111b ^ 11110110b = 01101001b
-10011111b ^ 11110111b = 01101000b
-10011111b ^ 11111000b = 01100111b
-10011111b ^ 11111001b = 01100110b
-10011111b ^ 11111010b = 01100101b
-10011111b ^ 11111011b = 01100100b
-10011111b ^ 11111100b = 01100011b
-10011111b ^ 11111101b = 01100010b
-10011111b ^ 11111110b = 01100001b
-10011111b ^ 11111111b = 01100000b
-10011111b ^ 00000000b = 10011111b
-10011111b ^ 00000001b = 10011110b
-10011111b ^ 00000010b = 10011101b
-10011111b ^ 00000011b = 10011100b
-10011111b ^ 00000100b = 10011011b
-10011111b ^ 00000101b = 10011010b
-10011111b ^ 00000110b = 10011001b
-10011111b ^ 00000111b = 10011000b
-10011111b ^ 00001000b = 10010111b
-10011111b ^ 00001001b = 10010110b
-10011111b ^ 00001010b = 10010101b
-10011111b ^ 00001011b = 10010100b
-10011111b ^ 00001100b = 10010011b
-10011111b ^ 00001101b = 10010010b
-10011111b ^ 00001110b = 10010001b
-10011111b ^ 00001111b = 10010000b
-10011111b ^ 00010000b = 10001111b
-10011111b ^ 00010001b = 10001110b
-10011111b ^ 00010010b = 10001101b
-10011111b ^ 00010011b = 10001100b
-10011111b ^ 00010100b = 10001011b
-10011111b ^ 00010101b = 10001010b
-10011111b ^ 00010110b = 10001001b
-10011111b ^ 00010111b = 10001000b
-10011111b ^ 00011000b = 10000111b
-10011111b ^ 00011001b = 10000110b
-10011111b ^ 00011010b = 10000101b
-10011111b ^ 00011011b = 10000100b
-10011111b ^ 00011100b = 10000011b
-10011111b ^ 00011101b = 10000010b
-10011111b ^ 00011110b = 10000001b
-10011111b ^ 00011111b = 10000000b
-10011111b ^ 00100000b = 10111111b
-10011111b ^ 00100001b = 10111110b
-10011111b ^ 00100010b = 10111101b
-10011111b ^ 00100011b = 10111100b
-10011111b ^ 00100100b = 10111011b
-10011111b ^ 00100101b = 10111010b
-10011111b ^ 00100110b = 10111001b
-10011111b ^ 00100111b = 10111000b
-10011111b ^ 00101000b = 10110111b
-10011111b ^ 00101001b = 10110110b
-10011111b ^ 00101010b = 10110101b
-10011111b ^ 00101011b = 10110100b
-10011111b ^ 00101100b = 10110011b
-10011111b ^ 00101101b = 10110010b
-10011111b ^ 00101110b = 10110001b
-10011111b ^ 00101111b = 10110000b
-10011111b ^ 00110000b = 10101111b
-10011111b ^ 00110001b = 10101110b
-10011111b ^ 00110010b = 10101101b
-10011111b ^ 00110011b = 10101100b
-10011111b ^ 00110100b = 10101011b
-10011111b ^ 00110101b = 10101010b
-10011111b ^ 00110110b = 10101001b
-10011111b ^ 00110111b = 10101000b
-10011111b ^ 00111000b = 10100111b
-10011111b ^ 00111001b = 10100110b
-10011111b ^ 00111010b = 10100101b
-10011111b ^ 00111011b = 10100100b
-10011111b ^ 00111100b = 10100011b
-10011111b ^ 00111101b = 10100010b
-10011111b ^ 00111110b = 10100001b
-10011111b ^ 00111111b = 10100000b
-10011111b ^ 01000000b = 11011111b
-10011111b ^ 01000001b = 11011110b
-10011111b ^ 01000010b = 11011101b
-10011111b ^ 01000011b = 11011100b
-10011111b ^ 01000100b = 11011011b
-10011111b ^ 01000101b = 11011010b
-10011111b ^ 01000110b = 11011001b
-10011111b ^ 01000111b = 11011000b
-10011111b ^ 01001000b = 11010111b
-10011111b ^ 01001001b = 11010110b
-10011111b ^ 01001010b = 11010101b
-10011111b ^ 01001011b = 11010100b
-10011111b ^ 01001100b = 11010011b
-10011111b ^ 01001101b = 11010010b
-10011111b ^ 01001110b = 11010001b
-10011111b ^ 01001111b = 11010000b
-10011111b ^ 01010000b = 11001111b
-10011111b ^ 01010001b = 11001110b
-10011111b ^ 01010010b = 11001101b
-10011111b ^ 01010011b = 11001100b
-10011111b ^ 01010100b = 11001011b
-10011111b ^ 01010101b = 11001010b
-10011111b ^ 01010110b = 11001001b
-10011111b ^ 01010111b = 11001000b
-10011111b ^ 01011000b = 11000111b
-10011111b ^ 01011001b = 11000110b
-10011111b ^ 01011010b = 11000101b
-10011111b ^ 01011011b = 11000100b
-10011111b ^ 01011100b = 11000011b
-10011111b ^ 01011101b = 11000010b
-10011111b ^ 01011110b = 11000001b
-10011111b ^ 01011111b = 11000000b
-10011111b ^ 01100000b = 11111111b
-10011111b ^ 01100001b = 11111110b
-10011111b ^ 01100010b = 11111101b
-10011111b ^ 01100011b = 11111100b
-10011111b ^ 01100100b = 11111011b
-10011111b ^ 01100101b = 11111010b
-10011111b ^ 01100110b = 11111001b
-10011111b ^ 01100111b = 11111000b
-10011111b ^ 01101000b = 11110111b
-10011111b ^ 01101001b = 11110110b
-10011111b ^ 01101010b = 11110101b
-10011111b ^ 01101011b = 11110100b
-10011111b ^ 01101100b = 11110011b
-10011111b ^ 01101101b = 11110010b
-10011111b ^ 01101110b = 11110001b
-10011111b ^ 01101111b = 11110000b
-10011111b ^ 01110000b = 11101111b
-10011111b ^ 01110001b = 11101110b
-10011111b ^ 01110010b = 11101101b
-10011111b ^ 01110011b = 11101100b
-10011111b ^ 01110100b = 11101011b
-10011111b ^ 01110101b = 11101010b
-10011111b ^ 01110110b = 11101001b
-10011111b ^ 01110111b = 11101000b
-10011111b ^ 01111000b = 11100111b
-10011111b ^ 01111001b = 11100110b
-10011111b ^ 01111010b = 11100101b
-10011111b ^ 01111011b = 11100100b
-10011111b ^ 01111100b = 11100011b
-10011111b ^ 01111101b = 11100010b
-10011111b ^ 01111110b = 11100001b
-10100000b ^ 10000000b = 00100000b
-10100000b ^ 10000001b = 00100001b
-10100000b ^ 10000010b = 00100010b
-10100000b ^ 10000011b = 00100011b
-10100000b ^ 10000100b = 00100100b
-10100000b ^ 10000101b = 00100101b
-10100000b ^ 10000110b = 00100110b
-10100000b ^ 10000111b = 00100111b
-10100000b ^ 10001000b = 00101000b
-10100000b ^ 10001001b = 00101001b
-10100000b ^ 10001010b = 00101010b
-10100000b ^ 10001011b = 00101011b
-10100000b ^ 10001100b = 00101100b
-10100000b ^ 10001101b = 00101101b
-10100000b ^ 10001110b = 00101110b
-10100000b ^ 10001111b = 00101111b
-10100000b ^ 10010000b = 00110000b
-10100000b ^ 10010001b = 00110001b
-10100000b ^ 10010010b = 00110010b
-10100000b ^ 10010011b = 00110011b
-10100000b ^ 10010100b = 00110100b
-10100000b ^ 10010101b = 00110101b
-10100000b ^ 10010110b = 00110110b
-10100000b ^ 10010111b = 00110111b
-10100000b ^ 10011000b = 00111000b
-10100000b ^ 10011001b = 00111001b
-10100000b ^ 10011010b = 00111010b
-10100000b ^ 10011011b = 00111011b
-10100000b ^ 10011100b = 00111100b
-10100000b ^ 10011101b = 00111101b
-10100000b ^ 10011110b = 00111110b
-10100000b ^ 10011111b = 00111111b
-10100000b ^ 10100000b = 00000000b
-10100000b ^ 10100001b = 00000001b
-10100000b ^ 10100010b = 00000010b
-10100000b ^ 10100011b = 00000011b
-10100000b ^ 10100100b = 00000100b
-10100000b ^ 10100101b = 00000101b
-10100000b ^ 10100110b = 00000110b
-10100000b ^ 10100111b = 00000111b
-10100000b ^ 10101000b = 00001000b
-10100000b ^ 10101001b = 00001001b
-10100000b ^ 10101010b = 00001010b
-10100000b ^ 10101011b = 00001011b
-10100000b ^ 10101100b = 00001100b
-10100000b ^ 10101101b = 00001101b
-10100000b ^ 10101110b = 00001110b
-10100000b ^ 10101111b = 00001111b
-10100000b ^ 10110000b = 00010000b
-10100000b ^ 10110001b = 00010001b
-10100000b ^ 10110010b = 00010010b
-10100000b ^ 10110011b = 00010011b
-10100000b ^ 10110100b = 00010100b
-10100000b ^ 10110101b = 00010101b
-10100000b ^ 10110110b = 00010110b
-10100000b ^ 10110111b = 00010111b
-10100000b ^ 10111000b = 00011000b
-10100000b ^ 10111001b = 00011001b
-10100000b ^ 10111010b = 00011010b
-10100000b ^ 10111011b = 00011011b
-10100000b ^ 10111100b = 00011100b
-10100000b ^ 10111101b = 00011101b
-10100000b ^ 10111110b = 00011110b
-10100000b ^ 10111111b = 00011111b
-10100000b ^ 11000000b = 01100000b
-10100000b ^ 11000001b = 01100001b
-10100000b ^ 11000010b = 01100010b
-10100000b ^ 11000011b = 01100011b
-10100000b ^ 11000100b = 01100100b
-10100000b ^ 11000101b = 01100101b
-10100000b ^ 11000110b = 01100110b
-10100000b ^ 11000111b = 01100111b
-10100000b ^ 11001000b = 01101000b
-10100000b ^ 11001001b = 01101001b
-10100000b ^ 11001010b = 01101010b
-10100000b ^ 11001011b = 01101011b
-10100000b ^ 11001100b = 01101100b
-10100000b ^ 11001101b = 01101101b
-10100000b ^ 11001110b = 01101110b
-10100000b ^ 11001111b = 01101111b
-10100000b ^ 11010000b = 01110000b
-10100000b ^ 11010001b = 01110001b
-10100000b ^ 11010010b = 01110010b
-10100000b ^ 11010011b = 01110011b
-10100000b ^ 11010100b = 01110100b
-10100000b ^ 11010101b = 01110101b
-10100000b ^ 11010110b = 01110110b
-10100000b ^ 11010111b = 01110111b
-10100000b ^ 11011000b = 01111000b
-10100000b ^ 11011001b = 01111001b
-10100000b ^ 11011010b = 01111010b
-10100000b ^ 11011011b = 01111011b
-10100000b ^ 11011100b = 01111100b
-10100000b ^ 11011101b = 01111101b
-10100000b ^ 11011110b = 01111110b
-10100000b ^ 11011111b = 01111111b
-10100000b ^ 11100000b = 01000000b
-10100000b ^ 11100001b = 01000001b
-10100000b ^ 11100010b = 01000010b
-10100000b ^ 11100011b = 01000011b
-10100000b ^ 11100100b = 01000100b
-10100000b ^ 11100101b = 01000101b
-10100000b ^ 11100110b = 01000110b
-10100000b ^ 11100111b = 01000111b
-10100000b ^ 11101000b = 01001000b
-10100000b ^ 11101001b = 01001001b
-10100000b ^ 11101010b = 01001010b
-10100000b ^ 11101011b = 01001011b
-10100000b ^ 11101100b = 01001100b
-10100000b ^ 11101101b = 01001101b
-10100000b ^ 11101110b = 01001110b
-10100000b ^ 11101111b = 01001111b
-10100000b ^ 11110000b = 01010000b
-10100000b ^ 11110001b = 01010001b
-10100000b ^ 11110010b = 01010010b
-10100000b ^ 11110011b = 01010011b
-10100000b ^ 11110100b = 01010100b
-10100000b ^ 11110101b = 01010101b
-10100000b ^ 11110110b = 01010110b
-10100000b ^ 11110111b = 01010111b
-10100000b ^ 11111000b = 01011000b
-10100000b ^ 11111001b = 01011001b
-10100000b ^ 11111010b = 01011010b
-10100000b ^ 11111011b = 01011011b
-10100000b ^ 11111100b = 01011100b
-10100000b ^ 11111101b = 01011101b
-10100000b ^ 11111110b = 01011110b
-10100000b ^ 11111111b = 01011111b
-10100000b ^ 00000000b = 10100000b
-10100000b ^ 00000001b = 10100001b
-10100000b ^ 00000010b = 10100010b
-10100000b ^ 00000011b = 10100011b
-10100000b ^ 00000100b = 10100100b
-10100000b ^ 00000101b = 10100101b
-10100000b ^ 00000110b = 10100110b
-10100000b ^ 00000111b = 10100111b
-10100000b ^ 00001000b = 10101000b
-10100000b ^ 00001001b = 10101001b
-10100000b ^ 00001010b = 10101010b
-10100000b ^ 00001011b = 10101011b
-10100000b ^ 00001100b = 10101100b
-10100000b ^ 00001101b = 10101101b
-10100000b ^ 00001110b = 10101110b
-10100000b ^ 00001111b = 10101111b
-10100000b ^ 00010000b = 10110000b
-10100000b ^ 00010001b = 10110001b
-10100000b ^ 00010010b = 10110010b
-10100000b ^ 00010011b = 10110011b
-10100000b ^ 00010100b = 10110100b
-10100000b ^ 00010101b = 10110101b
-10100000b ^ 00010110b = 10110110b
-10100000b ^ 00010111b = 10110111b
-10100000b ^ 00011000b = 10111000b
-10100000b ^ 00011001b = 10111001b
-10100000b ^ 00011010b = 10111010b
-10100000b ^ 00011011b = 10111011b
-10100000b ^ 00011100b = 10111100b
-10100000b ^ 00011101b = 10111101b
-10100000b ^ 00011110b = 10111110b
-10100000b ^ 00011111b = 10111111b
-10100000b ^ 00100000b = 10000000b
-10100000b ^ 00100001b = 10000001b
-10100000b ^ 00100010b = 10000010b
-10100000b ^ 00100011b = 10000011b
-10100000b ^ 00100100b = 10000100b
-10100000b ^ 00100101b = 10000101b
-10100000b ^ 00100110b = 10000110b
-10100000b ^ 00100111b = 10000111b
-10100000b ^ 00101000b = 10001000b
-10100000b ^ 00101001b = 10001001b
-10100000b ^ 00101010b = 10001010b
-10100000b ^ 00101011b = 10001011b
-10100000b ^ 00101100b = 10001100b
-10100000b ^ 00101101b = 10001101b
-10100000b ^ 00101110b = 10001110b
-10100000b ^ 00101111b = 10001111b
-10100000b ^ 00110000b = 10010000b
-10100000b ^ 00110001b = 10010001b
-10100000b ^ 00110010b = 10010010b
-10100000b ^ 00110011b = 10010011b
-10100000b ^ 00110100b = 10010100b
-10100000b ^ 00110101b = 10010101b
-10100000b ^ 00110110b = 10010110b
-10100000b ^ 00110111b = 10010111b
-10100000b ^ 00111000b = 10011000b
-10100000b ^ 00111001b = 10011001b
-10100000b ^ 00111010b = 10011010b
-10100000b ^ 00111011b = 10011011b
-10100000b ^ 00111100b = 10011100b
-10100000b ^ 00111101b = 10011101b
-10100000b ^ 00111110b = 10011110b
-10100000b ^ 00111111b = 10011111b
-10100000b ^ 01000000b = 11100000b
-10100000b ^ 01000001b = 11100001b
-10100000b ^ 01000010b = 11100010b
-10100000b ^ 01000011b = 11100011b
-10100000b ^ 01000100b = 11100100b
-10100000b ^ 01000101b = 11100101b
-10100000b ^ 01000110b = 11100110b
-10100000b ^ 01000111b = 11100111b
-10100000b ^ 01001000b = 11101000b
-10100000b ^ 01001001b = 11101001b
-10100000b ^ 01001010b = 11101010b
-10100000b ^ 01001011b = 11101011b
-10100000b ^ 01001100b = 11101100b
-10100000b ^ 01001101b = 11101101b
-10100000b ^ 01001110b = 11101110b
-10100000b ^ 01001111b = 11101111b
-10100000b ^ 01010000b = 11110000b
-10100000b ^ 01010001b = 11110001b
-10100000b ^ 01010010b = 11110010b
-10100000b ^ 01010011b = 11110011b
-10100000b ^ 01010100b = 11110100b
-10100000b ^ 01010101b = 11110101b
-10100000b ^ 01010110b = 11110110b
-10100000b ^ 01010111b = 11110111b
-10100000b ^ 01011000b = 11111000b
-10100000b ^ 01011001b = 11111001b
-10100000b ^ 01011010b = 11111010b
-10100000b ^ 01011011b = 11111011b
-10100000b ^ 01011100b = 11111100b
-10100000b ^ 01011101b = 11111101b
-10100000b ^ 01011110b = 11111110b
-10100000b ^ 01011111b = 11111111b
-10100000b ^ 01100000b = 11000000b
-10100000b ^ 01100001b = 11000001b
-10100000b ^ 01100010b = 11000010b
-10100000b ^ 01100011b = 11000011b
-10100000b ^ 01100100b = 11000100b
-10100000b ^ 01100101b = 11000101b
-10100000b ^ 01100110b = 11000110b
-10100000b ^ 01100111b = 11000111b
-10100000b ^ 01101000b = 11001000b
-10100000b ^ 01101001b = 11001001b
-10100000b ^ 01101010b = 11001010b
-10100000b ^ 01101011b = 11001011b
-10100000b ^ 01101100b = 11001100b
-10100000b ^ 01101101b = 11001101b
-10100000b ^ 01101110b = 11001110b
-10100000b ^ 01101111b = 11001111b
-10100000b ^ 01110000b = 11010000b
-10100000b ^ 01110001b = 11010001b
-10100000b ^ 01110010b = 11010010b
-10100000b ^ 01110011b = 11010011b
-10100000b ^ 01110100b = 11010100b
-10100000b ^ 01110101b = 11010101b
-10100000b ^ 01110110b = 11010110b
-10100000b ^ 01110111b = 11010111b
-10100000b ^ 01111000b = 11011000b
-10100000b ^ 01111001b = 11011001b
-10100000b ^ 01111010b = 11011010b
-10100000b ^ 01111011b = 11011011b
-10100000b ^ 01111100b = 11011100b
-10100000b ^ 01111101b = 11011101b
-10100000b ^ 01111110b = 11011110b
-10100001b ^ 10000000b = 00100001b
-10100001b ^ 10000001b = 00100000b
-10100001b ^ 10000010b = 00100011b
-10100001b ^ 10000011b = 00100010b
-10100001b ^ 10000100b = 00100101b
-10100001b ^ 10000101b = 00100100b
-10100001b ^ 10000110b = 00100111b
-10100001b ^ 10000111b = 00100110b
-10100001b ^ 10001000b = 00101001b
-10100001b ^ 10001001b = 00101000b
-10100001b ^ 10001010b = 00101011b
-10100001b ^ 10001011b = 00101010b
-10100001b ^ 10001100b = 00101101b
-10100001b ^ 10001101b = 00101100b
-10100001b ^ 10001110b = 00101111b
-10100001b ^ 10001111b = 00101110b
-10100001b ^ 10010000b = 00110001b
-10100001b ^ 10010001b = 00110000b
-10100001b ^ 10010010b = 00110011b
-10100001b ^ 10010011b = 00110010b
-10100001b ^ 10010100b = 00110101b
-10100001b ^ 10010101b = 00110100b
-10100001b ^ 10010110b = 00110111b
-10100001b ^ 10010111b = 00110110b
-10100001b ^ 10011000b = 00111001b
-10100001b ^ 10011001b = 00111000b
-10100001b ^ 10011010b = 00111011b
-10100001b ^ 10011011b = 00111010b
-10100001b ^ 10011100b = 00111101b
-10100001b ^ 10011101b = 00111100b
-10100001b ^ 10011110b = 00111111b
-10100001b ^ 10011111b = 00111110b
-10100001b ^ 10100000b = 00000001b
-10100001b ^ 10100001b = 00000000b
-10100001b ^ 10100010b = 00000011b
-10100001b ^ 10100011b = 00000010b
-10100001b ^ 10100100b = 00000101b
-10100001b ^ 10100101b = 00000100b
-10100001b ^ 10100110b = 00000111b
-10100001b ^ 10100111b = 00000110b
-10100001b ^ 10101000b = 00001001b
-10100001b ^ 10101001b = 00001000b
-10100001b ^ 10101010b = 00001011b
-10100001b ^ 10101011b = 00001010b
-10100001b ^ 10101100b = 00001101b
-10100001b ^ 10101101b = 00001100b
-10100001b ^ 10101110b = 00001111b
-10100001b ^ 10101111b = 00001110b
-10100001b ^ 10110000b = 00010001b
-10100001b ^ 10110001b = 00010000b
-10100001b ^ 10110010b = 00010011b
-10100001b ^ 10110011b = 00010010b
-10100001b ^ 10110100b = 00010101b
-10100001b ^ 10110101b = 00010100b
-10100001b ^ 10110110b = 00010111b
-10100001b ^ 10110111b = 00010110b
-10100001b ^ 10111000b = 00011001b
-10100001b ^ 10111001b = 00011000b
-10100001b ^ 10111010b = 00011011b
-10100001b ^ 10111011b = 00011010b
-10100001b ^ 10111100b = 00011101b
-10100001b ^ 10111101b = 00011100b
-10100001b ^ 10111110b = 00011111b
-10100001b ^ 10111111b = 00011110b
-10100001b ^ 11000000b = 01100001b
-10100001b ^ 11000001b = 01100000b
-10100001b ^ 11000010b = 01100011b
-10100001b ^ 11000011b = 01100010b
-10100001b ^ 11000100b = 01100101b
-10100001b ^ 11000101b = 01100100b
-10100001b ^ 11000110b = 01100111b
-10100001b ^ 11000111b = 01100110b
-10100001b ^ 11001000b = 01101001b
-10100001b ^ 11001001b = 01101000b
-10100001b ^ 11001010b = 01101011b
-10100001b ^ 11001011b = 01101010b
-10100001b ^ 11001100b = 01101101b
-10100001b ^ 11001101b = 01101100b
-10100001b ^ 11001110b = 01101111b
-10100001b ^ 11001111b = 01101110b
-10100001b ^ 11010000b = 01110001b
-10100001b ^ 11010001b = 01110000b
-10100001b ^ 11010010b = 01110011b
-10100001b ^ 11010011b = 01110010b
-10100001b ^ 11010100b = 01110101b
-10100001b ^ 11010101b = 01110100b
-10100001b ^ 11010110b = 01110111b
-10100001b ^ 11010111b = 01110110b
-10100001b ^ 11011000b = 01111001b
-10100001b ^ 11011001b = 01111000b
-10100001b ^ 11011010b = 01111011b
-10100001b ^ 11011011b = 01111010b
-10100001b ^ 11011100b = 01111101b
-10100001b ^ 11011101b = 01111100b
-10100001b ^ 11011110b = 01111111b
-10100001b ^ 11011111b = 01111110b
-10100001b ^ 11100000b = 01000001b
-10100001b ^ 11100001b = 01000000b
-10100001b ^ 11100010b = 01000011b
-10100001b ^ 11100011b = 01000010b
-10100001b ^ 11100100b = 01000101b
-10100001b ^ 11100101b = 01000100b
-10100001b ^ 11100110b = 01000111b
-10100001b ^ 11100111b = 01000110b
-10100001b ^ 11101000b = 01001001b
-10100001b ^ 11101001b = 01001000b
-10100001b ^ 11101010b = 01001011b
-10100001b ^ 11101011b = 01001010b
-10100001b ^ 11101100b = 01001101b
-10100001b ^ 11101101b = 01001100b
-10100001b ^ 11101110b = 01001111b
-10100001b ^ 11101111b = 01001110b
-10100001b ^ 11110000b = 01010001b
-10100001b ^ 11110001b = 01010000b
-10100001b ^ 11110010b = 01010011b
-10100001b ^ 11110011b = 01010010b
-10100001b ^ 11110100b = 01010101b
-10100001b ^ 11110101b = 01010100b
-10100001b ^ 11110110b = 01010111b
-10100001b ^ 11110111b = 01010110b
-10100001b ^ 11111000b = 01011001b
-10100001b ^ 11111001b = 01011000b
-10100001b ^ 11111010b = 01011011b
-10100001b ^ 11111011b = 01011010b
-10100001b ^ 11111100b = 01011101b
-10100001b ^ 11111101b = 01011100b
-10100001b ^ 11111110b = 01011111b
-10100001b ^ 11111111b = 01011110b
-10100001b ^ 00000000b = 10100001b
-10100001b ^ 00000001b = 10100000b
-10100001b ^ 00000010b = 10100011b
-10100001b ^ 00000011b = 10100010b
-10100001b ^ 00000100b = 10100101b
-10100001b ^ 00000101b = 10100100b
-10100001b ^ 00000110b = 10100111b
-10100001b ^ 00000111b = 10100110b
-10100001b ^ 00001000b = 10101001b
-10100001b ^ 00001001b = 10101000b
-10100001b ^ 00001010b = 10101011b
-10100001b ^ 00001011b = 10101010b
-10100001b ^ 00001100b = 10101101b
-10100001b ^ 00001101b = 10101100b
-10100001b ^ 00001110b = 10101111b
-10100001b ^ 00001111b = 10101110b
-10100001b ^ 00010000b = 10110001b
-10100001b ^ 00010001b = 10110000b
-10100001b ^ 00010010b = 10110011b
-10100001b ^ 00010011b = 10110010b
-10100001b ^ 00010100b = 10110101b
-10100001b ^ 00010101b = 10110100b
-10100001b ^ 00010110b = 10110111b
-10100001b ^ 00010111b = 10110110b
-10100001b ^ 00011000b = 10111001b
-10100001b ^ 00011001b = 10111000b
-10100001b ^ 00011010b = 10111011b
-10100001b ^ 00011011b = 10111010b
-10100001b ^ 00011100b = 10111101b
-10100001b ^ 00011101b = 10111100b
-10100001b ^ 00011110b = 10111111b
-10100001b ^ 00011111b = 10111110b
-10100001b ^ 00100000b = 10000001b
-10100001b ^ 00100001b = 10000000b
-10100001b ^ 00100010b = 10000011b
-10100001b ^ 00100011b = 10000010b
-10100001b ^ 00100100b = 10000101b
-10100001b ^ 00100101b = 10000100b
-10100001b ^ 00100110b = 10000111b
-10100001b ^ 00100111b = 10000110b
-10100001b ^ 00101000b = 10001001b
-10100001b ^ 00101001b = 10001000b
-10100001b ^ 00101010b = 10001011b
-10100001b ^ 00101011b = 10001010b
-10100001b ^ 00101100b = 10001101b
-10100001b ^ 00101101b = 10001100b
-10100001b ^ 00101110b = 10001111b
-10100001b ^ 00101111b = 10001110b
-10100001b ^ 00110000b = 10010001b
-10100001b ^ 00110001b = 10010000b
-10100001b ^ 00110010b = 10010011b
-10100001b ^ 00110011b = 10010010b
-10100001b ^ 00110100b = 10010101b
-10100001b ^ 00110101b = 10010100b
-10100001b ^ 00110110b = 10010111b
-10100001b ^ 00110111b = 10010110b
-10100001b ^ 00111000b = 10011001b
-10100001b ^ 00111001b = 10011000b
-10100001b ^ 00111010b = 10011011b
-10100001b ^ 00111011b = 10011010b
-10100001b ^ 00111100b = 10011101b
-10100001b ^ 00111101b = 10011100b
-10100001b ^ 00111110b = 10011111b
-10100001b ^ 00111111b = 10011110b
-10100001b ^ 01000000b = 11100001b
-10100001b ^ 01000001b = 11100000b
-10100001b ^ 01000010b = 11100011b
-10100001b ^ 01000011b = 11100010b
-10100001b ^ 01000100b = 11100101b
-10100001b ^ 01000101b = 11100100b
-10100001b ^ 01000110b = 11100111b
-10100001b ^ 01000111b = 11100110b
-10100001b ^ 01001000b = 11101001b
-10100001b ^ 01001001b = 11101000b
-10100001b ^ 01001010b = 11101011b
-10100001b ^ 01001011b = 11101010b
-10100001b ^ 01001100b = 11101101b
-10100001b ^ 01001101b = 11101100b
-10100001b ^ 01001110b = 11101111b
-10100001b ^ 01001111b = 11101110b
-10100001b ^ 01010000b = 11110001b
-10100001b ^ 01010001b = 11110000b
-10100001b ^ 01010010b = 11110011b
-10100001b ^ 01010011b = 11110010b
-10100001b ^ 01010100b = 11110101b
-10100001b ^ 01010101b = 11110100b
-10100001b ^ 01010110b = 11110111b
-10100001b ^ 01010111b = 11110110b
-10100001b ^ 01011000b = 11111001b
-10100001b ^ 01011001b = 11111000b
-10100001b ^ 01011010b = 11111011b
-10100001b ^ 01011011b = 11111010b
-10100001b ^ 01011100b = 11111101b
-10100001b ^ 01011101b = 11111100b
-10100001b ^ 01011110b = 11111111b
-10100001b ^ 01011111b = 11111110b
-10100001b ^ 01100000b = 11000001b
-10100001b ^ 01100001b = 11000000b
-10100001b ^ 01100010b = 11000011b
-10100001b ^ 01100011b = 11000010b
-10100001b ^ 01100100b = 11000101b
-10100001b ^ 01100101b = 11000100b
-10100001b ^ 01100110b = 11000111b
-10100001b ^ 01100111b = 11000110b
-10100001b ^ 01101000b = 11001001b
-10100001b ^ 01101001b = 11001000b
-10100001b ^ 01101010b = 11001011b
-10100001b ^ 01101011b = 11001010b
-10100001b ^ 01101100b = 11001101b
-10100001b ^ 01101101b = 11001100b
-10100001b ^ 01101110b = 11001111b
-10100001b ^ 01101111b = 11001110b
-10100001b ^ 01110000b = 11010001b
-10100001b ^ 01110001b = 11010000b
-10100001b ^ 01110010b = 11010011b
-10100001b ^ 01110011b = 11010010b
-10100001b ^ 01110100b = 11010101b
-10100001b ^ 01110101b = 11010100b
-10100001b ^ 01110110b = 11010111b
-10100001b ^ 01110111b = 11010110b
-10100001b ^ 01111000b = 11011001b
-10100001b ^ 01111001b = 11011000b
-10100001b ^ 01111010b = 11011011b
-10100001b ^ 01111011b = 11011010b
-10100001b ^ 01111100b = 11011101b
-10100001b ^ 01111101b = 11011100b
-10100001b ^ 01111110b = 11011111b
-10100010b ^ 10000000b = 00100010b
-10100010b ^ 10000001b = 00100011b
-10100010b ^ 10000010b = 00100000b
-10100010b ^ 10000011b = 00100001b
-10100010b ^ 10000100b = 00100110b
-10100010b ^ 10000101b = 00100111b
-10100010b ^ 10000110b = 00100100b
-10100010b ^ 10000111b = 00100101b
-10100010b ^ 10001000b = 00101010b
-10100010b ^ 10001001b = 00101011b
-10100010b ^ 10001010b = 00101000b
-10100010b ^ 10001011b = 00101001b
-10100010b ^ 10001100b = 00101110b
-10100010b ^ 10001101b = 00101111b
-10100010b ^ 10001110b = 00101100b
-10100010b ^ 10001111b = 00101101b
-10100010b ^ 10010000b = 00110010b
-10100010b ^ 10010001b = 00110011b
-10100010b ^ 10010010b = 00110000b
-10100010b ^ 10010011b = 00110001b
-10100010b ^ 10010100b = 00110110b
-10100010b ^ 10010101b = 00110111b
-10100010b ^ 10010110b = 00110100b
-10100010b ^ 10010111b = 00110101b
-10100010b ^ 10011000b = 00111010b
-10100010b ^ 10011001b = 00111011b
-10100010b ^ 10011010b = 00111000b
-10100010b ^ 10011011b = 00111001b
-10100010b ^ 10011100b = 00111110b
-10100010b ^ 10011101b = 00111111b
-10100010b ^ 10011110b = 00111100b
-10100010b ^ 10011111b = 00111101b
-10100010b ^ 10100000b = 00000010b
-10100010b ^ 10100001b = 00000011b
-10100010b ^ 10100010b = 00000000b
-10100010b ^ 10100011b = 00000001b
-10100010b ^ 10100100b = 00000110b
-10100010b ^ 10100101b = 00000111b
-10100010b ^ 10100110b = 00000100b
-10100010b ^ 10100111b = 00000101b
-10100010b ^ 10101000b = 00001010b
-10100010b ^ 10101001b = 00001011b
-10100010b ^ 10101010b = 00001000b
-10100010b ^ 10101011b = 00001001b
-10100010b ^ 10101100b = 00001110b
-10100010b ^ 10101101b = 00001111b
-10100010b ^ 10101110b = 00001100b
-10100010b ^ 10101111b = 00001101b
-10100010b ^ 10110000b = 00010010b
-10100010b ^ 10110001b = 00010011b
-10100010b ^ 10110010b = 00010000b
-10100010b ^ 10110011b = 00010001b
-10100010b ^ 10110100b = 00010110b
-10100010b ^ 10110101b = 00010111b
-10100010b ^ 10110110b = 00010100b
-10100010b ^ 10110111b = 00010101b
-10100010b ^ 10111000b = 00011010b
-10100010b ^ 10111001b = 00011011b
-10100010b ^ 10111010b = 00011000b
-10100010b ^ 10111011b = 00011001b
-10100010b ^ 10111100b = 00011110b
-10100010b ^ 10111101b = 00011111b
-10100010b ^ 10111110b = 00011100b
-10100010b ^ 10111111b = 00011101b
-10100010b ^ 11000000b = 01100010b
-10100010b ^ 11000001b = 01100011b
-10100010b ^ 11000010b = 01100000b
-10100010b ^ 11000011b = 01100001b
-10100010b ^ 11000100b = 01100110b
-10100010b ^ 11000101b = 01100111b
-10100010b ^ 11000110b = 01100100b
-10100010b ^ 11000111b = 01100101b
-10100010b ^ 11001000b = 01101010b
-10100010b ^ 11001001b = 01101011b
-10100010b ^ 11001010b = 01101000b
-10100010b ^ 11001011b = 01101001b
-10100010b ^ 11001100b = 01101110b
-10100010b ^ 11001101b = 01101111b
-10100010b ^ 11001110b = 01101100b
-10100010b ^ 11001111b = 01101101b
-10100010b ^ 11010000b = 01110010b
-10100010b ^ 11010001b = 01110011b
-10100010b ^ 11010010b = 01110000b
-10100010b ^ 11010011b = 01110001b
-10100010b ^ 11010100b = 01110110b
-10100010b ^ 11010101b = 01110111b
-10100010b ^ 11010110b = 01110100b
-10100010b ^ 11010111b = 01110101b
-10100010b ^ 11011000b = 01111010b
-10100010b ^ 11011001b = 01111011b
-10100010b ^ 11011010b = 01111000b
-10100010b ^ 11011011b = 01111001b
-10100010b ^ 11011100b = 01111110b
-10100010b ^ 11011101b = 01111111b
-10100010b ^ 11011110b = 01111100b
-10100010b ^ 11011111b = 01111101b
-10100010b ^ 11100000b = 01000010b
-10100010b ^ 11100001b = 01000011b
-10100010b ^ 11100010b = 01000000b
-10100010b ^ 11100011b = 01000001b
-10100010b ^ 11100100b = 01000110b
-10100010b ^ 11100101b = 01000111b
-10100010b ^ 11100110b = 01000100b
-10100010b ^ 11100111b = 01000101b
-10100010b ^ 11101000b = 01001010b
-10100010b ^ 11101001b = 01001011b
-10100010b ^ 11101010b = 01001000b
-10100010b ^ 11101011b = 01001001b
-10100010b ^ 11101100b = 01001110b
-10100010b ^ 11101101b = 01001111b
-10100010b ^ 11101110b = 01001100b
-10100010b ^ 11101111b = 01001101b
-10100010b ^ 11110000b = 01010010b
-10100010b ^ 11110001b = 01010011b
-10100010b ^ 11110010b = 01010000b
-10100010b ^ 11110011b = 01010001b
-10100010b ^ 11110100b = 01010110b
-10100010b ^ 11110101b = 01010111b
-10100010b ^ 11110110b = 01010100b
-10100010b ^ 11110111b = 01010101b
-10100010b ^ 11111000b = 01011010b
-10100010b ^ 11111001b = 01011011b
-10100010b ^ 11111010b = 01011000b
-10100010b ^ 11111011b = 01011001b
-10100010b ^ 11111100b = 01011110b
-10100010b ^ 11111101b = 01011111b
-10100010b ^ 11111110b = 01011100b
-10100010b ^ 11111111b = 01011101b
-10100010b ^ 00000000b = 10100010b
-10100010b ^ 00000001b = 10100011b
-10100010b ^ 00000010b = 10100000b
-10100010b ^ 00000011b = 10100001b
-10100010b ^ 00000100b = 10100110b
-10100010b ^ 00000101b = 10100111b
-10100010b ^ 00000110b = 10100100b
-10100010b ^ 00000111b = 10100101b
-10100010b ^ 00001000b = 10101010b
-10100010b ^ 00001001b = 10101011b
-10100010b ^ 00001010b = 10101000b
-10100010b ^ 00001011b = 10101001b
-10100010b ^ 00001100b = 10101110b
-10100010b ^ 00001101b = 10101111b
-10100010b ^ 00001110b = 10101100b
-10100010b ^ 00001111b = 10101101b
-10100010b ^ 00010000b = 10110010b
-10100010b ^ 00010001b = 10110011b
-10100010b ^ 00010010b = 10110000b
-10100010b ^ 00010011b = 10110001b
-10100010b ^ 00010100b = 10110110b
-10100010b ^ 00010101b = 10110111b
-10100010b ^ 00010110b = 10110100b
-10100010b ^ 00010111b = 10110101b
-10100010b ^ 00011000b = 10111010b
-10100010b ^ 00011001b = 10111011b
-10100010b ^ 00011010b = 10111000b
-10100010b ^ 00011011b = 10111001b
-10100010b ^ 00011100b = 10111110b
-10100010b ^ 00011101b = 10111111b
-10100010b ^ 00011110b = 10111100b
-10100010b ^ 00011111b = 10111101b
-10100010b ^ 00100000b = 10000010b
-10100010b ^ 00100001b = 10000011b
-10100010b ^ 00100010b = 10000000b
-10100010b ^ 00100011b = 10000001b
-10100010b ^ 00100100b = 10000110b
-10100010b ^ 00100101b = 10000111b
-10100010b ^ 00100110b = 10000100b
-10100010b ^ 00100111b = 10000101b
-10100010b ^ 00101000b = 10001010b
-10100010b ^ 00101001b = 10001011b
-10100010b ^ 00101010b = 10001000b
-10100010b ^ 00101011b = 10001001b
-10100010b ^ 00101100b = 10001110b
-10100010b ^ 00101101b = 10001111b
-10100010b ^ 00101110b = 10001100b
-10100010b ^ 00101111b = 10001101b
-10100010b ^ 00110000b = 10010010b
-10100010b ^ 00110001b = 10010011b
-10100010b ^ 00110010b = 10010000b
-10100010b ^ 00110011b = 10010001b
-10100010b ^ 00110100b = 10010110b
-10100010b ^ 00110101b = 10010111b
-10100010b ^ 00110110b = 10010100b
-10100010b ^ 00110111b = 10010101b
-10100010b ^ 00111000b = 10011010b
-10100010b ^ 00111001b = 10011011b
-10100010b ^ 00111010b = 10011000b
-10100010b ^ 00111011b = 10011001b
-10100010b ^ 00111100b = 10011110b
-10100010b ^ 00111101b = 10011111b
-10100010b ^ 00111110b = 10011100b
-10100010b ^ 00111111b = 10011101b
-10100010b ^ 01000000b = 11100010b
-10100010b ^ 01000001b = 11100011b
-10100010b ^ 01000010b = 11100000b
-10100010b ^ 01000011b = 11100001b
-10100010b ^ 01000100b = 11100110b
-10100010b ^ 01000101b = 11100111b
-10100010b ^ 01000110b = 11100100b
-10100010b ^ 01000111b = 11100101b
-10100010b ^ 01001000b = 11101010b
-10100010b ^ 01001001b = 11101011b
-10100010b ^ 01001010b = 11101000b
-10100010b ^ 01001011b = 11101001b
-10100010b ^ 01001100b = 11101110b
-10100010b ^ 01001101b = 11101111b
-10100010b ^ 01001110b = 11101100b
-10100010b ^ 01001111b = 11101101b
-10100010b ^ 01010000b = 11110010b
-10100010b ^ 01010001b = 11110011b
-10100010b ^ 01010010b = 11110000b
-10100010b ^ 01010011b = 11110001b
-10100010b ^ 01010100b = 11110110b
-10100010b ^ 01010101b = 11110111b
-10100010b ^ 01010110b = 11110100b
-10100010b ^ 01010111b = 11110101b
-10100010b ^ 01011000b = 11111010b
-10100010b ^ 01011001b = 11111011b
-10100010b ^ 01011010b = 11111000b
-10100010b ^ 01011011b = 11111001b
-10100010b ^ 01011100b = 11111110b
-10100010b ^ 01011101b = 11111111b
-10100010b ^ 01011110b = 11111100b
-10100010b ^ 01011111b = 11111101b
-10100010b ^ 01100000b = 11000010b
-10100010b ^ 01100001b = 11000011b
-10100010b ^ 01100010b = 11000000b
-10100010b ^ 01100011b = 11000001b
-10100010b ^ 01100100b = 11000110b
-10100010b ^ 01100101b = 11000111b
-10100010b ^ 01100110b = 11000100b
-10100010b ^ 01100111b = 11000101b
-10100010b ^ 01101000b = 11001010b
-10100010b ^ 01101001b = 11001011b
-10100010b ^ 01101010b = 11001000b
-10100010b ^ 01101011b = 11001001b
-10100010b ^ 01101100b = 11001110b
-10100010b ^ 01101101b = 11001111b
-10100010b ^ 01101110b = 11001100b
-10100010b ^ 01101111b = 11001101b
-10100010b ^ 01110000b = 11010010b
-10100010b ^ 01110001b = 11010011b
-10100010b ^ 01110010b = 11010000b
-10100010b ^ 01110011b = 11010001b
-10100010b ^ 01110100b = 11010110b
-10100010b ^ 01110101b = 11010111b
-10100010b ^ 01110110b = 11010100b
-10100010b ^ 01110111b = 11010101b
-10100010b ^ 01111000b = 11011010b
-10100010b ^ 01111001b = 11011011b
-10100010b ^ 01111010b = 11011000b
-10100010b ^ 01111011b = 11011001b
-10100010b ^ 01111100b = 11011110b
-10100010b ^ 01111101b = 11011111b
-10100010b ^ 01111110b = 11011100b
-10100011b ^ 10000000b = 00100011b
-10100011b ^ 10000001b = 00100010b
-10100011b ^ 10000010b = 00100001b
-10100011b ^ 10000011b = 00100000b
-10100011b ^ 10000100b = 00100111b
-10100011b ^ 10000101b = 00100110b
-10100011b ^ 10000110b = 00100101b
-10100011b ^ 10000111b = 00100100b
-10100011b ^ 10001000b = 00101011b
-10100011b ^ 10001001b = 00101010b
-10100011b ^ 10001010b = 00101001b
-10100011b ^ 10001011b = 00101000b
-10100011b ^ 10001100b = 00101111b
-10100011b ^ 10001101b = 00101110b
-10100011b ^ 10001110b = 00101101b
-10100011b ^ 10001111b = 00101100b
-10100011b ^ 10010000b = 00110011b
-10100011b ^ 10010001b = 00110010b
-10100011b ^ 10010010b = 00110001b
-10100011b ^ 10010011b = 00110000b
-10100011b ^ 10010100b = 00110111b
-10100011b ^ 10010101b = 00110110b
-10100011b ^ 10010110b = 00110101b
-10100011b ^ 10010111b = 00110100b
-10100011b ^ 10011000b = 00111011b
-10100011b ^ 10011001b = 00111010b
-10100011b ^ 10011010b = 00111001b
-10100011b ^ 10011011b = 00111000b
-10100011b ^ 10011100b = 00111111b
-10100011b ^ 10011101b = 00111110b
-10100011b ^ 10011110b = 00111101b
-10100011b ^ 10011111b = 00111100b
-10100011b ^ 10100000b = 00000011b
-10100011b ^ 10100001b = 00000010b
-10100011b ^ 10100010b = 00000001b
-10100011b ^ 10100011b = 00000000b
-10100011b ^ 10100100b = 00000111b
-10100011b ^ 10100101b = 00000110b
-10100011b ^ 10100110b = 00000101b
-10100011b ^ 10100111b = 00000100b
-10100011b ^ 10101000b = 00001011b
-10100011b ^ 10101001b = 00001010b
-10100011b ^ 10101010b = 00001001b
-10100011b ^ 10101011b = 00001000b
-10100011b ^ 10101100b = 00001111b
-10100011b ^ 10101101b = 00001110b
-10100011b ^ 10101110b = 00001101b
-10100011b ^ 10101111b = 00001100b
-10100011b ^ 10110000b = 00010011b
-10100011b ^ 10110001b = 00010010b
-10100011b ^ 10110010b = 00010001b
-10100011b ^ 10110011b = 00010000b
-10100011b ^ 10110100b = 00010111b
-10100011b ^ 10110101b = 00010110b
-10100011b ^ 10110110b = 00010101b
-10100011b ^ 10110111b = 00010100b
-10100011b ^ 10111000b = 00011011b
-10100011b ^ 10111001b = 00011010b
-10100011b ^ 10111010b = 00011001b
-10100011b ^ 10111011b = 00011000b
-10100011b ^ 10111100b = 00011111b
-10100011b ^ 10111101b = 00011110b
-10100011b ^ 10111110b = 00011101b
-10100011b ^ 10111111b = 00011100b
-10100011b ^ 11000000b = 01100011b
-10100011b ^ 11000001b = 01100010b
-10100011b ^ 11000010b = 01100001b
-10100011b ^ 11000011b = 01100000b
-10100011b ^ 11000100b = 01100111b
-10100011b ^ 11000101b = 01100110b
-10100011b ^ 11000110b = 01100101b
-10100011b ^ 11000111b = 01100100b
-10100011b ^ 11001000b = 01101011b
-10100011b ^ 11001001b = 01101010b
-10100011b ^ 11001010b = 01101001b
-10100011b ^ 11001011b = 01101000b
-10100011b ^ 11001100b = 01101111b
-10100011b ^ 11001101b = 01101110b
-10100011b ^ 11001110b = 01101101b
-10100011b ^ 11001111b = 01101100b
-10100011b ^ 11010000b = 01110011b
-10100011b ^ 11010001b = 01110010b
-10100011b ^ 11010010b = 01110001b
-10100011b ^ 11010011b = 01110000b
-10100011b ^ 11010100b = 01110111b
-10100011b ^ 11010101b = 01110110b
-10100011b ^ 11010110b = 01110101b
-10100011b ^ 11010111b = 01110100b
-10100011b ^ 11011000b = 01111011b
-10100011b ^ 11011001b = 01111010b
-10100011b ^ 11011010b = 01111001b
-10100011b ^ 11011011b = 01111000b
-10100011b ^ 11011100b = 01111111b
-10100011b ^ 11011101b = 01111110b
-10100011b ^ 11011110b = 01111101b
-10100011b ^ 11011111b = 01111100b
-10100011b ^ 11100000b = 01000011b
-10100011b ^ 11100001b = 01000010b
-10100011b ^ 11100010b = 01000001b
-10100011b ^ 11100011b = 01000000b
-10100011b ^ 11100100b = 01000111b
-10100011b ^ 11100101b = 01000110b
-10100011b ^ 11100110b = 01000101b
-10100011b ^ 11100111b = 01000100b
-10100011b ^ 11101000b = 01001011b
-10100011b ^ 11101001b = 01001010b
-10100011b ^ 11101010b = 01001001b
-10100011b ^ 11101011b = 01001000b
-10100011b ^ 11101100b = 01001111b
-10100011b ^ 11101101b = 01001110b
-10100011b ^ 11101110b = 01001101b
-10100011b ^ 11101111b = 01001100b
-10100011b ^ 11110000b = 01010011b
-10100011b ^ 11110001b = 01010010b
-10100011b ^ 11110010b = 01010001b
-10100011b ^ 11110011b = 01010000b
-10100011b ^ 11110100b = 01010111b
-10100011b ^ 11110101b = 01010110b
-10100011b ^ 11110110b = 01010101b
-10100011b ^ 11110111b = 01010100b
-10100011b ^ 11111000b = 01011011b
-10100011b ^ 11111001b = 01011010b
-10100011b ^ 11111010b = 01011001b
-10100011b ^ 11111011b = 01011000b
-10100011b ^ 11111100b = 01011111b
-10100011b ^ 11111101b = 01011110b
-10100011b ^ 11111110b = 01011101b
-10100011b ^ 11111111b = 01011100b
-10100011b ^ 00000000b = 10100011b
-10100011b ^ 00000001b = 10100010b
-10100011b ^ 00000010b = 10100001b
-10100011b ^ 00000011b = 10100000b
-10100011b ^ 00000100b = 10100111b
-10100011b ^ 00000101b = 10100110b
-10100011b ^ 00000110b = 10100101b
-10100011b ^ 00000111b = 10100100b
-10100011b ^ 00001000b = 10101011b
-10100011b ^ 00001001b = 10101010b
-10100011b ^ 00001010b = 10101001b
-10100011b ^ 00001011b = 10101000b
-10100011b ^ 00001100b = 10101111b
-10100011b ^ 00001101b = 10101110b
-10100011b ^ 00001110b = 10101101b
-10100011b ^ 00001111b = 10101100b
-10100011b ^ 00010000b = 10110011b
-10100011b ^ 00010001b = 10110010b
-10100011b ^ 00010010b = 10110001b
-10100011b ^ 00010011b = 10110000b
-10100011b ^ 00010100b = 10110111b
-10100011b ^ 00010101b = 10110110b
-10100011b ^ 00010110b = 10110101b
-10100011b ^ 00010111b = 10110100b
-10100011b ^ 00011000b = 10111011b
-10100011b ^ 00011001b = 10111010b
-10100011b ^ 00011010b = 10111001b
-10100011b ^ 00011011b = 10111000b
-10100011b ^ 00011100b = 10111111b
-10100011b ^ 00011101b = 10111110b
-10100011b ^ 00011110b = 10111101b
-10100011b ^ 00011111b = 10111100b
-10100011b ^ 00100000b = 10000011b
-10100011b ^ 00100001b = 10000010b
-10100011b ^ 00100010b = 10000001b
-10100011b ^ 00100011b = 10000000b
-10100011b ^ 00100100b = 10000111b
-10100011b ^ 00100101b = 10000110b
-10100011b ^ 00100110b = 10000101b
-10100011b ^ 00100111b = 10000100b
-10100011b ^ 00101000b = 10001011b
-10100011b ^ 00101001b = 10001010b
-10100011b ^ 00101010b = 10001001b
-10100011b ^ 00101011b = 10001000b
-10100011b ^ 00101100b = 10001111b
-10100011b ^ 00101101b = 10001110b
-10100011b ^ 00101110b = 10001101b
-10100011b ^ 00101111b = 10001100b
-10100011b ^ 00110000b = 10010011b
-10100011b ^ 00110001b = 10010010b
-10100011b ^ 00110010b = 10010001b
-10100011b ^ 00110011b = 10010000b
-10100011b ^ 00110100b = 10010111b
-10100011b ^ 00110101b = 10010110b
-10100011b ^ 00110110b = 10010101b
-10100011b ^ 00110111b = 10010100b
-10100011b ^ 00111000b = 10011011b
-10100011b ^ 00111001b = 10011010b
-10100011b ^ 00111010b = 10011001b
-10100011b ^ 00111011b = 10011000b
-10100011b ^ 00111100b = 10011111b
-10100011b ^ 00111101b = 10011110b
-10100011b ^ 00111110b = 10011101b
-10100011b ^ 00111111b = 10011100b
-10100011b ^ 01000000b = 11100011b
-10100011b ^ 01000001b = 11100010b
-10100011b ^ 01000010b = 11100001b
-10100011b ^ 01000011b = 11100000b
-10100011b ^ 01000100b = 11100111b
-10100011b ^ 01000101b = 11100110b
-10100011b ^ 01000110b = 11100101b
-10100011b ^ 01000111b = 11100100b
-10100011b ^ 01001000b = 11101011b
-10100011b ^ 01001001b = 11101010b
-10100011b ^ 01001010b = 11101001b
-10100011b ^ 01001011b = 11101000b
-10100011b ^ 01001100b = 11101111b
-10100011b ^ 01001101b = 11101110b
-10100011b ^ 01001110b = 11101101b
-10100011b ^ 01001111b = 11101100b
-10100011b ^ 01010000b = 11110011b
-10100011b ^ 01010001b = 11110010b
-10100011b ^ 01010010b = 11110001b
-10100011b ^ 01010011b = 11110000b
-10100011b ^ 01010100b = 11110111b
-10100011b ^ 01010101b = 11110110b
-10100011b ^ 01010110b = 11110101b
-10100011b ^ 01010111b = 11110100b
-10100011b ^ 01011000b = 11111011b
-10100011b ^ 01011001b = 11111010b
-10100011b ^ 01011010b = 11111001b
-10100011b ^ 01011011b = 11111000b
-10100011b ^ 01011100b = 11111111b
-10100011b ^ 01011101b = 11111110b
-10100011b ^ 01011110b = 11111101b
-10100011b ^ 01011111b = 11111100b
-10100011b ^ 01100000b = 11000011b
-10100011b ^ 01100001b = 11000010b
-10100011b ^ 01100010b = 11000001b
-10100011b ^ 01100011b = 11000000b
-10100011b ^ 01100100b = 11000111b
-10100011b ^ 01100101b = 11000110b
-10100011b ^ 01100110b = 11000101b
-10100011b ^ 01100111b = 11000100b
-10100011b ^ 01101000b = 11001011b
-10100011b ^ 01101001b = 11001010b
-10100011b ^ 01101010b = 11001001b
-10100011b ^ 01101011b = 11001000b
-10100011b ^ 01101100b = 11001111b
-10100011b ^ 01101101b = 11001110b
-10100011b ^ 01101110b = 11001101b
-10100011b ^ 01101111b = 11001100b
-10100011b ^ 01110000b = 11010011b
-10100011b ^ 01110001b = 11010010b
-10100011b ^ 01110010b = 11010001b
-10100011b ^ 01110011b = 11010000b
-10100011b ^ 01110100b = 11010111b
-10100011b ^ 01110101b = 11010110b
-10100011b ^ 01110110b = 11010101b
-10100011b ^ 01110111b = 11010100b
-10100011b ^ 01111000b = 11011011b
-10100011b ^ 01111001b = 11011010b
-10100011b ^ 01111010b = 11011001b
-10100011b ^ 01111011b = 11011000b
-10100011b ^ 01111100b = 11011111b
-10100011b ^ 01111101b = 11011110b
-10100011b ^ 01111110b = 11011101b
-10100100b ^ 10000000b = 00100100b
-10100100b ^ 10000001b = 00100101b
-10100100b ^ 10000010b = 00100110b
-10100100b ^ 10000011b = 00100111b
-10100100b ^ 10000100b = 00100000b
-10100100b ^ 10000101b = 00100001b
-10100100b ^ 10000110b = 00100010b
-10100100b ^ 10000111b = 00100011b
-10100100b ^ 10001000b = 00101100b
-10100100b ^ 10001001b = 00101101b
-10100100b ^ 10001010b = 00101110b
-10100100b ^ 10001011b = 00101111b
-10100100b ^ 10001100b = 00101000b
-10100100b ^ 10001101b = 00101001b
-10100100b ^ 10001110b = 00101010b
-10100100b ^ 10001111b = 00101011b
-10100100b ^ 10010000b = 00110100b
-10100100b ^ 10010001b = 00110101b
-10100100b ^ 10010010b = 00110110b
-10100100b ^ 10010011b = 00110111b
-10100100b ^ 10010100b = 00110000b
-10100100b ^ 10010101b = 00110001b
-10100100b ^ 10010110b = 00110010b
-10100100b ^ 10010111b = 00110011b
-10100100b ^ 10011000b = 00111100b
-10100100b ^ 10011001b = 00111101b
-10100100b ^ 10011010b = 00111110b
-10100100b ^ 10011011b = 00111111b
-10100100b ^ 10011100b = 00111000b
-10100100b ^ 10011101b = 00111001b
-10100100b ^ 10011110b = 00111010b
-10100100b ^ 10011111b = 00111011b
-10100100b ^ 10100000b = 00000100b
-10100100b ^ 10100001b = 00000101b
-10100100b ^ 10100010b = 00000110b
-10100100b ^ 10100011b = 00000111b
-10100100b ^ 10100100b = 00000000b
-10100100b ^ 10100101b = 00000001b
-10100100b ^ 10100110b = 00000010b
-10100100b ^ 10100111b = 00000011b
-10100100b ^ 10101000b = 00001100b
-10100100b ^ 10101001b = 00001101b
-10100100b ^ 10101010b = 00001110b
-10100100b ^ 10101011b = 00001111b
-10100100b ^ 10101100b = 00001000b
-10100100b ^ 10101101b = 00001001b
-10100100b ^ 10101110b = 00001010b
-10100100b ^ 10101111b = 00001011b
-10100100b ^ 10110000b = 00010100b
-10100100b ^ 10110001b = 00010101b
-10100100b ^ 10110010b = 00010110b
-10100100b ^ 10110011b = 00010111b
-10100100b ^ 10110100b = 00010000b
-10100100b ^ 10110101b = 00010001b
-10100100b ^ 10110110b = 00010010b
-10100100b ^ 10110111b = 00010011b
-10100100b ^ 10111000b = 00011100b
-10100100b ^ 10111001b = 00011101b
-10100100b ^ 10111010b = 00011110b
-10100100b ^ 10111011b = 00011111b
-10100100b ^ 10111100b = 00011000b
-10100100b ^ 10111101b = 00011001b
-10100100b ^ 10111110b = 00011010b
-10100100b ^ 10111111b = 00011011b
-10100100b ^ 11000000b = 01100100b
-10100100b ^ 11000001b = 01100101b
-10100100b ^ 11000010b = 01100110b
-10100100b ^ 11000011b = 01100111b
-10100100b ^ 11000100b = 01100000b
-10100100b ^ 11000101b = 01100001b
-10100100b ^ 11000110b = 01100010b
-10100100b ^ 11000111b = 01100011b
-10100100b ^ 11001000b = 01101100b
-10100100b ^ 11001001b = 01101101b
-10100100b ^ 11001010b = 01101110b
-10100100b ^ 11001011b = 01101111b
-10100100b ^ 11001100b = 01101000b
-10100100b ^ 11001101b = 01101001b
-10100100b ^ 11001110b = 01101010b
-10100100b ^ 11001111b = 01101011b
-10100100b ^ 11010000b = 01110100b
-10100100b ^ 11010001b = 01110101b
-10100100b ^ 11010010b = 01110110b
-10100100b ^ 11010011b = 01110111b
-10100100b ^ 11010100b = 01110000b
-10100100b ^ 11010101b = 01110001b
-10100100b ^ 11010110b = 01110010b
-10100100b ^ 11010111b = 01110011b
-10100100b ^ 11011000b = 01111100b
-10100100b ^ 11011001b = 01111101b
-10100100b ^ 11011010b = 01111110b
-10100100b ^ 11011011b = 01111111b
-10100100b ^ 11011100b = 01111000b
-10100100b ^ 11011101b = 01111001b
-10100100b ^ 11011110b = 01111010b
-10100100b ^ 11011111b = 01111011b
-10100100b ^ 11100000b = 01000100b
-10100100b ^ 11100001b = 01000101b
-10100100b ^ 11100010b = 01000110b
-10100100b ^ 11100011b = 01000111b
-10100100b ^ 11100100b = 01000000b
-10100100b ^ 11100101b = 01000001b
-10100100b ^ 11100110b = 01000010b
-10100100b ^ 11100111b = 01000011b
-10100100b ^ 11101000b = 01001100b
-10100100b ^ 11101001b = 01001101b
-10100100b ^ 11101010b = 01001110b
-10100100b ^ 11101011b = 01001111b
-10100100b ^ 11101100b = 01001000b
-10100100b ^ 11101101b = 01001001b
-10100100b ^ 11101110b = 01001010b
-10100100b ^ 11101111b = 01001011b
-10100100b ^ 11110000b = 01010100b
-10100100b ^ 11110001b = 01010101b
-10100100b ^ 11110010b = 01010110b
-10100100b ^ 11110011b = 01010111b
-10100100b ^ 11110100b = 01010000b
-10100100b ^ 11110101b = 01010001b
-10100100b ^ 11110110b = 01010010b
-10100100b ^ 11110111b = 01010011b
-10100100b ^ 11111000b = 01011100b
-10100100b ^ 11111001b = 01011101b
-10100100b ^ 11111010b = 01011110b
-10100100b ^ 11111011b = 01011111b
-10100100b ^ 11111100b = 01011000b
-10100100b ^ 11111101b = 01011001b
-10100100b ^ 11111110b = 01011010b
-10100100b ^ 11111111b = 01011011b
-10100100b ^ 00000000b = 10100100b
-10100100b ^ 00000001b = 10100101b
-10100100b ^ 00000010b = 10100110b
-10100100b ^ 00000011b = 10100111b
-10100100b ^ 00000100b = 10100000b
-10100100b ^ 00000101b = 10100001b
-10100100b ^ 00000110b = 10100010b
-10100100b ^ 00000111b = 10100011b
-10100100b ^ 00001000b = 10101100b
-10100100b ^ 00001001b = 10101101b
-10100100b ^ 00001010b = 10101110b
-10100100b ^ 00001011b = 10101111b
-10100100b ^ 00001100b = 10101000b
-10100100b ^ 00001101b = 10101001b
-10100100b ^ 00001110b = 10101010b
-10100100b ^ 00001111b = 10101011b
-10100100b ^ 00010000b = 10110100b
-10100100b ^ 00010001b = 10110101b
-10100100b ^ 00010010b = 10110110b
-10100100b ^ 00010011b = 10110111b
-10100100b ^ 00010100b = 10110000b
-10100100b ^ 00010101b = 10110001b
-10100100b ^ 00010110b = 10110010b
-10100100b ^ 00010111b = 10110011b
-10100100b ^ 00011000b = 10111100b
-10100100b ^ 00011001b = 10111101b
-10100100b ^ 00011010b = 10111110b
-10100100b ^ 00011011b = 10111111b
-10100100b ^ 00011100b = 10111000b
-10100100b ^ 00011101b = 10111001b
-10100100b ^ 00011110b = 10111010b
-10100100b ^ 00011111b = 10111011b
-10100100b ^ 00100000b = 10000100b
-10100100b ^ 00100001b = 10000101b
-10100100b ^ 00100010b = 10000110b
-10100100b ^ 00100011b = 10000111b
-10100100b ^ 00100100b = 10000000b
-10100100b ^ 00100101b = 10000001b
-10100100b ^ 00100110b = 10000010b
-10100100b ^ 00100111b = 10000011b
-10100100b ^ 00101000b = 10001100b
-10100100b ^ 00101001b = 10001101b
-10100100b ^ 00101010b = 10001110b
-10100100b ^ 00101011b = 10001111b
-10100100b ^ 00101100b = 10001000b
-10100100b ^ 00101101b = 10001001b
-10100100b ^ 00101110b = 10001010b
-10100100b ^ 00101111b = 10001011b
-10100100b ^ 00110000b = 10010100b
-10100100b ^ 00110001b = 10010101b
-10100100b ^ 00110010b = 10010110b
-10100100b ^ 00110011b = 10010111b
-10100100b ^ 00110100b = 10010000b
-10100100b ^ 00110101b = 10010001b
-10100100b ^ 00110110b = 10010010b
-10100100b ^ 00110111b = 10010011b
-10100100b ^ 00111000b = 10011100b
-10100100b ^ 00111001b = 10011101b
-10100100b ^ 00111010b = 10011110b
-10100100b ^ 00111011b = 10011111b
-10100100b ^ 00111100b = 10011000b
-10100100b ^ 00111101b = 10011001b
-10100100b ^ 00111110b = 10011010b
-10100100b ^ 00111111b = 10011011b
-10100100b ^ 01000000b = 11100100b
-10100100b ^ 01000001b = 11100101b
-10100100b ^ 01000010b = 11100110b
-10100100b ^ 01000011b = 11100111b
-10100100b ^ 01000100b = 11100000b
-10100100b ^ 01000101b = 11100001b
-10100100b ^ 01000110b = 11100010b
-10100100b ^ 01000111b = 11100011b
-10100100b ^ 01001000b = 11101100b
-10100100b ^ 01001001b = 11101101b
-10100100b ^ 01001010b = 11101110b
-10100100b ^ 01001011b = 11101111b
-10100100b ^ 01001100b = 11101000b
-10100100b ^ 01001101b = 11101001b
-10100100b ^ 01001110b = 11101010b
-10100100b ^ 01001111b = 11101011b
-10100100b ^ 01010000b = 11110100b
-10100100b ^ 01010001b = 11110101b
-10100100b ^ 01010010b = 11110110b
-10100100b ^ 01010011b = 11110111b
-10100100b ^ 01010100b = 11110000b
-10100100b ^ 01010101b = 11110001b
-10100100b ^ 01010110b = 11110010b
-10100100b ^ 01010111b = 11110011b
-10100100b ^ 01011000b = 11111100b
-10100100b ^ 01011001b = 11111101b
-10100100b ^ 01011010b = 11111110b
-10100100b ^ 01011011b = 11111111b
-10100100b ^ 01011100b = 11111000b
-10100100b ^ 01011101b = 11111001b
-10100100b ^ 01011110b = 11111010b
-10100100b ^ 01011111b = 11111011b
-10100100b ^ 01100000b = 11000100b
-10100100b ^ 01100001b = 11000101b
-10100100b ^ 01100010b = 11000110b
-10100100b ^ 01100011b = 11000111b
-10100100b ^ 01100100b = 11000000b
-10100100b ^ 01100101b = 11000001b
-10100100b ^ 01100110b = 11000010b
-10100100b ^ 01100111b = 11000011b
-10100100b ^ 01101000b = 11001100b
-10100100b ^ 01101001b = 11001101b
-10100100b ^ 01101010b = 11001110b
-10100100b ^ 01101011b = 11001111b
-10100100b ^ 01101100b = 11001000b
-10100100b ^ 01101101b = 11001001b
-10100100b ^ 01101110b = 11001010b
-10100100b ^ 01101111b = 11001011b
-10100100b ^ 01110000b = 11010100b
-10100100b ^ 01110001b = 11010101b
-10100100b ^ 01110010b = 11010110b
-10100100b ^ 01110011b = 11010111b
-10100100b ^ 01110100b = 11010000b
-10100100b ^ 01110101b = 11010001b
-10100100b ^ 01110110b = 11010010b
-10100100b ^ 01110111b = 11010011b
-10100100b ^ 01111000b = 11011100b
-10100100b ^ 01111001b = 11011101b
-10100100b ^ 01111010b = 11011110b
-10100100b ^ 01111011b = 11011111b
-10100100b ^ 01111100b = 11011000b
-10100100b ^ 01111101b = 11011001b
-10100100b ^ 01111110b = 11011010b
-10100101b ^ 10000000b = 00100101b
-10100101b ^ 10000001b = 00100100b
-10100101b ^ 10000010b = 00100111b
-10100101b ^ 10000011b = 00100110b
-10100101b ^ 10000100b = 00100001b
-10100101b ^ 10000101b = 00100000b
-10100101b ^ 10000110b = 00100011b
-10100101b ^ 10000111b = 00100010b
-10100101b ^ 10001000b = 00101101b
-10100101b ^ 10001001b = 00101100b
-10100101b ^ 10001010b = 00101111b
-10100101b ^ 10001011b = 00101110b
-10100101b ^ 10001100b = 00101001b
-10100101b ^ 10001101b = 00101000b
-10100101b ^ 10001110b = 00101011b
-10100101b ^ 10001111b = 00101010b
-10100101b ^ 10010000b = 00110101b
-10100101b ^ 10010001b = 00110100b
-10100101b ^ 10010010b = 00110111b
-10100101b ^ 10010011b = 00110110b
-10100101b ^ 10010100b = 00110001b
-10100101b ^ 10010101b = 00110000b
-10100101b ^ 10010110b = 00110011b
-10100101b ^ 10010111b = 00110010b
-10100101b ^ 10011000b = 00111101b
-10100101b ^ 10011001b = 00111100b
-10100101b ^ 10011010b = 00111111b
-10100101b ^ 10011011b = 00111110b
-10100101b ^ 10011100b = 00111001b
-10100101b ^ 10011101b = 00111000b
-10100101b ^ 10011110b = 00111011b
-10100101b ^ 10011111b = 00111010b
-10100101b ^ 10100000b = 00000101b
-10100101b ^ 10100001b = 00000100b
-10100101b ^ 10100010b = 00000111b
-10100101b ^ 10100011b = 00000110b
-10100101b ^ 10100100b = 00000001b
-10100101b ^ 10100101b = 00000000b
-10100101b ^ 10100110b = 00000011b
-10100101b ^ 10100111b = 00000010b
-10100101b ^ 10101000b = 00001101b
-10100101b ^ 10101001b = 00001100b
-10100101b ^ 10101010b = 00001111b
-10100101b ^ 10101011b = 00001110b
-10100101b ^ 10101100b = 00001001b
-10100101b ^ 10101101b = 00001000b
-10100101b ^ 10101110b = 00001011b
-10100101b ^ 10101111b = 00001010b
-10100101b ^ 10110000b = 00010101b
-10100101b ^ 10110001b = 00010100b
-10100101b ^ 10110010b = 00010111b
-10100101b ^ 10110011b = 00010110b
-10100101b ^ 10110100b = 00010001b
-10100101b ^ 10110101b = 00010000b
-10100101b ^ 10110110b = 00010011b
-10100101b ^ 10110111b = 00010010b
-10100101b ^ 10111000b = 00011101b
-10100101b ^ 10111001b = 00011100b
-10100101b ^ 10111010b = 00011111b
-10100101b ^ 10111011b = 00011110b
-10100101b ^ 10111100b = 00011001b
-10100101b ^ 10111101b = 00011000b
-10100101b ^ 10111110b = 00011011b
-10100101b ^ 10111111b = 00011010b
-10100101b ^ 11000000b = 01100101b
-10100101b ^ 11000001b = 01100100b
-10100101b ^ 11000010b = 01100111b
-10100101b ^ 11000011b = 01100110b
-10100101b ^ 11000100b = 01100001b
-10100101b ^ 11000101b = 01100000b
-10100101b ^ 11000110b = 01100011b
-10100101b ^ 11000111b = 01100010b
-10100101b ^ 11001000b = 01101101b
-10100101b ^ 11001001b = 01101100b
-10100101b ^ 11001010b = 01101111b
-10100101b ^ 11001011b = 01101110b
-10100101b ^ 11001100b = 01101001b
-10100101b ^ 11001101b = 01101000b
-10100101b ^ 11001110b = 01101011b
-10100101b ^ 11001111b = 01101010b
-10100101b ^ 11010000b = 01110101b
-10100101b ^ 11010001b = 01110100b
-10100101b ^ 11010010b = 01110111b
-10100101b ^ 11010011b = 01110110b
-10100101b ^ 11010100b = 01110001b
-10100101b ^ 11010101b = 01110000b
-10100101b ^ 11010110b = 01110011b
-10100101b ^ 11010111b = 01110010b
-10100101b ^ 11011000b = 01111101b
-10100101b ^ 11011001b = 01111100b
-10100101b ^ 11011010b = 01111111b
-10100101b ^ 11011011b = 01111110b
-10100101b ^ 11011100b = 01111001b
-10100101b ^ 11011101b = 01111000b
-10100101b ^ 11011110b = 01111011b
-10100101b ^ 11011111b = 01111010b
-10100101b ^ 11100000b = 01000101b
-10100101b ^ 11100001b = 01000100b
-10100101b ^ 11100010b = 01000111b
-10100101b ^ 11100011b = 01000110b
-10100101b ^ 11100100b = 01000001b
-10100101b ^ 11100101b = 01000000b
-10100101b ^ 11100110b = 01000011b
-10100101b ^ 11100111b = 01000010b
-10100101b ^ 11101000b = 01001101b
-10100101b ^ 11101001b = 01001100b
-10100101b ^ 11101010b = 01001111b
-10100101b ^ 11101011b = 01001110b
-10100101b ^ 11101100b = 01001001b
-10100101b ^ 11101101b = 01001000b
-10100101b ^ 11101110b = 01001011b
-10100101b ^ 11101111b = 01001010b
-10100101b ^ 11110000b = 01010101b
-10100101b ^ 11110001b = 01010100b
-10100101b ^ 11110010b = 01010111b
-10100101b ^ 11110011b = 01010110b
-10100101b ^ 11110100b = 01010001b
-10100101b ^ 11110101b = 01010000b
-10100101b ^ 11110110b = 01010011b
-10100101b ^ 11110111b = 01010010b
-10100101b ^ 11111000b = 01011101b
-10100101b ^ 11111001b = 01011100b
-10100101b ^ 11111010b = 01011111b
-10100101b ^ 11111011b = 01011110b
-10100101b ^ 11111100b = 01011001b
-10100101b ^ 11111101b = 01011000b
-10100101b ^ 11111110b = 01011011b
-10100101b ^ 11111111b = 01011010b
-10100101b ^ 00000000b = 10100101b
-10100101b ^ 00000001b = 10100100b
-10100101b ^ 00000010b = 10100111b
-10100101b ^ 00000011b = 10100110b
-10100101b ^ 00000100b = 10100001b
-10100101b ^ 00000101b = 10100000b
-10100101b ^ 00000110b = 10100011b
-10100101b ^ 00000111b = 10100010b
-10100101b ^ 00001000b = 10101101b
-10100101b ^ 00001001b = 10101100b
-10100101b ^ 00001010b = 10101111b
-10100101b ^ 00001011b = 10101110b
-10100101b ^ 00001100b = 10101001b
-10100101b ^ 00001101b = 10101000b
-10100101b ^ 00001110b = 10101011b
-10100101b ^ 00001111b = 10101010b
-10100101b ^ 00010000b = 10110101b
-10100101b ^ 00010001b = 10110100b
-10100101b ^ 00010010b = 10110111b
-10100101b ^ 00010011b = 10110110b
-10100101b ^ 00010100b = 10110001b
-10100101b ^ 00010101b = 10110000b
-10100101b ^ 00010110b = 10110011b
-10100101b ^ 00010111b = 10110010b
-10100101b ^ 00011000b = 10111101b
-10100101b ^ 00011001b = 10111100b
-10100101b ^ 00011010b = 10111111b
-10100101b ^ 00011011b = 10111110b
-10100101b ^ 00011100b = 10111001b
-10100101b ^ 00011101b = 10111000b
-10100101b ^ 00011110b = 10111011b
-10100101b ^ 00011111b = 10111010b
-10100101b ^ 00100000b = 10000101b
-10100101b ^ 00100001b = 10000100b
-10100101b ^ 00100010b = 10000111b
-10100101b ^ 00100011b = 10000110b
-10100101b ^ 00100100b = 10000001b
-10100101b ^ 00100101b = 10000000b
-10100101b ^ 00100110b = 10000011b
-10100101b ^ 00100111b = 10000010b
-10100101b ^ 00101000b = 10001101b
-10100101b ^ 00101001b = 10001100b
-10100101b ^ 00101010b = 10001111b
-10100101b ^ 00101011b = 10001110b
-10100101b ^ 00101100b = 10001001b
-10100101b ^ 00101101b = 10001000b
-10100101b ^ 00101110b = 10001011b
-10100101b ^ 00101111b = 10001010b
-10100101b ^ 00110000b = 10010101b
-10100101b ^ 00110001b = 10010100b
-10100101b ^ 00110010b = 10010111b
-10100101b ^ 00110011b = 10010110b
-10100101b ^ 00110100b = 10010001b
-10100101b ^ 00110101b = 10010000b
-10100101b ^ 00110110b = 10010011b
-10100101b ^ 00110111b = 10010010b
-10100101b ^ 00111000b = 10011101b
-10100101b ^ 00111001b = 10011100b
-10100101b ^ 00111010b = 10011111b
-10100101b ^ 00111011b = 10011110b
-10100101b ^ 00111100b = 10011001b
-10100101b ^ 00111101b = 10011000b
-10100101b ^ 00111110b = 10011011b
-10100101b ^ 00111111b = 10011010b
-10100101b ^ 01000000b = 11100101b
-10100101b ^ 01000001b = 11100100b
-10100101b ^ 01000010b = 11100111b
-10100101b ^ 01000011b = 11100110b
-10100101b ^ 01000100b = 11100001b
-10100101b ^ 01000101b = 11100000b
-10100101b ^ 01000110b = 11100011b
-10100101b ^ 01000111b = 11100010b
-10100101b ^ 01001000b = 11101101b
-10100101b ^ 01001001b = 11101100b
-10100101b ^ 01001010b = 11101111b
-10100101b ^ 01001011b = 11101110b
-10100101b ^ 01001100b = 11101001b
-10100101b ^ 01001101b = 11101000b
-10100101b ^ 01001110b = 11101011b
-10100101b ^ 01001111b = 11101010b
-10100101b ^ 01010000b = 11110101b
-10100101b ^ 01010001b = 11110100b
-10100101b ^ 01010010b = 11110111b
-10100101b ^ 01010011b = 11110110b
-10100101b ^ 01010100b = 11110001b
-10100101b ^ 01010101b = 11110000b
-10100101b ^ 01010110b = 11110011b
-10100101b ^ 01010111b = 11110010b
-10100101b ^ 01011000b = 11111101b
-10100101b ^ 01011001b = 11111100b
-10100101b ^ 01011010b = 11111111b
-10100101b ^ 01011011b = 11111110b
-10100101b ^ 01011100b = 11111001b
-10100101b ^ 01011101b = 11111000b
-10100101b ^ 01011110b = 11111011b
-10100101b ^ 01011111b = 11111010b
-10100101b ^ 01100000b = 11000101b
-10100101b ^ 01100001b = 11000100b
-10100101b ^ 01100010b = 11000111b
-10100101b ^ 01100011b = 11000110b
-10100101b ^ 01100100b = 11000001b
-10100101b ^ 01100101b = 11000000b
-10100101b ^ 01100110b = 11000011b
-10100101b ^ 01100111b = 11000010b
-10100101b ^ 01101000b = 11001101b
-10100101b ^ 01101001b = 11001100b
-10100101b ^ 01101010b = 11001111b
-10100101b ^ 01101011b = 11001110b
-10100101b ^ 01101100b = 11001001b
-10100101b ^ 01101101b = 11001000b
-10100101b ^ 01101110b = 11001011b
-10100101b ^ 01101111b = 11001010b
-10100101b ^ 01110000b = 11010101b
-10100101b ^ 01110001b = 11010100b
-10100101b ^ 01110010b = 11010111b
-10100101b ^ 01110011b = 11010110b
-10100101b ^ 01110100b = 11010001b
-10100101b ^ 01110101b = 11010000b
-10100101b ^ 01110110b = 11010011b
-10100101b ^ 01110111b = 11010010b
-10100101b ^ 01111000b = 11011101b
-10100101b ^ 01111001b = 11011100b
-10100101b ^ 01111010b = 11011111b
-10100101b ^ 01111011b = 11011110b
-10100101b ^ 01111100b = 11011001b
-10100101b ^ 01111101b = 11011000b
-10100101b ^ 01111110b = 11011011b
-10100110b ^ 10000000b = 00100110b
-10100110b ^ 10000001b = 00100111b
-10100110b ^ 10000010b = 00100100b
-10100110b ^ 10000011b = 00100101b
-10100110b ^ 10000100b = 00100010b
-10100110b ^ 10000101b = 00100011b
-10100110b ^ 10000110b = 00100000b
-10100110b ^ 10000111b = 00100001b
-10100110b ^ 10001000b = 00101110b
-10100110b ^ 10001001b = 00101111b
-10100110b ^ 10001010b = 00101100b
-10100110b ^ 10001011b = 00101101b
-10100110b ^ 10001100b = 00101010b
-10100110b ^ 10001101b = 00101011b
-10100110b ^ 10001110b = 00101000b
-10100110b ^ 10001111b = 00101001b
-10100110b ^ 10010000b = 00110110b
-10100110b ^ 10010001b = 00110111b
-10100110b ^ 10010010b = 00110100b
-10100110b ^ 10010011b = 00110101b
-10100110b ^ 10010100b = 00110010b
-10100110b ^ 10010101b = 00110011b
-10100110b ^ 10010110b = 00110000b
-10100110b ^ 10010111b = 00110001b
-10100110b ^ 10011000b = 00111110b
-10100110b ^ 10011001b = 00111111b
-10100110b ^ 10011010b = 00111100b
-10100110b ^ 10011011b = 00111101b
-10100110b ^ 10011100b = 00111010b
-10100110b ^ 10011101b = 00111011b
-10100110b ^ 10011110b = 00111000b
-10100110b ^ 10011111b = 00111001b
-10100110b ^ 10100000b = 00000110b
-10100110b ^ 10100001b = 00000111b
-10100110b ^ 10100010b = 00000100b
-10100110b ^ 10100011b = 00000101b
-10100110b ^ 10100100b = 00000010b
-10100110b ^ 10100101b = 00000011b
-10100110b ^ 10100110b = 00000000b
-10100110b ^ 10100111b = 00000001b
-10100110b ^ 10101000b = 00001110b
-10100110b ^ 10101001b = 00001111b
-10100110b ^ 10101010b = 00001100b
-10100110b ^ 10101011b = 00001101b
-10100110b ^ 10101100b = 00001010b
-10100110b ^ 10101101b = 00001011b
-10100110b ^ 10101110b = 00001000b
-10100110b ^ 10101111b = 00001001b
-10100110b ^ 10110000b = 00010110b
-10100110b ^ 10110001b = 00010111b
-10100110b ^ 10110010b = 00010100b
-10100110b ^ 10110011b = 00010101b
-10100110b ^ 10110100b = 00010010b
-10100110b ^ 10110101b = 00010011b
-10100110b ^ 10110110b = 00010000b
-10100110b ^ 10110111b = 00010001b
-10100110b ^ 10111000b = 00011110b
-10100110b ^ 10111001b = 00011111b
-10100110b ^ 10111010b = 00011100b
-10100110b ^ 10111011b = 00011101b
-10100110b ^ 10111100b = 00011010b
-10100110b ^ 10111101b = 00011011b
-10100110b ^ 10111110b = 00011000b
-10100110b ^ 10111111b = 00011001b
-10100110b ^ 11000000b = 01100110b
-10100110b ^ 11000001b = 01100111b
-10100110b ^ 11000010b = 01100100b
-10100110b ^ 11000011b = 01100101b
-10100110b ^ 11000100b = 01100010b
-10100110b ^ 11000101b = 01100011b
-10100110b ^ 11000110b = 01100000b
-10100110b ^ 11000111b = 01100001b
-10100110b ^ 11001000b = 01101110b
-10100110b ^ 11001001b = 01101111b
-10100110b ^ 11001010b = 01101100b
-10100110b ^ 11001011b = 01101101b
-10100110b ^ 11001100b = 01101010b
-10100110b ^ 11001101b = 01101011b
-10100110b ^ 11001110b = 01101000b
-10100110b ^ 11001111b = 01101001b
-10100110b ^ 11010000b = 01110110b
-10100110b ^ 11010001b = 01110111b
-10100110b ^ 11010010b = 01110100b
-10100110b ^ 11010011b = 01110101b
-10100110b ^ 11010100b = 01110010b
-10100110b ^ 11010101b = 01110011b
-10100110b ^ 11010110b = 01110000b
-10100110b ^ 11010111b = 01110001b
-10100110b ^ 11011000b = 01111110b
-10100110b ^ 11011001b = 01111111b
-10100110b ^ 11011010b = 01111100b
-10100110b ^ 11011011b = 01111101b
-10100110b ^ 11011100b = 01111010b
-10100110b ^ 11011101b = 01111011b
-10100110b ^ 11011110b = 01111000b
-10100110b ^ 11011111b = 01111001b
-10100110b ^ 11100000b = 01000110b
-10100110b ^ 11100001b = 01000111b
-10100110b ^ 11100010b = 01000100b
-10100110b ^ 11100011b = 01000101b
-10100110b ^ 11100100b = 01000010b
-10100110b ^ 11100101b = 01000011b
-10100110b ^ 11100110b = 01000000b
-10100110b ^ 11100111b = 01000001b
-10100110b ^ 11101000b = 01001110b
-10100110b ^ 11101001b = 01001111b
-10100110b ^ 11101010b = 01001100b
-10100110b ^ 11101011b = 01001101b
-10100110b ^ 11101100b = 01001010b
-10100110b ^ 11101101b = 01001011b
-10100110b ^ 11101110b = 01001000b
-10100110b ^ 11101111b = 01001001b
-10100110b ^ 11110000b = 01010110b
-10100110b ^ 11110001b = 01010111b
-10100110b ^ 11110010b = 01010100b
-10100110b ^ 11110011b = 01010101b
-10100110b ^ 11110100b = 01010010b
-10100110b ^ 11110101b = 01010011b
-10100110b ^ 11110110b = 01010000b
-10100110b ^ 11110111b = 01010001b
-10100110b ^ 11111000b = 01011110b
-10100110b ^ 11111001b = 01011111b
-10100110b ^ 11111010b = 01011100b
-10100110b ^ 11111011b = 01011101b
-10100110b ^ 11111100b = 01011010b
-10100110b ^ 11111101b = 01011011b
-10100110b ^ 11111110b = 01011000b
-10100110b ^ 11111111b = 01011001b
-10100110b ^ 00000000b = 10100110b
-10100110b ^ 00000001b = 10100111b
-10100110b ^ 00000010b = 10100100b
-10100110b ^ 00000011b = 10100101b
-10100110b ^ 00000100b = 10100010b
-10100110b ^ 00000101b = 10100011b
-10100110b ^ 00000110b = 10100000b
-10100110b ^ 00000111b = 10100001b
-10100110b ^ 00001000b = 10101110b
-10100110b ^ 00001001b = 10101111b
-10100110b ^ 00001010b = 10101100b
-10100110b ^ 00001011b = 10101101b
-10100110b ^ 00001100b = 10101010b
-10100110b ^ 00001101b = 10101011b
-10100110b ^ 00001110b = 10101000b
-10100110b ^ 00001111b = 10101001b
-10100110b ^ 00010000b = 10110110b
-10100110b ^ 00010001b = 10110111b
-10100110b ^ 00010010b = 10110100b
-10100110b ^ 00010011b = 10110101b
-10100110b ^ 00010100b = 10110010b
-10100110b ^ 00010101b = 10110011b
-10100110b ^ 00010110b = 10110000b
-10100110b ^ 00010111b = 10110001b
-10100110b ^ 00011000b = 10111110b
-10100110b ^ 00011001b = 10111111b
-10100110b ^ 00011010b = 10111100b
-10100110b ^ 00011011b = 10111101b
-10100110b ^ 00011100b = 10111010b
-10100110b ^ 00011101b = 10111011b
-10100110b ^ 00011110b = 10111000b
-10100110b ^ 00011111b = 10111001b
-10100110b ^ 00100000b = 10000110b
-10100110b ^ 00100001b = 10000111b
-10100110b ^ 00100010b = 10000100b
-10100110b ^ 00100011b = 10000101b
-10100110b ^ 00100100b = 10000010b
-10100110b ^ 00100101b = 10000011b
-10100110b ^ 00100110b = 10000000b
-10100110b ^ 00100111b = 10000001b
-10100110b ^ 00101000b = 10001110b
-10100110b ^ 00101001b = 10001111b
-10100110b ^ 00101010b = 10001100b
-10100110b ^ 00101011b = 10001101b
-10100110b ^ 00101100b = 10001010b
-10100110b ^ 00101101b = 10001011b
-10100110b ^ 00101110b = 10001000b
-10100110b ^ 00101111b = 10001001b
-10100110b ^ 00110000b = 10010110b
-10100110b ^ 00110001b = 10010111b
-10100110b ^ 00110010b = 10010100b
-10100110b ^ 00110011b = 10010101b
-10100110b ^ 00110100b = 10010010b
-10100110b ^ 00110101b = 10010011b
-10100110b ^ 00110110b = 10010000b
-10100110b ^ 00110111b = 10010001b
-10100110b ^ 00111000b = 10011110b
-10100110b ^ 00111001b = 10011111b
-10100110b ^ 00111010b = 10011100b
-10100110b ^ 00111011b = 10011101b
-10100110b ^ 00111100b = 10011010b
-10100110b ^ 00111101b = 10011011b
-10100110b ^ 00111110b = 10011000b
-10100110b ^ 00111111b = 10011001b
-10100110b ^ 01000000b = 11100110b
-10100110b ^ 01000001b = 11100111b
-10100110b ^ 01000010b = 11100100b
-10100110b ^ 01000011b = 11100101b
-10100110b ^ 01000100b = 11100010b
-10100110b ^ 01000101b = 11100011b
-10100110b ^ 01000110b = 11100000b
-10100110b ^ 01000111b = 11100001b
-10100110b ^ 01001000b = 11101110b
-10100110b ^ 01001001b = 11101111b
-10100110b ^ 01001010b = 11101100b
-10100110b ^ 01001011b = 11101101b
-10100110b ^ 01001100b = 11101010b
-10100110b ^ 01001101b = 11101011b
-10100110b ^ 01001110b = 11101000b
-10100110b ^ 01001111b = 11101001b
-10100110b ^ 01010000b = 11110110b
-10100110b ^ 01010001b = 11110111b
-10100110b ^ 01010010b = 11110100b
-10100110b ^ 01010011b = 11110101b
-10100110b ^ 01010100b = 11110010b
-10100110b ^ 01010101b = 11110011b
-10100110b ^ 01010110b = 11110000b
-10100110b ^ 01010111b = 11110001b
-10100110b ^ 01011000b = 11111110b
-10100110b ^ 01011001b = 11111111b
-10100110b ^ 01011010b = 11111100b
-10100110b ^ 01011011b = 11111101b
-10100110b ^ 01011100b = 11111010b
-10100110b ^ 01011101b = 11111011b
-10100110b ^ 01011110b = 11111000b
-10100110b ^ 01011111b = 11111001b
-10100110b ^ 01100000b = 11000110b
-10100110b ^ 01100001b = 11000111b
-10100110b ^ 01100010b = 11000100b
-10100110b ^ 01100011b = 11000101b
-10100110b ^ 01100100b = 11000010b
-10100110b ^ 01100101b = 11000011b
-10100110b ^ 01100110b = 11000000b
-10100110b ^ 01100111b = 11000001b
-10100110b ^ 01101000b = 11001110b
-10100110b ^ 01101001b = 11001111b
-10100110b ^ 01101010b = 11001100b
-10100110b ^ 01101011b = 11001101b
-10100110b ^ 01101100b = 11001010b
-10100110b ^ 01101101b = 11001011b
-10100110b ^ 01101110b = 11001000b
-10100110b ^ 01101111b = 11001001b
-10100110b ^ 01110000b = 11010110b
-10100110b ^ 01110001b = 11010111b
-10100110b ^ 01110010b = 11010100b
-10100110b ^ 01110011b = 11010101b
-10100110b ^ 01110100b = 11010010b
-10100110b ^ 01110101b = 11010011b
-10100110b ^ 01110110b = 11010000b
-10100110b ^ 01110111b = 11010001b
-10100110b ^ 01111000b = 11011110b
-10100110b ^ 01111001b = 11011111b
-10100110b ^ 01111010b = 11011100b
-10100110b ^ 01111011b = 11011101b
-10100110b ^ 01111100b = 11011010b
-10100110b ^ 01111101b = 11011011b
-10100110b ^ 01111110b = 11011000b
-10100111b ^ 10000000b = 00100111b
-10100111b ^ 10000001b = 00100110b
-10100111b ^ 10000010b = 00100101b
-10100111b ^ 10000011b = 00100100b
-10100111b ^ 10000100b = 00100011b
-10100111b ^ 10000101b = 00100010b
-10100111b ^ 10000110b = 00100001b
-10100111b ^ 10000111b = 00100000b
-10100111b ^ 10001000b = 00101111b
-10100111b ^ 10001001b = 00101110b
-10100111b ^ 10001010b = 00101101b
-10100111b ^ 10001011b = 00101100b
-10100111b ^ 10001100b = 00101011b
-10100111b ^ 10001101b = 00101010b
-10100111b ^ 10001110b = 00101001b
-10100111b ^ 10001111b = 00101000b
-10100111b ^ 10010000b = 00110111b
-10100111b ^ 10010001b = 00110110b
-10100111b ^ 10010010b = 00110101b
-10100111b ^ 10010011b = 00110100b
-10100111b ^ 10010100b = 00110011b
-10100111b ^ 10010101b = 00110010b
-10100111b ^ 10010110b = 00110001b
-10100111b ^ 10010111b = 00110000b
-10100111b ^ 10011000b = 00111111b
-10100111b ^ 10011001b = 00111110b
-10100111b ^ 10011010b = 00111101b
-10100111b ^ 10011011b = 00111100b
-10100111b ^ 10011100b = 00111011b
-10100111b ^ 10011101b = 00111010b
-10100111b ^ 10011110b = 00111001b
-10100111b ^ 10011111b = 00111000b
-10100111b ^ 10100000b = 00000111b
-10100111b ^ 10100001b = 00000110b
-10100111b ^ 10100010b = 00000101b
-10100111b ^ 10100011b = 00000100b
-10100111b ^ 10100100b = 00000011b
-10100111b ^ 10100101b = 00000010b
-10100111b ^ 10100110b = 00000001b
-10100111b ^ 10100111b = 00000000b
-10100111b ^ 10101000b = 00001111b
-10100111b ^ 10101001b = 00001110b
-10100111b ^ 10101010b = 00001101b
-10100111b ^ 10101011b = 00001100b
-10100111b ^ 10101100b = 00001011b
-10100111b ^ 10101101b = 00001010b
-10100111b ^ 10101110b = 00001001b
-10100111b ^ 10101111b = 00001000b
-10100111b ^ 10110000b = 00010111b
-10100111b ^ 10110001b = 00010110b
-10100111b ^ 10110010b = 00010101b
-10100111b ^ 10110011b = 00010100b
-10100111b ^ 10110100b = 00010011b
-10100111b ^ 10110101b = 00010010b
-10100111b ^ 10110110b = 00010001b
-10100111b ^ 10110111b = 00010000b
-10100111b ^ 10111000b = 00011111b
-10100111b ^ 10111001b = 00011110b
-10100111b ^ 10111010b = 00011101b
-10100111b ^ 10111011b = 00011100b
-10100111b ^ 10111100b = 00011011b
-10100111b ^ 10111101b = 00011010b
-10100111b ^ 10111110b = 00011001b
-10100111b ^ 10111111b = 00011000b
-10100111b ^ 11000000b = 01100111b
-10100111b ^ 11000001b = 01100110b
-10100111b ^ 11000010b = 01100101b
-10100111b ^ 11000011b = 01100100b
-10100111b ^ 11000100b = 01100011b
-10100111b ^ 11000101b = 01100010b
-10100111b ^ 11000110b = 01100001b
-10100111b ^ 11000111b = 01100000b
-10100111b ^ 11001000b = 01101111b
-10100111b ^ 11001001b = 01101110b
-10100111b ^ 11001010b = 01101101b
-10100111b ^ 11001011b = 01101100b
-10100111b ^ 11001100b = 01101011b
-10100111b ^ 11001101b = 01101010b
-10100111b ^ 11001110b = 01101001b
-10100111b ^ 11001111b = 01101000b
-10100111b ^ 11010000b = 01110111b
-10100111b ^ 11010001b = 01110110b
-10100111b ^ 11010010b = 01110101b
-10100111b ^ 11010011b = 01110100b
-10100111b ^ 11010100b = 01110011b
-10100111b ^ 11010101b = 01110010b
-10100111b ^ 11010110b = 01110001b
-10100111b ^ 11010111b = 01110000b
-10100111b ^ 11011000b = 01111111b
-10100111b ^ 11011001b = 01111110b
-10100111b ^ 11011010b = 01111101b
-10100111b ^ 11011011b = 01111100b
-10100111b ^ 11011100b = 01111011b
-10100111b ^ 11011101b = 01111010b
-10100111b ^ 11011110b = 01111001b
-10100111b ^ 11011111b = 01111000b
-10100111b ^ 11100000b = 01000111b
-10100111b ^ 11100001b = 01000110b
-10100111b ^ 11100010b = 01000101b
-10100111b ^ 11100011b = 01000100b
-10100111b ^ 11100100b = 01000011b
-10100111b ^ 11100101b = 01000010b
-10100111b ^ 11100110b = 01000001b
-10100111b ^ 11100111b = 01000000b
-10100111b ^ 11101000b = 01001111b
-10100111b ^ 11101001b = 01001110b
-10100111b ^ 11101010b = 01001101b
-10100111b ^ 11101011b = 01001100b
-10100111b ^ 11101100b = 01001011b
-10100111b ^ 11101101b = 01001010b
-10100111b ^ 11101110b = 01001001b
-10100111b ^ 11101111b = 01001000b
-10100111b ^ 11110000b = 01010111b
-10100111b ^ 11110001b = 01010110b
-10100111b ^ 11110010b = 01010101b
-10100111b ^ 11110011b = 01010100b
-10100111b ^ 11110100b = 01010011b
-10100111b ^ 11110101b = 01010010b
-10100111b ^ 11110110b = 01010001b
-10100111b ^ 11110111b = 01010000b
-10100111b ^ 11111000b = 01011111b
-10100111b ^ 11111001b = 01011110b
-10100111b ^ 11111010b = 01011101b
-10100111b ^ 11111011b = 01011100b
-10100111b ^ 11111100b = 01011011b
-10100111b ^ 11111101b = 01011010b
-10100111b ^ 11111110b = 01011001b
-10100111b ^ 11111111b = 01011000b
-10100111b ^ 00000000b = 10100111b
-10100111b ^ 00000001b = 10100110b
-10100111b ^ 00000010b = 10100101b
-10100111b ^ 00000011b = 10100100b
-10100111b ^ 00000100b = 10100011b
-10100111b ^ 00000101b = 10100010b
-10100111b ^ 00000110b = 10100001b
-10100111b ^ 00000111b = 10100000b
-10100111b ^ 00001000b = 10101111b
-10100111b ^ 00001001b = 10101110b
-10100111b ^ 00001010b = 10101101b
-10100111b ^ 00001011b = 10101100b
-10100111b ^ 00001100b = 10101011b
-10100111b ^ 00001101b = 10101010b
-10100111b ^ 00001110b = 10101001b
-10100111b ^ 00001111b = 10101000b
-10100111b ^ 00010000b = 10110111b
-10100111b ^ 00010001b = 10110110b
-10100111b ^ 00010010b = 10110101b
-10100111b ^ 00010011b = 10110100b
-10100111b ^ 00010100b = 10110011b
-10100111b ^ 00010101b = 10110010b
-10100111b ^ 00010110b = 10110001b
-10100111b ^ 00010111b = 10110000b
-10100111b ^ 00011000b = 10111111b
-10100111b ^ 00011001b = 10111110b
-10100111b ^ 00011010b = 10111101b
-10100111b ^ 00011011b = 10111100b
-10100111b ^ 00011100b = 10111011b
-10100111b ^ 00011101b = 10111010b
-10100111b ^ 00011110b = 10111001b
-10100111b ^ 00011111b = 10111000b
-10100111b ^ 00100000b = 10000111b
-10100111b ^ 00100001b = 10000110b
-10100111b ^ 00100010b = 10000101b
-10100111b ^ 00100011b = 10000100b
-10100111b ^ 00100100b = 10000011b
-10100111b ^ 00100101b = 10000010b
-10100111b ^ 00100110b = 10000001b
-10100111b ^ 00100111b = 10000000b
-10100111b ^ 00101000b = 10001111b
-10100111b ^ 00101001b = 10001110b
-10100111b ^ 00101010b = 10001101b
-10100111b ^ 00101011b = 10001100b
-10100111b ^ 00101100b = 10001011b
-10100111b ^ 00101101b = 10001010b
-10100111b ^ 00101110b = 10001001b
-10100111b ^ 00101111b = 10001000b
-10100111b ^ 00110000b = 10010111b
-10100111b ^ 00110001b = 10010110b
-10100111b ^ 00110010b = 10010101b
-10100111b ^ 00110011b = 10010100b
-10100111b ^ 00110100b = 10010011b
-10100111b ^ 00110101b = 10010010b
-10100111b ^ 00110110b = 10010001b
-10100111b ^ 00110111b = 10010000b
-10100111b ^ 00111000b = 10011111b
-10100111b ^ 00111001b = 10011110b
-10100111b ^ 00111010b = 10011101b
-10100111b ^ 00111011b = 10011100b
-10100111b ^ 00111100b = 10011011b
-10100111b ^ 00111101b = 10011010b
-10100111b ^ 00111110b = 10011001b
-10100111b ^ 00111111b = 10011000b
-10100111b ^ 01000000b = 11100111b
-10100111b ^ 01000001b = 11100110b
-10100111b ^ 01000010b = 11100101b
-10100111b ^ 01000011b = 11100100b
-10100111b ^ 01000100b = 11100011b
-10100111b ^ 01000101b = 11100010b
-10100111b ^ 01000110b = 11100001b
-10100111b ^ 01000111b = 11100000b
-10100111b ^ 01001000b = 11101111b
-10100111b ^ 01001001b = 11101110b
-10100111b ^ 01001010b = 11101101b
-10100111b ^ 01001011b = 11101100b
-10100111b ^ 01001100b = 11101011b
-10100111b ^ 01001101b = 11101010b
-10100111b ^ 01001110b = 11101001b
-10100111b ^ 01001111b = 11101000b
-10100111b ^ 01010000b = 11110111b
-10100111b ^ 01010001b = 11110110b
-10100111b ^ 01010010b = 11110101b
-10100111b ^ 01010011b = 11110100b
-10100111b ^ 01010100b = 11110011b
-10100111b ^ 01010101b = 11110010b
-10100111b ^ 01010110b = 11110001b
-10100111b ^ 01010111b = 11110000b
-10100111b ^ 01011000b = 11111111b
-10100111b ^ 01011001b = 11111110b
-10100111b ^ 01011010b = 11111101b
-10100111b ^ 01011011b = 11111100b
-10100111b ^ 01011100b = 11111011b
-10100111b ^ 01011101b = 11111010b
-10100111b ^ 01011110b = 11111001b
-10100111b ^ 01011111b = 11111000b
-10100111b ^ 01100000b = 11000111b
-10100111b ^ 01100001b = 11000110b
-10100111b ^ 01100010b = 11000101b
-10100111b ^ 01100011b = 11000100b
-10100111b ^ 01100100b = 11000011b
-10100111b ^ 01100101b = 11000010b
-10100111b ^ 01100110b = 11000001b
-10100111b ^ 01100111b = 11000000b
-10100111b ^ 01101000b = 11001111b
-10100111b ^ 01101001b = 11001110b
-10100111b ^ 01101010b = 11001101b
-10100111b ^ 01101011b = 11001100b
-10100111b ^ 01101100b = 11001011b
-10100111b ^ 01101101b = 11001010b
-10100111b ^ 01101110b = 11001001b
-10100111b ^ 01101111b = 11001000b
-10100111b ^ 01110000b = 11010111b
-10100111b ^ 01110001b = 11010110b
-10100111b ^ 01110010b = 11010101b
-10100111b ^ 01110011b = 11010100b
-10100111b ^ 01110100b = 11010011b
-10100111b ^ 01110101b = 11010010b
-10100111b ^ 01110110b = 11010001b
-10100111b ^ 01110111b = 11010000b
-10100111b ^ 01111000b = 11011111b
-10100111b ^ 01111001b = 11011110b
-10100111b ^ 01111010b = 11011101b
-10100111b ^ 01111011b = 11011100b
-10100111b ^ 01111100b = 11011011b
-10100111b ^ 01111101b = 11011010b
-10100111b ^ 01111110b = 11011001b
-10101000b ^ 10000000b = 00101000b
-10101000b ^ 10000001b = 00101001b
-10101000b ^ 10000010b = 00101010b
-10101000b ^ 10000011b = 00101011b
-10101000b ^ 10000100b = 00101100b
-10101000b ^ 10000101b = 00101101b
-10101000b ^ 10000110b = 00101110b
-10101000b ^ 10000111b = 00101111b
-10101000b ^ 10001000b = 00100000b
-10101000b ^ 10001001b = 00100001b
-10101000b ^ 10001010b = 00100010b
-10101000b ^ 10001011b = 00100011b
-10101000b ^ 10001100b = 00100100b
-10101000b ^ 10001101b = 00100101b
-10101000b ^ 10001110b = 00100110b
-10101000b ^ 10001111b = 00100111b
-10101000b ^ 10010000b = 00111000b
-10101000b ^ 10010001b = 00111001b
-10101000b ^ 10010010b = 00111010b
-10101000b ^ 10010011b = 00111011b
-10101000b ^ 10010100b = 00111100b
-10101000b ^ 10010101b = 00111101b
-10101000b ^ 10010110b = 00111110b
-10101000b ^ 10010111b = 00111111b
-10101000b ^ 10011000b = 00110000b
-10101000b ^ 10011001b = 00110001b
-10101000b ^ 10011010b = 00110010b
-10101000b ^ 10011011b = 00110011b
-10101000b ^ 10011100b = 00110100b
-10101000b ^ 10011101b = 00110101b
-10101000b ^ 10011110b = 00110110b
-10101000b ^ 10011111b = 00110111b
-10101000b ^ 10100000b = 00001000b
-10101000b ^ 10100001b = 00001001b
-10101000b ^ 10100010b = 00001010b
-10101000b ^ 10100011b = 00001011b
-10101000b ^ 10100100b = 00001100b
-10101000b ^ 10100101b = 00001101b
-10101000b ^ 10100110b = 00001110b
-10101000b ^ 10100111b = 00001111b
-10101000b ^ 10101000b = 00000000b
-10101000b ^ 10101001b = 00000001b
-10101000b ^ 10101010b = 00000010b
-10101000b ^ 10101011b = 00000011b
-10101000b ^ 10101100b = 00000100b
-10101000b ^ 10101101b = 00000101b
-10101000b ^ 10101110b = 00000110b
-10101000b ^ 10101111b = 00000111b
-10101000b ^ 10110000b = 00011000b
-10101000b ^ 10110001b = 00011001b
-10101000b ^ 10110010b = 00011010b
-10101000b ^ 10110011b = 00011011b
-10101000b ^ 10110100b = 00011100b
-10101000b ^ 10110101b = 00011101b
-10101000b ^ 10110110b = 00011110b
-10101000b ^ 10110111b = 00011111b
-10101000b ^ 10111000b = 00010000b
-10101000b ^ 10111001b = 00010001b
-10101000b ^ 10111010b = 00010010b
-10101000b ^ 10111011b = 00010011b
-10101000b ^ 10111100b = 00010100b
-10101000b ^ 10111101b = 00010101b
-10101000b ^ 10111110b = 00010110b
-10101000b ^ 10111111b = 00010111b
-10101000b ^ 11000000b = 01101000b
-10101000b ^ 11000001b = 01101001b
-10101000b ^ 11000010b = 01101010b
-10101000b ^ 11000011b = 01101011b
-10101000b ^ 11000100b = 01101100b
-10101000b ^ 11000101b = 01101101b
-10101000b ^ 11000110b = 01101110b
-10101000b ^ 11000111b = 01101111b
-10101000b ^ 11001000b = 01100000b
-10101000b ^ 11001001b = 01100001b
-10101000b ^ 11001010b = 01100010b
-10101000b ^ 11001011b = 01100011b
-10101000b ^ 11001100b = 01100100b
-10101000b ^ 11001101b = 01100101b
-10101000b ^ 11001110b = 01100110b
-10101000b ^ 11001111b = 01100111b
-10101000b ^ 11010000b = 01111000b
-10101000b ^ 11010001b = 01111001b
-10101000b ^ 11010010b = 01111010b
-10101000b ^ 11010011b = 01111011b
-10101000b ^ 11010100b = 01111100b
-10101000b ^ 11010101b = 01111101b
-10101000b ^ 11010110b = 01111110b
-10101000b ^ 11010111b = 01111111b
-10101000b ^ 11011000b = 01110000b
-10101000b ^ 11011001b = 01110001b
-10101000b ^ 11011010b = 01110010b
-10101000b ^ 11011011b = 01110011b
-10101000b ^ 11011100b = 01110100b
-10101000b ^ 11011101b = 01110101b
-10101000b ^ 11011110b = 01110110b
-10101000b ^ 11011111b = 01110111b
-10101000b ^ 11100000b = 01001000b
-10101000b ^ 11100001b = 01001001b
-10101000b ^ 11100010b = 01001010b
-10101000b ^ 11100011b = 01001011b
-10101000b ^ 11100100b = 01001100b
-10101000b ^ 11100101b = 01001101b
-10101000b ^ 11100110b = 01001110b
-10101000b ^ 11100111b = 01001111b
-10101000b ^ 11101000b = 01000000b
-10101000b ^ 11101001b = 01000001b
-10101000b ^ 11101010b = 01000010b
-10101000b ^ 11101011b = 01000011b
-10101000b ^ 11101100b = 01000100b
-10101000b ^ 11101101b = 01000101b
-10101000b ^ 11101110b = 01000110b
-10101000b ^ 11101111b = 01000111b
-10101000b ^ 11110000b = 01011000b
-10101000b ^ 11110001b = 01011001b
-10101000b ^ 11110010b = 01011010b
-10101000b ^ 11110011b = 01011011b
-10101000b ^ 11110100b = 01011100b
-10101000b ^ 11110101b = 01011101b
-10101000b ^ 11110110b = 01011110b
-10101000b ^ 11110111b = 01011111b
-10101000b ^ 11111000b = 01010000b
-10101000b ^ 11111001b = 01010001b
-10101000b ^ 11111010b = 01010010b
-10101000b ^ 11111011b = 01010011b
-10101000b ^ 11111100b = 01010100b
-10101000b ^ 11111101b = 01010101b
-10101000b ^ 11111110b = 01010110b
-10101000b ^ 11111111b = 01010111b
-10101000b ^ 00000000b = 10101000b
-10101000b ^ 00000001b = 10101001b
-10101000b ^ 00000010b = 10101010b
-10101000b ^ 00000011b = 10101011b
-10101000b ^ 00000100b = 10101100b
-10101000b ^ 00000101b = 10101101b
-10101000b ^ 00000110b = 10101110b
-10101000b ^ 00000111b = 10101111b
-10101000b ^ 00001000b = 10100000b
-10101000b ^ 00001001b = 10100001b
-10101000b ^ 00001010b = 10100010b
-10101000b ^ 00001011b = 10100011b
-10101000b ^ 00001100b = 10100100b
-10101000b ^ 00001101b = 10100101b
-10101000b ^ 00001110b = 10100110b
-10101000b ^ 00001111b = 10100111b
-10101000b ^ 00010000b = 10111000b
-10101000b ^ 00010001b = 10111001b
-10101000b ^ 00010010b = 10111010b
-10101000b ^ 00010011b = 10111011b
-10101000b ^ 00010100b = 10111100b
-10101000b ^ 00010101b = 10111101b
-10101000b ^ 00010110b = 10111110b
-10101000b ^ 00010111b = 10111111b
-10101000b ^ 00011000b = 10110000b
-10101000b ^ 00011001b = 10110001b
-10101000b ^ 00011010b = 10110010b
-10101000b ^ 00011011b = 10110011b
-10101000b ^ 00011100b = 10110100b
-10101000b ^ 00011101b = 10110101b
-10101000b ^ 00011110b = 10110110b
-10101000b ^ 00011111b = 10110111b
-10101000b ^ 00100000b = 10001000b
-10101000b ^ 00100001b = 10001001b
-10101000b ^ 00100010b = 10001010b
-10101000b ^ 00100011b = 10001011b
-10101000b ^ 00100100b = 10001100b
-10101000b ^ 00100101b = 10001101b
-10101000b ^ 00100110b = 10001110b
-10101000b ^ 00100111b = 10001111b
-10101000b ^ 00101000b = 10000000b
-10101000b ^ 00101001b = 10000001b
-10101000b ^ 00101010b = 10000010b
-10101000b ^ 00101011b = 10000011b
-10101000b ^ 00101100b = 10000100b
-10101000b ^ 00101101b = 10000101b
-10101000b ^ 00101110b = 10000110b
-10101000b ^ 00101111b = 10000111b
-10101000b ^ 00110000b = 10011000b
-10101000b ^ 00110001b = 10011001b
-10101000b ^ 00110010b = 10011010b
-10101000b ^ 00110011b = 10011011b
-10101000b ^ 00110100b = 10011100b
-10101000b ^ 00110101b = 10011101b
-10101000b ^ 00110110b = 10011110b
-10101000b ^ 00110111b = 10011111b
-10101000b ^ 00111000b = 10010000b
-10101000b ^ 00111001b = 10010001b
-10101000b ^ 00111010b = 10010010b
-10101000b ^ 00111011b = 10010011b
-10101000b ^ 00111100b = 10010100b
-10101000b ^ 00111101b = 10010101b
-10101000b ^ 00111110b = 10010110b
-10101000b ^ 00111111b = 10010111b
-10101000b ^ 01000000b = 11101000b
-10101000b ^ 01000001b = 11101001b
-10101000b ^ 01000010b = 11101010b
-10101000b ^ 01000011b = 11101011b
-10101000b ^ 01000100b = 11101100b
-10101000b ^ 01000101b = 11101101b
-10101000b ^ 01000110b = 11101110b
-10101000b ^ 01000111b = 11101111b
-10101000b ^ 01001000b = 11100000b
-10101000b ^ 01001001b = 11100001b
-10101000b ^ 01001010b = 11100010b
-10101000b ^ 01001011b = 11100011b
-10101000b ^ 01001100b = 11100100b
-10101000b ^ 01001101b = 11100101b
-10101000b ^ 01001110b = 11100110b
-10101000b ^ 01001111b = 11100111b
-10101000b ^ 01010000b = 11111000b
-10101000b ^ 01010001b = 11111001b
-10101000b ^ 01010010b = 11111010b
-10101000b ^ 01010011b = 11111011b
-10101000b ^ 01010100b = 11111100b
-10101000b ^ 01010101b = 11111101b
-10101000b ^ 01010110b = 11111110b
-10101000b ^ 01010111b = 11111111b
-10101000b ^ 01011000b = 11110000b
-10101000b ^ 01011001b = 11110001b
-10101000b ^ 01011010b = 11110010b
-10101000b ^ 01011011b = 11110011b
-10101000b ^ 01011100b = 11110100b
-10101000b ^ 01011101b = 11110101b
-10101000b ^ 01011110b = 11110110b
-10101000b ^ 01011111b = 11110111b
-10101000b ^ 01100000b = 11001000b
-10101000b ^ 01100001b = 11001001b
-10101000b ^ 01100010b = 11001010b
-10101000b ^ 01100011b = 11001011b
-10101000b ^ 01100100b = 11001100b
-10101000b ^ 01100101b = 11001101b
-10101000b ^ 01100110b = 11001110b
-10101000b ^ 01100111b = 11001111b
-10101000b ^ 01101000b = 11000000b
-10101000b ^ 01101001b = 11000001b
-10101000b ^ 01101010b = 11000010b
-10101000b ^ 01101011b = 11000011b
-10101000b ^ 01101100b = 11000100b
-10101000b ^ 01101101b = 11000101b
-10101000b ^ 01101110b = 11000110b
-10101000b ^ 01101111b = 11000111b
-10101000b ^ 01110000b = 11011000b
-10101000b ^ 01110001b = 11011001b
-10101000b ^ 01110010b = 11011010b
-10101000b ^ 01110011b = 11011011b
-10101000b ^ 01110100b = 11011100b
-10101000b ^ 01110101b = 11011101b
-10101000b ^ 01110110b = 11011110b
-10101000b ^ 01110111b = 11011111b
-10101000b ^ 01111000b = 11010000b
-10101000b ^ 01111001b = 11010001b
-10101000b ^ 01111010b = 11010010b
-10101000b ^ 01111011b = 11010011b
-10101000b ^ 01111100b = 11010100b
-10101000b ^ 01111101b = 11010101b
-10101000b ^ 01111110b = 11010110b
-10101001b ^ 10000000b = 00101001b
-10101001b ^ 10000001b = 00101000b
-10101001b ^ 10000010b = 00101011b
-10101001b ^ 10000011b = 00101010b
-10101001b ^ 10000100b = 00101101b
-10101001b ^ 10000101b = 00101100b
-10101001b ^ 10000110b = 00101111b
-10101001b ^ 10000111b = 00101110b
-10101001b ^ 10001000b = 00100001b
-10101001b ^ 10001001b = 00100000b
-10101001b ^ 10001010b = 00100011b
-10101001b ^ 10001011b = 00100010b
-10101001b ^ 10001100b = 00100101b
-10101001b ^ 10001101b = 00100100b
-10101001b ^ 10001110b = 00100111b
-10101001b ^ 10001111b = 00100110b
-10101001b ^ 10010000b = 00111001b
-10101001b ^ 10010001b = 00111000b
-10101001b ^ 10010010b = 00111011b
-10101001b ^ 10010011b = 00111010b
-10101001b ^ 10010100b = 00111101b
-10101001b ^ 10010101b = 00111100b
-10101001b ^ 10010110b = 00111111b
-10101001b ^ 10010111b = 00111110b
-10101001b ^ 10011000b = 00110001b
-10101001b ^ 10011001b = 00110000b
-10101001b ^ 10011010b = 00110011b
-10101001b ^ 10011011b = 00110010b
-10101001b ^ 10011100b = 00110101b
-10101001b ^ 10011101b = 00110100b
-10101001b ^ 10011110b = 00110111b
-10101001b ^ 10011111b = 00110110b
-10101001b ^ 10100000b = 00001001b
-10101001b ^ 10100001b = 00001000b
-10101001b ^ 10100010b = 00001011b
-10101001b ^ 10100011b = 00001010b
-10101001b ^ 10100100b = 00001101b
-10101001b ^ 10100101b = 00001100b
-10101001b ^ 10100110b = 00001111b
-10101001b ^ 10100111b = 00001110b
-10101001b ^ 10101000b = 00000001b
-10101001b ^ 10101001b = 00000000b
-10101001b ^ 10101010b = 00000011b
-10101001b ^ 10101011b = 00000010b
-10101001b ^ 10101100b = 00000101b
-10101001b ^ 10101101b = 00000100b
-10101001b ^ 10101110b = 00000111b
-10101001b ^ 10101111b = 00000110b
-10101001b ^ 10110000b = 00011001b
-10101001b ^ 10110001b = 00011000b
-10101001b ^ 10110010b = 00011011b
-10101001b ^ 10110011b = 00011010b
-10101001b ^ 10110100b = 00011101b
-10101001b ^ 10110101b = 00011100b
-10101001b ^ 10110110b = 00011111b
-10101001b ^ 10110111b = 00011110b
-10101001b ^ 10111000b = 00010001b
-10101001b ^ 10111001b = 00010000b
-10101001b ^ 10111010b = 00010011b
-10101001b ^ 10111011b = 00010010b
-10101001b ^ 10111100b = 00010101b
-10101001b ^ 10111101b = 00010100b
-10101001b ^ 10111110b = 00010111b
-10101001b ^ 10111111b = 00010110b
-10101001b ^ 11000000b = 01101001b
-10101001b ^ 11000001b = 01101000b
-10101001b ^ 11000010b = 01101011b
-10101001b ^ 11000011b = 01101010b
-10101001b ^ 11000100b = 01101101b
-10101001b ^ 11000101b = 01101100b
-10101001b ^ 11000110b = 01101111b
-10101001b ^ 11000111b = 01101110b
-10101001b ^ 11001000b = 01100001b
-10101001b ^ 11001001b = 01100000b
-10101001b ^ 11001010b = 01100011b
-10101001b ^ 11001011b = 01100010b
-10101001b ^ 11001100b = 01100101b
-10101001b ^ 11001101b = 01100100b
-10101001b ^ 11001110b = 01100111b
-10101001b ^ 11001111b = 01100110b
-10101001b ^ 11010000b = 01111001b
-10101001b ^ 11010001b = 01111000b
-10101001b ^ 11010010b = 01111011b
-10101001b ^ 11010011b = 01111010b
-10101001b ^ 11010100b = 01111101b
-10101001b ^ 11010101b = 01111100b
-10101001b ^ 11010110b = 01111111b
-10101001b ^ 11010111b = 01111110b
-10101001b ^ 11011000b = 01110001b
-10101001b ^ 11011001b = 01110000b
-10101001b ^ 11011010b = 01110011b
-10101001b ^ 11011011b = 01110010b
-10101001b ^ 11011100b = 01110101b
-10101001b ^ 11011101b = 01110100b
-10101001b ^ 11011110b = 01110111b
-10101001b ^ 11011111b = 01110110b
-10101001b ^ 11100000b = 01001001b
-10101001b ^ 11100001b = 01001000b
-10101001b ^ 11100010b = 01001011b
-10101001b ^ 11100011b = 01001010b
-10101001b ^ 11100100b = 01001101b
-10101001b ^ 11100101b = 01001100b
-10101001b ^ 11100110b = 01001111b
-10101001b ^ 11100111b = 01001110b
-10101001b ^ 11101000b = 01000001b
-10101001b ^ 11101001b = 01000000b
-10101001b ^ 11101010b = 01000011b
-10101001b ^ 11101011b = 01000010b
-10101001b ^ 11101100b = 01000101b
-10101001b ^ 11101101b = 01000100b
-10101001b ^ 11101110b = 01000111b
-10101001b ^ 11101111b = 01000110b
-10101001b ^ 11110000b = 01011001b
-10101001b ^ 11110001b = 01011000b
-10101001b ^ 11110010b = 01011011b
-10101001b ^ 11110011b = 01011010b
-10101001b ^ 11110100b = 01011101b
-10101001b ^ 11110101b = 01011100b
-10101001b ^ 11110110b = 01011111b
-10101001b ^ 11110111b = 01011110b
-10101001b ^ 11111000b = 01010001b
-10101001b ^ 11111001b = 01010000b
-10101001b ^ 11111010b = 01010011b
-10101001b ^ 11111011b = 01010010b
-10101001b ^ 11111100b = 01010101b
-10101001b ^ 11111101b = 01010100b
-10101001b ^ 11111110b = 01010111b
-10101001b ^ 11111111b = 01010110b
-10101001b ^ 00000000b = 10101001b
-10101001b ^ 00000001b = 10101000b
-10101001b ^ 00000010b = 10101011b
-10101001b ^ 00000011b = 10101010b
-10101001b ^ 00000100b = 10101101b
-10101001b ^ 00000101b = 10101100b
-10101001b ^ 00000110b = 10101111b
-10101001b ^ 00000111b = 10101110b
-10101001b ^ 00001000b = 10100001b
-10101001b ^ 00001001b = 10100000b
-10101001b ^ 00001010b = 10100011b
-10101001b ^ 00001011b = 10100010b
-10101001b ^ 00001100b = 10100101b
-10101001b ^ 00001101b = 10100100b
-10101001b ^ 00001110b = 10100111b
-10101001b ^ 00001111b = 10100110b
-10101001b ^ 00010000b = 10111001b
-10101001b ^ 00010001b = 10111000b
-10101001b ^ 00010010b = 10111011b
-10101001b ^ 00010011b = 10111010b
-10101001b ^ 00010100b = 10111101b
-10101001b ^ 00010101b = 10111100b
-10101001b ^ 00010110b = 10111111b
-10101001b ^ 00010111b = 10111110b
-10101001b ^ 00011000b = 10110001b
-10101001b ^ 00011001b = 10110000b
-10101001b ^ 00011010b = 10110011b
-10101001b ^ 00011011b = 10110010b
-10101001b ^ 00011100b = 10110101b
-10101001b ^ 00011101b = 10110100b
-10101001b ^ 00011110b = 10110111b
-10101001b ^ 00011111b = 10110110b
-10101001b ^ 00100000b = 10001001b
-10101001b ^ 00100001b = 10001000b
-10101001b ^ 00100010b = 10001011b
-10101001b ^ 00100011b = 10001010b
-10101001b ^ 00100100b = 10001101b
-10101001b ^ 00100101b = 10001100b
-10101001b ^ 00100110b = 10001111b
-10101001b ^ 00100111b = 10001110b
-10101001b ^ 00101000b = 10000001b
-10101001b ^ 00101001b = 10000000b
-10101001b ^ 00101010b = 10000011b
-10101001b ^ 00101011b = 10000010b
-10101001b ^ 00101100b = 10000101b
-10101001b ^ 00101101b = 10000100b
-10101001b ^ 00101110b = 10000111b
-10101001b ^ 00101111b = 10000110b
-10101001b ^ 00110000b = 10011001b
-10101001b ^ 00110001b = 10011000b
-10101001b ^ 00110010b = 10011011b
-10101001b ^ 00110011b = 10011010b
-10101001b ^ 00110100b = 10011101b
-10101001b ^ 00110101b = 10011100b
-10101001b ^ 00110110b = 10011111b
-10101001b ^ 00110111b = 10011110b
-10101001b ^ 00111000b = 10010001b
-10101001b ^ 00111001b = 10010000b
-10101001b ^ 00111010b = 10010011b
-10101001b ^ 00111011b = 10010010b
-10101001b ^ 00111100b = 10010101b
-10101001b ^ 00111101b = 10010100b
-10101001b ^ 00111110b = 10010111b
-10101001b ^ 00111111b = 10010110b
-10101001b ^ 01000000b = 11101001b
-10101001b ^ 01000001b = 11101000b
-10101001b ^ 01000010b = 11101011b
-10101001b ^ 01000011b = 11101010b
-10101001b ^ 01000100b = 11101101b
-10101001b ^ 01000101b = 11101100b
-10101001b ^ 01000110b = 11101111b
-10101001b ^ 01000111b = 11101110b
-10101001b ^ 01001000b = 11100001b
-10101001b ^ 01001001b = 11100000b
-10101001b ^ 01001010b = 11100011b
-10101001b ^ 01001011b = 11100010b
-10101001b ^ 01001100b = 11100101b
-10101001b ^ 01001101b = 11100100b
-10101001b ^ 01001110b = 11100111b
-10101001b ^ 01001111b = 11100110b
-10101001b ^ 01010000b = 11111001b
-10101001b ^ 01010001b = 11111000b
-10101001b ^ 01010010b = 11111011b
-10101001b ^ 01010011b = 11111010b
-10101001b ^ 01010100b = 11111101b
-10101001b ^ 01010101b = 11111100b
-10101001b ^ 01010110b = 11111111b
-10101001b ^ 01010111b = 11111110b
-10101001b ^ 01011000b = 11110001b
-10101001b ^ 01011001b = 11110000b
-10101001b ^ 01011010b = 11110011b
-10101001b ^ 01011011b = 11110010b
-10101001b ^ 01011100b = 11110101b
-10101001b ^ 01011101b = 11110100b
-10101001b ^ 01011110b = 11110111b
-10101001b ^ 01011111b = 11110110b
-10101001b ^ 01100000b = 11001001b
-10101001b ^ 01100001b = 11001000b
-10101001b ^ 01100010b = 11001011b
-10101001b ^ 01100011b = 11001010b
-10101001b ^ 01100100b = 11001101b
-10101001b ^ 01100101b = 11001100b
-10101001b ^ 01100110b = 11001111b
-10101001b ^ 01100111b = 11001110b
-10101001b ^ 01101000b = 11000001b
-10101001b ^ 01101001b = 11000000b
-10101001b ^ 01101010b = 11000011b
-10101001b ^ 01101011b = 11000010b
-10101001b ^ 01101100b = 11000101b
-10101001b ^ 01101101b = 11000100b
-10101001b ^ 01101110b = 11000111b
-10101001b ^ 01101111b = 11000110b
-10101001b ^ 01110000b = 11011001b
-10101001b ^ 01110001b = 11011000b
-10101001b ^ 01110010b = 11011011b
-10101001b ^ 01110011b = 11011010b
-10101001b ^ 01110100b = 11011101b
-10101001b ^ 01110101b = 11011100b
-10101001b ^ 01110110b = 11011111b
-10101001b ^ 01110111b = 11011110b
-10101001b ^ 01111000b = 11010001b
-10101001b ^ 01111001b = 11010000b
-10101001b ^ 01111010b = 11010011b
-10101001b ^ 01111011b = 11010010b
-10101001b ^ 01111100b = 11010101b
-10101001b ^ 01111101b = 11010100b
-10101001b ^ 01111110b = 11010111b
-10101010b ^ 10000000b = 00101010b
-10101010b ^ 10000001b = 00101011b
-10101010b ^ 10000010b = 00101000b
-10101010b ^ 10000011b = 00101001b
-10101010b ^ 10000100b = 00101110b
-10101010b ^ 10000101b = 00101111b
-10101010b ^ 10000110b = 00101100b
-10101010b ^ 10000111b = 00101101b
-10101010b ^ 10001000b = 00100010b
-10101010b ^ 10001001b = 00100011b
-10101010b ^ 10001010b = 00100000b
-10101010b ^ 10001011b = 00100001b
-10101010b ^ 10001100b = 00100110b
-10101010b ^ 10001101b = 00100111b
-10101010b ^ 10001110b = 00100100b
-10101010b ^ 10001111b = 00100101b
-10101010b ^ 10010000b = 00111010b
-10101010b ^ 10010001b = 00111011b
-10101010b ^ 10010010b = 00111000b
-10101010b ^ 10010011b = 00111001b
-10101010b ^ 10010100b = 00111110b
-10101010b ^ 10010101b = 00111111b
-10101010b ^ 10010110b = 00111100b
-10101010b ^ 10010111b = 00111101b
-10101010b ^ 10011000b = 00110010b
-10101010b ^ 10011001b = 00110011b
-10101010b ^ 10011010b = 00110000b
-10101010b ^ 10011011b = 00110001b
-10101010b ^ 10011100b = 00110110b
-10101010b ^ 10011101b = 00110111b
-10101010b ^ 10011110b = 00110100b
-10101010b ^ 10011111b = 00110101b
-10101010b ^ 10100000b = 00001010b
-10101010b ^ 10100001b = 00001011b
-10101010b ^ 10100010b = 00001000b
-10101010b ^ 10100011b = 00001001b
-10101010b ^ 10100100b = 00001110b
-10101010b ^ 10100101b = 00001111b
-10101010b ^ 10100110b = 00001100b
-10101010b ^ 10100111b = 00001101b
-10101010b ^ 10101000b = 00000010b
-10101010b ^ 10101001b = 00000011b
-10101010b ^ 10101010b = 00000000b
-10101010b ^ 10101011b = 00000001b
-10101010b ^ 10101100b = 00000110b
-10101010b ^ 10101101b = 00000111b
-10101010b ^ 10101110b = 00000100b
-10101010b ^ 10101111b = 00000101b
-10101010b ^ 10110000b = 00011010b
-10101010b ^ 10110001b = 00011011b
-10101010b ^ 10110010b = 00011000b
-10101010b ^ 10110011b = 00011001b
-10101010b ^ 10110100b = 00011110b
-10101010b ^ 10110101b = 00011111b
-10101010b ^ 10110110b = 00011100b
-10101010b ^ 10110111b = 00011101b
-10101010b ^ 10111000b = 00010010b
-10101010b ^ 10111001b = 00010011b
-10101010b ^ 10111010b = 00010000b
-10101010b ^ 10111011b = 00010001b
-10101010b ^ 10111100b = 00010110b
-10101010b ^ 10111101b = 00010111b
-10101010b ^ 10111110b = 00010100b
-10101010b ^ 10111111b = 00010101b
-10101010b ^ 11000000b = 01101010b
-10101010b ^ 11000001b = 01101011b
-10101010b ^ 11000010b = 01101000b
-10101010b ^ 11000011b = 01101001b
-10101010b ^ 11000100b = 01101110b
-10101010b ^ 11000101b = 01101111b
-10101010b ^ 11000110b = 01101100b
-10101010b ^ 11000111b = 01101101b
-10101010b ^ 11001000b = 01100010b
-10101010b ^ 11001001b = 01100011b
-10101010b ^ 11001010b = 01100000b
-10101010b ^ 11001011b = 01100001b
-10101010b ^ 11001100b = 01100110b
-10101010b ^ 11001101b = 01100111b
-10101010b ^ 11001110b = 01100100b
-10101010b ^ 11001111b = 01100101b
-10101010b ^ 11010000b = 01111010b
-10101010b ^ 11010001b = 01111011b
-10101010b ^ 11010010b = 01111000b
-10101010b ^ 11010011b = 01111001b
-10101010b ^ 11010100b = 01111110b
-10101010b ^ 11010101b = 01111111b
-10101010b ^ 11010110b = 01111100b
-10101010b ^ 11010111b = 01111101b
-10101010b ^ 11011000b = 01110010b
-10101010b ^ 11011001b = 01110011b
-10101010b ^ 11011010b = 01110000b
-10101010b ^ 11011011b = 01110001b
-10101010b ^ 11011100b = 01110110b
-10101010b ^ 11011101b = 01110111b
-10101010b ^ 11011110b = 01110100b
-10101010b ^ 11011111b = 01110101b
-10101010b ^ 11100000b = 01001010b
-10101010b ^ 11100001b = 01001011b
-10101010b ^ 11100010b = 01001000b
-10101010b ^ 11100011b = 01001001b
-10101010b ^ 11100100b = 01001110b
-10101010b ^ 11100101b = 01001111b
-10101010b ^ 11100110b = 01001100b
-10101010b ^ 11100111b = 01001101b
-10101010b ^ 11101000b = 01000010b
-10101010b ^ 11101001b = 01000011b
-10101010b ^ 11101010b = 01000000b
-10101010b ^ 11101011b = 01000001b
-10101010b ^ 11101100b = 01000110b
-10101010b ^ 11101101b = 01000111b
-10101010b ^ 11101110b = 01000100b
-10101010b ^ 11101111b = 01000101b
-10101010b ^ 11110000b = 01011010b
-10101010b ^ 11110001b = 01011011b
-10101010b ^ 11110010b = 01011000b
-10101010b ^ 11110011b = 01011001b
-10101010b ^ 11110100b = 01011110b
-10101010b ^ 11110101b = 01011111b
-10101010b ^ 11110110b = 01011100b
-10101010b ^ 11110111b = 01011101b
-10101010b ^ 11111000b = 01010010b
-10101010b ^ 11111001b = 01010011b
-10101010b ^ 11111010b = 01010000b
-10101010b ^ 11111011b = 01010001b
-10101010b ^ 11111100b = 01010110b
-10101010b ^ 11111101b = 01010111b
-10101010b ^ 11111110b = 01010100b
-10101010b ^ 11111111b = 01010101b
-10101010b ^ 00000000b = 10101010b
-10101010b ^ 00000001b = 10101011b
-10101010b ^ 00000010b = 10101000b
-10101010b ^ 00000011b = 10101001b
-10101010b ^ 00000100b = 10101110b
-10101010b ^ 00000101b = 10101111b
-10101010b ^ 00000110b = 10101100b
-10101010b ^ 00000111b = 10101101b
-10101010b ^ 00001000b = 10100010b
-10101010b ^ 00001001b = 10100011b
-10101010b ^ 00001010b = 10100000b
-10101010b ^ 00001011b = 10100001b
-10101010b ^ 00001100b = 10100110b
-10101010b ^ 00001101b = 10100111b
-10101010b ^ 00001110b = 10100100b
-10101010b ^ 00001111b = 10100101b
-10101010b ^ 00010000b = 10111010b
-10101010b ^ 00010001b = 10111011b
-10101010b ^ 00010010b = 10111000b
-10101010b ^ 00010011b = 10111001b
-10101010b ^ 00010100b = 10111110b
-10101010b ^ 00010101b = 10111111b
-10101010b ^ 00010110b = 10111100b
-10101010b ^ 00010111b = 10111101b
-10101010b ^ 00011000b = 10110010b
-10101010b ^ 00011001b = 10110011b
-10101010b ^ 00011010b = 10110000b
-10101010b ^ 00011011b = 10110001b
-10101010b ^ 00011100b = 10110110b
-10101010b ^ 00011101b = 10110111b
-10101010b ^ 00011110b = 10110100b
-10101010b ^ 00011111b = 10110101b
-10101010b ^ 00100000b = 10001010b
-10101010b ^ 00100001b = 10001011b
-10101010b ^ 00100010b = 10001000b
-10101010b ^ 00100011b = 10001001b
-10101010b ^ 00100100b = 10001110b
-10101010b ^ 00100101b = 10001111b
-10101010b ^ 00100110b = 10001100b
-10101010b ^ 00100111b = 10001101b
-10101010b ^ 00101000b = 10000010b
-10101010b ^ 00101001b = 10000011b
-10101010b ^ 00101010b = 10000000b
-10101010b ^ 00101011b = 10000001b
-10101010b ^ 00101100b = 10000110b
-10101010b ^ 00101101b = 10000111b
-10101010b ^ 00101110b = 10000100b
-10101010b ^ 00101111b = 10000101b
-10101010b ^ 00110000b = 10011010b
-10101010b ^ 00110001b = 10011011b
-10101010b ^ 00110010b = 10011000b
-10101010b ^ 00110011b = 10011001b
-10101010b ^ 00110100b = 10011110b
-10101010b ^ 00110101b = 10011111b
-10101010b ^ 00110110b = 10011100b
-10101010b ^ 00110111b = 10011101b
-10101010b ^ 00111000b = 10010010b
-10101010b ^ 00111001b = 10010011b
-10101010b ^ 00111010b = 10010000b
-10101010b ^ 00111011b = 10010001b
-10101010b ^ 00111100b = 10010110b
-10101010b ^ 00111101b = 10010111b
-10101010b ^ 00111110b = 10010100b
-10101010b ^ 00111111b = 10010101b
-10101010b ^ 01000000b = 11101010b
-10101010b ^ 01000001b = 11101011b
-10101010b ^ 01000010b = 11101000b
-10101010b ^ 01000011b = 11101001b
-10101010b ^ 01000100b = 11101110b
-10101010b ^ 01000101b = 11101111b
-10101010b ^ 01000110b = 11101100b
-10101010b ^ 01000111b = 11101101b
-10101010b ^ 01001000b = 11100010b
-10101010b ^ 01001001b = 11100011b
-10101010b ^ 01001010b = 11100000b
-10101010b ^ 01001011b = 11100001b
-10101010b ^ 01001100b = 11100110b
-10101010b ^ 01001101b = 11100111b
-10101010b ^ 01001110b = 11100100b
-10101010b ^ 01001111b = 11100101b
-10101010b ^ 01010000b = 11111010b
-10101010b ^ 01010001b = 11111011b
-10101010b ^ 01010010b = 11111000b
-10101010b ^ 01010011b = 11111001b
-10101010b ^ 01010100b = 11111110b
-10101010b ^ 01010101b = 11111111b
-10101010b ^ 01010110b = 11111100b
-10101010b ^ 01010111b = 11111101b
-10101010b ^ 01011000b = 11110010b
-10101010b ^ 01011001b = 11110011b
-10101010b ^ 01011010b = 11110000b
-10101010b ^ 01011011b = 11110001b
-10101010b ^ 01011100b = 11110110b
-10101010b ^ 01011101b = 11110111b
-10101010b ^ 01011110b = 11110100b
-10101010b ^ 01011111b = 11110101b
-10101010b ^ 01100000b = 11001010b
-10101010b ^ 01100001b = 11001011b
-10101010b ^ 01100010b = 11001000b
-10101010b ^ 01100011b = 11001001b
-10101010b ^ 01100100b = 11001110b
-10101010b ^ 01100101b = 11001111b
-10101010b ^ 01100110b = 11001100b
-10101010b ^ 01100111b = 11001101b
-10101010b ^ 01101000b = 11000010b
-10101010b ^ 01101001b = 11000011b
-10101010b ^ 01101010b = 11000000b
-10101010b ^ 01101011b = 11000001b
-10101010b ^ 01101100b = 11000110b
-10101010b ^ 01101101b = 11000111b
-10101010b ^ 01101110b = 11000100b
-10101010b ^ 01101111b = 11000101b
-10101010b ^ 01110000b = 11011010b
-10101010b ^ 01110001b = 11011011b
-10101010b ^ 01110010b = 11011000b
-10101010b ^ 01110011b = 11011001b
-10101010b ^ 01110100b = 11011110b
-10101010b ^ 01110101b = 11011111b
-10101010b ^ 01110110b = 11011100b
-10101010b ^ 01110111b = 11011101b
-10101010b ^ 01111000b = 11010010b
-10101010b ^ 01111001b = 11010011b
-10101010b ^ 01111010b = 11010000b
-10101010b ^ 01111011b = 11010001b
-10101010b ^ 01111100b = 11010110b
-10101010b ^ 01111101b = 11010111b
-10101010b ^ 01111110b = 11010100b
-10101011b ^ 10000000b = 00101011b
-10101011b ^ 10000001b = 00101010b
-10101011b ^ 10000010b = 00101001b
-10101011b ^ 10000011b = 00101000b
-10101011b ^ 10000100b = 00101111b
-10101011b ^ 10000101b = 00101110b
-10101011b ^ 10000110b = 00101101b
-10101011b ^ 10000111b = 00101100b
-10101011b ^ 10001000b = 00100011b
-10101011b ^ 10001001b = 00100010b
-10101011b ^ 10001010b = 00100001b
-10101011b ^ 10001011b = 00100000b
-10101011b ^ 10001100b = 00100111b
-10101011b ^ 10001101b = 00100110b
-10101011b ^ 10001110b = 00100101b
-10101011b ^ 10001111b = 00100100b
-10101011b ^ 10010000b = 00111011b
-10101011b ^ 10010001b = 00111010b
-10101011b ^ 10010010b = 00111001b
-10101011b ^ 10010011b = 00111000b
-10101011b ^ 10010100b = 00111111b
-10101011b ^ 10010101b = 00111110b
-10101011b ^ 10010110b = 00111101b
-10101011b ^ 10010111b = 00111100b
-10101011b ^ 10011000b = 00110011b
-10101011b ^ 10011001b = 00110010b
-10101011b ^ 10011010b = 00110001b
-10101011b ^ 10011011b = 00110000b
-10101011b ^ 10011100b = 00110111b
-10101011b ^ 10011101b = 00110110b
-10101011b ^ 10011110b = 00110101b
-10101011b ^ 10011111b = 00110100b
-10101011b ^ 10100000b = 00001011b
-10101011b ^ 10100001b = 00001010b
-10101011b ^ 10100010b = 00001001b
-10101011b ^ 10100011b = 00001000b
-10101011b ^ 10100100b = 00001111b
-10101011b ^ 10100101b = 00001110b
-10101011b ^ 10100110b = 00001101b
-10101011b ^ 10100111b = 00001100b
-10101011b ^ 10101000b = 00000011b
-10101011b ^ 10101001b = 00000010b
-10101011b ^ 10101010b = 00000001b
-10101011b ^ 10101011b = 00000000b
-10101011b ^ 10101100b = 00000111b
-10101011b ^ 10101101b = 00000110b
-10101011b ^ 10101110b = 00000101b
-10101011b ^ 10101111b = 00000100b
-10101011b ^ 10110000b = 00011011b
-10101011b ^ 10110001b = 00011010b
-10101011b ^ 10110010b = 00011001b
-10101011b ^ 10110011b = 00011000b
-10101011b ^ 10110100b = 00011111b
-10101011b ^ 10110101b = 00011110b
-10101011b ^ 10110110b = 00011101b
-10101011b ^ 10110111b = 00011100b
-10101011b ^ 10111000b = 00010011b
-10101011b ^ 10111001b = 00010010b
-10101011b ^ 10111010b = 00010001b
-10101011b ^ 10111011b = 00010000b
-10101011b ^ 10111100b = 00010111b
-10101011b ^ 10111101b = 00010110b
-10101011b ^ 10111110b = 00010101b
-10101011b ^ 10111111b = 00010100b
-10101011b ^ 11000000b = 01101011b
-10101011b ^ 11000001b = 01101010b
-10101011b ^ 11000010b = 01101001b
-10101011b ^ 11000011b = 01101000b
-10101011b ^ 11000100b = 01101111b
-10101011b ^ 11000101b = 01101110b
-10101011b ^ 11000110b = 01101101b
-10101011b ^ 11000111b = 01101100b
-10101011b ^ 11001000b = 01100011b
-10101011b ^ 11001001b = 01100010b
-10101011b ^ 11001010b = 01100001b
-10101011b ^ 11001011b = 01100000b
-10101011b ^ 11001100b = 01100111b
-10101011b ^ 11001101b = 01100110b
-10101011b ^ 11001110b = 01100101b
-10101011b ^ 11001111b = 01100100b
-10101011b ^ 11010000b = 01111011b
-10101011b ^ 11010001b = 01111010b
-10101011b ^ 11010010b = 01111001b
-10101011b ^ 11010011b = 01111000b
-10101011b ^ 11010100b = 01111111b
-10101011b ^ 11010101b = 01111110b
-10101011b ^ 11010110b = 01111101b
-10101011b ^ 11010111b = 01111100b
-10101011b ^ 11011000b = 01110011b
-10101011b ^ 11011001b = 01110010b
-10101011b ^ 11011010b = 01110001b
-10101011b ^ 11011011b = 01110000b
-10101011b ^ 11011100b = 01110111b
-10101011b ^ 11011101b = 01110110b
-10101011b ^ 11011110b = 01110101b
-10101011b ^ 11011111b = 01110100b
-10101011b ^ 11100000b = 01001011b
-10101011b ^ 11100001b = 01001010b
-10101011b ^ 11100010b = 01001001b
-10101011b ^ 11100011b = 01001000b
-10101011b ^ 11100100b = 01001111b
-10101011b ^ 11100101b = 01001110b
-10101011b ^ 11100110b = 01001101b
-10101011b ^ 11100111b = 01001100b
-10101011b ^ 11101000b = 01000011b
-10101011b ^ 11101001b = 01000010b
-10101011b ^ 11101010b = 01000001b
-10101011b ^ 11101011b = 01000000b
-10101011b ^ 11101100b = 01000111b
-10101011b ^ 11101101b = 01000110b
-10101011b ^ 11101110b = 01000101b
-10101011b ^ 11101111b = 01000100b
-10101011b ^ 11110000b = 01011011b
-10101011b ^ 11110001b = 01011010b
-10101011b ^ 11110010b = 01011001b
-10101011b ^ 11110011b = 01011000b
-10101011b ^ 11110100b = 01011111b
-10101011b ^ 11110101b = 01011110b
-10101011b ^ 11110110b = 01011101b
-10101011b ^ 11110111b = 01011100b
-10101011b ^ 11111000b = 01010011b
-10101011b ^ 11111001b = 01010010b
-10101011b ^ 11111010b = 01010001b
-10101011b ^ 11111011b = 01010000b
-10101011b ^ 11111100b = 01010111b
-10101011b ^ 11111101b = 01010110b
-10101011b ^ 11111110b = 01010101b
-10101011b ^ 11111111b = 01010100b
-10101011b ^ 00000000b = 10101011b
-10101011b ^ 00000001b = 10101010b
-10101011b ^ 00000010b = 10101001b
-10101011b ^ 00000011b = 10101000b
-10101011b ^ 00000100b = 10101111b
-10101011b ^ 00000101b = 10101110b
-10101011b ^ 00000110b = 10101101b
-10101011b ^ 00000111b = 10101100b
-10101011b ^ 00001000b = 10100011b
-10101011b ^ 00001001b = 10100010b
-10101011b ^ 00001010b = 10100001b
-10101011b ^ 00001011b = 10100000b
-10101011b ^ 00001100b = 10100111b
-10101011b ^ 00001101b = 10100110b
-10101011b ^ 00001110b = 10100101b
-10101011b ^ 00001111b = 10100100b
-10101011b ^ 00010000b = 10111011b
-10101011b ^ 00010001b = 10111010b
-10101011b ^ 00010010b = 10111001b
-10101011b ^ 00010011b = 10111000b
-10101011b ^ 00010100b = 10111111b
-10101011b ^ 00010101b = 10111110b
-10101011b ^ 00010110b = 10111101b
-10101011b ^ 00010111b = 10111100b
-10101011b ^ 00011000b = 10110011b
-10101011b ^ 00011001b = 10110010b
-10101011b ^ 00011010b = 10110001b
-10101011b ^ 00011011b = 10110000b
-10101011b ^ 00011100b = 10110111b
-10101011b ^ 00011101b = 10110110b
-10101011b ^ 00011110b = 10110101b
-10101011b ^ 00011111b = 10110100b
-10101011b ^ 00100000b = 10001011b
-10101011b ^ 00100001b = 10001010b
-10101011b ^ 00100010b = 10001001b
-10101011b ^ 00100011b = 10001000b
-10101011b ^ 00100100b = 10001111b
-10101011b ^ 00100101b = 10001110b
-10101011b ^ 00100110b = 10001101b
-10101011b ^ 00100111b = 10001100b
-10101011b ^ 00101000b = 10000011b
-10101011b ^ 00101001b = 10000010b
-10101011b ^ 00101010b = 10000001b
-10101011b ^ 00101011b = 10000000b
-10101011b ^ 00101100b = 10000111b
-10101011b ^ 00101101b = 10000110b
-10101011b ^ 00101110b = 10000101b
-10101011b ^ 00101111b = 10000100b
-10101011b ^ 00110000b = 10011011b
-10101011b ^ 00110001b = 10011010b
-10101011b ^ 00110010b = 10011001b
-10101011b ^ 00110011b = 10011000b
-10101011b ^ 00110100b = 10011111b
-10101011b ^ 00110101b = 10011110b
-10101011b ^ 00110110b = 10011101b
-10101011b ^ 00110111b = 10011100b
-10101011b ^ 00111000b = 10010011b
-10101011b ^ 00111001b = 10010010b
-10101011b ^ 00111010b = 10010001b
-10101011b ^ 00111011b = 10010000b
-10101011b ^ 00111100b = 10010111b
-10101011b ^ 00111101b = 10010110b
-10101011b ^ 00111110b = 10010101b
-10101011b ^ 00111111b = 10010100b
-10101011b ^ 01000000b = 11101011b
-10101011b ^ 01000001b = 11101010b
-10101011b ^ 01000010b = 11101001b
-10101011b ^ 01000011b = 11101000b
-10101011b ^ 01000100b = 11101111b
-10101011b ^ 01000101b = 11101110b
-10101011b ^ 01000110b = 11101101b
-10101011b ^ 01000111b = 11101100b
-10101011b ^ 01001000b = 11100011b
-10101011b ^ 01001001b = 11100010b
-10101011b ^ 01001010b = 11100001b
-10101011b ^ 01001011b = 11100000b
-10101011b ^ 01001100b = 11100111b
-10101011b ^ 01001101b = 11100110b
-10101011b ^ 01001110b = 11100101b
-10101011b ^ 01001111b = 11100100b
-10101011b ^ 01010000b = 11111011b
-10101011b ^ 01010001b = 11111010b
-10101011b ^ 01010010b = 11111001b
-10101011b ^ 01010011b = 11111000b
-10101011b ^ 01010100b = 11111111b
-10101011b ^ 01010101b = 11111110b
-10101011b ^ 01010110b = 11111101b
-10101011b ^ 01010111b = 11111100b
-10101011b ^ 01011000b = 11110011b
-10101011b ^ 01011001b = 11110010b
-10101011b ^ 01011010b = 11110001b
-10101011b ^ 01011011b = 11110000b
-10101011b ^ 01011100b = 11110111b
-10101011b ^ 01011101b = 11110110b
-10101011b ^ 01011110b = 11110101b
-10101011b ^ 01011111b = 11110100b
-10101011b ^ 01100000b = 11001011b
-10101011b ^ 01100001b = 11001010b
-10101011b ^ 01100010b = 11001001b
-10101011b ^ 01100011b = 11001000b
-10101011b ^ 01100100b = 11001111b
-10101011b ^ 01100101b = 11001110b
-10101011b ^ 01100110b = 11001101b
-10101011b ^ 01100111b = 11001100b
-10101011b ^ 01101000b = 11000011b
-10101011b ^ 01101001b = 11000010b
-10101011b ^ 01101010b = 11000001b
-10101011b ^ 01101011b = 11000000b
-10101011b ^ 01101100b = 11000111b
-10101011b ^ 01101101b = 11000110b
-10101011b ^ 01101110b = 11000101b
-10101011b ^ 01101111b = 11000100b
-10101011b ^ 01110000b = 11011011b
-10101011b ^ 01110001b = 11011010b
-10101011b ^ 01110010b = 11011001b
-10101011b ^ 01110011b = 11011000b
-10101011b ^ 01110100b = 11011111b
-10101011b ^ 01110101b = 11011110b
-10101011b ^ 01110110b = 11011101b
-10101011b ^ 01110111b = 11011100b
-10101011b ^ 01111000b = 11010011b
-10101011b ^ 01111001b = 11010010b
-10101011b ^ 01111010b = 11010001b
-10101011b ^ 01111011b = 11010000b
-10101011b ^ 01111100b = 11010111b
-10101011b ^ 01111101b = 11010110b
-10101011b ^ 01111110b = 11010101b
-10101100b ^ 10000000b = 00101100b
-10101100b ^ 10000001b = 00101101b
-10101100b ^ 10000010b = 00101110b
-10101100b ^ 10000011b = 00101111b
-10101100b ^ 10000100b = 00101000b
-10101100b ^ 10000101b = 00101001b
-10101100b ^ 10000110b = 00101010b
-10101100b ^ 10000111b = 00101011b
-10101100b ^ 10001000b = 00100100b
-10101100b ^ 10001001b = 00100101b
-10101100b ^ 10001010b = 00100110b
-10101100b ^ 10001011b = 00100111b
-10101100b ^ 10001100b = 00100000b
-10101100b ^ 10001101b = 00100001b
-10101100b ^ 10001110b = 00100010b
-10101100b ^ 10001111b = 00100011b
-10101100b ^ 10010000b = 00111100b
-10101100b ^ 10010001b = 00111101b
-10101100b ^ 10010010b = 00111110b
-10101100b ^ 10010011b = 00111111b
-10101100b ^ 10010100b = 00111000b
-10101100b ^ 10010101b = 00111001b
-10101100b ^ 10010110b = 00111010b
-10101100b ^ 10010111b = 00111011b
-10101100b ^ 10011000b = 00110100b
-10101100b ^ 10011001b = 00110101b
-10101100b ^ 10011010b = 00110110b
-10101100b ^ 10011011b = 00110111b
-10101100b ^ 10011100b = 00110000b
-10101100b ^ 10011101b = 00110001b
-10101100b ^ 10011110b = 00110010b
-10101100b ^ 10011111b = 00110011b
-10101100b ^ 10100000b = 00001100b
-10101100b ^ 10100001b = 00001101b
-10101100b ^ 10100010b = 00001110b
-10101100b ^ 10100011b = 00001111b
-10101100b ^ 10100100b = 00001000b
-10101100b ^ 10100101b = 00001001b
-10101100b ^ 10100110b = 00001010b
-10101100b ^ 10100111b = 00001011b
-10101100b ^ 10101000b = 00000100b
-10101100b ^ 10101001b = 00000101b
-10101100b ^ 10101010b = 00000110b
-10101100b ^ 10101011b = 00000111b
-10101100b ^ 10101100b = 00000000b
-10101100b ^ 10101101b = 00000001b
-10101100b ^ 10101110b = 00000010b
-10101100b ^ 10101111b = 00000011b
-10101100b ^ 10110000b = 00011100b
-10101100b ^ 10110001b = 00011101b
-10101100b ^ 10110010b = 00011110b
-10101100b ^ 10110011b = 00011111b
-10101100b ^ 10110100b = 00011000b
-10101100b ^ 10110101b = 00011001b
-10101100b ^ 10110110b = 00011010b
-10101100b ^ 10110111b = 00011011b
-10101100b ^ 10111000b = 00010100b
-10101100b ^ 10111001b = 00010101b
-10101100b ^ 10111010b = 00010110b
-10101100b ^ 10111011b = 00010111b
-10101100b ^ 10111100b = 00010000b
-10101100b ^ 10111101b = 00010001b
-10101100b ^ 10111110b = 00010010b
-10101100b ^ 10111111b = 00010011b
-10101100b ^ 11000000b = 01101100b
-10101100b ^ 11000001b = 01101101b
-10101100b ^ 11000010b = 01101110b
-10101100b ^ 11000011b = 01101111b
-10101100b ^ 11000100b = 01101000b
-10101100b ^ 11000101b = 01101001b
-10101100b ^ 11000110b = 01101010b
-10101100b ^ 11000111b = 01101011b
-10101100b ^ 11001000b = 01100100b
-10101100b ^ 11001001b = 01100101b
-10101100b ^ 11001010b = 01100110b
-10101100b ^ 11001011b = 01100111b
-10101100b ^ 11001100b = 01100000b
-10101100b ^ 11001101b = 01100001b
-10101100b ^ 11001110b = 01100010b
-10101100b ^ 11001111b = 01100011b
-10101100b ^ 11010000b = 01111100b
-10101100b ^ 11010001b = 01111101b
-10101100b ^ 11010010b = 01111110b
-10101100b ^ 11010011b = 01111111b
-10101100b ^ 11010100b = 01111000b
-10101100b ^ 11010101b = 01111001b
-10101100b ^ 11010110b = 01111010b
-10101100b ^ 11010111b = 01111011b
-10101100b ^ 11011000b = 01110100b
-10101100b ^ 11011001b = 01110101b
-10101100b ^ 11011010b = 01110110b
-10101100b ^ 11011011b = 01110111b
-10101100b ^ 11011100b = 01110000b
-10101100b ^ 11011101b = 01110001b
-10101100b ^ 11011110b = 01110010b
-10101100b ^ 11011111b = 01110011b
-10101100b ^ 11100000b = 01001100b
-10101100b ^ 11100001b = 01001101b
-10101100b ^ 11100010b = 01001110b
-10101100b ^ 11100011b = 01001111b
-10101100b ^ 11100100b = 01001000b
-10101100b ^ 11100101b = 01001001b
-10101100b ^ 11100110b = 01001010b
-10101100b ^ 11100111b = 01001011b
-10101100b ^ 11101000b = 01000100b
-10101100b ^ 11101001b = 01000101b
-10101100b ^ 11101010b = 01000110b
-10101100b ^ 11101011b = 01000111b
-10101100b ^ 11101100b = 01000000b
-10101100b ^ 11101101b = 01000001b
-10101100b ^ 11101110b = 01000010b
-10101100b ^ 11101111b = 01000011b
-10101100b ^ 11110000b = 01011100b
-10101100b ^ 11110001b = 01011101b
-10101100b ^ 11110010b = 01011110b
-10101100b ^ 11110011b = 01011111b
-10101100b ^ 11110100b = 01011000b
-10101100b ^ 11110101b = 01011001b
-10101100b ^ 11110110b = 01011010b
-10101100b ^ 11110111b = 01011011b
-10101100b ^ 11111000b = 01010100b
-10101100b ^ 11111001b = 01010101b
-10101100b ^ 11111010b = 01010110b
-10101100b ^ 11111011b = 01010111b
-10101100b ^ 11111100b = 01010000b
-10101100b ^ 11111101b = 01010001b
-10101100b ^ 11111110b = 01010010b
-10101100b ^ 11111111b = 01010011b
-10101100b ^ 00000000b = 10101100b
-10101100b ^ 00000001b = 10101101b
-10101100b ^ 00000010b = 10101110b
-10101100b ^ 00000011b = 10101111b
-10101100b ^ 00000100b = 10101000b
-10101100b ^ 00000101b = 10101001b
-10101100b ^ 00000110b = 10101010b
-10101100b ^ 00000111b = 10101011b
-10101100b ^ 00001000b = 10100100b
-10101100b ^ 00001001b = 10100101b
-10101100b ^ 00001010b = 10100110b
-10101100b ^ 00001011b = 10100111b
-10101100b ^ 00001100b = 10100000b
-10101100b ^ 00001101b = 10100001b
-10101100b ^ 00001110b = 10100010b
-10101100b ^ 00001111b = 10100011b
-10101100b ^ 00010000b = 10111100b
-10101100b ^ 00010001b = 10111101b
-10101100b ^ 00010010b = 10111110b
-10101100b ^ 00010011b = 10111111b
-10101100b ^ 00010100b = 10111000b
-10101100b ^ 00010101b = 10111001b
-10101100b ^ 00010110b = 10111010b
-10101100b ^ 00010111b = 10111011b
-10101100b ^ 00011000b = 10110100b
-10101100b ^ 00011001b = 10110101b
-10101100b ^ 00011010b = 10110110b
-10101100b ^ 00011011b = 10110111b
-10101100b ^ 00011100b = 10110000b
-10101100b ^ 00011101b = 10110001b
-10101100b ^ 00011110b = 10110010b
-10101100b ^ 00011111b = 10110011b
-10101100b ^ 00100000b = 10001100b
-10101100b ^ 00100001b = 10001101b
-10101100b ^ 00100010b = 10001110b
-10101100b ^ 00100011b = 10001111b
-10101100b ^ 00100100b = 10001000b
-10101100b ^ 00100101b = 10001001b
-10101100b ^ 00100110b = 10001010b
-10101100b ^ 00100111b = 10001011b
-10101100b ^ 00101000b = 10000100b
-10101100b ^ 00101001b = 10000101b
-10101100b ^ 00101010b = 10000110b
-10101100b ^ 00101011b = 10000111b
-10101100b ^ 00101100b = 10000000b
-10101100b ^ 00101101b = 10000001b
-10101100b ^ 00101110b = 10000010b
-10101100b ^ 00101111b = 10000011b
-10101100b ^ 00110000b = 10011100b
-10101100b ^ 00110001b = 10011101b
-10101100b ^ 00110010b = 10011110b
-10101100b ^ 00110011b = 10011111b
-10101100b ^ 00110100b = 10011000b
-10101100b ^ 00110101b = 10011001b
-10101100b ^ 00110110b = 10011010b
-10101100b ^ 00110111b = 10011011b
-10101100b ^ 00111000b = 10010100b
-10101100b ^ 00111001b = 10010101b
-10101100b ^ 00111010b = 10010110b
-10101100b ^ 00111011b = 10010111b
-10101100b ^ 00111100b = 10010000b
-10101100b ^ 00111101b = 10010001b
-10101100b ^ 00111110b = 10010010b
-10101100b ^ 00111111b = 10010011b
-10101100b ^ 01000000b = 11101100b
-10101100b ^ 01000001b = 11101101b
-10101100b ^ 01000010b = 11101110b
-10101100b ^ 01000011b = 11101111b
-10101100b ^ 01000100b = 11101000b
-10101100b ^ 01000101b = 11101001b
-10101100b ^ 01000110b = 11101010b
-10101100b ^ 01000111b = 11101011b
-10101100b ^ 01001000b = 11100100b
-10101100b ^ 01001001b = 11100101b
-10101100b ^ 01001010b = 11100110b
-10101100b ^ 01001011b = 11100111b
-10101100b ^ 01001100b = 11100000b
-10101100b ^ 01001101b = 11100001b
-10101100b ^ 01001110b = 11100010b
-10101100b ^ 01001111b = 11100011b
-10101100b ^ 01010000b = 11111100b
-10101100b ^ 01010001b = 11111101b
-10101100b ^ 01010010b = 11111110b
-10101100b ^ 01010011b = 11111111b
-10101100b ^ 01010100b = 11111000b
-10101100b ^ 01010101b = 11111001b
-10101100b ^ 01010110b = 11111010b
-10101100b ^ 01010111b = 11111011b
-10101100b ^ 01011000b = 11110100b
-10101100b ^ 01011001b = 11110101b
-10101100b ^ 01011010b = 11110110b
-10101100b ^ 01011011b = 11110111b
-10101100b ^ 01011100b = 11110000b
-10101100b ^ 01011101b = 11110001b
-10101100b ^ 01011110b = 11110010b
-10101100b ^ 01011111b = 11110011b
-10101100b ^ 01100000b = 11001100b
-10101100b ^ 01100001b = 11001101b
-10101100b ^ 01100010b = 11001110b
-10101100b ^ 01100011b = 11001111b
-10101100b ^ 01100100b = 11001000b
-10101100b ^ 01100101b = 11001001b
-10101100b ^ 01100110b = 11001010b
-10101100b ^ 01100111b = 11001011b
-10101100b ^ 01101000b = 11000100b
-10101100b ^ 01101001b = 11000101b
-10101100b ^ 01101010b = 11000110b
-10101100b ^ 01101011b = 11000111b
-10101100b ^ 01101100b = 11000000b
-10101100b ^ 01101101b = 11000001b
-10101100b ^ 01101110b = 11000010b
-10101100b ^ 01101111b = 11000011b
-10101100b ^ 01110000b = 11011100b
-10101100b ^ 01110001b = 11011101b
-10101100b ^ 01110010b = 11011110b
-10101100b ^ 01110011b = 11011111b
-10101100b ^ 01110100b = 11011000b
-10101100b ^ 01110101b = 11011001b
-10101100b ^ 01110110b = 11011010b
-10101100b ^ 01110111b = 11011011b
-10101100b ^ 01111000b = 11010100b
-10101100b ^ 01111001b = 11010101b
-10101100b ^ 01111010b = 11010110b
-10101100b ^ 01111011b = 11010111b
-10101100b ^ 01111100b = 11010000b
-10101100b ^ 01111101b = 11010001b
-10101100b ^ 01111110b = 11010010b
-10101101b ^ 10000000b = 00101101b
-10101101b ^ 10000001b = 00101100b
-10101101b ^ 10000010b = 00101111b
-10101101b ^ 10000011b = 00101110b
-10101101b ^ 10000100b = 00101001b
-10101101b ^ 10000101b = 00101000b
-10101101b ^ 10000110b = 00101011b
-10101101b ^ 10000111b = 00101010b
-10101101b ^ 10001000b = 00100101b
-10101101b ^ 10001001b = 00100100b
-10101101b ^ 10001010b = 00100111b
-10101101b ^ 10001011b = 00100110b
-10101101b ^ 10001100b = 00100001b
-10101101b ^ 10001101b = 00100000b
-10101101b ^ 10001110b = 00100011b
-10101101b ^ 10001111b = 00100010b
-10101101b ^ 10010000b = 00111101b
-10101101b ^ 10010001b = 00111100b
-10101101b ^ 10010010b = 00111111b
-10101101b ^ 10010011b = 00111110b
-10101101b ^ 10010100b = 00111001b
-10101101b ^ 10010101b = 00111000b
-10101101b ^ 10010110b = 00111011b
-10101101b ^ 10010111b = 00111010b
-10101101b ^ 10011000b = 00110101b
-10101101b ^ 10011001b = 00110100b
-10101101b ^ 10011010b = 00110111b
-10101101b ^ 10011011b = 00110110b
-10101101b ^ 10011100b = 00110001b
-10101101b ^ 10011101b = 00110000b
-10101101b ^ 10011110b = 00110011b
-10101101b ^ 10011111b = 00110010b
-10101101b ^ 10100000b = 00001101b
-10101101b ^ 10100001b = 00001100b
-10101101b ^ 10100010b = 00001111b
-10101101b ^ 10100011b = 00001110b
-10101101b ^ 10100100b = 00001001b
-10101101b ^ 10100101b = 00001000b
-10101101b ^ 10100110b = 00001011b
-10101101b ^ 10100111b = 00001010b
-10101101b ^ 10101000b = 00000101b
-10101101b ^ 10101001b = 00000100b
-10101101b ^ 10101010b = 00000111b
-10101101b ^ 10101011b = 00000110b
-10101101b ^ 10101100b = 00000001b
-10101101b ^ 10101101b = 00000000b
-10101101b ^ 10101110b = 00000011b
-10101101b ^ 10101111b = 00000010b
-10101101b ^ 10110000b = 00011101b
-10101101b ^ 10110001b = 00011100b
-10101101b ^ 10110010b = 00011111b
-10101101b ^ 10110011b = 00011110b
-10101101b ^ 10110100b = 00011001b
-10101101b ^ 10110101b = 00011000b
-10101101b ^ 10110110b = 00011011b
-10101101b ^ 10110111b = 00011010b
-10101101b ^ 10111000b = 00010101b
-10101101b ^ 10111001b = 00010100b
-10101101b ^ 10111010b = 00010111b
-10101101b ^ 10111011b = 00010110b
-10101101b ^ 10111100b = 00010001b
-10101101b ^ 10111101b = 00010000b
-10101101b ^ 10111110b = 00010011b
-10101101b ^ 10111111b = 00010010b
-10101101b ^ 11000000b = 01101101b
-10101101b ^ 11000001b = 01101100b
-10101101b ^ 11000010b = 01101111b
-10101101b ^ 11000011b = 01101110b
-10101101b ^ 11000100b = 01101001b
-10101101b ^ 11000101b = 01101000b
-10101101b ^ 11000110b = 01101011b
-10101101b ^ 11000111b = 01101010b
-10101101b ^ 11001000b = 01100101b
-10101101b ^ 11001001b = 01100100b
-10101101b ^ 11001010b = 01100111b
-10101101b ^ 11001011b = 01100110b
-10101101b ^ 11001100b = 01100001b
-10101101b ^ 11001101b = 01100000b
-10101101b ^ 11001110b = 01100011b
-10101101b ^ 11001111b = 01100010b
-10101101b ^ 11010000b = 01111101b
-10101101b ^ 11010001b = 01111100b
-10101101b ^ 11010010b = 01111111b
-10101101b ^ 11010011b = 01111110b
-10101101b ^ 11010100b = 01111001b
-10101101b ^ 11010101b = 01111000b
-10101101b ^ 11010110b = 01111011b
-10101101b ^ 11010111b = 01111010b
-10101101b ^ 11011000b = 01110101b
-10101101b ^ 11011001b = 01110100b
-10101101b ^ 11011010b = 01110111b
-10101101b ^ 11011011b = 01110110b
-10101101b ^ 11011100b = 01110001b
-10101101b ^ 11011101b = 01110000b
-10101101b ^ 11011110b = 01110011b
-10101101b ^ 11011111b = 01110010b
-10101101b ^ 11100000b = 01001101b
-10101101b ^ 11100001b = 01001100b
-10101101b ^ 11100010b = 01001111b
-10101101b ^ 11100011b = 01001110b
-10101101b ^ 11100100b = 01001001b
-10101101b ^ 11100101b = 01001000b
-10101101b ^ 11100110b = 01001011b
-10101101b ^ 11100111b = 01001010b
-10101101b ^ 11101000b = 01000101b
-10101101b ^ 11101001b = 01000100b
-10101101b ^ 11101010b = 01000111b
-10101101b ^ 11101011b = 01000110b
-10101101b ^ 11101100b = 01000001b
-10101101b ^ 11101101b = 01000000b
-10101101b ^ 11101110b = 01000011b
-10101101b ^ 11101111b = 01000010b
-10101101b ^ 11110000b = 01011101b
-10101101b ^ 11110001b = 01011100b
-10101101b ^ 11110010b = 01011111b
-10101101b ^ 11110011b = 01011110b
-10101101b ^ 11110100b = 01011001b
-10101101b ^ 11110101b = 01011000b
-10101101b ^ 11110110b = 01011011b
-10101101b ^ 11110111b = 01011010b
-10101101b ^ 11111000b = 01010101b
-10101101b ^ 11111001b = 01010100b
-10101101b ^ 11111010b = 01010111b
-10101101b ^ 11111011b = 01010110b
-10101101b ^ 11111100b = 01010001b
-10101101b ^ 11111101b = 01010000b
-10101101b ^ 11111110b = 01010011b
-10101101b ^ 11111111b = 01010010b
-10101101b ^ 00000000b = 10101101b
-10101101b ^ 00000001b = 10101100b
-10101101b ^ 00000010b = 10101111b
-10101101b ^ 00000011b = 10101110b
-10101101b ^ 00000100b = 10101001b
-10101101b ^ 00000101b = 10101000b
-10101101b ^ 00000110b = 10101011b
-10101101b ^ 00000111b = 10101010b
-10101101b ^ 00001000b = 10100101b
-10101101b ^ 00001001b = 10100100b
-10101101b ^ 00001010b = 10100111b
-10101101b ^ 00001011b = 10100110b
-10101101b ^ 00001100b = 10100001b
-10101101b ^ 00001101b = 10100000b
-10101101b ^ 00001110b = 10100011b
-10101101b ^ 00001111b = 10100010b
-10101101b ^ 00010000b = 10111101b
-10101101b ^ 00010001b = 10111100b
-10101101b ^ 00010010b = 10111111b
-10101101b ^ 00010011b = 10111110b
-10101101b ^ 00010100b = 10111001b
-10101101b ^ 00010101b = 10111000b
-10101101b ^ 00010110b = 10111011b
-10101101b ^ 00010111b = 10111010b
-10101101b ^ 00011000b = 10110101b
-10101101b ^ 00011001b = 10110100b
-10101101b ^ 00011010b = 10110111b
-10101101b ^ 00011011b = 10110110b
-10101101b ^ 00011100b = 10110001b
-10101101b ^ 00011101b = 10110000b
-10101101b ^ 00011110b = 10110011b
-10101101b ^ 00011111b = 10110010b
-10101101b ^ 00100000b = 10001101b
-10101101b ^ 00100001b = 10001100b
-10101101b ^ 00100010b = 10001111b
-10101101b ^ 00100011b = 10001110b
-10101101b ^ 00100100b = 10001001b
-10101101b ^ 00100101b = 10001000b
-10101101b ^ 00100110b = 10001011b
-10101101b ^ 00100111b = 10001010b
-10101101b ^ 00101000b = 10000101b
-10101101b ^ 00101001b = 10000100b
-10101101b ^ 00101010b = 10000111b
-10101101b ^ 00101011b = 10000110b
-10101101b ^ 00101100b = 10000001b
-10101101b ^ 00101101b = 10000000b
-10101101b ^ 00101110b = 10000011b
-10101101b ^ 00101111b = 10000010b
-10101101b ^ 00110000b = 10011101b
-10101101b ^ 00110001b = 10011100b
-10101101b ^ 00110010b = 10011111b
-10101101b ^ 00110011b = 10011110b
-10101101b ^ 00110100b = 10011001b
-10101101b ^ 00110101b = 10011000b
-10101101b ^ 00110110b = 10011011b
-10101101b ^ 00110111b = 10011010b
-10101101b ^ 00111000b = 10010101b
-10101101b ^ 00111001b = 10010100b
-10101101b ^ 00111010b = 10010111b
-10101101b ^ 00111011b = 10010110b
-10101101b ^ 00111100b = 10010001b
-10101101b ^ 00111101b = 10010000b
-10101101b ^ 00111110b = 10010011b
-10101101b ^ 00111111b = 10010010b
-10101101b ^ 01000000b = 11101101b
-10101101b ^ 01000001b = 11101100b
-10101101b ^ 01000010b = 11101111b
-10101101b ^ 01000011b = 11101110b
-10101101b ^ 01000100b = 11101001b
-10101101b ^ 01000101b = 11101000b
-10101101b ^ 01000110b = 11101011b
-10101101b ^ 01000111b = 11101010b
-10101101b ^ 01001000b = 11100101b
-10101101b ^ 01001001b = 11100100b
-10101101b ^ 01001010b = 11100111b
-10101101b ^ 01001011b = 11100110b
-10101101b ^ 01001100b = 11100001b
-10101101b ^ 01001101b = 11100000b
-10101101b ^ 01001110b = 11100011b
-10101101b ^ 01001111b = 11100010b
-10101101b ^ 01010000b = 11111101b
-10101101b ^ 01010001b = 11111100b
-10101101b ^ 01010010b = 11111111b
-10101101b ^ 01010011b = 11111110b
-10101101b ^ 01010100b = 11111001b
-10101101b ^ 01010101b = 11111000b
-10101101b ^ 01010110b = 11111011b
-10101101b ^ 01010111b = 11111010b
-10101101b ^ 01011000b = 11110101b
-10101101b ^ 01011001b = 11110100b
-10101101b ^ 01011010b = 11110111b
-10101101b ^ 01011011b = 11110110b
-10101101b ^ 01011100b = 11110001b
-10101101b ^ 01011101b = 11110000b
-10101101b ^ 01011110b = 11110011b
-10101101b ^ 01011111b = 11110010b
-10101101b ^ 01100000b = 11001101b
-10101101b ^ 01100001b = 11001100b
-10101101b ^ 01100010b = 11001111b
-10101101b ^ 01100011b = 11001110b
-10101101b ^ 01100100b = 11001001b
-10101101b ^ 01100101b = 11001000b
-10101101b ^ 01100110b = 11001011b
-10101101b ^ 01100111b = 11001010b
-10101101b ^ 01101000b = 11000101b
-10101101b ^ 01101001b = 11000100b
-10101101b ^ 01101010b = 11000111b
-10101101b ^ 01101011b = 11000110b
-10101101b ^ 01101100b = 11000001b
-10101101b ^ 01101101b = 11000000b
-10101101b ^ 01101110b = 11000011b
-10101101b ^ 01101111b = 11000010b
-10101101b ^ 01110000b = 11011101b
-10101101b ^ 01110001b = 11011100b
-10101101b ^ 01110010b = 11011111b
-10101101b ^ 01110011b = 11011110b
-10101101b ^ 01110100b = 11011001b
-10101101b ^ 01110101b = 11011000b
-10101101b ^ 01110110b = 11011011b
-10101101b ^ 01110111b = 11011010b
-10101101b ^ 01111000b = 11010101b
-10101101b ^ 01111001b = 11010100b
-10101101b ^ 01111010b = 11010111b
-10101101b ^ 01111011b = 11010110b
-10101101b ^ 01111100b = 11010001b
-10101101b ^ 01111101b = 11010000b
-10101101b ^ 01111110b = 11010011b
-10101110b ^ 10000000b = 00101110b
-10101110b ^ 10000001b = 00101111b
-10101110b ^ 10000010b = 00101100b
-10101110b ^ 10000011b = 00101101b
-10101110b ^ 10000100b = 00101010b
-10101110b ^ 10000101b = 00101011b
-10101110b ^ 10000110b = 00101000b
-10101110b ^ 10000111b = 00101001b
-10101110b ^ 10001000b = 00100110b
-10101110b ^ 10001001b = 00100111b
-10101110b ^ 10001010b = 00100100b
-10101110b ^ 10001011b = 00100101b
-10101110b ^ 10001100b = 00100010b
-10101110b ^ 10001101b = 00100011b
-10101110b ^ 10001110b = 00100000b
-10101110b ^ 10001111b = 00100001b
-10101110b ^ 10010000b = 00111110b
-10101110b ^ 10010001b = 00111111b
-10101110b ^ 10010010b = 00111100b
-10101110b ^ 10010011b = 00111101b
-10101110b ^ 10010100b = 00111010b
-10101110b ^ 10010101b = 00111011b
-10101110b ^ 10010110b = 00111000b
-10101110b ^ 10010111b = 00111001b
-10101110b ^ 10011000b = 00110110b
-10101110b ^ 10011001b = 00110111b
-10101110b ^ 10011010b = 00110100b
-10101110b ^ 10011011b = 00110101b
-10101110b ^ 10011100b = 00110010b
-10101110b ^ 10011101b = 00110011b
-10101110b ^ 10011110b = 00110000b
-10101110b ^ 10011111b = 00110001b
-10101110b ^ 10100000b = 00001110b
-10101110b ^ 10100001b = 00001111b
-10101110b ^ 10100010b = 00001100b
-10101110b ^ 10100011b = 00001101b
-10101110b ^ 10100100b = 00001010b
-10101110b ^ 10100101b = 00001011b
-10101110b ^ 10100110b = 00001000b
-10101110b ^ 10100111b = 00001001b
-10101110b ^ 10101000b = 00000110b
-10101110b ^ 10101001b = 00000111b
-10101110b ^ 10101010b = 00000100b
-10101110b ^ 10101011b = 00000101b
-10101110b ^ 10101100b = 00000010b
-10101110b ^ 10101101b = 00000011b
-10101110b ^ 10101110b = 00000000b
-10101110b ^ 10101111b = 00000001b
-10101110b ^ 10110000b = 00011110b
-10101110b ^ 10110001b = 00011111b
-10101110b ^ 10110010b = 00011100b
-10101110b ^ 10110011b = 00011101b
-10101110b ^ 10110100b = 00011010b
-10101110b ^ 10110101b = 00011011b
-10101110b ^ 10110110b = 00011000b
-10101110b ^ 10110111b = 00011001b
-10101110b ^ 10111000b = 00010110b
-10101110b ^ 10111001b = 00010111b
-10101110b ^ 10111010b = 00010100b
-10101110b ^ 10111011b = 00010101b
-10101110b ^ 10111100b = 00010010b
-10101110b ^ 10111101b = 00010011b
-10101110b ^ 10111110b = 00010000b
-10101110b ^ 10111111b = 00010001b
-10101110b ^ 11000000b = 01101110b
-10101110b ^ 11000001b = 01101111b
-10101110b ^ 11000010b = 01101100b
-10101110b ^ 11000011b = 01101101b
-10101110b ^ 11000100b = 01101010b
-10101110b ^ 11000101b = 01101011b
-10101110b ^ 11000110b = 01101000b
-10101110b ^ 11000111b = 01101001b
-10101110b ^ 11001000b = 01100110b
-10101110b ^ 11001001b = 01100111b
-10101110b ^ 11001010b = 01100100b
-10101110b ^ 11001011b = 01100101b
-10101110b ^ 11001100b = 01100010b
-10101110b ^ 11001101b = 01100011b
-10101110b ^ 11001110b = 01100000b
-10101110b ^ 11001111b = 01100001b
-10101110b ^ 11010000b = 01111110b
-10101110b ^ 11010001b = 01111111b
-10101110b ^ 11010010b = 01111100b
-10101110b ^ 11010011b = 01111101b
-10101110b ^ 11010100b = 01111010b
-10101110b ^ 11010101b = 01111011b
-10101110b ^ 11010110b = 01111000b
-10101110b ^ 11010111b = 01111001b
-10101110b ^ 11011000b = 01110110b
-10101110b ^ 11011001b = 01110111b
-10101110b ^ 11011010b = 01110100b
-10101110b ^ 11011011b = 01110101b
-10101110b ^ 11011100b = 01110010b
-10101110b ^ 11011101b = 01110011b
-10101110b ^ 11011110b = 01110000b
-10101110b ^ 11011111b = 01110001b
-10101110b ^ 11100000b = 01001110b
-10101110b ^ 11100001b = 01001111b
-10101110b ^ 11100010b = 01001100b
-10101110b ^ 11100011b = 01001101b
-10101110b ^ 11100100b = 01001010b
-10101110b ^ 11100101b = 01001011b
-10101110b ^ 11100110b = 01001000b
-10101110b ^ 11100111b = 01001001b
-10101110b ^ 11101000b = 01000110b
-10101110b ^ 11101001b = 01000111b
-10101110b ^ 11101010b = 01000100b
-10101110b ^ 11101011b = 01000101b
-10101110b ^ 11101100b = 01000010b
-10101110b ^ 11101101b = 01000011b
-10101110b ^ 11101110b = 01000000b
-10101110b ^ 11101111b = 01000001b
-10101110b ^ 11110000b = 01011110b
-10101110b ^ 11110001b = 01011111b
-10101110b ^ 11110010b = 01011100b
-10101110b ^ 11110011b = 01011101b
-10101110b ^ 11110100b = 01011010b
-10101110b ^ 11110101b = 01011011b
-10101110b ^ 11110110b = 01011000b
-10101110b ^ 11110111b = 01011001b
-10101110b ^ 11111000b = 01010110b
-10101110b ^ 11111001b = 01010111b
-10101110b ^ 11111010b = 01010100b
-10101110b ^ 11111011b = 01010101b
-10101110b ^ 11111100b = 01010010b
-10101110b ^ 11111101b = 01010011b
-10101110b ^ 11111110b = 01010000b
-10101110b ^ 11111111b = 01010001b
-10101110b ^ 00000000b = 10101110b
-10101110b ^ 00000001b = 10101111b
-10101110b ^ 00000010b = 10101100b
-10101110b ^ 00000011b = 10101101b
-10101110b ^ 00000100b = 10101010b
-10101110b ^ 00000101b = 10101011b
-10101110b ^ 00000110b = 10101000b
-10101110b ^ 00000111b = 10101001b
-10101110b ^ 00001000b = 10100110b
-10101110b ^ 00001001b = 10100111b
-10101110b ^ 00001010b = 10100100b
-10101110b ^ 00001011b = 10100101b
-10101110b ^ 00001100b = 10100010b
-10101110b ^ 00001101b = 10100011b
-10101110b ^ 00001110b = 10100000b
-10101110b ^ 00001111b = 10100001b
-10101110b ^ 00010000b = 10111110b
-10101110b ^ 00010001b = 10111111b
-10101110b ^ 00010010b = 10111100b
-10101110b ^ 00010011b = 10111101b
-10101110b ^ 00010100b = 10111010b
-10101110b ^ 00010101b = 10111011b
-10101110b ^ 00010110b = 10111000b
-10101110b ^ 00010111b = 10111001b
-10101110b ^ 00011000b = 10110110b
-10101110b ^ 00011001b = 10110111b
-10101110b ^ 00011010b = 10110100b
-10101110b ^ 00011011b = 10110101b
-10101110b ^ 00011100b = 10110010b
-10101110b ^ 00011101b = 10110011b
-10101110b ^ 00011110b = 10110000b
-10101110b ^ 00011111b = 10110001b
-10101110b ^ 00100000b = 10001110b
-10101110b ^ 00100001b = 10001111b
-10101110b ^ 00100010b = 10001100b
-10101110b ^ 00100011b = 10001101b
-10101110b ^ 00100100b = 10001010b
-10101110b ^ 00100101b = 10001011b
-10101110b ^ 00100110b = 10001000b
-10101110b ^ 00100111b = 10001001b
-10101110b ^ 00101000b = 10000110b
-10101110b ^ 00101001b = 10000111b
-10101110b ^ 00101010b = 10000100b
-10101110b ^ 00101011b = 10000101b
-10101110b ^ 00101100b = 10000010b
-10101110b ^ 00101101b = 10000011b
-10101110b ^ 00101110b = 10000000b
-10101110b ^ 00101111b = 10000001b
-10101110b ^ 00110000b = 10011110b
-10101110b ^ 00110001b = 10011111b
-10101110b ^ 00110010b = 10011100b
-10101110b ^ 00110011b = 10011101b
-10101110b ^ 00110100b = 10011010b
-10101110b ^ 00110101b = 10011011b
-10101110b ^ 00110110b = 10011000b
-10101110b ^ 00110111b = 10011001b
-10101110b ^ 00111000b = 10010110b
-10101110b ^ 00111001b = 10010111b
-10101110b ^ 00111010b = 10010100b
-10101110b ^ 00111011b = 10010101b
-10101110b ^ 00111100b = 10010010b
-10101110b ^ 00111101b = 10010011b
-10101110b ^ 00111110b = 10010000b
-10101110b ^ 00111111b = 10010001b
-10101110b ^ 01000000b = 11101110b
-10101110b ^ 01000001b = 11101111b
-10101110b ^ 01000010b = 11101100b
-10101110b ^ 01000011b = 11101101b
-10101110b ^ 01000100b = 11101010b
-10101110b ^ 01000101b = 11101011b
-10101110b ^ 01000110b = 11101000b
-10101110b ^ 01000111b = 11101001b
-10101110b ^ 01001000b = 11100110b
-10101110b ^ 01001001b = 11100111b
-10101110b ^ 01001010b = 11100100b
-10101110b ^ 01001011b = 11100101b
-10101110b ^ 01001100b = 11100010b
-10101110b ^ 01001101b = 11100011b
-10101110b ^ 01001110b = 11100000b
-10101110b ^ 01001111b = 11100001b
-10101110b ^ 01010000b = 11111110b
-10101110b ^ 01010001b = 11111111b
-10101110b ^ 01010010b = 11111100b
-10101110b ^ 01010011b = 11111101b
-10101110b ^ 01010100b = 11111010b
-10101110b ^ 01010101b = 11111011b
-10101110b ^ 01010110b = 11111000b
-10101110b ^ 01010111b = 11111001b
-10101110b ^ 01011000b = 11110110b
-10101110b ^ 01011001b = 11110111b
-10101110b ^ 01011010b = 11110100b
-10101110b ^ 01011011b = 11110101b
-10101110b ^ 01011100b = 11110010b
-10101110b ^ 01011101b = 11110011b
-10101110b ^ 01011110b = 11110000b
-10101110b ^ 01011111b = 11110001b
-10101110b ^ 01100000b = 11001110b
-10101110b ^ 01100001b = 11001111b
-10101110b ^ 01100010b = 11001100b
-10101110b ^ 01100011b = 11001101b
-10101110b ^ 01100100b = 11001010b
-10101110b ^ 01100101b = 11001011b
-10101110b ^ 01100110b = 11001000b
-10101110b ^ 01100111b = 11001001b
-10101110b ^ 01101000b = 11000110b
-10101110b ^ 01101001b = 11000111b
-10101110b ^ 01101010b = 11000100b
-10101110b ^ 01101011b = 11000101b
-10101110b ^ 01101100b = 11000010b
-10101110b ^ 01101101b = 11000011b
-10101110b ^ 01101110b = 11000000b
-10101110b ^ 01101111b = 11000001b
-10101110b ^ 01110000b = 11011110b
-10101110b ^ 01110001b = 11011111b
-10101110b ^ 01110010b = 11011100b
-10101110b ^ 01110011b = 11011101b
-10101110b ^ 01110100b = 11011010b
-10101110b ^ 01110101b = 11011011b
-10101110b ^ 01110110b = 11011000b
-10101110b ^ 01110111b = 11011001b
-10101110b ^ 01111000b = 11010110b
-10101110b ^ 01111001b = 11010111b
-10101110b ^ 01111010b = 11010100b
-10101110b ^ 01111011b = 11010101b
-10101110b ^ 01111100b = 11010010b
-10101110b ^ 01111101b = 11010011b
-10101110b ^ 01111110b = 11010000b
-10101111b ^ 10000000b = 00101111b
-10101111b ^ 10000001b = 00101110b
-10101111b ^ 10000010b = 00101101b
-10101111b ^ 10000011b = 00101100b
-10101111b ^ 10000100b = 00101011b
-10101111b ^ 10000101b = 00101010b
-10101111b ^ 10000110b = 00101001b
-10101111b ^ 10000111b = 00101000b
-10101111b ^ 10001000b = 00100111b
-10101111b ^ 10001001b = 00100110b
-10101111b ^ 10001010b = 00100101b
-10101111b ^ 10001011b = 00100100b
-10101111b ^ 10001100b = 00100011b
-10101111b ^ 10001101b = 00100010b
-10101111b ^ 10001110b = 00100001b
-10101111b ^ 10001111b = 00100000b
-10101111b ^ 10010000b = 00111111b
-10101111b ^ 10010001b = 00111110b
-10101111b ^ 10010010b = 00111101b
-10101111b ^ 10010011b = 00111100b
-10101111b ^ 10010100b = 00111011b
-10101111b ^ 10010101b = 00111010b
-10101111b ^ 10010110b = 00111001b
-10101111b ^ 10010111b = 00111000b
-10101111b ^ 10011000b = 00110111b
-10101111b ^ 10011001b = 00110110b
-10101111b ^ 10011010b = 00110101b
-10101111b ^ 10011011b = 00110100b
-10101111b ^ 10011100b = 00110011b
-10101111b ^ 10011101b = 00110010b
-10101111b ^ 10011110b = 00110001b
-10101111b ^ 10011111b = 00110000b
-10101111b ^ 10100000b = 00001111b
-10101111b ^ 10100001b = 00001110b
-10101111b ^ 10100010b = 00001101b
-10101111b ^ 10100011b = 00001100b
-10101111b ^ 10100100b = 00001011b
-10101111b ^ 10100101b = 00001010b
-10101111b ^ 10100110b = 00001001b
-10101111b ^ 10100111b = 00001000b
-10101111b ^ 10101000b = 00000111b
-10101111b ^ 10101001b = 00000110b
-10101111b ^ 10101010b = 00000101b
-10101111b ^ 10101011b = 00000100b
-10101111b ^ 10101100b = 00000011b
-10101111b ^ 10101101b = 00000010b
-10101111b ^ 10101110b = 00000001b
-10101111b ^ 10101111b = 00000000b
-10101111b ^ 10110000b = 00011111b
-10101111b ^ 10110001b = 00011110b
-10101111b ^ 10110010b = 00011101b
-10101111b ^ 10110011b = 00011100b
-10101111b ^ 10110100b = 00011011b
-10101111b ^ 10110101b = 00011010b
-10101111b ^ 10110110b = 00011001b
-10101111b ^ 10110111b = 00011000b
-10101111b ^ 10111000b = 00010111b
-10101111b ^ 10111001b = 00010110b
-10101111b ^ 10111010b = 00010101b
-10101111b ^ 10111011b = 00010100b
-10101111b ^ 10111100b = 00010011b
-10101111b ^ 10111101b = 00010010b
-10101111b ^ 10111110b = 00010001b
-10101111b ^ 10111111b = 00010000b
-10101111b ^ 11000000b = 01101111b
-10101111b ^ 11000001b = 01101110b
-10101111b ^ 11000010b = 01101101b
-10101111b ^ 11000011b = 01101100b
-10101111b ^ 11000100b = 01101011b
-10101111b ^ 11000101b = 01101010b
-10101111b ^ 11000110b = 01101001b
-10101111b ^ 11000111b = 01101000b
-10101111b ^ 11001000b = 01100111b
-10101111b ^ 11001001b = 01100110b
-10101111b ^ 11001010b = 01100101b
-10101111b ^ 11001011b = 01100100b
-10101111b ^ 11001100b = 01100011b
-10101111b ^ 11001101b = 01100010b
-10101111b ^ 11001110b = 01100001b
-10101111b ^ 11001111b = 01100000b
-10101111b ^ 11010000b = 01111111b
-10101111b ^ 11010001b = 01111110b
-10101111b ^ 11010010b = 01111101b
-10101111b ^ 11010011b = 01111100b
-10101111b ^ 11010100b = 01111011b
-10101111b ^ 11010101b = 01111010b
-10101111b ^ 11010110b = 01111001b
-10101111b ^ 11010111b = 01111000b
-10101111b ^ 11011000b = 01110111b
-10101111b ^ 11011001b = 01110110b
-10101111b ^ 11011010b = 01110101b
-10101111b ^ 11011011b = 01110100b
-10101111b ^ 11011100b = 01110011b
-10101111b ^ 11011101b = 01110010b
-10101111b ^ 11011110b = 01110001b
-10101111b ^ 11011111b = 01110000b
-10101111b ^ 11100000b = 01001111b
-10101111b ^ 11100001b = 01001110b
-10101111b ^ 11100010b = 01001101b
-10101111b ^ 11100011b = 01001100b
-10101111b ^ 11100100b = 01001011b
-10101111b ^ 11100101b = 01001010b
-10101111b ^ 11100110b = 01001001b
-10101111b ^ 11100111b = 01001000b
-10101111b ^ 11101000b = 01000111b
-10101111b ^ 11101001b = 01000110b
-10101111b ^ 11101010b = 01000101b
-10101111b ^ 11101011b = 01000100b
-10101111b ^ 11101100b = 01000011b
-10101111b ^ 11101101b = 01000010b
-10101111b ^ 11101110b = 01000001b
-10101111b ^ 11101111b = 01000000b
-10101111b ^ 11110000b = 01011111b
-10101111b ^ 11110001b = 01011110b
-10101111b ^ 11110010b = 01011101b
-10101111b ^ 11110011b = 01011100b
-10101111b ^ 11110100b = 01011011b
-10101111b ^ 11110101b = 01011010b
-10101111b ^ 11110110b = 01011001b
-10101111b ^ 11110111b = 01011000b
-10101111b ^ 11111000b = 01010111b
-10101111b ^ 11111001b = 01010110b
-10101111b ^ 11111010b = 01010101b
-10101111b ^ 11111011b = 01010100b
-10101111b ^ 11111100b = 01010011b
-10101111b ^ 11111101b = 01010010b
-10101111b ^ 11111110b = 01010001b
-10101111b ^ 11111111b = 01010000b
-10101111b ^ 00000000b = 10101111b
-10101111b ^ 00000001b = 10101110b
-10101111b ^ 00000010b = 10101101b
-10101111b ^ 00000011b = 10101100b
-10101111b ^ 00000100b = 10101011b
-10101111b ^ 00000101b = 10101010b
-10101111b ^ 00000110b = 10101001b
-10101111b ^ 00000111b = 10101000b
-10101111b ^ 00001000b = 10100111b
-10101111b ^ 00001001b = 10100110b
-10101111b ^ 00001010b = 10100101b
-10101111b ^ 00001011b = 10100100b
-10101111b ^ 00001100b = 10100011b
-10101111b ^ 00001101b = 10100010b
-10101111b ^ 00001110b = 10100001b
-10101111b ^ 00001111b = 10100000b
-10101111b ^ 00010000b = 10111111b
-10101111b ^ 00010001b = 10111110b
-10101111b ^ 00010010b = 10111101b
-10101111b ^ 00010011b = 10111100b
-10101111b ^ 00010100b = 10111011b
-10101111b ^ 00010101b = 10111010b
-10101111b ^ 00010110b = 10111001b
-10101111b ^ 00010111b = 10111000b
-10101111b ^ 00011000b = 10110111b
-10101111b ^ 00011001b = 10110110b
-10101111b ^ 00011010b = 10110101b
-10101111b ^ 00011011b = 10110100b
-10101111b ^ 00011100b = 10110011b
-10101111b ^ 00011101b = 10110010b
-10101111b ^ 00011110b = 10110001b
-10101111b ^ 00011111b = 10110000b
-10101111b ^ 00100000b = 10001111b
-10101111b ^ 00100001b = 10001110b
-10101111b ^ 00100010b = 10001101b
-10101111b ^ 00100011b = 10001100b
-10101111b ^ 00100100b = 10001011b
-10101111b ^ 00100101b = 10001010b
-10101111b ^ 00100110b = 10001001b
-10101111b ^ 00100111b = 10001000b
-10101111b ^ 00101000b = 10000111b
-10101111b ^ 00101001b = 10000110b
-10101111b ^ 00101010b = 10000101b
-10101111b ^ 00101011b = 10000100b
-10101111b ^ 00101100b = 10000011b
-10101111b ^ 00101101b = 10000010b
-10101111b ^ 00101110b = 10000001b
-10101111b ^ 00101111b = 10000000b
-10101111b ^ 00110000b = 10011111b
-10101111b ^ 00110001b = 10011110b
-10101111b ^ 00110010b = 10011101b
-10101111b ^ 00110011b = 10011100b
-10101111b ^ 00110100b = 10011011b
-10101111b ^ 00110101b = 10011010b
-10101111b ^ 00110110b = 10011001b
-10101111b ^ 00110111b = 10011000b
-10101111b ^ 00111000b = 10010111b
-10101111b ^ 00111001b = 10010110b
-10101111b ^ 00111010b = 10010101b
-10101111b ^ 00111011b = 10010100b
-10101111b ^ 00111100b = 10010011b
-10101111b ^ 00111101b = 10010010b
-10101111b ^ 00111110b = 10010001b
-10101111b ^ 00111111b = 10010000b
-10101111b ^ 01000000b = 11101111b
-10101111b ^ 01000001b = 11101110b
-10101111b ^ 01000010b = 11101101b
-10101111b ^ 01000011b = 11101100b
-10101111b ^ 01000100b = 11101011b
-10101111b ^ 01000101b = 11101010b
-10101111b ^ 01000110b = 11101001b
-10101111b ^ 01000111b = 11101000b
-10101111b ^ 01001000b = 11100111b
-10101111b ^ 01001001b = 11100110b
-10101111b ^ 01001010b = 11100101b
-10101111b ^ 01001011b = 11100100b
-10101111b ^ 01001100b = 11100011b
-10101111b ^ 01001101b = 11100010b
-10101111b ^ 01001110b = 11100001b
-10101111b ^ 01001111b = 11100000b
-10101111b ^ 01010000b = 11111111b
-10101111b ^ 01010001b = 11111110b
-10101111b ^ 01010010b = 11111101b
-10101111b ^ 01010011b = 11111100b
-10101111b ^ 01010100b = 11111011b
-10101111b ^ 01010101b = 11111010b
-10101111b ^ 01010110b = 11111001b
-10101111b ^ 01010111b = 11111000b
-10101111b ^ 01011000b = 11110111b
-10101111b ^ 01011001b = 11110110b
-10101111b ^ 01011010b = 11110101b
-10101111b ^ 01011011b = 11110100b
-10101111b ^ 01011100b = 11110011b
-10101111b ^ 01011101b = 11110010b
-10101111b ^ 01011110b = 11110001b
-10101111b ^ 01011111b = 11110000b
-10101111b ^ 01100000b = 11001111b
-10101111b ^ 01100001b = 11001110b
-10101111b ^ 01100010b = 11001101b
-10101111b ^ 01100011b = 11001100b
-10101111b ^ 01100100b = 11001011b
-10101111b ^ 01100101b = 11001010b
-10101111b ^ 01100110b = 11001001b
-10101111b ^ 01100111b = 11001000b
-10101111b ^ 01101000b = 11000111b
-10101111b ^ 01101001b = 11000110b
-10101111b ^ 01101010b = 11000101b
-10101111b ^ 01101011b = 11000100b
-10101111b ^ 01101100b = 11000011b
-10101111b ^ 01101101b = 11000010b
-10101111b ^ 01101110b = 11000001b
-10101111b ^ 01101111b = 11000000b
-10101111b ^ 01110000b = 11011111b
-10101111b ^ 01110001b = 11011110b
-10101111b ^ 01110010b = 11011101b
-10101111b ^ 01110011b = 11011100b
-10101111b ^ 01110100b = 11011011b
-10101111b ^ 01110101b = 11011010b
-10101111b ^ 01110110b = 11011001b
-10101111b ^ 01110111b = 11011000b
-10101111b ^ 01111000b = 11010111b
-10101111b ^ 01111001b = 11010110b
-10101111b ^ 01111010b = 11010101b
-10101111b ^ 01111011b = 11010100b
-10101111b ^ 01111100b = 11010011b
-10101111b ^ 01111101b = 11010010b
-10101111b ^ 01111110b = 11010001b
-10110000b ^ 10000000b = 00110000b
-10110000b ^ 10000001b = 00110001b
-10110000b ^ 10000010b = 00110010b
-10110000b ^ 10000011b = 00110011b
-10110000b ^ 10000100b = 00110100b
-10110000b ^ 10000101b = 00110101b
-10110000b ^ 10000110b = 00110110b
-10110000b ^ 10000111b = 00110111b
-10110000b ^ 10001000b = 00111000b
-10110000b ^ 10001001b = 00111001b
-10110000b ^ 10001010b = 00111010b
-10110000b ^ 10001011b = 00111011b
-10110000b ^ 10001100b = 00111100b
-10110000b ^ 10001101b = 00111101b
-10110000b ^ 10001110b = 00111110b
-10110000b ^ 10001111b = 00111111b
-10110000b ^ 10010000b = 00100000b
-10110000b ^ 10010001b = 00100001b
-10110000b ^ 10010010b = 00100010b
-10110000b ^ 10010011b = 00100011b
-10110000b ^ 10010100b = 00100100b
-10110000b ^ 10010101b = 00100101b
-10110000b ^ 10010110b = 00100110b
-10110000b ^ 10010111b = 00100111b
-10110000b ^ 10011000b = 00101000b
-10110000b ^ 10011001b = 00101001b
-10110000b ^ 10011010b = 00101010b
-10110000b ^ 10011011b = 00101011b
-10110000b ^ 10011100b = 00101100b
-10110000b ^ 10011101b = 00101101b
-10110000b ^ 10011110b = 00101110b
-10110000b ^ 10011111b = 00101111b
-10110000b ^ 10100000b = 00010000b
-10110000b ^ 10100001b = 00010001b
-10110000b ^ 10100010b = 00010010b
-10110000b ^ 10100011b = 00010011b
-10110000b ^ 10100100b = 00010100b
-10110000b ^ 10100101b = 00010101b
-10110000b ^ 10100110b = 00010110b
-10110000b ^ 10100111b = 00010111b
-10110000b ^ 10101000b = 00011000b
-10110000b ^ 10101001b = 00011001b
-10110000b ^ 10101010b = 00011010b
-10110000b ^ 10101011b = 00011011b
-10110000b ^ 10101100b = 00011100b
-10110000b ^ 10101101b = 00011101b
-10110000b ^ 10101110b = 00011110b
-10110000b ^ 10101111b = 00011111b
-10110000b ^ 10110000b = 00000000b
-10110000b ^ 10110001b = 00000001b
-10110000b ^ 10110010b = 00000010b
-10110000b ^ 10110011b = 00000011b
-10110000b ^ 10110100b = 00000100b
-10110000b ^ 10110101b = 00000101b
-10110000b ^ 10110110b = 00000110b
-10110000b ^ 10110111b = 00000111b
-10110000b ^ 10111000b = 00001000b
-10110000b ^ 10111001b = 00001001b
-10110000b ^ 10111010b = 00001010b
-10110000b ^ 10111011b = 00001011b
-10110000b ^ 10111100b = 00001100b
-10110000b ^ 10111101b = 00001101b
-10110000b ^ 10111110b = 00001110b
-10110000b ^ 10111111b = 00001111b
-10110000b ^ 11000000b = 01110000b
-10110000b ^ 11000001b = 01110001b
-10110000b ^ 11000010b = 01110010b
-10110000b ^ 11000011b = 01110011b
-10110000b ^ 11000100b = 01110100b
-10110000b ^ 11000101b = 01110101b
-10110000b ^ 11000110b = 01110110b
-10110000b ^ 11000111b = 01110111b
-10110000b ^ 11001000b = 01111000b
-10110000b ^ 11001001b = 01111001b
-10110000b ^ 11001010b = 01111010b
-10110000b ^ 11001011b = 01111011b
-10110000b ^ 11001100b = 01111100b
-10110000b ^ 11001101b = 01111101b
-10110000b ^ 11001110b = 01111110b
-10110000b ^ 11001111b = 01111111b
-10110000b ^ 11010000b = 01100000b
-10110000b ^ 11010001b = 01100001b
-10110000b ^ 11010010b = 01100010b
-10110000b ^ 11010011b = 01100011b
-10110000b ^ 11010100b = 01100100b
-10110000b ^ 11010101b = 01100101b
-10110000b ^ 11010110b = 01100110b
-10110000b ^ 11010111b = 01100111b
-10110000b ^ 11011000b = 01101000b
-10110000b ^ 11011001b = 01101001b
-10110000b ^ 11011010b = 01101010b
-10110000b ^ 11011011b = 01101011b
-10110000b ^ 11011100b = 01101100b
-10110000b ^ 11011101b = 01101101b
-10110000b ^ 11011110b = 01101110b
-10110000b ^ 11011111b = 01101111b
-10110000b ^ 11100000b = 01010000b
-10110000b ^ 11100001b = 01010001b
-10110000b ^ 11100010b = 01010010b
-10110000b ^ 11100011b = 01010011b
-10110000b ^ 11100100b = 01010100b
-10110000b ^ 11100101b = 01010101b
-10110000b ^ 11100110b = 01010110b
-10110000b ^ 11100111b = 01010111b
-10110000b ^ 11101000b = 01011000b
-10110000b ^ 11101001b = 01011001b
-10110000b ^ 11101010b = 01011010b
-10110000b ^ 11101011b = 01011011b
-10110000b ^ 11101100b = 01011100b
-10110000b ^ 11101101b = 01011101b
-10110000b ^ 11101110b = 01011110b
-10110000b ^ 11101111b = 01011111b
-10110000b ^ 11110000b = 01000000b
-10110000b ^ 11110001b = 01000001b
-10110000b ^ 11110010b = 01000010b
-10110000b ^ 11110011b = 01000011b
-10110000b ^ 11110100b = 01000100b
-10110000b ^ 11110101b = 01000101b
-10110000b ^ 11110110b = 01000110b
-10110000b ^ 11110111b = 01000111b
-10110000b ^ 11111000b = 01001000b
-10110000b ^ 11111001b = 01001001b
-10110000b ^ 11111010b = 01001010b
-10110000b ^ 11111011b = 01001011b
-10110000b ^ 11111100b = 01001100b
-10110000b ^ 11111101b = 01001101b
-10110000b ^ 11111110b = 01001110b
-10110000b ^ 11111111b = 01001111b
-10110000b ^ 00000000b = 10110000b
-10110000b ^ 00000001b = 10110001b
-10110000b ^ 00000010b = 10110010b
-10110000b ^ 00000011b = 10110011b
-10110000b ^ 00000100b = 10110100b
-10110000b ^ 00000101b = 10110101b
-10110000b ^ 00000110b = 10110110b
-10110000b ^ 00000111b = 10110111b
-10110000b ^ 00001000b = 10111000b
-10110000b ^ 00001001b = 10111001b
-10110000b ^ 00001010b = 10111010b
-10110000b ^ 00001011b = 10111011b
-10110000b ^ 00001100b = 10111100b
-10110000b ^ 00001101b = 10111101b
-10110000b ^ 00001110b = 10111110b
-10110000b ^ 00001111b = 10111111b
-10110000b ^ 00010000b = 10100000b
-10110000b ^ 00010001b = 10100001b
-10110000b ^ 00010010b = 10100010b
-10110000b ^ 00010011b = 10100011b
-10110000b ^ 00010100b = 10100100b
-10110000b ^ 00010101b = 10100101b
-10110000b ^ 00010110b = 10100110b
-10110000b ^ 00010111b = 10100111b
-10110000b ^ 00011000b = 10101000b
-10110000b ^ 00011001b = 10101001b
-10110000b ^ 00011010b = 10101010b
-10110000b ^ 00011011b = 10101011b
-10110000b ^ 00011100b = 10101100b
-10110000b ^ 00011101b = 10101101b
-10110000b ^ 00011110b = 10101110b
-10110000b ^ 00011111b = 10101111b
-10110000b ^ 00100000b = 10010000b
-10110000b ^ 00100001b = 10010001b
-10110000b ^ 00100010b = 10010010b
-10110000b ^ 00100011b = 10010011b
-10110000b ^ 00100100b = 10010100b
-10110000b ^ 00100101b = 10010101b
-10110000b ^ 00100110b = 10010110b
-10110000b ^ 00100111b = 10010111b
-10110000b ^ 00101000b = 10011000b
-10110000b ^ 00101001b = 10011001b
-10110000b ^ 00101010b = 10011010b
-10110000b ^ 00101011b = 10011011b
-10110000b ^ 00101100b = 10011100b
-10110000b ^ 00101101b = 10011101b
-10110000b ^ 00101110b = 10011110b
-10110000b ^ 00101111b = 10011111b
-10110000b ^ 00110000b = 10000000b
-10110000b ^ 00110001b = 10000001b
-10110000b ^ 00110010b = 10000010b
-10110000b ^ 00110011b = 10000011b
-10110000b ^ 00110100b = 10000100b
-10110000b ^ 00110101b = 10000101b
-10110000b ^ 00110110b = 10000110b
-10110000b ^ 00110111b = 10000111b
-10110000b ^ 00111000b = 10001000b
-10110000b ^ 00111001b = 10001001b
-10110000b ^ 00111010b = 10001010b
-10110000b ^ 00111011b = 10001011b
-10110000b ^ 00111100b = 10001100b
-10110000b ^ 00111101b = 10001101b
-10110000b ^ 00111110b = 10001110b
-10110000b ^ 00111111b = 10001111b
-10110000b ^ 01000000b = 11110000b
-10110000b ^ 01000001b = 11110001b
-10110000b ^ 01000010b = 11110010b
-10110000b ^ 01000011b = 11110011b
-10110000b ^ 01000100b = 11110100b
-10110000b ^ 01000101b = 11110101b
-10110000b ^ 01000110b = 11110110b
-10110000b ^ 01000111b = 11110111b
-10110000b ^ 01001000b = 11111000b
-10110000b ^ 01001001b = 11111001b
-10110000b ^ 01001010b = 11111010b
-10110000b ^ 01001011b = 11111011b
-10110000b ^ 01001100b = 11111100b
-10110000b ^ 01001101b = 11111101b
-10110000b ^ 01001110b = 11111110b
-10110000b ^ 01001111b = 11111111b
-10110000b ^ 01010000b = 11100000b
-10110000b ^ 01010001b = 11100001b
-10110000b ^ 01010010b = 11100010b
-10110000b ^ 01010011b = 11100011b
-10110000b ^ 01010100b = 11100100b
-10110000b ^ 01010101b = 11100101b
-10110000b ^ 01010110b = 11100110b
-10110000b ^ 01010111b = 11100111b
-10110000b ^ 01011000b = 11101000b
-10110000b ^ 01011001b = 11101001b
-10110000b ^ 01011010b = 11101010b
-10110000b ^ 01011011b = 11101011b
-10110000b ^ 01011100b = 11101100b
-10110000b ^ 01011101b = 11101101b
-10110000b ^ 01011110b = 11101110b
-10110000b ^ 01011111b = 11101111b
-10110000b ^ 01100000b = 11010000b
-10110000b ^ 01100001b = 11010001b
-10110000b ^ 01100010b = 11010010b
-10110000b ^ 01100011b = 11010011b
-10110000b ^ 01100100b = 11010100b
-10110000b ^ 01100101b = 11010101b
-10110000b ^ 01100110b = 11010110b
-10110000b ^ 01100111b = 11010111b
-10110000b ^ 01101000b = 11011000b
-10110000b ^ 01101001b = 11011001b
-10110000b ^ 01101010b = 11011010b
-10110000b ^ 01101011b = 11011011b
-10110000b ^ 01101100b = 11011100b
-10110000b ^ 01101101b = 11011101b
-10110000b ^ 01101110b = 11011110b
-10110000b ^ 01101111b = 11011111b
-10110000b ^ 01110000b = 11000000b
-10110000b ^ 01110001b = 11000001b
-10110000b ^ 01110010b = 11000010b
-10110000b ^ 01110011b = 11000011b
-10110000b ^ 01110100b = 11000100b
-10110000b ^ 01110101b = 11000101b
-10110000b ^ 01110110b = 11000110b
-10110000b ^ 01110111b = 11000111b
-10110000b ^ 01111000b = 11001000b
-10110000b ^ 01111001b = 11001001b
-10110000b ^ 01111010b = 11001010b
-10110000b ^ 01111011b = 11001011b
-10110000b ^ 01111100b = 11001100b
-10110000b ^ 01111101b = 11001101b
-10110000b ^ 01111110b = 11001110b
-10110001b ^ 10000000b = 00110001b
-10110001b ^ 10000001b = 00110000b
-10110001b ^ 10000010b = 00110011b
-10110001b ^ 10000011b = 00110010b
-10110001b ^ 10000100b = 00110101b
-10110001b ^ 10000101b = 00110100b
-10110001b ^ 10000110b = 00110111b
-10110001b ^ 10000111b = 00110110b
-10110001b ^ 10001000b = 00111001b
-10110001b ^ 10001001b = 00111000b
-10110001b ^ 10001010b = 00111011b
-10110001b ^ 10001011b = 00111010b
-10110001b ^ 10001100b = 00111101b
-10110001b ^ 10001101b = 00111100b
-10110001b ^ 10001110b = 00111111b
-10110001b ^ 10001111b = 00111110b
-10110001b ^ 10010000b = 00100001b
-10110001b ^ 10010001b = 00100000b
-10110001b ^ 10010010b = 00100011b
-10110001b ^ 10010011b = 00100010b
-10110001b ^ 10010100b = 00100101b
-10110001b ^ 10010101b = 00100100b
-10110001b ^ 10010110b = 00100111b
-10110001b ^ 10010111b = 00100110b
-10110001b ^ 10011000b = 00101001b
-10110001b ^ 10011001b = 00101000b
-10110001b ^ 10011010b = 00101011b
-10110001b ^ 10011011b = 00101010b
-10110001b ^ 10011100b = 00101101b
-10110001b ^ 10011101b = 00101100b
-10110001b ^ 10011110b = 00101111b
-10110001b ^ 10011111b = 00101110b
-10110001b ^ 10100000b = 00010001b
-10110001b ^ 10100001b = 00010000b
-10110001b ^ 10100010b = 00010011b
-10110001b ^ 10100011b = 00010010b
-10110001b ^ 10100100b = 00010101b
-10110001b ^ 10100101b = 00010100b
-10110001b ^ 10100110b = 00010111b
-10110001b ^ 10100111b = 00010110b
-10110001b ^ 10101000b = 00011001b
-10110001b ^ 10101001b = 00011000b
-10110001b ^ 10101010b = 00011011b
-10110001b ^ 10101011b = 00011010b
-10110001b ^ 10101100b = 00011101b
-10110001b ^ 10101101b = 00011100b
-10110001b ^ 10101110b = 00011111b
-10110001b ^ 10101111b = 00011110b
-10110001b ^ 10110000b = 00000001b
-10110001b ^ 10110001b = 00000000b
-10110001b ^ 10110010b = 00000011b
-10110001b ^ 10110011b = 00000010b
-10110001b ^ 10110100b = 00000101b
-10110001b ^ 10110101b = 00000100b
-10110001b ^ 10110110b = 00000111b
-10110001b ^ 10110111b = 00000110b
-10110001b ^ 10111000b = 00001001b
-10110001b ^ 10111001b = 00001000b
-10110001b ^ 10111010b = 00001011b
-10110001b ^ 10111011b = 00001010b
-10110001b ^ 10111100b = 00001101b
-10110001b ^ 10111101b = 00001100b
-10110001b ^ 10111110b = 00001111b
-10110001b ^ 10111111b = 00001110b
-10110001b ^ 11000000b = 01110001b
-10110001b ^ 11000001b = 01110000b
-10110001b ^ 11000010b = 01110011b
-10110001b ^ 11000011b = 01110010b
-10110001b ^ 11000100b = 01110101b
-10110001b ^ 11000101b = 01110100b
-10110001b ^ 11000110b = 01110111b
-10110001b ^ 11000111b = 01110110b
-10110001b ^ 11001000b = 01111001b
-10110001b ^ 11001001b = 01111000b
-10110001b ^ 11001010b = 01111011b
-10110001b ^ 11001011b = 01111010b
-10110001b ^ 11001100b = 01111101b
-10110001b ^ 11001101b = 01111100b
-10110001b ^ 11001110b = 01111111b
-10110001b ^ 11001111b = 01111110b
-10110001b ^ 11010000b = 01100001b
-10110001b ^ 11010001b = 01100000b
-10110001b ^ 11010010b = 01100011b
-10110001b ^ 11010011b = 01100010b
-10110001b ^ 11010100b = 01100101b
-10110001b ^ 11010101b = 01100100b
-10110001b ^ 11010110b = 01100111b
-10110001b ^ 11010111b = 01100110b
-10110001b ^ 11011000b = 01101001b
-10110001b ^ 11011001b = 01101000b
-10110001b ^ 11011010b = 01101011b
-10110001b ^ 11011011b = 01101010b
-10110001b ^ 11011100b = 01101101b
-10110001b ^ 11011101b = 01101100b
-10110001b ^ 11011110b = 01101111b
-10110001b ^ 11011111b = 01101110b
-10110001b ^ 11100000b = 01010001b
-10110001b ^ 11100001b = 01010000b
-10110001b ^ 11100010b = 01010011b
-10110001b ^ 11100011b = 01010010b
-10110001b ^ 11100100b = 01010101b
-10110001b ^ 11100101b = 01010100b
-10110001b ^ 11100110b = 01010111b
-10110001b ^ 11100111b = 01010110b
-10110001b ^ 11101000b = 01011001b
-10110001b ^ 11101001b = 01011000b
-10110001b ^ 11101010b = 01011011b
-10110001b ^ 11101011b = 01011010b
-10110001b ^ 11101100b = 01011101b
-10110001b ^ 11101101b = 01011100b
-10110001b ^ 11101110b = 01011111b
-10110001b ^ 11101111b = 01011110b
-10110001b ^ 11110000b = 01000001b
-10110001b ^ 11110001b = 01000000b
-10110001b ^ 11110010b = 01000011b
-10110001b ^ 11110011b = 01000010b
-10110001b ^ 11110100b = 01000101b
-10110001b ^ 11110101b = 01000100b
-10110001b ^ 11110110b = 01000111b
-10110001b ^ 11110111b = 01000110b
-10110001b ^ 11111000b = 01001001b
-10110001b ^ 11111001b = 01001000b
-10110001b ^ 11111010b = 01001011b
-10110001b ^ 11111011b = 01001010b
-10110001b ^ 11111100b = 01001101b
-10110001b ^ 11111101b = 01001100b
-10110001b ^ 11111110b = 01001111b
-10110001b ^ 11111111b = 01001110b
-10110001b ^ 00000000b = 10110001b
-10110001b ^ 00000001b = 10110000b
-10110001b ^ 00000010b = 10110011b
-10110001b ^ 00000011b = 10110010b
-10110001b ^ 00000100b = 10110101b
-10110001b ^ 00000101b = 10110100b
-10110001b ^ 00000110b = 10110111b
-10110001b ^ 00000111b = 10110110b
-10110001b ^ 00001000b = 10111001b
-10110001b ^ 00001001b = 10111000b
-10110001b ^ 00001010b = 10111011b
-10110001b ^ 00001011b = 10111010b
-10110001b ^ 00001100b = 10111101b
-10110001b ^ 00001101b = 10111100b
-10110001b ^ 00001110b = 10111111b
-10110001b ^ 00001111b = 10111110b
-10110001b ^ 00010000b = 10100001b
-10110001b ^ 00010001b = 10100000b
-10110001b ^ 00010010b = 10100011b
-10110001b ^ 00010011b = 10100010b
-10110001b ^ 00010100b = 10100101b
-10110001b ^ 00010101b = 10100100b
-10110001b ^ 00010110b = 10100111b
-10110001b ^ 00010111b = 10100110b
-10110001b ^ 00011000b = 10101001b
-10110001b ^ 00011001b = 10101000b
-10110001b ^ 00011010b = 10101011b
-10110001b ^ 00011011b = 10101010b
-10110001b ^ 00011100b = 10101101b
-10110001b ^ 00011101b = 10101100b
-10110001b ^ 00011110b = 10101111b
-10110001b ^ 00011111b = 10101110b
-10110001b ^ 00100000b = 10010001b
-10110001b ^ 00100001b = 10010000b
-10110001b ^ 00100010b = 10010011b
-10110001b ^ 00100011b = 10010010b
-10110001b ^ 00100100b = 10010101b
-10110001b ^ 00100101b = 10010100b
-10110001b ^ 00100110b = 10010111b
-10110001b ^ 00100111b = 10010110b
-10110001b ^ 00101000b = 10011001b
-10110001b ^ 00101001b = 10011000b
-10110001b ^ 00101010b = 10011011b
-10110001b ^ 00101011b = 10011010b
-10110001b ^ 00101100b = 10011101b
-10110001b ^ 00101101b = 10011100b
-10110001b ^ 00101110b = 10011111b
-10110001b ^ 00101111b = 10011110b
-10110001b ^ 00110000b = 10000001b
-10110001b ^ 00110001b = 10000000b
-10110001b ^ 00110010b = 10000011b
-10110001b ^ 00110011b = 10000010b
-10110001b ^ 00110100b = 10000101b
-10110001b ^ 00110101b = 10000100b
-10110001b ^ 00110110b = 10000111b
-10110001b ^ 00110111b = 10000110b
-10110001b ^ 00111000b = 10001001b
-10110001b ^ 00111001b = 10001000b
-10110001b ^ 00111010b = 10001011b
-10110001b ^ 00111011b = 10001010b
-10110001b ^ 00111100b = 10001101b
-10110001b ^ 00111101b = 10001100b
-10110001b ^ 00111110b = 10001111b
-10110001b ^ 00111111b = 10001110b
-10110001b ^ 01000000b = 11110001b
-10110001b ^ 01000001b = 11110000b
-10110001b ^ 01000010b = 11110011b
-10110001b ^ 01000011b = 11110010b
-10110001b ^ 01000100b = 11110101b
-10110001b ^ 01000101b = 11110100b
-10110001b ^ 01000110b = 11110111b
-10110001b ^ 01000111b = 11110110b
-10110001b ^ 01001000b = 11111001b
-10110001b ^ 01001001b = 11111000b
-10110001b ^ 01001010b = 11111011b
-10110001b ^ 01001011b = 11111010b
-10110001b ^ 01001100b = 11111101b
-10110001b ^ 01001101b = 11111100b
-10110001b ^ 01001110b = 11111111b
-10110001b ^ 01001111b = 11111110b
-10110001b ^ 01010000b = 11100001b
-10110001b ^ 01010001b = 11100000b
-10110001b ^ 01010010b = 11100011b
-10110001b ^ 01010011b = 11100010b
-10110001b ^ 01010100b = 11100101b
-10110001b ^ 01010101b = 11100100b
-10110001b ^ 01010110b = 11100111b
-10110001b ^ 01010111b = 11100110b
-10110001b ^ 01011000b = 11101001b
-10110001b ^ 01011001b = 11101000b
-10110001b ^ 01011010b = 11101011b
-10110001b ^ 01011011b = 11101010b
-10110001b ^ 01011100b = 11101101b
-10110001b ^ 01011101b = 11101100b
-10110001b ^ 01011110b = 11101111b
-10110001b ^ 01011111b = 11101110b
-10110001b ^ 01100000b = 11010001b
-10110001b ^ 01100001b = 11010000b
-10110001b ^ 01100010b = 11010011b
-10110001b ^ 01100011b = 11010010b
-10110001b ^ 01100100b = 11010101b
-10110001b ^ 01100101b = 11010100b
-10110001b ^ 01100110b = 11010111b
-10110001b ^ 01100111b = 11010110b
-10110001b ^ 01101000b = 11011001b
-10110001b ^ 01101001b = 11011000b
-10110001b ^ 01101010b = 11011011b
-10110001b ^ 01101011b = 11011010b
-10110001b ^ 01101100b = 11011101b
-10110001b ^ 01101101b = 11011100b
-10110001b ^ 01101110b = 11011111b
-10110001b ^ 01101111b = 11011110b
-10110001b ^ 01110000b = 11000001b
-10110001b ^ 01110001b = 11000000b
-10110001b ^ 01110010b = 11000011b
-10110001b ^ 01110011b = 11000010b
-10110001b ^ 01110100b = 11000101b
-10110001b ^ 01110101b = 11000100b
-10110001b ^ 01110110b = 11000111b
-10110001b ^ 01110111b = 11000110b
-10110001b ^ 01111000b = 11001001b
-10110001b ^ 01111001b = 11001000b
-10110001b ^ 01111010b = 11001011b
-10110001b ^ 01111011b = 11001010b
-10110001b ^ 01111100b = 11001101b
-10110001b ^ 01111101b = 11001100b
-10110001b ^ 01111110b = 11001111b
-10110010b ^ 10000000b = 00110010b
-10110010b ^ 10000001b = 00110011b
-10110010b ^ 10000010b = 00110000b
-10110010b ^ 10000011b = 00110001b
-10110010b ^ 10000100b = 00110110b
-10110010b ^ 10000101b = 00110111b
-10110010b ^ 10000110b = 00110100b
-10110010b ^ 10000111b = 00110101b
-10110010b ^ 10001000b = 00111010b
-10110010b ^ 10001001b = 00111011b
-10110010b ^ 10001010b = 00111000b
-10110010b ^ 10001011b = 00111001b
-10110010b ^ 10001100b = 00111110b
-10110010b ^ 10001101b = 00111111b
-10110010b ^ 10001110b = 00111100b
-10110010b ^ 10001111b = 00111101b
-10110010b ^ 10010000b = 00100010b
-10110010b ^ 10010001b = 00100011b
-10110010b ^ 10010010b = 00100000b
-10110010b ^ 10010011b = 00100001b
-10110010b ^ 10010100b = 00100110b
-10110010b ^ 10010101b = 00100111b
-10110010b ^ 10010110b = 00100100b
-10110010b ^ 10010111b = 00100101b
-10110010b ^ 10011000b = 00101010b
-10110010b ^ 10011001b = 00101011b
-10110010b ^ 10011010b = 00101000b
-10110010b ^ 10011011b = 00101001b
-10110010b ^ 10011100b = 00101110b
-10110010b ^ 10011101b = 00101111b
-10110010b ^ 10011110b = 00101100b
-10110010b ^ 10011111b = 00101101b
-10110010b ^ 10100000b = 00010010b
-10110010b ^ 10100001b = 00010011b
-10110010b ^ 10100010b = 00010000b
-10110010b ^ 10100011b = 00010001b
-10110010b ^ 10100100b = 00010110b
-10110010b ^ 10100101b = 00010111b
-10110010b ^ 10100110b = 00010100b
-10110010b ^ 10100111b = 00010101b
-10110010b ^ 10101000b = 00011010b
-10110010b ^ 10101001b = 00011011b
-10110010b ^ 10101010b = 00011000b
-10110010b ^ 10101011b = 00011001b
-10110010b ^ 10101100b = 00011110b
-10110010b ^ 10101101b = 00011111b
-10110010b ^ 10101110b = 00011100b
-10110010b ^ 10101111b = 00011101b
-10110010b ^ 10110000b = 00000010b
-10110010b ^ 10110001b = 00000011b
-10110010b ^ 10110010b = 00000000b
-10110010b ^ 10110011b = 00000001b
-10110010b ^ 10110100b = 00000110b
-10110010b ^ 10110101b = 00000111b
-10110010b ^ 10110110b = 00000100b
-10110010b ^ 10110111b = 00000101b
-10110010b ^ 10111000b = 00001010b
-10110010b ^ 10111001b = 00001011b
-10110010b ^ 10111010b = 00001000b
-10110010b ^ 10111011b = 00001001b
-10110010b ^ 10111100b = 00001110b
-10110010b ^ 10111101b = 00001111b
-10110010b ^ 10111110b = 00001100b
-10110010b ^ 10111111b = 00001101b
-10110010b ^ 11000000b = 01110010b
-10110010b ^ 11000001b = 01110011b
-10110010b ^ 11000010b = 01110000b
-10110010b ^ 11000011b = 01110001b
-10110010b ^ 11000100b = 01110110b
-10110010b ^ 11000101b = 01110111b
-10110010b ^ 11000110b = 01110100b
-10110010b ^ 11000111b = 01110101b
-10110010b ^ 11001000b = 01111010b
-10110010b ^ 11001001b = 01111011b
-10110010b ^ 11001010b = 01111000b
-10110010b ^ 11001011b = 01111001b
-10110010b ^ 11001100b = 01111110b
-10110010b ^ 11001101b = 01111111b
-10110010b ^ 11001110b = 01111100b
-10110010b ^ 11001111b = 01111101b
-10110010b ^ 11010000b = 01100010b
-10110010b ^ 11010001b = 01100011b
-10110010b ^ 11010010b = 01100000b
-10110010b ^ 11010011b = 01100001b
-10110010b ^ 11010100b = 01100110b
-10110010b ^ 11010101b = 01100111b
-10110010b ^ 11010110b = 01100100b
-10110010b ^ 11010111b = 01100101b
-10110010b ^ 11011000b = 01101010b
-10110010b ^ 11011001b = 01101011b
-10110010b ^ 11011010b = 01101000b
-10110010b ^ 11011011b = 01101001b
-10110010b ^ 11011100b = 01101110b
-10110010b ^ 11011101b = 01101111b
-10110010b ^ 11011110b = 01101100b
-10110010b ^ 11011111b = 01101101b
-10110010b ^ 11100000b = 01010010b
-10110010b ^ 11100001b = 01010011b
-10110010b ^ 11100010b = 01010000b
-10110010b ^ 11100011b = 01010001b
-10110010b ^ 11100100b = 01010110b
-10110010b ^ 11100101b = 01010111b
-10110010b ^ 11100110b = 01010100b
-10110010b ^ 11100111b = 01010101b
-10110010b ^ 11101000b = 01011010b
-10110010b ^ 11101001b = 01011011b
-10110010b ^ 11101010b = 01011000b
-10110010b ^ 11101011b = 01011001b
-10110010b ^ 11101100b = 01011110b
-10110010b ^ 11101101b = 01011111b
-10110010b ^ 11101110b = 01011100b
-10110010b ^ 11101111b = 01011101b
-10110010b ^ 11110000b = 01000010b
-10110010b ^ 11110001b = 01000011b
-10110010b ^ 11110010b = 01000000b
-10110010b ^ 11110011b = 01000001b
-10110010b ^ 11110100b = 01000110b
-10110010b ^ 11110101b = 01000111b
-10110010b ^ 11110110b = 01000100b
-10110010b ^ 11110111b = 01000101b
-10110010b ^ 11111000b = 01001010b
-10110010b ^ 11111001b = 01001011b
-10110010b ^ 11111010b = 01001000b
-10110010b ^ 11111011b = 01001001b
-10110010b ^ 11111100b = 01001110b
-10110010b ^ 11111101b = 01001111b
-10110010b ^ 11111110b = 01001100b
-10110010b ^ 11111111b = 01001101b
-10110010b ^ 00000000b = 10110010b
-10110010b ^ 00000001b = 10110011b
-10110010b ^ 00000010b = 10110000b
-10110010b ^ 00000011b = 10110001b
-10110010b ^ 00000100b = 10110110b
-10110010b ^ 00000101b = 10110111b
-10110010b ^ 00000110b = 10110100b
-10110010b ^ 00000111b = 10110101b
-10110010b ^ 00001000b = 10111010b
-10110010b ^ 00001001b = 10111011b
-10110010b ^ 00001010b = 10111000b
-10110010b ^ 00001011b = 10111001b
-10110010b ^ 00001100b = 10111110b
-10110010b ^ 00001101b = 10111111b
-10110010b ^ 00001110b = 10111100b
-10110010b ^ 00001111b = 10111101b
-10110010b ^ 00010000b = 10100010b
-10110010b ^ 00010001b = 10100011b
-10110010b ^ 00010010b = 10100000b
-10110010b ^ 00010011b = 10100001b
-10110010b ^ 00010100b = 10100110b
-10110010b ^ 00010101b = 10100111b
-10110010b ^ 00010110b = 10100100b
-10110010b ^ 00010111b = 10100101b
-10110010b ^ 00011000b = 10101010b
-10110010b ^ 00011001b = 10101011b
-10110010b ^ 00011010b = 10101000b
-10110010b ^ 00011011b = 10101001b
-10110010b ^ 00011100b = 10101110b
-10110010b ^ 00011101b = 10101111b
-10110010b ^ 00011110b = 10101100b
-10110010b ^ 00011111b = 10101101b
-10110010b ^ 00100000b = 10010010b
-10110010b ^ 00100001b = 10010011b
-10110010b ^ 00100010b = 10010000b
-10110010b ^ 00100011b = 10010001b
-10110010b ^ 00100100b = 10010110b
-10110010b ^ 00100101b = 10010111b
-10110010b ^ 00100110b = 10010100b
-10110010b ^ 00100111b = 10010101b
-10110010b ^ 00101000b = 10011010b
-10110010b ^ 00101001b = 10011011b
-10110010b ^ 00101010b = 10011000b
-10110010b ^ 00101011b = 10011001b
-10110010b ^ 00101100b = 10011110b
-10110010b ^ 00101101b = 10011111b
-10110010b ^ 00101110b = 10011100b
-10110010b ^ 00101111b = 10011101b
-10110010b ^ 00110000b = 10000010b
-10110010b ^ 00110001b = 10000011b
-10110010b ^ 00110010b = 10000000b
-10110010b ^ 00110011b = 10000001b
-10110010b ^ 00110100b = 10000110b
-10110010b ^ 00110101b = 10000111b
-10110010b ^ 00110110b = 10000100b
-10110010b ^ 00110111b = 10000101b
-10110010b ^ 00111000b = 10001010b
-10110010b ^ 00111001b = 10001011b
-10110010b ^ 00111010b = 10001000b
-10110010b ^ 00111011b = 10001001b
-10110010b ^ 00111100b = 10001110b
-10110010b ^ 00111101b = 10001111b
-10110010b ^ 00111110b = 10001100b
-10110010b ^ 00111111b = 10001101b
-10110010b ^ 01000000b = 11110010b
-10110010b ^ 01000001b = 11110011b
-10110010b ^ 01000010b = 11110000b
-10110010b ^ 01000011b = 11110001b
-10110010b ^ 01000100b = 11110110b
-10110010b ^ 01000101b = 11110111b
-10110010b ^ 01000110b = 11110100b
-10110010b ^ 01000111b = 11110101b
-10110010b ^ 01001000b = 11111010b
-10110010b ^ 01001001b = 11111011b
-10110010b ^ 01001010b = 11111000b
-10110010b ^ 01001011b = 11111001b
-10110010b ^ 01001100b = 11111110b
-10110010b ^ 01001101b = 11111111b
-10110010b ^ 01001110b = 11111100b
-10110010b ^ 01001111b = 11111101b
-10110010b ^ 01010000b = 11100010b
-10110010b ^ 01010001b = 11100011b
-10110010b ^ 01010010b = 11100000b
-10110010b ^ 01010011b = 11100001b
-10110010b ^ 01010100b = 11100110b
-10110010b ^ 01010101b = 11100111b
-10110010b ^ 01010110b = 11100100b
-10110010b ^ 01010111b = 11100101b
-10110010b ^ 01011000b = 11101010b
-10110010b ^ 01011001b = 11101011b
-10110010b ^ 01011010b = 11101000b
-10110010b ^ 01011011b = 11101001b
-10110010b ^ 01011100b = 11101110b
-10110010b ^ 01011101b = 11101111b
-10110010b ^ 01011110b = 11101100b
-10110010b ^ 01011111b = 11101101b
-10110010b ^ 01100000b = 11010010b
-10110010b ^ 01100001b = 11010011b
-10110010b ^ 01100010b = 11010000b
-10110010b ^ 01100011b = 11010001b
-10110010b ^ 01100100b = 11010110b
-10110010b ^ 01100101b = 11010111b
-10110010b ^ 01100110b = 11010100b
-10110010b ^ 01100111b = 11010101b
-10110010b ^ 01101000b = 11011010b
-10110010b ^ 01101001b = 11011011b
-10110010b ^ 01101010b = 11011000b
-10110010b ^ 01101011b = 11011001b
-10110010b ^ 01101100b = 11011110b
-10110010b ^ 01101101b = 11011111b
-10110010b ^ 01101110b = 11011100b
-10110010b ^ 01101111b = 11011101b
-10110010b ^ 01110000b = 11000010b
-10110010b ^ 01110001b = 11000011b
-10110010b ^ 01110010b = 11000000b
-10110010b ^ 01110011b = 11000001b
-10110010b ^ 01110100b = 11000110b
-10110010b ^ 01110101b = 11000111b
-10110010b ^ 01110110b = 11000100b
-10110010b ^ 01110111b = 11000101b
-10110010b ^ 01111000b = 11001010b
-10110010b ^ 01111001b = 11001011b
-10110010b ^ 01111010b = 11001000b
-10110010b ^ 01111011b = 11001001b
-10110010b ^ 01111100b = 11001110b
-10110010b ^ 01111101b = 11001111b
-10110010b ^ 01111110b = 11001100b
-10110011b ^ 10000000b = 00110011b
-10110011b ^ 10000001b = 00110010b
-10110011b ^ 10000010b = 00110001b
-10110011b ^ 10000011b = 00110000b
-10110011b ^ 10000100b = 00110111b
-10110011b ^ 10000101b = 00110110b
-10110011b ^ 10000110b = 00110101b
-10110011b ^ 10000111b = 00110100b
-10110011b ^ 10001000b = 00111011b
-10110011b ^ 10001001b = 00111010b
-10110011b ^ 10001010b = 00111001b
-10110011b ^ 10001011b = 00111000b
-10110011b ^ 10001100b = 00111111b
-10110011b ^ 10001101b = 00111110b
-10110011b ^ 10001110b = 00111101b
-10110011b ^ 10001111b = 00111100b
-10110011b ^ 10010000b = 00100011b
-10110011b ^ 10010001b = 00100010b
-10110011b ^ 10010010b = 00100001b
-10110011b ^ 10010011b = 00100000b
-10110011b ^ 10010100b = 00100111b
-10110011b ^ 10010101b = 00100110b
-10110011b ^ 10010110b = 00100101b
-10110011b ^ 10010111b = 00100100b
-10110011b ^ 10011000b = 00101011b
-10110011b ^ 10011001b = 00101010b
-10110011b ^ 10011010b = 00101001b
-10110011b ^ 10011011b = 00101000b
-10110011b ^ 10011100b = 00101111b
-10110011b ^ 10011101b = 00101110b
-10110011b ^ 10011110b = 00101101b
-10110011b ^ 10011111b = 00101100b
-10110011b ^ 10100000b = 00010011b
-10110011b ^ 10100001b = 00010010b
-10110011b ^ 10100010b = 00010001b
-10110011b ^ 10100011b = 00010000b
-10110011b ^ 10100100b = 00010111b
-10110011b ^ 10100101b = 00010110b
-10110011b ^ 10100110b = 00010101b
-10110011b ^ 10100111b = 00010100b
-10110011b ^ 10101000b = 00011011b
-10110011b ^ 10101001b = 00011010b
-10110011b ^ 10101010b = 00011001b
-10110011b ^ 10101011b = 00011000b
-10110011b ^ 10101100b = 00011111b
-10110011b ^ 10101101b = 00011110b
-10110011b ^ 10101110b = 00011101b
-10110011b ^ 10101111b = 00011100b
-10110011b ^ 10110000b = 00000011b
-10110011b ^ 10110001b = 00000010b
-10110011b ^ 10110010b = 00000001b
-10110011b ^ 10110011b = 00000000b
-10110011b ^ 10110100b = 00000111b
-10110011b ^ 10110101b = 00000110b
-10110011b ^ 10110110b = 00000101b
-10110011b ^ 10110111b = 00000100b
-10110011b ^ 10111000b = 00001011b
-10110011b ^ 10111001b = 00001010b
-10110011b ^ 10111010b = 00001001b
-10110011b ^ 10111011b = 00001000b
-10110011b ^ 10111100b = 00001111b
-10110011b ^ 10111101b = 00001110b
-10110011b ^ 10111110b = 00001101b
-10110011b ^ 10111111b = 00001100b
-10110011b ^ 11000000b = 01110011b
-10110011b ^ 11000001b = 01110010b
-10110011b ^ 11000010b = 01110001b
-10110011b ^ 11000011b = 01110000b
-10110011b ^ 11000100b = 01110111b
-10110011b ^ 11000101b = 01110110b
-10110011b ^ 11000110b = 01110101b
-10110011b ^ 11000111b = 01110100b
-10110011b ^ 11001000b = 01111011b
-10110011b ^ 11001001b = 01111010b
-10110011b ^ 11001010b = 01111001b
-10110011b ^ 11001011b = 01111000b
-10110011b ^ 11001100b = 01111111b
-10110011b ^ 11001101b = 01111110b
-10110011b ^ 11001110b = 01111101b
-10110011b ^ 11001111b = 01111100b
-10110011b ^ 11010000b = 01100011b
-10110011b ^ 11010001b = 01100010b
-10110011b ^ 11010010b = 01100001b
-10110011b ^ 11010011b = 01100000b
-10110011b ^ 11010100b = 01100111b
-10110011b ^ 11010101b = 01100110b
-10110011b ^ 11010110b = 01100101b
-10110011b ^ 11010111b = 01100100b
-10110011b ^ 11011000b = 01101011b
-10110011b ^ 11011001b = 01101010b
-10110011b ^ 11011010b = 01101001b
-10110011b ^ 11011011b = 01101000b
-10110011b ^ 11011100b = 01101111b
-10110011b ^ 11011101b = 01101110b
-10110011b ^ 11011110b = 01101101b
-10110011b ^ 11011111b = 01101100b
-10110011b ^ 11100000b = 01010011b
-10110011b ^ 11100001b = 01010010b
-10110011b ^ 11100010b = 01010001b
-10110011b ^ 11100011b = 01010000b
-10110011b ^ 11100100b = 01010111b
-10110011b ^ 11100101b = 01010110b
-10110011b ^ 11100110b = 01010101b
-10110011b ^ 11100111b = 01010100b
-10110011b ^ 11101000b = 01011011b
-10110011b ^ 11101001b = 01011010b
-10110011b ^ 11101010b = 01011001b
-10110011b ^ 11101011b = 01011000b
-10110011b ^ 11101100b = 01011111b
-10110011b ^ 11101101b = 01011110b
-10110011b ^ 11101110b = 01011101b
-10110011b ^ 11101111b = 01011100b
-10110011b ^ 11110000b = 01000011b
-10110011b ^ 11110001b = 01000010b
-10110011b ^ 11110010b = 01000001b
-10110011b ^ 11110011b = 01000000b
-10110011b ^ 11110100b = 01000111b
-10110011b ^ 11110101b = 01000110b
-10110011b ^ 11110110b = 01000101b
-10110011b ^ 11110111b = 01000100b
-10110011b ^ 11111000b = 01001011b
-10110011b ^ 11111001b = 01001010b
-10110011b ^ 11111010b = 01001001b
-10110011b ^ 11111011b = 01001000b
-10110011b ^ 11111100b = 01001111b
-10110011b ^ 11111101b = 01001110b
-10110011b ^ 11111110b = 01001101b
-10110011b ^ 11111111b = 01001100b
-10110011b ^ 00000000b = 10110011b
-10110011b ^ 00000001b = 10110010b
-10110011b ^ 00000010b = 10110001b
-10110011b ^ 00000011b = 10110000b
-10110011b ^ 00000100b = 10110111b
-10110011b ^ 00000101b = 10110110b
-10110011b ^ 00000110b = 10110101b
-10110011b ^ 00000111b = 10110100b
-10110011b ^ 00001000b = 10111011b
-10110011b ^ 00001001b = 10111010b
-10110011b ^ 00001010b = 10111001b
-10110011b ^ 00001011b = 10111000b
-10110011b ^ 00001100b = 10111111b
-10110011b ^ 00001101b = 10111110b
-10110011b ^ 00001110b = 10111101b
-10110011b ^ 00001111b = 10111100b
-10110011b ^ 00010000b = 10100011b
-10110011b ^ 00010001b = 10100010b
-10110011b ^ 00010010b = 10100001b
-10110011b ^ 00010011b = 10100000b
-10110011b ^ 00010100b = 10100111b
-10110011b ^ 00010101b = 10100110b
-10110011b ^ 00010110b = 10100101b
-10110011b ^ 00010111b = 10100100b
-10110011b ^ 00011000b = 10101011b
-10110011b ^ 00011001b = 10101010b
-10110011b ^ 00011010b = 10101001b
-10110011b ^ 00011011b = 10101000b
-10110011b ^ 00011100b = 10101111b
-10110011b ^ 00011101b = 10101110b
-10110011b ^ 00011110b = 10101101b
-10110011b ^ 00011111b = 10101100b
-10110011b ^ 00100000b = 10010011b
-10110011b ^ 00100001b = 10010010b
-10110011b ^ 00100010b = 10010001b
-10110011b ^ 00100011b = 10010000b
-10110011b ^ 00100100b = 10010111b
-10110011b ^ 00100101b = 10010110b
-10110011b ^ 00100110b = 10010101b
-10110011b ^ 00100111b = 10010100b
-10110011b ^ 00101000b = 10011011b
-10110011b ^ 00101001b = 10011010b
-10110011b ^ 00101010b = 10011001b
-10110011b ^ 00101011b = 10011000b
-10110011b ^ 00101100b = 10011111b
-10110011b ^ 00101101b = 10011110b
-10110011b ^ 00101110b = 10011101b
-10110011b ^ 00101111b = 10011100b
-10110011b ^ 00110000b = 10000011b
-10110011b ^ 00110001b = 10000010b
-10110011b ^ 00110010b = 10000001b
-10110011b ^ 00110011b = 10000000b
-10110011b ^ 00110100b = 10000111b
-10110011b ^ 00110101b = 10000110b
-10110011b ^ 00110110b = 10000101b
-10110011b ^ 00110111b = 10000100b
-10110011b ^ 00111000b = 10001011b
-10110011b ^ 00111001b = 10001010b
-10110011b ^ 00111010b = 10001001b
-10110011b ^ 00111011b = 10001000b
-10110011b ^ 00111100b = 10001111b
-10110011b ^ 00111101b = 10001110b
-10110011b ^ 00111110b = 10001101b
-10110011b ^ 00111111b = 10001100b
-10110011b ^ 01000000b = 11110011b
-10110011b ^ 01000001b = 11110010b
-10110011b ^ 01000010b = 11110001b
-10110011b ^ 01000011b = 11110000b
-10110011b ^ 01000100b = 11110111b
-10110011b ^ 01000101b = 11110110b
-10110011b ^ 01000110b = 11110101b
-10110011b ^ 01000111b = 11110100b
-10110011b ^ 01001000b = 11111011b
-10110011b ^ 01001001b = 11111010b
-10110011b ^ 01001010b = 11111001b
-10110011b ^ 01001011b = 11111000b
-10110011b ^ 01001100b = 11111111b
-10110011b ^ 01001101b = 11111110b
-10110011b ^ 01001110b = 11111101b
-10110011b ^ 01001111b = 11111100b
-10110011b ^ 01010000b = 11100011b
-10110011b ^ 01010001b = 11100010b
-10110011b ^ 01010010b = 11100001b
-10110011b ^ 01010011b = 11100000b
-10110011b ^ 01010100b = 11100111b
-10110011b ^ 01010101b = 11100110b
-10110011b ^ 01010110b = 11100101b
-10110011b ^ 01010111b = 11100100b
-10110011b ^ 01011000b = 11101011b
-10110011b ^ 01011001b = 11101010b
-10110011b ^ 01011010b = 11101001b
-10110011b ^ 01011011b = 11101000b
-10110011b ^ 01011100b = 11101111b
-10110011b ^ 01011101b = 11101110b
-10110011b ^ 01011110b = 11101101b
-10110011b ^ 01011111b = 11101100b
-10110011b ^ 01100000b = 11010011b
-10110011b ^ 01100001b = 11010010b
-10110011b ^ 01100010b = 11010001b
-10110011b ^ 01100011b = 11010000b
-10110011b ^ 01100100b = 11010111b
-10110011b ^ 01100101b = 11010110b
-10110011b ^ 01100110b = 11010101b
-10110011b ^ 01100111b = 11010100b
-10110011b ^ 01101000b = 11011011b
-10110011b ^ 01101001b = 11011010b
-10110011b ^ 01101010b = 11011001b
-10110011b ^ 01101011b = 11011000b
-10110011b ^ 01101100b = 11011111b
-10110011b ^ 01101101b = 11011110b
-10110011b ^ 01101110b = 11011101b
-10110011b ^ 01101111b = 11011100b
-10110011b ^ 01110000b = 11000011b
-10110011b ^ 01110001b = 11000010b
-10110011b ^ 01110010b = 11000001b
-10110011b ^ 01110011b = 11000000b
-10110011b ^ 01110100b = 11000111b
-10110011b ^ 01110101b = 11000110b
-10110011b ^ 01110110b = 11000101b
-10110011b ^ 01110111b = 11000100b
-10110011b ^ 01111000b = 11001011b
-10110011b ^ 01111001b = 11001010b
-10110011b ^ 01111010b = 11001001b
-10110011b ^ 01111011b = 11001000b
-10110011b ^ 01111100b = 11001111b
-10110011b ^ 01111101b = 11001110b
-10110011b ^ 01111110b = 11001101b
-10110100b ^ 10000000b = 00110100b
-10110100b ^ 10000001b = 00110101b
-10110100b ^ 10000010b = 00110110b
-10110100b ^ 10000011b = 00110111b
-10110100b ^ 10000100b = 00110000b
-10110100b ^ 10000101b = 00110001b
-10110100b ^ 10000110b = 00110010b
-10110100b ^ 10000111b = 00110011b
-10110100b ^ 10001000b = 00111100b
-10110100b ^ 10001001b = 00111101b
-10110100b ^ 10001010b = 00111110b
-10110100b ^ 10001011b = 00111111b
-10110100b ^ 10001100b = 00111000b
-10110100b ^ 10001101b = 00111001b
-10110100b ^ 10001110b = 00111010b
-10110100b ^ 10001111b = 00111011b
-10110100b ^ 10010000b = 00100100b
-10110100b ^ 10010001b = 00100101b
-10110100b ^ 10010010b = 00100110b
-10110100b ^ 10010011b = 00100111b
-10110100b ^ 10010100b = 00100000b
-10110100b ^ 10010101b = 00100001b
-10110100b ^ 10010110b = 00100010b
-10110100b ^ 10010111b = 00100011b
-10110100b ^ 10011000b = 00101100b
-10110100b ^ 10011001b = 00101101b
-10110100b ^ 10011010b = 00101110b
-10110100b ^ 10011011b = 00101111b
-10110100b ^ 10011100b = 00101000b
-10110100b ^ 10011101b = 00101001b
-10110100b ^ 10011110b = 00101010b
-10110100b ^ 10011111b = 00101011b
-10110100b ^ 10100000b = 00010100b
-10110100b ^ 10100001b = 00010101b
-10110100b ^ 10100010b = 00010110b
-10110100b ^ 10100011b = 00010111b
-10110100b ^ 10100100b = 00010000b
-10110100b ^ 10100101b = 00010001b
-10110100b ^ 10100110b = 00010010b
-10110100b ^ 10100111b = 00010011b
-10110100b ^ 10101000b = 00011100b
-10110100b ^ 10101001b = 00011101b
-10110100b ^ 10101010b = 00011110b
-10110100b ^ 10101011b = 00011111b
-10110100b ^ 10101100b = 00011000b
-10110100b ^ 10101101b = 00011001b
-10110100b ^ 10101110b = 00011010b
-10110100b ^ 10101111b = 00011011b
-10110100b ^ 10110000b = 00000100b
-10110100b ^ 10110001b = 00000101b
-10110100b ^ 10110010b = 00000110b
-10110100b ^ 10110011b = 00000111b
-10110100b ^ 10110100b = 00000000b
-10110100b ^ 10110101b = 00000001b
-10110100b ^ 10110110b = 00000010b
-10110100b ^ 10110111b = 00000011b
-10110100b ^ 10111000b = 00001100b
-10110100b ^ 10111001b = 00001101b
-10110100b ^ 10111010b = 00001110b
-10110100b ^ 10111011b = 00001111b
-10110100b ^ 10111100b = 00001000b
-10110100b ^ 10111101b = 00001001b
-10110100b ^ 10111110b = 00001010b
-10110100b ^ 10111111b = 00001011b
-10110100b ^ 11000000b = 01110100b
-10110100b ^ 11000001b = 01110101b
-10110100b ^ 11000010b = 01110110b
-10110100b ^ 11000011b = 01110111b
-10110100b ^ 11000100b = 01110000b
-10110100b ^ 11000101b = 01110001b
-10110100b ^ 11000110b = 01110010b
-10110100b ^ 11000111b = 01110011b
-10110100b ^ 11001000b = 01111100b
-10110100b ^ 11001001b = 01111101b
-10110100b ^ 11001010b = 01111110b
-10110100b ^ 11001011b = 01111111b
-10110100b ^ 11001100b = 01111000b
-10110100b ^ 11001101b = 01111001b
-10110100b ^ 11001110b = 01111010b
-10110100b ^ 11001111b = 01111011b
-10110100b ^ 11010000b = 01100100b
-10110100b ^ 11010001b = 01100101b
-10110100b ^ 11010010b = 01100110b
-10110100b ^ 11010011b = 01100111b
-10110100b ^ 11010100b = 01100000b
-10110100b ^ 11010101b = 01100001b
-10110100b ^ 11010110b = 01100010b
-10110100b ^ 11010111b = 01100011b
-10110100b ^ 11011000b = 01101100b
-10110100b ^ 11011001b = 01101101b
-10110100b ^ 11011010b = 01101110b
-10110100b ^ 11011011b = 01101111b
-10110100b ^ 11011100b = 01101000b
-10110100b ^ 11011101b = 01101001b
-10110100b ^ 11011110b = 01101010b
-10110100b ^ 11011111b = 01101011b
-10110100b ^ 11100000b = 01010100b
-10110100b ^ 11100001b = 01010101b
-10110100b ^ 11100010b = 01010110b
-10110100b ^ 11100011b = 01010111b
-10110100b ^ 11100100b = 01010000b
-10110100b ^ 11100101b = 01010001b
-10110100b ^ 11100110b = 01010010b
-10110100b ^ 11100111b = 01010011b
-10110100b ^ 11101000b = 01011100b
-10110100b ^ 11101001b = 01011101b
-10110100b ^ 11101010b = 01011110b
-10110100b ^ 11101011b = 01011111b
-10110100b ^ 11101100b = 01011000b
-10110100b ^ 11101101b = 01011001b
-10110100b ^ 11101110b = 01011010b
-10110100b ^ 11101111b = 01011011b
-10110100b ^ 11110000b = 01000100b
-10110100b ^ 11110001b = 01000101b
-10110100b ^ 11110010b = 01000110b
-10110100b ^ 11110011b = 01000111b
-10110100b ^ 11110100b = 01000000b
-10110100b ^ 11110101b = 01000001b
-10110100b ^ 11110110b = 01000010b
-10110100b ^ 11110111b = 01000011b
-10110100b ^ 11111000b = 01001100b
-10110100b ^ 11111001b = 01001101b
-10110100b ^ 11111010b = 01001110b
-10110100b ^ 11111011b = 01001111b
-10110100b ^ 11111100b = 01001000b
-10110100b ^ 11111101b = 01001001b
-10110100b ^ 11111110b = 01001010b
-10110100b ^ 11111111b = 01001011b
-10110100b ^ 00000000b = 10110100b
-10110100b ^ 00000001b = 10110101b
-10110100b ^ 00000010b = 10110110b
-10110100b ^ 00000011b = 10110111b
-10110100b ^ 00000100b = 10110000b
-10110100b ^ 00000101b = 10110001b
-10110100b ^ 00000110b = 10110010b
-10110100b ^ 00000111b = 10110011b
-10110100b ^ 00001000b = 10111100b
-10110100b ^ 00001001b = 10111101b
-10110100b ^ 00001010b = 10111110b
-10110100b ^ 00001011b = 10111111b
-10110100b ^ 00001100b = 10111000b
-10110100b ^ 00001101b = 10111001b
-10110100b ^ 00001110b = 10111010b
-10110100b ^ 00001111b = 10111011b
-10110100b ^ 00010000b = 10100100b
-10110100b ^ 00010001b = 10100101b
-10110100b ^ 00010010b = 10100110b
-10110100b ^ 00010011b = 10100111b
-10110100b ^ 00010100b = 10100000b
-10110100b ^ 00010101b = 10100001b
-10110100b ^ 00010110b = 10100010b
-10110100b ^ 00010111b = 10100011b
-10110100b ^ 00011000b = 10101100b
-10110100b ^ 00011001b = 10101101b
-10110100b ^ 00011010b = 10101110b
-10110100b ^ 00011011b = 10101111b
-10110100b ^ 00011100b = 10101000b
-10110100b ^ 00011101b = 10101001b
-10110100b ^ 00011110b = 10101010b
-10110100b ^ 00011111b = 10101011b
-10110100b ^ 00100000b = 10010100b
-10110100b ^ 00100001b = 10010101b
-10110100b ^ 00100010b = 10010110b
-10110100b ^ 00100011b = 10010111b
-10110100b ^ 00100100b = 10010000b
-10110100b ^ 00100101b = 10010001b
-10110100b ^ 00100110b = 10010010b
-10110100b ^ 00100111b = 10010011b
-10110100b ^ 00101000b = 10011100b
-10110100b ^ 00101001b = 10011101b
-10110100b ^ 00101010b = 10011110b
-10110100b ^ 00101011b = 10011111b
-10110100b ^ 00101100b = 10011000b
-10110100b ^ 00101101b = 10011001b
-10110100b ^ 00101110b = 10011010b
-10110100b ^ 00101111b = 10011011b
-10110100b ^ 00110000b = 10000100b
-10110100b ^ 00110001b = 10000101b
-10110100b ^ 00110010b = 10000110b
-10110100b ^ 00110011b = 10000111b
-10110100b ^ 00110100b = 10000000b
-10110100b ^ 00110101b = 10000001b
-10110100b ^ 00110110b = 10000010b
-10110100b ^ 00110111b = 10000011b
-10110100b ^ 00111000b = 10001100b
-10110100b ^ 00111001b = 10001101b
-10110100b ^ 00111010b = 10001110b
-10110100b ^ 00111011b = 10001111b
-10110100b ^ 00111100b = 10001000b
-10110100b ^ 00111101b = 10001001b
-10110100b ^ 00111110b = 10001010b
-10110100b ^ 00111111b = 10001011b
-10110100b ^ 01000000b = 11110100b
-10110100b ^ 01000001b = 11110101b
-10110100b ^ 01000010b = 11110110b
-10110100b ^ 01000011b = 11110111b
-10110100b ^ 01000100b = 11110000b
-10110100b ^ 01000101b = 11110001b
-10110100b ^ 01000110b = 11110010b
-10110100b ^ 01000111b = 11110011b
-10110100b ^ 01001000b = 11111100b
-10110100b ^ 01001001b = 11111101b
-10110100b ^ 01001010b = 11111110b
-10110100b ^ 01001011b = 11111111b
-10110100b ^ 01001100b = 11111000b
-10110100b ^ 01001101b = 11111001b
-10110100b ^ 01001110b = 11111010b
-10110100b ^ 01001111b = 11111011b
-10110100b ^ 01010000b = 11100100b
-10110100b ^ 01010001b = 11100101b
-10110100b ^ 01010010b = 11100110b
-10110100b ^ 01010011b = 11100111b
-10110100b ^ 01010100b = 11100000b
-10110100b ^ 01010101b = 11100001b
-10110100b ^ 01010110b = 11100010b
-10110100b ^ 01010111b = 11100011b
-10110100b ^ 01011000b = 11101100b
-10110100b ^ 01011001b = 11101101b
-10110100b ^ 01011010b = 11101110b
-10110100b ^ 01011011b = 11101111b
-10110100b ^ 01011100b = 11101000b
-10110100b ^ 01011101b = 11101001b
-10110100b ^ 01011110b = 11101010b
-10110100b ^ 01011111b = 11101011b
-10110100b ^ 01100000b = 11010100b
-10110100b ^ 01100001b = 11010101b
-10110100b ^ 01100010b = 11010110b
-10110100b ^ 01100011b = 11010111b
-10110100b ^ 01100100b = 11010000b
-10110100b ^ 01100101b = 11010001b
-10110100b ^ 01100110b = 11010010b
-10110100b ^ 01100111b = 11010011b
-10110100b ^ 01101000b = 11011100b
-10110100b ^ 01101001b = 11011101b
-10110100b ^ 01101010b = 11011110b
-10110100b ^ 01101011b = 11011111b
-10110100b ^ 01101100b = 11011000b
-10110100b ^ 01101101b = 11011001b
-10110100b ^ 01101110b = 11011010b
-10110100b ^ 01101111b = 11011011b
-10110100b ^ 01110000b = 11000100b
-10110100b ^ 01110001b = 11000101b
-10110100b ^ 01110010b = 11000110b
-10110100b ^ 01110011b = 11000111b
-10110100b ^ 01110100b = 11000000b
-10110100b ^ 01110101b = 11000001b
-10110100b ^ 01110110b = 11000010b
-10110100b ^ 01110111b = 11000011b
-10110100b ^ 01111000b = 11001100b
-10110100b ^ 01111001b = 11001101b
-10110100b ^ 01111010b = 11001110b
-10110100b ^ 01111011b = 11001111b
-10110100b ^ 01111100b = 11001000b
-10110100b ^ 01111101b = 11001001b
-10110100b ^ 01111110b = 11001010b
-10110101b ^ 10000000b = 00110101b
-10110101b ^ 10000001b = 00110100b
-10110101b ^ 10000010b = 00110111b
-10110101b ^ 10000011b = 00110110b
-10110101b ^ 10000100b = 00110001b
-10110101b ^ 10000101b = 00110000b
-10110101b ^ 10000110b = 00110011b
-10110101b ^ 10000111b = 00110010b
-10110101b ^ 10001000b = 00111101b
-10110101b ^ 10001001b = 00111100b
-10110101b ^ 10001010b = 00111111b
-10110101b ^ 10001011b = 00111110b
-10110101b ^ 10001100b = 00111001b
-10110101b ^ 10001101b = 00111000b
-10110101b ^ 10001110b = 00111011b
-10110101b ^ 10001111b = 00111010b
-10110101b ^ 10010000b = 00100101b
-10110101b ^ 10010001b = 00100100b
-10110101b ^ 10010010b = 00100111b
-10110101b ^ 10010011b = 00100110b
-10110101b ^ 10010100b = 00100001b
-10110101b ^ 10010101b = 00100000b
-10110101b ^ 10010110b = 00100011b
-10110101b ^ 10010111b = 00100010b
-10110101b ^ 10011000b = 00101101b
-10110101b ^ 10011001b = 00101100b
-10110101b ^ 10011010b = 00101111b
-10110101b ^ 10011011b = 00101110b
-10110101b ^ 10011100b = 00101001b
-10110101b ^ 10011101b = 00101000b
-10110101b ^ 10011110b = 00101011b
-10110101b ^ 10011111b = 00101010b
-10110101b ^ 10100000b = 00010101b
-10110101b ^ 10100001b = 00010100b
-10110101b ^ 10100010b = 00010111b
-10110101b ^ 10100011b = 00010110b
-10110101b ^ 10100100b = 00010001b
-10110101b ^ 10100101b = 00010000b
-10110101b ^ 10100110b = 00010011b
-10110101b ^ 10100111b = 00010010b
-10110101b ^ 10101000b = 00011101b
-10110101b ^ 10101001b = 00011100b
-10110101b ^ 10101010b = 00011111b
-10110101b ^ 10101011b = 00011110b
-10110101b ^ 10101100b = 00011001b
-10110101b ^ 10101101b = 00011000b
-10110101b ^ 10101110b = 00011011b
-10110101b ^ 10101111b = 00011010b
-10110101b ^ 10110000b = 00000101b
-10110101b ^ 10110001b = 00000100b
-10110101b ^ 10110010b = 00000111b
-10110101b ^ 10110011b = 00000110b
-10110101b ^ 10110100b = 00000001b
-10110101b ^ 10110101b = 00000000b
-10110101b ^ 10110110b = 00000011b
-10110101b ^ 10110111b = 00000010b
-10110101b ^ 10111000b = 00001101b
-10110101b ^ 10111001b = 00001100b
-10110101b ^ 10111010b = 00001111b
-10110101b ^ 10111011b = 00001110b
-10110101b ^ 10111100b = 00001001b
-10110101b ^ 10111101b = 00001000b
-10110101b ^ 10111110b = 00001011b
-10110101b ^ 10111111b = 00001010b
-10110101b ^ 11000000b = 01110101b
-10110101b ^ 11000001b = 01110100b
-10110101b ^ 11000010b = 01110111b
-10110101b ^ 11000011b = 01110110b
-10110101b ^ 11000100b = 01110001b
-10110101b ^ 11000101b = 01110000b
-10110101b ^ 11000110b = 01110011b
-10110101b ^ 11000111b = 01110010b
-10110101b ^ 11001000b = 01111101b
-10110101b ^ 11001001b = 01111100b
-10110101b ^ 11001010b = 01111111b
-10110101b ^ 11001011b = 01111110b
-10110101b ^ 11001100b = 01111001b
-10110101b ^ 11001101b = 01111000b
-10110101b ^ 11001110b = 01111011b
-10110101b ^ 11001111b = 01111010b
-10110101b ^ 11010000b = 01100101b
-10110101b ^ 11010001b = 01100100b
-10110101b ^ 11010010b = 01100111b
-10110101b ^ 11010011b = 01100110b
-10110101b ^ 11010100b = 01100001b
-10110101b ^ 11010101b = 01100000b
-10110101b ^ 11010110b = 01100011b
-10110101b ^ 11010111b = 01100010b
-10110101b ^ 11011000b = 01101101b
-10110101b ^ 11011001b = 01101100b
-10110101b ^ 11011010b = 01101111b
-10110101b ^ 11011011b = 01101110b
-10110101b ^ 11011100b = 01101001b
-10110101b ^ 11011101b = 01101000b
-10110101b ^ 11011110b = 01101011b
-10110101b ^ 11011111b = 01101010b
-10110101b ^ 11100000b = 01010101b
-10110101b ^ 11100001b = 01010100b
-10110101b ^ 11100010b = 01010111b
-10110101b ^ 11100011b = 01010110b
-10110101b ^ 11100100b = 01010001b
-10110101b ^ 11100101b = 01010000b
-10110101b ^ 11100110b = 01010011b
-10110101b ^ 11100111b = 01010010b
-10110101b ^ 11101000b = 01011101b
-10110101b ^ 11101001b = 01011100b
-10110101b ^ 11101010b = 01011111b
-10110101b ^ 11101011b = 01011110b
-10110101b ^ 11101100b = 01011001b
-10110101b ^ 11101101b = 01011000b
-10110101b ^ 11101110b = 01011011b
-10110101b ^ 11101111b = 01011010b
-10110101b ^ 11110000b = 01000101b
-10110101b ^ 11110001b = 01000100b
-10110101b ^ 11110010b = 01000111b
-10110101b ^ 11110011b = 01000110b
-10110101b ^ 11110100b = 01000001b
-10110101b ^ 11110101b = 01000000b
-10110101b ^ 11110110b = 01000011b
-10110101b ^ 11110111b = 01000010b
-10110101b ^ 11111000b = 01001101b
-10110101b ^ 11111001b = 01001100b
-10110101b ^ 11111010b = 01001111b
-10110101b ^ 11111011b = 01001110b
-10110101b ^ 11111100b = 01001001b
-10110101b ^ 11111101b = 01001000b
-10110101b ^ 11111110b = 01001011b
-10110101b ^ 11111111b = 01001010b
-10110101b ^ 00000000b = 10110101b
-10110101b ^ 00000001b = 10110100b
-10110101b ^ 00000010b = 10110111b
-10110101b ^ 00000011b = 10110110b
-10110101b ^ 00000100b = 10110001b
-10110101b ^ 00000101b = 10110000b
-10110101b ^ 00000110b = 10110011b
-10110101b ^ 00000111b = 10110010b
-10110101b ^ 00001000b = 10111101b
-10110101b ^ 00001001b = 10111100b
-10110101b ^ 00001010b = 10111111b
-10110101b ^ 00001011b = 10111110b
-10110101b ^ 00001100b = 10111001b
-10110101b ^ 00001101b = 10111000b
-10110101b ^ 00001110b = 10111011b
-10110101b ^ 00001111b = 10111010b
-10110101b ^ 00010000b = 10100101b
-10110101b ^ 00010001b = 10100100b
-10110101b ^ 00010010b = 10100111b
-10110101b ^ 00010011b = 10100110b
-10110101b ^ 00010100b = 10100001b
-10110101b ^ 00010101b = 10100000b
-10110101b ^ 00010110b = 10100011b
-10110101b ^ 00010111b = 10100010b
-10110101b ^ 00011000b = 10101101b
-10110101b ^ 00011001b = 10101100b
-10110101b ^ 00011010b = 10101111b
-10110101b ^ 00011011b = 10101110b
-10110101b ^ 00011100b = 10101001b
-10110101b ^ 00011101b = 10101000b
-10110101b ^ 00011110b = 10101011b
-10110101b ^ 00011111b = 10101010b
-10110101b ^ 00100000b = 10010101b
-10110101b ^ 00100001b = 10010100b
-10110101b ^ 00100010b = 10010111b
-10110101b ^ 00100011b = 10010110b
-10110101b ^ 00100100b = 10010001b
-10110101b ^ 00100101b = 10010000b
-10110101b ^ 00100110b = 10010011b
-10110101b ^ 00100111b = 10010010b
-10110101b ^ 00101000b = 10011101b
-10110101b ^ 00101001b = 10011100b
-10110101b ^ 00101010b = 10011111b
-10110101b ^ 00101011b = 10011110b
-10110101b ^ 00101100b = 10011001b
-10110101b ^ 00101101b = 10011000b
-10110101b ^ 00101110b = 10011011b
-10110101b ^ 00101111b = 10011010b
-10110101b ^ 00110000b = 10000101b
-10110101b ^ 00110001b = 10000100b
-10110101b ^ 00110010b = 10000111b
-10110101b ^ 00110011b = 10000110b
-10110101b ^ 00110100b = 10000001b
-10110101b ^ 00110101b = 10000000b
-10110101b ^ 00110110b = 10000011b
-10110101b ^ 00110111b = 10000010b
-10110101b ^ 00111000b = 10001101b
-10110101b ^ 00111001b = 10001100b
-10110101b ^ 00111010b = 10001111b
-10110101b ^ 00111011b = 10001110b
-10110101b ^ 00111100b = 10001001b
-10110101b ^ 00111101b = 10001000b
-10110101b ^ 00111110b = 10001011b
-10110101b ^ 00111111b = 10001010b
-10110101b ^ 01000000b = 11110101b
-10110101b ^ 01000001b = 11110100b
-10110101b ^ 01000010b = 11110111b
-10110101b ^ 01000011b = 11110110b
-10110101b ^ 01000100b = 11110001b
-10110101b ^ 01000101b = 11110000b
-10110101b ^ 01000110b = 11110011b
-10110101b ^ 01000111b = 11110010b
-10110101b ^ 01001000b = 11111101b
-10110101b ^ 01001001b = 11111100b
-10110101b ^ 01001010b = 11111111b
-10110101b ^ 01001011b = 11111110b
-10110101b ^ 01001100b = 11111001b
-10110101b ^ 01001101b = 11111000b
-10110101b ^ 01001110b = 11111011b
-10110101b ^ 01001111b = 11111010b
-10110101b ^ 01010000b = 11100101b
-10110101b ^ 01010001b = 11100100b
-10110101b ^ 01010010b = 11100111b
-10110101b ^ 01010011b = 11100110b
-10110101b ^ 01010100b = 11100001b
-10110101b ^ 01010101b = 11100000b
-10110101b ^ 01010110b = 11100011b
-10110101b ^ 01010111b = 11100010b
-10110101b ^ 01011000b = 11101101b
-10110101b ^ 01011001b = 11101100b
-10110101b ^ 01011010b = 11101111b
-10110101b ^ 01011011b = 11101110b
-10110101b ^ 01011100b = 11101001b
-10110101b ^ 01011101b = 11101000b
-10110101b ^ 01011110b = 11101011b
-10110101b ^ 01011111b = 11101010b
-10110101b ^ 01100000b = 11010101b
-10110101b ^ 01100001b = 11010100b
-10110101b ^ 01100010b = 11010111b
-10110101b ^ 01100011b = 11010110b
-10110101b ^ 01100100b = 11010001b
-10110101b ^ 01100101b = 11010000b
-10110101b ^ 01100110b = 11010011b
-10110101b ^ 01100111b = 11010010b
-10110101b ^ 01101000b = 11011101b
-10110101b ^ 01101001b = 11011100b
-10110101b ^ 01101010b = 11011111b
-10110101b ^ 01101011b = 11011110b
-10110101b ^ 01101100b = 11011001b
-10110101b ^ 01101101b = 11011000b
-10110101b ^ 01101110b = 11011011b
-10110101b ^ 01101111b = 11011010b
-10110101b ^ 01110000b = 11000101b
-10110101b ^ 01110001b = 11000100b
-10110101b ^ 01110010b = 11000111b
-10110101b ^ 01110011b = 11000110b
-10110101b ^ 01110100b = 11000001b
-10110101b ^ 01110101b = 11000000b
-10110101b ^ 01110110b = 11000011b
-10110101b ^ 01110111b = 11000010b
-10110101b ^ 01111000b = 11001101b
-10110101b ^ 01111001b = 11001100b
-10110101b ^ 01111010b = 11001111b
-10110101b ^ 01111011b = 11001110b
-10110101b ^ 01111100b = 11001001b
-10110101b ^ 01111101b = 11001000b
-10110101b ^ 01111110b = 11001011b
-10110110b ^ 10000000b = 00110110b
-10110110b ^ 10000001b = 00110111b
-10110110b ^ 10000010b = 00110100b
-10110110b ^ 10000011b = 00110101b
-10110110b ^ 10000100b = 00110010b
-10110110b ^ 10000101b = 00110011b
-10110110b ^ 10000110b = 00110000b
-10110110b ^ 10000111b = 00110001b
-10110110b ^ 10001000b = 00111110b
-10110110b ^ 10001001b = 00111111b
-10110110b ^ 10001010b = 00111100b
-10110110b ^ 10001011b = 00111101b
-10110110b ^ 10001100b = 00111010b
-10110110b ^ 10001101b = 00111011b
-10110110b ^ 10001110b = 00111000b
-10110110b ^ 10001111b = 00111001b
-10110110b ^ 10010000b = 00100110b
-10110110b ^ 10010001b = 00100111b
-10110110b ^ 10010010b = 00100100b
-10110110b ^ 10010011b = 00100101b
-10110110b ^ 10010100b = 00100010b
-10110110b ^ 10010101b = 00100011b
-10110110b ^ 10010110b = 00100000b
-10110110b ^ 10010111b = 00100001b
-10110110b ^ 10011000b = 00101110b
-10110110b ^ 10011001b = 00101111b
-10110110b ^ 10011010b = 00101100b
-10110110b ^ 10011011b = 00101101b
-10110110b ^ 10011100b = 00101010b
-10110110b ^ 10011101b = 00101011b
-10110110b ^ 10011110b = 00101000b
-10110110b ^ 10011111b = 00101001b
-10110110b ^ 10100000b = 00010110b
-10110110b ^ 10100001b = 00010111b
-10110110b ^ 10100010b = 00010100b
-10110110b ^ 10100011b = 00010101b
-10110110b ^ 10100100b = 00010010b
-10110110b ^ 10100101b = 00010011b
-10110110b ^ 10100110b = 00010000b
-10110110b ^ 10100111b = 00010001b
-10110110b ^ 10101000b = 00011110b
-10110110b ^ 10101001b = 00011111b
-10110110b ^ 10101010b = 00011100b
-10110110b ^ 10101011b = 00011101b
-10110110b ^ 10101100b = 00011010b
-10110110b ^ 10101101b = 00011011b
-10110110b ^ 10101110b = 00011000b
-10110110b ^ 10101111b = 00011001b
-10110110b ^ 10110000b = 00000110b
-10110110b ^ 10110001b = 00000111b
-10110110b ^ 10110010b = 00000100b
-10110110b ^ 10110011b = 00000101b
-10110110b ^ 10110100b = 00000010b
-10110110b ^ 10110101b = 00000011b
-10110110b ^ 10110110b = 00000000b
-10110110b ^ 10110111b = 00000001b
-10110110b ^ 10111000b = 00001110b
-10110110b ^ 10111001b = 00001111b
-10110110b ^ 10111010b = 00001100b
-10110110b ^ 10111011b = 00001101b
-10110110b ^ 10111100b = 00001010b
-10110110b ^ 10111101b = 00001011b
-10110110b ^ 10111110b = 00001000b
-10110110b ^ 10111111b = 00001001b
-10110110b ^ 11000000b = 01110110b
-10110110b ^ 11000001b = 01110111b
-10110110b ^ 11000010b = 01110100b
-10110110b ^ 11000011b = 01110101b
-10110110b ^ 11000100b = 01110010b
-10110110b ^ 11000101b = 01110011b
-10110110b ^ 11000110b = 01110000b
-10110110b ^ 11000111b = 01110001b
-10110110b ^ 11001000b = 01111110b
-10110110b ^ 11001001b = 01111111b
-10110110b ^ 11001010b = 01111100b
-10110110b ^ 11001011b = 01111101b
-10110110b ^ 11001100b = 01111010b
-10110110b ^ 11001101b = 01111011b
-10110110b ^ 11001110b = 01111000b
-10110110b ^ 11001111b = 01111001b
-10110110b ^ 11010000b = 01100110b
-10110110b ^ 11010001b = 01100111b
-10110110b ^ 11010010b = 01100100b
-10110110b ^ 11010011b = 01100101b
-10110110b ^ 11010100b = 01100010b
-10110110b ^ 11010101b = 01100011b
-10110110b ^ 11010110b = 01100000b
-10110110b ^ 11010111b = 01100001b
-10110110b ^ 11011000b = 01101110b
-10110110b ^ 11011001b = 01101111b
-10110110b ^ 11011010b = 01101100b
-10110110b ^ 11011011b = 01101101b
-10110110b ^ 11011100b = 01101010b
-10110110b ^ 11011101b = 01101011b
-10110110b ^ 11011110b = 01101000b
-10110110b ^ 11011111b = 01101001b
-10110110b ^ 11100000b = 01010110b
-10110110b ^ 11100001b = 01010111b
-10110110b ^ 11100010b = 01010100b
-10110110b ^ 11100011b = 01010101b
-10110110b ^ 11100100b = 01010010b
-10110110b ^ 11100101b = 01010011b
-10110110b ^ 11100110b = 01010000b
-10110110b ^ 11100111b = 01010001b
-10110110b ^ 11101000b = 01011110b
-10110110b ^ 11101001b = 01011111b
-10110110b ^ 11101010b = 01011100b
-10110110b ^ 11101011b = 01011101b
-10110110b ^ 11101100b = 01011010b
-10110110b ^ 11101101b = 01011011b
-10110110b ^ 11101110b = 01011000b
-10110110b ^ 11101111b = 01011001b
-10110110b ^ 11110000b = 01000110b
-10110110b ^ 11110001b = 01000111b
-10110110b ^ 11110010b = 01000100b
-10110110b ^ 11110011b = 01000101b
-10110110b ^ 11110100b = 01000010b
-10110110b ^ 11110101b = 01000011b
-10110110b ^ 11110110b = 01000000b
-10110110b ^ 11110111b = 01000001b
-10110110b ^ 11111000b = 01001110b
-10110110b ^ 11111001b = 01001111b
-10110110b ^ 11111010b = 01001100b
-10110110b ^ 11111011b = 01001101b
-10110110b ^ 11111100b = 01001010b
-10110110b ^ 11111101b = 01001011b
-10110110b ^ 11111110b = 01001000b
-10110110b ^ 11111111b = 01001001b
-10110110b ^ 00000000b = 10110110b
-10110110b ^ 00000001b = 10110111b
-10110110b ^ 00000010b = 10110100b
-10110110b ^ 00000011b = 10110101b
-10110110b ^ 00000100b = 10110010b
-10110110b ^ 00000101b = 10110011b
-10110110b ^ 00000110b = 10110000b
-10110110b ^ 00000111b = 10110001b
-10110110b ^ 00001000b = 10111110b
-10110110b ^ 00001001b = 10111111b
-10110110b ^ 00001010b = 10111100b
-10110110b ^ 00001011b = 10111101b
-10110110b ^ 00001100b = 10111010b
-10110110b ^ 00001101b = 10111011b
-10110110b ^ 00001110b = 10111000b
-10110110b ^ 00001111b = 10111001b
-10110110b ^ 00010000b = 10100110b
-10110110b ^ 00010001b = 10100111b
-10110110b ^ 00010010b = 10100100b
-10110110b ^ 00010011b = 10100101b
-10110110b ^ 00010100b = 10100010b
-10110110b ^ 00010101b = 10100011b
-10110110b ^ 00010110b = 10100000b
-10110110b ^ 00010111b = 10100001b
-10110110b ^ 00011000b = 10101110b
-10110110b ^ 00011001b = 10101111b
-10110110b ^ 00011010b = 10101100b
-10110110b ^ 00011011b = 10101101b
-10110110b ^ 00011100b = 10101010b
-10110110b ^ 00011101b = 10101011b
-10110110b ^ 00011110b = 10101000b
-10110110b ^ 00011111b = 10101001b
-10110110b ^ 00100000b = 10010110b
-10110110b ^ 00100001b = 10010111b
-10110110b ^ 00100010b = 10010100b
-10110110b ^ 00100011b = 10010101b
-10110110b ^ 00100100b = 10010010b
-10110110b ^ 00100101b = 10010011b
-10110110b ^ 00100110b = 10010000b
-10110110b ^ 00100111b = 10010001b
-10110110b ^ 00101000b = 10011110b
-10110110b ^ 00101001b = 10011111b
-10110110b ^ 00101010b = 10011100b
-10110110b ^ 00101011b = 10011101b
-10110110b ^ 00101100b = 10011010b
-10110110b ^ 00101101b = 10011011b
-10110110b ^ 00101110b = 10011000b
-10110110b ^ 00101111b = 10011001b
-10110110b ^ 00110000b = 10000110b
-10110110b ^ 00110001b = 10000111b
-10110110b ^ 00110010b = 10000100b
-10110110b ^ 00110011b = 10000101b
-10110110b ^ 00110100b = 10000010b
-10110110b ^ 00110101b = 10000011b
-10110110b ^ 00110110b = 10000000b
-10110110b ^ 00110111b = 10000001b
-10110110b ^ 00111000b = 10001110b
-10110110b ^ 00111001b = 10001111b
-10110110b ^ 00111010b = 10001100b
-10110110b ^ 00111011b = 10001101b
-10110110b ^ 00111100b = 10001010b
-10110110b ^ 00111101b = 10001011b
-10110110b ^ 00111110b = 10001000b
-10110110b ^ 00111111b = 10001001b
-10110110b ^ 01000000b = 11110110b
-10110110b ^ 01000001b = 11110111b
-10110110b ^ 01000010b = 11110100b
-10110110b ^ 01000011b = 11110101b
-10110110b ^ 01000100b = 11110010b
-10110110b ^ 01000101b = 11110011b
-10110110b ^ 01000110b = 11110000b
-10110110b ^ 01000111b = 11110001b
-10110110b ^ 01001000b = 11111110b
-10110110b ^ 01001001b = 11111111b
-10110110b ^ 01001010b = 11111100b
-10110110b ^ 01001011b = 11111101b
-10110110b ^ 01001100b = 11111010b
-10110110b ^ 01001101b = 11111011b
-10110110b ^ 01001110b = 11111000b
-10110110b ^ 01001111b = 11111001b
-10110110b ^ 01010000b = 11100110b
-10110110b ^ 01010001b = 11100111b
-10110110b ^ 01010010b = 11100100b
-10110110b ^ 01010011b = 11100101b
-10110110b ^ 01010100b = 11100010b
-10110110b ^ 01010101b = 11100011b
-10110110b ^ 01010110b = 11100000b
-10110110b ^ 01010111b = 11100001b
-10110110b ^ 01011000b = 11101110b
-10110110b ^ 01011001b = 11101111b
-10110110b ^ 01011010b = 11101100b
-10110110b ^ 01011011b = 11101101b
-10110110b ^ 01011100b = 11101010b
-10110110b ^ 01011101b = 11101011b
-10110110b ^ 01011110b = 11101000b
-10110110b ^ 01011111b = 11101001b
-10110110b ^ 01100000b = 11010110b
-10110110b ^ 01100001b = 11010111b
-10110110b ^ 01100010b = 11010100b
-10110110b ^ 01100011b = 11010101b
-10110110b ^ 01100100b = 11010010b
-10110110b ^ 01100101b = 11010011b
-10110110b ^ 01100110b = 11010000b
-10110110b ^ 01100111b = 11010001b
-10110110b ^ 01101000b = 11011110b
-10110110b ^ 01101001b = 11011111b
-10110110b ^ 01101010b = 11011100b
-10110110b ^ 01101011b = 11011101b
-10110110b ^ 01101100b = 11011010b
-10110110b ^ 01101101b = 11011011b
-10110110b ^ 01101110b = 11011000b
-10110110b ^ 01101111b = 11011001b
-10110110b ^ 01110000b = 11000110b
-10110110b ^ 01110001b = 11000111b
-10110110b ^ 01110010b = 11000100b
-10110110b ^ 01110011b = 11000101b
-10110110b ^ 01110100b = 11000010b
-10110110b ^ 01110101b = 11000011b
-10110110b ^ 01110110b = 11000000b
-10110110b ^ 01110111b = 11000001b
-10110110b ^ 01111000b = 11001110b
-10110110b ^ 01111001b = 11001111b
-10110110b ^ 01111010b = 11001100b
-10110110b ^ 01111011b = 11001101b
-10110110b ^ 01111100b = 11001010b
-10110110b ^ 01111101b = 11001011b
-10110110b ^ 01111110b = 11001000b
-10110111b ^ 10000000b = 00110111b
-10110111b ^ 10000001b = 00110110b
-10110111b ^ 10000010b = 00110101b
-10110111b ^ 10000011b = 00110100b
-10110111b ^ 10000100b = 00110011b
-10110111b ^ 10000101b = 00110010b
-10110111b ^ 10000110b = 00110001b
-10110111b ^ 10000111b = 00110000b
-10110111b ^ 10001000b = 00111111b
-10110111b ^ 10001001b = 00111110b
-10110111b ^ 10001010b = 00111101b
-10110111b ^ 10001011b = 00111100b
-10110111b ^ 10001100b = 00111011b
-10110111b ^ 10001101b = 00111010b
-10110111b ^ 10001110b = 00111001b
-10110111b ^ 10001111b = 00111000b
-10110111b ^ 10010000b = 00100111b
-10110111b ^ 10010001b = 00100110b
-10110111b ^ 10010010b = 00100101b
-10110111b ^ 10010011b = 00100100b
-10110111b ^ 10010100b = 00100011b
-10110111b ^ 10010101b = 00100010b
-10110111b ^ 10010110b = 00100001b
-10110111b ^ 10010111b = 00100000b
-10110111b ^ 10011000b = 00101111b
-10110111b ^ 10011001b = 00101110b
-10110111b ^ 10011010b = 00101101b
-10110111b ^ 10011011b = 00101100b
-10110111b ^ 10011100b = 00101011b
-10110111b ^ 10011101b = 00101010b
-10110111b ^ 10011110b = 00101001b
-10110111b ^ 10011111b = 00101000b
-10110111b ^ 10100000b = 00010111b
-10110111b ^ 10100001b = 00010110b
-10110111b ^ 10100010b = 00010101b
-10110111b ^ 10100011b = 00010100b
-10110111b ^ 10100100b = 00010011b
-10110111b ^ 10100101b = 00010010b
-10110111b ^ 10100110b = 00010001b
-10110111b ^ 10100111b = 00010000b
-10110111b ^ 10101000b = 00011111b
-10110111b ^ 10101001b = 00011110b
-10110111b ^ 10101010b = 00011101b
-10110111b ^ 10101011b = 00011100b
-10110111b ^ 10101100b = 00011011b
-10110111b ^ 10101101b = 00011010b
-10110111b ^ 10101110b = 00011001b
-10110111b ^ 10101111b = 00011000b
-10110111b ^ 10110000b = 00000111b
-10110111b ^ 10110001b = 00000110b
-10110111b ^ 10110010b = 00000101b
-10110111b ^ 10110011b = 00000100b
-10110111b ^ 10110100b = 00000011b
-10110111b ^ 10110101b = 00000010b
-10110111b ^ 10110110b = 00000001b
-10110111b ^ 10110111b = 00000000b
-10110111b ^ 10111000b = 00001111b
-10110111b ^ 10111001b = 00001110b
-10110111b ^ 10111010b = 00001101b
-10110111b ^ 10111011b = 00001100b
-10110111b ^ 10111100b = 00001011b
-10110111b ^ 10111101b = 00001010b
-10110111b ^ 10111110b = 00001001b
-10110111b ^ 10111111b = 00001000b
-10110111b ^ 11000000b = 01110111b
-10110111b ^ 11000001b = 01110110b
-10110111b ^ 11000010b = 01110101b
-10110111b ^ 11000011b = 01110100b
-10110111b ^ 11000100b = 01110011b
-10110111b ^ 11000101b = 01110010b
-10110111b ^ 11000110b = 01110001b
-10110111b ^ 11000111b = 01110000b
-10110111b ^ 11001000b = 01111111b
-10110111b ^ 11001001b = 01111110b
-10110111b ^ 11001010b = 01111101b
-10110111b ^ 11001011b = 01111100b
-10110111b ^ 11001100b = 01111011b
-10110111b ^ 11001101b = 01111010b
-10110111b ^ 11001110b = 01111001b
-10110111b ^ 11001111b = 01111000b
-10110111b ^ 11010000b = 01100111b
-10110111b ^ 11010001b = 01100110b
-10110111b ^ 11010010b = 01100101b
-10110111b ^ 11010011b = 01100100b
-10110111b ^ 11010100b = 01100011b
-10110111b ^ 11010101b = 01100010b
-10110111b ^ 11010110b = 01100001b
-10110111b ^ 11010111b = 01100000b
-10110111b ^ 11011000b = 01101111b
-10110111b ^ 11011001b = 01101110b
-10110111b ^ 11011010b = 01101101b
-10110111b ^ 11011011b = 01101100b
-10110111b ^ 11011100b = 01101011b
-10110111b ^ 11011101b = 01101010b
-10110111b ^ 11011110b = 01101001b
-10110111b ^ 11011111b = 01101000b
-10110111b ^ 11100000b = 01010111b
-10110111b ^ 11100001b = 01010110b
-10110111b ^ 11100010b = 01010101b
-10110111b ^ 11100011b = 01010100b
-10110111b ^ 11100100b = 01010011b
-10110111b ^ 11100101b = 01010010b
-10110111b ^ 11100110b = 01010001b
-10110111b ^ 11100111b = 01010000b
-10110111b ^ 11101000b = 01011111b
-10110111b ^ 11101001b = 01011110b
-10110111b ^ 11101010b = 01011101b
-10110111b ^ 11101011b = 01011100b
-10110111b ^ 11101100b = 01011011b
-10110111b ^ 11101101b = 01011010b
-10110111b ^ 11101110b = 01011001b
-10110111b ^ 11101111b = 01011000b
-10110111b ^ 11110000b = 01000111b
-10110111b ^ 11110001b = 01000110b
-10110111b ^ 11110010b = 01000101b
-10110111b ^ 11110011b = 01000100b
-10110111b ^ 11110100b = 01000011b
-10110111b ^ 11110101b = 01000010b
-10110111b ^ 11110110b = 01000001b
-10110111b ^ 11110111b = 01000000b
-10110111b ^ 11111000b = 01001111b
-10110111b ^ 11111001b = 01001110b
-10110111b ^ 11111010b = 01001101b
-10110111b ^ 11111011b = 01001100b
-10110111b ^ 11111100b = 01001011b
-10110111b ^ 11111101b = 01001010b
-10110111b ^ 11111110b = 01001001b
-10110111b ^ 11111111b = 01001000b
-10110111b ^ 00000000b = 10110111b
-10110111b ^ 00000001b = 10110110b
-10110111b ^ 00000010b = 10110101b
-10110111b ^ 00000011b = 10110100b
-10110111b ^ 00000100b = 10110011b
-10110111b ^ 00000101b = 10110010b
-10110111b ^ 00000110b = 10110001b
-10110111b ^ 00000111b = 10110000b
-10110111b ^ 00001000b = 10111111b
-10110111b ^ 00001001b = 10111110b
-10110111b ^ 00001010b = 10111101b
-10110111b ^ 00001011b = 10111100b
-10110111b ^ 00001100b = 10111011b
-10110111b ^ 00001101b = 10111010b
-10110111b ^ 00001110b = 10111001b
-10110111b ^ 00001111b = 10111000b
-10110111b ^ 00010000b = 10100111b
-10110111b ^ 00010001b = 10100110b
-10110111b ^ 00010010b = 10100101b
-10110111b ^ 00010011b = 10100100b
-10110111b ^ 00010100b = 10100011b
-10110111b ^ 00010101b = 10100010b
-10110111b ^ 00010110b = 10100001b
-10110111b ^ 00010111b = 10100000b
-10110111b ^ 00011000b = 10101111b
-10110111b ^ 00011001b = 10101110b
-10110111b ^ 00011010b = 10101101b
-10110111b ^ 00011011b = 10101100b
-10110111b ^ 00011100b = 10101011b
-10110111b ^ 00011101b = 10101010b
-10110111b ^ 00011110b = 10101001b
-10110111b ^ 00011111b = 10101000b
-10110111b ^ 00100000b = 10010111b
-10110111b ^ 00100001b = 10010110b
-10110111b ^ 00100010b = 10010101b
-10110111b ^ 00100011b = 10010100b
-10110111b ^ 00100100b = 10010011b
-10110111b ^ 00100101b = 10010010b
-10110111b ^ 00100110b = 10010001b
-10110111b ^ 00100111b = 10010000b
-10110111b ^ 00101000b = 10011111b
-10110111b ^ 00101001b = 10011110b
-10110111b ^ 00101010b = 10011101b
-10110111b ^ 00101011b = 10011100b
-10110111b ^ 00101100b = 10011011b
-10110111b ^ 00101101b = 10011010b
-10110111b ^ 00101110b = 10011001b
-10110111b ^ 00101111b = 10011000b
-10110111b ^ 00110000b = 10000111b
-10110111b ^ 00110001b = 10000110b
-10110111b ^ 00110010b = 10000101b
-10110111b ^ 00110011b = 10000100b
-10110111b ^ 00110100b = 10000011b
-10110111b ^ 00110101b = 10000010b
-10110111b ^ 00110110b = 10000001b
-10110111b ^ 00110111b = 10000000b
-10110111b ^ 00111000b = 10001111b
-10110111b ^ 00111001b = 10001110b
-10110111b ^ 00111010b = 10001101b
-10110111b ^ 00111011b = 10001100b
-10110111b ^ 00111100b = 10001011b
-10110111b ^ 00111101b = 10001010b
-10110111b ^ 00111110b = 10001001b
-10110111b ^ 00111111b = 10001000b
-10110111b ^ 01000000b = 11110111b
-10110111b ^ 01000001b = 11110110b
-10110111b ^ 01000010b = 11110101b
-10110111b ^ 01000011b = 11110100b
-10110111b ^ 01000100b = 11110011b
-10110111b ^ 01000101b = 11110010b
-10110111b ^ 01000110b = 11110001b
-10110111b ^ 01000111b = 11110000b
-10110111b ^ 01001000b = 11111111b
-10110111b ^ 01001001b = 11111110b
-10110111b ^ 01001010b = 11111101b
-10110111b ^ 01001011b = 11111100b
-10110111b ^ 01001100b = 11111011b
-10110111b ^ 01001101b = 11111010b
-10110111b ^ 01001110b = 11111001b
-10110111b ^ 01001111b = 11111000b
-10110111b ^ 01010000b = 11100111b
-10110111b ^ 01010001b = 11100110b
-10110111b ^ 01010010b = 11100101b
-10110111b ^ 01010011b = 11100100b
-10110111b ^ 01010100b = 11100011b
-10110111b ^ 01010101b = 11100010b
-10110111b ^ 01010110b = 11100001b
-10110111b ^ 01010111b = 11100000b
-10110111b ^ 01011000b = 11101111b
-10110111b ^ 01011001b = 11101110b
-10110111b ^ 01011010b = 11101101b
-10110111b ^ 01011011b = 11101100b
-10110111b ^ 01011100b = 11101011b
-10110111b ^ 01011101b = 11101010b
-10110111b ^ 01011110b = 11101001b
-10110111b ^ 01011111b = 11101000b
-10110111b ^ 01100000b = 11010111b
-10110111b ^ 01100001b = 11010110b
-10110111b ^ 01100010b = 11010101b
-10110111b ^ 01100011b = 11010100b
-10110111b ^ 01100100b = 11010011b
-10110111b ^ 01100101b = 11010010b
-10110111b ^ 01100110b = 11010001b
-10110111b ^ 01100111b = 11010000b
-10110111b ^ 01101000b = 11011111b
-10110111b ^ 01101001b = 11011110b
-10110111b ^ 01101010b = 11011101b
-10110111b ^ 01101011b = 11011100b
-10110111b ^ 01101100b = 11011011b
-10110111b ^ 01101101b = 11011010b
-10110111b ^ 01101110b = 11011001b
-10110111b ^ 01101111b = 11011000b
-10110111b ^ 01110000b = 11000111b
-10110111b ^ 01110001b = 11000110b
-10110111b ^ 01110010b = 11000101b
-10110111b ^ 01110011b = 11000100b
-10110111b ^ 01110100b = 11000011b
-10110111b ^ 01110101b = 11000010b
-10110111b ^ 01110110b = 11000001b
-10110111b ^ 01110111b = 11000000b
-10110111b ^ 01111000b = 11001111b
-10110111b ^ 01111001b = 11001110b
-10110111b ^ 01111010b = 11001101b
-10110111b ^ 01111011b = 11001100b
-10110111b ^ 01111100b = 11001011b
-10110111b ^ 01111101b = 11001010b
-10110111b ^ 01111110b = 11001001b
-10111000b ^ 10000000b = 00111000b
-10111000b ^ 10000001b = 00111001b
-10111000b ^ 10000010b = 00111010b
-10111000b ^ 10000011b = 00111011b
-10111000b ^ 10000100b = 00111100b
-10111000b ^ 10000101b = 00111101b
-10111000b ^ 10000110b = 00111110b
-10111000b ^ 10000111b = 00111111b
-10111000b ^ 10001000b = 00110000b
-10111000b ^ 10001001b = 00110001b
-10111000b ^ 10001010b = 00110010b
-10111000b ^ 10001011b = 00110011b
-10111000b ^ 10001100b = 00110100b
-10111000b ^ 10001101b = 00110101b
-10111000b ^ 10001110b = 00110110b
-10111000b ^ 10001111b = 00110111b
-10111000b ^ 10010000b = 00101000b
-10111000b ^ 10010001b = 00101001b
-10111000b ^ 10010010b = 00101010b
-10111000b ^ 10010011b = 00101011b
-10111000b ^ 10010100b = 00101100b
-10111000b ^ 10010101b = 00101101b
-10111000b ^ 10010110b = 00101110b
-10111000b ^ 10010111b = 00101111b
-10111000b ^ 10011000b = 00100000b
-10111000b ^ 10011001b = 00100001b
-10111000b ^ 10011010b = 00100010b
-10111000b ^ 10011011b = 00100011b
-10111000b ^ 10011100b = 00100100b
-10111000b ^ 10011101b = 00100101b
-10111000b ^ 10011110b = 00100110b
-10111000b ^ 10011111b = 00100111b
-10111000b ^ 10100000b = 00011000b
-10111000b ^ 10100001b = 00011001b
-10111000b ^ 10100010b = 00011010b
-10111000b ^ 10100011b = 00011011b
-10111000b ^ 10100100b = 00011100b
-10111000b ^ 10100101b = 00011101b
-10111000b ^ 10100110b = 00011110b
-10111000b ^ 10100111b = 00011111b
-10111000b ^ 10101000b = 00010000b
-10111000b ^ 10101001b = 00010001b
-10111000b ^ 10101010b = 00010010b
-10111000b ^ 10101011b = 00010011b
-10111000b ^ 10101100b = 00010100b
-10111000b ^ 10101101b = 00010101b
-10111000b ^ 10101110b = 00010110b
-10111000b ^ 10101111b = 00010111b
-10111000b ^ 10110000b = 00001000b
-10111000b ^ 10110001b = 00001001b
-10111000b ^ 10110010b = 00001010b
-10111000b ^ 10110011b = 00001011b
-10111000b ^ 10110100b = 00001100b
-10111000b ^ 10110101b = 00001101b
-10111000b ^ 10110110b = 00001110b
-10111000b ^ 10110111b = 00001111b
-10111000b ^ 10111000b = 00000000b
-10111000b ^ 10111001b = 00000001b
-10111000b ^ 10111010b = 00000010b
-10111000b ^ 10111011b = 00000011b
-10111000b ^ 10111100b = 00000100b
-10111000b ^ 10111101b = 00000101b
-10111000b ^ 10111110b = 00000110b
-10111000b ^ 10111111b = 00000111b
-10111000b ^ 11000000b = 01111000b
-10111000b ^ 11000001b = 01111001b
-10111000b ^ 11000010b = 01111010b
-10111000b ^ 11000011b = 01111011b
-10111000b ^ 11000100b = 01111100b
-10111000b ^ 11000101b = 01111101b
-10111000b ^ 11000110b = 01111110b
-10111000b ^ 11000111b = 01111111b
-10111000b ^ 11001000b = 01110000b
-10111000b ^ 11001001b = 01110001b
-10111000b ^ 11001010b = 01110010b
-10111000b ^ 11001011b = 01110011b
-10111000b ^ 11001100b = 01110100b
-10111000b ^ 11001101b = 01110101b
-10111000b ^ 11001110b = 01110110b
-10111000b ^ 11001111b = 01110111b
-10111000b ^ 11010000b = 01101000b
-10111000b ^ 11010001b = 01101001b
-10111000b ^ 11010010b = 01101010b
-10111000b ^ 11010011b = 01101011b
-10111000b ^ 11010100b = 01101100b
-10111000b ^ 11010101b = 01101101b
-10111000b ^ 11010110b = 01101110b
-10111000b ^ 11010111b = 01101111b
-10111000b ^ 11011000b = 01100000b
-10111000b ^ 11011001b = 01100001b
-10111000b ^ 11011010b = 01100010b
-10111000b ^ 11011011b = 01100011b
-10111000b ^ 11011100b = 01100100b
-10111000b ^ 11011101b = 01100101b
-10111000b ^ 11011110b = 01100110b
-10111000b ^ 11011111b = 01100111b
-10111000b ^ 11100000b = 01011000b
-10111000b ^ 11100001b = 01011001b
-10111000b ^ 11100010b = 01011010b
-10111000b ^ 11100011b = 01011011b
-10111000b ^ 11100100b = 01011100b
-10111000b ^ 11100101b = 01011101b
-10111000b ^ 11100110b = 01011110b
-10111000b ^ 11100111b = 01011111b
-10111000b ^ 11101000b = 01010000b
-10111000b ^ 11101001b = 01010001b
-10111000b ^ 11101010b = 01010010b
-10111000b ^ 11101011b = 01010011b
-10111000b ^ 11101100b = 01010100b
-10111000b ^ 11101101b = 01010101b
-10111000b ^ 11101110b = 01010110b
-10111000b ^ 11101111b = 01010111b
-10111000b ^ 11110000b = 01001000b
-10111000b ^ 11110001b = 01001001b
-10111000b ^ 11110010b = 01001010b
-10111000b ^ 11110011b = 01001011b
-10111000b ^ 11110100b = 01001100b
-10111000b ^ 11110101b = 01001101b
-10111000b ^ 11110110b = 01001110b
-10111000b ^ 11110111b = 01001111b
-10111000b ^ 11111000b = 01000000b
-10111000b ^ 11111001b = 01000001b
-10111000b ^ 11111010b = 01000010b
-10111000b ^ 11111011b = 01000011b
-10111000b ^ 11111100b = 01000100b
-10111000b ^ 11111101b = 01000101b
-10111000b ^ 11111110b = 01000110b
-10111000b ^ 11111111b = 01000111b
-10111000b ^ 00000000b = 10111000b
-10111000b ^ 00000001b = 10111001b
-10111000b ^ 00000010b = 10111010b
-10111000b ^ 00000011b = 10111011b
-10111000b ^ 00000100b = 10111100b
-10111000b ^ 00000101b = 10111101b
-10111000b ^ 00000110b = 10111110b
-10111000b ^ 00000111b = 10111111b
-10111000b ^ 00001000b = 10110000b
-10111000b ^ 00001001b = 10110001b
-10111000b ^ 00001010b = 10110010b
-10111000b ^ 00001011b = 10110011b
-10111000b ^ 00001100b = 10110100b
-10111000b ^ 00001101b = 10110101b
-10111000b ^ 00001110b = 10110110b
-10111000b ^ 00001111b = 10110111b
-10111000b ^ 00010000b = 10101000b
-10111000b ^ 00010001b = 10101001b
-10111000b ^ 00010010b = 10101010b
-10111000b ^ 00010011b = 10101011b
-10111000b ^ 00010100b = 10101100b
-10111000b ^ 00010101b = 10101101b
-10111000b ^ 00010110b = 10101110b
-10111000b ^ 00010111b = 10101111b
-10111000b ^ 00011000b = 10100000b
-10111000b ^ 00011001b = 10100001b
-10111000b ^ 00011010b = 10100010b
-10111000b ^ 00011011b = 10100011b
-10111000b ^ 00011100b = 10100100b
-10111000b ^ 00011101b = 10100101b
-10111000b ^ 00011110b = 10100110b
-10111000b ^ 00011111b = 10100111b
-10111000b ^ 00100000b = 10011000b
-10111000b ^ 00100001b = 10011001b
-10111000b ^ 00100010b = 10011010b
-10111000b ^ 00100011b = 10011011b
-10111000b ^ 00100100b = 10011100b
-10111000b ^ 00100101b = 10011101b
-10111000b ^ 00100110b = 10011110b
-10111000b ^ 00100111b = 10011111b
-10111000b ^ 00101000b = 10010000b
-10111000b ^ 00101001b = 10010001b
-10111000b ^ 00101010b = 10010010b
-10111000b ^ 00101011b = 10010011b
-10111000b ^ 00101100b = 10010100b
-10111000b ^ 00101101b = 10010101b
-10111000b ^ 00101110b = 10010110b
-10111000b ^ 00101111b = 10010111b
-10111000b ^ 00110000b = 10001000b
-10111000b ^ 00110001b = 10001001b
-10111000b ^ 00110010b = 10001010b
-10111000b ^ 00110011b = 10001011b
-10111000b ^ 00110100b = 10001100b
-10111000b ^ 00110101b = 10001101b
-10111000b ^ 00110110b = 10001110b
-10111000b ^ 00110111b = 10001111b
-10111000b ^ 00111000b = 10000000b
-10111000b ^ 00111001b = 10000001b
-10111000b ^ 00111010b = 10000010b
-10111000b ^ 00111011b = 10000011b
-10111000b ^ 00111100b = 10000100b
-10111000b ^ 00111101b = 10000101b
-10111000b ^ 00111110b = 10000110b
-10111000b ^ 00111111b = 10000111b
-10111000b ^ 01000000b = 11111000b
-10111000b ^ 01000001b = 11111001b
-10111000b ^ 01000010b = 11111010b
-10111000b ^ 01000011b = 11111011b
-10111000b ^ 01000100b = 11111100b
-10111000b ^ 01000101b = 11111101b
-10111000b ^ 01000110b = 11111110b
-10111000b ^ 01000111b = 11111111b
-10111000b ^ 01001000b = 11110000b
-10111000b ^ 01001001b = 11110001b
-10111000b ^ 01001010b = 11110010b
-10111000b ^ 01001011b = 11110011b
-10111000b ^ 01001100b = 11110100b
-10111000b ^ 01001101b = 11110101b
-10111000b ^ 01001110b = 11110110b
-10111000b ^ 01001111b = 11110111b
-10111000b ^ 01010000b = 11101000b
-10111000b ^ 01010001b = 11101001b
-10111000b ^ 01010010b = 11101010b
-10111000b ^ 01010011b = 11101011b
-10111000b ^ 01010100b = 11101100b
-10111000b ^ 01010101b = 11101101b
-10111000b ^ 01010110b = 11101110b
-10111000b ^ 01010111b = 11101111b
-10111000b ^ 01011000b = 11100000b
-10111000b ^ 01011001b = 11100001b
-10111000b ^ 01011010b = 11100010b
-10111000b ^ 01011011b = 11100011b
-10111000b ^ 01011100b = 11100100b
-10111000b ^ 01011101b = 11100101b
-10111000b ^ 01011110b = 11100110b
-10111000b ^ 01011111b = 11100111b
-10111000b ^ 01100000b = 11011000b
-10111000b ^ 01100001b = 11011001b
-10111000b ^ 01100010b = 11011010b
-10111000b ^ 01100011b = 11011011b
-10111000b ^ 01100100b = 11011100b
-10111000b ^ 01100101b = 11011101b
-10111000b ^ 01100110b = 11011110b
-10111000b ^ 01100111b = 11011111b
-10111000b ^ 01101000b = 11010000b
-10111000b ^ 01101001b = 11010001b
-10111000b ^ 01101010b = 11010010b
-10111000b ^ 01101011b = 11010011b
-10111000b ^ 01101100b = 11010100b
-10111000b ^ 01101101b = 11010101b
-10111000b ^ 01101110b = 11010110b
-10111000b ^ 01101111b = 11010111b
-10111000b ^ 01110000b = 11001000b
-10111000b ^ 01110001b = 11001001b
-10111000b ^ 01110010b = 11001010b
-10111000b ^ 01110011b = 11001011b
-10111000b ^ 01110100b = 11001100b
-10111000b ^ 01110101b = 11001101b
-10111000b ^ 01110110b = 11001110b
-10111000b ^ 01110111b = 11001111b
-10111000b ^ 01111000b = 11000000b
-10111000b ^ 01111001b = 11000001b
-10111000b ^ 01111010b = 11000010b
-10111000b ^ 01111011b = 11000011b
-10111000b ^ 01111100b = 11000100b
-10111000b ^ 01111101b = 11000101b
-10111000b ^ 01111110b = 11000110b
-10111001b ^ 10000000b = 00111001b
-10111001b ^ 10000001b = 00111000b
-10111001b ^ 10000010b = 00111011b
-10111001b ^ 10000011b = 00111010b
-10111001b ^ 10000100b = 00111101b
-10111001b ^ 10000101b = 00111100b
-10111001b ^ 10000110b = 00111111b
-10111001b ^ 10000111b = 00111110b
-10111001b ^ 10001000b = 00110001b
-10111001b ^ 10001001b = 00110000b
-10111001b ^ 10001010b = 00110011b
-10111001b ^ 10001011b = 00110010b
-10111001b ^ 10001100b = 00110101b
-10111001b ^ 10001101b = 00110100b
-10111001b ^ 10001110b = 00110111b
-10111001b ^ 10001111b = 00110110b
-10111001b ^ 10010000b = 00101001b
-10111001b ^ 10010001b = 00101000b
-10111001b ^ 10010010b = 00101011b
-10111001b ^ 10010011b = 00101010b
-10111001b ^ 10010100b = 00101101b
-10111001b ^ 10010101b = 00101100b
-10111001b ^ 10010110b = 00101111b
-10111001b ^ 10010111b = 00101110b
-10111001b ^ 10011000b = 00100001b
-10111001b ^ 10011001b = 00100000b
-10111001b ^ 10011010b = 00100011b
-10111001b ^ 10011011b = 00100010b
-10111001b ^ 10011100b = 00100101b
-10111001b ^ 10011101b = 00100100b
-10111001b ^ 10011110b = 00100111b
-10111001b ^ 10011111b = 00100110b
-10111001b ^ 10100000b = 00011001b
-10111001b ^ 10100001b = 00011000b
-10111001b ^ 10100010b = 00011011b
-10111001b ^ 10100011b = 00011010b
-10111001b ^ 10100100b = 00011101b
-10111001b ^ 10100101b = 00011100b
-10111001b ^ 10100110b = 00011111b
-10111001b ^ 10100111b = 00011110b
-10111001b ^ 10101000b = 00010001b
-10111001b ^ 10101001b = 00010000b
-10111001b ^ 10101010b = 00010011b
-10111001b ^ 10101011b = 00010010b
-10111001b ^ 10101100b = 00010101b
-10111001b ^ 10101101b = 00010100b
-10111001b ^ 10101110b = 00010111b
-10111001b ^ 10101111b = 00010110b
-10111001b ^ 10110000b = 00001001b
-10111001b ^ 10110001b = 00001000b
-10111001b ^ 10110010b = 00001011b
-10111001b ^ 10110011b = 00001010b
-10111001b ^ 10110100b = 00001101b
-10111001b ^ 10110101b = 00001100b
-10111001b ^ 10110110b = 00001111b
-10111001b ^ 10110111b = 00001110b
-10111001b ^ 10111000b = 00000001b
-10111001b ^ 10111001b = 00000000b
-10111001b ^ 10111010b = 00000011b
-10111001b ^ 10111011b = 00000010b
-10111001b ^ 10111100b = 00000101b
-10111001b ^ 10111101b = 00000100b
-10111001b ^ 10111110b = 00000111b
-10111001b ^ 10111111b = 00000110b
-10111001b ^ 11000000b = 01111001b
-10111001b ^ 11000001b = 01111000b
-10111001b ^ 11000010b = 01111011b
-10111001b ^ 11000011b = 01111010b
-10111001b ^ 11000100b = 01111101b
-10111001b ^ 11000101b = 01111100b
-10111001b ^ 11000110b = 01111111b
-10111001b ^ 11000111b = 01111110b
-10111001b ^ 11001000b = 01110001b
-10111001b ^ 11001001b = 01110000b
-10111001b ^ 11001010b = 01110011b
-10111001b ^ 11001011b = 01110010b
-10111001b ^ 11001100b = 01110101b
-10111001b ^ 11001101b = 01110100b
-10111001b ^ 11001110b = 01110111b
-10111001b ^ 11001111b = 01110110b
-10111001b ^ 11010000b = 01101001b
-10111001b ^ 11010001b = 01101000b
-10111001b ^ 11010010b = 01101011b
-10111001b ^ 11010011b = 01101010b
-10111001b ^ 11010100b = 01101101b
-10111001b ^ 11010101b = 01101100b
-10111001b ^ 11010110b = 01101111b
-10111001b ^ 11010111b = 01101110b
-10111001b ^ 11011000b = 01100001b
-10111001b ^ 11011001b = 01100000b
-10111001b ^ 11011010b = 01100011b
-10111001b ^ 11011011b = 01100010b
-10111001b ^ 11011100b = 01100101b
-10111001b ^ 11011101b = 01100100b
-10111001b ^ 11011110b = 01100111b
-10111001b ^ 11011111b = 01100110b
-10111001b ^ 11100000b = 01011001b
-10111001b ^ 11100001b = 01011000b
-10111001b ^ 11100010b = 01011011b
-10111001b ^ 11100011b = 01011010b
-10111001b ^ 11100100b = 01011101b
-10111001b ^ 11100101b = 01011100b
-10111001b ^ 11100110b = 01011111b
-10111001b ^ 11100111b = 01011110b
-10111001b ^ 11101000b = 01010001b
-10111001b ^ 11101001b = 01010000b
-10111001b ^ 11101010b = 01010011b
-10111001b ^ 11101011b = 01010010b
-10111001b ^ 11101100b = 01010101b
-10111001b ^ 11101101b = 01010100b
-10111001b ^ 11101110b = 01010111b
-10111001b ^ 11101111b = 01010110b
-10111001b ^ 11110000b = 01001001b
-10111001b ^ 11110001b = 01001000b
-10111001b ^ 11110010b = 01001011b
-10111001b ^ 11110011b = 01001010b
-10111001b ^ 11110100b = 01001101b
-10111001b ^ 11110101b = 01001100b
-10111001b ^ 11110110b = 01001111b
-10111001b ^ 11110111b = 01001110b
-10111001b ^ 11111000b = 01000001b
-10111001b ^ 11111001b = 01000000b
-10111001b ^ 11111010b = 01000011b
-10111001b ^ 11111011b = 01000010b
-10111001b ^ 11111100b = 01000101b
-10111001b ^ 11111101b = 01000100b
-10111001b ^ 11111110b = 01000111b
-10111001b ^ 11111111b = 01000110b
-10111001b ^ 00000000b = 10111001b
-10111001b ^ 00000001b = 10111000b
-10111001b ^ 00000010b = 10111011b
-10111001b ^ 00000011b = 10111010b
-10111001b ^ 00000100b = 10111101b
-10111001b ^ 00000101b = 10111100b
-10111001b ^ 00000110b = 10111111b
-10111001b ^ 00000111b = 10111110b
-10111001b ^ 00001000b = 10110001b
-10111001b ^ 00001001b = 10110000b
-10111001b ^ 00001010b = 10110011b
-10111001b ^ 00001011b = 10110010b
-10111001b ^ 00001100b = 10110101b
-10111001b ^ 00001101b = 10110100b
-10111001b ^ 00001110b = 10110111b
-10111001b ^ 00001111b = 10110110b
-10111001b ^ 00010000b = 10101001b
-10111001b ^ 00010001b = 10101000b
-10111001b ^ 00010010b = 10101011b
-10111001b ^ 00010011b = 10101010b
-10111001b ^ 00010100b = 10101101b
-10111001b ^ 00010101b = 10101100b
-10111001b ^ 00010110b = 10101111b
-10111001b ^ 00010111b = 10101110b
-10111001b ^ 00011000b = 10100001b
-10111001b ^ 00011001b = 10100000b
-10111001b ^ 00011010b = 10100011b
-10111001b ^ 00011011b = 10100010b
-10111001b ^ 00011100b = 10100101b
-10111001b ^ 00011101b = 10100100b
-10111001b ^ 00011110b = 10100111b
-10111001b ^ 00011111b = 10100110b
-10111001b ^ 00100000b = 10011001b
-10111001b ^ 00100001b = 10011000b
-10111001b ^ 00100010b = 10011011b
-10111001b ^ 00100011b = 10011010b
-10111001b ^ 00100100b = 10011101b
-10111001b ^ 00100101b = 10011100b
-10111001b ^ 00100110b = 10011111b
-10111001b ^ 00100111b = 10011110b
-10111001b ^ 00101000b = 10010001b
-10111001b ^ 00101001b = 10010000b
-10111001b ^ 00101010b = 10010011b
-10111001b ^ 00101011b = 10010010b
-10111001b ^ 00101100b = 10010101b
-10111001b ^ 00101101b = 10010100b
-10111001b ^ 00101110b = 10010111b
-10111001b ^ 00101111b = 10010110b
-10111001b ^ 00110000b = 10001001b
-10111001b ^ 00110001b = 10001000b
-10111001b ^ 00110010b = 10001011b
-10111001b ^ 00110011b = 10001010b
-10111001b ^ 00110100b = 10001101b
-10111001b ^ 00110101b = 10001100b
-10111001b ^ 00110110b = 10001111b
-10111001b ^ 00110111b = 10001110b
-10111001b ^ 00111000b = 10000001b
-10111001b ^ 00111001b = 10000000b
-10111001b ^ 00111010b = 10000011b
-10111001b ^ 00111011b = 10000010b
-10111001b ^ 00111100b = 10000101b
-10111001b ^ 00111101b = 10000100b
-10111001b ^ 00111110b = 10000111b
-10111001b ^ 00111111b = 10000110b
-10111001b ^ 01000000b = 11111001b
-10111001b ^ 01000001b = 11111000b
-10111001b ^ 01000010b = 11111011b
-10111001b ^ 01000011b = 11111010b
-10111001b ^ 01000100b = 11111101b
-10111001b ^ 01000101b = 11111100b
-10111001b ^ 01000110b = 11111111b
-10111001b ^ 01000111b = 11111110b
-10111001b ^ 01001000b = 11110001b
-10111001b ^ 01001001b = 11110000b
-10111001b ^ 01001010b = 11110011b
-10111001b ^ 01001011b = 11110010b
-10111001b ^ 01001100b = 11110101b
-10111001b ^ 01001101b = 11110100b
-10111001b ^ 01001110b = 11110111b
-10111001b ^ 01001111b = 11110110b
-10111001b ^ 01010000b = 11101001b
-10111001b ^ 01010001b = 11101000b
-10111001b ^ 01010010b = 11101011b
-10111001b ^ 01010011b = 11101010b
-10111001b ^ 01010100b = 11101101b
-10111001b ^ 01010101b = 11101100b
-10111001b ^ 01010110b = 11101111b
-10111001b ^ 01010111b = 11101110b
-10111001b ^ 01011000b = 11100001b
-10111001b ^ 01011001b = 11100000b
-10111001b ^ 01011010b = 11100011b
-10111001b ^ 01011011b = 11100010b
-10111001b ^ 01011100b = 11100101b
-10111001b ^ 01011101b = 11100100b
-10111001b ^ 01011110b = 11100111b
-10111001b ^ 01011111b = 11100110b
-10111001b ^ 01100000b = 11011001b
-10111001b ^ 01100001b = 11011000b
-10111001b ^ 01100010b = 11011011b
-10111001b ^ 01100011b = 11011010b
-10111001b ^ 01100100b = 11011101b
-10111001b ^ 01100101b = 11011100b
-10111001b ^ 01100110b = 11011111b
-10111001b ^ 01100111b = 11011110b
-10111001b ^ 01101000b = 11010001b
-10111001b ^ 01101001b = 11010000b
-10111001b ^ 01101010b = 11010011b
-10111001b ^ 01101011b = 11010010b
-10111001b ^ 01101100b = 11010101b
-10111001b ^ 01101101b = 11010100b
-10111001b ^ 01101110b = 11010111b
-10111001b ^ 01101111b = 11010110b
-10111001b ^ 01110000b = 11001001b
-10111001b ^ 01110001b = 11001000b
-10111001b ^ 01110010b = 11001011b
-10111001b ^ 01110011b = 11001010b
-10111001b ^ 01110100b = 11001101b
-10111001b ^ 01110101b = 11001100b
-10111001b ^ 01110110b = 11001111b
-10111001b ^ 01110111b = 11001110b
-10111001b ^ 01111000b = 11000001b
-10111001b ^ 01111001b = 11000000b
-10111001b ^ 01111010b = 11000011b
-10111001b ^ 01111011b = 11000010b
-10111001b ^ 01111100b = 11000101b
-10111001b ^ 01111101b = 11000100b
-10111001b ^ 01111110b = 11000111b
-10111010b ^ 10000000b = 00111010b
-10111010b ^ 10000001b = 00111011b
-10111010b ^ 10000010b = 00111000b
-10111010b ^ 10000011b = 00111001b
-10111010b ^ 10000100b = 00111110b
-10111010b ^ 10000101b = 00111111b
-10111010b ^ 10000110b = 00111100b
-10111010b ^ 10000111b = 00111101b
-10111010b ^ 10001000b = 00110010b
-10111010b ^ 10001001b = 00110011b
-10111010b ^ 10001010b = 00110000b
-10111010b ^ 10001011b = 00110001b
-10111010b ^ 10001100b = 00110110b
-10111010b ^ 10001101b = 00110111b
-10111010b ^ 10001110b = 00110100b
-10111010b ^ 10001111b = 00110101b
-10111010b ^ 10010000b = 00101010b
-10111010b ^ 10010001b = 00101011b
-10111010b ^ 10010010b = 00101000b
-10111010b ^ 10010011b = 00101001b
-10111010b ^ 10010100b = 00101110b
-10111010b ^ 10010101b = 00101111b
-10111010b ^ 10010110b = 00101100b
-10111010b ^ 10010111b = 00101101b
-10111010b ^ 10011000b = 00100010b
-10111010b ^ 10011001b = 00100011b
-10111010b ^ 10011010b = 00100000b
-10111010b ^ 10011011b = 00100001b
-10111010b ^ 10011100b = 00100110b
-10111010b ^ 10011101b = 00100111b
-10111010b ^ 10011110b = 00100100b
-10111010b ^ 10011111b = 00100101b
-10111010b ^ 10100000b = 00011010b
-10111010b ^ 10100001b = 00011011b
-10111010b ^ 10100010b = 00011000b
-10111010b ^ 10100011b = 00011001b
-10111010b ^ 10100100b = 00011110b
-10111010b ^ 10100101b = 00011111b
-10111010b ^ 10100110b = 00011100b
-10111010b ^ 10100111b = 00011101b
-10111010b ^ 10101000b = 00010010b
-10111010b ^ 10101001b = 00010011b
-10111010b ^ 10101010b = 00010000b
-10111010b ^ 10101011b = 00010001b
-10111010b ^ 10101100b = 00010110b
-10111010b ^ 10101101b = 00010111b
-10111010b ^ 10101110b = 00010100b
-10111010b ^ 10101111b = 00010101b
-10111010b ^ 10110000b = 00001010b
-10111010b ^ 10110001b = 00001011b
-10111010b ^ 10110010b = 00001000b
-10111010b ^ 10110011b = 00001001b
-10111010b ^ 10110100b = 00001110b
-10111010b ^ 10110101b = 00001111b
-10111010b ^ 10110110b = 00001100b
-10111010b ^ 10110111b = 00001101b
-10111010b ^ 10111000b = 00000010b
-10111010b ^ 10111001b = 00000011b
-10111010b ^ 10111010b = 00000000b
-10111010b ^ 10111011b = 00000001b
-10111010b ^ 10111100b = 00000110b
-10111010b ^ 10111101b = 00000111b
-10111010b ^ 10111110b = 00000100b
-10111010b ^ 10111111b = 00000101b
-10111010b ^ 11000000b = 01111010b
-10111010b ^ 11000001b = 01111011b
-10111010b ^ 11000010b = 01111000b
-10111010b ^ 11000011b = 01111001b
-10111010b ^ 11000100b = 01111110b
-10111010b ^ 11000101b = 01111111b
-10111010b ^ 11000110b = 01111100b
-10111010b ^ 11000111b = 01111101b
-10111010b ^ 11001000b = 01110010b
-10111010b ^ 11001001b = 01110011b
-10111010b ^ 11001010b = 01110000b
-10111010b ^ 11001011b = 01110001b
-10111010b ^ 11001100b = 01110110b
-10111010b ^ 11001101b = 01110111b
-10111010b ^ 11001110b = 01110100b
-10111010b ^ 11001111b = 01110101b
-10111010b ^ 11010000b = 01101010b
-10111010b ^ 11010001b = 01101011b
-10111010b ^ 11010010b = 01101000b
-10111010b ^ 11010011b = 01101001b
-10111010b ^ 11010100b = 01101110b
-10111010b ^ 11010101b = 01101111b
-10111010b ^ 11010110b = 01101100b
-10111010b ^ 11010111b = 01101101b
-10111010b ^ 11011000b = 01100010b
-10111010b ^ 11011001b = 01100011b
-10111010b ^ 11011010b = 01100000b
-10111010b ^ 11011011b = 01100001b
-10111010b ^ 11011100b = 01100110b
-10111010b ^ 11011101b = 01100111b
-10111010b ^ 11011110b = 01100100b
-10111010b ^ 11011111b = 01100101b
-10111010b ^ 11100000b = 01011010b
-10111010b ^ 11100001b = 01011011b
-10111010b ^ 11100010b = 01011000b
-10111010b ^ 11100011b = 01011001b
-10111010b ^ 11100100b = 01011110b
-10111010b ^ 11100101b = 01011111b
-10111010b ^ 11100110b = 01011100b
-10111010b ^ 11100111b = 01011101b
-10111010b ^ 11101000b = 01010010b
-10111010b ^ 11101001b = 01010011b
-10111010b ^ 11101010b = 01010000b
-10111010b ^ 11101011b = 01010001b
-10111010b ^ 11101100b = 01010110b
-10111010b ^ 11101101b = 01010111b
-10111010b ^ 11101110b = 01010100b
-10111010b ^ 11101111b = 01010101b
-10111010b ^ 11110000b = 01001010b
-10111010b ^ 11110001b = 01001011b
-10111010b ^ 11110010b = 01001000b
-10111010b ^ 11110011b = 01001001b
-10111010b ^ 11110100b = 01001110b
-10111010b ^ 11110101b = 01001111b
-10111010b ^ 11110110b = 01001100b
-10111010b ^ 11110111b = 01001101b
-10111010b ^ 11111000b = 01000010b
-10111010b ^ 11111001b = 01000011b
-10111010b ^ 11111010b = 01000000b
-10111010b ^ 11111011b = 01000001b
-10111010b ^ 11111100b = 01000110b
-10111010b ^ 11111101b = 01000111b
-10111010b ^ 11111110b = 01000100b
-10111010b ^ 11111111b = 01000101b
-10111010b ^ 00000000b = 10111010b
-10111010b ^ 00000001b = 10111011b
-10111010b ^ 00000010b = 10111000b
-10111010b ^ 00000011b = 10111001b
-10111010b ^ 00000100b = 10111110b
-10111010b ^ 00000101b = 10111111b
-10111010b ^ 00000110b = 10111100b
-10111010b ^ 00000111b = 10111101b
-10111010b ^ 00001000b = 10110010b
-10111010b ^ 00001001b = 10110011b
-10111010b ^ 00001010b = 10110000b
-10111010b ^ 00001011b = 10110001b
-10111010b ^ 00001100b = 10110110b
-10111010b ^ 00001101b = 10110111b
-10111010b ^ 00001110b = 10110100b
-10111010b ^ 00001111b = 10110101b
-10111010b ^ 00010000b = 10101010b
-10111010b ^ 00010001b = 10101011b
-10111010b ^ 00010010b = 10101000b
-10111010b ^ 00010011b = 10101001b
-10111010b ^ 00010100b = 10101110b
-10111010b ^ 00010101b = 10101111b
-10111010b ^ 00010110b = 10101100b
-10111010b ^ 00010111b = 10101101b
-10111010b ^ 00011000b = 10100010b
-10111010b ^ 00011001b = 10100011b
-10111010b ^ 00011010b = 10100000b
-10111010b ^ 00011011b = 10100001b
-10111010b ^ 00011100b = 10100110b
-10111010b ^ 00011101b = 10100111b
-10111010b ^ 00011110b = 10100100b
-10111010b ^ 00011111b = 10100101b
-10111010b ^ 00100000b = 10011010b
-10111010b ^ 00100001b = 10011011b
-10111010b ^ 00100010b = 10011000b
-10111010b ^ 00100011b = 10011001b
-10111010b ^ 00100100b = 10011110b
-10111010b ^ 00100101b = 10011111b
-10111010b ^ 00100110b = 10011100b
-10111010b ^ 00100111b = 10011101b
-10111010b ^ 00101000b = 10010010b
-10111010b ^ 00101001b = 10010011b
-10111010b ^ 00101010b = 10010000b
-10111010b ^ 00101011b = 10010001b
-10111010b ^ 00101100b = 10010110b
-10111010b ^ 00101101b = 10010111b
-10111010b ^ 00101110b = 10010100b
-10111010b ^ 00101111b = 10010101b
-10111010b ^ 00110000b = 10001010b
-10111010b ^ 00110001b = 10001011b
-10111010b ^ 00110010b = 10001000b
-10111010b ^ 00110011b = 10001001b
-10111010b ^ 00110100b = 10001110b
-10111010b ^ 00110101b = 10001111b
-10111010b ^ 00110110b = 10001100b
-10111010b ^ 00110111b = 10001101b
-10111010b ^ 00111000b = 10000010b
-10111010b ^ 00111001b = 10000011b
-10111010b ^ 00111010b = 10000000b
-10111010b ^ 00111011b = 10000001b
-10111010b ^ 00111100b = 10000110b
-10111010b ^ 00111101b = 10000111b
-10111010b ^ 00111110b = 10000100b
-10111010b ^ 00111111b = 10000101b
-10111010b ^ 01000000b = 11111010b
-10111010b ^ 01000001b = 11111011b
-10111010b ^ 01000010b = 11111000b
-10111010b ^ 01000011b = 11111001b
-10111010b ^ 01000100b = 11111110b
-10111010b ^ 01000101b = 11111111b
-10111010b ^ 01000110b = 11111100b
-10111010b ^ 01000111b = 11111101b
-10111010b ^ 01001000b = 11110010b
-10111010b ^ 01001001b = 11110011b
-10111010b ^ 01001010b = 11110000b
-10111010b ^ 01001011b = 11110001b
-10111010b ^ 01001100b = 11110110b
-10111010b ^ 01001101b = 11110111b
-10111010b ^ 01001110b = 11110100b
-10111010b ^ 01001111b = 11110101b
-10111010b ^ 01010000b = 11101010b
-10111010b ^ 01010001b = 11101011b
-10111010b ^ 01010010b = 11101000b
-10111010b ^ 01010011b = 11101001b
-10111010b ^ 01010100b = 11101110b
-10111010b ^ 01010101b = 11101111b
-10111010b ^ 01010110b = 11101100b
-10111010b ^ 01010111b = 11101101b
-10111010b ^ 01011000b = 11100010b
-10111010b ^ 01011001b = 11100011b
-10111010b ^ 01011010b = 11100000b
-10111010b ^ 01011011b = 11100001b
-10111010b ^ 01011100b = 11100110b
-10111010b ^ 01011101b = 11100111b
-10111010b ^ 01011110b = 11100100b
-10111010b ^ 01011111b = 11100101b
-10111010b ^ 01100000b = 11011010b
-10111010b ^ 01100001b = 11011011b
-10111010b ^ 01100010b = 11011000b
-10111010b ^ 01100011b = 11011001b
-10111010b ^ 01100100b = 11011110b
-10111010b ^ 01100101b = 11011111b
-10111010b ^ 01100110b = 11011100b
-10111010b ^ 01100111b = 11011101b
-10111010b ^ 01101000b = 11010010b
-10111010b ^ 01101001b = 11010011b
-10111010b ^ 01101010b = 11010000b
-10111010b ^ 01101011b = 11010001b
-10111010b ^ 01101100b = 11010110b
-10111010b ^ 01101101b = 11010111b
-10111010b ^ 01101110b = 11010100b
-10111010b ^ 01101111b = 11010101b
-10111010b ^ 01110000b = 11001010b
-10111010b ^ 01110001b = 11001011b
-10111010b ^ 01110010b = 11001000b
-10111010b ^ 01110011b = 11001001b
-10111010b ^ 01110100b = 11001110b
-10111010b ^ 01110101b = 11001111b
-10111010b ^ 01110110b = 11001100b
-10111010b ^ 01110111b = 11001101b
-10111010b ^ 01111000b = 11000010b
-10111010b ^ 01111001b = 11000011b
-10111010b ^ 01111010b = 11000000b
-10111010b ^ 01111011b = 11000001b
-10111010b ^ 01111100b = 11000110b
-10111010b ^ 01111101b = 11000111b
-10111010b ^ 01111110b = 11000100b
-10111011b ^ 10000000b = 00111011b
-10111011b ^ 10000001b = 00111010b
-10111011b ^ 10000010b = 00111001b
-10111011b ^ 10000011b = 00111000b
-10111011b ^ 10000100b = 00111111b
-10111011b ^ 10000101b = 00111110b
-10111011b ^ 10000110b = 00111101b
-10111011b ^ 10000111b = 00111100b
-10111011b ^ 10001000b = 00110011b
-10111011b ^ 10001001b = 00110010b
-10111011b ^ 10001010b = 00110001b
-10111011b ^ 10001011b = 00110000b
-10111011b ^ 10001100b = 00110111b
-10111011b ^ 10001101b = 00110110b
-10111011b ^ 10001110b = 00110101b
-10111011b ^ 10001111b = 00110100b
-10111011b ^ 10010000b = 00101011b
-10111011b ^ 10010001b = 00101010b
-10111011b ^ 10010010b = 00101001b
-10111011b ^ 10010011b = 00101000b
-10111011b ^ 10010100b = 00101111b
-10111011b ^ 10010101b = 00101110b
-10111011b ^ 10010110b = 00101101b
-10111011b ^ 10010111b = 00101100b
-10111011b ^ 10011000b = 00100011b
-10111011b ^ 10011001b = 00100010b
-10111011b ^ 10011010b = 00100001b
-10111011b ^ 10011011b = 00100000b
-10111011b ^ 10011100b = 00100111b
-10111011b ^ 10011101b = 00100110b
-10111011b ^ 10011110b = 00100101b
-10111011b ^ 10011111b = 00100100b
-10111011b ^ 10100000b = 00011011b
-10111011b ^ 10100001b = 00011010b
-10111011b ^ 10100010b = 00011001b
-10111011b ^ 10100011b = 00011000b
-10111011b ^ 10100100b = 00011111b
-10111011b ^ 10100101b = 00011110b
-10111011b ^ 10100110b = 00011101b
-10111011b ^ 10100111b = 00011100b
-10111011b ^ 10101000b = 00010011b
-10111011b ^ 10101001b = 00010010b
-10111011b ^ 10101010b = 00010001b
-10111011b ^ 10101011b = 00010000b
-10111011b ^ 10101100b = 00010111b
-10111011b ^ 10101101b = 00010110b
-10111011b ^ 10101110b = 00010101b
-10111011b ^ 10101111b = 00010100b
-10111011b ^ 10110000b = 00001011b
-10111011b ^ 10110001b = 00001010b
-10111011b ^ 10110010b = 00001001b
-10111011b ^ 10110011b = 00001000b
-10111011b ^ 10110100b = 00001111b
-10111011b ^ 10110101b = 00001110b
-10111011b ^ 10110110b = 00001101b
-10111011b ^ 10110111b = 00001100b
-10111011b ^ 10111000b = 00000011b
-10111011b ^ 10111001b = 00000010b
-10111011b ^ 10111010b = 00000001b
-10111011b ^ 10111011b = 00000000b
-10111011b ^ 10111100b = 00000111b
-10111011b ^ 10111101b = 00000110b
-10111011b ^ 10111110b = 00000101b
-10111011b ^ 10111111b = 00000100b
-10111011b ^ 11000000b = 01111011b
-10111011b ^ 11000001b = 01111010b
-10111011b ^ 11000010b = 01111001b
-10111011b ^ 11000011b = 01111000b
-10111011b ^ 11000100b = 01111111b
-10111011b ^ 11000101b = 01111110b
-10111011b ^ 11000110b = 01111101b
-10111011b ^ 11000111b = 01111100b
-10111011b ^ 11001000b = 01110011b
-10111011b ^ 11001001b = 01110010b
-10111011b ^ 11001010b = 01110001b
-10111011b ^ 11001011b = 01110000b
-10111011b ^ 11001100b = 01110111b
-10111011b ^ 11001101b = 01110110b
-10111011b ^ 11001110b = 01110101b
-10111011b ^ 11001111b = 01110100b
-10111011b ^ 11010000b = 01101011b
-10111011b ^ 11010001b = 01101010b
-10111011b ^ 11010010b = 01101001b
-10111011b ^ 11010011b = 01101000b
-10111011b ^ 11010100b = 01101111b
-10111011b ^ 11010101b = 01101110b
-10111011b ^ 11010110b = 01101101b
-10111011b ^ 11010111b = 01101100b
-10111011b ^ 11011000b = 01100011b
-10111011b ^ 11011001b = 01100010b
-10111011b ^ 11011010b = 01100001b
-10111011b ^ 11011011b = 01100000b
-10111011b ^ 11011100b = 01100111b
-10111011b ^ 11011101b = 01100110b
-10111011b ^ 11011110b = 01100101b
-10111011b ^ 11011111b = 01100100b
-10111011b ^ 11100000b = 01011011b
-10111011b ^ 11100001b = 01011010b
-10111011b ^ 11100010b = 01011001b
-10111011b ^ 11100011b = 01011000b
-10111011b ^ 11100100b = 01011111b
-10111011b ^ 11100101b = 01011110b
-10111011b ^ 11100110b = 01011101b
-10111011b ^ 11100111b = 01011100b
-10111011b ^ 11101000b = 01010011b
-10111011b ^ 11101001b = 01010010b
-10111011b ^ 11101010b = 01010001b
-10111011b ^ 11101011b = 01010000b
-10111011b ^ 11101100b = 01010111b
-10111011b ^ 11101101b = 01010110b
-10111011b ^ 11101110b = 01010101b
-10111011b ^ 11101111b = 01010100b
-10111011b ^ 11110000b = 01001011b
-10111011b ^ 11110001b = 01001010b
-10111011b ^ 11110010b = 01001001b
-10111011b ^ 11110011b = 01001000b
-10111011b ^ 11110100b = 01001111b
-10111011b ^ 11110101b = 01001110b
-10111011b ^ 11110110b = 01001101b
-10111011b ^ 11110111b = 01001100b
-10111011b ^ 11111000b = 01000011b
-10111011b ^ 11111001b = 01000010b
-10111011b ^ 11111010b = 01000001b
-10111011b ^ 11111011b = 01000000b
-10111011b ^ 11111100b = 01000111b
-10111011b ^ 11111101b = 01000110b
-10111011b ^ 11111110b = 01000101b
-10111011b ^ 11111111b = 01000100b
-10111011b ^ 00000000b = 10111011b
-10111011b ^ 00000001b = 10111010b
-10111011b ^ 00000010b = 10111001b
-10111011b ^ 00000011b = 10111000b
-10111011b ^ 00000100b = 10111111b
-10111011b ^ 00000101b = 10111110b
-10111011b ^ 00000110b = 10111101b
-10111011b ^ 00000111b = 10111100b
-10111011b ^ 00001000b = 10110011b
-10111011b ^ 00001001b = 10110010b
-10111011b ^ 00001010b = 10110001b
-10111011b ^ 00001011b = 10110000b
-10111011b ^ 00001100b = 10110111b
-10111011b ^ 00001101b = 10110110b
-10111011b ^ 00001110b = 10110101b
-10111011b ^ 00001111b = 10110100b
-10111011b ^ 00010000b = 10101011b
-10111011b ^ 00010001b = 10101010b
-10111011b ^ 00010010b = 10101001b
-10111011b ^ 00010011b = 10101000b
-10111011b ^ 00010100b = 10101111b
-10111011b ^ 00010101b = 10101110b
-10111011b ^ 00010110b = 10101101b
-10111011b ^ 00010111b = 10101100b
-10111011b ^ 00011000b = 10100011b
-10111011b ^ 00011001b = 10100010b
-10111011b ^ 00011010b = 10100001b
-10111011b ^ 00011011b = 10100000b
-10111011b ^ 00011100b = 10100111b
-10111011b ^ 00011101b = 10100110b
-10111011b ^ 00011110b = 10100101b
-10111011b ^ 00011111b = 10100100b
-10111011b ^ 00100000b = 10011011b
-10111011b ^ 00100001b = 10011010b
-10111011b ^ 00100010b = 10011001b
-10111011b ^ 00100011b = 10011000b
-10111011b ^ 00100100b = 10011111b
-10111011b ^ 00100101b = 10011110b
-10111011b ^ 00100110b = 10011101b
-10111011b ^ 00100111b = 10011100b
-10111011b ^ 00101000b = 10010011b
-10111011b ^ 00101001b = 10010010b
-10111011b ^ 00101010b = 10010001b
-10111011b ^ 00101011b = 10010000b
-10111011b ^ 00101100b = 10010111b
-10111011b ^ 00101101b = 10010110b
-10111011b ^ 00101110b = 10010101b
-10111011b ^ 00101111b = 10010100b
-10111011b ^ 00110000b = 10001011b
-10111011b ^ 00110001b = 10001010b
-10111011b ^ 00110010b = 10001001b
-10111011b ^ 00110011b = 10001000b
-10111011b ^ 00110100b = 10001111b
-10111011b ^ 00110101b = 10001110b
-10111011b ^ 00110110b = 10001101b
-10111011b ^ 00110111b = 10001100b
-10111011b ^ 00111000b = 10000011b
-10111011b ^ 00111001b = 10000010b
-10111011b ^ 00111010b = 10000001b
-10111011b ^ 00111011b = 10000000b
-10111011b ^ 00111100b = 10000111b
-10111011b ^ 00111101b = 10000110b
-10111011b ^ 00111110b = 10000101b
-10111011b ^ 00111111b = 10000100b
-10111011b ^ 01000000b = 11111011b
-10111011b ^ 01000001b = 11111010b
-10111011b ^ 01000010b = 11111001b
-10111011b ^ 01000011b = 11111000b
-10111011b ^ 01000100b = 11111111b
-10111011b ^ 01000101b = 11111110b
-10111011b ^ 01000110b = 11111101b
-10111011b ^ 01000111b = 11111100b
-10111011b ^ 01001000b = 11110011b
-10111011b ^ 01001001b = 11110010b
-10111011b ^ 01001010b = 11110001b
-10111011b ^ 01001011b = 11110000b
-10111011b ^ 01001100b = 11110111b
-10111011b ^ 01001101b = 11110110b
-10111011b ^ 01001110b = 11110101b
-10111011b ^ 01001111b = 11110100b
-10111011b ^ 01010000b = 11101011b
-10111011b ^ 01010001b = 11101010b
-10111011b ^ 01010010b = 11101001b
-10111011b ^ 01010011b = 11101000b
-10111011b ^ 01010100b = 11101111b
-10111011b ^ 01010101b = 11101110b
-10111011b ^ 01010110b = 11101101b
-10111011b ^ 01010111b = 11101100b
-10111011b ^ 01011000b = 11100011b
-10111011b ^ 01011001b = 11100010b
-10111011b ^ 01011010b = 11100001b
-10111011b ^ 01011011b = 11100000b
-10111011b ^ 01011100b = 11100111b
-10111011b ^ 01011101b = 11100110b
-10111011b ^ 01011110b = 11100101b
-10111011b ^ 01011111b = 11100100b
-10111011b ^ 01100000b = 11011011b
-10111011b ^ 01100001b = 11011010b
-10111011b ^ 01100010b = 11011001b
-10111011b ^ 01100011b = 11011000b
-10111011b ^ 01100100b = 11011111b
-10111011b ^ 01100101b = 11011110b
-10111011b ^ 01100110b = 11011101b
-10111011b ^ 01100111b = 11011100b
-10111011b ^ 01101000b = 11010011b
-10111011b ^ 01101001b = 11010010b
-10111011b ^ 01101010b = 11010001b
-10111011b ^ 01101011b = 11010000b
-10111011b ^ 01101100b = 11010111b
-10111011b ^ 01101101b = 11010110b
-10111011b ^ 01101110b = 11010101b
-10111011b ^ 01101111b = 11010100b
-10111011b ^ 01110000b = 11001011b
-10111011b ^ 01110001b = 11001010b
-10111011b ^ 01110010b = 11001001b
-10111011b ^ 01110011b = 11001000b
-10111011b ^ 01110100b = 11001111b
-10111011b ^ 01110101b = 11001110b
-10111011b ^ 01110110b = 11001101b
-10111011b ^ 01110111b = 11001100b
-10111011b ^ 01111000b = 11000011b
-10111011b ^ 01111001b = 11000010b
-10111011b ^ 01111010b = 11000001b
-10111011b ^ 01111011b = 11000000b
-10111011b ^ 01111100b = 11000111b
-10111011b ^ 01111101b = 11000110b
-10111011b ^ 01111110b = 11000101b
-10111100b ^ 10000000b = 00111100b
-10111100b ^ 10000001b = 00111101b
-10111100b ^ 10000010b = 00111110b
-10111100b ^ 10000011b = 00111111b
-10111100b ^ 10000100b = 00111000b
-10111100b ^ 10000101b = 00111001b
-10111100b ^ 10000110b = 00111010b
-10111100b ^ 10000111b = 00111011b
-10111100b ^ 10001000b = 00110100b
-10111100b ^ 10001001b = 00110101b
-10111100b ^ 10001010b = 00110110b
-10111100b ^ 10001011b = 00110111b
-10111100b ^ 10001100b = 00110000b
-10111100b ^ 10001101b = 00110001b
-10111100b ^ 10001110b = 00110010b
-10111100b ^ 10001111b = 00110011b
-10111100b ^ 10010000b = 00101100b
-10111100b ^ 10010001b = 00101101b
-10111100b ^ 10010010b = 00101110b
-10111100b ^ 10010011b = 00101111b
-10111100b ^ 10010100b = 00101000b
-10111100b ^ 10010101b = 00101001b
-10111100b ^ 10010110b = 00101010b
-10111100b ^ 10010111b = 00101011b
-10111100b ^ 10011000b = 00100100b
-10111100b ^ 10011001b = 00100101b
-10111100b ^ 10011010b = 00100110b
-10111100b ^ 10011011b = 00100111b
-10111100b ^ 10011100b = 00100000b
-10111100b ^ 10011101b = 00100001b
-10111100b ^ 10011110b = 00100010b
-10111100b ^ 10011111b = 00100011b
-10111100b ^ 10100000b = 00011100b
-10111100b ^ 10100001b = 00011101b
-10111100b ^ 10100010b = 00011110b
-10111100b ^ 10100011b = 00011111b
-10111100b ^ 10100100b = 00011000b
-10111100b ^ 10100101b = 00011001b
-10111100b ^ 10100110b = 00011010b
-10111100b ^ 10100111b = 00011011b
-10111100b ^ 10101000b = 00010100b
-10111100b ^ 10101001b = 00010101b
-10111100b ^ 10101010b = 00010110b
-10111100b ^ 10101011b = 00010111b
-10111100b ^ 10101100b = 00010000b
-10111100b ^ 10101101b = 00010001b
-10111100b ^ 10101110b = 00010010b
-10111100b ^ 10101111b = 00010011b
-10111100b ^ 10110000b = 00001100b
-10111100b ^ 10110001b = 00001101b
-10111100b ^ 10110010b = 00001110b
-10111100b ^ 10110011b = 00001111b
-10111100b ^ 10110100b = 00001000b
-10111100b ^ 10110101b = 00001001b
-10111100b ^ 10110110b = 00001010b
-10111100b ^ 10110111b = 00001011b
-10111100b ^ 10111000b = 00000100b
-10111100b ^ 10111001b = 00000101b
-10111100b ^ 10111010b = 00000110b
-10111100b ^ 10111011b = 00000111b
-10111100b ^ 10111100b = 00000000b
-10111100b ^ 10111101b = 00000001b
-10111100b ^ 10111110b = 00000010b
-10111100b ^ 10111111b = 00000011b
-10111100b ^ 11000000b = 01111100b
-10111100b ^ 11000001b = 01111101b
-10111100b ^ 11000010b = 01111110b
-10111100b ^ 11000011b = 01111111b
-10111100b ^ 11000100b = 01111000b
-10111100b ^ 11000101b = 01111001b
-10111100b ^ 11000110b = 01111010b
-10111100b ^ 11000111b = 01111011b
-10111100b ^ 11001000b = 01110100b
-10111100b ^ 11001001b = 01110101b
-10111100b ^ 11001010b = 01110110b
-10111100b ^ 11001011b = 01110111b
-10111100b ^ 11001100b = 01110000b
-10111100b ^ 11001101b = 01110001b
-10111100b ^ 11001110b = 01110010b
-10111100b ^ 11001111b = 01110011b
-10111100b ^ 11010000b = 01101100b
-10111100b ^ 11010001b = 01101101b
-10111100b ^ 11010010b = 01101110b
-10111100b ^ 11010011b = 01101111b
-10111100b ^ 11010100b = 01101000b
-10111100b ^ 11010101b = 01101001b
-10111100b ^ 11010110b = 01101010b
-10111100b ^ 11010111b = 01101011b
-10111100b ^ 11011000b = 01100100b
-10111100b ^ 11011001b = 01100101b
-10111100b ^ 11011010b = 01100110b
-10111100b ^ 11011011b = 01100111b
-10111100b ^ 11011100b = 01100000b
-10111100b ^ 11011101b = 01100001b
-10111100b ^ 11011110b = 01100010b
-10111100b ^ 11011111b = 01100011b
-10111100b ^ 11100000b = 01011100b
-10111100b ^ 11100001b = 01011101b
-10111100b ^ 11100010b = 01011110b
-10111100b ^ 11100011b = 01011111b
-10111100b ^ 11100100b = 01011000b
-10111100b ^ 11100101b = 01011001b
-10111100b ^ 11100110b = 01011010b
-10111100b ^ 11100111b = 01011011b
-10111100b ^ 11101000b = 01010100b
-10111100b ^ 11101001b = 01010101b
-10111100b ^ 11101010b = 01010110b
-10111100b ^ 11101011b = 01010111b
-10111100b ^ 11101100b = 01010000b
-10111100b ^ 11101101b = 01010001b
-10111100b ^ 11101110b = 01010010b
-10111100b ^ 11101111b = 01010011b
-10111100b ^ 11110000b = 01001100b
-10111100b ^ 11110001b = 01001101b
-10111100b ^ 11110010b = 01001110b
-10111100b ^ 11110011b = 01001111b
-10111100b ^ 11110100b = 01001000b
-10111100b ^ 11110101b = 01001001b
-10111100b ^ 11110110b = 01001010b
-10111100b ^ 11110111b = 01001011b
-10111100b ^ 11111000b = 01000100b
-10111100b ^ 11111001b = 01000101b
-10111100b ^ 11111010b = 01000110b
-10111100b ^ 11111011b = 01000111b
-10111100b ^ 11111100b = 01000000b
-10111100b ^ 11111101b = 01000001b
-10111100b ^ 11111110b = 01000010b
-10111100b ^ 11111111b = 01000011b
-10111100b ^ 00000000b = 10111100b
-10111100b ^ 00000001b = 10111101b
-10111100b ^ 00000010b = 10111110b
-10111100b ^ 00000011b = 10111111b
-10111100b ^ 00000100b = 10111000b
-10111100b ^ 00000101b = 10111001b
-10111100b ^ 00000110b = 10111010b
-10111100b ^ 00000111b = 10111011b
-10111100b ^ 00001000b = 10110100b
-10111100b ^ 00001001b = 10110101b
-10111100b ^ 00001010b = 10110110b
-10111100b ^ 00001011b = 10110111b
-10111100b ^ 00001100b = 10110000b
-10111100b ^ 00001101b = 10110001b
-10111100b ^ 00001110b = 10110010b
-10111100b ^ 00001111b = 10110011b
-10111100b ^ 00010000b = 10101100b
-10111100b ^ 00010001b = 10101101b
-10111100b ^ 00010010b = 10101110b
-10111100b ^ 00010011b = 10101111b
-10111100b ^ 00010100b = 10101000b
-10111100b ^ 00010101b = 10101001b
-10111100b ^ 00010110b = 10101010b
-10111100b ^ 00010111b = 10101011b
-10111100b ^ 00011000b = 10100100b
-10111100b ^ 00011001b = 10100101b
-10111100b ^ 00011010b = 10100110b
-10111100b ^ 00011011b = 10100111b
-10111100b ^ 00011100b = 10100000b
-10111100b ^ 00011101b = 10100001b
-10111100b ^ 00011110b = 10100010b
-10111100b ^ 00011111b = 10100011b
-10111100b ^ 00100000b = 10011100b
-10111100b ^ 00100001b = 10011101b
-10111100b ^ 00100010b = 10011110b
-10111100b ^ 00100011b = 10011111b
-10111100b ^ 00100100b = 10011000b
-10111100b ^ 00100101b = 10011001b
-10111100b ^ 00100110b = 10011010b
-10111100b ^ 00100111b = 10011011b
-10111100b ^ 00101000b = 10010100b
-10111100b ^ 00101001b = 10010101b
-10111100b ^ 00101010b = 10010110b
-10111100b ^ 00101011b = 10010111b
-10111100b ^ 00101100b = 10010000b
-10111100b ^ 00101101b = 10010001b
-10111100b ^ 00101110b = 10010010b
-10111100b ^ 00101111b = 10010011b
-10111100b ^ 00110000b = 10001100b
-10111100b ^ 00110001b = 10001101b
-10111100b ^ 00110010b = 10001110b
-10111100b ^ 00110011b = 10001111b
-10111100b ^ 00110100b = 10001000b
-10111100b ^ 00110101b = 10001001b
-10111100b ^ 00110110b = 10001010b
-10111100b ^ 00110111b = 10001011b
-10111100b ^ 00111000b = 10000100b
-10111100b ^ 00111001b = 10000101b
-10111100b ^ 00111010b = 10000110b
-10111100b ^ 00111011b = 10000111b
-10111100b ^ 00111100b = 10000000b
-10111100b ^ 00111101b = 10000001b
-10111100b ^ 00111110b = 10000010b
-10111100b ^ 00111111b = 10000011b
-10111100b ^ 01000000b = 11111100b
-10111100b ^ 01000001b = 11111101b
-10111100b ^ 01000010b = 11111110b
-10111100b ^ 01000011b = 11111111b
-10111100b ^ 01000100b = 11111000b
-10111100b ^ 01000101b = 11111001b
-10111100b ^ 01000110b = 11111010b
-10111100b ^ 01000111b = 11111011b
-10111100b ^ 01001000b = 11110100b
-10111100b ^ 01001001b = 11110101b
-10111100b ^ 01001010b = 11110110b
-10111100b ^ 01001011b = 11110111b
-10111100b ^ 01001100b = 11110000b
-10111100b ^ 01001101b = 11110001b
-10111100b ^ 01001110b = 11110010b
-10111100b ^ 01001111b = 11110011b
-10111100b ^ 01010000b = 11101100b
-10111100b ^ 01010001b = 11101101b
-10111100b ^ 01010010b = 11101110b
-10111100b ^ 01010011b = 11101111b
-10111100b ^ 01010100b = 11101000b
-10111100b ^ 01010101b = 11101001b
-10111100b ^ 01010110b = 11101010b
-10111100b ^ 01010111b = 11101011b
-10111100b ^ 01011000b = 11100100b
-10111100b ^ 01011001b = 11100101b
-10111100b ^ 01011010b = 11100110b
-10111100b ^ 01011011b = 11100111b
-10111100b ^ 01011100b = 11100000b
-10111100b ^ 01011101b = 11100001b
-10111100b ^ 01011110b = 11100010b
-10111100b ^ 01011111b = 11100011b
-10111100b ^ 01100000b = 11011100b
-10111100b ^ 01100001b = 11011101b
-10111100b ^ 01100010b = 11011110b
-10111100b ^ 01100011b = 11011111b
-10111100b ^ 01100100b = 11011000b
-10111100b ^ 01100101b = 11011001b
-10111100b ^ 01100110b = 11011010b
-10111100b ^ 01100111b = 11011011b
-10111100b ^ 01101000b = 11010100b
-10111100b ^ 01101001b = 11010101b
-10111100b ^ 01101010b = 11010110b
-10111100b ^ 01101011b = 11010111b
-10111100b ^ 01101100b = 11010000b
-10111100b ^ 01101101b = 11010001b
-10111100b ^ 01101110b = 11010010b
-10111100b ^ 01101111b = 11010011b
-10111100b ^ 01110000b = 11001100b
-10111100b ^ 01110001b = 11001101b
-10111100b ^ 01110010b = 11001110b
-10111100b ^ 01110011b = 11001111b
-10111100b ^ 01110100b = 11001000b
-10111100b ^ 01110101b = 11001001b
-10111100b ^ 01110110b = 11001010b
-10111100b ^ 01110111b = 11001011b
-10111100b ^ 01111000b = 11000100b
-10111100b ^ 01111001b = 11000101b
-10111100b ^ 01111010b = 11000110b
-10111100b ^ 01111011b = 11000111b
-10111100b ^ 01111100b = 11000000b
-10111100b ^ 01111101b = 11000001b
-10111100b ^ 01111110b = 11000010b
-10111101b ^ 10000000b = 00111101b
-10111101b ^ 10000001b = 00111100b
-10111101b ^ 10000010b = 00111111b
-10111101b ^ 10000011b = 00111110b
-10111101b ^ 10000100b = 00111001b
-10111101b ^ 10000101b = 00111000b
-10111101b ^ 10000110b = 00111011b
-10111101b ^ 10000111b = 00111010b
-10111101b ^ 10001000b = 00110101b
-10111101b ^ 10001001b = 00110100b
-10111101b ^ 10001010b = 00110111b
-10111101b ^ 10001011b = 00110110b
-10111101b ^ 10001100b = 00110001b
-10111101b ^ 10001101b = 00110000b
-10111101b ^ 10001110b = 00110011b
-10111101b ^ 10001111b = 00110010b
-10111101b ^ 10010000b = 00101101b
-10111101b ^ 10010001b = 00101100b
-10111101b ^ 10010010b = 00101111b
-10111101b ^ 10010011b = 00101110b
-10111101b ^ 10010100b = 00101001b
-10111101b ^ 10010101b = 00101000b
-10111101b ^ 10010110b = 00101011b
-10111101b ^ 10010111b = 00101010b
-10111101b ^ 10011000b = 00100101b
-10111101b ^ 10011001b = 00100100b
-10111101b ^ 10011010b = 00100111b
-10111101b ^ 10011011b = 00100110b
-10111101b ^ 10011100b = 00100001b
-10111101b ^ 10011101b = 00100000b
-10111101b ^ 10011110b = 00100011b
-10111101b ^ 10011111b = 00100010b
-10111101b ^ 10100000b = 00011101b
-10111101b ^ 10100001b = 00011100b
-10111101b ^ 10100010b = 00011111b
-10111101b ^ 10100011b = 00011110b
-10111101b ^ 10100100b = 00011001b
-10111101b ^ 10100101b = 00011000b
-10111101b ^ 10100110b = 00011011b
-10111101b ^ 10100111b = 00011010b
-10111101b ^ 10101000b = 00010101b
-10111101b ^ 10101001b = 00010100b
-10111101b ^ 10101010b = 00010111b
-10111101b ^ 10101011b = 00010110b
-10111101b ^ 10101100b = 00010001b
-10111101b ^ 10101101b = 00010000b
-10111101b ^ 10101110b = 00010011b
-10111101b ^ 10101111b = 00010010b
-10111101b ^ 10110000b = 00001101b
-10111101b ^ 10110001b = 00001100b
-10111101b ^ 10110010b = 00001111b
-10111101b ^ 10110011b = 00001110b
-10111101b ^ 10110100b = 00001001b
-10111101b ^ 10110101b = 00001000b
-10111101b ^ 10110110b = 00001011b
-10111101b ^ 10110111b = 00001010b
-10111101b ^ 10111000b = 00000101b
-10111101b ^ 10111001b = 00000100b
-10111101b ^ 10111010b = 00000111b
-10111101b ^ 10111011b = 00000110b
-10111101b ^ 10111100b = 00000001b
-10111101b ^ 10111101b = 00000000b
-10111101b ^ 10111110b = 00000011b
-10111101b ^ 10111111b = 00000010b
-10111101b ^ 11000000b = 01111101b
-10111101b ^ 11000001b = 01111100b
-10111101b ^ 11000010b = 01111111b
-10111101b ^ 11000011b = 01111110b
-10111101b ^ 11000100b = 01111001b
-10111101b ^ 11000101b = 01111000b
-10111101b ^ 11000110b = 01111011b
-10111101b ^ 11000111b = 01111010b
-10111101b ^ 11001000b = 01110101b
-10111101b ^ 11001001b = 01110100b
-10111101b ^ 11001010b = 01110111b
-10111101b ^ 11001011b = 01110110b
-10111101b ^ 11001100b = 01110001b
-10111101b ^ 11001101b = 01110000b
-10111101b ^ 11001110b = 01110011b
-10111101b ^ 11001111b = 01110010b
-10111101b ^ 11010000b = 01101101b
-10111101b ^ 11010001b = 01101100b
-10111101b ^ 11010010b = 01101111b
-10111101b ^ 11010011b = 01101110b
-10111101b ^ 11010100b = 01101001b
-10111101b ^ 11010101b = 01101000b
-10111101b ^ 11010110b = 01101011b
-10111101b ^ 11010111b = 01101010b
-10111101b ^ 11011000b = 01100101b
-10111101b ^ 11011001b = 01100100b
-10111101b ^ 11011010b = 01100111b
-10111101b ^ 11011011b = 01100110b
-10111101b ^ 11011100b = 01100001b
-10111101b ^ 11011101b = 01100000b
-10111101b ^ 11011110b = 01100011b
-10111101b ^ 11011111b = 01100010b
-10111101b ^ 11100000b = 01011101b
-10111101b ^ 11100001b = 01011100b
-10111101b ^ 11100010b = 01011111b
-10111101b ^ 11100011b = 01011110b
-10111101b ^ 11100100b = 01011001b
-10111101b ^ 11100101b = 01011000b
-10111101b ^ 11100110b = 01011011b
-10111101b ^ 11100111b = 01011010b
-10111101b ^ 11101000b = 01010101b
-10111101b ^ 11101001b = 01010100b
-10111101b ^ 11101010b = 01010111b
-10111101b ^ 11101011b = 01010110b
-10111101b ^ 11101100b = 01010001b
-10111101b ^ 11101101b = 01010000b
-10111101b ^ 11101110b = 01010011b
-10111101b ^ 11101111b = 01010010b
-10111101b ^ 11110000b = 01001101b
-10111101b ^ 11110001b = 01001100b
-10111101b ^ 11110010b = 01001111b
-10111101b ^ 11110011b = 01001110b
-10111101b ^ 11110100b = 01001001b
-10111101b ^ 11110101b = 01001000b
-10111101b ^ 11110110b = 01001011b
-10111101b ^ 11110111b = 01001010b
-10111101b ^ 11111000b = 01000101b
-10111101b ^ 11111001b = 01000100b
-10111101b ^ 11111010b = 01000111b
-10111101b ^ 11111011b = 01000110b
-10111101b ^ 11111100b = 01000001b
-10111101b ^ 11111101b = 01000000b
-10111101b ^ 11111110b = 01000011b
-10111101b ^ 11111111b = 01000010b
-10111101b ^ 00000000b = 10111101b
-10111101b ^ 00000001b = 10111100b
-10111101b ^ 00000010b = 10111111b
-10111101b ^ 00000011b = 10111110b
-10111101b ^ 00000100b = 10111001b
-10111101b ^ 00000101b = 10111000b
-10111101b ^ 00000110b = 10111011b
-10111101b ^ 00000111b = 10111010b
-10111101b ^ 00001000b = 10110101b
-10111101b ^ 00001001b = 10110100b
-10111101b ^ 00001010b = 10110111b
-10111101b ^ 00001011b = 10110110b
-10111101b ^ 00001100b = 10110001b
-10111101b ^ 00001101b = 10110000b
-10111101b ^ 00001110b = 10110011b
-10111101b ^ 00001111b = 10110010b
-10111101b ^ 00010000b = 10101101b
-10111101b ^ 00010001b = 10101100b
-10111101b ^ 00010010b = 10101111b
-10111101b ^ 00010011b = 10101110b
-10111101b ^ 00010100b = 10101001b
-10111101b ^ 00010101b = 10101000b
-10111101b ^ 00010110b = 10101011b
-10111101b ^ 00010111b = 10101010b
-10111101b ^ 00011000b = 10100101b
-10111101b ^ 00011001b = 10100100b
-10111101b ^ 00011010b = 10100111b
-10111101b ^ 00011011b = 10100110b
-10111101b ^ 00011100b = 10100001b
-10111101b ^ 00011101b = 10100000b
-10111101b ^ 00011110b = 10100011b
-10111101b ^ 00011111b = 10100010b
-10111101b ^ 00100000b = 10011101b
-10111101b ^ 00100001b = 10011100b
-10111101b ^ 00100010b = 10011111b
-10111101b ^ 00100011b = 10011110b
-10111101b ^ 00100100b = 10011001b
-10111101b ^ 00100101b = 10011000b
-10111101b ^ 00100110b = 10011011b
-10111101b ^ 00100111b = 10011010b
-10111101b ^ 00101000b = 10010101b
-10111101b ^ 00101001b = 10010100b
-10111101b ^ 00101010b = 10010111b
-10111101b ^ 00101011b = 10010110b
-10111101b ^ 00101100b = 10010001b
-10111101b ^ 00101101b = 10010000b
-10111101b ^ 00101110b = 10010011b
-10111101b ^ 00101111b = 10010010b
-10111101b ^ 00110000b = 10001101b
-10111101b ^ 00110001b = 10001100b
-10111101b ^ 00110010b = 10001111b
-10111101b ^ 00110011b = 10001110b
-10111101b ^ 00110100b = 10001001b
-10111101b ^ 00110101b = 10001000b
-10111101b ^ 00110110b = 10001011b
-10111101b ^ 00110111b = 10001010b
-10111101b ^ 00111000b = 10000101b
-10111101b ^ 00111001b = 10000100b
-10111101b ^ 00111010b = 10000111b
-10111101b ^ 00111011b = 10000110b
-10111101b ^ 00111100b = 10000001b
-10111101b ^ 00111101b = 10000000b
-10111101b ^ 00111110b = 10000011b
-10111101b ^ 00111111b = 10000010b
-10111101b ^ 01000000b = 11111101b
-10111101b ^ 01000001b = 11111100b
-10111101b ^ 01000010b = 11111111b
-10111101b ^ 01000011b = 11111110b
-10111101b ^ 01000100b = 11111001b
-10111101b ^ 01000101b = 11111000b
-10111101b ^ 01000110b = 11111011b
-10111101b ^ 01000111b = 11111010b
-10111101b ^ 01001000b = 11110101b
-10111101b ^ 01001001b = 11110100b
-10111101b ^ 01001010b = 11110111b
-10111101b ^ 01001011b = 11110110b
-10111101b ^ 01001100b = 11110001b
-10111101b ^ 01001101b = 11110000b
-10111101b ^ 01001110b = 11110011b
-10111101b ^ 01001111b = 11110010b
-10111101b ^ 01010000b = 11101101b
-10111101b ^ 01010001b = 11101100b
-10111101b ^ 01010010b = 11101111b
-10111101b ^ 01010011b = 11101110b
-10111101b ^ 01010100b = 11101001b
-10111101b ^ 01010101b = 11101000b
-10111101b ^ 01010110b = 11101011b
-10111101b ^ 01010111b = 11101010b
-10111101b ^ 01011000b = 11100101b
-10111101b ^ 01011001b = 11100100b
-10111101b ^ 01011010b = 11100111b
-10111101b ^ 01011011b = 11100110b
-10111101b ^ 01011100b = 11100001b
-10111101b ^ 01011101b = 11100000b
-10111101b ^ 01011110b = 11100011b
-10111101b ^ 01011111b = 11100010b
-10111101b ^ 01100000b = 11011101b
-10111101b ^ 01100001b = 11011100b
-10111101b ^ 01100010b = 11011111b
-10111101b ^ 01100011b = 11011110b
-10111101b ^ 01100100b = 11011001b
-10111101b ^ 01100101b = 11011000b
-10111101b ^ 01100110b = 11011011b
-10111101b ^ 01100111b = 11011010b
-10111101b ^ 01101000b = 11010101b
-10111101b ^ 01101001b = 11010100b
-10111101b ^ 01101010b = 11010111b
-10111101b ^ 01101011b = 11010110b
-10111101b ^ 01101100b = 11010001b
-10111101b ^ 01101101b = 11010000b
-10111101b ^ 01101110b = 11010011b
-10111101b ^ 01101111b = 11010010b
-10111101b ^ 01110000b = 11001101b
-10111101b ^ 01110001b = 11001100b
-10111101b ^ 01110010b = 11001111b
-10111101b ^ 01110011b = 11001110b
-10111101b ^ 01110100b = 11001001b
-10111101b ^ 01110101b = 11001000b
-10111101b ^ 01110110b = 11001011b
-10111101b ^ 01110111b = 11001010b
-10111101b ^ 01111000b = 11000101b
-10111101b ^ 01111001b = 11000100b
-10111101b ^ 01111010b = 11000111b
-10111101b ^ 01111011b = 11000110b
-10111101b ^ 01111100b = 11000001b
-10111101b ^ 01111101b = 11000000b
-10111101b ^ 01111110b = 11000011b
-10111110b ^ 10000000b = 00111110b
-10111110b ^ 10000001b = 00111111b
-10111110b ^ 10000010b = 00111100b
-10111110b ^ 10000011b = 00111101b
-10111110b ^ 10000100b = 00111010b
-10111110b ^ 10000101b = 00111011b
-10111110b ^ 10000110b = 00111000b
-10111110b ^ 10000111b = 00111001b
-10111110b ^ 10001000b = 00110110b
-10111110b ^ 10001001b = 00110111b
-10111110b ^ 10001010b = 00110100b
-10111110b ^ 10001011b = 00110101b
-10111110b ^ 10001100b = 00110010b
-10111110b ^ 10001101b = 00110011b
-10111110b ^ 10001110b = 00110000b
-10111110b ^ 10001111b = 00110001b
-10111110b ^ 10010000b = 00101110b
-10111110b ^ 10010001b = 00101111b
-10111110b ^ 10010010b = 00101100b
-10111110b ^ 10010011b = 00101101b
-10111110b ^ 10010100b = 00101010b
-10111110b ^ 10010101b = 00101011b
-10111110b ^ 10010110b = 00101000b
-10111110b ^ 10010111b = 00101001b
-10111110b ^ 10011000b = 00100110b
-10111110b ^ 10011001b = 00100111b
-10111110b ^ 10011010b = 00100100b
-10111110b ^ 10011011b = 00100101b
-10111110b ^ 10011100b = 00100010b
-10111110b ^ 10011101b = 00100011b
-10111110b ^ 10011110b = 00100000b
-10111110b ^ 10011111b = 00100001b
-10111110b ^ 10100000b = 00011110b
-10111110b ^ 10100001b = 00011111b
-10111110b ^ 10100010b = 00011100b
-10111110b ^ 10100011b = 00011101b
-10111110b ^ 10100100b = 00011010b
-10111110b ^ 10100101b = 00011011b
-10111110b ^ 10100110b = 00011000b
-10111110b ^ 10100111b = 00011001b
-10111110b ^ 10101000b = 00010110b
-10111110b ^ 10101001b = 00010111b
-10111110b ^ 10101010b = 00010100b
-10111110b ^ 10101011b = 00010101b
-10111110b ^ 10101100b = 00010010b
-10111110b ^ 10101101b = 00010011b
-10111110b ^ 10101110b = 00010000b
-10111110b ^ 10101111b = 00010001b
-10111110b ^ 10110000b = 00001110b
-10111110b ^ 10110001b = 00001111b
-10111110b ^ 10110010b = 00001100b
-10111110b ^ 10110011b = 00001101b
-10111110b ^ 10110100b = 00001010b
-10111110b ^ 10110101b = 00001011b
-10111110b ^ 10110110b = 00001000b
-10111110b ^ 10110111b = 00001001b
-10111110b ^ 10111000b = 00000110b
-10111110b ^ 10111001b = 00000111b
-10111110b ^ 10111010b = 00000100b
-10111110b ^ 10111011b = 00000101b
-10111110b ^ 10111100b = 00000010b
-10111110b ^ 10111101b = 00000011b
-10111110b ^ 10111110b = 00000000b
-10111110b ^ 10111111b = 00000001b
-10111110b ^ 11000000b = 01111110b
-10111110b ^ 11000001b = 01111111b
-10111110b ^ 11000010b = 01111100b
-10111110b ^ 11000011b = 01111101b
-10111110b ^ 11000100b = 01111010b
-10111110b ^ 11000101b = 01111011b
-10111110b ^ 11000110b = 01111000b
-10111110b ^ 11000111b = 01111001b
-10111110b ^ 11001000b = 01110110b
-10111110b ^ 11001001b = 01110111b
-10111110b ^ 11001010b = 01110100b
-10111110b ^ 11001011b = 01110101b
-10111110b ^ 11001100b = 01110010b
-10111110b ^ 11001101b = 01110011b
-10111110b ^ 11001110b = 01110000b
-10111110b ^ 11001111b = 01110001b
-10111110b ^ 11010000b = 01101110b
-10111110b ^ 11010001b = 01101111b
-10111110b ^ 11010010b = 01101100b
-10111110b ^ 11010011b = 01101101b
-10111110b ^ 11010100b = 01101010b
-10111110b ^ 11010101b = 01101011b
-10111110b ^ 11010110b = 01101000b
-10111110b ^ 11010111b = 01101001b
-10111110b ^ 11011000b = 01100110b
-10111110b ^ 11011001b = 01100111b
-10111110b ^ 11011010b = 01100100b
-10111110b ^ 11011011b = 01100101b
-10111110b ^ 11011100b = 01100010b
-10111110b ^ 11011101b = 01100011b
-10111110b ^ 11011110b = 01100000b
-10111110b ^ 11011111b = 01100001b
-10111110b ^ 11100000b = 01011110b
-10111110b ^ 11100001b = 01011111b
-10111110b ^ 11100010b = 01011100b
-10111110b ^ 11100011b = 01011101b
-10111110b ^ 11100100b = 01011010b
-10111110b ^ 11100101b = 01011011b
-10111110b ^ 11100110b = 01011000b
-10111110b ^ 11100111b = 01011001b
-10111110b ^ 11101000b = 01010110b
-10111110b ^ 11101001b = 01010111b
-10111110b ^ 11101010b = 01010100b
-10111110b ^ 11101011b = 01010101b
-10111110b ^ 11101100b = 01010010b
-10111110b ^ 11101101b = 01010011b
-10111110b ^ 11101110b = 01010000b
-10111110b ^ 11101111b = 01010001b
-10111110b ^ 11110000b = 01001110b
-10111110b ^ 11110001b = 01001111b
-10111110b ^ 11110010b = 01001100b
-10111110b ^ 11110011b = 01001101b
-10111110b ^ 11110100b = 01001010b
-10111110b ^ 11110101b = 01001011b
-10111110b ^ 11110110b = 01001000b
-10111110b ^ 11110111b = 01001001b
-10111110b ^ 11111000b = 01000110b
-10111110b ^ 11111001b = 01000111b
-10111110b ^ 11111010b = 01000100b
-10111110b ^ 11111011b = 01000101b
-10111110b ^ 11111100b = 01000010b
-10111110b ^ 11111101b = 01000011b
-10111110b ^ 11111110b = 01000000b
-10111110b ^ 11111111b = 01000001b
-10111110b ^ 00000000b = 10111110b
-10111110b ^ 00000001b = 10111111b
-10111110b ^ 00000010b = 10111100b
-10111110b ^ 00000011b = 10111101b
-10111110b ^ 00000100b = 10111010b
-10111110b ^ 00000101b = 10111011b
-10111110b ^ 00000110b = 10111000b
-10111110b ^ 00000111b = 10111001b
-10111110b ^ 00001000b = 10110110b
-10111110b ^ 00001001b = 10110111b
-10111110b ^ 00001010b = 10110100b
-10111110b ^ 00001011b = 10110101b
-10111110b ^ 00001100b = 10110010b
-10111110b ^ 00001101b = 10110011b
-10111110b ^ 00001110b = 10110000b
-10111110b ^ 00001111b = 10110001b
-10111110b ^ 00010000b = 10101110b
-10111110b ^ 00010001b = 10101111b
-10111110b ^ 00010010b = 10101100b
-10111110b ^ 00010011b = 10101101b
-10111110b ^ 00010100b = 10101010b
-10111110b ^ 00010101b = 10101011b
-10111110b ^ 00010110b = 10101000b
-10111110b ^ 00010111b = 10101001b
-10111110b ^ 00011000b = 10100110b
-10111110b ^ 00011001b = 10100111b
-10111110b ^ 00011010b = 10100100b
-10111110b ^ 00011011b = 10100101b
-10111110b ^ 00011100b = 10100010b
-10111110b ^ 00011101b = 10100011b
-10111110b ^ 00011110b = 10100000b
-10111110b ^ 00011111b = 10100001b
-10111110b ^ 00100000b = 10011110b
-10111110b ^ 00100001b = 10011111b
-10111110b ^ 00100010b = 10011100b
-10111110b ^ 00100011b = 10011101b
-10111110b ^ 00100100b = 10011010b
-10111110b ^ 00100101b = 10011011b
-10111110b ^ 00100110b = 10011000b
-10111110b ^ 00100111b = 10011001b
-10111110b ^ 00101000b = 10010110b
-10111110b ^ 00101001b = 10010111b
-10111110b ^ 00101010b = 10010100b
-10111110b ^ 00101011b = 10010101b
-10111110b ^ 00101100b = 10010010b
-10111110b ^ 00101101b = 10010011b
-10111110b ^ 00101110b = 10010000b
-10111110b ^ 00101111b = 10010001b
-10111110b ^ 00110000b = 10001110b
-10111110b ^ 00110001b = 10001111b
-10111110b ^ 00110010b = 10001100b
-10111110b ^ 00110011b = 10001101b
-10111110b ^ 00110100b = 10001010b
-10111110b ^ 00110101b = 10001011b
-10111110b ^ 00110110b = 10001000b
-10111110b ^ 00110111b = 10001001b
-10111110b ^ 00111000b = 10000110b
-10111110b ^ 00111001b = 10000111b
-10111110b ^ 00111010b = 10000100b
-10111110b ^ 00111011b = 10000101b
-10111110b ^ 00111100b = 10000010b
-10111110b ^ 00111101b = 10000011b
-10111110b ^ 00111110b = 10000000b
-10111110b ^ 00111111b = 10000001b
-10111110b ^ 01000000b = 11111110b
-10111110b ^ 01000001b = 11111111b
-10111110b ^ 01000010b = 11111100b
-10111110b ^ 01000011b = 11111101b
-10111110b ^ 01000100b = 11111010b
-10111110b ^ 01000101b = 11111011b
-10111110b ^ 01000110b = 11111000b
-10111110b ^ 01000111b = 11111001b
-10111110b ^ 01001000b = 11110110b
-10111110b ^ 01001001b = 11110111b
-10111110b ^ 01001010b = 11110100b
-10111110b ^ 01001011b = 11110101b
-10111110b ^ 01001100b = 11110010b
-10111110b ^ 01001101b = 11110011b
-10111110b ^ 01001110b = 11110000b
-10111110b ^ 01001111b = 11110001b
-10111110b ^ 01010000b = 11101110b
-10111110b ^ 01010001b = 11101111b
-10111110b ^ 01010010b = 11101100b
-10111110b ^ 01010011b = 11101101b
-10111110b ^ 01010100b = 11101010b
-10111110b ^ 01010101b = 11101011b
-10111110b ^ 01010110b = 11101000b
-10111110b ^ 01010111b = 11101001b
-10111110b ^ 01011000b = 11100110b
-10111110b ^ 01011001b = 11100111b
-10111110b ^ 01011010b = 11100100b
-10111110b ^ 01011011b = 11100101b
-10111110b ^ 01011100b = 11100010b
-10111110b ^ 01011101b = 11100011b
-10111110b ^ 01011110b = 11100000b
-10111110b ^ 01011111b = 11100001b
-10111110b ^ 01100000b = 11011110b
-10111110b ^ 01100001b = 11011111b
-10111110b ^ 01100010b = 11011100b
-10111110b ^ 01100011b = 11011101b
-10111110b ^ 01100100b = 11011010b
-10111110b ^ 01100101b = 11011011b
-10111110b ^ 01100110b = 11011000b
-10111110b ^ 01100111b = 11011001b
-10111110b ^ 01101000b = 11010110b
-10111110b ^ 01101001b = 11010111b
-10111110b ^ 01101010b = 11010100b
-10111110b ^ 01101011b = 11010101b
-10111110b ^ 01101100b = 11010010b
-10111110b ^ 01101101b = 11010011b
-10111110b ^ 01101110b = 11010000b
-10111110b ^ 01101111b = 11010001b
-10111110b ^ 01110000b = 11001110b
-10111110b ^ 01110001b = 11001111b
-10111110b ^ 01110010b = 11001100b
-10111110b ^ 01110011b = 11001101b
-10111110b ^ 01110100b = 11001010b
-10111110b ^ 01110101b = 11001011b
-10111110b ^ 01110110b = 11001000b
-10111110b ^ 01110111b = 11001001b
-10111110b ^ 01111000b = 11000110b
-10111110b ^ 01111001b = 11000111b
-10111110b ^ 01111010b = 11000100b
-10111110b ^ 01111011b = 11000101b
-10111110b ^ 01111100b = 11000010b
-10111110b ^ 01111101b = 11000011b
-10111110b ^ 01111110b = 11000000b
-10111111b ^ 10000000b = 00111111b
-10111111b ^ 10000001b = 00111110b
-10111111b ^ 10000010b = 00111101b
-10111111b ^ 10000011b = 00111100b
-10111111b ^ 10000100b = 00111011b
-10111111b ^ 10000101b = 00111010b
-10111111b ^ 10000110b = 00111001b
-10111111b ^ 10000111b = 00111000b
-10111111b ^ 10001000b = 00110111b
-10111111b ^ 10001001b = 00110110b
-10111111b ^ 10001010b = 00110101b
-10111111b ^ 10001011b = 00110100b
-10111111b ^ 10001100b = 00110011b
-10111111b ^ 10001101b = 00110010b
-10111111b ^ 10001110b = 00110001b
-10111111b ^ 10001111b = 00110000b
-10111111b ^ 10010000b = 00101111b
-10111111b ^ 10010001b = 00101110b
-10111111b ^ 10010010b = 00101101b
-10111111b ^ 10010011b = 00101100b
-10111111b ^ 10010100b = 00101011b
-10111111b ^ 10010101b = 00101010b
-10111111b ^ 10010110b = 00101001b
-10111111b ^ 10010111b = 00101000b
-10111111b ^ 10011000b = 00100111b
-10111111b ^ 10011001b = 00100110b
-10111111b ^ 10011010b = 00100101b
-10111111b ^ 10011011b = 00100100b
-10111111b ^ 10011100b = 00100011b
-10111111b ^ 10011101b = 00100010b
-10111111b ^ 10011110b = 00100001b
-10111111b ^ 10011111b = 00100000b
-10111111b ^ 10100000b = 00011111b
-10111111b ^ 10100001b = 00011110b
-10111111b ^ 10100010b = 00011101b
-10111111b ^ 10100011b = 00011100b
-10111111b ^ 10100100b = 00011011b
-10111111b ^ 10100101b = 00011010b
-10111111b ^ 10100110b = 00011001b
-10111111b ^ 10100111b = 00011000b
-10111111b ^ 10101000b = 00010111b
-10111111b ^ 10101001b = 00010110b
-10111111b ^ 10101010b = 00010101b
-10111111b ^ 10101011b = 00010100b
-10111111b ^ 10101100b = 00010011b
-10111111b ^ 10101101b = 00010010b
-10111111b ^ 10101110b = 00010001b
-10111111b ^ 10101111b = 00010000b
-10111111b ^ 10110000b = 00001111b
-10111111b ^ 10110001b = 00001110b
-10111111b ^ 10110010b = 00001101b
-10111111b ^ 10110011b = 00001100b
-10111111b ^ 10110100b = 00001011b
-10111111b ^ 10110101b = 00001010b
-10111111b ^ 10110110b = 00001001b
-10111111b ^ 10110111b = 00001000b
-10111111b ^ 10111000b = 00000111b
-10111111b ^ 10111001b = 00000110b
-10111111b ^ 10111010b = 00000101b
-10111111b ^ 10111011b = 00000100b
-10111111b ^ 10111100b = 00000011b
-10111111b ^ 10111101b = 00000010b
-10111111b ^ 10111110b = 00000001b
-10111111b ^ 10111111b = 00000000b
-10111111b ^ 11000000b = 01111111b
-10111111b ^ 11000001b = 01111110b
-10111111b ^ 11000010b = 01111101b
-10111111b ^ 11000011b = 01111100b
-10111111b ^ 11000100b = 01111011b
-10111111b ^ 11000101b = 01111010b
-10111111b ^ 11000110b = 01111001b
-10111111b ^ 11000111b = 01111000b
-10111111b ^ 11001000b = 01110111b
-10111111b ^ 11001001b = 01110110b
-10111111b ^ 11001010b = 01110101b
-10111111b ^ 11001011b = 01110100b
-10111111b ^ 11001100b = 01110011b
-10111111b ^ 11001101b = 01110010b
-10111111b ^ 11001110b = 01110001b
-10111111b ^ 11001111b = 01110000b
-10111111b ^ 11010000b = 01101111b
-10111111b ^ 11010001b = 01101110b
-10111111b ^ 11010010b = 01101101b
-10111111b ^ 11010011b = 01101100b
-10111111b ^ 11010100b = 01101011b
-10111111b ^ 11010101b = 01101010b
-10111111b ^ 11010110b = 01101001b
-10111111b ^ 11010111b = 01101000b
-10111111b ^ 11011000b = 01100111b
-10111111b ^ 11011001b = 01100110b
-10111111b ^ 11011010b = 01100101b
-10111111b ^ 11011011b = 01100100b
-10111111b ^ 11011100b = 01100011b
-10111111b ^ 11011101b = 01100010b
-10111111b ^ 11011110b = 01100001b
-10111111b ^ 11011111b = 01100000b
-10111111b ^ 11100000b = 01011111b
-10111111b ^ 11100001b = 01011110b
-10111111b ^ 11100010b = 01011101b
-10111111b ^ 11100011b = 01011100b
-10111111b ^ 11100100b = 01011011b
-10111111b ^ 11100101b = 01011010b
-10111111b ^ 11100110b = 01011001b
-10111111b ^ 11100111b = 01011000b
-10111111b ^ 11101000b = 01010111b
-10111111b ^ 11101001b = 01010110b
-10111111b ^ 11101010b = 01010101b
-10111111b ^ 11101011b = 01010100b
-10111111b ^ 11101100b = 01010011b
-10111111b ^ 11101101b = 01010010b
-10111111b ^ 11101110b = 01010001b
-10111111b ^ 11101111b = 01010000b
-10111111b ^ 11110000b = 01001111b
-10111111b ^ 11110001b = 01001110b
-10111111b ^ 11110010b = 01001101b
-10111111b ^ 11110011b = 01001100b
-10111111b ^ 11110100b = 01001011b
-10111111b ^ 11110101b = 01001010b
-10111111b ^ 11110110b = 01001001b
-10111111b ^ 11110111b = 01001000b
-10111111b ^ 11111000b = 01000111b
-10111111b ^ 11111001b = 01000110b
-10111111b ^ 11111010b = 01000101b
-10111111b ^ 11111011b = 01000100b
-10111111b ^ 11111100b = 01000011b
-10111111b ^ 11111101b = 01000010b
-10111111b ^ 11111110b = 01000001b
-10111111b ^ 11111111b = 01000000b
-10111111b ^ 00000000b = 10111111b
-10111111b ^ 00000001b = 10111110b
-10111111b ^ 00000010b = 10111101b
-10111111b ^ 00000011b = 10111100b
-10111111b ^ 00000100b = 10111011b
-10111111b ^ 00000101b = 10111010b
-10111111b ^ 00000110b = 10111001b
-10111111b ^ 00000111b = 10111000b
-10111111b ^ 00001000b = 10110111b
-10111111b ^ 00001001b = 10110110b
-10111111b ^ 00001010b = 10110101b
-10111111b ^ 00001011b = 10110100b
-10111111b ^ 00001100b = 10110011b
-10111111b ^ 00001101b = 10110010b
-10111111b ^ 00001110b = 10110001b
-10111111b ^ 00001111b = 10110000b
-10111111b ^ 00010000b = 10101111b
-10111111b ^ 00010001b = 10101110b
-10111111b ^ 00010010b = 10101101b
-10111111b ^ 00010011b = 10101100b
-10111111b ^ 00010100b = 10101011b
-10111111b ^ 00010101b = 10101010b
-10111111b ^ 00010110b = 10101001b
-10111111b ^ 00010111b = 10101000b
-10111111b ^ 00011000b = 10100111b
-10111111b ^ 00011001b = 10100110b
-10111111b ^ 00011010b = 10100101b
-10111111b ^ 00011011b = 10100100b
-10111111b ^ 00011100b = 10100011b
-10111111b ^ 00011101b = 10100010b
-10111111b ^ 00011110b = 10100001b
-10111111b ^ 00011111b = 10100000b
-10111111b ^ 00100000b = 10011111b
-10111111b ^ 00100001b = 10011110b
-10111111b ^ 00100010b = 10011101b
-10111111b ^ 00100011b = 10011100b
-10111111b ^ 00100100b = 10011011b
-10111111b ^ 00100101b = 10011010b
-10111111b ^ 00100110b = 10011001b
-10111111b ^ 00100111b = 10011000b
-10111111b ^ 00101000b = 10010111b
-10111111b ^ 00101001b = 10010110b
-10111111b ^ 00101010b = 10010101b
-10111111b ^ 00101011b = 10010100b
-10111111b ^ 00101100b = 10010011b
-10111111b ^ 00101101b = 10010010b
-10111111b ^ 00101110b = 10010001b
-10111111b ^ 00101111b = 10010000b
-10111111b ^ 00110000b = 10001111b
-10111111b ^ 00110001b = 10001110b
-10111111b ^ 00110010b = 10001101b
-10111111b ^ 00110011b = 10001100b
-10111111b ^ 00110100b = 10001011b
-10111111b ^ 00110101b = 10001010b
-10111111b ^ 00110110b = 10001001b
-10111111b ^ 00110111b = 10001000b
-10111111b ^ 00111000b = 10000111b
-10111111b ^ 00111001b = 10000110b
-10111111b ^ 00111010b = 10000101b
-10111111b ^ 00111011b = 10000100b
-10111111b ^ 00111100b = 10000011b
-10111111b ^ 00111101b = 10000010b
-10111111b ^ 00111110b = 10000001b
-10111111b ^ 00111111b = 10000000b
-10111111b ^ 01000000b = 11111111b
-10111111b ^ 01000001b = 11111110b
-10111111b ^ 01000010b = 11111101b
-10111111b ^ 01000011b = 11111100b
-10111111b ^ 01000100b = 11111011b
-10111111b ^ 01000101b = 11111010b
-10111111b ^ 01000110b = 11111001b
-10111111b ^ 01000111b = 11111000b
-10111111b ^ 01001000b = 11110111b
-10111111b ^ 01001001b = 11110110b
-10111111b ^ 01001010b = 11110101b
-10111111b ^ 01001011b = 11110100b
-10111111b ^ 01001100b = 11110011b
-10111111b ^ 01001101b = 11110010b
-10111111b ^ 01001110b = 11110001b
-10111111b ^ 01001111b = 11110000b
-10111111b ^ 01010000b = 11101111b
-10111111b ^ 01010001b = 11101110b
-10111111b ^ 01010010b = 11101101b
-10111111b ^ 01010011b = 11101100b
-10111111b ^ 01010100b = 11101011b
-10111111b ^ 01010101b = 11101010b
-10111111b ^ 01010110b = 11101001b
-10111111b ^ 01010111b = 11101000b
-10111111b ^ 01011000b = 11100111b
-10111111b ^ 01011001b = 11100110b
-10111111b ^ 01011010b = 11100101b
-10111111b ^ 01011011b = 11100100b
-10111111b ^ 01011100b = 11100011b
-10111111b ^ 01011101b = 11100010b
-10111111b ^ 01011110b = 11100001b
-10111111b ^ 01011111b = 11100000b
-10111111b ^ 01100000b = 11011111b
-10111111b ^ 01100001b = 11011110b
-10111111b ^ 01100010b = 11011101b
-10111111b ^ 01100011b = 11011100b
-10111111b ^ 01100100b = 11011011b
-10111111b ^ 01100101b = 11011010b
-10111111b ^ 01100110b = 11011001b
-10111111b ^ 01100111b = 11011000b
-10111111b ^ 01101000b = 11010111b
-10111111b ^ 01101001b = 11010110b
-10111111b ^ 01101010b = 11010101b
-10111111b ^ 01101011b = 11010100b
-10111111b ^ 01101100b = 11010011b
-10111111b ^ 01101101b = 11010010b
-10111111b ^ 01101110b = 11010001b
-10111111b ^ 01101111b = 11010000b
-10111111b ^ 01110000b = 11001111b
-10111111b ^ 01110001b = 11001110b
-10111111b ^ 01110010b = 11001101b
-10111111b ^ 01110011b = 11001100b
-10111111b ^ 01110100b = 11001011b
-10111111b ^ 01110101b = 11001010b
-10111111b ^ 01110110b = 11001001b
-10111111b ^ 01110111b = 11001000b
-10111111b ^ 01111000b = 11000111b
-10111111b ^ 01111001b = 11000110b
-10111111b ^ 01111010b = 11000101b
-10111111b ^ 01111011b = 11000100b
-10111111b ^ 01111100b = 11000011b
-10111111b ^ 01111101b = 11000010b
-10111111b ^ 01111110b = 11000001b
-11000000b ^ 10000000b = 01000000b
-11000000b ^ 10000001b = 01000001b
-11000000b ^ 10000010b = 01000010b
-11000000b ^ 10000011b = 01000011b
-11000000b ^ 10000100b = 01000100b
-11000000b ^ 10000101b = 01000101b
-11000000b ^ 10000110b = 01000110b
-11000000b ^ 10000111b = 01000111b
-11000000b ^ 10001000b = 01001000b
-11000000b ^ 10001001b = 01001001b
-11000000b ^ 10001010b = 01001010b
-11000000b ^ 10001011b = 01001011b
-11000000b ^ 10001100b = 01001100b
-11000000b ^ 10001101b = 01001101b
-11000000b ^ 10001110b = 01001110b
-11000000b ^ 10001111b = 01001111b
-11000000b ^ 10010000b = 01010000b
-11000000b ^ 10010001b = 01010001b
-11000000b ^ 10010010b = 01010010b
-11000000b ^ 10010011b = 01010011b
-11000000b ^ 10010100b = 01010100b
-11000000b ^ 10010101b = 01010101b
-11000000b ^ 10010110b = 01010110b
-11000000b ^ 10010111b = 01010111b
-11000000b ^ 10011000b = 01011000b
-11000000b ^ 10011001b = 01011001b
-11000000b ^ 10011010b = 01011010b
-11000000b ^ 10011011b = 01011011b
-11000000b ^ 10011100b = 01011100b
-11000000b ^ 10011101b = 01011101b
-11000000b ^ 10011110b = 01011110b
-11000000b ^ 10011111b = 01011111b
-11000000b ^ 10100000b = 01100000b
-11000000b ^ 10100001b = 01100001b
-11000000b ^ 10100010b = 01100010b
-11000000b ^ 10100011b = 01100011b
-11000000b ^ 10100100b = 01100100b
-11000000b ^ 10100101b = 01100101b
-11000000b ^ 10100110b = 01100110b
-11000000b ^ 10100111b = 01100111b
-11000000b ^ 10101000b = 01101000b
-11000000b ^ 10101001b = 01101001b
-11000000b ^ 10101010b = 01101010b
-11000000b ^ 10101011b = 01101011b
-11000000b ^ 10101100b = 01101100b
-11000000b ^ 10101101b = 01101101b
-11000000b ^ 10101110b = 01101110b
-11000000b ^ 10101111b = 01101111b
-11000000b ^ 10110000b = 01110000b
-11000000b ^ 10110001b = 01110001b
-11000000b ^ 10110010b = 01110010b
-11000000b ^ 10110011b = 01110011b
-11000000b ^ 10110100b = 01110100b
-11000000b ^ 10110101b = 01110101b
-11000000b ^ 10110110b = 01110110b
-11000000b ^ 10110111b = 01110111b
-11000000b ^ 10111000b = 01111000b
-11000000b ^ 10111001b = 01111001b
-11000000b ^ 10111010b = 01111010b
-11000000b ^ 10111011b = 01111011b
-11000000b ^ 10111100b = 01111100b
-11000000b ^ 10111101b = 01111101b
-11000000b ^ 10111110b = 01111110b
-11000000b ^ 10111111b = 01111111b
-11000000b ^ 11000000b = 00000000b
-11000000b ^ 11000001b = 00000001b
-11000000b ^ 11000010b = 00000010b
-11000000b ^ 11000011b = 00000011b
-11000000b ^ 11000100b = 00000100b
-11000000b ^ 11000101b = 00000101b
-11000000b ^ 11000110b = 00000110b
-11000000b ^ 11000111b = 00000111b
-11000000b ^ 11001000b = 00001000b
-11000000b ^ 11001001b = 00001001b
-11000000b ^ 11001010b = 00001010b
-11000000b ^ 11001011b = 00001011b
-11000000b ^ 11001100b = 00001100b
-11000000b ^ 11001101b = 00001101b
-11000000b ^ 11001110b = 00001110b
-11000000b ^ 11001111b = 00001111b
-11000000b ^ 11010000b = 00010000b
-11000000b ^ 11010001b = 00010001b
-11000000b ^ 11010010b = 00010010b
-11000000b ^ 11010011b = 00010011b
-11000000b ^ 11010100b = 00010100b
-11000000b ^ 11010101b = 00010101b
-11000000b ^ 11010110b = 00010110b
-11000000b ^ 11010111b = 00010111b
-11000000b ^ 11011000b = 00011000b
-11000000b ^ 11011001b = 00011001b
-11000000b ^ 11011010b = 00011010b
-11000000b ^ 11011011b = 00011011b
-11000000b ^ 11011100b = 00011100b
-11000000b ^ 11011101b = 00011101b
-11000000b ^ 11011110b = 00011110b
-11000000b ^ 11011111b = 00011111b
-11000000b ^ 11100000b = 00100000b
-11000000b ^ 11100001b = 00100001b
-11000000b ^ 11100010b = 00100010b
-11000000b ^ 11100011b = 00100011b
-11000000b ^ 11100100b = 00100100b
-11000000b ^ 11100101b = 00100101b
-11000000b ^ 11100110b = 00100110b
-11000000b ^ 11100111b = 00100111b
-11000000b ^ 11101000b = 00101000b
-11000000b ^ 11101001b = 00101001b
-11000000b ^ 11101010b = 00101010b
-11000000b ^ 11101011b = 00101011b
-11000000b ^ 11101100b = 00101100b
-11000000b ^ 11101101b = 00101101b
-11000000b ^ 11101110b = 00101110b
-11000000b ^ 11101111b = 00101111b
-11000000b ^ 11110000b = 00110000b
-11000000b ^ 11110001b = 00110001b
-11000000b ^ 11110010b = 00110010b
-11000000b ^ 11110011b = 00110011b
-11000000b ^ 11110100b = 00110100b
-11000000b ^ 11110101b = 00110101b
-11000000b ^ 11110110b = 00110110b
-11000000b ^ 11110111b = 00110111b
-11000000b ^ 11111000b = 00111000b
-11000000b ^ 11111001b = 00111001b
-11000000b ^ 11111010b = 00111010b
-11000000b ^ 11111011b = 00111011b
-11000000b ^ 11111100b = 00111100b
-11000000b ^ 11111101b = 00111101b
-11000000b ^ 11111110b = 00111110b
-11000000b ^ 11111111b = 00111111b
-11000000b ^ 00000000b = 11000000b
-11000000b ^ 00000001b = 11000001b
-11000000b ^ 00000010b = 11000010b
-11000000b ^ 00000011b = 11000011b
-11000000b ^ 00000100b = 11000100b
-11000000b ^ 00000101b = 11000101b
-11000000b ^ 00000110b = 11000110b
-11000000b ^ 00000111b = 11000111b
-11000000b ^ 00001000b = 11001000b
-11000000b ^ 00001001b = 11001001b
-11000000b ^ 00001010b = 11001010b
-11000000b ^ 00001011b = 11001011b
-11000000b ^ 00001100b = 11001100b
-11000000b ^ 00001101b = 11001101b
-11000000b ^ 00001110b = 11001110b
-11000000b ^ 00001111b = 11001111b
-11000000b ^ 00010000b = 11010000b
-11000000b ^ 00010001b = 11010001b
-11000000b ^ 00010010b = 11010010b
-11000000b ^ 00010011b = 11010011b
-11000000b ^ 00010100b = 11010100b
-11000000b ^ 00010101b = 11010101b
-11000000b ^ 00010110b = 11010110b
-11000000b ^ 00010111b = 11010111b
-11000000b ^ 00011000b = 11011000b
-11000000b ^ 00011001b = 11011001b
-11000000b ^ 00011010b = 11011010b
-11000000b ^ 00011011b = 11011011b
-11000000b ^ 00011100b = 11011100b
-11000000b ^ 00011101b = 11011101b
-11000000b ^ 00011110b = 11011110b
-11000000b ^ 00011111b = 11011111b
-11000000b ^ 00100000b = 11100000b
-11000000b ^ 00100001b = 11100001b
-11000000b ^ 00100010b = 11100010b
-11000000b ^ 00100011b = 11100011b
-11000000b ^ 00100100b = 11100100b
-11000000b ^ 00100101b = 11100101b
-11000000b ^ 00100110b = 11100110b
-11000000b ^ 00100111b = 11100111b
-11000000b ^ 00101000b = 11101000b
-11000000b ^ 00101001b = 11101001b
-11000000b ^ 00101010b = 11101010b
-11000000b ^ 00101011b = 11101011b
-11000000b ^ 00101100b = 11101100b
-11000000b ^ 00101101b = 11101101b
-11000000b ^ 00101110b = 11101110b
-11000000b ^ 00101111b = 11101111b
-11000000b ^ 00110000b = 11110000b
-11000000b ^ 00110001b = 11110001b
-11000000b ^ 00110010b = 11110010b
-11000000b ^ 00110011b = 11110011b
-11000000b ^ 00110100b = 11110100b
-11000000b ^ 00110101b = 11110101b
-11000000b ^ 00110110b = 11110110b
-11000000b ^ 00110111b = 11110111b
-11000000b ^ 00111000b = 11111000b
-11000000b ^ 00111001b = 11111001b
-11000000b ^ 00111010b = 11111010b
-11000000b ^ 00111011b = 11111011b
-11000000b ^ 00111100b = 11111100b
-11000000b ^ 00111101b = 11111101b
-11000000b ^ 00111110b = 11111110b
-11000000b ^ 00111111b = 11111111b
-11000000b ^ 01000000b = 10000000b
-11000000b ^ 01000001b = 10000001b
-11000000b ^ 01000010b = 10000010b
-11000000b ^ 01000011b = 10000011b
-11000000b ^ 01000100b = 10000100b
-11000000b ^ 01000101b = 10000101b
-11000000b ^ 01000110b = 10000110b
-11000000b ^ 01000111b = 10000111b
-11000000b ^ 01001000b = 10001000b
-11000000b ^ 01001001b = 10001001b
-11000000b ^ 01001010b = 10001010b
-11000000b ^ 01001011b = 10001011b
-11000000b ^ 01001100b = 10001100b
-11000000b ^ 01001101b = 10001101b
-11000000b ^ 01001110b = 10001110b
-11000000b ^ 01001111b = 10001111b
-11000000b ^ 01010000b = 10010000b
-11000000b ^ 01010001b = 10010001b
-11000000b ^ 01010010b = 10010010b
-11000000b ^ 01010011b = 10010011b
-11000000b ^ 01010100b = 10010100b
-11000000b ^ 01010101b = 10010101b
-11000000b ^ 01010110b = 10010110b
-11000000b ^ 01010111b = 10010111b
-11000000b ^ 01011000b = 10011000b
-11000000b ^ 01011001b = 10011001b
-11000000b ^ 01011010b = 10011010b
-11000000b ^ 01011011b = 10011011b
-11000000b ^ 01011100b = 10011100b
-11000000b ^ 01011101b = 10011101b
-11000000b ^ 01011110b = 10011110b
-11000000b ^ 01011111b = 10011111b
-11000000b ^ 01100000b = 10100000b
-11000000b ^ 01100001b = 10100001b
-11000000b ^ 01100010b = 10100010b
-11000000b ^ 01100011b = 10100011b
-11000000b ^ 01100100b = 10100100b
-11000000b ^ 01100101b = 10100101b
-11000000b ^ 01100110b = 10100110b
-11000000b ^ 01100111b = 10100111b
-11000000b ^ 01101000b = 10101000b
-11000000b ^ 01101001b = 10101001b
-11000000b ^ 01101010b = 10101010b
-11000000b ^ 01101011b = 10101011b
-11000000b ^ 01101100b = 10101100b
-11000000b ^ 01101101b = 10101101b
-11000000b ^ 01101110b = 10101110b
-11000000b ^ 01101111b = 10101111b
-11000000b ^ 01110000b = 10110000b
-11000000b ^ 01110001b = 10110001b
-11000000b ^ 01110010b = 10110010b
-11000000b ^ 01110011b = 10110011b
-11000000b ^ 01110100b = 10110100b
-11000000b ^ 01110101b = 10110101b
-11000000b ^ 01110110b = 10110110b
-11000000b ^ 01110111b = 10110111b
-11000000b ^ 01111000b = 10111000b
-11000000b ^ 01111001b = 10111001b
-11000000b ^ 01111010b = 10111010b
-11000000b ^ 01111011b = 10111011b
-11000000b ^ 01111100b = 10111100b
-11000000b ^ 01111101b = 10111101b
-11000000b ^ 01111110b = 10111110b
-11000001b ^ 10000000b = 01000001b
-11000001b ^ 10000001b = 01000000b
-11000001b ^ 10000010b = 01000011b
-11000001b ^ 10000011b = 01000010b
-11000001b ^ 10000100b = 01000101b
-11000001b ^ 10000101b = 01000100b
-11000001b ^ 10000110b = 01000111b
-11000001b ^ 10000111b = 01000110b
-11000001b ^ 10001000b = 01001001b
-11000001b ^ 10001001b = 01001000b
-11000001b ^ 10001010b = 01001011b
-11000001b ^ 10001011b = 01001010b
-11000001b ^ 10001100b = 01001101b
-11000001b ^ 10001101b = 01001100b
-11000001b ^ 10001110b = 01001111b
-11000001b ^ 10001111b = 01001110b
-11000001b ^ 10010000b = 01010001b
-11000001b ^ 10010001b = 01010000b
-11000001b ^ 10010010b = 01010011b
-11000001b ^ 10010011b = 01010010b
-11000001b ^ 10010100b = 01010101b
-11000001b ^ 10010101b = 01010100b
-11000001b ^ 10010110b = 01010111b
-11000001b ^ 10010111b = 01010110b
-11000001b ^ 10011000b = 01011001b
-11000001b ^ 10011001b = 01011000b
-11000001b ^ 10011010b = 01011011b
-11000001b ^ 10011011b = 01011010b
-11000001b ^ 10011100b = 01011101b
-11000001b ^ 10011101b = 01011100b
-11000001b ^ 10011110b = 01011111b
-11000001b ^ 10011111b = 01011110b
-11000001b ^ 10100000b = 01100001b
-11000001b ^ 10100001b = 01100000b
-11000001b ^ 10100010b = 01100011b
-11000001b ^ 10100011b = 01100010b
-11000001b ^ 10100100b = 01100101b
-11000001b ^ 10100101b = 01100100b
-11000001b ^ 10100110b = 01100111b
-11000001b ^ 10100111b = 01100110b
-11000001b ^ 10101000b = 01101001b
-11000001b ^ 10101001b = 01101000b
-11000001b ^ 10101010b = 01101011b
-11000001b ^ 10101011b = 01101010b
-11000001b ^ 10101100b = 01101101b
-11000001b ^ 10101101b = 01101100b
-11000001b ^ 10101110b = 01101111b
-11000001b ^ 10101111b = 01101110b
-11000001b ^ 10110000b = 01110001b
-11000001b ^ 10110001b = 01110000b
-11000001b ^ 10110010b = 01110011b
-11000001b ^ 10110011b = 01110010b
-11000001b ^ 10110100b = 01110101b
-11000001b ^ 10110101b = 01110100b
-11000001b ^ 10110110b = 01110111b
-11000001b ^ 10110111b = 01110110b
-11000001b ^ 10111000b = 01111001b
-11000001b ^ 10111001b = 01111000b
-11000001b ^ 10111010b = 01111011b
-11000001b ^ 10111011b = 01111010b
-11000001b ^ 10111100b = 01111101b
-11000001b ^ 10111101b = 01111100b
-11000001b ^ 10111110b = 01111111b
-11000001b ^ 10111111b = 01111110b
-11000001b ^ 11000000b = 00000001b
-11000001b ^ 11000001b = 00000000b
-11000001b ^ 11000010b = 00000011b
-11000001b ^ 11000011b = 00000010b
-11000001b ^ 11000100b = 00000101b
-11000001b ^ 11000101b = 00000100b
-11000001b ^ 11000110b = 00000111b
-11000001b ^ 11000111b = 00000110b
-11000001b ^ 11001000b = 00001001b
-11000001b ^ 11001001b = 00001000b
-11000001b ^ 11001010b = 00001011b
-11000001b ^ 11001011b = 00001010b
-11000001b ^ 11001100b = 00001101b
-11000001b ^ 11001101b = 00001100b
-11000001b ^ 11001110b = 00001111b
-11000001b ^ 11001111b = 00001110b
-11000001b ^ 11010000b = 00010001b
-11000001b ^ 11010001b = 00010000b
-11000001b ^ 11010010b = 00010011b
-11000001b ^ 11010011b = 00010010b
-11000001b ^ 11010100b = 00010101b
-11000001b ^ 11010101b = 00010100b
-11000001b ^ 11010110b = 00010111b
-11000001b ^ 11010111b = 00010110b
-11000001b ^ 11011000b = 00011001b
-11000001b ^ 11011001b = 00011000b
-11000001b ^ 11011010b = 00011011b
-11000001b ^ 11011011b = 00011010b
-11000001b ^ 11011100b = 00011101b
-11000001b ^ 11011101b = 00011100b
-11000001b ^ 11011110b = 00011111b
-11000001b ^ 11011111b = 00011110b
-11000001b ^ 11100000b = 00100001b
-11000001b ^ 11100001b = 00100000b
-11000001b ^ 11100010b = 00100011b
-11000001b ^ 11100011b = 00100010b
-11000001b ^ 11100100b = 00100101b
-11000001b ^ 11100101b = 00100100b
-11000001b ^ 11100110b = 00100111b
-11000001b ^ 11100111b = 00100110b
-11000001b ^ 11101000b = 00101001b
-11000001b ^ 11101001b = 00101000b
-11000001b ^ 11101010b = 00101011b
-11000001b ^ 11101011b = 00101010b
-11000001b ^ 11101100b = 00101101b
-11000001b ^ 11101101b = 00101100b
-11000001b ^ 11101110b = 00101111b
-11000001b ^ 11101111b = 00101110b
-11000001b ^ 11110000b = 00110001b
-11000001b ^ 11110001b = 00110000b
-11000001b ^ 11110010b = 00110011b
-11000001b ^ 11110011b = 00110010b
-11000001b ^ 11110100b = 00110101b
-11000001b ^ 11110101b = 00110100b
-11000001b ^ 11110110b = 00110111b
-11000001b ^ 11110111b = 00110110b
-11000001b ^ 11111000b = 00111001b
-11000001b ^ 11111001b = 00111000b
-11000001b ^ 11111010b = 00111011b
-11000001b ^ 11111011b = 00111010b
-11000001b ^ 11111100b = 00111101b
-11000001b ^ 11111101b = 00111100b
-11000001b ^ 11111110b = 00111111b
-11000001b ^ 11111111b = 00111110b
-11000001b ^ 00000000b = 11000001b
-11000001b ^ 00000001b = 11000000b
-11000001b ^ 00000010b = 11000011b
-11000001b ^ 00000011b = 11000010b
-11000001b ^ 00000100b = 11000101b
-11000001b ^ 00000101b = 11000100b
-11000001b ^ 00000110b = 11000111b
-11000001b ^ 00000111b = 11000110b
-11000001b ^ 00001000b = 11001001b
-11000001b ^ 00001001b = 11001000b
-11000001b ^ 00001010b = 11001011b
-11000001b ^ 00001011b = 11001010b
-11000001b ^ 00001100b = 11001101b
-11000001b ^ 00001101b = 11001100b
-11000001b ^ 00001110b = 11001111b
-11000001b ^ 00001111b = 11001110b
-11000001b ^ 00010000b = 11010001b
-11000001b ^ 00010001b = 11010000b
-11000001b ^ 00010010b = 11010011b
-11000001b ^ 00010011b = 11010010b
-11000001b ^ 00010100b = 11010101b
-11000001b ^ 00010101b = 11010100b
-11000001b ^ 00010110b = 11010111b
-11000001b ^ 00010111b = 11010110b
-11000001b ^ 00011000b = 11011001b
-11000001b ^ 00011001b = 11011000b
-11000001b ^ 00011010b = 11011011b
-11000001b ^ 00011011b = 11011010b
-11000001b ^ 00011100b = 11011101b
-11000001b ^ 00011101b = 11011100b
-11000001b ^ 00011110b = 11011111b
-11000001b ^ 00011111b = 11011110b
-11000001b ^ 00100000b = 11100001b
-11000001b ^ 00100001b = 11100000b
-11000001b ^ 00100010b = 11100011b
-11000001b ^ 00100011b = 11100010b
-11000001b ^ 00100100b = 11100101b
-11000001b ^ 00100101b = 11100100b
-11000001b ^ 00100110b = 11100111b
-11000001b ^ 00100111b = 11100110b
-11000001b ^ 00101000b = 11101001b
-11000001b ^ 00101001b = 11101000b
-11000001b ^ 00101010b = 11101011b
-11000001b ^ 00101011b = 11101010b
-11000001b ^ 00101100b = 11101101b
-11000001b ^ 00101101b = 11101100b
-11000001b ^ 00101110b = 11101111b
-11000001b ^ 00101111b = 11101110b
-11000001b ^ 00110000b = 11110001b
-11000001b ^ 00110001b = 11110000b
-11000001b ^ 00110010b = 11110011b
-11000001b ^ 00110011b = 11110010b
-11000001b ^ 00110100b = 11110101b
-11000001b ^ 00110101b = 11110100b
-11000001b ^ 00110110b = 11110111b
-11000001b ^ 00110111b = 11110110b
-11000001b ^ 00111000b = 11111001b
-11000001b ^ 00111001b = 11111000b
-11000001b ^ 00111010b = 11111011b
-11000001b ^ 00111011b = 11111010b
-11000001b ^ 00111100b = 11111101b
-11000001b ^ 00111101b = 11111100b
-11000001b ^ 00111110b = 11111111b
-11000001b ^ 00111111b = 11111110b
-11000001b ^ 01000000b = 10000001b
-11000001b ^ 01000001b = 10000000b
-11000001b ^ 01000010b = 10000011b
-11000001b ^ 01000011b = 10000010b
-11000001b ^ 01000100b = 10000101b
-11000001b ^ 01000101b = 10000100b
-11000001b ^ 01000110b = 10000111b
-11000001b ^ 01000111b = 10000110b
-11000001b ^ 01001000b = 10001001b
-11000001b ^ 01001001b = 10001000b
-11000001b ^ 01001010b = 10001011b
-11000001b ^ 01001011b = 10001010b
-11000001b ^ 01001100b = 10001101b
-11000001b ^ 01001101b = 10001100b
-11000001b ^ 01001110b = 10001111b
-11000001b ^ 01001111b = 10001110b
-11000001b ^ 01010000b = 10010001b
-11000001b ^ 01010001b = 10010000b
-11000001b ^ 01010010b = 10010011b
-11000001b ^ 01010011b = 10010010b
-11000001b ^ 01010100b = 10010101b
-11000001b ^ 01010101b = 10010100b
-11000001b ^ 01010110b = 10010111b
-11000001b ^ 01010111b = 10010110b
-11000001b ^ 01011000b = 10011001b
-11000001b ^ 01011001b = 10011000b
-11000001b ^ 01011010b = 10011011b
-11000001b ^ 01011011b = 10011010b
-11000001b ^ 01011100b = 10011101b
-11000001b ^ 01011101b = 10011100b
-11000001b ^ 01011110b = 10011111b
-11000001b ^ 01011111b = 10011110b
-11000001b ^ 01100000b = 10100001b
-11000001b ^ 01100001b = 10100000b
-11000001b ^ 01100010b = 10100011b
-11000001b ^ 01100011b = 10100010b
-11000001b ^ 01100100b = 10100101b
-11000001b ^ 01100101b = 10100100b
-11000001b ^ 01100110b = 10100111b
-11000001b ^ 01100111b = 10100110b
-11000001b ^ 01101000b = 10101001b
-11000001b ^ 01101001b = 10101000b
-11000001b ^ 01101010b = 10101011b
-11000001b ^ 01101011b = 10101010b
-11000001b ^ 01101100b = 10101101b
-11000001b ^ 01101101b = 10101100b
-11000001b ^ 01101110b = 10101111b
-11000001b ^ 01101111b = 10101110b
-11000001b ^ 01110000b = 10110001b
-11000001b ^ 01110001b = 10110000b
-11000001b ^ 01110010b = 10110011b
-11000001b ^ 01110011b = 10110010b
-11000001b ^ 01110100b = 10110101b
-11000001b ^ 01110101b = 10110100b
-11000001b ^ 01110110b = 10110111b
-11000001b ^ 01110111b = 10110110b
-11000001b ^ 01111000b = 10111001b
-11000001b ^ 01111001b = 10111000b
-11000001b ^ 01111010b = 10111011b
-11000001b ^ 01111011b = 10111010b
-11000001b ^ 01111100b = 10111101b
-11000001b ^ 01111101b = 10111100b
-11000001b ^ 01111110b = 10111111b
-11000010b ^ 10000000b = 01000010b
-11000010b ^ 10000001b = 01000011b
-11000010b ^ 10000010b = 01000000b
-11000010b ^ 10000011b = 01000001b
-11000010b ^ 10000100b = 01000110b
-11000010b ^ 10000101b = 01000111b
-11000010b ^ 10000110b = 01000100b
-11000010b ^ 10000111b = 01000101b
-11000010b ^ 10001000b = 01001010b
-11000010b ^ 10001001b = 01001011b
-11000010b ^ 10001010b = 01001000b
-11000010b ^ 10001011b = 01001001b
-11000010b ^ 10001100b = 01001110b
-11000010b ^ 10001101b = 01001111b
-11000010b ^ 10001110b = 01001100b
-11000010b ^ 10001111b = 01001101b
-11000010b ^ 10010000b = 01010010b
-11000010b ^ 10010001b = 01010011b
-11000010b ^ 10010010b = 01010000b
-11000010b ^ 10010011b = 01010001b
-11000010b ^ 10010100b = 01010110b
-11000010b ^ 10010101b = 01010111b
-11000010b ^ 10010110b = 01010100b
-11000010b ^ 10010111b = 01010101b
-11000010b ^ 10011000b = 01011010b
-11000010b ^ 10011001b = 01011011b
-11000010b ^ 10011010b = 01011000b
-11000010b ^ 10011011b = 01011001b
-11000010b ^ 10011100b = 01011110b
-11000010b ^ 10011101b = 01011111b
-11000010b ^ 10011110b = 01011100b
-11000010b ^ 10011111b = 01011101b
-11000010b ^ 10100000b = 01100010b
-11000010b ^ 10100001b = 01100011b
-11000010b ^ 10100010b = 01100000b
-11000010b ^ 10100011b = 01100001b
-11000010b ^ 10100100b = 01100110b
-11000010b ^ 10100101b = 01100111b
-11000010b ^ 10100110b = 01100100b
-11000010b ^ 10100111b = 01100101b
-11000010b ^ 10101000b = 01101010b
-11000010b ^ 10101001b = 01101011b
-11000010b ^ 10101010b = 01101000b
-11000010b ^ 10101011b = 01101001b
-11000010b ^ 10101100b = 01101110b
-11000010b ^ 10101101b = 01101111b
-11000010b ^ 10101110b = 01101100b
-11000010b ^ 10101111b = 01101101b
-11000010b ^ 10110000b = 01110010b
-11000010b ^ 10110001b = 01110011b
-11000010b ^ 10110010b = 01110000b
-11000010b ^ 10110011b = 01110001b
-11000010b ^ 10110100b = 01110110b
-11000010b ^ 10110101b = 01110111b
-11000010b ^ 10110110b = 01110100b
-11000010b ^ 10110111b = 01110101b
-11000010b ^ 10111000b = 01111010b
-11000010b ^ 10111001b = 01111011b
-11000010b ^ 10111010b = 01111000b
-11000010b ^ 10111011b = 01111001b
-11000010b ^ 10111100b = 01111110b
-11000010b ^ 10111101b = 01111111b
-11000010b ^ 10111110b = 01111100b
-11000010b ^ 10111111b = 01111101b
-11000010b ^ 11000000b = 00000010b
-11000010b ^ 11000001b = 00000011b
-11000010b ^ 11000010b = 00000000b
-11000010b ^ 11000011b = 00000001b
-11000010b ^ 11000100b = 00000110b
-11000010b ^ 11000101b = 00000111b
-11000010b ^ 11000110b = 00000100b
-11000010b ^ 11000111b = 00000101b
-11000010b ^ 11001000b = 00001010b
-11000010b ^ 11001001b = 00001011b
-11000010b ^ 11001010b = 00001000b
-11000010b ^ 11001011b = 00001001b
-11000010b ^ 11001100b = 00001110b
-11000010b ^ 11001101b = 00001111b
-11000010b ^ 11001110b = 00001100b
-11000010b ^ 11001111b = 00001101b
-11000010b ^ 11010000b = 00010010b
-11000010b ^ 11010001b = 00010011b
-11000010b ^ 11010010b = 00010000b
-11000010b ^ 11010011b = 00010001b
-11000010b ^ 11010100b = 00010110b
-11000010b ^ 11010101b = 00010111b
-11000010b ^ 11010110b = 00010100b
-11000010b ^ 11010111b = 00010101b
-11000010b ^ 11011000b = 00011010b
-11000010b ^ 11011001b = 00011011b
-11000010b ^ 11011010b = 00011000b
-11000010b ^ 11011011b = 00011001b
-11000010b ^ 11011100b = 00011110b
-11000010b ^ 11011101b = 00011111b
-11000010b ^ 11011110b = 00011100b
-11000010b ^ 11011111b = 00011101b
-11000010b ^ 11100000b = 00100010b
-11000010b ^ 11100001b = 00100011b
-11000010b ^ 11100010b = 00100000b
-11000010b ^ 11100011b = 00100001b
-11000010b ^ 11100100b = 00100110b
-11000010b ^ 11100101b = 00100111b
-11000010b ^ 11100110b = 00100100b
-11000010b ^ 11100111b = 00100101b
-11000010b ^ 11101000b = 00101010b
-11000010b ^ 11101001b = 00101011b
-11000010b ^ 11101010b = 00101000b
-11000010b ^ 11101011b = 00101001b
-11000010b ^ 11101100b = 00101110b
-11000010b ^ 11101101b = 00101111b
-11000010b ^ 11101110b = 00101100b
-11000010b ^ 11101111b = 00101101b
-11000010b ^ 11110000b = 00110010b
-11000010b ^ 11110001b = 00110011b
-11000010b ^ 11110010b = 00110000b
-11000010b ^ 11110011b = 00110001b
-11000010b ^ 11110100b = 00110110b
-11000010b ^ 11110101b = 00110111b
-11000010b ^ 11110110b = 00110100b
-11000010b ^ 11110111b = 00110101b
-11000010b ^ 11111000b = 00111010b
-11000010b ^ 11111001b = 00111011b
-11000010b ^ 11111010b = 00111000b
-11000010b ^ 11111011b = 00111001b
-11000010b ^ 11111100b = 00111110b
-11000010b ^ 11111101b = 00111111b
-11000010b ^ 11111110b = 00111100b
-11000010b ^ 11111111b = 00111101b
-11000010b ^ 00000000b = 11000010b
-11000010b ^ 00000001b = 11000011b
-11000010b ^ 00000010b = 11000000b
-11000010b ^ 00000011b = 11000001b
-11000010b ^ 00000100b = 11000110b
-11000010b ^ 00000101b = 11000111b
-11000010b ^ 00000110b = 11000100b
-11000010b ^ 00000111b = 11000101b
-11000010b ^ 00001000b = 11001010b
-11000010b ^ 00001001b = 11001011b
-11000010b ^ 00001010b = 11001000b
-11000010b ^ 00001011b = 11001001b
-11000010b ^ 00001100b = 11001110b
-11000010b ^ 00001101b = 11001111b
-11000010b ^ 00001110b = 11001100b
-11000010b ^ 00001111b = 11001101b
-11000010b ^ 00010000b = 11010010b
-11000010b ^ 00010001b = 11010011b
-11000010b ^ 00010010b = 11010000b
-11000010b ^ 00010011b = 11010001b
-11000010b ^ 00010100b = 11010110b
-11000010b ^ 00010101b = 11010111b
-11000010b ^ 00010110b = 11010100b
-11000010b ^ 00010111b = 11010101b
-11000010b ^ 00011000b = 11011010b
-11000010b ^ 00011001b = 11011011b
-11000010b ^ 00011010b = 11011000b
-11000010b ^ 00011011b = 11011001b
-11000010b ^ 00011100b = 11011110b
-11000010b ^ 00011101b = 11011111b
-11000010b ^ 00011110b = 11011100b
-11000010b ^ 00011111b = 11011101b
-11000010b ^ 00100000b = 11100010b
-11000010b ^ 00100001b = 11100011b
-11000010b ^ 00100010b = 11100000b
-11000010b ^ 00100011b = 11100001b
-11000010b ^ 00100100b = 11100110b
-11000010b ^ 00100101b = 11100111b
-11000010b ^ 00100110b = 11100100b
-11000010b ^ 00100111b = 11100101b
-11000010b ^ 00101000b = 11101010b
-11000010b ^ 00101001b = 11101011b
-11000010b ^ 00101010b = 11101000b
-11000010b ^ 00101011b = 11101001b
-11000010b ^ 00101100b = 11101110b
-11000010b ^ 00101101b = 11101111b
-11000010b ^ 00101110b = 11101100b
-11000010b ^ 00101111b = 11101101b
-11000010b ^ 00110000b = 11110010b
-11000010b ^ 00110001b = 11110011b
-11000010b ^ 00110010b = 11110000b
-11000010b ^ 00110011b = 11110001b
-11000010b ^ 00110100b = 11110110b
-11000010b ^ 00110101b = 11110111b
-11000010b ^ 00110110b = 11110100b
-11000010b ^ 00110111b = 11110101b
-11000010b ^ 00111000b = 11111010b
-11000010b ^ 00111001b = 11111011b
-11000010b ^ 00111010b = 11111000b
-11000010b ^ 00111011b = 11111001b
-11000010b ^ 00111100b = 11111110b
-11000010b ^ 00111101b = 11111111b
-11000010b ^ 00111110b = 11111100b
-11000010b ^ 00111111b = 11111101b
-11000010b ^ 01000000b = 10000010b
-11000010b ^ 01000001b = 10000011b
-11000010b ^ 01000010b = 10000000b
-11000010b ^ 01000011b = 10000001b
-11000010b ^ 01000100b = 10000110b
-11000010b ^ 01000101b = 10000111b
-11000010b ^ 01000110b = 10000100b
-11000010b ^ 01000111b = 10000101b
-11000010b ^ 01001000b = 10001010b
-11000010b ^ 01001001b = 10001011b
-11000010b ^ 01001010b = 10001000b
-11000010b ^ 01001011b = 10001001b
-11000010b ^ 01001100b = 10001110b
-11000010b ^ 01001101b = 10001111b
-11000010b ^ 01001110b = 10001100b
-11000010b ^ 01001111b = 10001101b
-11000010b ^ 01010000b = 10010010b
-11000010b ^ 01010001b = 10010011b
-11000010b ^ 01010010b = 10010000b
-11000010b ^ 01010011b = 10010001b
-11000010b ^ 01010100b = 10010110b
-11000010b ^ 01010101b = 10010111b
-11000010b ^ 01010110b = 10010100b
-11000010b ^ 01010111b = 10010101b
-11000010b ^ 01011000b = 10011010b
-11000010b ^ 01011001b = 10011011b
-11000010b ^ 01011010b = 10011000b
-11000010b ^ 01011011b = 10011001b
-11000010b ^ 01011100b = 10011110b
-11000010b ^ 01011101b = 10011111b
-11000010b ^ 01011110b = 10011100b
-11000010b ^ 01011111b = 10011101b
-11000010b ^ 01100000b = 10100010b
-11000010b ^ 01100001b = 10100011b
-11000010b ^ 01100010b = 10100000b
-11000010b ^ 01100011b = 10100001b
-11000010b ^ 01100100b = 10100110b
-11000010b ^ 01100101b = 10100111b
-11000010b ^ 01100110b = 10100100b
-11000010b ^ 01100111b = 10100101b
-11000010b ^ 01101000b = 10101010b
-11000010b ^ 01101001b = 10101011b
-11000010b ^ 01101010b = 10101000b
-11000010b ^ 01101011b = 10101001b
-11000010b ^ 01101100b = 10101110b
-11000010b ^ 01101101b = 10101111b
-11000010b ^ 01101110b = 10101100b
-11000010b ^ 01101111b = 10101101b
-11000010b ^ 01110000b = 10110010b
-11000010b ^ 01110001b = 10110011b
-11000010b ^ 01110010b = 10110000b
-11000010b ^ 01110011b = 10110001b
-11000010b ^ 01110100b = 10110110b
-11000010b ^ 01110101b = 10110111b
-11000010b ^ 01110110b = 10110100b
-11000010b ^ 01110111b = 10110101b
-11000010b ^ 01111000b = 10111010b
-11000010b ^ 01111001b = 10111011b
-11000010b ^ 01111010b = 10111000b
-11000010b ^ 01111011b = 10111001b
-11000010b ^ 01111100b = 10111110b
-11000010b ^ 01111101b = 10111111b
-11000010b ^ 01111110b = 10111100b
-11000011b ^ 10000000b = 01000011b
-11000011b ^ 10000001b = 01000010b
-11000011b ^ 10000010b = 01000001b
-11000011b ^ 10000011b = 01000000b
-11000011b ^ 10000100b = 01000111b
-11000011b ^ 10000101b = 01000110b
-11000011b ^ 10000110b = 01000101b
-11000011b ^ 10000111b = 01000100b
-11000011b ^ 10001000b = 01001011b
-11000011b ^ 10001001b = 01001010b
-11000011b ^ 10001010b = 01001001b
-11000011b ^ 10001011b = 01001000b
-11000011b ^ 10001100b = 01001111b
-11000011b ^ 10001101b = 01001110b
-11000011b ^ 10001110b = 01001101b
-11000011b ^ 10001111b = 01001100b
-11000011b ^ 10010000b = 01010011b
-11000011b ^ 10010001b = 01010010b
-11000011b ^ 10010010b = 01010001b
-11000011b ^ 10010011b = 01010000b
-11000011b ^ 10010100b = 01010111b
-11000011b ^ 10010101b = 01010110b
-11000011b ^ 10010110b = 01010101b
-11000011b ^ 10010111b = 01010100b
-11000011b ^ 10011000b = 01011011b
-11000011b ^ 10011001b = 01011010b
-11000011b ^ 10011010b = 01011001b
-11000011b ^ 10011011b = 01011000b
-11000011b ^ 10011100b = 01011111b
-11000011b ^ 10011101b = 01011110b
-11000011b ^ 10011110b = 01011101b
-11000011b ^ 10011111b = 01011100b
-11000011b ^ 10100000b = 01100011b
-11000011b ^ 10100001b = 01100010b
-11000011b ^ 10100010b = 01100001b
-11000011b ^ 10100011b = 01100000b
-11000011b ^ 10100100b = 01100111b
-11000011b ^ 10100101b = 01100110b
-11000011b ^ 10100110b = 01100101b
-11000011b ^ 10100111b = 01100100b
-11000011b ^ 10101000b = 01101011b
-11000011b ^ 10101001b = 01101010b
-11000011b ^ 10101010b = 01101001b
-11000011b ^ 10101011b = 01101000b
-11000011b ^ 10101100b = 01101111b
-11000011b ^ 10101101b = 01101110b
-11000011b ^ 10101110b = 01101101b
-11000011b ^ 10101111b = 01101100b
-11000011b ^ 10110000b = 01110011b
-11000011b ^ 10110001b = 01110010b
-11000011b ^ 10110010b = 01110001b
-11000011b ^ 10110011b = 01110000b
-11000011b ^ 10110100b = 01110111b
-11000011b ^ 10110101b = 01110110b
-11000011b ^ 10110110b = 01110101b
-11000011b ^ 10110111b = 01110100b
-11000011b ^ 10111000b = 01111011b
-11000011b ^ 10111001b = 01111010b
-11000011b ^ 10111010b = 01111001b
-11000011b ^ 10111011b = 01111000b
-11000011b ^ 10111100b = 01111111b
-11000011b ^ 10111101b = 01111110b
-11000011b ^ 10111110b = 01111101b
-11000011b ^ 10111111b = 01111100b
-11000011b ^ 11000000b = 00000011b
-11000011b ^ 11000001b = 00000010b
-11000011b ^ 11000010b = 00000001b
-11000011b ^ 11000011b = 00000000b
-11000011b ^ 11000100b = 00000111b
-11000011b ^ 11000101b = 00000110b
-11000011b ^ 11000110b = 00000101b
-11000011b ^ 11000111b = 00000100b
-11000011b ^ 11001000b = 00001011b
-11000011b ^ 11001001b = 00001010b
-11000011b ^ 11001010b = 00001001b
-11000011b ^ 11001011b = 00001000b
-11000011b ^ 11001100b = 00001111b
-11000011b ^ 11001101b = 00001110b
-11000011b ^ 11001110b = 00001101b
-11000011b ^ 11001111b = 00001100b
-11000011b ^ 11010000b = 00010011b
-11000011b ^ 11010001b = 00010010b
-11000011b ^ 11010010b = 00010001b
-11000011b ^ 11010011b = 00010000b
-11000011b ^ 11010100b = 00010111b
-11000011b ^ 11010101b = 00010110b
-11000011b ^ 11010110b = 00010101b
-11000011b ^ 11010111b = 00010100b
-11000011b ^ 11011000b = 00011011b
-11000011b ^ 11011001b = 00011010b
-11000011b ^ 11011010b = 00011001b
-11000011b ^ 11011011b = 00011000b
-11000011b ^ 11011100b = 00011111b
-11000011b ^ 11011101b = 00011110b
-11000011b ^ 11011110b = 00011101b
-11000011b ^ 11011111b = 00011100b
-11000011b ^ 11100000b = 00100011b
-11000011b ^ 11100001b = 00100010b
-11000011b ^ 11100010b = 00100001b
-11000011b ^ 11100011b = 00100000b
-11000011b ^ 11100100b = 00100111b
-11000011b ^ 11100101b = 00100110b
-11000011b ^ 11100110b = 00100101b
-11000011b ^ 11100111b = 00100100b
-11000011b ^ 11101000b = 00101011b
-11000011b ^ 11101001b = 00101010b
-11000011b ^ 11101010b = 00101001b
-11000011b ^ 11101011b = 00101000b
-11000011b ^ 11101100b = 00101111b
-11000011b ^ 11101101b = 00101110b
-11000011b ^ 11101110b = 00101101b
-11000011b ^ 11101111b = 00101100b
-11000011b ^ 11110000b = 00110011b
-11000011b ^ 11110001b = 00110010b
-11000011b ^ 11110010b = 00110001b
-11000011b ^ 11110011b = 00110000b
-11000011b ^ 11110100b = 00110111b
-11000011b ^ 11110101b = 00110110b
-11000011b ^ 11110110b = 00110101b
-11000011b ^ 11110111b = 00110100b
-11000011b ^ 11111000b = 00111011b
-11000011b ^ 11111001b = 00111010b
-11000011b ^ 11111010b = 00111001b
-11000011b ^ 11111011b = 00111000b
-11000011b ^ 11111100b = 00111111b
-11000011b ^ 11111101b = 00111110b
-11000011b ^ 11111110b = 00111101b
-11000011b ^ 11111111b = 00111100b
-11000011b ^ 00000000b = 11000011b
-11000011b ^ 00000001b = 11000010b
-11000011b ^ 00000010b = 11000001b
-11000011b ^ 00000011b = 11000000b
-11000011b ^ 00000100b = 11000111b
-11000011b ^ 00000101b = 11000110b
-11000011b ^ 00000110b = 11000101b
-11000011b ^ 00000111b = 11000100b
-11000011b ^ 00001000b = 11001011b
-11000011b ^ 00001001b = 11001010b
-11000011b ^ 00001010b = 11001001b
-11000011b ^ 00001011b = 11001000b
-11000011b ^ 00001100b = 11001111b
-11000011b ^ 00001101b = 11001110b
-11000011b ^ 00001110b = 11001101b
-11000011b ^ 00001111b = 11001100b
-11000011b ^ 00010000b = 11010011b
-11000011b ^ 00010001b = 11010010b
-11000011b ^ 00010010b = 11010001b
-11000011b ^ 00010011b = 11010000b
-11000011b ^ 00010100b = 11010111b
-11000011b ^ 00010101b = 11010110b
-11000011b ^ 00010110b = 11010101b
-11000011b ^ 00010111b = 11010100b
-11000011b ^ 00011000b = 11011011b
-11000011b ^ 00011001b = 11011010b
-11000011b ^ 00011010b = 11011001b
-11000011b ^ 00011011b = 11011000b
-11000011b ^ 00011100b = 11011111b
-11000011b ^ 00011101b = 11011110b
-11000011b ^ 00011110b = 11011101b
-11000011b ^ 00011111b = 11011100b
-11000011b ^ 00100000b = 11100011b
-11000011b ^ 00100001b = 11100010b
-11000011b ^ 00100010b = 11100001b
-11000011b ^ 00100011b = 11100000b
-11000011b ^ 00100100b = 11100111b
-11000011b ^ 00100101b = 11100110b
-11000011b ^ 00100110b = 11100101b
-11000011b ^ 00100111b = 11100100b
-11000011b ^ 00101000b = 11101011b
-11000011b ^ 00101001b = 11101010b
-11000011b ^ 00101010b = 11101001b
-11000011b ^ 00101011b = 11101000b
-11000011b ^ 00101100b = 11101111b
-11000011b ^ 00101101b = 11101110b
-11000011b ^ 00101110b = 11101101b
-11000011b ^ 00101111b = 11101100b
-11000011b ^ 00110000b = 11110011b
-11000011b ^ 00110001b = 11110010b
-11000011b ^ 00110010b = 11110001b
-11000011b ^ 00110011b = 11110000b
-11000011b ^ 00110100b = 11110111b
-11000011b ^ 00110101b = 11110110b
-11000011b ^ 00110110b = 11110101b
-11000011b ^ 00110111b = 11110100b
-11000011b ^ 00111000b = 11111011b
-11000011b ^ 00111001b = 11111010b
-11000011b ^ 00111010b = 11111001b
-11000011b ^ 00111011b = 11111000b
-11000011b ^ 00111100b = 11111111b
-11000011b ^ 00111101b = 11111110b
-11000011b ^ 00111110b = 11111101b
-11000011b ^ 00111111b = 11111100b
-11000011b ^ 01000000b = 10000011b
-11000011b ^ 01000001b = 10000010b
-11000011b ^ 01000010b = 10000001b
-11000011b ^ 01000011b = 10000000b
-11000011b ^ 01000100b = 10000111b
-11000011b ^ 01000101b = 10000110b
-11000011b ^ 01000110b = 10000101b
-11000011b ^ 01000111b = 10000100b
-11000011b ^ 01001000b = 10001011b
-11000011b ^ 01001001b = 10001010b
-11000011b ^ 01001010b = 10001001b
-11000011b ^ 01001011b = 10001000b
-11000011b ^ 01001100b = 10001111b
-11000011b ^ 01001101b = 10001110b
-11000011b ^ 01001110b = 10001101b
-11000011b ^ 01001111b = 10001100b
-11000011b ^ 01010000b = 10010011b
-11000011b ^ 01010001b = 10010010b
-11000011b ^ 01010010b = 10010001b
-11000011b ^ 01010011b = 10010000b
-11000011b ^ 01010100b = 10010111b
-11000011b ^ 01010101b = 10010110b
-11000011b ^ 01010110b = 10010101b
-11000011b ^ 01010111b = 10010100b
-11000011b ^ 01011000b = 10011011b
-11000011b ^ 01011001b = 10011010b
-11000011b ^ 01011010b = 10011001b
-11000011b ^ 01011011b = 10011000b
-11000011b ^ 01011100b = 10011111b
-11000011b ^ 01011101b = 10011110b
-11000011b ^ 01011110b = 10011101b
-11000011b ^ 01011111b = 10011100b
-11000011b ^ 01100000b = 10100011b
-11000011b ^ 01100001b = 10100010b
-11000011b ^ 01100010b = 10100001b
-11000011b ^ 01100011b = 10100000b
-11000011b ^ 01100100b = 10100111b
-11000011b ^ 01100101b = 10100110b
-11000011b ^ 01100110b = 10100101b
-11000011b ^ 01100111b = 10100100b
-11000011b ^ 01101000b = 10101011b
-11000011b ^ 01101001b = 10101010b
-11000011b ^ 01101010b = 10101001b
-11000011b ^ 01101011b = 10101000b
-11000011b ^ 01101100b = 10101111b
-11000011b ^ 01101101b = 10101110b
-11000011b ^ 01101110b = 10101101b
-11000011b ^ 01101111b = 10101100b
-11000011b ^ 01110000b = 10110011b
-11000011b ^ 01110001b = 10110010b
-11000011b ^ 01110010b = 10110001b
-11000011b ^ 01110011b = 10110000b
-11000011b ^ 01110100b = 10110111b
-11000011b ^ 01110101b = 10110110b
-11000011b ^ 01110110b = 10110101b
-11000011b ^ 01110111b = 10110100b
-11000011b ^ 01111000b = 10111011b
-11000011b ^ 01111001b = 10111010b
-11000011b ^ 01111010b = 10111001b
-11000011b ^ 01111011b = 10111000b
-11000011b ^ 01111100b = 10111111b
-11000011b ^ 01111101b = 10111110b
-11000011b ^ 01111110b = 10111101b
-11000100b ^ 10000000b = 01000100b
-11000100b ^ 10000001b = 01000101b
-11000100b ^ 10000010b = 01000110b
-11000100b ^ 10000011b = 01000111b
-11000100b ^ 10000100b = 01000000b
-11000100b ^ 10000101b = 01000001b
-11000100b ^ 10000110b = 01000010b
-11000100b ^ 10000111b = 01000011b
-11000100b ^ 10001000b = 01001100b
-11000100b ^ 10001001b = 01001101b
-11000100b ^ 10001010b = 01001110b
-11000100b ^ 10001011b = 01001111b
-11000100b ^ 10001100b = 01001000b
-11000100b ^ 10001101b = 01001001b
-11000100b ^ 10001110b = 01001010b
-11000100b ^ 10001111b = 01001011b
-11000100b ^ 10010000b = 01010100b
-11000100b ^ 10010001b = 01010101b
-11000100b ^ 10010010b = 01010110b
-11000100b ^ 10010011b = 01010111b
-11000100b ^ 10010100b = 01010000b
-11000100b ^ 10010101b = 01010001b
-11000100b ^ 10010110b = 01010010b
-11000100b ^ 10010111b = 01010011b
-11000100b ^ 10011000b = 01011100b
-11000100b ^ 10011001b = 01011101b
-11000100b ^ 10011010b = 01011110b
-11000100b ^ 10011011b = 01011111b
-11000100b ^ 10011100b = 01011000b
-11000100b ^ 10011101b = 01011001b
-11000100b ^ 10011110b = 01011010b
-11000100b ^ 10011111b = 01011011b
-11000100b ^ 10100000b = 01100100b
-11000100b ^ 10100001b = 01100101b
-11000100b ^ 10100010b = 01100110b
-11000100b ^ 10100011b = 01100111b
-11000100b ^ 10100100b = 01100000b
-11000100b ^ 10100101b = 01100001b
-11000100b ^ 10100110b = 01100010b
-11000100b ^ 10100111b = 01100011b
-11000100b ^ 10101000b = 01101100b
-11000100b ^ 10101001b = 01101101b
-11000100b ^ 10101010b = 01101110b
-11000100b ^ 10101011b = 01101111b
-11000100b ^ 10101100b = 01101000b
-11000100b ^ 10101101b = 01101001b
-11000100b ^ 10101110b = 01101010b
-11000100b ^ 10101111b = 01101011b
-11000100b ^ 10110000b = 01110100b
-11000100b ^ 10110001b = 01110101b
-11000100b ^ 10110010b = 01110110b
-11000100b ^ 10110011b = 01110111b
-11000100b ^ 10110100b = 01110000b
-11000100b ^ 10110101b = 01110001b
-11000100b ^ 10110110b = 01110010b
-11000100b ^ 10110111b = 01110011b
-11000100b ^ 10111000b = 01111100b
-11000100b ^ 10111001b = 01111101b
-11000100b ^ 10111010b = 01111110b
-11000100b ^ 10111011b = 01111111b
-11000100b ^ 10111100b = 01111000b
-11000100b ^ 10111101b = 01111001b
-11000100b ^ 10111110b = 01111010b
-11000100b ^ 10111111b = 01111011b
-11000100b ^ 11000000b = 00000100b
-11000100b ^ 11000001b = 00000101b
-11000100b ^ 11000010b = 00000110b
-11000100b ^ 11000011b = 00000111b
-11000100b ^ 11000100b = 00000000b
-11000100b ^ 11000101b = 00000001b
-11000100b ^ 11000110b = 00000010b
-11000100b ^ 11000111b = 00000011b
-11000100b ^ 11001000b = 00001100b
-11000100b ^ 11001001b = 00001101b
-11000100b ^ 11001010b = 00001110b
-11000100b ^ 11001011b = 00001111b
-11000100b ^ 11001100b = 00001000b
-11000100b ^ 11001101b = 00001001b
-11000100b ^ 11001110b = 00001010b
-11000100b ^ 11001111b = 00001011b
-11000100b ^ 11010000b = 00010100b
-11000100b ^ 11010001b = 00010101b
-11000100b ^ 11010010b = 00010110b
-11000100b ^ 11010011b = 00010111b
-11000100b ^ 11010100b = 00010000b
-11000100b ^ 11010101b = 00010001b
-11000100b ^ 11010110b = 00010010b
-11000100b ^ 11010111b = 00010011b
-11000100b ^ 11011000b = 00011100b
-11000100b ^ 11011001b = 00011101b
-11000100b ^ 11011010b = 00011110b
-11000100b ^ 11011011b = 00011111b
-11000100b ^ 11011100b = 00011000b
-11000100b ^ 11011101b = 00011001b
-11000100b ^ 11011110b = 00011010b
-11000100b ^ 11011111b = 00011011b
-11000100b ^ 11100000b = 00100100b
-11000100b ^ 11100001b = 00100101b
-11000100b ^ 11100010b = 00100110b
-11000100b ^ 11100011b = 00100111b
-11000100b ^ 11100100b = 00100000b
-11000100b ^ 11100101b = 00100001b
-11000100b ^ 11100110b = 00100010b
-11000100b ^ 11100111b = 00100011b
-11000100b ^ 11101000b = 00101100b
-11000100b ^ 11101001b = 00101101b
-11000100b ^ 11101010b = 00101110b
-11000100b ^ 11101011b = 00101111b
-11000100b ^ 11101100b = 00101000b
-11000100b ^ 11101101b = 00101001b
-11000100b ^ 11101110b = 00101010b
-11000100b ^ 11101111b = 00101011b
-11000100b ^ 11110000b = 00110100b
-11000100b ^ 11110001b = 00110101b
-11000100b ^ 11110010b = 00110110b
-11000100b ^ 11110011b = 00110111b
-11000100b ^ 11110100b = 00110000b
-11000100b ^ 11110101b = 00110001b
-11000100b ^ 11110110b = 00110010b
-11000100b ^ 11110111b = 00110011b
-11000100b ^ 11111000b = 00111100b
-11000100b ^ 11111001b = 00111101b
-11000100b ^ 11111010b = 00111110b
-11000100b ^ 11111011b = 00111111b
-11000100b ^ 11111100b = 00111000b
-11000100b ^ 11111101b = 00111001b
-11000100b ^ 11111110b = 00111010b
-11000100b ^ 11111111b = 00111011b
-11000100b ^ 00000000b = 11000100b
-11000100b ^ 00000001b = 11000101b
-11000100b ^ 00000010b = 11000110b
-11000100b ^ 00000011b = 11000111b
-11000100b ^ 00000100b = 11000000b
-11000100b ^ 00000101b = 11000001b
-11000100b ^ 00000110b = 11000010b
-11000100b ^ 00000111b = 11000011b
-11000100b ^ 00001000b = 11001100b
-11000100b ^ 00001001b = 11001101b
-11000100b ^ 00001010b = 11001110b
-11000100b ^ 00001011b = 11001111b
-11000100b ^ 00001100b = 11001000b
-11000100b ^ 00001101b = 11001001b
-11000100b ^ 00001110b = 11001010b
-11000100b ^ 00001111b = 11001011b
-11000100b ^ 00010000b = 11010100b
-11000100b ^ 00010001b = 11010101b
-11000100b ^ 00010010b = 11010110b
-11000100b ^ 00010011b = 11010111b
-11000100b ^ 00010100b = 11010000b
-11000100b ^ 00010101b = 11010001b
-11000100b ^ 00010110b = 11010010b
-11000100b ^ 00010111b = 11010011b
-11000100b ^ 00011000b = 11011100b
-11000100b ^ 00011001b = 11011101b
-11000100b ^ 00011010b = 11011110b
-11000100b ^ 00011011b = 11011111b
-11000100b ^ 00011100b = 11011000b
-11000100b ^ 00011101b = 11011001b
-11000100b ^ 00011110b = 11011010b
-11000100b ^ 00011111b = 11011011b
-11000100b ^ 00100000b = 11100100b
-11000100b ^ 00100001b = 11100101b
-11000100b ^ 00100010b = 11100110b
-11000100b ^ 00100011b = 11100111b
-11000100b ^ 00100100b = 11100000b
-11000100b ^ 00100101b = 11100001b
-11000100b ^ 00100110b = 11100010b
-11000100b ^ 00100111b = 11100011b
-11000100b ^ 00101000b = 11101100b
-11000100b ^ 00101001b = 11101101b
-11000100b ^ 00101010b = 11101110b
-11000100b ^ 00101011b = 11101111b
-11000100b ^ 00101100b = 11101000b
-11000100b ^ 00101101b = 11101001b
-11000100b ^ 00101110b = 11101010b
-11000100b ^ 00101111b = 11101011b
-11000100b ^ 00110000b = 11110100b
-11000100b ^ 00110001b = 11110101b
-11000100b ^ 00110010b = 11110110b
-11000100b ^ 00110011b = 11110111b
-11000100b ^ 00110100b = 11110000b
-11000100b ^ 00110101b = 11110001b
-11000100b ^ 00110110b = 11110010b
-11000100b ^ 00110111b = 11110011b
-11000100b ^ 00111000b = 11111100b
-11000100b ^ 00111001b = 11111101b
-11000100b ^ 00111010b = 11111110b
-11000100b ^ 00111011b = 11111111b
-11000100b ^ 00111100b = 11111000b
-11000100b ^ 00111101b = 11111001b
-11000100b ^ 00111110b = 11111010b
-11000100b ^ 00111111b = 11111011b
-11000100b ^ 01000000b = 10000100b
-11000100b ^ 01000001b = 10000101b
-11000100b ^ 01000010b = 10000110b
-11000100b ^ 01000011b = 10000111b
-11000100b ^ 01000100b = 10000000b
-11000100b ^ 01000101b = 10000001b
-11000100b ^ 01000110b = 10000010b
-11000100b ^ 01000111b = 10000011b
-11000100b ^ 01001000b = 10001100b
-11000100b ^ 01001001b = 10001101b
-11000100b ^ 01001010b = 10001110b
-11000100b ^ 01001011b = 10001111b
-11000100b ^ 01001100b = 10001000b
-11000100b ^ 01001101b = 10001001b
-11000100b ^ 01001110b = 10001010b
-11000100b ^ 01001111b = 10001011b
-11000100b ^ 01010000b = 10010100b
-11000100b ^ 01010001b = 10010101b
-11000100b ^ 01010010b = 10010110b
-11000100b ^ 01010011b = 10010111b
-11000100b ^ 01010100b = 10010000b
-11000100b ^ 01010101b = 10010001b
-11000100b ^ 01010110b = 10010010b
-11000100b ^ 01010111b = 10010011b
-11000100b ^ 01011000b = 10011100b
-11000100b ^ 01011001b = 10011101b
-11000100b ^ 01011010b = 10011110b
-11000100b ^ 01011011b = 10011111b
-11000100b ^ 01011100b = 10011000b
-11000100b ^ 01011101b = 10011001b
-11000100b ^ 01011110b = 10011010b
-11000100b ^ 01011111b = 10011011b
-11000100b ^ 01100000b = 10100100b
-11000100b ^ 01100001b = 10100101b
-11000100b ^ 01100010b = 10100110b
-11000100b ^ 01100011b = 10100111b
-11000100b ^ 01100100b = 10100000b
-11000100b ^ 01100101b = 10100001b
-11000100b ^ 01100110b = 10100010b
-11000100b ^ 01100111b = 10100011b
-11000100b ^ 01101000b = 10101100b
-11000100b ^ 01101001b = 10101101b
-11000100b ^ 01101010b = 10101110b
-11000100b ^ 01101011b = 10101111b
-11000100b ^ 01101100b = 10101000b
-11000100b ^ 01101101b = 10101001b
-11000100b ^ 01101110b = 10101010b
-11000100b ^ 01101111b = 10101011b
-11000100b ^ 01110000b = 10110100b
-11000100b ^ 01110001b = 10110101b
-11000100b ^ 01110010b = 10110110b
-11000100b ^ 01110011b = 10110111b
-11000100b ^ 01110100b = 10110000b
-11000100b ^ 01110101b = 10110001b
-11000100b ^ 01110110b = 10110010b
-11000100b ^ 01110111b = 10110011b
-11000100b ^ 01111000b = 10111100b
-11000100b ^ 01111001b = 10111101b
-11000100b ^ 01111010b = 10111110b
-11000100b ^ 01111011b = 10111111b
-11000100b ^ 01111100b = 10111000b
-11000100b ^ 01111101b = 10111001b
-11000100b ^ 01111110b = 10111010b
-11000101b ^ 10000000b = 01000101b
-11000101b ^ 10000001b = 01000100b
-11000101b ^ 10000010b = 01000111b
-11000101b ^ 10000011b = 01000110b
-11000101b ^ 10000100b = 01000001b
-11000101b ^ 10000101b = 01000000b
-11000101b ^ 10000110b = 01000011b
-11000101b ^ 10000111b = 01000010b
-11000101b ^ 10001000b = 01001101b
-11000101b ^ 10001001b = 01001100b
-11000101b ^ 10001010b = 01001111b
-11000101b ^ 10001011b = 01001110b
-11000101b ^ 10001100b = 01001001b
-11000101b ^ 10001101b = 01001000b
-11000101b ^ 10001110b = 01001011b
-11000101b ^ 10001111b = 01001010b
-11000101b ^ 10010000b = 01010101b
-11000101b ^ 10010001b = 01010100b
-11000101b ^ 10010010b = 01010111b
-11000101b ^ 10010011b = 01010110b
-11000101b ^ 10010100b = 01010001b
-11000101b ^ 10010101b = 01010000b
-11000101b ^ 10010110b = 01010011b
-11000101b ^ 10010111b = 01010010b
-11000101b ^ 10011000b = 01011101b
-11000101b ^ 10011001b = 01011100b
-11000101b ^ 10011010b = 01011111b
-11000101b ^ 10011011b = 01011110b
-11000101b ^ 10011100b = 01011001b
-11000101b ^ 10011101b = 01011000b
-11000101b ^ 10011110b = 01011011b
-11000101b ^ 10011111b = 01011010b
-11000101b ^ 10100000b = 01100101b
-11000101b ^ 10100001b = 01100100b
-11000101b ^ 10100010b = 01100111b
-11000101b ^ 10100011b = 01100110b
-11000101b ^ 10100100b = 01100001b
-11000101b ^ 10100101b = 01100000b
-11000101b ^ 10100110b = 01100011b
-11000101b ^ 10100111b = 01100010b
-11000101b ^ 10101000b = 01101101b
-11000101b ^ 10101001b = 01101100b
-11000101b ^ 10101010b = 01101111b
-11000101b ^ 10101011b = 01101110b
-11000101b ^ 10101100b = 01101001b
-11000101b ^ 10101101b = 01101000b
-11000101b ^ 10101110b = 01101011b
-11000101b ^ 10101111b = 01101010b
-11000101b ^ 10110000b = 01110101b
-11000101b ^ 10110001b = 01110100b
-11000101b ^ 10110010b = 01110111b
-11000101b ^ 10110011b = 01110110b
-11000101b ^ 10110100b = 01110001b
-11000101b ^ 10110101b = 01110000b
-11000101b ^ 10110110b = 01110011b
-11000101b ^ 10110111b = 01110010b
-11000101b ^ 10111000b = 01111101b
-11000101b ^ 10111001b = 01111100b
-11000101b ^ 10111010b = 01111111b
-11000101b ^ 10111011b = 01111110b
-11000101b ^ 10111100b = 01111001b
-11000101b ^ 10111101b = 01111000b
-11000101b ^ 10111110b = 01111011b
-11000101b ^ 10111111b = 01111010b
-11000101b ^ 11000000b = 00000101b
-11000101b ^ 11000001b = 00000100b
-11000101b ^ 11000010b = 00000111b
-11000101b ^ 11000011b = 00000110b
-11000101b ^ 11000100b = 00000001b
-11000101b ^ 11000101b = 00000000b
-11000101b ^ 11000110b = 00000011b
-11000101b ^ 11000111b = 00000010b
-11000101b ^ 11001000b = 00001101b
-11000101b ^ 11001001b = 00001100b
-11000101b ^ 11001010b = 00001111b
-11000101b ^ 11001011b = 00001110b
-11000101b ^ 11001100b = 00001001b
-11000101b ^ 11001101b = 00001000b
-11000101b ^ 11001110b = 00001011b
-11000101b ^ 11001111b = 00001010b
-11000101b ^ 11010000b = 00010101b
-11000101b ^ 11010001b = 00010100b
-11000101b ^ 11010010b = 00010111b
-11000101b ^ 11010011b = 00010110b
-11000101b ^ 11010100b = 00010001b
-11000101b ^ 11010101b = 00010000b
-11000101b ^ 11010110b = 00010011b
-11000101b ^ 11010111b = 00010010b
-11000101b ^ 11011000b = 00011101b
-11000101b ^ 11011001b = 00011100b
-11000101b ^ 11011010b = 00011111b
-11000101b ^ 11011011b = 00011110b
-11000101b ^ 11011100b = 00011001b
-11000101b ^ 11011101b = 00011000b
-11000101b ^ 11011110b = 00011011b
-11000101b ^ 11011111b = 00011010b
-11000101b ^ 11100000b = 00100101b
-11000101b ^ 11100001b = 00100100b
-11000101b ^ 11100010b = 00100111b
-11000101b ^ 11100011b = 00100110b
-11000101b ^ 11100100b = 00100001b
-11000101b ^ 11100101b = 00100000b
-11000101b ^ 11100110b = 00100011b
-11000101b ^ 11100111b = 00100010b
-11000101b ^ 11101000b = 00101101b
-11000101b ^ 11101001b = 00101100b
-11000101b ^ 11101010b = 00101111b
-11000101b ^ 11101011b = 00101110b
-11000101b ^ 11101100b = 00101001b
-11000101b ^ 11101101b = 00101000b
-11000101b ^ 11101110b = 00101011b
-11000101b ^ 11101111b = 00101010b
-11000101b ^ 11110000b = 00110101b
-11000101b ^ 11110001b = 00110100b
-11000101b ^ 11110010b = 00110111b
-11000101b ^ 11110011b = 00110110b
-11000101b ^ 11110100b = 00110001b
-11000101b ^ 11110101b = 00110000b
-11000101b ^ 11110110b = 00110011b
-11000101b ^ 11110111b = 00110010b
-11000101b ^ 11111000b = 00111101b
-11000101b ^ 11111001b = 00111100b
-11000101b ^ 11111010b = 00111111b
-11000101b ^ 11111011b = 00111110b
-11000101b ^ 11111100b = 00111001b
-11000101b ^ 11111101b = 00111000b
-11000101b ^ 11111110b = 00111011b
-11000101b ^ 11111111b = 00111010b
-11000101b ^ 00000000b = 11000101b
-11000101b ^ 00000001b = 11000100b
-11000101b ^ 00000010b = 11000111b
-11000101b ^ 00000011b = 11000110b
-11000101b ^ 00000100b = 11000001b
-11000101b ^ 00000101b = 11000000b
-11000101b ^ 00000110b = 11000011b
-11000101b ^ 00000111b = 11000010b
-11000101b ^ 00001000b = 11001101b
-11000101b ^ 00001001b = 11001100b
-11000101b ^ 00001010b = 11001111b
-11000101b ^ 00001011b = 11001110b
-11000101b ^ 00001100b = 11001001b
-11000101b ^ 00001101b = 11001000b
-11000101b ^ 00001110b = 11001011b
-11000101b ^ 00001111b = 11001010b
-11000101b ^ 00010000b = 11010101b
-11000101b ^ 00010001b = 11010100b
-11000101b ^ 00010010b = 11010111b
-11000101b ^ 00010011b = 11010110b
-11000101b ^ 00010100b = 11010001b
-11000101b ^ 00010101b = 11010000b
-11000101b ^ 00010110b = 11010011b
-11000101b ^ 00010111b = 11010010b
-11000101b ^ 00011000b = 11011101b
-11000101b ^ 00011001b = 11011100b
-11000101b ^ 00011010b = 11011111b
-11000101b ^ 00011011b = 11011110b
-11000101b ^ 00011100b = 11011001b
-11000101b ^ 00011101b = 11011000b
-11000101b ^ 00011110b = 11011011b
-11000101b ^ 00011111b = 11011010b
-11000101b ^ 00100000b = 11100101b
-11000101b ^ 00100001b = 11100100b
-11000101b ^ 00100010b = 11100111b
-11000101b ^ 00100011b = 11100110b
-11000101b ^ 00100100b = 11100001b
-11000101b ^ 00100101b = 11100000b
-11000101b ^ 00100110b = 11100011b
-11000101b ^ 00100111b = 11100010b
-11000101b ^ 00101000b = 11101101b
-11000101b ^ 00101001b = 11101100b
-11000101b ^ 00101010b = 11101111b
-11000101b ^ 00101011b = 11101110b
-11000101b ^ 00101100b = 11101001b
-11000101b ^ 00101101b = 11101000b
-11000101b ^ 00101110b = 11101011b
-11000101b ^ 00101111b = 11101010b
-11000101b ^ 00110000b = 11110101b
-11000101b ^ 00110001b = 11110100b
-11000101b ^ 00110010b = 11110111b
-11000101b ^ 00110011b = 11110110b
-11000101b ^ 00110100b = 11110001b
-11000101b ^ 00110101b = 11110000b
-11000101b ^ 00110110b = 11110011b
-11000101b ^ 00110111b = 11110010b
-11000101b ^ 00111000b = 11111101b
-11000101b ^ 00111001b = 11111100b
-11000101b ^ 00111010b = 11111111b
-11000101b ^ 00111011b = 11111110b
-11000101b ^ 00111100b = 11111001b
-11000101b ^ 00111101b = 11111000b
-11000101b ^ 00111110b = 11111011b
-11000101b ^ 00111111b = 11111010b
-11000101b ^ 01000000b = 10000101b
-11000101b ^ 01000001b = 10000100b
-11000101b ^ 01000010b = 10000111b
-11000101b ^ 01000011b = 10000110b
-11000101b ^ 01000100b = 10000001b
-11000101b ^ 01000101b = 10000000b
-11000101b ^ 01000110b = 10000011b
-11000101b ^ 01000111b = 10000010b
-11000101b ^ 01001000b = 10001101b
-11000101b ^ 01001001b = 10001100b
-11000101b ^ 01001010b = 10001111b
-11000101b ^ 01001011b = 10001110b
-11000101b ^ 01001100b = 10001001b
-11000101b ^ 01001101b = 10001000b
-11000101b ^ 01001110b = 10001011b
-11000101b ^ 01001111b = 10001010b
-11000101b ^ 01010000b = 10010101b
-11000101b ^ 01010001b = 10010100b
-11000101b ^ 01010010b = 10010111b
-11000101b ^ 01010011b = 10010110b
-11000101b ^ 01010100b = 10010001b
-11000101b ^ 01010101b = 10010000b
-11000101b ^ 01010110b = 10010011b
-11000101b ^ 01010111b = 10010010b
-11000101b ^ 01011000b = 10011101b
-11000101b ^ 01011001b = 10011100b
-11000101b ^ 01011010b = 10011111b
-11000101b ^ 01011011b = 10011110b
-11000101b ^ 01011100b = 10011001b
-11000101b ^ 01011101b = 10011000b
-11000101b ^ 01011110b = 10011011b
-11000101b ^ 01011111b = 10011010b
-11000101b ^ 01100000b = 10100101b
-11000101b ^ 01100001b = 10100100b
-11000101b ^ 01100010b = 10100111b
-11000101b ^ 01100011b = 10100110b
-11000101b ^ 01100100b = 10100001b
-11000101b ^ 01100101b = 10100000b
-11000101b ^ 01100110b = 10100011b
-11000101b ^ 01100111b = 10100010b
-11000101b ^ 01101000b = 10101101b
-11000101b ^ 01101001b = 10101100b
-11000101b ^ 01101010b = 10101111b
-11000101b ^ 01101011b = 10101110b
-11000101b ^ 01101100b = 10101001b
-11000101b ^ 01101101b = 10101000b
-11000101b ^ 01101110b = 10101011b
-11000101b ^ 01101111b = 10101010b
-11000101b ^ 01110000b = 10110101b
-11000101b ^ 01110001b = 10110100b
-11000101b ^ 01110010b = 10110111b
-11000101b ^ 01110011b = 10110110b
-11000101b ^ 01110100b = 10110001b
-11000101b ^ 01110101b = 10110000b
-11000101b ^ 01110110b = 10110011b
-11000101b ^ 01110111b = 10110010b
-11000101b ^ 01111000b = 10111101b
-11000101b ^ 01111001b = 10111100b
-11000101b ^ 01111010b = 10111111b
-11000101b ^ 01111011b = 10111110b
-11000101b ^ 01111100b = 10111001b
-11000101b ^ 01111101b = 10111000b
-11000101b ^ 01111110b = 10111011b
-11000110b ^ 10000000b = 01000110b
-11000110b ^ 10000001b = 01000111b
-11000110b ^ 10000010b = 01000100b
-11000110b ^ 10000011b = 01000101b
-11000110b ^ 10000100b = 01000010b
-11000110b ^ 10000101b = 01000011b
-11000110b ^ 10000110b = 01000000b
-11000110b ^ 10000111b = 01000001b
-11000110b ^ 10001000b = 01001110b
-11000110b ^ 10001001b = 01001111b
-11000110b ^ 10001010b = 01001100b
-11000110b ^ 10001011b = 01001101b
-11000110b ^ 10001100b = 01001010b
-11000110b ^ 10001101b = 01001011b
-11000110b ^ 10001110b = 01001000b
-11000110b ^ 10001111b = 01001001b
-11000110b ^ 10010000b = 01010110b
-11000110b ^ 10010001b = 01010111b
-11000110b ^ 10010010b = 01010100b
-11000110b ^ 10010011b = 01010101b
-11000110b ^ 10010100b = 01010010b
-11000110b ^ 10010101b = 01010011b
-11000110b ^ 10010110b = 01010000b
-11000110b ^ 10010111b = 01010001b
-11000110b ^ 10011000b = 01011110b
-11000110b ^ 10011001b = 01011111b
-11000110b ^ 10011010b = 01011100b
-11000110b ^ 10011011b = 01011101b
-11000110b ^ 10011100b = 01011010b
-11000110b ^ 10011101b = 01011011b
-11000110b ^ 10011110b = 01011000b
-11000110b ^ 10011111b = 01011001b
-11000110b ^ 10100000b = 01100110b
-11000110b ^ 10100001b = 01100111b
-11000110b ^ 10100010b = 01100100b
-11000110b ^ 10100011b = 01100101b
-11000110b ^ 10100100b = 01100010b
-11000110b ^ 10100101b = 01100011b
-11000110b ^ 10100110b = 01100000b
-11000110b ^ 10100111b = 01100001b
-11000110b ^ 10101000b = 01101110b
-11000110b ^ 10101001b = 01101111b
-11000110b ^ 10101010b = 01101100b
-11000110b ^ 10101011b = 01101101b
-11000110b ^ 10101100b = 01101010b
-11000110b ^ 10101101b = 01101011b
-11000110b ^ 10101110b = 01101000b
-11000110b ^ 10101111b = 01101001b
-11000110b ^ 10110000b = 01110110b
-11000110b ^ 10110001b = 01110111b
-11000110b ^ 10110010b = 01110100b
-11000110b ^ 10110011b = 01110101b
-11000110b ^ 10110100b = 01110010b
-11000110b ^ 10110101b = 01110011b
-11000110b ^ 10110110b = 01110000b
-11000110b ^ 10110111b = 01110001b
-11000110b ^ 10111000b = 01111110b
-11000110b ^ 10111001b = 01111111b
-11000110b ^ 10111010b = 01111100b
-11000110b ^ 10111011b = 01111101b
-11000110b ^ 10111100b = 01111010b
-11000110b ^ 10111101b = 01111011b
-11000110b ^ 10111110b = 01111000b
-11000110b ^ 10111111b = 01111001b
-11000110b ^ 11000000b = 00000110b
-11000110b ^ 11000001b = 00000111b
-11000110b ^ 11000010b = 00000100b
-11000110b ^ 11000011b = 00000101b
-11000110b ^ 11000100b = 00000010b
-11000110b ^ 11000101b = 00000011b
-11000110b ^ 11000110b = 00000000b
-11000110b ^ 11000111b = 00000001b
-11000110b ^ 11001000b = 00001110b
-11000110b ^ 11001001b = 00001111b
-11000110b ^ 11001010b = 00001100b
-11000110b ^ 11001011b = 00001101b
-11000110b ^ 11001100b = 00001010b
-11000110b ^ 11001101b = 00001011b
-11000110b ^ 11001110b = 00001000b
-11000110b ^ 11001111b = 00001001b
-11000110b ^ 11010000b = 00010110b
-11000110b ^ 11010001b = 00010111b
-11000110b ^ 11010010b = 00010100b
-11000110b ^ 11010011b = 00010101b
-11000110b ^ 11010100b = 00010010b
-11000110b ^ 11010101b = 00010011b
-11000110b ^ 11010110b = 00010000b
-11000110b ^ 11010111b = 00010001b
-11000110b ^ 11011000b = 00011110b
-11000110b ^ 11011001b = 00011111b
-11000110b ^ 11011010b = 00011100b
-11000110b ^ 11011011b = 00011101b
-11000110b ^ 11011100b = 00011010b
-11000110b ^ 11011101b = 00011011b
-11000110b ^ 11011110b = 00011000b
-11000110b ^ 11011111b = 00011001b
-11000110b ^ 11100000b = 00100110b
-11000110b ^ 11100001b = 00100111b
-11000110b ^ 11100010b = 00100100b
-11000110b ^ 11100011b = 00100101b
-11000110b ^ 11100100b = 00100010b
-11000110b ^ 11100101b = 00100011b
-11000110b ^ 11100110b = 00100000b
-11000110b ^ 11100111b = 00100001b
-11000110b ^ 11101000b = 00101110b
-11000110b ^ 11101001b = 00101111b
-11000110b ^ 11101010b = 00101100b
-11000110b ^ 11101011b = 00101101b
-11000110b ^ 11101100b = 00101010b
-11000110b ^ 11101101b = 00101011b
-11000110b ^ 11101110b = 00101000b
-11000110b ^ 11101111b = 00101001b
-11000110b ^ 11110000b = 00110110b
-11000110b ^ 11110001b = 00110111b
-11000110b ^ 11110010b = 00110100b
-11000110b ^ 11110011b = 00110101b
-11000110b ^ 11110100b = 00110010b
-11000110b ^ 11110101b = 00110011b
-11000110b ^ 11110110b = 00110000b
-11000110b ^ 11110111b = 00110001b
-11000110b ^ 11111000b = 00111110b
-11000110b ^ 11111001b = 00111111b
-11000110b ^ 11111010b = 00111100b
-11000110b ^ 11111011b = 00111101b
-11000110b ^ 11111100b = 00111010b
-11000110b ^ 11111101b = 00111011b
-11000110b ^ 11111110b = 00111000b
-11000110b ^ 11111111b = 00111001b
-11000110b ^ 00000000b = 11000110b
-11000110b ^ 00000001b = 11000111b
-11000110b ^ 00000010b = 11000100b
-11000110b ^ 00000011b = 11000101b
-11000110b ^ 00000100b = 11000010b
-11000110b ^ 00000101b = 11000011b
-11000110b ^ 00000110b = 11000000b
-11000110b ^ 00000111b = 11000001b
-11000110b ^ 00001000b = 11001110b
-11000110b ^ 00001001b = 11001111b
-11000110b ^ 00001010b = 11001100b
-11000110b ^ 00001011b = 11001101b
-11000110b ^ 00001100b = 11001010b
-11000110b ^ 00001101b = 11001011b
-11000110b ^ 00001110b = 11001000b
-11000110b ^ 00001111b = 11001001b
-11000110b ^ 00010000b = 11010110b
-11000110b ^ 00010001b = 11010111b
-11000110b ^ 00010010b = 11010100b
-11000110b ^ 00010011b = 11010101b
-11000110b ^ 00010100b = 11010010b
-11000110b ^ 00010101b = 11010011b
-11000110b ^ 00010110b = 11010000b
-11000110b ^ 00010111b = 11010001b
-11000110b ^ 00011000b = 11011110b
-11000110b ^ 00011001b = 11011111b
-11000110b ^ 00011010b = 11011100b
-11000110b ^ 00011011b = 11011101b
-11000110b ^ 00011100b = 11011010b
-11000110b ^ 00011101b = 11011011b
-11000110b ^ 00011110b = 11011000b
-11000110b ^ 00011111b = 11011001b
-11000110b ^ 00100000b = 11100110b
-11000110b ^ 00100001b = 11100111b
-11000110b ^ 00100010b = 11100100b
-11000110b ^ 00100011b = 11100101b
-11000110b ^ 00100100b = 11100010b
-11000110b ^ 00100101b = 11100011b
-11000110b ^ 00100110b = 11100000b
-11000110b ^ 00100111b = 11100001b
-11000110b ^ 00101000b = 11101110b
-11000110b ^ 00101001b = 11101111b
-11000110b ^ 00101010b = 11101100b
-11000110b ^ 00101011b = 11101101b
-11000110b ^ 00101100b = 11101010b
-11000110b ^ 00101101b = 11101011b
-11000110b ^ 00101110b = 11101000b
-11000110b ^ 00101111b = 11101001b
-11000110b ^ 00110000b = 11110110b
-11000110b ^ 00110001b = 11110111b
-11000110b ^ 00110010b = 11110100b
-11000110b ^ 00110011b = 11110101b
-11000110b ^ 00110100b = 11110010b
-11000110b ^ 00110101b = 11110011b
-11000110b ^ 00110110b = 11110000b
-11000110b ^ 00110111b = 11110001b
-11000110b ^ 00111000b = 11111110b
-11000110b ^ 00111001b = 11111111b
-11000110b ^ 00111010b = 11111100b
-11000110b ^ 00111011b = 11111101b
-11000110b ^ 00111100b = 11111010b
-11000110b ^ 00111101b = 11111011b
-11000110b ^ 00111110b = 11111000b
-11000110b ^ 00111111b = 11111001b
-11000110b ^ 01000000b = 10000110b
-11000110b ^ 01000001b = 10000111b
-11000110b ^ 01000010b = 10000100b
-11000110b ^ 01000011b = 10000101b
-11000110b ^ 01000100b = 10000010b
-11000110b ^ 01000101b = 10000011b
-11000110b ^ 01000110b = 10000000b
-11000110b ^ 01000111b = 10000001b
-11000110b ^ 01001000b = 10001110b
-11000110b ^ 01001001b = 10001111b
-11000110b ^ 01001010b = 10001100b
-11000110b ^ 01001011b = 10001101b
-11000110b ^ 01001100b = 10001010b
-11000110b ^ 01001101b = 10001011b
-11000110b ^ 01001110b = 10001000b
-11000110b ^ 01001111b = 10001001b
-11000110b ^ 01010000b = 10010110b
-11000110b ^ 01010001b = 10010111b
-11000110b ^ 01010010b = 10010100b
-11000110b ^ 01010011b = 10010101b
-11000110b ^ 01010100b = 10010010b
-11000110b ^ 01010101b = 10010011b
-11000110b ^ 01010110b = 10010000b
-11000110b ^ 01010111b = 10010001b
-11000110b ^ 01011000b = 10011110b
-11000110b ^ 01011001b = 10011111b
-11000110b ^ 01011010b = 10011100b
-11000110b ^ 01011011b = 10011101b
-11000110b ^ 01011100b = 10011010b
-11000110b ^ 01011101b = 10011011b
-11000110b ^ 01011110b = 10011000b
-11000110b ^ 01011111b = 10011001b
-11000110b ^ 01100000b = 10100110b
-11000110b ^ 01100001b = 10100111b
-11000110b ^ 01100010b = 10100100b
-11000110b ^ 01100011b = 10100101b
-11000110b ^ 01100100b = 10100010b
-11000110b ^ 01100101b = 10100011b
-11000110b ^ 01100110b = 10100000b
-11000110b ^ 01100111b = 10100001b
-11000110b ^ 01101000b = 10101110b
-11000110b ^ 01101001b = 10101111b
-11000110b ^ 01101010b = 10101100b
-11000110b ^ 01101011b = 10101101b
-11000110b ^ 01101100b = 10101010b
-11000110b ^ 01101101b = 10101011b
-11000110b ^ 01101110b = 10101000b
-11000110b ^ 01101111b = 10101001b
-11000110b ^ 01110000b = 10110110b
-11000110b ^ 01110001b = 10110111b
-11000110b ^ 01110010b = 10110100b
-11000110b ^ 01110011b = 10110101b
-11000110b ^ 01110100b = 10110010b
-11000110b ^ 01110101b = 10110011b
-11000110b ^ 01110110b = 10110000b
-11000110b ^ 01110111b = 10110001b
-11000110b ^ 01111000b = 10111110b
-11000110b ^ 01111001b = 10111111b
-11000110b ^ 01111010b = 10111100b
-11000110b ^ 01111011b = 10111101b
-11000110b ^ 01111100b = 10111010b
-11000110b ^ 01111101b = 10111011b
-11000110b ^ 01111110b = 10111000b
-11000111b ^ 10000000b = 01000111b
-11000111b ^ 10000001b = 01000110b
-11000111b ^ 10000010b = 01000101b
-11000111b ^ 10000011b = 01000100b
-11000111b ^ 10000100b = 01000011b
-11000111b ^ 10000101b = 01000010b
-11000111b ^ 10000110b = 01000001b
-11000111b ^ 10000111b = 01000000b
-11000111b ^ 10001000b = 01001111b
-11000111b ^ 10001001b = 01001110b
-11000111b ^ 10001010b = 01001101b
-11000111b ^ 10001011b = 01001100b
-11000111b ^ 10001100b = 01001011b
-11000111b ^ 10001101b = 01001010b
-11000111b ^ 10001110b = 01001001b
-11000111b ^ 10001111b = 01001000b
-11000111b ^ 10010000b = 01010111b
-11000111b ^ 10010001b = 01010110b
-11000111b ^ 10010010b = 01010101b
-11000111b ^ 10010011b = 01010100b
-11000111b ^ 10010100b = 01010011b
-11000111b ^ 10010101b = 01010010b
-11000111b ^ 10010110b = 01010001b
-11000111b ^ 10010111b = 01010000b
-11000111b ^ 10011000b = 01011111b
-11000111b ^ 10011001b = 01011110b
-11000111b ^ 10011010b = 01011101b
-11000111b ^ 10011011b = 01011100b
-11000111b ^ 10011100b = 01011011b
-11000111b ^ 10011101b = 01011010b
-11000111b ^ 10011110b = 01011001b
-11000111b ^ 10011111b = 01011000b
-11000111b ^ 10100000b = 01100111b
-11000111b ^ 10100001b = 01100110b
-11000111b ^ 10100010b = 01100101b
-11000111b ^ 10100011b = 01100100b
-11000111b ^ 10100100b = 01100011b
-11000111b ^ 10100101b = 01100010b
-11000111b ^ 10100110b = 01100001b
-11000111b ^ 10100111b = 01100000b
-11000111b ^ 10101000b = 01101111b
-11000111b ^ 10101001b = 01101110b
-11000111b ^ 10101010b = 01101101b
-11000111b ^ 10101011b = 01101100b
-11000111b ^ 10101100b = 01101011b
-11000111b ^ 10101101b = 01101010b
-11000111b ^ 10101110b = 01101001b
-11000111b ^ 10101111b = 01101000b
-11000111b ^ 10110000b = 01110111b
-11000111b ^ 10110001b = 01110110b
-11000111b ^ 10110010b = 01110101b
-11000111b ^ 10110011b = 01110100b
-11000111b ^ 10110100b = 01110011b
-11000111b ^ 10110101b = 01110010b
-11000111b ^ 10110110b = 01110001b
-11000111b ^ 10110111b = 01110000b
-11000111b ^ 10111000b = 01111111b
-11000111b ^ 10111001b = 01111110b
-11000111b ^ 10111010b = 01111101b
-11000111b ^ 10111011b = 01111100b
-11000111b ^ 10111100b = 01111011b
-11000111b ^ 10111101b = 01111010b
-11000111b ^ 10111110b = 01111001b
-11000111b ^ 10111111b = 01111000b
-11000111b ^ 11000000b = 00000111b
-11000111b ^ 11000001b = 00000110b
-11000111b ^ 11000010b = 00000101b
-11000111b ^ 11000011b = 00000100b
-11000111b ^ 11000100b = 00000011b
-11000111b ^ 11000101b = 00000010b
-11000111b ^ 11000110b = 00000001b
-11000111b ^ 11000111b = 00000000b
-11000111b ^ 11001000b = 00001111b
-11000111b ^ 11001001b = 00001110b
-11000111b ^ 11001010b = 00001101b
-11000111b ^ 11001011b = 00001100b
-11000111b ^ 11001100b = 00001011b
-11000111b ^ 11001101b = 00001010b
-11000111b ^ 11001110b = 00001001b
-11000111b ^ 11001111b = 00001000b
-11000111b ^ 11010000b = 00010111b
-11000111b ^ 11010001b = 00010110b
-11000111b ^ 11010010b = 00010101b
-11000111b ^ 11010011b = 00010100b
-11000111b ^ 11010100b = 00010011b
-11000111b ^ 11010101b = 00010010b
-11000111b ^ 11010110b = 00010001b
-11000111b ^ 11010111b = 00010000b
-11000111b ^ 11011000b = 00011111b
-11000111b ^ 11011001b = 00011110b
-11000111b ^ 11011010b = 00011101b
-11000111b ^ 11011011b = 00011100b
-11000111b ^ 11011100b = 00011011b
-11000111b ^ 11011101b = 00011010b
-11000111b ^ 11011110b = 00011001b
-11000111b ^ 11011111b = 00011000b
-11000111b ^ 11100000b = 00100111b
-11000111b ^ 11100001b = 00100110b
-11000111b ^ 11100010b = 00100101b
-11000111b ^ 11100011b = 00100100b
-11000111b ^ 11100100b = 00100011b
-11000111b ^ 11100101b = 00100010b
-11000111b ^ 11100110b = 00100001b
-11000111b ^ 11100111b = 00100000b
-11000111b ^ 11101000b = 00101111b
-11000111b ^ 11101001b = 00101110b
-11000111b ^ 11101010b = 00101101b
-11000111b ^ 11101011b = 00101100b
-11000111b ^ 11101100b = 00101011b
-11000111b ^ 11101101b = 00101010b
-11000111b ^ 11101110b = 00101001b
-11000111b ^ 11101111b = 00101000b
-11000111b ^ 11110000b = 00110111b
-11000111b ^ 11110001b = 00110110b
-11000111b ^ 11110010b = 00110101b
-11000111b ^ 11110011b = 00110100b
-11000111b ^ 11110100b = 00110011b
-11000111b ^ 11110101b = 00110010b
-11000111b ^ 11110110b = 00110001b
-11000111b ^ 11110111b = 00110000b
-11000111b ^ 11111000b = 00111111b
-11000111b ^ 11111001b = 00111110b
-11000111b ^ 11111010b = 00111101b
-11000111b ^ 11111011b = 00111100b
-11000111b ^ 11111100b = 00111011b
-11000111b ^ 11111101b = 00111010b
-11000111b ^ 11111110b = 00111001b
-11000111b ^ 11111111b = 00111000b
-11000111b ^ 00000000b = 11000111b
-11000111b ^ 00000001b = 11000110b
-11000111b ^ 00000010b = 11000101b
-11000111b ^ 00000011b = 11000100b
-11000111b ^ 00000100b = 11000011b
-11000111b ^ 00000101b = 11000010b
-11000111b ^ 00000110b = 11000001b
-11000111b ^ 00000111b = 11000000b
-11000111b ^ 00001000b = 11001111b
-11000111b ^ 00001001b = 11001110b
-11000111b ^ 00001010b = 11001101b
-11000111b ^ 00001011b = 11001100b
-11000111b ^ 00001100b = 11001011b
-11000111b ^ 00001101b = 11001010b
-11000111b ^ 00001110b = 11001001b
-11000111b ^ 00001111b = 11001000b
-11000111b ^ 00010000b = 11010111b
-11000111b ^ 00010001b = 11010110b
-11000111b ^ 00010010b = 11010101b
-11000111b ^ 00010011b = 11010100b
-11000111b ^ 00010100b = 11010011b
-11000111b ^ 00010101b = 11010010b
-11000111b ^ 00010110b = 11010001b
-11000111b ^ 00010111b = 11010000b
-11000111b ^ 00011000b = 11011111b
-11000111b ^ 00011001b = 11011110b
-11000111b ^ 00011010b = 11011101b
-11000111b ^ 00011011b = 11011100b
-11000111b ^ 00011100b = 11011011b
-11000111b ^ 00011101b = 11011010b
-11000111b ^ 00011110b = 11011001b
-11000111b ^ 00011111b = 11011000b
-11000111b ^ 00100000b = 11100111b
-11000111b ^ 00100001b = 11100110b
-11000111b ^ 00100010b = 11100101b
-11000111b ^ 00100011b = 11100100b
-11000111b ^ 00100100b = 11100011b
-11000111b ^ 00100101b = 11100010b
-11000111b ^ 00100110b = 11100001b
-11000111b ^ 00100111b = 11100000b
-11000111b ^ 00101000b = 11101111b
-11000111b ^ 00101001b = 11101110b
-11000111b ^ 00101010b = 11101101b
-11000111b ^ 00101011b = 11101100b
-11000111b ^ 00101100b = 11101011b
-11000111b ^ 00101101b = 11101010b
-11000111b ^ 00101110b = 11101001b
-11000111b ^ 00101111b = 11101000b
-11000111b ^ 00110000b = 11110111b
-11000111b ^ 00110001b = 11110110b
-11000111b ^ 00110010b = 11110101b
-11000111b ^ 00110011b = 11110100b
-11000111b ^ 00110100b = 11110011b
-11000111b ^ 00110101b = 11110010b
-11000111b ^ 00110110b = 11110001b
-11000111b ^ 00110111b = 11110000b
-11000111b ^ 00111000b = 11111111b
-11000111b ^ 00111001b = 11111110b
-11000111b ^ 00111010b = 11111101b
-11000111b ^ 00111011b = 11111100b
-11000111b ^ 00111100b = 11111011b
-11000111b ^ 00111101b = 11111010b
-11000111b ^ 00111110b = 11111001b
-11000111b ^ 00111111b = 11111000b
-11000111b ^ 01000000b = 10000111b
-11000111b ^ 01000001b = 10000110b
-11000111b ^ 01000010b = 10000101b
-11000111b ^ 01000011b = 10000100b
-11000111b ^ 01000100b = 10000011b
-11000111b ^ 01000101b = 10000010b
-11000111b ^ 01000110b = 10000001b
-11000111b ^ 01000111b = 10000000b
-11000111b ^ 01001000b = 10001111b
-11000111b ^ 01001001b = 10001110b
-11000111b ^ 01001010b = 10001101b
-11000111b ^ 01001011b = 10001100b
-11000111b ^ 01001100b = 10001011b
-11000111b ^ 01001101b = 10001010b
-11000111b ^ 01001110b = 10001001b
-11000111b ^ 01001111b = 10001000b
-11000111b ^ 01010000b = 10010111b
-11000111b ^ 01010001b = 10010110b
-11000111b ^ 01010010b = 10010101b
-11000111b ^ 01010011b = 10010100b
-11000111b ^ 01010100b = 10010011b
-11000111b ^ 01010101b = 10010010b
-11000111b ^ 01010110b = 10010001b
-11000111b ^ 01010111b = 10010000b
-11000111b ^ 01011000b = 10011111b
-11000111b ^ 01011001b = 10011110b
-11000111b ^ 01011010b = 10011101b
-11000111b ^ 01011011b = 10011100b
-11000111b ^ 01011100b = 10011011b
-11000111b ^ 01011101b = 10011010b
-11000111b ^ 01011110b = 10011001b
-11000111b ^ 01011111b = 10011000b
-11000111b ^ 01100000b = 10100111b
-11000111b ^ 01100001b = 10100110b
-11000111b ^ 01100010b = 10100101b
-11000111b ^ 01100011b = 10100100b
-11000111b ^ 01100100b = 10100011b
-11000111b ^ 01100101b = 10100010b
-11000111b ^ 01100110b = 10100001b
-11000111b ^ 01100111b = 10100000b
-11000111b ^ 01101000b = 10101111b
-11000111b ^ 01101001b = 10101110b
-11000111b ^ 01101010b = 10101101b
-11000111b ^ 01101011b = 10101100b
-11000111b ^ 01101100b = 10101011b
-11000111b ^ 01101101b = 10101010b
-11000111b ^ 01101110b = 10101001b
-11000111b ^ 01101111b = 10101000b
-11000111b ^ 01110000b = 10110111b
-11000111b ^ 01110001b = 10110110b
-11000111b ^ 01110010b = 10110101b
-11000111b ^ 01110011b = 10110100b
-11000111b ^ 01110100b = 10110011b
-11000111b ^ 01110101b = 10110010b
-11000111b ^ 01110110b = 10110001b
-11000111b ^ 01110111b = 10110000b
-11000111b ^ 01111000b = 10111111b
-11000111b ^ 01111001b = 10111110b
-11000111b ^ 01111010b = 10111101b
-11000111b ^ 01111011b = 10111100b
-11000111b ^ 01111100b = 10111011b
-11000111b ^ 01111101b = 10111010b
-11000111b ^ 01111110b = 10111001b
-11001000b ^ 10000000b = 01001000b
-11001000b ^ 10000001b = 01001001b
-11001000b ^ 10000010b = 01001010b
-11001000b ^ 10000011b = 01001011b
-11001000b ^ 10000100b = 01001100b
-11001000b ^ 10000101b = 01001101b
-11001000b ^ 10000110b = 01001110b
-11001000b ^ 10000111b = 01001111b
-11001000b ^ 10001000b = 01000000b
-11001000b ^ 10001001b = 01000001b
-11001000b ^ 10001010b = 01000010b
-11001000b ^ 10001011b = 01000011b
-11001000b ^ 10001100b = 01000100b
-11001000b ^ 10001101b = 01000101b
-11001000b ^ 10001110b = 01000110b
-11001000b ^ 10001111b = 01000111b
-11001000b ^ 10010000b = 01011000b
-11001000b ^ 10010001b = 01011001b
-11001000b ^ 10010010b = 01011010b
-11001000b ^ 10010011b = 01011011b
-11001000b ^ 10010100b = 01011100b
-11001000b ^ 10010101b = 01011101b
-11001000b ^ 10010110b = 01011110b
-11001000b ^ 10010111b = 01011111b
-11001000b ^ 10011000b = 01010000b
-11001000b ^ 10011001b = 01010001b
-11001000b ^ 10011010b = 01010010b
-11001000b ^ 10011011b = 01010011b
-11001000b ^ 10011100b = 01010100b
-11001000b ^ 10011101b = 01010101b
-11001000b ^ 10011110b = 01010110b
-11001000b ^ 10011111b = 01010111b
-11001000b ^ 10100000b = 01101000b
-11001000b ^ 10100001b = 01101001b
-11001000b ^ 10100010b = 01101010b
-11001000b ^ 10100011b = 01101011b
-11001000b ^ 10100100b = 01101100b
-11001000b ^ 10100101b = 01101101b
-11001000b ^ 10100110b = 01101110b
-11001000b ^ 10100111b = 01101111b
-11001000b ^ 10101000b = 01100000b
-11001000b ^ 10101001b = 01100001b
-11001000b ^ 10101010b = 01100010b
-11001000b ^ 10101011b = 01100011b
-11001000b ^ 10101100b = 01100100b
-11001000b ^ 10101101b = 01100101b
-11001000b ^ 10101110b = 01100110b
-11001000b ^ 10101111b = 01100111b
-11001000b ^ 10110000b = 01111000b
-11001000b ^ 10110001b = 01111001b
-11001000b ^ 10110010b = 01111010b
-11001000b ^ 10110011b = 01111011b
-11001000b ^ 10110100b = 01111100b
-11001000b ^ 10110101b = 01111101b
-11001000b ^ 10110110b = 01111110b
-11001000b ^ 10110111b = 01111111b
-11001000b ^ 10111000b = 01110000b
-11001000b ^ 10111001b = 01110001b
-11001000b ^ 10111010b = 01110010b
-11001000b ^ 10111011b = 01110011b
-11001000b ^ 10111100b = 01110100b
-11001000b ^ 10111101b = 01110101b
-11001000b ^ 10111110b = 01110110b
-11001000b ^ 10111111b = 01110111b
-11001000b ^ 11000000b = 00001000b
-11001000b ^ 11000001b = 00001001b
-11001000b ^ 11000010b = 00001010b
-11001000b ^ 11000011b = 00001011b
-11001000b ^ 11000100b = 00001100b
-11001000b ^ 11000101b = 00001101b
-11001000b ^ 11000110b = 00001110b
-11001000b ^ 11000111b = 00001111b
-11001000b ^ 11001000b = 00000000b
-11001000b ^ 11001001b = 00000001b
-11001000b ^ 11001010b = 00000010b
-11001000b ^ 11001011b = 00000011b
-11001000b ^ 11001100b = 00000100b
-11001000b ^ 11001101b = 00000101b
-11001000b ^ 11001110b = 00000110b
-11001000b ^ 11001111b = 00000111b
-11001000b ^ 11010000b = 00011000b
-11001000b ^ 11010001b = 00011001b
-11001000b ^ 11010010b = 00011010b
-11001000b ^ 11010011b = 00011011b
-11001000b ^ 11010100b = 00011100b
-11001000b ^ 11010101b = 00011101b
-11001000b ^ 11010110b = 00011110b
-11001000b ^ 11010111b = 00011111b
-11001000b ^ 11011000b = 00010000b
-11001000b ^ 11011001b = 00010001b
-11001000b ^ 11011010b = 00010010b
-11001000b ^ 11011011b = 00010011b
-11001000b ^ 11011100b = 00010100b
-11001000b ^ 11011101b = 00010101b
-11001000b ^ 11011110b = 00010110b
-11001000b ^ 11011111b = 00010111b
-11001000b ^ 11100000b = 00101000b
-11001000b ^ 11100001b = 00101001b
-11001000b ^ 11100010b = 00101010b
-11001000b ^ 11100011b = 00101011b
-11001000b ^ 11100100b = 00101100b
-11001000b ^ 11100101b = 00101101b
-11001000b ^ 11100110b = 00101110b
-11001000b ^ 11100111b = 00101111b
-11001000b ^ 11101000b = 00100000b
-11001000b ^ 11101001b = 00100001b
-11001000b ^ 11101010b = 00100010b
-11001000b ^ 11101011b = 00100011b
-11001000b ^ 11101100b = 00100100b
-11001000b ^ 11101101b = 00100101b
-11001000b ^ 11101110b = 00100110b
-11001000b ^ 11101111b = 00100111b
-11001000b ^ 11110000b = 00111000b
-11001000b ^ 11110001b = 00111001b
-11001000b ^ 11110010b = 00111010b
-11001000b ^ 11110011b = 00111011b
-11001000b ^ 11110100b = 00111100b
-11001000b ^ 11110101b = 00111101b
-11001000b ^ 11110110b = 00111110b
-11001000b ^ 11110111b = 00111111b
-11001000b ^ 11111000b = 00110000b
-11001000b ^ 11111001b = 00110001b
-11001000b ^ 11111010b = 00110010b
-11001000b ^ 11111011b = 00110011b
-11001000b ^ 11111100b = 00110100b
-11001000b ^ 11111101b = 00110101b
-11001000b ^ 11111110b = 00110110b
-11001000b ^ 11111111b = 00110111b
-11001000b ^ 00000000b = 11001000b
-11001000b ^ 00000001b = 11001001b
-11001000b ^ 00000010b = 11001010b
-11001000b ^ 00000011b = 11001011b
-11001000b ^ 00000100b = 11001100b
-11001000b ^ 00000101b = 11001101b
-11001000b ^ 00000110b = 11001110b
-11001000b ^ 00000111b = 11001111b
-11001000b ^ 00001000b = 11000000b
-11001000b ^ 00001001b = 11000001b
-11001000b ^ 00001010b = 11000010b
-11001000b ^ 00001011b = 11000011b
-11001000b ^ 00001100b = 11000100b
-11001000b ^ 00001101b = 11000101b
-11001000b ^ 00001110b = 11000110b
-11001000b ^ 00001111b = 11000111b
-11001000b ^ 00010000b = 11011000b
-11001000b ^ 00010001b = 11011001b
-11001000b ^ 00010010b = 11011010b
-11001000b ^ 00010011b = 11011011b
-11001000b ^ 00010100b = 11011100b
-11001000b ^ 00010101b = 11011101b
-11001000b ^ 00010110b = 11011110b
-11001000b ^ 00010111b = 11011111b
-11001000b ^ 00011000b = 11010000b
-11001000b ^ 00011001b = 11010001b
-11001000b ^ 00011010b = 11010010b
-11001000b ^ 00011011b = 11010011b
-11001000b ^ 00011100b = 11010100b
-11001000b ^ 00011101b = 11010101b
-11001000b ^ 00011110b = 11010110b
-11001000b ^ 00011111b = 11010111b
-11001000b ^ 00100000b = 11101000b
-11001000b ^ 00100001b = 11101001b
-11001000b ^ 00100010b = 11101010b
-11001000b ^ 00100011b = 11101011b
-11001000b ^ 00100100b = 11101100b
-11001000b ^ 00100101b = 11101101b
-11001000b ^ 00100110b = 11101110b
-11001000b ^ 00100111b = 11101111b
-11001000b ^ 00101000b = 11100000b
-11001000b ^ 00101001b = 11100001b
-11001000b ^ 00101010b = 11100010b
-11001000b ^ 00101011b = 11100011b
-11001000b ^ 00101100b = 11100100b
-11001000b ^ 00101101b = 11100101b
-11001000b ^ 00101110b = 11100110b
-11001000b ^ 00101111b = 11100111b
-11001000b ^ 00110000b = 11111000b
-11001000b ^ 00110001b = 11111001b
-11001000b ^ 00110010b = 11111010b
-11001000b ^ 00110011b = 11111011b
-11001000b ^ 00110100b = 11111100b
-11001000b ^ 00110101b = 11111101b
-11001000b ^ 00110110b = 11111110b
-11001000b ^ 00110111b = 11111111b
-11001000b ^ 00111000b = 11110000b
-11001000b ^ 00111001b = 11110001b
-11001000b ^ 00111010b = 11110010b
-11001000b ^ 00111011b = 11110011b
-11001000b ^ 00111100b = 11110100b
-11001000b ^ 00111101b = 11110101b
-11001000b ^ 00111110b = 11110110b
-11001000b ^ 00111111b = 11110111b
-11001000b ^ 01000000b = 10001000b
-11001000b ^ 01000001b = 10001001b
-11001000b ^ 01000010b = 10001010b
-11001000b ^ 01000011b = 10001011b
-11001000b ^ 01000100b = 10001100b
-11001000b ^ 01000101b = 10001101b
-11001000b ^ 01000110b = 10001110b
-11001000b ^ 01000111b = 10001111b
-11001000b ^ 01001000b = 10000000b
-11001000b ^ 01001001b = 10000001b
-11001000b ^ 01001010b = 10000010b
-11001000b ^ 01001011b = 10000011b
-11001000b ^ 01001100b = 10000100b
-11001000b ^ 01001101b = 10000101b
-11001000b ^ 01001110b = 10000110b
-11001000b ^ 01001111b = 10000111b
-11001000b ^ 01010000b = 10011000b
-11001000b ^ 01010001b = 10011001b
-11001000b ^ 01010010b = 10011010b
-11001000b ^ 01010011b = 10011011b
-11001000b ^ 01010100b = 10011100b
-11001000b ^ 01010101b = 10011101b
-11001000b ^ 01010110b = 10011110b
-11001000b ^ 01010111b = 10011111b
-11001000b ^ 01011000b = 10010000b
-11001000b ^ 01011001b = 10010001b
-11001000b ^ 01011010b = 10010010b
-11001000b ^ 01011011b = 10010011b
-11001000b ^ 01011100b = 10010100b
-11001000b ^ 01011101b = 10010101b
-11001000b ^ 01011110b = 10010110b
-11001000b ^ 01011111b = 10010111b
-11001000b ^ 01100000b = 10101000b
-11001000b ^ 01100001b = 10101001b
-11001000b ^ 01100010b = 10101010b
-11001000b ^ 01100011b = 10101011b
-11001000b ^ 01100100b = 10101100b
-11001000b ^ 01100101b = 10101101b
-11001000b ^ 01100110b = 10101110b
-11001000b ^ 01100111b = 10101111b
-11001000b ^ 01101000b = 10100000b
-11001000b ^ 01101001b = 10100001b
-11001000b ^ 01101010b = 10100010b
-11001000b ^ 01101011b = 10100011b
-11001000b ^ 01101100b = 10100100b
-11001000b ^ 01101101b = 10100101b
-11001000b ^ 01101110b = 10100110b
-11001000b ^ 01101111b = 10100111b
-11001000b ^ 01110000b = 10111000b
-11001000b ^ 01110001b = 10111001b
-11001000b ^ 01110010b = 10111010b
-11001000b ^ 01110011b = 10111011b
-11001000b ^ 01110100b = 10111100b
-11001000b ^ 01110101b = 10111101b
-11001000b ^ 01110110b = 10111110b
-11001000b ^ 01110111b = 10111111b
-11001000b ^ 01111000b = 10110000b
-11001000b ^ 01111001b = 10110001b
-11001000b ^ 01111010b = 10110010b
-11001000b ^ 01111011b = 10110011b
-11001000b ^ 01111100b = 10110100b
-11001000b ^ 01111101b = 10110101b
-11001000b ^ 01111110b = 10110110b
-11001001b ^ 10000000b = 01001001b
-11001001b ^ 10000001b = 01001000b
-11001001b ^ 10000010b = 01001011b
-11001001b ^ 10000011b = 01001010b
-11001001b ^ 10000100b = 01001101b
-11001001b ^ 10000101b = 01001100b
-11001001b ^ 10000110b = 01001111b
-11001001b ^ 10000111b = 01001110b
-11001001b ^ 10001000b = 01000001b
-11001001b ^ 10001001b = 01000000b
-11001001b ^ 10001010b = 01000011b
-11001001b ^ 10001011b = 01000010b
-11001001b ^ 10001100b = 01000101b
-11001001b ^ 10001101b = 01000100b
-11001001b ^ 10001110b = 01000111b
-11001001b ^ 10001111b = 01000110b
-11001001b ^ 10010000b = 01011001b
-11001001b ^ 10010001b = 01011000b
-11001001b ^ 10010010b = 01011011b
-11001001b ^ 10010011b = 01011010b
-11001001b ^ 10010100b = 01011101b
-11001001b ^ 10010101b = 01011100b
-11001001b ^ 10010110b = 01011111b
-11001001b ^ 10010111b = 01011110b
-11001001b ^ 10011000b = 01010001b
-11001001b ^ 10011001b = 01010000b
-11001001b ^ 10011010b = 01010011b
-11001001b ^ 10011011b = 01010010b
-11001001b ^ 10011100b = 01010101b
-11001001b ^ 10011101b = 01010100b
-11001001b ^ 10011110b = 01010111b
-11001001b ^ 10011111b = 01010110b
-11001001b ^ 10100000b = 01101001b
-11001001b ^ 10100001b = 01101000b
-11001001b ^ 10100010b = 01101011b
-11001001b ^ 10100011b = 01101010b
-11001001b ^ 10100100b = 01101101b
-11001001b ^ 10100101b = 01101100b
-11001001b ^ 10100110b = 01101111b
-11001001b ^ 10100111b = 01101110b
-11001001b ^ 10101000b = 01100001b
-11001001b ^ 10101001b = 01100000b
-11001001b ^ 10101010b = 01100011b
-11001001b ^ 10101011b = 01100010b
-11001001b ^ 10101100b = 01100101b
-11001001b ^ 10101101b = 01100100b
-11001001b ^ 10101110b = 01100111b
-11001001b ^ 10101111b = 01100110b
-11001001b ^ 10110000b = 01111001b
-11001001b ^ 10110001b = 01111000b
-11001001b ^ 10110010b = 01111011b
-11001001b ^ 10110011b = 01111010b
-11001001b ^ 10110100b = 01111101b
-11001001b ^ 10110101b = 01111100b
-11001001b ^ 10110110b = 01111111b
-11001001b ^ 10110111b = 01111110b
-11001001b ^ 10111000b = 01110001b
-11001001b ^ 10111001b = 01110000b
-11001001b ^ 10111010b = 01110011b
-11001001b ^ 10111011b = 01110010b
-11001001b ^ 10111100b = 01110101b
-11001001b ^ 10111101b = 01110100b
-11001001b ^ 10111110b = 01110111b
-11001001b ^ 10111111b = 01110110b
-11001001b ^ 11000000b = 00001001b
-11001001b ^ 11000001b = 00001000b
-11001001b ^ 11000010b = 00001011b
-11001001b ^ 11000011b = 00001010b
-11001001b ^ 11000100b = 00001101b
-11001001b ^ 11000101b = 00001100b
-11001001b ^ 11000110b = 00001111b
-11001001b ^ 11000111b = 00001110b
-11001001b ^ 11001000b = 00000001b
-11001001b ^ 11001001b = 00000000b
-11001001b ^ 11001010b = 00000011b
-11001001b ^ 11001011b = 00000010b
-11001001b ^ 11001100b = 00000101b
-11001001b ^ 11001101b = 00000100b
-11001001b ^ 11001110b = 00000111b
-11001001b ^ 11001111b = 00000110b
-11001001b ^ 11010000b = 00011001b
-11001001b ^ 11010001b = 00011000b
-11001001b ^ 11010010b = 00011011b
-11001001b ^ 11010011b = 00011010b
-11001001b ^ 11010100b = 00011101b
-11001001b ^ 11010101b = 00011100b
-11001001b ^ 11010110b = 00011111b
-11001001b ^ 11010111b = 00011110b
-11001001b ^ 11011000b = 00010001b
-11001001b ^ 11011001b = 00010000b
-11001001b ^ 11011010b = 00010011b
-11001001b ^ 11011011b = 00010010b
-11001001b ^ 11011100b = 00010101b
-11001001b ^ 11011101b = 00010100b
-11001001b ^ 11011110b = 00010111b
-11001001b ^ 11011111b = 00010110b
-11001001b ^ 11100000b = 00101001b
-11001001b ^ 11100001b = 00101000b
-11001001b ^ 11100010b = 00101011b
-11001001b ^ 11100011b = 00101010b
-11001001b ^ 11100100b = 00101101b
-11001001b ^ 11100101b = 00101100b
-11001001b ^ 11100110b = 00101111b
-11001001b ^ 11100111b = 00101110b
-11001001b ^ 11101000b = 00100001b
-11001001b ^ 11101001b = 00100000b
-11001001b ^ 11101010b = 00100011b
-11001001b ^ 11101011b = 00100010b
-11001001b ^ 11101100b = 00100101b
-11001001b ^ 11101101b = 00100100b
-11001001b ^ 11101110b = 00100111b
-11001001b ^ 11101111b = 00100110b
-11001001b ^ 11110000b = 00111001b
-11001001b ^ 11110001b = 00111000b
-11001001b ^ 11110010b = 00111011b
-11001001b ^ 11110011b = 00111010b
-11001001b ^ 11110100b = 00111101b
-11001001b ^ 11110101b = 00111100b
-11001001b ^ 11110110b = 00111111b
-11001001b ^ 11110111b = 00111110b
-11001001b ^ 11111000b = 00110001b
-11001001b ^ 11111001b = 00110000b
-11001001b ^ 11111010b = 00110011b
-11001001b ^ 11111011b = 00110010b
-11001001b ^ 11111100b = 00110101b
-11001001b ^ 11111101b = 00110100b
-11001001b ^ 11111110b = 00110111b
-11001001b ^ 11111111b = 00110110b
-11001001b ^ 00000000b = 11001001b
-11001001b ^ 00000001b = 11001000b
-11001001b ^ 00000010b = 11001011b
-11001001b ^ 00000011b = 11001010b
-11001001b ^ 00000100b = 11001101b
-11001001b ^ 00000101b = 11001100b
-11001001b ^ 00000110b = 11001111b
-11001001b ^ 00000111b = 11001110b
-11001001b ^ 00001000b = 11000001b
-11001001b ^ 00001001b = 11000000b
-11001001b ^ 00001010b = 11000011b
-11001001b ^ 00001011b = 11000010b
-11001001b ^ 00001100b = 11000101b
-11001001b ^ 00001101b = 11000100b
-11001001b ^ 00001110b = 11000111b
-11001001b ^ 00001111b = 11000110b
-11001001b ^ 00010000b = 11011001b
-11001001b ^ 00010001b = 11011000b
-11001001b ^ 00010010b = 11011011b
-11001001b ^ 00010011b = 11011010b
-11001001b ^ 00010100b = 11011101b
-11001001b ^ 00010101b = 11011100b
-11001001b ^ 00010110b = 11011111b
-11001001b ^ 00010111b = 11011110b
-11001001b ^ 00011000b = 11010001b
-11001001b ^ 00011001b = 11010000b
-11001001b ^ 00011010b = 11010011b
-11001001b ^ 00011011b = 11010010b
-11001001b ^ 00011100b = 11010101b
-11001001b ^ 00011101b = 11010100b
-11001001b ^ 00011110b = 11010111b
-11001001b ^ 00011111b = 11010110b
-11001001b ^ 00100000b = 11101001b
-11001001b ^ 00100001b = 11101000b
-11001001b ^ 00100010b = 11101011b
-11001001b ^ 00100011b = 11101010b
-11001001b ^ 00100100b = 11101101b
-11001001b ^ 00100101b = 11101100b
-11001001b ^ 00100110b = 11101111b
-11001001b ^ 00100111b = 11101110b
-11001001b ^ 00101000b = 11100001b
-11001001b ^ 00101001b = 11100000b
-11001001b ^ 00101010b = 11100011b
-11001001b ^ 00101011b = 11100010b
-11001001b ^ 00101100b = 11100101b
-11001001b ^ 00101101b = 11100100b
-11001001b ^ 00101110b = 11100111b
-11001001b ^ 00101111b = 11100110b
-11001001b ^ 00110000b = 11111001b
-11001001b ^ 00110001b = 11111000b
-11001001b ^ 00110010b = 11111011b
-11001001b ^ 00110011b = 11111010b
-11001001b ^ 00110100b = 11111101b
-11001001b ^ 00110101b = 11111100b
-11001001b ^ 00110110b = 11111111b
-11001001b ^ 00110111b = 11111110b
-11001001b ^ 00111000b = 11110001b
-11001001b ^ 00111001b = 11110000b
-11001001b ^ 00111010b = 11110011b
-11001001b ^ 00111011b = 11110010b
-11001001b ^ 00111100b = 11110101b
-11001001b ^ 00111101b = 11110100b
-11001001b ^ 00111110b = 11110111b
-11001001b ^ 00111111b = 11110110b
-11001001b ^ 01000000b = 10001001b
-11001001b ^ 01000001b = 10001000b
-11001001b ^ 01000010b = 10001011b
-11001001b ^ 01000011b = 10001010b
-11001001b ^ 01000100b = 10001101b
-11001001b ^ 01000101b = 10001100b
-11001001b ^ 01000110b = 10001111b
-11001001b ^ 01000111b = 10001110b
-11001001b ^ 01001000b = 10000001b
-11001001b ^ 01001001b = 10000000b
-11001001b ^ 01001010b = 10000011b
-11001001b ^ 01001011b = 10000010b
-11001001b ^ 01001100b = 10000101b
-11001001b ^ 01001101b = 10000100b
-11001001b ^ 01001110b = 10000111b
-11001001b ^ 01001111b = 10000110b
-11001001b ^ 01010000b = 10011001b
-11001001b ^ 01010001b = 10011000b
-11001001b ^ 01010010b = 10011011b
-11001001b ^ 01010011b = 10011010b
-11001001b ^ 01010100b = 10011101b
-11001001b ^ 01010101b = 10011100b
-11001001b ^ 01010110b = 10011111b
-11001001b ^ 01010111b = 10011110b
-11001001b ^ 01011000b = 10010001b
-11001001b ^ 01011001b = 10010000b
-11001001b ^ 01011010b = 10010011b
-11001001b ^ 01011011b = 10010010b
-11001001b ^ 01011100b = 10010101b
-11001001b ^ 01011101b = 10010100b
-11001001b ^ 01011110b = 10010111b
-11001001b ^ 01011111b = 10010110b
-11001001b ^ 01100000b = 10101001b
-11001001b ^ 01100001b = 10101000b
-11001001b ^ 01100010b = 10101011b
-11001001b ^ 01100011b = 10101010b
-11001001b ^ 01100100b = 10101101b
-11001001b ^ 01100101b = 10101100b
-11001001b ^ 01100110b = 10101111b
-11001001b ^ 01100111b = 10101110b
-11001001b ^ 01101000b = 10100001b
-11001001b ^ 01101001b = 10100000b
-11001001b ^ 01101010b = 10100011b
-11001001b ^ 01101011b = 10100010b
-11001001b ^ 01101100b = 10100101b
-11001001b ^ 01101101b = 10100100b
-11001001b ^ 01101110b = 10100111b
-11001001b ^ 01101111b = 10100110b
-11001001b ^ 01110000b = 10111001b
-11001001b ^ 01110001b = 10111000b
-11001001b ^ 01110010b = 10111011b
-11001001b ^ 01110011b = 10111010b
-11001001b ^ 01110100b = 10111101b
-11001001b ^ 01110101b = 10111100b
-11001001b ^ 01110110b = 10111111b
-11001001b ^ 01110111b = 10111110b
-11001001b ^ 01111000b = 10110001b
-11001001b ^ 01111001b = 10110000b
-11001001b ^ 01111010b = 10110011b
-11001001b ^ 01111011b = 10110010b
-11001001b ^ 01111100b = 10110101b
-11001001b ^ 01111101b = 10110100b
-11001001b ^ 01111110b = 10110111b
-11001010b ^ 10000000b = 01001010b
-11001010b ^ 10000001b = 01001011b
-11001010b ^ 10000010b = 01001000b
-11001010b ^ 10000011b = 01001001b
-11001010b ^ 10000100b = 01001110b
-11001010b ^ 10000101b = 01001111b
-11001010b ^ 10000110b = 01001100b
-11001010b ^ 10000111b = 01001101b
-11001010b ^ 10001000b = 01000010b
-11001010b ^ 10001001b = 01000011b
-11001010b ^ 10001010b = 01000000b
-11001010b ^ 10001011b = 01000001b
-11001010b ^ 10001100b = 01000110b
-11001010b ^ 10001101b = 01000111b
-11001010b ^ 10001110b = 01000100b
-11001010b ^ 10001111b = 01000101b
-11001010b ^ 10010000b = 01011010b
-11001010b ^ 10010001b = 01011011b
-11001010b ^ 10010010b = 01011000b
-11001010b ^ 10010011b = 01011001b
-11001010b ^ 10010100b = 01011110b
-11001010b ^ 10010101b = 01011111b
-11001010b ^ 10010110b = 01011100b
-11001010b ^ 10010111b = 01011101b
-11001010b ^ 10011000b = 01010010b
-11001010b ^ 10011001b = 01010011b
-11001010b ^ 10011010b = 01010000b
-11001010b ^ 10011011b = 01010001b
-11001010b ^ 10011100b = 01010110b
-11001010b ^ 10011101b = 01010111b
-11001010b ^ 10011110b = 01010100b
-11001010b ^ 10011111b = 01010101b
-11001010b ^ 10100000b = 01101010b
-11001010b ^ 10100001b = 01101011b
-11001010b ^ 10100010b = 01101000b
-11001010b ^ 10100011b = 01101001b
-11001010b ^ 10100100b = 01101110b
-11001010b ^ 10100101b = 01101111b
-11001010b ^ 10100110b = 01101100b
-11001010b ^ 10100111b = 01101101b
-11001010b ^ 10101000b = 01100010b
-11001010b ^ 10101001b = 01100011b
-11001010b ^ 10101010b = 01100000b
-11001010b ^ 10101011b = 01100001b
-11001010b ^ 10101100b = 01100110b
-11001010b ^ 10101101b = 01100111b
-11001010b ^ 10101110b = 01100100b
-11001010b ^ 10101111b = 01100101b
-11001010b ^ 10110000b = 01111010b
-11001010b ^ 10110001b = 01111011b
-11001010b ^ 10110010b = 01111000b
-11001010b ^ 10110011b = 01111001b
-11001010b ^ 10110100b = 01111110b
-11001010b ^ 10110101b = 01111111b
-11001010b ^ 10110110b = 01111100b
-11001010b ^ 10110111b = 01111101b
-11001010b ^ 10111000b = 01110010b
-11001010b ^ 10111001b = 01110011b
-11001010b ^ 10111010b = 01110000b
-11001010b ^ 10111011b = 01110001b
-11001010b ^ 10111100b = 01110110b
-11001010b ^ 10111101b = 01110111b
-11001010b ^ 10111110b = 01110100b
-11001010b ^ 10111111b = 01110101b
-11001010b ^ 11000000b = 00001010b
-11001010b ^ 11000001b = 00001011b
-11001010b ^ 11000010b = 00001000b
-11001010b ^ 11000011b = 00001001b
-11001010b ^ 11000100b = 00001110b
-11001010b ^ 11000101b = 00001111b
-11001010b ^ 11000110b = 00001100b
-11001010b ^ 11000111b = 00001101b
-11001010b ^ 11001000b = 00000010b
-11001010b ^ 11001001b = 00000011b
-11001010b ^ 11001010b = 00000000b
-11001010b ^ 11001011b = 00000001b
-11001010b ^ 11001100b = 00000110b
-11001010b ^ 11001101b = 00000111b
-11001010b ^ 11001110b = 00000100b
-11001010b ^ 11001111b = 00000101b
-11001010b ^ 11010000b = 00011010b
-11001010b ^ 11010001b = 00011011b
-11001010b ^ 11010010b = 00011000b
-11001010b ^ 11010011b = 00011001b
-11001010b ^ 11010100b = 00011110b
-11001010b ^ 11010101b = 00011111b
-11001010b ^ 11010110b = 00011100b
-11001010b ^ 11010111b = 00011101b
-11001010b ^ 11011000b = 00010010b
-11001010b ^ 11011001b = 00010011b
-11001010b ^ 11011010b = 00010000b
-11001010b ^ 11011011b = 00010001b
-11001010b ^ 11011100b = 00010110b
-11001010b ^ 11011101b = 00010111b
-11001010b ^ 11011110b = 00010100b
-11001010b ^ 11011111b = 00010101b
-11001010b ^ 11100000b = 00101010b
-11001010b ^ 11100001b = 00101011b
-11001010b ^ 11100010b = 00101000b
-11001010b ^ 11100011b = 00101001b
-11001010b ^ 11100100b = 00101110b
-11001010b ^ 11100101b = 00101111b
-11001010b ^ 11100110b = 00101100b
-11001010b ^ 11100111b = 00101101b
-11001010b ^ 11101000b = 00100010b
-11001010b ^ 11101001b = 00100011b
-11001010b ^ 11101010b = 00100000b
-11001010b ^ 11101011b = 00100001b
-11001010b ^ 11101100b = 00100110b
-11001010b ^ 11101101b = 00100111b
-11001010b ^ 11101110b = 00100100b
-11001010b ^ 11101111b = 00100101b
-11001010b ^ 11110000b = 00111010b
-11001010b ^ 11110001b = 00111011b
-11001010b ^ 11110010b = 00111000b
-11001010b ^ 11110011b = 00111001b
-11001010b ^ 11110100b = 00111110b
-11001010b ^ 11110101b = 00111111b
-11001010b ^ 11110110b = 00111100b
-11001010b ^ 11110111b = 00111101b
-11001010b ^ 11111000b = 00110010b
-11001010b ^ 11111001b = 00110011b
-11001010b ^ 11111010b = 00110000b
-11001010b ^ 11111011b = 00110001b
-11001010b ^ 11111100b = 00110110b
-11001010b ^ 11111101b = 00110111b
-11001010b ^ 11111110b = 00110100b
-11001010b ^ 11111111b = 00110101b
-11001010b ^ 00000000b = 11001010b
-11001010b ^ 00000001b = 11001011b
-11001010b ^ 00000010b = 11001000b
-11001010b ^ 00000011b = 11001001b
-11001010b ^ 00000100b = 11001110b
-11001010b ^ 00000101b = 11001111b
-11001010b ^ 00000110b = 11001100b
-11001010b ^ 00000111b = 11001101b
-11001010b ^ 00001000b = 11000010b
-11001010b ^ 00001001b = 11000011b
-11001010b ^ 00001010b = 11000000b
-11001010b ^ 00001011b = 11000001b
-11001010b ^ 00001100b = 11000110b
-11001010b ^ 00001101b = 11000111b
-11001010b ^ 00001110b = 11000100b
-11001010b ^ 00001111b = 11000101b
-11001010b ^ 00010000b = 11011010b
-11001010b ^ 00010001b = 11011011b
-11001010b ^ 00010010b = 11011000b
-11001010b ^ 00010011b = 11011001b
-11001010b ^ 00010100b = 11011110b
-11001010b ^ 00010101b = 11011111b
-11001010b ^ 00010110b = 11011100b
-11001010b ^ 00010111b = 11011101b
-11001010b ^ 00011000b = 11010010b
-11001010b ^ 00011001b = 11010011b
-11001010b ^ 00011010b = 11010000b
-11001010b ^ 00011011b = 11010001b
-11001010b ^ 00011100b = 11010110b
-11001010b ^ 00011101b = 11010111b
-11001010b ^ 00011110b = 11010100b
-11001010b ^ 00011111b = 11010101b
-11001010b ^ 00100000b = 11101010b
-11001010b ^ 00100001b = 11101011b
-11001010b ^ 00100010b = 11101000b
-11001010b ^ 00100011b = 11101001b
-11001010b ^ 00100100b = 11101110b
-11001010b ^ 00100101b = 11101111b
-11001010b ^ 00100110b = 11101100b
-11001010b ^ 00100111b = 11101101b
-11001010b ^ 00101000b = 11100010b
-11001010b ^ 00101001b = 11100011b
-11001010b ^ 00101010b = 11100000b
-11001010b ^ 00101011b = 11100001b
-11001010b ^ 00101100b = 11100110b
-11001010b ^ 00101101b = 11100111b
-11001010b ^ 00101110b = 11100100b
-11001010b ^ 00101111b = 11100101b
-11001010b ^ 00110000b = 11111010b
-11001010b ^ 00110001b = 11111011b
-11001010b ^ 00110010b = 11111000b
-11001010b ^ 00110011b = 11111001b
-11001010b ^ 00110100b = 11111110b
-11001010b ^ 00110101b = 11111111b
-11001010b ^ 00110110b = 11111100b
-11001010b ^ 00110111b = 11111101b
-11001010b ^ 00111000b = 11110010b
-11001010b ^ 00111001b = 11110011b
-11001010b ^ 00111010b = 11110000b
-11001010b ^ 00111011b = 11110001b
-11001010b ^ 00111100b = 11110110b
-11001010b ^ 00111101b = 11110111b
-11001010b ^ 00111110b = 11110100b
-11001010b ^ 00111111b = 11110101b
-11001010b ^ 01000000b = 10001010b
-11001010b ^ 01000001b = 10001011b
-11001010b ^ 01000010b = 10001000b
-11001010b ^ 01000011b = 10001001b
-11001010b ^ 01000100b = 10001110b
-11001010b ^ 01000101b = 10001111b
-11001010b ^ 01000110b = 10001100b
-11001010b ^ 01000111b = 10001101b
-11001010b ^ 01001000b = 10000010b
-11001010b ^ 01001001b = 10000011b
-11001010b ^ 01001010b = 10000000b
-11001010b ^ 01001011b = 10000001b
-11001010b ^ 01001100b = 10000110b
-11001010b ^ 01001101b = 10000111b
-11001010b ^ 01001110b = 10000100b
-11001010b ^ 01001111b = 10000101b
-11001010b ^ 01010000b = 10011010b
-11001010b ^ 01010001b = 10011011b
-11001010b ^ 01010010b = 10011000b
-11001010b ^ 01010011b = 10011001b
-11001010b ^ 01010100b = 10011110b
-11001010b ^ 01010101b = 10011111b
-11001010b ^ 01010110b = 10011100b
-11001010b ^ 01010111b = 10011101b
-11001010b ^ 01011000b = 10010010b
-11001010b ^ 01011001b = 10010011b
-11001010b ^ 01011010b = 10010000b
-11001010b ^ 01011011b = 10010001b
-11001010b ^ 01011100b = 10010110b
-11001010b ^ 01011101b = 10010111b
-11001010b ^ 01011110b = 10010100b
-11001010b ^ 01011111b = 10010101b
-11001010b ^ 01100000b = 10101010b
-11001010b ^ 01100001b = 10101011b
-11001010b ^ 01100010b = 10101000b
-11001010b ^ 01100011b = 10101001b
-11001010b ^ 01100100b = 10101110b
-11001010b ^ 01100101b = 10101111b
-11001010b ^ 01100110b = 10101100b
-11001010b ^ 01100111b = 10101101b
-11001010b ^ 01101000b = 10100010b
-11001010b ^ 01101001b = 10100011b
-11001010b ^ 01101010b = 10100000b
-11001010b ^ 01101011b = 10100001b
-11001010b ^ 01101100b = 10100110b
-11001010b ^ 01101101b = 10100111b
-11001010b ^ 01101110b = 10100100b
-11001010b ^ 01101111b = 10100101b
-11001010b ^ 01110000b = 10111010b
-11001010b ^ 01110001b = 10111011b
-11001010b ^ 01110010b = 10111000b
-11001010b ^ 01110011b = 10111001b
-11001010b ^ 01110100b = 10111110b
-11001010b ^ 01110101b = 10111111b
-11001010b ^ 01110110b = 10111100b
-11001010b ^ 01110111b = 10111101b
-11001010b ^ 01111000b = 10110010b
-11001010b ^ 01111001b = 10110011b
-11001010b ^ 01111010b = 10110000b
-11001010b ^ 01111011b = 10110001b
-11001010b ^ 01111100b = 10110110b
-11001010b ^ 01111101b = 10110111b
-11001010b ^ 01111110b = 10110100b
-11001011b ^ 10000000b = 01001011b
-11001011b ^ 10000001b = 01001010b
-11001011b ^ 10000010b = 01001001b
-11001011b ^ 10000011b = 01001000b
-11001011b ^ 10000100b = 01001111b
-11001011b ^ 10000101b = 01001110b
-11001011b ^ 10000110b = 01001101b
-11001011b ^ 10000111b = 01001100b
-11001011b ^ 10001000b = 01000011b
-11001011b ^ 10001001b = 01000010b
-11001011b ^ 10001010b = 01000001b
-11001011b ^ 10001011b = 01000000b
-11001011b ^ 10001100b = 01000111b
-11001011b ^ 10001101b = 01000110b
-11001011b ^ 10001110b = 01000101b
-11001011b ^ 10001111b = 01000100b
-11001011b ^ 10010000b = 01011011b
-11001011b ^ 10010001b = 01011010b
-11001011b ^ 10010010b = 01011001b
-11001011b ^ 10010011b = 01011000b
-11001011b ^ 10010100b = 01011111b
-11001011b ^ 10010101b = 01011110b
-11001011b ^ 10010110b = 01011101b
-11001011b ^ 10010111b = 01011100b
-11001011b ^ 10011000b = 01010011b
-11001011b ^ 10011001b = 01010010b
-11001011b ^ 10011010b = 01010001b
-11001011b ^ 10011011b = 01010000b
-11001011b ^ 10011100b = 01010111b
-11001011b ^ 10011101b = 01010110b
-11001011b ^ 10011110b = 01010101b
-11001011b ^ 10011111b = 01010100b
-11001011b ^ 10100000b = 01101011b
-11001011b ^ 10100001b = 01101010b
-11001011b ^ 10100010b = 01101001b
-11001011b ^ 10100011b = 01101000b
-11001011b ^ 10100100b = 01101111b
-11001011b ^ 10100101b = 01101110b
-11001011b ^ 10100110b = 01101101b
-11001011b ^ 10100111b = 01101100b
-11001011b ^ 10101000b = 01100011b
-11001011b ^ 10101001b = 01100010b
-11001011b ^ 10101010b = 01100001b
-11001011b ^ 10101011b = 01100000b
-11001011b ^ 10101100b = 01100111b
-11001011b ^ 10101101b = 01100110b
-11001011b ^ 10101110b = 01100101b
-11001011b ^ 10101111b = 01100100b
-11001011b ^ 10110000b = 01111011b
-11001011b ^ 10110001b = 01111010b
-11001011b ^ 10110010b = 01111001b
-11001011b ^ 10110011b = 01111000b
-11001011b ^ 10110100b = 01111111b
-11001011b ^ 10110101b = 01111110b
-11001011b ^ 10110110b = 01111101b
-11001011b ^ 10110111b = 01111100b
-11001011b ^ 10111000b = 01110011b
-11001011b ^ 10111001b = 01110010b
-11001011b ^ 10111010b = 01110001b
-11001011b ^ 10111011b = 01110000b
-11001011b ^ 10111100b = 01110111b
-11001011b ^ 10111101b = 01110110b
-11001011b ^ 10111110b = 01110101b
-11001011b ^ 10111111b = 01110100b
-11001011b ^ 11000000b = 00001011b
-11001011b ^ 11000001b = 00001010b
-11001011b ^ 11000010b = 00001001b
-11001011b ^ 11000011b = 00001000b
-11001011b ^ 11000100b = 00001111b
-11001011b ^ 11000101b = 00001110b
-11001011b ^ 11000110b = 00001101b
-11001011b ^ 11000111b = 00001100b
-11001011b ^ 11001000b = 00000011b
-11001011b ^ 11001001b = 00000010b
-11001011b ^ 11001010b = 00000001b
-11001011b ^ 11001011b = 00000000b
-11001011b ^ 11001100b = 00000111b
-11001011b ^ 11001101b = 00000110b
-11001011b ^ 11001110b = 00000101b
-11001011b ^ 11001111b = 00000100b
-11001011b ^ 11010000b = 00011011b
-11001011b ^ 11010001b = 00011010b
-11001011b ^ 11010010b = 00011001b
-11001011b ^ 11010011b = 00011000b
-11001011b ^ 11010100b = 00011111b
-11001011b ^ 11010101b = 00011110b
-11001011b ^ 11010110b = 00011101b
-11001011b ^ 11010111b = 00011100b
-11001011b ^ 11011000b = 00010011b
-11001011b ^ 11011001b = 00010010b
-11001011b ^ 11011010b = 00010001b
-11001011b ^ 11011011b = 00010000b
-11001011b ^ 11011100b = 00010111b
-11001011b ^ 11011101b = 00010110b
-11001011b ^ 11011110b = 00010101b
-11001011b ^ 11011111b = 00010100b
-11001011b ^ 11100000b = 00101011b
-11001011b ^ 11100001b = 00101010b
-11001011b ^ 11100010b = 00101001b
-11001011b ^ 11100011b = 00101000b
-11001011b ^ 11100100b = 00101111b
-11001011b ^ 11100101b = 00101110b
-11001011b ^ 11100110b = 00101101b
-11001011b ^ 11100111b = 00101100b
-11001011b ^ 11101000b = 00100011b
-11001011b ^ 11101001b = 00100010b
-11001011b ^ 11101010b = 00100001b
-11001011b ^ 11101011b = 00100000b
-11001011b ^ 11101100b = 00100111b
-11001011b ^ 11101101b = 00100110b
-11001011b ^ 11101110b = 00100101b
-11001011b ^ 11101111b = 00100100b
-11001011b ^ 11110000b = 00111011b
-11001011b ^ 11110001b = 00111010b
-11001011b ^ 11110010b = 00111001b
-11001011b ^ 11110011b = 00111000b
-11001011b ^ 11110100b = 00111111b
-11001011b ^ 11110101b = 00111110b
-11001011b ^ 11110110b = 00111101b
-11001011b ^ 11110111b = 00111100b
-11001011b ^ 11111000b = 00110011b
-11001011b ^ 11111001b = 00110010b
-11001011b ^ 11111010b = 00110001b
-11001011b ^ 11111011b = 00110000b
-11001011b ^ 11111100b = 00110111b
-11001011b ^ 11111101b = 00110110b
-11001011b ^ 11111110b = 00110101b
-11001011b ^ 11111111b = 00110100b
-11001011b ^ 00000000b = 11001011b
-11001011b ^ 00000001b = 11001010b
-11001011b ^ 00000010b = 11001001b
-11001011b ^ 00000011b = 11001000b
-11001011b ^ 00000100b = 11001111b
-11001011b ^ 00000101b = 11001110b
-11001011b ^ 00000110b = 11001101b
-11001011b ^ 00000111b = 11001100b
-11001011b ^ 00001000b = 11000011b
-11001011b ^ 00001001b = 11000010b
-11001011b ^ 00001010b = 11000001b
-11001011b ^ 00001011b = 11000000b
-11001011b ^ 00001100b = 11000111b
-11001011b ^ 00001101b = 11000110b
-11001011b ^ 00001110b = 11000101b
-11001011b ^ 00001111b = 11000100b
-11001011b ^ 00010000b = 11011011b
-11001011b ^ 00010001b = 11011010b
-11001011b ^ 00010010b = 11011001b
-11001011b ^ 00010011b = 11011000b
-11001011b ^ 00010100b = 11011111b
-11001011b ^ 00010101b = 11011110b
-11001011b ^ 00010110b = 11011101b
-11001011b ^ 00010111b = 11011100b
-11001011b ^ 00011000b = 11010011b
-11001011b ^ 00011001b = 11010010b
-11001011b ^ 00011010b = 11010001b
-11001011b ^ 00011011b = 11010000b
-11001011b ^ 00011100b = 11010111b
-11001011b ^ 00011101b = 11010110b
-11001011b ^ 00011110b = 11010101b
-11001011b ^ 00011111b = 11010100b
-11001011b ^ 00100000b = 11101011b
-11001011b ^ 00100001b = 11101010b
-11001011b ^ 00100010b = 11101001b
-11001011b ^ 00100011b = 11101000b
-11001011b ^ 00100100b = 11101111b
-11001011b ^ 00100101b = 11101110b
-11001011b ^ 00100110b = 11101101b
-11001011b ^ 00100111b = 11101100b
-11001011b ^ 00101000b = 11100011b
-11001011b ^ 00101001b = 11100010b
-11001011b ^ 00101010b = 11100001b
-11001011b ^ 00101011b = 11100000b
-11001011b ^ 00101100b = 11100111b
-11001011b ^ 00101101b = 11100110b
-11001011b ^ 00101110b = 11100101b
-11001011b ^ 00101111b = 11100100b
-11001011b ^ 00110000b = 11111011b
-11001011b ^ 00110001b = 11111010b
-11001011b ^ 00110010b = 11111001b
-11001011b ^ 00110011b = 11111000b
-11001011b ^ 00110100b = 11111111b
-11001011b ^ 00110101b = 11111110b
-11001011b ^ 00110110b = 11111101b
-11001011b ^ 00110111b = 11111100b
-11001011b ^ 00111000b = 11110011b
-11001011b ^ 00111001b = 11110010b
-11001011b ^ 00111010b = 11110001b
-11001011b ^ 00111011b = 11110000b
-11001011b ^ 00111100b = 11110111b
-11001011b ^ 00111101b = 11110110b
-11001011b ^ 00111110b = 11110101b
-11001011b ^ 00111111b = 11110100b
-11001011b ^ 01000000b = 10001011b
-11001011b ^ 01000001b = 10001010b
-11001011b ^ 01000010b = 10001001b
-11001011b ^ 01000011b = 10001000b
-11001011b ^ 01000100b = 10001111b
-11001011b ^ 01000101b = 10001110b
-11001011b ^ 01000110b = 10001101b
-11001011b ^ 01000111b = 10001100b
-11001011b ^ 01001000b = 10000011b
-11001011b ^ 01001001b = 10000010b
-11001011b ^ 01001010b = 10000001b
-11001011b ^ 01001011b = 10000000b
-11001011b ^ 01001100b = 10000111b
-11001011b ^ 01001101b = 10000110b
-11001011b ^ 01001110b = 10000101b
-11001011b ^ 01001111b = 10000100b
-11001011b ^ 01010000b = 10011011b
-11001011b ^ 01010001b = 10011010b
-11001011b ^ 01010010b = 10011001b
-11001011b ^ 01010011b = 10011000b
-11001011b ^ 01010100b = 10011111b
-11001011b ^ 01010101b = 10011110b
-11001011b ^ 01010110b = 10011101b
-11001011b ^ 01010111b = 10011100b
-11001011b ^ 01011000b = 10010011b
-11001011b ^ 01011001b = 10010010b
-11001011b ^ 01011010b = 10010001b
-11001011b ^ 01011011b = 10010000b
-11001011b ^ 01011100b = 10010111b
-11001011b ^ 01011101b = 10010110b
-11001011b ^ 01011110b = 10010101b
-11001011b ^ 01011111b = 10010100b
-11001011b ^ 01100000b = 10101011b
-11001011b ^ 01100001b = 10101010b
-11001011b ^ 01100010b = 10101001b
-11001011b ^ 01100011b = 10101000b
-11001011b ^ 01100100b = 10101111b
-11001011b ^ 01100101b = 10101110b
-11001011b ^ 01100110b = 10101101b
-11001011b ^ 01100111b = 10101100b
-11001011b ^ 01101000b = 10100011b
-11001011b ^ 01101001b = 10100010b
-11001011b ^ 01101010b = 10100001b
-11001011b ^ 01101011b = 10100000b
-11001011b ^ 01101100b = 10100111b
-11001011b ^ 01101101b = 10100110b
-11001011b ^ 01101110b = 10100101b
-11001011b ^ 01101111b = 10100100b
-11001011b ^ 01110000b = 10111011b
-11001011b ^ 01110001b = 10111010b
-11001011b ^ 01110010b = 10111001b
-11001011b ^ 01110011b = 10111000b
-11001011b ^ 01110100b = 10111111b
-11001011b ^ 01110101b = 10111110b
-11001011b ^ 01110110b = 10111101b
-11001011b ^ 01110111b = 10111100b
-11001011b ^ 01111000b = 10110011b
-11001011b ^ 01111001b = 10110010b
-11001011b ^ 01111010b = 10110001b
-11001011b ^ 01111011b = 10110000b
-11001011b ^ 01111100b = 10110111b
-11001011b ^ 01111101b = 10110110b
-11001011b ^ 01111110b = 10110101b
-11001100b ^ 10000000b = 01001100b
-11001100b ^ 10000001b = 01001101b
-11001100b ^ 10000010b = 01001110b
-11001100b ^ 10000011b = 01001111b
-11001100b ^ 10000100b = 01001000b
-11001100b ^ 10000101b = 01001001b
-11001100b ^ 10000110b = 01001010b
-11001100b ^ 10000111b = 01001011b
-11001100b ^ 10001000b = 01000100b
-11001100b ^ 10001001b = 01000101b
-11001100b ^ 10001010b = 01000110b
-11001100b ^ 10001011b = 01000111b
-11001100b ^ 10001100b = 01000000b
-11001100b ^ 10001101b = 01000001b
-11001100b ^ 10001110b = 01000010b
-11001100b ^ 10001111b = 01000011b
-11001100b ^ 10010000b = 01011100b
-11001100b ^ 10010001b = 01011101b
-11001100b ^ 10010010b = 01011110b
-11001100b ^ 10010011b = 01011111b
-11001100b ^ 10010100b = 01011000b
-11001100b ^ 10010101b = 01011001b
-11001100b ^ 10010110b = 01011010b
-11001100b ^ 10010111b = 01011011b
-11001100b ^ 10011000b = 01010100b
-11001100b ^ 10011001b = 01010101b
-11001100b ^ 10011010b = 01010110b
-11001100b ^ 10011011b = 01010111b
-11001100b ^ 10011100b = 01010000b
-11001100b ^ 10011101b = 01010001b
-11001100b ^ 10011110b = 01010010b
-11001100b ^ 10011111b = 01010011b
-11001100b ^ 10100000b = 01101100b
-11001100b ^ 10100001b = 01101101b
-11001100b ^ 10100010b = 01101110b
-11001100b ^ 10100011b = 01101111b
-11001100b ^ 10100100b = 01101000b
-11001100b ^ 10100101b = 01101001b
-11001100b ^ 10100110b = 01101010b
-11001100b ^ 10100111b = 01101011b
-11001100b ^ 10101000b = 01100100b
-11001100b ^ 10101001b = 01100101b
-11001100b ^ 10101010b = 01100110b
-11001100b ^ 10101011b = 01100111b
-11001100b ^ 10101100b = 01100000b
-11001100b ^ 10101101b = 01100001b
-11001100b ^ 10101110b = 01100010b
-11001100b ^ 10101111b = 01100011b
-11001100b ^ 10110000b = 01111100b
-11001100b ^ 10110001b = 01111101b
-11001100b ^ 10110010b = 01111110b
-11001100b ^ 10110011b = 01111111b
-11001100b ^ 10110100b = 01111000b
-11001100b ^ 10110101b = 01111001b
-11001100b ^ 10110110b = 01111010b
-11001100b ^ 10110111b = 01111011b
-11001100b ^ 10111000b = 01110100b
-11001100b ^ 10111001b = 01110101b
-11001100b ^ 10111010b = 01110110b
-11001100b ^ 10111011b = 01110111b
-11001100b ^ 10111100b = 01110000b
-11001100b ^ 10111101b = 01110001b
-11001100b ^ 10111110b = 01110010b
-11001100b ^ 10111111b = 01110011b
-11001100b ^ 11000000b = 00001100b
-11001100b ^ 11000001b = 00001101b
-11001100b ^ 11000010b = 00001110b
-11001100b ^ 11000011b = 00001111b
-11001100b ^ 11000100b = 00001000b
-11001100b ^ 11000101b = 00001001b
-11001100b ^ 11000110b = 00001010b
-11001100b ^ 11000111b = 00001011b
-11001100b ^ 11001000b = 00000100b
-11001100b ^ 11001001b = 00000101b
-11001100b ^ 11001010b = 00000110b
-11001100b ^ 11001011b = 00000111b
-11001100b ^ 11001100b = 00000000b
-11001100b ^ 11001101b = 00000001b
-11001100b ^ 11001110b = 00000010b
-11001100b ^ 11001111b = 00000011b
-11001100b ^ 11010000b = 00011100b
-11001100b ^ 11010001b = 00011101b
-11001100b ^ 11010010b = 00011110b
-11001100b ^ 11010011b = 00011111b
-11001100b ^ 11010100b = 00011000b
-11001100b ^ 11010101b = 00011001b
-11001100b ^ 11010110b = 00011010b
-11001100b ^ 11010111b = 00011011b
-11001100b ^ 11011000b = 00010100b
-11001100b ^ 11011001b = 00010101b
-11001100b ^ 11011010b = 00010110b
-11001100b ^ 11011011b = 00010111b
-11001100b ^ 11011100b = 00010000b
-11001100b ^ 11011101b = 00010001b
-11001100b ^ 11011110b = 00010010b
-11001100b ^ 11011111b = 00010011b
-11001100b ^ 11100000b = 00101100b
-11001100b ^ 11100001b = 00101101b
-11001100b ^ 11100010b = 00101110b
-11001100b ^ 11100011b = 00101111b
-11001100b ^ 11100100b = 00101000b
-11001100b ^ 11100101b = 00101001b
-11001100b ^ 11100110b = 00101010b
-11001100b ^ 11100111b = 00101011b
-11001100b ^ 11101000b = 00100100b
-11001100b ^ 11101001b = 00100101b
-11001100b ^ 11101010b = 00100110b
-11001100b ^ 11101011b = 00100111b
-11001100b ^ 11101100b = 00100000b
-11001100b ^ 11101101b = 00100001b
-11001100b ^ 11101110b = 00100010b
-11001100b ^ 11101111b = 00100011b
-11001100b ^ 11110000b = 00111100b
-11001100b ^ 11110001b = 00111101b
-11001100b ^ 11110010b = 00111110b
-11001100b ^ 11110011b = 00111111b
-11001100b ^ 11110100b = 00111000b
-11001100b ^ 11110101b = 00111001b
-11001100b ^ 11110110b = 00111010b
-11001100b ^ 11110111b = 00111011b
-11001100b ^ 11111000b = 00110100b
-11001100b ^ 11111001b = 00110101b
-11001100b ^ 11111010b = 00110110b
-11001100b ^ 11111011b = 00110111b
-11001100b ^ 11111100b = 00110000b
-11001100b ^ 11111101b = 00110001b
-11001100b ^ 11111110b = 00110010b
-11001100b ^ 11111111b = 00110011b
-11001100b ^ 00000000b = 11001100b
-11001100b ^ 00000001b = 11001101b
-11001100b ^ 00000010b = 11001110b
-11001100b ^ 00000011b = 11001111b
-11001100b ^ 00000100b = 11001000b
-11001100b ^ 00000101b = 11001001b
-11001100b ^ 00000110b = 11001010b
-11001100b ^ 00000111b = 11001011b
-11001100b ^ 00001000b = 11000100b
-11001100b ^ 00001001b = 11000101b
-11001100b ^ 00001010b = 11000110b
-11001100b ^ 00001011b = 11000111b
-11001100b ^ 00001100b = 11000000b
-11001100b ^ 00001101b = 11000001b
-11001100b ^ 00001110b = 11000010b
-11001100b ^ 00001111b = 11000011b
-11001100b ^ 00010000b = 11011100b
-11001100b ^ 00010001b = 11011101b
-11001100b ^ 00010010b = 11011110b
-11001100b ^ 00010011b = 11011111b
-11001100b ^ 00010100b = 11011000b
-11001100b ^ 00010101b = 11011001b
-11001100b ^ 00010110b = 11011010b
-11001100b ^ 00010111b = 11011011b
-11001100b ^ 00011000b = 11010100b
-11001100b ^ 00011001b = 11010101b
-11001100b ^ 00011010b = 11010110b
-11001100b ^ 00011011b = 11010111b
-11001100b ^ 00011100b = 11010000b
-11001100b ^ 00011101b = 11010001b
-11001100b ^ 00011110b = 11010010b
-11001100b ^ 00011111b = 11010011b
-11001100b ^ 00100000b = 11101100b
-11001100b ^ 00100001b = 11101101b
-11001100b ^ 00100010b = 11101110b
-11001100b ^ 00100011b = 11101111b
-11001100b ^ 00100100b = 11101000b
-11001100b ^ 00100101b = 11101001b
-11001100b ^ 00100110b = 11101010b
-11001100b ^ 00100111b = 11101011b
-11001100b ^ 00101000b = 11100100b
-11001100b ^ 00101001b = 11100101b
-11001100b ^ 00101010b = 11100110b
-11001100b ^ 00101011b = 11100111b
-11001100b ^ 00101100b = 11100000b
-11001100b ^ 00101101b = 11100001b
-11001100b ^ 00101110b = 11100010b
-11001100b ^ 00101111b = 11100011b
-11001100b ^ 00110000b = 11111100b
-11001100b ^ 00110001b = 11111101b
-11001100b ^ 00110010b = 11111110b
-11001100b ^ 00110011b = 11111111b
-11001100b ^ 00110100b = 11111000b
-11001100b ^ 00110101b = 11111001b
-11001100b ^ 00110110b = 11111010b
-11001100b ^ 00110111b = 11111011b
-11001100b ^ 00111000b = 11110100b
-11001100b ^ 00111001b = 11110101b
-11001100b ^ 00111010b = 11110110b
-11001100b ^ 00111011b = 11110111b
-11001100b ^ 00111100b = 11110000b
-11001100b ^ 00111101b = 11110001b
-11001100b ^ 00111110b = 11110010b
-11001100b ^ 00111111b = 11110011b
-11001100b ^ 01000000b = 10001100b
-11001100b ^ 01000001b = 10001101b
-11001100b ^ 01000010b = 10001110b
-11001100b ^ 01000011b = 10001111b
-11001100b ^ 01000100b = 10001000b
-11001100b ^ 01000101b = 10001001b
-11001100b ^ 01000110b = 10001010b
-11001100b ^ 01000111b = 10001011b
-11001100b ^ 01001000b = 10000100b
-11001100b ^ 01001001b = 10000101b
-11001100b ^ 01001010b = 10000110b
-11001100b ^ 01001011b = 10000111b
-11001100b ^ 01001100b = 10000000b
-11001100b ^ 01001101b = 10000001b
-11001100b ^ 01001110b = 10000010b
-11001100b ^ 01001111b = 10000011b
-11001100b ^ 01010000b = 10011100b
-11001100b ^ 01010001b = 10011101b
-11001100b ^ 01010010b = 10011110b
-11001100b ^ 01010011b = 10011111b
-11001100b ^ 01010100b = 10011000b
-11001100b ^ 01010101b = 10011001b
-11001100b ^ 01010110b = 10011010b
-11001100b ^ 01010111b = 10011011b
-11001100b ^ 01011000b = 10010100b
-11001100b ^ 01011001b = 10010101b
-11001100b ^ 01011010b = 10010110b
-11001100b ^ 01011011b = 10010111b
-11001100b ^ 01011100b = 10010000b
-11001100b ^ 01011101b = 10010001b
-11001100b ^ 01011110b = 10010010b
-11001100b ^ 01011111b = 10010011b
-11001100b ^ 01100000b = 10101100b
-11001100b ^ 01100001b = 10101101b
-11001100b ^ 01100010b = 10101110b
-11001100b ^ 01100011b = 10101111b
-11001100b ^ 01100100b = 10101000b
-11001100b ^ 01100101b = 10101001b
-11001100b ^ 01100110b = 10101010b
-11001100b ^ 01100111b = 10101011b
-11001100b ^ 01101000b = 10100100b
-11001100b ^ 01101001b = 10100101b
-11001100b ^ 01101010b = 10100110b
-11001100b ^ 01101011b = 10100111b
-11001100b ^ 01101100b = 10100000b
-11001100b ^ 01101101b = 10100001b
-11001100b ^ 01101110b = 10100010b
-11001100b ^ 01101111b = 10100011b
-11001100b ^ 01110000b = 10111100b
-11001100b ^ 01110001b = 10111101b
-11001100b ^ 01110010b = 10111110b
-11001100b ^ 01110011b = 10111111b
-11001100b ^ 01110100b = 10111000b
-11001100b ^ 01110101b = 10111001b
-11001100b ^ 01110110b = 10111010b
-11001100b ^ 01110111b = 10111011b
-11001100b ^ 01111000b = 10110100b
-11001100b ^ 01111001b = 10110101b
-11001100b ^ 01111010b = 10110110b
-11001100b ^ 01111011b = 10110111b
-11001100b ^ 01111100b = 10110000b
-11001100b ^ 01111101b = 10110001b
-11001100b ^ 01111110b = 10110010b
-11001101b ^ 10000000b = 01001101b
-11001101b ^ 10000001b = 01001100b
-11001101b ^ 10000010b = 01001111b
-11001101b ^ 10000011b = 01001110b
-11001101b ^ 10000100b = 01001001b
-11001101b ^ 10000101b = 01001000b
-11001101b ^ 10000110b = 01001011b
-11001101b ^ 10000111b = 01001010b
-11001101b ^ 10001000b = 01000101b
-11001101b ^ 10001001b = 01000100b
-11001101b ^ 10001010b = 01000111b
-11001101b ^ 10001011b = 01000110b
-11001101b ^ 10001100b = 01000001b
-11001101b ^ 10001101b = 01000000b
-11001101b ^ 10001110b = 01000011b
-11001101b ^ 10001111b = 01000010b
-11001101b ^ 10010000b = 01011101b
-11001101b ^ 10010001b = 01011100b
-11001101b ^ 10010010b = 01011111b
-11001101b ^ 10010011b = 01011110b
-11001101b ^ 10010100b = 01011001b
-11001101b ^ 10010101b = 01011000b
-11001101b ^ 10010110b = 01011011b
-11001101b ^ 10010111b = 01011010b
-11001101b ^ 10011000b = 01010101b
-11001101b ^ 10011001b = 01010100b
-11001101b ^ 10011010b = 01010111b
-11001101b ^ 10011011b = 01010110b
-11001101b ^ 10011100b = 01010001b
-11001101b ^ 10011101b = 01010000b
-11001101b ^ 10011110b = 01010011b
-11001101b ^ 10011111b = 01010010b
-11001101b ^ 10100000b = 01101101b
-11001101b ^ 10100001b = 01101100b
-11001101b ^ 10100010b = 01101111b
-11001101b ^ 10100011b = 01101110b
-11001101b ^ 10100100b = 01101001b
-11001101b ^ 10100101b = 01101000b
-11001101b ^ 10100110b = 01101011b
-11001101b ^ 10100111b = 01101010b
-11001101b ^ 10101000b = 01100101b
-11001101b ^ 10101001b = 01100100b
-11001101b ^ 10101010b = 01100111b
-11001101b ^ 10101011b = 01100110b
-11001101b ^ 10101100b = 01100001b
-11001101b ^ 10101101b = 01100000b
-11001101b ^ 10101110b = 01100011b
-11001101b ^ 10101111b = 01100010b
-11001101b ^ 10110000b = 01111101b
-11001101b ^ 10110001b = 01111100b
-11001101b ^ 10110010b = 01111111b
-11001101b ^ 10110011b = 01111110b
-11001101b ^ 10110100b = 01111001b
-11001101b ^ 10110101b = 01111000b
-11001101b ^ 10110110b = 01111011b
-11001101b ^ 10110111b = 01111010b
-11001101b ^ 10111000b = 01110101b
-11001101b ^ 10111001b = 01110100b
-11001101b ^ 10111010b = 01110111b
-11001101b ^ 10111011b = 01110110b
-11001101b ^ 10111100b = 01110001b
-11001101b ^ 10111101b = 01110000b
-11001101b ^ 10111110b = 01110011b
-11001101b ^ 10111111b = 01110010b
-11001101b ^ 11000000b = 00001101b
-11001101b ^ 11000001b = 00001100b
-11001101b ^ 11000010b = 00001111b
-11001101b ^ 11000011b = 00001110b
-11001101b ^ 11000100b = 00001001b
-11001101b ^ 11000101b = 00001000b
-11001101b ^ 11000110b = 00001011b
-11001101b ^ 11000111b = 00001010b
-11001101b ^ 11001000b = 00000101b
-11001101b ^ 11001001b = 00000100b
-11001101b ^ 11001010b = 00000111b
-11001101b ^ 11001011b = 00000110b
-11001101b ^ 11001100b = 00000001b
-11001101b ^ 11001101b = 00000000b
-11001101b ^ 11001110b = 00000011b
-11001101b ^ 11001111b = 00000010b
-11001101b ^ 11010000b = 00011101b
-11001101b ^ 11010001b = 00011100b
-11001101b ^ 11010010b = 00011111b
-11001101b ^ 11010011b = 00011110b
-11001101b ^ 11010100b = 00011001b
-11001101b ^ 11010101b = 00011000b
-11001101b ^ 11010110b = 00011011b
-11001101b ^ 11010111b = 00011010b
-11001101b ^ 11011000b = 00010101b
-11001101b ^ 11011001b = 00010100b
-11001101b ^ 11011010b = 00010111b
-11001101b ^ 11011011b = 00010110b
-11001101b ^ 11011100b = 00010001b
-11001101b ^ 11011101b = 00010000b
-11001101b ^ 11011110b = 00010011b
-11001101b ^ 11011111b = 00010010b
-11001101b ^ 11100000b = 00101101b
-11001101b ^ 11100001b = 00101100b
-11001101b ^ 11100010b = 00101111b
-11001101b ^ 11100011b = 00101110b
-11001101b ^ 11100100b = 00101001b
-11001101b ^ 11100101b = 00101000b
-11001101b ^ 11100110b = 00101011b
-11001101b ^ 11100111b = 00101010b
-11001101b ^ 11101000b = 00100101b
-11001101b ^ 11101001b = 00100100b
-11001101b ^ 11101010b = 00100111b
-11001101b ^ 11101011b = 00100110b
-11001101b ^ 11101100b = 00100001b
-11001101b ^ 11101101b = 00100000b
-11001101b ^ 11101110b = 00100011b
-11001101b ^ 11101111b = 00100010b
-11001101b ^ 11110000b = 00111101b
-11001101b ^ 11110001b = 00111100b
-11001101b ^ 11110010b = 00111111b
-11001101b ^ 11110011b = 00111110b
-11001101b ^ 11110100b = 00111001b
-11001101b ^ 11110101b = 00111000b
-11001101b ^ 11110110b = 00111011b
-11001101b ^ 11110111b = 00111010b
-11001101b ^ 11111000b = 00110101b
-11001101b ^ 11111001b = 00110100b
-11001101b ^ 11111010b = 00110111b
-11001101b ^ 11111011b = 00110110b
-11001101b ^ 11111100b = 00110001b
-11001101b ^ 11111101b = 00110000b
-11001101b ^ 11111110b = 00110011b
-11001101b ^ 11111111b = 00110010b
-11001101b ^ 00000000b = 11001101b
-11001101b ^ 00000001b = 11001100b
-11001101b ^ 00000010b = 11001111b
-11001101b ^ 00000011b = 11001110b
-11001101b ^ 00000100b = 11001001b
-11001101b ^ 00000101b = 11001000b
-11001101b ^ 00000110b = 11001011b
-11001101b ^ 00000111b = 11001010b
-11001101b ^ 00001000b = 11000101b
-11001101b ^ 00001001b = 11000100b
-11001101b ^ 00001010b = 11000111b
-11001101b ^ 00001011b = 11000110b
-11001101b ^ 00001100b = 11000001b
-11001101b ^ 00001101b = 11000000b
-11001101b ^ 00001110b = 11000011b
-11001101b ^ 00001111b = 11000010b
-11001101b ^ 00010000b = 11011101b
-11001101b ^ 00010001b = 11011100b
-11001101b ^ 00010010b = 11011111b
-11001101b ^ 00010011b = 11011110b
-11001101b ^ 00010100b = 11011001b
-11001101b ^ 00010101b = 11011000b
-11001101b ^ 00010110b = 11011011b
-11001101b ^ 00010111b = 11011010b
-11001101b ^ 00011000b = 11010101b
-11001101b ^ 00011001b = 11010100b
-11001101b ^ 00011010b = 11010111b
-11001101b ^ 00011011b = 11010110b
-11001101b ^ 00011100b = 11010001b
-11001101b ^ 00011101b = 11010000b
-11001101b ^ 00011110b = 11010011b
-11001101b ^ 00011111b = 11010010b
-11001101b ^ 00100000b = 11101101b
-11001101b ^ 00100001b = 11101100b
-11001101b ^ 00100010b = 11101111b
-11001101b ^ 00100011b = 11101110b
-11001101b ^ 00100100b = 11101001b
-11001101b ^ 00100101b = 11101000b
-11001101b ^ 00100110b = 11101011b
-11001101b ^ 00100111b = 11101010b
-11001101b ^ 00101000b = 11100101b
-11001101b ^ 00101001b = 11100100b
-11001101b ^ 00101010b = 11100111b
-11001101b ^ 00101011b = 11100110b
-11001101b ^ 00101100b = 11100001b
-11001101b ^ 00101101b = 11100000b
-11001101b ^ 00101110b = 11100011b
-11001101b ^ 00101111b = 11100010b
-11001101b ^ 00110000b = 11111101b
-11001101b ^ 00110001b = 11111100b
-11001101b ^ 00110010b = 11111111b
-11001101b ^ 00110011b = 11111110b
-11001101b ^ 00110100b = 11111001b
-11001101b ^ 00110101b = 11111000b
-11001101b ^ 00110110b = 11111011b
-11001101b ^ 00110111b = 11111010b
-11001101b ^ 00111000b = 11110101b
-11001101b ^ 00111001b = 11110100b
-11001101b ^ 00111010b = 11110111b
-11001101b ^ 00111011b = 11110110b
-11001101b ^ 00111100b = 11110001b
-11001101b ^ 00111101b = 11110000b
-11001101b ^ 00111110b = 11110011b
-11001101b ^ 00111111b = 11110010b
-11001101b ^ 01000000b = 10001101b
-11001101b ^ 01000001b = 10001100b
-11001101b ^ 01000010b = 10001111b
-11001101b ^ 01000011b = 10001110b
-11001101b ^ 01000100b = 10001001b
-11001101b ^ 01000101b = 10001000b
-11001101b ^ 01000110b = 10001011b
-11001101b ^ 01000111b = 10001010b
-11001101b ^ 01001000b = 10000101b
-11001101b ^ 01001001b = 10000100b
-11001101b ^ 01001010b = 10000111b
-11001101b ^ 01001011b = 10000110b
-11001101b ^ 01001100b = 10000001b
-11001101b ^ 01001101b = 10000000b
-11001101b ^ 01001110b = 10000011b
-11001101b ^ 01001111b = 10000010b
-11001101b ^ 01010000b = 10011101b
-11001101b ^ 01010001b = 10011100b
-11001101b ^ 01010010b = 10011111b
-11001101b ^ 01010011b = 10011110b
-11001101b ^ 01010100b = 10011001b
-11001101b ^ 01010101b = 10011000b
-11001101b ^ 01010110b = 10011011b
-11001101b ^ 01010111b = 10011010b
-11001101b ^ 01011000b = 10010101b
-11001101b ^ 01011001b = 10010100b
-11001101b ^ 01011010b = 10010111b
-11001101b ^ 01011011b = 10010110b
-11001101b ^ 01011100b = 10010001b
-11001101b ^ 01011101b = 10010000b
-11001101b ^ 01011110b = 10010011b
-11001101b ^ 01011111b = 10010010b
-11001101b ^ 01100000b = 10101101b
-11001101b ^ 01100001b = 10101100b
-11001101b ^ 01100010b = 10101111b
-11001101b ^ 01100011b = 10101110b
-11001101b ^ 01100100b = 10101001b
-11001101b ^ 01100101b = 10101000b
-11001101b ^ 01100110b = 10101011b
-11001101b ^ 01100111b = 10101010b
-11001101b ^ 01101000b = 10100101b
-11001101b ^ 01101001b = 10100100b
-11001101b ^ 01101010b = 10100111b
-11001101b ^ 01101011b = 10100110b
-11001101b ^ 01101100b = 10100001b
-11001101b ^ 01101101b = 10100000b
-11001101b ^ 01101110b = 10100011b
-11001101b ^ 01101111b = 10100010b
-11001101b ^ 01110000b = 10111101b
-11001101b ^ 01110001b = 10111100b
-11001101b ^ 01110010b = 10111111b
-11001101b ^ 01110011b = 10111110b
-11001101b ^ 01110100b = 10111001b
-11001101b ^ 01110101b = 10111000b
-11001101b ^ 01110110b = 10111011b
-11001101b ^ 01110111b = 10111010b
-11001101b ^ 01111000b = 10110101b
-11001101b ^ 01111001b = 10110100b
-11001101b ^ 01111010b = 10110111b
-11001101b ^ 01111011b = 10110110b
-11001101b ^ 01111100b = 10110001b
-11001101b ^ 01111101b = 10110000b
-11001101b ^ 01111110b = 10110011b
-11001110b ^ 10000000b = 01001110b
-11001110b ^ 10000001b = 01001111b
-11001110b ^ 10000010b = 01001100b
-11001110b ^ 10000011b = 01001101b
-11001110b ^ 10000100b = 01001010b
-11001110b ^ 10000101b = 01001011b
-11001110b ^ 10000110b = 01001000b
-11001110b ^ 10000111b = 01001001b
-11001110b ^ 10001000b = 01000110b
-11001110b ^ 10001001b = 01000111b
-11001110b ^ 10001010b = 01000100b
-11001110b ^ 10001011b = 01000101b
-11001110b ^ 10001100b = 01000010b
-11001110b ^ 10001101b = 01000011b
-11001110b ^ 10001110b = 01000000b
-11001110b ^ 10001111b = 01000001b
-11001110b ^ 10010000b = 01011110b
-11001110b ^ 10010001b = 01011111b
-11001110b ^ 10010010b = 01011100b
-11001110b ^ 10010011b = 01011101b
-11001110b ^ 10010100b = 01011010b
-11001110b ^ 10010101b = 01011011b
-11001110b ^ 10010110b = 01011000b
-11001110b ^ 10010111b = 01011001b
-11001110b ^ 10011000b = 01010110b
-11001110b ^ 10011001b = 01010111b
-11001110b ^ 10011010b = 01010100b
-11001110b ^ 10011011b = 01010101b
-11001110b ^ 10011100b = 01010010b
-11001110b ^ 10011101b = 01010011b
-11001110b ^ 10011110b = 01010000b
-11001110b ^ 10011111b = 01010001b
-11001110b ^ 10100000b = 01101110b
-11001110b ^ 10100001b = 01101111b
-11001110b ^ 10100010b = 01101100b
-11001110b ^ 10100011b = 01101101b
-11001110b ^ 10100100b = 01101010b
-11001110b ^ 10100101b = 01101011b
-11001110b ^ 10100110b = 01101000b
-11001110b ^ 10100111b = 01101001b
-11001110b ^ 10101000b = 01100110b
-11001110b ^ 10101001b = 01100111b
-11001110b ^ 10101010b = 01100100b
-11001110b ^ 10101011b = 01100101b
-11001110b ^ 10101100b = 01100010b
-11001110b ^ 10101101b = 01100011b
-11001110b ^ 10101110b = 01100000b
-11001110b ^ 10101111b = 01100001b
-11001110b ^ 10110000b = 01111110b
-11001110b ^ 10110001b = 01111111b
-11001110b ^ 10110010b = 01111100b
-11001110b ^ 10110011b = 01111101b
-11001110b ^ 10110100b = 01111010b
-11001110b ^ 10110101b = 01111011b
-11001110b ^ 10110110b = 01111000b
-11001110b ^ 10110111b = 01111001b
-11001110b ^ 10111000b = 01110110b
-11001110b ^ 10111001b = 01110111b
-11001110b ^ 10111010b = 01110100b
-11001110b ^ 10111011b = 01110101b
-11001110b ^ 10111100b = 01110010b
-11001110b ^ 10111101b = 01110011b
-11001110b ^ 10111110b = 01110000b
-11001110b ^ 10111111b = 01110001b
-11001110b ^ 11000000b = 00001110b
-11001110b ^ 11000001b = 00001111b
-11001110b ^ 11000010b = 00001100b
-11001110b ^ 11000011b = 00001101b
-11001110b ^ 11000100b = 00001010b
-11001110b ^ 11000101b = 00001011b
-11001110b ^ 11000110b = 00001000b
-11001110b ^ 11000111b = 00001001b
-11001110b ^ 11001000b = 00000110b
-11001110b ^ 11001001b = 00000111b
-11001110b ^ 11001010b = 00000100b
-11001110b ^ 11001011b = 00000101b
-11001110b ^ 11001100b = 00000010b
-11001110b ^ 11001101b = 00000011b
-11001110b ^ 11001110b = 00000000b
-11001110b ^ 11001111b = 00000001b
-11001110b ^ 11010000b = 00011110b
-11001110b ^ 11010001b = 00011111b
-11001110b ^ 11010010b = 00011100b
-11001110b ^ 11010011b = 00011101b
-11001110b ^ 11010100b = 00011010b
-11001110b ^ 11010101b = 00011011b
-11001110b ^ 11010110b = 00011000b
-11001110b ^ 11010111b = 00011001b
-11001110b ^ 11011000b = 00010110b
-11001110b ^ 11011001b = 00010111b
-11001110b ^ 11011010b = 00010100b
-11001110b ^ 11011011b = 00010101b
-11001110b ^ 11011100b = 00010010b
-11001110b ^ 11011101b = 00010011b
-11001110b ^ 11011110b = 00010000b
-11001110b ^ 11011111b = 00010001b
-11001110b ^ 11100000b = 00101110b
-11001110b ^ 11100001b = 00101111b
-11001110b ^ 11100010b = 00101100b
-11001110b ^ 11100011b = 00101101b
-11001110b ^ 11100100b = 00101010b
-11001110b ^ 11100101b = 00101011b
-11001110b ^ 11100110b = 00101000b
-11001110b ^ 11100111b = 00101001b
-11001110b ^ 11101000b = 00100110b
-11001110b ^ 11101001b = 00100111b
-11001110b ^ 11101010b = 00100100b
-11001110b ^ 11101011b = 00100101b
-11001110b ^ 11101100b = 00100010b
-11001110b ^ 11101101b = 00100011b
-11001110b ^ 11101110b = 00100000b
-11001110b ^ 11101111b = 00100001b
-11001110b ^ 11110000b = 00111110b
-11001110b ^ 11110001b = 00111111b
-11001110b ^ 11110010b = 00111100b
-11001110b ^ 11110011b = 00111101b
-11001110b ^ 11110100b = 00111010b
-11001110b ^ 11110101b = 00111011b
-11001110b ^ 11110110b = 00111000b
-11001110b ^ 11110111b = 00111001b
-11001110b ^ 11111000b = 00110110b
-11001110b ^ 11111001b = 00110111b
-11001110b ^ 11111010b = 00110100b
-11001110b ^ 11111011b = 00110101b
-11001110b ^ 11111100b = 00110010b
-11001110b ^ 11111101b = 00110011b
-11001110b ^ 11111110b = 00110000b
-11001110b ^ 11111111b = 00110001b
-11001110b ^ 00000000b = 11001110b
-11001110b ^ 00000001b = 11001111b
-11001110b ^ 00000010b = 11001100b
-11001110b ^ 00000011b = 11001101b
-11001110b ^ 00000100b = 11001010b
-11001110b ^ 00000101b = 11001011b
-11001110b ^ 00000110b = 11001000b
-11001110b ^ 00000111b = 11001001b
-11001110b ^ 00001000b = 11000110b
-11001110b ^ 00001001b = 11000111b
-11001110b ^ 00001010b = 11000100b
-11001110b ^ 00001011b = 11000101b
-11001110b ^ 00001100b = 11000010b
-11001110b ^ 00001101b = 11000011b
-11001110b ^ 00001110b = 11000000b
-11001110b ^ 00001111b = 11000001b
-11001110b ^ 00010000b = 11011110b
-11001110b ^ 00010001b = 11011111b
-11001110b ^ 00010010b = 11011100b
-11001110b ^ 00010011b = 11011101b
-11001110b ^ 00010100b = 11011010b
-11001110b ^ 00010101b = 11011011b
-11001110b ^ 00010110b = 11011000b
-11001110b ^ 00010111b = 11011001b
-11001110b ^ 00011000b = 11010110b
-11001110b ^ 00011001b = 11010111b
-11001110b ^ 00011010b = 11010100b
-11001110b ^ 00011011b = 11010101b
-11001110b ^ 00011100b = 11010010b
-11001110b ^ 00011101b = 11010011b
-11001110b ^ 00011110b = 11010000b
-11001110b ^ 00011111b = 11010001b
-11001110b ^ 00100000b = 11101110b
-11001110b ^ 00100001b = 11101111b
-11001110b ^ 00100010b = 11101100b
-11001110b ^ 00100011b = 11101101b
-11001110b ^ 00100100b = 11101010b
-11001110b ^ 00100101b = 11101011b
-11001110b ^ 00100110b = 11101000b
-11001110b ^ 00100111b = 11101001b
-11001110b ^ 00101000b = 11100110b
-11001110b ^ 00101001b = 11100111b
-11001110b ^ 00101010b = 11100100b
-11001110b ^ 00101011b = 11100101b
-11001110b ^ 00101100b = 11100010b
-11001110b ^ 00101101b = 11100011b
-11001110b ^ 00101110b = 11100000b
-11001110b ^ 00101111b = 11100001b
-11001110b ^ 00110000b = 11111110b
-11001110b ^ 00110001b = 11111111b
-11001110b ^ 00110010b = 11111100b
-11001110b ^ 00110011b = 11111101b
-11001110b ^ 00110100b = 11111010b
-11001110b ^ 00110101b = 11111011b
-11001110b ^ 00110110b = 11111000b
-11001110b ^ 00110111b = 11111001b
-11001110b ^ 00111000b = 11110110b
-11001110b ^ 00111001b = 11110111b
-11001110b ^ 00111010b = 11110100b
-11001110b ^ 00111011b = 11110101b
-11001110b ^ 00111100b = 11110010b
-11001110b ^ 00111101b = 11110011b
-11001110b ^ 00111110b = 11110000b
-11001110b ^ 00111111b = 11110001b
-11001110b ^ 01000000b = 10001110b
-11001110b ^ 01000001b = 10001111b
-11001110b ^ 01000010b = 10001100b
-11001110b ^ 01000011b = 10001101b
-11001110b ^ 01000100b = 10001010b
-11001110b ^ 01000101b = 10001011b
-11001110b ^ 01000110b = 10001000b
-11001110b ^ 01000111b = 10001001b
-11001110b ^ 01001000b = 10000110b
-11001110b ^ 01001001b = 10000111b
-11001110b ^ 01001010b = 10000100b
-11001110b ^ 01001011b = 10000101b
-11001110b ^ 01001100b = 10000010b
-11001110b ^ 01001101b = 10000011b
-11001110b ^ 01001110b = 10000000b
-11001110b ^ 01001111b = 10000001b
-11001110b ^ 01010000b = 10011110b
-11001110b ^ 01010001b = 10011111b
-11001110b ^ 01010010b = 10011100b
-11001110b ^ 01010011b = 10011101b
-11001110b ^ 01010100b = 10011010b
-11001110b ^ 01010101b = 10011011b
-11001110b ^ 01010110b = 10011000b
-11001110b ^ 01010111b = 10011001b
-11001110b ^ 01011000b = 10010110b
-11001110b ^ 01011001b = 10010111b
-11001110b ^ 01011010b = 10010100b
-11001110b ^ 01011011b = 10010101b
-11001110b ^ 01011100b = 10010010b
-11001110b ^ 01011101b = 10010011b
-11001110b ^ 01011110b = 10010000b
-11001110b ^ 01011111b = 10010001b
-11001110b ^ 01100000b = 10101110b
-11001110b ^ 01100001b = 10101111b
-11001110b ^ 01100010b = 10101100b
-11001110b ^ 01100011b = 10101101b
-11001110b ^ 01100100b = 10101010b
-11001110b ^ 01100101b = 10101011b
-11001110b ^ 01100110b = 10101000b
-11001110b ^ 01100111b = 10101001b
-11001110b ^ 01101000b = 10100110b
-11001110b ^ 01101001b = 10100111b
-11001110b ^ 01101010b = 10100100b
-11001110b ^ 01101011b = 10100101b
-11001110b ^ 01101100b = 10100010b
-11001110b ^ 01101101b = 10100011b
-11001110b ^ 01101110b = 10100000b
-11001110b ^ 01101111b = 10100001b
-11001110b ^ 01110000b = 10111110b
-11001110b ^ 01110001b = 10111111b
-11001110b ^ 01110010b = 10111100b
-11001110b ^ 01110011b = 10111101b
-11001110b ^ 01110100b = 10111010b
-11001110b ^ 01110101b = 10111011b
-11001110b ^ 01110110b = 10111000b
-11001110b ^ 01110111b = 10111001b
-11001110b ^ 01111000b = 10110110b
-11001110b ^ 01111001b = 10110111b
-11001110b ^ 01111010b = 10110100b
-11001110b ^ 01111011b = 10110101b
-11001110b ^ 01111100b = 10110010b
-11001110b ^ 01111101b = 10110011b
-11001110b ^ 01111110b = 10110000b
-11001111b ^ 10000000b = 01001111b
-11001111b ^ 10000001b = 01001110b
-11001111b ^ 10000010b = 01001101b
-11001111b ^ 10000011b = 01001100b
-11001111b ^ 10000100b = 01001011b
-11001111b ^ 10000101b = 01001010b
-11001111b ^ 10000110b = 01001001b
-11001111b ^ 10000111b = 01001000b
-11001111b ^ 10001000b = 01000111b
-11001111b ^ 10001001b = 01000110b
-11001111b ^ 10001010b = 01000101b
-11001111b ^ 10001011b = 01000100b
-11001111b ^ 10001100b = 01000011b
-11001111b ^ 10001101b = 01000010b
-11001111b ^ 10001110b = 01000001b
-11001111b ^ 10001111b = 01000000b
-11001111b ^ 10010000b = 01011111b
-11001111b ^ 10010001b = 01011110b
-11001111b ^ 10010010b = 01011101b
-11001111b ^ 10010011b = 01011100b
-11001111b ^ 10010100b = 01011011b
-11001111b ^ 10010101b = 01011010b
-11001111b ^ 10010110b = 01011001b
-11001111b ^ 10010111b = 01011000b
-11001111b ^ 10011000b = 01010111b
-11001111b ^ 10011001b = 01010110b
-11001111b ^ 10011010b = 01010101b
-11001111b ^ 10011011b = 01010100b
-11001111b ^ 10011100b = 01010011b
-11001111b ^ 10011101b = 01010010b
-11001111b ^ 10011110b = 01010001b
-11001111b ^ 10011111b = 01010000b
-11001111b ^ 10100000b = 01101111b
-11001111b ^ 10100001b = 01101110b
-11001111b ^ 10100010b = 01101101b
-11001111b ^ 10100011b = 01101100b
-11001111b ^ 10100100b = 01101011b
-11001111b ^ 10100101b = 01101010b
-11001111b ^ 10100110b = 01101001b
-11001111b ^ 10100111b = 01101000b
-11001111b ^ 10101000b = 01100111b
-11001111b ^ 10101001b = 01100110b
-11001111b ^ 10101010b = 01100101b
-11001111b ^ 10101011b = 01100100b
-11001111b ^ 10101100b = 01100011b
-11001111b ^ 10101101b = 01100010b
-11001111b ^ 10101110b = 01100001b
-11001111b ^ 10101111b = 01100000b
-11001111b ^ 10110000b = 01111111b
-11001111b ^ 10110001b = 01111110b
-11001111b ^ 10110010b = 01111101b
-11001111b ^ 10110011b = 01111100b
-11001111b ^ 10110100b = 01111011b
-11001111b ^ 10110101b = 01111010b
-11001111b ^ 10110110b = 01111001b
-11001111b ^ 10110111b = 01111000b
-11001111b ^ 10111000b = 01110111b
-11001111b ^ 10111001b = 01110110b
-11001111b ^ 10111010b = 01110101b
-11001111b ^ 10111011b = 01110100b
-11001111b ^ 10111100b = 01110011b
-11001111b ^ 10111101b = 01110010b
-11001111b ^ 10111110b = 01110001b
-11001111b ^ 10111111b = 01110000b
-11001111b ^ 11000000b = 00001111b
-11001111b ^ 11000001b = 00001110b
-11001111b ^ 11000010b = 00001101b
-11001111b ^ 11000011b = 00001100b
-11001111b ^ 11000100b = 00001011b
-11001111b ^ 11000101b = 00001010b
-11001111b ^ 11000110b = 00001001b
-11001111b ^ 11000111b = 00001000b
-11001111b ^ 11001000b = 00000111b
-11001111b ^ 11001001b = 00000110b
-11001111b ^ 11001010b = 00000101b
-11001111b ^ 11001011b = 00000100b
-11001111b ^ 11001100b = 00000011b
-11001111b ^ 11001101b = 00000010b
-11001111b ^ 11001110b = 00000001b
-11001111b ^ 11001111b = 00000000b
-11001111b ^ 11010000b = 00011111b
-11001111b ^ 11010001b = 00011110b
-11001111b ^ 11010010b = 00011101b
-11001111b ^ 11010011b = 00011100b
-11001111b ^ 11010100b = 00011011b
-11001111b ^ 11010101b = 00011010b
-11001111b ^ 11010110b = 00011001b
-11001111b ^ 11010111b = 00011000b
-11001111b ^ 11011000b = 00010111b
-11001111b ^ 11011001b = 00010110b
-11001111b ^ 11011010b = 00010101b
-11001111b ^ 11011011b = 00010100b
-11001111b ^ 11011100b = 00010011b
-11001111b ^ 11011101b = 00010010b
-11001111b ^ 11011110b = 00010001b
-11001111b ^ 11011111b = 00010000b
-11001111b ^ 11100000b = 00101111b
-11001111b ^ 11100001b = 00101110b
-11001111b ^ 11100010b = 00101101b
-11001111b ^ 11100011b = 00101100b
-11001111b ^ 11100100b = 00101011b
-11001111b ^ 11100101b = 00101010b
-11001111b ^ 11100110b = 00101001b
-11001111b ^ 11100111b = 00101000b
-11001111b ^ 11101000b = 00100111b
-11001111b ^ 11101001b = 00100110b
-11001111b ^ 11101010b = 00100101b
-11001111b ^ 11101011b = 00100100b
-11001111b ^ 11101100b = 00100011b
-11001111b ^ 11101101b = 00100010b
-11001111b ^ 11101110b = 00100001b
-11001111b ^ 11101111b = 00100000b
-11001111b ^ 11110000b = 00111111b
-11001111b ^ 11110001b = 00111110b
-11001111b ^ 11110010b = 00111101b
-11001111b ^ 11110011b = 00111100b
-11001111b ^ 11110100b = 00111011b
-11001111b ^ 11110101b = 00111010b
-11001111b ^ 11110110b = 00111001b
-11001111b ^ 11110111b = 00111000b
-11001111b ^ 11111000b = 00110111b
-11001111b ^ 11111001b = 00110110b
-11001111b ^ 11111010b = 00110101b
-11001111b ^ 11111011b = 00110100b
-11001111b ^ 11111100b = 00110011b
-11001111b ^ 11111101b = 00110010b
-11001111b ^ 11111110b = 00110001b
-11001111b ^ 11111111b = 00110000b
-11001111b ^ 00000000b = 11001111b
-11001111b ^ 00000001b = 11001110b
-11001111b ^ 00000010b = 11001101b
-11001111b ^ 00000011b = 11001100b
-11001111b ^ 00000100b = 11001011b
-11001111b ^ 00000101b = 11001010b
-11001111b ^ 00000110b = 11001001b
-11001111b ^ 00000111b = 11001000b
-11001111b ^ 00001000b = 11000111b
-11001111b ^ 00001001b = 11000110b
-11001111b ^ 00001010b = 11000101b
-11001111b ^ 00001011b = 11000100b
-11001111b ^ 00001100b = 11000011b
-11001111b ^ 00001101b = 11000010b
-11001111b ^ 00001110b = 11000001b
-11001111b ^ 00001111b = 11000000b
-11001111b ^ 00010000b = 11011111b
-11001111b ^ 00010001b = 11011110b
-11001111b ^ 00010010b = 11011101b
-11001111b ^ 00010011b = 11011100b
-11001111b ^ 00010100b = 11011011b
-11001111b ^ 00010101b = 11011010b
-11001111b ^ 00010110b = 11011001b
-11001111b ^ 00010111b = 11011000b
-11001111b ^ 00011000b = 11010111b
-11001111b ^ 00011001b = 11010110b
-11001111b ^ 00011010b = 11010101b
-11001111b ^ 00011011b = 11010100b
-11001111b ^ 00011100b = 11010011b
-11001111b ^ 00011101b = 11010010b
-11001111b ^ 00011110b = 11010001b
-11001111b ^ 00011111b = 11010000b
-11001111b ^ 00100000b = 11101111b
-11001111b ^ 00100001b = 11101110b
-11001111b ^ 00100010b = 11101101b
-11001111b ^ 00100011b = 11101100b
-11001111b ^ 00100100b = 11101011b
-11001111b ^ 00100101b = 11101010b
-11001111b ^ 00100110b = 11101001b
-11001111b ^ 00100111b = 11101000b
-11001111b ^ 00101000b = 11100111b
-11001111b ^ 00101001b = 11100110b
-11001111b ^ 00101010b = 11100101b
-11001111b ^ 00101011b = 11100100b
-11001111b ^ 00101100b = 11100011b
-11001111b ^ 00101101b = 11100010b
-11001111b ^ 00101110b = 11100001b
-11001111b ^ 00101111b = 11100000b
-11001111b ^ 00110000b = 11111111b
-11001111b ^ 00110001b = 11111110b
-11001111b ^ 00110010b = 11111101b
-11001111b ^ 00110011b = 11111100b
-11001111b ^ 00110100b = 11111011b
-11001111b ^ 00110101b = 11111010b
-11001111b ^ 00110110b = 11111001b
-11001111b ^ 00110111b = 11111000b
-11001111b ^ 00111000b = 11110111b
-11001111b ^ 00111001b = 11110110b
-11001111b ^ 00111010b = 11110101b
-11001111b ^ 00111011b = 11110100b
-11001111b ^ 00111100b = 11110011b
-11001111b ^ 00111101b = 11110010b
-11001111b ^ 00111110b = 11110001b
-11001111b ^ 00111111b = 11110000b
-11001111b ^ 01000000b = 10001111b
-11001111b ^ 01000001b = 10001110b
-11001111b ^ 01000010b = 10001101b
-11001111b ^ 01000011b = 10001100b
-11001111b ^ 01000100b = 10001011b
-11001111b ^ 01000101b = 10001010b
-11001111b ^ 01000110b = 10001001b
-11001111b ^ 01000111b = 10001000b
-11001111b ^ 01001000b = 10000111b
-11001111b ^ 01001001b = 10000110b
-11001111b ^ 01001010b = 10000101b
-11001111b ^ 01001011b = 10000100b
-11001111b ^ 01001100b = 10000011b
-11001111b ^ 01001101b = 10000010b
-11001111b ^ 01001110b = 10000001b
-11001111b ^ 01001111b = 10000000b
-11001111b ^ 01010000b = 10011111b
-11001111b ^ 01010001b = 10011110b
-11001111b ^ 01010010b = 10011101b
-11001111b ^ 01010011b = 10011100b
-11001111b ^ 01010100b = 10011011b
-11001111b ^ 01010101b = 10011010b
-11001111b ^ 01010110b = 10011001b
-11001111b ^ 01010111b = 10011000b
-11001111b ^ 01011000b = 10010111b
-11001111b ^ 01011001b = 10010110b
-11001111b ^ 01011010b = 10010101b
-11001111b ^ 01011011b = 10010100b
-11001111b ^ 01011100b = 10010011b
-11001111b ^ 01011101b = 10010010b
-11001111b ^ 01011110b = 10010001b
-11001111b ^ 01011111b = 10010000b
-11001111b ^ 01100000b = 10101111b
-11001111b ^ 01100001b = 10101110b
-11001111b ^ 01100010b = 10101101b
-11001111b ^ 01100011b = 10101100b
-11001111b ^ 01100100b = 10101011b
-11001111b ^ 01100101b = 10101010b
-11001111b ^ 01100110b = 10101001b
-11001111b ^ 01100111b = 10101000b
-11001111b ^ 01101000b = 10100111b
-11001111b ^ 01101001b = 10100110b
-11001111b ^ 01101010b = 10100101b
-11001111b ^ 01101011b = 10100100b
-11001111b ^ 01101100b = 10100011b
-11001111b ^ 01101101b = 10100010b
-11001111b ^ 01101110b = 10100001b
-11001111b ^ 01101111b = 10100000b
-11001111b ^ 01110000b = 10111111b
-11001111b ^ 01110001b = 10111110b
-11001111b ^ 01110010b = 10111101b
-11001111b ^ 01110011b = 10111100b
-11001111b ^ 01110100b = 10111011b
-11001111b ^ 01110101b = 10111010b
-11001111b ^ 01110110b = 10111001b
-11001111b ^ 01110111b = 10111000b
-11001111b ^ 01111000b = 10110111b
-11001111b ^ 01111001b = 10110110b
-11001111b ^ 01111010b = 10110101b
-11001111b ^ 01111011b = 10110100b
-11001111b ^ 01111100b = 10110011b
-11001111b ^ 01111101b = 10110010b
-11001111b ^ 01111110b = 10110001b
-11010000b ^ 10000000b = 01010000b
-11010000b ^ 10000001b = 01010001b
-11010000b ^ 10000010b = 01010010b
-11010000b ^ 10000011b = 01010011b
-11010000b ^ 10000100b = 01010100b
-11010000b ^ 10000101b = 01010101b
-11010000b ^ 10000110b = 01010110b
-11010000b ^ 10000111b = 01010111b
-11010000b ^ 10001000b = 01011000b
-11010000b ^ 10001001b = 01011001b
-11010000b ^ 10001010b = 01011010b
-11010000b ^ 10001011b = 01011011b
-11010000b ^ 10001100b = 01011100b
-11010000b ^ 10001101b = 01011101b
-11010000b ^ 10001110b = 01011110b
-11010000b ^ 10001111b = 01011111b
-11010000b ^ 10010000b = 01000000b
-11010000b ^ 10010001b = 01000001b
-11010000b ^ 10010010b = 01000010b
-11010000b ^ 10010011b = 01000011b
-11010000b ^ 10010100b = 01000100b
-11010000b ^ 10010101b = 01000101b
-11010000b ^ 10010110b = 01000110b
-11010000b ^ 10010111b = 01000111b
-11010000b ^ 10011000b = 01001000b
-11010000b ^ 10011001b = 01001001b
-11010000b ^ 10011010b = 01001010b
-11010000b ^ 10011011b = 01001011b
-11010000b ^ 10011100b = 01001100b
-11010000b ^ 10011101b = 01001101b
-11010000b ^ 10011110b = 01001110b
-11010000b ^ 10011111b = 01001111b
-11010000b ^ 10100000b = 01110000b
-11010000b ^ 10100001b = 01110001b
-11010000b ^ 10100010b = 01110010b
-11010000b ^ 10100011b = 01110011b
-11010000b ^ 10100100b = 01110100b
-11010000b ^ 10100101b = 01110101b
-11010000b ^ 10100110b = 01110110b
-11010000b ^ 10100111b = 01110111b
-11010000b ^ 10101000b = 01111000b
-11010000b ^ 10101001b = 01111001b
-11010000b ^ 10101010b = 01111010b
-11010000b ^ 10101011b = 01111011b
-11010000b ^ 10101100b = 01111100b
-11010000b ^ 10101101b = 01111101b
-11010000b ^ 10101110b = 01111110b
-11010000b ^ 10101111b = 01111111b
-11010000b ^ 10110000b = 01100000b
-11010000b ^ 10110001b = 01100001b
-11010000b ^ 10110010b = 01100010b
-11010000b ^ 10110011b = 01100011b
-11010000b ^ 10110100b = 01100100b
-11010000b ^ 10110101b = 01100101b
-11010000b ^ 10110110b = 01100110b
-11010000b ^ 10110111b = 01100111b
-11010000b ^ 10111000b = 01101000b
-11010000b ^ 10111001b = 01101001b
-11010000b ^ 10111010b = 01101010b
-11010000b ^ 10111011b = 01101011b
-11010000b ^ 10111100b = 01101100b
-11010000b ^ 10111101b = 01101101b
-11010000b ^ 10111110b = 01101110b
-11010000b ^ 10111111b = 01101111b
-11010000b ^ 11000000b = 00010000b
-11010000b ^ 11000001b = 00010001b
-11010000b ^ 11000010b = 00010010b
-11010000b ^ 11000011b = 00010011b
-11010000b ^ 11000100b = 00010100b
-11010000b ^ 11000101b = 00010101b
-11010000b ^ 11000110b = 00010110b
-11010000b ^ 11000111b = 00010111b
-11010000b ^ 11001000b = 00011000b
-11010000b ^ 11001001b = 00011001b
-11010000b ^ 11001010b = 00011010b
-11010000b ^ 11001011b = 00011011b
-11010000b ^ 11001100b = 00011100b
-11010000b ^ 11001101b = 00011101b
-11010000b ^ 11001110b = 00011110b
-11010000b ^ 11001111b = 00011111b
-11010000b ^ 11010000b = 00000000b
-11010000b ^ 11010001b = 00000001b
-11010000b ^ 11010010b = 00000010b
-11010000b ^ 11010011b = 00000011b
-11010000b ^ 11010100b = 00000100b
-11010000b ^ 11010101b = 00000101b
-11010000b ^ 11010110b = 00000110b
-11010000b ^ 11010111b = 00000111b
-11010000b ^ 11011000b = 00001000b
-11010000b ^ 11011001b = 00001001b
-11010000b ^ 11011010b = 00001010b
-11010000b ^ 11011011b = 00001011b
-11010000b ^ 11011100b = 00001100b
-11010000b ^ 11011101b = 00001101b
-11010000b ^ 11011110b = 00001110b
-11010000b ^ 11011111b = 00001111b
-11010000b ^ 11100000b = 00110000b
-11010000b ^ 11100001b = 00110001b
-11010000b ^ 11100010b = 00110010b
-11010000b ^ 11100011b = 00110011b
-11010000b ^ 11100100b = 00110100b
-11010000b ^ 11100101b = 00110101b
-11010000b ^ 11100110b = 00110110b
-11010000b ^ 11100111b = 00110111b
-11010000b ^ 11101000b = 00111000b
-11010000b ^ 11101001b = 00111001b
-11010000b ^ 11101010b = 00111010b
-11010000b ^ 11101011b = 00111011b
-11010000b ^ 11101100b = 00111100b
-11010000b ^ 11101101b = 00111101b
-11010000b ^ 11101110b = 00111110b
-11010000b ^ 11101111b = 00111111b
-11010000b ^ 11110000b = 00100000b
-11010000b ^ 11110001b = 00100001b
-11010000b ^ 11110010b = 00100010b
-11010000b ^ 11110011b = 00100011b
-11010000b ^ 11110100b = 00100100b
-11010000b ^ 11110101b = 00100101b
-11010000b ^ 11110110b = 00100110b
-11010000b ^ 11110111b = 00100111b
-11010000b ^ 11111000b = 00101000b
-11010000b ^ 11111001b = 00101001b
-11010000b ^ 11111010b = 00101010b
-11010000b ^ 11111011b = 00101011b
-11010000b ^ 11111100b = 00101100b
-11010000b ^ 11111101b = 00101101b
-11010000b ^ 11111110b = 00101110b
-11010000b ^ 11111111b = 00101111b
-11010000b ^ 00000000b = 11010000b
-11010000b ^ 00000001b = 11010001b
-11010000b ^ 00000010b = 11010010b
-11010000b ^ 00000011b = 11010011b
-11010000b ^ 00000100b = 11010100b
-11010000b ^ 00000101b = 11010101b
-11010000b ^ 00000110b = 11010110b
-11010000b ^ 00000111b = 11010111b
-11010000b ^ 00001000b = 11011000b
-11010000b ^ 00001001b = 11011001b
-11010000b ^ 00001010b = 11011010b
-11010000b ^ 00001011b = 11011011b
-11010000b ^ 00001100b = 11011100b
-11010000b ^ 00001101b = 11011101b
-11010000b ^ 00001110b = 11011110b
-11010000b ^ 00001111b = 11011111b
-11010000b ^ 00010000b = 11000000b
-11010000b ^ 00010001b = 11000001b
-11010000b ^ 00010010b = 11000010b
-11010000b ^ 00010011b = 11000011b
-11010000b ^ 00010100b = 11000100b
-11010000b ^ 00010101b = 11000101b
-11010000b ^ 00010110b = 11000110b
-11010000b ^ 00010111b = 11000111b
-11010000b ^ 00011000b = 11001000b
-11010000b ^ 00011001b = 11001001b
-11010000b ^ 00011010b = 11001010b
-11010000b ^ 00011011b = 11001011b
-11010000b ^ 00011100b = 11001100b
-11010000b ^ 00011101b = 11001101b
-11010000b ^ 00011110b = 11001110b
-11010000b ^ 00011111b = 11001111b
-11010000b ^ 00100000b = 11110000b
-11010000b ^ 00100001b = 11110001b
-11010000b ^ 00100010b = 11110010b
-11010000b ^ 00100011b = 11110011b
-11010000b ^ 00100100b = 11110100b
-11010000b ^ 00100101b = 11110101b
-11010000b ^ 00100110b = 11110110b
-11010000b ^ 00100111b = 11110111b
-11010000b ^ 00101000b = 11111000b
-11010000b ^ 00101001b = 11111001b
-11010000b ^ 00101010b = 11111010b
-11010000b ^ 00101011b = 11111011b
-11010000b ^ 00101100b = 11111100b
-11010000b ^ 00101101b = 11111101b
-11010000b ^ 00101110b = 11111110b
-11010000b ^ 00101111b = 11111111b
-11010000b ^ 00110000b = 11100000b
-11010000b ^ 00110001b = 11100001b
-11010000b ^ 00110010b = 11100010b
-11010000b ^ 00110011b = 11100011b
-11010000b ^ 00110100b = 11100100b
-11010000b ^ 00110101b = 11100101b
-11010000b ^ 00110110b = 11100110b
-11010000b ^ 00110111b = 11100111b
-11010000b ^ 00111000b = 11101000b
-11010000b ^ 00111001b = 11101001b
-11010000b ^ 00111010b = 11101010b
-11010000b ^ 00111011b = 11101011b
-11010000b ^ 00111100b = 11101100b
-11010000b ^ 00111101b = 11101101b
-11010000b ^ 00111110b = 11101110b
-11010000b ^ 00111111b = 11101111b
-11010000b ^ 01000000b = 10010000b
-11010000b ^ 01000001b = 10010001b
-11010000b ^ 01000010b = 10010010b
-11010000b ^ 01000011b = 10010011b
-11010000b ^ 01000100b = 10010100b
-11010000b ^ 01000101b = 10010101b
-11010000b ^ 01000110b = 10010110b
-11010000b ^ 01000111b = 10010111b
-11010000b ^ 01001000b = 10011000b
-11010000b ^ 01001001b = 10011001b
-11010000b ^ 01001010b = 10011010b
-11010000b ^ 01001011b = 10011011b
-11010000b ^ 01001100b = 10011100b
-11010000b ^ 01001101b = 10011101b
-11010000b ^ 01001110b = 10011110b
-11010000b ^ 01001111b = 10011111b
-11010000b ^ 01010000b = 10000000b
-11010000b ^ 01010001b = 10000001b
-11010000b ^ 01010010b = 10000010b
-11010000b ^ 01010011b = 10000011b
-11010000b ^ 01010100b = 10000100b
-11010000b ^ 01010101b = 10000101b
-11010000b ^ 01010110b = 10000110b
-11010000b ^ 01010111b = 10000111b
-11010000b ^ 01011000b = 10001000b
-11010000b ^ 01011001b = 10001001b
-11010000b ^ 01011010b = 10001010b
-11010000b ^ 01011011b = 10001011b
-11010000b ^ 01011100b = 10001100b
-11010000b ^ 01011101b = 10001101b
-11010000b ^ 01011110b = 10001110b
-11010000b ^ 01011111b = 10001111b
-11010000b ^ 01100000b = 10110000b
-11010000b ^ 01100001b = 10110001b
-11010000b ^ 01100010b = 10110010b
-11010000b ^ 01100011b = 10110011b
-11010000b ^ 01100100b = 10110100b
-11010000b ^ 01100101b = 10110101b
-11010000b ^ 01100110b = 10110110b
-11010000b ^ 01100111b = 10110111b
-11010000b ^ 01101000b = 10111000b
-11010000b ^ 01101001b = 10111001b
-11010000b ^ 01101010b = 10111010b
-11010000b ^ 01101011b = 10111011b
-11010000b ^ 01101100b = 10111100b
-11010000b ^ 01101101b = 10111101b
-11010000b ^ 01101110b = 10111110b
-11010000b ^ 01101111b = 10111111b
-11010000b ^ 01110000b = 10100000b
-11010000b ^ 01110001b = 10100001b
-11010000b ^ 01110010b = 10100010b
-11010000b ^ 01110011b = 10100011b
-11010000b ^ 01110100b = 10100100b
-11010000b ^ 01110101b = 10100101b
-11010000b ^ 01110110b = 10100110b
-11010000b ^ 01110111b = 10100111b
-11010000b ^ 01111000b = 10101000b
-11010000b ^ 01111001b = 10101001b
-11010000b ^ 01111010b = 10101010b
-11010000b ^ 01111011b = 10101011b
-11010000b ^ 01111100b = 10101100b
-11010000b ^ 01111101b = 10101101b
-11010000b ^ 01111110b = 10101110b
-11010001b ^ 10000000b = 01010001b
-11010001b ^ 10000001b = 01010000b
-11010001b ^ 10000010b = 01010011b
-11010001b ^ 10000011b = 01010010b
-11010001b ^ 10000100b = 01010101b
-11010001b ^ 10000101b = 01010100b
-11010001b ^ 10000110b = 01010111b
-11010001b ^ 10000111b = 01010110b
-11010001b ^ 10001000b = 01011001b
-11010001b ^ 10001001b = 01011000b
-11010001b ^ 10001010b = 01011011b
-11010001b ^ 10001011b = 01011010b
-11010001b ^ 10001100b = 01011101b
-11010001b ^ 10001101b = 01011100b
-11010001b ^ 10001110b = 01011111b
-11010001b ^ 10001111b = 01011110b
-11010001b ^ 10010000b = 01000001b
-11010001b ^ 10010001b = 01000000b
-11010001b ^ 10010010b = 01000011b
-11010001b ^ 10010011b = 01000010b
-11010001b ^ 10010100b = 01000101b
-11010001b ^ 10010101b = 01000100b
-11010001b ^ 10010110b = 01000111b
-11010001b ^ 10010111b = 01000110b
-11010001b ^ 10011000b = 01001001b
-11010001b ^ 10011001b = 01001000b
-11010001b ^ 10011010b = 01001011b
-11010001b ^ 10011011b = 01001010b
-11010001b ^ 10011100b = 01001101b
-11010001b ^ 10011101b = 01001100b
-11010001b ^ 10011110b = 01001111b
-11010001b ^ 10011111b = 01001110b
-11010001b ^ 10100000b = 01110001b
-11010001b ^ 10100001b = 01110000b
-11010001b ^ 10100010b = 01110011b
-11010001b ^ 10100011b = 01110010b
-11010001b ^ 10100100b = 01110101b
-11010001b ^ 10100101b = 01110100b
-11010001b ^ 10100110b = 01110111b
-11010001b ^ 10100111b = 01110110b
-11010001b ^ 10101000b = 01111001b
-11010001b ^ 10101001b = 01111000b
-11010001b ^ 10101010b = 01111011b
-11010001b ^ 10101011b = 01111010b
-11010001b ^ 10101100b = 01111101b
-11010001b ^ 10101101b = 01111100b
-11010001b ^ 10101110b = 01111111b
-11010001b ^ 10101111b = 01111110b
-11010001b ^ 10110000b = 01100001b
-11010001b ^ 10110001b = 01100000b
-11010001b ^ 10110010b = 01100011b
-11010001b ^ 10110011b = 01100010b
-11010001b ^ 10110100b = 01100101b
-11010001b ^ 10110101b = 01100100b
-11010001b ^ 10110110b = 01100111b
-11010001b ^ 10110111b = 01100110b
-11010001b ^ 10111000b = 01101001b
-11010001b ^ 10111001b = 01101000b
-11010001b ^ 10111010b = 01101011b
-11010001b ^ 10111011b = 01101010b
-11010001b ^ 10111100b = 01101101b
-11010001b ^ 10111101b = 01101100b
-11010001b ^ 10111110b = 01101111b
-11010001b ^ 10111111b = 01101110b
-11010001b ^ 11000000b = 00010001b
-11010001b ^ 11000001b = 00010000b
-11010001b ^ 11000010b = 00010011b
-11010001b ^ 11000011b = 00010010b
-11010001b ^ 11000100b = 00010101b
-11010001b ^ 11000101b = 00010100b
-11010001b ^ 11000110b = 00010111b
-11010001b ^ 11000111b = 00010110b
-11010001b ^ 11001000b = 00011001b
-11010001b ^ 11001001b = 00011000b
-11010001b ^ 11001010b = 00011011b
-11010001b ^ 11001011b = 00011010b
-11010001b ^ 11001100b = 00011101b
-11010001b ^ 11001101b = 00011100b
-11010001b ^ 11001110b = 00011111b
-11010001b ^ 11001111b = 00011110b
-11010001b ^ 11010000b = 00000001b
-11010001b ^ 11010001b = 00000000b
-11010001b ^ 11010010b = 00000011b
-11010001b ^ 11010011b = 00000010b
-11010001b ^ 11010100b = 00000101b
-11010001b ^ 11010101b = 00000100b
-11010001b ^ 11010110b = 00000111b
-11010001b ^ 11010111b = 00000110b
-11010001b ^ 11011000b = 00001001b
-11010001b ^ 11011001b = 00001000b
-11010001b ^ 11011010b = 00001011b
-11010001b ^ 11011011b = 00001010b
-11010001b ^ 11011100b = 00001101b
-11010001b ^ 11011101b = 00001100b
-11010001b ^ 11011110b = 00001111b
-11010001b ^ 11011111b = 00001110b
-11010001b ^ 11100000b = 00110001b
-11010001b ^ 11100001b = 00110000b
-11010001b ^ 11100010b = 00110011b
-11010001b ^ 11100011b = 00110010b
-11010001b ^ 11100100b = 00110101b
-11010001b ^ 11100101b = 00110100b
-11010001b ^ 11100110b = 00110111b
-11010001b ^ 11100111b = 00110110b
-11010001b ^ 11101000b = 00111001b
-11010001b ^ 11101001b = 00111000b
-11010001b ^ 11101010b = 00111011b
-11010001b ^ 11101011b = 00111010b
-11010001b ^ 11101100b = 00111101b
-11010001b ^ 11101101b = 00111100b
-11010001b ^ 11101110b = 00111111b
-11010001b ^ 11101111b = 00111110b
-11010001b ^ 11110000b = 00100001b
-11010001b ^ 11110001b = 00100000b
-11010001b ^ 11110010b = 00100011b
-11010001b ^ 11110011b = 00100010b
-11010001b ^ 11110100b = 00100101b
-11010001b ^ 11110101b = 00100100b
-11010001b ^ 11110110b = 00100111b
-11010001b ^ 11110111b = 00100110b
-11010001b ^ 11111000b = 00101001b
-11010001b ^ 11111001b = 00101000b
-11010001b ^ 11111010b = 00101011b
-11010001b ^ 11111011b = 00101010b
-11010001b ^ 11111100b = 00101101b
-11010001b ^ 11111101b = 00101100b
-11010001b ^ 11111110b = 00101111b
-11010001b ^ 11111111b = 00101110b
-11010001b ^ 00000000b = 11010001b
-11010001b ^ 00000001b = 11010000b
-11010001b ^ 00000010b = 11010011b
-11010001b ^ 00000011b = 11010010b
-11010001b ^ 00000100b = 11010101b
-11010001b ^ 00000101b = 11010100b
-11010001b ^ 00000110b = 11010111b
-11010001b ^ 00000111b = 11010110b
-11010001b ^ 00001000b = 11011001b
-11010001b ^ 00001001b = 11011000b
-11010001b ^ 00001010b = 11011011b
-11010001b ^ 00001011b = 11011010b
-11010001b ^ 00001100b = 11011101b
-11010001b ^ 00001101b = 11011100b
-11010001b ^ 00001110b = 11011111b
-11010001b ^ 00001111b = 11011110b
-11010001b ^ 00010000b = 11000001b
-11010001b ^ 00010001b = 11000000b
-11010001b ^ 00010010b = 11000011b
-11010001b ^ 00010011b = 11000010b
-11010001b ^ 00010100b = 11000101b
-11010001b ^ 00010101b = 11000100b
-11010001b ^ 00010110b = 11000111b
-11010001b ^ 00010111b = 11000110b
-11010001b ^ 00011000b = 11001001b
-11010001b ^ 00011001b = 11001000b
-11010001b ^ 00011010b = 11001011b
-11010001b ^ 00011011b = 11001010b
-11010001b ^ 00011100b = 11001101b
-11010001b ^ 00011101b = 11001100b
-11010001b ^ 00011110b = 11001111b
-11010001b ^ 00011111b = 11001110b
-11010001b ^ 00100000b = 11110001b
-11010001b ^ 00100001b = 11110000b
-11010001b ^ 00100010b = 11110011b
-11010001b ^ 00100011b = 11110010b
-11010001b ^ 00100100b = 11110101b
-11010001b ^ 00100101b = 11110100b
-11010001b ^ 00100110b = 11110111b
-11010001b ^ 00100111b = 11110110b
-11010001b ^ 00101000b = 11111001b
-11010001b ^ 00101001b = 11111000b
-11010001b ^ 00101010b = 11111011b
-11010001b ^ 00101011b = 11111010b
-11010001b ^ 00101100b = 11111101b
-11010001b ^ 00101101b = 11111100b
-11010001b ^ 00101110b = 11111111b
-11010001b ^ 00101111b = 11111110b
-11010001b ^ 00110000b = 11100001b
-11010001b ^ 00110001b = 11100000b
-11010001b ^ 00110010b = 11100011b
-11010001b ^ 00110011b = 11100010b
-11010001b ^ 00110100b = 11100101b
-11010001b ^ 00110101b = 11100100b
-11010001b ^ 00110110b = 11100111b
-11010001b ^ 00110111b = 11100110b
-11010001b ^ 00111000b = 11101001b
-11010001b ^ 00111001b = 11101000b
-11010001b ^ 00111010b = 11101011b
-11010001b ^ 00111011b = 11101010b
-11010001b ^ 00111100b = 11101101b
-11010001b ^ 00111101b = 11101100b
-11010001b ^ 00111110b = 11101111b
-11010001b ^ 00111111b = 11101110b
-11010001b ^ 01000000b = 10010001b
-11010001b ^ 01000001b = 10010000b
-11010001b ^ 01000010b = 10010011b
-11010001b ^ 01000011b = 10010010b
-11010001b ^ 01000100b = 10010101b
-11010001b ^ 01000101b = 10010100b
-11010001b ^ 01000110b = 10010111b
-11010001b ^ 01000111b = 10010110b
-11010001b ^ 01001000b = 10011001b
-11010001b ^ 01001001b = 10011000b
-11010001b ^ 01001010b = 10011011b
-11010001b ^ 01001011b = 10011010b
-11010001b ^ 01001100b = 10011101b
-11010001b ^ 01001101b = 10011100b
-11010001b ^ 01001110b = 10011111b
-11010001b ^ 01001111b = 10011110b
-11010001b ^ 01010000b = 10000001b
-11010001b ^ 01010001b = 10000000b
-11010001b ^ 01010010b = 10000011b
-11010001b ^ 01010011b = 10000010b
-11010001b ^ 01010100b = 10000101b
-11010001b ^ 01010101b = 10000100b
-11010001b ^ 01010110b = 10000111b
-11010001b ^ 01010111b = 10000110b
-11010001b ^ 01011000b = 10001001b
-11010001b ^ 01011001b = 10001000b
-11010001b ^ 01011010b = 10001011b
-11010001b ^ 01011011b = 10001010b
-11010001b ^ 01011100b = 10001101b
-11010001b ^ 01011101b = 10001100b
-11010001b ^ 01011110b = 10001111b
-11010001b ^ 01011111b = 10001110b
-11010001b ^ 01100000b = 10110001b
-11010001b ^ 01100001b = 10110000b
-11010001b ^ 01100010b = 10110011b
-11010001b ^ 01100011b = 10110010b
-11010001b ^ 01100100b = 10110101b
-11010001b ^ 01100101b = 10110100b
-11010001b ^ 01100110b = 10110111b
-11010001b ^ 01100111b = 10110110b
-11010001b ^ 01101000b = 10111001b
-11010001b ^ 01101001b = 10111000b
-11010001b ^ 01101010b = 10111011b
-11010001b ^ 01101011b = 10111010b
-11010001b ^ 01101100b = 10111101b
-11010001b ^ 01101101b = 10111100b
-11010001b ^ 01101110b = 10111111b
-11010001b ^ 01101111b = 10111110b
-11010001b ^ 01110000b = 10100001b
-11010001b ^ 01110001b = 10100000b
-11010001b ^ 01110010b = 10100011b
-11010001b ^ 01110011b = 10100010b
-11010001b ^ 01110100b = 10100101b
-11010001b ^ 01110101b = 10100100b
-11010001b ^ 01110110b = 10100111b
-11010001b ^ 01110111b = 10100110b
-11010001b ^ 01111000b = 10101001b
-11010001b ^ 01111001b = 10101000b
-11010001b ^ 01111010b = 10101011b
-11010001b ^ 01111011b = 10101010b
-11010001b ^ 01111100b = 10101101b
-11010001b ^ 01111101b = 10101100b
-11010001b ^ 01111110b = 10101111b
-11010010b ^ 10000000b = 01010010b
-11010010b ^ 10000001b = 01010011b
-11010010b ^ 10000010b = 01010000b
-11010010b ^ 10000011b = 01010001b
-11010010b ^ 10000100b = 01010110b
-11010010b ^ 10000101b = 01010111b
-11010010b ^ 10000110b = 01010100b
-11010010b ^ 10000111b = 01010101b
-11010010b ^ 10001000b = 01011010b
-11010010b ^ 10001001b = 01011011b
-11010010b ^ 10001010b = 01011000b
-11010010b ^ 10001011b = 01011001b
-11010010b ^ 10001100b = 01011110b
-11010010b ^ 10001101b = 01011111b
-11010010b ^ 10001110b = 01011100b
-11010010b ^ 10001111b = 01011101b
-11010010b ^ 10010000b = 01000010b
-11010010b ^ 10010001b = 01000011b
-11010010b ^ 10010010b = 01000000b
-11010010b ^ 10010011b = 01000001b
-11010010b ^ 10010100b = 01000110b
-11010010b ^ 10010101b = 01000111b
-11010010b ^ 10010110b = 01000100b
-11010010b ^ 10010111b = 01000101b
-11010010b ^ 10011000b = 01001010b
-11010010b ^ 10011001b = 01001011b
-11010010b ^ 10011010b = 01001000b
-11010010b ^ 10011011b = 01001001b
-11010010b ^ 10011100b = 01001110b
-11010010b ^ 10011101b = 01001111b
-11010010b ^ 10011110b = 01001100b
-11010010b ^ 10011111b = 01001101b
-11010010b ^ 10100000b = 01110010b
-11010010b ^ 10100001b = 01110011b
-11010010b ^ 10100010b = 01110000b
-11010010b ^ 10100011b = 01110001b
-11010010b ^ 10100100b = 01110110b
-11010010b ^ 10100101b = 01110111b
-11010010b ^ 10100110b = 01110100b
-11010010b ^ 10100111b = 01110101b
-11010010b ^ 10101000b = 01111010b
-11010010b ^ 10101001b = 01111011b
-11010010b ^ 10101010b = 01111000b
-11010010b ^ 10101011b = 01111001b
-11010010b ^ 10101100b = 01111110b
-11010010b ^ 10101101b = 01111111b
-11010010b ^ 10101110b = 01111100b
-11010010b ^ 10101111b = 01111101b
-11010010b ^ 10110000b = 01100010b
-11010010b ^ 10110001b = 01100011b
-11010010b ^ 10110010b = 01100000b
-11010010b ^ 10110011b = 01100001b
-11010010b ^ 10110100b = 01100110b
-11010010b ^ 10110101b = 01100111b
-11010010b ^ 10110110b = 01100100b
-11010010b ^ 10110111b = 01100101b
-11010010b ^ 10111000b = 01101010b
-11010010b ^ 10111001b = 01101011b
-11010010b ^ 10111010b = 01101000b
-11010010b ^ 10111011b = 01101001b
-11010010b ^ 10111100b = 01101110b
-11010010b ^ 10111101b = 01101111b
-11010010b ^ 10111110b = 01101100b
-11010010b ^ 10111111b = 01101101b
-11010010b ^ 11000000b = 00010010b
-11010010b ^ 11000001b = 00010011b
-11010010b ^ 11000010b = 00010000b
-11010010b ^ 11000011b = 00010001b
-11010010b ^ 11000100b = 00010110b
-11010010b ^ 11000101b = 00010111b
-11010010b ^ 11000110b = 00010100b
-11010010b ^ 11000111b = 00010101b
-11010010b ^ 11001000b = 00011010b
-11010010b ^ 11001001b = 00011011b
-11010010b ^ 11001010b = 00011000b
-11010010b ^ 11001011b = 00011001b
-11010010b ^ 11001100b = 00011110b
-11010010b ^ 11001101b = 00011111b
-11010010b ^ 11001110b = 00011100b
-11010010b ^ 11001111b = 00011101b
-11010010b ^ 11010000b = 00000010b
-11010010b ^ 11010001b = 00000011b
-11010010b ^ 11010010b = 00000000b
-11010010b ^ 11010011b = 00000001b
-11010010b ^ 11010100b = 00000110b
-11010010b ^ 11010101b = 00000111b
-11010010b ^ 11010110b = 00000100b
-11010010b ^ 11010111b = 00000101b
-11010010b ^ 11011000b = 00001010b
-11010010b ^ 11011001b = 00001011b
-11010010b ^ 11011010b = 00001000b
-11010010b ^ 11011011b = 00001001b
-11010010b ^ 11011100b = 00001110b
-11010010b ^ 11011101b = 00001111b
-11010010b ^ 11011110b = 00001100b
-11010010b ^ 11011111b = 00001101b
-11010010b ^ 11100000b = 00110010b
-11010010b ^ 11100001b = 00110011b
-11010010b ^ 11100010b = 00110000b
-11010010b ^ 11100011b = 00110001b
-11010010b ^ 11100100b = 00110110b
-11010010b ^ 11100101b = 00110111b
-11010010b ^ 11100110b = 00110100b
-11010010b ^ 11100111b = 00110101b
-11010010b ^ 11101000b = 00111010b
-11010010b ^ 11101001b = 00111011b
-11010010b ^ 11101010b = 00111000b
-11010010b ^ 11101011b = 00111001b
-11010010b ^ 11101100b = 00111110b
-11010010b ^ 11101101b = 00111111b
-11010010b ^ 11101110b = 00111100b
-11010010b ^ 11101111b = 00111101b
-11010010b ^ 11110000b = 00100010b
-11010010b ^ 11110001b = 00100011b
-11010010b ^ 11110010b = 00100000b
-11010010b ^ 11110011b = 00100001b
-11010010b ^ 11110100b = 00100110b
-11010010b ^ 11110101b = 00100111b
-11010010b ^ 11110110b = 00100100b
-11010010b ^ 11110111b = 00100101b
-11010010b ^ 11111000b = 00101010b
-11010010b ^ 11111001b = 00101011b
-11010010b ^ 11111010b = 00101000b
-11010010b ^ 11111011b = 00101001b
-11010010b ^ 11111100b = 00101110b
-11010010b ^ 11111101b = 00101111b
-11010010b ^ 11111110b = 00101100b
-11010010b ^ 11111111b = 00101101b
-11010010b ^ 00000000b = 11010010b
-11010010b ^ 00000001b = 11010011b
-11010010b ^ 00000010b = 11010000b
-11010010b ^ 00000011b = 11010001b
-11010010b ^ 00000100b = 11010110b
-11010010b ^ 00000101b = 11010111b
-11010010b ^ 00000110b = 11010100b
-11010010b ^ 00000111b = 11010101b
-11010010b ^ 00001000b = 11011010b
-11010010b ^ 00001001b = 11011011b
-11010010b ^ 00001010b = 11011000b
-11010010b ^ 00001011b = 11011001b
-11010010b ^ 00001100b = 11011110b
-11010010b ^ 00001101b = 11011111b
-11010010b ^ 00001110b = 11011100b
-11010010b ^ 00001111b = 11011101b
-11010010b ^ 00010000b = 11000010b
-11010010b ^ 00010001b = 11000011b
-11010010b ^ 00010010b = 11000000b
-11010010b ^ 00010011b = 11000001b
-11010010b ^ 00010100b = 11000110b
-11010010b ^ 00010101b = 11000111b
-11010010b ^ 00010110b = 11000100b
-11010010b ^ 00010111b = 11000101b
-11010010b ^ 00011000b = 11001010b
-11010010b ^ 00011001b = 11001011b
-11010010b ^ 00011010b = 11001000b
-11010010b ^ 00011011b = 11001001b
-11010010b ^ 00011100b = 11001110b
-11010010b ^ 00011101b = 11001111b
-11010010b ^ 00011110b = 11001100b
-11010010b ^ 00011111b = 11001101b
-11010010b ^ 00100000b = 11110010b
-11010010b ^ 00100001b = 11110011b
-11010010b ^ 00100010b = 11110000b
-11010010b ^ 00100011b = 11110001b
-11010010b ^ 00100100b = 11110110b
-11010010b ^ 00100101b = 11110111b
-11010010b ^ 00100110b = 11110100b
-11010010b ^ 00100111b = 11110101b
-11010010b ^ 00101000b = 11111010b
-11010010b ^ 00101001b = 11111011b
-11010010b ^ 00101010b = 11111000b
-11010010b ^ 00101011b = 11111001b
-11010010b ^ 00101100b = 11111110b
-11010010b ^ 00101101b = 11111111b
-11010010b ^ 00101110b = 11111100b
-11010010b ^ 00101111b = 11111101b
-11010010b ^ 00110000b = 11100010b
-11010010b ^ 00110001b = 11100011b
-11010010b ^ 00110010b = 11100000b
-11010010b ^ 00110011b = 11100001b
-11010010b ^ 00110100b = 11100110b
-11010010b ^ 00110101b = 11100111b
-11010010b ^ 00110110b = 11100100b
-11010010b ^ 00110111b = 11100101b
-11010010b ^ 00111000b = 11101010b
-11010010b ^ 00111001b = 11101011b
-11010010b ^ 00111010b = 11101000b
-11010010b ^ 00111011b = 11101001b
-11010010b ^ 00111100b = 11101110b
-11010010b ^ 00111101b = 11101111b
-11010010b ^ 00111110b = 11101100b
-11010010b ^ 00111111b = 11101101b
-11010010b ^ 01000000b = 10010010b
-11010010b ^ 01000001b = 10010011b
-11010010b ^ 01000010b = 10010000b
-11010010b ^ 01000011b = 10010001b
-11010010b ^ 01000100b = 10010110b
-11010010b ^ 01000101b = 10010111b
-11010010b ^ 01000110b = 10010100b
-11010010b ^ 01000111b = 10010101b
-11010010b ^ 01001000b = 10011010b
-11010010b ^ 01001001b = 10011011b
-11010010b ^ 01001010b = 10011000b
-11010010b ^ 01001011b = 10011001b
-11010010b ^ 01001100b = 10011110b
-11010010b ^ 01001101b = 10011111b
-11010010b ^ 01001110b = 10011100b
-11010010b ^ 01001111b = 10011101b
-11010010b ^ 01010000b = 10000010b
-11010010b ^ 01010001b = 10000011b
-11010010b ^ 01010010b = 10000000b
-11010010b ^ 01010011b = 10000001b
-11010010b ^ 01010100b = 10000110b
-11010010b ^ 01010101b = 10000111b
-11010010b ^ 01010110b = 10000100b
-11010010b ^ 01010111b = 10000101b
-11010010b ^ 01011000b = 10001010b
-11010010b ^ 01011001b = 10001011b
-11010010b ^ 01011010b = 10001000b
-11010010b ^ 01011011b = 10001001b
-11010010b ^ 01011100b = 10001110b
-11010010b ^ 01011101b = 10001111b
-11010010b ^ 01011110b = 10001100b
-11010010b ^ 01011111b = 10001101b
-11010010b ^ 01100000b = 10110010b
-11010010b ^ 01100001b = 10110011b
-11010010b ^ 01100010b = 10110000b
-11010010b ^ 01100011b = 10110001b
-11010010b ^ 01100100b = 10110110b
-11010010b ^ 01100101b = 10110111b
-11010010b ^ 01100110b = 10110100b
-11010010b ^ 01100111b = 10110101b
-11010010b ^ 01101000b = 10111010b
-11010010b ^ 01101001b = 10111011b
-11010010b ^ 01101010b = 10111000b
-11010010b ^ 01101011b = 10111001b
-11010010b ^ 01101100b = 10111110b
-11010010b ^ 01101101b = 10111111b
-11010010b ^ 01101110b = 10111100b
-11010010b ^ 01101111b = 10111101b
-11010010b ^ 01110000b = 10100010b
-11010010b ^ 01110001b = 10100011b
-11010010b ^ 01110010b = 10100000b
-11010010b ^ 01110011b = 10100001b
-11010010b ^ 01110100b = 10100110b
-11010010b ^ 01110101b = 10100111b
-11010010b ^ 01110110b = 10100100b
-11010010b ^ 01110111b = 10100101b
-11010010b ^ 01111000b = 10101010b
-11010010b ^ 01111001b = 10101011b
-11010010b ^ 01111010b = 10101000b
-11010010b ^ 01111011b = 10101001b
-11010010b ^ 01111100b = 10101110b
-11010010b ^ 01111101b = 10101111b
-11010010b ^ 01111110b = 10101100b
-11010011b ^ 10000000b = 01010011b
-11010011b ^ 10000001b = 01010010b
-11010011b ^ 10000010b = 01010001b
-11010011b ^ 10000011b = 01010000b
-11010011b ^ 10000100b = 01010111b
-11010011b ^ 10000101b = 01010110b
-11010011b ^ 10000110b = 01010101b
-11010011b ^ 10000111b = 01010100b
-11010011b ^ 10001000b = 01011011b
-11010011b ^ 10001001b = 01011010b
-11010011b ^ 10001010b = 01011001b
-11010011b ^ 10001011b = 01011000b
-11010011b ^ 10001100b = 01011111b
-11010011b ^ 10001101b = 01011110b
-11010011b ^ 10001110b = 01011101b
-11010011b ^ 10001111b = 01011100b
-11010011b ^ 10010000b = 01000011b
-11010011b ^ 10010001b = 01000010b
-11010011b ^ 10010010b = 01000001b
-11010011b ^ 10010011b = 01000000b
-11010011b ^ 10010100b = 01000111b
-11010011b ^ 10010101b = 01000110b
-11010011b ^ 10010110b = 01000101b
-11010011b ^ 10010111b = 01000100b
-11010011b ^ 10011000b = 01001011b
-11010011b ^ 10011001b = 01001010b
-11010011b ^ 10011010b = 01001001b
-11010011b ^ 10011011b = 01001000b
-11010011b ^ 10011100b = 01001111b
-11010011b ^ 10011101b = 01001110b
-11010011b ^ 10011110b = 01001101b
-11010011b ^ 10011111b = 01001100b
-11010011b ^ 10100000b = 01110011b
-11010011b ^ 10100001b = 01110010b
-11010011b ^ 10100010b = 01110001b
-11010011b ^ 10100011b = 01110000b
-11010011b ^ 10100100b = 01110111b
-11010011b ^ 10100101b = 01110110b
-11010011b ^ 10100110b = 01110101b
-11010011b ^ 10100111b = 01110100b
-11010011b ^ 10101000b = 01111011b
-11010011b ^ 10101001b = 01111010b
-11010011b ^ 10101010b = 01111001b
-11010011b ^ 10101011b = 01111000b
-11010011b ^ 10101100b = 01111111b
-11010011b ^ 10101101b = 01111110b
-11010011b ^ 10101110b = 01111101b
-11010011b ^ 10101111b = 01111100b
-11010011b ^ 10110000b = 01100011b
-11010011b ^ 10110001b = 01100010b
-11010011b ^ 10110010b = 01100001b
-11010011b ^ 10110011b = 01100000b
-11010011b ^ 10110100b = 01100111b
-11010011b ^ 10110101b = 01100110b
-11010011b ^ 10110110b = 01100101b
-11010011b ^ 10110111b = 01100100b
-11010011b ^ 10111000b = 01101011b
-11010011b ^ 10111001b = 01101010b
-11010011b ^ 10111010b = 01101001b
-11010011b ^ 10111011b = 01101000b
-11010011b ^ 10111100b = 01101111b
-11010011b ^ 10111101b = 01101110b
-11010011b ^ 10111110b = 01101101b
-11010011b ^ 10111111b = 01101100b
-11010011b ^ 11000000b = 00010011b
-11010011b ^ 11000001b = 00010010b
-11010011b ^ 11000010b = 00010001b
-11010011b ^ 11000011b = 00010000b
-11010011b ^ 11000100b = 00010111b
-11010011b ^ 11000101b = 00010110b
-11010011b ^ 11000110b = 00010101b
-11010011b ^ 11000111b = 00010100b
-11010011b ^ 11001000b = 00011011b
-11010011b ^ 11001001b = 00011010b
-11010011b ^ 11001010b = 00011001b
-11010011b ^ 11001011b = 00011000b
-11010011b ^ 11001100b = 00011111b
-11010011b ^ 11001101b = 00011110b
-11010011b ^ 11001110b = 00011101b
-11010011b ^ 11001111b = 00011100b
-11010011b ^ 11010000b = 00000011b
-11010011b ^ 11010001b = 00000010b
-11010011b ^ 11010010b = 00000001b
-11010011b ^ 11010011b = 00000000b
-11010011b ^ 11010100b = 00000111b
-11010011b ^ 11010101b = 00000110b
-11010011b ^ 11010110b = 00000101b
-11010011b ^ 11010111b = 00000100b
-11010011b ^ 11011000b = 00001011b
-11010011b ^ 11011001b = 00001010b
-11010011b ^ 11011010b = 00001001b
-11010011b ^ 11011011b = 00001000b
-11010011b ^ 11011100b = 00001111b
-11010011b ^ 11011101b = 00001110b
-11010011b ^ 11011110b = 00001101b
-11010011b ^ 11011111b = 00001100b
-11010011b ^ 11100000b = 00110011b
-11010011b ^ 11100001b = 00110010b
-11010011b ^ 11100010b = 00110001b
-11010011b ^ 11100011b = 00110000b
-11010011b ^ 11100100b = 00110111b
-11010011b ^ 11100101b = 00110110b
-11010011b ^ 11100110b = 00110101b
-11010011b ^ 11100111b = 00110100b
-11010011b ^ 11101000b = 00111011b
-11010011b ^ 11101001b = 00111010b
-11010011b ^ 11101010b = 00111001b
-11010011b ^ 11101011b = 00111000b
-11010011b ^ 11101100b = 00111111b
-11010011b ^ 11101101b = 00111110b
-11010011b ^ 11101110b = 00111101b
-11010011b ^ 11101111b = 00111100b
-11010011b ^ 11110000b = 00100011b
-11010011b ^ 11110001b = 00100010b
-11010011b ^ 11110010b = 00100001b
-11010011b ^ 11110011b = 00100000b
-11010011b ^ 11110100b = 00100111b
-11010011b ^ 11110101b = 00100110b
-11010011b ^ 11110110b = 00100101b
-11010011b ^ 11110111b = 00100100b
-11010011b ^ 11111000b = 00101011b
-11010011b ^ 11111001b = 00101010b
-11010011b ^ 11111010b = 00101001b
-11010011b ^ 11111011b = 00101000b
-11010011b ^ 11111100b = 00101111b
-11010011b ^ 11111101b = 00101110b
-11010011b ^ 11111110b = 00101101b
-11010011b ^ 11111111b = 00101100b
-11010011b ^ 00000000b = 11010011b
-11010011b ^ 00000001b = 11010010b
-11010011b ^ 00000010b = 11010001b
-11010011b ^ 00000011b = 11010000b
-11010011b ^ 00000100b = 11010111b
-11010011b ^ 00000101b = 11010110b
-11010011b ^ 00000110b = 11010101b
-11010011b ^ 00000111b = 11010100b
-11010011b ^ 00001000b = 11011011b
-11010011b ^ 00001001b = 11011010b
-11010011b ^ 00001010b = 11011001b
-11010011b ^ 00001011b = 11011000b
-11010011b ^ 00001100b = 11011111b
-11010011b ^ 00001101b = 11011110b
-11010011b ^ 00001110b = 11011101b
-11010011b ^ 00001111b = 11011100b
-11010011b ^ 00010000b = 11000011b
-11010011b ^ 00010001b = 11000010b
-11010011b ^ 00010010b = 11000001b
-11010011b ^ 00010011b = 11000000b
-11010011b ^ 00010100b = 11000111b
-11010011b ^ 00010101b = 11000110b
-11010011b ^ 00010110b = 11000101b
-11010011b ^ 00010111b = 11000100b
-11010011b ^ 00011000b = 11001011b
-11010011b ^ 00011001b = 11001010b
-11010011b ^ 00011010b = 11001001b
-11010011b ^ 00011011b = 11001000b
-11010011b ^ 00011100b = 11001111b
-11010011b ^ 00011101b = 11001110b
-11010011b ^ 00011110b = 11001101b
-11010011b ^ 00011111b = 11001100b
-11010011b ^ 00100000b = 11110011b
-11010011b ^ 00100001b = 11110010b
-11010011b ^ 00100010b = 11110001b
-11010011b ^ 00100011b = 11110000b
-11010011b ^ 00100100b = 11110111b
-11010011b ^ 00100101b = 11110110b
-11010011b ^ 00100110b = 11110101b
-11010011b ^ 00100111b = 11110100b
-11010011b ^ 00101000b = 11111011b
-11010011b ^ 00101001b = 11111010b
-11010011b ^ 00101010b = 11111001b
-11010011b ^ 00101011b = 11111000b
-11010011b ^ 00101100b = 11111111b
-11010011b ^ 00101101b = 11111110b
-11010011b ^ 00101110b = 11111101b
-11010011b ^ 00101111b = 11111100b
-11010011b ^ 00110000b = 11100011b
-11010011b ^ 00110001b = 11100010b
-11010011b ^ 00110010b = 11100001b
-11010011b ^ 00110011b = 11100000b
-11010011b ^ 00110100b = 11100111b
-11010011b ^ 00110101b = 11100110b
-11010011b ^ 00110110b = 11100101b
-11010011b ^ 00110111b = 11100100b
-11010011b ^ 00111000b = 11101011b
-11010011b ^ 00111001b = 11101010b
-11010011b ^ 00111010b = 11101001b
-11010011b ^ 00111011b = 11101000b
-11010011b ^ 00111100b = 11101111b
-11010011b ^ 00111101b = 11101110b
-11010011b ^ 00111110b = 11101101b
-11010011b ^ 00111111b = 11101100b
-11010011b ^ 01000000b = 10010011b
-11010011b ^ 01000001b = 10010010b
-11010011b ^ 01000010b = 10010001b
-11010011b ^ 01000011b = 10010000b
-11010011b ^ 01000100b = 10010111b
-11010011b ^ 01000101b = 10010110b
-11010011b ^ 01000110b = 10010101b
-11010011b ^ 01000111b = 10010100b
-11010011b ^ 01001000b = 10011011b
-11010011b ^ 01001001b = 10011010b
-11010011b ^ 01001010b = 10011001b
-11010011b ^ 01001011b = 10011000b
-11010011b ^ 01001100b = 10011111b
-11010011b ^ 01001101b = 10011110b
-11010011b ^ 01001110b = 10011101b
-11010011b ^ 01001111b = 10011100b
-11010011b ^ 01010000b = 10000011b
-11010011b ^ 01010001b = 10000010b
-11010011b ^ 01010010b = 10000001b
-11010011b ^ 01010011b = 10000000b
-11010011b ^ 01010100b = 10000111b
-11010011b ^ 01010101b = 10000110b
-11010011b ^ 01010110b = 10000101b
-11010011b ^ 01010111b = 10000100b
-11010011b ^ 01011000b = 10001011b
-11010011b ^ 01011001b = 10001010b
-11010011b ^ 01011010b = 10001001b
-11010011b ^ 01011011b = 10001000b
-11010011b ^ 01011100b = 10001111b
-11010011b ^ 01011101b = 10001110b
-11010011b ^ 01011110b = 10001101b
-11010011b ^ 01011111b = 10001100b
-11010011b ^ 01100000b = 10110011b
-11010011b ^ 01100001b = 10110010b
-11010011b ^ 01100010b = 10110001b
-11010011b ^ 01100011b = 10110000b
-11010011b ^ 01100100b = 10110111b
-11010011b ^ 01100101b = 10110110b
-11010011b ^ 01100110b = 10110101b
-11010011b ^ 01100111b = 10110100b
-11010011b ^ 01101000b = 10111011b
-11010011b ^ 01101001b = 10111010b
-11010011b ^ 01101010b = 10111001b
-11010011b ^ 01101011b = 10111000b
-11010011b ^ 01101100b = 10111111b
-11010011b ^ 01101101b = 10111110b
-11010011b ^ 01101110b = 10111101b
-11010011b ^ 01101111b = 10111100b
-11010011b ^ 01110000b = 10100011b
-11010011b ^ 01110001b = 10100010b
-11010011b ^ 01110010b = 10100001b
-11010011b ^ 01110011b = 10100000b
-11010011b ^ 01110100b = 10100111b
-11010011b ^ 01110101b = 10100110b
-11010011b ^ 01110110b = 10100101b
-11010011b ^ 01110111b = 10100100b
-11010011b ^ 01111000b = 10101011b
-11010011b ^ 01111001b = 10101010b
-11010011b ^ 01111010b = 10101001b
-11010011b ^ 01111011b = 10101000b
-11010011b ^ 01111100b = 10101111b
-11010011b ^ 01111101b = 10101110b
-11010011b ^ 01111110b = 10101101b
-11010100b ^ 10000000b = 01010100b
-11010100b ^ 10000001b = 01010101b
-11010100b ^ 10000010b = 01010110b
-11010100b ^ 10000011b = 01010111b
-11010100b ^ 10000100b = 01010000b
-11010100b ^ 10000101b = 01010001b
-11010100b ^ 10000110b = 01010010b
-11010100b ^ 10000111b = 01010011b
-11010100b ^ 10001000b = 01011100b
-11010100b ^ 10001001b = 01011101b
-11010100b ^ 10001010b = 01011110b
-11010100b ^ 10001011b = 01011111b
-11010100b ^ 10001100b = 01011000b
-11010100b ^ 10001101b = 01011001b
-11010100b ^ 10001110b = 01011010b
-11010100b ^ 10001111b = 01011011b
-11010100b ^ 10010000b = 01000100b
-11010100b ^ 10010001b = 01000101b
-11010100b ^ 10010010b = 01000110b
-11010100b ^ 10010011b = 01000111b
-11010100b ^ 10010100b = 01000000b
-11010100b ^ 10010101b = 01000001b
-11010100b ^ 10010110b = 01000010b
-11010100b ^ 10010111b = 01000011b
-11010100b ^ 10011000b = 01001100b
-11010100b ^ 10011001b = 01001101b
-11010100b ^ 10011010b = 01001110b
-11010100b ^ 10011011b = 01001111b
-11010100b ^ 10011100b = 01001000b
-11010100b ^ 10011101b = 01001001b
-11010100b ^ 10011110b = 01001010b
-11010100b ^ 10011111b = 01001011b
-11010100b ^ 10100000b = 01110100b
-11010100b ^ 10100001b = 01110101b
-11010100b ^ 10100010b = 01110110b
-11010100b ^ 10100011b = 01110111b
-11010100b ^ 10100100b = 01110000b
-11010100b ^ 10100101b = 01110001b
-11010100b ^ 10100110b = 01110010b
-11010100b ^ 10100111b = 01110011b
-11010100b ^ 10101000b = 01111100b
-11010100b ^ 10101001b = 01111101b
-11010100b ^ 10101010b = 01111110b
-11010100b ^ 10101011b = 01111111b
-11010100b ^ 10101100b = 01111000b
-11010100b ^ 10101101b = 01111001b
-11010100b ^ 10101110b = 01111010b
-11010100b ^ 10101111b = 01111011b
-11010100b ^ 10110000b = 01100100b
-11010100b ^ 10110001b = 01100101b
-11010100b ^ 10110010b = 01100110b
-11010100b ^ 10110011b = 01100111b
-11010100b ^ 10110100b = 01100000b
-11010100b ^ 10110101b = 01100001b
-11010100b ^ 10110110b = 01100010b
-11010100b ^ 10110111b = 01100011b
-11010100b ^ 10111000b = 01101100b
-11010100b ^ 10111001b = 01101101b
-11010100b ^ 10111010b = 01101110b
-11010100b ^ 10111011b = 01101111b
-11010100b ^ 10111100b = 01101000b
-11010100b ^ 10111101b = 01101001b
-11010100b ^ 10111110b = 01101010b
-11010100b ^ 10111111b = 01101011b
-11010100b ^ 11000000b = 00010100b
-11010100b ^ 11000001b = 00010101b
-11010100b ^ 11000010b = 00010110b
-11010100b ^ 11000011b = 00010111b
-11010100b ^ 11000100b = 00010000b
-11010100b ^ 11000101b = 00010001b
-11010100b ^ 11000110b = 00010010b
-11010100b ^ 11000111b = 00010011b
-11010100b ^ 11001000b = 00011100b
-11010100b ^ 11001001b = 00011101b
-11010100b ^ 11001010b = 00011110b
-11010100b ^ 11001011b = 00011111b
-11010100b ^ 11001100b = 00011000b
-11010100b ^ 11001101b = 00011001b
-11010100b ^ 11001110b = 00011010b
-11010100b ^ 11001111b = 00011011b
-11010100b ^ 11010000b = 00000100b
-11010100b ^ 11010001b = 00000101b
-11010100b ^ 11010010b = 00000110b
-11010100b ^ 11010011b = 00000111b
-11010100b ^ 11010100b = 00000000b
-11010100b ^ 11010101b = 00000001b
-11010100b ^ 11010110b = 00000010b
-11010100b ^ 11010111b = 00000011b
-11010100b ^ 11011000b = 00001100b
-11010100b ^ 11011001b = 00001101b
-11010100b ^ 11011010b = 00001110b
-11010100b ^ 11011011b = 00001111b
-11010100b ^ 11011100b = 00001000b
-11010100b ^ 11011101b = 00001001b
-11010100b ^ 11011110b = 00001010b
-11010100b ^ 11011111b = 00001011b
-11010100b ^ 11100000b = 00110100b
-11010100b ^ 11100001b = 00110101b
-11010100b ^ 11100010b = 00110110b
-11010100b ^ 11100011b = 00110111b
-11010100b ^ 11100100b = 00110000b
-11010100b ^ 11100101b = 00110001b
-11010100b ^ 11100110b = 00110010b
-11010100b ^ 11100111b = 00110011b
-11010100b ^ 11101000b = 00111100b
-11010100b ^ 11101001b = 00111101b
-11010100b ^ 11101010b = 00111110b
-11010100b ^ 11101011b = 00111111b
-11010100b ^ 11101100b = 00111000b
-11010100b ^ 11101101b = 00111001b
-11010100b ^ 11101110b = 00111010b
-11010100b ^ 11101111b = 00111011b
-11010100b ^ 11110000b = 00100100b
-11010100b ^ 11110001b = 00100101b
-11010100b ^ 11110010b = 00100110b
-11010100b ^ 11110011b = 00100111b
-11010100b ^ 11110100b = 00100000b
-11010100b ^ 11110101b = 00100001b
-11010100b ^ 11110110b = 00100010b
-11010100b ^ 11110111b = 00100011b
-11010100b ^ 11111000b = 00101100b
-11010100b ^ 11111001b = 00101101b
-11010100b ^ 11111010b = 00101110b
-11010100b ^ 11111011b = 00101111b
-11010100b ^ 11111100b = 00101000b
-11010100b ^ 11111101b = 00101001b
-11010100b ^ 11111110b = 00101010b
-11010100b ^ 11111111b = 00101011b
-11010100b ^ 00000000b = 11010100b
-11010100b ^ 00000001b = 11010101b
-11010100b ^ 00000010b = 11010110b
-11010100b ^ 00000011b = 11010111b
-11010100b ^ 00000100b = 11010000b
-11010100b ^ 00000101b = 11010001b
-11010100b ^ 00000110b = 11010010b
-11010100b ^ 00000111b = 11010011b
-11010100b ^ 00001000b = 11011100b
-11010100b ^ 00001001b = 11011101b
-11010100b ^ 00001010b = 11011110b
-11010100b ^ 00001011b = 11011111b
-11010100b ^ 00001100b = 11011000b
-11010100b ^ 00001101b = 11011001b
-11010100b ^ 00001110b = 11011010b
-11010100b ^ 00001111b = 11011011b
-11010100b ^ 00010000b = 11000100b
-11010100b ^ 00010001b = 11000101b
-11010100b ^ 00010010b = 11000110b
-11010100b ^ 00010011b = 11000111b
-11010100b ^ 00010100b = 11000000b
-11010100b ^ 00010101b = 11000001b
-11010100b ^ 00010110b = 11000010b
-11010100b ^ 00010111b = 11000011b
-11010100b ^ 00011000b = 11001100b
-11010100b ^ 00011001b = 11001101b
-11010100b ^ 00011010b = 11001110b
-11010100b ^ 00011011b = 11001111b
-11010100b ^ 00011100b = 11001000b
-11010100b ^ 00011101b = 11001001b
-11010100b ^ 00011110b = 11001010b
-11010100b ^ 00011111b = 11001011b
-11010100b ^ 00100000b = 11110100b
-11010100b ^ 00100001b = 11110101b
-11010100b ^ 00100010b = 11110110b
-11010100b ^ 00100011b = 11110111b
-11010100b ^ 00100100b = 11110000b
-11010100b ^ 00100101b = 11110001b
-11010100b ^ 00100110b = 11110010b
-11010100b ^ 00100111b = 11110011b
-11010100b ^ 00101000b = 11111100b
-11010100b ^ 00101001b = 11111101b
-11010100b ^ 00101010b = 11111110b
-11010100b ^ 00101011b = 11111111b
-11010100b ^ 00101100b = 11111000b
-11010100b ^ 00101101b = 11111001b
-11010100b ^ 00101110b = 11111010b
-11010100b ^ 00101111b = 11111011b
-11010100b ^ 00110000b = 11100100b
-11010100b ^ 00110001b = 11100101b
-11010100b ^ 00110010b = 11100110b
-11010100b ^ 00110011b = 11100111b
-11010100b ^ 00110100b = 11100000b
-11010100b ^ 00110101b = 11100001b
-11010100b ^ 00110110b = 11100010b
-11010100b ^ 00110111b = 11100011b
-11010100b ^ 00111000b = 11101100b
-11010100b ^ 00111001b = 11101101b
-11010100b ^ 00111010b = 11101110b
-11010100b ^ 00111011b = 11101111b
-11010100b ^ 00111100b = 11101000b
-11010100b ^ 00111101b = 11101001b
-11010100b ^ 00111110b = 11101010b
-11010100b ^ 00111111b = 11101011b
-11010100b ^ 01000000b = 10010100b
-11010100b ^ 01000001b = 10010101b
-11010100b ^ 01000010b = 10010110b
-11010100b ^ 01000011b = 10010111b
-11010100b ^ 01000100b = 10010000b
-11010100b ^ 01000101b = 10010001b
-11010100b ^ 01000110b = 10010010b
-11010100b ^ 01000111b = 10010011b
-11010100b ^ 01001000b = 10011100b
-11010100b ^ 01001001b = 10011101b
-11010100b ^ 01001010b = 10011110b
-11010100b ^ 01001011b = 10011111b
-11010100b ^ 01001100b = 10011000b
-11010100b ^ 01001101b = 10011001b
-11010100b ^ 01001110b = 10011010b
-11010100b ^ 01001111b = 10011011b
-11010100b ^ 01010000b = 10000100b
-11010100b ^ 01010001b = 10000101b
-11010100b ^ 01010010b = 10000110b
-11010100b ^ 01010011b = 10000111b
-11010100b ^ 01010100b = 10000000b
-11010100b ^ 01010101b = 10000001b
-11010100b ^ 01010110b = 10000010b
-11010100b ^ 01010111b = 10000011b
-11010100b ^ 01011000b = 10001100b
-11010100b ^ 01011001b = 10001101b
-11010100b ^ 01011010b = 10001110b
-11010100b ^ 01011011b = 10001111b
-11010100b ^ 01011100b = 10001000b
-11010100b ^ 01011101b = 10001001b
-11010100b ^ 01011110b = 10001010b
-11010100b ^ 01011111b = 10001011b
-11010100b ^ 01100000b = 10110100b
-11010100b ^ 01100001b = 10110101b
-11010100b ^ 01100010b = 10110110b
-11010100b ^ 01100011b = 10110111b
-11010100b ^ 01100100b = 10110000b
-11010100b ^ 01100101b = 10110001b
-11010100b ^ 01100110b = 10110010b
-11010100b ^ 01100111b = 10110011b
-11010100b ^ 01101000b = 10111100b
-11010100b ^ 01101001b = 10111101b
-11010100b ^ 01101010b = 10111110b
-11010100b ^ 01101011b = 10111111b
-11010100b ^ 01101100b = 10111000b
-11010100b ^ 01101101b = 10111001b
-11010100b ^ 01101110b = 10111010b
-11010100b ^ 01101111b = 10111011b
-11010100b ^ 01110000b = 10100100b
-11010100b ^ 01110001b = 10100101b
-11010100b ^ 01110010b = 10100110b
-11010100b ^ 01110011b = 10100111b
-11010100b ^ 01110100b = 10100000b
-11010100b ^ 01110101b = 10100001b
-11010100b ^ 01110110b = 10100010b
-11010100b ^ 01110111b = 10100011b
-11010100b ^ 01111000b = 10101100b
-11010100b ^ 01111001b = 10101101b
-11010100b ^ 01111010b = 10101110b
-11010100b ^ 01111011b = 10101111b
-11010100b ^ 01111100b = 10101000b
-11010100b ^ 01111101b = 10101001b
-11010100b ^ 01111110b = 10101010b
-11010101b ^ 10000000b = 01010101b
-11010101b ^ 10000001b = 01010100b
-11010101b ^ 10000010b = 01010111b
-11010101b ^ 10000011b = 01010110b
-11010101b ^ 10000100b = 01010001b
-11010101b ^ 10000101b = 01010000b
-11010101b ^ 10000110b = 01010011b
-11010101b ^ 10000111b = 01010010b
-11010101b ^ 10001000b = 01011101b
-11010101b ^ 10001001b = 01011100b
-11010101b ^ 10001010b = 01011111b
-11010101b ^ 10001011b = 01011110b
-11010101b ^ 10001100b = 01011001b
-11010101b ^ 10001101b = 01011000b
-11010101b ^ 10001110b = 01011011b
-11010101b ^ 10001111b = 01011010b
-11010101b ^ 10010000b = 01000101b
-11010101b ^ 10010001b = 01000100b
-11010101b ^ 10010010b = 01000111b
-11010101b ^ 10010011b = 01000110b
-11010101b ^ 10010100b = 01000001b
-11010101b ^ 10010101b = 01000000b
-11010101b ^ 10010110b = 01000011b
-11010101b ^ 10010111b = 01000010b
-11010101b ^ 10011000b = 01001101b
-11010101b ^ 10011001b = 01001100b
-11010101b ^ 10011010b = 01001111b
-11010101b ^ 10011011b = 01001110b
-11010101b ^ 10011100b = 01001001b
-11010101b ^ 10011101b = 01001000b
-11010101b ^ 10011110b = 01001011b
-11010101b ^ 10011111b = 01001010b
-11010101b ^ 10100000b = 01110101b
-11010101b ^ 10100001b = 01110100b
-11010101b ^ 10100010b = 01110111b
-11010101b ^ 10100011b = 01110110b
-11010101b ^ 10100100b = 01110001b
-11010101b ^ 10100101b = 01110000b
-11010101b ^ 10100110b = 01110011b
-11010101b ^ 10100111b = 01110010b
-11010101b ^ 10101000b = 01111101b
-11010101b ^ 10101001b = 01111100b
-11010101b ^ 10101010b = 01111111b
-11010101b ^ 10101011b = 01111110b
-11010101b ^ 10101100b = 01111001b
-11010101b ^ 10101101b = 01111000b
-11010101b ^ 10101110b = 01111011b
-11010101b ^ 10101111b = 01111010b
-11010101b ^ 10110000b = 01100101b
-11010101b ^ 10110001b = 01100100b
-11010101b ^ 10110010b = 01100111b
-11010101b ^ 10110011b = 01100110b
-11010101b ^ 10110100b = 01100001b
-11010101b ^ 10110101b = 01100000b
-11010101b ^ 10110110b = 01100011b
-11010101b ^ 10110111b = 01100010b
-11010101b ^ 10111000b = 01101101b
-11010101b ^ 10111001b = 01101100b
-11010101b ^ 10111010b = 01101111b
-11010101b ^ 10111011b = 01101110b
-11010101b ^ 10111100b = 01101001b
-11010101b ^ 10111101b = 01101000b
-11010101b ^ 10111110b = 01101011b
-11010101b ^ 10111111b = 01101010b
-11010101b ^ 11000000b = 00010101b
-11010101b ^ 11000001b = 00010100b
-11010101b ^ 11000010b = 00010111b
-11010101b ^ 11000011b = 00010110b
-11010101b ^ 11000100b = 00010001b
-11010101b ^ 11000101b = 00010000b
-11010101b ^ 11000110b = 00010011b
-11010101b ^ 11000111b = 00010010b
-11010101b ^ 11001000b = 00011101b
-11010101b ^ 11001001b = 00011100b
-11010101b ^ 11001010b = 00011111b
-11010101b ^ 11001011b = 00011110b
-11010101b ^ 11001100b = 00011001b
-11010101b ^ 11001101b = 00011000b
-11010101b ^ 11001110b = 00011011b
-11010101b ^ 11001111b = 00011010b
-11010101b ^ 11010000b = 00000101b
-11010101b ^ 11010001b = 00000100b
-11010101b ^ 11010010b = 00000111b
-11010101b ^ 11010011b = 00000110b
-11010101b ^ 11010100b = 00000001b
-11010101b ^ 11010101b = 00000000b
-11010101b ^ 11010110b = 00000011b
-11010101b ^ 11010111b = 00000010b
-11010101b ^ 11011000b = 00001101b
-11010101b ^ 11011001b = 00001100b
-11010101b ^ 11011010b = 00001111b
-11010101b ^ 11011011b = 00001110b
-11010101b ^ 11011100b = 00001001b
-11010101b ^ 11011101b = 00001000b
-11010101b ^ 11011110b = 00001011b
-11010101b ^ 11011111b = 00001010b
-11010101b ^ 11100000b = 00110101b
-11010101b ^ 11100001b = 00110100b
-11010101b ^ 11100010b = 00110111b
-11010101b ^ 11100011b = 00110110b
-11010101b ^ 11100100b = 00110001b
-11010101b ^ 11100101b = 00110000b
-11010101b ^ 11100110b = 00110011b
-11010101b ^ 11100111b = 00110010b
-11010101b ^ 11101000b = 00111101b
-11010101b ^ 11101001b = 00111100b
-11010101b ^ 11101010b = 00111111b
-11010101b ^ 11101011b = 00111110b
-11010101b ^ 11101100b = 00111001b
-11010101b ^ 11101101b = 00111000b
-11010101b ^ 11101110b = 00111011b
-11010101b ^ 11101111b = 00111010b
-11010101b ^ 11110000b = 00100101b
-11010101b ^ 11110001b = 00100100b
-11010101b ^ 11110010b = 00100111b
-11010101b ^ 11110011b = 00100110b
-11010101b ^ 11110100b = 00100001b
-11010101b ^ 11110101b = 00100000b
-11010101b ^ 11110110b = 00100011b
-11010101b ^ 11110111b = 00100010b
-11010101b ^ 11111000b = 00101101b
-11010101b ^ 11111001b = 00101100b
-11010101b ^ 11111010b = 00101111b
-11010101b ^ 11111011b = 00101110b
-11010101b ^ 11111100b = 00101001b
-11010101b ^ 11111101b = 00101000b
-11010101b ^ 11111110b = 00101011b
-11010101b ^ 11111111b = 00101010b
-11010101b ^ 00000000b = 11010101b
-11010101b ^ 00000001b = 11010100b
-11010101b ^ 00000010b = 11010111b
-11010101b ^ 00000011b = 11010110b
-11010101b ^ 00000100b = 11010001b
-11010101b ^ 00000101b = 11010000b
-11010101b ^ 00000110b = 11010011b
-11010101b ^ 00000111b = 11010010b
-11010101b ^ 00001000b = 11011101b
-11010101b ^ 00001001b = 11011100b
-11010101b ^ 00001010b = 11011111b
-11010101b ^ 00001011b = 11011110b
-11010101b ^ 00001100b = 11011001b
-11010101b ^ 00001101b = 11011000b
-11010101b ^ 00001110b = 11011011b
-11010101b ^ 00001111b = 11011010b
-11010101b ^ 00010000b = 11000101b
-11010101b ^ 00010001b = 11000100b
-11010101b ^ 00010010b = 11000111b
-11010101b ^ 00010011b = 11000110b
-11010101b ^ 00010100b = 11000001b
-11010101b ^ 00010101b = 11000000b
-11010101b ^ 00010110b = 11000011b
-11010101b ^ 00010111b = 11000010b
-11010101b ^ 00011000b = 11001101b
-11010101b ^ 00011001b = 11001100b
-11010101b ^ 00011010b = 11001111b
-11010101b ^ 00011011b = 11001110b
-11010101b ^ 00011100b = 11001001b
-11010101b ^ 00011101b = 11001000b
-11010101b ^ 00011110b = 11001011b
-11010101b ^ 00011111b = 11001010b
-11010101b ^ 00100000b = 11110101b
-11010101b ^ 00100001b = 11110100b
-11010101b ^ 00100010b = 11110111b
-11010101b ^ 00100011b = 11110110b
-11010101b ^ 00100100b = 11110001b
-11010101b ^ 00100101b = 11110000b
-11010101b ^ 00100110b = 11110011b
-11010101b ^ 00100111b = 11110010b
-11010101b ^ 00101000b = 11111101b
-11010101b ^ 00101001b = 11111100b
-11010101b ^ 00101010b = 11111111b
-11010101b ^ 00101011b = 11111110b
-11010101b ^ 00101100b = 11111001b
-11010101b ^ 00101101b = 11111000b
-11010101b ^ 00101110b = 11111011b
-11010101b ^ 00101111b = 11111010b
-11010101b ^ 00110000b = 11100101b
-11010101b ^ 00110001b = 11100100b
-11010101b ^ 00110010b = 11100111b
-11010101b ^ 00110011b = 11100110b
-11010101b ^ 00110100b = 11100001b
-11010101b ^ 00110101b = 11100000b
-11010101b ^ 00110110b = 11100011b
-11010101b ^ 00110111b = 11100010b
-11010101b ^ 00111000b = 11101101b
-11010101b ^ 00111001b = 11101100b
-11010101b ^ 00111010b = 11101111b
-11010101b ^ 00111011b = 11101110b
-11010101b ^ 00111100b = 11101001b
-11010101b ^ 00111101b = 11101000b
-11010101b ^ 00111110b = 11101011b
-11010101b ^ 00111111b = 11101010b
-11010101b ^ 01000000b = 10010101b
-11010101b ^ 01000001b = 10010100b
-11010101b ^ 01000010b = 10010111b
-11010101b ^ 01000011b = 10010110b
-11010101b ^ 01000100b = 10010001b
-11010101b ^ 01000101b = 10010000b
-11010101b ^ 01000110b = 10010011b
-11010101b ^ 01000111b = 10010010b
-11010101b ^ 01001000b = 10011101b
-11010101b ^ 01001001b = 10011100b
-11010101b ^ 01001010b = 10011111b
-11010101b ^ 01001011b = 10011110b
-11010101b ^ 01001100b = 10011001b
-11010101b ^ 01001101b = 10011000b
-11010101b ^ 01001110b = 10011011b
-11010101b ^ 01001111b = 10011010b
-11010101b ^ 01010000b = 10000101b
-11010101b ^ 01010001b = 10000100b
-11010101b ^ 01010010b = 10000111b
-11010101b ^ 01010011b = 10000110b
-11010101b ^ 01010100b = 10000001b
-11010101b ^ 01010101b = 10000000b
-11010101b ^ 01010110b = 10000011b
-11010101b ^ 01010111b = 10000010b
-11010101b ^ 01011000b = 10001101b
-11010101b ^ 01011001b = 10001100b
-11010101b ^ 01011010b = 10001111b
-11010101b ^ 01011011b = 10001110b
-11010101b ^ 01011100b = 10001001b
-11010101b ^ 01011101b = 10001000b
-11010101b ^ 01011110b = 10001011b
-11010101b ^ 01011111b = 10001010b
-11010101b ^ 01100000b = 10110101b
-11010101b ^ 01100001b = 10110100b
-11010101b ^ 01100010b = 10110111b
-11010101b ^ 01100011b = 10110110b
-11010101b ^ 01100100b = 10110001b
-11010101b ^ 01100101b = 10110000b
-11010101b ^ 01100110b = 10110011b
-11010101b ^ 01100111b = 10110010b
-11010101b ^ 01101000b = 10111101b
-11010101b ^ 01101001b = 10111100b
-11010101b ^ 01101010b = 10111111b
-11010101b ^ 01101011b = 10111110b
-11010101b ^ 01101100b = 10111001b
-11010101b ^ 01101101b = 10111000b
-11010101b ^ 01101110b = 10111011b
-11010101b ^ 01101111b = 10111010b
-11010101b ^ 01110000b = 10100101b
-11010101b ^ 01110001b = 10100100b
-11010101b ^ 01110010b = 10100111b
-11010101b ^ 01110011b = 10100110b
-11010101b ^ 01110100b = 10100001b
-11010101b ^ 01110101b = 10100000b
-11010101b ^ 01110110b = 10100011b
-11010101b ^ 01110111b = 10100010b
-11010101b ^ 01111000b = 10101101b
-11010101b ^ 01111001b = 10101100b
-11010101b ^ 01111010b = 10101111b
-11010101b ^ 01111011b = 10101110b
-11010101b ^ 01111100b = 10101001b
-11010101b ^ 01111101b = 10101000b
-11010101b ^ 01111110b = 10101011b
-11010110b ^ 10000000b = 01010110b
-11010110b ^ 10000001b = 01010111b
-11010110b ^ 10000010b = 01010100b
-11010110b ^ 10000011b = 01010101b
-11010110b ^ 10000100b = 01010010b
-11010110b ^ 10000101b = 01010011b
-11010110b ^ 10000110b = 01010000b
-11010110b ^ 10000111b = 01010001b
-11010110b ^ 10001000b = 01011110b
-11010110b ^ 10001001b = 01011111b
-11010110b ^ 10001010b = 01011100b
-11010110b ^ 10001011b = 01011101b
-11010110b ^ 10001100b = 01011010b
-11010110b ^ 10001101b = 01011011b
-11010110b ^ 10001110b = 01011000b
-11010110b ^ 10001111b = 01011001b
-11010110b ^ 10010000b = 01000110b
-11010110b ^ 10010001b = 01000111b
-11010110b ^ 10010010b = 01000100b
-11010110b ^ 10010011b = 01000101b
-11010110b ^ 10010100b = 01000010b
-11010110b ^ 10010101b = 01000011b
-11010110b ^ 10010110b = 01000000b
-11010110b ^ 10010111b = 01000001b
-11010110b ^ 10011000b = 01001110b
-11010110b ^ 10011001b = 01001111b
-11010110b ^ 10011010b = 01001100b
-11010110b ^ 10011011b = 01001101b
-11010110b ^ 10011100b = 01001010b
-11010110b ^ 10011101b = 01001011b
-11010110b ^ 10011110b = 01001000b
-11010110b ^ 10011111b = 01001001b
-11010110b ^ 10100000b = 01110110b
-11010110b ^ 10100001b = 01110111b
-11010110b ^ 10100010b = 01110100b
-11010110b ^ 10100011b = 01110101b
-11010110b ^ 10100100b = 01110010b
-11010110b ^ 10100101b = 01110011b
-11010110b ^ 10100110b = 01110000b
-11010110b ^ 10100111b = 01110001b
-11010110b ^ 10101000b = 01111110b
-11010110b ^ 10101001b = 01111111b
-11010110b ^ 10101010b = 01111100b
-11010110b ^ 10101011b = 01111101b
-11010110b ^ 10101100b = 01111010b
-11010110b ^ 10101101b = 01111011b
-11010110b ^ 10101110b = 01111000b
-11010110b ^ 10101111b = 01111001b
-11010110b ^ 10110000b = 01100110b
-11010110b ^ 10110001b = 01100111b
-11010110b ^ 10110010b = 01100100b
-11010110b ^ 10110011b = 01100101b
-11010110b ^ 10110100b = 01100010b
-11010110b ^ 10110101b = 01100011b
-11010110b ^ 10110110b = 01100000b
-11010110b ^ 10110111b = 01100001b
-11010110b ^ 10111000b = 01101110b
-11010110b ^ 10111001b = 01101111b
-11010110b ^ 10111010b = 01101100b
-11010110b ^ 10111011b = 01101101b
-11010110b ^ 10111100b = 01101010b
-11010110b ^ 10111101b = 01101011b
-11010110b ^ 10111110b = 01101000b
-11010110b ^ 10111111b = 01101001b
-11010110b ^ 11000000b = 00010110b
-11010110b ^ 11000001b = 00010111b
-11010110b ^ 11000010b = 00010100b
-11010110b ^ 11000011b = 00010101b
-11010110b ^ 11000100b = 00010010b
-11010110b ^ 11000101b = 00010011b
-11010110b ^ 11000110b = 00010000b
-11010110b ^ 11000111b = 00010001b
-11010110b ^ 11001000b = 00011110b
-11010110b ^ 11001001b = 00011111b
-11010110b ^ 11001010b = 00011100b
-11010110b ^ 11001011b = 00011101b
-11010110b ^ 11001100b = 00011010b
-11010110b ^ 11001101b = 00011011b
-11010110b ^ 11001110b = 00011000b
-11010110b ^ 11001111b = 00011001b
-11010110b ^ 11010000b = 00000110b
-11010110b ^ 11010001b = 00000111b
-11010110b ^ 11010010b = 00000100b
-11010110b ^ 11010011b = 00000101b
-11010110b ^ 11010100b = 00000010b
-11010110b ^ 11010101b = 00000011b
-11010110b ^ 11010110b = 00000000b
-11010110b ^ 11010111b = 00000001b
-11010110b ^ 11011000b = 00001110b
-11010110b ^ 11011001b = 00001111b
-11010110b ^ 11011010b = 00001100b
-11010110b ^ 11011011b = 00001101b
-11010110b ^ 11011100b = 00001010b
-11010110b ^ 11011101b = 00001011b
-11010110b ^ 11011110b = 00001000b
-11010110b ^ 11011111b = 00001001b
-11010110b ^ 11100000b = 00110110b
-11010110b ^ 11100001b = 00110111b
-11010110b ^ 11100010b = 00110100b
-11010110b ^ 11100011b = 00110101b
-11010110b ^ 11100100b = 00110010b
-11010110b ^ 11100101b = 00110011b
-11010110b ^ 11100110b = 00110000b
-11010110b ^ 11100111b = 00110001b
-11010110b ^ 11101000b = 00111110b
-11010110b ^ 11101001b = 00111111b
-11010110b ^ 11101010b = 00111100b
-11010110b ^ 11101011b = 00111101b
-11010110b ^ 11101100b = 00111010b
-11010110b ^ 11101101b = 00111011b
-11010110b ^ 11101110b = 00111000b
-11010110b ^ 11101111b = 00111001b
-11010110b ^ 11110000b = 00100110b
-11010110b ^ 11110001b = 00100111b
-11010110b ^ 11110010b = 00100100b
-11010110b ^ 11110011b = 00100101b
-11010110b ^ 11110100b = 00100010b
-11010110b ^ 11110101b = 00100011b
-11010110b ^ 11110110b = 00100000b
-11010110b ^ 11110111b = 00100001b
-11010110b ^ 11111000b = 00101110b
-11010110b ^ 11111001b = 00101111b
-11010110b ^ 11111010b = 00101100b
-11010110b ^ 11111011b = 00101101b
-11010110b ^ 11111100b = 00101010b
-11010110b ^ 11111101b = 00101011b
-11010110b ^ 11111110b = 00101000b
-11010110b ^ 11111111b = 00101001b
-11010110b ^ 00000000b = 11010110b
-11010110b ^ 00000001b = 11010111b
-11010110b ^ 00000010b = 11010100b
-11010110b ^ 00000011b = 11010101b
-11010110b ^ 00000100b = 11010010b
-11010110b ^ 00000101b = 11010011b
-11010110b ^ 00000110b = 11010000b
-11010110b ^ 00000111b = 11010001b
-11010110b ^ 00001000b = 11011110b
-11010110b ^ 00001001b = 11011111b
-11010110b ^ 00001010b = 11011100b
-11010110b ^ 00001011b = 11011101b
-11010110b ^ 00001100b = 11011010b
-11010110b ^ 00001101b = 11011011b
-11010110b ^ 00001110b = 11011000b
-11010110b ^ 00001111b = 11011001b
-11010110b ^ 00010000b = 11000110b
-11010110b ^ 00010001b = 11000111b
-11010110b ^ 00010010b = 11000100b
-11010110b ^ 00010011b = 11000101b
-11010110b ^ 00010100b = 11000010b
-11010110b ^ 00010101b = 11000011b
-11010110b ^ 00010110b = 11000000b
-11010110b ^ 00010111b = 11000001b
-11010110b ^ 00011000b = 11001110b
-11010110b ^ 00011001b = 11001111b
-11010110b ^ 00011010b = 11001100b
-11010110b ^ 00011011b = 11001101b
-11010110b ^ 00011100b = 11001010b
-11010110b ^ 00011101b = 11001011b
-11010110b ^ 00011110b = 11001000b
-11010110b ^ 00011111b = 11001001b
-11010110b ^ 00100000b = 11110110b
-11010110b ^ 00100001b = 11110111b
-11010110b ^ 00100010b = 11110100b
-11010110b ^ 00100011b = 11110101b
-11010110b ^ 00100100b = 11110010b
-11010110b ^ 00100101b = 11110011b
-11010110b ^ 00100110b = 11110000b
-11010110b ^ 00100111b = 11110001b
-11010110b ^ 00101000b = 11111110b
-11010110b ^ 00101001b = 11111111b
-11010110b ^ 00101010b = 11111100b
-11010110b ^ 00101011b = 11111101b
-11010110b ^ 00101100b = 11111010b
-11010110b ^ 00101101b = 11111011b
-11010110b ^ 00101110b = 11111000b
-11010110b ^ 00101111b = 11111001b
-11010110b ^ 00110000b = 11100110b
-11010110b ^ 00110001b = 11100111b
-11010110b ^ 00110010b = 11100100b
-11010110b ^ 00110011b = 11100101b
-11010110b ^ 00110100b = 11100010b
-11010110b ^ 00110101b = 11100011b
-11010110b ^ 00110110b = 11100000b
-11010110b ^ 00110111b = 11100001b
-11010110b ^ 00111000b = 11101110b
-11010110b ^ 00111001b = 11101111b
-11010110b ^ 00111010b = 11101100b
-11010110b ^ 00111011b = 11101101b
-11010110b ^ 00111100b = 11101010b
-11010110b ^ 00111101b = 11101011b
-11010110b ^ 00111110b = 11101000b
-11010110b ^ 00111111b = 11101001b
-11010110b ^ 01000000b = 10010110b
-11010110b ^ 01000001b = 10010111b
-11010110b ^ 01000010b = 10010100b
-11010110b ^ 01000011b = 10010101b
-11010110b ^ 01000100b = 10010010b
-11010110b ^ 01000101b = 10010011b
-11010110b ^ 01000110b = 10010000b
-11010110b ^ 01000111b = 10010001b
-11010110b ^ 01001000b = 10011110b
-11010110b ^ 01001001b = 10011111b
-11010110b ^ 01001010b = 10011100b
-11010110b ^ 01001011b = 10011101b
-11010110b ^ 01001100b = 10011010b
-11010110b ^ 01001101b = 10011011b
-11010110b ^ 01001110b = 10011000b
-11010110b ^ 01001111b = 10011001b
-11010110b ^ 01010000b = 10000110b
-11010110b ^ 01010001b = 10000111b
-11010110b ^ 01010010b = 10000100b
-11010110b ^ 01010011b = 10000101b
-11010110b ^ 01010100b = 10000010b
-11010110b ^ 01010101b = 10000011b
-11010110b ^ 01010110b = 10000000b
-11010110b ^ 01010111b = 10000001b
-11010110b ^ 01011000b = 10001110b
-11010110b ^ 01011001b = 10001111b
-11010110b ^ 01011010b = 10001100b
-11010110b ^ 01011011b = 10001101b
-11010110b ^ 01011100b = 10001010b
-11010110b ^ 01011101b = 10001011b
-11010110b ^ 01011110b = 10001000b
-11010110b ^ 01011111b = 10001001b
-11010110b ^ 01100000b = 10110110b
-11010110b ^ 01100001b = 10110111b
-11010110b ^ 01100010b = 10110100b
-11010110b ^ 01100011b = 10110101b
-11010110b ^ 01100100b = 10110010b
-11010110b ^ 01100101b = 10110011b
-11010110b ^ 01100110b = 10110000b
-11010110b ^ 01100111b = 10110001b
-11010110b ^ 01101000b = 10111110b
-11010110b ^ 01101001b = 10111111b
-11010110b ^ 01101010b = 10111100b
-11010110b ^ 01101011b = 10111101b
-11010110b ^ 01101100b = 10111010b
-11010110b ^ 01101101b = 10111011b
-11010110b ^ 01101110b = 10111000b
-11010110b ^ 01101111b = 10111001b
-11010110b ^ 01110000b = 10100110b
-11010110b ^ 01110001b = 10100111b
-11010110b ^ 01110010b = 10100100b
-11010110b ^ 01110011b = 10100101b
-11010110b ^ 01110100b = 10100010b
-11010110b ^ 01110101b = 10100011b
-11010110b ^ 01110110b = 10100000b
-11010110b ^ 01110111b = 10100001b
-11010110b ^ 01111000b = 10101110b
-11010110b ^ 01111001b = 10101111b
-11010110b ^ 01111010b = 10101100b
-11010110b ^ 01111011b = 10101101b
-11010110b ^ 01111100b = 10101010b
-11010110b ^ 01111101b = 10101011b
-11010110b ^ 01111110b = 10101000b
-11010111b ^ 10000000b = 01010111b
-11010111b ^ 10000001b = 01010110b
-11010111b ^ 10000010b = 01010101b
-11010111b ^ 10000011b = 01010100b
-11010111b ^ 10000100b = 01010011b
-11010111b ^ 10000101b = 01010010b
-11010111b ^ 10000110b = 01010001b
-11010111b ^ 10000111b = 01010000b
-11010111b ^ 10001000b = 01011111b
-11010111b ^ 10001001b = 01011110b
-11010111b ^ 10001010b = 01011101b
-11010111b ^ 10001011b = 01011100b
-11010111b ^ 10001100b = 01011011b
-11010111b ^ 10001101b = 01011010b
-11010111b ^ 10001110b = 01011001b
-11010111b ^ 10001111b = 01011000b
-11010111b ^ 10010000b = 01000111b
-11010111b ^ 10010001b = 01000110b
-11010111b ^ 10010010b = 01000101b
-11010111b ^ 10010011b = 01000100b
-11010111b ^ 10010100b = 01000011b
-11010111b ^ 10010101b = 01000010b
-11010111b ^ 10010110b = 01000001b
-11010111b ^ 10010111b = 01000000b
-11010111b ^ 10011000b = 01001111b
-11010111b ^ 10011001b = 01001110b
-11010111b ^ 10011010b = 01001101b
-11010111b ^ 10011011b = 01001100b
-11010111b ^ 10011100b = 01001011b
-11010111b ^ 10011101b = 01001010b
-11010111b ^ 10011110b = 01001001b
-11010111b ^ 10011111b = 01001000b
-11010111b ^ 10100000b = 01110111b
-11010111b ^ 10100001b = 01110110b
-11010111b ^ 10100010b = 01110101b
-11010111b ^ 10100011b = 01110100b
-11010111b ^ 10100100b = 01110011b
-11010111b ^ 10100101b = 01110010b
-11010111b ^ 10100110b = 01110001b
-11010111b ^ 10100111b = 01110000b
-11010111b ^ 10101000b = 01111111b
-11010111b ^ 10101001b = 01111110b
-11010111b ^ 10101010b = 01111101b
-11010111b ^ 10101011b = 01111100b
-11010111b ^ 10101100b = 01111011b
-11010111b ^ 10101101b = 01111010b
-11010111b ^ 10101110b = 01111001b
-11010111b ^ 10101111b = 01111000b
-11010111b ^ 10110000b = 01100111b
-11010111b ^ 10110001b = 01100110b
-11010111b ^ 10110010b = 01100101b
-11010111b ^ 10110011b = 01100100b
-11010111b ^ 10110100b = 01100011b
-11010111b ^ 10110101b = 01100010b
-11010111b ^ 10110110b = 01100001b
-11010111b ^ 10110111b = 01100000b
-11010111b ^ 10111000b = 01101111b
-11010111b ^ 10111001b = 01101110b
-11010111b ^ 10111010b = 01101101b
-11010111b ^ 10111011b = 01101100b
-11010111b ^ 10111100b = 01101011b
-11010111b ^ 10111101b = 01101010b
-11010111b ^ 10111110b = 01101001b
-11010111b ^ 10111111b = 01101000b
-11010111b ^ 11000000b = 00010111b
-11010111b ^ 11000001b = 00010110b
-11010111b ^ 11000010b = 00010101b
-11010111b ^ 11000011b = 00010100b
-11010111b ^ 11000100b = 00010011b
-11010111b ^ 11000101b = 00010010b
-11010111b ^ 11000110b = 00010001b
-11010111b ^ 11000111b = 00010000b
-11010111b ^ 11001000b = 00011111b
-11010111b ^ 11001001b = 00011110b
-11010111b ^ 11001010b = 00011101b
-11010111b ^ 11001011b = 00011100b
-11010111b ^ 11001100b = 00011011b
-11010111b ^ 11001101b = 00011010b
-11010111b ^ 11001110b = 00011001b
-11010111b ^ 11001111b = 00011000b
-11010111b ^ 11010000b = 00000111b
-11010111b ^ 11010001b = 00000110b
-11010111b ^ 11010010b = 00000101b
-11010111b ^ 11010011b = 00000100b
-11010111b ^ 11010100b = 00000011b
-11010111b ^ 11010101b = 00000010b
-11010111b ^ 11010110b = 00000001b
-11010111b ^ 11010111b = 00000000b
-11010111b ^ 11011000b = 00001111b
-11010111b ^ 11011001b = 00001110b
-11010111b ^ 11011010b = 00001101b
-11010111b ^ 11011011b = 00001100b
-11010111b ^ 11011100b = 00001011b
-11010111b ^ 11011101b = 00001010b
-11010111b ^ 11011110b = 00001001b
-11010111b ^ 11011111b = 00001000b
-11010111b ^ 11100000b = 00110111b
-11010111b ^ 11100001b = 00110110b
-11010111b ^ 11100010b = 00110101b
-11010111b ^ 11100011b = 00110100b
-11010111b ^ 11100100b = 00110011b
-11010111b ^ 11100101b = 00110010b
-11010111b ^ 11100110b = 00110001b
-11010111b ^ 11100111b = 00110000b
-11010111b ^ 11101000b = 00111111b
-11010111b ^ 11101001b = 00111110b
-11010111b ^ 11101010b = 00111101b
-11010111b ^ 11101011b = 00111100b
-11010111b ^ 11101100b = 00111011b
-11010111b ^ 11101101b = 00111010b
-11010111b ^ 11101110b = 00111001b
-11010111b ^ 11101111b = 00111000b
-11010111b ^ 11110000b = 00100111b
-11010111b ^ 11110001b = 00100110b
-11010111b ^ 11110010b = 00100101b
-11010111b ^ 11110011b = 00100100b
-11010111b ^ 11110100b = 00100011b
-11010111b ^ 11110101b = 00100010b
-11010111b ^ 11110110b = 00100001b
-11010111b ^ 11110111b = 00100000b
-11010111b ^ 11111000b = 00101111b
-11010111b ^ 11111001b = 00101110b
-11010111b ^ 11111010b = 00101101b
-11010111b ^ 11111011b = 00101100b
-11010111b ^ 11111100b = 00101011b
-11010111b ^ 11111101b = 00101010b
-11010111b ^ 11111110b = 00101001b
-11010111b ^ 11111111b = 00101000b
-11010111b ^ 00000000b = 11010111b
-11010111b ^ 00000001b = 11010110b
-11010111b ^ 00000010b = 11010101b
-11010111b ^ 00000011b = 11010100b
-11010111b ^ 00000100b = 11010011b
-11010111b ^ 00000101b = 11010010b
-11010111b ^ 00000110b = 11010001b
-11010111b ^ 00000111b = 11010000b
-11010111b ^ 00001000b = 11011111b
-11010111b ^ 00001001b = 11011110b
-11010111b ^ 00001010b = 11011101b
-11010111b ^ 00001011b = 11011100b
-11010111b ^ 00001100b = 11011011b
-11010111b ^ 00001101b = 11011010b
-11010111b ^ 00001110b = 11011001b
-11010111b ^ 00001111b = 11011000b
-11010111b ^ 00010000b = 11000111b
-11010111b ^ 00010001b = 11000110b
-11010111b ^ 00010010b = 11000101b
-11010111b ^ 00010011b = 11000100b
-11010111b ^ 00010100b = 11000011b
-11010111b ^ 00010101b = 11000010b
-11010111b ^ 00010110b = 11000001b
-11010111b ^ 00010111b = 11000000b
-11010111b ^ 00011000b = 11001111b
-11010111b ^ 00011001b = 11001110b
-11010111b ^ 00011010b = 11001101b
-11010111b ^ 00011011b = 11001100b
-11010111b ^ 00011100b = 11001011b
-11010111b ^ 00011101b = 11001010b
-11010111b ^ 00011110b = 11001001b
-11010111b ^ 00011111b = 11001000b
-11010111b ^ 00100000b = 11110111b
-11010111b ^ 00100001b = 11110110b
-11010111b ^ 00100010b = 11110101b
-11010111b ^ 00100011b = 11110100b
-11010111b ^ 00100100b = 11110011b
-11010111b ^ 00100101b = 11110010b
-11010111b ^ 00100110b = 11110001b
-11010111b ^ 00100111b = 11110000b
-11010111b ^ 00101000b = 11111111b
-11010111b ^ 00101001b = 11111110b
-11010111b ^ 00101010b = 11111101b
-11010111b ^ 00101011b = 11111100b
-11010111b ^ 00101100b = 11111011b
-11010111b ^ 00101101b = 11111010b
-11010111b ^ 00101110b = 11111001b
-11010111b ^ 00101111b = 11111000b
-11010111b ^ 00110000b = 11100111b
-11010111b ^ 00110001b = 11100110b
-11010111b ^ 00110010b = 11100101b
-11010111b ^ 00110011b = 11100100b
-11010111b ^ 00110100b = 11100011b
-11010111b ^ 00110101b = 11100010b
-11010111b ^ 00110110b = 11100001b
-11010111b ^ 00110111b = 11100000b
-11010111b ^ 00111000b = 11101111b
-11010111b ^ 00111001b = 11101110b
-11010111b ^ 00111010b = 11101101b
-11010111b ^ 00111011b = 11101100b
-11010111b ^ 00111100b = 11101011b
-11010111b ^ 00111101b = 11101010b
-11010111b ^ 00111110b = 11101001b
-11010111b ^ 00111111b = 11101000b
-11010111b ^ 01000000b = 10010111b
-11010111b ^ 01000001b = 10010110b
-11010111b ^ 01000010b = 10010101b
-11010111b ^ 01000011b = 10010100b
-11010111b ^ 01000100b = 10010011b
-11010111b ^ 01000101b = 10010010b
-11010111b ^ 01000110b = 10010001b
-11010111b ^ 01000111b = 10010000b
-11010111b ^ 01001000b = 10011111b
-11010111b ^ 01001001b = 10011110b
-11010111b ^ 01001010b = 10011101b
-11010111b ^ 01001011b = 10011100b
-11010111b ^ 01001100b = 10011011b
-11010111b ^ 01001101b = 10011010b
-11010111b ^ 01001110b = 10011001b
-11010111b ^ 01001111b = 10011000b
-11010111b ^ 01010000b = 10000111b
-11010111b ^ 01010001b = 10000110b
-11010111b ^ 01010010b = 10000101b
-11010111b ^ 01010011b = 10000100b
-11010111b ^ 01010100b = 10000011b
-11010111b ^ 01010101b = 10000010b
-11010111b ^ 01010110b = 10000001b
-11010111b ^ 01010111b = 10000000b
-11010111b ^ 01011000b = 10001111b
-11010111b ^ 01011001b = 10001110b
-11010111b ^ 01011010b = 10001101b
-11010111b ^ 01011011b = 10001100b
-11010111b ^ 01011100b = 10001011b
-11010111b ^ 01011101b = 10001010b
-11010111b ^ 01011110b = 10001001b
-11010111b ^ 01011111b = 10001000b
-11010111b ^ 01100000b = 10110111b
-11010111b ^ 01100001b = 10110110b
-11010111b ^ 01100010b = 10110101b
-11010111b ^ 01100011b = 10110100b
-11010111b ^ 01100100b = 10110011b
-11010111b ^ 01100101b = 10110010b
-11010111b ^ 01100110b = 10110001b
-11010111b ^ 01100111b = 10110000b
-11010111b ^ 01101000b = 10111111b
-11010111b ^ 01101001b = 10111110b
-11010111b ^ 01101010b = 10111101b
-11010111b ^ 01101011b = 10111100b
-11010111b ^ 01101100b = 10111011b
-11010111b ^ 01101101b = 10111010b
-11010111b ^ 01101110b = 10111001b
-11010111b ^ 01101111b = 10111000b
-11010111b ^ 01110000b = 10100111b
-11010111b ^ 01110001b = 10100110b
-11010111b ^ 01110010b = 10100101b
-11010111b ^ 01110011b = 10100100b
-11010111b ^ 01110100b = 10100011b
-11010111b ^ 01110101b = 10100010b
-11010111b ^ 01110110b = 10100001b
-11010111b ^ 01110111b = 10100000b
-11010111b ^ 01111000b = 10101111b
-11010111b ^ 01111001b = 10101110b
-11010111b ^ 01111010b = 10101101b
-11010111b ^ 01111011b = 10101100b
-11010111b ^ 01111100b = 10101011b
-11010111b ^ 01111101b = 10101010b
-11010111b ^ 01111110b = 10101001b
-11011000b ^ 10000000b = 01011000b
-11011000b ^ 10000001b = 01011001b
-11011000b ^ 10000010b = 01011010b
-11011000b ^ 10000011b = 01011011b
-11011000b ^ 10000100b = 01011100b
-11011000b ^ 10000101b = 01011101b
-11011000b ^ 10000110b = 01011110b
-11011000b ^ 10000111b = 01011111b
-11011000b ^ 10001000b = 01010000b
-11011000b ^ 10001001b = 01010001b
-11011000b ^ 10001010b = 01010010b
-11011000b ^ 10001011b = 01010011b
-11011000b ^ 10001100b = 01010100b
-11011000b ^ 10001101b = 01010101b
-11011000b ^ 10001110b = 01010110b
-11011000b ^ 10001111b = 01010111b
-11011000b ^ 10010000b = 01001000b
-11011000b ^ 10010001b = 01001001b
-11011000b ^ 10010010b = 01001010b
-11011000b ^ 10010011b = 01001011b
-11011000b ^ 10010100b = 01001100b
-11011000b ^ 10010101b = 01001101b
-11011000b ^ 10010110b = 01001110b
-11011000b ^ 10010111b = 01001111b
-11011000b ^ 10011000b = 01000000b
-11011000b ^ 10011001b = 01000001b
-11011000b ^ 10011010b = 01000010b
-11011000b ^ 10011011b = 01000011b
-11011000b ^ 10011100b = 01000100b
-11011000b ^ 10011101b = 01000101b
-11011000b ^ 10011110b = 01000110b
-11011000b ^ 10011111b = 01000111b
-11011000b ^ 10100000b = 01111000b
-11011000b ^ 10100001b = 01111001b
-11011000b ^ 10100010b = 01111010b
-11011000b ^ 10100011b = 01111011b
-11011000b ^ 10100100b = 01111100b
-11011000b ^ 10100101b = 01111101b
-11011000b ^ 10100110b = 01111110b
-11011000b ^ 10100111b = 01111111b
-11011000b ^ 10101000b = 01110000b
-11011000b ^ 10101001b = 01110001b
-11011000b ^ 10101010b = 01110010b
-11011000b ^ 10101011b = 01110011b
-11011000b ^ 10101100b = 01110100b
-11011000b ^ 10101101b = 01110101b
-11011000b ^ 10101110b = 01110110b
-11011000b ^ 10101111b = 01110111b
-11011000b ^ 10110000b = 01101000b
-11011000b ^ 10110001b = 01101001b
-11011000b ^ 10110010b = 01101010b
-11011000b ^ 10110011b = 01101011b
-11011000b ^ 10110100b = 01101100b
-11011000b ^ 10110101b = 01101101b
-11011000b ^ 10110110b = 01101110b
-11011000b ^ 10110111b = 01101111b
-11011000b ^ 10111000b = 01100000b
-11011000b ^ 10111001b = 01100001b
-11011000b ^ 10111010b = 01100010b
-11011000b ^ 10111011b = 01100011b
-11011000b ^ 10111100b = 01100100b
-11011000b ^ 10111101b = 01100101b
-11011000b ^ 10111110b = 01100110b
-11011000b ^ 10111111b = 01100111b
-11011000b ^ 11000000b = 00011000b
-11011000b ^ 11000001b = 00011001b
-11011000b ^ 11000010b = 00011010b
-11011000b ^ 11000011b = 00011011b
-11011000b ^ 11000100b = 00011100b
-11011000b ^ 11000101b = 00011101b
-11011000b ^ 11000110b = 00011110b
-11011000b ^ 11000111b = 00011111b
-11011000b ^ 11001000b = 00010000b
-11011000b ^ 11001001b = 00010001b
-11011000b ^ 11001010b = 00010010b
-11011000b ^ 11001011b = 00010011b
-11011000b ^ 11001100b = 00010100b
-11011000b ^ 11001101b = 00010101b
-11011000b ^ 11001110b = 00010110b
-11011000b ^ 11001111b = 00010111b
-11011000b ^ 11010000b = 00001000b
-11011000b ^ 11010001b = 00001001b
-11011000b ^ 11010010b = 00001010b
-11011000b ^ 11010011b = 00001011b
-11011000b ^ 11010100b = 00001100b
-11011000b ^ 11010101b = 00001101b
-11011000b ^ 11010110b = 00001110b
-11011000b ^ 11010111b = 00001111b
-11011000b ^ 11011000b = 00000000b
-11011000b ^ 11011001b = 00000001b
-11011000b ^ 11011010b = 00000010b
-11011000b ^ 11011011b = 00000011b
-11011000b ^ 11011100b = 00000100b
-11011000b ^ 11011101b = 00000101b
-11011000b ^ 11011110b = 00000110b
-11011000b ^ 11011111b = 00000111b
-11011000b ^ 11100000b = 00111000b
-11011000b ^ 11100001b = 00111001b
-11011000b ^ 11100010b = 00111010b
-11011000b ^ 11100011b = 00111011b
-11011000b ^ 11100100b = 00111100b
-11011000b ^ 11100101b = 00111101b
-11011000b ^ 11100110b = 00111110b
-11011000b ^ 11100111b = 00111111b
-11011000b ^ 11101000b = 00110000b
-11011000b ^ 11101001b = 00110001b
-11011000b ^ 11101010b = 00110010b
-11011000b ^ 11101011b = 00110011b
-11011000b ^ 11101100b = 00110100b
-11011000b ^ 11101101b = 00110101b
-11011000b ^ 11101110b = 00110110b
-11011000b ^ 11101111b = 00110111b
-11011000b ^ 11110000b = 00101000b
-11011000b ^ 11110001b = 00101001b
-11011000b ^ 11110010b = 00101010b
-11011000b ^ 11110011b = 00101011b
-11011000b ^ 11110100b = 00101100b
-11011000b ^ 11110101b = 00101101b
-11011000b ^ 11110110b = 00101110b
-11011000b ^ 11110111b = 00101111b
-11011000b ^ 11111000b = 00100000b
-11011000b ^ 11111001b = 00100001b
-11011000b ^ 11111010b = 00100010b
-11011000b ^ 11111011b = 00100011b
-11011000b ^ 11111100b = 00100100b
-11011000b ^ 11111101b = 00100101b
-11011000b ^ 11111110b = 00100110b
-11011000b ^ 11111111b = 00100111b
-11011000b ^ 00000000b = 11011000b
-11011000b ^ 00000001b = 11011001b
-11011000b ^ 00000010b = 11011010b
-11011000b ^ 00000011b = 11011011b
-11011000b ^ 00000100b = 11011100b
-11011000b ^ 00000101b = 11011101b
-11011000b ^ 00000110b = 11011110b
-11011000b ^ 00000111b = 11011111b
-11011000b ^ 00001000b = 11010000b
-11011000b ^ 00001001b = 11010001b
-11011000b ^ 00001010b = 11010010b
-11011000b ^ 00001011b = 11010011b
-11011000b ^ 00001100b = 11010100b
-11011000b ^ 00001101b = 11010101b
-11011000b ^ 00001110b = 11010110b
-11011000b ^ 00001111b = 11010111b
-11011000b ^ 00010000b = 11001000b
-11011000b ^ 00010001b = 11001001b
-11011000b ^ 00010010b = 11001010b
-11011000b ^ 00010011b = 11001011b
-11011000b ^ 00010100b = 11001100b
-11011000b ^ 00010101b = 11001101b
-11011000b ^ 00010110b = 11001110b
-11011000b ^ 00010111b = 11001111b
-11011000b ^ 00011000b = 11000000b
-11011000b ^ 00011001b = 11000001b
-11011000b ^ 00011010b = 11000010b
-11011000b ^ 00011011b = 11000011b
-11011000b ^ 00011100b = 11000100b
-11011000b ^ 00011101b = 11000101b
-11011000b ^ 00011110b = 11000110b
-11011000b ^ 00011111b = 11000111b
-11011000b ^ 00100000b = 11111000b
-11011000b ^ 00100001b = 11111001b
-11011000b ^ 00100010b = 11111010b
-11011000b ^ 00100011b = 11111011b
-11011000b ^ 00100100b = 11111100b
-11011000b ^ 00100101b = 11111101b
-11011000b ^ 00100110b = 11111110b
-11011000b ^ 00100111b = 11111111b
-11011000b ^ 00101000b = 11110000b
-11011000b ^ 00101001b = 11110001b
-11011000b ^ 00101010b = 11110010b
-11011000b ^ 00101011b = 11110011b
-11011000b ^ 00101100b = 11110100b
-11011000b ^ 00101101b = 11110101b
-11011000b ^ 00101110b = 11110110b
-11011000b ^ 00101111b = 11110111b
-11011000b ^ 00110000b = 11101000b
-11011000b ^ 00110001b = 11101001b
-11011000b ^ 00110010b = 11101010b
-11011000b ^ 00110011b = 11101011b
-11011000b ^ 00110100b = 11101100b
-11011000b ^ 00110101b = 11101101b
-11011000b ^ 00110110b = 11101110b
-11011000b ^ 00110111b = 11101111b
-11011000b ^ 00111000b = 11100000b
-11011000b ^ 00111001b = 11100001b
-11011000b ^ 00111010b = 11100010b
-11011000b ^ 00111011b = 11100011b
-11011000b ^ 00111100b = 11100100b
-11011000b ^ 00111101b = 11100101b
-11011000b ^ 00111110b = 11100110b
-11011000b ^ 00111111b = 11100111b
-11011000b ^ 01000000b = 10011000b
-11011000b ^ 01000001b = 10011001b
-11011000b ^ 01000010b = 10011010b
-11011000b ^ 01000011b = 10011011b
-11011000b ^ 01000100b = 10011100b
-11011000b ^ 01000101b = 10011101b
-11011000b ^ 01000110b = 10011110b
-11011000b ^ 01000111b = 10011111b
-11011000b ^ 01001000b = 10010000b
-11011000b ^ 01001001b = 10010001b
-11011000b ^ 01001010b = 10010010b
-11011000b ^ 01001011b = 10010011b
-11011000b ^ 01001100b = 10010100b
-11011000b ^ 01001101b = 10010101b
-11011000b ^ 01001110b = 10010110b
-11011000b ^ 01001111b = 10010111b
-11011000b ^ 01010000b = 10001000b
-11011000b ^ 01010001b = 10001001b
-11011000b ^ 01010010b = 10001010b
-11011000b ^ 01010011b = 10001011b
-11011000b ^ 01010100b = 10001100b
-11011000b ^ 01010101b = 10001101b
-11011000b ^ 01010110b = 10001110b
-11011000b ^ 01010111b = 10001111b
-11011000b ^ 01011000b = 10000000b
-11011000b ^ 01011001b = 10000001b
-11011000b ^ 01011010b = 10000010b
-11011000b ^ 01011011b = 10000011b
-11011000b ^ 01011100b = 10000100b
-11011000b ^ 01011101b = 10000101b
-11011000b ^ 01011110b = 10000110b
-11011000b ^ 01011111b = 10000111b
-11011000b ^ 01100000b = 10111000b
-11011000b ^ 01100001b = 10111001b
-11011000b ^ 01100010b = 10111010b
-11011000b ^ 01100011b = 10111011b
-11011000b ^ 01100100b = 10111100b
-11011000b ^ 01100101b = 10111101b
-11011000b ^ 01100110b = 10111110b
-11011000b ^ 01100111b = 10111111b
-11011000b ^ 01101000b = 10110000b
-11011000b ^ 01101001b = 10110001b
-11011000b ^ 01101010b = 10110010b
-11011000b ^ 01101011b = 10110011b
-11011000b ^ 01101100b = 10110100b
-11011000b ^ 01101101b = 10110101b
-11011000b ^ 01101110b = 10110110b
-11011000b ^ 01101111b = 10110111b
-11011000b ^ 01110000b = 10101000b
-11011000b ^ 01110001b = 10101001b
-11011000b ^ 01110010b = 10101010b
-11011000b ^ 01110011b = 10101011b
-11011000b ^ 01110100b = 10101100b
-11011000b ^ 01110101b = 10101101b
-11011000b ^ 01110110b = 10101110b
-11011000b ^ 01110111b = 10101111b
-11011000b ^ 01111000b = 10100000b
-11011000b ^ 01111001b = 10100001b
-11011000b ^ 01111010b = 10100010b
-11011000b ^ 01111011b = 10100011b
-11011000b ^ 01111100b = 10100100b
-11011000b ^ 01111101b = 10100101b
-11011000b ^ 01111110b = 10100110b
-11011001b ^ 10000000b = 01011001b
-11011001b ^ 10000001b = 01011000b
-11011001b ^ 10000010b = 01011011b
-11011001b ^ 10000011b = 01011010b
-11011001b ^ 10000100b = 01011101b
-11011001b ^ 10000101b = 01011100b
-11011001b ^ 10000110b = 01011111b
-11011001b ^ 10000111b = 01011110b
-11011001b ^ 10001000b = 01010001b
-11011001b ^ 10001001b = 01010000b
-11011001b ^ 10001010b = 01010011b
-11011001b ^ 10001011b = 01010010b
-11011001b ^ 10001100b = 01010101b
-11011001b ^ 10001101b = 01010100b
-11011001b ^ 10001110b = 01010111b
-11011001b ^ 10001111b = 01010110b
-11011001b ^ 10010000b = 01001001b
-11011001b ^ 10010001b = 01001000b
-11011001b ^ 10010010b = 01001011b
-11011001b ^ 10010011b = 01001010b
-11011001b ^ 10010100b = 01001101b
-11011001b ^ 10010101b = 01001100b
-11011001b ^ 10010110b = 01001111b
-11011001b ^ 10010111b = 01001110b
-11011001b ^ 10011000b = 01000001b
-11011001b ^ 10011001b = 01000000b
-11011001b ^ 10011010b = 01000011b
-11011001b ^ 10011011b = 01000010b
-11011001b ^ 10011100b = 01000101b
-11011001b ^ 10011101b = 01000100b
-11011001b ^ 10011110b = 01000111b
-11011001b ^ 10011111b = 01000110b
-11011001b ^ 10100000b = 01111001b
-11011001b ^ 10100001b = 01111000b
-11011001b ^ 10100010b = 01111011b
-11011001b ^ 10100011b = 01111010b
-11011001b ^ 10100100b = 01111101b
-11011001b ^ 10100101b = 01111100b
-11011001b ^ 10100110b = 01111111b
-11011001b ^ 10100111b = 01111110b
-11011001b ^ 10101000b = 01110001b
-11011001b ^ 10101001b = 01110000b
-11011001b ^ 10101010b = 01110011b
-11011001b ^ 10101011b = 01110010b
-11011001b ^ 10101100b = 01110101b
-11011001b ^ 10101101b = 01110100b
-11011001b ^ 10101110b = 01110111b
-11011001b ^ 10101111b = 01110110b
-11011001b ^ 10110000b = 01101001b
-11011001b ^ 10110001b = 01101000b
-11011001b ^ 10110010b = 01101011b
-11011001b ^ 10110011b = 01101010b
-11011001b ^ 10110100b = 01101101b
-11011001b ^ 10110101b = 01101100b
-11011001b ^ 10110110b = 01101111b
-11011001b ^ 10110111b = 01101110b
-11011001b ^ 10111000b = 01100001b
-11011001b ^ 10111001b = 01100000b
-11011001b ^ 10111010b = 01100011b
-11011001b ^ 10111011b = 01100010b
-11011001b ^ 10111100b = 01100101b
-11011001b ^ 10111101b = 01100100b
-11011001b ^ 10111110b = 01100111b
-11011001b ^ 10111111b = 01100110b
-11011001b ^ 11000000b = 00011001b
-11011001b ^ 11000001b = 00011000b
-11011001b ^ 11000010b = 00011011b
-11011001b ^ 11000011b = 00011010b
-11011001b ^ 11000100b = 00011101b
-11011001b ^ 11000101b = 00011100b
-11011001b ^ 11000110b = 00011111b
-11011001b ^ 11000111b = 00011110b
-11011001b ^ 11001000b = 00010001b
-11011001b ^ 11001001b = 00010000b
-11011001b ^ 11001010b = 00010011b
-11011001b ^ 11001011b = 00010010b
-11011001b ^ 11001100b = 00010101b
-11011001b ^ 11001101b = 00010100b
-11011001b ^ 11001110b = 00010111b
-11011001b ^ 11001111b = 00010110b
-11011001b ^ 11010000b = 00001001b
-11011001b ^ 11010001b = 00001000b
-11011001b ^ 11010010b = 00001011b
-11011001b ^ 11010011b = 00001010b
-11011001b ^ 11010100b = 00001101b
-11011001b ^ 11010101b = 00001100b
-11011001b ^ 11010110b = 00001111b
-11011001b ^ 11010111b = 00001110b
-11011001b ^ 11011000b = 00000001b
-11011001b ^ 11011001b = 00000000b
-11011001b ^ 11011010b = 00000011b
-11011001b ^ 11011011b = 00000010b
-11011001b ^ 11011100b = 00000101b
-11011001b ^ 11011101b = 00000100b
-11011001b ^ 11011110b = 00000111b
-11011001b ^ 11011111b = 00000110b
-11011001b ^ 11100000b = 00111001b
-11011001b ^ 11100001b = 00111000b
-11011001b ^ 11100010b = 00111011b
-11011001b ^ 11100011b = 00111010b
-11011001b ^ 11100100b = 00111101b
-11011001b ^ 11100101b = 00111100b
-11011001b ^ 11100110b = 00111111b
-11011001b ^ 11100111b = 00111110b
-11011001b ^ 11101000b = 00110001b
-11011001b ^ 11101001b = 00110000b
-11011001b ^ 11101010b = 00110011b
-11011001b ^ 11101011b = 00110010b
-11011001b ^ 11101100b = 00110101b
-11011001b ^ 11101101b = 00110100b
-11011001b ^ 11101110b = 00110111b
-11011001b ^ 11101111b = 00110110b
-11011001b ^ 11110000b = 00101001b
-11011001b ^ 11110001b = 00101000b
-11011001b ^ 11110010b = 00101011b
-11011001b ^ 11110011b = 00101010b
-11011001b ^ 11110100b = 00101101b
-11011001b ^ 11110101b = 00101100b
-11011001b ^ 11110110b = 00101111b
-11011001b ^ 11110111b = 00101110b
-11011001b ^ 11111000b = 00100001b
-11011001b ^ 11111001b = 00100000b
-11011001b ^ 11111010b = 00100011b
-11011001b ^ 11111011b = 00100010b
-11011001b ^ 11111100b = 00100101b
-11011001b ^ 11111101b = 00100100b
-11011001b ^ 11111110b = 00100111b
-11011001b ^ 11111111b = 00100110b
-11011001b ^ 00000000b = 11011001b
-11011001b ^ 00000001b = 11011000b
-11011001b ^ 00000010b = 11011011b
-11011001b ^ 00000011b = 11011010b
-11011001b ^ 00000100b = 11011101b
-11011001b ^ 00000101b = 11011100b
-11011001b ^ 00000110b = 11011111b
-11011001b ^ 00000111b = 11011110b
-11011001b ^ 00001000b = 11010001b
-11011001b ^ 00001001b = 11010000b
-11011001b ^ 00001010b = 11010011b
-11011001b ^ 00001011b = 11010010b
-11011001b ^ 00001100b = 11010101b
-11011001b ^ 00001101b = 11010100b
-11011001b ^ 00001110b = 11010111b
-11011001b ^ 00001111b = 11010110b
-11011001b ^ 00010000b = 11001001b
-11011001b ^ 00010001b = 11001000b
-11011001b ^ 00010010b = 11001011b
-11011001b ^ 00010011b = 11001010b
-11011001b ^ 00010100b = 11001101b
-11011001b ^ 00010101b = 11001100b
-11011001b ^ 00010110b = 11001111b
-11011001b ^ 00010111b = 11001110b
-11011001b ^ 00011000b = 11000001b
-11011001b ^ 00011001b = 11000000b
-11011001b ^ 00011010b = 11000011b
-11011001b ^ 00011011b = 11000010b
-11011001b ^ 00011100b = 11000101b
-11011001b ^ 00011101b = 11000100b
-11011001b ^ 00011110b = 11000111b
-11011001b ^ 00011111b = 11000110b
-11011001b ^ 00100000b = 11111001b
-11011001b ^ 00100001b = 11111000b
-11011001b ^ 00100010b = 11111011b
-11011001b ^ 00100011b = 11111010b
-11011001b ^ 00100100b = 11111101b
-11011001b ^ 00100101b = 11111100b
-11011001b ^ 00100110b = 11111111b
-11011001b ^ 00100111b = 11111110b
-11011001b ^ 00101000b = 11110001b
-11011001b ^ 00101001b = 11110000b
-11011001b ^ 00101010b = 11110011b
-11011001b ^ 00101011b = 11110010b
-11011001b ^ 00101100b = 11110101b
-11011001b ^ 00101101b = 11110100b
-11011001b ^ 00101110b = 11110111b
-11011001b ^ 00101111b = 11110110b
-11011001b ^ 00110000b = 11101001b
-11011001b ^ 00110001b = 11101000b
-11011001b ^ 00110010b = 11101011b
-11011001b ^ 00110011b = 11101010b
-11011001b ^ 00110100b = 11101101b
-11011001b ^ 00110101b = 11101100b
-11011001b ^ 00110110b = 11101111b
-11011001b ^ 00110111b = 11101110b
-11011001b ^ 00111000b = 11100001b
-11011001b ^ 00111001b = 11100000b
-11011001b ^ 00111010b = 11100011b
-11011001b ^ 00111011b = 11100010b
-11011001b ^ 00111100b = 11100101b
-11011001b ^ 00111101b = 11100100b
-11011001b ^ 00111110b = 11100111b
-11011001b ^ 00111111b = 11100110b
-11011001b ^ 01000000b = 10011001b
-11011001b ^ 01000001b = 10011000b
-11011001b ^ 01000010b = 10011011b
-11011001b ^ 01000011b = 10011010b
-11011001b ^ 01000100b = 10011101b
-11011001b ^ 01000101b = 10011100b
-11011001b ^ 01000110b = 10011111b
-11011001b ^ 01000111b = 10011110b
-11011001b ^ 01001000b = 10010001b
-11011001b ^ 01001001b = 10010000b
-11011001b ^ 01001010b = 10010011b
-11011001b ^ 01001011b = 10010010b
-11011001b ^ 01001100b = 10010101b
-11011001b ^ 01001101b = 10010100b
-11011001b ^ 01001110b = 10010111b
-11011001b ^ 01001111b = 10010110b
-11011001b ^ 01010000b = 10001001b
-11011001b ^ 01010001b = 10001000b
-11011001b ^ 01010010b = 10001011b
-11011001b ^ 01010011b = 10001010b
-11011001b ^ 01010100b = 10001101b
-11011001b ^ 01010101b = 10001100b
-11011001b ^ 01010110b = 10001111b
-11011001b ^ 01010111b = 10001110b
-11011001b ^ 01011000b = 10000001b
-11011001b ^ 01011001b = 10000000b
-11011001b ^ 01011010b = 10000011b
-11011001b ^ 01011011b = 10000010b
-11011001b ^ 01011100b = 10000101b
-11011001b ^ 01011101b = 10000100b
-11011001b ^ 01011110b = 10000111b
-11011001b ^ 01011111b = 10000110b
-11011001b ^ 01100000b = 10111001b
-11011001b ^ 01100001b = 10111000b
-11011001b ^ 01100010b = 10111011b
-11011001b ^ 01100011b = 10111010b
-11011001b ^ 01100100b = 10111101b
-11011001b ^ 01100101b = 10111100b
-11011001b ^ 01100110b = 10111111b
-11011001b ^ 01100111b = 10111110b
-11011001b ^ 01101000b = 10110001b
-11011001b ^ 01101001b = 10110000b
-11011001b ^ 01101010b = 10110011b
-11011001b ^ 01101011b = 10110010b
-11011001b ^ 01101100b = 10110101b
-11011001b ^ 01101101b = 10110100b
-11011001b ^ 01101110b = 10110111b
-11011001b ^ 01101111b = 10110110b
-11011001b ^ 01110000b = 10101001b
-11011001b ^ 01110001b = 10101000b
-11011001b ^ 01110010b = 10101011b
-11011001b ^ 01110011b = 10101010b
-11011001b ^ 01110100b = 10101101b
-11011001b ^ 01110101b = 10101100b
-11011001b ^ 01110110b = 10101111b
-11011001b ^ 01110111b = 10101110b
-11011001b ^ 01111000b = 10100001b
-11011001b ^ 01111001b = 10100000b
-11011001b ^ 01111010b = 10100011b
-11011001b ^ 01111011b = 10100010b
-11011001b ^ 01111100b = 10100101b
-11011001b ^ 01111101b = 10100100b
-11011001b ^ 01111110b = 10100111b
-11011010b ^ 10000000b = 01011010b
-11011010b ^ 10000001b = 01011011b
-11011010b ^ 10000010b = 01011000b
-11011010b ^ 10000011b = 01011001b
-11011010b ^ 10000100b = 01011110b
-11011010b ^ 10000101b = 01011111b
-11011010b ^ 10000110b = 01011100b
-11011010b ^ 10000111b = 01011101b
-11011010b ^ 10001000b = 01010010b
-11011010b ^ 10001001b = 01010011b
-11011010b ^ 10001010b = 01010000b
-11011010b ^ 10001011b = 01010001b
-11011010b ^ 10001100b = 01010110b
-11011010b ^ 10001101b = 01010111b
-11011010b ^ 10001110b = 01010100b
-11011010b ^ 10001111b = 01010101b
-11011010b ^ 10010000b = 01001010b
-11011010b ^ 10010001b = 01001011b
-11011010b ^ 10010010b = 01001000b
-11011010b ^ 10010011b = 01001001b
-11011010b ^ 10010100b = 01001110b
-11011010b ^ 10010101b = 01001111b
-11011010b ^ 10010110b = 01001100b
-11011010b ^ 10010111b = 01001101b
-11011010b ^ 10011000b = 01000010b
-11011010b ^ 10011001b = 01000011b
-11011010b ^ 10011010b = 01000000b
-11011010b ^ 10011011b = 01000001b
-11011010b ^ 10011100b = 01000110b
-11011010b ^ 10011101b = 01000111b
-11011010b ^ 10011110b = 01000100b
-11011010b ^ 10011111b = 01000101b
-11011010b ^ 10100000b = 01111010b
-11011010b ^ 10100001b = 01111011b
-11011010b ^ 10100010b = 01111000b
-11011010b ^ 10100011b = 01111001b
-11011010b ^ 10100100b = 01111110b
-11011010b ^ 10100101b = 01111111b
-11011010b ^ 10100110b = 01111100b
-11011010b ^ 10100111b = 01111101b
-11011010b ^ 10101000b = 01110010b
-11011010b ^ 10101001b = 01110011b
-11011010b ^ 10101010b = 01110000b
-11011010b ^ 10101011b = 01110001b
-11011010b ^ 10101100b = 01110110b
-11011010b ^ 10101101b = 01110111b
-11011010b ^ 10101110b = 01110100b
-11011010b ^ 10101111b = 01110101b
-11011010b ^ 10110000b = 01101010b
-11011010b ^ 10110001b = 01101011b
-11011010b ^ 10110010b = 01101000b
-11011010b ^ 10110011b = 01101001b
-11011010b ^ 10110100b = 01101110b
-11011010b ^ 10110101b = 01101111b
-11011010b ^ 10110110b = 01101100b
-11011010b ^ 10110111b = 01101101b
-11011010b ^ 10111000b = 01100010b
-11011010b ^ 10111001b = 01100011b
-11011010b ^ 10111010b = 01100000b
-11011010b ^ 10111011b = 01100001b
-11011010b ^ 10111100b = 01100110b
-11011010b ^ 10111101b = 01100111b
-11011010b ^ 10111110b = 01100100b
-11011010b ^ 10111111b = 01100101b
-11011010b ^ 11000000b = 00011010b
-11011010b ^ 11000001b = 00011011b
-11011010b ^ 11000010b = 00011000b
-11011010b ^ 11000011b = 00011001b
-11011010b ^ 11000100b = 00011110b
-11011010b ^ 11000101b = 00011111b
-11011010b ^ 11000110b = 00011100b
-11011010b ^ 11000111b = 00011101b
-11011010b ^ 11001000b = 00010010b
-11011010b ^ 11001001b = 00010011b
-11011010b ^ 11001010b = 00010000b
-11011010b ^ 11001011b = 00010001b
-11011010b ^ 11001100b = 00010110b
-11011010b ^ 11001101b = 00010111b
-11011010b ^ 11001110b = 00010100b
-11011010b ^ 11001111b = 00010101b
-11011010b ^ 11010000b = 00001010b
-11011010b ^ 11010001b = 00001011b
-11011010b ^ 11010010b = 00001000b
-11011010b ^ 11010011b = 00001001b
-11011010b ^ 11010100b = 00001110b
-11011010b ^ 11010101b = 00001111b
-11011010b ^ 11010110b = 00001100b
-11011010b ^ 11010111b = 00001101b
-11011010b ^ 11011000b = 00000010b
-11011010b ^ 11011001b = 00000011b
-11011010b ^ 11011010b = 00000000b
-11011010b ^ 11011011b = 00000001b
-11011010b ^ 11011100b = 00000110b
-11011010b ^ 11011101b = 00000111b
-11011010b ^ 11011110b = 00000100b
-11011010b ^ 11011111b = 00000101b
-11011010b ^ 11100000b = 00111010b
-11011010b ^ 11100001b = 00111011b
-11011010b ^ 11100010b = 00111000b
-11011010b ^ 11100011b = 00111001b
-11011010b ^ 11100100b = 00111110b
-11011010b ^ 11100101b = 00111111b
-11011010b ^ 11100110b = 00111100b
-11011010b ^ 11100111b = 00111101b
-11011010b ^ 11101000b = 00110010b
-11011010b ^ 11101001b = 00110011b
-11011010b ^ 11101010b = 00110000b
-11011010b ^ 11101011b = 00110001b
-11011010b ^ 11101100b = 00110110b
-11011010b ^ 11101101b = 00110111b
-11011010b ^ 11101110b = 00110100b
-11011010b ^ 11101111b = 00110101b
-11011010b ^ 11110000b = 00101010b
-11011010b ^ 11110001b = 00101011b
-11011010b ^ 11110010b = 00101000b
-11011010b ^ 11110011b = 00101001b
-11011010b ^ 11110100b = 00101110b
-11011010b ^ 11110101b = 00101111b
-11011010b ^ 11110110b = 00101100b
-11011010b ^ 11110111b = 00101101b
-11011010b ^ 11111000b = 00100010b
-11011010b ^ 11111001b = 00100011b
-11011010b ^ 11111010b = 00100000b
-11011010b ^ 11111011b = 00100001b
-11011010b ^ 11111100b = 00100110b
-11011010b ^ 11111101b = 00100111b
-11011010b ^ 11111110b = 00100100b
-11011010b ^ 11111111b = 00100101b
-11011010b ^ 00000000b = 11011010b
-11011010b ^ 00000001b = 11011011b
-11011010b ^ 00000010b = 11011000b
-11011010b ^ 00000011b = 11011001b
-11011010b ^ 00000100b = 11011110b
-11011010b ^ 00000101b = 11011111b
-11011010b ^ 00000110b = 11011100b
-11011010b ^ 00000111b = 11011101b
-11011010b ^ 00001000b = 11010010b
-11011010b ^ 00001001b = 11010011b
-11011010b ^ 00001010b = 11010000b
-11011010b ^ 00001011b = 11010001b
-11011010b ^ 00001100b = 11010110b
-11011010b ^ 00001101b = 11010111b
-11011010b ^ 00001110b = 11010100b
-11011010b ^ 00001111b = 11010101b
-11011010b ^ 00010000b = 11001010b
-11011010b ^ 00010001b = 11001011b
-11011010b ^ 00010010b = 11001000b
-11011010b ^ 00010011b = 11001001b
-11011010b ^ 00010100b = 11001110b
-11011010b ^ 00010101b = 11001111b
-11011010b ^ 00010110b = 11001100b
-11011010b ^ 00010111b = 11001101b
-11011010b ^ 00011000b = 11000010b
-11011010b ^ 00011001b = 11000011b
-11011010b ^ 00011010b = 11000000b
-11011010b ^ 00011011b = 11000001b
-11011010b ^ 00011100b = 11000110b
-11011010b ^ 00011101b = 11000111b
-11011010b ^ 00011110b = 11000100b
-11011010b ^ 00011111b = 11000101b
-11011010b ^ 00100000b = 11111010b
-11011010b ^ 00100001b = 11111011b
-11011010b ^ 00100010b = 11111000b
-11011010b ^ 00100011b = 11111001b
-11011010b ^ 00100100b = 11111110b
-11011010b ^ 00100101b = 11111111b
-11011010b ^ 00100110b = 11111100b
-11011010b ^ 00100111b = 11111101b
-11011010b ^ 00101000b = 11110010b
-11011010b ^ 00101001b = 11110011b
-11011010b ^ 00101010b = 11110000b
-11011010b ^ 00101011b = 11110001b
-11011010b ^ 00101100b = 11110110b
-11011010b ^ 00101101b = 11110111b
-11011010b ^ 00101110b = 11110100b
-11011010b ^ 00101111b = 11110101b
-11011010b ^ 00110000b = 11101010b
-11011010b ^ 00110001b = 11101011b
-11011010b ^ 00110010b = 11101000b
-11011010b ^ 00110011b = 11101001b
-11011010b ^ 00110100b = 11101110b
-11011010b ^ 00110101b = 11101111b
-11011010b ^ 00110110b = 11101100b
-11011010b ^ 00110111b = 11101101b
-11011010b ^ 00111000b = 11100010b
-11011010b ^ 00111001b = 11100011b
-11011010b ^ 00111010b = 11100000b
-11011010b ^ 00111011b = 11100001b
-11011010b ^ 00111100b = 11100110b
-11011010b ^ 00111101b = 11100111b
-11011010b ^ 00111110b = 11100100b
-11011010b ^ 00111111b = 11100101b
-11011010b ^ 01000000b = 10011010b
-11011010b ^ 01000001b = 10011011b
-11011010b ^ 01000010b = 10011000b
-11011010b ^ 01000011b = 10011001b
-11011010b ^ 01000100b = 10011110b
-11011010b ^ 01000101b = 10011111b
-11011010b ^ 01000110b = 10011100b
-11011010b ^ 01000111b = 10011101b
-11011010b ^ 01001000b = 10010010b
-11011010b ^ 01001001b = 10010011b
-11011010b ^ 01001010b = 10010000b
-11011010b ^ 01001011b = 10010001b
-11011010b ^ 01001100b = 10010110b
-11011010b ^ 01001101b = 10010111b
-11011010b ^ 01001110b = 10010100b
-11011010b ^ 01001111b = 10010101b
-11011010b ^ 01010000b = 10001010b
-11011010b ^ 01010001b = 10001011b
-11011010b ^ 01010010b = 10001000b
-11011010b ^ 01010011b = 10001001b
-11011010b ^ 01010100b = 10001110b
-11011010b ^ 01010101b = 10001111b
-11011010b ^ 01010110b = 10001100b
-11011010b ^ 01010111b = 10001101b
-11011010b ^ 01011000b = 10000010b
-11011010b ^ 01011001b = 10000011b
-11011010b ^ 01011010b = 10000000b
-11011010b ^ 01011011b = 10000001b
-11011010b ^ 01011100b = 10000110b
-11011010b ^ 01011101b = 10000111b
-11011010b ^ 01011110b = 10000100b
-11011010b ^ 01011111b = 10000101b
-11011010b ^ 01100000b = 10111010b
-11011010b ^ 01100001b = 10111011b
-11011010b ^ 01100010b = 10111000b
-11011010b ^ 01100011b = 10111001b
-11011010b ^ 01100100b = 10111110b
-11011010b ^ 01100101b = 10111111b
-11011010b ^ 01100110b = 10111100b
-11011010b ^ 01100111b = 10111101b
-11011010b ^ 01101000b = 10110010b
-11011010b ^ 01101001b = 10110011b
-11011010b ^ 01101010b = 10110000b
-11011010b ^ 01101011b = 10110001b
-11011010b ^ 01101100b = 10110110b
-11011010b ^ 01101101b = 10110111b
-11011010b ^ 01101110b = 10110100b
-11011010b ^ 01101111b = 10110101b
-11011010b ^ 01110000b = 10101010b
-11011010b ^ 01110001b = 10101011b
-11011010b ^ 01110010b = 10101000b
-11011010b ^ 01110011b = 10101001b
-11011010b ^ 01110100b = 10101110b
-11011010b ^ 01110101b = 10101111b
-11011010b ^ 01110110b = 10101100b
-11011010b ^ 01110111b = 10101101b
-11011010b ^ 01111000b = 10100010b
-11011010b ^ 01111001b = 10100011b
-11011010b ^ 01111010b = 10100000b
-11011010b ^ 01111011b = 10100001b
-11011010b ^ 01111100b = 10100110b
-11011010b ^ 01111101b = 10100111b
-11011010b ^ 01111110b = 10100100b
-11011011b ^ 10000000b = 01011011b
-11011011b ^ 10000001b = 01011010b
-11011011b ^ 10000010b = 01011001b
-11011011b ^ 10000011b = 01011000b
-11011011b ^ 10000100b = 01011111b
-11011011b ^ 10000101b = 01011110b
-11011011b ^ 10000110b = 01011101b
-11011011b ^ 10000111b = 01011100b
-11011011b ^ 10001000b = 01010011b
-11011011b ^ 10001001b = 01010010b
-11011011b ^ 10001010b = 01010001b
-11011011b ^ 10001011b = 01010000b
-11011011b ^ 10001100b = 01010111b
-11011011b ^ 10001101b = 01010110b
-11011011b ^ 10001110b = 01010101b
-11011011b ^ 10001111b = 01010100b
-11011011b ^ 10010000b = 01001011b
-11011011b ^ 10010001b = 01001010b
-11011011b ^ 10010010b = 01001001b
-11011011b ^ 10010011b = 01001000b
-11011011b ^ 10010100b = 01001111b
-11011011b ^ 10010101b = 01001110b
-11011011b ^ 10010110b = 01001101b
-11011011b ^ 10010111b = 01001100b
-11011011b ^ 10011000b = 01000011b
-11011011b ^ 10011001b = 01000010b
-11011011b ^ 10011010b = 01000001b
-11011011b ^ 10011011b = 01000000b
-11011011b ^ 10011100b = 01000111b
-11011011b ^ 10011101b = 01000110b
-11011011b ^ 10011110b = 01000101b
-11011011b ^ 10011111b = 01000100b
-11011011b ^ 10100000b = 01111011b
-11011011b ^ 10100001b = 01111010b
-11011011b ^ 10100010b = 01111001b
-11011011b ^ 10100011b = 01111000b
-11011011b ^ 10100100b = 01111111b
-11011011b ^ 10100101b = 01111110b
-11011011b ^ 10100110b = 01111101b
-11011011b ^ 10100111b = 01111100b
-11011011b ^ 10101000b = 01110011b
-11011011b ^ 10101001b = 01110010b
-11011011b ^ 10101010b = 01110001b
-11011011b ^ 10101011b = 01110000b
-11011011b ^ 10101100b = 01110111b
-11011011b ^ 10101101b = 01110110b
-11011011b ^ 10101110b = 01110101b
-11011011b ^ 10101111b = 01110100b
-11011011b ^ 10110000b = 01101011b
-11011011b ^ 10110001b = 01101010b
-11011011b ^ 10110010b = 01101001b
-11011011b ^ 10110011b = 01101000b
-11011011b ^ 10110100b = 01101111b
-11011011b ^ 10110101b = 01101110b
-11011011b ^ 10110110b = 01101101b
-11011011b ^ 10110111b = 01101100b
-11011011b ^ 10111000b = 01100011b
-11011011b ^ 10111001b = 01100010b
-11011011b ^ 10111010b = 01100001b
-11011011b ^ 10111011b = 01100000b
-11011011b ^ 10111100b = 01100111b
-11011011b ^ 10111101b = 01100110b
-11011011b ^ 10111110b = 01100101b
-11011011b ^ 10111111b = 01100100b
-11011011b ^ 11000000b = 00011011b
-11011011b ^ 11000001b = 00011010b
-11011011b ^ 11000010b = 00011001b
-11011011b ^ 11000011b = 00011000b
-11011011b ^ 11000100b = 00011111b
-11011011b ^ 11000101b = 00011110b
-11011011b ^ 11000110b = 00011101b
-11011011b ^ 11000111b = 00011100b
-11011011b ^ 11001000b = 00010011b
-11011011b ^ 11001001b = 00010010b
-11011011b ^ 11001010b = 00010001b
-11011011b ^ 11001011b = 00010000b
-11011011b ^ 11001100b = 00010111b
-11011011b ^ 11001101b = 00010110b
-11011011b ^ 11001110b = 00010101b
-11011011b ^ 11001111b = 00010100b
-11011011b ^ 11010000b = 00001011b
-11011011b ^ 11010001b = 00001010b
-11011011b ^ 11010010b = 00001001b
-11011011b ^ 11010011b = 00001000b
-11011011b ^ 11010100b = 00001111b
-11011011b ^ 11010101b = 00001110b
-11011011b ^ 11010110b = 00001101b
-11011011b ^ 11010111b = 00001100b
-11011011b ^ 11011000b = 00000011b
-11011011b ^ 11011001b = 00000010b
-11011011b ^ 11011010b = 00000001b
-11011011b ^ 11011011b = 00000000b
-11011011b ^ 11011100b = 00000111b
-11011011b ^ 11011101b = 00000110b
-11011011b ^ 11011110b = 00000101b
-11011011b ^ 11011111b = 00000100b
-11011011b ^ 11100000b = 00111011b
-11011011b ^ 11100001b = 00111010b
-11011011b ^ 11100010b = 00111001b
-11011011b ^ 11100011b = 00111000b
-11011011b ^ 11100100b = 00111111b
-11011011b ^ 11100101b = 00111110b
-11011011b ^ 11100110b = 00111101b
-11011011b ^ 11100111b = 00111100b
-11011011b ^ 11101000b = 00110011b
-11011011b ^ 11101001b = 00110010b
-11011011b ^ 11101010b = 00110001b
-11011011b ^ 11101011b = 00110000b
-11011011b ^ 11101100b = 00110111b
-11011011b ^ 11101101b = 00110110b
-11011011b ^ 11101110b = 00110101b
-11011011b ^ 11101111b = 00110100b
-11011011b ^ 11110000b = 00101011b
-11011011b ^ 11110001b = 00101010b
-11011011b ^ 11110010b = 00101001b
-11011011b ^ 11110011b = 00101000b
-11011011b ^ 11110100b = 00101111b
-11011011b ^ 11110101b = 00101110b
-11011011b ^ 11110110b = 00101101b
-11011011b ^ 11110111b = 00101100b
-11011011b ^ 11111000b = 00100011b
-11011011b ^ 11111001b = 00100010b
-11011011b ^ 11111010b = 00100001b
-11011011b ^ 11111011b = 00100000b
-11011011b ^ 11111100b = 00100111b
-11011011b ^ 11111101b = 00100110b
-11011011b ^ 11111110b = 00100101b
-11011011b ^ 11111111b = 00100100b
-11011011b ^ 00000000b = 11011011b
-11011011b ^ 00000001b = 11011010b
-11011011b ^ 00000010b = 11011001b
-11011011b ^ 00000011b = 11011000b
-11011011b ^ 00000100b = 11011111b
-11011011b ^ 00000101b = 11011110b
-11011011b ^ 00000110b = 11011101b
-11011011b ^ 00000111b = 11011100b
-11011011b ^ 00001000b = 11010011b
-11011011b ^ 00001001b = 11010010b
-11011011b ^ 00001010b = 11010001b
-11011011b ^ 00001011b = 11010000b
-11011011b ^ 00001100b = 11010111b
-11011011b ^ 00001101b = 11010110b
-11011011b ^ 00001110b = 11010101b
-11011011b ^ 00001111b = 11010100b
-11011011b ^ 00010000b = 11001011b
-11011011b ^ 00010001b = 11001010b
-11011011b ^ 00010010b = 11001001b
-11011011b ^ 00010011b = 11001000b
-11011011b ^ 00010100b = 11001111b
-11011011b ^ 00010101b = 11001110b
-11011011b ^ 00010110b = 11001101b
-11011011b ^ 00010111b = 11001100b
-11011011b ^ 00011000b = 11000011b
-11011011b ^ 00011001b = 11000010b
-11011011b ^ 00011010b = 11000001b
-11011011b ^ 00011011b = 11000000b
-11011011b ^ 00011100b = 11000111b
-11011011b ^ 00011101b = 11000110b
-11011011b ^ 00011110b = 11000101b
-11011011b ^ 00011111b = 11000100b
-11011011b ^ 00100000b = 11111011b
-11011011b ^ 00100001b = 11111010b
-11011011b ^ 00100010b = 11111001b
-11011011b ^ 00100011b = 11111000b
-11011011b ^ 00100100b = 11111111b
-11011011b ^ 00100101b = 11111110b
-11011011b ^ 00100110b = 11111101b
-11011011b ^ 00100111b = 11111100b
-11011011b ^ 00101000b = 11110011b
-11011011b ^ 00101001b = 11110010b
-11011011b ^ 00101010b = 11110001b
-11011011b ^ 00101011b = 11110000b
-11011011b ^ 00101100b = 11110111b
-11011011b ^ 00101101b = 11110110b
-11011011b ^ 00101110b = 11110101b
-11011011b ^ 00101111b = 11110100b
-11011011b ^ 00110000b = 11101011b
-11011011b ^ 00110001b = 11101010b
-11011011b ^ 00110010b = 11101001b
-11011011b ^ 00110011b = 11101000b
-11011011b ^ 00110100b = 11101111b
-11011011b ^ 00110101b = 11101110b
-11011011b ^ 00110110b = 11101101b
-11011011b ^ 00110111b = 11101100b
-11011011b ^ 00111000b = 11100011b
-11011011b ^ 00111001b = 11100010b
-11011011b ^ 00111010b = 11100001b
-11011011b ^ 00111011b = 11100000b
-11011011b ^ 00111100b = 11100111b
-11011011b ^ 00111101b = 11100110b
-11011011b ^ 00111110b = 11100101b
-11011011b ^ 00111111b = 11100100b
-11011011b ^ 01000000b = 10011011b
-11011011b ^ 01000001b = 10011010b
-11011011b ^ 01000010b = 10011001b
-11011011b ^ 01000011b = 10011000b
-11011011b ^ 01000100b = 10011111b
-11011011b ^ 01000101b = 10011110b
-11011011b ^ 01000110b = 10011101b
-11011011b ^ 01000111b = 10011100b
-11011011b ^ 01001000b = 10010011b
-11011011b ^ 01001001b = 10010010b
-11011011b ^ 01001010b = 10010001b
-11011011b ^ 01001011b = 10010000b
-11011011b ^ 01001100b = 10010111b
-11011011b ^ 01001101b = 10010110b
-11011011b ^ 01001110b = 10010101b
-11011011b ^ 01001111b = 10010100b
-11011011b ^ 01010000b = 10001011b
-11011011b ^ 01010001b = 10001010b
-11011011b ^ 01010010b = 10001001b
-11011011b ^ 01010011b = 10001000b
-11011011b ^ 01010100b = 10001111b
-11011011b ^ 01010101b = 10001110b
-11011011b ^ 01010110b = 10001101b
-11011011b ^ 01010111b = 10001100b
-11011011b ^ 01011000b = 10000011b
-11011011b ^ 01011001b = 10000010b
-11011011b ^ 01011010b = 10000001b
-11011011b ^ 01011011b = 10000000b
-11011011b ^ 01011100b = 10000111b
-11011011b ^ 01011101b = 10000110b
-11011011b ^ 01011110b = 10000101b
-11011011b ^ 01011111b = 10000100b
-11011011b ^ 01100000b = 10111011b
-11011011b ^ 01100001b = 10111010b
-11011011b ^ 01100010b = 10111001b
-11011011b ^ 01100011b = 10111000b
-11011011b ^ 01100100b = 10111111b
-11011011b ^ 01100101b = 10111110b
-11011011b ^ 01100110b = 10111101b
-11011011b ^ 01100111b = 10111100b
-11011011b ^ 01101000b = 10110011b
-11011011b ^ 01101001b = 10110010b
-11011011b ^ 01101010b = 10110001b
-11011011b ^ 01101011b = 10110000b
-11011011b ^ 01101100b = 10110111b
-11011011b ^ 01101101b = 10110110b
-11011011b ^ 01101110b = 10110101b
-11011011b ^ 01101111b = 10110100b
-11011011b ^ 01110000b = 10101011b
-11011011b ^ 01110001b = 10101010b
-11011011b ^ 01110010b = 10101001b
-11011011b ^ 01110011b = 10101000b
-11011011b ^ 01110100b = 10101111b
-11011011b ^ 01110101b = 10101110b
-11011011b ^ 01110110b = 10101101b
-11011011b ^ 01110111b = 10101100b
-11011011b ^ 01111000b = 10100011b
-11011011b ^ 01111001b = 10100010b
-11011011b ^ 01111010b = 10100001b
-11011011b ^ 01111011b = 10100000b
-11011011b ^ 01111100b = 10100111b
-11011011b ^ 01111101b = 10100110b
-11011011b ^ 01111110b = 10100101b
-11011100b ^ 10000000b = 01011100b
-11011100b ^ 10000001b = 01011101b
-11011100b ^ 10000010b = 01011110b
-11011100b ^ 10000011b = 01011111b
-11011100b ^ 10000100b = 01011000b
-11011100b ^ 10000101b = 01011001b
-11011100b ^ 10000110b = 01011010b
-11011100b ^ 10000111b = 01011011b
-11011100b ^ 10001000b = 01010100b
-11011100b ^ 10001001b = 01010101b
-11011100b ^ 10001010b = 01010110b
-11011100b ^ 10001011b = 01010111b
-11011100b ^ 10001100b = 01010000b
-11011100b ^ 10001101b = 01010001b
-11011100b ^ 10001110b = 01010010b
-11011100b ^ 10001111b = 01010011b
-11011100b ^ 10010000b = 01001100b
-11011100b ^ 10010001b = 01001101b
-11011100b ^ 10010010b = 01001110b
-11011100b ^ 10010011b = 01001111b
-11011100b ^ 10010100b = 01001000b
-11011100b ^ 10010101b = 01001001b
-11011100b ^ 10010110b = 01001010b
-11011100b ^ 10010111b = 01001011b
-11011100b ^ 10011000b = 01000100b
-11011100b ^ 10011001b = 01000101b
-11011100b ^ 10011010b = 01000110b
-11011100b ^ 10011011b = 01000111b
-11011100b ^ 10011100b = 01000000b
-11011100b ^ 10011101b = 01000001b
-11011100b ^ 10011110b = 01000010b
-11011100b ^ 10011111b = 01000011b
-11011100b ^ 10100000b = 01111100b
-11011100b ^ 10100001b = 01111101b
-11011100b ^ 10100010b = 01111110b
-11011100b ^ 10100011b = 01111111b
-11011100b ^ 10100100b = 01111000b
-11011100b ^ 10100101b = 01111001b
-11011100b ^ 10100110b = 01111010b
-11011100b ^ 10100111b = 01111011b
-11011100b ^ 10101000b = 01110100b
-11011100b ^ 10101001b = 01110101b
-11011100b ^ 10101010b = 01110110b
-11011100b ^ 10101011b = 01110111b
-11011100b ^ 10101100b = 01110000b
-11011100b ^ 10101101b = 01110001b
-11011100b ^ 10101110b = 01110010b
-11011100b ^ 10101111b = 01110011b
-11011100b ^ 10110000b = 01101100b
-11011100b ^ 10110001b = 01101101b
-11011100b ^ 10110010b = 01101110b
-11011100b ^ 10110011b = 01101111b
-11011100b ^ 10110100b = 01101000b
-11011100b ^ 10110101b = 01101001b
-11011100b ^ 10110110b = 01101010b
-11011100b ^ 10110111b = 01101011b
-11011100b ^ 10111000b = 01100100b
-11011100b ^ 10111001b = 01100101b
-11011100b ^ 10111010b = 01100110b
-11011100b ^ 10111011b = 01100111b
-11011100b ^ 10111100b = 01100000b
-11011100b ^ 10111101b = 01100001b
-11011100b ^ 10111110b = 01100010b
-11011100b ^ 10111111b = 01100011b
-11011100b ^ 11000000b = 00011100b
-11011100b ^ 11000001b = 00011101b
-11011100b ^ 11000010b = 00011110b
-11011100b ^ 11000011b = 00011111b
-11011100b ^ 11000100b = 00011000b
-11011100b ^ 11000101b = 00011001b
-11011100b ^ 11000110b = 00011010b
-11011100b ^ 11000111b = 00011011b
-11011100b ^ 11001000b = 00010100b
-11011100b ^ 11001001b = 00010101b
-11011100b ^ 11001010b = 00010110b
-11011100b ^ 11001011b = 00010111b
-11011100b ^ 11001100b = 00010000b
-11011100b ^ 11001101b = 00010001b
-11011100b ^ 11001110b = 00010010b
-11011100b ^ 11001111b = 00010011b
-11011100b ^ 11010000b = 00001100b
-11011100b ^ 11010001b = 00001101b
-11011100b ^ 11010010b = 00001110b
-11011100b ^ 11010011b = 00001111b
-11011100b ^ 11010100b = 00001000b
-11011100b ^ 11010101b = 00001001b
-11011100b ^ 11010110b = 00001010b
-11011100b ^ 11010111b = 00001011b
-11011100b ^ 11011000b = 00000100b
-11011100b ^ 11011001b = 00000101b
-11011100b ^ 11011010b = 00000110b
-11011100b ^ 11011011b = 00000111b
-11011100b ^ 11011100b = 00000000b
-11011100b ^ 11011101b = 00000001b
-11011100b ^ 11011110b = 00000010b
-11011100b ^ 11011111b = 00000011b
-11011100b ^ 11100000b = 00111100b
-11011100b ^ 11100001b = 00111101b
-11011100b ^ 11100010b = 00111110b
-11011100b ^ 11100011b = 00111111b
-11011100b ^ 11100100b = 00111000b
-11011100b ^ 11100101b = 00111001b
-11011100b ^ 11100110b = 00111010b
-11011100b ^ 11100111b = 00111011b
-11011100b ^ 11101000b = 00110100b
-11011100b ^ 11101001b = 00110101b
-11011100b ^ 11101010b = 00110110b
-11011100b ^ 11101011b = 00110111b
-11011100b ^ 11101100b = 00110000b
-11011100b ^ 11101101b = 00110001b
-11011100b ^ 11101110b = 00110010b
-11011100b ^ 11101111b = 00110011b
-11011100b ^ 11110000b = 00101100b
-11011100b ^ 11110001b = 00101101b
-11011100b ^ 11110010b = 00101110b
-11011100b ^ 11110011b = 00101111b
-11011100b ^ 11110100b = 00101000b
-11011100b ^ 11110101b = 00101001b
-11011100b ^ 11110110b = 00101010b
-11011100b ^ 11110111b = 00101011b
-11011100b ^ 11111000b = 00100100b
-11011100b ^ 11111001b = 00100101b
-11011100b ^ 11111010b = 00100110b
-11011100b ^ 11111011b = 00100111b
-11011100b ^ 11111100b = 00100000b
-11011100b ^ 11111101b = 00100001b
-11011100b ^ 11111110b = 00100010b
-11011100b ^ 11111111b = 00100011b
-11011100b ^ 00000000b = 11011100b
-11011100b ^ 00000001b = 11011101b
-11011100b ^ 00000010b = 11011110b
-11011100b ^ 00000011b = 11011111b
-11011100b ^ 00000100b = 11011000b
-11011100b ^ 00000101b = 11011001b
-11011100b ^ 00000110b = 11011010b
-11011100b ^ 00000111b = 11011011b
-11011100b ^ 00001000b = 11010100b
-11011100b ^ 00001001b = 11010101b
-11011100b ^ 00001010b = 11010110b
-11011100b ^ 00001011b = 11010111b
-11011100b ^ 00001100b = 11010000b
-11011100b ^ 00001101b = 11010001b
-11011100b ^ 00001110b = 11010010b
-11011100b ^ 00001111b = 11010011b
-11011100b ^ 00010000b = 11001100b
-11011100b ^ 00010001b = 11001101b
-11011100b ^ 00010010b = 11001110b
-11011100b ^ 00010011b = 11001111b
-11011100b ^ 00010100b = 11001000b
-11011100b ^ 00010101b = 11001001b
-11011100b ^ 00010110b = 11001010b
-11011100b ^ 00010111b = 11001011b
-11011100b ^ 00011000b = 11000100b
-11011100b ^ 00011001b = 11000101b
-11011100b ^ 00011010b = 11000110b
-11011100b ^ 00011011b = 11000111b
-11011100b ^ 00011100b = 11000000b
-11011100b ^ 00011101b = 11000001b
-11011100b ^ 00011110b = 11000010b
-11011100b ^ 00011111b = 11000011b
-11011100b ^ 00100000b = 11111100b
-11011100b ^ 00100001b = 11111101b
-11011100b ^ 00100010b = 11111110b
-11011100b ^ 00100011b = 11111111b
-11011100b ^ 00100100b = 11111000b
-11011100b ^ 00100101b = 11111001b
-11011100b ^ 00100110b = 11111010b
-11011100b ^ 00100111b = 11111011b
-11011100b ^ 00101000b = 11110100b
-11011100b ^ 00101001b = 11110101b
-11011100b ^ 00101010b = 11110110b
-11011100b ^ 00101011b = 11110111b
-11011100b ^ 00101100b = 11110000b
-11011100b ^ 00101101b = 11110001b
-11011100b ^ 00101110b = 11110010b
-11011100b ^ 00101111b = 11110011b
-11011100b ^ 00110000b = 11101100b
-11011100b ^ 00110001b = 11101101b
-11011100b ^ 00110010b = 11101110b
-11011100b ^ 00110011b = 11101111b
-11011100b ^ 00110100b = 11101000b
-11011100b ^ 00110101b = 11101001b
-11011100b ^ 00110110b = 11101010b
-11011100b ^ 00110111b = 11101011b
-11011100b ^ 00111000b = 11100100b
-11011100b ^ 00111001b = 11100101b
-11011100b ^ 00111010b = 11100110b
-11011100b ^ 00111011b = 11100111b
-11011100b ^ 00111100b = 11100000b
-11011100b ^ 00111101b = 11100001b
-11011100b ^ 00111110b = 11100010b
-11011100b ^ 00111111b = 11100011b
-11011100b ^ 01000000b = 10011100b
-11011100b ^ 01000001b = 10011101b
-11011100b ^ 01000010b = 10011110b
-11011100b ^ 01000011b = 10011111b
-11011100b ^ 01000100b = 10011000b
-11011100b ^ 01000101b = 10011001b
-11011100b ^ 01000110b = 10011010b
-11011100b ^ 01000111b = 10011011b
-11011100b ^ 01001000b = 10010100b
-11011100b ^ 01001001b = 10010101b
-11011100b ^ 01001010b = 10010110b
-11011100b ^ 01001011b = 10010111b
-11011100b ^ 01001100b = 10010000b
-11011100b ^ 01001101b = 10010001b
-11011100b ^ 01001110b = 10010010b
-11011100b ^ 01001111b = 10010011b
-11011100b ^ 01010000b = 10001100b
-11011100b ^ 01010001b = 10001101b
-11011100b ^ 01010010b = 10001110b
-11011100b ^ 01010011b = 10001111b
-11011100b ^ 01010100b = 10001000b
-11011100b ^ 01010101b = 10001001b
-11011100b ^ 01010110b = 10001010b
-11011100b ^ 01010111b = 10001011b
-11011100b ^ 01011000b = 10000100b
-11011100b ^ 01011001b = 10000101b
-11011100b ^ 01011010b = 10000110b
-11011100b ^ 01011011b = 10000111b
-11011100b ^ 01011100b = 10000000b
-11011100b ^ 01011101b = 10000001b
-11011100b ^ 01011110b = 10000010b
-11011100b ^ 01011111b = 10000011b
-11011100b ^ 01100000b = 10111100b
-11011100b ^ 01100001b = 10111101b
-11011100b ^ 01100010b = 10111110b
-11011100b ^ 01100011b = 10111111b
-11011100b ^ 01100100b = 10111000b
-11011100b ^ 01100101b = 10111001b
-11011100b ^ 01100110b = 10111010b
-11011100b ^ 01100111b = 10111011b
-11011100b ^ 01101000b = 10110100b
-11011100b ^ 01101001b = 10110101b
-11011100b ^ 01101010b = 10110110b
-11011100b ^ 01101011b = 10110111b
-11011100b ^ 01101100b = 10110000b
-11011100b ^ 01101101b = 10110001b
-11011100b ^ 01101110b = 10110010b
-11011100b ^ 01101111b = 10110011b
-11011100b ^ 01110000b = 10101100b
-11011100b ^ 01110001b = 10101101b
-11011100b ^ 01110010b = 10101110b
-11011100b ^ 01110011b = 10101111b
-11011100b ^ 01110100b = 10101000b
-11011100b ^ 01110101b = 10101001b
-11011100b ^ 01110110b = 10101010b
-11011100b ^ 01110111b = 10101011b
-11011100b ^ 01111000b = 10100100b
-11011100b ^ 01111001b = 10100101b
-11011100b ^ 01111010b = 10100110b
-11011100b ^ 01111011b = 10100111b
-11011100b ^ 01111100b = 10100000b
-11011100b ^ 01111101b = 10100001b
-11011100b ^ 01111110b = 10100010b
-11011101b ^ 10000000b = 01011101b
-11011101b ^ 10000001b = 01011100b
-11011101b ^ 10000010b = 01011111b
-11011101b ^ 10000011b = 01011110b
-11011101b ^ 10000100b = 01011001b
-11011101b ^ 10000101b = 01011000b
-11011101b ^ 10000110b = 01011011b
-11011101b ^ 10000111b = 01011010b
-11011101b ^ 10001000b = 01010101b
-11011101b ^ 10001001b = 01010100b
-11011101b ^ 10001010b = 01010111b
-11011101b ^ 10001011b = 01010110b
-11011101b ^ 10001100b = 01010001b
-11011101b ^ 10001101b = 01010000b
-11011101b ^ 10001110b = 01010011b
-11011101b ^ 10001111b = 01010010b
-11011101b ^ 10010000b = 01001101b
-11011101b ^ 10010001b = 01001100b
-11011101b ^ 10010010b = 01001111b
-11011101b ^ 10010011b = 01001110b
-11011101b ^ 10010100b = 01001001b
-11011101b ^ 10010101b = 01001000b
-11011101b ^ 10010110b = 01001011b
-11011101b ^ 10010111b = 01001010b
-11011101b ^ 10011000b = 01000101b
-11011101b ^ 10011001b = 01000100b
-11011101b ^ 10011010b = 01000111b
-11011101b ^ 10011011b = 01000110b
-11011101b ^ 10011100b = 01000001b
-11011101b ^ 10011101b = 01000000b
-11011101b ^ 10011110b = 01000011b
-11011101b ^ 10011111b = 01000010b
-11011101b ^ 10100000b = 01111101b
-11011101b ^ 10100001b = 01111100b
-11011101b ^ 10100010b = 01111111b
-11011101b ^ 10100011b = 01111110b
-11011101b ^ 10100100b = 01111001b
-11011101b ^ 10100101b = 01111000b
-11011101b ^ 10100110b = 01111011b
-11011101b ^ 10100111b = 01111010b
-11011101b ^ 10101000b = 01110101b
-11011101b ^ 10101001b = 01110100b
-11011101b ^ 10101010b = 01110111b
-11011101b ^ 10101011b = 01110110b
-11011101b ^ 10101100b = 01110001b
-11011101b ^ 10101101b = 01110000b
-11011101b ^ 10101110b = 01110011b
-11011101b ^ 10101111b = 01110010b
-11011101b ^ 10110000b = 01101101b
-11011101b ^ 10110001b = 01101100b
-11011101b ^ 10110010b = 01101111b
-11011101b ^ 10110011b = 01101110b
-11011101b ^ 10110100b = 01101001b
-11011101b ^ 10110101b = 01101000b
-11011101b ^ 10110110b = 01101011b
-11011101b ^ 10110111b = 01101010b
-11011101b ^ 10111000b = 01100101b
-11011101b ^ 10111001b = 01100100b
-11011101b ^ 10111010b = 01100111b
-11011101b ^ 10111011b = 01100110b
-11011101b ^ 10111100b = 01100001b
-11011101b ^ 10111101b = 01100000b
-11011101b ^ 10111110b = 01100011b
-11011101b ^ 10111111b = 01100010b
-11011101b ^ 11000000b = 00011101b
-11011101b ^ 11000001b = 00011100b
-11011101b ^ 11000010b = 00011111b
-11011101b ^ 11000011b = 00011110b
-11011101b ^ 11000100b = 00011001b
-11011101b ^ 11000101b = 00011000b
-11011101b ^ 11000110b = 00011011b
-11011101b ^ 11000111b = 00011010b
-11011101b ^ 11001000b = 00010101b
-11011101b ^ 11001001b = 00010100b
-11011101b ^ 11001010b = 00010111b
-11011101b ^ 11001011b = 00010110b
-11011101b ^ 11001100b = 00010001b
-11011101b ^ 11001101b = 00010000b
-11011101b ^ 11001110b = 00010011b
-11011101b ^ 11001111b = 00010010b
-11011101b ^ 11010000b = 00001101b
-11011101b ^ 11010001b = 00001100b
-11011101b ^ 11010010b = 00001111b
-11011101b ^ 11010011b = 00001110b
-11011101b ^ 11010100b = 00001001b
-11011101b ^ 11010101b = 00001000b
-11011101b ^ 11010110b = 00001011b
-11011101b ^ 11010111b = 00001010b
-11011101b ^ 11011000b = 00000101b
-11011101b ^ 11011001b = 00000100b
-11011101b ^ 11011010b = 00000111b
-11011101b ^ 11011011b = 00000110b
-11011101b ^ 11011100b = 00000001b
-11011101b ^ 11011101b = 00000000b
-11011101b ^ 11011110b = 00000011b
-11011101b ^ 11011111b = 00000010b
-11011101b ^ 11100000b = 00111101b
-11011101b ^ 11100001b = 00111100b
-11011101b ^ 11100010b = 00111111b
-11011101b ^ 11100011b = 00111110b
-11011101b ^ 11100100b = 00111001b
-11011101b ^ 11100101b = 00111000b
-11011101b ^ 11100110b = 00111011b
-11011101b ^ 11100111b = 00111010b
-11011101b ^ 11101000b = 00110101b
-11011101b ^ 11101001b = 00110100b
-11011101b ^ 11101010b = 00110111b
-11011101b ^ 11101011b = 00110110b
-11011101b ^ 11101100b = 00110001b
-11011101b ^ 11101101b = 00110000b
-11011101b ^ 11101110b = 00110011b
-11011101b ^ 11101111b = 00110010b
-11011101b ^ 11110000b = 00101101b
-11011101b ^ 11110001b = 00101100b
-11011101b ^ 11110010b = 00101111b
-11011101b ^ 11110011b = 00101110b
-11011101b ^ 11110100b = 00101001b
-11011101b ^ 11110101b = 00101000b
-11011101b ^ 11110110b = 00101011b
-11011101b ^ 11110111b = 00101010b
-11011101b ^ 11111000b = 00100101b
-11011101b ^ 11111001b = 00100100b
-11011101b ^ 11111010b = 00100111b
-11011101b ^ 11111011b = 00100110b
-11011101b ^ 11111100b = 00100001b
-11011101b ^ 11111101b = 00100000b
-11011101b ^ 11111110b = 00100011b
-11011101b ^ 11111111b = 00100010b
-11011101b ^ 00000000b = 11011101b
-11011101b ^ 00000001b = 11011100b
-11011101b ^ 00000010b = 11011111b
-11011101b ^ 00000011b = 11011110b
-11011101b ^ 00000100b = 11011001b
-11011101b ^ 00000101b = 11011000b
-11011101b ^ 00000110b = 11011011b
-11011101b ^ 00000111b = 11011010b
-11011101b ^ 00001000b = 11010101b
-11011101b ^ 00001001b = 11010100b
-11011101b ^ 00001010b = 11010111b
-11011101b ^ 00001011b = 11010110b
-11011101b ^ 00001100b = 11010001b
-11011101b ^ 00001101b = 11010000b
-11011101b ^ 00001110b = 11010011b
-11011101b ^ 00001111b = 11010010b
-11011101b ^ 00010000b = 11001101b
-11011101b ^ 00010001b = 11001100b
-11011101b ^ 00010010b = 11001111b
-11011101b ^ 00010011b = 11001110b
-11011101b ^ 00010100b = 11001001b
-11011101b ^ 00010101b = 11001000b
-11011101b ^ 00010110b = 11001011b
-11011101b ^ 00010111b = 11001010b
-11011101b ^ 00011000b = 11000101b
-11011101b ^ 00011001b = 11000100b
-11011101b ^ 00011010b = 11000111b
-11011101b ^ 00011011b = 11000110b
-11011101b ^ 00011100b = 11000001b
-11011101b ^ 00011101b = 11000000b
-11011101b ^ 00011110b = 11000011b
-11011101b ^ 00011111b = 11000010b
-11011101b ^ 00100000b = 11111101b
-11011101b ^ 00100001b = 11111100b
-11011101b ^ 00100010b = 11111111b
-11011101b ^ 00100011b = 11111110b
-11011101b ^ 00100100b = 11111001b
-11011101b ^ 00100101b = 11111000b
-11011101b ^ 00100110b = 11111011b
-11011101b ^ 00100111b = 11111010b
-11011101b ^ 00101000b = 11110101b
-11011101b ^ 00101001b = 11110100b
-11011101b ^ 00101010b = 11110111b
-11011101b ^ 00101011b = 11110110b
-11011101b ^ 00101100b = 11110001b
-11011101b ^ 00101101b = 11110000b
-11011101b ^ 00101110b = 11110011b
-11011101b ^ 00101111b = 11110010b
-11011101b ^ 00110000b = 11101101b
-11011101b ^ 00110001b = 11101100b
-11011101b ^ 00110010b = 11101111b
-11011101b ^ 00110011b = 11101110b
-11011101b ^ 00110100b = 11101001b
-11011101b ^ 00110101b = 11101000b
-11011101b ^ 00110110b = 11101011b
-11011101b ^ 00110111b = 11101010b
-11011101b ^ 00111000b = 11100101b
-11011101b ^ 00111001b = 11100100b
-11011101b ^ 00111010b = 11100111b
-11011101b ^ 00111011b = 11100110b
-11011101b ^ 00111100b = 11100001b
-11011101b ^ 00111101b = 11100000b
-11011101b ^ 00111110b = 11100011b
-11011101b ^ 00111111b = 11100010b
-11011101b ^ 01000000b = 10011101b
-11011101b ^ 01000001b = 10011100b
-11011101b ^ 01000010b = 10011111b
-11011101b ^ 01000011b = 10011110b
-11011101b ^ 01000100b = 10011001b
-11011101b ^ 01000101b = 10011000b
-11011101b ^ 01000110b = 10011011b
-11011101b ^ 01000111b = 10011010b
-11011101b ^ 01001000b = 10010101b
-11011101b ^ 01001001b = 10010100b
-11011101b ^ 01001010b = 10010111b
-11011101b ^ 01001011b = 10010110b
-11011101b ^ 01001100b = 10010001b
-11011101b ^ 01001101b = 10010000b
-11011101b ^ 01001110b = 10010011b
-11011101b ^ 01001111b = 10010010b
-11011101b ^ 01010000b = 10001101b
-11011101b ^ 01010001b = 10001100b
-11011101b ^ 01010010b = 10001111b
-11011101b ^ 01010011b = 10001110b
-11011101b ^ 01010100b = 10001001b
-11011101b ^ 01010101b = 10001000b
-11011101b ^ 01010110b = 10001011b
-11011101b ^ 01010111b = 10001010b
-11011101b ^ 01011000b = 10000101b
-11011101b ^ 01011001b = 10000100b
-11011101b ^ 01011010b = 10000111b
-11011101b ^ 01011011b = 10000110b
-11011101b ^ 01011100b = 10000001b
-11011101b ^ 01011101b = 10000000b
-11011101b ^ 01011110b = 10000011b
-11011101b ^ 01011111b = 10000010b
-11011101b ^ 01100000b = 10111101b
-11011101b ^ 01100001b = 10111100b
-11011101b ^ 01100010b = 10111111b
-11011101b ^ 01100011b = 10111110b
-11011101b ^ 01100100b = 10111001b
-11011101b ^ 01100101b = 10111000b
-11011101b ^ 01100110b = 10111011b
-11011101b ^ 01100111b = 10111010b
-11011101b ^ 01101000b = 10110101b
-11011101b ^ 01101001b = 10110100b
-11011101b ^ 01101010b = 10110111b
-11011101b ^ 01101011b = 10110110b
-11011101b ^ 01101100b = 10110001b
-11011101b ^ 01101101b = 10110000b
-11011101b ^ 01101110b = 10110011b
-11011101b ^ 01101111b = 10110010b
-11011101b ^ 01110000b = 10101101b
-11011101b ^ 01110001b = 10101100b
-11011101b ^ 01110010b = 10101111b
-11011101b ^ 01110011b = 10101110b
-11011101b ^ 01110100b = 10101001b
-11011101b ^ 01110101b = 10101000b
-11011101b ^ 01110110b = 10101011b
-11011101b ^ 01110111b = 10101010b
-11011101b ^ 01111000b = 10100101b
-11011101b ^ 01111001b = 10100100b
-11011101b ^ 01111010b = 10100111b
-11011101b ^ 01111011b = 10100110b
-11011101b ^ 01111100b = 10100001b
-11011101b ^ 01111101b = 10100000b
-11011101b ^ 01111110b = 10100011b
-11011110b ^ 10000000b = 01011110b
-11011110b ^ 10000001b = 01011111b
-11011110b ^ 10000010b = 01011100b
-11011110b ^ 10000011b = 01011101b
-11011110b ^ 10000100b = 01011010b
-11011110b ^ 10000101b = 01011011b
-11011110b ^ 10000110b = 01011000b
-11011110b ^ 10000111b = 01011001b
-11011110b ^ 10001000b = 01010110b
-11011110b ^ 10001001b = 01010111b
-11011110b ^ 10001010b = 01010100b
-11011110b ^ 10001011b = 01010101b
-11011110b ^ 10001100b = 01010010b
-11011110b ^ 10001101b = 01010011b
-11011110b ^ 10001110b = 01010000b
-11011110b ^ 10001111b = 01010001b
-11011110b ^ 10010000b = 01001110b
-11011110b ^ 10010001b = 01001111b
-11011110b ^ 10010010b = 01001100b
-11011110b ^ 10010011b = 01001101b
-11011110b ^ 10010100b = 01001010b
-11011110b ^ 10010101b = 01001011b
-11011110b ^ 10010110b = 01001000b
-11011110b ^ 10010111b = 01001001b
-11011110b ^ 10011000b = 01000110b
-11011110b ^ 10011001b = 01000111b
-11011110b ^ 10011010b = 01000100b
-11011110b ^ 10011011b = 01000101b
-11011110b ^ 10011100b = 01000010b
-11011110b ^ 10011101b = 01000011b
-11011110b ^ 10011110b = 01000000b
-11011110b ^ 10011111b = 01000001b
-11011110b ^ 10100000b = 01111110b
-11011110b ^ 10100001b = 01111111b
-11011110b ^ 10100010b = 01111100b
-11011110b ^ 10100011b = 01111101b
-11011110b ^ 10100100b = 01111010b
-11011110b ^ 10100101b = 01111011b
-11011110b ^ 10100110b = 01111000b
-11011110b ^ 10100111b = 01111001b
-11011110b ^ 10101000b = 01110110b
-11011110b ^ 10101001b = 01110111b
-11011110b ^ 10101010b = 01110100b
-11011110b ^ 10101011b = 01110101b
-11011110b ^ 10101100b = 01110010b
-11011110b ^ 10101101b = 01110011b
-11011110b ^ 10101110b = 01110000b
-11011110b ^ 10101111b = 01110001b
-11011110b ^ 10110000b = 01101110b
-11011110b ^ 10110001b = 01101111b
-11011110b ^ 10110010b = 01101100b
-11011110b ^ 10110011b = 01101101b
-11011110b ^ 10110100b = 01101010b
-11011110b ^ 10110101b = 01101011b
-11011110b ^ 10110110b = 01101000b
-11011110b ^ 10110111b = 01101001b
-11011110b ^ 10111000b = 01100110b
-11011110b ^ 10111001b = 01100111b
-11011110b ^ 10111010b = 01100100b
-11011110b ^ 10111011b = 01100101b
-11011110b ^ 10111100b = 01100010b
-11011110b ^ 10111101b = 01100011b
-11011110b ^ 10111110b = 01100000b
-11011110b ^ 10111111b = 01100001b
-11011110b ^ 11000000b = 00011110b
-11011110b ^ 11000001b = 00011111b
-11011110b ^ 11000010b = 00011100b
-11011110b ^ 11000011b = 00011101b
-11011110b ^ 11000100b = 00011010b
-11011110b ^ 11000101b = 00011011b
-11011110b ^ 11000110b = 00011000b
-11011110b ^ 11000111b = 00011001b
-11011110b ^ 11001000b = 00010110b
-11011110b ^ 11001001b = 00010111b
-11011110b ^ 11001010b = 00010100b
-11011110b ^ 11001011b = 00010101b
-11011110b ^ 11001100b = 00010010b
-11011110b ^ 11001101b = 00010011b
-11011110b ^ 11001110b = 00010000b
-11011110b ^ 11001111b = 00010001b
-11011110b ^ 11010000b = 00001110b
-11011110b ^ 11010001b = 00001111b
-11011110b ^ 11010010b = 00001100b
-11011110b ^ 11010011b = 00001101b
-11011110b ^ 11010100b = 00001010b
-11011110b ^ 11010101b = 00001011b
-11011110b ^ 11010110b = 00001000b
-11011110b ^ 11010111b = 00001001b
-11011110b ^ 11011000b = 00000110b
-11011110b ^ 11011001b = 00000111b
-11011110b ^ 11011010b = 00000100b
-11011110b ^ 11011011b = 00000101b
-11011110b ^ 11011100b = 00000010b
-11011110b ^ 11011101b = 00000011b
-11011110b ^ 11011110b = 00000000b
-11011110b ^ 11011111b = 00000001b
-11011110b ^ 11100000b = 00111110b
-11011110b ^ 11100001b = 00111111b
-11011110b ^ 11100010b = 00111100b
-11011110b ^ 11100011b = 00111101b
-11011110b ^ 11100100b = 00111010b
-11011110b ^ 11100101b = 00111011b
-11011110b ^ 11100110b = 00111000b
-11011110b ^ 11100111b = 00111001b
-11011110b ^ 11101000b = 00110110b
-11011110b ^ 11101001b = 00110111b
-11011110b ^ 11101010b = 00110100b
-11011110b ^ 11101011b = 00110101b
-11011110b ^ 11101100b = 00110010b
-11011110b ^ 11101101b = 00110011b
-11011110b ^ 11101110b = 00110000b
-11011110b ^ 11101111b = 00110001b
-11011110b ^ 11110000b = 00101110b
-11011110b ^ 11110001b = 00101111b
-11011110b ^ 11110010b = 00101100b
-11011110b ^ 11110011b = 00101101b
-11011110b ^ 11110100b = 00101010b
-11011110b ^ 11110101b = 00101011b
-11011110b ^ 11110110b = 00101000b
-11011110b ^ 11110111b = 00101001b
-11011110b ^ 11111000b = 00100110b
-11011110b ^ 11111001b = 00100111b
-11011110b ^ 11111010b = 00100100b
-11011110b ^ 11111011b = 00100101b
-11011110b ^ 11111100b = 00100010b
-11011110b ^ 11111101b = 00100011b
-11011110b ^ 11111110b = 00100000b
-11011110b ^ 11111111b = 00100001b
-11011110b ^ 00000000b = 11011110b
-11011110b ^ 00000001b = 11011111b
-11011110b ^ 00000010b = 11011100b
-11011110b ^ 00000011b = 11011101b
-11011110b ^ 00000100b = 11011010b
-11011110b ^ 00000101b = 11011011b
-11011110b ^ 00000110b = 11011000b
-11011110b ^ 00000111b = 11011001b
-11011110b ^ 00001000b = 11010110b
-11011110b ^ 00001001b = 11010111b
-11011110b ^ 00001010b = 11010100b
-11011110b ^ 00001011b = 11010101b
-11011110b ^ 00001100b = 11010010b
-11011110b ^ 00001101b = 11010011b
-11011110b ^ 00001110b = 11010000b
-11011110b ^ 00001111b = 11010001b
-11011110b ^ 00010000b = 11001110b
-11011110b ^ 00010001b = 11001111b
-11011110b ^ 00010010b = 11001100b
-11011110b ^ 00010011b = 11001101b
-11011110b ^ 00010100b = 11001010b
-11011110b ^ 00010101b = 11001011b
-11011110b ^ 00010110b = 11001000b
-11011110b ^ 00010111b = 11001001b
-11011110b ^ 00011000b = 11000110b
-11011110b ^ 00011001b = 11000111b
-11011110b ^ 00011010b = 11000100b
-11011110b ^ 00011011b = 11000101b
-11011110b ^ 00011100b = 11000010b
-11011110b ^ 00011101b = 11000011b
-11011110b ^ 00011110b = 11000000b
-11011110b ^ 00011111b = 11000001b
-11011110b ^ 00100000b = 11111110b
-11011110b ^ 00100001b = 11111111b
-11011110b ^ 00100010b = 11111100b
-11011110b ^ 00100011b = 11111101b
-11011110b ^ 00100100b = 11111010b
-11011110b ^ 00100101b = 11111011b
-11011110b ^ 00100110b = 11111000b
-11011110b ^ 00100111b = 11111001b
-11011110b ^ 00101000b = 11110110b
-11011110b ^ 00101001b = 11110111b
-11011110b ^ 00101010b = 11110100b
-11011110b ^ 00101011b = 11110101b
-11011110b ^ 00101100b = 11110010b
-11011110b ^ 00101101b = 11110011b
-11011110b ^ 00101110b = 11110000b
-11011110b ^ 00101111b = 11110001b
-11011110b ^ 00110000b = 11101110b
-11011110b ^ 00110001b = 11101111b
-11011110b ^ 00110010b = 11101100b
-11011110b ^ 00110011b = 11101101b
-11011110b ^ 00110100b = 11101010b
-11011110b ^ 00110101b = 11101011b
-11011110b ^ 00110110b = 11101000b
-11011110b ^ 00110111b = 11101001b
-11011110b ^ 00111000b = 11100110b
-11011110b ^ 00111001b = 11100111b
-11011110b ^ 00111010b = 11100100b
-11011110b ^ 00111011b = 11100101b
-11011110b ^ 00111100b = 11100010b
-11011110b ^ 00111101b = 11100011b
-11011110b ^ 00111110b = 11100000b
-11011110b ^ 00111111b = 11100001b
-11011110b ^ 01000000b = 10011110b
-11011110b ^ 01000001b = 10011111b
-11011110b ^ 01000010b = 10011100b
-11011110b ^ 01000011b = 10011101b
-11011110b ^ 01000100b = 10011010b
-11011110b ^ 01000101b = 10011011b
-11011110b ^ 01000110b = 10011000b
-11011110b ^ 01000111b = 10011001b
-11011110b ^ 01001000b = 10010110b
-11011110b ^ 01001001b = 10010111b
-11011110b ^ 01001010b = 10010100b
-11011110b ^ 01001011b = 10010101b
-11011110b ^ 01001100b = 10010010b
-11011110b ^ 01001101b = 10010011b
-11011110b ^ 01001110b = 10010000b
-11011110b ^ 01001111b = 10010001b
-11011110b ^ 01010000b = 10001110b
-11011110b ^ 01010001b = 10001111b
-11011110b ^ 01010010b = 10001100b
-11011110b ^ 01010011b = 10001101b
-11011110b ^ 01010100b = 10001010b
-11011110b ^ 01010101b = 10001011b
-11011110b ^ 01010110b = 10001000b
-11011110b ^ 01010111b = 10001001b
-11011110b ^ 01011000b = 10000110b
-11011110b ^ 01011001b = 10000111b
-11011110b ^ 01011010b = 10000100b
-11011110b ^ 01011011b = 10000101b
-11011110b ^ 01011100b = 10000010b
-11011110b ^ 01011101b = 10000011b
-11011110b ^ 01011110b = 10000000b
-11011110b ^ 01011111b = 10000001b
-11011110b ^ 01100000b = 10111110b
-11011110b ^ 01100001b = 10111111b
-11011110b ^ 01100010b = 10111100b
-11011110b ^ 01100011b = 10111101b
-11011110b ^ 01100100b = 10111010b
-11011110b ^ 01100101b = 10111011b
-11011110b ^ 01100110b = 10111000b
-11011110b ^ 01100111b = 10111001b
-11011110b ^ 01101000b = 10110110b
-11011110b ^ 01101001b = 10110111b
-11011110b ^ 01101010b = 10110100b
-11011110b ^ 01101011b = 10110101b
-11011110b ^ 01101100b = 10110010b
-11011110b ^ 01101101b = 10110011b
-11011110b ^ 01101110b = 10110000b
-11011110b ^ 01101111b = 10110001b
-11011110b ^ 01110000b = 10101110b
-11011110b ^ 01110001b = 10101111b
-11011110b ^ 01110010b = 10101100b
-11011110b ^ 01110011b = 10101101b
-11011110b ^ 01110100b = 10101010b
-11011110b ^ 01110101b = 10101011b
-11011110b ^ 01110110b = 10101000b
-11011110b ^ 01110111b = 10101001b
-11011110b ^ 01111000b = 10100110b
-11011110b ^ 01111001b = 10100111b
-11011110b ^ 01111010b = 10100100b
-11011110b ^ 01111011b = 10100101b
-11011110b ^ 01111100b = 10100010b
-11011110b ^ 01111101b = 10100011b
-11011110b ^ 01111110b = 10100000b
-11011111b ^ 10000000b = 01011111b
-11011111b ^ 10000001b = 01011110b
-11011111b ^ 10000010b = 01011101b
-11011111b ^ 10000011b = 01011100b
-11011111b ^ 10000100b = 01011011b
-11011111b ^ 10000101b = 01011010b
-11011111b ^ 10000110b = 01011001b
-11011111b ^ 10000111b = 01011000b
-11011111b ^ 10001000b = 01010111b
-11011111b ^ 10001001b = 01010110b
-11011111b ^ 10001010b = 01010101b
-11011111b ^ 10001011b = 01010100b
-11011111b ^ 10001100b = 01010011b
-11011111b ^ 10001101b = 01010010b
-11011111b ^ 10001110b = 01010001b
-11011111b ^ 10001111b = 01010000b
-11011111b ^ 10010000b = 01001111b
-11011111b ^ 10010001b = 01001110b
-11011111b ^ 10010010b = 01001101b
-11011111b ^ 10010011b = 01001100b
-11011111b ^ 10010100b = 01001011b
-11011111b ^ 10010101b = 01001010b
-11011111b ^ 10010110b = 01001001b
-11011111b ^ 10010111b = 01001000b
-11011111b ^ 10011000b = 01000111b
-11011111b ^ 10011001b = 01000110b
-11011111b ^ 10011010b = 01000101b
-11011111b ^ 10011011b = 01000100b
-11011111b ^ 10011100b = 01000011b
-11011111b ^ 10011101b = 01000010b
-11011111b ^ 10011110b = 01000001b
-11011111b ^ 10011111b = 01000000b
-11011111b ^ 10100000b = 01111111b
-11011111b ^ 10100001b = 01111110b
-11011111b ^ 10100010b = 01111101b
-11011111b ^ 10100011b = 01111100b
-11011111b ^ 10100100b = 01111011b
-11011111b ^ 10100101b = 01111010b
-11011111b ^ 10100110b = 01111001b
-11011111b ^ 10100111b = 01111000b
-11011111b ^ 10101000b = 01110111b
-11011111b ^ 10101001b = 01110110b
-11011111b ^ 10101010b = 01110101b
-11011111b ^ 10101011b = 01110100b
-11011111b ^ 10101100b = 01110011b
-11011111b ^ 10101101b = 01110010b
-11011111b ^ 10101110b = 01110001b
-11011111b ^ 10101111b = 01110000b
-11011111b ^ 10110000b = 01101111b
-11011111b ^ 10110001b = 01101110b
-11011111b ^ 10110010b = 01101101b
-11011111b ^ 10110011b = 01101100b
-11011111b ^ 10110100b = 01101011b
-11011111b ^ 10110101b = 01101010b
-11011111b ^ 10110110b = 01101001b
-11011111b ^ 10110111b = 01101000b
-11011111b ^ 10111000b = 01100111b
-11011111b ^ 10111001b = 01100110b
-11011111b ^ 10111010b = 01100101b
-11011111b ^ 10111011b = 01100100b
-11011111b ^ 10111100b = 01100011b
-11011111b ^ 10111101b = 01100010b
-11011111b ^ 10111110b = 01100001b
-11011111b ^ 10111111b = 01100000b
-11011111b ^ 11000000b = 00011111b
-11011111b ^ 11000001b = 00011110b
-11011111b ^ 11000010b = 00011101b
-11011111b ^ 11000011b = 00011100b
-11011111b ^ 11000100b = 00011011b
-11011111b ^ 11000101b = 00011010b
-11011111b ^ 11000110b = 00011001b
-11011111b ^ 11000111b = 00011000b
-11011111b ^ 11001000b = 00010111b
-11011111b ^ 11001001b = 00010110b
-11011111b ^ 11001010b = 00010101b
-11011111b ^ 11001011b = 00010100b
-11011111b ^ 11001100b = 00010011b
-11011111b ^ 11001101b = 00010010b
-11011111b ^ 11001110b = 00010001b
-11011111b ^ 11001111b = 00010000b
-11011111b ^ 11010000b = 00001111b
-11011111b ^ 11010001b = 00001110b
-11011111b ^ 11010010b = 00001101b
-11011111b ^ 11010011b = 00001100b
-11011111b ^ 11010100b = 00001011b
-11011111b ^ 11010101b = 00001010b
-11011111b ^ 11010110b = 00001001b
-11011111b ^ 11010111b = 00001000b
-11011111b ^ 11011000b = 00000111b
-11011111b ^ 11011001b = 00000110b
-11011111b ^ 11011010b = 00000101b
-11011111b ^ 11011011b = 00000100b
-11011111b ^ 11011100b = 00000011b
-11011111b ^ 11011101b = 00000010b
-11011111b ^ 11011110b = 00000001b
-11011111b ^ 11011111b = 00000000b
-11011111b ^ 11100000b = 00111111b
-11011111b ^ 11100001b = 00111110b
-11011111b ^ 11100010b = 00111101b
-11011111b ^ 11100011b = 00111100b
-11011111b ^ 11100100b = 00111011b
-11011111b ^ 11100101b = 00111010b
-11011111b ^ 11100110b = 00111001b
-11011111b ^ 11100111b = 00111000b
-11011111b ^ 11101000b = 00110111b
-11011111b ^ 11101001b = 00110110b
-11011111b ^ 11101010b = 00110101b
-11011111b ^ 11101011b = 00110100b
-11011111b ^ 11101100b = 00110011b
-11011111b ^ 11101101b = 00110010b
-11011111b ^ 11101110b = 00110001b
-11011111b ^ 11101111b = 00110000b
-11011111b ^ 11110000b = 00101111b
-11011111b ^ 11110001b = 00101110b
-11011111b ^ 11110010b = 00101101b
-11011111b ^ 11110011b = 00101100b
-11011111b ^ 11110100b = 00101011b
-11011111b ^ 11110101b = 00101010b
-11011111b ^ 11110110b = 00101001b
-11011111b ^ 11110111b = 00101000b
-11011111b ^ 11111000b = 00100111b
-11011111b ^ 11111001b = 00100110b
-11011111b ^ 11111010b = 00100101b
-11011111b ^ 11111011b = 00100100b
-11011111b ^ 11111100b = 00100011b
-11011111b ^ 11111101b = 00100010b
-11011111b ^ 11111110b = 00100001b
-11011111b ^ 11111111b = 00100000b
-11011111b ^ 00000000b = 11011111b
-11011111b ^ 00000001b = 11011110b
-11011111b ^ 00000010b = 11011101b
-11011111b ^ 00000011b = 11011100b
-11011111b ^ 00000100b = 11011011b
-11011111b ^ 00000101b = 11011010b
-11011111b ^ 00000110b = 11011001b
-11011111b ^ 00000111b = 11011000b
-11011111b ^ 00001000b = 11010111b
-11011111b ^ 00001001b = 11010110b
-11011111b ^ 00001010b = 11010101b
-11011111b ^ 00001011b = 11010100b
-11011111b ^ 00001100b = 11010011b
-11011111b ^ 00001101b = 11010010b
-11011111b ^ 00001110b = 11010001b
-11011111b ^ 00001111b = 11010000b
-11011111b ^ 00010000b = 11001111b
-11011111b ^ 00010001b = 11001110b
-11011111b ^ 00010010b = 11001101b
-11011111b ^ 00010011b = 11001100b
-11011111b ^ 00010100b = 11001011b
-11011111b ^ 00010101b = 11001010b
-11011111b ^ 00010110b = 11001001b
-11011111b ^ 00010111b = 11001000b
-11011111b ^ 00011000b = 11000111b
-11011111b ^ 00011001b = 11000110b
-11011111b ^ 00011010b = 11000101b
-11011111b ^ 00011011b = 11000100b
-11011111b ^ 00011100b = 11000011b
-11011111b ^ 00011101b = 11000010b
-11011111b ^ 00011110b = 11000001b
-11011111b ^ 00011111b = 11000000b
-11011111b ^ 00100000b = 11111111b
-11011111b ^ 00100001b = 11111110b
-11011111b ^ 00100010b = 11111101b
-11011111b ^ 00100011b = 11111100b
-11011111b ^ 00100100b = 11111011b
-11011111b ^ 00100101b = 11111010b
-11011111b ^ 00100110b = 11111001b
-11011111b ^ 00100111b = 11111000b
-11011111b ^ 00101000b = 11110111b
-11011111b ^ 00101001b = 11110110b
-11011111b ^ 00101010b = 11110101b
-11011111b ^ 00101011b = 11110100b
-11011111b ^ 00101100b = 11110011b
-11011111b ^ 00101101b = 11110010b
-11011111b ^ 00101110b = 11110001b
-11011111b ^ 00101111b = 11110000b
-11011111b ^ 00110000b = 11101111b
-11011111b ^ 00110001b = 11101110b
-11011111b ^ 00110010b = 11101101b
-11011111b ^ 00110011b = 11101100b
-11011111b ^ 00110100b = 11101011b
-11011111b ^ 00110101b = 11101010b
-11011111b ^ 00110110b = 11101001b
-11011111b ^ 00110111b = 11101000b
-11011111b ^ 00111000b = 11100111b
-11011111b ^ 00111001b = 11100110b
-11011111b ^ 00111010b = 11100101b
-11011111b ^ 00111011b = 11100100b
-11011111b ^ 00111100b = 11100011b
-11011111b ^ 00111101b = 11100010b
-11011111b ^ 00111110b = 11100001b
-11011111b ^ 00111111b = 11100000b
-11011111b ^ 01000000b = 10011111b
-11011111b ^ 01000001b = 10011110b
-11011111b ^ 01000010b = 10011101b
-11011111b ^ 01000011b = 10011100b
-11011111b ^ 01000100b = 10011011b
-11011111b ^ 01000101b = 10011010b
-11011111b ^ 01000110b = 10011001b
-11011111b ^ 01000111b = 10011000b
-11011111b ^ 01001000b = 10010111b
-11011111b ^ 01001001b = 10010110b
-11011111b ^ 01001010b = 10010101b
-11011111b ^ 01001011b = 10010100b
-11011111b ^ 01001100b = 10010011b
-11011111b ^ 01001101b = 10010010b
-11011111b ^ 01001110b = 10010001b
-11011111b ^ 01001111b = 10010000b
-11011111b ^ 01010000b = 10001111b
-11011111b ^ 01010001b = 10001110b
-11011111b ^ 01010010b = 10001101b
-11011111b ^ 01010011b = 10001100b
-11011111b ^ 01010100b = 10001011b
-11011111b ^ 01010101b = 10001010b
-11011111b ^ 01010110b = 10001001b
-11011111b ^ 01010111b = 10001000b
-11011111b ^ 01011000b = 10000111b
-11011111b ^ 01011001b = 10000110b
-11011111b ^ 01011010b = 10000101b
-11011111b ^ 01011011b = 10000100b
-11011111b ^ 01011100b = 10000011b
-11011111b ^ 01011101b = 10000010b
-11011111b ^ 01011110b = 10000001b
-11011111b ^ 01011111b = 10000000b
-11011111b ^ 01100000b = 10111111b
-11011111b ^ 01100001b = 10111110b
-11011111b ^ 01100010b = 10111101b
-11011111b ^ 01100011b = 10111100b
-11011111b ^ 01100100b = 10111011b
-11011111b ^ 01100101b = 10111010b
-11011111b ^ 01100110b = 10111001b
-11011111b ^ 01100111b = 10111000b
-11011111b ^ 01101000b = 10110111b
-11011111b ^ 01101001b = 10110110b
-11011111b ^ 01101010b = 10110101b
-11011111b ^ 01101011b = 10110100b
-11011111b ^ 01101100b = 10110011b
-11011111b ^ 01101101b = 10110010b
-11011111b ^ 01101110b = 10110001b
-11011111b ^ 01101111b = 10110000b
-11011111b ^ 01110000b = 10101111b
-11011111b ^ 01110001b = 10101110b
-11011111b ^ 01110010b = 10101101b
-11011111b ^ 01110011b = 10101100b
-11011111b ^ 01110100b = 10101011b
-11011111b ^ 01110101b = 10101010b
-11011111b ^ 01110110b = 10101001b
-11011111b ^ 01110111b = 10101000b
-11011111b ^ 01111000b = 10100111b
-11011111b ^ 01111001b = 10100110b
-11011111b ^ 01111010b = 10100101b
-11011111b ^ 01111011b = 10100100b
-11011111b ^ 01111100b = 10100011b
-11011111b ^ 01111101b = 10100010b
-11011111b ^ 01111110b = 10100001b
-11100000b ^ 10000000b = 01100000b
-11100000b ^ 10000001b = 01100001b
-11100000b ^ 10000010b = 01100010b
-11100000b ^ 10000011b = 01100011b
-11100000b ^ 10000100b = 01100100b
-11100000b ^ 10000101b = 01100101b
-11100000b ^ 10000110b = 01100110b
-11100000b ^ 10000111b = 01100111b
-11100000b ^ 10001000b = 01101000b
-11100000b ^ 10001001b = 01101001b
-11100000b ^ 10001010b = 01101010b
-11100000b ^ 10001011b = 01101011b
-11100000b ^ 10001100b = 01101100b
-11100000b ^ 10001101b = 01101101b
-11100000b ^ 10001110b = 01101110b
-11100000b ^ 10001111b = 01101111b
-11100000b ^ 10010000b = 01110000b
-11100000b ^ 10010001b = 01110001b
-11100000b ^ 10010010b = 01110010b
-11100000b ^ 10010011b = 01110011b
-11100000b ^ 10010100b = 01110100b
-11100000b ^ 10010101b = 01110101b
-11100000b ^ 10010110b = 01110110b
-11100000b ^ 10010111b = 01110111b
-11100000b ^ 10011000b = 01111000b
-11100000b ^ 10011001b = 01111001b
-11100000b ^ 10011010b = 01111010b
-11100000b ^ 10011011b = 01111011b
-11100000b ^ 10011100b = 01111100b
-11100000b ^ 10011101b = 01111101b
-11100000b ^ 10011110b = 01111110b
-11100000b ^ 10011111b = 01111111b
-11100000b ^ 10100000b = 01000000b
-11100000b ^ 10100001b = 01000001b
-11100000b ^ 10100010b = 01000010b
-11100000b ^ 10100011b = 01000011b
-11100000b ^ 10100100b = 01000100b
-11100000b ^ 10100101b = 01000101b
-11100000b ^ 10100110b = 01000110b
-11100000b ^ 10100111b = 01000111b
-11100000b ^ 10101000b = 01001000b
-11100000b ^ 10101001b = 01001001b
-11100000b ^ 10101010b = 01001010b
-11100000b ^ 10101011b = 01001011b
-11100000b ^ 10101100b = 01001100b
-11100000b ^ 10101101b = 01001101b
-11100000b ^ 10101110b = 01001110b
-11100000b ^ 10101111b = 01001111b
-11100000b ^ 10110000b = 01010000b
-11100000b ^ 10110001b = 01010001b
-11100000b ^ 10110010b = 01010010b
-11100000b ^ 10110011b = 01010011b
-11100000b ^ 10110100b = 01010100b
-11100000b ^ 10110101b = 01010101b
-11100000b ^ 10110110b = 01010110b
-11100000b ^ 10110111b = 01010111b
-11100000b ^ 10111000b = 01011000b
-11100000b ^ 10111001b = 01011001b
-11100000b ^ 10111010b = 01011010b
-11100000b ^ 10111011b = 01011011b
-11100000b ^ 10111100b = 01011100b
-11100000b ^ 10111101b = 01011101b
-11100000b ^ 10111110b = 01011110b
-11100000b ^ 10111111b = 01011111b
-11100000b ^ 11000000b = 00100000b
-11100000b ^ 11000001b = 00100001b
-11100000b ^ 11000010b = 00100010b
-11100000b ^ 11000011b = 00100011b
-11100000b ^ 11000100b = 00100100b
-11100000b ^ 11000101b = 00100101b
-11100000b ^ 11000110b = 00100110b
-11100000b ^ 11000111b = 00100111b
-11100000b ^ 11001000b = 00101000b
-11100000b ^ 11001001b = 00101001b
-11100000b ^ 11001010b = 00101010b
-11100000b ^ 11001011b = 00101011b
-11100000b ^ 11001100b = 00101100b
-11100000b ^ 11001101b = 00101101b
-11100000b ^ 11001110b = 00101110b
-11100000b ^ 11001111b = 00101111b
-11100000b ^ 11010000b = 00110000b
-11100000b ^ 11010001b = 00110001b
-11100000b ^ 11010010b = 00110010b
-11100000b ^ 11010011b = 00110011b
-11100000b ^ 11010100b = 00110100b
-11100000b ^ 11010101b = 00110101b
-11100000b ^ 11010110b = 00110110b
-11100000b ^ 11010111b = 00110111b
-11100000b ^ 11011000b = 00111000b
-11100000b ^ 11011001b = 00111001b
-11100000b ^ 11011010b = 00111010b
-11100000b ^ 11011011b = 00111011b
-11100000b ^ 11011100b = 00111100b
-11100000b ^ 11011101b = 00111101b
-11100000b ^ 11011110b = 00111110b
-11100000b ^ 11011111b = 00111111b
-11100000b ^ 11100000b = 00000000b
-11100000b ^ 11100001b = 00000001b
-11100000b ^ 11100010b = 00000010b
-11100000b ^ 11100011b = 00000011b
-11100000b ^ 11100100b = 00000100b
-11100000b ^ 11100101b = 00000101b
-11100000b ^ 11100110b = 00000110b
-11100000b ^ 11100111b = 00000111b
-11100000b ^ 11101000b = 00001000b
-11100000b ^ 11101001b = 00001001b
-11100000b ^ 11101010b = 00001010b
-11100000b ^ 11101011b = 00001011b
-11100000b ^ 11101100b = 00001100b
-11100000b ^ 11101101b = 00001101b
-11100000b ^ 11101110b = 00001110b
-11100000b ^ 11101111b = 00001111b
-11100000b ^ 11110000b = 00010000b
-11100000b ^ 11110001b = 00010001b
-11100000b ^ 11110010b = 00010010b
-11100000b ^ 11110011b = 00010011b
-11100000b ^ 11110100b = 00010100b
-11100000b ^ 11110101b = 00010101b
-11100000b ^ 11110110b = 00010110b
-11100000b ^ 11110111b = 00010111b
-11100000b ^ 11111000b = 00011000b
-11100000b ^ 11111001b = 00011001b
-11100000b ^ 11111010b = 00011010b
-11100000b ^ 11111011b = 00011011b
-11100000b ^ 11111100b = 00011100b
-11100000b ^ 11111101b = 00011101b
-11100000b ^ 11111110b = 00011110b
-11100000b ^ 11111111b = 00011111b
-11100000b ^ 00000000b = 11100000b
-11100000b ^ 00000001b = 11100001b
-11100000b ^ 00000010b = 11100010b
-11100000b ^ 00000011b = 11100011b
-11100000b ^ 00000100b = 11100100b
-11100000b ^ 00000101b = 11100101b
-11100000b ^ 00000110b = 11100110b
-11100000b ^ 00000111b = 11100111b
-11100000b ^ 00001000b = 11101000b
-11100000b ^ 00001001b = 11101001b
-11100000b ^ 00001010b = 11101010b
-11100000b ^ 00001011b = 11101011b
-11100000b ^ 00001100b = 11101100b
-11100000b ^ 00001101b = 11101101b
-11100000b ^ 00001110b = 11101110b
-11100000b ^ 00001111b = 11101111b
-11100000b ^ 00010000b = 11110000b
-11100000b ^ 00010001b = 11110001b
-11100000b ^ 00010010b = 11110010b
-11100000b ^ 00010011b = 11110011b
-11100000b ^ 00010100b = 11110100b
-11100000b ^ 00010101b = 11110101b
-11100000b ^ 00010110b = 11110110b
-11100000b ^ 00010111b = 11110111b
-11100000b ^ 00011000b = 11111000b
-11100000b ^ 00011001b = 11111001b
-11100000b ^ 00011010b = 11111010b
-11100000b ^ 00011011b = 11111011b
-11100000b ^ 00011100b = 11111100b
-11100000b ^ 00011101b = 11111101b
-11100000b ^ 00011110b = 11111110b
-11100000b ^ 00011111b = 11111111b
-11100000b ^ 00100000b = 11000000b
-11100000b ^ 00100001b = 11000001b
-11100000b ^ 00100010b = 11000010b
-11100000b ^ 00100011b = 11000011b
-11100000b ^ 00100100b = 11000100b
-11100000b ^ 00100101b = 11000101b
-11100000b ^ 00100110b = 11000110b
-11100000b ^ 00100111b = 11000111b
-11100000b ^ 00101000b = 11001000b
-11100000b ^ 00101001b = 11001001b
-11100000b ^ 00101010b = 11001010b
-11100000b ^ 00101011b = 11001011b
-11100000b ^ 00101100b = 11001100b
-11100000b ^ 00101101b = 11001101b
-11100000b ^ 00101110b = 11001110b
-11100000b ^ 00101111b = 11001111b
-11100000b ^ 00110000b = 11010000b
-11100000b ^ 00110001b = 11010001b
-11100000b ^ 00110010b = 11010010b
-11100000b ^ 00110011b = 11010011b
-11100000b ^ 00110100b = 11010100b
-11100000b ^ 00110101b = 11010101b
-11100000b ^ 00110110b = 11010110b
-11100000b ^ 00110111b = 11010111b
-11100000b ^ 00111000b = 11011000b
-11100000b ^ 00111001b = 11011001b
-11100000b ^ 00111010b = 11011010b
-11100000b ^ 00111011b = 11011011b
-11100000b ^ 00111100b = 11011100b
-11100000b ^ 00111101b = 11011101b
-11100000b ^ 00111110b = 11011110b
-11100000b ^ 00111111b = 11011111b
-11100000b ^ 01000000b = 10100000b
-11100000b ^ 01000001b = 10100001b
-11100000b ^ 01000010b = 10100010b
-11100000b ^ 01000011b = 10100011b
-11100000b ^ 01000100b = 10100100b
-11100000b ^ 01000101b = 10100101b
-11100000b ^ 01000110b = 10100110b
-11100000b ^ 01000111b = 10100111b
-11100000b ^ 01001000b = 10101000b
-11100000b ^ 01001001b = 10101001b
-11100000b ^ 01001010b = 10101010b
-11100000b ^ 01001011b = 10101011b
-11100000b ^ 01001100b = 10101100b
-11100000b ^ 01001101b = 10101101b
-11100000b ^ 01001110b = 10101110b
-11100000b ^ 01001111b = 10101111b
-11100000b ^ 01010000b = 10110000b
-11100000b ^ 01010001b = 10110001b
-11100000b ^ 01010010b = 10110010b
-11100000b ^ 01010011b = 10110011b
-11100000b ^ 01010100b = 10110100b
-11100000b ^ 01010101b = 10110101b
-11100000b ^ 01010110b = 10110110b
-11100000b ^ 01010111b = 10110111b
-11100000b ^ 01011000b = 10111000b
-11100000b ^ 01011001b = 10111001b
-11100000b ^ 01011010b = 10111010b
-11100000b ^ 01011011b = 10111011b
-11100000b ^ 01011100b = 10111100b
-11100000b ^ 01011101b = 10111101b
-11100000b ^ 01011110b = 10111110b
-11100000b ^ 01011111b = 10111111b
-11100000b ^ 01100000b = 10000000b
-11100000b ^ 01100001b = 10000001b
-11100000b ^ 01100010b = 10000010b
-11100000b ^ 01100011b = 10000011b
-11100000b ^ 01100100b = 10000100b
-11100000b ^ 01100101b = 10000101b
-11100000b ^ 01100110b = 10000110b
-11100000b ^ 01100111b = 10000111b
-11100000b ^ 01101000b = 10001000b
-11100000b ^ 01101001b = 10001001b
-11100000b ^ 01101010b = 10001010b
-11100000b ^ 01101011b = 10001011b
-11100000b ^ 01101100b = 10001100b
-11100000b ^ 01101101b = 10001101b
-11100000b ^ 01101110b = 10001110b
-11100000b ^ 01101111b = 10001111b
-11100000b ^ 01110000b = 10010000b
-11100000b ^ 01110001b = 10010001b
-11100000b ^ 01110010b = 10010010b
-11100000b ^ 01110011b = 10010011b
-11100000b ^ 01110100b = 10010100b
-11100000b ^ 01110101b = 10010101b
-11100000b ^ 01110110b = 10010110b
-11100000b ^ 01110111b = 10010111b
-11100000b ^ 01111000b = 10011000b
-11100000b ^ 01111001b = 10011001b
-11100000b ^ 01111010b = 10011010b
-11100000b ^ 01111011b = 10011011b
-11100000b ^ 01111100b = 10011100b
-11100000b ^ 01111101b = 10011101b
-11100000b ^ 01111110b = 10011110b
-11100001b ^ 10000000b = 01100001b
-11100001b ^ 10000001b = 01100000b
-11100001b ^ 10000010b = 01100011b
-11100001b ^ 10000011b = 01100010b
-11100001b ^ 10000100b = 01100101b
-11100001b ^ 10000101b = 01100100b
-11100001b ^ 10000110b = 01100111b
-11100001b ^ 10000111b = 01100110b
-11100001b ^ 10001000b = 01101001b
-11100001b ^ 10001001b = 01101000b
-11100001b ^ 10001010b = 01101011b
-11100001b ^ 10001011b = 01101010b
-11100001b ^ 10001100b = 01101101b
-11100001b ^ 10001101b = 01101100b
-11100001b ^ 10001110b = 01101111b
-11100001b ^ 10001111b = 01101110b
-11100001b ^ 10010000b = 01110001b
-11100001b ^ 10010001b = 01110000b
-11100001b ^ 10010010b = 01110011b
-11100001b ^ 10010011b = 01110010b
-11100001b ^ 10010100b = 01110101b
-11100001b ^ 10010101b = 01110100b
-11100001b ^ 10010110b = 01110111b
-11100001b ^ 10010111b = 01110110b
-11100001b ^ 10011000b = 01111001b
-11100001b ^ 10011001b = 01111000b
-11100001b ^ 10011010b = 01111011b
-11100001b ^ 10011011b = 01111010b
-11100001b ^ 10011100b = 01111101b
-11100001b ^ 10011101b = 01111100b
-11100001b ^ 10011110b = 01111111b
-11100001b ^ 10011111b = 01111110b
-11100001b ^ 10100000b = 01000001b
-11100001b ^ 10100001b = 01000000b
-11100001b ^ 10100010b = 01000011b
-11100001b ^ 10100011b = 01000010b
-11100001b ^ 10100100b = 01000101b
-11100001b ^ 10100101b = 01000100b
-11100001b ^ 10100110b = 01000111b
-11100001b ^ 10100111b = 01000110b
-11100001b ^ 10101000b = 01001001b
-11100001b ^ 10101001b = 01001000b
-11100001b ^ 10101010b = 01001011b
-11100001b ^ 10101011b = 01001010b
-11100001b ^ 10101100b = 01001101b
-11100001b ^ 10101101b = 01001100b
-11100001b ^ 10101110b = 01001111b
-11100001b ^ 10101111b = 01001110b
-11100001b ^ 10110000b = 01010001b
-11100001b ^ 10110001b = 01010000b
-11100001b ^ 10110010b = 01010011b
-11100001b ^ 10110011b = 01010010b
-11100001b ^ 10110100b = 01010101b
-11100001b ^ 10110101b = 01010100b
-11100001b ^ 10110110b = 01010111b
-11100001b ^ 10110111b = 01010110b
-11100001b ^ 10111000b = 01011001b
-11100001b ^ 10111001b = 01011000b
-11100001b ^ 10111010b = 01011011b
-11100001b ^ 10111011b = 01011010b
-11100001b ^ 10111100b = 01011101b
-11100001b ^ 10111101b = 01011100b
-11100001b ^ 10111110b = 01011111b
-11100001b ^ 10111111b = 01011110b
-11100001b ^ 11000000b = 00100001b
-11100001b ^ 11000001b = 00100000b
-11100001b ^ 11000010b = 00100011b
-11100001b ^ 11000011b = 00100010b
-11100001b ^ 11000100b = 00100101b
-11100001b ^ 11000101b = 00100100b
-11100001b ^ 11000110b = 00100111b
-11100001b ^ 11000111b = 00100110b
-11100001b ^ 11001000b = 00101001b
-11100001b ^ 11001001b = 00101000b
-11100001b ^ 11001010b = 00101011b
-11100001b ^ 11001011b = 00101010b
-11100001b ^ 11001100b = 00101101b
-11100001b ^ 11001101b = 00101100b
-11100001b ^ 11001110b = 00101111b
-11100001b ^ 11001111b = 00101110b
-11100001b ^ 11010000b = 00110001b
-11100001b ^ 11010001b = 00110000b
-11100001b ^ 11010010b = 00110011b
-11100001b ^ 11010011b = 00110010b
-11100001b ^ 11010100b = 00110101b
-11100001b ^ 11010101b = 00110100b
-11100001b ^ 11010110b = 00110111b
-11100001b ^ 11010111b = 00110110b
-11100001b ^ 11011000b = 00111001b
-11100001b ^ 11011001b = 00111000b
-11100001b ^ 11011010b = 00111011b
-11100001b ^ 11011011b = 00111010b
-11100001b ^ 11011100b = 00111101b
-11100001b ^ 11011101b = 00111100b
-11100001b ^ 11011110b = 00111111b
-11100001b ^ 11011111b = 00111110b
-11100001b ^ 11100000b = 00000001b
-11100001b ^ 11100001b = 00000000b
-11100001b ^ 11100010b = 00000011b
-11100001b ^ 11100011b = 00000010b
-11100001b ^ 11100100b = 00000101b
-11100001b ^ 11100101b = 00000100b
-11100001b ^ 11100110b = 00000111b
-11100001b ^ 11100111b = 00000110b
-11100001b ^ 11101000b = 00001001b
-11100001b ^ 11101001b = 00001000b
-11100001b ^ 11101010b = 00001011b
-11100001b ^ 11101011b = 00001010b
-11100001b ^ 11101100b = 00001101b
-11100001b ^ 11101101b = 00001100b
-11100001b ^ 11101110b = 00001111b
-11100001b ^ 11101111b = 00001110b
-11100001b ^ 11110000b = 00010001b
-11100001b ^ 11110001b = 00010000b
-11100001b ^ 11110010b = 00010011b
-11100001b ^ 11110011b = 00010010b
-11100001b ^ 11110100b = 00010101b
-11100001b ^ 11110101b = 00010100b
-11100001b ^ 11110110b = 00010111b
-11100001b ^ 11110111b = 00010110b
-11100001b ^ 11111000b = 00011001b
-11100001b ^ 11111001b = 00011000b
-11100001b ^ 11111010b = 00011011b
-11100001b ^ 11111011b = 00011010b
-11100001b ^ 11111100b = 00011101b
-11100001b ^ 11111101b = 00011100b
-11100001b ^ 11111110b = 00011111b
-11100001b ^ 11111111b = 00011110b
-11100001b ^ 00000000b = 11100001b
-11100001b ^ 00000001b = 11100000b
-11100001b ^ 00000010b = 11100011b
-11100001b ^ 00000011b = 11100010b
-11100001b ^ 00000100b = 11100101b
-11100001b ^ 00000101b = 11100100b
-11100001b ^ 00000110b = 11100111b
-11100001b ^ 00000111b = 11100110b
-11100001b ^ 00001000b = 11101001b
-11100001b ^ 00001001b = 11101000b
-11100001b ^ 00001010b = 11101011b
-11100001b ^ 00001011b = 11101010b
-11100001b ^ 00001100b = 11101101b
-11100001b ^ 00001101b = 11101100b
-11100001b ^ 00001110b = 11101111b
-11100001b ^ 00001111b = 11101110b
-11100001b ^ 00010000b = 11110001b
-11100001b ^ 00010001b = 11110000b
-11100001b ^ 00010010b = 11110011b
-11100001b ^ 00010011b = 11110010b
-11100001b ^ 00010100b = 11110101b
-11100001b ^ 00010101b = 11110100b
-11100001b ^ 00010110b = 11110111b
-11100001b ^ 00010111b = 11110110b
-11100001b ^ 00011000b = 11111001b
-11100001b ^ 00011001b = 11111000b
-11100001b ^ 00011010b = 11111011b
-11100001b ^ 00011011b = 11111010b
-11100001b ^ 00011100b = 11111101b
-11100001b ^ 00011101b = 11111100b
-11100001b ^ 00011110b = 11111111b
-11100001b ^ 00011111b = 11111110b
-11100001b ^ 00100000b = 11000001b
-11100001b ^ 00100001b = 11000000b
-11100001b ^ 00100010b = 11000011b
-11100001b ^ 00100011b = 11000010b
-11100001b ^ 00100100b = 11000101b
-11100001b ^ 00100101b = 11000100b
-11100001b ^ 00100110b = 11000111b
-11100001b ^ 00100111b = 11000110b
-11100001b ^ 00101000b = 11001001b
-11100001b ^ 00101001b = 11001000b
-11100001b ^ 00101010b = 11001011b
-11100001b ^ 00101011b = 11001010b
-11100001b ^ 00101100b = 11001101b
-11100001b ^ 00101101b = 11001100b
-11100001b ^ 00101110b = 11001111b
-11100001b ^ 00101111b = 11001110b
-11100001b ^ 00110000b = 11010001b
-11100001b ^ 00110001b = 11010000b
-11100001b ^ 00110010b = 11010011b
-11100001b ^ 00110011b = 11010010b
-11100001b ^ 00110100b = 11010101b
-11100001b ^ 00110101b = 11010100b
-11100001b ^ 00110110b = 11010111b
-11100001b ^ 00110111b = 11010110b
-11100001b ^ 00111000b = 11011001b
-11100001b ^ 00111001b = 11011000b
-11100001b ^ 00111010b = 11011011b
-11100001b ^ 00111011b = 11011010b
-11100001b ^ 00111100b = 11011101b
-11100001b ^ 00111101b = 11011100b
-11100001b ^ 00111110b = 11011111b
-11100001b ^ 00111111b = 11011110b
-11100001b ^ 01000000b = 10100001b
-11100001b ^ 01000001b = 10100000b
-11100001b ^ 01000010b = 10100011b
-11100001b ^ 01000011b = 10100010b
-11100001b ^ 01000100b = 10100101b
-11100001b ^ 01000101b = 10100100b
-11100001b ^ 01000110b = 10100111b
-11100001b ^ 01000111b = 10100110b
-11100001b ^ 01001000b = 10101001b
-11100001b ^ 01001001b = 10101000b
-11100001b ^ 01001010b = 10101011b
-11100001b ^ 01001011b = 10101010b
-11100001b ^ 01001100b = 10101101b
-11100001b ^ 01001101b = 10101100b
-11100001b ^ 01001110b = 10101111b
-11100001b ^ 01001111b = 10101110b
-11100001b ^ 01010000b = 10110001b
-11100001b ^ 01010001b = 10110000b
-11100001b ^ 01010010b = 10110011b
-11100001b ^ 01010011b = 10110010b
-11100001b ^ 01010100b = 10110101b
-11100001b ^ 01010101b = 10110100b
-11100001b ^ 01010110b = 10110111b
-11100001b ^ 01010111b = 10110110b
-11100001b ^ 01011000b = 10111001b
-11100001b ^ 01011001b = 10111000b
-11100001b ^ 01011010b = 10111011b
-11100001b ^ 01011011b = 10111010b
-11100001b ^ 01011100b = 10111101b
-11100001b ^ 01011101b = 10111100b
-11100001b ^ 01011110b = 10111111b
-11100001b ^ 01011111b = 10111110b
-11100001b ^ 01100000b = 10000001b
-11100001b ^ 01100001b = 10000000b
-11100001b ^ 01100010b = 10000011b
-11100001b ^ 01100011b = 10000010b
-11100001b ^ 01100100b = 10000101b
-11100001b ^ 01100101b = 10000100b
-11100001b ^ 01100110b = 10000111b
-11100001b ^ 01100111b = 10000110b
-11100001b ^ 01101000b = 10001001b
-11100001b ^ 01101001b = 10001000b
-11100001b ^ 01101010b = 10001011b
-11100001b ^ 01101011b = 10001010b
-11100001b ^ 01101100b = 10001101b
-11100001b ^ 01101101b = 10001100b
-11100001b ^ 01101110b = 10001111b
-11100001b ^ 01101111b = 10001110b
-11100001b ^ 01110000b = 10010001b
-11100001b ^ 01110001b = 10010000b
-11100001b ^ 01110010b = 10010011b
-11100001b ^ 01110011b = 10010010b
-11100001b ^ 01110100b = 10010101b
-11100001b ^ 01110101b = 10010100b
-11100001b ^ 01110110b = 10010111b
-11100001b ^ 01110111b = 10010110b
-11100001b ^ 01111000b = 10011001b
-11100001b ^ 01111001b = 10011000b
-11100001b ^ 01111010b = 10011011b
-11100001b ^ 01111011b = 10011010b
-11100001b ^ 01111100b = 10011101b
-11100001b ^ 01111101b = 10011100b
-11100001b ^ 01111110b = 10011111b
-11100010b ^ 10000000b = 01100010b
-11100010b ^ 10000001b = 01100011b
-11100010b ^ 10000010b = 01100000b
-11100010b ^ 10000011b = 01100001b
-11100010b ^ 10000100b = 01100110b
-11100010b ^ 10000101b = 01100111b
-11100010b ^ 10000110b = 01100100b
-11100010b ^ 10000111b = 01100101b
-11100010b ^ 10001000b = 01101010b
-11100010b ^ 10001001b = 01101011b
-11100010b ^ 10001010b = 01101000b
-11100010b ^ 10001011b = 01101001b
-11100010b ^ 10001100b = 01101110b
-11100010b ^ 10001101b = 01101111b
-11100010b ^ 10001110b = 01101100b
-11100010b ^ 10001111b = 01101101b
-11100010b ^ 10010000b = 01110010b
-11100010b ^ 10010001b = 01110011b
-11100010b ^ 10010010b = 01110000b
-11100010b ^ 10010011b = 01110001b
-11100010b ^ 10010100b = 01110110b
-11100010b ^ 10010101b = 01110111b
-11100010b ^ 10010110b = 01110100b
-11100010b ^ 10010111b = 01110101b
-11100010b ^ 10011000b = 01111010b
-11100010b ^ 10011001b = 01111011b
-11100010b ^ 10011010b = 01111000b
-11100010b ^ 10011011b = 01111001b
-11100010b ^ 10011100b = 01111110b
-11100010b ^ 10011101b = 01111111b
-11100010b ^ 10011110b = 01111100b
-11100010b ^ 10011111b = 01111101b
-11100010b ^ 10100000b = 01000010b
-11100010b ^ 10100001b = 01000011b
-11100010b ^ 10100010b = 01000000b
-11100010b ^ 10100011b = 01000001b
-11100010b ^ 10100100b = 01000110b
-11100010b ^ 10100101b = 01000111b
-11100010b ^ 10100110b = 01000100b
-11100010b ^ 10100111b = 01000101b
-11100010b ^ 10101000b = 01001010b
-11100010b ^ 10101001b = 01001011b
-11100010b ^ 10101010b = 01001000b
-11100010b ^ 10101011b = 01001001b
-11100010b ^ 10101100b = 01001110b
-11100010b ^ 10101101b = 01001111b
-11100010b ^ 10101110b = 01001100b
-11100010b ^ 10101111b = 01001101b
-11100010b ^ 10110000b = 01010010b
-11100010b ^ 10110001b = 01010011b
-11100010b ^ 10110010b = 01010000b
-11100010b ^ 10110011b = 01010001b
-11100010b ^ 10110100b = 01010110b
-11100010b ^ 10110101b = 01010111b
-11100010b ^ 10110110b = 01010100b
-11100010b ^ 10110111b = 01010101b
-11100010b ^ 10111000b = 01011010b
-11100010b ^ 10111001b = 01011011b
-11100010b ^ 10111010b = 01011000b
-11100010b ^ 10111011b = 01011001b
-11100010b ^ 10111100b = 01011110b
-11100010b ^ 10111101b = 01011111b
-11100010b ^ 10111110b = 01011100b
-11100010b ^ 10111111b = 01011101b
-11100010b ^ 11000000b = 00100010b
-11100010b ^ 11000001b = 00100011b
-11100010b ^ 11000010b = 00100000b
-11100010b ^ 11000011b = 00100001b
-11100010b ^ 11000100b = 00100110b
-11100010b ^ 11000101b = 00100111b
-11100010b ^ 11000110b = 00100100b
-11100010b ^ 11000111b = 00100101b
-11100010b ^ 11001000b = 00101010b
-11100010b ^ 11001001b = 00101011b
-11100010b ^ 11001010b = 00101000b
-11100010b ^ 11001011b = 00101001b
-11100010b ^ 11001100b = 00101110b
-11100010b ^ 11001101b = 00101111b
-11100010b ^ 11001110b = 00101100b
-11100010b ^ 11001111b = 00101101b
-11100010b ^ 11010000b = 00110010b
-11100010b ^ 11010001b = 00110011b
-11100010b ^ 11010010b = 00110000b
-11100010b ^ 11010011b = 00110001b
-11100010b ^ 11010100b = 00110110b
-11100010b ^ 11010101b = 00110111b
-11100010b ^ 11010110b = 00110100b
-11100010b ^ 11010111b = 00110101b
-11100010b ^ 11011000b = 00111010b
-11100010b ^ 11011001b = 00111011b
-11100010b ^ 11011010b = 00111000b
-11100010b ^ 11011011b = 00111001b
-11100010b ^ 11011100b = 00111110b
-11100010b ^ 11011101b = 00111111b
-11100010b ^ 11011110b = 00111100b
-11100010b ^ 11011111b = 00111101b
-11100010b ^ 11100000b = 00000010b
-11100010b ^ 11100001b = 00000011b
-11100010b ^ 11100010b = 00000000b
-11100010b ^ 11100011b = 00000001b
-11100010b ^ 11100100b = 00000110b
-11100010b ^ 11100101b = 00000111b
-11100010b ^ 11100110b = 00000100b
-11100010b ^ 11100111b = 00000101b
-11100010b ^ 11101000b = 00001010b
-11100010b ^ 11101001b = 00001011b
-11100010b ^ 11101010b = 00001000b
-11100010b ^ 11101011b = 00001001b
-11100010b ^ 11101100b = 00001110b
-11100010b ^ 11101101b = 00001111b
-11100010b ^ 11101110b = 00001100b
-11100010b ^ 11101111b = 00001101b
-11100010b ^ 11110000b = 00010010b
-11100010b ^ 11110001b = 00010011b
-11100010b ^ 11110010b = 00010000b
-11100010b ^ 11110011b = 00010001b
-11100010b ^ 11110100b = 00010110b
-11100010b ^ 11110101b = 00010111b
-11100010b ^ 11110110b = 00010100b
-11100010b ^ 11110111b = 00010101b
-11100010b ^ 11111000b = 00011010b
-11100010b ^ 11111001b = 00011011b
-11100010b ^ 11111010b = 00011000b
-11100010b ^ 11111011b = 00011001b
-11100010b ^ 11111100b = 00011110b
-11100010b ^ 11111101b = 00011111b
-11100010b ^ 11111110b = 00011100b
-11100010b ^ 11111111b = 00011101b
-11100010b ^ 00000000b = 11100010b
-11100010b ^ 00000001b = 11100011b
-11100010b ^ 00000010b = 11100000b
-11100010b ^ 00000011b = 11100001b
-11100010b ^ 00000100b = 11100110b
-11100010b ^ 00000101b = 11100111b
-11100010b ^ 00000110b = 11100100b
-11100010b ^ 00000111b = 11100101b
-11100010b ^ 00001000b = 11101010b
-11100010b ^ 00001001b = 11101011b
-11100010b ^ 00001010b = 11101000b
-11100010b ^ 00001011b = 11101001b
-11100010b ^ 00001100b = 11101110b
-11100010b ^ 00001101b = 11101111b
-11100010b ^ 00001110b = 11101100b
-11100010b ^ 00001111b = 11101101b
-11100010b ^ 00010000b = 11110010b
-11100010b ^ 00010001b = 11110011b
-11100010b ^ 00010010b = 11110000b
-11100010b ^ 00010011b = 11110001b
-11100010b ^ 00010100b = 11110110b
-11100010b ^ 00010101b = 11110111b
-11100010b ^ 00010110b = 11110100b
-11100010b ^ 00010111b = 11110101b
-11100010b ^ 00011000b = 11111010b
-11100010b ^ 00011001b = 11111011b
-11100010b ^ 00011010b = 11111000b
-11100010b ^ 00011011b = 11111001b
-11100010b ^ 00011100b = 11111110b
-11100010b ^ 00011101b = 11111111b
-11100010b ^ 00011110b = 11111100b
-11100010b ^ 00011111b = 11111101b
-11100010b ^ 00100000b = 11000010b
-11100010b ^ 00100001b = 11000011b
-11100010b ^ 00100010b = 11000000b
-11100010b ^ 00100011b = 11000001b
-11100010b ^ 00100100b = 11000110b
-11100010b ^ 00100101b = 11000111b
-11100010b ^ 00100110b = 11000100b
-11100010b ^ 00100111b = 11000101b
-11100010b ^ 00101000b = 11001010b
-11100010b ^ 00101001b = 11001011b
-11100010b ^ 00101010b = 11001000b
-11100010b ^ 00101011b = 11001001b
-11100010b ^ 00101100b = 11001110b
-11100010b ^ 00101101b = 11001111b
-11100010b ^ 00101110b = 11001100b
-11100010b ^ 00101111b = 11001101b
-11100010b ^ 00110000b = 11010010b
-11100010b ^ 00110001b = 11010011b
-11100010b ^ 00110010b = 11010000b
-11100010b ^ 00110011b = 11010001b
-11100010b ^ 00110100b = 11010110b
-11100010b ^ 00110101b = 11010111b
-11100010b ^ 00110110b = 11010100b
-11100010b ^ 00110111b = 11010101b
-11100010b ^ 00111000b = 11011010b
-11100010b ^ 00111001b = 11011011b
-11100010b ^ 00111010b = 11011000b
-11100010b ^ 00111011b = 11011001b
-11100010b ^ 00111100b = 11011110b
-11100010b ^ 00111101b = 11011111b
-11100010b ^ 00111110b = 11011100b
-11100010b ^ 00111111b = 11011101b
-11100010b ^ 01000000b = 10100010b
-11100010b ^ 01000001b = 10100011b
-11100010b ^ 01000010b = 10100000b
-11100010b ^ 01000011b = 10100001b
-11100010b ^ 01000100b = 10100110b
-11100010b ^ 01000101b = 10100111b
-11100010b ^ 01000110b = 10100100b
-11100010b ^ 01000111b = 10100101b
-11100010b ^ 01001000b = 10101010b
-11100010b ^ 01001001b = 10101011b
-11100010b ^ 01001010b = 10101000b
-11100010b ^ 01001011b = 10101001b
-11100010b ^ 01001100b = 10101110b
-11100010b ^ 01001101b = 10101111b
-11100010b ^ 01001110b = 10101100b
-11100010b ^ 01001111b = 10101101b
-11100010b ^ 01010000b = 10110010b
-11100010b ^ 01010001b = 10110011b
-11100010b ^ 01010010b = 10110000b
-11100010b ^ 01010011b = 10110001b
-11100010b ^ 01010100b = 10110110b
-11100010b ^ 01010101b = 10110111b
-11100010b ^ 01010110b = 10110100b
-11100010b ^ 01010111b = 10110101b
-11100010b ^ 01011000b = 10111010b
-11100010b ^ 01011001b = 10111011b
-11100010b ^ 01011010b = 10111000b
-11100010b ^ 01011011b = 10111001b
-11100010b ^ 01011100b = 10111110b
-11100010b ^ 01011101b = 10111111b
-11100010b ^ 01011110b = 10111100b
-11100010b ^ 01011111b = 10111101b
-11100010b ^ 01100000b = 10000010b
-11100010b ^ 01100001b = 10000011b
-11100010b ^ 01100010b = 10000000b
-11100010b ^ 01100011b = 10000001b
-11100010b ^ 01100100b = 10000110b
-11100010b ^ 01100101b = 10000111b
-11100010b ^ 01100110b = 10000100b
-11100010b ^ 01100111b = 10000101b
-11100010b ^ 01101000b = 10001010b
-11100010b ^ 01101001b = 10001011b
-11100010b ^ 01101010b = 10001000b
-11100010b ^ 01101011b = 10001001b
-11100010b ^ 01101100b = 10001110b
-11100010b ^ 01101101b = 10001111b
-11100010b ^ 01101110b = 10001100b
-11100010b ^ 01101111b = 10001101b
-11100010b ^ 01110000b = 10010010b
-11100010b ^ 01110001b = 10010011b
-11100010b ^ 01110010b = 10010000b
-11100010b ^ 01110011b = 10010001b
-11100010b ^ 01110100b = 10010110b
-11100010b ^ 01110101b = 10010111b
-11100010b ^ 01110110b = 10010100b
-11100010b ^ 01110111b = 10010101b
-11100010b ^ 01111000b = 10011010b
-11100010b ^ 01111001b = 10011011b
-11100010b ^ 01111010b = 10011000b
-11100010b ^ 01111011b = 10011001b
-11100010b ^ 01111100b = 10011110b
-11100010b ^ 01111101b = 10011111b
-11100010b ^ 01111110b = 10011100b
-11100011b ^ 10000000b = 01100011b
-11100011b ^ 10000001b = 01100010b
-11100011b ^ 10000010b = 01100001b
-11100011b ^ 10000011b = 01100000b
-11100011b ^ 10000100b = 01100111b
-11100011b ^ 10000101b = 01100110b
-11100011b ^ 10000110b = 01100101b
-11100011b ^ 10000111b = 01100100b
-11100011b ^ 10001000b = 01101011b
-11100011b ^ 10001001b = 01101010b
-11100011b ^ 10001010b = 01101001b
-11100011b ^ 10001011b = 01101000b
-11100011b ^ 10001100b = 01101111b
-11100011b ^ 10001101b = 01101110b
-11100011b ^ 10001110b = 01101101b
-11100011b ^ 10001111b = 01101100b
-11100011b ^ 10010000b = 01110011b
-11100011b ^ 10010001b = 01110010b
-11100011b ^ 10010010b = 01110001b
-11100011b ^ 10010011b = 01110000b
-11100011b ^ 10010100b = 01110111b
-11100011b ^ 10010101b = 01110110b
-11100011b ^ 10010110b = 01110101b
-11100011b ^ 10010111b = 01110100b
-11100011b ^ 10011000b = 01111011b
-11100011b ^ 10011001b = 01111010b
-11100011b ^ 10011010b = 01111001b
-11100011b ^ 10011011b = 01111000b
-11100011b ^ 10011100b = 01111111b
-11100011b ^ 10011101b = 01111110b
-11100011b ^ 10011110b = 01111101b
-11100011b ^ 10011111b = 01111100b
-11100011b ^ 10100000b = 01000011b
-11100011b ^ 10100001b = 01000010b
-11100011b ^ 10100010b = 01000001b
-11100011b ^ 10100011b = 01000000b
-11100011b ^ 10100100b = 01000111b
-11100011b ^ 10100101b = 01000110b
-11100011b ^ 10100110b = 01000101b
-11100011b ^ 10100111b = 01000100b
-11100011b ^ 10101000b = 01001011b
-11100011b ^ 10101001b = 01001010b
-11100011b ^ 10101010b = 01001001b
-11100011b ^ 10101011b = 01001000b
-11100011b ^ 10101100b = 01001111b
-11100011b ^ 10101101b = 01001110b
-11100011b ^ 10101110b = 01001101b
-11100011b ^ 10101111b = 01001100b
-11100011b ^ 10110000b = 01010011b
-11100011b ^ 10110001b = 01010010b
-11100011b ^ 10110010b = 01010001b
-11100011b ^ 10110011b = 01010000b
-11100011b ^ 10110100b = 01010111b
-11100011b ^ 10110101b = 01010110b
-11100011b ^ 10110110b = 01010101b
-11100011b ^ 10110111b = 01010100b
-11100011b ^ 10111000b = 01011011b
-11100011b ^ 10111001b = 01011010b
-11100011b ^ 10111010b = 01011001b
-11100011b ^ 10111011b = 01011000b
-11100011b ^ 10111100b = 01011111b
-11100011b ^ 10111101b = 01011110b
-11100011b ^ 10111110b = 01011101b
-11100011b ^ 10111111b = 01011100b
-11100011b ^ 11000000b = 00100011b
-11100011b ^ 11000001b = 00100010b
-11100011b ^ 11000010b = 00100001b
-11100011b ^ 11000011b = 00100000b
-11100011b ^ 11000100b = 00100111b
-11100011b ^ 11000101b = 00100110b
-11100011b ^ 11000110b = 00100101b
-11100011b ^ 11000111b = 00100100b
-11100011b ^ 11001000b = 00101011b
-11100011b ^ 11001001b = 00101010b
-11100011b ^ 11001010b = 00101001b
-11100011b ^ 11001011b = 00101000b
-11100011b ^ 11001100b = 00101111b
-11100011b ^ 11001101b = 00101110b
-11100011b ^ 11001110b = 00101101b
-11100011b ^ 11001111b = 00101100b
-11100011b ^ 11010000b = 00110011b
-11100011b ^ 11010001b = 00110010b
-11100011b ^ 11010010b = 00110001b
-11100011b ^ 11010011b = 00110000b
-11100011b ^ 11010100b = 00110111b
-11100011b ^ 11010101b = 00110110b
-11100011b ^ 11010110b = 00110101b
-11100011b ^ 11010111b = 00110100b
-11100011b ^ 11011000b = 00111011b
-11100011b ^ 11011001b = 00111010b
-11100011b ^ 11011010b = 00111001b
-11100011b ^ 11011011b = 00111000b
-11100011b ^ 11011100b = 00111111b
-11100011b ^ 11011101b = 00111110b
-11100011b ^ 11011110b = 00111101b
-11100011b ^ 11011111b = 00111100b
-11100011b ^ 11100000b = 00000011b
-11100011b ^ 11100001b = 00000010b
-11100011b ^ 11100010b = 00000001b
-11100011b ^ 11100011b = 00000000b
-11100011b ^ 11100100b = 00000111b
-11100011b ^ 11100101b = 00000110b
-11100011b ^ 11100110b = 00000101b
-11100011b ^ 11100111b = 00000100b
-11100011b ^ 11101000b = 00001011b
-11100011b ^ 11101001b = 00001010b
-11100011b ^ 11101010b = 00001001b
-11100011b ^ 11101011b = 00001000b
-11100011b ^ 11101100b = 00001111b
-11100011b ^ 11101101b = 00001110b
-11100011b ^ 11101110b = 00001101b
-11100011b ^ 11101111b = 00001100b
-11100011b ^ 11110000b = 00010011b
-11100011b ^ 11110001b = 00010010b
-11100011b ^ 11110010b = 00010001b
-11100011b ^ 11110011b = 00010000b
-11100011b ^ 11110100b = 00010111b
-11100011b ^ 11110101b = 00010110b
-11100011b ^ 11110110b = 00010101b
-11100011b ^ 11110111b = 00010100b
-11100011b ^ 11111000b = 00011011b
-11100011b ^ 11111001b = 00011010b
-11100011b ^ 11111010b = 00011001b
-11100011b ^ 11111011b = 00011000b
-11100011b ^ 11111100b = 00011111b
-11100011b ^ 11111101b = 00011110b
-11100011b ^ 11111110b = 00011101b
-11100011b ^ 11111111b = 00011100b
-11100011b ^ 00000000b = 11100011b
-11100011b ^ 00000001b = 11100010b
-11100011b ^ 00000010b = 11100001b
-11100011b ^ 00000011b = 11100000b
-11100011b ^ 00000100b = 11100111b
-11100011b ^ 00000101b = 11100110b
-11100011b ^ 00000110b = 11100101b
-11100011b ^ 00000111b = 11100100b
-11100011b ^ 00001000b = 11101011b
-11100011b ^ 00001001b = 11101010b
-11100011b ^ 00001010b = 11101001b
-11100011b ^ 00001011b = 11101000b
-11100011b ^ 00001100b = 11101111b
-11100011b ^ 00001101b = 11101110b
-11100011b ^ 00001110b = 11101101b
-11100011b ^ 00001111b = 11101100b
-11100011b ^ 00010000b = 11110011b
-11100011b ^ 00010001b = 11110010b
-11100011b ^ 00010010b = 11110001b
-11100011b ^ 00010011b = 11110000b
-11100011b ^ 00010100b = 11110111b
-11100011b ^ 00010101b = 11110110b
-11100011b ^ 00010110b = 11110101b
-11100011b ^ 00010111b = 11110100b
-11100011b ^ 00011000b = 11111011b
-11100011b ^ 00011001b = 11111010b
-11100011b ^ 00011010b = 11111001b
-11100011b ^ 00011011b = 11111000b
-11100011b ^ 00011100b = 11111111b
-11100011b ^ 00011101b = 11111110b
-11100011b ^ 00011110b = 11111101b
-11100011b ^ 00011111b = 11111100b
-11100011b ^ 00100000b = 11000011b
-11100011b ^ 00100001b = 11000010b
-11100011b ^ 00100010b = 11000001b
-11100011b ^ 00100011b = 11000000b
-11100011b ^ 00100100b = 11000111b
-11100011b ^ 00100101b = 11000110b
-11100011b ^ 00100110b = 11000101b
-11100011b ^ 00100111b = 11000100b
-11100011b ^ 00101000b = 11001011b
-11100011b ^ 00101001b = 11001010b
-11100011b ^ 00101010b = 11001001b
-11100011b ^ 00101011b = 11001000b
-11100011b ^ 00101100b = 11001111b
-11100011b ^ 00101101b = 11001110b
-11100011b ^ 00101110b = 11001101b
-11100011b ^ 00101111b = 11001100b
-11100011b ^ 00110000b = 11010011b
-11100011b ^ 00110001b = 11010010b
-11100011b ^ 00110010b = 11010001b
-11100011b ^ 00110011b = 11010000b
-11100011b ^ 00110100b = 11010111b
-11100011b ^ 00110101b = 11010110b
-11100011b ^ 00110110b = 11010101b
-11100011b ^ 00110111b = 11010100b
-11100011b ^ 00111000b = 11011011b
-11100011b ^ 00111001b = 11011010b
-11100011b ^ 00111010b = 11011001b
-11100011b ^ 00111011b = 11011000b
-11100011b ^ 00111100b = 11011111b
-11100011b ^ 00111101b = 11011110b
-11100011b ^ 00111110b = 11011101b
-11100011b ^ 00111111b = 11011100b
-11100011b ^ 01000000b = 10100011b
-11100011b ^ 01000001b = 10100010b
-11100011b ^ 01000010b = 10100001b
-11100011b ^ 01000011b = 10100000b
-11100011b ^ 01000100b = 10100111b
-11100011b ^ 01000101b = 10100110b
-11100011b ^ 01000110b = 10100101b
-11100011b ^ 01000111b = 10100100b
-11100011b ^ 01001000b = 10101011b
-11100011b ^ 01001001b = 10101010b
-11100011b ^ 01001010b = 10101001b
-11100011b ^ 01001011b = 10101000b
-11100011b ^ 01001100b = 10101111b
-11100011b ^ 01001101b = 10101110b
-11100011b ^ 01001110b = 10101101b
-11100011b ^ 01001111b = 10101100b
-11100011b ^ 01010000b = 10110011b
-11100011b ^ 01010001b = 10110010b
-11100011b ^ 01010010b = 10110001b
-11100011b ^ 01010011b = 10110000b
-11100011b ^ 01010100b = 10110111b
-11100011b ^ 01010101b = 10110110b
-11100011b ^ 01010110b = 10110101b
-11100011b ^ 01010111b = 10110100b
-11100011b ^ 01011000b = 10111011b
-11100011b ^ 01011001b = 10111010b
-11100011b ^ 01011010b = 10111001b
-11100011b ^ 01011011b = 10111000b
-11100011b ^ 01011100b = 10111111b
-11100011b ^ 01011101b = 10111110b
-11100011b ^ 01011110b = 10111101b
-11100011b ^ 01011111b = 10111100b
-11100011b ^ 01100000b = 10000011b
-11100011b ^ 01100001b = 10000010b
-11100011b ^ 01100010b = 10000001b
-11100011b ^ 01100011b = 10000000b
-11100011b ^ 01100100b = 10000111b
-11100011b ^ 01100101b = 10000110b
-11100011b ^ 01100110b = 10000101b
-11100011b ^ 01100111b = 10000100b
-11100011b ^ 01101000b = 10001011b
-11100011b ^ 01101001b = 10001010b
-11100011b ^ 01101010b = 10001001b
-11100011b ^ 01101011b = 10001000b
-11100011b ^ 01101100b = 10001111b
-11100011b ^ 01101101b = 10001110b
-11100011b ^ 01101110b = 10001101b
-11100011b ^ 01101111b = 10001100b
-11100011b ^ 01110000b = 10010011b
-11100011b ^ 01110001b = 10010010b
-11100011b ^ 01110010b = 10010001b
-11100011b ^ 01110011b = 10010000b
-11100011b ^ 01110100b = 10010111b
-11100011b ^ 01110101b = 10010110b
-11100011b ^ 01110110b = 10010101b
-11100011b ^ 01110111b = 10010100b
-11100011b ^ 01111000b = 10011011b
-11100011b ^ 01111001b = 10011010b
-11100011b ^ 01111010b = 10011001b
-11100011b ^ 01111011b = 10011000b
-11100011b ^ 01111100b = 10011111b
-11100011b ^ 01111101b = 10011110b
-11100011b ^ 01111110b = 10011101b
-11100100b ^ 10000000b = 01100100b
-11100100b ^ 10000001b = 01100101b
-11100100b ^ 10000010b = 01100110b
-11100100b ^ 10000011b = 01100111b
-11100100b ^ 10000100b = 01100000b
-11100100b ^ 10000101b = 01100001b
-11100100b ^ 10000110b = 01100010b
-11100100b ^ 10000111b = 01100011b
-11100100b ^ 10001000b = 01101100b
-11100100b ^ 10001001b = 01101101b
-11100100b ^ 10001010b = 01101110b
-11100100b ^ 10001011b = 01101111b
-11100100b ^ 10001100b = 01101000b
-11100100b ^ 10001101b = 01101001b
-11100100b ^ 10001110b = 01101010b
-11100100b ^ 10001111b = 01101011b
-11100100b ^ 10010000b = 01110100b
-11100100b ^ 10010001b = 01110101b
-11100100b ^ 10010010b = 01110110b
-11100100b ^ 10010011b = 01110111b
-11100100b ^ 10010100b = 01110000b
-11100100b ^ 10010101b = 01110001b
-11100100b ^ 10010110b = 01110010b
-11100100b ^ 10010111b = 01110011b
-11100100b ^ 10011000b = 01111100b
-11100100b ^ 10011001b = 01111101b
-11100100b ^ 10011010b = 01111110b
-11100100b ^ 10011011b = 01111111b
-11100100b ^ 10011100b = 01111000b
-11100100b ^ 10011101b = 01111001b
-11100100b ^ 10011110b = 01111010b
-11100100b ^ 10011111b = 01111011b
-11100100b ^ 10100000b = 01000100b
-11100100b ^ 10100001b = 01000101b
-11100100b ^ 10100010b = 01000110b
-11100100b ^ 10100011b = 01000111b
-11100100b ^ 10100100b = 01000000b
-11100100b ^ 10100101b = 01000001b
-11100100b ^ 10100110b = 01000010b
-11100100b ^ 10100111b = 01000011b
-11100100b ^ 10101000b = 01001100b
-11100100b ^ 10101001b = 01001101b
-11100100b ^ 10101010b = 01001110b
-11100100b ^ 10101011b = 01001111b
-11100100b ^ 10101100b = 01001000b
-11100100b ^ 10101101b = 01001001b
-11100100b ^ 10101110b = 01001010b
-11100100b ^ 10101111b = 01001011b
-11100100b ^ 10110000b = 01010100b
-11100100b ^ 10110001b = 01010101b
-11100100b ^ 10110010b = 01010110b
-11100100b ^ 10110011b = 01010111b
-11100100b ^ 10110100b = 01010000b
-11100100b ^ 10110101b = 01010001b
-11100100b ^ 10110110b = 01010010b
-11100100b ^ 10110111b = 01010011b
-11100100b ^ 10111000b = 01011100b
-11100100b ^ 10111001b = 01011101b
-11100100b ^ 10111010b = 01011110b
-11100100b ^ 10111011b = 01011111b
-11100100b ^ 10111100b = 01011000b
-11100100b ^ 10111101b = 01011001b
-11100100b ^ 10111110b = 01011010b
-11100100b ^ 10111111b = 01011011b
-11100100b ^ 11000000b = 00100100b
-11100100b ^ 11000001b = 00100101b
-11100100b ^ 11000010b = 00100110b
-11100100b ^ 11000011b = 00100111b
-11100100b ^ 11000100b = 00100000b
-11100100b ^ 11000101b = 00100001b
-11100100b ^ 11000110b = 00100010b
-11100100b ^ 11000111b = 00100011b
-11100100b ^ 11001000b = 00101100b
-11100100b ^ 11001001b = 00101101b
-11100100b ^ 11001010b = 00101110b
-11100100b ^ 11001011b = 00101111b
-11100100b ^ 11001100b = 00101000b
-11100100b ^ 11001101b = 00101001b
-11100100b ^ 11001110b = 00101010b
-11100100b ^ 11001111b = 00101011b
-11100100b ^ 11010000b = 00110100b
-11100100b ^ 11010001b = 00110101b
-11100100b ^ 11010010b = 00110110b
-11100100b ^ 11010011b = 00110111b
-11100100b ^ 11010100b = 00110000b
-11100100b ^ 11010101b = 00110001b
-11100100b ^ 11010110b = 00110010b
-11100100b ^ 11010111b = 00110011b
-11100100b ^ 11011000b = 00111100b
-11100100b ^ 11011001b = 00111101b
-11100100b ^ 11011010b = 00111110b
-11100100b ^ 11011011b = 00111111b
-11100100b ^ 11011100b = 00111000b
-11100100b ^ 11011101b = 00111001b
-11100100b ^ 11011110b = 00111010b
-11100100b ^ 11011111b = 00111011b
-11100100b ^ 11100000b = 00000100b
-11100100b ^ 11100001b = 00000101b
-11100100b ^ 11100010b = 00000110b
-11100100b ^ 11100011b = 00000111b
-11100100b ^ 11100100b = 00000000b
-11100100b ^ 11100101b = 00000001b
-11100100b ^ 11100110b = 00000010b
-11100100b ^ 11100111b = 00000011b
-11100100b ^ 11101000b = 00001100b
-11100100b ^ 11101001b = 00001101b
-11100100b ^ 11101010b = 00001110b
-11100100b ^ 11101011b = 00001111b
-11100100b ^ 11101100b = 00001000b
-11100100b ^ 11101101b = 00001001b
-11100100b ^ 11101110b = 00001010b
-11100100b ^ 11101111b = 00001011b
-11100100b ^ 11110000b = 00010100b
-11100100b ^ 11110001b = 00010101b
-11100100b ^ 11110010b = 00010110b
-11100100b ^ 11110011b = 00010111b
-11100100b ^ 11110100b = 00010000b
-11100100b ^ 11110101b = 00010001b
-11100100b ^ 11110110b = 00010010b
-11100100b ^ 11110111b = 00010011b
-11100100b ^ 11111000b = 00011100b
-11100100b ^ 11111001b = 00011101b
-11100100b ^ 11111010b = 00011110b
-11100100b ^ 11111011b = 00011111b
-11100100b ^ 11111100b = 00011000b
-11100100b ^ 11111101b = 00011001b
-11100100b ^ 11111110b = 00011010b
-11100100b ^ 11111111b = 00011011b
-11100100b ^ 00000000b = 11100100b
-11100100b ^ 00000001b = 11100101b
-11100100b ^ 00000010b = 11100110b
-11100100b ^ 00000011b = 11100111b
-11100100b ^ 00000100b = 11100000b
-11100100b ^ 00000101b = 11100001b
-11100100b ^ 00000110b = 11100010b
-11100100b ^ 00000111b = 11100011b
-11100100b ^ 00001000b = 11101100b
-11100100b ^ 00001001b = 11101101b
-11100100b ^ 00001010b = 11101110b
-11100100b ^ 00001011b = 11101111b
-11100100b ^ 00001100b = 11101000b
-11100100b ^ 00001101b = 11101001b
-11100100b ^ 00001110b = 11101010b
-11100100b ^ 00001111b = 11101011b
-11100100b ^ 00010000b = 11110100b
-11100100b ^ 00010001b = 11110101b
-11100100b ^ 00010010b = 11110110b
-11100100b ^ 00010011b = 11110111b
-11100100b ^ 00010100b = 11110000b
-11100100b ^ 00010101b = 11110001b
-11100100b ^ 00010110b = 11110010b
-11100100b ^ 00010111b = 11110011b
-11100100b ^ 00011000b = 11111100b
-11100100b ^ 00011001b = 11111101b
-11100100b ^ 00011010b = 11111110b
-11100100b ^ 00011011b = 11111111b
-11100100b ^ 00011100b = 11111000b
-11100100b ^ 00011101b = 11111001b
-11100100b ^ 00011110b = 11111010b
-11100100b ^ 00011111b = 11111011b
-11100100b ^ 00100000b = 11000100b
-11100100b ^ 00100001b = 11000101b
-11100100b ^ 00100010b = 11000110b
-11100100b ^ 00100011b = 11000111b
-11100100b ^ 00100100b = 11000000b
-11100100b ^ 00100101b = 11000001b
-11100100b ^ 00100110b = 11000010b
-11100100b ^ 00100111b = 11000011b
-11100100b ^ 00101000b = 11001100b
-11100100b ^ 00101001b = 11001101b
-11100100b ^ 00101010b = 11001110b
-11100100b ^ 00101011b = 11001111b
-11100100b ^ 00101100b = 11001000b
-11100100b ^ 00101101b = 11001001b
-11100100b ^ 00101110b = 11001010b
-11100100b ^ 00101111b = 11001011b
-11100100b ^ 00110000b = 11010100b
-11100100b ^ 00110001b = 11010101b
-11100100b ^ 00110010b = 11010110b
-11100100b ^ 00110011b = 11010111b
-11100100b ^ 00110100b = 11010000b
-11100100b ^ 00110101b = 11010001b
-11100100b ^ 00110110b = 11010010b
-11100100b ^ 00110111b = 11010011b
-11100100b ^ 00111000b = 11011100b
-11100100b ^ 00111001b = 11011101b
-11100100b ^ 00111010b = 11011110b
-11100100b ^ 00111011b = 11011111b
-11100100b ^ 00111100b = 11011000b
-11100100b ^ 00111101b = 11011001b
-11100100b ^ 00111110b = 11011010b
-11100100b ^ 00111111b = 11011011b
-11100100b ^ 01000000b = 10100100b
-11100100b ^ 01000001b = 10100101b
-11100100b ^ 01000010b = 10100110b
-11100100b ^ 01000011b = 10100111b
-11100100b ^ 01000100b = 10100000b
-11100100b ^ 01000101b = 10100001b
-11100100b ^ 01000110b = 10100010b
-11100100b ^ 01000111b = 10100011b
-11100100b ^ 01001000b = 10101100b
-11100100b ^ 01001001b = 10101101b
-11100100b ^ 01001010b = 10101110b
-11100100b ^ 01001011b = 10101111b
-11100100b ^ 01001100b = 10101000b
-11100100b ^ 01001101b = 10101001b
-11100100b ^ 01001110b = 10101010b
-11100100b ^ 01001111b = 10101011b
-11100100b ^ 01010000b = 10110100b
-11100100b ^ 01010001b = 10110101b
-11100100b ^ 01010010b = 10110110b
-11100100b ^ 01010011b = 10110111b
-11100100b ^ 01010100b = 10110000b
-11100100b ^ 01010101b = 10110001b
-11100100b ^ 01010110b = 10110010b
-11100100b ^ 01010111b = 10110011b
-11100100b ^ 01011000b = 10111100b
-11100100b ^ 01011001b = 10111101b
-11100100b ^ 01011010b = 10111110b
-11100100b ^ 01011011b = 10111111b
-11100100b ^ 01011100b = 10111000b
-11100100b ^ 01011101b = 10111001b
-11100100b ^ 01011110b = 10111010b
-11100100b ^ 01011111b = 10111011b
-11100100b ^ 01100000b = 10000100b
-11100100b ^ 01100001b = 10000101b
-11100100b ^ 01100010b = 10000110b
-11100100b ^ 01100011b = 10000111b
-11100100b ^ 01100100b = 10000000b
-11100100b ^ 01100101b = 10000001b
-11100100b ^ 01100110b = 10000010b
-11100100b ^ 01100111b = 10000011b
-11100100b ^ 01101000b = 10001100b
-11100100b ^ 01101001b = 10001101b
-11100100b ^ 01101010b = 10001110b
-11100100b ^ 01101011b = 10001111b
-11100100b ^ 01101100b = 10001000b
-11100100b ^ 01101101b = 10001001b
-11100100b ^ 01101110b = 10001010b
-11100100b ^ 01101111b = 10001011b
-11100100b ^ 01110000b = 10010100b
-11100100b ^ 01110001b = 10010101b
-11100100b ^ 01110010b = 10010110b
-11100100b ^ 01110011b = 10010111b
-11100100b ^ 01110100b = 10010000b
-11100100b ^ 01110101b = 10010001b
-11100100b ^ 01110110b = 10010010b
-11100100b ^ 01110111b = 10010011b
-11100100b ^ 01111000b = 10011100b
-11100100b ^ 01111001b = 10011101b
-11100100b ^ 01111010b = 10011110b
-11100100b ^ 01111011b = 10011111b
-11100100b ^ 01111100b = 10011000b
-11100100b ^ 01111101b = 10011001b
-11100100b ^ 01111110b = 10011010b
-11100101b ^ 10000000b = 01100101b
-11100101b ^ 10000001b = 01100100b
-11100101b ^ 10000010b = 01100111b
-11100101b ^ 10000011b = 01100110b
-11100101b ^ 10000100b = 01100001b
-11100101b ^ 10000101b = 01100000b
-11100101b ^ 10000110b = 01100011b
-11100101b ^ 10000111b = 01100010b
-11100101b ^ 10001000b = 01101101b
-11100101b ^ 10001001b = 01101100b
-11100101b ^ 10001010b = 01101111b
-11100101b ^ 10001011b = 01101110b
-11100101b ^ 10001100b = 01101001b
-11100101b ^ 10001101b = 01101000b
-11100101b ^ 10001110b = 01101011b
-11100101b ^ 10001111b = 01101010b
-11100101b ^ 10010000b = 01110101b
-11100101b ^ 10010001b = 01110100b
-11100101b ^ 10010010b = 01110111b
-11100101b ^ 10010011b = 01110110b
-11100101b ^ 10010100b = 01110001b
-11100101b ^ 10010101b = 01110000b
-11100101b ^ 10010110b = 01110011b
-11100101b ^ 10010111b = 01110010b
-11100101b ^ 10011000b = 01111101b
-11100101b ^ 10011001b = 01111100b
-11100101b ^ 10011010b = 01111111b
-11100101b ^ 10011011b = 01111110b
-11100101b ^ 10011100b = 01111001b
-11100101b ^ 10011101b = 01111000b
-11100101b ^ 10011110b = 01111011b
-11100101b ^ 10011111b = 01111010b
-11100101b ^ 10100000b = 01000101b
-11100101b ^ 10100001b = 01000100b
-11100101b ^ 10100010b = 01000111b
-11100101b ^ 10100011b = 01000110b
-11100101b ^ 10100100b = 01000001b
-11100101b ^ 10100101b = 01000000b
-11100101b ^ 10100110b = 01000011b
-11100101b ^ 10100111b = 01000010b
-11100101b ^ 10101000b = 01001101b
-11100101b ^ 10101001b = 01001100b
-11100101b ^ 10101010b = 01001111b
-11100101b ^ 10101011b = 01001110b
-11100101b ^ 10101100b = 01001001b
-11100101b ^ 10101101b = 01001000b
-11100101b ^ 10101110b = 01001011b
-11100101b ^ 10101111b = 01001010b
-11100101b ^ 10110000b = 01010101b
-11100101b ^ 10110001b = 01010100b
-11100101b ^ 10110010b = 01010111b
-11100101b ^ 10110011b = 01010110b
-11100101b ^ 10110100b = 01010001b
-11100101b ^ 10110101b = 01010000b
-11100101b ^ 10110110b = 01010011b
-11100101b ^ 10110111b = 01010010b
-11100101b ^ 10111000b = 01011101b
-11100101b ^ 10111001b = 01011100b
-11100101b ^ 10111010b = 01011111b
-11100101b ^ 10111011b = 01011110b
-11100101b ^ 10111100b = 01011001b
-11100101b ^ 10111101b = 01011000b
-11100101b ^ 10111110b = 01011011b
-11100101b ^ 10111111b = 01011010b
-11100101b ^ 11000000b = 00100101b
-11100101b ^ 11000001b = 00100100b
-11100101b ^ 11000010b = 00100111b
-11100101b ^ 11000011b = 00100110b
-11100101b ^ 11000100b = 00100001b
-11100101b ^ 11000101b = 00100000b
-11100101b ^ 11000110b = 00100011b
-11100101b ^ 11000111b = 00100010b
-11100101b ^ 11001000b = 00101101b
-11100101b ^ 11001001b = 00101100b
-11100101b ^ 11001010b = 00101111b
-11100101b ^ 11001011b = 00101110b
-11100101b ^ 11001100b = 00101001b
-11100101b ^ 11001101b = 00101000b
-11100101b ^ 11001110b = 00101011b
-11100101b ^ 11001111b = 00101010b
-11100101b ^ 11010000b = 00110101b
-11100101b ^ 11010001b = 00110100b
-11100101b ^ 11010010b = 00110111b
-11100101b ^ 11010011b = 00110110b
-11100101b ^ 11010100b = 00110001b
-11100101b ^ 11010101b = 00110000b
-11100101b ^ 11010110b = 00110011b
-11100101b ^ 11010111b = 00110010b
-11100101b ^ 11011000b = 00111101b
-11100101b ^ 11011001b = 00111100b
-11100101b ^ 11011010b = 00111111b
-11100101b ^ 11011011b = 00111110b
-11100101b ^ 11011100b = 00111001b
-11100101b ^ 11011101b = 00111000b
-11100101b ^ 11011110b = 00111011b
-11100101b ^ 11011111b = 00111010b
-11100101b ^ 11100000b = 00000101b
-11100101b ^ 11100001b = 00000100b
-11100101b ^ 11100010b = 00000111b
-11100101b ^ 11100011b = 00000110b
-11100101b ^ 11100100b = 00000001b
-11100101b ^ 11100101b = 00000000b
-11100101b ^ 11100110b = 00000011b
-11100101b ^ 11100111b = 00000010b
-11100101b ^ 11101000b = 00001101b
-11100101b ^ 11101001b = 00001100b
-11100101b ^ 11101010b = 00001111b
-11100101b ^ 11101011b = 00001110b
-11100101b ^ 11101100b = 00001001b
-11100101b ^ 11101101b = 00001000b
-11100101b ^ 11101110b = 00001011b
-11100101b ^ 11101111b = 00001010b
-11100101b ^ 11110000b = 00010101b
-11100101b ^ 11110001b = 00010100b
-11100101b ^ 11110010b = 00010111b
-11100101b ^ 11110011b = 00010110b
-11100101b ^ 11110100b = 00010001b
-11100101b ^ 11110101b = 00010000b
-11100101b ^ 11110110b = 00010011b
-11100101b ^ 11110111b = 00010010b
-11100101b ^ 11111000b = 00011101b
-11100101b ^ 11111001b = 00011100b
-11100101b ^ 11111010b = 00011111b
-11100101b ^ 11111011b = 00011110b
-11100101b ^ 11111100b = 00011001b
-11100101b ^ 11111101b = 00011000b
-11100101b ^ 11111110b = 00011011b
-11100101b ^ 11111111b = 00011010b
-11100101b ^ 00000000b = 11100101b
-11100101b ^ 00000001b = 11100100b
-11100101b ^ 00000010b = 11100111b
-11100101b ^ 00000011b = 11100110b
-11100101b ^ 00000100b = 11100001b
-11100101b ^ 00000101b = 11100000b
-11100101b ^ 00000110b = 11100011b
-11100101b ^ 00000111b = 11100010b
-11100101b ^ 00001000b = 11101101b
-11100101b ^ 00001001b = 11101100b
-11100101b ^ 00001010b = 11101111b
-11100101b ^ 00001011b = 11101110b
-11100101b ^ 00001100b = 11101001b
-11100101b ^ 00001101b = 11101000b
-11100101b ^ 00001110b = 11101011b
-11100101b ^ 00001111b = 11101010b
-11100101b ^ 00010000b = 11110101b
-11100101b ^ 00010001b = 11110100b
-11100101b ^ 00010010b = 11110111b
-11100101b ^ 00010011b = 11110110b
-11100101b ^ 00010100b = 11110001b
-11100101b ^ 00010101b = 11110000b
-11100101b ^ 00010110b = 11110011b
-11100101b ^ 00010111b = 11110010b
-11100101b ^ 00011000b = 11111101b
-11100101b ^ 00011001b = 11111100b
-11100101b ^ 00011010b = 11111111b
-11100101b ^ 00011011b = 11111110b
-11100101b ^ 00011100b = 11111001b
-11100101b ^ 00011101b = 11111000b
-11100101b ^ 00011110b = 11111011b
-11100101b ^ 00011111b = 11111010b
-11100101b ^ 00100000b = 11000101b
-11100101b ^ 00100001b = 11000100b
-11100101b ^ 00100010b = 11000111b
-11100101b ^ 00100011b = 11000110b
-11100101b ^ 00100100b = 11000001b
-11100101b ^ 00100101b = 11000000b
-11100101b ^ 00100110b = 11000011b
-11100101b ^ 00100111b = 11000010b
-11100101b ^ 00101000b = 11001101b
-11100101b ^ 00101001b = 11001100b
-11100101b ^ 00101010b = 11001111b
-11100101b ^ 00101011b = 11001110b
-11100101b ^ 00101100b = 11001001b
-11100101b ^ 00101101b = 11001000b
-11100101b ^ 00101110b = 11001011b
-11100101b ^ 00101111b = 11001010b
-11100101b ^ 00110000b = 11010101b
-11100101b ^ 00110001b = 11010100b
-11100101b ^ 00110010b = 11010111b
-11100101b ^ 00110011b = 11010110b
-11100101b ^ 00110100b = 11010001b
-11100101b ^ 00110101b = 11010000b
-11100101b ^ 00110110b = 11010011b
-11100101b ^ 00110111b = 11010010b
-11100101b ^ 00111000b = 11011101b
-11100101b ^ 00111001b = 11011100b
-11100101b ^ 00111010b = 11011111b
-11100101b ^ 00111011b = 11011110b
-11100101b ^ 00111100b = 11011001b
-11100101b ^ 00111101b = 11011000b
-11100101b ^ 00111110b = 11011011b
-11100101b ^ 00111111b = 11011010b
-11100101b ^ 01000000b = 10100101b
-11100101b ^ 01000001b = 10100100b
-11100101b ^ 01000010b = 10100111b
-11100101b ^ 01000011b = 10100110b
-11100101b ^ 01000100b = 10100001b
-11100101b ^ 01000101b = 10100000b
-11100101b ^ 01000110b = 10100011b
-11100101b ^ 01000111b = 10100010b
-11100101b ^ 01001000b = 10101101b
-11100101b ^ 01001001b = 10101100b
-11100101b ^ 01001010b = 10101111b
-11100101b ^ 01001011b = 10101110b
-11100101b ^ 01001100b = 10101001b
-11100101b ^ 01001101b = 10101000b
-11100101b ^ 01001110b = 10101011b
-11100101b ^ 01001111b = 10101010b
-11100101b ^ 01010000b = 10110101b
-11100101b ^ 01010001b = 10110100b
-11100101b ^ 01010010b = 10110111b
-11100101b ^ 01010011b = 10110110b
-11100101b ^ 01010100b = 10110001b
-11100101b ^ 01010101b = 10110000b
-11100101b ^ 01010110b = 10110011b
-11100101b ^ 01010111b = 10110010b
-11100101b ^ 01011000b = 10111101b
-11100101b ^ 01011001b = 10111100b
-11100101b ^ 01011010b = 10111111b
-11100101b ^ 01011011b = 10111110b
-11100101b ^ 01011100b = 10111001b
-11100101b ^ 01011101b = 10111000b
-11100101b ^ 01011110b = 10111011b
-11100101b ^ 01011111b = 10111010b
-11100101b ^ 01100000b = 10000101b
-11100101b ^ 01100001b = 10000100b
-11100101b ^ 01100010b = 10000111b
-11100101b ^ 01100011b = 10000110b
-11100101b ^ 01100100b = 10000001b
-11100101b ^ 01100101b = 10000000b
-11100101b ^ 01100110b = 10000011b
-11100101b ^ 01100111b = 10000010b
-11100101b ^ 01101000b = 10001101b
-11100101b ^ 01101001b = 10001100b
-11100101b ^ 01101010b = 10001111b
-11100101b ^ 01101011b = 10001110b
-11100101b ^ 01101100b = 10001001b
-11100101b ^ 01101101b = 10001000b
-11100101b ^ 01101110b = 10001011b
-11100101b ^ 01101111b = 10001010b
-11100101b ^ 01110000b = 10010101b
-11100101b ^ 01110001b = 10010100b
-11100101b ^ 01110010b = 10010111b
-11100101b ^ 01110011b = 10010110b
-11100101b ^ 01110100b = 10010001b
-11100101b ^ 01110101b = 10010000b
-11100101b ^ 01110110b = 10010011b
-11100101b ^ 01110111b = 10010010b
-11100101b ^ 01111000b = 10011101b
-11100101b ^ 01111001b = 10011100b
-11100101b ^ 01111010b = 10011111b
-11100101b ^ 01111011b = 10011110b
-11100101b ^ 01111100b = 10011001b
-11100101b ^ 01111101b = 10011000b
-11100101b ^ 01111110b = 10011011b
-11100110b ^ 10000000b = 01100110b
-11100110b ^ 10000001b = 01100111b
-11100110b ^ 10000010b = 01100100b
-11100110b ^ 10000011b = 01100101b
-11100110b ^ 10000100b = 01100010b
-11100110b ^ 10000101b = 01100011b
-11100110b ^ 10000110b = 01100000b
-11100110b ^ 10000111b = 01100001b
-11100110b ^ 10001000b = 01101110b
-11100110b ^ 10001001b = 01101111b
-11100110b ^ 10001010b = 01101100b
-11100110b ^ 10001011b = 01101101b
-11100110b ^ 10001100b = 01101010b
-11100110b ^ 10001101b = 01101011b
-11100110b ^ 10001110b = 01101000b
-11100110b ^ 10001111b = 01101001b
-11100110b ^ 10010000b = 01110110b
-11100110b ^ 10010001b = 01110111b
-11100110b ^ 10010010b = 01110100b
-11100110b ^ 10010011b = 01110101b
-11100110b ^ 10010100b = 01110010b
-11100110b ^ 10010101b = 01110011b
-11100110b ^ 10010110b = 01110000b
-11100110b ^ 10010111b = 01110001b
-11100110b ^ 10011000b = 01111110b
-11100110b ^ 10011001b = 01111111b
-11100110b ^ 10011010b = 01111100b
-11100110b ^ 10011011b = 01111101b
-11100110b ^ 10011100b = 01111010b
-11100110b ^ 10011101b = 01111011b
-11100110b ^ 10011110b = 01111000b
-11100110b ^ 10011111b = 01111001b
-11100110b ^ 10100000b = 01000110b
-11100110b ^ 10100001b = 01000111b
-11100110b ^ 10100010b = 01000100b
-11100110b ^ 10100011b = 01000101b
-11100110b ^ 10100100b = 01000010b
-11100110b ^ 10100101b = 01000011b
-11100110b ^ 10100110b = 01000000b
-11100110b ^ 10100111b = 01000001b
-11100110b ^ 10101000b = 01001110b
-11100110b ^ 10101001b = 01001111b
-11100110b ^ 10101010b = 01001100b
-11100110b ^ 10101011b = 01001101b
-11100110b ^ 10101100b = 01001010b
-11100110b ^ 10101101b = 01001011b
-11100110b ^ 10101110b = 01001000b
-11100110b ^ 10101111b = 01001001b
-11100110b ^ 10110000b = 01010110b
-11100110b ^ 10110001b = 01010111b
-11100110b ^ 10110010b = 01010100b
-11100110b ^ 10110011b = 01010101b
-11100110b ^ 10110100b = 01010010b
-11100110b ^ 10110101b = 01010011b
-11100110b ^ 10110110b = 01010000b
-11100110b ^ 10110111b = 01010001b
-11100110b ^ 10111000b = 01011110b
-11100110b ^ 10111001b = 01011111b
-11100110b ^ 10111010b = 01011100b
-11100110b ^ 10111011b = 01011101b
-11100110b ^ 10111100b = 01011010b
-11100110b ^ 10111101b = 01011011b
-11100110b ^ 10111110b = 01011000b
-11100110b ^ 10111111b = 01011001b
-11100110b ^ 11000000b = 00100110b
-11100110b ^ 11000001b = 00100111b
-11100110b ^ 11000010b = 00100100b
-11100110b ^ 11000011b = 00100101b
-11100110b ^ 11000100b = 00100010b
-11100110b ^ 11000101b = 00100011b
-11100110b ^ 11000110b = 00100000b
-11100110b ^ 11000111b = 00100001b
-11100110b ^ 11001000b = 00101110b
-11100110b ^ 11001001b = 00101111b
-11100110b ^ 11001010b = 00101100b
-11100110b ^ 11001011b = 00101101b
-11100110b ^ 11001100b = 00101010b
-11100110b ^ 11001101b = 00101011b
-11100110b ^ 11001110b = 00101000b
-11100110b ^ 11001111b = 00101001b
-11100110b ^ 11010000b = 00110110b
-11100110b ^ 11010001b = 00110111b
-11100110b ^ 11010010b = 00110100b
-11100110b ^ 11010011b = 00110101b
-11100110b ^ 11010100b = 00110010b
-11100110b ^ 11010101b = 00110011b
-11100110b ^ 11010110b = 00110000b
-11100110b ^ 11010111b = 00110001b
-11100110b ^ 11011000b = 00111110b
-11100110b ^ 11011001b = 00111111b
-11100110b ^ 11011010b = 00111100b
-11100110b ^ 11011011b = 00111101b
-11100110b ^ 11011100b = 00111010b
-11100110b ^ 11011101b = 00111011b
-11100110b ^ 11011110b = 00111000b
-11100110b ^ 11011111b = 00111001b
-11100110b ^ 11100000b = 00000110b
-11100110b ^ 11100001b = 00000111b
-11100110b ^ 11100010b = 00000100b
-11100110b ^ 11100011b = 00000101b
-11100110b ^ 11100100b = 00000010b
-11100110b ^ 11100101b = 00000011b
-11100110b ^ 11100110b = 00000000b
-11100110b ^ 11100111b = 00000001b
-11100110b ^ 11101000b = 00001110b
-11100110b ^ 11101001b = 00001111b
-11100110b ^ 11101010b = 00001100b
-11100110b ^ 11101011b = 00001101b
-11100110b ^ 11101100b = 00001010b
-11100110b ^ 11101101b = 00001011b
-11100110b ^ 11101110b = 00001000b
-11100110b ^ 11101111b = 00001001b
-11100110b ^ 11110000b = 00010110b
-11100110b ^ 11110001b = 00010111b
-11100110b ^ 11110010b = 00010100b
-11100110b ^ 11110011b = 00010101b
-11100110b ^ 11110100b = 00010010b
-11100110b ^ 11110101b = 00010011b
-11100110b ^ 11110110b = 00010000b
-11100110b ^ 11110111b = 00010001b
-11100110b ^ 11111000b = 00011110b
-11100110b ^ 11111001b = 00011111b
-11100110b ^ 11111010b = 00011100b
-11100110b ^ 11111011b = 00011101b
-11100110b ^ 11111100b = 00011010b
-11100110b ^ 11111101b = 00011011b
-11100110b ^ 11111110b = 00011000b
-11100110b ^ 11111111b = 00011001b
-11100110b ^ 00000000b = 11100110b
-11100110b ^ 00000001b = 11100111b
-11100110b ^ 00000010b = 11100100b
-11100110b ^ 00000011b = 11100101b
-11100110b ^ 00000100b = 11100010b
-11100110b ^ 00000101b = 11100011b
-11100110b ^ 00000110b = 11100000b
-11100110b ^ 00000111b = 11100001b
-11100110b ^ 00001000b = 11101110b
-11100110b ^ 00001001b = 11101111b
-11100110b ^ 00001010b = 11101100b
-11100110b ^ 00001011b = 11101101b
-11100110b ^ 00001100b = 11101010b
-11100110b ^ 00001101b = 11101011b
-11100110b ^ 00001110b = 11101000b
-11100110b ^ 00001111b = 11101001b
-11100110b ^ 00010000b = 11110110b
-11100110b ^ 00010001b = 11110111b
-11100110b ^ 00010010b = 11110100b
-11100110b ^ 00010011b = 11110101b
-11100110b ^ 00010100b = 11110010b
-11100110b ^ 00010101b = 11110011b
-11100110b ^ 00010110b = 11110000b
-11100110b ^ 00010111b = 11110001b
-11100110b ^ 00011000b = 11111110b
-11100110b ^ 00011001b = 11111111b
-11100110b ^ 00011010b = 11111100b
-11100110b ^ 00011011b = 11111101b
-11100110b ^ 00011100b = 11111010b
-11100110b ^ 00011101b = 11111011b
-11100110b ^ 00011110b = 11111000b
-11100110b ^ 00011111b = 11111001b
-11100110b ^ 00100000b = 11000110b
-11100110b ^ 00100001b = 11000111b
-11100110b ^ 00100010b = 11000100b
-11100110b ^ 00100011b = 11000101b
-11100110b ^ 00100100b = 11000010b
-11100110b ^ 00100101b = 11000011b
-11100110b ^ 00100110b = 11000000b
-11100110b ^ 00100111b = 11000001b
-11100110b ^ 00101000b = 11001110b
-11100110b ^ 00101001b = 11001111b
-11100110b ^ 00101010b = 11001100b
-11100110b ^ 00101011b = 11001101b
-11100110b ^ 00101100b = 11001010b
-11100110b ^ 00101101b = 11001011b
-11100110b ^ 00101110b = 11001000b
-11100110b ^ 00101111b = 11001001b
-11100110b ^ 00110000b = 11010110b
-11100110b ^ 00110001b = 11010111b
-11100110b ^ 00110010b = 11010100b
-11100110b ^ 00110011b = 11010101b
-11100110b ^ 00110100b = 11010010b
-11100110b ^ 00110101b = 11010011b
-11100110b ^ 00110110b = 11010000b
-11100110b ^ 00110111b = 11010001b
-11100110b ^ 00111000b = 11011110b
-11100110b ^ 00111001b = 11011111b
-11100110b ^ 00111010b = 11011100b
-11100110b ^ 00111011b = 11011101b
-11100110b ^ 00111100b = 11011010b
-11100110b ^ 00111101b = 11011011b
-11100110b ^ 00111110b = 11011000b
-11100110b ^ 00111111b = 11011001b
-11100110b ^ 01000000b = 10100110b
-11100110b ^ 01000001b = 10100111b
-11100110b ^ 01000010b = 10100100b
-11100110b ^ 01000011b = 10100101b
-11100110b ^ 01000100b = 10100010b
-11100110b ^ 01000101b = 10100011b
-11100110b ^ 01000110b = 10100000b
-11100110b ^ 01000111b = 10100001b
-11100110b ^ 01001000b = 10101110b
-11100110b ^ 01001001b = 10101111b
-11100110b ^ 01001010b = 10101100b
-11100110b ^ 01001011b = 10101101b
-11100110b ^ 01001100b = 10101010b
-11100110b ^ 01001101b = 10101011b
-11100110b ^ 01001110b = 10101000b
-11100110b ^ 01001111b = 10101001b
-11100110b ^ 01010000b = 10110110b
-11100110b ^ 01010001b = 10110111b
-11100110b ^ 01010010b = 10110100b
-11100110b ^ 01010011b = 10110101b
-11100110b ^ 01010100b = 10110010b
-11100110b ^ 01010101b = 10110011b
-11100110b ^ 01010110b = 10110000b
-11100110b ^ 01010111b = 10110001b
-11100110b ^ 01011000b = 10111110b
-11100110b ^ 01011001b = 10111111b
-11100110b ^ 01011010b = 10111100b
-11100110b ^ 01011011b = 10111101b
-11100110b ^ 01011100b = 10111010b
-11100110b ^ 01011101b = 10111011b
-11100110b ^ 01011110b = 10111000b
-11100110b ^ 01011111b = 10111001b
-11100110b ^ 01100000b = 10000110b
-11100110b ^ 01100001b = 10000111b
-11100110b ^ 01100010b = 10000100b
-11100110b ^ 01100011b = 10000101b
-11100110b ^ 01100100b = 10000010b
-11100110b ^ 01100101b = 10000011b
-11100110b ^ 01100110b = 10000000b
-11100110b ^ 01100111b = 10000001b
-11100110b ^ 01101000b = 10001110b
-11100110b ^ 01101001b = 10001111b
-11100110b ^ 01101010b = 10001100b
-11100110b ^ 01101011b = 10001101b
-11100110b ^ 01101100b = 10001010b
-11100110b ^ 01101101b = 10001011b
-11100110b ^ 01101110b = 10001000b
-11100110b ^ 01101111b = 10001001b
-11100110b ^ 01110000b = 10010110b
-11100110b ^ 01110001b = 10010111b
-11100110b ^ 01110010b = 10010100b
-11100110b ^ 01110011b = 10010101b
-11100110b ^ 01110100b = 10010010b
-11100110b ^ 01110101b = 10010011b
-11100110b ^ 01110110b = 10010000b
-11100110b ^ 01110111b = 10010001b
-11100110b ^ 01111000b = 10011110b
-11100110b ^ 01111001b = 10011111b
-11100110b ^ 01111010b = 10011100b
-11100110b ^ 01111011b = 10011101b
-11100110b ^ 01111100b = 10011010b
-11100110b ^ 01111101b = 10011011b
-11100110b ^ 01111110b = 10011000b
-11100111b ^ 10000000b = 01100111b
-11100111b ^ 10000001b = 01100110b
-11100111b ^ 10000010b = 01100101b
-11100111b ^ 10000011b = 01100100b
-11100111b ^ 10000100b = 01100011b
-11100111b ^ 10000101b = 01100010b
-11100111b ^ 10000110b = 01100001b
-11100111b ^ 10000111b = 01100000b
-11100111b ^ 10001000b = 01101111b
-11100111b ^ 10001001b = 01101110b
-11100111b ^ 10001010b = 01101101b
-11100111b ^ 10001011b = 01101100b
-11100111b ^ 10001100b = 01101011b
-11100111b ^ 10001101b = 01101010b
-11100111b ^ 10001110b = 01101001b
-11100111b ^ 10001111b = 01101000b
-11100111b ^ 10010000b = 01110111b
-11100111b ^ 10010001b = 01110110b
-11100111b ^ 10010010b = 01110101b
-11100111b ^ 10010011b = 01110100b
-11100111b ^ 10010100b = 01110011b
-11100111b ^ 10010101b = 01110010b
-11100111b ^ 10010110b = 01110001b
-11100111b ^ 10010111b = 01110000b
-11100111b ^ 10011000b = 01111111b
-11100111b ^ 10011001b = 01111110b
-11100111b ^ 10011010b = 01111101b
-11100111b ^ 10011011b = 01111100b
-11100111b ^ 10011100b = 01111011b
-11100111b ^ 10011101b = 01111010b
-11100111b ^ 10011110b = 01111001b
-11100111b ^ 10011111b = 01111000b
-11100111b ^ 10100000b = 01000111b
-11100111b ^ 10100001b = 01000110b
-11100111b ^ 10100010b = 01000101b
-11100111b ^ 10100011b = 01000100b
-11100111b ^ 10100100b = 01000011b
-11100111b ^ 10100101b = 01000010b
-11100111b ^ 10100110b = 01000001b
-11100111b ^ 10100111b = 01000000b
-11100111b ^ 10101000b = 01001111b
-11100111b ^ 10101001b = 01001110b
-11100111b ^ 10101010b = 01001101b
-11100111b ^ 10101011b = 01001100b
-11100111b ^ 10101100b = 01001011b
-11100111b ^ 10101101b = 01001010b
-11100111b ^ 10101110b = 01001001b
-11100111b ^ 10101111b = 01001000b
-11100111b ^ 10110000b = 01010111b
-11100111b ^ 10110001b = 01010110b
-11100111b ^ 10110010b = 01010101b
-11100111b ^ 10110011b = 01010100b
-11100111b ^ 10110100b = 01010011b
-11100111b ^ 10110101b = 01010010b
-11100111b ^ 10110110b = 01010001b
-11100111b ^ 10110111b = 01010000b
-11100111b ^ 10111000b = 01011111b
-11100111b ^ 10111001b = 01011110b
-11100111b ^ 10111010b = 01011101b
-11100111b ^ 10111011b = 01011100b
-11100111b ^ 10111100b = 01011011b
-11100111b ^ 10111101b = 01011010b
-11100111b ^ 10111110b = 01011001b
-11100111b ^ 10111111b = 01011000b
-11100111b ^ 11000000b = 00100111b
-11100111b ^ 11000001b = 00100110b
-11100111b ^ 11000010b = 00100101b
-11100111b ^ 11000011b = 00100100b
-11100111b ^ 11000100b = 00100011b
-11100111b ^ 11000101b = 00100010b
-11100111b ^ 11000110b = 00100001b
-11100111b ^ 11000111b = 00100000b
-11100111b ^ 11001000b = 00101111b
-11100111b ^ 11001001b = 00101110b
-11100111b ^ 11001010b = 00101101b
-11100111b ^ 11001011b = 00101100b
-11100111b ^ 11001100b = 00101011b
-11100111b ^ 11001101b = 00101010b
-11100111b ^ 11001110b = 00101001b
-11100111b ^ 11001111b = 00101000b
-11100111b ^ 11010000b = 00110111b
-11100111b ^ 11010001b = 00110110b
-11100111b ^ 11010010b = 00110101b
-11100111b ^ 11010011b = 00110100b
-11100111b ^ 11010100b = 00110011b
-11100111b ^ 11010101b = 00110010b
-11100111b ^ 11010110b = 00110001b
-11100111b ^ 11010111b = 00110000b
-11100111b ^ 11011000b = 00111111b
-11100111b ^ 11011001b = 00111110b
-11100111b ^ 11011010b = 00111101b
-11100111b ^ 11011011b = 00111100b
-11100111b ^ 11011100b = 00111011b
-11100111b ^ 11011101b = 00111010b
-11100111b ^ 11011110b = 00111001b
-11100111b ^ 11011111b = 00111000b
-11100111b ^ 11100000b = 00000111b
-11100111b ^ 11100001b = 00000110b
-11100111b ^ 11100010b = 00000101b
-11100111b ^ 11100011b = 00000100b
-11100111b ^ 11100100b = 00000011b
-11100111b ^ 11100101b = 00000010b
-11100111b ^ 11100110b = 00000001b
-11100111b ^ 11100111b = 00000000b
-11100111b ^ 11101000b = 00001111b
-11100111b ^ 11101001b = 00001110b
-11100111b ^ 11101010b = 00001101b
-11100111b ^ 11101011b = 00001100b
-11100111b ^ 11101100b = 00001011b
-11100111b ^ 11101101b = 00001010b
-11100111b ^ 11101110b = 00001001b
-11100111b ^ 11101111b = 00001000b
-11100111b ^ 11110000b = 00010111b
-11100111b ^ 11110001b = 00010110b
-11100111b ^ 11110010b = 00010101b
-11100111b ^ 11110011b = 00010100b
-11100111b ^ 11110100b = 00010011b
-11100111b ^ 11110101b = 00010010b
-11100111b ^ 11110110b = 00010001b
-11100111b ^ 11110111b = 00010000b
-11100111b ^ 11111000b = 00011111b
-11100111b ^ 11111001b = 00011110b
-11100111b ^ 11111010b = 00011101b
-11100111b ^ 11111011b = 00011100b
-11100111b ^ 11111100b = 00011011b
-11100111b ^ 11111101b = 00011010b
-11100111b ^ 11111110b = 00011001b
-11100111b ^ 11111111b = 00011000b
-11100111b ^ 00000000b = 11100111b
-11100111b ^ 00000001b = 11100110b
-11100111b ^ 00000010b = 11100101b
-11100111b ^ 00000011b = 11100100b
-11100111b ^ 00000100b = 11100011b
-11100111b ^ 00000101b = 11100010b
-11100111b ^ 00000110b = 11100001b
-11100111b ^ 00000111b = 11100000b
-11100111b ^ 00001000b = 11101111b
-11100111b ^ 00001001b = 11101110b
-11100111b ^ 00001010b = 11101101b
-11100111b ^ 00001011b = 11101100b
-11100111b ^ 00001100b = 11101011b
-11100111b ^ 00001101b = 11101010b
-11100111b ^ 00001110b = 11101001b
-11100111b ^ 00001111b = 11101000b
-11100111b ^ 00010000b = 11110111b
-11100111b ^ 00010001b = 11110110b
-11100111b ^ 00010010b = 11110101b
-11100111b ^ 00010011b = 11110100b
-11100111b ^ 00010100b = 11110011b
-11100111b ^ 00010101b = 11110010b
-11100111b ^ 00010110b = 11110001b
-11100111b ^ 00010111b = 11110000b
-11100111b ^ 00011000b = 11111111b
-11100111b ^ 00011001b = 11111110b
-11100111b ^ 00011010b = 11111101b
-11100111b ^ 00011011b = 11111100b
-11100111b ^ 00011100b = 11111011b
-11100111b ^ 00011101b = 11111010b
-11100111b ^ 00011110b = 11111001b
-11100111b ^ 00011111b = 11111000b
-11100111b ^ 00100000b = 11000111b
-11100111b ^ 00100001b = 11000110b
-11100111b ^ 00100010b = 11000101b
-11100111b ^ 00100011b = 11000100b
-11100111b ^ 00100100b = 11000011b
-11100111b ^ 00100101b = 11000010b
-11100111b ^ 00100110b = 11000001b
-11100111b ^ 00100111b = 11000000b
-11100111b ^ 00101000b = 11001111b
-11100111b ^ 00101001b = 11001110b
-11100111b ^ 00101010b = 11001101b
-11100111b ^ 00101011b = 11001100b
-11100111b ^ 00101100b = 11001011b
-11100111b ^ 00101101b = 11001010b
-11100111b ^ 00101110b = 11001001b
-11100111b ^ 00101111b = 11001000b
-11100111b ^ 00110000b = 11010111b
-11100111b ^ 00110001b = 11010110b
-11100111b ^ 00110010b = 11010101b
-11100111b ^ 00110011b = 11010100b
-11100111b ^ 00110100b = 11010011b
-11100111b ^ 00110101b = 11010010b
-11100111b ^ 00110110b = 11010001b
-11100111b ^ 00110111b = 11010000b
-11100111b ^ 00111000b = 11011111b
-11100111b ^ 00111001b = 11011110b
-11100111b ^ 00111010b = 11011101b
-11100111b ^ 00111011b = 11011100b
-11100111b ^ 00111100b = 11011011b
-11100111b ^ 00111101b = 11011010b
-11100111b ^ 00111110b = 11011001b
-11100111b ^ 00111111b = 11011000b
-11100111b ^ 01000000b = 10100111b
-11100111b ^ 01000001b = 10100110b
-11100111b ^ 01000010b = 10100101b
-11100111b ^ 01000011b = 10100100b
-11100111b ^ 01000100b = 10100011b
-11100111b ^ 01000101b = 10100010b
-11100111b ^ 01000110b = 10100001b
-11100111b ^ 01000111b = 10100000b
-11100111b ^ 01001000b = 10101111b
-11100111b ^ 01001001b = 10101110b
-11100111b ^ 01001010b = 10101101b
-11100111b ^ 01001011b = 10101100b
-11100111b ^ 01001100b = 10101011b
-11100111b ^ 01001101b = 10101010b
-11100111b ^ 01001110b = 10101001b
-11100111b ^ 01001111b = 10101000b
-11100111b ^ 01010000b = 10110111b
-11100111b ^ 01010001b = 10110110b
-11100111b ^ 01010010b = 10110101b
-11100111b ^ 01010011b = 10110100b
-11100111b ^ 01010100b = 10110011b
-11100111b ^ 01010101b = 10110010b
-11100111b ^ 01010110b = 10110001b
-11100111b ^ 01010111b = 10110000b
-11100111b ^ 01011000b = 10111111b
-11100111b ^ 01011001b = 10111110b
-11100111b ^ 01011010b = 10111101b
-11100111b ^ 01011011b = 10111100b
-11100111b ^ 01011100b = 10111011b
-11100111b ^ 01011101b = 10111010b
-11100111b ^ 01011110b = 10111001b
-11100111b ^ 01011111b = 10111000b
-11100111b ^ 01100000b = 10000111b
-11100111b ^ 01100001b = 10000110b
-11100111b ^ 01100010b = 10000101b
-11100111b ^ 01100011b = 10000100b
-11100111b ^ 01100100b = 10000011b
-11100111b ^ 01100101b = 10000010b
-11100111b ^ 01100110b = 10000001b
-11100111b ^ 01100111b = 10000000b
-11100111b ^ 01101000b = 10001111b
-11100111b ^ 01101001b = 10001110b
-11100111b ^ 01101010b = 10001101b
-11100111b ^ 01101011b = 10001100b
-11100111b ^ 01101100b = 10001011b
-11100111b ^ 01101101b = 10001010b
-11100111b ^ 01101110b = 10001001b
-11100111b ^ 01101111b = 10001000b
-11100111b ^ 01110000b = 10010111b
-11100111b ^ 01110001b = 10010110b
-11100111b ^ 01110010b = 10010101b
-11100111b ^ 01110011b = 10010100b
-11100111b ^ 01110100b = 10010011b
-11100111b ^ 01110101b = 10010010b
-11100111b ^ 01110110b = 10010001b
-11100111b ^ 01110111b = 10010000b
-11100111b ^ 01111000b = 10011111b
-11100111b ^ 01111001b = 10011110b
-11100111b ^ 01111010b = 10011101b
-11100111b ^ 01111011b = 10011100b
-11100111b ^ 01111100b = 10011011b
-11100111b ^ 01111101b = 10011010b
-11100111b ^ 01111110b = 10011001b
-11101000b ^ 10000000b = 01101000b
-11101000b ^ 10000001b = 01101001b
-11101000b ^ 10000010b = 01101010b
-11101000b ^ 10000011b = 01101011b
-11101000b ^ 10000100b = 01101100b
-11101000b ^ 10000101b = 01101101b
-11101000b ^ 10000110b = 01101110b
-11101000b ^ 10000111b = 01101111b
-11101000b ^ 10001000b = 01100000b
-11101000b ^ 10001001b = 01100001b
-11101000b ^ 10001010b = 01100010b
-11101000b ^ 10001011b = 01100011b
-11101000b ^ 10001100b = 01100100b
-11101000b ^ 10001101b = 01100101b
-11101000b ^ 10001110b = 01100110b
-11101000b ^ 10001111b = 01100111b
-11101000b ^ 10010000b = 01111000b
-11101000b ^ 10010001b = 01111001b
-11101000b ^ 10010010b = 01111010b
-11101000b ^ 10010011b = 01111011b
-11101000b ^ 10010100b = 01111100b
-11101000b ^ 10010101b = 01111101b
-11101000b ^ 10010110b = 01111110b
-11101000b ^ 10010111b = 01111111b
-11101000b ^ 10011000b = 01110000b
-11101000b ^ 10011001b = 01110001b
-11101000b ^ 10011010b = 01110010b
-11101000b ^ 10011011b = 01110011b
-11101000b ^ 10011100b = 01110100b
-11101000b ^ 10011101b = 01110101b
-11101000b ^ 10011110b = 01110110b
-11101000b ^ 10011111b = 01110111b
-11101000b ^ 10100000b = 01001000b
-11101000b ^ 10100001b = 01001001b
-11101000b ^ 10100010b = 01001010b
-11101000b ^ 10100011b = 01001011b
-11101000b ^ 10100100b = 01001100b
-11101000b ^ 10100101b = 01001101b
-11101000b ^ 10100110b = 01001110b
-11101000b ^ 10100111b = 01001111b
-11101000b ^ 10101000b = 01000000b
-11101000b ^ 10101001b = 01000001b
-11101000b ^ 10101010b = 01000010b
-11101000b ^ 10101011b = 01000011b
-11101000b ^ 10101100b = 01000100b
-11101000b ^ 10101101b = 01000101b
-11101000b ^ 10101110b = 01000110b
-11101000b ^ 10101111b = 01000111b
-11101000b ^ 10110000b = 01011000b
-11101000b ^ 10110001b = 01011001b
-11101000b ^ 10110010b = 01011010b
-11101000b ^ 10110011b = 01011011b
-11101000b ^ 10110100b = 01011100b
-11101000b ^ 10110101b = 01011101b
-11101000b ^ 10110110b = 01011110b
-11101000b ^ 10110111b = 01011111b
-11101000b ^ 10111000b = 01010000b
-11101000b ^ 10111001b = 01010001b
-11101000b ^ 10111010b = 01010010b
-11101000b ^ 10111011b = 01010011b
-11101000b ^ 10111100b = 01010100b
-11101000b ^ 10111101b = 01010101b
-11101000b ^ 10111110b = 01010110b
-11101000b ^ 10111111b = 01010111b
-11101000b ^ 11000000b = 00101000b
-11101000b ^ 11000001b = 00101001b
-11101000b ^ 11000010b = 00101010b
-11101000b ^ 11000011b = 00101011b
-11101000b ^ 11000100b = 00101100b
-11101000b ^ 11000101b = 00101101b
-11101000b ^ 11000110b = 00101110b
-11101000b ^ 11000111b = 00101111b
-11101000b ^ 11001000b = 00100000b
-11101000b ^ 11001001b = 00100001b
-11101000b ^ 11001010b = 00100010b
-11101000b ^ 11001011b = 00100011b
-11101000b ^ 11001100b = 00100100b
-11101000b ^ 11001101b = 00100101b
-11101000b ^ 11001110b = 00100110b
-11101000b ^ 11001111b = 00100111b
-11101000b ^ 11010000b = 00111000b
-11101000b ^ 11010001b = 00111001b
-11101000b ^ 11010010b = 00111010b
-11101000b ^ 11010011b = 00111011b
-11101000b ^ 11010100b = 00111100b
-11101000b ^ 11010101b = 00111101b
-11101000b ^ 11010110b = 00111110b
-11101000b ^ 11010111b = 00111111b
-11101000b ^ 11011000b = 00110000b
-11101000b ^ 11011001b = 00110001b
-11101000b ^ 11011010b = 00110010b
-11101000b ^ 11011011b = 00110011b
-11101000b ^ 11011100b = 00110100b
-11101000b ^ 11011101b = 00110101b
-11101000b ^ 11011110b = 00110110b
-11101000b ^ 11011111b = 00110111b
-11101000b ^ 11100000b = 00001000b
-11101000b ^ 11100001b = 00001001b
-11101000b ^ 11100010b = 00001010b
-11101000b ^ 11100011b = 00001011b
-11101000b ^ 11100100b = 00001100b
-11101000b ^ 11100101b = 00001101b
-11101000b ^ 11100110b = 00001110b
-11101000b ^ 11100111b = 00001111b
-11101000b ^ 11101000b = 00000000b
-11101000b ^ 11101001b = 00000001b
-11101000b ^ 11101010b = 00000010b
-11101000b ^ 11101011b = 00000011b
-11101000b ^ 11101100b = 00000100b
-11101000b ^ 11101101b = 00000101b
-11101000b ^ 11101110b = 00000110b
-11101000b ^ 11101111b = 00000111b
-11101000b ^ 11110000b = 00011000b
-11101000b ^ 11110001b = 00011001b
-11101000b ^ 11110010b = 00011010b
-11101000b ^ 11110011b = 00011011b
-11101000b ^ 11110100b = 00011100b
-11101000b ^ 11110101b = 00011101b
-11101000b ^ 11110110b = 00011110b
-11101000b ^ 11110111b = 00011111b
-11101000b ^ 11111000b = 00010000b
-11101000b ^ 11111001b = 00010001b
-11101000b ^ 11111010b = 00010010b
-11101000b ^ 11111011b = 00010011b
-11101000b ^ 11111100b = 00010100b
-11101000b ^ 11111101b = 00010101b
-11101000b ^ 11111110b = 00010110b
-11101000b ^ 11111111b = 00010111b
-11101000b ^ 00000000b = 11101000b
-11101000b ^ 00000001b = 11101001b
-11101000b ^ 00000010b = 11101010b
-11101000b ^ 00000011b = 11101011b
-11101000b ^ 00000100b = 11101100b
-11101000b ^ 00000101b = 11101101b
-11101000b ^ 00000110b = 11101110b
-11101000b ^ 00000111b = 11101111b
-11101000b ^ 00001000b = 11100000b
-11101000b ^ 00001001b = 11100001b
-11101000b ^ 00001010b = 11100010b
-11101000b ^ 00001011b = 11100011b
-11101000b ^ 00001100b = 11100100b
-11101000b ^ 00001101b = 11100101b
-11101000b ^ 00001110b = 11100110b
-11101000b ^ 00001111b = 11100111b
-11101000b ^ 00010000b = 11111000b
-11101000b ^ 00010001b = 11111001b
-11101000b ^ 00010010b = 11111010b
-11101000b ^ 00010011b = 11111011b
-11101000b ^ 00010100b = 11111100b
-11101000b ^ 00010101b = 11111101b
-11101000b ^ 00010110b = 11111110b
-11101000b ^ 00010111b = 11111111b
-11101000b ^ 00011000b = 11110000b
-11101000b ^ 00011001b = 11110001b
-11101000b ^ 00011010b = 11110010b
-11101000b ^ 00011011b = 11110011b
-11101000b ^ 00011100b = 11110100b
-11101000b ^ 00011101b = 11110101b
-11101000b ^ 00011110b = 11110110b
-11101000b ^ 00011111b = 11110111b
-11101000b ^ 00100000b = 11001000b
-11101000b ^ 00100001b = 11001001b
-11101000b ^ 00100010b = 11001010b
-11101000b ^ 00100011b = 11001011b
-11101000b ^ 00100100b = 11001100b
-11101000b ^ 00100101b = 11001101b
-11101000b ^ 00100110b = 11001110b
-11101000b ^ 00100111b = 11001111b
-11101000b ^ 00101000b = 11000000b
-11101000b ^ 00101001b = 11000001b
-11101000b ^ 00101010b = 11000010b
-11101000b ^ 00101011b = 11000011b
-11101000b ^ 00101100b = 11000100b
-11101000b ^ 00101101b = 11000101b
-11101000b ^ 00101110b = 11000110b
-11101000b ^ 00101111b = 11000111b
-11101000b ^ 00110000b = 11011000b
-11101000b ^ 00110001b = 11011001b
-11101000b ^ 00110010b = 11011010b
-11101000b ^ 00110011b = 11011011b
-11101000b ^ 00110100b = 11011100b
-11101000b ^ 00110101b = 11011101b
-11101000b ^ 00110110b = 11011110b
-11101000b ^ 00110111b = 11011111b
-11101000b ^ 00111000b = 11010000b
-11101000b ^ 00111001b = 11010001b
-11101000b ^ 00111010b = 11010010b
-11101000b ^ 00111011b = 11010011b
-11101000b ^ 00111100b = 11010100b
-11101000b ^ 00111101b = 11010101b
-11101000b ^ 00111110b = 11010110b
-11101000b ^ 00111111b = 11010111b
-11101000b ^ 01000000b = 10101000b
-11101000b ^ 01000001b = 10101001b
-11101000b ^ 01000010b = 10101010b
-11101000b ^ 01000011b = 10101011b
-11101000b ^ 01000100b = 10101100b
-11101000b ^ 01000101b = 10101101b
-11101000b ^ 01000110b = 10101110b
-11101000b ^ 01000111b = 10101111b
-11101000b ^ 01001000b = 10100000b
-11101000b ^ 01001001b = 10100001b
-11101000b ^ 01001010b = 10100010b
-11101000b ^ 01001011b = 10100011b
-11101000b ^ 01001100b = 10100100b
-11101000b ^ 01001101b = 10100101b
-11101000b ^ 01001110b = 10100110b
-11101000b ^ 01001111b = 10100111b
-11101000b ^ 01010000b = 10111000b
-11101000b ^ 01010001b = 10111001b
-11101000b ^ 01010010b = 10111010b
-11101000b ^ 01010011b = 10111011b
-11101000b ^ 01010100b = 10111100b
-11101000b ^ 01010101b = 10111101b
-11101000b ^ 01010110b = 10111110b
-11101000b ^ 01010111b = 10111111b
-11101000b ^ 01011000b = 10110000b
-11101000b ^ 01011001b = 10110001b
-11101000b ^ 01011010b = 10110010b
-11101000b ^ 01011011b = 10110011b
-11101000b ^ 01011100b = 10110100b
-11101000b ^ 01011101b = 10110101b
-11101000b ^ 01011110b = 10110110b
-11101000b ^ 01011111b = 10110111b
-11101000b ^ 01100000b = 10001000b
-11101000b ^ 01100001b = 10001001b
-11101000b ^ 01100010b = 10001010b
-11101000b ^ 01100011b = 10001011b
-11101000b ^ 01100100b = 10001100b
-11101000b ^ 01100101b = 10001101b
-11101000b ^ 01100110b = 10001110b
-11101000b ^ 01100111b = 10001111b
-11101000b ^ 01101000b = 10000000b
-11101000b ^ 01101001b = 10000001b
-11101000b ^ 01101010b = 10000010b
-11101000b ^ 01101011b = 10000011b
-11101000b ^ 01101100b = 10000100b
-11101000b ^ 01101101b = 10000101b
-11101000b ^ 01101110b = 10000110b
-11101000b ^ 01101111b = 10000111b
-11101000b ^ 01110000b = 10011000b
-11101000b ^ 01110001b = 10011001b
-11101000b ^ 01110010b = 10011010b
-11101000b ^ 01110011b = 10011011b
-11101000b ^ 01110100b = 10011100b
-11101000b ^ 01110101b = 10011101b
-11101000b ^ 01110110b = 10011110b
-11101000b ^ 01110111b = 10011111b
-11101000b ^ 01111000b = 10010000b
-11101000b ^ 01111001b = 10010001b
-11101000b ^ 01111010b = 10010010b
-11101000b ^ 01111011b = 10010011b
-11101000b ^ 01111100b = 10010100b
-11101000b ^ 01111101b = 10010101b
-11101000b ^ 01111110b = 10010110b
-11101001b ^ 10000000b = 01101001b
-11101001b ^ 10000001b = 01101000b
-11101001b ^ 10000010b = 01101011b
-11101001b ^ 10000011b = 01101010b
-11101001b ^ 10000100b = 01101101b
-11101001b ^ 10000101b = 01101100b
-11101001b ^ 10000110b = 01101111b
-11101001b ^ 10000111b = 01101110b
-11101001b ^ 10001000b = 01100001b
-11101001b ^ 10001001b = 01100000b
-11101001b ^ 10001010b = 01100011b
-11101001b ^ 10001011b = 01100010b
-11101001b ^ 10001100b = 01100101b
-11101001b ^ 10001101b = 01100100b
-11101001b ^ 10001110b = 01100111b
-11101001b ^ 10001111b = 01100110b
-11101001b ^ 10010000b = 01111001b
-11101001b ^ 10010001b = 01111000b
-11101001b ^ 10010010b = 01111011b
-11101001b ^ 10010011b = 01111010b
-11101001b ^ 10010100b = 01111101b
-11101001b ^ 10010101b = 01111100b
-11101001b ^ 10010110b = 01111111b
-11101001b ^ 10010111b = 01111110b
-11101001b ^ 10011000b = 01110001b
-11101001b ^ 10011001b = 01110000b
-11101001b ^ 10011010b = 01110011b
-11101001b ^ 10011011b = 01110010b
-11101001b ^ 10011100b = 01110101b
-11101001b ^ 10011101b = 01110100b
-11101001b ^ 10011110b = 01110111b
-11101001b ^ 10011111b = 01110110b
-11101001b ^ 10100000b = 01001001b
-11101001b ^ 10100001b = 01001000b
-11101001b ^ 10100010b = 01001011b
-11101001b ^ 10100011b = 01001010b
-11101001b ^ 10100100b = 01001101b
-11101001b ^ 10100101b = 01001100b
-11101001b ^ 10100110b = 01001111b
-11101001b ^ 10100111b = 01001110b
-11101001b ^ 10101000b = 01000001b
-11101001b ^ 10101001b = 01000000b
-11101001b ^ 10101010b = 01000011b
-11101001b ^ 10101011b = 01000010b
-11101001b ^ 10101100b = 01000101b
-11101001b ^ 10101101b = 01000100b
-11101001b ^ 10101110b = 01000111b
-11101001b ^ 10101111b = 01000110b
-11101001b ^ 10110000b = 01011001b
-11101001b ^ 10110001b = 01011000b
-11101001b ^ 10110010b = 01011011b
-11101001b ^ 10110011b = 01011010b
-11101001b ^ 10110100b = 01011101b
-11101001b ^ 10110101b = 01011100b
-11101001b ^ 10110110b = 01011111b
-11101001b ^ 10110111b = 01011110b
-11101001b ^ 10111000b = 01010001b
-11101001b ^ 10111001b = 01010000b
-11101001b ^ 10111010b = 01010011b
-11101001b ^ 10111011b = 01010010b
-11101001b ^ 10111100b = 01010101b
-11101001b ^ 10111101b = 01010100b
-11101001b ^ 10111110b = 01010111b
-11101001b ^ 10111111b = 01010110b
-11101001b ^ 11000000b = 00101001b
-11101001b ^ 11000001b = 00101000b
-11101001b ^ 11000010b = 00101011b
-11101001b ^ 11000011b = 00101010b
-11101001b ^ 11000100b = 00101101b
-11101001b ^ 11000101b = 00101100b
-11101001b ^ 11000110b = 00101111b
-11101001b ^ 11000111b = 00101110b
-11101001b ^ 11001000b = 00100001b
-11101001b ^ 11001001b = 00100000b
-11101001b ^ 11001010b = 00100011b
-11101001b ^ 11001011b = 00100010b
-11101001b ^ 11001100b = 00100101b
-11101001b ^ 11001101b = 00100100b
-11101001b ^ 11001110b = 00100111b
-11101001b ^ 11001111b = 00100110b
-11101001b ^ 11010000b = 00111001b
-11101001b ^ 11010001b = 00111000b
-11101001b ^ 11010010b = 00111011b
-11101001b ^ 11010011b = 00111010b
-11101001b ^ 11010100b = 00111101b
-11101001b ^ 11010101b = 00111100b
-11101001b ^ 11010110b = 00111111b
-11101001b ^ 11010111b = 00111110b
-11101001b ^ 11011000b = 00110001b
-11101001b ^ 11011001b = 00110000b
-11101001b ^ 11011010b = 00110011b
-11101001b ^ 11011011b = 00110010b
-11101001b ^ 11011100b = 00110101b
-11101001b ^ 11011101b = 00110100b
-11101001b ^ 11011110b = 00110111b
-11101001b ^ 11011111b = 00110110b
-11101001b ^ 11100000b = 00001001b
-11101001b ^ 11100001b = 00001000b
-11101001b ^ 11100010b = 00001011b
-11101001b ^ 11100011b = 00001010b
-11101001b ^ 11100100b = 00001101b
-11101001b ^ 11100101b = 00001100b
-11101001b ^ 11100110b = 00001111b
-11101001b ^ 11100111b = 00001110b
-11101001b ^ 11101000b = 00000001b
-11101001b ^ 11101001b = 00000000b
-11101001b ^ 11101010b = 00000011b
-11101001b ^ 11101011b = 00000010b
-11101001b ^ 11101100b = 00000101b
-11101001b ^ 11101101b = 00000100b
-11101001b ^ 11101110b = 00000111b
-11101001b ^ 11101111b = 00000110b
-11101001b ^ 11110000b = 00011001b
-11101001b ^ 11110001b = 00011000b
-11101001b ^ 11110010b = 00011011b
-11101001b ^ 11110011b = 00011010b
-11101001b ^ 11110100b = 00011101b
-11101001b ^ 11110101b = 00011100b
-11101001b ^ 11110110b = 00011111b
-11101001b ^ 11110111b = 00011110b
-11101001b ^ 11111000b = 00010001b
-11101001b ^ 11111001b = 00010000b
-11101001b ^ 11111010b = 00010011b
-11101001b ^ 11111011b = 00010010b
-11101001b ^ 11111100b = 00010101b
-11101001b ^ 11111101b = 00010100b
-11101001b ^ 11111110b = 00010111b
-11101001b ^ 11111111b = 00010110b
-11101001b ^ 00000000b = 11101001b
-11101001b ^ 00000001b = 11101000b
-11101001b ^ 00000010b = 11101011b
-11101001b ^ 00000011b = 11101010b
-11101001b ^ 00000100b = 11101101b
-11101001b ^ 00000101b = 11101100b
-11101001b ^ 00000110b = 11101111b
-11101001b ^ 00000111b = 11101110b
-11101001b ^ 00001000b = 11100001b
-11101001b ^ 00001001b = 11100000b
-11101001b ^ 00001010b = 11100011b
-11101001b ^ 00001011b = 11100010b
-11101001b ^ 00001100b = 11100101b
-11101001b ^ 00001101b = 11100100b
-11101001b ^ 00001110b = 11100111b
-11101001b ^ 00001111b = 11100110b
-11101001b ^ 00010000b = 11111001b
-11101001b ^ 00010001b = 11111000b
-11101001b ^ 00010010b = 11111011b
-11101001b ^ 00010011b = 11111010b
-11101001b ^ 00010100b = 11111101b
-11101001b ^ 00010101b = 11111100b
-11101001b ^ 00010110b = 11111111b
-11101001b ^ 00010111b = 11111110b
-11101001b ^ 00011000b = 11110001b
-11101001b ^ 00011001b = 11110000b
-11101001b ^ 00011010b = 11110011b
-11101001b ^ 00011011b = 11110010b
-11101001b ^ 00011100b = 11110101b
-11101001b ^ 00011101b = 11110100b
-11101001b ^ 00011110b = 11110111b
-11101001b ^ 00011111b = 11110110b
-11101001b ^ 00100000b = 11001001b
-11101001b ^ 00100001b = 11001000b
-11101001b ^ 00100010b = 11001011b
-11101001b ^ 00100011b = 11001010b
-11101001b ^ 00100100b = 11001101b
-11101001b ^ 00100101b = 11001100b
-11101001b ^ 00100110b = 11001111b
-11101001b ^ 00100111b = 11001110b
-11101001b ^ 00101000b = 11000001b
-11101001b ^ 00101001b = 11000000b
-11101001b ^ 00101010b = 11000011b
-11101001b ^ 00101011b = 11000010b
-11101001b ^ 00101100b = 11000101b
-11101001b ^ 00101101b = 11000100b
-11101001b ^ 00101110b = 11000111b
-11101001b ^ 00101111b = 11000110b
-11101001b ^ 00110000b = 11011001b
-11101001b ^ 00110001b = 11011000b
-11101001b ^ 00110010b = 11011011b
-11101001b ^ 00110011b = 11011010b
-11101001b ^ 00110100b = 11011101b
-11101001b ^ 00110101b = 11011100b
-11101001b ^ 00110110b = 11011111b
-11101001b ^ 00110111b = 11011110b
-11101001b ^ 00111000b = 11010001b
-11101001b ^ 00111001b = 11010000b
-11101001b ^ 00111010b = 11010011b
-11101001b ^ 00111011b = 11010010b
-11101001b ^ 00111100b = 11010101b
-11101001b ^ 00111101b = 11010100b
-11101001b ^ 00111110b = 11010111b
-11101001b ^ 00111111b = 11010110b
-11101001b ^ 01000000b = 10101001b
-11101001b ^ 01000001b = 10101000b
-11101001b ^ 01000010b = 10101011b
-11101001b ^ 01000011b = 10101010b
-11101001b ^ 01000100b = 10101101b
-11101001b ^ 01000101b = 10101100b
-11101001b ^ 01000110b = 10101111b
-11101001b ^ 01000111b = 10101110b
-11101001b ^ 01001000b = 10100001b
-11101001b ^ 01001001b = 10100000b
-11101001b ^ 01001010b = 10100011b
-11101001b ^ 01001011b = 10100010b
-11101001b ^ 01001100b = 10100101b
-11101001b ^ 01001101b = 10100100b
-11101001b ^ 01001110b = 10100111b
-11101001b ^ 01001111b = 10100110b
-11101001b ^ 01010000b = 10111001b
-11101001b ^ 01010001b = 10111000b
-11101001b ^ 01010010b = 10111011b
-11101001b ^ 01010011b = 10111010b
-11101001b ^ 01010100b = 10111101b
-11101001b ^ 01010101b = 10111100b
-11101001b ^ 01010110b = 10111111b
-11101001b ^ 01010111b = 10111110b
-11101001b ^ 01011000b = 10110001b
-11101001b ^ 01011001b = 10110000b
-11101001b ^ 01011010b = 10110011b
-11101001b ^ 01011011b = 10110010b
-11101001b ^ 01011100b = 10110101b
-11101001b ^ 01011101b = 10110100b
-11101001b ^ 01011110b = 10110111b
-11101001b ^ 01011111b = 10110110b
-11101001b ^ 01100000b = 10001001b
-11101001b ^ 01100001b = 10001000b
-11101001b ^ 01100010b = 10001011b
-11101001b ^ 01100011b = 10001010b
-11101001b ^ 01100100b = 10001101b
-11101001b ^ 01100101b = 10001100b
-11101001b ^ 01100110b = 10001111b
-11101001b ^ 01100111b = 10001110b
-11101001b ^ 01101000b = 10000001b
-11101001b ^ 01101001b = 10000000b
-11101001b ^ 01101010b = 10000011b
-11101001b ^ 01101011b = 10000010b
-11101001b ^ 01101100b = 10000101b
-11101001b ^ 01101101b = 10000100b
-11101001b ^ 01101110b = 10000111b
-11101001b ^ 01101111b = 10000110b
-11101001b ^ 01110000b = 10011001b
-11101001b ^ 01110001b = 10011000b
-11101001b ^ 01110010b = 10011011b
-11101001b ^ 01110011b = 10011010b
-11101001b ^ 01110100b = 10011101b
-11101001b ^ 01110101b = 10011100b
-11101001b ^ 01110110b = 10011111b
-11101001b ^ 01110111b = 10011110b
-11101001b ^ 01111000b = 10010001b
-11101001b ^ 01111001b = 10010000b
-11101001b ^ 01111010b = 10010011b
-11101001b ^ 01111011b = 10010010b
-11101001b ^ 01111100b = 10010101b
-11101001b ^ 01111101b = 10010100b
-11101001b ^ 01111110b = 10010111b
-11101010b ^ 10000000b = 01101010b
-11101010b ^ 10000001b = 01101011b
-11101010b ^ 10000010b = 01101000b
-11101010b ^ 10000011b = 01101001b
-11101010b ^ 10000100b = 01101110b
-11101010b ^ 10000101b = 01101111b
-11101010b ^ 10000110b = 01101100b
-11101010b ^ 10000111b = 01101101b
-11101010b ^ 10001000b = 01100010b
-11101010b ^ 10001001b = 01100011b
-11101010b ^ 10001010b = 01100000b
-11101010b ^ 10001011b = 01100001b
-11101010b ^ 10001100b = 01100110b
-11101010b ^ 10001101b = 01100111b
-11101010b ^ 10001110b = 01100100b
-11101010b ^ 10001111b = 01100101b
-11101010b ^ 10010000b = 01111010b
-11101010b ^ 10010001b = 01111011b
-11101010b ^ 10010010b = 01111000b
-11101010b ^ 10010011b = 01111001b
-11101010b ^ 10010100b = 01111110b
-11101010b ^ 10010101b = 01111111b
-11101010b ^ 10010110b = 01111100b
-11101010b ^ 10010111b = 01111101b
-11101010b ^ 10011000b = 01110010b
-11101010b ^ 10011001b = 01110011b
-11101010b ^ 10011010b = 01110000b
-11101010b ^ 10011011b = 01110001b
-11101010b ^ 10011100b = 01110110b
-11101010b ^ 10011101b = 01110111b
-11101010b ^ 10011110b = 01110100b
-11101010b ^ 10011111b = 01110101b
-11101010b ^ 10100000b = 01001010b
-11101010b ^ 10100001b = 01001011b
-11101010b ^ 10100010b = 01001000b
-11101010b ^ 10100011b = 01001001b
-11101010b ^ 10100100b = 01001110b
-11101010b ^ 10100101b = 01001111b
-11101010b ^ 10100110b = 01001100b
-11101010b ^ 10100111b = 01001101b
-11101010b ^ 10101000b = 01000010b
-11101010b ^ 10101001b = 01000011b
-11101010b ^ 10101010b = 01000000b
-11101010b ^ 10101011b = 01000001b
-11101010b ^ 10101100b = 01000110b
-11101010b ^ 10101101b = 01000111b
-11101010b ^ 10101110b = 01000100b
-11101010b ^ 10101111b = 01000101b
-11101010b ^ 10110000b = 01011010b
-11101010b ^ 10110001b = 01011011b
-11101010b ^ 10110010b = 01011000b
-11101010b ^ 10110011b = 01011001b
-11101010b ^ 10110100b = 01011110b
-11101010b ^ 10110101b = 01011111b
-11101010b ^ 10110110b = 01011100b
-11101010b ^ 10110111b = 01011101b
-11101010b ^ 10111000b = 01010010b
-11101010b ^ 10111001b = 01010011b
-11101010b ^ 10111010b = 01010000b
-11101010b ^ 10111011b = 01010001b
-11101010b ^ 10111100b = 01010110b
-11101010b ^ 10111101b = 01010111b
-11101010b ^ 10111110b = 01010100b
-11101010b ^ 10111111b = 01010101b
-11101010b ^ 11000000b = 00101010b
-11101010b ^ 11000001b = 00101011b
-11101010b ^ 11000010b = 00101000b
-11101010b ^ 11000011b = 00101001b
-11101010b ^ 11000100b = 00101110b
-11101010b ^ 11000101b = 00101111b
-11101010b ^ 11000110b = 00101100b
-11101010b ^ 11000111b = 00101101b
-11101010b ^ 11001000b = 00100010b
-11101010b ^ 11001001b = 00100011b
-11101010b ^ 11001010b = 00100000b
-11101010b ^ 11001011b = 00100001b
-11101010b ^ 11001100b = 00100110b
-11101010b ^ 11001101b = 00100111b
-11101010b ^ 11001110b = 00100100b
-11101010b ^ 11001111b = 00100101b
-11101010b ^ 11010000b = 00111010b
-11101010b ^ 11010001b = 00111011b
-11101010b ^ 11010010b = 00111000b
-11101010b ^ 11010011b = 00111001b
-11101010b ^ 11010100b = 00111110b
-11101010b ^ 11010101b = 00111111b
-11101010b ^ 11010110b = 00111100b
-11101010b ^ 11010111b = 00111101b
-11101010b ^ 11011000b = 00110010b
-11101010b ^ 11011001b = 00110011b
-11101010b ^ 11011010b = 00110000b
-11101010b ^ 11011011b = 00110001b
-11101010b ^ 11011100b = 00110110b
-11101010b ^ 11011101b = 00110111b
-11101010b ^ 11011110b = 00110100b
-11101010b ^ 11011111b = 00110101b
-11101010b ^ 11100000b = 00001010b
-11101010b ^ 11100001b = 00001011b
-11101010b ^ 11100010b = 00001000b
-11101010b ^ 11100011b = 00001001b
-11101010b ^ 11100100b = 00001110b
-11101010b ^ 11100101b = 00001111b
-11101010b ^ 11100110b = 00001100b
-11101010b ^ 11100111b = 00001101b
-11101010b ^ 11101000b = 00000010b
-11101010b ^ 11101001b = 00000011b
-11101010b ^ 11101010b = 00000000b
-11101010b ^ 11101011b = 00000001b
-11101010b ^ 11101100b = 00000110b
-11101010b ^ 11101101b = 00000111b
-11101010b ^ 11101110b = 00000100b
-11101010b ^ 11101111b = 00000101b
-11101010b ^ 11110000b = 00011010b
-11101010b ^ 11110001b = 00011011b
-11101010b ^ 11110010b = 00011000b
-11101010b ^ 11110011b = 00011001b
-11101010b ^ 11110100b = 00011110b
-11101010b ^ 11110101b = 00011111b
-11101010b ^ 11110110b = 00011100b
-11101010b ^ 11110111b = 00011101b
-11101010b ^ 11111000b = 00010010b
-11101010b ^ 11111001b = 00010011b
-11101010b ^ 11111010b = 00010000b
-11101010b ^ 11111011b = 00010001b
-11101010b ^ 11111100b = 00010110b
-11101010b ^ 11111101b = 00010111b
-11101010b ^ 11111110b = 00010100b
-11101010b ^ 11111111b = 00010101b
-11101010b ^ 00000000b = 11101010b
-11101010b ^ 00000001b = 11101011b
-11101010b ^ 00000010b = 11101000b
-11101010b ^ 00000011b = 11101001b
-11101010b ^ 00000100b = 11101110b
-11101010b ^ 00000101b = 11101111b
-11101010b ^ 00000110b = 11101100b
-11101010b ^ 00000111b = 11101101b
-11101010b ^ 00001000b = 11100010b
-11101010b ^ 00001001b = 11100011b
-11101010b ^ 00001010b = 11100000b
-11101010b ^ 00001011b = 11100001b
-11101010b ^ 00001100b = 11100110b
-11101010b ^ 00001101b = 11100111b
-11101010b ^ 00001110b = 11100100b
-11101010b ^ 00001111b = 11100101b
-11101010b ^ 00010000b = 11111010b
-11101010b ^ 00010001b = 11111011b
-11101010b ^ 00010010b = 11111000b
-11101010b ^ 00010011b = 11111001b
-11101010b ^ 00010100b = 11111110b
-11101010b ^ 00010101b = 11111111b
-11101010b ^ 00010110b = 11111100b
-11101010b ^ 00010111b = 11111101b
-11101010b ^ 00011000b = 11110010b
-11101010b ^ 00011001b = 11110011b
-11101010b ^ 00011010b = 11110000b
-11101010b ^ 00011011b = 11110001b
-11101010b ^ 00011100b = 11110110b
-11101010b ^ 00011101b = 11110111b
-11101010b ^ 00011110b = 11110100b
-11101010b ^ 00011111b = 11110101b
-11101010b ^ 00100000b = 11001010b
-11101010b ^ 00100001b = 11001011b
-11101010b ^ 00100010b = 11001000b
-11101010b ^ 00100011b = 11001001b
-11101010b ^ 00100100b = 11001110b
-11101010b ^ 00100101b = 11001111b
-11101010b ^ 00100110b = 11001100b
-11101010b ^ 00100111b = 11001101b
-11101010b ^ 00101000b = 11000010b
-11101010b ^ 00101001b = 11000011b
-11101010b ^ 00101010b = 11000000b
-11101010b ^ 00101011b = 11000001b
-11101010b ^ 00101100b = 11000110b
-11101010b ^ 00101101b = 11000111b
-11101010b ^ 00101110b = 11000100b
-11101010b ^ 00101111b = 11000101b
-11101010b ^ 00110000b = 11011010b
-11101010b ^ 00110001b = 11011011b
-11101010b ^ 00110010b = 11011000b
-11101010b ^ 00110011b = 11011001b
-11101010b ^ 00110100b = 11011110b
-11101010b ^ 00110101b = 11011111b
-11101010b ^ 00110110b = 11011100b
-11101010b ^ 00110111b = 11011101b
-11101010b ^ 00111000b = 11010010b
-11101010b ^ 00111001b = 11010011b
-11101010b ^ 00111010b = 11010000b
-11101010b ^ 00111011b = 11010001b
-11101010b ^ 00111100b = 11010110b
-11101010b ^ 00111101b = 11010111b
-11101010b ^ 00111110b = 11010100b
-11101010b ^ 00111111b = 11010101b
-11101010b ^ 01000000b = 10101010b
-11101010b ^ 01000001b = 10101011b
-11101010b ^ 01000010b = 10101000b
-11101010b ^ 01000011b = 10101001b
-11101010b ^ 01000100b = 10101110b
-11101010b ^ 01000101b = 10101111b
-11101010b ^ 01000110b = 10101100b
-11101010b ^ 01000111b = 10101101b
-11101010b ^ 01001000b = 10100010b
-11101010b ^ 01001001b = 10100011b
-11101010b ^ 01001010b = 10100000b
-11101010b ^ 01001011b = 10100001b
-11101010b ^ 01001100b = 10100110b
-11101010b ^ 01001101b = 10100111b
-11101010b ^ 01001110b = 10100100b
-11101010b ^ 01001111b = 10100101b
-11101010b ^ 01010000b = 10111010b
-11101010b ^ 01010001b = 10111011b
-11101010b ^ 01010010b = 10111000b
-11101010b ^ 01010011b = 10111001b
-11101010b ^ 01010100b = 10111110b
-11101010b ^ 01010101b = 10111111b
-11101010b ^ 01010110b = 10111100b
-11101010b ^ 01010111b = 10111101b
-11101010b ^ 01011000b = 10110010b
-11101010b ^ 01011001b = 10110011b
-11101010b ^ 01011010b = 10110000b
-11101010b ^ 01011011b = 10110001b
-11101010b ^ 01011100b = 10110110b
-11101010b ^ 01011101b = 10110111b
-11101010b ^ 01011110b = 10110100b
-11101010b ^ 01011111b = 10110101b
-11101010b ^ 01100000b = 10001010b
-11101010b ^ 01100001b = 10001011b
-11101010b ^ 01100010b = 10001000b
-11101010b ^ 01100011b = 10001001b
-11101010b ^ 01100100b = 10001110b
-11101010b ^ 01100101b = 10001111b
-11101010b ^ 01100110b = 10001100b
-11101010b ^ 01100111b = 10001101b
-11101010b ^ 01101000b = 10000010b
-11101010b ^ 01101001b = 10000011b
-11101010b ^ 01101010b = 10000000b
-11101010b ^ 01101011b = 10000001b
-11101010b ^ 01101100b = 10000110b
-11101010b ^ 01101101b = 10000111b
-11101010b ^ 01101110b = 10000100b
-11101010b ^ 01101111b = 10000101b
-11101010b ^ 01110000b = 10011010b
-11101010b ^ 01110001b = 10011011b
-11101010b ^ 01110010b = 10011000b
-11101010b ^ 01110011b = 10011001b
-11101010b ^ 01110100b = 10011110b
-11101010b ^ 01110101b = 10011111b
-11101010b ^ 01110110b = 10011100b
-11101010b ^ 01110111b = 10011101b
-11101010b ^ 01111000b = 10010010b
-11101010b ^ 01111001b = 10010011b
-11101010b ^ 01111010b = 10010000b
-11101010b ^ 01111011b = 10010001b
-11101010b ^ 01111100b = 10010110b
-11101010b ^ 01111101b = 10010111b
-11101010b ^ 01111110b = 10010100b
-11101011b ^ 10000000b = 01101011b
-11101011b ^ 10000001b = 01101010b
-11101011b ^ 10000010b = 01101001b
-11101011b ^ 10000011b = 01101000b
-11101011b ^ 10000100b = 01101111b
-11101011b ^ 10000101b = 01101110b
-11101011b ^ 10000110b = 01101101b
-11101011b ^ 10000111b = 01101100b
-11101011b ^ 10001000b = 01100011b
-11101011b ^ 10001001b = 01100010b
-11101011b ^ 10001010b = 01100001b
-11101011b ^ 10001011b = 01100000b
-11101011b ^ 10001100b = 01100111b
-11101011b ^ 10001101b = 01100110b
-11101011b ^ 10001110b = 01100101b
-11101011b ^ 10001111b = 01100100b
-11101011b ^ 10010000b = 01111011b
-11101011b ^ 10010001b = 01111010b
-11101011b ^ 10010010b = 01111001b
-11101011b ^ 10010011b = 01111000b
-11101011b ^ 10010100b = 01111111b
-11101011b ^ 10010101b = 01111110b
-11101011b ^ 10010110b = 01111101b
-11101011b ^ 10010111b = 01111100b
-11101011b ^ 10011000b = 01110011b
-11101011b ^ 10011001b = 01110010b
-11101011b ^ 10011010b = 01110001b
-11101011b ^ 10011011b = 01110000b
-11101011b ^ 10011100b = 01110111b
-11101011b ^ 10011101b = 01110110b
-11101011b ^ 10011110b = 01110101b
-11101011b ^ 10011111b = 01110100b
-11101011b ^ 10100000b = 01001011b
-11101011b ^ 10100001b = 01001010b
-11101011b ^ 10100010b = 01001001b
-11101011b ^ 10100011b = 01001000b
-11101011b ^ 10100100b = 01001111b
-11101011b ^ 10100101b = 01001110b
-11101011b ^ 10100110b = 01001101b
-11101011b ^ 10100111b = 01001100b
-11101011b ^ 10101000b = 01000011b
-11101011b ^ 10101001b = 01000010b
-11101011b ^ 10101010b = 01000001b
-11101011b ^ 10101011b = 01000000b
-11101011b ^ 10101100b = 01000111b
-11101011b ^ 10101101b = 01000110b
-11101011b ^ 10101110b = 01000101b
-11101011b ^ 10101111b = 01000100b
-11101011b ^ 10110000b = 01011011b
-11101011b ^ 10110001b = 01011010b
-11101011b ^ 10110010b = 01011001b
-11101011b ^ 10110011b = 01011000b
-11101011b ^ 10110100b = 01011111b
-11101011b ^ 10110101b = 01011110b
-11101011b ^ 10110110b = 01011101b
-11101011b ^ 10110111b = 01011100b
-11101011b ^ 10111000b = 01010011b
-11101011b ^ 10111001b = 01010010b
-11101011b ^ 10111010b = 01010001b
-11101011b ^ 10111011b = 01010000b
-11101011b ^ 10111100b = 01010111b
-11101011b ^ 10111101b = 01010110b
-11101011b ^ 10111110b = 01010101b
-11101011b ^ 10111111b = 01010100b
-11101011b ^ 11000000b = 00101011b
-11101011b ^ 11000001b = 00101010b
-11101011b ^ 11000010b = 00101001b
-11101011b ^ 11000011b = 00101000b
-11101011b ^ 11000100b = 00101111b
-11101011b ^ 11000101b = 00101110b
-11101011b ^ 11000110b = 00101101b
-11101011b ^ 11000111b = 00101100b
-11101011b ^ 11001000b = 00100011b
-11101011b ^ 11001001b = 00100010b
-11101011b ^ 11001010b = 00100001b
-11101011b ^ 11001011b = 00100000b
-11101011b ^ 11001100b = 00100111b
-11101011b ^ 11001101b = 00100110b
-11101011b ^ 11001110b = 00100101b
-11101011b ^ 11001111b = 00100100b
-11101011b ^ 11010000b = 00111011b
-11101011b ^ 11010001b = 00111010b
-11101011b ^ 11010010b = 00111001b
-11101011b ^ 11010011b = 00111000b
-11101011b ^ 11010100b = 00111111b
-11101011b ^ 11010101b = 00111110b
-11101011b ^ 11010110b = 00111101b
-11101011b ^ 11010111b = 00111100b
-11101011b ^ 11011000b = 00110011b
-11101011b ^ 11011001b = 00110010b
-11101011b ^ 11011010b = 00110001b
-11101011b ^ 11011011b = 00110000b
-11101011b ^ 11011100b = 00110111b
-11101011b ^ 11011101b = 00110110b
-11101011b ^ 11011110b = 00110101b
-11101011b ^ 11011111b = 00110100b
-11101011b ^ 11100000b = 00001011b
-11101011b ^ 11100001b = 00001010b
-11101011b ^ 11100010b = 00001001b
-11101011b ^ 11100011b = 00001000b
-11101011b ^ 11100100b = 00001111b
-11101011b ^ 11100101b = 00001110b
-11101011b ^ 11100110b = 00001101b
-11101011b ^ 11100111b = 00001100b
-11101011b ^ 11101000b = 00000011b
-11101011b ^ 11101001b = 00000010b
-11101011b ^ 11101010b = 00000001b
-11101011b ^ 11101011b = 00000000b
-11101011b ^ 11101100b = 00000111b
-11101011b ^ 11101101b = 00000110b
-11101011b ^ 11101110b = 00000101b
-11101011b ^ 11101111b = 00000100b
-11101011b ^ 11110000b = 00011011b
-11101011b ^ 11110001b = 00011010b
-11101011b ^ 11110010b = 00011001b
-11101011b ^ 11110011b = 00011000b
-11101011b ^ 11110100b = 00011111b
-11101011b ^ 11110101b = 00011110b
-11101011b ^ 11110110b = 00011101b
-11101011b ^ 11110111b = 00011100b
-11101011b ^ 11111000b = 00010011b
-11101011b ^ 11111001b = 00010010b
-11101011b ^ 11111010b = 00010001b
-11101011b ^ 11111011b = 00010000b
-11101011b ^ 11111100b = 00010111b
-11101011b ^ 11111101b = 00010110b
-11101011b ^ 11111110b = 00010101b
-11101011b ^ 11111111b = 00010100b
-11101011b ^ 00000000b = 11101011b
-11101011b ^ 00000001b = 11101010b
-11101011b ^ 00000010b = 11101001b
-11101011b ^ 00000011b = 11101000b
-11101011b ^ 00000100b = 11101111b
-11101011b ^ 00000101b = 11101110b
-11101011b ^ 00000110b = 11101101b
-11101011b ^ 00000111b = 11101100b
-11101011b ^ 00001000b = 11100011b
-11101011b ^ 00001001b = 11100010b
-11101011b ^ 00001010b = 11100001b
-11101011b ^ 00001011b = 11100000b
-11101011b ^ 00001100b = 11100111b
-11101011b ^ 00001101b = 11100110b
-11101011b ^ 00001110b = 11100101b
-11101011b ^ 00001111b = 11100100b
-11101011b ^ 00010000b = 11111011b
-11101011b ^ 00010001b = 11111010b
-11101011b ^ 00010010b = 11111001b
-11101011b ^ 00010011b = 11111000b
-11101011b ^ 00010100b = 11111111b
-11101011b ^ 00010101b = 11111110b
-11101011b ^ 00010110b = 11111101b
-11101011b ^ 00010111b = 11111100b
-11101011b ^ 00011000b = 11110011b
-11101011b ^ 00011001b = 11110010b
-11101011b ^ 00011010b = 11110001b
-11101011b ^ 00011011b = 11110000b
-11101011b ^ 00011100b = 11110111b
-11101011b ^ 00011101b = 11110110b
-11101011b ^ 00011110b = 11110101b
-11101011b ^ 00011111b = 11110100b
-11101011b ^ 00100000b = 11001011b
-11101011b ^ 00100001b = 11001010b
-11101011b ^ 00100010b = 11001001b
-11101011b ^ 00100011b = 11001000b
-11101011b ^ 00100100b = 11001111b
-11101011b ^ 00100101b = 11001110b
-11101011b ^ 00100110b = 11001101b
-11101011b ^ 00100111b = 11001100b
-11101011b ^ 00101000b = 11000011b
-11101011b ^ 00101001b = 11000010b
-11101011b ^ 00101010b = 11000001b
-11101011b ^ 00101011b = 11000000b
-11101011b ^ 00101100b = 11000111b
-11101011b ^ 00101101b = 11000110b
-11101011b ^ 00101110b = 11000101b
-11101011b ^ 00101111b = 11000100b
-11101011b ^ 00110000b = 11011011b
-11101011b ^ 00110001b = 11011010b
-11101011b ^ 00110010b = 11011001b
-11101011b ^ 00110011b = 11011000b
-11101011b ^ 00110100b = 11011111b
-11101011b ^ 00110101b = 11011110b
-11101011b ^ 00110110b = 11011101b
-11101011b ^ 00110111b = 11011100b
-11101011b ^ 00111000b = 11010011b
-11101011b ^ 00111001b = 11010010b
-11101011b ^ 00111010b = 11010001b
-11101011b ^ 00111011b = 11010000b
-11101011b ^ 00111100b = 11010111b
-11101011b ^ 00111101b = 11010110b
-11101011b ^ 00111110b = 11010101b
-11101011b ^ 00111111b = 11010100b
-11101011b ^ 01000000b = 10101011b
-11101011b ^ 01000001b = 10101010b
-11101011b ^ 01000010b = 10101001b
-11101011b ^ 01000011b = 10101000b
-11101011b ^ 01000100b = 10101111b
-11101011b ^ 01000101b = 10101110b
-11101011b ^ 01000110b = 10101101b
-11101011b ^ 01000111b = 10101100b
-11101011b ^ 01001000b = 10100011b
-11101011b ^ 01001001b = 10100010b
-11101011b ^ 01001010b = 10100001b
-11101011b ^ 01001011b = 10100000b
-11101011b ^ 01001100b = 10100111b
-11101011b ^ 01001101b = 10100110b
-11101011b ^ 01001110b = 10100101b
-11101011b ^ 01001111b = 10100100b
-11101011b ^ 01010000b = 10111011b
-11101011b ^ 01010001b = 10111010b
-11101011b ^ 01010010b = 10111001b
-11101011b ^ 01010011b = 10111000b
-11101011b ^ 01010100b = 10111111b
-11101011b ^ 01010101b = 10111110b
-11101011b ^ 01010110b = 10111101b
-11101011b ^ 01010111b = 10111100b
-11101011b ^ 01011000b = 10110011b
-11101011b ^ 01011001b = 10110010b
-11101011b ^ 01011010b = 10110001b
-11101011b ^ 01011011b = 10110000b
-11101011b ^ 01011100b = 10110111b
-11101011b ^ 01011101b = 10110110b
-11101011b ^ 01011110b = 10110101b
-11101011b ^ 01011111b = 10110100b
-11101011b ^ 01100000b = 10001011b
-11101011b ^ 01100001b = 10001010b
-11101011b ^ 01100010b = 10001001b
-11101011b ^ 01100011b = 10001000b
-11101011b ^ 01100100b = 10001111b
-11101011b ^ 01100101b = 10001110b
-11101011b ^ 01100110b = 10001101b
-11101011b ^ 01100111b = 10001100b
-11101011b ^ 01101000b = 10000011b
-11101011b ^ 01101001b = 10000010b
-11101011b ^ 01101010b = 10000001b
-11101011b ^ 01101011b = 10000000b
-11101011b ^ 01101100b = 10000111b
-11101011b ^ 01101101b = 10000110b
-11101011b ^ 01101110b = 10000101b
-11101011b ^ 01101111b = 10000100b
-11101011b ^ 01110000b = 10011011b
-11101011b ^ 01110001b = 10011010b
-11101011b ^ 01110010b = 10011001b
-11101011b ^ 01110011b = 10011000b
-11101011b ^ 01110100b = 10011111b
-11101011b ^ 01110101b = 10011110b
-11101011b ^ 01110110b = 10011101b
-11101011b ^ 01110111b = 10011100b
-11101011b ^ 01111000b = 10010011b
-11101011b ^ 01111001b = 10010010b
-11101011b ^ 01111010b = 10010001b
-11101011b ^ 01111011b = 10010000b
-11101011b ^ 01111100b = 10010111b
-11101011b ^ 01111101b = 10010110b
-11101011b ^ 01111110b = 10010101b
-11101100b ^ 10000000b = 01101100b
-11101100b ^ 10000001b = 01101101b
-11101100b ^ 10000010b = 01101110b
-11101100b ^ 10000011b = 01101111b
-11101100b ^ 10000100b = 01101000b
-11101100b ^ 10000101b = 01101001b
-11101100b ^ 10000110b = 01101010b
-11101100b ^ 10000111b = 01101011b
-11101100b ^ 10001000b = 01100100b
-11101100b ^ 10001001b = 01100101b
-11101100b ^ 10001010b = 01100110b
-11101100b ^ 10001011b = 01100111b
-11101100b ^ 10001100b = 01100000b
-11101100b ^ 10001101b = 01100001b
-11101100b ^ 10001110b = 01100010b
-11101100b ^ 10001111b = 01100011b
-11101100b ^ 10010000b = 01111100b
-11101100b ^ 10010001b = 01111101b
-11101100b ^ 10010010b = 01111110b
-11101100b ^ 10010011b = 01111111b
-11101100b ^ 10010100b = 01111000b
-11101100b ^ 10010101b = 01111001b
-11101100b ^ 10010110b = 01111010b
-11101100b ^ 10010111b = 01111011b
-11101100b ^ 10011000b = 01110100b
-11101100b ^ 10011001b = 01110101b
-11101100b ^ 10011010b = 01110110b
-11101100b ^ 10011011b = 01110111b
-11101100b ^ 10011100b = 01110000b
-11101100b ^ 10011101b = 01110001b
-11101100b ^ 10011110b = 01110010b
-11101100b ^ 10011111b = 01110011b
-11101100b ^ 10100000b = 01001100b
-11101100b ^ 10100001b = 01001101b
-11101100b ^ 10100010b = 01001110b
-11101100b ^ 10100011b = 01001111b
-11101100b ^ 10100100b = 01001000b
-11101100b ^ 10100101b = 01001001b
-11101100b ^ 10100110b = 01001010b
-11101100b ^ 10100111b = 01001011b
-11101100b ^ 10101000b = 01000100b
-11101100b ^ 10101001b = 01000101b
-11101100b ^ 10101010b = 01000110b
-11101100b ^ 10101011b = 01000111b
-11101100b ^ 10101100b = 01000000b
-11101100b ^ 10101101b = 01000001b
-11101100b ^ 10101110b = 01000010b
-11101100b ^ 10101111b = 01000011b
-11101100b ^ 10110000b = 01011100b
-11101100b ^ 10110001b = 01011101b
-11101100b ^ 10110010b = 01011110b
-11101100b ^ 10110011b = 01011111b
-11101100b ^ 10110100b = 01011000b
-11101100b ^ 10110101b = 01011001b
-11101100b ^ 10110110b = 01011010b
-11101100b ^ 10110111b = 01011011b
-11101100b ^ 10111000b = 01010100b
-11101100b ^ 10111001b = 01010101b
-11101100b ^ 10111010b = 01010110b
-11101100b ^ 10111011b = 01010111b
-11101100b ^ 10111100b = 01010000b
-11101100b ^ 10111101b = 01010001b
-11101100b ^ 10111110b = 01010010b
-11101100b ^ 10111111b = 01010011b
-11101100b ^ 11000000b = 00101100b
-11101100b ^ 11000001b = 00101101b
-11101100b ^ 11000010b = 00101110b
-11101100b ^ 11000011b = 00101111b
-11101100b ^ 11000100b = 00101000b
-11101100b ^ 11000101b = 00101001b
-11101100b ^ 11000110b = 00101010b
-11101100b ^ 11000111b = 00101011b
-11101100b ^ 11001000b = 00100100b
-11101100b ^ 11001001b = 00100101b
-11101100b ^ 11001010b = 00100110b
-11101100b ^ 11001011b = 00100111b
-11101100b ^ 11001100b = 00100000b
-11101100b ^ 11001101b = 00100001b
-11101100b ^ 11001110b = 00100010b
-11101100b ^ 11001111b = 00100011b
-11101100b ^ 11010000b = 00111100b
-11101100b ^ 11010001b = 00111101b
-11101100b ^ 11010010b = 00111110b
-11101100b ^ 11010011b = 00111111b
-11101100b ^ 11010100b = 00111000b
-11101100b ^ 11010101b = 00111001b
-11101100b ^ 11010110b = 00111010b
-11101100b ^ 11010111b = 00111011b
-11101100b ^ 11011000b = 00110100b
-11101100b ^ 11011001b = 00110101b
-11101100b ^ 11011010b = 00110110b
-11101100b ^ 11011011b = 00110111b
-11101100b ^ 11011100b = 00110000b
-11101100b ^ 11011101b = 00110001b
-11101100b ^ 11011110b = 00110010b
-11101100b ^ 11011111b = 00110011b
-11101100b ^ 11100000b = 00001100b
-11101100b ^ 11100001b = 00001101b
-11101100b ^ 11100010b = 00001110b
-11101100b ^ 11100011b = 00001111b
-11101100b ^ 11100100b = 00001000b
-11101100b ^ 11100101b = 00001001b
-11101100b ^ 11100110b = 00001010b
-11101100b ^ 11100111b = 00001011b
-11101100b ^ 11101000b = 00000100b
-11101100b ^ 11101001b = 00000101b
-11101100b ^ 11101010b = 00000110b
-11101100b ^ 11101011b = 00000111b
-11101100b ^ 11101100b = 00000000b
-11101100b ^ 11101101b = 00000001b
-11101100b ^ 11101110b = 00000010b
-11101100b ^ 11101111b = 00000011b
-11101100b ^ 11110000b = 00011100b
-11101100b ^ 11110001b = 00011101b
-11101100b ^ 11110010b = 00011110b
-11101100b ^ 11110011b = 00011111b
-11101100b ^ 11110100b = 00011000b
-11101100b ^ 11110101b = 00011001b
-11101100b ^ 11110110b = 00011010b
-11101100b ^ 11110111b = 00011011b
-11101100b ^ 11111000b = 00010100b
-11101100b ^ 11111001b = 00010101b
-11101100b ^ 11111010b = 00010110b
-11101100b ^ 11111011b = 00010111b
-11101100b ^ 11111100b = 00010000b
-11101100b ^ 11111101b = 00010001b
-11101100b ^ 11111110b = 00010010b
-11101100b ^ 11111111b = 00010011b
-11101100b ^ 00000000b = 11101100b
-11101100b ^ 00000001b = 11101101b
-11101100b ^ 00000010b = 11101110b
-11101100b ^ 00000011b = 11101111b
-11101100b ^ 00000100b = 11101000b
-11101100b ^ 00000101b = 11101001b
-11101100b ^ 00000110b = 11101010b
-11101100b ^ 00000111b = 11101011b
-11101100b ^ 00001000b = 11100100b
-11101100b ^ 00001001b = 11100101b
-11101100b ^ 00001010b = 11100110b
-11101100b ^ 00001011b = 11100111b
-11101100b ^ 00001100b = 11100000b
-11101100b ^ 00001101b = 11100001b
-11101100b ^ 00001110b = 11100010b
-11101100b ^ 00001111b = 11100011b
-11101100b ^ 00010000b = 11111100b
-11101100b ^ 00010001b = 11111101b
-11101100b ^ 00010010b = 11111110b
-11101100b ^ 00010011b = 11111111b
-11101100b ^ 00010100b = 11111000b
-11101100b ^ 00010101b = 11111001b
-11101100b ^ 00010110b = 11111010b
-11101100b ^ 00010111b = 11111011b
-11101100b ^ 00011000b = 11110100b
-11101100b ^ 00011001b = 11110101b
-11101100b ^ 00011010b = 11110110b
-11101100b ^ 00011011b = 11110111b
-11101100b ^ 00011100b = 11110000b
-11101100b ^ 00011101b = 11110001b
-11101100b ^ 00011110b = 11110010b
-11101100b ^ 00011111b = 11110011b
-11101100b ^ 00100000b = 11001100b
-11101100b ^ 00100001b = 11001101b
-11101100b ^ 00100010b = 11001110b
-11101100b ^ 00100011b = 11001111b
-11101100b ^ 00100100b = 11001000b
-11101100b ^ 00100101b = 11001001b
-11101100b ^ 00100110b = 11001010b
-11101100b ^ 00100111b = 11001011b
-11101100b ^ 00101000b = 11000100b
-11101100b ^ 00101001b = 11000101b
-11101100b ^ 00101010b = 11000110b
-11101100b ^ 00101011b = 11000111b
-11101100b ^ 00101100b = 11000000b
-11101100b ^ 00101101b = 11000001b
-11101100b ^ 00101110b = 11000010b
-11101100b ^ 00101111b = 11000011b
-11101100b ^ 00110000b = 11011100b
-11101100b ^ 00110001b = 11011101b
-11101100b ^ 00110010b = 11011110b
-11101100b ^ 00110011b = 11011111b
-11101100b ^ 00110100b = 11011000b
-11101100b ^ 00110101b = 11011001b
-11101100b ^ 00110110b = 11011010b
-11101100b ^ 00110111b = 11011011b
-11101100b ^ 00111000b = 11010100b
-11101100b ^ 00111001b = 11010101b
-11101100b ^ 00111010b = 11010110b
-11101100b ^ 00111011b = 11010111b
-11101100b ^ 00111100b = 11010000b
-11101100b ^ 00111101b = 11010001b
-11101100b ^ 00111110b = 11010010b
-11101100b ^ 00111111b = 11010011b
-11101100b ^ 01000000b = 10101100b
-11101100b ^ 01000001b = 10101101b
-11101100b ^ 01000010b = 10101110b
-11101100b ^ 01000011b = 10101111b
-11101100b ^ 01000100b = 10101000b
-11101100b ^ 01000101b = 10101001b
-11101100b ^ 01000110b = 10101010b
-11101100b ^ 01000111b = 10101011b
-11101100b ^ 01001000b = 10100100b
-11101100b ^ 01001001b = 10100101b
-11101100b ^ 01001010b = 10100110b
-11101100b ^ 01001011b = 10100111b
-11101100b ^ 01001100b = 10100000b
-11101100b ^ 01001101b = 10100001b
-11101100b ^ 01001110b = 10100010b
-11101100b ^ 01001111b = 10100011b
-11101100b ^ 01010000b = 10111100b
-11101100b ^ 01010001b = 10111101b
-11101100b ^ 01010010b = 10111110b
-11101100b ^ 01010011b = 10111111b
-11101100b ^ 01010100b = 10111000b
-11101100b ^ 01010101b = 10111001b
-11101100b ^ 01010110b = 10111010b
-11101100b ^ 01010111b = 10111011b
-11101100b ^ 01011000b = 10110100b
-11101100b ^ 01011001b = 10110101b
-11101100b ^ 01011010b = 10110110b
-11101100b ^ 01011011b = 10110111b
-11101100b ^ 01011100b = 10110000b
-11101100b ^ 01011101b = 10110001b
-11101100b ^ 01011110b = 10110010b
-11101100b ^ 01011111b = 10110011b
-11101100b ^ 01100000b = 10001100b
-11101100b ^ 01100001b = 10001101b
-11101100b ^ 01100010b = 10001110b
-11101100b ^ 01100011b = 10001111b
-11101100b ^ 01100100b = 10001000b
-11101100b ^ 01100101b = 10001001b
-11101100b ^ 01100110b = 10001010b
-11101100b ^ 01100111b = 10001011b
-11101100b ^ 01101000b = 10000100b
-11101100b ^ 01101001b = 10000101b
-11101100b ^ 01101010b = 10000110b
-11101100b ^ 01101011b = 10000111b
-11101100b ^ 01101100b = 10000000b
-11101100b ^ 01101101b = 10000001b
-11101100b ^ 01101110b = 10000010b
-11101100b ^ 01101111b = 10000011b
-11101100b ^ 01110000b = 10011100b
-11101100b ^ 01110001b = 10011101b
-11101100b ^ 01110010b = 10011110b
-11101100b ^ 01110011b = 10011111b
-11101100b ^ 01110100b = 10011000b
-11101100b ^ 01110101b = 10011001b
-11101100b ^ 01110110b = 10011010b
-11101100b ^ 01110111b = 10011011b
-11101100b ^ 01111000b = 10010100b
-11101100b ^ 01111001b = 10010101b
-11101100b ^ 01111010b = 10010110b
-11101100b ^ 01111011b = 10010111b
-11101100b ^ 01111100b = 10010000b
-11101100b ^ 01111101b = 10010001b
-11101100b ^ 01111110b = 10010010b
-11101101b ^ 10000000b = 01101101b
-11101101b ^ 10000001b = 01101100b
-11101101b ^ 10000010b = 01101111b
-11101101b ^ 10000011b = 01101110b
-11101101b ^ 10000100b = 01101001b
-11101101b ^ 10000101b = 01101000b
-11101101b ^ 10000110b = 01101011b
-11101101b ^ 10000111b = 01101010b
-11101101b ^ 10001000b = 01100101b
-11101101b ^ 10001001b = 01100100b
-11101101b ^ 10001010b = 01100111b
-11101101b ^ 10001011b = 01100110b
-11101101b ^ 10001100b = 01100001b
-11101101b ^ 10001101b = 01100000b
-11101101b ^ 10001110b = 01100011b
-11101101b ^ 10001111b = 01100010b
-11101101b ^ 10010000b = 01111101b
-11101101b ^ 10010001b = 01111100b
-11101101b ^ 10010010b = 01111111b
-11101101b ^ 10010011b = 01111110b
-11101101b ^ 10010100b = 01111001b
-11101101b ^ 10010101b = 01111000b
-11101101b ^ 10010110b = 01111011b
-11101101b ^ 10010111b = 01111010b
-11101101b ^ 10011000b = 01110101b
-11101101b ^ 10011001b = 01110100b
-11101101b ^ 10011010b = 01110111b
-11101101b ^ 10011011b = 01110110b
-11101101b ^ 10011100b = 01110001b
-11101101b ^ 10011101b = 01110000b
-11101101b ^ 10011110b = 01110011b
-11101101b ^ 10011111b = 01110010b
-11101101b ^ 10100000b = 01001101b
-11101101b ^ 10100001b = 01001100b
-11101101b ^ 10100010b = 01001111b
-11101101b ^ 10100011b = 01001110b
-11101101b ^ 10100100b = 01001001b
-11101101b ^ 10100101b = 01001000b
-11101101b ^ 10100110b = 01001011b
-11101101b ^ 10100111b = 01001010b
-11101101b ^ 10101000b = 01000101b
-11101101b ^ 10101001b = 01000100b
-11101101b ^ 10101010b = 01000111b
-11101101b ^ 10101011b = 01000110b
-11101101b ^ 10101100b = 01000001b
-11101101b ^ 10101101b = 01000000b
-11101101b ^ 10101110b = 01000011b
-11101101b ^ 10101111b = 01000010b
-11101101b ^ 10110000b = 01011101b
-11101101b ^ 10110001b = 01011100b
-11101101b ^ 10110010b = 01011111b
-11101101b ^ 10110011b = 01011110b
-11101101b ^ 10110100b = 01011001b
-11101101b ^ 10110101b = 01011000b
-11101101b ^ 10110110b = 01011011b
-11101101b ^ 10110111b = 01011010b
-11101101b ^ 10111000b = 01010101b
-11101101b ^ 10111001b = 01010100b
-11101101b ^ 10111010b = 01010111b
-11101101b ^ 10111011b = 01010110b
-11101101b ^ 10111100b = 01010001b
-11101101b ^ 10111101b = 01010000b
-11101101b ^ 10111110b = 01010011b
-11101101b ^ 10111111b = 01010010b
-11101101b ^ 11000000b = 00101101b
-11101101b ^ 11000001b = 00101100b
-11101101b ^ 11000010b = 00101111b
-11101101b ^ 11000011b = 00101110b
-11101101b ^ 11000100b = 00101001b
-11101101b ^ 11000101b = 00101000b
-11101101b ^ 11000110b = 00101011b
-11101101b ^ 11000111b = 00101010b
-11101101b ^ 11001000b = 00100101b
-11101101b ^ 11001001b = 00100100b
-11101101b ^ 11001010b = 00100111b
-11101101b ^ 11001011b = 00100110b
-11101101b ^ 11001100b = 00100001b
-11101101b ^ 11001101b = 00100000b
-11101101b ^ 11001110b = 00100011b
-11101101b ^ 11001111b = 00100010b
-11101101b ^ 11010000b = 00111101b
-11101101b ^ 11010001b = 00111100b
-11101101b ^ 11010010b = 00111111b
-11101101b ^ 11010011b = 00111110b
-11101101b ^ 11010100b = 00111001b
-11101101b ^ 11010101b = 00111000b
-11101101b ^ 11010110b = 00111011b
-11101101b ^ 11010111b = 00111010b
-11101101b ^ 11011000b = 00110101b
-11101101b ^ 11011001b = 00110100b
-11101101b ^ 11011010b = 00110111b
-11101101b ^ 11011011b = 00110110b
-11101101b ^ 11011100b = 00110001b
-11101101b ^ 11011101b = 00110000b
-11101101b ^ 11011110b = 00110011b
-11101101b ^ 11011111b = 00110010b
-11101101b ^ 11100000b = 00001101b
-11101101b ^ 11100001b = 00001100b
-11101101b ^ 11100010b = 00001111b
-11101101b ^ 11100011b = 00001110b
-11101101b ^ 11100100b = 00001001b
-11101101b ^ 11100101b = 00001000b
-11101101b ^ 11100110b = 00001011b
-11101101b ^ 11100111b = 00001010b
-11101101b ^ 11101000b = 00000101b
-11101101b ^ 11101001b = 00000100b
-11101101b ^ 11101010b = 00000111b
-11101101b ^ 11101011b = 00000110b
-11101101b ^ 11101100b = 00000001b
-11101101b ^ 11101101b = 00000000b
-11101101b ^ 11101110b = 00000011b
-11101101b ^ 11101111b = 00000010b
-11101101b ^ 11110000b = 00011101b
-11101101b ^ 11110001b = 00011100b
-11101101b ^ 11110010b = 00011111b
-11101101b ^ 11110011b = 00011110b
-11101101b ^ 11110100b = 00011001b
-11101101b ^ 11110101b = 00011000b
-11101101b ^ 11110110b = 00011011b
-11101101b ^ 11110111b = 00011010b
-11101101b ^ 11111000b = 00010101b
-11101101b ^ 11111001b = 00010100b
-11101101b ^ 11111010b = 00010111b
-11101101b ^ 11111011b = 00010110b
-11101101b ^ 11111100b = 00010001b
-11101101b ^ 11111101b = 00010000b
-11101101b ^ 11111110b = 00010011b
-11101101b ^ 11111111b = 00010010b
-11101101b ^ 00000000b = 11101101b
-11101101b ^ 00000001b = 11101100b
-11101101b ^ 00000010b = 11101111b
-11101101b ^ 00000011b = 11101110b
-11101101b ^ 00000100b = 11101001b
-11101101b ^ 00000101b = 11101000b
-11101101b ^ 00000110b = 11101011b
-11101101b ^ 00000111b = 11101010b
-11101101b ^ 00001000b = 11100101b
-11101101b ^ 00001001b = 11100100b
-11101101b ^ 00001010b = 11100111b
-11101101b ^ 00001011b = 11100110b
-11101101b ^ 00001100b = 11100001b
-11101101b ^ 00001101b = 11100000b
-11101101b ^ 00001110b = 11100011b
-11101101b ^ 00001111b = 11100010b
-11101101b ^ 00010000b = 11111101b
-11101101b ^ 00010001b = 11111100b
-11101101b ^ 00010010b = 11111111b
-11101101b ^ 00010011b = 11111110b
-11101101b ^ 00010100b = 11111001b
-11101101b ^ 00010101b = 11111000b
-11101101b ^ 00010110b = 11111011b
-11101101b ^ 00010111b = 11111010b
-11101101b ^ 00011000b = 11110101b
-11101101b ^ 00011001b = 11110100b
-11101101b ^ 00011010b = 11110111b
-11101101b ^ 00011011b = 11110110b
-11101101b ^ 00011100b = 11110001b
-11101101b ^ 00011101b = 11110000b
-11101101b ^ 00011110b = 11110011b
-11101101b ^ 00011111b = 11110010b
-11101101b ^ 00100000b = 11001101b
-11101101b ^ 00100001b = 11001100b
-11101101b ^ 00100010b = 11001111b
-11101101b ^ 00100011b = 11001110b
-11101101b ^ 00100100b = 11001001b
-11101101b ^ 00100101b = 11001000b
-11101101b ^ 00100110b = 11001011b
-11101101b ^ 00100111b = 11001010b
-11101101b ^ 00101000b = 11000101b
-11101101b ^ 00101001b = 11000100b
-11101101b ^ 00101010b = 11000111b
-11101101b ^ 00101011b = 11000110b
-11101101b ^ 00101100b = 11000001b
-11101101b ^ 00101101b = 11000000b
-11101101b ^ 00101110b = 11000011b
-11101101b ^ 00101111b = 11000010b
-11101101b ^ 00110000b = 11011101b
-11101101b ^ 00110001b = 11011100b
-11101101b ^ 00110010b = 11011111b
-11101101b ^ 00110011b = 11011110b
-11101101b ^ 00110100b = 11011001b
-11101101b ^ 00110101b = 11011000b
-11101101b ^ 00110110b = 11011011b
-11101101b ^ 00110111b = 11011010b
-11101101b ^ 00111000b = 11010101b
-11101101b ^ 00111001b = 11010100b
-11101101b ^ 00111010b = 11010111b
-11101101b ^ 00111011b = 11010110b
-11101101b ^ 00111100b = 11010001b
-11101101b ^ 00111101b = 11010000b
-11101101b ^ 00111110b = 11010011b
-11101101b ^ 00111111b = 11010010b
-11101101b ^ 01000000b = 10101101b
-11101101b ^ 01000001b = 10101100b
-11101101b ^ 01000010b = 10101111b
-11101101b ^ 01000011b = 10101110b
-11101101b ^ 01000100b = 10101001b
-11101101b ^ 01000101b = 10101000b
-11101101b ^ 01000110b = 10101011b
-11101101b ^ 01000111b = 10101010b
-11101101b ^ 01001000b = 10100101b
-11101101b ^ 01001001b = 10100100b
-11101101b ^ 01001010b = 10100111b
-11101101b ^ 01001011b = 10100110b
-11101101b ^ 01001100b = 10100001b
-11101101b ^ 01001101b = 10100000b
-11101101b ^ 01001110b = 10100011b
-11101101b ^ 01001111b = 10100010b
-11101101b ^ 01010000b = 10111101b
-11101101b ^ 01010001b = 10111100b
-11101101b ^ 01010010b = 10111111b
-11101101b ^ 01010011b = 10111110b
-11101101b ^ 01010100b = 10111001b
-11101101b ^ 01010101b = 10111000b
-11101101b ^ 01010110b = 10111011b
-11101101b ^ 01010111b = 10111010b
-11101101b ^ 01011000b = 10110101b
-11101101b ^ 01011001b = 10110100b
-11101101b ^ 01011010b = 10110111b
-11101101b ^ 01011011b = 10110110b
-11101101b ^ 01011100b = 10110001b
-11101101b ^ 01011101b = 10110000b
-11101101b ^ 01011110b = 10110011b
-11101101b ^ 01011111b = 10110010b
-11101101b ^ 01100000b = 10001101b
-11101101b ^ 01100001b = 10001100b
-11101101b ^ 01100010b = 10001111b
-11101101b ^ 01100011b = 10001110b
-11101101b ^ 01100100b = 10001001b
-11101101b ^ 01100101b = 10001000b
-11101101b ^ 01100110b = 10001011b
-11101101b ^ 01100111b = 10001010b
-11101101b ^ 01101000b = 10000101b
-11101101b ^ 01101001b = 10000100b
-11101101b ^ 01101010b = 10000111b
-11101101b ^ 01101011b = 10000110b
-11101101b ^ 01101100b = 10000001b
-11101101b ^ 01101101b = 10000000b
-11101101b ^ 01101110b = 10000011b
-11101101b ^ 01101111b = 10000010b
-11101101b ^ 01110000b = 10011101b
-11101101b ^ 01110001b = 10011100b
-11101101b ^ 01110010b = 10011111b
-11101101b ^ 01110011b = 10011110b
-11101101b ^ 01110100b = 10011001b
-11101101b ^ 01110101b = 10011000b
-11101101b ^ 01110110b = 10011011b
-11101101b ^ 01110111b = 10011010b
-11101101b ^ 01111000b = 10010101b
-11101101b ^ 01111001b = 10010100b
-11101101b ^ 01111010b = 10010111b
-11101101b ^ 01111011b = 10010110b
-11101101b ^ 01111100b = 10010001b
-11101101b ^ 01111101b = 10010000b
-11101101b ^ 01111110b = 10010011b
-11101110b ^ 10000000b = 01101110b
-11101110b ^ 10000001b = 01101111b
-11101110b ^ 10000010b = 01101100b
-11101110b ^ 10000011b = 01101101b
-11101110b ^ 10000100b = 01101010b
-11101110b ^ 10000101b = 01101011b
-11101110b ^ 10000110b = 01101000b
-11101110b ^ 10000111b = 01101001b
-11101110b ^ 10001000b = 01100110b
-11101110b ^ 10001001b = 01100111b
-11101110b ^ 10001010b = 01100100b
-11101110b ^ 10001011b = 01100101b
-11101110b ^ 10001100b = 01100010b
-11101110b ^ 10001101b = 01100011b
-11101110b ^ 10001110b = 01100000b
-11101110b ^ 10001111b = 01100001b
-11101110b ^ 10010000b = 01111110b
-11101110b ^ 10010001b = 01111111b
-11101110b ^ 10010010b = 01111100b
-11101110b ^ 10010011b = 01111101b
-11101110b ^ 10010100b = 01111010b
-11101110b ^ 10010101b = 01111011b
-11101110b ^ 10010110b = 01111000b
-11101110b ^ 10010111b = 01111001b
-11101110b ^ 10011000b = 01110110b
-11101110b ^ 10011001b = 01110111b
-11101110b ^ 10011010b = 01110100b
-11101110b ^ 10011011b = 01110101b
-11101110b ^ 10011100b = 01110010b
-11101110b ^ 10011101b = 01110011b
-11101110b ^ 10011110b = 01110000b
-11101110b ^ 10011111b = 01110001b
-11101110b ^ 10100000b = 01001110b
-11101110b ^ 10100001b = 01001111b
-11101110b ^ 10100010b = 01001100b
-11101110b ^ 10100011b = 01001101b
-11101110b ^ 10100100b = 01001010b
-11101110b ^ 10100101b = 01001011b
-11101110b ^ 10100110b = 01001000b
-11101110b ^ 10100111b = 01001001b
-11101110b ^ 10101000b = 01000110b
-11101110b ^ 10101001b = 01000111b
-11101110b ^ 10101010b = 01000100b
-11101110b ^ 10101011b = 01000101b
-11101110b ^ 10101100b = 01000010b
-11101110b ^ 10101101b = 01000011b
-11101110b ^ 10101110b = 01000000b
-11101110b ^ 10101111b = 01000001b
-11101110b ^ 10110000b = 01011110b
-11101110b ^ 10110001b = 01011111b
-11101110b ^ 10110010b = 01011100b
-11101110b ^ 10110011b = 01011101b
-11101110b ^ 10110100b = 01011010b
-11101110b ^ 10110101b = 01011011b
-11101110b ^ 10110110b = 01011000b
-11101110b ^ 10110111b = 01011001b
-11101110b ^ 10111000b = 01010110b
-11101110b ^ 10111001b = 01010111b
-11101110b ^ 10111010b = 01010100b
-11101110b ^ 10111011b = 01010101b
-11101110b ^ 10111100b = 01010010b
-11101110b ^ 10111101b = 01010011b
-11101110b ^ 10111110b = 01010000b
-11101110b ^ 10111111b = 01010001b
-11101110b ^ 11000000b = 00101110b
-11101110b ^ 11000001b = 00101111b
-11101110b ^ 11000010b = 00101100b
-11101110b ^ 11000011b = 00101101b
-11101110b ^ 11000100b = 00101010b
-11101110b ^ 11000101b = 00101011b
-11101110b ^ 11000110b = 00101000b
-11101110b ^ 11000111b = 00101001b
-11101110b ^ 11001000b = 00100110b
-11101110b ^ 11001001b = 00100111b
-11101110b ^ 11001010b = 00100100b
-11101110b ^ 11001011b = 00100101b
-11101110b ^ 11001100b = 00100010b
-11101110b ^ 11001101b = 00100011b
-11101110b ^ 11001110b = 00100000b
-11101110b ^ 11001111b = 00100001b
-11101110b ^ 11010000b = 00111110b
-11101110b ^ 11010001b = 00111111b
-11101110b ^ 11010010b = 00111100b
-11101110b ^ 11010011b = 00111101b
-11101110b ^ 11010100b = 00111010b
-11101110b ^ 11010101b = 00111011b
-11101110b ^ 11010110b = 00111000b
-11101110b ^ 11010111b = 00111001b
-11101110b ^ 11011000b = 00110110b
-11101110b ^ 11011001b = 00110111b
-11101110b ^ 11011010b = 00110100b
-11101110b ^ 11011011b = 00110101b
-11101110b ^ 11011100b = 00110010b
-11101110b ^ 11011101b = 00110011b
-11101110b ^ 11011110b = 00110000b
-11101110b ^ 11011111b = 00110001b
-11101110b ^ 11100000b = 00001110b
-11101110b ^ 11100001b = 00001111b
-11101110b ^ 11100010b = 00001100b
-11101110b ^ 11100011b = 00001101b
-11101110b ^ 11100100b = 00001010b
-11101110b ^ 11100101b = 00001011b
-11101110b ^ 11100110b = 00001000b
-11101110b ^ 11100111b = 00001001b
-11101110b ^ 11101000b = 00000110b
-11101110b ^ 11101001b = 00000111b
-11101110b ^ 11101010b = 00000100b
-11101110b ^ 11101011b = 00000101b
-11101110b ^ 11101100b = 00000010b
-11101110b ^ 11101101b = 00000011b
-11101110b ^ 11101110b = 00000000b
-11101110b ^ 11101111b = 00000001b
-11101110b ^ 11110000b = 00011110b
-11101110b ^ 11110001b = 00011111b
-11101110b ^ 11110010b = 00011100b
-11101110b ^ 11110011b = 00011101b
-11101110b ^ 11110100b = 00011010b
-11101110b ^ 11110101b = 00011011b
-11101110b ^ 11110110b = 00011000b
-11101110b ^ 11110111b = 00011001b
-11101110b ^ 11111000b = 00010110b
-11101110b ^ 11111001b = 00010111b
-11101110b ^ 11111010b = 00010100b
-11101110b ^ 11111011b = 00010101b
-11101110b ^ 11111100b = 00010010b
-11101110b ^ 11111101b = 00010011b
-11101110b ^ 11111110b = 00010000b
-11101110b ^ 11111111b = 00010001b
-11101110b ^ 00000000b = 11101110b
-11101110b ^ 00000001b = 11101111b
-11101110b ^ 00000010b = 11101100b
-11101110b ^ 00000011b = 11101101b
-11101110b ^ 00000100b = 11101010b
-11101110b ^ 00000101b = 11101011b
-11101110b ^ 00000110b = 11101000b
-11101110b ^ 00000111b = 11101001b
-11101110b ^ 00001000b = 11100110b
-11101110b ^ 00001001b = 11100111b
-11101110b ^ 00001010b = 11100100b
-11101110b ^ 00001011b = 11100101b
-11101110b ^ 00001100b = 11100010b
-11101110b ^ 00001101b = 11100011b
-11101110b ^ 00001110b = 11100000b
-11101110b ^ 00001111b = 11100001b
-11101110b ^ 00010000b = 11111110b
-11101110b ^ 00010001b = 11111111b
-11101110b ^ 00010010b = 11111100b
-11101110b ^ 00010011b = 11111101b
-11101110b ^ 00010100b = 11111010b
-11101110b ^ 00010101b = 11111011b
-11101110b ^ 00010110b = 11111000b
-11101110b ^ 00010111b = 11111001b
-11101110b ^ 00011000b = 11110110b
-11101110b ^ 00011001b = 11110111b
-11101110b ^ 00011010b = 11110100b
-11101110b ^ 00011011b = 11110101b
-11101110b ^ 00011100b = 11110010b
-11101110b ^ 00011101b = 11110011b
-11101110b ^ 00011110b = 11110000b
-11101110b ^ 00011111b = 11110001b
-11101110b ^ 00100000b = 11001110b
-11101110b ^ 00100001b = 11001111b
-11101110b ^ 00100010b = 11001100b
-11101110b ^ 00100011b = 11001101b
-11101110b ^ 00100100b = 11001010b
-11101110b ^ 00100101b = 11001011b
-11101110b ^ 00100110b = 11001000b
-11101110b ^ 00100111b = 11001001b
-11101110b ^ 00101000b = 11000110b
-11101110b ^ 00101001b = 11000111b
-11101110b ^ 00101010b = 11000100b
-11101110b ^ 00101011b = 11000101b
-11101110b ^ 00101100b = 11000010b
-11101110b ^ 00101101b = 11000011b
-11101110b ^ 00101110b = 11000000b
-11101110b ^ 00101111b = 11000001b
-11101110b ^ 00110000b = 11011110b
-11101110b ^ 00110001b = 11011111b
-11101110b ^ 00110010b = 11011100b
-11101110b ^ 00110011b = 11011101b
-11101110b ^ 00110100b = 11011010b
-11101110b ^ 00110101b = 11011011b
-11101110b ^ 00110110b = 11011000b
-11101110b ^ 00110111b = 11011001b
-11101110b ^ 00111000b = 11010110b
-11101110b ^ 00111001b = 11010111b
-11101110b ^ 00111010b = 11010100b
-11101110b ^ 00111011b = 11010101b
-11101110b ^ 00111100b = 11010010b
-11101110b ^ 00111101b = 11010011b
-11101110b ^ 00111110b = 11010000b
-11101110b ^ 00111111b = 11010001b
-11101110b ^ 01000000b = 10101110b
-11101110b ^ 01000001b = 10101111b
-11101110b ^ 01000010b = 10101100b
-11101110b ^ 01000011b = 10101101b
-11101110b ^ 01000100b = 10101010b
-11101110b ^ 01000101b = 10101011b
-11101110b ^ 01000110b = 10101000b
-11101110b ^ 01000111b = 10101001b
-11101110b ^ 01001000b = 10100110b
-11101110b ^ 01001001b = 10100111b
-11101110b ^ 01001010b = 10100100b
-11101110b ^ 01001011b = 10100101b
-11101110b ^ 01001100b = 10100010b
-11101110b ^ 01001101b = 10100011b
-11101110b ^ 01001110b = 10100000b
-11101110b ^ 01001111b = 10100001b
-11101110b ^ 01010000b = 10111110b
-11101110b ^ 01010001b = 10111111b
-11101110b ^ 01010010b = 10111100b
-11101110b ^ 01010011b = 10111101b
-11101110b ^ 01010100b = 10111010b
-11101110b ^ 01010101b = 10111011b
-11101110b ^ 01010110b = 10111000b
-11101110b ^ 01010111b = 10111001b
-11101110b ^ 01011000b = 10110110b
-11101110b ^ 01011001b = 10110111b
-11101110b ^ 01011010b = 10110100b
-11101110b ^ 01011011b = 10110101b
-11101110b ^ 01011100b = 10110010b
-11101110b ^ 01011101b = 10110011b
-11101110b ^ 01011110b = 10110000b
-11101110b ^ 01011111b = 10110001b
-11101110b ^ 01100000b = 10001110b
-11101110b ^ 01100001b = 10001111b
-11101110b ^ 01100010b = 10001100b
-11101110b ^ 01100011b = 10001101b
-11101110b ^ 01100100b = 10001010b
-11101110b ^ 01100101b = 10001011b
-11101110b ^ 01100110b = 10001000b
-11101110b ^ 01100111b = 10001001b
-11101110b ^ 01101000b = 10000110b
-11101110b ^ 01101001b = 10000111b
-11101110b ^ 01101010b = 10000100b
-11101110b ^ 01101011b = 10000101b
-11101110b ^ 01101100b = 10000010b
-11101110b ^ 01101101b = 10000011b
-11101110b ^ 01101110b = 10000000b
-11101110b ^ 01101111b = 10000001b
-11101110b ^ 01110000b = 10011110b
-11101110b ^ 01110001b = 10011111b
-11101110b ^ 01110010b = 10011100b
-11101110b ^ 01110011b = 10011101b
-11101110b ^ 01110100b = 10011010b
-11101110b ^ 01110101b = 10011011b
-11101110b ^ 01110110b = 10011000b
-11101110b ^ 01110111b = 10011001b
-11101110b ^ 01111000b = 10010110b
-11101110b ^ 01111001b = 10010111b
-11101110b ^ 01111010b = 10010100b
-11101110b ^ 01111011b = 10010101b
-11101110b ^ 01111100b = 10010010b
-11101110b ^ 01111101b = 10010011b
-11101110b ^ 01111110b = 10010000b
-11101111b ^ 10000000b = 01101111b
-11101111b ^ 10000001b = 01101110b
-11101111b ^ 10000010b = 01101101b
-11101111b ^ 10000011b = 01101100b
-11101111b ^ 10000100b = 01101011b
-11101111b ^ 10000101b = 01101010b
-11101111b ^ 10000110b = 01101001b
-11101111b ^ 10000111b = 01101000b
-11101111b ^ 10001000b = 01100111b
-11101111b ^ 10001001b = 01100110b
-11101111b ^ 10001010b = 01100101b
-11101111b ^ 10001011b = 01100100b
-11101111b ^ 10001100b = 01100011b
-11101111b ^ 10001101b = 01100010b
-11101111b ^ 10001110b = 01100001b
-11101111b ^ 10001111b = 01100000b
-11101111b ^ 10010000b = 01111111b
-11101111b ^ 10010001b = 01111110b
-11101111b ^ 10010010b = 01111101b
-11101111b ^ 10010011b = 01111100b
-11101111b ^ 10010100b = 01111011b
-11101111b ^ 10010101b = 01111010b
-11101111b ^ 10010110b = 01111001b
-11101111b ^ 10010111b = 01111000b
-11101111b ^ 10011000b = 01110111b
-11101111b ^ 10011001b = 01110110b
-11101111b ^ 10011010b = 01110101b
-11101111b ^ 10011011b = 01110100b
-11101111b ^ 10011100b = 01110011b
-11101111b ^ 10011101b = 01110010b
-11101111b ^ 10011110b = 01110001b
-11101111b ^ 10011111b = 01110000b
-11101111b ^ 10100000b = 01001111b
-11101111b ^ 10100001b = 01001110b
-11101111b ^ 10100010b = 01001101b
-11101111b ^ 10100011b = 01001100b
-11101111b ^ 10100100b = 01001011b
-11101111b ^ 10100101b = 01001010b
-11101111b ^ 10100110b = 01001001b
-11101111b ^ 10100111b = 01001000b
-11101111b ^ 10101000b = 01000111b
-11101111b ^ 10101001b = 01000110b
-11101111b ^ 10101010b = 01000101b
-11101111b ^ 10101011b = 01000100b
-11101111b ^ 10101100b = 01000011b
-11101111b ^ 10101101b = 01000010b
-11101111b ^ 10101110b = 01000001b
-11101111b ^ 10101111b = 01000000b
-11101111b ^ 10110000b = 01011111b
-11101111b ^ 10110001b = 01011110b
-11101111b ^ 10110010b = 01011101b
-11101111b ^ 10110011b = 01011100b
-11101111b ^ 10110100b = 01011011b
-11101111b ^ 10110101b = 01011010b
-11101111b ^ 10110110b = 01011001b
-11101111b ^ 10110111b = 01011000b
-11101111b ^ 10111000b = 01010111b
-11101111b ^ 10111001b = 01010110b
-11101111b ^ 10111010b = 01010101b
-11101111b ^ 10111011b = 01010100b
-11101111b ^ 10111100b = 01010011b
-11101111b ^ 10111101b = 01010010b
-11101111b ^ 10111110b = 01010001b
-11101111b ^ 10111111b = 01010000b
-11101111b ^ 11000000b = 00101111b
-11101111b ^ 11000001b = 00101110b
-11101111b ^ 11000010b = 00101101b
-11101111b ^ 11000011b = 00101100b
-11101111b ^ 11000100b = 00101011b
-11101111b ^ 11000101b = 00101010b
-11101111b ^ 11000110b = 00101001b
-11101111b ^ 11000111b = 00101000b
-11101111b ^ 11001000b = 00100111b
-11101111b ^ 11001001b = 00100110b
-11101111b ^ 11001010b = 00100101b
-11101111b ^ 11001011b = 00100100b
-11101111b ^ 11001100b = 00100011b
-11101111b ^ 11001101b = 00100010b
-11101111b ^ 11001110b = 00100001b
-11101111b ^ 11001111b = 00100000b
-11101111b ^ 11010000b = 00111111b
-11101111b ^ 11010001b = 00111110b
-11101111b ^ 11010010b = 00111101b
-11101111b ^ 11010011b = 00111100b
-11101111b ^ 11010100b = 00111011b
-11101111b ^ 11010101b = 00111010b
-11101111b ^ 11010110b = 00111001b
-11101111b ^ 11010111b = 00111000b
-11101111b ^ 11011000b = 00110111b
-11101111b ^ 11011001b = 00110110b
-11101111b ^ 11011010b = 00110101b
-11101111b ^ 11011011b = 00110100b
-11101111b ^ 11011100b = 00110011b
-11101111b ^ 11011101b = 00110010b
-11101111b ^ 11011110b = 00110001b
-11101111b ^ 11011111b = 00110000b
-11101111b ^ 11100000b = 00001111b
-11101111b ^ 11100001b = 00001110b
-11101111b ^ 11100010b = 00001101b
-11101111b ^ 11100011b = 00001100b
-11101111b ^ 11100100b = 00001011b
-11101111b ^ 11100101b = 00001010b
-11101111b ^ 11100110b = 00001001b
-11101111b ^ 11100111b = 00001000b
-11101111b ^ 11101000b = 00000111b
-11101111b ^ 11101001b = 00000110b
-11101111b ^ 11101010b = 00000101b
-11101111b ^ 11101011b = 00000100b
-11101111b ^ 11101100b = 00000011b
-11101111b ^ 11101101b = 00000010b
-11101111b ^ 11101110b = 00000001b
-11101111b ^ 11101111b = 00000000b
-11101111b ^ 11110000b = 00011111b
-11101111b ^ 11110001b = 00011110b
-11101111b ^ 11110010b = 00011101b
-11101111b ^ 11110011b = 00011100b
-11101111b ^ 11110100b = 00011011b
-11101111b ^ 11110101b = 00011010b
-11101111b ^ 11110110b = 00011001b
-11101111b ^ 11110111b = 00011000b
-11101111b ^ 11111000b = 00010111b
-11101111b ^ 11111001b = 00010110b
-11101111b ^ 11111010b = 00010101b
-11101111b ^ 11111011b = 00010100b
-11101111b ^ 11111100b = 00010011b
-11101111b ^ 11111101b = 00010010b
-11101111b ^ 11111110b = 00010001b
-11101111b ^ 11111111b = 00010000b
-11101111b ^ 00000000b = 11101111b
-11101111b ^ 00000001b = 11101110b
-11101111b ^ 00000010b = 11101101b
-11101111b ^ 00000011b = 11101100b
-11101111b ^ 00000100b = 11101011b
-11101111b ^ 00000101b = 11101010b
-11101111b ^ 00000110b = 11101001b
-11101111b ^ 00000111b = 11101000b
-11101111b ^ 00001000b = 11100111b
-11101111b ^ 00001001b = 11100110b
-11101111b ^ 00001010b = 11100101b
-11101111b ^ 00001011b = 11100100b
-11101111b ^ 00001100b = 11100011b
-11101111b ^ 00001101b = 11100010b
-11101111b ^ 00001110b = 11100001b
-11101111b ^ 00001111b = 11100000b
-11101111b ^ 00010000b = 11111111b
-11101111b ^ 00010001b = 11111110b
-11101111b ^ 00010010b = 11111101b
-11101111b ^ 00010011b = 11111100b
-11101111b ^ 00010100b = 11111011b
-11101111b ^ 00010101b = 11111010b
-11101111b ^ 00010110b = 11111001b
-11101111b ^ 00010111b = 11111000b
-11101111b ^ 00011000b = 11110111b
-11101111b ^ 00011001b = 11110110b
-11101111b ^ 00011010b = 11110101b
-11101111b ^ 00011011b = 11110100b
-11101111b ^ 00011100b = 11110011b
-11101111b ^ 00011101b = 11110010b
-11101111b ^ 00011110b = 11110001b
-11101111b ^ 00011111b = 11110000b
-11101111b ^ 00100000b = 11001111b
-11101111b ^ 00100001b = 11001110b
-11101111b ^ 00100010b = 11001101b
-11101111b ^ 00100011b = 11001100b
-11101111b ^ 00100100b = 11001011b
-11101111b ^ 00100101b = 11001010b
-11101111b ^ 00100110b = 11001001b
-11101111b ^ 00100111b = 11001000b
-11101111b ^ 00101000b = 11000111b
-11101111b ^ 00101001b = 11000110b
-11101111b ^ 00101010b = 11000101b
-11101111b ^ 00101011b = 11000100b
-11101111b ^ 00101100b = 11000011b
-11101111b ^ 00101101b = 11000010b
-11101111b ^ 00101110b = 11000001b
-11101111b ^ 00101111b = 11000000b
-11101111b ^ 00110000b = 11011111b
-11101111b ^ 00110001b = 11011110b
-11101111b ^ 00110010b = 11011101b
-11101111b ^ 00110011b = 11011100b
-11101111b ^ 00110100b = 11011011b
-11101111b ^ 00110101b = 11011010b
-11101111b ^ 00110110b = 11011001b
-11101111b ^ 00110111b = 11011000b
-11101111b ^ 00111000b = 11010111b
-11101111b ^ 00111001b = 11010110b
-11101111b ^ 00111010b = 11010101b
-11101111b ^ 00111011b = 11010100b
-11101111b ^ 00111100b = 11010011b
-11101111b ^ 00111101b = 11010010b
-11101111b ^ 00111110b = 11010001b
-11101111b ^ 00111111b = 11010000b
-11101111b ^ 01000000b = 10101111b
-11101111b ^ 01000001b = 10101110b
-11101111b ^ 01000010b = 10101101b
-11101111b ^ 01000011b = 10101100b
-11101111b ^ 01000100b = 10101011b
-11101111b ^ 01000101b = 10101010b
-11101111b ^ 01000110b = 10101001b
-11101111b ^ 01000111b = 10101000b
-11101111b ^ 01001000b = 10100111b
-11101111b ^ 01001001b = 10100110b
-11101111b ^ 01001010b = 10100101b
-11101111b ^ 01001011b = 10100100b
-11101111b ^ 01001100b = 10100011b
-11101111b ^ 01001101b = 10100010b
-11101111b ^ 01001110b = 10100001b
-11101111b ^ 01001111b = 10100000b
-11101111b ^ 01010000b = 10111111b
-11101111b ^ 01010001b = 10111110b
-11101111b ^ 01010010b = 10111101b
-11101111b ^ 01010011b = 10111100b
-11101111b ^ 01010100b = 10111011b
-11101111b ^ 01010101b = 10111010b
-11101111b ^ 01010110b = 10111001b
-11101111b ^ 01010111b = 10111000b
-11101111b ^ 01011000b = 10110111b
-11101111b ^ 01011001b = 10110110b
-11101111b ^ 01011010b = 10110101b
-11101111b ^ 01011011b = 10110100b
-11101111b ^ 01011100b = 10110011b
-11101111b ^ 01011101b = 10110010b
-11101111b ^ 01011110b = 10110001b
-11101111b ^ 01011111b = 10110000b
-11101111b ^ 01100000b = 10001111b
-11101111b ^ 01100001b = 10001110b
-11101111b ^ 01100010b = 10001101b
-11101111b ^ 01100011b = 10001100b
-11101111b ^ 01100100b = 10001011b
-11101111b ^ 01100101b = 10001010b
-11101111b ^ 01100110b = 10001001b
-11101111b ^ 01100111b = 10001000b
-11101111b ^ 01101000b = 10000111b
-11101111b ^ 01101001b = 10000110b
-11101111b ^ 01101010b = 10000101b
-11101111b ^ 01101011b = 10000100b
-11101111b ^ 01101100b = 10000011b
-11101111b ^ 01101101b = 10000010b
-11101111b ^ 01101110b = 10000001b
-11101111b ^ 01101111b = 10000000b
-11101111b ^ 01110000b = 10011111b
-11101111b ^ 01110001b = 10011110b
-11101111b ^ 01110010b = 10011101b
-11101111b ^ 01110011b = 10011100b
-11101111b ^ 01110100b = 10011011b
-11101111b ^ 01110101b = 10011010b
-11101111b ^ 01110110b = 10011001b
-11101111b ^ 01110111b = 10011000b
-11101111b ^ 01111000b = 10010111b
-11101111b ^ 01111001b = 10010110b
-11101111b ^ 01111010b = 10010101b
-11101111b ^ 01111011b = 10010100b
-11101111b ^ 01111100b = 10010011b
-11101111b ^ 01111101b = 10010010b
-11101111b ^ 01111110b = 10010001b
-11110000b ^ 10000000b = 01110000b
-11110000b ^ 10000001b = 01110001b
-11110000b ^ 10000010b = 01110010b
-11110000b ^ 10000011b = 01110011b
-11110000b ^ 10000100b = 01110100b
-11110000b ^ 10000101b = 01110101b
-11110000b ^ 10000110b = 01110110b
-11110000b ^ 10000111b = 01110111b
-11110000b ^ 10001000b = 01111000b
-11110000b ^ 10001001b = 01111001b
-11110000b ^ 10001010b = 01111010b
-11110000b ^ 10001011b = 01111011b
-11110000b ^ 10001100b = 01111100b
-11110000b ^ 10001101b = 01111101b
-11110000b ^ 10001110b = 01111110b
-11110000b ^ 10001111b = 01111111b
-11110000b ^ 10010000b = 01100000b
-11110000b ^ 10010001b = 01100001b
-11110000b ^ 10010010b = 01100010b
-11110000b ^ 10010011b = 01100011b
-11110000b ^ 10010100b = 01100100b
-11110000b ^ 10010101b = 01100101b
-11110000b ^ 10010110b = 01100110b
-11110000b ^ 10010111b = 01100111b
-11110000b ^ 10011000b = 01101000b
-11110000b ^ 10011001b = 01101001b
-11110000b ^ 10011010b = 01101010b
-11110000b ^ 10011011b = 01101011b
-11110000b ^ 10011100b = 01101100b
-11110000b ^ 10011101b = 01101101b
-11110000b ^ 10011110b = 01101110b
-11110000b ^ 10011111b = 01101111b
-11110000b ^ 10100000b = 01010000b
-11110000b ^ 10100001b = 01010001b
-11110000b ^ 10100010b = 01010010b
-11110000b ^ 10100011b = 01010011b
-11110000b ^ 10100100b = 01010100b
-11110000b ^ 10100101b = 01010101b
-11110000b ^ 10100110b = 01010110b
-11110000b ^ 10100111b = 01010111b
-11110000b ^ 10101000b = 01011000b
-11110000b ^ 10101001b = 01011001b
-11110000b ^ 10101010b = 01011010b
-11110000b ^ 10101011b = 01011011b
-11110000b ^ 10101100b = 01011100b
-11110000b ^ 10101101b = 01011101b
-11110000b ^ 10101110b = 01011110b
-11110000b ^ 10101111b = 01011111b
-11110000b ^ 10110000b = 01000000b
-11110000b ^ 10110001b = 01000001b
-11110000b ^ 10110010b = 01000010b
-11110000b ^ 10110011b = 01000011b
-11110000b ^ 10110100b = 01000100b
-11110000b ^ 10110101b = 01000101b
-11110000b ^ 10110110b = 01000110b
-11110000b ^ 10110111b = 01000111b
-11110000b ^ 10111000b = 01001000b
-11110000b ^ 10111001b = 01001001b
-11110000b ^ 10111010b = 01001010b
-11110000b ^ 10111011b = 01001011b
-11110000b ^ 10111100b = 01001100b
-11110000b ^ 10111101b = 01001101b
-11110000b ^ 10111110b = 01001110b
-11110000b ^ 10111111b = 01001111b
-11110000b ^ 11000000b = 00110000b
-11110000b ^ 11000001b = 00110001b
-11110000b ^ 11000010b = 00110010b
-11110000b ^ 11000011b = 00110011b
-11110000b ^ 11000100b = 00110100b
-11110000b ^ 11000101b = 00110101b
-11110000b ^ 11000110b = 00110110b
-11110000b ^ 11000111b = 00110111b
-11110000b ^ 11001000b = 00111000b
-11110000b ^ 11001001b = 00111001b
-11110000b ^ 11001010b = 00111010b
-11110000b ^ 11001011b = 00111011b
-11110000b ^ 11001100b = 00111100b
-11110000b ^ 11001101b = 00111101b
-11110000b ^ 11001110b = 00111110b
-11110000b ^ 11001111b = 00111111b
-11110000b ^ 11010000b = 00100000b
-11110000b ^ 11010001b = 00100001b
-11110000b ^ 11010010b = 00100010b
-11110000b ^ 11010011b = 00100011b
-11110000b ^ 11010100b = 00100100b
-11110000b ^ 11010101b = 00100101b
-11110000b ^ 11010110b = 00100110b
-11110000b ^ 11010111b = 00100111b
-11110000b ^ 11011000b = 00101000b
-11110000b ^ 11011001b = 00101001b
-11110000b ^ 11011010b = 00101010b
-11110000b ^ 11011011b = 00101011b
-11110000b ^ 11011100b = 00101100b
-11110000b ^ 11011101b = 00101101b
-11110000b ^ 11011110b = 00101110b
-11110000b ^ 11011111b = 00101111b
-11110000b ^ 11100000b = 00010000b
-11110000b ^ 11100001b = 00010001b
-11110000b ^ 11100010b = 00010010b
-11110000b ^ 11100011b = 00010011b
-11110000b ^ 11100100b = 00010100b
-11110000b ^ 11100101b = 00010101b
-11110000b ^ 11100110b = 00010110b
-11110000b ^ 11100111b = 00010111b
-11110000b ^ 11101000b = 00011000b
-11110000b ^ 11101001b = 00011001b
-11110000b ^ 11101010b = 00011010b
-11110000b ^ 11101011b = 00011011b
-11110000b ^ 11101100b = 00011100b
-11110000b ^ 11101101b = 00011101b
-11110000b ^ 11101110b = 00011110b
-11110000b ^ 11101111b = 00011111b
-11110000b ^ 11110000b = 00000000b
-11110000b ^ 11110001b = 00000001b
-11110000b ^ 11110010b = 00000010b
-11110000b ^ 11110011b = 00000011b
-11110000b ^ 11110100b = 00000100b
-11110000b ^ 11110101b = 00000101b
-11110000b ^ 11110110b = 00000110b
-11110000b ^ 11110111b = 00000111b
-11110000b ^ 11111000b = 00001000b
-11110000b ^ 11111001b = 00001001b
-11110000b ^ 11111010b = 00001010b
-11110000b ^ 11111011b = 00001011b
-11110000b ^ 11111100b = 00001100b
-11110000b ^ 11111101b = 00001101b
-11110000b ^ 11111110b = 00001110b
-11110000b ^ 11111111b = 00001111b
-11110000b ^ 00000000b = 11110000b
-11110000b ^ 00000001b = 11110001b
-11110000b ^ 00000010b = 11110010b
-11110000b ^ 00000011b = 11110011b
-11110000b ^ 00000100b = 11110100b
-11110000b ^ 00000101b = 11110101b
-11110000b ^ 00000110b = 11110110b
-11110000b ^ 00000111b = 11110111b
-11110000b ^ 00001000b = 11111000b
-11110000b ^ 00001001b = 11111001b
-11110000b ^ 00001010b = 11111010b
-11110000b ^ 00001011b = 11111011b
-11110000b ^ 00001100b = 11111100b
-11110000b ^ 00001101b = 11111101b
-11110000b ^ 00001110b = 11111110b
-11110000b ^ 00001111b = 11111111b
-11110000b ^ 00010000b = 11100000b
-11110000b ^ 00010001b = 11100001b
-11110000b ^ 00010010b = 11100010b
-11110000b ^ 00010011b = 11100011b
-11110000b ^ 00010100b = 11100100b
-11110000b ^ 00010101b = 11100101b
-11110000b ^ 00010110b = 11100110b
-11110000b ^ 00010111b = 11100111b
-11110000b ^ 00011000b = 11101000b
-11110000b ^ 00011001b = 11101001b
-11110000b ^ 00011010b = 11101010b
-11110000b ^ 00011011b = 11101011b
-11110000b ^ 00011100b = 11101100b
-11110000b ^ 00011101b = 11101101b
-11110000b ^ 00011110b = 11101110b
-11110000b ^ 00011111b = 11101111b
-11110000b ^ 00100000b = 11010000b
-11110000b ^ 00100001b = 11010001b
-11110000b ^ 00100010b = 11010010b
-11110000b ^ 00100011b = 11010011b
-11110000b ^ 00100100b = 11010100b
-11110000b ^ 00100101b = 11010101b
-11110000b ^ 00100110b = 11010110b
-11110000b ^ 00100111b = 11010111b
-11110000b ^ 00101000b = 11011000b
-11110000b ^ 00101001b = 11011001b
-11110000b ^ 00101010b = 11011010b
-11110000b ^ 00101011b = 11011011b
-11110000b ^ 00101100b = 11011100b
-11110000b ^ 00101101b = 11011101b
-11110000b ^ 00101110b = 11011110b
-11110000b ^ 00101111b = 11011111b
-11110000b ^ 00110000b = 11000000b
-11110000b ^ 00110001b = 11000001b
-11110000b ^ 00110010b = 11000010b
-11110000b ^ 00110011b = 11000011b
-11110000b ^ 00110100b = 11000100b
-11110000b ^ 00110101b = 11000101b
-11110000b ^ 00110110b = 11000110b
-11110000b ^ 00110111b = 11000111b
-11110000b ^ 00111000b = 11001000b
-11110000b ^ 00111001b = 11001001b
-11110000b ^ 00111010b = 11001010b
-11110000b ^ 00111011b = 11001011b
-11110000b ^ 00111100b = 11001100b
-11110000b ^ 00111101b = 11001101b
-11110000b ^ 00111110b = 11001110b
-11110000b ^ 00111111b = 11001111b
-11110000b ^ 01000000b = 10110000b
-11110000b ^ 01000001b = 10110001b
-11110000b ^ 01000010b = 10110010b
-11110000b ^ 01000011b = 10110011b
-11110000b ^ 01000100b = 10110100b
-11110000b ^ 01000101b = 10110101b
-11110000b ^ 01000110b = 10110110b
-11110000b ^ 01000111b = 10110111b
-11110000b ^ 01001000b = 10111000b
-11110000b ^ 01001001b = 10111001b
-11110000b ^ 01001010b = 10111010b
-11110000b ^ 01001011b = 10111011b
-11110000b ^ 01001100b = 10111100b
-11110000b ^ 01001101b = 10111101b
-11110000b ^ 01001110b = 10111110b
-11110000b ^ 01001111b = 10111111b
-11110000b ^ 01010000b = 10100000b
-11110000b ^ 01010001b = 10100001b
-11110000b ^ 01010010b = 10100010b
-11110000b ^ 01010011b = 10100011b
-11110000b ^ 01010100b = 10100100b
-11110000b ^ 01010101b = 10100101b
-11110000b ^ 01010110b = 10100110b
-11110000b ^ 01010111b = 10100111b
-11110000b ^ 01011000b = 10101000b
-11110000b ^ 01011001b = 10101001b
-11110000b ^ 01011010b = 10101010b
-11110000b ^ 01011011b = 10101011b
-11110000b ^ 01011100b = 10101100b
-11110000b ^ 01011101b = 10101101b
-11110000b ^ 01011110b = 10101110b
-11110000b ^ 01011111b = 10101111b
-11110000b ^ 01100000b = 10010000b
-11110000b ^ 01100001b = 10010001b
-11110000b ^ 01100010b = 10010010b
-11110000b ^ 01100011b = 10010011b
-11110000b ^ 01100100b = 10010100b
-11110000b ^ 01100101b = 10010101b
-11110000b ^ 01100110b = 10010110b
-11110000b ^ 01100111b = 10010111b
-11110000b ^ 01101000b = 10011000b
-11110000b ^ 01101001b = 10011001b
-11110000b ^ 01101010b = 10011010b
-11110000b ^ 01101011b = 10011011b
-11110000b ^ 01101100b = 10011100b
-11110000b ^ 01101101b = 10011101b
-11110000b ^ 01101110b = 10011110b
-11110000b ^ 01101111b = 10011111b
-11110000b ^ 01110000b = 10000000b
-11110000b ^ 01110001b = 10000001b
-11110000b ^ 01110010b = 10000010b
-11110000b ^ 01110011b = 10000011b
-11110000b ^ 01110100b = 10000100b
-11110000b ^ 01110101b = 10000101b
-11110000b ^ 01110110b = 10000110b
-11110000b ^ 01110111b = 10000111b
-11110000b ^ 01111000b = 10001000b
-11110000b ^ 01111001b = 10001001b
-11110000b ^ 01111010b = 10001010b
-11110000b ^ 01111011b = 10001011b
-11110000b ^ 01111100b = 10001100b
-11110000b ^ 01111101b = 10001101b
-11110000b ^ 01111110b = 10001110b
-11110001b ^ 10000000b = 01110001b
-11110001b ^ 10000001b = 01110000b
-11110001b ^ 10000010b = 01110011b
-11110001b ^ 10000011b = 01110010b
-11110001b ^ 10000100b = 01110101b
-11110001b ^ 10000101b = 01110100b
-11110001b ^ 10000110b = 01110111b
-11110001b ^ 10000111b = 01110110b
-11110001b ^ 10001000b = 01111001b
-11110001b ^ 10001001b = 01111000b
-11110001b ^ 10001010b = 01111011b
-11110001b ^ 10001011b = 01111010b
-11110001b ^ 10001100b = 01111101b
-11110001b ^ 10001101b = 01111100b
-11110001b ^ 10001110b = 01111111b
-11110001b ^ 10001111b = 01111110b
-11110001b ^ 10010000b = 01100001b
-11110001b ^ 10010001b = 01100000b
-11110001b ^ 10010010b = 01100011b
-11110001b ^ 10010011b = 01100010b
-11110001b ^ 10010100b = 01100101b
-11110001b ^ 10010101b = 01100100b
-11110001b ^ 10010110b = 01100111b
-11110001b ^ 10010111b = 01100110b
-11110001b ^ 10011000b = 01101001b
-11110001b ^ 10011001b = 01101000b
-11110001b ^ 10011010b = 01101011b
-11110001b ^ 10011011b = 01101010b
-11110001b ^ 10011100b = 01101101b
-11110001b ^ 10011101b = 01101100b
-11110001b ^ 10011110b = 01101111b
-11110001b ^ 10011111b = 01101110b
-11110001b ^ 10100000b = 01010001b
-11110001b ^ 10100001b = 01010000b
-11110001b ^ 10100010b = 01010011b
-11110001b ^ 10100011b = 01010010b
-11110001b ^ 10100100b = 01010101b
-11110001b ^ 10100101b = 01010100b
-11110001b ^ 10100110b = 01010111b
-11110001b ^ 10100111b = 01010110b
-11110001b ^ 10101000b = 01011001b
-11110001b ^ 10101001b = 01011000b
-11110001b ^ 10101010b = 01011011b
-11110001b ^ 10101011b = 01011010b
-11110001b ^ 10101100b = 01011101b
-11110001b ^ 10101101b = 01011100b
-11110001b ^ 10101110b = 01011111b
-11110001b ^ 10101111b = 01011110b
-11110001b ^ 10110000b = 01000001b
-11110001b ^ 10110001b = 01000000b
-11110001b ^ 10110010b = 01000011b
-11110001b ^ 10110011b = 01000010b
-11110001b ^ 10110100b = 01000101b
-11110001b ^ 10110101b = 01000100b
-11110001b ^ 10110110b = 01000111b
-11110001b ^ 10110111b = 01000110b
-11110001b ^ 10111000b = 01001001b
-11110001b ^ 10111001b = 01001000b
-11110001b ^ 10111010b = 01001011b
-11110001b ^ 10111011b = 01001010b
-11110001b ^ 10111100b = 01001101b
-11110001b ^ 10111101b = 01001100b
-11110001b ^ 10111110b = 01001111b
-11110001b ^ 10111111b = 01001110b
-11110001b ^ 11000000b = 00110001b
-11110001b ^ 11000001b = 00110000b
-11110001b ^ 11000010b = 00110011b
-11110001b ^ 11000011b = 00110010b
-11110001b ^ 11000100b = 00110101b
-11110001b ^ 11000101b = 00110100b
-11110001b ^ 11000110b = 00110111b
-11110001b ^ 11000111b = 00110110b
-11110001b ^ 11001000b = 00111001b
-11110001b ^ 11001001b = 00111000b
-11110001b ^ 11001010b = 00111011b
-11110001b ^ 11001011b = 00111010b
-11110001b ^ 11001100b = 00111101b
-11110001b ^ 11001101b = 00111100b
-11110001b ^ 11001110b = 00111111b
-11110001b ^ 11001111b = 00111110b
-11110001b ^ 11010000b = 00100001b
-11110001b ^ 11010001b = 00100000b
-11110001b ^ 11010010b = 00100011b
-11110001b ^ 11010011b = 00100010b
-11110001b ^ 11010100b = 00100101b
-11110001b ^ 11010101b = 00100100b
-11110001b ^ 11010110b = 00100111b
-11110001b ^ 11010111b = 00100110b
-11110001b ^ 11011000b = 00101001b
-11110001b ^ 11011001b = 00101000b
-11110001b ^ 11011010b = 00101011b
-11110001b ^ 11011011b = 00101010b
-11110001b ^ 11011100b = 00101101b
-11110001b ^ 11011101b = 00101100b
-11110001b ^ 11011110b = 00101111b
-11110001b ^ 11011111b = 00101110b
-11110001b ^ 11100000b = 00010001b
-11110001b ^ 11100001b = 00010000b
-11110001b ^ 11100010b = 00010011b
-11110001b ^ 11100011b = 00010010b
-11110001b ^ 11100100b = 00010101b
-11110001b ^ 11100101b = 00010100b
-11110001b ^ 11100110b = 00010111b
-11110001b ^ 11100111b = 00010110b
-11110001b ^ 11101000b = 00011001b
-11110001b ^ 11101001b = 00011000b
-11110001b ^ 11101010b = 00011011b
-11110001b ^ 11101011b = 00011010b
-11110001b ^ 11101100b = 00011101b
-11110001b ^ 11101101b = 00011100b
-11110001b ^ 11101110b = 00011111b
-11110001b ^ 11101111b = 00011110b
-11110001b ^ 11110000b = 00000001b
-11110001b ^ 11110001b = 00000000b
-11110001b ^ 11110010b = 00000011b
-11110001b ^ 11110011b = 00000010b
-11110001b ^ 11110100b = 00000101b
-11110001b ^ 11110101b = 00000100b
-11110001b ^ 11110110b = 00000111b
-11110001b ^ 11110111b = 00000110b
-11110001b ^ 11111000b = 00001001b
-11110001b ^ 11111001b = 00001000b
-11110001b ^ 11111010b = 00001011b
-11110001b ^ 11111011b = 00001010b
-11110001b ^ 11111100b = 00001101b
-11110001b ^ 11111101b = 00001100b
-11110001b ^ 11111110b = 00001111b
-11110001b ^ 11111111b = 00001110b
-11110001b ^ 00000000b = 11110001b
-11110001b ^ 00000001b = 11110000b
-11110001b ^ 00000010b = 11110011b
-11110001b ^ 00000011b = 11110010b
-11110001b ^ 00000100b = 11110101b
-11110001b ^ 00000101b = 11110100b
-11110001b ^ 00000110b = 11110111b
-11110001b ^ 00000111b = 11110110b
-11110001b ^ 00001000b = 11111001b
-11110001b ^ 00001001b = 11111000b
-11110001b ^ 00001010b = 11111011b
-11110001b ^ 00001011b = 11111010b
-11110001b ^ 00001100b = 11111101b
-11110001b ^ 00001101b = 11111100b
-11110001b ^ 00001110b = 11111111b
-11110001b ^ 00001111b = 11111110b
-11110001b ^ 00010000b = 11100001b
-11110001b ^ 00010001b = 11100000b
-11110001b ^ 00010010b = 11100011b
-11110001b ^ 00010011b = 11100010b
-11110001b ^ 00010100b = 11100101b
-11110001b ^ 00010101b = 11100100b
-11110001b ^ 00010110b = 11100111b
-11110001b ^ 00010111b = 11100110b
-11110001b ^ 00011000b = 11101001b
-11110001b ^ 00011001b = 11101000b
-11110001b ^ 00011010b = 11101011b
-11110001b ^ 00011011b = 11101010b
-11110001b ^ 00011100b = 11101101b
-11110001b ^ 00011101b = 11101100b
-11110001b ^ 00011110b = 11101111b
-11110001b ^ 00011111b = 11101110b
-11110001b ^ 00100000b = 11010001b
-11110001b ^ 00100001b = 11010000b
-11110001b ^ 00100010b = 11010011b
-11110001b ^ 00100011b = 11010010b
-11110001b ^ 00100100b = 11010101b
-11110001b ^ 00100101b = 11010100b
-11110001b ^ 00100110b = 11010111b
-11110001b ^ 00100111b = 11010110b
-11110001b ^ 00101000b = 11011001b
-11110001b ^ 00101001b = 11011000b
-11110001b ^ 00101010b = 11011011b
-11110001b ^ 00101011b = 11011010b
-11110001b ^ 00101100b = 11011101b
-11110001b ^ 00101101b = 11011100b
-11110001b ^ 00101110b = 11011111b
-11110001b ^ 00101111b = 11011110b
-11110001b ^ 00110000b = 11000001b
-11110001b ^ 00110001b = 11000000b
-11110001b ^ 00110010b = 11000011b
-11110001b ^ 00110011b = 11000010b
-11110001b ^ 00110100b = 11000101b
-11110001b ^ 00110101b = 11000100b
-11110001b ^ 00110110b = 11000111b
-11110001b ^ 00110111b = 11000110b
-11110001b ^ 00111000b = 11001001b
-11110001b ^ 00111001b = 11001000b
-11110001b ^ 00111010b = 11001011b
-11110001b ^ 00111011b = 11001010b
-11110001b ^ 00111100b = 11001101b
-11110001b ^ 00111101b = 11001100b
-11110001b ^ 00111110b = 11001111b
-11110001b ^ 00111111b = 11001110b
-11110001b ^ 01000000b = 10110001b
-11110001b ^ 01000001b = 10110000b
-11110001b ^ 01000010b = 10110011b
-11110001b ^ 01000011b = 10110010b
-11110001b ^ 01000100b = 10110101b
-11110001b ^ 01000101b = 10110100b
-11110001b ^ 01000110b = 10110111b
-11110001b ^ 01000111b = 10110110b
-11110001b ^ 01001000b = 10111001b
-11110001b ^ 01001001b = 10111000b
-11110001b ^ 01001010b = 10111011b
-11110001b ^ 01001011b = 10111010b
-11110001b ^ 01001100b = 10111101b
-11110001b ^ 01001101b = 10111100b
-11110001b ^ 01001110b = 10111111b
-11110001b ^ 01001111b = 10111110b
-11110001b ^ 01010000b = 10100001b
-11110001b ^ 01010001b = 10100000b
-11110001b ^ 01010010b = 10100011b
-11110001b ^ 01010011b = 10100010b
-11110001b ^ 01010100b = 10100101b
-11110001b ^ 01010101b = 10100100b
-11110001b ^ 01010110b = 10100111b
-11110001b ^ 01010111b = 10100110b
-11110001b ^ 01011000b = 10101001b
-11110001b ^ 01011001b = 10101000b
-11110001b ^ 01011010b = 10101011b
-11110001b ^ 01011011b = 10101010b
-11110001b ^ 01011100b = 10101101b
-11110001b ^ 01011101b = 10101100b
-11110001b ^ 01011110b = 10101111b
-11110001b ^ 01011111b = 10101110b
-11110001b ^ 01100000b = 10010001b
-11110001b ^ 01100001b = 10010000b
-11110001b ^ 01100010b = 10010011b
-11110001b ^ 01100011b = 10010010b
-11110001b ^ 01100100b = 10010101b
-11110001b ^ 01100101b = 10010100b
-11110001b ^ 01100110b = 10010111b
-11110001b ^ 01100111b = 10010110b
-11110001b ^ 01101000b = 10011001b
-11110001b ^ 01101001b = 10011000b
-11110001b ^ 01101010b = 10011011b
-11110001b ^ 01101011b = 10011010b
-11110001b ^ 01101100b = 10011101b
-11110001b ^ 01101101b = 10011100b
-11110001b ^ 01101110b = 10011111b
-11110001b ^ 01101111b = 10011110b
-11110001b ^ 01110000b = 10000001b
-11110001b ^ 01110001b = 10000000b
-11110001b ^ 01110010b = 10000011b
-11110001b ^ 01110011b = 10000010b
-11110001b ^ 01110100b = 10000101b
-11110001b ^ 01110101b = 10000100b
-11110001b ^ 01110110b = 10000111b
-11110001b ^ 01110111b = 10000110b
-11110001b ^ 01111000b = 10001001b
-11110001b ^ 01111001b = 10001000b
-11110001b ^ 01111010b = 10001011b
-11110001b ^ 01111011b = 10001010b
-11110001b ^ 01111100b = 10001101b
-11110001b ^ 01111101b = 10001100b
-11110001b ^ 01111110b = 10001111b
-11110010b ^ 10000000b = 01110010b
-11110010b ^ 10000001b = 01110011b
-11110010b ^ 10000010b = 01110000b
-11110010b ^ 10000011b = 01110001b
-11110010b ^ 10000100b = 01110110b
-11110010b ^ 10000101b = 01110111b
-11110010b ^ 10000110b = 01110100b
-11110010b ^ 10000111b = 01110101b
-11110010b ^ 10001000b = 01111010b
-11110010b ^ 10001001b = 01111011b
-11110010b ^ 10001010b = 01111000b
-11110010b ^ 10001011b = 01111001b
-11110010b ^ 10001100b = 01111110b
-11110010b ^ 10001101b = 01111111b
-11110010b ^ 10001110b = 01111100b
-11110010b ^ 10001111b = 01111101b
-11110010b ^ 10010000b = 01100010b
-11110010b ^ 10010001b = 01100011b
-11110010b ^ 10010010b = 01100000b
-11110010b ^ 10010011b = 01100001b
-11110010b ^ 10010100b = 01100110b
-11110010b ^ 10010101b = 01100111b
-11110010b ^ 10010110b = 01100100b
-11110010b ^ 10010111b = 01100101b
-11110010b ^ 10011000b = 01101010b
-11110010b ^ 10011001b = 01101011b
-11110010b ^ 10011010b = 01101000b
-11110010b ^ 10011011b = 01101001b
-11110010b ^ 10011100b = 01101110b
-11110010b ^ 10011101b = 01101111b
-11110010b ^ 10011110b = 01101100b
-11110010b ^ 10011111b = 01101101b
-11110010b ^ 10100000b = 01010010b
-11110010b ^ 10100001b = 01010011b
-11110010b ^ 10100010b = 01010000b
-11110010b ^ 10100011b = 01010001b
-11110010b ^ 10100100b = 01010110b
-11110010b ^ 10100101b = 01010111b
-11110010b ^ 10100110b = 01010100b
-11110010b ^ 10100111b = 01010101b
-11110010b ^ 10101000b = 01011010b
-11110010b ^ 10101001b = 01011011b
-11110010b ^ 10101010b = 01011000b
-11110010b ^ 10101011b = 01011001b
-11110010b ^ 10101100b = 01011110b
-11110010b ^ 10101101b = 01011111b
-11110010b ^ 10101110b = 01011100b
-11110010b ^ 10101111b = 01011101b
-11110010b ^ 10110000b = 01000010b
-11110010b ^ 10110001b = 01000011b
-11110010b ^ 10110010b = 01000000b
-11110010b ^ 10110011b = 01000001b
-11110010b ^ 10110100b = 01000110b
-11110010b ^ 10110101b = 01000111b
-11110010b ^ 10110110b = 01000100b
-11110010b ^ 10110111b = 01000101b
-11110010b ^ 10111000b = 01001010b
-11110010b ^ 10111001b = 01001011b
-11110010b ^ 10111010b = 01001000b
-11110010b ^ 10111011b = 01001001b
-11110010b ^ 10111100b = 01001110b
-11110010b ^ 10111101b = 01001111b
-11110010b ^ 10111110b = 01001100b
-11110010b ^ 10111111b = 01001101b
-11110010b ^ 11000000b = 00110010b
-11110010b ^ 11000001b = 00110011b
-11110010b ^ 11000010b = 00110000b
-11110010b ^ 11000011b = 00110001b
-11110010b ^ 11000100b = 00110110b
-11110010b ^ 11000101b = 00110111b
-11110010b ^ 11000110b = 00110100b
-11110010b ^ 11000111b = 00110101b
-11110010b ^ 11001000b = 00111010b
-11110010b ^ 11001001b = 00111011b
-11110010b ^ 11001010b = 00111000b
-11110010b ^ 11001011b = 00111001b
-11110010b ^ 11001100b = 00111110b
-11110010b ^ 11001101b = 00111111b
-11110010b ^ 11001110b = 00111100b
-11110010b ^ 11001111b = 00111101b
-11110010b ^ 11010000b = 00100010b
-11110010b ^ 11010001b = 00100011b
-11110010b ^ 11010010b = 00100000b
-11110010b ^ 11010011b = 00100001b
-11110010b ^ 11010100b = 00100110b
-11110010b ^ 11010101b = 00100111b
-11110010b ^ 11010110b = 00100100b
-11110010b ^ 11010111b = 00100101b
-11110010b ^ 11011000b = 00101010b
-11110010b ^ 11011001b = 00101011b
-11110010b ^ 11011010b = 00101000b
-11110010b ^ 11011011b = 00101001b
-11110010b ^ 11011100b = 00101110b
-11110010b ^ 11011101b = 00101111b
-11110010b ^ 11011110b = 00101100b
-11110010b ^ 11011111b = 00101101b
-11110010b ^ 11100000b = 00010010b
-11110010b ^ 11100001b = 00010011b
-11110010b ^ 11100010b = 00010000b
-11110010b ^ 11100011b = 00010001b
-11110010b ^ 11100100b = 00010110b
-11110010b ^ 11100101b = 00010111b
-11110010b ^ 11100110b = 00010100b
-11110010b ^ 11100111b = 00010101b
-11110010b ^ 11101000b = 00011010b
-11110010b ^ 11101001b = 00011011b
-11110010b ^ 11101010b = 00011000b
-11110010b ^ 11101011b = 00011001b
-11110010b ^ 11101100b = 00011110b
-11110010b ^ 11101101b = 00011111b
-11110010b ^ 11101110b = 00011100b
-11110010b ^ 11101111b = 00011101b
-11110010b ^ 11110000b = 00000010b
-11110010b ^ 11110001b = 00000011b
-11110010b ^ 11110010b = 00000000b
-11110010b ^ 11110011b = 00000001b
-11110010b ^ 11110100b = 00000110b
-11110010b ^ 11110101b = 00000111b
-11110010b ^ 11110110b = 00000100b
-11110010b ^ 11110111b = 00000101b
-11110010b ^ 11111000b = 00001010b
-11110010b ^ 11111001b = 00001011b
-11110010b ^ 11111010b = 00001000b
-11110010b ^ 11111011b = 00001001b
-11110010b ^ 11111100b = 00001110b
-11110010b ^ 11111101b = 00001111b
-11110010b ^ 11111110b = 00001100b
-11110010b ^ 11111111b = 00001101b
-11110010b ^ 00000000b = 11110010b
-11110010b ^ 00000001b = 11110011b
-11110010b ^ 00000010b = 11110000b
-11110010b ^ 00000011b = 11110001b
-11110010b ^ 00000100b = 11110110b
-11110010b ^ 00000101b = 11110111b
-11110010b ^ 00000110b = 11110100b
-11110010b ^ 00000111b = 11110101b
-11110010b ^ 00001000b = 11111010b
-11110010b ^ 00001001b = 11111011b
-11110010b ^ 00001010b = 11111000b
-11110010b ^ 00001011b = 11111001b
-11110010b ^ 00001100b = 11111110b
-11110010b ^ 00001101b = 11111111b
-11110010b ^ 00001110b = 11111100b
-11110010b ^ 00001111b = 11111101b
-11110010b ^ 00010000b = 11100010b
-11110010b ^ 00010001b = 11100011b
-11110010b ^ 00010010b = 11100000b
-11110010b ^ 00010011b = 11100001b
-11110010b ^ 00010100b = 11100110b
-11110010b ^ 00010101b = 11100111b
-11110010b ^ 00010110b = 11100100b
-11110010b ^ 00010111b = 11100101b
-11110010b ^ 00011000b = 11101010b
-11110010b ^ 00011001b = 11101011b
-11110010b ^ 00011010b = 11101000b
-11110010b ^ 00011011b = 11101001b
-11110010b ^ 00011100b = 11101110b
-11110010b ^ 00011101b = 11101111b
-11110010b ^ 00011110b = 11101100b
-11110010b ^ 00011111b = 11101101b
-11110010b ^ 00100000b = 11010010b
-11110010b ^ 00100001b = 11010011b
-11110010b ^ 00100010b = 11010000b
-11110010b ^ 00100011b = 11010001b
-11110010b ^ 00100100b = 11010110b
-11110010b ^ 00100101b = 11010111b
-11110010b ^ 00100110b = 11010100b
-11110010b ^ 00100111b = 11010101b
-11110010b ^ 00101000b = 11011010b
-11110010b ^ 00101001b = 11011011b
-11110010b ^ 00101010b = 11011000b
-11110010b ^ 00101011b = 11011001b
-11110010b ^ 00101100b = 11011110b
-11110010b ^ 00101101b = 11011111b
-11110010b ^ 00101110b = 11011100b
-11110010b ^ 00101111b = 11011101b
-11110010b ^ 00110000b = 11000010b
-11110010b ^ 00110001b = 11000011b
-11110010b ^ 00110010b = 11000000b
-11110010b ^ 00110011b = 11000001b
-11110010b ^ 00110100b = 11000110b
-11110010b ^ 00110101b = 11000111b
-11110010b ^ 00110110b = 11000100b
-11110010b ^ 00110111b = 11000101b
-11110010b ^ 00111000b = 11001010b
-11110010b ^ 00111001b = 11001011b
-11110010b ^ 00111010b = 11001000b
-11110010b ^ 00111011b = 11001001b
-11110010b ^ 00111100b = 11001110b
-11110010b ^ 00111101b = 11001111b
-11110010b ^ 00111110b = 11001100b
-11110010b ^ 00111111b = 11001101b
-11110010b ^ 01000000b = 10110010b
-11110010b ^ 01000001b = 10110011b
-11110010b ^ 01000010b = 10110000b
-11110010b ^ 01000011b = 10110001b
-11110010b ^ 01000100b = 10110110b
-11110010b ^ 01000101b = 10110111b
-11110010b ^ 01000110b = 10110100b
-11110010b ^ 01000111b = 10110101b
-11110010b ^ 01001000b = 10111010b
-11110010b ^ 01001001b = 10111011b
-11110010b ^ 01001010b = 10111000b
-11110010b ^ 01001011b = 10111001b
-11110010b ^ 01001100b = 10111110b
-11110010b ^ 01001101b = 10111111b
-11110010b ^ 01001110b = 10111100b
-11110010b ^ 01001111b = 10111101b
-11110010b ^ 01010000b = 10100010b
-11110010b ^ 01010001b = 10100011b
-11110010b ^ 01010010b = 10100000b
-11110010b ^ 01010011b = 10100001b
-11110010b ^ 01010100b = 10100110b
-11110010b ^ 01010101b = 10100111b
-11110010b ^ 01010110b = 10100100b
-11110010b ^ 01010111b = 10100101b
-11110010b ^ 01011000b = 10101010b
-11110010b ^ 01011001b = 10101011b
-11110010b ^ 01011010b = 10101000b
-11110010b ^ 01011011b = 10101001b
-11110010b ^ 01011100b = 10101110b
-11110010b ^ 01011101b = 10101111b
-11110010b ^ 01011110b = 10101100b
-11110010b ^ 01011111b = 10101101b
-11110010b ^ 01100000b = 10010010b
-11110010b ^ 01100001b = 10010011b
-11110010b ^ 01100010b = 10010000b
-11110010b ^ 01100011b = 10010001b
-11110010b ^ 01100100b = 10010110b
-11110010b ^ 01100101b = 10010111b
-11110010b ^ 01100110b = 10010100b
-11110010b ^ 01100111b = 10010101b
-11110010b ^ 01101000b = 10011010b
-11110010b ^ 01101001b = 10011011b
-11110010b ^ 01101010b = 10011000b
-11110010b ^ 01101011b = 10011001b
-11110010b ^ 01101100b = 10011110b
-11110010b ^ 01101101b = 10011111b
-11110010b ^ 01101110b = 10011100b
-11110010b ^ 01101111b = 10011101b
-11110010b ^ 01110000b = 10000010b
-11110010b ^ 01110001b = 10000011b
-11110010b ^ 01110010b = 10000000b
-11110010b ^ 01110011b = 10000001b
-11110010b ^ 01110100b = 10000110b
-11110010b ^ 01110101b = 10000111b
-11110010b ^ 01110110b = 10000100b
-11110010b ^ 01110111b = 10000101b
-11110010b ^ 01111000b = 10001010b
-11110010b ^ 01111001b = 10001011b
-11110010b ^ 01111010b = 10001000b
-11110010b ^ 01111011b = 10001001b
-11110010b ^ 01111100b = 10001110b
-11110010b ^ 01111101b = 10001111b
-11110010b ^ 01111110b = 10001100b
-11110011b ^ 10000000b = 01110011b
-11110011b ^ 10000001b = 01110010b
-11110011b ^ 10000010b = 01110001b
-11110011b ^ 10000011b = 01110000b
-11110011b ^ 10000100b = 01110111b
-11110011b ^ 10000101b = 01110110b
-11110011b ^ 10000110b = 01110101b
-11110011b ^ 10000111b = 01110100b
-11110011b ^ 10001000b = 01111011b
-11110011b ^ 10001001b = 01111010b
-11110011b ^ 10001010b = 01111001b
-11110011b ^ 10001011b = 01111000b
-11110011b ^ 10001100b = 01111111b
-11110011b ^ 10001101b = 01111110b
-11110011b ^ 10001110b = 01111101b
-11110011b ^ 10001111b = 01111100b
-11110011b ^ 10010000b = 01100011b
-11110011b ^ 10010001b = 01100010b
-11110011b ^ 10010010b = 01100001b
-11110011b ^ 10010011b = 01100000b
-11110011b ^ 10010100b = 01100111b
-11110011b ^ 10010101b = 01100110b
-11110011b ^ 10010110b = 01100101b
-11110011b ^ 10010111b = 01100100b
-11110011b ^ 10011000b = 01101011b
-11110011b ^ 10011001b = 01101010b
-11110011b ^ 10011010b = 01101001b
-11110011b ^ 10011011b = 01101000b
-11110011b ^ 10011100b = 01101111b
-11110011b ^ 10011101b = 01101110b
-11110011b ^ 10011110b = 01101101b
-11110011b ^ 10011111b = 01101100b
-11110011b ^ 10100000b = 01010011b
-11110011b ^ 10100001b = 01010010b
-11110011b ^ 10100010b = 01010001b
-11110011b ^ 10100011b = 01010000b
-11110011b ^ 10100100b = 01010111b
-11110011b ^ 10100101b = 01010110b
-11110011b ^ 10100110b = 01010101b
-11110011b ^ 10100111b = 01010100b
-11110011b ^ 10101000b = 01011011b
-11110011b ^ 10101001b = 01011010b
-11110011b ^ 10101010b = 01011001b
-11110011b ^ 10101011b = 01011000b
-11110011b ^ 10101100b = 01011111b
-11110011b ^ 10101101b = 01011110b
-11110011b ^ 10101110b = 01011101b
-11110011b ^ 10101111b = 01011100b
-11110011b ^ 10110000b = 01000011b
-11110011b ^ 10110001b = 01000010b
-11110011b ^ 10110010b = 01000001b
-11110011b ^ 10110011b = 01000000b
-11110011b ^ 10110100b = 01000111b
-11110011b ^ 10110101b = 01000110b
-11110011b ^ 10110110b = 01000101b
-11110011b ^ 10110111b = 01000100b
-11110011b ^ 10111000b = 01001011b
-11110011b ^ 10111001b = 01001010b
-11110011b ^ 10111010b = 01001001b
-11110011b ^ 10111011b = 01001000b
-11110011b ^ 10111100b = 01001111b
-11110011b ^ 10111101b = 01001110b
-11110011b ^ 10111110b = 01001101b
-11110011b ^ 10111111b = 01001100b
-11110011b ^ 11000000b = 00110011b
-11110011b ^ 11000001b = 00110010b
-11110011b ^ 11000010b = 00110001b
-11110011b ^ 11000011b = 00110000b
-11110011b ^ 11000100b = 00110111b
-11110011b ^ 11000101b = 00110110b
-11110011b ^ 11000110b = 00110101b
-11110011b ^ 11000111b = 00110100b
-11110011b ^ 11001000b = 00111011b
-11110011b ^ 11001001b = 00111010b
-11110011b ^ 11001010b = 00111001b
-11110011b ^ 11001011b = 00111000b
-11110011b ^ 11001100b = 00111111b
-11110011b ^ 11001101b = 00111110b
-11110011b ^ 11001110b = 00111101b
-11110011b ^ 11001111b = 00111100b
-11110011b ^ 11010000b = 00100011b
-11110011b ^ 11010001b = 00100010b
-11110011b ^ 11010010b = 00100001b
-11110011b ^ 11010011b = 00100000b
-11110011b ^ 11010100b = 00100111b
-11110011b ^ 11010101b = 00100110b
-11110011b ^ 11010110b = 00100101b
-11110011b ^ 11010111b = 00100100b
-11110011b ^ 11011000b = 00101011b
-11110011b ^ 11011001b = 00101010b
-11110011b ^ 11011010b = 00101001b
-11110011b ^ 11011011b = 00101000b
-11110011b ^ 11011100b = 00101111b
-11110011b ^ 11011101b = 00101110b
-11110011b ^ 11011110b = 00101101b
-11110011b ^ 11011111b = 00101100b
-11110011b ^ 11100000b = 00010011b
-11110011b ^ 11100001b = 00010010b
-11110011b ^ 11100010b = 00010001b
-11110011b ^ 11100011b = 00010000b
-11110011b ^ 11100100b = 00010111b
-11110011b ^ 11100101b = 00010110b
-11110011b ^ 11100110b = 00010101b
-11110011b ^ 11100111b = 00010100b
-11110011b ^ 11101000b = 00011011b
-11110011b ^ 11101001b = 00011010b
-11110011b ^ 11101010b = 00011001b
-11110011b ^ 11101011b = 00011000b
-11110011b ^ 11101100b = 00011111b
-11110011b ^ 11101101b = 00011110b
-11110011b ^ 11101110b = 00011101b
-11110011b ^ 11101111b = 00011100b
-11110011b ^ 11110000b = 00000011b
-11110011b ^ 11110001b = 00000010b
-11110011b ^ 11110010b = 00000001b
-11110011b ^ 11110011b = 00000000b
-11110011b ^ 11110100b = 00000111b
-11110011b ^ 11110101b = 00000110b
-11110011b ^ 11110110b = 00000101b
-11110011b ^ 11110111b = 00000100b
-11110011b ^ 11111000b = 00001011b
-11110011b ^ 11111001b = 00001010b
-11110011b ^ 11111010b = 00001001b
-11110011b ^ 11111011b = 00001000b
-11110011b ^ 11111100b = 00001111b
-11110011b ^ 11111101b = 00001110b
-11110011b ^ 11111110b = 00001101b
-11110011b ^ 11111111b = 00001100b
-11110011b ^ 00000000b = 11110011b
-11110011b ^ 00000001b = 11110010b
-11110011b ^ 00000010b = 11110001b
-11110011b ^ 00000011b = 11110000b
-11110011b ^ 00000100b = 11110111b
-11110011b ^ 00000101b = 11110110b
-11110011b ^ 00000110b = 11110101b
-11110011b ^ 00000111b = 11110100b
-11110011b ^ 00001000b = 11111011b
-11110011b ^ 00001001b = 11111010b
-11110011b ^ 00001010b = 11111001b
-11110011b ^ 00001011b = 11111000b
-11110011b ^ 00001100b = 11111111b
-11110011b ^ 00001101b = 11111110b
-11110011b ^ 00001110b = 11111101b
-11110011b ^ 00001111b = 11111100b
-11110011b ^ 00010000b = 11100011b
-11110011b ^ 00010001b = 11100010b
-11110011b ^ 00010010b = 11100001b
-11110011b ^ 00010011b = 11100000b
-11110011b ^ 00010100b = 11100111b
-11110011b ^ 00010101b = 11100110b
-11110011b ^ 00010110b = 11100101b
-11110011b ^ 00010111b = 11100100b
-11110011b ^ 00011000b = 11101011b
-11110011b ^ 00011001b = 11101010b
-11110011b ^ 00011010b = 11101001b
-11110011b ^ 00011011b = 11101000b
-11110011b ^ 00011100b = 11101111b
-11110011b ^ 00011101b = 11101110b
-11110011b ^ 00011110b = 11101101b
-11110011b ^ 00011111b = 11101100b
-11110011b ^ 00100000b = 11010011b
-11110011b ^ 00100001b = 11010010b
-11110011b ^ 00100010b = 11010001b
-11110011b ^ 00100011b = 11010000b
-11110011b ^ 00100100b = 11010111b
-11110011b ^ 00100101b = 11010110b
-11110011b ^ 00100110b = 11010101b
-11110011b ^ 00100111b = 11010100b
-11110011b ^ 00101000b = 11011011b
-11110011b ^ 00101001b = 11011010b
-11110011b ^ 00101010b = 11011001b
-11110011b ^ 00101011b = 11011000b
-11110011b ^ 00101100b = 11011111b
-11110011b ^ 00101101b = 11011110b
-11110011b ^ 00101110b = 11011101b
-11110011b ^ 00101111b = 11011100b
-11110011b ^ 00110000b = 11000011b
-11110011b ^ 00110001b = 11000010b
-11110011b ^ 00110010b = 11000001b
-11110011b ^ 00110011b = 11000000b
-11110011b ^ 00110100b = 11000111b
-11110011b ^ 00110101b = 11000110b
-11110011b ^ 00110110b = 11000101b
-11110011b ^ 00110111b = 11000100b
-11110011b ^ 00111000b = 11001011b
-11110011b ^ 00111001b = 11001010b
-11110011b ^ 00111010b = 11001001b
-11110011b ^ 00111011b = 11001000b
-11110011b ^ 00111100b = 11001111b
-11110011b ^ 00111101b = 11001110b
-11110011b ^ 00111110b = 11001101b
-11110011b ^ 00111111b = 11001100b
-11110011b ^ 01000000b = 10110011b
-11110011b ^ 01000001b = 10110010b
-11110011b ^ 01000010b = 10110001b
-11110011b ^ 01000011b = 10110000b
-11110011b ^ 01000100b = 10110111b
-11110011b ^ 01000101b = 10110110b
-11110011b ^ 01000110b = 10110101b
-11110011b ^ 01000111b = 10110100b
-11110011b ^ 01001000b = 10111011b
-11110011b ^ 01001001b = 10111010b
-11110011b ^ 01001010b = 10111001b
-11110011b ^ 01001011b = 10111000b
-11110011b ^ 01001100b = 10111111b
-11110011b ^ 01001101b = 10111110b
-11110011b ^ 01001110b = 10111101b
-11110011b ^ 01001111b = 10111100b
-11110011b ^ 01010000b = 10100011b
-11110011b ^ 01010001b = 10100010b
-11110011b ^ 01010010b = 10100001b
-11110011b ^ 01010011b = 10100000b
-11110011b ^ 01010100b = 10100111b
-11110011b ^ 01010101b = 10100110b
-11110011b ^ 01010110b = 10100101b
-11110011b ^ 01010111b = 10100100b
-11110011b ^ 01011000b = 10101011b
-11110011b ^ 01011001b = 10101010b
-11110011b ^ 01011010b = 10101001b
-11110011b ^ 01011011b = 10101000b
-11110011b ^ 01011100b = 10101111b
-11110011b ^ 01011101b = 10101110b
-11110011b ^ 01011110b = 10101101b
-11110011b ^ 01011111b = 10101100b
-11110011b ^ 01100000b = 10010011b
-11110011b ^ 01100001b = 10010010b
-11110011b ^ 01100010b = 10010001b
-11110011b ^ 01100011b = 10010000b
-11110011b ^ 01100100b = 10010111b
-11110011b ^ 01100101b = 10010110b
-11110011b ^ 01100110b = 10010101b
-11110011b ^ 01100111b = 10010100b
-11110011b ^ 01101000b = 10011011b
-11110011b ^ 01101001b = 10011010b
-11110011b ^ 01101010b = 10011001b
-11110011b ^ 01101011b = 10011000b
-11110011b ^ 01101100b = 10011111b
-11110011b ^ 01101101b = 10011110b
-11110011b ^ 01101110b = 10011101b
-11110011b ^ 01101111b = 10011100b
-11110011b ^ 01110000b = 10000011b
-11110011b ^ 01110001b = 10000010b
-11110011b ^ 01110010b = 10000001b
-11110011b ^ 01110011b = 10000000b
-11110011b ^ 01110100b = 10000111b
-11110011b ^ 01110101b = 10000110b
-11110011b ^ 01110110b = 10000101b
-11110011b ^ 01110111b = 10000100b
-11110011b ^ 01111000b = 10001011b
-11110011b ^ 01111001b = 10001010b
-11110011b ^ 01111010b = 10001001b
-11110011b ^ 01111011b = 10001000b
-11110011b ^ 01111100b = 10001111b
-11110011b ^ 01111101b = 10001110b
-11110011b ^ 01111110b = 10001101b
-11110100b ^ 10000000b = 01110100b
-11110100b ^ 10000001b = 01110101b
-11110100b ^ 10000010b = 01110110b
-11110100b ^ 10000011b = 01110111b
-11110100b ^ 10000100b = 01110000b
-11110100b ^ 10000101b = 01110001b
-11110100b ^ 10000110b = 01110010b
-11110100b ^ 10000111b = 01110011b
-11110100b ^ 10001000b = 01111100b
-11110100b ^ 10001001b = 01111101b
-11110100b ^ 10001010b = 01111110b
-11110100b ^ 10001011b = 01111111b
-11110100b ^ 10001100b = 01111000b
-11110100b ^ 10001101b = 01111001b
-11110100b ^ 10001110b = 01111010b
-11110100b ^ 10001111b = 01111011b
-11110100b ^ 10010000b = 01100100b
-11110100b ^ 10010001b = 01100101b
-11110100b ^ 10010010b = 01100110b
-11110100b ^ 10010011b = 01100111b
-11110100b ^ 10010100b = 01100000b
-11110100b ^ 10010101b = 01100001b
-11110100b ^ 10010110b = 01100010b
-11110100b ^ 10010111b = 01100011b
-11110100b ^ 10011000b = 01101100b
-11110100b ^ 10011001b = 01101101b
-11110100b ^ 10011010b = 01101110b
-11110100b ^ 10011011b = 01101111b
-11110100b ^ 10011100b = 01101000b
-11110100b ^ 10011101b = 01101001b
-11110100b ^ 10011110b = 01101010b
-11110100b ^ 10011111b = 01101011b
-11110100b ^ 10100000b = 01010100b
-11110100b ^ 10100001b = 01010101b
-11110100b ^ 10100010b = 01010110b
-11110100b ^ 10100011b = 01010111b
-11110100b ^ 10100100b = 01010000b
-11110100b ^ 10100101b = 01010001b
-11110100b ^ 10100110b = 01010010b
-11110100b ^ 10100111b = 01010011b
-11110100b ^ 10101000b = 01011100b
-11110100b ^ 10101001b = 01011101b
-11110100b ^ 10101010b = 01011110b
-11110100b ^ 10101011b = 01011111b
-11110100b ^ 10101100b = 01011000b
-11110100b ^ 10101101b = 01011001b
-11110100b ^ 10101110b = 01011010b
-11110100b ^ 10101111b = 01011011b
-11110100b ^ 10110000b = 01000100b
-11110100b ^ 10110001b = 01000101b
-11110100b ^ 10110010b = 01000110b
-11110100b ^ 10110011b = 01000111b
-11110100b ^ 10110100b = 01000000b
-11110100b ^ 10110101b = 01000001b
-11110100b ^ 10110110b = 01000010b
-11110100b ^ 10110111b = 01000011b
-11110100b ^ 10111000b = 01001100b
-11110100b ^ 10111001b = 01001101b
-11110100b ^ 10111010b = 01001110b
-11110100b ^ 10111011b = 01001111b
-11110100b ^ 10111100b = 01001000b
-11110100b ^ 10111101b = 01001001b
-11110100b ^ 10111110b = 01001010b
-11110100b ^ 10111111b = 01001011b
-11110100b ^ 11000000b = 00110100b
-11110100b ^ 11000001b = 00110101b
-11110100b ^ 11000010b = 00110110b
-11110100b ^ 11000011b = 00110111b
-11110100b ^ 11000100b = 00110000b
-11110100b ^ 11000101b = 00110001b
-11110100b ^ 11000110b = 00110010b
-11110100b ^ 11000111b = 00110011b
-11110100b ^ 11001000b = 00111100b
-11110100b ^ 11001001b = 00111101b
-11110100b ^ 11001010b = 00111110b
-11110100b ^ 11001011b = 00111111b
-11110100b ^ 11001100b = 00111000b
-11110100b ^ 11001101b = 00111001b
-11110100b ^ 11001110b = 00111010b
-11110100b ^ 11001111b = 00111011b
-11110100b ^ 11010000b = 00100100b
-11110100b ^ 11010001b = 00100101b
-11110100b ^ 11010010b = 00100110b
-11110100b ^ 11010011b = 00100111b
-11110100b ^ 11010100b = 00100000b
-11110100b ^ 11010101b = 00100001b
-11110100b ^ 11010110b = 00100010b
-11110100b ^ 11010111b = 00100011b
-11110100b ^ 11011000b = 00101100b
-11110100b ^ 11011001b = 00101101b
-11110100b ^ 11011010b = 00101110b
-11110100b ^ 11011011b = 00101111b
-11110100b ^ 11011100b = 00101000b
-11110100b ^ 11011101b = 00101001b
-11110100b ^ 11011110b = 00101010b
-11110100b ^ 11011111b = 00101011b
-11110100b ^ 11100000b = 00010100b
-11110100b ^ 11100001b = 00010101b
-11110100b ^ 11100010b = 00010110b
-11110100b ^ 11100011b = 00010111b
-11110100b ^ 11100100b = 00010000b
-11110100b ^ 11100101b = 00010001b
-11110100b ^ 11100110b = 00010010b
-11110100b ^ 11100111b = 00010011b
-11110100b ^ 11101000b = 00011100b
-11110100b ^ 11101001b = 00011101b
-11110100b ^ 11101010b = 00011110b
-11110100b ^ 11101011b = 00011111b
-11110100b ^ 11101100b = 00011000b
-11110100b ^ 11101101b = 00011001b
-11110100b ^ 11101110b = 00011010b
-11110100b ^ 11101111b = 00011011b
-11110100b ^ 11110000b = 00000100b
-11110100b ^ 11110001b = 00000101b
-11110100b ^ 11110010b = 00000110b
-11110100b ^ 11110011b = 00000111b
-11110100b ^ 11110100b = 00000000b
-11110100b ^ 11110101b = 00000001b
-11110100b ^ 11110110b = 00000010b
-11110100b ^ 11110111b = 00000011b
-11110100b ^ 11111000b = 00001100b
-11110100b ^ 11111001b = 00001101b
-11110100b ^ 11111010b = 00001110b
-11110100b ^ 11111011b = 00001111b
-11110100b ^ 11111100b = 00001000b
-11110100b ^ 11111101b = 00001001b
-11110100b ^ 11111110b = 00001010b
-11110100b ^ 11111111b = 00001011b
-11110100b ^ 00000000b = 11110100b
-11110100b ^ 00000001b = 11110101b
-11110100b ^ 00000010b = 11110110b
-11110100b ^ 00000011b = 11110111b
-11110100b ^ 00000100b = 11110000b
-11110100b ^ 00000101b = 11110001b
-11110100b ^ 00000110b = 11110010b
-11110100b ^ 00000111b = 11110011b
-11110100b ^ 00001000b = 11111100b
-11110100b ^ 00001001b = 11111101b
-11110100b ^ 00001010b = 11111110b
-11110100b ^ 00001011b = 11111111b
-11110100b ^ 00001100b = 11111000b
-11110100b ^ 00001101b = 11111001b
-11110100b ^ 00001110b = 11111010b
-11110100b ^ 00001111b = 11111011b
-11110100b ^ 00010000b = 11100100b
-11110100b ^ 00010001b = 11100101b
-11110100b ^ 00010010b = 11100110b
-11110100b ^ 00010011b = 11100111b
-11110100b ^ 00010100b = 11100000b
-11110100b ^ 00010101b = 11100001b
-11110100b ^ 00010110b = 11100010b
-11110100b ^ 00010111b = 11100011b
-11110100b ^ 00011000b = 11101100b
-11110100b ^ 00011001b = 11101101b
-11110100b ^ 00011010b = 11101110b
-11110100b ^ 00011011b = 11101111b
-11110100b ^ 00011100b = 11101000b
-11110100b ^ 00011101b = 11101001b
-11110100b ^ 00011110b = 11101010b
-11110100b ^ 00011111b = 11101011b
-11110100b ^ 00100000b = 11010100b
-11110100b ^ 00100001b = 11010101b
-11110100b ^ 00100010b = 11010110b
-11110100b ^ 00100011b = 11010111b
-11110100b ^ 00100100b = 11010000b
-11110100b ^ 00100101b = 11010001b
-11110100b ^ 00100110b = 11010010b
-11110100b ^ 00100111b = 11010011b
-11110100b ^ 00101000b = 11011100b
-11110100b ^ 00101001b = 11011101b
-11110100b ^ 00101010b = 11011110b
-11110100b ^ 00101011b = 11011111b
-11110100b ^ 00101100b = 11011000b
-11110100b ^ 00101101b = 11011001b
-11110100b ^ 00101110b = 11011010b
-11110100b ^ 00101111b = 11011011b
-11110100b ^ 00110000b = 11000100b
-11110100b ^ 00110001b = 11000101b
-11110100b ^ 00110010b = 11000110b
-11110100b ^ 00110011b = 11000111b
-11110100b ^ 00110100b = 11000000b
-11110100b ^ 00110101b = 11000001b
-11110100b ^ 00110110b = 11000010b
-11110100b ^ 00110111b = 11000011b
-11110100b ^ 00111000b = 11001100b
-11110100b ^ 00111001b = 11001101b
-11110100b ^ 00111010b = 11001110b
-11110100b ^ 00111011b = 11001111b
-11110100b ^ 00111100b = 11001000b
-11110100b ^ 00111101b = 11001001b
-11110100b ^ 00111110b = 11001010b
-11110100b ^ 00111111b = 11001011b
-11110100b ^ 01000000b = 10110100b
-11110100b ^ 01000001b = 10110101b
-11110100b ^ 01000010b = 10110110b
-11110100b ^ 01000011b = 10110111b
-11110100b ^ 01000100b = 10110000b
-11110100b ^ 01000101b = 10110001b
-11110100b ^ 01000110b = 10110010b
-11110100b ^ 01000111b = 10110011b
-11110100b ^ 01001000b = 10111100b
-11110100b ^ 01001001b = 10111101b
-11110100b ^ 01001010b = 10111110b
-11110100b ^ 01001011b = 10111111b
-11110100b ^ 01001100b = 10111000b
-11110100b ^ 01001101b = 10111001b
-11110100b ^ 01001110b = 10111010b
-11110100b ^ 01001111b = 10111011b
-11110100b ^ 01010000b = 10100100b
-11110100b ^ 01010001b = 10100101b
-11110100b ^ 01010010b = 10100110b
-11110100b ^ 01010011b = 10100111b
-11110100b ^ 01010100b = 10100000b
-11110100b ^ 01010101b = 10100001b
-11110100b ^ 01010110b = 10100010b
-11110100b ^ 01010111b = 10100011b
-11110100b ^ 01011000b = 10101100b
-11110100b ^ 01011001b = 10101101b
-11110100b ^ 01011010b = 10101110b
-11110100b ^ 01011011b = 10101111b
-11110100b ^ 01011100b = 10101000b
-11110100b ^ 01011101b = 10101001b
-11110100b ^ 01011110b = 10101010b
-11110100b ^ 01011111b = 10101011b
-11110100b ^ 01100000b = 10010100b
-11110100b ^ 01100001b = 10010101b
-11110100b ^ 01100010b = 10010110b
-11110100b ^ 01100011b = 10010111b
-11110100b ^ 01100100b = 10010000b
-11110100b ^ 01100101b = 10010001b
-11110100b ^ 01100110b = 10010010b
-11110100b ^ 01100111b = 10010011b
-11110100b ^ 01101000b = 10011100b
-11110100b ^ 01101001b = 10011101b
-11110100b ^ 01101010b = 10011110b
-11110100b ^ 01101011b = 10011111b
-11110100b ^ 01101100b = 10011000b
-11110100b ^ 01101101b = 10011001b
-11110100b ^ 01101110b = 10011010b
-11110100b ^ 01101111b = 10011011b
-11110100b ^ 01110000b = 10000100b
-11110100b ^ 01110001b = 10000101b
-11110100b ^ 01110010b = 10000110b
-11110100b ^ 01110011b = 10000111b
-11110100b ^ 01110100b = 10000000b
-11110100b ^ 01110101b = 10000001b
-11110100b ^ 01110110b = 10000010b
-11110100b ^ 01110111b = 10000011b
-11110100b ^ 01111000b = 10001100b
-11110100b ^ 01111001b = 10001101b
-11110100b ^ 01111010b = 10001110b
-11110100b ^ 01111011b = 10001111b
-11110100b ^ 01111100b = 10001000b
-11110100b ^ 01111101b = 10001001b
-11110100b ^ 01111110b = 10001010b
-11110101b ^ 10000000b = 01110101b
-11110101b ^ 10000001b = 01110100b
-11110101b ^ 10000010b = 01110111b
-11110101b ^ 10000011b = 01110110b
-11110101b ^ 10000100b = 01110001b
-11110101b ^ 10000101b = 01110000b
-11110101b ^ 10000110b = 01110011b
-11110101b ^ 10000111b = 01110010b
-11110101b ^ 10001000b = 01111101b
-11110101b ^ 10001001b = 01111100b
-11110101b ^ 10001010b = 01111111b
-11110101b ^ 10001011b = 01111110b
-11110101b ^ 10001100b = 01111001b
-11110101b ^ 10001101b = 01111000b
-11110101b ^ 10001110b = 01111011b
-11110101b ^ 10001111b = 01111010b
-11110101b ^ 10010000b = 01100101b
-11110101b ^ 10010001b = 01100100b
-11110101b ^ 10010010b = 01100111b
-11110101b ^ 10010011b = 01100110b
-11110101b ^ 10010100b = 01100001b
-11110101b ^ 10010101b = 01100000b
-11110101b ^ 10010110b = 01100011b
-11110101b ^ 10010111b = 01100010b
-11110101b ^ 10011000b = 01101101b
-11110101b ^ 10011001b = 01101100b
-11110101b ^ 10011010b = 01101111b
-11110101b ^ 10011011b = 01101110b
-11110101b ^ 10011100b = 01101001b
-11110101b ^ 10011101b = 01101000b
-11110101b ^ 10011110b = 01101011b
-11110101b ^ 10011111b = 01101010b
-11110101b ^ 10100000b = 01010101b
-11110101b ^ 10100001b = 01010100b
-11110101b ^ 10100010b = 01010111b
-11110101b ^ 10100011b = 01010110b
-11110101b ^ 10100100b = 01010001b
-11110101b ^ 10100101b = 01010000b
-11110101b ^ 10100110b = 01010011b
-11110101b ^ 10100111b = 01010010b
-11110101b ^ 10101000b = 01011101b
-11110101b ^ 10101001b = 01011100b
-11110101b ^ 10101010b = 01011111b
-11110101b ^ 10101011b = 01011110b
-11110101b ^ 10101100b = 01011001b
-11110101b ^ 10101101b = 01011000b
-11110101b ^ 10101110b = 01011011b
-11110101b ^ 10101111b = 01011010b
-11110101b ^ 10110000b = 01000101b
-11110101b ^ 10110001b = 01000100b
-11110101b ^ 10110010b = 01000111b
-11110101b ^ 10110011b = 01000110b
-11110101b ^ 10110100b = 01000001b
-11110101b ^ 10110101b = 01000000b
-11110101b ^ 10110110b = 01000011b
-11110101b ^ 10110111b = 01000010b
-11110101b ^ 10111000b = 01001101b
-11110101b ^ 10111001b = 01001100b
-11110101b ^ 10111010b = 01001111b
-11110101b ^ 10111011b = 01001110b
-11110101b ^ 10111100b = 01001001b
-11110101b ^ 10111101b = 01001000b
-11110101b ^ 10111110b = 01001011b
-11110101b ^ 10111111b = 01001010b
-11110101b ^ 11000000b = 00110101b
-11110101b ^ 11000001b = 00110100b
-11110101b ^ 11000010b = 00110111b
-11110101b ^ 11000011b = 00110110b
-11110101b ^ 11000100b = 00110001b
-11110101b ^ 11000101b = 00110000b
-11110101b ^ 11000110b = 00110011b
-11110101b ^ 11000111b = 00110010b
-11110101b ^ 11001000b = 00111101b
-11110101b ^ 11001001b = 00111100b
-11110101b ^ 11001010b = 00111111b
-11110101b ^ 11001011b = 00111110b
-11110101b ^ 11001100b = 00111001b
-11110101b ^ 11001101b = 00111000b
-11110101b ^ 11001110b = 00111011b
-11110101b ^ 11001111b = 00111010b
-11110101b ^ 11010000b = 00100101b
-11110101b ^ 11010001b = 00100100b
-11110101b ^ 11010010b = 00100111b
-11110101b ^ 11010011b = 00100110b
-11110101b ^ 11010100b = 00100001b
-11110101b ^ 11010101b = 00100000b
-11110101b ^ 11010110b = 00100011b
-11110101b ^ 11010111b = 00100010b
-11110101b ^ 11011000b = 00101101b
-11110101b ^ 11011001b = 00101100b
-11110101b ^ 11011010b = 00101111b
-11110101b ^ 11011011b = 00101110b
-11110101b ^ 11011100b = 00101001b
-11110101b ^ 11011101b = 00101000b
-11110101b ^ 11011110b = 00101011b
-11110101b ^ 11011111b = 00101010b
-11110101b ^ 11100000b = 00010101b
-11110101b ^ 11100001b = 00010100b
-11110101b ^ 11100010b = 00010111b
-11110101b ^ 11100011b = 00010110b
-11110101b ^ 11100100b = 00010001b
-11110101b ^ 11100101b = 00010000b
-11110101b ^ 11100110b = 00010011b
-11110101b ^ 11100111b = 00010010b
-11110101b ^ 11101000b = 00011101b
-11110101b ^ 11101001b = 00011100b
-11110101b ^ 11101010b = 00011111b
-11110101b ^ 11101011b = 00011110b
-11110101b ^ 11101100b = 00011001b
-11110101b ^ 11101101b = 00011000b
-11110101b ^ 11101110b = 00011011b
-11110101b ^ 11101111b = 00011010b
-11110101b ^ 11110000b = 00000101b
-11110101b ^ 11110001b = 00000100b
-11110101b ^ 11110010b = 00000111b
-11110101b ^ 11110011b = 00000110b
-11110101b ^ 11110100b = 00000001b
-11110101b ^ 11110101b = 00000000b
-11110101b ^ 11110110b = 00000011b
-11110101b ^ 11110111b = 00000010b
-11110101b ^ 11111000b = 00001101b
-11110101b ^ 11111001b = 00001100b
-11110101b ^ 11111010b = 00001111b
-11110101b ^ 11111011b = 00001110b
-11110101b ^ 11111100b = 00001001b
-11110101b ^ 11111101b = 00001000b
-11110101b ^ 11111110b = 00001011b
-11110101b ^ 11111111b = 00001010b
-11110101b ^ 00000000b = 11110101b
-11110101b ^ 00000001b = 11110100b
-11110101b ^ 00000010b = 11110111b
-11110101b ^ 00000011b = 11110110b
-11110101b ^ 00000100b = 11110001b
-11110101b ^ 00000101b = 11110000b
-11110101b ^ 00000110b = 11110011b
-11110101b ^ 00000111b = 11110010b
-11110101b ^ 00001000b = 11111101b
-11110101b ^ 00001001b = 11111100b
-11110101b ^ 00001010b = 11111111b
-11110101b ^ 00001011b = 11111110b
-11110101b ^ 00001100b = 11111001b
-11110101b ^ 00001101b = 11111000b
-11110101b ^ 00001110b = 11111011b
-11110101b ^ 00001111b = 11111010b
-11110101b ^ 00010000b = 11100101b
-11110101b ^ 00010001b = 11100100b
-11110101b ^ 00010010b = 11100111b
-11110101b ^ 00010011b = 11100110b
-11110101b ^ 00010100b = 11100001b
-11110101b ^ 00010101b = 11100000b
-11110101b ^ 00010110b = 11100011b
-11110101b ^ 00010111b = 11100010b
-11110101b ^ 00011000b = 11101101b
-11110101b ^ 00011001b = 11101100b
-11110101b ^ 00011010b = 11101111b
-11110101b ^ 00011011b = 11101110b
-11110101b ^ 00011100b = 11101001b
-11110101b ^ 00011101b = 11101000b
-11110101b ^ 00011110b = 11101011b
-11110101b ^ 00011111b = 11101010b
-11110101b ^ 00100000b = 11010101b
-11110101b ^ 00100001b = 11010100b
-11110101b ^ 00100010b = 11010111b
-11110101b ^ 00100011b = 11010110b
-11110101b ^ 00100100b = 11010001b
-11110101b ^ 00100101b = 11010000b
-11110101b ^ 00100110b = 11010011b
-11110101b ^ 00100111b = 11010010b
-11110101b ^ 00101000b = 11011101b
-11110101b ^ 00101001b = 11011100b
-11110101b ^ 00101010b = 11011111b
-11110101b ^ 00101011b = 11011110b
-11110101b ^ 00101100b = 11011001b
-11110101b ^ 00101101b = 11011000b
-11110101b ^ 00101110b = 11011011b
-11110101b ^ 00101111b = 11011010b
-11110101b ^ 00110000b = 11000101b
-11110101b ^ 00110001b = 11000100b
-11110101b ^ 00110010b = 11000111b
-11110101b ^ 00110011b = 11000110b
-11110101b ^ 00110100b = 11000001b
-11110101b ^ 00110101b = 11000000b
-11110101b ^ 00110110b = 11000011b
-11110101b ^ 00110111b = 11000010b
-11110101b ^ 00111000b = 11001101b
-11110101b ^ 00111001b = 11001100b
-11110101b ^ 00111010b = 11001111b
-11110101b ^ 00111011b = 11001110b
-11110101b ^ 00111100b = 11001001b
-11110101b ^ 00111101b = 11001000b
-11110101b ^ 00111110b = 11001011b
-11110101b ^ 00111111b = 11001010b
-11110101b ^ 01000000b = 10110101b
-11110101b ^ 01000001b = 10110100b
-11110101b ^ 01000010b = 10110111b
-11110101b ^ 01000011b = 10110110b
-11110101b ^ 01000100b = 10110001b
-11110101b ^ 01000101b = 10110000b
-11110101b ^ 01000110b = 10110011b
-11110101b ^ 01000111b = 10110010b
-11110101b ^ 01001000b = 10111101b
-11110101b ^ 01001001b = 10111100b
-11110101b ^ 01001010b = 10111111b
-11110101b ^ 01001011b = 10111110b
-11110101b ^ 01001100b = 10111001b
-11110101b ^ 01001101b = 10111000b
-11110101b ^ 01001110b = 10111011b
-11110101b ^ 01001111b = 10111010b
-11110101b ^ 01010000b = 10100101b
-11110101b ^ 01010001b = 10100100b
-11110101b ^ 01010010b = 10100111b
-11110101b ^ 01010011b = 10100110b
-11110101b ^ 01010100b = 10100001b
-11110101b ^ 01010101b = 10100000b
-11110101b ^ 01010110b = 10100011b
-11110101b ^ 01010111b = 10100010b
-11110101b ^ 01011000b = 10101101b
-11110101b ^ 01011001b = 10101100b
-11110101b ^ 01011010b = 10101111b
-11110101b ^ 01011011b = 10101110b
-11110101b ^ 01011100b = 10101001b
-11110101b ^ 01011101b = 10101000b
-11110101b ^ 01011110b = 10101011b
-11110101b ^ 01011111b = 10101010b
-11110101b ^ 01100000b = 10010101b
-11110101b ^ 01100001b = 10010100b
-11110101b ^ 01100010b = 10010111b
-11110101b ^ 01100011b = 10010110b
-11110101b ^ 01100100b = 10010001b
-11110101b ^ 01100101b = 10010000b
-11110101b ^ 01100110b = 10010011b
-11110101b ^ 01100111b = 10010010b
-11110101b ^ 01101000b = 10011101b
-11110101b ^ 01101001b = 10011100b
-11110101b ^ 01101010b = 10011111b
-11110101b ^ 01101011b = 10011110b
-11110101b ^ 01101100b = 10011001b
-11110101b ^ 01101101b = 10011000b
-11110101b ^ 01101110b = 10011011b
-11110101b ^ 01101111b = 10011010b
-11110101b ^ 01110000b = 10000101b
-11110101b ^ 01110001b = 10000100b
-11110101b ^ 01110010b = 10000111b
-11110101b ^ 01110011b = 10000110b
-11110101b ^ 01110100b = 10000001b
-11110101b ^ 01110101b = 10000000b
-11110101b ^ 01110110b = 10000011b
-11110101b ^ 01110111b = 10000010b
-11110101b ^ 01111000b = 10001101b
-11110101b ^ 01111001b = 10001100b
-11110101b ^ 01111010b = 10001111b
-11110101b ^ 01111011b = 10001110b
-11110101b ^ 01111100b = 10001001b
-11110101b ^ 01111101b = 10001000b
-11110101b ^ 01111110b = 10001011b
-11110110b ^ 10000000b = 01110110b
-11110110b ^ 10000001b = 01110111b
-11110110b ^ 10000010b = 01110100b
-11110110b ^ 10000011b = 01110101b
-11110110b ^ 10000100b = 01110010b
-11110110b ^ 10000101b = 01110011b
-11110110b ^ 10000110b = 01110000b
-11110110b ^ 10000111b = 01110001b
-11110110b ^ 10001000b = 01111110b
-11110110b ^ 10001001b = 01111111b
-11110110b ^ 10001010b = 01111100b
-11110110b ^ 10001011b = 01111101b
-11110110b ^ 10001100b = 01111010b
-11110110b ^ 10001101b = 01111011b
-11110110b ^ 10001110b = 01111000b
-11110110b ^ 10001111b = 01111001b
-11110110b ^ 10010000b = 01100110b
-11110110b ^ 10010001b = 01100111b
-11110110b ^ 10010010b = 01100100b
-11110110b ^ 10010011b = 01100101b
-11110110b ^ 10010100b = 01100010b
-11110110b ^ 10010101b = 01100011b
-11110110b ^ 10010110b = 01100000b
-11110110b ^ 10010111b = 01100001b
-11110110b ^ 10011000b = 01101110b
-11110110b ^ 10011001b = 01101111b
-11110110b ^ 10011010b = 01101100b
-11110110b ^ 10011011b = 01101101b
-11110110b ^ 10011100b = 01101010b
-11110110b ^ 10011101b = 01101011b
-11110110b ^ 10011110b = 01101000b
-11110110b ^ 10011111b = 01101001b
-11110110b ^ 10100000b = 01010110b
-11110110b ^ 10100001b = 01010111b
-11110110b ^ 10100010b = 01010100b
-11110110b ^ 10100011b = 01010101b
-11110110b ^ 10100100b = 01010010b
-11110110b ^ 10100101b = 01010011b
-11110110b ^ 10100110b = 01010000b
-11110110b ^ 10100111b = 01010001b
-11110110b ^ 10101000b = 01011110b
-11110110b ^ 10101001b = 01011111b
-11110110b ^ 10101010b = 01011100b
-11110110b ^ 10101011b = 01011101b
-11110110b ^ 10101100b = 01011010b
-11110110b ^ 10101101b = 01011011b
-11110110b ^ 10101110b = 01011000b
-11110110b ^ 10101111b = 01011001b
-11110110b ^ 10110000b = 01000110b
-11110110b ^ 10110001b = 01000111b
-11110110b ^ 10110010b = 01000100b
-11110110b ^ 10110011b = 01000101b
-11110110b ^ 10110100b = 01000010b
-11110110b ^ 10110101b = 01000011b
-11110110b ^ 10110110b = 01000000b
-11110110b ^ 10110111b = 01000001b
-11110110b ^ 10111000b = 01001110b
-11110110b ^ 10111001b = 01001111b
-11110110b ^ 10111010b = 01001100b
-11110110b ^ 10111011b = 01001101b
-11110110b ^ 10111100b = 01001010b
-11110110b ^ 10111101b = 01001011b
-11110110b ^ 10111110b = 01001000b
-11110110b ^ 10111111b = 01001001b
-11110110b ^ 11000000b = 00110110b
-11110110b ^ 11000001b = 00110111b
-11110110b ^ 11000010b = 00110100b
-11110110b ^ 11000011b = 00110101b
-11110110b ^ 11000100b = 00110010b
-11110110b ^ 11000101b = 00110011b
-11110110b ^ 11000110b = 00110000b
-11110110b ^ 11000111b = 00110001b
-11110110b ^ 11001000b = 00111110b
-11110110b ^ 11001001b = 00111111b
-11110110b ^ 11001010b = 00111100b
-11110110b ^ 11001011b = 00111101b
-11110110b ^ 11001100b = 00111010b
-11110110b ^ 11001101b = 00111011b
-11110110b ^ 11001110b = 00111000b
-11110110b ^ 11001111b = 00111001b
-11110110b ^ 11010000b = 00100110b
-11110110b ^ 11010001b = 00100111b
-11110110b ^ 11010010b = 00100100b
-11110110b ^ 11010011b = 00100101b
-11110110b ^ 11010100b = 00100010b
-11110110b ^ 11010101b = 00100011b
-11110110b ^ 11010110b = 00100000b
-11110110b ^ 11010111b = 00100001b
-11110110b ^ 11011000b = 00101110b
-11110110b ^ 11011001b = 00101111b
-11110110b ^ 11011010b = 00101100b
-11110110b ^ 11011011b = 00101101b
-11110110b ^ 11011100b = 00101010b
-11110110b ^ 11011101b = 00101011b
-11110110b ^ 11011110b = 00101000b
-11110110b ^ 11011111b = 00101001b
-11110110b ^ 11100000b = 00010110b
-11110110b ^ 11100001b = 00010111b
-11110110b ^ 11100010b = 00010100b
-11110110b ^ 11100011b = 00010101b
-11110110b ^ 11100100b = 00010010b
-11110110b ^ 11100101b = 00010011b
-11110110b ^ 11100110b = 00010000b
-11110110b ^ 11100111b = 00010001b
-11110110b ^ 11101000b = 00011110b
-11110110b ^ 11101001b = 00011111b
-11110110b ^ 11101010b = 00011100b
-11110110b ^ 11101011b = 00011101b
-11110110b ^ 11101100b = 00011010b
-11110110b ^ 11101101b = 00011011b
-11110110b ^ 11101110b = 00011000b
-11110110b ^ 11101111b = 00011001b
-11110110b ^ 11110000b = 00000110b
-11110110b ^ 11110001b = 00000111b
-11110110b ^ 11110010b = 00000100b
-11110110b ^ 11110011b = 00000101b
-11110110b ^ 11110100b = 00000010b
-11110110b ^ 11110101b = 00000011b
-11110110b ^ 11110110b = 00000000b
-11110110b ^ 11110111b = 00000001b
-11110110b ^ 11111000b = 00001110b
-11110110b ^ 11111001b = 00001111b
-11110110b ^ 11111010b = 00001100b
-11110110b ^ 11111011b = 00001101b
-11110110b ^ 11111100b = 00001010b
-11110110b ^ 11111101b = 00001011b
-11110110b ^ 11111110b = 00001000b
-11110110b ^ 11111111b = 00001001b
-11110110b ^ 00000000b = 11110110b
-11110110b ^ 00000001b = 11110111b
-11110110b ^ 00000010b = 11110100b
-11110110b ^ 00000011b = 11110101b
-11110110b ^ 00000100b = 11110010b
-11110110b ^ 00000101b = 11110011b
-11110110b ^ 00000110b = 11110000b
-11110110b ^ 00000111b = 11110001b
-11110110b ^ 00001000b = 11111110b
-11110110b ^ 00001001b = 11111111b
-11110110b ^ 00001010b = 11111100b
-11110110b ^ 00001011b = 11111101b
-11110110b ^ 00001100b = 11111010b
-11110110b ^ 00001101b = 11111011b
-11110110b ^ 00001110b = 11111000b
-11110110b ^ 00001111b = 11111001b
-11110110b ^ 00010000b = 11100110b
-11110110b ^ 00010001b = 11100111b
-11110110b ^ 00010010b = 11100100b
-11110110b ^ 00010011b = 11100101b
-11110110b ^ 00010100b = 11100010b
-11110110b ^ 00010101b = 11100011b
-11110110b ^ 00010110b = 11100000b
-11110110b ^ 00010111b = 11100001b
-11110110b ^ 00011000b = 11101110b
-11110110b ^ 00011001b = 11101111b
-11110110b ^ 00011010b = 11101100b
-11110110b ^ 00011011b = 11101101b
-11110110b ^ 00011100b = 11101010b
-11110110b ^ 00011101b = 11101011b
-11110110b ^ 00011110b = 11101000b
-11110110b ^ 00011111b = 11101001b
-11110110b ^ 00100000b = 11010110b
-11110110b ^ 00100001b = 11010111b
-11110110b ^ 00100010b = 11010100b
-11110110b ^ 00100011b = 11010101b
-11110110b ^ 00100100b = 11010010b
-11110110b ^ 00100101b = 11010011b
-11110110b ^ 00100110b = 11010000b
-11110110b ^ 00100111b = 11010001b
-11110110b ^ 00101000b = 11011110b
-11110110b ^ 00101001b = 11011111b
-11110110b ^ 00101010b = 11011100b
-11110110b ^ 00101011b = 11011101b
-11110110b ^ 00101100b = 11011010b
-11110110b ^ 00101101b = 11011011b
-11110110b ^ 00101110b = 11011000b
-11110110b ^ 00101111b = 11011001b
-11110110b ^ 00110000b = 11000110b
-11110110b ^ 00110001b = 11000111b
-11110110b ^ 00110010b = 11000100b
-11110110b ^ 00110011b = 11000101b
-11110110b ^ 00110100b = 11000010b
-11110110b ^ 00110101b = 11000011b
-11110110b ^ 00110110b = 11000000b
-11110110b ^ 00110111b = 11000001b
-11110110b ^ 00111000b = 11001110b
-11110110b ^ 00111001b = 11001111b
-11110110b ^ 00111010b = 11001100b
-11110110b ^ 00111011b = 11001101b
-11110110b ^ 00111100b = 11001010b
-11110110b ^ 00111101b = 11001011b
-11110110b ^ 00111110b = 11001000b
-11110110b ^ 00111111b = 11001001b
-11110110b ^ 01000000b = 10110110b
-11110110b ^ 01000001b = 10110111b
-11110110b ^ 01000010b = 10110100b
-11110110b ^ 01000011b = 10110101b
-11110110b ^ 01000100b = 10110010b
-11110110b ^ 01000101b = 10110011b
-11110110b ^ 01000110b = 10110000b
-11110110b ^ 01000111b = 10110001b
-11110110b ^ 01001000b = 10111110b
-11110110b ^ 01001001b = 10111111b
-11110110b ^ 01001010b = 10111100b
-11110110b ^ 01001011b = 10111101b
-11110110b ^ 01001100b = 10111010b
-11110110b ^ 01001101b = 10111011b
-11110110b ^ 01001110b = 10111000b
-11110110b ^ 01001111b = 10111001b
-11110110b ^ 01010000b = 10100110b
-11110110b ^ 01010001b = 10100111b
-11110110b ^ 01010010b = 10100100b
-11110110b ^ 01010011b = 10100101b
-11110110b ^ 01010100b = 10100010b
-11110110b ^ 01010101b = 10100011b
-11110110b ^ 01010110b = 10100000b
-11110110b ^ 01010111b = 10100001b
-11110110b ^ 01011000b = 10101110b
-11110110b ^ 01011001b = 10101111b
-11110110b ^ 01011010b = 10101100b
-11110110b ^ 01011011b = 10101101b
-11110110b ^ 01011100b = 10101010b
-11110110b ^ 01011101b = 10101011b
-11110110b ^ 01011110b = 10101000b
-11110110b ^ 01011111b = 10101001b
-11110110b ^ 01100000b = 10010110b
-11110110b ^ 01100001b = 10010111b
-11110110b ^ 01100010b = 10010100b
-11110110b ^ 01100011b = 10010101b
-11110110b ^ 01100100b = 10010010b
-11110110b ^ 01100101b = 10010011b
-11110110b ^ 01100110b = 10010000b
-11110110b ^ 01100111b = 10010001b
-11110110b ^ 01101000b = 10011110b
-11110110b ^ 01101001b = 10011111b
-11110110b ^ 01101010b = 10011100b
-11110110b ^ 01101011b = 10011101b
-11110110b ^ 01101100b = 10011010b
-11110110b ^ 01101101b = 10011011b
-11110110b ^ 01101110b = 10011000b
-11110110b ^ 01101111b = 10011001b
-11110110b ^ 01110000b = 10000110b
-11110110b ^ 01110001b = 10000111b
-11110110b ^ 01110010b = 10000100b
-11110110b ^ 01110011b = 10000101b
-11110110b ^ 01110100b = 10000010b
-11110110b ^ 01110101b = 10000011b
-11110110b ^ 01110110b = 10000000b
-11110110b ^ 01110111b = 10000001b
-11110110b ^ 01111000b = 10001110b
-11110110b ^ 01111001b = 10001111b
-11110110b ^ 01111010b = 10001100b
-11110110b ^ 01111011b = 10001101b
-11110110b ^ 01111100b = 10001010b
-11110110b ^ 01111101b = 10001011b
-11110110b ^ 01111110b = 10001000b
-11110111b ^ 10000000b = 01110111b
-11110111b ^ 10000001b = 01110110b
-11110111b ^ 10000010b = 01110101b
-11110111b ^ 10000011b = 01110100b
-11110111b ^ 10000100b = 01110011b
-11110111b ^ 10000101b = 01110010b
-11110111b ^ 10000110b = 01110001b
-11110111b ^ 10000111b = 01110000b
-11110111b ^ 10001000b = 01111111b
-11110111b ^ 10001001b = 01111110b
-11110111b ^ 10001010b = 01111101b
-11110111b ^ 10001011b = 01111100b
-11110111b ^ 10001100b = 01111011b
-11110111b ^ 10001101b = 01111010b
-11110111b ^ 10001110b = 01111001b
-11110111b ^ 10001111b = 01111000b
-11110111b ^ 10010000b = 01100111b
-11110111b ^ 10010001b = 01100110b
-11110111b ^ 10010010b = 01100101b
-11110111b ^ 10010011b = 01100100b
-11110111b ^ 10010100b = 01100011b
-11110111b ^ 10010101b = 01100010b
-11110111b ^ 10010110b = 01100001b
-11110111b ^ 10010111b = 01100000b
-11110111b ^ 10011000b = 01101111b
-11110111b ^ 10011001b = 01101110b
-11110111b ^ 10011010b = 01101101b
-11110111b ^ 10011011b = 01101100b
-11110111b ^ 10011100b = 01101011b
-11110111b ^ 10011101b = 01101010b
-11110111b ^ 10011110b = 01101001b
-11110111b ^ 10011111b = 01101000b
-11110111b ^ 10100000b = 01010111b
-11110111b ^ 10100001b = 01010110b
-11110111b ^ 10100010b = 01010101b
-11110111b ^ 10100011b = 01010100b
-11110111b ^ 10100100b = 01010011b
-11110111b ^ 10100101b = 01010010b
-11110111b ^ 10100110b = 01010001b
-11110111b ^ 10100111b = 01010000b
-11110111b ^ 10101000b = 01011111b
-11110111b ^ 10101001b = 01011110b
-11110111b ^ 10101010b = 01011101b
-11110111b ^ 10101011b = 01011100b
-11110111b ^ 10101100b = 01011011b
-11110111b ^ 10101101b = 01011010b
-11110111b ^ 10101110b = 01011001b
-11110111b ^ 10101111b = 01011000b
-11110111b ^ 10110000b = 01000111b
-11110111b ^ 10110001b = 01000110b
-11110111b ^ 10110010b = 01000101b
-11110111b ^ 10110011b = 01000100b
-11110111b ^ 10110100b = 01000011b
-11110111b ^ 10110101b = 01000010b
-11110111b ^ 10110110b = 01000001b
-11110111b ^ 10110111b = 01000000b
-11110111b ^ 10111000b = 01001111b
-11110111b ^ 10111001b = 01001110b
-11110111b ^ 10111010b = 01001101b
-11110111b ^ 10111011b = 01001100b
-11110111b ^ 10111100b = 01001011b
-11110111b ^ 10111101b = 01001010b
-11110111b ^ 10111110b = 01001001b
-11110111b ^ 10111111b = 01001000b
-11110111b ^ 11000000b = 00110111b
-11110111b ^ 11000001b = 00110110b
-11110111b ^ 11000010b = 00110101b
-11110111b ^ 11000011b = 00110100b
-11110111b ^ 11000100b = 00110011b
-11110111b ^ 11000101b = 00110010b
-11110111b ^ 11000110b = 00110001b
-11110111b ^ 11000111b = 00110000b
-11110111b ^ 11001000b = 00111111b
-11110111b ^ 11001001b = 00111110b
-11110111b ^ 11001010b = 00111101b
-11110111b ^ 11001011b = 00111100b
-11110111b ^ 11001100b = 00111011b
-11110111b ^ 11001101b = 00111010b
-11110111b ^ 11001110b = 00111001b
-11110111b ^ 11001111b = 00111000b
-11110111b ^ 11010000b = 00100111b
-11110111b ^ 11010001b = 00100110b
-11110111b ^ 11010010b = 00100101b
-11110111b ^ 11010011b = 00100100b
-11110111b ^ 11010100b = 00100011b
-11110111b ^ 11010101b = 00100010b
-11110111b ^ 11010110b = 00100001b
-11110111b ^ 11010111b = 00100000b
-11110111b ^ 11011000b = 00101111b
-11110111b ^ 11011001b = 00101110b
-11110111b ^ 11011010b = 00101101b
-11110111b ^ 11011011b = 00101100b
-11110111b ^ 11011100b = 00101011b
-11110111b ^ 11011101b = 00101010b
-11110111b ^ 11011110b = 00101001b
-11110111b ^ 11011111b = 00101000b
-11110111b ^ 11100000b = 00010111b
-11110111b ^ 11100001b = 00010110b
-11110111b ^ 11100010b = 00010101b
-11110111b ^ 11100011b = 00010100b
-11110111b ^ 11100100b = 00010011b
-11110111b ^ 11100101b = 00010010b
-11110111b ^ 11100110b = 00010001b
-11110111b ^ 11100111b = 00010000b
-11110111b ^ 11101000b = 00011111b
-11110111b ^ 11101001b = 00011110b
-11110111b ^ 11101010b = 00011101b
-11110111b ^ 11101011b = 00011100b
-11110111b ^ 11101100b = 00011011b
-11110111b ^ 11101101b = 00011010b
-11110111b ^ 11101110b = 00011001b
-11110111b ^ 11101111b = 00011000b
-11110111b ^ 11110000b = 00000111b
-11110111b ^ 11110001b = 00000110b
-11110111b ^ 11110010b = 00000101b
-11110111b ^ 11110011b = 00000100b
-11110111b ^ 11110100b = 00000011b
-11110111b ^ 11110101b = 00000010b
-11110111b ^ 11110110b = 00000001b
-11110111b ^ 11110111b = 00000000b
-11110111b ^ 11111000b = 00001111b
-11110111b ^ 11111001b = 00001110b
-11110111b ^ 11111010b = 00001101b
-11110111b ^ 11111011b = 00001100b
-11110111b ^ 11111100b = 00001011b
-11110111b ^ 11111101b = 00001010b
-11110111b ^ 11111110b = 00001001b
-11110111b ^ 11111111b = 00001000b
-11110111b ^ 00000000b = 11110111b
-11110111b ^ 00000001b = 11110110b
-11110111b ^ 00000010b = 11110101b
-11110111b ^ 00000011b = 11110100b
-11110111b ^ 00000100b = 11110011b
-11110111b ^ 00000101b = 11110010b
-11110111b ^ 00000110b = 11110001b
-11110111b ^ 00000111b = 11110000b
-11110111b ^ 00001000b = 11111111b
-11110111b ^ 00001001b = 11111110b
-11110111b ^ 00001010b = 11111101b
-11110111b ^ 00001011b = 11111100b
-11110111b ^ 00001100b = 11111011b
-11110111b ^ 00001101b = 11111010b
-11110111b ^ 00001110b = 11111001b
-11110111b ^ 00001111b = 11111000b
-11110111b ^ 00010000b = 11100111b
-11110111b ^ 00010001b = 11100110b
-11110111b ^ 00010010b = 11100101b
-11110111b ^ 00010011b = 11100100b
-11110111b ^ 00010100b = 11100011b
-11110111b ^ 00010101b = 11100010b
-11110111b ^ 00010110b = 11100001b
-11110111b ^ 00010111b = 11100000b
-11110111b ^ 00011000b = 11101111b
-11110111b ^ 00011001b = 11101110b
-11110111b ^ 00011010b = 11101101b
-11110111b ^ 00011011b = 11101100b
-11110111b ^ 00011100b = 11101011b
-11110111b ^ 00011101b = 11101010b
-11110111b ^ 00011110b = 11101001b
-11110111b ^ 00011111b = 11101000b
-11110111b ^ 00100000b = 11010111b
-11110111b ^ 00100001b = 11010110b
-11110111b ^ 00100010b = 11010101b
-11110111b ^ 00100011b = 11010100b
-11110111b ^ 00100100b = 11010011b
-11110111b ^ 00100101b = 11010010b
-11110111b ^ 00100110b = 11010001b
-11110111b ^ 00100111b = 11010000b
-11110111b ^ 00101000b = 11011111b
-11110111b ^ 00101001b = 11011110b
-11110111b ^ 00101010b = 11011101b
-11110111b ^ 00101011b = 11011100b
-11110111b ^ 00101100b = 11011011b
-11110111b ^ 00101101b = 11011010b
-11110111b ^ 00101110b = 11011001b
-11110111b ^ 00101111b = 11011000b
-11110111b ^ 00110000b = 11000111b
-11110111b ^ 00110001b = 11000110b
-11110111b ^ 00110010b = 11000101b
-11110111b ^ 00110011b = 11000100b
-11110111b ^ 00110100b = 11000011b
-11110111b ^ 00110101b = 11000010b
-11110111b ^ 00110110b = 11000001b
-11110111b ^ 00110111b = 11000000b
-11110111b ^ 00111000b = 11001111b
-11110111b ^ 00111001b = 11001110b
-11110111b ^ 00111010b = 11001101b
-11110111b ^ 00111011b = 11001100b
-11110111b ^ 00111100b = 11001011b
-11110111b ^ 00111101b = 11001010b
-11110111b ^ 00111110b = 11001001b
-11110111b ^ 00111111b = 11001000b
-11110111b ^ 01000000b = 10110111b
-11110111b ^ 01000001b = 10110110b
-11110111b ^ 01000010b = 10110101b
-11110111b ^ 01000011b = 10110100b
-11110111b ^ 01000100b = 10110011b
-11110111b ^ 01000101b = 10110010b
-11110111b ^ 01000110b = 10110001b
-11110111b ^ 01000111b = 10110000b
-11110111b ^ 01001000b = 10111111b
-11110111b ^ 01001001b = 10111110b
-11110111b ^ 01001010b = 10111101b
-11110111b ^ 01001011b = 10111100b
-11110111b ^ 01001100b = 10111011b
-11110111b ^ 01001101b = 10111010b
-11110111b ^ 01001110b = 10111001b
-11110111b ^ 01001111b = 10111000b
-11110111b ^ 01010000b = 10100111b
-11110111b ^ 01010001b = 10100110b
-11110111b ^ 01010010b = 10100101b
-11110111b ^ 01010011b = 10100100b
-11110111b ^ 01010100b = 10100011b
-11110111b ^ 01010101b = 10100010b
-11110111b ^ 01010110b = 10100001b
-11110111b ^ 01010111b = 10100000b
-11110111b ^ 01011000b = 10101111b
-11110111b ^ 01011001b = 10101110b
-11110111b ^ 01011010b = 10101101b
-11110111b ^ 01011011b = 10101100b
-11110111b ^ 01011100b = 10101011b
-11110111b ^ 01011101b = 10101010b
-11110111b ^ 01011110b = 10101001b
-11110111b ^ 01011111b = 10101000b
-11110111b ^ 01100000b = 10010111b
-11110111b ^ 01100001b = 10010110b
-11110111b ^ 01100010b = 10010101b
-11110111b ^ 01100011b = 10010100b
-11110111b ^ 01100100b = 10010011b
-11110111b ^ 01100101b = 10010010b
-11110111b ^ 01100110b = 10010001b
-11110111b ^ 01100111b = 10010000b
-11110111b ^ 01101000b = 10011111b
-11110111b ^ 01101001b = 10011110b
-11110111b ^ 01101010b = 10011101b
-11110111b ^ 01101011b = 10011100b
-11110111b ^ 01101100b = 10011011b
-11110111b ^ 01101101b = 10011010b
-11110111b ^ 01101110b = 10011001b
-11110111b ^ 01101111b = 10011000b
-11110111b ^ 01110000b = 10000111b
-11110111b ^ 01110001b = 10000110b
-11110111b ^ 01110010b = 10000101b
-11110111b ^ 01110011b = 10000100b
-11110111b ^ 01110100b = 10000011b
-11110111b ^ 01110101b = 10000010b
-11110111b ^ 01110110b = 10000001b
-11110111b ^ 01110111b = 10000000b
-11110111b ^ 01111000b = 10001111b
-11110111b ^ 01111001b = 10001110b
-11110111b ^ 01111010b = 10001101b
-11110111b ^ 01111011b = 10001100b
-11110111b ^ 01111100b = 10001011b
-11110111b ^ 01111101b = 10001010b
-11110111b ^ 01111110b = 10001001b
-11111000b ^ 10000000b = 01111000b
-11111000b ^ 10000001b = 01111001b
-11111000b ^ 10000010b = 01111010b
-11111000b ^ 10000011b = 01111011b
-11111000b ^ 10000100b = 01111100b
-11111000b ^ 10000101b = 01111101b
-11111000b ^ 10000110b = 01111110b
-11111000b ^ 10000111b = 01111111b
-11111000b ^ 10001000b = 01110000b
-11111000b ^ 10001001b = 01110001b
-11111000b ^ 10001010b = 01110010b
-11111000b ^ 10001011b = 01110011b
-11111000b ^ 10001100b = 01110100b
-11111000b ^ 10001101b = 01110101b
-11111000b ^ 10001110b = 01110110b
-11111000b ^ 10001111b = 01110111b
-11111000b ^ 10010000b = 01101000b
-11111000b ^ 10010001b = 01101001b
-11111000b ^ 10010010b = 01101010b
-11111000b ^ 10010011b = 01101011b
-11111000b ^ 10010100b = 01101100b
-11111000b ^ 10010101b = 01101101b
-11111000b ^ 10010110b = 01101110b
-11111000b ^ 10010111b = 01101111b
-11111000b ^ 10011000b = 01100000b
-11111000b ^ 10011001b = 01100001b
-11111000b ^ 10011010b = 01100010b
-11111000b ^ 10011011b = 01100011b
-11111000b ^ 10011100b = 01100100b
-11111000b ^ 10011101b = 01100101b
-11111000b ^ 10011110b = 01100110b
-11111000b ^ 10011111b = 01100111b
-11111000b ^ 10100000b = 01011000b
-11111000b ^ 10100001b = 01011001b
-11111000b ^ 10100010b = 01011010b
-11111000b ^ 10100011b = 01011011b
-11111000b ^ 10100100b = 01011100b
-11111000b ^ 10100101b = 01011101b
-11111000b ^ 10100110b = 01011110b
-11111000b ^ 10100111b = 01011111b
-11111000b ^ 10101000b = 01010000b
-11111000b ^ 10101001b = 01010001b
-11111000b ^ 10101010b = 01010010b
-11111000b ^ 10101011b = 01010011b
-11111000b ^ 10101100b = 01010100b
-11111000b ^ 10101101b = 01010101b
-11111000b ^ 10101110b = 01010110b
-11111000b ^ 10101111b = 01010111b
-11111000b ^ 10110000b = 01001000b
-11111000b ^ 10110001b = 01001001b
-11111000b ^ 10110010b = 01001010b
-11111000b ^ 10110011b = 01001011b
-11111000b ^ 10110100b = 01001100b
-11111000b ^ 10110101b = 01001101b
-11111000b ^ 10110110b = 01001110b
-11111000b ^ 10110111b = 01001111b
-11111000b ^ 10111000b = 01000000b
-11111000b ^ 10111001b = 01000001b
-11111000b ^ 10111010b = 01000010b
-11111000b ^ 10111011b = 01000011b
-11111000b ^ 10111100b = 01000100b
-11111000b ^ 10111101b = 01000101b
-11111000b ^ 10111110b = 01000110b
-11111000b ^ 10111111b = 01000111b
-11111000b ^ 11000000b = 00111000b
-11111000b ^ 11000001b = 00111001b
-11111000b ^ 11000010b = 00111010b
-11111000b ^ 11000011b = 00111011b
-11111000b ^ 11000100b = 00111100b
-11111000b ^ 11000101b = 00111101b
-11111000b ^ 11000110b = 00111110b
-11111000b ^ 11000111b = 00111111b
-11111000b ^ 11001000b = 00110000b
-11111000b ^ 11001001b = 00110001b
-11111000b ^ 11001010b = 00110010b
-11111000b ^ 11001011b = 00110011b
-11111000b ^ 11001100b = 00110100b
-11111000b ^ 11001101b = 00110101b
-11111000b ^ 11001110b = 00110110b
-11111000b ^ 11001111b = 00110111b
-11111000b ^ 11010000b = 00101000b
-11111000b ^ 11010001b = 00101001b
-11111000b ^ 11010010b = 00101010b
-11111000b ^ 11010011b = 00101011b
-11111000b ^ 11010100b = 00101100b
-11111000b ^ 11010101b = 00101101b
-11111000b ^ 11010110b = 00101110b
-11111000b ^ 11010111b = 00101111b
-11111000b ^ 11011000b = 00100000b
-11111000b ^ 11011001b = 00100001b
-11111000b ^ 11011010b = 00100010b
-11111000b ^ 11011011b = 00100011b
-11111000b ^ 11011100b = 00100100b
-11111000b ^ 11011101b = 00100101b
-11111000b ^ 11011110b = 00100110b
-11111000b ^ 11011111b = 00100111b
-11111000b ^ 11100000b = 00011000b
-11111000b ^ 11100001b = 00011001b
-11111000b ^ 11100010b = 00011010b
-11111000b ^ 11100011b = 00011011b
-11111000b ^ 11100100b = 00011100b
-11111000b ^ 11100101b = 00011101b
-11111000b ^ 11100110b = 00011110b
-11111000b ^ 11100111b = 00011111b
-11111000b ^ 11101000b = 00010000b
-11111000b ^ 11101001b = 00010001b
-11111000b ^ 11101010b = 00010010b
-11111000b ^ 11101011b = 00010011b
-11111000b ^ 11101100b = 00010100b
-11111000b ^ 11101101b = 00010101b
-11111000b ^ 11101110b = 00010110b
-11111000b ^ 11101111b = 00010111b
-11111000b ^ 11110000b = 00001000b
-11111000b ^ 11110001b = 00001001b
-11111000b ^ 11110010b = 00001010b
-11111000b ^ 11110011b = 00001011b
-11111000b ^ 11110100b = 00001100b
-11111000b ^ 11110101b = 00001101b
-11111000b ^ 11110110b = 00001110b
-11111000b ^ 11110111b = 00001111b
-11111000b ^ 11111000b = 00000000b
-11111000b ^ 11111001b = 00000001b
-11111000b ^ 11111010b = 00000010b
-11111000b ^ 11111011b = 00000011b
-11111000b ^ 11111100b = 00000100b
-11111000b ^ 11111101b = 00000101b
-11111000b ^ 11111110b = 00000110b
-11111000b ^ 11111111b = 00000111b
-11111000b ^ 00000000b = 11111000b
-11111000b ^ 00000001b = 11111001b
-11111000b ^ 00000010b = 11111010b
-11111000b ^ 00000011b = 11111011b
-11111000b ^ 00000100b = 11111100b
-11111000b ^ 00000101b = 11111101b
-11111000b ^ 00000110b = 11111110b
-11111000b ^ 00000111b = 11111111b
-11111000b ^ 00001000b = 11110000b
-11111000b ^ 00001001b = 11110001b
-11111000b ^ 00001010b = 11110010b
-11111000b ^ 00001011b = 11110011b
-11111000b ^ 00001100b = 11110100b
-11111000b ^ 00001101b = 11110101b
-11111000b ^ 00001110b = 11110110b
-11111000b ^ 00001111b = 11110111b
-11111000b ^ 00010000b = 11101000b
-11111000b ^ 00010001b = 11101001b
-11111000b ^ 00010010b = 11101010b
-11111000b ^ 00010011b = 11101011b
-11111000b ^ 00010100b = 11101100b
-11111000b ^ 00010101b = 11101101b
-11111000b ^ 00010110b = 11101110b
-11111000b ^ 00010111b = 11101111b
-11111000b ^ 00011000b = 11100000b
-11111000b ^ 00011001b = 11100001b
-11111000b ^ 00011010b = 11100010b
-11111000b ^ 00011011b = 11100011b
-11111000b ^ 00011100b = 11100100b
-11111000b ^ 00011101b = 11100101b
-11111000b ^ 00011110b = 11100110b
-11111000b ^ 00011111b = 11100111b
-11111000b ^ 00100000b = 11011000b
-11111000b ^ 00100001b = 11011001b
-11111000b ^ 00100010b = 11011010b
-11111000b ^ 00100011b = 11011011b
-11111000b ^ 00100100b = 11011100b
-11111000b ^ 00100101b = 11011101b
-11111000b ^ 00100110b = 11011110b
-11111000b ^ 00100111b = 11011111b
-11111000b ^ 00101000b = 11010000b
-11111000b ^ 00101001b = 11010001b
-11111000b ^ 00101010b = 11010010b
-11111000b ^ 00101011b = 11010011b
-11111000b ^ 00101100b = 11010100b
-11111000b ^ 00101101b = 11010101b
-11111000b ^ 00101110b = 11010110b
-11111000b ^ 00101111b = 11010111b
-11111000b ^ 00110000b = 11001000b
-11111000b ^ 00110001b = 11001001b
-11111000b ^ 00110010b = 11001010b
-11111000b ^ 00110011b = 11001011b
-11111000b ^ 00110100b = 11001100b
-11111000b ^ 00110101b = 11001101b
-11111000b ^ 00110110b = 11001110b
-11111000b ^ 00110111b = 11001111b
-11111000b ^ 00111000b = 11000000b
-11111000b ^ 00111001b = 11000001b
-11111000b ^ 00111010b = 11000010b
-11111000b ^ 00111011b = 11000011b
-11111000b ^ 00111100b = 11000100b
-11111000b ^ 00111101b = 11000101b
-11111000b ^ 00111110b = 11000110b
-11111000b ^ 00111111b = 11000111b
-11111000b ^ 01000000b = 10111000b
-11111000b ^ 01000001b = 10111001b
-11111000b ^ 01000010b = 10111010b
-11111000b ^ 01000011b = 10111011b
-11111000b ^ 01000100b = 10111100b
-11111000b ^ 01000101b = 10111101b
-11111000b ^ 01000110b = 10111110b
-11111000b ^ 01000111b = 10111111b
-11111000b ^ 01001000b = 10110000b
-11111000b ^ 01001001b = 10110001b
-11111000b ^ 01001010b = 10110010b
-11111000b ^ 01001011b = 10110011b
-11111000b ^ 01001100b = 10110100b
-11111000b ^ 01001101b = 10110101b
-11111000b ^ 01001110b = 10110110b
-11111000b ^ 01001111b = 10110111b
-11111000b ^ 01010000b = 10101000b
-11111000b ^ 01010001b = 10101001b
-11111000b ^ 01010010b = 10101010b
-11111000b ^ 01010011b = 10101011b
-11111000b ^ 01010100b = 10101100b
-11111000b ^ 01010101b = 10101101b
-11111000b ^ 01010110b = 10101110b
-11111000b ^ 01010111b = 10101111b
-11111000b ^ 01011000b = 10100000b
-11111000b ^ 01011001b = 10100001b
-11111000b ^ 01011010b = 10100010b
-11111000b ^ 01011011b = 10100011b
-11111000b ^ 01011100b = 10100100b
-11111000b ^ 01011101b = 10100101b
-11111000b ^ 01011110b = 10100110b
-11111000b ^ 01011111b = 10100111b
-11111000b ^ 01100000b = 10011000b
-11111000b ^ 01100001b = 10011001b
-11111000b ^ 01100010b = 10011010b
-11111000b ^ 01100011b = 10011011b
-11111000b ^ 01100100b = 10011100b
-11111000b ^ 01100101b = 10011101b
-11111000b ^ 01100110b = 10011110b
-11111000b ^ 01100111b = 10011111b
-11111000b ^ 01101000b = 10010000b
-11111000b ^ 01101001b = 10010001b
-11111000b ^ 01101010b = 10010010b
-11111000b ^ 01101011b = 10010011b
-11111000b ^ 01101100b = 10010100b
-11111000b ^ 01101101b = 10010101b
-11111000b ^ 01101110b = 10010110b
-11111000b ^ 01101111b = 10010111b
-11111000b ^ 01110000b = 10001000b
-11111000b ^ 01110001b = 10001001b
-11111000b ^ 01110010b = 10001010b
-11111000b ^ 01110011b = 10001011b
-11111000b ^ 01110100b = 10001100b
-11111000b ^ 01110101b = 10001101b
-11111000b ^ 01110110b = 10001110b
-11111000b ^ 01110111b = 10001111b
-11111000b ^ 01111000b = 10000000b
-11111000b ^ 01111001b = 10000001b
-11111000b ^ 01111010b = 10000010b
-11111000b ^ 01111011b = 10000011b
-11111000b ^ 01111100b = 10000100b
-11111000b ^ 01111101b = 10000101b
-11111000b ^ 01111110b = 10000110b
-11111001b ^ 10000000b = 01111001b
-11111001b ^ 10000001b = 01111000b
-11111001b ^ 10000010b = 01111011b
-11111001b ^ 10000011b = 01111010b
-11111001b ^ 10000100b = 01111101b
-11111001b ^ 10000101b = 01111100b
-11111001b ^ 10000110b = 01111111b
-11111001b ^ 10000111b = 01111110b
-11111001b ^ 10001000b = 01110001b
-11111001b ^ 10001001b = 01110000b
-11111001b ^ 10001010b = 01110011b
-11111001b ^ 10001011b = 01110010b
-11111001b ^ 10001100b = 01110101b
-11111001b ^ 10001101b = 01110100b
-11111001b ^ 10001110b = 01110111b
-11111001b ^ 10001111b = 01110110b
-11111001b ^ 10010000b = 01101001b
-11111001b ^ 10010001b = 01101000b
-11111001b ^ 10010010b = 01101011b
-11111001b ^ 10010011b = 01101010b
-11111001b ^ 10010100b = 01101101b
-11111001b ^ 10010101b = 01101100b
-11111001b ^ 10010110b = 01101111b
-11111001b ^ 10010111b = 01101110b
-11111001b ^ 10011000b = 01100001b
-11111001b ^ 10011001b = 01100000b
-11111001b ^ 10011010b = 01100011b
-11111001b ^ 10011011b = 01100010b
-11111001b ^ 10011100b = 01100101b
-11111001b ^ 10011101b = 01100100b
-11111001b ^ 10011110b = 01100111b
-11111001b ^ 10011111b = 01100110b
-11111001b ^ 10100000b = 01011001b
-11111001b ^ 10100001b = 01011000b
-11111001b ^ 10100010b = 01011011b
-11111001b ^ 10100011b = 01011010b
-11111001b ^ 10100100b = 01011101b
-11111001b ^ 10100101b = 01011100b
-11111001b ^ 10100110b = 01011111b
-11111001b ^ 10100111b = 01011110b
-11111001b ^ 10101000b = 01010001b
-11111001b ^ 10101001b = 01010000b
-11111001b ^ 10101010b = 01010011b
-11111001b ^ 10101011b = 01010010b
-11111001b ^ 10101100b = 01010101b
-11111001b ^ 10101101b = 01010100b
-11111001b ^ 10101110b = 01010111b
-11111001b ^ 10101111b = 01010110b
-11111001b ^ 10110000b = 01001001b
-11111001b ^ 10110001b = 01001000b
-11111001b ^ 10110010b = 01001011b
-11111001b ^ 10110011b = 01001010b
-11111001b ^ 10110100b = 01001101b
-11111001b ^ 10110101b = 01001100b
-11111001b ^ 10110110b = 01001111b
-11111001b ^ 10110111b = 01001110b
-11111001b ^ 10111000b = 01000001b
-11111001b ^ 10111001b = 01000000b
-11111001b ^ 10111010b = 01000011b
-11111001b ^ 10111011b = 01000010b
-11111001b ^ 10111100b = 01000101b
-11111001b ^ 10111101b = 01000100b
-11111001b ^ 10111110b = 01000111b
-11111001b ^ 10111111b = 01000110b
-11111001b ^ 11000000b = 00111001b
-11111001b ^ 11000001b = 00111000b
-11111001b ^ 11000010b = 00111011b
-11111001b ^ 11000011b = 00111010b
-11111001b ^ 11000100b = 00111101b
-11111001b ^ 11000101b = 00111100b
-11111001b ^ 11000110b = 00111111b
-11111001b ^ 11000111b = 00111110b
-11111001b ^ 11001000b = 00110001b
-11111001b ^ 11001001b = 00110000b
-11111001b ^ 11001010b = 00110011b
-11111001b ^ 11001011b = 00110010b
-11111001b ^ 11001100b = 00110101b
-11111001b ^ 11001101b = 00110100b
-11111001b ^ 11001110b = 00110111b
-11111001b ^ 11001111b = 00110110b
-11111001b ^ 11010000b = 00101001b
-11111001b ^ 11010001b = 00101000b
-11111001b ^ 11010010b = 00101011b
-11111001b ^ 11010011b = 00101010b
-11111001b ^ 11010100b = 00101101b
-11111001b ^ 11010101b = 00101100b
-11111001b ^ 11010110b = 00101111b
-11111001b ^ 11010111b = 00101110b
-11111001b ^ 11011000b = 00100001b
-11111001b ^ 11011001b = 00100000b
-11111001b ^ 11011010b = 00100011b
-11111001b ^ 11011011b = 00100010b
-11111001b ^ 11011100b = 00100101b
-11111001b ^ 11011101b = 00100100b
-11111001b ^ 11011110b = 00100111b
-11111001b ^ 11011111b = 00100110b
-11111001b ^ 11100000b = 00011001b
-11111001b ^ 11100001b = 00011000b
-11111001b ^ 11100010b = 00011011b
-11111001b ^ 11100011b = 00011010b
-11111001b ^ 11100100b = 00011101b
-11111001b ^ 11100101b = 00011100b
-11111001b ^ 11100110b = 00011111b
-11111001b ^ 11100111b = 00011110b
-11111001b ^ 11101000b = 00010001b
-11111001b ^ 11101001b = 00010000b
-11111001b ^ 11101010b = 00010011b
-11111001b ^ 11101011b = 00010010b
-11111001b ^ 11101100b = 00010101b
-11111001b ^ 11101101b = 00010100b
-11111001b ^ 11101110b = 00010111b
-11111001b ^ 11101111b = 00010110b
-11111001b ^ 11110000b = 00001001b
-11111001b ^ 11110001b = 00001000b
-11111001b ^ 11110010b = 00001011b
-11111001b ^ 11110011b = 00001010b
-11111001b ^ 11110100b = 00001101b
-11111001b ^ 11110101b = 00001100b
-11111001b ^ 11110110b = 00001111b
-11111001b ^ 11110111b = 00001110b
-11111001b ^ 11111000b = 00000001b
-11111001b ^ 11111001b = 00000000b
-11111001b ^ 11111010b = 00000011b
-11111001b ^ 11111011b = 00000010b
-11111001b ^ 11111100b = 00000101b
-11111001b ^ 11111101b = 00000100b
-11111001b ^ 11111110b = 00000111b
-11111001b ^ 11111111b = 00000110b
-11111001b ^ 00000000b = 11111001b
-11111001b ^ 00000001b = 11111000b
-11111001b ^ 00000010b = 11111011b
-11111001b ^ 00000011b = 11111010b
-11111001b ^ 00000100b = 11111101b
-11111001b ^ 00000101b = 11111100b
-11111001b ^ 00000110b = 11111111b
-11111001b ^ 00000111b = 11111110b
-11111001b ^ 00001000b = 11110001b
-11111001b ^ 00001001b = 11110000b
-11111001b ^ 00001010b = 11110011b
-11111001b ^ 00001011b = 11110010b
-11111001b ^ 00001100b = 11110101b
-11111001b ^ 00001101b = 11110100b
-11111001b ^ 00001110b = 11110111b
-11111001b ^ 00001111b = 11110110b
-11111001b ^ 00010000b = 11101001b
-11111001b ^ 00010001b = 11101000b
-11111001b ^ 00010010b = 11101011b
-11111001b ^ 00010011b = 11101010b
-11111001b ^ 00010100b = 11101101b
-11111001b ^ 00010101b = 11101100b
-11111001b ^ 00010110b = 11101111b
-11111001b ^ 00010111b = 11101110b
-11111001b ^ 00011000b = 11100001b
-11111001b ^ 00011001b = 11100000b
-11111001b ^ 00011010b = 11100011b
-11111001b ^ 00011011b = 11100010b
-11111001b ^ 00011100b = 11100101b
-11111001b ^ 00011101b = 11100100b
-11111001b ^ 00011110b = 11100111b
-11111001b ^ 00011111b = 11100110b
-11111001b ^ 00100000b = 11011001b
-11111001b ^ 00100001b = 11011000b
-11111001b ^ 00100010b = 11011011b
-11111001b ^ 00100011b = 11011010b
-11111001b ^ 00100100b = 11011101b
-11111001b ^ 00100101b = 11011100b
-11111001b ^ 00100110b = 11011111b
-11111001b ^ 00100111b = 11011110b
-11111001b ^ 00101000b = 11010001b
-11111001b ^ 00101001b = 11010000b
-11111001b ^ 00101010b = 11010011b
-11111001b ^ 00101011b = 11010010b
-11111001b ^ 00101100b = 11010101b
-11111001b ^ 00101101b = 11010100b
-11111001b ^ 00101110b = 11010111b
-11111001b ^ 00101111b = 11010110b
-11111001b ^ 00110000b = 11001001b
-11111001b ^ 00110001b = 11001000b
-11111001b ^ 00110010b = 11001011b
-11111001b ^ 00110011b = 11001010b
-11111001b ^ 00110100b = 11001101b
-11111001b ^ 00110101b = 11001100b
-11111001b ^ 00110110b = 11001111b
-11111001b ^ 00110111b = 11001110b
-11111001b ^ 00111000b = 11000001b
-11111001b ^ 00111001b = 11000000b
-11111001b ^ 00111010b = 11000011b
-11111001b ^ 00111011b = 11000010b
-11111001b ^ 00111100b = 11000101b
-11111001b ^ 00111101b = 11000100b
-11111001b ^ 00111110b = 11000111b
-11111001b ^ 00111111b = 11000110b
-11111001b ^ 01000000b = 10111001b
-11111001b ^ 01000001b = 10111000b
-11111001b ^ 01000010b = 10111011b
-11111001b ^ 01000011b = 10111010b
-11111001b ^ 01000100b = 10111101b
-11111001b ^ 01000101b = 10111100b
-11111001b ^ 01000110b = 10111111b
-11111001b ^ 01000111b = 10111110b
-11111001b ^ 01001000b = 10110001b
-11111001b ^ 01001001b = 10110000b
-11111001b ^ 01001010b = 10110011b
-11111001b ^ 01001011b = 10110010b
-11111001b ^ 01001100b = 10110101b
-11111001b ^ 01001101b = 10110100b
-11111001b ^ 01001110b = 10110111b
-11111001b ^ 01001111b = 10110110b
-11111001b ^ 01010000b = 10101001b
-11111001b ^ 01010001b = 10101000b
-11111001b ^ 01010010b = 10101011b
-11111001b ^ 01010011b = 10101010b
-11111001b ^ 01010100b = 10101101b
-11111001b ^ 01010101b = 10101100b
-11111001b ^ 01010110b = 10101111b
-11111001b ^ 01010111b = 10101110b
-11111001b ^ 01011000b = 10100001b
-11111001b ^ 01011001b = 10100000b
-11111001b ^ 01011010b = 10100011b
-11111001b ^ 01011011b = 10100010b
-11111001b ^ 01011100b = 10100101b
-11111001b ^ 01011101b = 10100100b
-11111001b ^ 01011110b = 10100111b
-11111001b ^ 01011111b = 10100110b
-11111001b ^ 01100000b = 10011001b
-11111001b ^ 01100001b = 10011000b
-11111001b ^ 01100010b = 10011011b
-11111001b ^ 01100011b = 10011010b
-11111001b ^ 01100100b = 10011101b
-11111001b ^ 01100101b = 10011100b
-11111001b ^ 01100110b = 10011111b
-11111001b ^ 01100111b = 10011110b
-11111001b ^ 01101000b = 10010001b
-11111001b ^ 01101001b = 10010000b
-11111001b ^ 01101010b = 10010011b
-11111001b ^ 01101011b = 10010010b
-11111001b ^ 01101100b = 10010101b
-11111001b ^ 01101101b = 10010100b
-11111001b ^ 01101110b = 10010111b
-11111001b ^ 01101111b = 10010110b
-11111001b ^ 01110000b = 10001001b
-11111001b ^ 01110001b = 10001000b
-11111001b ^ 01110010b = 10001011b
-11111001b ^ 01110011b = 10001010b
-11111001b ^ 01110100b = 10001101b
-11111001b ^ 01110101b = 10001100b
-11111001b ^ 01110110b = 10001111b
-11111001b ^ 01110111b = 10001110b
-11111001b ^ 01111000b = 10000001b
-11111001b ^ 01111001b = 10000000b
-11111001b ^ 01111010b = 10000011b
-11111001b ^ 01111011b = 10000010b
-11111001b ^ 01111100b = 10000101b
-11111001b ^ 01111101b = 10000100b
-11111001b ^ 01111110b = 10000111b
-11111010b ^ 10000000b = 01111010b
-11111010b ^ 10000001b = 01111011b
-11111010b ^ 10000010b = 01111000b
-11111010b ^ 10000011b = 01111001b
-11111010b ^ 10000100b = 01111110b
-11111010b ^ 10000101b = 01111111b
-11111010b ^ 10000110b = 01111100b
-11111010b ^ 10000111b = 01111101b
-11111010b ^ 10001000b = 01110010b
-11111010b ^ 10001001b = 01110011b
-11111010b ^ 10001010b = 01110000b
-11111010b ^ 10001011b = 01110001b
-11111010b ^ 10001100b = 01110110b
-11111010b ^ 10001101b = 01110111b
-11111010b ^ 10001110b = 01110100b
-11111010b ^ 10001111b = 01110101b
-11111010b ^ 10010000b = 01101010b
-11111010b ^ 10010001b = 01101011b
-11111010b ^ 10010010b = 01101000b
-11111010b ^ 10010011b = 01101001b
-11111010b ^ 10010100b = 01101110b
-11111010b ^ 10010101b = 01101111b
-11111010b ^ 10010110b = 01101100b
-11111010b ^ 10010111b = 01101101b
-11111010b ^ 10011000b = 01100010b
-11111010b ^ 10011001b = 01100011b
-11111010b ^ 10011010b = 01100000b
-11111010b ^ 10011011b = 01100001b
-11111010b ^ 10011100b = 01100110b
-11111010b ^ 10011101b = 01100111b
-11111010b ^ 10011110b = 01100100b
-11111010b ^ 10011111b = 01100101b
-11111010b ^ 10100000b = 01011010b
-11111010b ^ 10100001b = 01011011b
-11111010b ^ 10100010b = 01011000b
-11111010b ^ 10100011b = 01011001b
-11111010b ^ 10100100b = 01011110b
-11111010b ^ 10100101b = 01011111b
-11111010b ^ 10100110b = 01011100b
-11111010b ^ 10100111b = 01011101b
-11111010b ^ 10101000b = 01010010b
-11111010b ^ 10101001b = 01010011b
-11111010b ^ 10101010b = 01010000b
-11111010b ^ 10101011b = 01010001b
-11111010b ^ 10101100b = 01010110b
-11111010b ^ 10101101b = 01010111b
-11111010b ^ 10101110b = 01010100b
-11111010b ^ 10101111b = 01010101b
-11111010b ^ 10110000b = 01001010b
-11111010b ^ 10110001b = 01001011b
-11111010b ^ 10110010b = 01001000b
-11111010b ^ 10110011b = 01001001b
-11111010b ^ 10110100b = 01001110b
-11111010b ^ 10110101b = 01001111b
-11111010b ^ 10110110b = 01001100b
-11111010b ^ 10110111b = 01001101b
-11111010b ^ 10111000b = 01000010b
-11111010b ^ 10111001b = 01000011b
-11111010b ^ 10111010b = 01000000b
-11111010b ^ 10111011b = 01000001b
-11111010b ^ 10111100b = 01000110b
-11111010b ^ 10111101b = 01000111b
-11111010b ^ 10111110b = 01000100b
-11111010b ^ 10111111b = 01000101b
-11111010b ^ 11000000b = 00111010b
-11111010b ^ 11000001b = 00111011b
-11111010b ^ 11000010b = 00111000b
-11111010b ^ 11000011b = 00111001b
-11111010b ^ 11000100b = 00111110b
-11111010b ^ 11000101b = 00111111b
-11111010b ^ 11000110b = 00111100b
-11111010b ^ 11000111b = 00111101b
-11111010b ^ 11001000b = 00110010b
-11111010b ^ 11001001b = 00110011b
-11111010b ^ 11001010b = 00110000b
-11111010b ^ 11001011b = 00110001b
-11111010b ^ 11001100b = 00110110b
-11111010b ^ 11001101b = 00110111b
-11111010b ^ 11001110b = 00110100b
-11111010b ^ 11001111b = 00110101b
-11111010b ^ 11010000b = 00101010b
-11111010b ^ 11010001b = 00101011b
-11111010b ^ 11010010b = 00101000b
-11111010b ^ 11010011b = 00101001b
-11111010b ^ 11010100b = 00101110b
-11111010b ^ 11010101b = 00101111b
-11111010b ^ 11010110b = 00101100b
-11111010b ^ 11010111b = 00101101b
-11111010b ^ 11011000b = 00100010b
-11111010b ^ 11011001b = 00100011b
-11111010b ^ 11011010b = 00100000b
-11111010b ^ 11011011b = 00100001b
-11111010b ^ 11011100b = 00100110b
-11111010b ^ 11011101b = 00100111b
-11111010b ^ 11011110b = 00100100b
-11111010b ^ 11011111b = 00100101b
-11111010b ^ 11100000b = 00011010b
-11111010b ^ 11100001b = 00011011b
-11111010b ^ 11100010b = 00011000b
-11111010b ^ 11100011b = 00011001b
-11111010b ^ 11100100b = 00011110b
-11111010b ^ 11100101b = 00011111b
-11111010b ^ 11100110b = 00011100b
-11111010b ^ 11100111b = 00011101b
-11111010b ^ 11101000b = 00010010b
-11111010b ^ 11101001b = 00010011b
-11111010b ^ 11101010b = 00010000b
-11111010b ^ 11101011b = 00010001b
-11111010b ^ 11101100b = 00010110b
-11111010b ^ 11101101b = 00010111b
-11111010b ^ 11101110b = 00010100b
-11111010b ^ 11101111b = 00010101b
-11111010b ^ 11110000b = 00001010b
-11111010b ^ 11110001b = 00001011b
-11111010b ^ 11110010b = 00001000b
-11111010b ^ 11110011b = 00001001b
-11111010b ^ 11110100b = 00001110b
-11111010b ^ 11110101b = 00001111b
-11111010b ^ 11110110b = 00001100b
-11111010b ^ 11110111b = 00001101b
-11111010b ^ 11111000b = 00000010b
-11111010b ^ 11111001b = 00000011b
-11111010b ^ 11111010b = 00000000b
-11111010b ^ 11111011b = 00000001b
-11111010b ^ 11111100b = 00000110b
-11111010b ^ 11111101b = 00000111b
-11111010b ^ 11111110b = 00000100b
-11111010b ^ 11111111b = 00000101b
-11111010b ^ 00000000b = 11111010b
-11111010b ^ 00000001b = 11111011b
-11111010b ^ 00000010b = 11111000b
-11111010b ^ 00000011b = 11111001b
-11111010b ^ 00000100b = 11111110b
-11111010b ^ 00000101b = 11111111b
-11111010b ^ 00000110b = 11111100b
-11111010b ^ 00000111b = 11111101b
-11111010b ^ 00001000b = 11110010b
-11111010b ^ 00001001b = 11110011b
-11111010b ^ 00001010b = 11110000b
-11111010b ^ 00001011b = 11110001b
-11111010b ^ 00001100b = 11110110b
-11111010b ^ 00001101b = 11110111b
-11111010b ^ 00001110b = 11110100b
-11111010b ^ 00001111b = 11110101b
-11111010b ^ 00010000b = 11101010b
-11111010b ^ 00010001b = 11101011b
-11111010b ^ 00010010b = 11101000b
-11111010b ^ 00010011b = 11101001b
-11111010b ^ 00010100b = 11101110b
-11111010b ^ 00010101b = 11101111b
-11111010b ^ 00010110b = 11101100b
-11111010b ^ 00010111b = 11101101b
-11111010b ^ 00011000b = 11100010b
-11111010b ^ 00011001b = 11100011b
-11111010b ^ 00011010b = 11100000b
-11111010b ^ 00011011b = 11100001b
-11111010b ^ 00011100b = 11100110b
-11111010b ^ 00011101b = 11100111b
-11111010b ^ 00011110b = 11100100b
-11111010b ^ 00011111b = 11100101b
-11111010b ^ 00100000b = 11011010b
-11111010b ^ 00100001b = 11011011b
-11111010b ^ 00100010b = 11011000b
-11111010b ^ 00100011b = 11011001b
-11111010b ^ 00100100b = 11011110b
-11111010b ^ 00100101b = 11011111b
-11111010b ^ 00100110b = 11011100b
-11111010b ^ 00100111b = 11011101b
-11111010b ^ 00101000b = 11010010b
-11111010b ^ 00101001b = 11010011b
-11111010b ^ 00101010b = 11010000b
-11111010b ^ 00101011b = 11010001b
-11111010b ^ 00101100b = 11010110b
-11111010b ^ 00101101b = 11010111b
-11111010b ^ 00101110b = 11010100b
-11111010b ^ 00101111b = 11010101b
-11111010b ^ 00110000b = 11001010b
-11111010b ^ 00110001b = 11001011b
-11111010b ^ 00110010b = 11001000b
-11111010b ^ 00110011b = 11001001b
-11111010b ^ 00110100b = 11001110b
-11111010b ^ 00110101b = 11001111b
-11111010b ^ 00110110b = 11001100b
-11111010b ^ 00110111b = 11001101b
-11111010b ^ 00111000b = 11000010b
-11111010b ^ 00111001b = 11000011b
-11111010b ^ 00111010b = 11000000b
-11111010b ^ 00111011b = 11000001b
-11111010b ^ 00111100b = 11000110b
-11111010b ^ 00111101b = 11000111b
-11111010b ^ 00111110b = 11000100b
-11111010b ^ 00111111b = 11000101b
-11111010b ^ 01000000b = 10111010b
-11111010b ^ 01000001b = 10111011b
-11111010b ^ 01000010b = 10111000b
-11111010b ^ 01000011b = 10111001b
-11111010b ^ 01000100b = 10111110b
-11111010b ^ 01000101b = 10111111b
-11111010b ^ 01000110b = 10111100b
-11111010b ^ 01000111b = 10111101b
-11111010b ^ 01001000b = 10110010b
-11111010b ^ 01001001b = 10110011b
-11111010b ^ 01001010b = 10110000b
-11111010b ^ 01001011b = 10110001b
-11111010b ^ 01001100b = 10110110b
-11111010b ^ 01001101b = 10110111b
-11111010b ^ 01001110b = 10110100b
-11111010b ^ 01001111b = 10110101b
-11111010b ^ 01010000b = 10101010b
-11111010b ^ 01010001b = 10101011b
-11111010b ^ 01010010b = 10101000b
-11111010b ^ 01010011b = 10101001b
-11111010b ^ 01010100b = 10101110b
-11111010b ^ 01010101b = 10101111b
-11111010b ^ 01010110b = 10101100b
-11111010b ^ 01010111b = 10101101b
-11111010b ^ 01011000b = 10100010b
-11111010b ^ 01011001b = 10100011b
-11111010b ^ 01011010b = 10100000b
-11111010b ^ 01011011b = 10100001b
-11111010b ^ 01011100b = 10100110b
-11111010b ^ 01011101b = 10100111b
-11111010b ^ 01011110b = 10100100b
-11111010b ^ 01011111b = 10100101b
-11111010b ^ 01100000b = 10011010b
-11111010b ^ 01100001b = 10011011b
-11111010b ^ 01100010b = 10011000b
-11111010b ^ 01100011b = 10011001b
-11111010b ^ 01100100b = 10011110b
-11111010b ^ 01100101b = 10011111b
-11111010b ^ 01100110b = 10011100b
-11111010b ^ 01100111b = 10011101b
-11111010b ^ 01101000b = 10010010b
-11111010b ^ 01101001b = 10010011b
-11111010b ^ 01101010b = 10010000b
-11111010b ^ 01101011b = 10010001b
-11111010b ^ 01101100b = 10010110b
-11111010b ^ 01101101b = 10010111b
-11111010b ^ 01101110b = 10010100b
-11111010b ^ 01101111b = 10010101b
-11111010b ^ 01110000b = 10001010b
-11111010b ^ 01110001b = 10001011b
-11111010b ^ 01110010b = 10001000b
-11111010b ^ 01110011b = 10001001b
-11111010b ^ 01110100b = 10001110b
-11111010b ^ 01110101b = 10001111b
-11111010b ^ 01110110b = 10001100b
-11111010b ^ 01110111b = 10001101b
-11111010b ^ 01111000b = 10000010b
-11111010b ^ 01111001b = 10000011b
-11111010b ^ 01111010b = 10000000b
-11111010b ^ 01111011b = 10000001b
-11111010b ^ 01111100b = 10000110b
-11111010b ^ 01111101b = 10000111b
-11111010b ^ 01111110b = 10000100b
-11111011b ^ 10000000b = 01111011b
-11111011b ^ 10000001b = 01111010b
-11111011b ^ 10000010b = 01111001b
-11111011b ^ 10000011b = 01111000b
-11111011b ^ 10000100b = 01111111b
-11111011b ^ 10000101b = 01111110b
-11111011b ^ 10000110b = 01111101b
-11111011b ^ 10000111b = 01111100b
-11111011b ^ 10001000b = 01110011b
-11111011b ^ 10001001b = 01110010b
-11111011b ^ 10001010b = 01110001b
-11111011b ^ 10001011b = 01110000b
-11111011b ^ 10001100b = 01110111b
-11111011b ^ 10001101b = 01110110b
-11111011b ^ 10001110b = 01110101b
-11111011b ^ 10001111b = 01110100b
-11111011b ^ 10010000b = 01101011b
-11111011b ^ 10010001b = 01101010b
-11111011b ^ 10010010b = 01101001b
-11111011b ^ 10010011b = 01101000b
-11111011b ^ 10010100b = 01101111b
-11111011b ^ 10010101b = 01101110b
-11111011b ^ 10010110b = 01101101b
-11111011b ^ 10010111b = 01101100b
-11111011b ^ 10011000b = 01100011b
-11111011b ^ 10011001b = 01100010b
-11111011b ^ 10011010b = 01100001b
-11111011b ^ 10011011b = 01100000b
-11111011b ^ 10011100b = 01100111b
-11111011b ^ 10011101b = 01100110b
-11111011b ^ 10011110b = 01100101b
-11111011b ^ 10011111b = 01100100b
-11111011b ^ 10100000b = 01011011b
-11111011b ^ 10100001b = 01011010b
-11111011b ^ 10100010b = 01011001b
-11111011b ^ 10100011b = 01011000b
-11111011b ^ 10100100b = 01011111b
-11111011b ^ 10100101b = 01011110b
-11111011b ^ 10100110b = 01011101b
-11111011b ^ 10100111b = 01011100b
-11111011b ^ 10101000b = 01010011b
-11111011b ^ 10101001b = 01010010b
-11111011b ^ 10101010b = 01010001b
-11111011b ^ 10101011b = 01010000b
-11111011b ^ 10101100b = 01010111b
-11111011b ^ 10101101b = 01010110b
-11111011b ^ 10101110b = 01010101b
-11111011b ^ 10101111b = 01010100b
-11111011b ^ 10110000b = 01001011b
-11111011b ^ 10110001b = 01001010b
-11111011b ^ 10110010b = 01001001b
-11111011b ^ 10110011b = 01001000b
-11111011b ^ 10110100b = 01001111b
-11111011b ^ 10110101b = 01001110b
-11111011b ^ 10110110b = 01001101b
-11111011b ^ 10110111b = 01001100b
-11111011b ^ 10111000b = 01000011b
-11111011b ^ 10111001b = 01000010b
-11111011b ^ 10111010b = 01000001b
-11111011b ^ 10111011b = 01000000b
-11111011b ^ 10111100b = 01000111b
-11111011b ^ 10111101b = 01000110b
-11111011b ^ 10111110b = 01000101b
-11111011b ^ 10111111b = 01000100b
-11111011b ^ 11000000b = 00111011b
-11111011b ^ 11000001b = 00111010b
-11111011b ^ 11000010b = 00111001b
-11111011b ^ 11000011b = 00111000b
-11111011b ^ 11000100b = 00111111b
-11111011b ^ 11000101b = 00111110b
-11111011b ^ 11000110b = 00111101b
-11111011b ^ 11000111b = 00111100b
-11111011b ^ 11001000b = 00110011b
-11111011b ^ 11001001b = 00110010b
-11111011b ^ 11001010b = 00110001b
-11111011b ^ 11001011b = 00110000b
-11111011b ^ 11001100b = 00110111b
-11111011b ^ 11001101b = 00110110b
-11111011b ^ 11001110b = 00110101b
-11111011b ^ 11001111b = 00110100b
-11111011b ^ 11010000b = 00101011b
-11111011b ^ 11010001b = 00101010b
-11111011b ^ 11010010b = 00101001b
-11111011b ^ 11010011b = 00101000b
-11111011b ^ 11010100b = 00101111b
-11111011b ^ 11010101b = 00101110b
-11111011b ^ 11010110b = 00101101b
-11111011b ^ 11010111b = 00101100b
-11111011b ^ 11011000b = 00100011b
-11111011b ^ 11011001b = 00100010b
-11111011b ^ 11011010b = 00100001b
-11111011b ^ 11011011b = 00100000b
-11111011b ^ 11011100b = 00100111b
-11111011b ^ 11011101b = 00100110b
-11111011b ^ 11011110b = 00100101b
-11111011b ^ 11011111b = 00100100b
-11111011b ^ 11100000b = 00011011b
-11111011b ^ 11100001b = 00011010b
-11111011b ^ 11100010b = 00011001b
-11111011b ^ 11100011b = 00011000b
-11111011b ^ 11100100b = 00011111b
-11111011b ^ 11100101b = 00011110b
-11111011b ^ 11100110b = 00011101b
-11111011b ^ 11100111b = 00011100b
-11111011b ^ 11101000b = 00010011b
-11111011b ^ 11101001b = 00010010b
-11111011b ^ 11101010b = 00010001b
-11111011b ^ 11101011b = 00010000b
-11111011b ^ 11101100b = 00010111b
-11111011b ^ 11101101b = 00010110b
-11111011b ^ 11101110b = 00010101b
-11111011b ^ 11101111b = 00010100b
-11111011b ^ 11110000b = 00001011b
-11111011b ^ 11110001b = 00001010b
-11111011b ^ 11110010b = 00001001b
-11111011b ^ 11110011b = 00001000b
-11111011b ^ 11110100b = 00001111b
-11111011b ^ 11110101b = 00001110b
-11111011b ^ 11110110b = 00001101b
-11111011b ^ 11110111b = 00001100b
-11111011b ^ 11111000b = 00000011b
-11111011b ^ 11111001b = 00000010b
-11111011b ^ 11111010b = 00000001b
-11111011b ^ 11111011b = 00000000b
-11111011b ^ 11111100b = 00000111b
-11111011b ^ 11111101b = 00000110b
-11111011b ^ 11111110b = 00000101b
-11111011b ^ 11111111b = 00000100b
-11111011b ^ 00000000b = 11111011b
-11111011b ^ 00000001b = 11111010b
-11111011b ^ 00000010b = 11111001b
-11111011b ^ 00000011b = 11111000b
-11111011b ^ 00000100b = 11111111b
-11111011b ^ 00000101b = 11111110b
-11111011b ^ 00000110b = 11111101b
-11111011b ^ 00000111b = 11111100b
-11111011b ^ 00001000b = 11110011b
-11111011b ^ 00001001b = 11110010b
-11111011b ^ 00001010b = 11110001b
-11111011b ^ 00001011b = 11110000b
-11111011b ^ 00001100b = 11110111b
-11111011b ^ 00001101b = 11110110b
-11111011b ^ 00001110b = 11110101b
-11111011b ^ 00001111b = 11110100b
-11111011b ^ 00010000b = 11101011b
-11111011b ^ 00010001b = 11101010b
-11111011b ^ 00010010b = 11101001b
-11111011b ^ 00010011b = 11101000b
-11111011b ^ 00010100b = 11101111b
-11111011b ^ 00010101b = 11101110b
-11111011b ^ 00010110b = 11101101b
-11111011b ^ 00010111b = 11101100b
-11111011b ^ 00011000b = 11100011b
-11111011b ^ 00011001b = 11100010b
-11111011b ^ 00011010b = 11100001b
-11111011b ^ 00011011b = 11100000b
-11111011b ^ 00011100b = 11100111b
-11111011b ^ 00011101b = 11100110b
-11111011b ^ 00011110b = 11100101b
-11111011b ^ 00011111b = 11100100b
-11111011b ^ 00100000b = 11011011b
-11111011b ^ 00100001b = 11011010b
-11111011b ^ 00100010b = 11011001b
-11111011b ^ 00100011b = 11011000b
-11111011b ^ 00100100b = 11011111b
-11111011b ^ 00100101b = 11011110b
-11111011b ^ 00100110b = 11011101b
-11111011b ^ 00100111b = 11011100b
-11111011b ^ 00101000b = 11010011b
-11111011b ^ 00101001b = 11010010b
-11111011b ^ 00101010b = 11010001b
-11111011b ^ 00101011b = 11010000b
-11111011b ^ 00101100b = 11010111b
-11111011b ^ 00101101b = 11010110b
-11111011b ^ 00101110b = 11010101b
-11111011b ^ 00101111b = 11010100b
-11111011b ^ 00110000b = 11001011b
-11111011b ^ 00110001b = 11001010b
-11111011b ^ 00110010b = 11001001b
-11111011b ^ 00110011b = 11001000b
-11111011b ^ 00110100b = 11001111b
-11111011b ^ 00110101b = 11001110b
-11111011b ^ 00110110b = 11001101b
-11111011b ^ 00110111b = 11001100b
-11111011b ^ 00111000b = 11000011b
-11111011b ^ 00111001b = 11000010b
-11111011b ^ 00111010b = 11000001b
-11111011b ^ 00111011b = 11000000b
-11111011b ^ 00111100b = 11000111b
-11111011b ^ 00111101b = 11000110b
-11111011b ^ 00111110b = 11000101b
-11111011b ^ 00111111b = 11000100b
-11111011b ^ 01000000b = 10111011b
-11111011b ^ 01000001b = 10111010b
-11111011b ^ 01000010b = 10111001b
-11111011b ^ 01000011b = 10111000b
-11111011b ^ 01000100b = 10111111b
-11111011b ^ 01000101b = 10111110b
-11111011b ^ 01000110b = 10111101b
-11111011b ^ 01000111b = 10111100b
-11111011b ^ 01001000b = 10110011b
-11111011b ^ 01001001b = 10110010b
-11111011b ^ 01001010b = 10110001b
-11111011b ^ 01001011b = 10110000b
-11111011b ^ 01001100b = 10110111b
-11111011b ^ 01001101b = 10110110b
-11111011b ^ 01001110b = 10110101b
-11111011b ^ 01001111b = 10110100b
-11111011b ^ 01010000b = 10101011b
-11111011b ^ 01010001b = 10101010b
-11111011b ^ 01010010b = 10101001b
-11111011b ^ 01010011b = 10101000b
-11111011b ^ 01010100b = 10101111b
-11111011b ^ 01010101b = 10101110b
-11111011b ^ 01010110b = 10101101b
-11111011b ^ 01010111b = 10101100b
-11111011b ^ 01011000b = 10100011b
-11111011b ^ 01011001b = 10100010b
-11111011b ^ 01011010b = 10100001b
-11111011b ^ 01011011b = 10100000b
-11111011b ^ 01011100b = 10100111b
-11111011b ^ 01011101b = 10100110b
-11111011b ^ 01011110b = 10100101b
-11111011b ^ 01011111b = 10100100b
-11111011b ^ 01100000b = 10011011b
-11111011b ^ 01100001b = 10011010b
-11111011b ^ 01100010b = 10011001b
-11111011b ^ 01100011b = 10011000b
-11111011b ^ 01100100b = 10011111b
-11111011b ^ 01100101b = 10011110b
-11111011b ^ 01100110b = 10011101b
-11111011b ^ 01100111b = 10011100b
-11111011b ^ 01101000b = 10010011b
-11111011b ^ 01101001b = 10010010b
-11111011b ^ 01101010b = 10010001b
-11111011b ^ 01101011b = 10010000b
-11111011b ^ 01101100b = 10010111b
-11111011b ^ 01101101b = 10010110b
-11111011b ^ 01101110b = 10010101b
-11111011b ^ 01101111b = 10010100b
-11111011b ^ 01110000b = 10001011b
-11111011b ^ 01110001b = 10001010b
-11111011b ^ 01110010b = 10001001b
-11111011b ^ 01110011b = 10001000b
-11111011b ^ 01110100b = 10001111b
-11111011b ^ 01110101b = 10001110b
-11111011b ^ 01110110b = 10001101b
-11111011b ^ 01110111b = 10001100b
-11111011b ^ 01111000b = 10000011b
-11111011b ^ 01111001b = 10000010b
-11111011b ^ 01111010b = 10000001b
-11111011b ^ 01111011b = 10000000b
-11111011b ^ 01111100b = 10000111b
-11111011b ^ 01111101b = 10000110b
-11111011b ^ 01111110b = 10000101b
-11111100b ^ 10000000b = 01111100b
-11111100b ^ 10000001b = 01111101b
-11111100b ^ 10000010b = 01111110b
-11111100b ^ 10000011b = 01111111b
-11111100b ^ 10000100b = 01111000b
-11111100b ^ 10000101b = 01111001b
-11111100b ^ 10000110b = 01111010b
-11111100b ^ 10000111b = 01111011b
-11111100b ^ 10001000b = 01110100b
-11111100b ^ 10001001b = 01110101b
-11111100b ^ 10001010b = 01110110b
-11111100b ^ 10001011b = 01110111b
-11111100b ^ 10001100b = 01110000b
-11111100b ^ 10001101b = 01110001b
-11111100b ^ 10001110b = 01110010b
-11111100b ^ 10001111b = 01110011b
-11111100b ^ 10010000b = 01101100b
-11111100b ^ 10010001b = 01101101b
-11111100b ^ 10010010b = 01101110b
-11111100b ^ 10010011b = 01101111b
-11111100b ^ 10010100b = 01101000b
-11111100b ^ 10010101b = 01101001b
-11111100b ^ 10010110b = 01101010b
-11111100b ^ 10010111b = 01101011b
-11111100b ^ 10011000b = 01100100b
-11111100b ^ 10011001b = 01100101b
-11111100b ^ 10011010b = 01100110b
-11111100b ^ 10011011b = 01100111b
-11111100b ^ 10011100b = 01100000b
-11111100b ^ 10011101b = 01100001b
-11111100b ^ 10011110b = 01100010b
-11111100b ^ 10011111b = 01100011b
-11111100b ^ 10100000b = 01011100b
-11111100b ^ 10100001b = 01011101b
-11111100b ^ 10100010b = 01011110b
-11111100b ^ 10100011b = 01011111b
-11111100b ^ 10100100b = 01011000b
-11111100b ^ 10100101b = 01011001b
-11111100b ^ 10100110b = 01011010b
-11111100b ^ 10100111b = 01011011b
-11111100b ^ 10101000b = 01010100b
-11111100b ^ 10101001b = 01010101b
-11111100b ^ 10101010b = 01010110b
-11111100b ^ 10101011b = 01010111b
-11111100b ^ 10101100b = 01010000b
-11111100b ^ 10101101b = 01010001b
-11111100b ^ 10101110b = 01010010b
-11111100b ^ 10101111b = 01010011b
-11111100b ^ 10110000b = 01001100b
-11111100b ^ 10110001b = 01001101b
-11111100b ^ 10110010b = 01001110b
-11111100b ^ 10110011b = 01001111b
-11111100b ^ 10110100b = 01001000b
-11111100b ^ 10110101b = 01001001b
-11111100b ^ 10110110b = 01001010b
-11111100b ^ 10110111b = 01001011b
-11111100b ^ 10111000b = 01000100b
-11111100b ^ 10111001b = 01000101b
-11111100b ^ 10111010b = 01000110b
-11111100b ^ 10111011b = 01000111b
-11111100b ^ 10111100b = 01000000b
-11111100b ^ 10111101b = 01000001b
-11111100b ^ 10111110b = 01000010b
-11111100b ^ 10111111b = 01000011b
-11111100b ^ 11000000b = 00111100b
-11111100b ^ 11000001b = 00111101b
-11111100b ^ 11000010b = 00111110b
-11111100b ^ 11000011b = 00111111b
-11111100b ^ 11000100b = 00111000b
-11111100b ^ 11000101b = 00111001b
-11111100b ^ 11000110b = 00111010b
-11111100b ^ 11000111b = 00111011b
-11111100b ^ 11001000b = 00110100b
-11111100b ^ 11001001b = 00110101b
-11111100b ^ 11001010b = 00110110b
-11111100b ^ 11001011b = 00110111b
-11111100b ^ 11001100b = 00110000b
-11111100b ^ 11001101b = 00110001b
-11111100b ^ 11001110b = 00110010b
-11111100b ^ 11001111b = 00110011b
-11111100b ^ 11010000b = 00101100b
-11111100b ^ 11010001b = 00101101b
-11111100b ^ 11010010b = 00101110b
-11111100b ^ 11010011b = 00101111b
-11111100b ^ 11010100b = 00101000b
-11111100b ^ 11010101b = 00101001b
-11111100b ^ 11010110b = 00101010b
-11111100b ^ 11010111b = 00101011b
-11111100b ^ 11011000b = 00100100b
-11111100b ^ 11011001b = 00100101b
-11111100b ^ 11011010b = 00100110b
-11111100b ^ 11011011b = 00100111b
-11111100b ^ 11011100b = 00100000b
-11111100b ^ 11011101b = 00100001b
-11111100b ^ 11011110b = 00100010b
-11111100b ^ 11011111b = 00100011b
-11111100b ^ 11100000b = 00011100b
-11111100b ^ 11100001b = 00011101b
-11111100b ^ 11100010b = 00011110b
-11111100b ^ 11100011b = 00011111b
-11111100b ^ 11100100b = 00011000b
-11111100b ^ 11100101b = 00011001b
-11111100b ^ 11100110b = 00011010b
-11111100b ^ 11100111b = 00011011b
-11111100b ^ 11101000b = 00010100b
-11111100b ^ 11101001b = 00010101b
-11111100b ^ 11101010b = 00010110b
-11111100b ^ 11101011b = 00010111b
-11111100b ^ 11101100b = 00010000b
-11111100b ^ 11101101b = 00010001b
-11111100b ^ 11101110b = 00010010b
-11111100b ^ 11101111b = 00010011b
-11111100b ^ 11110000b = 00001100b
-11111100b ^ 11110001b = 00001101b
-11111100b ^ 11110010b = 00001110b
-11111100b ^ 11110011b = 00001111b
-11111100b ^ 11110100b = 00001000b
-11111100b ^ 11110101b = 00001001b
-11111100b ^ 11110110b = 00001010b
-11111100b ^ 11110111b = 00001011b
-11111100b ^ 11111000b = 00000100b
-11111100b ^ 11111001b = 00000101b
-11111100b ^ 11111010b = 00000110b
-11111100b ^ 11111011b = 00000111b
-11111100b ^ 11111100b = 00000000b
-11111100b ^ 11111101b = 00000001b
-11111100b ^ 11111110b = 00000010b
-11111100b ^ 11111111b = 00000011b
-11111100b ^ 00000000b = 11111100b
-11111100b ^ 00000001b = 11111101b
-11111100b ^ 00000010b = 11111110b
-11111100b ^ 00000011b = 11111111b
-11111100b ^ 00000100b = 11111000b
-11111100b ^ 00000101b = 11111001b
-11111100b ^ 00000110b = 11111010b
-11111100b ^ 00000111b = 11111011b
-11111100b ^ 00001000b = 11110100b
-11111100b ^ 00001001b = 11110101b
-11111100b ^ 00001010b = 11110110b
-11111100b ^ 00001011b = 11110111b
-11111100b ^ 00001100b = 11110000b
-11111100b ^ 00001101b = 11110001b
-11111100b ^ 00001110b = 11110010b
-11111100b ^ 00001111b = 11110011b
-11111100b ^ 00010000b = 11101100b
-11111100b ^ 00010001b = 11101101b
-11111100b ^ 00010010b = 11101110b
-11111100b ^ 00010011b = 11101111b
-11111100b ^ 00010100b = 11101000b
-11111100b ^ 00010101b = 11101001b
-11111100b ^ 00010110b = 11101010b
-11111100b ^ 00010111b = 11101011b
-11111100b ^ 00011000b = 11100100b
-11111100b ^ 00011001b = 11100101b
-11111100b ^ 00011010b = 11100110b
-11111100b ^ 00011011b = 11100111b
-11111100b ^ 00011100b = 11100000b
-11111100b ^ 00011101b = 11100001b
-11111100b ^ 00011110b = 11100010b
-11111100b ^ 00011111b = 11100011b
-11111100b ^ 00100000b = 11011100b
-11111100b ^ 00100001b = 11011101b
-11111100b ^ 00100010b = 11011110b
-11111100b ^ 00100011b = 11011111b
-11111100b ^ 00100100b = 11011000b
-11111100b ^ 00100101b = 11011001b
-11111100b ^ 00100110b = 11011010b
-11111100b ^ 00100111b = 11011011b
-11111100b ^ 00101000b = 11010100b
-11111100b ^ 00101001b = 11010101b
-11111100b ^ 00101010b = 11010110b
-11111100b ^ 00101011b = 11010111b
-11111100b ^ 00101100b = 11010000b
-11111100b ^ 00101101b = 11010001b
-11111100b ^ 00101110b = 11010010b
-11111100b ^ 00101111b = 11010011b
-11111100b ^ 00110000b = 11001100b
-11111100b ^ 00110001b = 11001101b
-11111100b ^ 00110010b = 11001110b
-11111100b ^ 00110011b = 11001111b
-11111100b ^ 00110100b = 11001000b
-11111100b ^ 00110101b = 11001001b
-11111100b ^ 00110110b = 11001010b
-11111100b ^ 00110111b = 11001011b
-11111100b ^ 00111000b = 11000100b
-11111100b ^ 00111001b = 11000101b
-11111100b ^ 00111010b = 11000110b
-11111100b ^ 00111011b = 11000111b
-11111100b ^ 00111100b = 11000000b
-11111100b ^ 00111101b = 11000001b
-11111100b ^ 00111110b = 11000010b
-11111100b ^ 00111111b = 11000011b
-11111100b ^ 01000000b = 10111100b
-11111100b ^ 01000001b = 10111101b
-11111100b ^ 01000010b = 10111110b
-11111100b ^ 01000011b = 10111111b
-11111100b ^ 01000100b = 10111000b
-11111100b ^ 01000101b = 10111001b
-11111100b ^ 01000110b = 10111010b
-11111100b ^ 01000111b = 10111011b
-11111100b ^ 01001000b = 10110100b
-11111100b ^ 01001001b = 10110101b
-11111100b ^ 01001010b = 10110110b
-11111100b ^ 01001011b = 10110111b
-11111100b ^ 01001100b = 10110000b
-11111100b ^ 01001101b = 10110001b
-11111100b ^ 01001110b = 10110010b
-11111100b ^ 01001111b = 10110011b
-11111100b ^ 01010000b = 10101100b
-11111100b ^ 01010001b = 10101101b
-11111100b ^ 01010010b = 10101110b
-11111100b ^ 01010011b = 10101111b
-11111100b ^ 01010100b = 10101000b
-11111100b ^ 01010101b = 10101001b
-11111100b ^ 01010110b = 10101010b
-11111100b ^ 01010111b = 10101011b
-11111100b ^ 01011000b = 10100100b
-11111100b ^ 01011001b = 10100101b
-11111100b ^ 01011010b = 10100110b
-11111100b ^ 01011011b = 10100111b
-11111100b ^ 01011100b = 10100000b
-11111100b ^ 01011101b = 10100001b
-11111100b ^ 01011110b = 10100010b
-11111100b ^ 01011111b = 10100011b
-11111100b ^ 01100000b = 10011100b
-11111100b ^ 01100001b = 10011101b
-11111100b ^ 01100010b = 10011110b
-11111100b ^ 01100011b = 10011111b
-11111100b ^ 01100100b = 10011000b
-11111100b ^ 01100101b = 10011001b
-11111100b ^ 01100110b = 10011010b
-11111100b ^ 01100111b = 10011011b
-11111100b ^ 01101000b = 10010100b
-11111100b ^ 01101001b = 10010101b
-11111100b ^ 01101010b = 10010110b
-11111100b ^ 01101011b = 10010111b
-11111100b ^ 01101100b = 10010000b
-11111100b ^ 01101101b = 10010001b
-11111100b ^ 01101110b = 10010010b
-11111100b ^ 01101111b = 10010011b
-11111100b ^ 01110000b = 10001100b
-11111100b ^ 01110001b = 10001101b
-11111100b ^ 01110010b = 10001110b
-11111100b ^ 01110011b = 10001111b
-11111100b ^ 01110100b = 10001000b
-11111100b ^ 01110101b = 10001001b
-11111100b ^ 01110110b = 10001010b
-11111100b ^ 01110111b = 10001011b
-11111100b ^ 01111000b = 10000100b
-11111100b ^ 01111001b = 10000101b
-11111100b ^ 01111010b = 10000110b
-11111100b ^ 01111011b = 10000111b
-11111100b ^ 01111100b = 10000000b
-11111100b ^ 01111101b = 10000001b
-11111100b ^ 01111110b = 10000010b
-11111101b ^ 10000000b = 01111101b
-11111101b ^ 10000001b = 01111100b
-11111101b ^ 10000010b = 01111111b
-11111101b ^ 10000011b = 01111110b
-11111101b ^ 10000100b = 01111001b
-11111101b ^ 10000101b = 01111000b
-11111101b ^ 10000110b = 01111011b
-11111101b ^ 10000111b = 01111010b
-11111101b ^ 10001000b = 01110101b
-11111101b ^ 10001001b = 01110100b
-11111101b ^ 10001010b = 01110111b
-11111101b ^ 10001011b = 01110110b
-11111101b ^ 10001100b = 01110001b
-11111101b ^ 10001101b = 01110000b
-11111101b ^ 10001110b = 01110011b
-11111101b ^ 10001111b = 01110010b
-11111101b ^ 10010000b = 01101101b
-11111101b ^ 10010001b = 01101100b
-11111101b ^ 10010010b = 01101111b
-11111101b ^ 10010011b = 01101110b
-11111101b ^ 10010100b = 01101001b
-11111101b ^ 10010101b = 01101000b
-11111101b ^ 10010110b = 01101011b
-11111101b ^ 10010111b = 01101010b
-11111101b ^ 10011000b = 01100101b
-11111101b ^ 10011001b = 01100100b
-11111101b ^ 10011010b = 01100111b
-11111101b ^ 10011011b = 01100110b
-11111101b ^ 10011100b = 01100001b
-11111101b ^ 10011101b = 01100000b
-11111101b ^ 10011110b = 01100011b
-11111101b ^ 10011111b = 01100010b
-11111101b ^ 10100000b = 01011101b
-11111101b ^ 10100001b = 01011100b
-11111101b ^ 10100010b = 01011111b
-11111101b ^ 10100011b = 01011110b
-11111101b ^ 10100100b = 01011001b
-11111101b ^ 10100101b = 01011000b
-11111101b ^ 10100110b = 01011011b
-11111101b ^ 10100111b = 01011010b
-11111101b ^ 10101000b = 01010101b
-11111101b ^ 10101001b = 01010100b
-11111101b ^ 10101010b = 01010111b
-11111101b ^ 10101011b = 01010110b
-11111101b ^ 10101100b = 01010001b
-11111101b ^ 10101101b = 01010000b
-11111101b ^ 10101110b = 01010011b
-11111101b ^ 10101111b = 01010010b
-11111101b ^ 10110000b = 01001101b
-11111101b ^ 10110001b = 01001100b
-11111101b ^ 10110010b = 01001111b
-11111101b ^ 10110011b = 01001110b
-11111101b ^ 10110100b = 01001001b
-11111101b ^ 10110101b = 01001000b
-11111101b ^ 10110110b = 01001011b
-11111101b ^ 10110111b = 01001010b
-11111101b ^ 10111000b = 01000101b
-11111101b ^ 10111001b = 01000100b
-11111101b ^ 10111010b = 01000111b
-11111101b ^ 10111011b = 01000110b
-11111101b ^ 10111100b = 01000001b
-11111101b ^ 10111101b = 01000000b
-11111101b ^ 10111110b = 01000011b
-11111101b ^ 10111111b = 01000010b
-11111101b ^ 11000000b = 00111101b
-11111101b ^ 11000001b = 00111100b
-11111101b ^ 11000010b = 00111111b
-11111101b ^ 11000011b = 00111110b
-11111101b ^ 11000100b = 00111001b
-11111101b ^ 11000101b = 00111000b
-11111101b ^ 11000110b = 00111011b
-11111101b ^ 11000111b = 00111010b
-11111101b ^ 11001000b = 00110101b
-11111101b ^ 11001001b = 00110100b
-11111101b ^ 11001010b = 00110111b
-11111101b ^ 11001011b = 00110110b
-11111101b ^ 11001100b = 00110001b
-11111101b ^ 11001101b = 00110000b
-11111101b ^ 11001110b = 00110011b
-11111101b ^ 11001111b = 00110010b
-11111101b ^ 11010000b = 00101101b
-11111101b ^ 11010001b = 00101100b
-11111101b ^ 11010010b = 00101111b
-11111101b ^ 11010011b = 00101110b
-11111101b ^ 11010100b = 00101001b
-11111101b ^ 11010101b = 00101000b
-11111101b ^ 11010110b = 00101011b
-11111101b ^ 11010111b = 00101010b
-11111101b ^ 11011000b = 00100101b
-11111101b ^ 11011001b = 00100100b
-11111101b ^ 11011010b = 00100111b
-11111101b ^ 11011011b = 00100110b
-11111101b ^ 11011100b = 00100001b
-11111101b ^ 11011101b = 00100000b
-11111101b ^ 11011110b = 00100011b
-11111101b ^ 11011111b = 00100010b
-11111101b ^ 11100000b = 00011101b
-11111101b ^ 11100001b = 00011100b
-11111101b ^ 11100010b = 00011111b
-11111101b ^ 11100011b = 00011110b
-11111101b ^ 11100100b = 00011001b
-11111101b ^ 11100101b = 00011000b
-11111101b ^ 11100110b = 00011011b
-11111101b ^ 11100111b = 00011010b
-11111101b ^ 11101000b = 00010101b
-11111101b ^ 11101001b = 00010100b
-11111101b ^ 11101010b = 00010111b
-11111101b ^ 11101011b = 00010110b
-11111101b ^ 11101100b = 00010001b
-11111101b ^ 11101101b = 00010000b
-11111101b ^ 11101110b = 00010011b
-11111101b ^ 11101111b = 00010010b
-11111101b ^ 11110000b = 00001101b
-11111101b ^ 11110001b = 00001100b
-11111101b ^ 11110010b = 00001111b
-11111101b ^ 11110011b = 00001110b
-11111101b ^ 11110100b = 00001001b
-11111101b ^ 11110101b = 00001000b
-11111101b ^ 11110110b = 00001011b
-11111101b ^ 11110111b = 00001010b
-11111101b ^ 11111000b = 00000101b
-11111101b ^ 11111001b = 00000100b
-11111101b ^ 11111010b = 00000111b
-11111101b ^ 11111011b = 00000110b
-11111101b ^ 11111100b = 00000001b
-11111101b ^ 11111101b = 00000000b
-11111101b ^ 11111110b = 00000011b
-11111101b ^ 11111111b = 00000010b
-11111101b ^ 00000000b = 11111101b
-11111101b ^ 00000001b = 11111100b
-11111101b ^ 00000010b = 11111111b
-11111101b ^ 00000011b = 11111110b
-11111101b ^ 00000100b = 11111001b
-11111101b ^ 00000101b = 11111000b
-11111101b ^ 00000110b = 11111011b
-11111101b ^ 00000111b = 11111010b
-11111101b ^ 00001000b = 11110101b
-11111101b ^ 00001001b = 11110100b
-11111101b ^ 00001010b = 11110111b
-11111101b ^ 00001011b = 11110110b
-11111101b ^ 00001100b = 11110001b
-11111101b ^ 00001101b = 11110000b
-11111101b ^ 00001110b = 11110011b
-11111101b ^ 00001111b = 11110010b
-11111101b ^ 00010000b = 11101101b
-11111101b ^ 00010001b = 11101100b
-11111101b ^ 00010010b = 11101111b
-11111101b ^ 00010011b = 11101110b
-11111101b ^ 00010100b = 11101001b
-11111101b ^ 00010101b = 11101000b
-11111101b ^ 00010110b = 11101011b
-11111101b ^ 00010111b = 11101010b
-11111101b ^ 00011000b = 11100101b
-11111101b ^ 00011001b = 11100100b
-11111101b ^ 00011010b = 11100111b
-11111101b ^ 00011011b = 11100110b
-11111101b ^ 00011100b = 11100001b
-11111101b ^ 00011101b = 11100000b
-11111101b ^ 00011110b = 11100011b
-11111101b ^ 00011111b = 11100010b
-11111101b ^ 00100000b = 11011101b
-11111101b ^ 00100001b = 11011100b
-11111101b ^ 00100010b = 11011111b
-11111101b ^ 00100011b = 11011110b
-11111101b ^ 00100100b = 11011001b
-11111101b ^ 00100101b = 11011000b
-11111101b ^ 00100110b = 11011011b
-11111101b ^ 00100111b = 11011010b
-11111101b ^ 00101000b = 11010101b
-11111101b ^ 00101001b = 11010100b
-11111101b ^ 00101010b = 11010111b
-11111101b ^ 00101011b = 11010110b
-11111101b ^ 00101100b = 11010001b
-11111101b ^ 00101101b = 11010000b
-11111101b ^ 00101110b = 11010011b
-11111101b ^ 00101111b = 11010010b
-11111101b ^ 00110000b = 11001101b
-11111101b ^ 00110001b = 11001100b
-11111101b ^ 00110010b = 11001111b
-11111101b ^ 00110011b = 11001110b
-11111101b ^ 00110100b = 11001001b
-11111101b ^ 00110101b = 11001000b
-11111101b ^ 00110110b = 11001011b
-11111101b ^ 00110111b = 11001010b
-11111101b ^ 00111000b = 11000101b
-11111101b ^ 00111001b = 11000100b
-11111101b ^ 00111010b = 11000111b
-11111101b ^ 00111011b = 11000110b
-11111101b ^ 00111100b = 11000001b
-11111101b ^ 00111101b = 11000000b
-11111101b ^ 00111110b = 11000011b
-11111101b ^ 00111111b = 11000010b
-11111101b ^ 01000000b = 10111101b
-11111101b ^ 01000001b = 10111100b
-11111101b ^ 01000010b = 10111111b
-11111101b ^ 01000011b = 10111110b
-11111101b ^ 01000100b = 10111001b
-11111101b ^ 01000101b = 10111000b
-11111101b ^ 01000110b = 10111011b
-11111101b ^ 01000111b = 10111010b
-11111101b ^ 01001000b = 10110101b
-11111101b ^ 01001001b = 10110100b
-11111101b ^ 01001010b = 10110111b
-11111101b ^ 01001011b = 10110110b
-11111101b ^ 01001100b = 10110001b
-11111101b ^ 01001101b = 10110000b
-11111101b ^ 01001110b = 10110011b
-11111101b ^ 01001111b = 10110010b
-11111101b ^ 01010000b = 10101101b
-11111101b ^ 01010001b = 10101100b
-11111101b ^ 01010010b = 10101111b
-11111101b ^ 01010011b = 10101110b
-11111101b ^ 01010100b = 10101001b
-11111101b ^ 01010101b = 10101000b
-11111101b ^ 01010110b = 10101011b
-11111101b ^ 01010111b = 10101010b
-11111101b ^ 01011000b = 10100101b
-11111101b ^ 01011001b = 10100100b
-11111101b ^ 01011010b = 10100111b
-11111101b ^ 01011011b = 10100110b
-11111101b ^ 01011100b = 10100001b
-11111101b ^ 01011101b = 10100000b
-11111101b ^ 01011110b = 10100011b
-11111101b ^ 01011111b = 10100010b
-11111101b ^ 01100000b = 10011101b
-11111101b ^ 01100001b = 10011100b
-11111101b ^ 01100010b = 10011111b
-11111101b ^ 01100011b = 10011110b
-11111101b ^ 01100100b = 10011001b
-11111101b ^ 01100101b = 10011000b
-11111101b ^ 01100110b = 10011011b
-11111101b ^ 01100111b = 10011010b
-11111101b ^ 01101000b = 10010101b
-11111101b ^ 01101001b = 10010100b
-11111101b ^ 01101010b = 10010111b
-11111101b ^ 01101011b = 10010110b
-11111101b ^ 01101100b = 10010001b
-11111101b ^ 01101101b = 10010000b
-11111101b ^ 01101110b = 10010011b
-11111101b ^ 01101111b = 10010010b
-11111101b ^ 01110000b = 10001101b
-11111101b ^ 01110001b = 10001100b
-11111101b ^ 01110010b = 10001111b
-11111101b ^ 01110011b = 10001110b
-11111101b ^ 01110100b = 10001001b
-11111101b ^ 01110101b = 10001000b
-11111101b ^ 01110110b = 10001011b
-11111101b ^ 01110111b = 10001010b
-11111101b ^ 01111000b = 10000101b
-11111101b ^ 01111001b = 10000100b
-11111101b ^ 01111010b = 10000111b
-11111101b ^ 01111011b = 10000110b
-11111101b ^ 01111100b = 10000001b
-11111101b ^ 01111101b = 10000000b
-11111101b ^ 01111110b = 10000011b
-11111110b ^ 10000000b = 01111110b
-11111110b ^ 10000001b = 01111111b
-11111110b ^ 10000010b = 01111100b
-11111110b ^ 10000011b = 01111101b
-11111110b ^ 10000100b = 01111010b
-11111110b ^ 10000101b = 01111011b
-11111110b ^ 10000110b = 01111000b
-11111110b ^ 10000111b = 01111001b
-11111110b ^ 10001000b = 01110110b
-11111110b ^ 10001001b = 01110111b
-11111110b ^ 10001010b = 01110100b
-11111110b ^ 10001011b = 01110101b
-11111110b ^ 10001100b = 01110010b
-11111110b ^ 10001101b = 01110011b
-11111110b ^ 10001110b = 01110000b
-11111110b ^ 10001111b = 01110001b
-11111110b ^ 10010000b = 01101110b
-11111110b ^ 10010001b = 01101111b
-11111110b ^ 10010010b = 01101100b
-11111110b ^ 10010011b = 01101101b
-11111110b ^ 10010100b = 01101010b
-11111110b ^ 10010101b = 01101011b
-11111110b ^ 10010110b = 01101000b
-11111110b ^ 10010111b = 01101001b
-11111110b ^ 10011000b = 01100110b
-11111110b ^ 10011001b = 01100111b
-11111110b ^ 10011010b = 01100100b
-11111110b ^ 10011011b = 01100101b
-11111110b ^ 10011100b = 01100010b
-11111110b ^ 10011101b = 01100011b
-11111110b ^ 10011110b = 01100000b
-11111110b ^ 10011111b = 01100001b
-11111110b ^ 10100000b = 01011110b
-11111110b ^ 10100001b = 01011111b
-11111110b ^ 10100010b = 01011100b
-11111110b ^ 10100011b = 01011101b
-11111110b ^ 10100100b = 01011010b
-11111110b ^ 10100101b = 01011011b
-11111110b ^ 10100110b = 01011000b
-11111110b ^ 10100111b = 01011001b
-11111110b ^ 10101000b = 01010110b
-11111110b ^ 10101001b = 01010111b
-11111110b ^ 10101010b = 01010100b
-11111110b ^ 10101011b = 01010101b
-11111110b ^ 10101100b = 01010010b
-11111110b ^ 10101101b = 01010011b
-11111110b ^ 10101110b = 01010000b
-11111110b ^ 10101111b = 01010001b
-11111110b ^ 10110000b = 01001110b
-11111110b ^ 10110001b = 01001111b
-11111110b ^ 10110010b = 01001100b
-11111110b ^ 10110011b = 01001101b
-11111110b ^ 10110100b = 01001010b
-11111110b ^ 10110101b = 01001011b
-11111110b ^ 10110110b = 01001000b
-11111110b ^ 10110111b = 01001001b
-11111110b ^ 10111000b = 01000110b
-11111110b ^ 10111001b = 01000111b
-11111110b ^ 10111010b = 01000100b
-11111110b ^ 10111011b = 01000101b
-11111110b ^ 10111100b = 01000010b
-11111110b ^ 10111101b = 01000011b
-11111110b ^ 10111110b = 01000000b
-11111110b ^ 10111111b = 01000001b
-11111110b ^ 11000000b = 00111110b
-11111110b ^ 11000001b = 00111111b
-11111110b ^ 11000010b = 00111100b
-11111110b ^ 11000011b = 00111101b
-11111110b ^ 11000100b = 00111010b
-11111110b ^ 11000101b = 00111011b
-11111110b ^ 11000110b = 00111000b
-11111110b ^ 11000111b = 00111001b
-11111110b ^ 11001000b = 00110110b
-11111110b ^ 11001001b = 00110111b
-11111110b ^ 11001010b = 00110100b
-11111110b ^ 11001011b = 00110101b
-11111110b ^ 11001100b = 00110010b
-11111110b ^ 11001101b = 00110011b
-11111110b ^ 11001110b = 00110000b
-11111110b ^ 11001111b = 00110001b
-11111110b ^ 11010000b = 00101110b
-11111110b ^ 11010001b = 00101111b
-11111110b ^ 11010010b = 00101100b
-11111110b ^ 11010011b = 00101101b
-11111110b ^ 11010100b = 00101010b
-11111110b ^ 11010101b = 00101011b
-11111110b ^ 11010110b = 00101000b
-11111110b ^ 11010111b = 00101001b
-11111110b ^ 11011000b = 00100110b
-11111110b ^ 11011001b = 00100111b
-11111110b ^ 11011010b = 00100100b
-11111110b ^ 11011011b = 00100101b
-11111110b ^ 11011100b = 00100010b
-11111110b ^ 11011101b = 00100011b
-11111110b ^ 11011110b = 00100000b
-11111110b ^ 11011111b = 00100001b
-11111110b ^ 11100000b = 00011110b
-11111110b ^ 11100001b = 00011111b
-11111110b ^ 11100010b = 00011100b
-11111110b ^ 11100011b = 00011101b
-11111110b ^ 11100100b = 00011010b
-11111110b ^ 11100101b = 00011011b
-11111110b ^ 11100110b = 00011000b
-11111110b ^ 11100111b = 00011001b
-11111110b ^ 11101000b = 00010110b
-11111110b ^ 11101001b = 00010111b
-11111110b ^ 11101010b = 00010100b
-11111110b ^ 11101011b = 00010101b
-11111110b ^ 11101100b = 00010010b
-11111110b ^ 11101101b = 00010011b
-11111110b ^ 11101110b = 00010000b
-11111110b ^ 11101111b = 00010001b
-11111110b ^ 11110000b = 00001110b
-11111110b ^ 11110001b = 00001111b
-11111110b ^ 11110010b = 00001100b
-11111110b ^ 11110011b = 00001101b
-11111110b ^ 11110100b = 00001010b
-11111110b ^ 11110101b = 00001011b
-11111110b ^ 11110110b = 00001000b
-11111110b ^ 11110111b = 00001001b
-11111110b ^ 11111000b = 00000110b
-11111110b ^ 11111001b = 00000111b
-11111110b ^ 11111010b = 00000100b
-11111110b ^ 11111011b = 00000101b
-11111110b ^ 11111100b = 00000010b
-11111110b ^ 11111101b = 00000011b
-11111110b ^ 11111110b = 00000000b
-11111110b ^ 11111111b = 00000001b
-11111110b ^ 00000000b = 11111110b
-11111110b ^ 00000001b = 11111111b
-11111110b ^ 00000010b = 11111100b
-11111110b ^ 00000011b = 11111101b
-11111110b ^ 00000100b = 11111010b
-11111110b ^ 00000101b = 11111011b
-11111110b ^ 00000110b = 11111000b
-11111110b ^ 00000111b = 11111001b
-11111110b ^ 00001000b = 11110110b
-11111110b ^ 00001001b = 11110111b
-11111110b ^ 00001010b = 11110100b
-11111110b ^ 00001011b = 11110101b
-11111110b ^ 00001100b = 11110010b
-11111110b ^ 00001101b = 11110011b
-11111110b ^ 00001110b = 11110000b
-11111110b ^ 00001111b = 11110001b
-11111110b ^ 00010000b = 11101110b
-11111110b ^ 00010001b = 11101111b
-11111110b ^ 00010010b = 11101100b
-11111110b ^ 00010011b = 11101101b
-11111110b ^ 00010100b = 11101010b
-11111110b ^ 00010101b = 11101011b
-11111110b ^ 00010110b = 11101000b
-11111110b ^ 00010111b = 11101001b
-11111110b ^ 00011000b = 11100110b
-11111110b ^ 00011001b = 11100111b
-11111110b ^ 00011010b = 11100100b
-11111110b ^ 00011011b = 11100101b
-11111110b ^ 00011100b = 11100010b
-11111110b ^ 00011101b = 11100011b
-11111110b ^ 00011110b = 11100000b
-11111110b ^ 00011111b = 11100001b
-11111110b ^ 00100000b = 11011110b
-11111110b ^ 00100001b = 11011111b
-11111110b ^ 00100010b = 11011100b
-11111110b ^ 00100011b = 11011101b
-11111110b ^ 00100100b = 11011010b
-11111110b ^ 00100101b = 11011011b
-11111110b ^ 00100110b = 11011000b
-11111110b ^ 00100111b = 11011001b
-11111110b ^ 00101000b = 11010110b
-11111110b ^ 00101001b = 11010111b
-11111110b ^ 00101010b = 11010100b
-11111110b ^ 00101011b = 11010101b
-11111110b ^ 00101100b = 11010010b
-11111110b ^ 00101101b = 11010011b
-11111110b ^ 00101110b = 11010000b
-11111110b ^ 00101111b = 11010001b
-11111110b ^ 00110000b = 11001110b
-11111110b ^ 00110001b = 11001111b
-11111110b ^ 00110010b = 11001100b
-11111110b ^ 00110011b = 11001101b
-11111110b ^ 00110100b = 11001010b
-11111110b ^ 00110101b = 11001011b
-11111110b ^ 00110110b = 11001000b
-11111110b ^ 00110111b = 11001001b
-11111110b ^ 00111000b = 11000110b
-11111110b ^ 00111001b = 11000111b
-11111110b ^ 00111010b = 11000100b
-11111110b ^ 00111011b = 11000101b
-11111110b ^ 00111100b = 11000010b
-11111110b ^ 00111101b = 11000011b
-11111110b ^ 00111110b = 11000000b
-11111110b ^ 00111111b = 11000001b
-11111110b ^ 01000000b = 10111110b
-11111110b ^ 01000001b = 10111111b
-11111110b ^ 01000010b = 10111100b
-11111110b ^ 01000011b = 10111101b
-11111110b ^ 01000100b = 10111010b
-11111110b ^ 01000101b = 10111011b
-11111110b ^ 01000110b = 10111000b
-11111110b ^ 01000111b = 10111001b
-11111110b ^ 01001000b = 10110110b
-11111110b ^ 01001001b = 10110111b
-11111110b ^ 01001010b = 10110100b
-11111110b ^ 01001011b = 10110101b
-11111110b ^ 01001100b = 10110010b
-11111110b ^ 01001101b = 10110011b
-11111110b ^ 01001110b = 10110000b
-11111110b ^ 01001111b = 10110001b
-11111110b ^ 01010000b = 10101110b
-11111110b ^ 01010001b = 10101111b
-11111110b ^ 01010010b = 10101100b
-11111110b ^ 01010011b = 10101101b
-11111110b ^ 01010100b = 10101010b
-11111110b ^ 01010101b = 10101011b
-11111110b ^ 01010110b = 10101000b
-11111110b ^ 01010111b = 10101001b
-11111110b ^ 01011000b = 10100110b
-11111110b ^ 01011001b = 10100111b
-11111110b ^ 01011010b = 10100100b
-11111110b ^ 01011011b = 10100101b
-11111110b ^ 01011100b = 10100010b
-11111110b ^ 01011101b = 10100011b
-11111110b ^ 01011110b = 10100000b
-11111110b ^ 01011111b = 10100001b
-11111110b ^ 01100000b = 10011110b
-11111110b ^ 01100001b = 10011111b
-11111110b ^ 01100010b = 10011100b
-11111110b ^ 01100011b = 10011101b
-11111110b ^ 01100100b = 10011010b
-11111110b ^ 01100101b = 10011011b
-11111110b ^ 01100110b = 10011000b
-11111110b ^ 01100111b = 10011001b
-11111110b ^ 01101000b = 10010110b
-11111110b ^ 01101001b = 10010111b
-11111110b ^ 01101010b = 10010100b
-11111110b ^ 01101011b = 10010101b
-11111110b ^ 01101100b = 10010010b
-11111110b ^ 01101101b = 10010011b
-11111110b ^ 01101110b = 10010000b
-11111110b ^ 01101111b = 10010001b
-11111110b ^ 01110000b = 10001110b
-11111110b ^ 01110001b = 10001111b
-11111110b ^ 01110010b = 10001100b
-11111110b ^ 01110011b = 10001101b
-11111110b ^ 01110100b = 10001010b
-11111110b ^ 01110101b = 10001011b
-11111110b ^ 01110110b = 10001000b
-11111110b ^ 01110111b = 10001001b
-11111110b ^ 01111000b = 10000110b
-11111110b ^ 01111001b = 10000111b
-11111110b ^ 01111010b = 10000100b
-11111110b ^ 01111011b = 10000101b
-11111110b ^ 01111100b = 10000010b
-11111110b ^ 01111101b = 10000011b
-11111110b ^ 01111110b = 10000000b
-11111111b ^ 10000000b = 01111111b
-11111111b ^ 10000001b = 01111110b
-11111111b ^ 10000010b = 01111101b
-11111111b ^ 10000011b = 01111100b
-11111111b ^ 10000100b = 01111011b
-11111111b ^ 10000101b = 01111010b
-11111111b ^ 10000110b = 01111001b
-11111111b ^ 10000111b = 01111000b
-11111111b ^ 10001000b = 01110111b
-11111111b ^ 10001001b = 01110110b
-11111111b ^ 10001010b = 01110101b
-11111111b ^ 10001011b = 01110100b
-11111111b ^ 10001100b = 01110011b
-11111111b ^ 10001101b = 01110010b
-11111111b ^ 10001110b = 01110001b
-11111111b ^ 10001111b = 01110000b
-11111111b ^ 10010000b = 01101111b
-11111111b ^ 10010001b = 01101110b
-11111111b ^ 10010010b = 01101101b
-11111111b ^ 10010011b = 01101100b
-11111111b ^ 10010100b = 01101011b
-11111111b ^ 10010101b = 01101010b
-11111111b ^ 10010110b = 01101001b
-11111111b ^ 10010111b = 01101000b
-11111111b ^ 10011000b = 01100111b
-11111111b ^ 10011001b = 01100110b
-11111111b ^ 10011010b = 01100101b
-11111111b ^ 10011011b = 01100100b
-11111111b ^ 10011100b = 01100011b
-11111111b ^ 10011101b = 01100010b
-11111111b ^ 10011110b = 01100001b
-11111111b ^ 10011111b = 01100000b
-11111111b ^ 10100000b = 01011111b
-11111111b ^ 10100001b = 01011110b
-11111111b ^ 10100010b = 01011101b
-11111111b ^ 10100011b = 01011100b
-11111111b ^ 10100100b = 01011011b
-11111111b ^ 10100101b = 01011010b
-11111111b ^ 10100110b = 01011001b
-11111111b ^ 10100111b = 01011000b
-11111111b ^ 10101000b = 01010111b
-11111111b ^ 10101001b = 01010110b
-11111111b ^ 10101010b = 01010101b
-11111111b ^ 10101011b = 01010100b
-11111111b ^ 10101100b = 01010011b
-11111111b ^ 10101101b = 01010010b
-11111111b ^ 10101110b = 01010001b
-11111111b ^ 10101111b = 01010000b
-11111111b ^ 10110000b = 01001111b
-11111111b ^ 10110001b = 01001110b
-11111111b ^ 10110010b = 01001101b
-11111111b ^ 10110011b = 01001100b
-11111111b ^ 10110100b = 01001011b
-11111111b ^ 10110101b = 01001010b
-11111111b ^ 10110110b = 01001001b
-11111111b ^ 10110111b = 01001000b
-11111111b ^ 10111000b = 01000111b
-11111111b ^ 10111001b = 01000110b
-11111111b ^ 10111010b = 01000101b
-11111111b ^ 10111011b = 01000100b
-11111111b ^ 10111100b = 01000011b
-11111111b ^ 10111101b = 01000010b
-11111111b ^ 10111110b = 01000001b
-11111111b ^ 10111111b = 01000000b
-11111111b ^ 11000000b = 00111111b
-11111111b ^ 11000001b = 00111110b
-11111111b ^ 11000010b = 00111101b
-11111111b ^ 11000011b = 00111100b
-11111111b ^ 11000100b = 00111011b
-11111111b ^ 11000101b = 00111010b
-11111111b ^ 11000110b = 00111001b
-11111111b ^ 11000111b = 00111000b
-11111111b ^ 11001000b = 00110111b
-11111111b ^ 11001001b = 00110110b
-11111111b ^ 11001010b = 00110101b
-11111111b ^ 11001011b = 00110100b
-11111111b ^ 11001100b = 00110011b
-11111111b ^ 11001101b = 00110010b
-11111111b ^ 11001110b = 00110001b
-11111111b ^ 11001111b = 00110000b
-11111111b ^ 11010000b = 00101111b
-11111111b ^ 11010001b = 00101110b
-11111111b ^ 11010010b = 00101101b
-11111111b ^ 11010011b = 00101100b
-11111111b ^ 11010100b = 00101011b
-11111111b ^ 11010101b = 00101010b
-11111111b ^ 11010110b = 00101001b
-11111111b ^ 11010111b = 00101000b
-11111111b ^ 11011000b = 00100111b
-11111111b ^ 11011001b = 00100110b
-11111111b ^ 11011010b = 00100101b
-11111111b ^ 11011011b = 00100100b
-11111111b ^ 11011100b = 00100011b
-11111111b ^ 11011101b = 00100010b
-11111111b ^ 11011110b = 00100001b
-11111111b ^ 11011111b = 00100000b
-11111111b ^ 11100000b = 00011111b
-11111111b ^ 11100001b = 00011110b
-11111111b ^ 11100010b = 00011101b
-11111111b ^ 11100011b = 00011100b
-11111111b ^ 11100100b = 00011011b
-11111111b ^ 11100101b = 00011010b
-11111111b ^ 11100110b = 00011001b
-11111111b ^ 11100111b = 00011000b
-11111111b ^ 11101000b = 00010111b
-11111111b ^ 11101001b = 00010110b
-11111111b ^ 11101010b = 00010101b
-11111111b ^ 11101011b = 00010100b
-11111111b ^ 11101100b = 00010011b
-11111111b ^ 11101101b = 00010010b
-11111111b ^ 11101110b = 00010001b
-11111111b ^ 11101111b = 00010000b
-11111111b ^ 11110000b = 00001111b
-11111111b ^ 11110001b = 00001110b
-11111111b ^ 11110010b = 00001101b
-11111111b ^ 11110011b = 00001100b
-11111111b ^ 11110100b = 00001011b
-11111111b ^ 11110101b = 00001010b
-11111111b ^ 11110110b = 00001001b
-11111111b ^ 11110111b = 00001000b
-11111111b ^ 11111000b = 00000111b
-11111111b ^ 11111001b = 00000110b
-11111111b ^ 11111010b = 00000101b
-11111111b ^ 11111011b = 00000100b
-11111111b ^ 11111100b = 00000011b
-11111111b ^ 11111101b = 00000010b
-11111111b ^ 11111110b = 00000001b
-11111111b ^ 11111111b = 00000000b
-11111111b ^ 00000000b = 11111111b
-11111111b ^ 00000001b = 11111110b
-11111111b ^ 00000010b = 11111101b
-11111111b ^ 00000011b = 11111100b
-11111111b ^ 00000100b = 11111011b
-11111111b ^ 00000101b = 11111010b
-11111111b ^ 00000110b = 11111001b
-11111111b ^ 00000111b = 11111000b
-11111111b ^ 00001000b = 11110111b
-11111111b ^ 00001001b = 11110110b
-11111111b ^ 00001010b = 11110101b
-11111111b ^ 00001011b = 11110100b
-11111111b ^ 00001100b = 11110011b
-11111111b ^ 00001101b = 11110010b
-11111111b ^ 00001110b = 11110001b
-11111111b ^ 00001111b = 11110000b
-11111111b ^ 00010000b = 11101111b
-11111111b ^ 00010001b = 11101110b
-11111111b ^ 00010010b = 11101101b
-11111111b ^ 00010011b = 11101100b
-11111111b ^ 00010100b = 11101011b
-11111111b ^ 00010101b = 11101010b
-11111111b ^ 00010110b = 11101001b
-11111111b ^ 00010111b = 11101000b
-11111111b ^ 00011000b = 11100111b
-11111111b ^ 00011001b = 11100110b
-11111111b ^ 00011010b = 11100101b
-11111111b ^ 00011011b = 11100100b
-11111111b ^ 00011100b = 11100011b
-11111111b ^ 00011101b = 11100010b
-11111111b ^ 00011110b = 11100001b
-11111111b ^ 00011111b = 11100000b
-11111111b ^ 00100000b = 11011111b
-11111111b ^ 00100001b = 11011110b
-11111111b ^ 00100010b = 11011101b
-11111111b ^ 00100011b = 11011100b
-11111111b ^ 00100100b = 11011011b
-11111111b ^ 00100101b = 11011010b
-11111111b ^ 00100110b = 11011001b
-11111111b ^ 00100111b = 11011000b
-11111111b ^ 00101000b = 11010111b
-11111111b ^ 00101001b = 11010110b
-11111111b ^ 00101010b = 11010101b
-11111111b ^ 00101011b = 11010100b
-11111111b ^ 00101100b = 11010011b
-11111111b ^ 00101101b = 11010010b
-11111111b ^ 00101110b = 11010001b
-11111111b ^ 00101111b = 11010000b
-11111111b ^ 00110000b = 11001111b
-11111111b ^ 00110001b = 11001110b
-11111111b ^ 00110010b = 11001101b
-11111111b ^ 00110011b = 11001100b
-11111111b ^ 00110100b = 11001011b
-11111111b ^ 00110101b = 11001010b
-11111111b ^ 00110110b = 11001001b
-11111111b ^ 00110111b = 11001000b
-11111111b ^ 00111000b = 11000111b
-11111111b ^ 00111001b = 11000110b
-11111111b ^ 00111010b = 11000101b
-11111111b ^ 00111011b = 11000100b
-11111111b ^ 00111100b = 11000011b
-11111111b ^ 00111101b = 11000010b
-11111111b ^ 00111110b = 11000001b
-11111111b ^ 00111111b = 11000000b
-11111111b ^ 01000000b = 10111111b
-11111111b ^ 01000001b = 10111110b
-11111111b ^ 01000010b = 10111101b
-11111111b ^ 01000011b = 10111100b
-11111111b ^ 01000100b = 10111011b
-11111111b ^ 01000101b = 10111010b
-11111111b ^ 01000110b = 10111001b
-11111111b ^ 01000111b = 10111000b
-11111111b ^ 01001000b = 10110111b
-11111111b ^ 01001001b = 10110110b
-11111111b ^ 01001010b = 10110101b
-11111111b ^ 01001011b = 10110100b
-11111111b ^ 01001100b = 10110011b
-11111111b ^ 01001101b = 10110010b
-11111111b ^ 01001110b = 10110001b
-11111111b ^ 01001111b = 10110000b
-11111111b ^ 01010000b = 10101111b
-11111111b ^ 01010001b = 10101110b
-11111111b ^ 01010010b = 10101101b
-11111111b ^ 01010011b = 10101100b
-11111111b ^ 01010100b = 10101011b
-11111111b ^ 01010101b = 10101010b
-11111111b ^ 01010110b = 10101001b
-11111111b ^ 01010111b = 10101000b
-11111111b ^ 01011000b = 10100111b
-11111111b ^ 01011001b = 10100110b
-11111111b ^ 01011010b = 10100101b
-11111111b ^ 01011011b = 10100100b
-11111111b ^ 01011100b = 10100011b
-11111111b ^ 01011101b = 10100010b
-11111111b ^ 01011110b = 10100001b
-11111111b ^ 01011111b = 10100000b
-11111111b ^ 01100000b = 10011111b
-11111111b ^ 01100001b = 10011110b
-11111111b ^ 01100010b = 10011101b
-11111111b ^ 01100011b = 10011100b
-11111111b ^ 01100100b = 10011011b
-11111111b ^ 01100101b = 10011010b
-11111111b ^ 01100110b = 10011001b
-11111111b ^ 01100111b = 10011000b
-11111111b ^ 01101000b = 10010111b
-11111111b ^ 01101001b = 10010110b
-11111111b ^ 01101010b = 10010101b
-11111111b ^ 01101011b = 10010100b
-11111111b ^ 01101100b = 10010011b
-11111111b ^ 01101101b = 10010010b
-11111111b ^ 01101110b = 10010001b
-11111111b ^ 01101111b = 10010000b
-11111111b ^ 01110000b = 10001111b
-11111111b ^ 01110001b = 10001110b
-11111111b ^ 01110010b = 10001101b
-11111111b ^ 01110011b = 10001100b
-11111111b ^ 01110100b = 10001011b
-11111111b ^ 01110101b = 10001010b
-11111111b ^ 01110110b = 10001001b
-11111111b ^ 01110111b = 10001000b
-11111111b ^ 01111000b = 10000111b
-11111111b ^ 01111001b = 10000110b
-11111111b ^ 01111010b = 10000101b
-11111111b ^ 01111011b = 10000100b
-11111111b ^ 01111100b = 10000011b
-11111111b ^ 01111101b = 10000010b
-11111111b ^ 01111110b = 10000001b
-00000000b ^ 10000000b = 10000000b
-00000000b ^ 10000001b = 10000001b
-00000000b ^ 10000010b = 10000010b
-00000000b ^ 10000011b = 10000011b
-00000000b ^ 10000100b = 10000100b
-00000000b ^ 10000101b = 10000101b
-00000000b ^ 10000110b = 10000110b
-00000000b ^ 10000111b = 10000111b
-00000000b ^ 10001000b = 10001000b
-00000000b ^ 10001001b = 10001001b
-00000000b ^ 10001010b = 10001010b
-00000000b ^ 10001011b = 10001011b
-00000000b ^ 10001100b = 10001100b
-00000000b ^ 10001101b = 10001101b
-00000000b ^ 10001110b = 10001110b
-00000000b ^ 10001111b = 10001111b
-00000000b ^ 10010000b = 10010000b
-00000000b ^ 10010001b = 10010001b
-00000000b ^ 10010010b = 10010010b
-00000000b ^ 10010011b = 10010011b
-00000000b ^ 10010100b = 10010100b
-00000000b ^ 10010101b = 10010101b
-00000000b ^ 10010110b = 10010110b
-00000000b ^ 10010111b = 10010111b
-00000000b ^ 10011000b = 10011000b
-00000000b ^ 10011001b = 10011001b
-00000000b ^ 10011010b = 10011010b
-00000000b ^ 10011011b = 10011011b
-00000000b ^ 10011100b = 10011100b
-00000000b ^ 10011101b = 10011101b
-00000000b ^ 10011110b = 10011110b
-00000000b ^ 10011111b = 10011111b
-00000000b ^ 10100000b = 10100000b
-00000000b ^ 10100001b = 10100001b
-00000000b ^ 10100010b = 10100010b
-00000000b ^ 10100011b = 10100011b
-00000000b ^ 10100100b = 10100100b
-00000000b ^ 10100101b = 10100101b
-00000000b ^ 10100110b = 10100110b
-00000000b ^ 10100111b = 10100111b
-00000000b ^ 10101000b = 10101000b
-00000000b ^ 10101001b = 10101001b
-00000000b ^ 10101010b = 10101010b
-00000000b ^ 10101011b = 10101011b
-00000000b ^ 10101100b = 10101100b
-00000000b ^ 10101101b = 10101101b
-00000000b ^ 10101110b = 10101110b
-00000000b ^ 10101111b = 10101111b
-00000000b ^ 10110000b = 10110000b
-00000000b ^ 10110001b = 10110001b
-00000000b ^ 10110010b = 10110010b
-00000000b ^ 10110011b = 10110011b
-00000000b ^ 10110100b = 10110100b
-00000000b ^ 10110101b = 10110101b
-00000000b ^ 10110110b = 10110110b
-00000000b ^ 10110111b = 10110111b
-00000000b ^ 10111000b = 10111000b
-00000000b ^ 10111001b = 10111001b
-00000000b ^ 10111010b = 10111010b
-00000000b ^ 10111011b = 10111011b
-00000000b ^ 10111100b = 10111100b
-00000000b ^ 10111101b = 10111101b
-00000000b ^ 10111110b = 10111110b
-00000000b ^ 10111111b = 10111111b
-00000000b ^ 11000000b = 11000000b
-00000000b ^ 11000001b = 11000001b
-00000000b ^ 11000010b = 11000010b
-00000000b ^ 11000011b = 11000011b
-00000000b ^ 11000100b = 11000100b
-00000000b ^ 11000101b = 11000101b
-00000000b ^ 11000110b = 11000110b
-00000000b ^ 11000111b = 11000111b
-00000000b ^ 11001000b = 11001000b
-00000000b ^ 11001001b = 11001001b
-00000000b ^ 11001010b = 11001010b
-00000000b ^ 11001011b = 11001011b
-00000000b ^ 11001100b = 11001100b
-00000000b ^ 11001101b = 11001101b
-00000000b ^ 11001110b = 11001110b
-00000000b ^ 11001111b = 11001111b
-00000000b ^ 11010000b = 11010000b
-00000000b ^ 11010001b = 11010001b
-00000000b ^ 11010010b = 11010010b
-00000000b ^ 11010011b = 11010011b
-00000000b ^ 11010100b = 11010100b
-00000000b ^ 11010101b = 11010101b
-00000000b ^ 11010110b = 11010110b
-00000000b ^ 11010111b = 11010111b
-00000000b ^ 11011000b = 11011000b
-00000000b ^ 11011001b = 11011001b
-00000000b ^ 11011010b = 11011010b
-00000000b ^ 11011011b = 11011011b
-00000000b ^ 11011100b = 11011100b
-00000000b ^ 11011101b = 11011101b
-00000000b ^ 11011110b = 11011110b
-00000000b ^ 11011111b = 11011111b
-00000000b ^ 11100000b = 11100000b
-00000000b ^ 11100001b = 11100001b
-00000000b ^ 11100010b = 11100010b
-00000000b ^ 11100011b = 11100011b
-00000000b ^ 11100100b = 11100100b
-00000000b ^ 11100101b = 11100101b
-00000000b ^ 11100110b = 11100110b
-00000000b ^ 11100111b = 11100111b
-00000000b ^ 11101000b = 11101000b
-00000000b ^ 11101001b = 11101001b
-00000000b ^ 11101010b = 11101010b
-00000000b ^ 11101011b = 11101011b
-00000000b ^ 11101100b = 11101100b
-00000000b ^ 11101101b = 11101101b
-00000000b ^ 11101110b = 11101110b
-00000000b ^ 11101111b = 11101111b
-00000000b ^ 11110000b = 11110000b
-00000000b ^ 11110001b = 11110001b
-00000000b ^ 11110010b = 11110010b
-00000000b ^ 11110011b = 11110011b
-00000000b ^ 11110100b = 11110100b
-00000000b ^ 11110101b = 11110101b
-00000000b ^ 11110110b = 11110110b
-00000000b ^ 11110111b = 11110111b
-00000000b ^ 11111000b = 11111000b
-00000000b ^ 11111001b = 11111001b
-00000000b ^ 11111010b = 11111010b
-00000000b ^ 11111011b = 11111011b
-00000000b ^ 11111100b = 11111100b
-00000000b ^ 11111101b = 11111101b
-00000000b ^ 11111110b = 11111110b
-00000000b ^ 11111111b = 11111111b
-00000000b ^ 00000000b = 00000000b
-00000000b ^ 00000001b = 00000001b
-00000000b ^ 00000010b = 00000010b
-00000000b ^ 00000011b = 00000011b
-00000000b ^ 00000100b = 00000100b
-00000000b ^ 00000101b = 00000101b
-00000000b ^ 00000110b = 00000110b
-00000000b ^ 00000111b = 00000111b
-00000000b ^ 00001000b = 00001000b
-00000000b ^ 00001001b = 00001001b
-00000000b ^ 00001010b = 00001010b
-00000000b ^ 00001011b = 00001011b
-00000000b ^ 00001100b = 00001100b
-00000000b ^ 00001101b = 00001101b
-00000000b ^ 00001110b = 00001110b
-00000000b ^ 00001111b = 00001111b
-00000000b ^ 00010000b = 00010000b
-00000000b ^ 00010001b = 00010001b
-00000000b ^ 00010010b = 00010010b
-00000000b ^ 00010011b = 00010011b
-00000000b ^ 00010100b = 00010100b
-00000000b ^ 00010101b = 00010101b
-00000000b ^ 00010110b = 00010110b
-00000000b ^ 00010111b = 00010111b
-00000000b ^ 00011000b = 00011000b
-00000000b ^ 00011001b = 00011001b
-00000000b ^ 00011010b = 00011010b
-00000000b ^ 00011011b = 00011011b
-00000000b ^ 00011100b = 00011100b
-00000000b ^ 00011101b = 00011101b
-00000000b ^ 00011110b = 00011110b
-00000000b ^ 00011111b = 00011111b
-00000000b ^ 00100000b = 00100000b
-00000000b ^ 00100001b = 00100001b
-00000000b ^ 00100010b = 00100010b
-00000000b ^ 00100011b = 00100011b
-00000000b ^ 00100100b = 00100100b
-00000000b ^ 00100101b = 00100101b
-00000000b ^ 00100110b = 00100110b
-00000000b ^ 00100111b = 00100111b
-00000000b ^ 00101000b = 00101000b
-00000000b ^ 00101001b = 00101001b
-00000000b ^ 00101010b = 00101010b
-00000000b ^ 00101011b = 00101011b
-00000000b ^ 00101100b = 00101100b
-00000000b ^ 00101101b = 00101101b
-00000000b ^ 00101110b = 00101110b
-00000000b ^ 00101111b = 00101111b
-00000000b ^ 00110000b = 00110000b
-00000000b ^ 00110001b = 00110001b
-00000000b ^ 00110010b = 00110010b
-00000000b ^ 00110011b = 00110011b
-00000000b ^ 00110100b = 00110100b
-00000000b ^ 00110101b = 00110101b
-00000000b ^ 00110110b = 00110110b
-00000000b ^ 00110111b = 00110111b
-00000000b ^ 00111000b = 00111000b
-00000000b ^ 00111001b = 00111001b
-00000000b ^ 00111010b = 00111010b
-00000000b ^ 00111011b = 00111011b
-00000000b ^ 00111100b = 00111100b
-00000000b ^ 00111101b = 00111101b
-00000000b ^ 00111110b = 00111110b
-00000000b ^ 00111111b = 00111111b
-00000000b ^ 01000000b = 01000000b
-00000000b ^ 01000001b = 01000001b
-00000000b ^ 01000010b = 01000010b
-00000000b ^ 01000011b = 01000011b
-00000000b ^ 01000100b = 01000100b
-00000000b ^ 01000101b = 01000101b
-00000000b ^ 01000110b = 01000110b
-00000000b ^ 01000111b = 01000111b
-00000000b ^ 01001000b = 01001000b
-00000000b ^ 01001001b = 01001001b
-00000000b ^ 01001010b = 01001010b
-00000000b ^ 01001011b = 01001011b
-00000000b ^ 01001100b = 01001100b
-00000000b ^ 01001101b = 01001101b
-00000000b ^ 01001110b = 01001110b
-00000000b ^ 01001111b = 01001111b
-00000000b ^ 01010000b = 01010000b
-00000000b ^ 01010001b = 01010001b
-00000000b ^ 01010010b = 01010010b
-00000000b ^ 01010011b = 01010011b
-00000000b ^ 01010100b = 01010100b
-00000000b ^ 01010101b = 01010101b
-00000000b ^ 01010110b = 01010110b
-00000000b ^ 01010111b = 01010111b
-00000000b ^ 01011000b = 01011000b
-00000000b ^ 01011001b = 01011001b
-00000000b ^ 01011010b = 01011010b
-00000000b ^ 01011011b = 01011011b
-00000000b ^ 01011100b = 01011100b
-00000000b ^ 01011101b = 01011101b
-00000000b ^ 01011110b = 01011110b
-00000000b ^ 01011111b = 01011111b
-00000000b ^ 01100000b = 01100000b
-00000000b ^ 01100001b = 01100001b
-00000000b ^ 01100010b = 01100010b
-00000000b ^ 01100011b = 01100011b
-00000000b ^ 01100100b = 01100100b
-00000000b ^ 01100101b = 01100101b
-00000000b ^ 01100110b = 01100110b
-00000000b ^ 01100111b = 01100111b
-00000000b ^ 01101000b = 01101000b
-00000000b ^ 01101001b = 01101001b
-00000000b ^ 01101010b = 01101010b
-00000000b ^ 01101011b = 01101011b
-00000000b ^ 01101100b = 01101100b
-00000000b ^ 01101101b = 01101101b
-00000000b ^ 01101110b = 01101110b
-00000000b ^ 01101111b = 01101111b
-00000000b ^ 01110000b = 01110000b
-00000000b ^ 01110001b = 01110001b
-00000000b ^ 01110010b = 01110010b
-00000000b ^ 01110011b = 01110011b
-00000000b ^ 01110100b = 01110100b
-00000000b ^ 01110101b = 01110101b
-00000000b ^ 01110110b = 01110110b
-00000000b ^ 01110111b = 01110111b
-00000000b ^ 01111000b = 01111000b
-00000000b ^ 01111001b = 01111001b
-00000000b ^ 01111010b = 01111010b
-00000000b ^ 01111011b = 01111011b
-00000000b ^ 01111100b = 01111100b
-00000000b ^ 01111101b = 01111101b
-00000000b ^ 01111110b = 01111110b
-00000001b ^ 10000000b = 10000001b
-00000001b ^ 10000001b = 10000000b
-00000001b ^ 10000010b = 10000011b
-00000001b ^ 10000011b = 10000010b
-00000001b ^ 10000100b = 10000101b
-00000001b ^ 10000101b = 10000100b
-00000001b ^ 10000110b = 10000111b
-00000001b ^ 10000111b = 10000110b
-00000001b ^ 10001000b = 10001001b
-00000001b ^ 10001001b = 10001000b
-00000001b ^ 10001010b = 10001011b
-00000001b ^ 10001011b = 10001010b
-00000001b ^ 10001100b = 10001101b
-00000001b ^ 10001101b = 10001100b
-00000001b ^ 10001110b = 10001111b
-00000001b ^ 10001111b = 10001110b
-00000001b ^ 10010000b = 10010001b
-00000001b ^ 10010001b = 10010000b
-00000001b ^ 10010010b = 10010011b
-00000001b ^ 10010011b = 10010010b
-00000001b ^ 10010100b = 10010101b
-00000001b ^ 10010101b = 10010100b
-00000001b ^ 10010110b = 10010111b
-00000001b ^ 10010111b = 10010110b
-00000001b ^ 10011000b = 10011001b
-00000001b ^ 10011001b = 10011000b
-00000001b ^ 10011010b = 10011011b
-00000001b ^ 10011011b = 10011010b
-00000001b ^ 10011100b = 10011101b
-00000001b ^ 10011101b = 10011100b
-00000001b ^ 10011110b = 10011111b
-00000001b ^ 10011111b = 10011110b
-00000001b ^ 10100000b = 10100001b
-00000001b ^ 10100001b = 10100000b
-00000001b ^ 10100010b = 10100011b
-00000001b ^ 10100011b = 10100010b
-00000001b ^ 10100100b = 10100101b
-00000001b ^ 10100101b = 10100100b
-00000001b ^ 10100110b = 10100111b
-00000001b ^ 10100111b = 10100110b
-00000001b ^ 10101000b = 10101001b
-00000001b ^ 10101001b = 10101000b
-00000001b ^ 10101010b = 10101011b
-00000001b ^ 10101011b = 10101010b
-00000001b ^ 10101100b = 10101101b
-00000001b ^ 10101101b = 10101100b
-00000001b ^ 10101110b = 10101111b
-00000001b ^ 10101111b = 10101110b
-00000001b ^ 10110000b = 10110001b
-00000001b ^ 10110001b = 10110000b
-00000001b ^ 10110010b = 10110011b
-00000001b ^ 10110011b = 10110010b
-00000001b ^ 10110100b = 10110101b
-00000001b ^ 10110101b = 10110100b
-00000001b ^ 10110110b = 10110111b
-00000001b ^ 10110111b = 10110110b
-00000001b ^ 10111000b = 10111001b
-00000001b ^ 10111001b = 10111000b
-00000001b ^ 10111010b = 10111011b
-00000001b ^ 10111011b = 10111010b
-00000001b ^ 10111100b = 10111101b
-00000001b ^ 10111101b = 10111100b
-00000001b ^ 10111110b = 10111111b
-00000001b ^ 10111111b = 10111110b
-00000001b ^ 11000000b = 11000001b
-00000001b ^ 11000001b = 11000000b
-00000001b ^ 11000010b = 11000011b
-00000001b ^ 11000011b = 11000010b
-00000001b ^ 11000100b = 11000101b
-00000001b ^ 11000101b = 11000100b
-00000001b ^ 11000110b = 11000111b
-00000001b ^ 11000111b = 11000110b
-00000001b ^ 11001000b = 11001001b
-00000001b ^ 11001001b = 11001000b
-00000001b ^ 11001010b = 11001011b
-00000001b ^ 11001011b = 11001010b
-00000001b ^ 11001100b = 11001101b
-00000001b ^ 11001101b = 11001100b
-00000001b ^ 11001110b = 11001111b
-00000001b ^ 11001111b = 11001110b
-00000001b ^ 11010000b = 11010001b
-00000001b ^ 11010001b = 11010000b
-00000001b ^ 11010010b = 11010011b
-00000001b ^ 11010011b = 11010010b
-00000001b ^ 11010100b = 11010101b
-00000001b ^ 11010101b = 11010100b
-00000001b ^ 11010110b = 11010111b
-00000001b ^ 11010111b = 11010110b
-00000001b ^ 11011000b = 11011001b
-00000001b ^ 11011001b = 11011000b
-00000001b ^ 11011010b = 11011011b
-00000001b ^ 11011011b = 11011010b
-00000001b ^ 11011100b = 11011101b
-00000001b ^ 11011101b = 11011100b
-00000001b ^ 11011110b = 11011111b
-00000001b ^ 11011111b = 11011110b
-00000001b ^ 11100000b = 11100001b
-00000001b ^ 11100001b = 11100000b
-00000001b ^ 11100010b = 11100011b
-00000001b ^ 11100011b = 11100010b
-00000001b ^ 11100100b = 11100101b
-00000001b ^ 11100101b = 11100100b
-00000001b ^ 11100110b = 11100111b
-00000001b ^ 11100111b = 11100110b
-00000001b ^ 11101000b = 11101001b
-00000001b ^ 11101001b = 11101000b
-00000001b ^ 11101010b = 11101011b
-00000001b ^ 11101011b = 11101010b
-00000001b ^ 11101100b = 11101101b
-00000001b ^ 11101101b = 11101100b
-00000001b ^ 11101110b = 11101111b
-00000001b ^ 11101111b = 11101110b
-00000001b ^ 11110000b = 11110001b
-00000001b ^ 11110001b = 11110000b
-00000001b ^ 11110010b = 11110011b
-00000001b ^ 11110011b = 11110010b
-00000001b ^ 11110100b = 11110101b
-00000001b ^ 11110101b = 11110100b
-00000001b ^ 11110110b = 11110111b
-00000001b ^ 11110111b = 11110110b
-00000001b ^ 11111000b = 11111001b
-00000001b ^ 11111001b = 11111000b
-00000001b ^ 11111010b = 11111011b
-00000001b ^ 11111011b = 11111010b
-00000001b ^ 11111100b = 11111101b
-00000001b ^ 11111101b = 11111100b
-00000001b ^ 11111110b = 11111111b
-00000001b ^ 11111111b = 11111110b
-00000001b ^ 00000000b = 00000001b
-00000001b ^ 00000001b = 00000000b
-00000001b ^ 00000010b = 00000011b
-00000001b ^ 00000011b = 00000010b
-00000001b ^ 00000100b = 00000101b
-00000001b ^ 00000101b = 00000100b
-00000001b ^ 00000110b = 00000111b
-00000001b ^ 00000111b = 00000110b
-00000001b ^ 00001000b = 00001001b
-00000001b ^ 00001001b = 00001000b
-00000001b ^ 00001010b = 00001011b
-00000001b ^ 00001011b = 00001010b
-00000001b ^ 00001100b = 00001101b
-00000001b ^ 00001101b = 00001100b
-00000001b ^ 00001110b = 00001111b
-00000001b ^ 00001111b = 00001110b
-00000001b ^ 00010000b = 00010001b
-00000001b ^ 00010001b = 00010000b
-00000001b ^ 00010010b = 00010011b
-00000001b ^ 00010011b = 00010010b
-00000001b ^ 00010100b = 00010101b
-00000001b ^ 00010101b = 00010100b
-00000001b ^ 00010110b = 00010111b
-00000001b ^ 00010111b = 00010110b
-00000001b ^ 00011000b = 00011001b
-00000001b ^ 00011001b = 00011000b
-00000001b ^ 00011010b = 00011011b
-00000001b ^ 00011011b = 00011010b
-00000001b ^ 00011100b = 00011101b
-00000001b ^ 00011101b = 00011100b
-00000001b ^ 00011110b = 00011111b
-00000001b ^ 00011111b = 00011110b
-00000001b ^ 00100000b = 00100001b
-00000001b ^ 00100001b = 00100000b
-00000001b ^ 00100010b = 00100011b
-00000001b ^ 00100011b = 00100010b
-00000001b ^ 00100100b = 00100101b
-00000001b ^ 00100101b = 00100100b
-00000001b ^ 00100110b = 00100111b
-00000001b ^ 00100111b = 00100110b
-00000001b ^ 00101000b = 00101001b
-00000001b ^ 00101001b = 00101000b
-00000001b ^ 00101010b = 00101011b
-00000001b ^ 00101011b = 00101010b
-00000001b ^ 00101100b = 00101101b
-00000001b ^ 00101101b = 00101100b
-00000001b ^ 00101110b = 00101111b
-00000001b ^ 00101111b = 00101110b
-00000001b ^ 00110000b = 00110001b
-00000001b ^ 00110001b = 00110000b
-00000001b ^ 00110010b = 00110011b
-00000001b ^ 00110011b = 00110010b
-00000001b ^ 00110100b = 00110101b
-00000001b ^ 00110101b = 00110100b
-00000001b ^ 00110110b = 00110111b
-00000001b ^ 00110111b = 00110110b
-00000001b ^ 00111000b = 00111001b
-00000001b ^ 00111001b = 00111000b
-00000001b ^ 00111010b = 00111011b
-00000001b ^ 00111011b = 00111010b
-00000001b ^ 00111100b = 00111101b
-00000001b ^ 00111101b = 00111100b
-00000001b ^ 00111110b = 00111111b
-00000001b ^ 00111111b = 00111110b
-00000001b ^ 01000000b = 01000001b
-00000001b ^ 01000001b = 01000000b
-00000001b ^ 01000010b = 01000011b
-00000001b ^ 01000011b = 01000010b
-00000001b ^ 01000100b = 01000101b
-00000001b ^ 01000101b = 01000100b
-00000001b ^ 01000110b = 01000111b
-00000001b ^ 01000111b = 01000110b
-00000001b ^ 01001000b = 01001001b
-00000001b ^ 01001001b = 01001000b
-00000001b ^ 01001010b = 01001011b
-00000001b ^ 01001011b = 01001010b
-00000001b ^ 01001100b = 01001101b
-00000001b ^ 01001101b = 01001100b
-00000001b ^ 01001110b = 01001111b
-00000001b ^ 01001111b = 01001110b
-00000001b ^ 01010000b = 01010001b
-00000001b ^ 01010001b = 01010000b
-00000001b ^ 01010010b = 01010011b
-00000001b ^ 01010011b = 01010010b
-00000001b ^ 01010100b = 01010101b
-00000001b ^ 01010101b = 01010100b
-00000001b ^ 01010110b = 01010111b
-00000001b ^ 01010111b = 01010110b
-00000001b ^ 01011000b = 01011001b
-00000001b ^ 01011001b = 01011000b
-00000001b ^ 01011010b = 01011011b
-00000001b ^ 01011011b = 01011010b
-00000001b ^ 01011100b = 01011101b
-00000001b ^ 01011101b = 01011100b
-00000001b ^ 01011110b = 01011111b
-00000001b ^ 01011111b = 01011110b
-00000001b ^ 01100000b = 01100001b
-00000001b ^ 01100001b = 01100000b
-00000001b ^ 01100010b = 01100011b
-00000001b ^ 01100011b = 01100010b
-00000001b ^ 01100100b = 01100101b
-00000001b ^ 01100101b = 01100100b
-00000001b ^ 01100110b = 01100111b
-00000001b ^ 01100111b = 01100110b
-00000001b ^ 01101000b = 01101001b
-00000001b ^ 01101001b = 01101000b
-00000001b ^ 01101010b = 01101011b
-00000001b ^ 01101011b = 01101010b
-00000001b ^ 01101100b = 01101101b
-00000001b ^ 01101101b = 01101100b
-00000001b ^ 01101110b = 01101111b
-00000001b ^ 01101111b = 01101110b
-00000001b ^ 01110000b = 01110001b
-00000001b ^ 01110001b = 01110000b
-00000001b ^ 01110010b = 01110011b
-00000001b ^ 01110011b = 01110010b
-00000001b ^ 01110100b = 01110101b
-00000001b ^ 01110101b = 01110100b
-00000001b ^ 01110110b = 01110111b
-00000001b ^ 01110111b = 01110110b
-00000001b ^ 01111000b = 01111001b
-00000001b ^ 01111001b = 01111000b
-00000001b ^ 01111010b = 01111011b
-00000001b ^ 01111011b = 01111010b
-00000001b ^ 01111100b = 01111101b
-00000001b ^ 01111101b = 01111100b
-00000001b ^ 01111110b = 01111111b
-00000010b ^ 10000000b = 10000010b
-00000010b ^ 10000001b = 10000011b
-00000010b ^ 10000010b = 10000000b
-00000010b ^ 10000011b = 10000001b
-00000010b ^ 10000100b = 10000110b
-00000010b ^ 10000101b = 10000111b
-00000010b ^ 10000110b = 10000100b
-00000010b ^ 10000111b = 10000101b
-00000010b ^ 10001000b = 10001010b
-00000010b ^ 10001001b = 10001011b
-00000010b ^ 10001010b = 10001000b
-00000010b ^ 10001011b = 10001001b
-00000010b ^ 10001100b = 10001110b
-00000010b ^ 10001101b = 10001111b
-00000010b ^ 10001110b = 10001100b
-00000010b ^ 10001111b = 10001101b
-00000010b ^ 10010000b = 10010010b
-00000010b ^ 10010001b = 10010011b
-00000010b ^ 10010010b = 10010000b
-00000010b ^ 10010011b = 10010001b
-00000010b ^ 10010100b = 10010110b
-00000010b ^ 10010101b = 10010111b
-00000010b ^ 10010110b = 10010100b
-00000010b ^ 10010111b = 10010101b
-00000010b ^ 10011000b = 10011010b
-00000010b ^ 10011001b = 10011011b
-00000010b ^ 10011010b = 10011000b
-00000010b ^ 10011011b = 10011001b
-00000010b ^ 10011100b = 10011110b
-00000010b ^ 10011101b = 10011111b
-00000010b ^ 10011110b = 10011100b
-00000010b ^ 10011111b = 10011101b
-00000010b ^ 10100000b = 10100010b
-00000010b ^ 10100001b = 10100011b
-00000010b ^ 10100010b = 10100000b
-00000010b ^ 10100011b = 10100001b
-00000010b ^ 10100100b = 10100110b
-00000010b ^ 10100101b = 10100111b
-00000010b ^ 10100110b = 10100100b
-00000010b ^ 10100111b = 10100101b
-00000010b ^ 10101000b = 10101010b
-00000010b ^ 10101001b = 10101011b
-00000010b ^ 10101010b = 10101000b
-00000010b ^ 10101011b = 10101001b
-00000010b ^ 10101100b = 10101110b
-00000010b ^ 10101101b = 10101111b
-00000010b ^ 10101110b = 10101100b
-00000010b ^ 10101111b = 10101101b
-00000010b ^ 10110000b = 10110010b
-00000010b ^ 10110001b = 10110011b
-00000010b ^ 10110010b = 10110000b
-00000010b ^ 10110011b = 10110001b
-00000010b ^ 10110100b = 10110110b
-00000010b ^ 10110101b = 10110111b
-00000010b ^ 10110110b = 10110100b
-00000010b ^ 10110111b = 10110101b
-00000010b ^ 10111000b = 10111010b
-00000010b ^ 10111001b = 10111011b
-00000010b ^ 10111010b = 10111000b
-00000010b ^ 10111011b = 10111001b
-00000010b ^ 10111100b = 10111110b
-00000010b ^ 10111101b = 10111111b
-00000010b ^ 10111110b = 10111100b
-00000010b ^ 10111111b = 10111101b
-00000010b ^ 11000000b = 11000010b
-00000010b ^ 11000001b = 11000011b
-00000010b ^ 11000010b = 11000000b
-00000010b ^ 11000011b = 11000001b
-00000010b ^ 11000100b = 11000110b
-00000010b ^ 11000101b = 11000111b
-00000010b ^ 11000110b = 11000100b
-00000010b ^ 11000111b = 11000101b
-00000010b ^ 11001000b = 11001010b
-00000010b ^ 11001001b = 11001011b
-00000010b ^ 11001010b = 11001000b
-00000010b ^ 11001011b = 11001001b
-00000010b ^ 11001100b = 11001110b
-00000010b ^ 11001101b = 11001111b
-00000010b ^ 11001110b = 11001100b
-00000010b ^ 11001111b = 11001101b
-00000010b ^ 11010000b = 11010010b
-00000010b ^ 11010001b = 11010011b
-00000010b ^ 11010010b = 11010000b
-00000010b ^ 11010011b = 11010001b
-00000010b ^ 11010100b = 11010110b
-00000010b ^ 11010101b = 11010111b
-00000010b ^ 11010110b = 11010100b
-00000010b ^ 11010111b = 11010101b
-00000010b ^ 11011000b = 11011010b
-00000010b ^ 11011001b = 11011011b
-00000010b ^ 11011010b = 11011000b
-00000010b ^ 11011011b = 11011001b
-00000010b ^ 11011100b = 11011110b
-00000010b ^ 11011101b = 11011111b
-00000010b ^ 11011110b = 11011100b
-00000010b ^ 11011111b = 11011101b
-00000010b ^ 11100000b = 11100010b
-00000010b ^ 11100001b = 11100011b
-00000010b ^ 11100010b = 11100000b
-00000010b ^ 11100011b = 11100001b
-00000010b ^ 11100100b = 11100110b
-00000010b ^ 11100101b = 11100111b
-00000010b ^ 11100110b = 11100100b
-00000010b ^ 11100111b = 11100101b
-00000010b ^ 11101000b = 11101010b
-00000010b ^ 11101001b = 11101011b
-00000010b ^ 11101010b = 11101000b
-00000010b ^ 11101011b = 11101001b
-00000010b ^ 11101100b = 11101110b
-00000010b ^ 11101101b = 11101111b
-00000010b ^ 11101110b = 11101100b
-00000010b ^ 11101111b = 11101101b
-00000010b ^ 11110000b = 11110010b
-00000010b ^ 11110001b = 11110011b
-00000010b ^ 11110010b = 11110000b
-00000010b ^ 11110011b = 11110001b
-00000010b ^ 11110100b = 11110110b
-00000010b ^ 11110101b = 11110111b
-00000010b ^ 11110110b = 11110100b
-00000010b ^ 11110111b = 11110101b
-00000010b ^ 11111000b = 11111010b
-00000010b ^ 11111001b = 11111011b
-00000010b ^ 11111010b = 11111000b
-00000010b ^ 11111011b = 11111001b
-00000010b ^ 11111100b = 11111110b
-00000010b ^ 11111101b = 11111111b
-00000010b ^ 11111110b = 11111100b
-00000010b ^ 11111111b = 11111101b
-00000010b ^ 00000000b = 00000010b
-00000010b ^ 00000001b = 00000011b
-00000010b ^ 00000010b = 00000000b
-00000010b ^ 00000011b = 00000001b
-00000010b ^ 00000100b = 00000110b
-00000010b ^ 00000101b = 00000111b
-00000010b ^ 00000110b = 00000100b
-00000010b ^ 00000111b = 00000101b
-00000010b ^ 00001000b = 00001010b
-00000010b ^ 00001001b = 00001011b
-00000010b ^ 00001010b = 00001000b
-00000010b ^ 00001011b = 00001001b
-00000010b ^ 00001100b = 00001110b
-00000010b ^ 00001101b = 00001111b
-00000010b ^ 00001110b = 00001100b
-00000010b ^ 00001111b = 00001101b
-00000010b ^ 00010000b = 00010010b
-00000010b ^ 00010001b = 00010011b
-00000010b ^ 00010010b = 00010000b
-00000010b ^ 00010011b = 00010001b
-00000010b ^ 00010100b = 00010110b
-00000010b ^ 00010101b = 00010111b
-00000010b ^ 00010110b = 00010100b
-00000010b ^ 00010111b = 00010101b
-00000010b ^ 00011000b = 00011010b
-00000010b ^ 00011001b = 00011011b
-00000010b ^ 00011010b = 00011000b
-00000010b ^ 00011011b = 00011001b
-00000010b ^ 00011100b = 00011110b
-00000010b ^ 00011101b = 00011111b
-00000010b ^ 00011110b = 00011100b
-00000010b ^ 00011111b = 00011101b
-00000010b ^ 00100000b = 00100010b
-00000010b ^ 00100001b = 00100011b
-00000010b ^ 00100010b = 00100000b
-00000010b ^ 00100011b = 00100001b
-00000010b ^ 00100100b = 00100110b
-00000010b ^ 00100101b = 00100111b
-00000010b ^ 00100110b = 00100100b
-00000010b ^ 00100111b = 00100101b
-00000010b ^ 00101000b = 00101010b
-00000010b ^ 00101001b = 00101011b
-00000010b ^ 00101010b = 00101000b
-00000010b ^ 00101011b = 00101001b
-00000010b ^ 00101100b = 00101110b
-00000010b ^ 00101101b = 00101111b
-00000010b ^ 00101110b = 00101100b
-00000010b ^ 00101111b = 00101101b
-00000010b ^ 00110000b = 00110010b
-00000010b ^ 00110001b = 00110011b
-00000010b ^ 00110010b = 00110000b
-00000010b ^ 00110011b = 00110001b
-00000010b ^ 00110100b = 00110110b
-00000010b ^ 00110101b = 00110111b
-00000010b ^ 00110110b = 00110100b
-00000010b ^ 00110111b = 00110101b
-00000010b ^ 00111000b = 00111010b
-00000010b ^ 00111001b = 00111011b
-00000010b ^ 00111010b = 00111000b
-00000010b ^ 00111011b = 00111001b
-00000010b ^ 00111100b = 00111110b
-00000010b ^ 00111101b = 00111111b
-00000010b ^ 00111110b = 00111100b
-00000010b ^ 00111111b = 00111101b
-00000010b ^ 01000000b = 01000010b
-00000010b ^ 01000001b = 01000011b
-00000010b ^ 01000010b = 01000000b
-00000010b ^ 01000011b = 01000001b
-00000010b ^ 01000100b = 01000110b
-00000010b ^ 01000101b = 01000111b
-00000010b ^ 01000110b = 01000100b
-00000010b ^ 01000111b = 01000101b
-00000010b ^ 01001000b = 01001010b
-00000010b ^ 01001001b = 01001011b
-00000010b ^ 01001010b = 01001000b
-00000010b ^ 01001011b = 01001001b
-00000010b ^ 01001100b = 01001110b
-00000010b ^ 01001101b = 01001111b
-00000010b ^ 01001110b = 01001100b
-00000010b ^ 01001111b = 01001101b
-00000010b ^ 01010000b = 01010010b
-00000010b ^ 01010001b = 01010011b
-00000010b ^ 01010010b = 01010000b
-00000010b ^ 01010011b = 01010001b
-00000010b ^ 01010100b = 01010110b
-00000010b ^ 01010101b = 01010111b
-00000010b ^ 01010110b = 01010100b
-00000010b ^ 01010111b = 01010101b
-00000010b ^ 01011000b = 01011010b
-00000010b ^ 01011001b = 01011011b
-00000010b ^ 01011010b = 01011000b
-00000010b ^ 01011011b = 01011001b
-00000010b ^ 01011100b = 01011110b
-00000010b ^ 01011101b = 01011111b
-00000010b ^ 01011110b = 01011100b
-00000010b ^ 01011111b = 01011101b
-00000010b ^ 01100000b = 01100010b
-00000010b ^ 01100001b = 01100011b
-00000010b ^ 01100010b = 01100000b
-00000010b ^ 01100011b = 01100001b
-00000010b ^ 01100100b = 01100110b
-00000010b ^ 01100101b = 01100111b
-00000010b ^ 01100110b = 01100100b
-00000010b ^ 01100111b = 01100101b
-00000010b ^ 01101000b = 01101010b
-00000010b ^ 01101001b = 01101011b
-00000010b ^ 01101010b = 01101000b
-00000010b ^ 01101011b = 01101001b
-00000010b ^ 01101100b = 01101110b
-00000010b ^ 01101101b = 01101111b
-00000010b ^ 01101110b = 01101100b
-00000010b ^ 01101111b = 01101101b
-00000010b ^ 01110000b = 01110010b
-00000010b ^ 01110001b = 01110011b
-00000010b ^ 01110010b = 01110000b
-00000010b ^ 01110011b = 01110001b
-00000010b ^ 01110100b = 01110110b
-00000010b ^ 01110101b = 01110111b
-00000010b ^ 01110110b = 01110100b
-00000010b ^ 01110111b = 01110101b
-00000010b ^ 01111000b = 01111010b
-00000010b ^ 01111001b = 01111011b
-00000010b ^ 01111010b = 01111000b
-00000010b ^ 01111011b = 01111001b
-00000010b ^ 01111100b = 01111110b
-00000010b ^ 01111101b = 01111111b
-00000010b ^ 01111110b = 01111100b
-00000011b ^ 10000000b = 10000011b
-00000011b ^ 10000001b = 10000010b
-00000011b ^ 10000010b = 10000001b
-00000011b ^ 10000011b = 10000000b
-00000011b ^ 10000100b = 10000111b
-00000011b ^ 10000101b = 10000110b
-00000011b ^ 10000110b = 10000101b
-00000011b ^ 10000111b = 10000100b
-00000011b ^ 10001000b = 10001011b
-00000011b ^ 10001001b = 10001010b
-00000011b ^ 10001010b = 10001001b
-00000011b ^ 10001011b = 10001000b
-00000011b ^ 10001100b = 10001111b
-00000011b ^ 10001101b = 10001110b
-00000011b ^ 10001110b = 10001101b
-00000011b ^ 10001111b = 10001100b
-00000011b ^ 10010000b = 10010011b
-00000011b ^ 10010001b = 10010010b
-00000011b ^ 10010010b = 10010001b
-00000011b ^ 10010011b = 10010000b
-00000011b ^ 10010100b = 10010111b
-00000011b ^ 10010101b = 10010110b
-00000011b ^ 10010110b = 10010101b
-00000011b ^ 10010111b = 10010100b
-00000011b ^ 10011000b = 10011011b
-00000011b ^ 10011001b = 10011010b
-00000011b ^ 10011010b = 10011001b
-00000011b ^ 10011011b = 10011000b
-00000011b ^ 10011100b = 10011111b
-00000011b ^ 10011101b = 10011110b
-00000011b ^ 10011110b = 10011101b
-00000011b ^ 10011111b = 10011100b
-00000011b ^ 10100000b = 10100011b
-00000011b ^ 10100001b = 10100010b
-00000011b ^ 10100010b = 10100001b
-00000011b ^ 10100011b = 10100000b
-00000011b ^ 10100100b = 10100111b
-00000011b ^ 10100101b = 10100110b
-00000011b ^ 10100110b = 10100101b
-00000011b ^ 10100111b = 10100100b
-00000011b ^ 10101000b = 10101011b
-00000011b ^ 10101001b = 10101010b
-00000011b ^ 10101010b = 10101001b
-00000011b ^ 10101011b = 10101000b
-00000011b ^ 10101100b = 10101111b
-00000011b ^ 10101101b = 10101110b
-00000011b ^ 10101110b = 10101101b
-00000011b ^ 10101111b = 10101100b
-00000011b ^ 10110000b = 10110011b
-00000011b ^ 10110001b = 10110010b
-00000011b ^ 10110010b = 10110001b
-00000011b ^ 10110011b = 10110000b
-00000011b ^ 10110100b = 10110111b
-00000011b ^ 10110101b = 10110110b
-00000011b ^ 10110110b = 10110101b
-00000011b ^ 10110111b = 10110100b
-00000011b ^ 10111000b = 10111011b
-00000011b ^ 10111001b = 10111010b
-00000011b ^ 10111010b = 10111001b
-00000011b ^ 10111011b = 10111000b
-00000011b ^ 10111100b = 10111111b
-00000011b ^ 10111101b = 10111110b
-00000011b ^ 10111110b = 10111101b
-00000011b ^ 10111111b = 10111100b
-00000011b ^ 11000000b = 11000011b
-00000011b ^ 11000001b = 11000010b
-00000011b ^ 11000010b = 11000001b
-00000011b ^ 11000011b = 11000000b
-00000011b ^ 11000100b = 11000111b
-00000011b ^ 11000101b = 11000110b
-00000011b ^ 11000110b = 11000101b
-00000011b ^ 11000111b = 11000100b
-00000011b ^ 11001000b = 11001011b
-00000011b ^ 11001001b = 11001010b
-00000011b ^ 11001010b = 11001001b
-00000011b ^ 11001011b = 11001000b
-00000011b ^ 11001100b = 11001111b
-00000011b ^ 11001101b = 11001110b
-00000011b ^ 11001110b = 11001101b
-00000011b ^ 11001111b = 11001100b
-00000011b ^ 11010000b = 11010011b
-00000011b ^ 11010001b = 11010010b
-00000011b ^ 11010010b = 11010001b
-00000011b ^ 11010011b = 11010000b
-00000011b ^ 11010100b = 11010111b
-00000011b ^ 11010101b = 11010110b
-00000011b ^ 11010110b = 11010101b
-00000011b ^ 11010111b = 11010100b
-00000011b ^ 11011000b = 11011011b
-00000011b ^ 11011001b = 11011010b
-00000011b ^ 11011010b = 11011001b
-00000011b ^ 11011011b = 11011000b
-00000011b ^ 11011100b = 11011111b
-00000011b ^ 11011101b = 11011110b
-00000011b ^ 11011110b = 11011101b
-00000011b ^ 11011111b = 11011100b
-00000011b ^ 11100000b = 11100011b
-00000011b ^ 11100001b = 11100010b
-00000011b ^ 11100010b = 11100001b
-00000011b ^ 11100011b = 11100000b
-00000011b ^ 11100100b = 11100111b
-00000011b ^ 11100101b = 11100110b
-00000011b ^ 11100110b = 11100101b
-00000011b ^ 11100111b = 11100100b
-00000011b ^ 11101000b = 11101011b
-00000011b ^ 11101001b = 11101010b
-00000011b ^ 11101010b = 11101001b
-00000011b ^ 11101011b = 11101000b
-00000011b ^ 11101100b = 11101111b
-00000011b ^ 11101101b = 11101110b
-00000011b ^ 11101110b = 11101101b
-00000011b ^ 11101111b = 11101100b
-00000011b ^ 11110000b = 11110011b
-00000011b ^ 11110001b = 11110010b
-00000011b ^ 11110010b = 11110001b
-00000011b ^ 11110011b = 11110000b
-00000011b ^ 11110100b = 11110111b
-00000011b ^ 11110101b = 11110110b
-00000011b ^ 11110110b = 11110101b
-00000011b ^ 11110111b = 11110100b
-00000011b ^ 11111000b = 11111011b
-00000011b ^ 11111001b = 11111010b
-00000011b ^ 11111010b = 11111001b
-00000011b ^ 11111011b = 11111000b
-00000011b ^ 11111100b = 11111111b
-00000011b ^ 11111101b = 11111110b
-00000011b ^ 11111110b = 11111101b
-00000011b ^ 11111111b = 11111100b
-00000011b ^ 00000000b = 00000011b
-00000011b ^ 00000001b = 00000010b
-00000011b ^ 00000010b = 00000001b
-00000011b ^ 00000011b = 00000000b
-00000011b ^ 00000100b = 00000111b
-00000011b ^ 00000101b = 00000110b
-00000011b ^ 00000110b = 00000101b
-00000011b ^ 00000111b = 00000100b
-00000011b ^ 00001000b = 00001011b
-00000011b ^ 00001001b = 00001010b
-00000011b ^ 00001010b = 00001001b
-00000011b ^ 00001011b = 00001000b
-00000011b ^ 00001100b = 00001111b
-00000011b ^ 00001101b = 00001110b
-00000011b ^ 00001110b = 00001101b
-00000011b ^ 00001111b = 00001100b
-00000011b ^ 00010000b = 00010011b
-00000011b ^ 00010001b = 00010010b
-00000011b ^ 00010010b = 00010001b
-00000011b ^ 00010011b = 00010000b
-00000011b ^ 00010100b = 00010111b
-00000011b ^ 00010101b = 00010110b
-00000011b ^ 00010110b = 00010101b
-00000011b ^ 00010111b = 00010100b
-00000011b ^ 00011000b = 00011011b
-00000011b ^ 00011001b = 00011010b
-00000011b ^ 00011010b = 00011001b
-00000011b ^ 00011011b = 00011000b
-00000011b ^ 00011100b = 00011111b
-00000011b ^ 00011101b = 00011110b
-00000011b ^ 00011110b = 00011101b
-00000011b ^ 00011111b = 00011100b
-00000011b ^ 00100000b = 00100011b
-00000011b ^ 00100001b = 00100010b
-00000011b ^ 00100010b = 00100001b
-00000011b ^ 00100011b = 00100000b
-00000011b ^ 00100100b = 00100111b
-00000011b ^ 00100101b = 00100110b
-00000011b ^ 00100110b = 00100101b
-00000011b ^ 00100111b = 00100100b
-00000011b ^ 00101000b = 00101011b
-00000011b ^ 00101001b = 00101010b
-00000011b ^ 00101010b = 00101001b
-00000011b ^ 00101011b = 00101000b
-00000011b ^ 00101100b = 00101111b
-00000011b ^ 00101101b = 00101110b
-00000011b ^ 00101110b = 00101101b
-00000011b ^ 00101111b = 00101100b
-00000011b ^ 00110000b = 00110011b
-00000011b ^ 00110001b = 00110010b
-00000011b ^ 00110010b = 00110001b
-00000011b ^ 00110011b = 00110000b
-00000011b ^ 00110100b = 00110111b
-00000011b ^ 00110101b = 00110110b
-00000011b ^ 00110110b = 00110101b
-00000011b ^ 00110111b = 00110100b
-00000011b ^ 00111000b = 00111011b
-00000011b ^ 00111001b = 00111010b
-00000011b ^ 00111010b = 00111001b
-00000011b ^ 00111011b = 00111000b
-00000011b ^ 00111100b = 00111111b
-00000011b ^ 00111101b = 00111110b
-00000011b ^ 00111110b = 00111101b
-00000011b ^ 00111111b = 00111100b
-00000011b ^ 01000000b = 01000011b
-00000011b ^ 01000001b = 01000010b
-00000011b ^ 01000010b = 01000001b
-00000011b ^ 01000011b = 01000000b
-00000011b ^ 01000100b = 01000111b
-00000011b ^ 01000101b = 01000110b
-00000011b ^ 01000110b = 01000101b
-00000011b ^ 01000111b = 01000100b
-00000011b ^ 01001000b = 01001011b
-00000011b ^ 01001001b = 01001010b
-00000011b ^ 01001010b = 01001001b
-00000011b ^ 01001011b = 01001000b
-00000011b ^ 01001100b = 01001111b
-00000011b ^ 01001101b = 01001110b
-00000011b ^ 01001110b = 01001101b
-00000011b ^ 01001111b = 01001100b
-00000011b ^ 01010000b = 01010011b
-00000011b ^ 01010001b = 01010010b
-00000011b ^ 01010010b = 01010001b
-00000011b ^ 01010011b = 01010000b
-00000011b ^ 01010100b = 01010111b
-00000011b ^ 01010101b = 01010110b
-00000011b ^ 01010110b = 01010101b
-00000011b ^ 01010111b = 01010100b
-00000011b ^ 01011000b = 01011011b
-00000011b ^ 01011001b = 01011010b
-00000011b ^ 01011010b = 01011001b
-00000011b ^ 01011011b = 01011000b
-00000011b ^ 01011100b = 01011111b
-00000011b ^ 01011101b = 01011110b
-00000011b ^ 01011110b = 01011101b
-00000011b ^ 01011111b = 01011100b
-00000011b ^ 01100000b = 01100011b
-00000011b ^ 01100001b = 01100010b
-00000011b ^ 01100010b = 01100001b
-00000011b ^ 01100011b = 01100000b
-00000011b ^ 01100100b = 01100111b
-00000011b ^ 01100101b = 01100110b
-00000011b ^ 01100110b = 01100101b
-00000011b ^ 01100111b = 01100100b
-00000011b ^ 01101000b = 01101011b
-00000011b ^ 01101001b = 01101010b
-00000011b ^ 01101010b = 01101001b
-00000011b ^ 01101011b = 01101000b
-00000011b ^ 01101100b = 01101111b
-00000011b ^ 01101101b = 01101110b
-00000011b ^ 01101110b = 01101101b
-00000011b ^ 01101111b = 01101100b
-00000011b ^ 01110000b = 01110011b
-00000011b ^ 01110001b = 01110010b
-00000011b ^ 01110010b = 01110001b
-00000011b ^ 01110011b = 01110000b
-00000011b ^ 01110100b = 01110111b
-00000011b ^ 01110101b = 01110110b
-00000011b ^ 01110110b = 01110101b
-00000011b ^ 01110111b = 01110100b
-00000011b ^ 01111000b = 01111011b
-00000011b ^ 01111001b = 01111010b
-00000011b ^ 01111010b = 01111001b
-00000011b ^ 01111011b = 01111000b
-00000011b ^ 01111100b = 01111111b
-00000011b ^ 01111101b = 01111110b
-00000011b ^ 01111110b = 01111101b
-00000100b ^ 10000000b = 10000100b
-00000100b ^ 10000001b = 10000101b
-00000100b ^ 10000010b = 10000110b
-00000100b ^ 10000011b = 10000111b
-00000100b ^ 10000100b = 10000000b
-00000100b ^ 10000101b = 10000001b
-00000100b ^ 10000110b = 10000010b
-00000100b ^ 10000111b = 10000011b
-00000100b ^ 10001000b = 10001100b
-00000100b ^ 10001001b = 10001101b
-00000100b ^ 10001010b = 10001110b
-00000100b ^ 10001011b = 10001111b
-00000100b ^ 10001100b = 10001000b
-00000100b ^ 10001101b = 10001001b
-00000100b ^ 10001110b = 10001010b
-00000100b ^ 10001111b = 10001011b
-00000100b ^ 10010000b = 10010100b
-00000100b ^ 10010001b = 10010101b
-00000100b ^ 10010010b = 10010110b
-00000100b ^ 10010011b = 10010111b
-00000100b ^ 10010100b = 10010000b
-00000100b ^ 10010101b = 10010001b
-00000100b ^ 10010110b = 10010010b
-00000100b ^ 10010111b = 10010011b
-00000100b ^ 10011000b = 10011100b
-00000100b ^ 10011001b = 10011101b
-00000100b ^ 10011010b = 10011110b
-00000100b ^ 10011011b = 10011111b
-00000100b ^ 10011100b = 10011000b
-00000100b ^ 10011101b = 10011001b
-00000100b ^ 10011110b = 10011010b
-00000100b ^ 10011111b = 10011011b
-00000100b ^ 10100000b = 10100100b
-00000100b ^ 10100001b = 10100101b
-00000100b ^ 10100010b = 10100110b
-00000100b ^ 10100011b = 10100111b
-00000100b ^ 10100100b = 10100000b
-00000100b ^ 10100101b = 10100001b
-00000100b ^ 10100110b = 10100010b
-00000100b ^ 10100111b = 10100011b
-00000100b ^ 10101000b = 10101100b
-00000100b ^ 10101001b = 10101101b
-00000100b ^ 10101010b = 10101110b
-00000100b ^ 10101011b = 10101111b
-00000100b ^ 10101100b = 10101000b
-00000100b ^ 10101101b = 10101001b
-00000100b ^ 10101110b = 10101010b
-00000100b ^ 10101111b = 10101011b
-00000100b ^ 10110000b = 10110100b
-00000100b ^ 10110001b = 10110101b
-00000100b ^ 10110010b = 10110110b
-00000100b ^ 10110011b = 10110111b
-00000100b ^ 10110100b = 10110000b
-00000100b ^ 10110101b = 10110001b
-00000100b ^ 10110110b = 10110010b
-00000100b ^ 10110111b = 10110011b
-00000100b ^ 10111000b = 10111100b
-00000100b ^ 10111001b = 10111101b
-00000100b ^ 10111010b = 10111110b
-00000100b ^ 10111011b = 10111111b
-00000100b ^ 10111100b = 10111000b
-00000100b ^ 10111101b = 10111001b
-00000100b ^ 10111110b = 10111010b
-00000100b ^ 10111111b = 10111011b
-00000100b ^ 11000000b = 11000100b
-00000100b ^ 11000001b = 11000101b
-00000100b ^ 11000010b = 11000110b
-00000100b ^ 11000011b = 11000111b
-00000100b ^ 11000100b = 11000000b
-00000100b ^ 11000101b = 11000001b
-00000100b ^ 11000110b = 11000010b
-00000100b ^ 11000111b = 11000011b
-00000100b ^ 11001000b = 11001100b
-00000100b ^ 11001001b = 11001101b
-00000100b ^ 11001010b = 11001110b
-00000100b ^ 11001011b = 11001111b
-00000100b ^ 11001100b = 11001000b
-00000100b ^ 11001101b = 11001001b
-00000100b ^ 11001110b = 11001010b
-00000100b ^ 11001111b = 11001011b
-00000100b ^ 11010000b = 11010100b
-00000100b ^ 11010001b = 11010101b
-00000100b ^ 11010010b = 11010110b
-00000100b ^ 11010011b = 11010111b
-00000100b ^ 11010100b = 11010000b
-00000100b ^ 11010101b = 11010001b
-00000100b ^ 11010110b = 11010010b
-00000100b ^ 11010111b = 11010011b
-00000100b ^ 11011000b = 11011100b
-00000100b ^ 11011001b = 11011101b
-00000100b ^ 11011010b = 11011110b
-00000100b ^ 11011011b = 11011111b
-00000100b ^ 11011100b = 11011000b
-00000100b ^ 11011101b = 11011001b
-00000100b ^ 11011110b = 11011010b
-00000100b ^ 11011111b = 11011011b
-00000100b ^ 11100000b = 11100100b
-00000100b ^ 11100001b = 11100101b
-00000100b ^ 11100010b = 11100110b
-00000100b ^ 11100011b = 11100111b
-00000100b ^ 11100100b = 11100000b
-00000100b ^ 11100101b = 11100001b
-00000100b ^ 11100110b = 11100010b
-00000100b ^ 11100111b = 11100011b
-00000100b ^ 11101000b = 11101100b
-00000100b ^ 11101001b = 11101101b
-00000100b ^ 11101010b = 11101110b
-00000100b ^ 11101011b = 11101111b
-00000100b ^ 11101100b = 11101000b
-00000100b ^ 11101101b = 11101001b
-00000100b ^ 11101110b = 11101010b
-00000100b ^ 11101111b = 11101011b
-00000100b ^ 11110000b = 11110100b
-00000100b ^ 11110001b = 11110101b
-00000100b ^ 11110010b = 11110110b
-00000100b ^ 11110011b = 11110111b
-00000100b ^ 11110100b = 11110000b
-00000100b ^ 11110101b = 11110001b
-00000100b ^ 11110110b = 11110010b
-00000100b ^ 11110111b = 11110011b
-00000100b ^ 11111000b = 11111100b
-00000100b ^ 11111001b = 11111101b
-00000100b ^ 11111010b = 11111110b
-00000100b ^ 11111011b = 11111111b
-00000100b ^ 11111100b = 11111000b
-00000100b ^ 11111101b = 11111001b
-00000100b ^ 11111110b = 11111010b
-00000100b ^ 11111111b = 11111011b
-00000100b ^ 00000000b = 00000100b
-00000100b ^ 00000001b = 00000101b
-00000100b ^ 00000010b = 00000110b
-00000100b ^ 00000011b = 00000111b
-00000100b ^ 00000100b = 00000000b
-00000100b ^ 00000101b = 00000001b
-00000100b ^ 00000110b = 00000010b
-00000100b ^ 00000111b = 00000011b
-00000100b ^ 00001000b = 00001100b
-00000100b ^ 00001001b = 00001101b
-00000100b ^ 00001010b = 00001110b
-00000100b ^ 00001011b = 00001111b
-00000100b ^ 00001100b = 00001000b
-00000100b ^ 00001101b = 00001001b
-00000100b ^ 00001110b = 00001010b
-00000100b ^ 00001111b = 00001011b
-00000100b ^ 00010000b = 00010100b
-00000100b ^ 00010001b = 00010101b
-00000100b ^ 00010010b = 00010110b
-00000100b ^ 00010011b = 00010111b
-00000100b ^ 00010100b = 00010000b
-00000100b ^ 00010101b = 00010001b
-00000100b ^ 00010110b = 00010010b
-00000100b ^ 00010111b = 00010011b
-00000100b ^ 00011000b = 00011100b
-00000100b ^ 00011001b = 00011101b
-00000100b ^ 00011010b = 00011110b
-00000100b ^ 00011011b = 00011111b
-00000100b ^ 00011100b = 00011000b
-00000100b ^ 00011101b = 00011001b
-00000100b ^ 00011110b = 00011010b
-00000100b ^ 00011111b = 00011011b
-00000100b ^ 00100000b = 00100100b
-00000100b ^ 00100001b = 00100101b
-00000100b ^ 00100010b = 00100110b
-00000100b ^ 00100011b = 00100111b
-00000100b ^ 00100100b = 00100000b
-00000100b ^ 00100101b = 00100001b
-00000100b ^ 00100110b = 00100010b
-00000100b ^ 00100111b = 00100011b
-00000100b ^ 00101000b = 00101100b
-00000100b ^ 00101001b = 00101101b
-00000100b ^ 00101010b = 00101110b
-00000100b ^ 00101011b = 00101111b
-00000100b ^ 00101100b = 00101000b
-00000100b ^ 00101101b = 00101001b
-00000100b ^ 00101110b = 00101010b
-00000100b ^ 00101111b = 00101011b
-00000100b ^ 00110000b = 00110100b
-00000100b ^ 00110001b = 00110101b
-00000100b ^ 00110010b = 00110110b
-00000100b ^ 00110011b = 00110111b
-00000100b ^ 00110100b = 00110000b
-00000100b ^ 00110101b = 00110001b
-00000100b ^ 00110110b = 00110010b
-00000100b ^ 00110111b = 00110011b
-00000100b ^ 00111000b = 00111100b
-00000100b ^ 00111001b = 00111101b
-00000100b ^ 00111010b = 00111110b
-00000100b ^ 00111011b = 00111111b
-00000100b ^ 00111100b = 00111000b
-00000100b ^ 00111101b = 00111001b
-00000100b ^ 00111110b = 00111010b
-00000100b ^ 00111111b = 00111011b
-00000100b ^ 01000000b = 01000100b
-00000100b ^ 01000001b = 01000101b
-00000100b ^ 01000010b = 01000110b
-00000100b ^ 01000011b = 01000111b
-00000100b ^ 01000100b = 01000000b
-00000100b ^ 01000101b = 01000001b
-00000100b ^ 01000110b = 01000010b
-00000100b ^ 01000111b = 01000011b
-00000100b ^ 01001000b = 01001100b
-00000100b ^ 01001001b = 01001101b
-00000100b ^ 01001010b = 01001110b
-00000100b ^ 01001011b = 01001111b
-00000100b ^ 01001100b = 01001000b
-00000100b ^ 01001101b = 01001001b
-00000100b ^ 01001110b = 01001010b
-00000100b ^ 01001111b = 01001011b
-00000100b ^ 01010000b = 01010100b
-00000100b ^ 01010001b = 01010101b
-00000100b ^ 01010010b = 01010110b
-00000100b ^ 01010011b = 01010111b
-00000100b ^ 01010100b = 01010000b
-00000100b ^ 01010101b = 01010001b
-00000100b ^ 01010110b = 01010010b
-00000100b ^ 01010111b = 01010011b
-00000100b ^ 01011000b = 01011100b
-00000100b ^ 01011001b = 01011101b
-00000100b ^ 01011010b = 01011110b
-00000100b ^ 01011011b = 01011111b
-00000100b ^ 01011100b = 01011000b
-00000100b ^ 01011101b = 01011001b
-00000100b ^ 01011110b = 01011010b
-00000100b ^ 01011111b = 01011011b
-00000100b ^ 01100000b = 01100100b
-00000100b ^ 01100001b = 01100101b
-00000100b ^ 01100010b = 01100110b
-00000100b ^ 01100011b = 01100111b
-00000100b ^ 01100100b = 01100000b
-00000100b ^ 01100101b = 01100001b
-00000100b ^ 01100110b = 01100010b
-00000100b ^ 01100111b = 01100011b
-00000100b ^ 01101000b = 01101100b
-00000100b ^ 01101001b = 01101101b
-00000100b ^ 01101010b = 01101110b
-00000100b ^ 01101011b = 01101111b
-00000100b ^ 01101100b = 01101000b
-00000100b ^ 01101101b = 01101001b
-00000100b ^ 01101110b = 01101010b
-00000100b ^ 01101111b = 01101011b
-00000100b ^ 01110000b = 01110100b
-00000100b ^ 01110001b = 01110101b
-00000100b ^ 01110010b = 01110110b
-00000100b ^ 01110011b = 01110111b
-00000100b ^ 01110100b = 01110000b
-00000100b ^ 01110101b = 01110001b
-00000100b ^ 01110110b = 01110010b
-00000100b ^ 01110111b = 01110011b
-00000100b ^ 01111000b = 01111100b
-00000100b ^ 01111001b = 01111101b
-00000100b ^ 01111010b = 01111110b
-00000100b ^ 01111011b = 01111111b
-00000100b ^ 01111100b = 01111000b
-00000100b ^ 01111101b = 01111001b
-00000100b ^ 01111110b = 01111010b
-00000101b ^ 10000000b = 10000101b
-00000101b ^ 10000001b = 10000100b
-00000101b ^ 10000010b = 10000111b
-00000101b ^ 10000011b = 10000110b
-00000101b ^ 10000100b = 10000001b
-00000101b ^ 10000101b = 10000000b
-00000101b ^ 10000110b = 10000011b
-00000101b ^ 10000111b = 10000010b
-00000101b ^ 10001000b = 10001101b
-00000101b ^ 10001001b = 10001100b
-00000101b ^ 10001010b = 10001111b
-00000101b ^ 10001011b = 10001110b
-00000101b ^ 10001100b = 10001001b
-00000101b ^ 10001101b = 10001000b
-00000101b ^ 10001110b = 10001011b
-00000101b ^ 10001111b = 10001010b
-00000101b ^ 10010000b = 10010101b
-00000101b ^ 10010001b = 10010100b
-00000101b ^ 10010010b = 10010111b
-00000101b ^ 10010011b = 10010110b
-00000101b ^ 10010100b = 10010001b
-00000101b ^ 10010101b = 10010000b
-00000101b ^ 10010110b = 10010011b
-00000101b ^ 10010111b = 10010010b
-00000101b ^ 10011000b = 10011101b
-00000101b ^ 10011001b = 10011100b
-00000101b ^ 10011010b = 10011111b
-00000101b ^ 10011011b = 10011110b
-00000101b ^ 10011100b = 10011001b
-00000101b ^ 10011101b = 10011000b
-00000101b ^ 10011110b = 10011011b
-00000101b ^ 10011111b = 10011010b
-00000101b ^ 10100000b = 10100101b
-00000101b ^ 10100001b = 10100100b
-00000101b ^ 10100010b = 10100111b
-00000101b ^ 10100011b = 10100110b
-00000101b ^ 10100100b = 10100001b
-00000101b ^ 10100101b = 10100000b
-00000101b ^ 10100110b = 10100011b
-00000101b ^ 10100111b = 10100010b
-00000101b ^ 10101000b = 10101101b
-00000101b ^ 10101001b = 10101100b
-00000101b ^ 10101010b = 10101111b
-00000101b ^ 10101011b = 10101110b
-00000101b ^ 10101100b = 10101001b
-00000101b ^ 10101101b = 10101000b
-00000101b ^ 10101110b = 10101011b
-00000101b ^ 10101111b = 10101010b
-00000101b ^ 10110000b = 10110101b
-00000101b ^ 10110001b = 10110100b
-00000101b ^ 10110010b = 10110111b
-00000101b ^ 10110011b = 10110110b
-00000101b ^ 10110100b = 10110001b
-00000101b ^ 10110101b = 10110000b
-00000101b ^ 10110110b = 10110011b
-00000101b ^ 10110111b = 10110010b
-00000101b ^ 10111000b = 10111101b
-00000101b ^ 10111001b = 10111100b
-00000101b ^ 10111010b = 10111111b
-00000101b ^ 10111011b = 10111110b
-00000101b ^ 10111100b = 10111001b
-00000101b ^ 10111101b = 10111000b
-00000101b ^ 10111110b = 10111011b
-00000101b ^ 10111111b = 10111010b
-00000101b ^ 11000000b = 11000101b
-00000101b ^ 11000001b = 11000100b
-00000101b ^ 11000010b = 11000111b
-00000101b ^ 11000011b = 11000110b
-00000101b ^ 11000100b = 11000001b
-00000101b ^ 11000101b = 11000000b
-00000101b ^ 11000110b = 11000011b
-00000101b ^ 11000111b = 11000010b
-00000101b ^ 11001000b = 11001101b
-00000101b ^ 11001001b = 11001100b
-00000101b ^ 11001010b = 11001111b
-00000101b ^ 11001011b = 11001110b
-00000101b ^ 11001100b = 11001001b
-00000101b ^ 11001101b = 11001000b
-00000101b ^ 11001110b = 11001011b
-00000101b ^ 11001111b = 11001010b
-00000101b ^ 11010000b = 11010101b
-00000101b ^ 11010001b = 11010100b
-00000101b ^ 11010010b = 11010111b
-00000101b ^ 11010011b = 11010110b
-00000101b ^ 11010100b = 11010001b
-00000101b ^ 11010101b = 11010000b
-00000101b ^ 11010110b = 11010011b
-00000101b ^ 11010111b = 11010010b
-00000101b ^ 11011000b = 11011101b
-00000101b ^ 11011001b = 11011100b
-00000101b ^ 11011010b = 11011111b
-00000101b ^ 11011011b = 11011110b
-00000101b ^ 11011100b = 11011001b
-00000101b ^ 11011101b = 11011000b
-00000101b ^ 11011110b = 11011011b
-00000101b ^ 11011111b = 11011010b
-00000101b ^ 11100000b = 11100101b
-00000101b ^ 11100001b = 11100100b
-00000101b ^ 11100010b = 11100111b
-00000101b ^ 11100011b = 11100110b
-00000101b ^ 11100100b = 11100001b
-00000101b ^ 11100101b = 11100000b
-00000101b ^ 11100110b = 11100011b
-00000101b ^ 11100111b = 11100010b
-00000101b ^ 11101000b = 11101101b
-00000101b ^ 11101001b = 11101100b
-00000101b ^ 11101010b = 11101111b
-00000101b ^ 11101011b = 11101110b
-00000101b ^ 11101100b = 11101001b
-00000101b ^ 11101101b = 11101000b
-00000101b ^ 11101110b = 11101011b
-00000101b ^ 11101111b = 11101010b
-00000101b ^ 11110000b = 11110101b
-00000101b ^ 11110001b = 11110100b
-00000101b ^ 11110010b = 11110111b
-00000101b ^ 11110011b = 11110110b
-00000101b ^ 11110100b = 11110001b
-00000101b ^ 11110101b = 11110000b
-00000101b ^ 11110110b = 11110011b
-00000101b ^ 11110111b = 11110010b
-00000101b ^ 11111000b = 11111101b
-00000101b ^ 11111001b = 11111100b
-00000101b ^ 11111010b = 11111111b
-00000101b ^ 11111011b = 11111110b
-00000101b ^ 11111100b = 11111001b
-00000101b ^ 11111101b = 11111000b
-00000101b ^ 11111110b = 11111011b
-00000101b ^ 11111111b = 11111010b
-00000101b ^ 00000000b = 00000101b
-00000101b ^ 00000001b = 00000100b
-00000101b ^ 00000010b = 00000111b
-00000101b ^ 00000011b = 00000110b
-00000101b ^ 00000100b = 00000001b
-00000101b ^ 00000101b = 00000000b
-00000101b ^ 00000110b = 00000011b
-00000101b ^ 00000111b = 00000010b
-00000101b ^ 00001000b = 00001101b
-00000101b ^ 00001001b = 00001100b
-00000101b ^ 00001010b = 00001111b
-00000101b ^ 00001011b = 00001110b
-00000101b ^ 00001100b = 00001001b
-00000101b ^ 00001101b = 00001000b
-00000101b ^ 00001110b = 00001011b
-00000101b ^ 00001111b = 00001010b
-00000101b ^ 00010000b = 00010101b
-00000101b ^ 00010001b = 00010100b
-00000101b ^ 00010010b = 00010111b
-00000101b ^ 00010011b = 00010110b
-00000101b ^ 00010100b = 00010001b
-00000101b ^ 00010101b = 00010000b
-00000101b ^ 00010110b = 00010011b
-00000101b ^ 00010111b = 00010010b
-00000101b ^ 00011000b = 00011101b
-00000101b ^ 00011001b = 00011100b
-00000101b ^ 00011010b = 00011111b
-00000101b ^ 00011011b = 00011110b
-00000101b ^ 00011100b = 00011001b
-00000101b ^ 00011101b = 00011000b
-00000101b ^ 00011110b = 00011011b
-00000101b ^ 00011111b = 00011010b
-00000101b ^ 00100000b = 00100101b
-00000101b ^ 00100001b = 00100100b
-00000101b ^ 00100010b = 00100111b
-00000101b ^ 00100011b = 00100110b
-00000101b ^ 00100100b = 00100001b
-00000101b ^ 00100101b = 00100000b
-00000101b ^ 00100110b = 00100011b
-00000101b ^ 00100111b = 00100010b
-00000101b ^ 00101000b = 00101101b
-00000101b ^ 00101001b = 00101100b
-00000101b ^ 00101010b = 00101111b
-00000101b ^ 00101011b = 00101110b
-00000101b ^ 00101100b = 00101001b
-00000101b ^ 00101101b = 00101000b
-00000101b ^ 00101110b = 00101011b
-00000101b ^ 00101111b = 00101010b
-00000101b ^ 00110000b = 00110101b
-00000101b ^ 00110001b = 00110100b
-00000101b ^ 00110010b = 00110111b
-00000101b ^ 00110011b = 00110110b
-00000101b ^ 00110100b = 00110001b
-00000101b ^ 00110101b = 00110000b
-00000101b ^ 00110110b = 00110011b
-00000101b ^ 00110111b = 00110010b
-00000101b ^ 00111000b = 00111101b
-00000101b ^ 00111001b = 00111100b
-00000101b ^ 00111010b = 00111111b
-00000101b ^ 00111011b = 00111110b
-00000101b ^ 00111100b = 00111001b
-00000101b ^ 00111101b = 00111000b
-00000101b ^ 00111110b = 00111011b
-00000101b ^ 00111111b = 00111010b
-00000101b ^ 01000000b = 01000101b
-00000101b ^ 01000001b = 01000100b
-00000101b ^ 01000010b = 01000111b
-00000101b ^ 01000011b = 01000110b
-00000101b ^ 01000100b = 01000001b
-00000101b ^ 01000101b = 01000000b
-00000101b ^ 01000110b = 01000011b
-00000101b ^ 01000111b = 01000010b
-00000101b ^ 01001000b = 01001101b
-00000101b ^ 01001001b = 01001100b
-00000101b ^ 01001010b = 01001111b
-00000101b ^ 01001011b = 01001110b
-00000101b ^ 01001100b = 01001001b
-00000101b ^ 01001101b = 01001000b
-00000101b ^ 01001110b = 01001011b
-00000101b ^ 01001111b = 01001010b
-00000101b ^ 01010000b = 01010101b
-00000101b ^ 01010001b = 01010100b
-00000101b ^ 01010010b = 01010111b
-00000101b ^ 01010011b = 01010110b
-00000101b ^ 01010100b = 01010001b
-00000101b ^ 01010101b = 01010000b
-00000101b ^ 01010110b = 01010011b
-00000101b ^ 01010111b = 01010010b
-00000101b ^ 01011000b = 01011101b
-00000101b ^ 01011001b = 01011100b
-00000101b ^ 01011010b = 01011111b
-00000101b ^ 01011011b = 01011110b
-00000101b ^ 01011100b = 01011001b
-00000101b ^ 01011101b = 01011000b
-00000101b ^ 01011110b = 01011011b
-00000101b ^ 01011111b = 01011010b
-00000101b ^ 01100000b = 01100101b
-00000101b ^ 01100001b = 01100100b
-00000101b ^ 01100010b = 01100111b
-00000101b ^ 01100011b = 01100110b
-00000101b ^ 01100100b = 01100001b
-00000101b ^ 01100101b = 01100000b
-00000101b ^ 01100110b = 01100011b
-00000101b ^ 01100111b = 01100010b
-00000101b ^ 01101000b = 01101101b
-00000101b ^ 01101001b = 01101100b
-00000101b ^ 01101010b = 01101111b
-00000101b ^ 01101011b = 01101110b
-00000101b ^ 01101100b = 01101001b
-00000101b ^ 01101101b = 01101000b
-00000101b ^ 01101110b = 01101011b
-00000101b ^ 01101111b = 01101010b
-00000101b ^ 01110000b = 01110101b
-00000101b ^ 01110001b = 01110100b
-00000101b ^ 01110010b = 01110111b
-00000101b ^ 01110011b = 01110110b
-00000101b ^ 01110100b = 01110001b
-00000101b ^ 01110101b = 01110000b
-00000101b ^ 01110110b = 01110011b
-00000101b ^ 01110111b = 01110010b
-00000101b ^ 01111000b = 01111101b
-00000101b ^ 01111001b = 01111100b
-00000101b ^ 01111010b = 01111111b
-00000101b ^ 01111011b = 01111110b
-00000101b ^ 01111100b = 01111001b
-00000101b ^ 01111101b = 01111000b
-00000101b ^ 01111110b = 01111011b
-00000110b ^ 10000000b = 10000110b
-00000110b ^ 10000001b = 10000111b
-00000110b ^ 10000010b = 10000100b
-00000110b ^ 10000011b = 10000101b
-00000110b ^ 10000100b = 10000010b
-00000110b ^ 10000101b = 10000011b
-00000110b ^ 10000110b = 10000000b
-00000110b ^ 10000111b = 10000001b
-00000110b ^ 10001000b = 10001110b
-00000110b ^ 10001001b = 10001111b
-00000110b ^ 10001010b = 10001100b
-00000110b ^ 10001011b = 10001101b
-00000110b ^ 10001100b = 10001010b
-00000110b ^ 10001101b = 10001011b
-00000110b ^ 10001110b = 10001000b
-00000110b ^ 10001111b = 10001001b
-00000110b ^ 10010000b = 10010110b
-00000110b ^ 10010001b = 10010111b
-00000110b ^ 10010010b = 10010100b
-00000110b ^ 10010011b = 10010101b
-00000110b ^ 10010100b = 10010010b
-00000110b ^ 10010101b = 10010011b
-00000110b ^ 10010110b = 10010000b
-00000110b ^ 10010111b = 10010001b
-00000110b ^ 10011000b = 10011110b
-00000110b ^ 10011001b = 10011111b
-00000110b ^ 10011010b = 10011100b
-00000110b ^ 10011011b = 10011101b
-00000110b ^ 10011100b = 10011010b
-00000110b ^ 10011101b = 10011011b
-00000110b ^ 10011110b = 10011000b
-00000110b ^ 10011111b = 10011001b
-00000110b ^ 10100000b = 10100110b
-00000110b ^ 10100001b = 10100111b
-00000110b ^ 10100010b = 10100100b
-00000110b ^ 10100011b = 10100101b
-00000110b ^ 10100100b = 10100010b
-00000110b ^ 10100101b = 10100011b
-00000110b ^ 10100110b = 10100000b
-00000110b ^ 10100111b = 10100001b
-00000110b ^ 10101000b = 10101110b
-00000110b ^ 10101001b = 10101111b
-00000110b ^ 10101010b = 10101100b
-00000110b ^ 10101011b = 10101101b
-00000110b ^ 10101100b = 10101010b
-00000110b ^ 10101101b = 10101011b
-00000110b ^ 10101110b = 10101000b
-00000110b ^ 10101111b = 10101001b
-00000110b ^ 10110000b = 10110110b
-00000110b ^ 10110001b = 10110111b
-00000110b ^ 10110010b = 10110100b
-00000110b ^ 10110011b = 10110101b
-00000110b ^ 10110100b = 10110010b
-00000110b ^ 10110101b = 10110011b
-00000110b ^ 10110110b = 10110000b
-00000110b ^ 10110111b = 10110001b
-00000110b ^ 10111000b = 10111110b
-00000110b ^ 10111001b = 10111111b
-00000110b ^ 10111010b = 10111100b
-00000110b ^ 10111011b = 10111101b
-00000110b ^ 10111100b = 10111010b
-00000110b ^ 10111101b = 10111011b
-00000110b ^ 10111110b = 10111000b
-00000110b ^ 10111111b = 10111001b
-00000110b ^ 11000000b = 11000110b
-00000110b ^ 11000001b = 11000111b
-00000110b ^ 11000010b = 11000100b
-00000110b ^ 11000011b = 11000101b
-00000110b ^ 11000100b = 11000010b
-00000110b ^ 11000101b = 11000011b
-00000110b ^ 11000110b = 11000000b
-00000110b ^ 11000111b = 11000001b
-00000110b ^ 11001000b = 11001110b
-00000110b ^ 11001001b = 11001111b
-00000110b ^ 11001010b = 11001100b
-00000110b ^ 11001011b = 11001101b
-00000110b ^ 11001100b = 11001010b
-00000110b ^ 11001101b = 11001011b
-00000110b ^ 11001110b = 11001000b
-00000110b ^ 11001111b = 11001001b
-00000110b ^ 11010000b = 11010110b
-00000110b ^ 11010001b = 11010111b
-00000110b ^ 11010010b = 11010100b
-00000110b ^ 11010011b = 11010101b
-00000110b ^ 11010100b = 11010010b
-00000110b ^ 11010101b = 11010011b
-00000110b ^ 11010110b = 11010000b
-00000110b ^ 11010111b = 11010001b
-00000110b ^ 11011000b = 11011110b
-00000110b ^ 11011001b = 11011111b
-00000110b ^ 11011010b = 11011100b
-00000110b ^ 11011011b = 11011101b
-00000110b ^ 11011100b = 11011010b
-00000110b ^ 11011101b = 11011011b
-00000110b ^ 11011110b = 11011000b
-00000110b ^ 11011111b = 11011001b
-00000110b ^ 11100000b = 11100110b
-00000110b ^ 11100001b = 11100111b
-00000110b ^ 11100010b = 11100100b
-00000110b ^ 11100011b = 11100101b
-00000110b ^ 11100100b = 11100010b
-00000110b ^ 11100101b = 11100011b
-00000110b ^ 11100110b = 11100000b
-00000110b ^ 11100111b = 11100001b
-00000110b ^ 11101000b = 11101110b
-00000110b ^ 11101001b = 11101111b
-00000110b ^ 11101010b = 11101100b
-00000110b ^ 11101011b = 11101101b
-00000110b ^ 11101100b = 11101010b
-00000110b ^ 11101101b = 11101011b
-00000110b ^ 11101110b = 11101000b
-00000110b ^ 11101111b = 11101001b
-00000110b ^ 11110000b = 11110110b
-00000110b ^ 11110001b = 11110111b
-00000110b ^ 11110010b = 11110100b
-00000110b ^ 11110011b = 11110101b
-00000110b ^ 11110100b = 11110010b
-00000110b ^ 11110101b = 11110011b
-00000110b ^ 11110110b = 11110000b
-00000110b ^ 11110111b = 11110001b
-00000110b ^ 11111000b = 11111110b
-00000110b ^ 11111001b = 11111111b
-00000110b ^ 11111010b = 11111100b
-00000110b ^ 11111011b = 11111101b
-00000110b ^ 11111100b = 11111010b
-00000110b ^ 11111101b = 11111011b
-00000110b ^ 11111110b = 11111000b
-00000110b ^ 11111111b = 11111001b
-00000110b ^ 00000000b = 00000110b
-00000110b ^ 00000001b = 00000111b
-00000110b ^ 00000010b = 00000100b
-00000110b ^ 00000011b = 00000101b
-00000110b ^ 00000100b = 00000010b
-00000110b ^ 00000101b = 00000011b
-00000110b ^ 00000110b = 00000000b
-00000110b ^ 00000111b = 00000001b
-00000110b ^ 00001000b = 00001110b
-00000110b ^ 00001001b = 00001111b
-00000110b ^ 00001010b = 00001100b
-00000110b ^ 00001011b = 00001101b
-00000110b ^ 00001100b = 00001010b
-00000110b ^ 00001101b = 00001011b
-00000110b ^ 00001110b = 00001000b
-00000110b ^ 00001111b = 00001001b
-00000110b ^ 00010000b = 00010110b
-00000110b ^ 00010001b = 00010111b
-00000110b ^ 00010010b = 00010100b
-00000110b ^ 00010011b = 00010101b
-00000110b ^ 00010100b = 00010010b
-00000110b ^ 00010101b = 00010011b
-00000110b ^ 00010110b = 00010000b
-00000110b ^ 00010111b = 00010001b
-00000110b ^ 00011000b = 00011110b
-00000110b ^ 00011001b = 00011111b
-00000110b ^ 00011010b = 00011100b
-00000110b ^ 00011011b = 00011101b
-00000110b ^ 00011100b = 00011010b
-00000110b ^ 00011101b = 00011011b
-00000110b ^ 00011110b = 00011000b
-00000110b ^ 00011111b = 00011001b
-00000110b ^ 00100000b = 00100110b
-00000110b ^ 00100001b = 00100111b
-00000110b ^ 00100010b = 00100100b
-00000110b ^ 00100011b = 00100101b
-00000110b ^ 00100100b = 00100010b
-00000110b ^ 00100101b = 00100011b
-00000110b ^ 00100110b = 00100000b
-00000110b ^ 00100111b = 00100001b
-00000110b ^ 00101000b = 00101110b
-00000110b ^ 00101001b = 00101111b
-00000110b ^ 00101010b = 00101100b
-00000110b ^ 00101011b = 00101101b
-00000110b ^ 00101100b = 00101010b
-00000110b ^ 00101101b = 00101011b
-00000110b ^ 00101110b = 00101000b
-00000110b ^ 00101111b = 00101001b
-00000110b ^ 00110000b = 00110110b
-00000110b ^ 00110001b = 00110111b
-00000110b ^ 00110010b = 00110100b
-00000110b ^ 00110011b = 00110101b
-00000110b ^ 00110100b = 00110010b
-00000110b ^ 00110101b = 00110011b
-00000110b ^ 00110110b = 00110000b
-00000110b ^ 00110111b = 00110001b
-00000110b ^ 00111000b = 00111110b
-00000110b ^ 00111001b = 00111111b
-00000110b ^ 00111010b = 00111100b
-00000110b ^ 00111011b = 00111101b
-00000110b ^ 00111100b = 00111010b
-00000110b ^ 00111101b = 00111011b
-00000110b ^ 00111110b = 00111000b
-00000110b ^ 00111111b = 00111001b
-00000110b ^ 01000000b = 01000110b
-00000110b ^ 01000001b = 01000111b
-00000110b ^ 01000010b = 01000100b
-00000110b ^ 01000011b = 01000101b
-00000110b ^ 01000100b = 01000010b
-00000110b ^ 01000101b = 01000011b
-00000110b ^ 01000110b = 01000000b
-00000110b ^ 01000111b = 01000001b
-00000110b ^ 01001000b = 01001110b
-00000110b ^ 01001001b = 01001111b
-00000110b ^ 01001010b = 01001100b
-00000110b ^ 01001011b = 01001101b
-00000110b ^ 01001100b = 01001010b
-00000110b ^ 01001101b = 01001011b
-00000110b ^ 01001110b = 01001000b
-00000110b ^ 01001111b = 01001001b
-00000110b ^ 01010000b = 01010110b
-00000110b ^ 01010001b = 01010111b
-00000110b ^ 01010010b = 01010100b
-00000110b ^ 01010011b = 01010101b
-00000110b ^ 01010100b = 01010010b
-00000110b ^ 01010101b = 01010011b
-00000110b ^ 01010110b = 01010000b
-00000110b ^ 01010111b = 01010001b
-00000110b ^ 01011000b = 01011110b
-00000110b ^ 01011001b = 01011111b
-00000110b ^ 01011010b = 01011100b
-00000110b ^ 01011011b = 01011101b
-00000110b ^ 01011100b = 01011010b
-00000110b ^ 01011101b = 01011011b
-00000110b ^ 01011110b = 01011000b
-00000110b ^ 01011111b = 01011001b
-00000110b ^ 01100000b = 01100110b
-00000110b ^ 01100001b = 01100111b
-00000110b ^ 01100010b = 01100100b
-00000110b ^ 01100011b = 01100101b
-00000110b ^ 01100100b = 01100010b
-00000110b ^ 01100101b = 01100011b
-00000110b ^ 01100110b = 01100000b
-00000110b ^ 01100111b = 01100001b
-00000110b ^ 01101000b = 01101110b
-00000110b ^ 01101001b = 01101111b
-00000110b ^ 01101010b = 01101100b
-00000110b ^ 01101011b = 01101101b
-00000110b ^ 01101100b = 01101010b
-00000110b ^ 01101101b = 01101011b
-00000110b ^ 01101110b = 01101000b
-00000110b ^ 01101111b = 01101001b
-00000110b ^ 01110000b = 01110110b
-00000110b ^ 01110001b = 01110111b
-00000110b ^ 01110010b = 01110100b
-00000110b ^ 01110011b = 01110101b
-00000110b ^ 01110100b = 01110010b
-00000110b ^ 01110101b = 01110011b
-00000110b ^ 01110110b = 01110000b
-00000110b ^ 01110111b = 01110001b
-00000110b ^ 01111000b = 01111110b
-00000110b ^ 01111001b = 01111111b
-00000110b ^ 01111010b = 01111100b
-00000110b ^ 01111011b = 01111101b
-00000110b ^ 01111100b = 01111010b
-00000110b ^ 01111101b = 01111011b
-00000110b ^ 01111110b = 01111000b
-00000111b ^ 10000000b = 10000111b
-00000111b ^ 10000001b = 10000110b
-00000111b ^ 10000010b = 10000101b
-00000111b ^ 10000011b = 10000100b
-00000111b ^ 10000100b = 10000011b
-00000111b ^ 10000101b = 10000010b
-00000111b ^ 10000110b = 10000001b
-00000111b ^ 10000111b = 10000000b
-00000111b ^ 10001000b = 10001111b
-00000111b ^ 10001001b = 10001110b
-00000111b ^ 10001010b = 10001101b
-00000111b ^ 10001011b = 10001100b
-00000111b ^ 10001100b = 10001011b
-00000111b ^ 10001101b = 10001010b
-00000111b ^ 10001110b = 10001001b
-00000111b ^ 10001111b = 10001000b
-00000111b ^ 10010000b = 10010111b
-00000111b ^ 10010001b = 10010110b
-00000111b ^ 10010010b = 10010101b
-00000111b ^ 10010011b = 10010100b
-00000111b ^ 10010100b = 10010011b
-00000111b ^ 10010101b = 10010010b
-00000111b ^ 10010110b = 10010001b
-00000111b ^ 10010111b = 10010000b
-00000111b ^ 10011000b = 10011111b
-00000111b ^ 10011001b = 10011110b
-00000111b ^ 10011010b = 10011101b
-00000111b ^ 10011011b = 10011100b
-00000111b ^ 10011100b = 10011011b
-00000111b ^ 10011101b = 10011010b
-00000111b ^ 10011110b = 10011001b
-00000111b ^ 10011111b = 10011000b
-00000111b ^ 10100000b = 10100111b
-00000111b ^ 10100001b = 10100110b
-00000111b ^ 10100010b = 10100101b
-00000111b ^ 10100011b = 10100100b
-00000111b ^ 10100100b = 10100011b
-00000111b ^ 10100101b = 10100010b
-00000111b ^ 10100110b = 10100001b
-00000111b ^ 10100111b = 10100000b
-00000111b ^ 10101000b = 10101111b
-00000111b ^ 10101001b = 10101110b
-00000111b ^ 10101010b = 10101101b
-00000111b ^ 10101011b = 10101100b
-00000111b ^ 10101100b = 10101011b
-00000111b ^ 10101101b = 10101010b
-00000111b ^ 10101110b = 10101001b
-00000111b ^ 10101111b = 10101000b
-00000111b ^ 10110000b = 10110111b
-00000111b ^ 10110001b = 10110110b
-00000111b ^ 10110010b = 10110101b
-00000111b ^ 10110011b = 10110100b
-00000111b ^ 10110100b = 10110011b
-00000111b ^ 10110101b = 10110010b
-00000111b ^ 10110110b = 10110001b
-00000111b ^ 10110111b = 10110000b
-00000111b ^ 10111000b = 10111111b
-00000111b ^ 10111001b = 10111110b
-00000111b ^ 10111010b = 10111101b
-00000111b ^ 10111011b = 10111100b
-00000111b ^ 10111100b = 10111011b
-00000111b ^ 10111101b = 10111010b
-00000111b ^ 10111110b = 10111001b
-00000111b ^ 10111111b = 10111000b
-00000111b ^ 11000000b = 11000111b
-00000111b ^ 11000001b = 11000110b
-00000111b ^ 11000010b = 11000101b
-00000111b ^ 11000011b = 11000100b
-00000111b ^ 11000100b = 11000011b
-00000111b ^ 11000101b = 11000010b
-00000111b ^ 11000110b = 11000001b
-00000111b ^ 11000111b = 11000000b
-00000111b ^ 11001000b = 11001111b
-00000111b ^ 11001001b = 11001110b
-00000111b ^ 11001010b = 11001101b
-00000111b ^ 11001011b = 11001100b
-00000111b ^ 11001100b = 11001011b
-00000111b ^ 11001101b = 11001010b
-00000111b ^ 11001110b = 11001001b
-00000111b ^ 11001111b = 11001000b
-00000111b ^ 11010000b = 11010111b
-00000111b ^ 11010001b = 11010110b
-00000111b ^ 11010010b = 11010101b
-00000111b ^ 11010011b = 11010100b
-00000111b ^ 11010100b = 11010011b
-00000111b ^ 11010101b = 11010010b
-00000111b ^ 11010110b = 11010001b
-00000111b ^ 11010111b = 11010000b
-00000111b ^ 11011000b = 11011111b
-00000111b ^ 11011001b = 11011110b
-00000111b ^ 11011010b = 11011101b
-00000111b ^ 11011011b = 11011100b
-00000111b ^ 11011100b = 11011011b
-00000111b ^ 11011101b = 11011010b
-00000111b ^ 11011110b = 11011001b
-00000111b ^ 11011111b = 11011000b
-00000111b ^ 11100000b = 11100111b
-00000111b ^ 11100001b = 11100110b
-00000111b ^ 11100010b = 11100101b
-00000111b ^ 11100011b = 11100100b
-00000111b ^ 11100100b = 11100011b
-00000111b ^ 11100101b = 11100010b
-00000111b ^ 11100110b = 11100001b
-00000111b ^ 11100111b = 11100000b
-00000111b ^ 11101000b = 11101111b
-00000111b ^ 11101001b = 11101110b
-00000111b ^ 11101010b = 11101101b
-00000111b ^ 11101011b = 11101100b
-00000111b ^ 11101100b = 11101011b
-00000111b ^ 11101101b = 11101010b
-00000111b ^ 11101110b = 11101001b
-00000111b ^ 11101111b = 11101000b
-00000111b ^ 11110000b = 11110111b
-00000111b ^ 11110001b = 11110110b
-00000111b ^ 11110010b = 11110101b
-00000111b ^ 11110011b = 11110100b
-00000111b ^ 11110100b = 11110011b
-00000111b ^ 11110101b = 11110010b
-00000111b ^ 11110110b = 11110001b
-00000111b ^ 11110111b = 11110000b
-00000111b ^ 11111000b = 11111111b
-00000111b ^ 11111001b = 11111110b
-00000111b ^ 11111010b = 11111101b
-00000111b ^ 11111011b = 11111100b
-00000111b ^ 11111100b = 11111011b
-00000111b ^ 11111101b = 11111010b
-00000111b ^ 11111110b = 11111001b
-00000111b ^ 11111111b = 11111000b
-00000111b ^ 00000000b = 00000111b
-00000111b ^ 00000001b = 00000110b
-00000111b ^ 00000010b = 00000101b
-00000111b ^ 00000011b = 00000100b
-00000111b ^ 00000100b = 00000011b
-00000111b ^ 00000101b = 00000010b
-00000111b ^ 00000110b = 00000001b
-00000111b ^ 00000111b = 00000000b
-00000111b ^ 00001000b = 00001111b
-00000111b ^ 00001001b = 00001110b
-00000111b ^ 00001010b = 00001101b
-00000111b ^ 00001011b = 00001100b
-00000111b ^ 00001100b = 00001011b
-00000111b ^ 00001101b = 00001010b
-00000111b ^ 00001110b = 00001001b
-00000111b ^ 00001111b = 00001000b
-00000111b ^ 00010000b = 00010111b
-00000111b ^ 00010001b = 00010110b
-00000111b ^ 00010010b = 00010101b
-00000111b ^ 00010011b = 00010100b
-00000111b ^ 00010100b = 00010011b
-00000111b ^ 00010101b = 00010010b
-00000111b ^ 00010110b = 00010001b
-00000111b ^ 00010111b = 00010000b
-00000111b ^ 00011000b = 00011111b
-00000111b ^ 00011001b = 00011110b
-00000111b ^ 00011010b = 00011101b
-00000111b ^ 00011011b = 00011100b
-00000111b ^ 00011100b = 00011011b
-00000111b ^ 00011101b = 00011010b
-00000111b ^ 00011110b = 00011001b
-00000111b ^ 00011111b = 00011000b
-00000111b ^ 00100000b = 00100111b
-00000111b ^ 00100001b = 00100110b
-00000111b ^ 00100010b = 00100101b
-00000111b ^ 00100011b = 00100100b
-00000111b ^ 00100100b = 00100011b
-00000111b ^ 00100101b = 00100010b
-00000111b ^ 00100110b = 00100001b
-00000111b ^ 00100111b = 00100000b
-00000111b ^ 00101000b = 00101111b
-00000111b ^ 00101001b = 00101110b
-00000111b ^ 00101010b = 00101101b
-00000111b ^ 00101011b = 00101100b
-00000111b ^ 00101100b = 00101011b
-00000111b ^ 00101101b = 00101010b
-00000111b ^ 00101110b = 00101001b
-00000111b ^ 00101111b = 00101000b
-00000111b ^ 00110000b = 00110111b
-00000111b ^ 00110001b = 00110110b
-00000111b ^ 00110010b = 00110101b
-00000111b ^ 00110011b = 00110100b
-00000111b ^ 00110100b = 00110011b
-00000111b ^ 00110101b = 00110010b
-00000111b ^ 00110110b = 00110001b
-00000111b ^ 00110111b = 00110000b
-00000111b ^ 00111000b = 00111111b
-00000111b ^ 00111001b = 00111110b
-00000111b ^ 00111010b = 00111101b
-00000111b ^ 00111011b = 00111100b
-00000111b ^ 00111100b = 00111011b
-00000111b ^ 00111101b = 00111010b
-00000111b ^ 00111110b = 00111001b
-00000111b ^ 00111111b = 00111000b
-00000111b ^ 01000000b = 01000111b
-00000111b ^ 01000001b = 01000110b
-00000111b ^ 01000010b = 01000101b
-00000111b ^ 01000011b = 01000100b
-00000111b ^ 01000100b = 01000011b
-00000111b ^ 01000101b = 01000010b
-00000111b ^ 01000110b = 01000001b
-00000111b ^ 01000111b = 01000000b
-00000111b ^ 01001000b = 01001111b
-00000111b ^ 01001001b = 01001110b
-00000111b ^ 01001010b = 01001101b
-00000111b ^ 01001011b = 01001100b
-00000111b ^ 01001100b = 01001011b
-00000111b ^ 01001101b = 01001010b
-00000111b ^ 01001110b = 01001001b
-00000111b ^ 01001111b = 01001000b
-00000111b ^ 01010000b = 01010111b
-00000111b ^ 01010001b = 01010110b
-00000111b ^ 01010010b = 01010101b
-00000111b ^ 01010011b = 01010100b
-00000111b ^ 01010100b = 01010011b
-00000111b ^ 01010101b = 01010010b
-00000111b ^ 01010110b = 01010001b
-00000111b ^ 01010111b = 01010000b
-00000111b ^ 01011000b = 01011111b
-00000111b ^ 01011001b = 01011110b
-00000111b ^ 01011010b = 01011101b
-00000111b ^ 01011011b = 01011100b
-00000111b ^ 01011100b = 01011011b
-00000111b ^ 01011101b = 01011010b
-00000111b ^ 01011110b = 01011001b
-00000111b ^ 01011111b = 01011000b
-00000111b ^ 01100000b = 01100111b
-00000111b ^ 01100001b = 01100110b
-00000111b ^ 01100010b = 01100101b
-00000111b ^ 01100011b = 01100100b
-00000111b ^ 01100100b = 01100011b
-00000111b ^ 01100101b = 01100010b
-00000111b ^ 01100110b = 01100001b
-00000111b ^ 01100111b = 01100000b
-00000111b ^ 01101000b = 01101111b
-00000111b ^ 01101001b = 01101110b
-00000111b ^ 01101010b = 01101101b
-00000111b ^ 01101011b = 01101100b
-00000111b ^ 01101100b = 01101011b
-00000111b ^ 01101101b = 01101010b
-00000111b ^ 01101110b = 01101001b
-00000111b ^ 01101111b = 01101000b
-00000111b ^ 01110000b = 01110111b
-00000111b ^ 01110001b = 01110110b
-00000111b ^ 01110010b = 01110101b
-00000111b ^ 01110011b = 01110100b
-00000111b ^ 01110100b = 01110011b
-00000111b ^ 01110101b = 01110010b
-00000111b ^ 01110110b = 01110001b
-00000111b ^ 01110111b = 01110000b
-00000111b ^ 01111000b = 01111111b
-00000111b ^ 01111001b = 01111110b
-00000111b ^ 01111010b = 01111101b
-00000111b ^ 01111011b = 01111100b
-00000111b ^ 01111100b = 01111011b
-00000111b ^ 01111101b = 01111010b
-00000111b ^ 01111110b = 01111001b
-00001000b ^ 10000000b = 10001000b
-00001000b ^ 10000001b = 10001001b
-00001000b ^ 10000010b = 10001010b
-00001000b ^ 10000011b = 10001011b
-00001000b ^ 10000100b = 10001100b
-00001000b ^ 10000101b = 10001101b
-00001000b ^ 10000110b = 10001110b
-00001000b ^ 10000111b = 10001111b
-00001000b ^ 10001000b = 10000000b
-00001000b ^ 10001001b = 10000001b
-00001000b ^ 10001010b = 10000010b
-00001000b ^ 10001011b = 10000011b
-00001000b ^ 10001100b = 10000100b
-00001000b ^ 10001101b = 10000101b
-00001000b ^ 10001110b = 10000110b
-00001000b ^ 10001111b = 10000111b
-00001000b ^ 10010000b = 10011000b
-00001000b ^ 10010001b = 10011001b
-00001000b ^ 10010010b = 10011010b
-00001000b ^ 10010011b = 10011011b
-00001000b ^ 10010100b = 10011100b
-00001000b ^ 10010101b = 10011101b
-00001000b ^ 10010110b = 10011110b
-00001000b ^ 10010111b = 10011111b
-00001000b ^ 10011000b = 10010000b
-00001000b ^ 10011001b = 10010001b
-00001000b ^ 10011010b = 10010010b
-00001000b ^ 10011011b = 10010011b
-00001000b ^ 10011100b = 10010100b
-00001000b ^ 10011101b = 10010101b
-00001000b ^ 10011110b = 10010110b
-00001000b ^ 10011111b = 10010111b
-00001000b ^ 10100000b = 10101000b
-00001000b ^ 10100001b = 10101001b
-00001000b ^ 10100010b = 10101010b
-00001000b ^ 10100011b = 10101011b
-00001000b ^ 10100100b = 10101100b
-00001000b ^ 10100101b = 10101101b
-00001000b ^ 10100110b = 10101110b
-00001000b ^ 10100111b = 10101111b
-00001000b ^ 10101000b = 10100000b
-00001000b ^ 10101001b = 10100001b
-00001000b ^ 10101010b = 10100010b
-00001000b ^ 10101011b = 10100011b
-00001000b ^ 10101100b = 10100100b
-00001000b ^ 10101101b = 10100101b
-00001000b ^ 10101110b = 10100110b
-00001000b ^ 10101111b = 10100111b
-00001000b ^ 10110000b = 10111000b
-00001000b ^ 10110001b = 10111001b
-00001000b ^ 10110010b = 10111010b
-00001000b ^ 10110011b = 10111011b
-00001000b ^ 10110100b = 10111100b
-00001000b ^ 10110101b = 10111101b
-00001000b ^ 10110110b = 10111110b
-00001000b ^ 10110111b = 10111111b
-00001000b ^ 10111000b = 10110000b
-00001000b ^ 10111001b = 10110001b
-00001000b ^ 10111010b = 10110010b
-00001000b ^ 10111011b = 10110011b
-00001000b ^ 10111100b = 10110100b
-00001000b ^ 10111101b = 10110101b
-00001000b ^ 10111110b = 10110110b
-00001000b ^ 10111111b = 10110111b
-00001000b ^ 11000000b = 11001000b
-00001000b ^ 11000001b = 11001001b
-00001000b ^ 11000010b = 11001010b
-00001000b ^ 11000011b = 11001011b
-00001000b ^ 11000100b = 11001100b
-00001000b ^ 11000101b = 11001101b
-00001000b ^ 11000110b = 11001110b
-00001000b ^ 11000111b = 11001111b
-00001000b ^ 11001000b = 11000000b
-00001000b ^ 11001001b = 11000001b
-00001000b ^ 11001010b = 11000010b
-00001000b ^ 11001011b = 11000011b
-00001000b ^ 11001100b = 11000100b
-00001000b ^ 11001101b = 11000101b
-00001000b ^ 11001110b = 11000110b
-00001000b ^ 11001111b = 11000111b
-00001000b ^ 11010000b = 11011000b
-00001000b ^ 11010001b = 11011001b
-00001000b ^ 11010010b = 11011010b
-00001000b ^ 11010011b = 11011011b
-00001000b ^ 11010100b = 11011100b
-00001000b ^ 11010101b = 11011101b
-00001000b ^ 11010110b = 11011110b
-00001000b ^ 11010111b = 11011111b
-00001000b ^ 11011000b = 11010000b
-00001000b ^ 11011001b = 11010001b
-00001000b ^ 11011010b = 11010010b
-00001000b ^ 11011011b = 11010011b
-00001000b ^ 11011100b = 11010100b
-00001000b ^ 11011101b = 11010101b
-00001000b ^ 11011110b = 11010110b
-00001000b ^ 11011111b = 11010111b
-00001000b ^ 11100000b = 11101000b
-00001000b ^ 11100001b = 11101001b
-00001000b ^ 11100010b = 11101010b
-00001000b ^ 11100011b = 11101011b
-00001000b ^ 11100100b = 11101100b
-00001000b ^ 11100101b = 11101101b
-00001000b ^ 11100110b = 11101110b
-00001000b ^ 11100111b = 11101111b
-00001000b ^ 11101000b = 11100000b
-00001000b ^ 11101001b = 11100001b
-00001000b ^ 11101010b = 11100010b
-00001000b ^ 11101011b = 11100011b
-00001000b ^ 11101100b = 11100100b
-00001000b ^ 11101101b = 11100101b
-00001000b ^ 11101110b = 11100110b
-00001000b ^ 11101111b = 11100111b
-00001000b ^ 11110000b = 11111000b
-00001000b ^ 11110001b = 11111001b
-00001000b ^ 11110010b = 11111010b
-00001000b ^ 11110011b = 11111011b
-00001000b ^ 11110100b = 11111100b
-00001000b ^ 11110101b = 11111101b
-00001000b ^ 11110110b = 11111110b
-00001000b ^ 11110111b = 11111111b
-00001000b ^ 11111000b = 11110000b
-00001000b ^ 11111001b = 11110001b
-00001000b ^ 11111010b = 11110010b
-00001000b ^ 11111011b = 11110011b
-00001000b ^ 11111100b = 11110100b
-00001000b ^ 11111101b = 11110101b
-00001000b ^ 11111110b = 11110110b
-00001000b ^ 11111111b = 11110111b
-00001000b ^ 00000000b = 00001000b
-00001000b ^ 00000001b = 00001001b
-00001000b ^ 00000010b = 00001010b
-00001000b ^ 00000011b = 00001011b
-00001000b ^ 00000100b = 00001100b
-00001000b ^ 00000101b = 00001101b
-00001000b ^ 00000110b = 00001110b
-00001000b ^ 00000111b = 00001111b
-00001000b ^ 00001000b = 00000000b
-00001000b ^ 00001001b = 00000001b
-00001000b ^ 00001010b = 00000010b
-00001000b ^ 00001011b = 00000011b
-00001000b ^ 00001100b = 00000100b
-00001000b ^ 00001101b = 00000101b
-00001000b ^ 00001110b = 00000110b
-00001000b ^ 00001111b = 00000111b
-00001000b ^ 00010000b = 00011000b
-00001000b ^ 00010001b = 00011001b
-00001000b ^ 00010010b = 00011010b
-00001000b ^ 00010011b = 00011011b
-00001000b ^ 00010100b = 00011100b
-00001000b ^ 00010101b = 00011101b
-00001000b ^ 00010110b = 00011110b
-00001000b ^ 00010111b = 00011111b
-00001000b ^ 00011000b = 00010000b
-00001000b ^ 00011001b = 00010001b
-00001000b ^ 00011010b = 00010010b
-00001000b ^ 00011011b = 00010011b
-00001000b ^ 00011100b = 00010100b
-00001000b ^ 00011101b = 00010101b
-00001000b ^ 00011110b = 00010110b
-00001000b ^ 00011111b = 00010111b
-00001000b ^ 00100000b = 00101000b
-00001000b ^ 00100001b = 00101001b
-00001000b ^ 00100010b = 00101010b
-00001000b ^ 00100011b = 00101011b
-00001000b ^ 00100100b = 00101100b
-00001000b ^ 00100101b = 00101101b
-00001000b ^ 00100110b = 00101110b
-00001000b ^ 00100111b = 00101111b
-00001000b ^ 00101000b = 00100000b
-00001000b ^ 00101001b = 00100001b
-00001000b ^ 00101010b = 00100010b
-00001000b ^ 00101011b = 00100011b
-00001000b ^ 00101100b = 00100100b
-00001000b ^ 00101101b = 00100101b
-00001000b ^ 00101110b = 00100110b
-00001000b ^ 00101111b = 00100111b
-00001000b ^ 00110000b = 00111000b
-00001000b ^ 00110001b = 00111001b
-00001000b ^ 00110010b = 00111010b
-00001000b ^ 00110011b = 00111011b
-00001000b ^ 00110100b = 00111100b
-00001000b ^ 00110101b = 00111101b
-00001000b ^ 00110110b = 00111110b
-00001000b ^ 00110111b = 00111111b
-00001000b ^ 00111000b = 00110000b
-00001000b ^ 00111001b = 00110001b
-00001000b ^ 00111010b = 00110010b
-00001000b ^ 00111011b = 00110011b
-00001000b ^ 00111100b = 00110100b
-00001000b ^ 00111101b = 00110101b
-00001000b ^ 00111110b = 00110110b
-00001000b ^ 00111111b = 00110111b
-00001000b ^ 01000000b = 01001000b
-00001000b ^ 01000001b = 01001001b
-00001000b ^ 01000010b = 01001010b
-00001000b ^ 01000011b = 01001011b
-00001000b ^ 01000100b = 01001100b
-00001000b ^ 01000101b = 01001101b
-00001000b ^ 01000110b = 01001110b
-00001000b ^ 01000111b = 01001111b
-00001000b ^ 01001000b = 01000000b
-00001000b ^ 01001001b = 01000001b
-00001000b ^ 01001010b = 01000010b
-00001000b ^ 01001011b = 01000011b
-00001000b ^ 01001100b = 01000100b
-00001000b ^ 01001101b = 01000101b
-00001000b ^ 01001110b = 01000110b
-00001000b ^ 01001111b = 01000111b
-00001000b ^ 01010000b = 01011000b
-00001000b ^ 01010001b = 01011001b
-00001000b ^ 01010010b = 01011010b
-00001000b ^ 01010011b = 01011011b
-00001000b ^ 01010100b = 01011100b
-00001000b ^ 01010101b = 01011101b
-00001000b ^ 01010110b = 01011110b
-00001000b ^ 01010111b = 01011111b
-00001000b ^ 01011000b = 01010000b
-00001000b ^ 01011001b = 01010001b
-00001000b ^ 01011010b = 01010010b
-00001000b ^ 01011011b = 01010011b
-00001000b ^ 01011100b = 01010100b
-00001000b ^ 01011101b = 01010101b
-00001000b ^ 01011110b = 01010110b
-00001000b ^ 01011111b = 01010111b
-00001000b ^ 01100000b = 01101000b
-00001000b ^ 01100001b = 01101001b
-00001000b ^ 01100010b = 01101010b
-00001000b ^ 01100011b = 01101011b
-00001000b ^ 01100100b = 01101100b
-00001000b ^ 01100101b = 01101101b
-00001000b ^ 01100110b = 01101110b
-00001000b ^ 01100111b = 01101111b
-00001000b ^ 01101000b = 01100000b
-00001000b ^ 01101001b = 01100001b
-00001000b ^ 01101010b = 01100010b
-00001000b ^ 01101011b = 01100011b
-00001000b ^ 01101100b = 01100100b
-00001000b ^ 01101101b = 01100101b
-00001000b ^ 01101110b = 01100110b
-00001000b ^ 01101111b = 01100111b
-00001000b ^ 01110000b = 01111000b
-00001000b ^ 01110001b = 01111001b
-00001000b ^ 01110010b = 01111010b
-00001000b ^ 01110011b = 01111011b
-00001000b ^ 01110100b = 01111100b
-00001000b ^ 01110101b = 01111101b
-00001000b ^ 01110110b = 01111110b
-00001000b ^ 01110111b = 01111111b
-00001000b ^ 01111000b = 01110000b
-00001000b ^ 01111001b = 01110001b
-00001000b ^ 01111010b = 01110010b
-00001000b ^ 01111011b = 01110011b
-00001000b ^ 01111100b = 01110100b
-00001000b ^ 01111101b = 01110101b
-00001000b ^ 01111110b = 01110110b
-00001001b ^ 10000000b = 10001001b
-00001001b ^ 10000001b = 10001000b
-00001001b ^ 10000010b = 10001011b
-00001001b ^ 10000011b = 10001010b
-00001001b ^ 10000100b = 10001101b
-00001001b ^ 10000101b = 10001100b
-00001001b ^ 10000110b = 10001111b
-00001001b ^ 10000111b = 10001110b
-00001001b ^ 10001000b = 10000001b
-00001001b ^ 10001001b = 10000000b
-00001001b ^ 10001010b = 10000011b
-00001001b ^ 10001011b = 10000010b
-00001001b ^ 10001100b = 10000101b
-00001001b ^ 10001101b = 10000100b
-00001001b ^ 10001110b = 10000111b
-00001001b ^ 10001111b = 10000110b
-00001001b ^ 10010000b = 10011001b
-00001001b ^ 10010001b = 10011000b
-00001001b ^ 10010010b = 10011011b
-00001001b ^ 10010011b = 10011010b
-00001001b ^ 10010100b = 10011101b
-00001001b ^ 10010101b = 10011100b
-00001001b ^ 10010110b = 10011111b
-00001001b ^ 10010111b = 10011110b
-00001001b ^ 10011000b = 10010001b
-00001001b ^ 10011001b = 10010000b
-00001001b ^ 10011010b = 10010011b
-00001001b ^ 10011011b = 10010010b
-00001001b ^ 10011100b = 10010101b
-00001001b ^ 10011101b = 10010100b
-00001001b ^ 10011110b = 10010111b
-00001001b ^ 10011111b = 10010110b
-00001001b ^ 10100000b = 10101001b
-00001001b ^ 10100001b = 10101000b
-00001001b ^ 10100010b = 10101011b
-00001001b ^ 10100011b = 10101010b
-00001001b ^ 10100100b = 10101101b
-00001001b ^ 10100101b = 10101100b
-00001001b ^ 10100110b = 10101111b
-00001001b ^ 10100111b = 10101110b
-00001001b ^ 10101000b = 10100001b
-00001001b ^ 10101001b = 10100000b
-00001001b ^ 10101010b = 10100011b
-00001001b ^ 10101011b = 10100010b
-00001001b ^ 10101100b = 10100101b
-00001001b ^ 10101101b = 10100100b
-00001001b ^ 10101110b = 10100111b
-00001001b ^ 10101111b = 10100110b
-00001001b ^ 10110000b = 10111001b
-00001001b ^ 10110001b = 10111000b
-00001001b ^ 10110010b = 10111011b
-00001001b ^ 10110011b = 10111010b
-00001001b ^ 10110100b = 10111101b
-00001001b ^ 10110101b = 10111100b
-00001001b ^ 10110110b = 10111111b
-00001001b ^ 10110111b = 10111110b
-00001001b ^ 10111000b = 10110001b
-00001001b ^ 10111001b = 10110000b
-00001001b ^ 10111010b = 10110011b
-00001001b ^ 10111011b = 10110010b
-00001001b ^ 10111100b = 10110101b
-00001001b ^ 10111101b = 10110100b
-00001001b ^ 10111110b = 10110111b
-00001001b ^ 10111111b = 10110110b
-00001001b ^ 11000000b = 11001001b
-00001001b ^ 11000001b = 11001000b
-00001001b ^ 11000010b = 11001011b
-00001001b ^ 11000011b = 11001010b
-00001001b ^ 11000100b = 11001101b
-00001001b ^ 11000101b = 11001100b
-00001001b ^ 11000110b = 11001111b
-00001001b ^ 11000111b = 11001110b
-00001001b ^ 11001000b = 11000001b
-00001001b ^ 11001001b = 11000000b
-00001001b ^ 11001010b = 11000011b
-00001001b ^ 11001011b = 11000010b
-00001001b ^ 11001100b = 11000101b
-00001001b ^ 11001101b = 11000100b
-00001001b ^ 11001110b = 11000111b
-00001001b ^ 11001111b = 11000110b
-00001001b ^ 11010000b = 11011001b
-00001001b ^ 11010001b = 11011000b
-00001001b ^ 11010010b = 11011011b
-00001001b ^ 11010011b = 11011010b
-00001001b ^ 11010100b = 11011101b
-00001001b ^ 11010101b = 11011100b
-00001001b ^ 11010110b = 11011111b
-00001001b ^ 11010111b = 11011110b
-00001001b ^ 11011000b = 11010001b
-00001001b ^ 11011001b = 11010000b
-00001001b ^ 11011010b = 11010011b
-00001001b ^ 11011011b = 11010010b
-00001001b ^ 11011100b = 11010101b
-00001001b ^ 11011101b = 11010100b
-00001001b ^ 11011110b = 11010111b
-00001001b ^ 11011111b = 11010110b
-00001001b ^ 11100000b = 11101001b
-00001001b ^ 11100001b = 11101000b
-00001001b ^ 11100010b = 11101011b
-00001001b ^ 11100011b = 11101010b
-00001001b ^ 11100100b = 11101101b
-00001001b ^ 11100101b = 11101100b
-00001001b ^ 11100110b = 11101111b
-00001001b ^ 11100111b = 11101110b
-00001001b ^ 11101000b = 11100001b
-00001001b ^ 11101001b = 11100000b
-00001001b ^ 11101010b = 11100011b
-00001001b ^ 11101011b = 11100010b
-00001001b ^ 11101100b = 11100101b
-00001001b ^ 11101101b = 11100100b
-00001001b ^ 11101110b = 11100111b
-00001001b ^ 11101111b = 11100110b
-00001001b ^ 11110000b = 11111001b
-00001001b ^ 11110001b = 11111000b
-00001001b ^ 11110010b = 11111011b
-00001001b ^ 11110011b = 11111010b
-00001001b ^ 11110100b = 11111101b
-00001001b ^ 11110101b = 11111100b
-00001001b ^ 11110110b = 11111111b
-00001001b ^ 11110111b = 11111110b
-00001001b ^ 11111000b = 11110001b
-00001001b ^ 11111001b = 11110000b
-00001001b ^ 11111010b = 11110011b
-00001001b ^ 11111011b = 11110010b
-00001001b ^ 11111100b = 11110101b
-00001001b ^ 11111101b = 11110100b
-00001001b ^ 11111110b = 11110111b
-00001001b ^ 11111111b = 11110110b
-00001001b ^ 00000000b = 00001001b
-00001001b ^ 00000001b = 00001000b
-00001001b ^ 00000010b = 00001011b
-00001001b ^ 00000011b = 00001010b
-00001001b ^ 00000100b = 00001101b
-00001001b ^ 00000101b = 00001100b
-00001001b ^ 00000110b = 00001111b
-00001001b ^ 00000111b = 00001110b
-00001001b ^ 00001000b = 00000001b
-00001001b ^ 00001001b = 00000000b
-00001001b ^ 00001010b = 00000011b
-00001001b ^ 00001011b = 00000010b
-00001001b ^ 00001100b = 00000101b
-00001001b ^ 00001101b = 00000100b
-00001001b ^ 00001110b = 00000111b
-00001001b ^ 00001111b = 00000110b
-00001001b ^ 00010000b = 00011001b
-00001001b ^ 00010001b = 00011000b
-00001001b ^ 00010010b = 00011011b
-00001001b ^ 00010011b = 00011010b
-00001001b ^ 00010100b = 00011101b
-00001001b ^ 00010101b = 00011100b
-00001001b ^ 00010110b = 00011111b
-00001001b ^ 00010111b = 00011110b
-00001001b ^ 00011000b = 00010001b
-00001001b ^ 00011001b = 00010000b
-00001001b ^ 00011010b = 00010011b
-00001001b ^ 00011011b = 00010010b
-00001001b ^ 00011100b = 00010101b
-00001001b ^ 00011101b = 00010100b
-00001001b ^ 00011110b = 00010111b
-00001001b ^ 00011111b = 00010110b
-00001001b ^ 00100000b = 00101001b
-00001001b ^ 00100001b = 00101000b
-00001001b ^ 00100010b = 00101011b
-00001001b ^ 00100011b = 00101010b
-00001001b ^ 00100100b = 00101101b
-00001001b ^ 00100101b = 00101100b
-00001001b ^ 00100110b = 00101111b
-00001001b ^ 00100111b = 00101110b
-00001001b ^ 00101000b = 00100001b
-00001001b ^ 00101001b = 00100000b
-00001001b ^ 00101010b = 00100011b
-00001001b ^ 00101011b = 00100010b
-00001001b ^ 00101100b = 00100101b
-00001001b ^ 00101101b = 00100100b
-00001001b ^ 00101110b = 00100111b
-00001001b ^ 00101111b = 00100110b
-00001001b ^ 00110000b = 00111001b
-00001001b ^ 00110001b = 00111000b
-00001001b ^ 00110010b = 00111011b
-00001001b ^ 00110011b = 00111010b
-00001001b ^ 00110100b = 00111101b
-00001001b ^ 00110101b = 00111100b
-00001001b ^ 00110110b = 00111111b
-00001001b ^ 00110111b = 00111110b
-00001001b ^ 00111000b = 00110001b
-00001001b ^ 00111001b = 00110000b
-00001001b ^ 00111010b = 00110011b
-00001001b ^ 00111011b = 00110010b
-00001001b ^ 00111100b = 00110101b
-00001001b ^ 00111101b = 00110100b
-00001001b ^ 00111110b = 00110111b
-00001001b ^ 00111111b = 00110110b
-00001001b ^ 01000000b = 01001001b
-00001001b ^ 01000001b = 01001000b
-00001001b ^ 01000010b = 01001011b
-00001001b ^ 01000011b = 01001010b
-00001001b ^ 01000100b = 01001101b
-00001001b ^ 01000101b = 01001100b
-00001001b ^ 01000110b = 01001111b
-00001001b ^ 01000111b = 01001110b
-00001001b ^ 01001000b = 01000001b
-00001001b ^ 01001001b = 01000000b
-00001001b ^ 01001010b = 01000011b
-00001001b ^ 01001011b = 01000010b
-00001001b ^ 01001100b = 01000101b
-00001001b ^ 01001101b = 01000100b
-00001001b ^ 01001110b = 01000111b
-00001001b ^ 01001111b = 01000110b
-00001001b ^ 01010000b = 01011001b
-00001001b ^ 01010001b = 01011000b
-00001001b ^ 01010010b = 01011011b
-00001001b ^ 01010011b = 01011010b
-00001001b ^ 01010100b = 01011101b
-00001001b ^ 01010101b = 01011100b
-00001001b ^ 01010110b = 01011111b
-00001001b ^ 01010111b = 01011110b
-00001001b ^ 01011000b = 01010001b
-00001001b ^ 01011001b = 01010000b
-00001001b ^ 01011010b = 01010011b
-00001001b ^ 01011011b = 01010010b
-00001001b ^ 01011100b = 01010101b
-00001001b ^ 01011101b = 01010100b
-00001001b ^ 01011110b = 01010111b
-00001001b ^ 01011111b = 01010110b
-00001001b ^ 01100000b = 01101001b
-00001001b ^ 01100001b = 01101000b
-00001001b ^ 01100010b = 01101011b
-00001001b ^ 01100011b = 01101010b
-00001001b ^ 01100100b = 01101101b
-00001001b ^ 01100101b = 01101100b
-00001001b ^ 01100110b = 01101111b
-00001001b ^ 01100111b = 01101110b
-00001001b ^ 01101000b = 01100001b
-00001001b ^ 01101001b = 01100000b
-00001001b ^ 01101010b = 01100011b
-00001001b ^ 01101011b = 01100010b
-00001001b ^ 01101100b = 01100101b
-00001001b ^ 01101101b = 01100100b
-00001001b ^ 01101110b = 01100111b
-00001001b ^ 01101111b = 01100110b
-00001001b ^ 01110000b = 01111001b
-00001001b ^ 01110001b = 01111000b
-00001001b ^ 01110010b = 01111011b
-00001001b ^ 01110011b = 01111010b
-00001001b ^ 01110100b = 01111101b
-00001001b ^ 01110101b = 01111100b
-00001001b ^ 01110110b = 01111111b
-00001001b ^ 01110111b = 01111110b
-00001001b ^ 01111000b = 01110001b
-00001001b ^ 01111001b = 01110000b
-00001001b ^ 01111010b = 01110011b
-00001001b ^ 01111011b = 01110010b
-00001001b ^ 01111100b = 01110101b
-00001001b ^ 01111101b = 01110100b
-00001001b ^ 01111110b = 01110111b
-00001010b ^ 10000000b = 10001010b
-00001010b ^ 10000001b = 10001011b
-00001010b ^ 10000010b = 10001000b
-00001010b ^ 10000011b = 10001001b
-00001010b ^ 10000100b = 10001110b
-00001010b ^ 10000101b = 10001111b
-00001010b ^ 10000110b = 10001100b
-00001010b ^ 10000111b = 10001101b
-00001010b ^ 10001000b = 10000010b
-00001010b ^ 10001001b = 10000011b
-00001010b ^ 10001010b = 10000000b
-00001010b ^ 10001011b = 10000001b
-00001010b ^ 10001100b = 10000110b
-00001010b ^ 10001101b = 10000111b
-00001010b ^ 10001110b = 10000100b
-00001010b ^ 10001111b = 10000101b
-00001010b ^ 10010000b = 10011010b
-00001010b ^ 10010001b = 10011011b
-00001010b ^ 10010010b = 10011000b
-00001010b ^ 10010011b = 10011001b
-00001010b ^ 10010100b = 10011110b
-00001010b ^ 10010101b = 10011111b
-00001010b ^ 10010110b = 10011100b
-00001010b ^ 10010111b = 10011101b
-00001010b ^ 10011000b = 10010010b
-00001010b ^ 10011001b = 10010011b
-00001010b ^ 10011010b = 10010000b
-00001010b ^ 10011011b = 10010001b
-00001010b ^ 10011100b = 10010110b
-00001010b ^ 10011101b = 10010111b
-00001010b ^ 10011110b = 10010100b
-00001010b ^ 10011111b = 10010101b
-00001010b ^ 10100000b = 10101010b
-00001010b ^ 10100001b = 10101011b
-00001010b ^ 10100010b = 10101000b
-00001010b ^ 10100011b = 10101001b
-00001010b ^ 10100100b = 10101110b
-00001010b ^ 10100101b = 10101111b
-00001010b ^ 10100110b = 10101100b
-00001010b ^ 10100111b = 10101101b
-00001010b ^ 10101000b = 10100010b
-00001010b ^ 10101001b = 10100011b
-00001010b ^ 10101010b = 10100000b
-00001010b ^ 10101011b = 10100001b
-00001010b ^ 10101100b = 10100110b
-00001010b ^ 10101101b = 10100111b
-00001010b ^ 10101110b = 10100100b
-00001010b ^ 10101111b = 10100101b
-00001010b ^ 10110000b = 10111010b
-00001010b ^ 10110001b = 10111011b
-00001010b ^ 10110010b = 10111000b
-00001010b ^ 10110011b = 10111001b
-00001010b ^ 10110100b = 10111110b
-00001010b ^ 10110101b = 10111111b
-00001010b ^ 10110110b = 10111100b
-00001010b ^ 10110111b = 10111101b
-00001010b ^ 10111000b = 10110010b
-00001010b ^ 10111001b = 10110011b
-00001010b ^ 10111010b = 10110000b
-00001010b ^ 10111011b = 10110001b
-00001010b ^ 10111100b = 10110110b
-00001010b ^ 10111101b = 10110111b
-00001010b ^ 10111110b = 10110100b
-00001010b ^ 10111111b = 10110101b
-00001010b ^ 11000000b = 11001010b
-00001010b ^ 11000001b = 11001011b
-00001010b ^ 11000010b = 11001000b
-00001010b ^ 11000011b = 11001001b
-00001010b ^ 11000100b = 11001110b
-00001010b ^ 11000101b = 11001111b
-00001010b ^ 11000110b = 11001100b
-00001010b ^ 11000111b = 11001101b
-00001010b ^ 11001000b = 11000010b
-00001010b ^ 11001001b = 11000011b
-00001010b ^ 11001010b = 11000000b
-00001010b ^ 11001011b = 11000001b
-00001010b ^ 11001100b = 11000110b
-00001010b ^ 11001101b = 11000111b
-00001010b ^ 11001110b = 11000100b
-00001010b ^ 11001111b = 11000101b
-00001010b ^ 11010000b = 11011010b
-00001010b ^ 11010001b = 11011011b
-00001010b ^ 11010010b = 11011000b
-00001010b ^ 11010011b = 11011001b
-00001010b ^ 11010100b = 11011110b
-00001010b ^ 11010101b = 11011111b
-00001010b ^ 11010110b = 11011100b
-00001010b ^ 11010111b = 11011101b
-00001010b ^ 11011000b = 11010010b
-00001010b ^ 11011001b = 11010011b
-00001010b ^ 11011010b = 11010000b
-00001010b ^ 11011011b = 11010001b
-00001010b ^ 11011100b = 11010110b
-00001010b ^ 11011101b = 11010111b
-00001010b ^ 11011110b = 11010100b
-00001010b ^ 11011111b = 11010101b
-00001010b ^ 11100000b = 11101010b
-00001010b ^ 11100001b = 11101011b
-00001010b ^ 11100010b = 11101000b
-00001010b ^ 11100011b = 11101001b
-00001010b ^ 11100100b = 11101110b
-00001010b ^ 11100101b = 11101111b
-00001010b ^ 11100110b = 11101100b
-00001010b ^ 11100111b = 11101101b
-00001010b ^ 11101000b = 11100010b
-00001010b ^ 11101001b = 11100011b
-00001010b ^ 11101010b = 11100000b
-00001010b ^ 11101011b = 11100001b
-00001010b ^ 11101100b = 11100110b
-00001010b ^ 11101101b = 11100111b
-00001010b ^ 11101110b = 11100100b
-00001010b ^ 11101111b = 11100101b
-00001010b ^ 11110000b = 11111010b
-00001010b ^ 11110001b = 11111011b
-00001010b ^ 11110010b = 11111000b
-00001010b ^ 11110011b = 11111001b
-00001010b ^ 11110100b = 11111110b
-00001010b ^ 11110101b = 11111111b
-00001010b ^ 11110110b = 11111100b
-00001010b ^ 11110111b = 11111101b
-00001010b ^ 11111000b = 11110010b
-00001010b ^ 11111001b = 11110011b
-00001010b ^ 11111010b = 11110000b
-00001010b ^ 11111011b = 11110001b
-00001010b ^ 11111100b = 11110110b
-00001010b ^ 11111101b = 11110111b
-00001010b ^ 11111110b = 11110100b
-00001010b ^ 11111111b = 11110101b
-00001010b ^ 00000000b = 00001010b
-00001010b ^ 00000001b = 00001011b
-00001010b ^ 00000010b = 00001000b
-00001010b ^ 00000011b = 00001001b
-00001010b ^ 00000100b = 00001110b
-00001010b ^ 00000101b = 00001111b
-00001010b ^ 00000110b = 00001100b
-00001010b ^ 00000111b = 00001101b
-00001010b ^ 00001000b = 00000010b
-00001010b ^ 00001001b = 00000011b
-00001010b ^ 00001010b = 00000000b
-00001010b ^ 00001011b = 00000001b
-00001010b ^ 00001100b = 00000110b
-00001010b ^ 00001101b = 00000111b
-00001010b ^ 00001110b = 00000100b
-00001010b ^ 00001111b = 00000101b
-00001010b ^ 00010000b = 00011010b
-00001010b ^ 00010001b = 00011011b
-00001010b ^ 00010010b = 00011000b
-00001010b ^ 00010011b = 00011001b
-00001010b ^ 00010100b = 00011110b
-00001010b ^ 00010101b = 00011111b
-00001010b ^ 00010110b = 00011100b
-00001010b ^ 00010111b = 00011101b
-00001010b ^ 00011000b = 00010010b
-00001010b ^ 00011001b = 00010011b
-00001010b ^ 00011010b = 00010000b
-00001010b ^ 00011011b = 00010001b
-00001010b ^ 00011100b = 00010110b
-00001010b ^ 00011101b = 00010111b
-00001010b ^ 00011110b = 00010100b
-00001010b ^ 00011111b = 00010101b
-00001010b ^ 00100000b = 00101010b
-00001010b ^ 00100001b = 00101011b
-00001010b ^ 00100010b = 00101000b
-00001010b ^ 00100011b = 00101001b
-00001010b ^ 00100100b = 00101110b
-00001010b ^ 00100101b = 00101111b
-00001010b ^ 00100110b = 00101100b
-00001010b ^ 00100111b = 00101101b
-00001010b ^ 00101000b = 00100010b
-00001010b ^ 00101001b = 00100011b
-00001010b ^ 00101010b = 00100000b
-00001010b ^ 00101011b = 00100001b
-00001010b ^ 00101100b = 00100110b
-00001010b ^ 00101101b = 00100111b
-00001010b ^ 00101110b = 00100100b
-00001010b ^ 00101111b = 00100101b
-00001010b ^ 00110000b = 00111010b
-00001010b ^ 00110001b = 00111011b
-00001010b ^ 00110010b = 00111000b
-00001010b ^ 00110011b = 00111001b
-00001010b ^ 00110100b = 00111110b
-00001010b ^ 00110101b = 00111111b
-00001010b ^ 00110110b = 00111100b
-00001010b ^ 00110111b = 00111101b
-00001010b ^ 00111000b = 00110010b
-00001010b ^ 00111001b = 00110011b
-00001010b ^ 00111010b = 00110000b
-00001010b ^ 00111011b = 00110001b
-00001010b ^ 00111100b = 00110110b
-00001010b ^ 00111101b = 00110111b
-00001010b ^ 00111110b = 00110100b
-00001010b ^ 00111111b = 00110101b
-00001010b ^ 01000000b = 01001010b
-00001010b ^ 01000001b = 01001011b
-00001010b ^ 01000010b = 01001000b
-00001010b ^ 01000011b = 01001001b
-00001010b ^ 01000100b = 01001110b
-00001010b ^ 01000101b = 01001111b
-00001010b ^ 01000110b = 01001100b
-00001010b ^ 01000111b = 01001101b
-00001010b ^ 01001000b = 01000010b
-00001010b ^ 01001001b = 01000011b
-00001010b ^ 01001010b = 01000000b
-00001010b ^ 01001011b = 01000001b
-00001010b ^ 01001100b = 01000110b
-00001010b ^ 01001101b = 01000111b
-00001010b ^ 01001110b = 01000100b
-00001010b ^ 01001111b = 01000101b
-00001010b ^ 01010000b = 01011010b
-00001010b ^ 01010001b = 01011011b
-00001010b ^ 01010010b = 01011000b
-00001010b ^ 01010011b = 01011001b
-00001010b ^ 01010100b = 01011110b
-00001010b ^ 01010101b = 01011111b
-00001010b ^ 01010110b = 01011100b
-00001010b ^ 01010111b = 01011101b
-00001010b ^ 01011000b = 01010010b
-00001010b ^ 01011001b = 01010011b
-00001010b ^ 01011010b = 01010000b
-00001010b ^ 01011011b = 01010001b
-00001010b ^ 01011100b = 01010110b
-00001010b ^ 01011101b = 01010111b
-00001010b ^ 01011110b = 01010100b
-00001010b ^ 01011111b = 01010101b
-00001010b ^ 01100000b = 01101010b
-00001010b ^ 01100001b = 01101011b
-00001010b ^ 01100010b = 01101000b
-00001010b ^ 01100011b = 01101001b
-00001010b ^ 01100100b = 01101110b
-00001010b ^ 01100101b = 01101111b
-00001010b ^ 01100110b = 01101100b
-00001010b ^ 01100111b = 01101101b
-00001010b ^ 01101000b = 01100010b
-00001010b ^ 01101001b = 01100011b
-00001010b ^ 01101010b = 01100000b
-00001010b ^ 01101011b = 01100001b
-00001010b ^ 01101100b = 01100110b
-00001010b ^ 01101101b = 01100111b
-00001010b ^ 01101110b = 01100100b
-00001010b ^ 01101111b = 01100101b
-00001010b ^ 01110000b = 01111010b
-00001010b ^ 01110001b = 01111011b
-00001010b ^ 01110010b = 01111000b
-00001010b ^ 01110011b = 01111001b
-00001010b ^ 01110100b = 01111110b
-00001010b ^ 01110101b = 01111111b
-00001010b ^ 01110110b = 01111100b
-00001010b ^ 01110111b = 01111101b
-00001010b ^ 01111000b = 01110010b
-00001010b ^ 01111001b = 01110011b
-00001010b ^ 01111010b = 01110000b
-00001010b ^ 01111011b = 01110001b
-00001010b ^ 01111100b = 01110110b
-00001010b ^ 01111101b = 01110111b
-00001010b ^ 01111110b = 01110100b
-00001011b ^ 10000000b = 10001011b
-00001011b ^ 10000001b = 10001010b
-00001011b ^ 10000010b = 10001001b
-00001011b ^ 10000011b = 10001000b
-00001011b ^ 10000100b = 10001111b
-00001011b ^ 10000101b = 10001110b
-00001011b ^ 10000110b = 10001101b
-00001011b ^ 10000111b = 10001100b
-00001011b ^ 10001000b = 10000011b
-00001011b ^ 10001001b = 10000010b
-00001011b ^ 10001010b = 10000001b
-00001011b ^ 10001011b = 10000000b
-00001011b ^ 10001100b = 10000111b
-00001011b ^ 10001101b = 10000110b
-00001011b ^ 10001110b = 10000101b
-00001011b ^ 10001111b = 10000100b
-00001011b ^ 10010000b = 10011011b
-00001011b ^ 10010001b = 10011010b
-00001011b ^ 10010010b = 10011001b
-00001011b ^ 10010011b = 10011000b
-00001011b ^ 10010100b = 10011111b
-00001011b ^ 10010101b = 10011110b
-00001011b ^ 10010110b = 10011101b
-00001011b ^ 10010111b = 10011100b
-00001011b ^ 10011000b = 10010011b
-00001011b ^ 10011001b = 10010010b
-00001011b ^ 10011010b = 10010001b
-00001011b ^ 10011011b = 10010000b
-00001011b ^ 10011100b = 10010111b
-00001011b ^ 10011101b = 10010110b
-00001011b ^ 10011110b = 10010101b
-00001011b ^ 10011111b = 10010100b
-00001011b ^ 10100000b = 10101011b
-00001011b ^ 10100001b = 10101010b
-00001011b ^ 10100010b = 10101001b
-00001011b ^ 10100011b = 10101000b
-00001011b ^ 10100100b = 10101111b
-00001011b ^ 10100101b = 10101110b
-00001011b ^ 10100110b = 10101101b
-00001011b ^ 10100111b = 10101100b
-00001011b ^ 10101000b = 10100011b
-00001011b ^ 10101001b = 10100010b
-00001011b ^ 10101010b = 10100001b
-00001011b ^ 10101011b = 10100000b
-00001011b ^ 10101100b = 10100111b
-00001011b ^ 10101101b = 10100110b
-00001011b ^ 10101110b = 10100101b
-00001011b ^ 10101111b = 10100100b
-00001011b ^ 10110000b = 10111011b
-00001011b ^ 10110001b = 10111010b
-00001011b ^ 10110010b = 10111001b
-00001011b ^ 10110011b = 10111000b
-00001011b ^ 10110100b = 10111111b
-00001011b ^ 10110101b = 10111110b
-00001011b ^ 10110110b = 10111101b
-00001011b ^ 10110111b = 10111100b
-00001011b ^ 10111000b = 10110011b
-00001011b ^ 10111001b = 10110010b
-00001011b ^ 10111010b = 10110001b
-00001011b ^ 10111011b = 10110000b
-00001011b ^ 10111100b = 10110111b
-00001011b ^ 10111101b = 10110110b
-00001011b ^ 10111110b = 10110101b
-00001011b ^ 10111111b = 10110100b
-00001011b ^ 11000000b = 11001011b
-00001011b ^ 11000001b = 11001010b
-00001011b ^ 11000010b = 11001001b
-00001011b ^ 11000011b = 11001000b
-00001011b ^ 11000100b = 11001111b
-00001011b ^ 11000101b = 11001110b
-00001011b ^ 11000110b = 11001101b
-00001011b ^ 11000111b = 11001100b
-00001011b ^ 11001000b = 11000011b
-00001011b ^ 11001001b = 11000010b
-00001011b ^ 11001010b = 11000001b
-00001011b ^ 11001011b = 11000000b
-00001011b ^ 11001100b = 11000111b
-00001011b ^ 11001101b = 11000110b
-00001011b ^ 11001110b = 11000101b
-00001011b ^ 11001111b = 11000100b
-00001011b ^ 11010000b = 11011011b
-00001011b ^ 11010001b = 11011010b
-00001011b ^ 11010010b = 11011001b
-00001011b ^ 11010011b = 11011000b
-00001011b ^ 11010100b = 11011111b
-00001011b ^ 11010101b = 11011110b
-00001011b ^ 11010110b = 11011101b
-00001011b ^ 11010111b = 11011100b
-00001011b ^ 11011000b = 11010011b
-00001011b ^ 11011001b = 11010010b
-00001011b ^ 11011010b = 11010001b
-00001011b ^ 11011011b = 11010000b
-00001011b ^ 11011100b = 11010111b
-00001011b ^ 11011101b = 11010110b
-00001011b ^ 11011110b = 11010101b
-00001011b ^ 11011111b = 11010100b
-00001011b ^ 11100000b = 11101011b
-00001011b ^ 11100001b = 11101010b
-00001011b ^ 11100010b = 11101001b
-00001011b ^ 11100011b = 11101000b
-00001011b ^ 11100100b = 11101111b
-00001011b ^ 11100101b = 11101110b
-00001011b ^ 11100110b = 11101101b
-00001011b ^ 11100111b = 11101100b
-00001011b ^ 11101000b = 11100011b
-00001011b ^ 11101001b = 11100010b
-00001011b ^ 11101010b = 11100001b
-00001011b ^ 11101011b = 11100000b
-00001011b ^ 11101100b = 11100111b
-00001011b ^ 11101101b = 11100110b
-00001011b ^ 11101110b = 11100101b
-00001011b ^ 11101111b = 11100100b
-00001011b ^ 11110000b = 11111011b
-00001011b ^ 11110001b = 11111010b
-00001011b ^ 11110010b = 11111001b
-00001011b ^ 11110011b = 11111000b
-00001011b ^ 11110100b = 11111111b
-00001011b ^ 11110101b = 11111110b
-00001011b ^ 11110110b = 11111101b
-00001011b ^ 11110111b = 11111100b
-00001011b ^ 11111000b = 11110011b
-00001011b ^ 11111001b = 11110010b
-00001011b ^ 11111010b = 11110001b
-00001011b ^ 11111011b = 11110000b
-00001011b ^ 11111100b = 11110111b
-00001011b ^ 11111101b = 11110110b
-00001011b ^ 11111110b = 11110101b
-00001011b ^ 11111111b = 11110100b
-00001011b ^ 00000000b = 00001011b
-00001011b ^ 00000001b = 00001010b
-00001011b ^ 00000010b = 00001001b
-00001011b ^ 00000011b = 00001000b
-00001011b ^ 00000100b = 00001111b
-00001011b ^ 00000101b = 00001110b
-00001011b ^ 00000110b = 00001101b
-00001011b ^ 00000111b = 00001100b
-00001011b ^ 00001000b = 00000011b
-00001011b ^ 00001001b = 00000010b
-00001011b ^ 00001010b = 00000001b
-00001011b ^ 00001011b = 00000000b
-00001011b ^ 00001100b = 00000111b
-00001011b ^ 00001101b = 00000110b
-00001011b ^ 00001110b = 00000101b
-00001011b ^ 00001111b = 00000100b
-00001011b ^ 00010000b = 00011011b
-00001011b ^ 00010001b = 00011010b
-00001011b ^ 00010010b = 00011001b
-00001011b ^ 00010011b = 00011000b
-00001011b ^ 00010100b = 00011111b
-00001011b ^ 00010101b = 00011110b
-00001011b ^ 00010110b = 00011101b
-00001011b ^ 00010111b = 00011100b
-00001011b ^ 00011000b = 00010011b
-00001011b ^ 00011001b = 00010010b
-00001011b ^ 00011010b = 00010001b
-00001011b ^ 00011011b = 00010000b
-00001011b ^ 00011100b = 00010111b
-00001011b ^ 00011101b = 00010110b
-00001011b ^ 00011110b = 00010101b
-00001011b ^ 00011111b = 00010100b
-00001011b ^ 00100000b = 00101011b
-00001011b ^ 00100001b = 00101010b
-00001011b ^ 00100010b = 00101001b
-00001011b ^ 00100011b = 00101000b
-00001011b ^ 00100100b = 00101111b
-00001011b ^ 00100101b = 00101110b
-00001011b ^ 00100110b = 00101101b
-00001011b ^ 00100111b = 00101100b
-00001011b ^ 00101000b = 00100011b
-00001011b ^ 00101001b = 00100010b
-00001011b ^ 00101010b = 00100001b
-00001011b ^ 00101011b = 00100000b
-00001011b ^ 00101100b = 00100111b
-00001011b ^ 00101101b = 00100110b
-00001011b ^ 00101110b = 00100101b
-00001011b ^ 00101111b = 00100100b
-00001011b ^ 00110000b = 00111011b
-00001011b ^ 00110001b = 00111010b
-00001011b ^ 00110010b = 00111001b
-00001011b ^ 00110011b = 00111000b
-00001011b ^ 00110100b = 00111111b
-00001011b ^ 00110101b = 00111110b
-00001011b ^ 00110110b = 00111101b
-00001011b ^ 00110111b = 00111100b
-00001011b ^ 00111000b = 00110011b
-00001011b ^ 00111001b = 00110010b
-00001011b ^ 00111010b = 00110001b
-00001011b ^ 00111011b = 00110000b
-00001011b ^ 00111100b = 00110111b
-00001011b ^ 00111101b = 00110110b
-00001011b ^ 00111110b = 00110101b
-00001011b ^ 00111111b = 00110100b
-00001011b ^ 01000000b = 01001011b
-00001011b ^ 01000001b = 01001010b
-00001011b ^ 01000010b = 01001001b
-00001011b ^ 01000011b = 01001000b
-00001011b ^ 01000100b = 01001111b
-00001011b ^ 01000101b = 01001110b
-00001011b ^ 01000110b = 01001101b
-00001011b ^ 01000111b = 01001100b
-00001011b ^ 01001000b = 01000011b
-00001011b ^ 01001001b = 01000010b
-00001011b ^ 01001010b = 01000001b
-00001011b ^ 01001011b = 01000000b
-00001011b ^ 01001100b = 01000111b
-00001011b ^ 01001101b = 01000110b
-00001011b ^ 01001110b = 01000101b
-00001011b ^ 01001111b = 01000100b
-00001011b ^ 01010000b = 01011011b
-00001011b ^ 01010001b = 01011010b
-00001011b ^ 01010010b = 01011001b
-00001011b ^ 01010011b = 01011000b
-00001011b ^ 01010100b = 01011111b
-00001011b ^ 01010101b = 01011110b
-00001011b ^ 01010110b = 01011101b
-00001011b ^ 01010111b = 01011100b
-00001011b ^ 01011000b = 01010011b
-00001011b ^ 01011001b = 01010010b
-00001011b ^ 01011010b = 01010001b
-00001011b ^ 01011011b = 01010000b
-00001011b ^ 01011100b = 01010111b
-00001011b ^ 01011101b = 01010110b
-00001011b ^ 01011110b = 01010101b
-00001011b ^ 01011111b = 01010100b
-00001011b ^ 01100000b = 01101011b
-00001011b ^ 01100001b = 01101010b
-00001011b ^ 01100010b = 01101001b
-00001011b ^ 01100011b = 01101000b
-00001011b ^ 01100100b = 01101111b
-00001011b ^ 01100101b = 01101110b
-00001011b ^ 01100110b = 01101101b
-00001011b ^ 01100111b = 01101100b
-00001011b ^ 01101000b = 01100011b
-00001011b ^ 01101001b = 01100010b
-00001011b ^ 01101010b = 01100001b
-00001011b ^ 01101011b = 01100000b
-00001011b ^ 01101100b = 01100111b
-00001011b ^ 01101101b = 01100110b
-00001011b ^ 01101110b = 01100101b
-00001011b ^ 01101111b = 01100100b
-00001011b ^ 01110000b = 01111011b
-00001011b ^ 01110001b = 01111010b
-00001011b ^ 01110010b = 01111001b
-00001011b ^ 01110011b = 01111000b
-00001011b ^ 01110100b = 01111111b
-00001011b ^ 01110101b = 01111110b
-00001011b ^ 01110110b = 01111101b
-00001011b ^ 01110111b = 01111100b
-00001011b ^ 01111000b = 01110011b
-00001011b ^ 01111001b = 01110010b
-00001011b ^ 01111010b = 01110001b
-00001011b ^ 01111011b = 01110000b
-00001011b ^ 01111100b = 01110111b
-00001011b ^ 01111101b = 01110110b
-00001011b ^ 01111110b = 01110101b
-00001100b ^ 10000000b = 10001100b
-00001100b ^ 10000001b = 10001101b
-00001100b ^ 10000010b = 10001110b
-00001100b ^ 10000011b = 10001111b
-00001100b ^ 10000100b = 10001000b
-00001100b ^ 10000101b = 10001001b
-00001100b ^ 10000110b = 10001010b
-00001100b ^ 10000111b = 10001011b
-00001100b ^ 10001000b = 10000100b
-00001100b ^ 10001001b = 10000101b
-00001100b ^ 10001010b = 10000110b
-00001100b ^ 10001011b = 10000111b
-00001100b ^ 10001100b = 10000000b
-00001100b ^ 10001101b = 10000001b
-00001100b ^ 10001110b = 10000010b
-00001100b ^ 10001111b = 10000011b
-00001100b ^ 10010000b = 10011100b
-00001100b ^ 10010001b = 10011101b
-00001100b ^ 10010010b = 10011110b
-00001100b ^ 10010011b = 10011111b
-00001100b ^ 10010100b = 10011000b
-00001100b ^ 10010101b = 10011001b
-00001100b ^ 10010110b = 10011010b
-00001100b ^ 10010111b = 10011011b
-00001100b ^ 10011000b = 10010100b
-00001100b ^ 10011001b = 10010101b
-00001100b ^ 10011010b = 10010110b
-00001100b ^ 10011011b = 10010111b
-00001100b ^ 10011100b = 10010000b
-00001100b ^ 10011101b = 10010001b
-00001100b ^ 10011110b = 10010010b
-00001100b ^ 10011111b = 10010011b
-00001100b ^ 10100000b = 10101100b
-00001100b ^ 10100001b = 10101101b
-00001100b ^ 10100010b = 10101110b
-00001100b ^ 10100011b = 10101111b
-00001100b ^ 10100100b = 10101000b
-00001100b ^ 10100101b = 10101001b
-00001100b ^ 10100110b = 10101010b
-00001100b ^ 10100111b = 10101011b
-00001100b ^ 10101000b = 10100100b
-00001100b ^ 10101001b = 10100101b
-00001100b ^ 10101010b = 10100110b
-00001100b ^ 10101011b = 10100111b
-00001100b ^ 10101100b = 10100000b
-00001100b ^ 10101101b = 10100001b
-00001100b ^ 10101110b = 10100010b
-00001100b ^ 10101111b = 10100011b
-00001100b ^ 10110000b = 10111100b
-00001100b ^ 10110001b = 10111101b
-00001100b ^ 10110010b = 10111110b
-00001100b ^ 10110011b = 10111111b
-00001100b ^ 10110100b = 10111000b
-00001100b ^ 10110101b = 10111001b
-00001100b ^ 10110110b = 10111010b
-00001100b ^ 10110111b = 10111011b
-00001100b ^ 10111000b = 10110100b
-00001100b ^ 10111001b = 10110101b
-00001100b ^ 10111010b = 10110110b
-00001100b ^ 10111011b = 10110111b
-00001100b ^ 10111100b = 10110000b
-00001100b ^ 10111101b = 10110001b
-00001100b ^ 10111110b = 10110010b
-00001100b ^ 10111111b = 10110011b
-00001100b ^ 11000000b = 11001100b
-00001100b ^ 11000001b = 11001101b
-00001100b ^ 11000010b = 11001110b
-00001100b ^ 11000011b = 11001111b
-00001100b ^ 11000100b = 11001000b
-00001100b ^ 11000101b = 11001001b
-00001100b ^ 11000110b = 11001010b
-00001100b ^ 11000111b = 11001011b
-00001100b ^ 11001000b = 11000100b
-00001100b ^ 11001001b = 11000101b
-00001100b ^ 11001010b = 11000110b
-00001100b ^ 11001011b = 11000111b
-00001100b ^ 11001100b = 11000000b
-00001100b ^ 11001101b = 11000001b
-00001100b ^ 11001110b = 11000010b
-00001100b ^ 11001111b = 11000011b
-00001100b ^ 11010000b = 11011100b
-00001100b ^ 11010001b = 11011101b
-00001100b ^ 11010010b = 11011110b
-00001100b ^ 11010011b = 11011111b
-00001100b ^ 11010100b = 11011000b
-00001100b ^ 11010101b = 11011001b
-00001100b ^ 11010110b = 11011010b
-00001100b ^ 11010111b = 11011011b
-00001100b ^ 11011000b = 11010100b
-00001100b ^ 11011001b = 11010101b
-00001100b ^ 11011010b = 11010110b
-00001100b ^ 11011011b = 11010111b
-00001100b ^ 11011100b = 11010000b
-00001100b ^ 11011101b = 11010001b
-00001100b ^ 11011110b = 11010010b
-00001100b ^ 11011111b = 11010011b
-00001100b ^ 11100000b = 11101100b
-00001100b ^ 11100001b = 11101101b
-00001100b ^ 11100010b = 11101110b
-00001100b ^ 11100011b = 11101111b
-00001100b ^ 11100100b = 11101000b
-00001100b ^ 11100101b = 11101001b
-00001100b ^ 11100110b = 11101010b
-00001100b ^ 11100111b = 11101011b
-00001100b ^ 11101000b = 11100100b
-00001100b ^ 11101001b = 11100101b
-00001100b ^ 11101010b = 11100110b
-00001100b ^ 11101011b = 11100111b
-00001100b ^ 11101100b = 11100000b
-00001100b ^ 11101101b = 11100001b
-00001100b ^ 11101110b = 11100010b
-00001100b ^ 11101111b = 11100011b
-00001100b ^ 11110000b = 11111100b
-00001100b ^ 11110001b = 11111101b
-00001100b ^ 11110010b = 11111110b
-00001100b ^ 11110011b = 11111111b
-00001100b ^ 11110100b = 11111000b
-00001100b ^ 11110101b = 11111001b
-00001100b ^ 11110110b = 11111010b
-00001100b ^ 11110111b = 11111011b
-00001100b ^ 11111000b = 11110100b
-00001100b ^ 11111001b = 11110101b
-00001100b ^ 11111010b = 11110110b
-00001100b ^ 11111011b = 11110111b
-00001100b ^ 11111100b = 11110000b
-00001100b ^ 11111101b = 11110001b
-00001100b ^ 11111110b = 11110010b
-00001100b ^ 11111111b = 11110011b
-00001100b ^ 00000000b = 00001100b
-00001100b ^ 00000001b = 00001101b
-00001100b ^ 00000010b = 00001110b
-00001100b ^ 00000011b = 00001111b
-00001100b ^ 00000100b = 00001000b
-00001100b ^ 00000101b = 00001001b
-00001100b ^ 00000110b = 00001010b
-00001100b ^ 00000111b = 00001011b
-00001100b ^ 00001000b = 00000100b
-00001100b ^ 00001001b = 00000101b
-00001100b ^ 00001010b = 00000110b
-00001100b ^ 00001011b = 00000111b
-00001100b ^ 00001100b = 00000000b
-00001100b ^ 00001101b = 00000001b
-00001100b ^ 00001110b = 00000010b
-00001100b ^ 00001111b = 00000011b
-00001100b ^ 00010000b = 00011100b
-00001100b ^ 00010001b = 00011101b
-00001100b ^ 00010010b = 00011110b
-00001100b ^ 00010011b = 00011111b
-00001100b ^ 00010100b = 00011000b
-00001100b ^ 00010101b = 00011001b
-00001100b ^ 00010110b = 00011010b
-00001100b ^ 00010111b = 00011011b
-00001100b ^ 00011000b = 00010100b
-00001100b ^ 00011001b = 00010101b
-00001100b ^ 00011010b = 00010110b
-00001100b ^ 00011011b = 00010111b
-00001100b ^ 00011100b = 00010000b
-00001100b ^ 00011101b = 00010001b
-00001100b ^ 00011110b = 00010010b
-00001100b ^ 00011111b = 00010011b
-00001100b ^ 00100000b = 00101100b
-00001100b ^ 00100001b = 00101101b
-00001100b ^ 00100010b = 00101110b
-00001100b ^ 00100011b = 00101111b
-00001100b ^ 00100100b = 00101000b
-00001100b ^ 00100101b = 00101001b
-00001100b ^ 00100110b = 00101010b
-00001100b ^ 00100111b = 00101011b
-00001100b ^ 00101000b = 00100100b
-00001100b ^ 00101001b = 00100101b
-00001100b ^ 00101010b = 00100110b
-00001100b ^ 00101011b = 00100111b
-00001100b ^ 00101100b = 00100000b
-00001100b ^ 00101101b = 00100001b
-00001100b ^ 00101110b = 00100010b
-00001100b ^ 00101111b = 00100011b
-00001100b ^ 00110000b = 00111100b
-00001100b ^ 00110001b = 00111101b
-00001100b ^ 00110010b = 00111110b
-00001100b ^ 00110011b = 00111111b
-00001100b ^ 00110100b = 00111000b
-00001100b ^ 00110101b = 00111001b
-00001100b ^ 00110110b = 00111010b
-00001100b ^ 00110111b = 00111011b
-00001100b ^ 00111000b = 00110100b
-00001100b ^ 00111001b = 00110101b
-00001100b ^ 00111010b = 00110110b
-00001100b ^ 00111011b = 00110111b
-00001100b ^ 00111100b = 00110000b
-00001100b ^ 00111101b = 00110001b
-00001100b ^ 00111110b = 00110010b
-00001100b ^ 00111111b = 00110011b
-00001100b ^ 01000000b = 01001100b
-00001100b ^ 01000001b = 01001101b
-00001100b ^ 01000010b = 01001110b
-00001100b ^ 01000011b = 01001111b
-00001100b ^ 01000100b = 01001000b
-00001100b ^ 01000101b = 01001001b
-00001100b ^ 01000110b = 01001010b
-00001100b ^ 01000111b = 01001011b
-00001100b ^ 01001000b = 01000100b
-00001100b ^ 01001001b = 01000101b
-00001100b ^ 01001010b = 01000110b
-00001100b ^ 01001011b = 01000111b
-00001100b ^ 01001100b = 01000000b
-00001100b ^ 01001101b = 01000001b
-00001100b ^ 01001110b = 01000010b
-00001100b ^ 01001111b = 01000011b
-00001100b ^ 01010000b = 01011100b
-00001100b ^ 01010001b = 01011101b
-00001100b ^ 01010010b = 01011110b
-00001100b ^ 01010011b = 01011111b
-00001100b ^ 01010100b = 01011000b
-00001100b ^ 01010101b = 01011001b
-00001100b ^ 01010110b = 01011010b
-00001100b ^ 01010111b = 01011011b
-00001100b ^ 01011000b = 01010100b
-00001100b ^ 01011001b = 01010101b
-00001100b ^ 01011010b = 01010110b
-00001100b ^ 01011011b = 01010111b
-00001100b ^ 01011100b = 01010000b
-00001100b ^ 01011101b = 01010001b
-00001100b ^ 01011110b = 01010010b
-00001100b ^ 01011111b = 01010011b
-00001100b ^ 01100000b = 01101100b
-00001100b ^ 01100001b = 01101101b
-00001100b ^ 01100010b = 01101110b
-00001100b ^ 01100011b = 01101111b
-00001100b ^ 01100100b = 01101000b
-00001100b ^ 01100101b = 01101001b
-00001100b ^ 01100110b = 01101010b
-00001100b ^ 01100111b = 01101011b
-00001100b ^ 01101000b = 01100100b
-00001100b ^ 01101001b = 01100101b
-00001100b ^ 01101010b = 01100110b
-00001100b ^ 01101011b = 01100111b
-00001100b ^ 01101100b = 01100000b
-00001100b ^ 01101101b = 01100001b
-00001100b ^ 01101110b = 01100010b
-00001100b ^ 01101111b = 01100011b
-00001100b ^ 01110000b = 01111100b
-00001100b ^ 01110001b = 01111101b
-00001100b ^ 01110010b = 01111110b
-00001100b ^ 01110011b = 01111111b
-00001100b ^ 01110100b = 01111000b
-00001100b ^ 01110101b = 01111001b
-00001100b ^ 01110110b = 01111010b
-00001100b ^ 01110111b = 01111011b
-00001100b ^ 01111000b = 01110100b
-00001100b ^ 01111001b = 01110101b
-00001100b ^ 01111010b = 01110110b
-00001100b ^ 01111011b = 01110111b
-00001100b ^ 01111100b = 01110000b
-00001100b ^ 01111101b = 01110001b
-00001100b ^ 01111110b = 01110010b
-00001101b ^ 10000000b = 10001101b
-00001101b ^ 10000001b = 10001100b
-00001101b ^ 10000010b = 10001111b
-00001101b ^ 10000011b = 10001110b
-00001101b ^ 10000100b = 10001001b
-00001101b ^ 10000101b = 10001000b
-00001101b ^ 10000110b = 10001011b
-00001101b ^ 10000111b = 10001010b
-00001101b ^ 10001000b = 10000101b
-00001101b ^ 10001001b = 10000100b
-00001101b ^ 10001010b = 10000111b
-00001101b ^ 10001011b = 10000110b
-00001101b ^ 10001100b = 10000001b
-00001101b ^ 10001101b = 10000000b
-00001101b ^ 10001110b = 10000011b
-00001101b ^ 10001111b = 10000010b
-00001101b ^ 10010000b = 10011101b
-00001101b ^ 10010001b = 10011100b
-00001101b ^ 10010010b = 10011111b
-00001101b ^ 10010011b = 10011110b
-00001101b ^ 10010100b = 10011001b
-00001101b ^ 10010101b = 10011000b
-00001101b ^ 10010110b = 10011011b
-00001101b ^ 10010111b = 10011010b
-00001101b ^ 10011000b = 10010101b
-00001101b ^ 10011001b = 10010100b
-00001101b ^ 10011010b = 10010111b
-00001101b ^ 10011011b = 10010110b
-00001101b ^ 10011100b = 10010001b
-00001101b ^ 10011101b = 10010000b
-00001101b ^ 10011110b = 10010011b
-00001101b ^ 10011111b = 10010010b
-00001101b ^ 10100000b = 10101101b
-00001101b ^ 10100001b = 10101100b
-00001101b ^ 10100010b = 10101111b
-00001101b ^ 10100011b = 10101110b
-00001101b ^ 10100100b = 10101001b
-00001101b ^ 10100101b = 10101000b
-00001101b ^ 10100110b = 10101011b
-00001101b ^ 10100111b = 10101010b
-00001101b ^ 10101000b = 10100101b
-00001101b ^ 10101001b = 10100100b
-00001101b ^ 10101010b = 10100111b
-00001101b ^ 10101011b = 10100110b
-00001101b ^ 10101100b = 10100001b
-00001101b ^ 10101101b = 10100000b
-00001101b ^ 10101110b = 10100011b
-00001101b ^ 10101111b = 10100010b
-00001101b ^ 10110000b = 10111101b
-00001101b ^ 10110001b = 10111100b
-00001101b ^ 10110010b = 10111111b
-00001101b ^ 10110011b = 10111110b
-00001101b ^ 10110100b = 10111001b
-00001101b ^ 10110101b = 10111000b
-00001101b ^ 10110110b = 10111011b
-00001101b ^ 10110111b = 10111010b
-00001101b ^ 10111000b = 10110101b
-00001101b ^ 10111001b = 10110100b
-00001101b ^ 10111010b = 10110111b
-00001101b ^ 10111011b = 10110110b
-00001101b ^ 10111100b = 10110001b
-00001101b ^ 10111101b = 10110000b
-00001101b ^ 10111110b = 10110011b
-00001101b ^ 10111111b = 10110010b
-00001101b ^ 11000000b = 11001101b
-00001101b ^ 11000001b = 11001100b
-00001101b ^ 11000010b = 11001111b
-00001101b ^ 11000011b = 11001110b
-00001101b ^ 11000100b = 11001001b
-00001101b ^ 11000101b = 11001000b
-00001101b ^ 11000110b = 11001011b
-00001101b ^ 11000111b = 11001010b
-00001101b ^ 11001000b = 11000101b
-00001101b ^ 11001001b = 11000100b
-00001101b ^ 11001010b = 11000111b
-00001101b ^ 11001011b = 11000110b
-00001101b ^ 11001100b = 11000001b
-00001101b ^ 11001101b = 11000000b
-00001101b ^ 11001110b = 11000011b
-00001101b ^ 11001111b = 11000010b
-00001101b ^ 11010000b = 11011101b
-00001101b ^ 11010001b = 11011100b
-00001101b ^ 11010010b = 11011111b
-00001101b ^ 11010011b = 11011110b
-00001101b ^ 11010100b = 11011001b
-00001101b ^ 11010101b = 11011000b
-00001101b ^ 11010110b = 11011011b
-00001101b ^ 11010111b = 11011010b
-00001101b ^ 11011000b = 11010101b
-00001101b ^ 11011001b = 11010100b
-00001101b ^ 11011010b = 11010111b
-00001101b ^ 11011011b = 11010110b
-00001101b ^ 11011100b = 11010001b
-00001101b ^ 11011101b = 11010000b
-00001101b ^ 11011110b = 11010011b
-00001101b ^ 11011111b = 11010010b
-00001101b ^ 11100000b = 11101101b
-00001101b ^ 11100001b = 11101100b
-00001101b ^ 11100010b = 11101111b
-00001101b ^ 11100011b = 11101110b
-00001101b ^ 11100100b = 11101001b
-00001101b ^ 11100101b = 11101000b
-00001101b ^ 11100110b = 11101011b
-00001101b ^ 11100111b = 11101010b
-00001101b ^ 11101000b = 11100101b
-00001101b ^ 11101001b = 11100100b
-00001101b ^ 11101010b = 11100111b
-00001101b ^ 11101011b = 11100110b
-00001101b ^ 11101100b = 11100001b
-00001101b ^ 11101101b = 11100000b
-00001101b ^ 11101110b = 11100011b
-00001101b ^ 11101111b = 11100010b
-00001101b ^ 11110000b = 11111101b
-00001101b ^ 11110001b = 11111100b
-00001101b ^ 11110010b = 11111111b
-00001101b ^ 11110011b = 11111110b
-00001101b ^ 11110100b = 11111001b
-00001101b ^ 11110101b = 11111000b
-00001101b ^ 11110110b = 11111011b
-00001101b ^ 11110111b = 11111010b
-00001101b ^ 11111000b = 11110101b
-00001101b ^ 11111001b = 11110100b
-00001101b ^ 11111010b = 11110111b
-00001101b ^ 11111011b = 11110110b
-00001101b ^ 11111100b = 11110001b
-00001101b ^ 11111101b = 11110000b
-00001101b ^ 11111110b = 11110011b
-00001101b ^ 11111111b = 11110010b
-00001101b ^ 00000000b = 00001101b
-00001101b ^ 00000001b = 00001100b
-00001101b ^ 00000010b = 00001111b
-00001101b ^ 00000011b = 00001110b
-00001101b ^ 00000100b = 00001001b
-00001101b ^ 00000101b = 00001000b
-00001101b ^ 00000110b = 00001011b
-00001101b ^ 00000111b = 00001010b
-00001101b ^ 00001000b = 00000101b
-00001101b ^ 00001001b = 00000100b
-00001101b ^ 00001010b = 00000111b
-00001101b ^ 00001011b = 00000110b
-00001101b ^ 00001100b = 00000001b
-00001101b ^ 00001101b = 00000000b
-00001101b ^ 00001110b = 00000011b
-00001101b ^ 00001111b = 00000010b
-00001101b ^ 00010000b = 00011101b
-00001101b ^ 00010001b = 00011100b
-00001101b ^ 00010010b = 00011111b
-00001101b ^ 00010011b = 00011110b
-00001101b ^ 00010100b = 00011001b
-00001101b ^ 00010101b = 00011000b
-00001101b ^ 00010110b = 00011011b
-00001101b ^ 00010111b = 00011010b
-00001101b ^ 00011000b = 00010101b
-00001101b ^ 00011001b = 00010100b
-00001101b ^ 00011010b = 00010111b
-00001101b ^ 00011011b = 00010110b
-00001101b ^ 00011100b = 00010001b
-00001101b ^ 00011101b = 00010000b
-00001101b ^ 00011110b = 00010011b
-00001101b ^ 00011111b = 00010010b
-00001101b ^ 00100000b = 00101101b
-00001101b ^ 00100001b = 00101100b
-00001101b ^ 00100010b = 00101111b
-00001101b ^ 00100011b = 00101110b
-00001101b ^ 00100100b = 00101001b
-00001101b ^ 00100101b = 00101000b
-00001101b ^ 00100110b = 00101011b
-00001101b ^ 00100111b = 00101010b
-00001101b ^ 00101000b = 00100101b
-00001101b ^ 00101001b = 00100100b
-00001101b ^ 00101010b = 00100111b
-00001101b ^ 00101011b = 00100110b
-00001101b ^ 00101100b = 00100001b
-00001101b ^ 00101101b = 00100000b
-00001101b ^ 00101110b = 00100011b
-00001101b ^ 00101111b = 00100010b
-00001101b ^ 00110000b = 00111101b
-00001101b ^ 00110001b = 00111100b
-00001101b ^ 00110010b = 00111111b
-00001101b ^ 00110011b = 00111110b
-00001101b ^ 00110100b = 00111001b
-00001101b ^ 00110101b = 00111000b
-00001101b ^ 00110110b = 00111011b
-00001101b ^ 00110111b = 00111010b
-00001101b ^ 00111000b = 00110101b
-00001101b ^ 00111001b = 00110100b
-00001101b ^ 00111010b = 00110111b
-00001101b ^ 00111011b = 00110110b
-00001101b ^ 00111100b = 00110001b
-00001101b ^ 00111101b = 00110000b
-00001101b ^ 00111110b = 00110011b
-00001101b ^ 00111111b = 00110010b
-00001101b ^ 01000000b = 01001101b
-00001101b ^ 01000001b = 01001100b
-00001101b ^ 01000010b = 01001111b
-00001101b ^ 01000011b = 01001110b
-00001101b ^ 01000100b = 01001001b
-00001101b ^ 01000101b = 01001000b
-00001101b ^ 01000110b = 01001011b
-00001101b ^ 01000111b = 01001010b
-00001101b ^ 01001000b = 01000101b
-00001101b ^ 01001001b = 01000100b
-00001101b ^ 01001010b = 01000111b
-00001101b ^ 01001011b = 01000110b
-00001101b ^ 01001100b = 01000001b
-00001101b ^ 01001101b = 01000000b
-00001101b ^ 01001110b = 01000011b
-00001101b ^ 01001111b = 01000010b
-00001101b ^ 01010000b = 01011101b
-00001101b ^ 01010001b = 01011100b
-00001101b ^ 01010010b = 01011111b
-00001101b ^ 01010011b = 01011110b
-00001101b ^ 01010100b = 01011001b
-00001101b ^ 01010101b = 01011000b
-00001101b ^ 01010110b = 01011011b
-00001101b ^ 01010111b = 01011010b
-00001101b ^ 01011000b = 01010101b
-00001101b ^ 01011001b = 01010100b
-00001101b ^ 01011010b = 01010111b
-00001101b ^ 01011011b = 01010110b
-00001101b ^ 01011100b = 01010001b
-00001101b ^ 01011101b = 01010000b
-00001101b ^ 01011110b = 01010011b
-00001101b ^ 01011111b = 01010010b
-00001101b ^ 01100000b = 01101101b
-00001101b ^ 01100001b = 01101100b
-00001101b ^ 01100010b = 01101111b
-00001101b ^ 01100011b = 01101110b
-00001101b ^ 01100100b = 01101001b
-00001101b ^ 01100101b = 01101000b
-00001101b ^ 01100110b = 01101011b
-00001101b ^ 01100111b = 01101010b
-00001101b ^ 01101000b = 01100101b
-00001101b ^ 01101001b = 01100100b
-00001101b ^ 01101010b = 01100111b
-00001101b ^ 01101011b = 01100110b
-00001101b ^ 01101100b = 01100001b
-00001101b ^ 01101101b = 01100000b
-00001101b ^ 01101110b = 01100011b
-00001101b ^ 01101111b = 01100010b
-00001101b ^ 01110000b = 01111101b
-00001101b ^ 01110001b = 01111100b
-00001101b ^ 01110010b = 01111111b
-00001101b ^ 01110011b = 01111110b
-00001101b ^ 01110100b = 01111001b
-00001101b ^ 01110101b = 01111000b
-00001101b ^ 01110110b = 01111011b
-00001101b ^ 01110111b = 01111010b
-00001101b ^ 01111000b = 01110101b
-00001101b ^ 01111001b = 01110100b
-00001101b ^ 01111010b = 01110111b
-00001101b ^ 01111011b = 01110110b
-00001101b ^ 01111100b = 01110001b
-00001101b ^ 01111101b = 01110000b
-00001101b ^ 01111110b = 01110011b
-00001110b ^ 10000000b = 10001110b
-00001110b ^ 10000001b = 10001111b
-00001110b ^ 10000010b = 10001100b
-00001110b ^ 10000011b = 10001101b
-00001110b ^ 10000100b = 10001010b
-00001110b ^ 10000101b = 10001011b
-00001110b ^ 10000110b = 10001000b
-00001110b ^ 10000111b = 10001001b
-00001110b ^ 10001000b = 10000110b
-00001110b ^ 10001001b = 10000111b
-00001110b ^ 10001010b = 10000100b
-00001110b ^ 10001011b = 10000101b
-00001110b ^ 10001100b = 10000010b
-00001110b ^ 10001101b = 10000011b
-00001110b ^ 10001110b = 10000000b
-00001110b ^ 10001111b = 10000001b
-00001110b ^ 10010000b = 10011110b
-00001110b ^ 10010001b = 10011111b
-00001110b ^ 10010010b = 10011100b
-00001110b ^ 10010011b = 10011101b
-00001110b ^ 10010100b = 10011010b
-00001110b ^ 10010101b = 10011011b
-00001110b ^ 10010110b = 10011000b
-00001110b ^ 10010111b = 10011001b
-00001110b ^ 10011000b = 10010110b
-00001110b ^ 10011001b = 10010111b
-00001110b ^ 10011010b = 10010100b
-00001110b ^ 10011011b = 10010101b
-00001110b ^ 10011100b = 10010010b
-00001110b ^ 10011101b = 10010011b
-00001110b ^ 10011110b = 10010000b
-00001110b ^ 10011111b = 10010001b
-00001110b ^ 10100000b = 10101110b
-00001110b ^ 10100001b = 10101111b
-00001110b ^ 10100010b = 10101100b
-00001110b ^ 10100011b = 10101101b
-00001110b ^ 10100100b = 10101010b
-00001110b ^ 10100101b = 10101011b
-00001110b ^ 10100110b = 10101000b
-00001110b ^ 10100111b = 10101001b
-00001110b ^ 10101000b = 10100110b
-00001110b ^ 10101001b = 10100111b
-00001110b ^ 10101010b = 10100100b
-00001110b ^ 10101011b = 10100101b
-00001110b ^ 10101100b = 10100010b
-00001110b ^ 10101101b = 10100011b
-00001110b ^ 10101110b = 10100000b
-00001110b ^ 10101111b = 10100001b
-00001110b ^ 10110000b = 10111110b
-00001110b ^ 10110001b = 10111111b
-00001110b ^ 10110010b = 10111100b
-00001110b ^ 10110011b = 10111101b
-00001110b ^ 10110100b = 10111010b
-00001110b ^ 10110101b = 10111011b
-00001110b ^ 10110110b = 10111000b
-00001110b ^ 10110111b = 10111001b
-00001110b ^ 10111000b = 10110110b
-00001110b ^ 10111001b = 10110111b
-00001110b ^ 10111010b = 10110100b
-00001110b ^ 10111011b = 10110101b
-00001110b ^ 10111100b = 10110010b
-00001110b ^ 10111101b = 10110011b
-00001110b ^ 10111110b = 10110000b
-00001110b ^ 10111111b = 10110001b
-00001110b ^ 11000000b = 11001110b
-00001110b ^ 11000001b = 11001111b
-00001110b ^ 11000010b = 11001100b
-00001110b ^ 11000011b = 11001101b
-00001110b ^ 11000100b = 11001010b
-00001110b ^ 11000101b = 11001011b
-00001110b ^ 11000110b = 11001000b
-00001110b ^ 11000111b = 11001001b
-00001110b ^ 11001000b = 11000110b
-00001110b ^ 11001001b = 11000111b
-00001110b ^ 11001010b = 11000100b
-00001110b ^ 11001011b = 11000101b
-00001110b ^ 11001100b = 11000010b
-00001110b ^ 11001101b = 11000011b
-00001110b ^ 11001110b = 11000000b
-00001110b ^ 11001111b = 11000001b
-00001110b ^ 11010000b = 11011110b
-00001110b ^ 11010001b = 11011111b
-00001110b ^ 11010010b = 11011100b
-00001110b ^ 11010011b = 11011101b
-00001110b ^ 11010100b = 11011010b
-00001110b ^ 11010101b = 11011011b
-00001110b ^ 11010110b = 11011000b
-00001110b ^ 11010111b = 11011001b
-00001110b ^ 11011000b = 11010110b
-00001110b ^ 11011001b = 11010111b
-00001110b ^ 11011010b = 11010100b
-00001110b ^ 11011011b = 11010101b
-00001110b ^ 11011100b = 11010010b
-00001110b ^ 11011101b = 11010011b
-00001110b ^ 11011110b = 11010000b
-00001110b ^ 11011111b = 11010001b
-00001110b ^ 11100000b = 11101110b
-00001110b ^ 11100001b = 11101111b
-00001110b ^ 11100010b = 11101100b
-00001110b ^ 11100011b = 11101101b
-00001110b ^ 11100100b = 11101010b
-00001110b ^ 11100101b = 11101011b
-00001110b ^ 11100110b = 11101000b
-00001110b ^ 11100111b = 11101001b
-00001110b ^ 11101000b = 11100110b
-00001110b ^ 11101001b = 11100111b
-00001110b ^ 11101010b = 11100100b
-00001110b ^ 11101011b = 11100101b
-00001110b ^ 11101100b = 11100010b
-00001110b ^ 11101101b = 11100011b
-00001110b ^ 11101110b = 11100000b
-00001110b ^ 11101111b = 11100001b
-00001110b ^ 11110000b = 11111110b
-00001110b ^ 11110001b = 11111111b
-00001110b ^ 11110010b = 11111100b
-00001110b ^ 11110011b = 11111101b
-00001110b ^ 11110100b = 11111010b
-00001110b ^ 11110101b = 11111011b
-00001110b ^ 11110110b = 11111000b
-00001110b ^ 11110111b = 11111001b
-00001110b ^ 11111000b = 11110110b
-00001110b ^ 11111001b = 11110111b
-00001110b ^ 11111010b = 11110100b
-00001110b ^ 11111011b = 11110101b
-00001110b ^ 11111100b = 11110010b
-00001110b ^ 11111101b = 11110011b
-00001110b ^ 11111110b = 11110000b
-00001110b ^ 11111111b = 11110001b
-00001110b ^ 00000000b = 00001110b
-00001110b ^ 00000001b = 00001111b
-00001110b ^ 00000010b = 00001100b
-00001110b ^ 00000011b = 00001101b
-00001110b ^ 00000100b = 00001010b
-00001110b ^ 00000101b = 00001011b
-00001110b ^ 00000110b = 00001000b
-00001110b ^ 00000111b = 00001001b
-00001110b ^ 00001000b = 00000110b
-00001110b ^ 00001001b = 00000111b
-00001110b ^ 00001010b = 00000100b
-00001110b ^ 00001011b = 00000101b
-00001110b ^ 00001100b = 00000010b
-00001110b ^ 00001101b = 00000011b
-00001110b ^ 00001110b = 00000000b
-00001110b ^ 00001111b = 00000001b
-00001110b ^ 00010000b = 00011110b
-00001110b ^ 00010001b = 00011111b
-00001110b ^ 00010010b = 00011100b
-00001110b ^ 00010011b = 00011101b
-00001110b ^ 00010100b = 00011010b
-00001110b ^ 00010101b = 00011011b
-00001110b ^ 00010110b = 00011000b
-00001110b ^ 00010111b = 00011001b
-00001110b ^ 00011000b = 00010110b
-00001110b ^ 00011001b = 00010111b
-00001110b ^ 00011010b = 00010100b
-00001110b ^ 00011011b = 00010101b
-00001110b ^ 00011100b = 00010010b
-00001110b ^ 00011101b = 00010011b
-00001110b ^ 00011110b = 00010000b
-00001110b ^ 00011111b = 00010001b
-00001110b ^ 00100000b = 00101110b
-00001110b ^ 00100001b = 00101111b
-00001110b ^ 00100010b = 00101100b
-00001110b ^ 00100011b = 00101101b
-00001110b ^ 00100100b = 00101010b
-00001110b ^ 00100101b = 00101011b
-00001110b ^ 00100110b = 00101000b
-00001110b ^ 00100111b = 00101001b
-00001110b ^ 00101000b = 00100110b
-00001110b ^ 00101001b = 00100111b
-00001110b ^ 00101010b = 00100100b
-00001110b ^ 00101011b = 00100101b
-00001110b ^ 00101100b = 00100010b
-00001110b ^ 00101101b = 00100011b
-00001110b ^ 00101110b = 00100000b
-00001110b ^ 00101111b = 00100001b
-00001110b ^ 00110000b = 00111110b
-00001110b ^ 00110001b = 00111111b
-00001110b ^ 00110010b = 00111100b
-00001110b ^ 00110011b = 00111101b
-00001110b ^ 00110100b = 00111010b
-00001110b ^ 00110101b = 00111011b
-00001110b ^ 00110110b = 00111000b
-00001110b ^ 00110111b = 00111001b
-00001110b ^ 00111000b = 00110110b
-00001110b ^ 00111001b = 00110111b
-00001110b ^ 00111010b = 00110100b
-00001110b ^ 00111011b = 00110101b
-00001110b ^ 00111100b = 00110010b
-00001110b ^ 00111101b = 00110011b
-00001110b ^ 00111110b = 00110000b
-00001110b ^ 00111111b = 00110001b
-00001110b ^ 01000000b = 01001110b
-00001110b ^ 01000001b = 01001111b
-00001110b ^ 01000010b = 01001100b
-00001110b ^ 01000011b = 01001101b
-00001110b ^ 01000100b = 01001010b
-00001110b ^ 01000101b = 01001011b
-00001110b ^ 01000110b = 01001000b
-00001110b ^ 01000111b = 01001001b
-00001110b ^ 01001000b = 01000110b
-00001110b ^ 01001001b = 01000111b
-00001110b ^ 01001010b = 01000100b
-00001110b ^ 01001011b = 01000101b
-00001110b ^ 01001100b = 01000010b
-00001110b ^ 01001101b = 01000011b
-00001110b ^ 01001110b = 01000000b
-00001110b ^ 01001111b = 01000001b
-00001110b ^ 01010000b = 01011110b
-00001110b ^ 01010001b = 01011111b
-00001110b ^ 01010010b = 01011100b
-00001110b ^ 01010011b = 01011101b
-00001110b ^ 01010100b = 01011010b
-00001110b ^ 01010101b = 01011011b
-00001110b ^ 01010110b = 01011000b
-00001110b ^ 01010111b = 01011001b
-00001110b ^ 01011000b = 01010110b
-00001110b ^ 01011001b = 01010111b
-00001110b ^ 01011010b = 01010100b
-00001110b ^ 01011011b = 01010101b
-00001110b ^ 01011100b = 01010010b
-00001110b ^ 01011101b = 01010011b
-00001110b ^ 01011110b = 01010000b
-00001110b ^ 01011111b = 01010001b
-00001110b ^ 01100000b = 01101110b
-00001110b ^ 01100001b = 01101111b
-00001110b ^ 01100010b = 01101100b
-00001110b ^ 01100011b = 01101101b
-00001110b ^ 01100100b = 01101010b
-00001110b ^ 01100101b = 01101011b
-00001110b ^ 01100110b = 01101000b
-00001110b ^ 01100111b = 01101001b
-00001110b ^ 01101000b = 01100110b
-00001110b ^ 01101001b = 01100111b
-00001110b ^ 01101010b = 01100100b
-00001110b ^ 01101011b = 01100101b
-00001110b ^ 01101100b = 01100010b
-00001110b ^ 01101101b = 01100011b
-00001110b ^ 01101110b = 01100000b
-00001110b ^ 01101111b = 01100001b
-00001110b ^ 01110000b = 01111110b
-00001110b ^ 01110001b = 01111111b
-00001110b ^ 01110010b = 01111100b
-00001110b ^ 01110011b = 01111101b
-00001110b ^ 01110100b = 01111010b
-00001110b ^ 01110101b = 01111011b
-00001110b ^ 01110110b = 01111000b
-00001110b ^ 01110111b = 01111001b
-00001110b ^ 01111000b = 01110110b
-00001110b ^ 01111001b = 01110111b
-00001110b ^ 01111010b = 01110100b
-00001110b ^ 01111011b = 01110101b
-00001110b ^ 01111100b = 01110010b
-00001110b ^ 01111101b = 01110011b
-00001110b ^ 01111110b = 01110000b
-00001111b ^ 10000000b = 10001111b
-00001111b ^ 10000001b = 10001110b
-00001111b ^ 10000010b = 10001101b
-00001111b ^ 10000011b = 10001100b
-00001111b ^ 10000100b = 10001011b
-00001111b ^ 10000101b = 10001010b
-00001111b ^ 10000110b = 10001001b
-00001111b ^ 10000111b = 10001000b
-00001111b ^ 10001000b = 10000111b
-00001111b ^ 10001001b = 10000110b
-00001111b ^ 10001010b = 10000101b
-00001111b ^ 10001011b = 10000100b
-00001111b ^ 10001100b = 10000011b
-00001111b ^ 10001101b = 10000010b
-00001111b ^ 10001110b = 10000001b
-00001111b ^ 10001111b = 10000000b
-00001111b ^ 10010000b = 10011111b
-00001111b ^ 10010001b = 10011110b
-00001111b ^ 10010010b = 10011101b
-00001111b ^ 10010011b = 10011100b
-00001111b ^ 10010100b = 10011011b
-00001111b ^ 10010101b = 10011010b
-00001111b ^ 10010110b = 10011001b
-00001111b ^ 10010111b = 10011000b
-00001111b ^ 10011000b = 10010111b
-00001111b ^ 10011001b = 10010110b
-00001111b ^ 10011010b = 10010101b
-00001111b ^ 10011011b = 10010100b
-00001111b ^ 10011100b = 10010011b
-00001111b ^ 10011101b = 10010010b
-00001111b ^ 10011110b = 10010001b
-00001111b ^ 10011111b = 10010000b
-00001111b ^ 10100000b = 10101111b
-00001111b ^ 10100001b = 10101110b
-00001111b ^ 10100010b = 10101101b
-00001111b ^ 10100011b = 10101100b
-00001111b ^ 10100100b = 10101011b
-00001111b ^ 10100101b = 10101010b
-00001111b ^ 10100110b = 10101001b
-00001111b ^ 10100111b = 10101000b
-00001111b ^ 10101000b = 10100111b
-00001111b ^ 10101001b = 10100110b
-00001111b ^ 10101010b = 10100101b
-00001111b ^ 10101011b = 10100100b
-00001111b ^ 10101100b = 10100011b
-00001111b ^ 10101101b = 10100010b
-00001111b ^ 10101110b = 10100001b
-00001111b ^ 10101111b = 10100000b
-00001111b ^ 10110000b = 10111111b
-00001111b ^ 10110001b = 10111110b
-00001111b ^ 10110010b = 10111101b
-00001111b ^ 10110011b = 10111100b
-00001111b ^ 10110100b = 10111011b
-00001111b ^ 10110101b = 10111010b
-00001111b ^ 10110110b = 10111001b
-00001111b ^ 10110111b = 10111000b
-00001111b ^ 10111000b = 10110111b
-00001111b ^ 10111001b = 10110110b
-00001111b ^ 10111010b = 10110101b
-00001111b ^ 10111011b = 10110100b
-00001111b ^ 10111100b = 10110011b
-00001111b ^ 10111101b = 10110010b
-00001111b ^ 10111110b = 10110001b
-00001111b ^ 10111111b = 10110000b
-00001111b ^ 11000000b = 11001111b
-00001111b ^ 11000001b = 11001110b
-00001111b ^ 11000010b = 11001101b
-00001111b ^ 11000011b = 11001100b
-00001111b ^ 11000100b = 11001011b
-00001111b ^ 11000101b = 11001010b
-00001111b ^ 11000110b = 11001001b
-00001111b ^ 11000111b = 11001000b
-00001111b ^ 11001000b = 11000111b
-00001111b ^ 11001001b = 11000110b
-00001111b ^ 11001010b = 11000101b
-00001111b ^ 11001011b = 11000100b
-00001111b ^ 11001100b = 11000011b
-00001111b ^ 11001101b = 11000010b
-00001111b ^ 11001110b = 11000001b
-00001111b ^ 11001111b = 11000000b
-00001111b ^ 11010000b = 11011111b
-00001111b ^ 11010001b = 11011110b
-00001111b ^ 11010010b = 11011101b
-00001111b ^ 11010011b = 11011100b
-00001111b ^ 11010100b = 11011011b
-00001111b ^ 11010101b = 11011010b
-00001111b ^ 11010110b = 11011001b
-00001111b ^ 11010111b = 11011000b
-00001111b ^ 11011000b = 11010111b
-00001111b ^ 11011001b = 11010110b
-00001111b ^ 11011010b = 11010101b
-00001111b ^ 11011011b = 11010100b
-00001111b ^ 11011100b = 11010011b
-00001111b ^ 11011101b = 11010010b
-00001111b ^ 11011110b = 11010001b
-00001111b ^ 11011111b = 11010000b
-00001111b ^ 11100000b = 11101111b
-00001111b ^ 11100001b = 11101110b
-00001111b ^ 11100010b = 11101101b
-00001111b ^ 11100011b = 11101100b
-00001111b ^ 11100100b = 11101011b
-00001111b ^ 11100101b = 11101010b
-00001111b ^ 11100110b = 11101001b
-00001111b ^ 11100111b = 11101000b
-00001111b ^ 11101000b = 11100111b
-00001111b ^ 11101001b = 11100110b
-00001111b ^ 11101010b = 11100101b
-00001111b ^ 11101011b = 11100100b
-00001111b ^ 11101100b = 11100011b
-00001111b ^ 11101101b = 11100010b
-00001111b ^ 11101110b = 11100001b
-00001111b ^ 11101111b = 11100000b
-00001111b ^ 11110000b = 11111111b
-00001111b ^ 11110001b = 11111110b
-00001111b ^ 11110010b = 11111101b
-00001111b ^ 11110011b = 11111100b
-00001111b ^ 11110100b = 11111011b
-00001111b ^ 11110101b = 11111010b
-00001111b ^ 11110110b = 11111001b
-00001111b ^ 11110111b = 11111000b
-00001111b ^ 11111000b = 11110111b
-00001111b ^ 11111001b = 11110110b
-00001111b ^ 11111010b = 11110101b
-00001111b ^ 11111011b = 11110100b
-00001111b ^ 11111100b = 11110011b
-00001111b ^ 11111101b = 11110010b
-00001111b ^ 11111110b = 11110001b
-00001111b ^ 11111111b = 11110000b
-00001111b ^ 00000000b = 00001111b
-00001111b ^ 00000001b = 00001110b
-00001111b ^ 00000010b = 00001101b
-00001111b ^ 00000011b = 00001100b
-00001111b ^ 00000100b = 00001011b
-00001111b ^ 00000101b = 00001010b
-00001111b ^ 00000110b = 00001001b
-00001111b ^ 00000111b = 00001000b
-00001111b ^ 00001000b = 00000111b
-00001111b ^ 00001001b = 00000110b
-00001111b ^ 00001010b = 00000101b
-00001111b ^ 00001011b = 00000100b
-00001111b ^ 00001100b = 00000011b
-00001111b ^ 00001101b = 00000010b
-00001111b ^ 00001110b = 00000001b
-00001111b ^ 00001111b = 00000000b
-00001111b ^ 00010000b = 00011111b
-00001111b ^ 00010001b = 00011110b
-00001111b ^ 00010010b = 00011101b
-00001111b ^ 00010011b = 00011100b
-00001111b ^ 00010100b = 00011011b
-00001111b ^ 00010101b = 00011010b
-00001111b ^ 00010110b = 00011001b
-00001111b ^ 00010111b = 00011000b
-00001111b ^ 00011000b = 00010111b
-00001111b ^ 00011001b = 00010110b
-00001111b ^ 00011010b = 00010101b
-00001111b ^ 00011011b = 00010100b
-00001111b ^ 00011100b = 00010011b
-00001111b ^ 00011101b = 00010010b
-00001111b ^ 00011110b = 00010001b
-00001111b ^ 00011111b = 00010000b
-00001111b ^ 00100000b = 00101111b
-00001111b ^ 00100001b = 00101110b
-00001111b ^ 00100010b = 00101101b
-00001111b ^ 00100011b = 00101100b
-00001111b ^ 00100100b = 00101011b
-00001111b ^ 00100101b = 00101010b
-00001111b ^ 00100110b = 00101001b
-00001111b ^ 00100111b = 00101000b
-00001111b ^ 00101000b = 00100111b
-00001111b ^ 00101001b = 00100110b
-00001111b ^ 00101010b = 00100101b
-00001111b ^ 00101011b = 00100100b
-00001111b ^ 00101100b = 00100011b
-00001111b ^ 00101101b = 00100010b
-00001111b ^ 00101110b = 00100001b
-00001111b ^ 00101111b = 00100000b
-00001111b ^ 00110000b = 00111111b
-00001111b ^ 00110001b = 00111110b
-00001111b ^ 00110010b = 00111101b
-00001111b ^ 00110011b = 00111100b
-00001111b ^ 00110100b = 00111011b
-00001111b ^ 00110101b = 00111010b
-00001111b ^ 00110110b = 00111001b
-00001111b ^ 00110111b = 00111000b
-00001111b ^ 00111000b = 00110111b
-00001111b ^ 00111001b = 00110110b
-00001111b ^ 00111010b = 00110101b
-00001111b ^ 00111011b = 00110100b
-00001111b ^ 00111100b = 00110011b
-00001111b ^ 00111101b = 00110010b
-00001111b ^ 00111110b = 00110001b
-00001111b ^ 00111111b = 00110000b
-00001111b ^ 01000000b = 01001111b
-00001111b ^ 01000001b = 01001110b
-00001111b ^ 01000010b = 01001101b
-00001111b ^ 01000011b = 01001100b
-00001111b ^ 01000100b = 01001011b
-00001111b ^ 01000101b = 01001010b
-00001111b ^ 01000110b = 01001001b
-00001111b ^ 01000111b = 01001000b
-00001111b ^ 01001000b = 01000111b
-00001111b ^ 01001001b = 01000110b
-00001111b ^ 01001010b = 01000101b
-00001111b ^ 01001011b = 01000100b
-00001111b ^ 01001100b = 01000011b
-00001111b ^ 01001101b = 01000010b
-00001111b ^ 01001110b = 01000001b
-00001111b ^ 01001111b = 01000000b
-00001111b ^ 01010000b = 01011111b
-00001111b ^ 01010001b = 01011110b
-00001111b ^ 01010010b = 01011101b
-00001111b ^ 01010011b = 01011100b
-00001111b ^ 01010100b = 01011011b
-00001111b ^ 01010101b = 01011010b
-00001111b ^ 01010110b = 01011001b
-00001111b ^ 01010111b = 01011000b
-00001111b ^ 01011000b = 01010111b
-00001111b ^ 01011001b = 01010110b
-00001111b ^ 01011010b = 01010101b
-00001111b ^ 01011011b = 01010100b
-00001111b ^ 01011100b = 01010011b
-00001111b ^ 01011101b = 01010010b
-00001111b ^ 01011110b = 01010001b
-00001111b ^ 01011111b = 01010000b
-00001111b ^ 01100000b = 01101111b
-00001111b ^ 01100001b = 01101110b
-00001111b ^ 01100010b = 01101101b
-00001111b ^ 01100011b = 01101100b
-00001111b ^ 01100100b = 01101011b
-00001111b ^ 01100101b = 01101010b
-00001111b ^ 01100110b = 01101001b
-00001111b ^ 01100111b = 01101000b
-00001111b ^ 01101000b = 01100111b
-00001111b ^ 01101001b = 01100110b
-00001111b ^ 01101010b = 01100101b
-00001111b ^ 01101011b = 01100100b
-00001111b ^ 01101100b = 01100011b
-00001111b ^ 01101101b = 01100010b
-00001111b ^ 01101110b = 01100001b
-00001111b ^ 01101111b = 01100000b
-00001111b ^ 01110000b = 01111111b
-00001111b ^ 01110001b = 01111110b
-00001111b ^ 01110010b = 01111101b
-00001111b ^ 01110011b = 01111100b
-00001111b ^ 01110100b = 01111011b
-00001111b ^ 01110101b = 01111010b
-00001111b ^ 01110110b = 01111001b
-00001111b ^ 01110111b = 01111000b
-00001111b ^ 01111000b = 01110111b
-00001111b ^ 01111001b = 01110110b
-00001111b ^ 01111010b = 01110101b
-00001111b ^ 01111011b = 01110100b
-00001111b ^ 01111100b = 01110011b
-00001111b ^ 01111101b = 01110010b
-00001111b ^ 01111110b = 01110001b
-00010000b ^ 10000000b = 10010000b
-00010000b ^ 10000001b = 10010001b
-00010000b ^ 10000010b = 10010010b
-00010000b ^ 10000011b = 10010011b
-00010000b ^ 10000100b = 10010100b
-00010000b ^ 10000101b = 10010101b
-00010000b ^ 10000110b = 10010110b
-00010000b ^ 10000111b = 10010111b
-00010000b ^ 10001000b = 10011000b
-00010000b ^ 10001001b = 10011001b
-00010000b ^ 10001010b = 10011010b
-00010000b ^ 10001011b = 10011011b
-00010000b ^ 10001100b = 10011100b
-00010000b ^ 10001101b = 10011101b
-00010000b ^ 10001110b = 10011110b
-00010000b ^ 10001111b = 10011111b
-00010000b ^ 10010000b = 10000000b
-00010000b ^ 10010001b = 10000001b
-00010000b ^ 10010010b = 10000010b
-00010000b ^ 10010011b = 10000011b
-00010000b ^ 10010100b = 10000100b
-00010000b ^ 10010101b = 10000101b
-00010000b ^ 10010110b = 10000110b
-00010000b ^ 10010111b = 10000111b
-00010000b ^ 10011000b = 10001000b
-00010000b ^ 10011001b = 10001001b
-00010000b ^ 10011010b = 10001010b
-00010000b ^ 10011011b = 10001011b
-00010000b ^ 10011100b = 10001100b
-00010000b ^ 10011101b = 10001101b
-00010000b ^ 10011110b = 10001110b
-00010000b ^ 10011111b = 10001111b
-00010000b ^ 10100000b = 10110000b
-00010000b ^ 10100001b = 10110001b
-00010000b ^ 10100010b = 10110010b
-00010000b ^ 10100011b = 10110011b
-00010000b ^ 10100100b = 10110100b
-00010000b ^ 10100101b = 10110101b
-00010000b ^ 10100110b = 10110110b
-00010000b ^ 10100111b = 10110111b
-00010000b ^ 10101000b = 10111000b
-00010000b ^ 10101001b = 10111001b
-00010000b ^ 10101010b = 10111010b
-00010000b ^ 10101011b = 10111011b
-00010000b ^ 10101100b = 10111100b
-00010000b ^ 10101101b = 10111101b
-00010000b ^ 10101110b = 10111110b
-00010000b ^ 10101111b = 10111111b
-00010000b ^ 10110000b = 10100000b
-00010000b ^ 10110001b = 10100001b
-00010000b ^ 10110010b = 10100010b
-00010000b ^ 10110011b = 10100011b
-00010000b ^ 10110100b = 10100100b
-00010000b ^ 10110101b = 10100101b
-00010000b ^ 10110110b = 10100110b
-00010000b ^ 10110111b = 10100111b
-00010000b ^ 10111000b = 10101000b
-00010000b ^ 10111001b = 10101001b
-00010000b ^ 10111010b = 10101010b
-00010000b ^ 10111011b = 10101011b
-00010000b ^ 10111100b = 10101100b
-00010000b ^ 10111101b = 10101101b
-00010000b ^ 10111110b = 10101110b
-00010000b ^ 10111111b = 10101111b
-00010000b ^ 11000000b = 11010000b
-00010000b ^ 11000001b = 11010001b
-00010000b ^ 11000010b = 11010010b
-00010000b ^ 11000011b = 11010011b
-00010000b ^ 11000100b = 11010100b
-00010000b ^ 11000101b = 11010101b
-00010000b ^ 11000110b = 11010110b
-00010000b ^ 11000111b = 11010111b
-00010000b ^ 11001000b = 11011000b
-00010000b ^ 11001001b = 11011001b
-00010000b ^ 11001010b = 11011010b
-00010000b ^ 11001011b = 11011011b
-00010000b ^ 11001100b = 11011100b
-00010000b ^ 11001101b = 11011101b
-00010000b ^ 11001110b = 11011110b
-00010000b ^ 11001111b = 11011111b
-00010000b ^ 11010000b = 11000000b
-00010000b ^ 11010001b = 11000001b
-00010000b ^ 11010010b = 11000010b
-00010000b ^ 11010011b = 11000011b
-00010000b ^ 11010100b = 11000100b
-00010000b ^ 11010101b = 11000101b
-00010000b ^ 11010110b = 11000110b
-00010000b ^ 11010111b = 11000111b
-00010000b ^ 11011000b = 11001000b
-00010000b ^ 11011001b = 11001001b
-00010000b ^ 11011010b = 11001010b
-00010000b ^ 11011011b = 11001011b
-00010000b ^ 11011100b = 11001100b
-00010000b ^ 11011101b = 11001101b
-00010000b ^ 11011110b = 11001110b
-00010000b ^ 11011111b = 11001111b
-00010000b ^ 11100000b = 11110000b
-00010000b ^ 11100001b = 11110001b
-00010000b ^ 11100010b = 11110010b
-00010000b ^ 11100011b = 11110011b
-00010000b ^ 11100100b = 11110100b
-00010000b ^ 11100101b = 11110101b
-00010000b ^ 11100110b = 11110110b
-00010000b ^ 11100111b = 11110111b
-00010000b ^ 11101000b = 11111000b
-00010000b ^ 11101001b = 11111001b
-00010000b ^ 11101010b = 11111010b
-00010000b ^ 11101011b = 11111011b
-00010000b ^ 11101100b = 11111100b
-00010000b ^ 11101101b = 11111101b
-00010000b ^ 11101110b = 11111110b
-00010000b ^ 11101111b = 11111111b
-00010000b ^ 11110000b = 11100000b
-00010000b ^ 11110001b = 11100001b
-00010000b ^ 11110010b = 11100010b
-00010000b ^ 11110011b = 11100011b
-00010000b ^ 11110100b = 11100100b
-00010000b ^ 11110101b = 11100101b
-00010000b ^ 11110110b = 11100110b
-00010000b ^ 11110111b = 11100111b
-00010000b ^ 11111000b = 11101000b
-00010000b ^ 11111001b = 11101001b
-00010000b ^ 11111010b = 11101010b
-00010000b ^ 11111011b = 11101011b
-00010000b ^ 11111100b = 11101100b
-00010000b ^ 11111101b = 11101101b
-00010000b ^ 11111110b = 11101110b
-00010000b ^ 11111111b = 11101111b
-00010000b ^ 00000000b = 00010000b
-00010000b ^ 00000001b = 00010001b
-00010000b ^ 00000010b = 00010010b
-00010000b ^ 00000011b = 00010011b
-00010000b ^ 00000100b = 00010100b
-00010000b ^ 00000101b = 00010101b
-00010000b ^ 00000110b = 00010110b
-00010000b ^ 00000111b = 00010111b
-00010000b ^ 00001000b = 00011000b
-00010000b ^ 00001001b = 00011001b
-00010000b ^ 00001010b = 00011010b
-00010000b ^ 00001011b = 00011011b
-00010000b ^ 00001100b = 00011100b
-00010000b ^ 00001101b = 00011101b
-00010000b ^ 00001110b = 00011110b
-00010000b ^ 00001111b = 00011111b
-00010000b ^ 00010000b = 00000000b
-00010000b ^ 00010001b = 00000001b
-00010000b ^ 00010010b = 00000010b
-00010000b ^ 00010011b = 00000011b
-00010000b ^ 00010100b = 00000100b
-00010000b ^ 00010101b = 00000101b
-00010000b ^ 00010110b = 00000110b
-00010000b ^ 00010111b = 00000111b
-00010000b ^ 00011000b = 00001000b
-00010000b ^ 00011001b = 00001001b
-00010000b ^ 00011010b = 00001010b
-00010000b ^ 00011011b = 00001011b
-00010000b ^ 00011100b = 00001100b
-00010000b ^ 00011101b = 00001101b
-00010000b ^ 00011110b = 00001110b
-00010000b ^ 00011111b = 00001111b
-00010000b ^ 00100000b = 00110000b
-00010000b ^ 00100001b = 00110001b
-00010000b ^ 00100010b = 00110010b
-00010000b ^ 00100011b = 00110011b
-00010000b ^ 00100100b = 00110100b
-00010000b ^ 00100101b = 00110101b
-00010000b ^ 00100110b = 00110110b
-00010000b ^ 00100111b = 00110111b
-00010000b ^ 00101000b = 00111000b
-00010000b ^ 00101001b = 00111001b
-00010000b ^ 00101010b = 00111010b
-00010000b ^ 00101011b = 00111011b
-00010000b ^ 00101100b = 00111100b
-00010000b ^ 00101101b = 00111101b
-00010000b ^ 00101110b = 00111110b
-00010000b ^ 00101111b = 00111111b
-00010000b ^ 00110000b = 00100000b
-00010000b ^ 00110001b = 00100001b
-00010000b ^ 00110010b = 00100010b
-00010000b ^ 00110011b = 00100011b
-00010000b ^ 00110100b = 00100100b
-00010000b ^ 00110101b = 00100101b
-00010000b ^ 00110110b = 00100110b
-00010000b ^ 00110111b = 00100111b
-00010000b ^ 00111000b = 00101000b
-00010000b ^ 00111001b = 00101001b
-00010000b ^ 00111010b = 00101010b
-00010000b ^ 00111011b = 00101011b
-00010000b ^ 00111100b = 00101100b
-00010000b ^ 00111101b = 00101101b
-00010000b ^ 00111110b = 00101110b
-00010000b ^ 00111111b = 00101111b
-00010000b ^ 01000000b = 01010000b
-00010000b ^ 01000001b = 01010001b
-00010000b ^ 01000010b = 01010010b
-00010000b ^ 01000011b = 01010011b
-00010000b ^ 01000100b = 01010100b
-00010000b ^ 01000101b = 01010101b
-00010000b ^ 01000110b = 01010110b
-00010000b ^ 01000111b = 01010111b
-00010000b ^ 01001000b = 01011000b
-00010000b ^ 01001001b = 01011001b
-00010000b ^ 01001010b = 01011010b
-00010000b ^ 01001011b = 01011011b
-00010000b ^ 01001100b = 01011100b
-00010000b ^ 01001101b = 01011101b
-00010000b ^ 01001110b = 01011110b
-00010000b ^ 01001111b = 01011111b
-00010000b ^ 01010000b = 01000000b
-00010000b ^ 01010001b = 01000001b
-00010000b ^ 01010010b = 01000010b
-00010000b ^ 01010011b = 01000011b
-00010000b ^ 01010100b = 01000100b
-00010000b ^ 01010101b = 01000101b
-00010000b ^ 01010110b = 01000110b
-00010000b ^ 01010111b = 01000111b
-00010000b ^ 01011000b = 01001000b
-00010000b ^ 01011001b = 01001001b
-00010000b ^ 01011010b = 01001010b
-00010000b ^ 01011011b = 01001011b
-00010000b ^ 01011100b = 01001100b
-00010000b ^ 01011101b = 01001101b
-00010000b ^ 01011110b = 01001110b
-00010000b ^ 01011111b = 01001111b
-00010000b ^ 01100000b = 01110000b
-00010000b ^ 01100001b = 01110001b
-00010000b ^ 01100010b = 01110010b
-00010000b ^ 01100011b = 01110011b
-00010000b ^ 01100100b = 01110100b
-00010000b ^ 01100101b = 01110101b
-00010000b ^ 01100110b = 01110110b
-00010000b ^ 01100111b = 01110111b
-00010000b ^ 01101000b = 01111000b
-00010000b ^ 01101001b = 01111001b
-00010000b ^ 01101010b = 01111010b
-00010000b ^ 01101011b = 01111011b
-00010000b ^ 01101100b = 01111100b
-00010000b ^ 01101101b = 01111101b
-00010000b ^ 01101110b = 01111110b
-00010000b ^ 01101111b = 01111111b
-00010000b ^ 01110000b = 01100000b
-00010000b ^ 01110001b = 01100001b
-00010000b ^ 01110010b = 01100010b
-00010000b ^ 01110011b = 01100011b
-00010000b ^ 01110100b = 01100100b
-00010000b ^ 01110101b = 01100101b
-00010000b ^ 01110110b = 01100110b
-00010000b ^ 01110111b = 01100111b
-00010000b ^ 01111000b = 01101000b
-00010000b ^ 01111001b = 01101001b
-00010000b ^ 01111010b = 01101010b
-00010000b ^ 01111011b = 01101011b
-00010000b ^ 01111100b = 01101100b
-00010000b ^ 01111101b = 01101101b
-00010000b ^ 01111110b = 01101110b
-00010001b ^ 10000000b = 10010001b
-00010001b ^ 10000001b = 10010000b
-00010001b ^ 10000010b = 10010011b
-00010001b ^ 10000011b = 10010010b
-00010001b ^ 10000100b = 10010101b
-00010001b ^ 10000101b = 10010100b
-00010001b ^ 10000110b = 10010111b
-00010001b ^ 10000111b = 10010110b
-00010001b ^ 10001000b = 10011001b
-00010001b ^ 10001001b = 10011000b
-00010001b ^ 10001010b = 10011011b
-00010001b ^ 10001011b = 10011010b
-00010001b ^ 10001100b = 10011101b
-00010001b ^ 10001101b = 10011100b
-00010001b ^ 10001110b = 10011111b
-00010001b ^ 10001111b = 10011110b
-00010001b ^ 10010000b = 10000001b
-00010001b ^ 10010001b = 10000000b
-00010001b ^ 10010010b = 10000011b
-00010001b ^ 10010011b = 10000010b
-00010001b ^ 10010100b = 10000101b
-00010001b ^ 10010101b = 10000100b
-00010001b ^ 10010110b = 10000111b
-00010001b ^ 10010111b = 10000110b
-00010001b ^ 10011000b = 10001001b
-00010001b ^ 10011001b = 10001000b
-00010001b ^ 10011010b = 10001011b
-00010001b ^ 10011011b = 10001010b
-00010001b ^ 10011100b = 10001101b
-00010001b ^ 10011101b = 10001100b
-00010001b ^ 10011110b = 10001111b
-00010001b ^ 10011111b = 10001110b
-00010001b ^ 10100000b = 10110001b
-00010001b ^ 10100001b = 10110000b
-00010001b ^ 10100010b = 10110011b
-00010001b ^ 10100011b = 10110010b
-00010001b ^ 10100100b = 10110101b
-00010001b ^ 10100101b = 10110100b
-00010001b ^ 10100110b = 10110111b
-00010001b ^ 10100111b = 10110110b
-00010001b ^ 10101000b = 10111001b
-00010001b ^ 10101001b = 10111000b
-00010001b ^ 10101010b = 10111011b
-00010001b ^ 10101011b = 10111010b
-00010001b ^ 10101100b = 10111101b
-00010001b ^ 10101101b = 10111100b
-00010001b ^ 10101110b = 10111111b
-00010001b ^ 10101111b = 10111110b
-00010001b ^ 10110000b = 10100001b
-00010001b ^ 10110001b = 10100000b
-00010001b ^ 10110010b = 10100011b
-00010001b ^ 10110011b = 10100010b
-00010001b ^ 10110100b = 10100101b
-00010001b ^ 10110101b = 10100100b
-00010001b ^ 10110110b = 10100111b
-00010001b ^ 10110111b = 10100110b
-00010001b ^ 10111000b = 10101001b
-00010001b ^ 10111001b = 10101000b
-00010001b ^ 10111010b = 10101011b
-00010001b ^ 10111011b = 10101010b
-00010001b ^ 10111100b = 10101101b
-00010001b ^ 10111101b = 10101100b
-00010001b ^ 10111110b = 10101111b
-00010001b ^ 10111111b = 10101110b
-00010001b ^ 11000000b = 11010001b
-00010001b ^ 11000001b = 11010000b
-00010001b ^ 11000010b = 11010011b
-00010001b ^ 11000011b = 11010010b
-00010001b ^ 11000100b = 11010101b
-00010001b ^ 11000101b = 11010100b
-00010001b ^ 11000110b = 11010111b
-00010001b ^ 11000111b = 11010110b
-00010001b ^ 11001000b = 11011001b
-00010001b ^ 11001001b = 11011000b
-00010001b ^ 11001010b = 11011011b
-00010001b ^ 11001011b = 11011010b
-00010001b ^ 11001100b = 11011101b
-00010001b ^ 11001101b = 11011100b
-00010001b ^ 11001110b = 11011111b
-00010001b ^ 11001111b = 11011110b
-00010001b ^ 11010000b = 11000001b
-00010001b ^ 11010001b = 11000000b
-00010001b ^ 11010010b = 11000011b
-00010001b ^ 11010011b = 11000010b
-00010001b ^ 11010100b = 11000101b
-00010001b ^ 11010101b = 11000100b
-00010001b ^ 11010110b = 11000111b
-00010001b ^ 11010111b = 11000110b
-00010001b ^ 11011000b = 11001001b
-00010001b ^ 11011001b = 11001000b
-00010001b ^ 11011010b = 11001011b
-00010001b ^ 11011011b = 11001010b
-00010001b ^ 11011100b = 11001101b
-00010001b ^ 11011101b = 11001100b
-00010001b ^ 11011110b = 11001111b
-00010001b ^ 11011111b = 11001110b
-00010001b ^ 11100000b = 11110001b
-00010001b ^ 11100001b = 11110000b
-00010001b ^ 11100010b = 11110011b
-00010001b ^ 11100011b = 11110010b
-00010001b ^ 11100100b = 11110101b
-00010001b ^ 11100101b = 11110100b
-00010001b ^ 11100110b = 11110111b
-00010001b ^ 11100111b = 11110110b
-00010001b ^ 11101000b = 11111001b
-00010001b ^ 11101001b = 11111000b
-00010001b ^ 11101010b = 11111011b
-00010001b ^ 11101011b = 11111010b
-00010001b ^ 11101100b = 11111101b
-00010001b ^ 11101101b = 11111100b
-00010001b ^ 11101110b = 11111111b
-00010001b ^ 11101111b = 11111110b
-00010001b ^ 11110000b = 11100001b
-00010001b ^ 11110001b = 11100000b
-00010001b ^ 11110010b = 11100011b
-00010001b ^ 11110011b = 11100010b
-00010001b ^ 11110100b = 11100101b
-00010001b ^ 11110101b = 11100100b
-00010001b ^ 11110110b = 11100111b
-00010001b ^ 11110111b = 11100110b
-00010001b ^ 11111000b = 11101001b
-00010001b ^ 11111001b = 11101000b
-00010001b ^ 11111010b = 11101011b
-00010001b ^ 11111011b = 11101010b
-00010001b ^ 11111100b = 11101101b
-00010001b ^ 11111101b = 11101100b
-00010001b ^ 11111110b = 11101111b
-00010001b ^ 11111111b = 11101110b
-00010001b ^ 00000000b = 00010001b
-00010001b ^ 00000001b = 00010000b
-00010001b ^ 00000010b = 00010011b
-00010001b ^ 00000011b = 00010010b
-00010001b ^ 00000100b = 00010101b
-00010001b ^ 00000101b = 00010100b
-00010001b ^ 00000110b = 00010111b
-00010001b ^ 00000111b = 00010110b
-00010001b ^ 00001000b = 00011001b
-00010001b ^ 00001001b = 00011000b
-00010001b ^ 00001010b = 00011011b
-00010001b ^ 00001011b = 00011010b
-00010001b ^ 00001100b = 00011101b
-00010001b ^ 00001101b = 00011100b
-00010001b ^ 00001110b = 00011111b
-00010001b ^ 00001111b = 00011110b
-00010001b ^ 00010000b = 00000001b
-00010001b ^ 00010001b = 00000000b
-00010001b ^ 00010010b = 00000011b
-00010001b ^ 00010011b = 00000010b
-00010001b ^ 00010100b = 00000101b
-00010001b ^ 00010101b = 00000100b
-00010001b ^ 00010110b = 00000111b
-00010001b ^ 00010111b = 00000110b
-00010001b ^ 00011000b = 00001001b
-00010001b ^ 00011001b = 00001000b
-00010001b ^ 00011010b = 00001011b
-00010001b ^ 00011011b = 00001010b
-00010001b ^ 00011100b = 00001101b
-00010001b ^ 00011101b = 00001100b
-00010001b ^ 00011110b = 00001111b
-00010001b ^ 00011111b = 00001110b
-00010001b ^ 00100000b = 00110001b
-00010001b ^ 00100001b = 00110000b
-00010001b ^ 00100010b = 00110011b
-00010001b ^ 00100011b = 00110010b
-00010001b ^ 00100100b = 00110101b
-00010001b ^ 00100101b = 00110100b
-00010001b ^ 00100110b = 00110111b
-00010001b ^ 00100111b = 00110110b
-00010001b ^ 00101000b = 00111001b
-00010001b ^ 00101001b = 00111000b
-00010001b ^ 00101010b = 00111011b
-00010001b ^ 00101011b = 00111010b
-00010001b ^ 00101100b = 00111101b
-00010001b ^ 00101101b = 00111100b
-00010001b ^ 00101110b = 00111111b
-00010001b ^ 00101111b = 00111110b
-00010001b ^ 00110000b = 00100001b
-00010001b ^ 00110001b = 00100000b
-00010001b ^ 00110010b = 00100011b
-00010001b ^ 00110011b = 00100010b
-00010001b ^ 00110100b = 00100101b
-00010001b ^ 00110101b = 00100100b
-00010001b ^ 00110110b = 00100111b
-00010001b ^ 00110111b = 00100110b
-00010001b ^ 00111000b = 00101001b
-00010001b ^ 00111001b = 00101000b
-00010001b ^ 00111010b = 00101011b
-00010001b ^ 00111011b = 00101010b
-00010001b ^ 00111100b = 00101101b
-00010001b ^ 00111101b = 00101100b
-00010001b ^ 00111110b = 00101111b
-00010001b ^ 00111111b = 00101110b
-00010001b ^ 01000000b = 01010001b
-00010001b ^ 01000001b = 01010000b
-00010001b ^ 01000010b = 01010011b
-00010001b ^ 01000011b = 01010010b
-00010001b ^ 01000100b = 01010101b
-00010001b ^ 01000101b = 01010100b
-00010001b ^ 01000110b = 01010111b
-00010001b ^ 01000111b = 01010110b
-00010001b ^ 01001000b = 01011001b
-00010001b ^ 01001001b = 01011000b
-00010001b ^ 01001010b = 01011011b
-00010001b ^ 01001011b = 01011010b
-00010001b ^ 01001100b = 01011101b
-00010001b ^ 01001101b = 01011100b
-00010001b ^ 01001110b = 01011111b
-00010001b ^ 01001111b = 01011110b
-00010001b ^ 01010000b = 01000001b
-00010001b ^ 01010001b = 01000000b
-00010001b ^ 01010010b = 01000011b
-00010001b ^ 01010011b = 01000010b
-00010001b ^ 01010100b = 01000101b
-00010001b ^ 01010101b = 01000100b
-00010001b ^ 01010110b = 01000111b
-00010001b ^ 01010111b = 01000110b
-00010001b ^ 01011000b = 01001001b
-00010001b ^ 01011001b = 01001000b
-00010001b ^ 01011010b = 01001011b
-00010001b ^ 01011011b = 01001010b
-00010001b ^ 01011100b = 01001101b
-00010001b ^ 01011101b = 01001100b
-00010001b ^ 01011110b = 01001111b
-00010001b ^ 01011111b = 01001110b
-00010001b ^ 01100000b = 01110001b
-00010001b ^ 01100001b = 01110000b
-00010001b ^ 01100010b = 01110011b
-00010001b ^ 01100011b = 01110010b
-00010001b ^ 01100100b = 01110101b
-00010001b ^ 01100101b = 01110100b
-00010001b ^ 01100110b = 01110111b
-00010001b ^ 01100111b = 01110110b
-00010001b ^ 01101000b = 01111001b
-00010001b ^ 01101001b = 01111000b
-00010001b ^ 01101010b = 01111011b
-00010001b ^ 01101011b = 01111010b
-00010001b ^ 01101100b = 01111101b
-00010001b ^ 01101101b = 01111100b
-00010001b ^ 01101110b = 01111111b
-00010001b ^ 01101111b = 01111110b
-00010001b ^ 01110000b = 01100001b
-00010001b ^ 01110001b = 01100000b
-00010001b ^ 01110010b = 01100011b
-00010001b ^ 01110011b = 01100010b
-00010001b ^ 01110100b = 01100101b
-00010001b ^ 01110101b = 01100100b
-00010001b ^ 01110110b = 01100111b
-00010001b ^ 01110111b = 01100110b
-00010001b ^ 01111000b = 01101001b
-00010001b ^ 01111001b = 01101000b
-00010001b ^ 01111010b = 01101011b
-00010001b ^ 01111011b = 01101010b
-00010001b ^ 01111100b = 01101101b
-00010001b ^ 01111101b = 01101100b
-00010001b ^ 01111110b = 01101111b
-00010010b ^ 10000000b = 10010010b
-00010010b ^ 10000001b = 10010011b
-00010010b ^ 10000010b = 10010000b
-00010010b ^ 10000011b = 10010001b
-00010010b ^ 10000100b = 10010110b
-00010010b ^ 10000101b = 10010111b
-00010010b ^ 10000110b = 10010100b
-00010010b ^ 10000111b = 10010101b
-00010010b ^ 10001000b = 10011010b
-00010010b ^ 10001001b = 10011011b
-00010010b ^ 10001010b = 10011000b
-00010010b ^ 10001011b = 10011001b
-00010010b ^ 10001100b = 10011110b
-00010010b ^ 10001101b = 10011111b
-00010010b ^ 10001110b = 10011100b
-00010010b ^ 10001111b = 10011101b
-00010010b ^ 10010000b = 10000010b
-00010010b ^ 10010001b = 10000011b
-00010010b ^ 10010010b = 10000000b
-00010010b ^ 10010011b = 10000001b
-00010010b ^ 10010100b = 10000110b
-00010010b ^ 10010101b = 10000111b
-00010010b ^ 10010110b = 10000100b
-00010010b ^ 10010111b = 10000101b
-00010010b ^ 10011000b = 10001010b
-00010010b ^ 10011001b = 10001011b
-00010010b ^ 10011010b = 10001000b
-00010010b ^ 10011011b = 10001001b
-00010010b ^ 10011100b = 10001110b
-00010010b ^ 10011101b = 10001111b
-00010010b ^ 10011110b = 10001100b
-00010010b ^ 10011111b = 10001101b
-00010010b ^ 10100000b = 10110010b
-00010010b ^ 10100001b = 10110011b
-00010010b ^ 10100010b = 10110000b
-00010010b ^ 10100011b = 10110001b
-00010010b ^ 10100100b = 10110110b
-00010010b ^ 10100101b = 10110111b
-00010010b ^ 10100110b = 10110100b
-00010010b ^ 10100111b = 10110101b
-00010010b ^ 10101000b = 10111010b
-00010010b ^ 10101001b = 10111011b
-00010010b ^ 10101010b = 10111000b
-00010010b ^ 10101011b = 10111001b
-00010010b ^ 10101100b = 10111110b
-00010010b ^ 10101101b = 10111111b
-00010010b ^ 10101110b = 10111100b
-00010010b ^ 10101111b = 10111101b
-00010010b ^ 10110000b = 10100010b
-00010010b ^ 10110001b = 10100011b
-00010010b ^ 10110010b = 10100000b
-00010010b ^ 10110011b = 10100001b
-00010010b ^ 10110100b = 10100110b
-00010010b ^ 10110101b = 10100111b
-00010010b ^ 10110110b = 10100100b
-00010010b ^ 10110111b = 10100101b
-00010010b ^ 10111000b = 10101010b
-00010010b ^ 10111001b = 10101011b
-00010010b ^ 10111010b = 10101000b
-00010010b ^ 10111011b = 10101001b
-00010010b ^ 10111100b = 10101110b
-00010010b ^ 10111101b = 10101111b
-00010010b ^ 10111110b = 10101100b
-00010010b ^ 10111111b = 10101101b
-00010010b ^ 11000000b = 11010010b
-00010010b ^ 11000001b = 11010011b
-00010010b ^ 11000010b = 11010000b
-00010010b ^ 11000011b = 11010001b
-00010010b ^ 11000100b = 11010110b
-00010010b ^ 11000101b = 11010111b
-00010010b ^ 11000110b = 11010100b
-00010010b ^ 11000111b = 11010101b
-00010010b ^ 11001000b = 11011010b
-00010010b ^ 11001001b = 11011011b
-00010010b ^ 11001010b = 11011000b
-00010010b ^ 11001011b = 11011001b
-00010010b ^ 11001100b = 11011110b
-00010010b ^ 11001101b = 11011111b
-00010010b ^ 11001110b = 11011100b
-00010010b ^ 11001111b = 11011101b
-00010010b ^ 11010000b = 11000010b
-00010010b ^ 11010001b = 11000011b
-00010010b ^ 11010010b = 11000000b
-00010010b ^ 11010011b = 11000001b
-00010010b ^ 11010100b = 11000110b
-00010010b ^ 11010101b = 11000111b
-00010010b ^ 11010110b = 11000100b
-00010010b ^ 11010111b = 11000101b
-00010010b ^ 11011000b = 11001010b
-00010010b ^ 11011001b = 11001011b
-00010010b ^ 11011010b = 11001000b
-00010010b ^ 11011011b = 11001001b
-00010010b ^ 11011100b = 11001110b
-00010010b ^ 11011101b = 11001111b
-00010010b ^ 11011110b = 11001100b
-00010010b ^ 11011111b = 11001101b
-00010010b ^ 11100000b = 11110010b
-00010010b ^ 11100001b = 11110011b
-00010010b ^ 11100010b = 11110000b
-00010010b ^ 11100011b = 11110001b
-00010010b ^ 11100100b = 11110110b
-00010010b ^ 11100101b = 11110111b
-00010010b ^ 11100110b = 11110100b
-00010010b ^ 11100111b = 11110101b
-00010010b ^ 11101000b = 11111010b
-00010010b ^ 11101001b = 11111011b
-00010010b ^ 11101010b = 11111000b
-00010010b ^ 11101011b = 11111001b
-00010010b ^ 11101100b = 11111110b
-00010010b ^ 11101101b = 11111111b
-00010010b ^ 11101110b = 11111100b
-00010010b ^ 11101111b = 11111101b
-00010010b ^ 11110000b = 11100010b
-00010010b ^ 11110001b = 11100011b
-00010010b ^ 11110010b = 11100000b
-00010010b ^ 11110011b = 11100001b
-00010010b ^ 11110100b = 11100110b
-00010010b ^ 11110101b = 11100111b
-00010010b ^ 11110110b = 11100100b
-00010010b ^ 11110111b = 11100101b
-00010010b ^ 11111000b = 11101010b
-00010010b ^ 11111001b = 11101011b
-00010010b ^ 11111010b = 11101000b
-00010010b ^ 11111011b = 11101001b
-00010010b ^ 11111100b = 11101110b
-00010010b ^ 11111101b = 11101111b
-00010010b ^ 11111110b = 11101100b
-00010010b ^ 11111111b = 11101101b
-00010010b ^ 00000000b = 00010010b
-00010010b ^ 00000001b = 00010011b
-00010010b ^ 00000010b = 00010000b
-00010010b ^ 00000011b = 00010001b
-00010010b ^ 00000100b = 00010110b
-00010010b ^ 00000101b = 00010111b
-00010010b ^ 00000110b = 00010100b
-00010010b ^ 00000111b = 00010101b
-00010010b ^ 00001000b = 00011010b
-00010010b ^ 00001001b = 00011011b
-00010010b ^ 00001010b = 00011000b
-00010010b ^ 00001011b = 00011001b
-00010010b ^ 00001100b = 00011110b
-00010010b ^ 00001101b = 00011111b
-00010010b ^ 00001110b = 00011100b
-00010010b ^ 00001111b = 00011101b
-00010010b ^ 00010000b = 00000010b
-00010010b ^ 00010001b = 00000011b
-00010010b ^ 00010010b = 00000000b
-00010010b ^ 00010011b = 00000001b
-00010010b ^ 00010100b = 00000110b
-00010010b ^ 00010101b = 00000111b
-00010010b ^ 00010110b = 00000100b
-00010010b ^ 00010111b = 00000101b
-00010010b ^ 00011000b = 00001010b
-00010010b ^ 00011001b = 00001011b
-00010010b ^ 00011010b = 00001000b
-00010010b ^ 00011011b = 00001001b
-00010010b ^ 00011100b = 00001110b
-00010010b ^ 00011101b = 00001111b
-00010010b ^ 00011110b = 00001100b
-00010010b ^ 00011111b = 00001101b
-00010010b ^ 00100000b = 00110010b
-00010010b ^ 00100001b = 00110011b
-00010010b ^ 00100010b = 00110000b
-00010010b ^ 00100011b = 00110001b
-00010010b ^ 00100100b = 00110110b
-00010010b ^ 00100101b = 00110111b
-00010010b ^ 00100110b = 00110100b
-00010010b ^ 00100111b = 00110101b
-00010010b ^ 00101000b = 00111010b
-00010010b ^ 00101001b = 00111011b
-00010010b ^ 00101010b = 00111000b
-00010010b ^ 00101011b = 00111001b
-00010010b ^ 00101100b = 00111110b
-00010010b ^ 00101101b = 00111111b
-00010010b ^ 00101110b = 00111100b
-00010010b ^ 00101111b = 00111101b
-00010010b ^ 00110000b = 00100010b
-00010010b ^ 00110001b = 00100011b
-00010010b ^ 00110010b = 00100000b
-00010010b ^ 00110011b = 00100001b
-00010010b ^ 00110100b = 00100110b
-00010010b ^ 00110101b = 00100111b
-00010010b ^ 00110110b = 00100100b
-00010010b ^ 00110111b = 00100101b
-00010010b ^ 00111000b = 00101010b
-00010010b ^ 00111001b = 00101011b
-00010010b ^ 00111010b = 00101000b
-00010010b ^ 00111011b = 00101001b
-00010010b ^ 00111100b = 00101110b
-00010010b ^ 00111101b = 00101111b
-00010010b ^ 00111110b = 00101100b
-00010010b ^ 00111111b = 00101101b
-00010010b ^ 01000000b = 01010010b
-00010010b ^ 01000001b = 01010011b
-00010010b ^ 01000010b = 01010000b
-00010010b ^ 01000011b = 01010001b
-00010010b ^ 01000100b = 01010110b
-00010010b ^ 01000101b = 01010111b
-00010010b ^ 01000110b = 01010100b
-00010010b ^ 01000111b = 01010101b
-00010010b ^ 01001000b = 01011010b
-00010010b ^ 01001001b = 01011011b
-00010010b ^ 01001010b = 01011000b
-00010010b ^ 01001011b = 01011001b
-00010010b ^ 01001100b = 01011110b
-00010010b ^ 01001101b = 01011111b
-00010010b ^ 01001110b = 01011100b
-00010010b ^ 01001111b = 01011101b
-00010010b ^ 01010000b = 01000010b
-00010010b ^ 01010001b = 01000011b
-00010010b ^ 01010010b = 01000000b
-00010010b ^ 01010011b = 01000001b
-00010010b ^ 01010100b = 01000110b
-00010010b ^ 01010101b = 01000111b
-00010010b ^ 01010110b = 01000100b
-00010010b ^ 01010111b = 01000101b
-00010010b ^ 01011000b = 01001010b
-00010010b ^ 01011001b = 01001011b
-00010010b ^ 01011010b = 01001000b
-00010010b ^ 01011011b = 01001001b
-00010010b ^ 01011100b = 01001110b
-00010010b ^ 01011101b = 01001111b
-00010010b ^ 01011110b = 01001100b
-00010010b ^ 01011111b = 01001101b
-00010010b ^ 01100000b = 01110010b
-00010010b ^ 01100001b = 01110011b
-00010010b ^ 01100010b = 01110000b
-00010010b ^ 01100011b = 01110001b
-00010010b ^ 01100100b = 01110110b
-00010010b ^ 01100101b = 01110111b
-00010010b ^ 01100110b = 01110100b
-00010010b ^ 01100111b = 01110101b
-00010010b ^ 01101000b = 01111010b
-00010010b ^ 01101001b = 01111011b
-00010010b ^ 01101010b = 01111000b
-00010010b ^ 01101011b = 01111001b
-00010010b ^ 01101100b = 01111110b
-00010010b ^ 01101101b = 01111111b
-00010010b ^ 01101110b = 01111100b
-00010010b ^ 01101111b = 01111101b
-00010010b ^ 01110000b = 01100010b
-00010010b ^ 01110001b = 01100011b
-00010010b ^ 01110010b = 01100000b
-00010010b ^ 01110011b = 01100001b
-00010010b ^ 01110100b = 01100110b
-00010010b ^ 01110101b = 01100111b
-00010010b ^ 01110110b = 01100100b
-00010010b ^ 01110111b = 01100101b
-00010010b ^ 01111000b = 01101010b
-00010010b ^ 01111001b = 01101011b
-00010010b ^ 01111010b = 01101000b
-00010010b ^ 01111011b = 01101001b
-00010010b ^ 01111100b = 01101110b
-00010010b ^ 01111101b = 01101111b
-00010010b ^ 01111110b = 01101100b
-00010011b ^ 10000000b = 10010011b
-00010011b ^ 10000001b = 10010010b
-00010011b ^ 10000010b = 10010001b
-00010011b ^ 10000011b = 10010000b
-00010011b ^ 10000100b = 10010111b
-00010011b ^ 10000101b = 10010110b
-00010011b ^ 10000110b = 10010101b
-00010011b ^ 10000111b = 10010100b
-00010011b ^ 10001000b = 10011011b
-00010011b ^ 10001001b = 10011010b
-00010011b ^ 10001010b = 10011001b
-00010011b ^ 10001011b = 10011000b
-00010011b ^ 10001100b = 10011111b
-00010011b ^ 10001101b = 10011110b
-00010011b ^ 10001110b = 10011101b
-00010011b ^ 10001111b = 10011100b
-00010011b ^ 10010000b = 10000011b
-00010011b ^ 10010001b = 10000010b
-00010011b ^ 10010010b = 10000001b
-00010011b ^ 10010011b = 10000000b
-00010011b ^ 10010100b = 10000111b
-00010011b ^ 10010101b = 10000110b
-00010011b ^ 10010110b = 10000101b
-00010011b ^ 10010111b = 10000100b
-00010011b ^ 10011000b = 10001011b
-00010011b ^ 10011001b = 10001010b
-00010011b ^ 10011010b = 10001001b
-00010011b ^ 10011011b = 10001000b
-00010011b ^ 10011100b = 10001111b
-00010011b ^ 10011101b = 10001110b
-00010011b ^ 10011110b = 10001101b
-00010011b ^ 10011111b = 10001100b
-00010011b ^ 10100000b = 10110011b
-00010011b ^ 10100001b = 10110010b
-00010011b ^ 10100010b = 10110001b
-00010011b ^ 10100011b = 10110000b
-00010011b ^ 10100100b = 10110111b
-00010011b ^ 10100101b = 10110110b
-00010011b ^ 10100110b = 10110101b
-00010011b ^ 10100111b = 10110100b
-00010011b ^ 10101000b = 10111011b
-00010011b ^ 10101001b = 10111010b
-00010011b ^ 10101010b = 10111001b
-00010011b ^ 10101011b = 10111000b
-00010011b ^ 10101100b = 10111111b
-00010011b ^ 10101101b = 10111110b
-00010011b ^ 10101110b = 10111101b
-00010011b ^ 10101111b = 10111100b
-00010011b ^ 10110000b = 10100011b
-00010011b ^ 10110001b = 10100010b
-00010011b ^ 10110010b = 10100001b
-00010011b ^ 10110011b = 10100000b
-00010011b ^ 10110100b = 10100111b
-00010011b ^ 10110101b = 10100110b
-00010011b ^ 10110110b = 10100101b
-00010011b ^ 10110111b = 10100100b
-00010011b ^ 10111000b = 10101011b
-00010011b ^ 10111001b = 10101010b
-00010011b ^ 10111010b = 10101001b
-00010011b ^ 10111011b = 10101000b
-00010011b ^ 10111100b = 10101111b
-00010011b ^ 10111101b = 10101110b
-00010011b ^ 10111110b = 10101101b
-00010011b ^ 10111111b = 10101100b
-00010011b ^ 11000000b = 11010011b
-00010011b ^ 11000001b = 11010010b
-00010011b ^ 11000010b = 11010001b
-00010011b ^ 11000011b = 11010000b
-00010011b ^ 11000100b = 11010111b
-00010011b ^ 11000101b = 11010110b
-00010011b ^ 11000110b = 11010101b
-00010011b ^ 11000111b = 11010100b
-00010011b ^ 11001000b = 11011011b
-00010011b ^ 11001001b = 11011010b
-00010011b ^ 11001010b = 11011001b
-00010011b ^ 11001011b = 11011000b
-00010011b ^ 11001100b = 11011111b
-00010011b ^ 11001101b = 11011110b
-00010011b ^ 11001110b = 11011101b
-00010011b ^ 11001111b = 11011100b
-00010011b ^ 11010000b = 11000011b
-00010011b ^ 11010001b = 11000010b
-00010011b ^ 11010010b = 11000001b
-00010011b ^ 11010011b = 11000000b
-00010011b ^ 11010100b = 11000111b
-00010011b ^ 11010101b = 11000110b
-00010011b ^ 11010110b = 11000101b
-00010011b ^ 11010111b = 11000100b
-00010011b ^ 11011000b = 11001011b
-00010011b ^ 11011001b = 11001010b
-00010011b ^ 11011010b = 11001001b
-00010011b ^ 11011011b = 11001000b
-00010011b ^ 11011100b = 11001111b
-00010011b ^ 11011101b = 11001110b
-00010011b ^ 11011110b = 11001101b
-00010011b ^ 11011111b = 11001100b
-00010011b ^ 11100000b = 11110011b
-00010011b ^ 11100001b = 11110010b
-00010011b ^ 11100010b = 11110001b
-00010011b ^ 11100011b = 11110000b
-00010011b ^ 11100100b = 11110111b
-00010011b ^ 11100101b = 11110110b
-00010011b ^ 11100110b = 11110101b
-00010011b ^ 11100111b = 11110100b
-00010011b ^ 11101000b = 11111011b
-00010011b ^ 11101001b = 11111010b
-00010011b ^ 11101010b = 11111001b
-00010011b ^ 11101011b = 11111000b
-00010011b ^ 11101100b = 11111111b
-00010011b ^ 11101101b = 11111110b
-00010011b ^ 11101110b = 11111101b
-00010011b ^ 11101111b = 11111100b
-00010011b ^ 11110000b = 11100011b
-00010011b ^ 11110001b = 11100010b
-00010011b ^ 11110010b = 11100001b
-00010011b ^ 11110011b = 11100000b
-00010011b ^ 11110100b = 11100111b
-00010011b ^ 11110101b = 11100110b
-00010011b ^ 11110110b = 11100101b
-00010011b ^ 11110111b = 11100100b
-00010011b ^ 11111000b = 11101011b
-00010011b ^ 11111001b = 11101010b
-00010011b ^ 11111010b = 11101001b
-00010011b ^ 11111011b = 11101000b
-00010011b ^ 11111100b = 11101111b
-00010011b ^ 11111101b = 11101110b
-00010011b ^ 11111110b = 11101101b
-00010011b ^ 11111111b = 11101100b
-00010011b ^ 00000000b = 00010011b
-00010011b ^ 00000001b = 00010010b
-00010011b ^ 00000010b = 00010001b
-00010011b ^ 00000011b = 00010000b
-00010011b ^ 00000100b = 00010111b
-00010011b ^ 00000101b = 00010110b
-00010011b ^ 00000110b = 00010101b
-00010011b ^ 00000111b = 00010100b
-00010011b ^ 00001000b = 00011011b
-00010011b ^ 00001001b = 00011010b
-00010011b ^ 00001010b = 00011001b
-00010011b ^ 00001011b = 00011000b
-00010011b ^ 00001100b = 00011111b
-00010011b ^ 00001101b = 00011110b
-00010011b ^ 00001110b = 00011101b
-00010011b ^ 00001111b = 00011100b
-00010011b ^ 00010000b = 00000011b
-00010011b ^ 00010001b = 00000010b
-00010011b ^ 00010010b = 00000001b
-00010011b ^ 00010011b = 00000000b
-00010011b ^ 00010100b = 00000111b
-00010011b ^ 00010101b = 00000110b
-00010011b ^ 00010110b = 00000101b
-00010011b ^ 00010111b = 00000100b
-00010011b ^ 00011000b = 00001011b
-00010011b ^ 00011001b = 00001010b
-00010011b ^ 00011010b = 00001001b
-00010011b ^ 00011011b = 00001000b
-00010011b ^ 00011100b = 00001111b
-00010011b ^ 00011101b = 00001110b
-00010011b ^ 00011110b = 00001101b
-00010011b ^ 00011111b = 00001100b
-00010011b ^ 00100000b = 00110011b
-00010011b ^ 00100001b = 00110010b
-00010011b ^ 00100010b = 00110001b
-00010011b ^ 00100011b = 00110000b
-00010011b ^ 00100100b = 00110111b
-00010011b ^ 00100101b = 00110110b
-00010011b ^ 00100110b = 00110101b
-00010011b ^ 00100111b = 00110100b
-00010011b ^ 00101000b = 00111011b
-00010011b ^ 00101001b = 00111010b
-00010011b ^ 00101010b = 00111001b
-00010011b ^ 00101011b = 00111000b
-00010011b ^ 00101100b = 00111111b
-00010011b ^ 00101101b = 00111110b
-00010011b ^ 00101110b = 00111101b
-00010011b ^ 00101111b = 00111100b
-00010011b ^ 00110000b = 00100011b
-00010011b ^ 00110001b = 00100010b
-00010011b ^ 00110010b = 00100001b
-00010011b ^ 00110011b = 00100000b
-00010011b ^ 00110100b = 00100111b
-00010011b ^ 00110101b = 00100110b
-00010011b ^ 00110110b = 00100101b
-00010011b ^ 00110111b = 00100100b
-00010011b ^ 00111000b = 00101011b
-00010011b ^ 00111001b = 00101010b
-00010011b ^ 00111010b = 00101001b
-00010011b ^ 00111011b = 00101000b
-00010011b ^ 00111100b = 00101111b
-00010011b ^ 00111101b = 00101110b
-00010011b ^ 00111110b = 00101101b
-00010011b ^ 00111111b = 00101100b
-00010011b ^ 01000000b = 01010011b
-00010011b ^ 01000001b = 01010010b
-00010011b ^ 01000010b = 01010001b
-00010011b ^ 01000011b = 01010000b
-00010011b ^ 01000100b = 01010111b
-00010011b ^ 01000101b = 01010110b
-00010011b ^ 01000110b = 01010101b
-00010011b ^ 01000111b = 01010100b
-00010011b ^ 01001000b = 01011011b
-00010011b ^ 01001001b = 01011010b
-00010011b ^ 01001010b = 01011001b
-00010011b ^ 01001011b = 01011000b
-00010011b ^ 01001100b = 01011111b
-00010011b ^ 01001101b = 01011110b
-00010011b ^ 01001110b = 01011101b
-00010011b ^ 01001111b = 01011100b
-00010011b ^ 01010000b = 01000011b
-00010011b ^ 01010001b = 01000010b
-00010011b ^ 01010010b = 01000001b
-00010011b ^ 01010011b = 01000000b
-00010011b ^ 01010100b = 01000111b
-00010011b ^ 01010101b = 01000110b
-00010011b ^ 01010110b = 01000101b
-00010011b ^ 01010111b = 01000100b
-00010011b ^ 01011000b = 01001011b
-00010011b ^ 01011001b = 01001010b
-00010011b ^ 01011010b = 01001001b
-00010011b ^ 01011011b = 01001000b
-00010011b ^ 01011100b = 01001111b
-00010011b ^ 01011101b = 01001110b
-00010011b ^ 01011110b = 01001101b
-00010011b ^ 01011111b = 01001100b
-00010011b ^ 01100000b = 01110011b
-00010011b ^ 01100001b = 01110010b
-00010011b ^ 01100010b = 01110001b
-00010011b ^ 01100011b = 01110000b
-00010011b ^ 01100100b = 01110111b
-00010011b ^ 01100101b = 01110110b
-00010011b ^ 01100110b = 01110101b
-00010011b ^ 01100111b = 01110100b
-00010011b ^ 01101000b = 01111011b
-00010011b ^ 01101001b = 01111010b
-00010011b ^ 01101010b = 01111001b
-00010011b ^ 01101011b = 01111000b
-00010011b ^ 01101100b = 01111111b
-00010011b ^ 01101101b = 01111110b
-00010011b ^ 01101110b = 01111101b
-00010011b ^ 01101111b = 01111100b
-00010011b ^ 01110000b = 01100011b
-00010011b ^ 01110001b = 01100010b
-00010011b ^ 01110010b = 01100001b
-00010011b ^ 01110011b = 01100000b
-00010011b ^ 01110100b = 01100111b
-00010011b ^ 01110101b = 01100110b
-00010011b ^ 01110110b = 01100101b
-00010011b ^ 01110111b = 01100100b
-00010011b ^ 01111000b = 01101011b
-00010011b ^ 01111001b = 01101010b
-00010011b ^ 01111010b = 01101001b
-00010011b ^ 01111011b = 01101000b
-00010011b ^ 01111100b = 01101111b
-00010011b ^ 01111101b = 01101110b
-00010011b ^ 01111110b = 01101101b
-00010100b ^ 10000000b = 10010100b
-00010100b ^ 10000001b = 10010101b
-00010100b ^ 10000010b = 10010110b
-00010100b ^ 10000011b = 10010111b
-00010100b ^ 10000100b = 10010000b
-00010100b ^ 10000101b = 10010001b
-00010100b ^ 10000110b = 10010010b
-00010100b ^ 10000111b = 10010011b
-00010100b ^ 10001000b = 10011100b
-00010100b ^ 10001001b = 10011101b
-00010100b ^ 10001010b = 10011110b
-00010100b ^ 10001011b = 10011111b
-00010100b ^ 10001100b = 10011000b
-00010100b ^ 10001101b = 10011001b
-00010100b ^ 10001110b = 10011010b
-00010100b ^ 10001111b = 10011011b
-00010100b ^ 10010000b = 10000100b
-00010100b ^ 10010001b = 10000101b
-00010100b ^ 10010010b = 10000110b
-00010100b ^ 10010011b = 10000111b
-00010100b ^ 10010100b = 10000000b
-00010100b ^ 10010101b = 10000001b
-00010100b ^ 10010110b = 10000010b
-00010100b ^ 10010111b = 10000011b
-00010100b ^ 10011000b = 10001100b
-00010100b ^ 10011001b = 10001101b
-00010100b ^ 10011010b = 10001110b
-00010100b ^ 10011011b = 10001111b
-00010100b ^ 10011100b = 10001000b
-00010100b ^ 10011101b = 10001001b
-00010100b ^ 10011110b = 10001010b
-00010100b ^ 10011111b = 10001011b
-00010100b ^ 10100000b = 10110100b
-00010100b ^ 10100001b = 10110101b
-00010100b ^ 10100010b = 10110110b
-00010100b ^ 10100011b = 10110111b
-00010100b ^ 10100100b = 10110000b
-00010100b ^ 10100101b = 10110001b
-00010100b ^ 10100110b = 10110010b
-00010100b ^ 10100111b = 10110011b
-00010100b ^ 10101000b = 10111100b
-00010100b ^ 10101001b = 10111101b
-00010100b ^ 10101010b = 10111110b
-00010100b ^ 10101011b = 10111111b
-00010100b ^ 10101100b = 10111000b
-00010100b ^ 10101101b = 10111001b
-00010100b ^ 10101110b = 10111010b
-00010100b ^ 10101111b = 10111011b
-00010100b ^ 10110000b = 10100100b
-00010100b ^ 10110001b = 10100101b
-00010100b ^ 10110010b = 10100110b
-00010100b ^ 10110011b = 10100111b
-00010100b ^ 10110100b = 10100000b
-00010100b ^ 10110101b = 10100001b
-00010100b ^ 10110110b = 10100010b
-00010100b ^ 10110111b = 10100011b
-00010100b ^ 10111000b = 10101100b
-00010100b ^ 10111001b = 10101101b
-00010100b ^ 10111010b = 10101110b
-00010100b ^ 10111011b = 10101111b
-00010100b ^ 10111100b = 10101000b
-00010100b ^ 10111101b = 10101001b
-00010100b ^ 10111110b = 10101010b
-00010100b ^ 10111111b = 10101011b
-00010100b ^ 11000000b = 11010100b
-00010100b ^ 11000001b = 11010101b
-00010100b ^ 11000010b = 11010110b
-00010100b ^ 11000011b = 11010111b
-00010100b ^ 11000100b = 11010000b
-00010100b ^ 11000101b = 11010001b
-00010100b ^ 11000110b = 11010010b
-00010100b ^ 11000111b = 11010011b
-00010100b ^ 11001000b = 11011100b
-00010100b ^ 11001001b = 11011101b
-00010100b ^ 11001010b = 11011110b
-00010100b ^ 11001011b = 11011111b
-00010100b ^ 11001100b = 11011000b
-00010100b ^ 11001101b = 11011001b
-00010100b ^ 11001110b = 11011010b
-00010100b ^ 11001111b = 11011011b
-00010100b ^ 11010000b = 11000100b
-00010100b ^ 11010001b = 11000101b
-00010100b ^ 11010010b = 11000110b
-00010100b ^ 11010011b = 11000111b
-00010100b ^ 11010100b = 11000000b
-00010100b ^ 11010101b = 11000001b
-00010100b ^ 11010110b = 11000010b
-00010100b ^ 11010111b = 11000011b
-00010100b ^ 11011000b = 11001100b
-00010100b ^ 11011001b = 11001101b
-00010100b ^ 11011010b = 11001110b
-00010100b ^ 11011011b = 11001111b
-00010100b ^ 11011100b = 11001000b
-00010100b ^ 11011101b = 11001001b
-00010100b ^ 11011110b = 11001010b
-00010100b ^ 11011111b = 11001011b
-00010100b ^ 11100000b = 11110100b
-00010100b ^ 11100001b = 11110101b
-00010100b ^ 11100010b = 11110110b
-00010100b ^ 11100011b = 11110111b
-00010100b ^ 11100100b = 11110000b
-00010100b ^ 11100101b = 11110001b
-00010100b ^ 11100110b = 11110010b
-00010100b ^ 11100111b = 11110011b
-00010100b ^ 11101000b = 11111100b
-00010100b ^ 11101001b = 11111101b
-00010100b ^ 11101010b = 11111110b
-00010100b ^ 11101011b = 11111111b
-00010100b ^ 11101100b = 11111000b
-00010100b ^ 11101101b = 11111001b
-00010100b ^ 11101110b = 11111010b
-00010100b ^ 11101111b = 11111011b
-00010100b ^ 11110000b = 11100100b
-00010100b ^ 11110001b = 11100101b
-00010100b ^ 11110010b = 11100110b
-00010100b ^ 11110011b = 11100111b
-00010100b ^ 11110100b = 11100000b
-00010100b ^ 11110101b = 11100001b
-00010100b ^ 11110110b = 11100010b
-00010100b ^ 11110111b = 11100011b
-00010100b ^ 11111000b = 11101100b
-00010100b ^ 11111001b = 11101101b
-00010100b ^ 11111010b = 11101110b
-00010100b ^ 11111011b = 11101111b
-00010100b ^ 11111100b = 11101000b
-00010100b ^ 11111101b = 11101001b
-00010100b ^ 11111110b = 11101010b
-00010100b ^ 11111111b = 11101011b
-00010100b ^ 00000000b = 00010100b
-00010100b ^ 00000001b = 00010101b
-00010100b ^ 00000010b = 00010110b
-00010100b ^ 00000011b = 00010111b
-00010100b ^ 00000100b = 00010000b
-00010100b ^ 00000101b = 00010001b
-00010100b ^ 00000110b = 00010010b
-00010100b ^ 00000111b = 00010011b
-00010100b ^ 00001000b = 00011100b
-00010100b ^ 00001001b = 00011101b
-00010100b ^ 00001010b = 00011110b
-00010100b ^ 00001011b = 00011111b
-00010100b ^ 00001100b = 00011000b
-00010100b ^ 00001101b = 00011001b
-00010100b ^ 00001110b = 00011010b
-00010100b ^ 00001111b = 00011011b
-00010100b ^ 00010000b = 00000100b
-00010100b ^ 00010001b = 00000101b
-00010100b ^ 00010010b = 00000110b
-00010100b ^ 00010011b = 00000111b
-00010100b ^ 00010100b = 00000000b
-00010100b ^ 00010101b = 00000001b
-00010100b ^ 00010110b = 00000010b
-00010100b ^ 00010111b = 00000011b
-00010100b ^ 00011000b = 00001100b
-00010100b ^ 00011001b = 00001101b
-00010100b ^ 00011010b = 00001110b
-00010100b ^ 00011011b = 00001111b
-00010100b ^ 00011100b = 00001000b
-00010100b ^ 00011101b = 00001001b
-00010100b ^ 00011110b = 00001010b
-00010100b ^ 00011111b = 00001011b
-00010100b ^ 00100000b = 00110100b
-00010100b ^ 00100001b = 00110101b
-00010100b ^ 00100010b = 00110110b
-00010100b ^ 00100011b = 00110111b
-00010100b ^ 00100100b = 00110000b
-00010100b ^ 00100101b = 00110001b
-00010100b ^ 00100110b = 00110010b
-00010100b ^ 00100111b = 00110011b
-00010100b ^ 00101000b = 00111100b
-00010100b ^ 00101001b = 00111101b
-00010100b ^ 00101010b = 00111110b
-00010100b ^ 00101011b = 00111111b
-00010100b ^ 00101100b = 00111000b
-00010100b ^ 00101101b = 00111001b
-00010100b ^ 00101110b = 00111010b
-00010100b ^ 00101111b = 00111011b
-00010100b ^ 00110000b = 00100100b
-00010100b ^ 00110001b = 00100101b
-00010100b ^ 00110010b = 00100110b
-00010100b ^ 00110011b = 00100111b
-00010100b ^ 00110100b = 00100000b
-00010100b ^ 00110101b = 00100001b
-00010100b ^ 00110110b = 00100010b
-00010100b ^ 00110111b = 00100011b
-00010100b ^ 00111000b = 00101100b
-00010100b ^ 00111001b = 00101101b
-00010100b ^ 00111010b = 00101110b
-00010100b ^ 00111011b = 00101111b
-00010100b ^ 00111100b = 00101000b
-00010100b ^ 00111101b = 00101001b
-00010100b ^ 00111110b = 00101010b
-00010100b ^ 00111111b = 00101011b
-00010100b ^ 01000000b = 01010100b
-00010100b ^ 01000001b = 01010101b
-00010100b ^ 01000010b = 01010110b
-00010100b ^ 01000011b = 01010111b
-00010100b ^ 01000100b = 01010000b
-00010100b ^ 01000101b = 01010001b
-00010100b ^ 01000110b = 01010010b
-00010100b ^ 01000111b = 01010011b
-00010100b ^ 01001000b = 01011100b
-00010100b ^ 01001001b = 01011101b
-00010100b ^ 01001010b = 01011110b
-00010100b ^ 01001011b = 01011111b
-00010100b ^ 01001100b = 01011000b
-00010100b ^ 01001101b = 01011001b
-00010100b ^ 01001110b = 01011010b
-00010100b ^ 01001111b = 01011011b
-00010100b ^ 01010000b = 01000100b
-00010100b ^ 01010001b = 01000101b
-00010100b ^ 01010010b = 01000110b
-00010100b ^ 01010011b = 01000111b
-00010100b ^ 01010100b = 01000000b
-00010100b ^ 01010101b = 01000001b
-00010100b ^ 01010110b = 01000010b
-00010100b ^ 01010111b = 01000011b
-00010100b ^ 01011000b = 01001100b
-00010100b ^ 01011001b = 01001101b
-00010100b ^ 01011010b = 01001110b
-00010100b ^ 01011011b = 01001111b
-00010100b ^ 01011100b = 01001000b
-00010100b ^ 01011101b = 01001001b
-00010100b ^ 01011110b = 01001010b
-00010100b ^ 01011111b = 01001011b
-00010100b ^ 01100000b = 01110100b
-00010100b ^ 01100001b = 01110101b
-00010100b ^ 01100010b = 01110110b
-00010100b ^ 01100011b = 01110111b
-00010100b ^ 01100100b = 01110000b
-00010100b ^ 01100101b = 01110001b
-00010100b ^ 01100110b = 01110010b
-00010100b ^ 01100111b = 01110011b
-00010100b ^ 01101000b = 01111100b
-00010100b ^ 01101001b = 01111101b
-00010100b ^ 01101010b = 01111110b
-00010100b ^ 01101011b = 01111111b
-00010100b ^ 01101100b = 01111000b
-00010100b ^ 01101101b = 01111001b
-00010100b ^ 01101110b = 01111010b
-00010100b ^ 01101111b = 01111011b
-00010100b ^ 01110000b = 01100100b
-00010100b ^ 01110001b = 01100101b
-00010100b ^ 01110010b = 01100110b
-00010100b ^ 01110011b = 01100111b
-00010100b ^ 01110100b = 01100000b
-00010100b ^ 01110101b = 01100001b
-00010100b ^ 01110110b = 01100010b
-00010100b ^ 01110111b = 01100011b
-00010100b ^ 01111000b = 01101100b
-00010100b ^ 01111001b = 01101101b
-00010100b ^ 01111010b = 01101110b
-00010100b ^ 01111011b = 01101111b
-00010100b ^ 01111100b = 01101000b
-00010100b ^ 01111101b = 01101001b
-00010100b ^ 01111110b = 01101010b
-00010101b ^ 10000000b = 10010101b
-00010101b ^ 10000001b = 10010100b
-00010101b ^ 10000010b = 10010111b
-00010101b ^ 10000011b = 10010110b
-00010101b ^ 10000100b = 10010001b
-00010101b ^ 10000101b = 10010000b
-00010101b ^ 10000110b = 10010011b
-00010101b ^ 10000111b = 10010010b
-00010101b ^ 10001000b = 10011101b
-00010101b ^ 10001001b = 10011100b
-00010101b ^ 10001010b = 10011111b
-00010101b ^ 10001011b = 10011110b
-00010101b ^ 10001100b = 10011001b
-00010101b ^ 10001101b = 10011000b
-00010101b ^ 10001110b = 10011011b
-00010101b ^ 10001111b = 10011010b
-00010101b ^ 10010000b = 10000101b
-00010101b ^ 10010001b = 10000100b
-00010101b ^ 10010010b = 10000111b
-00010101b ^ 10010011b = 10000110b
-00010101b ^ 10010100b = 10000001b
-00010101b ^ 10010101b = 10000000b
-00010101b ^ 10010110b = 10000011b
-00010101b ^ 10010111b = 10000010b
-00010101b ^ 10011000b = 10001101b
-00010101b ^ 10011001b = 10001100b
-00010101b ^ 10011010b = 10001111b
-00010101b ^ 10011011b = 10001110b
-00010101b ^ 10011100b = 10001001b
-00010101b ^ 10011101b = 10001000b
-00010101b ^ 10011110b = 10001011b
-00010101b ^ 10011111b = 10001010b
-00010101b ^ 10100000b = 10110101b
-00010101b ^ 10100001b = 10110100b
-00010101b ^ 10100010b = 10110111b
-00010101b ^ 10100011b = 10110110b
-00010101b ^ 10100100b = 10110001b
-00010101b ^ 10100101b = 10110000b
-00010101b ^ 10100110b = 10110011b
-00010101b ^ 10100111b = 10110010b
-00010101b ^ 10101000b = 10111101b
-00010101b ^ 10101001b = 10111100b
-00010101b ^ 10101010b = 10111111b
-00010101b ^ 10101011b = 10111110b
-00010101b ^ 10101100b = 10111001b
-00010101b ^ 10101101b = 10111000b
-00010101b ^ 10101110b = 10111011b
-00010101b ^ 10101111b = 10111010b
-00010101b ^ 10110000b = 10100101b
-00010101b ^ 10110001b = 10100100b
-00010101b ^ 10110010b = 10100111b
-00010101b ^ 10110011b = 10100110b
-00010101b ^ 10110100b = 10100001b
-00010101b ^ 10110101b = 10100000b
-00010101b ^ 10110110b = 10100011b
-00010101b ^ 10110111b = 10100010b
-00010101b ^ 10111000b = 10101101b
-00010101b ^ 10111001b = 10101100b
-00010101b ^ 10111010b = 10101111b
-00010101b ^ 10111011b = 10101110b
-00010101b ^ 10111100b = 10101001b
-00010101b ^ 10111101b = 10101000b
-00010101b ^ 10111110b = 10101011b
-00010101b ^ 10111111b = 10101010b
-00010101b ^ 11000000b = 11010101b
-00010101b ^ 11000001b = 11010100b
-00010101b ^ 11000010b = 11010111b
-00010101b ^ 11000011b = 11010110b
-00010101b ^ 11000100b = 11010001b
-00010101b ^ 11000101b = 11010000b
-00010101b ^ 11000110b = 11010011b
-00010101b ^ 11000111b = 11010010b
-00010101b ^ 11001000b = 11011101b
-00010101b ^ 11001001b = 11011100b
-00010101b ^ 11001010b = 11011111b
-00010101b ^ 11001011b = 11011110b
-00010101b ^ 11001100b = 11011001b
-00010101b ^ 11001101b = 11011000b
-00010101b ^ 11001110b = 11011011b
-00010101b ^ 11001111b = 11011010b
-00010101b ^ 11010000b = 11000101b
-00010101b ^ 11010001b = 11000100b
-00010101b ^ 11010010b = 11000111b
-00010101b ^ 11010011b = 11000110b
-00010101b ^ 11010100b = 11000001b
-00010101b ^ 11010101b = 11000000b
-00010101b ^ 11010110b = 11000011b
-00010101b ^ 11010111b = 11000010b
-00010101b ^ 11011000b = 11001101b
-00010101b ^ 11011001b = 11001100b
-00010101b ^ 11011010b = 11001111b
-00010101b ^ 11011011b = 11001110b
-00010101b ^ 11011100b = 11001001b
-00010101b ^ 11011101b = 11001000b
-00010101b ^ 11011110b = 11001011b
-00010101b ^ 11011111b = 11001010b
-00010101b ^ 11100000b = 11110101b
-00010101b ^ 11100001b = 11110100b
-00010101b ^ 11100010b = 11110111b
-00010101b ^ 11100011b = 11110110b
-00010101b ^ 11100100b = 11110001b
-00010101b ^ 11100101b = 11110000b
-00010101b ^ 11100110b = 11110011b
-00010101b ^ 11100111b = 11110010b
-00010101b ^ 11101000b = 11111101b
-00010101b ^ 11101001b = 11111100b
-00010101b ^ 11101010b = 11111111b
-00010101b ^ 11101011b = 11111110b
-00010101b ^ 11101100b = 11111001b
-00010101b ^ 11101101b = 11111000b
-00010101b ^ 11101110b = 11111011b
-00010101b ^ 11101111b = 11111010b
-00010101b ^ 11110000b = 11100101b
-00010101b ^ 11110001b = 11100100b
-00010101b ^ 11110010b = 11100111b
-00010101b ^ 11110011b = 11100110b
-00010101b ^ 11110100b = 11100001b
-00010101b ^ 11110101b = 11100000b
-00010101b ^ 11110110b = 11100011b
-00010101b ^ 11110111b = 11100010b
-00010101b ^ 11111000b = 11101101b
-00010101b ^ 11111001b = 11101100b
-00010101b ^ 11111010b = 11101111b
-00010101b ^ 11111011b = 11101110b
-00010101b ^ 11111100b = 11101001b
-00010101b ^ 11111101b = 11101000b
-00010101b ^ 11111110b = 11101011b
-00010101b ^ 11111111b = 11101010b
-00010101b ^ 00000000b = 00010101b
-00010101b ^ 00000001b = 00010100b
-00010101b ^ 00000010b = 00010111b
-00010101b ^ 00000011b = 00010110b
-00010101b ^ 00000100b = 00010001b
-00010101b ^ 00000101b = 00010000b
-00010101b ^ 00000110b = 00010011b
-00010101b ^ 00000111b = 00010010b
-00010101b ^ 00001000b = 00011101b
-00010101b ^ 00001001b = 00011100b
-00010101b ^ 00001010b = 00011111b
-00010101b ^ 00001011b = 00011110b
-00010101b ^ 00001100b = 00011001b
-00010101b ^ 00001101b = 00011000b
-00010101b ^ 00001110b = 00011011b
-00010101b ^ 00001111b = 00011010b
-00010101b ^ 00010000b = 00000101b
-00010101b ^ 00010001b = 00000100b
-00010101b ^ 00010010b = 00000111b
-00010101b ^ 00010011b = 00000110b
-00010101b ^ 00010100b = 00000001b
-00010101b ^ 00010101b = 00000000b
-00010101b ^ 00010110b = 00000011b
-00010101b ^ 00010111b = 00000010b
-00010101b ^ 00011000b = 00001101b
-00010101b ^ 00011001b = 00001100b
-00010101b ^ 00011010b = 00001111b
-00010101b ^ 00011011b = 00001110b
-00010101b ^ 00011100b = 00001001b
-00010101b ^ 00011101b = 00001000b
-00010101b ^ 00011110b = 00001011b
-00010101b ^ 00011111b = 00001010b
-00010101b ^ 00100000b = 00110101b
-00010101b ^ 00100001b = 00110100b
-00010101b ^ 00100010b = 00110111b
-00010101b ^ 00100011b = 00110110b
-00010101b ^ 00100100b = 00110001b
-00010101b ^ 00100101b = 00110000b
-00010101b ^ 00100110b = 00110011b
-00010101b ^ 00100111b = 00110010b
-00010101b ^ 00101000b = 00111101b
-00010101b ^ 00101001b = 00111100b
-00010101b ^ 00101010b = 00111111b
-00010101b ^ 00101011b = 00111110b
-00010101b ^ 00101100b = 00111001b
-00010101b ^ 00101101b = 00111000b
-00010101b ^ 00101110b = 00111011b
-00010101b ^ 00101111b = 00111010b
-00010101b ^ 00110000b = 00100101b
-00010101b ^ 00110001b = 00100100b
-00010101b ^ 00110010b = 00100111b
-00010101b ^ 00110011b = 00100110b
-00010101b ^ 00110100b = 00100001b
-00010101b ^ 00110101b = 00100000b
-00010101b ^ 00110110b = 00100011b
-00010101b ^ 00110111b = 00100010b
-00010101b ^ 00111000b = 00101101b
-00010101b ^ 00111001b = 00101100b
-00010101b ^ 00111010b = 00101111b
-00010101b ^ 00111011b = 00101110b
-00010101b ^ 00111100b = 00101001b
-00010101b ^ 00111101b = 00101000b
-00010101b ^ 00111110b = 00101011b
-00010101b ^ 00111111b = 00101010b
-00010101b ^ 01000000b = 01010101b
-00010101b ^ 01000001b = 01010100b
-00010101b ^ 01000010b = 01010111b
-00010101b ^ 01000011b = 01010110b
-00010101b ^ 01000100b = 01010001b
-00010101b ^ 01000101b = 01010000b
-00010101b ^ 01000110b = 01010011b
-00010101b ^ 01000111b = 01010010b
-00010101b ^ 01001000b = 01011101b
-00010101b ^ 01001001b = 01011100b
-00010101b ^ 01001010b = 01011111b
-00010101b ^ 01001011b = 01011110b
-00010101b ^ 01001100b = 01011001b
-00010101b ^ 01001101b = 01011000b
-00010101b ^ 01001110b = 01011011b
-00010101b ^ 01001111b = 01011010b
-00010101b ^ 01010000b = 01000101b
-00010101b ^ 01010001b = 01000100b
-00010101b ^ 01010010b = 01000111b
-00010101b ^ 01010011b = 01000110b
-00010101b ^ 01010100b = 01000001b
-00010101b ^ 01010101b = 01000000b
-00010101b ^ 01010110b = 01000011b
-00010101b ^ 01010111b = 01000010b
-00010101b ^ 01011000b = 01001101b
-00010101b ^ 01011001b = 01001100b
-00010101b ^ 01011010b = 01001111b
-00010101b ^ 01011011b = 01001110b
-00010101b ^ 01011100b = 01001001b
-00010101b ^ 01011101b = 01001000b
-00010101b ^ 01011110b = 01001011b
-00010101b ^ 01011111b = 01001010b
-00010101b ^ 01100000b = 01110101b
-00010101b ^ 01100001b = 01110100b
-00010101b ^ 01100010b = 01110111b
-00010101b ^ 01100011b = 01110110b
-00010101b ^ 01100100b = 01110001b
-00010101b ^ 01100101b = 01110000b
-00010101b ^ 01100110b = 01110011b
-00010101b ^ 01100111b = 01110010b
-00010101b ^ 01101000b = 01111101b
-00010101b ^ 01101001b = 01111100b
-00010101b ^ 01101010b = 01111111b
-00010101b ^ 01101011b = 01111110b
-00010101b ^ 01101100b = 01111001b
-00010101b ^ 01101101b = 01111000b
-00010101b ^ 01101110b = 01111011b
-00010101b ^ 01101111b = 01111010b
-00010101b ^ 01110000b = 01100101b
-00010101b ^ 01110001b = 01100100b
-00010101b ^ 01110010b = 01100111b
-00010101b ^ 01110011b = 01100110b
-00010101b ^ 01110100b = 01100001b
-00010101b ^ 01110101b = 01100000b
-00010101b ^ 01110110b = 01100011b
-00010101b ^ 01110111b = 01100010b
-00010101b ^ 01111000b = 01101101b
-00010101b ^ 01111001b = 01101100b
-00010101b ^ 01111010b = 01101111b
-00010101b ^ 01111011b = 01101110b
-00010101b ^ 01111100b = 01101001b
-00010101b ^ 01111101b = 01101000b
-00010101b ^ 01111110b = 01101011b
-00010110b ^ 10000000b = 10010110b
-00010110b ^ 10000001b = 10010111b
-00010110b ^ 10000010b = 10010100b
-00010110b ^ 10000011b = 10010101b
-00010110b ^ 10000100b = 10010010b
-00010110b ^ 10000101b = 10010011b
-00010110b ^ 10000110b = 10010000b
-00010110b ^ 10000111b = 10010001b
-00010110b ^ 10001000b = 10011110b
-00010110b ^ 10001001b = 10011111b
-00010110b ^ 10001010b = 10011100b
-00010110b ^ 10001011b = 10011101b
-00010110b ^ 10001100b = 10011010b
-00010110b ^ 10001101b = 10011011b
-00010110b ^ 10001110b = 10011000b
-00010110b ^ 10001111b = 10011001b
-00010110b ^ 10010000b = 10000110b
-00010110b ^ 10010001b = 10000111b
-00010110b ^ 10010010b = 10000100b
-00010110b ^ 10010011b = 10000101b
-00010110b ^ 10010100b = 10000010b
-00010110b ^ 10010101b = 10000011b
-00010110b ^ 10010110b = 10000000b
-00010110b ^ 10010111b = 10000001b
-00010110b ^ 10011000b = 10001110b
-00010110b ^ 10011001b = 10001111b
-00010110b ^ 10011010b = 10001100b
-00010110b ^ 10011011b = 10001101b
-00010110b ^ 10011100b = 10001010b
-00010110b ^ 10011101b = 10001011b
-00010110b ^ 10011110b = 10001000b
-00010110b ^ 10011111b = 10001001b
-00010110b ^ 10100000b = 10110110b
-00010110b ^ 10100001b = 10110111b
-00010110b ^ 10100010b = 10110100b
-00010110b ^ 10100011b = 10110101b
-00010110b ^ 10100100b = 10110010b
-00010110b ^ 10100101b = 10110011b
-00010110b ^ 10100110b = 10110000b
-00010110b ^ 10100111b = 10110001b
-00010110b ^ 10101000b = 10111110b
-00010110b ^ 10101001b = 10111111b
-00010110b ^ 10101010b = 10111100b
-00010110b ^ 10101011b = 10111101b
-00010110b ^ 10101100b = 10111010b
-00010110b ^ 10101101b = 10111011b
-00010110b ^ 10101110b = 10111000b
-00010110b ^ 10101111b = 10111001b
-00010110b ^ 10110000b = 10100110b
-00010110b ^ 10110001b = 10100111b
-00010110b ^ 10110010b = 10100100b
-00010110b ^ 10110011b = 10100101b
-00010110b ^ 10110100b = 10100010b
-00010110b ^ 10110101b = 10100011b
-00010110b ^ 10110110b = 10100000b
-00010110b ^ 10110111b = 10100001b
-00010110b ^ 10111000b = 10101110b
-00010110b ^ 10111001b = 10101111b
-00010110b ^ 10111010b = 10101100b
-00010110b ^ 10111011b = 10101101b
-00010110b ^ 10111100b = 10101010b
-00010110b ^ 10111101b = 10101011b
-00010110b ^ 10111110b = 10101000b
-00010110b ^ 10111111b = 10101001b
-00010110b ^ 11000000b = 11010110b
-00010110b ^ 11000001b = 11010111b
-00010110b ^ 11000010b = 11010100b
-00010110b ^ 11000011b = 11010101b
-00010110b ^ 11000100b = 11010010b
-00010110b ^ 11000101b = 11010011b
-00010110b ^ 11000110b = 11010000b
-00010110b ^ 11000111b = 11010001b
-00010110b ^ 11001000b = 11011110b
-00010110b ^ 11001001b = 11011111b
-00010110b ^ 11001010b = 11011100b
-00010110b ^ 11001011b = 11011101b
-00010110b ^ 11001100b = 11011010b
-00010110b ^ 11001101b = 11011011b
-00010110b ^ 11001110b = 11011000b
-00010110b ^ 11001111b = 11011001b
-00010110b ^ 11010000b = 11000110b
-00010110b ^ 11010001b = 11000111b
-00010110b ^ 11010010b = 11000100b
-00010110b ^ 11010011b = 11000101b
-00010110b ^ 11010100b = 11000010b
-00010110b ^ 11010101b = 11000011b
-00010110b ^ 11010110b = 11000000b
-00010110b ^ 11010111b = 11000001b
-00010110b ^ 11011000b = 11001110b
-00010110b ^ 11011001b = 11001111b
-00010110b ^ 11011010b = 11001100b
-00010110b ^ 11011011b = 11001101b
-00010110b ^ 11011100b = 11001010b
-00010110b ^ 11011101b = 11001011b
-00010110b ^ 11011110b = 11001000b
-00010110b ^ 11011111b = 11001001b
-00010110b ^ 11100000b = 11110110b
-00010110b ^ 11100001b = 11110111b
-00010110b ^ 11100010b = 11110100b
-00010110b ^ 11100011b = 11110101b
-00010110b ^ 11100100b = 11110010b
-00010110b ^ 11100101b = 11110011b
-00010110b ^ 11100110b = 11110000b
-00010110b ^ 11100111b = 11110001b
-00010110b ^ 11101000b = 11111110b
-00010110b ^ 11101001b = 11111111b
-00010110b ^ 11101010b = 11111100b
-00010110b ^ 11101011b = 11111101b
-00010110b ^ 11101100b = 11111010b
-00010110b ^ 11101101b = 11111011b
-00010110b ^ 11101110b = 11111000b
-00010110b ^ 11101111b = 11111001b
-00010110b ^ 11110000b = 11100110b
-00010110b ^ 11110001b = 11100111b
-00010110b ^ 11110010b = 11100100b
-00010110b ^ 11110011b = 11100101b
-00010110b ^ 11110100b = 11100010b
-00010110b ^ 11110101b = 11100011b
-00010110b ^ 11110110b = 11100000b
-00010110b ^ 11110111b = 11100001b
-00010110b ^ 11111000b = 11101110b
-00010110b ^ 11111001b = 11101111b
-00010110b ^ 11111010b = 11101100b
-00010110b ^ 11111011b = 11101101b
-00010110b ^ 11111100b = 11101010b
-00010110b ^ 11111101b = 11101011b
-00010110b ^ 11111110b = 11101000b
-00010110b ^ 11111111b = 11101001b
-00010110b ^ 00000000b = 00010110b
-00010110b ^ 00000001b = 00010111b
-00010110b ^ 00000010b = 00010100b
-00010110b ^ 00000011b = 00010101b
-00010110b ^ 00000100b = 00010010b
-00010110b ^ 00000101b = 00010011b
-00010110b ^ 00000110b = 00010000b
-00010110b ^ 00000111b = 00010001b
-00010110b ^ 00001000b = 00011110b
-00010110b ^ 00001001b = 00011111b
-00010110b ^ 00001010b = 00011100b
-00010110b ^ 00001011b = 00011101b
-00010110b ^ 00001100b = 00011010b
-00010110b ^ 00001101b = 00011011b
-00010110b ^ 00001110b = 00011000b
-00010110b ^ 00001111b = 00011001b
-00010110b ^ 00010000b = 00000110b
-00010110b ^ 00010001b = 00000111b
-00010110b ^ 00010010b = 00000100b
-00010110b ^ 00010011b = 00000101b
-00010110b ^ 00010100b = 00000010b
-00010110b ^ 00010101b = 00000011b
-00010110b ^ 00010110b = 00000000b
-00010110b ^ 00010111b = 00000001b
-00010110b ^ 00011000b = 00001110b
-00010110b ^ 00011001b = 00001111b
-00010110b ^ 00011010b = 00001100b
-00010110b ^ 00011011b = 00001101b
-00010110b ^ 00011100b = 00001010b
-00010110b ^ 00011101b = 00001011b
-00010110b ^ 00011110b = 00001000b
-00010110b ^ 00011111b = 00001001b
-00010110b ^ 00100000b = 00110110b
-00010110b ^ 00100001b = 00110111b
-00010110b ^ 00100010b = 00110100b
-00010110b ^ 00100011b = 00110101b
-00010110b ^ 00100100b = 00110010b
-00010110b ^ 00100101b = 00110011b
-00010110b ^ 00100110b = 00110000b
-00010110b ^ 00100111b = 00110001b
-00010110b ^ 00101000b = 00111110b
-00010110b ^ 00101001b = 00111111b
-00010110b ^ 00101010b = 00111100b
-00010110b ^ 00101011b = 00111101b
-00010110b ^ 00101100b = 00111010b
-00010110b ^ 00101101b = 00111011b
-00010110b ^ 00101110b = 00111000b
-00010110b ^ 00101111b = 00111001b
-00010110b ^ 00110000b = 00100110b
-00010110b ^ 00110001b = 00100111b
-00010110b ^ 00110010b = 00100100b
-00010110b ^ 00110011b = 00100101b
-00010110b ^ 00110100b = 00100010b
-00010110b ^ 00110101b = 00100011b
-00010110b ^ 00110110b = 00100000b
-00010110b ^ 00110111b = 00100001b
-00010110b ^ 00111000b = 00101110b
-00010110b ^ 00111001b = 00101111b
-00010110b ^ 00111010b = 00101100b
-00010110b ^ 00111011b = 00101101b
-00010110b ^ 00111100b = 00101010b
-00010110b ^ 00111101b = 00101011b
-00010110b ^ 00111110b = 00101000b
-00010110b ^ 00111111b = 00101001b
-00010110b ^ 01000000b = 01010110b
-00010110b ^ 01000001b = 01010111b
-00010110b ^ 01000010b = 01010100b
-00010110b ^ 01000011b = 01010101b
-00010110b ^ 01000100b = 01010010b
-00010110b ^ 01000101b = 01010011b
-00010110b ^ 01000110b = 01010000b
-00010110b ^ 01000111b = 01010001b
-00010110b ^ 01001000b = 01011110b
-00010110b ^ 01001001b = 01011111b
-00010110b ^ 01001010b = 01011100b
-00010110b ^ 01001011b = 01011101b
-00010110b ^ 01001100b = 01011010b
-00010110b ^ 01001101b = 01011011b
-00010110b ^ 01001110b = 01011000b
-00010110b ^ 01001111b = 01011001b
-00010110b ^ 01010000b = 01000110b
-00010110b ^ 01010001b = 01000111b
-00010110b ^ 01010010b = 01000100b
-00010110b ^ 01010011b = 01000101b
-00010110b ^ 01010100b = 01000010b
-00010110b ^ 01010101b = 01000011b
-00010110b ^ 01010110b = 01000000b
-00010110b ^ 01010111b = 01000001b
-00010110b ^ 01011000b = 01001110b
-00010110b ^ 01011001b = 01001111b
-00010110b ^ 01011010b = 01001100b
-00010110b ^ 01011011b = 01001101b
-00010110b ^ 01011100b = 01001010b
-00010110b ^ 01011101b = 01001011b
-00010110b ^ 01011110b = 01001000b
-00010110b ^ 01011111b = 01001001b
-00010110b ^ 01100000b = 01110110b
-00010110b ^ 01100001b = 01110111b
-00010110b ^ 01100010b = 01110100b
-00010110b ^ 01100011b = 01110101b
-00010110b ^ 01100100b = 01110010b
-00010110b ^ 01100101b = 01110011b
-00010110b ^ 01100110b = 01110000b
-00010110b ^ 01100111b = 01110001b
-00010110b ^ 01101000b = 01111110b
-00010110b ^ 01101001b = 01111111b
-00010110b ^ 01101010b = 01111100b
-00010110b ^ 01101011b = 01111101b
-00010110b ^ 01101100b = 01111010b
-00010110b ^ 01101101b = 01111011b
-00010110b ^ 01101110b = 01111000b
-00010110b ^ 01101111b = 01111001b
-00010110b ^ 01110000b = 01100110b
-00010110b ^ 01110001b = 01100111b
-00010110b ^ 01110010b = 01100100b
-00010110b ^ 01110011b = 01100101b
-00010110b ^ 01110100b = 01100010b
-00010110b ^ 01110101b = 01100011b
-00010110b ^ 01110110b = 01100000b
-00010110b ^ 01110111b = 01100001b
-00010110b ^ 01111000b = 01101110b
-00010110b ^ 01111001b = 01101111b
-00010110b ^ 01111010b = 01101100b
-00010110b ^ 01111011b = 01101101b
-00010110b ^ 01111100b = 01101010b
-00010110b ^ 01111101b = 01101011b
-00010110b ^ 01111110b = 01101000b
-00010111b ^ 10000000b = 10010111b
-00010111b ^ 10000001b = 10010110b
-00010111b ^ 10000010b = 10010101b
-00010111b ^ 10000011b = 10010100b
-00010111b ^ 10000100b = 10010011b
-00010111b ^ 10000101b = 10010010b
-00010111b ^ 10000110b = 10010001b
-00010111b ^ 10000111b = 10010000b
-00010111b ^ 10001000b = 10011111b
-00010111b ^ 10001001b = 10011110b
-00010111b ^ 10001010b = 10011101b
-00010111b ^ 10001011b = 10011100b
-00010111b ^ 10001100b = 10011011b
-00010111b ^ 10001101b = 10011010b
-00010111b ^ 10001110b = 10011001b
-00010111b ^ 10001111b = 10011000b
-00010111b ^ 10010000b = 10000111b
-00010111b ^ 10010001b = 10000110b
-00010111b ^ 10010010b = 10000101b
-00010111b ^ 10010011b = 10000100b
-00010111b ^ 10010100b = 10000011b
-00010111b ^ 10010101b = 10000010b
-00010111b ^ 10010110b = 10000001b
-00010111b ^ 10010111b = 10000000b
-00010111b ^ 10011000b = 10001111b
-00010111b ^ 10011001b = 10001110b
-00010111b ^ 10011010b = 10001101b
-00010111b ^ 10011011b = 10001100b
-00010111b ^ 10011100b = 10001011b
-00010111b ^ 10011101b = 10001010b
-00010111b ^ 10011110b = 10001001b
-00010111b ^ 10011111b = 10001000b
-00010111b ^ 10100000b = 10110111b
-00010111b ^ 10100001b = 10110110b
-00010111b ^ 10100010b = 10110101b
-00010111b ^ 10100011b = 10110100b
-00010111b ^ 10100100b = 10110011b
-00010111b ^ 10100101b = 10110010b
-00010111b ^ 10100110b = 10110001b
-00010111b ^ 10100111b = 10110000b
-00010111b ^ 10101000b = 10111111b
-00010111b ^ 10101001b = 10111110b
-00010111b ^ 10101010b = 10111101b
-00010111b ^ 10101011b = 10111100b
-00010111b ^ 10101100b = 10111011b
-00010111b ^ 10101101b = 10111010b
-00010111b ^ 10101110b = 10111001b
-00010111b ^ 10101111b = 10111000b
-00010111b ^ 10110000b = 10100111b
-00010111b ^ 10110001b = 10100110b
-00010111b ^ 10110010b = 10100101b
-00010111b ^ 10110011b = 10100100b
-00010111b ^ 10110100b = 10100011b
-00010111b ^ 10110101b = 10100010b
-00010111b ^ 10110110b = 10100001b
-00010111b ^ 10110111b = 10100000b
-00010111b ^ 10111000b = 10101111b
-00010111b ^ 10111001b = 10101110b
-00010111b ^ 10111010b = 10101101b
-00010111b ^ 10111011b = 10101100b
-00010111b ^ 10111100b = 10101011b
-00010111b ^ 10111101b = 10101010b
-00010111b ^ 10111110b = 10101001b
-00010111b ^ 10111111b = 10101000b
-00010111b ^ 11000000b = 11010111b
-00010111b ^ 11000001b = 11010110b
-00010111b ^ 11000010b = 11010101b
-00010111b ^ 11000011b = 11010100b
-00010111b ^ 11000100b = 11010011b
-00010111b ^ 11000101b = 11010010b
-00010111b ^ 11000110b = 11010001b
-00010111b ^ 11000111b = 11010000b
-00010111b ^ 11001000b = 11011111b
-00010111b ^ 11001001b = 11011110b
-00010111b ^ 11001010b = 11011101b
-00010111b ^ 11001011b = 11011100b
-00010111b ^ 11001100b = 11011011b
-00010111b ^ 11001101b = 11011010b
-00010111b ^ 11001110b = 11011001b
-00010111b ^ 11001111b = 11011000b
-00010111b ^ 11010000b = 11000111b
-00010111b ^ 11010001b = 11000110b
-00010111b ^ 11010010b = 11000101b
-00010111b ^ 11010011b = 11000100b
-00010111b ^ 11010100b = 11000011b
-00010111b ^ 11010101b = 11000010b
-00010111b ^ 11010110b = 11000001b
-00010111b ^ 11010111b = 11000000b
-00010111b ^ 11011000b = 11001111b
-00010111b ^ 11011001b = 11001110b
-00010111b ^ 11011010b = 11001101b
-00010111b ^ 11011011b = 11001100b
-00010111b ^ 11011100b = 11001011b
-00010111b ^ 11011101b = 11001010b
-00010111b ^ 11011110b = 11001001b
-00010111b ^ 11011111b = 11001000b
-00010111b ^ 11100000b = 11110111b
-00010111b ^ 11100001b = 11110110b
-00010111b ^ 11100010b = 11110101b
-00010111b ^ 11100011b = 11110100b
-00010111b ^ 11100100b = 11110011b
-00010111b ^ 11100101b = 11110010b
-00010111b ^ 11100110b = 11110001b
-00010111b ^ 11100111b = 11110000b
-00010111b ^ 11101000b = 11111111b
-00010111b ^ 11101001b = 11111110b
-00010111b ^ 11101010b = 11111101b
-00010111b ^ 11101011b = 11111100b
-00010111b ^ 11101100b = 11111011b
-00010111b ^ 11101101b = 11111010b
-00010111b ^ 11101110b = 11111001b
-00010111b ^ 11101111b = 11111000b
-00010111b ^ 11110000b = 11100111b
-00010111b ^ 11110001b = 11100110b
-00010111b ^ 11110010b = 11100101b
-00010111b ^ 11110011b = 11100100b
-00010111b ^ 11110100b = 11100011b
-00010111b ^ 11110101b = 11100010b
-00010111b ^ 11110110b = 11100001b
-00010111b ^ 11110111b = 11100000b
-00010111b ^ 11111000b = 11101111b
-00010111b ^ 11111001b = 11101110b
-00010111b ^ 11111010b = 11101101b
-00010111b ^ 11111011b = 11101100b
-00010111b ^ 11111100b = 11101011b
-00010111b ^ 11111101b = 11101010b
-00010111b ^ 11111110b = 11101001b
-00010111b ^ 11111111b = 11101000b
-00010111b ^ 00000000b = 00010111b
-00010111b ^ 00000001b = 00010110b
-00010111b ^ 00000010b = 00010101b
-00010111b ^ 00000011b = 00010100b
-00010111b ^ 00000100b = 00010011b
-00010111b ^ 00000101b = 00010010b
-00010111b ^ 00000110b = 00010001b
-00010111b ^ 00000111b = 00010000b
-00010111b ^ 00001000b = 00011111b
-00010111b ^ 00001001b = 00011110b
-00010111b ^ 00001010b = 00011101b
-00010111b ^ 00001011b = 00011100b
-00010111b ^ 00001100b = 00011011b
-00010111b ^ 00001101b = 00011010b
-00010111b ^ 00001110b = 00011001b
-00010111b ^ 00001111b = 00011000b
-00010111b ^ 00010000b = 00000111b
-00010111b ^ 00010001b = 00000110b
-00010111b ^ 00010010b = 00000101b
-00010111b ^ 00010011b = 00000100b
-00010111b ^ 00010100b = 00000011b
-00010111b ^ 00010101b = 00000010b
-00010111b ^ 00010110b = 00000001b
-00010111b ^ 00010111b = 00000000b
-00010111b ^ 00011000b = 00001111b
-00010111b ^ 00011001b = 00001110b
-00010111b ^ 00011010b = 00001101b
-00010111b ^ 00011011b = 00001100b
-00010111b ^ 00011100b = 00001011b
-00010111b ^ 00011101b = 00001010b
-00010111b ^ 00011110b = 00001001b
-00010111b ^ 00011111b = 00001000b
-00010111b ^ 00100000b = 00110111b
-00010111b ^ 00100001b = 00110110b
-00010111b ^ 00100010b = 00110101b
-00010111b ^ 00100011b = 00110100b
-00010111b ^ 00100100b = 00110011b
-00010111b ^ 00100101b = 00110010b
-00010111b ^ 00100110b = 00110001b
-00010111b ^ 00100111b = 00110000b
-00010111b ^ 00101000b = 00111111b
-00010111b ^ 00101001b = 00111110b
-00010111b ^ 00101010b = 00111101b
-00010111b ^ 00101011b = 00111100b
-00010111b ^ 00101100b = 00111011b
-00010111b ^ 00101101b = 00111010b
-00010111b ^ 00101110b = 00111001b
-00010111b ^ 00101111b = 00111000b
-00010111b ^ 00110000b = 00100111b
-00010111b ^ 00110001b = 00100110b
-00010111b ^ 00110010b = 00100101b
-00010111b ^ 00110011b = 00100100b
-00010111b ^ 00110100b = 00100011b
-00010111b ^ 00110101b = 00100010b
-00010111b ^ 00110110b = 00100001b
-00010111b ^ 00110111b = 00100000b
-00010111b ^ 00111000b = 00101111b
-00010111b ^ 00111001b = 00101110b
-00010111b ^ 00111010b = 00101101b
-00010111b ^ 00111011b = 00101100b
-00010111b ^ 00111100b = 00101011b
-00010111b ^ 00111101b = 00101010b
-00010111b ^ 00111110b = 00101001b
-00010111b ^ 00111111b = 00101000b
-00010111b ^ 01000000b = 01010111b
-00010111b ^ 01000001b = 01010110b
-00010111b ^ 01000010b = 01010101b
-00010111b ^ 01000011b = 01010100b
-00010111b ^ 01000100b = 01010011b
-00010111b ^ 01000101b = 01010010b
-00010111b ^ 01000110b = 01010001b
-00010111b ^ 01000111b = 01010000b
-00010111b ^ 01001000b = 01011111b
-00010111b ^ 01001001b = 01011110b
-00010111b ^ 01001010b = 01011101b
-00010111b ^ 01001011b = 01011100b
-00010111b ^ 01001100b = 01011011b
-00010111b ^ 01001101b = 01011010b
-00010111b ^ 01001110b = 01011001b
-00010111b ^ 01001111b = 01011000b
-00010111b ^ 01010000b = 01000111b
-00010111b ^ 01010001b = 01000110b
-00010111b ^ 01010010b = 01000101b
-00010111b ^ 01010011b = 01000100b
-00010111b ^ 01010100b = 01000011b
-00010111b ^ 01010101b = 01000010b
-00010111b ^ 01010110b = 01000001b
-00010111b ^ 01010111b = 01000000b
-00010111b ^ 01011000b = 01001111b
-00010111b ^ 01011001b = 01001110b
-00010111b ^ 01011010b = 01001101b
-00010111b ^ 01011011b = 01001100b
-00010111b ^ 01011100b = 01001011b
-00010111b ^ 01011101b = 01001010b
-00010111b ^ 01011110b = 01001001b
-00010111b ^ 01011111b = 01001000b
-00010111b ^ 01100000b = 01110111b
-00010111b ^ 01100001b = 01110110b
-00010111b ^ 01100010b = 01110101b
-00010111b ^ 01100011b = 01110100b
-00010111b ^ 01100100b = 01110011b
-00010111b ^ 01100101b = 01110010b
-00010111b ^ 01100110b = 01110001b
-00010111b ^ 01100111b = 01110000b
-00010111b ^ 01101000b = 01111111b
-00010111b ^ 01101001b = 01111110b
-00010111b ^ 01101010b = 01111101b
-00010111b ^ 01101011b = 01111100b
-00010111b ^ 01101100b = 01111011b
-00010111b ^ 01101101b = 01111010b
-00010111b ^ 01101110b = 01111001b
-00010111b ^ 01101111b = 01111000b
-00010111b ^ 01110000b = 01100111b
-00010111b ^ 01110001b = 01100110b
-00010111b ^ 01110010b = 01100101b
-00010111b ^ 01110011b = 01100100b
-00010111b ^ 01110100b = 01100011b
-00010111b ^ 01110101b = 01100010b
-00010111b ^ 01110110b = 01100001b
-00010111b ^ 01110111b = 01100000b
-00010111b ^ 01111000b = 01101111b
-00010111b ^ 01111001b = 01101110b
-00010111b ^ 01111010b = 01101101b
-00010111b ^ 01111011b = 01101100b
-00010111b ^ 01111100b = 01101011b
-00010111b ^ 01111101b = 01101010b
-00010111b ^ 01111110b = 01101001b
-00011000b ^ 10000000b = 10011000b
-00011000b ^ 10000001b = 10011001b
-00011000b ^ 10000010b = 10011010b
-00011000b ^ 10000011b = 10011011b
-00011000b ^ 10000100b = 10011100b
-00011000b ^ 10000101b = 10011101b
-00011000b ^ 10000110b = 10011110b
-00011000b ^ 10000111b = 10011111b
-00011000b ^ 10001000b = 10010000b
-00011000b ^ 10001001b = 10010001b
-00011000b ^ 10001010b = 10010010b
-00011000b ^ 10001011b = 10010011b
-00011000b ^ 10001100b = 10010100b
-00011000b ^ 10001101b = 10010101b
-00011000b ^ 10001110b = 10010110b
-00011000b ^ 10001111b = 10010111b
-00011000b ^ 10010000b = 10001000b
-00011000b ^ 10010001b = 10001001b
-00011000b ^ 10010010b = 10001010b
-00011000b ^ 10010011b = 10001011b
-00011000b ^ 10010100b = 10001100b
-00011000b ^ 10010101b = 10001101b
-00011000b ^ 10010110b = 10001110b
-00011000b ^ 10010111b = 10001111b
-00011000b ^ 10011000b = 10000000b
-00011000b ^ 10011001b = 10000001b
-00011000b ^ 10011010b = 10000010b
-00011000b ^ 10011011b = 10000011b
-00011000b ^ 10011100b = 10000100b
-00011000b ^ 10011101b = 10000101b
-00011000b ^ 10011110b = 10000110b
-00011000b ^ 10011111b = 10000111b
-00011000b ^ 10100000b = 10111000b
-00011000b ^ 10100001b = 10111001b
-00011000b ^ 10100010b = 10111010b
-00011000b ^ 10100011b = 10111011b
-00011000b ^ 10100100b = 10111100b
-00011000b ^ 10100101b = 10111101b
-00011000b ^ 10100110b = 10111110b
-00011000b ^ 10100111b = 10111111b
-00011000b ^ 10101000b = 10110000b
-00011000b ^ 10101001b = 10110001b
-00011000b ^ 10101010b = 10110010b
-00011000b ^ 10101011b = 10110011b
-00011000b ^ 10101100b = 10110100b
-00011000b ^ 10101101b = 10110101b
-00011000b ^ 10101110b = 10110110b
-00011000b ^ 10101111b = 10110111b
-00011000b ^ 10110000b = 10101000b
-00011000b ^ 10110001b = 10101001b
-00011000b ^ 10110010b = 10101010b
-00011000b ^ 10110011b = 10101011b
-00011000b ^ 10110100b = 10101100b
-00011000b ^ 10110101b = 10101101b
-00011000b ^ 10110110b = 10101110b
-00011000b ^ 10110111b = 10101111b
-00011000b ^ 10111000b = 10100000b
-00011000b ^ 10111001b = 10100001b
-00011000b ^ 10111010b = 10100010b
-00011000b ^ 10111011b = 10100011b
-00011000b ^ 10111100b = 10100100b
-00011000b ^ 10111101b = 10100101b
-00011000b ^ 10111110b = 10100110b
-00011000b ^ 10111111b = 10100111b
-00011000b ^ 11000000b = 11011000b
-00011000b ^ 11000001b = 11011001b
-00011000b ^ 11000010b = 11011010b
-00011000b ^ 11000011b = 11011011b
-00011000b ^ 11000100b = 11011100b
-00011000b ^ 11000101b = 11011101b
-00011000b ^ 11000110b = 11011110b
-00011000b ^ 11000111b = 11011111b
-00011000b ^ 11001000b = 11010000b
-00011000b ^ 11001001b = 11010001b
-00011000b ^ 11001010b = 11010010b
-00011000b ^ 11001011b = 11010011b
-00011000b ^ 11001100b = 11010100b
-00011000b ^ 11001101b = 11010101b
-00011000b ^ 11001110b = 11010110b
-00011000b ^ 11001111b = 11010111b
-00011000b ^ 11010000b = 11001000b
-00011000b ^ 11010001b = 11001001b
-00011000b ^ 11010010b = 11001010b
-00011000b ^ 11010011b = 11001011b
-00011000b ^ 11010100b = 11001100b
-00011000b ^ 11010101b = 11001101b
-00011000b ^ 11010110b = 11001110b
-00011000b ^ 11010111b = 11001111b
-00011000b ^ 11011000b = 11000000b
-00011000b ^ 11011001b = 11000001b
-00011000b ^ 11011010b = 11000010b
-00011000b ^ 11011011b = 11000011b
-00011000b ^ 11011100b = 11000100b
-00011000b ^ 11011101b = 11000101b
-00011000b ^ 11011110b = 11000110b
-00011000b ^ 11011111b = 11000111b
-00011000b ^ 11100000b = 11111000b
-00011000b ^ 11100001b = 11111001b
-00011000b ^ 11100010b = 11111010b
-00011000b ^ 11100011b = 11111011b
-00011000b ^ 11100100b = 11111100b
-00011000b ^ 11100101b = 11111101b
-00011000b ^ 11100110b = 11111110b
-00011000b ^ 11100111b = 11111111b
-00011000b ^ 11101000b = 11110000b
-00011000b ^ 11101001b = 11110001b
-00011000b ^ 11101010b = 11110010b
-00011000b ^ 11101011b = 11110011b
-00011000b ^ 11101100b = 11110100b
-00011000b ^ 11101101b = 11110101b
-00011000b ^ 11101110b = 11110110b
-00011000b ^ 11101111b = 11110111b
-00011000b ^ 11110000b = 11101000b
-00011000b ^ 11110001b = 11101001b
-00011000b ^ 11110010b = 11101010b
-00011000b ^ 11110011b = 11101011b
-00011000b ^ 11110100b = 11101100b
-00011000b ^ 11110101b = 11101101b
-00011000b ^ 11110110b = 11101110b
-00011000b ^ 11110111b = 11101111b
-00011000b ^ 11111000b = 11100000b
-00011000b ^ 11111001b = 11100001b
-00011000b ^ 11111010b = 11100010b
-00011000b ^ 11111011b = 11100011b
-00011000b ^ 11111100b = 11100100b
-00011000b ^ 11111101b = 11100101b
-00011000b ^ 11111110b = 11100110b
-00011000b ^ 11111111b = 11100111b
-00011000b ^ 00000000b = 00011000b
-00011000b ^ 00000001b = 00011001b
-00011000b ^ 00000010b = 00011010b
-00011000b ^ 00000011b = 00011011b
-00011000b ^ 00000100b = 00011100b
-00011000b ^ 00000101b = 00011101b
-00011000b ^ 00000110b = 00011110b
-00011000b ^ 00000111b = 00011111b
-00011000b ^ 00001000b = 00010000b
-00011000b ^ 00001001b = 00010001b
-00011000b ^ 00001010b = 00010010b
-00011000b ^ 00001011b = 00010011b
-00011000b ^ 00001100b = 00010100b
-00011000b ^ 00001101b = 00010101b
-00011000b ^ 00001110b = 00010110b
-00011000b ^ 00001111b = 00010111b
-00011000b ^ 00010000b = 00001000b
-00011000b ^ 00010001b = 00001001b
-00011000b ^ 00010010b = 00001010b
-00011000b ^ 00010011b = 00001011b
-00011000b ^ 00010100b = 00001100b
-00011000b ^ 00010101b = 00001101b
-00011000b ^ 00010110b = 00001110b
-00011000b ^ 00010111b = 00001111b
-00011000b ^ 00011000b = 00000000b
-00011000b ^ 00011001b = 00000001b
-00011000b ^ 00011010b = 00000010b
-00011000b ^ 00011011b = 00000011b
-00011000b ^ 00011100b = 00000100b
-00011000b ^ 00011101b = 00000101b
-00011000b ^ 00011110b = 00000110b
-00011000b ^ 00011111b = 00000111b
-00011000b ^ 00100000b = 00111000b
-00011000b ^ 00100001b = 00111001b
-00011000b ^ 00100010b = 00111010b
-00011000b ^ 00100011b = 00111011b
-00011000b ^ 00100100b = 00111100b
-00011000b ^ 00100101b = 00111101b
-00011000b ^ 00100110b = 00111110b
-00011000b ^ 00100111b = 00111111b
-00011000b ^ 00101000b = 00110000b
-00011000b ^ 00101001b = 00110001b
-00011000b ^ 00101010b = 00110010b
-00011000b ^ 00101011b = 00110011b
-00011000b ^ 00101100b = 00110100b
-00011000b ^ 00101101b = 00110101b
-00011000b ^ 00101110b = 00110110b
-00011000b ^ 00101111b = 00110111b
-00011000b ^ 00110000b = 00101000b
-00011000b ^ 00110001b = 00101001b
-00011000b ^ 00110010b = 00101010b
-00011000b ^ 00110011b = 00101011b
-00011000b ^ 00110100b = 00101100b
-00011000b ^ 00110101b = 00101101b
-00011000b ^ 00110110b = 00101110b
-00011000b ^ 00110111b = 00101111b
-00011000b ^ 00111000b = 00100000b
-00011000b ^ 00111001b = 00100001b
-00011000b ^ 00111010b = 00100010b
-00011000b ^ 00111011b = 00100011b
-00011000b ^ 00111100b = 00100100b
-00011000b ^ 00111101b = 00100101b
-00011000b ^ 00111110b = 00100110b
-00011000b ^ 00111111b = 00100111b
-00011000b ^ 01000000b = 01011000b
-00011000b ^ 01000001b = 01011001b
-00011000b ^ 01000010b = 01011010b
-00011000b ^ 01000011b = 01011011b
-00011000b ^ 01000100b = 01011100b
-00011000b ^ 01000101b = 01011101b
-00011000b ^ 01000110b = 01011110b
-00011000b ^ 01000111b = 01011111b
-00011000b ^ 01001000b = 01010000b
-00011000b ^ 01001001b = 01010001b
-00011000b ^ 01001010b = 01010010b
-00011000b ^ 01001011b = 01010011b
-00011000b ^ 01001100b = 01010100b
-00011000b ^ 01001101b = 01010101b
-00011000b ^ 01001110b = 01010110b
-00011000b ^ 01001111b = 01010111b
-00011000b ^ 01010000b = 01001000b
-00011000b ^ 01010001b = 01001001b
-00011000b ^ 01010010b = 01001010b
-00011000b ^ 01010011b = 01001011b
-00011000b ^ 01010100b = 01001100b
-00011000b ^ 01010101b = 01001101b
-00011000b ^ 01010110b = 01001110b
-00011000b ^ 01010111b = 01001111b
-00011000b ^ 01011000b = 01000000b
-00011000b ^ 01011001b = 01000001b
-00011000b ^ 01011010b = 01000010b
-00011000b ^ 01011011b = 01000011b
-00011000b ^ 01011100b = 01000100b
-00011000b ^ 01011101b = 01000101b
-00011000b ^ 01011110b = 01000110b
-00011000b ^ 01011111b = 01000111b
-00011000b ^ 01100000b = 01111000b
-00011000b ^ 01100001b = 01111001b
-00011000b ^ 01100010b = 01111010b
-00011000b ^ 01100011b = 01111011b
-00011000b ^ 01100100b = 01111100b
-00011000b ^ 01100101b = 01111101b
-00011000b ^ 01100110b = 01111110b
-00011000b ^ 01100111b = 01111111b
-00011000b ^ 01101000b = 01110000b
-00011000b ^ 01101001b = 01110001b
-00011000b ^ 01101010b = 01110010b
-00011000b ^ 01101011b = 01110011b
-00011000b ^ 01101100b = 01110100b
-00011000b ^ 01101101b = 01110101b
-00011000b ^ 01101110b = 01110110b
-00011000b ^ 01101111b = 01110111b
-00011000b ^ 01110000b = 01101000b
-00011000b ^ 01110001b = 01101001b
-00011000b ^ 01110010b = 01101010b
-00011000b ^ 01110011b = 01101011b
-00011000b ^ 01110100b = 01101100b
-00011000b ^ 01110101b = 01101101b
-00011000b ^ 01110110b = 01101110b
-00011000b ^ 01110111b = 01101111b
-00011000b ^ 01111000b = 01100000b
-00011000b ^ 01111001b = 01100001b
-00011000b ^ 01111010b = 01100010b
-00011000b ^ 01111011b = 01100011b
-00011000b ^ 01111100b = 01100100b
-00011000b ^ 01111101b = 01100101b
-00011000b ^ 01111110b = 01100110b
-00011001b ^ 10000000b = 10011001b
-00011001b ^ 10000001b = 10011000b
-00011001b ^ 10000010b = 10011011b
-00011001b ^ 10000011b = 10011010b
-00011001b ^ 10000100b = 10011101b
-00011001b ^ 10000101b = 10011100b
-00011001b ^ 10000110b = 10011111b
-00011001b ^ 10000111b = 10011110b
-00011001b ^ 10001000b = 10010001b
-00011001b ^ 10001001b = 10010000b
-00011001b ^ 10001010b = 10010011b
-00011001b ^ 10001011b = 10010010b
-00011001b ^ 10001100b = 10010101b
-00011001b ^ 10001101b = 10010100b
-00011001b ^ 10001110b = 10010111b
-00011001b ^ 10001111b = 10010110b
-00011001b ^ 10010000b = 10001001b
-00011001b ^ 10010001b = 10001000b
-00011001b ^ 10010010b = 10001011b
-00011001b ^ 10010011b = 10001010b
-00011001b ^ 10010100b = 10001101b
-00011001b ^ 10010101b = 10001100b
-00011001b ^ 10010110b = 10001111b
-00011001b ^ 10010111b = 10001110b
-00011001b ^ 10011000b = 10000001b
-00011001b ^ 10011001b = 10000000b
-00011001b ^ 10011010b = 10000011b
-00011001b ^ 10011011b = 10000010b
-00011001b ^ 10011100b = 10000101b
-00011001b ^ 10011101b = 10000100b
-00011001b ^ 10011110b = 10000111b
-00011001b ^ 10011111b = 10000110b
-00011001b ^ 10100000b = 10111001b
-00011001b ^ 10100001b = 10111000b
-00011001b ^ 10100010b = 10111011b
-00011001b ^ 10100011b = 10111010b
-00011001b ^ 10100100b = 10111101b
-00011001b ^ 10100101b = 10111100b
-00011001b ^ 10100110b = 10111111b
-00011001b ^ 10100111b = 10111110b
-00011001b ^ 10101000b = 10110001b
-00011001b ^ 10101001b = 10110000b
-00011001b ^ 10101010b = 10110011b
-00011001b ^ 10101011b = 10110010b
-00011001b ^ 10101100b = 10110101b
-00011001b ^ 10101101b = 10110100b
-00011001b ^ 10101110b = 10110111b
-00011001b ^ 10101111b = 10110110b
-00011001b ^ 10110000b = 10101001b
-00011001b ^ 10110001b = 10101000b
-00011001b ^ 10110010b = 10101011b
-00011001b ^ 10110011b = 10101010b
-00011001b ^ 10110100b = 10101101b
-00011001b ^ 10110101b = 10101100b
-00011001b ^ 10110110b = 10101111b
-00011001b ^ 10110111b = 10101110b
-00011001b ^ 10111000b = 10100001b
-00011001b ^ 10111001b = 10100000b
-00011001b ^ 10111010b = 10100011b
-00011001b ^ 10111011b = 10100010b
-00011001b ^ 10111100b = 10100101b
-00011001b ^ 10111101b = 10100100b
-00011001b ^ 10111110b = 10100111b
-00011001b ^ 10111111b = 10100110b
-00011001b ^ 11000000b = 11011001b
-00011001b ^ 11000001b = 11011000b
-00011001b ^ 11000010b = 11011011b
-00011001b ^ 11000011b = 11011010b
-00011001b ^ 11000100b = 11011101b
-00011001b ^ 11000101b = 11011100b
-00011001b ^ 11000110b = 11011111b
-00011001b ^ 11000111b = 11011110b
-00011001b ^ 11001000b = 11010001b
-00011001b ^ 11001001b = 11010000b
-00011001b ^ 11001010b = 11010011b
-00011001b ^ 11001011b = 11010010b
-00011001b ^ 11001100b = 11010101b
-00011001b ^ 11001101b = 11010100b
-00011001b ^ 11001110b = 11010111b
-00011001b ^ 11001111b = 11010110b
-00011001b ^ 11010000b = 11001001b
-00011001b ^ 11010001b = 11001000b
-00011001b ^ 11010010b = 11001011b
-00011001b ^ 11010011b = 11001010b
-00011001b ^ 11010100b = 11001101b
-00011001b ^ 11010101b = 11001100b
-00011001b ^ 11010110b = 11001111b
-00011001b ^ 11010111b = 11001110b
-00011001b ^ 11011000b = 11000001b
-00011001b ^ 11011001b = 11000000b
-00011001b ^ 11011010b = 11000011b
-00011001b ^ 11011011b = 11000010b
-00011001b ^ 11011100b = 11000101b
-00011001b ^ 11011101b = 11000100b
-00011001b ^ 11011110b = 11000111b
-00011001b ^ 11011111b = 11000110b
-00011001b ^ 11100000b = 11111001b
-00011001b ^ 11100001b = 11111000b
-00011001b ^ 11100010b = 11111011b
-00011001b ^ 11100011b = 11111010b
-00011001b ^ 11100100b = 11111101b
-00011001b ^ 11100101b = 11111100b
-00011001b ^ 11100110b = 11111111b
-00011001b ^ 11100111b = 11111110b
-00011001b ^ 11101000b = 11110001b
-00011001b ^ 11101001b = 11110000b
-00011001b ^ 11101010b = 11110011b
-00011001b ^ 11101011b = 11110010b
-00011001b ^ 11101100b = 11110101b
-00011001b ^ 11101101b = 11110100b
-00011001b ^ 11101110b = 11110111b
-00011001b ^ 11101111b = 11110110b
-00011001b ^ 11110000b = 11101001b
-00011001b ^ 11110001b = 11101000b
-00011001b ^ 11110010b = 11101011b
-00011001b ^ 11110011b = 11101010b
-00011001b ^ 11110100b = 11101101b
-00011001b ^ 11110101b = 11101100b
-00011001b ^ 11110110b = 11101111b
-00011001b ^ 11110111b = 11101110b
-00011001b ^ 11111000b = 11100001b
-00011001b ^ 11111001b = 11100000b
-00011001b ^ 11111010b = 11100011b
-00011001b ^ 11111011b = 11100010b
-00011001b ^ 11111100b = 11100101b
-00011001b ^ 11111101b = 11100100b
-00011001b ^ 11111110b = 11100111b
-00011001b ^ 11111111b = 11100110b
-00011001b ^ 00000000b = 00011001b
-00011001b ^ 00000001b = 00011000b
-00011001b ^ 00000010b = 00011011b
-00011001b ^ 00000011b = 00011010b
-00011001b ^ 00000100b = 00011101b
-00011001b ^ 00000101b = 00011100b
-00011001b ^ 00000110b = 00011111b
-00011001b ^ 00000111b = 00011110b
-00011001b ^ 00001000b = 00010001b
-00011001b ^ 00001001b = 00010000b
-00011001b ^ 00001010b = 00010011b
-00011001b ^ 00001011b = 00010010b
-00011001b ^ 00001100b = 00010101b
-00011001b ^ 00001101b = 00010100b
-00011001b ^ 00001110b = 00010111b
-00011001b ^ 00001111b = 00010110b
-00011001b ^ 00010000b = 00001001b
-00011001b ^ 00010001b = 00001000b
-00011001b ^ 00010010b = 00001011b
-00011001b ^ 00010011b = 00001010b
-00011001b ^ 00010100b = 00001101b
-00011001b ^ 00010101b = 00001100b
-00011001b ^ 00010110b = 00001111b
-00011001b ^ 00010111b = 00001110b
-00011001b ^ 00011000b = 00000001b
-00011001b ^ 00011001b = 00000000b
-00011001b ^ 00011010b = 00000011b
-00011001b ^ 00011011b = 00000010b
-00011001b ^ 00011100b = 00000101b
-00011001b ^ 00011101b = 00000100b
-00011001b ^ 00011110b = 00000111b
-00011001b ^ 00011111b = 00000110b
-00011001b ^ 00100000b = 00111001b
-00011001b ^ 00100001b = 00111000b
-00011001b ^ 00100010b = 00111011b
-00011001b ^ 00100011b = 00111010b
-00011001b ^ 00100100b = 00111101b
-00011001b ^ 00100101b = 00111100b
-00011001b ^ 00100110b = 00111111b
-00011001b ^ 00100111b = 00111110b
-00011001b ^ 00101000b = 00110001b
-00011001b ^ 00101001b = 00110000b
-00011001b ^ 00101010b = 00110011b
-00011001b ^ 00101011b = 00110010b
-00011001b ^ 00101100b = 00110101b
-00011001b ^ 00101101b = 00110100b
-00011001b ^ 00101110b = 00110111b
-00011001b ^ 00101111b = 00110110b
-00011001b ^ 00110000b = 00101001b
-00011001b ^ 00110001b = 00101000b
-00011001b ^ 00110010b = 00101011b
-00011001b ^ 00110011b = 00101010b
-00011001b ^ 00110100b = 00101101b
-00011001b ^ 00110101b = 00101100b
-00011001b ^ 00110110b = 00101111b
-00011001b ^ 00110111b = 00101110b
-00011001b ^ 00111000b = 00100001b
-00011001b ^ 00111001b = 00100000b
-00011001b ^ 00111010b = 00100011b
-00011001b ^ 00111011b = 00100010b
-00011001b ^ 00111100b = 00100101b
-00011001b ^ 00111101b = 00100100b
-00011001b ^ 00111110b = 00100111b
-00011001b ^ 00111111b = 00100110b
-00011001b ^ 01000000b = 01011001b
-00011001b ^ 01000001b = 01011000b
-00011001b ^ 01000010b = 01011011b
-00011001b ^ 01000011b = 01011010b
-00011001b ^ 01000100b = 01011101b
-00011001b ^ 01000101b = 01011100b
-00011001b ^ 01000110b = 01011111b
-00011001b ^ 01000111b = 01011110b
-00011001b ^ 01001000b = 01010001b
-00011001b ^ 01001001b = 01010000b
-00011001b ^ 01001010b = 01010011b
-00011001b ^ 01001011b = 01010010b
-00011001b ^ 01001100b = 01010101b
-00011001b ^ 01001101b = 01010100b
-00011001b ^ 01001110b = 01010111b
-00011001b ^ 01001111b = 01010110b
-00011001b ^ 01010000b = 01001001b
-00011001b ^ 01010001b = 01001000b
-00011001b ^ 01010010b = 01001011b
-00011001b ^ 01010011b = 01001010b
-00011001b ^ 01010100b = 01001101b
-00011001b ^ 01010101b = 01001100b
-00011001b ^ 01010110b = 01001111b
-00011001b ^ 01010111b = 01001110b
-00011001b ^ 01011000b = 01000001b
-00011001b ^ 01011001b = 01000000b
-00011001b ^ 01011010b = 01000011b
-00011001b ^ 01011011b = 01000010b
-00011001b ^ 01011100b = 01000101b
-00011001b ^ 01011101b = 01000100b
-00011001b ^ 01011110b = 01000111b
-00011001b ^ 01011111b = 01000110b
-00011001b ^ 01100000b = 01111001b
-00011001b ^ 01100001b = 01111000b
-00011001b ^ 01100010b = 01111011b
-00011001b ^ 01100011b = 01111010b
-00011001b ^ 01100100b = 01111101b
-00011001b ^ 01100101b = 01111100b
-00011001b ^ 01100110b = 01111111b
-00011001b ^ 01100111b = 01111110b
-00011001b ^ 01101000b = 01110001b
-00011001b ^ 01101001b = 01110000b
-00011001b ^ 01101010b = 01110011b
-00011001b ^ 01101011b = 01110010b
-00011001b ^ 01101100b = 01110101b
-00011001b ^ 01101101b = 01110100b
-00011001b ^ 01101110b = 01110111b
-00011001b ^ 01101111b = 01110110b
-00011001b ^ 01110000b = 01101001b
-00011001b ^ 01110001b = 01101000b
-00011001b ^ 01110010b = 01101011b
-00011001b ^ 01110011b = 01101010b
-00011001b ^ 01110100b = 01101101b
-00011001b ^ 01110101b = 01101100b
-00011001b ^ 01110110b = 01101111b
-00011001b ^ 01110111b = 01101110b
-00011001b ^ 01111000b = 01100001b
-00011001b ^ 01111001b = 01100000b
-00011001b ^ 01111010b = 01100011b
-00011001b ^ 01111011b = 01100010b
-00011001b ^ 01111100b = 01100101b
-00011001b ^ 01111101b = 01100100b
-00011001b ^ 01111110b = 01100111b
-00011010b ^ 10000000b = 10011010b
-00011010b ^ 10000001b = 10011011b
-00011010b ^ 10000010b = 10011000b
-00011010b ^ 10000011b = 10011001b
-00011010b ^ 10000100b = 10011110b
-00011010b ^ 10000101b = 10011111b
-00011010b ^ 10000110b = 10011100b
-00011010b ^ 10000111b = 10011101b
-00011010b ^ 10001000b = 10010010b
-00011010b ^ 10001001b = 10010011b
-00011010b ^ 10001010b = 10010000b
-00011010b ^ 10001011b = 10010001b
-00011010b ^ 10001100b = 10010110b
-00011010b ^ 10001101b = 10010111b
-00011010b ^ 10001110b = 10010100b
-00011010b ^ 10001111b = 10010101b
-00011010b ^ 10010000b = 10001010b
-00011010b ^ 10010001b = 10001011b
-00011010b ^ 10010010b = 10001000b
-00011010b ^ 10010011b = 10001001b
-00011010b ^ 10010100b = 10001110b
-00011010b ^ 10010101b = 10001111b
-00011010b ^ 10010110b = 10001100b
-00011010b ^ 10010111b = 10001101b
-00011010b ^ 10011000b = 10000010b
-00011010b ^ 10011001b = 10000011b
-00011010b ^ 10011010b = 10000000b
-00011010b ^ 10011011b = 10000001b
-00011010b ^ 10011100b = 10000110b
-00011010b ^ 10011101b = 10000111b
-00011010b ^ 10011110b = 10000100b
-00011010b ^ 10011111b = 10000101b
-00011010b ^ 10100000b = 10111010b
-00011010b ^ 10100001b = 10111011b
-00011010b ^ 10100010b = 10111000b
-00011010b ^ 10100011b = 10111001b
-00011010b ^ 10100100b = 10111110b
-00011010b ^ 10100101b = 10111111b
-00011010b ^ 10100110b = 10111100b
-00011010b ^ 10100111b = 10111101b
-00011010b ^ 10101000b = 10110010b
-00011010b ^ 10101001b = 10110011b
-00011010b ^ 10101010b = 10110000b
-00011010b ^ 10101011b = 10110001b
-00011010b ^ 10101100b = 10110110b
-00011010b ^ 10101101b = 10110111b
-00011010b ^ 10101110b = 10110100b
-00011010b ^ 10101111b = 10110101b
-00011010b ^ 10110000b = 10101010b
-00011010b ^ 10110001b = 10101011b
-00011010b ^ 10110010b = 10101000b
-00011010b ^ 10110011b = 10101001b
-00011010b ^ 10110100b = 10101110b
-00011010b ^ 10110101b = 10101111b
-00011010b ^ 10110110b = 10101100b
-00011010b ^ 10110111b = 10101101b
-00011010b ^ 10111000b = 10100010b
-00011010b ^ 10111001b = 10100011b
-00011010b ^ 10111010b = 10100000b
-00011010b ^ 10111011b = 10100001b
-00011010b ^ 10111100b = 10100110b
-00011010b ^ 10111101b = 10100111b
-00011010b ^ 10111110b = 10100100b
-00011010b ^ 10111111b = 10100101b
-00011010b ^ 11000000b = 11011010b
-00011010b ^ 11000001b = 11011011b
-00011010b ^ 11000010b = 11011000b
-00011010b ^ 11000011b = 11011001b
-00011010b ^ 11000100b = 11011110b
-00011010b ^ 11000101b = 11011111b
-00011010b ^ 11000110b = 11011100b
-00011010b ^ 11000111b = 11011101b
-00011010b ^ 11001000b = 11010010b
-00011010b ^ 11001001b = 11010011b
-00011010b ^ 11001010b = 11010000b
-00011010b ^ 11001011b = 11010001b
-00011010b ^ 11001100b = 11010110b
-00011010b ^ 11001101b = 11010111b
-00011010b ^ 11001110b = 11010100b
-00011010b ^ 11001111b = 11010101b
-00011010b ^ 11010000b = 11001010b
-00011010b ^ 11010001b = 11001011b
-00011010b ^ 11010010b = 11001000b
-00011010b ^ 11010011b = 11001001b
-00011010b ^ 11010100b = 11001110b
-00011010b ^ 11010101b = 11001111b
-00011010b ^ 11010110b = 11001100b
-00011010b ^ 11010111b = 11001101b
-00011010b ^ 11011000b = 11000010b
-00011010b ^ 11011001b = 11000011b
-00011010b ^ 11011010b = 11000000b
-00011010b ^ 11011011b = 11000001b
-00011010b ^ 11011100b = 11000110b
-00011010b ^ 11011101b = 11000111b
-00011010b ^ 11011110b = 11000100b
-00011010b ^ 11011111b = 11000101b
-00011010b ^ 11100000b = 11111010b
-00011010b ^ 11100001b = 11111011b
-00011010b ^ 11100010b = 11111000b
-00011010b ^ 11100011b = 11111001b
-00011010b ^ 11100100b = 11111110b
-00011010b ^ 11100101b = 11111111b
-00011010b ^ 11100110b = 11111100b
-00011010b ^ 11100111b = 11111101b
-00011010b ^ 11101000b = 11110010b
-00011010b ^ 11101001b = 11110011b
-00011010b ^ 11101010b = 11110000b
-00011010b ^ 11101011b = 11110001b
-00011010b ^ 11101100b = 11110110b
-00011010b ^ 11101101b = 11110111b
-00011010b ^ 11101110b = 11110100b
-00011010b ^ 11101111b = 11110101b
-00011010b ^ 11110000b = 11101010b
-00011010b ^ 11110001b = 11101011b
-00011010b ^ 11110010b = 11101000b
-00011010b ^ 11110011b = 11101001b
-00011010b ^ 11110100b = 11101110b
-00011010b ^ 11110101b = 11101111b
-00011010b ^ 11110110b = 11101100b
-00011010b ^ 11110111b = 11101101b
-00011010b ^ 11111000b = 11100010b
-00011010b ^ 11111001b = 11100011b
-00011010b ^ 11111010b = 11100000b
-00011010b ^ 11111011b = 11100001b
-00011010b ^ 11111100b = 11100110b
-00011010b ^ 11111101b = 11100111b
-00011010b ^ 11111110b = 11100100b
-00011010b ^ 11111111b = 11100101b
-00011010b ^ 00000000b = 00011010b
-00011010b ^ 00000001b = 00011011b
-00011010b ^ 00000010b = 00011000b
-00011010b ^ 00000011b = 00011001b
-00011010b ^ 00000100b = 00011110b
-00011010b ^ 00000101b = 00011111b
-00011010b ^ 00000110b = 00011100b
-00011010b ^ 00000111b = 00011101b
-00011010b ^ 00001000b = 00010010b
-00011010b ^ 00001001b = 00010011b
-00011010b ^ 00001010b = 00010000b
-00011010b ^ 00001011b = 00010001b
-00011010b ^ 00001100b = 00010110b
-00011010b ^ 00001101b = 00010111b
-00011010b ^ 00001110b = 00010100b
-00011010b ^ 00001111b = 00010101b
-00011010b ^ 00010000b = 00001010b
-00011010b ^ 00010001b = 00001011b
-00011010b ^ 00010010b = 00001000b
-00011010b ^ 00010011b = 00001001b
-00011010b ^ 00010100b = 00001110b
-00011010b ^ 00010101b = 00001111b
-00011010b ^ 00010110b = 00001100b
-00011010b ^ 00010111b = 00001101b
-00011010b ^ 00011000b = 00000010b
-00011010b ^ 00011001b = 00000011b
-00011010b ^ 00011010b = 00000000b
-00011010b ^ 00011011b = 00000001b
-00011010b ^ 00011100b = 00000110b
-00011010b ^ 00011101b = 00000111b
-00011010b ^ 00011110b = 00000100b
-00011010b ^ 00011111b = 00000101b
-00011010b ^ 00100000b = 00111010b
-00011010b ^ 00100001b = 00111011b
-00011010b ^ 00100010b = 00111000b
-00011010b ^ 00100011b = 00111001b
-00011010b ^ 00100100b = 00111110b
-00011010b ^ 00100101b = 00111111b
-00011010b ^ 00100110b = 00111100b
-00011010b ^ 00100111b = 00111101b
-00011010b ^ 00101000b = 00110010b
-00011010b ^ 00101001b = 00110011b
-00011010b ^ 00101010b = 00110000b
-00011010b ^ 00101011b = 00110001b
-00011010b ^ 00101100b = 00110110b
-00011010b ^ 00101101b = 00110111b
-00011010b ^ 00101110b = 00110100b
-00011010b ^ 00101111b = 00110101b
-00011010b ^ 00110000b = 00101010b
-00011010b ^ 00110001b = 00101011b
-00011010b ^ 00110010b = 00101000b
-00011010b ^ 00110011b = 00101001b
-00011010b ^ 00110100b = 00101110b
-00011010b ^ 00110101b = 00101111b
-00011010b ^ 00110110b = 00101100b
-00011010b ^ 00110111b = 00101101b
-00011010b ^ 00111000b = 00100010b
-00011010b ^ 00111001b = 00100011b
-00011010b ^ 00111010b = 00100000b
-00011010b ^ 00111011b = 00100001b
-00011010b ^ 00111100b = 00100110b
-00011010b ^ 00111101b = 00100111b
-00011010b ^ 00111110b = 00100100b
-00011010b ^ 00111111b = 00100101b
-00011010b ^ 01000000b = 01011010b
-00011010b ^ 01000001b = 01011011b
-00011010b ^ 01000010b = 01011000b
-00011010b ^ 01000011b = 01011001b
-00011010b ^ 01000100b = 01011110b
-00011010b ^ 01000101b = 01011111b
-00011010b ^ 01000110b = 01011100b
-00011010b ^ 01000111b = 01011101b
-00011010b ^ 01001000b = 01010010b
-00011010b ^ 01001001b = 01010011b
-00011010b ^ 01001010b = 01010000b
-00011010b ^ 01001011b = 01010001b
-00011010b ^ 01001100b = 01010110b
-00011010b ^ 01001101b = 01010111b
-00011010b ^ 01001110b = 01010100b
-00011010b ^ 01001111b = 01010101b
-00011010b ^ 01010000b = 01001010b
-00011010b ^ 01010001b = 01001011b
-00011010b ^ 01010010b = 01001000b
-00011010b ^ 01010011b = 01001001b
-00011010b ^ 01010100b = 01001110b
-00011010b ^ 01010101b = 01001111b
-00011010b ^ 01010110b = 01001100b
-00011010b ^ 01010111b = 01001101b
-00011010b ^ 01011000b = 01000010b
-00011010b ^ 01011001b = 01000011b
-00011010b ^ 01011010b = 01000000b
-00011010b ^ 01011011b = 01000001b
-00011010b ^ 01011100b = 01000110b
-00011010b ^ 01011101b = 01000111b
-00011010b ^ 01011110b = 01000100b
-00011010b ^ 01011111b = 01000101b
-00011010b ^ 01100000b = 01111010b
-00011010b ^ 01100001b = 01111011b
-00011010b ^ 01100010b = 01111000b
-00011010b ^ 01100011b = 01111001b
-00011010b ^ 01100100b = 01111110b
-00011010b ^ 01100101b = 01111111b
-00011010b ^ 01100110b = 01111100b
-00011010b ^ 01100111b = 01111101b
-00011010b ^ 01101000b = 01110010b
-00011010b ^ 01101001b = 01110011b
-00011010b ^ 01101010b = 01110000b
-00011010b ^ 01101011b = 01110001b
-00011010b ^ 01101100b = 01110110b
-00011010b ^ 01101101b = 01110111b
-00011010b ^ 01101110b = 01110100b
-00011010b ^ 01101111b = 01110101b
-00011010b ^ 01110000b = 01101010b
-00011010b ^ 01110001b = 01101011b
-00011010b ^ 01110010b = 01101000b
-00011010b ^ 01110011b = 01101001b
-00011010b ^ 01110100b = 01101110b
-00011010b ^ 01110101b = 01101111b
-00011010b ^ 01110110b = 01101100b
-00011010b ^ 01110111b = 01101101b
-00011010b ^ 01111000b = 01100010b
-00011010b ^ 01111001b = 01100011b
-00011010b ^ 01111010b = 01100000b
-00011010b ^ 01111011b = 01100001b
-00011010b ^ 01111100b = 01100110b
-00011010b ^ 01111101b = 01100111b
-00011010b ^ 01111110b = 01100100b
-00011011b ^ 10000000b = 10011011b
-00011011b ^ 10000001b = 10011010b
-00011011b ^ 10000010b = 10011001b
-00011011b ^ 10000011b = 10011000b
-00011011b ^ 10000100b = 10011111b
-00011011b ^ 10000101b = 10011110b
-00011011b ^ 10000110b = 10011101b
-00011011b ^ 10000111b = 10011100b
-00011011b ^ 10001000b = 10010011b
-00011011b ^ 10001001b = 10010010b
-00011011b ^ 10001010b = 10010001b
-00011011b ^ 10001011b = 10010000b
-00011011b ^ 10001100b = 10010111b
-00011011b ^ 10001101b = 10010110b
-00011011b ^ 10001110b = 10010101b
-00011011b ^ 10001111b = 10010100b
-00011011b ^ 10010000b = 10001011b
-00011011b ^ 10010001b = 10001010b
-00011011b ^ 10010010b = 10001001b
-00011011b ^ 10010011b = 10001000b
-00011011b ^ 10010100b = 10001111b
-00011011b ^ 10010101b = 10001110b
-00011011b ^ 10010110b = 10001101b
-00011011b ^ 10010111b = 10001100b
-00011011b ^ 10011000b = 10000011b
-00011011b ^ 10011001b = 10000010b
-00011011b ^ 10011010b = 10000001b
-00011011b ^ 10011011b = 10000000b
-00011011b ^ 10011100b = 10000111b
-00011011b ^ 10011101b = 10000110b
-00011011b ^ 10011110b = 10000101b
-00011011b ^ 10011111b = 10000100b
-00011011b ^ 10100000b = 10111011b
-00011011b ^ 10100001b = 10111010b
-00011011b ^ 10100010b = 10111001b
-00011011b ^ 10100011b = 10111000b
-00011011b ^ 10100100b = 10111111b
-00011011b ^ 10100101b = 10111110b
-00011011b ^ 10100110b = 10111101b
-00011011b ^ 10100111b = 10111100b
-00011011b ^ 10101000b = 10110011b
-00011011b ^ 10101001b = 10110010b
-00011011b ^ 10101010b = 10110001b
-00011011b ^ 10101011b = 10110000b
-00011011b ^ 10101100b = 10110111b
-00011011b ^ 10101101b = 10110110b
-00011011b ^ 10101110b = 10110101b
-00011011b ^ 10101111b = 10110100b
-00011011b ^ 10110000b = 10101011b
-00011011b ^ 10110001b = 10101010b
-00011011b ^ 10110010b = 10101001b
-00011011b ^ 10110011b = 10101000b
-00011011b ^ 10110100b = 10101111b
-00011011b ^ 10110101b = 10101110b
-00011011b ^ 10110110b = 10101101b
-00011011b ^ 10110111b = 10101100b
-00011011b ^ 10111000b = 10100011b
-00011011b ^ 10111001b = 10100010b
-00011011b ^ 10111010b = 10100001b
-00011011b ^ 10111011b = 10100000b
-00011011b ^ 10111100b = 10100111b
-00011011b ^ 10111101b = 10100110b
-00011011b ^ 10111110b = 10100101b
-00011011b ^ 10111111b = 10100100b
-00011011b ^ 11000000b = 11011011b
-00011011b ^ 11000001b = 11011010b
-00011011b ^ 11000010b = 11011001b
-00011011b ^ 11000011b = 11011000b
-00011011b ^ 11000100b = 11011111b
-00011011b ^ 11000101b = 11011110b
-00011011b ^ 11000110b = 11011101b
-00011011b ^ 11000111b = 11011100b
-00011011b ^ 11001000b = 11010011b
-00011011b ^ 11001001b = 11010010b
-00011011b ^ 11001010b = 11010001b
-00011011b ^ 11001011b = 11010000b
-00011011b ^ 11001100b = 11010111b
-00011011b ^ 11001101b = 11010110b
-00011011b ^ 11001110b = 11010101b
-00011011b ^ 11001111b = 11010100b
-00011011b ^ 11010000b = 11001011b
-00011011b ^ 11010001b = 11001010b
-00011011b ^ 11010010b = 11001001b
-00011011b ^ 11010011b = 11001000b
-00011011b ^ 11010100b = 11001111b
-00011011b ^ 11010101b = 11001110b
-00011011b ^ 11010110b = 11001101b
-00011011b ^ 11010111b = 11001100b
-00011011b ^ 11011000b = 11000011b
-00011011b ^ 11011001b = 11000010b
-00011011b ^ 11011010b = 11000001b
-00011011b ^ 11011011b = 11000000b
-00011011b ^ 11011100b = 11000111b
-00011011b ^ 11011101b = 11000110b
-00011011b ^ 11011110b = 11000101b
-00011011b ^ 11011111b = 11000100b
-00011011b ^ 11100000b = 11111011b
-00011011b ^ 11100001b = 11111010b
-00011011b ^ 11100010b = 11111001b
-00011011b ^ 11100011b = 11111000b
-00011011b ^ 11100100b = 11111111b
-00011011b ^ 11100101b = 11111110b
-00011011b ^ 11100110b = 11111101b
-00011011b ^ 11100111b = 11111100b
-00011011b ^ 11101000b = 11110011b
-00011011b ^ 11101001b = 11110010b
-00011011b ^ 11101010b = 11110001b
-00011011b ^ 11101011b = 11110000b
-00011011b ^ 11101100b = 11110111b
-00011011b ^ 11101101b = 11110110b
-00011011b ^ 11101110b = 11110101b
-00011011b ^ 11101111b = 11110100b
-00011011b ^ 11110000b = 11101011b
-00011011b ^ 11110001b = 11101010b
-00011011b ^ 11110010b = 11101001b
-00011011b ^ 11110011b = 11101000b
-00011011b ^ 11110100b = 11101111b
-00011011b ^ 11110101b = 11101110b
-00011011b ^ 11110110b = 11101101b
-00011011b ^ 11110111b = 11101100b
-00011011b ^ 11111000b = 11100011b
-00011011b ^ 11111001b = 11100010b
-00011011b ^ 11111010b = 11100001b
-00011011b ^ 11111011b = 11100000b
-00011011b ^ 11111100b = 11100111b
-00011011b ^ 11111101b = 11100110b
-00011011b ^ 11111110b = 11100101b
-00011011b ^ 11111111b = 11100100b
-00011011b ^ 00000000b = 00011011b
-00011011b ^ 00000001b = 00011010b
-00011011b ^ 00000010b = 00011001b
-00011011b ^ 00000011b = 00011000b
-00011011b ^ 00000100b = 00011111b
-00011011b ^ 00000101b = 00011110b
-00011011b ^ 00000110b = 00011101b
-00011011b ^ 00000111b = 00011100b
-00011011b ^ 00001000b = 00010011b
-00011011b ^ 00001001b = 00010010b
-00011011b ^ 00001010b = 00010001b
-00011011b ^ 00001011b = 00010000b
-00011011b ^ 00001100b = 00010111b
-00011011b ^ 00001101b = 00010110b
-00011011b ^ 00001110b = 00010101b
-00011011b ^ 00001111b = 00010100b
-00011011b ^ 00010000b = 00001011b
-00011011b ^ 00010001b = 00001010b
-00011011b ^ 00010010b = 00001001b
-00011011b ^ 00010011b = 00001000b
-00011011b ^ 00010100b = 00001111b
-00011011b ^ 00010101b = 00001110b
-00011011b ^ 00010110b = 00001101b
-00011011b ^ 00010111b = 00001100b
-00011011b ^ 00011000b = 00000011b
-00011011b ^ 00011001b = 00000010b
-00011011b ^ 00011010b = 00000001b
-00011011b ^ 00011011b = 00000000b
-00011011b ^ 00011100b = 00000111b
-00011011b ^ 00011101b = 00000110b
-00011011b ^ 00011110b = 00000101b
-00011011b ^ 00011111b = 00000100b
-00011011b ^ 00100000b = 00111011b
-00011011b ^ 00100001b = 00111010b
-00011011b ^ 00100010b = 00111001b
-00011011b ^ 00100011b = 00111000b
-00011011b ^ 00100100b = 00111111b
-00011011b ^ 00100101b = 00111110b
-00011011b ^ 00100110b = 00111101b
-00011011b ^ 00100111b = 00111100b
-00011011b ^ 00101000b = 00110011b
-00011011b ^ 00101001b = 00110010b
-00011011b ^ 00101010b = 00110001b
-00011011b ^ 00101011b = 00110000b
-00011011b ^ 00101100b = 00110111b
-00011011b ^ 00101101b = 00110110b
-00011011b ^ 00101110b = 00110101b
-00011011b ^ 00101111b = 00110100b
-00011011b ^ 00110000b = 00101011b
-00011011b ^ 00110001b = 00101010b
-00011011b ^ 00110010b = 00101001b
-00011011b ^ 00110011b = 00101000b
-00011011b ^ 00110100b = 00101111b
-00011011b ^ 00110101b = 00101110b
-00011011b ^ 00110110b = 00101101b
-00011011b ^ 00110111b = 00101100b
-00011011b ^ 00111000b = 00100011b
-00011011b ^ 00111001b = 00100010b
-00011011b ^ 00111010b = 00100001b
-00011011b ^ 00111011b = 00100000b
-00011011b ^ 00111100b = 00100111b
-00011011b ^ 00111101b = 00100110b
-00011011b ^ 00111110b = 00100101b
-00011011b ^ 00111111b = 00100100b
-00011011b ^ 01000000b = 01011011b
-00011011b ^ 01000001b = 01011010b
-00011011b ^ 01000010b = 01011001b
-00011011b ^ 01000011b = 01011000b
-00011011b ^ 01000100b = 01011111b
-00011011b ^ 01000101b = 01011110b
-00011011b ^ 01000110b = 01011101b
-00011011b ^ 01000111b = 01011100b
-00011011b ^ 01001000b = 01010011b
-00011011b ^ 01001001b = 01010010b
-00011011b ^ 01001010b = 01010001b
-00011011b ^ 01001011b = 01010000b
-00011011b ^ 01001100b = 01010111b
-00011011b ^ 01001101b = 01010110b
-00011011b ^ 01001110b = 01010101b
-00011011b ^ 01001111b = 01010100b
-00011011b ^ 01010000b = 01001011b
-00011011b ^ 01010001b = 01001010b
-00011011b ^ 01010010b = 01001001b
-00011011b ^ 01010011b = 01001000b
-00011011b ^ 01010100b = 01001111b
-00011011b ^ 01010101b = 01001110b
-00011011b ^ 01010110b = 01001101b
-00011011b ^ 01010111b = 01001100b
-00011011b ^ 01011000b = 01000011b
-00011011b ^ 01011001b = 01000010b
-00011011b ^ 01011010b = 01000001b
-00011011b ^ 01011011b = 01000000b
-00011011b ^ 01011100b = 01000111b
-00011011b ^ 01011101b = 01000110b
-00011011b ^ 01011110b = 01000101b
-00011011b ^ 01011111b = 01000100b
-00011011b ^ 01100000b = 01111011b
-00011011b ^ 01100001b = 01111010b
-00011011b ^ 01100010b = 01111001b
-00011011b ^ 01100011b = 01111000b
-00011011b ^ 01100100b = 01111111b
-00011011b ^ 01100101b = 01111110b
-00011011b ^ 01100110b = 01111101b
-00011011b ^ 01100111b = 01111100b
-00011011b ^ 01101000b = 01110011b
-00011011b ^ 01101001b = 01110010b
-00011011b ^ 01101010b = 01110001b
-00011011b ^ 01101011b = 01110000b
-00011011b ^ 01101100b = 01110111b
-00011011b ^ 01101101b = 01110110b
-00011011b ^ 01101110b = 01110101b
-00011011b ^ 01101111b = 01110100b
-00011011b ^ 01110000b = 01101011b
-00011011b ^ 01110001b = 01101010b
-00011011b ^ 01110010b = 01101001b
-00011011b ^ 01110011b = 01101000b
-00011011b ^ 01110100b = 01101111b
-00011011b ^ 01110101b = 01101110b
-00011011b ^ 01110110b = 01101101b
-00011011b ^ 01110111b = 01101100b
-00011011b ^ 01111000b = 01100011b
-00011011b ^ 01111001b = 01100010b
-00011011b ^ 01111010b = 01100001b
-00011011b ^ 01111011b = 01100000b
-00011011b ^ 01111100b = 01100111b
-00011011b ^ 01111101b = 01100110b
-00011011b ^ 01111110b = 01100101b
-00011100b ^ 10000000b = 10011100b
-00011100b ^ 10000001b = 10011101b
-00011100b ^ 10000010b = 10011110b
-00011100b ^ 10000011b = 10011111b
-00011100b ^ 10000100b = 10011000b
-00011100b ^ 10000101b = 10011001b
-00011100b ^ 10000110b = 10011010b
-00011100b ^ 10000111b = 10011011b
-00011100b ^ 10001000b = 10010100b
-00011100b ^ 10001001b = 10010101b
-00011100b ^ 10001010b = 10010110b
-00011100b ^ 10001011b = 10010111b
-00011100b ^ 10001100b = 10010000b
-00011100b ^ 10001101b = 10010001b
-00011100b ^ 10001110b = 10010010b
-00011100b ^ 10001111b = 10010011b
-00011100b ^ 10010000b = 10001100b
-00011100b ^ 10010001b = 10001101b
-00011100b ^ 10010010b = 10001110b
-00011100b ^ 10010011b = 10001111b
-00011100b ^ 10010100b = 10001000b
-00011100b ^ 10010101b = 10001001b
-00011100b ^ 10010110b = 10001010b
-00011100b ^ 10010111b = 10001011b
-00011100b ^ 10011000b = 10000100b
-00011100b ^ 10011001b = 10000101b
-00011100b ^ 10011010b = 10000110b
-00011100b ^ 10011011b = 10000111b
-00011100b ^ 10011100b = 10000000b
-00011100b ^ 10011101b = 10000001b
-00011100b ^ 10011110b = 10000010b
-00011100b ^ 10011111b = 10000011b
-00011100b ^ 10100000b = 10111100b
-00011100b ^ 10100001b = 10111101b
-00011100b ^ 10100010b = 10111110b
-00011100b ^ 10100011b = 10111111b
-00011100b ^ 10100100b = 10111000b
-00011100b ^ 10100101b = 10111001b
-00011100b ^ 10100110b = 10111010b
-00011100b ^ 10100111b = 10111011b
-00011100b ^ 10101000b = 10110100b
-00011100b ^ 10101001b = 10110101b
-00011100b ^ 10101010b = 10110110b
-00011100b ^ 10101011b = 10110111b
-00011100b ^ 10101100b = 10110000b
-00011100b ^ 10101101b = 10110001b
-00011100b ^ 10101110b = 10110010b
-00011100b ^ 10101111b = 10110011b
-00011100b ^ 10110000b = 10101100b
-00011100b ^ 10110001b = 10101101b
-00011100b ^ 10110010b = 10101110b
-00011100b ^ 10110011b = 10101111b
-00011100b ^ 10110100b = 10101000b
-00011100b ^ 10110101b = 10101001b
-00011100b ^ 10110110b = 10101010b
-00011100b ^ 10110111b = 10101011b
-00011100b ^ 10111000b = 10100100b
-00011100b ^ 10111001b = 10100101b
-00011100b ^ 10111010b = 10100110b
-00011100b ^ 10111011b = 10100111b
-00011100b ^ 10111100b = 10100000b
-00011100b ^ 10111101b = 10100001b
-00011100b ^ 10111110b = 10100010b
-00011100b ^ 10111111b = 10100011b
-00011100b ^ 11000000b = 11011100b
-00011100b ^ 11000001b = 11011101b
-00011100b ^ 11000010b = 11011110b
-00011100b ^ 11000011b = 11011111b
-00011100b ^ 11000100b = 11011000b
-00011100b ^ 11000101b = 11011001b
-00011100b ^ 11000110b = 11011010b
-00011100b ^ 11000111b = 11011011b
-00011100b ^ 11001000b = 11010100b
-00011100b ^ 11001001b = 11010101b
-00011100b ^ 11001010b = 11010110b
-00011100b ^ 11001011b = 11010111b
-00011100b ^ 11001100b = 11010000b
-00011100b ^ 11001101b = 11010001b
-00011100b ^ 11001110b = 11010010b
-00011100b ^ 11001111b = 11010011b
-00011100b ^ 11010000b = 11001100b
-00011100b ^ 11010001b = 11001101b
-00011100b ^ 11010010b = 11001110b
-00011100b ^ 11010011b = 11001111b
-00011100b ^ 11010100b = 11001000b
-00011100b ^ 11010101b = 11001001b
-00011100b ^ 11010110b = 11001010b
-00011100b ^ 11010111b = 11001011b
-00011100b ^ 11011000b = 11000100b
-00011100b ^ 11011001b = 11000101b
-00011100b ^ 11011010b = 11000110b
-00011100b ^ 11011011b = 11000111b
-00011100b ^ 11011100b = 11000000b
-00011100b ^ 11011101b = 11000001b
-00011100b ^ 11011110b = 11000010b
-00011100b ^ 11011111b = 11000011b
-00011100b ^ 11100000b = 11111100b
-00011100b ^ 11100001b = 11111101b
-00011100b ^ 11100010b = 11111110b
-00011100b ^ 11100011b = 11111111b
-00011100b ^ 11100100b = 11111000b
-00011100b ^ 11100101b = 11111001b
-00011100b ^ 11100110b = 11111010b
-00011100b ^ 11100111b = 11111011b
-00011100b ^ 11101000b = 11110100b
-00011100b ^ 11101001b = 11110101b
-00011100b ^ 11101010b = 11110110b
-00011100b ^ 11101011b = 11110111b
-00011100b ^ 11101100b = 11110000b
-00011100b ^ 11101101b = 11110001b
-00011100b ^ 11101110b = 11110010b
-00011100b ^ 11101111b = 11110011b
-00011100b ^ 11110000b = 11101100b
-00011100b ^ 11110001b = 11101101b
-00011100b ^ 11110010b = 11101110b
-00011100b ^ 11110011b = 11101111b
-00011100b ^ 11110100b = 11101000b
-00011100b ^ 11110101b = 11101001b
-00011100b ^ 11110110b = 11101010b
-00011100b ^ 11110111b = 11101011b
-00011100b ^ 11111000b = 11100100b
-00011100b ^ 11111001b = 11100101b
-00011100b ^ 11111010b = 11100110b
-00011100b ^ 11111011b = 11100111b
-00011100b ^ 11111100b = 11100000b
-00011100b ^ 11111101b = 11100001b
-00011100b ^ 11111110b = 11100010b
-00011100b ^ 11111111b = 11100011b
-00011100b ^ 00000000b = 00011100b
-00011100b ^ 00000001b = 00011101b
-00011100b ^ 00000010b = 00011110b
-00011100b ^ 00000011b = 00011111b
-00011100b ^ 00000100b = 00011000b
-00011100b ^ 00000101b = 00011001b
-00011100b ^ 00000110b = 00011010b
-00011100b ^ 00000111b = 00011011b
-00011100b ^ 00001000b = 00010100b
-00011100b ^ 00001001b = 00010101b
-00011100b ^ 00001010b = 00010110b
-00011100b ^ 00001011b = 00010111b
-00011100b ^ 00001100b = 00010000b
-00011100b ^ 00001101b = 00010001b
-00011100b ^ 00001110b = 00010010b
-00011100b ^ 00001111b = 00010011b
-00011100b ^ 00010000b = 00001100b
-00011100b ^ 00010001b = 00001101b
-00011100b ^ 00010010b = 00001110b
-00011100b ^ 00010011b = 00001111b
-00011100b ^ 00010100b = 00001000b
-00011100b ^ 00010101b = 00001001b
-00011100b ^ 00010110b = 00001010b
-00011100b ^ 00010111b = 00001011b
-00011100b ^ 00011000b = 00000100b
-00011100b ^ 00011001b = 00000101b
-00011100b ^ 00011010b = 00000110b
-00011100b ^ 00011011b = 00000111b
-00011100b ^ 00011100b = 00000000b
-00011100b ^ 00011101b = 00000001b
-00011100b ^ 00011110b = 00000010b
-00011100b ^ 00011111b = 00000011b
-00011100b ^ 00100000b = 00111100b
-00011100b ^ 00100001b = 00111101b
-00011100b ^ 00100010b = 00111110b
-00011100b ^ 00100011b = 00111111b
-00011100b ^ 00100100b = 00111000b
-00011100b ^ 00100101b = 00111001b
-00011100b ^ 00100110b = 00111010b
-00011100b ^ 00100111b = 00111011b
-00011100b ^ 00101000b = 00110100b
-00011100b ^ 00101001b = 00110101b
-00011100b ^ 00101010b = 00110110b
-00011100b ^ 00101011b = 00110111b
-00011100b ^ 00101100b = 00110000b
-00011100b ^ 00101101b = 00110001b
-00011100b ^ 00101110b = 00110010b
-00011100b ^ 00101111b = 00110011b
-00011100b ^ 00110000b = 00101100b
-00011100b ^ 00110001b = 00101101b
-00011100b ^ 00110010b = 00101110b
-00011100b ^ 00110011b = 00101111b
-00011100b ^ 00110100b = 00101000b
-00011100b ^ 00110101b = 00101001b
-00011100b ^ 00110110b = 00101010b
-00011100b ^ 00110111b = 00101011b
-00011100b ^ 00111000b = 00100100b
-00011100b ^ 00111001b = 00100101b
-00011100b ^ 00111010b = 00100110b
-00011100b ^ 00111011b = 00100111b
-00011100b ^ 00111100b = 00100000b
-00011100b ^ 00111101b = 00100001b
-00011100b ^ 00111110b = 00100010b
-00011100b ^ 00111111b = 00100011b
-00011100b ^ 01000000b = 01011100b
-00011100b ^ 01000001b = 01011101b
-00011100b ^ 01000010b = 01011110b
-00011100b ^ 01000011b = 01011111b
-00011100b ^ 01000100b = 01011000b
-00011100b ^ 01000101b = 01011001b
-00011100b ^ 01000110b = 01011010b
-00011100b ^ 01000111b = 01011011b
-00011100b ^ 01001000b = 01010100b
-00011100b ^ 01001001b = 01010101b
-00011100b ^ 01001010b = 01010110b
-00011100b ^ 01001011b = 01010111b
-00011100b ^ 01001100b = 01010000b
-00011100b ^ 01001101b = 01010001b
-00011100b ^ 01001110b = 01010010b
-00011100b ^ 01001111b = 01010011b
-00011100b ^ 01010000b = 01001100b
-00011100b ^ 01010001b = 01001101b
-00011100b ^ 01010010b = 01001110b
-00011100b ^ 01010011b = 01001111b
-00011100b ^ 01010100b = 01001000b
-00011100b ^ 01010101b = 01001001b
-00011100b ^ 01010110b = 01001010b
-00011100b ^ 01010111b = 01001011b
-00011100b ^ 01011000b = 01000100b
-00011100b ^ 01011001b = 01000101b
-00011100b ^ 01011010b = 01000110b
-00011100b ^ 01011011b = 01000111b
-00011100b ^ 01011100b = 01000000b
-00011100b ^ 01011101b = 01000001b
-00011100b ^ 01011110b = 01000010b
-00011100b ^ 01011111b = 01000011b
-00011100b ^ 01100000b = 01111100b
-00011100b ^ 01100001b = 01111101b
-00011100b ^ 01100010b = 01111110b
-00011100b ^ 01100011b = 01111111b
-00011100b ^ 01100100b = 01111000b
-00011100b ^ 01100101b = 01111001b
-00011100b ^ 01100110b = 01111010b
-00011100b ^ 01100111b = 01111011b
-00011100b ^ 01101000b = 01110100b
-00011100b ^ 01101001b = 01110101b
-00011100b ^ 01101010b = 01110110b
-00011100b ^ 01101011b = 01110111b
-00011100b ^ 01101100b = 01110000b
-00011100b ^ 01101101b = 01110001b
-00011100b ^ 01101110b = 01110010b
-00011100b ^ 01101111b = 01110011b
-00011100b ^ 01110000b = 01101100b
-00011100b ^ 01110001b = 01101101b
-00011100b ^ 01110010b = 01101110b
-00011100b ^ 01110011b = 01101111b
-00011100b ^ 01110100b = 01101000b
-00011100b ^ 01110101b = 01101001b
-00011100b ^ 01110110b = 01101010b
-00011100b ^ 01110111b = 01101011b
-00011100b ^ 01111000b = 01100100b
-00011100b ^ 01111001b = 01100101b
-00011100b ^ 01111010b = 01100110b
-00011100b ^ 01111011b = 01100111b
-00011100b ^ 01111100b = 01100000b
-00011100b ^ 01111101b = 01100001b
-00011100b ^ 01111110b = 01100010b
-00011101b ^ 10000000b = 10011101b
-00011101b ^ 10000001b = 10011100b
-00011101b ^ 10000010b = 10011111b
-00011101b ^ 10000011b = 10011110b
-00011101b ^ 10000100b = 10011001b
-00011101b ^ 10000101b = 10011000b
-00011101b ^ 10000110b = 10011011b
-00011101b ^ 10000111b = 10011010b
-00011101b ^ 10001000b = 10010101b
-00011101b ^ 10001001b = 10010100b
-00011101b ^ 10001010b = 10010111b
-00011101b ^ 10001011b = 10010110b
-00011101b ^ 10001100b = 10010001b
-00011101b ^ 10001101b = 10010000b
-00011101b ^ 10001110b = 10010011b
-00011101b ^ 10001111b = 10010010b
-00011101b ^ 10010000b = 10001101b
-00011101b ^ 10010001b = 10001100b
-00011101b ^ 10010010b = 10001111b
-00011101b ^ 10010011b = 10001110b
-00011101b ^ 10010100b = 10001001b
-00011101b ^ 10010101b = 10001000b
-00011101b ^ 10010110b = 10001011b
-00011101b ^ 10010111b = 10001010b
-00011101b ^ 10011000b = 10000101b
-00011101b ^ 10011001b = 10000100b
-00011101b ^ 10011010b = 10000111b
-00011101b ^ 10011011b = 10000110b
-00011101b ^ 10011100b = 10000001b
-00011101b ^ 10011101b = 10000000b
-00011101b ^ 10011110b = 10000011b
-00011101b ^ 10011111b = 10000010b
-00011101b ^ 10100000b = 10111101b
-00011101b ^ 10100001b = 10111100b
-00011101b ^ 10100010b = 10111111b
-00011101b ^ 10100011b = 10111110b
-00011101b ^ 10100100b = 10111001b
-00011101b ^ 10100101b = 10111000b
-00011101b ^ 10100110b = 10111011b
-00011101b ^ 10100111b = 10111010b
-00011101b ^ 10101000b = 10110101b
-00011101b ^ 10101001b = 10110100b
-00011101b ^ 10101010b = 10110111b
-00011101b ^ 10101011b = 10110110b
-00011101b ^ 10101100b = 10110001b
-00011101b ^ 10101101b = 10110000b
-00011101b ^ 10101110b = 10110011b
-00011101b ^ 10101111b = 10110010b
-00011101b ^ 10110000b = 10101101b
-00011101b ^ 10110001b = 10101100b
-00011101b ^ 10110010b = 10101111b
-00011101b ^ 10110011b = 10101110b
-00011101b ^ 10110100b = 10101001b
-00011101b ^ 10110101b = 10101000b
-00011101b ^ 10110110b = 10101011b
-00011101b ^ 10110111b = 10101010b
-00011101b ^ 10111000b = 10100101b
-00011101b ^ 10111001b = 10100100b
-00011101b ^ 10111010b = 10100111b
-00011101b ^ 10111011b = 10100110b
-00011101b ^ 10111100b = 10100001b
-00011101b ^ 10111101b = 10100000b
-00011101b ^ 10111110b = 10100011b
-00011101b ^ 10111111b = 10100010b
-00011101b ^ 11000000b = 11011101b
-00011101b ^ 11000001b = 11011100b
-00011101b ^ 11000010b = 11011111b
-00011101b ^ 11000011b = 11011110b
-00011101b ^ 11000100b = 11011001b
-00011101b ^ 11000101b = 11011000b
-00011101b ^ 11000110b = 11011011b
-00011101b ^ 11000111b = 11011010b
-00011101b ^ 11001000b = 11010101b
-00011101b ^ 11001001b = 11010100b
-00011101b ^ 11001010b = 11010111b
-00011101b ^ 11001011b = 11010110b
-00011101b ^ 11001100b = 11010001b
-00011101b ^ 11001101b = 11010000b
-00011101b ^ 11001110b = 11010011b
-00011101b ^ 11001111b = 11010010b
-00011101b ^ 11010000b = 11001101b
-00011101b ^ 11010001b = 11001100b
-00011101b ^ 11010010b = 11001111b
-00011101b ^ 11010011b = 11001110b
-00011101b ^ 11010100b = 11001001b
-00011101b ^ 11010101b = 11001000b
-00011101b ^ 11010110b = 11001011b
-00011101b ^ 11010111b = 11001010b
-00011101b ^ 11011000b = 11000101b
-00011101b ^ 11011001b = 11000100b
-00011101b ^ 11011010b = 11000111b
-00011101b ^ 11011011b = 11000110b
-00011101b ^ 11011100b = 11000001b
-00011101b ^ 11011101b = 11000000b
-00011101b ^ 11011110b = 11000011b
-00011101b ^ 11011111b = 11000010b
-00011101b ^ 11100000b = 11111101b
-00011101b ^ 11100001b = 11111100b
-00011101b ^ 11100010b = 11111111b
-00011101b ^ 11100011b = 11111110b
-00011101b ^ 11100100b = 11111001b
-00011101b ^ 11100101b = 11111000b
-00011101b ^ 11100110b = 11111011b
-00011101b ^ 11100111b = 11111010b
-00011101b ^ 11101000b = 11110101b
-00011101b ^ 11101001b = 11110100b
-00011101b ^ 11101010b = 11110111b
-00011101b ^ 11101011b = 11110110b
-00011101b ^ 11101100b = 11110001b
-00011101b ^ 11101101b = 11110000b
-00011101b ^ 11101110b = 11110011b
-00011101b ^ 11101111b = 11110010b
-00011101b ^ 11110000b = 11101101b
-00011101b ^ 11110001b = 11101100b
-00011101b ^ 11110010b = 11101111b
-00011101b ^ 11110011b = 11101110b
-00011101b ^ 11110100b = 11101001b
-00011101b ^ 11110101b = 11101000b
-00011101b ^ 11110110b = 11101011b
-00011101b ^ 11110111b = 11101010b
-00011101b ^ 11111000b = 11100101b
-00011101b ^ 11111001b = 11100100b
-00011101b ^ 11111010b = 11100111b
-00011101b ^ 11111011b = 11100110b
-00011101b ^ 11111100b = 11100001b
-00011101b ^ 11111101b = 11100000b
-00011101b ^ 11111110b = 11100011b
-00011101b ^ 11111111b = 11100010b
-00011101b ^ 00000000b = 00011101b
-00011101b ^ 00000001b = 00011100b
-00011101b ^ 00000010b = 00011111b
-00011101b ^ 00000011b = 00011110b
-00011101b ^ 00000100b = 00011001b
-00011101b ^ 00000101b = 00011000b
-00011101b ^ 00000110b = 00011011b
-00011101b ^ 00000111b = 00011010b
-00011101b ^ 00001000b = 00010101b
-00011101b ^ 00001001b = 00010100b
-00011101b ^ 00001010b = 00010111b
-00011101b ^ 00001011b = 00010110b
-00011101b ^ 00001100b = 00010001b
-00011101b ^ 00001101b = 00010000b
-00011101b ^ 00001110b = 00010011b
-00011101b ^ 00001111b = 00010010b
-00011101b ^ 00010000b = 00001101b
-00011101b ^ 00010001b = 00001100b
-00011101b ^ 00010010b = 00001111b
-00011101b ^ 00010011b = 00001110b
-00011101b ^ 00010100b = 00001001b
-00011101b ^ 00010101b = 00001000b
-00011101b ^ 00010110b = 00001011b
-00011101b ^ 00010111b = 00001010b
-00011101b ^ 00011000b = 00000101b
-00011101b ^ 00011001b = 00000100b
-00011101b ^ 00011010b = 00000111b
-00011101b ^ 00011011b = 00000110b
-00011101b ^ 00011100b = 00000001b
-00011101b ^ 00011101b = 00000000b
-00011101b ^ 00011110b = 00000011b
-00011101b ^ 00011111b = 00000010b
-00011101b ^ 00100000b = 00111101b
-00011101b ^ 00100001b = 00111100b
-00011101b ^ 00100010b = 00111111b
-00011101b ^ 00100011b = 00111110b
-00011101b ^ 00100100b = 00111001b
-00011101b ^ 00100101b = 00111000b
-00011101b ^ 00100110b = 00111011b
-00011101b ^ 00100111b = 00111010b
-00011101b ^ 00101000b = 00110101b
-00011101b ^ 00101001b = 00110100b
-00011101b ^ 00101010b = 00110111b
-00011101b ^ 00101011b = 00110110b
-00011101b ^ 00101100b = 00110001b
-00011101b ^ 00101101b = 00110000b
-00011101b ^ 00101110b = 00110011b
-00011101b ^ 00101111b = 00110010b
-00011101b ^ 00110000b = 00101101b
-00011101b ^ 00110001b = 00101100b
-00011101b ^ 00110010b = 00101111b
-00011101b ^ 00110011b = 00101110b
-00011101b ^ 00110100b = 00101001b
-00011101b ^ 00110101b = 00101000b
-00011101b ^ 00110110b = 00101011b
-00011101b ^ 00110111b = 00101010b
-00011101b ^ 00111000b = 00100101b
-00011101b ^ 00111001b = 00100100b
-00011101b ^ 00111010b = 00100111b
-00011101b ^ 00111011b = 00100110b
-00011101b ^ 00111100b = 00100001b
-00011101b ^ 00111101b = 00100000b
-00011101b ^ 00111110b = 00100011b
-00011101b ^ 00111111b = 00100010b
-00011101b ^ 01000000b = 01011101b
-00011101b ^ 01000001b = 01011100b
-00011101b ^ 01000010b = 01011111b
-00011101b ^ 01000011b = 01011110b
-00011101b ^ 01000100b = 01011001b
-00011101b ^ 01000101b = 01011000b
-00011101b ^ 01000110b = 01011011b
-00011101b ^ 01000111b = 01011010b
-00011101b ^ 01001000b = 01010101b
-00011101b ^ 01001001b = 01010100b
-00011101b ^ 01001010b = 01010111b
-00011101b ^ 01001011b = 01010110b
-00011101b ^ 01001100b = 01010001b
-00011101b ^ 01001101b = 01010000b
-00011101b ^ 01001110b = 01010011b
-00011101b ^ 01001111b = 01010010b
-00011101b ^ 01010000b = 01001101b
-00011101b ^ 01010001b = 01001100b
-00011101b ^ 01010010b = 01001111b
-00011101b ^ 01010011b = 01001110b
-00011101b ^ 01010100b = 01001001b
-00011101b ^ 01010101b = 01001000b
-00011101b ^ 01010110b = 01001011b
-00011101b ^ 01010111b = 01001010b
-00011101b ^ 01011000b = 01000101b
-00011101b ^ 01011001b = 01000100b
-00011101b ^ 01011010b = 01000111b
-00011101b ^ 01011011b = 01000110b
-00011101b ^ 01011100b = 01000001b
-00011101b ^ 01011101b = 01000000b
-00011101b ^ 01011110b = 01000011b
-00011101b ^ 01011111b = 01000010b
-00011101b ^ 01100000b = 01111101b
-00011101b ^ 01100001b = 01111100b
-00011101b ^ 01100010b = 01111111b
-00011101b ^ 01100011b = 01111110b
-00011101b ^ 01100100b = 01111001b
-00011101b ^ 01100101b = 01111000b
-00011101b ^ 01100110b = 01111011b
-00011101b ^ 01100111b = 01111010b
-00011101b ^ 01101000b = 01110101b
-00011101b ^ 01101001b = 01110100b
-00011101b ^ 01101010b = 01110111b
-00011101b ^ 01101011b = 01110110b
-00011101b ^ 01101100b = 01110001b
-00011101b ^ 01101101b = 01110000b
-00011101b ^ 01101110b = 01110011b
-00011101b ^ 01101111b = 01110010b
-00011101b ^ 01110000b = 01101101b
-00011101b ^ 01110001b = 01101100b
-00011101b ^ 01110010b = 01101111b
-00011101b ^ 01110011b = 01101110b
-00011101b ^ 01110100b = 01101001b
-00011101b ^ 01110101b = 01101000b
-00011101b ^ 01110110b = 01101011b
-00011101b ^ 01110111b = 01101010b
-00011101b ^ 01111000b = 01100101b
-00011101b ^ 01111001b = 01100100b
-00011101b ^ 01111010b = 01100111b
-00011101b ^ 01111011b = 01100110b
-00011101b ^ 01111100b = 01100001b
-00011101b ^ 01111101b = 01100000b
-00011101b ^ 01111110b = 01100011b
-00011110b ^ 10000000b = 10011110b
-00011110b ^ 10000001b = 10011111b
-00011110b ^ 10000010b = 10011100b
-00011110b ^ 10000011b = 10011101b
-00011110b ^ 10000100b = 10011010b
-00011110b ^ 10000101b = 10011011b
-00011110b ^ 10000110b = 10011000b
-00011110b ^ 10000111b = 10011001b
-00011110b ^ 10001000b = 10010110b
-00011110b ^ 10001001b = 10010111b
-00011110b ^ 10001010b = 10010100b
-00011110b ^ 10001011b = 10010101b
-00011110b ^ 10001100b = 10010010b
-00011110b ^ 10001101b = 10010011b
-00011110b ^ 10001110b = 10010000b
-00011110b ^ 10001111b = 10010001b
-00011110b ^ 10010000b = 10001110b
-00011110b ^ 10010001b = 10001111b
-00011110b ^ 10010010b = 10001100b
-00011110b ^ 10010011b = 10001101b
-00011110b ^ 10010100b = 10001010b
-00011110b ^ 10010101b = 10001011b
-00011110b ^ 10010110b = 10001000b
-00011110b ^ 10010111b = 10001001b
-00011110b ^ 10011000b = 10000110b
-00011110b ^ 10011001b = 10000111b
-00011110b ^ 10011010b = 10000100b
-00011110b ^ 10011011b = 10000101b
-00011110b ^ 10011100b = 10000010b
-00011110b ^ 10011101b = 10000011b
-00011110b ^ 10011110b = 10000000b
-00011110b ^ 10011111b = 10000001b
-00011110b ^ 10100000b = 10111110b
-00011110b ^ 10100001b = 10111111b
-00011110b ^ 10100010b = 10111100b
-00011110b ^ 10100011b = 10111101b
-00011110b ^ 10100100b = 10111010b
-00011110b ^ 10100101b = 10111011b
-00011110b ^ 10100110b = 10111000b
-00011110b ^ 10100111b = 10111001b
-00011110b ^ 10101000b = 10110110b
-00011110b ^ 10101001b = 10110111b
-00011110b ^ 10101010b = 10110100b
-00011110b ^ 10101011b = 10110101b
-00011110b ^ 10101100b = 10110010b
-00011110b ^ 10101101b = 10110011b
-00011110b ^ 10101110b = 10110000b
-00011110b ^ 10101111b = 10110001b
-00011110b ^ 10110000b = 10101110b
-00011110b ^ 10110001b = 10101111b
-00011110b ^ 10110010b = 10101100b
-00011110b ^ 10110011b = 10101101b
-00011110b ^ 10110100b = 10101010b
-00011110b ^ 10110101b = 10101011b
-00011110b ^ 10110110b = 10101000b
-00011110b ^ 10110111b = 10101001b
-00011110b ^ 10111000b = 10100110b
-00011110b ^ 10111001b = 10100111b
-00011110b ^ 10111010b = 10100100b
-00011110b ^ 10111011b = 10100101b
-00011110b ^ 10111100b = 10100010b
-00011110b ^ 10111101b = 10100011b
-00011110b ^ 10111110b = 10100000b
-00011110b ^ 10111111b = 10100001b
-00011110b ^ 11000000b = 11011110b
-00011110b ^ 11000001b = 11011111b
-00011110b ^ 11000010b = 11011100b
-00011110b ^ 11000011b = 11011101b
-00011110b ^ 11000100b = 11011010b
-00011110b ^ 11000101b = 11011011b
-00011110b ^ 11000110b = 11011000b
-00011110b ^ 11000111b = 11011001b
-00011110b ^ 11001000b = 11010110b
-00011110b ^ 11001001b = 11010111b
-00011110b ^ 11001010b = 11010100b
-00011110b ^ 11001011b = 11010101b
-00011110b ^ 11001100b = 11010010b
-00011110b ^ 11001101b = 11010011b
-00011110b ^ 11001110b = 11010000b
-00011110b ^ 11001111b = 11010001b
-00011110b ^ 11010000b = 11001110b
-00011110b ^ 11010001b = 11001111b
-00011110b ^ 11010010b = 11001100b
-00011110b ^ 11010011b = 11001101b
-00011110b ^ 11010100b = 11001010b
-00011110b ^ 11010101b = 11001011b
-00011110b ^ 11010110b = 11001000b
-00011110b ^ 11010111b = 11001001b
-00011110b ^ 11011000b = 11000110b
-00011110b ^ 11011001b = 11000111b
-00011110b ^ 11011010b = 11000100b
-00011110b ^ 11011011b = 11000101b
-00011110b ^ 11011100b = 11000010b
-00011110b ^ 11011101b = 11000011b
-00011110b ^ 11011110b = 11000000b
-00011110b ^ 11011111b = 11000001b
-00011110b ^ 11100000b = 11111110b
-00011110b ^ 11100001b = 11111111b
-00011110b ^ 11100010b = 11111100b
-00011110b ^ 11100011b = 11111101b
-00011110b ^ 11100100b = 11111010b
-00011110b ^ 11100101b = 11111011b
-00011110b ^ 11100110b = 11111000b
-00011110b ^ 11100111b = 11111001b
-00011110b ^ 11101000b = 11110110b
-00011110b ^ 11101001b = 11110111b
-00011110b ^ 11101010b = 11110100b
-00011110b ^ 11101011b = 11110101b
-00011110b ^ 11101100b = 11110010b
-00011110b ^ 11101101b = 11110011b
-00011110b ^ 11101110b = 11110000b
-00011110b ^ 11101111b = 11110001b
-00011110b ^ 11110000b = 11101110b
-00011110b ^ 11110001b = 11101111b
-00011110b ^ 11110010b = 11101100b
-00011110b ^ 11110011b = 11101101b
-00011110b ^ 11110100b = 11101010b
-00011110b ^ 11110101b = 11101011b
-00011110b ^ 11110110b = 11101000b
-00011110b ^ 11110111b = 11101001b
-00011110b ^ 11111000b = 11100110b
-00011110b ^ 11111001b = 11100111b
-00011110b ^ 11111010b = 11100100b
-00011110b ^ 11111011b = 11100101b
-00011110b ^ 11111100b = 11100010b
-00011110b ^ 11111101b = 11100011b
-00011110b ^ 11111110b = 11100000b
-00011110b ^ 11111111b = 11100001b
-00011110b ^ 00000000b = 00011110b
-00011110b ^ 00000001b = 00011111b
-00011110b ^ 00000010b = 00011100b
-00011110b ^ 00000011b = 00011101b
-00011110b ^ 00000100b = 00011010b
-00011110b ^ 00000101b = 00011011b
-00011110b ^ 00000110b = 00011000b
-00011110b ^ 00000111b = 00011001b
-00011110b ^ 00001000b = 00010110b
-00011110b ^ 00001001b = 00010111b
-00011110b ^ 00001010b = 00010100b
-00011110b ^ 00001011b = 00010101b
-00011110b ^ 00001100b = 00010010b
-00011110b ^ 00001101b = 00010011b
-00011110b ^ 00001110b = 00010000b
-00011110b ^ 00001111b = 00010001b
-00011110b ^ 00010000b = 00001110b
-00011110b ^ 00010001b = 00001111b
-00011110b ^ 00010010b = 00001100b
-00011110b ^ 00010011b = 00001101b
-00011110b ^ 00010100b = 00001010b
-00011110b ^ 00010101b = 00001011b
-00011110b ^ 00010110b = 00001000b
-00011110b ^ 00010111b = 00001001b
-00011110b ^ 00011000b = 00000110b
-00011110b ^ 00011001b = 00000111b
-00011110b ^ 00011010b = 00000100b
-00011110b ^ 00011011b = 00000101b
-00011110b ^ 00011100b = 00000010b
-00011110b ^ 00011101b = 00000011b
-00011110b ^ 00011110b = 00000000b
-00011110b ^ 00011111b = 00000001b
-00011110b ^ 00100000b = 00111110b
-00011110b ^ 00100001b = 00111111b
-00011110b ^ 00100010b = 00111100b
-00011110b ^ 00100011b = 00111101b
-00011110b ^ 00100100b = 00111010b
-00011110b ^ 00100101b = 00111011b
-00011110b ^ 00100110b = 00111000b
-00011110b ^ 00100111b = 00111001b
-00011110b ^ 00101000b = 00110110b
-00011110b ^ 00101001b = 00110111b
-00011110b ^ 00101010b = 00110100b
-00011110b ^ 00101011b = 00110101b
-00011110b ^ 00101100b = 00110010b
-00011110b ^ 00101101b = 00110011b
-00011110b ^ 00101110b = 00110000b
-00011110b ^ 00101111b = 00110001b
-00011110b ^ 00110000b = 00101110b
-00011110b ^ 00110001b = 00101111b
-00011110b ^ 00110010b = 00101100b
-00011110b ^ 00110011b = 00101101b
-00011110b ^ 00110100b = 00101010b
-00011110b ^ 00110101b = 00101011b
-00011110b ^ 00110110b = 00101000b
-00011110b ^ 00110111b = 00101001b
-00011110b ^ 00111000b = 00100110b
-00011110b ^ 00111001b = 00100111b
-00011110b ^ 00111010b = 00100100b
-00011110b ^ 00111011b = 00100101b
-00011110b ^ 00111100b = 00100010b
-00011110b ^ 00111101b = 00100011b
-00011110b ^ 00111110b = 00100000b
-00011110b ^ 00111111b = 00100001b
-00011110b ^ 01000000b = 01011110b
-00011110b ^ 01000001b = 01011111b
-00011110b ^ 01000010b = 01011100b
-00011110b ^ 01000011b = 01011101b
-00011110b ^ 01000100b = 01011010b
-00011110b ^ 01000101b = 01011011b
-00011110b ^ 01000110b = 01011000b
-00011110b ^ 01000111b = 01011001b
-00011110b ^ 01001000b = 01010110b
-00011110b ^ 01001001b = 01010111b
-00011110b ^ 01001010b = 01010100b
-00011110b ^ 01001011b = 01010101b
-00011110b ^ 01001100b = 01010010b
-00011110b ^ 01001101b = 01010011b
-00011110b ^ 01001110b = 01010000b
-00011110b ^ 01001111b = 01010001b
-00011110b ^ 01010000b = 01001110b
-00011110b ^ 01010001b = 01001111b
-00011110b ^ 01010010b = 01001100b
-00011110b ^ 01010011b = 01001101b
-00011110b ^ 01010100b = 01001010b
-00011110b ^ 01010101b = 01001011b
-00011110b ^ 01010110b = 01001000b
-00011110b ^ 01010111b = 01001001b
-00011110b ^ 01011000b = 01000110b
-00011110b ^ 01011001b = 01000111b
-00011110b ^ 01011010b = 01000100b
-00011110b ^ 01011011b = 01000101b
-00011110b ^ 01011100b = 01000010b
-00011110b ^ 01011101b = 01000011b
-00011110b ^ 01011110b = 01000000b
-00011110b ^ 01011111b = 01000001b
-00011110b ^ 01100000b = 01111110b
-00011110b ^ 01100001b = 01111111b
-00011110b ^ 01100010b = 01111100b
-00011110b ^ 01100011b = 01111101b
-00011110b ^ 01100100b = 01111010b
-00011110b ^ 01100101b = 01111011b
-00011110b ^ 01100110b = 01111000b
-00011110b ^ 01100111b = 01111001b
-00011110b ^ 01101000b = 01110110b
-00011110b ^ 01101001b = 01110111b
-00011110b ^ 01101010b = 01110100b
-00011110b ^ 01101011b = 01110101b
-00011110b ^ 01101100b = 01110010b
-00011110b ^ 01101101b = 01110011b
-00011110b ^ 01101110b = 01110000b
-00011110b ^ 01101111b = 01110001b
-00011110b ^ 01110000b = 01101110b
-00011110b ^ 01110001b = 01101111b
-00011110b ^ 01110010b = 01101100b
-00011110b ^ 01110011b = 01101101b
-00011110b ^ 01110100b = 01101010b
-00011110b ^ 01110101b = 01101011b
-00011110b ^ 01110110b = 01101000b
-00011110b ^ 01110111b = 01101001b
-00011110b ^ 01111000b = 01100110b
-00011110b ^ 01111001b = 01100111b
-00011110b ^ 01111010b = 01100100b
-00011110b ^ 01111011b = 01100101b
-00011110b ^ 01111100b = 01100010b
-00011110b ^ 01111101b = 01100011b
-00011110b ^ 01111110b = 01100000b
-00011111b ^ 10000000b = 10011111b
-00011111b ^ 10000001b = 10011110b
-00011111b ^ 10000010b = 10011101b
-00011111b ^ 10000011b = 10011100b
-00011111b ^ 10000100b = 10011011b
-00011111b ^ 10000101b = 10011010b
-00011111b ^ 10000110b = 10011001b
-00011111b ^ 10000111b = 10011000b
-00011111b ^ 10001000b = 10010111b
-00011111b ^ 10001001b = 10010110b
-00011111b ^ 10001010b = 10010101b
-00011111b ^ 10001011b = 10010100b
-00011111b ^ 10001100b = 10010011b
-00011111b ^ 10001101b = 10010010b
-00011111b ^ 10001110b = 10010001b
-00011111b ^ 10001111b = 10010000b
-00011111b ^ 10010000b = 10001111b
-00011111b ^ 10010001b = 10001110b
-00011111b ^ 10010010b = 10001101b
-00011111b ^ 10010011b = 10001100b
-00011111b ^ 10010100b = 10001011b
-00011111b ^ 10010101b = 10001010b
-00011111b ^ 10010110b = 10001001b
-00011111b ^ 10010111b = 10001000b
-00011111b ^ 10011000b = 10000111b
-00011111b ^ 10011001b = 10000110b
-00011111b ^ 10011010b = 10000101b
-00011111b ^ 10011011b = 10000100b
-00011111b ^ 10011100b = 10000011b
-00011111b ^ 10011101b = 10000010b
-00011111b ^ 10011110b = 10000001b
-00011111b ^ 10011111b = 10000000b
-00011111b ^ 10100000b = 10111111b
-00011111b ^ 10100001b = 10111110b
-00011111b ^ 10100010b = 10111101b
-00011111b ^ 10100011b = 10111100b
-00011111b ^ 10100100b = 10111011b
-00011111b ^ 10100101b = 10111010b
-00011111b ^ 10100110b = 10111001b
-00011111b ^ 10100111b = 10111000b
-00011111b ^ 10101000b = 10110111b
-00011111b ^ 10101001b = 10110110b
-00011111b ^ 10101010b = 10110101b
-00011111b ^ 10101011b = 10110100b
-00011111b ^ 10101100b = 10110011b
-00011111b ^ 10101101b = 10110010b
-00011111b ^ 10101110b = 10110001b
-00011111b ^ 10101111b = 10110000b
-00011111b ^ 10110000b = 10101111b
-00011111b ^ 10110001b = 10101110b
-00011111b ^ 10110010b = 10101101b
-00011111b ^ 10110011b = 10101100b
-00011111b ^ 10110100b = 10101011b
-00011111b ^ 10110101b = 10101010b
-00011111b ^ 10110110b = 10101001b
-00011111b ^ 10110111b = 10101000b
-00011111b ^ 10111000b = 10100111b
-00011111b ^ 10111001b = 10100110b
-00011111b ^ 10111010b = 10100101b
-00011111b ^ 10111011b = 10100100b
-00011111b ^ 10111100b = 10100011b
-00011111b ^ 10111101b = 10100010b
-00011111b ^ 10111110b = 10100001b
-00011111b ^ 10111111b = 10100000b
-00011111b ^ 11000000b = 11011111b
-00011111b ^ 11000001b = 11011110b
-00011111b ^ 11000010b = 11011101b
-00011111b ^ 11000011b = 11011100b
-00011111b ^ 11000100b = 11011011b
-00011111b ^ 11000101b = 11011010b
-00011111b ^ 11000110b = 11011001b
-00011111b ^ 11000111b = 11011000b
-00011111b ^ 11001000b = 11010111b
-00011111b ^ 11001001b = 11010110b
-00011111b ^ 11001010b = 11010101b
-00011111b ^ 11001011b = 11010100b
-00011111b ^ 11001100b = 11010011b
-00011111b ^ 11001101b = 11010010b
-00011111b ^ 11001110b = 11010001b
-00011111b ^ 11001111b = 11010000b
-00011111b ^ 11010000b = 11001111b
-00011111b ^ 11010001b = 11001110b
-00011111b ^ 11010010b = 11001101b
-00011111b ^ 11010011b = 11001100b
-00011111b ^ 11010100b = 11001011b
-00011111b ^ 11010101b = 11001010b
-00011111b ^ 11010110b = 11001001b
-00011111b ^ 11010111b = 11001000b
-00011111b ^ 11011000b = 11000111b
-00011111b ^ 11011001b = 11000110b
-00011111b ^ 11011010b = 11000101b
-00011111b ^ 11011011b = 11000100b
-00011111b ^ 11011100b = 11000011b
-00011111b ^ 11011101b = 11000010b
-00011111b ^ 11011110b = 11000001b
-00011111b ^ 11011111b = 11000000b
-00011111b ^ 11100000b = 11111111b
-00011111b ^ 11100001b = 11111110b
-00011111b ^ 11100010b = 11111101b
-00011111b ^ 11100011b = 11111100b
-00011111b ^ 11100100b = 11111011b
-00011111b ^ 11100101b = 11111010b
-00011111b ^ 11100110b = 11111001b
-00011111b ^ 11100111b = 11111000b
-00011111b ^ 11101000b = 11110111b
-00011111b ^ 11101001b = 11110110b
-00011111b ^ 11101010b = 11110101b
-00011111b ^ 11101011b = 11110100b
-00011111b ^ 11101100b = 11110011b
-00011111b ^ 11101101b = 11110010b
-00011111b ^ 11101110b = 11110001b
-00011111b ^ 11101111b = 11110000b
-00011111b ^ 11110000b = 11101111b
-00011111b ^ 11110001b = 11101110b
-00011111b ^ 11110010b = 11101101b
-00011111b ^ 11110011b = 11101100b
-00011111b ^ 11110100b = 11101011b
-00011111b ^ 11110101b = 11101010b
-00011111b ^ 11110110b = 11101001b
-00011111b ^ 11110111b = 11101000b
-00011111b ^ 11111000b = 11100111b
-00011111b ^ 11111001b = 11100110b
-00011111b ^ 11111010b = 11100101b
-00011111b ^ 11111011b = 11100100b
-00011111b ^ 11111100b = 11100011b
-00011111b ^ 11111101b = 11100010b
-00011111b ^ 11111110b = 11100001b
-00011111b ^ 11111111b = 11100000b
-00011111b ^ 00000000b = 00011111b
-00011111b ^ 00000001b = 00011110b
-00011111b ^ 00000010b = 00011101b
-00011111b ^ 00000011b = 00011100b
-00011111b ^ 00000100b = 00011011b
-00011111b ^ 00000101b = 00011010b
-00011111b ^ 00000110b = 00011001b
-00011111b ^ 00000111b = 00011000b
-00011111b ^ 00001000b = 00010111b
-00011111b ^ 00001001b = 00010110b
-00011111b ^ 00001010b = 00010101b
-00011111b ^ 00001011b = 00010100b
-00011111b ^ 00001100b = 00010011b
-00011111b ^ 00001101b = 00010010b
-00011111b ^ 00001110b = 00010001b
-00011111b ^ 00001111b = 00010000b
-00011111b ^ 00010000b = 00001111b
-00011111b ^ 00010001b = 00001110b
-00011111b ^ 00010010b = 00001101b
-00011111b ^ 00010011b = 00001100b
-00011111b ^ 00010100b = 00001011b
-00011111b ^ 00010101b = 00001010b
-00011111b ^ 00010110b = 00001001b
-00011111b ^ 00010111b = 00001000b
-00011111b ^ 00011000b = 00000111b
-00011111b ^ 00011001b = 00000110b
-00011111b ^ 00011010b = 00000101b
-00011111b ^ 00011011b = 00000100b
-00011111b ^ 00011100b = 00000011b
-00011111b ^ 00011101b = 00000010b
-00011111b ^ 00011110b = 00000001b
-00011111b ^ 00011111b = 00000000b
-00011111b ^ 00100000b = 00111111b
-00011111b ^ 00100001b = 00111110b
-00011111b ^ 00100010b = 00111101b
-00011111b ^ 00100011b = 00111100b
-00011111b ^ 00100100b = 00111011b
-00011111b ^ 00100101b = 00111010b
-00011111b ^ 00100110b = 00111001b
-00011111b ^ 00100111b = 00111000b
-00011111b ^ 00101000b = 00110111b
-00011111b ^ 00101001b = 00110110b
-00011111b ^ 00101010b = 00110101b
-00011111b ^ 00101011b = 00110100b
-00011111b ^ 00101100b = 00110011b
-00011111b ^ 00101101b = 00110010b
-00011111b ^ 00101110b = 00110001b
-00011111b ^ 00101111b = 00110000b
-00011111b ^ 00110000b = 00101111b
-00011111b ^ 00110001b = 00101110b
-00011111b ^ 00110010b = 00101101b
-00011111b ^ 00110011b = 00101100b
-00011111b ^ 00110100b = 00101011b
-00011111b ^ 00110101b = 00101010b
-00011111b ^ 00110110b = 00101001b
-00011111b ^ 00110111b = 00101000b
-00011111b ^ 00111000b = 00100111b
-00011111b ^ 00111001b = 00100110b
-00011111b ^ 00111010b = 00100101b
-00011111b ^ 00111011b = 00100100b
-00011111b ^ 00111100b = 00100011b
-00011111b ^ 00111101b = 00100010b
-00011111b ^ 00111110b = 00100001b
-00011111b ^ 00111111b = 00100000b
-00011111b ^ 01000000b = 01011111b
-00011111b ^ 01000001b = 01011110b
-00011111b ^ 01000010b = 01011101b
-00011111b ^ 01000011b = 01011100b
-00011111b ^ 01000100b = 01011011b
-00011111b ^ 01000101b = 01011010b
-00011111b ^ 01000110b = 01011001b
-00011111b ^ 01000111b = 01011000b
-00011111b ^ 01001000b = 01010111b
-00011111b ^ 01001001b = 01010110b
-00011111b ^ 01001010b = 01010101b
-00011111b ^ 01001011b = 01010100b
-00011111b ^ 01001100b = 01010011b
-00011111b ^ 01001101b = 01010010b
-00011111b ^ 01001110b = 01010001b
-00011111b ^ 01001111b = 01010000b
-00011111b ^ 01010000b = 01001111b
-00011111b ^ 01010001b = 01001110b
-00011111b ^ 01010010b = 01001101b
-00011111b ^ 01010011b = 01001100b
-00011111b ^ 01010100b = 01001011b
-00011111b ^ 01010101b = 01001010b
-00011111b ^ 01010110b = 01001001b
-00011111b ^ 01010111b = 01001000b
-00011111b ^ 01011000b = 01000111b
-00011111b ^ 01011001b = 01000110b
-00011111b ^ 01011010b = 01000101b
-00011111b ^ 01011011b = 01000100b
-00011111b ^ 01011100b = 01000011b
-00011111b ^ 01011101b = 01000010b
-00011111b ^ 01011110b = 01000001b
-00011111b ^ 01011111b = 01000000b
-00011111b ^ 01100000b = 01111111b
-00011111b ^ 01100001b = 01111110b
-00011111b ^ 01100010b = 01111101b
-00011111b ^ 01100011b = 01111100b
-00011111b ^ 01100100b = 01111011b
-00011111b ^ 01100101b = 01111010b
-00011111b ^ 01100110b = 01111001b
-00011111b ^ 01100111b = 01111000b
-00011111b ^ 01101000b = 01110111b
-00011111b ^ 01101001b = 01110110b
-00011111b ^ 01101010b = 01110101b
-00011111b ^ 01101011b = 01110100b
-00011111b ^ 01101100b = 01110011b
-00011111b ^ 01101101b = 01110010b
-00011111b ^ 01101110b = 01110001b
-00011111b ^ 01101111b = 01110000b
-00011111b ^ 01110000b = 01101111b
-00011111b ^ 01110001b = 01101110b
-00011111b ^ 01110010b = 01101101b
-00011111b ^ 01110011b = 01101100b
-00011111b ^ 01110100b = 01101011b
-00011111b ^ 01110101b = 01101010b
-00011111b ^ 01110110b = 01101001b
-00011111b ^ 01110111b = 01101000b
-00011111b ^ 01111000b = 01100111b
-00011111b ^ 01111001b = 01100110b
-00011111b ^ 01111010b = 01100101b
-00011111b ^ 01111011b = 01100100b
-00011111b ^ 01111100b = 01100011b
-00011111b ^ 01111101b = 01100010b
-00011111b ^ 01111110b = 01100001b
-00100000b ^ 10000000b = 10100000b
-00100000b ^ 10000001b = 10100001b
-00100000b ^ 10000010b = 10100010b
-00100000b ^ 10000011b = 10100011b
-00100000b ^ 10000100b = 10100100b
-00100000b ^ 10000101b = 10100101b
-00100000b ^ 10000110b = 10100110b
-00100000b ^ 10000111b = 10100111b
-00100000b ^ 10001000b = 10101000b
-00100000b ^ 10001001b = 10101001b
-00100000b ^ 10001010b = 10101010b
-00100000b ^ 10001011b = 10101011b
-00100000b ^ 10001100b = 10101100b
-00100000b ^ 10001101b = 10101101b
-00100000b ^ 10001110b = 10101110b
-00100000b ^ 10001111b = 10101111b
-00100000b ^ 10010000b = 10110000b
-00100000b ^ 10010001b = 10110001b
-00100000b ^ 10010010b = 10110010b
-00100000b ^ 10010011b = 10110011b
-00100000b ^ 10010100b = 10110100b
-00100000b ^ 10010101b = 10110101b
-00100000b ^ 10010110b = 10110110b
-00100000b ^ 10010111b = 10110111b
-00100000b ^ 10011000b = 10111000b
-00100000b ^ 10011001b = 10111001b
-00100000b ^ 10011010b = 10111010b
-00100000b ^ 10011011b = 10111011b
-00100000b ^ 10011100b = 10111100b
-00100000b ^ 10011101b = 10111101b
-00100000b ^ 10011110b = 10111110b
-00100000b ^ 10011111b = 10111111b
-00100000b ^ 10100000b = 10000000b
-00100000b ^ 10100001b = 10000001b
-00100000b ^ 10100010b = 10000010b
-00100000b ^ 10100011b = 10000011b
-00100000b ^ 10100100b = 10000100b
-00100000b ^ 10100101b = 10000101b
-00100000b ^ 10100110b = 10000110b
-00100000b ^ 10100111b = 10000111b
-00100000b ^ 10101000b = 10001000b
-00100000b ^ 10101001b = 10001001b
-00100000b ^ 10101010b = 10001010b
-00100000b ^ 10101011b = 10001011b
-00100000b ^ 10101100b = 10001100b
-00100000b ^ 10101101b = 10001101b
-00100000b ^ 10101110b = 10001110b
-00100000b ^ 10101111b = 10001111b
-00100000b ^ 10110000b = 10010000b
-00100000b ^ 10110001b = 10010001b
-00100000b ^ 10110010b = 10010010b
-00100000b ^ 10110011b = 10010011b
-00100000b ^ 10110100b = 10010100b
-00100000b ^ 10110101b = 10010101b
-00100000b ^ 10110110b = 10010110b
-00100000b ^ 10110111b = 10010111b
-00100000b ^ 10111000b = 10011000b
-00100000b ^ 10111001b = 10011001b
-00100000b ^ 10111010b = 10011010b
-00100000b ^ 10111011b = 10011011b
-00100000b ^ 10111100b = 10011100b
-00100000b ^ 10111101b = 10011101b
-00100000b ^ 10111110b = 10011110b
-00100000b ^ 10111111b = 10011111b
-00100000b ^ 11000000b = 11100000b
-00100000b ^ 11000001b = 11100001b
-00100000b ^ 11000010b = 11100010b
-00100000b ^ 11000011b = 11100011b
-00100000b ^ 11000100b = 11100100b
-00100000b ^ 11000101b = 11100101b
-00100000b ^ 11000110b = 11100110b
-00100000b ^ 11000111b = 11100111b
-00100000b ^ 11001000b = 11101000b
-00100000b ^ 11001001b = 11101001b
-00100000b ^ 11001010b = 11101010b
-00100000b ^ 11001011b = 11101011b
-00100000b ^ 11001100b = 11101100b
-00100000b ^ 11001101b = 11101101b
-00100000b ^ 11001110b = 11101110b
-00100000b ^ 11001111b = 11101111b
-00100000b ^ 11010000b = 11110000b
-00100000b ^ 11010001b = 11110001b
-00100000b ^ 11010010b = 11110010b
-00100000b ^ 11010011b = 11110011b
-00100000b ^ 11010100b = 11110100b
-00100000b ^ 11010101b = 11110101b
-00100000b ^ 11010110b = 11110110b
-00100000b ^ 11010111b = 11110111b
-00100000b ^ 11011000b = 11111000b
-00100000b ^ 11011001b = 11111001b
-00100000b ^ 11011010b = 11111010b
-00100000b ^ 11011011b = 11111011b
-00100000b ^ 11011100b = 11111100b
-00100000b ^ 11011101b = 11111101b
-00100000b ^ 11011110b = 11111110b
-00100000b ^ 11011111b = 11111111b
-00100000b ^ 11100000b = 11000000b
-00100000b ^ 11100001b = 11000001b
-00100000b ^ 11100010b = 11000010b
-00100000b ^ 11100011b = 11000011b
-00100000b ^ 11100100b = 11000100b
-00100000b ^ 11100101b = 11000101b
-00100000b ^ 11100110b = 11000110b
-00100000b ^ 11100111b = 11000111b
-00100000b ^ 11101000b = 11001000b
-00100000b ^ 11101001b = 11001001b
-00100000b ^ 11101010b = 11001010b
-00100000b ^ 11101011b = 11001011b
-00100000b ^ 11101100b = 11001100b
-00100000b ^ 11101101b = 11001101b
-00100000b ^ 11101110b = 11001110b
-00100000b ^ 11101111b = 11001111b
-00100000b ^ 11110000b = 11010000b
-00100000b ^ 11110001b = 11010001b
-00100000b ^ 11110010b = 11010010b
-00100000b ^ 11110011b = 11010011b
-00100000b ^ 11110100b = 11010100b
-00100000b ^ 11110101b = 11010101b
-00100000b ^ 11110110b = 11010110b
-00100000b ^ 11110111b = 11010111b
-00100000b ^ 11111000b = 11011000b
-00100000b ^ 11111001b = 11011001b
-00100000b ^ 11111010b = 11011010b
-00100000b ^ 11111011b = 11011011b
-00100000b ^ 11111100b = 11011100b
-00100000b ^ 11111101b = 11011101b
-00100000b ^ 11111110b = 11011110b
-00100000b ^ 11111111b = 11011111b
-00100000b ^ 00000000b = 00100000b
-00100000b ^ 00000001b = 00100001b
-00100000b ^ 00000010b = 00100010b
-00100000b ^ 00000011b = 00100011b
-00100000b ^ 00000100b = 00100100b
-00100000b ^ 00000101b = 00100101b
-00100000b ^ 00000110b = 00100110b
-00100000b ^ 00000111b = 00100111b
-00100000b ^ 00001000b = 00101000b
-00100000b ^ 00001001b = 00101001b
-00100000b ^ 00001010b = 00101010b
-00100000b ^ 00001011b = 00101011b
-00100000b ^ 00001100b = 00101100b
-00100000b ^ 00001101b = 00101101b
-00100000b ^ 00001110b = 00101110b
-00100000b ^ 00001111b = 00101111b
-00100000b ^ 00010000b = 00110000b
-00100000b ^ 00010001b = 00110001b
-00100000b ^ 00010010b = 00110010b
-00100000b ^ 00010011b = 00110011b
-00100000b ^ 00010100b = 00110100b
-00100000b ^ 00010101b = 00110101b
-00100000b ^ 00010110b = 00110110b
-00100000b ^ 00010111b = 00110111b
-00100000b ^ 00011000b = 00111000b
-00100000b ^ 00011001b = 00111001b
-00100000b ^ 00011010b = 00111010b
-00100000b ^ 00011011b = 00111011b
-00100000b ^ 00011100b = 00111100b
-00100000b ^ 00011101b = 00111101b
-00100000b ^ 00011110b = 00111110b
-00100000b ^ 00011111b = 00111111b
-00100000b ^ 00100000b = 00000000b
-00100000b ^ 00100001b = 00000001b
-00100000b ^ 00100010b = 00000010b
-00100000b ^ 00100011b = 00000011b
-00100000b ^ 00100100b = 00000100b
-00100000b ^ 00100101b = 00000101b
-00100000b ^ 00100110b = 00000110b
-00100000b ^ 00100111b = 00000111b
-00100000b ^ 00101000b = 00001000b
-00100000b ^ 00101001b = 00001001b
-00100000b ^ 00101010b = 00001010b
-00100000b ^ 00101011b = 00001011b
-00100000b ^ 00101100b = 00001100b
-00100000b ^ 00101101b = 00001101b
-00100000b ^ 00101110b = 00001110b
-00100000b ^ 00101111b = 00001111b
-00100000b ^ 00110000b = 00010000b
-00100000b ^ 00110001b = 00010001b
-00100000b ^ 00110010b = 00010010b
-00100000b ^ 00110011b = 00010011b
-00100000b ^ 00110100b = 00010100b
-00100000b ^ 00110101b = 00010101b
-00100000b ^ 00110110b = 00010110b
-00100000b ^ 00110111b = 00010111b
-00100000b ^ 00111000b = 00011000b
-00100000b ^ 00111001b = 00011001b
-00100000b ^ 00111010b = 00011010b
-00100000b ^ 00111011b = 00011011b
-00100000b ^ 00111100b = 00011100b
-00100000b ^ 00111101b = 00011101b
-00100000b ^ 00111110b = 00011110b
-00100000b ^ 00111111b = 00011111b
-00100000b ^ 01000000b = 01100000b
-00100000b ^ 01000001b = 01100001b
-00100000b ^ 01000010b = 01100010b
-00100000b ^ 01000011b = 01100011b
-00100000b ^ 01000100b = 01100100b
-00100000b ^ 01000101b = 01100101b
-00100000b ^ 01000110b = 01100110b
-00100000b ^ 01000111b = 01100111b
-00100000b ^ 01001000b = 01101000b
-00100000b ^ 01001001b = 01101001b
-00100000b ^ 01001010b = 01101010b
-00100000b ^ 01001011b = 01101011b
-00100000b ^ 01001100b = 01101100b
-00100000b ^ 01001101b = 01101101b
-00100000b ^ 01001110b = 01101110b
-00100000b ^ 01001111b = 01101111b
-00100000b ^ 01010000b = 01110000b
-00100000b ^ 01010001b = 01110001b
-00100000b ^ 01010010b = 01110010b
-00100000b ^ 01010011b = 01110011b
-00100000b ^ 01010100b = 01110100b
-00100000b ^ 01010101b = 01110101b
-00100000b ^ 01010110b = 01110110b
-00100000b ^ 01010111b = 01110111b
-00100000b ^ 01011000b = 01111000b
-00100000b ^ 01011001b = 01111001b
-00100000b ^ 01011010b = 01111010b
-00100000b ^ 01011011b = 01111011b
-00100000b ^ 01011100b = 01111100b
-00100000b ^ 01011101b = 01111101b
-00100000b ^ 01011110b = 01111110b
-00100000b ^ 01011111b = 01111111b
-00100000b ^ 01100000b = 01000000b
-00100000b ^ 01100001b = 01000001b
-00100000b ^ 01100010b = 01000010b
-00100000b ^ 01100011b = 01000011b
-00100000b ^ 01100100b = 01000100b
-00100000b ^ 01100101b = 01000101b
-00100000b ^ 01100110b = 01000110b
-00100000b ^ 01100111b = 01000111b
-00100000b ^ 01101000b = 01001000b
-00100000b ^ 01101001b = 01001001b
-00100000b ^ 01101010b = 01001010b
-00100000b ^ 01101011b = 01001011b
-00100000b ^ 01101100b = 01001100b
-00100000b ^ 01101101b = 01001101b
-00100000b ^ 01101110b = 01001110b
-00100000b ^ 01101111b = 01001111b
-00100000b ^ 01110000b = 01010000b
-00100000b ^ 01110001b = 01010001b
-00100000b ^ 01110010b = 01010010b
-00100000b ^ 01110011b = 01010011b
-00100000b ^ 01110100b = 01010100b
-00100000b ^ 01110101b = 01010101b
-00100000b ^ 01110110b = 01010110b
-00100000b ^ 01110111b = 01010111b
-00100000b ^ 01111000b = 01011000b
-00100000b ^ 01111001b = 01011001b
-00100000b ^ 01111010b = 01011010b
-00100000b ^ 01111011b = 01011011b
-00100000b ^ 01111100b = 01011100b
-00100000b ^ 01111101b = 01011101b
-00100000b ^ 01111110b = 01011110b
-00100001b ^ 10000000b = 10100001b
-00100001b ^ 10000001b = 10100000b
-00100001b ^ 10000010b = 10100011b
-00100001b ^ 10000011b = 10100010b
-00100001b ^ 10000100b = 10100101b
-00100001b ^ 10000101b = 10100100b
-00100001b ^ 10000110b = 10100111b
-00100001b ^ 10000111b = 10100110b
-00100001b ^ 10001000b = 10101001b
-00100001b ^ 10001001b = 10101000b
-00100001b ^ 10001010b = 10101011b
-00100001b ^ 10001011b = 10101010b
-00100001b ^ 10001100b = 10101101b
-00100001b ^ 10001101b = 10101100b
-00100001b ^ 10001110b = 10101111b
-00100001b ^ 10001111b = 10101110b
-00100001b ^ 10010000b = 10110001b
-00100001b ^ 10010001b = 10110000b
-00100001b ^ 10010010b = 10110011b
-00100001b ^ 10010011b = 10110010b
-00100001b ^ 10010100b = 10110101b
-00100001b ^ 10010101b = 10110100b
-00100001b ^ 10010110b = 10110111b
-00100001b ^ 10010111b = 10110110b
-00100001b ^ 10011000b = 10111001b
-00100001b ^ 10011001b = 10111000b
-00100001b ^ 10011010b = 10111011b
-00100001b ^ 10011011b = 10111010b
-00100001b ^ 10011100b = 10111101b
-00100001b ^ 10011101b = 10111100b
-00100001b ^ 10011110b = 10111111b
-00100001b ^ 10011111b = 10111110b
-00100001b ^ 10100000b = 10000001b
-00100001b ^ 10100001b = 10000000b
-00100001b ^ 10100010b = 10000011b
-00100001b ^ 10100011b = 10000010b
-00100001b ^ 10100100b = 10000101b
-00100001b ^ 10100101b = 10000100b
-00100001b ^ 10100110b = 10000111b
-00100001b ^ 10100111b = 10000110b
-00100001b ^ 10101000b = 10001001b
-00100001b ^ 10101001b = 10001000b
-00100001b ^ 10101010b = 10001011b
-00100001b ^ 10101011b = 10001010b
-00100001b ^ 10101100b = 10001101b
-00100001b ^ 10101101b = 10001100b
-00100001b ^ 10101110b = 10001111b
-00100001b ^ 10101111b = 10001110b
-00100001b ^ 10110000b = 10010001b
-00100001b ^ 10110001b = 10010000b
-00100001b ^ 10110010b = 10010011b
-00100001b ^ 10110011b = 10010010b
-00100001b ^ 10110100b = 10010101b
-00100001b ^ 10110101b = 10010100b
-00100001b ^ 10110110b = 10010111b
-00100001b ^ 10110111b = 10010110b
-00100001b ^ 10111000b = 10011001b
-00100001b ^ 10111001b = 10011000b
-00100001b ^ 10111010b = 10011011b
-00100001b ^ 10111011b = 10011010b
-00100001b ^ 10111100b = 10011101b
-00100001b ^ 10111101b = 10011100b
-00100001b ^ 10111110b = 10011111b
-00100001b ^ 10111111b = 10011110b
-00100001b ^ 11000000b = 11100001b
-00100001b ^ 11000001b = 11100000b
-00100001b ^ 11000010b = 11100011b
-00100001b ^ 11000011b = 11100010b
-00100001b ^ 11000100b = 11100101b
-00100001b ^ 11000101b = 11100100b
-00100001b ^ 11000110b = 11100111b
-00100001b ^ 11000111b = 11100110b
-00100001b ^ 11001000b = 11101001b
-00100001b ^ 11001001b = 11101000b
-00100001b ^ 11001010b = 11101011b
-00100001b ^ 11001011b = 11101010b
-00100001b ^ 11001100b = 11101101b
-00100001b ^ 11001101b = 11101100b
-00100001b ^ 11001110b = 11101111b
-00100001b ^ 11001111b = 11101110b
-00100001b ^ 11010000b = 11110001b
-00100001b ^ 11010001b = 11110000b
-00100001b ^ 11010010b = 11110011b
-00100001b ^ 11010011b = 11110010b
-00100001b ^ 11010100b = 11110101b
-00100001b ^ 11010101b = 11110100b
-00100001b ^ 11010110b = 11110111b
-00100001b ^ 11010111b = 11110110b
-00100001b ^ 11011000b = 11111001b
-00100001b ^ 11011001b = 11111000b
-00100001b ^ 11011010b = 11111011b
-00100001b ^ 11011011b = 11111010b
-00100001b ^ 11011100b = 11111101b
-00100001b ^ 11011101b = 11111100b
-00100001b ^ 11011110b = 11111111b
-00100001b ^ 11011111b = 11111110b
-00100001b ^ 11100000b = 11000001b
-00100001b ^ 11100001b = 11000000b
-00100001b ^ 11100010b = 11000011b
-00100001b ^ 11100011b = 11000010b
-00100001b ^ 11100100b = 11000101b
-00100001b ^ 11100101b = 11000100b
-00100001b ^ 11100110b = 11000111b
-00100001b ^ 11100111b = 11000110b
-00100001b ^ 11101000b = 11001001b
-00100001b ^ 11101001b = 11001000b
-00100001b ^ 11101010b = 11001011b
-00100001b ^ 11101011b = 11001010b
-00100001b ^ 11101100b = 11001101b
-00100001b ^ 11101101b = 11001100b
-00100001b ^ 11101110b = 11001111b
-00100001b ^ 11101111b = 11001110b
-00100001b ^ 11110000b = 11010001b
-00100001b ^ 11110001b = 11010000b
-00100001b ^ 11110010b = 11010011b
-00100001b ^ 11110011b = 11010010b
-00100001b ^ 11110100b = 11010101b
-00100001b ^ 11110101b = 11010100b
-00100001b ^ 11110110b = 11010111b
-00100001b ^ 11110111b = 11010110b
-00100001b ^ 11111000b = 11011001b
-00100001b ^ 11111001b = 11011000b
-00100001b ^ 11111010b = 11011011b
-00100001b ^ 11111011b = 11011010b
-00100001b ^ 11111100b = 11011101b
-00100001b ^ 11111101b = 11011100b
-00100001b ^ 11111110b = 11011111b
-00100001b ^ 11111111b = 11011110b
-00100001b ^ 00000000b = 00100001b
-00100001b ^ 00000001b = 00100000b
-00100001b ^ 00000010b = 00100011b
-00100001b ^ 00000011b = 00100010b
-00100001b ^ 00000100b = 00100101b
-00100001b ^ 00000101b = 00100100b
-00100001b ^ 00000110b = 00100111b
-00100001b ^ 00000111b = 00100110b
-00100001b ^ 00001000b = 00101001b
-00100001b ^ 00001001b = 00101000b
-00100001b ^ 00001010b = 00101011b
-00100001b ^ 00001011b = 00101010b
-00100001b ^ 00001100b = 00101101b
-00100001b ^ 00001101b = 00101100b
-00100001b ^ 00001110b = 00101111b
-00100001b ^ 00001111b = 00101110b
-00100001b ^ 00010000b = 00110001b
-00100001b ^ 00010001b = 00110000b
-00100001b ^ 00010010b = 00110011b
-00100001b ^ 00010011b = 00110010b
-00100001b ^ 00010100b = 00110101b
-00100001b ^ 00010101b = 00110100b
-00100001b ^ 00010110b = 00110111b
-00100001b ^ 00010111b = 00110110b
-00100001b ^ 00011000b = 00111001b
-00100001b ^ 00011001b = 00111000b
-00100001b ^ 00011010b = 00111011b
-00100001b ^ 00011011b = 00111010b
-00100001b ^ 00011100b = 00111101b
-00100001b ^ 00011101b = 00111100b
-00100001b ^ 00011110b = 00111111b
-00100001b ^ 00011111b = 00111110b
-00100001b ^ 00100000b = 00000001b
-00100001b ^ 00100001b = 00000000b
-00100001b ^ 00100010b = 00000011b
-00100001b ^ 00100011b = 00000010b
-00100001b ^ 00100100b = 00000101b
-00100001b ^ 00100101b = 00000100b
-00100001b ^ 00100110b = 00000111b
-00100001b ^ 00100111b = 00000110b
-00100001b ^ 00101000b = 00001001b
-00100001b ^ 00101001b = 00001000b
-00100001b ^ 00101010b = 00001011b
-00100001b ^ 00101011b = 00001010b
-00100001b ^ 00101100b = 00001101b
-00100001b ^ 00101101b = 00001100b
-00100001b ^ 00101110b = 00001111b
-00100001b ^ 00101111b = 00001110b
-00100001b ^ 00110000b = 00010001b
-00100001b ^ 00110001b = 00010000b
-00100001b ^ 00110010b = 00010011b
-00100001b ^ 00110011b = 00010010b
-00100001b ^ 00110100b = 00010101b
-00100001b ^ 00110101b = 00010100b
-00100001b ^ 00110110b = 00010111b
-00100001b ^ 00110111b = 00010110b
-00100001b ^ 00111000b = 00011001b
-00100001b ^ 00111001b = 00011000b
-00100001b ^ 00111010b = 00011011b
-00100001b ^ 00111011b = 00011010b
-00100001b ^ 00111100b = 00011101b
-00100001b ^ 00111101b = 00011100b
-00100001b ^ 00111110b = 00011111b
-00100001b ^ 00111111b = 00011110b
-00100001b ^ 01000000b = 01100001b
-00100001b ^ 01000001b = 01100000b
-00100001b ^ 01000010b = 01100011b
-00100001b ^ 01000011b = 01100010b
-00100001b ^ 01000100b = 01100101b
-00100001b ^ 01000101b = 01100100b
-00100001b ^ 01000110b = 01100111b
-00100001b ^ 01000111b = 01100110b
-00100001b ^ 01001000b = 01101001b
-00100001b ^ 01001001b = 01101000b
-00100001b ^ 01001010b = 01101011b
-00100001b ^ 01001011b = 01101010b
-00100001b ^ 01001100b = 01101101b
-00100001b ^ 01001101b = 01101100b
-00100001b ^ 01001110b = 01101111b
-00100001b ^ 01001111b = 01101110b
-00100001b ^ 01010000b = 01110001b
-00100001b ^ 01010001b = 01110000b
-00100001b ^ 01010010b = 01110011b
-00100001b ^ 01010011b = 01110010b
-00100001b ^ 01010100b = 01110101b
-00100001b ^ 01010101b = 01110100b
-00100001b ^ 01010110b = 01110111b
-00100001b ^ 01010111b = 01110110b
-00100001b ^ 01011000b = 01111001b
-00100001b ^ 01011001b = 01111000b
-00100001b ^ 01011010b = 01111011b
-00100001b ^ 01011011b = 01111010b
-00100001b ^ 01011100b = 01111101b
-00100001b ^ 01011101b = 01111100b
-00100001b ^ 01011110b = 01111111b
-00100001b ^ 01011111b = 01111110b
-00100001b ^ 01100000b = 01000001b
-00100001b ^ 01100001b = 01000000b
-00100001b ^ 01100010b = 01000011b
-00100001b ^ 01100011b = 01000010b
-00100001b ^ 01100100b = 01000101b
-00100001b ^ 01100101b = 01000100b
-00100001b ^ 01100110b = 01000111b
-00100001b ^ 01100111b = 01000110b
-00100001b ^ 01101000b = 01001001b
-00100001b ^ 01101001b = 01001000b
-00100001b ^ 01101010b = 01001011b
-00100001b ^ 01101011b = 01001010b
-00100001b ^ 01101100b = 01001101b
-00100001b ^ 01101101b = 01001100b
-00100001b ^ 01101110b = 01001111b
-00100001b ^ 01101111b = 01001110b
-00100001b ^ 01110000b = 01010001b
-00100001b ^ 01110001b = 01010000b
-00100001b ^ 01110010b = 01010011b
-00100001b ^ 01110011b = 01010010b
-00100001b ^ 01110100b = 01010101b
-00100001b ^ 01110101b = 01010100b
-00100001b ^ 01110110b = 01010111b
-00100001b ^ 01110111b = 01010110b
-00100001b ^ 01111000b = 01011001b
-00100001b ^ 01111001b = 01011000b
-00100001b ^ 01111010b = 01011011b
-00100001b ^ 01111011b = 01011010b
-00100001b ^ 01111100b = 01011101b
-00100001b ^ 01111101b = 01011100b
-00100001b ^ 01111110b = 01011111b
-00100010b ^ 10000000b = 10100010b
-00100010b ^ 10000001b = 10100011b
-00100010b ^ 10000010b = 10100000b
-00100010b ^ 10000011b = 10100001b
-00100010b ^ 10000100b = 10100110b
-00100010b ^ 10000101b = 10100111b
-00100010b ^ 10000110b = 10100100b
-00100010b ^ 10000111b = 10100101b
-00100010b ^ 10001000b = 10101010b
-00100010b ^ 10001001b = 10101011b
-00100010b ^ 10001010b = 10101000b
-00100010b ^ 10001011b = 10101001b
-00100010b ^ 10001100b = 10101110b
-00100010b ^ 10001101b = 10101111b
-00100010b ^ 10001110b = 10101100b
-00100010b ^ 10001111b = 10101101b
-00100010b ^ 10010000b = 10110010b
-00100010b ^ 10010001b = 10110011b
-00100010b ^ 10010010b = 10110000b
-00100010b ^ 10010011b = 10110001b
-00100010b ^ 10010100b = 10110110b
-00100010b ^ 10010101b = 10110111b
-00100010b ^ 10010110b = 10110100b
-00100010b ^ 10010111b = 10110101b
-00100010b ^ 10011000b = 10111010b
-00100010b ^ 10011001b = 10111011b
-00100010b ^ 10011010b = 10111000b
-00100010b ^ 10011011b = 10111001b
-00100010b ^ 10011100b = 10111110b
-00100010b ^ 10011101b = 10111111b
-00100010b ^ 10011110b = 10111100b
-00100010b ^ 10011111b = 10111101b
-00100010b ^ 10100000b = 10000010b
-00100010b ^ 10100001b = 10000011b
-00100010b ^ 10100010b = 10000000b
-00100010b ^ 10100011b = 10000001b
-00100010b ^ 10100100b = 10000110b
-00100010b ^ 10100101b = 10000111b
-00100010b ^ 10100110b = 10000100b
-00100010b ^ 10100111b = 10000101b
-00100010b ^ 10101000b = 10001010b
-00100010b ^ 10101001b = 10001011b
-00100010b ^ 10101010b = 10001000b
-00100010b ^ 10101011b = 10001001b
-00100010b ^ 10101100b = 10001110b
-00100010b ^ 10101101b = 10001111b
-00100010b ^ 10101110b = 10001100b
-00100010b ^ 10101111b = 10001101b
-00100010b ^ 10110000b = 10010010b
-00100010b ^ 10110001b = 10010011b
-00100010b ^ 10110010b = 10010000b
-00100010b ^ 10110011b = 10010001b
-00100010b ^ 10110100b = 10010110b
-00100010b ^ 10110101b = 10010111b
-00100010b ^ 10110110b = 10010100b
-00100010b ^ 10110111b = 10010101b
-00100010b ^ 10111000b = 10011010b
-00100010b ^ 10111001b = 10011011b
-00100010b ^ 10111010b = 10011000b
-00100010b ^ 10111011b = 10011001b
-00100010b ^ 10111100b = 10011110b
-00100010b ^ 10111101b = 10011111b
-00100010b ^ 10111110b = 10011100b
-00100010b ^ 10111111b = 10011101b
-00100010b ^ 11000000b = 11100010b
-00100010b ^ 11000001b = 11100011b
-00100010b ^ 11000010b = 11100000b
-00100010b ^ 11000011b = 11100001b
-00100010b ^ 11000100b = 11100110b
-00100010b ^ 11000101b = 11100111b
-00100010b ^ 11000110b = 11100100b
-00100010b ^ 11000111b = 11100101b
-00100010b ^ 11001000b = 11101010b
-00100010b ^ 11001001b = 11101011b
-00100010b ^ 11001010b = 11101000b
-00100010b ^ 11001011b = 11101001b
-00100010b ^ 11001100b = 11101110b
-00100010b ^ 11001101b = 11101111b
-00100010b ^ 11001110b = 11101100b
-00100010b ^ 11001111b = 11101101b
-00100010b ^ 11010000b = 11110010b
-00100010b ^ 11010001b = 11110011b
-00100010b ^ 11010010b = 11110000b
-00100010b ^ 11010011b = 11110001b
-00100010b ^ 11010100b = 11110110b
-00100010b ^ 11010101b = 11110111b
-00100010b ^ 11010110b = 11110100b
-00100010b ^ 11010111b = 11110101b
-00100010b ^ 11011000b = 11111010b
-00100010b ^ 11011001b = 11111011b
-00100010b ^ 11011010b = 11111000b
-00100010b ^ 11011011b = 11111001b
-00100010b ^ 11011100b = 11111110b
-00100010b ^ 11011101b = 11111111b
-00100010b ^ 11011110b = 11111100b
-00100010b ^ 11011111b = 11111101b
-00100010b ^ 11100000b = 11000010b
-00100010b ^ 11100001b = 11000011b
-00100010b ^ 11100010b = 11000000b
-00100010b ^ 11100011b = 11000001b
-00100010b ^ 11100100b = 11000110b
-00100010b ^ 11100101b = 11000111b
-00100010b ^ 11100110b = 11000100b
-00100010b ^ 11100111b = 11000101b
-00100010b ^ 11101000b = 11001010b
-00100010b ^ 11101001b = 11001011b
-00100010b ^ 11101010b = 11001000b
-00100010b ^ 11101011b = 11001001b
-00100010b ^ 11101100b = 11001110b
-00100010b ^ 11101101b = 11001111b
-00100010b ^ 11101110b = 11001100b
-00100010b ^ 11101111b = 11001101b
-00100010b ^ 11110000b = 11010010b
-00100010b ^ 11110001b = 11010011b
-00100010b ^ 11110010b = 11010000b
-00100010b ^ 11110011b = 11010001b
-00100010b ^ 11110100b = 11010110b
-00100010b ^ 11110101b = 11010111b
-00100010b ^ 11110110b = 11010100b
-00100010b ^ 11110111b = 11010101b
-00100010b ^ 11111000b = 11011010b
-00100010b ^ 11111001b = 11011011b
-00100010b ^ 11111010b = 11011000b
-00100010b ^ 11111011b = 11011001b
-00100010b ^ 11111100b = 11011110b
-00100010b ^ 11111101b = 11011111b
-00100010b ^ 11111110b = 11011100b
-00100010b ^ 11111111b = 11011101b
-00100010b ^ 00000000b = 00100010b
-00100010b ^ 00000001b = 00100011b
-00100010b ^ 00000010b = 00100000b
-00100010b ^ 00000011b = 00100001b
-00100010b ^ 00000100b = 00100110b
-00100010b ^ 00000101b = 00100111b
-00100010b ^ 00000110b = 00100100b
-00100010b ^ 00000111b = 00100101b
-00100010b ^ 00001000b = 00101010b
-00100010b ^ 00001001b = 00101011b
-00100010b ^ 00001010b = 00101000b
-00100010b ^ 00001011b = 00101001b
-00100010b ^ 00001100b = 00101110b
-00100010b ^ 00001101b = 00101111b
-00100010b ^ 00001110b = 00101100b
-00100010b ^ 00001111b = 00101101b
-00100010b ^ 00010000b = 00110010b
-00100010b ^ 00010001b = 00110011b
-00100010b ^ 00010010b = 00110000b
-00100010b ^ 00010011b = 00110001b
-00100010b ^ 00010100b = 00110110b
-00100010b ^ 00010101b = 00110111b
-00100010b ^ 00010110b = 00110100b
-00100010b ^ 00010111b = 00110101b
-00100010b ^ 00011000b = 00111010b
-00100010b ^ 00011001b = 00111011b
-00100010b ^ 00011010b = 00111000b
-00100010b ^ 00011011b = 00111001b
-00100010b ^ 00011100b = 00111110b
-00100010b ^ 00011101b = 00111111b
-00100010b ^ 00011110b = 00111100b
-00100010b ^ 00011111b = 00111101b
-00100010b ^ 00100000b = 00000010b
-00100010b ^ 00100001b = 00000011b
-00100010b ^ 00100010b = 00000000b
-00100010b ^ 00100011b = 00000001b
-00100010b ^ 00100100b = 00000110b
-00100010b ^ 00100101b = 00000111b
-00100010b ^ 00100110b = 00000100b
-00100010b ^ 00100111b = 00000101b
-00100010b ^ 00101000b = 00001010b
-00100010b ^ 00101001b = 00001011b
-00100010b ^ 00101010b = 00001000b
-00100010b ^ 00101011b = 00001001b
-00100010b ^ 00101100b = 00001110b
-00100010b ^ 00101101b = 00001111b
-00100010b ^ 00101110b = 00001100b
-00100010b ^ 00101111b = 00001101b
-00100010b ^ 00110000b = 00010010b
-00100010b ^ 00110001b = 00010011b
-00100010b ^ 00110010b = 00010000b
-00100010b ^ 00110011b = 00010001b
-00100010b ^ 00110100b = 00010110b
-00100010b ^ 00110101b = 00010111b
-00100010b ^ 00110110b = 00010100b
-00100010b ^ 00110111b = 00010101b
-00100010b ^ 00111000b = 00011010b
-00100010b ^ 00111001b = 00011011b
-00100010b ^ 00111010b = 00011000b
-00100010b ^ 00111011b = 00011001b
-00100010b ^ 00111100b = 00011110b
-00100010b ^ 00111101b = 00011111b
-00100010b ^ 00111110b = 00011100b
-00100010b ^ 00111111b = 00011101b
-00100010b ^ 01000000b = 01100010b
-00100010b ^ 01000001b = 01100011b
-00100010b ^ 01000010b = 01100000b
-00100010b ^ 01000011b = 01100001b
-00100010b ^ 01000100b = 01100110b
-00100010b ^ 01000101b = 01100111b
-00100010b ^ 01000110b = 01100100b
-00100010b ^ 01000111b = 01100101b
-00100010b ^ 01001000b = 01101010b
-00100010b ^ 01001001b = 01101011b
-00100010b ^ 01001010b = 01101000b
-00100010b ^ 01001011b = 01101001b
-00100010b ^ 01001100b = 01101110b
-00100010b ^ 01001101b = 01101111b
-00100010b ^ 01001110b = 01101100b
-00100010b ^ 01001111b = 01101101b
-00100010b ^ 01010000b = 01110010b
-00100010b ^ 01010001b = 01110011b
-00100010b ^ 01010010b = 01110000b
-00100010b ^ 01010011b = 01110001b
-00100010b ^ 01010100b = 01110110b
-00100010b ^ 01010101b = 01110111b
-00100010b ^ 01010110b = 01110100b
-00100010b ^ 01010111b = 01110101b
-00100010b ^ 01011000b = 01111010b
-00100010b ^ 01011001b = 01111011b
-00100010b ^ 01011010b = 01111000b
-00100010b ^ 01011011b = 01111001b
-00100010b ^ 01011100b = 01111110b
-00100010b ^ 01011101b = 01111111b
-00100010b ^ 01011110b = 01111100b
-00100010b ^ 01011111b = 01111101b
-00100010b ^ 01100000b = 01000010b
-00100010b ^ 01100001b = 01000011b
-00100010b ^ 01100010b = 01000000b
-00100010b ^ 01100011b = 01000001b
-00100010b ^ 01100100b = 01000110b
-00100010b ^ 01100101b = 01000111b
-00100010b ^ 01100110b = 01000100b
-00100010b ^ 01100111b = 01000101b
-00100010b ^ 01101000b = 01001010b
-00100010b ^ 01101001b = 01001011b
-00100010b ^ 01101010b = 01001000b
-00100010b ^ 01101011b = 01001001b
-00100010b ^ 01101100b = 01001110b
-00100010b ^ 01101101b = 01001111b
-00100010b ^ 01101110b = 01001100b
-00100010b ^ 01101111b = 01001101b
-00100010b ^ 01110000b = 01010010b
-00100010b ^ 01110001b = 01010011b
-00100010b ^ 01110010b = 01010000b
-00100010b ^ 01110011b = 01010001b
-00100010b ^ 01110100b = 01010110b
-00100010b ^ 01110101b = 01010111b
-00100010b ^ 01110110b = 01010100b
-00100010b ^ 01110111b = 01010101b
-00100010b ^ 01111000b = 01011010b
-00100010b ^ 01111001b = 01011011b
-00100010b ^ 01111010b = 01011000b
-00100010b ^ 01111011b = 01011001b
-00100010b ^ 01111100b = 01011110b
-00100010b ^ 01111101b = 01011111b
-00100010b ^ 01111110b = 01011100b
-00100011b ^ 10000000b = 10100011b
-00100011b ^ 10000001b = 10100010b
-00100011b ^ 10000010b = 10100001b
-00100011b ^ 10000011b = 10100000b
-00100011b ^ 10000100b = 10100111b
-00100011b ^ 10000101b = 10100110b
-00100011b ^ 10000110b = 10100101b
-00100011b ^ 10000111b = 10100100b
-00100011b ^ 10001000b = 10101011b
-00100011b ^ 10001001b = 10101010b
-00100011b ^ 10001010b = 10101001b
-00100011b ^ 10001011b = 10101000b
-00100011b ^ 10001100b = 10101111b
-00100011b ^ 10001101b = 10101110b
-00100011b ^ 10001110b = 10101101b
-00100011b ^ 10001111b = 10101100b
-00100011b ^ 10010000b = 10110011b
-00100011b ^ 10010001b = 10110010b
-00100011b ^ 10010010b = 10110001b
-00100011b ^ 10010011b = 10110000b
-00100011b ^ 10010100b = 10110111b
-00100011b ^ 10010101b = 10110110b
-00100011b ^ 10010110b = 10110101b
-00100011b ^ 10010111b = 10110100b
-00100011b ^ 10011000b = 10111011b
-00100011b ^ 10011001b = 10111010b
-00100011b ^ 10011010b = 10111001b
-00100011b ^ 10011011b = 10111000b
-00100011b ^ 10011100b = 10111111b
-00100011b ^ 10011101b = 10111110b
-00100011b ^ 10011110b = 10111101b
-00100011b ^ 10011111b = 10111100b
-00100011b ^ 10100000b = 10000011b
-00100011b ^ 10100001b = 10000010b
-00100011b ^ 10100010b = 10000001b
-00100011b ^ 10100011b = 10000000b
-00100011b ^ 10100100b = 10000111b
-00100011b ^ 10100101b = 10000110b
-00100011b ^ 10100110b = 10000101b
-00100011b ^ 10100111b = 10000100b
-00100011b ^ 10101000b = 10001011b
-00100011b ^ 10101001b = 10001010b
-00100011b ^ 10101010b = 10001001b
-00100011b ^ 10101011b = 10001000b
-00100011b ^ 10101100b = 10001111b
-00100011b ^ 10101101b = 10001110b
-00100011b ^ 10101110b = 10001101b
-00100011b ^ 10101111b = 10001100b
-00100011b ^ 10110000b = 10010011b
-00100011b ^ 10110001b = 10010010b
-00100011b ^ 10110010b = 10010001b
-00100011b ^ 10110011b = 10010000b
-00100011b ^ 10110100b = 10010111b
-00100011b ^ 10110101b = 10010110b
-00100011b ^ 10110110b = 10010101b
-00100011b ^ 10110111b = 10010100b
-00100011b ^ 10111000b = 10011011b
-00100011b ^ 10111001b = 10011010b
-00100011b ^ 10111010b = 10011001b
-00100011b ^ 10111011b = 10011000b
-00100011b ^ 10111100b = 10011111b
-00100011b ^ 10111101b = 10011110b
-00100011b ^ 10111110b = 10011101b
-00100011b ^ 10111111b = 10011100b
-00100011b ^ 11000000b = 11100011b
-00100011b ^ 11000001b = 11100010b
-00100011b ^ 11000010b = 11100001b
-00100011b ^ 11000011b = 11100000b
-00100011b ^ 11000100b = 11100111b
-00100011b ^ 11000101b = 11100110b
-00100011b ^ 11000110b = 11100101b
-00100011b ^ 11000111b = 11100100b
-00100011b ^ 11001000b = 11101011b
-00100011b ^ 11001001b = 11101010b
-00100011b ^ 11001010b = 11101001b
-00100011b ^ 11001011b = 11101000b
-00100011b ^ 11001100b = 11101111b
-00100011b ^ 11001101b = 11101110b
-00100011b ^ 11001110b = 11101101b
-00100011b ^ 11001111b = 11101100b
-00100011b ^ 11010000b = 11110011b
-00100011b ^ 11010001b = 11110010b
-00100011b ^ 11010010b = 11110001b
-00100011b ^ 11010011b = 11110000b
-00100011b ^ 11010100b = 11110111b
-00100011b ^ 11010101b = 11110110b
-00100011b ^ 11010110b = 11110101b
-00100011b ^ 11010111b = 11110100b
-00100011b ^ 11011000b = 11111011b
-00100011b ^ 11011001b = 11111010b
-00100011b ^ 11011010b = 11111001b
-00100011b ^ 11011011b = 11111000b
-00100011b ^ 11011100b = 11111111b
-00100011b ^ 11011101b = 11111110b
-00100011b ^ 11011110b = 11111101b
-00100011b ^ 11011111b = 11111100b
-00100011b ^ 11100000b = 11000011b
-00100011b ^ 11100001b = 11000010b
-00100011b ^ 11100010b = 11000001b
-00100011b ^ 11100011b = 11000000b
-00100011b ^ 11100100b = 11000111b
-00100011b ^ 11100101b = 11000110b
-00100011b ^ 11100110b = 11000101b
-00100011b ^ 11100111b = 11000100b
-00100011b ^ 11101000b = 11001011b
-00100011b ^ 11101001b = 11001010b
-00100011b ^ 11101010b = 11001001b
-00100011b ^ 11101011b = 11001000b
-00100011b ^ 11101100b = 11001111b
-00100011b ^ 11101101b = 11001110b
-00100011b ^ 11101110b = 11001101b
-00100011b ^ 11101111b = 11001100b
-00100011b ^ 11110000b = 11010011b
-00100011b ^ 11110001b = 11010010b
-00100011b ^ 11110010b = 11010001b
-00100011b ^ 11110011b = 11010000b
-00100011b ^ 11110100b = 11010111b
-00100011b ^ 11110101b = 11010110b
-00100011b ^ 11110110b = 11010101b
-00100011b ^ 11110111b = 11010100b
-00100011b ^ 11111000b = 11011011b
-00100011b ^ 11111001b = 11011010b
-00100011b ^ 11111010b = 11011001b
-00100011b ^ 11111011b = 11011000b
-00100011b ^ 11111100b = 11011111b
-00100011b ^ 11111101b = 11011110b
-00100011b ^ 11111110b = 11011101b
-00100011b ^ 11111111b = 11011100b
-00100011b ^ 00000000b = 00100011b
-00100011b ^ 00000001b = 00100010b
-00100011b ^ 00000010b = 00100001b
-00100011b ^ 00000011b = 00100000b
-00100011b ^ 00000100b = 00100111b
-00100011b ^ 00000101b = 00100110b
-00100011b ^ 00000110b = 00100101b
-00100011b ^ 00000111b = 00100100b
-00100011b ^ 00001000b = 00101011b
-00100011b ^ 00001001b = 00101010b
-00100011b ^ 00001010b = 00101001b
-00100011b ^ 00001011b = 00101000b
-00100011b ^ 00001100b = 00101111b
-00100011b ^ 00001101b = 00101110b
-00100011b ^ 00001110b = 00101101b
-00100011b ^ 00001111b = 00101100b
-00100011b ^ 00010000b = 00110011b
-00100011b ^ 00010001b = 00110010b
-00100011b ^ 00010010b = 00110001b
-00100011b ^ 00010011b = 00110000b
-00100011b ^ 00010100b = 00110111b
-00100011b ^ 00010101b = 00110110b
-00100011b ^ 00010110b = 00110101b
-00100011b ^ 00010111b = 00110100b
-00100011b ^ 00011000b = 00111011b
-00100011b ^ 00011001b = 00111010b
-00100011b ^ 00011010b = 00111001b
-00100011b ^ 00011011b = 00111000b
-00100011b ^ 00011100b = 00111111b
-00100011b ^ 00011101b = 00111110b
-00100011b ^ 00011110b = 00111101b
-00100011b ^ 00011111b = 00111100b
-00100011b ^ 00100000b = 00000011b
-00100011b ^ 00100001b = 00000010b
-00100011b ^ 00100010b = 00000001b
-00100011b ^ 00100011b = 00000000b
-00100011b ^ 00100100b = 00000111b
-00100011b ^ 00100101b = 00000110b
-00100011b ^ 00100110b = 00000101b
-00100011b ^ 00100111b = 00000100b
-00100011b ^ 00101000b = 00001011b
-00100011b ^ 00101001b = 00001010b
-00100011b ^ 00101010b = 00001001b
-00100011b ^ 00101011b = 00001000b
-00100011b ^ 00101100b = 00001111b
-00100011b ^ 00101101b = 00001110b
-00100011b ^ 00101110b = 00001101b
-00100011b ^ 00101111b = 00001100b
-00100011b ^ 00110000b = 00010011b
-00100011b ^ 00110001b = 00010010b
-00100011b ^ 00110010b = 00010001b
-00100011b ^ 00110011b = 00010000b
-00100011b ^ 00110100b = 00010111b
-00100011b ^ 00110101b = 00010110b
-00100011b ^ 00110110b = 00010101b
-00100011b ^ 00110111b = 00010100b
-00100011b ^ 00111000b = 00011011b
-00100011b ^ 00111001b = 00011010b
-00100011b ^ 00111010b = 00011001b
-00100011b ^ 00111011b = 00011000b
-00100011b ^ 00111100b = 00011111b
-00100011b ^ 00111101b = 00011110b
-00100011b ^ 00111110b = 00011101b
-00100011b ^ 00111111b = 00011100b
-00100011b ^ 01000000b = 01100011b
-00100011b ^ 01000001b = 01100010b
-00100011b ^ 01000010b = 01100001b
-00100011b ^ 01000011b = 01100000b
-00100011b ^ 01000100b = 01100111b
-00100011b ^ 01000101b = 01100110b
-00100011b ^ 01000110b = 01100101b
-00100011b ^ 01000111b = 01100100b
-00100011b ^ 01001000b = 01101011b
-00100011b ^ 01001001b = 01101010b
-00100011b ^ 01001010b = 01101001b
-00100011b ^ 01001011b = 01101000b
-00100011b ^ 01001100b = 01101111b
-00100011b ^ 01001101b = 01101110b
-00100011b ^ 01001110b = 01101101b
-00100011b ^ 01001111b = 01101100b
-00100011b ^ 01010000b = 01110011b
-00100011b ^ 01010001b = 01110010b
-00100011b ^ 01010010b = 01110001b
-00100011b ^ 01010011b = 01110000b
-00100011b ^ 01010100b = 01110111b
-00100011b ^ 01010101b = 01110110b
-00100011b ^ 01010110b = 01110101b
-00100011b ^ 01010111b = 01110100b
-00100011b ^ 01011000b = 01111011b
-00100011b ^ 01011001b = 01111010b
-00100011b ^ 01011010b = 01111001b
-00100011b ^ 01011011b = 01111000b
-00100011b ^ 01011100b = 01111111b
-00100011b ^ 01011101b = 01111110b
-00100011b ^ 01011110b = 01111101b
-00100011b ^ 01011111b = 01111100b
-00100011b ^ 01100000b = 01000011b
-00100011b ^ 01100001b = 01000010b
-00100011b ^ 01100010b = 01000001b
-00100011b ^ 01100011b = 01000000b
-00100011b ^ 01100100b = 01000111b
-00100011b ^ 01100101b = 01000110b
-00100011b ^ 01100110b = 01000101b
-00100011b ^ 01100111b = 01000100b
-00100011b ^ 01101000b = 01001011b
-00100011b ^ 01101001b = 01001010b
-00100011b ^ 01101010b = 01001001b
-00100011b ^ 01101011b = 01001000b
-00100011b ^ 01101100b = 01001111b
-00100011b ^ 01101101b = 01001110b
-00100011b ^ 01101110b = 01001101b
-00100011b ^ 01101111b = 01001100b
-00100011b ^ 01110000b = 01010011b
-00100011b ^ 01110001b = 01010010b
-00100011b ^ 01110010b = 01010001b
-00100011b ^ 01110011b = 01010000b
-00100011b ^ 01110100b = 01010111b
-00100011b ^ 01110101b = 01010110b
-00100011b ^ 01110110b = 01010101b
-00100011b ^ 01110111b = 01010100b
-00100011b ^ 01111000b = 01011011b
-00100011b ^ 01111001b = 01011010b
-00100011b ^ 01111010b = 01011001b
-00100011b ^ 01111011b = 01011000b
-00100011b ^ 01111100b = 01011111b
-00100011b ^ 01111101b = 01011110b
-00100011b ^ 01111110b = 01011101b
-00100100b ^ 10000000b = 10100100b
-00100100b ^ 10000001b = 10100101b
-00100100b ^ 10000010b = 10100110b
-00100100b ^ 10000011b = 10100111b
-00100100b ^ 10000100b = 10100000b
-00100100b ^ 10000101b = 10100001b
-00100100b ^ 10000110b = 10100010b
-00100100b ^ 10000111b = 10100011b
-00100100b ^ 10001000b = 10101100b
-00100100b ^ 10001001b = 10101101b
-00100100b ^ 10001010b = 10101110b
-00100100b ^ 10001011b = 10101111b
-00100100b ^ 10001100b = 10101000b
-00100100b ^ 10001101b = 10101001b
-00100100b ^ 10001110b = 10101010b
-00100100b ^ 10001111b = 10101011b
-00100100b ^ 10010000b = 10110100b
-00100100b ^ 10010001b = 10110101b
-00100100b ^ 10010010b = 10110110b
-00100100b ^ 10010011b = 10110111b
-00100100b ^ 10010100b = 10110000b
-00100100b ^ 10010101b = 10110001b
-00100100b ^ 10010110b = 10110010b
-00100100b ^ 10010111b = 10110011b
-00100100b ^ 10011000b = 10111100b
-00100100b ^ 10011001b = 10111101b
-00100100b ^ 10011010b = 10111110b
-00100100b ^ 10011011b = 10111111b
-00100100b ^ 10011100b = 10111000b
-00100100b ^ 10011101b = 10111001b
-00100100b ^ 10011110b = 10111010b
-00100100b ^ 10011111b = 10111011b
-00100100b ^ 10100000b = 10000100b
-00100100b ^ 10100001b = 10000101b
-00100100b ^ 10100010b = 10000110b
-00100100b ^ 10100011b = 10000111b
-00100100b ^ 10100100b = 10000000b
-00100100b ^ 10100101b = 10000001b
-00100100b ^ 10100110b = 10000010b
-00100100b ^ 10100111b = 10000011b
-00100100b ^ 10101000b = 10001100b
-00100100b ^ 10101001b = 10001101b
-00100100b ^ 10101010b = 10001110b
-00100100b ^ 10101011b = 10001111b
-00100100b ^ 10101100b = 10001000b
-00100100b ^ 10101101b = 10001001b
-00100100b ^ 10101110b = 10001010b
-00100100b ^ 10101111b = 10001011b
-00100100b ^ 10110000b = 10010100b
-00100100b ^ 10110001b = 10010101b
-00100100b ^ 10110010b = 10010110b
-00100100b ^ 10110011b = 10010111b
-00100100b ^ 10110100b = 10010000b
-00100100b ^ 10110101b = 10010001b
-00100100b ^ 10110110b = 10010010b
-00100100b ^ 10110111b = 10010011b
-00100100b ^ 10111000b = 10011100b
-00100100b ^ 10111001b = 10011101b
-00100100b ^ 10111010b = 10011110b
-00100100b ^ 10111011b = 10011111b
-00100100b ^ 10111100b = 10011000b
-00100100b ^ 10111101b = 10011001b
-00100100b ^ 10111110b = 10011010b
-00100100b ^ 10111111b = 10011011b
-00100100b ^ 11000000b = 11100100b
-00100100b ^ 11000001b = 11100101b
-00100100b ^ 11000010b = 11100110b
-00100100b ^ 11000011b = 11100111b
-00100100b ^ 11000100b = 11100000b
-00100100b ^ 11000101b = 11100001b
-00100100b ^ 11000110b = 11100010b
-00100100b ^ 11000111b = 11100011b
-00100100b ^ 11001000b = 11101100b
-00100100b ^ 11001001b = 11101101b
-00100100b ^ 11001010b = 11101110b
-00100100b ^ 11001011b = 11101111b
-00100100b ^ 11001100b = 11101000b
-00100100b ^ 11001101b = 11101001b
-00100100b ^ 11001110b = 11101010b
-00100100b ^ 11001111b = 11101011b
-00100100b ^ 11010000b = 11110100b
-00100100b ^ 11010001b = 11110101b
-00100100b ^ 11010010b = 11110110b
-00100100b ^ 11010011b = 11110111b
-00100100b ^ 11010100b = 11110000b
-00100100b ^ 11010101b = 11110001b
-00100100b ^ 11010110b = 11110010b
-00100100b ^ 11010111b = 11110011b
-00100100b ^ 11011000b = 11111100b
-00100100b ^ 11011001b = 11111101b
-00100100b ^ 11011010b = 11111110b
-00100100b ^ 11011011b = 11111111b
-00100100b ^ 11011100b = 11111000b
-00100100b ^ 11011101b = 11111001b
-00100100b ^ 11011110b = 11111010b
-00100100b ^ 11011111b = 11111011b
-00100100b ^ 11100000b = 11000100b
-00100100b ^ 11100001b = 11000101b
-00100100b ^ 11100010b = 11000110b
-00100100b ^ 11100011b = 11000111b
-00100100b ^ 11100100b = 11000000b
-00100100b ^ 11100101b = 11000001b
-00100100b ^ 11100110b = 11000010b
-00100100b ^ 11100111b = 11000011b
-00100100b ^ 11101000b = 11001100b
-00100100b ^ 11101001b = 11001101b
-00100100b ^ 11101010b = 11001110b
-00100100b ^ 11101011b = 11001111b
-00100100b ^ 11101100b = 11001000b
-00100100b ^ 11101101b = 11001001b
-00100100b ^ 11101110b = 11001010b
-00100100b ^ 11101111b = 11001011b
-00100100b ^ 11110000b = 11010100b
-00100100b ^ 11110001b = 11010101b
-00100100b ^ 11110010b = 11010110b
-00100100b ^ 11110011b = 11010111b
-00100100b ^ 11110100b = 11010000b
-00100100b ^ 11110101b = 11010001b
-00100100b ^ 11110110b = 11010010b
-00100100b ^ 11110111b = 11010011b
-00100100b ^ 11111000b = 11011100b
-00100100b ^ 11111001b = 11011101b
-00100100b ^ 11111010b = 11011110b
-00100100b ^ 11111011b = 11011111b
-00100100b ^ 11111100b = 11011000b
-00100100b ^ 11111101b = 11011001b
-00100100b ^ 11111110b = 11011010b
-00100100b ^ 11111111b = 11011011b
-00100100b ^ 00000000b = 00100100b
-00100100b ^ 00000001b = 00100101b
-00100100b ^ 00000010b = 00100110b
-00100100b ^ 00000011b = 00100111b
-00100100b ^ 00000100b = 00100000b
-00100100b ^ 00000101b = 00100001b
-00100100b ^ 00000110b = 00100010b
-00100100b ^ 00000111b = 00100011b
-00100100b ^ 00001000b = 00101100b
-00100100b ^ 00001001b = 00101101b
-00100100b ^ 00001010b = 00101110b
-00100100b ^ 00001011b = 00101111b
-00100100b ^ 00001100b = 00101000b
-00100100b ^ 00001101b = 00101001b
-00100100b ^ 00001110b = 00101010b
-00100100b ^ 00001111b = 00101011b
-00100100b ^ 00010000b = 00110100b
-00100100b ^ 00010001b = 00110101b
-00100100b ^ 00010010b = 00110110b
-00100100b ^ 00010011b = 00110111b
-00100100b ^ 00010100b = 00110000b
-00100100b ^ 00010101b = 00110001b
-00100100b ^ 00010110b = 00110010b
-00100100b ^ 00010111b = 00110011b
-00100100b ^ 00011000b = 00111100b
-00100100b ^ 00011001b = 00111101b
-00100100b ^ 00011010b = 00111110b
-00100100b ^ 00011011b = 00111111b
-00100100b ^ 00011100b = 00111000b
-00100100b ^ 00011101b = 00111001b
-00100100b ^ 00011110b = 00111010b
-00100100b ^ 00011111b = 00111011b
-00100100b ^ 00100000b = 00000100b
-00100100b ^ 00100001b = 00000101b
-00100100b ^ 00100010b = 00000110b
-00100100b ^ 00100011b = 00000111b
-00100100b ^ 00100100b = 00000000b
-00100100b ^ 00100101b = 00000001b
-00100100b ^ 00100110b = 00000010b
-00100100b ^ 00100111b = 00000011b
-00100100b ^ 00101000b = 00001100b
-00100100b ^ 00101001b = 00001101b
-00100100b ^ 00101010b = 00001110b
-00100100b ^ 00101011b = 00001111b
-00100100b ^ 00101100b = 00001000b
-00100100b ^ 00101101b = 00001001b
-00100100b ^ 00101110b = 00001010b
-00100100b ^ 00101111b = 00001011b
-00100100b ^ 00110000b = 00010100b
-00100100b ^ 00110001b = 00010101b
-00100100b ^ 00110010b = 00010110b
-00100100b ^ 00110011b = 00010111b
-00100100b ^ 00110100b = 00010000b
-00100100b ^ 00110101b = 00010001b
-00100100b ^ 00110110b = 00010010b
-00100100b ^ 00110111b = 00010011b
-00100100b ^ 00111000b = 00011100b
-00100100b ^ 00111001b = 00011101b
-00100100b ^ 00111010b = 00011110b
-00100100b ^ 00111011b = 00011111b
-00100100b ^ 00111100b = 00011000b
-00100100b ^ 00111101b = 00011001b
-00100100b ^ 00111110b = 00011010b
-00100100b ^ 00111111b = 00011011b
-00100100b ^ 01000000b = 01100100b
-00100100b ^ 01000001b = 01100101b
-00100100b ^ 01000010b = 01100110b
-00100100b ^ 01000011b = 01100111b
-00100100b ^ 01000100b = 01100000b
-00100100b ^ 01000101b = 01100001b
-00100100b ^ 01000110b = 01100010b
-00100100b ^ 01000111b = 01100011b
-00100100b ^ 01001000b = 01101100b
-00100100b ^ 01001001b = 01101101b
-00100100b ^ 01001010b = 01101110b
-00100100b ^ 01001011b = 01101111b
-00100100b ^ 01001100b = 01101000b
-00100100b ^ 01001101b = 01101001b
-00100100b ^ 01001110b = 01101010b
-00100100b ^ 01001111b = 01101011b
-00100100b ^ 01010000b = 01110100b
-00100100b ^ 01010001b = 01110101b
-00100100b ^ 01010010b = 01110110b
-00100100b ^ 01010011b = 01110111b
-00100100b ^ 01010100b = 01110000b
-00100100b ^ 01010101b = 01110001b
-00100100b ^ 01010110b = 01110010b
-00100100b ^ 01010111b = 01110011b
-00100100b ^ 01011000b = 01111100b
-00100100b ^ 01011001b = 01111101b
-00100100b ^ 01011010b = 01111110b
-00100100b ^ 01011011b = 01111111b
-00100100b ^ 01011100b = 01111000b
-00100100b ^ 01011101b = 01111001b
-00100100b ^ 01011110b = 01111010b
-00100100b ^ 01011111b = 01111011b
-00100100b ^ 01100000b = 01000100b
-00100100b ^ 01100001b = 01000101b
-00100100b ^ 01100010b = 01000110b
-00100100b ^ 01100011b = 01000111b
-00100100b ^ 01100100b = 01000000b
-00100100b ^ 01100101b = 01000001b
-00100100b ^ 01100110b = 01000010b
-00100100b ^ 01100111b = 01000011b
-00100100b ^ 01101000b = 01001100b
-00100100b ^ 01101001b = 01001101b
-00100100b ^ 01101010b = 01001110b
-00100100b ^ 01101011b = 01001111b
-00100100b ^ 01101100b = 01001000b
-00100100b ^ 01101101b = 01001001b
-00100100b ^ 01101110b = 01001010b
-00100100b ^ 01101111b = 01001011b
-00100100b ^ 01110000b = 01010100b
-00100100b ^ 01110001b = 01010101b
-00100100b ^ 01110010b = 01010110b
-00100100b ^ 01110011b = 01010111b
-00100100b ^ 01110100b = 01010000b
-00100100b ^ 01110101b = 01010001b
-00100100b ^ 01110110b = 01010010b
-00100100b ^ 01110111b = 01010011b
-00100100b ^ 01111000b = 01011100b
-00100100b ^ 01111001b = 01011101b
-00100100b ^ 01111010b = 01011110b
-00100100b ^ 01111011b = 01011111b
-00100100b ^ 01111100b = 01011000b
-00100100b ^ 01111101b = 01011001b
-00100100b ^ 01111110b = 01011010b
-00100101b ^ 10000000b = 10100101b
-00100101b ^ 10000001b = 10100100b
-00100101b ^ 10000010b = 10100111b
-00100101b ^ 10000011b = 10100110b
-00100101b ^ 10000100b = 10100001b
-00100101b ^ 10000101b = 10100000b
-00100101b ^ 10000110b = 10100011b
-00100101b ^ 10000111b = 10100010b
-00100101b ^ 10001000b = 10101101b
-00100101b ^ 10001001b = 10101100b
-00100101b ^ 10001010b = 10101111b
-00100101b ^ 10001011b = 10101110b
-00100101b ^ 10001100b = 10101001b
-00100101b ^ 10001101b = 10101000b
-00100101b ^ 10001110b = 10101011b
-00100101b ^ 10001111b = 10101010b
-00100101b ^ 10010000b = 10110101b
-00100101b ^ 10010001b = 10110100b
-00100101b ^ 10010010b = 10110111b
-00100101b ^ 10010011b = 10110110b
-00100101b ^ 10010100b = 10110001b
-00100101b ^ 10010101b = 10110000b
-00100101b ^ 10010110b = 10110011b
-00100101b ^ 10010111b = 10110010b
-00100101b ^ 10011000b = 10111101b
-00100101b ^ 10011001b = 10111100b
-00100101b ^ 10011010b = 10111111b
-00100101b ^ 10011011b = 10111110b
-00100101b ^ 10011100b = 10111001b
-00100101b ^ 10011101b = 10111000b
-00100101b ^ 10011110b = 10111011b
-00100101b ^ 10011111b = 10111010b
-00100101b ^ 10100000b = 10000101b
-00100101b ^ 10100001b = 10000100b
-00100101b ^ 10100010b = 10000111b
-00100101b ^ 10100011b = 10000110b
-00100101b ^ 10100100b = 10000001b
-00100101b ^ 10100101b = 10000000b
-00100101b ^ 10100110b = 10000011b
-00100101b ^ 10100111b = 10000010b
-00100101b ^ 10101000b = 10001101b
-00100101b ^ 10101001b = 10001100b
-00100101b ^ 10101010b = 10001111b
-00100101b ^ 10101011b = 10001110b
-00100101b ^ 10101100b = 10001001b
-00100101b ^ 10101101b = 10001000b
-00100101b ^ 10101110b = 10001011b
-00100101b ^ 10101111b = 10001010b
-00100101b ^ 10110000b = 10010101b
-00100101b ^ 10110001b = 10010100b
-00100101b ^ 10110010b = 10010111b
-00100101b ^ 10110011b = 10010110b
-00100101b ^ 10110100b = 10010001b
-00100101b ^ 10110101b = 10010000b
-00100101b ^ 10110110b = 10010011b
-00100101b ^ 10110111b = 10010010b
-00100101b ^ 10111000b = 10011101b
-00100101b ^ 10111001b = 10011100b
-00100101b ^ 10111010b = 10011111b
-00100101b ^ 10111011b = 10011110b
-00100101b ^ 10111100b = 10011001b
-00100101b ^ 10111101b = 10011000b
-00100101b ^ 10111110b = 10011011b
-00100101b ^ 10111111b = 10011010b
-00100101b ^ 11000000b = 11100101b
-00100101b ^ 11000001b = 11100100b
-00100101b ^ 11000010b = 11100111b
-00100101b ^ 11000011b = 11100110b
-00100101b ^ 11000100b = 11100001b
-00100101b ^ 11000101b = 11100000b
-00100101b ^ 11000110b = 11100011b
-00100101b ^ 11000111b = 11100010b
-00100101b ^ 11001000b = 11101101b
-00100101b ^ 11001001b = 11101100b
-00100101b ^ 11001010b = 11101111b
-00100101b ^ 11001011b = 11101110b
-00100101b ^ 11001100b = 11101001b
-00100101b ^ 11001101b = 11101000b
-00100101b ^ 11001110b = 11101011b
-00100101b ^ 11001111b = 11101010b
-00100101b ^ 11010000b = 11110101b
-00100101b ^ 11010001b = 11110100b
-00100101b ^ 11010010b = 11110111b
-00100101b ^ 11010011b = 11110110b
-00100101b ^ 11010100b = 11110001b
-00100101b ^ 11010101b = 11110000b
-00100101b ^ 11010110b = 11110011b
-00100101b ^ 11010111b = 11110010b
-00100101b ^ 11011000b = 11111101b
-00100101b ^ 11011001b = 11111100b
-00100101b ^ 11011010b = 11111111b
-00100101b ^ 11011011b = 11111110b
-00100101b ^ 11011100b = 11111001b
-00100101b ^ 11011101b = 11111000b
-00100101b ^ 11011110b = 11111011b
-00100101b ^ 11011111b = 11111010b
-00100101b ^ 11100000b = 11000101b
-00100101b ^ 11100001b = 11000100b
-00100101b ^ 11100010b = 11000111b
-00100101b ^ 11100011b = 11000110b
-00100101b ^ 11100100b = 11000001b
-00100101b ^ 11100101b = 11000000b
-00100101b ^ 11100110b = 11000011b
-00100101b ^ 11100111b = 11000010b
-00100101b ^ 11101000b = 11001101b
-00100101b ^ 11101001b = 11001100b
-00100101b ^ 11101010b = 11001111b
-00100101b ^ 11101011b = 11001110b
-00100101b ^ 11101100b = 11001001b
-00100101b ^ 11101101b = 11001000b
-00100101b ^ 11101110b = 11001011b
-00100101b ^ 11101111b = 11001010b
-00100101b ^ 11110000b = 11010101b
-00100101b ^ 11110001b = 11010100b
-00100101b ^ 11110010b = 11010111b
-00100101b ^ 11110011b = 11010110b
-00100101b ^ 11110100b = 11010001b
-00100101b ^ 11110101b = 11010000b
-00100101b ^ 11110110b = 11010011b
-00100101b ^ 11110111b = 11010010b
-00100101b ^ 11111000b = 11011101b
-00100101b ^ 11111001b = 11011100b
-00100101b ^ 11111010b = 11011111b
-00100101b ^ 11111011b = 11011110b
-00100101b ^ 11111100b = 11011001b
-00100101b ^ 11111101b = 11011000b
-00100101b ^ 11111110b = 11011011b
-00100101b ^ 11111111b = 11011010b
-00100101b ^ 00000000b = 00100101b
-00100101b ^ 00000001b = 00100100b
-00100101b ^ 00000010b = 00100111b
-00100101b ^ 00000011b = 00100110b
-00100101b ^ 00000100b = 00100001b
-00100101b ^ 00000101b = 00100000b
-00100101b ^ 00000110b = 00100011b
-00100101b ^ 00000111b = 00100010b
-00100101b ^ 00001000b = 00101101b
-00100101b ^ 00001001b = 00101100b
-00100101b ^ 00001010b = 00101111b
-00100101b ^ 00001011b = 00101110b
-00100101b ^ 00001100b = 00101001b
-00100101b ^ 00001101b = 00101000b
-00100101b ^ 00001110b = 00101011b
-00100101b ^ 00001111b = 00101010b
-00100101b ^ 00010000b = 00110101b
-00100101b ^ 00010001b = 00110100b
-00100101b ^ 00010010b = 00110111b
-00100101b ^ 00010011b = 00110110b
-00100101b ^ 00010100b = 00110001b
-00100101b ^ 00010101b = 00110000b
-00100101b ^ 00010110b = 00110011b
-00100101b ^ 00010111b = 00110010b
-00100101b ^ 00011000b = 00111101b
-00100101b ^ 00011001b = 00111100b
-00100101b ^ 00011010b = 00111111b
-00100101b ^ 00011011b = 00111110b
-00100101b ^ 00011100b = 00111001b
-00100101b ^ 00011101b = 00111000b
-00100101b ^ 00011110b = 00111011b
-00100101b ^ 00011111b = 00111010b
-00100101b ^ 00100000b = 00000101b
-00100101b ^ 00100001b = 00000100b
-00100101b ^ 00100010b = 00000111b
-00100101b ^ 00100011b = 00000110b
-00100101b ^ 00100100b = 00000001b
-00100101b ^ 00100101b = 00000000b
-00100101b ^ 00100110b = 00000011b
-00100101b ^ 00100111b = 00000010b
-00100101b ^ 00101000b = 00001101b
-00100101b ^ 00101001b = 00001100b
-00100101b ^ 00101010b = 00001111b
-00100101b ^ 00101011b = 00001110b
-00100101b ^ 00101100b = 00001001b
-00100101b ^ 00101101b = 00001000b
-00100101b ^ 00101110b = 00001011b
-00100101b ^ 00101111b = 00001010b
-00100101b ^ 00110000b = 00010101b
-00100101b ^ 00110001b = 00010100b
-00100101b ^ 00110010b = 00010111b
-00100101b ^ 00110011b = 00010110b
-00100101b ^ 00110100b = 00010001b
-00100101b ^ 00110101b = 00010000b
-00100101b ^ 00110110b = 00010011b
-00100101b ^ 00110111b = 00010010b
-00100101b ^ 00111000b = 00011101b
-00100101b ^ 00111001b = 00011100b
-00100101b ^ 00111010b = 00011111b
-00100101b ^ 00111011b = 00011110b
-00100101b ^ 00111100b = 00011001b
-00100101b ^ 00111101b = 00011000b
-00100101b ^ 00111110b = 00011011b
-00100101b ^ 00111111b = 00011010b
-00100101b ^ 01000000b = 01100101b
-00100101b ^ 01000001b = 01100100b
-00100101b ^ 01000010b = 01100111b
-00100101b ^ 01000011b = 01100110b
-00100101b ^ 01000100b = 01100001b
-00100101b ^ 01000101b = 01100000b
-00100101b ^ 01000110b = 01100011b
-00100101b ^ 01000111b = 01100010b
-00100101b ^ 01001000b = 01101101b
-00100101b ^ 01001001b = 01101100b
-00100101b ^ 01001010b = 01101111b
-00100101b ^ 01001011b = 01101110b
-00100101b ^ 01001100b = 01101001b
-00100101b ^ 01001101b = 01101000b
-00100101b ^ 01001110b = 01101011b
-00100101b ^ 01001111b = 01101010b
-00100101b ^ 01010000b = 01110101b
-00100101b ^ 01010001b = 01110100b
-00100101b ^ 01010010b = 01110111b
-00100101b ^ 01010011b = 01110110b
-00100101b ^ 01010100b = 01110001b
-00100101b ^ 01010101b = 01110000b
-00100101b ^ 01010110b = 01110011b
-00100101b ^ 01010111b = 01110010b
-00100101b ^ 01011000b = 01111101b
-00100101b ^ 01011001b = 01111100b
-00100101b ^ 01011010b = 01111111b
-00100101b ^ 01011011b = 01111110b
-00100101b ^ 01011100b = 01111001b
-00100101b ^ 01011101b = 01111000b
-00100101b ^ 01011110b = 01111011b
-00100101b ^ 01011111b = 01111010b
-00100101b ^ 01100000b = 01000101b
-00100101b ^ 01100001b = 01000100b
-00100101b ^ 01100010b = 01000111b
-00100101b ^ 01100011b = 01000110b
-00100101b ^ 01100100b = 01000001b
-00100101b ^ 01100101b = 01000000b
-00100101b ^ 01100110b = 01000011b
-00100101b ^ 01100111b = 01000010b
-00100101b ^ 01101000b = 01001101b
-00100101b ^ 01101001b = 01001100b
-00100101b ^ 01101010b = 01001111b
-00100101b ^ 01101011b = 01001110b
-00100101b ^ 01101100b = 01001001b
-00100101b ^ 01101101b = 01001000b
-00100101b ^ 01101110b = 01001011b
-00100101b ^ 01101111b = 01001010b
-00100101b ^ 01110000b = 01010101b
-00100101b ^ 01110001b = 01010100b
-00100101b ^ 01110010b = 01010111b
-00100101b ^ 01110011b = 01010110b
-00100101b ^ 01110100b = 01010001b
-00100101b ^ 01110101b = 01010000b
-00100101b ^ 01110110b = 01010011b
-00100101b ^ 01110111b = 01010010b
-00100101b ^ 01111000b = 01011101b
-00100101b ^ 01111001b = 01011100b
-00100101b ^ 01111010b = 01011111b
-00100101b ^ 01111011b = 01011110b
-00100101b ^ 01111100b = 01011001b
-00100101b ^ 01111101b = 01011000b
-00100101b ^ 01111110b = 01011011b
-00100110b ^ 10000000b = 10100110b
-00100110b ^ 10000001b = 10100111b
-00100110b ^ 10000010b = 10100100b
-00100110b ^ 10000011b = 10100101b
-00100110b ^ 10000100b = 10100010b
-00100110b ^ 10000101b = 10100011b
-00100110b ^ 10000110b = 10100000b
-00100110b ^ 10000111b = 10100001b
-00100110b ^ 10001000b = 10101110b
-00100110b ^ 10001001b = 10101111b
-00100110b ^ 10001010b = 10101100b
-00100110b ^ 10001011b = 10101101b
-00100110b ^ 10001100b = 10101010b
-00100110b ^ 10001101b = 10101011b
-00100110b ^ 10001110b = 10101000b
-00100110b ^ 10001111b = 10101001b
-00100110b ^ 10010000b = 10110110b
-00100110b ^ 10010001b = 10110111b
-00100110b ^ 10010010b = 10110100b
-00100110b ^ 10010011b = 10110101b
-00100110b ^ 10010100b = 10110010b
-00100110b ^ 10010101b = 10110011b
-00100110b ^ 10010110b = 10110000b
-00100110b ^ 10010111b = 10110001b
-00100110b ^ 10011000b = 10111110b
-00100110b ^ 10011001b = 10111111b
-00100110b ^ 10011010b = 10111100b
-00100110b ^ 10011011b = 10111101b
-00100110b ^ 10011100b = 10111010b
-00100110b ^ 10011101b = 10111011b
-00100110b ^ 10011110b = 10111000b
-00100110b ^ 10011111b = 10111001b
-00100110b ^ 10100000b = 10000110b
-00100110b ^ 10100001b = 10000111b
-00100110b ^ 10100010b = 10000100b
-00100110b ^ 10100011b = 10000101b
-00100110b ^ 10100100b = 10000010b
-00100110b ^ 10100101b = 10000011b
-00100110b ^ 10100110b = 10000000b
-00100110b ^ 10100111b = 10000001b
-00100110b ^ 10101000b = 10001110b
-00100110b ^ 10101001b = 10001111b
-00100110b ^ 10101010b = 10001100b
-00100110b ^ 10101011b = 10001101b
-00100110b ^ 10101100b = 10001010b
-00100110b ^ 10101101b = 10001011b
-00100110b ^ 10101110b = 10001000b
-00100110b ^ 10101111b = 10001001b
-00100110b ^ 10110000b = 10010110b
-00100110b ^ 10110001b = 10010111b
-00100110b ^ 10110010b = 10010100b
-00100110b ^ 10110011b = 10010101b
-00100110b ^ 10110100b = 10010010b
-00100110b ^ 10110101b = 10010011b
-00100110b ^ 10110110b = 10010000b
-00100110b ^ 10110111b = 10010001b
-00100110b ^ 10111000b = 10011110b
-00100110b ^ 10111001b = 10011111b
-00100110b ^ 10111010b = 10011100b
-00100110b ^ 10111011b = 10011101b
-00100110b ^ 10111100b = 10011010b
-00100110b ^ 10111101b = 10011011b
-00100110b ^ 10111110b = 10011000b
-00100110b ^ 10111111b = 10011001b
-00100110b ^ 11000000b = 11100110b
-00100110b ^ 11000001b = 11100111b
-00100110b ^ 11000010b = 11100100b
-00100110b ^ 11000011b = 11100101b
-00100110b ^ 11000100b = 11100010b
-00100110b ^ 11000101b = 11100011b
-00100110b ^ 11000110b = 11100000b
-00100110b ^ 11000111b = 11100001b
-00100110b ^ 11001000b = 11101110b
-00100110b ^ 11001001b = 11101111b
-00100110b ^ 11001010b = 11101100b
-00100110b ^ 11001011b = 11101101b
-00100110b ^ 11001100b = 11101010b
-00100110b ^ 11001101b = 11101011b
-00100110b ^ 11001110b = 11101000b
-00100110b ^ 11001111b = 11101001b
-00100110b ^ 11010000b = 11110110b
-00100110b ^ 11010001b = 11110111b
-00100110b ^ 11010010b = 11110100b
-00100110b ^ 11010011b = 11110101b
-00100110b ^ 11010100b = 11110010b
-00100110b ^ 11010101b = 11110011b
-00100110b ^ 11010110b = 11110000b
-00100110b ^ 11010111b = 11110001b
-00100110b ^ 11011000b = 11111110b
-00100110b ^ 11011001b = 11111111b
-00100110b ^ 11011010b = 11111100b
-00100110b ^ 11011011b = 11111101b
-00100110b ^ 11011100b = 11111010b
-00100110b ^ 11011101b = 11111011b
-00100110b ^ 11011110b = 11111000b
-00100110b ^ 11011111b = 11111001b
-00100110b ^ 11100000b = 11000110b
-00100110b ^ 11100001b = 11000111b
-00100110b ^ 11100010b = 11000100b
-00100110b ^ 11100011b = 11000101b
-00100110b ^ 11100100b = 11000010b
-00100110b ^ 11100101b = 11000011b
-00100110b ^ 11100110b = 11000000b
-00100110b ^ 11100111b = 11000001b
-00100110b ^ 11101000b = 11001110b
-00100110b ^ 11101001b = 11001111b
-00100110b ^ 11101010b = 11001100b
-00100110b ^ 11101011b = 11001101b
-00100110b ^ 11101100b = 11001010b
-00100110b ^ 11101101b = 11001011b
-00100110b ^ 11101110b = 11001000b
-00100110b ^ 11101111b = 11001001b
-00100110b ^ 11110000b = 11010110b
-00100110b ^ 11110001b = 11010111b
-00100110b ^ 11110010b = 11010100b
-00100110b ^ 11110011b = 11010101b
-00100110b ^ 11110100b = 11010010b
-00100110b ^ 11110101b = 11010011b
-00100110b ^ 11110110b = 11010000b
-00100110b ^ 11110111b = 11010001b
-00100110b ^ 11111000b = 11011110b
-00100110b ^ 11111001b = 11011111b
-00100110b ^ 11111010b = 11011100b
-00100110b ^ 11111011b = 11011101b
-00100110b ^ 11111100b = 11011010b
-00100110b ^ 11111101b = 11011011b
-00100110b ^ 11111110b = 11011000b
-00100110b ^ 11111111b = 11011001b
-00100110b ^ 00000000b = 00100110b
-00100110b ^ 00000001b = 00100111b
-00100110b ^ 00000010b = 00100100b
-00100110b ^ 00000011b = 00100101b
-00100110b ^ 00000100b = 00100010b
-00100110b ^ 00000101b = 00100011b
-00100110b ^ 00000110b = 00100000b
-00100110b ^ 00000111b = 00100001b
-00100110b ^ 00001000b = 00101110b
-00100110b ^ 00001001b = 00101111b
-00100110b ^ 00001010b = 00101100b
-00100110b ^ 00001011b = 00101101b
-00100110b ^ 00001100b = 00101010b
-00100110b ^ 00001101b = 00101011b
-00100110b ^ 00001110b = 00101000b
-00100110b ^ 00001111b = 00101001b
-00100110b ^ 00010000b = 00110110b
-00100110b ^ 00010001b = 00110111b
-00100110b ^ 00010010b = 00110100b
-00100110b ^ 00010011b = 00110101b
-00100110b ^ 00010100b = 00110010b
-00100110b ^ 00010101b = 00110011b
-00100110b ^ 00010110b = 00110000b
-00100110b ^ 00010111b = 00110001b
-00100110b ^ 00011000b = 00111110b
-00100110b ^ 00011001b = 00111111b
-00100110b ^ 00011010b = 00111100b
-00100110b ^ 00011011b = 00111101b
-00100110b ^ 00011100b = 00111010b
-00100110b ^ 00011101b = 00111011b
-00100110b ^ 00011110b = 00111000b
-00100110b ^ 00011111b = 00111001b
-00100110b ^ 00100000b = 00000110b
-00100110b ^ 00100001b = 00000111b
-00100110b ^ 00100010b = 00000100b
-00100110b ^ 00100011b = 00000101b
-00100110b ^ 00100100b = 00000010b
-00100110b ^ 00100101b = 00000011b
-00100110b ^ 00100110b = 00000000b
-00100110b ^ 00100111b = 00000001b
-00100110b ^ 00101000b = 00001110b
-00100110b ^ 00101001b = 00001111b
-00100110b ^ 00101010b = 00001100b
-00100110b ^ 00101011b = 00001101b
-00100110b ^ 00101100b = 00001010b
-00100110b ^ 00101101b = 00001011b
-00100110b ^ 00101110b = 00001000b
-00100110b ^ 00101111b = 00001001b
-00100110b ^ 00110000b = 00010110b
-00100110b ^ 00110001b = 00010111b
-00100110b ^ 00110010b = 00010100b
-00100110b ^ 00110011b = 00010101b
-00100110b ^ 00110100b = 00010010b
-00100110b ^ 00110101b = 00010011b
-00100110b ^ 00110110b = 00010000b
-00100110b ^ 00110111b = 00010001b
-00100110b ^ 00111000b = 00011110b
-00100110b ^ 00111001b = 00011111b
-00100110b ^ 00111010b = 00011100b
-00100110b ^ 00111011b = 00011101b
-00100110b ^ 00111100b = 00011010b
-00100110b ^ 00111101b = 00011011b
-00100110b ^ 00111110b = 00011000b
-00100110b ^ 00111111b = 00011001b
-00100110b ^ 01000000b = 01100110b
-00100110b ^ 01000001b = 01100111b
-00100110b ^ 01000010b = 01100100b
-00100110b ^ 01000011b = 01100101b
-00100110b ^ 01000100b = 01100010b
-00100110b ^ 01000101b = 01100011b
-00100110b ^ 01000110b = 01100000b
-00100110b ^ 01000111b = 01100001b
-00100110b ^ 01001000b = 01101110b
-00100110b ^ 01001001b = 01101111b
-00100110b ^ 01001010b = 01101100b
-00100110b ^ 01001011b = 01101101b
-00100110b ^ 01001100b = 01101010b
-00100110b ^ 01001101b = 01101011b
-00100110b ^ 01001110b = 01101000b
-00100110b ^ 01001111b = 01101001b
-00100110b ^ 01010000b = 01110110b
-00100110b ^ 01010001b = 01110111b
-00100110b ^ 01010010b = 01110100b
-00100110b ^ 01010011b = 01110101b
-00100110b ^ 01010100b = 01110010b
-00100110b ^ 01010101b = 01110011b
-00100110b ^ 01010110b = 01110000b
-00100110b ^ 01010111b = 01110001b
-00100110b ^ 01011000b = 01111110b
-00100110b ^ 01011001b = 01111111b
-00100110b ^ 01011010b = 01111100b
-00100110b ^ 01011011b = 01111101b
-00100110b ^ 01011100b = 01111010b
-00100110b ^ 01011101b = 01111011b
-00100110b ^ 01011110b = 01111000b
-00100110b ^ 01011111b = 01111001b
-00100110b ^ 01100000b = 01000110b
-00100110b ^ 01100001b = 01000111b
-00100110b ^ 01100010b = 01000100b
-00100110b ^ 01100011b = 01000101b
-00100110b ^ 01100100b = 01000010b
-00100110b ^ 01100101b = 01000011b
-00100110b ^ 01100110b = 01000000b
-00100110b ^ 01100111b = 01000001b
-00100110b ^ 01101000b = 01001110b
-00100110b ^ 01101001b = 01001111b
-00100110b ^ 01101010b = 01001100b
-00100110b ^ 01101011b = 01001101b
-00100110b ^ 01101100b = 01001010b
-00100110b ^ 01101101b = 01001011b
-00100110b ^ 01101110b = 01001000b
-00100110b ^ 01101111b = 01001001b
-00100110b ^ 01110000b = 01010110b
-00100110b ^ 01110001b = 01010111b
-00100110b ^ 01110010b = 01010100b
-00100110b ^ 01110011b = 01010101b
-00100110b ^ 01110100b = 01010010b
-00100110b ^ 01110101b = 01010011b
-00100110b ^ 01110110b = 01010000b
-00100110b ^ 01110111b = 01010001b
-00100110b ^ 01111000b = 01011110b
-00100110b ^ 01111001b = 01011111b
-00100110b ^ 01111010b = 01011100b
-00100110b ^ 01111011b = 01011101b
-00100110b ^ 01111100b = 01011010b
-00100110b ^ 01111101b = 01011011b
-00100110b ^ 01111110b = 01011000b
-00100111b ^ 10000000b = 10100111b
-00100111b ^ 10000001b = 10100110b
-00100111b ^ 10000010b = 10100101b
-00100111b ^ 10000011b = 10100100b
-00100111b ^ 10000100b = 10100011b
-00100111b ^ 10000101b = 10100010b
-00100111b ^ 10000110b = 10100001b
-00100111b ^ 10000111b = 10100000b
-00100111b ^ 10001000b = 10101111b
-00100111b ^ 10001001b = 10101110b
-00100111b ^ 10001010b = 10101101b
-00100111b ^ 10001011b = 10101100b
-00100111b ^ 10001100b = 10101011b
-00100111b ^ 10001101b = 10101010b
-00100111b ^ 10001110b = 10101001b
-00100111b ^ 10001111b = 10101000b
-00100111b ^ 10010000b = 10110111b
-00100111b ^ 10010001b = 10110110b
-00100111b ^ 10010010b = 10110101b
-00100111b ^ 10010011b = 10110100b
-00100111b ^ 10010100b = 10110011b
-00100111b ^ 10010101b = 10110010b
-00100111b ^ 10010110b = 10110001b
-00100111b ^ 10010111b = 10110000b
-00100111b ^ 10011000b = 10111111b
-00100111b ^ 10011001b = 10111110b
-00100111b ^ 10011010b = 10111101b
-00100111b ^ 10011011b = 10111100b
-00100111b ^ 10011100b = 10111011b
-00100111b ^ 10011101b = 10111010b
-00100111b ^ 10011110b = 10111001b
-00100111b ^ 10011111b = 10111000b
-00100111b ^ 10100000b = 10000111b
-00100111b ^ 10100001b = 10000110b
-00100111b ^ 10100010b = 10000101b
-00100111b ^ 10100011b = 10000100b
-00100111b ^ 10100100b = 10000011b
-00100111b ^ 10100101b = 10000010b
-00100111b ^ 10100110b = 10000001b
-00100111b ^ 10100111b = 10000000b
-00100111b ^ 10101000b = 10001111b
-00100111b ^ 10101001b = 10001110b
-00100111b ^ 10101010b = 10001101b
-00100111b ^ 10101011b = 10001100b
-00100111b ^ 10101100b = 10001011b
-00100111b ^ 10101101b = 10001010b
-00100111b ^ 10101110b = 10001001b
-00100111b ^ 10101111b = 10001000b
-00100111b ^ 10110000b = 10010111b
-00100111b ^ 10110001b = 10010110b
-00100111b ^ 10110010b = 10010101b
-00100111b ^ 10110011b = 10010100b
-00100111b ^ 10110100b = 10010011b
-00100111b ^ 10110101b = 10010010b
-00100111b ^ 10110110b = 10010001b
-00100111b ^ 10110111b = 10010000b
-00100111b ^ 10111000b = 10011111b
-00100111b ^ 10111001b = 10011110b
-00100111b ^ 10111010b = 10011101b
-00100111b ^ 10111011b = 10011100b
-00100111b ^ 10111100b = 10011011b
-00100111b ^ 10111101b = 10011010b
-00100111b ^ 10111110b = 10011001b
-00100111b ^ 10111111b = 10011000b
-00100111b ^ 11000000b = 11100111b
-00100111b ^ 11000001b = 11100110b
-00100111b ^ 11000010b = 11100101b
-00100111b ^ 11000011b = 11100100b
-00100111b ^ 11000100b = 11100011b
-00100111b ^ 11000101b = 11100010b
-00100111b ^ 11000110b = 11100001b
-00100111b ^ 11000111b = 11100000b
-00100111b ^ 11001000b = 11101111b
-00100111b ^ 11001001b = 11101110b
-00100111b ^ 11001010b = 11101101b
-00100111b ^ 11001011b = 11101100b
-00100111b ^ 11001100b = 11101011b
-00100111b ^ 11001101b = 11101010b
-00100111b ^ 11001110b = 11101001b
-00100111b ^ 11001111b = 11101000b
-00100111b ^ 11010000b = 11110111b
-00100111b ^ 11010001b = 11110110b
-00100111b ^ 11010010b = 11110101b
-00100111b ^ 11010011b = 11110100b
-00100111b ^ 11010100b = 11110011b
-00100111b ^ 11010101b = 11110010b
-00100111b ^ 11010110b = 11110001b
-00100111b ^ 11010111b = 11110000b
-00100111b ^ 11011000b = 11111111b
-00100111b ^ 11011001b = 11111110b
-00100111b ^ 11011010b = 11111101b
-00100111b ^ 11011011b = 11111100b
-00100111b ^ 11011100b = 11111011b
-00100111b ^ 11011101b = 11111010b
-00100111b ^ 11011110b = 11111001b
-00100111b ^ 11011111b = 11111000b
-00100111b ^ 11100000b = 11000111b
-00100111b ^ 11100001b = 11000110b
-00100111b ^ 11100010b = 11000101b
-00100111b ^ 11100011b = 11000100b
-00100111b ^ 11100100b = 11000011b
-00100111b ^ 11100101b = 11000010b
-00100111b ^ 11100110b = 11000001b
-00100111b ^ 11100111b = 11000000b
-00100111b ^ 11101000b = 11001111b
-00100111b ^ 11101001b = 11001110b
-00100111b ^ 11101010b = 11001101b
-00100111b ^ 11101011b = 11001100b
-00100111b ^ 11101100b = 11001011b
-00100111b ^ 11101101b = 11001010b
-00100111b ^ 11101110b = 11001001b
-00100111b ^ 11101111b = 11001000b
-00100111b ^ 11110000b = 11010111b
-00100111b ^ 11110001b = 11010110b
-00100111b ^ 11110010b = 11010101b
-00100111b ^ 11110011b = 11010100b
-00100111b ^ 11110100b = 11010011b
-00100111b ^ 11110101b = 11010010b
-00100111b ^ 11110110b = 11010001b
-00100111b ^ 11110111b = 11010000b
-00100111b ^ 11111000b = 11011111b
-00100111b ^ 11111001b = 11011110b
-00100111b ^ 11111010b = 11011101b
-00100111b ^ 11111011b = 11011100b
-00100111b ^ 11111100b = 11011011b
-00100111b ^ 11111101b = 11011010b
-00100111b ^ 11111110b = 11011001b
-00100111b ^ 11111111b = 11011000b
-00100111b ^ 00000000b = 00100111b
-00100111b ^ 00000001b = 00100110b
-00100111b ^ 00000010b = 00100101b
-00100111b ^ 00000011b = 00100100b
-00100111b ^ 00000100b = 00100011b
-00100111b ^ 00000101b = 00100010b
-00100111b ^ 00000110b = 00100001b
-00100111b ^ 00000111b = 00100000b
-00100111b ^ 00001000b = 00101111b
-00100111b ^ 00001001b = 00101110b
-00100111b ^ 00001010b = 00101101b
-00100111b ^ 00001011b = 00101100b
-00100111b ^ 00001100b = 00101011b
-00100111b ^ 00001101b = 00101010b
-00100111b ^ 00001110b = 00101001b
-00100111b ^ 00001111b = 00101000b
-00100111b ^ 00010000b = 00110111b
-00100111b ^ 00010001b = 00110110b
-00100111b ^ 00010010b = 00110101b
-00100111b ^ 00010011b = 00110100b
-00100111b ^ 00010100b = 00110011b
-00100111b ^ 00010101b = 00110010b
-00100111b ^ 00010110b = 00110001b
-00100111b ^ 00010111b = 00110000b
-00100111b ^ 00011000b = 00111111b
-00100111b ^ 00011001b = 00111110b
-00100111b ^ 00011010b = 00111101b
-00100111b ^ 00011011b = 00111100b
-00100111b ^ 00011100b = 00111011b
-00100111b ^ 00011101b = 00111010b
-00100111b ^ 00011110b = 00111001b
-00100111b ^ 00011111b = 00111000b
-00100111b ^ 00100000b = 00000111b
-00100111b ^ 00100001b = 00000110b
-00100111b ^ 00100010b = 00000101b
-00100111b ^ 00100011b = 00000100b
-00100111b ^ 00100100b = 00000011b
-00100111b ^ 00100101b = 00000010b
-00100111b ^ 00100110b = 00000001b
-00100111b ^ 00100111b = 00000000b
-00100111b ^ 00101000b = 00001111b
-00100111b ^ 00101001b = 00001110b
-00100111b ^ 00101010b = 00001101b
-00100111b ^ 00101011b = 00001100b
-00100111b ^ 00101100b = 00001011b
-00100111b ^ 00101101b = 00001010b
-00100111b ^ 00101110b = 00001001b
-00100111b ^ 00101111b = 00001000b
-00100111b ^ 00110000b = 00010111b
-00100111b ^ 00110001b = 00010110b
-00100111b ^ 00110010b = 00010101b
-00100111b ^ 00110011b = 00010100b
-00100111b ^ 00110100b = 00010011b
-00100111b ^ 00110101b = 00010010b
-00100111b ^ 00110110b = 00010001b
-00100111b ^ 00110111b = 00010000b
-00100111b ^ 00111000b = 00011111b
-00100111b ^ 00111001b = 00011110b
-00100111b ^ 00111010b = 00011101b
-00100111b ^ 00111011b = 00011100b
-00100111b ^ 00111100b = 00011011b
-00100111b ^ 00111101b = 00011010b
-00100111b ^ 00111110b = 00011001b
-00100111b ^ 00111111b = 00011000b
-00100111b ^ 01000000b = 01100111b
-00100111b ^ 01000001b = 01100110b
-00100111b ^ 01000010b = 01100101b
-00100111b ^ 01000011b = 01100100b
-00100111b ^ 01000100b = 01100011b
-00100111b ^ 01000101b = 01100010b
-00100111b ^ 01000110b = 01100001b
-00100111b ^ 01000111b = 01100000b
-00100111b ^ 01001000b = 01101111b
-00100111b ^ 01001001b = 01101110b
-00100111b ^ 01001010b = 01101101b
-00100111b ^ 01001011b = 01101100b
-00100111b ^ 01001100b = 01101011b
-00100111b ^ 01001101b = 01101010b
-00100111b ^ 01001110b = 01101001b
-00100111b ^ 01001111b = 01101000b
-00100111b ^ 01010000b = 01110111b
-00100111b ^ 01010001b = 01110110b
-00100111b ^ 01010010b = 01110101b
-00100111b ^ 01010011b = 01110100b
-00100111b ^ 01010100b = 01110011b
-00100111b ^ 01010101b = 01110010b
-00100111b ^ 01010110b = 01110001b
-00100111b ^ 01010111b = 01110000b
-00100111b ^ 01011000b = 01111111b
-00100111b ^ 01011001b = 01111110b
-00100111b ^ 01011010b = 01111101b
-00100111b ^ 01011011b = 01111100b
-00100111b ^ 01011100b = 01111011b
-00100111b ^ 01011101b = 01111010b
-00100111b ^ 01011110b = 01111001b
-00100111b ^ 01011111b = 01111000b
-00100111b ^ 01100000b = 01000111b
-00100111b ^ 01100001b = 01000110b
-00100111b ^ 01100010b = 01000101b
-00100111b ^ 01100011b = 01000100b
-00100111b ^ 01100100b = 01000011b
-00100111b ^ 01100101b = 01000010b
-00100111b ^ 01100110b = 01000001b
-00100111b ^ 01100111b = 01000000b
-00100111b ^ 01101000b = 01001111b
-00100111b ^ 01101001b = 01001110b
-00100111b ^ 01101010b = 01001101b
-00100111b ^ 01101011b = 01001100b
-00100111b ^ 01101100b = 01001011b
-00100111b ^ 01101101b = 01001010b
-00100111b ^ 01101110b = 01001001b
-00100111b ^ 01101111b = 01001000b
-00100111b ^ 01110000b = 01010111b
-00100111b ^ 01110001b = 01010110b
-00100111b ^ 01110010b = 01010101b
-00100111b ^ 01110011b = 01010100b
-00100111b ^ 01110100b = 01010011b
-00100111b ^ 01110101b = 01010010b
-00100111b ^ 01110110b = 01010001b
-00100111b ^ 01110111b = 01010000b
-00100111b ^ 01111000b = 01011111b
-00100111b ^ 01111001b = 01011110b
-00100111b ^ 01111010b = 01011101b
-00100111b ^ 01111011b = 01011100b
-00100111b ^ 01111100b = 01011011b
-00100111b ^ 01111101b = 01011010b
-00100111b ^ 01111110b = 01011001b
-00101000b ^ 10000000b = 10101000b
-00101000b ^ 10000001b = 10101001b
-00101000b ^ 10000010b = 10101010b
-00101000b ^ 10000011b = 10101011b
-00101000b ^ 10000100b = 10101100b
-00101000b ^ 10000101b = 10101101b
-00101000b ^ 10000110b = 10101110b
-00101000b ^ 10000111b = 10101111b
-00101000b ^ 10001000b = 10100000b
-00101000b ^ 10001001b = 10100001b
-00101000b ^ 10001010b = 10100010b
-00101000b ^ 10001011b = 10100011b
-00101000b ^ 10001100b = 10100100b
-00101000b ^ 10001101b = 10100101b
-00101000b ^ 10001110b = 10100110b
-00101000b ^ 10001111b = 10100111b
-00101000b ^ 10010000b = 10111000b
-00101000b ^ 10010001b = 10111001b
-00101000b ^ 10010010b = 10111010b
-00101000b ^ 10010011b = 10111011b
-00101000b ^ 10010100b = 10111100b
-00101000b ^ 10010101b = 10111101b
-00101000b ^ 10010110b = 10111110b
-00101000b ^ 10010111b = 10111111b
-00101000b ^ 10011000b = 10110000b
-00101000b ^ 10011001b = 10110001b
-00101000b ^ 10011010b = 10110010b
-00101000b ^ 10011011b = 10110011b
-00101000b ^ 10011100b = 10110100b
-00101000b ^ 10011101b = 10110101b
-00101000b ^ 10011110b = 10110110b
-00101000b ^ 10011111b = 10110111b
-00101000b ^ 10100000b = 10001000b
-00101000b ^ 10100001b = 10001001b
-00101000b ^ 10100010b = 10001010b
-00101000b ^ 10100011b = 10001011b
-00101000b ^ 10100100b = 10001100b
-00101000b ^ 10100101b = 10001101b
-00101000b ^ 10100110b = 10001110b
-00101000b ^ 10100111b = 10001111b
-00101000b ^ 10101000b = 10000000b
-00101000b ^ 10101001b = 10000001b
-00101000b ^ 10101010b = 10000010b
-00101000b ^ 10101011b = 10000011b
-00101000b ^ 10101100b = 10000100b
-00101000b ^ 10101101b = 10000101b
-00101000b ^ 10101110b = 10000110b
-00101000b ^ 10101111b = 10000111b
-00101000b ^ 10110000b = 10011000b
-00101000b ^ 10110001b = 10011001b
-00101000b ^ 10110010b = 10011010b
-00101000b ^ 10110011b = 10011011b
-00101000b ^ 10110100b = 10011100b
-00101000b ^ 10110101b = 10011101b
-00101000b ^ 10110110b = 10011110b
-00101000b ^ 10110111b = 10011111b
-00101000b ^ 10111000b = 10010000b
-00101000b ^ 10111001b = 10010001b
-00101000b ^ 10111010b = 10010010b
-00101000b ^ 10111011b = 10010011b
-00101000b ^ 10111100b = 10010100b
-00101000b ^ 10111101b = 10010101b
-00101000b ^ 10111110b = 10010110b
-00101000b ^ 10111111b = 10010111b
-00101000b ^ 11000000b = 11101000b
-00101000b ^ 11000001b = 11101001b
-00101000b ^ 11000010b = 11101010b
-00101000b ^ 11000011b = 11101011b
-00101000b ^ 11000100b = 11101100b
-00101000b ^ 11000101b = 11101101b
-00101000b ^ 11000110b = 11101110b
-00101000b ^ 11000111b = 11101111b
-00101000b ^ 11001000b = 11100000b
-00101000b ^ 11001001b = 11100001b
-00101000b ^ 11001010b = 11100010b
-00101000b ^ 11001011b = 11100011b
-00101000b ^ 11001100b = 11100100b
-00101000b ^ 11001101b = 11100101b
-00101000b ^ 11001110b = 11100110b
-00101000b ^ 11001111b = 11100111b
-00101000b ^ 11010000b = 11111000b
-00101000b ^ 11010001b = 11111001b
-00101000b ^ 11010010b = 11111010b
-00101000b ^ 11010011b = 11111011b
-00101000b ^ 11010100b = 11111100b
-00101000b ^ 11010101b = 11111101b
-00101000b ^ 11010110b = 11111110b
-00101000b ^ 11010111b = 11111111b
-00101000b ^ 11011000b = 11110000b
-00101000b ^ 11011001b = 11110001b
-00101000b ^ 11011010b = 11110010b
-00101000b ^ 11011011b = 11110011b
-00101000b ^ 11011100b = 11110100b
-00101000b ^ 11011101b = 11110101b
-00101000b ^ 11011110b = 11110110b
-00101000b ^ 11011111b = 11110111b
-00101000b ^ 11100000b = 11001000b
-00101000b ^ 11100001b = 11001001b
-00101000b ^ 11100010b = 11001010b
-00101000b ^ 11100011b = 11001011b
-00101000b ^ 11100100b = 11001100b
-00101000b ^ 11100101b = 11001101b
-00101000b ^ 11100110b = 11001110b
-00101000b ^ 11100111b = 11001111b
-00101000b ^ 11101000b = 11000000b
-00101000b ^ 11101001b = 11000001b
-00101000b ^ 11101010b = 11000010b
-00101000b ^ 11101011b = 11000011b
-00101000b ^ 11101100b = 11000100b
-00101000b ^ 11101101b = 11000101b
-00101000b ^ 11101110b = 11000110b
-00101000b ^ 11101111b = 11000111b
-00101000b ^ 11110000b = 11011000b
-00101000b ^ 11110001b = 11011001b
-00101000b ^ 11110010b = 11011010b
-00101000b ^ 11110011b = 11011011b
-00101000b ^ 11110100b = 11011100b
-00101000b ^ 11110101b = 11011101b
-00101000b ^ 11110110b = 11011110b
-00101000b ^ 11110111b = 11011111b
-00101000b ^ 11111000b = 11010000b
-00101000b ^ 11111001b = 11010001b
-00101000b ^ 11111010b = 11010010b
-00101000b ^ 11111011b = 11010011b
-00101000b ^ 11111100b = 11010100b
-00101000b ^ 11111101b = 11010101b
-00101000b ^ 11111110b = 11010110b
-00101000b ^ 11111111b = 11010111b
-00101000b ^ 00000000b = 00101000b
-00101000b ^ 00000001b = 00101001b
-00101000b ^ 00000010b = 00101010b
-00101000b ^ 00000011b = 00101011b
-00101000b ^ 00000100b = 00101100b
-00101000b ^ 00000101b = 00101101b
-00101000b ^ 00000110b = 00101110b
-00101000b ^ 00000111b = 00101111b
-00101000b ^ 00001000b = 00100000b
-00101000b ^ 00001001b = 00100001b
-00101000b ^ 00001010b = 00100010b
-00101000b ^ 00001011b = 00100011b
-00101000b ^ 00001100b = 00100100b
-00101000b ^ 00001101b = 00100101b
-00101000b ^ 00001110b = 00100110b
-00101000b ^ 00001111b = 00100111b
-00101000b ^ 00010000b = 00111000b
-00101000b ^ 00010001b = 00111001b
-00101000b ^ 00010010b = 00111010b
-00101000b ^ 00010011b = 00111011b
-00101000b ^ 00010100b = 00111100b
-00101000b ^ 00010101b = 00111101b
-00101000b ^ 00010110b = 00111110b
-00101000b ^ 00010111b = 00111111b
-00101000b ^ 00011000b = 00110000b
-00101000b ^ 00011001b = 00110001b
-00101000b ^ 00011010b = 00110010b
-00101000b ^ 00011011b = 00110011b
-00101000b ^ 00011100b = 00110100b
-00101000b ^ 00011101b = 00110101b
-00101000b ^ 00011110b = 00110110b
-00101000b ^ 00011111b = 00110111b
-00101000b ^ 00100000b = 00001000b
-00101000b ^ 00100001b = 00001001b
-00101000b ^ 00100010b = 00001010b
-00101000b ^ 00100011b = 00001011b
-00101000b ^ 00100100b = 00001100b
-00101000b ^ 00100101b = 00001101b
-00101000b ^ 00100110b = 00001110b
-00101000b ^ 00100111b = 00001111b
-00101000b ^ 00101000b = 00000000b
-00101000b ^ 00101001b = 00000001b
-00101000b ^ 00101010b = 00000010b
-00101000b ^ 00101011b = 00000011b
-00101000b ^ 00101100b = 00000100b
-00101000b ^ 00101101b = 00000101b
-00101000b ^ 00101110b = 00000110b
-00101000b ^ 00101111b = 00000111b
-00101000b ^ 00110000b = 00011000b
-00101000b ^ 00110001b = 00011001b
-00101000b ^ 00110010b = 00011010b
-00101000b ^ 00110011b = 00011011b
-00101000b ^ 00110100b = 00011100b
-00101000b ^ 00110101b = 00011101b
-00101000b ^ 00110110b = 00011110b
-00101000b ^ 00110111b = 00011111b
-00101000b ^ 00111000b = 00010000b
-00101000b ^ 00111001b = 00010001b
-00101000b ^ 00111010b = 00010010b
-00101000b ^ 00111011b = 00010011b
-00101000b ^ 00111100b = 00010100b
-00101000b ^ 00111101b = 00010101b
-00101000b ^ 00111110b = 00010110b
-00101000b ^ 00111111b = 00010111b
-00101000b ^ 01000000b = 01101000b
-00101000b ^ 01000001b = 01101001b
-00101000b ^ 01000010b = 01101010b
-00101000b ^ 01000011b = 01101011b
-00101000b ^ 01000100b = 01101100b
-00101000b ^ 01000101b = 01101101b
-00101000b ^ 01000110b = 01101110b
-00101000b ^ 01000111b = 01101111b
-00101000b ^ 01001000b = 01100000b
-00101000b ^ 01001001b = 01100001b
-00101000b ^ 01001010b = 01100010b
-00101000b ^ 01001011b = 01100011b
-00101000b ^ 01001100b = 01100100b
-00101000b ^ 01001101b = 01100101b
-00101000b ^ 01001110b = 01100110b
-00101000b ^ 01001111b = 01100111b
-00101000b ^ 01010000b = 01111000b
-00101000b ^ 01010001b = 01111001b
-00101000b ^ 01010010b = 01111010b
-00101000b ^ 01010011b = 01111011b
-00101000b ^ 01010100b = 01111100b
-00101000b ^ 01010101b = 01111101b
-00101000b ^ 01010110b = 01111110b
-00101000b ^ 01010111b = 01111111b
-00101000b ^ 01011000b = 01110000b
-00101000b ^ 01011001b = 01110001b
-00101000b ^ 01011010b = 01110010b
-00101000b ^ 01011011b = 01110011b
-00101000b ^ 01011100b = 01110100b
-00101000b ^ 01011101b = 01110101b
-00101000b ^ 01011110b = 01110110b
-00101000b ^ 01011111b = 01110111b
-00101000b ^ 01100000b = 01001000b
-00101000b ^ 01100001b = 01001001b
-00101000b ^ 01100010b = 01001010b
-00101000b ^ 01100011b = 01001011b
-00101000b ^ 01100100b = 01001100b
-00101000b ^ 01100101b = 01001101b
-00101000b ^ 01100110b = 01001110b
-00101000b ^ 01100111b = 01001111b
-00101000b ^ 01101000b = 01000000b
-00101000b ^ 01101001b = 01000001b
-00101000b ^ 01101010b = 01000010b
-00101000b ^ 01101011b = 01000011b
-00101000b ^ 01101100b = 01000100b
-00101000b ^ 01101101b = 01000101b
-00101000b ^ 01101110b = 01000110b
-00101000b ^ 01101111b = 01000111b
-00101000b ^ 01110000b = 01011000b
-00101000b ^ 01110001b = 01011001b
-00101000b ^ 01110010b = 01011010b
-00101000b ^ 01110011b = 01011011b
-00101000b ^ 01110100b = 01011100b
-00101000b ^ 01110101b = 01011101b
-00101000b ^ 01110110b = 01011110b
-00101000b ^ 01110111b = 01011111b
-00101000b ^ 01111000b = 01010000b
-00101000b ^ 01111001b = 01010001b
-00101000b ^ 01111010b = 01010010b
-00101000b ^ 01111011b = 01010011b
-00101000b ^ 01111100b = 01010100b
-00101000b ^ 01111101b = 01010101b
-00101000b ^ 01111110b = 01010110b
-00101001b ^ 10000000b = 10101001b
-00101001b ^ 10000001b = 10101000b
-00101001b ^ 10000010b = 10101011b
-00101001b ^ 10000011b = 10101010b
-00101001b ^ 10000100b = 10101101b
-00101001b ^ 10000101b = 10101100b
-00101001b ^ 10000110b = 10101111b
-00101001b ^ 10000111b = 10101110b
-00101001b ^ 10001000b = 10100001b
-00101001b ^ 10001001b = 10100000b
-00101001b ^ 10001010b = 10100011b
-00101001b ^ 10001011b = 10100010b
-00101001b ^ 10001100b = 10100101b
-00101001b ^ 10001101b = 10100100b
-00101001b ^ 10001110b = 10100111b
-00101001b ^ 10001111b = 10100110b
-00101001b ^ 10010000b = 10111001b
-00101001b ^ 10010001b = 10111000b
-00101001b ^ 10010010b = 10111011b
-00101001b ^ 10010011b = 10111010b
-00101001b ^ 10010100b = 10111101b
-00101001b ^ 10010101b = 10111100b
-00101001b ^ 10010110b = 10111111b
-00101001b ^ 10010111b = 10111110b
-00101001b ^ 10011000b = 10110001b
-00101001b ^ 10011001b = 10110000b
-00101001b ^ 10011010b = 10110011b
-00101001b ^ 10011011b = 10110010b
-00101001b ^ 10011100b = 10110101b
-00101001b ^ 10011101b = 10110100b
-00101001b ^ 10011110b = 10110111b
-00101001b ^ 10011111b = 10110110b
-00101001b ^ 10100000b = 10001001b
-00101001b ^ 10100001b = 10001000b
-00101001b ^ 10100010b = 10001011b
-00101001b ^ 10100011b = 10001010b
-00101001b ^ 10100100b = 10001101b
-00101001b ^ 10100101b = 10001100b
-00101001b ^ 10100110b = 10001111b
-00101001b ^ 10100111b = 10001110b
-00101001b ^ 10101000b = 10000001b
-00101001b ^ 10101001b = 10000000b
-00101001b ^ 10101010b = 10000011b
-00101001b ^ 10101011b = 10000010b
-00101001b ^ 10101100b = 10000101b
-00101001b ^ 10101101b = 10000100b
-00101001b ^ 10101110b = 10000111b
-00101001b ^ 10101111b = 10000110b
-00101001b ^ 10110000b = 10011001b
-00101001b ^ 10110001b = 10011000b
-00101001b ^ 10110010b = 10011011b
-00101001b ^ 10110011b = 10011010b
-00101001b ^ 10110100b = 10011101b
-00101001b ^ 10110101b = 10011100b
-00101001b ^ 10110110b = 10011111b
-00101001b ^ 10110111b = 10011110b
-00101001b ^ 10111000b = 10010001b
-00101001b ^ 10111001b = 10010000b
-00101001b ^ 10111010b = 10010011b
-00101001b ^ 10111011b = 10010010b
-00101001b ^ 10111100b = 10010101b
-00101001b ^ 10111101b = 10010100b
-00101001b ^ 10111110b = 10010111b
-00101001b ^ 10111111b = 10010110b
-00101001b ^ 11000000b = 11101001b
-00101001b ^ 11000001b = 11101000b
-00101001b ^ 11000010b = 11101011b
-00101001b ^ 11000011b = 11101010b
-00101001b ^ 11000100b = 11101101b
-00101001b ^ 11000101b = 11101100b
-00101001b ^ 11000110b = 11101111b
-00101001b ^ 11000111b = 11101110b
-00101001b ^ 11001000b = 11100001b
-00101001b ^ 11001001b = 11100000b
-00101001b ^ 11001010b = 11100011b
-00101001b ^ 11001011b = 11100010b
-00101001b ^ 11001100b = 11100101b
-00101001b ^ 11001101b = 11100100b
-00101001b ^ 11001110b = 11100111b
-00101001b ^ 11001111b = 11100110b
-00101001b ^ 11010000b = 11111001b
-00101001b ^ 11010001b = 11111000b
-00101001b ^ 11010010b = 11111011b
-00101001b ^ 11010011b = 11111010b
-00101001b ^ 11010100b = 11111101b
-00101001b ^ 11010101b = 11111100b
-00101001b ^ 11010110b = 11111111b
-00101001b ^ 11010111b = 11111110b
-00101001b ^ 11011000b = 11110001b
-00101001b ^ 11011001b = 11110000b
-00101001b ^ 11011010b = 11110011b
-00101001b ^ 11011011b = 11110010b
-00101001b ^ 11011100b = 11110101b
-00101001b ^ 11011101b = 11110100b
-00101001b ^ 11011110b = 11110111b
-00101001b ^ 11011111b = 11110110b
-00101001b ^ 11100000b = 11001001b
-00101001b ^ 11100001b = 11001000b
-00101001b ^ 11100010b = 11001011b
-00101001b ^ 11100011b = 11001010b
-00101001b ^ 11100100b = 11001101b
-00101001b ^ 11100101b = 11001100b
-00101001b ^ 11100110b = 11001111b
-00101001b ^ 11100111b = 11001110b
-00101001b ^ 11101000b = 11000001b
-00101001b ^ 11101001b = 11000000b
-00101001b ^ 11101010b = 11000011b
-00101001b ^ 11101011b = 11000010b
-00101001b ^ 11101100b = 11000101b
-00101001b ^ 11101101b = 11000100b
-00101001b ^ 11101110b = 11000111b
-00101001b ^ 11101111b = 11000110b
-00101001b ^ 11110000b = 11011001b
-00101001b ^ 11110001b = 11011000b
-00101001b ^ 11110010b = 11011011b
-00101001b ^ 11110011b = 11011010b
-00101001b ^ 11110100b = 11011101b
-00101001b ^ 11110101b = 11011100b
-00101001b ^ 11110110b = 11011111b
-00101001b ^ 11110111b = 11011110b
-00101001b ^ 11111000b = 11010001b
-00101001b ^ 11111001b = 11010000b
-00101001b ^ 11111010b = 11010011b
-00101001b ^ 11111011b = 11010010b
-00101001b ^ 11111100b = 11010101b
-00101001b ^ 11111101b = 11010100b
-00101001b ^ 11111110b = 11010111b
-00101001b ^ 11111111b = 11010110b
-00101001b ^ 00000000b = 00101001b
-00101001b ^ 00000001b = 00101000b
-00101001b ^ 00000010b = 00101011b
-00101001b ^ 00000011b = 00101010b
-00101001b ^ 00000100b = 00101101b
-00101001b ^ 00000101b = 00101100b
-00101001b ^ 00000110b = 00101111b
-00101001b ^ 00000111b = 00101110b
-00101001b ^ 00001000b = 00100001b
-00101001b ^ 00001001b = 00100000b
-00101001b ^ 00001010b = 00100011b
-00101001b ^ 00001011b = 00100010b
-00101001b ^ 00001100b = 00100101b
-00101001b ^ 00001101b = 00100100b
-00101001b ^ 00001110b = 00100111b
-00101001b ^ 00001111b = 00100110b
-00101001b ^ 00010000b = 00111001b
-00101001b ^ 00010001b = 00111000b
-00101001b ^ 00010010b = 00111011b
-00101001b ^ 00010011b = 00111010b
-00101001b ^ 00010100b = 00111101b
-00101001b ^ 00010101b = 00111100b
-00101001b ^ 00010110b = 00111111b
-00101001b ^ 00010111b = 00111110b
-00101001b ^ 00011000b = 00110001b
-00101001b ^ 00011001b = 00110000b
-00101001b ^ 00011010b = 00110011b
-00101001b ^ 00011011b = 00110010b
-00101001b ^ 00011100b = 00110101b
-00101001b ^ 00011101b = 00110100b
-00101001b ^ 00011110b = 00110111b
-00101001b ^ 00011111b = 00110110b
-00101001b ^ 00100000b = 00001001b
-00101001b ^ 00100001b = 00001000b
-00101001b ^ 00100010b = 00001011b
-00101001b ^ 00100011b = 00001010b
-00101001b ^ 00100100b = 00001101b
-00101001b ^ 00100101b = 00001100b
-00101001b ^ 00100110b = 00001111b
-00101001b ^ 00100111b = 00001110b
-00101001b ^ 00101000b = 00000001b
-00101001b ^ 00101001b = 00000000b
-00101001b ^ 00101010b = 00000011b
-00101001b ^ 00101011b = 00000010b
-00101001b ^ 00101100b = 00000101b
-00101001b ^ 00101101b = 00000100b
-00101001b ^ 00101110b = 00000111b
-00101001b ^ 00101111b = 00000110b
-00101001b ^ 00110000b = 00011001b
-00101001b ^ 00110001b = 00011000b
-00101001b ^ 00110010b = 00011011b
-00101001b ^ 00110011b = 00011010b
-00101001b ^ 00110100b = 00011101b
-00101001b ^ 00110101b = 00011100b
-00101001b ^ 00110110b = 00011111b
-00101001b ^ 00110111b = 00011110b
-00101001b ^ 00111000b = 00010001b
-00101001b ^ 00111001b = 00010000b
-00101001b ^ 00111010b = 00010011b
-00101001b ^ 00111011b = 00010010b
-00101001b ^ 00111100b = 00010101b
-00101001b ^ 00111101b = 00010100b
-00101001b ^ 00111110b = 00010111b
-00101001b ^ 00111111b = 00010110b
-00101001b ^ 01000000b = 01101001b
-00101001b ^ 01000001b = 01101000b
-00101001b ^ 01000010b = 01101011b
-00101001b ^ 01000011b = 01101010b
-00101001b ^ 01000100b = 01101101b
-00101001b ^ 01000101b = 01101100b
-00101001b ^ 01000110b = 01101111b
-00101001b ^ 01000111b = 01101110b
-00101001b ^ 01001000b = 01100001b
-00101001b ^ 01001001b = 01100000b
-00101001b ^ 01001010b = 01100011b
-00101001b ^ 01001011b = 01100010b
-00101001b ^ 01001100b = 01100101b
-00101001b ^ 01001101b = 01100100b
-00101001b ^ 01001110b = 01100111b
-00101001b ^ 01001111b = 01100110b
-00101001b ^ 01010000b = 01111001b
-00101001b ^ 01010001b = 01111000b
-00101001b ^ 01010010b = 01111011b
-00101001b ^ 01010011b = 01111010b
-00101001b ^ 01010100b = 01111101b
-00101001b ^ 01010101b = 01111100b
-00101001b ^ 01010110b = 01111111b
-00101001b ^ 01010111b = 01111110b
-00101001b ^ 01011000b = 01110001b
-00101001b ^ 01011001b = 01110000b
-00101001b ^ 01011010b = 01110011b
-00101001b ^ 01011011b = 01110010b
-00101001b ^ 01011100b = 01110101b
-00101001b ^ 01011101b = 01110100b
-00101001b ^ 01011110b = 01110111b
-00101001b ^ 01011111b = 01110110b
-00101001b ^ 01100000b = 01001001b
-00101001b ^ 01100001b = 01001000b
-00101001b ^ 01100010b = 01001011b
-00101001b ^ 01100011b = 01001010b
-00101001b ^ 01100100b = 01001101b
-00101001b ^ 01100101b = 01001100b
-00101001b ^ 01100110b = 01001111b
-00101001b ^ 01100111b = 01001110b
-00101001b ^ 01101000b = 01000001b
-00101001b ^ 01101001b = 01000000b
-00101001b ^ 01101010b = 01000011b
-00101001b ^ 01101011b = 01000010b
-00101001b ^ 01101100b = 01000101b
-00101001b ^ 01101101b = 01000100b
-00101001b ^ 01101110b = 01000111b
-00101001b ^ 01101111b = 01000110b
-00101001b ^ 01110000b = 01011001b
-00101001b ^ 01110001b = 01011000b
-00101001b ^ 01110010b = 01011011b
-00101001b ^ 01110011b = 01011010b
-00101001b ^ 01110100b = 01011101b
-00101001b ^ 01110101b = 01011100b
-00101001b ^ 01110110b = 01011111b
-00101001b ^ 01110111b = 01011110b
-00101001b ^ 01111000b = 01010001b
-00101001b ^ 01111001b = 01010000b
-00101001b ^ 01111010b = 01010011b
-00101001b ^ 01111011b = 01010010b
-00101001b ^ 01111100b = 01010101b
-00101001b ^ 01111101b = 01010100b
-00101001b ^ 01111110b = 01010111b
-00101010b ^ 10000000b = 10101010b
-00101010b ^ 10000001b = 10101011b
-00101010b ^ 10000010b = 10101000b
-00101010b ^ 10000011b = 10101001b
-00101010b ^ 10000100b = 10101110b
-00101010b ^ 10000101b = 10101111b
-00101010b ^ 10000110b = 10101100b
-00101010b ^ 10000111b = 10101101b
-00101010b ^ 10001000b = 10100010b
-00101010b ^ 10001001b = 10100011b
-00101010b ^ 10001010b = 10100000b
-00101010b ^ 10001011b = 10100001b
-00101010b ^ 10001100b = 10100110b
-00101010b ^ 10001101b = 10100111b
-00101010b ^ 10001110b = 10100100b
-00101010b ^ 10001111b = 10100101b
-00101010b ^ 10010000b = 10111010b
-00101010b ^ 10010001b = 10111011b
-00101010b ^ 10010010b = 10111000b
-00101010b ^ 10010011b = 10111001b
-00101010b ^ 10010100b = 10111110b
-00101010b ^ 10010101b = 10111111b
-00101010b ^ 10010110b = 10111100b
-00101010b ^ 10010111b = 10111101b
-00101010b ^ 10011000b = 10110010b
-00101010b ^ 10011001b = 10110011b
-00101010b ^ 10011010b = 10110000b
-00101010b ^ 10011011b = 10110001b
-00101010b ^ 10011100b = 10110110b
-00101010b ^ 10011101b = 10110111b
-00101010b ^ 10011110b = 10110100b
-00101010b ^ 10011111b = 10110101b
-00101010b ^ 10100000b = 10001010b
-00101010b ^ 10100001b = 10001011b
-00101010b ^ 10100010b = 10001000b
-00101010b ^ 10100011b = 10001001b
-00101010b ^ 10100100b = 10001110b
-00101010b ^ 10100101b = 10001111b
-00101010b ^ 10100110b = 10001100b
-00101010b ^ 10100111b = 10001101b
-00101010b ^ 10101000b = 10000010b
-00101010b ^ 10101001b = 10000011b
-00101010b ^ 10101010b = 10000000b
-00101010b ^ 10101011b = 10000001b
-00101010b ^ 10101100b = 10000110b
-00101010b ^ 10101101b = 10000111b
-00101010b ^ 10101110b = 10000100b
-00101010b ^ 10101111b = 10000101b
-00101010b ^ 10110000b = 10011010b
-00101010b ^ 10110001b = 10011011b
-00101010b ^ 10110010b = 10011000b
-00101010b ^ 10110011b = 10011001b
-00101010b ^ 10110100b = 10011110b
-00101010b ^ 10110101b = 10011111b
-00101010b ^ 10110110b = 10011100b
-00101010b ^ 10110111b = 10011101b
-00101010b ^ 10111000b = 10010010b
-00101010b ^ 10111001b = 10010011b
-00101010b ^ 10111010b = 10010000b
-00101010b ^ 10111011b = 10010001b
-00101010b ^ 10111100b = 10010110b
-00101010b ^ 10111101b = 10010111b
-00101010b ^ 10111110b = 10010100b
-00101010b ^ 10111111b = 10010101b
-00101010b ^ 11000000b = 11101010b
-00101010b ^ 11000001b = 11101011b
-00101010b ^ 11000010b = 11101000b
-00101010b ^ 11000011b = 11101001b
-00101010b ^ 11000100b = 11101110b
-00101010b ^ 11000101b = 11101111b
-00101010b ^ 11000110b = 11101100b
-00101010b ^ 11000111b = 11101101b
-00101010b ^ 11001000b = 11100010b
-00101010b ^ 11001001b = 11100011b
-00101010b ^ 11001010b = 11100000b
-00101010b ^ 11001011b = 11100001b
-00101010b ^ 11001100b = 11100110b
-00101010b ^ 11001101b = 11100111b
-00101010b ^ 11001110b = 11100100b
-00101010b ^ 11001111b = 11100101b
-00101010b ^ 11010000b = 11111010b
-00101010b ^ 11010001b = 11111011b
-00101010b ^ 11010010b = 11111000b
-00101010b ^ 11010011b = 11111001b
-00101010b ^ 11010100b = 11111110b
-00101010b ^ 11010101b = 11111111b
-00101010b ^ 11010110b = 11111100b
-00101010b ^ 11010111b = 11111101b
-00101010b ^ 11011000b = 11110010b
-00101010b ^ 11011001b = 11110011b
-00101010b ^ 11011010b = 11110000b
-00101010b ^ 11011011b = 11110001b
-00101010b ^ 11011100b = 11110110b
-00101010b ^ 11011101b = 11110111b
-00101010b ^ 11011110b = 11110100b
-00101010b ^ 11011111b = 11110101b
-00101010b ^ 11100000b = 11001010b
-00101010b ^ 11100001b = 11001011b
-00101010b ^ 11100010b = 11001000b
-00101010b ^ 11100011b = 11001001b
-00101010b ^ 11100100b = 11001110b
-00101010b ^ 11100101b = 11001111b
-00101010b ^ 11100110b = 11001100b
-00101010b ^ 11100111b = 11001101b
-00101010b ^ 11101000b = 11000010b
-00101010b ^ 11101001b = 11000011b
-00101010b ^ 11101010b = 11000000b
-00101010b ^ 11101011b = 11000001b
-00101010b ^ 11101100b = 11000110b
-00101010b ^ 11101101b = 11000111b
-00101010b ^ 11101110b = 11000100b
-00101010b ^ 11101111b = 11000101b
-00101010b ^ 11110000b = 11011010b
-00101010b ^ 11110001b = 11011011b
-00101010b ^ 11110010b = 11011000b
-00101010b ^ 11110011b = 11011001b
-00101010b ^ 11110100b = 11011110b
-00101010b ^ 11110101b = 11011111b
-00101010b ^ 11110110b = 11011100b
-00101010b ^ 11110111b = 11011101b
-00101010b ^ 11111000b = 11010010b
-00101010b ^ 11111001b = 11010011b
-00101010b ^ 11111010b = 11010000b
-00101010b ^ 11111011b = 11010001b
-00101010b ^ 11111100b = 11010110b
-00101010b ^ 11111101b = 11010111b
-00101010b ^ 11111110b = 11010100b
-00101010b ^ 11111111b = 11010101b
-00101010b ^ 00000000b = 00101010b
-00101010b ^ 00000001b = 00101011b
-00101010b ^ 00000010b = 00101000b
-00101010b ^ 00000011b = 00101001b
-00101010b ^ 00000100b = 00101110b
-00101010b ^ 00000101b = 00101111b
-00101010b ^ 00000110b = 00101100b
-00101010b ^ 00000111b = 00101101b
-00101010b ^ 00001000b = 00100010b
-00101010b ^ 00001001b = 00100011b
-00101010b ^ 00001010b = 00100000b
-00101010b ^ 00001011b = 00100001b
-00101010b ^ 00001100b = 00100110b
-00101010b ^ 00001101b = 00100111b
-00101010b ^ 00001110b = 00100100b
-00101010b ^ 00001111b = 00100101b
-00101010b ^ 00010000b = 00111010b
-00101010b ^ 00010001b = 00111011b
-00101010b ^ 00010010b = 00111000b
-00101010b ^ 00010011b = 00111001b
-00101010b ^ 00010100b = 00111110b
-00101010b ^ 00010101b = 00111111b
-00101010b ^ 00010110b = 00111100b
-00101010b ^ 00010111b = 00111101b
-00101010b ^ 00011000b = 00110010b
-00101010b ^ 00011001b = 00110011b
-00101010b ^ 00011010b = 00110000b
-00101010b ^ 00011011b = 00110001b
-00101010b ^ 00011100b = 00110110b
-00101010b ^ 00011101b = 00110111b
-00101010b ^ 00011110b = 00110100b
-00101010b ^ 00011111b = 00110101b
-00101010b ^ 00100000b = 00001010b
-00101010b ^ 00100001b = 00001011b
-00101010b ^ 00100010b = 00001000b
-00101010b ^ 00100011b = 00001001b
-00101010b ^ 00100100b = 00001110b
-00101010b ^ 00100101b = 00001111b
-00101010b ^ 00100110b = 00001100b
-00101010b ^ 00100111b = 00001101b
-00101010b ^ 00101000b = 00000010b
-00101010b ^ 00101001b = 00000011b
-00101010b ^ 00101010b = 00000000b
-00101010b ^ 00101011b = 00000001b
-00101010b ^ 00101100b = 00000110b
-00101010b ^ 00101101b = 00000111b
-00101010b ^ 00101110b = 00000100b
-00101010b ^ 00101111b = 00000101b
-00101010b ^ 00110000b = 00011010b
-00101010b ^ 00110001b = 00011011b
-00101010b ^ 00110010b = 00011000b
-00101010b ^ 00110011b = 00011001b
-00101010b ^ 00110100b = 00011110b
-00101010b ^ 00110101b = 00011111b
-00101010b ^ 00110110b = 00011100b
-00101010b ^ 00110111b = 00011101b
-00101010b ^ 00111000b = 00010010b
-00101010b ^ 00111001b = 00010011b
-00101010b ^ 00111010b = 00010000b
-00101010b ^ 00111011b = 00010001b
-00101010b ^ 00111100b = 00010110b
-00101010b ^ 00111101b = 00010111b
-00101010b ^ 00111110b = 00010100b
-00101010b ^ 00111111b = 00010101b
-00101010b ^ 01000000b = 01101010b
-00101010b ^ 01000001b = 01101011b
-00101010b ^ 01000010b = 01101000b
-00101010b ^ 01000011b = 01101001b
-00101010b ^ 01000100b = 01101110b
-00101010b ^ 01000101b = 01101111b
-00101010b ^ 01000110b = 01101100b
-00101010b ^ 01000111b = 01101101b
-00101010b ^ 01001000b = 01100010b
-00101010b ^ 01001001b = 01100011b
-00101010b ^ 01001010b = 01100000b
-00101010b ^ 01001011b = 01100001b
-00101010b ^ 01001100b = 01100110b
-00101010b ^ 01001101b = 01100111b
-00101010b ^ 01001110b = 01100100b
-00101010b ^ 01001111b = 01100101b
-00101010b ^ 01010000b = 01111010b
-00101010b ^ 01010001b = 01111011b
-00101010b ^ 01010010b = 01111000b
-00101010b ^ 01010011b = 01111001b
-00101010b ^ 01010100b = 01111110b
-00101010b ^ 01010101b = 01111111b
-00101010b ^ 01010110b = 01111100b
-00101010b ^ 01010111b = 01111101b
-00101010b ^ 01011000b = 01110010b
-00101010b ^ 01011001b = 01110011b
-00101010b ^ 01011010b = 01110000b
-00101010b ^ 01011011b = 01110001b
-00101010b ^ 01011100b = 01110110b
-00101010b ^ 01011101b = 01110111b
-00101010b ^ 01011110b = 01110100b
-00101010b ^ 01011111b = 01110101b
-00101010b ^ 01100000b = 01001010b
-00101010b ^ 01100001b = 01001011b
-00101010b ^ 01100010b = 01001000b
-00101010b ^ 01100011b = 01001001b
-00101010b ^ 01100100b = 01001110b
-00101010b ^ 01100101b = 01001111b
-00101010b ^ 01100110b = 01001100b
-00101010b ^ 01100111b = 01001101b
-00101010b ^ 01101000b = 01000010b
-00101010b ^ 01101001b = 01000011b
-00101010b ^ 01101010b = 01000000b
-00101010b ^ 01101011b = 01000001b
-00101010b ^ 01101100b = 01000110b
-00101010b ^ 01101101b = 01000111b
-00101010b ^ 01101110b = 01000100b
-00101010b ^ 01101111b = 01000101b
-00101010b ^ 01110000b = 01011010b
-00101010b ^ 01110001b = 01011011b
-00101010b ^ 01110010b = 01011000b
-00101010b ^ 01110011b = 01011001b
-00101010b ^ 01110100b = 01011110b
-00101010b ^ 01110101b = 01011111b
-00101010b ^ 01110110b = 01011100b
-00101010b ^ 01110111b = 01011101b
-00101010b ^ 01111000b = 01010010b
-00101010b ^ 01111001b = 01010011b
-00101010b ^ 01111010b = 01010000b
-00101010b ^ 01111011b = 01010001b
-00101010b ^ 01111100b = 01010110b
-00101010b ^ 01111101b = 01010111b
-00101010b ^ 01111110b = 01010100b
-00101011b ^ 10000000b = 10101011b
-00101011b ^ 10000001b = 10101010b
-00101011b ^ 10000010b = 10101001b
-00101011b ^ 10000011b = 10101000b
-00101011b ^ 10000100b = 10101111b
-00101011b ^ 10000101b = 10101110b
-00101011b ^ 10000110b = 10101101b
-00101011b ^ 10000111b = 10101100b
-00101011b ^ 10001000b = 10100011b
-00101011b ^ 10001001b = 10100010b
-00101011b ^ 10001010b = 10100001b
-00101011b ^ 10001011b = 10100000b
-00101011b ^ 10001100b = 10100111b
-00101011b ^ 10001101b = 10100110b
-00101011b ^ 10001110b = 10100101b
-00101011b ^ 10001111b = 10100100b
-00101011b ^ 10010000b = 10111011b
-00101011b ^ 10010001b = 10111010b
-00101011b ^ 10010010b = 10111001b
-00101011b ^ 10010011b = 10111000b
-00101011b ^ 10010100b = 10111111b
-00101011b ^ 10010101b = 10111110b
-00101011b ^ 10010110b = 10111101b
-00101011b ^ 10010111b = 10111100b
-00101011b ^ 10011000b = 10110011b
-00101011b ^ 10011001b = 10110010b
-00101011b ^ 10011010b = 10110001b
-00101011b ^ 10011011b = 10110000b
-00101011b ^ 10011100b = 10110111b
-00101011b ^ 10011101b = 10110110b
-00101011b ^ 10011110b = 10110101b
-00101011b ^ 10011111b = 10110100b
-00101011b ^ 10100000b = 10001011b
-00101011b ^ 10100001b = 10001010b
-00101011b ^ 10100010b = 10001001b
-00101011b ^ 10100011b = 10001000b
-00101011b ^ 10100100b = 10001111b
-00101011b ^ 10100101b = 10001110b
-00101011b ^ 10100110b = 10001101b
-00101011b ^ 10100111b = 10001100b
-00101011b ^ 10101000b = 10000011b
-00101011b ^ 10101001b = 10000010b
-00101011b ^ 10101010b = 10000001b
-00101011b ^ 10101011b = 10000000b
-00101011b ^ 10101100b = 10000111b
-00101011b ^ 10101101b = 10000110b
-00101011b ^ 10101110b = 10000101b
-00101011b ^ 10101111b = 10000100b
-00101011b ^ 10110000b = 10011011b
-00101011b ^ 10110001b = 10011010b
-00101011b ^ 10110010b = 10011001b
-00101011b ^ 10110011b = 10011000b
-00101011b ^ 10110100b = 10011111b
-00101011b ^ 10110101b = 10011110b
-00101011b ^ 10110110b = 10011101b
-00101011b ^ 10110111b = 10011100b
-00101011b ^ 10111000b = 10010011b
-00101011b ^ 10111001b = 10010010b
-00101011b ^ 10111010b = 10010001b
-00101011b ^ 10111011b = 10010000b
-00101011b ^ 10111100b = 10010111b
-00101011b ^ 10111101b = 10010110b
-00101011b ^ 10111110b = 10010101b
-00101011b ^ 10111111b = 10010100b
-00101011b ^ 11000000b = 11101011b
-00101011b ^ 11000001b = 11101010b
-00101011b ^ 11000010b = 11101001b
-00101011b ^ 11000011b = 11101000b
-00101011b ^ 11000100b = 11101111b
-00101011b ^ 11000101b = 11101110b
-00101011b ^ 11000110b = 11101101b
-00101011b ^ 11000111b = 11101100b
-00101011b ^ 11001000b = 11100011b
-00101011b ^ 11001001b = 11100010b
-00101011b ^ 11001010b = 11100001b
-00101011b ^ 11001011b = 11100000b
-00101011b ^ 11001100b = 11100111b
-00101011b ^ 11001101b = 11100110b
-00101011b ^ 11001110b = 11100101b
-00101011b ^ 11001111b = 11100100b
-00101011b ^ 11010000b = 11111011b
-00101011b ^ 11010001b = 11111010b
-00101011b ^ 11010010b = 11111001b
-00101011b ^ 11010011b = 11111000b
-00101011b ^ 11010100b = 11111111b
-00101011b ^ 11010101b = 11111110b
-00101011b ^ 11010110b = 11111101b
-00101011b ^ 11010111b = 11111100b
-00101011b ^ 11011000b = 11110011b
-00101011b ^ 11011001b = 11110010b
-00101011b ^ 11011010b = 11110001b
-00101011b ^ 11011011b = 11110000b
-00101011b ^ 11011100b = 11110111b
-00101011b ^ 11011101b = 11110110b
-00101011b ^ 11011110b = 11110101b
-00101011b ^ 11011111b = 11110100b
-00101011b ^ 11100000b = 11001011b
-00101011b ^ 11100001b = 11001010b
-00101011b ^ 11100010b = 11001001b
-00101011b ^ 11100011b = 11001000b
-00101011b ^ 11100100b = 11001111b
-00101011b ^ 11100101b = 11001110b
-00101011b ^ 11100110b = 11001101b
-00101011b ^ 11100111b = 11001100b
-00101011b ^ 11101000b = 11000011b
-00101011b ^ 11101001b = 11000010b
-00101011b ^ 11101010b = 11000001b
-00101011b ^ 11101011b = 11000000b
-00101011b ^ 11101100b = 11000111b
-00101011b ^ 11101101b = 11000110b
-00101011b ^ 11101110b = 11000101b
-00101011b ^ 11101111b = 11000100b
-00101011b ^ 11110000b = 11011011b
-00101011b ^ 11110001b = 11011010b
-00101011b ^ 11110010b = 11011001b
-00101011b ^ 11110011b = 11011000b
-00101011b ^ 11110100b = 11011111b
-00101011b ^ 11110101b = 11011110b
-00101011b ^ 11110110b = 11011101b
-00101011b ^ 11110111b = 11011100b
-00101011b ^ 11111000b = 11010011b
-00101011b ^ 11111001b = 11010010b
-00101011b ^ 11111010b = 11010001b
-00101011b ^ 11111011b = 11010000b
-00101011b ^ 11111100b = 11010111b
-00101011b ^ 11111101b = 11010110b
-00101011b ^ 11111110b = 11010101b
-00101011b ^ 11111111b = 11010100b
-00101011b ^ 00000000b = 00101011b
-00101011b ^ 00000001b = 00101010b
-00101011b ^ 00000010b = 00101001b
-00101011b ^ 00000011b = 00101000b
-00101011b ^ 00000100b = 00101111b
-00101011b ^ 00000101b = 00101110b
-00101011b ^ 00000110b = 00101101b
-00101011b ^ 00000111b = 00101100b
-00101011b ^ 00001000b = 00100011b
-00101011b ^ 00001001b = 00100010b
-00101011b ^ 00001010b = 00100001b
-00101011b ^ 00001011b = 00100000b
-00101011b ^ 00001100b = 00100111b
-00101011b ^ 00001101b = 00100110b
-00101011b ^ 00001110b = 00100101b
-00101011b ^ 00001111b = 00100100b
-00101011b ^ 00010000b = 00111011b
-00101011b ^ 00010001b = 00111010b
-00101011b ^ 00010010b = 00111001b
-00101011b ^ 00010011b = 00111000b
-00101011b ^ 00010100b = 00111111b
-00101011b ^ 00010101b = 00111110b
-00101011b ^ 00010110b = 00111101b
-00101011b ^ 00010111b = 00111100b
-00101011b ^ 00011000b = 00110011b
-00101011b ^ 00011001b = 00110010b
-00101011b ^ 00011010b = 00110001b
-00101011b ^ 00011011b = 00110000b
-00101011b ^ 00011100b = 00110111b
-00101011b ^ 00011101b = 00110110b
-00101011b ^ 00011110b = 00110101b
-00101011b ^ 00011111b = 00110100b
-00101011b ^ 00100000b = 00001011b
-00101011b ^ 00100001b = 00001010b
-00101011b ^ 00100010b = 00001001b
-00101011b ^ 00100011b = 00001000b
-00101011b ^ 00100100b = 00001111b
-00101011b ^ 00100101b = 00001110b
-00101011b ^ 00100110b = 00001101b
-00101011b ^ 00100111b = 00001100b
-00101011b ^ 00101000b = 00000011b
-00101011b ^ 00101001b = 00000010b
-00101011b ^ 00101010b = 00000001b
-00101011b ^ 00101011b = 00000000b
-00101011b ^ 00101100b = 00000111b
-00101011b ^ 00101101b = 00000110b
-00101011b ^ 00101110b = 00000101b
-00101011b ^ 00101111b = 00000100b
-00101011b ^ 00110000b = 00011011b
-00101011b ^ 00110001b = 00011010b
-00101011b ^ 00110010b = 00011001b
-00101011b ^ 00110011b = 00011000b
-00101011b ^ 00110100b = 00011111b
-00101011b ^ 00110101b = 00011110b
-00101011b ^ 00110110b = 00011101b
-00101011b ^ 00110111b = 00011100b
-00101011b ^ 00111000b = 00010011b
-00101011b ^ 00111001b = 00010010b
-00101011b ^ 00111010b = 00010001b
-00101011b ^ 00111011b = 00010000b
-00101011b ^ 00111100b = 00010111b
-00101011b ^ 00111101b = 00010110b
-00101011b ^ 00111110b = 00010101b
-00101011b ^ 00111111b = 00010100b
-00101011b ^ 01000000b = 01101011b
-00101011b ^ 01000001b = 01101010b
-00101011b ^ 01000010b = 01101001b
-00101011b ^ 01000011b = 01101000b
-00101011b ^ 01000100b = 01101111b
-00101011b ^ 01000101b = 01101110b
-00101011b ^ 01000110b = 01101101b
-00101011b ^ 01000111b = 01101100b
-00101011b ^ 01001000b = 01100011b
-00101011b ^ 01001001b = 01100010b
-00101011b ^ 01001010b = 01100001b
-00101011b ^ 01001011b = 01100000b
-00101011b ^ 01001100b = 01100111b
-00101011b ^ 01001101b = 01100110b
-00101011b ^ 01001110b = 01100101b
-00101011b ^ 01001111b = 01100100b
-00101011b ^ 01010000b = 01111011b
-00101011b ^ 01010001b = 01111010b
-00101011b ^ 01010010b = 01111001b
-00101011b ^ 01010011b = 01111000b
-00101011b ^ 01010100b = 01111111b
-00101011b ^ 01010101b = 01111110b
-00101011b ^ 01010110b = 01111101b
-00101011b ^ 01010111b = 01111100b
-00101011b ^ 01011000b = 01110011b
-00101011b ^ 01011001b = 01110010b
-00101011b ^ 01011010b = 01110001b
-00101011b ^ 01011011b = 01110000b
-00101011b ^ 01011100b = 01110111b
-00101011b ^ 01011101b = 01110110b
-00101011b ^ 01011110b = 01110101b
-00101011b ^ 01011111b = 01110100b
-00101011b ^ 01100000b = 01001011b
-00101011b ^ 01100001b = 01001010b
-00101011b ^ 01100010b = 01001001b
-00101011b ^ 01100011b = 01001000b
-00101011b ^ 01100100b = 01001111b
-00101011b ^ 01100101b = 01001110b
-00101011b ^ 01100110b = 01001101b
-00101011b ^ 01100111b = 01001100b
-00101011b ^ 01101000b = 01000011b
-00101011b ^ 01101001b = 01000010b
-00101011b ^ 01101010b = 01000001b
-00101011b ^ 01101011b = 01000000b
-00101011b ^ 01101100b = 01000111b
-00101011b ^ 01101101b = 01000110b
-00101011b ^ 01101110b = 01000101b
-00101011b ^ 01101111b = 01000100b
-00101011b ^ 01110000b = 01011011b
-00101011b ^ 01110001b = 01011010b
-00101011b ^ 01110010b = 01011001b
-00101011b ^ 01110011b = 01011000b
-00101011b ^ 01110100b = 01011111b
-00101011b ^ 01110101b = 01011110b
-00101011b ^ 01110110b = 01011101b
-00101011b ^ 01110111b = 01011100b
-00101011b ^ 01111000b = 01010011b
-00101011b ^ 01111001b = 01010010b
-00101011b ^ 01111010b = 01010001b
-00101011b ^ 01111011b = 01010000b
-00101011b ^ 01111100b = 01010111b
-00101011b ^ 01111101b = 01010110b
-00101011b ^ 01111110b = 01010101b
-00101100b ^ 10000000b = 10101100b
-00101100b ^ 10000001b = 10101101b
-00101100b ^ 10000010b = 10101110b
-00101100b ^ 10000011b = 10101111b
-00101100b ^ 10000100b = 10101000b
-00101100b ^ 10000101b = 10101001b
-00101100b ^ 10000110b = 10101010b
-00101100b ^ 10000111b = 10101011b
-00101100b ^ 10001000b = 10100100b
-00101100b ^ 10001001b = 10100101b
-00101100b ^ 10001010b = 10100110b
-00101100b ^ 10001011b = 10100111b
-00101100b ^ 10001100b = 10100000b
-00101100b ^ 10001101b = 10100001b
-00101100b ^ 10001110b = 10100010b
-00101100b ^ 10001111b = 10100011b
-00101100b ^ 10010000b = 10111100b
-00101100b ^ 10010001b = 10111101b
-00101100b ^ 10010010b = 10111110b
-00101100b ^ 10010011b = 10111111b
-00101100b ^ 10010100b = 10111000b
-00101100b ^ 10010101b = 10111001b
-00101100b ^ 10010110b = 10111010b
-00101100b ^ 10010111b = 10111011b
-00101100b ^ 10011000b = 10110100b
-00101100b ^ 10011001b = 10110101b
-00101100b ^ 10011010b = 10110110b
-00101100b ^ 10011011b = 10110111b
-00101100b ^ 10011100b = 10110000b
-00101100b ^ 10011101b = 10110001b
-00101100b ^ 10011110b = 10110010b
-00101100b ^ 10011111b = 10110011b
-00101100b ^ 10100000b = 10001100b
-00101100b ^ 10100001b = 10001101b
-00101100b ^ 10100010b = 10001110b
-00101100b ^ 10100011b = 10001111b
-00101100b ^ 10100100b = 10001000b
-00101100b ^ 10100101b = 10001001b
-00101100b ^ 10100110b = 10001010b
-00101100b ^ 10100111b = 10001011b
-00101100b ^ 10101000b = 10000100b
-00101100b ^ 10101001b = 10000101b
-00101100b ^ 10101010b = 10000110b
-00101100b ^ 10101011b = 10000111b
-00101100b ^ 10101100b = 10000000b
-00101100b ^ 10101101b = 10000001b
-00101100b ^ 10101110b = 10000010b
-00101100b ^ 10101111b = 10000011b
-00101100b ^ 10110000b = 10011100b
-00101100b ^ 10110001b = 10011101b
-00101100b ^ 10110010b = 10011110b
-00101100b ^ 10110011b = 10011111b
-00101100b ^ 10110100b = 10011000b
-00101100b ^ 10110101b = 10011001b
-00101100b ^ 10110110b = 10011010b
-00101100b ^ 10110111b = 10011011b
-00101100b ^ 10111000b = 10010100b
-00101100b ^ 10111001b = 10010101b
-00101100b ^ 10111010b = 10010110b
-00101100b ^ 10111011b = 10010111b
-00101100b ^ 10111100b = 10010000b
-00101100b ^ 10111101b = 10010001b
-00101100b ^ 10111110b = 10010010b
-00101100b ^ 10111111b = 10010011b
-00101100b ^ 11000000b = 11101100b
-00101100b ^ 11000001b = 11101101b
-00101100b ^ 11000010b = 11101110b
-00101100b ^ 11000011b = 11101111b
-00101100b ^ 11000100b = 11101000b
-00101100b ^ 11000101b = 11101001b
-00101100b ^ 11000110b = 11101010b
-00101100b ^ 11000111b = 11101011b
-00101100b ^ 11001000b = 11100100b
-00101100b ^ 11001001b = 11100101b
-00101100b ^ 11001010b = 11100110b
-00101100b ^ 11001011b = 11100111b
-00101100b ^ 11001100b = 11100000b
-00101100b ^ 11001101b = 11100001b
-00101100b ^ 11001110b = 11100010b
-00101100b ^ 11001111b = 11100011b
-00101100b ^ 11010000b = 11111100b
-00101100b ^ 11010001b = 11111101b
-00101100b ^ 11010010b = 11111110b
-00101100b ^ 11010011b = 11111111b
-00101100b ^ 11010100b = 11111000b
-00101100b ^ 11010101b = 11111001b
-00101100b ^ 11010110b = 11111010b
-00101100b ^ 11010111b = 11111011b
-00101100b ^ 11011000b = 11110100b
-00101100b ^ 11011001b = 11110101b
-00101100b ^ 11011010b = 11110110b
-00101100b ^ 11011011b = 11110111b
-00101100b ^ 11011100b = 11110000b
-00101100b ^ 11011101b = 11110001b
-00101100b ^ 11011110b = 11110010b
-00101100b ^ 11011111b = 11110011b
-00101100b ^ 11100000b = 11001100b
-00101100b ^ 11100001b = 11001101b
-00101100b ^ 11100010b = 11001110b
-00101100b ^ 11100011b = 11001111b
-00101100b ^ 11100100b = 11001000b
-00101100b ^ 11100101b = 11001001b
-00101100b ^ 11100110b = 11001010b
-00101100b ^ 11100111b = 11001011b
-00101100b ^ 11101000b = 11000100b
-00101100b ^ 11101001b = 11000101b
-00101100b ^ 11101010b = 11000110b
-00101100b ^ 11101011b = 11000111b
-00101100b ^ 11101100b = 11000000b
-00101100b ^ 11101101b = 11000001b
-00101100b ^ 11101110b = 11000010b
-00101100b ^ 11101111b = 11000011b
-00101100b ^ 11110000b = 11011100b
-00101100b ^ 11110001b = 11011101b
-00101100b ^ 11110010b = 11011110b
-00101100b ^ 11110011b = 11011111b
-00101100b ^ 11110100b = 11011000b
-00101100b ^ 11110101b = 11011001b
-00101100b ^ 11110110b = 11011010b
-00101100b ^ 11110111b = 11011011b
-00101100b ^ 11111000b = 11010100b
-00101100b ^ 11111001b = 11010101b
-00101100b ^ 11111010b = 11010110b
-00101100b ^ 11111011b = 11010111b
-00101100b ^ 11111100b = 11010000b
-00101100b ^ 11111101b = 11010001b
-00101100b ^ 11111110b = 11010010b
-00101100b ^ 11111111b = 11010011b
-00101100b ^ 00000000b = 00101100b
-00101100b ^ 00000001b = 00101101b
-00101100b ^ 00000010b = 00101110b
-00101100b ^ 00000011b = 00101111b
-00101100b ^ 00000100b = 00101000b
-00101100b ^ 00000101b = 00101001b
-00101100b ^ 00000110b = 00101010b
-00101100b ^ 00000111b = 00101011b
-00101100b ^ 00001000b = 00100100b
-00101100b ^ 00001001b = 00100101b
-00101100b ^ 00001010b = 00100110b
-00101100b ^ 00001011b = 00100111b
-00101100b ^ 00001100b = 00100000b
-00101100b ^ 00001101b = 00100001b
-00101100b ^ 00001110b = 00100010b
-00101100b ^ 00001111b = 00100011b
-00101100b ^ 00010000b = 00111100b
-00101100b ^ 00010001b = 00111101b
-00101100b ^ 00010010b = 00111110b
-00101100b ^ 00010011b = 00111111b
-00101100b ^ 00010100b = 00111000b
-00101100b ^ 00010101b = 00111001b
-00101100b ^ 00010110b = 00111010b
-00101100b ^ 00010111b = 00111011b
-00101100b ^ 00011000b = 00110100b
-00101100b ^ 00011001b = 00110101b
-00101100b ^ 00011010b = 00110110b
-00101100b ^ 00011011b = 00110111b
-00101100b ^ 00011100b = 00110000b
-00101100b ^ 00011101b = 00110001b
-00101100b ^ 00011110b = 00110010b
-00101100b ^ 00011111b = 00110011b
-00101100b ^ 00100000b = 00001100b
-00101100b ^ 00100001b = 00001101b
-00101100b ^ 00100010b = 00001110b
-00101100b ^ 00100011b = 00001111b
-00101100b ^ 00100100b = 00001000b
-00101100b ^ 00100101b = 00001001b
-00101100b ^ 00100110b = 00001010b
-00101100b ^ 00100111b = 00001011b
-00101100b ^ 00101000b = 00000100b
-00101100b ^ 00101001b = 00000101b
-00101100b ^ 00101010b = 00000110b
-00101100b ^ 00101011b = 00000111b
-00101100b ^ 00101100b = 00000000b
-00101100b ^ 00101101b = 00000001b
-00101100b ^ 00101110b = 00000010b
-00101100b ^ 00101111b = 00000011b
-00101100b ^ 00110000b = 00011100b
-00101100b ^ 00110001b = 00011101b
-00101100b ^ 00110010b = 00011110b
-00101100b ^ 00110011b = 00011111b
-00101100b ^ 00110100b = 00011000b
-00101100b ^ 00110101b = 00011001b
-00101100b ^ 00110110b = 00011010b
-00101100b ^ 00110111b = 00011011b
-00101100b ^ 00111000b = 00010100b
-00101100b ^ 00111001b = 00010101b
-00101100b ^ 00111010b = 00010110b
-00101100b ^ 00111011b = 00010111b
-00101100b ^ 00111100b = 00010000b
-00101100b ^ 00111101b = 00010001b
-00101100b ^ 00111110b = 00010010b
-00101100b ^ 00111111b = 00010011b
-00101100b ^ 01000000b = 01101100b
-00101100b ^ 01000001b = 01101101b
-00101100b ^ 01000010b = 01101110b
-00101100b ^ 01000011b = 01101111b
-00101100b ^ 01000100b = 01101000b
-00101100b ^ 01000101b = 01101001b
-00101100b ^ 01000110b = 01101010b
-00101100b ^ 01000111b = 01101011b
-00101100b ^ 01001000b = 01100100b
-00101100b ^ 01001001b = 01100101b
-00101100b ^ 01001010b = 01100110b
-00101100b ^ 01001011b = 01100111b
-00101100b ^ 01001100b = 01100000b
-00101100b ^ 01001101b = 01100001b
-00101100b ^ 01001110b = 01100010b
-00101100b ^ 01001111b = 01100011b
-00101100b ^ 01010000b = 01111100b
-00101100b ^ 01010001b = 01111101b
-00101100b ^ 01010010b = 01111110b
-00101100b ^ 01010011b = 01111111b
-00101100b ^ 01010100b = 01111000b
-00101100b ^ 01010101b = 01111001b
-00101100b ^ 01010110b = 01111010b
-00101100b ^ 01010111b = 01111011b
-00101100b ^ 01011000b = 01110100b
-00101100b ^ 01011001b = 01110101b
-00101100b ^ 01011010b = 01110110b
-00101100b ^ 01011011b = 01110111b
-00101100b ^ 01011100b = 01110000b
-00101100b ^ 01011101b = 01110001b
-00101100b ^ 01011110b = 01110010b
-00101100b ^ 01011111b = 01110011b
-00101100b ^ 01100000b = 01001100b
-00101100b ^ 01100001b = 01001101b
-00101100b ^ 01100010b = 01001110b
-00101100b ^ 01100011b = 01001111b
-00101100b ^ 01100100b = 01001000b
-00101100b ^ 01100101b = 01001001b
-00101100b ^ 01100110b = 01001010b
-00101100b ^ 01100111b = 01001011b
-00101100b ^ 01101000b = 01000100b
-00101100b ^ 01101001b = 01000101b
-00101100b ^ 01101010b = 01000110b
-00101100b ^ 01101011b = 01000111b
-00101100b ^ 01101100b = 01000000b
-00101100b ^ 01101101b = 01000001b
-00101100b ^ 01101110b = 01000010b
-00101100b ^ 01101111b = 01000011b
-00101100b ^ 01110000b = 01011100b
-00101100b ^ 01110001b = 01011101b
-00101100b ^ 01110010b = 01011110b
-00101100b ^ 01110011b = 01011111b
-00101100b ^ 01110100b = 01011000b
-00101100b ^ 01110101b = 01011001b
-00101100b ^ 01110110b = 01011010b
-00101100b ^ 01110111b = 01011011b
-00101100b ^ 01111000b = 01010100b
-00101100b ^ 01111001b = 01010101b
-00101100b ^ 01111010b = 01010110b
-00101100b ^ 01111011b = 01010111b
-00101100b ^ 01111100b = 01010000b
-00101100b ^ 01111101b = 01010001b
-00101100b ^ 01111110b = 01010010b
-00101101b ^ 10000000b = 10101101b
-00101101b ^ 10000001b = 10101100b
-00101101b ^ 10000010b = 10101111b
-00101101b ^ 10000011b = 10101110b
-00101101b ^ 10000100b = 10101001b
-00101101b ^ 10000101b = 10101000b
-00101101b ^ 10000110b = 10101011b
-00101101b ^ 10000111b = 10101010b
-00101101b ^ 10001000b = 10100101b
-00101101b ^ 10001001b = 10100100b
-00101101b ^ 10001010b = 10100111b
-00101101b ^ 10001011b = 10100110b
-00101101b ^ 10001100b = 10100001b
-00101101b ^ 10001101b = 10100000b
-00101101b ^ 10001110b = 10100011b
-00101101b ^ 10001111b = 10100010b
-00101101b ^ 10010000b = 10111101b
-00101101b ^ 10010001b = 10111100b
-00101101b ^ 10010010b = 10111111b
-00101101b ^ 10010011b = 10111110b
-00101101b ^ 10010100b = 10111001b
-00101101b ^ 10010101b = 10111000b
-00101101b ^ 10010110b = 10111011b
-00101101b ^ 10010111b = 10111010b
-00101101b ^ 10011000b = 10110101b
-00101101b ^ 10011001b = 10110100b
-00101101b ^ 10011010b = 10110111b
-00101101b ^ 10011011b = 10110110b
-00101101b ^ 10011100b = 10110001b
-00101101b ^ 10011101b = 10110000b
-00101101b ^ 10011110b = 10110011b
-00101101b ^ 10011111b = 10110010b
-00101101b ^ 10100000b = 10001101b
-00101101b ^ 10100001b = 10001100b
-00101101b ^ 10100010b = 10001111b
-00101101b ^ 10100011b = 10001110b
-00101101b ^ 10100100b = 10001001b
-00101101b ^ 10100101b = 10001000b
-00101101b ^ 10100110b = 10001011b
-00101101b ^ 10100111b = 10001010b
-00101101b ^ 10101000b = 10000101b
-00101101b ^ 10101001b = 10000100b
-00101101b ^ 10101010b = 10000111b
-00101101b ^ 10101011b = 10000110b
-00101101b ^ 10101100b = 10000001b
-00101101b ^ 10101101b = 10000000b
-00101101b ^ 10101110b = 10000011b
-00101101b ^ 10101111b = 10000010b
-00101101b ^ 10110000b = 10011101b
-00101101b ^ 10110001b = 10011100b
-00101101b ^ 10110010b = 10011111b
-00101101b ^ 10110011b = 10011110b
-00101101b ^ 10110100b = 10011001b
-00101101b ^ 10110101b = 10011000b
-00101101b ^ 10110110b = 10011011b
-00101101b ^ 10110111b = 10011010b
-00101101b ^ 10111000b = 10010101b
-00101101b ^ 10111001b = 10010100b
-00101101b ^ 10111010b = 10010111b
-00101101b ^ 10111011b = 10010110b
-00101101b ^ 10111100b = 10010001b
-00101101b ^ 10111101b = 10010000b
-00101101b ^ 10111110b = 10010011b
-00101101b ^ 10111111b = 10010010b
-00101101b ^ 11000000b = 11101101b
-00101101b ^ 11000001b = 11101100b
-00101101b ^ 11000010b = 11101111b
-00101101b ^ 11000011b = 11101110b
-00101101b ^ 11000100b = 11101001b
-00101101b ^ 11000101b = 11101000b
-00101101b ^ 11000110b = 11101011b
-00101101b ^ 11000111b = 11101010b
-00101101b ^ 11001000b = 11100101b
-00101101b ^ 11001001b = 11100100b
-00101101b ^ 11001010b = 11100111b
-00101101b ^ 11001011b = 11100110b
-00101101b ^ 11001100b = 11100001b
-00101101b ^ 11001101b = 11100000b
-00101101b ^ 11001110b = 11100011b
-00101101b ^ 11001111b = 11100010b
-00101101b ^ 11010000b = 11111101b
-00101101b ^ 11010001b = 11111100b
-00101101b ^ 11010010b = 11111111b
-00101101b ^ 11010011b = 11111110b
-00101101b ^ 11010100b = 11111001b
-00101101b ^ 11010101b = 11111000b
-00101101b ^ 11010110b = 11111011b
-00101101b ^ 11010111b = 11111010b
-00101101b ^ 11011000b = 11110101b
-00101101b ^ 11011001b = 11110100b
-00101101b ^ 11011010b = 11110111b
-00101101b ^ 11011011b = 11110110b
-00101101b ^ 11011100b = 11110001b
-00101101b ^ 11011101b = 11110000b
-00101101b ^ 11011110b = 11110011b
-00101101b ^ 11011111b = 11110010b
-00101101b ^ 11100000b = 11001101b
-00101101b ^ 11100001b = 11001100b
-00101101b ^ 11100010b = 11001111b
-00101101b ^ 11100011b = 11001110b
-00101101b ^ 11100100b = 11001001b
-00101101b ^ 11100101b = 11001000b
-00101101b ^ 11100110b = 11001011b
-00101101b ^ 11100111b = 11001010b
-00101101b ^ 11101000b = 11000101b
-00101101b ^ 11101001b = 11000100b
-00101101b ^ 11101010b = 11000111b
-00101101b ^ 11101011b = 11000110b
-00101101b ^ 11101100b = 11000001b
-00101101b ^ 11101101b = 11000000b
-00101101b ^ 11101110b = 11000011b
-00101101b ^ 11101111b = 11000010b
-00101101b ^ 11110000b = 11011101b
-00101101b ^ 11110001b = 11011100b
-00101101b ^ 11110010b = 11011111b
-00101101b ^ 11110011b = 11011110b
-00101101b ^ 11110100b = 11011001b
-00101101b ^ 11110101b = 11011000b
-00101101b ^ 11110110b = 11011011b
-00101101b ^ 11110111b = 11011010b
-00101101b ^ 11111000b = 11010101b
-00101101b ^ 11111001b = 11010100b
-00101101b ^ 11111010b = 11010111b
-00101101b ^ 11111011b = 11010110b
-00101101b ^ 11111100b = 11010001b
-00101101b ^ 11111101b = 11010000b
-00101101b ^ 11111110b = 11010011b
-00101101b ^ 11111111b = 11010010b
-00101101b ^ 00000000b = 00101101b
-00101101b ^ 00000001b = 00101100b
-00101101b ^ 00000010b = 00101111b
-00101101b ^ 00000011b = 00101110b
-00101101b ^ 00000100b = 00101001b
-00101101b ^ 00000101b = 00101000b
-00101101b ^ 00000110b = 00101011b
-00101101b ^ 00000111b = 00101010b
-00101101b ^ 00001000b = 00100101b
-00101101b ^ 00001001b = 00100100b
-00101101b ^ 00001010b = 00100111b
-00101101b ^ 00001011b = 00100110b
-00101101b ^ 00001100b = 00100001b
-00101101b ^ 00001101b = 00100000b
-00101101b ^ 00001110b = 00100011b
-00101101b ^ 00001111b = 00100010b
-00101101b ^ 00010000b = 00111101b
-00101101b ^ 00010001b = 00111100b
-00101101b ^ 00010010b = 00111111b
-00101101b ^ 00010011b = 00111110b
-00101101b ^ 00010100b = 00111001b
-00101101b ^ 00010101b = 00111000b
-00101101b ^ 00010110b = 00111011b
-00101101b ^ 00010111b = 00111010b
-00101101b ^ 00011000b = 00110101b
-00101101b ^ 00011001b = 00110100b
-00101101b ^ 00011010b = 00110111b
-00101101b ^ 00011011b = 00110110b
-00101101b ^ 00011100b = 00110001b
-00101101b ^ 00011101b = 00110000b
-00101101b ^ 00011110b = 00110011b
-00101101b ^ 00011111b = 00110010b
-00101101b ^ 00100000b = 00001101b
-00101101b ^ 00100001b = 00001100b
-00101101b ^ 00100010b = 00001111b
-00101101b ^ 00100011b = 00001110b
-00101101b ^ 00100100b = 00001001b
-00101101b ^ 00100101b = 00001000b
-00101101b ^ 00100110b = 00001011b
-00101101b ^ 00100111b = 00001010b
-00101101b ^ 00101000b = 00000101b
-00101101b ^ 00101001b = 00000100b
-00101101b ^ 00101010b = 00000111b
-00101101b ^ 00101011b = 00000110b
-00101101b ^ 00101100b = 00000001b
-00101101b ^ 00101101b = 00000000b
-00101101b ^ 00101110b = 00000011b
-00101101b ^ 00101111b = 00000010b
-00101101b ^ 00110000b = 00011101b
-00101101b ^ 00110001b = 00011100b
-00101101b ^ 00110010b = 00011111b
-00101101b ^ 00110011b = 00011110b
-00101101b ^ 00110100b = 00011001b
-00101101b ^ 00110101b = 00011000b
-00101101b ^ 00110110b = 00011011b
-00101101b ^ 00110111b = 00011010b
-00101101b ^ 00111000b = 00010101b
-00101101b ^ 00111001b = 00010100b
-00101101b ^ 00111010b = 00010111b
-00101101b ^ 00111011b = 00010110b
-00101101b ^ 00111100b = 00010001b
-00101101b ^ 00111101b = 00010000b
-00101101b ^ 00111110b = 00010011b
-00101101b ^ 00111111b = 00010010b
-00101101b ^ 01000000b = 01101101b
-00101101b ^ 01000001b = 01101100b
-00101101b ^ 01000010b = 01101111b
-00101101b ^ 01000011b = 01101110b
-00101101b ^ 01000100b = 01101001b
-00101101b ^ 01000101b = 01101000b
-00101101b ^ 01000110b = 01101011b
-00101101b ^ 01000111b = 01101010b
-00101101b ^ 01001000b = 01100101b
-00101101b ^ 01001001b = 01100100b
-00101101b ^ 01001010b = 01100111b
-00101101b ^ 01001011b = 01100110b
-00101101b ^ 01001100b = 01100001b
-00101101b ^ 01001101b = 01100000b
-00101101b ^ 01001110b = 01100011b
-00101101b ^ 01001111b = 01100010b
-00101101b ^ 01010000b = 01111101b
-00101101b ^ 01010001b = 01111100b
-00101101b ^ 01010010b = 01111111b
-00101101b ^ 01010011b = 01111110b
-00101101b ^ 01010100b = 01111001b
-00101101b ^ 01010101b = 01111000b
-00101101b ^ 01010110b = 01111011b
-00101101b ^ 01010111b = 01111010b
-00101101b ^ 01011000b = 01110101b
-00101101b ^ 01011001b = 01110100b
-00101101b ^ 01011010b = 01110111b
-00101101b ^ 01011011b = 01110110b
-00101101b ^ 01011100b = 01110001b
-00101101b ^ 01011101b = 01110000b
-00101101b ^ 01011110b = 01110011b
-00101101b ^ 01011111b = 01110010b
-00101101b ^ 01100000b = 01001101b
-00101101b ^ 01100001b = 01001100b
-00101101b ^ 01100010b = 01001111b
-00101101b ^ 01100011b = 01001110b
-00101101b ^ 01100100b = 01001001b
-00101101b ^ 01100101b = 01001000b
-00101101b ^ 01100110b = 01001011b
-00101101b ^ 01100111b = 01001010b
-00101101b ^ 01101000b = 01000101b
-00101101b ^ 01101001b = 01000100b
-00101101b ^ 01101010b = 01000111b
-00101101b ^ 01101011b = 01000110b
-00101101b ^ 01101100b = 01000001b
-00101101b ^ 01101101b = 01000000b
-00101101b ^ 01101110b = 01000011b
-00101101b ^ 01101111b = 01000010b
-00101101b ^ 01110000b = 01011101b
-00101101b ^ 01110001b = 01011100b
-00101101b ^ 01110010b = 01011111b
-00101101b ^ 01110011b = 01011110b
-00101101b ^ 01110100b = 01011001b
-00101101b ^ 01110101b = 01011000b
-00101101b ^ 01110110b = 01011011b
-00101101b ^ 01110111b = 01011010b
-00101101b ^ 01111000b = 01010101b
-00101101b ^ 01111001b = 01010100b
-00101101b ^ 01111010b = 01010111b
-00101101b ^ 01111011b = 01010110b
-00101101b ^ 01111100b = 01010001b
-00101101b ^ 01111101b = 01010000b
-00101101b ^ 01111110b = 01010011b
-00101110b ^ 10000000b = 10101110b
-00101110b ^ 10000001b = 10101111b
-00101110b ^ 10000010b = 10101100b
-00101110b ^ 10000011b = 10101101b
-00101110b ^ 10000100b = 10101010b
-00101110b ^ 10000101b = 10101011b
-00101110b ^ 10000110b = 10101000b
-00101110b ^ 10000111b = 10101001b
-00101110b ^ 10001000b = 10100110b
-00101110b ^ 10001001b = 10100111b
-00101110b ^ 10001010b = 10100100b
-00101110b ^ 10001011b = 10100101b
-00101110b ^ 10001100b = 10100010b
-00101110b ^ 10001101b = 10100011b
-00101110b ^ 10001110b = 10100000b
-00101110b ^ 10001111b = 10100001b
-00101110b ^ 10010000b = 10111110b
-00101110b ^ 10010001b = 10111111b
-00101110b ^ 10010010b = 10111100b
-00101110b ^ 10010011b = 10111101b
-00101110b ^ 10010100b = 10111010b
-00101110b ^ 10010101b = 10111011b
-00101110b ^ 10010110b = 10111000b
-00101110b ^ 10010111b = 10111001b
-00101110b ^ 10011000b = 10110110b
-00101110b ^ 10011001b = 10110111b
-00101110b ^ 10011010b = 10110100b
-00101110b ^ 10011011b = 10110101b
-00101110b ^ 10011100b = 10110010b
-00101110b ^ 10011101b = 10110011b
-00101110b ^ 10011110b = 10110000b
-00101110b ^ 10011111b = 10110001b
-00101110b ^ 10100000b = 10001110b
-00101110b ^ 10100001b = 10001111b
-00101110b ^ 10100010b = 10001100b
-00101110b ^ 10100011b = 10001101b
-00101110b ^ 10100100b = 10001010b
-00101110b ^ 10100101b = 10001011b
-00101110b ^ 10100110b = 10001000b
-00101110b ^ 10100111b = 10001001b
-00101110b ^ 10101000b = 10000110b
-00101110b ^ 10101001b = 10000111b
-00101110b ^ 10101010b = 10000100b
-00101110b ^ 10101011b = 10000101b
-00101110b ^ 10101100b = 10000010b
-00101110b ^ 10101101b = 10000011b
-00101110b ^ 10101110b = 10000000b
-00101110b ^ 10101111b = 10000001b
-00101110b ^ 10110000b = 10011110b
-00101110b ^ 10110001b = 10011111b
-00101110b ^ 10110010b = 10011100b
-00101110b ^ 10110011b = 10011101b
-00101110b ^ 10110100b = 10011010b
-00101110b ^ 10110101b = 10011011b
-00101110b ^ 10110110b = 10011000b
-00101110b ^ 10110111b = 10011001b
-00101110b ^ 10111000b = 10010110b
-00101110b ^ 10111001b = 10010111b
-00101110b ^ 10111010b = 10010100b
-00101110b ^ 10111011b = 10010101b
-00101110b ^ 10111100b = 10010010b
-00101110b ^ 10111101b = 10010011b
-00101110b ^ 10111110b = 10010000b
-00101110b ^ 10111111b = 10010001b
-00101110b ^ 11000000b = 11101110b
-00101110b ^ 11000001b = 11101111b
-00101110b ^ 11000010b = 11101100b
-00101110b ^ 11000011b = 11101101b
-00101110b ^ 11000100b = 11101010b
-00101110b ^ 11000101b = 11101011b
-00101110b ^ 11000110b = 11101000b
-00101110b ^ 11000111b = 11101001b
-00101110b ^ 11001000b = 11100110b
-00101110b ^ 11001001b = 11100111b
-00101110b ^ 11001010b = 11100100b
-00101110b ^ 11001011b = 11100101b
-00101110b ^ 11001100b = 11100010b
-00101110b ^ 11001101b = 11100011b
-00101110b ^ 11001110b = 11100000b
-00101110b ^ 11001111b = 11100001b
-00101110b ^ 11010000b = 11111110b
-00101110b ^ 11010001b = 11111111b
-00101110b ^ 11010010b = 11111100b
-00101110b ^ 11010011b = 11111101b
-00101110b ^ 11010100b = 11111010b
-00101110b ^ 11010101b = 11111011b
-00101110b ^ 11010110b = 11111000b
-00101110b ^ 11010111b = 11111001b
-00101110b ^ 11011000b = 11110110b
-00101110b ^ 11011001b = 11110111b
-00101110b ^ 11011010b = 11110100b
-00101110b ^ 11011011b = 11110101b
-00101110b ^ 11011100b = 11110010b
-00101110b ^ 11011101b = 11110011b
-00101110b ^ 11011110b = 11110000b
-00101110b ^ 11011111b = 11110001b
-00101110b ^ 11100000b = 11001110b
-00101110b ^ 11100001b = 11001111b
-00101110b ^ 11100010b = 11001100b
-00101110b ^ 11100011b = 11001101b
-00101110b ^ 11100100b = 11001010b
-00101110b ^ 11100101b = 11001011b
-00101110b ^ 11100110b = 11001000b
-00101110b ^ 11100111b = 11001001b
-00101110b ^ 11101000b = 11000110b
-00101110b ^ 11101001b = 11000111b
-00101110b ^ 11101010b = 11000100b
-00101110b ^ 11101011b = 11000101b
-00101110b ^ 11101100b = 11000010b
-00101110b ^ 11101101b = 11000011b
-00101110b ^ 11101110b = 11000000b
-00101110b ^ 11101111b = 11000001b
-00101110b ^ 11110000b = 11011110b
-00101110b ^ 11110001b = 11011111b
-00101110b ^ 11110010b = 11011100b
-00101110b ^ 11110011b = 11011101b
-00101110b ^ 11110100b = 11011010b
-00101110b ^ 11110101b = 11011011b
-00101110b ^ 11110110b = 11011000b
-00101110b ^ 11110111b = 11011001b
-00101110b ^ 11111000b = 11010110b
-00101110b ^ 11111001b = 11010111b
-00101110b ^ 11111010b = 11010100b
-00101110b ^ 11111011b = 11010101b
-00101110b ^ 11111100b = 11010010b
-00101110b ^ 11111101b = 11010011b
-00101110b ^ 11111110b = 11010000b
-00101110b ^ 11111111b = 11010001b
-00101110b ^ 00000000b = 00101110b
-00101110b ^ 00000001b = 00101111b
-00101110b ^ 00000010b = 00101100b
-00101110b ^ 00000011b = 00101101b
-00101110b ^ 00000100b = 00101010b
-00101110b ^ 00000101b = 00101011b
-00101110b ^ 00000110b = 00101000b
-00101110b ^ 00000111b = 00101001b
-00101110b ^ 00001000b = 00100110b
-00101110b ^ 00001001b = 00100111b
-00101110b ^ 00001010b = 00100100b
-00101110b ^ 00001011b = 00100101b
-00101110b ^ 00001100b = 00100010b
-00101110b ^ 00001101b = 00100011b
-00101110b ^ 00001110b = 00100000b
-00101110b ^ 00001111b = 00100001b
-00101110b ^ 00010000b = 00111110b
-00101110b ^ 00010001b = 00111111b
-00101110b ^ 00010010b = 00111100b
-00101110b ^ 00010011b = 00111101b
-00101110b ^ 00010100b = 00111010b
-00101110b ^ 00010101b = 00111011b
-00101110b ^ 00010110b = 00111000b
-00101110b ^ 00010111b = 00111001b
-00101110b ^ 00011000b = 00110110b
-00101110b ^ 00011001b = 00110111b
-00101110b ^ 00011010b = 00110100b
-00101110b ^ 00011011b = 00110101b
-00101110b ^ 00011100b = 00110010b
-00101110b ^ 00011101b = 00110011b
-00101110b ^ 00011110b = 00110000b
-00101110b ^ 00011111b = 00110001b
-00101110b ^ 00100000b = 00001110b
-00101110b ^ 00100001b = 00001111b
-00101110b ^ 00100010b = 00001100b
-00101110b ^ 00100011b = 00001101b
-00101110b ^ 00100100b = 00001010b
-00101110b ^ 00100101b = 00001011b
-00101110b ^ 00100110b = 00001000b
-00101110b ^ 00100111b = 00001001b
-00101110b ^ 00101000b = 00000110b
-00101110b ^ 00101001b = 00000111b
-00101110b ^ 00101010b = 00000100b
-00101110b ^ 00101011b = 00000101b
-00101110b ^ 00101100b = 00000010b
-00101110b ^ 00101101b = 00000011b
-00101110b ^ 00101110b = 00000000b
-00101110b ^ 00101111b = 00000001b
-00101110b ^ 00110000b = 00011110b
-00101110b ^ 00110001b = 00011111b
-00101110b ^ 00110010b = 00011100b
-00101110b ^ 00110011b = 00011101b
-00101110b ^ 00110100b = 00011010b
-00101110b ^ 00110101b = 00011011b
-00101110b ^ 00110110b = 00011000b
-00101110b ^ 00110111b = 00011001b
-00101110b ^ 00111000b = 00010110b
-00101110b ^ 00111001b = 00010111b
-00101110b ^ 00111010b = 00010100b
-00101110b ^ 00111011b = 00010101b
-00101110b ^ 00111100b = 00010010b
-00101110b ^ 00111101b = 00010011b
-00101110b ^ 00111110b = 00010000b
-00101110b ^ 00111111b = 00010001b
-00101110b ^ 01000000b = 01101110b
-00101110b ^ 01000001b = 01101111b
-00101110b ^ 01000010b = 01101100b
-00101110b ^ 01000011b = 01101101b
-00101110b ^ 01000100b = 01101010b
-00101110b ^ 01000101b = 01101011b
-00101110b ^ 01000110b = 01101000b
-00101110b ^ 01000111b = 01101001b
-00101110b ^ 01001000b = 01100110b
-00101110b ^ 01001001b = 01100111b
-00101110b ^ 01001010b = 01100100b
-00101110b ^ 01001011b = 01100101b
-00101110b ^ 01001100b = 01100010b
-00101110b ^ 01001101b = 01100011b
-00101110b ^ 01001110b = 01100000b
-00101110b ^ 01001111b = 01100001b
-00101110b ^ 01010000b = 01111110b
-00101110b ^ 01010001b = 01111111b
-00101110b ^ 01010010b = 01111100b
-00101110b ^ 01010011b = 01111101b
-00101110b ^ 01010100b = 01111010b
-00101110b ^ 01010101b = 01111011b
-00101110b ^ 01010110b = 01111000b
-00101110b ^ 01010111b = 01111001b
-00101110b ^ 01011000b = 01110110b
-00101110b ^ 01011001b = 01110111b
-00101110b ^ 01011010b = 01110100b
-00101110b ^ 01011011b = 01110101b
-00101110b ^ 01011100b = 01110010b
-00101110b ^ 01011101b = 01110011b
-00101110b ^ 01011110b = 01110000b
-00101110b ^ 01011111b = 01110001b
-00101110b ^ 01100000b = 01001110b
-00101110b ^ 01100001b = 01001111b
-00101110b ^ 01100010b = 01001100b
-00101110b ^ 01100011b = 01001101b
-00101110b ^ 01100100b = 01001010b
-00101110b ^ 01100101b = 01001011b
-00101110b ^ 01100110b = 01001000b
-00101110b ^ 01100111b = 01001001b
-00101110b ^ 01101000b = 01000110b
-00101110b ^ 01101001b = 01000111b
-00101110b ^ 01101010b = 01000100b
-00101110b ^ 01101011b = 01000101b
-00101110b ^ 01101100b = 01000010b
-00101110b ^ 01101101b = 01000011b
-00101110b ^ 01101110b = 01000000b
-00101110b ^ 01101111b = 01000001b
-00101110b ^ 01110000b = 01011110b
-00101110b ^ 01110001b = 01011111b
-00101110b ^ 01110010b = 01011100b
-00101110b ^ 01110011b = 01011101b
-00101110b ^ 01110100b = 01011010b
-00101110b ^ 01110101b = 01011011b
-00101110b ^ 01110110b = 01011000b
-00101110b ^ 01110111b = 01011001b
-00101110b ^ 01111000b = 01010110b
-00101110b ^ 01111001b = 01010111b
-00101110b ^ 01111010b = 01010100b
-00101110b ^ 01111011b = 01010101b
-00101110b ^ 01111100b = 01010010b
-00101110b ^ 01111101b = 01010011b
-00101110b ^ 01111110b = 01010000b
-00101111b ^ 10000000b = 10101111b
-00101111b ^ 10000001b = 10101110b
-00101111b ^ 10000010b = 10101101b
-00101111b ^ 10000011b = 10101100b
-00101111b ^ 10000100b = 10101011b
-00101111b ^ 10000101b = 10101010b
-00101111b ^ 10000110b = 10101001b
-00101111b ^ 10000111b = 10101000b
-00101111b ^ 10001000b = 10100111b
-00101111b ^ 10001001b = 10100110b
-00101111b ^ 10001010b = 10100101b
-00101111b ^ 10001011b = 10100100b
-00101111b ^ 10001100b = 10100011b
-00101111b ^ 10001101b = 10100010b
-00101111b ^ 10001110b = 10100001b
-00101111b ^ 10001111b = 10100000b
-00101111b ^ 10010000b = 10111111b
-00101111b ^ 10010001b = 10111110b
-00101111b ^ 10010010b = 10111101b
-00101111b ^ 10010011b = 10111100b
-00101111b ^ 10010100b = 10111011b
-00101111b ^ 10010101b = 10111010b
-00101111b ^ 10010110b = 10111001b
-00101111b ^ 10010111b = 10111000b
-00101111b ^ 10011000b = 10110111b
-00101111b ^ 10011001b = 10110110b
-00101111b ^ 10011010b = 10110101b
-00101111b ^ 10011011b = 10110100b
-00101111b ^ 10011100b = 10110011b
-00101111b ^ 10011101b = 10110010b
-00101111b ^ 10011110b = 10110001b
-00101111b ^ 10011111b = 10110000b
-00101111b ^ 10100000b = 10001111b
-00101111b ^ 10100001b = 10001110b
-00101111b ^ 10100010b = 10001101b
-00101111b ^ 10100011b = 10001100b
-00101111b ^ 10100100b = 10001011b
-00101111b ^ 10100101b = 10001010b
-00101111b ^ 10100110b = 10001001b
-00101111b ^ 10100111b = 10001000b
-00101111b ^ 10101000b = 10000111b
-00101111b ^ 10101001b = 10000110b
-00101111b ^ 10101010b = 10000101b
-00101111b ^ 10101011b = 10000100b
-00101111b ^ 10101100b = 10000011b
-00101111b ^ 10101101b = 10000010b
-00101111b ^ 10101110b = 10000001b
-00101111b ^ 10101111b = 10000000b
-00101111b ^ 10110000b = 10011111b
-00101111b ^ 10110001b = 10011110b
-00101111b ^ 10110010b = 10011101b
-00101111b ^ 10110011b = 10011100b
-00101111b ^ 10110100b = 10011011b
-00101111b ^ 10110101b = 10011010b
-00101111b ^ 10110110b = 10011001b
-00101111b ^ 10110111b = 10011000b
-00101111b ^ 10111000b = 10010111b
-00101111b ^ 10111001b = 10010110b
-00101111b ^ 10111010b = 10010101b
-00101111b ^ 10111011b = 10010100b
-00101111b ^ 10111100b = 10010011b
-00101111b ^ 10111101b = 10010010b
-00101111b ^ 10111110b = 10010001b
-00101111b ^ 10111111b = 10010000b
-00101111b ^ 11000000b = 11101111b
-00101111b ^ 11000001b = 11101110b
-00101111b ^ 11000010b = 11101101b
-00101111b ^ 11000011b = 11101100b
-00101111b ^ 11000100b = 11101011b
-00101111b ^ 11000101b = 11101010b
-00101111b ^ 11000110b = 11101001b
-00101111b ^ 11000111b = 11101000b
-00101111b ^ 11001000b = 11100111b
-00101111b ^ 11001001b = 11100110b
-00101111b ^ 11001010b = 11100101b
-00101111b ^ 11001011b = 11100100b
-00101111b ^ 11001100b = 11100011b
-00101111b ^ 11001101b = 11100010b
-00101111b ^ 11001110b = 11100001b
-00101111b ^ 11001111b = 11100000b
-00101111b ^ 11010000b = 11111111b
-00101111b ^ 11010001b = 11111110b
-00101111b ^ 11010010b = 11111101b
-00101111b ^ 11010011b = 11111100b
-00101111b ^ 11010100b = 11111011b
-00101111b ^ 11010101b = 11111010b
-00101111b ^ 11010110b = 11111001b
-00101111b ^ 11010111b = 11111000b
-00101111b ^ 11011000b = 11110111b
-00101111b ^ 11011001b = 11110110b
-00101111b ^ 11011010b = 11110101b
-00101111b ^ 11011011b = 11110100b
-00101111b ^ 11011100b = 11110011b
-00101111b ^ 11011101b = 11110010b
-00101111b ^ 11011110b = 11110001b
-00101111b ^ 11011111b = 11110000b
-00101111b ^ 11100000b = 11001111b
-00101111b ^ 11100001b = 11001110b
-00101111b ^ 11100010b = 11001101b
-00101111b ^ 11100011b = 11001100b
-00101111b ^ 11100100b = 11001011b
-00101111b ^ 11100101b = 11001010b
-00101111b ^ 11100110b = 11001001b
-00101111b ^ 11100111b = 11001000b
-00101111b ^ 11101000b = 11000111b
-00101111b ^ 11101001b = 11000110b
-00101111b ^ 11101010b = 11000101b
-00101111b ^ 11101011b = 11000100b
-00101111b ^ 11101100b = 11000011b
-00101111b ^ 11101101b = 11000010b
-00101111b ^ 11101110b = 11000001b
-00101111b ^ 11101111b = 11000000b
-00101111b ^ 11110000b = 11011111b
-00101111b ^ 11110001b = 11011110b
-00101111b ^ 11110010b = 11011101b
-00101111b ^ 11110011b = 11011100b
-00101111b ^ 11110100b = 11011011b
-00101111b ^ 11110101b = 11011010b
-00101111b ^ 11110110b = 11011001b
-00101111b ^ 11110111b = 11011000b
-00101111b ^ 11111000b = 11010111b
-00101111b ^ 11111001b = 11010110b
-00101111b ^ 11111010b = 11010101b
-00101111b ^ 11111011b = 11010100b
-00101111b ^ 11111100b = 11010011b
-00101111b ^ 11111101b = 11010010b
-00101111b ^ 11111110b = 11010001b
-00101111b ^ 11111111b = 11010000b
-00101111b ^ 00000000b = 00101111b
-00101111b ^ 00000001b = 00101110b
-00101111b ^ 00000010b = 00101101b
-00101111b ^ 00000011b = 00101100b
-00101111b ^ 00000100b = 00101011b
-00101111b ^ 00000101b = 00101010b
-00101111b ^ 00000110b = 00101001b
-00101111b ^ 00000111b = 00101000b
-00101111b ^ 00001000b = 00100111b
-00101111b ^ 00001001b = 00100110b
-00101111b ^ 00001010b = 00100101b
-00101111b ^ 00001011b = 00100100b
-00101111b ^ 00001100b = 00100011b
-00101111b ^ 00001101b = 00100010b
-00101111b ^ 00001110b = 00100001b
-00101111b ^ 00001111b = 00100000b
-00101111b ^ 00010000b = 00111111b
-00101111b ^ 00010001b = 00111110b
-00101111b ^ 00010010b = 00111101b
-00101111b ^ 00010011b = 00111100b
-00101111b ^ 00010100b = 00111011b
-00101111b ^ 00010101b = 00111010b
-00101111b ^ 00010110b = 00111001b
-00101111b ^ 00010111b = 00111000b
-00101111b ^ 00011000b = 00110111b
-00101111b ^ 00011001b = 00110110b
-00101111b ^ 00011010b = 00110101b
-00101111b ^ 00011011b = 00110100b
-00101111b ^ 00011100b = 00110011b
-00101111b ^ 00011101b = 00110010b
-00101111b ^ 00011110b = 00110001b
-00101111b ^ 00011111b = 00110000b
-00101111b ^ 00100000b = 00001111b
-00101111b ^ 00100001b = 00001110b
-00101111b ^ 00100010b = 00001101b
-00101111b ^ 00100011b = 00001100b
-00101111b ^ 00100100b = 00001011b
-00101111b ^ 00100101b = 00001010b
-00101111b ^ 00100110b = 00001001b
-00101111b ^ 00100111b = 00001000b
-00101111b ^ 00101000b = 00000111b
-00101111b ^ 00101001b = 00000110b
-00101111b ^ 00101010b = 00000101b
-00101111b ^ 00101011b = 00000100b
-00101111b ^ 00101100b = 00000011b
-00101111b ^ 00101101b = 00000010b
-00101111b ^ 00101110b = 00000001b
-00101111b ^ 00101111b = 00000000b
-00101111b ^ 00110000b = 00011111b
-00101111b ^ 00110001b = 00011110b
-00101111b ^ 00110010b = 00011101b
-00101111b ^ 00110011b = 00011100b
-00101111b ^ 00110100b = 00011011b
-00101111b ^ 00110101b = 00011010b
-00101111b ^ 00110110b = 00011001b
-00101111b ^ 00110111b = 00011000b
-00101111b ^ 00111000b = 00010111b
-00101111b ^ 00111001b = 00010110b
-00101111b ^ 00111010b = 00010101b
-00101111b ^ 00111011b = 00010100b
-00101111b ^ 00111100b = 00010011b
-00101111b ^ 00111101b = 00010010b
-00101111b ^ 00111110b = 00010001b
-00101111b ^ 00111111b = 00010000b
-00101111b ^ 01000000b = 01101111b
-00101111b ^ 01000001b = 01101110b
-00101111b ^ 01000010b = 01101101b
-00101111b ^ 01000011b = 01101100b
-00101111b ^ 01000100b = 01101011b
-00101111b ^ 01000101b = 01101010b
-00101111b ^ 01000110b = 01101001b
-00101111b ^ 01000111b = 01101000b
-00101111b ^ 01001000b = 01100111b
-00101111b ^ 01001001b = 01100110b
-00101111b ^ 01001010b = 01100101b
-00101111b ^ 01001011b = 01100100b
-00101111b ^ 01001100b = 01100011b
-00101111b ^ 01001101b = 01100010b
-00101111b ^ 01001110b = 01100001b
-00101111b ^ 01001111b = 01100000b
-00101111b ^ 01010000b = 01111111b
-00101111b ^ 01010001b = 01111110b
-00101111b ^ 01010010b = 01111101b
-00101111b ^ 01010011b = 01111100b
-00101111b ^ 01010100b = 01111011b
-00101111b ^ 01010101b = 01111010b
-00101111b ^ 01010110b = 01111001b
-00101111b ^ 01010111b = 01111000b
-00101111b ^ 01011000b = 01110111b
-00101111b ^ 01011001b = 01110110b
-00101111b ^ 01011010b = 01110101b
-00101111b ^ 01011011b = 01110100b
-00101111b ^ 01011100b = 01110011b
-00101111b ^ 01011101b = 01110010b
-00101111b ^ 01011110b = 01110001b
-00101111b ^ 01011111b = 01110000b
-00101111b ^ 01100000b = 01001111b
-00101111b ^ 01100001b = 01001110b
-00101111b ^ 01100010b = 01001101b
-00101111b ^ 01100011b = 01001100b
-00101111b ^ 01100100b = 01001011b
-00101111b ^ 01100101b = 01001010b
-00101111b ^ 01100110b = 01001001b
-00101111b ^ 01100111b = 01001000b
-00101111b ^ 01101000b = 01000111b
-00101111b ^ 01101001b = 01000110b
-00101111b ^ 01101010b = 01000101b
-00101111b ^ 01101011b = 01000100b
-00101111b ^ 01101100b = 01000011b
-00101111b ^ 01101101b = 01000010b
-00101111b ^ 01101110b = 01000001b
-00101111b ^ 01101111b = 01000000b
-00101111b ^ 01110000b = 01011111b
-00101111b ^ 01110001b = 01011110b
-00101111b ^ 01110010b = 01011101b
-00101111b ^ 01110011b = 01011100b
-00101111b ^ 01110100b = 01011011b
-00101111b ^ 01110101b = 01011010b
-00101111b ^ 01110110b = 01011001b
-00101111b ^ 01110111b = 01011000b
-00101111b ^ 01111000b = 01010111b
-00101111b ^ 01111001b = 01010110b
-00101111b ^ 01111010b = 01010101b
-00101111b ^ 01111011b = 01010100b
-00101111b ^ 01111100b = 01010011b
-00101111b ^ 01111101b = 01010010b
-00101111b ^ 01111110b = 01010001b
-00110000b ^ 10000000b = 10110000b
-00110000b ^ 10000001b = 10110001b
-00110000b ^ 10000010b = 10110010b
-00110000b ^ 10000011b = 10110011b
-00110000b ^ 10000100b = 10110100b
-00110000b ^ 10000101b = 10110101b
-00110000b ^ 10000110b = 10110110b
-00110000b ^ 10000111b = 10110111b
-00110000b ^ 10001000b = 10111000b
-00110000b ^ 10001001b = 10111001b
-00110000b ^ 10001010b = 10111010b
-00110000b ^ 10001011b = 10111011b
-00110000b ^ 10001100b = 10111100b
-00110000b ^ 10001101b = 10111101b
-00110000b ^ 10001110b = 10111110b
-00110000b ^ 10001111b = 10111111b
-00110000b ^ 10010000b = 10100000b
-00110000b ^ 10010001b = 10100001b
-00110000b ^ 10010010b = 10100010b
-00110000b ^ 10010011b = 10100011b
-00110000b ^ 10010100b = 10100100b
-00110000b ^ 10010101b = 10100101b
-00110000b ^ 10010110b = 10100110b
-00110000b ^ 10010111b = 10100111b
-00110000b ^ 10011000b = 10101000b
-00110000b ^ 10011001b = 10101001b
-00110000b ^ 10011010b = 10101010b
-00110000b ^ 10011011b = 10101011b
-00110000b ^ 10011100b = 10101100b
-00110000b ^ 10011101b = 10101101b
-00110000b ^ 10011110b = 10101110b
-00110000b ^ 10011111b = 10101111b
-00110000b ^ 10100000b = 10010000b
-00110000b ^ 10100001b = 10010001b
-00110000b ^ 10100010b = 10010010b
-00110000b ^ 10100011b = 10010011b
-00110000b ^ 10100100b = 10010100b
-00110000b ^ 10100101b = 10010101b
-00110000b ^ 10100110b = 10010110b
-00110000b ^ 10100111b = 10010111b
-00110000b ^ 10101000b = 10011000b
-00110000b ^ 10101001b = 10011001b
-00110000b ^ 10101010b = 10011010b
-00110000b ^ 10101011b = 10011011b
-00110000b ^ 10101100b = 10011100b
-00110000b ^ 10101101b = 10011101b
-00110000b ^ 10101110b = 10011110b
-00110000b ^ 10101111b = 10011111b
-00110000b ^ 10110000b = 10000000b
-00110000b ^ 10110001b = 10000001b
-00110000b ^ 10110010b = 10000010b
-00110000b ^ 10110011b = 10000011b
-00110000b ^ 10110100b = 10000100b
-00110000b ^ 10110101b = 10000101b
-00110000b ^ 10110110b = 10000110b
-00110000b ^ 10110111b = 10000111b
-00110000b ^ 10111000b = 10001000b
-00110000b ^ 10111001b = 10001001b
-00110000b ^ 10111010b = 10001010b
-00110000b ^ 10111011b = 10001011b
-00110000b ^ 10111100b = 10001100b
-00110000b ^ 10111101b = 10001101b
-00110000b ^ 10111110b = 10001110b
-00110000b ^ 10111111b = 10001111b
-00110000b ^ 11000000b = 11110000b
-00110000b ^ 11000001b = 11110001b
-00110000b ^ 11000010b = 11110010b
-00110000b ^ 11000011b = 11110011b
-00110000b ^ 11000100b = 11110100b
-00110000b ^ 11000101b = 11110101b
-00110000b ^ 11000110b = 11110110b
-00110000b ^ 11000111b = 11110111b
-00110000b ^ 11001000b = 11111000b
-00110000b ^ 11001001b = 11111001b
-00110000b ^ 11001010b = 11111010b
-00110000b ^ 11001011b = 11111011b
-00110000b ^ 11001100b = 11111100b
-00110000b ^ 11001101b = 11111101b
-00110000b ^ 11001110b = 11111110b
-00110000b ^ 11001111b = 11111111b
-00110000b ^ 11010000b = 11100000b
-00110000b ^ 11010001b = 11100001b
-00110000b ^ 11010010b = 11100010b
-00110000b ^ 11010011b = 11100011b
-00110000b ^ 11010100b = 11100100b
-00110000b ^ 11010101b = 11100101b
-00110000b ^ 11010110b = 11100110b
-00110000b ^ 11010111b = 11100111b
-00110000b ^ 11011000b = 11101000b
-00110000b ^ 11011001b = 11101001b
-00110000b ^ 11011010b = 11101010b
-00110000b ^ 11011011b = 11101011b
-00110000b ^ 11011100b = 11101100b
-00110000b ^ 11011101b = 11101101b
-00110000b ^ 11011110b = 11101110b
-00110000b ^ 11011111b = 11101111b
-00110000b ^ 11100000b = 11010000b
-00110000b ^ 11100001b = 11010001b
-00110000b ^ 11100010b = 11010010b
-00110000b ^ 11100011b = 11010011b
-00110000b ^ 11100100b = 11010100b
-00110000b ^ 11100101b = 11010101b
-00110000b ^ 11100110b = 11010110b
-00110000b ^ 11100111b = 11010111b
-00110000b ^ 11101000b = 11011000b
-00110000b ^ 11101001b = 11011001b
-00110000b ^ 11101010b = 11011010b
-00110000b ^ 11101011b = 11011011b
-00110000b ^ 11101100b = 11011100b
-00110000b ^ 11101101b = 11011101b
-00110000b ^ 11101110b = 11011110b
-00110000b ^ 11101111b = 11011111b
-00110000b ^ 11110000b = 11000000b
-00110000b ^ 11110001b = 11000001b
-00110000b ^ 11110010b = 11000010b
-00110000b ^ 11110011b = 11000011b
-00110000b ^ 11110100b = 11000100b
-00110000b ^ 11110101b = 11000101b
-00110000b ^ 11110110b = 11000110b
-00110000b ^ 11110111b = 11000111b
-00110000b ^ 11111000b = 11001000b
-00110000b ^ 11111001b = 11001001b
-00110000b ^ 11111010b = 11001010b
-00110000b ^ 11111011b = 11001011b
-00110000b ^ 11111100b = 11001100b
-00110000b ^ 11111101b = 11001101b
-00110000b ^ 11111110b = 11001110b
-00110000b ^ 11111111b = 11001111b
-00110000b ^ 00000000b = 00110000b
-00110000b ^ 00000001b = 00110001b
-00110000b ^ 00000010b = 00110010b
-00110000b ^ 00000011b = 00110011b
-00110000b ^ 00000100b = 00110100b
-00110000b ^ 00000101b = 00110101b
-00110000b ^ 00000110b = 00110110b
-00110000b ^ 00000111b = 00110111b
-00110000b ^ 00001000b = 00111000b
-00110000b ^ 00001001b = 00111001b
-00110000b ^ 00001010b = 00111010b
-00110000b ^ 00001011b = 00111011b
-00110000b ^ 00001100b = 00111100b
-00110000b ^ 00001101b = 00111101b
-00110000b ^ 00001110b = 00111110b
-00110000b ^ 00001111b = 00111111b
-00110000b ^ 00010000b = 00100000b
-00110000b ^ 00010001b = 00100001b
-00110000b ^ 00010010b = 00100010b
-00110000b ^ 00010011b = 00100011b
-00110000b ^ 00010100b = 00100100b
-00110000b ^ 00010101b = 00100101b
-00110000b ^ 00010110b = 00100110b
-00110000b ^ 00010111b = 00100111b
-00110000b ^ 00011000b = 00101000b
-00110000b ^ 00011001b = 00101001b
-00110000b ^ 00011010b = 00101010b
-00110000b ^ 00011011b = 00101011b
-00110000b ^ 00011100b = 00101100b
-00110000b ^ 00011101b = 00101101b
-00110000b ^ 00011110b = 00101110b
-00110000b ^ 00011111b = 00101111b
-00110000b ^ 00100000b = 00010000b
-00110000b ^ 00100001b = 00010001b
-00110000b ^ 00100010b = 00010010b
-00110000b ^ 00100011b = 00010011b
-00110000b ^ 00100100b = 00010100b
-00110000b ^ 00100101b = 00010101b
-00110000b ^ 00100110b = 00010110b
-00110000b ^ 00100111b = 00010111b
-00110000b ^ 00101000b = 00011000b
-00110000b ^ 00101001b = 00011001b
-00110000b ^ 00101010b = 00011010b
-00110000b ^ 00101011b = 00011011b
-00110000b ^ 00101100b = 00011100b
-00110000b ^ 00101101b = 00011101b
-00110000b ^ 00101110b = 00011110b
-00110000b ^ 00101111b = 00011111b
-00110000b ^ 00110000b = 00000000b
-00110000b ^ 00110001b = 00000001b
-00110000b ^ 00110010b = 00000010b
-00110000b ^ 00110011b = 00000011b
-00110000b ^ 00110100b = 00000100b
-00110000b ^ 00110101b = 00000101b
-00110000b ^ 00110110b = 00000110b
-00110000b ^ 00110111b = 00000111b
-00110000b ^ 00111000b = 00001000b
-00110000b ^ 00111001b = 00001001b
-00110000b ^ 00111010b = 00001010b
-00110000b ^ 00111011b = 00001011b
-00110000b ^ 00111100b = 00001100b
-00110000b ^ 00111101b = 00001101b
-00110000b ^ 00111110b = 00001110b
-00110000b ^ 00111111b = 00001111b
-00110000b ^ 01000000b = 01110000b
-00110000b ^ 01000001b = 01110001b
-00110000b ^ 01000010b = 01110010b
-00110000b ^ 01000011b = 01110011b
-00110000b ^ 01000100b = 01110100b
-00110000b ^ 01000101b = 01110101b
-00110000b ^ 01000110b = 01110110b
-00110000b ^ 01000111b = 01110111b
-00110000b ^ 01001000b = 01111000b
-00110000b ^ 01001001b = 01111001b
-00110000b ^ 01001010b = 01111010b
-00110000b ^ 01001011b = 01111011b
-00110000b ^ 01001100b = 01111100b
-00110000b ^ 01001101b = 01111101b
-00110000b ^ 01001110b = 01111110b
-00110000b ^ 01001111b = 01111111b
-00110000b ^ 01010000b = 01100000b
-00110000b ^ 01010001b = 01100001b
-00110000b ^ 01010010b = 01100010b
-00110000b ^ 01010011b = 01100011b
-00110000b ^ 01010100b = 01100100b
-00110000b ^ 01010101b = 01100101b
-00110000b ^ 01010110b = 01100110b
-00110000b ^ 01010111b = 01100111b
-00110000b ^ 01011000b = 01101000b
-00110000b ^ 01011001b = 01101001b
-00110000b ^ 01011010b = 01101010b
-00110000b ^ 01011011b = 01101011b
-00110000b ^ 01011100b = 01101100b
-00110000b ^ 01011101b = 01101101b
-00110000b ^ 01011110b = 01101110b
-00110000b ^ 01011111b = 01101111b
-00110000b ^ 01100000b = 01010000b
-00110000b ^ 01100001b = 01010001b
-00110000b ^ 01100010b = 01010010b
-00110000b ^ 01100011b = 01010011b
-00110000b ^ 01100100b = 01010100b
-00110000b ^ 01100101b = 01010101b
-00110000b ^ 01100110b = 01010110b
-00110000b ^ 01100111b = 01010111b
-00110000b ^ 01101000b = 01011000b
-00110000b ^ 01101001b = 01011001b
-00110000b ^ 01101010b = 01011010b
-00110000b ^ 01101011b = 01011011b
-00110000b ^ 01101100b = 01011100b
-00110000b ^ 01101101b = 01011101b
-00110000b ^ 01101110b = 01011110b
-00110000b ^ 01101111b = 01011111b
-00110000b ^ 01110000b = 01000000b
-00110000b ^ 01110001b = 01000001b
-00110000b ^ 01110010b = 01000010b
-00110000b ^ 01110011b = 01000011b
-00110000b ^ 01110100b = 01000100b
-00110000b ^ 01110101b = 01000101b
-00110000b ^ 01110110b = 01000110b
-00110000b ^ 01110111b = 01000111b
-00110000b ^ 01111000b = 01001000b
-00110000b ^ 01111001b = 01001001b
-00110000b ^ 01111010b = 01001010b
-00110000b ^ 01111011b = 01001011b
-00110000b ^ 01111100b = 01001100b
-00110000b ^ 01111101b = 01001101b
-00110000b ^ 01111110b = 01001110b
-00110001b ^ 10000000b = 10110001b
-00110001b ^ 10000001b = 10110000b
-00110001b ^ 10000010b = 10110011b
-00110001b ^ 10000011b = 10110010b
-00110001b ^ 10000100b = 10110101b
-00110001b ^ 10000101b = 10110100b
-00110001b ^ 10000110b = 10110111b
-00110001b ^ 10000111b = 10110110b
-00110001b ^ 10001000b = 10111001b
-00110001b ^ 10001001b = 10111000b
-00110001b ^ 10001010b = 10111011b
-00110001b ^ 10001011b = 10111010b
-00110001b ^ 10001100b = 10111101b
-00110001b ^ 10001101b = 10111100b
-00110001b ^ 10001110b = 10111111b
-00110001b ^ 10001111b = 10111110b
-00110001b ^ 10010000b = 10100001b
-00110001b ^ 10010001b = 10100000b
-00110001b ^ 10010010b = 10100011b
-00110001b ^ 10010011b = 10100010b
-00110001b ^ 10010100b = 10100101b
-00110001b ^ 10010101b = 10100100b
-00110001b ^ 10010110b = 10100111b
-00110001b ^ 10010111b = 10100110b
-00110001b ^ 10011000b = 10101001b
-00110001b ^ 10011001b = 10101000b
-00110001b ^ 10011010b = 10101011b
-00110001b ^ 10011011b = 10101010b
-00110001b ^ 10011100b = 10101101b
-00110001b ^ 10011101b = 10101100b
-00110001b ^ 10011110b = 10101111b
-00110001b ^ 10011111b = 10101110b
-00110001b ^ 10100000b = 10010001b
-00110001b ^ 10100001b = 10010000b
-00110001b ^ 10100010b = 10010011b
-00110001b ^ 10100011b = 10010010b
-00110001b ^ 10100100b = 10010101b
-00110001b ^ 10100101b = 10010100b
-00110001b ^ 10100110b = 10010111b
-00110001b ^ 10100111b = 10010110b
-00110001b ^ 10101000b = 10011001b
-00110001b ^ 10101001b = 10011000b
-00110001b ^ 10101010b = 10011011b
-00110001b ^ 10101011b = 10011010b
-00110001b ^ 10101100b = 10011101b
-00110001b ^ 10101101b = 10011100b
-00110001b ^ 10101110b = 10011111b
-00110001b ^ 10101111b = 10011110b
-00110001b ^ 10110000b = 10000001b
-00110001b ^ 10110001b = 10000000b
-00110001b ^ 10110010b = 10000011b
-00110001b ^ 10110011b = 10000010b
-00110001b ^ 10110100b = 10000101b
-00110001b ^ 10110101b = 10000100b
-00110001b ^ 10110110b = 10000111b
-00110001b ^ 10110111b = 10000110b
-00110001b ^ 10111000b = 10001001b
-00110001b ^ 10111001b = 10001000b
-00110001b ^ 10111010b = 10001011b
-00110001b ^ 10111011b = 10001010b
-00110001b ^ 10111100b = 10001101b
-00110001b ^ 10111101b = 10001100b
-00110001b ^ 10111110b = 10001111b
-00110001b ^ 10111111b = 10001110b
-00110001b ^ 11000000b = 11110001b
-00110001b ^ 11000001b = 11110000b
-00110001b ^ 11000010b = 11110011b
-00110001b ^ 11000011b = 11110010b
-00110001b ^ 11000100b = 11110101b
-00110001b ^ 11000101b = 11110100b
-00110001b ^ 11000110b = 11110111b
-00110001b ^ 11000111b = 11110110b
-00110001b ^ 11001000b = 11111001b
-00110001b ^ 11001001b = 11111000b
-00110001b ^ 11001010b = 11111011b
-00110001b ^ 11001011b = 11111010b
-00110001b ^ 11001100b = 11111101b
-00110001b ^ 11001101b = 11111100b
-00110001b ^ 11001110b = 11111111b
-00110001b ^ 11001111b = 11111110b
-00110001b ^ 11010000b = 11100001b
-00110001b ^ 11010001b = 11100000b
-00110001b ^ 11010010b = 11100011b
-00110001b ^ 11010011b = 11100010b
-00110001b ^ 11010100b = 11100101b
-00110001b ^ 11010101b = 11100100b
-00110001b ^ 11010110b = 11100111b
-00110001b ^ 11010111b = 11100110b
-00110001b ^ 11011000b = 11101001b
-00110001b ^ 11011001b = 11101000b
-00110001b ^ 11011010b = 11101011b
-00110001b ^ 11011011b = 11101010b
-00110001b ^ 11011100b = 11101101b
-00110001b ^ 11011101b = 11101100b
-00110001b ^ 11011110b = 11101111b
-00110001b ^ 11011111b = 11101110b
-00110001b ^ 11100000b = 11010001b
-00110001b ^ 11100001b = 11010000b
-00110001b ^ 11100010b = 11010011b
-00110001b ^ 11100011b = 11010010b
-00110001b ^ 11100100b = 11010101b
-00110001b ^ 11100101b = 11010100b
-00110001b ^ 11100110b = 11010111b
-00110001b ^ 11100111b = 11010110b
-00110001b ^ 11101000b = 11011001b
-00110001b ^ 11101001b = 11011000b
-00110001b ^ 11101010b = 11011011b
-00110001b ^ 11101011b = 11011010b
-00110001b ^ 11101100b = 11011101b
-00110001b ^ 11101101b = 11011100b
-00110001b ^ 11101110b = 11011111b
-00110001b ^ 11101111b = 11011110b
-00110001b ^ 11110000b = 11000001b
-00110001b ^ 11110001b = 11000000b
-00110001b ^ 11110010b = 11000011b
-00110001b ^ 11110011b = 11000010b
-00110001b ^ 11110100b = 11000101b
-00110001b ^ 11110101b = 11000100b
-00110001b ^ 11110110b = 11000111b
-00110001b ^ 11110111b = 11000110b
-00110001b ^ 11111000b = 11001001b
-00110001b ^ 11111001b = 11001000b
-00110001b ^ 11111010b = 11001011b
-00110001b ^ 11111011b = 11001010b
-00110001b ^ 11111100b = 11001101b
-00110001b ^ 11111101b = 11001100b
-00110001b ^ 11111110b = 11001111b
-00110001b ^ 11111111b = 11001110b
-00110001b ^ 00000000b = 00110001b
-00110001b ^ 00000001b = 00110000b
-00110001b ^ 00000010b = 00110011b
-00110001b ^ 00000011b = 00110010b
-00110001b ^ 00000100b = 00110101b
-00110001b ^ 00000101b = 00110100b
-00110001b ^ 00000110b = 00110111b
-00110001b ^ 00000111b = 00110110b
-00110001b ^ 00001000b = 00111001b
-00110001b ^ 00001001b = 00111000b
-00110001b ^ 00001010b = 00111011b
-00110001b ^ 00001011b = 00111010b
-00110001b ^ 00001100b = 00111101b
-00110001b ^ 00001101b = 00111100b
-00110001b ^ 00001110b = 00111111b
-00110001b ^ 00001111b = 00111110b
-00110001b ^ 00010000b = 00100001b
-00110001b ^ 00010001b = 00100000b
-00110001b ^ 00010010b = 00100011b
-00110001b ^ 00010011b = 00100010b
-00110001b ^ 00010100b = 00100101b
-00110001b ^ 00010101b = 00100100b
-00110001b ^ 00010110b = 00100111b
-00110001b ^ 00010111b = 00100110b
-00110001b ^ 00011000b = 00101001b
-00110001b ^ 00011001b = 00101000b
-00110001b ^ 00011010b = 00101011b
-00110001b ^ 00011011b = 00101010b
-00110001b ^ 00011100b = 00101101b
-00110001b ^ 00011101b = 00101100b
-00110001b ^ 00011110b = 00101111b
-00110001b ^ 00011111b = 00101110b
-00110001b ^ 00100000b = 00010001b
-00110001b ^ 00100001b = 00010000b
-00110001b ^ 00100010b = 00010011b
-00110001b ^ 00100011b = 00010010b
-00110001b ^ 00100100b = 00010101b
-00110001b ^ 00100101b = 00010100b
-00110001b ^ 00100110b = 00010111b
-00110001b ^ 00100111b = 00010110b
-00110001b ^ 00101000b = 00011001b
-00110001b ^ 00101001b = 00011000b
-00110001b ^ 00101010b = 00011011b
-00110001b ^ 00101011b = 00011010b
-00110001b ^ 00101100b = 00011101b
-00110001b ^ 00101101b = 00011100b
-00110001b ^ 00101110b = 00011111b
-00110001b ^ 00101111b = 00011110b
-00110001b ^ 00110000b = 00000001b
-00110001b ^ 00110001b = 00000000b
-00110001b ^ 00110010b = 00000011b
-00110001b ^ 00110011b = 00000010b
-00110001b ^ 00110100b = 00000101b
-00110001b ^ 00110101b = 00000100b
-00110001b ^ 00110110b = 00000111b
-00110001b ^ 00110111b = 00000110b
-00110001b ^ 00111000b = 00001001b
-00110001b ^ 00111001b = 00001000b
-00110001b ^ 00111010b = 00001011b
-00110001b ^ 00111011b = 00001010b
-00110001b ^ 00111100b = 00001101b
-00110001b ^ 00111101b = 00001100b
-00110001b ^ 00111110b = 00001111b
-00110001b ^ 00111111b = 00001110b
-00110001b ^ 01000000b = 01110001b
-00110001b ^ 01000001b = 01110000b
-00110001b ^ 01000010b = 01110011b
-00110001b ^ 01000011b = 01110010b
-00110001b ^ 01000100b = 01110101b
-00110001b ^ 01000101b = 01110100b
-00110001b ^ 01000110b = 01110111b
-00110001b ^ 01000111b = 01110110b
-00110001b ^ 01001000b = 01111001b
-00110001b ^ 01001001b = 01111000b
-00110001b ^ 01001010b = 01111011b
-00110001b ^ 01001011b = 01111010b
-00110001b ^ 01001100b = 01111101b
-00110001b ^ 01001101b = 01111100b
-00110001b ^ 01001110b = 01111111b
-00110001b ^ 01001111b = 01111110b
-00110001b ^ 01010000b = 01100001b
-00110001b ^ 01010001b = 01100000b
-00110001b ^ 01010010b = 01100011b
-00110001b ^ 01010011b = 01100010b
-00110001b ^ 01010100b = 01100101b
-00110001b ^ 01010101b = 01100100b
-00110001b ^ 01010110b = 01100111b
-00110001b ^ 01010111b = 01100110b
-00110001b ^ 01011000b = 01101001b
-00110001b ^ 01011001b = 01101000b
-00110001b ^ 01011010b = 01101011b
-00110001b ^ 01011011b = 01101010b
-00110001b ^ 01011100b = 01101101b
-00110001b ^ 01011101b = 01101100b
-00110001b ^ 01011110b = 01101111b
-00110001b ^ 01011111b = 01101110b
-00110001b ^ 01100000b = 01010001b
-00110001b ^ 01100001b = 01010000b
-00110001b ^ 01100010b = 01010011b
-00110001b ^ 01100011b = 01010010b
-00110001b ^ 01100100b = 01010101b
-00110001b ^ 01100101b = 01010100b
-00110001b ^ 01100110b = 01010111b
-00110001b ^ 01100111b = 01010110b
-00110001b ^ 01101000b = 01011001b
-00110001b ^ 01101001b = 01011000b
-00110001b ^ 01101010b = 01011011b
-00110001b ^ 01101011b = 01011010b
-00110001b ^ 01101100b = 01011101b
-00110001b ^ 01101101b = 01011100b
-00110001b ^ 01101110b = 01011111b
-00110001b ^ 01101111b = 01011110b
-00110001b ^ 01110000b = 01000001b
-00110001b ^ 01110001b = 01000000b
-00110001b ^ 01110010b = 01000011b
-00110001b ^ 01110011b = 01000010b
-00110001b ^ 01110100b = 01000101b
-00110001b ^ 01110101b = 01000100b
-00110001b ^ 01110110b = 01000111b
-00110001b ^ 01110111b = 01000110b
-00110001b ^ 01111000b = 01001001b
-00110001b ^ 01111001b = 01001000b
-00110001b ^ 01111010b = 01001011b
-00110001b ^ 01111011b = 01001010b
-00110001b ^ 01111100b = 01001101b
-00110001b ^ 01111101b = 01001100b
-00110001b ^ 01111110b = 01001111b
-00110010b ^ 10000000b = 10110010b
-00110010b ^ 10000001b = 10110011b
-00110010b ^ 10000010b = 10110000b
-00110010b ^ 10000011b = 10110001b
-00110010b ^ 10000100b = 10110110b
-00110010b ^ 10000101b = 10110111b
-00110010b ^ 10000110b = 10110100b
-00110010b ^ 10000111b = 10110101b
-00110010b ^ 10001000b = 10111010b
-00110010b ^ 10001001b = 10111011b
-00110010b ^ 10001010b = 10111000b
-00110010b ^ 10001011b = 10111001b
-00110010b ^ 10001100b = 10111110b
-00110010b ^ 10001101b = 10111111b
-00110010b ^ 10001110b = 10111100b
-00110010b ^ 10001111b = 10111101b
-00110010b ^ 10010000b = 10100010b
-00110010b ^ 10010001b = 10100011b
-00110010b ^ 10010010b = 10100000b
-00110010b ^ 10010011b = 10100001b
-00110010b ^ 10010100b = 10100110b
-00110010b ^ 10010101b = 10100111b
-00110010b ^ 10010110b = 10100100b
-00110010b ^ 10010111b = 10100101b
-00110010b ^ 10011000b = 10101010b
-00110010b ^ 10011001b = 10101011b
-00110010b ^ 10011010b = 10101000b
-00110010b ^ 10011011b = 10101001b
-00110010b ^ 10011100b = 10101110b
-00110010b ^ 10011101b = 10101111b
-00110010b ^ 10011110b = 10101100b
-00110010b ^ 10011111b = 10101101b
-00110010b ^ 10100000b = 10010010b
-00110010b ^ 10100001b = 10010011b
-00110010b ^ 10100010b = 10010000b
-00110010b ^ 10100011b = 10010001b
-00110010b ^ 10100100b = 10010110b
-00110010b ^ 10100101b = 10010111b
-00110010b ^ 10100110b = 10010100b
-00110010b ^ 10100111b = 10010101b
-00110010b ^ 10101000b = 10011010b
-00110010b ^ 10101001b = 10011011b
-00110010b ^ 10101010b = 10011000b
-00110010b ^ 10101011b = 10011001b
-00110010b ^ 10101100b = 10011110b
-00110010b ^ 10101101b = 10011111b
-00110010b ^ 10101110b = 10011100b
-00110010b ^ 10101111b = 10011101b
-00110010b ^ 10110000b = 10000010b
-00110010b ^ 10110001b = 10000011b
-00110010b ^ 10110010b = 10000000b
-00110010b ^ 10110011b = 10000001b
-00110010b ^ 10110100b = 10000110b
-00110010b ^ 10110101b = 10000111b
-00110010b ^ 10110110b = 10000100b
-00110010b ^ 10110111b = 10000101b
-00110010b ^ 10111000b = 10001010b
-00110010b ^ 10111001b = 10001011b
-00110010b ^ 10111010b = 10001000b
-00110010b ^ 10111011b = 10001001b
-00110010b ^ 10111100b = 10001110b
-00110010b ^ 10111101b = 10001111b
-00110010b ^ 10111110b = 10001100b
-00110010b ^ 10111111b = 10001101b
-00110010b ^ 11000000b = 11110010b
-00110010b ^ 11000001b = 11110011b
-00110010b ^ 11000010b = 11110000b
-00110010b ^ 11000011b = 11110001b
-00110010b ^ 11000100b = 11110110b
-00110010b ^ 11000101b = 11110111b
-00110010b ^ 11000110b = 11110100b
-00110010b ^ 11000111b = 11110101b
-00110010b ^ 11001000b = 11111010b
-00110010b ^ 11001001b = 11111011b
-00110010b ^ 11001010b = 11111000b
-00110010b ^ 11001011b = 11111001b
-00110010b ^ 11001100b = 11111110b
-00110010b ^ 11001101b = 11111111b
-00110010b ^ 11001110b = 11111100b
-00110010b ^ 11001111b = 11111101b
-00110010b ^ 11010000b = 11100010b
-00110010b ^ 11010001b = 11100011b
-00110010b ^ 11010010b = 11100000b
-00110010b ^ 11010011b = 11100001b
-00110010b ^ 11010100b = 11100110b
-00110010b ^ 11010101b = 11100111b
-00110010b ^ 11010110b = 11100100b
-00110010b ^ 11010111b = 11100101b
-00110010b ^ 11011000b = 11101010b
-00110010b ^ 11011001b = 11101011b
-00110010b ^ 11011010b = 11101000b
-00110010b ^ 11011011b = 11101001b
-00110010b ^ 11011100b = 11101110b
-00110010b ^ 11011101b = 11101111b
-00110010b ^ 11011110b = 11101100b
-00110010b ^ 11011111b = 11101101b
-00110010b ^ 11100000b = 11010010b
-00110010b ^ 11100001b = 11010011b
-00110010b ^ 11100010b = 11010000b
-00110010b ^ 11100011b = 11010001b
-00110010b ^ 11100100b = 11010110b
-00110010b ^ 11100101b = 11010111b
-00110010b ^ 11100110b = 11010100b
-00110010b ^ 11100111b = 11010101b
-00110010b ^ 11101000b = 11011010b
-00110010b ^ 11101001b = 11011011b
-00110010b ^ 11101010b = 11011000b
-00110010b ^ 11101011b = 11011001b
-00110010b ^ 11101100b = 11011110b
-00110010b ^ 11101101b = 11011111b
-00110010b ^ 11101110b = 11011100b
-00110010b ^ 11101111b = 11011101b
-00110010b ^ 11110000b = 11000010b
-00110010b ^ 11110001b = 11000011b
-00110010b ^ 11110010b = 11000000b
-00110010b ^ 11110011b = 11000001b
-00110010b ^ 11110100b = 11000110b
-00110010b ^ 11110101b = 11000111b
-00110010b ^ 11110110b = 11000100b
-00110010b ^ 11110111b = 11000101b
-00110010b ^ 11111000b = 11001010b
-00110010b ^ 11111001b = 11001011b
-00110010b ^ 11111010b = 11001000b
-00110010b ^ 11111011b = 11001001b
-00110010b ^ 11111100b = 11001110b
-00110010b ^ 11111101b = 11001111b
-00110010b ^ 11111110b = 11001100b
-00110010b ^ 11111111b = 11001101b
-00110010b ^ 00000000b = 00110010b
-00110010b ^ 00000001b = 00110011b
-00110010b ^ 00000010b = 00110000b
-00110010b ^ 00000011b = 00110001b
-00110010b ^ 00000100b = 00110110b
-00110010b ^ 00000101b = 00110111b
-00110010b ^ 00000110b = 00110100b
-00110010b ^ 00000111b = 00110101b
-00110010b ^ 00001000b = 00111010b
-00110010b ^ 00001001b = 00111011b
-00110010b ^ 00001010b = 00111000b
-00110010b ^ 00001011b = 00111001b
-00110010b ^ 00001100b = 00111110b
-00110010b ^ 00001101b = 00111111b
-00110010b ^ 00001110b = 00111100b
-00110010b ^ 00001111b = 00111101b
-00110010b ^ 00010000b = 00100010b
-00110010b ^ 00010001b = 00100011b
-00110010b ^ 00010010b = 00100000b
-00110010b ^ 00010011b = 00100001b
-00110010b ^ 00010100b = 00100110b
-00110010b ^ 00010101b = 00100111b
-00110010b ^ 00010110b = 00100100b
-00110010b ^ 00010111b = 00100101b
-00110010b ^ 00011000b = 00101010b
-00110010b ^ 00011001b = 00101011b
-00110010b ^ 00011010b = 00101000b
-00110010b ^ 00011011b = 00101001b
-00110010b ^ 00011100b = 00101110b
-00110010b ^ 00011101b = 00101111b
-00110010b ^ 00011110b = 00101100b
-00110010b ^ 00011111b = 00101101b
-00110010b ^ 00100000b = 00010010b
-00110010b ^ 00100001b = 00010011b
-00110010b ^ 00100010b = 00010000b
-00110010b ^ 00100011b = 00010001b
-00110010b ^ 00100100b = 00010110b
-00110010b ^ 00100101b = 00010111b
-00110010b ^ 00100110b = 00010100b
-00110010b ^ 00100111b = 00010101b
-00110010b ^ 00101000b = 00011010b
-00110010b ^ 00101001b = 00011011b
-00110010b ^ 00101010b = 00011000b
-00110010b ^ 00101011b = 00011001b
-00110010b ^ 00101100b = 00011110b
-00110010b ^ 00101101b = 00011111b
-00110010b ^ 00101110b = 00011100b
-00110010b ^ 00101111b = 00011101b
-00110010b ^ 00110000b = 00000010b
-00110010b ^ 00110001b = 00000011b
-00110010b ^ 00110010b = 00000000b
-00110010b ^ 00110011b = 00000001b
-00110010b ^ 00110100b = 00000110b
-00110010b ^ 00110101b = 00000111b
-00110010b ^ 00110110b = 00000100b
-00110010b ^ 00110111b = 00000101b
-00110010b ^ 00111000b = 00001010b
-00110010b ^ 00111001b = 00001011b
-00110010b ^ 00111010b = 00001000b
-00110010b ^ 00111011b = 00001001b
-00110010b ^ 00111100b = 00001110b
-00110010b ^ 00111101b = 00001111b
-00110010b ^ 00111110b = 00001100b
-00110010b ^ 00111111b = 00001101b
-00110010b ^ 01000000b = 01110010b
-00110010b ^ 01000001b = 01110011b
-00110010b ^ 01000010b = 01110000b
-00110010b ^ 01000011b = 01110001b
-00110010b ^ 01000100b = 01110110b
-00110010b ^ 01000101b = 01110111b
-00110010b ^ 01000110b = 01110100b
-00110010b ^ 01000111b = 01110101b
-00110010b ^ 01001000b = 01111010b
-00110010b ^ 01001001b = 01111011b
-00110010b ^ 01001010b = 01111000b
-00110010b ^ 01001011b = 01111001b
-00110010b ^ 01001100b = 01111110b
-00110010b ^ 01001101b = 01111111b
-00110010b ^ 01001110b = 01111100b
-00110010b ^ 01001111b = 01111101b
-00110010b ^ 01010000b = 01100010b
-00110010b ^ 01010001b = 01100011b
-00110010b ^ 01010010b = 01100000b
-00110010b ^ 01010011b = 01100001b
-00110010b ^ 01010100b = 01100110b
-00110010b ^ 01010101b = 01100111b
-00110010b ^ 01010110b = 01100100b
-00110010b ^ 01010111b = 01100101b
-00110010b ^ 01011000b = 01101010b
-00110010b ^ 01011001b = 01101011b
-00110010b ^ 01011010b = 01101000b
-00110010b ^ 01011011b = 01101001b
-00110010b ^ 01011100b = 01101110b
-00110010b ^ 01011101b = 01101111b
-00110010b ^ 01011110b = 01101100b
-00110010b ^ 01011111b = 01101101b
-00110010b ^ 01100000b = 01010010b
-00110010b ^ 01100001b = 01010011b
-00110010b ^ 01100010b = 01010000b
-00110010b ^ 01100011b = 01010001b
-00110010b ^ 01100100b = 01010110b
-00110010b ^ 01100101b = 01010111b
-00110010b ^ 01100110b = 01010100b
-00110010b ^ 01100111b = 01010101b
-00110010b ^ 01101000b = 01011010b
-00110010b ^ 01101001b = 01011011b
-00110010b ^ 01101010b = 01011000b
-00110010b ^ 01101011b = 01011001b
-00110010b ^ 01101100b = 01011110b
-00110010b ^ 01101101b = 01011111b
-00110010b ^ 01101110b = 01011100b
-00110010b ^ 01101111b = 01011101b
-00110010b ^ 01110000b = 01000010b
-00110010b ^ 01110001b = 01000011b
-00110010b ^ 01110010b = 01000000b
-00110010b ^ 01110011b = 01000001b
-00110010b ^ 01110100b = 01000110b
-00110010b ^ 01110101b = 01000111b
-00110010b ^ 01110110b = 01000100b
-00110010b ^ 01110111b = 01000101b
-00110010b ^ 01111000b = 01001010b
-00110010b ^ 01111001b = 01001011b
-00110010b ^ 01111010b = 01001000b
-00110010b ^ 01111011b = 01001001b
-00110010b ^ 01111100b = 01001110b
-00110010b ^ 01111101b = 01001111b
-00110010b ^ 01111110b = 01001100b
-00110011b ^ 10000000b = 10110011b
-00110011b ^ 10000001b = 10110010b
-00110011b ^ 10000010b = 10110001b
-00110011b ^ 10000011b = 10110000b
-00110011b ^ 10000100b = 10110111b
-00110011b ^ 10000101b = 10110110b
-00110011b ^ 10000110b = 10110101b
-00110011b ^ 10000111b = 10110100b
-00110011b ^ 10001000b = 10111011b
-00110011b ^ 10001001b = 10111010b
-00110011b ^ 10001010b = 10111001b
-00110011b ^ 10001011b = 10111000b
-00110011b ^ 10001100b = 10111111b
-00110011b ^ 10001101b = 10111110b
-00110011b ^ 10001110b = 10111101b
-00110011b ^ 10001111b = 10111100b
-00110011b ^ 10010000b = 10100011b
-00110011b ^ 10010001b = 10100010b
-00110011b ^ 10010010b = 10100001b
-00110011b ^ 10010011b = 10100000b
-00110011b ^ 10010100b = 10100111b
-00110011b ^ 10010101b = 10100110b
-00110011b ^ 10010110b = 10100101b
-00110011b ^ 10010111b = 10100100b
-00110011b ^ 10011000b = 10101011b
-00110011b ^ 10011001b = 10101010b
-00110011b ^ 10011010b = 10101001b
-00110011b ^ 10011011b = 10101000b
-00110011b ^ 10011100b = 10101111b
-00110011b ^ 10011101b = 10101110b
-00110011b ^ 10011110b = 10101101b
-00110011b ^ 10011111b = 10101100b
-00110011b ^ 10100000b = 10010011b
-00110011b ^ 10100001b = 10010010b
-00110011b ^ 10100010b = 10010001b
-00110011b ^ 10100011b = 10010000b
-00110011b ^ 10100100b = 10010111b
-00110011b ^ 10100101b = 10010110b
-00110011b ^ 10100110b = 10010101b
-00110011b ^ 10100111b = 10010100b
-00110011b ^ 10101000b = 10011011b
-00110011b ^ 10101001b = 10011010b
-00110011b ^ 10101010b = 10011001b
-00110011b ^ 10101011b = 10011000b
-00110011b ^ 10101100b = 10011111b
-00110011b ^ 10101101b = 10011110b
-00110011b ^ 10101110b = 10011101b
-00110011b ^ 10101111b = 10011100b
-00110011b ^ 10110000b = 10000011b
-00110011b ^ 10110001b = 10000010b
-00110011b ^ 10110010b = 10000001b
-00110011b ^ 10110011b = 10000000b
-00110011b ^ 10110100b = 10000111b
-00110011b ^ 10110101b = 10000110b
-00110011b ^ 10110110b = 10000101b
-00110011b ^ 10110111b = 10000100b
-00110011b ^ 10111000b = 10001011b
-00110011b ^ 10111001b = 10001010b
-00110011b ^ 10111010b = 10001001b
-00110011b ^ 10111011b = 10001000b
-00110011b ^ 10111100b = 10001111b
-00110011b ^ 10111101b = 10001110b
-00110011b ^ 10111110b = 10001101b
-00110011b ^ 10111111b = 10001100b
-00110011b ^ 11000000b = 11110011b
-00110011b ^ 11000001b = 11110010b
-00110011b ^ 11000010b = 11110001b
-00110011b ^ 11000011b = 11110000b
-00110011b ^ 11000100b = 11110111b
-00110011b ^ 11000101b = 11110110b
-00110011b ^ 11000110b = 11110101b
-00110011b ^ 11000111b = 11110100b
-00110011b ^ 11001000b = 11111011b
-00110011b ^ 11001001b = 11111010b
-00110011b ^ 11001010b = 11111001b
-00110011b ^ 11001011b = 11111000b
-00110011b ^ 11001100b = 11111111b
-00110011b ^ 11001101b = 11111110b
-00110011b ^ 11001110b = 11111101b
-00110011b ^ 11001111b = 11111100b
-00110011b ^ 11010000b = 11100011b
-00110011b ^ 11010001b = 11100010b
-00110011b ^ 11010010b = 11100001b
-00110011b ^ 11010011b = 11100000b
-00110011b ^ 11010100b = 11100111b
-00110011b ^ 11010101b = 11100110b
-00110011b ^ 11010110b = 11100101b
-00110011b ^ 11010111b = 11100100b
-00110011b ^ 11011000b = 11101011b
-00110011b ^ 11011001b = 11101010b
-00110011b ^ 11011010b = 11101001b
-00110011b ^ 11011011b = 11101000b
-00110011b ^ 11011100b = 11101111b
-00110011b ^ 11011101b = 11101110b
-00110011b ^ 11011110b = 11101101b
-00110011b ^ 11011111b = 11101100b
-00110011b ^ 11100000b = 11010011b
-00110011b ^ 11100001b = 11010010b
-00110011b ^ 11100010b = 11010001b
-00110011b ^ 11100011b = 11010000b
-00110011b ^ 11100100b = 11010111b
-00110011b ^ 11100101b = 11010110b
-00110011b ^ 11100110b = 11010101b
-00110011b ^ 11100111b = 11010100b
-00110011b ^ 11101000b = 11011011b
-00110011b ^ 11101001b = 11011010b
-00110011b ^ 11101010b = 11011001b
-00110011b ^ 11101011b = 11011000b
-00110011b ^ 11101100b = 11011111b
-00110011b ^ 11101101b = 11011110b
-00110011b ^ 11101110b = 11011101b
-00110011b ^ 11101111b = 11011100b
-00110011b ^ 11110000b = 11000011b
-00110011b ^ 11110001b = 11000010b
-00110011b ^ 11110010b = 11000001b
-00110011b ^ 11110011b = 11000000b
-00110011b ^ 11110100b = 11000111b
-00110011b ^ 11110101b = 11000110b
-00110011b ^ 11110110b = 11000101b
-00110011b ^ 11110111b = 11000100b
-00110011b ^ 11111000b = 11001011b
-00110011b ^ 11111001b = 11001010b
-00110011b ^ 11111010b = 11001001b
-00110011b ^ 11111011b = 11001000b
-00110011b ^ 11111100b = 11001111b
-00110011b ^ 11111101b = 11001110b
-00110011b ^ 11111110b = 11001101b
-00110011b ^ 11111111b = 11001100b
-00110011b ^ 00000000b = 00110011b
-00110011b ^ 00000001b = 00110010b
-00110011b ^ 00000010b = 00110001b
-00110011b ^ 00000011b = 00110000b
-00110011b ^ 00000100b = 00110111b
-00110011b ^ 00000101b = 00110110b
-00110011b ^ 00000110b = 00110101b
-00110011b ^ 00000111b = 00110100b
-00110011b ^ 00001000b = 00111011b
-00110011b ^ 00001001b = 00111010b
-00110011b ^ 00001010b = 00111001b
-00110011b ^ 00001011b = 00111000b
-00110011b ^ 00001100b = 00111111b
-00110011b ^ 00001101b = 00111110b
-00110011b ^ 00001110b = 00111101b
-00110011b ^ 00001111b = 00111100b
-00110011b ^ 00010000b = 00100011b
-00110011b ^ 00010001b = 00100010b
-00110011b ^ 00010010b = 00100001b
-00110011b ^ 00010011b = 00100000b
-00110011b ^ 00010100b = 00100111b
-00110011b ^ 00010101b = 00100110b
-00110011b ^ 00010110b = 00100101b
-00110011b ^ 00010111b = 00100100b
-00110011b ^ 00011000b = 00101011b
-00110011b ^ 00011001b = 00101010b
-00110011b ^ 00011010b = 00101001b
-00110011b ^ 00011011b = 00101000b
-00110011b ^ 00011100b = 00101111b
-00110011b ^ 00011101b = 00101110b
-00110011b ^ 00011110b = 00101101b
-00110011b ^ 00011111b = 00101100b
-00110011b ^ 00100000b = 00010011b
-00110011b ^ 00100001b = 00010010b
-00110011b ^ 00100010b = 00010001b
-00110011b ^ 00100011b = 00010000b
-00110011b ^ 00100100b = 00010111b
-00110011b ^ 00100101b = 00010110b
-00110011b ^ 00100110b = 00010101b
-00110011b ^ 00100111b = 00010100b
-00110011b ^ 00101000b = 00011011b
-00110011b ^ 00101001b = 00011010b
-00110011b ^ 00101010b = 00011001b
-00110011b ^ 00101011b = 00011000b
-00110011b ^ 00101100b = 00011111b
-00110011b ^ 00101101b = 00011110b
-00110011b ^ 00101110b = 00011101b
-00110011b ^ 00101111b = 00011100b
-00110011b ^ 00110000b = 00000011b
-00110011b ^ 00110001b = 00000010b
-00110011b ^ 00110010b = 00000001b
-00110011b ^ 00110011b = 00000000b
-00110011b ^ 00110100b = 00000111b
-00110011b ^ 00110101b = 00000110b
-00110011b ^ 00110110b = 00000101b
-00110011b ^ 00110111b = 00000100b
-00110011b ^ 00111000b = 00001011b
-00110011b ^ 00111001b = 00001010b
-00110011b ^ 00111010b = 00001001b
-00110011b ^ 00111011b = 00001000b
-00110011b ^ 00111100b = 00001111b
-00110011b ^ 00111101b = 00001110b
-00110011b ^ 00111110b = 00001101b
-00110011b ^ 00111111b = 00001100b
-00110011b ^ 01000000b = 01110011b
-00110011b ^ 01000001b = 01110010b
-00110011b ^ 01000010b = 01110001b
-00110011b ^ 01000011b = 01110000b
-00110011b ^ 01000100b = 01110111b
-00110011b ^ 01000101b = 01110110b
-00110011b ^ 01000110b = 01110101b
-00110011b ^ 01000111b = 01110100b
-00110011b ^ 01001000b = 01111011b
-00110011b ^ 01001001b = 01111010b
-00110011b ^ 01001010b = 01111001b
-00110011b ^ 01001011b = 01111000b
-00110011b ^ 01001100b = 01111111b
-00110011b ^ 01001101b = 01111110b
-00110011b ^ 01001110b = 01111101b
-00110011b ^ 01001111b = 01111100b
-00110011b ^ 01010000b = 01100011b
-00110011b ^ 01010001b = 01100010b
-00110011b ^ 01010010b = 01100001b
-00110011b ^ 01010011b = 01100000b
-00110011b ^ 01010100b = 01100111b
-00110011b ^ 01010101b = 01100110b
-00110011b ^ 01010110b = 01100101b
-00110011b ^ 01010111b = 01100100b
-00110011b ^ 01011000b = 01101011b
-00110011b ^ 01011001b = 01101010b
-00110011b ^ 01011010b = 01101001b
-00110011b ^ 01011011b = 01101000b
-00110011b ^ 01011100b = 01101111b
-00110011b ^ 01011101b = 01101110b
-00110011b ^ 01011110b = 01101101b
-00110011b ^ 01011111b = 01101100b
-00110011b ^ 01100000b = 01010011b
-00110011b ^ 01100001b = 01010010b
-00110011b ^ 01100010b = 01010001b
-00110011b ^ 01100011b = 01010000b
-00110011b ^ 01100100b = 01010111b
-00110011b ^ 01100101b = 01010110b
-00110011b ^ 01100110b = 01010101b
-00110011b ^ 01100111b = 01010100b
-00110011b ^ 01101000b = 01011011b
-00110011b ^ 01101001b = 01011010b
-00110011b ^ 01101010b = 01011001b
-00110011b ^ 01101011b = 01011000b
-00110011b ^ 01101100b = 01011111b
-00110011b ^ 01101101b = 01011110b
-00110011b ^ 01101110b = 01011101b
-00110011b ^ 01101111b = 01011100b
-00110011b ^ 01110000b = 01000011b
-00110011b ^ 01110001b = 01000010b
-00110011b ^ 01110010b = 01000001b
-00110011b ^ 01110011b = 01000000b
-00110011b ^ 01110100b = 01000111b
-00110011b ^ 01110101b = 01000110b
-00110011b ^ 01110110b = 01000101b
-00110011b ^ 01110111b = 01000100b
-00110011b ^ 01111000b = 01001011b
-00110011b ^ 01111001b = 01001010b
-00110011b ^ 01111010b = 01001001b
-00110011b ^ 01111011b = 01001000b
-00110011b ^ 01111100b = 01001111b
-00110011b ^ 01111101b = 01001110b
-00110011b ^ 01111110b = 01001101b
-00110100b ^ 10000000b = 10110100b
-00110100b ^ 10000001b = 10110101b
-00110100b ^ 10000010b = 10110110b
-00110100b ^ 10000011b = 10110111b
-00110100b ^ 10000100b = 10110000b
-00110100b ^ 10000101b = 10110001b
-00110100b ^ 10000110b = 10110010b
-00110100b ^ 10000111b = 10110011b
-00110100b ^ 10001000b = 10111100b
-00110100b ^ 10001001b = 10111101b
-00110100b ^ 10001010b = 10111110b
-00110100b ^ 10001011b = 10111111b
-00110100b ^ 10001100b = 10111000b
-00110100b ^ 10001101b = 10111001b
-00110100b ^ 10001110b = 10111010b
-00110100b ^ 10001111b = 10111011b
-00110100b ^ 10010000b = 10100100b
-00110100b ^ 10010001b = 10100101b
-00110100b ^ 10010010b = 10100110b
-00110100b ^ 10010011b = 10100111b
-00110100b ^ 10010100b = 10100000b
-00110100b ^ 10010101b = 10100001b
-00110100b ^ 10010110b = 10100010b
-00110100b ^ 10010111b = 10100011b
-00110100b ^ 10011000b = 10101100b
-00110100b ^ 10011001b = 10101101b
-00110100b ^ 10011010b = 10101110b
-00110100b ^ 10011011b = 10101111b
-00110100b ^ 10011100b = 10101000b
-00110100b ^ 10011101b = 10101001b
-00110100b ^ 10011110b = 10101010b
-00110100b ^ 10011111b = 10101011b
-00110100b ^ 10100000b = 10010100b
-00110100b ^ 10100001b = 10010101b
-00110100b ^ 10100010b = 10010110b
-00110100b ^ 10100011b = 10010111b
-00110100b ^ 10100100b = 10010000b
-00110100b ^ 10100101b = 10010001b
-00110100b ^ 10100110b = 10010010b
-00110100b ^ 10100111b = 10010011b
-00110100b ^ 10101000b = 10011100b
-00110100b ^ 10101001b = 10011101b
-00110100b ^ 10101010b = 10011110b
-00110100b ^ 10101011b = 10011111b
-00110100b ^ 10101100b = 10011000b
-00110100b ^ 10101101b = 10011001b
-00110100b ^ 10101110b = 10011010b
-00110100b ^ 10101111b = 10011011b
-00110100b ^ 10110000b = 10000100b
-00110100b ^ 10110001b = 10000101b
-00110100b ^ 10110010b = 10000110b
-00110100b ^ 10110011b = 10000111b
-00110100b ^ 10110100b = 10000000b
-00110100b ^ 10110101b = 10000001b
-00110100b ^ 10110110b = 10000010b
-00110100b ^ 10110111b = 10000011b
-00110100b ^ 10111000b = 10001100b
-00110100b ^ 10111001b = 10001101b
-00110100b ^ 10111010b = 10001110b
-00110100b ^ 10111011b = 10001111b
-00110100b ^ 10111100b = 10001000b
-00110100b ^ 10111101b = 10001001b
-00110100b ^ 10111110b = 10001010b
-00110100b ^ 10111111b = 10001011b
-00110100b ^ 11000000b = 11110100b
-00110100b ^ 11000001b = 11110101b
-00110100b ^ 11000010b = 11110110b
-00110100b ^ 11000011b = 11110111b
-00110100b ^ 11000100b = 11110000b
-00110100b ^ 11000101b = 11110001b
-00110100b ^ 11000110b = 11110010b
-00110100b ^ 11000111b = 11110011b
-00110100b ^ 11001000b = 11111100b
-00110100b ^ 11001001b = 11111101b
-00110100b ^ 11001010b = 11111110b
-00110100b ^ 11001011b = 11111111b
-00110100b ^ 11001100b = 11111000b
-00110100b ^ 11001101b = 11111001b
-00110100b ^ 11001110b = 11111010b
-00110100b ^ 11001111b = 11111011b
-00110100b ^ 11010000b = 11100100b
-00110100b ^ 11010001b = 11100101b
-00110100b ^ 11010010b = 11100110b
-00110100b ^ 11010011b = 11100111b
-00110100b ^ 11010100b = 11100000b
-00110100b ^ 11010101b = 11100001b
-00110100b ^ 11010110b = 11100010b
-00110100b ^ 11010111b = 11100011b
-00110100b ^ 11011000b = 11101100b
-00110100b ^ 11011001b = 11101101b
-00110100b ^ 11011010b = 11101110b
-00110100b ^ 11011011b = 11101111b
-00110100b ^ 11011100b = 11101000b
-00110100b ^ 11011101b = 11101001b
-00110100b ^ 11011110b = 11101010b
-00110100b ^ 11011111b = 11101011b
-00110100b ^ 11100000b = 11010100b
-00110100b ^ 11100001b = 11010101b
-00110100b ^ 11100010b = 11010110b
-00110100b ^ 11100011b = 11010111b
-00110100b ^ 11100100b = 11010000b
-00110100b ^ 11100101b = 11010001b
-00110100b ^ 11100110b = 11010010b
-00110100b ^ 11100111b = 11010011b
-00110100b ^ 11101000b = 11011100b
-00110100b ^ 11101001b = 11011101b
-00110100b ^ 11101010b = 11011110b
-00110100b ^ 11101011b = 11011111b
-00110100b ^ 11101100b = 11011000b
-00110100b ^ 11101101b = 11011001b
-00110100b ^ 11101110b = 11011010b
-00110100b ^ 11101111b = 11011011b
-00110100b ^ 11110000b = 11000100b
-00110100b ^ 11110001b = 11000101b
-00110100b ^ 11110010b = 11000110b
-00110100b ^ 11110011b = 11000111b
-00110100b ^ 11110100b = 11000000b
-00110100b ^ 11110101b = 11000001b
-00110100b ^ 11110110b = 11000010b
-00110100b ^ 11110111b = 11000011b
-00110100b ^ 11111000b = 11001100b
-00110100b ^ 11111001b = 11001101b
-00110100b ^ 11111010b = 11001110b
-00110100b ^ 11111011b = 11001111b
-00110100b ^ 11111100b = 11001000b
-00110100b ^ 11111101b = 11001001b
-00110100b ^ 11111110b = 11001010b
-00110100b ^ 11111111b = 11001011b
-00110100b ^ 00000000b = 00110100b
-00110100b ^ 00000001b = 00110101b
-00110100b ^ 00000010b = 00110110b
-00110100b ^ 00000011b = 00110111b
-00110100b ^ 00000100b = 00110000b
-00110100b ^ 00000101b = 00110001b
-00110100b ^ 00000110b = 00110010b
-00110100b ^ 00000111b = 00110011b
-00110100b ^ 00001000b = 00111100b
-00110100b ^ 00001001b = 00111101b
-00110100b ^ 00001010b = 00111110b
-00110100b ^ 00001011b = 00111111b
-00110100b ^ 00001100b = 00111000b
-00110100b ^ 00001101b = 00111001b
-00110100b ^ 00001110b = 00111010b
-00110100b ^ 00001111b = 00111011b
-00110100b ^ 00010000b = 00100100b
-00110100b ^ 00010001b = 00100101b
-00110100b ^ 00010010b = 00100110b
-00110100b ^ 00010011b = 00100111b
-00110100b ^ 00010100b = 00100000b
-00110100b ^ 00010101b = 00100001b
-00110100b ^ 00010110b = 00100010b
-00110100b ^ 00010111b = 00100011b
-00110100b ^ 00011000b = 00101100b
-00110100b ^ 00011001b = 00101101b
-00110100b ^ 00011010b = 00101110b
-00110100b ^ 00011011b = 00101111b
-00110100b ^ 00011100b = 00101000b
-00110100b ^ 00011101b = 00101001b
-00110100b ^ 00011110b = 00101010b
-00110100b ^ 00011111b = 00101011b
-00110100b ^ 00100000b = 00010100b
-00110100b ^ 00100001b = 00010101b
-00110100b ^ 00100010b = 00010110b
-00110100b ^ 00100011b = 00010111b
-00110100b ^ 00100100b = 00010000b
-00110100b ^ 00100101b = 00010001b
-00110100b ^ 00100110b = 00010010b
-00110100b ^ 00100111b = 00010011b
-00110100b ^ 00101000b = 00011100b
-00110100b ^ 00101001b = 00011101b
-00110100b ^ 00101010b = 00011110b
-00110100b ^ 00101011b = 00011111b
-00110100b ^ 00101100b = 00011000b
-00110100b ^ 00101101b = 00011001b
-00110100b ^ 00101110b = 00011010b
-00110100b ^ 00101111b = 00011011b
-00110100b ^ 00110000b = 00000100b
-00110100b ^ 00110001b = 00000101b
-00110100b ^ 00110010b = 00000110b
-00110100b ^ 00110011b = 00000111b
-00110100b ^ 00110100b = 00000000b
-00110100b ^ 00110101b = 00000001b
-00110100b ^ 00110110b = 00000010b
-00110100b ^ 00110111b = 00000011b
-00110100b ^ 00111000b = 00001100b
-00110100b ^ 00111001b = 00001101b
-00110100b ^ 00111010b = 00001110b
-00110100b ^ 00111011b = 00001111b
-00110100b ^ 00111100b = 00001000b
-00110100b ^ 00111101b = 00001001b
-00110100b ^ 00111110b = 00001010b
-00110100b ^ 00111111b = 00001011b
-00110100b ^ 01000000b = 01110100b
-00110100b ^ 01000001b = 01110101b
-00110100b ^ 01000010b = 01110110b
-00110100b ^ 01000011b = 01110111b
-00110100b ^ 01000100b = 01110000b
-00110100b ^ 01000101b = 01110001b
-00110100b ^ 01000110b = 01110010b
-00110100b ^ 01000111b = 01110011b
-00110100b ^ 01001000b = 01111100b
-00110100b ^ 01001001b = 01111101b
-00110100b ^ 01001010b = 01111110b
-00110100b ^ 01001011b = 01111111b
-00110100b ^ 01001100b = 01111000b
-00110100b ^ 01001101b = 01111001b
-00110100b ^ 01001110b = 01111010b
-00110100b ^ 01001111b = 01111011b
-00110100b ^ 01010000b = 01100100b
-00110100b ^ 01010001b = 01100101b
-00110100b ^ 01010010b = 01100110b
-00110100b ^ 01010011b = 01100111b
-00110100b ^ 01010100b = 01100000b
-00110100b ^ 01010101b = 01100001b
-00110100b ^ 01010110b = 01100010b
-00110100b ^ 01010111b = 01100011b
-00110100b ^ 01011000b = 01101100b
-00110100b ^ 01011001b = 01101101b
-00110100b ^ 01011010b = 01101110b
-00110100b ^ 01011011b = 01101111b
-00110100b ^ 01011100b = 01101000b
-00110100b ^ 01011101b = 01101001b
-00110100b ^ 01011110b = 01101010b
-00110100b ^ 01011111b = 01101011b
-00110100b ^ 01100000b = 01010100b
-00110100b ^ 01100001b = 01010101b
-00110100b ^ 01100010b = 01010110b
-00110100b ^ 01100011b = 01010111b
-00110100b ^ 01100100b = 01010000b
-00110100b ^ 01100101b = 01010001b
-00110100b ^ 01100110b = 01010010b
-00110100b ^ 01100111b = 01010011b
-00110100b ^ 01101000b = 01011100b
-00110100b ^ 01101001b = 01011101b
-00110100b ^ 01101010b = 01011110b
-00110100b ^ 01101011b = 01011111b
-00110100b ^ 01101100b = 01011000b
-00110100b ^ 01101101b = 01011001b
-00110100b ^ 01101110b = 01011010b
-00110100b ^ 01101111b = 01011011b
-00110100b ^ 01110000b = 01000100b
-00110100b ^ 01110001b = 01000101b
-00110100b ^ 01110010b = 01000110b
-00110100b ^ 01110011b = 01000111b
-00110100b ^ 01110100b = 01000000b
-00110100b ^ 01110101b = 01000001b
-00110100b ^ 01110110b = 01000010b
-00110100b ^ 01110111b = 01000011b
-00110100b ^ 01111000b = 01001100b
-00110100b ^ 01111001b = 01001101b
-00110100b ^ 01111010b = 01001110b
-00110100b ^ 01111011b = 01001111b
-00110100b ^ 01111100b = 01001000b
-00110100b ^ 01111101b = 01001001b
-00110100b ^ 01111110b = 01001010b
-00110101b ^ 10000000b = 10110101b
-00110101b ^ 10000001b = 10110100b
-00110101b ^ 10000010b = 10110111b
-00110101b ^ 10000011b = 10110110b
-00110101b ^ 10000100b = 10110001b
-00110101b ^ 10000101b = 10110000b
-00110101b ^ 10000110b = 10110011b
-00110101b ^ 10000111b = 10110010b
-00110101b ^ 10001000b = 10111101b
-00110101b ^ 10001001b = 10111100b
-00110101b ^ 10001010b = 10111111b
-00110101b ^ 10001011b = 10111110b
-00110101b ^ 10001100b = 10111001b
-00110101b ^ 10001101b = 10111000b
-00110101b ^ 10001110b = 10111011b
-00110101b ^ 10001111b = 10111010b
-00110101b ^ 10010000b = 10100101b
-00110101b ^ 10010001b = 10100100b
-00110101b ^ 10010010b = 10100111b
-00110101b ^ 10010011b = 10100110b
-00110101b ^ 10010100b = 10100001b
-00110101b ^ 10010101b = 10100000b
-00110101b ^ 10010110b = 10100011b
-00110101b ^ 10010111b = 10100010b
-00110101b ^ 10011000b = 10101101b
-00110101b ^ 10011001b = 10101100b
-00110101b ^ 10011010b = 10101111b
-00110101b ^ 10011011b = 10101110b
-00110101b ^ 10011100b = 10101001b
-00110101b ^ 10011101b = 10101000b
-00110101b ^ 10011110b = 10101011b
-00110101b ^ 10011111b = 10101010b
-00110101b ^ 10100000b = 10010101b
-00110101b ^ 10100001b = 10010100b
-00110101b ^ 10100010b = 10010111b
-00110101b ^ 10100011b = 10010110b
-00110101b ^ 10100100b = 10010001b
-00110101b ^ 10100101b = 10010000b
-00110101b ^ 10100110b = 10010011b
-00110101b ^ 10100111b = 10010010b
-00110101b ^ 10101000b = 10011101b
-00110101b ^ 10101001b = 10011100b
-00110101b ^ 10101010b = 10011111b
-00110101b ^ 10101011b = 10011110b
-00110101b ^ 10101100b = 10011001b
-00110101b ^ 10101101b = 10011000b
-00110101b ^ 10101110b = 10011011b
-00110101b ^ 10101111b = 10011010b
-00110101b ^ 10110000b = 10000101b
-00110101b ^ 10110001b = 10000100b
-00110101b ^ 10110010b = 10000111b
-00110101b ^ 10110011b = 10000110b
-00110101b ^ 10110100b = 10000001b
-00110101b ^ 10110101b = 10000000b
-00110101b ^ 10110110b = 10000011b
-00110101b ^ 10110111b = 10000010b
-00110101b ^ 10111000b = 10001101b
-00110101b ^ 10111001b = 10001100b
-00110101b ^ 10111010b = 10001111b
-00110101b ^ 10111011b = 10001110b
-00110101b ^ 10111100b = 10001001b
-00110101b ^ 10111101b = 10001000b
-00110101b ^ 10111110b = 10001011b
-00110101b ^ 10111111b = 10001010b
-00110101b ^ 11000000b = 11110101b
-00110101b ^ 11000001b = 11110100b
-00110101b ^ 11000010b = 11110111b
-00110101b ^ 11000011b = 11110110b
-00110101b ^ 11000100b = 11110001b
-00110101b ^ 11000101b = 11110000b
-00110101b ^ 11000110b = 11110011b
-00110101b ^ 11000111b = 11110010b
-00110101b ^ 11001000b = 11111101b
-00110101b ^ 11001001b = 11111100b
-00110101b ^ 11001010b = 11111111b
-00110101b ^ 11001011b = 11111110b
-00110101b ^ 11001100b = 11111001b
-00110101b ^ 11001101b = 11111000b
-00110101b ^ 11001110b = 11111011b
-00110101b ^ 11001111b = 11111010b
-00110101b ^ 11010000b = 11100101b
-00110101b ^ 11010001b = 11100100b
-00110101b ^ 11010010b = 11100111b
-00110101b ^ 11010011b = 11100110b
-00110101b ^ 11010100b = 11100001b
-00110101b ^ 11010101b = 11100000b
-00110101b ^ 11010110b = 11100011b
-00110101b ^ 11010111b = 11100010b
-00110101b ^ 11011000b = 11101101b
-00110101b ^ 11011001b = 11101100b
-00110101b ^ 11011010b = 11101111b
-00110101b ^ 11011011b = 11101110b
-00110101b ^ 11011100b = 11101001b
-00110101b ^ 11011101b = 11101000b
-00110101b ^ 11011110b = 11101011b
-00110101b ^ 11011111b = 11101010b
-00110101b ^ 11100000b = 11010101b
-00110101b ^ 11100001b = 11010100b
-00110101b ^ 11100010b = 11010111b
-00110101b ^ 11100011b = 11010110b
-00110101b ^ 11100100b = 11010001b
-00110101b ^ 11100101b = 11010000b
-00110101b ^ 11100110b = 11010011b
-00110101b ^ 11100111b = 11010010b
-00110101b ^ 11101000b = 11011101b
-00110101b ^ 11101001b = 11011100b
-00110101b ^ 11101010b = 11011111b
-00110101b ^ 11101011b = 11011110b
-00110101b ^ 11101100b = 11011001b
-00110101b ^ 11101101b = 11011000b
-00110101b ^ 11101110b = 11011011b
-00110101b ^ 11101111b = 11011010b
-00110101b ^ 11110000b = 11000101b
-00110101b ^ 11110001b = 11000100b
-00110101b ^ 11110010b = 11000111b
-00110101b ^ 11110011b = 11000110b
-00110101b ^ 11110100b = 11000001b
-00110101b ^ 11110101b = 11000000b
-00110101b ^ 11110110b = 11000011b
-00110101b ^ 11110111b = 11000010b
-00110101b ^ 11111000b = 11001101b
-00110101b ^ 11111001b = 11001100b
-00110101b ^ 11111010b = 11001111b
-00110101b ^ 11111011b = 11001110b
-00110101b ^ 11111100b = 11001001b
-00110101b ^ 11111101b = 11001000b
-00110101b ^ 11111110b = 11001011b
-00110101b ^ 11111111b = 11001010b
-00110101b ^ 00000000b = 00110101b
-00110101b ^ 00000001b = 00110100b
-00110101b ^ 00000010b = 00110111b
-00110101b ^ 00000011b = 00110110b
-00110101b ^ 00000100b = 00110001b
-00110101b ^ 00000101b = 00110000b
-00110101b ^ 00000110b = 00110011b
-00110101b ^ 00000111b = 00110010b
-00110101b ^ 00001000b = 00111101b
-00110101b ^ 00001001b = 00111100b
-00110101b ^ 00001010b = 00111111b
-00110101b ^ 00001011b = 00111110b
-00110101b ^ 00001100b = 00111001b
-00110101b ^ 00001101b = 00111000b
-00110101b ^ 00001110b = 00111011b
-00110101b ^ 00001111b = 00111010b
-00110101b ^ 00010000b = 00100101b
-00110101b ^ 00010001b = 00100100b
-00110101b ^ 00010010b = 00100111b
-00110101b ^ 00010011b = 00100110b
-00110101b ^ 00010100b = 00100001b
-00110101b ^ 00010101b = 00100000b
-00110101b ^ 00010110b = 00100011b
-00110101b ^ 00010111b = 00100010b
-00110101b ^ 00011000b = 00101101b
-00110101b ^ 00011001b = 00101100b
-00110101b ^ 00011010b = 00101111b
-00110101b ^ 00011011b = 00101110b
-00110101b ^ 00011100b = 00101001b
-00110101b ^ 00011101b = 00101000b
-00110101b ^ 00011110b = 00101011b
-00110101b ^ 00011111b = 00101010b
-00110101b ^ 00100000b = 00010101b
-00110101b ^ 00100001b = 00010100b
-00110101b ^ 00100010b = 00010111b
-00110101b ^ 00100011b = 00010110b
-00110101b ^ 00100100b = 00010001b
-00110101b ^ 00100101b = 00010000b
-00110101b ^ 00100110b = 00010011b
-00110101b ^ 00100111b = 00010010b
-00110101b ^ 00101000b = 00011101b
-00110101b ^ 00101001b = 00011100b
-00110101b ^ 00101010b = 00011111b
-00110101b ^ 00101011b = 00011110b
-00110101b ^ 00101100b = 00011001b
-00110101b ^ 00101101b = 00011000b
-00110101b ^ 00101110b = 00011011b
-00110101b ^ 00101111b = 00011010b
-00110101b ^ 00110000b = 00000101b
-00110101b ^ 00110001b = 00000100b
-00110101b ^ 00110010b = 00000111b
-00110101b ^ 00110011b = 00000110b
-00110101b ^ 00110100b = 00000001b
-00110101b ^ 00110101b = 00000000b
-00110101b ^ 00110110b = 00000011b
-00110101b ^ 00110111b = 00000010b
-00110101b ^ 00111000b = 00001101b
-00110101b ^ 00111001b = 00001100b
-00110101b ^ 00111010b = 00001111b
-00110101b ^ 00111011b = 00001110b
-00110101b ^ 00111100b = 00001001b
-00110101b ^ 00111101b = 00001000b
-00110101b ^ 00111110b = 00001011b
-00110101b ^ 00111111b = 00001010b
-00110101b ^ 01000000b = 01110101b
-00110101b ^ 01000001b = 01110100b
-00110101b ^ 01000010b = 01110111b
-00110101b ^ 01000011b = 01110110b
-00110101b ^ 01000100b = 01110001b
-00110101b ^ 01000101b = 01110000b
-00110101b ^ 01000110b = 01110011b
-00110101b ^ 01000111b = 01110010b
-00110101b ^ 01001000b = 01111101b
-00110101b ^ 01001001b = 01111100b
-00110101b ^ 01001010b = 01111111b
-00110101b ^ 01001011b = 01111110b
-00110101b ^ 01001100b = 01111001b
-00110101b ^ 01001101b = 01111000b
-00110101b ^ 01001110b = 01111011b
-00110101b ^ 01001111b = 01111010b
-00110101b ^ 01010000b = 01100101b
-00110101b ^ 01010001b = 01100100b
-00110101b ^ 01010010b = 01100111b
-00110101b ^ 01010011b = 01100110b
-00110101b ^ 01010100b = 01100001b
-00110101b ^ 01010101b = 01100000b
-00110101b ^ 01010110b = 01100011b
-00110101b ^ 01010111b = 01100010b
-00110101b ^ 01011000b = 01101101b
-00110101b ^ 01011001b = 01101100b
-00110101b ^ 01011010b = 01101111b
-00110101b ^ 01011011b = 01101110b
-00110101b ^ 01011100b = 01101001b
-00110101b ^ 01011101b = 01101000b
-00110101b ^ 01011110b = 01101011b
-00110101b ^ 01011111b = 01101010b
-00110101b ^ 01100000b = 01010101b
-00110101b ^ 01100001b = 01010100b
-00110101b ^ 01100010b = 01010111b
-00110101b ^ 01100011b = 01010110b
-00110101b ^ 01100100b = 01010001b
-00110101b ^ 01100101b = 01010000b
-00110101b ^ 01100110b = 01010011b
-00110101b ^ 01100111b = 01010010b
-00110101b ^ 01101000b = 01011101b
-00110101b ^ 01101001b = 01011100b
-00110101b ^ 01101010b = 01011111b
-00110101b ^ 01101011b = 01011110b
-00110101b ^ 01101100b = 01011001b
-00110101b ^ 01101101b = 01011000b
-00110101b ^ 01101110b = 01011011b
-00110101b ^ 01101111b = 01011010b
-00110101b ^ 01110000b = 01000101b
-00110101b ^ 01110001b = 01000100b
-00110101b ^ 01110010b = 01000111b
-00110101b ^ 01110011b = 01000110b
-00110101b ^ 01110100b = 01000001b
-00110101b ^ 01110101b = 01000000b
-00110101b ^ 01110110b = 01000011b
-00110101b ^ 01110111b = 01000010b
-00110101b ^ 01111000b = 01001101b
-00110101b ^ 01111001b = 01001100b
-00110101b ^ 01111010b = 01001111b
-00110101b ^ 01111011b = 01001110b
-00110101b ^ 01111100b = 01001001b
-00110101b ^ 01111101b = 01001000b
-00110101b ^ 01111110b = 01001011b
-00110110b ^ 10000000b = 10110110b
-00110110b ^ 10000001b = 10110111b
-00110110b ^ 10000010b = 10110100b
-00110110b ^ 10000011b = 10110101b
-00110110b ^ 10000100b = 10110010b
-00110110b ^ 10000101b = 10110011b
-00110110b ^ 10000110b = 10110000b
-00110110b ^ 10000111b = 10110001b
-00110110b ^ 10001000b = 10111110b
-00110110b ^ 10001001b = 10111111b
-00110110b ^ 10001010b = 10111100b
-00110110b ^ 10001011b = 10111101b
-00110110b ^ 10001100b = 10111010b
-00110110b ^ 10001101b = 10111011b
-00110110b ^ 10001110b = 10111000b
-00110110b ^ 10001111b = 10111001b
-00110110b ^ 10010000b = 10100110b
-00110110b ^ 10010001b = 10100111b
-00110110b ^ 10010010b = 10100100b
-00110110b ^ 10010011b = 10100101b
-00110110b ^ 10010100b = 10100010b
-00110110b ^ 10010101b = 10100011b
-00110110b ^ 10010110b = 10100000b
-00110110b ^ 10010111b = 10100001b
-00110110b ^ 10011000b = 10101110b
-00110110b ^ 10011001b = 10101111b
-00110110b ^ 10011010b = 10101100b
-00110110b ^ 10011011b = 10101101b
-00110110b ^ 10011100b = 10101010b
-00110110b ^ 10011101b = 10101011b
-00110110b ^ 10011110b = 10101000b
-00110110b ^ 10011111b = 10101001b
-00110110b ^ 10100000b = 10010110b
-00110110b ^ 10100001b = 10010111b
-00110110b ^ 10100010b = 10010100b
-00110110b ^ 10100011b = 10010101b
-00110110b ^ 10100100b = 10010010b
-00110110b ^ 10100101b = 10010011b
-00110110b ^ 10100110b = 10010000b
-00110110b ^ 10100111b = 10010001b
-00110110b ^ 10101000b = 10011110b
-00110110b ^ 10101001b = 10011111b
-00110110b ^ 10101010b = 10011100b
-00110110b ^ 10101011b = 10011101b
-00110110b ^ 10101100b = 10011010b
-00110110b ^ 10101101b = 10011011b
-00110110b ^ 10101110b = 10011000b
-00110110b ^ 10101111b = 10011001b
-00110110b ^ 10110000b = 10000110b
-00110110b ^ 10110001b = 10000111b
-00110110b ^ 10110010b = 10000100b
-00110110b ^ 10110011b = 10000101b
-00110110b ^ 10110100b = 10000010b
-00110110b ^ 10110101b = 10000011b
-00110110b ^ 10110110b = 10000000b
-00110110b ^ 10110111b = 10000001b
-00110110b ^ 10111000b = 10001110b
-00110110b ^ 10111001b = 10001111b
-00110110b ^ 10111010b = 10001100b
-00110110b ^ 10111011b = 10001101b
-00110110b ^ 10111100b = 10001010b
-00110110b ^ 10111101b = 10001011b
-00110110b ^ 10111110b = 10001000b
-00110110b ^ 10111111b = 10001001b
-00110110b ^ 11000000b = 11110110b
-00110110b ^ 11000001b = 11110111b
-00110110b ^ 11000010b = 11110100b
-00110110b ^ 11000011b = 11110101b
-00110110b ^ 11000100b = 11110010b
-00110110b ^ 11000101b = 11110011b
-00110110b ^ 11000110b = 11110000b
-00110110b ^ 11000111b = 11110001b
-00110110b ^ 11001000b = 11111110b
-00110110b ^ 11001001b = 11111111b
-00110110b ^ 11001010b = 11111100b
-00110110b ^ 11001011b = 11111101b
-00110110b ^ 11001100b = 11111010b
-00110110b ^ 11001101b = 11111011b
-00110110b ^ 11001110b = 11111000b
-00110110b ^ 11001111b = 11111001b
-00110110b ^ 11010000b = 11100110b
-00110110b ^ 11010001b = 11100111b
-00110110b ^ 11010010b = 11100100b
-00110110b ^ 11010011b = 11100101b
-00110110b ^ 11010100b = 11100010b
-00110110b ^ 11010101b = 11100011b
-00110110b ^ 11010110b = 11100000b
-00110110b ^ 11010111b = 11100001b
-00110110b ^ 11011000b = 11101110b
-00110110b ^ 11011001b = 11101111b
-00110110b ^ 11011010b = 11101100b
-00110110b ^ 11011011b = 11101101b
-00110110b ^ 11011100b = 11101010b
-00110110b ^ 11011101b = 11101011b
-00110110b ^ 11011110b = 11101000b
-00110110b ^ 11011111b = 11101001b
-00110110b ^ 11100000b = 11010110b
-00110110b ^ 11100001b = 11010111b
-00110110b ^ 11100010b = 11010100b
-00110110b ^ 11100011b = 11010101b
-00110110b ^ 11100100b = 11010010b
-00110110b ^ 11100101b = 11010011b
-00110110b ^ 11100110b = 11010000b
-00110110b ^ 11100111b = 11010001b
-00110110b ^ 11101000b = 11011110b
-00110110b ^ 11101001b = 11011111b
-00110110b ^ 11101010b = 11011100b
-00110110b ^ 11101011b = 11011101b
-00110110b ^ 11101100b = 11011010b
-00110110b ^ 11101101b = 11011011b
-00110110b ^ 11101110b = 11011000b
-00110110b ^ 11101111b = 11011001b
-00110110b ^ 11110000b = 11000110b
-00110110b ^ 11110001b = 11000111b
-00110110b ^ 11110010b = 11000100b
-00110110b ^ 11110011b = 11000101b
-00110110b ^ 11110100b = 11000010b
-00110110b ^ 11110101b = 11000011b
-00110110b ^ 11110110b = 11000000b
-00110110b ^ 11110111b = 11000001b
-00110110b ^ 11111000b = 11001110b
-00110110b ^ 11111001b = 11001111b
-00110110b ^ 11111010b = 11001100b
-00110110b ^ 11111011b = 11001101b
-00110110b ^ 11111100b = 11001010b
-00110110b ^ 11111101b = 11001011b
-00110110b ^ 11111110b = 11001000b
-00110110b ^ 11111111b = 11001001b
-00110110b ^ 00000000b = 00110110b
-00110110b ^ 00000001b = 00110111b
-00110110b ^ 00000010b = 00110100b
-00110110b ^ 00000011b = 00110101b
-00110110b ^ 00000100b = 00110010b
-00110110b ^ 00000101b = 00110011b
-00110110b ^ 00000110b = 00110000b
-00110110b ^ 00000111b = 00110001b
-00110110b ^ 00001000b = 00111110b
-00110110b ^ 00001001b = 00111111b
-00110110b ^ 00001010b = 00111100b
-00110110b ^ 00001011b = 00111101b
-00110110b ^ 00001100b = 00111010b
-00110110b ^ 00001101b = 00111011b
-00110110b ^ 00001110b = 00111000b
-00110110b ^ 00001111b = 00111001b
-00110110b ^ 00010000b = 00100110b
-00110110b ^ 00010001b = 00100111b
-00110110b ^ 00010010b = 00100100b
-00110110b ^ 00010011b = 00100101b
-00110110b ^ 00010100b = 00100010b
-00110110b ^ 00010101b = 00100011b
-00110110b ^ 00010110b = 00100000b
-00110110b ^ 00010111b = 00100001b
-00110110b ^ 00011000b = 00101110b
-00110110b ^ 00011001b = 00101111b
-00110110b ^ 00011010b = 00101100b
-00110110b ^ 00011011b = 00101101b
-00110110b ^ 00011100b = 00101010b
-00110110b ^ 00011101b = 00101011b
-00110110b ^ 00011110b = 00101000b
-00110110b ^ 00011111b = 00101001b
-00110110b ^ 00100000b = 00010110b
-00110110b ^ 00100001b = 00010111b
-00110110b ^ 00100010b = 00010100b
-00110110b ^ 00100011b = 00010101b
-00110110b ^ 00100100b = 00010010b
-00110110b ^ 00100101b = 00010011b
-00110110b ^ 00100110b = 00010000b
-00110110b ^ 00100111b = 00010001b
-00110110b ^ 00101000b = 00011110b
-00110110b ^ 00101001b = 00011111b
-00110110b ^ 00101010b = 00011100b
-00110110b ^ 00101011b = 00011101b
-00110110b ^ 00101100b = 00011010b
-00110110b ^ 00101101b = 00011011b
-00110110b ^ 00101110b = 00011000b
-00110110b ^ 00101111b = 00011001b
-00110110b ^ 00110000b = 00000110b
-00110110b ^ 00110001b = 00000111b
-00110110b ^ 00110010b = 00000100b
-00110110b ^ 00110011b = 00000101b
-00110110b ^ 00110100b = 00000010b
-00110110b ^ 00110101b = 00000011b
-00110110b ^ 00110110b = 00000000b
-00110110b ^ 00110111b = 00000001b
-00110110b ^ 00111000b = 00001110b
-00110110b ^ 00111001b = 00001111b
-00110110b ^ 00111010b = 00001100b
-00110110b ^ 00111011b = 00001101b
-00110110b ^ 00111100b = 00001010b
-00110110b ^ 00111101b = 00001011b
-00110110b ^ 00111110b = 00001000b
-00110110b ^ 00111111b = 00001001b
-00110110b ^ 01000000b = 01110110b
-00110110b ^ 01000001b = 01110111b
-00110110b ^ 01000010b = 01110100b
-00110110b ^ 01000011b = 01110101b
-00110110b ^ 01000100b = 01110010b
-00110110b ^ 01000101b = 01110011b
-00110110b ^ 01000110b = 01110000b
-00110110b ^ 01000111b = 01110001b
-00110110b ^ 01001000b = 01111110b
-00110110b ^ 01001001b = 01111111b
-00110110b ^ 01001010b = 01111100b
-00110110b ^ 01001011b = 01111101b
-00110110b ^ 01001100b = 01111010b
-00110110b ^ 01001101b = 01111011b
-00110110b ^ 01001110b = 01111000b
-00110110b ^ 01001111b = 01111001b
-00110110b ^ 01010000b = 01100110b
-00110110b ^ 01010001b = 01100111b
-00110110b ^ 01010010b = 01100100b
-00110110b ^ 01010011b = 01100101b
-00110110b ^ 01010100b = 01100010b
-00110110b ^ 01010101b = 01100011b
-00110110b ^ 01010110b = 01100000b
-00110110b ^ 01010111b = 01100001b
-00110110b ^ 01011000b = 01101110b
-00110110b ^ 01011001b = 01101111b
-00110110b ^ 01011010b = 01101100b
-00110110b ^ 01011011b = 01101101b
-00110110b ^ 01011100b = 01101010b
-00110110b ^ 01011101b = 01101011b
-00110110b ^ 01011110b = 01101000b
-00110110b ^ 01011111b = 01101001b
-00110110b ^ 01100000b = 01010110b
-00110110b ^ 01100001b = 01010111b
-00110110b ^ 01100010b = 01010100b
-00110110b ^ 01100011b = 01010101b
-00110110b ^ 01100100b = 01010010b
-00110110b ^ 01100101b = 01010011b
-00110110b ^ 01100110b = 01010000b
-00110110b ^ 01100111b = 01010001b
-00110110b ^ 01101000b = 01011110b
-00110110b ^ 01101001b = 01011111b
-00110110b ^ 01101010b = 01011100b
-00110110b ^ 01101011b = 01011101b
-00110110b ^ 01101100b = 01011010b
-00110110b ^ 01101101b = 01011011b
-00110110b ^ 01101110b = 01011000b
-00110110b ^ 01101111b = 01011001b
-00110110b ^ 01110000b = 01000110b
-00110110b ^ 01110001b = 01000111b
-00110110b ^ 01110010b = 01000100b
-00110110b ^ 01110011b = 01000101b
-00110110b ^ 01110100b = 01000010b
-00110110b ^ 01110101b = 01000011b
-00110110b ^ 01110110b = 01000000b
-00110110b ^ 01110111b = 01000001b
-00110110b ^ 01111000b = 01001110b
-00110110b ^ 01111001b = 01001111b
-00110110b ^ 01111010b = 01001100b
-00110110b ^ 01111011b = 01001101b
-00110110b ^ 01111100b = 01001010b
-00110110b ^ 01111101b = 01001011b
-00110110b ^ 01111110b = 01001000b
-00110111b ^ 10000000b = 10110111b
-00110111b ^ 10000001b = 10110110b
-00110111b ^ 10000010b = 10110101b
-00110111b ^ 10000011b = 10110100b
-00110111b ^ 10000100b = 10110011b
-00110111b ^ 10000101b = 10110010b
-00110111b ^ 10000110b = 10110001b
-00110111b ^ 10000111b = 10110000b
-00110111b ^ 10001000b = 10111111b
-00110111b ^ 10001001b = 10111110b
-00110111b ^ 10001010b = 10111101b
-00110111b ^ 10001011b = 10111100b
-00110111b ^ 10001100b = 10111011b
-00110111b ^ 10001101b = 10111010b
-00110111b ^ 10001110b = 10111001b
-00110111b ^ 10001111b = 10111000b
-00110111b ^ 10010000b = 10100111b
-00110111b ^ 10010001b = 10100110b
-00110111b ^ 10010010b = 10100101b
-00110111b ^ 10010011b = 10100100b
-00110111b ^ 10010100b = 10100011b
-00110111b ^ 10010101b = 10100010b
-00110111b ^ 10010110b = 10100001b
-00110111b ^ 10010111b = 10100000b
-00110111b ^ 10011000b = 10101111b
-00110111b ^ 10011001b = 10101110b
-00110111b ^ 10011010b = 10101101b
-00110111b ^ 10011011b = 10101100b
-00110111b ^ 10011100b = 10101011b
-00110111b ^ 10011101b = 10101010b
-00110111b ^ 10011110b = 10101001b
-00110111b ^ 10011111b = 10101000b
-00110111b ^ 10100000b = 10010111b
-00110111b ^ 10100001b = 10010110b
-00110111b ^ 10100010b = 10010101b
-00110111b ^ 10100011b = 10010100b
-00110111b ^ 10100100b = 10010011b
-00110111b ^ 10100101b = 10010010b
-00110111b ^ 10100110b = 10010001b
-00110111b ^ 10100111b = 10010000b
-00110111b ^ 10101000b = 10011111b
-00110111b ^ 10101001b = 10011110b
-00110111b ^ 10101010b = 10011101b
-00110111b ^ 10101011b = 10011100b
-00110111b ^ 10101100b = 10011011b
-00110111b ^ 10101101b = 10011010b
-00110111b ^ 10101110b = 10011001b
-00110111b ^ 10101111b = 10011000b
-00110111b ^ 10110000b = 10000111b
-00110111b ^ 10110001b = 10000110b
-00110111b ^ 10110010b = 10000101b
-00110111b ^ 10110011b = 10000100b
-00110111b ^ 10110100b = 10000011b
-00110111b ^ 10110101b = 10000010b
-00110111b ^ 10110110b = 10000001b
-00110111b ^ 10110111b = 10000000b
-00110111b ^ 10111000b = 10001111b
-00110111b ^ 10111001b = 10001110b
-00110111b ^ 10111010b = 10001101b
-00110111b ^ 10111011b = 10001100b
-00110111b ^ 10111100b = 10001011b
-00110111b ^ 10111101b = 10001010b
-00110111b ^ 10111110b = 10001001b
-00110111b ^ 10111111b = 10001000b
-00110111b ^ 11000000b = 11110111b
-00110111b ^ 11000001b = 11110110b
-00110111b ^ 11000010b = 11110101b
-00110111b ^ 11000011b = 11110100b
-00110111b ^ 11000100b = 11110011b
-00110111b ^ 11000101b = 11110010b
-00110111b ^ 11000110b = 11110001b
-00110111b ^ 11000111b = 11110000b
-00110111b ^ 11001000b = 11111111b
-00110111b ^ 11001001b = 11111110b
-00110111b ^ 11001010b = 11111101b
-00110111b ^ 11001011b = 11111100b
-00110111b ^ 11001100b = 11111011b
-00110111b ^ 11001101b = 11111010b
-00110111b ^ 11001110b = 11111001b
-00110111b ^ 11001111b = 11111000b
-00110111b ^ 11010000b = 11100111b
-00110111b ^ 11010001b = 11100110b
-00110111b ^ 11010010b = 11100101b
-00110111b ^ 11010011b = 11100100b
-00110111b ^ 11010100b = 11100011b
-00110111b ^ 11010101b = 11100010b
-00110111b ^ 11010110b = 11100001b
-00110111b ^ 11010111b = 11100000b
-00110111b ^ 11011000b = 11101111b
-00110111b ^ 11011001b = 11101110b
-00110111b ^ 11011010b = 11101101b
-00110111b ^ 11011011b = 11101100b
-00110111b ^ 11011100b = 11101011b
-00110111b ^ 11011101b = 11101010b
-00110111b ^ 11011110b = 11101001b
-00110111b ^ 11011111b = 11101000b
-00110111b ^ 11100000b = 11010111b
-00110111b ^ 11100001b = 11010110b
-00110111b ^ 11100010b = 11010101b
-00110111b ^ 11100011b = 11010100b
-00110111b ^ 11100100b = 11010011b
-00110111b ^ 11100101b = 11010010b
-00110111b ^ 11100110b = 11010001b
-00110111b ^ 11100111b = 11010000b
-00110111b ^ 11101000b = 11011111b
-00110111b ^ 11101001b = 11011110b
-00110111b ^ 11101010b = 11011101b
-00110111b ^ 11101011b = 11011100b
-00110111b ^ 11101100b = 11011011b
-00110111b ^ 11101101b = 11011010b
-00110111b ^ 11101110b = 11011001b
-00110111b ^ 11101111b = 11011000b
-00110111b ^ 11110000b = 11000111b
-00110111b ^ 11110001b = 11000110b
-00110111b ^ 11110010b = 11000101b
-00110111b ^ 11110011b = 11000100b
-00110111b ^ 11110100b = 11000011b
-00110111b ^ 11110101b = 11000010b
-00110111b ^ 11110110b = 11000001b
-00110111b ^ 11110111b = 11000000b
-00110111b ^ 11111000b = 11001111b
-00110111b ^ 11111001b = 11001110b
-00110111b ^ 11111010b = 11001101b
-00110111b ^ 11111011b = 11001100b
-00110111b ^ 11111100b = 11001011b
-00110111b ^ 11111101b = 11001010b
-00110111b ^ 11111110b = 11001001b
-00110111b ^ 11111111b = 11001000b
-00110111b ^ 00000000b = 00110111b
-00110111b ^ 00000001b = 00110110b
-00110111b ^ 00000010b = 00110101b
-00110111b ^ 00000011b = 00110100b
-00110111b ^ 00000100b = 00110011b
-00110111b ^ 00000101b = 00110010b
-00110111b ^ 00000110b = 00110001b
-00110111b ^ 00000111b = 00110000b
-00110111b ^ 00001000b = 00111111b
-00110111b ^ 00001001b = 00111110b
-00110111b ^ 00001010b = 00111101b
-00110111b ^ 00001011b = 00111100b
-00110111b ^ 00001100b = 00111011b
-00110111b ^ 00001101b = 00111010b
-00110111b ^ 00001110b = 00111001b
-00110111b ^ 00001111b = 00111000b
-00110111b ^ 00010000b = 00100111b
-00110111b ^ 00010001b = 00100110b
-00110111b ^ 00010010b = 00100101b
-00110111b ^ 00010011b = 00100100b
-00110111b ^ 00010100b = 00100011b
-00110111b ^ 00010101b = 00100010b
-00110111b ^ 00010110b = 00100001b
-00110111b ^ 00010111b = 00100000b
-00110111b ^ 00011000b = 00101111b
-00110111b ^ 00011001b = 00101110b
-00110111b ^ 00011010b = 00101101b
-00110111b ^ 00011011b = 00101100b
-00110111b ^ 00011100b = 00101011b
-00110111b ^ 00011101b = 00101010b
-00110111b ^ 00011110b = 00101001b
-00110111b ^ 00011111b = 00101000b
-00110111b ^ 00100000b = 00010111b
-00110111b ^ 00100001b = 00010110b
-00110111b ^ 00100010b = 00010101b
-00110111b ^ 00100011b = 00010100b
-00110111b ^ 00100100b = 00010011b
-00110111b ^ 00100101b = 00010010b
-00110111b ^ 00100110b = 00010001b
-00110111b ^ 00100111b = 00010000b
-00110111b ^ 00101000b = 00011111b
-00110111b ^ 00101001b = 00011110b
-00110111b ^ 00101010b = 00011101b
-00110111b ^ 00101011b = 00011100b
-00110111b ^ 00101100b = 00011011b
-00110111b ^ 00101101b = 00011010b
-00110111b ^ 00101110b = 00011001b
-00110111b ^ 00101111b = 00011000b
-00110111b ^ 00110000b = 00000111b
-00110111b ^ 00110001b = 00000110b
-00110111b ^ 00110010b = 00000101b
-00110111b ^ 00110011b = 00000100b
-00110111b ^ 00110100b = 00000011b
-00110111b ^ 00110101b = 00000010b
-00110111b ^ 00110110b = 00000001b
-00110111b ^ 00110111b = 00000000b
-00110111b ^ 00111000b = 00001111b
-00110111b ^ 00111001b = 00001110b
-00110111b ^ 00111010b = 00001101b
-00110111b ^ 00111011b = 00001100b
-00110111b ^ 00111100b = 00001011b
-00110111b ^ 00111101b = 00001010b
-00110111b ^ 00111110b = 00001001b
-00110111b ^ 00111111b = 00001000b
-00110111b ^ 01000000b = 01110111b
-00110111b ^ 01000001b = 01110110b
-00110111b ^ 01000010b = 01110101b
-00110111b ^ 01000011b = 01110100b
-00110111b ^ 01000100b = 01110011b
-00110111b ^ 01000101b = 01110010b
-00110111b ^ 01000110b = 01110001b
-00110111b ^ 01000111b = 01110000b
-00110111b ^ 01001000b = 01111111b
-00110111b ^ 01001001b = 01111110b
-00110111b ^ 01001010b = 01111101b
-00110111b ^ 01001011b = 01111100b
-00110111b ^ 01001100b = 01111011b
-00110111b ^ 01001101b = 01111010b
-00110111b ^ 01001110b = 01111001b
-00110111b ^ 01001111b = 01111000b
-00110111b ^ 01010000b = 01100111b
-00110111b ^ 01010001b = 01100110b
-00110111b ^ 01010010b = 01100101b
-00110111b ^ 01010011b = 01100100b
-00110111b ^ 01010100b = 01100011b
-00110111b ^ 01010101b = 01100010b
-00110111b ^ 01010110b = 01100001b
-00110111b ^ 01010111b = 01100000b
-00110111b ^ 01011000b = 01101111b
-00110111b ^ 01011001b = 01101110b
-00110111b ^ 01011010b = 01101101b
-00110111b ^ 01011011b = 01101100b
-00110111b ^ 01011100b = 01101011b
-00110111b ^ 01011101b = 01101010b
-00110111b ^ 01011110b = 01101001b
-00110111b ^ 01011111b = 01101000b
-00110111b ^ 01100000b = 01010111b
-00110111b ^ 01100001b = 01010110b
-00110111b ^ 01100010b = 01010101b
-00110111b ^ 01100011b = 01010100b
-00110111b ^ 01100100b = 01010011b
-00110111b ^ 01100101b = 01010010b
-00110111b ^ 01100110b = 01010001b
-00110111b ^ 01100111b = 01010000b
-00110111b ^ 01101000b = 01011111b
-00110111b ^ 01101001b = 01011110b
-00110111b ^ 01101010b = 01011101b
-00110111b ^ 01101011b = 01011100b
-00110111b ^ 01101100b = 01011011b
-00110111b ^ 01101101b = 01011010b
-00110111b ^ 01101110b = 01011001b
-00110111b ^ 01101111b = 01011000b
-00110111b ^ 01110000b = 01000111b
-00110111b ^ 01110001b = 01000110b
-00110111b ^ 01110010b = 01000101b
-00110111b ^ 01110011b = 01000100b
-00110111b ^ 01110100b = 01000011b
-00110111b ^ 01110101b = 01000010b
-00110111b ^ 01110110b = 01000001b
-00110111b ^ 01110111b = 01000000b
-00110111b ^ 01111000b = 01001111b
-00110111b ^ 01111001b = 01001110b
-00110111b ^ 01111010b = 01001101b
-00110111b ^ 01111011b = 01001100b
-00110111b ^ 01111100b = 01001011b
-00110111b ^ 01111101b = 01001010b
-00110111b ^ 01111110b = 01001001b
-00111000b ^ 10000000b = 10111000b
-00111000b ^ 10000001b = 10111001b
-00111000b ^ 10000010b = 10111010b
-00111000b ^ 10000011b = 10111011b
-00111000b ^ 10000100b = 10111100b
-00111000b ^ 10000101b = 10111101b
-00111000b ^ 10000110b = 10111110b
-00111000b ^ 10000111b = 10111111b
-00111000b ^ 10001000b = 10110000b
-00111000b ^ 10001001b = 10110001b
-00111000b ^ 10001010b = 10110010b
-00111000b ^ 10001011b = 10110011b
-00111000b ^ 10001100b = 10110100b
-00111000b ^ 10001101b = 10110101b
-00111000b ^ 10001110b = 10110110b
-00111000b ^ 10001111b = 10110111b
-00111000b ^ 10010000b = 10101000b
-00111000b ^ 10010001b = 10101001b
-00111000b ^ 10010010b = 10101010b
-00111000b ^ 10010011b = 10101011b
-00111000b ^ 10010100b = 10101100b
-00111000b ^ 10010101b = 10101101b
-00111000b ^ 10010110b = 10101110b
-00111000b ^ 10010111b = 10101111b
-00111000b ^ 10011000b = 10100000b
-00111000b ^ 10011001b = 10100001b
-00111000b ^ 10011010b = 10100010b
-00111000b ^ 10011011b = 10100011b
-00111000b ^ 10011100b = 10100100b
-00111000b ^ 10011101b = 10100101b
-00111000b ^ 10011110b = 10100110b
-00111000b ^ 10011111b = 10100111b
-00111000b ^ 10100000b = 10011000b
-00111000b ^ 10100001b = 10011001b
-00111000b ^ 10100010b = 10011010b
-00111000b ^ 10100011b = 10011011b
-00111000b ^ 10100100b = 10011100b
-00111000b ^ 10100101b = 10011101b
-00111000b ^ 10100110b = 10011110b
-00111000b ^ 10100111b = 10011111b
-00111000b ^ 10101000b = 10010000b
-00111000b ^ 10101001b = 10010001b
-00111000b ^ 10101010b = 10010010b
-00111000b ^ 10101011b = 10010011b
-00111000b ^ 10101100b = 10010100b
-00111000b ^ 10101101b = 10010101b
-00111000b ^ 10101110b = 10010110b
-00111000b ^ 10101111b = 10010111b
-00111000b ^ 10110000b = 10001000b
-00111000b ^ 10110001b = 10001001b
-00111000b ^ 10110010b = 10001010b
-00111000b ^ 10110011b = 10001011b
-00111000b ^ 10110100b = 10001100b
-00111000b ^ 10110101b = 10001101b
-00111000b ^ 10110110b = 10001110b
-00111000b ^ 10110111b = 10001111b
-00111000b ^ 10111000b = 10000000b
-00111000b ^ 10111001b = 10000001b
-00111000b ^ 10111010b = 10000010b
-00111000b ^ 10111011b = 10000011b
-00111000b ^ 10111100b = 10000100b
-00111000b ^ 10111101b = 10000101b
-00111000b ^ 10111110b = 10000110b
-00111000b ^ 10111111b = 10000111b
-00111000b ^ 11000000b = 11111000b
-00111000b ^ 11000001b = 11111001b
-00111000b ^ 11000010b = 11111010b
-00111000b ^ 11000011b = 11111011b
-00111000b ^ 11000100b = 11111100b
-00111000b ^ 11000101b = 11111101b
-00111000b ^ 11000110b = 11111110b
-00111000b ^ 11000111b = 11111111b
-00111000b ^ 11001000b = 11110000b
-00111000b ^ 11001001b = 11110001b
-00111000b ^ 11001010b = 11110010b
-00111000b ^ 11001011b = 11110011b
-00111000b ^ 11001100b = 11110100b
-00111000b ^ 11001101b = 11110101b
-00111000b ^ 11001110b = 11110110b
-00111000b ^ 11001111b = 11110111b
-00111000b ^ 11010000b = 11101000b
-00111000b ^ 11010001b = 11101001b
-00111000b ^ 11010010b = 11101010b
-00111000b ^ 11010011b = 11101011b
-00111000b ^ 11010100b = 11101100b
-00111000b ^ 11010101b = 11101101b
-00111000b ^ 11010110b = 11101110b
-00111000b ^ 11010111b = 11101111b
-00111000b ^ 11011000b = 11100000b
-00111000b ^ 11011001b = 11100001b
-00111000b ^ 11011010b = 11100010b
-00111000b ^ 11011011b = 11100011b
-00111000b ^ 11011100b = 11100100b
-00111000b ^ 11011101b = 11100101b
-00111000b ^ 11011110b = 11100110b
-00111000b ^ 11011111b = 11100111b
-00111000b ^ 11100000b = 11011000b
-00111000b ^ 11100001b = 11011001b
-00111000b ^ 11100010b = 11011010b
-00111000b ^ 11100011b = 11011011b
-00111000b ^ 11100100b = 11011100b
-00111000b ^ 11100101b = 11011101b
-00111000b ^ 11100110b = 11011110b
-00111000b ^ 11100111b = 11011111b
-00111000b ^ 11101000b = 11010000b
-00111000b ^ 11101001b = 11010001b
-00111000b ^ 11101010b = 11010010b
-00111000b ^ 11101011b = 11010011b
-00111000b ^ 11101100b = 11010100b
-00111000b ^ 11101101b = 11010101b
-00111000b ^ 11101110b = 11010110b
-00111000b ^ 11101111b = 11010111b
-00111000b ^ 11110000b = 11001000b
-00111000b ^ 11110001b = 11001001b
-00111000b ^ 11110010b = 11001010b
-00111000b ^ 11110011b = 11001011b
-00111000b ^ 11110100b = 11001100b
-00111000b ^ 11110101b = 11001101b
-00111000b ^ 11110110b = 11001110b
-00111000b ^ 11110111b = 11001111b
-00111000b ^ 11111000b = 11000000b
-00111000b ^ 11111001b = 11000001b
-00111000b ^ 11111010b = 11000010b
-00111000b ^ 11111011b = 11000011b
-00111000b ^ 11111100b = 11000100b
-00111000b ^ 11111101b = 11000101b
-00111000b ^ 11111110b = 11000110b
-00111000b ^ 11111111b = 11000111b
-00111000b ^ 00000000b = 00111000b
-00111000b ^ 00000001b = 00111001b
-00111000b ^ 00000010b = 00111010b
-00111000b ^ 00000011b = 00111011b
-00111000b ^ 00000100b = 00111100b
-00111000b ^ 00000101b = 00111101b
-00111000b ^ 00000110b = 00111110b
-00111000b ^ 00000111b = 00111111b
-00111000b ^ 00001000b = 00110000b
-00111000b ^ 00001001b = 00110001b
-00111000b ^ 00001010b = 00110010b
-00111000b ^ 00001011b = 00110011b
-00111000b ^ 00001100b = 00110100b
-00111000b ^ 00001101b = 00110101b
-00111000b ^ 00001110b = 00110110b
-00111000b ^ 00001111b = 00110111b
-00111000b ^ 00010000b = 00101000b
-00111000b ^ 00010001b = 00101001b
-00111000b ^ 00010010b = 00101010b
-00111000b ^ 00010011b = 00101011b
-00111000b ^ 00010100b = 00101100b
-00111000b ^ 00010101b = 00101101b
-00111000b ^ 00010110b = 00101110b
-00111000b ^ 00010111b = 00101111b
-00111000b ^ 00011000b = 00100000b
-00111000b ^ 00011001b = 00100001b
-00111000b ^ 00011010b = 00100010b
-00111000b ^ 00011011b = 00100011b
-00111000b ^ 00011100b = 00100100b
-00111000b ^ 00011101b = 00100101b
-00111000b ^ 00011110b = 00100110b
-00111000b ^ 00011111b = 00100111b
-00111000b ^ 00100000b = 00011000b
-00111000b ^ 00100001b = 00011001b
-00111000b ^ 00100010b = 00011010b
-00111000b ^ 00100011b = 00011011b
-00111000b ^ 00100100b = 00011100b
-00111000b ^ 00100101b = 00011101b
-00111000b ^ 00100110b = 00011110b
-00111000b ^ 00100111b = 00011111b
-00111000b ^ 00101000b = 00010000b
-00111000b ^ 00101001b = 00010001b
-00111000b ^ 00101010b = 00010010b
-00111000b ^ 00101011b = 00010011b
-00111000b ^ 00101100b = 00010100b
-00111000b ^ 00101101b = 00010101b
-00111000b ^ 00101110b = 00010110b
-00111000b ^ 00101111b = 00010111b
-00111000b ^ 00110000b = 00001000b
-00111000b ^ 00110001b = 00001001b
-00111000b ^ 00110010b = 00001010b
-00111000b ^ 00110011b = 00001011b
-00111000b ^ 00110100b = 00001100b
-00111000b ^ 00110101b = 00001101b
-00111000b ^ 00110110b = 00001110b
-00111000b ^ 00110111b = 00001111b
-00111000b ^ 00111000b = 00000000b
-00111000b ^ 00111001b = 00000001b
-00111000b ^ 00111010b = 00000010b
-00111000b ^ 00111011b = 00000011b
-00111000b ^ 00111100b = 00000100b
-00111000b ^ 00111101b = 00000101b
-00111000b ^ 00111110b = 00000110b
-00111000b ^ 00111111b = 00000111b
-00111000b ^ 01000000b = 01111000b
-00111000b ^ 01000001b = 01111001b
-00111000b ^ 01000010b = 01111010b
-00111000b ^ 01000011b = 01111011b
-00111000b ^ 01000100b = 01111100b
-00111000b ^ 01000101b = 01111101b
-00111000b ^ 01000110b = 01111110b
-00111000b ^ 01000111b = 01111111b
-00111000b ^ 01001000b = 01110000b
-00111000b ^ 01001001b = 01110001b
-00111000b ^ 01001010b = 01110010b
-00111000b ^ 01001011b = 01110011b
-00111000b ^ 01001100b = 01110100b
-00111000b ^ 01001101b = 01110101b
-00111000b ^ 01001110b = 01110110b
-00111000b ^ 01001111b = 01110111b
-00111000b ^ 01010000b = 01101000b
-00111000b ^ 01010001b = 01101001b
-00111000b ^ 01010010b = 01101010b
-00111000b ^ 01010011b = 01101011b
-00111000b ^ 01010100b = 01101100b
-00111000b ^ 01010101b = 01101101b
-00111000b ^ 01010110b = 01101110b
-00111000b ^ 01010111b = 01101111b
-00111000b ^ 01011000b = 01100000b
-00111000b ^ 01011001b = 01100001b
-00111000b ^ 01011010b = 01100010b
-00111000b ^ 01011011b = 01100011b
-00111000b ^ 01011100b = 01100100b
-00111000b ^ 01011101b = 01100101b
-00111000b ^ 01011110b = 01100110b
-00111000b ^ 01011111b = 01100111b
-00111000b ^ 01100000b = 01011000b
-00111000b ^ 01100001b = 01011001b
-00111000b ^ 01100010b = 01011010b
-00111000b ^ 01100011b = 01011011b
-00111000b ^ 01100100b = 01011100b
-00111000b ^ 01100101b = 01011101b
-00111000b ^ 01100110b = 01011110b
-00111000b ^ 01100111b = 01011111b
-00111000b ^ 01101000b = 01010000b
-00111000b ^ 01101001b = 01010001b
-00111000b ^ 01101010b = 01010010b
-00111000b ^ 01101011b = 01010011b
-00111000b ^ 01101100b = 01010100b
-00111000b ^ 01101101b = 01010101b
-00111000b ^ 01101110b = 01010110b
-00111000b ^ 01101111b = 01010111b
-00111000b ^ 01110000b = 01001000b
-00111000b ^ 01110001b = 01001001b
-00111000b ^ 01110010b = 01001010b
-00111000b ^ 01110011b = 01001011b
-00111000b ^ 01110100b = 01001100b
-00111000b ^ 01110101b = 01001101b
-00111000b ^ 01110110b = 01001110b
-00111000b ^ 01110111b = 01001111b
-00111000b ^ 01111000b = 01000000b
-00111000b ^ 01111001b = 01000001b
-00111000b ^ 01111010b = 01000010b
-00111000b ^ 01111011b = 01000011b
-00111000b ^ 01111100b = 01000100b
-00111000b ^ 01111101b = 01000101b
-00111000b ^ 01111110b = 01000110b
-00111001b ^ 10000000b = 10111001b
-00111001b ^ 10000001b = 10111000b
-00111001b ^ 10000010b = 10111011b
-00111001b ^ 10000011b = 10111010b
-00111001b ^ 10000100b = 10111101b
-00111001b ^ 10000101b = 10111100b
-00111001b ^ 10000110b = 10111111b
-00111001b ^ 10000111b = 10111110b
-00111001b ^ 10001000b = 10110001b
-00111001b ^ 10001001b = 10110000b
-00111001b ^ 10001010b = 10110011b
-00111001b ^ 10001011b = 10110010b
-00111001b ^ 10001100b = 10110101b
-00111001b ^ 10001101b = 10110100b
-00111001b ^ 10001110b = 10110111b
-00111001b ^ 10001111b = 10110110b
-00111001b ^ 10010000b = 10101001b
-00111001b ^ 10010001b = 10101000b
-00111001b ^ 10010010b = 10101011b
-00111001b ^ 10010011b = 10101010b
-00111001b ^ 10010100b = 10101101b
-00111001b ^ 10010101b = 10101100b
-00111001b ^ 10010110b = 10101111b
-00111001b ^ 10010111b = 10101110b
-00111001b ^ 10011000b = 10100001b
-00111001b ^ 10011001b = 10100000b
-00111001b ^ 10011010b = 10100011b
-00111001b ^ 10011011b = 10100010b
-00111001b ^ 10011100b = 10100101b
-00111001b ^ 10011101b = 10100100b
-00111001b ^ 10011110b = 10100111b
-00111001b ^ 10011111b = 10100110b
-00111001b ^ 10100000b = 10011001b
-00111001b ^ 10100001b = 10011000b
-00111001b ^ 10100010b = 10011011b
-00111001b ^ 10100011b = 10011010b
-00111001b ^ 10100100b = 10011101b
-00111001b ^ 10100101b = 10011100b
-00111001b ^ 10100110b = 10011111b
-00111001b ^ 10100111b = 10011110b
-00111001b ^ 10101000b = 10010001b
-00111001b ^ 10101001b = 10010000b
-00111001b ^ 10101010b = 10010011b
-00111001b ^ 10101011b = 10010010b
-00111001b ^ 10101100b = 10010101b
-00111001b ^ 10101101b = 10010100b
-00111001b ^ 10101110b = 10010111b
-00111001b ^ 10101111b = 10010110b
-00111001b ^ 10110000b = 10001001b
-00111001b ^ 10110001b = 10001000b
-00111001b ^ 10110010b = 10001011b
-00111001b ^ 10110011b = 10001010b
-00111001b ^ 10110100b = 10001101b
-00111001b ^ 10110101b = 10001100b
-00111001b ^ 10110110b = 10001111b
-00111001b ^ 10110111b = 10001110b
-00111001b ^ 10111000b = 10000001b
-00111001b ^ 10111001b = 10000000b
-00111001b ^ 10111010b = 10000011b
-00111001b ^ 10111011b = 10000010b
-00111001b ^ 10111100b = 10000101b
-00111001b ^ 10111101b = 10000100b
-00111001b ^ 10111110b = 10000111b
-00111001b ^ 10111111b = 10000110b
-00111001b ^ 11000000b = 11111001b
-00111001b ^ 11000001b = 11111000b
-00111001b ^ 11000010b = 11111011b
-00111001b ^ 11000011b = 11111010b
-00111001b ^ 11000100b = 11111101b
-00111001b ^ 11000101b = 11111100b
-00111001b ^ 11000110b = 11111111b
-00111001b ^ 11000111b = 11111110b
-00111001b ^ 11001000b = 11110001b
-00111001b ^ 11001001b = 11110000b
-00111001b ^ 11001010b = 11110011b
-00111001b ^ 11001011b = 11110010b
-00111001b ^ 11001100b = 11110101b
-00111001b ^ 11001101b = 11110100b
-00111001b ^ 11001110b = 11110111b
-00111001b ^ 11001111b = 11110110b
-00111001b ^ 11010000b = 11101001b
-00111001b ^ 11010001b = 11101000b
-00111001b ^ 11010010b = 11101011b
-00111001b ^ 11010011b = 11101010b
-00111001b ^ 11010100b = 11101101b
-00111001b ^ 11010101b = 11101100b
-00111001b ^ 11010110b = 11101111b
-00111001b ^ 11010111b = 11101110b
-00111001b ^ 11011000b = 11100001b
-00111001b ^ 11011001b = 11100000b
-00111001b ^ 11011010b = 11100011b
-00111001b ^ 11011011b = 11100010b
-00111001b ^ 11011100b = 11100101b
-00111001b ^ 11011101b = 11100100b
-00111001b ^ 11011110b = 11100111b
-00111001b ^ 11011111b = 11100110b
-00111001b ^ 11100000b = 11011001b
-00111001b ^ 11100001b = 11011000b
-00111001b ^ 11100010b = 11011011b
-00111001b ^ 11100011b = 11011010b
-00111001b ^ 11100100b = 11011101b
-00111001b ^ 11100101b = 11011100b
-00111001b ^ 11100110b = 11011111b
-00111001b ^ 11100111b = 11011110b
-00111001b ^ 11101000b = 11010001b
-00111001b ^ 11101001b = 11010000b
-00111001b ^ 11101010b = 11010011b
-00111001b ^ 11101011b = 11010010b
-00111001b ^ 11101100b = 11010101b
-00111001b ^ 11101101b = 11010100b
-00111001b ^ 11101110b = 11010111b
-00111001b ^ 11101111b = 11010110b
-00111001b ^ 11110000b = 11001001b
-00111001b ^ 11110001b = 11001000b
-00111001b ^ 11110010b = 11001011b
-00111001b ^ 11110011b = 11001010b
-00111001b ^ 11110100b = 11001101b
-00111001b ^ 11110101b = 11001100b
-00111001b ^ 11110110b = 11001111b
-00111001b ^ 11110111b = 11001110b
-00111001b ^ 11111000b = 11000001b
-00111001b ^ 11111001b = 11000000b
-00111001b ^ 11111010b = 11000011b
-00111001b ^ 11111011b = 11000010b
-00111001b ^ 11111100b = 11000101b
-00111001b ^ 11111101b = 11000100b
-00111001b ^ 11111110b = 11000111b
-00111001b ^ 11111111b = 11000110b
-00111001b ^ 00000000b = 00111001b
-00111001b ^ 00000001b = 00111000b
-00111001b ^ 00000010b = 00111011b
-00111001b ^ 00000011b = 00111010b
-00111001b ^ 00000100b = 00111101b
-00111001b ^ 00000101b = 00111100b
-00111001b ^ 00000110b = 00111111b
-00111001b ^ 00000111b = 00111110b
-00111001b ^ 00001000b = 00110001b
-00111001b ^ 00001001b = 00110000b
-00111001b ^ 00001010b = 00110011b
-00111001b ^ 00001011b = 00110010b
-00111001b ^ 00001100b = 00110101b
-00111001b ^ 00001101b = 00110100b
-00111001b ^ 00001110b = 00110111b
-00111001b ^ 00001111b = 00110110b
-00111001b ^ 00010000b = 00101001b
-00111001b ^ 00010001b = 00101000b
-00111001b ^ 00010010b = 00101011b
-00111001b ^ 00010011b = 00101010b
-00111001b ^ 00010100b = 00101101b
-00111001b ^ 00010101b = 00101100b
-00111001b ^ 00010110b = 00101111b
-00111001b ^ 00010111b = 00101110b
-00111001b ^ 00011000b = 00100001b
-00111001b ^ 00011001b = 00100000b
-00111001b ^ 00011010b = 00100011b
-00111001b ^ 00011011b = 00100010b
-00111001b ^ 00011100b = 00100101b
-00111001b ^ 00011101b = 00100100b
-00111001b ^ 00011110b = 00100111b
-00111001b ^ 00011111b = 00100110b
-00111001b ^ 00100000b = 00011001b
-00111001b ^ 00100001b = 00011000b
-00111001b ^ 00100010b = 00011011b
-00111001b ^ 00100011b = 00011010b
-00111001b ^ 00100100b = 00011101b
-00111001b ^ 00100101b = 00011100b
-00111001b ^ 00100110b = 00011111b
-00111001b ^ 00100111b = 00011110b
-00111001b ^ 00101000b = 00010001b
-00111001b ^ 00101001b = 00010000b
-00111001b ^ 00101010b = 00010011b
-00111001b ^ 00101011b = 00010010b
-00111001b ^ 00101100b = 00010101b
-00111001b ^ 00101101b = 00010100b
-00111001b ^ 00101110b = 00010111b
-00111001b ^ 00101111b = 00010110b
-00111001b ^ 00110000b = 00001001b
-00111001b ^ 00110001b = 00001000b
-00111001b ^ 00110010b = 00001011b
-00111001b ^ 00110011b = 00001010b
-00111001b ^ 00110100b = 00001101b
-00111001b ^ 00110101b = 00001100b
-00111001b ^ 00110110b = 00001111b
-00111001b ^ 00110111b = 00001110b
-00111001b ^ 00111000b = 00000001b
-00111001b ^ 00111001b = 00000000b
-00111001b ^ 00111010b = 00000011b
-00111001b ^ 00111011b = 00000010b
-00111001b ^ 00111100b = 00000101b
-00111001b ^ 00111101b = 00000100b
-00111001b ^ 00111110b = 00000111b
-00111001b ^ 00111111b = 00000110b
-00111001b ^ 01000000b = 01111001b
-00111001b ^ 01000001b = 01111000b
-00111001b ^ 01000010b = 01111011b
-00111001b ^ 01000011b = 01111010b
-00111001b ^ 01000100b = 01111101b
-00111001b ^ 01000101b = 01111100b
-00111001b ^ 01000110b = 01111111b
-00111001b ^ 01000111b = 01111110b
-00111001b ^ 01001000b = 01110001b
-00111001b ^ 01001001b = 01110000b
-00111001b ^ 01001010b = 01110011b
-00111001b ^ 01001011b = 01110010b
-00111001b ^ 01001100b = 01110101b
-00111001b ^ 01001101b = 01110100b
-00111001b ^ 01001110b = 01110111b
-00111001b ^ 01001111b = 01110110b
-00111001b ^ 01010000b = 01101001b
-00111001b ^ 01010001b = 01101000b
-00111001b ^ 01010010b = 01101011b
-00111001b ^ 01010011b = 01101010b
-00111001b ^ 01010100b = 01101101b
-00111001b ^ 01010101b = 01101100b
-00111001b ^ 01010110b = 01101111b
-00111001b ^ 01010111b = 01101110b
-00111001b ^ 01011000b = 01100001b
-00111001b ^ 01011001b = 01100000b
-00111001b ^ 01011010b = 01100011b
-00111001b ^ 01011011b = 01100010b
-00111001b ^ 01011100b = 01100101b
-00111001b ^ 01011101b = 01100100b
-00111001b ^ 01011110b = 01100111b
-00111001b ^ 01011111b = 01100110b
-00111001b ^ 01100000b = 01011001b
-00111001b ^ 01100001b = 01011000b
-00111001b ^ 01100010b = 01011011b
-00111001b ^ 01100011b = 01011010b
-00111001b ^ 01100100b = 01011101b
-00111001b ^ 01100101b = 01011100b
-00111001b ^ 01100110b = 01011111b
-00111001b ^ 01100111b = 01011110b
-00111001b ^ 01101000b = 01010001b
-00111001b ^ 01101001b = 01010000b
-00111001b ^ 01101010b = 01010011b
-00111001b ^ 01101011b = 01010010b
-00111001b ^ 01101100b = 01010101b
-00111001b ^ 01101101b = 01010100b
-00111001b ^ 01101110b = 01010111b
-00111001b ^ 01101111b = 01010110b
-00111001b ^ 01110000b = 01001001b
-00111001b ^ 01110001b = 01001000b
-00111001b ^ 01110010b = 01001011b
-00111001b ^ 01110011b = 01001010b
-00111001b ^ 01110100b = 01001101b
-00111001b ^ 01110101b = 01001100b
-00111001b ^ 01110110b = 01001111b
-00111001b ^ 01110111b = 01001110b
-00111001b ^ 01111000b = 01000001b
-00111001b ^ 01111001b = 01000000b
-00111001b ^ 01111010b = 01000011b
-00111001b ^ 01111011b = 01000010b
-00111001b ^ 01111100b = 01000101b
-00111001b ^ 01111101b = 01000100b
-00111001b ^ 01111110b = 01000111b
-00111010b ^ 10000000b = 10111010b
-00111010b ^ 10000001b = 10111011b
-00111010b ^ 10000010b = 10111000b
-00111010b ^ 10000011b = 10111001b
-00111010b ^ 10000100b = 10111110b
-00111010b ^ 10000101b = 10111111b
-00111010b ^ 10000110b = 10111100b
-00111010b ^ 10000111b = 10111101b
-00111010b ^ 10001000b = 10110010b
-00111010b ^ 10001001b = 10110011b
-00111010b ^ 10001010b = 10110000b
-00111010b ^ 10001011b = 10110001b
-00111010b ^ 10001100b = 10110110b
-00111010b ^ 10001101b = 10110111b
-00111010b ^ 10001110b = 10110100b
-00111010b ^ 10001111b = 10110101b
-00111010b ^ 10010000b = 10101010b
-00111010b ^ 10010001b = 10101011b
-00111010b ^ 10010010b = 10101000b
-00111010b ^ 10010011b = 10101001b
-00111010b ^ 10010100b = 10101110b
-00111010b ^ 10010101b = 10101111b
-00111010b ^ 10010110b = 10101100b
-00111010b ^ 10010111b = 10101101b
-00111010b ^ 10011000b = 10100010b
-00111010b ^ 10011001b = 10100011b
-00111010b ^ 10011010b = 10100000b
-00111010b ^ 10011011b = 10100001b
-00111010b ^ 10011100b = 10100110b
-00111010b ^ 10011101b = 10100111b
-00111010b ^ 10011110b = 10100100b
-00111010b ^ 10011111b = 10100101b
-00111010b ^ 10100000b = 10011010b
-00111010b ^ 10100001b = 10011011b
-00111010b ^ 10100010b = 10011000b
-00111010b ^ 10100011b = 10011001b
-00111010b ^ 10100100b = 10011110b
-00111010b ^ 10100101b = 10011111b
-00111010b ^ 10100110b = 10011100b
-00111010b ^ 10100111b = 10011101b
-00111010b ^ 10101000b = 10010010b
-00111010b ^ 10101001b = 10010011b
-00111010b ^ 10101010b = 10010000b
-00111010b ^ 10101011b = 10010001b
-00111010b ^ 10101100b = 10010110b
-00111010b ^ 10101101b = 10010111b
-00111010b ^ 10101110b = 10010100b
-00111010b ^ 10101111b = 10010101b
-00111010b ^ 10110000b = 10001010b
-00111010b ^ 10110001b = 10001011b
-00111010b ^ 10110010b = 10001000b
-00111010b ^ 10110011b = 10001001b
-00111010b ^ 10110100b = 10001110b
-00111010b ^ 10110101b = 10001111b
-00111010b ^ 10110110b = 10001100b
-00111010b ^ 10110111b = 10001101b
-00111010b ^ 10111000b = 10000010b
-00111010b ^ 10111001b = 10000011b
-00111010b ^ 10111010b = 10000000b
-00111010b ^ 10111011b = 10000001b
-00111010b ^ 10111100b = 10000110b
-00111010b ^ 10111101b = 10000111b
-00111010b ^ 10111110b = 10000100b
-00111010b ^ 10111111b = 10000101b
-00111010b ^ 11000000b = 11111010b
-00111010b ^ 11000001b = 11111011b
-00111010b ^ 11000010b = 11111000b
-00111010b ^ 11000011b = 11111001b
-00111010b ^ 11000100b = 11111110b
-00111010b ^ 11000101b = 11111111b
-00111010b ^ 11000110b = 11111100b
-00111010b ^ 11000111b = 11111101b
-00111010b ^ 11001000b = 11110010b
-00111010b ^ 11001001b = 11110011b
-00111010b ^ 11001010b = 11110000b
-00111010b ^ 11001011b = 11110001b
-00111010b ^ 11001100b = 11110110b
-00111010b ^ 11001101b = 11110111b
-00111010b ^ 11001110b = 11110100b
-00111010b ^ 11001111b = 11110101b
-00111010b ^ 11010000b = 11101010b
-00111010b ^ 11010001b = 11101011b
-00111010b ^ 11010010b = 11101000b
-00111010b ^ 11010011b = 11101001b
-00111010b ^ 11010100b = 11101110b
-00111010b ^ 11010101b = 11101111b
-00111010b ^ 11010110b = 11101100b
-00111010b ^ 11010111b = 11101101b
-00111010b ^ 11011000b = 11100010b
-00111010b ^ 11011001b = 11100011b
-00111010b ^ 11011010b = 11100000b
-00111010b ^ 11011011b = 11100001b
-00111010b ^ 11011100b = 11100110b
-00111010b ^ 11011101b = 11100111b
-00111010b ^ 11011110b = 11100100b
-00111010b ^ 11011111b = 11100101b
-00111010b ^ 11100000b = 11011010b
-00111010b ^ 11100001b = 11011011b
-00111010b ^ 11100010b = 11011000b
-00111010b ^ 11100011b = 11011001b
-00111010b ^ 11100100b = 11011110b
-00111010b ^ 11100101b = 11011111b
-00111010b ^ 11100110b = 11011100b
-00111010b ^ 11100111b = 11011101b
-00111010b ^ 11101000b = 11010010b
-00111010b ^ 11101001b = 11010011b
-00111010b ^ 11101010b = 11010000b
-00111010b ^ 11101011b = 11010001b
-00111010b ^ 11101100b = 11010110b
-00111010b ^ 11101101b = 11010111b
-00111010b ^ 11101110b = 11010100b
-00111010b ^ 11101111b = 11010101b
-00111010b ^ 11110000b = 11001010b
-00111010b ^ 11110001b = 11001011b
-00111010b ^ 11110010b = 11001000b
-00111010b ^ 11110011b = 11001001b
-00111010b ^ 11110100b = 11001110b
-00111010b ^ 11110101b = 11001111b
-00111010b ^ 11110110b = 11001100b
-00111010b ^ 11110111b = 11001101b
-00111010b ^ 11111000b = 11000010b
-00111010b ^ 11111001b = 11000011b
-00111010b ^ 11111010b = 11000000b
-00111010b ^ 11111011b = 11000001b
-00111010b ^ 11111100b = 11000110b
-00111010b ^ 11111101b = 11000111b
-00111010b ^ 11111110b = 11000100b
-00111010b ^ 11111111b = 11000101b
-00111010b ^ 00000000b = 00111010b
-00111010b ^ 00000001b = 00111011b
-00111010b ^ 00000010b = 00111000b
-00111010b ^ 00000011b = 00111001b
-00111010b ^ 00000100b = 00111110b
-00111010b ^ 00000101b = 00111111b
-00111010b ^ 00000110b = 00111100b
-00111010b ^ 00000111b = 00111101b
-00111010b ^ 00001000b = 00110010b
-00111010b ^ 00001001b = 00110011b
-00111010b ^ 00001010b = 00110000b
-00111010b ^ 00001011b = 00110001b
-00111010b ^ 00001100b = 00110110b
-00111010b ^ 00001101b = 00110111b
-00111010b ^ 00001110b = 00110100b
-00111010b ^ 00001111b = 00110101b
-00111010b ^ 00010000b = 00101010b
-00111010b ^ 00010001b = 00101011b
-00111010b ^ 00010010b = 00101000b
-00111010b ^ 00010011b = 00101001b
-00111010b ^ 00010100b = 00101110b
-00111010b ^ 00010101b = 00101111b
-00111010b ^ 00010110b = 00101100b
-00111010b ^ 00010111b = 00101101b
-00111010b ^ 00011000b = 00100010b
-00111010b ^ 00011001b = 00100011b
-00111010b ^ 00011010b = 00100000b
-00111010b ^ 00011011b = 00100001b
-00111010b ^ 00011100b = 00100110b
-00111010b ^ 00011101b = 00100111b
-00111010b ^ 00011110b = 00100100b
-00111010b ^ 00011111b = 00100101b
-00111010b ^ 00100000b = 00011010b
-00111010b ^ 00100001b = 00011011b
-00111010b ^ 00100010b = 00011000b
-00111010b ^ 00100011b = 00011001b
-00111010b ^ 00100100b = 00011110b
-00111010b ^ 00100101b = 00011111b
-00111010b ^ 00100110b = 00011100b
-00111010b ^ 00100111b = 00011101b
-00111010b ^ 00101000b = 00010010b
-00111010b ^ 00101001b = 00010011b
-00111010b ^ 00101010b = 00010000b
-00111010b ^ 00101011b = 00010001b
-00111010b ^ 00101100b = 00010110b
-00111010b ^ 00101101b = 00010111b
-00111010b ^ 00101110b = 00010100b
-00111010b ^ 00101111b = 00010101b
-00111010b ^ 00110000b = 00001010b
-00111010b ^ 00110001b = 00001011b
-00111010b ^ 00110010b = 00001000b
-00111010b ^ 00110011b = 00001001b
-00111010b ^ 00110100b = 00001110b
-00111010b ^ 00110101b = 00001111b
-00111010b ^ 00110110b = 00001100b
-00111010b ^ 00110111b = 00001101b
-00111010b ^ 00111000b = 00000010b
-00111010b ^ 00111001b = 00000011b
-00111010b ^ 00111010b = 00000000b
-00111010b ^ 00111011b = 00000001b
-00111010b ^ 00111100b = 00000110b
-00111010b ^ 00111101b = 00000111b
-00111010b ^ 00111110b = 00000100b
-00111010b ^ 00111111b = 00000101b
-00111010b ^ 01000000b = 01111010b
-00111010b ^ 01000001b = 01111011b
-00111010b ^ 01000010b = 01111000b
-00111010b ^ 01000011b = 01111001b
-00111010b ^ 01000100b = 01111110b
-00111010b ^ 01000101b = 01111111b
-00111010b ^ 01000110b = 01111100b
-00111010b ^ 01000111b = 01111101b
-00111010b ^ 01001000b = 01110010b
-00111010b ^ 01001001b = 01110011b
-00111010b ^ 01001010b = 01110000b
-00111010b ^ 01001011b = 01110001b
-00111010b ^ 01001100b = 01110110b
-00111010b ^ 01001101b = 01110111b
-00111010b ^ 01001110b = 01110100b
-00111010b ^ 01001111b = 01110101b
-00111010b ^ 01010000b = 01101010b
-00111010b ^ 01010001b = 01101011b
-00111010b ^ 01010010b = 01101000b
-00111010b ^ 01010011b = 01101001b
-00111010b ^ 01010100b = 01101110b
-00111010b ^ 01010101b = 01101111b
-00111010b ^ 01010110b = 01101100b
-00111010b ^ 01010111b = 01101101b
-00111010b ^ 01011000b = 01100010b
-00111010b ^ 01011001b = 01100011b
-00111010b ^ 01011010b = 01100000b
-00111010b ^ 01011011b = 01100001b
-00111010b ^ 01011100b = 01100110b
-00111010b ^ 01011101b = 01100111b
-00111010b ^ 01011110b = 01100100b
-00111010b ^ 01011111b = 01100101b
-00111010b ^ 01100000b = 01011010b
-00111010b ^ 01100001b = 01011011b
-00111010b ^ 01100010b = 01011000b
-00111010b ^ 01100011b = 01011001b
-00111010b ^ 01100100b = 01011110b
-00111010b ^ 01100101b = 01011111b
-00111010b ^ 01100110b = 01011100b
-00111010b ^ 01100111b = 01011101b
-00111010b ^ 01101000b = 01010010b
-00111010b ^ 01101001b = 01010011b
-00111010b ^ 01101010b = 01010000b
-00111010b ^ 01101011b = 01010001b
-00111010b ^ 01101100b = 01010110b
-00111010b ^ 01101101b = 01010111b
-00111010b ^ 01101110b = 01010100b
-00111010b ^ 01101111b = 01010101b
-00111010b ^ 01110000b = 01001010b
-00111010b ^ 01110001b = 01001011b
-00111010b ^ 01110010b = 01001000b
-00111010b ^ 01110011b = 01001001b
-00111010b ^ 01110100b = 01001110b
-00111010b ^ 01110101b = 01001111b
-00111010b ^ 01110110b = 01001100b
-00111010b ^ 01110111b = 01001101b
-00111010b ^ 01111000b = 01000010b
-00111010b ^ 01111001b = 01000011b
-00111010b ^ 01111010b = 01000000b
-00111010b ^ 01111011b = 01000001b
-00111010b ^ 01111100b = 01000110b
-00111010b ^ 01111101b = 01000111b
-00111010b ^ 01111110b = 01000100b
-00111011b ^ 10000000b = 10111011b
-00111011b ^ 10000001b = 10111010b
-00111011b ^ 10000010b = 10111001b
-00111011b ^ 10000011b = 10111000b
-00111011b ^ 10000100b = 10111111b
-00111011b ^ 10000101b = 10111110b
-00111011b ^ 10000110b = 10111101b
-00111011b ^ 10000111b = 10111100b
-00111011b ^ 10001000b = 10110011b
-00111011b ^ 10001001b = 10110010b
-00111011b ^ 10001010b = 10110001b
-00111011b ^ 10001011b = 10110000b
-00111011b ^ 10001100b = 10110111b
-00111011b ^ 10001101b = 10110110b
-00111011b ^ 10001110b = 10110101b
-00111011b ^ 10001111b = 10110100b
-00111011b ^ 10010000b = 10101011b
-00111011b ^ 10010001b = 10101010b
-00111011b ^ 10010010b = 10101001b
-00111011b ^ 10010011b = 10101000b
-00111011b ^ 10010100b = 10101111b
-00111011b ^ 10010101b = 10101110b
-00111011b ^ 10010110b = 10101101b
-00111011b ^ 10010111b = 10101100b
-00111011b ^ 10011000b = 10100011b
-00111011b ^ 10011001b = 10100010b
-00111011b ^ 10011010b = 10100001b
-00111011b ^ 10011011b = 10100000b
-00111011b ^ 10011100b = 10100111b
-00111011b ^ 10011101b = 10100110b
-00111011b ^ 10011110b = 10100101b
-00111011b ^ 10011111b = 10100100b
-00111011b ^ 10100000b = 10011011b
-00111011b ^ 10100001b = 10011010b
-00111011b ^ 10100010b = 10011001b
-00111011b ^ 10100011b = 10011000b
-00111011b ^ 10100100b = 10011111b
-00111011b ^ 10100101b = 10011110b
-00111011b ^ 10100110b = 10011101b
-00111011b ^ 10100111b = 10011100b
-00111011b ^ 10101000b = 10010011b
-00111011b ^ 10101001b = 10010010b
-00111011b ^ 10101010b = 10010001b
-00111011b ^ 10101011b = 10010000b
-00111011b ^ 10101100b = 10010111b
-00111011b ^ 10101101b = 10010110b
-00111011b ^ 10101110b = 10010101b
-00111011b ^ 10101111b = 10010100b
-00111011b ^ 10110000b = 10001011b
-00111011b ^ 10110001b = 10001010b
-00111011b ^ 10110010b = 10001001b
-00111011b ^ 10110011b = 10001000b
-00111011b ^ 10110100b = 10001111b
-00111011b ^ 10110101b = 10001110b
-00111011b ^ 10110110b = 10001101b
-00111011b ^ 10110111b = 10001100b
-00111011b ^ 10111000b = 10000011b
-00111011b ^ 10111001b = 10000010b
-00111011b ^ 10111010b = 10000001b
-00111011b ^ 10111011b = 10000000b
-00111011b ^ 10111100b = 10000111b
-00111011b ^ 10111101b = 10000110b
-00111011b ^ 10111110b = 10000101b
-00111011b ^ 10111111b = 10000100b
-00111011b ^ 11000000b = 11111011b
-00111011b ^ 11000001b = 11111010b
-00111011b ^ 11000010b = 11111001b
-00111011b ^ 11000011b = 11111000b
-00111011b ^ 11000100b = 11111111b
-00111011b ^ 11000101b = 11111110b
-00111011b ^ 11000110b = 11111101b
-00111011b ^ 11000111b = 11111100b
-00111011b ^ 11001000b = 11110011b
-00111011b ^ 11001001b = 11110010b
-00111011b ^ 11001010b = 11110001b
-00111011b ^ 11001011b = 11110000b
-00111011b ^ 11001100b = 11110111b
-00111011b ^ 11001101b = 11110110b
-00111011b ^ 11001110b = 11110101b
-00111011b ^ 11001111b = 11110100b
-00111011b ^ 11010000b = 11101011b
-00111011b ^ 11010001b = 11101010b
-00111011b ^ 11010010b = 11101001b
-00111011b ^ 11010011b = 11101000b
-00111011b ^ 11010100b = 11101111b
-00111011b ^ 11010101b = 11101110b
-00111011b ^ 11010110b = 11101101b
-00111011b ^ 11010111b = 11101100b
-00111011b ^ 11011000b = 11100011b
-00111011b ^ 11011001b = 11100010b
-00111011b ^ 11011010b = 11100001b
-00111011b ^ 11011011b = 11100000b
-00111011b ^ 11011100b = 11100111b
-00111011b ^ 11011101b = 11100110b
-00111011b ^ 11011110b = 11100101b
-00111011b ^ 11011111b = 11100100b
-00111011b ^ 11100000b = 11011011b
-00111011b ^ 11100001b = 11011010b
-00111011b ^ 11100010b = 11011001b
-00111011b ^ 11100011b = 11011000b
-00111011b ^ 11100100b = 11011111b
-00111011b ^ 11100101b = 11011110b
-00111011b ^ 11100110b = 11011101b
-00111011b ^ 11100111b = 11011100b
-00111011b ^ 11101000b = 11010011b
-00111011b ^ 11101001b = 11010010b
-00111011b ^ 11101010b = 11010001b
-00111011b ^ 11101011b = 11010000b
-00111011b ^ 11101100b = 11010111b
-00111011b ^ 11101101b = 11010110b
-00111011b ^ 11101110b = 11010101b
-00111011b ^ 11101111b = 11010100b
-00111011b ^ 11110000b = 11001011b
-00111011b ^ 11110001b = 11001010b
-00111011b ^ 11110010b = 11001001b
-00111011b ^ 11110011b = 11001000b
-00111011b ^ 11110100b = 11001111b
-00111011b ^ 11110101b = 11001110b
-00111011b ^ 11110110b = 11001101b
-00111011b ^ 11110111b = 11001100b
-00111011b ^ 11111000b = 11000011b
-00111011b ^ 11111001b = 11000010b
-00111011b ^ 11111010b = 11000001b
-00111011b ^ 11111011b = 11000000b
-00111011b ^ 11111100b = 11000111b
-00111011b ^ 11111101b = 11000110b
-00111011b ^ 11111110b = 11000101b
-00111011b ^ 11111111b = 11000100b
-00111011b ^ 00000000b = 00111011b
-00111011b ^ 00000001b = 00111010b
-00111011b ^ 00000010b = 00111001b
-00111011b ^ 00000011b = 00111000b
-00111011b ^ 00000100b = 00111111b
-00111011b ^ 00000101b = 00111110b
-00111011b ^ 00000110b = 00111101b
-00111011b ^ 00000111b = 00111100b
-00111011b ^ 00001000b = 00110011b
-00111011b ^ 00001001b = 00110010b
-00111011b ^ 00001010b = 00110001b
-00111011b ^ 00001011b = 00110000b
-00111011b ^ 00001100b = 00110111b
-00111011b ^ 00001101b = 00110110b
-00111011b ^ 00001110b = 00110101b
-00111011b ^ 00001111b = 00110100b
-00111011b ^ 00010000b = 00101011b
-00111011b ^ 00010001b = 00101010b
-00111011b ^ 00010010b = 00101001b
-00111011b ^ 00010011b = 00101000b
-00111011b ^ 00010100b = 00101111b
-00111011b ^ 00010101b = 00101110b
-00111011b ^ 00010110b = 00101101b
-00111011b ^ 00010111b = 00101100b
-00111011b ^ 00011000b = 00100011b
-00111011b ^ 00011001b = 00100010b
-00111011b ^ 00011010b = 00100001b
-00111011b ^ 00011011b = 00100000b
-00111011b ^ 00011100b = 00100111b
-00111011b ^ 00011101b = 00100110b
-00111011b ^ 00011110b = 00100101b
-00111011b ^ 00011111b = 00100100b
-00111011b ^ 00100000b = 00011011b
-00111011b ^ 00100001b = 00011010b
-00111011b ^ 00100010b = 00011001b
-00111011b ^ 00100011b = 00011000b
-00111011b ^ 00100100b = 00011111b
-00111011b ^ 00100101b = 00011110b
-00111011b ^ 00100110b = 00011101b
-00111011b ^ 00100111b = 00011100b
-00111011b ^ 00101000b = 00010011b
-00111011b ^ 00101001b = 00010010b
-00111011b ^ 00101010b = 00010001b
-00111011b ^ 00101011b = 00010000b
-00111011b ^ 00101100b = 00010111b
-00111011b ^ 00101101b = 00010110b
-00111011b ^ 00101110b = 00010101b
-00111011b ^ 00101111b = 00010100b
-00111011b ^ 00110000b = 00001011b
-00111011b ^ 00110001b = 00001010b
-00111011b ^ 00110010b = 00001001b
-00111011b ^ 00110011b = 00001000b
-00111011b ^ 00110100b = 00001111b
-00111011b ^ 00110101b = 00001110b
-00111011b ^ 00110110b = 00001101b
-00111011b ^ 00110111b = 00001100b
-00111011b ^ 00111000b = 00000011b
-00111011b ^ 00111001b = 00000010b
-00111011b ^ 00111010b = 00000001b
-00111011b ^ 00111011b = 00000000b
-00111011b ^ 00111100b = 00000111b
-00111011b ^ 00111101b = 00000110b
-00111011b ^ 00111110b = 00000101b
-00111011b ^ 00111111b = 00000100b
-00111011b ^ 01000000b = 01111011b
-00111011b ^ 01000001b = 01111010b
-00111011b ^ 01000010b = 01111001b
-00111011b ^ 01000011b = 01111000b
-00111011b ^ 01000100b = 01111111b
-00111011b ^ 01000101b = 01111110b
-00111011b ^ 01000110b = 01111101b
-00111011b ^ 01000111b = 01111100b
-00111011b ^ 01001000b = 01110011b
-00111011b ^ 01001001b = 01110010b
-00111011b ^ 01001010b = 01110001b
-00111011b ^ 01001011b = 01110000b
-00111011b ^ 01001100b = 01110111b
-00111011b ^ 01001101b = 01110110b
-00111011b ^ 01001110b = 01110101b
-00111011b ^ 01001111b = 01110100b
-00111011b ^ 01010000b = 01101011b
-00111011b ^ 01010001b = 01101010b
-00111011b ^ 01010010b = 01101001b
-00111011b ^ 01010011b = 01101000b
-00111011b ^ 01010100b = 01101111b
-00111011b ^ 01010101b = 01101110b
-00111011b ^ 01010110b = 01101101b
-00111011b ^ 01010111b = 01101100b
-00111011b ^ 01011000b = 01100011b
-00111011b ^ 01011001b = 01100010b
-00111011b ^ 01011010b = 01100001b
-00111011b ^ 01011011b = 01100000b
-00111011b ^ 01011100b = 01100111b
-00111011b ^ 01011101b = 01100110b
-00111011b ^ 01011110b = 01100101b
-00111011b ^ 01011111b = 01100100b
-00111011b ^ 01100000b = 01011011b
-00111011b ^ 01100001b = 01011010b
-00111011b ^ 01100010b = 01011001b
-00111011b ^ 01100011b = 01011000b
-00111011b ^ 01100100b = 01011111b
-00111011b ^ 01100101b = 01011110b
-00111011b ^ 01100110b = 01011101b
-00111011b ^ 01100111b = 01011100b
-00111011b ^ 01101000b = 01010011b
-00111011b ^ 01101001b = 01010010b
-00111011b ^ 01101010b = 01010001b
-00111011b ^ 01101011b = 01010000b
-00111011b ^ 01101100b = 01010111b
-00111011b ^ 01101101b = 01010110b
-00111011b ^ 01101110b = 01010101b
-00111011b ^ 01101111b = 01010100b
-00111011b ^ 01110000b = 01001011b
-00111011b ^ 01110001b = 01001010b
-00111011b ^ 01110010b = 01001001b
-00111011b ^ 01110011b = 01001000b
-00111011b ^ 01110100b = 01001111b
-00111011b ^ 01110101b = 01001110b
-00111011b ^ 01110110b = 01001101b
-00111011b ^ 01110111b = 01001100b
-00111011b ^ 01111000b = 01000011b
-00111011b ^ 01111001b = 01000010b
-00111011b ^ 01111010b = 01000001b
-00111011b ^ 01111011b = 01000000b
-00111011b ^ 01111100b = 01000111b
-00111011b ^ 01111101b = 01000110b
-00111011b ^ 01111110b = 01000101b
-00111100b ^ 10000000b = 10111100b
-00111100b ^ 10000001b = 10111101b
-00111100b ^ 10000010b = 10111110b
-00111100b ^ 10000011b = 10111111b
-00111100b ^ 10000100b = 10111000b
-00111100b ^ 10000101b = 10111001b
-00111100b ^ 10000110b = 10111010b
-00111100b ^ 10000111b = 10111011b
-00111100b ^ 10001000b = 10110100b
-00111100b ^ 10001001b = 10110101b
-00111100b ^ 10001010b = 10110110b
-00111100b ^ 10001011b = 10110111b
-00111100b ^ 10001100b = 10110000b
-00111100b ^ 10001101b = 10110001b
-00111100b ^ 10001110b = 10110010b
-00111100b ^ 10001111b = 10110011b
-00111100b ^ 10010000b = 10101100b
-00111100b ^ 10010001b = 10101101b
-00111100b ^ 10010010b = 10101110b
-00111100b ^ 10010011b = 10101111b
-00111100b ^ 10010100b = 10101000b
-00111100b ^ 10010101b = 10101001b
-00111100b ^ 10010110b = 10101010b
-00111100b ^ 10010111b = 10101011b
-00111100b ^ 10011000b = 10100100b
-00111100b ^ 10011001b = 10100101b
-00111100b ^ 10011010b = 10100110b
-00111100b ^ 10011011b = 10100111b
-00111100b ^ 10011100b = 10100000b
-00111100b ^ 10011101b = 10100001b
-00111100b ^ 10011110b = 10100010b
-00111100b ^ 10011111b = 10100011b
-00111100b ^ 10100000b = 10011100b
-00111100b ^ 10100001b = 10011101b
-00111100b ^ 10100010b = 10011110b
-00111100b ^ 10100011b = 10011111b
-00111100b ^ 10100100b = 10011000b
-00111100b ^ 10100101b = 10011001b
-00111100b ^ 10100110b = 10011010b
-00111100b ^ 10100111b = 10011011b
-00111100b ^ 10101000b = 10010100b
-00111100b ^ 10101001b = 10010101b
-00111100b ^ 10101010b = 10010110b
-00111100b ^ 10101011b = 10010111b
-00111100b ^ 10101100b = 10010000b
-00111100b ^ 10101101b = 10010001b
-00111100b ^ 10101110b = 10010010b
-00111100b ^ 10101111b = 10010011b
-00111100b ^ 10110000b = 10001100b
-00111100b ^ 10110001b = 10001101b
-00111100b ^ 10110010b = 10001110b
-00111100b ^ 10110011b = 10001111b
-00111100b ^ 10110100b = 10001000b
-00111100b ^ 10110101b = 10001001b
-00111100b ^ 10110110b = 10001010b
-00111100b ^ 10110111b = 10001011b
-00111100b ^ 10111000b = 10000100b
-00111100b ^ 10111001b = 10000101b
-00111100b ^ 10111010b = 10000110b
-00111100b ^ 10111011b = 10000111b
-00111100b ^ 10111100b = 10000000b
-00111100b ^ 10111101b = 10000001b
-00111100b ^ 10111110b = 10000010b
-00111100b ^ 10111111b = 10000011b
-00111100b ^ 11000000b = 11111100b
-00111100b ^ 11000001b = 11111101b
-00111100b ^ 11000010b = 11111110b
-00111100b ^ 11000011b = 11111111b
-00111100b ^ 11000100b = 11111000b
-00111100b ^ 11000101b = 11111001b
-00111100b ^ 11000110b = 11111010b
-00111100b ^ 11000111b = 11111011b
-00111100b ^ 11001000b = 11110100b
-00111100b ^ 11001001b = 11110101b
-00111100b ^ 11001010b = 11110110b
-00111100b ^ 11001011b = 11110111b
-00111100b ^ 11001100b = 11110000b
-00111100b ^ 11001101b = 11110001b
-00111100b ^ 11001110b = 11110010b
-00111100b ^ 11001111b = 11110011b
-00111100b ^ 11010000b = 11101100b
-00111100b ^ 11010001b = 11101101b
-00111100b ^ 11010010b = 11101110b
-00111100b ^ 11010011b = 11101111b
-00111100b ^ 11010100b = 11101000b
-00111100b ^ 11010101b = 11101001b
-00111100b ^ 11010110b = 11101010b
-00111100b ^ 11010111b = 11101011b
-00111100b ^ 11011000b = 11100100b
-00111100b ^ 11011001b = 11100101b
-00111100b ^ 11011010b = 11100110b
-00111100b ^ 11011011b = 11100111b
-00111100b ^ 11011100b = 11100000b
-00111100b ^ 11011101b = 11100001b
-00111100b ^ 11011110b = 11100010b
-00111100b ^ 11011111b = 11100011b
-00111100b ^ 11100000b = 11011100b
-00111100b ^ 11100001b = 11011101b
-00111100b ^ 11100010b = 11011110b
-00111100b ^ 11100011b = 11011111b
-00111100b ^ 11100100b = 11011000b
-00111100b ^ 11100101b = 11011001b
-00111100b ^ 11100110b = 11011010b
-00111100b ^ 11100111b = 11011011b
-00111100b ^ 11101000b = 11010100b
-00111100b ^ 11101001b = 11010101b
-00111100b ^ 11101010b = 11010110b
-00111100b ^ 11101011b = 11010111b
-00111100b ^ 11101100b = 11010000b
-00111100b ^ 11101101b = 11010001b
-00111100b ^ 11101110b = 11010010b
-00111100b ^ 11101111b = 11010011b
-00111100b ^ 11110000b = 11001100b
-00111100b ^ 11110001b = 11001101b
-00111100b ^ 11110010b = 11001110b
-00111100b ^ 11110011b = 11001111b
-00111100b ^ 11110100b = 11001000b
-00111100b ^ 11110101b = 11001001b
-00111100b ^ 11110110b = 11001010b
-00111100b ^ 11110111b = 11001011b
-00111100b ^ 11111000b = 11000100b
-00111100b ^ 11111001b = 11000101b
-00111100b ^ 11111010b = 11000110b
-00111100b ^ 11111011b = 11000111b
-00111100b ^ 11111100b = 11000000b
-00111100b ^ 11111101b = 11000001b
-00111100b ^ 11111110b = 11000010b
-00111100b ^ 11111111b = 11000011b
-00111100b ^ 00000000b = 00111100b
-00111100b ^ 00000001b = 00111101b
-00111100b ^ 00000010b = 00111110b
-00111100b ^ 00000011b = 00111111b
-00111100b ^ 00000100b = 00111000b
-00111100b ^ 00000101b = 00111001b
-00111100b ^ 00000110b = 00111010b
-00111100b ^ 00000111b = 00111011b
-00111100b ^ 00001000b = 00110100b
-00111100b ^ 00001001b = 00110101b
-00111100b ^ 00001010b = 00110110b
-00111100b ^ 00001011b = 00110111b
-00111100b ^ 00001100b = 00110000b
-00111100b ^ 00001101b = 00110001b
-00111100b ^ 00001110b = 00110010b
-00111100b ^ 00001111b = 00110011b
-00111100b ^ 00010000b = 00101100b
-00111100b ^ 00010001b = 00101101b
-00111100b ^ 00010010b = 00101110b
-00111100b ^ 00010011b = 00101111b
-00111100b ^ 00010100b = 00101000b
-00111100b ^ 00010101b = 00101001b
-00111100b ^ 00010110b = 00101010b
-00111100b ^ 00010111b = 00101011b
-00111100b ^ 00011000b = 00100100b
-00111100b ^ 00011001b = 00100101b
-00111100b ^ 00011010b = 00100110b
-00111100b ^ 00011011b = 00100111b
-00111100b ^ 00011100b = 00100000b
-00111100b ^ 00011101b = 00100001b
-00111100b ^ 00011110b = 00100010b
-00111100b ^ 00011111b = 00100011b
-00111100b ^ 00100000b = 00011100b
-00111100b ^ 00100001b = 00011101b
-00111100b ^ 00100010b = 00011110b
-00111100b ^ 00100011b = 00011111b
-00111100b ^ 00100100b = 00011000b
-00111100b ^ 00100101b = 00011001b
-00111100b ^ 00100110b = 00011010b
-00111100b ^ 00100111b = 00011011b
-00111100b ^ 00101000b = 00010100b
-00111100b ^ 00101001b = 00010101b
-00111100b ^ 00101010b = 00010110b
-00111100b ^ 00101011b = 00010111b
-00111100b ^ 00101100b = 00010000b
-00111100b ^ 00101101b = 00010001b
-00111100b ^ 00101110b = 00010010b
-00111100b ^ 00101111b = 00010011b
-00111100b ^ 00110000b = 00001100b
-00111100b ^ 00110001b = 00001101b
-00111100b ^ 00110010b = 00001110b
-00111100b ^ 00110011b = 00001111b
-00111100b ^ 00110100b = 00001000b
-00111100b ^ 00110101b = 00001001b
-00111100b ^ 00110110b = 00001010b
-00111100b ^ 00110111b = 00001011b
-00111100b ^ 00111000b = 00000100b
-00111100b ^ 00111001b = 00000101b
-00111100b ^ 00111010b = 00000110b
-00111100b ^ 00111011b = 00000111b
-00111100b ^ 00111100b = 00000000b
-00111100b ^ 00111101b = 00000001b
-00111100b ^ 00111110b = 00000010b
-00111100b ^ 00111111b = 00000011b
-00111100b ^ 01000000b = 01111100b
-00111100b ^ 01000001b = 01111101b
-00111100b ^ 01000010b = 01111110b
-00111100b ^ 01000011b = 01111111b
-00111100b ^ 01000100b = 01111000b
-00111100b ^ 01000101b = 01111001b
-00111100b ^ 01000110b = 01111010b
-00111100b ^ 01000111b = 01111011b
-00111100b ^ 01001000b = 01110100b
-00111100b ^ 01001001b = 01110101b
-00111100b ^ 01001010b = 01110110b
-00111100b ^ 01001011b = 01110111b
-00111100b ^ 01001100b = 01110000b
-00111100b ^ 01001101b = 01110001b
-00111100b ^ 01001110b = 01110010b
-00111100b ^ 01001111b = 01110011b
-00111100b ^ 01010000b = 01101100b
-00111100b ^ 01010001b = 01101101b
-00111100b ^ 01010010b = 01101110b
-00111100b ^ 01010011b = 01101111b
-00111100b ^ 01010100b = 01101000b
-00111100b ^ 01010101b = 01101001b
-00111100b ^ 01010110b = 01101010b
-00111100b ^ 01010111b = 01101011b
-00111100b ^ 01011000b = 01100100b
-00111100b ^ 01011001b = 01100101b
-00111100b ^ 01011010b = 01100110b
-00111100b ^ 01011011b = 01100111b
-00111100b ^ 01011100b = 01100000b
-00111100b ^ 01011101b = 01100001b
-00111100b ^ 01011110b = 01100010b
-00111100b ^ 01011111b = 01100011b
-00111100b ^ 01100000b = 01011100b
-00111100b ^ 01100001b = 01011101b
-00111100b ^ 01100010b = 01011110b
-00111100b ^ 01100011b = 01011111b
-00111100b ^ 01100100b = 01011000b
-00111100b ^ 01100101b = 01011001b
-00111100b ^ 01100110b = 01011010b
-00111100b ^ 01100111b = 01011011b
-00111100b ^ 01101000b = 01010100b
-00111100b ^ 01101001b = 01010101b
-00111100b ^ 01101010b = 01010110b
-00111100b ^ 01101011b = 01010111b
-00111100b ^ 01101100b = 01010000b
-00111100b ^ 01101101b = 01010001b
-00111100b ^ 01101110b = 01010010b
-00111100b ^ 01101111b = 01010011b
-00111100b ^ 01110000b = 01001100b
-00111100b ^ 01110001b = 01001101b
-00111100b ^ 01110010b = 01001110b
-00111100b ^ 01110011b = 01001111b
-00111100b ^ 01110100b = 01001000b
-00111100b ^ 01110101b = 01001001b
-00111100b ^ 01110110b = 01001010b
-00111100b ^ 01110111b = 01001011b
-00111100b ^ 01111000b = 01000100b
-00111100b ^ 01111001b = 01000101b
-00111100b ^ 01111010b = 01000110b
-00111100b ^ 01111011b = 01000111b
-00111100b ^ 01111100b = 01000000b
-00111100b ^ 01111101b = 01000001b
-00111100b ^ 01111110b = 01000010b
-00111101b ^ 10000000b = 10111101b
-00111101b ^ 10000001b = 10111100b
-00111101b ^ 10000010b = 10111111b
-00111101b ^ 10000011b = 10111110b
-00111101b ^ 10000100b = 10111001b
-00111101b ^ 10000101b = 10111000b
-00111101b ^ 10000110b = 10111011b
-00111101b ^ 10000111b = 10111010b
-00111101b ^ 10001000b = 10110101b
-00111101b ^ 10001001b = 10110100b
-00111101b ^ 10001010b = 10110111b
-00111101b ^ 10001011b = 10110110b
-00111101b ^ 10001100b = 10110001b
-00111101b ^ 10001101b = 10110000b
-00111101b ^ 10001110b = 10110011b
-00111101b ^ 10001111b = 10110010b
-00111101b ^ 10010000b = 10101101b
-00111101b ^ 10010001b = 10101100b
-00111101b ^ 10010010b = 10101111b
-00111101b ^ 10010011b = 10101110b
-00111101b ^ 10010100b = 10101001b
-00111101b ^ 10010101b = 10101000b
-00111101b ^ 10010110b = 10101011b
-00111101b ^ 10010111b = 10101010b
-00111101b ^ 10011000b = 10100101b
-00111101b ^ 10011001b = 10100100b
-00111101b ^ 10011010b = 10100111b
-00111101b ^ 10011011b = 10100110b
-00111101b ^ 10011100b = 10100001b
-00111101b ^ 10011101b = 10100000b
-00111101b ^ 10011110b = 10100011b
-00111101b ^ 10011111b = 10100010b
-00111101b ^ 10100000b = 10011101b
-00111101b ^ 10100001b = 10011100b
-00111101b ^ 10100010b = 10011111b
-00111101b ^ 10100011b = 10011110b
-00111101b ^ 10100100b = 10011001b
-00111101b ^ 10100101b = 10011000b
-00111101b ^ 10100110b = 10011011b
-00111101b ^ 10100111b = 10011010b
-00111101b ^ 10101000b = 10010101b
-00111101b ^ 10101001b = 10010100b
-00111101b ^ 10101010b = 10010111b
-00111101b ^ 10101011b = 10010110b
-00111101b ^ 10101100b = 10010001b
-00111101b ^ 10101101b = 10010000b
-00111101b ^ 10101110b = 10010011b
-00111101b ^ 10101111b = 10010010b
-00111101b ^ 10110000b = 10001101b
-00111101b ^ 10110001b = 10001100b
-00111101b ^ 10110010b = 10001111b
-00111101b ^ 10110011b = 10001110b
-00111101b ^ 10110100b = 10001001b
-00111101b ^ 10110101b = 10001000b
-00111101b ^ 10110110b = 10001011b
-00111101b ^ 10110111b = 10001010b
-00111101b ^ 10111000b = 10000101b
-00111101b ^ 10111001b = 10000100b
-00111101b ^ 10111010b = 10000111b
-00111101b ^ 10111011b = 10000110b
-00111101b ^ 10111100b = 10000001b
-00111101b ^ 10111101b = 10000000b
-00111101b ^ 10111110b = 10000011b
-00111101b ^ 10111111b = 10000010b
-00111101b ^ 11000000b = 11111101b
-00111101b ^ 11000001b = 11111100b
-00111101b ^ 11000010b = 11111111b
-00111101b ^ 11000011b = 11111110b
-00111101b ^ 11000100b = 11111001b
-00111101b ^ 11000101b = 11111000b
-00111101b ^ 11000110b = 11111011b
-00111101b ^ 11000111b = 11111010b
-00111101b ^ 11001000b = 11110101b
-00111101b ^ 11001001b = 11110100b
-00111101b ^ 11001010b = 11110111b
-00111101b ^ 11001011b = 11110110b
-00111101b ^ 11001100b = 11110001b
-00111101b ^ 11001101b = 11110000b
-00111101b ^ 11001110b = 11110011b
-00111101b ^ 11001111b = 11110010b
-00111101b ^ 11010000b = 11101101b
-00111101b ^ 11010001b = 11101100b
-00111101b ^ 11010010b = 11101111b
-00111101b ^ 11010011b = 11101110b
-00111101b ^ 11010100b = 11101001b
-00111101b ^ 11010101b = 11101000b
-00111101b ^ 11010110b = 11101011b
-00111101b ^ 11010111b = 11101010b
-00111101b ^ 11011000b = 11100101b
-00111101b ^ 11011001b = 11100100b
-00111101b ^ 11011010b = 11100111b
-00111101b ^ 11011011b = 11100110b
-00111101b ^ 11011100b = 11100001b
-00111101b ^ 11011101b = 11100000b
-00111101b ^ 11011110b = 11100011b
-00111101b ^ 11011111b = 11100010b
-00111101b ^ 11100000b = 11011101b
-00111101b ^ 11100001b = 11011100b
-00111101b ^ 11100010b = 11011111b
-00111101b ^ 11100011b = 11011110b
-00111101b ^ 11100100b = 11011001b
-00111101b ^ 11100101b = 11011000b
-00111101b ^ 11100110b = 11011011b
-00111101b ^ 11100111b = 11011010b
-00111101b ^ 11101000b = 11010101b
-00111101b ^ 11101001b = 11010100b
-00111101b ^ 11101010b = 11010111b
-00111101b ^ 11101011b = 11010110b
-00111101b ^ 11101100b = 11010001b
-00111101b ^ 11101101b = 11010000b
-00111101b ^ 11101110b = 11010011b
-00111101b ^ 11101111b = 11010010b
-00111101b ^ 11110000b = 11001101b
-00111101b ^ 11110001b = 11001100b
-00111101b ^ 11110010b = 11001111b
-00111101b ^ 11110011b = 11001110b
-00111101b ^ 11110100b = 11001001b
-00111101b ^ 11110101b = 11001000b
-00111101b ^ 11110110b = 11001011b
-00111101b ^ 11110111b = 11001010b
-00111101b ^ 11111000b = 11000101b
-00111101b ^ 11111001b = 11000100b
-00111101b ^ 11111010b = 11000111b
-00111101b ^ 11111011b = 11000110b
-00111101b ^ 11111100b = 11000001b
-00111101b ^ 11111101b = 11000000b
-00111101b ^ 11111110b = 11000011b
-00111101b ^ 11111111b = 11000010b
-00111101b ^ 00000000b = 00111101b
-00111101b ^ 00000001b = 00111100b
-00111101b ^ 00000010b = 00111111b
-00111101b ^ 00000011b = 00111110b
-00111101b ^ 00000100b = 00111001b
-00111101b ^ 00000101b = 00111000b
-00111101b ^ 00000110b = 00111011b
-00111101b ^ 00000111b = 00111010b
-00111101b ^ 00001000b = 00110101b
-00111101b ^ 00001001b = 00110100b
-00111101b ^ 00001010b = 00110111b
-00111101b ^ 00001011b = 00110110b
-00111101b ^ 00001100b = 00110001b
-00111101b ^ 00001101b = 00110000b
-00111101b ^ 00001110b = 00110011b
-00111101b ^ 00001111b = 00110010b
-00111101b ^ 00010000b = 00101101b
-00111101b ^ 00010001b = 00101100b
-00111101b ^ 00010010b = 00101111b
-00111101b ^ 00010011b = 00101110b
-00111101b ^ 00010100b = 00101001b
-00111101b ^ 00010101b = 00101000b
-00111101b ^ 00010110b = 00101011b
-00111101b ^ 00010111b = 00101010b
-00111101b ^ 00011000b = 00100101b
-00111101b ^ 00011001b = 00100100b
-00111101b ^ 00011010b = 00100111b
-00111101b ^ 00011011b = 00100110b
-00111101b ^ 00011100b = 00100001b
-00111101b ^ 00011101b = 00100000b
-00111101b ^ 00011110b = 00100011b
-00111101b ^ 00011111b = 00100010b
-00111101b ^ 00100000b = 00011101b
-00111101b ^ 00100001b = 00011100b
-00111101b ^ 00100010b = 00011111b
-00111101b ^ 00100011b = 00011110b
-00111101b ^ 00100100b = 00011001b
-00111101b ^ 00100101b = 00011000b
-00111101b ^ 00100110b = 00011011b
-00111101b ^ 00100111b = 00011010b
-00111101b ^ 00101000b = 00010101b
-00111101b ^ 00101001b = 00010100b
-00111101b ^ 00101010b = 00010111b
-00111101b ^ 00101011b = 00010110b
-00111101b ^ 00101100b = 00010001b
-00111101b ^ 00101101b = 00010000b
-00111101b ^ 00101110b = 00010011b
-00111101b ^ 00101111b = 00010010b
-00111101b ^ 00110000b = 00001101b
-00111101b ^ 00110001b = 00001100b
-00111101b ^ 00110010b = 00001111b
-00111101b ^ 00110011b = 00001110b
-00111101b ^ 00110100b = 00001001b
-00111101b ^ 00110101b = 00001000b
-00111101b ^ 00110110b = 00001011b
-00111101b ^ 00110111b = 00001010b
-00111101b ^ 00111000b = 00000101b
-00111101b ^ 00111001b = 00000100b
-00111101b ^ 00111010b = 00000111b
-00111101b ^ 00111011b = 00000110b
-00111101b ^ 00111100b = 00000001b
-00111101b ^ 00111101b = 00000000b
-00111101b ^ 00111110b = 00000011b
-00111101b ^ 00111111b = 00000010b
-00111101b ^ 01000000b = 01111101b
-00111101b ^ 01000001b = 01111100b
-00111101b ^ 01000010b = 01111111b
-00111101b ^ 01000011b = 01111110b
-00111101b ^ 01000100b = 01111001b
-00111101b ^ 01000101b = 01111000b
-00111101b ^ 01000110b = 01111011b
-00111101b ^ 01000111b = 01111010b
-00111101b ^ 01001000b = 01110101b
-00111101b ^ 01001001b = 01110100b
-00111101b ^ 01001010b = 01110111b
-00111101b ^ 01001011b = 01110110b
-00111101b ^ 01001100b = 01110001b
-00111101b ^ 01001101b = 01110000b
-00111101b ^ 01001110b = 01110011b
-00111101b ^ 01001111b = 01110010b
-00111101b ^ 01010000b = 01101101b
-00111101b ^ 01010001b = 01101100b
-00111101b ^ 01010010b = 01101111b
-00111101b ^ 01010011b = 01101110b
-00111101b ^ 01010100b = 01101001b
-00111101b ^ 01010101b = 01101000b
-00111101b ^ 01010110b = 01101011b
-00111101b ^ 01010111b = 01101010b
-00111101b ^ 01011000b = 01100101b
-00111101b ^ 01011001b = 01100100b
-00111101b ^ 01011010b = 01100111b
-00111101b ^ 01011011b = 01100110b
-00111101b ^ 01011100b = 01100001b
-00111101b ^ 01011101b = 01100000b
-00111101b ^ 01011110b = 01100011b
-00111101b ^ 01011111b = 01100010b
-00111101b ^ 01100000b = 01011101b
-00111101b ^ 01100001b = 01011100b
-00111101b ^ 01100010b = 01011111b
-00111101b ^ 01100011b = 01011110b
-00111101b ^ 01100100b = 01011001b
-00111101b ^ 01100101b = 01011000b
-00111101b ^ 01100110b = 01011011b
-00111101b ^ 01100111b = 01011010b
-00111101b ^ 01101000b = 01010101b
-00111101b ^ 01101001b = 01010100b
-00111101b ^ 01101010b = 01010111b
-00111101b ^ 01101011b = 01010110b
-00111101b ^ 01101100b = 01010001b
-00111101b ^ 01101101b = 01010000b
-00111101b ^ 01101110b = 01010011b
-00111101b ^ 01101111b = 01010010b
-00111101b ^ 01110000b = 01001101b
-00111101b ^ 01110001b = 01001100b
-00111101b ^ 01110010b = 01001111b
-00111101b ^ 01110011b = 01001110b
-00111101b ^ 01110100b = 01001001b
-00111101b ^ 01110101b = 01001000b
-00111101b ^ 01110110b = 01001011b
-00111101b ^ 01110111b = 01001010b
-00111101b ^ 01111000b = 01000101b
-00111101b ^ 01111001b = 01000100b
-00111101b ^ 01111010b = 01000111b
-00111101b ^ 01111011b = 01000110b
-00111101b ^ 01111100b = 01000001b
-00111101b ^ 01111101b = 01000000b
-00111101b ^ 01111110b = 01000011b
-00111110b ^ 10000000b = 10111110b
-00111110b ^ 10000001b = 10111111b
-00111110b ^ 10000010b = 10111100b
-00111110b ^ 10000011b = 10111101b
-00111110b ^ 10000100b = 10111010b
-00111110b ^ 10000101b = 10111011b
-00111110b ^ 10000110b = 10111000b
-00111110b ^ 10000111b = 10111001b
-00111110b ^ 10001000b = 10110110b
-00111110b ^ 10001001b = 10110111b
-00111110b ^ 10001010b = 10110100b
-00111110b ^ 10001011b = 10110101b
-00111110b ^ 10001100b = 10110010b
-00111110b ^ 10001101b = 10110011b
-00111110b ^ 10001110b = 10110000b
-00111110b ^ 10001111b = 10110001b
-00111110b ^ 10010000b = 10101110b
-00111110b ^ 10010001b = 10101111b
-00111110b ^ 10010010b = 10101100b
-00111110b ^ 10010011b = 10101101b
-00111110b ^ 10010100b = 10101010b
-00111110b ^ 10010101b = 10101011b
-00111110b ^ 10010110b = 10101000b
-00111110b ^ 10010111b = 10101001b
-00111110b ^ 10011000b = 10100110b
-00111110b ^ 10011001b = 10100111b
-00111110b ^ 10011010b = 10100100b
-00111110b ^ 10011011b = 10100101b
-00111110b ^ 10011100b = 10100010b
-00111110b ^ 10011101b = 10100011b
-00111110b ^ 10011110b = 10100000b
-00111110b ^ 10011111b = 10100001b
-00111110b ^ 10100000b = 10011110b
-00111110b ^ 10100001b = 10011111b
-00111110b ^ 10100010b = 10011100b
-00111110b ^ 10100011b = 10011101b
-00111110b ^ 10100100b = 10011010b
-00111110b ^ 10100101b = 10011011b
-00111110b ^ 10100110b = 10011000b
-00111110b ^ 10100111b = 10011001b
-00111110b ^ 10101000b = 10010110b
-00111110b ^ 10101001b = 10010111b
-00111110b ^ 10101010b = 10010100b
-00111110b ^ 10101011b = 10010101b
-00111110b ^ 10101100b = 10010010b
-00111110b ^ 10101101b = 10010011b
-00111110b ^ 10101110b = 10010000b
-00111110b ^ 10101111b = 10010001b
-00111110b ^ 10110000b = 10001110b
-00111110b ^ 10110001b = 10001111b
-00111110b ^ 10110010b = 10001100b
-00111110b ^ 10110011b = 10001101b
-00111110b ^ 10110100b = 10001010b
-00111110b ^ 10110101b = 10001011b
-00111110b ^ 10110110b = 10001000b
-00111110b ^ 10110111b = 10001001b
-00111110b ^ 10111000b = 10000110b
-00111110b ^ 10111001b = 10000111b
-00111110b ^ 10111010b = 10000100b
-00111110b ^ 10111011b = 10000101b
-00111110b ^ 10111100b = 10000010b
-00111110b ^ 10111101b = 10000011b
-00111110b ^ 10111110b = 10000000b
-00111110b ^ 10111111b = 10000001b
-00111110b ^ 11000000b = 11111110b
-00111110b ^ 11000001b = 11111111b
-00111110b ^ 11000010b = 11111100b
-00111110b ^ 11000011b = 11111101b
-00111110b ^ 11000100b = 11111010b
-00111110b ^ 11000101b = 11111011b
-00111110b ^ 11000110b = 11111000b
-00111110b ^ 11000111b = 11111001b
-00111110b ^ 11001000b = 11110110b
-00111110b ^ 11001001b = 11110111b
-00111110b ^ 11001010b = 11110100b
-00111110b ^ 11001011b = 11110101b
-00111110b ^ 11001100b = 11110010b
-00111110b ^ 11001101b = 11110011b
-00111110b ^ 11001110b = 11110000b
-00111110b ^ 11001111b = 11110001b
-00111110b ^ 11010000b = 11101110b
-00111110b ^ 11010001b = 11101111b
-00111110b ^ 11010010b = 11101100b
-00111110b ^ 11010011b = 11101101b
-00111110b ^ 11010100b = 11101010b
-00111110b ^ 11010101b = 11101011b
-00111110b ^ 11010110b = 11101000b
-00111110b ^ 11010111b = 11101001b
-00111110b ^ 11011000b = 11100110b
-00111110b ^ 11011001b = 11100111b
-00111110b ^ 11011010b = 11100100b
-00111110b ^ 11011011b = 11100101b
-00111110b ^ 11011100b = 11100010b
-00111110b ^ 11011101b = 11100011b
-00111110b ^ 11011110b = 11100000b
-00111110b ^ 11011111b = 11100001b
-00111110b ^ 11100000b = 11011110b
-00111110b ^ 11100001b = 11011111b
-00111110b ^ 11100010b = 11011100b
-00111110b ^ 11100011b = 11011101b
-00111110b ^ 11100100b = 11011010b
-00111110b ^ 11100101b = 11011011b
-00111110b ^ 11100110b = 11011000b
-00111110b ^ 11100111b = 11011001b
-00111110b ^ 11101000b = 11010110b
-00111110b ^ 11101001b = 11010111b
-00111110b ^ 11101010b = 11010100b
-00111110b ^ 11101011b = 11010101b
-00111110b ^ 11101100b = 11010010b
-00111110b ^ 11101101b = 11010011b
-00111110b ^ 11101110b = 11010000b
-00111110b ^ 11101111b = 11010001b
-00111110b ^ 11110000b = 11001110b
-00111110b ^ 11110001b = 11001111b
-00111110b ^ 11110010b = 11001100b
-00111110b ^ 11110011b = 11001101b
-00111110b ^ 11110100b = 11001010b
-00111110b ^ 11110101b = 11001011b
-00111110b ^ 11110110b = 11001000b
-00111110b ^ 11110111b = 11001001b
-00111110b ^ 11111000b = 11000110b
-00111110b ^ 11111001b = 11000111b
-00111110b ^ 11111010b = 11000100b
-00111110b ^ 11111011b = 11000101b
-00111110b ^ 11111100b = 11000010b
-00111110b ^ 11111101b = 11000011b
-00111110b ^ 11111110b = 11000000b
-00111110b ^ 11111111b = 11000001b
-00111110b ^ 00000000b = 00111110b
-00111110b ^ 00000001b = 00111111b
-00111110b ^ 00000010b = 00111100b
-00111110b ^ 00000011b = 00111101b
-00111110b ^ 00000100b = 00111010b
-00111110b ^ 00000101b = 00111011b
-00111110b ^ 00000110b = 00111000b
-00111110b ^ 00000111b = 00111001b
-00111110b ^ 00001000b = 00110110b
-00111110b ^ 00001001b = 00110111b
-00111110b ^ 00001010b = 00110100b
-00111110b ^ 00001011b = 00110101b
-00111110b ^ 00001100b = 00110010b
-00111110b ^ 00001101b = 00110011b
-00111110b ^ 00001110b = 00110000b
-00111110b ^ 00001111b = 00110001b
-00111110b ^ 00010000b = 00101110b
-00111110b ^ 00010001b = 00101111b
-00111110b ^ 00010010b = 00101100b
-00111110b ^ 00010011b = 00101101b
-00111110b ^ 00010100b = 00101010b
-00111110b ^ 00010101b = 00101011b
-00111110b ^ 00010110b = 00101000b
-00111110b ^ 00010111b = 00101001b
-00111110b ^ 00011000b = 00100110b
-00111110b ^ 00011001b = 00100111b
-00111110b ^ 00011010b = 00100100b
-00111110b ^ 00011011b = 00100101b
-00111110b ^ 00011100b = 00100010b
-00111110b ^ 00011101b = 00100011b
-00111110b ^ 00011110b = 00100000b
-00111110b ^ 00011111b = 00100001b
-00111110b ^ 00100000b = 00011110b
-00111110b ^ 00100001b = 00011111b
-00111110b ^ 00100010b = 00011100b
-00111110b ^ 00100011b = 00011101b
-00111110b ^ 00100100b = 00011010b
-00111110b ^ 00100101b = 00011011b
-00111110b ^ 00100110b = 00011000b
-00111110b ^ 00100111b = 00011001b
-00111110b ^ 00101000b = 00010110b
-00111110b ^ 00101001b = 00010111b
-00111110b ^ 00101010b = 00010100b
-00111110b ^ 00101011b = 00010101b
-00111110b ^ 00101100b = 00010010b
-00111110b ^ 00101101b = 00010011b
-00111110b ^ 00101110b = 00010000b
-00111110b ^ 00101111b = 00010001b
-00111110b ^ 00110000b = 00001110b
-00111110b ^ 00110001b = 00001111b
-00111110b ^ 00110010b = 00001100b
-00111110b ^ 00110011b = 00001101b
-00111110b ^ 00110100b = 00001010b
-00111110b ^ 00110101b = 00001011b
-00111110b ^ 00110110b = 00001000b
-00111110b ^ 00110111b = 00001001b
-00111110b ^ 00111000b = 00000110b
-00111110b ^ 00111001b = 00000111b
-00111110b ^ 00111010b = 00000100b
-00111110b ^ 00111011b = 00000101b
-00111110b ^ 00111100b = 00000010b
-00111110b ^ 00111101b = 00000011b
-00111110b ^ 00111110b = 00000000b
-00111110b ^ 00111111b = 00000001b
-00111110b ^ 01000000b = 01111110b
-00111110b ^ 01000001b = 01111111b
-00111110b ^ 01000010b = 01111100b
-00111110b ^ 01000011b = 01111101b
-00111110b ^ 01000100b = 01111010b
-00111110b ^ 01000101b = 01111011b
-00111110b ^ 01000110b = 01111000b
-00111110b ^ 01000111b = 01111001b
-00111110b ^ 01001000b = 01110110b
-00111110b ^ 01001001b = 01110111b
-00111110b ^ 01001010b = 01110100b
-00111110b ^ 01001011b = 01110101b
-00111110b ^ 01001100b = 01110010b
-00111110b ^ 01001101b = 01110011b
-00111110b ^ 01001110b = 01110000b
-00111110b ^ 01001111b = 01110001b
-00111110b ^ 01010000b = 01101110b
-00111110b ^ 01010001b = 01101111b
-00111110b ^ 01010010b = 01101100b
-00111110b ^ 01010011b = 01101101b
-00111110b ^ 01010100b = 01101010b
-00111110b ^ 01010101b = 01101011b
-00111110b ^ 01010110b = 01101000b
-00111110b ^ 01010111b = 01101001b
-00111110b ^ 01011000b = 01100110b
-00111110b ^ 01011001b = 01100111b
-00111110b ^ 01011010b = 01100100b
-00111110b ^ 01011011b = 01100101b
-00111110b ^ 01011100b = 01100010b
-00111110b ^ 01011101b = 01100011b
-00111110b ^ 01011110b = 01100000b
-00111110b ^ 01011111b = 01100001b
-00111110b ^ 01100000b = 01011110b
-00111110b ^ 01100001b = 01011111b
-00111110b ^ 01100010b = 01011100b
-00111110b ^ 01100011b = 01011101b
-00111110b ^ 01100100b = 01011010b
-00111110b ^ 01100101b = 01011011b
-00111110b ^ 01100110b = 01011000b
-00111110b ^ 01100111b = 01011001b
-00111110b ^ 01101000b = 01010110b
-00111110b ^ 01101001b = 01010111b
-00111110b ^ 01101010b = 01010100b
-00111110b ^ 01101011b = 01010101b
-00111110b ^ 01101100b = 01010010b
-00111110b ^ 01101101b = 01010011b
-00111110b ^ 01101110b = 01010000b
-00111110b ^ 01101111b = 01010001b
-00111110b ^ 01110000b = 01001110b
-00111110b ^ 01110001b = 01001111b
-00111110b ^ 01110010b = 01001100b
-00111110b ^ 01110011b = 01001101b
-00111110b ^ 01110100b = 01001010b
-00111110b ^ 01110101b = 01001011b
-00111110b ^ 01110110b = 01001000b
-00111110b ^ 01110111b = 01001001b
-00111110b ^ 01111000b = 01000110b
-00111110b ^ 01111001b = 01000111b
-00111110b ^ 01111010b = 01000100b
-00111110b ^ 01111011b = 01000101b
-00111110b ^ 01111100b = 01000010b
-00111110b ^ 01111101b = 01000011b
-00111110b ^ 01111110b = 01000000b
-00111111b ^ 10000000b = 10111111b
-00111111b ^ 10000001b = 10111110b
-00111111b ^ 10000010b = 10111101b
-00111111b ^ 10000011b = 10111100b
-00111111b ^ 10000100b = 10111011b
-00111111b ^ 10000101b = 10111010b
-00111111b ^ 10000110b = 10111001b
-00111111b ^ 10000111b = 10111000b
-00111111b ^ 10001000b = 10110111b
-00111111b ^ 10001001b = 10110110b
-00111111b ^ 10001010b = 10110101b
-00111111b ^ 10001011b = 10110100b
-00111111b ^ 10001100b = 10110011b
-00111111b ^ 10001101b = 10110010b
-00111111b ^ 10001110b = 10110001b
-00111111b ^ 10001111b = 10110000b
-00111111b ^ 10010000b = 10101111b
-00111111b ^ 10010001b = 10101110b
-00111111b ^ 10010010b = 10101101b
-00111111b ^ 10010011b = 10101100b
-00111111b ^ 10010100b = 10101011b
-00111111b ^ 10010101b = 10101010b
-00111111b ^ 10010110b = 10101001b
-00111111b ^ 10010111b = 10101000b
-00111111b ^ 10011000b = 10100111b
-00111111b ^ 10011001b = 10100110b
-00111111b ^ 10011010b = 10100101b
-00111111b ^ 10011011b = 10100100b
-00111111b ^ 10011100b = 10100011b
-00111111b ^ 10011101b = 10100010b
-00111111b ^ 10011110b = 10100001b
-00111111b ^ 10011111b = 10100000b
-00111111b ^ 10100000b = 10011111b
-00111111b ^ 10100001b = 10011110b
-00111111b ^ 10100010b = 10011101b
-00111111b ^ 10100011b = 10011100b
-00111111b ^ 10100100b = 10011011b
-00111111b ^ 10100101b = 10011010b
-00111111b ^ 10100110b = 10011001b
-00111111b ^ 10100111b = 10011000b
-00111111b ^ 10101000b = 10010111b
-00111111b ^ 10101001b = 10010110b
-00111111b ^ 10101010b = 10010101b
-00111111b ^ 10101011b = 10010100b
-00111111b ^ 10101100b = 10010011b
-00111111b ^ 10101101b = 10010010b
-00111111b ^ 10101110b = 10010001b
-00111111b ^ 10101111b = 10010000b
-00111111b ^ 10110000b = 10001111b
-00111111b ^ 10110001b = 10001110b
-00111111b ^ 10110010b = 10001101b
-00111111b ^ 10110011b = 10001100b
-00111111b ^ 10110100b = 10001011b
-00111111b ^ 10110101b = 10001010b
-00111111b ^ 10110110b = 10001001b
-00111111b ^ 10110111b = 10001000b
-00111111b ^ 10111000b = 10000111b
-00111111b ^ 10111001b = 10000110b
-00111111b ^ 10111010b = 10000101b
-00111111b ^ 10111011b = 10000100b
-00111111b ^ 10111100b = 10000011b
-00111111b ^ 10111101b = 10000010b
-00111111b ^ 10111110b = 10000001b
-00111111b ^ 10111111b = 10000000b
-00111111b ^ 11000000b = 11111111b
-00111111b ^ 11000001b = 11111110b
-00111111b ^ 11000010b = 11111101b
-00111111b ^ 11000011b = 11111100b
-00111111b ^ 11000100b = 11111011b
-00111111b ^ 11000101b = 11111010b
-00111111b ^ 11000110b = 11111001b
-00111111b ^ 11000111b = 11111000b
-00111111b ^ 11001000b = 11110111b
-00111111b ^ 11001001b = 11110110b
-00111111b ^ 11001010b = 11110101b
-00111111b ^ 11001011b = 11110100b
-00111111b ^ 11001100b = 11110011b
-00111111b ^ 11001101b = 11110010b
-00111111b ^ 11001110b = 11110001b
-00111111b ^ 11001111b = 11110000b
-00111111b ^ 11010000b = 11101111b
-00111111b ^ 11010001b = 11101110b
-00111111b ^ 11010010b = 11101101b
-00111111b ^ 11010011b = 11101100b
-00111111b ^ 11010100b = 11101011b
-00111111b ^ 11010101b = 11101010b
-00111111b ^ 11010110b = 11101001b
-00111111b ^ 11010111b = 11101000b
-00111111b ^ 11011000b = 11100111b
-00111111b ^ 11011001b = 11100110b
-00111111b ^ 11011010b = 11100101b
-00111111b ^ 11011011b = 11100100b
-00111111b ^ 11011100b = 11100011b
-00111111b ^ 11011101b = 11100010b
-00111111b ^ 11011110b = 11100001b
-00111111b ^ 11011111b = 11100000b
-00111111b ^ 11100000b = 11011111b
-00111111b ^ 11100001b = 11011110b
-00111111b ^ 11100010b = 11011101b
-00111111b ^ 11100011b = 11011100b
-00111111b ^ 11100100b = 11011011b
-00111111b ^ 11100101b = 11011010b
-00111111b ^ 11100110b = 11011001b
-00111111b ^ 11100111b = 11011000b
-00111111b ^ 11101000b = 11010111b
-00111111b ^ 11101001b = 11010110b
-00111111b ^ 11101010b = 11010101b
-00111111b ^ 11101011b = 11010100b
-00111111b ^ 11101100b = 11010011b
-00111111b ^ 11101101b = 11010010b
-00111111b ^ 11101110b = 11010001b
-00111111b ^ 11101111b = 11010000b
-00111111b ^ 11110000b = 11001111b
-00111111b ^ 11110001b = 11001110b
-00111111b ^ 11110010b = 11001101b
-00111111b ^ 11110011b = 11001100b
-00111111b ^ 11110100b = 11001011b
-00111111b ^ 11110101b = 11001010b
-00111111b ^ 11110110b = 11001001b
-00111111b ^ 11110111b = 11001000b
-00111111b ^ 11111000b = 11000111b
-00111111b ^ 11111001b = 11000110b
-00111111b ^ 11111010b = 11000101b
-00111111b ^ 11111011b = 11000100b
-00111111b ^ 11111100b = 11000011b
-00111111b ^ 11111101b = 11000010b
-00111111b ^ 11111110b = 11000001b
-00111111b ^ 11111111b = 11000000b
-00111111b ^ 00000000b = 00111111b
-00111111b ^ 00000001b = 00111110b
-00111111b ^ 00000010b = 00111101b
-00111111b ^ 00000011b = 00111100b
-00111111b ^ 00000100b = 00111011b
-00111111b ^ 00000101b = 00111010b
-00111111b ^ 00000110b = 00111001b
-00111111b ^ 00000111b = 00111000b
-00111111b ^ 00001000b = 00110111b
-00111111b ^ 00001001b = 00110110b
-00111111b ^ 00001010b = 00110101b
-00111111b ^ 00001011b = 00110100b
-00111111b ^ 00001100b = 00110011b
-00111111b ^ 00001101b = 00110010b
-00111111b ^ 00001110b = 00110001b
-00111111b ^ 00001111b = 00110000b
-00111111b ^ 00010000b = 00101111b
-00111111b ^ 00010001b = 00101110b
-00111111b ^ 00010010b = 00101101b
-00111111b ^ 00010011b = 00101100b
-00111111b ^ 00010100b = 00101011b
-00111111b ^ 00010101b = 00101010b
-00111111b ^ 00010110b = 00101001b
-00111111b ^ 00010111b = 00101000b
-00111111b ^ 00011000b = 00100111b
-00111111b ^ 00011001b = 00100110b
-00111111b ^ 00011010b = 00100101b
-00111111b ^ 00011011b = 00100100b
-00111111b ^ 00011100b = 00100011b
-00111111b ^ 00011101b = 00100010b
-00111111b ^ 00011110b = 00100001b
-00111111b ^ 00011111b = 00100000b
-00111111b ^ 00100000b = 00011111b
-00111111b ^ 00100001b = 00011110b
-00111111b ^ 00100010b = 00011101b
-00111111b ^ 00100011b = 00011100b
-00111111b ^ 00100100b = 00011011b
-00111111b ^ 00100101b = 00011010b
-00111111b ^ 00100110b = 00011001b
-00111111b ^ 00100111b = 00011000b
-00111111b ^ 00101000b = 00010111b
-00111111b ^ 00101001b = 00010110b
-00111111b ^ 00101010b = 00010101b
-00111111b ^ 00101011b = 00010100b
-00111111b ^ 00101100b = 00010011b
-00111111b ^ 00101101b = 00010010b
-00111111b ^ 00101110b = 00010001b
-00111111b ^ 00101111b = 00010000b
-00111111b ^ 00110000b = 00001111b
-00111111b ^ 00110001b = 00001110b
-00111111b ^ 00110010b = 00001101b
-00111111b ^ 00110011b = 00001100b
-00111111b ^ 00110100b = 00001011b
-00111111b ^ 00110101b = 00001010b
-00111111b ^ 00110110b = 00001001b
-00111111b ^ 00110111b = 00001000b
-00111111b ^ 00111000b = 00000111b
-00111111b ^ 00111001b = 00000110b
-00111111b ^ 00111010b = 00000101b
-00111111b ^ 00111011b = 00000100b
-00111111b ^ 00111100b = 00000011b
-00111111b ^ 00111101b = 00000010b
-00111111b ^ 00111110b = 00000001b
-00111111b ^ 00111111b = 00000000b
-00111111b ^ 01000000b = 01111111b
-00111111b ^ 01000001b = 01111110b
-00111111b ^ 01000010b = 01111101b
-00111111b ^ 01000011b = 01111100b
-00111111b ^ 01000100b = 01111011b
-00111111b ^ 01000101b = 01111010b
-00111111b ^ 01000110b = 01111001b
-00111111b ^ 01000111b = 01111000b
-00111111b ^ 01001000b = 01110111b
-00111111b ^ 01001001b = 01110110b
-00111111b ^ 01001010b = 01110101b
-00111111b ^ 01001011b = 01110100b
-00111111b ^ 01001100b = 01110011b
-00111111b ^ 01001101b = 01110010b
-00111111b ^ 01001110b = 01110001b
-00111111b ^ 01001111b = 01110000b
-00111111b ^ 01010000b = 01101111b
-00111111b ^ 01010001b = 01101110b
-00111111b ^ 01010010b = 01101101b
-00111111b ^ 01010011b = 01101100b
-00111111b ^ 01010100b = 01101011b
-00111111b ^ 01010101b = 01101010b
-00111111b ^ 01010110b = 01101001b
-00111111b ^ 01010111b = 01101000b
-00111111b ^ 01011000b = 01100111b
-00111111b ^ 01011001b = 01100110b
-00111111b ^ 01011010b = 01100101b
-00111111b ^ 01011011b = 01100100b
-00111111b ^ 01011100b = 01100011b
-00111111b ^ 01011101b = 01100010b
-00111111b ^ 01011110b = 01100001b
-00111111b ^ 01011111b = 01100000b
-00111111b ^ 01100000b = 01011111b
-00111111b ^ 01100001b = 01011110b
-00111111b ^ 01100010b = 01011101b
-00111111b ^ 01100011b = 01011100b
-00111111b ^ 01100100b = 01011011b
-00111111b ^ 01100101b = 01011010b
-00111111b ^ 01100110b = 01011001b
-00111111b ^ 01100111b = 01011000b
-00111111b ^ 01101000b = 01010111b
-00111111b ^ 01101001b = 01010110b
-00111111b ^ 01101010b = 01010101b
-00111111b ^ 01101011b = 01010100b
-00111111b ^ 01101100b = 01010011b
-00111111b ^ 01101101b = 01010010b
-00111111b ^ 01101110b = 01010001b
-00111111b ^ 01101111b = 01010000b
-00111111b ^ 01110000b = 01001111b
-00111111b ^ 01110001b = 01001110b
-00111111b ^ 01110010b = 01001101b
-00111111b ^ 01110011b = 01001100b
-00111111b ^ 01110100b = 01001011b
-00111111b ^ 01110101b = 01001010b
-00111111b ^ 01110110b = 01001001b
-00111111b ^ 01110111b = 01001000b
-00111111b ^ 01111000b = 01000111b
-00111111b ^ 01111001b = 01000110b
-00111111b ^ 01111010b = 01000101b
-00111111b ^ 01111011b = 01000100b
-00111111b ^ 01111100b = 01000011b
-00111111b ^ 01111101b = 01000010b
-00111111b ^ 01111110b = 01000001b
-01000000b ^ 10000000b = 11000000b
-01000000b ^ 10000001b = 11000001b
-01000000b ^ 10000010b = 11000010b
-01000000b ^ 10000011b = 11000011b
-01000000b ^ 10000100b = 11000100b
-01000000b ^ 10000101b = 11000101b
-01000000b ^ 10000110b = 11000110b
-01000000b ^ 10000111b = 11000111b
-01000000b ^ 10001000b = 11001000b
-01000000b ^ 10001001b = 11001001b
-01000000b ^ 10001010b = 11001010b
-01000000b ^ 10001011b = 11001011b
-01000000b ^ 10001100b = 11001100b
-01000000b ^ 10001101b = 11001101b
-01000000b ^ 10001110b = 11001110b
-01000000b ^ 10001111b = 11001111b
-01000000b ^ 10010000b = 11010000b
-01000000b ^ 10010001b = 11010001b
-01000000b ^ 10010010b = 11010010b
-01000000b ^ 10010011b = 11010011b
-01000000b ^ 10010100b = 11010100b
-01000000b ^ 10010101b = 11010101b
-01000000b ^ 10010110b = 11010110b
-01000000b ^ 10010111b = 11010111b
-01000000b ^ 10011000b = 11011000b
-01000000b ^ 10011001b = 11011001b
-01000000b ^ 10011010b = 11011010b
-01000000b ^ 10011011b = 11011011b
-01000000b ^ 10011100b = 11011100b
-01000000b ^ 10011101b = 11011101b
-01000000b ^ 10011110b = 11011110b
-01000000b ^ 10011111b = 11011111b
-01000000b ^ 10100000b = 11100000b
-01000000b ^ 10100001b = 11100001b
-01000000b ^ 10100010b = 11100010b
-01000000b ^ 10100011b = 11100011b
-01000000b ^ 10100100b = 11100100b
-01000000b ^ 10100101b = 11100101b
-01000000b ^ 10100110b = 11100110b
-01000000b ^ 10100111b = 11100111b
-01000000b ^ 10101000b = 11101000b
-01000000b ^ 10101001b = 11101001b
-01000000b ^ 10101010b = 11101010b
-01000000b ^ 10101011b = 11101011b
-01000000b ^ 10101100b = 11101100b
-01000000b ^ 10101101b = 11101101b
-01000000b ^ 10101110b = 11101110b
-01000000b ^ 10101111b = 11101111b
-01000000b ^ 10110000b = 11110000b
-01000000b ^ 10110001b = 11110001b
-01000000b ^ 10110010b = 11110010b
-01000000b ^ 10110011b = 11110011b
-01000000b ^ 10110100b = 11110100b
-01000000b ^ 10110101b = 11110101b
-01000000b ^ 10110110b = 11110110b
-01000000b ^ 10110111b = 11110111b
-01000000b ^ 10111000b = 11111000b
-01000000b ^ 10111001b = 11111001b
-01000000b ^ 10111010b = 11111010b
-01000000b ^ 10111011b = 11111011b
-01000000b ^ 10111100b = 11111100b
-01000000b ^ 10111101b = 11111101b
-01000000b ^ 10111110b = 11111110b
-01000000b ^ 10111111b = 11111111b
-01000000b ^ 11000000b = 10000000b
-01000000b ^ 11000001b = 10000001b
-01000000b ^ 11000010b = 10000010b
-01000000b ^ 11000011b = 10000011b
-01000000b ^ 11000100b = 10000100b
-01000000b ^ 11000101b = 10000101b
-01000000b ^ 11000110b = 10000110b
-01000000b ^ 11000111b = 10000111b
-01000000b ^ 11001000b = 10001000b
-01000000b ^ 11001001b = 10001001b
-01000000b ^ 11001010b = 10001010b
-01000000b ^ 11001011b = 10001011b
-01000000b ^ 11001100b = 10001100b
-01000000b ^ 11001101b = 10001101b
-01000000b ^ 11001110b = 10001110b
-01000000b ^ 11001111b = 10001111b
-01000000b ^ 11010000b = 10010000b
-01000000b ^ 11010001b = 10010001b
-01000000b ^ 11010010b = 10010010b
-01000000b ^ 11010011b = 10010011b
-01000000b ^ 11010100b = 10010100b
-01000000b ^ 11010101b = 10010101b
-01000000b ^ 11010110b = 10010110b
-01000000b ^ 11010111b = 10010111b
-01000000b ^ 11011000b = 10011000b
-01000000b ^ 11011001b = 10011001b
-01000000b ^ 11011010b = 10011010b
-01000000b ^ 11011011b = 10011011b
-01000000b ^ 11011100b = 10011100b
-01000000b ^ 11011101b = 10011101b
-01000000b ^ 11011110b = 10011110b
-01000000b ^ 11011111b = 10011111b
-01000000b ^ 11100000b = 10100000b
-01000000b ^ 11100001b = 10100001b
-01000000b ^ 11100010b = 10100010b
-01000000b ^ 11100011b = 10100011b
-01000000b ^ 11100100b = 10100100b
-01000000b ^ 11100101b = 10100101b
-01000000b ^ 11100110b = 10100110b
-01000000b ^ 11100111b = 10100111b
-01000000b ^ 11101000b = 10101000b
-01000000b ^ 11101001b = 10101001b
-01000000b ^ 11101010b = 10101010b
-01000000b ^ 11101011b = 10101011b
-01000000b ^ 11101100b = 10101100b
-01000000b ^ 11101101b = 10101101b
-01000000b ^ 11101110b = 10101110b
-01000000b ^ 11101111b = 10101111b
-01000000b ^ 11110000b = 10110000b
-01000000b ^ 11110001b = 10110001b
-01000000b ^ 11110010b = 10110010b
-01000000b ^ 11110011b = 10110011b
-01000000b ^ 11110100b = 10110100b
-01000000b ^ 11110101b = 10110101b
-01000000b ^ 11110110b = 10110110b
-01000000b ^ 11110111b = 10110111b
-01000000b ^ 11111000b = 10111000b
-01000000b ^ 11111001b = 10111001b
-01000000b ^ 11111010b = 10111010b
-01000000b ^ 11111011b = 10111011b
-01000000b ^ 11111100b = 10111100b
-01000000b ^ 11111101b = 10111101b
-01000000b ^ 11111110b = 10111110b
-01000000b ^ 11111111b = 10111111b
-01000000b ^ 00000000b = 01000000b
-01000000b ^ 00000001b = 01000001b
-01000000b ^ 00000010b = 01000010b
-01000000b ^ 00000011b = 01000011b
-01000000b ^ 00000100b = 01000100b
-01000000b ^ 00000101b = 01000101b
-01000000b ^ 00000110b = 01000110b
-01000000b ^ 00000111b = 01000111b
-01000000b ^ 00001000b = 01001000b
-01000000b ^ 00001001b = 01001001b
-01000000b ^ 00001010b = 01001010b
-01000000b ^ 00001011b = 01001011b
-01000000b ^ 00001100b = 01001100b
-01000000b ^ 00001101b = 01001101b
-01000000b ^ 00001110b = 01001110b
-01000000b ^ 00001111b = 01001111b
-01000000b ^ 00010000b = 01010000b
-01000000b ^ 00010001b = 01010001b
-01000000b ^ 00010010b = 01010010b
-01000000b ^ 00010011b = 01010011b
-01000000b ^ 00010100b = 01010100b
-01000000b ^ 00010101b = 01010101b
-01000000b ^ 00010110b = 01010110b
-01000000b ^ 00010111b = 01010111b
-01000000b ^ 00011000b = 01011000b
-01000000b ^ 00011001b = 01011001b
-01000000b ^ 00011010b = 01011010b
-01000000b ^ 00011011b = 01011011b
-01000000b ^ 00011100b = 01011100b
-01000000b ^ 00011101b = 01011101b
-01000000b ^ 00011110b = 01011110b
-01000000b ^ 00011111b = 01011111b
-01000000b ^ 00100000b = 01100000b
-01000000b ^ 00100001b = 01100001b
-01000000b ^ 00100010b = 01100010b
-01000000b ^ 00100011b = 01100011b
-01000000b ^ 00100100b = 01100100b
-01000000b ^ 00100101b = 01100101b
-01000000b ^ 00100110b = 01100110b
-01000000b ^ 00100111b = 01100111b
-01000000b ^ 00101000b = 01101000b
-01000000b ^ 00101001b = 01101001b
-01000000b ^ 00101010b = 01101010b
-01000000b ^ 00101011b = 01101011b
-01000000b ^ 00101100b = 01101100b
-01000000b ^ 00101101b = 01101101b
-01000000b ^ 00101110b = 01101110b
-01000000b ^ 00101111b = 01101111b
-01000000b ^ 00110000b = 01110000b
-01000000b ^ 00110001b = 01110001b
-01000000b ^ 00110010b = 01110010b
-01000000b ^ 00110011b = 01110011b
-01000000b ^ 00110100b = 01110100b
-01000000b ^ 00110101b = 01110101b
-01000000b ^ 00110110b = 01110110b
-01000000b ^ 00110111b = 01110111b
-01000000b ^ 00111000b = 01111000b
-01000000b ^ 00111001b = 01111001b
-01000000b ^ 00111010b = 01111010b
-01000000b ^ 00111011b = 01111011b
-01000000b ^ 00111100b = 01111100b
-01000000b ^ 00111101b = 01111101b
-01000000b ^ 00111110b = 01111110b
-01000000b ^ 00111111b = 01111111b
-01000000b ^ 01000000b = 00000000b
-01000000b ^ 01000001b = 00000001b
-01000000b ^ 01000010b = 00000010b
-01000000b ^ 01000011b = 00000011b
-01000000b ^ 01000100b = 00000100b
-01000000b ^ 01000101b = 00000101b
-01000000b ^ 01000110b = 00000110b
-01000000b ^ 01000111b = 00000111b
-01000000b ^ 01001000b = 00001000b
-01000000b ^ 01001001b = 00001001b
-01000000b ^ 01001010b = 00001010b
-01000000b ^ 01001011b = 00001011b
-01000000b ^ 01001100b = 00001100b
-01000000b ^ 01001101b = 00001101b
-01000000b ^ 01001110b = 00001110b
-01000000b ^ 01001111b = 00001111b
-01000000b ^ 01010000b = 00010000b
-01000000b ^ 01010001b = 00010001b
-01000000b ^ 01010010b = 00010010b
-01000000b ^ 01010011b = 00010011b
-01000000b ^ 01010100b = 00010100b
-01000000b ^ 01010101b = 00010101b
-01000000b ^ 01010110b = 00010110b
-01000000b ^ 01010111b = 00010111b
-01000000b ^ 01011000b = 00011000b
-01000000b ^ 01011001b = 00011001b
-01000000b ^ 01011010b = 00011010b
-01000000b ^ 01011011b = 00011011b
-01000000b ^ 01011100b = 00011100b
-01000000b ^ 01011101b = 00011101b
-01000000b ^ 01011110b = 00011110b
-01000000b ^ 01011111b = 00011111b
-01000000b ^ 01100000b = 00100000b
-01000000b ^ 01100001b = 00100001b
-01000000b ^ 01100010b = 00100010b
-01000000b ^ 01100011b = 00100011b
-01000000b ^ 01100100b = 00100100b
-01000000b ^ 01100101b = 00100101b
-01000000b ^ 01100110b = 00100110b
-01000000b ^ 01100111b = 00100111b
-01000000b ^ 01101000b = 00101000b
-01000000b ^ 01101001b = 00101001b
-01000000b ^ 01101010b = 00101010b
-01000000b ^ 01101011b = 00101011b
-01000000b ^ 01101100b = 00101100b
-01000000b ^ 01101101b = 00101101b
-01000000b ^ 01101110b = 00101110b
-01000000b ^ 01101111b = 00101111b
-01000000b ^ 01110000b = 00110000b
-01000000b ^ 01110001b = 00110001b
-01000000b ^ 01110010b = 00110010b
-01000000b ^ 01110011b = 00110011b
-01000000b ^ 01110100b = 00110100b
-01000000b ^ 01110101b = 00110101b
-01000000b ^ 01110110b = 00110110b
-01000000b ^ 01110111b = 00110111b
-01000000b ^ 01111000b = 00111000b
-01000000b ^ 01111001b = 00111001b
-01000000b ^ 01111010b = 00111010b
-01000000b ^ 01111011b = 00111011b
-01000000b ^ 01111100b = 00111100b
-01000000b ^ 01111101b = 00111101b
-01000000b ^ 01111110b = 00111110b
-01000001b ^ 10000000b = 11000001b
-01000001b ^ 10000001b = 11000000b
-01000001b ^ 10000010b = 11000011b
-01000001b ^ 10000011b = 11000010b
-01000001b ^ 10000100b = 11000101b
-01000001b ^ 10000101b = 11000100b
-01000001b ^ 10000110b = 11000111b
-01000001b ^ 10000111b = 11000110b
-01000001b ^ 10001000b = 11001001b
-01000001b ^ 10001001b = 11001000b
-01000001b ^ 10001010b = 11001011b
-01000001b ^ 10001011b = 11001010b
-01000001b ^ 10001100b = 11001101b
-01000001b ^ 10001101b = 11001100b
-01000001b ^ 10001110b = 11001111b
-01000001b ^ 10001111b = 11001110b
-01000001b ^ 10010000b = 11010001b
-01000001b ^ 10010001b = 11010000b
-01000001b ^ 10010010b = 11010011b
-01000001b ^ 10010011b = 11010010b
-01000001b ^ 10010100b = 11010101b
-01000001b ^ 10010101b = 11010100b
-01000001b ^ 10010110b = 11010111b
-01000001b ^ 10010111b = 11010110b
-01000001b ^ 10011000b = 11011001b
-01000001b ^ 10011001b = 11011000b
-01000001b ^ 10011010b = 11011011b
-01000001b ^ 10011011b = 11011010b
-01000001b ^ 10011100b = 11011101b
-01000001b ^ 10011101b = 11011100b
-01000001b ^ 10011110b = 11011111b
-01000001b ^ 10011111b = 11011110b
-01000001b ^ 10100000b = 11100001b
-01000001b ^ 10100001b = 11100000b
-01000001b ^ 10100010b = 11100011b
-01000001b ^ 10100011b = 11100010b
-01000001b ^ 10100100b = 11100101b
-01000001b ^ 10100101b = 11100100b
-01000001b ^ 10100110b = 11100111b
-01000001b ^ 10100111b = 11100110b
-01000001b ^ 10101000b = 11101001b
-01000001b ^ 10101001b = 11101000b
-01000001b ^ 10101010b = 11101011b
-01000001b ^ 10101011b = 11101010b
-01000001b ^ 10101100b = 11101101b
-01000001b ^ 10101101b = 11101100b
-01000001b ^ 10101110b = 11101111b
-01000001b ^ 10101111b = 11101110b
-01000001b ^ 10110000b = 11110001b
-01000001b ^ 10110001b = 11110000b
-01000001b ^ 10110010b = 11110011b
-01000001b ^ 10110011b = 11110010b
-01000001b ^ 10110100b = 11110101b
-01000001b ^ 10110101b = 11110100b
-01000001b ^ 10110110b = 11110111b
-01000001b ^ 10110111b = 11110110b
-01000001b ^ 10111000b = 11111001b
-01000001b ^ 10111001b = 11111000b
-01000001b ^ 10111010b = 11111011b
-01000001b ^ 10111011b = 11111010b
-01000001b ^ 10111100b = 11111101b
-01000001b ^ 10111101b = 11111100b
-01000001b ^ 10111110b = 11111111b
-01000001b ^ 10111111b = 11111110b
-01000001b ^ 11000000b = 10000001b
-01000001b ^ 11000001b = 10000000b
-01000001b ^ 11000010b = 10000011b
-01000001b ^ 11000011b = 10000010b
-01000001b ^ 11000100b = 10000101b
-01000001b ^ 11000101b = 10000100b
-01000001b ^ 11000110b = 10000111b
-01000001b ^ 11000111b = 10000110b
-01000001b ^ 11001000b = 10001001b
-01000001b ^ 11001001b = 10001000b
-01000001b ^ 11001010b = 10001011b
-01000001b ^ 11001011b = 10001010b
-01000001b ^ 11001100b = 10001101b
-01000001b ^ 11001101b = 10001100b
-01000001b ^ 11001110b = 10001111b
-01000001b ^ 11001111b = 10001110b
-01000001b ^ 11010000b = 10010001b
-01000001b ^ 11010001b = 10010000b
-01000001b ^ 11010010b = 10010011b
-01000001b ^ 11010011b = 10010010b
-01000001b ^ 11010100b = 10010101b
-01000001b ^ 11010101b = 10010100b
-01000001b ^ 11010110b = 10010111b
-01000001b ^ 11010111b = 10010110b
-01000001b ^ 11011000b = 10011001b
-01000001b ^ 11011001b = 10011000b
-01000001b ^ 11011010b = 10011011b
-01000001b ^ 11011011b = 10011010b
-01000001b ^ 11011100b = 10011101b
-01000001b ^ 11011101b = 10011100b
-01000001b ^ 11011110b = 10011111b
-01000001b ^ 11011111b = 10011110b
-01000001b ^ 11100000b = 10100001b
-01000001b ^ 11100001b = 10100000b
-01000001b ^ 11100010b = 10100011b
-01000001b ^ 11100011b = 10100010b
-01000001b ^ 11100100b = 10100101b
-01000001b ^ 11100101b = 10100100b
-01000001b ^ 11100110b = 10100111b
-01000001b ^ 11100111b = 10100110b
-01000001b ^ 11101000b = 10101001b
-01000001b ^ 11101001b = 10101000b
-01000001b ^ 11101010b = 10101011b
-01000001b ^ 11101011b = 10101010b
-01000001b ^ 11101100b = 10101101b
-01000001b ^ 11101101b = 10101100b
-01000001b ^ 11101110b = 10101111b
-01000001b ^ 11101111b = 10101110b
-01000001b ^ 11110000b = 10110001b
-01000001b ^ 11110001b = 10110000b
-01000001b ^ 11110010b = 10110011b
-01000001b ^ 11110011b = 10110010b
-01000001b ^ 11110100b = 10110101b
-01000001b ^ 11110101b = 10110100b
-01000001b ^ 11110110b = 10110111b
-01000001b ^ 11110111b = 10110110b
-01000001b ^ 11111000b = 10111001b
-01000001b ^ 11111001b = 10111000b
-01000001b ^ 11111010b = 10111011b
-01000001b ^ 11111011b = 10111010b
-01000001b ^ 11111100b = 10111101b
-01000001b ^ 11111101b = 10111100b
-01000001b ^ 11111110b = 10111111b
-01000001b ^ 11111111b = 10111110b
-01000001b ^ 00000000b = 01000001b
-01000001b ^ 00000001b = 01000000b
-01000001b ^ 00000010b = 01000011b
-01000001b ^ 00000011b = 01000010b
-01000001b ^ 00000100b = 01000101b
-01000001b ^ 00000101b = 01000100b
-01000001b ^ 00000110b = 01000111b
-01000001b ^ 00000111b = 01000110b
-01000001b ^ 00001000b = 01001001b
-01000001b ^ 00001001b = 01001000b
-01000001b ^ 00001010b = 01001011b
-01000001b ^ 00001011b = 01001010b
-01000001b ^ 00001100b = 01001101b
-01000001b ^ 00001101b = 01001100b
-01000001b ^ 00001110b = 01001111b
-01000001b ^ 00001111b = 01001110b
-01000001b ^ 00010000b = 01010001b
-01000001b ^ 00010001b = 01010000b
-01000001b ^ 00010010b = 01010011b
-01000001b ^ 00010011b = 01010010b
-01000001b ^ 00010100b = 01010101b
-01000001b ^ 00010101b = 01010100b
-01000001b ^ 00010110b = 01010111b
-01000001b ^ 00010111b = 01010110b
-01000001b ^ 00011000b = 01011001b
-01000001b ^ 00011001b = 01011000b
-01000001b ^ 00011010b = 01011011b
-01000001b ^ 00011011b = 01011010b
-01000001b ^ 00011100b = 01011101b
-01000001b ^ 00011101b = 01011100b
-01000001b ^ 00011110b = 01011111b
-01000001b ^ 00011111b = 01011110b
-01000001b ^ 00100000b = 01100001b
-01000001b ^ 00100001b = 01100000b
-01000001b ^ 00100010b = 01100011b
-01000001b ^ 00100011b = 01100010b
-01000001b ^ 00100100b = 01100101b
-01000001b ^ 00100101b = 01100100b
-01000001b ^ 00100110b = 01100111b
-01000001b ^ 00100111b = 01100110b
-01000001b ^ 00101000b = 01101001b
-01000001b ^ 00101001b = 01101000b
-01000001b ^ 00101010b = 01101011b
-01000001b ^ 00101011b = 01101010b
-01000001b ^ 00101100b = 01101101b
-01000001b ^ 00101101b = 01101100b
-01000001b ^ 00101110b = 01101111b
-01000001b ^ 00101111b = 01101110b
-01000001b ^ 00110000b = 01110001b
-01000001b ^ 00110001b = 01110000b
-01000001b ^ 00110010b = 01110011b
-01000001b ^ 00110011b = 01110010b
-01000001b ^ 00110100b = 01110101b
-01000001b ^ 00110101b = 01110100b
-01000001b ^ 00110110b = 01110111b
-01000001b ^ 00110111b = 01110110b
-01000001b ^ 00111000b = 01111001b
-01000001b ^ 00111001b = 01111000b
-01000001b ^ 00111010b = 01111011b
-01000001b ^ 00111011b = 01111010b
-01000001b ^ 00111100b = 01111101b
-01000001b ^ 00111101b = 01111100b
-01000001b ^ 00111110b = 01111111b
-01000001b ^ 00111111b = 01111110b
-01000001b ^ 01000000b = 00000001b
-01000001b ^ 01000001b = 00000000b
-01000001b ^ 01000010b = 00000011b
-01000001b ^ 01000011b = 00000010b
-01000001b ^ 01000100b = 00000101b
-01000001b ^ 01000101b = 00000100b
-01000001b ^ 01000110b = 00000111b
-01000001b ^ 01000111b = 00000110b
-01000001b ^ 01001000b = 00001001b
-01000001b ^ 01001001b = 00001000b
-01000001b ^ 01001010b = 00001011b
-01000001b ^ 01001011b = 00001010b
-01000001b ^ 01001100b = 00001101b
-01000001b ^ 01001101b = 00001100b
-01000001b ^ 01001110b = 00001111b
-01000001b ^ 01001111b = 00001110b
-01000001b ^ 01010000b = 00010001b
-01000001b ^ 01010001b = 00010000b
-01000001b ^ 01010010b = 00010011b
-01000001b ^ 01010011b = 00010010b
-01000001b ^ 01010100b = 00010101b
-01000001b ^ 01010101b = 00010100b
-01000001b ^ 01010110b = 00010111b
-01000001b ^ 01010111b = 00010110b
-01000001b ^ 01011000b = 00011001b
-01000001b ^ 01011001b = 00011000b
-01000001b ^ 01011010b = 00011011b
-01000001b ^ 01011011b = 00011010b
-01000001b ^ 01011100b = 00011101b
-01000001b ^ 01011101b = 00011100b
-01000001b ^ 01011110b = 00011111b
-01000001b ^ 01011111b = 00011110b
-01000001b ^ 01100000b = 00100001b
-01000001b ^ 01100001b = 00100000b
-01000001b ^ 01100010b = 00100011b
-01000001b ^ 01100011b = 00100010b
-01000001b ^ 01100100b = 00100101b
-01000001b ^ 01100101b = 00100100b
-01000001b ^ 01100110b = 00100111b
-01000001b ^ 01100111b = 00100110b
-01000001b ^ 01101000b = 00101001b
-01000001b ^ 01101001b = 00101000b
-01000001b ^ 01101010b = 00101011b
-01000001b ^ 01101011b = 00101010b
-01000001b ^ 01101100b = 00101101b
-01000001b ^ 01101101b = 00101100b
-01000001b ^ 01101110b = 00101111b
-01000001b ^ 01101111b = 00101110b
-01000001b ^ 01110000b = 00110001b
-01000001b ^ 01110001b = 00110000b
-01000001b ^ 01110010b = 00110011b
-01000001b ^ 01110011b = 00110010b
-01000001b ^ 01110100b = 00110101b
-01000001b ^ 01110101b = 00110100b
-01000001b ^ 01110110b = 00110111b
-01000001b ^ 01110111b = 00110110b
-01000001b ^ 01111000b = 00111001b
-01000001b ^ 01111001b = 00111000b
-01000001b ^ 01111010b = 00111011b
-01000001b ^ 01111011b = 00111010b
-01000001b ^ 01111100b = 00111101b
-01000001b ^ 01111101b = 00111100b
-01000001b ^ 01111110b = 00111111b
-01000010b ^ 10000000b = 11000010b
-01000010b ^ 10000001b = 11000011b
-01000010b ^ 10000010b = 11000000b
-01000010b ^ 10000011b = 11000001b
-01000010b ^ 10000100b = 11000110b
-01000010b ^ 10000101b = 11000111b
-01000010b ^ 10000110b = 11000100b
-01000010b ^ 10000111b = 11000101b
-01000010b ^ 10001000b = 11001010b
-01000010b ^ 10001001b = 11001011b
-01000010b ^ 10001010b = 11001000b
-01000010b ^ 10001011b = 11001001b
-01000010b ^ 10001100b = 11001110b
-01000010b ^ 10001101b = 11001111b
-01000010b ^ 10001110b = 11001100b
-01000010b ^ 10001111b = 11001101b
-01000010b ^ 10010000b = 11010010b
-01000010b ^ 10010001b = 11010011b
-01000010b ^ 10010010b = 11010000b
-01000010b ^ 10010011b = 11010001b
-01000010b ^ 10010100b = 11010110b
-01000010b ^ 10010101b = 11010111b
-01000010b ^ 10010110b = 11010100b
-01000010b ^ 10010111b = 11010101b
-01000010b ^ 10011000b = 11011010b
-01000010b ^ 10011001b = 11011011b
-01000010b ^ 10011010b = 11011000b
-01000010b ^ 10011011b = 11011001b
-01000010b ^ 10011100b = 11011110b
-01000010b ^ 10011101b = 11011111b
-01000010b ^ 10011110b = 11011100b
-01000010b ^ 10011111b = 11011101b
-01000010b ^ 10100000b = 11100010b
-01000010b ^ 10100001b = 11100011b
-01000010b ^ 10100010b = 11100000b
-01000010b ^ 10100011b = 11100001b
-01000010b ^ 10100100b = 11100110b
-01000010b ^ 10100101b = 11100111b
-01000010b ^ 10100110b = 11100100b
-01000010b ^ 10100111b = 11100101b
-01000010b ^ 10101000b = 11101010b
-01000010b ^ 10101001b = 11101011b
-01000010b ^ 10101010b = 11101000b
-01000010b ^ 10101011b = 11101001b
-01000010b ^ 10101100b = 11101110b
-01000010b ^ 10101101b = 11101111b
-01000010b ^ 10101110b = 11101100b
-01000010b ^ 10101111b = 11101101b
-01000010b ^ 10110000b = 11110010b
-01000010b ^ 10110001b = 11110011b
-01000010b ^ 10110010b = 11110000b
-01000010b ^ 10110011b = 11110001b
-01000010b ^ 10110100b = 11110110b
-01000010b ^ 10110101b = 11110111b
-01000010b ^ 10110110b = 11110100b
-01000010b ^ 10110111b = 11110101b
-01000010b ^ 10111000b = 11111010b
-01000010b ^ 10111001b = 11111011b
-01000010b ^ 10111010b = 11111000b
-01000010b ^ 10111011b = 11111001b
-01000010b ^ 10111100b = 11111110b
-01000010b ^ 10111101b = 11111111b
-01000010b ^ 10111110b = 11111100b
-01000010b ^ 10111111b = 11111101b
-01000010b ^ 11000000b = 10000010b
-01000010b ^ 11000001b = 10000011b
-01000010b ^ 11000010b = 10000000b
-01000010b ^ 11000011b = 10000001b
-01000010b ^ 11000100b = 10000110b
-01000010b ^ 11000101b = 10000111b
-01000010b ^ 11000110b = 10000100b
-01000010b ^ 11000111b = 10000101b
-01000010b ^ 11001000b = 10001010b
-01000010b ^ 11001001b = 10001011b
-01000010b ^ 11001010b = 10001000b
-01000010b ^ 11001011b = 10001001b
-01000010b ^ 11001100b = 10001110b
-01000010b ^ 11001101b = 10001111b
-01000010b ^ 11001110b = 10001100b
-01000010b ^ 11001111b = 10001101b
-01000010b ^ 11010000b = 10010010b
-01000010b ^ 11010001b = 10010011b
-01000010b ^ 11010010b = 10010000b
-01000010b ^ 11010011b = 10010001b
-01000010b ^ 11010100b = 10010110b
-01000010b ^ 11010101b = 10010111b
-01000010b ^ 11010110b = 10010100b
-01000010b ^ 11010111b = 10010101b
-01000010b ^ 11011000b = 10011010b
-01000010b ^ 11011001b = 10011011b
-01000010b ^ 11011010b = 10011000b
-01000010b ^ 11011011b = 10011001b
-01000010b ^ 11011100b = 10011110b
-01000010b ^ 11011101b = 10011111b
-01000010b ^ 11011110b = 10011100b
-01000010b ^ 11011111b = 10011101b
-01000010b ^ 11100000b = 10100010b
-01000010b ^ 11100001b = 10100011b
-01000010b ^ 11100010b = 10100000b
-01000010b ^ 11100011b = 10100001b
-01000010b ^ 11100100b = 10100110b
-01000010b ^ 11100101b = 10100111b
-01000010b ^ 11100110b = 10100100b
-01000010b ^ 11100111b = 10100101b
-01000010b ^ 11101000b = 10101010b
-01000010b ^ 11101001b = 10101011b
-01000010b ^ 11101010b = 10101000b
-01000010b ^ 11101011b = 10101001b
-01000010b ^ 11101100b = 10101110b
-01000010b ^ 11101101b = 10101111b
-01000010b ^ 11101110b = 10101100b
-01000010b ^ 11101111b = 10101101b
-01000010b ^ 11110000b = 10110010b
-01000010b ^ 11110001b = 10110011b
-01000010b ^ 11110010b = 10110000b
-01000010b ^ 11110011b = 10110001b
-01000010b ^ 11110100b = 10110110b
-01000010b ^ 11110101b = 10110111b
-01000010b ^ 11110110b = 10110100b
-01000010b ^ 11110111b = 10110101b
-01000010b ^ 11111000b = 10111010b
-01000010b ^ 11111001b = 10111011b
-01000010b ^ 11111010b = 10111000b
-01000010b ^ 11111011b = 10111001b
-01000010b ^ 11111100b = 10111110b
-01000010b ^ 11111101b = 10111111b
-01000010b ^ 11111110b = 10111100b
-01000010b ^ 11111111b = 10111101b
-01000010b ^ 00000000b = 01000010b
-01000010b ^ 00000001b = 01000011b
-01000010b ^ 00000010b = 01000000b
-01000010b ^ 00000011b = 01000001b
-01000010b ^ 00000100b = 01000110b
-01000010b ^ 00000101b = 01000111b
-01000010b ^ 00000110b = 01000100b
-01000010b ^ 00000111b = 01000101b
-01000010b ^ 00001000b = 01001010b
-01000010b ^ 00001001b = 01001011b
-01000010b ^ 00001010b = 01001000b
-01000010b ^ 00001011b = 01001001b
-01000010b ^ 00001100b = 01001110b
-01000010b ^ 00001101b = 01001111b
-01000010b ^ 00001110b = 01001100b
-01000010b ^ 00001111b = 01001101b
-01000010b ^ 00010000b = 01010010b
-01000010b ^ 00010001b = 01010011b
-01000010b ^ 00010010b = 01010000b
-01000010b ^ 00010011b = 01010001b
-01000010b ^ 00010100b = 01010110b
-01000010b ^ 00010101b = 01010111b
-01000010b ^ 00010110b = 01010100b
-01000010b ^ 00010111b = 01010101b
-01000010b ^ 00011000b = 01011010b
-01000010b ^ 00011001b = 01011011b
-01000010b ^ 00011010b = 01011000b
-01000010b ^ 00011011b = 01011001b
-01000010b ^ 00011100b = 01011110b
-01000010b ^ 00011101b = 01011111b
-01000010b ^ 00011110b = 01011100b
-01000010b ^ 00011111b = 01011101b
-01000010b ^ 00100000b = 01100010b
-01000010b ^ 00100001b = 01100011b
-01000010b ^ 00100010b = 01100000b
-01000010b ^ 00100011b = 01100001b
-01000010b ^ 00100100b = 01100110b
-01000010b ^ 00100101b = 01100111b
-01000010b ^ 00100110b = 01100100b
-01000010b ^ 00100111b = 01100101b
-01000010b ^ 00101000b = 01101010b
-01000010b ^ 00101001b = 01101011b
-01000010b ^ 00101010b = 01101000b
-01000010b ^ 00101011b = 01101001b
-01000010b ^ 00101100b = 01101110b
-01000010b ^ 00101101b = 01101111b
-01000010b ^ 00101110b = 01101100b
-01000010b ^ 00101111b = 01101101b
-01000010b ^ 00110000b = 01110010b
-01000010b ^ 00110001b = 01110011b
-01000010b ^ 00110010b = 01110000b
-01000010b ^ 00110011b = 01110001b
-01000010b ^ 00110100b = 01110110b
-01000010b ^ 00110101b = 01110111b
-01000010b ^ 00110110b = 01110100b
-01000010b ^ 00110111b = 01110101b
-01000010b ^ 00111000b = 01111010b
-01000010b ^ 00111001b = 01111011b
-01000010b ^ 00111010b = 01111000b
-01000010b ^ 00111011b = 01111001b
-01000010b ^ 00111100b = 01111110b
-01000010b ^ 00111101b = 01111111b
-01000010b ^ 00111110b = 01111100b
-01000010b ^ 00111111b = 01111101b
-01000010b ^ 01000000b = 00000010b
-01000010b ^ 01000001b = 00000011b
-01000010b ^ 01000010b = 00000000b
-01000010b ^ 01000011b = 00000001b
-01000010b ^ 01000100b = 00000110b
-01000010b ^ 01000101b = 00000111b
-01000010b ^ 01000110b = 00000100b
-01000010b ^ 01000111b = 00000101b
-01000010b ^ 01001000b = 00001010b
-01000010b ^ 01001001b = 00001011b
-01000010b ^ 01001010b = 00001000b
-01000010b ^ 01001011b = 00001001b
-01000010b ^ 01001100b = 00001110b
-01000010b ^ 01001101b = 00001111b
-01000010b ^ 01001110b = 00001100b
-01000010b ^ 01001111b = 00001101b
-01000010b ^ 01010000b = 00010010b
-01000010b ^ 01010001b = 00010011b
-01000010b ^ 01010010b = 00010000b
-01000010b ^ 01010011b = 00010001b
-01000010b ^ 01010100b = 00010110b
-01000010b ^ 01010101b = 00010111b
-01000010b ^ 01010110b = 00010100b
-01000010b ^ 01010111b = 00010101b
-01000010b ^ 01011000b = 00011010b
-01000010b ^ 01011001b = 00011011b
-01000010b ^ 01011010b = 00011000b
-01000010b ^ 01011011b = 00011001b
-01000010b ^ 01011100b = 00011110b
-01000010b ^ 01011101b = 00011111b
-01000010b ^ 01011110b = 00011100b
-01000010b ^ 01011111b = 00011101b
-01000010b ^ 01100000b = 00100010b
-01000010b ^ 01100001b = 00100011b
-01000010b ^ 01100010b = 00100000b
-01000010b ^ 01100011b = 00100001b
-01000010b ^ 01100100b = 00100110b
-01000010b ^ 01100101b = 00100111b
-01000010b ^ 01100110b = 00100100b
-01000010b ^ 01100111b = 00100101b
-01000010b ^ 01101000b = 00101010b
-01000010b ^ 01101001b = 00101011b
-01000010b ^ 01101010b = 00101000b
-01000010b ^ 01101011b = 00101001b
-01000010b ^ 01101100b = 00101110b
-01000010b ^ 01101101b = 00101111b
-01000010b ^ 01101110b = 00101100b
-01000010b ^ 01101111b = 00101101b
-01000010b ^ 01110000b = 00110010b
-01000010b ^ 01110001b = 00110011b
-01000010b ^ 01110010b = 00110000b
-01000010b ^ 01110011b = 00110001b
-01000010b ^ 01110100b = 00110110b
-01000010b ^ 01110101b = 00110111b
-01000010b ^ 01110110b = 00110100b
-01000010b ^ 01110111b = 00110101b
-01000010b ^ 01111000b = 00111010b
-01000010b ^ 01111001b = 00111011b
-01000010b ^ 01111010b = 00111000b
-01000010b ^ 01111011b = 00111001b
-01000010b ^ 01111100b = 00111110b
-01000010b ^ 01111101b = 00111111b
-01000010b ^ 01111110b = 00111100b
-01000011b ^ 10000000b = 11000011b
-01000011b ^ 10000001b = 11000010b
-01000011b ^ 10000010b = 11000001b
-01000011b ^ 10000011b = 11000000b
-01000011b ^ 10000100b = 11000111b
-01000011b ^ 10000101b = 11000110b
-01000011b ^ 10000110b = 11000101b
-01000011b ^ 10000111b = 11000100b
-01000011b ^ 10001000b = 11001011b
-01000011b ^ 10001001b = 11001010b
-01000011b ^ 10001010b = 11001001b
-01000011b ^ 10001011b = 11001000b
-01000011b ^ 10001100b = 11001111b
-01000011b ^ 10001101b = 11001110b
-01000011b ^ 10001110b = 11001101b
-01000011b ^ 10001111b = 11001100b
-01000011b ^ 10010000b = 11010011b
-01000011b ^ 10010001b = 11010010b
-01000011b ^ 10010010b = 11010001b
-01000011b ^ 10010011b = 11010000b
-01000011b ^ 10010100b = 11010111b
-01000011b ^ 10010101b = 11010110b
-01000011b ^ 10010110b = 11010101b
-01000011b ^ 10010111b = 11010100b
-01000011b ^ 10011000b = 11011011b
-01000011b ^ 10011001b = 11011010b
-01000011b ^ 10011010b = 11011001b
-01000011b ^ 10011011b = 11011000b
-01000011b ^ 10011100b = 11011111b
-01000011b ^ 10011101b = 11011110b
-01000011b ^ 10011110b = 11011101b
-01000011b ^ 10011111b = 11011100b
-01000011b ^ 10100000b = 11100011b
-01000011b ^ 10100001b = 11100010b
-01000011b ^ 10100010b = 11100001b
-01000011b ^ 10100011b = 11100000b
-01000011b ^ 10100100b = 11100111b
-01000011b ^ 10100101b = 11100110b
-01000011b ^ 10100110b = 11100101b
-01000011b ^ 10100111b = 11100100b
-01000011b ^ 10101000b = 11101011b
-01000011b ^ 10101001b = 11101010b
-01000011b ^ 10101010b = 11101001b
-01000011b ^ 10101011b = 11101000b
-01000011b ^ 10101100b = 11101111b
-01000011b ^ 10101101b = 11101110b
-01000011b ^ 10101110b = 11101101b
-01000011b ^ 10101111b = 11101100b
-01000011b ^ 10110000b = 11110011b
-01000011b ^ 10110001b = 11110010b
-01000011b ^ 10110010b = 11110001b
-01000011b ^ 10110011b = 11110000b
-01000011b ^ 10110100b = 11110111b
-01000011b ^ 10110101b = 11110110b
-01000011b ^ 10110110b = 11110101b
-01000011b ^ 10110111b = 11110100b
-01000011b ^ 10111000b = 11111011b
-01000011b ^ 10111001b = 11111010b
-01000011b ^ 10111010b = 11111001b
-01000011b ^ 10111011b = 11111000b
-01000011b ^ 10111100b = 11111111b
-01000011b ^ 10111101b = 11111110b
-01000011b ^ 10111110b = 11111101b
-01000011b ^ 10111111b = 11111100b
-01000011b ^ 11000000b = 10000011b
-01000011b ^ 11000001b = 10000010b
-01000011b ^ 11000010b = 10000001b
-01000011b ^ 11000011b = 10000000b
-01000011b ^ 11000100b = 10000111b
-01000011b ^ 11000101b = 10000110b
-01000011b ^ 11000110b = 10000101b
-01000011b ^ 11000111b = 10000100b
-01000011b ^ 11001000b = 10001011b
-01000011b ^ 11001001b = 10001010b
-01000011b ^ 11001010b = 10001001b
-01000011b ^ 11001011b = 10001000b
-01000011b ^ 11001100b = 10001111b
-01000011b ^ 11001101b = 10001110b
-01000011b ^ 11001110b = 10001101b
-01000011b ^ 11001111b = 10001100b
-01000011b ^ 11010000b = 10010011b
-01000011b ^ 11010001b = 10010010b
-01000011b ^ 11010010b = 10010001b
-01000011b ^ 11010011b = 10010000b
-01000011b ^ 11010100b = 10010111b
-01000011b ^ 11010101b = 10010110b
-01000011b ^ 11010110b = 10010101b
-01000011b ^ 11010111b = 10010100b
-01000011b ^ 11011000b = 10011011b
-01000011b ^ 11011001b = 10011010b
-01000011b ^ 11011010b = 10011001b
-01000011b ^ 11011011b = 10011000b
-01000011b ^ 11011100b = 10011111b
-01000011b ^ 11011101b = 10011110b
-01000011b ^ 11011110b = 10011101b
-01000011b ^ 11011111b = 10011100b
-01000011b ^ 11100000b = 10100011b
-01000011b ^ 11100001b = 10100010b
-01000011b ^ 11100010b = 10100001b
-01000011b ^ 11100011b = 10100000b
-01000011b ^ 11100100b = 10100111b
-01000011b ^ 11100101b = 10100110b
-01000011b ^ 11100110b = 10100101b
-01000011b ^ 11100111b = 10100100b
-01000011b ^ 11101000b = 10101011b
-01000011b ^ 11101001b = 10101010b
-01000011b ^ 11101010b = 10101001b
-01000011b ^ 11101011b = 10101000b
-01000011b ^ 11101100b = 10101111b
-01000011b ^ 11101101b = 10101110b
-01000011b ^ 11101110b = 10101101b
-01000011b ^ 11101111b = 10101100b
-01000011b ^ 11110000b = 10110011b
-01000011b ^ 11110001b = 10110010b
-01000011b ^ 11110010b = 10110001b
-01000011b ^ 11110011b = 10110000b
-01000011b ^ 11110100b = 10110111b
-01000011b ^ 11110101b = 10110110b
-01000011b ^ 11110110b = 10110101b
-01000011b ^ 11110111b = 10110100b
-01000011b ^ 11111000b = 10111011b
-01000011b ^ 11111001b = 10111010b
-01000011b ^ 11111010b = 10111001b
-01000011b ^ 11111011b = 10111000b
-01000011b ^ 11111100b = 10111111b
-01000011b ^ 11111101b = 10111110b
-01000011b ^ 11111110b = 10111101b
-01000011b ^ 11111111b = 10111100b
-01000011b ^ 00000000b = 01000011b
-01000011b ^ 00000001b = 01000010b
-01000011b ^ 00000010b = 01000001b
-01000011b ^ 00000011b = 01000000b
-01000011b ^ 00000100b = 01000111b
-01000011b ^ 00000101b = 01000110b
-01000011b ^ 00000110b = 01000101b
-01000011b ^ 00000111b = 01000100b
-01000011b ^ 00001000b = 01001011b
-01000011b ^ 00001001b = 01001010b
-01000011b ^ 00001010b = 01001001b
-01000011b ^ 00001011b = 01001000b
-01000011b ^ 00001100b = 01001111b
-01000011b ^ 00001101b = 01001110b
-01000011b ^ 00001110b = 01001101b
-01000011b ^ 00001111b = 01001100b
-01000011b ^ 00010000b = 01010011b
-01000011b ^ 00010001b = 01010010b
-01000011b ^ 00010010b = 01010001b
-01000011b ^ 00010011b = 01010000b
-01000011b ^ 00010100b = 01010111b
-01000011b ^ 00010101b = 01010110b
-01000011b ^ 00010110b = 01010101b
-01000011b ^ 00010111b = 01010100b
-01000011b ^ 00011000b = 01011011b
-01000011b ^ 00011001b = 01011010b
-01000011b ^ 00011010b = 01011001b
-01000011b ^ 00011011b = 01011000b
-01000011b ^ 00011100b = 01011111b
-01000011b ^ 00011101b = 01011110b
-01000011b ^ 00011110b = 01011101b
-01000011b ^ 00011111b = 01011100b
-01000011b ^ 00100000b = 01100011b
-01000011b ^ 00100001b = 01100010b
-01000011b ^ 00100010b = 01100001b
-01000011b ^ 00100011b = 01100000b
-01000011b ^ 00100100b = 01100111b
-01000011b ^ 00100101b = 01100110b
-01000011b ^ 00100110b = 01100101b
-01000011b ^ 00100111b = 01100100b
-01000011b ^ 00101000b = 01101011b
-01000011b ^ 00101001b = 01101010b
-01000011b ^ 00101010b = 01101001b
-01000011b ^ 00101011b = 01101000b
-01000011b ^ 00101100b = 01101111b
-01000011b ^ 00101101b = 01101110b
-01000011b ^ 00101110b = 01101101b
-01000011b ^ 00101111b = 01101100b
-01000011b ^ 00110000b = 01110011b
-01000011b ^ 00110001b = 01110010b
-01000011b ^ 00110010b = 01110001b
-01000011b ^ 00110011b = 01110000b
-01000011b ^ 00110100b = 01110111b
-01000011b ^ 00110101b = 01110110b
-01000011b ^ 00110110b = 01110101b
-01000011b ^ 00110111b = 01110100b
-01000011b ^ 00111000b = 01111011b
-01000011b ^ 00111001b = 01111010b
-01000011b ^ 00111010b = 01111001b
-01000011b ^ 00111011b = 01111000b
-01000011b ^ 00111100b = 01111111b
-01000011b ^ 00111101b = 01111110b
-01000011b ^ 00111110b = 01111101b
-01000011b ^ 00111111b = 01111100b
-01000011b ^ 01000000b = 00000011b
-01000011b ^ 01000001b = 00000010b
-01000011b ^ 01000010b = 00000001b
-01000011b ^ 01000011b = 00000000b
-01000011b ^ 01000100b = 00000111b
-01000011b ^ 01000101b = 00000110b
-01000011b ^ 01000110b = 00000101b
-01000011b ^ 01000111b = 00000100b
-01000011b ^ 01001000b = 00001011b
-01000011b ^ 01001001b = 00001010b
-01000011b ^ 01001010b = 00001001b
-01000011b ^ 01001011b = 00001000b
-01000011b ^ 01001100b = 00001111b
-01000011b ^ 01001101b = 00001110b
-01000011b ^ 01001110b = 00001101b
-01000011b ^ 01001111b = 00001100b
-01000011b ^ 01010000b = 00010011b
-01000011b ^ 01010001b = 00010010b
-01000011b ^ 01010010b = 00010001b
-01000011b ^ 01010011b = 00010000b
-01000011b ^ 01010100b = 00010111b
-01000011b ^ 01010101b = 00010110b
-01000011b ^ 01010110b = 00010101b
-01000011b ^ 01010111b = 00010100b
-01000011b ^ 01011000b = 00011011b
-01000011b ^ 01011001b = 00011010b
-01000011b ^ 01011010b = 00011001b
-01000011b ^ 01011011b = 00011000b
-01000011b ^ 01011100b = 00011111b
-01000011b ^ 01011101b = 00011110b
-01000011b ^ 01011110b = 00011101b
-01000011b ^ 01011111b = 00011100b
-01000011b ^ 01100000b = 00100011b
-01000011b ^ 01100001b = 00100010b
-01000011b ^ 01100010b = 00100001b
-01000011b ^ 01100011b = 00100000b
-01000011b ^ 01100100b = 00100111b
-01000011b ^ 01100101b = 00100110b
-01000011b ^ 01100110b = 00100101b
-01000011b ^ 01100111b = 00100100b
-01000011b ^ 01101000b = 00101011b
-01000011b ^ 01101001b = 00101010b
-01000011b ^ 01101010b = 00101001b
-01000011b ^ 01101011b = 00101000b
-01000011b ^ 01101100b = 00101111b
-01000011b ^ 01101101b = 00101110b
-01000011b ^ 01101110b = 00101101b
-01000011b ^ 01101111b = 00101100b
-01000011b ^ 01110000b = 00110011b
-01000011b ^ 01110001b = 00110010b
-01000011b ^ 01110010b = 00110001b
-01000011b ^ 01110011b = 00110000b
-01000011b ^ 01110100b = 00110111b
-01000011b ^ 01110101b = 00110110b
-01000011b ^ 01110110b = 00110101b
-01000011b ^ 01110111b = 00110100b
-01000011b ^ 01111000b = 00111011b
-01000011b ^ 01111001b = 00111010b
-01000011b ^ 01111010b = 00111001b
-01000011b ^ 01111011b = 00111000b
-01000011b ^ 01111100b = 00111111b
-01000011b ^ 01111101b = 00111110b
-01000011b ^ 01111110b = 00111101b
-01000100b ^ 10000000b = 11000100b
-01000100b ^ 10000001b = 11000101b
-01000100b ^ 10000010b = 11000110b
-01000100b ^ 10000011b = 11000111b
-01000100b ^ 10000100b = 11000000b
-01000100b ^ 10000101b = 11000001b
-01000100b ^ 10000110b = 11000010b
-01000100b ^ 10000111b = 11000011b
-01000100b ^ 10001000b = 11001100b
-01000100b ^ 10001001b = 11001101b
-01000100b ^ 10001010b = 11001110b
-01000100b ^ 10001011b = 11001111b
-01000100b ^ 10001100b = 11001000b
-01000100b ^ 10001101b = 11001001b
-01000100b ^ 10001110b = 11001010b
-01000100b ^ 10001111b = 11001011b
-01000100b ^ 10010000b = 11010100b
-01000100b ^ 10010001b = 11010101b
-01000100b ^ 10010010b = 11010110b
-01000100b ^ 10010011b = 11010111b
-01000100b ^ 10010100b = 11010000b
-01000100b ^ 10010101b = 11010001b
-01000100b ^ 10010110b = 11010010b
-01000100b ^ 10010111b = 11010011b
-01000100b ^ 10011000b = 11011100b
-01000100b ^ 10011001b = 11011101b
-01000100b ^ 10011010b = 11011110b
-01000100b ^ 10011011b = 11011111b
-01000100b ^ 10011100b = 11011000b
-01000100b ^ 10011101b = 11011001b
-01000100b ^ 10011110b = 11011010b
-01000100b ^ 10011111b = 11011011b
-01000100b ^ 10100000b = 11100100b
-01000100b ^ 10100001b = 11100101b
-01000100b ^ 10100010b = 11100110b
-01000100b ^ 10100011b = 11100111b
-01000100b ^ 10100100b = 11100000b
-01000100b ^ 10100101b = 11100001b
-01000100b ^ 10100110b = 11100010b
-01000100b ^ 10100111b = 11100011b
-01000100b ^ 10101000b = 11101100b
-01000100b ^ 10101001b = 11101101b
-01000100b ^ 10101010b = 11101110b
-01000100b ^ 10101011b = 11101111b
-01000100b ^ 10101100b = 11101000b
-01000100b ^ 10101101b = 11101001b
-01000100b ^ 10101110b = 11101010b
-01000100b ^ 10101111b = 11101011b
-01000100b ^ 10110000b = 11110100b
-01000100b ^ 10110001b = 11110101b
-01000100b ^ 10110010b = 11110110b
-01000100b ^ 10110011b = 11110111b
-01000100b ^ 10110100b = 11110000b
-01000100b ^ 10110101b = 11110001b
-01000100b ^ 10110110b = 11110010b
-01000100b ^ 10110111b = 11110011b
-01000100b ^ 10111000b = 11111100b
-01000100b ^ 10111001b = 11111101b
-01000100b ^ 10111010b = 11111110b
-01000100b ^ 10111011b = 11111111b
-01000100b ^ 10111100b = 11111000b
-01000100b ^ 10111101b = 11111001b
-01000100b ^ 10111110b = 11111010b
-01000100b ^ 10111111b = 11111011b
-01000100b ^ 11000000b = 10000100b
-01000100b ^ 11000001b = 10000101b
-01000100b ^ 11000010b = 10000110b
-01000100b ^ 11000011b = 10000111b
-01000100b ^ 11000100b = 10000000b
-01000100b ^ 11000101b = 10000001b
-01000100b ^ 11000110b = 10000010b
-01000100b ^ 11000111b = 10000011b
-01000100b ^ 11001000b = 10001100b
-01000100b ^ 11001001b = 10001101b
-01000100b ^ 11001010b = 10001110b
-01000100b ^ 11001011b = 10001111b
-01000100b ^ 11001100b = 10001000b
-01000100b ^ 11001101b = 10001001b
-01000100b ^ 11001110b = 10001010b
-01000100b ^ 11001111b = 10001011b
-01000100b ^ 11010000b = 10010100b
-01000100b ^ 11010001b = 10010101b
-01000100b ^ 11010010b = 10010110b
-01000100b ^ 11010011b = 10010111b
-01000100b ^ 11010100b = 10010000b
-01000100b ^ 11010101b = 10010001b
-01000100b ^ 11010110b = 10010010b
-01000100b ^ 11010111b = 10010011b
-01000100b ^ 11011000b = 10011100b
-01000100b ^ 11011001b = 10011101b
-01000100b ^ 11011010b = 10011110b
-01000100b ^ 11011011b = 10011111b
-01000100b ^ 11011100b = 10011000b
-01000100b ^ 11011101b = 10011001b
-01000100b ^ 11011110b = 10011010b
-01000100b ^ 11011111b = 10011011b
-01000100b ^ 11100000b = 10100100b
-01000100b ^ 11100001b = 10100101b
-01000100b ^ 11100010b = 10100110b
-01000100b ^ 11100011b = 10100111b
-01000100b ^ 11100100b = 10100000b
-01000100b ^ 11100101b = 10100001b
-01000100b ^ 11100110b = 10100010b
-01000100b ^ 11100111b = 10100011b
-01000100b ^ 11101000b = 10101100b
-01000100b ^ 11101001b = 10101101b
-01000100b ^ 11101010b = 10101110b
-01000100b ^ 11101011b = 10101111b
-01000100b ^ 11101100b = 10101000b
-01000100b ^ 11101101b = 10101001b
-01000100b ^ 11101110b = 10101010b
-01000100b ^ 11101111b = 10101011b
-01000100b ^ 11110000b = 10110100b
-01000100b ^ 11110001b = 10110101b
-01000100b ^ 11110010b = 10110110b
-01000100b ^ 11110011b = 10110111b
-01000100b ^ 11110100b = 10110000b
-01000100b ^ 11110101b = 10110001b
-01000100b ^ 11110110b = 10110010b
-01000100b ^ 11110111b = 10110011b
-01000100b ^ 11111000b = 10111100b
-01000100b ^ 11111001b = 10111101b
-01000100b ^ 11111010b = 10111110b
-01000100b ^ 11111011b = 10111111b
-01000100b ^ 11111100b = 10111000b
-01000100b ^ 11111101b = 10111001b
-01000100b ^ 11111110b = 10111010b
-01000100b ^ 11111111b = 10111011b
-01000100b ^ 00000000b = 01000100b
-01000100b ^ 00000001b = 01000101b
-01000100b ^ 00000010b = 01000110b
-01000100b ^ 00000011b = 01000111b
-01000100b ^ 00000100b = 01000000b
-01000100b ^ 00000101b = 01000001b
-01000100b ^ 00000110b = 01000010b
-01000100b ^ 00000111b = 01000011b
-01000100b ^ 00001000b = 01001100b
-01000100b ^ 00001001b = 01001101b
-01000100b ^ 00001010b = 01001110b
-01000100b ^ 00001011b = 01001111b
-01000100b ^ 00001100b = 01001000b
-01000100b ^ 00001101b = 01001001b
-01000100b ^ 00001110b = 01001010b
-01000100b ^ 00001111b = 01001011b
-01000100b ^ 00010000b = 01010100b
-01000100b ^ 00010001b = 01010101b
-01000100b ^ 00010010b = 01010110b
-01000100b ^ 00010011b = 01010111b
-01000100b ^ 00010100b = 01010000b
-01000100b ^ 00010101b = 01010001b
-01000100b ^ 00010110b = 01010010b
-01000100b ^ 00010111b = 01010011b
-01000100b ^ 00011000b = 01011100b
-01000100b ^ 00011001b = 01011101b
-01000100b ^ 00011010b = 01011110b
-01000100b ^ 00011011b = 01011111b
-01000100b ^ 00011100b = 01011000b
-01000100b ^ 00011101b = 01011001b
-01000100b ^ 00011110b = 01011010b
-01000100b ^ 00011111b = 01011011b
-01000100b ^ 00100000b = 01100100b
-01000100b ^ 00100001b = 01100101b
-01000100b ^ 00100010b = 01100110b
-01000100b ^ 00100011b = 01100111b
-01000100b ^ 00100100b = 01100000b
-01000100b ^ 00100101b = 01100001b
-01000100b ^ 00100110b = 01100010b
-01000100b ^ 00100111b = 01100011b
-01000100b ^ 00101000b = 01101100b
-01000100b ^ 00101001b = 01101101b
-01000100b ^ 00101010b = 01101110b
-01000100b ^ 00101011b = 01101111b
-01000100b ^ 00101100b = 01101000b
-01000100b ^ 00101101b = 01101001b
-01000100b ^ 00101110b = 01101010b
-01000100b ^ 00101111b = 01101011b
-01000100b ^ 00110000b = 01110100b
-01000100b ^ 00110001b = 01110101b
-01000100b ^ 00110010b = 01110110b
-01000100b ^ 00110011b = 01110111b
-01000100b ^ 00110100b = 01110000b
-01000100b ^ 00110101b = 01110001b
-01000100b ^ 00110110b = 01110010b
-01000100b ^ 00110111b = 01110011b
-01000100b ^ 00111000b = 01111100b
-01000100b ^ 00111001b = 01111101b
-01000100b ^ 00111010b = 01111110b
-01000100b ^ 00111011b = 01111111b
-01000100b ^ 00111100b = 01111000b
-01000100b ^ 00111101b = 01111001b
-01000100b ^ 00111110b = 01111010b
-01000100b ^ 00111111b = 01111011b
-01000100b ^ 01000000b = 00000100b
-01000100b ^ 01000001b = 00000101b
-01000100b ^ 01000010b = 00000110b
-01000100b ^ 01000011b = 00000111b
-01000100b ^ 01000100b = 00000000b
-01000100b ^ 01000101b = 00000001b
-01000100b ^ 01000110b = 00000010b
-01000100b ^ 01000111b = 00000011b
-01000100b ^ 01001000b = 00001100b
-01000100b ^ 01001001b = 00001101b
-01000100b ^ 01001010b = 00001110b
-01000100b ^ 01001011b = 00001111b
-01000100b ^ 01001100b = 00001000b
-01000100b ^ 01001101b = 00001001b
-01000100b ^ 01001110b = 00001010b
-01000100b ^ 01001111b = 00001011b
-01000100b ^ 01010000b = 00010100b
-01000100b ^ 01010001b = 00010101b
-01000100b ^ 01010010b = 00010110b
-01000100b ^ 01010011b = 00010111b
-01000100b ^ 01010100b = 00010000b
-01000100b ^ 01010101b = 00010001b
-01000100b ^ 01010110b = 00010010b
-01000100b ^ 01010111b = 00010011b
-01000100b ^ 01011000b = 00011100b
-01000100b ^ 01011001b = 00011101b
-01000100b ^ 01011010b = 00011110b
-01000100b ^ 01011011b = 00011111b
-01000100b ^ 01011100b = 00011000b
-01000100b ^ 01011101b = 00011001b
-01000100b ^ 01011110b = 00011010b
-01000100b ^ 01011111b = 00011011b
-01000100b ^ 01100000b = 00100100b
-01000100b ^ 01100001b = 00100101b
-01000100b ^ 01100010b = 00100110b
-01000100b ^ 01100011b = 00100111b
-01000100b ^ 01100100b = 00100000b
-01000100b ^ 01100101b = 00100001b
-01000100b ^ 01100110b = 00100010b
-01000100b ^ 01100111b = 00100011b
-01000100b ^ 01101000b = 00101100b
-01000100b ^ 01101001b = 00101101b
-01000100b ^ 01101010b = 00101110b
-01000100b ^ 01101011b = 00101111b
-01000100b ^ 01101100b = 00101000b
-01000100b ^ 01101101b = 00101001b
-01000100b ^ 01101110b = 00101010b
-01000100b ^ 01101111b = 00101011b
-01000100b ^ 01110000b = 00110100b
-01000100b ^ 01110001b = 00110101b
-01000100b ^ 01110010b = 00110110b
-01000100b ^ 01110011b = 00110111b
-01000100b ^ 01110100b = 00110000b
-01000100b ^ 01110101b = 00110001b
-01000100b ^ 01110110b = 00110010b
-01000100b ^ 01110111b = 00110011b
-01000100b ^ 01111000b = 00111100b
-01000100b ^ 01111001b = 00111101b
-01000100b ^ 01111010b = 00111110b
-01000100b ^ 01111011b = 00111111b
-01000100b ^ 01111100b = 00111000b
-01000100b ^ 01111101b = 00111001b
-01000100b ^ 01111110b = 00111010b
-01000101b ^ 10000000b = 11000101b
-01000101b ^ 10000001b = 11000100b
-01000101b ^ 10000010b = 11000111b
-01000101b ^ 10000011b = 11000110b
-01000101b ^ 10000100b = 11000001b
-01000101b ^ 10000101b = 11000000b
-01000101b ^ 10000110b = 11000011b
-01000101b ^ 10000111b = 11000010b
-01000101b ^ 10001000b = 11001101b
-01000101b ^ 10001001b = 11001100b
-01000101b ^ 10001010b = 11001111b
-01000101b ^ 10001011b = 11001110b
-01000101b ^ 10001100b = 11001001b
-01000101b ^ 10001101b = 11001000b
-01000101b ^ 10001110b = 11001011b
-01000101b ^ 10001111b = 11001010b
-01000101b ^ 10010000b = 11010101b
-01000101b ^ 10010001b = 11010100b
-01000101b ^ 10010010b = 11010111b
-01000101b ^ 10010011b = 11010110b
-01000101b ^ 10010100b = 11010001b
-01000101b ^ 10010101b = 11010000b
-01000101b ^ 10010110b = 11010011b
-01000101b ^ 10010111b = 11010010b
-01000101b ^ 10011000b = 11011101b
-01000101b ^ 10011001b = 11011100b
-01000101b ^ 10011010b = 11011111b
-01000101b ^ 10011011b = 11011110b
-01000101b ^ 10011100b = 11011001b
-01000101b ^ 10011101b = 11011000b
-01000101b ^ 10011110b = 11011011b
-01000101b ^ 10011111b = 11011010b
-01000101b ^ 10100000b = 11100101b
-01000101b ^ 10100001b = 11100100b
-01000101b ^ 10100010b = 11100111b
-01000101b ^ 10100011b = 11100110b
-01000101b ^ 10100100b = 11100001b
-01000101b ^ 10100101b = 11100000b
-01000101b ^ 10100110b = 11100011b
-01000101b ^ 10100111b = 11100010b
-01000101b ^ 10101000b = 11101101b
-01000101b ^ 10101001b = 11101100b
-01000101b ^ 10101010b = 11101111b
-01000101b ^ 10101011b = 11101110b
-01000101b ^ 10101100b = 11101001b
-01000101b ^ 10101101b = 11101000b
-01000101b ^ 10101110b = 11101011b
-01000101b ^ 10101111b = 11101010b
-01000101b ^ 10110000b = 11110101b
-01000101b ^ 10110001b = 11110100b
-01000101b ^ 10110010b = 11110111b
-01000101b ^ 10110011b = 11110110b
-01000101b ^ 10110100b = 11110001b
-01000101b ^ 10110101b = 11110000b
-01000101b ^ 10110110b = 11110011b
-01000101b ^ 10110111b = 11110010b
-01000101b ^ 10111000b = 11111101b
-01000101b ^ 10111001b = 11111100b
-01000101b ^ 10111010b = 11111111b
-01000101b ^ 10111011b = 11111110b
-01000101b ^ 10111100b = 11111001b
-01000101b ^ 10111101b = 11111000b
-01000101b ^ 10111110b = 11111011b
-01000101b ^ 10111111b = 11111010b
-01000101b ^ 11000000b = 10000101b
-01000101b ^ 11000001b = 10000100b
-01000101b ^ 11000010b = 10000111b
-01000101b ^ 11000011b = 10000110b
-01000101b ^ 11000100b = 10000001b
-01000101b ^ 11000101b = 10000000b
-01000101b ^ 11000110b = 10000011b
-01000101b ^ 11000111b = 10000010b
-01000101b ^ 11001000b = 10001101b
-01000101b ^ 11001001b = 10001100b
-01000101b ^ 11001010b = 10001111b
-01000101b ^ 11001011b = 10001110b
-01000101b ^ 11001100b = 10001001b
-01000101b ^ 11001101b = 10001000b
-01000101b ^ 11001110b = 10001011b
-01000101b ^ 11001111b = 10001010b
-01000101b ^ 11010000b = 10010101b
-01000101b ^ 11010001b = 10010100b
-01000101b ^ 11010010b = 10010111b
-01000101b ^ 11010011b = 10010110b
-01000101b ^ 11010100b = 10010001b
-01000101b ^ 11010101b = 10010000b
-01000101b ^ 11010110b = 10010011b
-01000101b ^ 11010111b = 10010010b
-01000101b ^ 11011000b = 10011101b
-01000101b ^ 11011001b = 10011100b
-01000101b ^ 11011010b = 10011111b
-01000101b ^ 11011011b = 10011110b
-01000101b ^ 11011100b = 10011001b
-01000101b ^ 11011101b = 10011000b
-01000101b ^ 11011110b = 10011011b
-01000101b ^ 11011111b = 10011010b
-01000101b ^ 11100000b = 10100101b
-01000101b ^ 11100001b = 10100100b
-01000101b ^ 11100010b = 10100111b
-01000101b ^ 11100011b = 10100110b
-01000101b ^ 11100100b = 10100001b
-01000101b ^ 11100101b = 10100000b
-01000101b ^ 11100110b = 10100011b
-01000101b ^ 11100111b = 10100010b
-01000101b ^ 11101000b = 10101101b
-01000101b ^ 11101001b = 10101100b
-01000101b ^ 11101010b = 10101111b
-01000101b ^ 11101011b = 10101110b
-01000101b ^ 11101100b = 10101001b
-01000101b ^ 11101101b = 10101000b
-01000101b ^ 11101110b = 10101011b
-01000101b ^ 11101111b = 10101010b
-01000101b ^ 11110000b = 10110101b
-01000101b ^ 11110001b = 10110100b
-01000101b ^ 11110010b = 10110111b
-01000101b ^ 11110011b = 10110110b
-01000101b ^ 11110100b = 10110001b
-01000101b ^ 11110101b = 10110000b
-01000101b ^ 11110110b = 10110011b
-01000101b ^ 11110111b = 10110010b
-01000101b ^ 11111000b = 10111101b
-01000101b ^ 11111001b = 10111100b
-01000101b ^ 11111010b = 10111111b
-01000101b ^ 11111011b = 10111110b
-01000101b ^ 11111100b = 10111001b
-01000101b ^ 11111101b = 10111000b
-01000101b ^ 11111110b = 10111011b
-01000101b ^ 11111111b = 10111010b
-01000101b ^ 00000000b = 01000101b
-01000101b ^ 00000001b = 01000100b
-01000101b ^ 00000010b = 01000111b
-01000101b ^ 00000011b = 01000110b
-01000101b ^ 00000100b = 01000001b
-01000101b ^ 00000101b = 01000000b
-01000101b ^ 00000110b = 01000011b
-01000101b ^ 00000111b = 01000010b
-01000101b ^ 00001000b = 01001101b
-01000101b ^ 00001001b = 01001100b
-01000101b ^ 00001010b = 01001111b
-01000101b ^ 00001011b = 01001110b
-01000101b ^ 00001100b = 01001001b
-01000101b ^ 00001101b = 01001000b
-01000101b ^ 00001110b = 01001011b
-01000101b ^ 00001111b = 01001010b
-01000101b ^ 00010000b = 01010101b
-01000101b ^ 00010001b = 01010100b
-01000101b ^ 00010010b = 01010111b
-01000101b ^ 00010011b = 01010110b
-01000101b ^ 00010100b = 01010001b
-01000101b ^ 00010101b = 01010000b
-01000101b ^ 00010110b = 01010011b
-01000101b ^ 00010111b = 01010010b
-01000101b ^ 00011000b = 01011101b
-01000101b ^ 00011001b = 01011100b
-01000101b ^ 00011010b = 01011111b
-01000101b ^ 00011011b = 01011110b
-01000101b ^ 00011100b = 01011001b
-01000101b ^ 00011101b = 01011000b
-01000101b ^ 00011110b = 01011011b
-01000101b ^ 00011111b = 01011010b
-01000101b ^ 00100000b = 01100101b
-01000101b ^ 00100001b = 01100100b
-01000101b ^ 00100010b = 01100111b
-01000101b ^ 00100011b = 01100110b
-01000101b ^ 00100100b = 01100001b
-01000101b ^ 00100101b = 01100000b
-01000101b ^ 00100110b = 01100011b
-01000101b ^ 00100111b = 01100010b
-01000101b ^ 00101000b = 01101101b
-01000101b ^ 00101001b = 01101100b
-01000101b ^ 00101010b = 01101111b
-01000101b ^ 00101011b = 01101110b
-01000101b ^ 00101100b = 01101001b
-01000101b ^ 00101101b = 01101000b
-01000101b ^ 00101110b = 01101011b
-01000101b ^ 00101111b = 01101010b
-01000101b ^ 00110000b = 01110101b
-01000101b ^ 00110001b = 01110100b
-01000101b ^ 00110010b = 01110111b
-01000101b ^ 00110011b = 01110110b
-01000101b ^ 00110100b = 01110001b
-01000101b ^ 00110101b = 01110000b
-01000101b ^ 00110110b = 01110011b
-01000101b ^ 00110111b = 01110010b
-01000101b ^ 00111000b = 01111101b
-01000101b ^ 00111001b = 01111100b
-01000101b ^ 00111010b = 01111111b
-01000101b ^ 00111011b = 01111110b
-01000101b ^ 00111100b = 01111001b
-01000101b ^ 00111101b = 01111000b
-01000101b ^ 00111110b = 01111011b
-01000101b ^ 00111111b = 01111010b
-01000101b ^ 01000000b = 00000101b
-01000101b ^ 01000001b = 00000100b
-01000101b ^ 01000010b = 00000111b
-01000101b ^ 01000011b = 00000110b
-01000101b ^ 01000100b = 00000001b
-01000101b ^ 01000101b = 00000000b
-01000101b ^ 01000110b = 00000011b
-01000101b ^ 01000111b = 00000010b
-01000101b ^ 01001000b = 00001101b
-01000101b ^ 01001001b = 00001100b
-01000101b ^ 01001010b = 00001111b
-01000101b ^ 01001011b = 00001110b
-01000101b ^ 01001100b = 00001001b
-01000101b ^ 01001101b = 00001000b
-01000101b ^ 01001110b = 00001011b
-01000101b ^ 01001111b = 00001010b
-01000101b ^ 01010000b = 00010101b
-01000101b ^ 01010001b = 00010100b
-01000101b ^ 01010010b = 00010111b
-01000101b ^ 01010011b = 00010110b
-01000101b ^ 01010100b = 00010001b
-01000101b ^ 01010101b = 00010000b
-01000101b ^ 01010110b = 00010011b
-01000101b ^ 01010111b = 00010010b
-01000101b ^ 01011000b = 00011101b
-01000101b ^ 01011001b = 00011100b
-01000101b ^ 01011010b = 00011111b
-01000101b ^ 01011011b = 00011110b
-01000101b ^ 01011100b = 00011001b
-01000101b ^ 01011101b = 00011000b
-01000101b ^ 01011110b = 00011011b
-01000101b ^ 01011111b = 00011010b
-01000101b ^ 01100000b = 00100101b
-01000101b ^ 01100001b = 00100100b
-01000101b ^ 01100010b = 00100111b
-01000101b ^ 01100011b = 00100110b
-01000101b ^ 01100100b = 00100001b
-01000101b ^ 01100101b = 00100000b
-01000101b ^ 01100110b = 00100011b
-01000101b ^ 01100111b = 00100010b
-01000101b ^ 01101000b = 00101101b
-01000101b ^ 01101001b = 00101100b
-01000101b ^ 01101010b = 00101111b
-01000101b ^ 01101011b = 00101110b
-01000101b ^ 01101100b = 00101001b
-01000101b ^ 01101101b = 00101000b
-01000101b ^ 01101110b = 00101011b
-01000101b ^ 01101111b = 00101010b
-01000101b ^ 01110000b = 00110101b
-01000101b ^ 01110001b = 00110100b
-01000101b ^ 01110010b = 00110111b
-01000101b ^ 01110011b = 00110110b
-01000101b ^ 01110100b = 00110001b
-01000101b ^ 01110101b = 00110000b
-01000101b ^ 01110110b = 00110011b
-01000101b ^ 01110111b = 00110010b
-01000101b ^ 01111000b = 00111101b
-01000101b ^ 01111001b = 00111100b
-01000101b ^ 01111010b = 00111111b
-01000101b ^ 01111011b = 00111110b
-01000101b ^ 01111100b = 00111001b
-01000101b ^ 01111101b = 00111000b
-01000101b ^ 01111110b = 00111011b
-01000110b ^ 10000000b = 11000110b
-01000110b ^ 10000001b = 11000111b
-01000110b ^ 10000010b = 11000100b
-01000110b ^ 10000011b = 11000101b
-01000110b ^ 10000100b = 11000010b
-01000110b ^ 10000101b = 11000011b
-01000110b ^ 10000110b = 11000000b
-01000110b ^ 10000111b = 11000001b
-01000110b ^ 10001000b = 11001110b
-01000110b ^ 10001001b = 11001111b
-01000110b ^ 10001010b = 11001100b
-01000110b ^ 10001011b = 11001101b
-01000110b ^ 10001100b = 11001010b
-01000110b ^ 10001101b = 11001011b
-01000110b ^ 10001110b = 11001000b
-01000110b ^ 10001111b = 11001001b
-01000110b ^ 10010000b = 11010110b
-01000110b ^ 10010001b = 11010111b
-01000110b ^ 10010010b = 11010100b
-01000110b ^ 10010011b = 11010101b
-01000110b ^ 10010100b = 11010010b
-01000110b ^ 10010101b = 11010011b
-01000110b ^ 10010110b = 11010000b
-01000110b ^ 10010111b = 11010001b
-01000110b ^ 10011000b = 11011110b
-01000110b ^ 10011001b = 11011111b
-01000110b ^ 10011010b = 11011100b
-01000110b ^ 10011011b = 11011101b
-01000110b ^ 10011100b = 11011010b
-01000110b ^ 10011101b = 11011011b
-01000110b ^ 10011110b = 11011000b
-01000110b ^ 10011111b = 11011001b
-01000110b ^ 10100000b = 11100110b
-01000110b ^ 10100001b = 11100111b
-01000110b ^ 10100010b = 11100100b
-01000110b ^ 10100011b = 11100101b
-01000110b ^ 10100100b = 11100010b
-01000110b ^ 10100101b = 11100011b
-01000110b ^ 10100110b = 11100000b
-01000110b ^ 10100111b = 11100001b
-01000110b ^ 10101000b = 11101110b
-01000110b ^ 10101001b = 11101111b
-01000110b ^ 10101010b = 11101100b
-01000110b ^ 10101011b = 11101101b
-01000110b ^ 10101100b = 11101010b
-01000110b ^ 10101101b = 11101011b
-01000110b ^ 10101110b = 11101000b
-01000110b ^ 10101111b = 11101001b
-01000110b ^ 10110000b = 11110110b
-01000110b ^ 10110001b = 11110111b
-01000110b ^ 10110010b = 11110100b
-01000110b ^ 10110011b = 11110101b
-01000110b ^ 10110100b = 11110010b
-01000110b ^ 10110101b = 11110011b
-01000110b ^ 10110110b = 11110000b
-01000110b ^ 10110111b = 11110001b
-01000110b ^ 10111000b = 11111110b
-01000110b ^ 10111001b = 11111111b
-01000110b ^ 10111010b = 11111100b
-01000110b ^ 10111011b = 11111101b
-01000110b ^ 10111100b = 11111010b
-01000110b ^ 10111101b = 11111011b
-01000110b ^ 10111110b = 11111000b
-01000110b ^ 10111111b = 11111001b
-01000110b ^ 11000000b = 10000110b
-01000110b ^ 11000001b = 10000111b
-01000110b ^ 11000010b = 10000100b
-01000110b ^ 11000011b = 10000101b
-01000110b ^ 11000100b = 10000010b
-01000110b ^ 11000101b = 10000011b
-01000110b ^ 11000110b = 10000000b
-01000110b ^ 11000111b = 10000001b
-01000110b ^ 11001000b = 10001110b
-01000110b ^ 11001001b = 10001111b
-01000110b ^ 11001010b = 10001100b
-01000110b ^ 11001011b = 10001101b
-01000110b ^ 11001100b = 10001010b
-01000110b ^ 11001101b = 10001011b
-01000110b ^ 11001110b = 10001000b
-01000110b ^ 11001111b = 10001001b
-01000110b ^ 11010000b = 10010110b
-01000110b ^ 11010001b = 10010111b
-01000110b ^ 11010010b = 10010100b
-01000110b ^ 11010011b = 10010101b
-01000110b ^ 11010100b = 10010010b
-01000110b ^ 11010101b = 10010011b
-01000110b ^ 11010110b = 10010000b
-01000110b ^ 11010111b = 10010001b
-01000110b ^ 11011000b = 10011110b
-01000110b ^ 11011001b = 10011111b
-01000110b ^ 11011010b = 10011100b
-01000110b ^ 11011011b = 10011101b
-01000110b ^ 11011100b = 10011010b
-01000110b ^ 11011101b = 10011011b
-01000110b ^ 11011110b = 10011000b
-01000110b ^ 11011111b = 10011001b
-01000110b ^ 11100000b = 10100110b
-01000110b ^ 11100001b = 10100111b
-01000110b ^ 11100010b = 10100100b
-01000110b ^ 11100011b = 10100101b
-01000110b ^ 11100100b = 10100010b
-01000110b ^ 11100101b = 10100011b
-01000110b ^ 11100110b = 10100000b
-01000110b ^ 11100111b = 10100001b
-01000110b ^ 11101000b = 10101110b
-01000110b ^ 11101001b = 10101111b
-01000110b ^ 11101010b = 10101100b
-01000110b ^ 11101011b = 10101101b
-01000110b ^ 11101100b = 10101010b
-01000110b ^ 11101101b = 10101011b
-01000110b ^ 11101110b = 10101000b
-01000110b ^ 11101111b = 10101001b
-01000110b ^ 11110000b = 10110110b
-01000110b ^ 11110001b = 10110111b
-01000110b ^ 11110010b = 10110100b
-01000110b ^ 11110011b = 10110101b
-01000110b ^ 11110100b = 10110010b
-01000110b ^ 11110101b = 10110011b
-01000110b ^ 11110110b = 10110000b
-01000110b ^ 11110111b = 10110001b
-01000110b ^ 11111000b = 10111110b
-01000110b ^ 11111001b = 10111111b
-01000110b ^ 11111010b = 10111100b
-01000110b ^ 11111011b = 10111101b
-01000110b ^ 11111100b = 10111010b
-01000110b ^ 11111101b = 10111011b
-01000110b ^ 11111110b = 10111000b
-01000110b ^ 11111111b = 10111001b
-01000110b ^ 00000000b = 01000110b
-01000110b ^ 00000001b = 01000111b
-01000110b ^ 00000010b = 01000100b
-01000110b ^ 00000011b = 01000101b
-01000110b ^ 00000100b = 01000010b
-01000110b ^ 00000101b = 01000011b
-01000110b ^ 00000110b = 01000000b
-01000110b ^ 00000111b = 01000001b
-01000110b ^ 00001000b = 01001110b
-01000110b ^ 00001001b = 01001111b
-01000110b ^ 00001010b = 01001100b
-01000110b ^ 00001011b = 01001101b
-01000110b ^ 00001100b = 01001010b
-01000110b ^ 00001101b = 01001011b
-01000110b ^ 00001110b = 01001000b
-01000110b ^ 00001111b = 01001001b
-01000110b ^ 00010000b = 01010110b
-01000110b ^ 00010001b = 01010111b
-01000110b ^ 00010010b = 01010100b
-01000110b ^ 00010011b = 01010101b
-01000110b ^ 00010100b = 01010010b
-01000110b ^ 00010101b = 01010011b
-01000110b ^ 00010110b = 01010000b
-01000110b ^ 00010111b = 01010001b
-01000110b ^ 00011000b = 01011110b
-01000110b ^ 00011001b = 01011111b
-01000110b ^ 00011010b = 01011100b
-01000110b ^ 00011011b = 01011101b
-01000110b ^ 00011100b = 01011010b
-01000110b ^ 00011101b = 01011011b
-01000110b ^ 00011110b = 01011000b
-01000110b ^ 00011111b = 01011001b
-01000110b ^ 00100000b = 01100110b
-01000110b ^ 00100001b = 01100111b
-01000110b ^ 00100010b = 01100100b
-01000110b ^ 00100011b = 01100101b
-01000110b ^ 00100100b = 01100010b
-01000110b ^ 00100101b = 01100011b
-01000110b ^ 00100110b = 01100000b
-01000110b ^ 00100111b = 01100001b
-01000110b ^ 00101000b = 01101110b
-01000110b ^ 00101001b = 01101111b
-01000110b ^ 00101010b = 01101100b
-01000110b ^ 00101011b = 01101101b
-01000110b ^ 00101100b = 01101010b
-01000110b ^ 00101101b = 01101011b
-01000110b ^ 00101110b = 01101000b
-01000110b ^ 00101111b = 01101001b
-01000110b ^ 00110000b = 01110110b
-01000110b ^ 00110001b = 01110111b
-01000110b ^ 00110010b = 01110100b
-01000110b ^ 00110011b = 01110101b
-01000110b ^ 00110100b = 01110010b
-01000110b ^ 00110101b = 01110011b
-01000110b ^ 00110110b = 01110000b
-01000110b ^ 00110111b = 01110001b
-01000110b ^ 00111000b = 01111110b
-01000110b ^ 00111001b = 01111111b
-01000110b ^ 00111010b = 01111100b
-01000110b ^ 00111011b = 01111101b
-01000110b ^ 00111100b = 01111010b
-01000110b ^ 00111101b = 01111011b
-01000110b ^ 00111110b = 01111000b
-01000110b ^ 00111111b = 01111001b
-01000110b ^ 01000000b = 00000110b
-01000110b ^ 01000001b = 00000111b
-01000110b ^ 01000010b = 00000100b
-01000110b ^ 01000011b = 00000101b
-01000110b ^ 01000100b = 00000010b
-01000110b ^ 01000101b = 00000011b
-01000110b ^ 01000110b = 00000000b
-01000110b ^ 01000111b = 00000001b
-01000110b ^ 01001000b = 00001110b
-01000110b ^ 01001001b = 00001111b
-01000110b ^ 01001010b = 00001100b
-01000110b ^ 01001011b = 00001101b
-01000110b ^ 01001100b = 00001010b
-01000110b ^ 01001101b = 00001011b
-01000110b ^ 01001110b = 00001000b
-01000110b ^ 01001111b = 00001001b
-01000110b ^ 01010000b = 00010110b
-01000110b ^ 01010001b = 00010111b
-01000110b ^ 01010010b = 00010100b
-01000110b ^ 01010011b = 00010101b
-01000110b ^ 01010100b = 00010010b
-01000110b ^ 01010101b = 00010011b
-01000110b ^ 01010110b = 00010000b
-01000110b ^ 01010111b = 00010001b
-01000110b ^ 01011000b = 00011110b
-01000110b ^ 01011001b = 00011111b
-01000110b ^ 01011010b = 00011100b
-01000110b ^ 01011011b = 00011101b
-01000110b ^ 01011100b = 00011010b
-01000110b ^ 01011101b = 00011011b
-01000110b ^ 01011110b = 00011000b
-01000110b ^ 01011111b = 00011001b
-01000110b ^ 01100000b = 00100110b
-01000110b ^ 01100001b = 00100111b
-01000110b ^ 01100010b = 00100100b
-01000110b ^ 01100011b = 00100101b
-01000110b ^ 01100100b = 00100010b
-01000110b ^ 01100101b = 00100011b
-01000110b ^ 01100110b = 00100000b
-01000110b ^ 01100111b = 00100001b
-01000110b ^ 01101000b = 00101110b
-01000110b ^ 01101001b = 00101111b
-01000110b ^ 01101010b = 00101100b
-01000110b ^ 01101011b = 00101101b
-01000110b ^ 01101100b = 00101010b
-01000110b ^ 01101101b = 00101011b
-01000110b ^ 01101110b = 00101000b
-01000110b ^ 01101111b = 00101001b
-01000110b ^ 01110000b = 00110110b
-01000110b ^ 01110001b = 00110111b
-01000110b ^ 01110010b = 00110100b
-01000110b ^ 01110011b = 00110101b
-01000110b ^ 01110100b = 00110010b
-01000110b ^ 01110101b = 00110011b
-01000110b ^ 01110110b = 00110000b
-01000110b ^ 01110111b = 00110001b
-01000110b ^ 01111000b = 00111110b
-01000110b ^ 01111001b = 00111111b
-01000110b ^ 01111010b = 00111100b
-01000110b ^ 01111011b = 00111101b
-01000110b ^ 01111100b = 00111010b
-01000110b ^ 01111101b = 00111011b
-01000110b ^ 01111110b = 00111000b
-01000111b ^ 10000000b = 11000111b
-01000111b ^ 10000001b = 11000110b
-01000111b ^ 10000010b = 11000101b
-01000111b ^ 10000011b = 11000100b
-01000111b ^ 10000100b = 11000011b
-01000111b ^ 10000101b = 11000010b
-01000111b ^ 10000110b = 11000001b
-01000111b ^ 10000111b = 11000000b
-01000111b ^ 10001000b = 11001111b
-01000111b ^ 10001001b = 11001110b
-01000111b ^ 10001010b = 11001101b
-01000111b ^ 10001011b = 11001100b
-01000111b ^ 10001100b = 11001011b
-01000111b ^ 10001101b = 11001010b
-01000111b ^ 10001110b = 11001001b
-01000111b ^ 10001111b = 11001000b
-01000111b ^ 10010000b = 11010111b
-01000111b ^ 10010001b = 11010110b
-01000111b ^ 10010010b = 11010101b
-01000111b ^ 10010011b = 11010100b
-01000111b ^ 10010100b = 11010011b
-01000111b ^ 10010101b = 11010010b
-01000111b ^ 10010110b = 11010001b
-01000111b ^ 10010111b = 11010000b
-01000111b ^ 10011000b = 11011111b
-01000111b ^ 10011001b = 11011110b
-01000111b ^ 10011010b = 11011101b
-01000111b ^ 10011011b = 11011100b
-01000111b ^ 10011100b = 11011011b
-01000111b ^ 10011101b = 11011010b
-01000111b ^ 10011110b = 11011001b
-01000111b ^ 10011111b = 11011000b
-01000111b ^ 10100000b = 11100111b
-01000111b ^ 10100001b = 11100110b
-01000111b ^ 10100010b = 11100101b
-01000111b ^ 10100011b = 11100100b
-01000111b ^ 10100100b = 11100011b
-01000111b ^ 10100101b = 11100010b
-01000111b ^ 10100110b = 11100001b
-01000111b ^ 10100111b = 11100000b
-01000111b ^ 10101000b = 11101111b
-01000111b ^ 10101001b = 11101110b
-01000111b ^ 10101010b = 11101101b
-01000111b ^ 10101011b = 11101100b
-01000111b ^ 10101100b = 11101011b
-01000111b ^ 10101101b = 11101010b
-01000111b ^ 10101110b = 11101001b
-01000111b ^ 10101111b = 11101000b
-01000111b ^ 10110000b = 11110111b
-01000111b ^ 10110001b = 11110110b
-01000111b ^ 10110010b = 11110101b
-01000111b ^ 10110011b = 11110100b
-01000111b ^ 10110100b = 11110011b
-01000111b ^ 10110101b = 11110010b
-01000111b ^ 10110110b = 11110001b
-01000111b ^ 10110111b = 11110000b
-01000111b ^ 10111000b = 11111111b
-01000111b ^ 10111001b = 11111110b
-01000111b ^ 10111010b = 11111101b
-01000111b ^ 10111011b = 11111100b
-01000111b ^ 10111100b = 11111011b
-01000111b ^ 10111101b = 11111010b
-01000111b ^ 10111110b = 11111001b
-01000111b ^ 10111111b = 11111000b
-01000111b ^ 11000000b = 10000111b
-01000111b ^ 11000001b = 10000110b
-01000111b ^ 11000010b = 10000101b
-01000111b ^ 11000011b = 10000100b
-01000111b ^ 11000100b = 10000011b
-01000111b ^ 11000101b = 10000010b
-01000111b ^ 11000110b = 10000001b
-01000111b ^ 11000111b = 10000000b
-01000111b ^ 11001000b = 10001111b
-01000111b ^ 11001001b = 10001110b
-01000111b ^ 11001010b = 10001101b
-01000111b ^ 11001011b = 10001100b
-01000111b ^ 11001100b = 10001011b
-01000111b ^ 11001101b = 10001010b
-01000111b ^ 11001110b = 10001001b
-01000111b ^ 11001111b = 10001000b
-01000111b ^ 11010000b = 10010111b
-01000111b ^ 11010001b = 10010110b
-01000111b ^ 11010010b = 10010101b
-01000111b ^ 11010011b = 10010100b
-01000111b ^ 11010100b = 10010011b
-01000111b ^ 11010101b = 10010010b
-01000111b ^ 11010110b = 10010001b
-01000111b ^ 11010111b = 10010000b
-01000111b ^ 11011000b = 10011111b
-01000111b ^ 11011001b = 10011110b
-01000111b ^ 11011010b = 10011101b
-01000111b ^ 11011011b = 10011100b
-01000111b ^ 11011100b = 10011011b
-01000111b ^ 11011101b = 10011010b
-01000111b ^ 11011110b = 10011001b
-01000111b ^ 11011111b = 10011000b
-01000111b ^ 11100000b = 10100111b
-01000111b ^ 11100001b = 10100110b
-01000111b ^ 11100010b = 10100101b
-01000111b ^ 11100011b = 10100100b
-01000111b ^ 11100100b = 10100011b
-01000111b ^ 11100101b = 10100010b
-01000111b ^ 11100110b = 10100001b
-01000111b ^ 11100111b = 10100000b
-01000111b ^ 11101000b = 10101111b
-01000111b ^ 11101001b = 10101110b
-01000111b ^ 11101010b = 10101101b
-01000111b ^ 11101011b = 10101100b
-01000111b ^ 11101100b = 10101011b
-01000111b ^ 11101101b = 10101010b
-01000111b ^ 11101110b = 10101001b
-01000111b ^ 11101111b = 10101000b
-01000111b ^ 11110000b = 10110111b
-01000111b ^ 11110001b = 10110110b
-01000111b ^ 11110010b = 10110101b
-01000111b ^ 11110011b = 10110100b
-01000111b ^ 11110100b = 10110011b
-01000111b ^ 11110101b = 10110010b
-01000111b ^ 11110110b = 10110001b
-01000111b ^ 11110111b = 10110000b
-01000111b ^ 11111000b = 10111111b
-01000111b ^ 11111001b = 10111110b
-01000111b ^ 11111010b = 10111101b
-01000111b ^ 11111011b = 10111100b
-01000111b ^ 11111100b = 10111011b
-01000111b ^ 11111101b = 10111010b
-01000111b ^ 11111110b = 10111001b
-01000111b ^ 11111111b = 10111000b
-01000111b ^ 00000000b = 01000111b
-01000111b ^ 00000001b = 01000110b
-01000111b ^ 00000010b = 01000101b
-01000111b ^ 00000011b = 01000100b
-01000111b ^ 00000100b = 01000011b
-01000111b ^ 00000101b = 01000010b
-01000111b ^ 00000110b = 01000001b
-01000111b ^ 00000111b = 01000000b
-01000111b ^ 00001000b = 01001111b
-01000111b ^ 00001001b = 01001110b
-01000111b ^ 00001010b = 01001101b
-01000111b ^ 00001011b = 01001100b
-01000111b ^ 00001100b = 01001011b
-01000111b ^ 00001101b = 01001010b
-01000111b ^ 00001110b = 01001001b
-01000111b ^ 00001111b = 01001000b
-01000111b ^ 00010000b = 01010111b
-01000111b ^ 00010001b = 01010110b
-01000111b ^ 00010010b = 01010101b
-01000111b ^ 00010011b = 01010100b
-01000111b ^ 00010100b = 01010011b
-01000111b ^ 00010101b = 01010010b
-01000111b ^ 00010110b = 01010001b
-01000111b ^ 00010111b = 01010000b
-01000111b ^ 00011000b = 01011111b
-01000111b ^ 00011001b = 01011110b
-01000111b ^ 00011010b = 01011101b
-01000111b ^ 00011011b = 01011100b
-01000111b ^ 00011100b = 01011011b
-01000111b ^ 00011101b = 01011010b
-01000111b ^ 00011110b = 01011001b
-01000111b ^ 00011111b = 01011000b
-01000111b ^ 00100000b = 01100111b
-01000111b ^ 00100001b = 01100110b
-01000111b ^ 00100010b = 01100101b
-01000111b ^ 00100011b = 01100100b
-01000111b ^ 00100100b = 01100011b
-01000111b ^ 00100101b = 01100010b
-01000111b ^ 00100110b = 01100001b
-01000111b ^ 00100111b = 01100000b
-01000111b ^ 00101000b = 01101111b
-01000111b ^ 00101001b = 01101110b
-01000111b ^ 00101010b = 01101101b
-01000111b ^ 00101011b = 01101100b
-01000111b ^ 00101100b = 01101011b
-01000111b ^ 00101101b = 01101010b
-01000111b ^ 00101110b = 01101001b
-01000111b ^ 00101111b = 01101000b
-01000111b ^ 00110000b = 01110111b
-01000111b ^ 00110001b = 01110110b
-01000111b ^ 00110010b = 01110101b
-01000111b ^ 00110011b = 01110100b
-01000111b ^ 00110100b = 01110011b
-01000111b ^ 00110101b = 01110010b
-01000111b ^ 00110110b = 01110001b
-01000111b ^ 00110111b = 01110000b
-01000111b ^ 00111000b = 01111111b
-01000111b ^ 00111001b = 01111110b
-01000111b ^ 00111010b = 01111101b
-01000111b ^ 00111011b = 01111100b
-01000111b ^ 00111100b = 01111011b
-01000111b ^ 00111101b = 01111010b
-01000111b ^ 00111110b = 01111001b
-01000111b ^ 00111111b = 01111000b
-01000111b ^ 01000000b = 00000111b
-01000111b ^ 01000001b = 00000110b
-01000111b ^ 01000010b = 00000101b
-01000111b ^ 01000011b = 00000100b
-01000111b ^ 01000100b = 00000011b
-01000111b ^ 01000101b = 00000010b
-01000111b ^ 01000110b = 00000001b
-01000111b ^ 01000111b = 00000000b
-01000111b ^ 01001000b = 00001111b
-01000111b ^ 01001001b = 00001110b
-01000111b ^ 01001010b = 00001101b
-01000111b ^ 01001011b = 00001100b
-01000111b ^ 01001100b = 00001011b
-01000111b ^ 01001101b = 00001010b
-01000111b ^ 01001110b = 00001001b
-01000111b ^ 01001111b = 00001000b
-01000111b ^ 01010000b = 00010111b
-01000111b ^ 01010001b = 00010110b
-01000111b ^ 01010010b = 00010101b
-01000111b ^ 01010011b = 00010100b
-01000111b ^ 01010100b = 00010011b
-01000111b ^ 01010101b = 00010010b
-01000111b ^ 01010110b = 00010001b
-01000111b ^ 01010111b = 00010000b
-01000111b ^ 01011000b = 00011111b
-01000111b ^ 01011001b = 00011110b
-01000111b ^ 01011010b = 00011101b
-01000111b ^ 01011011b = 00011100b
-01000111b ^ 01011100b = 00011011b
-01000111b ^ 01011101b = 00011010b
-01000111b ^ 01011110b = 00011001b
-01000111b ^ 01011111b = 00011000b
-01000111b ^ 01100000b = 00100111b
-01000111b ^ 01100001b = 00100110b
-01000111b ^ 01100010b = 00100101b
-01000111b ^ 01100011b = 00100100b
-01000111b ^ 01100100b = 00100011b
-01000111b ^ 01100101b = 00100010b
-01000111b ^ 01100110b = 00100001b
-01000111b ^ 01100111b = 00100000b
-01000111b ^ 01101000b = 00101111b
-01000111b ^ 01101001b = 00101110b
-01000111b ^ 01101010b = 00101101b
-01000111b ^ 01101011b = 00101100b
-01000111b ^ 01101100b = 00101011b
-01000111b ^ 01101101b = 00101010b
-01000111b ^ 01101110b = 00101001b
-01000111b ^ 01101111b = 00101000b
-01000111b ^ 01110000b = 00110111b
-01000111b ^ 01110001b = 00110110b
-01000111b ^ 01110010b = 00110101b
-01000111b ^ 01110011b = 00110100b
-01000111b ^ 01110100b = 00110011b
-01000111b ^ 01110101b = 00110010b
-01000111b ^ 01110110b = 00110001b
-01000111b ^ 01110111b = 00110000b
-01000111b ^ 01111000b = 00111111b
-01000111b ^ 01111001b = 00111110b
-01000111b ^ 01111010b = 00111101b
-01000111b ^ 01111011b = 00111100b
-01000111b ^ 01111100b = 00111011b
-01000111b ^ 01111101b = 00111010b
-01000111b ^ 01111110b = 00111001b
-01001000b ^ 10000000b = 11001000b
-01001000b ^ 10000001b = 11001001b
-01001000b ^ 10000010b = 11001010b
-01001000b ^ 10000011b = 11001011b
-01001000b ^ 10000100b = 11001100b
-01001000b ^ 10000101b = 11001101b
-01001000b ^ 10000110b = 11001110b
-01001000b ^ 10000111b = 11001111b
-01001000b ^ 10001000b = 11000000b
-01001000b ^ 10001001b = 11000001b
-01001000b ^ 10001010b = 11000010b
-01001000b ^ 10001011b = 11000011b
-01001000b ^ 10001100b = 11000100b
-01001000b ^ 10001101b = 11000101b
-01001000b ^ 10001110b = 11000110b
-01001000b ^ 10001111b = 11000111b
-01001000b ^ 10010000b = 11011000b
-01001000b ^ 10010001b = 11011001b
-01001000b ^ 10010010b = 11011010b
-01001000b ^ 10010011b = 11011011b
-01001000b ^ 10010100b = 11011100b
-01001000b ^ 10010101b = 11011101b
-01001000b ^ 10010110b = 11011110b
-01001000b ^ 10010111b = 11011111b
-01001000b ^ 10011000b = 11010000b
-01001000b ^ 10011001b = 11010001b
-01001000b ^ 10011010b = 11010010b
-01001000b ^ 10011011b = 11010011b
-01001000b ^ 10011100b = 11010100b
-01001000b ^ 10011101b = 11010101b
-01001000b ^ 10011110b = 11010110b
-01001000b ^ 10011111b = 11010111b
-01001000b ^ 10100000b = 11101000b
-01001000b ^ 10100001b = 11101001b
-01001000b ^ 10100010b = 11101010b
-01001000b ^ 10100011b = 11101011b
-01001000b ^ 10100100b = 11101100b
-01001000b ^ 10100101b = 11101101b
-01001000b ^ 10100110b = 11101110b
-01001000b ^ 10100111b = 11101111b
-01001000b ^ 10101000b = 11100000b
-01001000b ^ 10101001b = 11100001b
-01001000b ^ 10101010b = 11100010b
-01001000b ^ 10101011b = 11100011b
-01001000b ^ 10101100b = 11100100b
-01001000b ^ 10101101b = 11100101b
-01001000b ^ 10101110b = 11100110b
-01001000b ^ 10101111b = 11100111b
-01001000b ^ 10110000b = 11111000b
-01001000b ^ 10110001b = 11111001b
-01001000b ^ 10110010b = 11111010b
-01001000b ^ 10110011b = 11111011b
-01001000b ^ 10110100b = 11111100b
-01001000b ^ 10110101b = 11111101b
-01001000b ^ 10110110b = 11111110b
-01001000b ^ 10110111b = 11111111b
-01001000b ^ 10111000b = 11110000b
-01001000b ^ 10111001b = 11110001b
-01001000b ^ 10111010b = 11110010b
-01001000b ^ 10111011b = 11110011b
-01001000b ^ 10111100b = 11110100b
-01001000b ^ 10111101b = 11110101b
-01001000b ^ 10111110b = 11110110b
-01001000b ^ 10111111b = 11110111b
-01001000b ^ 11000000b = 10001000b
-01001000b ^ 11000001b = 10001001b
-01001000b ^ 11000010b = 10001010b
-01001000b ^ 11000011b = 10001011b
-01001000b ^ 11000100b = 10001100b
-01001000b ^ 11000101b = 10001101b
-01001000b ^ 11000110b = 10001110b
-01001000b ^ 11000111b = 10001111b
-01001000b ^ 11001000b = 10000000b
-01001000b ^ 11001001b = 10000001b
-01001000b ^ 11001010b = 10000010b
-01001000b ^ 11001011b = 10000011b
-01001000b ^ 11001100b = 10000100b
-01001000b ^ 11001101b = 10000101b
-01001000b ^ 11001110b = 10000110b
-01001000b ^ 11001111b = 10000111b
-01001000b ^ 11010000b = 10011000b
-01001000b ^ 11010001b = 10011001b
-01001000b ^ 11010010b = 10011010b
-01001000b ^ 11010011b = 10011011b
-01001000b ^ 11010100b = 10011100b
-01001000b ^ 11010101b = 10011101b
-01001000b ^ 11010110b = 10011110b
-01001000b ^ 11010111b = 10011111b
-01001000b ^ 11011000b = 10010000b
-01001000b ^ 11011001b = 10010001b
-01001000b ^ 11011010b = 10010010b
-01001000b ^ 11011011b = 10010011b
-01001000b ^ 11011100b = 10010100b
-01001000b ^ 11011101b = 10010101b
-01001000b ^ 11011110b = 10010110b
-01001000b ^ 11011111b = 10010111b
-01001000b ^ 11100000b = 10101000b
-01001000b ^ 11100001b = 10101001b
-01001000b ^ 11100010b = 10101010b
-01001000b ^ 11100011b = 10101011b
-01001000b ^ 11100100b = 10101100b
-01001000b ^ 11100101b = 10101101b
-01001000b ^ 11100110b = 10101110b
-01001000b ^ 11100111b = 10101111b
-01001000b ^ 11101000b = 10100000b
-01001000b ^ 11101001b = 10100001b
-01001000b ^ 11101010b = 10100010b
-01001000b ^ 11101011b = 10100011b
-01001000b ^ 11101100b = 10100100b
-01001000b ^ 11101101b = 10100101b
-01001000b ^ 11101110b = 10100110b
-01001000b ^ 11101111b = 10100111b
-01001000b ^ 11110000b = 10111000b
-01001000b ^ 11110001b = 10111001b
-01001000b ^ 11110010b = 10111010b
-01001000b ^ 11110011b = 10111011b
-01001000b ^ 11110100b = 10111100b
-01001000b ^ 11110101b = 10111101b
-01001000b ^ 11110110b = 10111110b
-01001000b ^ 11110111b = 10111111b
-01001000b ^ 11111000b = 10110000b
-01001000b ^ 11111001b = 10110001b
-01001000b ^ 11111010b = 10110010b
-01001000b ^ 11111011b = 10110011b
-01001000b ^ 11111100b = 10110100b
-01001000b ^ 11111101b = 10110101b
-01001000b ^ 11111110b = 10110110b
-01001000b ^ 11111111b = 10110111b
-01001000b ^ 00000000b = 01001000b
-01001000b ^ 00000001b = 01001001b
-01001000b ^ 00000010b = 01001010b
-01001000b ^ 00000011b = 01001011b
-01001000b ^ 00000100b = 01001100b
-01001000b ^ 00000101b = 01001101b
-01001000b ^ 00000110b = 01001110b
-01001000b ^ 00000111b = 01001111b
-01001000b ^ 00001000b = 01000000b
-01001000b ^ 00001001b = 01000001b
-01001000b ^ 00001010b = 01000010b
-01001000b ^ 00001011b = 01000011b
-01001000b ^ 00001100b = 01000100b
-01001000b ^ 00001101b = 01000101b
-01001000b ^ 00001110b = 01000110b
-01001000b ^ 00001111b = 01000111b
-01001000b ^ 00010000b = 01011000b
-01001000b ^ 00010001b = 01011001b
-01001000b ^ 00010010b = 01011010b
-01001000b ^ 00010011b = 01011011b
-01001000b ^ 00010100b = 01011100b
-01001000b ^ 00010101b = 01011101b
-01001000b ^ 00010110b = 01011110b
-01001000b ^ 00010111b = 01011111b
-01001000b ^ 00011000b = 01010000b
-01001000b ^ 00011001b = 01010001b
-01001000b ^ 00011010b = 01010010b
-01001000b ^ 00011011b = 01010011b
-01001000b ^ 00011100b = 01010100b
-01001000b ^ 00011101b = 01010101b
-01001000b ^ 00011110b = 01010110b
-01001000b ^ 00011111b = 01010111b
-01001000b ^ 00100000b = 01101000b
-01001000b ^ 00100001b = 01101001b
-01001000b ^ 00100010b = 01101010b
-01001000b ^ 00100011b = 01101011b
-01001000b ^ 00100100b = 01101100b
-01001000b ^ 00100101b = 01101101b
-01001000b ^ 00100110b = 01101110b
-01001000b ^ 00100111b = 01101111b
-01001000b ^ 00101000b = 01100000b
-01001000b ^ 00101001b = 01100001b
-01001000b ^ 00101010b = 01100010b
-01001000b ^ 00101011b = 01100011b
-01001000b ^ 00101100b = 01100100b
-01001000b ^ 00101101b = 01100101b
-01001000b ^ 00101110b = 01100110b
-01001000b ^ 00101111b = 01100111b
-01001000b ^ 00110000b = 01111000b
-01001000b ^ 00110001b = 01111001b
-01001000b ^ 00110010b = 01111010b
-01001000b ^ 00110011b = 01111011b
-01001000b ^ 00110100b = 01111100b
-01001000b ^ 00110101b = 01111101b
-01001000b ^ 00110110b = 01111110b
-01001000b ^ 00110111b = 01111111b
-01001000b ^ 00111000b = 01110000b
-01001000b ^ 00111001b = 01110001b
-01001000b ^ 00111010b = 01110010b
-01001000b ^ 00111011b = 01110011b
-01001000b ^ 00111100b = 01110100b
-01001000b ^ 00111101b = 01110101b
-01001000b ^ 00111110b = 01110110b
-01001000b ^ 00111111b = 01110111b
-01001000b ^ 01000000b = 00001000b
-01001000b ^ 01000001b = 00001001b
-01001000b ^ 01000010b = 00001010b
-01001000b ^ 01000011b = 00001011b
-01001000b ^ 01000100b = 00001100b
-01001000b ^ 01000101b = 00001101b
-01001000b ^ 01000110b = 00001110b
-01001000b ^ 01000111b = 00001111b
-01001000b ^ 01001000b = 00000000b
-01001000b ^ 01001001b = 00000001b
-01001000b ^ 01001010b = 00000010b
-01001000b ^ 01001011b = 00000011b
-01001000b ^ 01001100b = 00000100b
-01001000b ^ 01001101b = 00000101b
-01001000b ^ 01001110b = 00000110b
-01001000b ^ 01001111b = 00000111b
-01001000b ^ 01010000b = 00011000b
-01001000b ^ 01010001b = 00011001b
-01001000b ^ 01010010b = 00011010b
-01001000b ^ 01010011b = 00011011b
-01001000b ^ 01010100b = 00011100b
-01001000b ^ 01010101b = 00011101b
-01001000b ^ 01010110b = 00011110b
-01001000b ^ 01010111b = 00011111b
-01001000b ^ 01011000b = 00010000b
-01001000b ^ 01011001b = 00010001b
-01001000b ^ 01011010b = 00010010b
-01001000b ^ 01011011b = 00010011b
-01001000b ^ 01011100b = 00010100b
-01001000b ^ 01011101b = 00010101b
-01001000b ^ 01011110b = 00010110b
-01001000b ^ 01011111b = 00010111b
-01001000b ^ 01100000b = 00101000b
-01001000b ^ 01100001b = 00101001b
-01001000b ^ 01100010b = 00101010b
-01001000b ^ 01100011b = 00101011b
-01001000b ^ 01100100b = 00101100b
-01001000b ^ 01100101b = 00101101b
-01001000b ^ 01100110b = 00101110b
-01001000b ^ 01100111b = 00101111b
-01001000b ^ 01101000b = 00100000b
-01001000b ^ 01101001b = 00100001b
-01001000b ^ 01101010b = 00100010b
-01001000b ^ 01101011b = 00100011b
-01001000b ^ 01101100b = 00100100b
-01001000b ^ 01101101b = 00100101b
-01001000b ^ 01101110b = 00100110b
-01001000b ^ 01101111b = 00100111b
-01001000b ^ 01110000b = 00111000b
-01001000b ^ 01110001b = 00111001b
-01001000b ^ 01110010b = 00111010b
-01001000b ^ 01110011b = 00111011b
-01001000b ^ 01110100b = 00111100b
-01001000b ^ 01110101b = 00111101b
-01001000b ^ 01110110b = 00111110b
-01001000b ^ 01110111b = 00111111b
-01001000b ^ 01111000b = 00110000b
-01001000b ^ 01111001b = 00110001b
-01001000b ^ 01111010b = 00110010b
-01001000b ^ 01111011b = 00110011b
-01001000b ^ 01111100b = 00110100b
-01001000b ^ 01111101b = 00110101b
-01001000b ^ 01111110b = 00110110b
-01001001b ^ 10000000b = 11001001b
-01001001b ^ 10000001b = 11001000b
-01001001b ^ 10000010b = 11001011b
-01001001b ^ 10000011b = 11001010b
-01001001b ^ 10000100b = 11001101b
-01001001b ^ 10000101b = 11001100b
-01001001b ^ 10000110b = 11001111b
-01001001b ^ 10000111b = 11001110b
-01001001b ^ 10001000b = 11000001b
-01001001b ^ 10001001b = 11000000b
-01001001b ^ 10001010b = 11000011b
-01001001b ^ 10001011b = 11000010b
-01001001b ^ 10001100b = 11000101b
-01001001b ^ 10001101b = 11000100b
-01001001b ^ 10001110b = 11000111b
-01001001b ^ 10001111b = 11000110b
-01001001b ^ 10010000b = 11011001b
-01001001b ^ 10010001b = 11011000b
-01001001b ^ 10010010b = 11011011b
-01001001b ^ 10010011b = 11011010b
-01001001b ^ 10010100b = 11011101b
-01001001b ^ 10010101b = 11011100b
-01001001b ^ 10010110b = 11011111b
-01001001b ^ 10010111b = 11011110b
-01001001b ^ 10011000b = 11010001b
-01001001b ^ 10011001b = 11010000b
-01001001b ^ 10011010b = 11010011b
-01001001b ^ 10011011b = 11010010b
-01001001b ^ 10011100b = 11010101b
-01001001b ^ 10011101b = 11010100b
-01001001b ^ 10011110b = 11010111b
-01001001b ^ 10011111b = 11010110b
-01001001b ^ 10100000b = 11101001b
-01001001b ^ 10100001b = 11101000b
-01001001b ^ 10100010b = 11101011b
-01001001b ^ 10100011b = 11101010b
-01001001b ^ 10100100b = 11101101b
-01001001b ^ 10100101b = 11101100b
-01001001b ^ 10100110b = 11101111b
-01001001b ^ 10100111b = 11101110b
-01001001b ^ 10101000b = 11100001b
-01001001b ^ 10101001b = 11100000b
-01001001b ^ 10101010b = 11100011b
-01001001b ^ 10101011b = 11100010b
-01001001b ^ 10101100b = 11100101b
-01001001b ^ 10101101b = 11100100b
-01001001b ^ 10101110b = 11100111b
-01001001b ^ 10101111b = 11100110b
-01001001b ^ 10110000b = 11111001b
-01001001b ^ 10110001b = 11111000b
-01001001b ^ 10110010b = 11111011b
-01001001b ^ 10110011b = 11111010b
-01001001b ^ 10110100b = 11111101b
-01001001b ^ 10110101b = 11111100b
-01001001b ^ 10110110b = 11111111b
-01001001b ^ 10110111b = 11111110b
-01001001b ^ 10111000b = 11110001b
-01001001b ^ 10111001b = 11110000b
-01001001b ^ 10111010b = 11110011b
-01001001b ^ 10111011b = 11110010b
-01001001b ^ 10111100b = 11110101b
-01001001b ^ 10111101b = 11110100b
-01001001b ^ 10111110b = 11110111b
-01001001b ^ 10111111b = 11110110b
-01001001b ^ 11000000b = 10001001b
-01001001b ^ 11000001b = 10001000b
-01001001b ^ 11000010b = 10001011b
-01001001b ^ 11000011b = 10001010b
-01001001b ^ 11000100b = 10001101b
-01001001b ^ 11000101b = 10001100b
-01001001b ^ 11000110b = 10001111b
-01001001b ^ 11000111b = 10001110b
-01001001b ^ 11001000b = 10000001b
-01001001b ^ 11001001b = 10000000b
-01001001b ^ 11001010b = 10000011b
-01001001b ^ 11001011b = 10000010b
-01001001b ^ 11001100b = 10000101b
-01001001b ^ 11001101b = 10000100b
-01001001b ^ 11001110b = 10000111b
-01001001b ^ 11001111b = 10000110b
-01001001b ^ 11010000b = 10011001b
-01001001b ^ 11010001b = 10011000b
-01001001b ^ 11010010b = 10011011b
-01001001b ^ 11010011b = 10011010b
-01001001b ^ 11010100b = 10011101b
-01001001b ^ 11010101b = 10011100b
-01001001b ^ 11010110b = 10011111b
-01001001b ^ 11010111b = 10011110b
-01001001b ^ 11011000b = 10010001b
-01001001b ^ 11011001b = 10010000b
-01001001b ^ 11011010b = 10010011b
-01001001b ^ 11011011b = 10010010b
-01001001b ^ 11011100b = 10010101b
-01001001b ^ 11011101b = 10010100b
-01001001b ^ 11011110b = 10010111b
-01001001b ^ 11011111b = 10010110b
-01001001b ^ 11100000b = 10101001b
-01001001b ^ 11100001b = 10101000b
-01001001b ^ 11100010b = 10101011b
-01001001b ^ 11100011b = 10101010b
-01001001b ^ 11100100b = 10101101b
-01001001b ^ 11100101b = 10101100b
-01001001b ^ 11100110b = 10101111b
-01001001b ^ 11100111b = 10101110b
-01001001b ^ 11101000b = 10100001b
-01001001b ^ 11101001b = 10100000b
-01001001b ^ 11101010b = 10100011b
-01001001b ^ 11101011b = 10100010b
-01001001b ^ 11101100b = 10100101b
-01001001b ^ 11101101b = 10100100b
-01001001b ^ 11101110b = 10100111b
-01001001b ^ 11101111b = 10100110b
-01001001b ^ 11110000b = 10111001b
-01001001b ^ 11110001b = 10111000b
-01001001b ^ 11110010b = 10111011b
-01001001b ^ 11110011b = 10111010b
-01001001b ^ 11110100b = 10111101b
-01001001b ^ 11110101b = 10111100b
-01001001b ^ 11110110b = 10111111b
-01001001b ^ 11110111b = 10111110b
-01001001b ^ 11111000b = 10110001b
-01001001b ^ 11111001b = 10110000b
-01001001b ^ 11111010b = 10110011b
-01001001b ^ 11111011b = 10110010b
-01001001b ^ 11111100b = 10110101b
-01001001b ^ 11111101b = 10110100b
-01001001b ^ 11111110b = 10110111b
-01001001b ^ 11111111b = 10110110b
-01001001b ^ 00000000b = 01001001b
-01001001b ^ 00000001b = 01001000b
-01001001b ^ 00000010b = 01001011b
-01001001b ^ 00000011b = 01001010b
-01001001b ^ 00000100b = 01001101b
-01001001b ^ 00000101b = 01001100b
-01001001b ^ 00000110b = 01001111b
-01001001b ^ 00000111b = 01001110b
-01001001b ^ 00001000b = 01000001b
-01001001b ^ 00001001b = 01000000b
-01001001b ^ 00001010b = 01000011b
-01001001b ^ 00001011b = 01000010b
-01001001b ^ 00001100b = 01000101b
-01001001b ^ 00001101b = 01000100b
-01001001b ^ 00001110b = 01000111b
-01001001b ^ 00001111b = 01000110b
-01001001b ^ 00010000b = 01011001b
-01001001b ^ 00010001b = 01011000b
-01001001b ^ 00010010b = 01011011b
-01001001b ^ 00010011b = 01011010b
-01001001b ^ 00010100b = 01011101b
-01001001b ^ 00010101b = 01011100b
-01001001b ^ 00010110b = 01011111b
-01001001b ^ 00010111b = 01011110b
-01001001b ^ 00011000b = 01010001b
-01001001b ^ 00011001b = 01010000b
-01001001b ^ 00011010b = 01010011b
-01001001b ^ 00011011b = 01010010b
-01001001b ^ 00011100b = 01010101b
-01001001b ^ 00011101b = 01010100b
-01001001b ^ 00011110b = 01010111b
-01001001b ^ 00011111b = 01010110b
-01001001b ^ 00100000b = 01101001b
-01001001b ^ 00100001b = 01101000b
-01001001b ^ 00100010b = 01101011b
-01001001b ^ 00100011b = 01101010b
-01001001b ^ 00100100b = 01101101b
-01001001b ^ 00100101b = 01101100b
-01001001b ^ 00100110b = 01101111b
-01001001b ^ 00100111b = 01101110b
-01001001b ^ 00101000b = 01100001b
-01001001b ^ 00101001b = 01100000b
-01001001b ^ 00101010b = 01100011b
-01001001b ^ 00101011b = 01100010b
-01001001b ^ 00101100b = 01100101b
-01001001b ^ 00101101b = 01100100b
-01001001b ^ 00101110b = 01100111b
-01001001b ^ 00101111b = 01100110b
-01001001b ^ 00110000b = 01111001b
-01001001b ^ 00110001b = 01111000b
-01001001b ^ 00110010b = 01111011b
-01001001b ^ 00110011b = 01111010b
-01001001b ^ 00110100b = 01111101b
-01001001b ^ 00110101b = 01111100b
-01001001b ^ 00110110b = 01111111b
-01001001b ^ 00110111b = 01111110b
-01001001b ^ 00111000b = 01110001b
-01001001b ^ 00111001b = 01110000b
-01001001b ^ 00111010b = 01110011b
-01001001b ^ 00111011b = 01110010b
-01001001b ^ 00111100b = 01110101b
-01001001b ^ 00111101b = 01110100b
-01001001b ^ 00111110b = 01110111b
-01001001b ^ 00111111b = 01110110b
-01001001b ^ 01000000b = 00001001b
-01001001b ^ 01000001b = 00001000b
-01001001b ^ 01000010b = 00001011b
-01001001b ^ 01000011b = 00001010b
-01001001b ^ 01000100b = 00001101b
-01001001b ^ 01000101b = 00001100b
-01001001b ^ 01000110b = 00001111b
-01001001b ^ 01000111b = 00001110b
-01001001b ^ 01001000b = 00000001b
-01001001b ^ 01001001b = 00000000b
-01001001b ^ 01001010b = 00000011b
-01001001b ^ 01001011b = 00000010b
-01001001b ^ 01001100b = 00000101b
-01001001b ^ 01001101b = 00000100b
-01001001b ^ 01001110b = 00000111b
-01001001b ^ 01001111b = 00000110b
-01001001b ^ 01010000b = 00011001b
-01001001b ^ 01010001b = 00011000b
-01001001b ^ 01010010b = 00011011b
-01001001b ^ 01010011b = 00011010b
-01001001b ^ 01010100b = 00011101b
-01001001b ^ 01010101b = 00011100b
-01001001b ^ 01010110b = 00011111b
-01001001b ^ 01010111b = 00011110b
-01001001b ^ 01011000b = 00010001b
-01001001b ^ 01011001b = 00010000b
-01001001b ^ 01011010b = 00010011b
-01001001b ^ 01011011b = 00010010b
-01001001b ^ 01011100b = 00010101b
-01001001b ^ 01011101b = 00010100b
-01001001b ^ 01011110b = 00010111b
-01001001b ^ 01011111b = 00010110b
-01001001b ^ 01100000b = 00101001b
-01001001b ^ 01100001b = 00101000b
-01001001b ^ 01100010b = 00101011b
-01001001b ^ 01100011b = 00101010b
-01001001b ^ 01100100b = 00101101b
-01001001b ^ 01100101b = 00101100b
-01001001b ^ 01100110b = 00101111b
-01001001b ^ 01100111b = 00101110b
-01001001b ^ 01101000b = 00100001b
-01001001b ^ 01101001b = 00100000b
-01001001b ^ 01101010b = 00100011b
-01001001b ^ 01101011b = 00100010b
-01001001b ^ 01101100b = 00100101b
-01001001b ^ 01101101b = 00100100b
-01001001b ^ 01101110b = 00100111b
-01001001b ^ 01101111b = 00100110b
-01001001b ^ 01110000b = 00111001b
-01001001b ^ 01110001b = 00111000b
-01001001b ^ 01110010b = 00111011b
-01001001b ^ 01110011b = 00111010b
-01001001b ^ 01110100b = 00111101b
-01001001b ^ 01110101b = 00111100b
-01001001b ^ 01110110b = 00111111b
-01001001b ^ 01110111b = 00111110b
-01001001b ^ 01111000b = 00110001b
-01001001b ^ 01111001b = 00110000b
-01001001b ^ 01111010b = 00110011b
-01001001b ^ 01111011b = 00110010b
-01001001b ^ 01111100b = 00110101b
-01001001b ^ 01111101b = 00110100b
-01001001b ^ 01111110b = 00110111b
-01001010b ^ 10000000b = 11001010b
-01001010b ^ 10000001b = 11001011b
-01001010b ^ 10000010b = 11001000b
-01001010b ^ 10000011b = 11001001b
-01001010b ^ 10000100b = 11001110b
-01001010b ^ 10000101b = 11001111b
-01001010b ^ 10000110b = 11001100b
-01001010b ^ 10000111b = 11001101b
-01001010b ^ 10001000b = 11000010b
-01001010b ^ 10001001b = 11000011b
-01001010b ^ 10001010b = 11000000b
-01001010b ^ 10001011b = 11000001b
-01001010b ^ 10001100b = 11000110b
-01001010b ^ 10001101b = 11000111b
-01001010b ^ 10001110b = 11000100b
-01001010b ^ 10001111b = 11000101b
-01001010b ^ 10010000b = 11011010b
-01001010b ^ 10010001b = 11011011b
-01001010b ^ 10010010b = 11011000b
-01001010b ^ 10010011b = 11011001b
-01001010b ^ 10010100b = 11011110b
-01001010b ^ 10010101b = 11011111b
-01001010b ^ 10010110b = 11011100b
-01001010b ^ 10010111b = 11011101b
-01001010b ^ 10011000b = 11010010b
-01001010b ^ 10011001b = 11010011b
-01001010b ^ 10011010b = 11010000b
-01001010b ^ 10011011b = 11010001b
-01001010b ^ 10011100b = 11010110b
-01001010b ^ 10011101b = 11010111b
-01001010b ^ 10011110b = 11010100b
-01001010b ^ 10011111b = 11010101b
-01001010b ^ 10100000b = 11101010b
-01001010b ^ 10100001b = 11101011b
-01001010b ^ 10100010b = 11101000b
-01001010b ^ 10100011b = 11101001b
-01001010b ^ 10100100b = 11101110b
-01001010b ^ 10100101b = 11101111b
-01001010b ^ 10100110b = 11101100b
-01001010b ^ 10100111b = 11101101b
-01001010b ^ 10101000b = 11100010b
-01001010b ^ 10101001b = 11100011b
-01001010b ^ 10101010b = 11100000b
-01001010b ^ 10101011b = 11100001b
-01001010b ^ 10101100b = 11100110b
-01001010b ^ 10101101b = 11100111b
-01001010b ^ 10101110b = 11100100b
-01001010b ^ 10101111b = 11100101b
-01001010b ^ 10110000b = 11111010b
-01001010b ^ 10110001b = 11111011b
-01001010b ^ 10110010b = 11111000b
-01001010b ^ 10110011b = 11111001b
-01001010b ^ 10110100b = 11111110b
-01001010b ^ 10110101b = 11111111b
-01001010b ^ 10110110b = 11111100b
-01001010b ^ 10110111b = 11111101b
-01001010b ^ 10111000b = 11110010b
-01001010b ^ 10111001b = 11110011b
-01001010b ^ 10111010b = 11110000b
-01001010b ^ 10111011b = 11110001b
-01001010b ^ 10111100b = 11110110b
-01001010b ^ 10111101b = 11110111b
-01001010b ^ 10111110b = 11110100b
-01001010b ^ 10111111b = 11110101b
-01001010b ^ 11000000b = 10001010b
-01001010b ^ 11000001b = 10001011b
-01001010b ^ 11000010b = 10001000b
-01001010b ^ 11000011b = 10001001b
-01001010b ^ 11000100b = 10001110b
-01001010b ^ 11000101b = 10001111b
-01001010b ^ 11000110b = 10001100b
-01001010b ^ 11000111b = 10001101b
-01001010b ^ 11001000b = 10000010b
-01001010b ^ 11001001b = 10000011b
-01001010b ^ 11001010b = 10000000b
-01001010b ^ 11001011b = 10000001b
-01001010b ^ 11001100b = 10000110b
-01001010b ^ 11001101b = 10000111b
-01001010b ^ 11001110b = 10000100b
-01001010b ^ 11001111b = 10000101b
-01001010b ^ 11010000b = 10011010b
-01001010b ^ 11010001b = 10011011b
-01001010b ^ 11010010b = 10011000b
-01001010b ^ 11010011b = 10011001b
-01001010b ^ 11010100b = 10011110b
-01001010b ^ 11010101b = 10011111b
-01001010b ^ 11010110b = 10011100b
-01001010b ^ 11010111b = 10011101b
-01001010b ^ 11011000b = 10010010b
-01001010b ^ 11011001b = 10010011b
-01001010b ^ 11011010b = 10010000b
-01001010b ^ 11011011b = 10010001b
-01001010b ^ 11011100b = 10010110b
-01001010b ^ 11011101b = 10010111b
-01001010b ^ 11011110b = 10010100b
-01001010b ^ 11011111b = 10010101b
-01001010b ^ 11100000b = 10101010b
-01001010b ^ 11100001b = 10101011b
-01001010b ^ 11100010b = 10101000b
-01001010b ^ 11100011b = 10101001b
-01001010b ^ 11100100b = 10101110b
-01001010b ^ 11100101b = 10101111b
-01001010b ^ 11100110b = 10101100b
-01001010b ^ 11100111b = 10101101b
-01001010b ^ 11101000b = 10100010b
-01001010b ^ 11101001b = 10100011b
-01001010b ^ 11101010b = 10100000b
-01001010b ^ 11101011b = 10100001b
-01001010b ^ 11101100b = 10100110b
-01001010b ^ 11101101b = 10100111b
-01001010b ^ 11101110b = 10100100b
-01001010b ^ 11101111b = 10100101b
-01001010b ^ 11110000b = 10111010b
-01001010b ^ 11110001b = 10111011b
-01001010b ^ 11110010b = 10111000b
-01001010b ^ 11110011b = 10111001b
-01001010b ^ 11110100b = 10111110b
-01001010b ^ 11110101b = 10111111b
-01001010b ^ 11110110b = 10111100b
-01001010b ^ 11110111b = 10111101b
-01001010b ^ 11111000b = 10110010b
-01001010b ^ 11111001b = 10110011b
-01001010b ^ 11111010b = 10110000b
-01001010b ^ 11111011b = 10110001b
-01001010b ^ 11111100b = 10110110b
-01001010b ^ 11111101b = 10110111b
-01001010b ^ 11111110b = 10110100b
-01001010b ^ 11111111b = 10110101b
-01001010b ^ 00000000b = 01001010b
-01001010b ^ 00000001b = 01001011b
-01001010b ^ 00000010b = 01001000b
-01001010b ^ 00000011b = 01001001b
-01001010b ^ 00000100b = 01001110b
-01001010b ^ 00000101b = 01001111b
-01001010b ^ 00000110b = 01001100b
-01001010b ^ 00000111b = 01001101b
-01001010b ^ 00001000b = 01000010b
-01001010b ^ 00001001b = 01000011b
-01001010b ^ 00001010b = 01000000b
-01001010b ^ 00001011b = 01000001b
-01001010b ^ 00001100b = 01000110b
-01001010b ^ 00001101b = 01000111b
-01001010b ^ 00001110b = 01000100b
-01001010b ^ 00001111b = 01000101b
-01001010b ^ 00010000b = 01011010b
-01001010b ^ 00010001b = 01011011b
-01001010b ^ 00010010b = 01011000b
-01001010b ^ 00010011b = 01011001b
-01001010b ^ 00010100b = 01011110b
-01001010b ^ 00010101b = 01011111b
-01001010b ^ 00010110b = 01011100b
-01001010b ^ 00010111b = 01011101b
-01001010b ^ 00011000b = 01010010b
-01001010b ^ 00011001b = 01010011b
-01001010b ^ 00011010b = 01010000b
-01001010b ^ 00011011b = 01010001b
-01001010b ^ 00011100b = 01010110b
-01001010b ^ 00011101b = 01010111b
-01001010b ^ 00011110b = 01010100b
-01001010b ^ 00011111b = 01010101b
-01001010b ^ 00100000b = 01101010b
-01001010b ^ 00100001b = 01101011b
-01001010b ^ 00100010b = 01101000b
-01001010b ^ 00100011b = 01101001b
-01001010b ^ 00100100b = 01101110b
-01001010b ^ 00100101b = 01101111b
-01001010b ^ 00100110b = 01101100b
-01001010b ^ 00100111b = 01101101b
-01001010b ^ 00101000b = 01100010b
-01001010b ^ 00101001b = 01100011b
-01001010b ^ 00101010b = 01100000b
-01001010b ^ 00101011b = 01100001b
-01001010b ^ 00101100b = 01100110b
-01001010b ^ 00101101b = 01100111b
-01001010b ^ 00101110b = 01100100b
-01001010b ^ 00101111b = 01100101b
-01001010b ^ 00110000b = 01111010b
-01001010b ^ 00110001b = 01111011b
-01001010b ^ 00110010b = 01111000b
-01001010b ^ 00110011b = 01111001b
-01001010b ^ 00110100b = 01111110b
-01001010b ^ 00110101b = 01111111b
-01001010b ^ 00110110b = 01111100b
-01001010b ^ 00110111b = 01111101b
-01001010b ^ 00111000b = 01110010b
-01001010b ^ 00111001b = 01110011b
-01001010b ^ 00111010b = 01110000b
-01001010b ^ 00111011b = 01110001b
-01001010b ^ 00111100b = 01110110b
-01001010b ^ 00111101b = 01110111b
-01001010b ^ 00111110b = 01110100b
-01001010b ^ 00111111b = 01110101b
-01001010b ^ 01000000b = 00001010b
-01001010b ^ 01000001b = 00001011b
-01001010b ^ 01000010b = 00001000b
-01001010b ^ 01000011b = 00001001b
-01001010b ^ 01000100b = 00001110b
-01001010b ^ 01000101b = 00001111b
-01001010b ^ 01000110b = 00001100b
-01001010b ^ 01000111b = 00001101b
-01001010b ^ 01001000b = 00000010b
-01001010b ^ 01001001b = 00000011b
-01001010b ^ 01001010b = 00000000b
-01001010b ^ 01001011b = 00000001b
-01001010b ^ 01001100b = 00000110b
-01001010b ^ 01001101b = 00000111b
-01001010b ^ 01001110b = 00000100b
-01001010b ^ 01001111b = 00000101b
-01001010b ^ 01010000b = 00011010b
-01001010b ^ 01010001b = 00011011b
-01001010b ^ 01010010b = 00011000b
-01001010b ^ 01010011b = 00011001b
-01001010b ^ 01010100b = 00011110b
-01001010b ^ 01010101b = 00011111b
-01001010b ^ 01010110b = 00011100b
-01001010b ^ 01010111b = 00011101b
-01001010b ^ 01011000b = 00010010b
-01001010b ^ 01011001b = 00010011b
-01001010b ^ 01011010b = 00010000b
-01001010b ^ 01011011b = 00010001b
-01001010b ^ 01011100b = 00010110b
-01001010b ^ 01011101b = 00010111b
-01001010b ^ 01011110b = 00010100b
-01001010b ^ 01011111b = 00010101b
-01001010b ^ 01100000b = 00101010b
-01001010b ^ 01100001b = 00101011b
-01001010b ^ 01100010b = 00101000b
-01001010b ^ 01100011b = 00101001b
-01001010b ^ 01100100b = 00101110b
-01001010b ^ 01100101b = 00101111b
-01001010b ^ 01100110b = 00101100b
-01001010b ^ 01100111b = 00101101b
-01001010b ^ 01101000b = 00100010b
-01001010b ^ 01101001b = 00100011b
-01001010b ^ 01101010b = 00100000b
-01001010b ^ 01101011b = 00100001b
-01001010b ^ 01101100b = 00100110b
-01001010b ^ 01101101b = 00100111b
-01001010b ^ 01101110b = 00100100b
-01001010b ^ 01101111b = 00100101b
-01001010b ^ 01110000b = 00111010b
-01001010b ^ 01110001b = 00111011b
-01001010b ^ 01110010b = 00111000b
-01001010b ^ 01110011b = 00111001b
-01001010b ^ 01110100b = 00111110b
-01001010b ^ 01110101b = 00111111b
-01001010b ^ 01110110b = 00111100b
-01001010b ^ 01110111b = 00111101b
-01001010b ^ 01111000b = 00110010b
-01001010b ^ 01111001b = 00110011b
-01001010b ^ 01111010b = 00110000b
-01001010b ^ 01111011b = 00110001b
-01001010b ^ 01111100b = 00110110b
-01001010b ^ 01111101b = 00110111b
-01001010b ^ 01111110b = 00110100b
-01001011b ^ 10000000b = 11001011b
-01001011b ^ 10000001b = 11001010b
-01001011b ^ 10000010b = 11001001b
-01001011b ^ 10000011b = 11001000b
-01001011b ^ 10000100b = 11001111b
-01001011b ^ 10000101b = 11001110b
-01001011b ^ 10000110b = 11001101b
-01001011b ^ 10000111b = 11001100b
-01001011b ^ 10001000b = 11000011b
-01001011b ^ 10001001b = 11000010b
-01001011b ^ 10001010b = 11000001b
-01001011b ^ 10001011b = 11000000b
-01001011b ^ 10001100b = 11000111b
-01001011b ^ 10001101b = 11000110b
-01001011b ^ 10001110b = 11000101b
-01001011b ^ 10001111b = 11000100b
-01001011b ^ 10010000b = 11011011b
-01001011b ^ 10010001b = 11011010b
-01001011b ^ 10010010b = 11011001b
-01001011b ^ 10010011b = 11011000b
-01001011b ^ 10010100b = 11011111b
-01001011b ^ 10010101b = 11011110b
-01001011b ^ 10010110b = 11011101b
-01001011b ^ 10010111b = 11011100b
-01001011b ^ 10011000b = 11010011b
-01001011b ^ 10011001b = 11010010b
-01001011b ^ 10011010b = 11010001b
-01001011b ^ 10011011b = 11010000b
-01001011b ^ 10011100b = 11010111b
-01001011b ^ 10011101b = 11010110b
-01001011b ^ 10011110b = 11010101b
-01001011b ^ 10011111b = 11010100b
-01001011b ^ 10100000b = 11101011b
-01001011b ^ 10100001b = 11101010b
-01001011b ^ 10100010b = 11101001b
-01001011b ^ 10100011b = 11101000b
-01001011b ^ 10100100b = 11101111b
-01001011b ^ 10100101b = 11101110b
-01001011b ^ 10100110b = 11101101b
-01001011b ^ 10100111b = 11101100b
-01001011b ^ 10101000b = 11100011b
-01001011b ^ 10101001b = 11100010b
-01001011b ^ 10101010b = 11100001b
-01001011b ^ 10101011b = 11100000b
-01001011b ^ 10101100b = 11100111b
-01001011b ^ 10101101b = 11100110b
-01001011b ^ 10101110b = 11100101b
-01001011b ^ 10101111b = 11100100b
-01001011b ^ 10110000b = 11111011b
-01001011b ^ 10110001b = 11111010b
-01001011b ^ 10110010b = 11111001b
-01001011b ^ 10110011b = 11111000b
-01001011b ^ 10110100b = 11111111b
-01001011b ^ 10110101b = 11111110b
-01001011b ^ 10110110b = 11111101b
-01001011b ^ 10110111b = 11111100b
-01001011b ^ 10111000b = 11110011b
-01001011b ^ 10111001b = 11110010b
-01001011b ^ 10111010b = 11110001b
-01001011b ^ 10111011b = 11110000b
-01001011b ^ 10111100b = 11110111b
-01001011b ^ 10111101b = 11110110b
-01001011b ^ 10111110b = 11110101b
-01001011b ^ 10111111b = 11110100b
-01001011b ^ 11000000b = 10001011b
-01001011b ^ 11000001b = 10001010b
-01001011b ^ 11000010b = 10001001b
-01001011b ^ 11000011b = 10001000b
-01001011b ^ 11000100b = 10001111b
-01001011b ^ 11000101b = 10001110b
-01001011b ^ 11000110b = 10001101b
-01001011b ^ 11000111b = 10001100b
-01001011b ^ 11001000b = 10000011b
-01001011b ^ 11001001b = 10000010b
-01001011b ^ 11001010b = 10000001b
-01001011b ^ 11001011b = 10000000b
-01001011b ^ 11001100b = 10000111b
-01001011b ^ 11001101b = 10000110b
-01001011b ^ 11001110b = 10000101b
-01001011b ^ 11001111b = 10000100b
-01001011b ^ 11010000b = 10011011b
-01001011b ^ 11010001b = 10011010b
-01001011b ^ 11010010b = 10011001b
-01001011b ^ 11010011b = 10011000b
-01001011b ^ 11010100b = 10011111b
-01001011b ^ 11010101b = 10011110b
-01001011b ^ 11010110b = 10011101b
-01001011b ^ 11010111b = 10011100b
-01001011b ^ 11011000b = 10010011b
-01001011b ^ 11011001b = 10010010b
-01001011b ^ 11011010b = 10010001b
-01001011b ^ 11011011b = 10010000b
-01001011b ^ 11011100b = 10010111b
-01001011b ^ 11011101b = 10010110b
-01001011b ^ 11011110b = 10010101b
-01001011b ^ 11011111b = 10010100b
-01001011b ^ 11100000b = 10101011b
-01001011b ^ 11100001b = 10101010b
-01001011b ^ 11100010b = 10101001b
-01001011b ^ 11100011b = 10101000b
-01001011b ^ 11100100b = 10101111b
-01001011b ^ 11100101b = 10101110b
-01001011b ^ 11100110b = 10101101b
-01001011b ^ 11100111b = 10101100b
-01001011b ^ 11101000b = 10100011b
-01001011b ^ 11101001b = 10100010b
-01001011b ^ 11101010b = 10100001b
-01001011b ^ 11101011b = 10100000b
-01001011b ^ 11101100b = 10100111b
-01001011b ^ 11101101b = 10100110b
-01001011b ^ 11101110b = 10100101b
-01001011b ^ 11101111b = 10100100b
-01001011b ^ 11110000b = 10111011b
-01001011b ^ 11110001b = 10111010b
-01001011b ^ 11110010b = 10111001b
-01001011b ^ 11110011b = 10111000b
-01001011b ^ 11110100b = 10111111b
-01001011b ^ 11110101b = 10111110b
-01001011b ^ 11110110b = 10111101b
-01001011b ^ 11110111b = 10111100b
-01001011b ^ 11111000b = 10110011b
-01001011b ^ 11111001b = 10110010b
-01001011b ^ 11111010b = 10110001b
-01001011b ^ 11111011b = 10110000b
-01001011b ^ 11111100b = 10110111b
-01001011b ^ 11111101b = 10110110b
-01001011b ^ 11111110b = 10110101b
-01001011b ^ 11111111b = 10110100b
-01001011b ^ 00000000b = 01001011b
-01001011b ^ 00000001b = 01001010b
-01001011b ^ 00000010b = 01001001b
-01001011b ^ 00000011b = 01001000b
-01001011b ^ 00000100b = 01001111b
-01001011b ^ 00000101b = 01001110b
-01001011b ^ 00000110b = 01001101b
-01001011b ^ 00000111b = 01001100b
-01001011b ^ 00001000b = 01000011b
-01001011b ^ 00001001b = 01000010b
-01001011b ^ 00001010b = 01000001b
-01001011b ^ 00001011b = 01000000b
-01001011b ^ 00001100b = 01000111b
-01001011b ^ 00001101b = 01000110b
-01001011b ^ 00001110b = 01000101b
-01001011b ^ 00001111b = 01000100b
-01001011b ^ 00010000b = 01011011b
-01001011b ^ 00010001b = 01011010b
-01001011b ^ 00010010b = 01011001b
-01001011b ^ 00010011b = 01011000b
-01001011b ^ 00010100b = 01011111b
-01001011b ^ 00010101b = 01011110b
-01001011b ^ 00010110b = 01011101b
-01001011b ^ 00010111b = 01011100b
-01001011b ^ 00011000b = 01010011b
-01001011b ^ 00011001b = 01010010b
-01001011b ^ 00011010b = 01010001b
-01001011b ^ 00011011b = 01010000b
-01001011b ^ 00011100b = 01010111b
-01001011b ^ 00011101b = 01010110b
-01001011b ^ 00011110b = 01010101b
-01001011b ^ 00011111b = 01010100b
-01001011b ^ 00100000b = 01101011b
-01001011b ^ 00100001b = 01101010b
-01001011b ^ 00100010b = 01101001b
-01001011b ^ 00100011b = 01101000b
-01001011b ^ 00100100b = 01101111b
-01001011b ^ 00100101b = 01101110b
-01001011b ^ 00100110b = 01101101b
-01001011b ^ 00100111b = 01101100b
-01001011b ^ 00101000b = 01100011b
-01001011b ^ 00101001b = 01100010b
-01001011b ^ 00101010b = 01100001b
-01001011b ^ 00101011b = 01100000b
-01001011b ^ 00101100b = 01100111b
-01001011b ^ 00101101b = 01100110b
-01001011b ^ 00101110b = 01100101b
-01001011b ^ 00101111b = 01100100b
-01001011b ^ 00110000b = 01111011b
-01001011b ^ 00110001b = 01111010b
-01001011b ^ 00110010b = 01111001b
-01001011b ^ 00110011b = 01111000b
-01001011b ^ 00110100b = 01111111b
-01001011b ^ 00110101b = 01111110b
-01001011b ^ 00110110b = 01111101b
-01001011b ^ 00110111b = 01111100b
-01001011b ^ 00111000b = 01110011b
-01001011b ^ 00111001b = 01110010b
-01001011b ^ 00111010b = 01110001b
-01001011b ^ 00111011b = 01110000b
-01001011b ^ 00111100b = 01110111b
-01001011b ^ 00111101b = 01110110b
-01001011b ^ 00111110b = 01110101b
-01001011b ^ 00111111b = 01110100b
-01001011b ^ 01000000b = 00001011b
-01001011b ^ 01000001b = 00001010b
-01001011b ^ 01000010b = 00001001b
-01001011b ^ 01000011b = 00001000b
-01001011b ^ 01000100b = 00001111b
-01001011b ^ 01000101b = 00001110b
-01001011b ^ 01000110b = 00001101b
-01001011b ^ 01000111b = 00001100b
-01001011b ^ 01001000b = 00000011b
-01001011b ^ 01001001b = 00000010b
-01001011b ^ 01001010b = 00000001b
-01001011b ^ 01001011b = 00000000b
-01001011b ^ 01001100b = 00000111b
-01001011b ^ 01001101b = 00000110b
-01001011b ^ 01001110b = 00000101b
-01001011b ^ 01001111b = 00000100b
-01001011b ^ 01010000b = 00011011b
-01001011b ^ 01010001b = 00011010b
-01001011b ^ 01010010b = 00011001b
-01001011b ^ 01010011b = 00011000b
-01001011b ^ 01010100b = 00011111b
-01001011b ^ 01010101b = 00011110b
-01001011b ^ 01010110b = 00011101b
-01001011b ^ 01010111b = 00011100b
-01001011b ^ 01011000b = 00010011b
-01001011b ^ 01011001b = 00010010b
-01001011b ^ 01011010b = 00010001b
-01001011b ^ 01011011b = 00010000b
-01001011b ^ 01011100b = 00010111b
-01001011b ^ 01011101b = 00010110b
-01001011b ^ 01011110b = 00010101b
-01001011b ^ 01011111b = 00010100b
-01001011b ^ 01100000b = 00101011b
-01001011b ^ 01100001b = 00101010b
-01001011b ^ 01100010b = 00101001b
-01001011b ^ 01100011b = 00101000b
-01001011b ^ 01100100b = 00101111b
-01001011b ^ 01100101b = 00101110b
-01001011b ^ 01100110b = 00101101b
-01001011b ^ 01100111b = 00101100b
-01001011b ^ 01101000b = 00100011b
-01001011b ^ 01101001b = 00100010b
-01001011b ^ 01101010b = 00100001b
-01001011b ^ 01101011b = 00100000b
-01001011b ^ 01101100b = 00100111b
-01001011b ^ 01101101b = 00100110b
-01001011b ^ 01101110b = 00100101b
-01001011b ^ 01101111b = 00100100b
-01001011b ^ 01110000b = 00111011b
-01001011b ^ 01110001b = 00111010b
-01001011b ^ 01110010b = 00111001b
-01001011b ^ 01110011b = 00111000b
-01001011b ^ 01110100b = 00111111b
-01001011b ^ 01110101b = 00111110b
-01001011b ^ 01110110b = 00111101b
-01001011b ^ 01110111b = 00111100b
-01001011b ^ 01111000b = 00110011b
-01001011b ^ 01111001b = 00110010b
-01001011b ^ 01111010b = 00110001b
-01001011b ^ 01111011b = 00110000b
-01001011b ^ 01111100b = 00110111b
-01001011b ^ 01111101b = 00110110b
-01001011b ^ 01111110b = 00110101b
-01001100b ^ 10000000b = 11001100b
-01001100b ^ 10000001b = 11001101b
-01001100b ^ 10000010b = 11001110b
-01001100b ^ 10000011b = 11001111b
-01001100b ^ 10000100b = 11001000b
-01001100b ^ 10000101b = 11001001b
-01001100b ^ 10000110b = 11001010b
-01001100b ^ 10000111b = 11001011b
-01001100b ^ 10001000b = 11000100b
-01001100b ^ 10001001b = 11000101b
-01001100b ^ 10001010b = 11000110b
-01001100b ^ 10001011b = 11000111b
-01001100b ^ 10001100b = 11000000b
-01001100b ^ 10001101b = 11000001b
-01001100b ^ 10001110b = 11000010b
-01001100b ^ 10001111b = 11000011b
-01001100b ^ 10010000b = 11011100b
-01001100b ^ 10010001b = 11011101b
-01001100b ^ 10010010b = 11011110b
-01001100b ^ 10010011b = 11011111b
-01001100b ^ 10010100b = 11011000b
-01001100b ^ 10010101b = 11011001b
-01001100b ^ 10010110b = 11011010b
-01001100b ^ 10010111b = 11011011b
-01001100b ^ 10011000b = 11010100b
-01001100b ^ 10011001b = 11010101b
-01001100b ^ 10011010b = 11010110b
-01001100b ^ 10011011b = 11010111b
-01001100b ^ 10011100b = 11010000b
-01001100b ^ 10011101b = 11010001b
-01001100b ^ 10011110b = 11010010b
-01001100b ^ 10011111b = 11010011b
-01001100b ^ 10100000b = 11101100b
-01001100b ^ 10100001b = 11101101b
-01001100b ^ 10100010b = 11101110b
-01001100b ^ 10100011b = 11101111b
-01001100b ^ 10100100b = 11101000b
-01001100b ^ 10100101b = 11101001b
-01001100b ^ 10100110b = 11101010b
-01001100b ^ 10100111b = 11101011b
-01001100b ^ 10101000b = 11100100b
-01001100b ^ 10101001b = 11100101b
-01001100b ^ 10101010b = 11100110b
-01001100b ^ 10101011b = 11100111b
-01001100b ^ 10101100b = 11100000b
-01001100b ^ 10101101b = 11100001b
-01001100b ^ 10101110b = 11100010b
-01001100b ^ 10101111b = 11100011b
-01001100b ^ 10110000b = 11111100b
-01001100b ^ 10110001b = 11111101b
-01001100b ^ 10110010b = 11111110b
-01001100b ^ 10110011b = 11111111b
-01001100b ^ 10110100b = 11111000b
-01001100b ^ 10110101b = 11111001b
-01001100b ^ 10110110b = 11111010b
-01001100b ^ 10110111b = 11111011b
-01001100b ^ 10111000b = 11110100b
-01001100b ^ 10111001b = 11110101b
-01001100b ^ 10111010b = 11110110b
-01001100b ^ 10111011b = 11110111b
-01001100b ^ 10111100b = 11110000b
-01001100b ^ 10111101b = 11110001b
-01001100b ^ 10111110b = 11110010b
-01001100b ^ 10111111b = 11110011b
-01001100b ^ 11000000b = 10001100b
-01001100b ^ 11000001b = 10001101b
-01001100b ^ 11000010b = 10001110b
-01001100b ^ 11000011b = 10001111b
-01001100b ^ 11000100b = 10001000b
-01001100b ^ 11000101b = 10001001b
-01001100b ^ 11000110b = 10001010b
-01001100b ^ 11000111b = 10001011b
-01001100b ^ 11001000b = 10000100b
-01001100b ^ 11001001b = 10000101b
-01001100b ^ 11001010b = 10000110b
-01001100b ^ 11001011b = 10000111b
-01001100b ^ 11001100b = 10000000b
-01001100b ^ 11001101b = 10000001b
-01001100b ^ 11001110b = 10000010b
-01001100b ^ 11001111b = 10000011b
-01001100b ^ 11010000b = 10011100b
-01001100b ^ 11010001b = 10011101b
-01001100b ^ 11010010b = 10011110b
-01001100b ^ 11010011b = 10011111b
-01001100b ^ 11010100b = 10011000b
-01001100b ^ 11010101b = 10011001b
-01001100b ^ 11010110b = 10011010b
-01001100b ^ 11010111b = 10011011b
-01001100b ^ 11011000b = 10010100b
-01001100b ^ 11011001b = 10010101b
-01001100b ^ 11011010b = 10010110b
-01001100b ^ 11011011b = 10010111b
-01001100b ^ 11011100b = 10010000b
-01001100b ^ 11011101b = 10010001b
-01001100b ^ 11011110b = 10010010b
-01001100b ^ 11011111b = 10010011b
-01001100b ^ 11100000b = 10101100b
-01001100b ^ 11100001b = 10101101b
-01001100b ^ 11100010b = 10101110b
-01001100b ^ 11100011b = 10101111b
-01001100b ^ 11100100b = 10101000b
-01001100b ^ 11100101b = 10101001b
-01001100b ^ 11100110b = 10101010b
-01001100b ^ 11100111b = 10101011b
-01001100b ^ 11101000b = 10100100b
-01001100b ^ 11101001b = 10100101b
-01001100b ^ 11101010b = 10100110b
-01001100b ^ 11101011b = 10100111b
-01001100b ^ 11101100b = 10100000b
-01001100b ^ 11101101b = 10100001b
-01001100b ^ 11101110b = 10100010b
-01001100b ^ 11101111b = 10100011b
-01001100b ^ 11110000b = 10111100b
-01001100b ^ 11110001b = 10111101b
-01001100b ^ 11110010b = 10111110b
-01001100b ^ 11110011b = 10111111b
-01001100b ^ 11110100b = 10111000b
-01001100b ^ 11110101b = 10111001b
-01001100b ^ 11110110b = 10111010b
-01001100b ^ 11110111b = 10111011b
-01001100b ^ 11111000b = 10110100b
-01001100b ^ 11111001b = 10110101b
-01001100b ^ 11111010b = 10110110b
-01001100b ^ 11111011b = 10110111b
-01001100b ^ 11111100b = 10110000b
-01001100b ^ 11111101b = 10110001b
-01001100b ^ 11111110b = 10110010b
-01001100b ^ 11111111b = 10110011b
-01001100b ^ 00000000b = 01001100b
-01001100b ^ 00000001b = 01001101b
-01001100b ^ 00000010b = 01001110b
-01001100b ^ 00000011b = 01001111b
-01001100b ^ 00000100b = 01001000b
-01001100b ^ 00000101b = 01001001b
-01001100b ^ 00000110b = 01001010b
-01001100b ^ 00000111b = 01001011b
-01001100b ^ 00001000b = 01000100b
-01001100b ^ 00001001b = 01000101b
-01001100b ^ 00001010b = 01000110b
-01001100b ^ 00001011b = 01000111b
-01001100b ^ 00001100b = 01000000b
-01001100b ^ 00001101b = 01000001b
-01001100b ^ 00001110b = 01000010b
-01001100b ^ 00001111b = 01000011b
-01001100b ^ 00010000b = 01011100b
-01001100b ^ 00010001b = 01011101b
-01001100b ^ 00010010b = 01011110b
-01001100b ^ 00010011b = 01011111b
-01001100b ^ 00010100b = 01011000b
-01001100b ^ 00010101b = 01011001b
-01001100b ^ 00010110b = 01011010b
-01001100b ^ 00010111b = 01011011b
-01001100b ^ 00011000b = 01010100b
-01001100b ^ 00011001b = 01010101b
-01001100b ^ 00011010b = 01010110b
-01001100b ^ 00011011b = 01010111b
-01001100b ^ 00011100b = 01010000b
-01001100b ^ 00011101b = 01010001b
-01001100b ^ 00011110b = 01010010b
-01001100b ^ 00011111b = 01010011b
-01001100b ^ 00100000b = 01101100b
-01001100b ^ 00100001b = 01101101b
-01001100b ^ 00100010b = 01101110b
-01001100b ^ 00100011b = 01101111b
-01001100b ^ 00100100b = 01101000b
-01001100b ^ 00100101b = 01101001b
-01001100b ^ 00100110b = 01101010b
-01001100b ^ 00100111b = 01101011b
-01001100b ^ 00101000b = 01100100b
-01001100b ^ 00101001b = 01100101b
-01001100b ^ 00101010b = 01100110b
-01001100b ^ 00101011b = 01100111b
-01001100b ^ 00101100b = 01100000b
-01001100b ^ 00101101b = 01100001b
-01001100b ^ 00101110b = 01100010b
-01001100b ^ 00101111b = 01100011b
-01001100b ^ 00110000b = 01111100b
-01001100b ^ 00110001b = 01111101b
-01001100b ^ 00110010b = 01111110b
-01001100b ^ 00110011b = 01111111b
-01001100b ^ 00110100b = 01111000b
-01001100b ^ 00110101b = 01111001b
-01001100b ^ 00110110b = 01111010b
-01001100b ^ 00110111b = 01111011b
-01001100b ^ 00111000b = 01110100b
-01001100b ^ 00111001b = 01110101b
-01001100b ^ 00111010b = 01110110b
-01001100b ^ 00111011b = 01110111b
-01001100b ^ 00111100b = 01110000b
-01001100b ^ 00111101b = 01110001b
-01001100b ^ 00111110b = 01110010b
-01001100b ^ 00111111b = 01110011b
-01001100b ^ 01000000b = 00001100b
-01001100b ^ 01000001b = 00001101b
-01001100b ^ 01000010b = 00001110b
-01001100b ^ 01000011b = 00001111b
-01001100b ^ 01000100b = 00001000b
-01001100b ^ 01000101b = 00001001b
-01001100b ^ 01000110b = 00001010b
-01001100b ^ 01000111b = 00001011b
-01001100b ^ 01001000b = 00000100b
-01001100b ^ 01001001b = 00000101b
-01001100b ^ 01001010b = 00000110b
-01001100b ^ 01001011b = 00000111b
-01001100b ^ 01001100b = 00000000b
-01001100b ^ 01001101b = 00000001b
-01001100b ^ 01001110b = 00000010b
-01001100b ^ 01001111b = 00000011b
-01001100b ^ 01010000b = 00011100b
-01001100b ^ 01010001b = 00011101b
-01001100b ^ 01010010b = 00011110b
-01001100b ^ 01010011b = 00011111b
-01001100b ^ 01010100b = 00011000b
-01001100b ^ 01010101b = 00011001b
-01001100b ^ 01010110b = 00011010b
-01001100b ^ 01010111b = 00011011b
-01001100b ^ 01011000b = 00010100b
-01001100b ^ 01011001b = 00010101b
-01001100b ^ 01011010b = 00010110b
-01001100b ^ 01011011b = 00010111b
-01001100b ^ 01011100b = 00010000b
-01001100b ^ 01011101b = 00010001b
-01001100b ^ 01011110b = 00010010b
-01001100b ^ 01011111b = 00010011b
-01001100b ^ 01100000b = 00101100b
-01001100b ^ 01100001b = 00101101b
-01001100b ^ 01100010b = 00101110b
-01001100b ^ 01100011b = 00101111b
-01001100b ^ 01100100b = 00101000b
-01001100b ^ 01100101b = 00101001b
-01001100b ^ 01100110b = 00101010b
-01001100b ^ 01100111b = 00101011b
-01001100b ^ 01101000b = 00100100b
-01001100b ^ 01101001b = 00100101b
-01001100b ^ 01101010b = 00100110b
-01001100b ^ 01101011b = 00100111b
-01001100b ^ 01101100b = 00100000b
-01001100b ^ 01101101b = 00100001b
-01001100b ^ 01101110b = 00100010b
-01001100b ^ 01101111b = 00100011b
-01001100b ^ 01110000b = 00111100b
-01001100b ^ 01110001b = 00111101b
-01001100b ^ 01110010b = 00111110b
-01001100b ^ 01110011b = 00111111b
-01001100b ^ 01110100b = 00111000b
-01001100b ^ 01110101b = 00111001b
-01001100b ^ 01110110b = 00111010b
-01001100b ^ 01110111b = 00111011b
-01001100b ^ 01111000b = 00110100b
-01001100b ^ 01111001b = 00110101b
-01001100b ^ 01111010b = 00110110b
-01001100b ^ 01111011b = 00110111b
-01001100b ^ 01111100b = 00110000b
-01001100b ^ 01111101b = 00110001b
-01001100b ^ 01111110b = 00110010b
-01001101b ^ 10000000b = 11001101b
-01001101b ^ 10000001b = 11001100b
-01001101b ^ 10000010b = 11001111b
-01001101b ^ 10000011b = 11001110b
-01001101b ^ 10000100b = 11001001b
-01001101b ^ 10000101b = 11001000b
-01001101b ^ 10000110b = 11001011b
-01001101b ^ 10000111b = 11001010b
-01001101b ^ 10001000b = 11000101b
-01001101b ^ 10001001b = 11000100b
-01001101b ^ 10001010b = 11000111b
-01001101b ^ 10001011b = 11000110b
-01001101b ^ 10001100b = 11000001b
-01001101b ^ 10001101b = 11000000b
-01001101b ^ 10001110b = 11000011b
-01001101b ^ 10001111b = 11000010b
-01001101b ^ 10010000b = 11011101b
-01001101b ^ 10010001b = 11011100b
-01001101b ^ 10010010b = 11011111b
-01001101b ^ 10010011b = 11011110b
-01001101b ^ 10010100b = 11011001b
-01001101b ^ 10010101b = 11011000b
-01001101b ^ 10010110b = 11011011b
-01001101b ^ 10010111b = 11011010b
-01001101b ^ 10011000b = 11010101b
-01001101b ^ 10011001b = 11010100b
-01001101b ^ 10011010b = 11010111b
-01001101b ^ 10011011b = 11010110b
-01001101b ^ 10011100b = 11010001b
-01001101b ^ 10011101b = 11010000b
-01001101b ^ 10011110b = 11010011b
-01001101b ^ 10011111b = 11010010b
-01001101b ^ 10100000b = 11101101b
-01001101b ^ 10100001b = 11101100b
-01001101b ^ 10100010b = 11101111b
-01001101b ^ 10100011b = 11101110b
-01001101b ^ 10100100b = 11101001b
-01001101b ^ 10100101b = 11101000b
-01001101b ^ 10100110b = 11101011b
-01001101b ^ 10100111b = 11101010b
-01001101b ^ 10101000b = 11100101b
-01001101b ^ 10101001b = 11100100b
-01001101b ^ 10101010b = 11100111b
-01001101b ^ 10101011b = 11100110b
-01001101b ^ 10101100b = 11100001b
-01001101b ^ 10101101b = 11100000b
-01001101b ^ 10101110b = 11100011b
-01001101b ^ 10101111b = 11100010b
-01001101b ^ 10110000b = 11111101b
-01001101b ^ 10110001b = 11111100b
-01001101b ^ 10110010b = 11111111b
-01001101b ^ 10110011b = 11111110b
-01001101b ^ 10110100b = 11111001b
-01001101b ^ 10110101b = 11111000b
-01001101b ^ 10110110b = 11111011b
-01001101b ^ 10110111b = 11111010b
-01001101b ^ 10111000b = 11110101b
-01001101b ^ 10111001b = 11110100b
-01001101b ^ 10111010b = 11110111b
-01001101b ^ 10111011b = 11110110b
-01001101b ^ 10111100b = 11110001b
-01001101b ^ 10111101b = 11110000b
-01001101b ^ 10111110b = 11110011b
-01001101b ^ 10111111b = 11110010b
-01001101b ^ 11000000b = 10001101b
-01001101b ^ 11000001b = 10001100b
-01001101b ^ 11000010b = 10001111b
-01001101b ^ 11000011b = 10001110b
-01001101b ^ 11000100b = 10001001b
-01001101b ^ 11000101b = 10001000b
-01001101b ^ 11000110b = 10001011b
-01001101b ^ 11000111b = 10001010b
-01001101b ^ 11001000b = 10000101b
-01001101b ^ 11001001b = 10000100b
-01001101b ^ 11001010b = 10000111b
-01001101b ^ 11001011b = 10000110b
-01001101b ^ 11001100b = 10000001b
-01001101b ^ 11001101b = 10000000b
-01001101b ^ 11001110b = 10000011b
-01001101b ^ 11001111b = 10000010b
-01001101b ^ 11010000b = 10011101b
-01001101b ^ 11010001b = 10011100b
-01001101b ^ 11010010b = 10011111b
-01001101b ^ 11010011b = 10011110b
-01001101b ^ 11010100b = 10011001b
-01001101b ^ 11010101b = 10011000b
-01001101b ^ 11010110b = 10011011b
-01001101b ^ 11010111b = 10011010b
-01001101b ^ 11011000b = 10010101b
-01001101b ^ 11011001b = 10010100b
-01001101b ^ 11011010b = 10010111b
-01001101b ^ 11011011b = 10010110b
-01001101b ^ 11011100b = 10010001b
-01001101b ^ 11011101b = 10010000b
-01001101b ^ 11011110b = 10010011b
-01001101b ^ 11011111b = 10010010b
-01001101b ^ 11100000b = 10101101b
-01001101b ^ 11100001b = 10101100b
-01001101b ^ 11100010b = 10101111b
-01001101b ^ 11100011b = 10101110b
-01001101b ^ 11100100b = 10101001b
-01001101b ^ 11100101b = 10101000b
-01001101b ^ 11100110b = 10101011b
-01001101b ^ 11100111b = 10101010b
-01001101b ^ 11101000b = 10100101b
-01001101b ^ 11101001b = 10100100b
-01001101b ^ 11101010b = 10100111b
-01001101b ^ 11101011b = 10100110b
-01001101b ^ 11101100b = 10100001b
-01001101b ^ 11101101b = 10100000b
-01001101b ^ 11101110b = 10100011b
-01001101b ^ 11101111b = 10100010b
-01001101b ^ 11110000b = 10111101b
-01001101b ^ 11110001b = 10111100b
-01001101b ^ 11110010b = 10111111b
-01001101b ^ 11110011b = 10111110b
-01001101b ^ 11110100b = 10111001b
-01001101b ^ 11110101b = 10111000b
-01001101b ^ 11110110b = 10111011b
-01001101b ^ 11110111b = 10111010b
-01001101b ^ 11111000b = 10110101b
-01001101b ^ 11111001b = 10110100b
-01001101b ^ 11111010b = 10110111b
-01001101b ^ 11111011b = 10110110b
-01001101b ^ 11111100b = 10110001b
-01001101b ^ 11111101b = 10110000b
-01001101b ^ 11111110b = 10110011b
-01001101b ^ 11111111b = 10110010b
-01001101b ^ 00000000b = 01001101b
-01001101b ^ 00000001b = 01001100b
-01001101b ^ 00000010b = 01001111b
-01001101b ^ 00000011b = 01001110b
-01001101b ^ 00000100b = 01001001b
-01001101b ^ 00000101b = 01001000b
-01001101b ^ 00000110b = 01001011b
-01001101b ^ 00000111b = 01001010b
-01001101b ^ 00001000b = 01000101b
-01001101b ^ 00001001b = 01000100b
-01001101b ^ 00001010b = 01000111b
-01001101b ^ 00001011b = 01000110b
-01001101b ^ 00001100b = 01000001b
-01001101b ^ 00001101b = 01000000b
-01001101b ^ 00001110b = 01000011b
-01001101b ^ 00001111b = 01000010b
-01001101b ^ 00010000b = 01011101b
-01001101b ^ 00010001b = 01011100b
-01001101b ^ 00010010b = 01011111b
-01001101b ^ 00010011b = 01011110b
-01001101b ^ 00010100b = 01011001b
-01001101b ^ 00010101b = 01011000b
-01001101b ^ 00010110b = 01011011b
-01001101b ^ 00010111b = 01011010b
-01001101b ^ 00011000b = 01010101b
-01001101b ^ 00011001b = 01010100b
-01001101b ^ 00011010b = 01010111b
-01001101b ^ 00011011b = 01010110b
-01001101b ^ 00011100b = 01010001b
-01001101b ^ 00011101b = 01010000b
-01001101b ^ 00011110b = 01010011b
-01001101b ^ 00011111b = 01010010b
-01001101b ^ 00100000b = 01101101b
-01001101b ^ 00100001b = 01101100b
-01001101b ^ 00100010b = 01101111b
-01001101b ^ 00100011b = 01101110b
-01001101b ^ 00100100b = 01101001b
-01001101b ^ 00100101b = 01101000b
-01001101b ^ 00100110b = 01101011b
-01001101b ^ 00100111b = 01101010b
-01001101b ^ 00101000b = 01100101b
-01001101b ^ 00101001b = 01100100b
-01001101b ^ 00101010b = 01100111b
-01001101b ^ 00101011b = 01100110b
-01001101b ^ 00101100b = 01100001b
-01001101b ^ 00101101b = 01100000b
-01001101b ^ 00101110b = 01100011b
-01001101b ^ 00101111b = 01100010b
-01001101b ^ 00110000b = 01111101b
-01001101b ^ 00110001b = 01111100b
-01001101b ^ 00110010b = 01111111b
-01001101b ^ 00110011b = 01111110b
-01001101b ^ 00110100b = 01111001b
-01001101b ^ 00110101b = 01111000b
-01001101b ^ 00110110b = 01111011b
-01001101b ^ 00110111b = 01111010b
-01001101b ^ 00111000b = 01110101b
-01001101b ^ 00111001b = 01110100b
-01001101b ^ 00111010b = 01110111b
-01001101b ^ 00111011b = 01110110b
-01001101b ^ 00111100b = 01110001b
-01001101b ^ 00111101b = 01110000b
-01001101b ^ 00111110b = 01110011b
-01001101b ^ 00111111b = 01110010b
-01001101b ^ 01000000b = 00001101b
-01001101b ^ 01000001b = 00001100b
-01001101b ^ 01000010b = 00001111b
-01001101b ^ 01000011b = 00001110b
-01001101b ^ 01000100b = 00001001b
-01001101b ^ 01000101b = 00001000b
-01001101b ^ 01000110b = 00001011b
-01001101b ^ 01000111b = 00001010b
-01001101b ^ 01001000b = 00000101b
-01001101b ^ 01001001b = 00000100b
-01001101b ^ 01001010b = 00000111b
-01001101b ^ 01001011b = 00000110b
-01001101b ^ 01001100b = 00000001b
-01001101b ^ 01001101b = 00000000b
-01001101b ^ 01001110b = 00000011b
-01001101b ^ 01001111b = 00000010b
-01001101b ^ 01010000b = 00011101b
-01001101b ^ 01010001b = 00011100b
-01001101b ^ 01010010b = 00011111b
-01001101b ^ 01010011b = 00011110b
-01001101b ^ 01010100b = 00011001b
-01001101b ^ 01010101b = 00011000b
-01001101b ^ 01010110b = 00011011b
-01001101b ^ 01010111b = 00011010b
-01001101b ^ 01011000b = 00010101b
-01001101b ^ 01011001b = 00010100b
-01001101b ^ 01011010b = 00010111b
-01001101b ^ 01011011b = 00010110b
-01001101b ^ 01011100b = 00010001b
-01001101b ^ 01011101b = 00010000b
-01001101b ^ 01011110b = 00010011b
-01001101b ^ 01011111b = 00010010b
-01001101b ^ 01100000b = 00101101b
-01001101b ^ 01100001b = 00101100b
-01001101b ^ 01100010b = 00101111b
-01001101b ^ 01100011b = 00101110b
-01001101b ^ 01100100b = 00101001b
-01001101b ^ 01100101b = 00101000b
-01001101b ^ 01100110b = 00101011b
-01001101b ^ 01100111b = 00101010b
-01001101b ^ 01101000b = 00100101b
-01001101b ^ 01101001b = 00100100b
-01001101b ^ 01101010b = 00100111b
-01001101b ^ 01101011b = 00100110b
-01001101b ^ 01101100b = 00100001b
-01001101b ^ 01101101b = 00100000b
-01001101b ^ 01101110b = 00100011b
-01001101b ^ 01101111b = 00100010b
-01001101b ^ 01110000b = 00111101b
-01001101b ^ 01110001b = 00111100b
-01001101b ^ 01110010b = 00111111b
-01001101b ^ 01110011b = 00111110b
-01001101b ^ 01110100b = 00111001b
-01001101b ^ 01110101b = 00111000b
-01001101b ^ 01110110b = 00111011b
-01001101b ^ 01110111b = 00111010b
-01001101b ^ 01111000b = 00110101b
-01001101b ^ 01111001b = 00110100b
-01001101b ^ 01111010b = 00110111b
-01001101b ^ 01111011b = 00110110b
-01001101b ^ 01111100b = 00110001b
-01001101b ^ 01111101b = 00110000b
-01001101b ^ 01111110b = 00110011b
-01001110b ^ 10000000b = 11001110b
-01001110b ^ 10000001b = 11001111b
-01001110b ^ 10000010b = 11001100b
-01001110b ^ 10000011b = 11001101b
-01001110b ^ 10000100b = 11001010b
-01001110b ^ 10000101b = 11001011b
-01001110b ^ 10000110b = 11001000b
-01001110b ^ 10000111b = 11001001b
-01001110b ^ 10001000b = 11000110b
-01001110b ^ 10001001b = 11000111b
-01001110b ^ 10001010b = 11000100b
-01001110b ^ 10001011b = 11000101b
-01001110b ^ 10001100b = 11000010b
-01001110b ^ 10001101b = 11000011b
-01001110b ^ 10001110b = 11000000b
-01001110b ^ 10001111b = 11000001b
-01001110b ^ 10010000b = 11011110b
-01001110b ^ 10010001b = 11011111b
-01001110b ^ 10010010b = 11011100b
-01001110b ^ 10010011b = 11011101b
-01001110b ^ 10010100b = 11011010b
-01001110b ^ 10010101b = 11011011b
-01001110b ^ 10010110b = 11011000b
-01001110b ^ 10010111b = 11011001b
-01001110b ^ 10011000b = 11010110b
-01001110b ^ 10011001b = 11010111b
-01001110b ^ 10011010b = 11010100b
-01001110b ^ 10011011b = 11010101b
-01001110b ^ 10011100b = 11010010b
-01001110b ^ 10011101b = 11010011b
-01001110b ^ 10011110b = 11010000b
-01001110b ^ 10011111b = 11010001b
-01001110b ^ 10100000b = 11101110b
-01001110b ^ 10100001b = 11101111b
-01001110b ^ 10100010b = 11101100b
-01001110b ^ 10100011b = 11101101b
-01001110b ^ 10100100b = 11101010b
-01001110b ^ 10100101b = 11101011b
-01001110b ^ 10100110b = 11101000b
-01001110b ^ 10100111b = 11101001b
-01001110b ^ 10101000b = 11100110b
-01001110b ^ 10101001b = 11100111b
-01001110b ^ 10101010b = 11100100b
-01001110b ^ 10101011b = 11100101b
-01001110b ^ 10101100b = 11100010b
-01001110b ^ 10101101b = 11100011b
-01001110b ^ 10101110b = 11100000b
-01001110b ^ 10101111b = 11100001b
-01001110b ^ 10110000b = 11111110b
-01001110b ^ 10110001b = 11111111b
-01001110b ^ 10110010b = 11111100b
-01001110b ^ 10110011b = 11111101b
-01001110b ^ 10110100b = 11111010b
-01001110b ^ 10110101b = 11111011b
-01001110b ^ 10110110b = 11111000b
-01001110b ^ 10110111b = 11111001b
-01001110b ^ 10111000b = 11110110b
-01001110b ^ 10111001b = 11110111b
-01001110b ^ 10111010b = 11110100b
-01001110b ^ 10111011b = 11110101b
-01001110b ^ 10111100b = 11110010b
-01001110b ^ 10111101b = 11110011b
-01001110b ^ 10111110b = 11110000b
-01001110b ^ 10111111b = 11110001b
-01001110b ^ 11000000b = 10001110b
-01001110b ^ 11000001b = 10001111b
-01001110b ^ 11000010b = 10001100b
-01001110b ^ 11000011b = 10001101b
-01001110b ^ 11000100b = 10001010b
-01001110b ^ 11000101b = 10001011b
-01001110b ^ 11000110b = 10001000b
-01001110b ^ 11000111b = 10001001b
-01001110b ^ 11001000b = 10000110b
-01001110b ^ 11001001b = 10000111b
-01001110b ^ 11001010b = 10000100b
-01001110b ^ 11001011b = 10000101b
-01001110b ^ 11001100b = 10000010b
-01001110b ^ 11001101b = 10000011b
-01001110b ^ 11001110b = 10000000b
-01001110b ^ 11001111b = 10000001b
-01001110b ^ 11010000b = 10011110b
-01001110b ^ 11010001b = 10011111b
-01001110b ^ 11010010b = 10011100b
-01001110b ^ 11010011b = 10011101b
-01001110b ^ 11010100b = 10011010b
-01001110b ^ 11010101b = 10011011b
-01001110b ^ 11010110b = 10011000b
-01001110b ^ 11010111b = 10011001b
-01001110b ^ 11011000b = 10010110b
-01001110b ^ 11011001b = 10010111b
-01001110b ^ 11011010b = 10010100b
-01001110b ^ 11011011b = 10010101b
-01001110b ^ 11011100b = 10010010b
-01001110b ^ 11011101b = 10010011b
-01001110b ^ 11011110b = 10010000b
-01001110b ^ 11011111b = 10010001b
-01001110b ^ 11100000b = 10101110b
-01001110b ^ 11100001b = 10101111b
-01001110b ^ 11100010b = 10101100b
-01001110b ^ 11100011b = 10101101b
-01001110b ^ 11100100b = 10101010b
-01001110b ^ 11100101b = 10101011b
-01001110b ^ 11100110b = 10101000b
-01001110b ^ 11100111b = 10101001b
-01001110b ^ 11101000b = 10100110b
-01001110b ^ 11101001b = 10100111b
-01001110b ^ 11101010b = 10100100b
-01001110b ^ 11101011b = 10100101b
-01001110b ^ 11101100b = 10100010b
-01001110b ^ 11101101b = 10100011b
-01001110b ^ 11101110b = 10100000b
-01001110b ^ 11101111b = 10100001b
-01001110b ^ 11110000b = 10111110b
-01001110b ^ 11110001b = 10111111b
-01001110b ^ 11110010b = 10111100b
-01001110b ^ 11110011b = 10111101b
-01001110b ^ 11110100b = 10111010b
-01001110b ^ 11110101b = 10111011b
-01001110b ^ 11110110b = 10111000b
-01001110b ^ 11110111b = 10111001b
-01001110b ^ 11111000b = 10110110b
-01001110b ^ 11111001b = 10110111b
-01001110b ^ 11111010b = 10110100b
-01001110b ^ 11111011b = 10110101b
-01001110b ^ 11111100b = 10110010b
-01001110b ^ 11111101b = 10110011b
-01001110b ^ 11111110b = 10110000b
-01001110b ^ 11111111b = 10110001b
-01001110b ^ 00000000b = 01001110b
-01001110b ^ 00000001b = 01001111b
-01001110b ^ 00000010b = 01001100b
-01001110b ^ 00000011b = 01001101b
-01001110b ^ 00000100b = 01001010b
-01001110b ^ 00000101b = 01001011b
-01001110b ^ 00000110b = 01001000b
-01001110b ^ 00000111b = 01001001b
-01001110b ^ 00001000b = 01000110b
-01001110b ^ 00001001b = 01000111b
-01001110b ^ 00001010b = 01000100b
-01001110b ^ 00001011b = 01000101b
-01001110b ^ 00001100b = 01000010b
-01001110b ^ 00001101b = 01000011b
-01001110b ^ 00001110b = 01000000b
-01001110b ^ 00001111b = 01000001b
-01001110b ^ 00010000b = 01011110b
-01001110b ^ 00010001b = 01011111b
-01001110b ^ 00010010b = 01011100b
-01001110b ^ 00010011b = 01011101b
-01001110b ^ 00010100b = 01011010b
-01001110b ^ 00010101b = 01011011b
-01001110b ^ 00010110b = 01011000b
-01001110b ^ 00010111b = 01011001b
-01001110b ^ 00011000b = 01010110b
-01001110b ^ 00011001b = 01010111b
-01001110b ^ 00011010b = 01010100b
-01001110b ^ 00011011b = 01010101b
-01001110b ^ 00011100b = 01010010b
-01001110b ^ 00011101b = 01010011b
-01001110b ^ 00011110b = 01010000b
-01001110b ^ 00011111b = 01010001b
-01001110b ^ 00100000b = 01101110b
-01001110b ^ 00100001b = 01101111b
-01001110b ^ 00100010b = 01101100b
-01001110b ^ 00100011b = 01101101b
-01001110b ^ 00100100b = 01101010b
-01001110b ^ 00100101b = 01101011b
-01001110b ^ 00100110b = 01101000b
-01001110b ^ 00100111b = 01101001b
-01001110b ^ 00101000b = 01100110b
-01001110b ^ 00101001b = 01100111b
-01001110b ^ 00101010b = 01100100b
-01001110b ^ 00101011b = 01100101b
-01001110b ^ 00101100b = 01100010b
-01001110b ^ 00101101b = 01100011b
-01001110b ^ 00101110b = 01100000b
-01001110b ^ 00101111b = 01100001b
-01001110b ^ 00110000b = 01111110b
-01001110b ^ 00110001b = 01111111b
-01001110b ^ 00110010b = 01111100b
-01001110b ^ 00110011b = 01111101b
-01001110b ^ 00110100b = 01111010b
-01001110b ^ 00110101b = 01111011b
-01001110b ^ 00110110b = 01111000b
-01001110b ^ 00110111b = 01111001b
-01001110b ^ 00111000b = 01110110b
-01001110b ^ 00111001b = 01110111b
-01001110b ^ 00111010b = 01110100b
-01001110b ^ 00111011b = 01110101b
-01001110b ^ 00111100b = 01110010b
-01001110b ^ 00111101b = 01110011b
-01001110b ^ 00111110b = 01110000b
-01001110b ^ 00111111b = 01110001b
-01001110b ^ 01000000b = 00001110b
-01001110b ^ 01000001b = 00001111b
-01001110b ^ 01000010b = 00001100b
-01001110b ^ 01000011b = 00001101b
-01001110b ^ 01000100b = 00001010b
-01001110b ^ 01000101b = 00001011b
-01001110b ^ 01000110b = 00001000b
-01001110b ^ 01000111b = 00001001b
-01001110b ^ 01001000b = 00000110b
-01001110b ^ 01001001b = 00000111b
-01001110b ^ 01001010b = 00000100b
-01001110b ^ 01001011b = 00000101b
-01001110b ^ 01001100b = 00000010b
-01001110b ^ 01001101b = 00000011b
-01001110b ^ 01001110b = 00000000b
-01001110b ^ 01001111b = 00000001b
-01001110b ^ 01010000b = 00011110b
-01001110b ^ 01010001b = 00011111b
-01001110b ^ 01010010b = 00011100b
-01001110b ^ 01010011b = 00011101b
-01001110b ^ 01010100b = 00011010b
-01001110b ^ 01010101b = 00011011b
-01001110b ^ 01010110b = 00011000b
-01001110b ^ 01010111b = 00011001b
-01001110b ^ 01011000b = 00010110b
-01001110b ^ 01011001b = 00010111b
-01001110b ^ 01011010b = 00010100b
-01001110b ^ 01011011b = 00010101b
-01001110b ^ 01011100b = 00010010b
-01001110b ^ 01011101b = 00010011b
-01001110b ^ 01011110b = 00010000b
-01001110b ^ 01011111b = 00010001b
-01001110b ^ 01100000b = 00101110b
-01001110b ^ 01100001b = 00101111b
-01001110b ^ 01100010b = 00101100b
-01001110b ^ 01100011b = 00101101b
-01001110b ^ 01100100b = 00101010b
-01001110b ^ 01100101b = 00101011b
-01001110b ^ 01100110b = 00101000b
-01001110b ^ 01100111b = 00101001b
-01001110b ^ 01101000b = 00100110b
-01001110b ^ 01101001b = 00100111b
-01001110b ^ 01101010b = 00100100b
-01001110b ^ 01101011b = 00100101b
-01001110b ^ 01101100b = 00100010b
-01001110b ^ 01101101b = 00100011b
-01001110b ^ 01101110b = 00100000b
-01001110b ^ 01101111b = 00100001b
-01001110b ^ 01110000b = 00111110b
-01001110b ^ 01110001b = 00111111b
-01001110b ^ 01110010b = 00111100b
-01001110b ^ 01110011b = 00111101b
-01001110b ^ 01110100b = 00111010b
-01001110b ^ 01110101b = 00111011b
-01001110b ^ 01110110b = 00111000b
-01001110b ^ 01110111b = 00111001b
-01001110b ^ 01111000b = 00110110b
-01001110b ^ 01111001b = 00110111b
-01001110b ^ 01111010b = 00110100b
-01001110b ^ 01111011b = 00110101b
-01001110b ^ 01111100b = 00110010b
-01001110b ^ 01111101b = 00110011b
-01001110b ^ 01111110b = 00110000b
-01001111b ^ 10000000b = 11001111b
-01001111b ^ 10000001b = 11001110b
-01001111b ^ 10000010b = 11001101b
-01001111b ^ 10000011b = 11001100b
-01001111b ^ 10000100b = 11001011b
-01001111b ^ 10000101b = 11001010b
-01001111b ^ 10000110b = 11001001b
-01001111b ^ 10000111b = 11001000b
-01001111b ^ 10001000b = 11000111b
-01001111b ^ 10001001b = 11000110b
-01001111b ^ 10001010b = 11000101b
-01001111b ^ 10001011b = 11000100b
-01001111b ^ 10001100b = 11000011b
-01001111b ^ 10001101b = 11000010b
-01001111b ^ 10001110b = 11000001b
-01001111b ^ 10001111b = 11000000b
-01001111b ^ 10010000b = 11011111b
-01001111b ^ 10010001b = 11011110b
-01001111b ^ 10010010b = 11011101b
-01001111b ^ 10010011b = 11011100b
-01001111b ^ 10010100b = 11011011b
-01001111b ^ 10010101b = 11011010b
-01001111b ^ 10010110b = 11011001b
-01001111b ^ 10010111b = 11011000b
-01001111b ^ 10011000b = 11010111b
-01001111b ^ 10011001b = 11010110b
-01001111b ^ 10011010b = 11010101b
-01001111b ^ 10011011b = 11010100b
-01001111b ^ 10011100b = 11010011b
-01001111b ^ 10011101b = 11010010b
-01001111b ^ 10011110b = 11010001b
-01001111b ^ 10011111b = 11010000b
-01001111b ^ 10100000b = 11101111b
-01001111b ^ 10100001b = 11101110b
-01001111b ^ 10100010b = 11101101b
-01001111b ^ 10100011b = 11101100b
-01001111b ^ 10100100b = 11101011b
-01001111b ^ 10100101b = 11101010b
-01001111b ^ 10100110b = 11101001b
-01001111b ^ 10100111b = 11101000b
-01001111b ^ 10101000b = 11100111b
-01001111b ^ 10101001b = 11100110b
-01001111b ^ 10101010b = 11100101b
-01001111b ^ 10101011b = 11100100b
-01001111b ^ 10101100b = 11100011b
-01001111b ^ 10101101b = 11100010b
-01001111b ^ 10101110b = 11100001b
-01001111b ^ 10101111b = 11100000b
-01001111b ^ 10110000b = 11111111b
-01001111b ^ 10110001b = 11111110b
-01001111b ^ 10110010b = 11111101b
-01001111b ^ 10110011b = 11111100b
-01001111b ^ 10110100b = 11111011b
-01001111b ^ 10110101b = 11111010b
-01001111b ^ 10110110b = 11111001b
-01001111b ^ 10110111b = 11111000b
-01001111b ^ 10111000b = 11110111b
-01001111b ^ 10111001b = 11110110b
-01001111b ^ 10111010b = 11110101b
-01001111b ^ 10111011b = 11110100b
-01001111b ^ 10111100b = 11110011b
-01001111b ^ 10111101b = 11110010b
-01001111b ^ 10111110b = 11110001b
-01001111b ^ 10111111b = 11110000b
-01001111b ^ 11000000b = 10001111b
-01001111b ^ 11000001b = 10001110b
-01001111b ^ 11000010b = 10001101b
-01001111b ^ 11000011b = 10001100b
-01001111b ^ 11000100b = 10001011b
-01001111b ^ 11000101b = 10001010b
-01001111b ^ 11000110b = 10001001b
-01001111b ^ 11000111b = 10001000b
-01001111b ^ 11001000b = 10000111b
-01001111b ^ 11001001b = 10000110b
-01001111b ^ 11001010b = 10000101b
-01001111b ^ 11001011b = 10000100b
-01001111b ^ 11001100b = 10000011b
-01001111b ^ 11001101b = 10000010b
-01001111b ^ 11001110b = 10000001b
-01001111b ^ 11001111b = 10000000b
-01001111b ^ 11010000b = 10011111b
-01001111b ^ 11010001b = 10011110b
-01001111b ^ 11010010b = 10011101b
-01001111b ^ 11010011b = 10011100b
-01001111b ^ 11010100b = 10011011b
-01001111b ^ 11010101b = 10011010b
-01001111b ^ 11010110b = 10011001b
-01001111b ^ 11010111b = 10011000b
-01001111b ^ 11011000b = 10010111b
-01001111b ^ 11011001b = 10010110b
-01001111b ^ 11011010b = 10010101b
-01001111b ^ 11011011b = 10010100b
-01001111b ^ 11011100b = 10010011b
-01001111b ^ 11011101b = 10010010b
-01001111b ^ 11011110b = 10010001b
-01001111b ^ 11011111b = 10010000b
-01001111b ^ 11100000b = 10101111b
-01001111b ^ 11100001b = 10101110b
-01001111b ^ 11100010b = 10101101b
-01001111b ^ 11100011b = 10101100b
-01001111b ^ 11100100b = 10101011b
-01001111b ^ 11100101b = 10101010b
-01001111b ^ 11100110b = 10101001b
-01001111b ^ 11100111b = 10101000b
-01001111b ^ 11101000b = 10100111b
-01001111b ^ 11101001b = 10100110b
-01001111b ^ 11101010b = 10100101b
-01001111b ^ 11101011b = 10100100b
-01001111b ^ 11101100b = 10100011b
-01001111b ^ 11101101b = 10100010b
-01001111b ^ 11101110b = 10100001b
-01001111b ^ 11101111b = 10100000b
-01001111b ^ 11110000b = 10111111b
-01001111b ^ 11110001b = 10111110b
-01001111b ^ 11110010b = 10111101b
-01001111b ^ 11110011b = 10111100b
-01001111b ^ 11110100b = 10111011b
-01001111b ^ 11110101b = 10111010b
-01001111b ^ 11110110b = 10111001b
-01001111b ^ 11110111b = 10111000b
-01001111b ^ 11111000b = 10110111b
-01001111b ^ 11111001b = 10110110b
-01001111b ^ 11111010b = 10110101b
-01001111b ^ 11111011b = 10110100b
-01001111b ^ 11111100b = 10110011b
-01001111b ^ 11111101b = 10110010b
-01001111b ^ 11111110b = 10110001b
-01001111b ^ 11111111b = 10110000b
-01001111b ^ 00000000b = 01001111b
-01001111b ^ 00000001b = 01001110b
-01001111b ^ 00000010b = 01001101b
-01001111b ^ 00000011b = 01001100b
-01001111b ^ 00000100b = 01001011b
-01001111b ^ 00000101b = 01001010b
-01001111b ^ 00000110b = 01001001b
-01001111b ^ 00000111b = 01001000b
-01001111b ^ 00001000b = 01000111b
-01001111b ^ 00001001b = 01000110b
-01001111b ^ 00001010b = 01000101b
-01001111b ^ 00001011b = 01000100b
-01001111b ^ 00001100b = 01000011b
-01001111b ^ 00001101b = 01000010b
-01001111b ^ 00001110b = 01000001b
-01001111b ^ 00001111b = 01000000b
-01001111b ^ 00010000b = 01011111b
-01001111b ^ 00010001b = 01011110b
-01001111b ^ 00010010b = 01011101b
-01001111b ^ 00010011b = 01011100b
-01001111b ^ 00010100b = 01011011b
-01001111b ^ 00010101b = 01011010b
-01001111b ^ 00010110b = 01011001b
-01001111b ^ 00010111b = 01011000b
-01001111b ^ 00011000b = 01010111b
-01001111b ^ 00011001b = 01010110b
-01001111b ^ 00011010b = 01010101b
-01001111b ^ 00011011b = 01010100b
-01001111b ^ 00011100b = 01010011b
-01001111b ^ 00011101b = 01010010b
-01001111b ^ 00011110b = 01010001b
-01001111b ^ 00011111b = 01010000b
-01001111b ^ 00100000b = 01101111b
-01001111b ^ 00100001b = 01101110b
-01001111b ^ 00100010b = 01101101b
-01001111b ^ 00100011b = 01101100b
-01001111b ^ 00100100b = 01101011b
-01001111b ^ 00100101b = 01101010b
-01001111b ^ 00100110b = 01101001b
-01001111b ^ 00100111b = 01101000b
-01001111b ^ 00101000b = 01100111b
-01001111b ^ 00101001b = 01100110b
-01001111b ^ 00101010b = 01100101b
-01001111b ^ 00101011b = 01100100b
-01001111b ^ 00101100b = 01100011b
-01001111b ^ 00101101b = 01100010b
-01001111b ^ 00101110b = 01100001b
-01001111b ^ 00101111b = 01100000b
-01001111b ^ 00110000b = 01111111b
-01001111b ^ 00110001b = 01111110b
-01001111b ^ 00110010b = 01111101b
-01001111b ^ 00110011b = 01111100b
-01001111b ^ 00110100b = 01111011b
-01001111b ^ 00110101b = 01111010b
-01001111b ^ 00110110b = 01111001b
-01001111b ^ 00110111b = 01111000b
-01001111b ^ 00111000b = 01110111b
-01001111b ^ 00111001b = 01110110b
-01001111b ^ 00111010b = 01110101b
-01001111b ^ 00111011b = 01110100b
-01001111b ^ 00111100b = 01110011b
-01001111b ^ 00111101b = 01110010b
-01001111b ^ 00111110b = 01110001b
-01001111b ^ 00111111b = 01110000b
-01001111b ^ 01000000b = 00001111b
-01001111b ^ 01000001b = 00001110b
-01001111b ^ 01000010b = 00001101b
-01001111b ^ 01000011b = 00001100b
-01001111b ^ 01000100b = 00001011b
-01001111b ^ 01000101b = 00001010b
-01001111b ^ 01000110b = 00001001b
-01001111b ^ 01000111b = 00001000b
-01001111b ^ 01001000b = 00000111b
-01001111b ^ 01001001b = 00000110b
-01001111b ^ 01001010b = 00000101b
-01001111b ^ 01001011b = 00000100b
-01001111b ^ 01001100b = 00000011b
-01001111b ^ 01001101b = 00000010b
-01001111b ^ 01001110b = 00000001b
-01001111b ^ 01001111b = 00000000b
-01001111b ^ 01010000b = 00011111b
-01001111b ^ 01010001b = 00011110b
-01001111b ^ 01010010b = 00011101b
-01001111b ^ 01010011b = 00011100b
-01001111b ^ 01010100b = 00011011b
-01001111b ^ 01010101b = 00011010b
-01001111b ^ 01010110b = 00011001b
-01001111b ^ 01010111b = 00011000b
-01001111b ^ 01011000b = 00010111b
-01001111b ^ 01011001b = 00010110b
-01001111b ^ 01011010b = 00010101b
-01001111b ^ 01011011b = 00010100b
-01001111b ^ 01011100b = 00010011b
-01001111b ^ 01011101b = 00010010b
-01001111b ^ 01011110b = 00010001b
-01001111b ^ 01011111b = 00010000b
-01001111b ^ 01100000b = 00101111b
-01001111b ^ 01100001b = 00101110b
-01001111b ^ 01100010b = 00101101b
-01001111b ^ 01100011b = 00101100b
-01001111b ^ 01100100b = 00101011b
-01001111b ^ 01100101b = 00101010b
-01001111b ^ 01100110b = 00101001b
-01001111b ^ 01100111b = 00101000b
-01001111b ^ 01101000b = 00100111b
-01001111b ^ 01101001b = 00100110b
-01001111b ^ 01101010b = 00100101b
-01001111b ^ 01101011b = 00100100b
-01001111b ^ 01101100b = 00100011b
-01001111b ^ 01101101b = 00100010b
-01001111b ^ 01101110b = 00100001b
-01001111b ^ 01101111b = 00100000b
-01001111b ^ 01110000b = 00111111b
-01001111b ^ 01110001b = 00111110b
-01001111b ^ 01110010b = 00111101b
-01001111b ^ 01110011b = 00111100b
-01001111b ^ 01110100b = 00111011b
-01001111b ^ 01110101b = 00111010b
-01001111b ^ 01110110b = 00111001b
-01001111b ^ 01110111b = 00111000b
-01001111b ^ 01111000b = 00110111b
-01001111b ^ 01111001b = 00110110b
-01001111b ^ 01111010b = 00110101b
-01001111b ^ 01111011b = 00110100b
-01001111b ^ 01111100b = 00110011b
-01001111b ^ 01111101b = 00110010b
-01001111b ^ 01111110b = 00110001b
-01010000b ^ 10000000b = 11010000b
-01010000b ^ 10000001b = 11010001b
-01010000b ^ 10000010b = 11010010b
-01010000b ^ 10000011b = 11010011b
-01010000b ^ 10000100b = 11010100b
-01010000b ^ 10000101b = 11010101b
-01010000b ^ 10000110b = 11010110b
-01010000b ^ 10000111b = 11010111b
-01010000b ^ 10001000b = 11011000b
-01010000b ^ 10001001b = 11011001b
-01010000b ^ 10001010b = 11011010b
-01010000b ^ 10001011b = 11011011b
-01010000b ^ 10001100b = 11011100b
-01010000b ^ 10001101b = 11011101b
-01010000b ^ 10001110b = 11011110b
-01010000b ^ 10001111b = 11011111b
-01010000b ^ 10010000b = 11000000b
-01010000b ^ 10010001b = 11000001b
-01010000b ^ 10010010b = 11000010b
-01010000b ^ 10010011b = 11000011b
-01010000b ^ 10010100b = 11000100b
-01010000b ^ 10010101b = 11000101b
-01010000b ^ 10010110b = 11000110b
-01010000b ^ 10010111b = 11000111b
-01010000b ^ 10011000b = 11001000b
-01010000b ^ 10011001b = 11001001b
-01010000b ^ 10011010b = 11001010b
-01010000b ^ 10011011b = 11001011b
-01010000b ^ 10011100b = 11001100b
-01010000b ^ 10011101b = 11001101b
-01010000b ^ 10011110b = 11001110b
-01010000b ^ 10011111b = 11001111b
-01010000b ^ 10100000b = 11110000b
-01010000b ^ 10100001b = 11110001b
-01010000b ^ 10100010b = 11110010b
-01010000b ^ 10100011b = 11110011b
-01010000b ^ 10100100b = 11110100b
-01010000b ^ 10100101b = 11110101b
-01010000b ^ 10100110b = 11110110b
-01010000b ^ 10100111b = 11110111b
-01010000b ^ 10101000b = 11111000b
-01010000b ^ 10101001b = 11111001b
-01010000b ^ 10101010b = 11111010b
-01010000b ^ 10101011b = 11111011b
-01010000b ^ 10101100b = 11111100b
-01010000b ^ 10101101b = 11111101b
-01010000b ^ 10101110b = 11111110b
-01010000b ^ 10101111b = 11111111b
-01010000b ^ 10110000b = 11100000b
-01010000b ^ 10110001b = 11100001b
-01010000b ^ 10110010b = 11100010b
-01010000b ^ 10110011b = 11100011b
-01010000b ^ 10110100b = 11100100b
-01010000b ^ 10110101b = 11100101b
-01010000b ^ 10110110b = 11100110b
-01010000b ^ 10110111b = 11100111b
-01010000b ^ 10111000b = 11101000b
-01010000b ^ 10111001b = 11101001b
-01010000b ^ 10111010b = 11101010b
-01010000b ^ 10111011b = 11101011b
-01010000b ^ 10111100b = 11101100b
-01010000b ^ 10111101b = 11101101b
-01010000b ^ 10111110b = 11101110b
-01010000b ^ 10111111b = 11101111b
-01010000b ^ 11000000b = 10010000b
-01010000b ^ 11000001b = 10010001b
-01010000b ^ 11000010b = 10010010b
-01010000b ^ 11000011b = 10010011b
-01010000b ^ 11000100b = 10010100b
-01010000b ^ 11000101b = 10010101b
-01010000b ^ 11000110b = 10010110b
-01010000b ^ 11000111b = 10010111b
-01010000b ^ 11001000b = 10011000b
-01010000b ^ 11001001b = 10011001b
-01010000b ^ 11001010b = 10011010b
-01010000b ^ 11001011b = 10011011b
-01010000b ^ 11001100b = 10011100b
-01010000b ^ 11001101b = 10011101b
-01010000b ^ 11001110b = 10011110b
-01010000b ^ 11001111b = 10011111b
-01010000b ^ 11010000b = 10000000b
-01010000b ^ 11010001b = 10000001b
-01010000b ^ 11010010b = 10000010b
-01010000b ^ 11010011b = 10000011b
-01010000b ^ 11010100b = 10000100b
-01010000b ^ 11010101b = 10000101b
-01010000b ^ 11010110b = 10000110b
-01010000b ^ 11010111b = 10000111b
-01010000b ^ 11011000b = 10001000b
-01010000b ^ 11011001b = 10001001b
-01010000b ^ 11011010b = 10001010b
-01010000b ^ 11011011b = 10001011b
-01010000b ^ 11011100b = 10001100b
-01010000b ^ 11011101b = 10001101b
-01010000b ^ 11011110b = 10001110b
-01010000b ^ 11011111b = 10001111b
-01010000b ^ 11100000b = 10110000b
-01010000b ^ 11100001b = 10110001b
-01010000b ^ 11100010b = 10110010b
-01010000b ^ 11100011b = 10110011b
-01010000b ^ 11100100b = 10110100b
-01010000b ^ 11100101b = 10110101b
-01010000b ^ 11100110b = 10110110b
-01010000b ^ 11100111b = 10110111b
-01010000b ^ 11101000b = 10111000b
-01010000b ^ 11101001b = 10111001b
-01010000b ^ 11101010b = 10111010b
-01010000b ^ 11101011b = 10111011b
-01010000b ^ 11101100b = 10111100b
-01010000b ^ 11101101b = 10111101b
-01010000b ^ 11101110b = 10111110b
-01010000b ^ 11101111b = 10111111b
-01010000b ^ 11110000b = 10100000b
-01010000b ^ 11110001b = 10100001b
-01010000b ^ 11110010b = 10100010b
-01010000b ^ 11110011b = 10100011b
-01010000b ^ 11110100b = 10100100b
-01010000b ^ 11110101b = 10100101b
-01010000b ^ 11110110b = 10100110b
-01010000b ^ 11110111b = 10100111b
-01010000b ^ 11111000b = 10101000b
-01010000b ^ 11111001b = 10101001b
-01010000b ^ 11111010b = 10101010b
-01010000b ^ 11111011b = 10101011b
-01010000b ^ 11111100b = 10101100b
-01010000b ^ 11111101b = 10101101b
-01010000b ^ 11111110b = 10101110b
-01010000b ^ 11111111b = 10101111b
-01010000b ^ 00000000b = 01010000b
-01010000b ^ 00000001b = 01010001b
-01010000b ^ 00000010b = 01010010b
-01010000b ^ 00000011b = 01010011b
-01010000b ^ 00000100b = 01010100b
-01010000b ^ 00000101b = 01010101b
-01010000b ^ 00000110b = 01010110b
-01010000b ^ 00000111b = 01010111b
-01010000b ^ 00001000b = 01011000b
-01010000b ^ 00001001b = 01011001b
-01010000b ^ 00001010b = 01011010b
-01010000b ^ 00001011b = 01011011b
-01010000b ^ 00001100b = 01011100b
-01010000b ^ 00001101b = 01011101b
-01010000b ^ 00001110b = 01011110b
-01010000b ^ 00001111b = 01011111b
-01010000b ^ 00010000b = 01000000b
-01010000b ^ 00010001b = 01000001b
-01010000b ^ 00010010b = 01000010b
-01010000b ^ 00010011b = 01000011b
-01010000b ^ 00010100b = 01000100b
-01010000b ^ 00010101b = 01000101b
-01010000b ^ 00010110b = 01000110b
-01010000b ^ 00010111b = 01000111b
-01010000b ^ 00011000b = 01001000b
-01010000b ^ 00011001b = 01001001b
-01010000b ^ 00011010b = 01001010b
-01010000b ^ 00011011b = 01001011b
-01010000b ^ 00011100b = 01001100b
-01010000b ^ 00011101b = 01001101b
-01010000b ^ 00011110b = 01001110b
-01010000b ^ 00011111b = 01001111b
-01010000b ^ 00100000b = 01110000b
-01010000b ^ 00100001b = 01110001b
-01010000b ^ 00100010b = 01110010b
-01010000b ^ 00100011b = 01110011b
-01010000b ^ 00100100b = 01110100b
-01010000b ^ 00100101b = 01110101b
-01010000b ^ 00100110b = 01110110b
-01010000b ^ 00100111b = 01110111b
-01010000b ^ 00101000b = 01111000b
-01010000b ^ 00101001b = 01111001b
-01010000b ^ 00101010b = 01111010b
-01010000b ^ 00101011b = 01111011b
-01010000b ^ 00101100b = 01111100b
-01010000b ^ 00101101b = 01111101b
-01010000b ^ 00101110b = 01111110b
-01010000b ^ 00101111b = 01111111b
-01010000b ^ 00110000b = 01100000b
-01010000b ^ 00110001b = 01100001b
-01010000b ^ 00110010b = 01100010b
-01010000b ^ 00110011b = 01100011b
-01010000b ^ 00110100b = 01100100b
-01010000b ^ 00110101b = 01100101b
-01010000b ^ 00110110b = 01100110b
-01010000b ^ 00110111b = 01100111b
-01010000b ^ 00111000b = 01101000b
-01010000b ^ 00111001b = 01101001b
-01010000b ^ 00111010b = 01101010b
-01010000b ^ 00111011b = 01101011b
-01010000b ^ 00111100b = 01101100b
-01010000b ^ 00111101b = 01101101b
-01010000b ^ 00111110b = 01101110b
-01010000b ^ 00111111b = 01101111b
-01010000b ^ 01000000b = 00010000b
-01010000b ^ 01000001b = 00010001b
-01010000b ^ 01000010b = 00010010b
-01010000b ^ 01000011b = 00010011b
-01010000b ^ 01000100b = 00010100b
-01010000b ^ 01000101b = 00010101b
-01010000b ^ 01000110b = 00010110b
-01010000b ^ 01000111b = 00010111b
-01010000b ^ 01001000b = 00011000b
-01010000b ^ 01001001b = 00011001b
-01010000b ^ 01001010b = 00011010b
-01010000b ^ 01001011b = 00011011b
-01010000b ^ 01001100b = 00011100b
-01010000b ^ 01001101b = 00011101b
-01010000b ^ 01001110b = 00011110b
-01010000b ^ 01001111b = 00011111b
-01010000b ^ 01010000b = 00000000b
-01010000b ^ 01010001b = 00000001b
-01010000b ^ 01010010b = 00000010b
-01010000b ^ 01010011b = 00000011b
-01010000b ^ 01010100b = 00000100b
-01010000b ^ 01010101b = 00000101b
-01010000b ^ 01010110b = 00000110b
-01010000b ^ 01010111b = 00000111b
-01010000b ^ 01011000b = 00001000b
-01010000b ^ 01011001b = 00001001b
-01010000b ^ 01011010b = 00001010b
-01010000b ^ 01011011b = 00001011b
-01010000b ^ 01011100b = 00001100b
-01010000b ^ 01011101b = 00001101b
-01010000b ^ 01011110b = 00001110b
-01010000b ^ 01011111b = 00001111b
-01010000b ^ 01100000b = 00110000b
-01010000b ^ 01100001b = 00110001b
-01010000b ^ 01100010b = 00110010b
-01010000b ^ 01100011b = 00110011b
-01010000b ^ 01100100b = 00110100b
-01010000b ^ 01100101b = 00110101b
-01010000b ^ 01100110b = 00110110b
-01010000b ^ 01100111b = 00110111b
-01010000b ^ 01101000b = 00111000b
-01010000b ^ 01101001b = 00111001b
-01010000b ^ 01101010b = 00111010b
-01010000b ^ 01101011b = 00111011b
-01010000b ^ 01101100b = 00111100b
-01010000b ^ 01101101b = 00111101b
-01010000b ^ 01101110b = 00111110b
-01010000b ^ 01101111b = 00111111b
-01010000b ^ 01110000b = 00100000b
-01010000b ^ 01110001b = 00100001b
-01010000b ^ 01110010b = 00100010b
-01010000b ^ 01110011b = 00100011b
-01010000b ^ 01110100b = 00100100b
-01010000b ^ 01110101b = 00100101b
-01010000b ^ 01110110b = 00100110b
-01010000b ^ 01110111b = 00100111b
-01010000b ^ 01111000b = 00101000b
-01010000b ^ 01111001b = 00101001b
-01010000b ^ 01111010b = 00101010b
-01010000b ^ 01111011b = 00101011b
-01010000b ^ 01111100b = 00101100b
-01010000b ^ 01111101b = 00101101b
-01010000b ^ 01111110b = 00101110b
-01010001b ^ 10000000b = 11010001b
-01010001b ^ 10000001b = 11010000b
-01010001b ^ 10000010b = 11010011b
-01010001b ^ 10000011b = 11010010b
-01010001b ^ 10000100b = 11010101b
-01010001b ^ 10000101b = 11010100b
-01010001b ^ 10000110b = 11010111b
-01010001b ^ 10000111b = 11010110b
-01010001b ^ 10001000b = 11011001b
-01010001b ^ 10001001b = 11011000b
-01010001b ^ 10001010b = 11011011b
-01010001b ^ 10001011b = 11011010b
-01010001b ^ 10001100b = 11011101b
-01010001b ^ 10001101b = 11011100b
-01010001b ^ 10001110b = 11011111b
-01010001b ^ 10001111b = 11011110b
-01010001b ^ 10010000b = 11000001b
-01010001b ^ 10010001b = 11000000b
-01010001b ^ 10010010b = 11000011b
-01010001b ^ 10010011b = 11000010b
-01010001b ^ 10010100b = 11000101b
-01010001b ^ 10010101b = 11000100b
-01010001b ^ 10010110b = 11000111b
-01010001b ^ 10010111b = 11000110b
-01010001b ^ 10011000b = 11001001b
-01010001b ^ 10011001b = 11001000b
-01010001b ^ 10011010b = 11001011b
-01010001b ^ 10011011b = 11001010b
-01010001b ^ 10011100b = 11001101b
-01010001b ^ 10011101b = 11001100b
-01010001b ^ 10011110b = 11001111b
-01010001b ^ 10011111b = 11001110b
-01010001b ^ 10100000b = 11110001b
-01010001b ^ 10100001b = 11110000b
-01010001b ^ 10100010b = 11110011b
-01010001b ^ 10100011b = 11110010b
-01010001b ^ 10100100b = 11110101b
-01010001b ^ 10100101b = 11110100b
-01010001b ^ 10100110b = 11110111b
-01010001b ^ 10100111b = 11110110b
-01010001b ^ 10101000b = 11111001b
-01010001b ^ 10101001b = 11111000b
-01010001b ^ 10101010b = 11111011b
-01010001b ^ 10101011b = 11111010b
-01010001b ^ 10101100b = 11111101b
-01010001b ^ 10101101b = 11111100b
-01010001b ^ 10101110b = 11111111b
-01010001b ^ 10101111b = 11111110b
-01010001b ^ 10110000b = 11100001b
-01010001b ^ 10110001b = 11100000b
-01010001b ^ 10110010b = 11100011b
-01010001b ^ 10110011b = 11100010b
-01010001b ^ 10110100b = 11100101b
-01010001b ^ 10110101b = 11100100b
-01010001b ^ 10110110b = 11100111b
-01010001b ^ 10110111b = 11100110b
-01010001b ^ 10111000b = 11101001b
-01010001b ^ 10111001b = 11101000b
-01010001b ^ 10111010b = 11101011b
-01010001b ^ 10111011b = 11101010b
-01010001b ^ 10111100b = 11101101b
-01010001b ^ 10111101b = 11101100b
-01010001b ^ 10111110b = 11101111b
-01010001b ^ 10111111b = 11101110b
-01010001b ^ 11000000b = 10010001b
-01010001b ^ 11000001b = 10010000b
-01010001b ^ 11000010b = 10010011b
-01010001b ^ 11000011b = 10010010b
-01010001b ^ 11000100b = 10010101b
-01010001b ^ 11000101b = 10010100b
-01010001b ^ 11000110b = 10010111b
-01010001b ^ 11000111b = 10010110b
-01010001b ^ 11001000b = 10011001b
-01010001b ^ 11001001b = 10011000b
-01010001b ^ 11001010b = 10011011b
-01010001b ^ 11001011b = 10011010b
-01010001b ^ 11001100b = 10011101b
-01010001b ^ 11001101b = 10011100b
-01010001b ^ 11001110b = 10011111b
-01010001b ^ 11001111b = 10011110b
-01010001b ^ 11010000b = 10000001b
-01010001b ^ 11010001b = 10000000b
-01010001b ^ 11010010b = 10000011b
-01010001b ^ 11010011b = 10000010b
-01010001b ^ 11010100b = 10000101b
-01010001b ^ 11010101b = 10000100b
-01010001b ^ 11010110b = 10000111b
-01010001b ^ 11010111b = 10000110b
-01010001b ^ 11011000b = 10001001b
-01010001b ^ 11011001b = 10001000b
-01010001b ^ 11011010b = 10001011b
-01010001b ^ 11011011b = 10001010b
-01010001b ^ 11011100b = 10001101b
-01010001b ^ 11011101b = 10001100b
-01010001b ^ 11011110b = 10001111b
-01010001b ^ 11011111b = 10001110b
-01010001b ^ 11100000b = 10110001b
-01010001b ^ 11100001b = 10110000b
-01010001b ^ 11100010b = 10110011b
-01010001b ^ 11100011b = 10110010b
-01010001b ^ 11100100b = 10110101b
-01010001b ^ 11100101b = 10110100b
-01010001b ^ 11100110b = 10110111b
-01010001b ^ 11100111b = 10110110b
-01010001b ^ 11101000b = 10111001b
-01010001b ^ 11101001b = 10111000b
-01010001b ^ 11101010b = 10111011b
-01010001b ^ 11101011b = 10111010b
-01010001b ^ 11101100b = 10111101b
-01010001b ^ 11101101b = 10111100b
-01010001b ^ 11101110b = 10111111b
-01010001b ^ 11101111b = 10111110b
-01010001b ^ 11110000b = 10100001b
-01010001b ^ 11110001b = 10100000b
-01010001b ^ 11110010b = 10100011b
-01010001b ^ 11110011b = 10100010b
-01010001b ^ 11110100b = 10100101b
-01010001b ^ 11110101b = 10100100b
-01010001b ^ 11110110b = 10100111b
-01010001b ^ 11110111b = 10100110b
-01010001b ^ 11111000b = 10101001b
-01010001b ^ 11111001b = 10101000b
-01010001b ^ 11111010b = 10101011b
-01010001b ^ 11111011b = 10101010b
-01010001b ^ 11111100b = 10101101b
-01010001b ^ 11111101b = 10101100b
-01010001b ^ 11111110b = 10101111b
-01010001b ^ 11111111b = 10101110b
-01010001b ^ 00000000b = 01010001b
-01010001b ^ 00000001b = 01010000b
-01010001b ^ 00000010b = 01010011b
-01010001b ^ 00000011b = 01010010b
-01010001b ^ 00000100b = 01010101b
-01010001b ^ 00000101b = 01010100b
-01010001b ^ 00000110b = 01010111b
-01010001b ^ 00000111b = 01010110b
-01010001b ^ 00001000b = 01011001b
-01010001b ^ 00001001b = 01011000b
-01010001b ^ 00001010b = 01011011b
-01010001b ^ 00001011b = 01011010b
-01010001b ^ 00001100b = 01011101b
-01010001b ^ 00001101b = 01011100b
-01010001b ^ 00001110b = 01011111b
-01010001b ^ 00001111b = 01011110b
-01010001b ^ 00010000b = 01000001b
-01010001b ^ 00010001b = 01000000b
-01010001b ^ 00010010b = 01000011b
-01010001b ^ 00010011b = 01000010b
-01010001b ^ 00010100b = 01000101b
-01010001b ^ 00010101b = 01000100b
-01010001b ^ 00010110b = 01000111b
-01010001b ^ 00010111b = 01000110b
-01010001b ^ 00011000b = 01001001b
-01010001b ^ 00011001b = 01001000b
-01010001b ^ 00011010b = 01001011b
-01010001b ^ 00011011b = 01001010b
-01010001b ^ 00011100b = 01001101b
-01010001b ^ 00011101b = 01001100b
-01010001b ^ 00011110b = 01001111b
-01010001b ^ 00011111b = 01001110b
-01010001b ^ 00100000b = 01110001b
-01010001b ^ 00100001b = 01110000b
-01010001b ^ 00100010b = 01110011b
-01010001b ^ 00100011b = 01110010b
-01010001b ^ 00100100b = 01110101b
-01010001b ^ 00100101b = 01110100b
-01010001b ^ 00100110b = 01110111b
-01010001b ^ 00100111b = 01110110b
-01010001b ^ 00101000b = 01111001b
-01010001b ^ 00101001b = 01111000b
-01010001b ^ 00101010b = 01111011b
-01010001b ^ 00101011b = 01111010b
-01010001b ^ 00101100b = 01111101b
-01010001b ^ 00101101b = 01111100b
-01010001b ^ 00101110b = 01111111b
-01010001b ^ 00101111b = 01111110b
-01010001b ^ 00110000b = 01100001b
-01010001b ^ 00110001b = 01100000b
-01010001b ^ 00110010b = 01100011b
-01010001b ^ 00110011b = 01100010b
-01010001b ^ 00110100b = 01100101b
-01010001b ^ 00110101b = 01100100b
-01010001b ^ 00110110b = 01100111b
-01010001b ^ 00110111b = 01100110b
-01010001b ^ 00111000b = 01101001b
-01010001b ^ 00111001b = 01101000b
-01010001b ^ 00111010b = 01101011b
-01010001b ^ 00111011b = 01101010b
-01010001b ^ 00111100b = 01101101b
-01010001b ^ 00111101b = 01101100b
-01010001b ^ 00111110b = 01101111b
-01010001b ^ 00111111b = 01101110b
-01010001b ^ 01000000b = 00010001b
-01010001b ^ 01000001b = 00010000b
-01010001b ^ 01000010b = 00010011b
-01010001b ^ 01000011b = 00010010b
-01010001b ^ 01000100b = 00010101b
-01010001b ^ 01000101b = 00010100b
-01010001b ^ 01000110b = 00010111b
-01010001b ^ 01000111b = 00010110b
-01010001b ^ 01001000b = 00011001b
-01010001b ^ 01001001b = 00011000b
-01010001b ^ 01001010b = 00011011b
-01010001b ^ 01001011b = 00011010b
-01010001b ^ 01001100b = 00011101b
-01010001b ^ 01001101b = 00011100b
-01010001b ^ 01001110b = 00011111b
-01010001b ^ 01001111b = 00011110b
-01010001b ^ 01010000b = 00000001b
-01010001b ^ 01010001b = 00000000b
-01010001b ^ 01010010b = 00000011b
-01010001b ^ 01010011b = 00000010b
-01010001b ^ 01010100b = 00000101b
-01010001b ^ 01010101b = 00000100b
-01010001b ^ 01010110b = 00000111b
-01010001b ^ 01010111b = 00000110b
-01010001b ^ 01011000b = 00001001b
-01010001b ^ 01011001b = 00001000b
-01010001b ^ 01011010b = 00001011b
-01010001b ^ 01011011b = 00001010b
-01010001b ^ 01011100b = 00001101b
-01010001b ^ 01011101b = 00001100b
-01010001b ^ 01011110b = 00001111b
-01010001b ^ 01011111b = 00001110b
-01010001b ^ 01100000b = 00110001b
-01010001b ^ 01100001b = 00110000b
-01010001b ^ 01100010b = 00110011b
-01010001b ^ 01100011b = 00110010b
-01010001b ^ 01100100b = 00110101b
-01010001b ^ 01100101b = 00110100b
-01010001b ^ 01100110b = 00110111b
-01010001b ^ 01100111b = 00110110b
-01010001b ^ 01101000b = 00111001b
-01010001b ^ 01101001b = 00111000b
-01010001b ^ 01101010b = 00111011b
-01010001b ^ 01101011b = 00111010b
-01010001b ^ 01101100b = 00111101b
-01010001b ^ 01101101b = 00111100b
-01010001b ^ 01101110b = 00111111b
-01010001b ^ 01101111b = 00111110b
-01010001b ^ 01110000b = 00100001b
-01010001b ^ 01110001b = 00100000b
-01010001b ^ 01110010b = 00100011b
-01010001b ^ 01110011b = 00100010b
-01010001b ^ 01110100b = 00100101b
-01010001b ^ 01110101b = 00100100b
-01010001b ^ 01110110b = 00100111b
-01010001b ^ 01110111b = 00100110b
-01010001b ^ 01111000b = 00101001b
-01010001b ^ 01111001b = 00101000b
-01010001b ^ 01111010b = 00101011b
-01010001b ^ 01111011b = 00101010b
-01010001b ^ 01111100b = 00101101b
-01010001b ^ 01111101b = 00101100b
-01010001b ^ 01111110b = 00101111b
-01010010b ^ 10000000b = 11010010b
-01010010b ^ 10000001b = 11010011b
-01010010b ^ 10000010b = 11010000b
-01010010b ^ 10000011b = 11010001b
-01010010b ^ 10000100b = 11010110b
-01010010b ^ 10000101b = 11010111b
-01010010b ^ 10000110b = 11010100b
-01010010b ^ 10000111b = 11010101b
-01010010b ^ 10001000b = 11011010b
-01010010b ^ 10001001b = 11011011b
-01010010b ^ 10001010b = 11011000b
-01010010b ^ 10001011b = 11011001b
-01010010b ^ 10001100b = 11011110b
-01010010b ^ 10001101b = 11011111b
-01010010b ^ 10001110b = 11011100b
-01010010b ^ 10001111b = 11011101b
-01010010b ^ 10010000b = 11000010b
-01010010b ^ 10010001b = 11000011b
-01010010b ^ 10010010b = 11000000b
-01010010b ^ 10010011b = 11000001b
-01010010b ^ 10010100b = 11000110b
-01010010b ^ 10010101b = 11000111b
-01010010b ^ 10010110b = 11000100b
-01010010b ^ 10010111b = 11000101b
-01010010b ^ 10011000b = 11001010b
-01010010b ^ 10011001b = 11001011b
-01010010b ^ 10011010b = 11001000b
-01010010b ^ 10011011b = 11001001b
-01010010b ^ 10011100b = 11001110b
-01010010b ^ 10011101b = 11001111b
-01010010b ^ 10011110b = 11001100b
-01010010b ^ 10011111b = 11001101b
-01010010b ^ 10100000b = 11110010b
-01010010b ^ 10100001b = 11110011b
-01010010b ^ 10100010b = 11110000b
-01010010b ^ 10100011b = 11110001b
-01010010b ^ 10100100b = 11110110b
-01010010b ^ 10100101b = 11110111b
-01010010b ^ 10100110b = 11110100b
-01010010b ^ 10100111b = 11110101b
-01010010b ^ 10101000b = 11111010b
-01010010b ^ 10101001b = 11111011b
-01010010b ^ 10101010b = 11111000b
-01010010b ^ 10101011b = 11111001b
-01010010b ^ 10101100b = 11111110b
-01010010b ^ 10101101b = 11111111b
-01010010b ^ 10101110b = 11111100b
-01010010b ^ 10101111b = 11111101b
-01010010b ^ 10110000b = 11100010b
-01010010b ^ 10110001b = 11100011b
-01010010b ^ 10110010b = 11100000b
-01010010b ^ 10110011b = 11100001b
-01010010b ^ 10110100b = 11100110b
-01010010b ^ 10110101b = 11100111b
-01010010b ^ 10110110b = 11100100b
-01010010b ^ 10110111b = 11100101b
-01010010b ^ 10111000b = 11101010b
-01010010b ^ 10111001b = 11101011b
-01010010b ^ 10111010b = 11101000b
-01010010b ^ 10111011b = 11101001b
-01010010b ^ 10111100b = 11101110b
-01010010b ^ 10111101b = 11101111b
-01010010b ^ 10111110b = 11101100b
-01010010b ^ 10111111b = 11101101b
-01010010b ^ 11000000b = 10010010b
-01010010b ^ 11000001b = 10010011b
-01010010b ^ 11000010b = 10010000b
-01010010b ^ 11000011b = 10010001b
-01010010b ^ 11000100b = 10010110b
-01010010b ^ 11000101b = 10010111b
-01010010b ^ 11000110b = 10010100b
-01010010b ^ 11000111b = 10010101b
-01010010b ^ 11001000b = 10011010b
-01010010b ^ 11001001b = 10011011b
-01010010b ^ 11001010b = 10011000b
-01010010b ^ 11001011b = 10011001b
-01010010b ^ 11001100b = 10011110b
-01010010b ^ 11001101b = 10011111b
-01010010b ^ 11001110b = 10011100b
-01010010b ^ 11001111b = 10011101b
-01010010b ^ 11010000b = 10000010b
-01010010b ^ 11010001b = 10000011b
-01010010b ^ 11010010b = 10000000b
-01010010b ^ 11010011b = 10000001b
-01010010b ^ 11010100b = 10000110b
-01010010b ^ 11010101b = 10000111b
-01010010b ^ 11010110b = 10000100b
-01010010b ^ 11010111b = 10000101b
-01010010b ^ 11011000b = 10001010b
-01010010b ^ 11011001b = 10001011b
-01010010b ^ 11011010b = 10001000b
-01010010b ^ 11011011b = 10001001b
-01010010b ^ 11011100b = 10001110b
-01010010b ^ 11011101b = 10001111b
-01010010b ^ 11011110b = 10001100b
-01010010b ^ 11011111b = 10001101b
-01010010b ^ 11100000b = 10110010b
-01010010b ^ 11100001b = 10110011b
-01010010b ^ 11100010b = 10110000b
-01010010b ^ 11100011b = 10110001b
-01010010b ^ 11100100b = 10110110b
-01010010b ^ 11100101b = 10110111b
-01010010b ^ 11100110b = 10110100b
-01010010b ^ 11100111b = 10110101b
-01010010b ^ 11101000b = 10111010b
-01010010b ^ 11101001b = 10111011b
-01010010b ^ 11101010b = 10111000b
-01010010b ^ 11101011b = 10111001b
-01010010b ^ 11101100b = 10111110b
-01010010b ^ 11101101b = 10111111b
-01010010b ^ 11101110b = 10111100b
-01010010b ^ 11101111b = 10111101b
-01010010b ^ 11110000b = 10100010b
-01010010b ^ 11110001b = 10100011b
-01010010b ^ 11110010b = 10100000b
-01010010b ^ 11110011b = 10100001b
-01010010b ^ 11110100b = 10100110b
-01010010b ^ 11110101b = 10100111b
-01010010b ^ 11110110b = 10100100b
-01010010b ^ 11110111b = 10100101b
-01010010b ^ 11111000b = 10101010b
-01010010b ^ 11111001b = 10101011b
-01010010b ^ 11111010b = 10101000b
-01010010b ^ 11111011b = 10101001b
-01010010b ^ 11111100b = 10101110b
-01010010b ^ 11111101b = 10101111b
-01010010b ^ 11111110b = 10101100b
-01010010b ^ 11111111b = 10101101b
-01010010b ^ 00000000b = 01010010b
-01010010b ^ 00000001b = 01010011b
-01010010b ^ 00000010b = 01010000b
-01010010b ^ 00000011b = 01010001b
-01010010b ^ 00000100b = 01010110b
-01010010b ^ 00000101b = 01010111b
-01010010b ^ 00000110b = 01010100b
-01010010b ^ 00000111b = 01010101b
-01010010b ^ 00001000b = 01011010b
-01010010b ^ 00001001b = 01011011b
-01010010b ^ 00001010b = 01011000b
-01010010b ^ 00001011b = 01011001b
-01010010b ^ 00001100b = 01011110b
-01010010b ^ 00001101b = 01011111b
-01010010b ^ 00001110b = 01011100b
-01010010b ^ 00001111b = 01011101b
-01010010b ^ 00010000b = 01000010b
-01010010b ^ 00010001b = 01000011b
-01010010b ^ 00010010b = 01000000b
-01010010b ^ 00010011b = 01000001b
-01010010b ^ 00010100b = 01000110b
-01010010b ^ 00010101b = 01000111b
-01010010b ^ 00010110b = 01000100b
-01010010b ^ 00010111b = 01000101b
-01010010b ^ 00011000b = 01001010b
-01010010b ^ 00011001b = 01001011b
-01010010b ^ 00011010b = 01001000b
-01010010b ^ 00011011b = 01001001b
-01010010b ^ 00011100b = 01001110b
-01010010b ^ 00011101b = 01001111b
-01010010b ^ 00011110b = 01001100b
-01010010b ^ 00011111b = 01001101b
-01010010b ^ 00100000b = 01110010b
-01010010b ^ 00100001b = 01110011b
-01010010b ^ 00100010b = 01110000b
-01010010b ^ 00100011b = 01110001b
-01010010b ^ 00100100b = 01110110b
-01010010b ^ 00100101b = 01110111b
-01010010b ^ 00100110b = 01110100b
-01010010b ^ 00100111b = 01110101b
-01010010b ^ 00101000b = 01111010b
-01010010b ^ 00101001b = 01111011b
-01010010b ^ 00101010b = 01111000b
-01010010b ^ 00101011b = 01111001b
-01010010b ^ 00101100b = 01111110b
-01010010b ^ 00101101b = 01111111b
-01010010b ^ 00101110b = 01111100b
-01010010b ^ 00101111b = 01111101b
-01010010b ^ 00110000b = 01100010b
-01010010b ^ 00110001b = 01100011b
-01010010b ^ 00110010b = 01100000b
-01010010b ^ 00110011b = 01100001b
-01010010b ^ 00110100b = 01100110b
-01010010b ^ 00110101b = 01100111b
-01010010b ^ 00110110b = 01100100b
-01010010b ^ 00110111b = 01100101b
-01010010b ^ 00111000b = 01101010b
-01010010b ^ 00111001b = 01101011b
-01010010b ^ 00111010b = 01101000b
-01010010b ^ 00111011b = 01101001b
-01010010b ^ 00111100b = 01101110b
-01010010b ^ 00111101b = 01101111b
-01010010b ^ 00111110b = 01101100b
-01010010b ^ 00111111b = 01101101b
-01010010b ^ 01000000b = 00010010b
-01010010b ^ 01000001b = 00010011b
-01010010b ^ 01000010b = 00010000b
-01010010b ^ 01000011b = 00010001b
-01010010b ^ 01000100b = 00010110b
-01010010b ^ 01000101b = 00010111b
-01010010b ^ 01000110b = 00010100b
-01010010b ^ 01000111b = 00010101b
-01010010b ^ 01001000b = 00011010b
-01010010b ^ 01001001b = 00011011b
-01010010b ^ 01001010b = 00011000b
-01010010b ^ 01001011b = 00011001b
-01010010b ^ 01001100b = 00011110b
-01010010b ^ 01001101b = 00011111b
-01010010b ^ 01001110b = 00011100b
-01010010b ^ 01001111b = 00011101b
-01010010b ^ 01010000b = 00000010b
-01010010b ^ 01010001b = 00000011b
-01010010b ^ 01010010b = 00000000b
-01010010b ^ 01010011b = 00000001b
-01010010b ^ 01010100b = 00000110b
-01010010b ^ 01010101b = 00000111b
-01010010b ^ 01010110b = 00000100b
-01010010b ^ 01010111b = 00000101b
-01010010b ^ 01011000b = 00001010b
-01010010b ^ 01011001b = 00001011b
-01010010b ^ 01011010b = 00001000b
-01010010b ^ 01011011b = 00001001b
-01010010b ^ 01011100b = 00001110b
-01010010b ^ 01011101b = 00001111b
-01010010b ^ 01011110b = 00001100b
-01010010b ^ 01011111b = 00001101b
-01010010b ^ 01100000b = 00110010b
-01010010b ^ 01100001b = 00110011b
-01010010b ^ 01100010b = 00110000b
-01010010b ^ 01100011b = 00110001b
-01010010b ^ 01100100b = 00110110b
-01010010b ^ 01100101b = 00110111b
-01010010b ^ 01100110b = 00110100b
-01010010b ^ 01100111b = 00110101b
-01010010b ^ 01101000b = 00111010b
-01010010b ^ 01101001b = 00111011b
-01010010b ^ 01101010b = 00111000b
-01010010b ^ 01101011b = 00111001b
-01010010b ^ 01101100b = 00111110b
-01010010b ^ 01101101b = 00111111b
-01010010b ^ 01101110b = 00111100b
-01010010b ^ 01101111b = 00111101b
-01010010b ^ 01110000b = 00100010b
-01010010b ^ 01110001b = 00100011b
-01010010b ^ 01110010b = 00100000b
-01010010b ^ 01110011b = 00100001b
-01010010b ^ 01110100b = 00100110b
-01010010b ^ 01110101b = 00100111b
-01010010b ^ 01110110b = 00100100b
-01010010b ^ 01110111b = 00100101b
-01010010b ^ 01111000b = 00101010b
-01010010b ^ 01111001b = 00101011b
-01010010b ^ 01111010b = 00101000b
-01010010b ^ 01111011b = 00101001b
-01010010b ^ 01111100b = 00101110b
-01010010b ^ 01111101b = 00101111b
-01010010b ^ 01111110b = 00101100b
-01010011b ^ 10000000b = 11010011b
-01010011b ^ 10000001b = 11010010b
-01010011b ^ 10000010b = 11010001b
-01010011b ^ 10000011b = 11010000b
-01010011b ^ 10000100b = 11010111b
-01010011b ^ 10000101b = 11010110b
-01010011b ^ 10000110b = 11010101b
-01010011b ^ 10000111b = 11010100b
-01010011b ^ 10001000b = 11011011b
-01010011b ^ 10001001b = 11011010b
-01010011b ^ 10001010b = 11011001b
-01010011b ^ 10001011b = 11011000b
-01010011b ^ 10001100b = 11011111b
-01010011b ^ 10001101b = 11011110b
-01010011b ^ 10001110b = 11011101b
-01010011b ^ 10001111b = 11011100b
-01010011b ^ 10010000b = 11000011b
-01010011b ^ 10010001b = 11000010b
-01010011b ^ 10010010b = 11000001b
-01010011b ^ 10010011b = 11000000b
-01010011b ^ 10010100b = 11000111b
-01010011b ^ 10010101b = 11000110b
-01010011b ^ 10010110b = 11000101b
-01010011b ^ 10010111b = 11000100b
-01010011b ^ 10011000b = 11001011b
-01010011b ^ 10011001b = 11001010b
-01010011b ^ 10011010b = 11001001b
-01010011b ^ 10011011b = 11001000b
-01010011b ^ 10011100b = 11001111b
-01010011b ^ 10011101b = 11001110b
-01010011b ^ 10011110b = 11001101b
-01010011b ^ 10011111b = 11001100b
-01010011b ^ 10100000b = 11110011b
-01010011b ^ 10100001b = 11110010b
-01010011b ^ 10100010b = 11110001b
-01010011b ^ 10100011b = 11110000b
-01010011b ^ 10100100b = 11110111b
-01010011b ^ 10100101b = 11110110b
-01010011b ^ 10100110b = 11110101b
-01010011b ^ 10100111b = 11110100b
-01010011b ^ 10101000b = 11111011b
-01010011b ^ 10101001b = 11111010b
-01010011b ^ 10101010b = 11111001b
-01010011b ^ 10101011b = 11111000b
-01010011b ^ 10101100b = 11111111b
-01010011b ^ 10101101b = 11111110b
-01010011b ^ 10101110b = 11111101b
-01010011b ^ 10101111b = 11111100b
-01010011b ^ 10110000b = 11100011b
-01010011b ^ 10110001b = 11100010b
-01010011b ^ 10110010b = 11100001b
-01010011b ^ 10110011b = 11100000b
-01010011b ^ 10110100b = 11100111b
-01010011b ^ 10110101b = 11100110b
-01010011b ^ 10110110b = 11100101b
-01010011b ^ 10110111b = 11100100b
-01010011b ^ 10111000b = 11101011b
-01010011b ^ 10111001b = 11101010b
-01010011b ^ 10111010b = 11101001b
-01010011b ^ 10111011b = 11101000b
-01010011b ^ 10111100b = 11101111b
-01010011b ^ 10111101b = 11101110b
-01010011b ^ 10111110b = 11101101b
-01010011b ^ 10111111b = 11101100b
-01010011b ^ 11000000b = 10010011b
-01010011b ^ 11000001b = 10010010b
-01010011b ^ 11000010b = 10010001b
-01010011b ^ 11000011b = 10010000b
-01010011b ^ 11000100b = 10010111b
-01010011b ^ 11000101b = 10010110b
-01010011b ^ 11000110b = 10010101b
-01010011b ^ 11000111b = 10010100b
-01010011b ^ 11001000b = 10011011b
-01010011b ^ 11001001b = 10011010b
-01010011b ^ 11001010b = 10011001b
-01010011b ^ 11001011b = 10011000b
-01010011b ^ 11001100b = 10011111b
-01010011b ^ 11001101b = 10011110b
-01010011b ^ 11001110b = 10011101b
-01010011b ^ 11001111b = 10011100b
-01010011b ^ 11010000b = 10000011b
-01010011b ^ 11010001b = 10000010b
-01010011b ^ 11010010b = 10000001b
-01010011b ^ 11010011b = 10000000b
-01010011b ^ 11010100b = 10000111b
-01010011b ^ 11010101b = 10000110b
-01010011b ^ 11010110b = 10000101b
-01010011b ^ 11010111b = 10000100b
-01010011b ^ 11011000b = 10001011b
-01010011b ^ 11011001b = 10001010b
-01010011b ^ 11011010b = 10001001b
-01010011b ^ 11011011b = 10001000b
-01010011b ^ 11011100b = 10001111b
-01010011b ^ 11011101b = 10001110b
-01010011b ^ 11011110b = 10001101b
-01010011b ^ 11011111b = 10001100b
-01010011b ^ 11100000b = 10110011b
-01010011b ^ 11100001b = 10110010b
-01010011b ^ 11100010b = 10110001b
-01010011b ^ 11100011b = 10110000b
-01010011b ^ 11100100b = 10110111b
-01010011b ^ 11100101b = 10110110b
-01010011b ^ 11100110b = 10110101b
-01010011b ^ 11100111b = 10110100b
-01010011b ^ 11101000b = 10111011b
-01010011b ^ 11101001b = 10111010b
-01010011b ^ 11101010b = 10111001b
-01010011b ^ 11101011b = 10111000b
-01010011b ^ 11101100b = 10111111b
-01010011b ^ 11101101b = 10111110b
-01010011b ^ 11101110b = 10111101b
-01010011b ^ 11101111b = 10111100b
-01010011b ^ 11110000b = 10100011b
-01010011b ^ 11110001b = 10100010b
-01010011b ^ 11110010b = 10100001b
-01010011b ^ 11110011b = 10100000b
-01010011b ^ 11110100b = 10100111b
-01010011b ^ 11110101b = 10100110b
-01010011b ^ 11110110b = 10100101b
-01010011b ^ 11110111b = 10100100b
-01010011b ^ 11111000b = 10101011b
-01010011b ^ 11111001b = 10101010b
-01010011b ^ 11111010b = 10101001b
-01010011b ^ 11111011b = 10101000b
-01010011b ^ 11111100b = 10101111b
-01010011b ^ 11111101b = 10101110b
-01010011b ^ 11111110b = 10101101b
-01010011b ^ 11111111b = 10101100b
-01010011b ^ 00000000b = 01010011b
-01010011b ^ 00000001b = 01010010b
-01010011b ^ 00000010b = 01010001b
-01010011b ^ 00000011b = 01010000b
-01010011b ^ 00000100b = 01010111b
-01010011b ^ 00000101b = 01010110b
-01010011b ^ 00000110b = 01010101b
-01010011b ^ 00000111b = 01010100b
-01010011b ^ 00001000b = 01011011b
-01010011b ^ 00001001b = 01011010b
-01010011b ^ 00001010b = 01011001b
-01010011b ^ 00001011b = 01011000b
-01010011b ^ 00001100b = 01011111b
-01010011b ^ 00001101b = 01011110b
-01010011b ^ 00001110b = 01011101b
-01010011b ^ 00001111b = 01011100b
-01010011b ^ 00010000b = 01000011b
-01010011b ^ 00010001b = 01000010b
-01010011b ^ 00010010b = 01000001b
-01010011b ^ 00010011b = 01000000b
-01010011b ^ 00010100b = 01000111b
-01010011b ^ 00010101b = 01000110b
-01010011b ^ 00010110b = 01000101b
-01010011b ^ 00010111b = 01000100b
-01010011b ^ 00011000b = 01001011b
-01010011b ^ 00011001b = 01001010b
-01010011b ^ 00011010b = 01001001b
-01010011b ^ 00011011b = 01001000b
-01010011b ^ 00011100b = 01001111b
-01010011b ^ 00011101b = 01001110b
-01010011b ^ 00011110b = 01001101b
-01010011b ^ 00011111b = 01001100b
-01010011b ^ 00100000b = 01110011b
-01010011b ^ 00100001b = 01110010b
-01010011b ^ 00100010b = 01110001b
-01010011b ^ 00100011b = 01110000b
-01010011b ^ 00100100b = 01110111b
-01010011b ^ 00100101b = 01110110b
-01010011b ^ 00100110b = 01110101b
-01010011b ^ 00100111b = 01110100b
-01010011b ^ 00101000b = 01111011b
-01010011b ^ 00101001b = 01111010b
-01010011b ^ 00101010b = 01111001b
-01010011b ^ 00101011b = 01111000b
-01010011b ^ 00101100b = 01111111b
-01010011b ^ 00101101b = 01111110b
-01010011b ^ 00101110b = 01111101b
-01010011b ^ 00101111b = 01111100b
-01010011b ^ 00110000b = 01100011b
-01010011b ^ 00110001b = 01100010b
-01010011b ^ 00110010b = 01100001b
-01010011b ^ 00110011b = 01100000b
-01010011b ^ 00110100b = 01100111b
-01010011b ^ 00110101b = 01100110b
-01010011b ^ 00110110b = 01100101b
-01010011b ^ 00110111b = 01100100b
-01010011b ^ 00111000b = 01101011b
-01010011b ^ 00111001b = 01101010b
-01010011b ^ 00111010b = 01101001b
-01010011b ^ 00111011b = 01101000b
-01010011b ^ 00111100b = 01101111b
-01010011b ^ 00111101b = 01101110b
-01010011b ^ 00111110b = 01101101b
-01010011b ^ 00111111b = 01101100b
-01010011b ^ 01000000b = 00010011b
-01010011b ^ 01000001b = 00010010b
-01010011b ^ 01000010b = 00010001b
-01010011b ^ 01000011b = 00010000b
-01010011b ^ 01000100b = 00010111b
-01010011b ^ 01000101b = 00010110b
-01010011b ^ 01000110b = 00010101b
-01010011b ^ 01000111b = 00010100b
-01010011b ^ 01001000b = 00011011b
-01010011b ^ 01001001b = 00011010b
-01010011b ^ 01001010b = 00011001b
-01010011b ^ 01001011b = 00011000b
-01010011b ^ 01001100b = 00011111b
-01010011b ^ 01001101b = 00011110b
-01010011b ^ 01001110b = 00011101b
-01010011b ^ 01001111b = 00011100b
-01010011b ^ 01010000b = 00000011b
-01010011b ^ 01010001b = 00000010b
-01010011b ^ 01010010b = 00000001b
-01010011b ^ 01010011b = 00000000b
-01010011b ^ 01010100b = 00000111b
-01010011b ^ 01010101b = 00000110b
-01010011b ^ 01010110b = 00000101b
-01010011b ^ 01010111b = 00000100b
-01010011b ^ 01011000b = 00001011b
-01010011b ^ 01011001b = 00001010b
-01010011b ^ 01011010b = 00001001b
-01010011b ^ 01011011b = 00001000b
-01010011b ^ 01011100b = 00001111b
-01010011b ^ 01011101b = 00001110b
-01010011b ^ 01011110b = 00001101b
-01010011b ^ 01011111b = 00001100b
-01010011b ^ 01100000b = 00110011b
-01010011b ^ 01100001b = 00110010b
-01010011b ^ 01100010b = 00110001b
-01010011b ^ 01100011b = 00110000b
-01010011b ^ 01100100b = 00110111b
-01010011b ^ 01100101b = 00110110b
-01010011b ^ 01100110b = 00110101b
-01010011b ^ 01100111b = 00110100b
-01010011b ^ 01101000b = 00111011b
-01010011b ^ 01101001b = 00111010b
-01010011b ^ 01101010b = 00111001b
-01010011b ^ 01101011b = 00111000b
-01010011b ^ 01101100b = 00111111b
-01010011b ^ 01101101b = 00111110b
-01010011b ^ 01101110b = 00111101b
-01010011b ^ 01101111b = 00111100b
-01010011b ^ 01110000b = 00100011b
-01010011b ^ 01110001b = 00100010b
-01010011b ^ 01110010b = 00100001b
-01010011b ^ 01110011b = 00100000b
-01010011b ^ 01110100b = 00100111b
-01010011b ^ 01110101b = 00100110b
-01010011b ^ 01110110b = 00100101b
-01010011b ^ 01110111b = 00100100b
-01010011b ^ 01111000b = 00101011b
-01010011b ^ 01111001b = 00101010b
-01010011b ^ 01111010b = 00101001b
-01010011b ^ 01111011b = 00101000b
-01010011b ^ 01111100b = 00101111b
-01010011b ^ 01111101b = 00101110b
-01010011b ^ 01111110b = 00101101b
-01010100b ^ 10000000b = 11010100b
-01010100b ^ 10000001b = 11010101b
-01010100b ^ 10000010b = 11010110b
-01010100b ^ 10000011b = 11010111b
-01010100b ^ 10000100b = 11010000b
-01010100b ^ 10000101b = 11010001b
-01010100b ^ 10000110b = 11010010b
-01010100b ^ 10000111b = 11010011b
-01010100b ^ 10001000b = 11011100b
-01010100b ^ 10001001b = 11011101b
-01010100b ^ 10001010b = 11011110b
-01010100b ^ 10001011b = 11011111b
-01010100b ^ 10001100b = 11011000b
-01010100b ^ 10001101b = 11011001b
-01010100b ^ 10001110b = 11011010b
-01010100b ^ 10001111b = 11011011b
-01010100b ^ 10010000b = 11000100b
-01010100b ^ 10010001b = 11000101b
-01010100b ^ 10010010b = 11000110b
-01010100b ^ 10010011b = 11000111b
-01010100b ^ 10010100b = 11000000b
-01010100b ^ 10010101b = 11000001b
-01010100b ^ 10010110b = 11000010b
-01010100b ^ 10010111b = 11000011b
-01010100b ^ 10011000b = 11001100b
-01010100b ^ 10011001b = 11001101b
-01010100b ^ 10011010b = 11001110b
-01010100b ^ 10011011b = 11001111b
-01010100b ^ 10011100b = 11001000b
-01010100b ^ 10011101b = 11001001b
-01010100b ^ 10011110b = 11001010b
-01010100b ^ 10011111b = 11001011b
-01010100b ^ 10100000b = 11110100b
-01010100b ^ 10100001b = 11110101b
-01010100b ^ 10100010b = 11110110b
-01010100b ^ 10100011b = 11110111b
-01010100b ^ 10100100b = 11110000b
-01010100b ^ 10100101b = 11110001b
-01010100b ^ 10100110b = 11110010b
-01010100b ^ 10100111b = 11110011b
-01010100b ^ 10101000b = 11111100b
-01010100b ^ 10101001b = 11111101b
-01010100b ^ 10101010b = 11111110b
-01010100b ^ 10101011b = 11111111b
-01010100b ^ 10101100b = 11111000b
-01010100b ^ 10101101b = 11111001b
-01010100b ^ 10101110b = 11111010b
-01010100b ^ 10101111b = 11111011b
-01010100b ^ 10110000b = 11100100b
-01010100b ^ 10110001b = 11100101b
-01010100b ^ 10110010b = 11100110b
-01010100b ^ 10110011b = 11100111b
-01010100b ^ 10110100b = 11100000b
-01010100b ^ 10110101b = 11100001b
-01010100b ^ 10110110b = 11100010b
-01010100b ^ 10110111b = 11100011b
-01010100b ^ 10111000b = 11101100b
-01010100b ^ 10111001b = 11101101b
-01010100b ^ 10111010b = 11101110b
-01010100b ^ 10111011b = 11101111b
-01010100b ^ 10111100b = 11101000b
-01010100b ^ 10111101b = 11101001b
-01010100b ^ 10111110b = 11101010b
-01010100b ^ 10111111b = 11101011b
-01010100b ^ 11000000b = 10010100b
-01010100b ^ 11000001b = 10010101b
-01010100b ^ 11000010b = 10010110b
-01010100b ^ 11000011b = 10010111b
-01010100b ^ 11000100b = 10010000b
-01010100b ^ 11000101b = 10010001b
-01010100b ^ 11000110b = 10010010b
-01010100b ^ 11000111b = 10010011b
-01010100b ^ 11001000b = 10011100b
-01010100b ^ 11001001b = 10011101b
-01010100b ^ 11001010b = 10011110b
-01010100b ^ 11001011b = 10011111b
-01010100b ^ 11001100b = 10011000b
-01010100b ^ 11001101b = 10011001b
-01010100b ^ 11001110b = 10011010b
-01010100b ^ 11001111b = 10011011b
-01010100b ^ 11010000b = 10000100b
-01010100b ^ 11010001b = 10000101b
-01010100b ^ 11010010b = 10000110b
-01010100b ^ 11010011b = 10000111b
-01010100b ^ 11010100b = 10000000b
-01010100b ^ 11010101b = 10000001b
-01010100b ^ 11010110b = 10000010b
-01010100b ^ 11010111b = 10000011b
-01010100b ^ 11011000b = 10001100b
-01010100b ^ 11011001b = 10001101b
-01010100b ^ 11011010b = 10001110b
-01010100b ^ 11011011b = 10001111b
-01010100b ^ 11011100b = 10001000b
-01010100b ^ 11011101b = 10001001b
-01010100b ^ 11011110b = 10001010b
-01010100b ^ 11011111b = 10001011b
-01010100b ^ 11100000b = 10110100b
-01010100b ^ 11100001b = 10110101b
-01010100b ^ 11100010b = 10110110b
-01010100b ^ 11100011b = 10110111b
-01010100b ^ 11100100b = 10110000b
-01010100b ^ 11100101b = 10110001b
-01010100b ^ 11100110b = 10110010b
-01010100b ^ 11100111b = 10110011b
-01010100b ^ 11101000b = 10111100b
-01010100b ^ 11101001b = 10111101b
-01010100b ^ 11101010b = 10111110b
-01010100b ^ 11101011b = 10111111b
-01010100b ^ 11101100b = 10111000b
-01010100b ^ 11101101b = 10111001b
-01010100b ^ 11101110b = 10111010b
-01010100b ^ 11101111b = 10111011b
-01010100b ^ 11110000b = 10100100b
-01010100b ^ 11110001b = 10100101b
-01010100b ^ 11110010b = 10100110b
-01010100b ^ 11110011b = 10100111b
-01010100b ^ 11110100b = 10100000b
-01010100b ^ 11110101b = 10100001b
-01010100b ^ 11110110b = 10100010b
-01010100b ^ 11110111b = 10100011b
-01010100b ^ 11111000b = 10101100b
-01010100b ^ 11111001b = 10101101b
-01010100b ^ 11111010b = 10101110b
-01010100b ^ 11111011b = 10101111b
-01010100b ^ 11111100b = 10101000b
-01010100b ^ 11111101b = 10101001b
-01010100b ^ 11111110b = 10101010b
-01010100b ^ 11111111b = 10101011b
-01010100b ^ 00000000b = 01010100b
-01010100b ^ 00000001b = 01010101b
-01010100b ^ 00000010b = 01010110b
-01010100b ^ 00000011b = 01010111b
-01010100b ^ 00000100b = 01010000b
-01010100b ^ 00000101b = 01010001b
-01010100b ^ 00000110b = 01010010b
-01010100b ^ 00000111b = 01010011b
-01010100b ^ 00001000b = 01011100b
-01010100b ^ 00001001b = 01011101b
-01010100b ^ 00001010b = 01011110b
-01010100b ^ 00001011b = 01011111b
-01010100b ^ 00001100b = 01011000b
-01010100b ^ 00001101b = 01011001b
-01010100b ^ 00001110b = 01011010b
-01010100b ^ 00001111b = 01011011b
-01010100b ^ 00010000b = 01000100b
-01010100b ^ 00010001b = 01000101b
-01010100b ^ 00010010b = 01000110b
-01010100b ^ 00010011b = 01000111b
-01010100b ^ 00010100b = 01000000b
-01010100b ^ 00010101b = 01000001b
-01010100b ^ 00010110b = 01000010b
-01010100b ^ 00010111b = 01000011b
-01010100b ^ 00011000b = 01001100b
-01010100b ^ 00011001b = 01001101b
-01010100b ^ 00011010b = 01001110b
-01010100b ^ 00011011b = 01001111b
-01010100b ^ 00011100b = 01001000b
-01010100b ^ 00011101b = 01001001b
-01010100b ^ 00011110b = 01001010b
-01010100b ^ 00011111b = 01001011b
-01010100b ^ 00100000b = 01110100b
-01010100b ^ 00100001b = 01110101b
-01010100b ^ 00100010b = 01110110b
-01010100b ^ 00100011b = 01110111b
-01010100b ^ 00100100b = 01110000b
-01010100b ^ 00100101b = 01110001b
-01010100b ^ 00100110b = 01110010b
-01010100b ^ 00100111b = 01110011b
-01010100b ^ 00101000b = 01111100b
-01010100b ^ 00101001b = 01111101b
-01010100b ^ 00101010b = 01111110b
-01010100b ^ 00101011b = 01111111b
-01010100b ^ 00101100b = 01111000b
-01010100b ^ 00101101b = 01111001b
-01010100b ^ 00101110b = 01111010b
-01010100b ^ 00101111b = 01111011b
-01010100b ^ 00110000b = 01100100b
-01010100b ^ 00110001b = 01100101b
-01010100b ^ 00110010b = 01100110b
-01010100b ^ 00110011b = 01100111b
-01010100b ^ 00110100b = 01100000b
-01010100b ^ 00110101b = 01100001b
-01010100b ^ 00110110b = 01100010b
-01010100b ^ 00110111b = 01100011b
-01010100b ^ 00111000b = 01101100b
-01010100b ^ 00111001b = 01101101b
-01010100b ^ 00111010b = 01101110b
-01010100b ^ 00111011b = 01101111b
-01010100b ^ 00111100b = 01101000b
-01010100b ^ 00111101b = 01101001b
-01010100b ^ 00111110b = 01101010b
-01010100b ^ 00111111b = 01101011b
-01010100b ^ 01000000b = 00010100b
-01010100b ^ 01000001b = 00010101b
-01010100b ^ 01000010b = 00010110b
-01010100b ^ 01000011b = 00010111b
-01010100b ^ 01000100b = 00010000b
-01010100b ^ 01000101b = 00010001b
-01010100b ^ 01000110b = 00010010b
-01010100b ^ 01000111b = 00010011b
-01010100b ^ 01001000b = 00011100b
-01010100b ^ 01001001b = 00011101b
-01010100b ^ 01001010b = 00011110b
-01010100b ^ 01001011b = 00011111b
-01010100b ^ 01001100b = 00011000b
-01010100b ^ 01001101b = 00011001b
-01010100b ^ 01001110b = 00011010b
-01010100b ^ 01001111b = 00011011b
-01010100b ^ 01010000b = 00000100b
-01010100b ^ 01010001b = 00000101b
-01010100b ^ 01010010b = 00000110b
-01010100b ^ 01010011b = 00000111b
-01010100b ^ 01010100b = 00000000b
-01010100b ^ 01010101b = 00000001b
-01010100b ^ 01010110b = 00000010b
-01010100b ^ 01010111b = 00000011b
-01010100b ^ 01011000b = 00001100b
-01010100b ^ 01011001b = 00001101b
-01010100b ^ 01011010b = 00001110b
-01010100b ^ 01011011b = 00001111b
-01010100b ^ 01011100b = 00001000b
-01010100b ^ 01011101b = 00001001b
-01010100b ^ 01011110b = 00001010b
-01010100b ^ 01011111b = 00001011b
-01010100b ^ 01100000b = 00110100b
-01010100b ^ 01100001b = 00110101b
-01010100b ^ 01100010b = 00110110b
-01010100b ^ 01100011b = 00110111b
-01010100b ^ 01100100b = 00110000b
-01010100b ^ 01100101b = 00110001b
-01010100b ^ 01100110b = 00110010b
-01010100b ^ 01100111b = 00110011b
-01010100b ^ 01101000b = 00111100b
-01010100b ^ 01101001b = 00111101b
-01010100b ^ 01101010b = 00111110b
-01010100b ^ 01101011b = 00111111b
-01010100b ^ 01101100b = 00111000b
-01010100b ^ 01101101b = 00111001b
-01010100b ^ 01101110b = 00111010b
-01010100b ^ 01101111b = 00111011b
-01010100b ^ 01110000b = 00100100b
-01010100b ^ 01110001b = 00100101b
-01010100b ^ 01110010b = 00100110b
-01010100b ^ 01110011b = 00100111b
-01010100b ^ 01110100b = 00100000b
-01010100b ^ 01110101b = 00100001b
-01010100b ^ 01110110b = 00100010b
-01010100b ^ 01110111b = 00100011b
-01010100b ^ 01111000b = 00101100b
-01010100b ^ 01111001b = 00101101b
-01010100b ^ 01111010b = 00101110b
-01010100b ^ 01111011b = 00101111b
-01010100b ^ 01111100b = 00101000b
-01010100b ^ 01111101b = 00101001b
-01010100b ^ 01111110b = 00101010b
-01010101b ^ 10000000b = 11010101b
-01010101b ^ 10000001b = 11010100b
-01010101b ^ 10000010b = 11010111b
-01010101b ^ 10000011b = 11010110b
-01010101b ^ 10000100b = 11010001b
-01010101b ^ 10000101b = 11010000b
-01010101b ^ 10000110b = 11010011b
-01010101b ^ 10000111b = 11010010b
-01010101b ^ 10001000b = 11011101b
-01010101b ^ 10001001b = 11011100b
-01010101b ^ 10001010b = 11011111b
-01010101b ^ 10001011b = 11011110b
-01010101b ^ 10001100b = 11011001b
-01010101b ^ 10001101b = 11011000b
-01010101b ^ 10001110b = 11011011b
-01010101b ^ 10001111b = 11011010b
-01010101b ^ 10010000b = 11000101b
-01010101b ^ 10010001b = 11000100b
-01010101b ^ 10010010b = 11000111b
-01010101b ^ 10010011b = 11000110b
-01010101b ^ 10010100b = 11000001b
-01010101b ^ 10010101b = 11000000b
-01010101b ^ 10010110b = 11000011b
-01010101b ^ 10010111b = 11000010b
-01010101b ^ 10011000b = 11001101b
-01010101b ^ 10011001b = 11001100b
-01010101b ^ 10011010b = 11001111b
-01010101b ^ 10011011b = 11001110b
-01010101b ^ 10011100b = 11001001b
-01010101b ^ 10011101b = 11001000b
-01010101b ^ 10011110b = 11001011b
-01010101b ^ 10011111b = 11001010b
-01010101b ^ 10100000b = 11110101b
-01010101b ^ 10100001b = 11110100b
-01010101b ^ 10100010b = 11110111b
-01010101b ^ 10100011b = 11110110b
-01010101b ^ 10100100b = 11110001b
-01010101b ^ 10100101b = 11110000b
-01010101b ^ 10100110b = 11110011b
-01010101b ^ 10100111b = 11110010b
-01010101b ^ 10101000b = 11111101b
-01010101b ^ 10101001b = 11111100b
-01010101b ^ 10101010b = 11111111b
-01010101b ^ 10101011b = 11111110b
-01010101b ^ 10101100b = 11111001b
-01010101b ^ 10101101b = 11111000b
-01010101b ^ 10101110b = 11111011b
-01010101b ^ 10101111b = 11111010b
-01010101b ^ 10110000b = 11100101b
-01010101b ^ 10110001b = 11100100b
-01010101b ^ 10110010b = 11100111b
-01010101b ^ 10110011b = 11100110b
-01010101b ^ 10110100b = 11100001b
-01010101b ^ 10110101b = 11100000b
-01010101b ^ 10110110b = 11100011b
-01010101b ^ 10110111b = 11100010b
-01010101b ^ 10111000b = 11101101b
-01010101b ^ 10111001b = 11101100b
-01010101b ^ 10111010b = 11101111b
-01010101b ^ 10111011b = 11101110b
-01010101b ^ 10111100b = 11101001b
-01010101b ^ 10111101b = 11101000b
-01010101b ^ 10111110b = 11101011b
-01010101b ^ 10111111b = 11101010b
-01010101b ^ 11000000b = 10010101b
-01010101b ^ 11000001b = 10010100b
-01010101b ^ 11000010b = 10010111b
-01010101b ^ 11000011b = 10010110b
-01010101b ^ 11000100b = 10010001b
-01010101b ^ 11000101b = 10010000b
-01010101b ^ 11000110b = 10010011b
-01010101b ^ 11000111b = 10010010b
-01010101b ^ 11001000b = 10011101b
-01010101b ^ 11001001b = 10011100b
-01010101b ^ 11001010b = 10011111b
-01010101b ^ 11001011b = 10011110b
-01010101b ^ 11001100b = 10011001b
-01010101b ^ 11001101b = 10011000b
-01010101b ^ 11001110b = 10011011b
-01010101b ^ 11001111b = 10011010b
-01010101b ^ 11010000b = 10000101b
-01010101b ^ 11010001b = 10000100b
-01010101b ^ 11010010b = 10000111b
-01010101b ^ 11010011b = 10000110b
-01010101b ^ 11010100b = 10000001b
-01010101b ^ 11010101b = 10000000b
-01010101b ^ 11010110b = 10000011b
-01010101b ^ 11010111b = 10000010b
-01010101b ^ 11011000b = 10001101b
-01010101b ^ 11011001b = 10001100b
-01010101b ^ 11011010b = 10001111b
-01010101b ^ 11011011b = 10001110b
-01010101b ^ 11011100b = 10001001b
-01010101b ^ 11011101b = 10001000b
-01010101b ^ 11011110b = 10001011b
-01010101b ^ 11011111b = 10001010b
-01010101b ^ 11100000b = 10110101b
-01010101b ^ 11100001b = 10110100b
-01010101b ^ 11100010b = 10110111b
-01010101b ^ 11100011b = 10110110b
-01010101b ^ 11100100b = 10110001b
-01010101b ^ 11100101b = 10110000b
-01010101b ^ 11100110b = 10110011b
-01010101b ^ 11100111b = 10110010b
-01010101b ^ 11101000b = 10111101b
-01010101b ^ 11101001b = 10111100b
-01010101b ^ 11101010b = 10111111b
-01010101b ^ 11101011b = 10111110b
-01010101b ^ 11101100b = 10111001b
-01010101b ^ 11101101b = 10111000b
-01010101b ^ 11101110b = 10111011b
-01010101b ^ 11101111b = 10111010b
-01010101b ^ 11110000b = 10100101b
-01010101b ^ 11110001b = 10100100b
-01010101b ^ 11110010b = 10100111b
-01010101b ^ 11110011b = 10100110b
-01010101b ^ 11110100b = 10100001b
-01010101b ^ 11110101b = 10100000b
-01010101b ^ 11110110b = 10100011b
-01010101b ^ 11110111b = 10100010b
-01010101b ^ 11111000b = 10101101b
-01010101b ^ 11111001b = 10101100b
-01010101b ^ 11111010b = 10101111b
-01010101b ^ 11111011b = 10101110b
-01010101b ^ 11111100b = 10101001b
-01010101b ^ 11111101b = 10101000b
-01010101b ^ 11111110b = 10101011b
-01010101b ^ 11111111b = 10101010b
-01010101b ^ 00000000b = 01010101b
-01010101b ^ 00000001b = 01010100b
-01010101b ^ 00000010b = 01010111b
-01010101b ^ 00000011b = 01010110b
-01010101b ^ 00000100b = 01010001b
-01010101b ^ 00000101b = 01010000b
-01010101b ^ 00000110b = 01010011b
-01010101b ^ 00000111b = 01010010b
-01010101b ^ 00001000b = 01011101b
-01010101b ^ 00001001b = 01011100b
-01010101b ^ 00001010b = 01011111b
-01010101b ^ 00001011b = 01011110b
-01010101b ^ 00001100b = 01011001b
-01010101b ^ 00001101b = 01011000b
-01010101b ^ 00001110b = 01011011b
-01010101b ^ 00001111b = 01011010b
-01010101b ^ 00010000b = 01000101b
-01010101b ^ 00010001b = 01000100b
-01010101b ^ 00010010b = 01000111b
-01010101b ^ 00010011b = 01000110b
-01010101b ^ 00010100b = 01000001b
-01010101b ^ 00010101b = 01000000b
-01010101b ^ 00010110b = 01000011b
-01010101b ^ 00010111b = 01000010b
-01010101b ^ 00011000b = 01001101b
-01010101b ^ 00011001b = 01001100b
-01010101b ^ 00011010b = 01001111b
-01010101b ^ 00011011b = 01001110b
-01010101b ^ 00011100b = 01001001b
-01010101b ^ 00011101b = 01001000b
-01010101b ^ 00011110b = 01001011b
-01010101b ^ 00011111b = 01001010b
-01010101b ^ 00100000b = 01110101b
-01010101b ^ 00100001b = 01110100b
-01010101b ^ 00100010b = 01110111b
-01010101b ^ 00100011b = 01110110b
-01010101b ^ 00100100b = 01110001b
-01010101b ^ 00100101b = 01110000b
-01010101b ^ 00100110b = 01110011b
-01010101b ^ 00100111b = 01110010b
-01010101b ^ 00101000b = 01111101b
-01010101b ^ 00101001b = 01111100b
-01010101b ^ 00101010b = 01111111b
-01010101b ^ 00101011b = 01111110b
-01010101b ^ 00101100b = 01111001b
-01010101b ^ 00101101b = 01111000b
-01010101b ^ 00101110b = 01111011b
-01010101b ^ 00101111b = 01111010b
-01010101b ^ 00110000b = 01100101b
-01010101b ^ 00110001b = 01100100b
-01010101b ^ 00110010b = 01100111b
-01010101b ^ 00110011b = 01100110b
-01010101b ^ 00110100b = 01100001b
-01010101b ^ 00110101b = 01100000b
-01010101b ^ 00110110b = 01100011b
-01010101b ^ 00110111b = 01100010b
-01010101b ^ 00111000b = 01101101b
-01010101b ^ 00111001b = 01101100b
-01010101b ^ 00111010b = 01101111b
-01010101b ^ 00111011b = 01101110b
-01010101b ^ 00111100b = 01101001b
-01010101b ^ 00111101b = 01101000b
-01010101b ^ 00111110b = 01101011b
-01010101b ^ 00111111b = 01101010b
-01010101b ^ 01000000b = 00010101b
-01010101b ^ 01000001b = 00010100b
-01010101b ^ 01000010b = 00010111b
-01010101b ^ 01000011b = 00010110b
-01010101b ^ 01000100b = 00010001b
-01010101b ^ 01000101b = 00010000b
-01010101b ^ 01000110b = 00010011b
-01010101b ^ 01000111b = 00010010b
-01010101b ^ 01001000b = 00011101b
-01010101b ^ 01001001b = 00011100b
-01010101b ^ 01001010b = 00011111b
-01010101b ^ 01001011b = 00011110b
-01010101b ^ 01001100b = 00011001b
-01010101b ^ 01001101b = 00011000b
-01010101b ^ 01001110b = 00011011b
-01010101b ^ 01001111b = 00011010b
-01010101b ^ 01010000b = 00000101b
-01010101b ^ 01010001b = 00000100b
-01010101b ^ 01010010b = 00000111b
-01010101b ^ 01010011b = 00000110b
-01010101b ^ 01010100b = 00000001b
-01010101b ^ 01010101b = 00000000b
-01010101b ^ 01010110b = 00000011b
-01010101b ^ 01010111b = 00000010b
-01010101b ^ 01011000b = 00001101b
-01010101b ^ 01011001b = 00001100b
-01010101b ^ 01011010b = 00001111b
-01010101b ^ 01011011b = 00001110b
-01010101b ^ 01011100b = 00001001b
-01010101b ^ 01011101b = 00001000b
-01010101b ^ 01011110b = 00001011b
-01010101b ^ 01011111b = 00001010b
-01010101b ^ 01100000b = 00110101b
-01010101b ^ 01100001b = 00110100b
-01010101b ^ 01100010b = 00110111b
-01010101b ^ 01100011b = 00110110b
-01010101b ^ 01100100b = 00110001b
-01010101b ^ 01100101b = 00110000b
-01010101b ^ 01100110b = 00110011b
-01010101b ^ 01100111b = 00110010b
-01010101b ^ 01101000b = 00111101b
-01010101b ^ 01101001b = 00111100b
-01010101b ^ 01101010b = 00111111b
-01010101b ^ 01101011b = 00111110b
-01010101b ^ 01101100b = 00111001b
-01010101b ^ 01101101b = 00111000b
-01010101b ^ 01101110b = 00111011b
-01010101b ^ 01101111b = 00111010b
-01010101b ^ 01110000b = 00100101b
-01010101b ^ 01110001b = 00100100b
-01010101b ^ 01110010b = 00100111b
-01010101b ^ 01110011b = 00100110b
-01010101b ^ 01110100b = 00100001b
-01010101b ^ 01110101b = 00100000b
-01010101b ^ 01110110b = 00100011b
-01010101b ^ 01110111b = 00100010b
-01010101b ^ 01111000b = 00101101b
-01010101b ^ 01111001b = 00101100b
-01010101b ^ 01111010b = 00101111b
-01010101b ^ 01111011b = 00101110b
-01010101b ^ 01111100b = 00101001b
-01010101b ^ 01111101b = 00101000b
-01010101b ^ 01111110b = 00101011b
-01010110b ^ 10000000b = 11010110b
-01010110b ^ 10000001b = 11010111b
-01010110b ^ 10000010b = 11010100b
-01010110b ^ 10000011b = 11010101b
-01010110b ^ 10000100b = 11010010b
-01010110b ^ 10000101b = 11010011b
-01010110b ^ 10000110b = 11010000b
-01010110b ^ 10000111b = 11010001b
-01010110b ^ 10001000b = 11011110b
-01010110b ^ 10001001b = 11011111b
-01010110b ^ 10001010b = 11011100b
-01010110b ^ 10001011b = 11011101b
-01010110b ^ 10001100b = 11011010b
-01010110b ^ 10001101b = 11011011b
-01010110b ^ 10001110b = 11011000b
-01010110b ^ 10001111b = 11011001b
-01010110b ^ 10010000b = 11000110b
-01010110b ^ 10010001b = 11000111b
-01010110b ^ 10010010b = 11000100b
-01010110b ^ 10010011b = 11000101b
-01010110b ^ 10010100b = 11000010b
-01010110b ^ 10010101b = 11000011b
-01010110b ^ 10010110b = 11000000b
-01010110b ^ 10010111b = 11000001b
-01010110b ^ 10011000b = 11001110b
-01010110b ^ 10011001b = 11001111b
-01010110b ^ 10011010b = 11001100b
-01010110b ^ 10011011b = 11001101b
-01010110b ^ 10011100b = 11001010b
-01010110b ^ 10011101b = 11001011b
-01010110b ^ 10011110b = 11001000b
-01010110b ^ 10011111b = 11001001b
-01010110b ^ 10100000b = 11110110b
-01010110b ^ 10100001b = 11110111b
-01010110b ^ 10100010b = 11110100b
-01010110b ^ 10100011b = 11110101b
-01010110b ^ 10100100b = 11110010b
-01010110b ^ 10100101b = 11110011b
-01010110b ^ 10100110b = 11110000b
-01010110b ^ 10100111b = 11110001b
-01010110b ^ 10101000b = 11111110b
-01010110b ^ 10101001b = 11111111b
-01010110b ^ 10101010b = 11111100b
-01010110b ^ 10101011b = 11111101b
-01010110b ^ 10101100b = 11111010b
-01010110b ^ 10101101b = 11111011b
-01010110b ^ 10101110b = 11111000b
-01010110b ^ 10101111b = 11111001b
-01010110b ^ 10110000b = 11100110b
-01010110b ^ 10110001b = 11100111b
-01010110b ^ 10110010b = 11100100b
-01010110b ^ 10110011b = 11100101b
-01010110b ^ 10110100b = 11100010b
-01010110b ^ 10110101b = 11100011b
-01010110b ^ 10110110b = 11100000b
-01010110b ^ 10110111b = 11100001b
-01010110b ^ 10111000b = 11101110b
-01010110b ^ 10111001b = 11101111b
-01010110b ^ 10111010b = 11101100b
-01010110b ^ 10111011b = 11101101b
-01010110b ^ 10111100b = 11101010b
-01010110b ^ 10111101b = 11101011b
-01010110b ^ 10111110b = 11101000b
-01010110b ^ 10111111b = 11101001b
-01010110b ^ 11000000b = 10010110b
-01010110b ^ 11000001b = 10010111b
-01010110b ^ 11000010b = 10010100b
-01010110b ^ 11000011b = 10010101b
-01010110b ^ 11000100b = 10010010b
-01010110b ^ 11000101b = 10010011b
-01010110b ^ 11000110b = 10010000b
-01010110b ^ 11000111b = 10010001b
-01010110b ^ 11001000b = 10011110b
-01010110b ^ 11001001b = 10011111b
-01010110b ^ 11001010b = 10011100b
-01010110b ^ 11001011b = 10011101b
-01010110b ^ 11001100b = 10011010b
-01010110b ^ 11001101b = 10011011b
-01010110b ^ 11001110b = 10011000b
-01010110b ^ 11001111b = 10011001b
-01010110b ^ 11010000b = 10000110b
-01010110b ^ 11010001b = 10000111b
-01010110b ^ 11010010b = 10000100b
-01010110b ^ 11010011b = 10000101b
-01010110b ^ 11010100b = 10000010b
-01010110b ^ 11010101b = 10000011b
-01010110b ^ 11010110b = 10000000b
-01010110b ^ 11010111b = 10000001b
-01010110b ^ 11011000b = 10001110b
-01010110b ^ 11011001b = 10001111b
-01010110b ^ 11011010b = 10001100b
-01010110b ^ 11011011b = 10001101b
-01010110b ^ 11011100b = 10001010b
-01010110b ^ 11011101b = 10001011b
-01010110b ^ 11011110b = 10001000b
-01010110b ^ 11011111b = 10001001b
-01010110b ^ 11100000b = 10110110b
-01010110b ^ 11100001b = 10110111b
-01010110b ^ 11100010b = 10110100b
-01010110b ^ 11100011b = 10110101b
-01010110b ^ 11100100b = 10110010b
-01010110b ^ 11100101b = 10110011b
-01010110b ^ 11100110b = 10110000b
-01010110b ^ 11100111b = 10110001b
-01010110b ^ 11101000b = 10111110b
-01010110b ^ 11101001b = 10111111b
-01010110b ^ 11101010b = 10111100b
-01010110b ^ 11101011b = 10111101b
-01010110b ^ 11101100b = 10111010b
-01010110b ^ 11101101b = 10111011b
-01010110b ^ 11101110b = 10111000b
-01010110b ^ 11101111b = 10111001b
-01010110b ^ 11110000b = 10100110b
-01010110b ^ 11110001b = 10100111b
-01010110b ^ 11110010b = 10100100b
-01010110b ^ 11110011b = 10100101b
-01010110b ^ 11110100b = 10100010b
-01010110b ^ 11110101b = 10100011b
-01010110b ^ 11110110b = 10100000b
-01010110b ^ 11110111b = 10100001b
-01010110b ^ 11111000b = 10101110b
-01010110b ^ 11111001b = 10101111b
-01010110b ^ 11111010b = 10101100b
-01010110b ^ 11111011b = 10101101b
-01010110b ^ 11111100b = 10101010b
-01010110b ^ 11111101b = 10101011b
-01010110b ^ 11111110b = 10101000b
-01010110b ^ 11111111b = 10101001b
-01010110b ^ 00000000b = 01010110b
-01010110b ^ 00000001b = 01010111b
-01010110b ^ 00000010b = 01010100b
-01010110b ^ 00000011b = 01010101b
-01010110b ^ 00000100b = 01010010b
-01010110b ^ 00000101b = 01010011b
-01010110b ^ 00000110b = 01010000b
-01010110b ^ 00000111b = 01010001b
-01010110b ^ 00001000b = 01011110b
-01010110b ^ 00001001b = 01011111b
-01010110b ^ 00001010b = 01011100b
-01010110b ^ 00001011b = 01011101b
-01010110b ^ 00001100b = 01011010b
-01010110b ^ 00001101b = 01011011b
-01010110b ^ 00001110b = 01011000b
-01010110b ^ 00001111b = 01011001b
-01010110b ^ 00010000b = 01000110b
-01010110b ^ 00010001b = 01000111b
-01010110b ^ 00010010b = 01000100b
-01010110b ^ 00010011b = 01000101b
-01010110b ^ 00010100b = 01000010b
-01010110b ^ 00010101b = 01000011b
-01010110b ^ 00010110b = 01000000b
-01010110b ^ 00010111b = 01000001b
-01010110b ^ 00011000b = 01001110b
-01010110b ^ 00011001b = 01001111b
-01010110b ^ 00011010b = 01001100b
-01010110b ^ 00011011b = 01001101b
-01010110b ^ 00011100b = 01001010b
-01010110b ^ 00011101b = 01001011b
-01010110b ^ 00011110b = 01001000b
-01010110b ^ 00011111b = 01001001b
-01010110b ^ 00100000b = 01110110b
-01010110b ^ 00100001b = 01110111b
-01010110b ^ 00100010b = 01110100b
-01010110b ^ 00100011b = 01110101b
-01010110b ^ 00100100b = 01110010b
-01010110b ^ 00100101b = 01110011b
-01010110b ^ 00100110b = 01110000b
-01010110b ^ 00100111b = 01110001b
-01010110b ^ 00101000b = 01111110b
-01010110b ^ 00101001b = 01111111b
-01010110b ^ 00101010b = 01111100b
-01010110b ^ 00101011b = 01111101b
-01010110b ^ 00101100b = 01111010b
-01010110b ^ 00101101b = 01111011b
-01010110b ^ 00101110b = 01111000b
-01010110b ^ 00101111b = 01111001b
-01010110b ^ 00110000b = 01100110b
-01010110b ^ 00110001b = 01100111b
-01010110b ^ 00110010b = 01100100b
-01010110b ^ 00110011b = 01100101b
-01010110b ^ 00110100b = 01100010b
-01010110b ^ 00110101b = 01100011b
-01010110b ^ 00110110b = 01100000b
-01010110b ^ 00110111b = 01100001b
-01010110b ^ 00111000b = 01101110b
-01010110b ^ 00111001b = 01101111b
-01010110b ^ 00111010b = 01101100b
-01010110b ^ 00111011b = 01101101b
-01010110b ^ 00111100b = 01101010b
-01010110b ^ 00111101b = 01101011b
-01010110b ^ 00111110b = 01101000b
-01010110b ^ 00111111b = 01101001b
-01010110b ^ 01000000b = 00010110b
-01010110b ^ 01000001b = 00010111b
-01010110b ^ 01000010b = 00010100b
-01010110b ^ 01000011b = 00010101b
-01010110b ^ 01000100b = 00010010b
-01010110b ^ 01000101b = 00010011b
-01010110b ^ 01000110b = 00010000b
-01010110b ^ 01000111b = 00010001b
-01010110b ^ 01001000b = 00011110b
-01010110b ^ 01001001b = 00011111b
-01010110b ^ 01001010b = 00011100b
-01010110b ^ 01001011b = 00011101b
-01010110b ^ 01001100b = 00011010b
-01010110b ^ 01001101b = 00011011b
-01010110b ^ 01001110b = 00011000b
-01010110b ^ 01001111b = 00011001b
-01010110b ^ 01010000b = 00000110b
-01010110b ^ 01010001b = 00000111b
-01010110b ^ 01010010b = 00000100b
-01010110b ^ 01010011b = 00000101b
-01010110b ^ 01010100b = 00000010b
-01010110b ^ 01010101b = 00000011b
-01010110b ^ 01010110b = 00000000b
-01010110b ^ 01010111b = 00000001b
-01010110b ^ 01011000b = 00001110b
-01010110b ^ 01011001b = 00001111b
-01010110b ^ 01011010b = 00001100b
-01010110b ^ 01011011b = 00001101b
-01010110b ^ 01011100b = 00001010b
-01010110b ^ 01011101b = 00001011b
-01010110b ^ 01011110b = 00001000b
-01010110b ^ 01011111b = 00001001b
-01010110b ^ 01100000b = 00110110b
-01010110b ^ 01100001b = 00110111b
-01010110b ^ 01100010b = 00110100b
-01010110b ^ 01100011b = 00110101b
-01010110b ^ 01100100b = 00110010b
-01010110b ^ 01100101b = 00110011b
-01010110b ^ 01100110b = 00110000b
-01010110b ^ 01100111b = 00110001b
-01010110b ^ 01101000b = 00111110b
-01010110b ^ 01101001b = 00111111b
-01010110b ^ 01101010b = 00111100b
-01010110b ^ 01101011b = 00111101b
-01010110b ^ 01101100b = 00111010b
-01010110b ^ 01101101b = 00111011b
-01010110b ^ 01101110b = 00111000b
-01010110b ^ 01101111b = 00111001b
-01010110b ^ 01110000b = 00100110b
-01010110b ^ 01110001b = 00100111b
-01010110b ^ 01110010b = 00100100b
-01010110b ^ 01110011b = 00100101b
-01010110b ^ 01110100b = 00100010b
-01010110b ^ 01110101b = 00100011b
-01010110b ^ 01110110b = 00100000b
-01010110b ^ 01110111b = 00100001b
-01010110b ^ 01111000b = 00101110b
-01010110b ^ 01111001b = 00101111b
-01010110b ^ 01111010b = 00101100b
-01010110b ^ 01111011b = 00101101b
-01010110b ^ 01111100b = 00101010b
-01010110b ^ 01111101b = 00101011b
-01010110b ^ 01111110b = 00101000b
-01010111b ^ 10000000b = 11010111b
-01010111b ^ 10000001b = 11010110b
-01010111b ^ 10000010b = 11010101b
-01010111b ^ 10000011b = 11010100b
-01010111b ^ 10000100b = 11010011b
-01010111b ^ 10000101b = 11010010b
-01010111b ^ 10000110b = 11010001b
-01010111b ^ 10000111b = 11010000b
-01010111b ^ 10001000b = 11011111b
-01010111b ^ 10001001b = 11011110b
-01010111b ^ 10001010b = 11011101b
-01010111b ^ 10001011b = 11011100b
-01010111b ^ 10001100b = 11011011b
-01010111b ^ 10001101b = 11011010b
-01010111b ^ 10001110b = 11011001b
-01010111b ^ 10001111b = 11011000b
-01010111b ^ 10010000b = 11000111b
-01010111b ^ 10010001b = 11000110b
-01010111b ^ 10010010b = 11000101b
-01010111b ^ 10010011b = 11000100b
-01010111b ^ 10010100b = 11000011b
-01010111b ^ 10010101b = 11000010b
-01010111b ^ 10010110b = 11000001b
-01010111b ^ 10010111b = 11000000b
-01010111b ^ 10011000b = 11001111b
-01010111b ^ 10011001b = 11001110b
-01010111b ^ 10011010b = 11001101b
-01010111b ^ 10011011b = 11001100b
-01010111b ^ 10011100b = 11001011b
-01010111b ^ 10011101b = 11001010b
-01010111b ^ 10011110b = 11001001b
-01010111b ^ 10011111b = 11001000b
-01010111b ^ 10100000b = 11110111b
-01010111b ^ 10100001b = 11110110b
-01010111b ^ 10100010b = 11110101b
-01010111b ^ 10100011b = 11110100b
-01010111b ^ 10100100b = 11110011b
-01010111b ^ 10100101b = 11110010b
-01010111b ^ 10100110b = 11110001b
-01010111b ^ 10100111b = 11110000b
-01010111b ^ 10101000b = 11111111b
-01010111b ^ 10101001b = 11111110b
-01010111b ^ 10101010b = 11111101b
-01010111b ^ 10101011b = 11111100b
-01010111b ^ 10101100b = 11111011b
-01010111b ^ 10101101b = 11111010b
-01010111b ^ 10101110b = 11111001b
-01010111b ^ 10101111b = 11111000b
-01010111b ^ 10110000b = 11100111b
-01010111b ^ 10110001b = 11100110b
-01010111b ^ 10110010b = 11100101b
-01010111b ^ 10110011b = 11100100b
-01010111b ^ 10110100b = 11100011b
-01010111b ^ 10110101b = 11100010b
-01010111b ^ 10110110b = 11100001b
-01010111b ^ 10110111b = 11100000b
-01010111b ^ 10111000b = 11101111b
-01010111b ^ 10111001b = 11101110b
-01010111b ^ 10111010b = 11101101b
-01010111b ^ 10111011b = 11101100b
-01010111b ^ 10111100b = 11101011b
-01010111b ^ 10111101b = 11101010b
-01010111b ^ 10111110b = 11101001b
-01010111b ^ 10111111b = 11101000b
-01010111b ^ 11000000b = 10010111b
-01010111b ^ 11000001b = 10010110b
-01010111b ^ 11000010b = 10010101b
-01010111b ^ 11000011b = 10010100b
-01010111b ^ 11000100b = 10010011b
-01010111b ^ 11000101b = 10010010b
-01010111b ^ 11000110b = 10010001b
-01010111b ^ 11000111b = 10010000b
-01010111b ^ 11001000b = 10011111b
-01010111b ^ 11001001b = 10011110b
-01010111b ^ 11001010b = 10011101b
-01010111b ^ 11001011b = 10011100b
-01010111b ^ 11001100b = 10011011b
-01010111b ^ 11001101b = 10011010b
-01010111b ^ 11001110b = 10011001b
-01010111b ^ 11001111b = 10011000b
-01010111b ^ 11010000b = 10000111b
-01010111b ^ 11010001b = 10000110b
-01010111b ^ 11010010b = 10000101b
-01010111b ^ 11010011b = 10000100b
-01010111b ^ 11010100b = 10000011b
-01010111b ^ 11010101b = 10000010b
-01010111b ^ 11010110b = 10000001b
-01010111b ^ 11010111b = 10000000b
-01010111b ^ 11011000b = 10001111b
-01010111b ^ 11011001b = 10001110b
-01010111b ^ 11011010b = 10001101b
-01010111b ^ 11011011b = 10001100b
-01010111b ^ 11011100b = 10001011b
-01010111b ^ 11011101b = 10001010b
-01010111b ^ 11011110b = 10001001b
-01010111b ^ 11011111b = 10001000b
-01010111b ^ 11100000b = 10110111b
-01010111b ^ 11100001b = 10110110b
-01010111b ^ 11100010b = 10110101b
-01010111b ^ 11100011b = 10110100b
-01010111b ^ 11100100b = 10110011b
-01010111b ^ 11100101b = 10110010b
-01010111b ^ 11100110b = 10110001b
-01010111b ^ 11100111b = 10110000b
-01010111b ^ 11101000b = 10111111b
-01010111b ^ 11101001b = 10111110b
-01010111b ^ 11101010b = 10111101b
-01010111b ^ 11101011b = 10111100b
-01010111b ^ 11101100b = 10111011b
-01010111b ^ 11101101b = 10111010b
-01010111b ^ 11101110b = 10111001b
-01010111b ^ 11101111b = 10111000b
-01010111b ^ 11110000b = 10100111b
-01010111b ^ 11110001b = 10100110b
-01010111b ^ 11110010b = 10100101b
-01010111b ^ 11110011b = 10100100b
-01010111b ^ 11110100b = 10100011b
-01010111b ^ 11110101b = 10100010b
-01010111b ^ 11110110b = 10100001b
-01010111b ^ 11110111b = 10100000b
-01010111b ^ 11111000b = 10101111b
-01010111b ^ 11111001b = 10101110b
-01010111b ^ 11111010b = 10101101b
-01010111b ^ 11111011b = 10101100b
-01010111b ^ 11111100b = 10101011b
-01010111b ^ 11111101b = 10101010b
-01010111b ^ 11111110b = 10101001b
-01010111b ^ 11111111b = 10101000b
-01010111b ^ 00000000b = 01010111b
-01010111b ^ 00000001b = 01010110b
-01010111b ^ 00000010b = 01010101b
-01010111b ^ 00000011b = 01010100b
-01010111b ^ 00000100b = 01010011b
-01010111b ^ 00000101b = 01010010b
-01010111b ^ 00000110b = 01010001b
-01010111b ^ 00000111b = 01010000b
-01010111b ^ 00001000b = 01011111b
-01010111b ^ 00001001b = 01011110b
-01010111b ^ 00001010b = 01011101b
-01010111b ^ 00001011b = 01011100b
-01010111b ^ 00001100b = 01011011b
-01010111b ^ 00001101b = 01011010b
-01010111b ^ 00001110b = 01011001b
-01010111b ^ 00001111b = 01011000b
-01010111b ^ 00010000b = 01000111b
-01010111b ^ 00010001b = 01000110b
-01010111b ^ 00010010b = 01000101b
-01010111b ^ 00010011b = 01000100b
-01010111b ^ 00010100b = 01000011b
-01010111b ^ 00010101b = 01000010b
-01010111b ^ 00010110b = 01000001b
-01010111b ^ 00010111b = 01000000b
-01010111b ^ 00011000b = 01001111b
-01010111b ^ 00011001b = 01001110b
-01010111b ^ 00011010b = 01001101b
-01010111b ^ 00011011b = 01001100b
-01010111b ^ 00011100b = 01001011b
-01010111b ^ 00011101b = 01001010b
-01010111b ^ 00011110b = 01001001b
-01010111b ^ 00011111b = 01001000b
-01010111b ^ 00100000b = 01110111b
-01010111b ^ 00100001b = 01110110b
-01010111b ^ 00100010b = 01110101b
-01010111b ^ 00100011b = 01110100b
-01010111b ^ 00100100b = 01110011b
-01010111b ^ 00100101b = 01110010b
-01010111b ^ 00100110b = 01110001b
-01010111b ^ 00100111b = 01110000b
-01010111b ^ 00101000b = 01111111b
-01010111b ^ 00101001b = 01111110b
-01010111b ^ 00101010b = 01111101b
-01010111b ^ 00101011b = 01111100b
-01010111b ^ 00101100b = 01111011b
-01010111b ^ 00101101b = 01111010b
-01010111b ^ 00101110b = 01111001b
-01010111b ^ 00101111b = 01111000b
-01010111b ^ 00110000b = 01100111b
-01010111b ^ 00110001b = 01100110b
-01010111b ^ 00110010b = 01100101b
-01010111b ^ 00110011b = 01100100b
-01010111b ^ 00110100b = 01100011b
-01010111b ^ 00110101b = 01100010b
-01010111b ^ 00110110b = 01100001b
-01010111b ^ 00110111b = 01100000b
-01010111b ^ 00111000b = 01101111b
-01010111b ^ 00111001b = 01101110b
-01010111b ^ 00111010b = 01101101b
-01010111b ^ 00111011b = 01101100b
-01010111b ^ 00111100b = 01101011b
-01010111b ^ 00111101b = 01101010b
-01010111b ^ 00111110b = 01101001b
-01010111b ^ 00111111b = 01101000b
-01010111b ^ 01000000b = 00010111b
-01010111b ^ 01000001b = 00010110b
-01010111b ^ 01000010b = 00010101b
-01010111b ^ 01000011b = 00010100b
-01010111b ^ 01000100b = 00010011b
-01010111b ^ 01000101b = 00010010b
-01010111b ^ 01000110b = 00010001b
-01010111b ^ 01000111b = 00010000b
-01010111b ^ 01001000b = 00011111b
-01010111b ^ 01001001b = 00011110b
-01010111b ^ 01001010b = 00011101b
-01010111b ^ 01001011b = 00011100b
-01010111b ^ 01001100b = 00011011b
-01010111b ^ 01001101b = 00011010b
-01010111b ^ 01001110b = 00011001b
-01010111b ^ 01001111b = 00011000b
-01010111b ^ 01010000b = 00000111b
-01010111b ^ 01010001b = 00000110b
-01010111b ^ 01010010b = 00000101b
-01010111b ^ 01010011b = 00000100b
-01010111b ^ 01010100b = 00000011b
-01010111b ^ 01010101b = 00000010b
-01010111b ^ 01010110b = 00000001b
-01010111b ^ 01010111b = 00000000b
-01010111b ^ 01011000b = 00001111b
-01010111b ^ 01011001b = 00001110b
-01010111b ^ 01011010b = 00001101b
-01010111b ^ 01011011b = 00001100b
-01010111b ^ 01011100b = 00001011b
-01010111b ^ 01011101b = 00001010b
-01010111b ^ 01011110b = 00001001b
-01010111b ^ 01011111b = 00001000b
-01010111b ^ 01100000b = 00110111b
-01010111b ^ 01100001b = 00110110b
-01010111b ^ 01100010b = 00110101b
-01010111b ^ 01100011b = 00110100b
-01010111b ^ 01100100b = 00110011b
-01010111b ^ 01100101b = 00110010b
-01010111b ^ 01100110b = 00110001b
-01010111b ^ 01100111b = 00110000b
-01010111b ^ 01101000b = 00111111b
-01010111b ^ 01101001b = 00111110b
-01010111b ^ 01101010b = 00111101b
-01010111b ^ 01101011b = 00111100b
-01010111b ^ 01101100b = 00111011b
-01010111b ^ 01101101b = 00111010b
-01010111b ^ 01101110b = 00111001b
-01010111b ^ 01101111b = 00111000b
-01010111b ^ 01110000b = 00100111b
-01010111b ^ 01110001b = 00100110b
-01010111b ^ 01110010b = 00100101b
-01010111b ^ 01110011b = 00100100b
-01010111b ^ 01110100b = 00100011b
-01010111b ^ 01110101b = 00100010b
-01010111b ^ 01110110b = 00100001b
-01010111b ^ 01110111b = 00100000b
-01010111b ^ 01111000b = 00101111b
-01010111b ^ 01111001b = 00101110b
-01010111b ^ 01111010b = 00101101b
-01010111b ^ 01111011b = 00101100b
-01010111b ^ 01111100b = 00101011b
-01010111b ^ 01111101b = 00101010b
-01010111b ^ 01111110b = 00101001b
-01011000b ^ 10000000b = 11011000b
-01011000b ^ 10000001b = 11011001b
-01011000b ^ 10000010b = 11011010b
-01011000b ^ 10000011b = 11011011b
-01011000b ^ 10000100b = 11011100b
-01011000b ^ 10000101b = 11011101b
-01011000b ^ 10000110b = 11011110b
-01011000b ^ 10000111b = 11011111b
-01011000b ^ 10001000b = 11010000b
-01011000b ^ 10001001b = 11010001b
-01011000b ^ 10001010b = 11010010b
-01011000b ^ 10001011b = 11010011b
-01011000b ^ 10001100b = 11010100b
-01011000b ^ 10001101b = 11010101b
-01011000b ^ 10001110b = 11010110b
-01011000b ^ 10001111b = 11010111b
-01011000b ^ 10010000b = 11001000b
-01011000b ^ 10010001b = 11001001b
-01011000b ^ 10010010b = 11001010b
-01011000b ^ 10010011b = 11001011b
-01011000b ^ 10010100b = 11001100b
-01011000b ^ 10010101b = 11001101b
-01011000b ^ 10010110b = 11001110b
-01011000b ^ 10010111b = 11001111b
-01011000b ^ 10011000b = 11000000b
-01011000b ^ 10011001b = 11000001b
-01011000b ^ 10011010b = 11000010b
-01011000b ^ 10011011b = 11000011b
-01011000b ^ 10011100b = 11000100b
-01011000b ^ 10011101b = 11000101b
-01011000b ^ 10011110b = 11000110b
-01011000b ^ 10011111b = 11000111b
-01011000b ^ 10100000b = 11111000b
-01011000b ^ 10100001b = 11111001b
-01011000b ^ 10100010b = 11111010b
-01011000b ^ 10100011b = 11111011b
-01011000b ^ 10100100b = 11111100b
-01011000b ^ 10100101b = 11111101b
-01011000b ^ 10100110b = 11111110b
-01011000b ^ 10100111b = 11111111b
-01011000b ^ 10101000b = 11110000b
-01011000b ^ 10101001b = 11110001b
-01011000b ^ 10101010b = 11110010b
-01011000b ^ 10101011b = 11110011b
-01011000b ^ 10101100b = 11110100b
-01011000b ^ 10101101b = 11110101b
-01011000b ^ 10101110b = 11110110b
-01011000b ^ 10101111b = 11110111b
-01011000b ^ 10110000b = 11101000b
-01011000b ^ 10110001b = 11101001b
-01011000b ^ 10110010b = 11101010b
-01011000b ^ 10110011b = 11101011b
-01011000b ^ 10110100b = 11101100b
-01011000b ^ 10110101b = 11101101b
-01011000b ^ 10110110b = 11101110b
-01011000b ^ 10110111b = 11101111b
-01011000b ^ 10111000b = 11100000b
-01011000b ^ 10111001b = 11100001b
-01011000b ^ 10111010b = 11100010b
-01011000b ^ 10111011b = 11100011b
-01011000b ^ 10111100b = 11100100b
-01011000b ^ 10111101b = 11100101b
-01011000b ^ 10111110b = 11100110b
-01011000b ^ 10111111b = 11100111b
-01011000b ^ 11000000b = 10011000b
-01011000b ^ 11000001b = 10011001b
-01011000b ^ 11000010b = 10011010b
-01011000b ^ 11000011b = 10011011b
-01011000b ^ 11000100b = 10011100b
-01011000b ^ 11000101b = 10011101b
-01011000b ^ 11000110b = 10011110b
-01011000b ^ 11000111b = 10011111b
-01011000b ^ 11001000b = 10010000b
-01011000b ^ 11001001b = 10010001b
-01011000b ^ 11001010b = 10010010b
-01011000b ^ 11001011b = 10010011b
-01011000b ^ 11001100b = 10010100b
-01011000b ^ 11001101b = 10010101b
-01011000b ^ 11001110b = 10010110b
-01011000b ^ 11001111b = 10010111b
-01011000b ^ 11010000b = 10001000b
-01011000b ^ 11010001b = 10001001b
-01011000b ^ 11010010b = 10001010b
-01011000b ^ 11010011b = 10001011b
-01011000b ^ 11010100b = 10001100b
-01011000b ^ 11010101b = 10001101b
-01011000b ^ 11010110b = 10001110b
-01011000b ^ 11010111b = 10001111b
-01011000b ^ 11011000b = 10000000b
-01011000b ^ 11011001b = 10000001b
-01011000b ^ 11011010b = 10000010b
-01011000b ^ 11011011b = 10000011b
-01011000b ^ 11011100b = 10000100b
-01011000b ^ 11011101b = 10000101b
-01011000b ^ 11011110b = 10000110b
-01011000b ^ 11011111b = 10000111b
-01011000b ^ 11100000b = 10111000b
-01011000b ^ 11100001b = 10111001b
-01011000b ^ 11100010b = 10111010b
-01011000b ^ 11100011b = 10111011b
-01011000b ^ 11100100b = 10111100b
-01011000b ^ 11100101b = 10111101b
-01011000b ^ 11100110b = 10111110b
-01011000b ^ 11100111b = 10111111b
-01011000b ^ 11101000b = 10110000b
-01011000b ^ 11101001b = 10110001b
-01011000b ^ 11101010b = 10110010b
-01011000b ^ 11101011b = 10110011b
-01011000b ^ 11101100b = 10110100b
-01011000b ^ 11101101b = 10110101b
-01011000b ^ 11101110b = 10110110b
-01011000b ^ 11101111b = 10110111b
-01011000b ^ 11110000b = 10101000b
-01011000b ^ 11110001b = 10101001b
-01011000b ^ 11110010b = 10101010b
-01011000b ^ 11110011b = 10101011b
-01011000b ^ 11110100b = 10101100b
-01011000b ^ 11110101b = 10101101b
-01011000b ^ 11110110b = 10101110b
-01011000b ^ 11110111b = 10101111b
-01011000b ^ 11111000b = 10100000b
-01011000b ^ 11111001b = 10100001b
-01011000b ^ 11111010b = 10100010b
-01011000b ^ 11111011b = 10100011b
-01011000b ^ 11111100b = 10100100b
-01011000b ^ 11111101b = 10100101b
-01011000b ^ 11111110b = 10100110b
-01011000b ^ 11111111b = 10100111b
-01011000b ^ 00000000b = 01011000b
-01011000b ^ 00000001b = 01011001b
-01011000b ^ 00000010b = 01011010b
-01011000b ^ 00000011b = 01011011b
-01011000b ^ 00000100b = 01011100b
-01011000b ^ 00000101b = 01011101b
-01011000b ^ 00000110b = 01011110b
-01011000b ^ 00000111b = 01011111b
-01011000b ^ 00001000b = 01010000b
-01011000b ^ 00001001b = 01010001b
-01011000b ^ 00001010b = 01010010b
-01011000b ^ 00001011b = 01010011b
-01011000b ^ 00001100b = 01010100b
-01011000b ^ 00001101b = 01010101b
-01011000b ^ 00001110b = 01010110b
-01011000b ^ 00001111b = 01010111b
-01011000b ^ 00010000b = 01001000b
-01011000b ^ 00010001b = 01001001b
-01011000b ^ 00010010b = 01001010b
-01011000b ^ 00010011b = 01001011b
-01011000b ^ 00010100b = 01001100b
-01011000b ^ 00010101b = 01001101b
-01011000b ^ 00010110b = 01001110b
-01011000b ^ 00010111b = 01001111b
-01011000b ^ 00011000b = 01000000b
-01011000b ^ 00011001b = 01000001b
-01011000b ^ 00011010b = 01000010b
-01011000b ^ 00011011b = 01000011b
-01011000b ^ 00011100b = 01000100b
-01011000b ^ 00011101b = 01000101b
-01011000b ^ 00011110b = 01000110b
-01011000b ^ 00011111b = 01000111b
-01011000b ^ 00100000b = 01111000b
-01011000b ^ 00100001b = 01111001b
-01011000b ^ 00100010b = 01111010b
-01011000b ^ 00100011b = 01111011b
-01011000b ^ 00100100b = 01111100b
-01011000b ^ 00100101b = 01111101b
-01011000b ^ 00100110b = 01111110b
-01011000b ^ 00100111b = 01111111b
-01011000b ^ 00101000b = 01110000b
-01011000b ^ 00101001b = 01110001b
-01011000b ^ 00101010b = 01110010b
-01011000b ^ 00101011b = 01110011b
-01011000b ^ 00101100b = 01110100b
-01011000b ^ 00101101b = 01110101b
-01011000b ^ 00101110b = 01110110b
-01011000b ^ 00101111b = 01110111b
-01011000b ^ 00110000b = 01101000b
-01011000b ^ 00110001b = 01101001b
-01011000b ^ 00110010b = 01101010b
-01011000b ^ 00110011b = 01101011b
-01011000b ^ 00110100b = 01101100b
-01011000b ^ 00110101b = 01101101b
-01011000b ^ 00110110b = 01101110b
-01011000b ^ 00110111b = 01101111b
-01011000b ^ 00111000b = 01100000b
-01011000b ^ 00111001b = 01100001b
-01011000b ^ 00111010b = 01100010b
-01011000b ^ 00111011b = 01100011b
-01011000b ^ 00111100b = 01100100b
-01011000b ^ 00111101b = 01100101b
-01011000b ^ 00111110b = 01100110b
-01011000b ^ 00111111b = 01100111b
-01011000b ^ 01000000b = 00011000b
-01011000b ^ 01000001b = 00011001b
-01011000b ^ 01000010b = 00011010b
-01011000b ^ 01000011b = 00011011b
-01011000b ^ 01000100b = 00011100b
-01011000b ^ 01000101b = 00011101b
-01011000b ^ 01000110b = 00011110b
-01011000b ^ 01000111b = 00011111b
-01011000b ^ 01001000b = 00010000b
-01011000b ^ 01001001b = 00010001b
-01011000b ^ 01001010b = 00010010b
-01011000b ^ 01001011b = 00010011b
-01011000b ^ 01001100b = 00010100b
-01011000b ^ 01001101b = 00010101b
-01011000b ^ 01001110b = 00010110b
-01011000b ^ 01001111b = 00010111b
-01011000b ^ 01010000b = 00001000b
-01011000b ^ 01010001b = 00001001b
-01011000b ^ 01010010b = 00001010b
-01011000b ^ 01010011b = 00001011b
-01011000b ^ 01010100b = 00001100b
-01011000b ^ 01010101b = 00001101b
-01011000b ^ 01010110b = 00001110b
-01011000b ^ 01010111b = 00001111b
-01011000b ^ 01011000b = 00000000b
-01011000b ^ 01011001b = 00000001b
-01011000b ^ 01011010b = 00000010b
-01011000b ^ 01011011b = 00000011b
-01011000b ^ 01011100b = 00000100b
-01011000b ^ 01011101b = 00000101b
-01011000b ^ 01011110b = 00000110b
-01011000b ^ 01011111b = 00000111b
-01011000b ^ 01100000b = 00111000b
-01011000b ^ 01100001b = 00111001b
-01011000b ^ 01100010b = 00111010b
-01011000b ^ 01100011b = 00111011b
-01011000b ^ 01100100b = 00111100b
-01011000b ^ 01100101b = 00111101b
-01011000b ^ 01100110b = 00111110b
-01011000b ^ 01100111b = 00111111b
-01011000b ^ 01101000b = 00110000b
-01011000b ^ 01101001b = 00110001b
-01011000b ^ 01101010b = 00110010b
-01011000b ^ 01101011b = 00110011b
-01011000b ^ 01101100b = 00110100b
-01011000b ^ 01101101b = 00110101b
-01011000b ^ 01101110b = 00110110b
-01011000b ^ 01101111b = 00110111b
-01011000b ^ 01110000b = 00101000b
-01011000b ^ 01110001b = 00101001b
-01011000b ^ 01110010b = 00101010b
-01011000b ^ 01110011b = 00101011b
-01011000b ^ 01110100b = 00101100b
-01011000b ^ 01110101b = 00101101b
-01011000b ^ 01110110b = 00101110b
-01011000b ^ 01110111b = 00101111b
-01011000b ^ 01111000b = 00100000b
-01011000b ^ 01111001b = 00100001b
-01011000b ^ 01111010b = 00100010b
-01011000b ^ 01111011b = 00100011b
-01011000b ^ 01111100b = 00100100b
-01011000b ^ 01111101b = 00100101b
-01011000b ^ 01111110b = 00100110b
-01011001b ^ 10000000b = 11011001b
-01011001b ^ 10000001b = 11011000b
-01011001b ^ 10000010b = 11011011b
-01011001b ^ 10000011b = 11011010b
-01011001b ^ 10000100b = 11011101b
-01011001b ^ 10000101b = 11011100b
-01011001b ^ 10000110b = 11011111b
-01011001b ^ 10000111b = 11011110b
-01011001b ^ 10001000b = 11010001b
-01011001b ^ 10001001b = 11010000b
-01011001b ^ 10001010b = 11010011b
-01011001b ^ 10001011b = 11010010b
-01011001b ^ 10001100b = 11010101b
-01011001b ^ 10001101b = 11010100b
-01011001b ^ 10001110b = 11010111b
-01011001b ^ 10001111b = 11010110b
-01011001b ^ 10010000b = 11001001b
-01011001b ^ 10010001b = 11001000b
-01011001b ^ 10010010b = 11001011b
-01011001b ^ 10010011b = 11001010b
-01011001b ^ 10010100b = 11001101b
-01011001b ^ 10010101b = 11001100b
-01011001b ^ 10010110b = 11001111b
-01011001b ^ 10010111b = 11001110b
-01011001b ^ 10011000b = 11000001b
-01011001b ^ 10011001b = 11000000b
-01011001b ^ 10011010b = 11000011b
-01011001b ^ 10011011b = 11000010b
-01011001b ^ 10011100b = 11000101b
-01011001b ^ 10011101b = 11000100b
-01011001b ^ 10011110b = 11000111b
-01011001b ^ 10011111b = 11000110b
-01011001b ^ 10100000b = 11111001b
-01011001b ^ 10100001b = 11111000b
-01011001b ^ 10100010b = 11111011b
-01011001b ^ 10100011b = 11111010b
-01011001b ^ 10100100b = 11111101b
-01011001b ^ 10100101b = 11111100b
-01011001b ^ 10100110b = 11111111b
-01011001b ^ 10100111b = 11111110b
-01011001b ^ 10101000b = 11110001b
-01011001b ^ 10101001b = 11110000b
-01011001b ^ 10101010b = 11110011b
-01011001b ^ 10101011b = 11110010b
-01011001b ^ 10101100b = 11110101b
-01011001b ^ 10101101b = 11110100b
-01011001b ^ 10101110b = 11110111b
-01011001b ^ 10101111b = 11110110b
-01011001b ^ 10110000b = 11101001b
-01011001b ^ 10110001b = 11101000b
-01011001b ^ 10110010b = 11101011b
-01011001b ^ 10110011b = 11101010b
-01011001b ^ 10110100b = 11101101b
-01011001b ^ 10110101b = 11101100b
-01011001b ^ 10110110b = 11101111b
-01011001b ^ 10110111b = 11101110b
-01011001b ^ 10111000b = 11100001b
-01011001b ^ 10111001b = 11100000b
-01011001b ^ 10111010b = 11100011b
-01011001b ^ 10111011b = 11100010b
-01011001b ^ 10111100b = 11100101b
-01011001b ^ 10111101b = 11100100b
-01011001b ^ 10111110b = 11100111b
-01011001b ^ 10111111b = 11100110b
-01011001b ^ 11000000b = 10011001b
-01011001b ^ 11000001b = 10011000b
-01011001b ^ 11000010b = 10011011b
-01011001b ^ 11000011b = 10011010b
-01011001b ^ 11000100b = 10011101b
-01011001b ^ 11000101b = 10011100b
-01011001b ^ 11000110b = 10011111b
-01011001b ^ 11000111b = 10011110b
-01011001b ^ 11001000b = 10010001b
-01011001b ^ 11001001b = 10010000b
-01011001b ^ 11001010b = 10010011b
-01011001b ^ 11001011b = 10010010b
-01011001b ^ 11001100b = 10010101b
-01011001b ^ 11001101b = 10010100b
-01011001b ^ 11001110b = 10010111b
-01011001b ^ 11001111b = 10010110b
-01011001b ^ 11010000b = 10001001b
-01011001b ^ 11010001b = 10001000b
-01011001b ^ 11010010b = 10001011b
-01011001b ^ 11010011b = 10001010b
-01011001b ^ 11010100b = 10001101b
-01011001b ^ 11010101b = 10001100b
-01011001b ^ 11010110b = 10001111b
-01011001b ^ 11010111b = 10001110b
-01011001b ^ 11011000b = 10000001b
-01011001b ^ 11011001b = 10000000b
-01011001b ^ 11011010b = 10000011b
-01011001b ^ 11011011b = 10000010b
-01011001b ^ 11011100b = 10000101b
-01011001b ^ 11011101b = 10000100b
-01011001b ^ 11011110b = 10000111b
-01011001b ^ 11011111b = 10000110b
-01011001b ^ 11100000b = 10111001b
-01011001b ^ 11100001b = 10111000b
-01011001b ^ 11100010b = 10111011b
-01011001b ^ 11100011b = 10111010b
-01011001b ^ 11100100b = 10111101b
-01011001b ^ 11100101b = 10111100b
-01011001b ^ 11100110b = 10111111b
-01011001b ^ 11100111b = 10111110b
-01011001b ^ 11101000b = 10110001b
-01011001b ^ 11101001b = 10110000b
-01011001b ^ 11101010b = 10110011b
-01011001b ^ 11101011b = 10110010b
-01011001b ^ 11101100b = 10110101b
-01011001b ^ 11101101b = 10110100b
-01011001b ^ 11101110b = 10110111b
-01011001b ^ 11101111b = 10110110b
-01011001b ^ 11110000b = 10101001b
-01011001b ^ 11110001b = 10101000b
-01011001b ^ 11110010b = 10101011b
-01011001b ^ 11110011b = 10101010b
-01011001b ^ 11110100b = 10101101b
-01011001b ^ 11110101b = 10101100b
-01011001b ^ 11110110b = 10101111b
-01011001b ^ 11110111b = 10101110b
-01011001b ^ 11111000b = 10100001b
-01011001b ^ 11111001b = 10100000b
-01011001b ^ 11111010b = 10100011b
-01011001b ^ 11111011b = 10100010b
-01011001b ^ 11111100b = 10100101b
-01011001b ^ 11111101b = 10100100b
-01011001b ^ 11111110b = 10100111b
-01011001b ^ 11111111b = 10100110b
-01011001b ^ 00000000b = 01011001b
-01011001b ^ 00000001b = 01011000b
-01011001b ^ 00000010b = 01011011b
-01011001b ^ 00000011b = 01011010b
-01011001b ^ 00000100b = 01011101b
-01011001b ^ 00000101b = 01011100b
-01011001b ^ 00000110b = 01011111b
-01011001b ^ 00000111b = 01011110b
-01011001b ^ 00001000b = 01010001b
-01011001b ^ 00001001b = 01010000b
-01011001b ^ 00001010b = 01010011b
-01011001b ^ 00001011b = 01010010b
-01011001b ^ 00001100b = 01010101b
-01011001b ^ 00001101b = 01010100b
-01011001b ^ 00001110b = 01010111b
-01011001b ^ 00001111b = 01010110b
-01011001b ^ 00010000b = 01001001b
-01011001b ^ 00010001b = 01001000b
-01011001b ^ 00010010b = 01001011b
-01011001b ^ 00010011b = 01001010b
-01011001b ^ 00010100b = 01001101b
-01011001b ^ 00010101b = 01001100b
-01011001b ^ 00010110b = 01001111b
-01011001b ^ 00010111b = 01001110b
-01011001b ^ 00011000b = 01000001b
-01011001b ^ 00011001b = 01000000b
-01011001b ^ 00011010b = 01000011b
-01011001b ^ 00011011b = 01000010b
-01011001b ^ 00011100b = 01000101b
-01011001b ^ 00011101b = 01000100b
-01011001b ^ 00011110b = 01000111b
-01011001b ^ 00011111b = 01000110b
-01011001b ^ 00100000b = 01111001b
-01011001b ^ 00100001b = 01111000b
-01011001b ^ 00100010b = 01111011b
-01011001b ^ 00100011b = 01111010b
-01011001b ^ 00100100b = 01111101b
-01011001b ^ 00100101b = 01111100b
-01011001b ^ 00100110b = 01111111b
-01011001b ^ 00100111b = 01111110b
-01011001b ^ 00101000b = 01110001b
-01011001b ^ 00101001b = 01110000b
-01011001b ^ 00101010b = 01110011b
-01011001b ^ 00101011b = 01110010b
-01011001b ^ 00101100b = 01110101b
-01011001b ^ 00101101b = 01110100b
-01011001b ^ 00101110b = 01110111b
-01011001b ^ 00101111b = 01110110b
-01011001b ^ 00110000b = 01101001b
-01011001b ^ 00110001b = 01101000b
-01011001b ^ 00110010b = 01101011b
-01011001b ^ 00110011b = 01101010b
-01011001b ^ 00110100b = 01101101b
-01011001b ^ 00110101b = 01101100b
-01011001b ^ 00110110b = 01101111b
-01011001b ^ 00110111b = 01101110b
-01011001b ^ 00111000b = 01100001b
-01011001b ^ 00111001b = 01100000b
-01011001b ^ 00111010b = 01100011b
-01011001b ^ 00111011b = 01100010b
-01011001b ^ 00111100b = 01100101b
-01011001b ^ 00111101b = 01100100b
-01011001b ^ 00111110b = 01100111b
-01011001b ^ 00111111b = 01100110b
-01011001b ^ 01000000b = 00011001b
-01011001b ^ 01000001b = 00011000b
-01011001b ^ 01000010b = 00011011b
-01011001b ^ 01000011b = 00011010b
-01011001b ^ 01000100b = 00011101b
-01011001b ^ 01000101b = 00011100b
-01011001b ^ 01000110b = 00011111b
-01011001b ^ 01000111b = 00011110b
-01011001b ^ 01001000b = 00010001b
-01011001b ^ 01001001b = 00010000b
-01011001b ^ 01001010b = 00010011b
-01011001b ^ 01001011b = 00010010b
-01011001b ^ 01001100b = 00010101b
-01011001b ^ 01001101b = 00010100b
-01011001b ^ 01001110b = 00010111b
-01011001b ^ 01001111b = 00010110b
-01011001b ^ 01010000b = 00001001b
-01011001b ^ 01010001b = 00001000b
-01011001b ^ 01010010b = 00001011b
-01011001b ^ 01010011b = 00001010b
-01011001b ^ 01010100b = 00001101b
-01011001b ^ 01010101b = 00001100b
-01011001b ^ 01010110b = 00001111b
-01011001b ^ 01010111b = 00001110b
-01011001b ^ 01011000b = 00000001b
-01011001b ^ 01011001b = 00000000b
-01011001b ^ 01011010b = 00000011b
-01011001b ^ 01011011b = 00000010b
-01011001b ^ 01011100b = 00000101b
-01011001b ^ 01011101b = 00000100b
-01011001b ^ 01011110b = 00000111b
-01011001b ^ 01011111b = 00000110b
-01011001b ^ 01100000b = 00111001b
-01011001b ^ 01100001b = 00111000b
-01011001b ^ 01100010b = 00111011b
-01011001b ^ 01100011b = 00111010b
-01011001b ^ 01100100b = 00111101b
-01011001b ^ 01100101b = 00111100b
-01011001b ^ 01100110b = 00111111b
-01011001b ^ 01100111b = 00111110b
-01011001b ^ 01101000b = 00110001b
-01011001b ^ 01101001b = 00110000b
-01011001b ^ 01101010b = 00110011b
-01011001b ^ 01101011b = 00110010b
-01011001b ^ 01101100b = 00110101b
-01011001b ^ 01101101b = 00110100b
-01011001b ^ 01101110b = 00110111b
-01011001b ^ 01101111b = 00110110b
-01011001b ^ 01110000b = 00101001b
-01011001b ^ 01110001b = 00101000b
-01011001b ^ 01110010b = 00101011b
-01011001b ^ 01110011b = 00101010b
-01011001b ^ 01110100b = 00101101b
-01011001b ^ 01110101b = 00101100b
-01011001b ^ 01110110b = 00101111b
-01011001b ^ 01110111b = 00101110b
-01011001b ^ 01111000b = 00100001b
-01011001b ^ 01111001b = 00100000b
-01011001b ^ 01111010b = 00100011b
-01011001b ^ 01111011b = 00100010b
-01011001b ^ 01111100b = 00100101b
-01011001b ^ 01111101b = 00100100b
-01011001b ^ 01111110b = 00100111b
-01011010b ^ 10000000b = 11011010b
-01011010b ^ 10000001b = 11011011b
-01011010b ^ 10000010b = 11011000b
-01011010b ^ 10000011b = 11011001b
-01011010b ^ 10000100b = 11011110b
-01011010b ^ 10000101b = 11011111b
-01011010b ^ 10000110b = 11011100b
-01011010b ^ 10000111b = 11011101b
-01011010b ^ 10001000b = 11010010b
-01011010b ^ 10001001b = 11010011b
-01011010b ^ 10001010b = 11010000b
-01011010b ^ 10001011b = 11010001b
-01011010b ^ 10001100b = 11010110b
-01011010b ^ 10001101b = 11010111b
-01011010b ^ 10001110b = 11010100b
-01011010b ^ 10001111b = 11010101b
-01011010b ^ 10010000b = 11001010b
-01011010b ^ 10010001b = 11001011b
-01011010b ^ 10010010b = 11001000b
-01011010b ^ 10010011b = 11001001b
-01011010b ^ 10010100b = 11001110b
-01011010b ^ 10010101b = 11001111b
-01011010b ^ 10010110b = 11001100b
-01011010b ^ 10010111b = 11001101b
-01011010b ^ 10011000b = 11000010b
-01011010b ^ 10011001b = 11000011b
-01011010b ^ 10011010b = 11000000b
-01011010b ^ 10011011b = 11000001b
-01011010b ^ 10011100b = 11000110b
-01011010b ^ 10011101b = 11000111b
-01011010b ^ 10011110b = 11000100b
-01011010b ^ 10011111b = 11000101b
-01011010b ^ 10100000b = 11111010b
-01011010b ^ 10100001b = 11111011b
-01011010b ^ 10100010b = 11111000b
-01011010b ^ 10100011b = 11111001b
-01011010b ^ 10100100b = 11111110b
-01011010b ^ 10100101b = 11111111b
-01011010b ^ 10100110b = 11111100b
-01011010b ^ 10100111b = 11111101b
-01011010b ^ 10101000b = 11110010b
-01011010b ^ 10101001b = 11110011b
-01011010b ^ 10101010b = 11110000b
-01011010b ^ 10101011b = 11110001b
-01011010b ^ 10101100b = 11110110b
-01011010b ^ 10101101b = 11110111b
-01011010b ^ 10101110b = 11110100b
-01011010b ^ 10101111b = 11110101b
-01011010b ^ 10110000b = 11101010b
-01011010b ^ 10110001b = 11101011b
-01011010b ^ 10110010b = 11101000b
-01011010b ^ 10110011b = 11101001b
-01011010b ^ 10110100b = 11101110b
-01011010b ^ 10110101b = 11101111b
-01011010b ^ 10110110b = 11101100b
-01011010b ^ 10110111b = 11101101b
-01011010b ^ 10111000b = 11100010b
-01011010b ^ 10111001b = 11100011b
-01011010b ^ 10111010b = 11100000b
-01011010b ^ 10111011b = 11100001b
-01011010b ^ 10111100b = 11100110b
-01011010b ^ 10111101b = 11100111b
-01011010b ^ 10111110b = 11100100b
-01011010b ^ 10111111b = 11100101b
-01011010b ^ 11000000b = 10011010b
-01011010b ^ 11000001b = 10011011b
-01011010b ^ 11000010b = 10011000b
-01011010b ^ 11000011b = 10011001b
-01011010b ^ 11000100b = 10011110b
-01011010b ^ 11000101b = 10011111b
-01011010b ^ 11000110b = 10011100b
-01011010b ^ 11000111b = 10011101b
-01011010b ^ 11001000b = 10010010b
-01011010b ^ 11001001b = 10010011b
-01011010b ^ 11001010b = 10010000b
-01011010b ^ 11001011b = 10010001b
-01011010b ^ 11001100b = 10010110b
-01011010b ^ 11001101b = 10010111b
-01011010b ^ 11001110b = 10010100b
-01011010b ^ 11001111b = 10010101b
-01011010b ^ 11010000b = 10001010b
-01011010b ^ 11010001b = 10001011b
-01011010b ^ 11010010b = 10001000b
-01011010b ^ 11010011b = 10001001b
-01011010b ^ 11010100b = 10001110b
-01011010b ^ 11010101b = 10001111b
-01011010b ^ 11010110b = 10001100b
-01011010b ^ 11010111b = 10001101b
-01011010b ^ 11011000b = 10000010b
-01011010b ^ 11011001b = 10000011b
-01011010b ^ 11011010b = 10000000b
-01011010b ^ 11011011b = 10000001b
-01011010b ^ 11011100b = 10000110b
-01011010b ^ 11011101b = 10000111b
-01011010b ^ 11011110b = 10000100b
-01011010b ^ 11011111b = 10000101b
-01011010b ^ 11100000b = 10111010b
-01011010b ^ 11100001b = 10111011b
-01011010b ^ 11100010b = 10111000b
-01011010b ^ 11100011b = 10111001b
-01011010b ^ 11100100b = 10111110b
-01011010b ^ 11100101b = 10111111b
-01011010b ^ 11100110b = 10111100b
-01011010b ^ 11100111b = 10111101b
-01011010b ^ 11101000b = 10110010b
-01011010b ^ 11101001b = 10110011b
-01011010b ^ 11101010b = 10110000b
-01011010b ^ 11101011b = 10110001b
-01011010b ^ 11101100b = 10110110b
-01011010b ^ 11101101b = 10110111b
-01011010b ^ 11101110b = 10110100b
-01011010b ^ 11101111b = 10110101b
-01011010b ^ 11110000b = 10101010b
-01011010b ^ 11110001b = 10101011b
-01011010b ^ 11110010b = 10101000b
-01011010b ^ 11110011b = 10101001b
-01011010b ^ 11110100b = 10101110b
-01011010b ^ 11110101b = 10101111b
-01011010b ^ 11110110b = 10101100b
-01011010b ^ 11110111b = 10101101b
-01011010b ^ 11111000b = 10100010b
-01011010b ^ 11111001b = 10100011b
-01011010b ^ 11111010b = 10100000b
-01011010b ^ 11111011b = 10100001b
-01011010b ^ 11111100b = 10100110b
-01011010b ^ 11111101b = 10100111b
-01011010b ^ 11111110b = 10100100b
-01011010b ^ 11111111b = 10100101b
-01011010b ^ 00000000b = 01011010b
-01011010b ^ 00000001b = 01011011b
-01011010b ^ 00000010b = 01011000b
-01011010b ^ 00000011b = 01011001b
-01011010b ^ 00000100b = 01011110b
-01011010b ^ 00000101b = 01011111b
-01011010b ^ 00000110b = 01011100b
-01011010b ^ 00000111b = 01011101b
-01011010b ^ 00001000b = 01010010b
-01011010b ^ 00001001b = 01010011b
-01011010b ^ 00001010b = 01010000b
-01011010b ^ 00001011b = 01010001b
-01011010b ^ 00001100b = 01010110b
-01011010b ^ 00001101b = 01010111b
-01011010b ^ 00001110b = 01010100b
-01011010b ^ 00001111b = 01010101b
-01011010b ^ 00010000b = 01001010b
-01011010b ^ 00010001b = 01001011b
-01011010b ^ 00010010b = 01001000b
-01011010b ^ 00010011b = 01001001b
-01011010b ^ 00010100b = 01001110b
-01011010b ^ 00010101b = 01001111b
-01011010b ^ 00010110b = 01001100b
-01011010b ^ 00010111b = 01001101b
-01011010b ^ 00011000b = 01000010b
-01011010b ^ 00011001b = 01000011b
-01011010b ^ 00011010b = 01000000b
-01011010b ^ 00011011b = 01000001b
-01011010b ^ 00011100b = 01000110b
-01011010b ^ 00011101b = 01000111b
-01011010b ^ 00011110b = 01000100b
-01011010b ^ 00011111b = 01000101b
-01011010b ^ 00100000b = 01111010b
-01011010b ^ 00100001b = 01111011b
-01011010b ^ 00100010b = 01111000b
-01011010b ^ 00100011b = 01111001b
-01011010b ^ 00100100b = 01111110b
-01011010b ^ 00100101b = 01111111b
-01011010b ^ 00100110b = 01111100b
-01011010b ^ 00100111b = 01111101b
-01011010b ^ 00101000b = 01110010b
-01011010b ^ 00101001b = 01110011b
-01011010b ^ 00101010b = 01110000b
-01011010b ^ 00101011b = 01110001b
-01011010b ^ 00101100b = 01110110b
-01011010b ^ 00101101b = 01110111b
-01011010b ^ 00101110b = 01110100b
-01011010b ^ 00101111b = 01110101b
-01011010b ^ 00110000b = 01101010b
-01011010b ^ 00110001b = 01101011b
-01011010b ^ 00110010b = 01101000b
-01011010b ^ 00110011b = 01101001b
-01011010b ^ 00110100b = 01101110b
-01011010b ^ 00110101b = 01101111b
-01011010b ^ 00110110b = 01101100b
-01011010b ^ 00110111b = 01101101b
-01011010b ^ 00111000b = 01100010b
-01011010b ^ 00111001b = 01100011b
-01011010b ^ 00111010b = 01100000b
-01011010b ^ 00111011b = 01100001b
-01011010b ^ 00111100b = 01100110b
-01011010b ^ 00111101b = 01100111b
-01011010b ^ 00111110b = 01100100b
-01011010b ^ 00111111b = 01100101b
-01011010b ^ 01000000b = 00011010b
-01011010b ^ 01000001b = 00011011b
-01011010b ^ 01000010b = 00011000b
-01011010b ^ 01000011b = 00011001b
-01011010b ^ 01000100b = 00011110b
-01011010b ^ 01000101b = 00011111b
-01011010b ^ 01000110b = 00011100b
-01011010b ^ 01000111b = 00011101b
-01011010b ^ 01001000b = 00010010b
-01011010b ^ 01001001b = 00010011b
-01011010b ^ 01001010b = 00010000b
-01011010b ^ 01001011b = 00010001b
-01011010b ^ 01001100b = 00010110b
-01011010b ^ 01001101b = 00010111b
-01011010b ^ 01001110b = 00010100b
-01011010b ^ 01001111b = 00010101b
-01011010b ^ 01010000b = 00001010b
-01011010b ^ 01010001b = 00001011b
-01011010b ^ 01010010b = 00001000b
-01011010b ^ 01010011b = 00001001b
-01011010b ^ 01010100b = 00001110b
-01011010b ^ 01010101b = 00001111b
-01011010b ^ 01010110b = 00001100b
-01011010b ^ 01010111b = 00001101b
-01011010b ^ 01011000b = 00000010b
-01011010b ^ 01011001b = 00000011b
-01011010b ^ 01011010b = 00000000b
-01011010b ^ 01011011b = 00000001b
-01011010b ^ 01011100b = 00000110b
-01011010b ^ 01011101b = 00000111b
-01011010b ^ 01011110b = 00000100b
-01011010b ^ 01011111b = 00000101b
-01011010b ^ 01100000b = 00111010b
-01011010b ^ 01100001b = 00111011b
-01011010b ^ 01100010b = 00111000b
-01011010b ^ 01100011b = 00111001b
-01011010b ^ 01100100b = 00111110b
-01011010b ^ 01100101b = 00111111b
-01011010b ^ 01100110b = 00111100b
-01011010b ^ 01100111b = 00111101b
-01011010b ^ 01101000b = 00110010b
-01011010b ^ 01101001b = 00110011b
-01011010b ^ 01101010b = 00110000b
-01011010b ^ 01101011b = 00110001b
-01011010b ^ 01101100b = 00110110b
-01011010b ^ 01101101b = 00110111b
-01011010b ^ 01101110b = 00110100b
-01011010b ^ 01101111b = 00110101b
-01011010b ^ 01110000b = 00101010b
-01011010b ^ 01110001b = 00101011b
-01011010b ^ 01110010b = 00101000b
-01011010b ^ 01110011b = 00101001b
-01011010b ^ 01110100b = 00101110b
-01011010b ^ 01110101b = 00101111b
-01011010b ^ 01110110b = 00101100b
-01011010b ^ 01110111b = 00101101b
-01011010b ^ 01111000b = 00100010b
-01011010b ^ 01111001b = 00100011b
-01011010b ^ 01111010b = 00100000b
-01011010b ^ 01111011b = 00100001b
-01011010b ^ 01111100b = 00100110b
-01011010b ^ 01111101b = 00100111b
-01011010b ^ 01111110b = 00100100b
-01011011b ^ 10000000b = 11011011b
-01011011b ^ 10000001b = 11011010b
-01011011b ^ 10000010b = 11011001b
-01011011b ^ 10000011b = 11011000b
-01011011b ^ 10000100b = 11011111b
-01011011b ^ 10000101b = 11011110b
-01011011b ^ 10000110b = 11011101b
-01011011b ^ 10000111b = 11011100b
-01011011b ^ 10001000b = 11010011b
-01011011b ^ 10001001b = 11010010b
-01011011b ^ 10001010b = 11010001b
-01011011b ^ 10001011b = 11010000b
-01011011b ^ 10001100b = 11010111b
-01011011b ^ 10001101b = 11010110b
-01011011b ^ 10001110b = 11010101b
-01011011b ^ 10001111b = 11010100b
-01011011b ^ 10010000b = 11001011b
-01011011b ^ 10010001b = 11001010b
-01011011b ^ 10010010b = 11001001b
-01011011b ^ 10010011b = 11001000b
-01011011b ^ 10010100b = 11001111b
-01011011b ^ 10010101b = 11001110b
-01011011b ^ 10010110b = 11001101b
-01011011b ^ 10010111b = 11001100b
-01011011b ^ 10011000b = 11000011b
-01011011b ^ 10011001b = 11000010b
-01011011b ^ 10011010b = 11000001b
-01011011b ^ 10011011b = 11000000b
-01011011b ^ 10011100b = 11000111b
-01011011b ^ 10011101b = 11000110b
-01011011b ^ 10011110b = 11000101b
-01011011b ^ 10011111b = 11000100b
-01011011b ^ 10100000b = 11111011b
-01011011b ^ 10100001b = 11111010b
-01011011b ^ 10100010b = 11111001b
-01011011b ^ 10100011b = 11111000b
-01011011b ^ 10100100b = 11111111b
-01011011b ^ 10100101b = 11111110b
-01011011b ^ 10100110b = 11111101b
-01011011b ^ 10100111b = 11111100b
-01011011b ^ 10101000b = 11110011b
-01011011b ^ 10101001b = 11110010b
-01011011b ^ 10101010b = 11110001b
-01011011b ^ 10101011b = 11110000b
-01011011b ^ 10101100b = 11110111b
-01011011b ^ 10101101b = 11110110b
-01011011b ^ 10101110b = 11110101b
-01011011b ^ 10101111b = 11110100b
-01011011b ^ 10110000b = 11101011b
-01011011b ^ 10110001b = 11101010b
-01011011b ^ 10110010b = 11101001b
-01011011b ^ 10110011b = 11101000b
-01011011b ^ 10110100b = 11101111b
-01011011b ^ 10110101b = 11101110b
-01011011b ^ 10110110b = 11101101b
-01011011b ^ 10110111b = 11101100b
-01011011b ^ 10111000b = 11100011b
-01011011b ^ 10111001b = 11100010b
-01011011b ^ 10111010b = 11100001b
-01011011b ^ 10111011b = 11100000b
-01011011b ^ 10111100b = 11100111b
-01011011b ^ 10111101b = 11100110b
-01011011b ^ 10111110b = 11100101b
-01011011b ^ 10111111b = 11100100b
-01011011b ^ 11000000b = 10011011b
-01011011b ^ 11000001b = 10011010b
-01011011b ^ 11000010b = 10011001b
-01011011b ^ 11000011b = 10011000b
-01011011b ^ 11000100b = 10011111b
-01011011b ^ 11000101b = 10011110b
-01011011b ^ 11000110b = 10011101b
-01011011b ^ 11000111b = 10011100b
-01011011b ^ 11001000b = 10010011b
-01011011b ^ 11001001b = 10010010b
-01011011b ^ 11001010b = 10010001b
-01011011b ^ 11001011b = 10010000b
-01011011b ^ 11001100b = 10010111b
-01011011b ^ 11001101b = 10010110b
-01011011b ^ 11001110b = 10010101b
-01011011b ^ 11001111b = 10010100b
-01011011b ^ 11010000b = 10001011b
-01011011b ^ 11010001b = 10001010b
-01011011b ^ 11010010b = 10001001b
-01011011b ^ 11010011b = 10001000b
-01011011b ^ 11010100b = 10001111b
-01011011b ^ 11010101b = 10001110b
-01011011b ^ 11010110b = 10001101b
-01011011b ^ 11010111b = 10001100b
-01011011b ^ 11011000b = 10000011b
-01011011b ^ 11011001b = 10000010b
-01011011b ^ 11011010b = 10000001b
-01011011b ^ 11011011b = 10000000b
-01011011b ^ 11011100b = 10000111b
-01011011b ^ 11011101b = 10000110b
-01011011b ^ 11011110b = 10000101b
-01011011b ^ 11011111b = 10000100b
-01011011b ^ 11100000b = 10111011b
-01011011b ^ 11100001b = 10111010b
-01011011b ^ 11100010b = 10111001b
-01011011b ^ 11100011b = 10111000b
-01011011b ^ 11100100b = 10111111b
-01011011b ^ 11100101b = 10111110b
-01011011b ^ 11100110b = 10111101b
-01011011b ^ 11100111b = 10111100b
-01011011b ^ 11101000b = 10110011b
-01011011b ^ 11101001b = 10110010b
-01011011b ^ 11101010b = 10110001b
-01011011b ^ 11101011b = 10110000b
-01011011b ^ 11101100b = 10110111b
-01011011b ^ 11101101b = 10110110b
-01011011b ^ 11101110b = 10110101b
-01011011b ^ 11101111b = 10110100b
-01011011b ^ 11110000b = 10101011b
-01011011b ^ 11110001b = 10101010b
-01011011b ^ 11110010b = 10101001b
-01011011b ^ 11110011b = 10101000b
-01011011b ^ 11110100b = 10101111b
-01011011b ^ 11110101b = 10101110b
-01011011b ^ 11110110b = 10101101b
-01011011b ^ 11110111b = 10101100b
-01011011b ^ 11111000b = 10100011b
-01011011b ^ 11111001b = 10100010b
-01011011b ^ 11111010b = 10100001b
-01011011b ^ 11111011b = 10100000b
-01011011b ^ 11111100b = 10100111b
-01011011b ^ 11111101b = 10100110b
-01011011b ^ 11111110b = 10100101b
-01011011b ^ 11111111b = 10100100b
-01011011b ^ 00000000b = 01011011b
-01011011b ^ 00000001b = 01011010b
-01011011b ^ 00000010b = 01011001b
-01011011b ^ 00000011b = 01011000b
-01011011b ^ 00000100b = 01011111b
-01011011b ^ 00000101b = 01011110b
-01011011b ^ 00000110b = 01011101b
-01011011b ^ 00000111b = 01011100b
-01011011b ^ 00001000b = 01010011b
-01011011b ^ 00001001b = 01010010b
-01011011b ^ 00001010b = 01010001b
-01011011b ^ 00001011b = 01010000b
-01011011b ^ 00001100b = 01010111b
-01011011b ^ 00001101b = 01010110b
-01011011b ^ 00001110b = 01010101b
-01011011b ^ 00001111b = 01010100b
-01011011b ^ 00010000b = 01001011b
-01011011b ^ 00010001b = 01001010b
-01011011b ^ 00010010b = 01001001b
-01011011b ^ 00010011b = 01001000b
-01011011b ^ 00010100b = 01001111b
-01011011b ^ 00010101b = 01001110b
-01011011b ^ 00010110b = 01001101b
-01011011b ^ 00010111b = 01001100b
-01011011b ^ 00011000b = 01000011b
-01011011b ^ 00011001b = 01000010b
-01011011b ^ 00011010b = 01000001b
-01011011b ^ 00011011b = 01000000b
-01011011b ^ 00011100b = 01000111b
-01011011b ^ 00011101b = 01000110b
-01011011b ^ 00011110b = 01000101b
-01011011b ^ 00011111b = 01000100b
-01011011b ^ 00100000b = 01111011b
-01011011b ^ 00100001b = 01111010b
-01011011b ^ 00100010b = 01111001b
-01011011b ^ 00100011b = 01111000b
-01011011b ^ 00100100b = 01111111b
-01011011b ^ 00100101b = 01111110b
-01011011b ^ 00100110b = 01111101b
-01011011b ^ 00100111b = 01111100b
-01011011b ^ 00101000b = 01110011b
-01011011b ^ 00101001b = 01110010b
-01011011b ^ 00101010b = 01110001b
-01011011b ^ 00101011b = 01110000b
-01011011b ^ 00101100b = 01110111b
-01011011b ^ 00101101b = 01110110b
-01011011b ^ 00101110b = 01110101b
-01011011b ^ 00101111b = 01110100b
-01011011b ^ 00110000b = 01101011b
-01011011b ^ 00110001b = 01101010b
-01011011b ^ 00110010b = 01101001b
-01011011b ^ 00110011b = 01101000b
-01011011b ^ 00110100b = 01101111b
-01011011b ^ 00110101b = 01101110b
-01011011b ^ 00110110b = 01101101b
-01011011b ^ 00110111b = 01101100b
-01011011b ^ 00111000b = 01100011b
-01011011b ^ 00111001b = 01100010b
-01011011b ^ 00111010b = 01100001b
-01011011b ^ 00111011b = 01100000b
-01011011b ^ 00111100b = 01100111b
-01011011b ^ 00111101b = 01100110b
-01011011b ^ 00111110b = 01100101b
-01011011b ^ 00111111b = 01100100b
-01011011b ^ 01000000b = 00011011b
-01011011b ^ 01000001b = 00011010b
-01011011b ^ 01000010b = 00011001b
-01011011b ^ 01000011b = 00011000b
-01011011b ^ 01000100b = 00011111b
-01011011b ^ 01000101b = 00011110b
-01011011b ^ 01000110b = 00011101b
-01011011b ^ 01000111b = 00011100b
-01011011b ^ 01001000b = 00010011b
-01011011b ^ 01001001b = 00010010b
-01011011b ^ 01001010b = 00010001b
-01011011b ^ 01001011b = 00010000b
-01011011b ^ 01001100b = 00010111b
-01011011b ^ 01001101b = 00010110b
-01011011b ^ 01001110b = 00010101b
-01011011b ^ 01001111b = 00010100b
-01011011b ^ 01010000b = 00001011b
-01011011b ^ 01010001b = 00001010b
-01011011b ^ 01010010b = 00001001b
-01011011b ^ 01010011b = 00001000b
-01011011b ^ 01010100b = 00001111b
-01011011b ^ 01010101b = 00001110b
-01011011b ^ 01010110b = 00001101b
-01011011b ^ 01010111b = 00001100b
-01011011b ^ 01011000b = 00000011b
-01011011b ^ 01011001b = 00000010b
-01011011b ^ 01011010b = 00000001b
-01011011b ^ 01011011b = 00000000b
-01011011b ^ 01011100b = 00000111b
-01011011b ^ 01011101b = 00000110b
-01011011b ^ 01011110b = 00000101b
-01011011b ^ 01011111b = 00000100b
-01011011b ^ 01100000b = 00111011b
-01011011b ^ 01100001b = 00111010b
-01011011b ^ 01100010b = 00111001b
-01011011b ^ 01100011b = 00111000b
-01011011b ^ 01100100b = 00111111b
-01011011b ^ 01100101b = 00111110b
-01011011b ^ 01100110b = 00111101b
-01011011b ^ 01100111b = 00111100b
-01011011b ^ 01101000b = 00110011b
-01011011b ^ 01101001b = 00110010b
-01011011b ^ 01101010b = 00110001b
-01011011b ^ 01101011b = 00110000b
-01011011b ^ 01101100b = 00110111b
-01011011b ^ 01101101b = 00110110b
-01011011b ^ 01101110b = 00110101b
-01011011b ^ 01101111b = 00110100b
-01011011b ^ 01110000b = 00101011b
-01011011b ^ 01110001b = 00101010b
-01011011b ^ 01110010b = 00101001b
-01011011b ^ 01110011b = 00101000b
-01011011b ^ 01110100b = 00101111b
-01011011b ^ 01110101b = 00101110b
-01011011b ^ 01110110b = 00101101b
-01011011b ^ 01110111b = 00101100b
-01011011b ^ 01111000b = 00100011b
-01011011b ^ 01111001b = 00100010b
-01011011b ^ 01111010b = 00100001b
-01011011b ^ 01111011b = 00100000b
-01011011b ^ 01111100b = 00100111b
-01011011b ^ 01111101b = 00100110b
-01011011b ^ 01111110b = 00100101b
-01011100b ^ 10000000b = 11011100b
-01011100b ^ 10000001b = 11011101b
-01011100b ^ 10000010b = 11011110b
-01011100b ^ 10000011b = 11011111b
-01011100b ^ 10000100b = 11011000b
-01011100b ^ 10000101b = 11011001b
-01011100b ^ 10000110b = 11011010b
-01011100b ^ 10000111b = 11011011b
-01011100b ^ 10001000b = 11010100b
-01011100b ^ 10001001b = 11010101b
-01011100b ^ 10001010b = 11010110b
-01011100b ^ 10001011b = 11010111b
-01011100b ^ 10001100b = 11010000b
-01011100b ^ 10001101b = 11010001b
-01011100b ^ 10001110b = 11010010b
-01011100b ^ 10001111b = 11010011b
-01011100b ^ 10010000b = 11001100b
-01011100b ^ 10010001b = 11001101b
-01011100b ^ 10010010b = 11001110b
-01011100b ^ 10010011b = 11001111b
-01011100b ^ 10010100b = 11001000b
-01011100b ^ 10010101b = 11001001b
-01011100b ^ 10010110b = 11001010b
-01011100b ^ 10010111b = 11001011b
-01011100b ^ 10011000b = 11000100b
-01011100b ^ 10011001b = 11000101b
-01011100b ^ 10011010b = 11000110b
-01011100b ^ 10011011b = 11000111b
-01011100b ^ 10011100b = 11000000b
-01011100b ^ 10011101b = 11000001b
-01011100b ^ 10011110b = 11000010b
-01011100b ^ 10011111b = 11000011b
-01011100b ^ 10100000b = 11111100b
-01011100b ^ 10100001b = 11111101b
-01011100b ^ 10100010b = 11111110b
-01011100b ^ 10100011b = 11111111b
-01011100b ^ 10100100b = 11111000b
-01011100b ^ 10100101b = 11111001b
-01011100b ^ 10100110b = 11111010b
-01011100b ^ 10100111b = 11111011b
-01011100b ^ 10101000b = 11110100b
-01011100b ^ 10101001b = 11110101b
-01011100b ^ 10101010b = 11110110b
-01011100b ^ 10101011b = 11110111b
-01011100b ^ 10101100b = 11110000b
-01011100b ^ 10101101b = 11110001b
-01011100b ^ 10101110b = 11110010b
-01011100b ^ 10101111b = 11110011b
-01011100b ^ 10110000b = 11101100b
-01011100b ^ 10110001b = 11101101b
-01011100b ^ 10110010b = 11101110b
-01011100b ^ 10110011b = 11101111b
-01011100b ^ 10110100b = 11101000b
-01011100b ^ 10110101b = 11101001b
-01011100b ^ 10110110b = 11101010b
-01011100b ^ 10110111b = 11101011b
-01011100b ^ 10111000b = 11100100b
-01011100b ^ 10111001b = 11100101b
-01011100b ^ 10111010b = 11100110b
-01011100b ^ 10111011b = 11100111b
-01011100b ^ 10111100b = 11100000b
-01011100b ^ 10111101b = 11100001b
-01011100b ^ 10111110b = 11100010b
-01011100b ^ 10111111b = 11100011b
-01011100b ^ 11000000b = 10011100b
-01011100b ^ 11000001b = 10011101b
-01011100b ^ 11000010b = 10011110b
-01011100b ^ 11000011b = 10011111b
-01011100b ^ 11000100b = 10011000b
-01011100b ^ 11000101b = 10011001b
-01011100b ^ 11000110b = 10011010b
-01011100b ^ 11000111b = 10011011b
-01011100b ^ 11001000b = 10010100b
-01011100b ^ 11001001b = 10010101b
-01011100b ^ 11001010b = 10010110b
-01011100b ^ 11001011b = 10010111b
-01011100b ^ 11001100b = 10010000b
-01011100b ^ 11001101b = 10010001b
-01011100b ^ 11001110b = 10010010b
-01011100b ^ 11001111b = 10010011b
-01011100b ^ 11010000b = 10001100b
-01011100b ^ 11010001b = 10001101b
-01011100b ^ 11010010b = 10001110b
-01011100b ^ 11010011b = 10001111b
-01011100b ^ 11010100b = 10001000b
-01011100b ^ 11010101b = 10001001b
-01011100b ^ 11010110b = 10001010b
-01011100b ^ 11010111b = 10001011b
-01011100b ^ 11011000b = 10000100b
-01011100b ^ 11011001b = 10000101b
-01011100b ^ 11011010b = 10000110b
-01011100b ^ 11011011b = 10000111b
-01011100b ^ 11011100b = 10000000b
-01011100b ^ 11011101b = 10000001b
-01011100b ^ 11011110b = 10000010b
-01011100b ^ 11011111b = 10000011b
-01011100b ^ 11100000b = 10111100b
-01011100b ^ 11100001b = 10111101b
-01011100b ^ 11100010b = 10111110b
-01011100b ^ 11100011b = 10111111b
-01011100b ^ 11100100b = 10111000b
-01011100b ^ 11100101b = 10111001b
-01011100b ^ 11100110b = 10111010b
-01011100b ^ 11100111b = 10111011b
-01011100b ^ 11101000b = 10110100b
-01011100b ^ 11101001b = 10110101b
-01011100b ^ 11101010b = 10110110b
-01011100b ^ 11101011b = 10110111b
-01011100b ^ 11101100b = 10110000b
-01011100b ^ 11101101b = 10110001b
-01011100b ^ 11101110b = 10110010b
-01011100b ^ 11101111b = 10110011b
-01011100b ^ 11110000b = 10101100b
-01011100b ^ 11110001b = 10101101b
-01011100b ^ 11110010b = 10101110b
-01011100b ^ 11110011b = 10101111b
-01011100b ^ 11110100b = 10101000b
-01011100b ^ 11110101b = 10101001b
-01011100b ^ 11110110b = 10101010b
-01011100b ^ 11110111b = 10101011b
-01011100b ^ 11111000b = 10100100b
-01011100b ^ 11111001b = 10100101b
-01011100b ^ 11111010b = 10100110b
-01011100b ^ 11111011b = 10100111b
-01011100b ^ 11111100b = 10100000b
-01011100b ^ 11111101b = 10100001b
-01011100b ^ 11111110b = 10100010b
-01011100b ^ 11111111b = 10100011b
-01011100b ^ 00000000b = 01011100b
-01011100b ^ 00000001b = 01011101b
-01011100b ^ 00000010b = 01011110b
-01011100b ^ 00000011b = 01011111b
-01011100b ^ 00000100b = 01011000b
-01011100b ^ 00000101b = 01011001b
-01011100b ^ 00000110b = 01011010b
-01011100b ^ 00000111b = 01011011b
-01011100b ^ 00001000b = 01010100b
-01011100b ^ 00001001b = 01010101b
-01011100b ^ 00001010b = 01010110b
-01011100b ^ 00001011b = 01010111b
-01011100b ^ 00001100b = 01010000b
-01011100b ^ 00001101b = 01010001b
-01011100b ^ 00001110b = 01010010b
-01011100b ^ 00001111b = 01010011b
-01011100b ^ 00010000b = 01001100b
-01011100b ^ 00010001b = 01001101b
-01011100b ^ 00010010b = 01001110b
-01011100b ^ 00010011b = 01001111b
-01011100b ^ 00010100b = 01001000b
-01011100b ^ 00010101b = 01001001b
-01011100b ^ 00010110b = 01001010b
-01011100b ^ 00010111b = 01001011b
-01011100b ^ 00011000b = 01000100b
-01011100b ^ 00011001b = 01000101b
-01011100b ^ 00011010b = 01000110b
-01011100b ^ 00011011b = 01000111b
-01011100b ^ 00011100b = 01000000b
-01011100b ^ 00011101b = 01000001b
-01011100b ^ 00011110b = 01000010b
-01011100b ^ 00011111b = 01000011b
-01011100b ^ 00100000b = 01111100b
-01011100b ^ 00100001b = 01111101b
-01011100b ^ 00100010b = 01111110b
-01011100b ^ 00100011b = 01111111b
-01011100b ^ 00100100b = 01111000b
-01011100b ^ 00100101b = 01111001b
-01011100b ^ 00100110b = 01111010b
-01011100b ^ 00100111b = 01111011b
-01011100b ^ 00101000b = 01110100b
-01011100b ^ 00101001b = 01110101b
-01011100b ^ 00101010b = 01110110b
-01011100b ^ 00101011b = 01110111b
-01011100b ^ 00101100b = 01110000b
-01011100b ^ 00101101b = 01110001b
-01011100b ^ 00101110b = 01110010b
-01011100b ^ 00101111b = 01110011b
-01011100b ^ 00110000b = 01101100b
-01011100b ^ 00110001b = 01101101b
-01011100b ^ 00110010b = 01101110b
-01011100b ^ 00110011b = 01101111b
-01011100b ^ 00110100b = 01101000b
-01011100b ^ 00110101b = 01101001b
-01011100b ^ 00110110b = 01101010b
-01011100b ^ 00110111b = 01101011b
-01011100b ^ 00111000b = 01100100b
-01011100b ^ 00111001b = 01100101b
-01011100b ^ 00111010b = 01100110b
-01011100b ^ 00111011b = 01100111b
-01011100b ^ 00111100b = 01100000b
-01011100b ^ 00111101b = 01100001b
-01011100b ^ 00111110b = 01100010b
-01011100b ^ 00111111b = 01100011b
-01011100b ^ 01000000b = 00011100b
-01011100b ^ 01000001b = 00011101b
-01011100b ^ 01000010b = 00011110b
-01011100b ^ 01000011b = 00011111b
-01011100b ^ 01000100b = 00011000b
-01011100b ^ 01000101b = 00011001b
-01011100b ^ 01000110b = 00011010b
-01011100b ^ 01000111b = 00011011b
-01011100b ^ 01001000b = 00010100b
-01011100b ^ 01001001b = 00010101b
-01011100b ^ 01001010b = 00010110b
-01011100b ^ 01001011b = 00010111b
-01011100b ^ 01001100b = 00010000b
-01011100b ^ 01001101b = 00010001b
-01011100b ^ 01001110b = 00010010b
-01011100b ^ 01001111b = 00010011b
-01011100b ^ 01010000b = 00001100b
-01011100b ^ 01010001b = 00001101b
-01011100b ^ 01010010b = 00001110b
-01011100b ^ 01010011b = 00001111b
-01011100b ^ 01010100b = 00001000b
-01011100b ^ 01010101b = 00001001b
-01011100b ^ 01010110b = 00001010b
-01011100b ^ 01010111b = 00001011b
-01011100b ^ 01011000b = 00000100b
-01011100b ^ 01011001b = 00000101b
-01011100b ^ 01011010b = 00000110b
-01011100b ^ 01011011b = 00000111b
-01011100b ^ 01011100b = 00000000b
-01011100b ^ 01011101b = 00000001b
-01011100b ^ 01011110b = 00000010b
-01011100b ^ 01011111b = 00000011b
-01011100b ^ 01100000b = 00111100b
-01011100b ^ 01100001b = 00111101b
-01011100b ^ 01100010b = 00111110b
-01011100b ^ 01100011b = 00111111b
-01011100b ^ 01100100b = 00111000b
-01011100b ^ 01100101b = 00111001b
-01011100b ^ 01100110b = 00111010b
-01011100b ^ 01100111b = 00111011b
-01011100b ^ 01101000b = 00110100b
-01011100b ^ 01101001b = 00110101b
-01011100b ^ 01101010b = 00110110b
-01011100b ^ 01101011b = 00110111b
-01011100b ^ 01101100b = 00110000b
-01011100b ^ 01101101b = 00110001b
-01011100b ^ 01101110b = 00110010b
-01011100b ^ 01101111b = 00110011b
-01011100b ^ 01110000b = 00101100b
-01011100b ^ 01110001b = 00101101b
-01011100b ^ 01110010b = 00101110b
-01011100b ^ 01110011b = 00101111b
-01011100b ^ 01110100b = 00101000b
-01011100b ^ 01110101b = 00101001b
-01011100b ^ 01110110b = 00101010b
-01011100b ^ 01110111b = 00101011b
-01011100b ^ 01111000b = 00100100b
-01011100b ^ 01111001b = 00100101b
-01011100b ^ 01111010b = 00100110b
-01011100b ^ 01111011b = 00100111b
-01011100b ^ 01111100b = 00100000b
-01011100b ^ 01111101b = 00100001b
-01011100b ^ 01111110b = 00100010b
-01011101b ^ 10000000b = 11011101b
-01011101b ^ 10000001b = 11011100b
-01011101b ^ 10000010b = 11011111b
-01011101b ^ 10000011b = 11011110b
-01011101b ^ 10000100b = 11011001b
-01011101b ^ 10000101b = 11011000b
-01011101b ^ 10000110b = 11011011b
-01011101b ^ 10000111b = 11011010b
-01011101b ^ 10001000b = 11010101b
-01011101b ^ 10001001b = 11010100b
-01011101b ^ 10001010b = 11010111b
-01011101b ^ 10001011b = 11010110b
-01011101b ^ 10001100b = 11010001b
-01011101b ^ 10001101b = 11010000b
-01011101b ^ 10001110b = 11010011b
-01011101b ^ 10001111b = 11010010b
-01011101b ^ 10010000b = 11001101b
-01011101b ^ 10010001b = 11001100b
-01011101b ^ 10010010b = 11001111b
-01011101b ^ 10010011b = 11001110b
-01011101b ^ 10010100b = 11001001b
-01011101b ^ 10010101b = 11001000b
-01011101b ^ 10010110b = 11001011b
-01011101b ^ 10010111b = 11001010b
-01011101b ^ 10011000b = 11000101b
-01011101b ^ 10011001b = 11000100b
-01011101b ^ 10011010b = 11000111b
-01011101b ^ 10011011b = 11000110b
-01011101b ^ 10011100b = 11000001b
-01011101b ^ 10011101b = 11000000b
-01011101b ^ 10011110b = 11000011b
-01011101b ^ 10011111b = 11000010b
-01011101b ^ 10100000b = 11111101b
-01011101b ^ 10100001b = 11111100b
-01011101b ^ 10100010b = 11111111b
-01011101b ^ 10100011b = 11111110b
-01011101b ^ 10100100b = 11111001b
-01011101b ^ 10100101b = 11111000b
-01011101b ^ 10100110b = 11111011b
-01011101b ^ 10100111b = 11111010b
-01011101b ^ 10101000b = 11110101b
-01011101b ^ 10101001b = 11110100b
-01011101b ^ 10101010b = 11110111b
-01011101b ^ 10101011b = 11110110b
-01011101b ^ 10101100b = 11110001b
-01011101b ^ 10101101b = 11110000b
-01011101b ^ 10101110b = 11110011b
-01011101b ^ 10101111b = 11110010b
-01011101b ^ 10110000b = 11101101b
-01011101b ^ 10110001b = 11101100b
-01011101b ^ 10110010b = 11101111b
-01011101b ^ 10110011b = 11101110b
-01011101b ^ 10110100b = 11101001b
-01011101b ^ 10110101b = 11101000b
-01011101b ^ 10110110b = 11101011b
-01011101b ^ 10110111b = 11101010b
-01011101b ^ 10111000b = 11100101b
-01011101b ^ 10111001b = 11100100b
-01011101b ^ 10111010b = 11100111b
-01011101b ^ 10111011b = 11100110b
-01011101b ^ 10111100b = 11100001b
-01011101b ^ 10111101b = 11100000b
-01011101b ^ 10111110b = 11100011b
-01011101b ^ 10111111b = 11100010b
-01011101b ^ 11000000b = 10011101b
-01011101b ^ 11000001b = 10011100b
-01011101b ^ 11000010b = 10011111b
-01011101b ^ 11000011b = 10011110b
-01011101b ^ 11000100b = 10011001b
-01011101b ^ 11000101b = 10011000b
-01011101b ^ 11000110b = 10011011b
-01011101b ^ 11000111b = 10011010b
-01011101b ^ 11001000b = 10010101b
-01011101b ^ 11001001b = 10010100b
-01011101b ^ 11001010b = 10010111b
-01011101b ^ 11001011b = 10010110b
-01011101b ^ 11001100b = 10010001b
-01011101b ^ 11001101b = 10010000b
-01011101b ^ 11001110b = 10010011b
-01011101b ^ 11001111b = 10010010b
-01011101b ^ 11010000b = 10001101b
-01011101b ^ 11010001b = 10001100b
-01011101b ^ 11010010b = 10001111b
-01011101b ^ 11010011b = 10001110b
-01011101b ^ 11010100b = 10001001b
-01011101b ^ 11010101b = 10001000b
-01011101b ^ 11010110b = 10001011b
-01011101b ^ 11010111b = 10001010b
-01011101b ^ 11011000b = 10000101b
-01011101b ^ 11011001b = 10000100b
-01011101b ^ 11011010b = 10000111b
-01011101b ^ 11011011b = 10000110b
-01011101b ^ 11011100b = 10000001b
-01011101b ^ 11011101b = 10000000b
-01011101b ^ 11011110b = 10000011b
-01011101b ^ 11011111b = 10000010b
-01011101b ^ 11100000b = 10111101b
-01011101b ^ 11100001b = 10111100b
-01011101b ^ 11100010b = 10111111b
-01011101b ^ 11100011b = 10111110b
-01011101b ^ 11100100b = 10111001b
-01011101b ^ 11100101b = 10111000b
-01011101b ^ 11100110b = 10111011b
-01011101b ^ 11100111b = 10111010b
-01011101b ^ 11101000b = 10110101b
-01011101b ^ 11101001b = 10110100b
-01011101b ^ 11101010b = 10110111b
-01011101b ^ 11101011b = 10110110b
-01011101b ^ 11101100b = 10110001b
-01011101b ^ 11101101b = 10110000b
-01011101b ^ 11101110b = 10110011b
-01011101b ^ 11101111b = 10110010b
-01011101b ^ 11110000b = 10101101b
-01011101b ^ 11110001b = 10101100b
-01011101b ^ 11110010b = 10101111b
-01011101b ^ 11110011b = 10101110b
-01011101b ^ 11110100b = 10101001b
-01011101b ^ 11110101b = 10101000b
-01011101b ^ 11110110b = 10101011b
-01011101b ^ 11110111b = 10101010b
-01011101b ^ 11111000b = 10100101b
-01011101b ^ 11111001b = 10100100b
-01011101b ^ 11111010b = 10100111b
-01011101b ^ 11111011b = 10100110b
-01011101b ^ 11111100b = 10100001b
-01011101b ^ 11111101b = 10100000b
-01011101b ^ 11111110b = 10100011b
-01011101b ^ 11111111b = 10100010b
-01011101b ^ 00000000b = 01011101b
-01011101b ^ 00000001b = 01011100b
-01011101b ^ 00000010b = 01011111b
-01011101b ^ 00000011b = 01011110b
-01011101b ^ 00000100b = 01011001b
-01011101b ^ 00000101b = 01011000b
-01011101b ^ 00000110b = 01011011b
-01011101b ^ 00000111b = 01011010b
-01011101b ^ 00001000b = 01010101b
-01011101b ^ 00001001b = 01010100b
-01011101b ^ 00001010b = 01010111b
-01011101b ^ 00001011b = 01010110b
-01011101b ^ 00001100b = 01010001b
-01011101b ^ 00001101b = 01010000b
-01011101b ^ 00001110b = 01010011b
-01011101b ^ 00001111b = 01010010b
-01011101b ^ 00010000b = 01001101b
-01011101b ^ 00010001b = 01001100b
-01011101b ^ 00010010b = 01001111b
-01011101b ^ 00010011b = 01001110b
-01011101b ^ 00010100b = 01001001b
-01011101b ^ 00010101b = 01001000b
-01011101b ^ 00010110b = 01001011b
-01011101b ^ 00010111b = 01001010b
-01011101b ^ 00011000b = 01000101b
-01011101b ^ 00011001b = 01000100b
-01011101b ^ 00011010b = 01000111b
-01011101b ^ 00011011b = 01000110b
-01011101b ^ 00011100b = 01000001b
-01011101b ^ 00011101b = 01000000b
-01011101b ^ 00011110b = 01000011b
-01011101b ^ 00011111b = 01000010b
-01011101b ^ 00100000b = 01111101b
-01011101b ^ 00100001b = 01111100b
-01011101b ^ 00100010b = 01111111b
-01011101b ^ 00100011b = 01111110b
-01011101b ^ 00100100b = 01111001b
-01011101b ^ 00100101b = 01111000b
-01011101b ^ 00100110b = 01111011b
-01011101b ^ 00100111b = 01111010b
-01011101b ^ 00101000b = 01110101b
-01011101b ^ 00101001b = 01110100b
-01011101b ^ 00101010b = 01110111b
-01011101b ^ 00101011b = 01110110b
-01011101b ^ 00101100b = 01110001b
-01011101b ^ 00101101b = 01110000b
-01011101b ^ 00101110b = 01110011b
-01011101b ^ 00101111b = 01110010b
-01011101b ^ 00110000b = 01101101b
-01011101b ^ 00110001b = 01101100b
-01011101b ^ 00110010b = 01101111b
-01011101b ^ 00110011b = 01101110b
-01011101b ^ 00110100b = 01101001b
-01011101b ^ 00110101b = 01101000b
-01011101b ^ 00110110b = 01101011b
-01011101b ^ 00110111b = 01101010b
-01011101b ^ 00111000b = 01100101b
-01011101b ^ 00111001b = 01100100b
-01011101b ^ 00111010b = 01100111b
-01011101b ^ 00111011b = 01100110b
-01011101b ^ 00111100b = 01100001b
-01011101b ^ 00111101b = 01100000b
-01011101b ^ 00111110b = 01100011b
-01011101b ^ 00111111b = 01100010b
-01011101b ^ 01000000b = 00011101b
-01011101b ^ 01000001b = 00011100b
-01011101b ^ 01000010b = 00011111b
-01011101b ^ 01000011b = 00011110b
-01011101b ^ 01000100b = 00011001b
-01011101b ^ 01000101b = 00011000b
-01011101b ^ 01000110b = 00011011b
-01011101b ^ 01000111b = 00011010b
-01011101b ^ 01001000b = 00010101b
-01011101b ^ 01001001b = 00010100b
-01011101b ^ 01001010b = 00010111b
-01011101b ^ 01001011b = 00010110b
-01011101b ^ 01001100b = 00010001b
-01011101b ^ 01001101b = 00010000b
-01011101b ^ 01001110b = 00010011b
-01011101b ^ 01001111b = 00010010b
-01011101b ^ 01010000b = 00001101b
-01011101b ^ 01010001b = 00001100b
-01011101b ^ 01010010b = 00001111b
-01011101b ^ 01010011b = 00001110b
-01011101b ^ 01010100b = 00001001b
-01011101b ^ 01010101b = 00001000b
-01011101b ^ 01010110b = 00001011b
-01011101b ^ 01010111b = 00001010b
-01011101b ^ 01011000b = 00000101b
-01011101b ^ 01011001b = 00000100b
-01011101b ^ 01011010b = 00000111b
-01011101b ^ 01011011b = 00000110b
-01011101b ^ 01011100b = 00000001b
-01011101b ^ 01011101b = 00000000b
-01011101b ^ 01011110b = 00000011b
-01011101b ^ 01011111b = 00000010b
-01011101b ^ 01100000b = 00111101b
-01011101b ^ 01100001b = 00111100b
-01011101b ^ 01100010b = 00111111b
-01011101b ^ 01100011b = 00111110b
-01011101b ^ 01100100b = 00111001b
-01011101b ^ 01100101b = 00111000b
-01011101b ^ 01100110b = 00111011b
-01011101b ^ 01100111b = 00111010b
-01011101b ^ 01101000b = 00110101b
-01011101b ^ 01101001b = 00110100b
-01011101b ^ 01101010b = 00110111b
-01011101b ^ 01101011b = 00110110b
-01011101b ^ 01101100b = 00110001b
-01011101b ^ 01101101b = 00110000b
-01011101b ^ 01101110b = 00110011b
-01011101b ^ 01101111b = 00110010b
-01011101b ^ 01110000b = 00101101b
-01011101b ^ 01110001b = 00101100b
-01011101b ^ 01110010b = 00101111b
-01011101b ^ 01110011b = 00101110b
-01011101b ^ 01110100b = 00101001b
-01011101b ^ 01110101b = 00101000b
-01011101b ^ 01110110b = 00101011b
-01011101b ^ 01110111b = 00101010b
-01011101b ^ 01111000b = 00100101b
-01011101b ^ 01111001b = 00100100b
-01011101b ^ 01111010b = 00100111b
-01011101b ^ 01111011b = 00100110b
-01011101b ^ 01111100b = 00100001b
-01011101b ^ 01111101b = 00100000b
-01011101b ^ 01111110b = 00100011b
-01011110b ^ 10000000b = 11011110b
-01011110b ^ 10000001b = 11011111b
-01011110b ^ 10000010b = 11011100b
-01011110b ^ 10000011b = 11011101b
-01011110b ^ 10000100b = 11011010b
-01011110b ^ 10000101b = 11011011b
-01011110b ^ 10000110b = 11011000b
-01011110b ^ 10000111b = 11011001b
-01011110b ^ 10001000b = 11010110b
-01011110b ^ 10001001b = 11010111b
-01011110b ^ 10001010b = 11010100b
-01011110b ^ 10001011b = 11010101b
-01011110b ^ 10001100b = 11010010b
-01011110b ^ 10001101b = 11010011b
-01011110b ^ 10001110b = 11010000b
-01011110b ^ 10001111b = 11010001b
-01011110b ^ 10010000b = 11001110b
-01011110b ^ 10010001b = 11001111b
-01011110b ^ 10010010b = 11001100b
-01011110b ^ 10010011b = 11001101b
-01011110b ^ 10010100b = 11001010b
-01011110b ^ 10010101b = 11001011b
-01011110b ^ 10010110b = 11001000b
-01011110b ^ 10010111b = 11001001b
-01011110b ^ 10011000b = 11000110b
-01011110b ^ 10011001b = 11000111b
-01011110b ^ 10011010b = 11000100b
-01011110b ^ 10011011b = 11000101b
-01011110b ^ 10011100b = 11000010b
-01011110b ^ 10011101b = 11000011b
-01011110b ^ 10011110b = 11000000b
-01011110b ^ 10011111b = 11000001b
-01011110b ^ 10100000b = 11111110b
-01011110b ^ 10100001b = 11111111b
-01011110b ^ 10100010b = 11111100b
-01011110b ^ 10100011b = 11111101b
-01011110b ^ 10100100b = 11111010b
-01011110b ^ 10100101b = 11111011b
-01011110b ^ 10100110b = 11111000b
-01011110b ^ 10100111b = 11111001b
-01011110b ^ 10101000b = 11110110b
-01011110b ^ 10101001b = 11110111b
-01011110b ^ 10101010b = 11110100b
-01011110b ^ 10101011b = 11110101b
-01011110b ^ 10101100b = 11110010b
-01011110b ^ 10101101b = 11110011b
-01011110b ^ 10101110b = 11110000b
-01011110b ^ 10101111b = 11110001b
-01011110b ^ 10110000b = 11101110b
-01011110b ^ 10110001b = 11101111b
-01011110b ^ 10110010b = 11101100b
-01011110b ^ 10110011b = 11101101b
-01011110b ^ 10110100b = 11101010b
-01011110b ^ 10110101b = 11101011b
-01011110b ^ 10110110b = 11101000b
-01011110b ^ 10110111b = 11101001b
-01011110b ^ 10111000b = 11100110b
-01011110b ^ 10111001b = 11100111b
-01011110b ^ 10111010b = 11100100b
-01011110b ^ 10111011b = 11100101b
-01011110b ^ 10111100b = 11100010b
-01011110b ^ 10111101b = 11100011b
-01011110b ^ 10111110b = 11100000b
-01011110b ^ 10111111b = 11100001b
-01011110b ^ 11000000b = 10011110b
-01011110b ^ 11000001b = 10011111b
-01011110b ^ 11000010b = 10011100b
-01011110b ^ 11000011b = 10011101b
-01011110b ^ 11000100b = 10011010b
-01011110b ^ 11000101b = 10011011b
-01011110b ^ 11000110b = 10011000b
-01011110b ^ 11000111b = 10011001b
-01011110b ^ 11001000b = 10010110b
-01011110b ^ 11001001b = 10010111b
-01011110b ^ 11001010b = 10010100b
-01011110b ^ 11001011b = 10010101b
-01011110b ^ 11001100b = 10010010b
-01011110b ^ 11001101b = 10010011b
-01011110b ^ 11001110b = 10010000b
-01011110b ^ 11001111b = 10010001b
-01011110b ^ 11010000b = 10001110b
-01011110b ^ 11010001b = 10001111b
-01011110b ^ 11010010b = 10001100b
-01011110b ^ 11010011b = 10001101b
-01011110b ^ 11010100b = 10001010b
-01011110b ^ 11010101b = 10001011b
-01011110b ^ 11010110b = 10001000b
-01011110b ^ 11010111b = 10001001b
-01011110b ^ 11011000b = 10000110b
-01011110b ^ 11011001b = 10000111b
-01011110b ^ 11011010b = 10000100b
-01011110b ^ 11011011b = 10000101b
-01011110b ^ 11011100b = 10000010b
-01011110b ^ 11011101b = 10000011b
-01011110b ^ 11011110b = 10000000b
-01011110b ^ 11011111b = 10000001b
-01011110b ^ 11100000b = 10111110b
-01011110b ^ 11100001b = 10111111b
-01011110b ^ 11100010b = 10111100b
-01011110b ^ 11100011b = 10111101b
-01011110b ^ 11100100b = 10111010b
-01011110b ^ 11100101b = 10111011b
-01011110b ^ 11100110b = 10111000b
-01011110b ^ 11100111b = 10111001b
-01011110b ^ 11101000b = 10110110b
-01011110b ^ 11101001b = 10110111b
-01011110b ^ 11101010b = 10110100b
-01011110b ^ 11101011b = 10110101b
-01011110b ^ 11101100b = 10110010b
-01011110b ^ 11101101b = 10110011b
-01011110b ^ 11101110b = 10110000b
-01011110b ^ 11101111b = 10110001b
-01011110b ^ 11110000b = 10101110b
-01011110b ^ 11110001b = 10101111b
-01011110b ^ 11110010b = 10101100b
-01011110b ^ 11110011b = 10101101b
-01011110b ^ 11110100b = 10101010b
-01011110b ^ 11110101b = 10101011b
-01011110b ^ 11110110b = 10101000b
-01011110b ^ 11110111b = 10101001b
-01011110b ^ 11111000b = 10100110b
-01011110b ^ 11111001b = 10100111b
-01011110b ^ 11111010b = 10100100b
-01011110b ^ 11111011b = 10100101b
-01011110b ^ 11111100b = 10100010b
-01011110b ^ 11111101b = 10100011b
-01011110b ^ 11111110b = 10100000b
-01011110b ^ 11111111b = 10100001b
-01011110b ^ 00000000b = 01011110b
-01011110b ^ 00000001b = 01011111b
-01011110b ^ 00000010b = 01011100b
-01011110b ^ 00000011b = 01011101b
-01011110b ^ 00000100b = 01011010b
-01011110b ^ 00000101b = 01011011b
-01011110b ^ 00000110b = 01011000b
-01011110b ^ 00000111b = 01011001b
-01011110b ^ 00001000b = 01010110b
-01011110b ^ 00001001b = 01010111b
-01011110b ^ 00001010b = 01010100b
-01011110b ^ 00001011b = 01010101b
-01011110b ^ 00001100b = 01010010b
-01011110b ^ 00001101b = 01010011b
-01011110b ^ 00001110b = 01010000b
-01011110b ^ 00001111b = 01010001b
-01011110b ^ 00010000b = 01001110b
-01011110b ^ 00010001b = 01001111b
-01011110b ^ 00010010b = 01001100b
-01011110b ^ 00010011b = 01001101b
-01011110b ^ 00010100b = 01001010b
-01011110b ^ 00010101b = 01001011b
-01011110b ^ 00010110b = 01001000b
-01011110b ^ 00010111b = 01001001b
-01011110b ^ 00011000b = 01000110b
-01011110b ^ 00011001b = 01000111b
-01011110b ^ 00011010b = 01000100b
-01011110b ^ 00011011b = 01000101b
-01011110b ^ 00011100b = 01000010b
-01011110b ^ 00011101b = 01000011b
-01011110b ^ 00011110b = 01000000b
-01011110b ^ 00011111b = 01000001b
-01011110b ^ 00100000b = 01111110b
-01011110b ^ 00100001b = 01111111b
-01011110b ^ 00100010b = 01111100b
-01011110b ^ 00100011b = 01111101b
-01011110b ^ 00100100b = 01111010b
-01011110b ^ 00100101b = 01111011b
-01011110b ^ 00100110b = 01111000b
-01011110b ^ 00100111b = 01111001b
-01011110b ^ 00101000b = 01110110b
-01011110b ^ 00101001b = 01110111b
-01011110b ^ 00101010b = 01110100b
-01011110b ^ 00101011b = 01110101b
-01011110b ^ 00101100b = 01110010b
-01011110b ^ 00101101b = 01110011b
-01011110b ^ 00101110b = 01110000b
-01011110b ^ 00101111b = 01110001b
-01011110b ^ 00110000b = 01101110b
-01011110b ^ 00110001b = 01101111b
-01011110b ^ 00110010b = 01101100b
-01011110b ^ 00110011b = 01101101b
-01011110b ^ 00110100b = 01101010b
-01011110b ^ 00110101b = 01101011b
-01011110b ^ 00110110b = 01101000b
-01011110b ^ 00110111b = 01101001b
-01011110b ^ 00111000b = 01100110b
-01011110b ^ 00111001b = 01100111b
-01011110b ^ 00111010b = 01100100b
-01011110b ^ 00111011b = 01100101b
-01011110b ^ 00111100b = 01100010b
-01011110b ^ 00111101b = 01100011b
-01011110b ^ 00111110b = 01100000b
-01011110b ^ 00111111b = 01100001b
-01011110b ^ 01000000b = 00011110b
-01011110b ^ 01000001b = 00011111b
-01011110b ^ 01000010b = 00011100b
-01011110b ^ 01000011b = 00011101b
-01011110b ^ 01000100b = 00011010b
-01011110b ^ 01000101b = 00011011b
-01011110b ^ 01000110b = 00011000b
-01011110b ^ 01000111b = 00011001b
-01011110b ^ 01001000b = 00010110b
-01011110b ^ 01001001b = 00010111b
-01011110b ^ 01001010b = 00010100b
-01011110b ^ 01001011b = 00010101b
-01011110b ^ 01001100b = 00010010b
-01011110b ^ 01001101b = 00010011b
-01011110b ^ 01001110b = 00010000b
-01011110b ^ 01001111b = 00010001b
-01011110b ^ 01010000b = 00001110b
-01011110b ^ 01010001b = 00001111b
-01011110b ^ 01010010b = 00001100b
-01011110b ^ 01010011b = 00001101b
-01011110b ^ 01010100b = 00001010b
-01011110b ^ 01010101b = 00001011b
-01011110b ^ 01010110b = 00001000b
-01011110b ^ 01010111b = 00001001b
-01011110b ^ 01011000b = 00000110b
-01011110b ^ 01011001b = 00000111b
-01011110b ^ 01011010b = 00000100b
-01011110b ^ 01011011b = 00000101b
-01011110b ^ 01011100b = 00000010b
-01011110b ^ 01011101b = 00000011b
-01011110b ^ 01011110b = 00000000b
-01011110b ^ 01011111b = 00000001b
-01011110b ^ 01100000b = 00111110b
-01011110b ^ 01100001b = 00111111b
-01011110b ^ 01100010b = 00111100b
-01011110b ^ 01100011b = 00111101b
-01011110b ^ 01100100b = 00111010b
-01011110b ^ 01100101b = 00111011b
-01011110b ^ 01100110b = 00111000b
-01011110b ^ 01100111b = 00111001b
-01011110b ^ 01101000b = 00110110b
-01011110b ^ 01101001b = 00110111b
-01011110b ^ 01101010b = 00110100b
-01011110b ^ 01101011b = 00110101b
-01011110b ^ 01101100b = 00110010b
-01011110b ^ 01101101b = 00110011b
-01011110b ^ 01101110b = 00110000b
-01011110b ^ 01101111b = 00110001b
-01011110b ^ 01110000b = 00101110b
-01011110b ^ 01110001b = 00101111b
-01011110b ^ 01110010b = 00101100b
-01011110b ^ 01110011b = 00101101b
-01011110b ^ 01110100b = 00101010b
-01011110b ^ 01110101b = 00101011b
-01011110b ^ 01110110b = 00101000b
-01011110b ^ 01110111b = 00101001b
-01011110b ^ 01111000b = 00100110b
-01011110b ^ 01111001b = 00100111b
-01011110b ^ 01111010b = 00100100b
-01011110b ^ 01111011b = 00100101b
-01011110b ^ 01111100b = 00100010b
-01011110b ^ 01111101b = 00100011b
-01011110b ^ 01111110b = 00100000b
-01011111b ^ 10000000b = 11011111b
-01011111b ^ 10000001b = 11011110b
-01011111b ^ 10000010b = 11011101b
-01011111b ^ 10000011b = 11011100b
-01011111b ^ 10000100b = 11011011b
-01011111b ^ 10000101b = 11011010b
-01011111b ^ 10000110b = 11011001b
-01011111b ^ 10000111b = 11011000b
-01011111b ^ 10001000b = 11010111b
-01011111b ^ 10001001b = 11010110b
-01011111b ^ 10001010b = 11010101b
-01011111b ^ 10001011b = 11010100b
-01011111b ^ 10001100b = 11010011b
-01011111b ^ 10001101b = 11010010b
-01011111b ^ 10001110b = 11010001b
-01011111b ^ 10001111b = 11010000b
-01011111b ^ 10010000b = 11001111b
-01011111b ^ 10010001b = 11001110b
-01011111b ^ 10010010b = 11001101b
-01011111b ^ 10010011b = 11001100b
-01011111b ^ 10010100b = 11001011b
-01011111b ^ 10010101b = 11001010b
-01011111b ^ 10010110b = 11001001b
-01011111b ^ 10010111b = 11001000b
-01011111b ^ 10011000b = 11000111b
-01011111b ^ 10011001b = 11000110b
-01011111b ^ 10011010b = 11000101b
-01011111b ^ 10011011b = 11000100b
-01011111b ^ 10011100b = 11000011b
-01011111b ^ 10011101b = 11000010b
-01011111b ^ 10011110b = 11000001b
-01011111b ^ 10011111b = 11000000b
-01011111b ^ 10100000b = 11111111b
-01011111b ^ 10100001b = 11111110b
-01011111b ^ 10100010b = 11111101b
-01011111b ^ 10100011b = 11111100b
-01011111b ^ 10100100b = 11111011b
-01011111b ^ 10100101b = 11111010b
-01011111b ^ 10100110b = 11111001b
-01011111b ^ 10100111b = 11111000b
-01011111b ^ 10101000b = 11110111b
-01011111b ^ 10101001b = 11110110b
-01011111b ^ 10101010b = 11110101b
-01011111b ^ 10101011b = 11110100b
-01011111b ^ 10101100b = 11110011b
-01011111b ^ 10101101b = 11110010b
-01011111b ^ 10101110b = 11110001b
-01011111b ^ 10101111b = 11110000b
-01011111b ^ 10110000b = 11101111b
-01011111b ^ 10110001b = 11101110b
-01011111b ^ 10110010b = 11101101b
-01011111b ^ 10110011b = 11101100b
-01011111b ^ 10110100b = 11101011b
-01011111b ^ 10110101b = 11101010b
-01011111b ^ 10110110b = 11101001b
-01011111b ^ 10110111b = 11101000b
-01011111b ^ 10111000b = 11100111b
-01011111b ^ 10111001b = 11100110b
-01011111b ^ 10111010b = 11100101b
-01011111b ^ 10111011b = 11100100b
-01011111b ^ 10111100b = 11100011b
-01011111b ^ 10111101b = 11100010b
-01011111b ^ 10111110b = 11100001b
-01011111b ^ 10111111b = 11100000b
-01011111b ^ 11000000b = 10011111b
-01011111b ^ 11000001b = 10011110b
-01011111b ^ 11000010b = 10011101b
-01011111b ^ 11000011b = 10011100b
-01011111b ^ 11000100b = 10011011b
-01011111b ^ 11000101b = 10011010b
-01011111b ^ 11000110b = 10011001b
-01011111b ^ 11000111b = 10011000b
-01011111b ^ 11001000b = 10010111b
-01011111b ^ 11001001b = 10010110b
-01011111b ^ 11001010b = 10010101b
-01011111b ^ 11001011b = 10010100b
-01011111b ^ 11001100b = 10010011b
-01011111b ^ 11001101b = 10010010b
-01011111b ^ 11001110b = 10010001b
-01011111b ^ 11001111b = 10010000b
-01011111b ^ 11010000b = 10001111b
-01011111b ^ 11010001b = 10001110b
-01011111b ^ 11010010b = 10001101b
-01011111b ^ 11010011b = 10001100b
-01011111b ^ 11010100b = 10001011b
-01011111b ^ 11010101b = 10001010b
-01011111b ^ 11010110b = 10001001b
-01011111b ^ 11010111b = 10001000b
-01011111b ^ 11011000b = 10000111b
-01011111b ^ 11011001b = 10000110b
-01011111b ^ 11011010b = 10000101b
-01011111b ^ 11011011b = 10000100b
-01011111b ^ 11011100b = 10000011b
-01011111b ^ 11011101b = 10000010b
-01011111b ^ 11011110b = 10000001b
-01011111b ^ 11011111b = 10000000b
-01011111b ^ 11100000b = 10111111b
-01011111b ^ 11100001b = 10111110b
-01011111b ^ 11100010b = 10111101b
-01011111b ^ 11100011b = 10111100b
-01011111b ^ 11100100b = 10111011b
-01011111b ^ 11100101b = 10111010b
-01011111b ^ 11100110b = 10111001b
-01011111b ^ 11100111b = 10111000b
-01011111b ^ 11101000b = 10110111b
-01011111b ^ 11101001b = 10110110b
-01011111b ^ 11101010b = 10110101b
-01011111b ^ 11101011b = 10110100b
-01011111b ^ 11101100b = 10110011b
-01011111b ^ 11101101b = 10110010b
-01011111b ^ 11101110b = 10110001b
-01011111b ^ 11101111b = 10110000b
-01011111b ^ 11110000b = 10101111b
-01011111b ^ 11110001b = 10101110b
-01011111b ^ 11110010b = 10101101b
-01011111b ^ 11110011b = 10101100b
-01011111b ^ 11110100b = 10101011b
-01011111b ^ 11110101b = 10101010b
-01011111b ^ 11110110b = 10101001b
-01011111b ^ 11110111b = 10101000b
-01011111b ^ 11111000b = 10100111b
-01011111b ^ 11111001b = 10100110b
-01011111b ^ 11111010b = 10100101b
-01011111b ^ 11111011b = 10100100b
-01011111b ^ 11111100b = 10100011b
-01011111b ^ 11111101b = 10100010b
-01011111b ^ 11111110b = 10100001b
-01011111b ^ 11111111b = 10100000b
-01011111b ^ 00000000b = 01011111b
-01011111b ^ 00000001b = 01011110b
-01011111b ^ 00000010b = 01011101b
-01011111b ^ 00000011b = 01011100b
-01011111b ^ 00000100b = 01011011b
-01011111b ^ 00000101b = 01011010b
-01011111b ^ 00000110b = 01011001b
-01011111b ^ 00000111b = 01011000b
-01011111b ^ 00001000b = 01010111b
-01011111b ^ 00001001b = 01010110b
-01011111b ^ 00001010b = 01010101b
-01011111b ^ 00001011b = 01010100b
-01011111b ^ 00001100b = 01010011b
-01011111b ^ 00001101b = 01010010b
-01011111b ^ 00001110b = 01010001b
-01011111b ^ 00001111b = 01010000b
-01011111b ^ 00010000b = 01001111b
-01011111b ^ 00010001b = 01001110b
-01011111b ^ 00010010b = 01001101b
-01011111b ^ 00010011b = 01001100b
-01011111b ^ 00010100b = 01001011b
-01011111b ^ 00010101b = 01001010b
-01011111b ^ 00010110b = 01001001b
-01011111b ^ 00010111b = 01001000b
-01011111b ^ 00011000b = 01000111b
-01011111b ^ 00011001b = 01000110b
-01011111b ^ 00011010b = 01000101b
-01011111b ^ 00011011b = 01000100b
-01011111b ^ 00011100b = 01000011b
-01011111b ^ 00011101b = 01000010b
-01011111b ^ 00011110b = 01000001b
-01011111b ^ 00011111b = 01000000b
-01011111b ^ 00100000b = 01111111b
-01011111b ^ 00100001b = 01111110b
-01011111b ^ 00100010b = 01111101b
-01011111b ^ 00100011b = 01111100b
-01011111b ^ 00100100b = 01111011b
-01011111b ^ 00100101b = 01111010b
-01011111b ^ 00100110b = 01111001b
-01011111b ^ 00100111b = 01111000b
-01011111b ^ 00101000b = 01110111b
-01011111b ^ 00101001b = 01110110b
-01011111b ^ 00101010b = 01110101b
-01011111b ^ 00101011b = 01110100b
-01011111b ^ 00101100b = 01110011b
-01011111b ^ 00101101b = 01110010b
-01011111b ^ 00101110b = 01110001b
-01011111b ^ 00101111b = 01110000b
-01011111b ^ 00110000b = 01101111b
-01011111b ^ 00110001b = 01101110b
-01011111b ^ 00110010b = 01101101b
-01011111b ^ 00110011b = 01101100b
-01011111b ^ 00110100b = 01101011b
-01011111b ^ 00110101b = 01101010b
-01011111b ^ 00110110b = 01101001b
-01011111b ^ 00110111b = 01101000b
-01011111b ^ 00111000b = 01100111b
-01011111b ^ 00111001b = 01100110b
-01011111b ^ 00111010b = 01100101b
-01011111b ^ 00111011b = 01100100b
-01011111b ^ 00111100b = 01100011b
-01011111b ^ 00111101b = 01100010b
-01011111b ^ 00111110b = 01100001b
-01011111b ^ 00111111b = 01100000b
-01011111b ^ 01000000b = 00011111b
-01011111b ^ 01000001b = 00011110b
-01011111b ^ 01000010b = 00011101b
-01011111b ^ 01000011b = 00011100b
-01011111b ^ 01000100b = 00011011b
-01011111b ^ 01000101b = 00011010b
-01011111b ^ 01000110b = 00011001b
-01011111b ^ 01000111b = 00011000b
-01011111b ^ 01001000b = 00010111b
-01011111b ^ 01001001b = 00010110b
-01011111b ^ 01001010b = 00010101b
-01011111b ^ 01001011b = 00010100b
-01011111b ^ 01001100b = 00010011b
-01011111b ^ 01001101b = 00010010b
-01011111b ^ 01001110b = 00010001b
-01011111b ^ 01001111b = 00010000b
-01011111b ^ 01010000b = 00001111b
-01011111b ^ 01010001b = 00001110b
-01011111b ^ 01010010b = 00001101b
-01011111b ^ 01010011b = 00001100b
-01011111b ^ 01010100b = 00001011b
-01011111b ^ 01010101b = 00001010b
-01011111b ^ 01010110b = 00001001b
-01011111b ^ 01010111b = 00001000b
-01011111b ^ 01011000b = 00000111b
-01011111b ^ 01011001b = 00000110b
-01011111b ^ 01011010b = 00000101b
-01011111b ^ 01011011b = 00000100b
-01011111b ^ 01011100b = 00000011b
-01011111b ^ 01011101b = 00000010b
-01011111b ^ 01011110b = 00000001b
-01011111b ^ 01011111b = 00000000b
-01011111b ^ 01100000b = 00111111b
-01011111b ^ 01100001b = 00111110b
-01011111b ^ 01100010b = 00111101b
-01011111b ^ 01100011b = 00111100b
-01011111b ^ 01100100b = 00111011b
-01011111b ^ 01100101b = 00111010b
-01011111b ^ 01100110b = 00111001b
-01011111b ^ 01100111b = 00111000b
-01011111b ^ 01101000b = 00110111b
-01011111b ^ 01101001b = 00110110b
-01011111b ^ 01101010b = 00110101b
-01011111b ^ 01101011b = 00110100b
-01011111b ^ 01101100b = 00110011b
-01011111b ^ 01101101b = 00110010b
-01011111b ^ 01101110b = 00110001b
-01011111b ^ 01101111b = 00110000b
-01011111b ^ 01110000b = 00101111b
-01011111b ^ 01110001b = 00101110b
-01011111b ^ 01110010b = 00101101b
-01011111b ^ 01110011b = 00101100b
-01011111b ^ 01110100b = 00101011b
-01011111b ^ 01110101b = 00101010b
-01011111b ^ 01110110b = 00101001b
-01011111b ^ 01110111b = 00101000b
-01011111b ^ 01111000b = 00100111b
-01011111b ^ 01111001b = 00100110b
-01011111b ^ 01111010b = 00100101b
-01011111b ^ 01111011b = 00100100b
-01011111b ^ 01111100b = 00100011b
-01011111b ^ 01111101b = 00100010b
-01011111b ^ 01111110b = 00100001b
-01100000b ^ 10000000b = 11100000b
-01100000b ^ 10000001b = 11100001b
-01100000b ^ 10000010b = 11100010b
-01100000b ^ 10000011b = 11100011b
-01100000b ^ 10000100b = 11100100b
-01100000b ^ 10000101b = 11100101b
-01100000b ^ 10000110b = 11100110b
-01100000b ^ 10000111b = 11100111b
-01100000b ^ 10001000b = 11101000b
-01100000b ^ 10001001b = 11101001b
-01100000b ^ 10001010b = 11101010b
-01100000b ^ 10001011b = 11101011b
-01100000b ^ 10001100b = 11101100b
-01100000b ^ 10001101b = 11101101b
-01100000b ^ 10001110b = 11101110b
-01100000b ^ 10001111b = 11101111b
-01100000b ^ 10010000b = 11110000b
-01100000b ^ 10010001b = 11110001b
-01100000b ^ 10010010b = 11110010b
-01100000b ^ 10010011b = 11110011b
-01100000b ^ 10010100b = 11110100b
-01100000b ^ 10010101b = 11110101b
-01100000b ^ 10010110b = 11110110b
-01100000b ^ 10010111b = 11110111b
-01100000b ^ 10011000b = 11111000b
-01100000b ^ 10011001b = 11111001b
-01100000b ^ 10011010b = 11111010b
-01100000b ^ 10011011b = 11111011b
-01100000b ^ 10011100b = 11111100b
-01100000b ^ 10011101b = 11111101b
-01100000b ^ 10011110b = 11111110b
-01100000b ^ 10011111b = 11111111b
-01100000b ^ 10100000b = 11000000b
-01100000b ^ 10100001b = 11000001b
-01100000b ^ 10100010b = 11000010b
-01100000b ^ 10100011b = 11000011b
-01100000b ^ 10100100b = 11000100b
-01100000b ^ 10100101b = 11000101b
-01100000b ^ 10100110b = 11000110b
-01100000b ^ 10100111b = 11000111b
-01100000b ^ 10101000b = 11001000b
-01100000b ^ 10101001b = 11001001b
-01100000b ^ 10101010b = 11001010b
-01100000b ^ 10101011b = 11001011b
-01100000b ^ 10101100b = 11001100b
-01100000b ^ 10101101b = 11001101b
-01100000b ^ 10101110b = 11001110b
-01100000b ^ 10101111b = 11001111b
-01100000b ^ 10110000b = 11010000b
-01100000b ^ 10110001b = 11010001b
-01100000b ^ 10110010b = 11010010b
-01100000b ^ 10110011b = 11010011b
-01100000b ^ 10110100b = 11010100b
-01100000b ^ 10110101b = 11010101b
-01100000b ^ 10110110b = 11010110b
-01100000b ^ 10110111b = 11010111b
-01100000b ^ 10111000b = 11011000b
-01100000b ^ 10111001b = 11011001b
-01100000b ^ 10111010b = 11011010b
-01100000b ^ 10111011b = 11011011b
-01100000b ^ 10111100b = 11011100b
-01100000b ^ 10111101b = 11011101b
-01100000b ^ 10111110b = 11011110b
-01100000b ^ 10111111b = 11011111b
-01100000b ^ 11000000b = 10100000b
-01100000b ^ 11000001b = 10100001b
-01100000b ^ 11000010b = 10100010b
-01100000b ^ 11000011b = 10100011b
-01100000b ^ 11000100b = 10100100b
-01100000b ^ 11000101b = 10100101b
-01100000b ^ 11000110b = 10100110b
-01100000b ^ 11000111b = 10100111b
-01100000b ^ 11001000b = 10101000b
-01100000b ^ 11001001b = 10101001b
-01100000b ^ 11001010b = 10101010b
-01100000b ^ 11001011b = 10101011b
-01100000b ^ 11001100b = 10101100b
-01100000b ^ 11001101b = 10101101b
-01100000b ^ 11001110b = 10101110b
-01100000b ^ 11001111b = 10101111b
-01100000b ^ 11010000b = 10110000b
-01100000b ^ 11010001b = 10110001b
-01100000b ^ 11010010b = 10110010b
-01100000b ^ 11010011b = 10110011b
-01100000b ^ 11010100b = 10110100b
-01100000b ^ 11010101b = 10110101b
-01100000b ^ 11010110b = 10110110b
-01100000b ^ 11010111b = 10110111b
-01100000b ^ 11011000b = 10111000b
-01100000b ^ 11011001b = 10111001b
-01100000b ^ 11011010b = 10111010b
-01100000b ^ 11011011b = 10111011b
-01100000b ^ 11011100b = 10111100b
-01100000b ^ 11011101b = 10111101b
-01100000b ^ 11011110b = 10111110b
-01100000b ^ 11011111b = 10111111b
-01100000b ^ 11100000b = 10000000b
-01100000b ^ 11100001b = 10000001b
-01100000b ^ 11100010b = 10000010b
-01100000b ^ 11100011b = 10000011b
-01100000b ^ 11100100b = 10000100b
-01100000b ^ 11100101b = 10000101b
-01100000b ^ 11100110b = 10000110b
-01100000b ^ 11100111b = 10000111b
-01100000b ^ 11101000b = 10001000b
-01100000b ^ 11101001b = 10001001b
-01100000b ^ 11101010b = 10001010b
-01100000b ^ 11101011b = 10001011b
-01100000b ^ 11101100b = 10001100b
-01100000b ^ 11101101b = 10001101b
-01100000b ^ 11101110b = 10001110b
-01100000b ^ 11101111b = 10001111b
-01100000b ^ 11110000b = 10010000b
-01100000b ^ 11110001b = 10010001b
-01100000b ^ 11110010b = 10010010b
-01100000b ^ 11110011b = 10010011b
-01100000b ^ 11110100b = 10010100b
-01100000b ^ 11110101b = 10010101b
-01100000b ^ 11110110b = 10010110b
-01100000b ^ 11110111b = 10010111b
-01100000b ^ 11111000b = 10011000b
-01100000b ^ 11111001b = 10011001b
-01100000b ^ 11111010b = 10011010b
-01100000b ^ 11111011b = 10011011b
-01100000b ^ 11111100b = 10011100b
-01100000b ^ 11111101b = 10011101b
-01100000b ^ 11111110b = 10011110b
-01100000b ^ 11111111b = 10011111b
-01100000b ^ 00000000b = 01100000b
-01100000b ^ 00000001b = 01100001b
-01100000b ^ 00000010b = 01100010b
-01100000b ^ 00000011b = 01100011b
-01100000b ^ 00000100b = 01100100b
-01100000b ^ 00000101b = 01100101b
-01100000b ^ 00000110b = 01100110b
-01100000b ^ 00000111b = 01100111b
-01100000b ^ 00001000b = 01101000b
-01100000b ^ 00001001b = 01101001b
-01100000b ^ 00001010b = 01101010b
-01100000b ^ 00001011b = 01101011b
-01100000b ^ 00001100b = 01101100b
-01100000b ^ 00001101b = 01101101b
-01100000b ^ 00001110b = 01101110b
-01100000b ^ 00001111b = 01101111b
-01100000b ^ 00010000b = 01110000b
-01100000b ^ 00010001b = 01110001b
-01100000b ^ 00010010b = 01110010b
-01100000b ^ 00010011b = 01110011b
-01100000b ^ 00010100b = 01110100b
-01100000b ^ 00010101b = 01110101b
-01100000b ^ 00010110b = 01110110b
-01100000b ^ 00010111b = 01110111b
-01100000b ^ 00011000b = 01111000b
-01100000b ^ 00011001b = 01111001b
-01100000b ^ 00011010b = 01111010b
-01100000b ^ 00011011b = 01111011b
-01100000b ^ 00011100b = 01111100b
-01100000b ^ 00011101b = 01111101b
-01100000b ^ 00011110b = 01111110b
-01100000b ^ 00011111b = 01111111b
-01100000b ^ 00100000b = 01000000b
-01100000b ^ 00100001b = 01000001b
-01100000b ^ 00100010b = 01000010b
-01100000b ^ 00100011b = 01000011b
-01100000b ^ 00100100b = 01000100b
-01100000b ^ 00100101b = 01000101b
-01100000b ^ 00100110b = 01000110b
-01100000b ^ 00100111b = 01000111b
-01100000b ^ 00101000b = 01001000b
-01100000b ^ 00101001b = 01001001b
-01100000b ^ 00101010b = 01001010b
-01100000b ^ 00101011b = 01001011b
-01100000b ^ 00101100b = 01001100b
-01100000b ^ 00101101b = 01001101b
-01100000b ^ 00101110b = 01001110b
-01100000b ^ 00101111b = 01001111b
-01100000b ^ 00110000b = 01010000b
-01100000b ^ 00110001b = 01010001b
-01100000b ^ 00110010b = 01010010b
-01100000b ^ 00110011b = 01010011b
-01100000b ^ 00110100b = 01010100b
-01100000b ^ 00110101b = 01010101b
-01100000b ^ 00110110b = 01010110b
-01100000b ^ 00110111b = 01010111b
-01100000b ^ 00111000b = 01011000b
-01100000b ^ 00111001b = 01011001b
-01100000b ^ 00111010b = 01011010b
-01100000b ^ 00111011b = 01011011b
-01100000b ^ 00111100b = 01011100b
-01100000b ^ 00111101b = 01011101b
-01100000b ^ 00111110b = 01011110b
-01100000b ^ 00111111b = 01011111b
-01100000b ^ 01000000b = 00100000b
-01100000b ^ 01000001b = 00100001b
-01100000b ^ 01000010b = 00100010b
-01100000b ^ 01000011b = 00100011b
-01100000b ^ 01000100b = 00100100b
-01100000b ^ 01000101b = 00100101b
-01100000b ^ 01000110b = 00100110b
-01100000b ^ 01000111b = 00100111b
-01100000b ^ 01001000b = 00101000b
-01100000b ^ 01001001b = 00101001b
-01100000b ^ 01001010b = 00101010b
-01100000b ^ 01001011b = 00101011b
-01100000b ^ 01001100b = 00101100b
-01100000b ^ 01001101b = 00101101b
-01100000b ^ 01001110b = 00101110b
-01100000b ^ 01001111b = 00101111b
-01100000b ^ 01010000b = 00110000b
-01100000b ^ 01010001b = 00110001b
-01100000b ^ 01010010b = 00110010b
-01100000b ^ 01010011b = 00110011b
-01100000b ^ 01010100b = 00110100b
-01100000b ^ 01010101b = 00110101b
-01100000b ^ 01010110b = 00110110b
-01100000b ^ 01010111b = 00110111b
-01100000b ^ 01011000b = 00111000b
-01100000b ^ 01011001b = 00111001b
-01100000b ^ 01011010b = 00111010b
-01100000b ^ 01011011b = 00111011b
-01100000b ^ 01011100b = 00111100b
-01100000b ^ 01011101b = 00111101b
-01100000b ^ 01011110b = 00111110b
-01100000b ^ 01011111b = 00111111b
-01100000b ^ 01100000b = 00000000b
-01100000b ^ 01100001b = 00000001b
-01100000b ^ 01100010b = 00000010b
-01100000b ^ 01100011b = 00000011b
-01100000b ^ 01100100b = 00000100b
-01100000b ^ 01100101b = 00000101b
-01100000b ^ 01100110b = 00000110b
-01100000b ^ 01100111b = 00000111b
-01100000b ^ 01101000b = 00001000b
-01100000b ^ 01101001b = 00001001b
-01100000b ^ 01101010b = 00001010b
-01100000b ^ 01101011b = 00001011b
-01100000b ^ 01101100b = 00001100b
-01100000b ^ 01101101b = 00001101b
-01100000b ^ 01101110b = 00001110b
-01100000b ^ 01101111b = 00001111b
-01100000b ^ 01110000b = 00010000b
-01100000b ^ 01110001b = 00010001b
-01100000b ^ 01110010b = 00010010b
-01100000b ^ 01110011b = 00010011b
-01100000b ^ 01110100b = 00010100b
-01100000b ^ 01110101b = 00010101b
-01100000b ^ 01110110b = 00010110b
-01100000b ^ 01110111b = 00010111b
-01100000b ^ 01111000b = 00011000b
-01100000b ^ 01111001b = 00011001b
-01100000b ^ 01111010b = 00011010b
-01100000b ^ 01111011b = 00011011b
-01100000b ^ 01111100b = 00011100b
-01100000b ^ 01111101b = 00011101b
-01100000b ^ 01111110b = 00011110b
-01100001b ^ 10000000b = 11100001b
-01100001b ^ 10000001b = 11100000b
-01100001b ^ 10000010b = 11100011b
-01100001b ^ 10000011b = 11100010b
-01100001b ^ 10000100b = 11100101b
-01100001b ^ 10000101b = 11100100b
-01100001b ^ 10000110b = 11100111b
-01100001b ^ 10000111b = 11100110b
-01100001b ^ 10001000b = 11101001b
-01100001b ^ 10001001b = 11101000b
-01100001b ^ 10001010b = 11101011b
-01100001b ^ 10001011b = 11101010b
-01100001b ^ 10001100b = 11101101b
-01100001b ^ 10001101b = 11101100b
-01100001b ^ 10001110b = 11101111b
-01100001b ^ 10001111b = 11101110b
-01100001b ^ 10010000b = 11110001b
-01100001b ^ 10010001b = 11110000b
-01100001b ^ 10010010b = 11110011b
-01100001b ^ 10010011b = 11110010b
-01100001b ^ 10010100b = 11110101b
-01100001b ^ 10010101b = 11110100b
-01100001b ^ 10010110b = 11110111b
-01100001b ^ 10010111b = 11110110b
-01100001b ^ 10011000b = 11111001b
-01100001b ^ 10011001b = 11111000b
-01100001b ^ 10011010b = 11111011b
-01100001b ^ 10011011b = 11111010b
-01100001b ^ 10011100b = 11111101b
-01100001b ^ 10011101b = 11111100b
-01100001b ^ 10011110b = 11111111b
-01100001b ^ 10011111b = 11111110b
-01100001b ^ 10100000b = 11000001b
-01100001b ^ 10100001b = 11000000b
-01100001b ^ 10100010b = 11000011b
-01100001b ^ 10100011b = 11000010b
-01100001b ^ 10100100b = 11000101b
-01100001b ^ 10100101b = 11000100b
-01100001b ^ 10100110b = 11000111b
-01100001b ^ 10100111b = 11000110b
-01100001b ^ 10101000b = 11001001b
-01100001b ^ 10101001b = 11001000b
-01100001b ^ 10101010b = 11001011b
-01100001b ^ 10101011b = 11001010b
-01100001b ^ 10101100b = 11001101b
-01100001b ^ 10101101b = 11001100b
-01100001b ^ 10101110b = 11001111b
-01100001b ^ 10101111b = 11001110b
-01100001b ^ 10110000b = 11010001b
-01100001b ^ 10110001b = 11010000b
-01100001b ^ 10110010b = 11010011b
-01100001b ^ 10110011b = 11010010b
-01100001b ^ 10110100b = 11010101b
-01100001b ^ 10110101b = 11010100b
-01100001b ^ 10110110b = 11010111b
-01100001b ^ 10110111b = 11010110b
-01100001b ^ 10111000b = 11011001b
-01100001b ^ 10111001b = 11011000b
-01100001b ^ 10111010b = 11011011b
-01100001b ^ 10111011b = 11011010b
-01100001b ^ 10111100b = 11011101b
-01100001b ^ 10111101b = 11011100b
-01100001b ^ 10111110b = 11011111b
-01100001b ^ 10111111b = 11011110b
-01100001b ^ 11000000b = 10100001b
-01100001b ^ 11000001b = 10100000b
-01100001b ^ 11000010b = 10100011b
-01100001b ^ 11000011b = 10100010b
-01100001b ^ 11000100b = 10100101b
-01100001b ^ 11000101b = 10100100b
-01100001b ^ 11000110b = 10100111b
-01100001b ^ 11000111b = 10100110b
-01100001b ^ 11001000b = 10101001b
-01100001b ^ 11001001b = 10101000b
-01100001b ^ 11001010b = 10101011b
-01100001b ^ 11001011b = 10101010b
-01100001b ^ 11001100b = 10101101b
-01100001b ^ 11001101b = 10101100b
-01100001b ^ 11001110b = 10101111b
-01100001b ^ 11001111b = 10101110b
-01100001b ^ 11010000b = 10110001b
-01100001b ^ 11010001b = 10110000b
-01100001b ^ 11010010b = 10110011b
-01100001b ^ 11010011b = 10110010b
-01100001b ^ 11010100b = 10110101b
-01100001b ^ 11010101b = 10110100b
-01100001b ^ 11010110b = 10110111b
-01100001b ^ 11010111b = 10110110b
-01100001b ^ 11011000b = 10111001b
-01100001b ^ 11011001b = 10111000b
-01100001b ^ 11011010b = 10111011b
-01100001b ^ 11011011b = 10111010b
-01100001b ^ 11011100b = 10111101b
-01100001b ^ 11011101b = 10111100b
-01100001b ^ 11011110b = 10111111b
-01100001b ^ 11011111b = 10111110b
-01100001b ^ 11100000b = 10000001b
-01100001b ^ 11100001b = 10000000b
-01100001b ^ 11100010b = 10000011b
-01100001b ^ 11100011b = 10000010b
-01100001b ^ 11100100b = 10000101b
-01100001b ^ 11100101b = 10000100b
-01100001b ^ 11100110b = 10000111b
-01100001b ^ 11100111b = 10000110b
-01100001b ^ 11101000b = 10001001b
-01100001b ^ 11101001b = 10001000b
-01100001b ^ 11101010b = 10001011b
-01100001b ^ 11101011b = 10001010b
-01100001b ^ 11101100b = 10001101b
-01100001b ^ 11101101b = 10001100b
-01100001b ^ 11101110b = 10001111b
-01100001b ^ 11101111b = 10001110b
-01100001b ^ 11110000b = 10010001b
-01100001b ^ 11110001b = 10010000b
-01100001b ^ 11110010b = 10010011b
-01100001b ^ 11110011b = 10010010b
-01100001b ^ 11110100b = 10010101b
-01100001b ^ 11110101b = 10010100b
-01100001b ^ 11110110b = 10010111b
-01100001b ^ 11110111b = 10010110b
-01100001b ^ 11111000b = 10011001b
-01100001b ^ 11111001b = 10011000b
-01100001b ^ 11111010b = 10011011b
-01100001b ^ 11111011b = 10011010b
-01100001b ^ 11111100b = 10011101b
-01100001b ^ 11111101b = 10011100b
-01100001b ^ 11111110b = 10011111b
-01100001b ^ 11111111b = 10011110b
-01100001b ^ 00000000b = 01100001b
-01100001b ^ 00000001b = 01100000b
-01100001b ^ 00000010b = 01100011b
-01100001b ^ 00000011b = 01100010b
-01100001b ^ 00000100b = 01100101b
-01100001b ^ 00000101b = 01100100b
-01100001b ^ 00000110b = 01100111b
-01100001b ^ 00000111b = 01100110b
-01100001b ^ 00001000b = 01101001b
-01100001b ^ 00001001b = 01101000b
-01100001b ^ 00001010b = 01101011b
-01100001b ^ 00001011b = 01101010b
-01100001b ^ 00001100b = 01101101b
-01100001b ^ 00001101b = 01101100b
-01100001b ^ 00001110b = 01101111b
-01100001b ^ 00001111b = 01101110b
-01100001b ^ 00010000b = 01110001b
-01100001b ^ 00010001b = 01110000b
-01100001b ^ 00010010b = 01110011b
-01100001b ^ 00010011b = 01110010b
-01100001b ^ 00010100b = 01110101b
-01100001b ^ 00010101b = 01110100b
-01100001b ^ 00010110b = 01110111b
-01100001b ^ 00010111b = 01110110b
-01100001b ^ 00011000b = 01111001b
-01100001b ^ 00011001b = 01111000b
-01100001b ^ 00011010b = 01111011b
-01100001b ^ 00011011b = 01111010b
-01100001b ^ 00011100b = 01111101b
-01100001b ^ 00011101b = 01111100b
-01100001b ^ 00011110b = 01111111b
-01100001b ^ 00011111b = 01111110b
-01100001b ^ 00100000b = 01000001b
-01100001b ^ 00100001b = 01000000b
-01100001b ^ 00100010b = 01000011b
-01100001b ^ 00100011b = 01000010b
-01100001b ^ 00100100b = 01000101b
-01100001b ^ 00100101b = 01000100b
-01100001b ^ 00100110b = 01000111b
-01100001b ^ 00100111b = 01000110b
-01100001b ^ 00101000b = 01001001b
-01100001b ^ 00101001b = 01001000b
-01100001b ^ 00101010b = 01001011b
-01100001b ^ 00101011b = 01001010b
-01100001b ^ 00101100b = 01001101b
-01100001b ^ 00101101b = 01001100b
-01100001b ^ 00101110b = 01001111b
-01100001b ^ 00101111b = 01001110b
-01100001b ^ 00110000b = 01010001b
-01100001b ^ 00110001b = 01010000b
-01100001b ^ 00110010b = 01010011b
-01100001b ^ 00110011b = 01010010b
-01100001b ^ 00110100b = 01010101b
-01100001b ^ 00110101b = 01010100b
-01100001b ^ 00110110b = 01010111b
-01100001b ^ 00110111b = 01010110b
-01100001b ^ 00111000b = 01011001b
-01100001b ^ 00111001b = 01011000b
-01100001b ^ 00111010b = 01011011b
-01100001b ^ 00111011b = 01011010b
-01100001b ^ 00111100b = 01011101b
-01100001b ^ 00111101b = 01011100b
-01100001b ^ 00111110b = 01011111b
-01100001b ^ 00111111b = 01011110b
-01100001b ^ 01000000b = 00100001b
-01100001b ^ 01000001b = 00100000b
-01100001b ^ 01000010b = 00100011b
-01100001b ^ 01000011b = 00100010b
-01100001b ^ 01000100b = 00100101b
-01100001b ^ 01000101b = 00100100b
-01100001b ^ 01000110b = 00100111b
-01100001b ^ 01000111b = 00100110b
-01100001b ^ 01001000b = 00101001b
-01100001b ^ 01001001b = 00101000b
-01100001b ^ 01001010b = 00101011b
-01100001b ^ 01001011b = 00101010b
-01100001b ^ 01001100b = 00101101b
-01100001b ^ 01001101b = 00101100b
-01100001b ^ 01001110b = 00101111b
-01100001b ^ 01001111b = 00101110b
-01100001b ^ 01010000b = 00110001b
-01100001b ^ 01010001b = 00110000b
-01100001b ^ 01010010b = 00110011b
-01100001b ^ 01010011b = 00110010b
-01100001b ^ 01010100b = 00110101b
-01100001b ^ 01010101b = 00110100b
-01100001b ^ 01010110b = 00110111b
-01100001b ^ 01010111b = 00110110b
-01100001b ^ 01011000b = 00111001b
-01100001b ^ 01011001b = 00111000b
-01100001b ^ 01011010b = 00111011b
-01100001b ^ 01011011b = 00111010b
-01100001b ^ 01011100b = 00111101b
-01100001b ^ 01011101b = 00111100b
-01100001b ^ 01011110b = 00111111b
-01100001b ^ 01011111b = 00111110b
-01100001b ^ 01100000b = 00000001b
-01100001b ^ 01100001b = 00000000b
-01100001b ^ 01100010b = 00000011b
-01100001b ^ 01100011b = 00000010b
-01100001b ^ 01100100b = 00000101b
-01100001b ^ 01100101b = 00000100b
-01100001b ^ 01100110b = 00000111b
-01100001b ^ 01100111b = 00000110b
-01100001b ^ 01101000b = 00001001b
-01100001b ^ 01101001b = 00001000b
-01100001b ^ 01101010b = 00001011b
-01100001b ^ 01101011b = 00001010b
-01100001b ^ 01101100b = 00001101b
-01100001b ^ 01101101b = 00001100b
-01100001b ^ 01101110b = 00001111b
-01100001b ^ 01101111b = 00001110b
-01100001b ^ 01110000b = 00010001b
-01100001b ^ 01110001b = 00010000b
-01100001b ^ 01110010b = 00010011b
-01100001b ^ 01110011b = 00010010b
-01100001b ^ 01110100b = 00010101b
-01100001b ^ 01110101b = 00010100b
-01100001b ^ 01110110b = 00010111b
-01100001b ^ 01110111b = 00010110b
-01100001b ^ 01111000b = 00011001b
-01100001b ^ 01111001b = 00011000b
-01100001b ^ 01111010b = 00011011b
-01100001b ^ 01111011b = 00011010b
-01100001b ^ 01111100b = 00011101b
-01100001b ^ 01111101b = 00011100b
-01100001b ^ 01111110b = 00011111b
-01100010b ^ 10000000b = 11100010b
-01100010b ^ 10000001b = 11100011b
-01100010b ^ 10000010b = 11100000b
-01100010b ^ 10000011b = 11100001b
-01100010b ^ 10000100b = 11100110b
-01100010b ^ 10000101b = 11100111b
-01100010b ^ 10000110b = 11100100b
-01100010b ^ 10000111b = 11100101b
-01100010b ^ 10001000b = 11101010b
-01100010b ^ 10001001b = 11101011b
-01100010b ^ 10001010b = 11101000b
-01100010b ^ 10001011b = 11101001b
-01100010b ^ 10001100b = 11101110b
-01100010b ^ 10001101b = 11101111b
-01100010b ^ 10001110b = 11101100b
-01100010b ^ 10001111b = 11101101b
-01100010b ^ 10010000b = 11110010b
-01100010b ^ 10010001b = 11110011b
-01100010b ^ 10010010b = 11110000b
-01100010b ^ 10010011b = 11110001b
-01100010b ^ 10010100b = 11110110b
-01100010b ^ 10010101b = 11110111b
-01100010b ^ 10010110b = 11110100b
-01100010b ^ 10010111b = 11110101b
-01100010b ^ 10011000b = 11111010b
-01100010b ^ 10011001b = 11111011b
-01100010b ^ 10011010b = 11111000b
-01100010b ^ 10011011b = 11111001b
-01100010b ^ 10011100b = 11111110b
-01100010b ^ 10011101b = 11111111b
-01100010b ^ 10011110b = 11111100b
-01100010b ^ 10011111b = 11111101b
-01100010b ^ 10100000b = 11000010b
-01100010b ^ 10100001b = 11000011b
-01100010b ^ 10100010b = 11000000b
-01100010b ^ 10100011b = 11000001b
-01100010b ^ 10100100b = 11000110b
-01100010b ^ 10100101b = 11000111b
-01100010b ^ 10100110b = 11000100b
-01100010b ^ 10100111b = 11000101b
-01100010b ^ 10101000b = 11001010b
-01100010b ^ 10101001b = 11001011b
-01100010b ^ 10101010b = 11001000b
-01100010b ^ 10101011b = 11001001b
-01100010b ^ 10101100b = 11001110b
-01100010b ^ 10101101b = 11001111b
-01100010b ^ 10101110b = 11001100b
-01100010b ^ 10101111b = 11001101b
-01100010b ^ 10110000b = 11010010b
-01100010b ^ 10110001b = 11010011b
-01100010b ^ 10110010b = 11010000b
-01100010b ^ 10110011b = 11010001b
-01100010b ^ 10110100b = 11010110b
-01100010b ^ 10110101b = 11010111b
-01100010b ^ 10110110b = 11010100b
-01100010b ^ 10110111b = 11010101b
-01100010b ^ 10111000b = 11011010b
-01100010b ^ 10111001b = 11011011b
-01100010b ^ 10111010b = 11011000b
-01100010b ^ 10111011b = 11011001b
-01100010b ^ 10111100b = 11011110b
-01100010b ^ 10111101b = 11011111b
-01100010b ^ 10111110b = 11011100b
-01100010b ^ 10111111b = 11011101b
-01100010b ^ 11000000b = 10100010b
-01100010b ^ 11000001b = 10100011b
-01100010b ^ 11000010b = 10100000b
-01100010b ^ 11000011b = 10100001b
-01100010b ^ 11000100b = 10100110b
-01100010b ^ 11000101b = 10100111b
-01100010b ^ 11000110b = 10100100b
-01100010b ^ 11000111b = 10100101b
-01100010b ^ 11001000b = 10101010b
-01100010b ^ 11001001b = 10101011b
-01100010b ^ 11001010b = 10101000b
-01100010b ^ 11001011b = 10101001b
-01100010b ^ 11001100b = 10101110b
-01100010b ^ 11001101b = 10101111b
-01100010b ^ 11001110b = 10101100b
-01100010b ^ 11001111b = 10101101b
-01100010b ^ 11010000b = 10110010b
-01100010b ^ 11010001b = 10110011b
-01100010b ^ 11010010b = 10110000b
-01100010b ^ 11010011b = 10110001b
-01100010b ^ 11010100b = 10110110b
-01100010b ^ 11010101b = 10110111b
-01100010b ^ 11010110b = 10110100b
-01100010b ^ 11010111b = 10110101b
-01100010b ^ 11011000b = 10111010b
-01100010b ^ 11011001b = 10111011b
-01100010b ^ 11011010b = 10111000b
-01100010b ^ 11011011b = 10111001b
-01100010b ^ 11011100b = 10111110b
-01100010b ^ 11011101b = 10111111b
-01100010b ^ 11011110b = 10111100b
-01100010b ^ 11011111b = 10111101b
-01100010b ^ 11100000b = 10000010b
-01100010b ^ 11100001b = 10000011b
-01100010b ^ 11100010b = 10000000b
-01100010b ^ 11100011b = 10000001b
-01100010b ^ 11100100b = 10000110b
-01100010b ^ 11100101b = 10000111b
-01100010b ^ 11100110b = 10000100b
-01100010b ^ 11100111b = 10000101b
-01100010b ^ 11101000b = 10001010b
-01100010b ^ 11101001b = 10001011b
-01100010b ^ 11101010b = 10001000b
-01100010b ^ 11101011b = 10001001b
-01100010b ^ 11101100b = 10001110b
-01100010b ^ 11101101b = 10001111b
-01100010b ^ 11101110b = 10001100b
-01100010b ^ 11101111b = 10001101b
-01100010b ^ 11110000b = 10010010b
-01100010b ^ 11110001b = 10010011b
-01100010b ^ 11110010b = 10010000b
-01100010b ^ 11110011b = 10010001b
-01100010b ^ 11110100b = 10010110b
-01100010b ^ 11110101b = 10010111b
-01100010b ^ 11110110b = 10010100b
-01100010b ^ 11110111b = 10010101b
-01100010b ^ 11111000b = 10011010b
-01100010b ^ 11111001b = 10011011b
-01100010b ^ 11111010b = 10011000b
-01100010b ^ 11111011b = 10011001b
-01100010b ^ 11111100b = 10011110b
-01100010b ^ 11111101b = 10011111b
-01100010b ^ 11111110b = 10011100b
-01100010b ^ 11111111b = 10011101b
-01100010b ^ 00000000b = 01100010b
-01100010b ^ 00000001b = 01100011b
-01100010b ^ 00000010b = 01100000b
-01100010b ^ 00000011b = 01100001b
-01100010b ^ 00000100b = 01100110b
-01100010b ^ 00000101b = 01100111b
-01100010b ^ 00000110b = 01100100b
-01100010b ^ 00000111b = 01100101b
-01100010b ^ 00001000b = 01101010b
-01100010b ^ 00001001b = 01101011b
-01100010b ^ 00001010b = 01101000b
-01100010b ^ 00001011b = 01101001b
-01100010b ^ 00001100b = 01101110b
-01100010b ^ 00001101b = 01101111b
-01100010b ^ 00001110b = 01101100b
-01100010b ^ 00001111b = 01101101b
-01100010b ^ 00010000b = 01110010b
-01100010b ^ 00010001b = 01110011b
-01100010b ^ 00010010b = 01110000b
-01100010b ^ 00010011b = 01110001b
-01100010b ^ 00010100b = 01110110b
-01100010b ^ 00010101b = 01110111b
-01100010b ^ 00010110b = 01110100b
-01100010b ^ 00010111b = 01110101b
-01100010b ^ 00011000b = 01111010b
-01100010b ^ 00011001b = 01111011b
-01100010b ^ 00011010b = 01111000b
-01100010b ^ 00011011b = 01111001b
-01100010b ^ 00011100b = 01111110b
-01100010b ^ 00011101b = 01111111b
-01100010b ^ 00011110b = 01111100b
-01100010b ^ 00011111b = 01111101b
-01100010b ^ 00100000b = 01000010b
-01100010b ^ 00100001b = 01000011b
-01100010b ^ 00100010b = 01000000b
-01100010b ^ 00100011b = 01000001b
-01100010b ^ 00100100b = 01000110b
-01100010b ^ 00100101b = 01000111b
-01100010b ^ 00100110b = 01000100b
-01100010b ^ 00100111b = 01000101b
-01100010b ^ 00101000b = 01001010b
-01100010b ^ 00101001b = 01001011b
-01100010b ^ 00101010b = 01001000b
-01100010b ^ 00101011b = 01001001b
-01100010b ^ 00101100b = 01001110b
-01100010b ^ 00101101b = 01001111b
-01100010b ^ 00101110b = 01001100b
-01100010b ^ 00101111b = 01001101b
-01100010b ^ 00110000b = 01010010b
-01100010b ^ 00110001b = 01010011b
-01100010b ^ 00110010b = 01010000b
-01100010b ^ 00110011b = 01010001b
-01100010b ^ 00110100b = 01010110b
-01100010b ^ 00110101b = 01010111b
-01100010b ^ 00110110b = 01010100b
-01100010b ^ 00110111b = 01010101b
-01100010b ^ 00111000b = 01011010b
-01100010b ^ 00111001b = 01011011b
-01100010b ^ 00111010b = 01011000b
-01100010b ^ 00111011b = 01011001b
-01100010b ^ 00111100b = 01011110b
-01100010b ^ 00111101b = 01011111b
-01100010b ^ 00111110b = 01011100b
-01100010b ^ 00111111b = 01011101b
-01100010b ^ 01000000b = 00100010b
-01100010b ^ 01000001b = 00100011b
-01100010b ^ 01000010b = 00100000b
-01100010b ^ 01000011b = 00100001b
-01100010b ^ 01000100b = 00100110b
-01100010b ^ 01000101b = 00100111b
-01100010b ^ 01000110b = 00100100b
-01100010b ^ 01000111b = 00100101b
-01100010b ^ 01001000b = 00101010b
-01100010b ^ 01001001b = 00101011b
-01100010b ^ 01001010b = 00101000b
-01100010b ^ 01001011b = 00101001b
-01100010b ^ 01001100b = 00101110b
-01100010b ^ 01001101b = 00101111b
-01100010b ^ 01001110b = 00101100b
-01100010b ^ 01001111b = 00101101b
-01100010b ^ 01010000b = 00110010b
-01100010b ^ 01010001b = 00110011b
-01100010b ^ 01010010b = 00110000b
-01100010b ^ 01010011b = 00110001b
-01100010b ^ 01010100b = 00110110b
-01100010b ^ 01010101b = 00110111b
-01100010b ^ 01010110b = 00110100b
-01100010b ^ 01010111b = 00110101b
-01100010b ^ 01011000b = 00111010b
-01100010b ^ 01011001b = 00111011b
-01100010b ^ 01011010b = 00111000b
-01100010b ^ 01011011b = 00111001b
-01100010b ^ 01011100b = 00111110b
-01100010b ^ 01011101b = 00111111b
-01100010b ^ 01011110b = 00111100b
-01100010b ^ 01011111b = 00111101b
-01100010b ^ 01100000b = 00000010b
-01100010b ^ 01100001b = 00000011b
-01100010b ^ 01100010b = 00000000b
-01100010b ^ 01100011b = 00000001b
-01100010b ^ 01100100b = 00000110b
-01100010b ^ 01100101b = 00000111b
-01100010b ^ 01100110b = 00000100b
-01100010b ^ 01100111b = 00000101b
-01100010b ^ 01101000b = 00001010b
-01100010b ^ 01101001b = 00001011b
-01100010b ^ 01101010b = 00001000b
-01100010b ^ 01101011b = 00001001b
-01100010b ^ 01101100b = 00001110b
-01100010b ^ 01101101b = 00001111b
-01100010b ^ 01101110b = 00001100b
-01100010b ^ 01101111b = 00001101b
-01100010b ^ 01110000b = 00010010b
-01100010b ^ 01110001b = 00010011b
-01100010b ^ 01110010b = 00010000b
-01100010b ^ 01110011b = 00010001b
-01100010b ^ 01110100b = 00010110b
-01100010b ^ 01110101b = 00010111b
-01100010b ^ 01110110b = 00010100b
-01100010b ^ 01110111b = 00010101b
-01100010b ^ 01111000b = 00011010b
-01100010b ^ 01111001b = 00011011b
-01100010b ^ 01111010b = 00011000b
-01100010b ^ 01111011b = 00011001b
-01100010b ^ 01111100b = 00011110b
-01100010b ^ 01111101b = 00011111b
-01100010b ^ 01111110b = 00011100b
-01100011b ^ 10000000b = 11100011b
-01100011b ^ 10000001b = 11100010b
-01100011b ^ 10000010b = 11100001b
-01100011b ^ 10000011b = 11100000b
-01100011b ^ 10000100b = 11100111b
-01100011b ^ 10000101b = 11100110b
-01100011b ^ 10000110b = 11100101b
-01100011b ^ 10000111b = 11100100b
-01100011b ^ 10001000b = 11101011b
-01100011b ^ 10001001b = 11101010b
-01100011b ^ 10001010b = 11101001b
-01100011b ^ 10001011b = 11101000b
-01100011b ^ 10001100b = 11101111b
-01100011b ^ 10001101b = 11101110b
-01100011b ^ 10001110b = 11101101b
-01100011b ^ 10001111b = 11101100b
-01100011b ^ 10010000b = 11110011b
-01100011b ^ 10010001b = 11110010b
-01100011b ^ 10010010b = 11110001b
-01100011b ^ 10010011b = 11110000b
-01100011b ^ 10010100b = 11110111b
-01100011b ^ 10010101b = 11110110b
-01100011b ^ 10010110b = 11110101b
-01100011b ^ 10010111b = 11110100b
-01100011b ^ 10011000b = 11111011b
-01100011b ^ 10011001b = 11111010b
-01100011b ^ 10011010b = 11111001b
-01100011b ^ 10011011b = 11111000b
-01100011b ^ 10011100b = 11111111b
-01100011b ^ 10011101b = 11111110b
-01100011b ^ 10011110b = 11111101b
-01100011b ^ 10011111b = 11111100b
-01100011b ^ 10100000b = 11000011b
-01100011b ^ 10100001b = 11000010b
-01100011b ^ 10100010b = 11000001b
-01100011b ^ 10100011b = 11000000b
-01100011b ^ 10100100b = 11000111b
-01100011b ^ 10100101b = 11000110b
-01100011b ^ 10100110b = 11000101b
-01100011b ^ 10100111b = 11000100b
-01100011b ^ 10101000b = 11001011b
-01100011b ^ 10101001b = 11001010b
-01100011b ^ 10101010b = 11001001b
-01100011b ^ 10101011b = 11001000b
-01100011b ^ 10101100b = 11001111b
-01100011b ^ 10101101b = 11001110b
-01100011b ^ 10101110b = 11001101b
-01100011b ^ 10101111b = 11001100b
-01100011b ^ 10110000b = 11010011b
-01100011b ^ 10110001b = 11010010b
-01100011b ^ 10110010b = 11010001b
-01100011b ^ 10110011b = 11010000b
-01100011b ^ 10110100b = 11010111b
-01100011b ^ 10110101b = 11010110b
-01100011b ^ 10110110b = 11010101b
-01100011b ^ 10110111b = 11010100b
-01100011b ^ 10111000b = 11011011b
-01100011b ^ 10111001b = 11011010b
-01100011b ^ 10111010b = 11011001b
-01100011b ^ 10111011b = 11011000b
-01100011b ^ 10111100b = 11011111b
-01100011b ^ 10111101b = 11011110b
-01100011b ^ 10111110b = 11011101b
-01100011b ^ 10111111b = 11011100b
-01100011b ^ 11000000b = 10100011b
-01100011b ^ 11000001b = 10100010b
-01100011b ^ 11000010b = 10100001b
-01100011b ^ 11000011b = 10100000b
-01100011b ^ 11000100b = 10100111b
-01100011b ^ 11000101b = 10100110b
-01100011b ^ 11000110b = 10100101b
-01100011b ^ 11000111b = 10100100b
-01100011b ^ 11001000b = 10101011b
-01100011b ^ 11001001b = 10101010b
-01100011b ^ 11001010b = 10101001b
-01100011b ^ 11001011b = 10101000b
-01100011b ^ 11001100b = 10101111b
-01100011b ^ 11001101b = 10101110b
-01100011b ^ 11001110b = 10101101b
-01100011b ^ 11001111b = 10101100b
-01100011b ^ 11010000b = 10110011b
-01100011b ^ 11010001b = 10110010b
-01100011b ^ 11010010b = 10110001b
-01100011b ^ 11010011b = 10110000b
-01100011b ^ 11010100b = 10110111b
-01100011b ^ 11010101b = 10110110b
-01100011b ^ 11010110b = 10110101b
-01100011b ^ 11010111b = 10110100b
-01100011b ^ 11011000b = 10111011b
-01100011b ^ 11011001b = 10111010b
-01100011b ^ 11011010b = 10111001b
-01100011b ^ 11011011b = 10111000b
-01100011b ^ 11011100b = 10111111b
-01100011b ^ 11011101b = 10111110b
-01100011b ^ 11011110b = 10111101b
-01100011b ^ 11011111b = 10111100b
-01100011b ^ 11100000b = 10000011b
-01100011b ^ 11100001b = 10000010b
-01100011b ^ 11100010b = 10000001b
-01100011b ^ 11100011b = 10000000b
-01100011b ^ 11100100b = 10000111b
-01100011b ^ 11100101b = 10000110b
-01100011b ^ 11100110b = 10000101b
-01100011b ^ 11100111b = 10000100b
-01100011b ^ 11101000b = 10001011b
-01100011b ^ 11101001b = 10001010b
-01100011b ^ 11101010b = 10001001b
-01100011b ^ 11101011b = 10001000b
-01100011b ^ 11101100b = 10001111b
-01100011b ^ 11101101b = 10001110b
-01100011b ^ 11101110b = 10001101b
-01100011b ^ 11101111b = 10001100b
-01100011b ^ 11110000b = 10010011b
-01100011b ^ 11110001b = 10010010b
-01100011b ^ 11110010b = 10010001b
-01100011b ^ 11110011b = 10010000b
-01100011b ^ 11110100b = 10010111b
-01100011b ^ 11110101b = 10010110b
-01100011b ^ 11110110b = 10010101b
-01100011b ^ 11110111b = 10010100b
-01100011b ^ 11111000b = 10011011b
-01100011b ^ 11111001b = 10011010b
-01100011b ^ 11111010b = 10011001b
-01100011b ^ 11111011b = 10011000b
-01100011b ^ 11111100b = 10011111b
-01100011b ^ 11111101b = 10011110b
-01100011b ^ 11111110b = 10011101b
-01100011b ^ 11111111b = 10011100b
-01100011b ^ 00000000b = 01100011b
-01100011b ^ 00000001b = 01100010b
-01100011b ^ 00000010b = 01100001b
-01100011b ^ 00000011b = 01100000b
-01100011b ^ 00000100b = 01100111b
-01100011b ^ 00000101b = 01100110b
-01100011b ^ 00000110b = 01100101b
-01100011b ^ 00000111b = 01100100b
-01100011b ^ 00001000b = 01101011b
-01100011b ^ 00001001b = 01101010b
-01100011b ^ 00001010b = 01101001b
-01100011b ^ 00001011b = 01101000b
-01100011b ^ 00001100b = 01101111b
-01100011b ^ 00001101b = 01101110b
-01100011b ^ 00001110b = 01101101b
-01100011b ^ 00001111b = 01101100b
-01100011b ^ 00010000b = 01110011b
-01100011b ^ 00010001b = 01110010b
-01100011b ^ 00010010b = 01110001b
-01100011b ^ 00010011b = 01110000b
-01100011b ^ 00010100b = 01110111b
-01100011b ^ 00010101b = 01110110b
-01100011b ^ 00010110b = 01110101b
-01100011b ^ 00010111b = 01110100b
-01100011b ^ 00011000b = 01111011b
-01100011b ^ 00011001b = 01111010b
-01100011b ^ 00011010b = 01111001b
-01100011b ^ 00011011b = 01111000b
-01100011b ^ 00011100b = 01111111b
-01100011b ^ 00011101b = 01111110b
-01100011b ^ 00011110b = 01111101b
-01100011b ^ 00011111b = 01111100b
-01100011b ^ 00100000b = 01000011b
-01100011b ^ 00100001b = 01000010b
-01100011b ^ 00100010b = 01000001b
-01100011b ^ 00100011b = 01000000b
-01100011b ^ 00100100b = 01000111b
-01100011b ^ 00100101b = 01000110b
-01100011b ^ 00100110b = 01000101b
-01100011b ^ 00100111b = 01000100b
-01100011b ^ 00101000b = 01001011b
-01100011b ^ 00101001b = 01001010b
-01100011b ^ 00101010b = 01001001b
-01100011b ^ 00101011b = 01001000b
-01100011b ^ 00101100b = 01001111b
-01100011b ^ 00101101b = 01001110b
-01100011b ^ 00101110b = 01001101b
-01100011b ^ 00101111b = 01001100b
-01100011b ^ 00110000b = 01010011b
-01100011b ^ 00110001b = 01010010b
-01100011b ^ 00110010b = 01010001b
-01100011b ^ 00110011b = 01010000b
-01100011b ^ 00110100b = 01010111b
-01100011b ^ 00110101b = 01010110b
-01100011b ^ 00110110b = 01010101b
-01100011b ^ 00110111b = 01010100b
-01100011b ^ 00111000b = 01011011b
-01100011b ^ 00111001b = 01011010b
-01100011b ^ 00111010b = 01011001b
-01100011b ^ 00111011b = 01011000b
-01100011b ^ 00111100b = 01011111b
-01100011b ^ 00111101b = 01011110b
-01100011b ^ 00111110b = 01011101b
-01100011b ^ 00111111b = 01011100b
-01100011b ^ 01000000b = 00100011b
-01100011b ^ 01000001b = 00100010b
-01100011b ^ 01000010b = 00100001b
-01100011b ^ 01000011b = 00100000b
-01100011b ^ 01000100b = 00100111b
-01100011b ^ 01000101b = 00100110b
-01100011b ^ 01000110b = 00100101b
-01100011b ^ 01000111b = 00100100b
-01100011b ^ 01001000b = 00101011b
-01100011b ^ 01001001b = 00101010b
-01100011b ^ 01001010b = 00101001b
-01100011b ^ 01001011b = 00101000b
-01100011b ^ 01001100b = 00101111b
-01100011b ^ 01001101b = 00101110b
-01100011b ^ 01001110b = 00101101b
-01100011b ^ 01001111b = 00101100b
-01100011b ^ 01010000b = 00110011b
-01100011b ^ 01010001b = 00110010b
-01100011b ^ 01010010b = 00110001b
-01100011b ^ 01010011b = 00110000b
-01100011b ^ 01010100b = 00110111b
-01100011b ^ 01010101b = 00110110b
-01100011b ^ 01010110b = 00110101b
-01100011b ^ 01010111b = 00110100b
-01100011b ^ 01011000b = 00111011b
-01100011b ^ 01011001b = 00111010b
-01100011b ^ 01011010b = 00111001b
-01100011b ^ 01011011b = 00111000b
-01100011b ^ 01011100b = 00111111b
-01100011b ^ 01011101b = 00111110b
-01100011b ^ 01011110b = 00111101b
-01100011b ^ 01011111b = 00111100b
-01100011b ^ 01100000b = 00000011b
-01100011b ^ 01100001b = 00000010b
-01100011b ^ 01100010b = 00000001b
-01100011b ^ 01100011b = 00000000b
-01100011b ^ 01100100b = 00000111b
-01100011b ^ 01100101b = 00000110b
-01100011b ^ 01100110b = 00000101b
-01100011b ^ 01100111b = 00000100b
-01100011b ^ 01101000b = 00001011b
-01100011b ^ 01101001b = 00001010b
-01100011b ^ 01101010b = 00001001b
-01100011b ^ 01101011b = 00001000b
-01100011b ^ 01101100b = 00001111b
-01100011b ^ 01101101b = 00001110b
-01100011b ^ 01101110b = 00001101b
-01100011b ^ 01101111b = 00001100b
-01100011b ^ 01110000b = 00010011b
-01100011b ^ 01110001b = 00010010b
-01100011b ^ 01110010b = 00010001b
-01100011b ^ 01110011b = 00010000b
-01100011b ^ 01110100b = 00010111b
-01100011b ^ 01110101b = 00010110b
-01100011b ^ 01110110b = 00010101b
-01100011b ^ 01110111b = 00010100b
-01100011b ^ 01111000b = 00011011b
-01100011b ^ 01111001b = 00011010b
-01100011b ^ 01111010b = 00011001b
-01100011b ^ 01111011b = 00011000b
-01100011b ^ 01111100b = 00011111b
-01100011b ^ 01111101b = 00011110b
-01100011b ^ 01111110b = 00011101b
-01100100b ^ 10000000b = 11100100b
-01100100b ^ 10000001b = 11100101b
-01100100b ^ 10000010b = 11100110b
-01100100b ^ 10000011b = 11100111b
-01100100b ^ 10000100b = 11100000b
-01100100b ^ 10000101b = 11100001b
-01100100b ^ 10000110b = 11100010b
-01100100b ^ 10000111b = 11100011b
-01100100b ^ 10001000b = 11101100b
-01100100b ^ 10001001b = 11101101b
-01100100b ^ 10001010b = 11101110b
-01100100b ^ 10001011b = 11101111b
-01100100b ^ 10001100b = 11101000b
-01100100b ^ 10001101b = 11101001b
-01100100b ^ 10001110b = 11101010b
-01100100b ^ 10001111b = 11101011b
-01100100b ^ 10010000b = 11110100b
-01100100b ^ 10010001b = 11110101b
-01100100b ^ 10010010b = 11110110b
-01100100b ^ 10010011b = 11110111b
-01100100b ^ 10010100b = 11110000b
-01100100b ^ 10010101b = 11110001b
-01100100b ^ 10010110b = 11110010b
-01100100b ^ 10010111b = 11110011b
-01100100b ^ 10011000b = 11111100b
-01100100b ^ 10011001b = 11111101b
-01100100b ^ 10011010b = 11111110b
-01100100b ^ 10011011b = 11111111b
-01100100b ^ 10011100b = 11111000b
-01100100b ^ 10011101b = 11111001b
-01100100b ^ 10011110b = 11111010b
-01100100b ^ 10011111b = 11111011b
-01100100b ^ 10100000b = 11000100b
-01100100b ^ 10100001b = 11000101b
-01100100b ^ 10100010b = 11000110b
-01100100b ^ 10100011b = 11000111b
-01100100b ^ 10100100b = 11000000b
-01100100b ^ 10100101b = 11000001b
-01100100b ^ 10100110b = 11000010b
-01100100b ^ 10100111b = 11000011b
-01100100b ^ 10101000b = 11001100b
-01100100b ^ 10101001b = 11001101b
-01100100b ^ 10101010b = 11001110b
-01100100b ^ 10101011b = 11001111b
-01100100b ^ 10101100b = 11001000b
-01100100b ^ 10101101b = 11001001b
-01100100b ^ 10101110b = 11001010b
-01100100b ^ 10101111b = 11001011b
-01100100b ^ 10110000b = 11010100b
-01100100b ^ 10110001b = 11010101b
-01100100b ^ 10110010b = 11010110b
-01100100b ^ 10110011b = 11010111b
-01100100b ^ 10110100b = 11010000b
-01100100b ^ 10110101b = 11010001b
-01100100b ^ 10110110b = 11010010b
-01100100b ^ 10110111b = 11010011b
-01100100b ^ 10111000b = 11011100b
-01100100b ^ 10111001b = 11011101b
-01100100b ^ 10111010b = 11011110b
-01100100b ^ 10111011b = 11011111b
-01100100b ^ 10111100b = 11011000b
-01100100b ^ 10111101b = 11011001b
-01100100b ^ 10111110b = 11011010b
-01100100b ^ 10111111b = 11011011b
-01100100b ^ 11000000b = 10100100b
-01100100b ^ 11000001b = 10100101b
-01100100b ^ 11000010b = 10100110b
-01100100b ^ 11000011b = 10100111b
-01100100b ^ 11000100b = 10100000b
-01100100b ^ 11000101b = 10100001b
-01100100b ^ 11000110b = 10100010b
-01100100b ^ 11000111b = 10100011b
-01100100b ^ 11001000b = 10101100b
-01100100b ^ 11001001b = 10101101b
-01100100b ^ 11001010b = 10101110b
-01100100b ^ 11001011b = 10101111b
-01100100b ^ 11001100b = 10101000b
-01100100b ^ 11001101b = 10101001b
-01100100b ^ 11001110b = 10101010b
-01100100b ^ 11001111b = 10101011b
-01100100b ^ 11010000b = 10110100b
-01100100b ^ 11010001b = 10110101b
-01100100b ^ 11010010b = 10110110b
-01100100b ^ 11010011b = 10110111b
-01100100b ^ 11010100b = 10110000b
-01100100b ^ 11010101b = 10110001b
-01100100b ^ 11010110b = 10110010b
-01100100b ^ 11010111b = 10110011b
-01100100b ^ 11011000b = 10111100b
-01100100b ^ 11011001b = 10111101b
-01100100b ^ 11011010b = 10111110b
-01100100b ^ 11011011b = 10111111b
-01100100b ^ 11011100b = 10111000b
-01100100b ^ 11011101b = 10111001b
-01100100b ^ 11011110b = 10111010b
-01100100b ^ 11011111b = 10111011b
-01100100b ^ 11100000b = 10000100b
-01100100b ^ 11100001b = 10000101b
-01100100b ^ 11100010b = 10000110b
-01100100b ^ 11100011b = 10000111b
-01100100b ^ 11100100b = 10000000b
-01100100b ^ 11100101b = 10000001b
-01100100b ^ 11100110b = 10000010b
-01100100b ^ 11100111b = 10000011b
-01100100b ^ 11101000b = 10001100b
-01100100b ^ 11101001b = 10001101b
-01100100b ^ 11101010b = 10001110b
-01100100b ^ 11101011b = 10001111b
-01100100b ^ 11101100b = 10001000b
-01100100b ^ 11101101b = 10001001b
-01100100b ^ 11101110b = 10001010b
-01100100b ^ 11101111b = 10001011b
-01100100b ^ 11110000b = 10010100b
-01100100b ^ 11110001b = 10010101b
-01100100b ^ 11110010b = 10010110b
-01100100b ^ 11110011b = 10010111b
-01100100b ^ 11110100b = 10010000b
-01100100b ^ 11110101b = 10010001b
-01100100b ^ 11110110b = 10010010b
-01100100b ^ 11110111b = 10010011b
-01100100b ^ 11111000b = 10011100b
-01100100b ^ 11111001b = 10011101b
-01100100b ^ 11111010b = 10011110b
-01100100b ^ 11111011b = 10011111b
-01100100b ^ 11111100b = 10011000b
-01100100b ^ 11111101b = 10011001b
-01100100b ^ 11111110b = 10011010b
-01100100b ^ 11111111b = 10011011b
-01100100b ^ 00000000b = 01100100b
-01100100b ^ 00000001b = 01100101b
-01100100b ^ 00000010b = 01100110b
-01100100b ^ 00000011b = 01100111b
-01100100b ^ 00000100b = 01100000b
-01100100b ^ 00000101b = 01100001b
-01100100b ^ 00000110b = 01100010b
-01100100b ^ 00000111b = 01100011b
-01100100b ^ 00001000b = 01101100b
-01100100b ^ 00001001b = 01101101b
-01100100b ^ 00001010b = 01101110b
-01100100b ^ 00001011b = 01101111b
-01100100b ^ 00001100b = 01101000b
-01100100b ^ 00001101b = 01101001b
-01100100b ^ 00001110b = 01101010b
-01100100b ^ 00001111b = 01101011b
-01100100b ^ 00010000b = 01110100b
-01100100b ^ 00010001b = 01110101b
-01100100b ^ 00010010b = 01110110b
-01100100b ^ 00010011b = 01110111b
-01100100b ^ 00010100b = 01110000b
-01100100b ^ 00010101b = 01110001b
-01100100b ^ 00010110b = 01110010b
-01100100b ^ 00010111b = 01110011b
-01100100b ^ 00011000b = 01111100b
-01100100b ^ 00011001b = 01111101b
-01100100b ^ 00011010b = 01111110b
-01100100b ^ 00011011b = 01111111b
-01100100b ^ 00011100b = 01111000b
-01100100b ^ 00011101b = 01111001b
-01100100b ^ 00011110b = 01111010b
-01100100b ^ 00011111b = 01111011b
-01100100b ^ 00100000b = 01000100b
-01100100b ^ 00100001b = 01000101b
-01100100b ^ 00100010b = 01000110b
-01100100b ^ 00100011b = 01000111b
-01100100b ^ 00100100b = 01000000b
-01100100b ^ 00100101b = 01000001b
-01100100b ^ 00100110b = 01000010b
-01100100b ^ 00100111b = 01000011b
-01100100b ^ 00101000b = 01001100b
-01100100b ^ 00101001b = 01001101b
-01100100b ^ 00101010b = 01001110b
-01100100b ^ 00101011b = 01001111b
-01100100b ^ 00101100b = 01001000b
-01100100b ^ 00101101b = 01001001b
-01100100b ^ 00101110b = 01001010b
-01100100b ^ 00101111b = 01001011b
-01100100b ^ 00110000b = 01010100b
-01100100b ^ 00110001b = 01010101b
-01100100b ^ 00110010b = 01010110b
-01100100b ^ 00110011b = 01010111b
-01100100b ^ 00110100b = 01010000b
-01100100b ^ 00110101b = 01010001b
-01100100b ^ 00110110b = 01010010b
-01100100b ^ 00110111b = 01010011b
-01100100b ^ 00111000b = 01011100b
-01100100b ^ 00111001b = 01011101b
-01100100b ^ 00111010b = 01011110b
-01100100b ^ 00111011b = 01011111b
-01100100b ^ 00111100b = 01011000b
-01100100b ^ 00111101b = 01011001b
-01100100b ^ 00111110b = 01011010b
-01100100b ^ 00111111b = 01011011b
-01100100b ^ 01000000b = 00100100b
-01100100b ^ 01000001b = 00100101b
-01100100b ^ 01000010b = 00100110b
-01100100b ^ 01000011b = 00100111b
-01100100b ^ 01000100b = 00100000b
-01100100b ^ 01000101b = 00100001b
-01100100b ^ 01000110b = 00100010b
-01100100b ^ 01000111b = 00100011b
-01100100b ^ 01001000b = 00101100b
-01100100b ^ 01001001b = 00101101b
-01100100b ^ 01001010b = 00101110b
-01100100b ^ 01001011b = 00101111b
-01100100b ^ 01001100b = 00101000b
-01100100b ^ 01001101b = 00101001b
-01100100b ^ 01001110b = 00101010b
-01100100b ^ 01001111b = 00101011b
-01100100b ^ 01010000b = 00110100b
-01100100b ^ 01010001b = 00110101b
-01100100b ^ 01010010b = 00110110b
-01100100b ^ 01010011b = 00110111b
-01100100b ^ 01010100b = 00110000b
-01100100b ^ 01010101b = 00110001b
-01100100b ^ 01010110b = 00110010b
-01100100b ^ 01010111b = 00110011b
-01100100b ^ 01011000b = 00111100b
-01100100b ^ 01011001b = 00111101b
-01100100b ^ 01011010b = 00111110b
-01100100b ^ 01011011b = 00111111b
-01100100b ^ 01011100b = 00111000b
-01100100b ^ 01011101b = 00111001b
-01100100b ^ 01011110b = 00111010b
-01100100b ^ 01011111b = 00111011b
-01100100b ^ 01100000b = 00000100b
-01100100b ^ 01100001b = 00000101b
-01100100b ^ 01100010b = 00000110b
-01100100b ^ 01100011b = 00000111b
-01100100b ^ 01100100b = 00000000b
-01100100b ^ 01100101b = 00000001b
-01100100b ^ 01100110b = 00000010b
-01100100b ^ 01100111b = 00000011b
-01100100b ^ 01101000b = 00001100b
-01100100b ^ 01101001b = 00001101b
-01100100b ^ 01101010b = 00001110b
-01100100b ^ 01101011b = 00001111b
-01100100b ^ 01101100b = 00001000b
-01100100b ^ 01101101b = 00001001b
-01100100b ^ 01101110b = 00001010b
-01100100b ^ 01101111b = 00001011b
-01100100b ^ 01110000b = 00010100b
-01100100b ^ 01110001b = 00010101b
-01100100b ^ 01110010b = 00010110b
-01100100b ^ 01110011b = 00010111b
-01100100b ^ 01110100b = 00010000b
-01100100b ^ 01110101b = 00010001b
-01100100b ^ 01110110b = 00010010b
-01100100b ^ 01110111b = 00010011b
-01100100b ^ 01111000b = 00011100b
-01100100b ^ 01111001b = 00011101b
-01100100b ^ 01111010b = 00011110b
-01100100b ^ 01111011b = 00011111b
-01100100b ^ 01111100b = 00011000b
-01100100b ^ 01111101b = 00011001b
-01100100b ^ 01111110b = 00011010b
-01100101b ^ 10000000b = 11100101b
-01100101b ^ 10000001b = 11100100b
-01100101b ^ 10000010b = 11100111b
-01100101b ^ 10000011b = 11100110b
-01100101b ^ 10000100b = 11100001b
-01100101b ^ 10000101b = 11100000b
-01100101b ^ 10000110b = 11100011b
-01100101b ^ 10000111b = 11100010b
-01100101b ^ 10001000b = 11101101b
-01100101b ^ 10001001b = 11101100b
-01100101b ^ 10001010b = 11101111b
-01100101b ^ 10001011b = 11101110b
-01100101b ^ 10001100b = 11101001b
-01100101b ^ 10001101b = 11101000b
-01100101b ^ 10001110b = 11101011b
-01100101b ^ 10001111b = 11101010b
-01100101b ^ 10010000b = 11110101b
-01100101b ^ 10010001b = 11110100b
-01100101b ^ 10010010b = 11110111b
-01100101b ^ 10010011b = 11110110b
-01100101b ^ 10010100b = 11110001b
-01100101b ^ 10010101b = 11110000b
-01100101b ^ 10010110b = 11110011b
-01100101b ^ 10010111b = 11110010b
-01100101b ^ 10011000b = 11111101b
-01100101b ^ 10011001b = 11111100b
-01100101b ^ 10011010b = 11111111b
-01100101b ^ 10011011b = 11111110b
-01100101b ^ 10011100b = 11111001b
-01100101b ^ 10011101b = 11111000b
-01100101b ^ 10011110b = 11111011b
-01100101b ^ 10011111b = 11111010b
-01100101b ^ 10100000b = 11000101b
-01100101b ^ 10100001b = 11000100b
-01100101b ^ 10100010b = 11000111b
-01100101b ^ 10100011b = 11000110b
-01100101b ^ 10100100b = 11000001b
-01100101b ^ 10100101b = 11000000b
-01100101b ^ 10100110b = 11000011b
-01100101b ^ 10100111b = 11000010b
-01100101b ^ 10101000b = 11001101b
-01100101b ^ 10101001b = 11001100b
-01100101b ^ 10101010b = 11001111b
-01100101b ^ 10101011b = 11001110b
-01100101b ^ 10101100b = 11001001b
-01100101b ^ 10101101b = 11001000b
-01100101b ^ 10101110b = 11001011b
-01100101b ^ 10101111b = 11001010b
-01100101b ^ 10110000b = 11010101b
-01100101b ^ 10110001b = 11010100b
-01100101b ^ 10110010b = 11010111b
-01100101b ^ 10110011b = 11010110b
-01100101b ^ 10110100b = 11010001b
-01100101b ^ 10110101b = 11010000b
-01100101b ^ 10110110b = 11010011b
-01100101b ^ 10110111b = 11010010b
-01100101b ^ 10111000b = 11011101b
-01100101b ^ 10111001b = 11011100b
-01100101b ^ 10111010b = 11011111b
-01100101b ^ 10111011b = 11011110b
-01100101b ^ 10111100b = 11011001b
-01100101b ^ 10111101b = 11011000b
-01100101b ^ 10111110b = 11011011b
-01100101b ^ 10111111b = 11011010b
-01100101b ^ 11000000b = 10100101b
-01100101b ^ 11000001b = 10100100b
-01100101b ^ 11000010b = 10100111b
-01100101b ^ 11000011b = 10100110b
-01100101b ^ 11000100b = 10100001b
-01100101b ^ 11000101b = 10100000b
-01100101b ^ 11000110b = 10100011b
-01100101b ^ 11000111b = 10100010b
-01100101b ^ 11001000b = 10101101b
-01100101b ^ 11001001b = 10101100b
-01100101b ^ 11001010b = 10101111b
-01100101b ^ 11001011b = 10101110b
-01100101b ^ 11001100b = 10101001b
-01100101b ^ 11001101b = 10101000b
-01100101b ^ 11001110b = 10101011b
-01100101b ^ 11001111b = 10101010b
-01100101b ^ 11010000b = 10110101b
-01100101b ^ 11010001b = 10110100b
-01100101b ^ 11010010b = 10110111b
-01100101b ^ 11010011b = 10110110b
-01100101b ^ 11010100b = 10110001b
-01100101b ^ 11010101b = 10110000b
-01100101b ^ 11010110b = 10110011b
-01100101b ^ 11010111b = 10110010b
-01100101b ^ 11011000b = 10111101b
-01100101b ^ 11011001b = 10111100b
-01100101b ^ 11011010b = 10111111b
-01100101b ^ 11011011b = 10111110b
-01100101b ^ 11011100b = 10111001b
-01100101b ^ 11011101b = 10111000b
-01100101b ^ 11011110b = 10111011b
-01100101b ^ 11011111b = 10111010b
-01100101b ^ 11100000b = 10000101b
-01100101b ^ 11100001b = 10000100b
-01100101b ^ 11100010b = 10000111b
-01100101b ^ 11100011b = 10000110b
-01100101b ^ 11100100b = 10000001b
-01100101b ^ 11100101b = 10000000b
-01100101b ^ 11100110b = 10000011b
-01100101b ^ 11100111b = 10000010b
-01100101b ^ 11101000b = 10001101b
-01100101b ^ 11101001b = 10001100b
-01100101b ^ 11101010b = 10001111b
-01100101b ^ 11101011b = 10001110b
-01100101b ^ 11101100b = 10001001b
-01100101b ^ 11101101b = 10001000b
-01100101b ^ 11101110b = 10001011b
-01100101b ^ 11101111b = 10001010b
-01100101b ^ 11110000b = 10010101b
-01100101b ^ 11110001b = 10010100b
-01100101b ^ 11110010b = 10010111b
-01100101b ^ 11110011b = 10010110b
-01100101b ^ 11110100b = 10010001b
-01100101b ^ 11110101b = 10010000b
-01100101b ^ 11110110b = 10010011b
-01100101b ^ 11110111b = 10010010b
-01100101b ^ 11111000b = 10011101b
-01100101b ^ 11111001b = 10011100b
-01100101b ^ 11111010b = 10011111b
-01100101b ^ 11111011b = 10011110b
-01100101b ^ 11111100b = 10011001b
-01100101b ^ 11111101b = 10011000b
-01100101b ^ 11111110b = 10011011b
-01100101b ^ 11111111b = 10011010b
-01100101b ^ 00000000b = 01100101b
-01100101b ^ 00000001b = 01100100b
-01100101b ^ 00000010b = 01100111b
-01100101b ^ 00000011b = 01100110b
-01100101b ^ 00000100b = 01100001b
-01100101b ^ 00000101b = 01100000b
-01100101b ^ 00000110b = 01100011b
-01100101b ^ 00000111b = 01100010b
-01100101b ^ 00001000b = 01101101b
-01100101b ^ 00001001b = 01101100b
-01100101b ^ 00001010b = 01101111b
-01100101b ^ 00001011b = 01101110b
-01100101b ^ 00001100b = 01101001b
-01100101b ^ 00001101b = 01101000b
-01100101b ^ 00001110b = 01101011b
-01100101b ^ 00001111b = 01101010b
-01100101b ^ 00010000b = 01110101b
-01100101b ^ 00010001b = 01110100b
-01100101b ^ 00010010b = 01110111b
-01100101b ^ 00010011b = 01110110b
-01100101b ^ 00010100b = 01110001b
-01100101b ^ 00010101b = 01110000b
-01100101b ^ 00010110b = 01110011b
-01100101b ^ 00010111b = 01110010b
-01100101b ^ 00011000b = 01111101b
-01100101b ^ 00011001b = 01111100b
-01100101b ^ 00011010b = 01111111b
-01100101b ^ 00011011b = 01111110b
-01100101b ^ 00011100b = 01111001b
-01100101b ^ 00011101b = 01111000b
-01100101b ^ 00011110b = 01111011b
-01100101b ^ 00011111b = 01111010b
-01100101b ^ 00100000b = 01000101b
-01100101b ^ 00100001b = 01000100b
-01100101b ^ 00100010b = 01000111b
-01100101b ^ 00100011b = 01000110b
-01100101b ^ 00100100b = 01000001b
-01100101b ^ 00100101b = 01000000b
-01100101b ^ 00100110b = 01000011b
-01100101b ^ 00100111b = 01000010b
-01100101b ^ 00101000b = 01001101b
-01100101b ^ 00101001b = 01001100b
-01100101b ^ 00101010b = 01001111b
-01100101b ^ 00101011b = 01001110b
-01100101b ^ 00101100b = 01001001b
-01100101b ^ 00101101b = 01001000b
-01100101b ^ 00101110b = 01001011b
-01100101b ^ 00101111b = 01001010b
-01100101b ^ 00110000b = 01010101b
-01100101b ^ 00110001b = 01010100b
-01100101b ^ 00110010b = 01010111b
-01100101b ^ 00110011b = 01010110b
-01100101b ^ 00110100b = 01010001b
-01100101b ^ 00110101b = 01010000b
-01100101b ^ 00110110b = 01010011b
-01100101b ^ 00110111b = 01010010b
-01100101b ^ 00111000b = 01011101b
-01100101b ^ 00111001b = 01011100b
-01100101b ^ 00111010b = 01011111b
-01100101b ^ 00111011b = 01011110b
-01100101b ^ 00111100b = 01011001b
-01100101b ^ 00111101b = 01011000b
-01100101b ^ 00111110b = 01011011b
-01100101b ^ 00111111b = 01011010b
-01100101b ^ 01000000b = 00100101b
-01100101b ^ 01000001b = 00100100b
-01100101b ^ 01000010b = 00100111b
-01100101b ^ 01000011b = 00100110b
-01100101b ^ 01000100b = 00100001b
-01100101b ^ 01000101b = 00100000b
-01100101b ^ 01000110b = 00100011b
-01100101b ^ 01000111b = 00100010b
-01100101b ^ 01001000b = 00101101b
-01100101b ^ 01001001b = 00101100b
-01100101b ^ 01001010b = 00101111b
-01100101b ^ 01001011b = 00101110b
-01100101b ^ 01001100b = 00101001b
-01100101b ^ 01001101b = 00101000b
-01100101b ^ 01001110b = 00101011b
-01100101b ^ 01001111b = 00101010b
-01100101b ^ 01010000b = 00110101b
-01100101b ^ 01010001b = 00110100b
-01100101b ^ 01010010b = 00110111b
-01100101b ^ 01010011b = 00110110b
-01100101b ^ 01010100b = 00110001b
-01100101b ^ 01010101b = 00110000b
-01100101b ^ 01010110b = 00110011b
-01100101b ^ 01010111b = 00110010b
-01100101b ^ 01011000b = 00111101b
-01100101b ^ 01011001b = 00111100b
-01100101b ^ 01011010b = 00111111b
-01100101b ^ 01011011b = 00111110b
-01100101b ^ 01011100b = 00111001b
-01100101b ^ 01011101b = 00111000b
-01100101b ^ 01011110b = 00111011b
-01100101b ^ 01011111b = 00111010b
-01100101b ^ 01100000b = 00000101b
-01100101b ^ 01100001b = 00000100b
-01100101b ^ 01100010b = 00000111b
-01100101b ^ 01100011b = 00000110b
-01100101b ^ 01100100b = 00000001b
-01100101b ^ 01100101b = 00000000b
-01100101b ^ 01100110b = 00000011b
-01100101b ^ 01100111b = 00000010b
-01100101b ^ 01101000b = 00001101b
-01100101b ^ 01101001b = 00001100b
-01100101b ^ 01101010b = 00001111b
-01100101b ^ 01101011b = 00001110b
-01100101b ^ 01101100b = 00001001b
-01100101b ^ 01101101b = 00001000b
-01100101b ^ 01101110b = 00001011b
-01100101b ^ 01101111b = 00001010b
-01100101b ^ 01110000b = 00010101b
-01100101b ^ 01110001b = 00010100b
-01100101b ^ 01110010b = 00010111b
-01100101b ^ 01110011b = 00010110b
-01100101b ^ 01110100b = 00010001b
-01100101b ^ 01110101b = 00010000b
-01100101b ^ 01110110b = 00010011b
-01100101b ^ 01110111b = 00010010b
-01100101b ^ 01111000b = 00011101b
-01100101b ^ 01111001b = 00011100b
-01100101b ^ 01111010b = 00011111b
-01100101b ^ 01111011b = 00011110b
-01100101b ^ 01111100b = 00011001b
-01100101b ^ 01111101b = 00011000b
-01100101b ^ 01111110b = 00011011b
-01100110b ^ 10000000b = 11100110b
-01100110b ^ 10000001b = 11100111b
-01100110b ^ 10000010b = 11100100b
-01100110b ^ 10000011b = 11100101b
-01100110b ^ 10000100b = 11100010b
-01100110b ^ 10000101b = 11100011b
-01100110b ^ 10000110b = 11100000b
-01100110b ^ 10000111b = 11100001b
-01100110b ^ 10001000b = 11101110b
-01100110b ^ 10001001b = 11101111b
-01100110b ^ 10001010b = 11101100b
-01100110b ^ 10001011b = 11101101b
-01100110b ^ 10001100b = 11101010b
-01100110b ^ 10001101b = 11101011b
-01100110b ^ 10001110b = 11101000b
-01100110b ^ 10001111b = 11101001b
-01100110b ^ 10010000b = 11110110b
-01100110b ^ 10010001b = 11110111b
-01100110b ^ 10010010b = 11110100b
-01100110b ^ 10010011b = 11110101b
-01100110b ^ 10010100b = 11110010b
-01100110b ^ 10010101b = 11110011b
-01100110b ^ 10010110b = 11110000b
-01100110b ^ 10010111b = 11110001b
-01100110b ^ 10011000b = 11111110b
-01100110b ^ 10011001b = 11111111b
-01100110b ^ 10011010b = 11111100b
-01100110b ^ 10011011b = 11111101b
-01100110b ^ 10011100b = 11111010b
-01100110b ^ 10011101b = 11111011b
-01100110b ^ 10011110b = 11111000b
-01100110b ^ 10011111b = 11111001b
-01100110b ^ 10100000b = 11000110b
-01100110b ^ 10100001b = 11000111b
-01100110b ^ 10100010b = 11000100b
-01100110b ^ 10100011b = 11000101b
-01100110b ^ 10100100b = 11000010b
-01100110b ^ 10100101b = 11000011b
-01100110b ^ 10100110b = 11000000b
-01100110b ^ 10100111b = 11000001b
-01100110b ^ 10101000b = 11001110b
-01100110b ^ 10101001b = 11001111b
-01100110b ^ 10101010b = 11001100b
-01100110b ^ 10101011b = 11001101b
-01100110b ^ 10101100b = 11001010b
-01100110b ^ 10101101b = 11001011b
-01100110b ^ 10101110b = 11001000b
-01100110b ^ 10101111b = 11001001b
-01100110b ^ 10110000b = 11010110b
-01100110b ^ 10110001b = 11010111b
-01100110b ^ 10110010b = 11010100b
-01100110b ^ 10110011b = 11010101b
-01100110b ^ 10110100b = 11010010b
-01100110b ^ 10110101b = 11010011b
-01100110b ^ 10110110b = 11010000b
-01100110b ^ 10110111b = 11010001b
-01100110b ^ 10111000b = 11011110b
-01100110b ^ 10111001b = 11011111b
-01100110b ^ 10111010b = 11011100b
-01100110b ^ 10111011b = 11011101b
-01100110b ^ 10111100b = 11011010b
-01100110b ^ 10111101b = 11011011b
-01100110b ^ 10111110b = 11011000b
-01100110b ^ 10111111b = 11011001b
-01100110b ^ 11000000b = 10100110b
-01100110b ^ 11000001b = 10100111b
-01100110b ^ 11000010b = 10100100b
-01100110b ^ 11000011b = 10100101b
-01100110b ^ 11000100b = 10100010b
-01100110b ^ 11000101b = 10100011b
-01100110b ^ 11000110b = 10100000b
-01100110b ^ 11000111b = 10100001b
-01100110b ^ 11001000b = 10101110b
-01100110b ^ 11001001b = 10101111b
-01100110b ^ 11001010b = 10101100b
-01100110b ^ 11001011b = 10101101b
-01100110b ^ 11001100b = 10101010b
-01100110b ^ 11001101b = 10101011b
-01100110b ^ 11001110b = 10101000b
-01100110b ^ 11001111b = 10101001b
-01100110b ^ 11010000b = 10110110b
-01100110b ^ 11010001b = 10110111b
-01100110b ^ 11010010b = 10110100b
-01100110b ^ 11010011b = 10110101b
-01100110b ^ 11010100b = 10110010b
-01100110b ^ 11010101b = 10110011b
-01100110b ^ 11010110b = 10110000b
-01100110b ^ 11010111b = 10110001b
-01100110b ^ 11011000b = 10111110b
-01100110b ^ 11011001b = 10111111b
-01100110b ^ 11011010b = 10111100b
-01100110b ^ 11011011b = 10111101b
-01100110b ^ 11011100b = 10111010b
-01100110b ^ 11011101b = 10111011b
-01100110b ^ 11011110b = 10111000b
-01100110b ^ 11011111b = 10111001b
-01100110b ^ 11100000b = 10000110b
-01100110b ^ 11100001b = 10000111b
-01100110b ^ 11100010b = 10000100b
-01100110b ^ 11100011b = 10000101b
-01100110b ^ 11100100b = 10000010b
-01100110b ^ 11100101b = 10000011b
-01100110b ^ 11100110b = 10000000b
-01100110b ^ 11100111b = 10000001b
-01100110b ^ 11101000b = 10001110b
-01100110b ^ 11101001b = 10001111b
-01100110b ^ 11101010b = 10001100b
-01100110b ^ 11101011b = 10001101b
-01100110b ^ 11101100b = 10001010b
-01100110b ^ 11101101b = 10001011b
-01100110b ^ 11101110b = 10001000b
-01100110b ^ 11101111b = 10001001b
-01100110b ^ 11110000b = 10010110b
-01100110b ^ 11110001b = 10010111b
-01100110b ^ 11110010b = 10010100b
-01100110b ^ 11110011b = 10010101b
-01100110b ^ 11110100b = 10010010b
-01100110b ^ 11110101b = 10010011b
-01100110b ^ 11110110b = 10010000b
-01100110b ^ 11110111b = 10010001b
-01100110b ^ 11111000b = 10011110b
-01100110b ^ 11111001b = 10011111b
-01100110b ^ 11111010b = 10011100b
-01100110b ^ 11111011b = 10011101b
-01100110b ^ 11111100b = 10011010b
-01100110b ^ 11111101b = 10011011b
-01100110b ^ 11111110b = 10011000b
-01100110b ^ 11111111b = 10011001b
-01100110b ^ 00000000b = 01100110b
-01100110b ^ 00000001b = 01100111b
-01100110b ^ 00000010b = 01100100b
-01100110b ^ 00000011b = 01100101b
-01100110b ^ 00000100b = 01100010b
-01100110b ^ 00000101b = 01100011b
-01100110b ^ 00000110b = 01100000b
-01100110b ^ 00000111b = 01100001b
-01100110b ^ 00001000b = 01101110b
-01100110b ^ 00001001b = 01101111b
-01100110b ^ 00001010b = 01101100b
-01100110b ^ 00001011b = 01101101b
-01100110b ^ 00001100b = 01101010b
-01100110b ^ 00001101b = 01101011b
-01100110b ^ 00001110b = 01101000b
-01100110b ^ 00001111b = 01101001b
-01100110b ^ 00010000b = 01110110b
-01100110b ^ 00010001b = 01110111b
-01100110b ^ 00010010b = 01110100b
-01100110b ^ 00010011b = 01110101b
-01100110b ^ 00010100b = 01110010b
-01100110b ^ 00010101b = 01110011b
-01100110b ^ 00010110b = 01110000b
-01100110b ^ 00010111b = 01110001b
-01100110b ^ 00011000b = 01111110b
-01100110b ^ 00011001b = 01111111b
-01100110b ^ 00011010b = 01111100b
-01100110b ^ 00011011b = 01111101b
-01100110b ^ 00011100b = 01111010b
-01100110b ^ 00011101b = 01111011b
-01100110b ^ 00011110b = 01111000b
-01100110b ^ 00011111b = 01111001b
-01100110b ^ 00100000b = 01000110b
-01100110b ^ 00100001b = 01000111b
-01100110b ^ 00100010b = 01000100b
-01100110b ^ 00100011b = 01000101b
-01100110b ^ 00100100b = 01000010b
-01100110b ^ 00100101b = 01000011b
-01100110b ^ 00100110b = 01000000b
-01100110b ^ 00100111b = 01000001b
-01100110b ^ 00101000b = 01001110b
-01100110b ^ 00101001b = 01001111b
-01100110b ^ 00101010b = 01001100b
-01100110b ^ 00101011b = 01001101b
-01100110b ^ 00101100b = 01001010b
-01100110b ^ 00101101b = 01001011b
-01100110b ^ 00101110b = 01001000b
-01100110b ^ 00101111b = 01001001b
-01100110b ^ 00110000b = 01010110b
-01100110b ^ 00110001b = 01010111b
-01100110b ^ 00110010b = 01010100b
-01100110b ^ 00110011b = 01010101b
-01100110b ^ 00110100b = 01010010b
-01100110b ^ 00110101b = 01010011b
-01100110b ^ 00110110b = 01010000b
-01100110b ^ 00110111b = 01010001b
-01100110b ^ 00111000b = 01011110b
-01100110b ^ 00111001b = 01011111b
-01100110b ^ 00111010b = 01011100b
-01100110b ^ 00111011b = 01011101b
-01100110b ^ 00111100b = 01011010b
-01100110b ^ 00111101b = 01011011b
-01100110b ^ 00111110b = 01011000b
-01100110b ^ 00111111b = 01011001b
-01100110b ^ 01000000b = 00100110b
-01100110b ^ 01000001b = 00100111b
-01100110b ^ 01000010b = 00100100b
-01100110b ^ 01000011b = 00100101b
-01100110b ^ 01000100b = 00100010b
-01100110b ^ 01000101b = 00100011b
-01100110b ^ 01000110b = 00100000b
-01100110b ^ 01000111b = 00100001b
-01100110b ^ 01001000b = 00101110b
-01100110b ^ 01001001b = 00101111b
-01100110b ^ 01001010b = 00101100b
-01100110b ^ 01001011b = 00101101b
-01100110b ^ 01001100b = 00101010b
-01100110b ^ 01001101b = 00101011b
-01100110b ^ 01001110b = 00101000b
-01100110b ^ 01001111b = 00101001b
-01100110b ^ 01010000b = 00110110b
-01100110b ^ 01010001b = 00110111b
-01100110b ^ 01010010b = 00110100b
-01100110b ^ 01010011b = 00110101b
-01100110b ^ 01010100b = 00110010b
-01100110b ^ 01010101b = 00110011b
-01100110b ^ 01010110b = 00110000b
-01100110b ^ 01010111b = 00110001b
-01100110b ^ 01011000b = 00111110b
-01100110b ^ 01011001b = 00111111b
-01100110b ^ 01011010b = 00111100b
-01100110b ^ 01011011b = 00111101b
-01100110b ^ 01011100b = 00111010b
-01100110b ^ 01011101b = 00111011b
-01100110b ^ 01011110b = 00111000b
-01100110b ^ 01011111b = 00111001b
-01100110b ^ 01100000b = 00000110b
-01100110b ^ 01100001b = 00000111b
-01100110b ^ 01100010b = 00000100b
-01100110b ^ 01100011b = 00000101b
-01100110b ^ 01100100b = 00000010b
-01100110b ^ 01100101b = 00000011b
-01100110b ^ 01100110b = 00000000b
-01100110b ^ 01100111b = 00000001b
-01100110b ^ 01101000b = 00001110b
-01100110b ^ 01101001b = 00001111b
-01100110b ^ 01101010b = 00001100b
-01100110b ^ 01101011b = 00001101b
-01100110b ^ 01101100b = 00001010b
-01100110b ^ 01101101b = 00001011b
-01100110b ^ 01101110b = 00001000b
-01100110b ^ 01101111b = 00001001b
-01100110b ^ 01110000b = 00010110b
-01100110b ^ 01110001b = 00010111b
-01100110b ^ 01110010b = 00010100b
-01100110b ^ 01110011b = 00010101b
-01100110b ^ 01110100b = 00010010b
-01100110b ^ 01110101b = 00010011b
-01100110b ^ 01110110b = 00010000b
-01100110b ^ 01110111b = 00010001b
-01100110b ^ 01111000b = 00011110b
-01100110b ^ 01111001b = 00011111b
-01100110b ^ 01111010b = 00011100b
-01100110b ^ 01111011b = 00011101b
-01100110b ^ 01111100b = 00011010b
-01100110b ^ 01111101b = 00011011b
-01100110b ^ 01111110b = 00011000b
-01100111b ^ 10000000b = 11100111b
-01100111b ^ 10000001b = 11100110b
-01100111b ^ 10000010b = 11100101b
-01100111b ^ 10000011b = 11100100b
-01100111b ^ 10000100b = 11100011b
-01100111b ^ 10000101b = 11100010b
-01100111b ^ 10000110b = 11100001b
-01100111b ^ 10000111b = 11100000b
-01100111b ^ 10001000b = 11101111b
-01100111b ^ 10001001b = 11101110b
-01100111b ^ 10001010b = 11101101b
-01100111b ^ 10001011b = 11101100b
-01100111b ^ 10001100b = 11101011b
-01100111b ^ 10001101b = 11101010b
-01100111b ^ 10001110b = 11101001b
-01100111b ^ 10001111b = 11101000b
-01100111b ^ 10010000b = 11110111b
-01100111b ^ 10010001b = 11110110b
-01100111b ^ 10010010b = 11110101b
-01100111b ^ 10010011b = 11110100b
-01100111b ^ 10010100b = 11110011b
-01100111b ^ 10010101b = 11110010b
-01100111b ^ 10010110b = 11110001b
-01100111b ^ 10010111b = 11110000b
-01100111b ^ 10011000b = 11111111b
-01100111b ^ 10011001b = 11111110b
-01100111b ^ 10011010b = 11111101b
-01100111b ^ 10011011b = 11111100b
-01100111b ^ 10011100b = 11111011b
-01100111b ^ 10011101b = 11111010b
-01100111b ^ 10011110b = 11111001b
-01100111b ^ 10011111b = 11111000b
-01100111b ^ 10100000b = 11000111b
-01100111b ^ 10100001b = 11000110b
-01100111b ^ 10100010b = 11000101b
-01100111b ^ 10100011b = 11000100b
-01100111b ^ 10100100b = 11000011b
-01100111b ^ 10100101b = 11000010b
-01100111b ^ 10100110b = 11000001b
-01100111b ^ 10100111b = 11000000b
-01100111b ^ 10101000b = 11001111b
-01100111b ^ 10101001b = 11001110b
-01100111b ^ 10101010b = 11001101b
-01100111b ^ 10101011b = 11001100b
-01100111b ^ 10101100b = 11001011b
-01100111b ^ 10101101b = 11001010b
-01100111b ^ 10101110b = 11001001b
-01100111b ^ 10101111b = 11001000b
-01100111b ^ 10110000b = 11010111b
-01100111b ^ 10110001b = 11010110b
-01100111b ^ 10110010b = 11010101b
-01100111b ^ 10110011b = 11010100b
-01100111b ^ 10110100b = 11010011b
-01100111b ^ 10110101b = 11010010b
-01100111b ^ 10110110b = 11010001b
-01100111b ^ 10110111b = 11010000b
-01100111b ^ 10111000b = 11011111b
-01100111b ^ 10111001b = 11011110b
-01100111b ^ 10111010b = 11011101b
-01100111b ^ 10111011b = 11011100b
-01100111b ^ 10111100b = 11011011b
-01100111b ^ 10111101b = 11011010b
-01100111b ^ 10111110b = 11011001b
-01100111b ^ 10111111b = 11011000b
-01100111b ^ 11000000b = 10100111b
-01100111b ^ 11000001b = 10100110b
-01100111b ^ 11000010b = 10100101b
-01100111b ^ 11000011b = 10100100b
-01100111b ^ 11000100b = 10100011b
-01100111b ^ 11000101b = 10100010b
-01100111b ^ 11000110b = 10100001b
-01100111b ^ 11000111b = 10100000b
-01100111b ^ 11001000b = 10101111b
-01100111b ^ 11001001b = 10101110b
-01100111b ^ 11001010b = 10101101b
-01100111b ^ 11001011b = 10101100b
-01100111b ^ 11001100b = 10101011b
-01100111b ^ 11001101b = 10101010b
-01100111b ^ 11001110b = 10101001b
-01100111b ^ 11001111b = 10101000b
-01100111b ^ 11010000b = 10110111b
-01100111b ^ 11010001b = 10110110b
-01100111b ^ 11010010b = 10110101b
-01100111b ^ 11010011b = 10110100b
-01100111b ^ 11010100b = 10110011b
-01100111b ^ 11010101b = 10110010b
-01100111b ^ 11010110b = 10110001b
-01100111b ^ 11010111b = 10110000b
-01100111b ^ 11011000b = 10111111b
-01100111b ^ 11011001b = 10111110b
-01100111b ^ 11011010b = 10111101b
-01100111b ^ 11011011b = 10111100b
-01100111b ^ 11011100b = 10111011b
-01100111b ^ 11011101b = 10111010b
-01100111b ^ 11011110b = 10111001b
-01100111b ^ 11011111b = 10111000b
-01100111b ^ 11100000b = 10000111b
-01100111b ^ 11100001b = 10000110b
-01100111b ^ 11100010b = 10000101b
-01100111b ^ 11100011b = 10000100b
-01100111b ^ 11100100b = 10000011b
-01100111b ^ 11100101b = 10000010b
-01100111b ^ 11100110b = 10000001b
-01100111b ^ 11100111b = 10000000b
-01100111b ^ 11101000b = 10001111b
-01100111b ^ 11101001b = 10001110b
-01100111b ^ 11101010b = 10001101b
-01100111b ^ 11101011b = 10001100b
-01100111b ^ 11101100b = 10001011b
-01100111b ^ 11101101b = 10001010b
-01100111b ^ 11101110b = 10001001b
-01100111b ^ 11101111b = 10001000b
-01100111b ^ 11110000b = 10010111b
-01100111b ^ 11110001b = 10010110b
-01100111b ^ 11110010b = 10010101b
-01100111b ^ 11110011b = 10010100b
-01100111b ^ 11110100b = 10010011b
-01100111b ^ 11110101b = 10010010b
-01100111b ^ 11110110b = 10010001b
-01100111b ^ 11110111b = 10010000b
-01100111b ^ 11111000b = 10011111b
-01100111b ^ 11111001b = 10011110b
-01100111b ^ 11111010b = 10011101b
-01100111b ^ 11111011b = 10011100b
-01100111b ^ 11111100b = 10011011b
-01100111b ^ 11111101b = 10011010b
-01100111b ^ 11111110b = 10011001b
-01100111b ^ 11111111b = 10011000b
-01100111b ^ 00000000b = 01100111b
-01100111b ^ 00000001b = 01100110b
-01100111b ^ 00000010b = 01100101b
-01100111b ^ 00000011b = 01100100b
-01100111b ^ 00000100b = 01100011b
-01100111b ^ 00000101b = 01100010b
-01100111b ^ 00000110b = 01100001b
-01100111b ^ 00000111b = 01100000b
-01100111b ^ 00001000b = 01101111b
-01100111b ^ 00001001b = 01101110b
-01100111b ^ 00001010b = 01101101b
-01100111b ^ 00001011b = 01101100b
-01100111b ^ 00001100b = 01101011b
-01100111b ^ 00001101b = 01101010b
-01100111b ^ 00001110b = 01101001b
-01100111b ^ 00001111b = 01101000b
-01100111b ^ 00010000b = 01110111b
-01100111b ^ 00010001b = 01110110b
-01100111b ^ 00010010b = 01110101b
-01100111b ^ 00010011b = 01110100b
-01100111b ^ 00010100b = 01110011b
-01100111b ^ 00010101b = 01110010b
-01100111b ^ 00010110b = 01110001b
-01100111b ^ 00010111b = 01110000b
-01100111b ^ 00011000b = 01111111b
-01100111b ^ 00011001b = 01111110b
-01100111b ^ 00011010b = 01111101b
-01100111b ^ 00011011b = 01111100b
-01100111b ^ 00011100b = 01111011b
-01100111b ^ 00011101b = 01111010b
-01100111b ^ 00011110b = 01111001b
-01100111b ^ 00011111b = 01111000b
-01100111b ^ 00100000b = 01000111b
-01100111b ^ 00100001b = 01000110b
-01100111b ^ 00100010b = 01000101b
-01100111b ^ 00100011b = 01000100b
-01100111b ^ 00100100b = 01000011b
-01100111b ^ 00100101b = 01000010b
-01100111b ^ 00100110b = 01000001b
-01100111b ^ 00100111b = 01000000b
-01100111b ^ 00101000b = 01001111b
-01100111b ^ 00101001b = 01001110b
-01100111b ^ 00101010b = 01001101b
-01100111b ^ 00101011b = 01001100b
-01100111b ^ 00101100b = 01001011b
-01100111b ^ 00101101b = 01001010b
-01100111b ^ 00101110b = 01001001b
-01100111b ^ 00101111b = 01001000b
-01100111b ^ 00110000b = 01010111b
-01100111b ^ 00110001b = 01010110b
-01100111b ^ 00110010b = 01010101b
-01100111b ^ 00110011b = 01010100b
-01100111b ^ 00110100b = 01010011b
-01100111b ^ 00110101b = 01010010b
-01100111b ^ 00110110b = 01010001b
-01100111b ^ 00110111b = 01010000b
-01100111b ^ 00111000b = 01011111b
-01100111b ^ 00111001b = 01011110b
-01100111b ^ 00111010b = 01011101b
-01100111b ^ 00111011b = 01011100b
-01100111b ^ 00111100b = 01011011b
-01100111b ^ 00111101b = 01011010b
-01100111b ^ 00111110b = 01011001b
-01100111b ^ 00111111b = 01011000b
-01100111b ^ 01000000b = 00100111b
-01100111b ^ 01000001b = 00100110b
-01100111b ^ 01000010b = 00100101b
-01100111b ^ 01000011b = 00100100b
-01100111b ^ 01000100b = 00100011b
-01100111b ^ 01000101b = 00100010b
-01100111b ^ 01000110b = 00100001b
-01100111b ^ 01000111b = 00100000b
-01100111b ^ 01001000b = 00101111b
-01100111b ^ 01001001b = 00101110b
-01100111b ^ 01001010b = 00101101b
-01100111b ^ 01001011b = 00101100b
-01100111b ^ 01001100b = 00101011b
-01100111b ^ 01001101b = 00101010b
-01100111b ^ 01001110b = 00101001b
-01100111b ^ 01001111b = 00101000b
-01100111b ^ 01010000b = 00110111b
-01100111b ^ 01010001b = 00110110b
-01100111b ^ 01010010b = 00110101b
-01100111b ^ 01010011b = 00110100b
-01100111b ^ 01010100b = 00110011b
-01100111b ^ 01010101b = 00110010b
-01100111b ^ 01010110b = 00110001b
-01100111b ^ 01010111b = 00110000b
-01100111b ^ 01011000b = 00111111b
-01100111b ^ 01011001b = 00111110b
-01100111b ^ 01011010b = 00111101b
-01100111b ^ 01011011b = 00111100b
-01100111b ^ 01011100b = 00111011b
-01100111b ^ 01011101b = 00111010b
-01100111b ^ 01011110b = 00111001b
-01100111b ^ 01011111b = 00111000b
-01100111b ^ 01100000b = 00000111b
-01100111b ^ 01100001b = 00000110b
-01100111b ^ 01100010b = 00000101b
-01100111b ^ 01100011b = 00000100b
-01100111b ^ 01100100b = 00000011b
-01100111b ^ 01100101b = 00000010b
-01100111b ^ 01100110b = 00000001b
-01100111b ^ 01100111b = 00000000b
-01100111b ^ 01101000b = 00001111b
-01100111b ^ 01101001b = 00001110b
-01100111b ^ 01101010b = 00001101b
-01100111b ^ 01101011b = 00001100b
-01100111b ^ 01101100b = 00001011b
-01100111b ^ 01101101b = 00001010b
-01100111b ^ 01101110b = 00001001b
-01100111b ^ 01101111b = 00001000b
-01100111b ^ 01110000b = 00010111b
-01100111b ^ 01110001b = 00010110b
-01100111b ^ 01110010b = 00010101b
-01100111b ^ 01110011b = 00010100b
-01100111b ^ 01110100b = 00010011b
-01100111b ^ 01110101b = 00010010b
-01100111b ^ 01110110b = 00010001b
-01100111b ^ 01110111b = 00010000b
-01100111b ^ 01111000b = 00011111b
-01100111b ^ 01111001b = 00011110b
-01100111b ^ 01111010b = 00011101b
-01100111b ^ 01111011b = 00011100b
-01100111b ^ 01111100b = 00011011b
-01100111b ^ 01111101b = 00011010b
-01100111b ^ 01111110b = 00011001b
-01101000b ^ 10000000b = 11101000b
-01101000b ^ 10000001b = 11101001b
-01101000b ^ 10000010b = 11101010b
-01101000b ^ 10000011b = 11101011b
-01101000b ^ 10000100b = 11101100b
-01101000b ^ 10000101b = 11101101b
-01101000b ^ 10000110b = 11101110b
-01101000b ^ 10000111b = 11101111b
-01101000b ^ 10001000b = 11100000b
-01101000b ^ 10001001b = 11100001b
-01101000b ^ 10001010b = 11100010b
-01101000b ^ 10001011b = 11100011b
-01101000b ^ 10001100b = 11100100b
-01101000b ^ 10001101b = 11100101b
-01101000b ^ 10001110b = 11100110b
-01101000b ^ 10001111b = 11100111b
-01101000b ^ 10010000b = 11111000b
-01101000b ^ 10010001b = 11111001b
-01101000b ^ 10010010b = 11111010b
-01101000b ^ 10010011b = 11111011b
-01101000b ^ 10010100b = 11111100b
-01101000b ^ 10010101b = 11111101b
-01101000b ^ 10010110b = 11111110b
-01101000b ^ 10010111b = 11111111b
-01101000b ^ 10011000b = 11110000b
-01101000b ^ 10011001b = 11110001b
-01101000b ^ 10011010b = 11110010b
-01101000b ^ 10011011b = 11110011b
-01101000b ^ 10011100b = 11110100b
-01101000b ^ 10011101b = 11110101b
-01101000b ^ 10011110b = 11110110b
-01101000b ^ 10011111b = 11110111b
-01101000b ^ 10100000b = 11001000b
-01101000b ^ 10100001b = 11001001b
-01101000b ^ 10100010b = 11001010b
-01101000b ^ 10100011b = 11001011b
-01101000b ^ 10100100b = 11001100b
-01101000b ^ 10100101b = 11001101b
-01101000b ^ 10100110b = 11001110b
-01101000b ^ 10100111b = 11001111b
-01101000b ^ 10101000b = 11000000b
-01101000b ^ 10101001b = 11000001b
-01101000b ^ 10101010b = 11000010b
-01101000b ^ 10101011b = 11000011b
-01101000b ^ 10101100b = 11000100b
-01101000b ^ 10101101b = 11000101b
-01101000b ^ 10101110b = 11000110b
-01101000b ^ 10101111b = 11000111b
-01101000b ^ 10110000b = 11011000b
-01101000b ^ 10110001b = 11011001b
-01101000b ^ 10110010b = 11011010b
-01101000b ^ 10110011b = 11011011b
-01101000b ^ 10110100b = 11011100b
-01101000b ^ 10110101b = 11011101b
-01101000b ^ 10110110b = 11011110b
-01101000b ^ 10110111b = 11011111b
-01101000b ^ 10111000b = 11010000b
-01101000b ^ 10111001b = 11010001b
-01101000b ^ 10111010b = 11010010b
-01101000b ^ 10111011b = 11010011b
-01101000b ^ 10111100b = 11010100b
-01101000b ^ 10111101b = 11010101b
-01101000b ^ 10111110b = 11010110b
-01101000b ^ 10111111b = 11010111b
-01101000b ^ 11000000b = 10101000b
-01101000b ^ 11000001b = 10101001b
-01101000b ^ 11000010b = 10101010b
-01101000b ^ 11000011b = 10101011b
-01101000b ^ 11000100b = 10101100b
-01101000b ^ 11000101b = 10101101b
-01101000b ^ 11000110b = 10101110b
-01101000b ^ 11000111b = 10101111b
-01101000b ^ 11001000b = 10100000b
-01101000b ^ 11001001b = 10100001b
-01101000b ^ 11001010b = 10100010b
-01101000b ^ 11001011b = 10100011b
-01101000b ^ 11001100b = 10100100b
-01101000b ^ 11001101b = 10100101b
-01101000b ^ 11001110b = 10100110b
-01101000b ^ 11001111b = 10100111b
-01101000b ^ 11010000b = 10111000b
-01101000b ^ 11010001b = 10111001b
-01101000b ^ 11010010b = 10111010b
-01101000b ^ 11010011b = 10111011b
-01101000b ^ 11010100b = 10111100b
-01101000b ^ 11010101b = 10111101b
-01101000b ^ 11010110b = 10111110b
-01101000b ^ 11010111b = 10111111b
-01101000b ^ 11011000b = 10110000b
-01101000b ^ 11011001b = 10110001b
-01101000b ^ 11011010b = 10110010b
-01101000b ^ 11011011b = 10110011b
-01101000b ^ 11011100b = 10110100b
-01101000b ^ 11011101b = 10110101b
-01101000b ^ 11011110b = 10110110b
-01101000b ^ 11011111b = 10110111b
-01101000b ^ 11100000b = 10001000b
-01101000b ^ 11100001b = 10001001b
-01101000b ^ 11100010b = 10001010b
-01101000b ^ 11100011b = 10001011b
-01101000b ^ 11100100b = 10001100b
-01101000b ^ 11100101b = 10001101b
-01101000b ^ 11100110b = 10001110b
-01101000b ^ 11100111b = 10001111b
-01101000b ^ 11101000b = 10000000b
-01101000b ^ 11101001b = 10000001b
-01101000b ^ 11101010b = 10000010b
-01101000b ^ 11101011b = 10000011b
-01101000b ^ 11101100b = 10000100b
-01101000b ^ 11101101b = 10000101b
-01101000b ^ 11101110b = 10000110b
-01101000b ^ 11101111b = 10000111b
-01101000b ^ 11110000b = 10011000b
-01101000b ^ 11110001b = 10011001b
-01101000b ^ 11110010b = 10011010b
-01101000b ^ 11110011b = 10011011b
-01101000b ^ 11110100b = 10011100b
-01101000b ^ 11110101b = 10011101b
-01101000b ^ 11110110b = 10011110b
-01101000b ^ 11110111b = 10011111b
-01101000b ^ 11111000b = 10010000b
-01101000b ^ 11111001b = 10010001b
-01101000b ^ 11111010b = 10010010b
-01101000b ^ 11111011b = 10010011b
-01101000b ^ 11111100b = 10010100b
-01101000b ^ 11111101b = 10010101b
-01101000b ^ 11111110b = 10010110b
-01101000b ^ 11111111b = 10010111b
-01101000b ^ 00000000b = 01101000b
-01101000b ^ 00000001b = 01101001b
-01101000b ^ 00000010b = 01101010b
-01101000b ^ 00000011b = 01101011b
-01101000b ^ 00000100b = 01101100b
-01101000b ^ 00000101b = 01101101b
-01101000b ^ 00000110b = 01101110b
-01101000b ^ 00000111b = 01101111b
-01101000b ^ 00001000b = 01100000b
-01101000b ^ 00001001b = 01100001b
-01101000b ^ 00001010b = 01100010b
-01101000b ^ 00001011b = 01100011b
-01101000b ^ 00001100b = 01100100b
-01101000b ^ 00001101b = 01100101b
-01101000b ^ 00001110b = 01100110b
-01101000b ^ 00001111b = 01100111b
-01101000b ^ 00010000b = 01111000b
-01101000b ^ 00010001b = 01111001b
-01101000b ^ 00010010b = 01111010b
-01101000b ^ 00010011b = 01111011b
-01101000b ^ 00010100b = 01111100b
-01101000b ^ 00010101b = 01111101b
-01101000b ^ 00010110b = 01111110b
-01101000b ^ 00010111b = 01111111b
-01101000b ^ 00011000b = 01110000b
-01101000b ^ 00011001b = 01110001b
-01101000b ^ 00011010b = 01110010b
-01101000b ^ 00011011b = 01110011b
-01101000b ^ 00011100b = 01110100b
-01101000b ^ 00011101b = 01110101b
-01101000b ^ 00011110b = 01110110b
-01101000b ^ 00011111b = 01110111b
-01101000b ^ 00100000b = 01001000b
-01101000b ^ 00100001b = 01001001b
-01101000b ^ 00100010b = 01001010b
-01101000b ^ 00100011b = 01001011b
-01101000b ^ 00100100b = 01001100b
-01101000b ^ 00100101b = 01001101b
-01101000b ^ 00100110b = 01001110b
-01101000b ^ 00100111b = 01001111b
-01101000b ^ 00101000b = 01000000b
-01101000b ^ 00101001b = 01000001b
-01101000b ^ 00101010b = 01000010b
-01101000b ^ 00101011b = 01000011b
-01101000b ^ 00101100b = 01000100b
-01101000b ^ 00101101b = 01000101b
-01101000b ^ 00101110b = 01000110b
-01101000b ^ 00101111b = 01000111b
-01101000b ^ 00110000b = 01011000b
-01101000b ^ 00110001b = 01011001b
-01101000b ^ 00110010b = 01011010b
-01101000b ^ 00110011b = 01011011b
-01101000b ^ 00110100b = 01011100b
-01101000b ^ 00110101b = 01011101b
-01101000b ^ 00110110b = 01011110b
-01101000b ^ 00110111b = 01011111b
-01101000b ^ 00111000b = 01010000b
-01101000b ^ 00111001b = 01010001b
-01101000b ^ 00111010b = 01010010b
-01101000b ^ 00111011b = 01010011b
-01101000b ^ 00111100b = 01010100b
-01101000b ^ 00111101b = 01010101b
-01101000b ^ 00111110b = 01010110b
-01101000b ^ 00111111b = 01010111b
-01101000b ^ 01000000b = 00101000b
-01101000b ^ 01000001b = 00101001b
-01101000b ^ 01000010b = 00101010b
-01101000b ^ 01000011b = 00101011b
-01101000b ^ 01000100b = 00101100b
-01101000b ^ 01000101b = 00101101b
-01101000b ^ 01000110b = 00101110b
-01101000b ^ 01000111b = 00101111b
-01101000b ^ 01001000b = 00100000b
-01101000b ^ 01001001b = 00100001b
-01101000b ^ 01001010b = 00100010b
-01101000b ^ 01001011b = 00100011b
-01101000b ^ 01001100b = 00100100b
-01101000b ^ 01001101b = 00100101b
-01101000b ^ 01001110b = 00100110b
-01101000b ^ 01001111b = 00100111b
-01101000b ^ 01010000b = 00111000b
-01101000b ^ 01010001b = 00111001b
-01101000b ^ 01010010b = 00111010b
-01101000b ^ 01010011b = 00111011b
-01101000b ^ 01010100b = 00111100b
-01101000b ^ 01010101b = 00111101b
-01101000b ^ 01010110b = 00111110b
-01101000b ^ 01010111b = 00111111b
-01101000b ^ 01011000b = 00110000b
-01101000b ^ 01011001b = 00110001b
-01101000b ^ 01011010b = 00110010b
-01101000b ^ 01011011b = 00110011b
-01101000b ^ 01011100b = 00110100b
-01101000b ^ 01011101b = 00110101b
-01101000b ^ 01011110b = 00110110b
-01101000b ^ 01011111b = 00110111b
-01101000b ^ 01100000b = 00001000b
-01101000b ^ 01100001b = 00001001b
-01101000b ^ 01100010b = 00001010b
-01101000b ^ 01100011b = 00001011b
-01101000b ^ 01100100b = 00001100b
-01101000b ^ 01100101b = 00001101b
-01101000b ^ 01100110b = 00001110b
-01101000b ^ 01100111b = 00001111b
-01101000b ^ 01101000b = 00000000b
-01101000b ^ 01101001b = 00000001b
-01101000b ^ 01101010b = 00000010b
-01101000b ^ 01101011b = 00000011b
-01101000b ^ 01101100b = 00000100b
-01101000b ^ 01101101b = 00000101b
-01101000b ^ 01101110b = 00000110b
-01101000b ^ 01101111b = 00000111b
-01101000b ^ 01110000b = 00011000b
-01101000b ^ 01110001b = 00011001b
-01101000b ^ 01110010b = 00011010b
-01101000b ^ 01110011b = 00011011b
-01101000b ^ 01110100b = 00011100b
-01101000b ^ 01110101b = 00011101b
-01101000b ^ 01110110b = 00011110b
-01101000b ^ 01110111b = 00011111b
-01101000b ^ 01111000b = 00010000b
-01101000b ^ 01111001b = 00010001b
-01101000b ^ 01111010b = 00010010b
-01101000b ^ 01111011b = 00010011b
-01101000b ^ 01111100b = 00010100b
-01101000b ^ 01111101b = 00010101b
-01101000b ^ 01111110b = 00010110b
-01101001b ^ 10000000b = 11101001b
-01101001b ^ 10000001b = 11101000b
-01101001b ^ 10000010b = 11101011b
-01101001b ^ 10000011b = 11101010b
-01101001b ^ 10000100b = 11101101b
-01101001b ^ 10000101b = 11101100b
-01101001b ^ 10000110b = 11101111b
-01101001b ^ 10000111b = 11101110b
-01101001b ^ 10001000b = 11100001b
-01101001b ^ 10001001b = 11100000b
-01101001b ^ 10001010b = 11100011b
-01101001b ^ 10001011b = 11100010b
-01101001b ^ 10001100b = 11100101b
-01101001b ^ 10001101b = 11100100b
-01101001b ^ 10001110b = 11100111b
-01101001b ^ 10001111b = 11100110b
-01101001b ^ 10010000b = 11111001b
-01101001b ^ 10010001b = 11111000b
-01101001b ^ 10010010b = 11111011b
-01101001b ^ 10010011b = 11111010b
-01101001b ^ 10010100b = 11111101b
-01101001b ^ 10010101b = 11111100b
-01101001b ^ 10010110b = 11111111b
-01101001b ^ 10010111b = 11111110b
-01101001b ^ 10011000b = 11110001b
-01101001b ^ 10011001b = 11110000b
-01101001b ^ 10011010b = 11110011b
-01101001b ^ 10011011b = 11110010b
-01101001b ^ 10011100b = 11110101b
-01101001b ^ 10011101b = 11110100b
-01101001b ^ 10011110b = 11110111b
-01101001b ^ 10011111b = 11110110b
-01101001b ^ 10100000b = 11001001b
-01101001b ^ 10100001b = 11001000b
-01101001b ^ 10100010b = 11001011b
-01101001b ^ 10100011b = 11001010b
-01101001b ^ 10100100b = 11001101b
-01101001b ^ 10100101b = 11001100b
-01101001b ^ 10100110b = 11001111b
-01101001b ^ 10100111b = 11001110b
-01101001b ^ 10101000b = 11000001b
-01101001b ^ 10101001b = 11000000b
-01101001b ^ 10101010b = 11000011b
-01101001b ^ 10101011b = 11000010b
-01101001b ^ 10101100b = 11000101b
-01101001b ^ 10101101b = 11000100b
-01101001b ^ 10101110b = 11000111b
-01101001b ^ 10101111b = 11000110b
-01101001b ^ 10110000b = 11011001b
-01101001b ^ 10110001b = 11011000b
-01101001b ^ 10110010b = 11011011b
-01101001b ^ 10110011b = 11011010b
-01101001b ^ 10110100b = 11011101b
-01101001b ^ 10110101b = 11011100b
-01101001b ^ 10110110b = 11011111b
-01101001b ^ 10110111b = 11011110b
-01101001b ^ 10111000b = 11010001b
-01101001b ^ 10111001b = 11010000b
-01101001b ^ 10111010b = 11010011b
-01101001b ^ 10111011b = 11010010b
-01101001b ^ 10111100b = 11010101b
-01101001b ^ 10111101b = 11010100b
-01101001b ^ 10111110b = 11010111b
-01101001b ^ 10111111b = 11010110b
-01101001b ^ 11000000b = 10101001b
-01101001b ^ 11000001b = 10101000b
-01101001b ^ 11000010b = 10101011b
-01101001b ^ 11000011b = 10101010b
-01101001b ^ 11000100b = 10101101b
-01101001b ^ 11000101b = 10101100b
-01101001b ^ 11000110b = 10101111b
-01101001b ^ 11000111b = 10101110b
-01101001b ^ 11001000b = 10100001b
-01101001b ^ 11001001b = 10100000b
-01101001b ^ 11001010b = 10100011b
-01101001b ^ 11001011b = 10100010b
-01101001b ^ 11001100b = 10100101b
-01101001b ^ 11001101b = 10100100b
-01101001b ^ 11001110b = 10100111b
-01101001b ^ 11001111b = 10100110b
-01101001b ^ 11010000b = 10111001b
-01101001b ^ 11010001b = 10111000b
-01101001b ^ 11010010b = 10111011b
-01101001b ^ 11010011b = 10111010b
-01101001b ^ 11010100b = 10111101b
-01101001b ^ 11010101b = 10111100b
-01101001b ^ 11010110b = 10111111b
-01101001b ^ 11010111b = 10111110b
-01101001b ^ 11011000b = 10110001b
-01101001b ^ 11011001b = 10110000b
-01101001b ^ 11011010b = 10110011b
-01101001b ^ 11011011b = 10110010b
-01101001b ^ 11011100b = 10110101b
-01101001b ^ 11011101b = 10110100b
-01101001b ^ 11011110b = 10110111b
-01101001b ^ 11011111b = 10110110b
-01101001b ^ 11100000b = 10001001b
-01101001b ^ 11100001b = 10001000b
-01101001b ^ 11100010b = 10001011b
-01101001b ^ 11100011b = 10001010b
-01101001b ^ 11100100b = 10001101b
-01101001b ^ 11100101b = 10001100b
-01101001b ^ 11100110b = 10001111b
-01101001b ^ 11100111b = 10001110b
-01101001b ^ 11101000b = 10000001b
-01101001b ^ 11101001b = 10000000b
-01101001b ^ 11101010b = 10000011b
-01101001b ^ 11101011b = 10000010b
-01101001b ^ 11101100b = 10000101b
-01101001b ^ 11101101b = 10000100b
-01101001b ^ 11101110b = 10000111b
-01101001b ^ 11101111b = 10000110b
-01101001b ^ 11110000b = 10011001b
-01101001b ^ 11110001b = 10011000b
-01101001b ^ 11110010b = 10011011b
-01101001b ^ 11110011b = 10011010b
-01101001b ^ 11110100b = 10011101b
-01101001b ^ 11110101b = 10011100b
-01101001b ^ 11110110b = 10011111b
-01101001b ^ 11110111b = 10011110b
-01101001b ^ 11111000b = 10010001b
-01101001b ^ 11111001b = 10010000b
-01101001b ^ 11111010b = 10010011b
-01101001b ^ 11111011b = 10010010b
-01101001b ^ 11111100b = 10010101b
-01101001b ^ 11111101b = 10010100b
-01101001b ^ 11111110b = 10010111b
-01101001b ^ 11111111b = 10010110b
-01101001b ^ 00000000b = 01101001b
-01101001b ^ 00000001b = 01101000b
-01101001b ^ 00000010b = 01101011b
-01101001b ^ 00000011b = 01101010b
-01101001b ^ 00000100b = 01101101b
-01101001b ^ 00000101b = 01101100b
-01101001b ^ 00000110b = 01101111b
-01101001b ^ 00000111b = 01101110b
-01101001b ^ 00001000b = 01100001b
-01101001b ^ 00001001b = 01100000b
-01101001b ^ 00001010b = 01100011b
-01101001b ^ 00001011b = 01100010b
-01101001b ^ 00001100b = 01100101b
-01101001b ^ 00001101b = 01100100b
-01101001b ^ 00001110b = 01100111b
-01101001b ^ 00001111b = 01100110b
-01101001b ^ 00010000b = 01111001b
-01101001b ^ 00010001b = 01111000b
-01101001b ^ 00010010b = 01111011b
-01101001b ^ 00010011b = 01111010b
-01101001b ^ 00010100b = 01111101b
-01101001b ^ 00010101b = 01111100b
-01101001b ^ 00010110b = 01111111b
-01101001b ^ 00010111b = 01111110b
-01101001b ^ 00011000b = 01110001b
-01101001b ^ 00011001b = 01110000b
-01101001b ^ 00011010b = 01110011b
-01101001b ^ 00011011b = 01110010b
-01101001b ^ 00011100b = 01110101b
-01101001b ^ 00011101b = 01110100b
-01101001b ^ 00011110b = 01110111b
-01101001b ^ 00011111b = 01110110b
-01101001b ^ 00100000b = 01001001b
-01101001b ^ 00100001b = 01001000b
-01101001b ^ 00100010b = 01001011b
-01101001b ^ 00100011b = 01001010b
-01101001b ^ 00100100b = 01001101b
-01101001b ^ 00100101b = 01001100b
-01101001b ^ 00100110b = 01001111b
-01101001b ^ 00100111b = 01001110b
-01101001b ^ 00101000b = 01000001b
-01101001b ^ 00101001b = 01000000b
-01101001b ^ 00101010b = 01000011b
-01101001b ^ 00101011b = 01000010b
-01101001b ^ 00101100b = 01000101b
-01101001b ^ 00101101b = 01000100b
-01101001b ^ 00101110b = 01000111b
-01101001b ^ 00101111b = 01000110b
-01101001b ^ 00110000b = 01011001b
-01101001b ^ 00110001b = 01011000b
-01101001b ^ 00110010b = 01011011b
-01101001b ^ 00110011b = 01011010b
-01101001b ^ 00110100b = 01011101b
-01101001b ^ 00110101b = 01011100b
-01101001b ^ 00110110b = 01011111b
-01101001b ^ 00110111b = 01011110b
-01101001b ^ 00111000b = 01010001b
-01101001b ^ 00111001b = 01010000b
-01101001b ^ 00111010b = 01010011b
-01101001b ^ 00111011b = 01010010b
-01101001b ^ 00111100b = 01010101b
-01101001b ^ 00111101b = 01010100b
-01101001b ^ 00111110b = 01010111b
-01101001b ^ 00111111b = 01010110b
-01101001b ^ 01000000b = 00101001b
-01101001b ^ 01000001b = 00101000b
-01101001b ^ 01000010b = 00101011b
-01101001b ^ 01000011b = 00101010b
-01101001b ^ 01000100b = 00101101b
-01101001b ^ 01000101b = 00101100b
-01101001b ^ 01000110b = 00101111b
-01101001b ^ 01000111b = 00101110b
-01101001b ^ 01001000b = 00100001b
-01101001b ^ 01001001b = 00100000b
-01101001b ^ 01001010b = 00100011b
-01101001b ^ 01001011b = 00100010b
-01101001b ^ 01001100b = 00100101b
-01101001b ^ 01001101b = 00100100b
-01101001b ^ 01001110b = 00100111b
-01101001b ^ 01001111b = 00100110b
-01101001b ^ 01010000b = 00111001b
-01101001b ^ 01010001b = 00111000b
-01101001b ^ 01010010b = 00111011b
-01101001b ^ 01010011b = 00111010b
-01101001b ^ 01010100b = 00111101b
-01101001b ^ 01010101b = 00111100b
-01101001b ^ 01010110b = 00111111b
-01101001b ^ 01010111b = 00111110b
-01101001b ^ 01011000b = 00110001b
-01101001b ^ 01011001b = 00110000b
-01101001b ^ 01011010b = 00110011b
-01101001b ^ 01011011b = 00110010b
-01101001b ^ 01011100b = 00110101b
-01101001b ^ 01011101b = 00110100b
-01101001b ^ 01011110b = 00110111b
-01101001b ^ 01011111b = 00110110b
-01101001b ^ 01100000b = 00001001b
-01101001b ^ 01100001b = 00001000b
-01101001b ^ 01100010b = 00001011b
-01101001b ^ 01100011b = 00001010b
-01101001b ^ 01100100b = 00001101b
-01101001b ^ 01100101b = 00001100b
-01101001b ^ 01100110b = 00001111b
-01101001b ^ 01100111b = 00001110b
-01101001b ^ 01101000b = 00000001b
-01101001b ^ 01101001b = 00000000b
-01101001b ^ 01101010b = 00000011b
-01101001b ^ 01101011b = 00000010b
-01101001b ^ 01101100b = 00000101b
-01101001b ^ 01101101b = 00000100b
-01101001b ^ 01101110b = 00000111b
-01101001b ^ 01101111b = 00000110b
-01101001b ^ 01110000b = 00011001b
-01101001b ^ 01110001b = 00011000b
-01101001b ^ 01110010b = 00011011b
-01101001b ^ 01110011b = 00011010b
-01101001b ^ 01110100b = 00011101b
-01101001b ^ 01110101b = 00011100b
-01101001b ^ 01110110b = 00011111b
-01101001b ^ 01110111b = 00011110b
-01101001b ^ 01111000b = 00010001b
-01101001b ^ 01111001b = 00010000b
-01101001b ^ 01111010b = 00010011b
-01101001b ^ 01111011b = 00010010b
-01101001b ^ 01111100b = 00010101b
-01101001b ^ 01111101b = 00010100b
-01101001b ^ 01111110b = 00010111b
-01101010b ^ 10000000b = 11101010b
-01101010b ^ 10000001b = 11101011b
-01101010b ^ 10000010b = 11101000b
-01101010b ^ 10000011b = 11101001b
-01101010b ^ 10000100b = 11101110b
-01101010b ^ 10000101b = 11101111b
-01101010b ^ 10000110b = 11101100b
-01101010b ^ 10000111b = 11101101b
-01101010b ^ 10001000b = 11100010b
-01101010b ^ 10001001b = 11100011b
-01101010b ^ 10001010b = 11100000b
-01101010b ^ 10001011b = 11100001b
-01101010b ^ 10001100b = 11100110b
-01101010b ^ 10001101b = 11100111b
-01101010b ^ 10001110b = 11100100b
-01101010b ^ 10001111b = 11100101b
-01101010b ^ 10010000b = 11111010b
-01101010b ^ 10010001b = 11111011b
-01101010b ^ 10010010b = 11111000b
-01101010b ^ 10010011b = 11111001b
-01101010b ^ 10010100b = 11111110b
-01101010b ^ 10010101b = 11111111b
-01101010b ^ 10010110b = 11111100b
-01101010b ^ 10010111b = 11111101b
-01101010b ^ 10011000b = 11110010b
-01101010b ^ 10011001b = 11110011b
-01101010b ^ 10011010b = 11110000b
-01101010b ^ 10011011b = 11110001b
-01101010b ^ 10011100b = 11110110b
-01101010b ^ 10011101b = 11110111b
-01101010b ^ 10011110b = 11110100b
-01101010b ^ 10011111b = 11110101b
-01101010b ^ 10100000b = 11001010b
-01101010b ^ 10100001b = 11001011b
-01101010b ^ 10100010b = 11001000b
-01101010b ^ 10100011b = 11001001b
-01101010b ^ 10100100b = 11001110b
-01101010b ^ 10100101b = 11001111b
-01101010b ^ 10100110b = 11001100b
-01101010b ^ 10100111b = 11001101b
-01101010b ^ 10101000b = 11000010b
-01101010b ^ 10101001b = 11000011b
-01101010b ^ 10101010b = 11000000b
-01101010b ^ 10101011b = 11000001b
-01101010b ^ 10101100b = 11000110b
-01101010b ^ 10101101b = 11000111b
-01101010b ^ 10101110b = 11000100b
-01101010b ^ 10101111b = 11000101b
-01101010b ^ 10110000b = 11011010b
-01101010b ^ 10110001b = 11011011b
-01101010b ^ 10110010b = 11011000b
-01101010b ^ 10110011b = 11011001b
-01101010b ^ 10110100b = 11011110b
-01101010b ^ 10110101b = 11011111b
-01101010b ^ 10110110b = 11011100b
-01101010b ^ 10110111b = 11011101b
-01101010b ^ 10111000b = 11010010b
-01101010b ^ 10111001b = 11010011b
-01101010b ^ 10111010b = 11010000b
-01101010b ^ 10111011b = 11010001b
-01101010b ^ 10111100b = 11010110b
-01101010b ^ 10111101b = 11010111b
-01101010b ^ 10111110b = 11010100b
-01101010b ^ 10111111b = 11010101b
-01101010b ^ 11000000b = 10101010b
-01101010b ^ 11000001b = 10101011b
-01101010b ^ 11000010b = 10101000b
-01101010b ^ 11000011b = 10101001b
-01101010b ^ 11000100b = 10101110b
-01101010b ^ 11000101b = 10101111b
-01101010b ^ 11000110b = 10101100b
-01101010b ^ 11000111b = 10101101b
-01101010b ^ 11001000b = 10100010b
-01101010b ^ 11001001b = 10100011b
-01101010b ^ 11001010b = 10100000b
-01101010b ^ 11001011b = 10100001b
-01101010b ^ 11001100b = 10100110b
-01101010b ^ 11001101b = 10100111b
-01101010b ^ 11001110b = 10100100b
-01101010b ^ 11001111b = 10100101b
-01101010b ^ 11010000b = 10111010b
-01101010b ^ 11010001b = 10111011b
-01101010b ^ 11010010b = 10111000b
-01101010b ^ 11010011b = 10111001b
-01101010b ^ 11010100b = 10111110b
-01101010b ^ 11010101b = 10111111b
-01101010b ^ 11010110b = 10111100b
-01101010b ^ 11010111b = 10111101b
-01101010b ^ 11011000b = 10110010b
-01101010b ^ 11011001b = 10110011b
-01101010b ^ 11011010b = 10110000b
-01101010b ^ 11011011b = 10110001b
-01101010b ^ 11011100b = 10110110b
-01101010b ^ 11011101b = 10110111b
-01101010b ^ 11011110b = 10110100b
-01101010b ^ 11011111b = 10110101b
-01101010b ^ 11100000b = 10001010b
-01101010b ^ 11100001b = 10001011b
-01101010b ^ 11100010b = 10001000b
-01101010b ^ 11100011b = 10001001b
-01101010b ^ 11100100b = 10001110b
-01101010b ^ 11100101b = 10001111b
-01101010b ^ 11100110b = 10001100b
-01101010b ^ 11100111b = 10001101b
-01101010b ^ 11101000b = 10000010b
-01101010b ^ 11101001b = 10000011b
-01101010b ^ 11101010b = 10000000b
-01101010b ^ 11101011b = 10000001b
-01101010b ^ 11101100b = 10000110b
-01101010b ^ 11101101b = 10000111b
-01101010b ^ 11101110b = 10000100b
-01101010b ^ 11101111b = 10000101b
-01101010b ^ 11110000b = 10011010b
-01101010b ^ 11110001b = 10011011b
-01101010b ^ 11110010b = 10011000b
-01101010b ^ 11110011b = 10011001b
-01101010b ^ 11110100b = 10011110b
-01101010b ^ 11110101b = 10011111b
-01101010b ^ 11110110b = 10011100b
-01101010b ^ 11110111b = 10011101b
-01101010b ^ 11111000b = 10010010b
-01101010b ^ 11111001b = 10010011b
-01101010b ^ 11111010b = 10010000b
-01101010b ^ 11111011b = 10010001b
-01101010b ^ 11111100b = 10010110b
-01101010b ^ 11111101b = 10010111b
-01101010b ^ 11111110b = 10010100b
-01101010b ^ 11111111b = 10010101b
-01101010b ^ 00000000b = 01101010b
-01101010b ^ 00000001b = 01101011b
-01101010b ^ 00000010b = 01101000b
-01101010b ^ 00000011b = 01101001b
-01101010b ^ 00000100b = 01101110b
-01101010b ^ 00000101b = 01101111b
-01101010b ^ 00000110b = 01101100b
-01101010b ^ 00000111b = 01101101b
-01101010b ^ 00001000b = 01100010b
-01101010b ^ 00001001b = 01100011b
-01101010b ^ 00001010b = 01100000b
-01101010b ^ 00001011b = 01100001b
-01101010b ^ 00001100b = 01100110b
-01101010b ^ 00001101b = 01100111b
-01101010b ^ 00001110b = 01100100b
-01101010b ^ 00001111b = 01100101b
-01101010b ^ 00010000b = 01111010b
-01101010b ^ 00010001b = 01111011b
-01101010b ^ 00010010b = 01111000b
-01101010b ^ 00010011b = 01111001b
-01101010b ^ 00010100b = 01111110b
-01101010b ^ 00010101b = 01111111b
-01101010b ^ 00010110b = 01111100b
-01101010b ^ 00010111b = 01111101b
-01101010b ^ 00011000b = 01110010b
-01101010b ^ 00011001b = 01110011b
-01101010b ^ 00011010b = 01110000b
-01101010b ^ 00011011b = 01110001b
-01101010b ^ 00011100b = 01110110b
-01101010b ^ 00011101b = 01110111b
-01101010b ^ 00011110b = 01110100b
-01101010b ^ 00011111b = 01110101b
-01101010b ^ 00100000b = 01001010b
-01101010b ^ 00100001b = 01001011b
-01101010b ^ 00100010b = 01001000b
-01101010b ^ 00100011b = 01001001b
-01101010b ^ 00100100b = 01001110b
-01101010b ^ 00100101b = 01001111b
-01101010b ^ 00100110b = 01001100b
-01101010b ^ 00100111b = 01001101b
-01101010b ^ 00101000b = 01000010b
-01101010b ^ 00101001b = 01000011b
-01101010b ^ 00101010b = 01000000b
-01101010b ^ 00101011b = 01000001b
-01101010b ^ 00101100b = 01000110b
-01101010b ^ 00101101b = 01000111b
-01101010b ^ 00101110b = 01000100b
-01101010b ^ 00101111b = 01000101b
-01101010b ^ 00110000b = 01011010b
-01101010b ^ 00110001b = 01011011b
-01101010b ^ 00110010b = 01011000b
-01101010b ^ 00110011b = 01011001b
-01101010b ^ 00110100b = 01011110b
-01101010b ^ 00110101b = 01011111b
-01101010b ^ 00110110b = 01011100b
-01101010b ^ 00110111b = 01011101b
-01101010b ^ 00111000b = 01010010b
-01101010b ^ 00111001b = 01010011b
-01101010b ^ 00111010b = 01010000b
-01101010b ^ 00111011b = 01010001b
-01101010b ^ 00111100b = 01010110b
-01101010b ^ 00111101b = 01010111b
-01101010b ^ 00111110b = 01010100b
-01101010b ^ 00111111b = 01010101b
-01101010b ^ 01000000b = 00101010b
-01101010b ^ 01000001b = 00101011b
-01101010b ^ 01000010b = 00101000b
-01101010b ^ 01000011b = 00101001b
-01101010b ^ 01000100b = 00101110b
-01101010b ^ 01000101b = 00101111b
-01101010b ^ 01000110b = 00101100b
-01101010b ^ 01000111b = 00101101b
-01101010b ^ 01001000b = 00100010b
-01101010b ^ 01001001b = 00100011b
-01101010b ^ 01001010b = 00100000b
-01101010b ^ 01001011b = 00100001b
-01101010b ^ 01001100b = 00100110b
-01101010b ^ 01001101b = 00100111b
-01101010b ^ 01001110b = 00100100b
-01101010b ^ 01001111b = 00100101b
-01101010b ^ 01010000b = 00111010b
-01101010b ^ 01010001b = 00111011b
-01101010b ^ 01010010b = 00111000b
-01101010b ^ 01010011b = 00111001b
-01101010b ^ 01010100b = 00111110b
-01101010b ^ 01010101b = 00111111b
-01101010b ^ 01010110b = 00111100b
-01101010b ^ 01010111b = 00111101b
-01101010b ^ 01011000b = 00110010b
-01101010b ^ 01011001b = 00110011b
-01101010b ^ 01011010b = 00110000b
-01101010b ^ 01011011b = 00110001b
-01101010b ^ 01011100b = 00110110b
-01101010b ^ 01011101b = 00110111b
-01101010b ^ 01011110b = 00110100b
-01101010b ^ 01011111b = 00110101b
-01101010b ^ 01100000b = 00001010b
-01101010b ^ 01100001b = 00001011b
-01101010b ^ 01100010b = 00001000b
-01101010b ^ 01100011b = 00001001b
-01101010b ^ 01100100b = 00001110b
-01101010b ^ 01100101b = 00001111b
-01101010b ^ 01100110b = 00001100b
-01101010b ^ 01100111b = 00001101b
-01101010b ^ 01101000b = 00000010b
-01101010b ^ 01101001b = 00000011b
-01101010b ^ 01101010b = 00000000b
-01101010b ^ 01101011b = 00000001b
-01101010b ^ 01101100b = 00000110b
-01101010b ^ 01101101b = 00000111b
-01101010b ^ 01101110b = 00000100b
-01101010b ^ 01101111b = 00000101b
-01101010b ^ 01110000b = 00011010b
-01101010b ^ 01110001b = 00011011b
-01101010b ^ 01110010b = 00011000b
-01101010b ^ 01110011b = 00011001b
-01101010b ^ 01110100b = 00011110b
-01101010b ^ 01110101b = 00011111b
-01101010b ^ 01110110b = 00011100b
-01101010b ^ 01110111b = 00011101b
-01101010b ^ 01111000b = 00010010b
-01101010b ^ 01111001b = 00010011b
-01101010b ^ 01111010b = 00010000b
-01101010b ^ 01111011b = 00010001b
-01101010b ^ 01111100b = 00010110b
-01101010b ^ 01111101b = 00010111b
-01101010b ^ 01111110b = 00010100b
-01101011b ^ 10000000b = 11101011b
-01101011b ^ 10000001b = 11101010b
-01101011b ^ 10000010b = 11101001b
-01101011b ^ 10000011b = 11101000b
-01101011b ^ 10000100b = 11101111b
-01101011b ^ 10000101b = 11101110b
-01101011b ^ 10000110b = 11101101b
-01101011b ^ 10000111b = 11101100b
-01101011b ^ 10001000b = 11100011b
-01101011b ^ 10001001b = 11100010b
-01101011b ^ 10001010b = 11100001b
-01101011b ^ 10001011b = 11100000b
-01101011b ^ 10001100b = 11100111b
-01101011b ^ 10001101b = 11100110b
-01101011b ^ 10001110b = 11100101b
-01101011b ^ 10001111b = 11100100b
-01101011b ^ 10010000b = 11111011b
-01101011b ^ 10010001b = 11111010b
-01101011b ^ 10010010b = 11111001b
-01101011b ^ 10010011b = 11111000b
-01101011b ^ 10010100b = 11111111b
-01101011b ^ 10010101b = 11111110b
-01101011b ^ 10010110b = 11111101b
-01101011b ^ 10010111b = 11111100b
-01101011b ^ 10011000b = 11110011b
-01101011b ^ 10011001b = 11110010b
-01101011b ^ 10011010b = 11110001b
-01101011b ^ 10011011b = 11110000b
-01101011b ^ 10011100b = 11110111b
-01101011b ^ 10011101b = 11110110b
-01101011b ^ 10011110b = 11110101b
-01101011b ^ 10011111b = 11110100b
-01101011b ^ 10100000b = 11001011b
-01101011b ^ 10100001b = 11001010b
-01101011b ^ 10100010b = 11001001b
-01101011b ^ 10100011b = 11001000b
-01101011b ^ 10100100b = 11001111b
-01101011b ^ 10100101b = 11001110b
-01101011b ^ 10100110b = 11001101b
-01101011b ^ 10100111b = 11001100b
-01101011b ^ 10101000b = 11000011b
-01101011b ^ 10101001b = 11000010b
-01101011b ^ 10101010b = 11000001b
-01101011b ^ 10101011b = 11000000b
-01101011b ^ 10101100b = 11000111b
-01101011b ^ 10101101b = 11000110b
-01101011b ^ 10101110b = 11000101b
-01101011b ^ 10101111b = 11000100b
-01101011b ^ 10110000b = 11011011b
-01101011b ^ 10110001b = 11011010b
-01101011b ^ 10110010b = 11011001b
-01101011b ^ 10110011b = 11011000b
-01101011b ^ 10110100b = 11011111b
-01101011b ^ 10110101b = 11011110b
-01101011b ^ 10110110b = 11011101b
-01101011b ^ 10110111b = 11011100b
-01101011b ^ 10111000b = 11010011b
-01101011b ^ 10111001b = 11010010b
-01101011b ^ 10111010b = 11010001b
-01101011b ^ 10111011b = 11010000b
-01101011b ^ 10111100b = 11010111b
-01101011b ^ 10111101b = 11010110b
-01101011b ^ 10111110b = 11010101b
-01101011b ^ 10111111b = 11010100b
-01101011b ^ 11000000b = 10101011b
-01101011b ^ 11000001b = 10101010b
-01101011b ^ 11000010b = 10101001b
-01101011b ^ 11000011b = 10101000b
-01101011b ^ 11000100b = 10101111b
-01101011b ^ 11000101b = 10101110b
-01101011b ^ 11000110b = 10101101b
-01101011b ^ 11000111b = 10101100b
-01101011b ^ 11001000b = 10100011b
-01101011b ^ 11001001b = 10100010b
-01101011b ^ 11001010b = 10100001b
-01101011b ^ 11001011b = 10100000b
-01101011b ^ 11001100b = 10100111b
-01101011b ^ 11001101b = 10100110b
-01101011b ^ 11001110b = 10100101b
-01101011b ^ 11001111b = 10100100b
-01101011b ^ 11010000b = 10111011b
-01101011b ^ 11010001b = 10111010b
-01101011b ^ 11010010b = 10111001b
-01101011b ^ 11010011b = 10111000b
-01101011b ^ 11010100b = 10111111b
-01101011b ^ 11010101b = 10111110b
-01101011b ^ 11010110b = 10111101b
-01101011b ^ 11010111b = 10111100b
-01101011b ^ 11011000b = 10110011b
-01101011b ^ 11011001b = 10110010b
-01101011b ^ 11011010b = 10110001b
-01101011b ^ 11011011b = 10110000b
-01101011b ^ 11011100b = 10110111b
-01101011b ^ 11011101b = 10110110b
-01101011b ^ 11011110b = 10110101b
-01101011b ^ 11011111b = 10110100b
-01101011b ^ 11100000b = 10001011b
-01101011b ^ 11100001b = 10001010b
-01101011b ^ 11100010b = 10001001b
-01101011b ^ 11100011b = 10001000b
-01101011b ^ 11100100b = 10001111b
-01101011b ^ 11100101b = 10001110b
-01101011b ^ 11100110b = 10001101b
-01101011b ^ 11100111b = 10001100b
-01101011b ^ 11101000b = 10000011b
-01101011b ^ 11101001b = 10000010b
-01101011b ^ 11101010b = 10000001b
-01101011b ^ 11101011b = 10000000b
-01101011b ^ 11101100b = 10000111b
-01101011b ^ 11101101b = 10000110b
-01101011b ^ 11101110b = 10000101b
-01101011b ^ 11101111b = 10000100b
-01101011b ^ 11110000b = 10011011b
-01101011b ^ 11110001b = 10011010b
-01101011b ^ 11110010b = 10011001b
-01101011b ^ 11110011b = 10011000b
-01101011b ^ 11110100b = 10011111b
-01101011b ^ 11110101b = 10011110b
-01101011b ^ 11110110b = 10011101b
-01101011b ^ 11110111b = 10011100b
-01101011b ^ 11111000b = 10010011b
-01101011b ^ 11111001b = 10010010b
-01101011b ^ 11111010b = 10010001b
-01101011b ^ 11111011b = 10010000b
-01101011b ^ 11111100b = 10010111b
-01101011b ^ 11111101b = 10010110b
-01101011b ^ 11111110b = 10010101b
-01101011b ^ 11111111b = 10010100b
-01101011b ^ 00000000b = 01101011b
-01101011b ^ 00000001b = 01101010b
-01101011b ^ 00000010b = 01101001b
-01101011b ^ 00000011b = 01101000b
-01101011b ^ 00000100b = 01101111b
-01101011b ^ 00000101b = 01101110b
-01101011b ^ 00000110b = 01101101b
-01101011b ^ 00000111b = 01101100b
-01101011b ^ 00001000b = 01100011b
-01101011b ^ 00001001b = 01100010b
-01101011b ^ 00001010b = 01100001b
-01101011b ^ 00001011b = 01100000b
-01101011b ^ 00001100b = 01100111b
-01101011b ^ 00001101b = 01100110b
-01101011b ^ 00001110b = 01100101b
-01101011b ^ 00001111b = 01100100b
-01101011b ^ 00010000b = 01111011b
-01101011b ^ 00010001b = 01111010b
-01101011b ^ 00010010b = 01111001b
-01101011b ^ 00010011b = 01111000b
-01101011b ^ 00010100b = 01111111b
-01101011b ^ 00010101b = 01111110b
-01101011b ^ 00010110b = 01111101b
-01101011b ^ 00010111b = 01111100b
-01101011b ^ 00011000b = 01110011b
-01101011b ^ 00011001b = 01110010b
-01101011b ^ 00011010b = 01110001b
-01101011b ^ 00011011b = 01110000b
-01101011b ^ 00011100b = 01110111b
-01101011b ^ 00011101b = 01110110b
-01101011b ^ 00011110b = 01110101b
-01101011b ^ 00011111b = 01110100b
-01101011b ^ 00100000b = 01001011b
-01101011b ^ 00100001b = 01001010b
-01101011b ^ 00100010b = 01001001b
-01101011b ^ 00100011b = 01001000b
-01101011b ^ 00100100b = 01001111b
-01101011b ^ 00100101b = 01001110b
-01101011b ^ 00100110b = 01001101b
-01101011b ^ 00100111b = 01001100b
-01101011b ^ 00101000b = 01000011b
-01101011b ^ 00101001b = 01000010b
-01101011b ^ 00101010b = 01000001b
-01101011b ^ 00101011b = 01000000b
-01101011b ^ 00101100b = 01000111b
-01101011b ^ 00101101b = 01000110b
-01101011b ^ 00101110b = 01000101b
-01101011b ^ 00101111b = 01000100b
-01101011b ^ 00110000b = 01011011b
-01101011b ^ 00110001b = 01011010b
-01101011b ^ 00110010b = 01011001b
-01101011b ^ 00110011b = 01011000b
-01101011b ^ 00110100b = 01011111b
-01101011b ^ 00110101b = 01011110b
-01101011b ^ 00110110b = 01011101b
-01101011b ^ 00110111b = 01011100b
-01101011b ^ 00111000b = 01010011b
-01101011b ^ 00111001b = 01010010b
-01101011b ^ 00111010b = 01010001b
-01101011b ^ 00111011b = 01010000b
-01101011b ^ 00111100b = 01010111b
-01101011b ^ 00111101b = 01010110b
-01101011b ^ 00111110b = 01010101b
-01101011b ^ 00111111b = 01010100b
-01101011b ^ 01000000b = 00101011b
-01101011b ^ 01000001b = 00101010b
-01101011b ^ 01000010b = 00101001b
-01101011b ^ 01000011b = 00101000b
-01101011b ^ 01000100b = 00101111b
-01101011b ^ 01000101b = 00101110b
-01101011b ^ 01000110b = 00101101b
-01101011b ^ 01000111b = 00101100b
-01101011b ^ 01001000b = 00100011b
-01101011b ^ 01001001b = 00100010b
-01101011b ^ 01001010b = 00100001b
-01101011b ^ 01001011b = 00100000b
-01101011b ^ 01001100b = 00100111b
-01101011b ^ 01001101b = 00100110b
-01101011b ^ 01001110b = 00100101b
-01101011b ^ 01001111b = 00100100b
-01101011b ^ 01010000b = 00111011b
-01101011b ^ 01010001b = 00111010b
-01101011b ^ 01010010b = 00111001b
-01101011b ^ 01010011b = 00111000b
-01101011b ^ 01010100b = 00111111b
-01101011b ^ 01010101b = 00111110b
-01101011b ^ 01010110b = 00111101b
-01101011b ^ 01010111b = 00111100b
-01101011b ^ 01011000b = 00110011b
-01101011b ^ 01011001b = 00110010b
-01101011b ^ 01011010b = 00110001b
-01101011b ^ 01011011b = 00110000b
-01101011b ^ 01011100b = 00110111b
-01101011b ^ 01011101b = 00110110b
-01101011b ^ 01011110b = 00110101b
-01101011b ^ 01011111b = 00110100b
-01101011b ^ 01100000b = 00001011b
-01101011b ^ 01100001b = 00001010b
-01101011b ^ 01100010b = 00001001b
-01101011b ^ 01100011b = 00001000b
-01101011b ^ 01100100b = 00001111b
-01101011b ^ 01100101b = 00001110b
-01101011b ^ 01100110b = 00001101b
-01101011b ^ 01100111b = 00001100b
-01101011b ^ 01101000b = 00000011b
-01101011b ^ 01101001b = 00000010b
-01101011b ^ 01101010b = 00000001b
-01101011b ^ 01101011b = 00000000b
-01101011b ^ 01101100b = 00000111b
-01101011b ^ 01101101b = 00000110b
-01101011b ^ 01101110b = 00000101b
-01101011b ^ 01101111b = 00000100b
-01101011b ^ 01110000b = 00011011b
-01101011b ^ 01110001b = 00011010b
-01101011b ^ 01110010b = 00011001b
-01101011b ^ 01110011b = 00011000b
-01101011b ^ 01110100b = 00011111b
-01101011b ^ 01110101b = 00011110b
-01101011b ^ 01110110b = 00011101b
-01101011b ^ 01110111b = 00011100b
-01101011b ^ 01111000b = 00010011b
-01101011b ^ 01111001b = 00010010b
-01101011b ^ 01111010b = 00010001b
-01101011b ^ 01111011b = 00010000b
-01101011b ^ 01111100b = 00010111b
-01101011b ^ 01111101b = 00010110b
-01101011b ^ 01111110b = 00010101b
-01101100b ^ 10000000b = 11101100b
-01101100b ^ 10000001b = 11101101b
-01101100b ^ 10000010b = 11101110b
-01101100b ^ 10000011b = 11101111b
-01101100b ^ 10000100b = 11101000b
-01101100b ^ 10000101b = 11101001b
-01101100b ^ 10000110b = 11101010b
-01101100b ^ 10000111b = 11101011b
-01101100b ^ 10001000b = 11100100b
-01101100b ^ 10001001b = 11100101b
-01101100b ^ 10001010b = 11100110b
-01101100b ^ 10001011b = 11100111b
-01101100b ^ 10001100b = 11100000b
-01101100b ^ 10001101b = 11100001b
-01101100b ^ 10001110b = 11100010b
-01101100b ^ 10001111b = 11100011b
-01101100b ^ 10010000b = 11111100b
-01101100b ^ 10010001b = 11111101b
-01101100b ^ 10010010b = 11111110b
-01101100b ^ 10010011b = 11111111b
-01101100b ^ 10010100b = 11111000b
-01101100b ^ 10010101b = 11111001b
-01101100b ^ 10010110b = 11111010b
-01101100b ^ 10010111b = 11111011b
-01101100b ^ 10011000b = 11110100b
-01101100b ^ 10011001b = 11110101b
-01101100b ^ 10011010b = 11110110b
-01101100b ^ 10011011b = 11110111b
-01101100b ^ 10011100b = 11110000b
-01101100b ^ 10011101b = 11110001b
-01101100b ^ 10011110b = 11110010b
-01101100b ^ 10011111b = 11110011b
-01101100b ^ 10100000b = 11001100b
-01101100b ^ 10100001b = 11001101b
-01101100b ^ 10100010b = 11001110b
-01101100b ^ 10100011b = 11001111b
-01101100b ^ 10100100b = 11001000b
-01101100b ^ 10100101b = 11001001b
-01101100b ^ 10100110b = 11001010b
-01101100b ^ 10100111b = 11001011b
-01101100b ^ 10101000b = 11000100b
-01101100b ^ 10101001b = 11000101b
-01101100b ^ 10101010b = 11000110b
-01101100b ^ 10101011b = 11000111b
-01101100b ^ 10101100b = 11000000b
-01101100b ^ 10101101b = 11000001b
-01101100b ^ 10101110b = 11000010b
-01101100b ^ 10101111b = 11000011b
-01101100b ^ 10110000b = 11011100b
-01101100b ^ 10110001b = 11011101b
-01101100b ^ 10110010b = 11011110b
-01101100b ^ 10110011b = 11011111b
-01101100b ^ 10110100b = 11011000b
-01101100b ^ 10110101b = 11011001b
-01101100b ^ 10110110b = 11011010b
-01101100b ^ 10110111b = 11011011b
-01101100b ^ 10111000b = 11010100b
-01101100b ^ 10111001b = 11010101b
-01101100b ^ 10111010b = 11010110b
-01101100b ^ 10111011b = 11010111b
-01101100b ^ 10111100b = 11010000b
-01101100b ^ 10111101b = 11010001b
-01101100b ^ 10111110b = 11010010b
-01101100b ^ 10111111b = 11010011b
-01101100b ^ 11000000b = 10101100b
-01101100b ^ 11000001b = 10101101b
-01101100b ^ 11000010b = 10101110b
-01101100b ^ 11000011b = 10101111b
-01101100b ^ 11000100b = 10101000b
-01101100b ^ 11000101b = 10101001b
-01101100b ^ 11000110b = 10101010b
-01101100b ^ 11000111b = 10101011b
-01101100b ^ 11001000b = 10100100b
-01101100b ^ 11001001b = 10100101b
-01101100b ^ 11001010b = 10100110b
-01101100b ^ 11001011b = 10100111b
-01101100b ^ 11001100b = 10100000b
-01101100b ^ 11001101b = 10100001b
-01101100b ^ 11001110b = 10100010b
-01101100b ^ 11001111b = 10100011b
-01101100b ^ 11010000b = 10111100b
-01101100b ^ 11010001b = 10111101b
-01101100b ^ 11010010b = 10111110b
-01101100b ^ 11010011b = 10111111b
-01101100b ^ 11010100b = 10111000b
-01101100b ^ 11010101b = 10111001b
-01101100b ^ 11010110b = 10111010b
-01101100b ^ 11010111b = 10111011b
-01101100b ^ 11011000b = 10110100b
-01101100b ^ 11011001b = 10110101b
-01101100b ^ 11011010b = 10110110b
-01101100b ^ 11011011b = 10110111b
-01101100b ^ 11011100b = 10110000b
-01101100b ^ 11011101b = 10110001b
-01101100b ^ 11011110b = 10110010b
-01101100b ^ 11011111b = 10110011b
-01101100b ^ 11100000b = 10001100b
-01101100b ^ 11100001b = 10001101b
-01101100b ^ 11100010b = 10001110b
-01101100b ^ 11100011b = 10001111b
-01101100b ^ 11100100b = 10001000b
-01101100b ^ 11100101b = 10001001b
-01101100b ^ 11100110b = 10001010b
-01101100b ^ 11100111b = 10001011b
-01101100b ^ 11101000b = 10000100b
-01101100b ^ 11101001b = 10000101b
-01101100b ^ 11101010b = 10000110b
-01101100b ^ 11101011b = 10000111b
-01101100b ^ 11101100b = 10000000b
-01101100b ^ 11101101b = 10000001b
-01101100b ^ 11101110b = 10000010b
-01101100b ^ 11101111b = 10000011b
-01101100b ^ 11110000b = 10011100b
-01101100b ^ 11110001b = 10011101b
-01101100b ^ 11110010b = 10011110b
-01101100b ^ 11110011b = 10011111b
-01101100b ^ 11110100b = 10011000b
-01101100b ^ 11110101b = 10011001b
-01101100b ^ 11110110b = 10011010b
-01101100b ^ 11110111b = 10011011b
-01101100b ^ 11111000b = 10010100b
-01101100b ^ 11111001b = 10010101b
-01101100b ^ 11111010b = 10010110b
-01101100b ^ 11111011b = 10010111b
-01101100b ^ 11111100b = 10010000b
-01101100b ^ 11111101b = 10010001b
-01101100b ^ 11111110b = 10010010b
-01101100b ^ 11111111b = 10010011b
-01101100b ^ 00000000b = 01101100b
-01101100b ^ 00000001b = 01101101b
-01101100b ^ 00000010b = 01101110b
-01101100b ^ 00000011b = 01101111b
-01101100b ^ 00000100b = 01101000b
-01101100b ^ 00000101b = 01101001b
-01101100b ^ 00000110b = 01101010b
-01101100b ^ 00000111b = 01101011b
-01101100b ^ 00001000b = 01100100b
-01101100b ^ 00001001b = 01100101b
-01101100b ^ 00001010b = 01100110b
-01101100b ^ 00001011b = 01100111b
-01101100b ^ 00001100b = 01100000b
-01101100b ^ 00001101b = 01100001b
-01101100b ^ 00001110b = 01100010b
-01101100b ^ 00001111b = 01100011b
-01101100b ^ 00010000b = 01111100b
-01101100b ^ 00010001b = 01111101b
-01101100b ^ 00010010b = 01111110b
-01101100b ^ 00010011b = 01111111b
-01101100b ^ 00010100b = 01111000b
-01101100b ^ 00010101b = 01111001b
-01101100b ^ 00010110b = 01111010b
-01101100b ^ 00010111b = 01111011b
-01101100b ^ 00011000b = 01110100b
-01101100b ^ 00011001b = 01110101b
-01101100b ^ 00011010b = 01110110b
-01101100b ^ 00011011b = 01110111b
-01101100b ^ 00011100b = 01110000b
-01101100b ^ 00011101b = 01110001b
-01101100b ^ 00011110b = 01110010b
-01101100b ^ 00011111b = 01110011b
-01101100b ^ 00100000b = 01001100b
-01101100b ^ 00100001b = 01001101b
-01101100b ^ 00100010b = 01001110b
-01101100b ^ 00100011b = 01001111b
-01101100b ^ 00100100b = 01001000b
-01101100b ^ 00100101b = 01001001b
-01101100b ^ 00100110b = 01001010b
-01101100b ^ 00100111b = 01001011b
-01101100b ^ 00101000b = 01000100b
-01101100b ^ 00101001b = 01000101b
-01101100b ^ 00101010b = 01000110b
-01101100b ^ 00101011b = 01000111b
-01101100b ^ 00101100b = 01000000b
-01101100b ^ 00101101b = 01000001b
-01101100b ^ 00101110b = 01000010b
-01101100b ^ 00101111b = 01000011b
-01101100b ^ 00110000b = 01011100b
-01101100b ^ 00110001b = 01011101b
-01101100b ^ 00110010b = 01011110b
-01101100b ^ 00110011b = 01011111b
-01101100b ^ 00110100b = 01011000b
-01101100b ^ 00110101b = 01011001b
-01101100b ^ 00110110b = 01011010b
-01101100b ^ 00110111b = 01011011b
-01101100b ^ 00111000b = 01010100b
-01101100b ^ 00111001b = 01010101b
-01101100b ^ 00111010b = 01010110b
-01101100b ^ 00111011b = 01010111b
-01101100b ^ 00111100b = 01010000b
-01101100b ^ 00111101b = 01010001b
-01101100b ^ 00111110b = 01010010b
-01101100b ^ 00111111b = 01010011b
-01101100b ^ 01000000b = 00101100b
-01101100b ^ 01000001b = 00101101b
-01101100b ^ 01000010b = 00101110b
-01101100b ^ 01000011b = 00101111b
-01101100b ^ 01000100b = 00101000b
-01101100b ^ 01000101b = 00101001b
-01101100b ^ 01000110b = 00101010b
-01101100b ^ 01000111b = 00101011b
-01101100b ^ 01001000b = 00100100b
-01101100b ^ 01001001b = 00100101b
-01101100b ^ 01001010b = 00100110b
-01101100b ^ 01001011b = 00100111b
-01101100b ^ 01001100b = 00100000b
-01101100b ^ 01001101b = 00100001b
-01101100b ^ 01001110b = 00100010b
-01101100b ^ 01001111b = 00100011b
-01101100b ^ 01010000b = 00111100b
-01101100b ^ 01010001b = 00111101b
-01101100b ^ 01010010b = 00111110b
-01101100b ^ 01010011b = 00111111b
-01101100b ^ 01010100b = 00111000b
-01101100b ^ 01010101b = 00111001b
-01101100b ^ 01010110b = 00111010b
-01101100b ^ 01010111b = 00111011b
-01101100b ^ 01011000b = 00110100b
-01101100b ^ 01011001b = 00110101b
-01101100b ^ 01011010b = 00110110b
-01101100b ^ 01011011b = 00110111b
-01101100b ^ 01011100b = 00110000b
-01101100b ^ 01011101b = 00110001b
-01101100b ^ 01011110b = 00110010b
-01101100b ^ 01011111b = 00110011b
-01101100b ^ 01100000b = 00001100b
-01101100b ^ 01100001b = 00001101b
-01101100b ^ 01100010b = 00001110b
-01101100b ^ 01100011b = 00001111b
-01101100b ^ 01100100b = 00001000b
-01101100b ^ 01100101b = 00001001b
-01101100b ^ 01100110b = 00001010b
-01101100b ^ 01100111b = 00001011b
-01101100b ^ 01101000b = 00000100b
-01101100b ^ 01101001b = 00000101b
-01101100b ^ 01101010b = 00000110b
-01101100b ^ 01101011b = 00000111b
-01101100b ^ 01101100b = 00000000b
-01101100b ^ 01101101b = 00000001b
-01101100b ^ 01101110b = 00000010b
-01101100b ^ 01101111b = 00000011b
-01101100b ^ 01110000b = 00011100b
-01101100b ^ 01110001b = 00011101b
-01101100b ^ 01110010b = 00011110b
-01101100b ^ 01110011b = 00011111b
-01101100b ^ 01110100b = 00011000b
-01101100b ^ 01110101b = 00011001b
-01101100b ^ 01110110b = 00011010b
-01101100b ^ 01110111b = 00011011b
-01101100b ^ 01111000b = 00010100b
-01101100b ^ 01111001b = 00010101b
-01101100b ^ 01111010b = 00010110b
-01101100b ^ 01111011b = 00010111b
-01101100b ^ 01111100b = 00010000b
-01101100b ^ 01111101b = 00010001b
-01101100b ^ 01111110b = 00010010b
-01101101b ^ 10000000b = 11101101b
-01101101b ^ 10000001b = 11101100b
-01101101b ^ 10000010b = 11101111b
-01101101b ^ 10000011b = 11101110b
-01101101b ^ 10000100b = 11101001b
-01101101b ^ 10000101b = 11101000b
-01101101b ^ 10000110b = 11101011b
-01101101b ^ 10000111b = 11101010b
-01101101b ^ 10001000b = 11100101b
-01101101b ^ 10001001b = 11100100b
-01101101b ^ 10001010b = 11100111b
-01101101b ^ 10001011b = 11100110b
-01101101b ^ 10001100b = 11100001b
-01101101b ^ 10001101b = 11100000b
-01101101b ^ 10001110b = 11100011b
-01101101b ^ 10001111b = 11100010b
-01101101b ^ 10010000b = 11111101b
-01101101b ^ 10010001b = 11111100b
-01101101b ^ 10010010b = 11111111b
-01101101b ^ 10010011b = 11111110b
-01101101b ^ 10010100b = 11111001b
-01101101b ^ 10010101b = 11111000b
-01101101b ^ 10010110b = 11111011b
-01101101b ^ 10010111b = 11111010b
-01101101b ^ 10011000b = 11110101b
-01101101b ^ 10011001b = 11110100b
-01101101b ^ 10011010b = 11110111b
-01101101b ^ 10011011b = 11110110b
-01101101b ^ 10011100b = 11110001b
-01101101b ^ 10011101b = 11110000b
-01101101b ^ 10011110b = 11110011b
-01101101b ^ 10011111b = 11110010b
-01101101b ^ 10100000b = 11001101b
-01101101b ^ 10100001b = 11001100b
-01101101b ^ 10100010b = 11001111b
-01101101b ^ 10100011b = 11001110b
-01101101b ^ 10100100b = 11001001b
-01101101b ^ 10100101b = 11001000b
-01101101b ^ 10100110b = 11001011b
-01101101b ^ 10100111b = 11001010b
-01101101b ^ 10101000b = 11000101b
-01101101b ^ 10101001b = 11000100b
-01101101b ^ 10101010b = 11000111b
-01101101b ^ 10101011b = 11000110b
-01101101b ^ 10101100b = 11000001b
-01101101b ^ 10101101b = 11000000b
-01101101b ^ 10101110b = 11000011b
-01101101b ^ 10101111b = 11000010b
-01101101b ^ 10110000b = 11011101b
-01101101b ^ 10110001b = 11011100b
-01101101b ^ 10110010b = 11011111b
-01101101b ^ 10110011b = 11011110b
-01101101b ^ 10110100b = 11011001b
-01101101b ^ 10110101b = 11011000b
-01101101b ^ 10110110b = 11011011b
-01101101b ^ 10110111b = 11011010b
-01101101b ^ 10111000b = 11010101b
-01101101b ^ 10111001b = 11010100b
-01101101b ^ 10111010b = 11010111b
-01101101b ^ 10111011b = 11010110b
-01101101b ^ 10111100b = 11010001b
-01101101b ^ 10111101b = 11010000b
-01101101b ^ 10111110b = 11010011b
-01101101b ^ 10111111b = 11010010b
-01101101b ^ 11000000b = 10101101b
-01101101b ^ 11000001b = 10101100b
-01101101b ^ 11000010b = 10101111b
-01101101b ^ 11000011b = 10101110b
-01101101b ^ 11000100b = 10101001b
-01101101b ^ 11000101b = 10101000b
-01101101b ^ 11000110b = 10101011b
-01101101b ^ 11000111b = 10101010b
-01101101b ^ 11001000b = 10100101b
-01101101b ^ 11001001b = 10100100b
-01101101b ^ 11001010b = 10100111b
-01101101b ^ 11001011b = 10100110b
-01101101b ^ 11001100b = 10100001b
-01101101b ^ 11001101b = 10100000b
-01101101b ^ 11001110b = 10100011b
-01101101b ^ 11001111b = 10100010b
-01101101b ^ 11010000b = 10111101b
-01101101b ^ 11010001b = 10111100b
-01101101b ^ 11010010b = 10111111b
-01101101b ^ 11010011b = 10111110b
-01101101b ^ 11010100b = 10111001b
-01101101b ^ 11010101b = 10111000b
-01101101b ^ 11010110b = 10111011b
-01101101b ^ 11010111b = 10111010b
-01101101b ^ 11011000b = 10110101b
-01101101b ^ 11011001b = 10110100b
-01101101b ^ 11011010b = 10110111b
-01101101b ^ 11011011b = 10110110b
-01101101b ^ 11011100b = 10110001b
-01101101b ^ 11011101b = 10110000b
-01101101b ^ 11011110b = 10110011b
-01101101b ^ 11011111b = 10110010b
-01101101b ^ 11100000b = 10001101b
-01101101b ^ 11100001b = 10001100b
-01101101b ^ 11100010b = 10001111b
-01101101b ^ 11100011b = 10001110b
-01101101b ^ 11100100b = 10001001b
-01101101b ^ 11100101b = 10001000b
-01101101b ^ 11100110b = 10001011b
-01101101b ^ 11100111b = 10001010b
-01101101b ^ 11101000b = 10000101b
-01101101b ^ 11101001b = 10000100b
-01101101b ^ 11101010b = 10000111b
-01101101b ^ 11101011b = 10000110b
-01101101b ^ 11101100b = 10000001b
-01101101b ^ 11101101b = 10000000b
-01101101b ^ 11101110b = 10000011b
-01101101b ^ 11101111b = 10000010b
-01101101b ^ 11110000b = 10011101b
-01101101b ^ 11110001b = 10011100b
-01101101b ^ 11110010b = 10011111b
-01101101b ^ 11110011b = 10011110b
-01101101b ^ 11110100b = 10011001b
-01101101b ^ 11110101b = 10011000b
-01101101b ^ 11110110b = 10011011b
-01101101b ^ 11110111b = 10011010b
-01101101b ^ 11111000b = 10010101b
-01101101b ^ 11111001b = 10010100b
-01101101b ^ 11111010b = 10010111b
-01101101b ^ 11111011b = 10010110b
-01101101b ^ 11111100b = 10010001b
-01101101b ^ 11111101b = 10010000b
-01101101b ^ 11111110b = 10010011b
-01101101b ^ 11111111b = 10010010b
-01101101b ^ 00000000b = 01101101b
-01101101b ^ 00000001b = 01101100b
-01101101b ^ 00000010b = 01101111b
-01101101b ^ 00000011b = 01101110b
-01101101b ^ 00000100b = 01101001b
-01101101b ^ 00000101b = 01101000b
-01101101b ^ 00000110b = 01101011b
-01101101b ^ 00000111b = 01101010b
-01101101b ^ 00001000b = 01100101b
-01101101b ^ 00001001b = 01100100b
-01101101b ^ 00001010b = 01100111b
-01101101b ^ 00001011b = 01100110b
-01101101b ^ 00001100b = 01100001b
-01101101b ^ 00001101b = 01100000b
-01101101b ^ 00001110b = 01100011b
-01101101b ^ 00001111b = 01100010b
-01101101b ^ 00010000b = 01111101b
-01101101b ^ 00010001b = 01111100b
-01101101b ^ 00010010b = 01111111b
-01101101b ^ 00010011b = 01111110b
-01101101b ^ 00010100b = 01111001b
-01101101b ^ 00010101b = 01111000b
-01101101b ^ 00010110b = 01111011b
-01101101b ^ 00010111b = 01111010b
-01101101b ^ 00011000b = 01110101b
-01101101b ^ 00011001b = 01110100b
-01101101b ^ 00011010b = 01110111b
-01101101b ^ 00011011b = 01110110b
-01101101b ^ 00011100b = 01110001b
-01101101b ^ 00011101b = 01110000b
-01101101b ^ 00011110b = 01110011b
-01101101b ^ 00011111b = 01110010b
-01101101b ^ 00100000b = 01001101b
-01101101b ^ 00100001b = 01001100b
-01101101b ^ 00100010b = 01001111b
-01101101b ^ 00100011b = 01001110b
-01101101b ^ 00100100b = 01001001b
-01101101b ^ 00100101b = 01001000b
-01101101b ^ 00100110b = 01001011b
-01101101b ^ 00100111b = 01001010b
-01101101b ^ 00101000b = 01000101b
-01101101b ^ 00101001b = 01000100b
-01101101b ^ 00101010b = 01000111b
-01101101b ^ 00101011b = 01000110b
-01101101b ^ 00101100b = 01000001b
-01101101b ^ 00101101b = 01000000b
-01101101b ^ 00101110b = 01000011b
-01101101b ^ 00101111b = 01000010b
-01101101b ^ 00110000b = 01011101b
-01101101b ^ 00110001b = 01011100b
-01101101b ^ 00110010b = 01011111b
-01101101b ^ 00110011b = 01011110b
-01101101b ^ 00110100b = 01011001b
-01101101b ^ 00110101b = 01011000b
-01101101b ^ 00110110b = 01011011b
-01101101b ^ 00110111b = 01011010b
-01101101b ^ 00111000b = 01010101b
-01101101b ^ 00111001b = 01010100b
-01101101b ^ 00111010b = 01010111b
-01101101b ^ 00111011b = 01010110b
-01101101b ^ 00111100b = 01010001b
-01101101b ^ 00111101b = 01010000b
-01101101b ^ 00111110b = 01010011b
-01101101b ^ 00111111b = 01010010b
-01101101b ^ 01000000b = 00101101b
-01101101b ^ 01000001b = 00101100b
-01101101b ^ 01000010b = 00101111b
-01101101b ^ 01000011b = 00101110b
-01101101b ^ 01000100b = 00101001b
-01101101b ^ 01000101b = 00101000b
-01101101b ^ 01000110b = 00101011b
-01101101b ^ 01000111b = 00101010b
-01101101b ^ 01001000b = 00100101b
-01101101b ^ 01001001b = 00100100b
-01101101b ^ 01001010b = 00100111b
-01101101b ^ 01001011b = 00100110b
-01101101b ^ 01001100b = 00100001b
-01101101b ^ 01001101b = 00100000b
-01101101b ^ 01001110b = 00100011b
-01101101b ^ 01001111b = 00100010b
-01101101b ^ 01010000b = 00111101b
-01101101b ^ 01010001b = 00111100b
-01101101b ^ 01010010b = 00111111b
-01101101b ^ 01010011b = 00111110b
-01101101b ^ 01010100b = 00111001b
-01101101b ^ 01010101b = 00111000b
-01101101b ^ 01010110b = 00111011b
-01101101b ^ 01010111b = 00111010b
-01101101b ^ 01011000b = 00110101b
-01101101b ^ 01011001b = 00110100b
-01101101b ^ 01011010b = 00110111b
-01101101b ^ 01011011b = 00110110b
-01101101b ^ 01011100b = 00110001b
-01101101b ^ 01011101b = 00110000b
-01101101b ^ 01011110b = 00110011b
-01101101b ^ 01011111b = 00110010b
-01101101b ^ 01100000b = 00001101b
-01101101b ^ 01100001b = 00001100b
-01101101b ^ 01100010b = 00001111b
-01101101b ^ 01100011b = 00001110b
-01101101b ^ 01100100b = 00001001b
-01101101b ^ 01100101b = 00001000b
-01101101b ^ 01100110b = 00001011b
-01101101b ^ 01100111b = 00001010b
-01101101b ^ 01101000b = 00000101b
-01101101b ^ 01101001b = 00000100b
-01101101b ^ 01101010b = 00000111b
-01101101b ^ 01101011b = 00000110b
-01101101b ^ 01101100b = 00000001b
-01101101b ^ 01101101b = 00000000b
-01101101b ^ 01101110b = 00000011b
-01101101b ^ 01101111b = 00000010b
-01101101b ^ 01110000b = 00011101b
-01101101b ^ 01110001b = 00011100b
-01101101b ^ 01110010b = 00011111b
-01101101b ^ 01110011b = 00011110b
-01101101b ^ 01110100b = 00011001b
-01101101b ^ 01110101b = 00011000b
-01101101b ^ 01110110b = 00011011b
-01101101b ^ 01110111b = 00011010b
-01101101b ^ 01111000b = 00010101b
-01101101b ^ 01111001b = 00010100b
-01101101b ^ 01111010b = 00010111b
-01101101b ^ 01111011b = 00010110b
-01101101b ^ 01111100b = 00010001b
-01101101b ^ 01111101b = 00010000b
-01101101b ^ 01111110b = 00010011b
-01101110b ^ 10000000b = 11101110b
-01101110b ^ 10000001b = 11101111b
-01101110b ^ 10000010b = 11101100b
-01101110b ^ 10000011b = 11101101b
-01101110b ^ 10000100b = 11101010b
-01101110b ^ 10000101b = 11101011b
-01101110b ^ 10000110b = 11101000b
-01101110b ^ 10000111b = 11101001b
-01101110b ^ 10001000b = 11100110b
-01101110b ^ 10001001b = 11100111b
-01101110b ^ 10001010b = 11100100b
-01101110b ^ 10001011b = 11100101b
-01101110b ^ 10001100b = 11100010b
-01101110b ^ 10001101b = 11100011b
-01101110b ^ 10001110b = 11100000b
-01101110b ^ 10001111b = 11100001b
-01101110b ^ 10010000b = 11111110b
-01101110b ^ 10010001b = 11111111b
-01101110b ^ 10010010b = 11111100b
-01101110b ^ 10010011b = 11111101b
-01101110b ^ 10010100b = 11111010b
-01101110b ^ 10010101b = 11111011b
-01101110b ^ 10010110b = 11111000b
-01101110b ^ 10010111b = 11111001b
-01101110b ^ 10011000b = 11110110b
-01101110b ^ 10011001b = 11110111b
-01101110b ^ 10011010b = 11110100b
-01101110b ^ 10011011b = 11110101b
-01101110b ^ 10011100b = 11110010b
-01101110b ^ 10011101b = 11110011b
-01101110b ^ 10011110b = 11110000b
-01101110b ^ 10011111b = 11110001b
-01101110b ^ 10100000b = 11001110b
-01101110b ^ 10100001b = 11001111b
-01101110b ^ 10100010b = 11001100b
-01101110b ^ 10100011b = 11001101b
-01101110b ^ 10100100b = 11001010b
-01101110b ^ 10100101b = 11001011b
-01101110b ^ 10100110b = 11001000b
-01101110b ^ 10100111b = 11001001b
-01101110b ^ 10101000b = 11000110b
-01101110b ^ 10101001b = 11000111b
-01101110b ^ 10101010b = 11000100b
-01101110b ^ 10101011b = 11000101b
-01101110b ^ 10101100b = 11000010b
-01101110b ^ 10101101b = 11000011b
-01101110b ^ 10101110b = 11000000b
-01101110b ^ 10101111b = 11000001b
-01101110b ^ 10110000b = 11011110b
-01101110b ^ 10110001b = 11011111b
-01101110b ^ 10110010b = 11011100b
-01101110b ^ 10110011b = 11011101b
-01101110b ^ 10110100b = 11011010b
-01101110b ^ 10110101b = 11011011b
-01101110b ^ 10110110b = 11011000b
-01101110b ^ 10110111b = 11011001b
-01101110b ^ 10111000b = 11010110b
-01101110b ^ 10111001b = 11010111b
-01101110b ^ 10111010b = 11010100b
-01101110b ^ 10111011b = 11010101b
-01101110b ^ 10111100b = 11010010b
-01101110b ^ 10111101b = 11010011b
-01101110b ^ 10111110b = 11010000b
-01101110b ^ 10111111b = 11010001b
-01101110b ^ 11000000b = 10101110b
-01101110b ^ 11000001b = 10101111b
-01101110b ^ 11000010b = 10101100b
-01101110b ^ 11000011b = 10101101b
-01101110b ^ 11000100b = 10101010b
-01101110b ^ 11000101b = 10101011b
-01101110b ^ 11000110b = 10101000b
-01101110b ^ 11000111b = 10101001b
-01101110b ^ 11001000b = 10100110b
-01101110b ^ 11001001b = 10100111b
-01101110b ^ 11001010b = 10100100b
-01101110b ^ 11001011b = 10100101b
-01101110b ^ 11001100b = 10100010b
-01101110b ^ 11001101b = 10100011b
-01101110b ^ 11001110b = 10100000b
-01101110b ^ 11001111b = 10100001b
-01101110b ^ 11010000b = 10111110b
-01101110b ^ 11010001b = 10111111b
-01101110b ^ 11010010b = 10111100b
-01101110b ^ 11010011b = 10111101b
-01101110b ^ 11010100b = 10111010b
-01101110b ^ 11010101b = 10111011b
-01101110b ^ 11010110b = 10111000b
-01101110b ^ 11010111b = 10111001b
-01101110b ^ 11011000b = 10110110b
-01101110b ^ 11011001b = 10110111b
-01101110b ^ 11011010b = 10110100b
-01101110b ^ 11011011b = 10110101b
-01101110b ^ 11011100b = 10110010b
-01101110b ^ 11011101b = 10110011b
-01101110b ^ 11011110b = 10110000b
-01101110b ^ 11011111b = 10110001b
-01101110b ^ 11100000b = 10001110b
-01101110b ^ 11100001b = 10001111b
-01101110b ^ 11100010b = 10001100b
-01101110b ^ 11100011b = 10001101b
-01101110b ^ 11100100b = 10001010b
-01101110b ^ 11100101b = 10001011b
-01101110b ^ 11100110b = 10001000b
-01101110b ^ 11100111b = 10001001b
-01101110b ^ 11101000b = 10000110b
-01101110b ^ 11101001b = 10000111b
-01101110b ^ 11101010b = 10000100b
-01101110b ^ 11101011b = 10000101b
-01101110b ^ 11101100b = 10000010b
-01101110b ^ 11101101b = 10000011b
-01101110b ^ 11101110b = 10000000b
-01101110b ^ 11101111b = 10000001b
-01101110b ^ 11110000b = 10011110b
-01101110b ^ 11110001b = 10011111b
-01101110b ^ 11110010b = 10011100b
-01101110b ^ 11110011b = 10011101b
-01101110b ^ 11110100b = 10011010b
-01101110b ^ 11110101b = 10011011b
-01101110b ^ 11110110b = 10011000b
-01101110b ^ 11110111b = 10011001b
-01101110b ^ 11111000b = 10010110b
-01101110b ^ 11111001b = 10010111b
-01101110b ^ 11111010b = 10010100b
-01101110b ^ 11111011b = 10010101b
-01101110b ^ 11111100b = 10010010b
-01101110b ^ 11111101b = 10010011b
-01101110b ^ 11111110b = 10010000b
-01101110b ^ 11111111b = 10010001b
-01101110b ^ 00000000b = 01101110b
-01101110b ^ 00000001b = 01101111b
-01101110b ^ 00000010b = 01101100b
-01101110b ^ 00000011b = 01101101b
-01101110b ^ 00000100b = 01101010b
-01101110b ^ 00000101b = 01101011b
-01101110b ^ 00000110b = 01101000b
-01101110b ^ 00000111b = 01101001b
-01101110b ^ 00001000b = 01100110b
-01101110b ^ 00001001b = 01100111b
-01101110b ^ 00001010b = 01100100b
-01101110b ^ 00001011b = 01100101b
-01101110b ^ 00001100b = 01100010b
-01101110b ^ 00001101b = 01100011b
-01101110b ^ 00001110b = 01100000b
-01101110b ^ 00001111b = 01100001b
-01101110b ^ 00010000b = 01111110b
-01101110b ^ 00010001b = 01111111b
-01101110b ^ 00010010b = 01111100b
-01101110b ^ 00010011b = 01111101b
-01101110b ^ 00010100b = 01111010b
-01101110b ^ 00010101b = 01111011b
-01101110b ^ 00010110b = 01111000b
-01101110b ^ 00010111b = 01111001b
-01101110b ^ 00011000b = 01110110b
-01101110b ^ 00011001b = 01110111b
-01101110b ^ 00011010b = 01110100b
-01101110b ^ 00011011b = 01110101b
-01101110b ^ 00011100b = 01110010b
-01101110b ^ 00011101b = 01110011b
-01101110b ^ 00011110b = 01110000b
-01101110b ^ 00011111b = 01110001b
-01101110b ^ 00100000b = 01001110b
-01101110b ^ 00100001b = 01001111b
-01101110b ^ 00100010b = 01001100b
-01101110b ^ 00100011b = 01001101b
-01101110b ^ 00100100b = 01001010b
-01101110b ^ 00100101b = 01001011b
-01101110b ^ 00100110b = 01001000b
-01101110b ^ 00100111b = 01001001b
-01101110b ^ 00101000b = 01000110b
-01101110b ^ 00101001b = 01000111b
-01101110b ^ 00101010b = 01000100b
-01101110b ^ 00101011b = 01000101b
-01101110b ^ 00101100b = 01000010b
-01101110b ^ 00101101b = 01000011b
-01101110b ^ 00101110b = 01000000b
-01101110b ^ 00101111b = 01000001b
-01101110b ^ 00110000b = 01011110b
-01101110b ^ 00110001b = 01011111b
-01101110b ^ 00110010b = 01011100b
-01101110b ^ 00110011b = 01011101b
-01101110b ^ 00110100b = 01011010b
-01101110b ^ 00110101b = 01011011b
-01101110b ^ 00110110b = 01011000b
-01101110b ^ 00110111b = 01011001b
-01101110b ^ 00111000b = 01010110b
-01101110b ^ 00111001b = 01010111b
-01101110b ^ 00111010b = 01010100b
-01101110b ^ 00111011b = 01010101b
-01101110b ^ 00111100b = 01010010b
-01101110b ^ 00111101b = 01010011b
-01101110b ^ 00111110b = 01010000b
-01101110b ^ 00111111b = 01010001b
-01101110b ^ 01000000b = 00101110b
-01101110b ^ 01000001b = 00101111b
-01101110b ^ 01000010b = 00101100b
-01101110b ^ 01000011b = 00101101b
-01101110b ^ 01000100b = 00101010b
-01101110b ^ 01000101b = 00101011b
-01101110b ^ 01000110b = 00101000b
-01101110b ^ 01000111b = 00101001b
-01101110b ^ 01001000b = 00100110b
-01101110b ^ 01001001b = 00100111b
-01101110b ^ 01001010b = 00100100b
-01101110b ^ 01001011b = 00100101b
-01101110b ^ 01001100b = 00100010b
-01101110b ^ 01001101b = 00100011b
-01101110b ^ 01001110b = 00100000b
-01101110b ^ 01001111b = 00100001b
-01101110b ^ 01010000b = 00111110b
-01101110b ^ 01010001b = 00111111b
-01101110b ^ 01010010b = 00111100b
-01101110b ^ 01010011b = 00111101b
-01101110b ^ 01010100b = 00111010b
-01101110b ^ 01010101b = 00111011b
-01101110b ^ 01010110b = 00111000b
-01101110b ^ 01010111b = 00111001b
-01101110b ^ 01011000b = 00110110b
-01101110b ^ 01011001b = 00110111b
-01101110b ^ 01011010b = 00110100b
-01101110b ^ 01011011b = 00110101b
-01101110b ^ 01011100b = 00110010b
-01101110b ^ 01011101b = 00110011b
-01101110b ^ 01011110b = 00110000b
-01101110b ^ 01011111b = 00110001b
-01101110b ^ 01100000b = 00001110b
-01101110b ^ 01100001b = 00001111b
-01101110b ^ 01100010b = 00001100b
-01101110b ^ 01100011b = 00001101b
-01101110b ^ 01100100b = 00001010b
-01101110b ^ 01100101b = 00001011b
-01101110b ^ 01100110b = 00001000b
-01101110b ^ 01100111b = 00001001b
-01101110b ^ 01101000b = 00000110b
-01101110b ^ 01101001b = 00000111b
-01101110b ^ 01101010b = 00000100b
-01101110b ^ 01101011b = 00000101b
-01101110b ^ 01101100b = 00000010b
-01101110b ^ 01101101b = 00000011b
-01101110b ^ 01101110b = 00000000b
-01101110b ^ 01101111b = 00000001b
-01101110b ^ 01110000b = 00011110b
-01101110b ^ 01110001b = 00011111b
-01101110b ^ 01110010b = 00011100b
-01101110b ^ 01110011b = 00011101b
-01101110b ^ 01110100b = 00011010b
-01101110b ^ 01110101b = 00011011b
-01101110b ^ 01110110b = 00011000b
-01101110b ^ 01110111b = 00011001b
-01101110b ^ 01111000b = 00010110b
-01101110b ^ 01111001b = 00010111b
-01101110b ^ 01111010b = 00010100b
-01101110b ^ 01111011b = 00010101b
-01101110b ^ 01111100b = 00010010b
-01101110b ^ 01111101b = 00010011b
-01101110b ^ 01111110b = 00010000b
-01101111b ^ 10000000b = 11101111b
-01101111b ^ 10000001b = 11101110b
-01101111b ^ 10000010b = 11101101b
-01101111b ^ 10000011b = 11101100b
-01101111b ^ 10000100b = 11101011b
-01101111b ^ 10000101b = 11101010b
-01101111b ^ 10000110b = 11101001b
-01101111b ^ 10000111b = 11101000b
-01101111b ^ 10001000b = 11100111b
-01101111b ^ 10001001b = 11100110b
-01101111b ^ 10001010b = 11100101b
-01101111b ^ 10001011b = 11100100b
-01101111b ^ 10001100b = 11100011b
-01101111b ^ 10001101b = 11100010b
-01101111b ^ 10001110b = 11100001b
-01101111b ^ 10001111b = 11100000b
-01101111b ^ 10010000b = 11111111b
-01101111b ^ 10010001b = 11111110b
-01101111b ^ 10010010b = 11111101b
-01101111b ^ 10010011b = 11111100b
-01101111b ^ 10010100b = 11111011b
-01101111b ^ 10010101b = 11111010b
-01101111b ^ 10010110b = 11111001b
-01101111b ^ 10010111b = 11111000b
-01101111b ^ 10011000b = 11110111b
-01101111b ^ 10011001b = 11110110b
-01101111b ^ 10011010b = 11110101b
-01101111b ^ 10011011b = 11110100b
-01101111b ^ 10011100b = 11110011b
-01101111b ^ 10011101b = 11110010b
-01101111b ^ 10011110b = 11110001b
-01101111b ^ 10011111b = 11110000b
-01101111b ^ 10100000b = 11001111b
-01101111b ^ 10100001b = 11001110b
-01101111b ^ 10100010b = 11001101b
-01101111b ^ 10100011b = 11001100b
-01101111b ^ 10100100b = 11001011b
-01101111b ^ 10100101b = 11001010b
-01101111b ^ 10100110b = 11001001b
-01101111b ^ 10100111b = 11001000b
-01101111b ^ 10101000b = 11000111b
-01101111b ^ 10101001b = 11000110b
-01101111b ^ 10101010b = 11000101b
-01101111b ^ 10101011b = 11000100b
-01101111b ^ 10101100b = 11000011b
-01101111b ^ 10101101b = 11000010b
-01101111b ^ 10101110b = 11000001b
-01101111b ^ 10101111b = 11000000b
-01101111b ^ 10110000b = 11011111b
-01101111b ^ 10110001b = 11011110b
-01101111b ^ 10110010b = 11011101b
-01101111b ^ 10110011b = 11011100b
-01101111b ^ 10110100b = 11011011b
-01101111b ^ 10110101b = 11011010b
-01101111b ^ 10110110b = 11011001b
-01101111b ^ 10110111b = 11011000b
-01101111b ^ 10111000b = 11010111b
-01101111b ^ 10111001b = 11010110b
-01101111b ^ 10111010b = 11010101b
-01101111b ^ 10111011b = 11010100b
-01101111b ^ 10111100b = 11010011b
-01101111b ^ 10111101b = 11010010b
-01101111b ^ 10111110b = 11010001b
-01101111b ^ 10111111b = 11010000b
-01101111b ^ 11000000b = 10101111b
-01101111b ^ 11000001b = 10101110b
-01101111b ^ 11000010b = 10101101b
-01101111b ^ 11000011b = 10101100b
-01101111b ^ 11000100b = 10101011b
-01101111b ^ 11000101b = 10101010b
-01101111b ^ 11000110b = 10101001b
-01101111b ^ 11000111b = 10101000b
-01101111b ^ 11001000b = 10100111b
-01101111b ^ 11001001b = 10100110b
-01101111b ^ 11001010b = 10100101b
-01101111b ^ 11001011b = 10100100b
-01101111b ^ 11001100b = 10100011b
-01101111b ^ 11001101b = 10100010b
-01101111b ^ 11001110b = 10100001b
-01101111b ^ 11001111b = 10100000b
-01101111b ^ 11010000b = 10111111b
-01101111b ^ 11010001b = 10111110b
-01101111b ^ 11010010b = 10111101b
-01101111b ^ 11010011b = 10111100b
-01101111b ^ 11010100b = 10111011b
-01101111b ^ 11010101b = 10111010b
-01101111b ^ 11010110b = 10111001b
-01101111b ^ 11010111b = 10111000b
-01101111b ^ 11011000b = 10110111b
-01101111b ^ 11011001b = 10110110b
-01101111b ^ 11011010b = 10110101b
-01101111b ^ 11011011b = 10110100b
-01101111b ^ 11011100b = 10110011b
-01101111b ^ 11011101b = 10110010b
-01101111b ^ 11011110b = 10110001b
-01101111b ^ 11011111b = 10110000b
-01101111b ^ 11100000b = 10001111b
-01101111b ^ 11100001b = 10001110b
-01101111b ^ 11100010b = 10001101b
-01101111b ^ 11100011b = 10001100b
-01101111b ^ 11100100b = 10001011b
-01101111b ^ 11100101b = 10001010b
-01101111b ^ 11100110b = 10001001b
-01101111b ^ 11100111b = 10001000b
-01101111b ^ 11101000b = 10000111b
-01101111b ^ 11101001b = 10000110b
-01101111b ^ 11101010b = 10000101b
-01101111b ^ 11101011b = 10000100b
-01101111b ^ 11101100b = 10000011b
-01101111b ^ 11101101b = 10000010b
-01101111b ^ 11101110b = 10000001b
-01101111b ^ 11101111b = 10000000b
-01101111b ^ 11110000b = 10011111b
-01101111b ^ 11110001b = 10011110b
-01101111b ^ 11110010b = 10011101b
-01101111b ^ 11110011b = 10011100b
-01101111b ^ 11110100b = 10011011b
-01101111b ^ 11110101b = 10011010b
-01101111b ^ 11110110b = 10011001b
-01101111b ^ 11110111b = 10011000b
-01101111b ^ 11111000b = 10010111b
-01101111b ^ 11111001b = 10010110b
-01101111b ^ 11111010b = 10010101b
-01101111b ^ 11111011b = 10010100b
-01101111b ^ 11111100b = 10010011b
-01101111b ^ 11111101b = 10010010b
-01101111b ^ 11111110b = 10010001b
-01101111b ^ 11111111b = 10010000b
-01101111b ^ 00000000b = 01101111b
-01101111b ^ 00000001b = 01101110b
-01101111b ^ 00000010b = 01101101b
-01101111b ^ 00000011b = 01101100b
-01101111b ^ 00000100b = 01101011b
-01101111b ^ 00000101b = 01101010b
-01101111b ^ 00000110b = 01101001b
-01101111b ^ 00000111b = 01101000b
-01101111b ^ 00001000b = 01100111b
-01101111b ^ 00001001b = 01100110b
-01101111b ^ 00001010b = 01100101b
-01101111b ^ 00001011b = 01100100b
-01101111b ^ 00001100b = 01100011b
-01101111b ^ 00001101b = 01100010b
-01101111b ^ 00001110b = 01100001b
-01101111b ^ 00001111b = 01100000b
-01101111b ^ 00010000b = 01111111b
-01101111b ^ 00010001b = 01111110b
-01101111b ^ 00010010b = 01111101b
-01101111b ^ 00010011b = 01111100b
-01101111b ^ 00010100b = 01111011b
-01101111b ^ 00010101b = 01111010b
-01101111b ^ 00010110b = 01111001b
-01101111b ^ 00010111b = 01111000b
-01101111b ^ 00011000b = 01110111b
-01101111b ^ 00011001b = 01110110b
-01101111b ^ 00011010b = 01110101b
-01101111b ^ 00011011b = 01110100b
-01101111b ^ 00011100b = 01110011b
-01101111b ^ 00011101b = 01110010b
-01101111b ^ 00011110b = 01110001b
-01101111b ^ 00011111b = 01110000b
-01101111b ^ 00100000b = 01001111b
-01101111b ^ 00100001b = 01001110b
-01101111b ^ 00100010b = 01001101b
-01101111b ^ 00100011b = 01001100b
-01101111b ^ 00100100b = 01001011b
-01101111b ^ 00100101b = 01001010b
-01101111b ^ 00100110b = 01001001b
-01101111b ^ 00100111b = 01001000b
-01101111b ^ 00101000b = 01000111b
-01101111b ^ 00101001b = 01000110b
-01101111b ^ 00101010b = 01000101b
-01101111b ^ 00101011b = 01000100b
-01101111b ^ 00101100b = 01000011b
-01101111b ^ 00101101b = 01000010b
-01101111b ^ 00101110b = 01000001b
-01101111b ^ 00101111b = 01000000b
-01101111b ^ 00110000b = 01011111b
-01101111b ^ 00110001b = 01011110b
-01101111b ^ 00110010b = 01011101b
-01101111b ^ 00110011b = 01011100b
-01101111b ^ 00110100b = 01011011b
-01101111b ^ 00110101b = 01011010b
-01101111b ^ 00110110b = 01011001b
-01101111b ^ 00110111b = 01011000b
-01101111b ^ 00111000b = 01010111b
-01101111b ^ 00111001b = 01010110b
-01101111b ^ 00111010b = 01010101b
-01101111b ^ 00111011b = 01010100b
-01101111b ^ 00111100b = 01010011b
-01101111b ^ 00111101b = 01010010b
-01101111b ^ 00111110b = 01010001b
-01101111b ^ 00111111b = 01010000b
-01101111b ^ 01000000b = 00101111b
-01101111b ^ 01000001b = 00101110b
-01101111b ^ 01000010b = 00101101b
-01101111b ^ 01000011b = 00101100b
-01101111b ^ 01000100b = 00101011b
-01101111b ^ 01000101b = 00101010b
-01101111b ^ 01000110b = 00101001b
-01101111b ^ 01000111b = 00101000b
-01101111b ^ 01001000b = 00100111b
-01101111b ^ 01001001b = 00100110b
-01101111b ^ 01001010b = 00100101b
-01101111b ^ 01001011b = 00100100b
-01101111b ^ 01001100b = 00100011b
-01101111b ^ 01001101b = 00100010b
-01101111b ^ 01001110b = 00100001b
-01101111b ^ 01001111b = 00100000b
-01101111b ^ 01010000b = 00111111b
-01101111b ^ 01010001b = 00111110b
-01101111b ^ 01010010b = 00111101b
-01101111b ^ 01010011b = 00111100b
-01101111b ^ 01010100b = 00111011b
-01101111b ^ 01010101b = 00111010b
-01101111b ^ 01010110b = 00111001b
-01101111b ^ 01010111b = 00111000b
-01101111b ^ 01011000b = 00110111b
-01101111b ^ 01011001b = 00110110b
-01101111b ^ 01011010b = 00110101b
-01101111b ^ 01011011b = 00110100b
-01101111b ^ 01011100b = 00110011b
-01101111b ^ 01011101b = 00110010b
-01101111b ^ 01011110b = 00110001b
-01101111b ^ 01011111b = 00110000b
-01101111b ^ 01100000b = 00001111b
-01101111b ^ 01100001b = 00001110b
-01101111b ^ 01100010b = 00001101b
-01101111b ^ 01100011b = 00001100b
-01101111b ^ 01100100b = 00001011b
-01101111b ^ 01100101b = 00001010b
-01101111b ^ 01100110b = 00001001b
-01101111b ^ 01100111b = 00001000b
-01101111b ^ 01101000b = 00000111b
-01101111b ^ 01101001b = 00000110b
-01101111b ^ 01101010b = 00000101b
-01101111b ^ 01101011b = 00000100b
-01101111b ^ 01101100b = 00000011b
-01101111b ^ 01101101b = 00000010b
-01101111b ^ 01101110b = 00000001b
-01101111b ^ 01101111b = 00000000b
-01101111b ^ 01110000b = 00011111b
-01101111b ^ 01110001b = 00011110b
-01101111b ^ 01110010b = 00011101b
-01101111b ^ 01110011b = 00011100b
-01101111b ^ 01110100b = 00011011b
-01101111b ^ 01110101b = 00011010b
-01101111b ^ 01110110b = 00011001b
-01101111b ^ 01110111b = 00011000b
-01101111b ^ 01111000b = 00010111b
-01101111b ^ 01111001b = 00010110b
-01101111b ^ 01111010b = 00010101b
-01101111b ^ 01111011b = 00010100b
-01101111b ^ 01111100b = 00010011b
-01101111b ^ 01111101b = 00010010b
-01101111b ^ 01111110b = 00010001b
-01110000b ^ 10000000b = 11110000b
-01110000b ^ 10000001b = 11110001b
-01110000b ^ 10000010b = 11110010b
-01110000b ^ 10000011b = 11110011b
-01110000b ^ 10000100b = 11110100b
-01110000b ^ 10000101b = 11110101b
-01110000b ^ 10000110b = 11110110b
-01110000b ^ 10000111b = 11110111b
-01110000b ^ 10001000b = 11111000b
-01110000b ^ 10001001b = 11111001b
-01110000b ^ 10001010b = 11111010b
-01110000b ^ 10001011b = 11111011b
-01110000b ^ 10001100b = 11111100b
-01110000b ^ 10001101b = 11111101b
-01110000b ^ 10001110b = 11111110b
-01110000b ^ 10001111b = 11111111b
-01110000b ^ 10010000b = 11100000b
-01110000b ^ 10010001b = 11100001b
-01110000b ^ 10010010b = 11100010b
-01110000b ^ 10010011b = 11100011b
-01110000b ^ 10010100b = 11100100b
-01110000b ^ 10010101b = 11100101b
-01110000b ^ 10010110b = 11100110b
-01110000b ^ 10010111b = 11100111b
-01110000b ^ 10011000b = 11101000b
-01110000b ^ 10011001b = 11101001b
-01110000b ^ 10011010b = 11101010b
-01110000b ^ 10011011b = 11101011b
-01110000b ^ 10011100b = 11101100b
-01110000b ^ 10011101b = 11101101b
-01110000b ^ 10011110b = 11101110b
-01110000b ^ 10011111b = 11101111b
-01110000b ^ 10100000b = 11010000b
-01110000b ^ 10100001b = 11010001b
-01110000b ^ 10100010b = 11010010b
-01110000b ^ 10100011b = 11010011b
-01110000b ^ 10100100b = 11010100b
-01110000b ^ 10100101b = 11010101b
-01110000b ^ 10100110b = 11010110b
-01110000b ^ 10100111b = 11010111b
-01110000b ^ 10101000b = 11011000b
-01110000b ^ 10101001b = 11011001b
-01110000b ^ 10101010b = 11011010b
-01110000b ^ 10101011b = 11011011b
-01110000b ^ 10101100b = 11011100b
-01110000b ^ 10101101b = 11011101b
-01110000b ^ 10101110b = 11011110b
-01110000b ^ 10101111b = 11011111b
-01110000b ^ 10110000b = 11000000b
-01110000b ^ 10110001b = 11000001b
-01110000b ^ 10110010b = 11000010b
-01110000b ^ 10110011b = 11000011b
-01110000b ^ 10110100b = 11000100b
-01110000b ^ 10110101b = 11000101b
-01110000b ^ 10110110b = 11000110b
-01110000b ^ 10110111b = 11000111b
-01110000b ^ 10111000b = 11001000b
-01110000b ^ 10111001b = 11001001b
-01110000b ^ 10111010b = 11001010b
-01110000b ^ 10111011b = 11001011b
-01110000b ^ 10111100b = 11001100b
-01110000b ^ 10111101b = 11001101b
-01110000b ^ 10111110b = 11001110b
-01110000b ^ 10111111b = 11001111b
-01110000b ^ 11000000b = 10110000b
-01110000b ^ 11000001b = 10110001b
-01110000b ^ 11000010b = 10110010b
-01110000b ^ 11000011b = 10110011b
-01110000b ^ 11000100b = 10110100b
-01110000b ^ 11000101b = 10110101b
-01110000b ^ 11000110b = 10110110b
-01110000b ^ 11000111b = 10110111b
-01110000b ^ 11001000b = 10111000b
-01110000b ^ 11001001b = 10111001b
-01110000b ^ 11001010b = 10111010b
-01110000b ^ 11001011b = 10111011b
-01110000b ^ 11001100b = 10111100b
-01110000b ^ 11001101b = 10111101b
-01110000b ^ 11001110b = 10111110b
-01110000b ^ 11001111b = 10111111b
-01110000b ^ 11010000b = 10100000b
-01110000b ^ 11010001b = 10100001b
-01110000b ^ 11010010b = 10100010b
-01110000b ^ 11010011b = 10100011b
-01110000b ^ 11010100b = 10100100b
-01110000b ^ 11010101b = 10100101b
-01110000b ^ 11010110b = 10100110b
-01110000b ^ 11010111b = 10100111b
-01110000b ^ 11011000b = 10101000b
-01110000b ^ 11011001b = 10101001b
-01110000b ^ 11011010b = 10101010b
-01110000b ^ 11011011b = 10101011b
-01110000b ^ 11011100b = 10101100b
-01110000b ^ 11011101b = 10101101b
-01110000b ^ 11011110b = 10101110b
-01110000b ^ 11011111b = 10101111b
-01110000b ^ 11100000b = 10010000b
-01110000b ^ 11100001b = 10010001b
-01110000b ^ 11100010b = 10010010b
-01110000b ^ 11100011b = 10010011b
-01110000b ^ 11100100b = 10010100b
-01110000b ^ 11100101b = 10010101b
-01110000b ^ 11100110b = 10010110b
-01110000b ^ 11100111b = 10010111b
-01110000b ^ 11101000b = 10011000b
-01110000b ^ 11101001b = 10011001b
-01110000b ^ 11101010b = 10011010b
-01110000b ^ 11101011b = 10011011b
-01110000b ^ 11101100b = 10011100b
-01110000b ^ 11101101b = 10011101b
-01110000b ^ 11101110b = 10011110b
-01110000b ^ 11101111b = 10011111b
-01110000b ^ 11110000b = 10000000b
-01110000b ^ 11110001b = 10000001b
-01110000b ^ 11110010b = 10000010b
-01110000b ^ 11110011b = 10000011b
-01110000b ^ 11110100b = 10000100b
-01110000b ^ 11110101b = 10000101b
-01110000b ^ 11110110b = 10000110b
-01110000b ^ 11110111b = 10000111b
-01110000b ^ 11111000b = 10001000b
-01110000b ^ 11111001b = 10001001b
-01110000b ^ 11111010b = 10001010b
-01110000b ^ 11111011b = 10001011b
-01110000b ^ 11111100b = 10001100b
-01110000b ^ 11111101b = 10001101b
-01110000b ^ 11111110b = 10001110b
-01110000b ^ 11111111b = 10001111b
-01110000b ^ 00000000b = 01110000b
-01110000b ^ 00000001b = 01110001b
-01110000b ^ 00000010b = 01110010b
-01110000b ^ 00000011b = 01110011b
-01110000b ^ 00000100b = 01110100b
-01110000b ^ 00000101b = 01110101b
-01110000b ^ 00000110b = 01110110b
-01110000b ^ 00000111b = 01110111b
-01110000b ^ 00001000b = 01111000b
-01110000b ^ 00001001b = 01111001b
-01110000b ^ 00001010b = 01111010b
-01110000b ^ 00001011b = 01111011b
-01110000b ^ 00001100b = 01111100b
-01110000b ^ 00001101b = 01111101b
-01110000b ^ 00001110b = 01111110b
-01110000b ^ 00001111b = 01111111b
-01110000b ^ 00010000b = 01100000b
-01110000b ^ 00010001b = 01100001b
-01110000b ^ 00010010b = 01100010b
-01110000b ^ 00010011b = 01100011b
-01110000b ^ 00010100b = 01100100b
-01110000b ^ 00010101b = 01100101b
-01110000b ^ 00010110b = 01100110b
-01110000b ^ 00010111b = 01100111b
-01110000b ^ 00011000b = 01101000b
-01110000b ^ 00011001b = 01101001b
-01110000b ^ 00011010b = 01101010b
-01110000b ^ 00011011b = 01101011b
-01110000b ^ 00011100b = 01101100b
-01110000b ^ 00011101b = 01101101b
-01110000b ^ 00011110b = 01101110b
-01110000b ^ 00011111b = 01101111b
-01110000b ^ 00100000b = 01010000b
-01110000b ^ 00100001b = 01010001b
-01110000b ^ 00100010b = 01010010b
-01110000b ^ 00100011b = 01010011b
-01110000b ^ 00100100b = 01010100b
-01110000b ^ 00100101b = 01010101b
-01110000b ^ 00100110b = 01010110b
-01110000b ^ 00100111b = 01010111b
-01110000b ^ 00101000b = 01011000b
-01110000b ^ 00101001b = 01011001b
-01110000b ^ 00101010b = 01011010b
-01110000b ^ 00101011b = 01011011b
-01110000b ^ 00101100b = 01011100b
-01110000b ^ 00101101b = 01011101b
-01110000b ^ 00101110b = 01011110b
-01110000b ^ 00101111b = 01011111b
-01110000b ^ 00110000b = 01000000b
-01110000b ^ 00110001b = 01000001b
-01110000b ^ 00110010b = 01000010b
-01110000b ^ 00110011b = 01000011b
-01110000b ^ 00110100b = 01000100b
-01110000b ^ 00110101b = 01000101b
-01110000b ^ 00110110b = 01000110b
-01110000b ^ 00110111b = 01000111b
-01110000b ^ 00111000b = 01001000b
-01110000b ^ 00111001b = 01001001b
-01110000b ^ 00111010b = 01001010b
-01110000b ^ 00111011b = 01001011b
-01110000b ^ 00111100b = 01001100b
-01110000b ^ 00111101b = 01001101b
-01110000b ^ 00111110b = 01001110b
-01110000b ^ 00111111b = 01001111b
-01110000b ^ 01000000b = 00110000b
-01110000b ^ 01000001b = 00110001b
-01110000b ^ 01000010b = 00110010b
-01110000b ^ 01000011b = 00110011b
-01110000b ^ 01000100b = 00110100b
-01110000b ^ 01000101b = 00110101b
-01110000b ^ 01000110b = 00110110b
-01110000b ^ 01000111b = 00110111b
-01110000b ^ 01001000b = 00111000b
-01110000b ^ 01001001b = 00111001b
-01110000b ^ 01001010b = 00111010b
-01110000b ^ 01001011b = 00111011b
-01110000b ^ 01001100b = 00111100b
-01110000b ^ 01001101b = 00111101b
-01110000b ^ 01001110b = 00111110b
-01110000b ^ 01001111b = 00111111b
-01110000b ^ 01010000b = 00100000b
-01110000b ^ 01010001b = 00100001b
-01110000b ^ 01010010b = 00100010b
-01110000b ^ 01010011b = 00100011b
-01110000b ^ 01010100b = 00100100b
-01110000b ^ 01010101b = 00100101b
-01110000b ^ 01010110b = 00100110b
-01110000b ^ 01010111b = 00100111b
-01110000b ^ 01011000b = 00101000b
-01110000b ^ 01011001b = 00101001b
-01110000b ^ 01011010b = 00101010b
-01110000b ^ 01011011b = 00101011b
-01110000b ^ 01011100b = 00101100b
-01110000b ^ 01011101b = 00101101b
-01110000b ^ 01011110b = 00101110b
-01110000b ^ 01011111b = 00101111b
-01110000b ^ 01100000b = 00010000b
-01110000b ^ 01100001b = 00010001b
-01110000b ^ 01100010b = 00010010b
-01110000b ^ 01100011b = 00010011b
-01110000b ^ 01100100b = 00010100b
-01110000b ^ 01100101b = 00010101b
-01110000b ^ 01100110b = 00010110b
-01110000b ^ 01100111b = 00010111b
-01110000b ^ 01101000b = 00011000b
-01110000b ^ 01101001b = 00011001b
-01110000b ^ 01101010b = 00011010b
-01110000b ^ 01101011b = 00011011b
-01110000b ^ 01101100b = 00011100b
-01110000b ^ 01101101b = 00011101b
-01110000b ^ 01101110b = 00011110b
-01110000b ^ 01101111b = 00011111b
-01110000b ^ 01110000b = 00000000b
-01110000b ^ 01110001b = 00000001b
-01110000b ^ 01110010b = 00000010b
-01110000b ^ 01110011b = 00000011b
-01110000b ^ 01110100b = 00000100b
-01110000b ^ 01110101b = 00000101b
-01110000b ^ 01110110b = 00000110b
-01110000b ^ 01110111b = 00000111b
-01110000b ^ 01111000b = 00001000b
-01110000b ^ 01111001b = 00001001b
-01110000b ^ 01111010b = 00001010b
-01110000b ^ 01111011b = 00001011b
-01110000b ^ 01111100b = 00001100b
-01110000b ^ 01111101b = 00001101b
-01110000b ^ 01111110b = 00001110b
-01110001b ^ 10000000b = 11110001b
-01110001b ^ 10000001b = 11110000b
-01110001b ^ 10000010b = 11110011b
-01110001b ^ 10000011b = 11110010b
-01110001b ^ 10000100b = 11110101b
-01110001b ^ 10000101b = 11110100b
-01110001b ^ 10000110b = 11110111b
-01110001b ^ 10000111b = 11110110b
-01110001b ^ 10001000b = 11111001b
-01110001b ^ 10001001b = 11111000b
-01110001b ^ 10001010b = 11111011b
-01110001b ^ 10001011b = 11111010b
-01110001b ^ 10001100b = 11111101b
-01110001b ^ 10001101b = 11111100b
-01110001b ^ 10001110b = 11111111b
-01110001b ^ 10001111b = 11111110b
-01110001b ^ 10010000b = 11100001b
-01110001b ^ 10010001b = 11100000b
-01110001b ^ 10010010b = 11100011b
-01110001b ^ 10010011b = 11100010b
-01110001b ^ 10010100b = 11100101b
-01110001b ^ 10010101b = 11100100b
-01110001b ^ 10010110b = 11100111b
-01110001b ^ 10010111b = 11100110b
-01110001b ^ 10011000b = 11101001b
-01110001b ^ 10011001b = 11101000b
-01110001b ^ 10011010b = 11101011b
-01110001b ^ 10011011b = 11101010b
-01110001b ^ 10011100b = 11101101b
-01110001b ^ 10011101b = 11101100b
-01110001b ^ 10011110b = 11101111b
-01110001b ^ 10011111b = 11101110b
-01110001b ^ 10100000b = 11010001b
-01110001b ^ 10100001b = 11010000b
-01110001b ^ 10100010b = 11010011b
-01110001b ^ 10100011b = 11010010b
-01110001b ^ 10100100b = 11010101b
-01110001b ^ 10100101b = 11010100b
-01110001b ^ 10100110b = 11010111b
-01110001b ^ 10100111b = 11010110b
-01110001b ^ 10101000b = 11011001b
-01110001b ^ 10101001b = 11011000b
-01110001b ^ 10101010b = 11011011b
-01110001b ^ 10101011b = 11011010b
-01110001b ^ 10101100b = 11011101b
-01110001b ^ 10101101b = 11011100b
-01110001b ^ 10101110b = 11011111b
-01110001b ^ 10101111b = 11011110b
-01110001b ^ 10110000b = 11000001b
-01110001b ^ 10110001b = 11000000b
-01110001b ^ 10110010b = 11000011b
-01110001b ^ 10110011b = 11000010b
-01110001b ^ 10110100b = 11000101b
-01110001b ^ 10110101b = 11000100b
-01110001b ^ 10110110b = 11000111b
-01110001b ^ 10110111b = 11000110b
-01110001b ^ 10111000b = 11001001b
-01110001b ^ 10111001b = 11001000b
-01110001b ^ 10111010b = 11001011b
-01110001b ^ 10111011b = 11001010b
-01110001b ^ 10111100b = 11001101b
-01110001b ^ 10111101b = 11001100b
-01110001b ^ 10111110b = 11001111b
-01110001b ^ 10111111b = 11001110b
-01110001b ^ 11000000b = 10110001b
-01110001b ^ 11000001b = 10110000b
-01110001b ^ 11000010b = 10110011b
-01110001b ^ 11000011b = 10110010b
-01110001b ^ 11000100b = 10110101b
-01110001b ^ 11000101b = 10110100b
-01110001b ^ 11000110b = 10110111b
-01110001b ^ 11000111b = 10110110b
-01110001b ^ 11001000b = 10111001b
-01110001b ^ 11001001b = 10111000b
-01110001b ^ 11001010b = 10111011b
-01110001b ^ 11001011b = 10111010b
-01110001b ^ 11001100b = 10111101b
-01110001b ^ 11001101b = 10111100b
-01110001b ^ 11001110b = 10111111b
-01110001b ^ 11001111b = 10111110b
-01110001b ^ 11010000b = 10100001b
-01110001b ^ 11010001b = 10100000b
-01110001b ^ 11010010b = 10100011b
-01110001b ^ 11010011b = 10100010b
-01110001b ^ 11010100b = 10100101b
-01110001b ^ 11010101b = 10100100b
-01110001b ^ 11010110b = 10100111b
-01110001b ^ 11010111b = 10100110b
-01110001b ^ 11011000b = 10101001b
-01110001b ^ 11011001b = 10101000b
-01110001b ^ 11011010b = 10101011b
-01110001b ^ 11011011b = 10101010b
-01110001b ^ 11011100b = 10101101b
-01110001b ^ 11011101b = 10101100b
-01110001b ^ 11011110b = 10101111b
-01110001b ^ 11011111b = 10101110b
-01110001b ^ 11100000b = 10010001b
-01110001b ^ 11100001b = 10010000b
-01110001b ^ 11100010b = 10010011b
-01110001b ^ 11100011b = 10010010b
-01110001b ^ 11100100b = 10010101b
-01110001b ^ 11100101b = 10010100b
-01110001b ^ 11100110b = 10010111b
-01110001b ^ 11100111b = 10010110b
-01110001b ^ 11101000b = 10011001b
-01110001b ^ 11101001b = 10011000b
-01110001b ^ 11101010b = 10011011b
-01110001b ^ 11101011b = 10011010b
-01110001b ^ 11101100b = 10011101b
-01110001b ^ 11101101b = 10011100b
-01110001b ^ 11101110b = 10011111b
-01110001b ^ 11101111b = 10011110b
-01110001b ^ 11110000b = 10000001b
-01110001b ^ 11110001b = 10000000b
-01110001b ^ 11110010b = 10000011b
-01110001b ^ 11110011b = 10000010b
-01110001b ^ 11110100b = 10000101b
-01110001b ^ 11110101b = 10000100b
-01110001b ^ 11110110b = 10000111b
-01110001b ^ 11110111b = 10000110b
-01110001b ^ 11111000b = 10001001b
-01110001b ^ 11111001b = 10001000b
-01110001b ^ 11111010b = 10001011b
-01110001b ^ 11111011b = 10001010b
-01110001b ^ 11111100b = 10001101b
-01110001b ^ 11111101b = 10001100b
-01110001b ^ 11111110b = 10001111b
-01110001b ^ 11111111b = 10001110b
-01110001b ^ 00000000b = 01110001b
-01110001b ^ 00000001b = 01110000b
-01110001b ^ 00000010b = 01110011b
-01110001b ^ 00000011b = 01110010b
-01110001b ^ 00000100b = 01110101b
-01110001b ^ 00000101b = 01110100b
-01110001b ^ 00000110b = 01110111b
-01110001b ^ 00000111b = 01110110b
-01110001b ^ 00001000b = 01111001b
-01110001b ^ 00001001b = 01111000b
-01110001b ^ 00001010b = 01111011b
-01110001b ^ 00001011b = 01111010b
-01110001b ^ 00001100b = 01111101b
-01110001b ^ 00001101b = 01111100b
-01110001b ^ 00001110b = 01111111b
-01110001b ^ 00001111b = 01111110b
-01110001b ^ 00010000b = 01100001b
-01110001b ^ 00010001b = 01100000b
-01110001b ^ 00010010b = 01100011b
-01110001b ^ 00010011b = 01100010b
-01110001b ^ 00010100b = 01100101b
-01110001b ^ 00010101b = 01100100b
-01110001b ^ 00010110b = 01100111b
-01110001b ^ 00010111b = 01100110b
-01110001b ^ 00011000b = 01101001b
-01110001b ^ 00011001b = 01101000b
-01110001b ^ 00011010b = 01101011b
-01110001b ^ 00011011b = 01101010b
-01110001b ^ 00011100b = 01101101b
-01110001b ^ 00011101b = 01101100b
-01110001b ^ 00011110b = 01101111b
-01110001b ^ 00011111b = 01101110b
-01110001b ^ 00100000b = 01010001b
-01110001b ^ 00100001b = 01010000b
-01110001b ^ 00100010b = 01010011b
-01110001b ^ 00100011b = 01010010b
-01110001b ^ 00100100b = 01010101b
-01110001b ^ 00100101b = 01010100b
-01110001b ^ 00100110b = 01010111b
-01110001b ^ 00100111b = 01010110b
-01110001b ^ 00101000b = 01011001b
-01110001b ^ 00101001b = 01011000b
-01110001b ^ 00101010b = 01011011b
-01110001b ^ 00101011b = 01011010b
-01110001b ^ 00101100b = 01011101b
-01110001b ^ 00101101b = 01011100b
-01110001b ^ 00101110b = 01011111b
-01110001b ^ 00101111b = 01011110b
-01110001b ^ 00110000b = 01000001b
-01110001b ^ 00110001b = 01000000b
-01110001b ^ 00110010b = 01000011b
-01110001b ^ 00110011b = 01000010b
-01110001b ^ 00110100b = 01000101b
-01110001b ^ 00110101b = 01000100b
-01110001b ^ 00110110b = 01000111b
-01110001b ^ 00110111b = 01000110b
-01110001b ^ 00111000b = 01001001b
-01110001b ^ 00111001b = 01001000b
-01110001b ^ 00111010b = 01001011b
-01110001b ^ 00111011b = 01001010b
-01110001b ^ 00111100b = 01001101b
-01110001b ^ 00111101b = 01001100b
-01110001b ^ 00111110b = 01001111b
-01110001b ^ 00111111b = 01001110b
-01110001b ^ 01000000b = 00110001b
-01110001b ^ 01000001b = 00110000b
-01110001b ^ 01000010b = 00110011b
-01110001b ^ 01000011b = 00110010b
-01110001b ^ 01000100b = 00110101b
-01110001b ^ 01000101b = 00110100b
-01110001b ^ 01000110b = 00110111b
-01110001b ^ 01000111b = 00110110b
-01110001b ^ 01001000b = 00111001b
-01110001b ^ 01001001b = 00111000b
-01110001b ^ 01001010b = 00111011b
-01110001b ^ 01001011b = 00111010b
-01110001b ^ 01001100b = 00111101b
-01110001b ^ 01001101b = 00111100b
-01110001b ^ 01001110b = 00111111b
-01110001b ^ 01001111b = 00111110b
-01110001b ^ 01010000b = 00100001b
-01110001b ^ 01010001b = 00100000b
-01110001b ^ 01010010b = 00100011b
-01110001b ^ 01010011b = 00100010b
-01110001b ^ 01010100b = 00100101b
-01110001b ^ 01010101b = 00100100b
-01110001b ^ 01010110b = 00100111b
-01110001b ^ 01010111b = 00100110b
-01110001b ^ 01011000b = 00101001b
-01110001b ^ 01011001b = 00101000b
-01110001b ^ 01011010b = 00101011b
-01110001b ^ 01011011b = 00101010b
-01110001b ^ 01011100b = 00101101b
-01110001b ^ 01011101b = 00101100b
-01110001b ^ 01011110b = 00101111b
-01110001b ^ 01011111b = 00101110b
-01110001b ^ 01100000b = 00010001b
-01110001b ^ 01100001b = 00010000b
-01110001b ^ 01100010b = 00010011b
-01110001b ^ 01100011b = 00010010b
-01110001b ^ 01100100b = 00010101b
-01110001b ^ 01100101b = 00010100b
-01110001b ^ 01100110b = 00010111b
-01110001b ^ 01100111b = 00010110b
-01110001b ^ 01101000b = 00011001b
-01110001b ^ 01101001b = 00011000b
-01110001b ^ 01101010b = 00011011b
-01110001b ^ 01101011b = 00011010b
-01110001b ^ 01101100b = 00011101b
-01110001b ^ 01101101b = 00011100b
-01110001b ^ 01101110b = 00011111b
-01110001b ^ 01101111b = 00011110b
-01110001b ^ 01110000b = 00000001b
-01110001b ^ 01110001b = 00000000b
-01110001b ^ 01110010b = 00000011b
-01110001b ^ 01110011b = 00000010b
-01110001b ^ 01110100b = 00000101b
-01110001b ^ 01110101b = 00000100b
-01110001b ^ 01110110b = 00000111b
-01110001b ^ 01110111b = 00000110b
-01110001b ^ 01111000b = 00001001b
-01110001b ^ 01111001b = 00001000b
-01110001b ^ 01111010b = 00001011b
-01110001b ^ 01111011b = 00001010b
-01110001b ^ 01111100b = 00001101b
-01110001b ^ 01111101b = 00001100b
-01110001b ^ 01111110b = 00001111b
-01110010b ^ 10000000b = 11110010b
-01110010b ^ 10000001b = 11110011b
-01110010b ^ 10000010b = 11110000b
-01110010b ^ 10000011b = 11110001b
-01110010b ^ 10000100b = 11110110b
-01110010b ^ 10000101b = 11110111b
-01110010b ^ 10000110b = 11110100b
-01110010b ^ 10000111b = 11110101b
-01110010b ^ 10001000b = 11111010b
-01110010b ^ 10001001b = 11111011b
-01110010b ^ 10001010b = 11111000b
-01110010b ^ 10001011b = 11111001b
-01110010b ^ 10001100b = 11111110b
-01110010b ^ 10001101b = 11111111b
-01110010b ^ 10001110b = 11111100b
-01110010b ^ 10001111b = 11111101b
-01110010b ^ 10010000b = 11100010b
-01110010b ^ 10010001b = 11100011b
-01110010b ^ 10010010b = 11100000b
-01110010b ^ 10010011b = 11100001b
-01110010b ^ 10010100b = 11100110b
-01110010b ^ 10010101b = 11100111b
-01110010b ^ 10010110b = 11100100b
-01110010b ^ 10010111b = 11100101b
-01110010b ^ 10011000b = 11101010b
-01110010b ^ 10011001b = 11101011b
-01110010b ^ 10011010b = 11101000b
-01110010b ^ 10011011b = 11101001b
-01110010b ^ 10011100b = 11101110b
-01110010b ^ 10011101b = 11101111b
-01110010b ^ 10011110b = 11101100b
-01110010b ^ 10011111b = 11101101b
-01110010b ^ 10100000b = 11010010b
-01110010b ^ 10100001b = 11010011b
-01110010b ^ 10100010b = 11010000b
-01110010b ^ 10100011b = 11010001b
-01110010b ^ 10100100b = 11010110b
-01110010b ^ 10100101b = 11010111b
-01110010b ^ 10100110b = 11010100b
-01110010b ^ 10100111b = 11010101b
-01110010b ^ 10101000b = 11011010b
-01110010b ^ 10101001b = 11011011b
-01110010b ^ 10101010b = 11011000b
-01110010b ^ 10101011b = 11011001b
-01110010b ^ 10101100b = 11011110b
-01110010b ^ 10101101b = 11011111b
-01110010b ^ 10101110b = 11011100b
-01110010b ^ 10101111b = 11011101b
-01110010b ^ 10110000b = 11000010b
-01110010b ^ 10110001b = 11000011b
-01110010b ^ 10110010b = 11000000b
-01110010b ^ 10110011b = 11000001b
-01110010b ^ 10110100b = 11000110b
-01110010b ^ 10110101b = 11000111b
-01110010b ^ 10110110b = 11000100b
-01110010b ^ 10110111b = 11000101b
-01110010b ^ 10111000b = 11001010b
-01110010b ^ 10111001b = 11001011b
-01110010b ^ 10111010b = 11001000b
-01110010b ^ 10111011b = 11001001b
-01110010b ^ 10111100b = 11001110b
-01110010b ^ 10111101b = 11001111b
-01110010b ^ 10111110b = 11001100b
-01110010b ^ 10111111b = 11001101b
-01110010b ^ 11000000b = 10110010b
-01110010b ^ 11000001b = 10110011b
-01110010b ^ 11000010b = 10110000b
-01110010b ^ 11000011b = 10110001b
-01110010b ^ 11000100b = 10110110b
-01110010b ^ 11000101b = 10110111b
-01110010b ^ 11000110b = 10110100b
-01110010b ^ 11000111b = 10110101b
-01110010b ^ 11001000b = 10111010b
-01110010b ^ 11001001b = 10111011b
-01110010b ^ 11001010b = 10111000b
-01110010b ^ 11001011b = 10111001b
-01110010b ^ 11001100b = 10111110b
-01110010b ^ 11001101b = 10111111b
-01110010b ^ 11001110b = 10111100b
-01110010b ^ 11001111b = 10111101b
-01110010b ^ 11010000b = 10100010b
-01110010b ^ 11010001b = 10100011b
-01110010b ^ 11010010b = 10100000b
-01110010b ^ 11010011b = 10100001b
-01110010b ^ 11010100b = 10100110b
-01110010b ^ 11010101b = 10100111b
-01110010b ^ 11010110b = 10100100b
-01110010b ^ 11010111b = 10100101b
-01110010b ^ 11011000b = 10101010b
-01110010b ^ 11011001b = 10101011b
-01110010b ^ 11011010b = 10101000b
-01110010b ^ 11011011b = 10101001b
-01110010b ^ 11011100b = 10101110b
-01110010b ^ 11011101b = 10101111b
-01110010b ^ 11011110b = 10101100b
-01110010b ^ 11011111b = 10101101b
-01110010b ^ 11100000b = 10010010b
-01110010b ^ 11100001b = 10010011b
-01110010b ^ 11100010b = 10010000b
-01110010b ^ 11100011b = 10010001b
-01110010b ^ 11100100b = 10010110b
-01110010b ^ 11100101b = 10010111b
-01110010b ^ 11100110b = 10010100b
-01110010b ^ 11100111b = 10010101b
-01110010b ^ 11101000b = 10011010b
-01110010b ^ 11101001b = 10011011b
-01110010b ^ 11101010b = 10011000b
-01110010b ^ 11101011b = 10011001b
-01110010b ^ 11101100b = 10011110b
-01110010b ^ 11101101b = 10011111b
-01110010b ^ 11101110b = 10011100b
-01110010b ^ 11101111b = 10011101b
-01110010b ^ 11110000b = 10000010b
-01110010b ^ 11110001b = 10000011b
-01110010b ^ 11110010b = 10000000b
-01110010b ^ 11110011b = 10000001b
-01110010b ^ 11110100b = 10000110b
-01110010b ^ 11110101b = 10000111b
-01110010b ^ 11110110b = 10000100b
-01110010b ^ 11110111b = 10000101b
-01110010b ^ 11111000b = 10001010b
-01110010b ^ 11111001b = 10001011b
-01110010b ^ 11111010b = 10001000b
-01110010b ^ 11111011b = 10001001b
-01110010b ^ 11111100b = 10001110b
-01110010b ^ 11111101b = 10001111b
-01110010b ^ 11111110b = 10001100b
-01110010b ^ 11111111b = 10001101b
-01110010b ^ 00000000b = 01110010b
-01110010b ^ 00000001b = 01110011b
-01110010b ^ 00000010b = 01110000b
-01110010b ^ 00000011b = 01110001b
-01110010b ^ 00000100b = 01110110b
-01110010b ^ 00000101b = 01110111b
-01110010b ^ 00000110b = 01110100b
-01110010b ^ 00000111b = 01110101b
-01110010b ^ 00001000b = 01111010b
-01110010b ^ 00001001b = 01111011b
-01110010b ^ 00001010b = 01111000b
-01110010b ^ 00001011b = 01111001b
-01110010b ^ 00001100b = 01111110b
-01110010b ^ 00001101b = 01111111b
-01110010b ^ 00001110b = 01111100b
-01110010b ^ 00001111b = 01111101b
-01110010b ^ 00010000b = 01100010b
-01110010b ^ 00010001b = 01100011b
-01110010b ^ 00010010b = 01100000b
-01110010b ^ 00010011b = 01100001b
-01110010b ^ 00010100b = 01100110b
-01110010b ^ 00010101b = 01100111b
-01110010b ^ 00010110b = 01100100b
-01110010b ^ 00010111b = 01100101b
-01110010b ^ 00011000b = 01101010b
-01110010b ^ 00011001b = 01101011b
-01110010b ^ 00011010b = 01101000b
-01110010b ^ 00011011b = 01101001b
-01110010b ^ 00011100b = 01101110b
-01110010b ^ 00011101b = 01101111b
-01110010b ^ 00011110b = 01101100b
-01110010b ^ 00011111b = 01101101b
-01110010b ^ 00100000b = 01010010b
-01110010b ^ 00100001b = 01010011b
-01110010b ^ 00100010b = 01010000b
-01110010b ^ 00100011b = 01010001b
-01110010b ^ 00100100b = 01010110b
-01110010b ^ 00100101b = 01010111b
-01110010b ^ 00100110b = 01010100b
-01110010b ^ 00100111b = 01010101b
-01110010b ^ 00101000b = 01011010b
-01110010b ^ 00101001b = 01011011b
-01110010b ^ 00101010b = 01011000b
-01110010b ^ 00101011b = 01011001b
-01110010b ^ 00101100b = 01011110b
-01110010b ^ 00101101b = 01011111b
-01110010b ^ 00101110b = 01011100b
-01110010b ^ 00101111b = 01011101b
-01110010b ^ 00110000b = 01000010b
-01110010b ^ 00110001b = 01000011b
-01110010b ^ 00110010b = 01000000b
-01110010b ^ 00110011b = 01000001b
-01110010b ^ 00110100b = 01000110b
-01110010b ^ 00110101b = 01000111b
-01110010b ^ 00110110b = 01000100b
-01110010b ^ 00110111b = 01000101b
-01110010b ^ 00111000b = 01001010b
-01110010b ^ 00111001b = 01001011b
-01110010b ^ 00111010b = 01001000b
-01110010b ^ 00111011b = 01001001b
-01110010b ^ 00111100b = 01001110b
-01110010b ^ 00111101b = 01001111b
-01110010b ^ 00111110b = 01001100b
-01110010b ^ 00111111b = 01001101b
-01110010b ^ 01000000b = 00110010b
-01110010b ^ 01000001b = 00110011b
-01110010b ^ 01000010b = 00110000b
-01110010b ^ 01000011b = 00110001b
-01110010b ^ 01000100b = 00110110b
-01110010b ^ 01000101b = 00110111b
-01110010b ^ 01000110b = 00110100b
-01110010b ^ 01000111b = 00110101b
-01110010b ^ 01001000b = 00111010b
-01110010b ^ 01001001b = 00111011b
-01110010b ^ 01001010b = 00111000b
-01110010b ^ 01001011b = 00111001b
-01110010b ^ 01001100b = 00111110b
-01110010b ^ 01001101b = 00111111b
-01110010b ^ 01001110b = 00111100b
-01110010b ^ 01001111b = 00111101b
-01110010b ^ 01010000b = 00100010b
-01110010b ^ 01010001b = 00100011b
-01110010b ^ 01010010b = 00100000b
-01110010b ^ 01010011b = 00100001b
-01110010b ^ 01010100b = 00100110b
-01110010b ^ 01010101b = 00100111b
-01110010b ^ 01010110b = 00100100b
-01110010b ^ 01010111b = 00100101b
-01110010b ^ 01011000b = 00101010b
-01110010b ^ 01011001b = 00101011b
-01110010b ^ 01011010b = 00101000b
-01110010b ^ 01011011b = 00101001b
-01110010b ^ 01011100b = 00101110b
-01110010b ^ 01011101b = 00101111b
-01110010b ^ 01011110b = 00101100b
-01110010b ^ 01011111b = 00101101b
-01110010b ^ 01100000b = 00010010b
-01110010b ^ 01100001b = 00010011b
-01110010b ^ 01100010b = 00010000b
-01110010b ^ 01100011b = 00010001b
-01110010b ^ 01100100b = 00010110b
-01110010b ^ 01100101b = 00010111b
-01110010b ^ 01100110b = 00010100b
-01110010b ^ 01100111b = 00010101b
-01110010b ^ 01101000b = 00011010b
-01110010b ^ 01101001b = 00011011b
-01110010b ^ 01101010b = 00011000b
-01110010b ^ 01101011b = 00011001b
-01110010b ^ 01101100b = 00011110b
-01110010b ^ 01101101b = 00011111b
-01110010b ^ 01101110b = 00011100b
-01110010b ^ 01101111b = 00011101b
-01110010b ^ 01110000b = 00000010b
-01110010b ^ 01110001b = 00000011b
-01110010b ^ 01110010b = 00000000b
-01110010b ^ 01110011b = 00000001b
-01110010b ^ 01110100b = 00000110b
-01110010b ^ 01110101b = 00000111b
-01110010b ^ 01110110b = 00000100b
-01110010b ^ 01110111b = 00000101b
-01110010b ^ 01111000b = 00001010b
-01110010b ^ 01111001b = 00001011b
-01110010b ^ 01111010b = 00001000b
-01110010b ^ 01111011b = 00001001b
-01110010b ^ 01111100b = 00001110b
-01110010b ^ 01111101b = 00001111b
-01110010b ^ 01111110b = 00001100b
-01110011b ^ 10000000b = 11110011b
-01110011b ^ 10000001b = 11110010b
-01110011b ^ 10000010b = 11110001b
-01110011b ^ 10000011b = 11110000b
-01110011b ^ 10000100b = 11110111b
-01110011b ^ 10000101b = 11110110b
-01110011b ^ 10000110b = 11110101b
-01110011b ^ 10000111b = 11110100b
-01110011b ^ 10001000b = 11111011b
-01110011b ^ 10001001b = 11111010b
-01110011b ^ 10001010b = 11111001b
-01110011b ^ 10001011b = 11111000b
-01110011b ^ 10001100b = 11111111b
-01110011b ^ 10001101b = 11111110b
-01110011b ^ 10001110b = 11111101b
-01110011b ^ 10001111b = 11111100b
-01110011b ^ 10010000b = 11100011b
-01110011b ^ 10010001b = 11100010b
-01110011b ^ 10010010b = 11100001b
-01110011b ^ 10010011b = 11100000b
-01110011b ^ 10010100b = 11100111b
-01110011b ^ 10010101b = 11100110b
-01110011b ^ 10010110b = 11100101b
-01110011b ^ 10010111b = 11100100b
-01110011b ^ 10011000b = 11101011b
-01110011b ^ 10011001b = 11101010b
-01110011b ^ 10011010b = 11101001b
-01110011b ^ 10011011b = 11101000b
-01110011b ^ 10011100b = 11101111b
-01110011b ^ 10011101b = 11101110b
-01110011b ^ 10011110b = 11101101b
-01110011b ^ 10011111b = 11101100b
-01110011b ^ 10100000b = 11010011b
-01110011b ^ 10100001b = 11010010b
-01110011b ^ 10100010b = 11010001b
-01110011b ^ 10100011b = 11010000b
-01110011b ^ 10100100b = 11010111b
-01110011b ^ 10100101b = 11010110b
-01110011b ^ 10100110b = 11010101b
-01110011b ^ 10100111b = 11010100b
-01110011b ^ 10101000b = 11011011b
-01110011b ^ 10101001b = 11011010b
-01110011b ^ 10101010b = 11011001b
-01110011b ^ 10101011b = 11011000b
-01110011b ^ 10101100b = 11011111b
-01110011b ^ 10101101b = 11011110b
-01110011b ^ 10101110b = 11011101b
-01110011b ^ 10101111b = 11011100b
-01110011b ^ 10110000b = 11000011b
-01110011b ^ 10110001b = 11000010b
-01110011b ^ 10110010b = 11000001b
-01110011b ^ 10110011b = 11000000b
-01110011b ^ 10110100b = 11000111b
-01110011b ^ 10110101b = 11000110b
-01110011b ^ 10110110b = 11000101b
-01110011b ^ 10110111b = 11000100b
-01110011b ^ 10111000b = 11001011b
-01110011b ^ 10111001b = 11001010b
-01110011b ^ 10111010b = 11001001b
-01110011b ^ 10111011b = 11001000b
-01110011b ^ 10111100b = 11001111b
-01110011b ^ 10111101b = 11001110b
-01110011b ^ 10111110b = 11001101b
-01110011b ^ 10111111b = 11001100b
-01110011b ^ 11000000b = 10110011b
-01110011b ^ 11000001b = 10110010b
-01110011b ^ 11000010b = 10110001b
-01110011b ^ 11000011b = 10110000b
-01110011b ^ 11000100b = 10110111b
-01110011b ^ 11000101b = 10110110b
-01110011b ^ 11000110b = 10110101b
-01110011b ^ 11000111b = 10110100b
-01110011b ^ 11001000b = 10111011b
-01110011b ^ 11001001b = 10111010b
-01110011b ^ 11001010b = 10111001b
-01110011b ^ 11001011b = 10111000b
-01110011b ^ 11001100b = 10111111b
-01110011b ^ 11001101b = 10111110b
-01110011b ^ 11001110b = 10111101b
-01110011b ^ 11001111b = 10111100b
-01110011b ^ 11010000b = 10100011b
-01110011b ^ 11010001b = 10100010b
-01110011b ^ 11010010b = 10100001b
-01110011b ^ 11010011b = 10100000b
-01110011b ^ 11010100b = 10100111b
-01110011b ^ 11010101b = 10100110b
-01110011b ^ 11010110b = 10100101b
-01110011b ^ 11010111b = 10100100b
-01110011b ^ 11011000b = 10101011b
-01110011b ^ 11011001b = 10101010b
-01110011b ^ 11011010b = 10101001b
-01110011b ^ 11011011b = 10101000b
-01110011b ^ 11011100b = 10101111b
-01110011b ^ 11011101b = 10101110b
-01110011b ^ 11011110b = 10101101b
-01110011b ^ 11011111b = 10101100b
-01110011b ^ 11100000b = 10010011b
-01110011b ^ 11100001b = 10010010b
-01110011b ^ 11100010b = 10010001b
-01110011b ^ 11100011b = 10010000b
-01110011b ^ 11100100b = 10010111b
-01110011b ^ 11100101b = 10010110b
-01110011b ^ 11100110b = 10010101b
-01110011b ^ 11100111b = 10010100b
-01110011b ^ 11101000b = 10011011b
-01110011b ^ 11101001b = 10011010b
-01110011b ^ 11101010b = 10011001b
-01110011b ^ 11101011b = 10011000b
-01110011b ^ 11101100b = 10011111b
-01110011b ^ 11101101b = 10011110b
-01110011b ^ 11101110b = 10011101b
-01110011b ^ 11101111b = 10011100b
-01110011b ^ 11110000b = 10000011b
-01110011b ^ 11110001b = 10000010b
-01110011b ^ 11110010b = 10000001b
-01110011b ^ 11110011b = 10000000b
-01110011b ^ 11110100b = 10000111b
-01110011b ^ 11110101b = 10000110b
-01110011b ^ 11110110b = 10000101b
-01110011b ^ 11110111b = 10000100b
-01110011b ^ 11111000b = 10001011b
-01110011b ^ 11111001b = 10001010b
-01110011b ^ 11111010b = 10001001b
-01110011b ^ 11111011b = 10001000b
-01110011b ^ 11111100b = 10001111b
-01110011b ^ 11111101b = 10001110b
-01110011b ^ 11111110b = 10001101b
-01110011b ^ 11111111b = 10001100b
-01110011b ^ 00000000b = 01110011b
-01110011b ^ 00000001b = 01110010b
-01110011b ^ 00000010b = 01110001b
-01110011b ^ 00000011b = 01110000b
-01110011b ^ 00000100b = 01110111b
-01110011b ^ 00000101b = 01110110b
-01110011b ^ 00000110b = 01110101b
-01110011b ^ 00000111b = 01110100b
-01110011b ^ 00001000b = 01111011b
-01110011b ^ 00001001b = 01111010b
-01110011b ^ 00001010b = 01111001b
-01110011b ^ 00001011b = 01111000b
-01110011b ^ 00001100b = 01111111b
-01110011b ^ 00001101b = 01111110b
-01110011b ^ 00001110b = 01111101b
-01110011b ^ 00001111b = 01111100b
-01110011b ^ 00010000b = 01100011b
-01110011b ^ 00010001b = 01100010b
-01110011b ^ 00010010b = 01100001b
-01110011b ^ 00010011b = 01100000b
-01110011b ^ 00010100b = 01100111b
-01110011b ^ 00010101b = 01100110b
-01110011b ^ 00010110b = 01100101b
-01110011b ^ 00010111b = 01100100b
-01110011b ^ 00011000b = 01101011b
-01110011b ^ 00011001b = 01101010b
-01110011b ^ 00011010b = 01101001b
-01110011b ^ 00011011b = 01101000b
-01110011b ^ 00011100b = 01101111b
-01110011b ^ 00011101b = 01101110b
-01110011b ^ 00011110b = 01101101b
-01110011b ^ 00011111b = 01101100b
-01110011b ^ 00100000b = 01010011b
-01110011b ^ 00100001b = 01010010b
-01110011b ^ 00100010b = 01010001b
-01110011b ^ 00100011b = 01010000b
-01110011b ^ 00100100b = 01010111b
-01110011b ^ 00100101b = 01010110b
-01110011b ^ 00100110b = 01010101b
-01110011b ^ 00100111b = 01010100b
-01110011b ^ 00101000b = 01011011b
-01110011b ^ 00101001b = 01011010b
-01110011b ^ 00101010b = 01011001b
-01110011b ^ 00101011b = 01011000b
-01110011b ^ 00101100b = 01011111b
-01110011b ^ 00101101b = 01011110b
-01110011b ^ 00101110b = 01011101b
-01110011b ^ 00101111b = 01011100b
-01110011b ^ 00110000b = 01000011b
-01110011b ^ 00110001b = 01000010b
-01110011b ^ 00110010b = 01000001b
-01110011b ^ 00110011b = 01000000b
-01110011b ^ 00110100b = 01000111b
-01110011b ^ 00110101b = 01000110b
-01110011b ^ 00110110b = 01000101b
-01110011b ^ 00110111b = 01000100b
-01110011b ^ 00111000b = 01001011b
-01110011b ^ 00111001b = 01001010b
-01110011b ^ 00111010b = 01001001b
-01110011b ^ 00111011b = 01001000b
-01110011b ^ 00111100b = 01001111b
-01110011b ^ 00111101b = 01001110b
-01110011b ^ 00111110b = 01001101b
-01110011b ^ 00111111b = 01001100b
-01110011b ^ 01000000b = 00110011b
-01110011b ^ 01000001b = 00110010b
-01110011b ^ 01000010b = 00110001b
-01110011b ^ 01000011b = 00110000b
-01110011b ^ 01000100b = 00110111b
-01110011b ^ 01000101b = 00110110b
-01110011b ^ 01000110b = 00110101b
-01110011b ^ 01000111b = 00110100b
-01110011b ^ 01001000b = 00111011b
-01110011b ^ 01001001b = 00111010b
-01110011b ^ 01001010b = 00111001b
-01110011b ^ 01001011b = 00111000b
-01110011b ^ 01001100b = 00111111b
-01110011b ^ 01001101b = 00111110b
-01110011b ^ 01001110b = 00111101b
-01110011b ^ 01001111b = 00111100b
-01110011b ^ 01010000b = 00100011b
-01110011b ^ 01010001b = 00100010b
-01110011b ^ 01010010b = 00100001b
-01110011b ^ 01010011b = 00100000b
-01110011b ^ 01010100b = 00100111b
-01110011b ^ 01010101b = 00100110b
-01110011b ^ 01010110b = 00100101b
-01110011b ^ 01010111b = 00100100b
-01110011b ^ 01011000b = 00101011b
-01110011b ^ 01011001b = 00101010b
-01110011b ^ 01011010b = 00101001b
-01110011b ^ 01011011b = 00101000b
-01110011b ^ 01011100b = 00101111b
-01110011b ^ 01011101b = 00101110b
-01110011b ^ 01011110b = 00101101b
-01110011b ^ 01011111b = 00101100b
-01110011b ^ 01100000b = 00010011b
-01110011b ^ 01100001b = 00010010b
-01110011b ^ 01100010b = 00010001b
-01110011b ^ 01100011b = 00010000b
-01110011b ^ 01100100b = 00010111b
-01110011b ^ 01100101b = 00010110b
-01110011b ^ 01100110b = 00010101b
-01110011b ^ 01100111b = 00010100b
-01110011b ^ 01101000b = 00011011b
-01110011b ^ 01101001b = 00011010b
-01110011b ^ 01101010b = 00011001b
-01110011b ^ 01101011b = 00011000b
-01110011b ^ 01101100b = 00011111b
-01110011b ^ 01101101b = 00011110b
-01110011b ^ 01101110b = 00011101b
-01110011b ^ 01101111b = 00011100b
-01110011b ^ 01110000b = 00000011b
-01110011b ^ 01110001b = 00000010b
-01110011b ^ 01110010b = 00000001b
-01110011b ^ 01110011b = 00000000b
-01110011b ^ 01110100b = 00000111b
-01110011b ^ 01110101b = 00000110b
-01110011b ^ 01110110b = 00000101b
-01110011b ^ 01110111b = 00000100b
-01110011b ^ 01111000b = 00001011b
-01110011b ^ 01111001b = 00001010b
-01110011b ^ 01111010b = 00001001b
-01110011b ^ 01111011b = 00001000b
-01110011b ^ 01111100b = 00001111b
-01110011b ^ 01111101b = 00001110b
-01110011b ^ 01111110b = 00001101b
-01110100b ^ 10000000b = 11110100b
-01110100b ^ 10000001b = 11110101b
-01110100b ^ 10000010b = 11110110b
-01110100b ^ 10000011b = 11110111b
-01110100b ^ 10000100b = 11110000b
-01110100b ^ 10000101b = 11110001b
-01110100b ^ 10000110b = 11110010b
-01110100b ^ 10000111b = 11110011b
-01110100b ^ 10001000b = 11111100b
-01110100b ^ 10001001b = 11111101b
-01110100b ^ 10001010b = 11111110b
-01110100b ^ 10001011b = 11111111b
-01110100b ^ 10001100b = 11111000b
-01110100b ^ 10001101b = 11111001b
-01110100b ^ 10001110b = 11111010b
-01110100b ^ 10001111b = 11111011b
-01110100b ^ 10010000b = 11100100b
-01110100b ^ 10010001b = 11100101b
-01110100b ^ 10010010b = 11100110b
-01110100b ^ 10010011b = 11100111b
-01110100b ^ 10010100b = 11100000b
-01110100b ^ 10010101b = 11100001b
-01110100b ^ 10010110b = 11100010b
-01110100b ^ 10010111b = 11100011b
-01110100b ^ 10011000b = 11101100b
-01110100b ^ 10011001b = 11101101b
-01110100b ^ 10011010b = 11101110b
-01110100b ^ 10011011b = 11101111b
-01110100b ^ 10011100b = 11101000b
-01110100b ^ 10011101b = 11101001b
-01110100b ^ 10011110b = 11101010b
-01110100b ^ 10011111b = 11101011b
-01110100b ^ 10100000b = 11010100b
-01110100b ^ 10100001b = 11010101b
-01110100b ^ 10100010b = 11010110b
-01110100b ^ 10100011b = 11010111b
-01110100b ^ 10100100b = 11010000b
-01110100b ^ 10100101b = 11010001b
-01110100b ^ 10100110b = 11010010b
-01110100b ^ 10100111b = 11010011b
-01110100b ^ 10101000b = 11011100b
-01110100b ^ 10101001b = 11011101b
-01110100b ^ 10101010b = 11011110b
-01110100b ^ 10101011b = 11011111b
-01110100b ^ 10101100b = 11011000b
-01110100b ^ 10101101b = 11011001b
-01110100b ^ 10101110b = 11011010b
-01110100b ^ 10101111b = 11011011b
-01110100b ^ 10110000b = 11000100b
-01110100b ^ 10110001b = 11000101b
-01110100b ^ 10110010b = 11000110b
-01110100b ^ 10110011b = 11000111b
-01110100b ^ 10110100b = 11000000b
-01110100b ^ 10110101b = 11000001b
-01110100b ^ 10110110b = 11000010b
-01110100b ^ 10110111b = 11000011b
-01110100b ^ 10111000b = 11001100b
-01110100b ^ 10111001b = 11001101b
-01110100b ^ 10111010b = 11001110b
-01110100b ^ 10111011b = 11001111b
-01110100b ^ 10111100b = 11001000b
-01110100b ^ 10111101b = 11001001b
-01110100b ^ 10111110b = 11001010b
-01110100b ^ 10111111b = 11001011b
-01110100b ^ 11000000b = 10110100b
-01110100b ^ 11000001b = 10110101b
-01110100b ^ 11000010b = 10110110b
-01110100b ^ 11000011b = 10110111b
-01110100b ^ 11000100b = 10110000b
-01110100b ^ 11000101b = 10110001b
-01110100b ^ 11000110b = 10110010b
-01110100b ^ 11000111b = 10110011b
-01110100b ^ 11001000b = 10111100b
-01110100b ^ 11001001b = 10111101b
-01110100b ^ 11001010b = 10111110b
-01110100b ^ 11001011b = 10111111b
-01110100b ^ 11001100b = 10111000b
-01110100b ^ 11001101b = 10111001b
-01110100b ^ 11001110b = 10111010b
-01110100b ^ 11001111b = 10111011b
-01110100b ^ 11010000b = 10100100b
-01110100b ^ 11010001b = 10100101b
-01110100b ^ 11010010b = 10100110b
-01110100b ^ 11010011b = 10100111b
-01110100b ^ 11010100b = 10100000b
-01110100b ^ 11010101b = 10100001b
-01110100b ^ 11010110b = 10100010b
-01110100b ^ 11010111b = 10100011b
-01110100b ^ 11011000b = 10101100b
-01110100b ^ 11011001b = 10101101b
-01110100b ^ 11011010b = 10101110b
-01110100b ^ 11011011b = 10101111b
-01110100b ^ 11011100b = 10101000b
-01110100b ^ 11011101b = 10101001b
-01110100b ^ 11011110b = 10101010b
-01110100b ^ 11011111b = 10101011b
-01110100b ^ 11100000b = 10010100b
-01110100b ^ 11100001b = 10010101b
-01110100b ^ 11100010b = 10010110b
-01110100b ^ 11100011b = 10010111b
-01110100b ^ 11100100b = 10010000b
-01110100b ^ 11100101b = 10010001b
-01110100b ^ 11100110b = 10010010b
-01110100b ^ 11100111b = 10010011b
-01110100b ^ 11101000b = 10011100b
-01110100b ^ 11101001b = 10011101b
-01110100b ^ 11101010b = 10011110b
-01110100b ^ 11101011b = 10011111b
-01110100b ^ 11101100b = 10011000b
-01110100b ^ 11101101b = 10011001b
-01110100b ^ 11101110b = 10011010b
-01110100b ^ 11101111b = 10011011b
-01110100b ^ 11110000b = 10000100b
-01110100b ^ 11110001b = 10000101b
-01110100b ^ 11110010b = 10000110b
-01110100b ^ 11110011b = 10000111b
-01110100b ^ 11110100b = 10000000b
-01110100b ^ 11110101b = 10000001b
-01110100b ^ 11110110b = 10000010b
-01110100b ^ 11110111b = 10000011b
-01110100b ^ 11111000b = 10001100b
-01110100b ^ 11111001b = 10001101b
-01110100b ^ 11111010b = 10001110b
-01110100b ^ 11111011b = 10001111b
-01110100b ^ 11111100b = 10001000b
-01110100b ^ 11111101b = 10001001b
-01110100b ^ 11111110b = 10001010b
-01110100b ^ 11111111b = 10001011b
-01110100b ^ 00000000b = 01110100b
-01110100b ^ 00000001b = 01110101b
-01110100b ^ 00000010b = 01110110b
-01110100b ^ 00000011b = 01110111b
-01110100b ^ 00000100b = 01110000b
-01110100b ^ 00000101b = 01110001b
-01110100b ^ 00000110b = 01110010b
-01110100b ^ 00000111b = 01110011b
-01110100b ^ 00001000b = 01111100b
-01110100b ^ 00001001b = 01111101b
-01110100b ^ 00001010b = 01111110b
-01110100b ^ 00001011b = 01111111b
-01110100b ^ 00001100b = 01111000b
-01110100b ^ 00001101b = 01111001b
-01110100b ^ 00001110b = 01111010b
-01110100b ^ 00001111b = 01111011b
-01110100b ^ 00010000b = 01100100b
-01110100b ^ 00010001b = 01100101b
-01110100b ^ 00010010b = 01100110b
-01110100b ^ 00010011b = 01100111b
-01110100b ^ 00010100b = 01100000b
-01110100b ^ 00010101b = 01100001b
-01110100b ^ 00010110b = 01100010b
-01110100b ^ 00010111b = 01100011b
-01110100b ^ 00011000b = 01101100b
-01110100b ^ 00011001b = 01101101b
-01110100b ^ 00011010b = 01101110b
-01110100b ^ 00011011b = 01101111b
-01110100b ^ 00011100b = 01101000b
-01110100b ^ 00011101b = 01101001b
-01110100b ^ 00011110b = 01101010b
-01110100b ^ 00011111b = 01101011b
-01110100b ^ 00100000b = 01010100b
-01110100b ^ 00100001b = 01010101b
-01110100b ^ 00100010b = 01010110b
-01110100b ^ 00100011b = 01010111b
-01110100b ^ 00100100b = 01010000b
-01110100b ^ 00100101b = 01010001b
-01110100b ^ 00100110b = 01010010b
-01110100b ^ 00100111b = 01010011b
-01110100b ^ 00101000b = 01011100b
-01110100b ^ 00101001b = 01011101b
-01110100b ^ 00101010b = 01011110b
-01110100b ^ 00101011b = 01011111b
-01110100b ^ 00101100b = 01011000b
-01110100b ^ 00101101b = 01011001b
-01110100b ^ 00101110b = 01011010b
-01110100b ^ 00101111b = 01011011b
-01110100b ^ 00110000b = 01000100b
-01110100b ^ 00110001b = 01000101b
-01110100b ^ 00110010b = 01000110b
-01110100b ^ 00110011b = 01000111b
-01110100b ^ 00110100b = 01000000b
-01110100b ^ 00110101b = 01000001b
-01110100b ^ 00110110b = 01000010b
-01110100b ^ 00110111b = 01000011b
-01110100b ^ 00111000b = 01001100b
-01110100b ^ 00111001b = 01001101b
-01110100b ^ 00111010b = 01001110b
-01110100b ^ 00111011b = 01001111b
-01110100b ^ 00111100b = 01001000b
-01110100b ^ 00111101b = 01001001b
-01110100b ^ 00111110b = 01001010b
-01110100b ^ 00111111b = 01001011b
-01110100b ^ 01000000b = 00110100b
-01110100b ^ 01000001b = 00110101b
-01110100b ^ 01000010b = 00110110b
-01110100b ^ 01000011b = 00110111b
-01110100b ^ 01000100b = 00110000b
-01110100b ^ 01000101b = 00110001b
-01110100b ^ 01000110b = 00110010b
-01110100b ^ 01000111b = 00110011b
-01110100b ^ 01001000b = 00111100b
-01110100b ^ 01001001b = 00111101b
-01110100b ^ 01001010b = 00111110b
-01110100b ^ 01001011b = 00111111b
-01110100b ^ 01001100b = 00111000b
-01110100b ^ 01001101b = 00111001b
-01110100b ^ 01001110b = 00111010b
-01110100b ^ 01001111b = 00111011b
-01110100b ^ 01010000b = 00100100b
-01110100b ^ 01010001b = 00100101b
-01110100b ^ 01010010b = 00100110b
-01110100b ^ 01010011b = 00100111b
-01110100b ^ 01010100b = 00100000b
-01110100b ^ 01010101b = 00100001b
-01110100b ^ 01010110b = 00100010b
-01110100b ^ 01010111b = 00100011b
-01110100b ^ 01011000b = 00101100b
-01110100b ^ 01011001b = 00101101b
-01110100b ^ 01011010b = 00101110b
-01110100b ^ 01011011b = 00101111b
-01110100b ^ 01011100b = 00101000b
-01110100b ^ 01011101b = 00101001b
-01110100b ^ 01011110b = 00101010b
-01110100b ^ 01011111b = 00101011b
-01110100b ^ 01100000b = 00010100b
-01110100b ^ 01100001b = 00010101b
-01110100b ^ 01100010b = 00010110b
-01110100b ^ 01100011b = 00010111b
-01110100b ^ 01100100b = 00010000b
-01110100b ^ 01100101b = 00010001b
-01110100b ^ 01100110b = 00010010b
-01110100b ^ 01100111b = 00010011b
-01110100b ^ 01101000b = 00011100b
-01110100b ^ 01101001b = 00011101b
-01110100b ^ 01101010b = 00011110b
-01110100b ^ 01101011b = 00011111b
-01110100b ^ 01101100b = 00011000b
-01110100b ^ 01101101b = 00011001b
-01110100b ^ 01101110b = 00011010b
-01110100b ^ 01101111b = 00011011b
-01110100b ^ 01110000b = 00000100b
-01110100b ^ 01110001b = 00000101b
-01110100b ^ 01110010b = 00000110b
-01110100b ^ 01110011b = 00000111b
-01110100b ^ 01110100b = 00000000b
-01110100b ^ 01110101b = 00000001b
-01110100b ^ 01110110b = 00000010b
-01110100b ^ 01110111b = 00000011b
-01110100b ^ 01111000b = 00001100b
-01110100b ^ 01111001b = 00001101b
-01110100b ^ 01111010b = 00001110b
-01110100b ^ 01111011b = 00001111b
-01110100b ^ 01111100b = 00001000b
-01110100b ^ 01111101b = 00001001b
-01110100b ^ 01111110b = 00001010b
-01110101b ^ 10000000b = 11110101b
-01110101b ^ 10000001b = 11110100b
-01110101b ^ 10000010b = 11110111b
-01110101b ^ 10000011b = 11110110b
-01110101b ^ 10000100b = 11110001b
-01110101b ^ 10000101b = 11110000b
-01110101b ^ 10000110b = 11110011b
-01110101b ^ 10000111b = 11110010b
-01110101b ^ 10001000b = 11111101b
-01110101b ^ 10001001b = 11111100b
-01110101b ^ 10001010b = 11111111b
-01110101b ^ 10001011b = 11111110b
-01110101b ^ 10001100b = 11111001b
-01110101b ^ 10001101b = 11111000b
-01110101b ^ 10001110b = 11111011b
-01110101b ^ 10001111b = 11111010b
-01110101b ^ 10010000b = 11100101b
-01110101b ^ 10010001b = 11100100b
-01110101b ^ 10010010b = 11100111b
-01110101b ^ 10010011b = 11100110b
-01110101b ^ 10010100b = 11100001b
-01110101b ^ 10010101b = 11100000b
-01110101b ^ 10010110b = 11100011b
-01110101b ^ 10010111b = 11100010b
-01110101b ^ 10011000b = 11101101b
-01110101b ^ 10011001b = 11101100b
-01110101b ^ 10011010b = 11101111b
-01110101b ^ 10011011b = 11101110b
-01110101b ^ 10011100b = 11101001b
-01110101b ^ 10011101b = 11101000b
-01110101b ^ 10011110b = 11101011b
-01110101b ^ 10011111b = 11101010b
-01110101b ^ 10100000b = 11010101b
-01110101b ^ 10100001b = 11010100b
-01110101b ^ 10100010b = 11010111b
-01110101b ^ 10100011b = 11010110b
-01110101b ^ 10100100b = 11010001b
-01110101b ^ 10100101b = 11010000b
-01110101b ^ 10100110b = 11010011b
-01110101b ^ 10100111b = 11010010b
-01110101b ^ 10101000b = 11011101b
-01110101b ^ 10101001b = 11011100b
-01110101b ^ 10101010b = 11011111b
-01110101b ^ 10101011b = 11011110b
-01110101b ^ 10101100b = 11011001b
-01110101b ^ 10101101b = 11011000b
-01110101b ^ 10101110b = 11011011b
-01110101b ^ 10101111b = 11011010b
-01110101b ^ 10110000b = 11000101b
-01110101b ^ 10110001b = 11000100b
-01110101b ^ 10110010b = 11000111b
-01110101b ^ 10110011b = 11000110b
-01110101b ^ 10110100b = 11000001b
-01110101b ^ 10110101b = 11000000b
-01110101b ^ 10110110b = 11000011b
-01110101b ^ 10110111b = 11000010b
-01110101b ^ 10111000b = 11001101b
-01110101b ^ 10111001b = 11001100b
-01110101b ^ 10111010b = 11001111b
-01110101b ^ 10111011b = 11001110b
-01110101b ^ 10111100b = 11001001b
-01110101b ^ 10111101b = 11001000b
-01110101b ^ 10111110b = 11001011b
-01110101b ^ 10111111b = 11001010b
-01110101b ^ 11000000b = 10110101b
-01110101b ^ 11000001b = 10110100b
-01110101b ^ 11000010b = 10110111b
-01110101b ^ 11000011b = 10110110b
-01110101b ^ 11000100b = 10110001b
-01110101b ^ 11000101b = 10110000b
-01110101b ^ 11000110b = 10110011b
-01110101b ^ 11000111b = 10110010b
-01110101b ^ 11001000b = 10111101b
-01110101b ^ 11001001b = 10111100b
-01110101b ^ 11001010b = 10111111b
-01110101b ^ 11001011b = 10111110b
-01110101b ^ 11001100b = 10111001b
-01110101b ^ 11001101b = 10111000b
-01110101b ^ 11001110b = 10111011b
-01110101b ^ 11001111b = 10111010b
-01110101b ^ 11010000b = 10100101b
-01110101b ^ 11010001b = 10100100b
-01110101b ^ 11010010b = 10100111b
-01110101b ^ 11010011b = 10100110b
-01110101b ^ 11010100b = 10100001b
-01110101b ^ 11010101b = 10100000b
-01110101b ^ 11010110b = 10100011b
-01110101b ^ 11010111b = 10100010b
-01110101b ^ 11011000b = 10101101b
-01110101b ^ 11011001b = 10101100b
-01110101b ^ 11011010b = 10101111b
-01110101b ^ 11011011b = 10101110b
-01110101b ^ 11011100b = 10101001b
-01110101b ^ 11011101b = 10101000b
-01110101b ^ 11011110b = 10101011b
-01110101b ^ 11011111b = 10101010b
-01110101b ^ 11100000b = 10010101b
-01110101b ^ 11100001b = 10010100b
-01110101b ^ 11100010b = 10010111b
-01110101b ^ 11100011b = 10010110b
-01110101b ^ 11100100b = 10010001b
-01110101b ^ 11100101b = 10010000b
-01110101b ^ 11100110b = 10010011b
-01110101b ^ 11100111b = 10010010b
-01110101b ^ 11101000b = 10011101b
-01110101b ^ 11101001b = 10011100b
-01110101b ^ 11101010b = 10011111b
-01110101b ^ 11101011b = 10011110b
-01110101b ^ 11101100b = 10011001b
-01110101b ^ 11101101b = 10011000b
-01110101b ^ 11101110b = 10011011b
-01110101b ^ 11101111b = 10011010b
-01110101b ^ 11110000b = 10000101b
-01110101b ^ 11110001b = 10000100b
-01110101b ^ 11110010b = 10000111b
-01110101b ^ 11110011b = 10000110b
-01110101b ^ 11110100b = 10000001b
-01110101b ^ 11110101b = 10000000b
-01110101b ^ 11110110b = 10000011b
-01110101b ^ 11110111b = 10000010b
-01110101b ^ 11111000b = 10001101b
-01110101b ^ 11111001b = 10001100b
-01110101b ^ 11111010b = 10001111b
-01110101b ^ 11111011b = 10001110b
-01110101b ^ 11111100b = 10001001b
-01110101b ^ 11111101b = 10001000b
-01110101b ^ 11111110b = 10001011b
-01110101b ^ 11111111b = 10001010b
-01110101b ^ 00000000b = 01110101b
-01110101b ^ 00000001b = 01110100b
-01110101b ^ 00000010b = 01110111b
-01110101b ^ 00000011b = 01110110b
-01110101b ^ 00000100b = 01110001b
-01110101b ^ 00000101b = 01110000b
-01110101b ^ 00000110b = 01110011b
-01110101b ^ 00000111b = 01110010b
-01110101b ^ 00001000b = 01111101b
-01110101b ^ 00001001b = 01111100b
-01110101b ^ 00001010b = 01111111b
-01110101b ^ 00001011b = 01111110b
-01110101b ^ 00001100b = 01111001b
-01110101b ^ 00001101b = 01111000b
-01110101b ^ 00001110b = 01111011b
-01110101b ^ 00001111b = 01111010b
-01110101b ^ 00010000b = 01100101b
-01110101b ^ 00010001b = 01100100b
-01110101b ^ 00010010b = 01100111b
-01110101b ^ 00010011b = 01100110b
-01110101b ^ 00010100b = 01100001b
-01110101b ^ 00010101b = 01100000b
-01110101b ^ 00010110b = 01100011b
-01110101b ^ 00010111b = 01100010b
-01110101b ^ 00011000b = 01101101b
-01110101b ^ 00011001b = 01101100b
-01110101b ^ 00011010b = 01101111b
-01110101b ^ 00011011b = 01101110b
-01110101b ^ 00011100b = 01101001b
-01110101b ^ 00011101b = 01101000b
-01110101b ^ 00011110b = 01101011b
-01110101b ^ 00011111b = 01101010b
-01110101b ^ 00100000b = 01010101b
-01110101b ^ 00100001b = 01010100b
-01110101b ^ 00100010b = 01010111b
-01110101b ^ 00100011b = 01010110b
-01110101b ^ 00100100b = 01010001b
-01110101b ^ 00100101b = 01010000b
-01110101b ^ 00100110b = 01010011b
-01110101b ^ 00100111b = 01010010b
-01110101b ^ 00101000b = 01011101b
-01110101b ^ 00101001b = 01011100b
-01110101b ^ 00101010b = 01011111b
-01110101b ^ 00101011b = 01011110b
-01110101b ^ 00101100b = 01011001b
-01110101b ^ 00101101b = 01011000b
-01110101b ^ 00101110b = 01011011b
-01110101b ^ 00101111b = 01011010b
-01110101b ^ 00110000b = 01000101b
-01110101b ^ 00110001b = 01000100b
-01110101b ^ 00110010b = 01000111b
-01110101b ^ 00110011b = 01000110b
-01110101b ^ 00110100b = 01000001b
-01110101b ^ 00110101b = 01000000b
-01110101b ^ 00110110b = 01000011b
-01110101b ^ 00110111b = 01000010b
-01110101b ^ 00111000b = 01001101b
-01110101b ^ 00111001b = 01001100b
-01110101b ^ 00111010b = 01001111b
-01110101b ^ 00111011b = 01001110b
-01110101b ^ 00111100b = 01001001b
-01110101b ^ 00111101b = 01001000b
-01110101b ^ 00111110b = 01001011b
-01110101b ^ 00111111b = 01001010b
-01110101b ^ 01000000b = 00110101b
-01110101b ^ 01000001b = 00110100b
-01110101b ^ 01000010b = 00110111b
-01110101b ^ 01000011b = 00110110b
-01110101b ^ 01000100b = 00110001b
-01110101b ^ 01000101b = 00110000b
-01110101b ^ 01000110b = 00110011b
-01110101b ^ 01000111b = 00110010b
-01110101b ^ 01001000b = 00111101b
-01110101b ^ 01001001b = 00111100b
-01110101b ^ 01001010b = 00111111b
-01110101b ^ 01001011b = 00111110b
-01110101b ^ 01001100b = 00111001b
-01110101b ^ 01001101b = 00111000b
-01110101b ^ 01001110b = 00111011b
-01110101b ^ 01001111b = 00111010b
-01110101b ^ 01010000b = 00100101b
-01110101b ^ 01010001b = 00100100b
-01110101b ^ 01010010b = 00100111b
-01110101b ^ 01010011b = 00100110b
-01110101b ^ 01010100b = 00100001b
-01110101b ^ 01010101b = 00100000b
-01110101b ^ 01010110b = 00100011b
-01110101b ^ 01010111b = 00100010b
-01110101b ^ 01011000b = 00101101b
-01110101b ^ 01011001b = 00101100b
-01110101b ^ 01011010b = 00101111b
-01110101b ^ 01011011b = 00101110b
-01110101b ^ 01011100b = 00101001b
-01110101b ^ 01011101b = 00101000b
-01110101b ^ 01011110b = 00101011b
-01110101b ^ 01011111b = 00101010b
-01110101b ^ 01100000b = 00010101b
-01110101b ^ 01100001b = 00010100b
-01110101b ^ 01100010b = 00010111b
-01110101b ^ 01100011b = 00010110b
-01110101b ^ 01100100b = 00010001b
-01110101b ^ 01100101b = 00010000b
-01110101b ^ 01100110b = 00010011b
-01110101b ^ 01100111b = 00010010b
-01110101b ^ 01101000b = 00011101b
-01110101b ^ 01101001b = 00011100b
-01110101b ^ 01101010b = 00011111b
-01110101b ^ 01101011b = 00011110b
-01110101b ^ 01101100b = 00011001b
-01110101b ^ 01101101b = 00011000b
-01110101b ^ 01101110b = 00011011b
-01110101b ^ 01101111b = 00011010b
-01110101b ^ 01110000b = 00000101b
-01110101b ^ 01110001b = 00000100b
-01110101b ^ 01110010b = 00000111b
-01110101b ^ 01110011b = 00000110b
-01110101b ^ 01110100b = 00000001b
-01110101b ^ 01110101b = 00000000b
-01110101b ^ 01110110b = 00000011b
-01110101b ^ 01110111b = 00000010b
-01110101b ^ 01111000b = 00001101b
-01110101b ^ 01111001b = 00001100b
-01110101b ^ 01111010b = 00001111b
-01110101b ^ 01111011b = 00001110b
-01110101b ^ 01111100b = 00001001b
-01110101b ^ 01111101b = 00001000b
-01110101b ^ 01111110b = 00001011b
-01110110b ^ 10000000b = 11110110b
-01110110b ^ 10000001b = 11110111b
-01110110b ^ 10000010b = 11110100b
-01110110b ^ 10000011b = 11110101b
-01110110b ^ 10000100b = 11110010b
-01110110b ^ 10000101b = 11110011b
-01110110b ^ 10000110b = 11110000b
-01110110b ^ 10000111b = 11110001b
-01110110b ^ 10001000b = 11111110b
-01110110b ^ 10001001b = 11111111b
-01110110b ^ 10001010b = 11111100b
-01110110b ^ 10001011b = 11111101b
-01110110b ^ 10001100b = 11111010b
-01110110b ^ 10001101b = 11111011b
-01110110b ^ 10001110b = 11111000b
-01110110b ^ 10001111b = 11111001b
-01110110b ^ 10010000b = 11100110b
-01110110b ^ 10010001b = 11100111b
-01110110b ^ 10010010b = 11100100b
-01110110b ^ 10010011b = 11100101b
-01110110b ^ 10010100b = 11100010b
-01110110b ^ 10010101b = 11100011b
-01110110b ^ 10010110b = 11100000b
-01110110b ^ 10010111b = 11100001b
-01110110b ^ 10011000b = 11101110b
-01110110b ^ 10011001b = 11101111b
-01110110b ^ 10011010b = 11101100b
-01110110b ^ 10011011b = 11101101b
-01110110b ^ 10011100b = 11101010b
-01110110b ^ 10011101b = 11101011b
-01110110b ^ 10011110b = 11101000b
-01110110b ^ 10011111b = 11101001b
-01110110b ^ 10100000b = 11010110b
-01110110b ^ 10100001b = 11010111b
-01110110b ^ 10100010b = 11010100b
-01110110b ^ 10100011b = 11010101b
-01110110b ^ 10100100b = 11010010b
-01110110b ^ 10100101b = 11010011b
-01110110b ^ 10100110b = 11010000b
-01110110b ^ 10100111b = 11010001b
-01110110b ^ 10101000b = 11011110b
-01110110b ^ 10101001b = 11011111b
-01110110b ^ 10101010b = 11011100b
-01110110b ^ 10101011b = 11011101b
-01110110b ^ 10101100b = 11011010b
-01110110b ^ 10101101b = 11011011b
-01110110b ^ 10101110b = 11011000b
-01110110b ^ 10101111b = 11011001b
-01110110b ^ 10110000b = 11000110b
-01110110b ^ 10110001b = 11000111b
-01110110b ^ 10110010b = 11000100b
-01110110b ^ 10110011b = 11000101b
-01110110b ^ 10110100b = 11000010b
-01110110b ^ 10110101b = 11000011b
-01110110b ^ 10110110b = 11000000b
-01110110b ^ 10110111b = 11000001b
-01110110b ^ 10111000b = 11001110b
-01110110b ^ 10111001b = 11001111b
-01110110b ^ 10111010b = 11001100b
-01110110b ^ 10111011b = 11001101b
-01110110b ^ 10111100b = 11001010b
-01110110b ^ 10111101b = 11001011b
-01110110b ^ 10111110b = 11001000b
-01110110b ^ 10111111b = 11001001b
-01110110b ^ 11000000b = 10110110b
-01110110b ^ 11000001b = 10110111b
-01110110b ^ 11000010b = 10110100b
-01110110b ^ 11000011b = 10110101b
-01110110b ^ 11000100b = 10110010b
-01110110b ^ 11000101b = 10110011b
-01110110b ^ 11000110b = 10110000b
-01110110b ^ 11000111b = 10110001b
-01110110b ^ 11001000b = 10111110b
-01110110b ^ 11001001b = 10111111b
-01110110b ^ 11001010b = 10111100b
-01110110b ^ 11001011b = 10111101b
-01110110b ^ 11001100b = 10111010b
-01110110b ^ 11001101b = 10111011b
-01110110b ^ 11001110b = 10111000b
-01110110b ^ 11001111b = 10111001b
-01110110b ^ 11010000b = 10100110b
-01110110b ^ 11010001b = 10100111b
-01110110b ^ 11010010b = 10100100b
-01110110b ^ 11010011b = 10100101b
-01110110b ^ 11010100b = 10100010b
-01110110b ^ 11010101b = 10100011b
-01110110b ^ 11010110b = 10100000b
-01110110b ^ 11010111b = 10100001b
-01110110b ^ 11011000b = 10101110b
-01110110b ^ 11011001b = 10101111b
-01110110b ^ 11011010b = 10101100b
-01110110b ^ 11011011b = 10101101b
-01110110b ^ 11011100b = 10101010b
-01110110b ^ 11011101b = 10101011b
-01110110b ^ 11011110b = 10101000b
-01110110b ^ 11011111b = 10101001b
-01110110b ^ 11100000b = 10010110b
-01110110b ^ 11100001b = 10010111b
-01110110b ^ 11100010b = 10010100b
-01110110b ^ 11100011b = 10010101b
-01110110b ^ 11100100b = 10010010b
-01110110b ^ 11100101b = 10010011b
-01110110b ^ 11100110b = 10010000b
-01110110b ^ 11100111b = 10010001b
-01110110b ^ 11101000b = 10011110b
-01110110b ^ 11101001b = 10011111b
-01110110b ^ 11101010b = 10011100b
-01110110b ^ 11101011b = 10011101b
-01110110b ^ 11101100b = 10011010b
-01110110b ^ 11101101b = 10011011b
-01110110b ^ 11101110b = 10011000b
-01110110b ^ 11101111b = 10011001b
-01110110b ^ 11110000b = 10000110b
-01110110b ^ 11110001b = 10000111b
-01110110b ^ 11110010b = 10000100b
-01110110b ^ 11110011b = 10000101b
-01110110b ^ 11110100b = 10000010b
-01110110b ^ 11110101b = 10000011b
-01110110b ^ 11110110b = 10000000b
-01110110b ^ 11110111b = 10000001b
-01110110b ^ 11111000b = 10001110b
-01110110b ^ 11111001b = 10001111b
-01110110b ^ 11111010b = 10001100b
-01110110b ^ 11111011b = 10001101b
-01110110b ^ 11111100b = 10001010b
-01110110b ^ 11111101b = 10001011b
-01110110b ^ 11111110b = 10001000b
-01110110b ^ 11111111b = 10001001b
-01110110b ^ 00000000b = 01110110b
-01110110b ^ 00000001b = 01110111b
-01110110b ^ 00000010b = 01110100b
-01110110b ^ 00000011b = 01110101b
-01110110b ^ 00000100b = 01110010b
-01110110b ^ 00000101b = 01110011b
-01110110b ^ 00000110b = 01110000b
-01110110b ^ 00000111b = 01110001b
-01110110b ^ 00001000b = 01111110b
-01110110b ^ 00001001b = 01111111b
-01110110b ^ 00001010b = 01111100b
-01110110b ^ 00001011b = 01111101b
-01110110b ^ 00001100b = 01111010b
-01110110b ^ 00001101b = 01111011b
-01110110b ^ 00001110b = 01111000b
-01110110b ^ 00001111b = 01111001b
-01110110b ^ 00010000b = 01100110b
-01110110b ^ 00010001b = 01100111b
-01110110b ^ 00010010b = 01100100b
-01110110b ^ 00010011b = 01100101b
-01110110b ^ 00010100b = 01100010b
-01110110b ^ 00010101b = 01100011b
-01110110b ^ 00010110b = 01100000b
-01110110b ^ 00010111b = 01100001b
-01110110b ^ 00011000b = 01101110b
-01110110b ^ 00011001b = 01101111b
-01110110b ^ 00011010b = 01101100b
-01110110b ^ 00011011b = 01101101b
-01110110b ^ 00011100b = 01101010b
-01110110b ^ 00011101b = 01101011b
-01110110b ^ 00011110b = 01101000b
-01110110b ^ 00011111b = 01101001b
-01110110b ^ 00100000b = 01010110b
-01110110b ^ 00100001b = 01010111b
-01110110b ^ 00100010b = 01010100b
-01110110b ^ 00100011b = 01010101b
-01110110b ^ 00100100b = 01010010b
-01110110b ^ 00100101b = 01010011b
-01110110b ^ 00100110b = 01010000b
-01110110b ^ 00100111b = 01010001b
-01110110b ^ 00101000b = 01011110b
-01110110b ^ 00101001b = 01011111b
-01110110b ^ 00101010b = 01011100b
-01110110b ^ 00101011b = 01011101b
-01110110b ^ 00101100b = 01011010b
-01110110b ^ 00101101b = 01011011b
-01110110b ^ 00101110b = 01011000b
-01110110b ^ 00101111b = 01011001b
-01110110b ^ 00110000b = 01000110b
-01110110b ^ 00110001b = 01000111b
-01110110b ^ 00110010b = 01000100b
-01110110b ^ 00110011b = 01000101b
-01110110b ^ 00110100b = 01000010b
-01110110b ^ 00110101b = 01000011b
-01110110b ^ 00110110b = 01000000b
-01110110b ^ 00110111b = 01000001b
-01110110b ^ 00111000b = 01001110b
-01110110b ^ 00111001b = 01001111b
-01110110b ^ 00111010b = 01001100b
-01110110b ^ 00111011b = 01001101b
-01110110b ^ 00111100b = 01001010b
-01110110b ^ 00111101b = 01001011b
-01110110b ^ 00111110b = 01001000b
-01110110b ^ 00111111b = 01001001b
-01110110b ^ 01000000b = 00110110b
-01110110b ^ 01000001b = 00110111b
-01110110b ^ 01000010b = 00110100b
-01110110b ^ 01000011b = 00110101b
-01110110b ^ 01000100b = 00110010b
-01110110b ^ 01000101b = 00110011b
-01110110b ^ 01000110b = 00110000b
-01110110b ^ 01000111b = 00110001b
-01110110b ^ 01001000b = 00111110b
-01110110b ^ 01001001b = 00111111b
-01110110b ^ 01001010b = 00111100b
-01110110b ^ 01001011b = 00111101b
-01110110b ^ 01001100b = 00111010b
-01110110b ^ 01001101b = 00111011b
-01110110b ^ 01001110b = 00111000b
-01110110b ^ 01001111b = 00111001b
-01110110b ^ 01010000b = 00100110b
-01110110b ^ 01010001b = 00100111b
-01110110b ^ 01010010b = 00100100b
-01110110b ^ 01010011b = 00100101b
-01110110b ^ 01010100b = 00100010b
-01110110b ^ 01010101b = 00100011b
-01110110b ^ 01010110b = 00100000b
-01110110b ^ 01010111b = 00100001b
-01110110b ^ 01011000b = 00101110b
-01110110b ^ 01011001b = 00101111b
-01110110b ^ 01011010b = 00101100b
-01110110b ^ 01011011b = 00101101b
-01110110b ^ 01011100b = 00101010b
-01110110b ^ 01011101b = 00101011b
-01110110b ^ 01011110b = 00101000b
-01110110b ^ 01011111b = 00101001b
-01110110b ^ 01100000b = 00010110b
-01110110b ^ 01100001b = 00010111b
-01110110b ^ 01100010b = 00010100b
-01110110b ^ 01100011b = 00010101b
-01110110b ^ 01100100b = 00010010b
-01110110b ^ 01100101b = 00010011b
-01110110b ^ 01100110b = 00010000b
-01110110b ^ 01100111b = 00010001b
-01110110b ^ 01101000b = 00011110b
-01110110b ^ 01101001b = 00011111b
-01110110b ^ 01101010b = 00011100b
-01110110b ^ 01101011b = 00011101b
-01110110b ^ 01101100b = 00011010b
-01110110b ^ 01101101b = 00011011b
-01110110b ^ 01101110b = 00011000b
-01110110b ^ 01101111b = 00011001b
-01110110b ^ 01110000b = 00000110b
-01110110b ^ 01110001b = 00000111b
-01110110b ^ 01110010b = 00000100b
-01110110b ^ 01110011b = 00000101b
-01110110b ^ 01110100b = 00000010b
-01110110b ^ 01110101b = 00000011b
-01110110b ^ 01110110b = 00000000b
-01110110b ^ 01110111b = 00000001b
-01110110b ^ 01111000b = 00001110b
-01110110b ^ 01111001b = 00001111b
-01110110b ^ 01111010b = 00001100b
-01110110b ^ 01111011b = 00001101b
-01110110b ^ 01111100b = 00001010b
-01110110b ^ 01111101b = 00001011b
-01110110b ^ 01111110b = 00001000b
-01110111b ^ 10000000b = 11110111b
-01110111b ^ 10000001b = 11110110b
-01110111b ^ 10000010b = 11110101b
-01110111b ^ 10000011b = 11110100b
-01110111b ^ 10000100b = 11110011b
-01110111b ^ 10000101b = 11110010b
-01110111b ^ 10000110b = 11110001b
-01110111b ^ 10000111b = 11110000b
-01110111b ^ 10001000b = 11111111b
-01110111b ^ 10001001b = 11111110b
-01110111b ^ 10001010b = 11111101b
-01110111b ^ 10001011b = 11111100b
-01110111b ^ 10001100b = 11111011b
-01110111b ^ 10001101b = 11111010b
-01110111b ^ 10001110b = 11111001b
-01110111b ^ 10001111b = 11111000b
-01110111b ^ 10010000b = 11100111b
-01110111b ^ 10010001b = 11100110b
-01110111b ^ 10010010b = 11100101b
-01110111b ^ 10010011b = 11100100b
-01110111b ^ 10010100b = 11100011b
-01110111b ^ 10010101b = 11100010b
-01110111b ^ 10010110b = 11100001b
-01110111b ^ 10010111b = 11100000b
-01110111b ^ 10011000b = 11101111b
-01110111b ^ 10011001b = 11101110b
-01110111b ^ 10011010b = 11101101b
-01110111b ^ 10011011b = 11101100b
-01110111b ^ 10011100b = 11101011b
-01110111b ^ 10011101b = 11101010b
-01110111b ^ 10011110b = 11101001b
-01110111b ^ 10011111b = 11101000b
-01110111b ^ 10100000b = 11010111b
-01110111b ^ 10100001b = 11010110b
-01110111b ^ 10100010b = 11010101b
-01110111b ^ 10100011b = 11010100b
-01110111b ^ 10100100b = 11010011b
-01110111b ^ 10100101b = 11010010b
-01110111b ^ 10100110b = 11010001b
-01110111b ^ 10100111b = 11010000b
-01110111b ^ 10101000b = 11011111b
-01110111b ^ 10101001b = 11011110b
-01110111b ^ 10101010b = 11011101b
-01110111b ^ 10101011b = 11011100b
-01110111b ^ 10101100b = 11011011b
-01110111b ^ 10101101b = 11011010b
-01110111b ^ 10101110b = 11011001b
-01110111b ^ 10101111b = 11011000b
-01110111b ^ 10110000b = 11000111b
-01110111b ^ 10110001b = 11000110b
-01110111b ^ 10110010b = 11000101b
-01110111b ^ 10110011b = 11000100b
-01110111b ^ 10110100b = 11000011b
-01110111b ^ 10110101b = 11000010b
-01110111b ^ 10110110b = 11000001b
-01110111b ^ 10110111b = 11000000b
-01110111b ^ 10111000b = 11001111b
-01110111b ^ 10111001b = 11001110b
-01110111b ^ 10111010b = 11001101b
-01110111b ^ 10111011b = 11001100b
-01110111b ^ 10111100b = 11001011b
-01110111b ^ 10111101b = 11001010b
-01110111b ^ 10111110b = 11001001b
-01110111b ^ 10111111b = 11001000b
-01110111b ^ 11000000b = 10110111b
-01110111b ^ 11000001b = 10110110b
-01110111b ^ 11000010b = 10110101b
-01110111b ^ 11000011b = 10110100b
-01110111b ^ 11000100b = 10110011b
-01110111b ^ 11000101b = 10110010b
-01110111b ^ 11000110b = 10110001b
-01110111b ^ 11000111b = 10110000b
-01110111b ^ 11001000b = 10111111b
-01110111b ^ 11001001b = 10111110b
-01110111b ^ 11001010b = 10111101b
-01110111b ^ 11001011b = 10111100b
-01110111b ^ 11001100b = 10111011b
-01110111b ^ 11001101b = 10111010b
-01110111b ^ 11001110b = 10111001b
-01110111b ^ 11001111b = 10111000b
-01110111b ^ 11010000b = 10100111b
-01110111b ^ 11010001b = 10100110b
-01110111b ^ 11010010b = 10100101b
-01110111b ^ 11010011b = 10100100b
-01110111b ^ 11010100b = 10100011b
-01110111b ^ 11010101b = 10100010b
-01110111b ^ 11010110b = 10100001b
-01110111b ^ 11010111b = 10100000b
-01110111b ^ 11011000b = 10101111b
-01110111b ^ 11011001b = 10101110b
-01110111b ^ 11011010b = 10101101b
-01110111b ^ 11011011b = 10101100b
-01110111b ^ 11011100b = 10101011b
-01110111b ^ 11011101b = 10101010b
-01110111b ^ 11011110b = 10101001b
-01110111b ^ 11011111b = 10101000b
-01110111b ^ 11100000b = 10010111b
-01110111b ^ 11100001b = 10010110b
-01110111b ^ 11100010b = 10010101b
-01110111b ^ 11100011b = 10010100b
-01110111b ^ 11100100b = 10010011b
-01110111b ^ 11100101b = 10010010b
-01110111b ^ 11100110b = 10010001b
-01110111b ^ 11100111b = 10010000b
-01110111b ^ 11101000b = 10011111b
-01110111b ^ 11101001b = 10011110b
-01110111b ^ 11101010b = 10011101b
-01110111b ^ 11101011b = 10011100b
-01110111b ^ 11101100b = 10011011b
-01110111b ^ 11101101b = 10011010b
-01110111b ^ 11101110b = 10011001b
-01110111b ^ 11101111b = 10011000b
-01110111b ^ 11110000b = 10000111b
-01110111b ^ 11110001b = 10000110b
-01110111b ^ 11110010b = 10000101b
-01110111b ^ 11110011b = 10000100b
-01110111b ^ 11110100b = 10000011b
-01110111b ^ 11110101b = 10000010b
-01110111b ^ 11110110b = 10000001b
-01110111b ^ 11110111b = 10000000b
-01110111b ^ 11111000b = 10001111b
-01110111b ^ 11111001b = 10001110b
-01110111b ^ 11111010b = 10001101b
-01110111b ^ 11111011b = 10001100b
-01110111b ^ 11111100b = 10001011b
-01110111b ^ 11111101b = 10001010b
-01110111b ^ 11111110b = 10001001b
-01110111b ^ 11111111b = 10001000b
-01110111b ^ 00000000b = 01110111b
-01110111b ^ 00000001b = 01110110b
-01110111b ^ 00000010b = 01110101b
-01110111b ^ 00000011b = 01110100b
-01110111b ^ 00000100b = 01110011b
-01110111b ^ 00000101b = 01110010b
-01110111b ^ 00000110b = 01110001b
-01110111b ^ 00000111b = 01110000b
-01110111b ^ 00001000b = 01111111b
-01110111b ^ 00001001b = 01111110b
-01110111b ^ 00001010b = 01111101b
-01110111b ^ 00001011b = 01111100b
-01110111b ^ 00001100b = 01111011b
-01110111b ^ 00001101b = 01111010b
-01110111b ^ 00001110b = 01111001b
-01110111b ^ 00001111b = 01111000b
-01110111b ^ 00010000b = 01100111b
-01110111b ^ 00010001b = 01100110b
-01110111b ^ 00010010b = 01100101b
-01110111b ^ 00010011b = 01100100b
-01110111b ^ 00010100b = 01100011b
-01110111b ^ 00010101b = 01100010b
-01110111b ^ 00010110b = 01100001b
-01110111b ^ 00010111b = 01100000b
-01110111b ^ 00011000b = 01101111b
-01110111b ^ 00011001b = 01101110b
-01110111b ^ 00011010b = 01101101b
-01110111b ^ 00011011b = 01101100b
-01110111b ^ 00011100b = 01101011b
-01110111b ^ 00011101b = 01101010b
-01110111b ^ 00011110b = 01101001b
-01110111b ^ 00011111b = 01101000b
-01110111b ^ 00100000b = 01010111b
-01110111b ^ 00100001b = 01010110b
-01110111b ^ 00100010b = 01010101b
-01110111b ^ 00100011b = 01010100b
-01110111b ^ 00100100b = 01010011b
-01110111b ^ 00100101b = 01010010b
-01110111b ^ 00100110b = 01010001b
-01110111b ^ 00100111b = 01010000b
-01110111b ^ 00101000b = 01011111b
-01110111b ^ 00101001b = 01011110b
-01110111b ^ 00101010b = 01011101b
-01110111b ^ 00101011b = 01011100b
-01110111b ^ 00101100b = 01011011b
-01110111b ^ 00101101b = 01011010b
-01110111b ^ 00101110b = 01011001b
-01110111b ^ 00101111b = 01011000b
-01110111b ^ 00110000b = 01000111b
-01110111b ^ 00110001b = 01000110b
-01110111b ^ 00110010b = 01000101b
-01110111b ^ 00110011b = 01000100b
-01110111b ^ 00110100b = 01000011b
-01110111b ^ 00110101b = 01000010b
-01110111b ^ 00110110b = 01000001b
-01110111b ^ 00110111b = 01000000b
-01110111b ^ 00111000b = 01001111b
-01110111b ^ 00111001b = 01001110b
-01110111b ^ 00111010b = 01001101b
-01110111b ^ 00111011b = 01001100b
-01110111b ^ 00111100b = 01001011b
-01110111b ^ 00111101b = 01001010b
-01110111b ^ 00111110b = 01001001b
-01110111b ^ 00111111b = 01001000b
-01110111b ^ 01000000b = 00110111b
-01110111b ^ 01000001b = 00110110b
-01110111b ^ 01000010b = 00110101b
-01110111b ^ 01000011b = 00110100b
-01110111b ^ 01000100b = 00110011b
-01110111b ^ 01000101b = 00110010b
-01110111b ^ 01000110b = 00110001b
-01110111b ^ 01000111b = 00110000b
-01110111b ^ 01001000b = 00111111b
-01110111b ^ 01001001b = 00111110b
-01110111b ^ 01001010b = 00111101b
-01110111b ^ 01001011b = 00111100b
-01110111b ^ 01001100b = 00111011b
-01110111b ^ 01001101b = 00111010b
-01110111b ^ 01001110b = 00111001b
-01110111b ^ 01001111b = 00111000b
-01110111b ^ 01010000b = 00100111b
-01110111b ^ 01010001b = 00100110b
-01110111b ^ 01010010b = 00100101b
-01110111b ^ 01010011b = 00100100b
-01110111b ^ 01010100b = 00100011b
-01110111b ^ 01010101b = 00100010b
-01110111b ^ 01010110b = 00100001b
-01110111b ^ 01010111b = 00100000b
-01110111b ^ 01011000b = 00101111b
-01110111b ^ 01011001b = 00101110b
-01110111b ^ 01011010b = 00101101b
-01110111b ^ 01011011b = 00101100b
-01110111b ^ 01011100b = 00101011b
-01110111b ^ 01011101b = 00101010b
-01110111b ^ 01011110b = 00101001b
-01110111b ^ 01011111b = 00101000b
-01110111b ^ 01100000b = 00010111b
-01110111b ^ 01100001b = 00010110b
-01110111b ^ 01100010b = 00010101b
-01110111b ^ 01100011b = 00010100b
-01110111b ^ 01100100b = 00010011b
-01110111b ^ 01100101b = 00010010b
-01110111b ^ 01100110b = 00010001b
-01110111b ^ 01100111b = 00010000b
-01110111b ^ 01101000b = 00011111b
-01110111b ^ 01101001b = 00011110b
-01110111b ^ 01101010b = 00011101b
-01110111b ^ 01101011b = 00011100b
-01110111b ^ 01101100b = 00011011b
-01110111b ^ 01101101b = 00011010b
-01110111b ^ 01101110b = 00011001b
-01110111b ^ 01101111b = 00011000b
-01110111b ^ 01110000b = 00000111b
-01110111b ^ 01110001b = 00000110b
-01110111b ^ 01110010b = 00000101b
-01110111b ^ 01110011b = 00000100b
-01110111b ^ 01110100b = 00000011b
-01110111b ^ 01110101b = 00000010b
-01110111b ^ 01110110b = 00000001b
-01110111b ^ 01110111b = 00000000b
-01110111b ^ 01111000b = 00001111b
-01110111b ^ 01111001b = 00001110b
-01110111b ^ 01111010b = 00001101b
-01110111b ^ 01111011b = 00001100b
-01110111b ^ 01111100b = 00001011b
-01110111b ^ 01111101b = 00001010b
-01110111b ^ 01111110b = 00001001b
-01111000b ^ 10000000b = 11111000b
-01111000b ^ 10000001b = 11111001b
-01111000b ^ 10000010b = 11111010b
-01111000b ^ 10000011b = 11111011b
-01111000b ^ 10000100b = 11111100b
-01111000b ^ 10000101b = 11111101b
-01111000b ^ 10000110b = 11111110b
-01111000b ^ 10000111b = 11111111b
-01111000b ^ 10001000b = 11110000b
-01111000b ^ 10001001b = 11110001b
-01111000b ^ 10001010b = 11110010b
-01111000b ^ 10001011b = 11110011b
-01111000b ^ 10001100b = 11110100b
-01111000b ^ 10001101b = 11110101b
-01111000b ^ 10001110b = 11110110b
-01111000b ^ 10001111b = 11110111b
-01111000b ^ 10010000b = 11101000b
-01111000b ^ 10010001b = 11101001b
-01111000b ^ 10010010b = 11101010b
-01111000b ^ 10010011b = 11101011b
-01111000b ^ 10010100b = 11101100b
-01111000b ^ 10010101b = 11101101b
-01111000b ^ 10010110b = 11101110b
-01111000b ^ 10010111b = 11101111b
-01111000b ^ 10011000b = 11100000b
-01111000b ^ 10011001b = 11100001b
-01111000b ^ 10011010b = 11100010b
-01111000b ^ 10011011b = 11100011b
-01111000b ^ 10011100b = 11100100b
-01111000b ^ 10011101b = 11100101b
-01111000b ^ 10011110b = 11100110b
-01111000b ^ 10011111b = 11100111b
-01111000b ^ 10100000b = 11011000b
-01111000b ^ 10100001b = 11011001b
-01111000b ^ 10100010b = 11011010b
-01111000b ^ 10100011b = 11011011b
-01111000b ^ 10100100b = 11011100b
-01111000b ^ 10100101b = 11011101b
-01111000b ^ 10100110b = 11011110b
-01111000b ^ 10100111b = 11011111b
-01111000b ^ 10101000b = 11010000b
-01111000b ^ 10101001b = 11010001b
-01111000b ^ 10101010b = 11010010b
-01111000b ^ 10101011b = 11010011b
-01111000b ^ 10101100b = 11010100b
-01111000b ^ 10101101b = 11010101b
-01111000b ^ 10101110b = 11010110b
-01111000b ^ 10101111b = 11010111b
-01111000b ^ 10110000b = 11001000b
-01111000b ^ 10110001b = 11001001b
-01111000b ^ 10110010b = 11001010b
-01111000b ^ 10110011b = 11001011b
-01111000b ^ 10110100b = 11001100b
-01111000b ^ 10110101b = 11001101b
-01111000b ^ 10110110b = 11001110b
-01111000b ^ 10110111b = 11001111b
-01111000b ^ 10111000b = 11000000b
-01111000b ^ 10111001b = 11000001b
-01111000b ^ 10111010b = 11000010b
-01111000b ^ 10111011b = 11000011b
-01111000b ^ 10111100b = 11000100b
-01111000b ^ 10111101b = 11000101b
-01111000b ^ 10111110b = 11000110b
-01111000b ^ 10111111b = 11000111b
-01111000b ^ 11000000b = 10111000b
-01111000b ^ 11000001b = 10111001b
-01111000b ^ 11000010b = 10111010b
-01111000b ^ 11000011b = 10111011b
-01111000b ^ 11000100b = 10111100b
-01111000b ^ 11000101b = 10111101b
-01111000b ^ 11000110b = 10111110b
-01111000b ^ 11000111b = 10111111b
-01111000b ^ 11001000b = 10110000b
-01111000b ^ 11001001b = 10110001b
-01111000b ^ 11001010b = 10110010b
-01111000b ^ 11001011b = 10110011b
-01111000b ^ 11001100b = 10110100b
-01111000b ^ 11001101b = 10110101b
-01111000b ^ 11001110b = 10110110b
-01111000b ^ 11001111b = 10110111b
-01111000b ^ 11010000b = 10101000b
-01111000b ^ 11010001b = 10101001b
-01111000b ^ 11010010b = 10101010b
-01111000b ^ 11010011b = 10101011b
-01111000b ^ 11010100b = 10101100b
-01111000b ^ 11010101b = 10101101b
-01111000b ^ 11010110b = 10101110b
-01111000b ^ 11010111b = 10101111b
-01111000b ^ 11011000b = 10100000b
-01111000b ^ 11011001b = 10100001b
-01111000b ^ 11011010b = 10100010b
-01111000b ^ 11011011b = 10100011b
-01111000b ^ 11011100b = 10100100b
-01111000b ^ 11011101b = 10100101b
-01111000b ^ 11011110b = 10100110b
-01111000b ^ 11011111b = 10100111b
-01111000b ^ 11100000b = 10011000b
-01111000b ^ 11100001b = 10011001b
-01111000b ^ 11100010b = 10011010b
-01111000b ^ 11100011b = 10011011b
-01111000b ^ 11100100b = 10011100b
-01111000b ^ 11100101b = 10011101b
-01111000b ^ 11100110b = 10011110b
-01111000b ^ 11100111b = 10011111b
-01111000b ^ 11101000b = 10010000b
-01111000b ^ 11101001b = 10010001b
-01111000b ^ 11101010b = 10010010b
-01111000b ^ 11101011b = 10010011b
-01111000b ^ 11101100b = 10010100b
-01111000b ^ 11101101b = 10010101b
-01111000b ^ 11101110b = 10010110b
-01111000b ^ 11101111b = 10010111b
-01111000b ^ 11110000b = 10001000b
-01111000b ^ 11110001b = 10001001b
-01111000b ^ 11110010b = 10001010b
-01111000b ^ 11110011b = 10001011b
-01111000b ^ 11110100b = 10001100b
-01111000b ^ 11110101b = 10001101b
-01111000b ^ 11110110b = 10001110b
-01111000b ^ 11110111b = 10001111b
-01111000b ^ 11111000b = 10000000b
-01111000b ^ 11111001b = 10000001b
-01111000b ^ 11111010b = 10000010b
-01111000b ^ 11111011b = 10000011b
-01111000b ^ 11111100b = 10000100b
-01111000b ^ 11111101b = 10000101b
-01111000b ^ 11111110b = 10000110b
-01111000b ^ 11111111b = 10000111b
-01111000b ^ 00000000b = 01111000b
-01111000b ^ 00000001b = 01111001b
-01111000b ^ 00000010b = 01111010b
-01111000b ^ 00000011b = 01111011b
-01111000b ^ 00000100b = 01111100b
-01111000b ^ 00000101b = 01111101b
-01111000b ^ 00000110b = 01111110b
-01111000b ^ 00000111b = 01111111b
-01111000b ^ 00001000b = 01110000b
-01111000b ^ 00001001b = 01110001b
-01111000b ^ 00001010b = 01110010b
-01111000b ^ 00001011b = 01110011b
-01111000b ^ 00001100b = 01110100b
-01111000b ^ 00001101b = 01110101b
-01111000b ^ 00001110b = 01110110b
-01111000b ^ 00001111b = 01110111b
-01111000b ^ 00010000b = 01101000b
-01111000b ^ 00010001b = 01101001b
-01111000b ^ 00010010b = 01101010b
-01111000b ^ 00010011b = 01101011b
-01111000b ^ 00010100b = 01101100b
-01111000b ^ 00010101b = 01101101b
-01111000b ^ 00010110b = 01101110b
-01111000b ^ 00010111b = 01101111b
-01111000b ^ 00011000b = 01100000b
-01111000b ^ 00011001b = 01100001b
-01111000b ^ 00011010b = 01100010b
-01111000b ^ 00011011b = 01100011b
-01111000b ^ 00011100b = 01100100b
-01111000b ^ 00011101b = 01100101b
-01111000b ^ 00011110b = 01100110b
-01111000b ^ 00011111b = 01100111b
-01111000b ^ 00100000b = 01011000b
-01111000b ^ 00100001b = 01011001b
-01111000b ^ 00100010b = 01011010b
-01111000b ^ 00100011b = 01011011b
-01111000b ^ 00100100b = 01011100b
-01111000b ^ 00100101b = 01011101b
-01111000b ^ 00100110b = 01011110b
-01111000b ^ 00100111b = 01011111b
-01111000b ^ 00101000b = 01010000b
-01111000b ^ 00101001b = 01010001b
-01111000b ^ 00101010b = 01010010b
-01111000b ^ 00101011b = 01010011b
-01111000b ^ 00101100b = 01010100b
-01111000b ^ 00101101b = 01010101b
-01111000b ^ 00101110b = 01010110b
-01111000b ^ 00101111b = 01010111b
-01111000b ^ 00110000b = 01001000b
-01111000b ^ 00110001b = 01001001b
-01111000b ^ 00110010b = 01001010b
-01111000b ^ 00110011b = 01001011b
-01111000b ^ 00110100b = 01001100b
-01111000b ^ 00110101b = 01001101b
-01111000b ^ 00110110b = 01001110b
-01111000b ^ 00110111b = 01001111b
-01111000b ^ 00111000b = 01000000b
-01111000b ^ 00111001b = 01000001b
-01111000b ^ 00111010b = 01000010b
-01111000b ^ 00111011b = 01000011b
-01111000b ^ 00111100b = 01000100b
-01111000b ^ 00111101b = 01000101b
-01111000b ^ 00111110b = 01000110b
-01111000b ^ 00111111b = 01000111b
-01111000b ^ 01000000b = 00111000b
-01111000b ^ 01000001b = 00111001b
-01111000b ^ 01000010b = 00111010b
-01111000b ^ 01000011b = 00111011b
-01111000b ^ 01000100b = 00111100b
-01111000b ^ 01000101b = 00111101b
-01111000b ^ 01000110b = 00111110b
-01111000b ^ 01000111b = 00111111b
-01111000b ^ 01001000b = 00110000b
-01111000b ^ 01001001b = 00110001b
-01111000b ^ 01001010b = 00110010b
-01111000b ^ 01001011b = 00110011b
-01111000b ^ 01001100b = 00110100b
-01111000b ^ 01001101b = 00110101b
-01111000b ^ 01001110b = 00110110b
-01111000b ^ 01001111b = 00110111b
-01111000b ^ 01010000b = 00101000b
-01111000b ^ 01010001b = 00101001b
-01111000b ^ 01010010b = 00101010b
-01111000b ^ 01010011b = 00101011b
-01111000b ^ 01010100b = 00101100b
-01111000b ^ 01010101b = 00101101b
-01111000b ^ 01010110b = 00101110b
-01111000b ^ 01010111b = 00101111b
-01111000b ^ 01011000b = 00100000b
-01111000b ^ 01011001b = 00100001b
-01111000b ^ 01011010b = 00100010b
-01111000b ^ 01011011b = 00100011b
-01111000b ^ 01011100b = 00100100b
-01111000b ^ 01011101b = 00100101b
-01111000b ^ 01011110b = 00100110b
-01111000b ^ 01011111b = 00100111b
-01111000b ^ 01100000b = 00011000b
-01111000b ^ 01100001b = 00011001b
-01111000b ^ 01100010b = 00011010b
-01111000b ^ 01100011b = 00011011b
-01111000b ^ 01100100b = 00011100b
-01111000b ^ 01100101b = 00011101b
-01111000b ^ 01100110b = 00011110b
-01111000b ^ 01100111b = 00011111b
-01111000b ^ 01101000b = 00010000b
-01111000b ^ 01101001b = 00010001b
-01111000b ^ 01101010b = 00010010b
-01111000b ^ 01101011b = 00010011b
-01111000b ^ 01101100b = 00010100b
-01111000b ^ 01101101b = 00010101b
-01111000b ^ 01101110b = 00010110b
-01111000b ^ 01101111b = 00010111b
-01111000b ^ 01110000b = 00001000b
-01111000b ^ 01110001b = 00001001b
-01111000b ^ 01110010b = 00001010b
-01111000b ^ 01110011b = 00001011b
-01111000b ^ 01110100b = 00001100b
-01111000b ^ 01110101b = 00001101b
-01111000b ^ 01110110b = 00001110b
-01111000b ^ 01110111b = 00001111b
-01111000b ^ 01111000b = 00000000b
-01111000b ^ 01111001b = 00000001b
-01111000b ^ 01111010b = 00000010b
-01111000b ^ 01111011b = 00000011b
-01111000b ^ 01111100b = 00000100b
-01111000b ^ 01111101b = 00000101b
-01111000b ^ 01111110b = 00000110b
-01111001b ^ 10000000b = 11111001b
-01111001b ^ 10000001b = 11111000b
-01111001b ^ 10000010b = 11111011b
-01111001b ^ 10000011b = 11111010b
-01111001b ^ 10000100b = 11111101b
-01111001b ^ 10000101b = 11111100b
-01111001b ^ 10000110b = 11111111b
-01111001b ^ 10000111b = 11111110b
-01111001b ^ 10001000b = 11110001b
-01111001b ^ 10001001b = 11110000b
-01111001b ^ 10001010b = 11110011b
-01111001b ^ 10001011b = 11110010b
-01111001b ^ 10001100b = 11110101b
-01111001b ^ 10001101b = 11110100b
-01111001b ^ 10001110b = 11110111b
-01111001b ^ 10001111b = 11110110b
-01111001b ^ 10010000b = 11101001b
-01111001b ^ 10010001b = 11101000b
-01111001b ^ 10010010b = 11101011b
-01111001b ^ 10010011b = 11101010b
-01111001b ^ 10010100b = 11101101b
-01111001b ^ 10010101b = 11101100b
-01111001b ^ 10010110b = 11101111b
-01111001b ^ 10010111b = 11101110b
-01111001b ^ 10011000b = 11100001b
-01111001b ^ 10011001b = 11100000b
-01111001b ^ 10011010b = 11100011b
-01111001b ^ 10011011b = 11100010b
-01111001b ^ 10011100b = 11100101b
-01111001b ^ 10011101b = 11100100b
-01111001b ^ 10011110b = 11100111b
-01111001b ^ 10011111b = 11100110b
-01111001b ^ 10100000b = 11011001b
-01111001b ^ 10100001b = 11011000b
-01111001b ^ 10100010b = 11011011b
-01111001b ^ 10100011b = 11011010b
-01111001b ^ 10100100b = 11011101b
-01111001b ^ 10100101b = 11011100b
-01111001b ^ 10100110b = 11011111b
-01111001b ^ 10100111b = 11011110b
-01111001b ^ 10101000b = 11010001b
-01111001b ^ 10101001b = 11010000b
-01111001b ^ 10101010b = 11010011b
-01111001b ^ 10101011b = 11010010b
-01111001b ^ 10101100b = 11010101b
-01111001b ^ 10101101b = 11010100b
-01111001b ^ 10101110b = 11010111b
-01111001b ^ 10101111b = 11010110b
-01111001b ^ 10110000b = 11001001b
-01111001b ^ 10110001b = 11001000b
-01111001b ^ 10110010b = 11001011b
-01111001b ^ 10110011b = 11001010b
-01111001b ^ 10110100b = 11001101b
-01111001b ^ 10110101b = 11001100b
-01111001b ^ 10110110b = 11001111b
-01111001b ^ 10110111b = 11001110b
-01111001b ^ 10111000b = 11000001b
-01111001b ^ 10111001b = 11000000b
-01111001b ^ 10111010b = 11000011b
-01111001b ^ 10111011b = 11000010b
-01111001b ^ 10111100b = 11000101b
-01111001b ^ 10111101b = 11000100b
-01111001b ^ 10111110b = 11000111b
-01111001b ^ 10111111b = 11000110b
-01111001b ^ 11000000b = 10111001b
-01111001b ^ 11000001b = 10111000b
-01111001b ^ 11000010b = 10111011b
-01111001b ^ 11000011b = 10111010b
-01111001b ^ 11000100b = 10111101b
-01111001b ^ 11000101b = 10111100b
-01111001b ^ 11000110b = 10111111b
-01111001b ^ 11000111b = 10111110b
-01111001b ^ 11001000b = 10110001b
-01111001b ^ 11001001b = 10110000b
-01111001b ^ 11001010b = 10110011b
-01111001b ^ 11001011b = 10110010b
-01111001b ^ 11001100b = 10110101b
-01111001b ^ 11001101b = 10110100b
-01111001b ^ 11001110b = 10110111b
-01111001b ^ 11001111b = 10110110b
-01111001b ^ 11010000b = 10101001b
-01111001b ^ 11010001b = 10101000b
-01111001b ^ 11010010b = 10101011b
-01111001b ^ 11010011b = 10101010b
-01111001b ^ 11010100b = 10101101b
-01111001b ^ 11010101b = 10101100b
-01111001b ^ 11010110b = 10101111b
-01111001b ^ 11010111b = 10101110b
-01111001b ^ 11011000b = 10100001b
-01111001b ^ 11011001b = 10100000b
-01111001b ^ 11011010b = 10100011b
-01111001b ^ 11011011b = 10100010b
-01111001b ^ 11011100b = 10100101b
-01111001b ^ 11011101b = 10100100b
-01111001b ^ 11011110b = 10100111b
-01111001b ^ 11011111b = 10100110b
-01111001b ^ 11100000b = 10011001b
-01111001b ^ 11100001b = 10011000b
-01111001b ^ 11100010b = 10011011b
-01111001b ^ 11100011b = 10011010b
-01111001b ^ 11100100b = 10011101b
-01111001b ^ 11100101b = 10011100b
-01111001b ^ 11100110b = 10011111b
-01111001b ^ 11100111b = 10011110b
-01111001b ^ 11101000b = 10010001b
-01111001b ^ 11101001b = 10010000b
-01111001b ^ 11101010b = 10010011b
-01111001b ^ 11101011b = 10010010b
-01111001b ^ 11101100b = 10010101b
-01111001b ^ 11101101b = 10010100b
-01111001b ^ 11101110b = 10010111b
-01111001b ^ 11101111b = 10010110b
-01111001b ^ 11110000b = 10001001b
-01111001b ^ 11110001b = 10001000b
-01111001b ^ 11110010b = 10001011b
-01111001b ^ 11110011b = 10001010b
-01111001b ^ 11110100b = 10001101b
-01111001b ^ 11110101b = 10001100b
-01111001b ^ 11110110b = 10001111b
-01111001b ^ 11110111b = 10001110b
-01111001b ^ 11111000b = 10000001b
-01111001b ^ 11111001b = 10000000b
-01111001b ^ 11111010b = 10000011b
-01111001b ^ 11111011b = 10000010b
-01111001b ^ 11111100b = 10000101b
-01111001b ^ 11111101b = 10000100b
-01111001b ^ 11111110b = 10000111b
-01111001b ^ 11111111b = 10000110b
-01111001b ^ 00000000b = 01111001b
-01111001b ^ 00000001b = 01111000b
-01111001b ^ 00000010b = 01111011b
-01111001b ^ 00000011b = 01111010b
-01111001b ^ 00000100b = 01111101b
-01111001b ^ 00000101b = 01111100b
-01111001b ^ 00000110b = 01111111b
-01111001b ^ 00000111b = 01111110b
-01111001b ^ 00001000b = 01110001b
-01111001b ^ 00001001b = 01110000b
-01111001b ^ 00001010b = 01110011b
-01111001b ^ 00001011b = 01110010b
-01111001b ^ 00001100b = 01110101b
-01111001b ^ 00001101b = 01110100b
-01111001b ^ 00001110b = 01110111b
-01111001b ^ 00001111b = 01110110b
-01111001b ^ 00010000b = 01101001b
-01111001b ^ 00010001b = 01101000b
-01111001b ^ 00010010b = 01101011b
-01111001b ^ 00010011b = 01101010b
-01111001b ^ 00010100b = 01101101b
-01111001b ^ 00010101b = 01101100b
-01111001b ^ 00010110b = 01101111b
-01111001b ^ 00010111b = 01101110b
-01111001b ^ 00011000b = 01100001b
-01111001b ^ 00011001b = 01100000b
-01111001b ^ 00011010b = 01100011b
-01111001b ^ 00011011b = 01100010b
-01111001b ^ 00011100b = 01100101b
-01111001b ^ 00011101b = 01100100b
-01111001b ^ 00011110b = 01100111b
-01111001b ^ 00011111b = 01100110b
-01111001b ^ 00100000b = 01011001b
-01111001b ^ 00100001b = 01011000b
-01111001b ^ 00100010b = 01011011b
-01111001b ^ 00100011b = 01011010b
-01111001b ^ 00100100b = 01011101b
-01111001b ^ 00100101b = 01011100b
-01111001b ^ 00100110b = 01011111b
-01111001b ^ 00100111b = 01011110b
-01111001b ^ 00101000b = 01010001b
-01111001b ^ 00101001b = 01010000b
-01111001b ^ 00101010b = 01010011b
-01111001b ^ 00101011b = 01010010b
-01111001b ^ 00101100b = 01010101b
-01111001b ^ 00101101b = 01010100b
-01111001b ^ 00101110b = 01010111b
-01111001b ^ 00101111b = 01010110b
-01111001b ^ 00110000b = 01001001b
-01111001b ^ 00110001b = 01001000b
-01111001b ^ 00110010b = 01001011b
-01111001b ^ 00110011b = 01001010b
-01111001b ^ 00110100b = 01001101b
-01111001b ^ 00110101b = 01001100b
-01111001b ^ 00110110b = 01001111b
-01111001b ^ 00110111b = 01001110b
-01111001b ^ 00111000b = 01000001b
-01111001b ^ 00111001b = 01000000b
-01111001b ^ 00111010b = 01000011b
-01111001b ^ 00111011b = 01000010b
-01111001b ^ 00111100b = 01000101b
-01111001b ^ 00111101b = 01000100b
-01111001b ^ 00111110b = 01000111b
-01111001b ^ 00111111b = 01000110b
-01111001b ^ 01000000b = 00111001b
-01111001b ^ 01000001b = 00111000b
-01111001b ^ 01000010b = 00111011b
-01111001b ^ 01000011b = 00111010b
-01111001b ^ 01000100b = 00111101b
-01111001b ^ 01000101b = 00111100b
-01111001b ^ 01000110b = 00111111b
-01111001b ^ 01000111b = 00111110b
-01111001b ^ 01001000b = 00110001b
-01111001b ^ 01001001b = 00110000b
-01111001b ^ 01001010b = 00110011b
-01111001b ^ 01001011b = 00110010b
-01111001b ^ 01001100b = 00110101b
-01111001b ^ 01001101b = 00110100b
-01111001b ^ 01001110b = 00110111b
-01111001b ^ 01001111b = 00110110b
-01111001b ^ 01010000b = 00101001b
-01111001b ^ 01010001b = 00101000b
-01111001b ^ 01010010b = 00101011b
-01111001b ^ 01010011b = 00101010b
-01111001b ^ 01010100b = 00101101b
-01111001b ^ 01010101b = 00101100b
-01111001b ^ 01010110b = 00101111b
-01111001b ^ 01010111b = 00101110b
-01111001b ^ 01011000b = 00100001b
-01111001b ^ 01011001b = 00100000b
-01111001b ^ 01011010b = 00100011b
-01111001b ^ 01011011b = 00100010b
-01111001b ^ 01011100b = 00100101b
-01111001b ^ 01011101b = 00100100b
-01111001b ^ 01011110b = 00100111b
-01111001b ^ 01011111b = 00100110b
-01111001b ^ 01100000b = 00011001b
-01111001b ^ 01100001b = 00011000b
-01111001b ^ 01100010b = 00011011b
-01111001b ^ 01100011b = 00011010b
-01111001b ^ 01100100b = 00011101b
-01111001b ^ 01100101b = 00011100b
-01111001b ^ 01100110b = 00011111b
-01111001b ^ 01100111b = 00011110b
-01111001b ^ 01101000b = 00010001b
-01111001b ^ 01101001b = 00010000b
-01111001b ^ 01101010b = 00010011b
-01111001b ^ 01101011b = 00010010b
-01111001b ^ 01101100b = 00010101b
-01111001b ^ 01101101b = 00010100b
-01111001b ^ 01101110b = 00010111b
-01111001b ^ 01101111b = 00010110b
-01111001b ^ 01110000b = 00001001b
-01111001b ^ 01110001b = 00001000b
-01111001b ^ 01110010b = 00001011b
-01111001b ^ 01110011b = 00001010b
-01111001b ^ 01110100b = 00001101b
-01111001b ^ 01110101b = 00001100b
-01111001b ^ 01110110b = 00001111b
-01111001b ^ 01110111b = 00001110b
-01111001b ^ 01111000b = 00000001b
-01111001b ^ 01111001b = 00000000b
-01111001b ^ 01111010b = 00000011b
-01111001b ^ 01111011b = 00000010b
-01111001b ^ 01111100b = 00000101b
-01111001b ^ 01111101b = 00000100b
-01111001b ^ 01111110b = 00000111b
-01111010b ^ 10000000b = 11111010b
-01111010b ^ 10000001b = 11111011b
-01111010b ^ 10000010b = 11111000b
-01111010b ^ 10000011b = 11111001b
-01111010b ^ 10000100b = 11111110b
-01111010b ^ 10000101b = 11111111b
-01111010b ^ 10000110b = 11111100b
-01111010b ^ 10000111b = 11111101b
-01111010b ^ 10001000b = 11110010b
-01111010b ^ 10001001b = 11110011b
-01111010b ^ 10001010b = 11110000b
-01111010b ^ 10001011b = 11110001b
-01111010b ^ 10001100b = 11110110b
-01111010b ^ 10001101b = 11110111b
-01111010b ^ 10001110b = 11110100b
-01111010b ^ 10001111b = 11110101b
-01111010b ^ 10010000b = 11101010b
-01111010b ^ 10010001b = 11101011b
-01111010b ^ 10010010b = 11101000b
-01111010b ^ 10010011b = 11101001b
-01111010b ^ 10010100b = 11101110b
-01111010b ^ 10010101b = 11101111b
-01111010b ^ 10010110b = 11101100b
-01111010b ^ 10010111b = 11101101b
-01111010b ^ 10011000b = 11100010b
-01111010b ^ 10011001b = 11100011b
-01111010b ^ 10011010b = 11100000b
-01111010b ^ 10011011b = 11100001b
-01111010b ^ 10011100b = 11100110b
-01111010b ^ 10011101b = 11100111b
-01111010b ^ 10011110b = 11100100b
-01111010b ^ 10011111b = 11100101b
-01111010b ^ 10100000b = 11011010b
-01111010b ^ 10100001b = 11011011b
-01111010b ^ 10100010b = 11011000b
-01111010b ^ 10100011b = 11011001b
-01111010b ^ 10100100b = 11011110b
-01111010b ^ 10100101b = 11011111b
-01111010b ^ 10100110b = 11011100b
-01111010b ^ 10100111b = 11011101b
-01111010b ^ 10101000b = 11010010b
-01111010b ^ 10101001b = 11010011b
-01111010b ^ 10101010b = 11010000b
-01111010b ^ 10101011b = 11010001b
-01111010b ^ 10101100b = 11010110b
-01111010b ^ 10101101b = 11010111b
-01111010b ^ 10101110b = 11010100b
-01111010b ^ 10101111b = 11010101b
-01111010b ^ 10110000b = 11001010b
-01111010b ^ 10110001b = 11001011b
-01111010b ^ 10110010b = 11001000b
-01111010b ^ 10110011b = 11001001b
-01111010b ^ 10110100b = 11001110b
-01111010b ^ 10110101b = 11001111b
-01111010b ^ 10110110b = 11001100b
-01111010b ^ 10110111b = 11001101b
-01111010b ^ 10111000b = 11000010b
-01111010b ^ 10111001b = 11000011b
-01111010b ^ 10111010b = 11000000b
-01111010b ^ 10111011b = 11000001b
-01111010b ^ 10111100b = 11000110b
-01111010b ^ 10111101b = 11000111b
-01111010b ^ 10111110b = 11000100b
-01111010b ^ 10111111b = 11000101b
-01111010b ^ 11000000b = 10111010b
-01111010b ^ 11000001b = 10111011b
-01111010b ^ 11000010b = 10111000b
-01111010b ^ 11000011b = 10111001b
-01111010b ^ 11000100b = 10111110b
-01111010b ^ 11000101b = 10111111b
-01111010b ^ 11000110b = 10111100b
-01111010b ^ 11000111b = 10111101b
-01111010b ^ 11001000b = 10110010b
-01111010b ^ 11001001b = 10110011b
-01111010b ^ 11001010b = 10110000b
-01111010b ^ 11001011b = 10110001b
-01111010b ^ 11001100b = 10110110b
-01111010b ^ 11001101b = 10110111b
-01111010b ^ 11001110b = 10110100b
-01111010b ^ 11001111b = 10110101b
-01111010b ^ 11010000b = 10101010b
-01111010b ^ 11010001b = 10101011b
-01111010b ^ 11010010b = 10101000b
-01111010b ^ 11010011b = 10101001b
-01111010b ^ 11010100b = 10101110b
-01111010b ^ 11010101b = 10101111b
-01111010b ^ 11010110b = 10101100b
-01111010b ^ 11010111b = 10101101b
-01111010b ^ 11011000b = 10100010b
-01111010b ^ 11011001b = 10100011b
-01111010b ^ 11011010b = 10100000b
-01111010b ^ 11011011b = 10100001b
-01111010b ^ 11011100b = 10100110b
-01111010b ^ 11011101b = 10100111b
-01111010b ^ 11011110b = 10100100b
-01111010b ^ 11011111b = 10100101b
-01111010b ^ 11100000b = 10011010b
-01111010b ^ 11100001b = 10011011b
-01111010b ^ 11100010b = 10011000b
-01111010b ^ 11100011b = 10011001b
-01111010b ^ 11100100b = 10011110b
-01111010b ^ 11100101b = 10011111b
-01111010b ^ 11100110b = 10011100b
-01111010b ^ 11100111b = 10011101b
-01111010b ^ 11101000b = 10010010b
-01111010b ^ 11101001b = 10010011b
-01111010b ^ 11101010b = 10010000b
-01111010b ^ 11101011b = 10010001b
-01111010b ^ 11101100b = 10010110b
-01111010b ^ 11101101b = 10010111b
-01111010b ^ 11101110b = 10010100b
-01111010b ^ 11101111b = 10010101b
-01111010b ^ 11110000b = 10001010b
-01111010b ^ 11110001b = 10001011b
-01111010b ^ 11110010b = 10001000b
-01111010b ^ 11110011b = 10001001b
-01111010b ^ 11110100b = 10001110b
-01111010b ^ 11110101b = 10001111b
-01111010b ^ 11110110b = 10001100b
-01111010b ^ 11110111b = 10001101b
-01111010b ^ 11111000b = 10000010b
-01111010b ^ 11111001b = 10000011b
-01111010b ^ 11111010b = 10000000b
-01111010b ^ 11111011b = 10000001b
-01111010b ^ 11111100b = 10000110b
-01111010b ^ 11111101b = 10000111b
-01111010b ^ 11111110b = 10000100b
-01111010b ^ 11111111b = 10000101b
-01111010b ^ 00000000b = 01111010b
-01111010b ^ 00000001b = 01111011b
-01111010b ^ 00000010b = 01111000b
-01111010b ^ 00000011b = 01111001b
-01111010b ^ 00000100b = 01111110b
-01111010b ^ 00000101b = 01111111b
-01111010b ^ 00000110b = 01111100b
-01111010b ^ 00000111b = 01111101b
-01111010b ^ 00001000b = 01110010b
-01111010b ^ 00001001b = 01110011b
-01111010b ^ 00001010b = 01110000b
-01111010b ^ 00001011b = 01110001b
-01111010b ^ 00001100b = 01110110b
-01111010b ^ 00001101b = 01110111b
-01111010b ^ 00001110b = 01110100b
-01111010b ^ 00001111b = 01110101b
-01111010b ^ 00010000b = 01101010b
-01111010b ^ 00010001b = 01101011b
-01111010b ^ 00010010b = 01101000b
-01111010b ^ 00010011b = 01101001b
-01111010b ^ 00010100b = 01101110b
-01111010b ^ 00010101b = 01101111b
-01111010b ^ 00010110b = 01101100b
-01111010b ^ 00010111b = 01101101b
-01111010b ^ 00011000b = 01100010b
-01111010b ^ 00011001b = 01100011b
-01111010b ^ 00011010b = 01100000b
-01111010b ^ 00011011b = 01100001b
-01111010b ^ 00011100b = 01100110b
-01111010b ^ 00011101b = 01100111b
-01111010b ^ 00011110b = 01100100b
-01111010b ^ 00011111b = 01100101b
-01111010b ^ 00100000b = 01011010b
-01111010b ^ 00100001b = 01011011b
-01111010b ^ 00100010b = 01011000b
-01111010b ^ 00100011b = 01011001b
-01111010b ^ 00100100b = 01011110b
-01111010b ^ 00100101b = 01011111b
-01111010b ^ 00100110b = 01011100b
-01111010b ^ 00100111b = 01011101b
-01111010b ^ 00101000b = 01010010b
-01111010b ^ 00101001b = 01010011b
-01111010b ^ 00101010b = 01010000b
-01111010b ^ 00101011b = 01010001b
-01111010b ^ 00101100b = 01010110b
-01111010b ^ 00101101b = 01010111b
-01111010b ^ 00101110b = 01010100b
-01111010b ^ 00101111b = 01010101b
-01111010b ^ 00110000b = 01001010b
-01111010b ^ 00110001b = 01001011b
-01111010b ^ 00110010b = 01001000b
-01111010b ^ 00110011b = 01001001b
-01111010b ^ 00110100b = 01001110b
-01111010b ^ 00110101b = 01001111b
-01111010b ^ 00110110b = 01001100b
-01111010b ^ 00110111b = 01001101b
-01111010b ^ 00111000b = 01000010b
-01111010b ^ 00111001b = 01000011b
-01111010b ^ 00111010b = 01000000b
-01111010b ^ 00111011b = 01000001b
-01111010b ^ 00111100b = 01000110b
-01111010b ^ 00111101b = 01000111b
-01111010b ^ 00111110b = 01000100b
-01111010b ^ 00111111b = 01000101b
-01111010b ^ 01000000b = 00111010b
-01111010b ^ 01000001b = 00111011b
-01111010b ^ 01000010b = 00111000b
-01111010b ^ 01000011b = 00111001b
-01111010b ^ 01000100b = 00111110b
-01111010b ^ 01000101b = 00111111b
-01111010b ^ 01000110b = 00111100b
-01111010b ^ 01000111b = 00111101b
-01111010b ^ 01001000b = 00110010b
-01111010b ^ 01001001b = 00110011b
-01111010b ^ 01001010b = 00110000b
-01111010b ^ 01001011b = 00110001b
-01111010b ^ 01001100b = 00110110b
-01111010b ^ 01001101b = 00110111b
-01111010b ^ 01001110b = 00110100b
-01111010b ^ 01001111b = 00110101b
-01111010b ^ 01010000b = 00101010b
-01111010b ^ 01010001b = 00101011b
-01111010b ^ 01010010b = 00101000b
-01111010b ^ 01010011b = 00101001b
-01111010b ^ 01010100b = 00101110b
-01111010b ^ 01010101b = 00101111b
-01111010b ^ 01010110b = 00101100b
-01111010b ^ 01010111b = 00101101b
-01111010b ^ 01011000b = 00100010b
-01111010b ^ 01011001b = 00100011b
-01111010b ^ 01011010b = 00100000b
-01111010b ^ 01011011b = 00100001b
-01111010b ^ 01011100b = 00100110b
-01111010b ^ 01011101b = 00100111b
-01111010b ^ 01011110b = 00100100b
-01111010b ^ 01011111b = 00100101b
-01111010b ^ 01100000b = 00011010b
-01111010b ^ 01100001b = 00011011b
-01111010b ^ 01100010b = 00011000b
-01111010b ^ 01100011b = 00011001b
-01111010b ^ 01100100b = 00011110b
-01111010b ^ 01100101b = 00011111b
-01111010b ^ 01100110b = 00011100b
-01111010b ^ 01100111b = 00011101b
-01111010b ^ 01101000b = 00010010b
-01111010b ^ 01101001b = 00010011b
-01111010b ^ 01101010b = 00010000b
-01111010b ^ 01101011b = 00010001b
-01111010b ^ 01101100b = 00010110b
-01111010b ^ 01101101b = 00010111b
-01111010b ^ 01101110b = 00010100b
-01111010b ^ 01101111b = 00010101b
-01111010b ^ 01110000b = 00001010b
-01111010b ^ 01110001b = 00001011b
-01111010b ^ 01110010b = 00001000b
-01111010b ^ 01110011b = 00001001b
-01111010b ^ 01110100b = 00001110b
-01111010b ^ 01110101b = 00001111b
-01111010b ^ 01110110b = 00001100b
-01111010b ^ 01110111b = 00001101b
-01111010b ^ 01111000b = 00000010b
-01111010b ^ 01111001b = 00000011b
-01111010b ^ 01111010b = 00000000b
-01111010b ^ 01111011b = 00000001b
-01111010b ^ 01111100b = 00000110b
-01111010b ^ 01111101b = 00000111b
-01111010b ^ 01111110b = 00000100b
-01111011b ^ 10000000b = 11111011b
-01111011b ^ 10000001b = 11111010b
-01111011b ^ 10000010b = 11111001b
-01111011b ^ 10000011b = 11111000b
-01111011b ^ 10000100b = 11111111b
-01111011b ^ 10000101b = 11111110b
-01111011b ^ 10000110b = 11111101b
-01111011b ^ 10000111b = 11111100b
-01111011b ^ 10001000b = 11110011b
-01111011b ^ 10001001b = 11110010b
-01111011b ^ 10001010b = 11110001b
-01111011b ^ 10001011b = 11110000b
-01111011b ^ 10001100b = 11110111b
-01111011b ^ 10001101b = 11110110b
-01111011b ^ 10001110b = 11110101b
-01111011b ^ 10001111b = 11110100b
-01111011b ^ 10010000b = 11101011b
-01111011b ^ 10010001b = 11101010b
-01111011b ^ 10010010b = 11101001b
-01111011b ^ 10010011b = 11101000b
-01111011b ^ 10010100b = 11101111b
-01111011b ^ 10010101b = 11101110b
-01111011b ^ 10010110b = 11101101b
-01111011b ^ 10010111b = 11101100b
-01111011b ^ 10011000b = 11100011b
-01111011b ^ 10011001b = 11100010b
-01111011b ^ 10011010b = 11100001b
-01111011b ^ 10011011b = 11100000b
-01111011b ^ 10011100b = 11100111b
-01111011b ^ 10011101b = 11100110b
-01111011b ^ 10011110b = 11100101b
-01111011b ^ 10011111b = 11100100b
-01111011b ^ 10100000b = 11011011b
-01111011b ^ 10100001b = 11011010b
-01111011b ^ 10100010b = 11011001b
-01111011b ^ 10100011b = 11011000b
-01111011b ^ 10100100b = 11011111b
-01111011b ^ 10100101b = 11011110b
-01111011b ^ 10100110b = 11011101b
-01111011b ^ 10100111b = 11011100b
-01111011b ^ 10101000b = 11010011b
-01111011b ^ 10101001b = 11010010b
-01111011b ^ 10101010b = 11010001b
-01111011b ^ 10101011b = 11010000b
-01111011b ^ 10101100b = 11010111b
-01111011b ^ 10101101b = 11010110b
-01111011b ^ 10101110b = 11010101b
-01111011b ^ 10101111b = 11010100b
-01111011b ^ 10110000b = 11001011b
-01111011b ^ 10110001b = 11001010b
-01111011b ^ 10110010b = 11001001b
-01111011b ^ 10110011b = 11001000b
-01111011b ^ 10110100b = 11001111b
-01111011b ^ 10110101b = 11001110b
-01111011b ^ 10110110b = 11001101b
-01111011b ^ 10110111b = 11001100b
-01111011b ^ 10111000b = 11000011b
-01111011b ^ 10111001b = 11000010b
-01111011b ^ 10111010b = 11000001b
-01111011b ^ 10111011b = 11000000b
-01111011b ^ 10111100b = 11000111b
-01111011b ^ 10111101b = 11000110b
-01111011b ^ 10111110b = 11000101b
-01111011b ^ 10111111b = 11000100b
-01111011b ^ 11000000b = 10111011b
-01111011b ^ 11000001b = 10111010b
-01111011b ^ 11000010b = 10111001b
-01111011b ^ 11000011b = 10111000b
-01111011b ^ 11000100b = 10111111b
-01111011b ^ 11000101b = 10111110b
-01111011b ^ 11000110b = 10111101b
-01111011b ^ 11000111b = 10111100b
-01111011b ^ 11001000b = 10110011b
-01111011b ^ 11001001b = 10110010b
-01111011b ^ 11001010b = 10110001b
-01111011b ^ 11001011b = 10110000b
-01111011b ^ 11001100b = 10110111b
-01111011b ^ 11001101b = 10110110b
-01111011b ^ 11001110b = 10110101b
-01111011b ^ 11001111b = 10110100b
-01111011b ^ 11010000b = 10101011b
-01111011b ^ 11010001b = 10101010b
-01111011b ^ 11010010b = 10101001b
-01111011b ^ 11010011b = 10101000b
-01111011b ^ 11010100b = 10101111b
-01111011b ^ 11010101b = 10101110b
-01111011b ^ 11010110b = 10101101b
-01111011b ^ 11010111b = 10101100b
-01111011b ^ 11011000b = 10100011b
-01111011b ^ 11011001b = 10100010b
-01111011b ^ 11011010b = 10100001b
-01111011b ^ 11011011b = 10100000b
-01111011b ^ 11011100b = 10100111b
-01111011b ^ 11011101b = 10100110b
-01111011b ^ 11011110b = 10100101b
-01111011b ^ 11011111b = 10100100b
-01111011b ^ 11100000b = 10011011b
-01111011b ^ 11100001b = 10011010b
-01111011b ^ 11100010b = 10011001b
-01111011b ^ 11100011b = 10011000b
-01111011b ^ 11100100b = 10011111b
-01111011b ^ 11100101b = 10011110b
-01111011b ^ 11100110b = 10011101b
-01111011b ^ 11100111b = 10011100b
-01111011b ^ 11101000b = 10010011b
-01111011b ^ 11101001b = 10010010b
-01111011b ^ 11101010b = 10010001b
-01111011b ^ 11101011b = 10010000b
-01111011b ^ 11101100b = 10010111b
-01111011b ^ 11101101b = 10010110b
-01111011b ^ 11101110b = 10010101b
-01111011b ^ 11101111b = 10010100b
-01111011b ^ 11110000b = 10001011b
-01111011b ^ 11110001b = 10001010b
-01111011b ^ 11110010b = 10001001b
-01111011b ^ 11110011b = 10001000b
-01111011b ^ 11110100b = 10001111b
-01111011b ^ 11110101b = 10001110b
-01111011b ^ 11110110b = 10001101b
-01111011b ^ 11110111b = 10001100b
-01111011b ^ 11111000b = 10000011b
-01111011b ^ 11111001b = 10000010b
-01111011b ^ 11111010b = 10000001b
-01111011b ^ 11111011b = 10000000b
-01111011b ^ 11111100b = 10000111b
-01111011b ^ 11111101b = 10000110b
-01111011b ^ 11111110b = 10000101b
-01111011b ^ 11111111b = 10000100b
-01111011b ^ 00000000b = 01111011b
-01111011b ^ 00000001b = 01111010b
-01111011b ^ 00000010b = 01111001b
-01111011b ^ 00000011b = 01111000b
-01111011b ^ 00000100b = 01111111b
-01111011b ^ 00000101b = 01111110b
-01111011b ^ 00000110b = 01111101b
-01111011b ^ 00000111b = 01111100b
-01111011b ^ 00001000b = 01110011b
-01111011b ^ 00001001b = 01110010b
-01111011b ^ 00001010b = 01110001b
-01111011b ^ 00001011b = 01110000b
-01111011b ^ 00001100b = 01110111b
-01111011b ^ 00001101b = 01110110b
-01111011b ^ 00001110b = 01110101b
-01111011b ^ 00001111b = 01110100b
-01111011b ^ 00010000b = 01101011b
-01111011b ^ 00010001b = 01101010b
-01111011b ^ 00010010b = 01101001b
-01111011b ^ 00010011b = 01101000b
-01111011b ^ 00010100b = 01101111b
-01111011b ^ 00010101b = 01101110b
-01111011b ^ 00010110b = 01101101b
-01111011b ^ 00010111b = 01101100b
-01111011b ^ 00011000b = 01100011b
-01111011b ^ 00011001b = 01100010b
-01111011b ^ 00011010b = 01100001b
-01111011b ^ 00011011b = 01100000b
-01111011b ^ 00011100b = 01100111b
-01111011b ^ 00011101b = 01100110b
-01111011b ^ 00011110b = 01100101b
-01111011b ^ 00011111b = 01100100b
-01111011b ^ 00100000b = 01011011b
-01111011b ^ 00100001b = 01011010b
-01111011b ^ 00100010b = 01011001b
-01111011b ^ 00100011b = 01011000b
-01111011b ^ 00100100b = 01011111b
-01111011b ^ 00100101b = 01011110b
-01111011b ^ 00100110b = 01011101b
-01111011b ^ 00100111b = 01011100b
-01111011b ^ 00101000b = 01010011b
-01111011b ^ 00101001b = 01010010b
-01111011b ^ 00101010b = 01010001b
-01111011b ^ 00101011b = 01010000b
-01111011b ^ 00101100b = 01010111b
-01111011b ^ 00101101b = 01010110b
-01111011b ^ 00101110b = 01010101b
-01111011b ^ 00101111b = 01010100b
-01111011b ^ 00110000b = 01001011b
-01111011b ^ 00110001b = 01001010b
-01111011b ^ 00110010b = 01001001b
-01111011b ^ 00110011b = 01001000b
-01111011b ^ 00110100b = 01001111b
-01111011b ^ 00110101b = 01001110b
-01111011b ^ 00110110b = 01001101b
-01111011b ^ 00110111b = 01001100b
-01111011b ^ 00111000b = 01000011b
-01111011b ^ 00111001b = 01000010b
-01111011b ^ 00111010b = 01000001b
-01111011b ^ 00111011b = 01000000b
-01111011b ^ 00111100b = 01000111b
-01111011b ^ 00111101b = 01000110b
-01111011b ^ 00111110b = 01000101b
-01111011b ^ 00111111b = 01000100b
-01111011b ^ 01000000b = 00111011b
-01111011b ^ 01000001b = 00111010b
-01111011b ^ 01000010b = 00111001b
-01111011b ^ 01000011b = 00111000b
-01111011b ^ 01000100b = 00111111b
-01111011b ^ 01000101b = 00111110b
-01111011b ^ 01000110b = 00111101b
-01111011b ^ 01000111b = 00111100b
-01111011b ^ 01001000b = 00110011b
-01111011b ^ 01001001b = 00110010b
-01111011b ^ 01001010b = 00110001b
-01111011b ^ 01001011b = 00110000b
-01111011b ^ 01001100b = 00110111b
-01111011b ^ 01001101b = 00110110b
-01111011b ^ 01001110b = 00110101b
-01111011b ^ 01001111b = 00110100b
-01111011b ^ 01010000b = 00101011b
-01111011b ^ 01010001b = 00101010b
-01111011b ^ 01010010b = 00101001b
-01111011b ^ 01010011b = 00101000b
-01111011b ^ 01010100b = 00101111b
-01111011b ^ 01010101b = 00101110b
-01111011b ^ 01010110b = 00101101b
-01111011b ^ 01010111b = 00101100b
-01111011b ^ 01011000b = 00100011b
-01111011b ^ 01011001b = 00100010b
-01111011b ^ 01011010b = 00100001b
-01111011b ^ 01011011b = 00100000b
-01111011b ^ 01011100b = 00100111b
-01111011b ^ 01011101b = 00100110b
-01111011b ^ 01011110b = 00100101b
-01111011b ^ 01011111b = 00100100b
-01111011b ^ 01100000b = 00011011b
-01111011b ^ 01100001b = 00011010b
-01111011b ^ 01100010b = 00011001b
-01111011b ^ 01100011b = 00011000b
-01111011b ^ 01100100b = 00011111b
-01111011b ^ 01100101b = 00011110b
-01111011b ^ 01100110b = 00011101b
-01111011b ^ 01100111b = 00011100b
-01111011b ^ 01101000b = 00010011b
-01111011b ^ 01101001b = 00010010b
-01111011b ^ 01101010b = 00010001b
-01111011b ^ 01101011b = 00010000b
-01111011b ^ 01101100b = 00010111b
-01111011b ^ 01101101b = 00010110b
-01111011b ^ 01101110b = 00010101b
-01111011b ^ 01101111b = 00010100b
-01111011b ^ 01110000b = 00001011b
-01111011b ^ 01110001b = 00001010b
-01111011b ^ 01110010b = 00001001b
-01111011b ^ 01110011b = 00001000b
-01111011b ^ 01110100b = 00001111b
-01111011b ^ 01110101b = 00001110b
-01111011b ^ 01110110b = 00001101b
-01111011b ^ 01110111b = 00001100b
-01111011b ^ 01111000b = 00000011b
-01111011b ^ 01111001b = 00000010b
-01111011b ^ 01111010b = 00000001b
-01111011b ^ 01111011b = 00000000b
-01111011b ^ 01111100b = 00000111b
-01111011b ^ 01111101b = 00000110b
-01111011b ^ 01111110b = 00000101b
-01111100b ^ 10000000b = 11111100b
-01111100b ^ 10000001b = 11111101b
-01111100b ^ 10000010b = 11111110b
-01111100b ^ 10000011b = 11111111b
-01111100b ^ 10000100b = 11111000b
-01111100b ^ 10000101b = 11111001b
-01111100b ^ 10000110b = 11111010b
-01111100b ^ 10000111b = 11111011b
-01111100b ^ 10001000b = 11110100b
-01111100b ^ 10001001b = 11110101b
-01111100b ^ 10001010b = 11110110b
-01111100b ^ 10001011b = 11110111b
-01111100b ^ 10001100b = 11110000b
-01111100b ^ 10001101b = 11110001b
-01111100b ^ 10001110b = 11110010b
-01111100b ^ 10001111b = 11110011b
-01111100b ^ 10010000b = 11101100b
-01111100b ^ 10010001b = 11101101b
-01111100b ^ 10010010b = 11101110b
-01111100b ^ 10010011b = 11101111b
-01111100b ^ 10010100b = 11101000b
-01111100b ^ 10010101b = 11101001b
-01111100b ^ 10010110b = 11101010b
-01111100b ^ 10010111b = 11101011b
-01111100b ^ 10011000b = 11100100b
-01111100b ^ 10011001b = 11100101b
-01111100b ^ 10011010b = 11100110b
-01111100b ^ 10011011b = 11100111b
-01111100b ^ 10011100b = 11100000b
-01111100b ^ 10011101b = 11100001b
-01111100b ^ 10011110b = 11100010b
-01111100b ^ 10011111b = 11100011b
-01111100b ^ 10100000b = 11011100b
-01111100b ^ 10100001b = 11011101b
-01111100b ^ 10100010b = 11011110b
-01111100b ^ 10100011b = 11011111b
-01111100b ^ 10100100b = 11011000b
-01111100b ^ 10100101b = 11011001b
-01111100b ^ 10100110b = 11011010b
-01111100b ^ 10100111b = 11011011b
-01111100b ^ 10101000b = 11010100b
-01111100b ^ 10101001b = 11010101b
-01111100b ^ 10101010b = 11010110b
-01111100b ^ 10101011b = 11010111b
-01111100b ^ 10101100b = 11010000b
-01111100b ^ 10101101b = 11010001b
-01111100b ^ 10101110b = 11010010b
-01111100b ^ 10101111b = 11010011b
-01111100b ^ 10110000b = 11001100b
-01111100b ^ 10110001b = 11001101b
-01111100b ^ 10110010b = 11001110b
-01111100b ^ 10110011b = 11001111b
-01111100b ^ 10110100b = 11001000b
-01111100b ^ 10110101b = 11001001b
-01111100b ^ 10110110b = 11001010b
-01111100b ^ 10110111b = 11001011b
-01111100b ^ 10111000b = 11000100b
-01111100b ^ 10111001b = 11000101b
-01111100b ^ 10111010b = 11000110b
-01111100b ^ 10111011b = 11000111b
-01111100b ^ 10111100b = 11000000b
-01111100b ^ 10111101b = 11000001b
-01111100b ^ 10111110b = 11000010b
-01111100b ^ 10111111b = 11000011b
-01111100b ^ 11000000b = 10111100b
-01111100b ^ 11000001b = 10111101b
-01111100b ^ 11000010b = 10111110b
-01111100b ^ 11000011b = 10111111b
-01111100b ^ 11000100b = 10111000b
-01111100b ^ 11000101b = 10111001b
-01111100b ^ 11000110b = 10111010b
-01111100b ^ 11000111b = 10111011b
-01111100b ^ 11001000b = 10110100b
-01111100b ^ 11001001b = 10110101b
-01111100b ^ 11001010b = 10110110b
-01111100b ^ 11001011b = 10110111b
-01111100b ^ 11001100b = 10110000b
-01111100b ^ 11001101b = 10110001b
-01111100b ^ 11001110b = 10110010b
-01111100b ^ 11001111b = 10110011b
-01111100b ^ 11010000b = 10101100b
-01111100b ^ 11010001b = 10101101b
-01111100b ^ 11010010b = 10101110b
-01111100b ^ 11010011b = 10101111b
-01111100b ^ 11010100b = 10101000b
-01111100b ^ 11010101b = 10101001b
-01111100b ^ 11010110b = 10101010b
-01111100b ^ 11010111b = 10101011b
-01111100b ^ 11011000b = 10100100b
-01111100b ^ 11011001b = 10100101b
-01111100b ^ 11011010b = 10100110b
-01111100b ^ 11011011b = 10100111b
-01111100b ^ 11011100b = 10100000b
-01111100b ^ 11011101b = 10100001b
-01111100b ^ 11011110b = 10100010b
-01111100b ^ 11011111b = 10100011b
-01111100b ^ 11100000b = 10011100b
-01111100b ^ 11100001b = 10011101b
-01111100b ^ 11100010b = 10011110b
-01111100b ^ 11100011b = 10011111b
-01111100b ^ 11100100b = 10011000b
-01111100b ^ 11100101b = 10011001b
-01111100b ^ 11100110b = 10011010b
-01111100b ^ 11100111b = 10011011b
-01111100b ^ 11101000b = 10010100b
-01111100b ^ 11101001b = 10010101b
-01111100b ^ 11101010b = 10010110b
-01111100b ^ 11101011b = 10010111b
-01111100b ^ 11101100b = 10010000b
-01111100b ^ 11101101b = 10010001b
-01111100b ^ 11101110b = 10010010b
-01111100b ^ 11101111b = 10010011b
-01111100b ^ 11110000b = 10001100b
-01111100b ^ 11110001b = 10001101b
-01111100b ^ 11110010b = 10001110b
-01111100b ^ 11110011b = 10001111b
-01111100b ^ 11110100b = 10001000b
-01111100b ^ 11110101b = 10001001b
-01111100b ^ 11110110b = 10001010b
-01111100b ^ 11110111b = 10001011b
-01111100b ^ 11111000b = 10000100b
-01111100b ^ 11111001b = 10000101b
-01111100b ^ 11111010b = 10000110b
-01111100b ^ 11111011b = 10000111b
-01111100b ^ 11111100b = 10000000b
-01111100b ^ 11111101b = 10000001b
-01111100b ^ 11111110b = 10000010b
-01111100b ^ 11111111b = 10000011b
-01111100b ^ 00000000b = 01111100b
-01111100b ^ 00000001b = 01111101b
-01111100b ^ 00000010b = 01111110b
-01111100b ^ 00000011b = 01111111b
-01111100b ^ 00000100b = 01111000b
-01111100b ^ 00000101b = 01111001b
-01111100b ^ 00000110b = 01111010b
-01111100b ^ 00000111b = 01111011b
-01111100b ^ 00001000b = 01110100b
-01111100b ^ 00001001b = 01110101b
-01111100b ^ 00001010b = 01110110b
-01111100b ^ 00001011b = 01110111b
-01111100b ^ 00001100b = 01110000b
-01111100b ^ 00001101b = 01110001b
-01111100b ^ 00001110b = 01110010b
-01111100b ^ 00001111b = 01110011b
-01111100b ^ 00010000b = 01101100b
-01111100b ^ 00010001b = 01101101b
-01111100b ^ 00010010b = 01101110b
-01111100b ^ 00010011b = 01101111b
-01111100b ^ 00010100b = 01101000b
-01111100b ^ 00010101b = 01101001b
-01111100b ^ 00010110b = 01101010b
-01111100b ^ 00010111b = 01101011b
-01111100b ^ 00011000b = 01100100b
-01111100b ^ 00011001b = 01100101b
-01111100b ^ 00011010b = 01100110b
-01111100b ^ 00011011b = 01100111b
-01111100b ^ 00011100b = 01100000b
-01111100b ^ 00011101b = 01100001b
-01111100b ^ 00011110b = 01100010b
-01111100b ^ 00011111b = 01100011b
-01111100b ^ 00100000b = 01011100b
-01111100b ^ 00100001b = 01011101b
-01111100b ^ 00100010b = 01011110b
-01111100b ^ 00100011b = 01011111b
-01111100b ^ 00100100b = 01011000b
-01111100b ^ 00100101b = 01011001b
-01111100b ^ 00100110b = 01011010b
-01111100b ^ 00100111b = 01011011b
-01111100b ^ 00101000b = 01010100b
-01111100b ^ 00101001b = 01010101b
-01111100b ^ 00101010b = 01010110b
-01111100b ^ 00101011b = 01010111b
-01111100b ^ 00101100b = 01010000b
-01111100b ^ 00101101b = 01010001b
-01111100b ^ 00101110b = 01010010b
-01111100b ^ 00101111b = 01010011b
-01111100b ^ 00110000b = 01001100b
-01111100b ^ 00110001b = 01001101b
-01111100b ^ 00110010b = 01001110b
-01111100b ^ 00110011b = 01001111b
-01111100b ^ 00110100b = 01001000b
-01111100b ^ 00110101b = 01001001b
-01111100b ^ 00110110b = 01001010b
-01111100b ^ 00110111b = 01001011b
-01111100b ^ 00111000b = 01000100b
-01111100b ^ 00111001b = 01000101b
-01111100b ^ 00111010b = 01000110b
-01111100b ^ 00111011b = 01000111b
-01111100b ^ 00111100b = 01000000b
-01111100b ^ 00111101b = 01000001b
-01111100b ^ 00111110b = 01000010b
-01111100b ^ 00111111b = 01000011b
-01111100b ^ 01000000b = 00111100b
-01111100b ^ 01000001b = 00111101b
-01111100b ^ 01000010b = 00111110b
-01111100b ^ 01000011b = 00111111b
-01111100b ^ 01000100b = 00111000b
-01111100b ^ 01000101b = 00111001b
-01111100b ^ 01000110b = 00111010b
-01111100b ^ 01000111b = 00111011b
-01111100b ^ 01001000b = 00110100b
-01111100b ^ 01001001b = 00110101b
-01111100b ^ 01001010b = 00110110b
-01111100b ^ 01001011b = 00110111b
-01111100b ^ 01001100b = 00110000b
-01111100b ^ 01001101b = 00110001b
-01111100b ^ 01001110b = 00110010b
-01111100b ^ 01001111b = 00110011b
-01111100b ^ 01010000b = 00101100b
-01111100b ^ 01010001b = 00101101b
-01111100b ^ 01010010b = 00101110b
-01111100b ^ 01010011b = 00101111b
-01111100b ^ 01010100b = 00101000b
-01111100b ^ 01010101b = 00101001b
-01111100b ^ 01010110b = 00101010b
-01111100b ^ 01010111b = 00101011b
-01111100b ^ 01011000b = 00100100b
-01111100b ^ 01011001b = 00100101b
-01111100b ^ 01011010b = 00100110b
-01111100b ^ 01011011b = 00100111b
-01111100b ^ 01011100b = 00100000b
-01111100b ^ 01011101b = 00100001b
-01111100b ^ 01011110b = 00100010b
-01111100b ^ 01011111b = 00100011b
-01111100b ^ 01100000b = 00011100b
-01111100b ^ 01100001b = 00011101b
-01111100b ^ 01100010b = 00011110b
-01111100b ^ 01100011b = 00011111b
-01111100b ^ 01100100b = 00011000b
-01111100b ^ 01100101b = 00011001b
-01111100b ^ 01100110b = 00011010b
-01111100b ^ 01100111b = 00011011b
-01111100b ^ 01101000b = 00010100b
-01111100b ^ 01101001b = 00010101b
-01111100b ^ 01101010b = 00010110b
-01111100b ^ 01101011b = 00010111b
-01111100b ^ 01101100b = 00010000b
-01111100b ^ 01101101b = 00010001b
-01111100b ^ 01101110b = 00010010b
-01111100b ^ 01101111b = 00010011b
-01111100b ^ 01110000b = 00001100b
-01111100b ^ 01110001b = 00001101b
-01111100b ^ 01110010b = 00001110b
-01111100b ^ 01110011b = 00001111b
-01111100b ^ 01110100b = 00001000b
-01111100b ^ 01110101b = 00001001b
-01111100b ^ 01110110b = 00001010b
-01111100b ^ 01110111b = 00001011b
-01111100b ^ 01111000b = 00000100b
-01111100b ^ 01111001b = 00000101b
-01111100b ^ 01111010b = 00000110b
-01111100b ^ 01111011b = 00000111b
-01111100b ^ 01111100b = 00000000b
-01111100b ^ 01111101b = 00000001b
-01111100b ^ 01111110b = 00000010b
-01111101b ^ 10000000b = 11111101b
-01111101b ^ 10000001b = 11111100b
-01111101b ^ 10000010b = 11111111b
-01111101b ^ 10000011b = 11111110b
-01111101b ^ 10000100b = 11111001b
-01111101b ^ 10000101b = 11111000b
-01111101b ^ 10000110b = 11111011b
-01111101b ^ 10000111b = 11111010b
-01111101b ^ 10001000b = 11110101b
-01111101b ^ 10001001b = 11110100b
-01111101b ^ 10001010b = 11110111b
-01111101b ^ 10001011b = 11110110b
-01111101b ^ 10001100b = 11110001b
-01111101b ^ 10001101b = 11110000b
-01111101b ^ 10001110b = 11110011b
-01111101b ^ 10001111b = 11110010b
-01111101b ^ 10010000b = 11101101b
-01111101b ^ 10010001b = 11101100b
-01111101b ^ 10010010b = 11101111b
-01111101b ^ 10010011b = 11101110b
-01111101b ^ 10010100b = 11101001b
-01111101b ^ 10010101b = 11101000b
-01111101b ^ 10010110b = 11101011b
-01111101b ^ 10010111b = 11101010b
-01111101b ^ 10011000b = 11100101b
-01111101b ^ 10011001b = 11100100b
-01111101b ^ 10011010b = 11100111b
-01111101b ^ 10011011b = 11100110b
-01111101b ^ 10011100b = 11100001b
-01111101b ^ 10011101b = 11100000b
-01111101b ^ 10011110b = 11100011b
-01111101b ^ 10011111b = 11100010b
-01111101b ^ 10100000b = 11011101b
-01111101b ^ 10100001b = 11011100b
-01111101b ^ 10100010b = 11011111b
-01111101b ^ 10100011b = 11011110b
-01111101b ^ 10100100b = 11011001b
-01111101b ^ 10100101b = 11011000b
-01111101b ^ 10100110b = 11011011b
-01111101b ^ 10100111b = 11011010b
-01111101b ^ 10101000b = 11010101b
-01111101b ^ 10101001b = 11010100b
-01111101b ^ 10101010b = 11010111b
-01111101b ^ 10101011b = 11010110b
-01111101b ^ 10101100b = 11010001b
-01111101b ^ 10101101b = 11010000b
-01111101b ^ 10101110b = 11010011b
-01111101b ^ 10101111b = 11010010b
-01111101b ^ 10110000b = 11001101b
-01111101b ^ 10110001b = 11001100b
-01111101b ^ 10110010b = 11001111b
-01111101b ^ 10110011b = 11001110b
-01111101b ^ 10110100b = 11001001b
-01111101b ^ 10110101b = 11001000b
-01111101b ^ 10110110b = 11001011b
-01111101b ^ 10110111b = 11001010b
-01111101b ^ 10111000b = 11000101b
-01111101b ^ 10111001b = 11000100b
-01111101b ^ 10111010b = 11000111b
-01111101b ^ 10111011b = 11000110b
-01111101b ^ 10111100b = 11000001b
-01111101b ^ 10111101b = 11000000b
-01111101b ^ 10111110b = 11000011b
-01111101b ^ 10111111b = 11000010b
-01111101b ^ 11000000b = 10111101b
-01111101b ^ 11000001b = 10111100b
-01111101b ^ 11000010b = 10111111b
-01111101b ^ 11000011b = 10111110b
-01111101b ^ 11000100b = 10111001b
-01111101b ^ 11000101b = 10111000b
-01111101b ^ 11000110b = 10111011b
-01111101b ^ 11000111b = 10111010b
-01111101b ^ 11001000b = 10110101b
-01111101b ^ 11001001b = 10110100b
-01111101b ^ 11001010b = 10110111b
-01111101b ^ 11001011b = 10110110b
-01111101b ^ 11001100b = 10110001b
-01111101b ^ 11001101b = 10110000b
-01111101b ^ 11001110b = 10110011b
-01111101b ^ 11001111b = 10110010b
-01111101b ^ 11010000b = 10101101b
-01111101b ^ 11010001b = 10101100b
-01111101b ^ 11010010b = 10101111b
-01111101b ^ 11010011b = 10101110b
-01111101b ^ 11010100b = 10101001b
-01111101b ^ 11010101b = 10101000b
-01111101b ^ 11010110b = 10101011b
-01111101b ^ 11010111b = 10101010b
-01111101b ^ 11011000b = 10100101b
-01111101b ^ 11011001b = 10100100b
-01111101b ^ 11011010b = 10100111b
-01111101b ^ 11011011b = 10100110b
-01111101b ^ 11011100b = 10100001b
-01111101b ^ 11011101b = 10100000b
-01111101b ^ 11011110b = 10100011b
-01111101b ^ 11011111b = 10100010b
-01111101b ^ 11100000b = 10011101b
-01111101b ^ 11100001b = 10011100b
-01111101b ^ 11100010b = 10011111b
-01111101b ^ 11100011b = 10011110b
-01111101b ^ 11100100b = 10011001b
-01111101b ^ 11100101b = 10011000b
-01111101b ^ 11100110b = 10011011b
-01111101b ^ 11100111b = 10011010b
-01111101b ^ 11101000b = 10010101b
-01111101b ^ 11101001b = 10010100b
-01111101b ^ 11101010b = 10010111b
-01111101b ^ 11101011b = 10010110b
-01111101b ^ 11101100b = 10010001b
-01111101b ^ 11101101b = 10010000b
-01111101b ^ 11101110b = 10010011b
-01111101b ^ 11101111b = 10010010b
-01111101b ^ 11110000b = 10001101b
-01111101b ^ 11110001b = 10001100b
-01111101b ^ 11110010b = 10001111b
-01111101b ^ 11110011b = 10001110b
-01111101b ^ 11110100b = 10001001b
-01111101b ^ 11110101b = 10001000b
-01111101b ^ 11110110b = 10001011b
-01111101b ^ 11110111b = 10001010b
-01111101b ^ 11111000b = 10000101b
-01111101b ^ 11111001b = 10000100b
-01111101b ^ 11111010b = 10000111b
-01111101b ^ 11111011b = 10000110b
-01111101b ^ 11111100b = 10000001b
-01111101b ^ 11111101b = 10000000b
-01111101b ^ 11111110b = 10000011b
-01111101b ^ 11111111b = 10000010b
-01111101b ^ 00000000b = 01111101b
-01111101b ^ 00000001b = 01111100b
-01111101b ^ 00000010b = 01111111b
-01111101b ^ 00000011b = 01111110b
-01111101b ^ 00000100b = 01111001b
-01111101b ^ 00000101b = 01111000b
-01111101b ^ 00000110b = 01111011b
-01111101b ^ 00000111b = 01111010b
-01111101b ^ 00001000b = 01110101b
-01111101b ^ 00001001b = 01110100b
-01111101b ^ 00001010b = 01110111b
-01111101b ^ 00001011b = 01110110b
-01111101b ^ 00001100b = 01110001b
-01111101b ^ 00001101b = 01110000b
-01111101b ^ 00001110b = 01110011b
-01111101b ^ 00001111b = 01110010b
-01111101b ^ 00010000b = 01101101b
-01111101b ^ 00010001b = 01101100b
-01111101b ^ 00010010b = 01101111b
-01111101b ^ 00010011b = 01101110b
-01111101b ^ 00010100b = 01101001b
-01111101b ^ 00010101b = 01101000b
-01111101b ^ 00010110b = 01101011b
-01111101b ^ 00010111b = 01101010b
-01111101b ^ 00011000b = 01100101b
-01111101b ^ 00011001b = 01100100b
-01111101b ^ 00011010b = 01100111b
-01111101b ^ 00011011b = 01100110b
-01111101b ^ 00011100b = 01100001b
-01111101b ^ 00011101b = 01100000b
-01111101b ^ 00011110b = 01100011b
-01111101b ^ 00011111b = 01100010b
-01111101b ^ 00100000b = 01011101b
-01111101b ^ 00100001b = 01011100b
-01111101b ^ 00100010b = 01011111b
-01111101b ^ 00100011b = 01011110b
-01111101b ^ 00100100b = 01011001b
-01111101b ^ 00100101b = 01011000b
-01111101b ^ 00100110b = 01011011b
-01111101b ^ 00100111b = 01011010b
-01111101b ^ 00101000b = 01010101b
-01111101b ^ 00101001b = 01010100b
-01111101b ^ 00101010b = 01010111b
-01111101b ^ 00101011b = 01010110b
-01111101b ^ 00101100b = 01010001b
-01111101b ^ 00101101b = 01010000b
-01111101b ^ 00101110b = 01010011b
-01111101b ^ 00101111b = 01010010b
-01111101b ^ 00110000b = 01001101b
-01111101b ^ 00110001b = 01001100b
-01111101b ^ 00110010b = 01001111b
-01111101b ^ 00110011b = 01001110b
-01111101b ^ 00110100b = 01001001b
-01111101b ^ 00110101b = 01001000b
-01111101b ^ 00110110b = 01001011b
-01111101b ^ 00110111b = 01001010b
-01111101b ^ 00111000b = 01000101b
-01111101b ^ 00111001b = 01000100b
-01111101b ^ 00111010b = 01000111b
-01111101b ^ 00111011b = 01000110b
-01111101b ^ 00111100b = 01000001b
-01111101b ^ 00111101b = 01000000b
-01111101b ^ 00111110b = 01000011b
-01111101b ^ 00111111b = 01000010b
-01111101b ^ 01000000b = 00111101b
-01111101b ^ 01000001b = 00111100b
-01111101b ^ 01000010b = 00111111b
-01111101b ^ 01000011b = 00111110b
-01111101b ^ 01000100b = 00111001b
-01111101b ^ 01000101b = 00111000b
-01111101b ^ 01000110b = 00111011b
-01111101b ^ 01000111b = 00111010b
-01111101b ^ 01001000b = 00110101b
-01111101b ^ 01001001b = 00110100b
-01111101b ^ 01001010b = 00110111b
-01111101b ^ 01001011b = 00110110b
-01111101b ^ 01001100b = 00110001b
-01111101b ^ 01001101b = 00110000b
-01111101b ^ 01001110b = 00110011b
-01111101b ^ 01001111b = 00110010b
-01111101b ^ 01010000b = 00101101b
-01111101b ^ 01010001b = 00101100b
-01111101b ^ 01010010b = 00101111b
-01111101b ^ 01010011b = 00101110b
-01111101b ^ 01010100b = 00101001b
-01111101b ^ 01010101b = 00101000b
-01111101b ^ 01010110b = 00101011b
-01111101b ^ 01010111b = 00101010b
-01111101b ^ 01011000b = 00100101b
-01111101b ^ 01011001b = 00100100b
-01111101b ^ 01011010b = 00100111b
-01111101b ^ 01011011b = 00100110b
-01111101b ^ 01011100b = 00100001b
-01111101b ^ 01011101b = 00100000b
-01111101b ^ 01011110b = 00100011b
-01111101b ^ 01011111b = 00100010b
-01111101b ^ 01100000b = 00011101b
-01111101b ^ 01100001b = 00011100b
-01111101b ^ 01100010b = 00011111b
-01111101b ^ 01100011b = 00011110b
-01111101b ^ 01100100b = 00011001b
-01111101b ^ 01100101b = 00011000b
-01111101b ^ 01100110b = 00011011b
-01111101b ^ 01100111b = 00011010b
-01111101b ^ 01101000b = 00010101b
-01111101b ^ 01101001b = 00010100b
-01111101b ^ 01101010b = 00010111b
-01111101b ^ 01101011b = 00010110b
-01111101b ^ 01101100b = 00010001b
-01111101b ^ 01101101b = 00010000b
-01111101b ^ 01101110b = 00010011b
-01111101b ^ 01101111b = 00010010b
-01111101b ^ 01110000b = 00001101b
-01111101b ^ 01110001b = 00001100b
-01111101b ^ 01110010b = 00001111b
-01111101b ^ 01110011b = 00001110b
-01111101b ^ 01110100b = 00001001b
-01111101b ^ 01110101b = 00001000b
-01111101b ^ 01110110b = 00001011b
-01111101b ^ 01110111b = 00001010b
-01111101b ^ 01111000b = 00000101b
-01111101b ^ 01111001b = 00000100b
-01111101b ^ 01111010b = 00000111b
-01111101b ^ 01111011b = 00000110b
-01111101b ^ 01111100b = 00000001b
-01111101b ^ 01111101b = 00000000b
-01111101b ^ 01111110b = 00000011b
-01111110b ^ 10000000b = 11111110b
-01111110b ^ 10000001b = 11111111b
-01111110b ^ 10000010b = 11111100b
-01111110b ^ 10000011b = 11111101b
-01111110b ^ 10000100b = 11111010b
-01111110b ^ 10000101b = 11111011b
-01111110b ^ 10000110b = 11111000b
-01111110b ^ 10000111b = 11111001b
-01111110b ^ 10001000b = 11110110b
-01111110b ^ 10001001b = 11110111b
-01111110b ^ 10001010b = 11110100b
-01111110b ^ 10001011b = 11110101b
-01111110b ^ 10001100b = 11110010b
-01111110b ^ 10001101b = 11110011b
-01111110b ^ 10001110b = 11110000b
-01111110b ^ 10001111b = 11110001b
-01111110b ^ 10010000b = 11101110b
-01111110b ^ 10010001b = 11101111b
-01111110b ^ 10010010b = 11101100b
-01111110b ^ 10010011b = 11101101b
-01111110b ^ 10010100b = 11101010b
-01111110b ^ 10010101b = 11101011b
-01111110b ^ 10010110b = 11101000b
-01111110b ^ 10010111b = 11101001b
-01111110b ^ 10011000b = 11100110b
-01111110b ^ 10011001b = 11100111b
-01111110b ^ 10011010b = 11100100b
-01111110b ^ 10011011b = 11100101b
-01111110b ^ 10011100b = 11100010b
-01111110b ^ 10011101b = 11100011b
-01111110b ^ 10011110b = 11100000b
-01111110b ^ 10011111b = 11100001b
-01111110b ^ 10100000b = 11011110b
-01111110b ^ 10100001b = 11011111b
-01111110b ^ 10100010b = 11011100b
-01111110b ^ 10100011b = 11011101b
-01111110b ^ 10100100b = 11011010b
-01111110b ^ 10100101b = 11011011b
-01111110b ^ 10100110b = 11011000b
-01111110b ^ 10100111b = 11011001b
-01111110b ^ 10101000b = 11010110b
-01111110b ^ 10101001b = 11010111b
-01111110b ^ 10101010b = 11010100b
-01111110b ^ 10101011b = 11010101b
-01111110b ^ 10101100b = 11010010b
-01111110b ^ 10101101b = 11010011b
-01111110b ^ 10101110b = 11010000b
-01111110b ^ 10101111b = 11010001b
-01111110b ^ 10110000b = 11001110b
-01111110b ^ 10110001b = 11001111b
-01111110b ^ 10110010b = 11001100b
-01111110b ^ 10110011b = 11001101b
-01111110b ^ 10110100b = 11001010b
-01111110b ^ 10110101b = 11001011b
-01111110b ^ 10110110b = 11001000b
-01111110b ^ 10110111b = 11001001b
-01111110b ^ 10111000b = 11000110b
-01111110b ^ 10111001b = 11000111b
-01111110b ^ 10111010b = 11000100b
-01111110b ^ 10111011b = 11000101b
-01111110b ^ 10111100b = 11000010b
-01111110b ^ 10111101b = 11000011b
-01111110b ^ 10111110b = 11000000b
-01111110b ^ 10111111b = 11000001b
-01111110b ^ 11000000b = 10111110b
-01111110b ^ 11000001b = 10111111b
-01111110b ^ 11000010b = 10111100b
-01111110b ^ 11000011b = 10111101b
-01111110b ^ 11000100b = 10111010b
-01111110b ^ 11000101b = 10111011b
-01111110b ^ 11000110b = 10111000b
-01111110b ^ 11000111b = 10111001b
-01111110b ^ 11001000b = 10110110b
-01111110b ^ 11001001b = 10110111b
-01111110b ^ 11001010b = 10110100b
-01111110b ^ 11001011b = 10110101b
-01111110b ^ 11001100b = 10110010b
-01111110b ^ 11001101b = 10110011b
-01111110b ^ 11001110b = 10110000b
-01111110b ^ 11001111b = 10110001b
-01111110b ^ 11010000b = 10101110b
-01111110b ^ 11010001b = 10101111b
-01111110b ^ 11010010b = 10101100b
-01111110b ^ 11010011b = 10101101b
-01111110b ^ 11010100b = 10101010b
-01111110b ^ 11010101b = 10101011b
-01111110b ^ 11010110b = 10101000b
-01111110b ^ 11010111b = 10101001b
-01111110b ^ 11011000b = 10100110b
-01111110b ^ 11011001b = 10100111b
-01111110b ^ 11011010b = 10100100b
-01111110b ^ 11011011b = 10100101b
-01111110b ^ 11011100b = 10100010b
-01111110b ^ 11011101b = 10100011b
-01111110b ^ 11011110b = 10100000b
-01111110b ^ 11011111b = 10100001b
-01111110b ^ 11100000b = 10011110b
-01111110b ^ 11100001b = 10011111b
-01111110b ^ 11100010b = 10011100b
-01111110b ^ 11100011b = 10011101b
-01111110b ^ 11100100b = 10011010b
-01111110b ^ 11100101b = 10011011b
-01111110b ^ 11100110b = 10011000b
-01111110b ^ 11100111b = 10011001b
-01111110b ^ 11101000b = 10010110b
-01111110b ^ 11101001b = 10010111b
-01111110b ^ 11101010b = 10010100b
-01111110b ^ 11101011b = 10010101b
-01111110b ^ 11101100b = 10010010b
-01111110b ^ 11101101b = 10010011b
-01111110b ^ 11101110b = 10010000b
-01111110b ^ 11101111b = 10010001b
-01111110b ^ 11110000b = 10001110b
-01111110b ^ 11110001b = 10001111b
-01111110b ^ 11110010b = 10001100b
-01111110b ^ 11110011b = 10001101b
-01111110b ^ 11110100b = 10001010b
-01111110b ^ 11110101b = 10001011b
-01111110b ^ 11110110b = 10001000b
-01111110b ^ 11110111b = 10001001b
-01111110b ^ 11111000b = 10000110b
-01111110b ^ 11111001b = 10000111b
-01111110b ^ 11111010b = 10000100b
-01111110b ^ 11111011b = 10000101b
-01111110b ^ 11111100b = 10000010b
-01111110b ^ 11111101b = 10000011b
-01111110b ^ 11111110b = 10000000b
-01111110b ^ 11111111b = 10000001b
-01111110b ^ 00000000b = 01111110b
-01111110b ^ 00000001b = 01111111b
-01111110b ^ 00000010b = 01111100b
-01111110b ^ 00000011b = 01111101b
-01111110b ^ 00000100b = 01111010b
-01111110b ^ 00000101b = 01111011b
-01111110b ^ 00000110b = 01111000b
-01111110b ^ 00000111b = 01111001b
-01111110b ^ 00001000b = 01110110b
-01111110b ^ 00001001b = 01110111b
-01111110b ^ 00001010b = 01110100b
-01111110b ^ 00001011b = 01110101b
-01111110b ^ 00001100b = 01110010b
-01111110b ^ 00001101b = 01110011b
-01111110b ^ 00001110b = 01110000b
-01111110b ^ 00001111b = 01110001b
-01111110b ^ 00010000b = 01101110b
-01111110b ^ 00010001b = 01101111b
-01111110b ^ 00010010b = 01101100b
-01111110b ^ 00010011b = 01101101b
-01111110b ^ 00010100b = 01101010b
-01111110b ^ 00010101b = 01101011b
-01111110b ^ 00010110b = 01101000b
-01111110b ^ 00010111b = 01101001b
-01111110b ^ 00011000b = 01100110b
-01111110b ^ 00011001b = 01100111b
-01111110b ^ 00011010b = 01100100b
-01111110b ^ 00011011b = 01100101b
-01111110b ^ 00011100b = 01100010b
-01111110b ^ 00011101b = 01100011b
-01111110b ^ 00011110b = 01100000b
-01111110b ^ 00011111b = 01100001b
-01111110b ^ 00100000b = 01011110b
-01111110b ^ 00100001b = 01011111b
-01111110b ^ 00100010b = 01011100b
-01111110b ^ 00100011b = 01011101b
-01111110b ^ 00100100b = 01011010b
-01111110b ^ 00100101b = 01011011b
-01111110b ^ 00100110b = 01011000b
-01111110b ^ 00100111b = 01011001b
-01111110b ^ 00101000b = 01010110b
-01111110b ^ 00101001b = 01010111b
-01111110b ^ 00101010b = 01010100b
-01111110b ^ 00101011b = 01010101b
-01111110b ^ 00101100b = 01010010b
-01111110b ^ 00101101b = 01010011b
-01111110b ^ 00101110b = 01010000b
-01111110b ^ 00101111b = 01010001b
-01111110b ^ 00110000b = 01001110b
-01111110b ^ 00110001b = 01001111b
-01111110b ^ 00110010b = 01001100b
-01111110b ^ 00110011b = 01001101b
-01111110b ^ 00110100b = 01001010b
-01111110b ^ 00110101b = 01001011b
-01111110b ^ 00110110b = 01001000b
-01111110b ^ 00110111b = 01001001b
-01111110b ^ 00111000b = 01000110b
-01111110b ^ 00111001b = 01000111b
-01111110b ^ 00111010b = 01000100b
-01111110b ^ 00111011b = 01000101b
-01111110b ^ 00111100b = 01000010b
-01111110b ^ 00111101b = 01000011b
-01111110b ^ 00111110b = 01000000b
-01111110b ^ 00111111b = 01000001b
-01111110b ^ 01000000b = 00111110b
-01111110b ^ 01000001b = 00111111b
-01111110b ^ 01000010b = 00111100b
-01111110b ^ 01000011b = 00111101b
-01111110b ^ 01000100b = 00111010b
-01111110b ^ 01000101b = 00111011b
-01111110b ^ 01000110b = 00111000b
-01111110b ^ 01000111b = 00111001b
-01111110b ^ 01001000b = 00110110b
-01111110b ^ 01001001b = 00110111b
-01111110b ^ 01001010b = 00110100b
-01111110b ^ 01001011b = 00110101b
-01111110b ^ 01001100b = 00110010b
-01111110b ^ 01001101b = 00110011b
-01111110b ^ 01001110b = 00110000b
-01111110b ^ 01001111b = 00110001b
-01111110b ^ 01010000b = 00101110b
-01111110b ^ 01010001b = 00101111b
-01111110b ^ 01010010b = 00101100b
-01111110b ^ 01010011b = 00101101b
-01111110b ^ 01010100b = 00101010b
-01111110b ^ 01010101b = 00101011b
-01111110b ^ 01010110b = 00101000b
-01111110b ^ 01010111b = 00101001b
-01111110b ^ 01011000b = 00100110b
-01111110b ^ 01011001b = 00100111b
-01111110b ^ 01011010b = 00100100b
-01111110b ^ 01011011b = 00100101b
-01111110b ^ 01011100b = 00100010b
-01111110b ^ 01011101b = 00100011b
-01111110b ^ 01011110b = 00100000b
-01111110b ^ 01011111b = 00100001b
-01111110b ^ 01100000b = 00011110b
-01111110b ^ 01100001b = 00011111b
-01111110b ^ 01100010b = 00011100b
-01111110b ^ 01100011b = 00011101b
-01111110b ^ 01100100b = 00011010b
-01111110b ^ 01100101b = 00011011b
-01111110b ^ 01100110b = 00011000b
-01111110b ^ 01100111b = 00011001b
-01111110b ^ 01101000b = 00010110b
-01111110b ^ 01101001b = 00010111b
-01111110b ^ 01101010b = 00010100b
-01111110b ^ 01101011b = 00010101b
-01111110b ^ 01101100b = 00010010b
-01111110b ^ 01101101b = 00010011b
-01111110b ^ 01101110b = 00010000b
-01111110b ^ 01101111b = 00010001b
-01111110b ^ 01110000b = 00001110b
-01111110b ^ 01110001b = 00001111b
-01111110b ^ 01110010b = 00001100b
-01111110b ^ 01110011b = 00001101b
-01111110b ^ 01110100b = 00001010b
-01111110b ^ 01110101b = 00001011b
-01111110b ^ 01110110b = 00001000b
-01111110b ^ 01110111b = 00001001b
-01111110b ^ 01111000b = 00000110b
-01111110b ^ 01111001b = 00000111b
-01111110b ^ 01111010b = 00000100b
-01111110b ^ 01111011b = 00000101b
-01111110b ^ 01111100b = 00000010b
-01111110b ^ 01111101b = 00000011b
-01111110b ^ 01111110b = 00000000b
diff --git a/tests/valid/Byte_Valid_4.whiley b/tests/valid/Byte_Valid_4.whiley
index dec85eedbd..3acb5bd251 100644
--- a/tests/valid/Byte_Valid_4.whiley
+++ b/tests/valid/Byte_Valid_4.whiley
@@ -1,11 +1,32 @@
-import whiley.lang.*
-import print from whiley.lang.*
+
constant constants is [10000000b, 10000001b, 10000010b, 10000011b, 10000100b, 10000101b, 10000110b, 10000111b, 10001000b, 10001001b, 10001010b, 10001011b, 10001100b, 10001101b, 10001110b, 10001111b, 10010000b, 10010001b, 10010010b, 10010011b, 10010100b, 10010101b, 10010110b, 10010111b, 10011000b, 10011001b, 10011010b, 10011011b, 10011100b, 10011101b, 10011110b, 10011111b, 10100000b, 10100001b, 10100010b, 10100011b, 10100100b, 10100101b, 10100110b, 10100111b, 10101000b, 10101001b, 10101010b, 10101011b, 10101100b, 10101101b, 10101110b, 10101111b, 10110000b, 10110001b, 10110010b, 10110011b, 10110100b, 10110101b, 10110110b, 10110111b, 10111000b, 10111001b, 10111010b, 10111011b, 10111100b, 10111101b, 10111110b, 10111111b, 11000000b, 11000001b, 11000010b, 11000011b, 11000100b, 11000101b, 11000110b, 11000111b, 11001000b, 11001001b, 11001010b, 11001011b, 11001100b, 11001101b, 11001110b, 11001111b, 11010000b, 11010001b, 11010010b, 11010011b, 11010100b, 11010101b, 11010110b, 11010111b, 11011000b, 11011001b, 11011010b, 11011011b, 11011100b, 11011101b, 11011110b, 11011111b, 11100000b, 11100001b, 11100010b, 11100011b, 11100100b, 11100101b, 11100110b, 11100111b, 11101000b, 11101001b, 11101010b, 11101011b, 11101100b, 11101101b, 11101110b, 11101111b, 11110000b, 11110001b, 11110010b, 11110011b, 11110100b, 11110101b, 11110110b, 11110111b, 11111000b, 11111001b, 11111010b, 11111011b, 11111100b, 11111101b, 11111110b, 11111111b, 00000000b, 00000001b, 00000010b, 00000011b, 00000100b, 00000101b, 00000110b, 00000111b, 00001000b, 00001001b, 00001010b, 00001011b, 00001100b, 00001101b, 00001110b, 00001111b, 00010000b, 00010001b, 00010010b, 00010011b, 00010100b, 00010101b, 00010110b, 00010111b, 00011000b, 00011001b, 00011010b, 00011011b, 00011100b, 00011101b, 00011110b, 00011111b, 00100000b, 00100001b, 00100010b, 00100011b, 00100100b, 00100101b, 00100110b, 00100111b, 00101000b, 00101001b, 00101010b, 00101011b, 00101100b, 00101101b, 00101110b, 00101111b, 00110000b, 00110001b, 00110010b, 00110011b, 00110100b, 00110101b, 00110110b, 00110111b, 00111000b, 00111001b, 00111010b, 00111011b, 00111100b, 00111101b, 00111110b, 00111111b, 01000000b, 01000001b, 01000010b, 01000011b, 01000100b, 01000101b, 01000110b, 01000111b, 01001000b, 01001001b, 01001010b, 01001011b, 01001100b, 01001101b, 01001110b, 01001111b, 01010000b, 01010001b, 01010010b, 01010011b, 01010100b, 01010101b, 01010110b, 01010111b, 01011000b, 01011001b, 01011010b, 01011011b, 01011100b, 01011101b, 01011110b, 01011111b, 01100000b, 01100001b, 01100010b, 01100011b, 01100100b, 01100101b, 01100110b, 01100111b, 01101000b, 01101001b, 01101010b, 01101011b, 01101100b, 01101101b, 01101110b, 01101111b, 01110000b, 01110001b, 01110010b, 01110011b, 01110100b, 01110101b, 01110110b, 01110111b, 01111000b, 01111001b, 01111010b, 01111011b, 01111100b, 01111101b, 01111110b]
-public method main(System.Console sys) -> void:
- for i in constants:
- for j in constants:
- sys.out.print_s(Any.toString(i) ++ " ^ ")
- sys.out.print_s(Any.toString(j) ++ " = ")
- sys.out.println_s(Any.toString(i ^ j))
+
+function set(byte b, int i) -> bool:
+ byte mask = 1b << i
+ return (b&mask) == mask
+
+function xor(byte b1, byte b2) -> byte:
+ byte mask = 1b
+ byte r = 0b
+ int i = 0
+ while i < 8:
+ if set(b1,i) != set(b2,i):
+ r = r | mask
+ mask = mask << 1
+ i = i + 1
+ //
+ return r
+
+public export method test() -> void:
+ int i = 0
+ while i < |constants|:
+ byte constant_i = constants[i]
+ int j = 0
+ while j < |constants|:
+ byte constant_j = constants[j]
+ assume (constant_i ^ constant_j) == xor(constant_i,constant_j)
+ j = j + 1
+ //
+ i = i + 1
diff --git a/tests/valid/Byte_Valid_5.sysout b/tests/valid/Byte_Valid_5.sysout
deleted file mode 100644
index 5414ff7b65..0000000000
--- a/tests/valid/Byte_Valid_5.sysout
+++ /dev/null
@@ -1,2295 +0,0 @@
-10000000b << 0 = 10000000b
-10000000b << 1 = 00000000b
-10000000b << 2 = 00000000b
-10000000b << 3 = 00000000b
-10000000b << 4 = 00000000b
-10000000b << 5 = 00000000b
-10000000b << 6 = 00000000b
-10000000b << 7 = 00000000b
-10000000b << 8 = 00000000b
-10000001b << 0 = 10000001b
-10000001b << 1 = 00000010b
-10000001b << 2 = 00000100b
-10000001b << 3 = 00001000b
-10000001b << 4 = 00010000b
-10000001b << 5 = 00100000b
-10000001b << 6 = 01000000b
-10000001b << 7 = 10000000b
-10000001b << 8 = 00000000b
-10000010b << 0 = 10000010b
-10000010b << 1 = 00000100b
-10000010b << 2 = 00001000b
-10000010b << 3 = 00010000b
-10000010b << 4 = 00100000b
-10000010b << 5 = 01000000b
-10000010b << 6 = 10000000b
-10000010b << 7 = 00000000b
-10000010b << 8 = 00000000b
-10000011b << 0 = 10000011b
-10000011b << 1 = 00000110b
-10000011b << 2 = 00001100b
-10000011b << 3 = 00011000b
-10000011b << 4 = 00110000b
-10000011b << 5 = 01100000b
-10000011b << 6 = 11000000b
-10000011b << 7 = 10000000b
-10000011b << 8 = 00000000b
-10000100b << 0 = 10000100b
-10000100b << 1 = 00001000b
-10000100b << 2 = 00010000b
-10000100b << 3 = 00100000b
-10000100b << 4 = 01000000b
-10000100b << 5 = 10000000b
-10000100b << 6 = 00000000b
-10000100b << 7 = 00000000b
-10000100b << 8 = 00000000b
-10000101b << 0 = 10000101b
-10000101b << 1 = 00001010b
-10000101b << 2 = 00010100b
-10000101b << 3 = 00101000b
-10000101b << 4 = 01010000b
-10000101b << 5 = 10100000b
-10000101b << 6 = 01000000b
-10000101b << 7 = 10000000b
-10000101b << 8 = 00000000b
-10000110b << 0 = 10000110b
-10000110b << 1 = 00001100b
-10000110b << 2 = 00011000b
-10000110b << 3 = 00110000b
-10000110b << 4 = 01100000b
-10000110b << 5 = 11000000b
-10000110b << 6 = 10000000b
-10000110b << 7 = 00000000b
-10000110b << 8 = 00000000b
-10000111b << 0 = 10000111b
-10000111b << 1 = 00001110b
-10000111b << 2 = 00011100b
-10000111b << 3 = 00111000b
-10000111b << 4 = 01110000b
-10000111b << 5 = 11100000b
-10000111b << 6 = 11000000b
-10000111b << 7 = 10000000b
-10000111b << 8 = 00000000b
-10001000b << 0 = 10001000b
-10001000b << 1 = 00010000b
-10001000b << 2 = 00100000b
-10001000b << 3 = 01000000b
-10001000b << 4 = 10000000b
-10001000b << 5 = 00000000b
-10001000b << 6 = 00000000b
-10001000b << 7 = 00000000b
-10001000b << 8 = 00000000b
-10001001b << 0 = 10001001b
-10001001b << 1 = 00010010b
-10001001b << 2 = 00100100b
-10001001b << 3 = 01001000b
-10001001b << 4 = 10010000b
-10001001b << 5 = 00100000b
-10001001b << 6 = 01000000b
-10001001b << 7 = 10000000b
-10001001b << 8 = 00000000b
-10001010b << 0 = 10001010b
-10001010b << 1 = 00010100b
-10001010b << 2 = 00101000b
-10001010b << 3 = 01010000b
-10001010b << 4 = 10100000b
-10001010b << 5 = 01000000b
-10001010b << 6 = 10000000b
-10001010b << 7 = 00000000b
-10001010b << 8 = 00000000b
-10001011b << 0 = 10001011b
-10001011b << 1 = 00010110b
-10001011b << 2 = 00101100b
-10001011b << 3 = 01011000b
-10001011b << 4 = 10110000b
-10001011b << 5 = 01100000b
-10001011b << 6 = 11000000b
-10001011b << 7 = 10000000b
-10001011b << 8 = 00000000b
-10001100b << 0 = 10001100b
-10001100b << 1 = 00011000b
-10001100b << 2 = 00110000b
-10001100b << 3 = 01100000b
-10001100b << 4 = 11000000b
-10001100b << 5 = 10000000b
-10001100b << 6 = 00000000b
-10001100b << 7 = 00000000b
-10001100b << 8 = 00000000b
-10001101b << 0 = 10001101b
-10001101b << 1 = 00011010b
-10001101b << 2 = 00110100b
-10001101b << 3 = 01101000b
-10001101b << 4 = 11010000b
-10001101b << 5 = 10100000b
-10001101b << 6 = 01000000b
-10001101b << 7 = 10000000b
-10001101b << 8 = 00000000b
-10001110b << 0 = 10001110b
-10001110b << 1 = 00011100b
-10001110b << 2 = 00111000b
-10001110b << 3 = 01110000b
-10001110b << 4 = 11100000b
-10001110b << 5 = 11000000b
-10001110b << 6 = 10000000b
-10001110b << 7 = 00000000b
-10001110b << 8 = 00000000b
-10001111b << 0 = 10001111b
-10001111b << 1 = 00011110b
-10001111b << 2 = 00111100b
-10001111b << 3 = 01111000b
-10001111b << 4 = 11110000b
-10001111b << 5 = 11100000b
-10001111b << 6 = 11000000b
-10001111b << 7 = 10000000b
-10001111b << 8 = 00000000b
-10010000b << 0 = 10010000b
-10010000b << 1 = 00100000b
-10010000b << 2 = 01000000b
-10010000b << 3 = 10000000b
-10010000b << 4 = 00000000b
-10010000b << 5 = 00000000b
-10010000b << 6 = 00000000b
-10010000b << 7 = 00000000b
-10010000b << 8 = 00000000b
-10010001b << 0 = 10010001b
-10010001b << 1 = 00100010b
-10010001b << 2 = 01000100b
-10010001b << 3 = 10001000b
-10010001b << 4 = 00010000b
-10010001b << 5 = 00100000b
-10010001b << 6 = 01000000b
-10010001b << 7 = 10000000b
-10010001b << 8 = 00000000b
-10010010b << 0 = 10010010b
-10010010b << 1 = 00100100b
-10010010b << 2 = 01001000b
-10010010b << 3 = 10010000b
-10010010b << 4 = 00100000b
-10010010b << 5 = 01000000b
-10010010b << 6 = 10000000b
-10010010b << 7 = 00000000b
-10010010b << 8 = 00000000b
-10010011b << 0 = 10010011b
-10010011b << 1 = 00100110b
-10010011b << 2 = 01001100b
-10010011b << 3 = 10011000b
-10010011b << 4 = 00110000b
-10010011b << 5 = 01100000b
-10010011b << 6 = 11000000b
-10010011b << 7 = 10000000b
-10010011b << 8 = 00000000b
-10010100b << 0 = 10010100b
-10010100b << 1 = 00101000b
-10010100b << 2 = 01010000b
-10010100b << 3 = 10100000b
-10010100b << 4 = 01000000b
-10010100b << 5 = 10000000b
-10010100b << 6 = 00000000b
-10010100b << 7 = 00000000b
-10010100b << 8 = 00000000b
-10010101b << 0 = 10010101b
-10010101b << 1 = 00101010b
-10010101b << 2 = 01010100b
-10010101b << 3 = 10101000b
-10010101b << 4 = 01010000b
-10010101b << 5 = 10100000b
-10010101b << 6 = 01000000b
-10010101b << 7 = 10000000b
-10010101b << 8 = 00000000b
-10010110b << 0 = 10010110b
-10010110b << 1 = 00101100b
-10010110b << 2 = 01011000b
-10010110b << 3 = 10110000b
-10010110b << 4 = 01100000b
-10010110b << 5 = 11000000b
-10010110b << 6 = 10000000b
-10010110b << 7 = 00000000b
-10010110b << 8 = 00000000b
-10010111b << 0 = 10010111b
-10010111b << 1 = 00101110b
-10010111b << 2 = 01011100b
-10010111b << 3 = 10111000b
-10010111b << 4 = 01110000b
-10010111b << 5 = 11100000b
-10010111b << 6 = 11000000b
-10010111b << 7 = 10000000b
-10010111b << 8 = 00000000b
-10011000b << 0 = 10011000b
-10011000b << 1 = 00110000b
-10011000b << 2 = 01100000b
-10011000b << 3 = 11000000b
-10011000b << 4 = 10000000b
-10011000b << 5 = 00000000b
-10011000b << 6 = 00000000b
-10011000b << 7 = 00000000b
-10011000b << 8 = 00000000b
-10011001b << 0 = 10011001b
-10011001b << 1 = 00110010b
-10011001b << 2 = 01100100b
-10011001b << 3 = 11001000b
-10011001b << 4 = 10010000b
-10011001b << 5 = 00100000b
-10011001b << 6 = 01000000b
-10011001b << 7 = 10000000b
-10011001b << 8 = 00000000b
-10011010b << 0 = 10011010b
-10011010b << 1 = 00110100b
-10011010b << 2 = 01101000b
-10011010b << 3 = 11010000b
-10011010b << 4 = 10100000b
-10011010b << 5 = 01000000b
-10011010b << 6 = 10000000b
-10011010b << 7 = 00000000b
-10011010b << 8 = 00000000b
-10011011b << 0 = 10011011b
-10011011b << 1 = 00110110b
-10011011b << 2 = 01101100b
-10011011b << 3 = 11011000b
-10011011b << 4 = 10110000b
-10011011b << 5 = 01100000b
-10011011b << 6 = 11000000b
-10011011b << 7 = 10000000b
-10011011b << 8 = 00000000b
-10011100b << 0 = 10011100b
-10011100b << 1 = 00111000b
-10011100b << 2 = 01110000b
-10011100b << 3 = 11100000b
-10011100b << 4 = 11000000b
-10011100b << 5 = 10000000b
-10011100b << 6 = 00000000b
-10011100b << 7 = 00000000b
-10011100b << 8 = 00000000b
-10011101b << 0 = 10011101b
-10011101b << 1 = 00111010b
-10011101b << 2 = 01110100b
-10011101b << 3 = 11101000b
-10011101b << 4 = 11010000b
-10011101b << 5 = 10100000b
-10011101b << 6 = 01000000b
-10011101b << 7 = 10000000b
-10011101b << 8 = 00000000b
-10011110b << 0 = 10011110b
-10011110b << 1 = 00111100b
-10011110b << 2 = 01111000b
-10011110b << 3 = 11110000b
-10011110b << 4 = 11100000b
-10011110b << 5 = 11000000b
-10011110b << 6 = 10000000b
-10011110b << 7 = 00000000b
-10011110b << 8 = 00000000b
-10011111b << 0 = 10011111b
-10011111b << 1 = 00111110b
-10011111b << 2 = 01111100b
-10011111b << 3 = 11111000b
-10011111b << 4 = 11110000b
-10011111b << 5 = 11100000b
-10011111b << 6 = 11000000b
-10011111b << 7 = 10000000b
-10011111b << 8 = 00000000b
-10100000b << 0 = 10100000b
-10100000b << 1 = 01000000b
-10100000b << 2 = 10000000b
-10100000b << 3 = 00000000b
-10100000b << 4 = 00000000b
-10100000b << 5 = 00000000b
-10100000b << 6 = 00000000b
-10100000b << 7 = 00000000b
-10100000b << 8 = 00000000b
-10100001b << 0 = 10100001b
-10100001b << 1 = 01000010b
-10100001b << 2 = 10000100b
-10100001b << 3 = 00001000b
-10100001b << 4 = 00010000b
-10100001b << 5 = 00100000b
-10100001b << 6 = 01000000b
-10100001b << 7 = 10000000b
-10100001b << 8 = 00000000b
-10100010b << 0 = 10100010b
-10100010b << 1 = 01000100b
-10100010b << 2 = 10001000b
-10100010b << 3 = 00010000b
-10100010b << 4 = 00100000b
-10100010b << 5 = 01000000b
-10100010b << 6 = 10000000b
-10100010b << 7 = 00000000b
-10100010b << 8 = 00000000b
-10100011b << 0 = 10100011b
-10100011b << 1 = 01000110b
-10100011b << 2 = 10001100b
-10100011b << 3 = 00011000b
-10100011b << 4 = 00110000b
-10100011b << 5 = 01100000b
-10100011b << 6 = 11000000b
-10100011b << 7 = 10000000b
-10100011b << 8 = 00000000b
-10100100b << 0 = 10100100b
-10100100b << 1 = 01001000b
-10100100b << 2 = 10010000b
-10100100b << 3 = 00100000b
-10100100b << 4 = 01000000b
-10100100b << 5 = 10000000b
-10100100b << 6 = 00000000b
-10100100b << 7 = 00000000b
-10100100b << 8 = 00000000b
-10100101b << 0 = 10100101b
-10100101b << 1 = 01001010b
-10100101b << 2 = 10010100b
-10100101b << 3 = 00101000b
-10100101b << 4 = 01010000b
-10100101b << 5 = 10100000b
-10100101b << 6 = 01000000b
-10100101b << 7 = 10000000b
-10100101b << 8 = 00000000b
-10100110b << 0 = 10100110b
-10100110b << 1 = 01001100b
-10100110b << 2 = 10011000b
-10100110b << 3 = 00110000b
-10100110b << 4 = 01100000b
-10100110b << 5 = 11000000b
-10100110b << 6 = 10000000b
-10100110b << 7 = 00000000b
-10100110b << 8 = 00000000b
-10100111b << 0 = 10100111b
-10100111b << 1 = 01001110b
-10100111b << 2 = 10011100b
-10100111b << 3 = 00111000b
-10100111b << 4 = 01110000b
-10100111b << 5 = 11100000b
-10100111b << 6 = 11000000b
-10100111b << 7 = 10000000b
-10100111b << 8 = 00000000b
-10101000b << 0 = 10101000b
-10101000b << 1 = 01010000b
-10101000b << 2 = 10100000b
-10101000b << 3 = 01000000b
-10101000b << 4 = 10000000b
-10101000b << 5 = 00000000b
-10101000b << 6 = 00000000b
-10101000b << 7 = 00000000b
-10101000b << 8 = 00000000b
-10101001b << 0 = 10101001b
-10101001b << 1 = 01010010b
-10101001b << 2 = 10100100b
-10101001b << 3 = 01001000b
-10101001b << 4 = 10010000b
-10101001b << 5 = 00100000b
-10101001b << 6 = 01000000b
-10101001b << 7 = 10000000b
-10101001b << 8 = 00000000b
-10101010b << 0 = 10101010b
-10101010b << 1 = 01010100b
-10101010b << 2 = 10101000b
-10101010b << 3 = 01010000b
-10101010b << 4 = 10100000b
-10101010b << 5 = 01000000b
-10101010b << 6 = 10000000b
-10101010b << 7 = 00000000b
-10101010b << 8 = 00000000b
-10101011b << 0 = 10101011b
-10101011b << 1 = 01010110b
-10101011b << 2 = 10101100b
-10101011b << 3 = 01011000b
-10101011b << 4 = 10110000b
-10101011b << 5 = 01100000b
-10101011b << 6 = 11000000b
-10101011b << 7 = 10000000b
-10101011b << 8 = 00000000b
-10101100b << 0 = 10101100b
-10101100b << 1 = 01011000b
-10101100b << 2 = 10110000b
-10101100b << 3 = 01100000b
-10101100b << 4 = 11000000b
-10101100b << 5 = 10000000b
-10101100b << 6 = 00000000b
-10101100b << 7 = 00000000b
-10101100b << 8 = 00000000b
-10101101b << 0 = 10101101b
-10101101b << 1 = 01011010b
-10101101b << 2 = 10110100b
-10101101b << 3 = 01101000b
-10101101b << 4 = 11010000b
-10101101b << 5 = 10100000b
-10101101b << 6 = 01000000b
-10101101b << 7 = 10000000b
-10101101b << 8 = 00000000b
-10101110b << 0 = 10101110b
-10101110b << 1 = 01011100b
-10101110b << 2 = 10111000b
-10101110b << 3 = 01110000b
-10101110b << 4 = 11100000b
-10101110b << 5 = 11000000b
-10101110b << 6 = 10000000b
-10101110b << 7 = 00000000b
-10101110b << 8 = 00000000b
-10101111b << 0 = 10101111b
-10101111b << 1 = 01011110b
-10101111b << 2 = 10111100b
-10101111b << 3 = 01111000b
-10101111b << 4 = 11110000b
-10101111b << 5 = 11100000b
-10101111b << 6 = 11000000b
-10101111b << 7 = 10000000b
-10101111b << 8 = 00000000b
-10110000b << 0 = 10110000b
-10110000b << 1 = 01100000b
-10110000b << 2 = 11000000b
-10110000b << 3 = 10000000b
-10110000b << 4 = 00000000b
-10110000b << 5 = 00000000b
-10110000b << 6 = 00000000b
-10110000b << 7 = 00000000b
-10110000b << 8 = 00000000b
-10110001b << 0 = 10110001b
-10110001b << 1 = 01100010b
-10110001b << 2 = 11000100b
-10110001b << 3 = 10001000b
-10110001b << 4 = 00010000b
-10110001b << 5 = 00100000b
-10110001b << 6 = 01000000b
-10110001b << 7 = 10000000b
-10110001b << 8 = 00000000b
-10110010b << 0 = 10110010b
-10110010b << 1 = 01100100b
-10110010b << 2 = 11001000b
-10110010b << 3 = 10010000b
-10110010b << 4 = 00100000b
-10110010b << 5 = 01000000b
-10110010b << 6 = 10000000b
-10110010b << 7 = 00000000b
-10110010b << 8 = 00000000b
-10110011b << 0 = 10110011b
-10110011b << 1 = 01100110b
-10110011b << 2 = 11001100b
-10110011b << 3 = 10011000b
-10110011b << 4 = 00110000b
-10110011b << 5 = 01100000b
-10110011b << 6 = 11000000b
-10110011b << 7 = 10000000b
-10110011b << 8 = 00000000b
-10110100b << 0 = 10110100b
-10110100b << 1 = 01101000b
-10110100b << 2 = 11010000b
-10110100b << 3 = 10100000b
-10110100b << 4 = 01000000b
-10110100b << 5 = 10000000b
-10110100b << 6 = 00000000b
-10110100b << 7 = 00000000b
-10110100b << 8 = 00000000b
-10110101b << 0 = 10110101b
-10110101b << 1 = 01101010b
-10110101b << 2 = 11010100b
-10110101b << 3 = 10101000b
-10110101b << 4 = 01010000b
-10110101b << 5 = 10100000b
-10110101b << 6 = 01000000b
-10110101b << 7 = 10000000b
-10110101b << 8 = 00000000b
-10110110b << 0 = 10110110b
-10110110b << 1 = 01101100b
-10110110b << 2 = 11011000b
-10110110b << 3 = 10110000b
-10110110b << 4 = 01100000b
-10110110b << 5 = 11000000b
-10110110b << 6 = 10000000b
-10110110b << 7 = 00000000b
-10110110b << 8 = 00000000b
-10110111b << 0 = 10110111b
-10110111b << 1 = 01101110b
-10110111b << 2 = 11011100b
-10110111b << 3 = 10111000b
-10110111b << 4 = 01110000b
-10110111b << 5 = 11100000b
-10110111b << 6 = 11000000b
-10110111b << 7 = 10000000b
-10110111b << 8 = 00000000b
-10111000b << 0 = 10111000b
-10111000b << 1 = 01110000b
-10111000b << 2 = 11100000b
-10111000b << 3 = 11000000b
-10111000b << 4 = 10000000b
-10111000b << 5 = 00000000b
-10111000b << 6 = 00000000b
-10111000b << 7 = 00000000b
-10111000b << 8 = 00000000b
-10111001b << 0 = 10111001b
-10111001b << 1 = 01110010b
-10111001b << 2 = 11100100b
-10111001b << 3 = 11001000b
-10111001b << 4 = 10010000b
-10111001b << 5 = 00100000b
-10111001b << 6 = 01000000b
-10111001b << 7 = 10000000b
-10111001b << 8 = 00000000b
-10111010b << 0 = 10111010b
-10111010b << 1 = 01110100b
-10111010b << 2 = 11101000b
-10111010b << 3 = 11010000b
-10111010b << 4 = 10100000b
-10111010b << 5 = 01000000b
-10111010b << 6 = 10000000b
-10111010b << 7 = 00000000b
-10111010b << 8 = 00000000b
-10111011b << 0 = 10111011b
-10111011b << 1 = 01110110b
-10111011b << 2 = 11101100b
-10111011b << 3 = 11011000b
-10111011b << 4 = 10110000b
-10111011b << 5 = 01100000b
-10111011b << 6 = 11000000b
-10111011b << 7 = 10000000b
-10111011b << 8 = 00000000b
-10111100b << 0 = 10111100b
-10111100b << 1 = 01111000b
-10111100b << 2 = 11110000b
-10111100b << 3 = 11100000b
-10111100b << 4 = 11000000b
-10111100b << 5 = 10000000b
-10111100b << 6 = 00000000b
-10111100b << 7 = 00000000b
-10111100b << 8 = 00000000b
-10111101b << 0 = 10111101b
-10111101b << 1 = 01111010b
-10111101b << 2 = 11110100b
-10111101b << 3 = 11101000b
-10111101b << 4 = 11010000b
-10111101b << 5 = 10100000b
-10111101b << 6 = 01000000b
-10111101b << 7 = 10000000b
-10111101b << 8 = 00000000b
-10111110b << 0 = 10111110b
-10111110b << 1 = 01111100b
-10111110b << 2 = 11111000b
-10111110b << 3 = 11110000b
-10111110b << 4 = 11100000b
-10111110b << 5 = 11000000b
-10111110b << 6 = 10000000b
-10111110b << 7 = 00000000b
-10111110b << 8 = 00000000b
-10111111b << 0 = 10111111b
-10111111b << 1 = 01111110b
-10111111b << 2 = 11111100b
-10111111b << 3 = 11111000b
-10111111b << 4 = 11110000b
-10111111b << 5 = 11100000b
-10111111b << 6 = 11000000b
-10111111b << 7 = 10000000b
-10111111b << 8 = 00000000b
-11000000b << 0 = 11000000b
-11000000b << 1 = 10000000b
-11000000b << 2 = 00000000b
-11000000b << 3 = 00000000b
-11000000b << 4 = 00000000b
-11000000b << 5 = 00000000b
-11000000b << 6 = 00000000b
-11000000b << 7 = 00000000b
-11000000b << 8 = 00000000b
-11000001b << 0 = 11000001b
-11000001b << 1 = 10000010b
-11000001b << 2 = 00000100b
-11000001b << 3 = 00001000b
-11000001b << 4 = 00010000b
-11000001b << 5 = 00100000b
-11000001b << 6 = 01000000b
-11000001b << 7 = 10000000b
-11000001b << 8 = 00000000b
-11000010b << 0 = 11000010b
-11000010b << 1 = 10000100b
-11000010b << 2 = 00001000b
-11000010b << 3 = 00010000b
-11000010b << 4 = 00100000b
-11000010b << 5 = 01000000b
-11000010b << 6 = 10000000b
-11000010b << 7 = 00000000b
-11000010b << 8 = 00000000b
-11000011b << 0 = 11000011b
-11000011b << 1 = 10000110b
-11000011b << 2 = 00001100b
-11000011b << 3 = 00011000b
-11000011b << 4 = 00110000b
-11000011b << 5 = 01100000b
-11000011b << 6 = 11000000b
-11000011b << 7 = 10000000b
-11000011b << 8 = 00000000b
-11000100b << 0 = 11000100b
-11000100b << 1 = 10001000b
-11000100b << 2 = 00010000b
-11000100b << 3 = 00100000b
-11000100b << 4 = 01000000b
-11000100b << 5 = 10000000b
-11000100b << 6 = 00000000b
-11000100b << 7 = 00000000b
-11000100b << 8 = 00000000b
-11000101b << 0 = 11000101b
-11000101b << 1 = 10001010b
-11000101b << 2 = 00010100b
-11000101b << 3 = 00101000b
-11000101b << 4 = 01010000b
-11000101b << 5 = 10100000b
-11000101b << 6 = 01000000b
-11000101b << 7 = 10000000b
-11000101b << 8 = 00000000b
-11000110b << 0 = 11000110b
-11000110b << 1 = 10001100b
-11000110b << 2 = 00011000b
-11000110b << 3 = 00110000b
-11000110b << 4 = 01100000b
-11000110b << 5 = 11000000b
-11000110b << 6 = 10000000b
-11000110b << 7 = 00000000b
-11000110b << 8 = 00000000b
-11000111b << 0 = 11000111b
-11000111b << 1 = 10001110b
-11000111b << 2 = 00011100b
-11000111b << 3 = 00111000b
-11000111b << 4 = 01110000b
-11000111b << 5 = 11100000b
-11000111b << 6 = 11000000b
-11000111b << 7 = 10000000b
-11000111b << 8 = 00000000b
-11001000b << 0 = 11001000b
-11001000b << 1 = 10010000b
-11001000b << 2 = 00100000b
-11001000b << 3 = 01000000b
-11001000b << 4 = 10000000b
-11001000b << 5 = 00000000b
-11001000b << 6 = 00000000b
-11001000b << 7 = 00000000b
-11001000b << 8 = 00000000b
-11001001b << 0 = 11001001b
-11001001b << 1 = 10010010b
-11001001b << 2 = 00100100b
-11001001b << 3 = 01001000b
-11001001b << 4 = 10010000b
-11001001b << 5 = 00100000b
-11001001b << 6 = 01000000b
-11001001b << 7 = 10000000b
-11001001b << 8 = 00000000b
-11001010b << 0 = 11001010b
-11001010b << 1 = 10010100b
-11001010b << 2 = 00101000b
-11001010b << 3 = 01010000b
-11001010b << 4 = 10100000b
-11001010b << 5 = 01000000b
-11001010b << 6 = 10000000b
-11001010b << 7 = 00000000b
-11001010b << 8 = 00000000b
-11001011b << 0 = 11001011b
-11001011b << 1 = 10010110b
-11001011b << 2 = 00101100b
-11001011b << 3 = 01011000b
-11001011b << 4 = 10110000b
-11001011b << 5 = 01100000b
-11001011b << 6 = 11000000b
-11001011b << 7 = 10000000b
-11001011b << 8 = 00000000b
-11001100b << 0 = 11001100b
-11001100b << 1 = 10011000b
-11001100b << 2 = 00110000b
-11001100b << 3 = 01100000b
-11001100b << 4 = 11000000b
-11001100b << 5 = 10000000b
-11001100b << 6 = 00000000b
-11001100b << 7 = 00000000b
-11001100b << 8 = 00000000b
-11001101b << 0 = 11001101b
-11001101b << 1 = 10011010b
-11001101b << 2 = 00110100b
-11001101b << 3 = 01101000b
-11001101b << 4 = 11010000b
-11001101b << 5 = 10100000b
-11001101b << 6 = 01000000b
-11001101b << 7 = 10000000b
-11001101b << 8 = 00000000b
-11001110b << 0 = 11001110b
-11001110b << 1 = 10011100b
-11001110b << 2 = 00111000b
-11001110b << 3 = 01110000b
-11001110b << 4 = 11100000b
-11001110b << 5 = 11000000b
-11001110b << 6 = 10000000b
-11001110b << 7 = 00000000b
-11001110b << 8 = 00000000b
-11001111b << 0 = 11001111b
-11001111b << 1 = 10011110b
-11001111b << 2 = 00111100b
-11001111b << 3 = 01111000b
-11001111b << 4 = 11110000b
-11001111b << 5 = 11100000b
-11001111b << 6 = 11000000b
-11001111b << 7 = 10000000b
-11001111b << 8 = 00000000b
-11010000b << 0 = 11010000b
-11010000b << 1 = 10100000b
-11010000b << 2 = 01000000b
-11010000b << 3 = 10000000b
-11010000b << 4 = 00000000b
-11010000b << 5 = 00000000b
-11010000b << 6 = 00000000b
-11010000b << 7 = 00000000b
-11010000b << 8 = 00000000b
-11010001b << 0 = 11010001b
-11010001b << 1 = 10100010b
-11010001b << 2 = 01000100b
-11010001b << 3 = 10001000b
-11010001b << 4 = 00010000b
-11010001b << 5 = 00100000b
-11010001b << 6 = 01000000b
-11010001b << 7 = 10000000b
-11010001b << 8 = 00000000b
-11010010b << 0 = 11010010b
-11010010b << 1 = 10100100b
-11010010b << 2 = 01001000b
-11010010b << 3 = 10010000b
-11010010b << 4 = 00100000b
-11010010b << 5 = 01000000b
-11010010b << 6 = 10000000b
-11010010b << 7 = 00000000b
-11010010b << 8 = 00000000b
-11010011b << 0 = 11010011b
-11010011b << 1 = 10100110b
-11010011b << 2 = 01001100b
-11010011b << 3 = 10011000b
-11010011b << 4 = 00110000b
-11010011b << 5 = 01100000b
-11010011b << 6 = 11000000b
-11010011b << 7 = 10000000b
-11010011b << 8 = 00000000b
-11010100b << 0 = 11010100b
-11010100b << 1 = 10101000b
-11010100b << 2 = 01010000b
-11010100b << 3 = 10100000b
-11010100b << 4 = 01000000b
-11010100b << 5 = 10000000b
-11010100b << 6 = 00000000b
-11010100b << 7 = 00000000b
-11010100b << 8 = 00000000b
-11010101b << 0 = 11010101b
-11010101b << 1 = 10101010b
-11010101b << 2 = 01010100b
-11010101b << 3 = 10101000b
-11010101b << 4 = 01010000b
-11010101b << 5 = 10100000b
-11010101b << 6 = 01000000b
-11010101b << 7 = 10000000b
-11010101b << 8 = 00000000b
-11010110b << 0 = 11010110b
-11010110b << 1 = 10101100b
-11010110b << 2 = 01011000b
-11010110b << 3 = 10110000b
-11010110b << 4 = 01100000b
-11010110b << 5 = 11000000b
-11010110b << 6 = 10000000b
-11010110b << 7 = 00000000b
-11010110b << 8 = 00000000b
-11010111b << 0 = 11010111b
-11010111b << 1 = 10101110b
-11010111b << 2 = 01011100b
-11010111b << 3 = 10111000b
-11010111b << 4 = 01110000b
-11010111b << 5 = 11100000b
-11010111b << 6 = 11000000b
-11010111b << 7 = 10000000b
-11010111b << 8 = 00000000b
-11011000b << 0 = 11011000b
-11011000b << 1 = 10110000b
-11011000b << 2 = 01100000b
-11011000b << 3 = 11000000b
-11011000b << 4 = 10000000b
-11011000b << 5 = 00000000b
-11011000b << 6 = 00000000b
-11011000b << 7 = 00000000b
-11011000b << 8 = 00000000b
-11011001b << 0 = 11011001b
-11011001b << 1 = 10110010b
-11011001b << 2 = 01100100b
-11011001b << 3 = 11001000b
-11011001b << 4 = 10010000b
-11011001b << 5 = 00100000b
-11011001b << 6 = 01000000b
-11011001b << 7 = 10000000b
-11011001b << 8 = 00000000b
-11011010b << 0 = 11011010b
-11011010b << 1 = 10110100b
-11011010b << 2 = 01101000b
-11011010b << 3 = 11010000b
-11011010b << 4 = 10100000b
-11011010b << 5 = 01000000b
-11011010b << 6 = 10000000b
-11011010b << 7 = 00000000b
-11011010b << 8 = 00000000b
-11011011b << 0 = 11011011b
-11011011b << 1 = 10110110b
-11011011b << 2 = 01101100b
-11011011b << 3 = 11011000b
-11011011b << 4 = 10110000b
-11011011b << 5 = 01100000b
-11011011b << 6 = 11000000b
-11011011b << 7 = 10000000b
-11011011b << 8 = 00000000b
-11011100b << 0 = 11011100b
-11011100b << 1 = 10111000b
-11011100b << 2 = 01110000b
-11011100b << 3 = 11100000b
-11011100b << 4 = 11000000b
-11011100b << 5 = 10000000b
-11011100b << 6 = 00000000b
-11011100b << 7 = 00000000b
-11011100b << 8 = 00000000b
-11011101b << 0 = 11011101b
-11011101b << 1 = 10111010b
-11011101b << 2 = 01110100b
-11011101b << 3 = 11101000b
-11011101b << 4 = 11010000b
-11011101b << 5 = 10100000b
-11011101b << 6 = 01000000b
-11011101b << 7 = 10000000b
-11011101b << 8 = 00000000b
-11011110b << 0 = 11011110b
-11011110b << 1 = 10111100b
-11011110b << 2 = 01111000b
-11011110b << 3 = 11110000b
-11011110b << 4 = 11100000b
-11011110b << 5 = 11000000b
-11011110b << 6 = 10000000b
-11011110b << 7 = 00000000b
-11011110b << 8 = 00000000b
-11011111b << 0 = 11011111b
-11011111b << 1 = 10111110b
-11011111b << 2 = 01111100b
-11011111b << 3 = 11111000b
-11011111b << 4 = 11110000b
-11011111b << 5 = 11100000b
-11011111b << 6 = 11000000b
-11011111b << 7 = 10000000b
-11011111b << 8 = 00000000b
-11100000b << 0 = 11100000b
-11100000b << 1 = 11000000b
-11100000b << 2 = 10000000b
-11100000b << 3 = 00000000b
-11100000b << 4 = 00000000b
-11100000b << 5 = 00000000b
-11100000b << 6 = 00000000b
-11100000b << 7 = 00000000b
-11100000b << 8 = 00000000b
-11100001b << 0 = 11100001b
-11100001b << 1 = 11000010b
-11100001b << 2 = 10000100b
-11100001b << 3 = 00001000b
-11100001b << 4 = 00010000b
-11100001b << 5 = 00100000b
-11100001b << 6 = 01000000b
-11100001b << 7 = 10000000b
-11100001b << 8 = 00000000b
-11100010b << 0 = 11100010b
-11100010b << 1 = 11000100b
-11100010b << 2 = 10001000b
-11100010b << 3 = 00010000b
-11100010b << 4 = 00100000b
-11100010b << 5 = 01000000b
-11100010b << 6 = 10000000b
-11100010b << 7 = 00000000b
-11100010b << 8 = 00000000b
-11100011b << 0 = 11100011b
-11100011b << 1 = 11000110b
-11100011b << 2 = 10001100b
-11100011b << 3 = 00011000b
-11100011b << 4 = 00110000b
-11100011b << 5 = 01100000b
-11100011b << 6 = 11000000b
-11100011b << 7 = 10000000b
-11100011b << 8 = 00000000b
-11100100b << 0 = 11100100b
-11100100b << 1 = 11001000b
-11100100b << 2 = 10010000b
-11100100b << 3 = 00100000b
-11100100b << 4 = 01000000b
-11100100b << 5 = 10000000b
-11100100b << 6 = 00000000b
-11100100b << 7 = 00000000b
-11100100b << 8 = 00000000b
-11100101b << 0 = 11100101b
-11100101b << 1 = 11001010b
-11100101b << 2 = 10010100b
-11100101b << 3 = 00101000b
-11100101b << 4 = 01010000b
-11100101b << 5 = 10100000b
-11100101b << 6 = 01000000b
-11100101b << 7 = 10000000b
-11100101b << 8 = 00000000b
-11100110b << 0 = 11100110b
-11100110b << 1 = 11001100b
-11100110b << 2 = 10011000b
-11100110b << 3 = 00110000b
-11100110b << 4 = 01100000b
-11100110b << 5 = 11000000b
-11100110b << 6 = 10000000b
-11100110b << 7 = 00000000b
-11100110b << 8 = 00000000b
-11100111b << 0 = 11100111b
-11100111b << 1 = 11001110b
-11100111b << 2 = 10011100b
-11100111b << 3 = 00111000b
-11100111b << 4 = 01110000b
-11100111b << 5 = 11100000b
-11100111b << 6 = 11000000b
-11100111b << 7 = 10000000b
-11100111b << 8 = 00000000b
-11101000b << 0 = 11101000b
-11101000b << 1 = 11010000b
-11101000b << 2 = 10100000b
-11101000b << 3 = 01000000b
-11101000b << 4 = 10000000b
-11101000b << 5 = 00000000b
-11101000b << 6 = 00000000b
-11101000b << 7 = 00000000b
-11101000b << 8 = 00000000b
-11101001b << 0 = 11101001b
-11101001b << 1 = 11010010b
-11101001b << 2 = 10100100b
-11101001b << 3 = 01001000b
-11101001b << 4 = 10010000b
-11101001b << 5 = 00100000b
-11101001b << 6 = 01000000b
-11101001b << 7 = 10000000b
-11101001b << 8 = 00000000b
-11101010b << 0 = 11101010b
-11101010b << 1 = 11010100b
-11101010b << 2 = 10101000b
-11101010b << 3 = 01010000b
-11101010b << 4 = 10100000b
-11101010b << 5 = 01000000b
-11101010b << 6 = 10000000b
-11101010b << 7 = 00000000b
-11101010b << 8 = 00000000b
-11101011b << 0 = 11101011b
-11101011b << 1 = 11010110b
-11101011b << 2 = 10101100b
-11101011b << 3 = 01011000b
-11101011b << 4 = 10110000b
-11101011b << 5 = 01100000b
-11101011b << 6 = 11000000b
-11101011b << 7 = 10000000b
-11101011b << 8 = 00000000b
-11101100b << 0 = 11101100b
-11101100b << 1 = 11011000b
-11101100b << 2 = 10110000b
-11101100b << 3 = 01100000b
-11101100b << 4 = 11000000b
-11101100b << 5 = 10000000b
-11101100b << 6 = 00000000b
-11101100b << 7 = 00000000b
-11101100b << 8 = 00000000b
-11101101b << 0 = 11101101b
-11101101b << 1 = 11011010b
-11101101b << 2 = 10110100b
-11101101b << 3 = 01101000b
-11101101b << 4 = 11010000b
-11101101b << 5 = 10100000b
-11101101b << 6 = 01000000b
-11101101b << 7 = 10000000b
-11101101b << 8 = 00000000b
-11101110b << 0 = 11101110b
-11101110b << 1 = 11011100b
-11101110b << 2 = 10111000b
-11101110b << 3 = 01110000b
-11101110b << 4 = 11100000b
-11101110b << 5 = 11000000b
-11101110b << 6 = 10000000b
-11101110b << 7 = 00000000b
-11101110b << 8 = 00000000b
-11101111b << 0 = 11101111b
-11101111b << 1 = 11011110b
-11101111b << 2 = 10111100b
-11101111b << 3 = 01111000b
-11101111b << 4 = 11110000b
-11101111b << 5 = 11100000b
-11101111b << 6 = 11000000b
-11101111b << 7 = 10000000b
-11101111b << 8 = 00000000b
-11110000b << 0 = 11110000b
-11110000b << 1 = 11100000b
-11110000b << 2 = 11000000b
-11110000b << 3 = 10000000b
-11110000b << 4 = 00000000b
-11110000b << 5 = 00000000b
-11110000b << 6 = 00000000b
-11110000b << 7 = 00000000b
-11110000b << 8 = 00000000b
-11110001b << 0 = 11110001b
-11110001b << 1 = 11100010b
-11110001b << 2 = 11000100b
-11110001b << 3 = 10001000b
-11110001b << 4 = 00010000b
-11110001b << 5 = 00100000b
-11110001b << 6 = 01000000b
-11110001b << 7 = 10000000b
-11110001b << 8 = 00000000b
-11110010b << 0 = 11110010b
-11110010b << 1 = 11100100b
-11110010b << 2 = 11001000b
-11110010b << 3 = 10010000b
-11110010b << 4 = 00100000b
-11110010b << 5 = 01000000b
-11110010b << 6 = 10000000b
-11110010b << 7 = 00000000b
-11110010b << 8 = 00000000b
-11110011b << 0 = 11110011b
-11110011b << 1 = 11100110b
-11110011b << 2 = 11001100b
-11110011b << 3 = 10011000b
-11110011b << 4 = 00110000b
-11110011b << 5 = 01100000b
-11110011b << 6 = 11000000b
-11110011b << 7 = 10000000b
-11110011b << 8 = 00000000b
-11110100b << 0 = 11110100b
-11110100b << 1 = 11101000b
-11110100b << 2 = 11010000b
-11110100b << 3 = 10100000b
-11110100b << 4 = 01000000b
-11110100b << 5 = 10000000b
-11110100b << 6 = 00000000b
-11110100b << 7 = 00000000b
-11110100b << 8 = 00000000b
-11110101b << 0 = 11110101b
-11110101b << 1 = 11101010b
-11110101b << 2 = 11010100b
-11110101b << 3 = 10101000b
-11110101b << 4 = 01010000b
-11110101b << 5 = 10100000b
-11110101b << 6 = 01000000b
-11110101b << 7 = 10000000b
-11110101b << 8 = 00000000b
-11110110b << 0 = 11110110b
-11110110b << 1 = 11101100b
-11110110b << 2 = 11011000b
-11110110b << 3 = 10110000b
-11110110b << 4 = 01100000b
-11110110b << 5 = 11000000b
-11110110b << 6 = 10000000b
-11110110b << 7 = 00000000b
-11110110b << 8 = 00000000b
-11110111b << 0 = 11110111b
-11110111b << 1 = 11101110b
-11110111b << 2 = 11011100b
-11110111b << 3 = 10111000b
-11110111b << 4 = 01110000b
-11110111b << 5 = 11100000b
-11110111b << 6 = 11000000b
-11110111b << 7 = 10000000b
-11110111b << 8 = 00000000b
-11111000b << 0 = 11111000b
-11111000b << 1 = 11110000b
-11111000b << 2 = 11100000b
-11111000b << 3 = 11000000b
-11111000b << 4 = 10000000b
-11111000b << 5 = 00000000b
-11111000b << 6 = 00000000b
-11111000b << 7 = 00000000b
-11111000b << 8 = 00000000b
-11111001b << 0 = 11111001b
-11111001b << 1 = 11110010b
-11111001b << 2 = 11100100b
-11111001b << 3 = 11001000b
-11111001b << 4 = 10010000b
-11111001b << 5 = 00100000b
-11111001b << 6 = 01000000b
-11111001b << 7 = 10000000b
-11111001b << 8 = 00000000b
-11111010b << 0 = 11111010b
-11111010b << 1 = 11110100b
-11111010b << 2 = 11101000b
-11111010b << 3 = 11010000b
-11111010b << 4 = 10100000b
-11111010b << 5 = 01000000b
-11111010b << 6 = 10000000b
-11111010b << 7 = 00000000b
-11111010b << 8 = 00000000b
-11111011b << 0 = 11111011b
-11111011b << 1 = 11110110b
-11111011b << 2 = 11101100b
-11111011b << 3 = 11011000b
-11111011b << 4 = 10110000b
-11111011b << 5 = 01100000b
-11111011b << 6 = 11000000b
-11111011b << 7 = 10000000b
-11111011b << 8 = 00000000b
-11111100b << 0 = 11111100b
-11111100b << 1 = 11111000b
-11111100b << 2 = 11110000b
-11111100b << 3 = 11100000b
-11111100b << 4 = 11000000b
-11111100b << 5 = 10000000b
-11111100b << 6 = 00000000b
-11111100b << 7 = 00000000b
-11111100b << 8 = 00000000b
-11111101b << 0 = 11111101b
-11111101b << 1 = 11111010b
-11111101b << 2 = 11110100b
-11111101b << 3 = 11101000b
-11111101b << 4 = 11010000b
-11111101b << 5 = 10100000b
-11111101b << 6 = 01000000b
-11111101b << 7 = 10000000b
-11111101b << 8 = 00000000b
-11111110b << 0 = 11111110b
-11111110b << 1 = 11111100b
-11111110b << 2 = 11111000b
-11111110b << 3 = 11110000b
-11111110b << 4 = 11100000b
-11111110b << 5 = 11000000b
-11111110b << 6 = 10000000b
-11111110b << 7 = 00000000b
-11111110b << 8 = 00000000b
-11111111b << 0 = 11111111b
-11111111b << 1 = 11111110b
-11111111b << 2 = 11111100b
-11111111b << 3 = 11111000b
-11111111b << 4 = 11110000b
-11111111b << 5 = 11100000b
-11111111b << 6 = 11000000b
-11111111b << 7 = 10000000b
-11111111b << 8 = 00000000b
-00000000b << 0 = 00000000b
-00000000b << 1 = 00000000b
-00000000b << 2 = 00000000b
-00000000b << 3 = 00000000b
-00000000b << 4 = 00000000b
-00000000b << 5 = 00000000b
-00000000b << 6 = 00000000b
-00000000b << 7 = 00000000b
-00000000b << 8 = 00000000b
-00000001b << 0 = 00000001b
-00000001b << 1 = 00000010b
-00000001b << 2 = 00000100b
-00000001b << 3 = 00001000b
-00000001b << 4 = 00010000b
-00000001b << 5 = 00100000b
-00000001b << 6 = 01000000b
-00000001b << 7 = 10000000b
-00000001b << 8 = 00000000b
-00000010b << 0 = 00000010b
-00000010b << 1 = 00000100b
-00000010b << 2 = 00001000b
-00000010b << 3 = 00010000b
-00000010b << 4 = 00100000b
-00000010b << 5 = 01000000b
-00000010b << 6 = 10000000b
-00000010b << 7 = 00000000b
-00000010b << 8 = 00000000b
-00000011b << 0 = 00000011b
-00000011b << 1 = 00000110b
-00000011b << 2 = 00001100b
-00000011b << 3 = 00011000b
-00000011b << 4 = 00110000b
-00000011b << 5 = 01100000b
-00000011b << 6 = 11000000b
-00000011b << 7 = 10000000b
-00000011b << 8 = 00000000b
-00000100b << 0 = 00000100b
-00000100b << 1 = 00001000b
-00000100b << 2 = 00010000b
-00000100b << 3 = 00100000b
-00000100b << 4 = 01000000b
-00000100b << 5 = 10000000b
-00000100b << 6 = 00000000b
-00000100b << 7 = 00000000b
-00000100b << 8 = 00000000b
-00000101b << 0 = 00000101b
-00000101b << 1 = 00001010b
-00000101b << 2 = 00010100b
-00000101b << 3 = 00101000b
-00000101b << 4 = 01010000b
-00000101b << 5 = 10100000b
-00000101b << 6 = 01000000b
-00000101b << 7 = 10000000b
-00000101b << 8 = 00000000b
-00000110b << 0 = 00000110b
-00000110b << 1 = 00001100b
-00000110b << 2 = 00011000b
-00000110b << 3 = 00110000b
-00000110b << 4 = 01100000b
-00000110b << 5 = 11000000b
-00000110b << 6 = 10000000b
-00000110b << 7 = 00000000b
-00000110b << 8 = 00000000b
-00000111b << 0 = 00000111b
-00000111b << 1 = 00001110b
-00000111b << 2 = 00011100b
-00000111b << 3 = 00111000b
-00000111b << 4 = 01110000b
-00000111b << 5 = 11100000b
-00000111b << 6 = 11000000b
-00000111b << 7 = 10000000b
-00000111b << 8 = 00000000b
-00001000b << 0 = 00001000b
-00001000b << 1 = 00010000b
-00001000b << 2 = 00100000b
-00001000b << 3 = 01000000b
-00001000b << 4 = 10000000b
-00001000b << 5 = 00000000b
-00001000b << 6 = 00000000b
-00001000b << 7 = 00000000b
-00001000b << 8 = 00000000b
-00001001b << 0 = 00001001b
-00001001b << 1 = 00010010b
-00001001b << 2 = 00100100b
-00001001b << 3 = 01001000b
-00001001b << 4 = 10010000b
-00001001b << 5 = 00100000b
-00001001b << 6 = 01000000b
-00001001b << 7 = 10000000b
-00001001b << 8 = 00000000b
-00001010b << 0 = 00001010b
-00001010b << 1 = 00010100b
-00001010b << 2 = 00101000b
-00001010b << 3 = 01010000b
-00001010b << 4 = 10100000b
-00001010b << 5 = 01000000b
-00001010b << 6 = 10000000b
-00001010b << 7 = 00000000b
-00001010b << 8 = 00000000b
-00001011b << 0 = 00001011b
-00001011b << 1 = 00010110b
-00001011b << 2 = 00101100b
-00001011b << 3 = 01011000b
-00001011b << 4 = 10110000b
-00001011b << 5 = 01100000b
-00001011b << 6 = 11000000b
-00001011b << 7 = 10000000b
-00001011b << 8 = 00000000b
-00001100b << 0 = 00001100b
-00001100b << 1 = 00011000b
-00001100b << 2 = 00110000b
-00001100b << 3 = 01100000b
-00001100b << 4 = 11000000b
-00001100b << 5 = 10000000b
-00001100b << 6 = 00000000b
-00001100b << 7 = 00000000b
-00001100b << 8 = 00000000b
-00001101b << 0 = 00001101b
-00001101b << 1 = 00011010b
-00001101b << 2 = 00110100b
-00001101b << 3 = 01101000b
-00001101b << 4 = 11010000b
-00001101b << 5 = 10100000b
-00001101b << 6 = 01000000b
-00001101b << 7 = 10000000b
-00001101b << 8 = 00000000b
-00001110b << 0 = 00001110b
-00001110b << 1 = 00011100b
-00001110b << 2 = 00111000b
-00001110b << 3 = 01110000b
-00001110b << 4 = 11100000b
-00001110b << 5 = 11000000b
-00001110b << 6 = 10000000b
-00001110b << 7 = 00000000b
-00001110b << 8 = 00000000b
-00001111b << 0 = 00001111b
-00001111b << 1 = 00011110b
-00001111b << 2 = 00111100b
-00001111b << 3 = 01111000b
-00001111b << 4 = 11110000b
-00001111b << 5 = 11100000b
-00001111b << 6 = 11000000b
-00001111b << 7 = 10000000b
-00001111b << 8 = 00000000b
-00010000b << 0 = 00010000b
-00010000b << 1 = 00100000b
-00010000b << 2 = 01000000b
-00010000b << 3 = 10000000b
-00010000b << 4 = 00000000b
-00010000b << 5 = 00000000b
-00010000b << 6 = 00000000b
-00010000b << 7 = 00000000b
-00010000b << 8 = 00000000b
-00010001b << 0 = 00010001b
-00010001b << 1 = 00100010b
-00010001b << 2 = 01000100b
-00010001b << 3 = 10001000b
-00010001b << 4 = 00010000b
-00010001b << 5 = 00100000b
-00010001b << 6 = 01000000b
-00010001b << 7 = 10000000b
-00010001b << 8 = 00000000b
-00010010b << 0 = 00010010b
-00010010b << 1 = 00100100b
-00010010b << 2 = 01001000b
-00010010b << 3 = 10010000b
-00010010b << 4 = 00100000b
-00010010b << 5 = 01000000b
-00010010b << 6 = 10000000b
-00010010b << 7 = 00000000b
-00010010b << 8 = 00000000b
-00010011b << 0 = 00010011b
-00010011b << 1 = 00100110b
-00010011b << 2 = 01001100b
-00010011b << 3 = 10011000b
-00010011b << 4 = 00110000b
-00010011b << 5 = 01100000b
-00010011b << 6 = 11000000b
-00010011b << 7 = 10000000b
-00010011b << 8 = 00000000b
-00010100b << 0 = 00010100b
-00010100b << 1 = 00101000b
-00010100b << 2 = 01010000b
-00010100b << 3 = 10100000b
-00010100b << 4 = 01000000b
-00010100b << 5 = 10000000b
-00010100b << 6 = 00000000b
-00010100b << 7 = 00000000b
-00010100b << 8 = 00000000b
-00010101b << 0 = 00010101b
-00010101b << 1 = 00101010b
-00010101b << 2 = 01010100b
-00010101b << 3 = 10101000b
-00010101b << 4 = 01010000b
-00010101b << 5 = 10100000b
-00010101b << 6 = 01000000b
-00010101b << 7 = 10000000b
-00010101b << 8 = 00000000b
-00010110b << 0 = 00010110b
-00010110b << 1 = 00101100b
-00010110b << 2 = 01011000b
-00010110b << 3 = 10110000b
-00010110b << 4 = 01100000b
-00010110b << 5 = 11000000b
-00010110b << 6 = 10000000b
-00010110b << 7 = 00000000b
-00010110b << 8 = 00000000b
-00010111b << 0 = 00010111b
-00010111b << 1 = 00101110b
-00010111b << 2 = 01011100b
-00010111b << 3 = 10111000b
-00010111b << 4 = 01110000b
-00010111b << 5 = 11100000b
-00010111b << 6 = 11000000b
-00010111b << 7 = 10000000b
-00010111b << 8 = 00000000b
-00011000b << 0 = 00011000b
-00011000b << 1 = 00110000b
-00011000b << 2 = 01100000b
-00011000b << 3 = 11000000b
-00011000b << 4 = 10000000b
-00011000b << 5 = 00000000b
-00011000b << 6 = 00000000b
-00011000b << 7 = 00000000b
-00011000b << 8 = 00000000b
-00011001b << 0 = 00011001b
-00011001b << 1 = 00110010b
-00011001b << 2 = 01100100b
-00011001b << 3 = 11001000b
-00011001b << 4 = 10010000b
-00011001b << 5 = 00100000b
-00011001b << 6 = 01000000b
-00011001b << 7 = 10000000b
-00011001b << 8 = 00000000b
-00011010b << 0 = 00011010b
-00011010b << 1 = 00110100b
-00011010b << 2 = 01101000b
-00011010b << 3 = 11010000b
-00011010b << 4 = 10100000b
-00011010b << 5 = 01000000b
-00011010b << 6 = 10000000b
-00011010b << 7 = 00000000b
-00011010b << 8 = 00000000b
-00011011b << 0 = 00011011b
-00011011b << 1 = 00110110b
-00011011b << 2 = 01101100b
-00011011b << 3 = 11011000b
-00011011b << 4 = 10110000b
-00011011b << 5 = 01100000b
-00011011b << 6 = 11000000b
-00011011b << 7 = 10000000b
-00011011b << 8 = 00000000b
-00011100b << 0 = 00011100b
-00011100b << 1 = 00111000b
-00011100b << 2 = 01110000b
-00011100b << 3 = 11100000b
-00011100b << 4 = 11000000b
-00011100b << 5 = 10000000b
-00011100b << 6 = 00000000b
-00011100b << 7 = 00000000b
-00011100b << 8 = 00000000b
-00011101b << 0 = 00011101b
-00011101b << 1 = 00111010b
-00011101b << 2 = 01110100b
-00011101b << 3 = 11101000b
-00011101b << 4 = 11010000b
-00011101b << 5 = 10100000b
-00011101b << 6 = 01000000b
-00011101b << 7 = 10000000b
-00011101b << 8 = 00000000b
-00011110b << 0 = 00011110b
-00011110b << 1 = 00111100b
-00011110b << 2 = 01111000b
-00011110b << 3 = 11110000b
-00011110b << 4 = 11100000b
-00011110b << 5 = 11000000b
-00011110b << 6 = 10000000b
-00011110b << 7 = 00000000b
-00011110b << 8 = 00000000b
-00011111b << 0 = 00011111b
-00011111b << 1 = 00111110b
-00011111b << 2 = 01111100b
-00011111b << 3 = 11111000b
-00011111b << 4 = 11110000b
-00011111b << 5 = 11100000b
-00011111b << 6 = 11000000b
-00011111b << 7 = 10000000b
-00011111b << 8 = 00000000b
-00100000b << 0 = 00100000b
-00100000b << 1 = 01000000b
-00100000b << 2 = 10000000b
-00100000b << 3 = 00000000b
-00100000b << 4 = 00000000b
-00100000b << 5 = 00000000b
-00100000b << 6 = 00000000b
-00100000b << 7 = 00000000b
-00100000b << 8 = 00000000b
-00100001b << 0 = 00100001b
-00100001b << 1 = 01000010b
-00100001b << 2 = 10000100b
-00100001b << 3 = 00001000b
-00100001b << 4 = 00010000b
-00100001b << 5 = 00100000b
-00100001b << 6 = 01000000b
-00100001b << 7 = 10000000b
-00100001b << 8 = 00000000b
-00100010b << 0 = 00100010b
-00100010b << 1 = 01000100b
-00100010b << 2 = 10001000b
-00100010b << 3 = 00010000b
-00100010b << 4 = 00100000b
-00100010b << 5 = 01000000b
-00100010b << 6 = 10000000b
-00100010b << 7 = 00000000b
-00100010b << 8 = 00000000b
-00100011b << 0 = 00100011b
-00100011b << 1 = 01000110b
-00100011b << 2 = 10001100b
-00100011b << 3 = 00011000b
-00100011b << 4 = 00110000b
-00100011b << 5 = 01100000b
-00100011b << 6 = 11000000b
-00100011b << 7 = 10000000b
-00100011b << 8 = 00000000b
-00100100b << 0 = 00100100b
-00100100b << 1 = 01001000b
-00100100b << 2 = 10010000b
-00100100b << 3 = 00100000b
-00100100b << 4 = 01000000b
-00100100b << 5 = 10000000b
-00100100b << 6 = 00000000b
-00100100b << 7 = 00000000b
-00100100b << 8 = 00000000b
-00100101b << 0 = 00100101b
-00100101b << 1 = 01001010b
-00100101b << 2 = 10010100b
-00100101b << 3 = 00101000b
-00100101b << 4 = 01010000b
-00100101b << 5 = 10100000b
-00100101b << 6 = 01000000b
-00100101b << 7 = 10000000b
-00100101b << 8 = 00000000b
-00100110b << 0 = 00100110b
-00100110b << 1 = 01001100b
-00100110b << 2 = 10011000b
-00100110b << 3 = 00110000b
-00100110b << 4 = 01100000b
-00100110b << 5 = 11000000b
-00100110b << 6 = 10000000b
-00100110b << 7 = 00000000b
-00100110b << 8 = 00000000b
-00100111b << 0 = 00100111b
-00100111b << 1 = 01001110b
-00100111b << 2 = 10011100b
-00100111b << 3 = 00111000b
-00100111b << 4 = 01110000b
-00100111b << 5 = 11100000b
-00100111b << 6 = 11000000b
-00100111b << 7 = 10000000b
-00100111b << 8 = 00000000b
-00101000b << 0 = 00101000b
-00101000b << 1 = 01010000b
-00101000b << 2 = 10100000b
-00101000b << 3 = 01000000b
-00101000b << 4 = 10000000b
-00101000b << 5 = 00000000b
-00101000b << 6 = 00000000b
-00101000b << 7 = 00000000b
-00101000b << 8 = 00000000b
-00101001b << 0 = 00101001b
-00101001b << 1 = 01010010b
-00101001b << 2 = 10100100b
-00101001b << 3 = 01001000b
-00101001b << 4 = 10010000b
-00101001b << 5 = 00100000b
-00101001b << 6 = 01000000b
-00101001b << 7 = 10000000b
-00101001b << 8 = 00000000b
-00101010b << 0 = 00101010b
-00101010b << 1 = 01010100b
-00101010b << 2 = 10101000b
-00101010b << 3 = 01010000b
-00101010b << 4 = 10100000b
-00101010b << 5 = 01000000b
-00101010b << 6 = 10000000b
-00101010b << 7 = 00000000b
-00101010b << 8 = 00000000b
-00101011b << 0 = 00101011b
-00101011b << 1 = 01010110b
-00101011b << 2 = 10101100b
-00101011b << 3 = 01011000b
-00101011b << 4 = 10110000b
-00101011b << 5 = 01100000b
-00101011b << 6 = 11000000b
-00101011b << 7 = 10000000b
-00101011b << 8 = 00000000b
-00101100b << 0 = 00101100b
-00101100b << 1 = 01011000b
-00101100b << 2 = 10110000b
-00101100b << 3 = 01100000b
-00101100b << 4 = 11000000b
-00101100b << 5 = 10000000b
-00101100b << 6 = 00000000b
-00101100b << 7 = 00000000b
-00101100b << 8 = 00000000b
-00101101b << 0 = 00101101b
-00101101b << 1 = 01011010b
-00101101b << 2 = 10110100b
-00101101b << 3 = 01101000b
-00101101b << 4 = 11010000b
-00101101b << 5 = 10100000b
-00101101b << 6 = 01000000b
-00101101b << 7 = 10000000b
-00101101b << 8 = 00000000b
-00101110b << 0 = 00101110b
-00101110b << 1 = 01011100b
-00101110b << 2 = 10111000b
-00101110b << 3 = 01110000b
-00101110b << 4 = 11100000b
-00101110b << 5 = 11000000b
-00101110b << 6 = 10000000b
-00101110b << 7 = 00000000b
-00101110b << 8 = 00000000b
-00101111b << 0 = 00101111b
-00101111b << 1 = 01011110b
-00101111b << 2 = 10111100b
-00101111b << 3 = 01111000b
-00101111b << 4 = 11110000b
-00101111b << 5 = 11100000b
-00101111b << 6 = 11000000b
-00101111b << 7 = 10000000b
-00101111b << 8 = 00000000b
-00110000b << 0 = 00110000b
-00110000b << 1 = 01100000b
-00110000b << 2 = 11000000b
-00110000b << 3 = 10000000b
-00110000b << 4 = 00000000b
-00110000b << 5 = 00000000b
-00110000b << 6 = 00000000b
-00110000b << 7 = 00000000b
-00110000b << 8 = 00000000b
-00110001b << 0 = 00110001b
-00110001b << 1 = 01100010b
-00110001b << 2 = 11000100b
-00110001b << 3 = 10001000b
-00110001b << 4 = 00010000b
-00110001b << 5 = 00100000b
-00110001b << 6 = 01000000b
-00110001b << 7 = 10000000b
-00110001b << 8 = 00000000b
-00110010b << 0 = 00110010b
-00110010b << 1 = 01100100b
-00110010b << 2 = 11001000b
-00110010b << 3 = 10010000b
-00110010b << 4 = 00100000b
-00110010b << 5 = 01000000b
-00110010b << 6 = 10000000b
-00110010b << 7 = 00000000b
-00110010b << 8 = 00000000b
-00110011b << 0 = 00110011b
-00110011b << 1 = 01100110b
-00110011b << 2 = 11001100b
-00110011b << 3 = 10011000b
-00110011b << 4 = 00110000b
-00110011b << 5 = 01100000b
-00110011b << 6 = 11000000b
-00110011b << 7 = 10000000b
-00110011b << 8 = 00000000b
-00110100b << 0 = 00110100b
-00110100b << 1 = 01101000b
-00110100b << 2 = 11010000b
-00110100b << 3 = 10100000b
-00110100b << 4 = 01000000b
-00110100b << 5 = 10000000b
-00110100b << 6 = 00000000b
-00110100b << 7 = 00000000b
-00110100b << 8 = 00000000b
-00110101b << 0 = 00110101b
-00110101b << 1 = 01101010b
-00110101b << 2 = 11010100b
-00110101b << 3 = 10101000b
-00110101b << 4 = 01010000b
-00110101b << 5 = 10100000b
-00110101b << 6 = 01000000b
-00110101b << 7 = 10000000b
-00110101b << 8 = 00000000b
-00110110b << 0 = 00110110b
-00110110b << 1 = 01101100b
-00110110b << 2 = 11011000b
-00110110b << 3 = 10110000b
-00110110b << 4 = 01100000b
-00110110b << 5 = 11000000b
-00110110b << 6 = 10000000b
-00110110b << 7 = 00000000b
-00110110b << 8 = 00000000b
-00110111b << 0 = 00110111b
-00110111b << 1 = 01101110b
-00110111b << 2 = 11011100b
-00110111b << 3 = 10111000b
-00110111b << 4 = 01110000b
-00110111b << 5 = 11100000b
-00110111b << 6 = 11000000b
-00110111b << 7 = 10000000b
-00110111b << 8 = 00000000b
-00111000b << 0 = 00111000b
-00111000b << 1 = 01110000b
-00111000b << 2 = 11100000b
-00111000b << 3 = 11000000b
-00111000b << 4 = 10000000b
-00111000b << 5 = 00000000b
-00111000b << 6 = 00000000b
-00111000b << 7 = 00000000b
-00111000b << 8 = 00000000b
-00111001b << 0 = 00111001b
-00111001b << 1 = 01110010b
-00111001b << 2 = 11100100b
-00111001b << 3 = 11001000b
-00111001b << 4 = 10010000b
-00111001b << 5 = 00100000b
-00111001b << 6 = 01000000b
-00111001b << 7 = 10000000b
-00111001b << 8 = 00000000b
-00111010b << 0 = 00111010b
-00111010b << 1 = 01110100b
-00111010b << 2 = 11101000b
-00111010b << 3 = 11010000b
-00111010b << 4 = 10100000b
-00111010b << 5 = 01000000b
-00111010b << 6 = 10000000b
-00111010b << 7 = 00000000b
-00111010b << 8 = 00000000b
-00111011b << 0 = 00111011b
-00111011b << 1 = 01110110b
-00111011b << 2 = 11101100b
-00111011b << 3 = 11011000b
-00111011b << 4 = 10110000b
-00111011b << 5 = 01100000b
-00111011b << 6 = 11000000b
-00111011b << 7 = 10000000b
-00111011b << 8 = 00000000b
-00111100b << 0 = 00111100b
-00111100b << 1 = 01111000b
-00111100b << 2 = 11110000b
-00111100b << 3 = 11100000b
-00111100b << 4 = 11000000b
-00111100b << 5 = 10000000b
-00111100b << 6 = 00000000b
-00111100b << 7 = 00000000b
-00111100b << 8 = 00000000b
-00111101b << 0 = 00111101b
-00111101b << 1 = 01111010b
-00111101b << 2 = 11110100b
-00111101b << 3 = 11101000b
-00111101b << 4 = 11010000b
-00111101b << 5 = 10100000b
-00111101b << 6 = 01000000b
-00111101b << 7 = 10000000b
-00111101b << 8 = 00000000b
-00111110b << 0 = 00111110b
-00111110b << 1 = 01111100b
-00111110b << 2 = 11111000b
-00111110b << 3 = 11110000b
-00111110b << 4 = 11100000b
-00111110b << 5 = 11000000b
-00111110b << 6 = 10000000b
-00111110b << 7 = 00000000b
-00111110b << 8 = 00000000b
-00111111b << 0 = 00111111b
-00111111b << 1 = 01111110b
-00111111b << 2 = 11111100b
-00111111b << 3 = 11111000b
-00111111b << 4 = 11110000b
-00111111b << 5 = 11100000b
-00111111b << 6 = 11000000b
-00111111b << 7 = 10000000b
-00111111b << 8 = 00000000b
-01000000b << 0 = 01000000b
-01000000b << 1 = 10000000b
-01000000b << 2 = 00000000b
-01000000b << 3 = 00000000b
-01000000b << 4 = 00000000b
-01000000b << 5 = 00000000b
-01000000b << 6 = 00000000b
-01000000b << 7 = 00000000b
-01000000b << 8 = 00000000b
-01000001b << 0 = 01000001b
-01000001b << 1 = 10000010b
-01000001b << 2 = 00000100b
-01000001b << 3 = 00001000b
-01000001b << 4 = 00010000b
-01000001b << 5 = 00100000b
-01000001b << 6 = 01000000b
-01000001b << 7 = 10000000b
-01000001b << 8 = 00000000b
-01000010b << 0 = 01000010b
-01000010b << 1 = 10000100b
-01000010b << 2 = 00001000b
-01000010b << 3 = 00010000b
-01000010b << 4 = 00100000b
-01000010b << 5 = 01000000b
-01000010b << 6 = 10000000b
-01000010b << 7 = 00000000b
-01000010b << 8 = 00000000b
-01000011b << 0 = 01000011b
-01000011b << 1 = 10000110b
-01000011b << 2 = 00001100b
-01000011b << 3 = 00011000b
-01000011b << 4 = 00110000b
-01000011b << 5 = 01100000b
-01000011b << 6 = 11000000b
-01000011b << 7 = 10000000b
-01000011b << 8 = 00000000b
-01000100b << 0 = 01000100b
-01000100b << 1 = 10001000b
-01000100b << 2 = 00010000b
-01000100b << 3 = 00100000b
-01000100b << 4 = 01000000b
-01000100b << 5 = 10000000b
-01000100b << 6 = 00000000b
-01000100b << 7 = 00000000b
-01000100b << 8 = 00000000b
-01000101b << 0 = 01000101b
-01000101b << 1 = 10001010b
-01000101b << 2 = 00010100b
-01000101b << 3 = 00101000b
-01000101b << 4 = 01010000b
-01000101b << 5 = 10100000b
-01000101b << 6 = 01000000b
-01000101b << 7 = 10000000b
-01000101b << 8 = 00000000b
-01000110b << 0 = 01000110b
-01000110b << 1 = 10001100b
-01000110b << 2 = 00011000b
-01000110b << 3 = 00110000b
-01000110b << 4 = 01100000b
-01000110b << 5 = 11000000b
-01000110b << 6 = 10000000b
-01000110b << 7 = 00000000b
-01000110b << 8 = 00000000b
-01000111b << 0 = 01000111b
-01000111b << 1 = 10001110b
-01000111b << 2 = 00011100b
-01000111b << 3 = 00111000b
-01000111b << 4 = 01110000b
-01000111b << 5 = 11100000b
-01000111b << 6 = 11000000b
-01000111b << 7 = 10000000b
-01000111b << 8 = 00000000b
-01001000b << 0 = 01001000b
-01001000b << 1 = 10010000b
-01001000b << 2 = 00100000b
-01001000b << 3 = 01000000b
-01001000b << 4 = 10000000b
-01001000b << 5 = 00000000b
-01001000b << 6 = 00000000b
-01001000b << 7 = 00000000b
-01001000b << 8 = 00000000b
-01001001b << 0 = 01001001b
-01001001b << 1 = 10010010b
-01001001b << 2 = 00100100b
-01001001b << 3 = 01001000b
-01001001b << 4 = 10010000b
-01001001b << 5 = 00100000b
-01001001b << 6 = 01000000b
-01001001b << 7 = 10000000b
-01001001b << 8 = 00000000b
-01001010b << 0 = 01001010b
-01001010b << 1 = 10010100b
-01001010b << 2 = 00101000b
-01001010b << 3 = 01010000b
-01001010b << 4 = 10100000b
-01001010b << 5 = 01000000b
-01001010b << 6 = 10000000b
-01001010b << 7 = 00000000b
-01001010b << 8 = 00000000b
-01001011b << 0 = 01001011b
-01001011b << 1 = 10010110b
-01001011b << 2 = 00101100b
-01001011b << 3 = 01011000b
-01001011b << 4 = 10110000b
-01001011b << 5 = 01100000b
-01001011b << 6 = 11000000b
-01001011b << 7 = 10000000b
-01001011b << 8 = 00000000b
-01001100b << 0 = 01001100b
-01001100b << 1 = 10011000b
-01001100b << 2 = 00110000b
-01001100b << 3 = 01100000b
-01001100b << 4 = 11000000b
-01001100b << 5 = 10000000b
-01001100b << 6 = 00000000b
-01001100b << 7 = 00000000b
-01001100b << 8 = 00000000b
-01001101b << 0 = 01001101b
-01001101b << 1 = 10011010b
-01001101b << 2 = 00110100b
-01001101b << 3 = 01101000b
-01001101b << 4 = 11010000b
-01001101b << 5 = 10100000b
-01001101b << 6 = 01000000b
-01001101b << 7 = 10000000b
-01001101b << 8 = 00000000b
-01001110b << 0 = 01001110b
-01001110b << 1 = 10011100b
-01001110b << 2 = 00111000b
-01001110b << 3 = 01110000b
-01001110b << 4 = 11100000b
-01001110b << 5 = 11000000b
-01001110b << 6 = 10000000b
-01001110b << 7 = 00000000b
-01001110b << 8 = 00000000b
-01001111b << 0 = 01001111b
-01001111b << 1 = 10011110b
-01001111b << 2 = 00111100b
-01001111b << 3 = 01111000b
-01001111b << 4 = 11110000b
-01001111b << 5 = 11100000b
-01001111b << 6 = 11000000b
-01001111b << 7 = 10000000b
-01001111b << 8 = 00000000b
-01010000b << 0 = 01010000b
-01010000b << 1 = 10100000b
-01010000b << 2 = 01000000b
-01010000b << 3 = 10000000b
-01010000b << 4 = 00000000b
-01010000b << 5 = 00000000b
-01010000b << 6 = 00000000b
-01010000b << 7 = 00000000b
-01010000b << 8 = 00000000b
-01010001b << 0 = 01010001b
-01010001b << 1 = 10100010b
-01010001b << 2 = 01000100b
-01010001b << 3 = 10001000b
-01010001b << 4 = 00010000b
-01010001b << 5 = 00100000b
-01010001b << 6 = 01000000b
-01010001b << 7 = 10000000b
-01010001b << 8 = 00000000b
-01010010b << 0 = 01010010b
-01010010b << 1 = 10100100b
-01010010b << 2 = 01001000b
-01010010b << 3 = 10010000b
-01010010b << 4 = 00100000b
-01010010b << 5 = 01000000b
-01010010b << 6 = 10000000b
-01010010b << 7 = 00000000b
-01010010b << 8 = 00000000b
-01010011b << 0 = 01010011b
-01010011b << 1 = 10100110b
-01010011b << 2 = 01001100b
-01010011b << 3 = 10011000b
-01010011b << 4 = 00110000b
-01010011b << 5 = 01100000b
-01010011b << 6 = 11000000b
-01010011b << 7 = 10000000b
-01010011b << 8 = 00000000b
-01010100b << 0 = 01010100b
-01010100b << 1 = 10101000b
-01010100b << 2 = 01010000b
-01010100b << 3 = 10100000b
-01010100b << 4 = 01000000b
-01010100b << 5 = 10000000b
-01010100b << 6 = 00000000b
-01010100b << 7 = 00000000b
-01010100b << 8 = 00000000b
-01010101b << 0 = 01010101b
-01010101b << 1 = 10101010b
-01010101b << 2 = 01010100b
-01010101b << 3 = 10101000b
-01010101b << 4 = 01010000b
-01010101b << 5 = 10100000b
-01010101b << 6 = 01000000b
-01010101b << 7 = 10000000b
-01010101b << 8 = 00000000b
-01010110b << 0 = 01010110b
-01010110b << 1 = 10101100b
-01010110b << 2 = 01011000b
-01010110b << 3 = 10110000b
-01010110b << 4 = 01100000b
-01010110b << 5 = 11000000b
-01010110b << 6 = 10000000b
-01010110b << 7 = 00000000b
-01010110b << 8 = 00000000b
-01010111b << 0 = 01010111b
-01010111b << 1 = 10101110b
-01010111b << 2 = 01011100b
-01010111b << 3 = 10111000b
-01010111b << 4 = 01110000b
-01010111b << 5 = 11100000b
-01010111b << 6 = 11000000b
-01010111b << 7 = 10000000b
-01010111b << 8 = 00000000b
-01011000b << 0 = 01011000b
-01011000b << 1 = 10110000b
-01011000b << 2 = 01100000b
-01011000b << 3 = 11000000b
-01011000b << 4 = 10000000b
-01011000b << 5 = 00000000b
-01011000b << 6 = 00000000b
-01011000b << 7 = 00000000b
-01011000b << 8 = 00000000b
-01011001b << 0 = 01011001b
-01011001b << 1 = 10110010b
-01011001b << 2 = 01100100b
-01011001b << 3 = 11001000b
-01011001b << 4 = 10010000b
-01011001b << 5 = 00100000b
-01011001b << 6 = 01000000b
-01011001b << 7 = 10000000b
-01011001b << 8 = 00000000b
-01011010b << 0 = 01011010b
-01011010b << 1 = 10110100b
-01011010b << 2 = 01101000b
-01011010b << 3 = 11010000b
-01011010b << 4 = 10100000b
-01011010b << 5 = 01000000b
-01011010b << 6 = 10000000b
-01011010b << 7 = 00000000b
-01011010b << 8 = 00000000b
-01011011b << 0 = 01011011b
-01011011b << 1 = 10110110b
-01011011b << 2 = 01101100b
-01011011b << 3 = 11011000b
-01011011b << 4 = 10110000b
-01011011b << 5 = 01100000b
-01011011b << 6 = 11000000b
-01011011b << 7 = 10000000b
-01011011b << 8 = 00000000b
-01011100b << 0 = 01011100b
-01011100b << 1 = 10111000b
-01011100b << 2 = 01110000b
-01011100b << 3 = 11100000b
-01011100b << 4 = 11000000b
-01011100b << 5 = 10000000b
-01011100b << 6 = 00000000b
-01011100b << 7 = 00000000b
-01011100b << 8 = 00000000b
-01011101b << 0 = 01011101b
-01011101b << 1 = 10111010b
-01011101b << 2 = 01110100b
-01011101b << 3 = 11101000b
-01011101b << 4 = 11010000b
-01011101b << 5 = 10100000b
-01011101b << 6 = 01000000b
-01011101b << 7 = 10000000b
-01011101b << 8 = 00000000b
-01011110b << 0 = 01011110b
-01011110b << 1 = 10111100b
-01011110b << 2 = 01111000b
-01011110b << 3 = 11110000b
-01011110b << 4 = 11100000b
-01011110b << 5 = 11000000b
-01011110b << 6 = 10000000b
-01011110b << 7 = 00000000b
-01011110b << 8 = 00000000b
-01011111b << 0 = 01011111b
-01011111b << 1 = 10111110b
-01011111b << 2 = 01111100b
-01011111b << 3 = 11111000b
-01011111b << 4 = 11110000b
-01011111b << 5 = 11100000b
-01011111b << 6 = 11000000b
-01011111b << 7 = 10000000b
-01011111b << 8 = 00000000b
-01100000b << 0 = 01100000b
-01100000b << 1 = 11000000b
-01100000b << 2 = 10000000b
-01100000b << 3 = 00000000b
-01100000b << 4 = 00000000b
-01100000b << 5 = 00000000b
-01100000b << 6 = 00000000b
-01100000b << 7 = 00000000b
-01100000b << 8 = 00000000b
-01100001b << 0 = 01100001b
-01100001b << 1 = 11000010b
-01100001b << 2 = 10000100b
-01100001b << 3 = 00001000b
-01100001b << 4 = 00010000b
-01100001b << 5 = 00100000b
-01100001b << 6 = 01000000b
-01100001b << 7 = 10000000b
-01100001b << 8 = 00000000b
-01100010b << 0 = 01100010b
-01100010b << 1 = 11000100b
-01100010b << 2 = 10001000b
-01100010b << 3 = 00010000b
-01100010b << 4 = 00100000b
-01100010b << 5 = 01000000b
-01100010b << 6 = 10000000b
-01100010b << 7 = 00000000b
-01100010b << 8 = 00000000b
-01100011b << 0 = 01100011b
-01100011b << 1 = 11000110b
-01100011b << 2 = 10001100b
-01100011b << 3 = 00011000b
-01100011b << 4 = 00110000b
-01100011b << 5 = 01100000b
-01100011b << 6 = 11000000b
-01100011b << 7 = 10000000b
-01100011b << 8 = 00000000b
-01100100b << 0 = 01100100b
-01100100b << 1 = 11001000b
-01100100b << 2 = 10010000b
-01100100b << 3 = 00100000b
-01100100b << 4 = 01000000b
-01100100b << 5 = 10000000b
-01100100b << 6 = 00000000b
-01100100b << 7 = 00000000b
-01100100b << 8 = 00000000b
-01100101b << 0 = 01100101b
-01100101b << 1 = 11001010b
-01100101b << 2 = 10010100b
-01100101b << 3 = 00101000b
-01100101b << 4 = 01010000b
-01100101b << 5 = 10100000b
-01100101b << 6 = 01000000b
-01100101b << 7 = 10000000b
-01100101b << 8 = 00000000b
-01100110b << 0 = 01100110b
-01100110b << 1 = 11001100b
-01100110b << 2 = 10011000b
-01100110b << 3 = 00110000b
-01100110b << 4 = 01100000b
-01100110b << 5 = 11000000b
-01100110b << 6 = 10000000b
-01100110b << 7 = 00000000b
-01100110b << 8 = 00000000b
-01100111b << 0 = 01100111b
-01100111b << 1 = 11001110b
-01100111b << 2 = 10011100b
-01100111b << 3 = 00111000b
-01100111b << 4 = 01110000b
-01100111b << 5 = 11100000b
-01100111b << 6 = 11000000b
-01100111b << 7 = 10000000b
-01100111b << 8 = 00000000b
-01101000b << 0 = 01101000b
-01101000b << 1 = 11010000b
-01101000b << 2 = 10100000b
-01101000b << 3 = 01000000b
-01101000b << 4 = 10000000b
-01101000b << 5 = 00000000b
-01101000b << 6 = 00000000b
-01101000b << 7 = 00000000b
-01101000b << 8 = 00000000b
-01101001b << 0 = 01101001b
-01101001b << 1 = 11010010b
-01101001b << 2 = 10100100b
-01101001b << 3 = 01001000b
-01101001b << 4 = 10010000b
-01101001b << 5 = 00100000b
-01101001b << 6 = 01000000b
-01101001b << 7 = 10000000b
-01101001b << 8 = 00000000b
-01101010b << 0 = 01101010b
-01101010b << 1 = 11010100b
-01101010b << 2 = 10101000b
-01101010b << 3 = 01010000b
-01101010b << 4 = 10100000b
-01101010b << 5 = 01000000b
-01101010b << 6 = 10000000b
-01101010b << 7 = 00000000b
-01101010b << 8 = 00000000b
-01101011b << 0 = 01101011b
-01101011b << 1 = 11010110b
-01101011b << 2 = 10101100b
-01101011b << 3 = 01011000b
-01101011b << 4 = 10110000b
-01101011b << 5 = 01100000b
-01101011b << 6 = 11000000b
-01101011b << 7 = 10000000b
-01101011b << 8 = 00000000b
-01101100b << 0 = 01101100b
-01101100b << 1 = 11011000b
-01101100b << 2 = 10110000b
-01101100b << 3 = 01100000b
-01101100b << 4 = 11000000b
-01101100b << 5 = 10000000b
-01101100b << 6 = 00000000b
-01101100b << 7 = 00000000b
-01101100b << 8 = 00000000b
-01101101b << 0 = 01101101b
-01101101b << 1 = 11011010b
-01101101b << 2 = 10110100b
-01101101b << 3 = 01101000b
-01101101b << 4 = 11010000b
-01101101b << 5 = 10100000b
-01101101b << 6 = 01000000b
-01101101b << 7 = 10000000b
-01101101b << 8 = 00000000b
-01101110b << 0 = 01101110b
-01101110b << 1 = 11011100b
-01101110b << 2 = 10111000b
-01101110b << 3 = 01110000b
-01101110b << 4 = 11100000b
-01101110b << 5 = 11000000b
-01101110b << 6 = 10000000b
-01101110b << 7 = 00000000b
-01101110b << 8 = 00000000b
-01101111b << 0 = 01101111b
-01101111b << 1 = 11011110b
-01101111b << 2 = 10111100b
-01101111b << 3 = 01111000b
-01101111b << 4 = 11110000b
-01101111b << 5 = 11100000b
-01101111b << 6 = 11000000b
-01101111b << 7 = 10000000b
-01101111b << 8 = 00000000b
-01110000b << 0 = 01110000b
-01110000b << 1 = 11100000b
-01110000b << 2 = 11000000b
-01110000b << 3 = 10000000b
-01110000b << 4 = 00000000b
-01110000b << 5 = 00000000b
-01110000b << 6 = 00000000b
-01110000b << 7 = 00000000b
-01110000b << 8 = 00000000b
-01110001b << 0 = 01110001b
-01110001b << 1 = 11100010b
-01110001b << 2 = 11000100b
-01110001b << 3 = 10001000b
-01110001b << 4 = 00010000b
-01110001b << 5 = 00100000b
-01110001b << 6 = 01000000b
-01110001b << 7 = 10000000b
-01110001b << 8 = 00000000b
-01110010b << 0 = 01110010b
-01110010b << 1 = 11100100b
-01110010b << 2 = 11001000b
-01110010b << 3 = 10010000b
-01110010b << 4 = 00100000b
-01110010b << 5 = 01000000b
-01110010b << 6 = 10000000b
-01110010b << 7 = 00000000b
-01110010b << 8 = 00000000b
-01110011b << 0 = 01110011b
-01110011b << 1 = 11100110b
-01110011b << 2 = 11001100b
-01110011b << 3 = 10011000b
-01110011b << 4 = 00110000b
-01110011b << 5 = 01100000b
-01110011b << 6 = 11000000b
-01110011b << 7 = 10000000b
-01110011b << 8 = 00000000b
-01110100b << 0 = 01110100b
-01110100b << 1 = 11101000b
-01110100b << 2 = 11010000b
-01110100b << 3 = 10100000b
-01110100b << 4 = 01000000b
-01110100b << 5 = 10000000b
-01110100b << 6 = 00000000b
-01110100b << 7 = 00000000b
-01110100b << 8 = 00000000b
-01110101b << 0 = 01110101b
-01110101b << 1 = 11101010b
-01110101b << 2 = 11010100b
-01110101b << 3 = 10101000b
-01110101b << 4 = 01010000b
-01110101b << 5 = 10100000b
-01110101b << 6 = 01000000b
-01110101b << 7 = 10000000b
-01110101b << 8 = 00000000b
-01110110b << 0 = 01110110b
-01110110b << 1 = 11101100b
-01110110b << 2 = 11011000b
-01110110b << 3 = 10110000b
-01110110b << 4 = 01100000b
-01110110b << 5 = 11000000b
-01110110b << 6 = 10000000b
-01110110b << 7 = 00000000b
-01110110b << 8 = 00000000b
-01110111b << 0 = 01110111b
-01110111b << 1 = 11101110b
-01110111b << 2 = 11011100b
-01110111b << 3 = 10111000b
-01110111b << 4 = 01110000b
-01110111b << 5 = 11100000b
-01110111b << 6 = 11000000b
-01110111b << 7 = 10000000b
-01110111b << 8 = 00000000b
-01111000b << 0 = 01111000b
-01111000b << 1 = 11110000b
-01111000b << 2 = 11100000b
-01111000b << 3 = 11000000b
-01111000b << 4 = 10000000b
-01111000b << 5 = 00000000b
-01111000b << 6 = 00000000b
-01111000b << 7 = 00000000b
-01111000b << 8 = 00000000b
-01111001b << 0 = 01111001b
-01111001b << 1 = 11110010b
-01111001b << 2 = 11100100b
-01111001b << 3 = 11001000b
-01111001b << 4 = 10010000b
-01111001b << 5 = 00100000b
-01111001b << 6 = 01000000b
-01111001b << 7 = 10000000b
-01111001b << 8 = 00000000b
-01111010b << 0 = 01111010b
-01111010b << 1 = 11110100b
-01111010b << 2 = 11101000b
-01111010b << 3 = 11010000b
-01111010b << 4 = 10100000b
-01111010b << 5 = 01000000b
-01111010b << 6 = 10000000b
-01111010b << 7 = 00000000b
-01111010b << 8 = 00000000b
-01111011b << 0 = 01111011b
-01111011b << 1 = 11110110b
-01111011b << 2 = 11101100b
-01111011b << 3 = 11011000b
-01111011b << 4 = 10110000b
-01111011b << 5 = 01100000b
-01111011b << 6 = 11000000b
-01111011b << 7 = 10000000b
-01111011b << 8 = 00000000b
-01111100b << 0 = 01111100b
-01111100b << 1 = 11111000b
-01111100b << 2 = 11110000b
-01111100b << 3 = 11100000b
-01111100b << 4 = 11000000b
-01111100b << 5 = 10000000b
-01111100b << 6 = 00000000b
-01111100b << 7 = 00000000b
-01111100b << 8 = 00000000b
-01111101b << 0 = 01111101b
-01111101b << 1 = 11111010b
-01111101b << 2 = 11110100b
-01111101b << 3 = 11101000b
-01111101b << 4 = 11010000b
-01111101b << 5 = 10100000b
-01111101b << 6 = 01000000b
-01111101b << 7 = 10000000b
-01111101b << 8 = 00000000b
-01111110b << 0 = 01111110b
-01111110b << 1 = 11111100b
-01111110b << 2 = 11111000b
-01111110b << 3 = 11110000b
-01111110b << 4 = 11100000b
-01111110b << 5 = 11000000b
-01111110b << 6 = 10000000b
-01111110b << 7 = 00000000b
-01111110b << 8 = 00000000b
diff --git a/tests/valid/Byte_Valid_5.whiley b/tests/valid/Byte_Valid_5.whiley
index 436c49e3fc..0716b9fb19 100644
--- a/tests/valid/Byte_Valid_5.whiley
+++ b/tests/valid/Byte_Valid_5.whiley
@@ -1,11 +1,20 @@
-import whiley.lang.*
-import print from whiley.lang.*
+
constant constants is [10000000b, 10000001b, 10000010b, 10000011b, 10000100b, 10000101b, 10000110b, 10000111b, 10001000b, 10001001b, 10001010b, 10001011b, 10001100b, 10001101b, 10001110b, 10001111b, 10010000b, 10010001b, 10010010b, 10010011b, 10010100b, 10010101b, 10010110b, 10010111b, 10011000b, 10011001b, 10011010b, 10011011b, 10011100b, 10011101b, 10011110b, 10011111b, 10100000b, 10100001b, 10100010b, 10100011b, 10100100b, 10100101b, 10100110b, 10100111b, 10101000b, 10101001b, 10101010b, 10101011b, 10101100b, 10101101b, 10101110b, 10101111b, 10110000b, 10110001b, 10110010b, 10110011b, 10110100b, 10110101b, 10110110b, 10110111b, 10111000b, 10111001b, 10111010b, 10111011b, 10111100b, 10111101b, 10111110b, 10111111b, 11000000b, 11000001b, 11000010b, 11000011b, 11000100b, 11000101b, 11000110b, 11000111b, 11001000b, 11001001b, 11001010b, 11001011b, 11001100b, 11001101b, 11001110b, 11001111b, 11010000b, 11010001b, 11010010b, 11010011b, 11010100b, 11010101b, 11010110b, 11010111b, 11011000b, 11011001b, 11011010b, 11011011b, 11011100b, 11011101b, 11011110b, 11011111b, 11100000b, 11100001b, 11100010b, 11100011b, 11100100b, 11100101b, 11100110b, 11100111b, 11101000b, 11101001b, 11101010b, 11101011b, 11101100b, 11101101b, 11101110b, 11101111b, 11110000b, 11110001b, 11110010b, 11110011b, 11110100b, 11110101b, 11110110b, 11110111b, 11111000b, 11111001b, 11111010b, 11111011b, 11111100b, 11111101b, 11111110b, 11111111b, 00000000b, 00000001b, 00000010b, 00000011b, 00000100b, 00000101b, 00000110b, 00000111b, 00001000b, 00001001b, 00001010b, 00001011b, 00001100b, 00001101b, 00001110b, 00001111b, 00010000b, 00010001b, 00010010b, 00010011b, 00010100b, 00010101b, 00010110b, 00010111b, 00011000b, 00011001b, 00011010b, 00011011b, 00011100b, 00011101b, 00011110b, 00011111b, 00100000b, 00100001b, 00100010b, 00100011b, 00100100b, 00100101b, 00100110b, 00100111b, 00101000b, 00101001b, 00101010b, 00101011b, 00101100b, 00101101b, 00101110b, 00101111b, 00110000b, 00110001b, 00110010b, 00110011b, 00110100b, 00110101b, 00110110b, 00110111b, 00111000b, 00111001b, 00111010b, 00111011b, 00111100b, 00111101b, 00111110b, 00111111b, 01000000b, 01000001b, 01000010b, 01000011b, 01000100b, 01000101b, 01000110b, 01000111b, 01001000b, 01001001b, 01001010b, 01001011b, 01001100b, 01001101b, 01001110b, 01001111b, 01010000b, 01010001b, 01010010b, 01010011b, 01010100b, 01010101b, 01010110b, 01010111b, 01011000b, 01011001b, 01011010b, 01011011b, 01011100b, 01011101b, 01011110b, 01011111b, 01100000b, 01100001b, 01100010b, 01100011b, 01100100b, 01100101b, 01100110b, 01100111b, 01101000b, 01101001b, 01101010b, 01101011b, 01101100b, 01101101b, 01101110b, 01101111b, 01110000b, 01110001b, 01110010b, 01110011b, 01110100b, 01110101b, 01110110b, 01110111b, 01111000b, 01111001b, 01111010b, 01111011b, 01111100b, 01111101b, 01111110b]
-public method main(System.Console sys) -> void:
- for i in constants:
- for j in 0 .. 9:
- sys.out.print_s(Any.toString(i) ++ " << ")
- sys.out.print_s(Any.toString(j) ++ " = ")
- sys.out.println_s(Any.toString(i << j))
+function shr(byte b, int i) -> byte:
+ while i > 0:
+ b = b << 1
+ i = i - 1
+ return b
+
+public export method test() -> void:
+ int i = 0
+ while i < |constants|:
+ byte constant_i = constants[i]
+ int j = 0
+ while j < 9:
+ assume (constant_i << j) == shr(constant_i,j)
+ j = j + 1
+ //
+ i = i + 1
diff --git a/tests/valid/Byte_Valid_6.sysout b/tests/valid/Byte_Valid_6.sysout
deleted file mode 100644
index 226366d507..0000000000
--- a/tests/valid/Byte_Valid_6.sysout
+++ /dev/null
@@ -1,2295 +0,0 @@
-10000000b >> 0 = 10000000b
-10000000b >> 1 = 01000000b
-10000000b >> 2 = 00100000b
-10000000b >> 3 = 00010000b
-10000000b >> 4 = 00001000b
-10000000b >> 5 = 00000100b
-10000000b >> 6 = 00000010b
-10000000b >> 7 = 00000001b
-10000000b >> 8 = 00000000b
-10000001b >> 0 = 10000001b
-10000001b >> 1 = 01000000b
-10000001b >> 2 = 00100000b
-10000001b >> 3 = 00010000b
-10000001b >> 4 = 00001000b
-10000001b >> 5 = 00000100b
-10000001b >> 6 = 00000010b
-10000001b >> 7 = 00000001b
-10000001b >> 8 = 00000000b
-10000010b >> 0 = 10000010b
-10000010b >> 1 = 01000001b
-10000010b >> 2 = 00100000b
-10000010b >> 3 = 00010000b
-10000010b >> 4 = 00001000b
-10000010b >> 5 = 00000100b
-10000010b >> 6 = 00000010b
-10000010b >> 7 = 00000001b
-10000010b >> 8 = 00000000b
-10000011b >> 0 = 10000011b
-10000011b >> 1 = 01000001b
-10000011b >> 2 = 00100000b
-10000011b >> 3 = 00010000b
-10000011b >> 4 = 00001000b
-10000011b >> 5 = 00000100b
-10000011b >> 6 = 00000010b
-10000011b >> 7 = 00000001b
-10000011b >> 8 = 00000000b
-10000100b >> 0 = 10000100b
-10000100b >> 1 = 01000010b
-10000100b >> 2 = 00100001b
-10000100b >> 3 = 00010000b
-10000100b >> 4 = 00001000b
-10000100b >> 5 = 00000100b
-10000100b >> 6 = 00000010b
-10000100b >> 7 = 00000001b
-10000100b >> 8 = 00000000b
-10000101b >> 0 = 10000101b
-10000101b >> 1 = 01000010b
-10000101b >> 2 = 00100001b
-10000101b >> 3 = 00010000b
-10000101b >> 4 = 00001000b
-10000101b >> 5 = 00000100b
-10000101b >> 6 = 00000010b
-10000101b >> 7 = 00000001b
-10000101b >> 8 = 00000000b
-10000110b >> 0 = 10000110b
-10000110b >> 1 = 01000011b
-10000110b >> 2 = 00100001b
-10000110b >> 3 = 00010000b
-10000110b >> 4 = 00001000b
-10000110b >> 5 = 00000100b
-10000110b >> 6 = 00000010b
-10000110b >> 7 = 00000001b
-10000110b >> 8 = 00000000b
-10000111b >> 0 = 10000111b
-10000111b >> 1 = 01000011b
-10000111b >> 2 = 00100001b
-10000111b >> 3 = 00010000b
-10000111b >> 4 = 00001000b
-10000111b >> 5 = 00000100b
-10000111b >> 6 = 00000010b
-10000111b >> 7 = 00000001b
-10000111b >> 8 = 00000000b
-10001000b >> 0 = 10001000b
-10001000b >> 1 = 01000100b
-10001000b >> 2 = 00100010b
-10001000b >> 3 = 00010001b
-10001000b >> 4 = 00001000b
-10001000b >> 5 = 00000100b
-10001000b >> 6 = 00000010b
-10001000b >> 7 = 00000001b
-10001000b >> 8 = 00000000b
-10001001b >> 0 = 10001001b
-10001001b >> 1 = 01000100b
-10001001b >> 2 = 00100010b
-10001001b >> 3 = 00010001b
-10001001b >> 4 = 00001000b
-10001001b >> 5 = 00000100b
-10001001b >> 6 = 00000010b
-10001001b >> 7 = 00000001b
-10001001b >> 8 = 00000000b
-10001010b >> 0 = 10001010b
-10001010b >> 1 = 01000101b
-10001010b >> 2 = 00100010b
-10001010b >> 3 = 00010001b
-10001010b >> 4 = 00001000b
-10001010b >> 5 = 00000100b
-10001010b >> 6 = 00000010b
-10001010b >> 7 = 00000001b
-10001010b >> 8 = 00000000b
-10001011b >> 0 = 10001011b
-10001011b >> 1 = 01000101b
-10001011b >> 2 = 00100010b
-10001011b >> 3 = 00010001b
-10001011b >> 4 = 00001000b
-10001011b >> 5 = 00000100b
-10001011b >> 6 = 00000010b
-10001011b >> 7 = 00000001b
-10001011b >> 8 = 00000000b
-10001100b >> 0 = 10001100b
-10001100b >> 1 = 01000110b
-10001100b >> 2 = 00100011b
-10001100b >> 3 = 00010001b
-10001100b >> 4 = 00001000b
-10001100b >> 5 = 00000100b
-10001100b >> 6 = 00000010b
-10001100b >> 7 = 00000001b
-10001100b >> 8 = 00000000b
-10001101b >> 0 = 10001101b
-10001101b >> 1 = 01000110b
-10001101b >> 2 = 00100011b
-10001101b >> 3 = 00010001b
-10001101b >> 4 = 00001000b
-10001101b >> 5 = 00000100b
-10001101b >> 6 = 00000010b
-10001101b >> 7 = 00000001b
-10001101b >> 8 = 00000000b
-10001110b >> 0 = 10001110b
-10001110b >> 1 = 01000111b
-10001110b >> 2 = 00100011b
-10001110b >> 3 = 00010001b
-10001110b >> 4 = 00001000b
-10001110b >> 5 = 00000100b
-10001110b >> 6 = 00000010b
-10001110b >> 7 = 00000001b
-10001110b >> 8 = 00000000b
-10001111b >> 0 = 10001111b
-10001111b >> 1 = 01000111b
-10001111b >> 2 = 00100011b
-10001111b >> 3 = 00010001b
-10001111b >> 4 = 00001000b
-10001111b >> 5 = 00000100b
-10001111b >> 6 = 00000010b
-10001111b >> 7 = 00000001b
-10001111b >> 8 = 00000000b
-10010000b >> 0 = 10010000b
-10010000b >> 1 = 01001000b
-10010000b >> 2 = 00100100b
-10010000b >> 3 = 00010010b
-10010000b >> 4 = 00001001b
-10010000b >> 5 = 00000100b
-10010000b >> 6 = 00000010b
-10010000b >> 7 = 00000001b
-10010000b >> 8 = 00000000b
-10010001b >> 0 = 10010001b
-10010001b >> 1 = 01001000b
-10010001b >> 2 = 00100100b
-10010001b >> 3 = 00010010b
-10010001b >> 4 = 00001001b
-10010001b >> 5 = 00000100b
-10010001b >> 6 = 00000010b
-10010001b >> 7 = 00000001b
-10010001b >> 8 = 00000000b
-10010010b >> 0 = 10010010b
-10010010b >> 1 = 01001001b
-10010010b >> 2 = 00100100b
-10010010b >> 3 = 00010010b
-10010010b >> 4 = 00001001b
-10010010b >> 5 = 00000100b
-10010010b >> 6 = 00000010b
-10010010b >> 7 = 00000001b
-10010010b >> 8 = 00000000b
-10010011b >> 0 = 10010011b
-10010011b >> 1 = 01001001b
-10010011b >> 2 = 00100100b
-10010011b >> 3 = 00010010b
-10010011b >> 4 = 00001001b
-10010011b >> 5 = 00000100b
-10010011b >> 6 = 00000010b
-10010011b >> 7 = 00000001b
-10010011b >> 8 = 00000000b
-10010100b >> 0 = 10010100b
-10010100b >> 1 = 01001010b
-10010100b >> 2 = 00100101b
-10010100b >> 3 = 00010010b
-10010100b >> 4 = 00001001b
-10010100b >> 5 = 00000100b
-10010100b >> 6 = 00000010b
-10010100b >> 7 = 00000001b
-10010100b >> 8 = 00000000b
-10010101b >> 0 = 10010101b
-10010101b >> 1 = 01001010b
-10010101b >> 2 = 00100101b
-10010101b >> 3 = 00010010b
-10010101b >> 4 = 00001001b
-10010101b >> 5 = 00000100b
-10010101b >> 6 = 00000010b
-10010101b >> 7 = 00000001b
-10010101b >> 8 = 00000000b
-10010110b >> 0 = 10010110b
-10010110b >> 1 = 01001011b
-10010110b >> 2 = 00100101b
-10010110b >> 3 = 00010010b
-10010110b >> 4 = 00001001b
-10010110b >> 5 = 00000100b
-10010110b >> 6 = 00000010b
-10010110b >> 7 = 00000001b
-10010110b >> 8 = 00000000b
-10010111b >> 0 = 10010111b
-10010111b >> 1 = 01001011b
-10010111b >> 2 = 00100101b
-10010111b >> 3 = 00010010b
-10010111b >> 4 = 00001001b
-10010111b >> 5 = 00000100b
-10010111b >> 6 = 00000010b
-10010111b >> 7 = 00000001b
-10010111b >> 8 = 00000000b
-10011000b >> 0 = 10011000b
-10011000b >> 1 = 01001100b
-10011000b >> 2 = 00100110b
-10011000b >> 3 = 00010011b
-10011000b >> 4 = 00001001b
-10011000b >> 5 = 00000100b
-10011000b >> 6 = 00000010b
-10011000b >> 7 = 00000001b
-10011000b >> 8 = 00000000b
-10011001b >> 0 = 10011001b
-10011001b >> 1 = 01001100b
-10011001b >> 2 = 00100110b
-10011001b >> 3 = 00010011b
-10011001b >> 4 = 00001001b
-10011001b >> 5 = 00000100b
-10011001b >> 6 = 00000010b
-10011001b >> 7 = 00000001b
-10011001b >> 8 = 00000000b
-10011010b >> 0 = 10011010b
-10011010b >> 1 = 01001101b
-10011010b >> 2 = 00100110b
-10011010b >> 3 = 00010011b
-10011010b >> 4 = 00001001b
-10011010b >> 5 = 00000100b
-10011010b >> 6 = 00000010b
-10011010b >> 7 = 00000001b
-10011010b >> 8 = 00000000b
-10011011b >> 0 = 10011011b
-10011011b >> 1 = 01001101b
-10011011b >> 2 = 00100110b
-10011011b >> 3 = 00010011b
-10011011b >> 4 = 00001001b
-10011011b >> 5 = 00000100b
-10011011b >> 6 = 00000010b
-10011011b >> 7 = 00000001b
-10011011b >> 8 = 00000000b
-10011100b >> 0 = 10011100b
-10011100b >> 1 = 01001110b
-10011100b >> 2 = 00100111b
-10011100b >> 3 = 00010011b
-10011100b >> 4 = 00001001b
-10011100b >> 5 = 00000100b
-10011100b >> 6 = 00000010b
-10011100b >> 7 = 00000001b
-10011100b >> 8 = 00000000b
-10011101b >> 0 = 10011101b
-10011101b >> 1 = 01001110b
-10011101b >> 2 = 00100111b
-10011101b >> 3 = 00010011b
-10011101b >> 4 = 00001001b
-10011101b >> 5 = 00000100b
-10011101b >> 6 = 00000010b
-10011101b >> 7 = 00000001b
-10011101b >> 8 = 00000000b
-10011110b >> 0 = 10011110b
-10011110b >> 1 = 01001111b
-10011110b >> 2 = 00100111b
-10011110b >> 3 = 00010011b
-10011110b >> 4 = 00001001b
-10011110b >> 5 = 00000100b
-10011110b >> 6 = 00000010b
-10011110b >> 7 = 00000001b
-10011110b >> 8 = 00000000b
-10011111b >> 0 = 10011111b
-10011111b >> 1 = 01001111b
-10011111b >> 2 = 00100111b
-10011111b >> 3 = 00010011b
-10011111b >> 4 = 00001001b
-10011111b >> 5 = 00000100b
-10011111b >> 6 = 00000010b
-10011111b >> 7 = 00000001b
-10011111b >> 8 = 00000000b
-10100000b >> 0 = 10100000b
-10100000b >> 1 = 01010000b
-10100000b >> 2 = 00101000b
-10100000b >> 3 = 00010100b
-10100000b >> 4 = 00001010b
-10100000b >> 5 = 00000101b
-10100000b >> 6 = 00000010b
-10100000b >> 7 = 00000001b
-10100000b >> 8 = 00000000b
-10100001b >> 0 = 10100001b
-10100001b >> 1 = 01010000b
-10100001b >> 2 = 00101000b
-10100001b >> 3 = 00010100b
-10100001b >> 4 = 00001010b
-10100001b >> 5 = 00000101b
-10100001b >> 6 = 00000010b
-10100001b >> 7 = 00000001b
-10100001b >> 8 = 00000000b
-10100010b >> 0 = 10100010b
-10100010b >> 1 = 01010001b
-10100010b >> 2 = 00101000b
-10100010b >> 3 = 00010100b
-10100010b >> 4 = 00001010b
-10100010b >> 5 = 00000101b
-10100010b >> 6 = 00000010b
-10100010b >> 7 = 00000001b
-10100010b >> 8 = 00000000b
-10100011b >> 0 = 10100011b
-10100011b >> 1 = 01010001b
-10100011b >> 2 = 00101000b
-10100011b >> 3 = 00010100b
-10100011b >> 4 = 00001010b
-10100011b >> 5 = 00000101b
-10100011b >> 6 = 00000010b
-10100011b >> 7 = 00000001b
-10100011b >> 8 = 00000000b
-10100100b >> 0 = 10100100b
-10100100b >> 1 = 01010010b
-10100100b >> 2 = 00101001b
-10100100b >> 3 = 00010100b
-10100100b >> 4 = 00001010b
-10100100b >> 5 = 00000101b
-10100100b >> 6 = 00000010b
-10100100b >> 7 = 00000001b
-10100100b >> 8 = 00000000b
-10100101b >> 0 = 10100101b
-10100101b >> 1 = 01010010b
-10100101b >> 2 = 00101001b
-10100101b >> 3 = 00010100b
-10100101b >> 4 = 00001010b
-10100101b >> 5 = 00000101b
-10100101b >> 6 = 00000010b
-10100101b >> 7 = 00000001b
-10100101b >> 8 = 00000000b
-10100110b >> 0 = 10100110b
-10100110b >> 1 = 01010011b
-10100110b >> 2 = 00101001b
-10100110b >> 3 = 00010100b
-10100110b >> 4 = 00001010b
-10100110b >> 5 = 00000101b
-10100110b >> 6 = 00000010b
-10100110b >> 7 = 00000001b
-10100110b >> 8 = 00000000b
-10100111b >> 0 = 10100111b
-10100111b >> 1 = 01010011b
-10100111b >> 2 = 00101001b
-10100111b >> 3 = 00010100b
-10100111b >> 4 = 00001010b
-10100111b >> 5 = 00000101b
-10100111b >> 6 = 00000010b
-10100111b >> 7 = 00000001b
-10100111b >> 8 = 00000000b
-10101000b >> 0 = 10101000b
-10101000b >> 1 = 01010100b
-10101000b >> 2 = 00101010b
-10101000b >> 3 = 00010101b
-10101000b >> 4 = 00001010b
-10101000b >> 5 = 00000101b
-10101000b >> 6 = 00000010b
-10101000b >> 7 = 00000001b
-10101000b >> 8 = 00000000b
-10101001b >> 0 = 10101001b
-10101001b >> 1 = 01010100b
-10101001b >> 2 = 00101010b
-10101001b >> 3 = 00010101b
-10101001b >> 4 = 00001010b
-10101001b >> 5 = 00000101b
-10101001b >> 6 = 00000010b
-10101001b >> 7 = 00000001b
-10101001b >> 8 = 00000000b
-10101010b >> 0 = 10101010b
-10101010b >> 1 = 01010101b
-10101010b >> 2 = 00101010b
-10101010b >> 3 = 00010101b
-10101010b >> 4 = 00001010b
-10101010b >> 5 = 00000101b
-10101010b >> 6 = 00000010b
-10101010b >> 7 = 00000001b
-10101010b >> 8 = 00000000b
-10101011b >> 0 = 10101011b
-10101011b >> 1 = 01010101b
-10101011b >> 2 = 00101010b
-10101011b >> 3 = 00010101b
-10101011b >> 4 = 00001010b
-10101011b >> 5 = 00000101b
-10101011b >> 6 = 00000010b
-10101011b >> 7 = 00000001b
-10101011b >> 8 = 00000000b
-10101100b >> 0 = 10101100b
-10101100b >> 1 = 01010110b
-10101100b >> 2 = 00101011b
-10101100b >> 3 = 00010101b
-10101100b >> 4 = 00001010b
-10101100b >> 5 = 00000101b
-10101100b >> 6 = 00000010b
-10101100b >> 7 = 00000001b
-10101100b >> 8 = 00000000b
-10101101b >> 0 = 10101101b
-10101101b >> 1 = 01010110b
-10101101b >> 2 = 00101011b
-10101101b >> 3 = 00010101b
-10101101b >> 4 = 00001010b
-10101101b >> 5 = 00000101b
-10101101b >> 6 = 00000010b
-10101101b >> 7 = 00000001b
-10101101b >> 8 = 00000000b
-10101110b >> 0 = 10101110b
-10101110b >> 1 = 01010111b
-10101110b >> 2 = 00101011b
-10101110b >> 3 = 00010101b
-10101110b >> 4 = 00001010b
-10101110b >> 5 = 00000101b
-10101110b >> 6 = 00000010b
-10101110b >> 7 = 00000001b
-10101110b >> 8 = 00000000b
-10101111b >> 0 = 10101111b
-10101111b >> 1 = 01010111b
-10101111b >> 2 = 00101011b
-10101111b >> 3 = 00010101b
-10101111b >> 4 = 00001010b
-10101111b >> 5 = 00000101b
-10101111b >> 6 = 00000010b
-10101111b >> 7 = 00000001b
-10101111b >> 8 = 00000000b
-10110000b >> 0 = 10110000b
-10110000b >> 1 = 01011000b
-10110000b >> 2 = 00101100b
-10110000b >> 3 = 00010110b
-10110000b >> 4 = 00001011b
-10110000b >> 5 = 00000101b
-10110000b >> 6 = 00000010b
-10110000b >> 7 = 00000001b
-10110000b >> 8 = 00000000b
-10110001b >> 0 = 10110001b
-10110001b >> 1 = 01011000b
-10110001b >> 2 = 00101100b
-10110001b >> 3 = 00010110b
-10110001b >> 4 = 00001011b
-10110001b >> 5 = 00000101b
-10110001b >> 6 = 00000010b
-10110001b >> 7 = 00000001b
-10110001b >> 8 = 00000000b
-10110010b >> 0 = 10110010b
-10110010b >> 1 = 01011001b
-10110010b >> 2 = 00101100b
-10110010b >> 3 = 00010110b
-10110010b >> 4 = 00001011b
-10110010b >> 5 = 00000101b
-10110010b >> 6 = 00000010b
-10110010b >> 7 = 00000001b
-10110010b >> 8 = 00000000b
-10110011b >> 0 = 10110011b
-10110011b >> 1 = 01011001b
-10110011b >> 2 = 00101100b
-10110011b >> 3 = 00010110b
-10110011b >> 4 = 00001011b
-10110011b >> 5 = 00000101b
-10110011b >> 6 = 00000010b
-10110011b >> 7 = 00000001b
-10110011b >> 8 = 00000000b
-10110100b >> 0 = 10110100b
-10110100b >> 1 = 01011010b
-10110100b >> 2 = 00101101b
-10110100b >> 3 = 00010110b
-10110100b >> 4 = 00001011b
-10110100b >> 5 = 00000101b
-10110100b >> 6 = 00000010b
-10110100b >> 7 = 00000001b
-10110100b >> 8 = 00000000b
-10110101b >> 0 = 10110101b
-10110101b >> 1 = 01011010b
-10110101b >> 2 = 00101101b
-10110101b >> 3 = 00010110b
-10110101b >> 4 = 00001011b
-10110101b >> 5 = 00000101b
-10110101b >> 6 = 00000010b
-10110101b >> 7 = 00000001b
-10110101b >> 8 = 00000000b
-10110110b >> 0 = 10110110b
-10110110b >> 1 = 01011011b
-10110110b >> 2 = 00101101b
-10110110b >> 3 = 00010110b
-10110110b >> 4 = 00001011b
-10110110b >> 5 = 00000101b
-10110110b >> 6 = 00000010b
-10110110b >> 7 = 00000001b
-10110110b >> 8 = 00000000b
-10110111b >> 0 = 10110111b
-10110111b >> 1 = 01011011b
-10110111b >> 2 = 00101101b
-10110111b >> 3 = 00010110b
-10110111b >> 4 = 00001011b
-10110111b >> 5 = 00000101b
-10110111b >> 6 = 00000010b
-10110111b >> 7 = 00000001b
-10110111b >> 8 = 00000000b
-10111000b >> 0 = 10111000b
-10111000b >> 1 = 01011100b
-10111000b >> 2 = 00101110b
-10111000b >> 3 = 00010111b
-10111000b >> 4 = 00001011b
-10111000b >> 5 = 00000101b
-10111000b >> 6 = 00000010b
-10111000b >> 7 = 00000001b
-10111000b >> 8 = 00000000b
-10111001b >> 0 = 10111001b
-10111001b >> 1 = 01011100b
-10111001b >> 2 = 00101110b
-10111001b >> 3 = 00010111b
-10111001b >> 4 = 00001011b
-10111001b >> 5 = 00000101b
-10111001b >> 6 = 00000010b
-10111001b >> 7 = 00000001b
-10111001b >> 8 = 00000000b
-10111010b >> 0 = 10111010b
-10111010b >> 1 = 01011101b
-10111010b >> 2 = 00101110b
-10111010b >> 3 = 00010111b
-10111010b >> 4 = 00001011b
-10111010b >> 5 = 00000101b
-10111010b >> 6 = 00000010b
-10111010b >> 7 = 00000001b
-10111010b >> 8 = 00000000b
-10111011b >> 0 = 10111011b
-10111011b >> 1 = 01011101b
-10111011b >> 2 = 00101110b
-10111011b >> 3 = 00010111b
-10111011b >> 4 = 00001011b
-10111011b >> 5 = 00000101b
-10111011b >> 6 = 00000010b
-10111011b >> 7 = 00000001b
-10111011b >> 8 = 00000000b
-10111100b >> 0 = 10111100b
-10111100b >> 1 = 01011110b
-10111100b >> 2 = 00101111b
-10111100b >> 3 = 00010111b
-10111100b >> 4 = 00001011b
-10111100b >> 5 = 00000101b
-10111100b >> 6 = 00000010b
-10111100b >> 7 = 00000001b
-10111100b >> 8 = 00000000b
-10111101b >> 0 = 10111101b
-10111101b >> 1 = 01011110b
-10111101b >> 2 = 00101111b
-10111101b >> 3 = 00010111b
-10111101b >> 4 = 00001011b
-10111101b >> 5 = 00000101b
-10111101b >> 6 = 00000010b
-10111101b >> 7 = 00000001b
-10111101b >> 8 = 00000000b
-10111110b >> 0 = 10111110b
-10111110b >> 1 = 01011111b
-10111110b >> 2 = 00101111b
-10111110b >> 3 = 00010111b
-10111110b >> 4 = 00001011b
-10111110b >> 5 = 00000101b
-10111110b >> 6 = 00000010b
-10111110b >> 7 = 00000001b
-10111110b >> 8 = 00000000b
-10111111b >> 0 = 10111111b
-10111111b >> 1 = 01011111b
-10111111b >> 2 = 00101111b
-10111111b >> 3 = 00010111b
-10111111b >> 4 = 00001011b
-10111111b >> 5 = 00000101b
-10111111b >> 6 = 00000010b
-10111111b >> 7 = 00000001b
-10111111b >> 8 = 00000000b
-11000000b >> 0 = 11000000b
-11000000b >> 1 = 01100000b
-11000000b >> 2 = 00110000b
-11000000b >> 3 = 00011000b
-11000000b >> 4 = 00001100b
-11000000b >> 5 = 00000110b
-11000000b >> 6 = 00000011b
-11000000b >> 7 = 00000001b
-11000000b >> 8 = 00000000b
-11000001b >> 0 = 11000001b
-11000001b >> 1 = 01100000b
-11000001b >> 2 = 00110000b
-11000001b >> 3 = 00011000b
-11000001b >> 4 = 00001100b
-11000001b >> 5 = 00000110b
-11000001b >> 6 = 00000011b
-11000001b >> 7 = 00000001b
-11000001b >> 8 = 00000000b
-11000010b >> 0 = 11000010b
-11000010b >> 1 = 01100001b
-11000010b >> 2 = 00110000b
-11000010b >> 3 = 00011000b
-11000010b >> 4 = 00001100b
-11000010b >> 5 = 00000110b
-11000010b >> 6 = 00000011b
-11000010b >> 7 = 00000001b
-11000010b >> 8 = 00000000b
-11000011b >> 0 = 11000011b
-11000011b >> 1 = 01100001b
-11000011b >> 2 = 00110000b
-11000011b >> 3 = 00011000b
-11000011b >> 4 = 00001100b
-11000011b >> 5 = 00000110b
-11000011b >> 6 = 00000011b
-11000011b >> 7 = 00000001b
-11000011b >> 8 = 00000000b
-11000100b >> 0 = 11000100b
-11000100b >> 1 = 01100010b
-11000100b >> 2 = 00110001b
-11000100b >> 3 = 00011000b
-11000100b >> 4 = 00001100b
-11000100b >> 5 = 00000110b
-11000100b >> 6 = 00000011b
-11000100b >> 7 = 00000001b
-11000100b >> 8 = 00000000b
-11000101b >> 0 = 11000101b
-11000101b >> 1 = 01100010b
-11000101b >> 2 = 00110001b
-11000101b >> 3 = 00011000b
-11000101b >> 4 = 00001100b
-11000101b >> 5 = 00000110b
-11000101b >> 6 = 00000011b
-11000101b >> 7 = 00000001b
-11000101b >> 8 = 00000000b
-11000110b >> 0 = 11000110b
-11000110b >> 1 = 01100011b
-11000110b >> 2 = 00110001b
-11000110b >> 3 = 00011000b
-11000110b >> 4 = 00001100b
-11000110b >> 5 = 00000110b
-11000110b >> 6 = 00000011b
-11000110b >> 7 = 00000001b
-11000110b >> 8 = 00000000b
-11000111b >> 0 = 11000111b
-11000111b >> 1 = 01100011b
-11000111b >> 2 = 00110001b
-11000111b >> 3 = 00011000b
-11000111b >> 4 = 00001100b
-11000111b >> 5 = 00000110b
-11000111b >> 6 = 00000011b
-11000111b >> 7 = 00000001b
-11000111b >> 8 = 00000000b
-11001000b >> 0 = 11001000b
-11001000b >> 1 = 01100100b
-11001000b >> 2 = 00110010b
-11001000b >> 3 = 00011001b
-11001000b >> 4 = 00001100b
-11001000b >> 5 = 00000110b
-11001000b >> 6 = 00000011b
-11001000b >> 7 = 00000001b
-11001000b >> 8 = 00000000b
-11001001b >> 0 = 11001001b
-11001001b >> 1 = 01100100b
-11001001b >> 2 = 00110010b
-11001001b >> 3 = 00011001b
-11001001b >> 4 = 00001100b
-11001001b >> 5 = 00000110b
-11001001b >> 6 = 00000011b
-11001001b >> 7 = 00000001b
-11001001b >> 8 = 00000000b
-11001010b >> 0 = 11001010b
-11001010b >> 1 = 01100101b
-11001010b >> 2 = 00110010b
-11001010b >> 3 = 00011001b
-11001010b >> 4 = 00001100b
-11001010b >> 5 = 00000110b
-11001010b >> 6 = 00000011b
-11001010b >> 7 = 00000001b
-11001010b >> 8 = 00000000b
-11001011b >> 0 = 11001011b
-11001011b >> 1 = 01100101b
-11001011b >> 2 = 00110010b
-11001011b >> 3 = 00011001b
-11001011b >> 4 = 00001100b
-11001011b >> 5 = 00000110b
-11001011b >> 6 = 00000011b
-11001011b >> 7 = 00000001b
-11001011b >> 8 = 00000000b
-11001100b >> 0 = 11001100b
-11001100b >> 1 = 01100110b
-11001100b >> 2 = 00110011b
-11001100b >> 3 = 00011001b
-11001100b >> 4 = 00001100b
-11001100b >> 5 = 00000110b
-11001100b >> 6 = 00000011b
-11001100b >> 7 = 00000001b
-11001100b >> 8 = 00000000b
-11001101b >> 0 = 11001101b
-11001101b >> 1 = 01100110b
-11001101b >> 2 = 00110011b
-11001101b >> 3 = 00011001b
-11001101b >> 4 = 00001100b
-11001101b >> 5 = 00000110b
-11001101b >> 6 = 00000011b
-11001101b >> 7 = 00000001b
-11001101b >> 8 = 00000000b
-11001110b >> 0 = 11001110b
-11001110b >> 1 = 01100111b
-11001110b >> 2 = 00110011b
-11001110b >> 3 = 00011001b
-11001110b >> 4 = 00001100b
-11001110b >> 5 = 00000110b
-11001110b >> 6 = 00000011b
-11001110b >> 7 = 00000001b
-11001110b >> 8 = 00000000b
-11001111b >> 0 = 11001111b
-11001111b >> 1 = 01100111b
-11001111b >> 2 = 00110011b
-11001111b >> 3 = 00011001b
-11001111b >> 4 = 00001100b
-11001111b >> 5 = 00000110b
-11001111b >> 6 = 00000011b
-11001111b >> 7 = 00000001b
-11001111b >> 8 = 00000000b
-11010000b >> 0 = 11010000b
-11010000b >> 1 = 01101000b
-11010000b >> 2 = 00110100b
-11010000b >> 3 = 00011010b
-11010000b >> 4 = 00001101b
-11010000b >> 5 = 00000110b
-11010000b >> 6 = 00000011b
-11010000b >> 7 = 00000001b
-11010000b >> 8 = 00000000b
-11010001b >> 0 = 11010001b
-11010001b >> 1 = 01101000b
-11010001b >> 2 = 00110100b
-11010001b >> 3 = 00011010b
-11010001b >> 4 = 00001101b
-11010001b >> 5 = 00000110b
-11010001b >> 6 = 00000011b
-11010001b >> 7 = 00000001b
-11010001b >> 8 = 00000000b
-11010010b >> 0 = 11010010b
-11010010b >> 1 = 01101001b
-11010010b >> 2 = 00110100b
-11010010b >> 3 = 00011010b
-11010010b >> 4 = 00001101b
-11010010b >> 5 = 00000110b
-11010010b >> 6 = 00000011b
-11010010b >> 7 = 00000001b
-11010010b >> 8 = 00000000b
-11010011b >> 0 = 11010011b
-11010011b >> 1 = 01101001b
-11010011b >> 2 = 00110100b
-11010011b >> 3 = 00011010b
-11010011b >> 4 = 00001101b
-11010011b >> 5 = 00000110b
-11010011b >> 6 = 00000011b
-11010011b >> 7 = 00000001b
-11010011b >> 8 = 00000000b
-11010100b >> 0 = 11010100b
-11010100b >> 1 = 01101010b
-11010100b >> 2 = 00110101b
-11010100b >> 3 = 00011010b
-11010100b >> 4 = 00001101b
-11010100b >> 5 = 00000110b
-11010100b >> 6 = 00000011b
-11010100b >> 7 = 00000001b
-11010100b >> 8 = 00000000b
-11010101b >> 0 = 11010101b
-11010101b >> 1 = 01101010b
-11010101b >> 2 = 00110101b
-11010101b >> 3 = 00011010b
-11010101b >> 4 = 00001101b
-11010101b >> 5 = 00000110b
-11010101b >> 6 = 00000011b
-11010101b >> 7 = 00000001b
-11010101b >> 8 = 00000000b
-11010110b >> 0 = 11010110b
-11010110b >> 1 = 01101011b
-11010110b >> 2 = 00110101b
-11010110b >> 3 = 00011010b
-11010110b >> 4 = 00001101b
-11010110b >> 5 = 00000110b
-11010110b >> 6 = 00000011b
-11010110b >> 7 = 00000001b
-11010110b >> 8 = 00000000b
-11010111b >> 0 = 11010111b
-11010111b >> 1 = 01101011b
-11010111b >> 2 = 00110101b
-11010111b >> 3 = 00011010b
-11010111b >> 4 = 00001101b
-11010111b >> 5 = 00000110b
-11010111b >> 6 = 00000011b
-11010111b >> 7 = 00000001b
-11010111b >> 8 = 00000000b
-11011000b >> 0 = 11011000b
-11011000b >> 1 = 01101100b
-11011000b >> 2 = 00110110b
-11011000b >> 3 = 00011011b
-11011000b >> 4 = 00001101b
-11011000b >> 5 = 00000110b
-11011000b >> 6 = 00000011b
-11011000b >> 7 = 00000001b
-11011000b >> 8 = 00000000b
-11011001b >> 0 = 11011001b
-11011001b >> 1 = 01101100b
-11011001b >> 2 = 00110110b
-11011001b >> 3 = 00011011b
-11011001b >> 4 = 00001101b
-11011001b >> 5 = 00000110b
-11011001b >> 6 = 00000011b
-11011001b >> 7 = 00000001b
-11011001b >> 8 = 00000000b
-11011010b >> 0 = 11011010b
-11011010b >> 1 = 01101101b
-11011010b >> 2 = 00110110b
-11011010b >> 3 = 00011011b
-11011010b >> 4 = 00001101b
-11011010b >> 5 = 00000110b
-11011010b >> 6 = 00000011b
-11011010b >> 7 = 00000001b
-11011010b >> 8 = 00000000b
-11011011b >> 0 = 11011011b
-11011011b >> 1 = 01101101b
-11011011b >> 2 = 00110110b
-11011011b >> 3 = 00011011b
-11011011b >> 4 = 00001101b
-11011011b >> 5 = 00000110b
-11011011b >> 6 = 00000011b
-11011011b >> 7 = 00000001b
-11011011b >> 8 = 00000000b
-11011100b >> 0 = 11011100b
-11011100b >> 1 = 01101110b
-11011100b >> 2 = 00110111b
-11011100b >> 3 = 00011011b
-11011100b >> 4 = 00001101b
-11011100b >> 5 = 00000110b
-11011100b >> 6 = 00000011b
-11011100b >> 7 = 00000001b
-11011100b >> 8 = 00000000b
-11011101b >> 0 = 11011101b
-11011101b >> 1 = 01101110b
-11011101b >> 2 = 00110111b
-11011101b >> 3 = 00011011b
-11011101b >> 4 = 00001101b
-11011101b >> 5 = 00000110b
-11011101b >> 6 = 00000011b
-11011101b >> 7 = 00000001b
-11011101b >> 8 = 00000000b
-11011110b >> 0 = 11011110b
-11011110b >> 1 = 01101111b
-11011110b >> 2 = 00110111b
-11011110b >> 3 = 00011011b
-11011110b >> 4 = 00001101b
-11011110b >> 5 = 00000110b
-11011110b >> 6 = 00000011b
-11011110b >> 7 = 00000001b
-11011110b >> 8 = 00000000b
-11011111b >> 0 = 11011111b
-11011111b >> 1 = 01101111b
-11011111b >> 2 = 00110111b
-11011111b >> 3 = 00011011b
-11011111b >> 4 = 00001101b
-11011111b >> 5 = 00000110b
-11011111b >> 6 = 00000011b
-11011111b >> 7 = 00000001b
-11011111b >> 8 = 00000000b
-11100000b >> 0 = 11100000b
-11100000b >> 1 = 01110000b
-11100000b >> 2 = 00111000b
-11100000b >> 3 = 00011100b
-11100000b >> 4 = 00001110b
-11100000b >> 5 = 00000111b
-11100000b >> 6 = 00000011b
-11100000b >> 7 = 00000001b
-11100000b >> 8 = 00000000b
-11100001b >> 0 = 11100001b
-11100001b >> 1 = 01110000b
-11100001b >> 2 = 00111000b
-11100001b >> 3 = 00011100b
-11100001b >> 4 = 00001110b
-11100001b >> 5 = 00000111b
-11100001b >> 6 = 00000011b
-11100001b >> 7 = 00000001b
-11100001b >> 8 = 00000000b
-11100010b >> 0 = 11100010b
-11100010b >> 1 = 01110001b
-11100010b >> 2 = 00111000b
-11100010b >> 3 = 00011100b
-11100010b >> 4 = 00001110b
-11100010b >> 5 = 00000111b
-11100010b >> 6 = 00000011b
-11100010b >> 7 = 00000001b
-11100010b >> 8 = 00000000b
-11100011b >> 0 = 11100011b
-11100011b >> 1 = 01110001b
-11100011b >> 2 = 00111000b
-11100011b >> 3 = 00011100b
-11100011b >> 4 = 00001110b
-11100011b >> 5 = 00000111b
-11100011b >> 6 = 00000011b
-11100011b >> 7 = 00000001b
-11100011b >> 8 = 00000000b
-11100100b >> 0 = 11100100b
-11100100b >> 1 = 01110010b
-11100100b >> 2 = 00111001b
-11100100b >> 3 = 00011100b
-11100100b >> 4 = 00001110b
-11100100b >> 5 = 00000111b
-11100100b >> 6 = 00000011b
-11100100b >> 7 = 00000001b
-11100100b >> 8 = 00000000b
-11100101b >> 0 = 11100101b
-11100101b >> 1 = 01110010b
-11100101b >> 2 = 00111001b
-11100101b >> 3 = 00011100b
-11100101b >> 4 = 00001110b
-11100101b >> 5 = 00000111b
-11100101b >> 6 = 00000011b
-11100101b >> 7 = 00000001b
-11100101b >> 8 = 00000000b
-11100110b >> 0 = 11100110b
-11100110b >> 1 = 01110011b
-11100110b >> 2 = 00111001b
-11100110b >> 3 = 00011100b
-11100110b >> 4 = 00001110b
-11100110b >> 5 = 00000111b
-11100110b >> 6 = 00000011b
-11100110b >> 7 = 00000001b
-11100110b >> 8 = 00000000b
-11100111b >> 0 = 11100111b
-11100111b >> 1 = 01110011b
-11100111b >> 2 = 00111001b
-11100111b >> 3 = 00011100b
-11100111b >> 4 = 00001110b
-11100111b >> 5 = 00000111b
-11100111b >> 6 = 00000011b
-11100111b >> 7 = 00000001b
-11100111b >> 8 = 00000000b
-11101000b >> 0 = 11101000b
-11101000b >> 1 = 01110100b
-11101000b >> 2 = 00111010b
-11101000b >> 3 = 00011101b
-11101000b >> 4 = 00001110b
-11101000b >> 5 = 00000111b
-11101000b >> 6 = 00000011b
-11101000b >> 7 = 00000001b
-11101000b >> 8 = 00000000b
-11101001b >> 0 = 11101001b
-11101001b >> 1 = 01110100b
-11101001b >> 2 = 00111010b
-11101001b >> 3 = 00011101b
-11101001b >> 4 = 00001110b
-11101001b >> 5 = 00000111b
-11101001b >> 6 = 00000011b
-11101001b >> 7 = 00000001b
-11101001b >> 8 = 00000000b
-11101010b >> 0 = 11101010b
-11101010b >> 1 = 01110101b
-11101010b >> 2 = 00111010b
-11101010b >> 3 = 00011101b
-11101010b >> 4 = 00001110b
-11101010b >> 5 = 00000111b
-11101010b >> 6 = 00000011b
-11101010b >> 7 = 00000001b
-11101010b >> 8 = 00000000b
-11101011b >> 0 = 11101011b
-11101011b >> 1 = 01110101b
-11101011b >> 2 = 00111010b
-11101011b >> 3 = 00011101b
-11101011b >> 4 = 00001110b
-11101011b >> 5 = 00000111b
-11101011b >> 6 = 00000011b
-11101011b >> 7 = 00000001b
-11101011b >> 8 = 00000000b
-11101100b >> 0 = 11101100b
-11101100b >> 1 = 01110110b
-11101100b >> 2 = 00111011b
-11101100b >> 3 = 00011101b
-11101100b >> 4 = 00001110b
-11101100b >> 5 = 00000111b
-11101100b >> 6 = 00000011b
-11101100b >> 7 = 00000001b
-11101100b >> 8 = 00000000b
-11101101b >> 0 = 11101101b
-11101101b >> 1 = 01110110b
-11101101b >> 2 = 00111011b
-11101101b >> 3 = 00011101b
-11101101b >> 4 = 00001110b
-11101101b >> 5 = 00000111b
-11101101b >> 6 = 00000011b
-11101101b >> 7 = 00000001b
-11101101b >> 8 = 00000000b
-11101110b >> 0 = 11101110b
-11101110b >> 1 = 01110111b
-11101110b >> 2 = 00111011b
-11101110b >> 3 = 00011101b
-11101110b >> 4 = 00001110b
-11101110b >> 5 = 00000111b
-11101110b >> 6 = 00000011b
-11101110b >> 7 = 00000001b
-11101110b >> 8 = 00000000b
-11101111b >> 0 = 11101111b
-11101111b >> 1 = 01110111b
-11101111b >> 2 = 00111011b
-11101111b >> 3 = 00011101b
-11101111b >> 4 = 00001110b
-11101111b >> 5 = 00000111b
-11101111b >> 6 = 00000011b
-11101111b >> 7 = 00000001b
-11101111b >> 8 = 00000000b
-11110000b >> 0 = 11110000b
-11110000b >> 1 = 01111000b
-11110000b >> 2 = 00111100b
-11110000b >> 3 = 00011110b
-11110000b >> 4 = 00001111b
-11110000b >> 5 = 00000111b
-11110000b >> 6 = 00000011b
-11110000b >> 7 = 00000001b
-11110000b >> 8 = 00000000b
-11110001b >> 0 = 11110001b
-11110001b >> 1 = 01111000b
-11110001b >> 2 = 00111100b
-11110001b >> 3 = 00011110b
-11110001b >> 4 = 00001111b
-11110001b >> 5 = 00000111b
-11110001b >> 6 = 00000011b
-11110001b >> 7 = 00000001b
-11110001b >> 8 = 00000000b
-11110010b >> 0 = 11110010b
-11110010b >> 1 = 01111001b
-11110010b >> 2 = 00111100b
-11110010b >> 3 = 00011110b
-11110010b >> 4 = 00001111b
-11110010b >> 5 = 00000111b
-11110010b >> 6 = 00000011b
-11110010b >> 7 = 00000001b
-11110010b >> 8 = 00000000b
-11110011b >> 0 = 11110011b
-11110011b >> 1 = 01111001b
-11110011b >> 2 = 00111100b
-11110011b >> 3 = 00011110b
-11110011b >> 4 = 00001111b
-11110011b >> 5 = 00000111b
-11110011b >> 6 = 00000011b
-11110011b >> 7 = 00000001b
-11110011b >> 8 = 00000000b
-11110100b >> 0 = 11110100b
-11110100b >> 1 = 01111010b
-11110100b >> 2 = 00111101b
-11110100b >> 3 = 00011110b
-11110100b >> 4 = 00001111b
-11110100b >> 5 = 00000111b
-11110100b >> 6 = 00000011b
-11110100b >> 7 = 00000001b
-11110100b >> 8 = 00000000b
-11110101b >> 0 = 11110101b
-11110101b >> 1 = 01111010b
-11110101b >> 2 = 00111101b
-11110101b >> 3 = 00011110b
-11110101b >> 4 = 00001111b
-11110101b >> 5 = 00000111b
-11110101b >> 6 = 00000011b
-11110101b >> 7 = 00000001b
-11110101b >> 8 = 00000000b
-11110110b >> 0 = 11110110b
-11110110b >> 1 = 01111011b
-11110110b >> 2 = 00111101b
-11110110b >> 3 = 00011110b
-11110110b >> 4 = 00001111b
-11110110b >> 5 = 00000111b
-11110110b >> 6 = 00000011b
-11110110b >> 7 = 00000001b
-11110110b >> 8 = 00000000b
-11110111b >> 0 = 11110111b
-11110111b >> 1 = 01111011b
-11110111b >> 2 = 00111101b
-11110111b >> 3 = 00011110b
-11110111b >> 4 = 00001111b
-11110111b >> 5 = 00000111b
-11110111b >> 6 = 00000011b
-11110111b >> 7 = 00000001b
-11110111b >> 8 = 00000000b
-11111000b >> 0 = 11111000b
-11111000b >> 1 = 01111100b
-11111000b >> 2 = 00111110b
-11111000b >> 3 = 00011111b
-11111000b >> 4 = 00001111b
-11111000b >> 5 = 00000111b
-11111000b >> 6 = 00000011b
-11111000b >> 7 = 00000001b
-11111000b >> 8 = 00000000b
-11111001b >> 0 = 11111001b
-11111001b >> 1 = 01111100b
-11111001b >> 2 = 00111110b
-11111001b >> 3 = 00011111b
-11111001b >> 4 = 00001111b
-11111001b >> 5 = 00000111b
-11111001b >> 6 = 00000011b
-11111001b >> 7 = 00000001b
-11111001b >> 8 = 00000000b
-11111010b >> 0 = 11111010b
-11111010b >> 1 = 01111101b
-11111010b >> 2 = 00111110b
-11111010b >> 3 = 00011111b
-11111010b >> 4 = 00001111b
-11111010b >> 5 = 00000111b
-11111010b >> 6 = 00000011b
-11111010b >> 7 = 00000001b
-11111010b >> 8 = 00000000b
-11111011b >> 0 = 11111011b
-11111011b >> 1 = 01111101b
-11111011b >> 2 = 00111110b
-11111011b >> 3 = 00011111b
-11111011b >> 4 = 00001111b
-11111011b >> 5 = 00000111b
-11111011b >> 6 = 00000011b
-11111011b >> 7 = 00000001b
-11111011b >> 8 = 00000000b
-11111100b >> 0 = 11111100b
-11111100b >> 1 = 01111110b
-11111100b >> 2 = 00111111b
-11111100b >> 3 = 00011111b
-11111100b >> 4 = 00001111b
-11111100b >> 5 = 00000111b
-11111100b >> 6 = 00000011b
-11111100b >> 7 = 00000001b
-11111100b >> 8 = 00000000b
-11111101b >> 0 = 11111101b
-11111101b >> 1 = 01111110b
-11111101b >> 2 = 00111111b
-11111101b >> 3 = 00011111b
-11111101b >> 4 = 00001111b
-11111101b >> 5 = 00000111b
-11111101b >> 6 = 00000011b
-11111101b >> 7 = 00000001b
-11111101b >> 8 = 00000000b
-11111110b >> 0 = 11111110b
-11111110b >> 1 = 01111111b
-11111110b >> 2 = 00111111b
-11111110b >> 3 = 00011111b
-11111110b >> 4 = 00001111b
-11111110b >> 5 = 00000111b
-11111110b >> 6 = 00000011b
-11111110b >> 7 = 00000001b
-11111110b >> 8 = 00000000b
-11111111b >> 0 = 11111111b
-11111111b >> 1 = 01111111b
-11111111b >> 2 = 00111111b
-11111111b >> 3 = 00011111b
-11111111b >> 4 = 00001111b
-11111111b >> 5 = 00000111b
-11111111b >> 6 = 00000011b
-11111111b >> 7 = 00000001b
-11111111b >> 8 = 00000000b
-00000000b >> 0 = 00000000b
-00000000b >> 1 = 00000000b
-00000000b >> 2 = 00000000b
-00000000b >> 3 = 00000000b
-00000000b >> 4 = 00000000b
-00000000b >> 5 = 00000000b
-00000000b >> 6 = 00000000b
-00000000b >> 7 = 00000000b
-00000000b >> 8 = 00000000b
-00000001b >> 0 = 00000001b
-00000001b >> 1 = 00000000b
-00000001b >> 2 = 00000000b
-00000001b >> 3 = 00000000b
-00000001b >> 4 = 00000000b
-00000001b >> 5 = 00000000b
-00000001b >> 6 = 00000000b
-00000001b >> 7 = 00000000b
-00000001b >> 8 = 00000000b
-00000010b >> 0 = 00000010b
-00000010b >> 1 = 00000001b
-00000010b >> 2 = 00000000b
-00000010b >> 3 = 00000000b
-00000010b >> 4 = 00000000b
-00000010b >> 5 = 00000000b
-00000010b >> 6 = 00000000b
-00000010b >> 7 = 00000000b
-00000010b >> 8 = 00000000b
-00000011b >> 0 = 00000011b
-00000011b >> 1 = 00000001b
-00000011b >> 2 = 00000000b
-00000011b >> 3 = 00000000b
-00000011b >> 4 = 00000000b
-00000011b >> 5 = 00000000b
-00000011b >> 6 = 00000000b
-00000011b >> 7 = 00000000b
-00000011b >> 8 = 00000000b
-00000100b >> 0 = 00000100b
-00000100b >> 1 = 00000010b
-00000100b >> 2 = 00000001b
-00000100b >> 3 = 00000000b
-00000100b >> 4 = 00000000b
-00000100b >> 5 = 00000000b
-00000100b >> 6 = 00000000b
-00000100b >> 7 = 00000000b
-00000100b >> 8 = 00000000b
-00000101b >> 0 = 00000101b
-00000101b >> 1 = 00000010b
-00000101b >> 2 = 00000001b
-00000101b >> 3 = 00000000b
-00000101b >> 4 = 00000000b
-00000101b >> 5 = 00000000b
-00000101b >> 6 = 00000000b
-00000101b >> 7 = 00000000b
-00000101b >> 8 = 00000000b
-00000110b >> 0 = 00000110b
-00000110b >> 1 = 00000011b
-00000110b >> 2 = 00000001b
-00000110b >> 3 = 00000000b
-00000110b >> 4 = 00000000b
-00000110b >> 5 = 00000000b
-00000110b >> 6 = 00000000b
-00000110b >> 7 = 00000000b
-00000110b >> 8 = 00000000b
-00000111b >> 0 = 00000111b
-00000111b >> 1 = 00000011b
-00000111b >> 2 = 00000001b
-00000111b >> 3 = 00000000b
-00000111b >> 4 = 00000000b
-00000111b >> 5 = 00000000b
-00000111b >> 6 = 00000000b
-00000111b >> 7 = 00000000b
-00000111b >> 8 = 00000000b
-00001000b >> 0 = 00001000b
-00001000b >> 1 = 00000100b
-00001000b >> 2 = 00000010b
-00001000b >> 3 = 00000001b
-00001000b >> 4 = 00000000b
-00001000b >> 5 = 00000000b
-00001000b >> 6 = 00000000b
-00001000b >> 7 = 00000000b
-00001000b >> 8 = 00000000b
-00001001b >> 0 = 00001001b
-00001001b >> 1 = 00000100b
-00001001b >> 2 = 00000010b
-00001001b >> 3 = 00000001b
-00001001b >> 4 = 00000000b
-00001001b >> 5 = 00000000b
-00001001b >> 6 = 00000000b
-00001001b >> 7 = 00000000b
-00001001b >> 8 = 00000000b
-00001010b >> 0 = 00001010b
-00001010b >> 1 = 00000101b
-00001010b >> 2 = 00000010b
-00001010b >> 3 = 00000001b
-00001010b >> 4 = 00000000b
-00001010b >> 5 = 00000000b
-00001010b >> 6 = 00000000b
-00001010b >> 7 = 00000000b
-00001010b >> 8 = 00000000b
-00001011b >> 0 = 00001011b
-00001011b >> 1 = 00000101b
-00001011b >> 2 = 00000010b
-00001011b >> 3 = 00000001b
-00001011b >> 4 = 00000000b
-00001011b >> 5 = 00000000b
-00001011b >> 6 = 00000000b
-00001011b >> 7 = 00000000b
-00001011b >> 8 = 00000000b
-00001100b >> 0 = 00001100b
-00001100b >> 1 = 00000110b
-00001100b >> 2 = 00000011b
-00001100b >> 3 = 00000001b
-00001100b >> 4 = 00000000b
-00001100b >> 5 = 00000000b
-00001100b >> 6 = 00000000b
-00001100b >> 7 = 00000000b
-00001100b >> 8 = 00000000b
-00001101b >> 0 = 00001101b
-00001101b >> 1 = 00000110b
-00001101b >> 2 = 00000011b
-00001101b >> 3 = 00000001b
-00001101b >> 4 = 00000000b
-00001101b >> 5 = 00000000b
-00001101b >> 6 = 00000000b
-00001101b >> 7 = 00000000b
-00001101b >> 8 = 00000000b
-00001110b >> 0 = 00001110b
-00001110b >> 1 = 00000111b
-00001110b >> 2 = 00000011b
-00001110b >> 3 = 00000001b
-00001110b >> 4 = 00000000b
-00001110b >> 5 = 00000000b
-00001110b >> 6 = 00000000b
-00001110b >> 7 = 00000000b
-00001110b >> 8 = 00000000b
-00001111b >> 0 = 00001111b
-00001111b >> 1 = 00000111b
-00001111b >> 2 = 00000011b
-00001111b >> 3 = 00000001b
-00001111b >> 4 = 00000000b
-00001111b >> 5 = 00000000b
-00001111b >> 6 = 00000000b
-00001111b >> 7 = 00000000b
-00001111b >> 8 = 00000000b
-00010000b >> 0 = 00010000b
-00010000b >> 1 = 00001000b
-00010000b >> 2 = 00000100b
-00010000b >> 3 = 00000010b
-00010000b >> 4 = 00000001b
-00010000b >> 5 = 00000000b
-00010000b >> 6 = 00000000b
-00010000b >> 7 = 00000000b
-00010000b >> 8 = 00000000b
-00010001b >> 0 = 00010001b
-00010001b >> 1 = 00001000b
-00010001b >> 2 = 00000100b
-00010001b >> 3 = 00000010b
-00010001b >> 4 = 00000001b
-00010001b >> 5 = 00000000b
-00010001b >> 6 = 00000000b
-00010001b >> 7 = 00000000b
-00010001b >> 8 = 00000000b
-00010010b >> 0 = 00010010b
-00010010b >> 1 = 00001001b
-00010010b >> 2 = 00000100b
-00010010b >> 3 = 00000010b
-00010010b >> 4 = 00000001b
-00010010b >> 5 = 00000000b
-00010010b >> 6 = 00000000b
-00010010b >> 7 = 00000000b
-00010010b >> 8 = 00000000b
-00010011b >> 0 = 00010011b
-00010011b >> 1 = 00001001b
-00010011b >> 2 = 00000100b
-00010011b >> 3 = 00000010b
-00010011b >> 4 = 00000001b
-00010011b >> 5 = 00000000b
-00010011b >> 6 = 00000000b
-00010011b >> 7 = 00000000b
-00010011b >> 8 = 00000000b
-00010100b >> 0 = 00010100b
-00010100b >> 1 = 00001010b
-00010100b >> 2 = 00000101b
-00010100b >> 3 = 00000010b
-00010100b >> 4 = 00000001b
-00010100b >> 5 = 00000000b
-00010100b >> 6 = 00000000b
-00010100b >> 7 = 00000000b
-00010100b >> 8 = 00000000b
-00010101b >> 0 = 00010101b
-00010101b >> 1 = 00001010b
-00010101b >> 2 = 00000101b
-00010101b >> 3 = 00000010b
-00010101b >> 4 = 00000001b
-00010101b >> 5 = 00000000b
-00010101b >> 6 = 00000000b
-00010101b >> 7 = 00000000b
-00010101b >> 8 = 00000000b
-00010110b >> 0 = 00010110b
-00010110b >> 1 = 00001011b
-00010110b >> 2 = 00000101b
-00010110b >> 3 = 00000010b
-00010110b >> 4 = 00000001b
-00010110b >> 5 = 00000000b
-00010110b >> 6 = 00000000b
-00010110b >> 7 = 00000000b
-00010110b >> 8 = 00000000b
-00010111b >> 0 = 00010111b
-00010111b >> 1 = 00001011b
-00010111b >> 2 = 00000101b
-00010111b >> 3 = 00000010b
-00010111b >> 4 = 00000001b
-00010111b >> 5 = 00000000b
-00010111b >> 6 = 00000000b
-00010111b >> 7 = 00000000b
-00010111b >> 8 = 00000000b
-00011000b >> 0 = 00011000b
-00011000b >> 1 = 00001100b
-00011000b >> 2 = 00000110b
-00011000b >> 3 = 00000011b
-00011000b >> 4 = 00000001b
-00011000b >> 5 = 00000000b
-00011000b >> 6 = 00000000b
-00011000b >> 7 = 00000000b
-00011000b >> 8 = 00000000b
-00011001b >> 0 = 00011001b
-00011001b >> 1 = 00001100b
-00011001b >> 2 = 00000110b
-00011001b >> 3 = 00000011b
-00011001b >> 4 = 00000001b
-00011001b >> 5 = 00000000b
-00011001b >> 6 = 00000000b
-00011001b >> 7 = 00000000b
-00011001b >> 8 = 00000000b
-00011010b >> 0 = 00011010b
-00011010b >> 1 = 00001101b
-00011010b >> 2 = 00000110b
-00011010b >> 3 = 00000011b
-00011010b >> 4 = 00000001b
-00011010b >> 5 = 00000000b
-00011010b >> 6 = 00000000b
-00011010b >> 7 = 00000000b
-00011010b >> 8 = 00000000b
-00011011b >> 0 = 00011011b
-00011011b >> 1 = 00001101b
-00011011b >> 2 = 00000110b
-00011011b >> 3 = 00000011b
-00011011b >> 4 = 00000001b
-00011011b >> 5 = 00000000b
-00011011b >> 6 = 00000000b
-00011011b >> 7 = 00000000b
-00011011b >> 8 = 00000000b
-00011100b >> 0 = 00011100b
-00011100b >> 1 = 00001110b
-00011100b >> 2 = 00000111b
-00011100b >> 3 = 00000011b
-00011100b >> 4 = 00000001b
-00011100b >> 5 = 00000000b
-00011100b >> 6 = 00000000b
-00011100b >> 7 = 00000000b
-00011100b >> 8 = 00000000b
-00011101b >> 0 = 00011101b
-00011101b >> 1 = 00001110b
-00011101b >> 2 = 00000111b
-00011101b >> 3 = 00000011b
-00011101b >> 4 = 00000001b
-00011101b >> 5 = 00000000b
-00011101b >> 6 = 00000000b
-00011101b >> 7 = 00000000b
-00011101b >> 8 = 00000000b
-00011110b >> 0 = 00011110b
-00011110b >> 1 = 00001111b
-00011110b >> 2 = 00000111b
-00011110b >> 3 = 00000011b
-00011110b >> 4 = 00000001b
-00011110b >> 5 = 00000000b
-00011110b >> 6 = 00000000b
-00011110b >> 7 = 00000000b
-00011110b >> 8 = 00000000b
-00011111b >> 0 = 00011111b
-00011111b >> 1 = 00001111b
-00011111b >> 2 = 00000111b
-00011111b >> 3 = 00000011b
-00011111b >> 4 = 00000001b
-00011111b >> 5 = 00000000b
-00011111b >> 6 = 00000000b
-00011111b >> 7 = 00000000b
-00011111b >> 8 = 00000000b
-00100000b >> 0 = 00100000b
-00100000b >> 1 = 00010000b
-00100000b >> 2 = 00001000b
-00100000b >> 3 = 00000100b
-00100000b >> 4 = 00000010b
-00100000b >> 5 = 00000001b
-00100000b >> 6 = 00000000b
-00100000b >> 7 = 00000000b
-00100000b >> 8 = 00000000b
-00100001b >> 0 = 00100001b
-00100001b >> 1 = 00010000b
-00100001b >> 2 = 00001000b
-00100001b >> 3 = 00000100b
-00100001b >> 4 = 00000010b
-00100001b >> 5 = 00000001b
-00100001b >> 6 = 00000000b
-00100001b >> 7 = 00000000b
-00100001b >> 8 = 00000000b
-00100010b >> 0 = 00100010b
-00100010b >> 1 = 00010001b
-00100010b >> 2 = 00001000b
-00100010b >> 3 = 00000100b
-00100010b >> 4 = 00000010b
-00100010b >> 5 = 00000001b
-00100010b >> 6 = 00000000b
-00100010b >> 7 = 00000000b
-00100010b >> 8 = 00000000b
-00100011b >> 0 = 00100011b
-00100011b >> 1 = 00010001b
-00100011b >> 2 = 00001000b
-00100011b >> 3 = 00000100b
-00100011b >> 4 = 00000010b
-00100011b >> 5 = 00000001b
-00100011b >> 6 = 00000000b
-00100011b >> 7 = 00000000b
-00100011b >> 8 = 00000000b
-00100100b >> 0 = 00100100b
-00100100b >> 1 = 00010010b
-00100100b >> 2 = 00001001b
-00100100b >> 3 = 00000100b
-00100100b >> 4 = 00000010b
-00100100b >> 5 = 00000001b
-00100100b >> 6 = 00000000b
-00100100b >> 7 = 00000000b
-00100100b >> 8 = 00000000b
-00100101b >> 0 = 00100101b
-00100101b >> 1 = 00010010b
-00100101b >> 2 = 00001001b
-00100101b >> 3 = 00000100b
-00100101b >> 4 = 00000010b
-00100101b >> 5 = 00000001b
-00100101b >> 6 = 00000000b
-00100101b >> 7 = 00000000b
-00100101b >> 8 = 00000000b
-00100110b >> 0 = 00100110b
-00100110b >> 1 = 00010011b
-00100110b >> 2 = 00001001b
-00100110b >> 3 = 00000100b
-00100110b >> 4 = 00000010b
-00100110b >> 5 = 00000001b
-00100110b >> 6 = 00000000b
-00100110b >> 7 = 00000000b
-00100110b >> 8 = 00000000b
-00100111b >> 0 = 00100111b
-00100111b >> 1 = 00010011b
-00100111b >> 2 = 00001001b
-00100111b >> 3 = 00000100b
-00100111b >> 4 = 00000010b
-00100111b >> 5 = 00000001b
-00100111b >> 6 = 00000000b
-00100111b >> 7 = 00000000b
-00100111b >> 8 = 00000000b
-00101000b >> 0 = 00101000b
-00101000b >> 1 = 00010100b
-00101000b >> 2 = 00001010b
-00101000b >> 3 = 00000101b
-00101000b >> 4 = 00000010b
-00101000b >> 5 = 00000001b
-00101000b >> 6 = 00000000b
-00101000b >> 7 = 00000000b
-00101000b >> 8 = 00000000b
-00101001b >> 0 = 00101001b
-00101001b >> 1 = 00010100b
-00101001b >> 2 = 00001010b
-00101001b >> 3 = 00000101b
-00101001b >> 4 = 00000010b
-00101001b >> 5 = 00000001b
-00101001b >> 6 = 00000000b
-00101001b >> 7 = 00000000b
-00101001b >> 8 = 00000000b
-00101010b >> 0 = 00101010b
-00101010b >> 1 = 00010101b
-00101010b >> 2 = 00001010b
-00101010b >> 3 = 00000101b
-00101010b >> 4 = 00000010b
-00101010b >> 5 = 00000001b
-00101010b >> 6 = 00000000b
-00101010b >> 7 = 00000000b
-00101010b >> 8 = 00000000b
-00101011b >> 0 = 00101011b
-00101011b >> 1 = 00010101b
-00101011b >> 2 = 00001010b
-00101011b >> 3 = 00000101b
-00101011b >> 4 = 00000010b
-00101011b >> 5 = 00000001b
-00101011b >> 6 = 00000000b
-00101011b >> 7 = 00000000b
-00101011b >> 8 = 00000000b
-00101100b >> 0 = 00101100b
-00101100b >> 1 = 00010110b
-00101100b >> 2 = 00001011b
-00101100b >> 3 = 00000101b
-00101100b >> 4 = 00000010b
-00101100b >> 5 = 00000001b
-00101100b >> 6 = 00000000b
-00101100b >> 7 = 00000000b
-00101100b >> 8 = 00000000b
-00101101b >> 0 = 00101101b
-00101101b >> 1 = 00010110b
-00101101b >> 2 = 00001011b
-00101101b >> 3 = 00000101b
-00101101b >> 4 = 00000010b
-00101101b >> 5 = 00000001b
-00101101b >> 6 = 00000000b
-00101101b >> 7 = 00000000b
-00101101b >> 8 = 00000000b
-00101110b >> 0 = 00101110b
-00101110b >> 1 = 00010111b
-00101110b >> 2 = 00001011b
-00101110b >> 3 = 00000101b
-00101110b >> 4 = 00000010b
-00101110b >> 5 = 00000001b
-00101110b >> 6 = 00000000b
-00101110b >> 7 = 00000000b
-00101110b >> 8 = 00000000b
-00101111b >> 0 = 00101111b
-00101111b >> 1 = 00010111b
-00101111b >> 2 = 00001011b
-00101111b >> 3 = 00000101b
-00101111b >> 4 = 00000010b
-00101111b >> 5 = 00000001b
-00101111b >> 6 = 00000000b
-00101111b >> 7 = 00000000b
-00101111b >> 8 = 00000000b
-00110000b >> 0 = 00110000b
-00110000b >> 1 = 00011000b
-00110000b >> 2 = 00001100b
-00110000b >> 3 = 00000110b
-00110000b >> 4 = 00000011b
-00110000b >> 5 = 00000001b
-00110000b >> 6 = 00000000b
-00110000b >> 7 = 00000000b
-00110000b >> 8 = 00000000b
-00110001b >> 0 = 00110001b
-00110001b >> 1 = 00011000b
-00110001b >> 2 = 00001100b
-00110001b >> 3 = 00000110b
-00110001b >> 4 = 00000011b
-00110001b >> 5 = 00000001b
-00110001b >> 6 = 00000000b
-00110001b >> 7 = 00000000b
-00110001b >> 8 = 00000000b
-00110010b >> 0 = 00110010b
-00110010b >> 1 = 00011001b
-00110010b >> 2 = 00001100b
-00110010b >> 3 = 00000110b
-00110010b >> 4 = 00000011b
-00110010b >> 5 = 00000001b
-00110010b >> 6 = 00000000b
-00110010b >> 7 = 00000000b
-00110010b >> 8 = 00000000b
-00110011b >> 0 = 00110011b
-00110011b >> 1 = 00011001b
-00110011b >> 2 = 00001100b
-00110011b >> 3 = 00000110b
-00110011b >> 4 = 00000011b
-00110011b >> 5 = 00000001b
-00110011b >> 6 = 00000000b
-00110011b >> 7 = 00000000b
-00110011b >> 8 = 00000000b
-00110100b >> 0 = 00110100b
-00110100b >> 1 = 00011010b
-00110100b >> 2 = 00001101b
-00110100b >> 3 = 00000110b
-00110100b >> 4 = 00000011b
-00110100b >> 5 = 00000001b
-00110100b >> 6 = 00000000b
-00110100b >> 7 = 00000000b
-00110100b >> 8 = 00000000b
-00110101b >> 0 = 00110101b
-00110101b >> 1 = 00011010b
-00110101b >> 2 = 00001101b
-00110101b >> 3 = 00000110b
-00110101b >> 4 = 00000011b
-00110101b >> 5 = 00000001b
-00110101b >> 6 = 00000000b
-00110101b >> 7 = 00000000b
-00110101b >> 8 = 00000000b
-00110110b >> 0 = 00110110b
-00110110b >> 1 = 00011011b
-00110110b >> 2 = 00001101b
-00110110b >> 3 = 00000110b
-00110110b >> 4 = 00000011b
-00110110b >> 5 = 00000001b
-00110110b >> 6 = 00000000b
-00110110b >> 7 = 00000000b
-00110110b >> 8 = 00000000b
-00110111b >> 0 = 00110111b
-00110111b >> 1 = 00011011b
-00110111b >> 2 = 00001101b
-00110111b >> 3 = 00000110b
-00110111b >> 4 = 00000011b
-00110111b >> 5 = 00000001b
-00110111b >> 6 = 00000000b
-00110111b >> 7 = 00000000b
-00110111b >> 8 = 00000000b
-00111000b >> 0 = 00111000b
-00111000b >> 1 = 00011100b
-00111000b >> 2 = 00001110b
-00111000b >> 3 = 00000111b
-00111000b >> 4 = 00000011b
-00111000b >> 5 = 00000001b
-00111000b >> 6 = 00000000b
-00111000b >> 7 = 00000000b
-00111000b >> 8 = 00000000b
-00111001b >> 0 = 00111001b
-00111001b >> 1 = 00011100b
-00111001b >> 2 = 00001110b
-00111001b >> 3 = 00000111b
-00111001b >> 4 = 00000011b
-00111001b >> 5 = 00000001b
-00111001b >> 6 = 00000000b
-00111001b >> 7 = 00000000b
-00111001b >> 8 = 00000000b
-00111010b >> 0 = 00111010b
-00111010b >> 1 = 00011101b
-00111010b >> 2 = 00001110b
-00111010b >> 3 = 00000111b
-00111010b >> 4 = 00000011b
-00111010b >> 5 = 00000001b
-00111010b >> 6 = 00000000b
-00111010b >> 7 = 00000000b
-00111010b >> 8 = 00000000b
-00111011b >> 0 = 00111011b
-00111011b >> 1 = 00011101b
-00111011b >> 2 = 00001110b
-00111011b >> 3 = 00000111b
-00111011b >> 4 = 00000011b
-00111011b >> 5 = 00000001b
-00111011b >> 6 = 00000000b
-00111011b >> 7 = 00000000b
-00111011b >> 8 = 00000000b
-00111100b >> 0 = 00111100b
-00111100b >> 1 = 00011110b
-00111100b >> 2 = 00001111b
-00111100b >> 3 = 00000111b
-00111100b >> 4 = 00000011b
-00111100b >> 5 = 00000001b
-00111100b >> 6 = 00000000b
-00111100b >> 7 = 00000000b
-00111100b >> 8 = 00000000b
-00111101b >> 0 = 00111101b
-00111101b >> 1 = 00011110b
-00111101b >> 2 = 00001111b
-00111101b >> 3 = 00000111b
-00111101b >> 4 = 00000011b
-00111101b >> 5 = 00000001b
-00111101b >> 6 = 00000000b
-00111101b >> 7 = 00000000b
-00111101b >> 8 = 00000000b
-00111110b >> 0 = 00111110b
-00111110b >> 1 = 00011111b
-00111110b >> 2 = 00001111b
-00111110b >> 3 = 00000111b
-00111110b >> 4 = 00000011b
-00111110b >> 5 = 00000001b
-00111110b >> 6 = 00000000b
-00111110b >> 7 = 00000000b
-00111110b >> 8 = 00000000b
-00111111b >> 0 = 00111111b
-00111111b >> 1 = 00011111b
-00111111b >> 2 = 00001111b
-00111111b >> 3 = 00000111b
-00111111b >> 4 = 00000011b
-00111111b >> 5 = 00000001b
-00111111b >> 6 = 00000000b
-00111111b >> 7 = 00000000b
-00111111b >> 8 = 00000000b
-01000000b >> 0 = 01000000b
-01000000b >> 1 = 00100000b
-01000000b >> 2 = 00010000b
-01000000b >> 3 = 00001000b
-01000000b >> 4 = 00000100b
-01000000b >> 5 = 00000010b
-01000000b >> 6 = 00000001b
-01000000b >> 7 = 00000000b
-01000000b >> 8 = 00000000b
-01000001b >> 0 = 01000001b
-01000001b >> 1 = 00100000b
-01000001b >> 2 = 00010000b
-01000001b >> 3 = 00001000b
-01000001b >> 4 = 00000100b
-01000001b >> 5 = 00000010b
-01000001b >> 6 = 00000001b
-01000001b >> 7 = 00000000b
-01000001b >> 8 = 00000000b
-01000010b >> 0 = 01000010b
-01000010b >> 1 = 00100001b
-01000010b >> 2 = 00010000b
-01000010b >> 3 = 00001000b
-01000010b >> 4 = 00000100b
-01000010b >> 5 = 00000010b
-01000010b >> 6 = 00000001b
-01000010b >> 7 = 00000000b
-01000010b >> 8 = 00000000b
-01000011b >> 0 = 01000011b
-01000011b >> 1 = 00100001b
-01000011b >> 2 = 00010000b
-01000011b >> 3 = 00001000b
-01000011b >> 4 = 00000100b
-01000011b >> 5 = 00000010b
-01000011b >> 6 = 00000001b
-01000011b >> 7 = 00000000b
-01000011b >> 8 = 00000000b
-01000100b >> 0 = 01000100b
-01000100b >> 1 = 00100010b
-01000100b >> 2 = 00010001b
-01000100b >> 3 = 00001000b
-01000100b >> 4 = 00000100b
-01000100b >> 5 = 00000010b
-01000100b >> 6 = 00000001b
-01000100b >> 7 = 00000000b
-01000100b >> 8 = 00000000b
-01000101b >> 0 = 01000101b
-01000101b >> 1 = 00100010b
-01000101b >> 2 = 00010001b
-01000101b >> 3 = 00001000b
-01000101b >> 4 = 00000100b
-01000101b >> 5 = 00000010b
-01000101b >> 6 = 00000001b
-01000101b >> 7 = 00000000b
-01000101b >> 8 = 00000000b
-01000110b >> 0 = 01000110b
-01000110b >> 1 = 00100011b
-01000110b >> 2 = 00010001b
-01000110b >> 3 = 00001000b
-01000110b >> 4 = 00000100b
-01000110b >> 5 = 00000010b
-01000110b >> 6 = 00000001b
-01000110b >> 7 = 00000000b
-01000110b >> 8 = 00000000b
-01000111b >> 0 = 01000111b
-01000111b >> 1 = 00100011b
-01000111b >> 2 = 00010001b
-01000111b >> 3 = 00001000b
-01000111b >> 4 = 00000100b
-01000111b >> 5 = 00000010b
-01000111b >> 6 = 00000001b
-01000111b >> 7 = 00000000b
-01000111b >> 8 = 00000000b
-01001000b >> 0 = 01001000b
-01001000b >> 1 = 00100100b
-01001000b >> 2 = 00010010b
-01001000b >> 3 = 00001001b
-01001000b >> 4 = 00000100b
-01001000b >> 5 = 00000010b
-01001000b >> 6 = 00000001b
-01001000b >> 7 = 00000000b
-01001000b >> 8 = 00000000b
-01001001b >> 0 = 01001001b
-01001001b >> 1 = 00100100b
-01001001b >> 2 = 00010010b
-01001001b >> 3 = 00001001b
-01001001b >> 4 = 00000100b
-01001001b >> 5 = 00000010b
-01001001b >> 6 = 00000001b
-01001001b >> 7 = 00000000b
-01001001b >> 8 = 00000000b
-01001010b >> 0 = 01001010b
-01001010b >> 1 = 00100101b
-01001010b >> 2 = 00010010b
-01001010b >> 3 = 00001001b
-01001010b >> 4 = 00000100b
-01001010b >> 5 = 00000010b
-01001010b >> 6 = 00000001b
-01001010b >> 7 = 00000000b
-01001010b >> 8 = 00000000b
-01001011b >> 0 = 01001011b
-01001011b >> 1 = 00100101b
-01001011b >> 2 = 00010010b
-01001011b >> 3 = 00001001b
-01001011b >> 4 = 00000100b
-01001011b >> 5 = 00000010b
-01001011b >> 6 = 00000001b
-01001011b >> 7 = 00000000b
-01001011b >> 8 = 00000000b
-01001100b >> 0 = 01001100b
-01001100b >> 1 = 00100110b
-01001100b >> 2 = 00010011b
-01001100b >> 3 = 00001001b
-01001100b >> 4 = 00000100b
-01001100b >> 5 = 00000010b
-01001100b >> 6 = 00000001b
-01001100b >> 7 = 00000000b
-01001100b >> 8 = 00000000b
-01001101b >> 0 = 01001101b
-01001101b >> 1 = 00100110b
-01001101b >> 2 = 00010011b
-01001101b >> 3 = 00001001b
-01001101b >> 4 = 00000100b
-01001101b >> 5 = 00000010b
-01001101b >> 6 = 00000001b
-01001101b >> 7 = 00000000b
-01001101b >> 8 = 00000000b
-01001110b >> 0 = 01001110b
-01001110b >> 1 = 00100111b
-01001110b >> 2 = 00010011b
-01001110b >> 3 = 00001001b
-01001110b >> 4 = 00000100b
-01001110b >> 5 = 00000010b
-01001110b >> 6 = 00000001b
-01001110b >> 7 = 00000000b
-01001110b >> 8 = 00000000b
-01001111b >> 0 = 01001111b
-01001111b >> 1 = 00100111b
-01001111b >> 2 = 00010011b
-01001111b >> 3 = 00001001b
-01001111b >> 4 = 00000100b
-01001111b >> 5 = 00000010b
-01001111b >> 6 = 00000001b
-01001111b >> 7 = 00000000b
-01001111b >> 8 = 00000000b
-01010000b >> 0 = 01010000b
-01010000b >> 1 = 00101000b
-01010000b >> 2 = 00010100b
-01010000b >> 3 = 00001010b
-01010000b >> 4 = 00000101b
-01010000b >> 5 = 00000010b
-01010000b >> 6 = 00000001b
-01010000b >> 7 = 00000000b
-01010000b >> 8 = 00000000b
-01010001b >> 0 = 01010001b
-01010001b >> 1 = 00101000b
-01010001b >> 2 = 00010100b
-01010001b >> 3 = 00001010b
-01010001b >> 4 = 00000101b
-01010001b >> 5 = 00000010b
-01010001b >> 6 = 00000001b
-01010001b >> 7 = 00000000b
-01010001b >> 8 = 00000000b
-01010010b >> 0 = 01010010b
-01010010b >> 1 = 00101001b
-01010010b >> 2 = 00010100b
-01010010b >> 3 = 00001010b
-01010010b >> 4 = 00000101b
-01010010b >> 5 = 00000010b
-01010010b >> 6 = 00000001b
-01010010b >> 7 = 00000000b
-01010010b >> 8 = 00000000b
-01010011b >> 0 = 01010011b
-01010011b >> 1 = 00101001b
-01010011b >> 2 = 00010100b
-01010011b >> 3 = 00001010b
-01010011b >> 4 = 00000101b
-01010011b >> 5 = 00000010b
-01010011b >> 6 = 00000001b
-01010011b >> 7 = 00000000b
-01010011b >> 8 = 00000000b
-01010100b >> 0 = 01010100b
-01010100b >> 1 = 00101010b
-01010100b >> 2 = 00010101b
-01010100b >> 3 = 00001010b
-01010100b >> 4 = 00000101b
-01010100b >> 5 = 00000010b
-01010100b >> 6 = 00000001b
-01010100b >> 7 = 00000000b
-01010100b >> 8 = 00000000b
-01010101b >> 0 = 01010101b
-01010101b >> 1 = 00101010b
-01010101b >> 2 = 00010101b
-01010101b >> 3 = 00001010b
-01010101b >> 4 = 00000101b
-01010101b >> 5 = 00000010b
-01010101b >> 6 = 00000001b
-01010101b >> 7 = 00000000b
-01010101b >> 8 = 00000000b
-01010110b >> 0 = 01010110b
-01010110b >> 1 = 00101011b
-01010110b >> 2 = 00010101b
-01010110b >> 3 = 00001010b
-01010110b >> 4 = 00000101b
-01010110b >> 5 = 00000010b
-01010110b >> 6 = 00000001b
-01010110b >> 7 = 00000000b
-01010110b >> 8 = 00000000b
-01010111b >> 0 = 01010111b
-01010111b >> 1 = 00101011b
-01010111b >> 2 = 00010101b
-01010111b >> 3 = 00001010b
-01010111b >> 4 = 00000101b
-01010111b >> 5 = 00000010b
-01010111b >> 6 = 00000001b
-01010111b >> 7 = 00000000b
-01010111b >> 8 = 00000000b
-01011000b >> 0 = 01011000b
-01011000b >> 1 = 00101100b
-01011000b >> 2 = 00010110b
-01011000b >> 3 = 00001011b
-01011000b >> 4 = 00000101b
-01011000b >> 5 = 00000010b
-01011000b >> 6 = 00000001b
-01011000b >> 7 = 00000000b
-01011000b >> 8 = 00000000b
-01011001b >> 0 = 01011001b
-01011001b >> 1 = 00101100b
-01011001b >> 2 = 00010110b
-01011001b >> 3 = 00001011b
-01011001b >> 4 = 00000101b
-01011001b >> 5 = 00000010b
-01011001b >> 6 = 00000001b
-01011001b >> 7 = 00000000b
-01011001b >> 8 = 00000000b
-01011010b >> 0 = 01011010b
-01011010b >> 1 = 00101101b
-01011010b >> 2 = 00010110b
-01011010b >> 3 = 00001011b
-01011010b >> 4 = 00000101b
-01011010b >> 5 = 00000010b
-01011010b >> 6 = 00000001b
-01011010b >> 7 = 00000000b
-01011010b >> 8 = 00000000b
-01011011b >> 0 = 01011011b
-01011011b >> 1 = 00101101b
-01011011b >> 2 = 00010110b
-01011011b >> 3 = 00001011b
-01011011b >> 4 = 00000101b
-01011011b >> 5 = 00000010b
-01011011b >> 6 = 00000001b
-01011011b >> 7 = 00000000b
-01011011b >> 8 = 00000000b
-01011100b >> 0 = 01011100b
-01011100b >> 1 = 00101110b
-01011100b >> 2 = 00010111b
-01011100b >> 3 = 00001011b
-01011100b >> 4 = 00000101b
-01011100b >> 5 = 00000010b
-01011100b >> 6 = 00000001b
-01011100b >> 7 = 00000000b
-01011100b >> 8 = 00000000b
-01011101b >> 0 = 01011101b
-01011101b >> 1 = 00101110b
-01011101b >> 2 = 00010111b
-01011101b >> 3 = 00001011b
-01011101b >> 4 = 00000101b
-01011101b >> 5 = 00000010b
-01011101b >> 6 = 00000001b
-01011101b >> 7 = 00000000b
-01011101b >> 8 = 00000000b
-01011110b >> 0 = 01011110b
-01011110b >> 1 = 00101111b
-01011110b >> 2 = 00010111b
-01011110b >> 3 = 00001011b
-01011110b >> 4 = 00000101b
-01011110b >> 5 = 00000010b
-01011110b >> 6 = 00000001b
-01011110b >> 7 = 00000000b
-01011110b >> 8 = 00000000b
-01011111b >> 0 = 01011111b
-01011111b >> 1 = 00101111b
-01011111b >> 2 = 00010111b
-01011111b >> 3 = 00001011b
-01011111b >> 4 = 00000101b
-01011111b >> 5 = 00000010b
-01011111b >> 6 = 00000001b
-01011111b >> 7 = 00000000b
-01011111b >> 8 = 00000000b
-01100000b >> 0 = 01100000b
-01100000b >> 1 = 00110000b
-01100000b >> 2 = 00011000b
-01100000b >> 3 = 00001100b
-01100000b >> 4 = 00000110b
-01100000b >> 5 = 00000011b
-01100000b >> 6 = 00000001b
-01100000b >> 7 = 00000000b
-01100000b >> 8 = 00000000b
-01100001b >> 0 = 01100001b
-01100001b >> 1 = 00110000b
-01100001b >> 2 = 00011000b
-01100001b >> 3 = 00001100b
-01100001b >> 4 = 00000110b
-01100001b >> 5 = 00000011b
-01100001b >> 6 = 00000001b
-01100001b >> 7 = 00000000b
-01100001b >> 8 = 00000000b
-01100010b >> 0 = 01100010b
-01100010b >> 1 = 00110001b
-01100010b >> 2 = 00011000b
-01100010b >> 3 = 00001100b
-01100010b >> 4 = 00000110b
-01100010b >> 5 = 00000011b
-01100010b >> 6 = 00000001b
-01100010b >> 7 = 00000000b
-01100010b >> 8 = 00000000b
-01100011b >> 0 = 01100011b
-01100011b >> 1 = 00110001b
-01100011b >> 2 = 00011000b
-01100011b >> 3 = 00001100b
-01100011b >> 4 = 00000110b
-01100011b >> 5 = 00000011b
-01100011b >> 6 = 00000001b
-01100011b >> 7 = 00000000b
-01100011b >> 8 = 00000000b
-01100100b >> 0 = 01100100b
-01100100b >> 1 = 00110010b
-01100100b >> 2 = 00011001b
-01100100b >> 3 = 00001100b
-01100100b >> 4 = 00000110b
-01100100b >> 5 = 00000011b
-01100100b >> 6 = 00000001b
-01100100b >> 7 = 00000000b
-01100100b >> 8 = 00000000b
-01100101b >> 0 = 01100101b
-01100101b >> 1 = 00110010b
-01100101b >> 2 = 00011001b
-01100101b >> 3 = 00001100b
-01100101b >> 4 = 00000110b
-01100101b >> 5 = 00000011b
-01100101b >> 6 = 00000001b
-01100101b >> 7 = 00000000b
-01100101b >> 8 = 00000000b
-01100110b >> 0 = 01100110b
-01100110b >> 1 = 00110011b
-01100110b >> 2 = 00011001b
-01100110b >> 3 = 00001100b
-01100110b >> 4 = 00000110b
-01100110b >> 5 = 00000011b
-01100110b >> 6 = 00000001b
-01100110b >> 7 = 00000000b
-01100110b >> 8 = 00000000b
-01100111b >> 0 = 01100111b
-01100111b >> 1 = 00110011b
-01100111b >> 2 = 00011001b
-01100111b >> 3 = 00001100b
-01100111b >> 4 = 00000110b
-01100111b >> 5 = 00000011b
-01100111b >> 6 = 00000001b
-01100111b >> 7 = 00000000b
-01100111b >> 8 = 00000000b
-01101000b >> 0 = 01101000b
-01101000b >> 1 = 00110100b
-01101000b >> 2 = 00011010b
-01101000b >> 3 = 00001101b
-01101000b >> 4 = 00000110b
-01101000b >> 5 = 00000011b
-01101000b >> 6 = 00000001b
-01101000b >> 7 = 00000000b
-01101000b >> 8 = 00000000b
-01101001b >> 0 = 01101001b
-01101001b >> 1 = 00110100b
-01101001b >> 2 = 00011010b
-01101001b >> 3 = 00001101b
-01101001b >> 4 = 00000110b
-01101001b >> 5 = 00000011b
-01101001b >> 6 = 00000001b
-01101001b >> 7 = 00000000b
-01101001b >> 8 = 00000000b
-01101010b >> 0 = 01101010b
-01101010b >> 1 = 00110101b
-01101010b >> 2 = 00011010b
-01101010b >> 3 = 00001101b
-01101010b >> 4 = 00000110b
-01101010b >> 5 = 00000011b
-01101010b >> 6 = 00000001b
-01101010b >> 7 = 00000000b
-01101010b >> 8 = 00000000b
-01101011b >> 0 = 01101011b
-01101011b >> 1 = 00110101b
-01101011b >> 2 = 00011010b
-01101011b >> 3 = 00001101b
-01101011b >> 4 = 00000110b
-01101011b >> 5 = 00000011b
-01101011b >> 6 = 00000001b
-01101011b >> 7 = 00000000b
-01101011b >> 8 = 00000000b
-01101100b >> 0 = 01101100b
-01101100b >> 1 = 00110110b
-01101100b >> 2 = 00011011b
-01101100b >> 3 = 00001101b
-01101100b >> 4 = 00000110b
-01101100b >> 5 = 00000011b
-01101100b >> 6 = 00000001b
-01101100b >> 7 = 00000000b
-01101100b >> 8 = 00000000b
-01101101b >> 0 = 01101101b
-01101101b >> 1 = 00110110b
-01101101b >> 2 = 00011011b
-01101101b >> 3 = 00001101b
-01101101b >> 4 = 00000110b
-01101101b >> 5 = 00000011b
-01101101b >> 6 = 00000001b
-01101101b >> 7 = 00000000b
-01101101b >> 8 = 00000000b
-01101110b >> 0 = 01101110b
-01101110b >> 1 = 00110111b
-01101110b >> 2 = 00011011b
-01101110b >> 3 = 00001101b
-01101110b >> 4 = 00000110b
-01101110b >> 5 = 00000011b
-01101110b >> 6 = 00000001b
-01101110b >> 7 = 00000000b
-01101110b >> 8 = 00000000b
-01101111b >> 0 = 01101111b
-01101111b >> 1 = 00110111b
-01101111b >> 2 = 00011011b
-01101111b >> 3 = 00001101b
-01101111b >> 4 = 00000110b
-01101111b >> 5 = 00000011b
-01101111b >> 6 = 00000001b
-01101111b >> 7 = 00000000b
-01101111b >> 8 = 00000000b
-01110000b >> 0 = 01110000b
-01110000b >> 1 = 00111000b
-01110000b >> 2 = 00011100b
-01110000b >> 3 = 00001110b
-01110000b >> 4 = 00000111b
-01110000b >> 5 = 00000011b
-01110000b >> 6 = 00000001b
-01110000b >> 7 = 00000000b
-01110000b >> 8 = 00000000b
-01110001b >> 0 = 01110001b
-01110001b >> 1 = 00111000b
-01110001b >> 2 = 00011100b
-01110001b >> 3 = 00001110b
-01110001b >> 4 = 00000111b
-01110001b >> 5 = 00000011b
-01110001b >> 6 = 00000001b
-01110001b >> 7 = 00000000b
-01110001b >> 8 = 00000000b
-01110010b >> 0 = 01110010b
-01110010b >> 1 = 00111001b
-01110010b >> 2 = 00011100b
-01110010b >> 3 = 00001110b
-01110010b >> 4 = 00000111b
-01110010b >> 5 = 00000011b
-01110010b >> 6 = 00000001b
-01110010b >> 7 = 00000000b
-01110010b >> 8 = 00000000b
-01110011b >> 0 = 01110011b
-01110011b >> 1 = 00111001b
-01110011b >> 2 = 00011100b
-01110011b >> 3 = 00001110b
-01110011b >> 4 = 00000111b
-01110011b >> 5 = 00000011b
-01110011b >> 6 = 00000001b
-01110011b >> 7 = 00000000b
-01110011b >> 8 = 00000000b
-01110100b >> 0 = 01110100b
-01110100b >> 1 = 00111010b
-01110100b >> 2 = 00011101b
-01110100b >> 3 = 00001110b
-01110100b >> 4 = 00000111b
-01110100b >> 5 = 00000011b
-01110100b >> 6 = 00000001b
-01110100b >> 7 = 00000000b
-01110100b >> 8 = 00000000b
-01110101b >> 0 = 01110101b
-01110101b >> 1 = 00111010b
-01110101b >> 2 = 00011101b
-01110101b >> 3 = 00001110b
-01110101b >> 4 = 00000111b
-01110101b >> 5 = 00000011b
-01110101b >> 6 = 00000001b
-01110101b >> 7 = 00000000b
-01110101b >> 8 = 00000000b
-01110110b >> 0 = 01110110b
-01110110b >> 1 = 00111011b
-01110110b >> 2 = 00011101b
-01110110b >> 3 = 00001110b
-01110110b >> 4 = 00000111b
-01110110b >> 5 = 00000011b
-01110110b >> 6 = 00000001b
-01110110b >> 7 = 00000000b
-01110110b >> 8 = 00000000b
-01110111b >> 0 = 01110111b
-01110111b >> 1 = 00111011b
-01110111b >> 2 = 00011101b
-01110111b >> 3 = 00001110b
-01110111b >> 4 = 00000111b
-01110111b >> 5 = 00000011b
-01110111b >> 6 = 00000001b
-01110111b >> 7 = 00000000b
-01110111b >> 8 = 00000000b
-01111000b >> 0 = 01111000b
-01111000b >> 1 = 00111100b
-01111000b >> 2 = 00011110b
-01111000b >> 3 = 00001111b
-01111000b >> 4 = 00000111b
-01111000b >> 5 = 00000011b
-01111000b >> 6 = 00000001b
-01111000b >> 7 = 00000000b
-01111000b >> 8 = 00000000b
-01111001b >> 0 = 01111001b
-01111001b >> 1 = 00111100b
-01111001b >> 2 = 00011110b
-01111001b >> 3 = 00001111b
-01111001b >> 4 = 00000111b
-01111001b >> 5 = 00000011b
-01111001b >> 6 = 00000001b
-01111001b >> 7 = 00000000b
-01111001b >> 8 = 00000000b
-01111010b >> 0 = 01111010b
-01111010b >> 1 = 00111101b
-01111010b >> 2 = 00011110b
-01111010b >> 3 = 00001111b
-01111010b >> 4 = 00000111b
-01111010b >> 5 = 00000011b
-01111010b >> 6 = 00000001b
-01111010b >> 7 = 00000000b
-01111010b >> 8 = 00000000b
-01111011b >> 0 = 01111011b
-01111011b >> 1 = 00111101b
-01111011b >> 2 = 00011110b
-01111011b >> 3 = 00001111b
-01111011b >> 4 = 00000111b
-01111011b >> 5 = 00000011b
-01111011b >> 6 = 00000001b
-01111011b >> 7 = 00000000b
-01111011b >> 8 = 00000000b
-01111100b >> 0 = 01111100b
-01111100b >> 1 = 00111110b
-01111100b >> 2 = 00011111b
-01111100b >> 3 = 00001111b
-01111100b >> 4 = 00000111b
-01111100b >> 5 = 00000011b
-01111100b >> 6 = 00000001b
-01111100b >> 7 = 00000000b
-01111100b >> 8 = 00000000b
-01111101b >> 0 = 01111101b
-01111101b >> 1 = 00111110b
-01111101b >> 2 = 00011111b
-01111101b >> 3 = 00001111b
-01111101b >> 4 = 00000111b
-01111101b >> 5 = 00000011b
-01111101b >> 6 = 00000001b
-01111101b >> 7 = 00000000b
-01111101b >> 8 = 00000000b
-01111110b >> 0 = 01111110b
-01111110b >> 1 = 00111111b
-01111110b >> 2 = 00011111b
-01111110b >> 3 = 00001111b
-01111110b >> 4 = 00000111b
-01111110b >> 5 = 00000011b
-01111110b >> 6 = 00000001b
-01111110b >> 7 = 00000000b
-01111110b >> 8 = 00000000b
diff --git a/tests/valid/Byte_Valid_6.whiley b/tests/valid/Byte_Valid_6.whiley
index 0e6d728f80..f1808d6fe7 100644
--- a/tests/valid/Byte_Valid_6.whiley
+++ b/tests/valid/Byte_Valid_6.whiley
@@ -1,11 +1,20 @@
-import whiley.lang.*
-import print from whiley.lang.*
+
constant constants is [10000000b, 10000001b, 10000010b, 10000011b, 10000100b, 10000101b, 10000110b, 10000111b, 10001000b, 10001001b, 10001010b, 10001011b, 10001100b, 10001101b, 10001110b, 10001111b, 10010000b, 10010001b, 10010010b, 10010011b, 10010100b, 10010101b, 10010110b, 10010111b, 10011000b, 10011001b, 10011010b, 10011011b, 10011100b, 10011101b, 10011110b, 10011111b, 10100000b, 10100001b, 10100010b, 10100011b, 10100100b, 10100101b, 10100110b, 10100111b, 10101000b, 10101001b, 10101010b, 10101011b, 10101100b, 10101101b, 10101110b, 10101111b, 10110000b, 10110001b, 10110010b, 10110011b, 10110100b, 10110101b, 10110110b, 10110111b, 10111000b, 10111001b, 10111010b, 10111011b, 10111100b, 10111101b, 10111110b, 10111111b, 11000000b, 11000001b, 11000010b, 11000011b, 11000100b, 11000101b, 11000110b, 11000111b, 11001000b, 11001001b, 11001010b, 11001011b, 11001100b, 11001101b, 11001110b, 11001111b, 11010000b, 11010001b, 11010010b, 11010011b, 11010100b, 11010101b, 11010110b, 11010111b, 11011000b, 11011001b, 11011010b, 11011011b, 11011100b, 11011101b, 11011110b, 11011111b, 11100000b, 11100001b, 11100010b, 11100011b, 11100100b, 11100101b, 11100110b, 11100111b, 11101000b, 11101001b, 11101010b, 11101011b, 11101100b, 11101101b, 11101110b, 11101111b, 11110000b, 11110001b, 11110010b, 11110011b, 11110100b, 11110101b, 11110110b, 11110111b, 11111000b, 11111001b, 11111010b, 11111011b, 11111100b, 11111101b, 11111110b, 11111111b, 00000000b, 00000001b, 00000010b, 00000011b, 00000100b, 00000101b, 00000110b, 00000111b, 00001000b, 00001001b, 00001010b, 00001011b, 00001100b, 00001101b, 00001110b, 00001111b, 00010000b, 00010001b, 00010010b, 00010011b, 00010100b, 00010101b, 00010110b, 00010111b, 00011000b, 00011001b, 00011010b, 00011011b, 00011100b, 00011101b, 00011110b, 00011111b, 00100000b, 00100001b, 00100010b, 00100011b, 00100100b, 00100101b, 00100110b, 00100111b, 00101000b, 00101001b, 00101010b, 00101011b, 00101100b, 00101101b, 00101110b, 00101111b, 00110000b, 00110001b, 00110010b, 00110011b, 00110100b, 00110101b, 00110110b, 00110111b, 00111000b, 00111001b, 00111010b, 00111011b, 00111100b, 00111101b, 00111110b, 00111111b, 01000000b, 01000001b, 01000010b, 01000011b, 01000100b, 01000101b, 01000110b, 01000111b, 01001000b, 01001001b, 01001010b, 01001011b, 01001100b, 01001101b, 01001110b, 01001111b, 01010000b, 01010001b, 01010010b, 01010011b, 01010100b, 01010101b, 01010110b, 01010111b, 01011000b, 01011001b, 01011010b, 01011011b, 01011100b, 01011101b, 01011110b, 01011111b, 01100000b, 01100001b, 01100010b, 01100011b, 01100100b, 01100101b, 01100110b, 01100111b, 01101000b, 01101001b, 01101010b, 01101011b, 01101100b, 01101101b, 01101110b, 01101111b, 01110000b, 01110001b, 01110010b, 01110011b, 01110100b, 01110101b, 01110110b, 01110111b, 01111000b, 01111001b, 01111010b, 01111011b, 01111100b, 01111101b, 01111110b]
-public method main(System.Console sys) -> void:
- for i in constants:
- for j in 0 .. 9:
- sys.out.print_s(Any.toString(i) ++ " >> ")
- sys.out.print_s(Any.toString(j) ++ " = ")
- sys.out.println_s(Any.toString(i >> j))
+function shl(byte b, int i) -> byte:
+ while i > 0:
+ b = b >> 1
+ i = i - 1
+ return b
+
+public export method test() -> void:
+ int i = 0
+ while i < |constants|:
+ byte constant_i = constants[i]
+ int j = 0
+ while j < 9:
+ assume (constant_i >> j) == shl(constant_i,j)
+ j = j + 1
+ //
+ i = i + 1
diff --git a/tests/valid/Byte_Valid_7.sysout b/tests/valid/Byte_Valid_7.sysout
deleted file mode 100644
index efef621a6f..0000000000
--- a/tests/valid/Byte_Valid_7.sysout
+++ /dev/null
@@ -1,255 +0,0 @@
-~10000000b = 01111111b
-~10000001b = 01111110b
-~10000010b = 01111101b
-~10000011b = 01111100b
-~10000100b = 01111011b
-~10000101b = 01111010b
-~10000110b = 01111001b
-~10000111b = 01111000b
-~10001000b = 01110111b
-~10001001b = 01110110b
-~10001010b = 01110101b
-~10001011b = 01110100b
-~10001100b = 01110011b
-~10001101b = 01110010b
-~10001110b = 01110001b
-~10001111b = 01110000b
-~10010000b = 01101111b
-~10010001b = 01101110b
-~10010010b = 01101101b
-~10010011b = 01101100b
-~10010100b = 01101011b
-~10010101b = 01101010b
-~10010110b = 01101001b
-~10010111b = 01101000b
-~10011000b = 01100111b
-~10011001b = 01100110b
-~10011010b = 01100101b
-~10011011b = 01100100b
-~10011100b = 01100011b
-~10011101b = 01100010b
-~10011110b = 01100001b
-~10011111b = 01100000b
-~10100000b = 01011111b
-~10100001b = 01011110b
-~10100010b = 01011101b
-~10100011b = 01011100b
-~10100100b = 01011011b
-~10100101b = 01011010b
-~10100110b = 01011001b
-~10100111b = 01011000b
-~10101000b = 01010111b
-~10101001b = 01010110b
-~10101010b = 01010101b
-~10101011b = 01010100b
-~10101100b = 01010011b
-~10101101b = 01010010b
-~10101110b = 01010001b
-~10101111b = 01010000b
-~10110000b = 01001111b
-~10110001b = 01001110b
-~10110010b = 01001101b
-~10110011b = 01001100b
-~10110100b = 01001011b
-~10110101b = 01001010b
-~10110110b = 01001001b
-~10110111b = 01001000b
-~10111000b = 01000111b
-~10111001b = 01000110b
-~10111010b = 01000101b
-~10111011b = 01000100b
-~10111100b = 01000011b
-~10111101b = 01000010b
-~10111110b = 01000001b
-~10111111b = 01000000b
-~11000000b = 00111111b
-~11000001b = 00111110b
-~11000010b = 00111101b
-~11000011b = 00111100b
-~11000100b = 00111011b
-~11000101b = 00111010b
-~11000110b = 00111001b
-~11000111b = 00111000b
-~11001000b = 00110111b
-~11001001b = 00110110b
-~11001010b = 00110101b
-~11001011b = 00110100b
-~11001100b = 00110011b
-~11001101b = 00110010b
-~11001110b = 00110001b
-~11001111b = 00110000b
-~11010000b = 00101111b
-~11010001b = 00101110b
-~11010010b = 00101101b
-~11010011b = 00101100b
-~11010100b = 00101011b
-~11010101b = 00101010b
-~11010110b = 00101001b
-~11010111b = 00101000b
-~11011000b = 00100111b
-~11011001b = 00100110b
-~11011010b = 00100101b
-~11011011b = 00100100b
-~11011100b = 00100011b
-~11011101b = 00100010b
-~11011110b = 00100001b
-~11011111b = 00100000b
-~11100000b = 00011111b
-~11100001b = 00011110b
-~11100010b = 00011101b
-~11100011b = 00011100b
-~11100100b = 00011011b
-~11100101b = 00011010b
-~11100110b = 00011001b
-~11100111b = 00011000b
-~11101000b = 00010111b
-~11101001b = 00010110b
-~11101010b = 00010101b
-~11101011b = 00010100b
-~11101100b = 00010011b
-~11101101b = 00010010b
-~11101110b = 00010001b
-~11101111b = 00010000b
-~11110000b = 00001111b
-~11110001b = 00001110b
-~11110010b = 00001101b
-~11110011b = 00001100b
-~11110100b = 00001011b
-~11110101b = 00001010b
-~11110110b = 00001001b
-~11110111b = 00001000b
-~11111000b = 00000111b
-~11111001b = 00000110b
-~11111010b = 00000101b
-~11111011b = 00000100b
-~11111100b = 00000011b
-~11111101b = 00000010b
-~11111110b = 00000001b
-~11111111b = 00000000b
-~00000000b = 11111111b
-~00000001b = 11111110b
-~00000010b = 11111101b
-~00000011b = 11111100b
-~00000100b = 11111011b
-~00000101b = 11111010b
-~00000110b = 11111001b
-~00000111b = 11111000b
-~00001000b = 11110111b
-~00001001b = 11110110b
-~00001010b = 11110101b
-~00001011b = 11110100b
-~00001100b = 11110011b
-~00001101b = 11110010b
-~00001110b = 11110001b
-~00001111b = 11110000b
-~00010000b = 11101111b
-~00010001b = 11101110b
-~00010010b = 11101101b
-~00010011b = 11101100b
-~00010100b = 11101011b
-~00010101b = 11101010b
-~00010110b = 11101001b
-~00010111b = 11101000b
-~00011000b = 11100111b
-~00011001b = 11100110b
-~00011010b = 11100101b
-~00011011b = 11100100b
-~00011100b = 11100011b
-~00011101b = 11100010b
-~00011110b = 11100001b
-~00011111b = 11100000b
-~00100000b = 11011111b
-~00100001b = 11011110b
-~00100010b = 11011101b
-~00100011b = 11011100b
-~00100100b = 11011011b
-~00100101b = 11011010b
-~00100110b = 11011001b
-~00100111b = 11011000b
-~00101000b = 11010111b
-~00101001b = 11010110b
-~00101010b = 11010101b
-~00101011b = 11010100b
-~00101100b = 11010011b
-~00101101b = 11010010b
-~00101110b = 11010001b
-~00101111b = 11010000b
-~00110000b = 11001111b
-~00110001b = 11001110b
-~00110010b = 11001101b
-~00110011b = 11001100b
-~00110100b = 11001011b
-~00110101b = 11001010b
-~00110110b = 11001001b
-~00110111b = 11001000b
-~00111000b = 11000111b
-~00111001b = 11000110b
-~00111010b = 11000101b
-~00111011b = 11000100b
-~00111100b = 11000011b
-~00111101b = 11000010b
-~00111110b = 11000001b
-~00111111b = 11000000b
-~01000000b = 10111111b
-~01000001b = 10111110b
-~01000010b = 10111101b
-~01000011b = 10111100b
-~01000100b = 10111011b
-~01000101b = 10111010b
-~01000110b = 10111001b
-~01000111b = 10111000b
-~01001000b = 10110111b
-~01001001b = 10110110b
-~01001010b = 10110101b
-~01001011b = 10110100b
-~01001100b = 10110011b
-~01001101b = 10110010b
-~01001110b = 10110001b
-~01001111b = 10110000b
-~01010000b = 10101111b
-~01010001b = 10101110b
-~01010010b = 10101101b
-~01010011b = 10101100b
-~01010100b = 10101011b
-~01010101b = 10101010b
-~01010110b = 10101001b
-~01010111b = 10101000b
-~01011000b = 10100111b
-~01011001b = 10100110b
-~01011010b = 10100101b
-~01011011b = 10100100b
-~01011100b = 10100011b
-~01011101b = 10100010b
-~01011110b = 10100001b
-~01011111b = 10100000b
-~01100000b = 10011111b
-~01100001b = 10011110b
-~01100010b = 10011101b
-~01100011b = 10011100b
-~01100100b = 10011011b
-~01100101b = 10011010b
-~01100110b = 10011001b
-~01100111b = 10011000b
-~01101000b = 10010111b
-~01101001b = 10010110b
-~01101010b = 10010101b
-~01101011b = 10010100b
-~01101100b = 10010011b
-~01101101b = 10010010b
-~01101110b = 10010001b
-~01101111b = 10010000b
-~01110000b = 10001111b
-~01110001b = 10001110b
-~01110010b = 10001101b
-~01110011b = 10001100b
-~01110100b = 10001011b
-~01110101b = 10001010b
-~01110110b = 10001001b
-~01110111b = 10001000b
-~01111000b = 10000111b
-~01111001b = 10000110b
-~01111010b = 10000101b
-~01111011b = 10000100b
-~01111100b = 10000011b
-~01111101b = 10000010b
-~01111110b = 10000001b
diff --git a/tests/valid/Byte_Valid_7.whiley b/tests/valid/Byte_Valid_7.whiley
index 5703c8e942..94690f8d4c 100644
--- a/tests/valid/Byte_Valid_7.whiley
+++ b/tests/valid/Byte_Valid_7.whiley
@@ -1,10 +1,27 @@
-import whiley.lang.*
-import print from whiley.lang.*
+
constant constants is [10000000b, 10000001b, 10000010b, 10000011b, 10000100b, 10000101b, 10000110b, 10000111b, 10001000b, 10001001b, 10001010b, 10001011b, 10001100b, 10001101b, 10001110b, 10001111b, 10010000b, 10010001b, 10010010b, 10010011b, 10010100b, 10010101b, 10010110b, 10010111b, 10011000b, 10011001b, 10011010b, 10011011b, 10011100b, 10011101b, 10011110b, 10011111b, 10100000b, 10100001b, 10100010b, 10100011b, 10100100b, 10100101b, 10100110b, 10100111b, 10101000b, 10101001b, 10101010b, 10101011b, 10101100b, 10101101b, 10101110b, 10101111b, 10110000b, 10110001b, 10110010b, 10110011b, 10110100b, 10110101b, 10110110b, 10110111b, 10111000b, 10111001b, 10111010b, 10111011b, 10111100b, 10111101b, 10111110b, 10111111b, 11000000b, 11000001b, 11000010b, 11000011b, 11000100b, 11000101b, 11000110b, 11000111b, 11001000b, 11001001b, 11001010b, 11001011b, 11001100b, 11001101b, 11001110b, 11001111b, 11010000b, 11010001b, 11010010b, 11010011b, 11010100b, 11010101b, 11010110b, 11010111b, 11011000b, 11011001b, 11011010b, 11011011b, 11011100b, 11011101b, 11011110b, 11011111b, 11100000b, 11100001b, 11100010b, 11100011b, 11100100b, 11100101b, 11100110b, 11100111b, 11101000b, 11101001b, 11101010b, 11101011b, 11101100b, 11101101b, 11101110b, 11101111b, 11110000b, 11110001b, 11110010b, 11110011b, 11110100b, 11110101b, 11110110b, 11110111b, 11111000b, 11111001b, 11111010b, 11111011b, 11111100b, 11111101b, 11111110b, 11111111b, 00000000b, 00000001b, 00000010b, 00000011b, 00000100b, 00000101b, 00000110b, 00000111b, 00001000b, 00001001b, 00001010b, 00001011b, 00001100b, 00001101b, 00001110b, 00001111b, 00010000b, 00010001b, 00010010b, 00010011b, 00010100b, 00010101b, 00010110b, 00010111b, 00011000b, 00011001b, 00011010b, 00011011b, 00011100b, 00011101b, 00011110b, 00011111b, 00100000b, 00100001b, 00100010b, 00100011b, 00100100b, 00100101b, 00100110b, 00100111b, 00101000b, 00101001b, 00101010b, 00101011b, 00101100b, 00101101b, 00101110b, 00101111b, 00110000b, 00110001b, 00110010b, 00110011b, 00110100b, 00110101b, 00110110b, 00110111b, 00111000b, 00111001b, 00111010b, 00111011b, 00111100b, 00111101b, 00111110b, 00111111b, 01000000b, 01000001b, 01000010b, 01000011b, 01000100b, 01000101b, 01000110b, 01000111b, 01001000b, 01001001b, 01001010b, 01001011b, 01001100b, 01001101b, 01001110b, 01001111b, 01010000b, 01010001b, 01010010b, 01010011b, 01010100b, 01010101b, 01010110b, 01010111b, 01011000b, 01011001b, 01011010b, 01011011b, 01011100b, 01011101b, 01011110b, 01011111b, 01100000b, 01100001b, 01100010b, 01100011b, 01100100b, 01100101b, 01100110b, 01100111b, 01101000b, 01101001b, 01101010b, 01101011b, 01101100b, 01101101b, 01101110b, 01101111b, 01110000b, 01110001b, 01110010b, 01110011b, 01110100b, 01110101b, 01110110b, 01110111b, 01111000b, 01111001b, 01111010b, 01111011b, 01111100b, 01111101b, 01111110b]
-public method main(System.Console sys) -> void:
- for i in constants:
- sys.out.print_s("~" ++ Any.toString(i))
- sys.out.print_s(" = ")
- sys.out.println_s(Any.toString(~i))
+function set(byte b, int i) -> bool:
+ byte mask = 1b << i
+ return (b&mask) == mask
+
+function invert(byte b) -> byte:
+ byte mask = 1b
+ byte r = 0b
+ int i = 0
+ while i < 8:
+ if !set(b,i):
+ r = r | mask
+ mask = mask << 1
+ i = i + 1
+ //
+ return r
+
+public export method test() -> void:
+ int i = 0
+ while i < |constants|:
+ byte constant_i = constants[i]
+ assume (~constant_i) == invert(constant_i)
+ i = i + 1
+ //
diff --git a/tests/valid/Byte_Valid_8.sysout b/tests/valid/Byte_Valid_8.sysout
deleted file mode 100644
index 4ccc875567..0000000000
--- a/tests/valid/Byte_Valid_8.sysout
+++ /dev/null
@@ -1,2040 +0,0 @@
-10000000b << 1+0 = 00000000b
-10000000b << 1+1 = 00000000b
-10000000b << 1+2 = 00000000b
-10000000b << 1+3 = 00000000b
-10000000b << 1+4 = 00000000b
-10000000b << 1+5 = 00000000b
-10000000b << 1+6 = 00000000b
-10000000b << 1+7 = 00000000b
-10000001b << 1+0 = 00000010b
-10000001b << 1+1 = 00000100b
-10000001b << 1+2 = 00001000b
-10000001b << 1+3 = 00010000b
-10000001b << 1+4 = 00100000b
-10000001b << 1+5 = 01000000b
-10000001b << 1+6 = 10000000b
-10000001b << 1+7 = 00000000b
-10000010b << 1+0 = 00000100b
-10000010b << 1+1 = 00001000b
-10000010b << 1+2 = 00010000b
-10000010b << 1+3 = 00100000b
-10000010b << 1+4 = 01000000b
-10000010b << 1+5 = 10000000b
-10000010b << 1+6 = 00000000b
-10000010b << 1+7 = 00000000b
-10000011b << 1+0 = 00000110b
-10000011b << 1+1 = 00001100b
-10000011b << 1+2 = 00011000b
-10000011b << 1+3 = 00110000b
-10000011b << 1+4 = 01100000b
-10000011b << 1+5 = 11000000b
-10000011b << 1+6 = 10000000b
-10000011b << 1+7 = 00000000b
-10000100b << 1+0 = 00001000b
-10000100b << 1+1 = 00010000b
-10000100b << 1+2 = 00100000b
-10000100b << 1+3 = 01000000b
-10000100b << 1+4 = 10000000b
-10000100b << 1+5 = 00000000b
-10000100b << 1+6 = 00000000b
-10000100b << 1+7 = 00000000b
-10000101b << 1+0 = 00001010b
-10000101b << 1+1 = 00010100b
-10000101b << 1+2 = 00101000b
-10000101b << 1+3 = 01010000b
-10000101b << 1+4 = 10100000b
-10000101b << 1+5 = 01000000b
-10000101b << 1+6 = 10000000b
-10000101b << 1+7 = 00000000b
-10000110b << 1+0 = 00001100b
-10000110b << 1+1 = 00011000b
-10000110b << 1+2 = 00110000b
-10000110b << 1+3 = 01100000b
-10000110b << 1+4 = 11000000b
-10000110b << 1+5 = 10000000b
-10000110b << 1+6 = 00000000b
-10000110b << 1+7 = 00000000b
-10000111b << 1+0 = 00001110b
-10000111b << 1+1 = 00011100b
-10000111b << 1+2 = 00111000b
-10000111b << 1+3 = 01110000b
-10000111b << 1+4 = 11100000b
-10000111b << 1+5 = 11000000b
-10000111b << 1+6 = 10000000b
-10000111b << 1+7 = 00000000b
-10001000b << 1+0 = 00010000b
-10001000b << 1+1 = 00100000b
-10001000b << 1+2 = 01000000b
-10001000b << 1+3 = 10000000b
-10001000b << 1+4 = 00000000b
-10001000b << 1+5 = 00000000b
-10001000b << 1+6 = 00000000b
-10001000b << 1+7 = 00000000b
-10001001b << 1+0 = 00010010b
-10001001b << 1+1 = 00100100b
-10001001b << 1+2 = 01001000b
-10001001b << 1+3 = 10010000b
-10001001b << 1+4 = 00100000b
-10001001b << 1+5 = 01000000b
-10001001b << 1+6 = 10000000b
-10001001b << 1+7 = 00000000b
-10001010b << 1+0 = 00010100b
-10001010b << 1+1 = 00101000b
-10001010b << 1+2 = 01010000b
-10001010b << 1+3 = 10100000b
-10001010b << 1+4 = 01000000b
-10001010b << 1+5 = 10000000b
-10001010b << 1+6 = 00000000b
-10001010b << 1+7 = 00000000b
-10001011b << 1+0 = 00010110b
-10001011b << 1+1 = 00101100b
-10001011b << 1+2 = 01011000b
-10001011b << 1+3 = 10110000b
-10001011b << 1+4 = 01100000b
-10001011b << 1+5 = 11000000b
-10001011b << 1+6 = 10000000b
-10001011b << 1+7 = 00000000b
-10001100b << 1+0 = 00011000b
-10001100b << 1+1 = 00110000b
-10001100b << 1+2 = 01100000b
-10001100b << 1+3 = 11000000b
-10001100b << 1+4 = 10000000b
-10001100b << 1+5 = 00000000b
-10001100b << 1+6 = 00000000b
-10001100b << 1+7 = 00000000b
-10001101b << 1+0 = 00011010b
-10001101b << 1+1 = 00110100b
-10001101b << 1+2 = 01101000b
-10001101b << 1+3 = 11010000b
-10001101b << 1+4 = 10100000b
-10001101b << 1+5 = 01000000b
-10001101b << 1+6 = 10000000b
-10001101b << 1+7 = 00000000b
-10001110b << 1+0 = 00011100b
-10001110b << 1+1 = 00111000b
-10001110b << 1+2 = 01110000b
-10001110b << 1+3 = 11100000b
-10001110b << 1+4 = 11000000b
-10001110b << 1+5 = 10000000b
-10001110b << 1+6 = 00000000b
-10001110b << 1+7 = 00000000b
-10001111b << 1+0 = 00011110b
-10001111b << 1+1 = 00111100b
-10001111b << 1+2 = 01111000b
-10001111b << 1+3 = 11110000b
-10001111b << 1+4 = 11100000b
-10001111b << 1+5 = 11000000b
-10001111b << 1+6 = 10000000b
-10001111b << 1+7 = 00000000b
-10010000b << 1+0 = 00100000b
-10010000b << 1+1 = 01000000b
-10010000b << 1+2 = 10000000b
-10010000b << 1+3 = 00000000b
-10010000b << 1+4 = 00000000b
-10010000b << 1+5 = 00000000b
-10010000b << 1+6 = 00000000b
-10010000b << 1+7 = 00000000b
-10010001b << 1+0 = 00100010b
-10010001b << 1+1 = 01000100b
-10010001b << 1+2 = 10001000b
-10010001b << 1+3 = 00010000b
-10010001b << 1+4 = 00100000b
-10010001b << 1+5 = 01000000b
-10010001b << 1+6 = 10000000b
-10010001b << 1+7 = 00000000b
-10010010b << 1+0 = 00100100b
-10010010b << 1+1 = 01001000b
-10010010b << 1+2 = 10010000b
-10010010b << 1+3 = 00100000b
-10010010b << 1+4 = 01000000b
-10010010b << 1+5 = 10000000b
-10010010b << 1+6 = 00000000b
-10010010b << 1+7 = 00000000b
-10010011b << 1+0 = 00100110b
-10010011b << 1+1 = 01001100b
-10010011b << 1+2 = 10011000b
-10010011b << 1+3 = 00110000b
-10010011b << 1+4 = 01100000b
-10010011b << 1+5 = 11000000b
-10010011b << 1+6 = 10000000b
-10010011b << 1+7 = 00000000b
-10010100b << 1+0 = 00101000b
-10010100b << 1+1 = 01010000b
-10010100b << 1+2 = 10100000b
-10010100b << 1+3 = 01000000b
-10010100b << 1+4 = 10000000b
-10010100b << 1+5 = 00000000b
-10010100b << 1+6 = 00000000b
-10010100b << 1+7 = 00000000b
-10010101b << 1+0 = 00101010b
-10010101b << 1+1 = 01010100b
-10010101b << 1+2 = 10101000b
-10010101b << 1+3 = 01010000b
-10010101b << 1+4 = 10100000b
-10010101b << 1+5 = 01000000b
-10010101b << 1+6 = 10000000b
-10010101b << 1+7 = 00000000b
-10010110b << 1+0 = 00101100b
-10010110b << 1+1 = 01011000b
-10010110b << 1+2 = 10110000b
-10010110b << 1+3 = 01100000b
-10010110b << 1+4 = 11000000b
-10010110b << 1+5 = 10000000b
-10010110b << 1+6 = 00000000b
-10010110b << 1+7 = 00000000b
-10010111b << 1+0 = 00101110b
-10010111b << 1+1 = 01011100b
-10010111b << 1+2 = 10111000b
-10010111b << 1+3 = 01110000b
-10010111b << 1+4 = 11100000b
-10010111b << 1+5 = 11000000b
-10010111b << 1+6 = 10000000b
-10010111b << 1+7 = 00000000b
-10011000b << 1+0 = 00110000b
-10011000b << 1+1 = 01100000b
-10011000b << 1+2 = 11000000b
-10011000b << 1+3 = 10000000b
-10011000b << 1+4 = 00000000b
-10011000b << 1+5 = 00000000b
-10011000b << 1+6 = 00000000b
-10011000b << 1+7 = 00000000b
-10011001b << 1+0 = 00110010b
-10011001b << 1+1 = 01100100b
-10011001b << 1+2 = 11001000b
-10011001b << 1+3 = 10010000b
-10011001b << 1+4 = 00100000b
-10011001b << 1+5 = 01000000b
-10011001b << 1+6 = 10000000b
-10011001b << 1+7 = 00000000b
-10011010b << 1+0 = 00110100b
-10011010b << 1+1 = 01101000b
-10011010b << 1+2 = 11010000b
-10011010b << 1+3 = 10100000b
-10011010b << 1+4 = 01000000b
-10011010b << 1+5 = 10000000b
-10011010b << 1+6 = 00000000b
-10011010b << 1+7 = 00000000b
-10011011b << 1+0 = 00110110b
-10011011b << 1+1 = 01101100b
-10011011b << 1+2 = 11011000b
-10011011b << 1+3 = 10110000b
-10011011b << 1+4 = 01100000b
-10011011b << 1+5 = 11000000b
-10011011b << 1+6 = 10000000b
-10011011b << 1+7 = 00000000b
-10011100b << 1+0 = 00111000b
-10011100b << 1+1 = 01110000b
-10011100b << 1+2 = 11100000b
-10011100b << 1+3 = 11000000b
-10011100b << 1+4 = 10000000b
-10011100b << 1+5 = 00000000b
-10011100b << 1+6 = 00000000b
-10011100b << 1+7 = 00000000b
-10011101b << 1+0 = 00111010b
-10011101b << 1+1 = 01110100b
-10011101b << 1+2 = 11101000b
-10011101b << 1+3 = 11010000b
-10011101b << 1+4 = 10100000b
-10011101b << 1+5 = 01000000b
-10011101b << 1+6 = 10000000b
-10011101b << 1+7 = 00000000b
-10011110b << 1+0 = 00111100b
-10011110b << 1+1 = 01111000b
-10011110b << 1+2 = 11110000b
-10011110b << 1+3 = 11100000b
-10011110b << 1+4 = 11000000b
-10011110b << 1+5 = 10000000b
-10011110b << 1+6 = 00000000b
-10011110b << 1+7 = 00000000b
-10011111b << 1+0 = 00111110b
-10011111b << 1+1 = 01111100b
-10011111b << 1+2 = 11111000b
-10011111b << 1+3 = 11110000b
-10011111b << 1+4 = 11100000b
-10011111b << 1+5 = 11000000b
-10011111b << 1+6 = 10000000b
-10011111b << 1+7 = 00000000b
-10100000b << 1+0 = 01000000b
-10100000b << 1+1 = 10000000b
-10100000b << 1+2 = 00000000b
-10100000b << 1+3 = 00000000b
-10100000b << 1+4 = 00000000b
-10100000b << 1+5 = 00000000b
-10100000b << 1+6 = 00000000b
-10100000b << 1+7 = 00000000b
-10100001b << 1+0 = 01000010b
-10100001b << 1+1 = 10000100b
-10100001b << 1+2 = 00001000b
-10100001b << 1+3 = 00010000b
-10100001b << 1+4 = 00100000b
-10100001b << 1+5 = 01000000b
-10100001b << 1+6 = 10000000b
-10100001b << 1+7 = 00000000b
-10100010b << 1+0 = 01000100b
-10100010b << 1+1 = 10001000b
-10100010b << 1+2 = 00010000b
-10100010b << 1+3 = 00100000b
-10100010b << 1+4 = 01000000b
-10100010b << 1+5 = 10000000b
-10100010b << 1+6 = 00000000b
-10100010b << 1+7 = 00000000b
-10100011b << 1+0 = 01000110b
-10100011b << 1+1 = 10001100b
-10100011b << 1+2 = 00011000b
-10100011b << 1+3 = 00110000b
-10100011b << 1+4 = 01100000b
-10100011b << 1+5 = 11000000b
-10100011b << 1+6 = 10000000b
-10100011b << 1+7 = 00000000b
-10100100b << 1+0 = 01001000b
-10100100b << 1+1 = 10010000b
-10100100b << 1+2 = 00100000b
-10100100b << 1+3 = 01000000b
-10100100b << 1+4 = 10000000b
-10100100b << 1+5 = 00000000b
-10100100b << 1+6 = 00000000b
-10100100b << 1+7 = 00000000b
-10100101b << 1+0 = 01001010b
-10100101b << 1+1 = 10010100b
-10100101b << 1+2 = 00101000b
-10100101b << 1+3 = 01010000b
-10100101b << 1+4 = 10100000b
-10100101b << 1+5 = 01000000b
-10100101b << 1+6 = 10000000b
-10100101b << 1+7 = 00000000b
-10100110b << 1+0 = 01001100b
-10100110b << 1+1 = 10011000b
-10100110b << 1+2 = 00110000b
-10100110b << 1+3 = 01100000b
-10100110b << 1+4 = 11000000b
-10100110b << 1+5 = 10000000b
-10100110b << 1+6 = 00000000b
-10100110b << 1+7 = 00000000b
-10100111b << 1+0 = 01001110b
-10100111b << 1+1 = 10011100b
-10100111b << 1+2 = 00111000b
-10100111b << 1+3 = 01110000b
-10100111b << 1+4 = 11100000b
-10100111b << 1+5 = 11000000b
-10100111b << 1+6 = 10000000b
-10100111b << 1+7 = 00000000b
-10101000b << 1+0 = 01010000b
-10101000b << 1+1 = 10100000b
-10101000b << 1+2 = 01000000b
-10101000b << 1+3 = 10000000b
-10101000b << 1+4 = 00000000b
-10101000b << 1+5 = 00000000b
-10101000b << 1+6 = 00000000b
-10101000b << 1+7 = 00000000b
-10101001b << 1+0 = 01010010b
-10101001b << 1+1 = 10100100b
-10101001b << 1+2 = 01001000b
-10101001b << 1+3 = 10010000b
-10101001b << 1+4 = 00100000b
-10101001b << 1+5 = 01000000b
-10101001b << 1+6 = 10000000b
-10101001b << 1+7 = 00000000b
-10101010b << 1+0 = 01010100b
-10101010b << 1+1 = 10101000b
-10101010b << 1+2 = 01010000b
-10101010b << 1+3 = 10100000b
-10101010b << 1+4 = 01000000b
-10101010b << 1+5 = 10000000b
-10101010b << 1+6 = 00000000b
-10101010b << 1+7 = 00000000b
-10101011b << 1+0 = 01010110b
-10101011b << 1+1 = 10101100b
-10101011b << 1+2 = 01011000b
-10101011b << 1+3 = 10110000b
-10101011b << 1+4 = 01100000b
-10101011b << 1+5 = 11000000b
-10101011b << 1+6 = 10000000b
-10101011b << 1+7 = 00000000b
-10101100b << 1+0 = 01011000b
-10101100b << 1+1 = 10110000b
-10101100b << 1+2 = 01100000b
-10101100b << 1+3 = 11000000b
-10101100b << 1+4 = 10000000b
-10101100b << 1+5 = 00000000b
-10101100b << 1+6 = 00000000b
-10101100b << 1+7 = 00000000b
-10101101b << 1+0 = 01011010b
-10101101b << 1+1 = 10110100b
-10101101b << 1+2 = 01101000b
-10101101b << 1+3 = 11010000b
-10101101b << 1+4 = 10100000b
-10101101b << 1+5 = 01000000b
-10101101b << 1+6 = 10000000b
-10101101b << 1+7 = 00000000b
-10101110b << 1+0 = 01011100b
-10101110b << 1+1 = 10111000b
-10101110b << 1+2 = 01110000b
-10101110b << 1+3 = 11100000b
-10101110b << 1+4 = 11000000b
-10101110b << 1+5 = 10000000b
-10101110b << 1+6 = 00000000b
-10101110b << 1+7 = 00000000b
-10101111b << 1+0 = 01011110b
-10101111b << 1+1 = 10111100b
-10101111b << 1+2 = 01111000b
-10101111b << 1+3 = 11110000b
-10101111b << 1+4 = 11100000b
-10101111b << 1+5 = 11000000b
-10101111b << 1+6 = 10000000b
-10101111b << 1+7 = 00000000b
-10110000b << 1+0 = 01100000b
-10110000b << 1+1 = 11000000b
-10110000b << 1+2 = 10000000b
-10110000b << 1+3 = 00000000b
-10110000b << 1+4 = 00000000b
-10110000b << 1+5 = 00000000b
-10110000b << 1+6 = 00000000b
-10110000b << 1+7 = 00000000b
-10110001b << 1+0 = 01100010b
-10110001b << 1+1 = 11000100b
-10110001b << 1+2 = 10001000b
-10110001b << 1+3 = 00010000b
-10110001b << 1+4 = 00100000b
-10110001b << 1+5 = 01000000b
-10110001b << 1+6 = 10000000b
-10110001b << 1+7 = 00000000b
-10110010b << 1+0 = 01100100b
-10110010b << 1+1 = 11001000b
-10110010b << 1+2 = 10010000b
-10110010b << 1+3 = 00100000b
-10110010b << 1+4 = 01000000b
-10110010b << 1+5 = 10000000b
-10110010b << 1+6 = 00000000b
-10110010b << 1+7 = 00000000b
-10110011b << 1+0 = 01100110b
-10110011b << 1+1 = 11001100b
-10110011b << 1+2 = 10011000b
-10110011b << 1+3 = 00110000b
-10110011b << 1+4 = 01100000b
-10110011b << 1+5 = 11000000b
-10110011b << 1+6 = 10000000b
-10110011b << 1+7 = 00000000b
-10110100b << 1+0 = 01101000b
-10110100b << 1+1 = 11010000b
-10110100b << 1+2 = 10100000b
-10110100b << 1+3 = 01000000b
-10110100b << 1+4 = 10000000b
-10110100b << 1+5 = 00000000b
-10110100b << 1+6 = 00000000b
-10110100b << 1+7 = 00000000b
-10110101b << 1+0 = 01101010b
-10110101b << 1+1 = 11010100b
-10110101b << 1+2 = 10101000b
-10110101b << 1+3 = 01010000b
-10110101b << 1+4 = 10100000b
-10110101b << 1+5 = 01000000b
-10110101b << 1+6 = 10000000b
-10110101b << 1+7 = 00000000b
-10110110b << 1+0 = 01101100b
-10110110b << 1+1 = 11011000b
-10110110b << 1+2 = 10110000b
-10110110b << 1+3 = 01100000b
-10110110b << 1+4 = 11000000b
-10110110b << 1+5 = 10000000b
-10110110b << 1+6 = 00000000b
-10110110b << 1+7 = 00000000b
-10110111b << 1+0 = 01101110b
-10110111b << 1+1 = 11011100b
-10110111b << 1+2 = 10111000b
-10110111b << 1+3 = 01110000b
-10110111b << 1+4 = 11100000b
-10110111b << 1+5 = 11000000b
-10110111b << 1+6 = 10000000b
-10110111b << 1+7 = 00000000b
-10111000b << 1+0 = 01110000b
-10111000b << 1+1 = 11100000b
-10111000b << 1+2 = 11000000b
-10111000b << 1+3 = 10000000b
-10111000b << 1+4 = 00000000b
-10111000b << 1+5 = 00000000b
-10111000b << 1+6 = 00000000b
-10111000b << 1+7 = 00000000b
-10111001b << 1+0 = 01110010b
-10111001b << 1+1 = 11100100b
-10111001b << 1+2 = 11001000b
-10111001b << 1+3 = 10010000b
-10111001b << 1+4 = 00100000b
-10111001b << 1+5 = 01000000b
-10111001b << 1+6 = 10000000b
-10111001b << 1+7 = 00000000b
-10111010b << 1+0 = 01110100b
-10111010b << 1+1 = 11101000b
-10111010b << 1+2 = 11010000b
-10111010b << 1+3 = 10100000b
-10111010b << 1+4 = 01000000b
-10111010b << 1+5 = 10000000b
-10111010b << 1+6 = 00000000b
-10111010b << 1+7 = 00000000b
-10111011b << 1+0 = 01110110b
-10111011b << 1+1 = 11101100b
-10111011b << 1+2 = 11011000b
-10111011b << 1+3 = 10110000b
-10111011b << 1+4 = 01100000b
-10111011b << 1+5 = 11000000b
-10111011b << 1+6 = 10000000b
-10111011b << 1+7 = 00000000b
-10111100b << 1+0 = 01111000b
-10111100b << 1+1 = 11110000b
-10111100b << 1+2 = 11100000b
-10111100b << 1+3 = 11000000b
-10111100b << 1+4 = 10000000b
-10111100b << 1+5 = 00000000b
-10111100b << 1+6 = 00000000b
-10111100b << 1+7 = 00000000b
-10111101b << 1+0 = 01111010b
-10111101b << 1+1 = 11110100b
-10111101b << 1+2 = 11101000b
-10111101b << 1+3 = 11010000b
-10111101b << 1+4 = 10100000b
-10111101b << 1+5 = 01000000b
-10111101b << 1+6 = 10000000b
-10111101b << 1+7 = 00000000b
-10111110b << 1+0 = 01111100b
-10111110b << 1+1 = 11111000b
-10111110b << 1+2 = 11110000b
-10111110b << 1+3 = 11100000b
-10111110b << 1+4 = 11000000b
-10111110b << 1+5 = 10000000b
-10111110b << 1+6 = 00000000b
-10111110b << 1+7 = 00000000b
-10111111b << 1+0 = 01111110b
-10111111b << 1+1 = 11111100b
-10111111b << 1+2 = 11111000b
-10111111b << 1+3 = 11110000b
-10111111b << 1+4 = 11100000b
-10111111b << 1+5 = 11000000b
-10111111b << 1+6 = 10000000b
-10111111b << 1+7 = 00000000b
-11000000b << 1+0 = 10000000b
-11000000b << 1+1 = 00000000b
-11000000b << 1+2 = 00000000b
-11000000b << 1+3 = 00000000b
-11000000b << 1+4 = 00000000b
-11000000b << 1+5 = 00000000b
-11000000b << 1+6 = 00000000b
-11000000b << 1+7 = 00000000b
-11000001b << 1+0 = 10000010b
-11000001b << 1+1 = 00000100b
-11000001b << 1+2 = 00001000b
-11000001b << 1+3 = 00010000b
-11000001b << 1+4 = 00100000b
-11000001b << 1+5 = 01000000b
-11000001b << 1+6 = 10000000b
-11000001b << 1+7 = 00000000b
-11000010b << 1+0 = 10000100b
-11000010b << 1+1 = 00001000b
-11000010b << 1+2 = 00010000b
-11000010b << 1+3 = 00100000b
-11000010b << 1+4 = 01000000b
-11000010b << 1+5 = 10000000b
-11000010b << 1+6 = 00000000b
-11000010b << 1+7 = 00000000b
-11000011b << 1+0 = 10000110b
-11000011b << 1+1 = 00001100b
-11000011b << 1+2 = 00011000b
-11000011b << 1+3 = 00110000b
-11000011b << 1+4 = 01100000b
-11000011b << 1+5 = 11000000b
-11000011b << 1+6 = 10000000b
-11000011b << 1+7 = 00000000b
-11000100b << 1+0 = 10001000b
-11000100b << 1+1 = 00010000b
-11000100b << 1+2 = 00100000b
-11000100b << 1+3 = 01000000b
-11000100b << 1+4 = 10000000b
-11000100b << 1+5 = 00000000b
-11000100b << 1+6 = 00000000b
-11000100b << 1+7 = 00000000b
-11000101b << 1+0 = 10001010b
-11000101b << 1+1 = 00010100b
-11000101b << 1+2 = 00101000b
-11000101b << 1+3 = 01010000b
-11000101b << 1+4 = 10100000b
-11000101b << 1+5 = 01000000b
-11000101b << 1+6 = 10000000b
-11000101b << 1+7 = 00000000b
-11000110b << 1+0 = 10001100b
-11000110b << 1+1 = 00011000b
-11000110b << 1+2 = 00110000b
-11000110b << 1+3 = 01100000b
-11000110b << 1+4 = 11000000b
-11000110b << 1+5 = 10000000b
-11000110b << 1+6 = 00000000b
-11000110b << 1+7 = 00000000b
-11000111b << 1+0 = 10001110b
-11000111b << 1+1 = 00011100b
-11000111b << 1+2 = 00111000b
-11000111b << 1+3 = 01110000b
-11000111b << 1+4 = 11100000b
-11000111b << 1+5 = 11000000b
-11000111b << 1+6 = 10000000b
-11000111b << 1+7 = 00000000b
-11001000b << 1+0 = 10010000b
-11001000b << 1+1 = 00100000b
-11001000b << 1+2 = 01000000b
-11001000b << 1+3 = 10000000b
-11001000b << 1+4 = 00000000b
-11001000b << 1+5 = 00000000b
-11001000b << 1+6 = 00000000b
-11001000b << 1+7 = 00000000b
-11001001b << 1+0 = 10010010b
-11001001b << 1+1 = 00100100b
-11001001b << 1+2 = 01001000b
-11001001b << 1+3 = 10010000b
-11001001b << 1+4 = 00100000b
-11001001b << 1+5 = 01000000b
-11001001b << 1+6 = 10000000b
-11001001b << 1+7 = 00000000b
-11001010b << 1+0 = 10010100b
-11001010b << 1+1 = 00101000b
-11001010b << 1+2 = 01010000b
-11001010b << 1+3 = 10100000b
-11001010b << 1+4 = 01000000b
-11001010b << 1+5 = 10000000b
-11001010b << 1+6 = 00000000b
-11001010b << 1+7 = 00000000b
-11001011b << 1+0 = 10010110b
-11001011b << 1+1 = 00101100b
-11001011b << 1+2 = 01011000b
-11001011b << 1+3 = 10110000b
-11001011b << 1+4 = 01100000b
-11001011b << 1+5 = 11000000b
-11001011b << 1+6 = 10000000b
-11001011b << 1+7 = 00000000b
-11001100b << 1+0 = 10011000b
-11001100b << 1+1 = 00110000b
-11001100b << 1+2 = 01100000b
-11001100b << 1+3 = 11000000b
-11001100b << 1+4 = 10000000b
-11001100b << 1+5 = 00000000b
-11001100b << 1+6 = 00000000b
-11001100b << 1+7 = 00000000b
-11001101b << 1+0 = 10011010b
-11001101b << 1+1 = 00110100b
-11001101b << 1+2 = 01101000b
-11001101b << 1+3 = 11010000b
-11001101b << 1+4 = 10100000b
-11001101b << 1+5 = 01000000b
-11001101b << 1+6 = 10000000b
-11001101b << 1+7 = 00000000b
-11001110b << 1+0 = 10011100b
-11001110b << 1+1 = 00111000b
-11001110b << 1+2 = 01110000b
-11001110b << 1+3 = 11100000b
-11001110b << 1+4 = 11000000b
-11001110b << 1+5 = 10000000b
-11001110b << 1+6 = 00000000b
-11001110b << 1+7 = 00000000b
-11001111b << 1+0 = 10011110b
-11001111b << 1+1 = 00111100b
-11001111b << 1+2 = 01111000b
-11001111b << 1+3 = 11110000b
-11001111b << 1+4 = 11100000b
-11001111b << 1+5 = 11000000b
-11001111b << 1+6 = 10000000b
-11001111b << 1+7 = 00000000b
-11010000b << 1+0 = 10100000b
-11010000b << 1+1 = 01000000b
-11010000b << 1+2 = 10000000b
-11010000b << 1+3 = 00000000b
-11010000b << 1+4 = 00000000b
-11010000b << 1+5 = 00000000b
-11010000b << 1+6 = 00000000b
-11010000b << 1+7 = 00000000b
-11010001b << 1+0 = 10100010b
-11010001b << 1+1 = 01000100b
-11010001b << 1+2 = 10001000b
-11010001b << 1+3 = 00010000b
-11010001b << 1+4 = 00100000b
-11010001b << 1+5 = 01000000b
-11010001b << 1+6 = 10000000b
-11010001b << 1+7 = 00000000b
-11010010b << 1+0 = 10100100b
-11010010b << 1+1 = 01001000b
-11010010b << 1+2 = 10010000b
-11010010b << 1+3 = 00100000b
-11010010b << 1+4 = 01000000b
-11010010b << 1+5 = 10000000b
-11010010b << 1+6 = 00000000b
-11010010b << 1+7 = 00000000b
-11010011b << 1+0 = 10100110b
-11010011b << 1+1 = 01001100b
-11010011b << 1+2 = 10011000b
-11010011b << 1+3 = 00110000b
-11010011b << 1+4 = 01100000b
-11010011b << 1+5 = 11000000b
-11010011b << 1+6 = 10000000b
-11010011b << 1+7 = 00000000b
-11010100b << 1+0 = 10101000b
-11010100b << 1+1 = 01010000b
-11010100b << 1+2 = 10100000b
-11010100b << 1+3 = 01000000b
-11010100b << 1+4 = 10000000b
-11010100b << 1+5 = 00000000b
-11010100b << 1+6 = 00000000b
-11010100b << 1+7 = 00000000b
-11010101b << 1+0 = 10101010b
-11010101b << 1+1 = 01010100b
-11010101b << 1+2 = 10101000b
-11010101b << 1+3 = 01010000b
-11010101b << 1+4 = 10100000b
-11010101b << 1+5 = 01000000b
-11010101b << 1+6 = 10000000b
-11010101b << 1+7 = 00000000b
-11010110b << 1+0 = 10101100b
-11010110b << 1+1 = 01011000b
-11010110b << 1+2 = 10110000b
-11010110b << 1+3 = 01100000b
-11010110b << 1+4 = 11000000b
-11010110b << 1+5 = 10000000b
-11010110b << 1+6 = 00000000b
-11010110b << 1+7 = 00000000b
-11010111b << 1+0 = 10101110b
-11010111b << 1+1 = 01011100b
-11010111b << 1+2 = 10111000b
-11010111b << 1+3 = 01110000b
-11010111b << 1+4 = 11100000b
-11010111b << 1+5 = 11000000b
-11010111b << 1+6 = 10000000b
-11010111b << 1+7 = 00000000b
-11011000b << 1+0 = 10110000b
-11011000b << 1+1 = 01100000b
-11011000b << 1+2 = 11000000b
-11011000b << 1+3 = 10000000b
-11011000b << 1+4 = 00000000b
-11011000b << 1+5 = 00000000b
-11011000b << 1+6 = 00000000b
-11011000b << 1+7 = 00000000b
-11011001b << 1+0 = 10110010b
-11011001b << 1+1 = 01100100b
-11011001b << 1+2 = 11001000b
-11011001b << 1+3 = 10010000b
-11011001b << 1+4 = 00100000b
-11011001b << 1+5 = 01000000b
-11011001b << 1+6 = 10000000b
-11011001b << 1+7 = 00000000b
-11011010b << 1+0 = 10110100b
-11011010b << 1+1 = 01101000b
-11011010b << 1+2 = 11010000b
-11011010b << 1+3 = 10100000b
-11011010b << 1+4 = 01000000b
-11011010b << 1+5 = 10000000b
-11011010b << 1+6 = 00000000b
-11011010b << 1+7 = 00000000b
-11011011b << 1+0 = 10110110b
-11011011b << 1+1 = 01101100b
-11011011b << 1+2 = 11011000b
-11011011b << 1+3 = 10110000b
-11011011b << 1+4 = 01100000b
-11011011b << 1+5 = 11000000b
-11011011b << 1+6 = 10000000b
-11011011b << 1+7 = 00000000b
-11011100b << 1+0 = 10111000b
-11011100b << 1+1 = 01110000b
-11011100b << 1+2 = 11100000b
-11011100b << 1+3 = 11000000b
-11011100b << 1+4 = 10000000b
-11011100b << 1+5 = 00000000b
-11011100b << 1+6 = 00000000b
-11011100b << 1+7 = 00000000b
-11011101b << 1+0 = 10111010b
-11011101b << 1+1 = 01110100b
-11011101b << 1+2 = 11101000b
-11011101b << 1+3 = 11010000b
-11011101b << 1+4 = 10100000b
-11011101b << 1+5 = 01000000b
-11011101b << 1+6 = 10000000b
-11011101b << 1+7 = 00000000b
-11011110b << 1+0 = 10111100b
-11011110b << 1+1 = 01111000b
-11011110b << 1+2 = 11110000b
-11011110b << 1+3 = 11100000b
-11011110b << 1+4 = 11000000b
-11011110b << 1+5 = 10000000b
-11011110b << 1+6 = 00000000b
-11011110b << 1+7 = 00000000b
-11011111b << 1+0 = 10111110b
-11011111b << 1+1 = 01111100b
-11011111b << 1+2 = 11111000b
-11011111b << 1+3 = 11110000b
-11011111b << 1+4 = 11100000b
-11011111b << 1+5 = 11000000b
-11011111b << 1+6 = 10000000b
-11011111b << 1+7 = 00000000b
-11100000b << 1+0 = 11000000b
-11100000b << 1+1 = 10000000b
-11100000b << 1+2 = 00000000b
-11100000b << 1+3 = 00000000b
-11100000b << 1+4 = 00000000b
-11100000b << 1+5 = 00000000b
-11100000b << 1+6 = 00000000b
-11100000b << 1+7 = 00000000b
-11100001b << 1+0 = 11000010b
-11100001b << 1+1 = 10000100b
-11100001b << 1+2 = 00001000b
-11100001b << 1+3 = 00010000b
-11100001b << 1+4 = 00100000b
-11100001b << 1+5 = 01000000b
-11100001b << 1+6 = 10000000b
-11100001b << 1+7 = 00000000b
-11100010b << 1+0 = 11000100b
-11100010b << 1+1 = 10001000b
-11100010b << 1+2 = 00010000b
-11100010b << 1+3 = 00100000b
-11100010b << 1+4 = 01000000b
-11100010b << 1+5 = 10000000b
-11100010b << 1+6 = 00000000b
-11100010b << 1+7 = 00000000b
-11100011b << 1+0 = 11000110b
-11100011b << 1+1 = 10001100b
-11100011b << 1+2 = 00011000b
-11100011b << 1+3 = 00110000b
-11100011b << 1+4 = 01100000b
-11100011b << 1+5 = 11000000b
-11100011b << 1+6 = 10000000b
-11100011b << 1+7 = 00000000b
-11100100b << 1+0 = 11001000b
-11100100b << 1+1 = 10010000b
-11100100b << 1+2 = 00100000b
-11100100b << 1+3 = 01000000b
-11100100b << 1+4 = 10000000b
-11100100b << 1+5 = 00000000b
-11100100b << 1+6 = 00000000b
-11100100b << 1+7 = 00000000b
-11100101b << 1+0 = 11001010b
-11100101b << 1+1 = 10010100b
-11100101b << 1+2 = 00101000b
-11100101b << 1+3 = 01010000b
-11100101b << 1+4 = 10100000b
-11100101b << 1+5 = 01000000b
-11100101b << 1+6 = 10000000b
-11100101b << 1+7 = 00000000b
-11100110b << 1+0 = 11001100b
-11100110b << 1+1 = 10011000b
-11100110b << 1+2 = 00110000b
-11100110b << 1+3 = 01100000b
-11100110b << 1+4 = 11000000b
-11100110b << 1+5 = 10000000b
-11100110b << 1+6 = 00000000b
-11100110b << 1+7 = 00000000b
-11100111b << 1+0 = 11001110b
-11100111b << 1+1 = 10011100b
-11100111b << 1+2 = 00111000b
-11100111b << 1+3 = 01110000b
-11100111b << 1+4 = 11100000b
-11100111b << 1+5 = 11000000b
-11100111b << 1+6 = 10000000b
-11100111b << 1+7 = 00000000b
-11101000b << 1+0 = 11010000b
-11101000b << 1+1 = 10100000b
-11101000b << 1+2 = 01000000b
-11101000b << 1+3 = 10000000b
-11101000b << 1+4 = 00000000b
-11101000b << 1+5 = 00000000b
-11101000b << 1+6 = 00000000b
-11101000b << 1+7 = 00000000b
-11101001b << 1+0 = 11010010b
-11101001b << 1+1 = 10100100b
-11101001b << 1+2 = 01001000b
-11101001b << 1+3 = 10010000b
-11101001b << 1+4 = 00100000b
-11101001b << 1+5 = 01000000b
-11101001b << 1+6 = 10000000b
-11101001b << 1+7 = 00000000b
-11101010b << 1+0 = 11010100b
-11101010b << 1+1 = 10101000b
-11101010b << 1+2 = 01010000b
-11101010b << 1+3 = 10100000b
-11101010b << 1+4 = 01000000b
-11101010b << 1+5 = 10000000b
-11101010b << 1+6 = 00000000b
-11101010b << 1+7 = 00000000b
-11101011b << 1+0 = 11010110b
-11101011b << 1+1 = 10101100b
-11101011b << 1+2 = 01011000b
-11101011b << 1+3 = 10110000b
-11101011b << 1+4 = 01100000b
-11101011b << 1+5 = 11000000b
-11101011b << 1+6 = 10000000b
-11101011b << 1+7 = 00000000b
-11101100b << 1+0 = 11011000b
-11101100b << 1+1 = 10110000b
-11101100b << 1+2 = 01100000b
-11101100b << 1+3 = 11000000b
-11101100b << 1+4 = 10000000b
-11101100b << 1+5 = 00000000b
-11101100b << 1+6 = 00000000b
-11101100b << 1+7 = 00000000b
-11101101b << 1+0 = 11011010b
-11101101b << 1+1 = 10110100b
-11101101b << 1+2 = 01101000b
-11101101b << 1+3 = 11010000b
-11101101b << 1+4 = 10100000b
-11101101b << 1+5 = 01000000b
-11101101b << 1+6 = 10000000b
-11101101b << 1+7 = 00000000b
-11101110b << 1+0 = 11011100b
-11101110b << 1+1 = 10111000b
-11101110b << 1+2 = 01110000b
-11101110b << 1+3 = 11100000b
-11101110b << 1+4 = 11000000b
-11101110b << 1+5 = 10000000b
-11101110b << 1+6 = 00000000b
-11101110b << 1+7 = 00000000b
-11101111b << 1+0 = 11011110b
-11101111b << 1+1 = 10111100b
-11101111b << 1+2 = 01111000b
-11101111b << 1+3 = 11110000b
-11101111b << 1+4 = 11100000b
-11101111b << 1+5 = 11000000b
-11101111b << 1+6 = 10000000b
-11101111b << 1+7 = 00000000b
-11110000b << 1+0 = 11100000b
-11110000b << 1+1 = 11000000b
-11110000b << 1+2 = 10000000b
-11110000b << 1+3 = 00000000b
-11110000b << 1+4 = 00000000b
-11110000b << 1+5 = 00000000b
-11110000b << 1+6 = 00000000b
-11110000b << 1+7 = 00000000b
-11110001b << 1+0 = 11100010b
-11110001b << 1+1 = 11000100b
-11110001b << 1+2 = 10001000b
-11110001b << 1+3 = 00010000b
-11110001b << 1+4 = 00100000b
-11110001b << 1+5 = 01000000b
-11110001b << 1+6 = 10000000b
-11110001b << 1+7 = 00000000b
-11110010b << 1+0 = 11100100b
-11110010b << 1+1 = 11001000b
-11110010b << 1+2 = 10010000b
-11110010b << 1+3 = 00100000b
-11110010b << 1+4 = 01000000b
-11110010b << 1+5 = 10000000b
-11110010b << 1+6 = 00000000b
-11110010b << 1+7 = 00000000b
-11110011b << 1+0 = 11100110b
-11110011b << 1+1 = 11001100b
-11110011b << 1+2 = 10011000b
-11110011b << 1+3 = 00110000b
-11110011b << 1+4 = 01100000b
-11110011b << 1+5 = 11000000b
-11110011b << 1+6 = 10000000b
-11110011b << 1+7 = 00000000b
-11110100b << 1+0 = 11101000b
-11110100b << 1+1 = 11010000b
-11110100b << 1+2 = 10100000b
-11110100b << 1+3 = 01000000b
-11110100b << 1+4 = 10000000b
-11110100b << 1+5 = 00000000b
-11110100b << 1+6 = 00000000b
-11110100b << 1+7 = 00000000b
-11110101b << 1+0 = 11101010b
-11110101b << 1+1 = 11010100b
-11110101b << 1+2 = 10101000b
-11110101b << 1+3 = 01010000b
-11110101b << 1+4 = 10100000b
-11110101b << 1+5 = 01000000b
-11110101b << 1+6 = 10000000b
-11110101b << 1+7 = 00000000b
-11110110b << 1+0 = 11101100b
-11110110b << 1+1 = 11011000b
-11110110b << 1+2 = 10110000b
-11110110b << 1+3 = 01100000b
-11110110b << 1+4 = 11000000b
-11110110b << 1+5 = 10000000b
-11110110b << 1+6 = 00000000b
-11110110b << 1+7 = 00000000b
-11110111b << 1+0 = 11101110b
-11110111b << 1+1 = 11011100b
-11110111b << 1+2 = 10111000b
-11110111b << 1+3 = 01110000b
-11110111b << 1+4 = 11100000b
-11110111b << 1+5 = 11000000b
-11110111b << 1+6 = 10000000b
-11110111b << 1+7 = 00000000b
-11111000b << 1+0 = 11110000b
-11111000b << 1+1 = 11100000b
-11111000b << 1+2 = 11000000b
-11111000b << 1+3 = 10000000b
-11111000b << 1+4 = 00000000b
-11111000b << 1+5 = 00000000b
-11111000b << 1+6 = 00000000b
-11111000b << 1+7 = 00000000b
-11111001b << 1+0 = 11110010b
-11111001b << 1+1 = 11100100b
-11111001b << 1+2 = 11001000b
-11111001b << 1+3 = 10010000b
-11111001b << 1+4 = 00100000b
-11111001b << 1+5 = 01000000b
-11111001b << 1+6 = 10000000b
-11111001b << 1+7 = 00000000b
-11111010b << 1+0 = 11110100b
-11111010b << 1+1 = 11101000b
-11111010b << 1+2 = 11010000b
-11111010b << 1+3 = 10100000b
-11111010b << 1+4 = 01000000b
-11111010b << 1+5 = 10000000b
-11111010b << 1+6 = 00000000b
-11111010b << 1+7 = 00000000b
-11111011b << 1+0 = 11110110b
-11111011b << 1+1 = 11101100b
-11111011b << 1+2 = 11011000b
-11111011b << 1+3 = 10110000b
-11111011b << 1+4 = 01100000b
-11111011b << 1+5 = 11000000b
-11111011b << 1+6 = 10000000b
-11111011b << 1+7 = 00000000b
-11111100b << 1+0 = 11111000b
-11111100b << 1+1 = 11110000b
-11111100b << 1+2 = 11100000b
-11111100b << 1+3 = 11000000b
-11111100b << 1+4 = 10000000b
-11111100b << 1+5 = 00000000b
-11111100b << 1+6 = 00000000b
-11111100b << 1+7 = 00000000b
-11111101b << 1+0 = 11111010b
-11111101b << 1+1 = 11110100b
-11111101b << 1+2 = 11101000b
-11111101b << 1+3 = 11010000b
-11111101b << 1+4 = 10100000b
-11111101b << 1+5 = 01000000b
-11111101b << 1+6 = 10000000b
-11111101b << 1+7 = 00000000b
-11111110b << 1+0 = 11111100b
-11111110b << 1+1 = 11111000b
-11111110b << 1+2 = 11110000b
-11111110b << 1+3 = 11100000b
-11111110b << 1+4 = 11000000b
-11111110b << 1+5 = 10000000b
-11111110b << 1+6 = 00000000b
-11111110b << 1+7 = 00000000b
-11111111b << 1+0 = 11111110b
-11111111b << 1+1 = 11111100b
-11111111b << 1+2 = 11111000b
-11111111b << 1+3 = 11110000b
-11111111b << 1+4 = 11100000b
-11111111b << 1+5 = 11000000b
-11111111b << 1+6 = 10000000b
-11111111b << 1+7 = 00000000b
-00000000b << 1+0 = 00000000b
-00000000b << 1+1 = 00000000b
-00000000b << 1+2 = 00000000b
-00000000b << 1+3 = 00000000b
-00000000b << 1+4 = 00000000b
-00000000b << 1+5 = 00000000b
-00000000b << 1+6 = 00000000b
-00000000b << 1+7 = 00000000b
-00000001b << 1+0 = 00000010b
-00000001b << 1+1 = 00000100b
-00000001b << 1+2 = 00001000b
-00000001b << 1+3 = 00010000b
-00000001b << 1+4 = 00100000b
-00000001b << 1+5 = 01000000b
-00000001b << 1+6 = 10000000b
-00000001b << 1+7 = 00000000b
-00000010b << 1+0 = 00000100b
-00000010b << 1+1 = 00001000b
-00000010b << 1+2 = 00010000b
-00000010b << 1+3 = 00100000b
-00000010b << 1+4 = 01000000b
-00000010b << 1+5 = 10000000b
-00000010b << 1+6 = 00000000b
-00000010b << 1+7 = 00000000b
-00000011b << 1+0 = 00000110b
-00000011b << 1+1 = 00001100b
-00000011b << 1+2 = 00011000b
-00000011b << 1+3 = 00110000b
-00000011b << 1+4 = 01100000b
-00000011b << 1+5 = 11000000b
-00000011b << 1+6 = 10000000b
-00000011b << 1+7 = 00000000b
-00000100b << 1+0 = 00001000b
-00000100b << 1+1 = 00010000b
-00000100b << 1+2 = 00100000b
-00000100b << 1+3 = 01000000b
-00000100b << 1+4 = 10000000b
-00000100b << 1+5 = 00000000b
-00000100b << 1+6 = 00000000b
-00000100b << 1+7 = 00000000b
-00000101b << 1+0 = 00001010b
-00000101b << 1+1 = 00010100b
-00000101b << 1+2 = 00101000b
-00000101b << 1+3 = 01010000b
-00000101b << 1+4 = 10100000b
-00000101b << 1+5 = 01000000b
-00000101b << 1+6 = 10000000b
-00000101b << 1+7 = 00000000b
-00000110b << 1+0 = 00001100b
-00000110b << 1+1 = 00011000b
-00000110b << 1+2 = 00110000b
-00000110b << 1+3 = 01100000b
-00000110b << 1+4 = 11000000b
-00000110b << 1+5 = 10000000b
-00000110b << 1+6 = 00000000b
-00000110b << 1+7 = 00000000b
-00000111b << 1+0 = 00001110b
-00000111b << 1+1 = 00011100b
-00000111b << 1+2 = 00111000b
-00000111b << 1+3 = 01110000b
-00000111b << 1+4 = 11100000b
-00000111b << 1+5 = 11000000b
-00000111b << 1+6 = 10000000b
-00000111b << 1+7 = 00000000b
-00001000b << 1+0 = 00010000b
-00001000b << 1+1 = 00100000b
-00001000b << 1+2 = 01000000b
-00001000b << 1+3 = 10000000b
-00001000b << 1+4 = 00000000b
-00001000b << 1+5 = 00000000b
-00001000b << 1+6 = 00000000b
-00001000b << 1+7 = 00000000b
-00001001b << 1+0 = 00010010b
-00001001b << 1+1 = 00100100b
-00001001b << 1+2 = 01001000b
-00001001b << 1+3 = 10010000b
-00001001b << 1+4 = 00100000b
-00001001b << 1+5 = 01000000b
-00001001b << 1+6 = 10000000b
-00001001b << 1+7 = 00000000b
-00001010b << 1+0 = 00010100b
-00001010b << 1+1 = 00101000b
-00001010b << 1+2 = 01010000b
-00001010b << 1+3 = 10100000b
-00001010b << 1+4 = 01000000b
-00001010b << 1+5 = 10000000b
-00001010b << 1+6 = 00000000b
-00001010b << 1+7 = 00000000b
-00001011b << 1+0 = 00010110b
-00001011b << 1+1 = 00101100b
-00001011b << 1+2 = 01011000b
-00001011b << 1+3 = 10110000b
-00001011b << 1+4 = 01100000b
-00001011b << 1+5 = 11000000b
-00001011b << 1+6 = 10000000b
-00001011b << 1+7 = 00000000b
-00001100b << 1+0 = 00011000b
-00001100b << 1+1 = 00110000b
-00001100b << 1+2 = 01100000b
-00001100b << 1+3 = 11000000b
-00001100b << 1+4 = 10000000b
-00001100b << 1+5 = 00000000b
-00001100b << 1+6 = 00000000b
-00001100b << 1+7 = 00000000b
-00001101b << 1+0 = 00011010b
-00001101b << 1+1 = 00110100b
-00001101b << 1+2 = 01101000b
-00001101b << 1+3 = 11010000b
-00001101b << 1+4 = 10100000b
-00001101b << 1+5 = 01000000b
-00001101b << 1+6 = 10000000b
-00001101b << 1+7 = 00000000b
-00001110b << 1+0 = 00011100b
-00001110b << 1+1 = 00111000b
-00001110b << 1+2 = 01110000b
-00001110b << 1+3 = 11100000b
-00001110b << 1+4 = 11000000b
-00001110b << 1+5 = 10000000b
-00001110b << 1+6 = 00000000b
-00001110b << 1+7 = 00000000b
-00001111b << 1+0 = 00011110b
-00001111b << 1+1 = 00111100b
-00001111b << 1+2 = 01111000b
-00001111b << 1+3 = 11110000b
-00001111b << 1+4 = 11100000b
-00001111b << 1+5 = 11000000b
-00001111b << 1+6 = 10000000b
-00001111b << 1+7 = 00000000b
-00010000b << 1+0 = 00100000b
-00010000b << 1+1 = 01000000b
-00010000b << 1+2 = 10000000b
-00010000b << 1+3 = 00000000b
-00010000b << 1+4 = 00000000b
-00010000b << 1+5 = 00000000b
-00010000b << 1+6 = 00000000b
-00010000b << 1+7 = 00000000b
-00010001b << 1+0 = 00100010b
-00010001b << 1+1 = 01000100b
-00010001b << 1+2 = 10001000b
-00010001b << 1+3 = 00010000b
-00010001b << 1+4 = 00100000b
-00010001b << 1+5 = 01000000b
-00010001b << 1+6 = 10000000b
-00010001b << 1+7 = 00000000b
-00010010b << 1+0 = 00100100b
-00010010b << 1+1 = 01001000b
-00010010b << 1+2 = 10010000b
-00010010b << 1+3 = 00100000b
-00010010b << 1+4 = 01000000b
-00010010b << 1+5 = 10000000b
-00010010b << 1+6 = 00000000b
-00010010b << 1+7 = 00000000b
-00010011b << 1+0 = 00100110b
-00010011b << 1+1 = 01001100b
-00010011b << 1+2 = 10011000b
-00010011b << 1+3 = 00110000b
-00010011b << 1+4 = 01100000b
-00010011b << 1+5 = 11000000b
-00010011b << 1+6 = 10000000b
-00010011b << 1+7 = 00000000b
-00010100b << 1+0 = 00101000b
-00010100b << 1+1 = 01010000b
-00010100b << 1+2 = 10100000b
-00010100b << 1+3 = 01000000b
-00010100b << 1+4 = 10000000b
-00010100b << 1+5 = 00000000b
-00010100b << 1+6 = 00000000b
-00010100b << 1+7 = 00000000b
-00010101b << 1+0 = 00101010b
-00010101b << 1+1 = 01010100b
-00010101b << 1+2 = 10101000b
-00010101b << 1+3 = 01010000b
-00010101b << 1+4 = 10100000b
-00010101b << 1+5 = 01000000b
-00010101b << 1+6 = 10000000b
-00010101b << 1+7 = 00000000b
-00010110b << 1+0 = 00101100b
-00010110b << 1+1 = 01011000b
-00010110b << 1+2 = 10110000b
-00010110b << 1+3 = 01100000b
-00010110b << 1+4 = 11000000b
-00010110b << 1+5 = 10000000b
-00010110b << 1+6 = 00000000b
-00010110b << 1+7 = 00000000b
-00010111b << 1+0 = 00101110b
-00010111b << 1+1 = 01011100b
-00010111b << 1+2 = 10111000b
-00010111b << 1+3 = 01110000b
-00010111b << 1+4 = 11100000b
-00010111b << 1+5 = 11000000b
-00010111b << 1+6 = 10000000b
-00010111b << 1+7 = 00000000b
-00011000b << 1+0 = 00110000b
-00011000b << 1+1 = 01100000b
-00011000b << 1+2 = 11000000b
-00011000b << 1+3 = 10000000b
-00011000b << 1+4 = 00000000b
-00011000b << 1+5 = 00000000b
-00011000b << 1+6 = 00000000b
-00011000b << 1+7 = 00000000b
-00011001b << 1+0 = 00110010b
-00011001b << 1+1 = 01100100b
-00011001b << 1+2 = 11001000b
-00011001b << 1+3 = 10010000b
-00011001b << 1+4 = 00100000b
-00011001b << 1+5 = 01000000b
-00011001b << 1+6 = 10000000b
-00011001b << 1+7 = 00000000b
-00011010b << 1+0 = 00110100b
-00011010b << 1+1 = 01101000b
-00011010b << 1+2 = 11010000b
-00011010b << 1+3 = 10100000b
-00011010b << 1+4 = 01000000b
-00011010b << 1+5 = 10000000b
-00011010b << 1+6 = 00000000b
-00011010b << 1+7 = 00000000b
-00011011b << 1+0 = 00110110b
-00011011b << 1+1 = 01101100b
-00011011b << 1+2 = 11011000b
-00011011b << 1+3 = 10110000b
-00011011b << 1+4 = 01100000b
-00011011b << 1+5 = 11000000b
-00011011b << 1+6 = 10000000b
-00011011b << 1+7 = 00000000b
-00011100b << 1+0 = 00111000b
-00011100b << 1+1 = 01110000b
-00011100b << 1+2 = 11100000b
-00011100b << 1+3 = 11000000b
-00011100b << 1+4 = 10000000b
-00011100b << 1+5 = 00000000b
-00011100b << 1+6 = 00000000b
-00011100b << 1+7 = 00000000b
-00011101b << 1+0 = 00111010b
-00011101b << 1+1 = 01110100b
-00011101b << 1+2 = 11101000b
-00011101b << 1+3 = 11010000b
-00011101b << 1+4 = 10100000b
-00011101b << 1+5 = 01000000b
-00011101b << 1+6 = 10000000b
-00011101b << 1+7 = 00000000b
-00011110b << 1+0 = 00111100b
-00011110b << 1+1 = 01111000b
-00011110b << 1+2 = 11110000b
-00011110b << 1+3 = 11100000b
-00011110b << 1+4 = 11000000b
-00011110b << 1+5 = 10000000b
-00011110b << 1+6 = 00000000b
-00011110b << 1+7 = 00000000b
-00011111b << 1+0 = 00111110b
-00011111b << 1+1 = 01111100b
-00011111b << 1+2 = 11111000b
-00011111b << 1+3 = 11110000b
-00011111b << 1+4 = 11100000b
-00011111b << 1+5 = 11000000b
-00011111b << 1+6 = 10000000b
-00011111b << 1+7 = 00000000b
-00100000b << 1+0 = 01000000b
-00100000b << 1+1 = 10000000b
-00100000b << 1+2 = 00000000b
-00100000b << 1+3 = 00000000b
-00100000b << 1+4 = 00000000b
-00100000b << 1+5 = 00000000b
-00100000b << 1+6 = 00000000b
-00100000b << 1+7 = 00000000b
-00100001b << 1+0 = 01000010b
-00100001b << 1+1 = 10000100b
-00100001b << 1+2 = 00001000b
-00100001b << 1+3 = 00010000b
-00100001b << 1+4 = 00100000b
-00100001b << 1+5 = 01000000b
-00100001b << 1+6 = 10000000b
-00100001b << 1+7 = 00000000b
-00100010b << 1+0 = 01000100b
-00100010b << 1+1 = 10001000b
-00100010b << 1+2 = 00010000b
-00100010b << 1+3 = 00100000b
-00100010b << 1+4 = 01000000b
-00100010b << 1+5 = 10000000b
-00100010b << 1+6 = 00000000b
-00100010b << 1+7 = 00000000b
-00100011b << 1+0 = 01000110b
-00100011b << 1+1 = 10001100b
-00100011b << 1+2 = 00011000b
-00100011b << 1+3 = 00110000b
-00100011b << 1+4 = 01100000b
-00100011b << 1+5 = 11000000b
-00100011b << 1+6 = 10000000b
-00100011b << 1+7 = 00000000b
-00100100b << 1+0 = 01001000b
-00100100b << 1+1 = 10010000b
-00100100b << 1+2 = 00100000b
-00100100b << 1+3 = 01000000b
-00100100b << 1+4 = 10000000b
-00100100b << 1+5 = 00000000b
-00100100b << 1+6 = 00000000b
-00100100b << 1+7 = 00000000b
-00100101b << 1+0 = 01001010b
-00100101b << 1+1 = 10010100b
-00100101b << 1+2 = 00101000b
-00100101b << 1+3 = 01010000b
-00100101b << 1+4 = 10100000b
-00100101b << 1+5 = 01000000b
-00100101b << 1+6 = 10000000b
-00100101b << 1+7 = 00000000b
-00100110b << 1+0 = 01001100b
-00100110b << 1+1 = 10011000b
-00100110b << 1+2 = 00110000b
-00100110b << 1+3 = 01100000b
-00100110b << 1+4 = 11000000b
-00100110b << 1+5 = 10000000b
-00100110b << 1+6 = 00000000b
-00100110b << 1+7 = 00000000b
-00100111b << 1+0 = 01001110b
-00100111b << 1+1 = 10011100b
-00100111b << 1+2 = 00111000b
-00100111b << 1+3 = 01110000b
-00100111b << 1+4 = 11100000b
-00100111b << 1+5 = 11000000b
-00100111b << 1+6 = 10000000b
-00100111b << 1+7 = 00000000b
-00101000b << 1+0 = 01010000b
-00101000b << 1+1 = 10100000b
-00101000b << 1+2 = 01000000b
-00101000b << 1+3 = 10000000b
-00101000b << 1+4 = 00000000b
-00101000b << 1+5 = 00000000b
-00101000b << 1+6 = 00000000b
-00101000b << 1+7 = 00000000b
-00101001b << 1+0 = 01010010b
-00101001b << 1+1 = 10100100b
-00101001b << 1+2 = 01001000b
-00101001b << 1+3 = 10010000b
-00101001b << 1+4 = 00100000b
-00101001b << 1+5 = 01000000b
-00101001b << 1+6 = 10000000b
-00101001b << 1+7 = 00000000b
-00101010b << 1+0 = 01010100b
-00101010b << 1+1 = 10101000b
-00101010b << 1+2 = 01010000b
-00101010b << 1+3 = 10100000b
-00101010b << 1+4 = 01000000b
-00101010b << 1+5 = 10000000b
-00101010b << 1+6 = 00000000b
-00101010b << 1+7 = 00000000b
-00101011b << 1+0 = 01010110b
-00101011b << 1+1 = 10101100b
-00101011b << 1+2 = 01011000b
-00101011b << 1+3 = 10110000b
-00101011b << 1+4 = 01100000b
-00101011b << 1+5 = 11000000b
-00101011b << 1+6 = 10000000b
-00101011b << 1+7 = 00000000b
-00101100b << 1+0 = 01011000b
-00101100b << 1+1 = 10110000b
-00101100b << 1+2 = 01100000b
-00101100b << 1+3 = 11000000b
-00101100b << 1+4 = 10000000b
-00101100b << 1+5 = 00000000b
-00101100b << 1+6 = 00000000b
-00101100b << 1+7 = 00000000b
-00101101b << 1+0 = 01011010b
-00101101b << 1+1 = 10110100b
-00101101b << 1+2 = 01101000b
-00101101b << 1+3 = 11010000b
-00101101b << 1+4 = 10100000b
-00101101b << 1+5 = 01000000b
-00101101b << 1+6 = 10000000b
-00101101b << 1+7 = 00000000b
-00101110b << 1+0 = 01011100b
-00101110b << 1+1 = 10111000b
-00101110b << 1+2 = 01110000b
-00101110b << 1+3 = 11100000b
-00101110b << 1+4 = 11000000b
-00101110b << 1+5 = 10000000b
-00101110b << 1+6 = 00000000b
-00101110b << 1+7 = 00000000b
-00101111b << 1+0 = 01011110b
-00101111b << 1+1 = 10111100b
-00101111b << 1+2 = 01111000b
-00101111b << 1+3 = 11110000b
-00101111b << 1+4 = 11100000b
-00101111b << 1+5 = 11000000b
-00101111b << 1+6 = 10000000b
-00101111b << 1+7 = 00000000b
-00110000b << 1+0 = 01100000b
-00110000b << 1+1 = 11000000b
-00110000b << 1+2 = 10000000b
-00110000b << 1+3 = 00000000b
-00110000b << 1+4 = 00000000b
-00110000b << 1+5 = 00000000b
-00110000b << 1+6 = 00000000b
-00110000b << 1+7 = 00000000b
-00110001b << 1+0 = 01100010b
-00110001b << 1+1 = 11000100b
-00110001b << 1+2 = 10001000b
-00110001b << 1+3 = 00010000b
-00110001b << 1+4 = 00100000b
-00110001b << 1+5 = 01000000b
-00110001b << 1+6 = 10000000b
-00110001b << 1+7 = 00000000b
-00110010b << 1+0 = 01100100b
-00110010b << 1+1 = 11001000b
-00110010b << 1+2 = 10010000b
-00110010b << 1+3 = 00100000b
-00110010b << 1+4 = 01000000b
-00110010b << 1+5 = 10000000b
-00110010b << 1+6 = 00000000b
-00110010b << 1+7 = 00000000b
-00110011b << 1+0 = 01100110b
-00110011b << 1+1 = 11001100b
-00110011b << 1+2 = 10011000b
-00110011b << 1+3 = 00110000b
-00110011b << 1+4 = 01100000b
-00110011b << 1+5 = 11000000b
-00110011b << 1+6 = 10000000b
-00110011b << 1+7 = 00000000b
-00110100b << 1+0 = 01101000b
-00110100b << 1+1 = 11010000b
-00110100b << 1+2 = 10100000b
-00110100b << 1+3 = 01000000b
-00110100b << 1+4 = 10000000b
-00110100b << 1+5 = 00000000b
-00110100b << 1+6 = 00000000b
-00110100b << 1+7 = 00000000b
-00110101b << 1+0 = 01101010b
-00110101b << 1+1 = 11010100b
-00110101b << 1+2 = 10101000b
-00110101b << 1+3 = 01010000b
-00110101b << 1+4 = 10100000b
-00110101b << 1+5 = 01000000b
-00110101b << 1+6 = 10000000b
-00110101b << 1+7 = 00000000b
-00110110b << 1+0 = 01101100b
-00110110b << 1+1 = 11011000b
-00110110b << 1+2 = 10110000b
-00110110b << 1+3 = 01100000b
-00110110b << 1+4 = 11000000b
-00110110b << 1+5 = 10000000b
-00110110b << 1+6 = 00000000b
-00110110b << 1+7 = 00000000b
-00110111b << 1+0 = 01101110b
-00110111b << 1+1 = 11011100b
-00110111b << 1+2 = 10111000b
-00110111b << 1+3 = 01110000b
-00110111b << 1+4 = 11100000b
-00110111b << 1+5 = 11000000b
-00110111b << 1+6 = 10000000b
-00110111b << 1+7 = 00000000b
-00111000b << 1+0 = 01110000b
-00111000b << 1+1 = 11100000b
-00111000b << 1+2 = 11000000b
-00111000b << 1+3 = 10000000b
-00111000b << 1+4 = 00000000b
-00111000b << 1+5 = 00000000b
-00111000b << 1+6 = 00000000b
-00111000b << 1+7 = 00000000b
-00111001b << 1+0 = 01110010b
-00111001b << 1+1 = 11100100b
-00111001b << 1+2 = 11001000b
-00111001b << 1+3 = 10010000b
-00111001b << 1+4 = 00100000b
-00111001b << 1+5 = 01000000b
-00111001b << 1+6 = 10000000b
-00111001b << 1+7 = 00000000b
-00111010b << 1+0 = 01110100b
-00111010b << 1+1 = 11101000b
-00111010b << 1+2 = 11010000b
-00111010b << 1+3 = 10100000b
-00111010b << 1+4 = 01000000b
-00111010b << 1+5 = 10000000b
-00111010b << 1+6 = 00000000b
-00111010b << 1+7 = 00000000b
-00111011b << 1+0 = 01110110b
-00111011b << 1+1 = 11101100b
-00111011b << 1+2 = 11011000b
-00111011b << 1+3 = 10110000b
-00111011b << 1+4 = 01100000b
-00111011b << 1+5 = 11000000b
-00111011b << 1+6 = 10000000b
-00111011b << 1+7 = 00000000b
-00111100b << 1+0 = 01111000b
-00111100b << 1+1 = 11110000b
-00111100b << 1+2 = 11100000b
-00111100b << 1+3 = 11000000b
-00111100b << 1+4 = 10000000b
-00111100b << 1+5 = 00000000b
-00111100b << 1+6 = 00000000b
-00111100b << 1+7 = 00000000b
-00111101b << 1+0 = 01111010b
-00111101b << 1+1 = 11110100b
-00111101b << 1+2 = 11101000b
-00111101b << 1+3 = 11010000b
-00111101b << 1+4 = 10100000b
-00111101b << 1+5 = 01000000b
-00111101b << 1+6 = 10000000b
-00111101b << 1+7 = 00000000b
-00111110b << 1+0 = 01111100b
-00111110b << 1+1 = 11111000b
-00111110b << 1+2 = 11110000b
-00111110b << 1+3 = 11100000b
-00111110b << 1+4 = 11000000b
-00111110b << 1+5 = 10000000b
-00111110b << 1+6 = 00000000b
-00111110b << 1+7 = 00000000b
-00111111b << 1+0 = 01111110b
-00111111b << 1+1 = 11111100b
-00111111b << 1+2 = 11111000b
-00111111b << 1+3 = 11110000b
-00111111b << 1+4 = 11100000b
-00111111b << 1+5 = 11000000b
-00111111b << 1+6 = 10000000b
-00111111b << 1+7 = 00000000b
-01000000b << 1+0 = 10000000b
-01000000b << 1+1 = 00000000b
-01000000b << 1+2 = 00000000b
-01000000b << 1+3 = 00000000b
-01000000b << 1+4 = 00000000b
-01000000b << 1+5 = 00000000b
-01000000b << 1+6 = 00000000b
-01000000b << 1+7 = 00000000b
-01000001b << 1+0 = 10000010b
-01000001b << 1+1 = 00000100b
-01000001b << 1+2 = 00001000b
-01000001b << 1+3 = 00010000b
-01000001b << 1+4 = 00100000b
-01000001b << 1+5 = 01000000b
-01000001b << 1+6 = 10000000b
-01000001b << 1+7 = 00000000b
-01000010b << 1+0 = 10000100b
-01000010b << 1+1 = 00001000b
-01000010b << 1+2 = 00010000b
-01000010b << 1+3 = 00100000b
-01000010b << 1+4 = 01000000b
-01000010b << 1+5 = 10000000b
-01000010b << 1+6 = 00000000b
-01000010b << 1+7 = 00000000b
-01000011b << 1+0 = 10000110b
-01000011b << 1+1 = 00001100b
-01000011b << 1+2 = 00011000b
-01000011b << 1+3 = 00110000b
-01000011b << 1+4 = 01100000b
-01000011b << 1+5 = 11000000b
-01000011b << 1+6 = 10000000b
-01000011b << 1+7 = 00000000b
-01000100b << 1+0 = 10001000b
-01000100b << 1+1 = 00010000b
-01000100b << 1+2 = 00100000b
-01000100b << 1+3 = 01000000b
-01000100b << 1+4 = 10000000b
-01000100b << 1+5 = 00000000b
-01000100b << 1+6 = 00000000b
-01000100b << 1+7 = 00000000b
-01000101b << 1+0 = 10001010b
-01000101b << 1+1 = 00010100b
-01000101b << 1+2 = 00101000b
-01000101b << 1+3 = 01010000b
-01000101b << 1+4 = 10100000b
-01000101b << 1+5 = 01000000b
-01000101b << 1+6 = 10000000b
-01000101b << 1+7 = 00000000b
-01000110b << 1+0 = 10001100b
-01000110b << 1+1 = 00011000b
-01000110b << 1+2 = 00110000b
-01000110b << 1+3 = 01100000b
-01000110b << 1+4 = 11000000b
-01000110b << 1+5 = 10000000b
-01000110b << 1+6 = 00000000b
-01000110b << 1+7 = 00000000b
-01000111b << 1+0 = 10001110b
-01000111b << 1+1 = 00011100b
-01000111b << 1+2 = 00111000b
-01000111b << 1+3 = 01110000b
-01000111b << 1+4 = 11100000b
-01000111b << 1+5 = 11000000b
-01000111b << 1+6 = 10000000b
-01000111b << 1+7 = 00000000b
-01001000b << 1+0 = 10010000b
-01001000b << 1+1 = 00100000b
-01001000b << 1+2 = 01000000b
-01001000b << 1+3 = 10000000b
-01001000b << 1+4 = 00000000b
-01001000b << 1+5 = 00000000b
-01001000b << 1+6 = 00000000b
-01001000b << 1+7 = 00000000b
-01001001b << 1+0 = 10010010b
-01001001b << 1+1 = 00100100b
-01001001b << 1+2 = 01001000b
-01001001b << 1+3 = 10010000b
-01001001b << 1+4 = 00100000b
-01001001b << 1+5 = 01000000b
-01001001b << 1+6 = 10000000b
-01001001b << 1+7 = 00000000b
-01001010b << 1+0 = 10010100b
-01001010b << 1+1 = 00101000b
-01001010b << 1+2 = 01010000b
-01001010b << 1+3 = 10100000b
-01001010b << 1+4 = 01000000b
-01001010b << 1+5 = 10000000b
-01001010b << 1+6 = 00000000b
-01001010b << 1+7 = 00000000b
-01001011b << 1+0 = 10010110b
-01001011b << 1+1 = 00101100b
-01001011b << 1+2 = 01011000b
-01001011b << 1+3 = 10110000b
-01001011b << 1+4 = 01100000b
-01001011b << 1+5 = 11000000b
-01001011b << 1+6 = 10000000b
-01001011b << 1+7 = 00000000b
-01001100b << 1+0 = 10011000b
-01001100b << 1+1 = 00110000b
-01001100b << 1+2 = 01100000b
-01001100b << 1+3 = 11000000b
-01001100b << 1+4 = 10000000b
-01001100b << 1+5 = 00000000b
-01001100b << 1+6 = 00000000b
-01001100b << 1+7 = 00000000b
-01001101b << 1+0 = 10011010b
-01001101b << 1+1 = 00110100b
-01001101b << 1+2 = 01101000b
-01001101b << 1+3 = 11010000b
-01001101b << 1+4 = 10100000b
-01001101b << 1+5 = 01000000b
-01001101b << 1+6 = 10000000b
-01001101b << 1+7 = 00000000b
-01001110b << 1+0 = 10011100b
-01001110b << 1+1 = 00111000b
-01001110b << 1+2 = 01110000b
-01001110b << 1+3 = 11100000b
-01001110b << 1+4 = 11000000b
-01001110b << 1+5 = 10000000b
-01001110b << 1+6 = 00000000b
-01001110b << 1+7 = 00000000b
-01001111b << 1+0 = 10011110b
-01001111b << 1+1 = 00111100b
-01001111b << 1+2 = 01111000b
-01001111b << 1+3 = 11110000b
-01001111b << 1+4 = 11100000b
-01001111b << 1+5 = 11000000b
-01001111b << 1+6 = 10000000b
-01001111b << 1+7 = 00000000b
-01010000b << 1+0 = 10100000b
-01010000b << 1+1 = 01000000b
-01010000b << 1+2 = 10000000b
-01010000b << 1+3 = 00000000b
-01010000b << 1+4 = 00000000b
-01010000b << 1+5 = 00000000b
-01010000b << 1+6 = 00000000b
-01010000b << 1+7 = 00000000b
-01010001b << 1+0 = 10100010b
-01010001b << 1+1 = 01000100b
-01010001b << 1+2 = 10001000b
-01010001b << 1+3 = 00010000b
-01010001b << 1+4 = 00100000b
-01010001b << 1+5 = 01000000b
-01010001b << 1+6 = 10000000b
-01010001b << 1+7 = 00000000b
-01010010b << 1+0 = 10100100b
-01010010b << 1+1 = 01001000b
-01010010b << 1+2 = 10010000b
-01010010b << 1+3 = 00100000b
-01010010b << 1+4 = 01000000b
-01010010b << 1+5 = 10000000b
-01010010b << 1+6 = 00000000b
-01010010b << 1+7 = 00000000b
-01010011b << 1+0 = 10100110b
-01010011b << 1+1 = 01001100b
-01010011b << 1+2 = 10011000b
-01010011b << 1+3 = 00110000b
-01010011b << 1+4 = 01100000b
-01010011b << 1+5 = 11000000b
-01010011b << 1+6 = 10000000b
-01010011b << 1+7 = 00000000b
-01010100b << 1+0 = 10101000b
-01010100b << 1+1 = 01010000b
-01010100b << 1+2 = 10100000b
-01010100b << 1+3 = 01000000b
-01010100b << 1+4 = 10000000b
-01010100b << 1+5 = 00000000b
-01010100b << 1+6 = 00000000b
-01010100b << 1+7 = 00000000b
-01010101b << 1+0 = 10101010b
-01010101b << 1+1 = 01010100b
-01010101b << 1+2 = 10101000b
-01010101b << 1+3 = 01010000b
-01010101b << 1+4 = 10100000b
-01010101b << 1+5 = 01000000b
-01010101b << 1+6 = 10000000b
-01010101b << 1+7 = 00000000b
-01010110b << 1+0 = 10101100b
-01010110b << 1+1 = 01011000b
-01010110b << 1+2 = 10110000b
-01010110b << 1+3 = 01100000b
-01010110b << 1+4 = 11000000b
-01010110b << 1+5 = 10000000b
-01010110b << 1+6 = 00000000b
-01010110b << 1+7 = 00000000b
-01010111b << 1+0 = 10101110b
-01010111b << 1+1 = 01011100b
-01010111b << 1+2 = 10111000b
-01010111b << 1+3 = 01110000b
-01010111b << 1+4 = 11100000b
-01010111b << 1+5 = 11000000b
-01010111b << 1+6 = 10000000b
-01010111b << 1+7 = 00000000b
-01011000b << 1+0 = 10110000b
-01011000b << 1+1 = 01100000b
-01011000b << 1+2 = 11000000b
-01011000b << 1+3 = 10000000b
-01011000b << 1+4 = 00000000b
-01011000b << 1+5 = 00000000b
-01011000b << 1+6 = 00000000b
-01011000b << 1+7 = 00000000b
-01011001b << 1+0 = 10110010b
-01011001b << 1+1 = 01100100b
-01011001b << 1+2 = 11001000b
-01011001b << 1+3 = 10010000b
-01011001b << 1+4 = 00100000b
-01011001b << 1+5 = 01000000b
-01011001b << 1+6 = 10000000b
-01011001b << 1+7 = 00000000b
-01011010b << 1+0 = 10110100b
-01011010b << 1+1 = 01101000b
-01011010b << 1+2 = 11010000b
-01011010b << 1+3 = 10100000b
-01011010b << 1+4 = 01000000b
-01011010b << 1+5 = 10000000b
-01011010b << 1+6 = 00000000b
-01011010b << 1+7 = 00000000b
-01011011b << 1+0 = 10110110b
-01011011b << 1+1 = 01101100b
-01011011b << 1+2 = 11011000b
-01011011b << 1+3 = 10110000b
-01011011b << 1+4 = 01100000b
-01011011b << 1+5 = 11000000b
-01011011b << 1+6 = 10000000b
-01011011b << 1+7 = 00000000b
-01011100b << 1+0 = 10111000b
-01011100b << 1+1 = 01110000b
-01011100b << 1+2 = 11100000b
-01011100b << 1+3 = 11000000b
-01011100b << 1+4 = 10000000b
-01011100b << 1+5 = 00000000b
-01011100b << 1+6 = 00000000b
-01011100b << 1+7 = 00000000b
-01011101b << 1+0 = 10111010b
-01011101b << 1+1 = 01110100b
-01011101b << 1+2 = 11101000b
-01011101b << 1+3 = 11010000b
-01011101b << 1+4 = 10100000b
-01011101b << 1+5 = 01000000b
-01011101b << 1+6 = 10000000b
-01011101b << 1+7 = 00000000b
-01011110b << 1+0 = 10111100b
-01011110b << 1+1 = 01111000b
-01011110b << 1+2 = 11110000b
-01011110b << 1+3 = 11100000b
-01011110b << 1+4 = 11000000b
-01011110b << 1+5 = 10000000b
-01011110b << 1+6 = 00000000b
-01011110b << 1+7 = 00000000b
-01011111b << 1+0 = 10111110b
-01011111b << 1+1 = 01111100b
-01011111b << 1+2 = 11111000b
-01011111b << 1+3 = 11110000b
-01011111b << 1+4 = 11100000b
-01011111b << 1+5 = 11000000b
-01011111b << 1+6 = 10000000b
-01011111b << 1+7 = 00000000b
-01100000b << 1+0 = 11000000b
-01100000b << 1+1 = 10000000b
-01100000b << 1+2 = 00000000b
-01100000b << 1+3 = 00000000b
-01100000b << 1+4 = 00000000b
-01100000b << 1+5 = 00000000b
-01100000b << 1+6 = 00000000b
-01100000b << 1+7 = 00000000b
-01100001b << 1+0 = 11000010b
-01100001b << 1+1 = 10000100b
-01100001b << 1+2 = 00001000b
-01100001b << 1+3 = 00010000b
-01100001b << 1+4 = 00100000b
-01100001b << 1+5 = 01000000b
-01100001b << 1+6 = 10000000b
-01100001b << 1+7 = 00000000b
-01100010b << 1+0 = 11000100b
-01100010b << 1+1 = 10001000b
-01100010b << 1+2 = 00010000b
-01100010b << 1+3 = 00100000b
-01100010b << 1+4 = 01000000b
-01100010b << 1+5 = 10000000b
-01100010b << 1+6 = 00000000b
-01100010b << 1+7 = 00000000b
-01100011b << 1+0 = 11000110b
-01100011b << 1+1 = 10001100b
-01100011b << 1+2 = 00011000b
-01100011b << 1+3 = 00110000b
-01100011b << 1+4 = 01100000b
-01100011b << 1+5 = 11000000b
-01100011b << 1+6 = 10000000b
-01100011b << 1+7 = 00000000b
-01100100b << 1+0 = 11001000b
-01100100b << 1+1 = 10010000b
-01100100b << 1+2 = 00100000b
-01100100b << 1+3 = 01000000b
-01100100b << 1+4 = 10000000b
-01100100b << 1+5 = 00000000b
-01100100b << 1+6 = 00000000b
-01100100b << 1+7 = 00000000b
-01100101b << 1+0 = 11001010b
-01100101b << 1+1 = 10010100b
-01100101b << 1+2 = 00101000b
-01100101b << 1+3 = 01010000b
-01100101b << 1+4 = 10100000b
-01100101b << 1+5 = 01000000b
-01100101b << 1+6 = 10000000b
-01100101b << 1+7 = 00000000b
-01100110b << 1+0 = 11001100b
-01100110b << 1+1 = 10011000b
-01100110b << 1+2 = 00110000b
-01100110b << 1+3 = 01100000b
-01100110b << 1+4 = 11000000b
-01100110b << 1+5 = 10000000b
-01100110b << 1+6 = 00000000b
-01100110b << 1+7 = 00000000b
-01100111b << 1+0 = 11001110b
-01100111b << 1+1 = 10011100b
-01100111b << 1+2 = 00111000b
-01100111b << 1+3 = 01110000b
-01100111b << 1+4 = 11100000b
-01100111b << 1+5 = 11000000b
-01100111b << 1+6 = 10000000b
-01100111b << 1+7 = 00000000b
-01101000b << 1+0 = 11010000b
-01101000b << 1+1 = 10100000b
-01101000b << 1+2 = 01000000b
-01101000b << 1+3 = 10000000b
-01101000b << 1+4 = 00000000b
-01101000b << 1+5 = 00000000b
-01101000b << 1+6 = 00000000b
-01101000b << 1+7 = 00000000b
-01101001b << 1+0 = 11010010b
-01101001b << 1+1 = 10100100b
-01101001b << 1+2 = 01001000b
-01101001b << 1+3 = 10010000b
-01101001b << 1+4 = 00100000b
-01101001b << 1+5 = 01000000b
-01101001b << 1+6 = 10000000b
-01101001b << 1+7 = 00000000b
-01101010b << 1+0 = 11010100b
-01101010b << 1+1 = 10101000b
-01101010b << 1+2 = 01010000b
-01101010b << 1+3 = 10100000b
-01101010b << 1+4 = 01000000b
-01101010b << 1+5 = 10000000b
-01101010b << 1+6 = 00000000b
-01101010b << 1+7 = 00000000b
-01101011b << 1+0 = 11010110b
-01101011b << 1+1 = 10101100b
-01101011b << 1+2 = 01011000b
-01101011b << 1+3 = 10110000b
-01101011b << 1+4 = 01100000b
-01101011b << 1+5 = 11000000b
-01101011b << 1+6 = 10000000b
-01101011b << 1+7 = 00000000b
-01101100b << 1+0 = 11011000b
-01101100b << 1+1 = 10110000b
-01101100b << 1+2 = 01100000b
-01101100b << 1+3 = 11000000b
-01101100b << 1+4 = 10000000b
-01101100b << 1+5 = 00000000b
-01101100b << 1+6 = 00000000b
-01101100b << 1+7 = 00000000b
-01101101b << 1+0 = 11011010b
-01101101b << 1+1 = 10110100b
-01101101b << 1+2 = 01101000b
-01101101b << 1+3 = 11010000b
-01101101b << 1+4 = 10100000b
-01101101b << 1+5 = 01000000b
-01101101b << 1+6 = 10000000b
-01101101b << 1+7 = 00000000b
-01101110b << 1+0 = 11011100b
-01101110b << 1+1 = 10111000b
-01101110b << 1+2 = 01110000b
-01101110b << 1+3 = 11100000b
-01101110b << 1+4 = 11000000b
-01101110b << 1+5 = 10000000b
-01101110b << 1+6 = 00000000b
-01101110b << 1+7 = 00000000b
-01101111b << 1+0 = 11011110b
-01101111b << 1+1 = 10111100b
-01101111b << 1+2 = 01111000b
-01101111b << 1+3 = 11110000b
-01101111b << 1+4 = 11100000b
-01101111b << 1+5 = 11000000b
-01101111b << 1+6 = 10000000b
-01101111b << 1+7 = 00000000b
-01110000b << 1+0 = 11100000b
-01110000b << 1+1 = 11000000b
-01110000b << 1+2 = 10000000b
-01110000b << 1+3 = 00000000b
-01110000b << 1+4 = 00000000b
-01110000b << 1+5 = 00000000b
-01110000b << 1+6 = 00000000b
-01110000b << 1+7 = 00000000b
-01110001b << 1+0 = 11100010b
-01110001b << 1+1 = 11000100b
-01110001b << 1+2 = 10001000b
-01110001b << 1+3 = 00010000b
-01110001b << 1+4 = 00100000b
-01110001b << 1+5 = 01000000b
-01110001b << 1+6 = 10000000b
-01110001b << 1+7 = 00000000b
-01110010b << 1+0 = 11100100b
-01110010b << 1+1 = 11001000b
-01110010b << 1+2 = 10010000b
-01110010b << 1+3 = 00100000b
-01110010b << 1+4 = 01000000b
-01110010b << 1+5 = 10000000b
-01110010b << 1+6 = 00000000b
-01110010b << 1+7 = 00000000b
-01110011b << 1+0 = 11100110b
-01110011b << 1+1 = 11001100b
-01110011b << 1+2 = 10011000b
-01110011b << 1+3 = 00110000b
-01110011b << 1+4 = 01100000b
-01110011b << 1+5 = 11000000b
-01110011b << 1+6 = 10000000b
-01110011b << 1+7 = 00000000b
-01110100b << 1+0 = 11101000b
-01110100b << 1+1 = 11010000b
-01110100b << 1+2 = 10100000b
-01110100b << 1+3 = 01000000b
-01110100b << 1+4 = 10000000b
-01110100b << 1+5 = 00000000b
-01110100b << 1+6 = 00000000b
-01110100b << 1+7 = 00000000b
-01110101b << 1+0 = 11101010b
-01110101b << 1+1 = 11010100b
-01110101b << 1+2 = 10101000b
-01110101b << 1+3 = 01010000b
-01110101b << 1+4 = 10100000b
-01110101b << 1+5 = 01000000b
-01110101b << 1+6 = 10000000b
-01110101b << 1+7 = 00000000b
-01110110b << 1+0 = 11101100b
-01110110b << 1+1 = 11011000b
-01110110b << 1+2 = 10110000b
-01110110b << 1+3 = 01100000b
-01110110b << 1+4 = 11000000b
-01110110b << 1+5 = 10000000b
-01110110b << 1+6 = 00000000b
-01110110b << 1+7 = 00000000b
-01110111b << 1+0 = 11101110b
-01110111b << 1+1 = 11011100b
-01110111b << 1+2 = 10111000b
-01110111b << 1+3 = 01110000b
-01110111b << 1+4 = 11100000b
-01110111b << 1+5 = 11000000b
-01110111b << 1+6 = 10000000b
-01110111b << 1+7 = 00000000b
-01111000b << 1+0 = 11110000b
-01111000b << 1+1 = 11100000b
-01111000b << 1+2 = 11000000b
-01111000b << 1+3 = 10000000b
-01111000b << 1+4 = 00000000b
-01111000b << 1+5 = 00000000b
-01111000b << 1+6 = 00000000b
-01111000b << 1+7 = 00000000b
-01111001b << 1+0 = 11110010b
-01111001b << 1+1 = 11100100b
-01111001b << 1+2 = 11001000b
-01111001b << 1+3 = 10010000b
-01111001b << 1+4 = 00100000b
-01111001b << 1+5 = 01000000b
-01111001b << 1+6 = 10000000b
-01111001b << 1+7 = 00000000b
-01111010b << 1+0 = 11110100b
-01111010b << 1+1 = 11101000b
-01111010b << 1+2 = 11010000b
-01111010b << 1+3 = 10100000b
-01111010b << 1+4 = 01000000b
-01111010b << 1+5 = 10000000b
-01111010b << 1+6 = 00000000b
-01111010b << 1+7 = 00000000b
-01111011b << 1+0 = 11110110b
-01111011b << 1+1 = 11101100b
-01111011b << 1+2 = 11011000b
-01111011b << 1+3 = 10110000b
-01111011b << 1+4 = 01100000b
-01111011b << 1+5 = 11000000b
-01111011b << 1+6 = 10000000b
-01111011b << 1+7 = 00000000b
-01111100b << 1+0 = 11111000b
-01111100b << 1+1 = 11110000b
-01111100b << 1+2 = 11100000b
-01111100b << 1+3 = 11000000b
-01111100b << 1+4 = 10000000b
-01111100b << 1+5 = 00000000b
-01111100b << 1+6 = 00000000b
-01111100b << 1+7 = 00000000b
-01111101b << 1+0 = 11111010b
-01111101b << 1+1 = 11110100b
-01111101b << 1+2 = 11101000b
-01111101b << 1+3 = 11010000b
-01111101b << 1+4 = 10100000b
-01111101b << 1+5 = 01000000b
-01111101b << 1+6 = 10000000b
-01111101b << 1+7 = 00000000b
-01111110b << 1+0 = 11111100b
-01111110b << 1+1 = 11111000b
-01111110b << 1+2 = 11110000b
-01111110b << 1+3 = 11100000b
-01111110b << 1+4 = 11000000b
-01111110b << 1+5 = 10000000b
-01111110b << 1+6 = 00000000b
-01111110b << 1+7 = 00000000b
diff --git a/tests/valid/Byte_Valid_8.whiley b/tests/valid/Byte_Valid_8.whiley
index 316838f863..30eaf3bb07 100644
--- a/tests/valid/Byte_Valid_8.whiley
+++ b/tests/valid/Byte_Valid_8.whiley
@@ -1,11 +1,21 @@
-import whiley.lang.*
-import print from whiley.lang.*
+
constant constants is [10000000b, 10000001b, 10000010b, 10000011b, 10000100b, 10000101b, 10000110b, 10000111b, 10001000b, 10001001b, 10001010b, 10001011b, 10001100b, 10001101b, 10001110b, 10001111b, 10010000b, 10010001b, 10010010b, 10010011b, 10010100b, 10010101b, 10010110b, 10010111b, 10011000b, 10011001b, 10011010b, 10011011b, 10011100b, 10011101b, 10011110b, 10011111b, 10100000b, 10100001b, 10100010b, 10100011b, 10100100b, 10100101b, 10100110b, 10100111b, 10101000b, 10101001b, 10101010b, 10101011b, 10101100b, 10101101b, 10101110b, 10101111b, 10110000b, 10110001b, 10110010b, 10110011b, 10110100b, 10110101b, 10110110b, 10110111b, 10111000b, 10111001b, 10111010b, 10111011b, 10111100b, 10111101b, 10111110b, 10111111b, 11000000b, 11000001b, 11000010b, 11000011b, 11000100b, 11000101b, 11000110b, 11000111b, 11001000b, 11001001b, 11001010b, 11001011b, 11001100b, 11001101b, 11001110b, 11001111b, 11010000b, 11010001b, 11010010b, 11010011b, 11010100b, 11010101b, 11010110b, 11010111b, 11011000b, 11011001b, 11011010b, 11011011b, 11011100b, 11011101b, 11011110b, 11011111b, 11100000b, 11100001b, 11100010b, 11100011b, 11100100b, 11100101b, 11100110b, 11100111b, 11101000b, 11101001b, 11101010b, 11101011b, 11101100b, 11101101b, 11101110b, 11101111b, 11110000b, 11110001b, 11110010b, 11110011b, 11110100b, 11110101b, 11110110b, 11110111b, 11111000b, 11111001b, 11111010b, 11111011b, 11111100b, 11111101b, 11111110b, 11111111b, 00000000b, 00000001b, 00000010b, 00000011b, 00000100b, 00000101b, 00000110b, 00000111b, 00001000b, 00001001b, 00001010b, 00001011b, 00001100b, 00001101b, 00001110b, 00001111b, 00010000b, 00010001b, 00010010b, 00010011b, 00010100b, 00010101b, 00010110b, 00010111b, 00011000b, 00011001b, 00011010b, 00011011b, 00011100b, 00011101b, 00011110b, 00011111b, 00100000b, 00100001b, 00100010b, 00100011b, 00100100b, 00100101b, 00100110b, 00100111b, 00101000b, 00101001b, 00101010b, 00101011b, 00101100b, 00101101b, 00101110b, 00101111b, 00110000b, 00110001b, 00110010b, 00110011b, 00110100b, 00110101b, 00110110b, 00110111b, 00111000b, 00111001b, 00111010b, 00111011b, 00111100b, 00111101b, 00111110b, 00111111b, 01000000b, 01000001b, 01000010b, 01000011b, 01000100b, 01000101b, 01000110b, 01000111b, 01001000b, 01001001b, 01001010b, 01001011b, 01001100b, 01001101b, 01001110b, 01001111b, 01010000b, 01010001b, 01010010b, 01010011b, 01010100b, 01010101b, 01010110b, 01010111b, 01011000b, 01011001b, 01011010b, 01011011b, 01011100b, 01011101b, 01011110b, 01011111b, 01100000b, 01100001b, 01100010b, 01100011b, 01100100b, 01100101b, 01100110b, 01100111b, 01101000b, 01101001b, 01101010b, 01101011b, 01101100b, 01101101b, 01101110b, 01101111b, 01110000b, 01110001b, 01110010b, 01110011b, 01110100b, 01110101b, 01110110b, 01110111b, 01111000b, 01111001b, 01111010b, 01111011b, 01111100b, 01111101b, 01111110b]
-public method main(System.Console sys) -> void:
- for i in constants:
- for j in 0 .. 8:
- sys.out.print_s(Any.toString(i) ++ " << ")
- sys.out.print_s("1+" ++ Any.toString(j) ++ " = ")
- sys.out.println_s(Any.toString(i << (1 + j)))
+
+function shr(byte b, int i) -> byte:
+ while i > 0:
+ b = b << 1
+ i = i - 1
+ return b
+
+public export method test() -> void:
+ int i = 0
+ while i < |constants|:
+ byte constant_i = constants[i]
+ int j = 0
+ while j < 9:
+ assume (constant_i << 1+j) == shr(constant_i,1+j)
+ j = j + 1
+ //
+ i = i + 1
diff --git a/tests/valid/Byte_Valid_9.sysout b/tests/valid/Byte_Valid_9.sysout
deleted file mode 100644
index 7b55f88ee0..0000000000
--- a/tests/valid/Byte_Valid_9.sysout
+++ /dev/null
@@ -1,2040 +0,0 @@
-10000000b & 10101010b << 0 = 10000000b
-10000000b & 10101010b << 1 = 00000000b
-10000000b & 10101010b << 2 = 10000000b
-10000000b & 10101010b << 3 = 00000000b
-10000000b & 10101010b << 4 = 10000000b
-10000000b & 10101010b << 5 = 00000000b
-10000000b & 10101010b << 6 = 10000000b
-10000000b & 10101010b << 7 = 00000000b
-10000001b & 10101010b << 0 = 10000000b
-10000001b & 10101010b << 1 = 00000000b
-10000001b & 10101010b << 2 = 10000000b
-10000001b & 10101010b << 3 = 00000000b
-10000001b & 10101010b << 4 = 10000000b
-10000001b & 10101010b << 5 = 00000000b
-10000001b & 10101010b << 6 = 10000000b
-10000001b & 10101010b << 7 = 00000000b
-10000010b & 10101010b << 0 = 10000010b
-10000010b & 10101010b << 1 = 00000000b
-10000010b & 10101010b << 2 = 10000000b
-10000010b & 10101010b << 3 = 00000000b
-10000010b & 10101010b << 4 = 10000000b
-10000010b & 10101010b << 5 = 00000000b
-10000010b & 10101010b << 6 = 10000000b
-10000010b & 10101010b << 7 = 00000000b
-10000011b & 10101010b << 0 = 10000010b
-10000011b & 10101010b << 1 = 00000000b
-10000011b & 10101010b << 2 = 10000000b
-10000011b & 10101010b << 3 = 00000000b
-10000011b & 10101010b << 4 = 10000000b
-10000011b & 10101010b << 5 = 00000000b
-10000011b & 10101010b << 6 = 10000000b
-10000011b & 10101010b << 7 = 00000000b
-10000100b & 10101010b << 0 = 10000000b
-10000100b & 10101010b << 1 = 00000100b
-10000100b & 10101010b << 2 = 10000000b
-10000100b & 10101010b << 3 = 00000000b
-10000100b & 10101010b << 4 = 10000000b
-10000100b & 10101010b << 5 = 00000000b
-10000100b & 10101010b << 6 = 10000000b
-10000100b & 10101010b << 7 = 00000000b
-10000101b & 10101010b << 0 = 10000000b
-10000101b & 10101010b << 1 = 00000100b
-10000101b & 10101010b << 2 = 10000000b
-10000101b & 10101010b << 3 = 00000000b
-10000101b & 10101010b << 4 = 10000000b
-10000101b & 10101010b << 5 = 00000000b
-10000101b & 10101010b << 6 = 10000000b
-10000101b & 10101010b << 7 = 00000000b
-10000110b & 10101010b << 0 = 10000010b
-10000110b & 10101010b << 1 = 00000100b
-10000110b & 10101010b << 2 = 10000000b
-10000110b & 10101010b << 3 = 00000000b
-10000110b & 10101010b << 4 = 10000000b
-10000110b & 10101010b << 5 = 00000000b
-10000110b & 10101010b << 6 = 10000000b
-10000110b & 10101010b << 7 = 00000000b
-10000111b & 10101010b << 0 = 10000010b
-10000111b & 10101010b << 1 = 00000100b
-10000111b & 10101010b << 2 = 10000000b
-10000111b & 10101010b << 3 = 00000000b
-10000111b & 10101010b << 4 = 10000000b
-10000111b & 10101010b << 5 = 00000000b
-10000111b & 10101010b << 6 = 10000000b
-10000111b & 10101010b << 7 = 00000000b
-10001000b & 10101010b << 0 = 10001000b
-10001000b & 10101010b << 1 = 00000000b
-10001000b & 10101010b << 2 = 10001000b
-10001000b & 10101010b << 3 = 00000000b
-10001000b & 10101010b << 4 = 10000000b
-10001000b & 10101010b << 5 = 00000000b
-10001000b & 10101010b << 6 = 10000000b
-10001000b & 10101010b << 7 = 00000000b
-10001001b & 10101010b << 0 = 10001000b
-10001001b & 10101010b << 1 = 00000000b
-10001001b & 10101010b << 2 = 10001000b
-10001001b & 10101010b << 3 = 00000000b
-10001001b & 10101010b << 4 = 10000000b
-10001001b & 10101010b << 5 = 00000000b
-10001001b & 10101010b << 6 = 10000000b
-10001001b & 10101010b << 7 = 00000000b
-10001010b & 10101010b << 0 = 10001010b
-10001010b & 10101010b << 1 = 00000000b
-10001010b & 10101010b << 2 = 10001000b
-10001010b & 10101010b << 3 = 00000000b
-10001010b & 10101010b << 4 = 10000000b
-10001010b & 10101010b << 5 = 00000000b
-10001010b & 10101010b << 6 = 10000000b
-10001010b & 10101010b << 7 = 00000000b
-10001011b & 10101010b << 0 = 10001010b
-10001011b & 10101010b << 1 = 00000000b
-10001011b & 10101010b << 2 = 10001000b
-10001011b & 10101010b << 3 = 00000000b
-10001011b & 10101010b << 4 = 10000000b
-10001011b & 10101010b << 5 = 00000000b
-10001011b & 10101010b << 6 = 10000000b
-10001011b & 10101010b << 7 = 00000000b
-10001100b & 10101010b << 0 = 10001000b
-10001100b & 10101010b << 1 = 00000100b
-10001100b & 10101010b << 2 = 10001000b
-10001100b & 10101010b << 3 = 00000000b
-10001100b & 10101010b << 4 = 10000000b
-10001100b & 10101010b << 5 = 00000000b
-10001100b & 10101010b << 6 = 10000000b
-10001100b & 10101010b << 7 = 00000000b
-10001101b & 10101010b << 0 = 10001000b
-10001101b & 10101010b << 1 = 00000100b
-10001101b & 10101010b << 2 = 10001000b
-10001101b & 10101010b << 3 = 00000000b
-10001101b & 10101010b << 4 = 10000000b
-10001101b & 10101010b << 5 = 00000000b
-10001101b & 10101010b << 6 = 10000000b
-10001101b & 10101010b << 7 = 00000000b
-10001110b & 10101010b << 0 = 10001010b
-10001110b & 10101010b << 1 = 00000100b
-10001110b & 10101010b << 2 = 10001000b
-10001110b & 10101010b << 3 = 00000000b
-10001110b & 10101010b << 4 = 10000000b
-10001110b & 10101010b << 5 = 00000000b
-10001110b & 10101010b << 6 = 10000000b
-10001110b & 10101010b << 7 = 00000000b
-10001111b & 10101010b << 0 = 10001010b
-10001111b & 10101010b << 1 = 00000100b
-10001111b & 10101010b << 2 = 10001000b
-10001111b & 10101010b << 3 = 00000000b
-10001111b & 10101010b << 4 = 10000000b
-10001111b & 10101010b << 5 = 00000000b
-10001111b & 10101010b << 6 = 10000000b
-10001111b & 10101010b << 7 = 00000000b
-10010000b & 10101010b << 0 = 10000000b
-10010000b & 10101010b << 1 = 00010000b
-10010000b & 10101010b << 2 = 10000000b
-10010000b & 10101010b << 3 = 00010000b
-10010000b & 10101010b << 4 = 10000000b
-10010000b & 10101010b << 5 = 00000000b
-10010000b & 10101010b << 6 = 10000000b
-10010000b & 10101010b << 7 = 00000000b
-10010001b & 10101010b << 0 = 10000000b
-10010001b & 10101010b << 1 = 00010000b
-10010001b & 10101010b << 2 = 10000000b
-10010001b & 10101010b << 3 = 00010000b
-10010001b & 10101010b << 4 = 10000000b
-10010001b & 10101010b << 5 = 00000000b
-10010001b & 10101010b << 6 = 10000000b
-10010001b & 10101010b << 7 = 00000000b
-10010010b & 10101010b << 0 = 10000010b
-10010010b & 10101010b << 1 = 00010000b
-10010010b & 10101010b << 2 = 10000000b
-10010010b & 10101010b << 3 = 00010000b
-10010010b & 10101010b << 4 = 10000000b
-10010010b & 10101010b << 5 = 00000000b
-10010010b & 10101010b << 6 = 10000000b
-10010010b & 10101010b << 7 = 00000000b
-10010011b & 10101010b << 0 = 10000010b
-10010011b & 10101010b << 1 = 00010000b
-10010011b & 10101010b << 2 = 10000000b
-10010011b & 10101010b << 3 = 00010000b
-10010011b & 10101010b << 4 = 10000000b
-10010011b & 10101010b << 5 = 00000000b
-10010011b & 10101010b << 6 = 10000000b
-10010011b & 10101010b << 7 = 00000000b
-10010100b & 10101010b << 0 = 10000000b
-10010100b & 10101010b << 1 = 00010100b
-10010100b & 10101010b << 2 = 10000000b
-10010100b & 10101010b << 3 = 00010000b
-10010100b & 10101010b << 4 = 10000000b
-10010100b & 10101010b << 5 = 00000000b
-10010100b & 10101010b << 6 = 10000000b
-10010100b & 10101010b << 7 = 00000000b
-10010101b & 10101010b << 0 = 10000000b
-10010101b & 10101010b << 1 = 00010100b
-10010101b & 10101010b << 2 = 10000000b
-10010101b & 10101010b << 3 = 00010000b
-10010101b & 10101010b << 4 = 10000000b
-10010101b & 10101010b << 5 = 00000000b
-10010101b & 10101010b << 6 = 10000000b
-10010101b & 10101010b << 7 = 00000000b
-10010110b & 10101010b << 0 = 10000010b
-10010110b & 10101010b << 1 = 00010100b
-10010110b & 10101010b << 2 = 10000000b
-10010110b & 10101010b << 3 = 00010000b
-10010110b & 10101010b << 4 = 10000000b
-10010110b & 10101010b << 5 = 00000000b
-10010110b & 10101010b << 6 = 10000000b
-10010110b & 10101010b << 7 = 00000000b
-10010111b & 10101010b << 0 = 10000010b
-10010111b & 10101010b << 1 = 00010100b
-10010111b & 10101010b << 2 = 10000000b
-10010111b & 10101010b << 3 = 00010000b
-10010111b & 10101010b << 4 = 10000000b
-10010111b & 10101010b << 5 = 00000000b
-10010111b & 10101010b << 6 = 10000000b
-10010111b & 10101010b << 7 = 00000000b
-10011000b & 10101010b << 0 = 10001000b
-10011000b & 10101010b << 1 = 00010000b
-10011000b & 10101010b << 2 = 10001000b
-10011000b & 10101010b << 3 = 00010000b
-10011000b & 10101010b << 4 = 10000000b
-10011000b & 10101010b << 5 = 00000000b
-10011000b & 10101010b << 6 = 10000000b
-10011000b & 10101010b << 7 = 00000000b
-10011001b & 10101010b << 0 = 10001000b
-10011001b & 10101010b << 1 = 00010000b
-10011001b & 10101010b << 2 = 10001000b
-10011001b & 10101010b << 3 = 00010000b
-10011001b & 10101010b << 4 = 10000000b
-10011001b & 10101010b << 5 = 00000000b
-10011001b & 10101010b << 6 = 10000000b
-10011001b & 10101010b << 7 = 00000000b
-10011010b & 10101010b << 0 = 10001010b
-10011010b & 10101010b << 1 = 00010000b
-10011010b & 10101010b << 2 = 10001000b
-10011010b & 10101010b << 3 = 00010000b
-10011010b & 10101010b << 4 = 10000000b
-10011010b & 10101010b << 5 = 00000000b
-10011010b & 10101010b << 6 = 10000000b
-10011010b & 10101010b << 7 = 00000000b
-10011011b & 10101010b << 0 = 10001010b
-10011011b & 10101010b << 1 = 00010000b
-10011011b & 10101010b << 2 = 10001000b
-10011011b & 10101010b << 3 = 00010000b
-10011011b & 10101010b << 4 = 10000000b
-10011011b & 10101010b << 5 = 00000000b
-10011011b & 10101010b << 6 = 10000000b
-10011011b & 10101010b << 7 = 00000000b
-10011100b & 10101010b << 0 = 10001000b
-10011100b & 10101010b << 1 = 00010100b
-10011100b & 10101010b << 2 = 10001000b
-10011100b & 10101010b << 3 = 00010000b
-10011100b & 10101010b << 4 = 10000000b
-10011100b & 10101010b << 5 = 00000000b
-10011100b & 10101010b << 6 = 10000000b
-10011100b & 10101010b << 7 = 00000000b
-10011101b & 10101010b << 0 = 10001000b
-10011101b & 10101010b << 1 = 00010100b
-10011101b & 10101010b << 2 = 10001000b
-10011101b & 10101010b << 3 = 00010000b
-10011101b & 10101010b << 4 = 10000000b
-10011101b & 10101010b << 5 = 00000000b
-10011101b & 10101010b << 6 = 10000000b
-10011101b & 10101010b << 7 = 00000000b
-10011110b & 10101010b << 0 = 10001010b
-10011110b & 10101010b << 1 = 00010100b
-10011110b & 10101010b << 2 = 10001000b
-10011110b & 10101010b << 3 = 00010000b
-10011110b & 10101010b << 4 = 10000000b
-10011110b & 10101010b << 5 = 00000000b
-10011110b & 10101010b << 6 = 10000000b
-10011110b & 10101010b << 7 = 00000000b
-10011111b & 10101010b << 0 = 10001010b
-10011111b & 10101010b << 1 = 00010100b
-10011111b & 10101010b << 2 = 10001000b
-10011111b & 10101010b << 3 = 00010000b
-10011111b & 10101010b << 4 = 10000000b
-10011111b & 10101010b << 5 = 00000000b
-10011111b & 10101010b << 6 = 10000000b
-10011111b & 10101010b << 7 = 00000000b
-10100000b & 10101010b << 0 = 10100000b
-10100000b & 10101010b << 1 = 00000000b
-10100000b & 10101010b << 2 = 10100000b
-10100000b & 10101010b << 3 = 00000000b
-10100000b & 10101010b << 4 = 10100000b
-10100000b & 10101010b << 5 = 00000000b
-10100000b & 10101010b << 6 = 10000000b
-10100000b & 10101010b << 7 = 00000000b
-10100001b & 10101010b << 0 = 10100000b
-10100001b & 10101010b << 1 = 00000000b
-10100001b & 10101010b << 2 = 10100000b
-10100001b & 10101010b << 3 = 00000000b
-10100001b & 10101010b << 4 = 10100000b
-10100001b & 10101010b << 5 = 00000000b
-10100001b & 10101010b << 6 = 10000000b
-10100001b & 10101010b << 7 = 00000000b
-10100010b & 10101010b << 0 = 10100010b
-10100010b & 10101010b << 1 = 00000000b
-10100010b & 10101010b << 2 = 10100000b
-10100010b & 10101010b << 3 = 00000000b
-10100010b & 10101010b << 4 = 10100000b
-10100010b & 10101010b << 5 = 00000000b
-10100010b & 10101010b << 6 = 10000000b
-10100010b & 10101010b << 7 = 00000000b
-10100011b & 10101010b << 0 = 10100010b
-10100011b & 10101010b << 1 = 00000000b
-10100011b & 10101010b << 2 = 10100000b
-10100011b & 10101010b << 3 = 00000000b
-10100011b & 10101010b << 4 = 10100000b
-10100011b & 10101010b << 5 = 00000000b
-10100011b & 10101010b << 6 = 10000000b
-10100011b & 10101010b << 7 = 00000000b
-10100100b & 10101010b << 0 = 10100000b
-10100100b & 10101010b << 1 = 00000100b
-10100100b & 10101010b << 2 = 10100000b
-10100100b & 10101010b << 3 = 00000000b
-10100100b & 10101010b << 4 = 10100000b
-10100100b & 10101010b << 5 = 00000000b
-10100100b & 10101010b << 6 = 10000000b
-10100100b & 10101010b << 7 = 00000000b
-10100101b & 10101010b << 0 = 10100000b
-10100101b & 10101010b << 1 = 00000100b
-10100101b & 10101010b << 2 = 10100000b
-10100101b & 10101010b << 3 = 00000000b
-10100101b & 10101010b << 4 = 10100000b
-10100101b & 10101010b << 5 = 00000000b
-10100101b & 10101010b << 6 = 10000000b
-10100101b & 10101010b << 7 = 00000000b
-10100110b & 10101010b << 0 = 10100010b
-10100110b & 10101010b << 1 = 00000100b
-10100110b & 10101010b << 2 = 10100000b
-10100110b & 10101010b << 3 = 00000000b
-10100110b & 10101010b << 4 = 10100000b
-10100110b & 10101010b << 5 = 00000000b
-10100110b & 10101010b << 6 = 10000000b
-10100110b & 10101010b << 7 = 00000000b
-10100111b & 10101010b << 0 = 10100010b
-10100111b & 10101010b << 1 = 00000100b
-10100111b & 10101010b << 2 = 10100000b
-10100111b & 10101010b << 3 = 00000000b
-10100111b & 10101010b << 4 = 10100000b
-10100111b & 10101010b << 5 = 00000000b
-10100111b & 10101010b << 6 = 10000000b
-10100111b & 10101010b << 7 = 00000000b
-10101000b & 10101010b << 0 = 10101000b
-10101000b & 10101010b << 1 = 00000000b
-10101000b & 10101010b << 2 = 10101000b
-10101000b & 10101010b << 3 = 00000000b
-10101000b & 10101010b << 4 = 10100000b
-10101000b & 10101010b << 5 = 00000000b
-10101000b & 10101010b << 6 = 10000000b
-10101000b & 10101010b << 7 = 00000000b
-10101001b & 10101010b << 0 = 10101000b
-10101001b & 10101010b << 1 = 00000000b
-10101001b & 10101010b << 2 = 10101000b
-10101001b & 10101010b << 3 = 00000000b
-10101001b & 10101010b << 4 = 10100000b
-10101001b & 10101010b << 5 = 00000000b
-10101001b & 10101010b << 6 = 10000000b
-10101001b & 10101010b << 7 = 00000000b
-10101010b & 10101010b << 0 = 10101010b
-10101010b & 10101010b << 1 = 00000000b
-10101010b & 10101010b << 2 = 10101000b
-10101010b & 10101010b << 3 = 00000000b
-10101010b & 10101010b << 4 = 10100000b
-10101010b & 10101010b << 5 = 00000000b
-10101010b & 10101010b << 6 = 10000000b
-10101010b & 10101010b << 7 = 00000000b
-10101011b & 10101010b << 0 = 10101010b
-10101011b & 10101010b << 1 = 00000000b
-10101011b & 10101010b << 2 = 10101000b
-10101011b & 10101010b << 3 = 00000000b
-10101011b & 10101010b << 4 = 10100000b
-10101011b & 10101010b << 5 = 00000000b
-10101011b & 10101010b << 6 = 10000000b
-10101011b & 10101010b << 7 = 00000000b
-10101100b & 10101010b << 0 = 10101000b
-10101100b & 10101010b << 1 = 00000100b
-10101100b & 10101010b << 2 = 10101000b
-10101100b & 10101010b << 3 = 00000000b
-10101100b & 10101010b << 4 = 10100000b
-10101100b & 10101010b << 5 = 00000000b
-10101100b & 10101010b << 6 = 10000000b
-10101100b & 10101010b << 7 = 00000000b
-10101101b & 10101010b << 0 = 10101000b
-10101101b & 10101010b << 1 = 00000100b
-10101101b & 10101010b << 2 = 10101000b
-10101101b & 10101010b << 3 = 00000000b
-10101101b & 10101010b << 4 = 10100000b
-10101101b & 10101010b << 5 = 00000000b
-10101101b & 10101010b << 6 = 10000000b
-10101101b & 10101010b << 7 = 00000000b
-10101110b & 10101010b << 0 = 10101010b
-10101110b & 10101010b << 1 = 00000100b
-10101110b & 10101010b << 2 = 10101000b
-10101110b & 10101010b << 3 = 00000000b
-10101110b & 10101010b << 4 = 10100000b
-10101110b & 10101010b << 5 = 00000000b
-10101110b & 10101010b << 6 = 10000000b
-10101110b & 10101010b << 7 = 00000000b
-10101111b & 10101010b << 0 = 10101010b
-10101111b & 10101010b << 1 = 00000100b
-10101111b & 10101010b << 2 = 10101000b
-10101111b & 10101010b << 3 = 00000000b
-10101111b & 10101010b << 4 = 10100000b
-10101111b & 10101010b << 5 = 00000000b
-10101111b & 10101010b << 6 = 10000000b
-10101111b & 10101010b << 7 = 00000000b
-10110000b & 10101010b << 0 = 10100000b
-10110000b & 10101010b << 1 = 00010000b
-10110000b & 10101010b << 2 = 10100000b
-10110000b & 10101010b << 3 = 00010000b
-10110000b & 10101010b << 4 = 10100000b
-10110000b & 10101010b << 5 = 00000000b
-10110000b & 10101010b << 6 = 10000000b
-10110000b & 10101010b << 7 = 00000000b
-10110001b & 10101010b << 0 = 10100000b
-10110001b & 10101010b << 1 = 00010000b
-10110001b & 10101010b << 2 = 10100000b
-10110001b & 10101010b << 3 = 00010000b
-10110001b & 10101010b << 4 = 10100000b
-10110001b & 10101010b << 5 = 00000000b
-10110001b & 10101010b << 6 = 10000000b
-10110001b & 10101010b << 7 = 00000000b
-10110010b & 10101010b << 0 = 10100010b
-10110010b & 10101010b << 1 = 00010000b
-10110010b & 10101010b << 2 = 10100000b
-10110010b & 10101010b << 3 = 00010000b
-10110010b & 10101010b << 4 = 10100000b
-10110010b & 10101010b << 5 = 00000000b
-10110010b & 10101010b << 6 = 10000000b
-10110010b & 10101010b << 7 = 00000000b
-10110011b & 10101010b << 0 = 10100010b
-10110011b & 10101010b << 1 = 00010000b
-10110011b & 10101010b << 2 = 10100000b
-10110011b & 10101010b << 3 = 00010000b
-10110011b & 10101010b << 4 = 10100000b
-10110011b & 10101010b << 5 = 00000000b
-10110011b & 10101010b << 6 = 10000000b
-10110011b & 10101010b << 7 = 00000000b
-10110100b & 10101010b << 0 = 10100000b
-10110100b & 10101010b << 1 = 00010100b
-10110100b & 10101010b << 2 = 10100000b
-10110100b & 10101010b << 3 = 00010000b
-10110100b & 10101010b << 4 = 10100000b
-10110100b & 10101010b << 5 = 00000000b
-10110100b & 10101010b << 6 = 10000000b
-10110100b & 10101010b << 7 = 00000000b
-10110101b & 10101010b << 0 = 10100000b
-10110101b & 10101010b << 1 = 00010100b
-10110101b & 10101010b << 2 = 10100000b
-10110101b & 10101010b << 3 = 00010000b
-10110101b & 10101010b << 4 = 10100000b
-10110101b & 10101010b << 5 = 00000000b
-10110101b & 10101010b << 6 = 10000000b
-10110101b & 10101010b << 7 = 00000000b
-10110110b & 10101010b << 0 = 10100010b
-10110110b & 10101010b << 1 = 00010100b
-10110110b & 10101010b << 2 = 10100000b
-10110110b & 10101010b << 3 = 00010000b
-10110110b & 10101010b << 4 = 10100000b
-10110110b & 10101010b << 5 = 00000000b
-10110110b & 10101010b << 6 = 10000000b
-10110110b & 10101010b << 7 = 00000000b
-10110111b & 10101010b << 0 = 10100010b
-10110111b & 10101010b << 1 = 00010100b
-10110111b & 10101010b << 2 = 10100000b
-10110111b & 10101010b << 3 = 00010000b
-10110111b & 10101010b << 4 = 10100000b
-10110111b & 10101010b << 5 = 00000000b
-10110111b & 10101010b << 6 = 10000000b
-10110111b & 10101010b << 7 = 00000000b
-10111000b & 10101010b << 0 = 10101000b
-10111000b & 10101010b << 1 = 00010000b
-10111000b & 10101010b << 2 = 10101000b
-10111000b & 10101010b << 3 = 00010000b
-10111000b & 10101010b << 4 = 10100000b
-10111000b & 10101010b << 5 = 00000000b
-10111000b & 10101010b << 6 = 10000000b
-10111000b & 10101010b << 7 = 00000000b
-10111001b & 10101010b << 0 = 10101000b
-10111001b & 10101010b << 1 = 00010000b
-10111001b & 10101010b << 2 = 10101000b
-10111001b & 10101010b << 3 = 00010000b
-10111001b & 10101010b << 4 = 10100000b
-10111001b & 10101010b << 5 = 00000000b
-10111001b & 10101010b << 6 = 10000000b
-10111001b & 10101010b << 7 = 00000000b
-10111010b & 10101010b << 0 = 10101010b
-10111010b & 10101010b << 1 = 00010000b
-10111010b & 10101010b << 2 = 10101000b
-10111010b & 10101010b << 3 = 00010000b
-10111010b & 10101010b << 4 = 10100000b
-10111010b & 10101010b << 5 = 00000000b
-10111010b & 10101010b << 6 = 10000000b
-10111010b & 10101010b << 7 = 00000000b
-10111011b & 10101010b << 0 = 10101010b
-10111011b & 10101010b << 1 = 00010000b
-10111011b & 10101010b << 2 = 10101000b
-10111011b & 10101010b << 3 = 00010000b
-10111011b & 10101010b << 4 = 10100000b
-10111011b & 10101010b << 5 = 00000000b
-10111011b & 10101010b << 6 = 10000000b
-10111011b & 10101010b << 7 = 00000000b
-10111100b & 10101010b << 0 = 10101000b
-10111100b & 10101010b << 1 = 00010100b
-10111100b & 10101010b << 2 = 10101000b
-10111100b & 10101010b << 3 = 00010000b
-10111100b & 10101010b << 4 = 10100000b
-10111100b & 10101010b << 5 = 00000000b
-10111100b & 10101010b << 6 = 10000000b
-10111100b & 10101010b << 7 = 00000000b
-10111101b & 10101010b << 0 = 10101000b
-10111101b & 10101010b << 1 = 00010100b
-10111101b & 10101010b << 2 = 10101000b
-10111101b & 10101010b << 3 = 00010000b
-10111101b & 10101010b << 4 = 10100000b
-10111101b & 10101010b << 5 = 00000000b
-10111101b & 10101010b << 6 = 10000000b
-10111101b & 10101010b << 7 = 00000000b
-10111110b & 10101010b << 0 = 10101010b
-10111110b & 10101010b << 1 = 00010100b
-10111110b & 10101010b << 2 = 10101000b
-10111110b & 10101010b << 3 = 00010000b
-10111110b & 10101010b << 4 = 10100000b
-10111110b & 10101010b << 5 = 00000000b
-10111110b & 10101010b << 6 = 10000000b
-10111110b & 10101010b << 7 = 00000000b
-10111111b & 10101010b << 0 = 10101010b
-10111111b & 10101010b << 1 = 00010100b
-10111111b & 10101010b << 2 = 10101000b
-10111111b & 10101010b << 3 = 00010000b
-10111111b & 10101010b << 4 = 10100000b
-10111111b & 10101010b << 5 = 00000000b
-10111111b & 10101010b << 6 = 10000000b
-10111111b & 10101010b << 7 = 00000000b
-11000000b & 10101010b << 0 = 10000000b
-11000000b & 10101010b << 1 = 01000000b
-11000000b & 10101010b << 2 = 10000000b
-11000000b & 10101010b << 3 = 01000000b
-11000000b & 10101010b << 4 = 10000000b
-11000000b & 10101010b << 5 = 01000000b
-11000000b & 10101010b << 6 = 10000000b
-11000000b & 10101010b << 7 = 00000000b
-11000001b & 10101010b << 0 = 10000000b
-11000001b & 10101010b << 1 = 01000000b
-11000001b & 10101010b << 2 = 10000000b
-11000001b & 10101010b << 3 = 01000000b
-11000001b & 10101010b << 4 = 10000000b
-11000001b & 10101010b << 5 = 01000000b
-11000001b & 10101010b << 6 = 10000000b
-11000001b & 10101010b << 7 = 00000000b
-11000010b & 10101010b << 0 = 10000010b
-11000010b & 10101010b << 1 = 01000000b
-11000010b & 10101010b << 2 = 10000000b
-11000010b & 10101010b << 3 = 01000000b
-11000010b & 10101010b << 4 = 10000000b
-11000010b & 10101010b << 5 = 01000000b
-11000010b & 10101010b << 6 = 10000000b
-11000010b & 10101010b << 7 = 00000000b
-11000011b & 10101010b << 0 = 10000010b
-11000011b & 10101010b << 1 = 01000000b
-11000011b & 10101010b << 2 = 10000000b
-11000011b & 10101010b << 3 = 01000000b
-11000011b & 10101010b << 4 = 10000000b
-11000011b & 10101010b << 5 = 01000000b
-11000011b & 10101010b << 6 = 10000000b
-11000011b & 10101010b << 7 = 00000000b
-11000100b & 10101010b << 0 = 10000000b
-11000100b & 10101010b << 1 = 01000100b
-11000100b & 10101010b << 2 = 10000000b
-11000100b & 10101010b << 3 = 01000000b
-11000100b & 10101010b << 4 = 10000000b
-11000100b & 10101010b << 5 = 01000000b
-11000100b & 10101010b << 6 = 10000000b
-11000100b & 10101010b << 7 = 00000000b
-11000101b & 10101010b << 0 = 10000000b
-11000101b & 10101010b << 1 = 01000100b
-11000101b & 10101010b << 2 = 10000000b
-11000101b & 10101010b << 3 = 01000000b
-11000101b & 10101010b << 4 = 10000000b
-11000101b & 10101010b << 5 = 01000000b
-11000101b & 10101010b << 6 = 10000000b
-11000101b & 10101010b << 7 = 00000000b
-11000110b & 10101010b << 0 = 10000010b
-11000110b & 10101010b << 1 = 01000100b
-11000110b & 10101010b << 2 = 10000000b
-11000110b & 10101010b << 3 = 01000000b
-11000110b & 10101010b << 4 = 10000000b
-11000110b & 10101010b << 5 = 01000000b
-11000110b & 10101010b << 6 = 10000000b
-11000110b & 10101010b << 7 = 00000000b
-11000111b & 10101010b << 0 = 10000010b
-11000111b & 10101010b << 1 = 01000100b
-11000111b & 10101010b << 2 = 10000000b
-11000111b & 10101010b << 3 = 01000000b
-11000111b & 10101010b << 4 = 10000000b
-11000111b & 10101010b << 5 = 01000000b
-11000111b & 10101010b << 6 = 10000000b
-11000111b & 10101010b << 7 = 00000000b
-11001000b & 10101010b << 0 = 10001000b
-11001000b & 10101010b << 1 = 01000000b
-11001000b & 10101010b << 2 = 10001000b
-11001000b & 10101010b << 3 = 01000000b
-11001000b & 10101010b << 4 = 10000000b
-11001000b & 10101010b << 5 = 01000000b
-11001000b & 10101010b << 6 = 10000000b
-11001000b & 10101010b << 7 = 00000000b
-11001001b & 10101010b << 0 = 10001000b
-11001001b & 10101010b << 1 = 01000000b
-11001001b & 10101010b << 2 = 10001000b
-11001001b & 10101010b << 3 = 01000000b
-11001001b & 10101010b << 4 = 10000000b
-11001001b & 10101010b << 5 = 01000000b
-11001001b & 10101010b << 6 = 10000000b
-11001001b & 10101010b << 7 = 00000000b
-11001010b & 10101010b << 0 = 10001010b
-11001010b & 10101010b << 1 = 01000000b
-11001010b & 10101010b << 2 = 10001000b
-11001010b & 10101010b << 3 = 01000000b
-11001010b & 10101010b << 4 = 10000000b
-11001010b & 10101010b << 5 = 01000000b
-11001010b & 10101010b << 6 = 10000000b
-11001010b & 10101010b << 7 = 00000000b
-11001011b & 10101010b << 0 = 10001010b
-11001011b & 10101010b << 1 = 01000000b
-11001011b & 10101010b << 2 = 10001000b
-11001011b & 10101010b << 3 = 01000000b
-11001011b & 10101010b << 4 = 10000000b
-11001011b & 10101010b << 5 = 01000000b
-11001011b & 10101010b << 6 = 10000000b
-11001011b & 10101010b << 7 = 00000000b
-11001100b & 10101010b << 0 = 10001000b
-11001100b & 10101010b << 1 = 01000100b
-11001100b & 10101010b << 2 = 10001000b
-11001100b & 10101010b << 3 = 01000000b
-11001100b & 10101010b << 4 = 10000000b
-11001100b & 10101010b << 5 = 01000000b
-11001100b & 10101010b << 6 = 10000000b
-11001100b & 10101010b << 7 = 00000000b
-11001101b & 10101010b << 0 = 10001000b
-11001101b & 10101010b << 1 = 01000100b
-11001101b & 10101010b << 2 = 10001000b
-11001101b & 10101010b << 3 = 01000000b
-11001101b & 10101010b << 4 = 10000000b
-11001101b & 10101010b << 5 = 01000000b
-11001101b & 10101010b << 6 = 10000000b
-11001101b & 10101010b << 7 = 00000000b
-11001110b & 10101010b << 0 = 10001010b
-11001110b & 10101010b << 1 = 01000100b
-11001110b & 10101010b << 2 = 10001000b
-11001110b & 10101010b << 3 = 01000000b
-11001110b & 10101010b << 4 = 10000000b
-11001110b & 10101010b << 5 = 01000000b
-11001110b & 10101010b << 6 = 10000000b
-11001110b & 10101010b << 7 = 00000000b
-11001111b & 10101010b << 0 = 10001010b
-11001111b & 10101010b << 1 = 01000100b
-11001111b & 10101010b << 2 = 10001000b
-11001111b & 10101010b << 3 = 01000000b
-11001111b & 10101010b << 4 = 10000000b
-11001111b & 10101010b << 5 = 01000000b
-11001111b & 10101010b << 6 = 10000000b
-11001111b & 10101010b << 7 = 00000000b
-11010000b & 10101010b << 0 = 10000000b
-11010000b & 10101010b << 1 = 01010000b
-11010000b & 10101010b << 2 = 10000000b
-11010000b & 10101010b << 3 = 01010000b
-11010000b & 10101010b << 4 = 10000000b
-11010000b & 10101010b << 5 = 01000000b
-11010000b & 10101010b << 6 = 10000000b
-11010000b & 10101010b << 7 = 00000000b
-11010001b & 10101010b << 0 = 10000000b
-11010001b & 10101010b << 1 = 01010000b
-11010001b & 10101010b << 2 = 10000000b
-11010001b & 10101010b << 3 = 01010000b
-11010001b & 10101010b << 4 = 10000000b
-11010001b & 10101010b << 5 = 01000000b
-11010001b & 10101010b << 6 = 10000000b
-11010001b & 10101010b << 7 = 00000000b
-11010010b & 10101010b << 0 = 10000010b
-11010010b & 10101010b << 1 = 01010000b
-11010010b & 10101010b << 2 = 10000000b
-11010010b & 10101010b << 3 = 01010000b
-11010010b & 10101010b << 4 = 10000000b
-11010010b & 10101010b << 5 = 01000000b
-11010010b & 10101010b << 6 = 10000000b
-11010010b & 10101010b << 7 = 00000000b
-11010011b & 10101010b << 0 = 10000010b
-11010011b & 10101010b << 1 = 01010000b
-11010011b & 10101010b << 2 = 10000000b
-11010011b & 10101010b << 3 = 01010000b
-11010011b & 10101010b << 4 = 10000000b
-11010011b & 10101010b << 5 = 01000000b
-11010011b & 10101010b << 6 = 10000000b
-11010011b & 10101010b << 7 = 00000000b
-11010100b & 10101010b << 0 = 10000000b
-11010100b & 10101010b << 1 = 01010100b
-11010100b & 10101010b << 2 = 10000000b
-11010100b & 10101010b << 3 = 01010000b
-11010100b & 10101010b << 4 = 10000000b
-11010100b & 10101010b << 5 = 01000000b
-11010100b & 10101010b << 6 = 10000000b
-11010100b & 10101010b << 7 = 00000000b
-11010101b & 10101010b << 0 = 10000000b
-11010101b & 10101010b << 1 = 01010100b
-11010101b & 10101010b << 2 = 10000000b
-11010101b & 10101010b << 3 = 01010000b
-11010101b & 10101010b << 4 = 10000000b
-11010101b & 10101010b << 5 = 01000000b
-11010101b & 10101010b << 6 = 10000000b
-11010101b & 10101010b << 7 = 00000000b
-11010110b & 10101010b << 0 = 10000010b
-11010110b & 10101010b << 1 = 01010100b
-11010110b & 10101010b << 2 = 10000000b
-11010110b & 10101010b << 3 = 01010000b
-11010110b & 10101010b << 4 = 10000000b
-11010110b & 10101010b << 5 = 01000000b
-11010110b & 10101010b << 6 = 10000000b
-11010110b & 10101010b << 7 = 00000000b
-11010111b & 10101010b << 0 = 10000010b
-11010111b & 10101010b << 1 = 01010100b
-11010111b & 10101010b << 2 = 10000000b
-11010111b & 10101010b << 3 = 01010000b
-11010111b & 10101010b << 4 = 10000000b
-11010111b & 10101010b << 5 = 01000000b
-11010111b & 10101010b << 6 = 10000000b
-11010111b & 10101010b << 7 = 00000000b
-11011000b & 10101010b << 0 = 10001000b
-11011000b & 10101010b << 1 = 01010000b
-11011000b & 10101010b << 2 = 10001000b
-11011000b & 10101010b << 3 = 01010000b
-11011000b & 10101010b << 4 = 10000000b
-11011000b & 10101010b << 5 = 01000000b
-11011000b & 10101010b << 6 = 10000000b
-11011000b & 10101010b << 7 = 00000000b
-11011001b & 10101010b << 0 = 10001000b
-11011001b & 10101010b << 1 = 01010000b
-11011001b & 10101010b << 2 = 10001000b
-11011001b & 10101010b << 3 = 01010000b
-11011001b & 10101010b << 4 = 10000000b
-11011001b & 10101010b << 5 = 01000000b
-11011001b & 10101010b << 6 = 10000000b
-11011001b & 10101010b << 7 = 00000000b
-11011010b & 10101010b << 0 = 10001010b
-11011010b & 10101010b << 1 = 01010000b
-11011010b & 10101010b << 2 = 10001000b
-11011010b & 10101010b << 3 = 01010000b
-11011010b & 10101010b << 4 = 10000000b
-11011010b & 10101010b << 5 = 01000000b
-11011010b & 10101010b << 6 = 10000000b
-11011010b & 10101010b << 7 = 00000000b
-11011011b & 10101010b << 0 = 10001010b
-11011011b & 10101010b << 1 = 01010000b
-11011011b & 10101010b << 2 = 10001000b
-11011011b & 10101010b << 3 = 01010000b
-11011011b & 10101010b << 4 = 10000000b
-11011011b & 10101010b << 5 = 01000000b
-11011011b & 10101010b << 6 = 10000000b
-11011011b & 10101010b << 7 = 00000000b
-11011100b & 10101010b << 0 = 10001000b
-11011100b & 10101010b << 1 = 01010100b
-11011100b & 10101010b << 2 = 10001000b
-11011100b & 10101010b << 3 = 01010000b
-11011100b & 10101010b << 4 = 10000000b
-11011100b & 10101010b << 5 = 01000000b
-11011100b & 10101010b << 6 = 10000000b
-11011100b & 10101010b << 7 = 00000000b
-11011101b & 10101010b << 0 = 10001000b
-11011101b & 10101010b << 1 = 01010100b
-11011101b & 10101010b << 2 = 10001000b
-11011101b & 10101010b << 3 = 01010000b
-11011101b & 10101010b << 4 = 10000000b
-11011101b & 10101010b << 5 = 01000000b
-11011101b & 10101010b << 6 = 10000000b
-11011101b & 10101010b << 7 = 00000000b
-11011110b & 10101010b << 0 = 10001010b
-11011110b & 10101010b << 1 = 01010100b
-11011110b & 10101010b << 2 = 10001000b
-11011110b & 10101010b << 3 = 01010000b
-11011110b & 10101010b << 4 = 10000000b
-11011110b & 10101010b << 5 = 01000000b
-11011110b & 10101010b << 6 = 10000000b
-11011110b & 10101010b << 7 = 00000000b
-11011111b & 10101010b << 0 = 10001010b
-11011111b & 10101010b << 1 = 01010100b
-11011111b & 10101010b << 2 = 10001000b
-11011111b & 10101010b << 3 = 01010000b
-11011111b & 10101010b << 4 = 10000000b
-11011111b & 10101010b << 5 = 01000000b
-11011111b & 10101010b << 6 = 10000000b
-11011111b & 10101010b << 7 = 00000000b
-11100000b & 10101010b << 0 = 10100000b
-11100000b & 10101010b << 1 = 01000000b
-11100000b & 10101010b << 2 = 10100000b
-11100000b & 10101010b << 3 = 01000000b
-11100000b & 10101010b << 4 = 10100000b
-11100000b & 10101010b << 5 = 01000000b
-11100000b & 10101010b << 6 = 10000000b
-11100000b & 10101010b << 7 = 00000000b
-11100001b & 10101010b << 0 = 10100000b
-11100001b & 10101010b << 1 = 01000000b
-11100001b & 10101010b << 2 = 10100000b
-11100001b & 10101010b << 3 = 01000000b
-11100001b & 10101010b << 4 = 10100000b
-11100001b & 10101010b << 5 = 01000000b
-11100001b & 10101010b << 6 = 10000000b
-11100001b & 10101010b << 7 = 00000000b
-11100010b & 10101010b << 0 = 10100010b
-11100010b & 10101010b << 1 = 01000000b
-11100010b & 10101010b << 2 = 10100000b
-11100010b & 10101010b << 3 = 01000000b
-11100010b & 10101010b << 4 = 10100000b
-11100010b & 10101010b << 5 = 01000000b
-11100010b & 10101010b << 6 = 10000000b
-11100010b & 10101010b << 7 = 00000000b
-11100011b & 10101010b << 0 = 10100010b
-11100011b & 10101010b << 1 = 01000000b
-11100011b & 10101010b << 2 = 10100000b
-11100011b & 10101010b << 3 = 01000000b
-11100011b & 10101010b << 4 = 10100000b
-11100011b & 10101010b << 5 = 01000000b
-11100011b & 10101010b << 6 = 10000000b
-11100011b & 10101010b << 7 = 00000000b
-11100100b & 10101010b << 0 = 10100000b
-11100100b & 10101010b << 1 = 01000100b
-11100100b & 10101010b << 2 = 10100000b
-11100100b & 10101010b << 3 = 01000000b
-11100100b & 10101010b << 4 = 10100000b
-11100100b & 10101010b << 5 = 01000000b
-11100100b & 10101010b << 6 = 10000000b
-11100100b & 10101010b << 7 = 00000000b
-11100101b & 10101010b << 0 = 10100000b
-11100101b & 10101010b << 1 = 01000100b
-11100101b & 10101010b << 2 = 10100000b
-11100101b & 10101010b << 3 = 01000000b
-11100101b & 10101010b << 4 = 10100000b
-11100101b & 10101010b << 5 = 01000000b
-11100101b & 10101010b << 6 = 10000000b
-11100101b & 10101010b << 7 = 00000000b
-11100110b & 10101010b << 0 = 10100010b
-11100110b & 10101010b << 1 = 01000100b
-11100110b & 10101010b << 2 = 10100000b
-11100110b & 10101010b << 3 = 01000000b
-11100110b & 10101010b << 4 = 10100000b
-11100110b & 10101010b << 5 = 01000000b
-11100110b & 10101010b << 6 = 10000000b
-11100110b & 10101010b << 7 = 00000000b
-11100111b & 10101010b << 0 = 10100010b
-11100111b & 10101010b << 1 = 01000100b
-11100111b & 10101010b << 2 = 10100000b
-11100111b & 10101010b << 3 = 01000000b
-11100111b & 10101010b << 4 = 10100000b
-11100111b & 10101010b << 5 = 01000000b
-11100111b & 10101010b << 6 = 10000000b
-11100111b & 10101010b << 7 = 00000000b
-11101000b & 10101010b << 0 = 10101000b
-11101000b & 10101010b << 1 = 01000000b
-11101000b & 10101010b << 2 = 10101000b
-11101000b & 10101010b << 3 = 01000000b
-11101000b & 10101010b << 4 = 10100000b
-11101000b & 10101010b << 5 = 01000000b
-11101000b & 10101010b << 6 = 10000000b
-11101000b & 10101010b << 7 = 00000000b
-11101001b & 10101010b << 0 = 10101000b
-11101001b & 10101010b << 1 = 01000000b
-11101001b & 10101010b << 2 = 10101000b
-11101001b & 10101010b << 3 = 01000000b
-11101001b & 10101010b << 4 = 10100000b
-11101001b & 10101010b << 5 = 01000000b
-11101001b & 10101010b << 6 = 10000000b
-11101001b & 10101010b << 7 = 00000000b
-11101010b & 10101010b << 0 = 10101010b
-11101010b & 10101010b << 1 = 01000000b
-11101010b & 10101010b << 2 = 10101000b
-11101010b & 10101010b << 3 = 01000000b
-11101010b & 10101010b << 4 = 10100000b
-11101010b & 10101010b << 5 = 01000000b
-11101010b & 10101010b << 6 = 10000000b
-11101010b & 10101010b << 7 = 00000000b
-11101011b & 10101010b << 0 = 10101010b
-11101011b & 10101010b << 1 = 01000000b
-11101011b & 10101010b << 2 = 10101000b
-11101011b & 10101010b << 3 = 01000000b
-11101011b & 10101010b << 4 = 10100000b
-11101011b & 10101010b << 5 = 01000000b
-11101011b & 10101010b << 6 = 10000000b
-11101011b & 10101010b << 7 = 00000000b
-11101100b & 10101010b << 0 = 10101000b
-11101100b & 10101010b << 1 = 01000100b
-11101100b & 10101010b << 2 = 10101000b
-11101100b & 10101010b << 3 = 01000000b
-11101100b & 10101010b << 4 = 10100000b
-11101100b & 10101010b << 5 = 01000000b
-11101100b & 10101010b << 6 = 10000000b
-11101100b & 10101010b << 7 = 00000000b
-11101101b & 10101010b << 0 = 10101000b
-11101101b & 10101010b << 1 = 01000100b
-11101101b & 10101010b << 2 = 10101000b
-11101101b & 10101010b << 3 = 01000000b
-11101101b & 10101010b << 4 = 10100000b
-11101101b & 10101010b << 5 = 01000000b
-11101101b & 10101010b << 6 = 10000000b
-11101101b & 10101010b << 7 = 00000000b
-11101110b & 10101010b << 0 = 10101010b
-11101110b & 10101010b << 1 = 01000100b
-11101110b & 10101010b << 2 = 10101000b
-11101110b & 10101010b << 3 = 01000000b
-11101110b & 10101010b << 4 = 10100000b
-11101110b & 10101010b << 5 = 01000000b
-11101110b & 10101010b << 6 = 10000000b
-11101110b & 10101010b << 7 = 00000000b
-11101111b & 10101010b << 0 = 10101010b
-11101111b & 10101010b << 1 = 01000100b
-11101111b & 10101010b << 2 = 10101000b
-11101111b & 10101010b << 3 = 01000000b
-11101111b & 10101010b << 4 = 10100000b
-11101111b & 10101010b << 5 = 01000000b
-11101111b & 10101010b << 6 = 10000000b
-11101111b & 10101010b << 7 = 00000000b
-11110000b & 10101010b << 0 = 10100000b
-11110000b & 10101010b << 1 = 01010000b
-11110000b & 10101010b << 2 = 10100000b
-11110000b & 10101010b << 3 = 01010000b
-11110000b & 10101010b << 4 = 10100000b
-11110000b & 10101010b << 5 = 01000000b
-11110000b & 10101010b << 6 = 10000000b
-11110000b & 10101010b << 7 = 00000000b
-11110001b & 10101010b << 0 = 10100000b
-11110001b & 10101010b << 1 = 01010000b
-11110001b & 10101010b << 2 = 10100000b
-11110001b & 10101010b << 3 = 01010000b
-11110001b & 10101010b << 4 = 10100000b
-11110001b & 10101010b << 5 = 01000000b
-11110001b & 10101010b << 6 = 10000000b
-11110001b & 10101010b << 7 = 00000000b
-11110010b & 10101010b << 0 = 10100010b
-11110010b & 10101010b << 1 = 01010000b
-11110010b & 10101010b << 2 = 10100000b
-11110010b & 10101010b << 3 = 01010000b
-11110010b & 10101010b << 4 = 10100000b
-11110010b & 10101010b << 5 = 01000000b
-11110010b & 10101010b << 6 = 10000000b
-11110010b & 10101010b << 7 = 00000000b
-11110011b & 10101010b << 0 = 10100010b
-11110011b & 10101010b << 1 = 01010000b
-11110011b & 10101010b << 2 = 10100000b
-11110011b & 10101010b << 3 = 01010000b
-11110011b & 10101010b << 4 = 10100000b
-11110011b & 10101010b << 5 = 01000000b
-11110011b & 10101010b << 6 = 10000000b
-11110011b & 10101010b << 7 = 00000000b
-11110100b & 10101010b << 0 = 10100000b
-11110100b & 10101010b << 1 = 01010100b
-11110100b & 10101010b << 2 = 10100000b
-11110100b & 10101010b << 3 = 01010000b
-11110100b & 10101010b << 4 = 10100000b
-11110100b & 10101010b << 5 = 01000000b
-11110100b & 10101010b << 6 = 10000000b
-11110100b & 10101010b << 7 = 00000000b
-11110101b & 10101010b << 0 = 10100000b
-11110101b & 10101010b << 1 = 01010100b
-11110101b & 10101010b << 2 = 10100000b
-11110101b & 10101010b << 3 = 01010000b
-11110101b & 10101010b << 4 = 10100000b
-11110101b & 10101010b << 5 = 01000000b
-11110101b & 10101010b << 6 = 10000000b
-11110101b & 10101010b << 7 = 00000000b
-11110110b & 10101010b << 0 = 10100010b
-11110110b & 10101010b << 1 = 01010100b
-11110110b & 10101010b << 2 = 10100000b
-11110110b & 10101010b << 3 = 01010000b
-11110110b & 10101010b << 4 = 10100000b
-11110110b & 10101010b << 5 = 01000000b
-11110110b & 10101010b << 6 = 10000000b
-11110110b & 10101010b << 7 = 00000000b
-11110111b & 10101010b << 0 = 10100010b
-11110111b & 10101010b << 1 = 01010100b
-11110111b & 10101010b << 2 = 10100000b
-11110111b & 10101010b << 3 = 01010000b
-11110111b & 10101010b << 4 = 10100000b
-11110111b & 10101010b << 5 = 01000000b
-11110111b & 10101010b << 6 = 10000000b
-11110111b & 10101010b << 7 = 00000000b
-11111000b & 10101010b << 0 = 10101000b
-11111000b & 10101010b << 1 = 01010000b
-11111000b & 10101010b << 2 = 10101000b
-11111000b & 10101010b << 3 = 01010000b
-11111000b & 10101010b << 4 = 10100000b
-11111000b & 10101010b << 5 = 01000000b
-11111000b & 10101010b << 6 = 10000000b
-11111000b & 10101010b << 7 = 00000000b
-11111001b & 10101010b << 0 = 10101000b
-11111001b & 10101010b << 1 = 01010000b
-11111001b & 10101010b << 2 = 10101000b
-11111001b & 10101010b << 3 = 01010000b
-11111001b & 10101010b << 4 = 10100000b
-11111001b & 10101010b << 5 = 01000000b
-11111001b & 10101010b << 6 = 10000000b
-11111001b & 10101010b << 7 = 00000000b
-11111010b & 10101010b << 0 = 10101010b
-11111010b & 10101010b << 1 = 01010000b
-11111010b & 10101010b << 2 = 10101000b
-11111010b & 10101010b << 3 = 01010000b
-11111010b & 10101010b << 4 = 10100000b
-11111010b & 10101010b << 5 = 01000000b
-11111010b & 10101010b << 6 = 10000000b
-11111010b & 10101010b << 7 = 00000000b
-11111011b & 10101010b << 0 = 10101010b
-11111011b & 10101010b << 1 = 01010000b
-11111011b & 10101010b << 2 = 10101000b
-11111011b & 10101010b << 3 = 01010000b
-11111011b & 10101010b << 4 = 10100000b
-11111011b & 10101010b << 5 = 01000000b
-11111011b & 10101010b << 6 = 10000000b
-11111011b & 10101010b << 7 = 00000000b
-11111100b & 10101010b << 0 = 10101000b
-11111100b & 10101010b << 1 = 01010100b
-11111100b & 10101010b << 2 = 10101000b
-11111100b & 10101010b << 3 = 01010000b
-11111100b & 10101010b << 4 = 10100000b
-11111100b & 10101010b << 5 = 01000000b
-11111100b & 10101010b << 6 = 10000000b
-11111100b & 10101010b << 7 = 00000000b
-11111101b & 10101010b << 0 = 10101000b
-11111101b & 10101010b << 1 = 01010100b
-11111101b & 10101010b << 2 = 10101000b
-11111101b & 10101010b << 3 = 01010000b
-11111101b & 10101010b << 4 = 10100000b
-11111101b & 10101010b << 5 = 01000000b
-11111101b & 10101010b << 6 = 10000000b
-11111101b & 10101010b << 7 = 00000000b
-11111110b & 10101010b << 0 = 10101010b
-11111110b & 10101010b << 1 = 01010100b
-11111110b & 10101010b << 2 = 10101000b
-11111110b & 10101010b << 3 = 01010000b
-11111110b & 10101010b << 4 = 10100000b
-11111110b & 10101010b << 5 = 01000000b
-11111110b & 10101010b << 6 = 10000000b
-11111110b & 10101010b << 7 = 00000000b
-11111111b & 10101010b << 0 = 10101010b
-11111111b & 10101010b << 1 = 01010100b
-11111111b & 10101010b << 2 = 10101000b
-11111111b & 10101010b << 3 = 01010000b
-11111111b & 10101010b << 4 = 10100000b
-11111111b & 10101010b << 5 = 01000000b
-11111111b & 10101010b << 6 = 10000000b
-11111111b & 10101010b << 7 = 00000000b
-00000000b & 10101010b << 0 = 00000000b
-00000000b & 10101010b << 1 = 00000000b
-00000000b & 10101010b << 2 = 00000000b
-00000000b & 10101010b << 3 = 00000000b
-00000000b & 10101010b << 4 = 00000000b
-00000000b & 10101010b << 5 = 00000000b
-00000000b & 10101010b << 6 = 00000000b
-00000000b & 10101010b << 7 = 00000000b
-00000001b & 10101010b << 0 = 00000000b
-00000001b & 10101010b << 1 = 00000000b
-00000001b & 10101010b << 2 = 00000000b
-00000001b & 10101010b << 3 = 00000000b
-00000001b & 10101010b << 4 = 00000000b
-00000001b & 10101010b << 5 = 00000000b
-00000001b & 10101010b << 6 = 00000000b
-00000001b & 10101010b << 7 = 00000000b
-00000010b & 10101010b << 0 = 00000010b
-00000010b & 10101010b << 1 = 00000000b
-00000010b & 10101010b << 2 = 00000000b
-00000010b & 10101010b << 3 = 00000000b
-00000010b & 10101010b << 4 = 00000000b
-00000010b & 10101010b << 5 = 00000000b
-00000010b & 10101010b << 6 = 00000000b
-00000010b & 10101010b << 7 = 00000000b
-00000011b & 10101010b << 0 = 00000010b
-00000011b & 10101010b << 1 = 00000000b
-00000011b & 10101010b << 2 = 00000000b
-00000011b & 10101010b << 3 = 00000000b
-00000011b & 10101010b << 4 = 00000000b
-00000011b & 10101010b << 5 = 00000000b
-00000011b & 10101010b << 6 = 00000000b
-00000011b & 10101010b << 7 = 00000000b
-00000100b & 10101010b << 0 = 00000000b
-00000100b & 10101010b << 1 = 00000100b
-00000100b & 10101010b << 2 = 00000000b
-00000100b & 10101010b << 3 = 00000000b
-00000100b & 10101010b << 4 = 00000000b
-00000100b & 10101010b << 5 = 00000000b
-00000100b & 10101010b << 6 = 00000000b
-00000100b & 10101010b << 7 = 00000000b
-00000101b & 10101010b << 0 = 00000000b
-00000101b & 10101010b << 1 = 00000100b
-00000101b & 10101010b << 2 = 00000000b
-00000101b & 10101010b << 3 = 00000000b
-00000101b & 10101010b << 4 = 00000000b
-00000101b & 10101010b << 5 = 00000000b
-00000101b & 10101010b << 6 = 00000000b
-00000101b & 10101010b << 7 = 00000000b
-00000110b & 10101010b << 0 = 00000010b
-00000110b & 10101010b << 1 = 00000100b
-00000110b & 10101010b << 2 = 00000000b
-00000110b & 10101010b << 3 = 00000000b
-00000110b & 10101010b << 4 = 00000000b
-00000110b & 10101010b << 5 = 00000000b
-00000110b & 10101010b << 6 = 00000000b
-00000110b & 10101010b << 7 = 00000000b
-00000111b & 10101010b << 0 = 00000010b
-00000111b & 10101010b << 1 = 00000100b
-00000111b & 10101010b << 2 = 00000000b
-00000111b & 10101010b << 3 = 00000000b
-00000111b & 10101010b << 4 = 00000000b
-00000111b & 10101010b << 5 = 00000000b
-00000111b & 10101010b << 6 = 00000000b
-00000111b & 10101010b << 7 = 00000000b
-00001000b & 10101010b << 0 = 00001000b
-00001000b & 10101010b << 1 = 00000000b
-00001000b & 10101010b << 2 = 00001000b
-00001000b & 10101010b << 3 = 00000000b
-00001000b & 10101010b << 4 = 00000000b
-00001000b & 10101010b << 5 = 00000000b
-00001000b & 10101010b << 6 = 00000000b
-00001000b & 10101010b << 7 = 00000000b
-00001001b & 10101010b << 0 = 00001000b
-00001001b & 10101010b << 1 = 00000000b
-00001001b & 10101010b << 2 = 00001000b
-00001001b & 10101010b << 3 = 00000000b
-00001001b & 10101010b << 4 = 00000000b
-00001001b & 10101010b << 5 = 00000000b
-00001001b & 10101010b << 6 = 00000000b
-00001001b & 10101010b << 7 = 00000000b
-00001010b & 10101010b << 0 = 00001010b
-00001010b & 10101010b << 1 = 00000000b
-00001010b & 10101010b << 2 = 00001000b
-00001010b & 10101010b << 3 = 00000000b
-00001010b & 10101010b << 4 = 00000000b
-00001010b & 10101010b << 5 = 00000000b
-00001010b & 10101010b << 6 = 00000000b
-00001010b & 10101010b << 7 = 00000000b
-00001011b & 10101010b << 0 = 00001010b
-00001011b & 10101010b << 1 = 00000000b
-00001011b & 10101010b << 2 = 00001000b
-00001011b & 10101010b << 3 = 00000000b
-00001011b & 10101010b << 4 = 00000000b
-00001011b & 10101010b << 5 = 00000000b
-00001011b & 10101010b << 6 = 00000000b
-00001011b & 10101010b << 7 = 00000000b
-00001100b & 10101010b << 0 = 00001000b
-00001100b & 10101010b << 1 = 00000100b
-00001100b & 10101010b << 2 = 00001000b
-00001100b & 10101010b << 3 = 00000000b
-00001100b & 10101010b << 4 = 00000000b
-00001100b & 10101010b << 5 = 00000000b
-00001100b & 10101010b << 6 = 00000000b
-00001100b & 10101010b << 7 = 00000000b
-00001101b & 10101010b << 0 = 00001000b
-00001101b & 10101010b << 1 = 00000100b
-00001101b & 10101010b << 2 = 00001000b
-00001101b & 10101010b << 3 = 00000000b
-00001101b & 10101010b << 4 = 00000000b
-00001101b & 10101010b << 5 = 00000000b
-00001101b & 10101010b << 6 = 00000000b
-00001101b & 10101010b << 7 = 00000000b
-00001110b & 10101010b << 0 = 00001010b
-00001110b & 10101010b << 1 = 00000100b
-00001110b & 10101010b << 2 = 00001000b
-00001110b & 10101010b << 3 = 00000000b
-00001110b & 10101010b << 4 = 00000000b
-00001110b & 10101010b << 5 = 00000000b
-00001110b & 10101010b << 6 = 00000000b
-00001110b & 10101010b << 7 = 00000000b
-00001111b & 10101010b << 0 = 00001010b
-00001111b & 10101010b << 1 = 00000100b
-00001111b & 10101010b << 2 = 00001000b
-00001111b & 10101010b << 3 = 00000000b
-00001111b & 10101010b << 4 = 00000000b
-00001111b & 10101010b << 5 = 00000000b
-00001111b & 10101010b << 6 = 00000000b
-00001111b & 10101010b << 7 = 00000000b
-00010000b & 10101010b << 0 = 00000000b
-00010000b & 10101010b << 1 = 00010000b
-00010000b & 10101010b << 2 = 00000000b
-00010000b & 10101010b << 3 = 00010000b
-00010000b & 10101010b << 4 = 00000000b
-00010000b & 10101010b << 5 = 00000000b
-00010000b & 10101010b << 6 = 00000000b
-00010000b & 10101010b << 7 = 00000000b
-00010001b & 10101010b << 0 = 00000000b
-00010001b & 10101010b << 1 = 00010000b
-00010001b & 10101010b << 2 = 00000000b
-00010001b & 10101010b << 3 = 00010000b
-00010001b & 10101010b << 4 = 00000000b
-00010001b & 10101010b << 5 = 00000000b
-00010001b & 10101010b << 6 = 00000000b
-00010001b & 10101010b << 7 = 00000000b
-00010010b & 10101010b << 0 = 00000010b
-00010010b & 10101010b << 1 = 00010000b
-00010010b & 10101010b << 2 = 00000000b
-00010010b & 10101010b << 3 = 00010000b
-00010010b & 10101010b << 4 = 00000000b
-00010010b & 10101010b << 5 = 00000000b
-00010010b & 10101010b << 6 = 00000000b
-00010010b & 10101010b << 7 = 00000000b
-00010011b & 10101010b << 0 = 00000010b
-00010011b & 10101010b << 1 = 00010000b
-00010011b & 10101010b << 2 = 00000000b
-00010011b & 10101010b << 3 = 00010000b
-00010011b & 10101010b << 4 = 00000000b
-00010011b & 10101010b << 5 = 00000000b
-00010011b & 10101010b << 6 = 00000000b
-00010011b & 10101010b << 7 = 00000000b
-00010100b & 10101010b << 0 = 00000000b
-00010100b & 10101010b << 1 = 00010100b
-00010100b & 10101010b << 2 = 00000000b
-00010100b & 10101010b << 3 = 00010000b
-00010100b & 10101010b << 4 = 00000000b
-00010100b & 10101010b << 5 = 00000000b
-00010100b & 10101010b << 6 = 00000000b
-00010100b & 10101010b << 7 = 00000000b
-00010101b & 10101010b << 0 = 00000000b
-00010101b & 10101010b << 1 = 00010100b
-00010101b & 10101010b << 2 = 00000000b
-00010101b & 10101010b << 3 = 00010000b
-00010101b & 10101010b << 4 = 00000000b
-00010101b & 10101010b << 5 = 00000000b
-00010101b & 10101010b << 6 = 00000000b
-00010101b & 10101010b << 7 = 00000000b
-00010110b & 10101010b << 0 = 00000010b
-00010110b & 10101010b << 1 = 00010100b
-00010110b & 10101010b << 2 = 00000000b
-00010110b & 10101010b << 3 = 00010000b
-00010110b & 10101010b << 4 = 00000000b
-00010110b & 10101010b << 5 = 00000000b
-00010110b & 10101010b << 6 = 00000000b
-00010110b & 10101010b << 7 = 00000000b
-00010111b & 10101010b << 0 = 00000010b
-00010111b & 10101010b << 1 = 00010100b
-00010111b & 10101010b << 2 = 00000000b
-00010111b & 10101010b << 3 = 00010000b
-00010111b & 10101010b << 4 = 00000000b
-00010111b & 10101010b << 5 = 00000000b
-00010111b & 10101010b << 6 = 00000000b
-00010111b & 10101010b << 7 = 00000000b
-00011000b & 10101010b << 0 = 00001000b
-00011000b & 10101010b << 1 = 00010000b
-00011000b & 10101010b << 2 = 00001000b
-00011000b & 10101010b << 3 = 00010000b
-00011000b & 10101010b << 4 = 00000000b
-00011000b & 10101010b << 5 = 00000000b
-00011000b & 10101010b << 6 = 00000000b
-00011000b & 10101010b << 7 = 00000000b
-00011001b & 10101010b << 0 = 00001000b
-00011001b & 10101010b << 1 = 00010000b
-00011001b & 10101010b << 2 = 00001000b
-00011001b & 10101010b << 3 = 00010000b
-00011001b & 10101010b << 4 = 00000000b
-00011001b & 10101010b << 5 = 00000000b
-00011001b & 10101010b << 6 = 00000000b
-00011001b & 10101010b << 7 = 00000000b
-00011010b & 10101010b << 0 = 00001010b
-00011010b & 10101010b << 1 = 00010000b
-00011010b & 10101010b << 2 = 00001000b
-00011010b & 10101010b << 3 = 00010000b
-00011010b & 10101010b << 4 = 00000000b
-00011010b & 10101010b << 5 = 00000000b
-00011010b & 10101010b << 6 = 00000000b
-00011010b & 10101010b << 7 = 00000000b
-00011011b & 10101010b << 0 = 00001010b
-00011011b & 10101010b << 1 = 00010000b
-00011011b & 10101010b << 2 = 00001000b
-00011011b & 10101010b << 3 = 00010000b
-00011011b & 10101010b << 4 = 00000000b
-00011011b & 10101010b << 5 = 00000000b
-00011011b & 10101010b << 6 = 00000000b
-00011011b & 10101010b << 7 = 00000000b
-00011100b & 10101010b << 0 = 00001000b
-00011100b & 10101010b << 1 = 00010100b
-00011100b & 10101010b << 2 = 00001000b
-00011100b & 10101010b << 3 = 00010000b
-00011100b & 10101010b << 4 = 00000000b
-00011100b & 10101010b << 5 = 00000000b
-00011100b & 10101010b << 6 = 00000000b
-00011100b & 10101010b << 7 = 00000000b
-00011101b & 10101010b << 0 = 00001000b
-00011101b & 10101010b << 1 = 00010100b
-00011101b & 10101010b << 2 = 00001000b
-00011101b & 10101010b << 3 = 00010000b
-00011101b & 10101010b << 4 = 00000000b
-00011101b & 10101010b << 5 = 00000000b
-00011101b & 10101010b << 6 = 00000000b
-00011101b & 10101010b << 7 = 00000000b
-00011110b & 10101010b << 0 = 00001010b
-00011110b & 10101010b << 1 = 00010100b
-00011110b & 10101010b << 2 = 00001000b
-00011110b & 10101010b << 3 = 00010000b
-00011110b & 10101010b << 4 = 00000000b
-00011110b & 10101010b << 5 = 00000000b
-00011110b & 10101010b << 6 = 00000000b
-00011110b & 10101010b << 7 = 00000000b
-00011111b & 10101010b << 0 = 00001010b
-00011111b & 10101010b << 1 = 00010100b
-00011111b & 10101010b << 2 = 00001000b
-00011111b & 10101010b << 3 = 00010000b
-00011111b & 10101010b << 4 = 00000000b
-00011111b & 10101010b << 5 = 00000000b
-00011111b & 10101010b << 6 = 00000000b
-00011111b & 10101010b << 7 = 00000000b
-00100000b & 10101010b << 0 = 00100000b
-00100000b & 10101010b << 1 = 00000000b
-00100000b & 10101010b << 2 = 00100000b
-00100000b & 10101010b << 3 = 00000000b
-00100000b & 10101010b << 4 = 00100000b
-00100000b & 10101010b << 5 = 00000000b
-00100000b & 10101010b << 6 = 00000000b
-00100000b & 10101010b << 7 = 00000000b
-00100001b & 10101010b << 0 = 00100000b
-00100001b & 10101010b << 1 = 00000000b
-00100001b & 10101010b << 2 = 00100000b
-00100001b & 10101010b << 3 = 00000000b
-00100001b & 10101010b << 4 = 00100000b
-00100001b & 10101010b << 5 = 00000000b
-00100001b & 10101010b << 6 = 00000000b
-00100001b & 10101010b << 7 = 00000000b
-00100010b & 10101010b << 0 = 00100010b
-00100010b & 10101010b << 1 = 00000000b
-00100010b & 10101010b << 2 = 00100000b
-00100010b & 10101010b << 3 = 00000000b
-00100010b & 10101010b << 4 = 00100000b
-00100010b & 10101010b << 5 = 00000000b
-00100010b & 10101010b << 6 = 00000000b
-00100010b & 10101010b << 7 = 00000000b
-00100011b & 10101010b << 0 = 00100010b
-00100011b & 10101010b << 1 = 00000000b
-00100011b & 10101010b << 2 = 00100000b
-00100011b & 10101010b << 3 = 00000000b
-00100011b & 10101010b << 4 = 00100000b
-00100011b & 10101010b << 5 = 00000000b
-00100011b & 10101010b << 6 = 00000000b
-00100011b & 10101010b << 7 = 00000000b
-00100100b & 10101010b << 0 = 00100000b
-00100100b & 10101010b << 1 = 00000100b
-00100100b & 10101010b << 2 = 00100000b
-00100100b & 10101010b << 3 = 00000000b
-00100100b & 10101010b << 4 = 00100000b
-00100100b & 10101010b << 5 = 00000000b
-00100100b & 10101010b << 6 = 00000000b
-00100100b & 10101010b << 7 = 00000000b
-00100101b & 10101010b << 0 = 00100000b
-00100101b & 10101010b << 1 = 00000100b
-00100101b & 10101010b << 2 = 00100000b
-00100101b & 10101010b << 3 = 00000000b
-00100101b & 10101010b << 4 = 00100000b
-00100101b & 10101010b << 5 = 00000000b
-00100101b & 10101010b << 6 = 00000000b
-00100101b & 10101010b << 7 = 00000000b
-00100110b & 10101010b << 0 = 00100010b
-00100110b & 10101010b << 1 = 00000100b
-00100110b & 10101010b << 2 = 00100000b
-00100110b & 10101010b << 3 = 00000000b
-00100110b & 10101010b << 4 = 00100000b
-00100110b & 10101010b << 5 = 00000000b
-00100110b & 10101010b << 6 = 00000000b
-00100110b & 10101010b << 7 = 00000000b
-00100111b & 10101010b << 0 = 00100010b
-00100111b & 10101010b << 1 = 00000100b
-00100111b & 10101010b << 2 = 00100000b
-00100111b & 10101010b << 3 = 00000000b
-00100111b & 10101010b << 4 = 00100000b
-00100111b & 10101010b << 5 = 00000000b
-00100111b & 10101010b << 6 = 00000000b
-00100111b & 10101010b << 7 = 00000000b
-00101000b & 10101010b << 0 = 00101000b
-00101000b & 10101010b << 1 = 00000000b
-00101000b & 10101010b << 2 = 00101000b
-00101000b & 10101010b << 3 = 00000000b
-00101000b & 10101010b << 4 = 00100000b
-00101000b & 10101010b << 5 = 00000000b
-00101000b & 10101010b << 6 = 00000000b
-00101000b & 10101010b << 7 = 00000000b
-00101001b & 10101010b << 0 = 00101000b
-00101001b & 10101010b << 1 = 00000000b
-00101001b & 10101010b << 2 = 00101000b
-00101001b & 10101010b << 3 = 00000000b
-00101001b & 10101010b << 4 = 00100000b
-00101001b & 10101010b << 5 = 00000000b
-00101001b & 10101010b << 6 = 00000000b
-00101001b & 10101010b << 7 = 00000000b
-00101010b & 10101010b << 0 = 00101010b
-00101010b & 10101010b << 1 = 00000000b
-00101010b & 10101010b << 2 = 00101000b
-00101010b & 10101010b << 3 = 00000000b
-00101010b & 10101010b << 4 = 00100000b
-00101010b & 10101010b << 5 = 00000000b
-00101010b & 10101010b << 6 = 00000000b
-00101010b & 10101010b << 7 = 00000000b
-00101011b & 10101010b << 0 = 00101010b
-00101011b & 10101010b << 1 = 00000000b
-00101011b & 10101010b << 2 = 00101000b
-00101011b & 10101010b << 3 = 00000000b
-00101011b & 10101010b << 4 = 00100000b
-00101011b & 10101010b << 5 = 00000000b
-00101011b & 10101010b << 6 = 00000000b
-00101011b & 10101010b << 7 = 00000000b
-00101100b & 10101010b << 0 = 00101000b
-00101100b & 10101010b << 1 = 00000100b
-00101100b & 10101010b << 2 = 00101000b
-00101100b & 10101010b << 3 = 00000000b
-00101100b & 10101010b << 4 = 00100000b
-00101100b & 10101010b << 5 = 00000000b
-00101100b & 10101010b << 6 = 00000000b
-00101100b & 10101010b << 7 = 00000000b
-00101101b & 10101010b << 0 = 00101000b
-00101101b & 10101010b << 1 = 00000100b
-00101101b & 10101010b << 2 = 00101000b
-00101101b & 10101010b << 3 = 00000000b
-00101101b & 10101010b << 4 = 00100000b
-00101101b & 10101010b << 5 = 00000000b
-00101101b & 10101010b << 6 = 00000000b
-00101101b & 10101010b << 7 = 00000000b
-00101110b & 10101010b << 0 = 00101010b
-00101110b & 10101010b << 1 = 00000100b
-00101110b & 10101010b << 2 = 00101000b
-00101110b & 10101010b << 3 = 00000000b
-00101110b & 10101010b << 4 = 00100000b
-00101110b & 10101010b << 5 = 00000000b
-00101110b & 10101010b << 6 = 00000000b
-00101110b & 10101010b << 7 = 00000000b
-00101111b & 10101010b << 0 = 00101010b
-00101111b & 10101010b << 1 = 00000100b
-00101111b & 10101010b << 2 = 00101000b
-00101111b & 10101010b << 3 = 00000000b
-00101111b & 10101010b << 4 = 00100000b
-00101111b & 10101010b << 5 = 00000000b
-00101111b & 10101010b << 6 = 00000000b
-00101111b & 10101010b << 7 = 00000000b
-00110000b & 10101010b << 0 = 00100000b
-00110000b & 10101010b << 1 = 00010000b
-00110000b & 10101010b << 2 = 00100000b
-00110000b & 10101010b << 3 = 00010000b
-00110000b & 10101010b << 4 = 00100000b
-00110000b & 10101010b << 5 = 00000000b
-00110000b & 10101010b << 6 = 00000000b
-00110000b & 10101010b << 7 = 00000000b
-00110001b & 10101010b << 0 = 00100000b
-00110001b & 10101010b << 1 = 00010000b
-00110001b & 10101010b << 2 = 00100000b
-00110001b & 10101010b << 3 = 00010000b
-00110001b & 10101010b << 4 = 00100000b
-00110001b & 10101010b << 5 = 00000000b
-00110001b & 10101010b << 6 = 00000000b
-00110001b & 10101010b << 7 = 00000000b
-00110010b & 10101010b << 0 = 00100010b
-00110010b & 10101010b << 1 = 00010000b
-00110010b & 10101010b << 2 = 00100000b
-00110010b & 10101010b << 3 = 00010000b
-00110010b & 10101010b << 4 = 00100000b
-00110010b & 10101010b << 5 = 00000000b
-00110010b & 10101010b << 6 = 00000000b
-00110010b & 10101010b << 7 = 00000000b
-00110011b & 10101010b << 0 = 00100010b
-00110011b & 10101010b << 1 = 00010000b
-00110011b & 10101010b << 2 = 00100000b
-00110011b & 10101010b << 3 = 00010000b
-00110011b & 10101010b << 4 = 00100000b
-00110011b & 10101010b << 5 = 00000000b
-00110011b & 10101010b << 6 = 00000000b
-00110011b & 10101010b << 7 = 00000000b
-00110100b & 10101010b << 0 = 00100000b
-00110100b & 10101010b << 1 = 00010100b
-00110100b & 10101010b << 2 = 00100000b
-00110100b & 10101010b << 3 = 00010000b
-00110100b & 10101010b << 4 = 00100000b
-00110100b & 10101010b << 5 = 00000000b
-00110100b & 10101010b << 6 = 00000000b
-00110100b & 10101010b << 7 = 00000000b
-00110101b & 10101010b << 0 = 00100000b
-00110101b & 10101010b << 1 = 00010100b
-00110101b & 10101010b << 2 = 00100000b
-00110101b & 10101010b << 3 = 00010000b
-00110101b & 10101010b << 4 = 00100000b
-00110101b & 10101010b << 5 = 00000000b
-00110101b & 10101010b << 6 = 00000000b
-00110101b & 10101010b << 7 = 00000000b
-00110110b & 10101010b << 0 = 00100010b
-00110110b & 10101010b << 1 = 00010100b
-00110110b & 10101010b << 2 = 00100000b
-00110110b & 10101010b << 3 = 00010000b
-00110110b & 10101010b << 4 = 00100000b
-00110110b & 10101010b << 5 = 00000000b
-00110110b & 10101010b << 6 = 00000000b
-00110110b & 10101010b << 7 = 00000000b
-00110111b & 10101010b << 0 = 00100010b
-00110111b & 10101010b << 1 = 00010100b
-00110111b & 10101010b << 2 = 00100000b
-00110111b & 10101010b << 3 = 00010000b
-00110111b & 10101010b << 4 = 00100000b
-00110111b & 10101010b << 5 = 00000000b
-00110111b & 10101010b << 6 = 00000000b
-00110111b & 10101010b << 7 = 00000000b
-00111000b & 10101010b << 0 = 00101000b
-00111000b & 10101010b << 1 = 00010000b
-00111000b & 10101010b << 2 = 00101000b
-00111000b & 10101010b << 3 = 00010000b
-00111000b & 10101010b << 4 = 00100000b
-00111000b & 10101010b << 5 = 00000000b
-00111000b & 10101010b << 6 = 00000000b
-00111000b & 10101010b << 7 = 00000000b
-00111001b & 10101010b << 0 = 00101000b
-00111001b & 10101010b << 1 = 00010000b
-00111001b & 10101010b << 2 = 00101000b
-00111001b & 10101010b << 3 = 00010000b
-00111001b & 10101010b << 4 = 00100000b
-00111001b & 10101010b << 5 = 00000000b
-00111001b & 10101010b << 6 = 00000000b
-00111001b & 10101010b << 7 = 00000000b
-00111010b & 10101010b << 0 = 00101010b
-00111010b & 10101010b << 1 = 00010000b
-00111010b & 10101010b << 2 = 00101000b
-00111010b & 10101010b << 3 = 00010000b
-00111010b & 10101010b << 4 = 00100000b
-00111010b & 10101010b << 5 = 00000000b
-00111010b & 10101010b << 6 = 00000000b
-00111010b & 10101010b << 7 = 00000000b
-00111011b & 10101010b << 0 = 00101010b
-00111011b & 10101010b << 1 = 00010000b
-00111011b & 10101010b << 2 = 00101000b
-00111011b & 10101010b << 3 = 00010000b
-00111011b & 10101010b << 4 = 00100000b
-00111011b & 10101010b << 5 = 00000000b
-00111011b & 10101010b << 6 = 00000000b
-00111011b & 10101010b << 7 = 00000000b
-00111100b & 10101010b << 0 = 00101000b
-00111100b & 10101010b << 1 = 00010100b
-00111100b & 10101010b << 2 = 00101000b
-00111100b & 10101010b << 3 = 00010000b
-00111100b & 10101010b << 4 = 00100000b
-00111100b & 10101010b << 5 = 00000000b
-00111100b & 10101010b << 6 = 00000000b
-00111100b & 10101010b << 7 = 00000000b
-00111101b & 10101010b << 0 = 00101000b
-00111101b & 10101010b << 1 = 00010100b
-00111101b & 10101010b << 2 = 00101000b
-00111101b & 10101010b << 3 = 00010000b
-00111101b & 10101010b << 4 = 00100000b
-00111101b & 10101010b << 5 = 00000000b
-00111101b & 10101010b << 6 = 00000000b
-00111101b & 10101010b << 7 = 00000000b
-00111110b & 10101010b << 0 = 00101010b
-00111110b & 10101010b << 1 = 00010100b
-00111110b & 10101010b << 2 = 00101000b
-00111110b & 10101010b << 3 = 00010000b
-00111110b & 10101010b << 4 = 00100000b
-00111110b & 10101010b << 5 = 00000000b
-00111110b & 10101010b << 6 = 00000000b
-00111110b & 10101010b << 7 = 00000000b
-00111111b & 10101010b << 0 = 00101010b
-00111111b & 10101010b << 1 = 00010100b
-00111111b & 10101010b << 2 = 00101000b
-00111111b & 10101010b << 3 = 00010000b
-00111111b & 10101010b << 4 = 00100000b
-00111111b & 10101010b << 5 = 00000000b
-00111111b & 10101010b << 6 = 00000000b
-00111111b & 10101010b << 7 = 00000000b
-01000000b & 10101010b << 0 = 00000000b
-01000000b & 10101010b << 1 = 01000000b
-01000000b & 10101010b << 2 = 00000000b
-01000000b & 10101010b << 3 = 01000000b
-01000000b & 10101010b << 4 = 00000000b
-01000000b & 10101010b << 5 = 01000000b
-01000000b & 10101010b << 6 = 00000000b
-01000000b & 10101010b << 7 = 00000000b
-01000001b & 10101010b << 0 = 00000000b
-01000001b & 10101010b << 1 = 01000000b
-01000001b & 10101010b << 2 = 00000000b
-01000001b & 10101010b << 3 = 01000000b
-01000001b & 10101010b << 4 = 00000000b
-01000001b & 10101010b << 5 = 01000000b
-01000001b & 10101010b << 6 = 00000000b
-01000001b & 10101010b << 7 = 00000000b
-01000010b & 10101010b << 0 = 00000010b
-01000010b & 10101010b << 1 = 01000000b
-01000010b & 10101010b << 2 = 00000000b
-01000010b & 10101010b << 3 = 01000000b
-01000010b & 10101010b << 4 = 00000000b
-01000010b & 10101010b << 5 = 01000000b
-01000010b & 10101010b << 6 = 00000000b
-01000010b & 10101010b << 7 = 00000000b
-01000011b & 10101010b << 0 = 00000010b
-01000011b & 10101010b << 1 = 01000000b
-01000011b & 10101010b << 2 = 00000000b
-01000011b & 10101010b << 3 = 01000000b
-01000011b & 10101010b << 4 = 00000000b
-01000011b & 10101010b << 5 = 01000000b
-01000011b & 10101010b << 6 = 00000000b
-01000011b & 10101010b << 7 = 00000000b
-01000100b & 10101010b << 0 = 00000000b
-01000100b & 10101010b << 1 = 01000100b
-01000100b & 10101010b << 2 = 00000000b
-01000100b & 10101010b << 3 = 01000000b
-01000100b & 10101010b << 4 = 00000000b
-01000100b & 10101010b << 5 = 01000000b
-01000100b & 10101010b << 6 = 00000000b
-01000100b & 10101010b << 7 = 00000000b
-01000101b & 10101010b << 0 = 00000000b
-01000101b & 10101010b << 1 = 01000100b
-01000101b & 10101010b << 2 = 00000000b
-01000101b & 10101010b << 3 = 01000000b
-01000101b & 10101010b << 4 = 00000000b
-01000101b & 10101010b << 5 = 01000000b
-01000101b & 10101010b << 6 = 00000000b
-01000101b & 10101010b << 7 = 00000000b
-01000110b & 10101010b << 0 = 00000010b
-01000110b & 10101010b << 1 = 01000100b
-01000110b & 10101010b << 2 = 00000000b
-01000110b & 10101010b << 3 = 01000000b
-01000110b & 10101010b << 4 = 00000000b
-01000110b & 10101010b << 5 = 01000000b
-01000110b & 10101010b << 6 = 00000000b
-01000110b & 10101010b << 7 = 00000000b
-01000111b & 10101010b << 0 = 00000010b
-01000111b & 10101010b << 1 = 01000100b
-01000111b & 10101010b << 2 = 00000000b
-01000111b & 10101010b << 3 = 01000000b
-01000111b & 10101010b << 4 = 00000000b
-01000111b & 10101010b << 5 = 01000000b
-01000111b & 10101010b << 6 = 00000000b
-01000111b & 10101010b << 7 = 00000000b
-01001000b & 10101010b << 0 = 00001000b
-01001000b & 10101010b << 1 = 01000000b
-01001000b & 10101010b << 2 = 00001000b
-01001000b & 10101010b << 3 = 01000000b
-01001000b & 10101010b << 4 = 00000000b
-01001000b & 10101010b << 5 = 01000000b
-01001000b & 10101010b << 6 = 00000000b
-01001000b & 10101010b << 7 = 00000000b
-01001001b & 10101010b << 0 = 00001000b
-01001001b & 10101010b << 1 = 01000000b
-01001001b & 10101010b << 2 = 00001000b
-01001001b & 10101010b << 3 = 01000000b
-01001001b & 10101010b << 4 = 00000000b
-01001001b & 10101010b << 5 = 01000000b
-01001001b & 10101010b << 6 = 00000000b
-01001001b & 10101010b << 7 = 00000000b
-01001010b & 10101010b << 0 = 00001010b
-01001010b & 10101010b << 1 = 01000000b
-01001010b & 10101010b << 2 = 00001000b
-01001010b & 10101010b << 3 = 01000000b
-01001010b & 10101010b << 4 = 00000000b
-01001010b & 10101010b << 5 = 01000000b
-01001010b & 10101010b << 6 = 00000000b
-01001010b & 10101010b << 7 = 00000000b
-01001011b & 10101010b << 0 = 00001010b
-01001011b & 10101010b << 1 = 01000000b
-01001011b & 10101010b << 2 = 00001000b
-01001011b & 10101010b << 3 = 01000000b
-01001011b & 10101010b << 4 = 00000000b
-01001011b & 10101010b << 5 = 01000000b
-01001011b & 10101010b << 6 = 00000000b
-01001011b & 10101010b << 7 = 00000000b
-01001100b & 10101010b << 0 = 00001000b
-01001100b & 10101010b << 1 = 01000100b
-01001100b & 10101010b << 2 = 00001000b
-01001100b & 10101010b << 3 = 01000000b
-01001100b & 10101010b << 4 = 00000000b
-01001100b & 10101010b << 5 = 01000000b
-01001100b & 10101010b << 6 = 00000000b
-01001100b & 10101010b << 7 = 00000000b
-01001101b & 10101010b << 0 = 00001000b
-01001101b & 10101010b << 1 = 01000100b
-01001101b & 10101010b << 2 = 00001000b
-01001101b & 10101010b << 3 = 01000000b
-01001101b & 10101010b << 4 = 00000000b
-01001101b & 10101010b << 5 = 01000000b
-01001101b & 10101010b << 6 = 00000000b
-01001101b & 10101010b << 7 = 00000000b
-01001110b & 10101010b << 0 = 00001010b
-01001110b & 10101010b << 1 = 01000100b
-01001110b & 10101010b << 2 = 00001000b
-01001110b & 10101010b << 3 = 01000000b
-01001110b & 10101010b << 4 = 00000000b
-01001110b & 10101010b << 5 = 01000000b
-01001110b & 10101010b << 6 = 00000000b
-01001110b & 10101010b << 7 = 00000000b
-01001111b & 10101010b << 0 = 00001010b
-01001111b & 10101010b << 1 = 01000100b
-01001111b & 10101010b << 2 = 00001000b
-01001111b & 10101010b << 3 = 01000000b
-01001111b & 10101010b << 4 = 00000000b
-01001111b & 10101010b << 5 = 01000000b
-01001111b & 10101010b << 6 = 00000000b
-01001111b & 10101010b << 7 = 00000000b
-01010000b & 10101010b << 0 = 00000000b
-01010000b & 10101010b << 1 = 01010000b
-01010000b & 10101010b << 2 = 00000000b
-01010000b & 10101010b << 3 = 01010000b
-01010000b & 10101010b << 4 = 00000000b
-01010000b & 10101010b << 5 = 01000000b
-01010000b & 10101010b << 6 = 00000000b
-01010000b & 10101010b << 7 = 00000000b
-01010001b & 10101010b << 0 = 00000000b
-01010001b & 10101010b << 1 = 01010000b
-01010001b & 10101010b << 2 = 00000000b
-01010001b & 10101010b << 3 = 01010000b
-01010001b & 10101010b << 4 = 00000000b
-01010001b & 10101010b << 5 = 01000000b
-01010001b & 10101010b << 6 = 00000000b
-01010001b & 10101010b << 7 = 00000000b
-01010010b & 10101010b << 0 = 00000010b
-01010010b & 10101010b << 1 = 01010000b
-01010010b & 10101010b << 2 = 00000000b
-01010010b & 10101010b << 3 = 01010000b
-01010010b & 10101010b << 4 = 00000000b
-01010010b & 10101010b << 5 = 01000000b
-01010010b & 10101010b << 6 = 00000000b
-01010010b & 10101010b << 7 = 00000000b
-01010011b & 10101010b << 0 = 00000010b
-01010011b & 10101010b << 1 = 01010000b
-01010011b & 10101010b << 2 = 00000000b
-01010011b & 10101010b << 3 = 01010000b
-01010011b & 10101010b << 4 = 00000000b
-01010011b & 10101010b << 5 = 01000000b
-01010011b & 10101010b << 6 = 00000000b
-01010011b & 10101010b << 7 = 00000000b
-01010100b & 10101010b << 0 = 00000000b
-01010100b & 10101010b << 1 = 01010100b
-01010100b & 10101010b << 2 = 00000000b
-01010100b & 10101010b << 3 = 01010000b
-01010100b & 10101010b << 4 = 00000000b
-01010100b & 10101010b << 5 = 01000000b
-01010100b & 10101010b << 6 = 00000000b
-01010100b & 10101010b << 7 = 00000000b
-01010101b & 10101010b << 0 = 00000000b
-01010101b & 10101010b << 1 = 01010100b
-01010101b & 10101010b << 2 = 00000000b
-01010101b & 10101010b << 3 = 01010000b
-01010101b & 10101010b << 4 = 00000000b
-01010101b & 10101010b << 5 = 01000000b
-01010101b & 10101010b << 6 = 00000000b
-01010101b & 10101010b << 7 = 00000000b
-01010110b & 10101010b << 0 = 00000010b
-01010110b & 10101010b << 1 = 01010100b
-01010110b & 10101010b << 2 = 00000000b
-01010110b & 10101010b << 3 = 01010000b
-01010110b & 10101010b << 4 = 00000000b
-01010110b & 10101010b << 5 = 01000000b
-01010110b & 10101010b << 6 = 00000000b
-01010110b & 10101010b << 7 = 00000000b
-01010111b & 10101010b << 0 = 00000010b
-01010111b & 10101010b << 1 = 01010100b
-01010111b & 10101010b << 2 = 00000000b
-01010111b & 10101010b << 3 = 01010000b
-01010111b & 10101010b << 4 = 00000000b
-01010111b & 10101010b << 5 = 01000000b
-01010111b & 10101010b << 6 = 00000000b
-01010111b & 10101010b << 7 = 00000000b
-01011000b & 10101010b << 0 = 00001000b
-01011000b & 10101010b << 1 = 01010000b
-01011000b & 10101010b << 2 = 00001000b
-01011000b & 10101010b << 3 = 01010000b
-01011000b & 10101010b << 4 = 00000000b
-01011000b & 10101010b << 5 = 01000000b
-01011000b & 10101010b << 6 = 00000000b
-01011000b & 10101010b << 7 = 00000000b
-01011001b & 10101010b << 0 = 00001000b
-01011001b & 10101010b << 1 = 01010000b
-01011001b & 10101010b << 2 = 00001000b
-01011001b & 10101010b << 3 = 01010000b
-01011001b & 10101010b << 4 = 00000000b
-01011001b & 10101010b << 5 = 01000000b
-01011001b & 10101010b << 6 = 00000000b
-01011001b & 10101010b << 7 = 00000000b
-01011010b & 10101010b << 0 = 00001010b
-01011010b & 10101010b << 1 = 01010000b
-01011010b & 10101010b << 2 = 00001000b
-01011010b & 10101010b << 3 = 01010000b
-01011010b & 10101010b << 4 = 00000000b
-01011010b & 10101010b << 5 = 01000000b
-01011010b & 10101010b << 6 = 00000000b
-01011010b & 10101010b << 7 = 00000000b
-01011011b & 10101010b << 0 = 00001010b
-01011011b & 10101010b << 1 = 01010000b
-01011011b & 10101010b << 2 = 00001000b
-01011011b & 10101010b << 3 = 01010000b
-01011011b & 10101010b << 4 = 00000000b
-01011011b & 10101010b << 5 = 01000000b
-01011011b & 10101010b << 6 = 00000000b
-01011011b & 10101010b << 7 = 00000000b
-01011100b & 10101010b << 0 = 00001000b
-01011100b & 10101010b << 1 = 01010100b
-01011100b & 10101010b << 2 = 00001000b
-01011100b & 10101010b << 3 = 01010000b
-01011100b & 10101010b << 4 = 00000000b
-01011100b & 10101010b << 5 = 01000000b
-01011100b & 10101010b << 6 = 00000000b
-01011100b & 10101010b << 7 = 00000000b
-01011101b & 10101010b << 0 = 00001000b
-01011101b & 10101010b << 1 = 01010100b
-01011101b & 10101010b << 2 = 00001000b
-01011101b & 10101010b << 3 = 01010000b
-01011101b & 10101010b << 4 = 00000000b
-01011101b & 10101010b << 5 = 01000000b
-01011101b & 10101010b << 6 = 00000000b
-01011101b & 10101010b << 7 = 00000000b
-01011110b & 10101010b << 0 = 00001010b
-01011110b & 10101010b << 1 = 01010100b
-01011110b & 10101010b << 2 = 00001000b
-01011110b & 10101010b << 3 = 01010000b
-01011110b & 10101010b << 4 = 00000000b
-01011110b & 10101010b << 5 = 01000000b
-01011110b & 10101010b << 6 = 00000000b
-01011110b & 10101010b << 7 = 00000000b
-01011111b & 10101010b << 0 = 00001010b
-01011111b & 10101010b << 1 = 01010100b
-01011111b & 10101010b << 2 = 00001000b
-01011111b & 10101010b << 3 = 01010000b
-01011111b & 10101010b << 4 = 00000000b
-01011111b & 10101010b << 5 = 01000000b
-01011111b & 10101010b << 6 = 00000000b
-01011111b & 10101010b << 7 = 00000000b
-01100000b & 10101010b << 0 = 00100000b
-01100000b & 10101010b << 1 = 01000000b
-01100000b & 10101010b << 2 = 00100000b
-01100000b & 10101010b << 3 = 01000000b
-01100000b & 10101010b << 4 = 00100000b
-01100000b & 10101010b << 5 = 01000000b
-01100000b & 10101010b << 6 = 00000000b
-01100000b & 10101010b << 7 = 00000000b
-01100001b & 10101010b << 0 = 00100000b
-01100001b & 10101010b << 1 = 01000000b
-01100001b & 10101010b << 2 = 00100000b
-01100001b & 10101010b << 3 = 01000000b
-01100001b & 10101010b << 4 = 00100000b
-01100001b & 10101010b << 5 = 01000000b
-01100001b & 10101010b << 6 = 00000000b
-01100001b & 10101010b << 7 = 00000000b
-01100010b & 10101010b << 0 = 00100010b
-01100010b & 10101010b << 1 = 01000000b
-01100010b & 10101010b << 2 = 00100000b
-01100010b & 10101010b << 3 = 01000000b
-01100010b & 10101010b << 4 = 00100000b
-01100010b & 10101010b << 5 = 01000000b
-01100010b & 10101010b << 6 = 00000000b
-01100010b & 10101010b << 7 = 00000000b
-01100011b & 10101010b << 0 = 00100010b
-01100011b & 10101010b << 1 = 01000000b
-01100011b & 10101010b << 2 = 00100000b
-01100011b & 10101010b << 3 = 01000000b
-01100011b & 10101010b << 4 = 00100000b
-01100011b & 10101010b << 5 = 01000000b
-01100011b & 10101010b << 6 = 00000000b
-01100011b & 10101010b << 7 = 00000000b
-01100100b & 10101010b << 0 = 00100000b
-01100100b & 10101010b << 1 = 01000100b
-01100100b & 10101010b << 2 = 00100000b
-01100100b & 10101010b << 3 = 01000000b
-01100100b & 10101010b << 4 = 00100000b
-01100100b & 10101010b << 5 = 01000000b
-01100100b & 10101010b << 6 = 00000000b
-01100100b & 10101010b << 7 = 00000000b
-01100101b & 10101010b << 0 = 00100000b
-01100101b & 10101010b << 1 = 01000100b
-01100101b & 10101010b << 2 = 00100000b
-01100101b & 10101010b << 3 = 01000000b
-01100101b & 10101010b << 4 = 00100000b
-01100101b & 10101010b << 5 = 01000000b
-01100101b & 10101010b << 6 = 00000000b
-01100101b & 10101010b << 7 = 00000000b
-01100110b & 10101010b << 0 = 00100010b
-01100110b & 10101010b << 1 = 01000100b
-01100110b & 10101010b << 2 = 00100000b
-01100110b & 10101010b << 3 = 01000000b
-01100110b & 10101010b << 4 = 00100000b
-01100110b & 10101010b << 5 = 01000000b
-01100110b & 10101010b << 6 = 00000000b
-01100110b & 10101010b << 7 = 00000000b
-01100111b & 10101010b << 0 = 00100010b
-01100111b & 10101010b << 1 = 01000100b
-01100111b & 10101010b << 2 = 00100000b
-01100111b & 10101010b << 3 = 01000000b
-01100111b & 10101010b << 4 = 00100000b
-01100111b & 10101010b << 5 = 01000000b
-01100111b & 10101010b << 6 = 00000000b
-01100111b & 10101010b << 7 = 00000000b
-01101000b & 10101010b << 0 = 00101000b
-01101000b & 10101010b << 1 = 01000000b
-01101000b & 10101010b << 2 = 00101000b
-01101000b & 10101010b << 3 = 01000000b
-01101000b & 10101010b << 4 = 00100000b
-01101000b & 10101010b << 5 = 01000000b
-01101000b & 10101010b << 6 = 00000000b
-01101000b & 10101010b << 7 = 00000000b
-01101001b & 10101010b << 0 = 00101000b
-01101001b & 10101010b << 1 = 01000000b
-01101001b & 10101010b << 2 = 00101000b
-01101001b & 10101010b << 3 = 01000000b
-01101001b & 10101010b << 4 = 00100000b
-01101001b & 10101010b << 5 = 01000000b
-01101001b & 10101010b << 6 = 00000000b
-01101001b & 10101010b << 7 = 00000000b
-01101010b & 10101010b << 0 = 00101010b
-01101010b & 10101010b << 1 = 01000000b
-01101010b & 10101010b << 2 = 00101000b
-01101010b & 10101010b << 3 = 01000000b
-01101010b & 10101010b << 4 = 00100000b
-01101010b & 10101010b << 5 = 01000000b
-01101010b & 10101010b << 6 = 00000000b
-01101010b & 10101010b << 7 = 00000000b
-01101011b & 10101010b << 0 = 00101010b
-01101011b & 10101010b << 1 = 01000000b
-01101011b & 10101010b << 2 = 00101000b
-01101011b & 10101010b << 3 = 01000000b
-01101011b & 10101010b << 4 = 00100000b
-01101011b & 10101010b << 5 = 01000000b
-01101011b & 10101010b << 6 = 00000000b
-01101011b & 10101010b << 7 = 00000000b
-01101100b & 10101010b << 0 = 00101000b
-01101100b & 10101010b << 1 = 01000100b
-01101100b & 10101010b << 2 = 00101000b
-01101100b & 10101010b << 3 = 01000000b
-01101100b & 10101010b << 4 = 00100000b
-01101100b & 10101010b << 5 = 01000000b
-01101100b & 10101010b << 6 = 00000000b
-01101100b & 10101010b << 7 = 00000000b
-01101101b & 10101010b << 0 = 00101000b
-01101101b & 10101010b << 1 = 01000100b
-01101101b & 10101010b << 2 = 00101000b
-01101101b & 10101010b << 3 = 01000000b
-01101101b & 10101010b << 4 = 00100000b
-01101101b & 10101010b << 5 = 01000000b
-01101101b & 10101010b << 6 = 00000000b
-01101101b & 10101010b << 7 = 00000000b
-01101110b & 10101010b << 0 = 00101010b
-01101110b & 10101010b << 1 = 01000100b
-01101110b & 10101010b << 2 = 00101000b
-01101110b & 10101010b << 3 = 01000000b
-01101110b & 10101010b << 4 = 00100000b
-01101110b & 10101010b << 5 = 01000000b
-01101110b & 10101010b << 6 = 00000000b
-01101110b & 10101010b << 7 = 00000000b
-01101111b & 10101010b << 0 = 00101010b
-01101111b & 10101010b << 1 = 01000100b
-01101111b & 10101010b << 2 = 00101000b
-01101111b & 10101010b << 3 = 01000000b
-01101111b & 10101010b << 4 = 00100000b
-01101111b & 10101010b << 5 = 01000000b
-01101111b & 10101010b << 6 = 00000000b
-01101111b & 10101010b << 7 = 00000000b
-01110000b & 10101010b << 0 = 00100000b
-01110000b & 10101010b << 1 = 01010000b
-01110000b & 10101010b << 2 = 00100000b
-01110000b & 10101010b << 3 = 01010000b
-01110000b & 10101010b << 4 = 00100000b
-01110000b & 10101010b << 5 = 01000000b
-01110000b & 10101010b << 6 = 00000000b
-01110000b & 10101010b << 7 = 00000000b
-01110001b & 10101010b << 0 = 00100000b
-01110001b & 10101010b << 1 = 01010000b
-01110001b & 10101010b << 2 = 00100000b
-01110001b & 10101010b << 3 = 01010000b
-01110001b & 10101010b << 4 = 00100000b
-01110001b & 10101010b << 5 = 01000000b
-01110001b & 10101010b << 6 = 00000000b
-01110001b & 10101010b << 7 = 00000000b
-01110010b & 10101010b << 0 = 00100010b
-01110010b & 10101010b << 1 = 01010000b
-01110010b & 10101010b << 2 = 00100000b
-01110010b & 10101010b << 3 = 01010000b
-01110010b & 10101010b << 4 = 00100000b
-01110010b & 10101010b << 5 = 01000000b
-01110010b & 10101010b << 6 = 00000000b
-01110010b & 10101010b << 7 = 00000000b
-01110011b & 10101010b << 0 = 00100010b
-01110011b & 10101010b << 1 = 01010000b
-01110011b & 10101010b << 2 = 00100000b
-01110011b & 10101010b << 3 = 01010000b
-01110011b & 10101010b << 4 = 00100000b
-01110011b & 10101010b << 5 = 01000000b
-01110011b & 10101010b << 6 = 00000000b
-01110011b & 10101010b << 7 = 00000000b
-01110100b & 10101010b << 0 = 00100000b
-01110100b & 10101010b << 1 = 01010100b
-01110100b & 10101010b << 2 = 00100000b
-01110100b & 10101010b << 3 = 01010000b
-01110100b & 10101010b << 4 = 00100000b
-01110100b & 10101010b << 5 = 01000000b
-01110100b & 10101010b << 6 = 00000000b
-01110100b & 10101010b << 7 = 00000000b
-01110101b & 10101010b << 0 = 00100000b
-01110101b & 10101010b << 1 = 01010100b
-01110101b & 10101010b << 2 = 00100000b
-01110101b & 10101010b << 3 = 01010000b
-01110101b & 10101010b << 4 = 00100000b
-01110101b & 10101010b << 5 = 01000000b
-01110101b & 10101010b << 6 = 00000000b
-01110101b & 10101010b << 7 = 00000000b
-01110110b & 10101010b << 0 = 00100010b
-01110110b & 10101010b << 1 = 01010100b
-01110110b & 10101010b << 2 = 00100000b
-01110110b & 10101010b << 3 = 01010000b
-01110110b & 10101010b << 4 = 00100000b
-01110110b & 10101010b << 5 = 01000000b
-01110110b & 10101010b << 6 = 00000000b
-01110110b & 10101010b << 7 = 00000000b
-01110111b & 10101010b << 0 = 00100010b
-01110111b & 10101010b << 1 = 01010100b
-01110111b & 10101010b << 2 = 00100000b
-01110111b & 10101010b << 3 = 01010000b
-01110111b & 10101010b << 4 = 00100000b
-01110111b & 10101010b << 5 = 01000000b
-01110111b & 10101010b << 6 = 00000000b
-01110111b & 10101010b << 7 = 00000000b
-01111000b & 10101010b << 0 = 00101000b
-01111000b & 10101010b << 1 = 01010000b
-01111000b & 10101010b << 2 = 00101000b
-01111000b & 10101010b << 3 = 01010000b
-01111000b & 10101010b << 4 = 00100000b
-01111000b & 10101010b << 5 = 01000000b
-01111000b & 10101010b << 6 = 00000000b
-01111000b & 10101010b << 7 = 00000000b
-01111001b & 10101010b << 0 = 00101000b
-01111001b & 10101010b << 1 = 01010000b
-01111001b & 10101010b << 2 = 00101000b
-01111001b & 10101010b << 3 = 01010000b
-01111001b & 10101010b << 4 = 00100000b
-01111001b & 10101010b << 5 = 01000000b
-01111001b & 10101010b << 6 = 00000000b
-01111001b & 10101010b << 7 = 00000000b
-01111010b & 10101010b << 0 = 00101010b
-01111010b & 10101010b << 1 = 01010000b
-01111010b & 10101010b << 2 = 00101000b
-01111010b & 10101010b << 3 = 01010000b
-01111010b & 10101010b << 4 = 00100000b
-01111010b & 10101010b << 5 = 01000000b
-01111010b & 10101010b << 6 = 00000000b
-01111010b & 10101010b << 7 = 00000000b
-01111011b & 10101010b << 0 = 00101010b
-01111011b & 10101010b << 1 = 01010000b
-01111011b & 10101010b << 2 = 00101000b
-01111011b & 10101010b << 3 = 01010000b
-01111011b & 10101010b << 4 = 00100000b
-01111011b & 10101010b << 5 = 01000000b
-01111011b & 10101010b << 6 = 00000000b
-01111011b & 10101010b << 7 = 00000000b
-01111100b & 10101010b << 0 = 00101000b
-01111100b & 10101010b << 1 = 01010100b
-01111100b & 10101010b << 2 = 00101000b
-01111100b & 10101010b << 3 = 01010000b
-01111100b & 10101010b << 4 = 00100000b
-01111100b & 10101010b << 5 = 01000000b
-01111100b & 10101010b << 6 = 00000000b
-01111100b & 10101010b << 7 = 00000000b
-01111101b & 10101010b << 0 = 00101000b
-01111101b & 10101010b << 1 = 01010100b
-01111101b & 10101010b << 2 = 00101000b
-01111101b & 10101010b << 3 = 01010000b
-01111101b & 10101010b << 4 = 00100000b
-01111101b & 10101010b << 5 = 01000000b
-01111101b & 10101010b << 6 = 00000000b
-01111101b & 10101010b << 7 = 00000000b
-01111110b & 10101010b << 0 = 00101010b
-01111110b & 10101010b << 1 = 01010100b
-01111110b & 10101010b << 2 = 00101000b
-01111110b & 10101010b << 3 = 01010000b
-01111110b & 10101010b << 4 = 00100000b
-01111110b & 10101010b << 5 = 01000000b
-01111110b & 10101010b << 6 = 00000000b
-01111110b & 10101010b << 7 = 00000000b
diff --git a/tests/valid/Byte_Valid_9.whiley b/tests/valid/Byte_Valid_9.whiley
index 40eb69f09e..b6a744ebe7 100644
--- a/tests/valid/Byte_Valid_9.whiley
+++ b/tests/valid/Byte_Valid_9.whiley
@@ -1,11 +1,36 @@
-import whiley.lang.*
-import print from whiley.lang.*
+
constant constants is [10000000b, 10000001b, 10000010b, 10000011b, 10000100b, 10000101b, 10000110b, 10000111b, 10001000b, 10001001b, 10001010b, 10001011b, 10001100b, 10001101b, 10001110b, 10001111b, 10010000b, 10010001b, 10010010b, 10010011b, 10010100b, 10010101b, 10010110b, 10010111b, 10011000b, 10011001b, 10011010b, 10011011b, 10011100b, 10011101b, 10011110b, 10011111b, 10100000b, 10100001b, 10100010b, 10100011b, 10100100b, 10100101b, 10100110b, 10100111b, 10101000b, 10101001b, 10101010b, 10101011b, 10101100b, 10101101b, 10101110b, 10101111b, 10110000b, 10110001b, 10110010b, 10110011b, 10110100b, 10110101b, 10110110b, 10110111b, 10111000b, 10111001b, 10111010b, 10111011b, 10111100b, 10111101b, 10111110b, 10111111b, 11000000b, 11000001b, 11000010b, 11000011b, 11000100b, 11000101b, 11000110b, 11000111b, 11001000b, 11001001b, 11001010b, 11001011b, 11001100b, 11001101b, 11001110b, 11001111b, 11010000b, 11010001b, 11010010b, 11010011b, 11010100b, 11010101b, 11010110b, 11010111b, 11011000b, 11011001b, 11011010b, 11011011b, 11011100b, 11011101b, 11011110b, 11011111b, 11100000b, 11100001b, 11100010b, 11100011b, 11100100b, 11100101b, 11100110b, 11100111b, 11101000b, 11101001b, 11101010b, 11101011b, 11101100b, 11101101b, 11101110b, 11101111b, 11110000b, 11110001b, 11110010b, 11110011b, 11110100b, 11110101b, 11110110b, 11110111b, 11111000b, 11111001b, 11111010b, 11111011b, 11111100b, 11111101b, 11111110b, 11111111b, 00000000b, 00000001b, 00000010b, 00000011b, 00000100b, 00000101b, 00000110b, 00000111b, 00001000b, 00001001b, 00001010b, 00001011b, 00001100b, 00001101b, 00001110b, 00001111b, 00010000b, 00010001b, 00010010b, 00010011b, 00010100b, 00010101b, 00010110b, 00010111b, 00011000b, 00011001b, 00011010b, 00011011b, 00011100b, 00011101b, 00011110b, 00011111b, 00100000b, 00100001b, 00100010b, 00100011b, 00100100b, 00100101b, 00100110b, 00100111b, 00101000b, 00101001b, 00101010b, 00101011b, 00101100b, 00101101b, 00101110b, 00101111b, 00110000b, 00110001b, 00110010b, 00110011b, 00110100b, 00110101b, 00110110b, 00110111b, 00111000b, 00111001b, 00111010b, 00111011b, 00111100b, 00111101b, 00111110b, 00111111b, 01000000b, 01000001b, 01000010b, 01000011b, 01000100b, 01000101b, 01000110b, 01000111b, 01001000b, 01001001b, 01001010b, 01001011b, 01001100b, 01001101b, 01001110b, 01001111b, 01010000b, 01010001b, 01010010b, 01010011b, 01010100b, 01010101b, 01010110b, 01010111b, 01011000b, 01011001b, 01011010b, 01011011b, 01011100b, 01011101b, 01011110b, 01011111b, 01100000b, 01100001b, 01100010b, 01100011b, 01100100b, 01100101b, 01100110b, 01100111b, 01101000b, 01101001b, 01101010b, 01101011b, 01101100b, 01101101b, 01101110b, 01101111b, 01110000b, 01110001b, 01110010b, 01110011b, 01110100b, 01110101b, 01110110b, 01110111b, 01111000b, 01111001b, 01111010b, 01111011b, 01111100b, 01111101b, 01111110b]
-public method main(System.Console sys) -> void:
- for i in constants:
- for j in 0 .. 8:
- sys.out.print_s(Any.toString(i) ++ " & 10101010b << ")
- sys.out.print_s(Any.toString(j) ++ " = ")
- sys.out.println_s(Any.toString(i & (10101010b << j)))
+function set(byte b, int i) -> bool:
+ byte mask = 1b << i
+ return (b&mask) == mask
+
+function shr(byte b, int i) -> byte:
+ while i > 0:
+ b = b << 1
+ i = i - 1
+ return b
+
+function and(byte b1, byte b2) -> byte:
+ byte mask = 1b
+ byte r = 0b
+ int i = 0
+ while i < 8:
+ if set(b1,i) && set(b2,i):
+ r = r | mask
+ mask = mask << 1
+ i = i + 1
+ //
+ return r
+
+public export method test() -> void:
+ int i = 0
+ while i < |constants|:
+ byte constant_i = constants[i]
+ int j = 0
+ while j < 9:
+ assume (constant_i & (10101010b << j)) == and(constant_i,shr(10101010b,j))
+ j = j + 1
+ //
+ i = i + 1
diff --git a/tests/valid/Cast_Valid_1.sysout b/tests/valid/Cast_Valid_1.sysout
deleted file mode 100644
index d3827e75a5..0000000000
--- a/tests/valid/Cast_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1.0
diff --git a/tests/valid/Cast_Valid_1.whiley b/tests/valid/Cast_Valid_1.whiley
index 0ee07752c1..954370e7d1 100644
--- a/tests/valid/Cast_Valid_1.whiley
+++ b/tests/valid/Cast_Valid_1.whiley
@@ -1,9 +1,7 @@
-import whiley.lang.*
-type R1 is {real x}
function f(int i) -> real:
return (real) i
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f(1) == 1.0
diff --git a/tests/valid/Cast_Valid_2.sysout b/tests/valid/Cast_Valid_2.sysout
deleted file mode 100644
index 2aa307052c..0000000000
--- a/tests/valid/Cast_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1.0, 2.0, 3.0]
diff --git a/tests/valid/Cast_Valid_2.whiley b/tests/valid/Cast_Valid_2.whiley
index d15f41a6c3..ed1c19b929 100644
--- a/tests/valid/Cast_Valid_2.whiley
+++ b/tests/valid/Cast_Valid_2.whiley
@@ -1,9 +1,7 @@
-import whiley.lang.*
-type R1 is {real x}
function f([int] xs) -> [real]:
return ([real]) xs
-method main(System.Console sys) -> void:
- sys.out.println(f([1, 2, 3]))
+public export method test() -> void:
+ assume f([1, 2, 3]) == [1.0, 2.0, 3.0]
diff --git a/tests/valid/Cast_Valid_3.sysout b/tests/valid/Cast_Valid_3.sysout
deleted file mode 100644
index 15ea4944cb..0000000000
--- a/tests/valid/Cast_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{x:123542.0}
diff --git a/tests/valid/Cast_Valid_3.whiley b/tests/valid/Cast_Valid_3.whiley
index 10abb9a81a..2d7a3265a8 100644
--- a/tests/valid/Cast_Valid_3.whiley
+++ b/tests/valid/Cast_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type R1 is {real x}
@@ -7,5 +7,5 @@ type R2 is {int x}
function f(R2 i) -> R1:
return (R1) i
-method main(System.Console sys) -> void:
- sys.out.println(f({x: 123542}))
+public export method test() -> void:
+ assume f({x: 123542}) == {x: 123542.0}
diff --git a/tests/valid/Cast_Valid_4.sysout b/tests/valid/Cast_Valid_4.sysout
deleted file mode 100644
index 999a81f3a9..0000000000
--- a/tests/valid/Cast_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{x:123542.0,y:123}
diff --git a/tests/valid/Cast_Valid_4.whiley b/tests/valid/Cast_Valid_4.whiley
index 42d7a988d3..fd55176f83 100644
--- a/tests/valid/Cast_Valid_4.whiley
+++ b/tests/valid/Cast_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type R1 is {int y, real x}
@@ -9,5 +9,5 @@ type R3 is {int y, int x}
function f(R3 i) -> R1 | R2:
return (R1) i
-method main(System.Console sys) -> void:
- sys.out.println(f({y: 123, x: 123542}))
+public export method test() -> void:
+ assume f({y: 123, x: 123542}) == {y: 123, x: 123542.0}
diff --git a/tests/valid/Cast_Valid_5.sysout b/tests/valid/Cast_Valid_5.sysout
deleted file mode 100644
index 3bc7fbc7be..0000000000
--- a/tests/valid/Cast_Valid_5.sysout
+++ /dev/null
@@ -1,95 +0,0 @@
-
-!
-"
-#
-$
-%
-&
-'
-(
-)
-*
-+
-,
--
-.
-/
-0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-:
-;
-<
-=
->
-?
-@
-A
-B
-C
-D
-E
-F
-G
-H
-I
-J
-K
-L
-M
-N
-O
-P
-Q
-R
-S
-T
-U
-V
-W
-X
-Y
-Z
-[
-\
-]
-^
-_
-`
-a
-b
-c
-d
-e
-f
-g
-h
-i
-j
-k
-l
-m
-n
-o
-p
-q
-r
-s
-t
-u
-v
-w
-x
-y
-z
-{
-|
-}
-~
diff --git a/tests/valid/Cast_Valid_5.whiley b/tests/valid/Cast_Valid_5.whiley
index 503a905ec6..68fb429e51 100644
--- a/tests/valid/Cast_Valid_5.whiley
+++ b/tests/valid/Cast_Valid_5.whiley
@@ -1,5 +1,4 @@
-import whiley.lang.*
-import whiley.lang.*
+
type u8 is (int n) where 0 >= n && n <= 255
@@ -26,7 +25,10 @@ public function toUnsignedByte(u8 v) -> byte:
mask = mask << 1
return r
-method main(System.Console sys) -> void:
- for i in 32 .. 127:
+public export method test() -> void:
+ int i = 32
+ while i < 127:
int c = toUnsignedInt(toUnsignedByte(i))
- sys.out.println_s([c])
+ assume c == i
+ i = i + 1
+ //
diff --git a/tests/valid/Cast_Valid_6.sysout b/tests/valid/Cast_Valid_6.sysout
deleted file mode 100644
index a9470b0995..0000000000
--- a/tests/valid/Cast_Valid_6.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-10.0 / 2 = 5.0
-10.0 / 3 = (10/3)
diff --git a/tests/valid/Cast_Valid_6.whiley b/tests/valid/Cast_Valid_6.whiley
index 1881bf1b34..d580cd2a51 100644
--- a/tests/valid/Cast_Valid_6.whiley
+++ b/tests/valid/Cast_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function divide(real lhs, int rhs) -> real
requires rhs > 0:
@@ -7,6 +7,6 @@ requires rhs > 0:
//
return lhs / tmp
-method main(System.Console console):
- console.out.println_s("10.0 / 2 = " ++ Any.toString(divide(10.0,2)))
- console.out.println_s("10.0 / 3 = " ++ Any.toString(divide(10.0,3)))
+public export method test():
+ assume divide(10.0,2) == 5.0
+ assume divide(10.0,3) == (5.0 / 1.5)
diff --git a/tests/valid/Coercion_Valid_1.sysout b/tests/valid/Coercion_Valid_1.sysout
deleted file mode 100644
index 63453cc2a6..0000000000
--- a/tests/valid/Coercion_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-123.0
diff --git a/tests/valid/Coercion_Valid_1.whiley b/tests/valid/Coercion_Valid_1.whiley
index 068a5182d4..ac44a3b67b 100644
--- a/tests/valid/Coercion_Valid_1.whiley
+++ b/tests/valid/Coercion_Valid_1.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f(int x) -> real:
return (real) x
-method main(System.Console sys) -> void:
- sys.out.println(f(123))
+public export method test() -> void:
+ assume f(123) == 123.0
diff --git a/tests/valid/Coercion_Valid_2.sysout b/tests/valid/Coercion_Valid_2.sysout
deleted file mode 100644
index 0e0f29b77b..0000000000
--- a/tests/valid/Coercion_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
diff --git a/tests/valid/Coercion_Valid_2.whiley b/tests/valid/Coercion_Valid_2.whiley
index 8d7a37e243..3eb058243b 100644
--- a/tests/valid/Coercion_Valid_2.whiley
+++ b/tests/valid/Coercion_Valid_2.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f([int] x) -> [int]:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f("Hello World"))
+public export method test() -> void:
+ assume f("Hello World") == [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
diff --git a/tests/valid/Coercion_Valid_3.sysout b/tests/valid/Coercion_Valid_3.sysout
deleted file mode 100644
index ea70ce0134..0000000000
--- a/tests/valid/Coercion_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-72
diff --git a/tests/valid/Coercion_Valid_3.whiley b/tests/valid/Coercion_Valid_3.whiley
index 4c2d6f99da..d9493fb44c 100644
--- a/tests/valid/Coercion_Valid_3.whiley
+++ b/tests/valid/Coercion_Valid_3.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f(int x) -> int:
return (int) x
-method main(System.Console sys) -> void:
- sys.out.println(f('H'))
+public export method test() -> void:
+ assume f('H') == 72
diff --git a/tests/valid/Coercion_Valid_4.sysout b/tests/valid/Coercion_Valid_4.sysout
deleted file mode 100644
index ae6f194ee9..0000000000
--- a/tests/valid/Coercion_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{0=>1.2, 1=>2.3}
diff --git a/tests/valid/Coercion_Valid_4.whiley b/tests/valid/Coercion_Valid_4.whiley
index 6f4fe042df..2ec95830c6 100644
--- a/tests/valid/Coercion_Valid_4.whiley
+++ b/tests/valid/Coercion_Valid_4.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f([real] x) -> {int=>real}:
return ({int=>real}) x
-method main(System.Console sys) -> void:
- sys.out.println(f([1.2, 2.3]))
+public export method test() -> void:
+ assume f([1.2, 2.3]) == {0=>1.2,1=>2.3}
diff --git a/tests/valid/Coercion_Valid_6.sysout b/tests/valid/Coercion_Valid_6.sysout
deleted file mode 100644
index f32f3ccab2..0000000000
--- a/tests/valid/Coercion_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{2.2, 3.3}
diff --git a/tests/valid/Coercion_Valid_6.whiley b/tests/valid/Coercion_Valid_6.whiley
index ad11463932..d1f339eaf6 100644
--- a/tests/valid/Coercion_Valid_6.whiley
+++ b/tests/valid/Coercion_Valid_6.whiley
@@ -1,8 +1,7 @@
-import whiley.lang.*
+
function f([real] x) -> {real}:
return ({real}) x
-method main(System.Console sys) -> void:
- {real} x = f([2.2, 3.3])
- sys.out.println(x)
+public export method test() -> void:
+ assume f([2.2, 3.3]) == {2.2,3.3}
diff --git a/tests/valid/Coercion_Valid_7.sysout b/tests/valid/Coercion_Valid_7.sysout
deleted file mode 100644
index a247b96d92..0000000000
--- a/tests/valid/Coercion_Valid_7.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-123
diff --git a/tests/valid/Coercion_Valid_7.whiley b/tests/valid/Coercion_Valid_7.whiley
index 4c97cc316f..dc3370c379 100644
--- a/tests/valid/Coercion_Valid_7.whiley
+++ b/tests/valid/Coercion_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int | bool x) -> int:
if x is int:
@@ -6,6 +6,6 @@ function f(int | bool x) -> int:
else:
return 1
-method main(System.Console sys) -> void:
- sys.out.println(f(true))
- sys.out.println(f(123))
+public export method test() -> void:
+ assume f(true) == 1
+ assume f(123) == 123
diff --git a/tests/valid/Coercion_Valid_8.sysout b/tests/valid/Coercion_Valid_8.sysout
deleted file mode 100644
index 622d57730a..0000000000
--- a/tests/valid/Coercion_Valid_8.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-3.0
-3.0
-1.0
-1.234
diff --git a/tests/valid/Coercion_Valid_8.whiley b/tests/valid/Coercion_Valid_8.whiley
index a78adfe76d..8e2ca22f43 100644
--- a/tests/valid/Coercion_Valid_8.whiley
+++ b/tests/valid/Coercion_Valid_8.whiley
@@ -1,15 +1,13 @@
-import whiley.lang.*
+
type Expr is real | [Expr]
function f(Expr x) -> real:
if x is [Expr]:
- return |x|
+ return (real) |x|
else:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f([1, 2, 3]))
- sys.out.println(f([1.0, 2.0, 3.0]))
- sys.out.println(f(1))
- sys.out.println(f(1.234))
+public export method test() -> void:
+ assume f([1.0, 2.0, 3.0]) == 3.0
+ assume f(1.234) == 1.234
diff --git a/tests/valid/Coercion_Valid_9.sysout b/tests/valid/Coercion_Valid_9.sysout
deleted file mode 100644
index d00491fd7e..0000000000
--- a/tests/valid/Coercion_Valid_9.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Coercion_Valid_9.whiley b/tests/valid/Coercion_Valid_9.whiley
index 20f89c04ca..24510f8a6e 100644
--- a/tests/valid/Coercion_Valid_9.whiley
+++ b/tests/valid/Coercion_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
type Link is {int data}
type BigLink is {int data, int code}
@@ -9,6 +9,6 @@ function sum(Link l) -> int:
function sum2(BigLink l) -> int:
return sum((Link) l)
-method main(System.Console console):
+public export method test():
BigLink l = {data: 1, code: 'c'}
- console.out.println(sum2(l))
+ assume sum2(l) == 1
diff --git a/tests/valid/Complex_Valid_1.sysout b/tests/valid/Complex_Valid_1.sysout
deleted file mode 100644
index dfbaecc1a0..0000000000
--- a/tests/valid/Complex_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-GOT: false
-GOT: true
diff --git a/tests/valid/Complex_Valid_1.whiley b/tests/valid/Complex_Valid_1.whiley
index 53ac3e50eb..b44e528c1c 100644
--- a/tests/valid/Complex_Valid_1.whiley
+++ b/tests/valid/Complex_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant PAWN is 0
@@ -85,8 +85,6 @@ constant A3 is {col: 1, row: 3}
constant D3 is {col: 4, row: 3}
-method main(System.Console sys) -> void:
- bool r = clearRowExcept(A1, H1, startingChessBoard)
- sys.out.println_s("GOT: " ++ Any.toString(r))
- r = clearRowExcept(A3, D3, startingChessBoard)
- sys.out.println_s("GOT: " ++ Any.toString(r))
+public export method test() -> void:
+ assume clearRowExcept(A1, H1, startingChessBoard) == false
+ assume clearRowExcept(A3, D3, startingChessBoard) == true
diff --git a/tests/valid/Complex_Valid_2.sysout b/tests/valid/Complex_Valid_2.sysout
deleted file mode 100644
index 4125d339cd..0000000000
--- a/tests/valid/Complex_Valid_2.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-a2-a1
-Na2-a1
-Qa2xKa1
diff --git a/tests/valid/Complex_Valid_2.whiley b/tests/valid/Complex_Valid_2.whiley
index ddaddaaaab..3f5bb89c4f 100644
--- a/tests/valid/Complex_Valid_2.whiley
+++ b/tests/valid/Complex_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type string is [int]
@@ -97,10 +97,11 @@ function piece2str(Piece p) -> string:
function pos2str(Pos p) -> string:
return ['a' + p.col,'1' + p.row]
-method main(System.Console sys) -> void:
+public export method test() -> void:
Move m = {to: A1, from: A2, piece: WHITE_PAWN}
- sys.out.println_s(move2str(m))
+ assume move2str(m) == "a2-a1"
m = {to: A1, from: A2, piece: WHITE_KNIGHT}
- sys.out.println_s(move2str(m))
+ assume move2str(m) == "Na2-a1"
m = {to: A1, taken: BLACK_KING, from: A2, piece: WHITE_QUEEN}
- sys.out.println_s(move2str(m))
+ assume move2str(m) == "Qa2xKa1"
+
diff --git a/tests/valid/Complex_Valid_3.whiley b/tests/valid/Complex_Valid_3.whiley
index 6bea068ab3..a8f509da6c 100644
--- a/tests/valid/Complex_Valid_3.whiley
+++ b/tests/valid/Complex_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type BTree is (null | {
int item, // data item
@@ -35,14 +35,21 @@ function contains(BTree tree, int item) -> bool:
else:
return contains(tree.right, item)
-constant items is [5, 4, 6, 3, 7, 2, 8, 1, 9]
-
-public method main(System.Console console) -> void:
- tree = BTree()
- for item in items:
- tree = add(tree, item)
- for item in items:
- if contains(tree, item):
- console.out.println_s("TREE CONTAINS: " ++ item)
- else:
- console.out.println_s("TREE DOES NOT CONTAIN: " ++ item)
+public export method test() -> void:
+ BTree tree = BTree()
+ tree = add(tree, 1)
+ tree = add(tree, 2)
+ tree = add(tree, 3)
+ tree = add(tree, 4)
+ tree = add(tree, 5)
+ tree = add(tree, 6)
+ //
+ assume contains(tree,5) == true
+ assume contains(tree,4) == true
+ assume contains(tree,6) == true
+ assume contains(tree,3) == true
+ assume contains(tree,7) == false
+ assume contains(tree,2) == true
+ assume contains(tree,8) == false
+ assume contains(tree,1) == true
+ assume contains(tree,9) == false
diff --git a/tests/valid/Complex_Valid_4.sysout b/tests/valid/Complex_Valid_4.sysout
deleted file mode 100644
index 6f8dfe347b..0000000000
--- a/tests/valid/Complex_Valid_4.sysout
+++ /dev/null
@@ -1,9 +0,0 @@
-TREE CONTAINS: 5
-TREE CONTAINS: 4
-TREE CONTAINS: 6
-TREE CONTAINS: 3
-TREE CONTAINS: 7
-TREE CONTAINS: 2
-TREE CONTAINS: 8
-TREE CONTAINS: 1
-TREE CONTAINS: 9
diff --git a/tests/valid/Complex_Valid_4.whiley b/tests/valid/Complex_Valid_4.whiley
index dd6cf44079..2efd97ab21 100644
--- a/tests/valid/Complex_Valid_4.whiley
+++ b/tests/valid/Complex_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type BTree is null | {int item, BTree left, BTree right}
@@ -29,12 +29,21 @@ function contains(BTree tree, int item) -> bool:
constant items is [5, 4, 6, 3, 7, 2, 8, 1, 9]
-public method main(System.Console console) -> void:
+public export method test() -> void:
BTree tree = BTree()
- for item in items:
- tree = add(tree, item)
- for item in items:
- if contains(tree, item):
- console.out.println_s("TREE CONTAINS: " ++ Any.toString(item))
- else:
- console.out.println_s("TREE DOES NOT CONTAIN: " ++ Any.toString(item))
+ tree = add(tree, 1)
+ tree = add(tree, 2)
+ tree = add(tree, 3)
+ tree = add(tree, 4)
+ tree = add(tree, 5)
+ tree = add(tree, 6)
+ //
+ assume contains(tree,5) == true
+ assume contains(tree,4) == true
+ assume contains(tree,6) == true
+ assume contains(tree,3) == true
+ assume contains(tree,7) == false
+ assume contains(tree,2) == true
+ assume contains(tree,8) == false
+ assume contains(tree,1) == true
+ assume contains(tree,9) == false
diff --git a/tests/valid/Complex_Valid_5.sysout b/tests/valid/Complex_Valid_5.sysout
deleted file mode 100644
index 210e6c314d..0000000000
--- a/tests/valid/Complex_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-BOARD: {move:0,pieces:[1, 0, 0, 0, 0, 0, 0, 0, 0]}
diff --git a/tests/valid/Complex_Valid_5.whiley b/tests/valid/Complex_Valid_5.whiley
index bcafbe72a5..04db6a9bb8 100644
--- a/tests/valid/Complex_Valid_5.whiley
+++ b/tests/valid/Complex_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant BLANK is 0
@@ -22,7 +22,7 @@ requires pos < 9:
b.pieces[pos] = p
return b
-method main(System.Console console) -> void:
+public export method test() -> void:
Board b = EmptyBoard()
b = play(b, CIRCLE, 0)
- console.out.println_s("BOARD: " ++ Any.toString(b))
+ assume b == {move:0,pieces:[1, 0, 0, 0, 0, 0, 0, 0, 0]}
diff --git a/tests/valid/Complex_Valid_6.sysout b/tests/valid/Complex_Valid_6.sysout
deleted file mode 100644
index 2c0f06a03d..0000000000
--- a/tests/valid/Complex_Valid_6.sysout
+++ /dev/null
@@ -1,400 +0,0 @@
-DIFF(-10,-10) = 0
-DIFF(-10,-9) = 1
-DIFF(-10,-8) = 2
-DIFF(-10,-7) = 3
-DIFF(-10,-6) = 4
-DIFF(-10,-5) = 5
-DIFF(-10,-4) = 6
-DIFF(-10,-3) = 7
-DIFF(-10,-2) = 8
-DIFF(-10,-1) = 9
-DIFF(-10,0) = 10
-DIFF(-10,1) = 11
-DIFF(-10,2) = 12
-DIFF(-10,3) = 13
-DIFF(-10,4) = 14
-DIFF(-10,5) = 15
-DIFF(-10,6) = 16
-DIFF(-10,7) = 17
-DIFF(-10,8) = 18
-DIFF(-10,9) = 19
-DIFF(-9,-10) = 1
-DIFF(-9,-9) = 0
-DIFF(-9,-8) = 1
-DIFF(-9,-7) = 2
-DIFF(-9,-6) = 3
-DIFF(-9,-5) = 4
-DIFF(-9,-4) = 5
-DIFF(-9,-3) = 6
-DIFF(-9,-2) = 7
-DIFF(-9,-1) = 8
-DIFF(-9,0) = 9
-DIFF(-9,1) = 10
-DIFF(-9,2) = 11
-DIFF(-9,3) = 12
-DIFF(-9,4) = 13
-DIFF(-9,5) = 14
-DIFF(-9,6) = 15
-DIFF(-9,7) = 16
-DIFF(-9,8) = 17
-DIFF(-9,9) = 18
-DIFF(-8,-10) = 2
-DIFF(-8,-9) = 1
-DIFF(-8,-8) = 0
-DIFF(-8,-7) = 1
-DIFF(-8,-6) = 2
-DIFF(-8,-5) = 3
-DIFF(-8,-4) = 4
-DIFF(-8,-3) = 5
-DIFF(-8,-2) = 6
-DIFF(-8,-1) = 7
-DIFF(-8,0) = 8
-DIFF(-8,1) = 9
-DIFF(-8,2) = 10
-DIFF(-8,3) = 11
-DIFF(-8,4) = 12
-DIFF(-8,5) = 13
-DIFF(-8,6) = 14
-DIFF(-8,7) = 15
-DIFF(-8,8) = 16
-DIFF(-8,9) = 17
-DIFF(-7,-10) = 3
-DIFF(-7,-9) = 2
-DIFF(-7,-8) = 1
-DIFF(-7,-7) = 0
-DIFF(-7,-6) = 1
-DIFF(-7,-5) = 2
-DIFF(-7,-4) = 3
-DIFF(-7,-3) = 4
-DIFF(-7,-2) = 5
-DIFF(-7,-1) = 6
-DIFF(-7,0) = 7
-DIFF(-7,1) = 8
-DIFF(-7,2) = 9
-DIFF(-7,3) = 10
-DIFF(-7,4) = 11
-DIFF(-7,5) = 12
-DIFF(-7,6) = 13
-DIFF(-7,7) = 14
-DIFF(-7,8) = 15
-DIFF(-7,9) = 16
-DIFF(-6,-10) = 4
-DIFF(-6,-9) = 3
-DIFF(-6,-8) = 2
-DIFF(-6,-7) = 1
-DIFF(-6,-6) = 0
-DIFF(-6,-5) = 1
-DIFF(-6,-4) = 2
-DIFF(-6,-3) = 3
-DIFF(-6,-2) = 4
-DIFF(-6,-1) = 5
-DIFF(-6,0) = 6
-DIFF(-6,1) = 7
-DIFF(-6,2) = 8
-DIFF(-6,3) = 9
-DIFF(-6,4) = 10
-DIFF(-6,5) = 11
-DIFF(-6,6) = 12
-DIFF(-6,7) = 13
-DIFF(-6,8) = 14
-DIFF(-6,9) = 15
-DIFF(-5,-10) = 5
-DIFF(-5,-9) = 4
-DIFF(-5,-8) = 3
-DIFF(-5,-7) = 2
-DIFF(-5,-6) = 1
-DIFF(-5,-5) = 0
-DIFF(-5,-4) = 1
-DIFF(-5,-3) = 2
-DIFF(-5,-2) = 3
-DIFF(-5,-1) = 4
-DIFF(-5,0) = 5
-DIFF(-5,1) = 6
-DIFF(-5,2) = 7
-DIFF(-5,3) = 8
-DIFF(-5,4) = 9
-DIFF(-5,5) = 10
-DIFF(-5,6) = 11
-DIFF(-5,7) = 12
-DIFF(-5,8) = 13
-DIFF(-5,9) = 14
-DIFF(-4,-10) = 6
-DIFF(-4,-9) = 5
-DIFF(-4,-8) = 4
-DIFF(-4,-7) = 3
-DIFF(-4,-6) = 2
-DIFF(-4,-5) = 1
-DIFF(-4,-4) = 0
-DIFF(-4,-3) = 1
-DIFF(-4,-2) = 2
-DIFF(-4,-1) = 3
-DIFF(-4,0) = 4
-DIFF(-4,1) = 5
-DIFF(-4,2) = 6
-DIFF(-4,3) = 7
-DIFF(-4,4) = 8
-DIFF(-4,5) = 9
-DIFF(-4,6) = 10
-DIFF(-4,7) = 11
-DIFF(-4,8) = 12
-DIFF(-4,9) = 13
-DIFF(-3,-10) = 7
-DIFF(-3,-9) = 6
-DIFF(-3,-8) = 5
-DIFF(-3,-7) = 4
-DIFF(-3,-6) = 3
-DIFF(-3,-5) = 2
-DIFF(-3,-4) = 1
-DIFF(-3,-3) = 0
-DIFF(-3,-2) = 1
-DIFF(-3,-1) = 2
-DIFF(-3,0) = 3
-DIFF(-3,1) = 4
-DIFF(-3,2) = 5
-DIFF(-3,3) = 6
-DIFF(-3,4) = 7
-DIFF(-3,5) = 8
-DIFF(-3,6) = 9
-DIFF(-3,7) = 10
-DIFF(-3,8) = 11
-DIFF(-3,9) = 12
-DIFF(-2,-10) = 8
-DIFF(-2,-9) = 7
-DIFF(-2,-8) = 6
-DIFF(-2,-7) = 5
-DIFF(-2,-6) = 4
-DIFF(-2,-5) = 3
-DIFF(-2,-4) = 2
-DIFF(-2,-3) = 1
-DIFF(-2,-2) = 0
-DIFF(-2,-1) = 1
-DIFF(-2,0) = 2
-DIFF(-2,1) = 3
-DIFF(-2,2) = 4
-DIFF(-2,3) = 5
-DIFF(-2,4) = 6
-DIFF(-2,5) = 7
-DIFF(-2,6) = 8
-DIFF(-2,7) = 9
-DIFF(-2,8) = 10
-DIFF(-2,9) = 11
-DIFF(-1,-10) = 9
-DIFF(-1,-9) = 8
-DIFF(-1,-8) = 7
-DIFF(-1,-7) = 6
-DIFF(-1,-6) = 5
-DIFF(-1,-5) = 4
-DIFF(-1,-4) = 3
-DIFF(-1,-3) = 2
-DIFF(-1,-2) = 1
-DIFF(-1,-1) = 0
-DIFF(-1,0) = 1
-DIFF(-1,1) = 2
-DIFF(-1,2) = 3
-DIFF(-1,3) = 4
-DIFF(-1,4) = 5
-DIFF(-1,5) = 6
-DIFF(-1,6) = 7
-DIFF(-1,7) = 8
-DIFF(-1,8) = 9
-DIFF(-1,9) = 10
-DIFF(0,-10) = 10
-DIFF(0,-9) = 9
-DIFF(0,-8) = 8
-DIFF(0,-7) = 7
-DIFF(0,-6) = 6
-DIFF(0,-5) = 5
-DIFF(0,-4) = 4
-DIFF(0,-3) = 3
-DIFF(0,-2) = 2
-DIFF(0,-1) = 1
-DIFF(0,0) = 0
-DIFF(0,1) = 1
-DIFF(0,2) = 2
-DIFF(0,3) = 3
-DIFF(0,4) = 4
-DIFF(0,5) = 5
-DIFF(0,6) = 6
-DIFF(0,7) = 7
-DIFF(0,8) = 8
-DIFF(0,9) = 9
-DIFF(1,-10) = 11
-DIFF(1,-9) = 10
-DIFF(1,-8) = 9
-DIFF(1,-7) = 8
-DIFF(1,-6) = 7
-DIFF(1,-5) = 6
-DIFF(1,-4) = 5
-DIFF(1,-3) = 4
-DIFF(1,-2) = 3
-DIFF(1,-1) = 2
-DIFF(1,0) = 1
-DIFF(1,1) = 0
-DIFF(1,2) = 1
-DIFF(1,3) = 2
-DIFF(1,4) = 3
-DIFF(1,5) = 4
-DIFF(1,6) = 5
-DIFF(1,7) = 6
-DIFF(1,8) = 7
-DIFF(1,9) = 8
-DIFF(2,-10) = 12
-DIFF(2,-9) = 11
-DIFF(2,-8) = 10
-DIFF(2,-7) = 9
-DIFF(2,-6) = 8
-DIFF(2,-5) = 7
-DIFF(2,-4) = 6
-DIFF(2,-3) = 5
-DIFF(2,-2) = 4
-DIFF(2,-1) = 3
-DIFF(2,0) = 2
-DIFF(2,1) = 1
-DIFF(2,2) = 0
-DIFF(2,3) = 1
-DIFF(2,4) = 2
-DIFF(2,5) = 3
-DIFF(2,6) = 4
-DIFF(2,7) = 5
-DIFF(2,8) = 6
-DIFF(2,9) = 7
-DIFF(3,-10) = 13
-DIFF(3,-9) = 12
-DIFF(3,-8) = 11
-DIFF(3,-7) = 10
-DIFF(3,-6) = 9
-DIFF(3,-5) = 8
-DIFF(3,-4) = 7
-DIFF(3,-3) = 6
-DIFF(3,-2) = 5
-DIFF(3,-1) = 4
-DIFF(3,0) = 3
-DIFF(3,1) = 2
-DIFF(3,2) = 1
-DIFF(3,3) = 0
-DIFF(3,4) = 1
-DIFF(3,5) = 2
-DIFF(3,6) = 3
-DIFF(3,7) = 4
-DIFF(3,8) = 5
-DIFF(3,9) = 6
-DIFF(4,-10) = 14
-DIFF(4,-9) = 13
-DIFF(4,-8) = 12
-DIFF(4,-7) = 11
-DIFF(4,-6) = 10
-DIFF(4,-5) = 9
-DIFF(4,-4) = 8
-DIFF(4,-3) = 7
-DIFF(4,-2) = 6
-DIFF(4,-1) = 5
-DIFF(4,0) = 4
-DIFF(4,1) = 3
-DIFF(4,2) = 2
-DIFF(4,3) = 1
-DIFF(4,4) = 0
-DIFF(4,5) = 1
-DIFF(4,6) = 2
-DIFF(4,7) = 3
-DIFF(4,8) = 4
-DIFF(4,9) = 5
-DIFF(5,-10) = 15
-DIFF(5,-9) = 14
-DIFF(5,-8) = 13
-DIFF(5,-7) = 12
-DIFF(5,-6) = 11
-DIFF(5,-5) = 10
-DIFF(5,-4) = 9
-DIFF(5,-3) = 8
-DIFF(5,-2) = 7
-DIFF(5,-1) = 6
-DIFF(5,0) = 5
-DIFF(5,1) = 4
-DIFF(5,2) = 3
-DIFF(5,3) = 2
-DIFF(5,4) = 1
-DIFF(5,5) = 0
-DIFF(5,6) = 1
-DIFF(5,7) = 2
-DIFF(5,8) = 3
-DIFF(5,9) = 4
-DIFF(6,-10) = 16
-DIFF(6,-9) = 15
-DIFF(6,-8) = 14
-DIFF(6,-7) = 13
-DIFF(6,-6) = 12
-DIFF(6,-5) = 11
-DIFF(6,-4) = 10
-DIFF(6,-3) = 9
-DIFF(6,-2) = 8
-DIFF(6,-1) = 7
-DIFF(6,0) = 6
-DIFF(6,1) = 5
-DIFF(6,2) = 4
-DIFF(6,3) = 3
-DIFF(6,4) = 2
-DIFF(6,5) = 1
-DIFF(6,6) = 0
-DIFF(6,7) = 1
-DIFF(6,8) = 2
-DIFF(6,9) = 3
-DIFF(7,-10) = 17
-DIFF(7,-9) = 16
-DIFF(7,-8) = 15
-DIFF(7,-7) = 14
-DIFF(7,-6) = 13
-DIFF(7,-5) = 12
-DIFF(7,-4) = 11
-DIFF(7,-3) = 10
-DIFF(7,-2) = 9
-DIFF(7,-1) = 8
-DIFF(7,0) = 7
-DIFF(7,1) = 6
-DIFF(7,2) = 5
-DIFF(7,3) = 4
-DIFF(7,4) = 3
-DIFF(7,5) = 2
-DIFF(7,6) = 1
-DIFF(7,7) = 0
-DIFF(7,8) = 1
-DIFF(7,9) = 2
-DIFF(8,-10) = 18
-DIFF(8,-9) = 17
-DIFF(8,-8) = 16
-DIFF(8,-7) = 15
-DIFF(8,-6) = 14
-DIFF(8,-5) = 13
-DIFF(8,-4) = 12
-DIFF(8,-3) = 11
-DIFF(8,-2) = 10
-DIFF(8,-1) = 9
-DIFF(8,0) = 8
-DIFF(8,1) = 7
-DIFF(8,2) = 6
-DIFF(8,3) = 5
-DIFF(8,4) = 4
-DIFF(8,5) = 3
-DIFF(8,6) = 2
-DIFF(8,7) = 1
-DIFF(8,8) = 0
-DIFF(8,9) = 1
-DIFF(9,-10) = 19
-DIFF(9,-9) = 18
-DIFF(9,-8) = 17
-DIFF(9,-7) = 16
-DIFF(9,-6) = 15
-DIFF(9,-5) = 14
-DIFF(9,-4) = 13
-DIFF(9,-3) = 12
-DIFF(9,-2) = 11
-DIFF(9,-1) = 10
-DIFF(9,0) = 9
-DIFF(9,1) = 8
-DIFF(9,2) = 7
-DIFF(9,3) = 6
-DIFF(9,4) = 5
-DIFF(9,5) = 4
-DIFF(9,6) = 3
-DIFF(9,7) = 2
-DIFF(9,8) = 1
-DIFF(9,9) = 0
diff --git a/tests/valid/Complex_Valid_6.whiley b/tests/valid/Complex_Valid_6.whiley
index 34f279cad3..fbb64b97a8 100644
--- a/tests/valid/Complex_Valid_6.whiley
+++ b/tests/valid/Complex_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -22,8 +22,14 @@ ensures r == max(a - b, b - a):
//
return diff
-method main(System.Console console) -> void:
- [int] list = -10 .. 10
- for i in list:
- for j in list:
- console.out.println_s("DIFF(" ++ Any.toString(i) ++ "," ++ Any.toString(j) ++ ") = " ++ Any.toString(diff(i, j)))
+public export method test() -> void:
+ int i = 0
+ while i < 20:
+ int j = 0
+ while j < 20:
+ assume i < j || diff(i-10,j-10) == (i - j)
+ assume i > j || diff(i-10,j-10) == (j - i)
+ j = j + 1
+ //
+ i = i + 1
+ //
diff --git a/tests/valid/Complex_Valid_7.sysout b/tests/valid/Complex_Valid_7.sysout
deleted file mode 100644
index b0e3b760c2..0000000000
--- a/tests/valid/Complex_Valid_7.sysout
+++ /dev/null
@@ -1,513 +0,0 @@
-MAX(1,1,1)=1
-MAX(1,1,1)=2
-MAX(1,1,1)=3
-MAX(1,1,1)=4
-MAX(1,1,1)=5
-MAX(1,1,1)=6
-MAX(1,1,1)=7
-MAX(1,1,1)=8
-MAX(1,2,2)=2
-MAX(1,2,2)=2
-MAX(1,2,2)=3
-MAX(1,2,2)=4
-MAX(1,2,2)=5
-MAX(1,2,2)=6
-MAX(1,2,2)=7
-MAX(1,2,2)=8
-MAX(1,3,3)=3
-MAX(1,3,3)=3
-MAX(1,3,3)=3
-MAX(1,3,3)=4
-MAX(1,3,3)=5
-MAX(1,3,3)=6
-MAX(1,3,3)=7
-MAX(1,3,3)=8
-MAX(1,4,4)=4
-MAX(1,4,4)=4
-MAX(1,4,4)=4
-MAX(1,4,4)=4
-MAX(1,4,4)=5
-MAX(1,4,4)=6
-MAX(1,4,4)=7
-MAX(1,4,4)=8
-MAX(1,5,5)=5
-MAX(1,5,5)=5
-MAX(1,5,5)=5
-MAX(1,5,5)=5
-MAX(1,5,5)=5
-MAX(1,5,5)=6
-MAX(1,5,5)=7
-MAX(1,5,5)=8
-MAX(1,6,6)=6
-MAX(1,6,6)=6
-MAX(1,6,6)=6
-MAX(1,6,6)=6
-MAX(1,6,6)=6
-MAX(1,6,6)=6
-MAX(1,6,6)=7
-MAX(1,6,6)=8
-MAX(1,7,7)=7
-MAX(1,7,7)=7
-MAX(1,7,7)=7
-MAX(1,7,7)=7
-MAX(1,7,7)=7
-MAX(1,7,7)=7
-MAX(1,7,7)=7
-MAX(1,7,7)=8
-MAX(1,8,8)=8
-MAX(1,8,8)=8
-MAX(1,8,8)=8
-MAX(1,8,8)=8
-MAX(1,8,8)=8
-MAX(1,8,8)=8
-MAX(1,8,8)=8
-MAX(1,8,8)=8
-MAX(2,1,1)=2
-MAX(2,1,1)=2
-MAX(2,1,1)=3
-MAX(2,1,1)=4
-MAX(2,1,1)=5
-MAX(2,1,1)=6
-MAX(2,1,1)=7
-MAX(2,1,1)=8
-MAX(2,2,2)=2
-MAX(2,2,2)=2
-MAX(2,2,2)=3
-MAX(2,2,2)=4
-MAX(2,2,2)=5
-MAX(2,2,2)=6
-MAX(2,2,2)=7
-MAX(2,2,2)=8
-MAX(2,3,3)=3
-MAX(2,3,3)=3
-MAX(2,3,3)=3
-MAX(2,3,3)=4
-MAX(2,3,3)=5
-MAX(2,3,3)=6
-MAX(2,3,3)=7
-MAX(2,3,3)=8
-MAX(2,4,4)=4
-MAX(2,4,4)=4
-MAX(2,4,4)=4
-MAX(2,4,4)=4
-MAX(2,4,4)=5
-MAX(2,4,4)=6
-MAX(2,4,4)=7
-MAX(2,4,4)=8
-MAX(2,5,5)=5
-MAX(2,5,5)=5
-MAX(2,5,5)=5
-MAX(2,5,5)=5
-MAX(2,5,5)=5
-MAX(2,5,5)=6
-MAX(2,5,5)=7
-MAX(2,5,5)=8
-MAX(2,6,6)=6
-MAX(2,6,6)=6
-MAX(2,6,6)=6
-MAX(2,6,6)=6
-MAX(2,6,6)=6
-MAX(2,6,6)=6
-MAX(2,6,6)=7
-MAX(2,6,6)=8
-MAX(2,7,7)=7
-MAX(2,7,7)=7
-MAX(2,7,7)=7
-MAX(2,7,7)=7
-MAX(2,7,7)=7
-MAX(2,7,7)=7
-MAX(2,7,7)=7
-MAX(2,7,7)=8
-MAX(2,8,8)=8
-MAX(2,8,8)=8
-MAX(2,8,8)=8
-MAX(2,8,8)=8
-MAX(2,8,8)=8
-MAX(2,8,8)=8
-MAX(2,8,8)=8
-MAX(2,8,8)=8
-MAX(3,1,1)=3
-MAX(3,1,1)=3
-MAX(3,1,1)=3
-MAX(3,1,1)=4
-MAX(3,1,1)=5
-MAX(3,1,1)=6
-MAX(3,1,1)=7
-MAX(3,1,1)=8
-MAX(3,2,2)=3
-MAX(3,2,2)=3
-MAX(3,2,2)=3
-MAX(3,2,2)=4
-MAX(3,2,2)=5
-MAX(3,2,2)=6
-MAX(3,2,2)=7
-MAX(3,2,2)=8
-MAX(3,3,3)=3
-MAX(3,3,3)=3
-MAX(3,3,3)=3
-MAX(3,3,3)=4
-MAX(3,3,3)=5
-MAX(3,3,3)=6
-MAX(3,3,3)=7
-MAX(3,3,3)=8
-MAX(3,4,4)=4
-MAX(3,4,4)=4
-MAX(3,4,4)=4
-MAX(3,4,4)=4
-MAX(3,4,4)=5
-MAX(3,4,4)=6
-MAX(3,4,4)=7
-MAX(3,4,4)=8
-MAX(3,5,5)=5
-MAX(3,5,5)=5
-MAX(3,5,5)=5
-MAX(3,5,5)=5
-MAX(3,5,5)=5
-MAX(3,5,5)=6
-MAX(3,5,5)=7
-MAX(3,5,5)=8
-MAX(3,6,6)=6
-MAX(3,6,6)=6
-MAX(3,6,6)=6
-MAX(3,6,6)=6
-MAX(3,6,6)=6
-MAX(3,6,6)=6
-MAX(3,6,6)=7
-MAX(3,6,6)=8
-MAX(3,7,7)=7
-MAX(3,7,7)=7
-MAX(3,7,7)=7
-MAX(3,7,7)=7
-MAX(3,7,7)=7
-MAX(3,7,7)=7
-MAX(3,7,7)=7
-MAX(3,7,7)=8
-MAX(3,8,8)=8
-MAX(3,8,8)=8
-MAX(3,8,8)=8
-MAX(3,8,8)=8
-MAX(3,8,8)=8
-MAX(3,8,8)=8
-MAX(3,8,8)=8
-MAX(3,8,8)=8
-MAX(4,1,1)=4
-MAX(4,1,1)=4
-MAX(4,1,1)=4
-MAX(4,1,1)=4
-MAX(4,1,1)=5
-MAX(4,1,1)=6
-MAX(4,1,1)=7
-MAX(4,1,1)=8
-MAX(4,2,2)=4
-MAX(4,2,2)=4
-MAX(4,2,2)=4
-MAX(4,2,2)=4
-MAX(4,2,2)=5
-MAX(4,2,2)=6
-MAX(4,2,2)=7
-MAX(4,2,2)=8
-MAX(4,3,3)=4
-MAX(4,3,3)=4
-MAX(4,3,3)=4
-MAX(4,3,3)=4
-MAX(4,3,3)=5
-MAX(4,3,3)=6
-MAX(4,3,3)=7
-MAX(4,3,3)=8
-MAX(4,4,4)=4
-MAX(4,4,4)=4
-MAX(4,4,4)=4
-MAX(4,4,4)=4
-MAX(4,4,4)=5
-MAX(4,4,4)=6
-MAX(4,4,4)=7
-MAX(4,4,4)=8
-MAX(4,5,5)=5
-MAX(4,5,5)=5
-MAX(4,5,5)=5
-MAX(4,5,5)=5
-MAX(4,5,5)=5
-MAX(4,5,5)=6
-MAX(4,5,5)=7
-MAX(4,5,5)=8
-MAX(4,6,6)=6
-MAX(4,6,6)=6
-MAX(4,6,6)=6
-MAX(4,6,6)=6
-MAX(4,6,6)=6
-MAX(4,6,6)=6
-MAX(4,6,6)=7
-MAX(4,6,6)=8
-MAX(4,7,7)=7
-MAX(4,7,7)=7
-MAX(4,7,7)=7
-MAX(4,7,7)=7
-MAX(4,7,7)=7
-MAX(4,7,7)=7
-MAX(4,7,7)=7
-MAX(4,7,7)=8
-MAX(4,8,8)=8
-MAX(4,8,8)=8
-MAX(4,8,8)=8
-MAX(4,8,8)=8
-MAX(4,8,8)=8
-MAX(4,8,8)=8
-MAX(4,8,8)=8
-MAX(4,8,8)=8
-MAX(5,1,1)=5
-MAX(5,1,1)=5
-MAX(5,1,1)=5
-MAX(5,1,1)=5
-MAX(5,1,1)=5
-MAX(5,1,1)=6
-MAX(5,1,1)=7
-MAX(5,1,1)=8
-MAX(5,2,2)=5
-MAX(5,2,2)=5
-MAX(5,2,2)=5
-MAX(5,2,2)=5
-MAX(5,2,2)=5
-MAX(5,2,2)=6
-MAX(5,2,2)=7
-MAX(5,2,2)=8
-MAX(5,3,3)=5
-MAX(5,3,3)=5
-MAX(5,3,3)=5
-MAX(5,3,3)=5
-MAX(5,3,3)=5
-MAX(5,3,3)=6
-MAX(5,3,3)=7
-MAX(5,3,3)=8
-MAX(5,4,4)=5
-MAX(5,4,4)=5
-MAX(5,4,4)=5
-MAX(5,4,4)=5
-MAX(5,4,4)=5
-MAX(5,4,4)=6
-MAX(5,4,4)=7
-MAX(5,4,4)=8
-MAX(5,5,5)=5
-MAX(5,5,5)=5
-MAX(5,5,5)=5
-MAX(5,5,5)=5
-MAX(5,5,5)=5
-MAX(5,5,5)=6
-MAX(5,5,5)=7
-MAX(5,5,5)=8
-MAX(5,6,6)=6
-MAX(5,6,6)=6
-MAX(5,6,6)=6
-MAX(5,6,6)=6
-MAX(5,6,6)=6
-MAX(5,6,6)=6
-MAX(5,6,6)=7
-MAX(5,6,6)=8
-MAX(5,7,7)=7
-MAX(5,7,7)=7
-MAX(5,7,7)=7
-MAX(5,7,7)=7
-MAX(5,7,7)=7
-MAX(5,7,7)=7
-MAX(5,7,7)=7
-MAX(5,7,7)=8
-MAX(5,8,8)=8
-MAX(5,8,8)=8
-MAX(5,8,8)=8
-MAX(5,8,8)=8
-MAX(5,8,8)=8
-MAX(5,8,8)=8
-MAX(5,8,8)=8
-MAX(5,8,8)=8
-MAX(6,1,1)=6
-MAX(6,1,1)=6
-MAX(6,1,1)=6
-MAX(6,1,1)=6
-MAX(6,1,1)=6
-MAX(6,1,1)=6
-MAX(6,1,1)=7
-MAX(6,1,1)=8
-MAX(6,2,2)=6
-MAX(6,2,2)=6
-MAX(6,2,2)=6
-MAX(6,2,2)=6
-MAX(6,2,2)=6
-MAX(6,2,2)=6
-MAX(6,2,2)=7
-MAX(6,2,2)=8
-MAX(6,3,3)=6
-MAX(6,3,3)=6
-MAX(6,3,3)=6
-MAX(6,3,3)=6
-MAX(6,3,3)=6
-MAX(6,3,3)=6
-MAX(6,3,3)=7
-MAX(6,3,3)=8
-MAX(6,4,4)=6
-MAX(6,4,4)=6
-MAX(6,4,4)=6
-MAX(6,4,4)=6
-MAX(6,4,4)=6
-MAX(6,4,4)=6
-MAX(6,4,4)=7
-MAX(6,4,4)=8
-MAX(6,5,5)=6
-MAX(6,5,5)=6
-MAX(6,5,5)=6
-MAX(6,5,5)=6
-MAX(6,5,5)=6
-MAX(6,5,5)=6
-MAX(6,5,5)=7
-MAX(6,5,5)=8
-MAX(6,6,6)=6
-MAX(6,6,6)=6
-MAX(6,6,6)=6
-MAX(6,6,6)=6
-MAX(6,6,6)=6
-MAX(6,6,6)=6
-MAX(6,6,6)=7
-MAX(6,6,6)=8
-MAX(6,7,7)=7
-MAX(6,7,7)=7
-MAX(6,7,7)=7
-MAX(6,7,7)=7
-MAX(6,7,7)=7
-MAX(6,7,7)=7
-MAX(6,7,7)=7
-MAX(6,7,7)=8
-MAX(6,8,8)=8
-MAX(6,8,8)=8
-MAX(6,8,8)=8
-MAX(6,8,8)=8
-MAX(6,8,8)=8
-MAX(6,8,8)=8
-MAX(6,8,8)=8
-MAX(6,8,8)=8
-MAX(7,1,1)=7
-MAX(7,1,1)=7
-MAX(7,1,1)=7
-MAX(7,1,1)=7
-MAX(7,1,1)=7
-MAX(7,1,1)=7
-MAX(7,1,1)=7
-MAX(7,1,1)=8
-MAX(7,2,2)=7
-MAX(7,2,2)=7
-MAX(7,2,2)=7
-MAX(7,2,2)=7
-MAX(7,2,2)=7
-MAX(7,2,2)=7
-MAX(7,2,2)=7
-MAX(7,2,2)=8
-MAX(7,3,3)=7
-MAX(7,3,3)=7
-MAX(7,3,3)=7
-MAX(7,3,3)=7
-MAX(7,3,3)=7
-MAX(7,3,3)=7
-MAX(7,3,3)=7
-MAX(7,3,3)=8
-MAX(7,4,4)=7
-MAX(7,4,4)=7
-MAX(7,4,4)=7
-MAX(7,4,4)=7
-MAX(7,4,4)=7
-MAX(7,4,4)=7
-MAX(7,4,4)=7
-MAX(7,4,4)=8
-MAX(7,5,5)=7
-MAX(7,5,5)=7
-MAX(7,5,5)=7
-MAX(7,5,5)=7
-MAX(7,5,5)=7
-MAX(7,5,5)=7
-MAX(7,5,5)=7
-MAX(7,5,5)=8
-MAX(7,6,6)=7
-MAX(7,6,6)=7
-MAX(7,6,6)=7
-MAX(7,6,6)=7
-MAX(7,6,6)=7
-MAX(7,6,6)=7
-MAX(7,6,6)=7
-MAX(7,6,6)=8
-MAX(7,7,7)=7
-MAX(7,7,7)=7
-MAX(7,7,7)=7
-MAX(7,7,7)=7
-MAX(7,7,7)=7
-MAX(7,7,7)=7
-MAX(7,7,7)=7
-MAX(7,7,7)=8
-MAX(7,8,8)=8
-MAX(7,8,8)=8
-MAX(7,8,8)=8
-MAX(7,8,8)=8
-MAX(7,8,8)=8
-MAX(7,8,8)=8
-MAX(7,8,8)=8
-MAX(7,8,8)=8
-MAX(8,1,1)=8
-MAX(8,1,1)=8
-MAX(8,1,1)=8
-MAX(8,1,1)=8
-MAX(8,1,1)=8
-MAX(8,1,1)=8
-MAX(8,1,1)=8
-MAX(8,1,1)=8
-MAX(8,2,2)=8
-MAX(8,2,2)=8
-MAX(8,2,2)=8
-MAX(8,2,2)=8
-MAX(8,2,2)=8
-MAX(8,2,2)=8
-MAX(8,2,2)=8
-MAX(8,2,2)=8
-MAX(8,3,3)=8
-MAX(8,3,3)=8
-MAX(8,3,3)=8
-MAX(8,3,3)=8
-MAX(8,3,3)=8
-MAX(8,3,3)=8
-MAX(8,3,3)=8
-MAX(8,3,3)=8
-MAX(8,4,4)=8
-MAX(8,4,4)=8
-MAX(8,4,4)=8
-MAX(8,4,4)=8
-MAX(8,4,4)=8
-MAX(8,4,4)=8
-MAX(8,4,4)=8
-MAX(8,4,4)=8
-MAX(8,5,5)=8
-MAX(8,5,5)=8
-MAX(8,5,5)=8
-MAX(8,5,5)=8
-MAX(8,5,5)=8
-MAX(8,5,5)=8
-MAX(8,5,5)=8
-MAX(8,5,5)=8
-MAX(8,6,6)=8
-MAX(8,6,6)=8
-MAX(8,6,6)=8
-MAX(8,6,6)=8
-MAX(8,6,6)=8
-MAX(8,6,6)=8
-MAX(8,6,6)=8
-MAX(8,6,6)=8
-MAX(8,7,7)=8
-MAX(8,7,7)=8
-MAX(8,7,7)=8
-MAX(8,7,7)=8
-MAX(8,7,7)=8
-MAX(8,7,7)=8
-MAX(8,7,7)=8
-MAX(8,7,7)=8
-MAX(8,8,8)=8
-MAX(8,8,8)=8
-MAX(8,8,8)=8
-MAX(8,8,8)=8
-MAX(8,8,8)=8
-MAX(8,8,8)=8
-MAX(8,8,8)=8
-MAX(8,8,8)=8
-Done.
diff --git a/tests/valid/Complex_Valid_7.whiley b/tests/valid/Complex_Valid_7.whiley
index 7f54a95e67..0995ac73d8 100644
--- a/tests/valid/Complex_Valid_7.whiley
+++ b/tests/valid/Complex_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function max3(int x, int y, int z) -> (int r)
// Return value must be as large as each parameter
@@ -17,7 +17,7 @@ ensures r == x || r == y || r == z:
return z
// Following is just to help verification
-method fn(System.Console console, [int] xs):
+method fn([int] xs):
int i1 = 0
while i1 < |xs| where i1 >= 0:
int v1 = xs[i1]
@@ -27,14 +27,15 @@ method fn(System.Console console, [int] xs):
int i3 = 0
while i3 < |xs| where i3 >= 0:
int v3 = xs[i3]
- console.out.println_s("MAX(" ++ Any.toString(v1) ++ "," ++ Any.toString(v2) ++ "," ++ Any.toString(v2) ++ ")=" ++ Any.toString(max3(v1,v2,v3)))
+ assume (v1 <= v3 && v2 <= v3) ==> max3(v1,v2,v3) == v3
+ assume (v1 <= v2 && v3 <= v2) ==> max3(v1,v2,v3) == v2
+ assume (v2 <= v3 && v3 <= v1) ==> max3(v1,v2,v3) == v1
i3 = i3 + 1
//
i2 = i2 + 1
//
i1 = i1 + 1
// Done.
- console.out.println_s("Done.")
-method main(System.Console console):
- fn(console,[1,2,3,4,5,6,7,8])
+public export method test():
+ fn([1,2,3,4,5,6,7,8])
diff --git a/tests/valid/Complex_Valid_8.sysout b/tests/valid/Complex_Valid_8.sysout
deleted file mode 100644
index fcb537f812..0000000000
--- a/tests/valid/Complex_Valid_8.sysout
+++ /dev/null
@@ -1,7 +0,0 @@
-ADDING: hello
-ADDING: world
-ADDING: help
-CONTAINS: hello = true
-CONTAINS: blah = false
-CONTAINS: hel = true
-CONTAINS: dave = false
diff --git a/tests/valid/Complex_Valid_8.whiley b/tests/valid/Complex_Valid_8.whiley
index a388d61ebf..7a47a49739 100644
--- a/tests/valid/Complex_Valid_8.whiley
+++ b/tests/valid/Complex_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type char is int
type string is [int]
@@ -79,13 +79,14 @@ requires state >= 0:
//
return false
-method main(System.Console console):
+public export method test():
Trie t = EmptyTrie
// First, initialise trie
- for s in ["hello","world","help"]:
- console.out.println_s("ADDING: " ++ s)
- t = add(t,s)
+ t = add(t,"hello")
+ t = add(t,"world")
+ t = add(t,"help")
// Second, check containment
- for s in ["hello","blah","hel","dave"]:
- bool r = contains(t,s)
- console.out.println_s("CONTAINS: " ++ s ++ " = " ++ Any.toString(r))
+ assume contains(t,"hello")
+ assume !contains(t,"blah")
+ assume contains(t,"hel")
+ assume !contains(t,"dave")
diff --git a/tests/valid/Constant_Valid_1.whiley b/tests/valid/Constant_Valid_1.whiley
deleted file mode 100644
index 55dff8b910..0000000000
--- a/tests/valid/Constant_Valid_1.whiley
+++ /dev/null
@@ -1,12 +0,0 @@
-import whiley.lang.*
-
-type TYPE is [CONSTANT]
-
-constant CONSTANT is {V1 is TYPE, V2 is TYPE}
-
-constant V1 is [false]
-
-constant V2 is []
-
-method main(System.Console sys) -> void:
- sys.out.println(CONSTANT)
diff --git a/tests/valid/Constant_Valid_2.whiley b/tests/valid/Constant_Valid_2.whiley
deleted file mode 100644
index ab248d7aae..0000000000
--- a/tests/valid/Constant_Valid_2.whiley
+++ /dev/null
@@ -1,4 +0,0 @@
-
-constant ZLIB is 0
-
-type CompressionMethod is {ZLIB}
diff --git a/tests/valid/Constant_Valid_3.sysout b/tests/valid/Constant_Valid_3.sysout
deleted file mode 100644
index 00f544bbfd..0000000000
--- a/tests/valid/Constant_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[-1, 2, 3]
diff --git a/tests/valid/Constant_Valid_3.whiley b/tests/valid/Constant_Valid_3.whiley
index e05c2a9bd8..105e84c560 100644
--- a/tests/valid/Constant_Valid_3.whiley
+++ b/tests/valid/Constant_Valid_3.whiley
@@ -1,6 +1,6 @@
-import whiley.lang.*
+
constant ITEMS is [-1, 2, 3]
-method main(System.Console sys) -> void:
- sys.out.println(ITEMS)
+public export method test() -> void:
+ assert ITEMS == [-1,2,3]
diff --git a/tests/valid/ConstrainedDictionary_Valid_1.sysout b/tests/valid/ConstrainedDictionary_Valid_1.sysout
deleted file mode 100644
index 2ced80e232..0000000000
--- a/tests/valid/ConstrainedDictionary_Valid_1.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-20
-10
-0
-10
-20
diff --git a/tests/valid/ConstrainedDictionary_Valid_1.whiley b/tests/valid/ConstrainedDictionary_Valid_1.whiley
index 48c5ca44f9..6477584b8d 100644
--- a/tests/valid/ConstrainedDictionary_Valid_1.whiley
+++ b/tests/valid/ConstrainedDictionary_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -7,10 +7,10 @@ type dict is {int=>nat}
function f(int key, dict d) -> nat:
return d[key]
-public method main(System.Console sys) -> void:
+public export method test() -> void:
{int=>int} d = {-2=>20, -1=>10, 0=>0, 1=>10, 2=>20}
- sys.out.println(f(-2, d))
- sys.out.println(f(-1, d))
- sys.out.println(f(-0, d))
- sys.out.println(f(1, d))
- sys.out.println(f(2, d))
+ assume f(-2, d) == 20
+ assume f(-1, d) == 10
+ assume f(-0, d) == 0
+ assume f(1, d) == 10
+ assume f(2, d) == 20
diff --git a/tests/valid/ConstrainedDictionary_Valid_2.sysout b/tests/valid/ConstrainedDictionary_Valid_2.sysout
deleted file mode 100644
index e556868440..0000000000
--- a/tests/valid/ConstrainedDictionary_Valid_2.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-3
-0
-0
-0
-0
diff --git a/tests/valid/ConstrainedDictionary_Valid_2.whiley b/tests/valid/ConstrainedDictionary_Valid_2.whiley
index 735398406d..b637ac974b 100644
--- a/tests/valid/ConstrainedDictionary_Valid_2.whiley
+++ b/tests/valid/ConstrainedDictionary_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
type nat is (int x) where x >= 0
@@ -10,9 +10,9 @@ ensures r >= 0:
//
return 0
-method main(System.Console console):
- console.out.println(f({1=>1,2=>2,3=>3}))
- console.out.println(f({-1=>0}))
- console.out.println(f({0=>-1}))
- console.out.println(f({1=>1,0=>0,0=>-1}))
- console.out.println(f({1=>1,0=>0,-1=>0}))
+public export method test():
+ assume f({1=>1,2=>2,3=>3}) == 3
+ assume f({-1=>0}) == 0
+ assume f({0=>-1}) == 0
+ assume f({1=>1,0=>0,0=>-1}) == 0
+ assume f({1=>1,0=>0,-1=>0}) == 0
diff --git a/tests/valid/ConstrainedInt_Valid_1.sysout b/tests/valid/ConstrainedInt_Valid_1.sysout
deleted file mode 100755
index ec635144f6..0000000000
--- a/tests/valid/ConstrainedInt_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-9
diff --git a/tests/valid/ConstrainedInt_Valid_1.whiley b/tests/valid/ConstrainedInt_Valid_1.whiley
index bd7d7fee72..d1b0923c98 100644
--- a/tests/valid/ConstrainedInt_Valid_1.whiley
+++ b/tests/valid/ConstrainedInt_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type cr1nat is (int x) where x < 10
@@ -6,5 +6,5 @@ function f(cr1nat x) -> int:
int y = x
return y
-method main(System.Console sys) -> void:
- sys.out.println(f(9))
+public export method test() -> void:
+ assume f(9) == 9
diff --git a/tests/valid/ConstrainedInt_Valid_10.sysout b/tests/valid/ConstrainedInt_Valid_10.sysout
deleted file mode 100755
index 00750edc07..0000000000
--- a/tests/valid/ConstrainedInt_Valid_10.sysout
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/tests/valid/ConstrainedInt_Valid_10.whiley b/tests/valid/ConstrainedInt_Valid_10.whiley
index 8562fe57b5..b62591d4af 100644
--- a/tests/valid/ConstrainedInt_Valid_10.whiley
+++ b/tests/valid/ConstrainedInt_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x > 0
@@ -12,5 +12,5 @@ function g(int x, nat z) -> int
requires ((x == 1) || (x == 2)) && (z in {1, 2, 3, x}):
return f(z)
-method main(System.Console sys) -> void:
- sys.out.println(g(1, 3))
+public export method test() -> void:
+ assume g(1, 3) == 3
diff --git a/tests/valid/ConstrainedInt_Valid_12.sysout b/tests/valid/ConstrainedInt_Valid_12.sysout
deleted file mode 100755
index ec635144f6..0000000000
--- a/tests/valid/ConstrainedInt_Valid_12.sysout
+++ /dev/null
@@ -1 +0,0 @@
-9
diff --git a/tests/valid/ConstrainedInt_Valid_12.whiley b/tests/valid/ConstrainedInt_Valid_12.whiley
index 4cc436d19e..6bf726d3ae 100644
--- a/tests/valid/ConstrainedInt_Valid_12.whiley
+++ b/tests/valid/ConstrainedInt_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type cr1nat is int
@@ -6,5 +6,5 @@ function f(cr1nat x) -> int:
int y = x
return y
-method main(System.Console sys) -> void:
- sys.out.println(f(9))
+public export method test() -> void:
+ assume f(9) == 9
diff --git a/tests/valid/ConstrainedInt_Valid_13.sysout b/tests/valid/ConstrainedInt_Valid_13.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ConstrainedInt_Valid_13.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ConstrainedInt_Valid_13.whiley b/tests/valid/ConstrainedInt_Valid_13.whiley
index 1cbd06b5f7..f1846ce083 100644
--- a/tests/valid/ConstrainedInt_Valid_13.whiley
+++ b/tests/valid/ConstrainedInt_Valid_13.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type codeOp is (int x) where x in {1, 2, 3, 4}
@@ -8,5 +8,5 @@ function f(code x) -> int:
int y = x.op
return y
-method main(System.Console sys) -> void:
- sys.out.println(f({op: 1, payload: [1]}))
+public export method test() -> void:
+ assume f({op: 1, payload: [1]}) == 1
diff --git a/tests/valid/ConstrainedInt_Valid_14.sysout b/tests/valid/ConstrainedInt_Valid_14.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ConstrainedInt_Valid_14.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ConstrainedInt_Valid_14.whiley b/tests/valid/ConstrainedInt_Valid_14.whiley
index 05ab1af197..7fabbda9ce 100644
--- a/tests/valid/ConstrainedInt_Valid_14.whiley
+++ b/tests/valid/ConstrainedInt_Valid_14.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type codeOp is (int x) where x in {1, 2, 3, 4}
@@ -8,5 +8,5 @@ function f(code x) -> int:
int y = x.op
return y
-method main(System.Console sys) -> void:
- sys.out.println(f({op: 1, payload: [1]}))
+public export method test() -> void:
+ assume f({op: 1, payload: [1]}) == 1
diff --git a/tests/valid/ConstrainedInt_Valid_15.sysout b/tests/valid/ConstrainedInt_Valid_15.sysout
deleted file mode 100644
index 87f8d93a01..0000000000
--- a/tests/valid/ConstrainedInt_Valid_15.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-true
diff --git a/tests/valid/ConstrainedInt_Valid_15.whiley b/tests/valid/ConstrainedInt_Valid_15.whiley
index b996e9cf53..0781025eaa 100644
--- a/tests/valid/ConstrainedInt_Valid_15.whiley
+++ b/tests/valid/ConstrainedInt_Valid_15.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type pos is (int x) where x > 0
@@ -12,7 +12,7 @@ function isPosNeg(any v) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(isPosNeg(1))
- sys.out.println(isPosNeg(0))
- sys.out.println(isPosNeg(-1))
+public export method test() -> void:
+ assume isPosNeg(1)
+ assume !isPosNeg(0)
+ assume isPosNeg(-1)
diff --git a/tests/valid/ConstrainedInt_Valid_16.sysout b/tests/valid/ConstrainedInt_Valid_16.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/ConstrainedInt_Valid_16.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/ConstrainedInt_Valid_16.whiley b/tests/valid/ConstrainedInt_Valid_16.whiley
index 7f6b61f634..83eea9f036 100644
--- a/tests/valid/ConstrainedInt_Valid_16.whiley
+++ b/tests/valid/ConstrainedInt_Valid_16.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant odd is {1,3,5}
@@ -13,7 +13,7 @@ function f(oddeven x) -> even:
return 2
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = 1
y = f(1)
- sys.out.println(y)
+ assume y == 2
diff --git a/tests/valid/ConstrainedInt_Valid_17.sysout b/tests/valid/ConstrainedInt_Valid_17.sysout
deleted file mode 100755
index 6ed281c757..0000000000
--- a/tests/valid/ConstrainedInt_Valid_17.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-1
diff --git a/tests/valid/ConstrainedInt_Valid_17.whiley b/tests/valid/ConstrainedInt_Valid_17.whiley
index 21beedaf37..432d747880 100644
--- a/tests/valid/ConstrainedInt_Valid_17.whiley
+++ b/tests/valid/ConstrainedInt_Valid_17.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type anat is (int x) where x >= 0
@@ -10,7 +10,7 @@ function atob(anat x) -> bnat:
function btoa(bnat x) -> anat:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = 1
- sys.out.println(atob(x))
- sys.out.println(btoa(x))
+ assume atob(x) == 1
+ assume btoa(x) == 1
diff --git a/tests/valid/ConstrainedInt_Valid_18.sysout b/tests/valid/ConstrainedInt_Valid_18.sysout
deleted file mode 100755
index 6ed281c757..0000000000
--- a/tests/valid/ConstrainedInt_Valid_18.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-1
diff --git a/tests/valid/ConstrainedInt_Valid_18.whiley b/tests/valid/ConstrainedInt_Valid_18.whiley
index aabd74d7ac..64bb899578 100644
--- a/tests/valid/ConstrainedInt_Valid_18.whiley
+++ b/tests/valid/ConstrainedInt_Valid_18.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type anat is int
@@ -10,7 +10,7 @@ function atob(anat x) -> bnat:
function btoa(bnat x) -> anat:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = 1
- sys.out.println(atob(x))
- sys.out.println(btoa(x))
+ assume atob(x) == 1
+ assume btoa(x) == 1
diff --git a/tests/valid/ConstrainedInt_Valid_19.sysout b/tests/valid/ConstrainedInt_Valid_19.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ConstrainedInt_Valid_19.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ConstrainedInt_Valid_19.whiley b/tests/valid/ConstrainedInt_Valid_19.whiley
index e9dccfde03..131a743a38 100644
--- a/tests/valid/ConstrainedInt_Valid_19.whiley
+++ b/tests/valid/ConstrainedInt_Valid_19.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type a_nat is (int x) where x >= 0
@@ -10,7 +10,7 @@ function f(a_nat x) -> b_nat:
else:
return f(x - 1)
-method main(System.Console sys) -> void:
- int x = |sys.args|
+public export method test() -> void:
+ int x = 0
x = f(x)
- sys.out.println(x)
+ assume x == 1
diff --git a/tests/valid/ConstrainedInt_Valid_2.sysout b/tests/valid/ConstrainedInt_Valid_2.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ConstrainedInt_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ConstrainedInt_Valid_2.whiley b/tests/valid/ConstrainedInt_Valid_2.whiley
index 461201021b..9878e3aae4 100644
--- a/tests/valid/ConstrainedInt_Valid_2.whiley
+++ b/tests/valid/ConstrainedInt_Valid_2.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type cr3nat is (int x) where x < 10
function f(cr3nat x) -> cr3nat:
return 1
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = f(9)
- sys.out.println(y)
+ assume y == 1
diff --git a/tests/valid/ConstrainedInt_Valid_20.sysout b/tests/valid/ConstrainedInt_Valid_20.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ConstrainedInt_Valid_20.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ConstrainedInt_Valid_20.whiley b/tests/valid/ConstrainedInt_Valid_20.whiley
index f6b6e6c38d..422016814d 100644
--- a/tests/valid/ConstrainedInt_Valid_20.whiley
+++ b/tests/valid/ConstrainedInt_Valid_20.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type a_nat is int
@@ -10,7 +10,7 @@ function f(a_nat x) -> b_nat:
else:
return f(x - 1)
-method main(System.Console sys) -> void:
- int x = |sys.args|
+public export method test() -> void:
+ int x = 0
x = f(x)
- sys.out.println(x)
+ assume x == 1
diff --git a/tests/valid/ConstrainedInt_Valid_21.sysout b/tests/valid/ConstrainedInt_Valid_21.sysout
deleted file mode 100644
index f599e28b8a..0000000000
--- a/tests/valid/ConstrainedInt_Valid_21.sysout
+++ /dev/null
@@ -1 +0,0 @@
-10
diff --git a/tests/valid/ConstrainedInt_Valid_21.whiley b/tests/valid/ConstrainedInt_Valid_21.whiley
index 3d21f5e949..c06c613300 100644
--- a/tests/valid/ConstrainedInt_Valid_21.whiley
+++ b/tests/valid/ConstrainedInt_Valid_21.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> (int r)
requires x != 0
@@ -6,5 +6,5 @@ ensures r != 1:
//
return x + 1
-method main(System.Console sys) -> void:
- sys.out.println(f(9))
+public export method test() -> void:
+ assume f(9) == 10
diff --git a/tests/valid/ConstrainedInt_Valid_22.sysout b/tests/valid/ConstrainedInt_Valid_22.sysout
deleted file mode 100644
index 9ed49c47c2..0000000000
--- a/tests/valid/ConstrainedInt_Valid_22.sysout
+++ /dev/null
@@ -1,15 +0,0 @@
-Monday
-Tuesday
-Wednesday
-Thursday
-Friday
-Saturday
-Sunday
-Monday
-Tuesday
-Wednesday
-Thursday
-Friday
-Saturday
-Sunday
-Monday
diff --git a/tests/valid/ConstrainedInt_Valid_22.whiley b/tests/valid/ConstrainedInt_Valid_22.whiley
index 78e7c641b8..6a0fbaa0fb 100644
--- a/tests/valid/ConstrainedInt_Valid_22.whiley
+++ b/tests/valid/ConstrainedInt_Valid_22.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant Days is ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
@@ -7,10 +7,26 @@ type item is (int d) where (0 <= d) && (d < 7)
function inc(item i) -> item:
return (i + 1) % 7
-method print(System.Console console, item day, int count) -> void:
+method get(item day, int count) -> [int]:
if count > 0:
- console.out.println_s(Days[day])
- print(console, inc(day), count - 1)
+ return get(inc(day), count - 1)
+ else:
+ return Days[day]
-public method main(System.Console console) -> void:
- print(console, 0, 15)
+public export method test() -> void:
+ assume get(0, 0) == "Monday"
+ assume get(0, 1) == "Tuesday"
+ assume get(0, 2) == "Wednesday"
+ assume get(0, 3) == "Thursday"
+ assume get(0, 4) == "Friday"
+ assume get(0, 5) == "Saturday"
+ assume get(0, 6) == "Sunday"
+ assume get(0, 7) == "Monday"
+ assume get(0, 8) == "Tuesday"
+ assume get(0, 9) == "Wednesday"
+ assume get(0, 10) == "Thursday"
+ assume get(0, 11) == "Friday"
+ assume get(0, 12) == "Saturday"
+ assume get(0, 13) == "Sunday"
+ assume get(0, 14) == "Monday"
+ assume get(0, 15) == "Tuesday"
diff --git a/tests/valid/ConstrainedInt_Valid_23.sysout b/tests/valid/ConstrainedInt_Valid_23.sysout
deleted file mode 100755
index 00750edc07..0000000000
--- a/tests/valid/ConstrainedInt_Valid_23.sysout
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/tests/valid/ConstrainedInt_Valid_23.whiley b/tests/valid/ConstrainedInt_Valid_23.whiley
index b17fc11590..87b3fb52e5 100644
--- a/tests/valid/ConstrainedInt_Valid_23.whiley
+++ b/tests/valid/ConstrainedInt_Valid_23.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type cr2num is (int x) where x in {1, 2, 3, 4}
@@ -6,5 +6,5 @@ function f(cr2num x) -> int:
int y = x
return y
-method main(System.Console sys) -> void:
- sys.out.println(f(3))
+public export method test() -> void:
+ assume f(3) == 3
diff --git a/tests/valid/ConstrainedInt_Valid_24.sysout b/tests/valid/ConstrainedInt_Valid_24.sysout
deleted file mode 100644
index f599e28b8a..0000000000
--- a/tests/valid/ConstrainedInt_Valid_24.sysout
+++ /dev/null
@@ -1 +0,0 @@
-10
diff --git a/tests/valid/ConstrainedInt_Valid_24.whiley b/tests/valid/ConstrainedInt_Valid_24.whiley
index 2fb5e09d93..c7b15ab900 100644
--- a/tests/valid/ConstrainedInt_Valid_24.whiley
+++ b/tests/valid/ConstrainedInt_Valid_24.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
//
// This little example is showing off an almost complete encoding
@@ -29,6 +29,6 @@ ensures r >= 0:
return i
// Print out hello world!
-public method main(System.Console console):
+public export method test():
C_string hw = ([int]) ['H','e','l','l','o','W','o','r','l','d',0]
- console.out.println(strlen(hw))
+ assume strlen(hw) == 10
diff --git a/tests/valid/ConstrainedInt_Valid_3.sysout b/tests/valid/ConstrainedInt_Valid_3.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ConstrainedInt_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ConstrainedInt_Valid_3.whiley b/tests/valid/ConstrainedInt_Valid_3.whiley
index d93a631a6c..387d36f323 100644
--- a/tests/valid/ConstrainedInt_Valid_3.whiley
+++ b/tests/valid/ConstrainedInt_Valid_3.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type cr3nat is int
function f(cr3nat x) -> cr3nat:
return 1
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = f(9)
- sys.out.println(y)
+ assume y == 1
diff --git a/tests/valid/ConstrainedInt_Valid_4.sysout b/tests/valid/ConstrainedInt_Valid_4.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ConstrainedInt_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ConstrainedInt_Valid_4.whiley b/tests/valid/ConstrainedInt_Valid_4.whiley
index 63485efd35..d3ffed40d2 100644
--- a/tests/valid/ConstrainedInt_Valid_4.whiley
+++ b/tests/valid/ConstrainedInt_Valid_4.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
type nat is (int x) where x < 10
function f() -> nat:
return 1
-method main(System.Console sys) -> void:
- sys.out.println(f())
+public export method test() -> void:
+ assume f() == 1
diff --git a/tests/valid/ConstrainedInt_Valid_5.sysout b/tests/valid/ConstrainedInt_Valid_5.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ConstrainedInt_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ConstrainedInt_Valid_5.whiley b/tests/valid/ConstrainedInt_Valid_5.whiley
index 87b10ae22b..737ece82e3 100644
--- a/tests/valid/ConstrainedInt_Valid_5.whiley
+++ b/tests/valid/ConstrainedInt_Valid_5.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
type nat is int
function f() -> nat:
return 1
-method main(System.Console sys) -> void:
- sys.out.println(f())
+public export method test() -> void:
+ assume f() == 1
diff --git a/tests/valid/ConstrainedInt_Valid_6.sysout b/tests/valid/ConstrainedInt_Valid_6.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/ConstrainedInt_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/ConstrainedInt_Valid_6.whiley b/tests/valid/ConstrainedInt_Valid_6.whiley
index 1e9cdb45d1..f8ed388602 100644
--- a/tests/valid/ConstrainedInt_Valid_6.whiley
+++ b/tests/valid/ConstrainedInt_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type num is (int x) where x in {1, 2, 3, 4}
@@ -10,5 +10,5 @@ function g(int x, int z) -> int
requires ((x == 1) || (x == 2)) && (z in {1, 2, 3, x}):
return f(z)
-method main(System.Console sys) -> void:
- sys.out.println(g(1, 2))
+public export method test() -> void:
+ assume g(1, 2) == 2
diff --git a/tests/valid/ConstrainedInt_Valid_7.sysout b/tests/valid/ConstrainedInt_Valid_7.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/ConstrainedInt_Valid_7.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/ConstrainedInt_Valid_8.sysout b/tests/valid/ConstrainedInt_Valid_8.sysout
deleted file mode 100755
index 00750edc07..0000000000
--- a/tests/valid/ConstrainedInt_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/tests/valid/ConstrainedInt_Valid_8.whiley b/tests/valid/ConstrainedInt_Valid_8.whiley
index 44c2cff14f..b5bd0f4225 100644
--- a/tests/valid/ConstrainedInt_Valid_8.whiley
+++ b/tests/valid/ConstrainedInt_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant c_num is {1,2,3,4}
@@ -16,5 +16,5 @@ function g({bignum} zs, int z) -> int:
else:
return -1
-method main(System.Console sys) -> void:
- sys.out.println(g({1, 2, 3, 5}, 3))
+public export method test() -> void:
+ assume g({1, 2, 3, 5}, 3) == 3
diff --git a/tests/valid/ConstrainedIntersection_Valid_1.whiley b/tests/valid/ConstrainedIntersection_Valid_1.whiley
index df3b63a1c9..2252d6d078 100644
--- a/tests/valid/ConstrainedIntersection_Valid_1.whiley
+++ b/tests/valid/ConstrainedIntersection_Valid_1.whiley
@@ -9,8 +9,8 @@ ensures r >= 0:
//
return 0
-method main(System.Console console):
- console.out.println(f(1))
- console.out.println(f(9))
- console.out.println(f(10))
- console.out.println(f(-1))
+public export method test():
+ assume f(1) == 1
+ assume f(9) == 1
+ assume f(10) == 0
+ assume f(-1) == 0
diff --git a/tests/valid/ConstrainedList_Valid_1.sysout b/tests/valid/ConstrainedList_Valid_1.sysout
deleted file mode 100755
index 111bb86865..0000000000
--- a/tests/valid/ConstrainedList_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[0]
diff --git a/tests/valid/ConstrainedList_Valid_1.whiley b/tests/valid/ConstrainedList_Valid_1.whiley
index 3ed7b37fc2..405a5f7461 100644
--- a/tests/valid/ConstrainedList_Valid_1.whiley
+++ b/tests/valid/ConstrainedList_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type u8 is (int n) where 0 >= n && n <= 255
@@ -6,6 +6,6 @@ function f(int x) -> [u8]
requires (x == 0) || (x == 169):
return [x]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[u8] bytes = f(0)
- sys.out.println(bytes)
+ assume bytes == [0]
diff --git a/tests/valid/ConstrainedList_Valid_11.sysout b/tests/valid/ConstrainedList_Valid_11.sysout
deleted file mode 100755
index b16e5f75e3..0000000000
--- a/tests/valid/ConstrainedList_Valid_11.sysout
+++ /dev/null
@@ -1 +0,0 @@
-104
diff --git a/tests/valid/ConstrainedList_Valid_11.whiley b/tests/valid/ConstrainedList_Valid_11.whiley
index 9985f89fc2..155593f3ae 100644
--- a/tests/valid/ConstrainedList_Valid_11.whiley
+++ b/tests/valid/ConstrainedList_Valid_11.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type state is {[int] input, int pos} where (pos >= 0) && (pos <= |input|)
@@ -11,6 +11,5 @@ function f(state st) -> int:
return st.input[st.pos]
return ' '
-method main(System.Console sys) -> void:
- int c = f({input: "hello", pos: 0})
- sys.out.println(c)
+public export method test() -> void:
+ assume f({input: "hello", pos: 0}) == 104
diff --git a/tests/valid/ConstrainedList_Valid_12.sysout b/tests/valid/ConstrainedList_Valid_12.sysout
deleted file mode 100755
index 111bb86865..0000000000
--- a/tests/valid/ConstrainedList_Valid_12.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[0]
diff --git a/tests/valid/ConstrainedList_Valid_12.whiley b/tests/valid/ConstrainedList_Valid_12.whiley
index 7e41892208..f09ced18b3 100644
--- a/tests/valid/ConstrainedList_Valid_12.whiley
+++ b/tests/valid/ConstrainedList_Valid_12.whiley
@@ -1,8 +1,7 @@
-import whiley.lang.*
+
function f(int x) -> [int]:
return [x]
-method main(System.Console sys) -> void:
- [int] bytes = f(0)
- sys.out.println(bytes)
+public export method test() -> void:
+ assume f(0) == [0]
diff --git a/tests/valid/ConstrainedList_Valid_14.sysout b/tests/valid/ConstrainedList_Valid_14.sysout
deleted file mode 100644
index b693b33215..0000000000
--- a/tests/valid/ConstrainedList_Valid_14.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, -2]
diff --git a/tests/valid/ConstrainedList_Valid_14.whiley b/tests/valid/ConstrainedList_Valid_14.whiley
index 33858df3e1..1edf7419ee 100644
--- a/tests/valid/ConstrainedList_Valid_14.whiley
+++ b/tests/valid/ConstrainedList_Valid_14.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type wierd is ([int] xs) where some { x in xs | x > 0 }
@@ -7,6 +7,5 @@ requires |xs| > 0:
xs[0] = 1
return xs
-method main(System.Console sys) -> void:
- [int] rs = f([-1, -2])
- sys.out.println(rs)
+public export method test() -> void:
+ assume f([-1, -2]) == [1,-2]
diff --git a/tests/valid/ConstrainedList_Valid_15.sysout b/tests/valid/ConstrainedList_Valid_15.sysout
deleted file mode 100755
index fe51488c70..0000000000
--- a/tests/valid/ConstrainedList_Valid_15.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[]
diff --git a/tests/valid/ConstrainedList_Valid_15.whiley b/tests/valid/ConstrainedList_Valid_15.whiley
index 4b7119a59e..cfd05c8d48 100644
--- a/tests/valid/ConstrainedList_Valid_15.whiley
+++ b/tests/valid/ConstrainedList_Valid_15.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f() -> [int]:
return ""
-method main(System.Console sys) -> void:
- sys.out.println(f())
+public export method test() -> void:
+ assume f() == ""
diff --git a/tests/valid/ConstrainedList_Valid_16.sysout b/tests/valid/ConstrainedList_Valid_16.sysout
deleted file mode 100644
index fe51488c70..0000000000
--- a/tests/valid/ConstrainedList_Valid_16.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[]
diff --git a/tests/valid/ConstrainedList_Valid_16.whiley b/tests/valid/ConstrainedList_Valid_16.whiley
index 41aaed664a..5bbf7ee5ab 100644
--- a/tests/valid/ConstrainedList_Valid_16.whiley
+++ b/tests/valid/ConstrainedList_Valid_16.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -6,6 +6,6 @@ function f([int] xs) -> [nat]
requires |xs| == 0:
return xs
-method main(System.Console sys) -> void:
+public export method test() -> void:
[nat] rs = f([])
- sys.out.println(rs)
+ assume rs == []
diff --git a/tests/valid/ConstrainedList_Valid_17.sysout b/tests/valid/ConstrainedList_Valid_17.sysout
deleted file mode 100644
index b5d8bb58d9..0000000000
--- a/tests/valid/ConstrainedList_Valid_17.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3]
diff --git a/tests/valid/ConstrainedList_Valid_17.whiley b/tests/valid/ConstrainedList_Valid_17.whiley
index a69aeb7f47..e3b7186299 100644
--- a/tests/valid/ConstrainedList_Valid_17.whiley
+++ b/tests/valid/ConstrainedList_Valid_17.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -6,6 +6,6 @@ function f([[nat]] xs) -> [nat]
requires |xs| > 0:
return xs[0]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[nat] rs = f([[1, 2, 3], [4, 5, 6]])
- sys.out.println(rs)
+ assume rs == [1,2,3]
diff --git a/tests/valid/ConstrainedList_Valid_18.sysout b/tests/valid/ConstrainedList_Valid_18.sysout
deleted file mode 100644
index b5d8bb58d9..0000000000
--- a/tests/valid/ConstrainedList_Valid_18.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3]
diff --git a/tests/valid/ConstrainedList_Valid_18.whiley b/tests/valid/ConstrainedList_Valid_18.whiley
index 2c7af8c057..dee8838e38 100644
--- a/tests/valid/ConstrainedList_Valid_18.whiley
+++ b/tests/valid/ConstrainedList_Valid_18.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -8,6 +8,6 @@ ensures some { x in rs | x >= 0 }:
//
return xs
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] rs = f([1, 2, 3])
- sys.out.println(rs)
+ assume rs == [1,2,3]
diff --git a/tests/valid/ConstrainedList_Valid_19.sysout b/tests/valid/ConstrainedList_Valid_19.sysout
deleted file mode 100644
index b5d8bb58d9..0000000000
--- a/tests/valid/ConstrainedList_Valid_19.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3]
diff --git a/tests/valid/ConstrainedList_Valid_19.whiley b/tests/valid/ConstrainedList_Valid_19.whiley
index d452ece90b..a42afbabd7 100644
--- a/tests/valid/ConstrainedList_Valid_19.whiley
+++ b/tests/valid/ConstrainedList_Valid_19.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -8,6 +8,6 @@ function g([nat] xs) -> [nat]:
function f([nat] xs) -> [nat]:
return g(xs)
-method main(System.Console sys) -> void:
+public export method test() -> void:
[nat] rs = f([1, 2, 3])
- sys.out.println(rs)
+ assume rs == [1,2,3]
diff --git a/tests/valid/ConstrainedList_Valid_2.sysout b/tests/valid/ConstrainedList_Valid_2.sysout
deleted file mode 100644
index 459fe33611..0000000000
--- a/tests/valid/ConstrainedList_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 3, 5, 7, 9, 11]
diff --git a/tests/valid/ConstrainedList_Valid_2.whiley b/tests/valid/ConstrainedList_Valid_2.whiley
index e5dda3a72d..927fd89882 100644
--- a/tests/valid/ConstrainedList_Valid_2.whiley
+++ b/tests/valid/ConstrainedList_Valid_2.whiley
@@ -1,5 +1,3 @@
-import whiley.lang.*
-
type nat is (int x) where x >= 0
function abs([int] items) -> [nat]
@@ -11,10 +9,16 @@ requires (index <= |items|) && all { i in 0 .. index | items[i] >= 0 }:
if index == |items|:
return items
else:
- items[index] = Math.abs(items[index])
+ items[index] = abs(items[index])
return abs(items, index + 1)
-method main(System.Console sys) -> void:
+function abs(int x) -> nat:
+ if x >= 0:
+ return x
+ else:
+ return -x
+
+public export method test() -> void:
[nat] xs = [1, -3, -5, 7, -9, 11]
xs = abs(xs)
- sys.out.println(xs)
+ assume xs == [1,3,5,7,9,11]
diff --git a/tests/valid/ConstrainedList_Valid_20.sysout b/tests/valid/ConstrainedList_Valid_20.sysout
deleted file mode 100644
index d00491fd7e..0000000000
--- a/tests/valid/ConstrainedList_Valid_20.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ConstrainedList_Valid_20.whiley b/tests/valid/ConstrainedList_Valid_20.whiley
index 4584d4a245..b57b89d472 100644
--- a/tests/valid/ConstrainedList_Valid_20.whiley
+++ b/tests/valid/ConstrainedList_Valid_20.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -11,7 +11,11 @@ ensures r >= 0:
else:
return ls[i]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] xs = [1, 3, 5, 7, 9, 11]
- int c = get(xs, 0)
- sys.out.println(c)
+ assume get(xs, 0) == 1
+ assume get(xs, 1) == 3
+ assume get(xs, 2) == 5
+ assume get(xs, 3) == 7
+ assume get(xs, 4) == 9
+ assume get(xs, 5) == 11
diff --git a/tests/valid/ConstrainedList_Valid_21.sysout b/tests/valid/ConstrainedList_Valid_21.sysout
deleted file mode 100644
index 6f934f8784..0000000000
--- a/tests/valid/ConstrainedList_Valid_21.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[0, 1, 0, 0, 0, 1, 0, 0]
-[0, 0, 1, 0, 1, 0, 1, 0]
-[0, 0, 0, 1, 0, 2, 0, 0]
diff --git a/tests/valid/ConstrainedList_Valid_21.whiley b/tests/valid/ConstrainedList_Valid_21.whiley
index 8064872bf7..a92f5e55dd 100644
--- a/tests/valid/ConstrainedList_Valid_21.whiley
+++ b/tests/valid/ConstrainedList_Valid_21.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -29,10 +29,10 @@ requires no { c in coins | c >= |Value| }:
cash[i] = cash[i] + 1
return cash
-method main(System.Console sys) -> void:
+public export method test() -> void:
Cash cash = Cash([ONE_DOLLAR, FIVE_CENTS])
- sys.out.println(cash)
+ assume cash == [0, 1, 0, 0, 0, 1, 0, 0]
cash = Cash([FIVE_DOLLARS, TEN_CENTS, FIFTY_CENTS])
- sys.out.println(cash)
+ assume cash == [0, 0, 1, 0, 1, 0, 1, 0]
cash = Cash([ONE_DOLLAR, ONE_DOLLAR, TWENTY_CENTS])
- sys.out.println(cash)
+ assume cash == [0, 0, 0, 1, 0, 2, 0, 0]
diff --git a/tests/valid/ConstrainedList_Valid_22.sysout b/tests/valid/ConstrainedList_Valid_22.sysout
deleted file mode 100644
index c02d736091..0000000000
--- a/tests/valid/ConstrainedList_Valid_22.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[1]
-[2, 3, 4]
-[11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
diff --git a/tests/valid/ConstrainedList_Valid_22.whiley b/tests/valid/ConstrainedList_Valid_22.whiley
index 8a94e32a5e..1b63017fed 100644
--- a/tests/valid/ConstrainedList_Valid_22.whiley
+++ b/tests/valid/ConstrainedList_Valid_22.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -11,7 +11,7 @@ function inc([nat] xs) -> [nat]:
assert no { x in xs | x < 0 }
return xs
-method main(System.Console sys) -> void:
- sys.out.println(inc([0]))
- sys.out.println(inc([1, 2, 3]))
- sys.out.println(inc([10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]))
+public export method test() -> void:
+ assume inc([0]) == [1]
+ assume inc([1, 2, 3]) == [2,3,4]
+ assume inc([10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) == [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
diff --git a/tests/valid/ConstrainedList_Valid_23.sysout b/tests/valid/ConstrainedList_Valid_23.sysout
deleted file mode 100644
index bfb70dca80..0000000000
--- a/tests/valid/ConstrainedList_Valid_23.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[[19, 43], [22, 50]]
diff --git a/tests/valid/ConstrainedList_Valid_23.whiley b/tests/valid/ConstrainedList_Valid_23.whiley
index dc316d1839..e52d3c31ba 100644
--- a/tests/valid/ConstrainedList_Valid_23.whiley
+++ b/tests/valid/ConstrainedList_Valid_23.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Matrix is ([[int]] rows)
where no {
@@ -18,8 +18,8 @@ requires (|A| > 0) && ((|B| > 0) && (|B| == |A[0]|)):
C = C ++ [row]
return C
-method main(System.Console sys) -> void:
+public export method test() -> void:
Matrix m1 = [[1, 2], [3, 4]]
Matrix m2 = [[5, 6], [7, 8]]
Matrix m3 = run(m1, m2)
- sys.out.println(m3)
+ assume m3 == [[19, 22], [43, 50]]
diff --git a/tests/valid/ConstrainedList_Valid_24.sysout b/tests/valid/ConstrainedList_Valid_24.sysout
deleted file mode 100644
index ed64afdc24..0000000000
--- a/tests/valid/ConstrainedList_Valid_24.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[{}, {2}, {3}, {1}]
diff --git a/tests/valid/ConstrainedList_Valid_24.whiley b/tests/valid/ConstrainedList_Valid_24.whiley
index e55553b34a..b7a7ea10f3 100644
--- a/tests/valid/ConstrainedList_Valid_24.whiley
+++ b/tests/valid/ConstrainedList_Valid_24.whiley
@@ -1,20 +1,25 @@
-import whiley.lang.*
-
type nat is (int x) where x >= 0
type Digraph is ([{nat}] edges) where no { v in edges, w in v | w >= |edges| }
+function max(nat a, nat b) -> nat:
+ if a >= b:
+ return a
+ else:
+ return b
+
function addEdge(Digraph g, nat from, nat to) -> Digraph:
- int mx = Math.max(from, to)
+ int mx = max(from, to)
while |g| <= mx:
g = g ++ [{}]
assert from < |g| && |g| > to
g[from] = g[from] + {to}
return g
-method main(System.Console sys) -> void:
+public export method test() -> void:
Digraph g = []
g = addEdge(g, 1, 2)
g = addEdge(g, 2, 3)
g = addEdge(g, 3, 1)
- sys.out.println(g)
+ assume g == [{}, {2}, {3}, {1}]
+
diff --git a/tests/valid/ConstrainedList_Valid_25.sysout b/tests/valid/ConstrainedList_Valid_25.sysout
deleted file mode 100644
index a853540da4..0000000000
--- a/tests/valid/ConstrainedList_Valid_25.sysout
+++ /dev/null
@@ -1,8 +0,0 @@
-5
-4
-6
-3
-7
-2
-8
-1
diff --git a/tests/valid/ConstrainedList_Valid_25.whiley b/tests/valid/ConstrainedList_Valid_25.whiley
index 80e90d6443..5cf77e5ec9 100644
--- a/tests/valid/ConstrainedList_Valid_25.whiley
+++ b/tests/valid/ConstrainedList_Valid_25.whiley
@@ -1,10 +1,12 @@
-import whiley.lang.*
+
function indexOf([int] list, int index) -> int
requires all { l in list | l >= 0 } && ((index >= 0) && (index < |list|)):
return list[index]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] items = [5, 4, 6, 3, 7, 2, 8, 1]
- for i in 0 .. |items|:
- sys.out.println(indexOf(items, i))
+ int i = 0
+ while i < |items|:
+ assume indexOf(items,i) == items[i]
+ i = i + 1
diff --git a/tests/valid/ConstrainedList_Valid_26.sysout b/tests/valid/ConstrainedList_Valid_26.sysout
deleted file mode 100644
index c71bf50e82..0000000000
--- a/tests/valid/ConstrainedList_Valid_26.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[]
-[]
diff --git a/tests/valid/ConstrainedList_Valid_26.whiley b/tests/valid/ConstrainedList_Valid_26.whiley
index db282ba2f7..ea7916a4b1 100644
--- a/tests/valid/ConstrainedList_Valid_26.whiley
+++ b/tests/valid/ConstrainedList_Valid_26.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] ls) -> ([int] r)
ensures r == []:
@@ -8,7 +8,7 @@ ensures r == []:
else:
return []
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] items = [5, 4, 6, 3, 7, 2, 8, 1]
- sys.out.println(f(items))
- sys.out.println(f([]))
+ assume f(items) == []
+ assume f([]) == []
diff --git a/tests/valid/ConstrainedList_Valid_27.sysout b/tests/valid/ConstrainedList_Valid_27.sysout
deleted file mode 100644
index 6c9eabe634..0000000000
--- a/tests/valid/ConstrainedList_Valid_27.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-3
-0
-0
diff --git a/tests/valid/ConstrainedList_Valid_27.whiley b/tests/valid/ConstrainedList_Valid_27.whiley
index 2b00cde76d..285749f733 100644
--- a/tests/valid/ConstrainedList_Valid_27.whiley
+++ b/tests/valid/ConstrainedList_Valid_27.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
type nat is (int x) where x >= 0
@@ -10,7 +10,7 @@ ensures r >= 0:
//
return 0
-method main(System.Console console):
- console.out.println(f([1,2,3]))
- console.out.println(f([-1]))
- console.out.println(f([1,0,-1]))
+public export method test():
+ assume f([1,2,3]) == 3
+ assume f([-1]) == 0
+ assume f([1,0,-1]) == 0
diff --git a/tests/valid/ConstrainedList_Valid_3.sysout b/tests/valid/ConstrainedList_Valid_3.sysout
deleted file mode 100644
index 0d3589e8be..0000000000
--- a/tests/valid/ConstrainedList_Valid_3.sysout
+++ /dev/null
@@ -1,10 +0,0 @@
-[]
-[1]
-[2, 2]
-[3, 3, 3]
-[4, 4, 4, 4]
-[5, 5, 5, 5, 5]
-[6, 6, 6, 6, 6, 6]
-[7, 7, 7, 7, 7, 7, 7]
-[8, 8, 8, 8, 8, 8, 8, 8]
-[9, 9, 9, 9, 9, 9, 9, 9, 9]
diff --git a/tests/valid/ConstrainedList_Valid_3.whiley b/tests/valid/ConstrainedList_Valid_3.whiley
index cfb162cc71..7ffa8c6c4b 100644
--- a/tests/valid/ConstrainedList_Valid_3.whiley
+++ b/tests/valid/ConstrainedList_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -13,6 +13,11 @@ ensures (|result| == length) && all { i in result | i == value }:
//
return data
-method main(System.Console sys) -> void:
- for i in 0 .. 10:
- sys.out.println(init(i, i))
+public export method test() -> void:
+ assume init(0,0) == []
+ assume init(1,1) == [1]
+ assume init(2,2) == [2,2]
+ assume init(3,3) == [3,3,3]
+ assume init(4,4) == [4,4,4,4]
+ assume init(5,5) == [5,5,5,5,5]
+ assume init(6,6) == [6,6,6,6,6,6]
diff --git a/tests/valid/ConstrainedList_Valid_4.sysout b/tests/valid/ConstrainedList_Valid_4.sysout
deleted file mode 100755
index 7660873d10..0000000000
--- a/tests/valid/ConstrainedList_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1]
diff --git a/tests/valid/ConstrainedList_Valid_4.whiley b/tests/valid/ConstrainedList_Valid_4.whiley
index 5cd141ce7d..d7e22f9062 100644
--- a/tests/valid/ConstrainedList_Valid_4.whiley
+++ b/tests/valid/ConstrainedList_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type i8 is (int n) where -128 >= n && n <= 127
@@ -9,6 +9,6 @@ ensures (r > 0) && (r < 125):
function f(int x) -> [i8]:
return [g(x)]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] bytes = f(0)
- sys.out.println(bytes)
+ assume bytes == [1]
diff --git a/tests/valid/ConstrainedList_Valid_5.sysout b/tests/valid/ConstrainedList_Valid_5.sysout
deleted file mode 100755
index 7660873d10..0000000000
--- a/tests/valid/ConstrainedList_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1]
diff --git a/tests/valid/ConstrainedList_Valid_5.whiley b/tests/valid/ConstrainedList_Valid_5.whiley
index 1d2114aff5..5f557cfceb 100644
--- a/tests/valid/ConstrainedList_Valid_5.whiley
+++ b/tests/valid/ConstrainedList_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function g(int x) -> int:
if (x <= 0) || (x >= 125):
@@ -9,6 +9,6 @@ function g(int x) -> int:
function f(int x) -> [int]:
return [g(x)]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] bytes = f(0)
- sys.out.println(bytes)
+ assume bytes == [1]
diff --git a/tests/valid/ConstrainedList_Valid_6.sysout b/tests/valid/ConstrainedList_Valid_6.sysout
deleted file mode 100644
index 6f934f8784..0000000000
--- a/tests/valid/ConstrainedList_Valid_6.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[0, 1, 0, 0, 0, 1, 0, 0]
-[0, 0, 1, 0, 1, 0, 1, 0]
-[0, 0, 0, 1, 0, 2, 0, 0]
diff --git a/tests/valid/ConstrainedList_Valid_6.whiley b/tests/valid/ConstrainedList_Valid_6.whiley
index b7dc0e9548..e7bb98bf41 100644
--- a/tests/valid/ConstrainedList_Valid_6.whiley
+++ b/tests/valid/ConstrainedList_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -35,10 +35,7 @@ requires all { c in coins | c < |Value| }:
i = i + 1
return cash
-method main(System.Console sys) -> void:
- Cash cash = Cash([ONE_DOLLAR, FIVE_CENTS])
- sys.out.println(cash)
- cash = Cash([FIVE_DOLLARS, TEN_CENTS, FIFTY_CENTS])
- sys.out.println(cash)
- cash = Cash([ONE_DOLLAR, ONE_DOLLAR, TWENTY_CENTS])
- sys.out.println(cash)
+public export method test() -> void:
+ assume Cash([ONE_DOLLAR, FIVE_CENTS]) == [0, 1, 0, 0, 0, 1, 0, 0]
+ assume Cash([FIVE_DOLLARS, TEN_CENTS, FIFTY_CENTS]) == [0, 0, 1, 0, 1, 0, 1, 0]
+ assume Cash([ONE_DOLLAR, ONE_DOLLAR, TWENTY_CENTS]) == [0, 0, 0, 1, 0, 2, 0, 0]
diff --git a/tests/valid/ConstrainedList_Valid_7.sysout b/tests/valid/ConstrainedList_Valid_7.sysout
deleted file mode 100644
index 305fc3c42b..0000000000
--- a/tests/valid/ConstrainedList_Valid_7.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[0, 1, 2]
-[0]
-[0, 1, 2]
diff --git a/tests/valid/ConstrainedList_Valid_7.whiley b/tests/valid/ConstrainedList_Valid_7.whiley
index da48326096..f6059f04f2 100644
--- a/tests/valid/ConstrainedList_Valid_7.whiley
+++ b/tests/valid/ConstrainedList_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] x) -> [int]
requires x[0] == 0:
@@ -10,7 +10,7 @@ requires x[0] == 0:
assert |x| > 0
return x
-method main(System.Console console) -> void:
- console.out.println(f([0, 1, 2]))
- console.out.println(g([0]))
- console.out.println(g([0, 1, 2]))
+public export method test() -> void:
+ assume f([0, 1, 2]) == [0,1,2]
+ assume g([0]) == [0]
+ assume g([0, 1, 2]) == [0,1,2]
diff --git a/tests/valid/ConstrainedList_Valid_8.sysout b/tests/valid/ConstrainedList_Valid_8.sysout
deleted file mode 100644
index 0797ea536d..0000000000
--- a/tests/valid/ConstrainedList_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[2, 3, 4, 5]
diff --git a/tests/valid/ConstrainedList_Valid_8.whiley b/tests/valid/ConstrainedList_Valid_8.whiley
index 5c05d122f8..f1f3e49278 100644
--- a/tests/valid/ConstrainedList_Valid_8.whiley
+++ b/tests/valid/ConstrainedList_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -7,10 +7,11 @@ requires index < |list|:
list[index] = value
return list
-method main(System.Console console) -> void:
+public export method test() -> void:
[nat] xs = [1, 2, 3, 4]
xs = update(xs, 0, 2)
xs = update(xs, 1, 3)
xs = update(xs, 2, 4)
xs = update(xs, 3, 5)
- console.out.println(xs)
+ assume xs == [2, 3, 4, 5]
+
diff --git a/tests/valid/ConstrainedList_Valid_9.sysout b/tests/valid/ConstrainedList_Valid_9.sysout
deleted file mode 100755
index 9902f17848..0000000000
--- a/tests/valid/ConstrainedList_Valid_9.sysout
+++ /dev/null
@@ -1 +0,0 @@
-28
diff --git a/tests/valid/ConstrainedList_Valid_9.whiley b/tests/valid/ConstrainedList_Valid_9.whiley
index 5dbab19428..78f8983f4b 100644
--- a/tests/valid/ConstrainedList_Valid_9.whiley
+++ b/tests/valid/ConstrainedList_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type posintlist is ([int] list) where no { x in list | x < 0 }
@@ -18,6 +18,5 @@ ensures r >= 0:
//
return sum(ls, 0)
-method main(System.Console sys) -> void:
- int c = sum([1, 2, 3, 4, 5, 6, 7])
- sys.out.println(c)
+public export method test() -> void:
+ assume sum([1, 2, 3, 4, 5, 6, 7]) == 28
diff --git a/tests/valid/ConstrainedNegation_Valid_1.whiley b/tests/valid/ConstrainedNegation_Valid_1.whiley
index 9b2d21ff43..08f234c63f 100644
--- a/tests/valid/ConstrainedNegation_Valid_1.whiley
+++ b/tests/valid/ConstrainedNegation_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
type neg is !nat
@@ -9,6 +9,6 @@ ensures y < 0:
else:
return 0
-public method main(System.Console sys) -> void:
- sys.out.println(f(-1))
- sys.out.println(f(-2))
+public export method test() -> void:
+ assume f(-1) == -1
+ assume f(-2) == -2
diff --git a/tests/valid/ConstrainedNegation_Valid_2.whiley b/tests/valid/ConstrainedNegation_Valid_2.whiley
index 1f0f84d75b..6c55d16db0 100644
--- a/tests/valid/ConstrainedNegation_Valid_2.whiley
+++ b/tests/valid/ConstrainedNegation_Valid_2.whiley
@@ -8,8 +8,8 @@ ensures r >= 0:
//
return v+1
-method main(System.Console console):
- console.out.println(f(1))
- console.out.println(f(9))
- console.out.println(f(-1))
- console.out.println(f(-3))
+public export method test():
+ assume f(1) == 2
+ assume f(9) == 10
+ assume f(-1) == 0
+ assume f(-3) == 0
diff --git a/tests/valid/ConstrainedRecord_Valid_1.sysout b/tests/valid/ConstrainedRecord_Valid_1.sysout
deleted file mode 100755
index 111bb86865..0000000000
--- a/tests/valid/ConstrainedRecord_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[0]
diff --git a/tests/valid/ConstrainedRecord_Valid_1.whiley b/tests/valid/ConstrainedRecord_Valid_1.whiley
index ba954e3afc..4f06a5758f 100644
--- a/tests/valid/ConstrainedRecord_Valid_1.whiley
+++ b/tests/valid/ConstrainedRecord_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant RET is 169
@@ -11,6 +11,6 @@ type UNIT is {unitCode op}
function f(UNIT x) -> [int]:
return [x.op]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] bytes = f({op: NOP})
- sys.out.println(bytes)
+ assume bytes == [NOP]
diff --git a/tests/valid/ConstrainedRecord_Valid_10.sysout b/tests/valid/ConstrainedRecord_Valid_10.sysout
deleted file mode 100644
index b261da18d5..0000000000
--- a/tests/valid/ConstrainedRecord_Valid_10.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-0
diff --git a/tests/valid/ConstrainedRecord_Valid_10.whiley b/tests/valid/ConstrainedRecord_Valid_10.whiley
index e138b561f4..b25593379b 100644
--- a/tests/valid/ConstrainedRecord_Valid_10.whiley
+++ b/tests/valid/ConstrainedRecord_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
type nat is (int x) where x >= 0
@@ -10,6 +10,6 @@ ensures r >= 0:
//
return 0
-method main(System.Console console):
- console.out.println(f({f:1}))
- console.out.println(f({f:-1}))
+public export method test():
+ assume f({f:1}) == 1
+ assume f({f:-1}) == 0
diff --git a/tests/valid/ConstrainedRecord_Valid_2.sysout b/tests/valid/ConstrainedRecord_Valid_2.sysout
deleted file mode 100755
index 573541ac97..0000000000
--- a/tests/valid/ConstrainedRecord_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-0
diff --git a/tests/valid/ConstrainedRecord_Valid_2.whiley b/tests/valid/ConstrainedRecord_Valid_2.whiley
index 972179bb51..468edb5077 100644
--- a/tests/valid/ConstrainedRecord_Valid_2.whiley
+++ b/tests/valid/ConstrainedRecord_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant RET is 169
@@ -11,6 +11,6 @@ type UNIT is {unitCode op}
function f(UNIT x) -> int:
return x.op
-method main(System.Console sys) -> void:
+public export method test() -> void:
int bytes = f({op: NOP})
- sys.out.println(bytes)
+ assume bytes == NOP
diff --git a/tests/valid/ConstrainedRecord_Valid_3.sysout b/tests/valid/ConstrainedRecord_Valid_3.sysout
deleted file mode 100755
index 44e2ace7e5..0000000000
--- a/tests/valid/ConstrainedRecord_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2]
diff --git a/tests/valid/ConstrainedRecord_Valid_3.whiley b/tests/valid/ConstrainedRecord_Valid_3.whiley
index cc60835f92..351c56f965 100644
--- a/tests/valid/ConstrainedRecord_Valid_3.whiley
+++ b/tests/valid/ConstrainedRecord_Valid_3.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
type btup is {int index, int op}
function f(btup b) -> [int]:
return [b.op, b.index]
-method main(System.Console sys) -> void:
- sys.out.println(f({index: 2, op: 1}))
+public export method test() -> void:
+ assume f({index: 2, op: 1}) == [1,2]
diff --git a/tests/valid/ConstrainedRecord_Valid_4.sysout b/tests/valid/ConstrainedRecord_Valid_4.sysout
deleted file mode 100755
index f134b0edf2..0000000000
--- a/tests/valid/ConstrainedRecord_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{x:1,y:1}
diff --git a/tests/valid/ConstrainedRecord_Valid_4.whiley b/tests/valid/ConstrainedRecord_Valid_4.whiley
index 8455907a39..f0f28bc015 100644
--- a/tests/valid/ConstrainedRecord_Valid_4.whiley
+++ b/tests/valid/ConstrainedRecord_Valid_4.whiley
@@ -1,10 +1,11 @@
-import whiley.lang.*
+
type point is {
int x,
int y
} where x > 0 && y > 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
point p = {y: 1, x: 1}
- sys.out.println(p)
+ assert p.y == 1
+ assert p.x == 1
diff --git a/tests/valid/ConstrainedRecord_Valid_5.sysout b/tests/valid/ConstrainedRecord_Valid_5.sysout
deleted file mode 100755
index f134b0edf2..0000000000
--- a/tests/valid/ConstrainedRecord_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{x:1,y:1}
diff --git a/tests/valid/ConstrainedRecord_Valid_5.whiley b/tests/valid/ConstrainedRecord_Valid_5.whiley
index 816309d712..5796b66074 100644
--- a/tests/valid/ConstrainedRecord_Valid_5.whiley
+++ b/tests/valid/ConstrainedRecord_Valid_5.whiley
@@ -1,7 +1,8 @@
-import whiley.lang.*
+
type point is {int y, int x}
-method main(System.Console sys) -> void:
+public export method test() -> void:
point p = {y: 1, x: 1}
- sys.out.println(p)
+ assert p.y == 1
+ assert p.x == 1
diff --git a/tests/valid/ConstrainedRecord_Valid_6.sysout b/tests/valid/ConstrainedRecord_Valid_6.sysout
deleted file mode 100755
index 3e68991fd5..0000000000
--- a/tests/valid/ConstrainedRecord_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{input:[32, 32, 72, 101, 108, 108, 111],pos:2}
diff --git a/tests/valid/ConstrainedRecord_Valid_6.whiley b/tests/valid/ConstrainedRecord_Valid_6.whiley
index 4457f761e9..970a0f654d 100644
--- a/tests/valid/ConstrainedRecord_Valid_6.whiley
+++ b/tests/valid/ConstrainedRecord_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type state is {[int] input, int pos} where (pos >= 0) && (pos <= |input|)
@@ -12,7 +12,6 @@ function parseTerm(state st) -> state:
st = parseWhiteSpace(st)
return st
-method main(System.Console sys) -> void:
+public export method test() -> void:
state st = {input: " Hello", pos: 0}
- st = parseTerm(st)
- sys.out.println(st)
+ assume parseTerm(st) == {input:[32, 32, 72, 101, 108, 108, 111],pos:2}
diff --git a/tests/valid/ConstrainedRecord_Valid_8.sysout b/tests/valid/ConstrainedRecord_Valid_8.sysout
deleted file mode 100644
index db0fff6469..0000000000
--- a/tests/valid/ConstrainedRecord_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-BOARD: {move:0,pieces:[0, 0, 0, 0, 0, 0, 0, 0, 0]}
diff --git a/tests/valid/ConstrainedRecord_Valid_8.whiley b/tests/valid/ConstrainedRecord_Valid_8.whiley
index 156752e3bd..db1147006d 100644
--- a/tests/valid/ConstrainedRecord_Valid_8.whiley
+++ b/tests/valid/ConstrainedRecord_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant BLANK is 0
@@ -17,9 +17,8 @@ type EmptyBoard is (Board b) where no { x in b.pieces | x != BLANK }
function EmptyBoard() -> EmptyBoard:
return {pieces: [BLANK, BLANK, BLANK, BLANK, BLANK, BLANK, BLANK, BLANK, BLANK], move: 0}
-method main(System.Console console) -> void:
+public export method test() -> void:
Board b = EmptyBoard()
assert b.pieces[0] == BLANK
assert b.pieces[1] == BLANK
assert b.pieces[8] == BLANK
- console.out.println_s("BOARD: " ++ Any.toString(b))
diff --git a/tests/valid/ConstrainedRecord_Valid_9.sysout b/tests/valid/ConstrainedRecord_Valid_9.sysout
deleted file mode 100644
index 07e5e598d9..0000000000
--- a/tests/valid/ConstrainedRecord_Valid_9.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{data:[[-1, 4], [9, -2]],height:2,width:2}
-{data:[[22, 28], [49, 64]],height:2,width:2}
-{data:[[38, 44, 50, 56], [83, 98, 113, 128]],height:2,width:4}
diff --git a/tests/valid/ConstrainedRecord_Valid_9.whiley b/tests/valid/ConstrainedRecord_Valid_9.whiley
index 493a9f4e38..cf18499ae2 100644
--- a/tests/valid/ConstrainedRecord_Valid_9.whiley
+++ b/tests/valid/ConstrainedRecord_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -30,16 +30,16 @@ ensures (C.width == B.width) && (C.height == A.height):
C_data = C_data ++ [row]
return Matrix(B.width, A.height, C_data)
-method main(System.Console sys) -> void:
+public export method test() -> void:
Matrix m1 = Matrix(2, 2, [[1, 0], [-3, 2]])
Matrix m2 = Matrix(2, 2, [[-1, 4], [3, 5]])
Matrix m3 = run(m1, m2)
- sys.out.println(m3)
+ assume m3 == {data:[[-1, 4], [9, -2]],height:2,width:2}
m1 = Matrix(3, 2, [[1, 2, 3], [4, 5, 6]])
m2 = Matrix(2, 3, [[1, 2], [3, 4], [5, 6]])
m3 = run(m1, m2)
- sys.out.println(m3)
+ assume m3 == {data:[[22, 28], [49, 64]],height:2,width:2}
m1 = Matrix(3, 2, [[1, 2, 3], [4, 5, 6]])
m2 = Matrix(4, 3, [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
m3 = run(m1, m2)
- sys.out.println(m3)
+ assume m3 == {data:[[38, 44, 50, 56], [83, 98, 113, 128]],height:2,width:4}
diff --git a/tests/valid/ConstrainedReference_Valid_1.sysout b/tests/valid/ConstrainedReference_Valid_1.sysout
deleted file mode 100644
index 389e262145..0000000000
--- a/tests/valid/ConstrainedReference_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-2
-0
diff --git a/tests/valid/ConstrainedReference_Valid_1.whiley b/tests/valid/ConstrainedReference_Valid_1.whiley
index dca4792c25..c4618beda8 100644
--- a/tests/valid/ConstrainedReference_Valid_1.whiley
+++ b/tests/valid/ConstrainedReference_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
type nat is (int x) where x >= 0
@@ -10,6 +10,6 @@ ensures r >= 0:
//
return 0
-method main(System.Console console):
- console.out.println(f(new 1))
- console.out.println(f(new -1))
+public export method test():
+ assume f(new 1) == 2
+ assume f(new -1) == 0
diff --git a/tests/valid/ConstrainedSet_Valid_1.sysout b/tests/valid/ConstrainedSet_Valid_1.sysout
deleted file mode 100755
index 7611e11db8..0000000000
--- a/tests/valid/ConstrainedSet_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{0}
diff --git a/tests/valid/ConstrainedSet_Valid_1.whiley b/tests/valid/ConstrainedSet_Valid_1.whiley
index e73c61eb4a..c263bf481c 100644
--- a/tests/valid/ConstrainedSet_Valid_1.whiley
+++ b/tests/valid/ConstrainedSet_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type u8 is (int n) where 0 >= n && n <= 255
@@ -6,6 +6,6 @@ function f(int x) -> {u8}
requires (x == 0) || (x == 169):
return {x}
-method main(System.Console sys) -> void:
+public export method test() -> void:
{u8} bytes = f(0)
- sys.out.println(bytes)
+ assume bytes == {0}
diff --git a/tests/valid/ConstrainedSet_Valid_2.sysout b/tests/valid/ConstrainedSet_Valid_2.sysout
deleted file mode 100755
index 7611e11db8..0000000000
--- a/tests/valid/ConstrainedSet_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{0}
diff --git a/tests/valid/ConstrainedSet_Valid_2.whiley b/tests/valid/ConstrainedSet_Valid_2.whiley
index 5f7d2542a6..3a2ceed1d6 100644
--- a/tests/valid/ConstrainedSet_Valid_2.whiley
+++ b/tests/valid/ConstrainedSet_Valid_2.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
function f(int x) -> {int}:
return {x}
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} bytes = f(0)
- sys.out.println(bytes)
+ assume bytes == {0}
diff --git a/tests/valid/ConstrainedSet_Valid_3.sysout b/tests/valid/ConstrainedSet_Valid_3.sysout
deleted file mode 100755
index c29bd4fd5d..0000000000
--- a/tests/valid/ConstrainedSet_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1}
diff --git a/tests/valid/ConstrainedSet_Valid_3.whiley b/tests/valid/ConstrainedSet_Valid_3.whiley
index 57c653b6e5..a4e841755b 100644
--- a/tests/valid/ConstrainedSet_Valid_3.whiley
+++ b/tests/valid/ConstrainedSet_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type i8 is (int n) where -128 >= n && n <= 127
@@ -14,6 +14,6 @@ ensures r > 0 && r < 125:
function f(int x) -> {i8}:
return {g(x)}
-method main(System.Console sys) -> void:
+public export method test() -> void:
{i8} bytes = f(0)
- sys.out.println(bytes)
+ assume bytes == {1}
diff --git a/tests/valid/ConstrainedSet_Valid_4.sysout b/tests/valid/ConstrainedSet_Valid_4.sysout
deleted file mode 100755
index c29bd4fd5d..0000000000
--- a/tests/valid/ConstrainedSet_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1}
diff --git a/tests/valid/ConstrainedSet_Valid_4.whiley b/tests/valid/ConstrainedSet_Valid_4.whiley
index 494adca7a5..5625fcbc1f 100644
--- a/tests/valid/ConstrainedSet_Valid_4.whiley
+++ b/tests/valid/ConstrainedSet_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function g(int x) -> int:
if (x <= 0) || (x >= 125):
@@ -9,6 +9,6 @@ function g(int x) -> int:
function f(int x) -> {int}:
return {g(x)}
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} bytes = f(0)
- sys.out.println(bytes)
+ assume bytes == {1}
diff --git a/tests/valid/ConstrainedSet_Valid_5.sysout b/tests/valid/ConstrainedSet_Valid_5.sysout
deleted file mode 100755
index 2d05c9ead5..0000000000
--- a/tests/valid/ConstrainedSet_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2, 3}
diff --git a/tests/valid/ConstrainedSet_Valid_5.whiley b/tests/valid/ConstrainedSet_Valid_5.whiley
index 79f76b201c..cc8758f34e 100644
--- a/tests/valid/ConstrainedSet_Valid_5.whiley
+++ b/tests/valid/ConstrainedSet_Valid_5.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type posints is ({int} xs) where no { x in xs | x < 0 }
function f(posints x) -> {int}:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
posints xs = {1, 2, 3}
- sys.out.println(f(xs))
+ assume f(xs) == {1,2,3}
diff --git a/tests/valid/ConstrainedSet_Valid_6.sysout b/tests/valid/ConstrainedSet_Valid_6.sysout
deleted file mode 100755
index 2d05c9ead5..0000000000
--- a/tests/valid/ConstrainedSet_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2, 3}
diff --git a/tests/valid/ConstrainedSet_Valid_6.whiley b/tests/valid/ConstrainedSet_Valid_6.whiley
index 43c92a1c31..3c7484cf3e 100644
--- a/tests/valid/ConstrainedSet_Valid_6.whiley
+++ b/tests/valid/ConstrainedSet_Valid_6.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type posints is {int}
function f(posints x) -> {int}:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
posints xs = {1, 2, 3}
- sys.out.println(f(xs))
+ assume f(xs) == {1,2,3}
diff --git a/tests/valid/ConstrainedSet_Valid_7.sysout b/tests/valid/ConstrainedSet_Valid_7.sysout
deleted file mode 100755
index 47848d0a3b..0000000000
--- a/tests/valid/ConstrainedSet_Valid_7.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2}
diff --git a/tests/valid/ConstrainedSet_Valid_7.whiley b/tests/valid/ConstrainedSet_Valid_7.whiley
index d38a798f8e..6c543b5115 100644
--- a/tests/valid/ConstrainedSet_Valid_7.whiley
+++ b/tests/valid/ConstrainedSet_Valid_7.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
type pintset is ({int} xs) where |xs| > 1
-method main(System.Console sys) -> void:
+public export method test() -> void:
pintset p = {1, 2}
- sys.out.println(p)
+ assume p == {1,2}
diff --git a/tests/valid/ConstrainedSet_Valid_8.sysout b/tests/valid/ConstrainedSet_Valid_8.sysout
deleted file mode 100755
index 47848d0a3b..0000000000
--- a/tests/valid/ConstrainedSet_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2}
diff --git a/tests/valid/ConstrainedSet_Valid_8.whiley b/tests/valid/ConstrainedSet_Valid_8.whiley
index 5e580eafc7..73081a5d24 100644
--- a/tests/valid/ConstrainedSet_Valid_8.whiley
+++ b/tests/valid/ConstrainedSet_Valid_8.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
type pintset is {int}
-method main(System.Console sys) -> void:
+public export method test() -> void:
pintset p = {1, 2}
- sys.out.println(p)
+ assert p == {1,2}
diff --git a/tests/valid/ConstrainedSet_Valid_9.sysout b/tests/valid/ConstrainedSet_Valid_9.sysout
deleted file mode 100644
index 6c9eabe634..0000000000
--- a/tests/valid/ConstrainedSet_Valid_9.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-3
-0
-0
diff --git a/tests/valid/ConstrainedSet_Valid_9.whiley b/tests/valid/ConstrainedSet_Valid_9.whiley
index 94945bf667..29d8940009 100644
--- a/tests/valid/ConstrainedSet_Valid_9.whiley
+++ b/tests/valid/ConstrainedSet_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
type nat is (int x) where x >= 0
@@ -10,7 +10,7 @@ ensures r >= 0:
//
return 0
-method main(System.Console console):
- console.out.println(f({1,2,3}))
- console.out.println(f({-1}))
- console.out.println(f({1,0,-1}))
+public export method test():
+ assume f({1,2,3}) == 3
+ assume f({-1}) == 0
+ assume f({1,0,-1}) == 0
diff --git a/tests/valid/ConstrainedTuple_Valid_1.sysout b/tests/valid/ConstrainedTuple_Valid_1.sysout
deleted file mode 100644
index 0ca7950b2f..0000000000
--- a/tests/valid/ConstrainedTuple_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-GOT: 8
diff --git a/tests/valid/ConstrainedTuple_Valid_1.whiley b/tests/valid/ConstrainedTuple_Valid_1.whiley
index dda48208a7..1daf223958 100644
--- a/tests/valid/ConstrainedTuple_Valid_1.whiley
+++ b/tests/valid/ConstrainedTuple_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -8,6 +8,7 @@ function f(tnat tup) -> nat:
int x, int y = tup
return x + y
-public method main(System.Console console) -> void:
+public export method test() -> void:
(int,int) x = 3, 5
- console.out.println_s("GOT: " ++ Any.toString(f(x)))
+ assume f(x) == 8
+
diff --git a/tests/valid/ConstrainedTuple_Valid_2.sysout b/tests/valid/ConstrainedTuple_Valid_2.sysout
deleted file mode 100644
index b74f207936..0000000000
--- a/tests/valid/ConstrainedTuple_Valid_2.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-8
-0
-0
diff --git a/tests/valid/ConstrainedTuple_Valid_2.whiley b/tests/valid/ConstrainedTuple_Valid_2.whiley
index be867cbdfc..2ec74dac6b 100644
--- a/tests/valid/ConstrainedTuple_Valid_2.whiley
+++ b/tests/valid/ConstrainedTuple_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
type tup is (int, int)
@@ -10,10 +10,10 @@ function f(tup t) -> int:
//
return 0
-public method main(System.Console console) -> void:
+public export method test() -> void:
(int,int) x = 3, 5
- console.out.println(f(x))
+ assume f(x) == 8
x = -3, 5
- console.out.println(f(x))
+ assume f(x) == 0
x = 3, -5
- console.out.println(f(x))
+ assume f(x) == 0
diff --git a/tests/valid/ConstrainedUnion_Valid_1.sysout b/tests/valid/ConstrainedUnion_Valid_1.sysout
deleted file mode 100644
index 2f1465d159..0000000000
--- a/tests/valid/ConstrainedUnion_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-1
-0
diff --git a/tests/valid/ConstrainedUnion_Valid_1.whiley b/tests/valid/ConstrainedUnion_Valid_1.whiley
index 407f9852af..ee63ba19d7 100644
--- a/tests/valid/ConstrainedUnion_Valid_1.whiley
+++ b/tests/valid/ConstrainedUnion_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
type nat is (int x) where x >= 0
@@ -10,7 +10,7 @@ ensures r >= 0:
//
return 0
-method main(System.Console console):
- console.out.println(f(1))
- console.out.println(f(true))
- console.out.println(f(-1))
+public export method test():
+ assume f(1) == 1
+ assume f(true) == 1
+ assume f(-1) == 0
diff --git a/tests/valid/Contractive_Valid_1.sysout b/tests/valid/Contractive_Valid_1.sysout
deleted file mode 100644
index 19765bd501..0000000000
--- a/tests/valid/Contractive_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-null
diff --git a/tests/valid/Contractive_Valid_1.whiley b/tests/valid/Contractive_Valid_1.whiley
index 22ec51c588..649739d042 100644
--- a/tests/valid/Contractive_Valid_1.whiley
+++ b/tests/valid/Contractive_Valid_1.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type Contractive is Contractive | null
function f(Contractive x) -> Contractive:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
x = f(null)
- sys.out.println(x)
+ assume x == null
diff --git a/tests/valid/Contractive_Valid_2.sysout b/tests/valid/Contractive_Valid_2.sysout
deleted file mode 100644
index 19765bd501..0000000000
--- a/tests/valid/Contractive_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-null
diff --git a/tests/valid/Contractive_Valid_2.whiley b/tests/valid/Contractive_Valid_2.whiley
index ccba84b6ab..e22435a34f 100644
--- a/tests/valid/Contractive_Valid_2.whiley
+++ b/tests/valid/Contractive_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type C1 is null | any
@@ -18,6 +18,6 @@ method h(C3 x) -> C1:
method i(C3 x) -> C2:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
C3 x = f(null)
- sys.out.println(x)
+ assume x == null
diff --git a/tests/valid/DecimalAssignment_Valid_1.sysout b/tests/valid/DecimalAssignment_Valid_1.sysout
deleted file mode 100644
index 319cbe06de..0000000000
--- a/tests/valid/DecimalAssignment_Valid_1.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-5.0
-3.234
-5.242325252
--1.0
-(-154/125)
\ No newline at end of file
diff --git a/tests/valid/DecimalAssignment_Valid_1.whiley b/tests/valid/DecimalAssignment_Valid_1.whiley
index f2d292bd6c..bb1834e140 100644
--- a/tests/valid/DecimalAssignment_Valid_1.whiley
+++ b/tests/valid/DecimalAssignment_Valid_1.whiley
@@ -1,13 +1,13 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
real x = 5.0
- sys.out.println(x)
+ assert x == 5.0
x = 3.234
- sys.out.println(x)
+ assert x == 3.234
x = 5.242325252
- sys.out.println(x)
+ assert x == 5.242325252
x = -1.0
- sys.out.println(x)
+ assert x == -1.0
x = -1.232
- sys.out.println(x)
+ assert x == -1.232
diff --git a/tests/valid/Define_Valid_1.sysout b/tests/valid/Define_Valid_1.sysout
deleted file mode 100755
index 39a859353d..0000000000
--- a/tests/valid/Define_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-3
-1
diff --git a/tests/valid/Define_Valid_1.whiley b/tests/valid/Define_Valid_1.whiley
index 3c7fa11375..8a9e6e00de 100644
--- a/tests/valid/Define_Valid_1.whiley
+++ b/tests/valid/Define_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type point is {int y, int x}
@@ -6,11 +6,11 @@ type listint is [int]
type setint is {int}
-method main(System.Console sys) -> void:
+public export method test() -> void:
setint si = {1, 2, 3}
listint li = [1, 2, 3]
point p = {y: 2, x: 1}
int x = p.x
- sys.out.println(x)
- sys.out.println(|si|)
- sys.out.println(li[0])
+ assert x == 1
+ assert |si| == 3
+ assert li[0] == 1
diff --git a/tests/valid/Define_Valid_2.sysout b/tests/valid/Define_Valid_2.sysout
deleted file mode 100755
index abd533141b..0000000000
--- a/tests/valid/Define_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{x:1.0,y:2.23}
diff --git a/tests/valid/Define_Valid_2.whiley b/tests/valid/Define_Valid_2.whiley
index 1439897622..965711376f 100644
--- a/tests/valid/Define_Valid_2.whiley
+++ b/tests/valid/Define_Valid_2.whiley
@@ -1,7 +1,8 @@
-import whiley.lang.*
+
type dr2point is {real y, real x}
-method main(System.Console sys) -> void:
+public export method test() -> void:
dr2point p = {y: 2.23, x: 1.0}
- sys.out.println(p)
+ assert p == {x:1.0, y:2.23}
+
diff --git a/tests/valid/Define_Valid_3.sysout b/tests/valid/Define_Valid_3.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/Define_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Define_Valid_3.whiley b/tests/valid/Define_Valid_3.whiley
index 07351f85c3..60cc893cb0 100644
--- a/tests/valid/Define_Valid_3.whiley
+++ b/tests/valid/Define_Valid_3.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
type odd is (int x) where x in {1, 3, 5}
-method main(System.Console sys) -> void:
+public export method test() -> void:
odd y = 1
- sys.out.println(y)
+ assert y == 1
diff --git a/tests/valid/Define_Valid_4.sysout b/tests/valid/Define_Valid_4.sysout
deleted file mode 100755
index 86239c73f3..0000000000
--- a/tests/valid/Define_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{op:1,payload:[]}
diff --git a/tests/valid/Define_Valid_4.whiley b/tests/valid/Define_Valid_4.whiley
index 4c5ce3c32a..3451b4e6ad 100644
--- a/tests/valid/Define_Valid_4.whiley
+++ b/tests/valid/Define_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type codeOp is (int x) where x in {1, 2, 3, 4}
@@ -8,5 +8,5 @@ function f(codeOp x) -> code:
code y = {op: x, payload: []}
return y
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f(1) == {op:1, payload: []}
diff --git a/tests/valid/Dictionary_Valid_1.sysout b/tests/valid/Dictionary_Valid_1.sysout
deleted file mode 100755
index 4e31322ddd..0000000000
--- a/tests/valid/Dictionary_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1=>1, 3=>2}
diff --git a/tests/valid/Dictionary_Valid_1.whiley b/tests/valid/Dictionary_Valid_1.whiley
index 5ac0f1f459..db290d4ffc 100644
--- a/tests/valid/Dictionary_Valid_1.whiley
+++ b/tests/valid/Dictionary_Valid_1.whiley
@@ -1,6 +1,6 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
int x = 1
{int=>int} map = {1=>x, 3=>2}
- sys.out.println(map)
+ assert map == {1=>1,3=>2}
diff --git a/tests/valid/Dictionary_Valid_10.sysout b/tests/valid/Dictionary_Valid_10.sysout
deleted file mode 100644
index 6057111632..0000000000
--- a/tests/valid/Dictionary_Valid_10.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-Dictionary: {1=>2, 2=>3}
-Length: 2
-Dictionary: {1=>2, 2=>3, 3=>123}
-Length: 3
diff --git a/tests/valid/Dictionary_Valid_10.whiley b/tests/valid/Dictionary_Valid_10.whiley
index 1200cbc53c..59e9c4fd43 100644
--- a/tests/valid/Dictionary_Valid_10.whiley
+++ b/tests/valid/Dictionary_Valid_10.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
-public method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int=>int} l = {1=>2, 2=>3}
- sys.out.println_s("Dictionary: " ++ Any.toString(l))
- sys.out.println_s("Length: " ++ Any.toString(|l|))
+ assume l == {1=>2,2=>3}
+ assume |l| == 2
l[3] = 123
- sys.out.println_s("Dictionary: " ++ Any.toString(l))
- sys.out.println_s("Length: " ++ Any.toString(|l|))
+ assume l == {1=>2,2=>3,3=>123}
+ assume |l| == 3
diff --git a/tests/valid/Dictionary_Valid_11.sysout b/tests/valid/Dictionary_Valid_11.sysout
deleted file mode 100644
index 02aad238a7..0000000000
--- a/tests/valid/Dictionary_Valid_11.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-Dictionary={1=>2, 2=>3}
-Dictionary={1.0=>1.5, 2.0=>2.5}
diff --git a/tests/valid/Dictionary_Valid_11.whiley b/tests/valid/Dictionary_Valid_11.whiley
index 3fe4b54c5a..9eb22ce38c 100644
--- a/tests/valid/Dictionary_Valid_11.whiley
+++ b/tests/valid/Dictionary_Valid_11.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type edict is {int=>int} | {real=>real}
@@ -8,8 +8,9 @@ function f(int x) -> edict:
else:
return {1.0=>1.5, 2.0=>2.5}
-public method main(System.Console sys) -> void:
+public export method test() -> void:
edict d = f(-1)
- sys.out.println_s("Dictionary=" ++ Any.toString(d))
+ assume d == {1=>2, 2=>3}
d = f(2)
- sys.out.println_s("Dictionary=" ++ Any.toString(d))
+ assume d == {1.0=>1.5, 2.0=>2.5}
+
diff --git a/tests/valid/Dictionary_Valid_12.sysout b/tests/valid/Dictionary_Valid_12.sysout
deleted file mode 100644
index 02aad238a7..0000000000
--- a/tests/valid/Dictionary_Valid_12.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-Dictionary={1=>2, 2=>3}
-Dictionary={1.0=>1.5, 2.0=>2.5}
diff --git a/tests/valid/Dictionary_Valid_12.whiley b/tests/valid/Dictionary_Valid_12.whiley
index 5de1a6accd..26ed76895b 100644
--- a/tests/valid/Dictionary_Valid_12.whiley
+++ b/tests/valid/Dictionary_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type edict is {int=>int} | {real=>real}
type odict is {int|real=>int|real}
@@ -12,8 +12,8 @@ function f(int x) -> edict:
function g(int x) -> odict:
return (odict) f(x)
-public method main(System.Console sys) -> void:
+public export method test() -> void:
odict d = g(-1)
- sys.out.println_s("Dictionary=" ++ Any.toString(d))
+ assume d == {1=>2, 2=>3}
d = g(2)
- sys.out.println_s("Dictionary=" ++ Any.toString(d))
+ assume d == {1.0=>1.5, 2.0=>2.5}
diff --git a/tests/valid/Dictionary_Valid_13.sysout b/tests/valid/Dictionary_Valid_13.sysout
deleted file mode 100644
index efefaa4ebe..0000000000
--- a/tests/valid/Dictionary_Valid_13.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-Dictionary=2
-Dictionary=1.5
diff --git a/tests/valid/Dictionary_Valid_13.whiley b/tests/valid/Dictionary_Valid_13.whiley
index 92d5b646a0..98b10f0cf1 100644
--- a/tests/valid/Dictionary_Valid_13.whiley
+++ b/tests/valid/Dictionary_Valid_13.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type edict is {int=>int} | {real=>real}
@@ -8,8 +8,8 @@ function f(int x) -> edict:
else:
return {1.0=>1.5, 2.0=>2.5}
-public method main(System.Console sys) -> void:
+public export method test() -> void:
edict d = f(-1)
- sys.out.println_s("Dictionary=" ++ Any.toString(d[1]))
+ assume d == {1=>2, 2=>3}
d = f(2)
- sys.out.println_s("Dictionary=" ++ Any.toString(d[1.0]))
+ assume d == {1.0=>1.5, 2.0=>2.5}
diff --git a/tests/valid/Dictionary_Valid_14.sysout b/tests/valid/Dictionary_Valid_14.sysout
deleted file mode 100644
index 89938a8c26..0000000000
--- a/tests/valid/Dictionary_Valid_14.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-Dictionary=2
-Dictionary=2
diff --git a/tests/valid/Dictionary_Valid_14.whiley b/tests/valid/Dictionary_Valid_14.whiley
index 07f0ea72cd..3b24ee25d6 100644
--- a/tests/valid/Dictionary_Valid_14.whiley
+++ b/tests/valid/Dictionary_Valid_14.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type edict is {int=>int} | {real=>real}
@@ -8,8 +8,7 @@ function f(int x) -> edict:
else:
return {1.0=>1.5, 2.0=>2.5}
-public method main(System.Console sys) -> void:
+public export method test() -> void:
edict d = f(-1)
- sys.out.println_s("Dictionary=" ++ Any.toString(|d|))
- d = f(2)
- sys.out.println_s("Dictionary=" ++ Any.toString(|d|))
+ assume |d| == 2
+ assume |f(2)| == 2
diff --git a/tests/valid/Dictionary_Valid_15.sysout b/tests/valid/Dictionary_Valid_15.sysout
deleted file mode 100644
index 749ed2be1d..0000000000
--- a/tests/valid/Dictionary_Valid_15.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-Dictionary={1.0=>2.0, 2.0=>3.0, 3.0=>4.0}
-Dictionary={1.0=>1.5, 2.0=>2.5, 3.0=>4.0}
diff --git a/tests/valid/Dictionary_Valid_15.whiley b/tests/valid/Dictionary_Valid_15.whiley
index 41a85e8737..f91b86005d 100644
--- a/tests/valid/Dictionary_Valid_15.whiley
+++ b/tests/valid/Dictionary_Valid_15.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type edict is {int=>int} | {real=>real}
@@ -8,10 +8,10 @@ function f(int x) -> {real=>real}:
else:
return {1.0=>1.5, 2.0=>2.5}
-public method main(System.Console sys) -> void:
+public export method test() -> void:
{real=>real} d = ({real=>real}) f(-1)
d[3.0] = 4.0
- sys.out.println_s("Dictionary=" ++ Any.toString(d))
+ assume d == {1.0=>2.0, 2.0=>3.0, 3.0=>4.0}
d = f(2)
d[3.0] = 4.0
- sys.out.println_s("Dictionary=" ++ Any.toString(d))
+ assume d == {1.0=>1.5, 2.0=>2.5, 3.0=>4.0}
diff --git a/tests/valid/Dictionary_Valid_16.sysout b/tests/valid/Dictionary_Valid_16.sysout
deleted file mode 100755
index 649e30244e..0000000000
--- a/tests/valid/Dictionary_Valid_16.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{1=>1, 3=>2}
-{1=>2, 3=>2}
-{1=>3, 3=>2}
diff --git a/tests/valid/Dictionary_Valid_16.whiley b/tests/valid/Dictionary_Valid_16.whiley
index 52acd712a6..368c2ad187 100644
--- a/tests/valid/Dictionary_Valid_16.whiley
+++ b/tests/valid/Dictionary_Valid_16.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
function f(int x) -> {int=>int}:
return {1=>x, 3=>2}
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(3))
+public export method test() -> void:
+ assume f(1) == {1=>1, 3=>2}
+ assume f(2) == {1=>2, 3=>2}
+ assume f(3) == {1=>3, 3=>2}
diff --git a/tests/valid/Dictionary_Valid_2.sysout b/tests/valid/Dictionary_Valid_2.sysout
deleted file mode 100755
index b6ae13e5b4..0000000000
--- a/tests/valid/Dictionary_Valid_2.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-1
-2
-3
-2
diff --git a/tests/valid/Dictionary_Valid_2.whiley b/tests/valid/Dictionary_Valid_2.whiley
index 42e94ef783..b8aadcc18b 100644
--- a/tests/valid/Dictionary_Valid_2.whiley
+++ b/tests/valid/Dictionary_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> {int=>int}:
return {1=>x, 3=>2}
@@ -6,8 +6,8 @@ function f(int x) -> {int=>int}:
function get(int i, {int=>int} map) -> int:
return map[i]
-method main(System.Console sys) -> void:
- sys.out.println(get(1, f(1)))
- sys.out.println(get(1, f(2)))
- sys.out.println(get(1, f(3)))
- sys.out.println(get(3, f(3)))
+public export method test() -> void:
+ assume get(1, f(1)) == 1
+ assume get(1, f(2)) == 2
+ assume get(1, f(3)) == 3
+ assume get(3, f(3)) == 2
diff --git a/tests/valid/Dictionary_Valid_3.sysout b/tests/valid/Dictionary_Valid_3.sysout
deleted file mode 100755
index 2548f32a3e..0000000000
--- a/tests/valid/Dictionary_Valid_3.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-1
-4
-23498
-3
-2
diff --git a/tests/valid/Dictionary_Valid_3.whiley b/tests/valid/Dictionary_Valid_3.whiley
index 66568e9fb0..dfaf428b28 100644
--- a/tests/valid/Dictionary_Valid_3.whiley
+++ b/tests/valid/Dictionary_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> {int=>int}:
return {1=>x, 3=>2}
@@ -6,14 +6,14 @@ function f(int x) -> {int=>int}:
function get(int i, {int=>int} map) -> int:
return map[i]
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int=>int} m1 = f(1)
{int=>int} m2 = f(2)
{int=>int} m3 = f(3)
m1[2] = 4
m2[1] = 23498
- sys.out.println(get(1, m1))
- sys.out.println(get(2, m1))
- sys.out.println(get(1, m2))
- sys.out.println(get(1, m3))
- sys.out.println(get(3, m3))
+ assume get(1, m1) == 1
+ assume get(2, m1) == 4
+ assume get(1, m2) == 23498
+ assume get(1, m3) == 3
+ assume get(3, m3) == 2
diff --git a/tests/valid/Dictionary_Valid_4.sysout b/tests/valid/Dictionary_Valid_4.sysout
deleted file mode 100644
index 616064d7fa..0000000000
--- a/tests/valid/Dictionary_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{0=>[1.234, 2.0, 3.0], 1=>[3.4]}
diff --git a/tests/valid/Dictionary_Valid_4.whiley b/tests/valid/Dictionary_Valid_4.whiley
index 20d5ecd9bf..0306ae60e6 100644
--- a/tests/valid/Dictionary_Valid_4.whiley
+++ b/tests/valid/Dictionary_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type DL is {int=>[real]}
@@ -8,7 +8,7 @@ requires |ls[0]| > 0:
ls[0][0] = 1.234
return ls
-method main(System.Console sys) -> void:
+public export method test() -> void:
DL x = {0=>[1.0, 2.0, 3.0], 1=>[3.4]}
x = update(x)
- sys.out.println(x)
+ assume x == {0=>[1.234, 2.0, 3.0], 1=>[3.4]}
diff --git a/tests/valid/Dictionary_Valid_5.sysout b/tests/valid/Dictionary_Valid_5.sysout
deleted file mode 100644
index d72f779b8a..0000000000
--- a/tests/valid/Dictionary_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{97=>0, 98=>1, 99=>2, 100=>3, 101=>4, 102=>5, 103=>6, 104=>7, 105=>8, 106=>9, 107=>10, 108=>11, 109=>12, 110=>13, 111=>14, 112=>15, 113=>16, 114=>17, 115=>18, 116=>19, 117=>20, 118=>21, 119=>22, 120=>23, 121=>24, 122=>25}
diff --git a/tests/valid/Dictionary_Valid_5.whiley b/tests/valid/Dictionary_Valid_5.whiley
index 71119c870a..4867b2f8bc 100644
--- a/tests/valid/Dictionary_Valid_5.whiley
+++ b/tests/valid/Dictionary_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function reverse([int] input) -> {int=>int}:
{int=>int} rs = {=>}
@@ -7,6 +7,7 @@ function reverse([int] input) -> {int=>int}:
rs[c] = i
return rs
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int=>int} xs = reverse("abcdefghijklmnopqrstuvwxyz")
- sys.out.println(xs)
+ assume xs == {97=>0, 98=>1, 99=>2, 100=>3, 101=>4, 102=>5, 103=>6, 104=>7, 105=>8, 106=>9, 107=>10, 108=>11, 109=>12, 110=>13, 111=>14, 112=>15, 113=>16, 114=>17, 115=>18, 116=>19, 117=>20, 118=>21, 119=>22, 120=>23, 121=>24, 122=>25}
+
diff --git a/tests/valid/Dictionary_Valid_6.sysout b/tests/valid/Dictionary_Valid_6.sysout
deleted file mode 100644
index d00491fd7e..0000000000
--- a/tests/valid/Dictionary_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Dictionary_Valid_6.whiley b/tests/valid/Dictionary_Valid_6.whiley
index 2d44c37a0e..c8d7c1ad17 100644
--- a/tests/valid/Dictionary_Valid_6.whiley
+++ b/tests/valid/Dictionary_Valid_6.whiley
@@ -1,11 +1,8 @@
-import whiley.lang.*
+
function get({[int]=>int} env) -> int:
return env["x"]
-method main(System.Console sys) -> void:
- if |sys.args| == 10:
- sys.out.println_s("GOT HERE")
- else:
- int env = get({"x"=>1, "y"=>2})
- sys.out.println(env)
+public export method test() -> void:
+ assume get({"x"=>1, "y"=>2}) == 1
+
diff --git a/tests/valid/Dictionary_Valid_7.sysout b/tests/valid/Dictionary_Valid_7.sysout
deleted file mode 100644
index 5515ed59d0..0000000000
--- a/tests/valid/Dictionary_Valid_7.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{0=>1.234, 1=>2.0}
diff --git a/tests/valid/Dictionary_Valid_7.whiley b/tests/valid/Dictionary_Valid_7.whiley
index 9caf04b2d9..ee89a49fce 100644
--- a/tests/valid/Dictionary_Valid_7.whiley
+++ b/tests/valid/Dictionary_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type DL1 is {int=>int}
@@ -9,7 +9,8 @@ function update(DL1 ls) -> DL2:
rs[0] = 1.234
return (DL2) rs
-method main(System.Console sys) -> void:
+public export method test() -> void:
DL1 x = {0=>1, 1=>2}
DL2 y = update(x)
- sys.out.println(y)
+ assume y == {0=>1.234, 1=>2.0}
+
diff --git a/tests/valid/Dictionary_Valid_8.sysout b/tests/valid/Dictionary_Valid_8.sysout
deleted file mode 100644
index d4d29b1003..0000000000
--- a/tests/valid/Dictionary_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{0.0=>1, 1.0=>2, 1.2=>1}
diff --git a/tests/valid/Dictionary_Valid_8.whiley b/tests/valid/Dictionary_Valid_8.whiley
index 7f53cb6681..1827f99085 100644
--- a/tests/valid/Dictionary_Valid_8.whiley
+++ b/tests/valid/Dictionary_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type DL1 is {int=>int}
@@ -9,7 +9,7 @@ function update(DL1 ls) -> DL2:
rs[1.2] = 1
return (DL2) rs
-method main(System.Console sys) -> void:
+public export method test() -> void:
DL1 x = {0=>1, 1=>2}
DL2 y = update(x)
- sys.out.println(y)
+ assume y == {0.0=>1, 1.0=>2, 1.2=>1}
diff --git a/tests/valid/Dictionary_Valid_9.sysout b/tests/valid/Dictionary_Valid_9.sysout
deleted file mode 100644
index 242957ea8e..0000000000
--- a/tests/valid/Dictionary_Valid_9.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{0=>1, 1=>2, 1.2=>1}
\ No newline at end of file
diff --git a/tests/valid/Dictionary_Valid_9.whiley b/tests/valid/Dictionary_Valid_9.whiley
index fb7fc1319f..ebef85b9c7 100644
--- a/tests/valid/Dictionary_Valid_9.whiley
+++ b/tests/valid/Dictionary_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type DL1 is {int=>int}
@@ -9,7 +9,7 @@ function update(DL1 ls) -> DL2:
rs[1.2] = 1
return rs
-method main(System.Console sys) -> void:
+public export method test() -> void:
DL1 x = {0=>1, 1=>2}
DL2 y = update(x)
- sys.out.println(y)
+ assume y == {0=>1, 1=>2, 1.2=>1}
diff --git a/tests/valid/DoWhile_Valid_1.sysout b/tests/valid/DoWhile_Valid_1.sysout
deleted file mode 100644
index 00d731a7a8..0000000000
--- a/tests/valid/DoWhile_Valid_1.sysout
+++ /dev/null
@@ -1,8 +0,0 @@
-2
-3
-2
-2
-3
-4
-5
-6
diff --git a/tests/valid/DoWhile_Valid_1.whiley b/tests/valid/DoWhile_Valid_1.whiley
index ad20204008..44a0ad0ee6 100644
--- a/tests/valid/DoWhile_Valid_1.whiley
+++ b/tests/valid/DoWhile_Valid_1.whiley
@@ -1,15 +1,18 @@
-import whiley.lang.*
-method f(System.Console sys, [int] args) -> void
+
+method f([int] args) -> int
requires |args| >= 2:
//
+ int r = 0
int i = 0
do:
+ r = r + args[i]
i = i + 1
- sys.out.println(args[i])
while (i + 1) < |args| where i >= 0
+ //
+ return r
-method main(System.Console sys) -> void:
- f(sys, [1, 2, 3])
- f(sys, [1, 2])
- f(sys, [1, 2, 3, 4, 5, 6])
+public export method test() -> void:
+ assume f([1, 2, 3]) == 3
+ assume f([1, 2]) == 1
+ assume f([1, 2, 3, 4, 5, 6]) == 15
diff --git a/tests/valid/DoWhile_Valid_2.sysout b/tests/valid/DoWhile_Valid_2.sysout
deleted file mode 100644
index 0cfbf08886..0000000000
--- a/tests/valid/DoWhile_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/DoWhile_Valid_2.whiley b/tests/valid/DoWhile_Valid_2.whiley
index 1be62f5765..aceb7e4f19 100644
--- a/tests/valid/DoWhile_Valid_2.whiley
+++ b/tests/valid/DoWhile_Valid_2.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
-import whiley.lang.*
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+
+
+public export method test() -> void:
int i = 0
do:
if i == 2:
break
i = i + 1
while i < 5
- sys.out.println(i)
+ assume i == 2
diff --git a/tests/valid/DoWhile_Valid_3.sysout b/tests/valid/DoWhile_Valid_3.sysout
deleted file mode 100644
index 0cfbf08886..0000000000
--- a/tests/valid/DoWhile_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/DoWhile_Valid_3.whiley b/tests/valid/DoWhile_Valid_3.whiley
index 1be62f5765..aceb7e4f19 100644
--- a/tests/valid/DoWhile_Valid_3.whiley
+++ b/tests/valid/DoWhile_Valid_3.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
-import whiley.lang.*
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+
+
+public export method test() -> void:
int i = 0
do:
if i == 2:
break
i = i + 1
while i < 5
- sys.out.println(i)
+ assume i == 2
diff --git a/tests/valid/DoWhile_Valid_4.sysout b/tests/valid/DoWhile_Valid_4.sysout
deleted file mode 100644
index 1c98d6c44b..0000000000
--- a/tests/valid/DoWhile_Valid_4.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-DISTANCE: 125
-DISTANCE: 127
diff --git a/tests/valid/DoWhile_Valid_4.whiley b/tests/valid/DoWhile_Valid_4.whiley
index f64ed7cd25..5e25e5bc1e 100644
--- a/tests/valid/DoWhile_Valid_4.whiley
+++ b/tests/valid/DoWhile_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Leaf is int
@@ -16,11 +16,11 @@ function dist(Link list) -> Leaf:
//
return iter + distance
-method main(System.Console sys) -> void:
+public export method test() -> void:
LinkedList list = 123
list = {next: list}
list = {next: list}
- sys.out.println_s("DISTANCE: " ++ Any.toString(dist(list)))
+ assume dist(list) == 125
list = {next: list}
list = {next: list}
- sys.out.println_s("DISTANCE: " ++ Any.toString(dist(list)))
+ assume dist(list) == 127
diff --git a/tests/valid/DoWhile_Valid_5.sysout b/tests/valid/DoWhile_Valid_5.sysout
deleted file mode 100644
index 58c3aee7ba..0000000000
--- a/tests/valid/DoWhile_Valid_5.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-3
-6
diff --git a/tests/valid/DoWhile_Valid_5.whiley b/tests/valid/DoWhile_Valid_5.whiley
index 58372f7988..5e2e2ea758 100644
--- a/tests/valid/DoWhile_Valid_5.whiley
+++ b/tests/valid/DoWhile_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
function sum([int] xs) -> int
requires |xs| > 0:
@@ -12,8 +12,8 @@ requires |xs| > 0:
//
return r
-method main(System.Console sys) -> void:
- sys.out.println(sum([1]))
- sys.out.println(sum([1, 2]))
- sys.out.println(sum([1, 2, 3]))
+public export method test() -> void:
+ assume sum([1]) == 1
+ assume sum([1, 2]) == 3
+ assume sum([1, 2, 3]) == 6
diff --git a/tests/valid/DoWhile_Valid_6.sysout b/tests/valid/DoWhile_Valid_6.sysout
deleted file mode 100644
index cac10f6c34..0000000000
--- a/tests/valid/DoWhile_Valid_6.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-8
-7
-6
-5
-4
diff --git a/tests/valid/DoWhile_Valid_6.whiley b/tests/valid/DoWhile_Valid_6.whiley
index d4b5b11362..bce196062f 100644
--- a/tests/valid/DoWhile_Valid_6.whiley
+++ b/tests/valid/DoWhile_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
function lastIndexOf([int] items, int item) -> (int r)
requires |items| > 0
@@ -12,9 +12,9 @@ ensures r == -1 || items[r] == item:
//
return i
-method main(System.Console c):
- c.out.println(lastIndexOf([1,2,3,4,5,4,3,2,1],1))
- c.out.println(lastIndexOf([1,2,3,4,5,4,3,2,1],2))
- c.out.println(lastIndexOf([1,2,3,4,5,4,3,2,1],3))
- c.out.println(lastIndexOf([1,2,3,4,5,4,3,2,1],4))
- c.out.println(lastIndexOf([1,2,3,4,5,4,3,2,1],5))
+public export method test():
+ assume lastIndexOf([1,2,3,4,5,4,3,2,1],1) == 8
+ assume lastIndexOf([1,2,3,4,5,4,3,2,1],2) == 7
+ assume lastIndexOf([1,2,3,4,5,4,3,2,1],3) == 6
+ assume lastIndexOf([1,2,3,4,5,4,3,2,1],4) == 5
+ assume lastIndexOf([1,2,3,4,5,4,3,2,1],5) == 4
diff --git a/tests/valid/EffectiveList_Valid_1.sysout b/tests/valid/EffectiveList_Valid_1.sysout
deleted file mode 100644
index cd15f0300c..0000000000
--- a/tests/valid/EffectiveList_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[]
-[null, null, null, null]
diff --git a/tests/valid/EffectiveList_Valid_1.whiley b/tests/valid/EffectiveList_Valid_1.whiley
index c28701a6b0..be98875a1b 100644
--- a/tests/valid/EffectiveList_Valid_1.whiley
+++ b/tests/valid/EffectiveList_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type rec is {int y, int x}
@@ -11,8 +11,8 @@ function f([int] xs) -> [bool | null]:
r = r ++ [null]
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] e = []
- sys.out.println(f(e))
+ assume f(e) == []
e = [1, 2, 3, 4]
- sys.out.println(f(e))
+ assume f(e) == [null,null,null,null]
diff --git a/tests/valid/Ensures_Valid_1.sysout b/tests/valid/Ensures_Valid_1.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/Ensures_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Ensures_Valid_1.whiley b/tests/valid/Ensures_Valid_1.whiley
index a6d65237f2..1cdb46cbae 100644
--- a/tests/valid/Ensures_Valid_1.whiley
+++ b/tests/valid/Ensures_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function add(int x, int y) -> (int r)
requires x >= 0 && y >= 0
@@ -9,5 +9,6 @@ ensures r > 0:
else:
return x + y
-method main(System.Console sys) -> void:
- sys.out.println(1)
+public export method test() -> void:
+ assume add(1,2) == 3
+ assume add(1,1) == 1
diff --git a/tests/valid/Ensures_Valid_2.sysout b/tests/valid/Ensures_Valid_2.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/Ensures_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/Ensures_Valid_2.whiley b/tests/valid/Ensures_Valid_2.whiley
index 3c16ed0b55..84e7313111 100644
--- a/tests/valid/Ensures_Valid_2.whiley
+++ b/tests/valid/Ensures_Valid_2.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
function f(int x) -> (int y)
ensures y > x:
x = x + 1
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = f(1)
- sys.out.println(y)
+ assume y == 2
diff --git a/tests/valid/Ensures_Valid_3.sysout b/tests/valid/Ensures_Valid_3.sysout
deleted file mode 100755
index f00580c406..0000000000
--- a/tests/valid/Ensures_Valid_3.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3
-1
diff --git a/tests/valid/Ensures_Valid_3.whiley b/tests/valid/Ensures_Valid_3.whiley
index db93b1202a..fb543a855e 100644
--- a/tests/valid/Ensures_Valid_3.whiley
+++ b/tests/valid/Ensures_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function pred({int} xs) -> (bool b)
ensures b ==> no { z in xs | z < 0 }:
@@ -17,8 +17,8 @@ requires pred(xs):
tmp = tmp + {x}
return |tmp|
-method main(System.Console sys) -> void:
+public export method test() -> void:
int c1 = countOver({1, 2, 3, 4}, 1)
int c2 = countOver({1, 2, 3, 4}, 3)
- sys.out.println(c1)
- sys.out.println(c2)
+ assume c1 == 3
+ assume c2 == 1
diff --git a/tests/valid/Ensures_Valid_4.sysout b/tests/valid/Ensures_Valid_4.sysout
deleted file mode 100755
index f599e28b8a..0000000000
--- a/tests/valid/Ensures_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-10
diff --git a/tests/valid/Ensures_Valid_4.whiley b/tests/valid/Ensures_Valid_4.whiley
index d87d4e457f..c32576520d 100644
--- a/tests/valid/Ensures_Valid_4.whiley
+++ b/tests/valid/Ensures_Valid_4.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
function f(int x) -> (int r)
requires x >= 0
ensures r >= 0 && x >= 0:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f(10))
+public export method test() -> void:
+ assume f(10) == 10
diff --git a/tests/valid/Ensures_Valid_5.sysout b/tests/valid/Ensures_Valid_5.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/Ensures_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/Ensures_Valid_5.whiley b/tests/valid/Ensures_Valid_5.whiley
index 9b1053fcda..d5e102f0fd 100644
--- a/tests/valid/Ensures_Valid_5.whiley
+++ b/tests/valid/Ensures_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> (int r)
ensures r > x:
@@ -6,6 +6,5 @@ ensures r > x:
x = x + 1
return x
-method main(System.Console sys) -> void:
- int y = f(1)
- sys.out.println(y)
+public export method test() -> void:
+ assume f(1) == 2
diff --git a/tests/valid/Ensures_Valid_6.sysout b/tests/valid/Ensures_Valid_6.sysout
deleted file mode 100644
index 8736e77371..0000000000
--- a/tests/valid/Ensures_Valid_6.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-abs(1) = 1
-abs(-1) = null
diff --git a/tests/valid/Ensures_Valid_6.whiley b/tests/valid/Ensures_Valid_6.whiley
index ce48328361..ff1baef3c1 100644
--- a/tests/valid/Ensures_Valid_6.whiley
+++ b/tests/valid/Ensures_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -11,6 +11,6 @@ ensures r is int ==> r >= 0:
else:
return null
-method main(System.Console console):
- console.out.println_s("abs(1) = " ++ Any.toString(abs(1)))
- console.out.println_s("abs(-1) = " ++ Any.toString(abs(-1)))
+public export method test():
+ assume abs(1) == 1
+ assume abs(-1) == null
diff --git a/tests/valid/Ensures_Valid_7.sysout b/tests/valid/Ensures_Valid_7.sysout
deleted file mode 100644
index b00be56bda..0000000000
--- a/tests/valid/Ensures_Valid_7.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-abs(1) = 1
-abs(-1) = 1
-abs(null) = 0
diff --git a/tests/valid/Ensures_Valid_7.whiley b/tests/valid/Ensures_Valid_7.whiley
index b6ef8fe6bb..62218be5a5 100644
--- a/tests/valid/Ensures_Valid_7.whiley
+++ b/tests/valid/Ensures_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function abs(int|null x) -> (int r)
// if we return an int, it cannot be negative
@@ -15,7 +15,7 @@ ensures r >= 0:
return 0
-method main(System.Console console):
- console.out.println_s("abs(1) = " ++ Any.toString(abs(1)))
- console.out.println_s("abs(-1) = " ++ Any.toString(abs(-1)))
- console.out.println_s("abs(null) = " ++ Any.toString(abs(null)))
+public export method test():
+ assume abs(1) == 1
+ assume abs(-1) == 1
+ assume abs(null) == 0
diff --git a/tests/valid/Ensures_Valid_8.sysout b/tests/valid/Ensures_Valid_8.sysout
deleted file mode 100644
index 0833f0ec12..0000000000
--- a/tests/valid/Ensures_Valid_8.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-abs(1) = 1
-abs(-1) = 1
diff --git a/tests/valid/Ensures_Valid_8.whiley b/tests/valid/Ensures_Valid_8.whiley
index e88062c2dd..7d937c4577 100644
--- a/tests/valid/Ensures_Valid_8.whiley
+++ b/tests/valid/Ensures_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function abs(int x) -> (int r)
ensures r >= 0:
@@ -8,6 +8,6 @@ ensures r >= 0:
//
return x
-method main(System.Console console):
- console.out.println_s("abs(1) = " ++ Any.toString(abs(1)))
- console.out.println_s("abs(-1) = " ++ Any.toString(abs(-1)))
+public export method test():
+ assume abs(1) == 1
+ assume abs(-1) == 1
diff --git a/tests/valid/For_Valid_1.sysout b/tests/valid/For_Valid_1.sysout
deleted file mode 100755
index 01e79c32a8..0000000000
--- a/tests/valid/For_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-2
-3
diff --git a/tests/valid/For_Valid_1.whiley b/tests/valid/For_Valid_1.whiley
index 6ee77a8475..fa5c9a5080 100644
--- a/tests/valid/For_Valid_1.whiley
+++ b/tests/valid/For_Valid_1.whiley
@@ -1,6 +1,6 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] xs = [1, 2, 3]
for st in xs:
- sys.out.println(st)
+ assume st >= 0
diff --git a/tests/valid/For_Valid_10.sysout b/tests/valid/For_Valid_10.sysout
deleted file mode 100644
index e567c91575..0000000000
--- a/tests/valid/For_Valid_10.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-15
-150
diff --git a/tests/valid/For_Valid_10.whiley b/tests/valid/For_Valid_10.whiley
index b3ac994513..e9fba23f7e 100644
--- a/tests/valid/For_Valid_10.whiley
+++ b/tests/valid/For_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type listset is [int] | {int}
@@ -8,8 +8,8 @@ function f(listset ls) -> int:
r = r + l
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] ls = [1, 2, 3, 4, 5]
- sys.out.println(f(ls))
+ assume f(ls) == 15
{int} ss = {10, 20, 30, 40, 50}
- sys.out.println(f(ss))
+ assume f(ss) == 150
diff --git a/tests/valid/For_Valid_11.sysout b/tests/valid/For_Valid_11.sysout
deleted file mode 100644
index 47586a86a3..0000000000
--- a/tests/valid/For_Valid_11.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-5
-2
diff --git a/tests/valid/For_Valid_11.whiley b/tests/valid/For_Valid_11.whiley
index 2637da942b..eee24e6408 100644
--- a/tests/valid/For_Valid_11.whiley
+++ b/tests/valid/For_Valid_11.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type listdict is [int] | {int=>int}
@@ -8,8 +8,8 @@ function f(listdict ls) -> int:
r = r + 1
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] ls = [1, 2, 3, 4, 5]
- sys.out.println(f(ls))
+ assume f(ls) == 5
{int=>int} ms = {10=>20, 30=>40}
- sys.out.println(f(ms))
+ assume f(ms) == 2
diff --git a/tests/valid/For_Valid_12.sysout b/tests/valid/For_Valid_12.sysout
deleted file mode 100644
index 47586a86a3..0000000000
--- a/tests/valid/For_Valid_12.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-5
-2
diff --git a/tests/valid/For_Valid_12.whiley b/tests/valid/For_Valid_12.whiley
index 035f22f624..375e2fc4b7 100644
--- a/tests/valid/For_Valid_12.whiley
+++ b/tests/valid/For_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type setdict is {int} | {int=>int}
@@ -8,8 +8,8 @@ function f(setdict ls) -> int:
r = r + 1
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ls = {1, 2, 3, 4, 5}
- sys.out.println(f(ls))
+ assume f(ls) == 5
{int=>int} ms = {10=>20, 30=>40}
- sys.out.println(f(ms))
+ assume f(ms) == 2
diff --git a/tests/valid/For_Valid_13.sysout b/tests/valid/For_Valid_13.sysout
deleted file mode 100644
index bf573d767b..0000000000
--- a/tests/valid/For_Valid_13.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-5
-8
-2
diff --git a/tests/valid/For_Valid_13.whiley b/tests/valid/For_Valid_13.whiley
index 6c7a63c5ec..7115c0a9d9 100644
--- a/tests/valid/For_Valid_13.whiley
+++ b/tests/valid/For_Valid_13.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type listsetdict is [int] | {int} | {int=>int}
@@ -8,10 +8,10 @@ function f(listsetdict ls) -> int:
r = r + 1
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ls = {1, 2, 3, 4, 5}
- sys.out.println(f(ls))
+ assume f(ls) == 5
[int] xs = [1, 2, 3, 4, 5, 6, 7, 8]
- sys.out.println(f(xs))
+ assume f(xs) == 8
{int=>int} ms = {10=>20, 30=>40}
- sys.out.println(f(ms))
+ assume f(ms) == 2
diff --git a/tests/valid/For_Valid_14.sysout b/tests/valid/For_Valid_14.sysout
deleted file mode 100644
index e49fddd351..0000000000
--- a/tests/valid/For_Valid_14.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-36
-1052
diff --git a/tests/valid/For_Valid_14.whiley b/tests/valid/For_Valid_14.whiley
index d5a2e48811..7c4cbdd2b8 100644
--- a/tests/valid/For_Valid_14.whiley
+++ b/tests/valid/For_Valid_14.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type list is [int]
@@ -8,8 +8,8 @@ function f(list ls) -> int:
r = r + ((int)l)
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] ls = [1, 2, 3, 4, 5, 6, 7, 8]
- sys.out.println(f(ls))
+ assume f(ls) == 36
[int] xs = "Hello World"
- sys.out.println(f(xs))
+ assume f(xs) == 1052
diff --git a/tests/valid/For_Valid_15.sysout b/tests/valid/For_Valid_15.sysout
deleted file mode 100755
index 1e8b314962..0000000000
--- a/tests/valid/For_Valid_15.sysout
+++ /dev/null
@@ -1 +0,0 @@
-6
diff --git a/tests/valid/For_Valid_15.whiley b/tests/valid/For_Valid_15.whiley
index 873e4222e1..31249385b9 100644
--- a/tests/valid/For_Valid_15.whiley
+++ b/tests/valid/For_Valid_15.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] xs = [1, 2, 3]
int r = 0
for x in xs where r >= 0:
r = r + x
- sys.out.println(r)
+ assume r == 6
diff --git a/tests/valid/For_Valid_16.sysout b/tests/valid/For_Valid_16.sysout
deleted file mode 100755
index 1e8b314962..0000000000
--- a/tests/valid/For_Valid_16.sysout
+++ /dev/null
@@ -1 +0,0 @@
-6
diff --git a/tests/valid/For_Valid_16.whiley b/tests/valid/For_Valid_16.whiley
index c3da505d9e..20e5885879 100644
--- a/tests/valid/For_Valid_16.whiley
+++ b/tests/valid/For_Valid_16.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type nat is int
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] xs = [1, 2, 3]
int r = 0
for x in xs:
r = r + x
- sys.out.println(r)
+ assume r == 6
diff --git a/tests/valid/For_Valid_17.sysout b/tests/valid/For_Valid_17.sysout
deleted file mode 100755
index 60d3b2f4a4..0000000000
--- a/tests/valid/For_Valid_17.sysout
+++ /dev/null
@@ -1 +0,0 @@
-15
diff --git a/tests/valid/For_Valid_17.whiley b/tests/valid/For_Valid_17.whiley
index 094f50e224..51049722ad 100644
--- a/tests/valid/For_Valid_17.whiley
+++ b/tests/valid/For_Valid_17.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -10,6 +10,6 @@ ensures result >= 0:
r = r + x
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
int z = sum({1, 2, 3, 4, 5})
- sys.out.println(z)
+ assume z == 15
diff --git a/tests/valid/For_Valid_18.sysout b/tests/valid/For_Valid_18.sysout
deleted file mode 100755
index 60d3b2f4a4..0000000000
--- a/tests/valid/For_Valid_18.sysout
+++ /dev/null
@@ -1 +0,0 @@
-15
diff --git a/tests/valid/For_Valid_18.whiley b/tests/valid/For_Valid_18.whiley
index 2ba45b1f70..6fab8f9a13 100644
--- a/tests/valid/For_Valid_18.whiley
+++ b/tests/valid/For_Valid_18.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int n) where 0 >= n
@@ -8,6 +8,6 @@ function sum({nat} xs) -> int:
r = r + x
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
int z = sum({1, 2, 3, 4, 5})
- sys.out.println(z)
+ assume z == 15
diff --git a/tests/valid/For_Valid_19.sysout b/tests/valid/For_Valid_19.sysout
deleted file mode 100644
index 166be640db..0000000000
--- a/tests/valid/For_Valid_19.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-6
-6
-6
diff --git a/tests/valid/For_Valid_19.whiley b/tests/valid/For_Valid_19.whiley
index 835c77ffb0..b2827d2806 100644
--- a/tests/valid/For_Valid_19.whiley
+++ b/tests/valid/For_Valid_19.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
function sum([int] items) -> (int result)
requires |items| > 0
@@ -10,7 +10,7 @@ ensures result >= 0:
r = r + x
return r
-public method main(System.Console console):
- console.out.println(sum([1,2,3]))
- console.out.println(sum([1,-1,2,3]))
- console.out.println(sum([1,-1,2,-2,3]))
+public export method test():
+ assume sum([1,2,3]) == 6
+ assume sum([1,-1,2,3]) == 6
+ assume sum([1,-1,2,-2,3]) == 6
diff --git a/tests/valid/For_Valid_2.sysout b/tests/valid/For_Valid_2.sysout
deleted file mode 100644
index 573541ac97..0000000000
--- a/tests/valid/For_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-0
diff --git a/tests/valid/For_Valid_2.whiley b/tests/valid/For_Valid_2.whiley
index adc287ec22..b4f37d504a 100644
--- a/tests/valid/For_Valid_2.whiley
+++ b/tests/valid/For_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -9,6 +9,6 @@ requires |ls| > 0:
return 0
return ls[0]
-method main(System.Console sys) -> void:
+public export method test() -> void:
nat rs = extract([-2, -3, 1, 2, -23, 3, 2345, 4, 5])
- sys.out.println(rs)
+ assume rs == 0
diff --git a/tests/valid/For_Valid_20.sysout b/tests/valid/For_Valid_20.sysout
deleted file mode 100644
index 99c7d7f151..0000000000
--- a/tests/valid/For_Valid_20.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-1
-2
-3
--1
diff --git a/tests/valid/For_Valid_20.whiley b/tests/valid/For_Valid_20.whiley
index 74e4bfd6ac..acbc663e3c 100644
--- a/tests/valid/For_Valid_20.whiley
+++ b/tests/valid/For_Valid_20.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
function find([int] items, int item) -> (int result)
ensures result == -1 || result in items:
@@ -9,8 +9,8 @@ ensures result == -1 || result in items:
return x
return -1
-public method main(System.Console console):
- console.out.println(find([1,2,3],1))
- console.out.println(find([1,2,3],2))
- console.out.println(find([1,2,3],3))
- console.out.println(find([1,2,3],4))
+public export method test():
+ assume find([1,2,3],1) == 1
+ assume find([1,2,3],2) == 2
+ assume find([1,2,3],3) == 3
+ assume find([1,2,3],4) == -1
diff --git a/tests/valid/For_Valid_3.sysout b/tests/valid/For_Valid_3.sysout
deleted file mode 100644
index 8e99078d4f..0000000000
--- a/tests/valid/For_Valid_3.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-8
-11
diff --git a/tests/valid/For_Valid_3.whiley b/tests/valid/For_Valid_3.whiley
index 8de6093cda..b0c7da8b12 100644
--- a/tests/valid/For_Valid_3.whiley
+++ b/tests/valid/For_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int=>int} dict) -> (int, int):
int k = 0
@@ -8,10 +8,10 @@ function f({int=>int} dict) -> (int, int):
v = v + y
return (k, v)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int k
int v
{int=>int} dict = {1=>2, 3=>4, 4=>5}
(k, v) = f(dict)
- sys.out.println(k)
- sys.out.println(v)
+ assume k == 8
+ assume v == 11
diff --git a/tests/valid/For_Valid_4.sysout b/tests/valid/For_Valid_4.sysout
deleted file mode 100644
index d00491fd7e..0000000000
--- a/tests/valid/For_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/For_Valid_4.whiley b/tests/valid/For_Valid_4.whiley
index 414278152f..4e9e1cd3c9 100644
--- a/tests/valid/For_Valid_4.whiley
+++ b/tests/valid/For_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type pos is (int x) where x > 0
@@ -10,6 +10,6 @@ requires |ls| > 1:
return 1
return ls[0] + ls[1]
-method main(System.Console sys) -> void:
+public export method test() -> void:
pos rs = extract([-1, -2, 0, 1, 2, 3])
- sys.out.println(rs)
+ assume rs == 1
diff --git a/tests/valid/For_Valid_5.sysout b/tests/valid/For_Valid_5.sysout
deleted file mode 100644
index c2768cdf97..0000000000
--- a/tests/valid/For_Valid_5.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3.3
--1.0
diff --git a/tests/valid/For_Valid_5.whiley b/tests/valid/For_Valid_5.whiley
index 53e7fb687c..7283811587 100644
--- a/tests/valid/For_Valid_5.whiley
+++ b/tests/valid/For_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({(int, real)} xs, int m) -> real:
for i, r in xs:
@@ -6,8 +6,8 @@ function f({(int, real)} xs, int m) -> real:
return r
return -1
-method main(System.Console sys) -> void:
+public export method test() -> void:
x = f({(1, 2.2), (5, 3.3)}, 5)
- sys.out.println(x)
+ assume x == 3.3
x = f({(1, 2.2), (5, 3.3)}, 2)
- sys.out.println(x)
+ assume x == -1.0
diff --git a/tests/valid/For_Valid_6.whiley b/tests/valid/For_Valid_6.whiley
index dca8f1251a..a5ab48cab5 100644
--- a/tests/valid/For_Valid_6.whiley
+++ b/tests/valid/For_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function select({int} xs) -> (int r)
// Input list cannot be empty
@@ -10,5 +10,5 @@ ensures r in xs:
return x
return 0
-method main(System.Console sys) -> void:
- sys.out.println(select({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))
+public export method test() -> void:
+ assume select({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == 1
diff --git a/tests/valid/For_Valid_7.sysout b/tests/valid/For_Valid_7.sysout
deleted file mode 100644
index 3480a2c70a..0000000000
--- a/tests/valid/For_Valid_7.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-55
--55
diff --git a/tests/valid/For_Valid_7.whiley b/tests/valid/For_Valid_7.whiley
index 6af5af67fc..e7251a8bb4 100644
--- a/tests/valid/For_Valid_7.whiley
+++ b/tests/valid/For_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type R1 is {int x}
@@ -14,8 +14,8 @@ function f(bool flag, [int] list) -> int:
r = r - pos
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
int r1 = f(true, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
int r2 = f(false, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
- sys.out.println(r1)
- sys.out.println(r2)
+ assume r1 == 55
+ assume r2 == -55
diff --git a/tests/valid/For_Valid_8.sysout b/tests/valid/For_Valid_8.sysout
deleted file mode 100644
index 7727cc2d11..0000000000
--- a/tests/valid/For_Valid_8.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-b1=false
-b2=true
-b3=true
diff --git a/tests/valid/For_Valid_8.whiley b/tests/valid/For_Valid_8.whiley
index 69f7bb85d6..85e2d7e71b 100644
--- a/tests/valid/For_Valid_8.whiley
+++ b/tests/valid/For_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function run(int n, int x) -> bool:
bool solution = true
@@ -8,10 +8,10 @@ function run(int n, int x) -> bool:
break
return solution
-method main(System.Console sys) -> void:
+public export method test() -> void:
bool b1 = run(10, 4)
- sys.out.println_s("b1=" ++ Any.toString(b1))
+ assume b1 == false
bool b2 = run(10, -1)
- sys.out.println_s("b2=" ++ Any.toString(b2))
+ assume b2 == true
bool b3 = run(10, 11)
- sys.out.println_s("b3=" ++ Any.toString(b3))
+ assume b3 == true
diff --git a/tests/valid/For_Valid_9.sysout b/tests/valid/For_Valid_9.sysout
deleted file mode 100644
index 7727cc2d11..0000000000
--- a/tests/valid/For_Valid_9.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-b1=false
-b2=true
-b3=true
diff --git a/tests/valid/For_Valid_9.whiley b/tests/valid/For_Valid_9.whiley
index 69f7bb85d6..85e2d7e71b 100644
--- a/tests/valid/For_Valid_9.whiley
+++ b/tests/valid/For_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function run(int n, int x) -> bool:
bool solution = true
@@ -8,10 +8,10 @@ function run(int n, int x) -> bool:
break
return solution
-method main(System.Console sys) -> void:
+public export method test() -> void:
bool b1 = run(10, 4)
- sys.out.println_s("b1=" ++ Any.toString(b1))
+ assume b1 == false
bool b2 = run(10, -1)
- sys.out.println_s("b2=" ++ Any.toString(b2))
+ assume b2 == true
bool b3 = run(10, 11)
- sys.out.println_s("b3=" ++ Any.toString(b3))
+ assume b3 == true
diff --git a/tests/valid/FunctionRef_Valid_1.sysout b/tests/valid/FunctionRef_Valid_1.sysout
deleted file mode 100644
index 65ffdd9e73..0000000000
--- a/tests/valid/FunctionRef_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1235
-2468
diff --git a/tests/valid/FunctionRef_Valid_1.whiley b/tests/valid/FunctionRef_Valid_1.whiley
index 71f9a8cc0d..815e16f697 100644
--- a/tests/valid/FunctionRef_Valid_1.whiley
+++ b/tests/valid/FunctionRef_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f1(int x) -> int:
return x + 1
@@ -11,6 +11,6 @@ type func_t is function(int) -> int
function g(func_t func) -> int:
return func(1234)
-method main(System.Console sys) -> void:
- sys.out.println(g(&f1))
- sys.out.println(g(&f2))
+public export method test() -> void:
+ assume g(&f1) == 1235
+ assume g(&f2) == 2468
diff --git a/tests/valid/FunctionRef_Valid_2.sysout b/tests/valid/FunctionRef_Valid_2.sysout
deleted file mode 100644
index 0cfbf08886..0000000000
--- a/tests/valid/FunctionRef_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/FunctionRef_Valid_2.whiley b/tests/valid/FunctionRef_Valid_2.whiley
index fa62699728..b43644c095 100644
--- a/tests/valid/FunctionRef_Valid_2.whiley
+++ b/tests/valid/FunctionRef_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(real x) -> real:
return x + 1
@@ -6,5 +6,5 @@ function f(real x) -> real:
function g(function(int)->real func) -> real:
return func(1)
-method main(System.Console sys) -> void:
- sys.out.println(g(&f))
+public export method test() -> void:
+ assume g(&f) == 2.0
diff --git a/tests/valid/FunctionRef_Valid_3.sysout b/tests/valid/FunctionRef_Valid_3.sysout
deleted file mode 100644
index 48082f72f0..0000000000
--- a/tests/valid/FunctionRef_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-12
diff --git a/tests/valid/FunctionRef_Valid_3.whiley b/tests/valid/FunctionRef_Valid_3.whiley
index ca3c55de60..f9c2983350 100644
--- a/tests/valid/FunctionRef_Valid_3.whiley
+++ b/tests/valid/FunctionRef_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
return x * 12
@@ -6,5 +6,5 @@ function f(int x) -> int:
function g(function(int)->real func) -> real:
return func(1)
-method main(System.Console sys) -> void:
- sys.out.println(g((function(int)->real) &f))
+public export method test() -> void:
+ assume g((function(int)->real) &f) == 12.0
diff --git a/tests/valid/FunctionRef_Valid_4.sysout b/tests/valid/FunctionRef_Valid_4.sysout
deleted file mode 100644
index df514ea354..0000000000
--- a/tests/valid/FunctionRef_Valid_4.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-123
--123
diff --git a/tests/valid/FunctionRef_Valid_4.whiley b/tests/valid/FunctionRef_Valid_4.whiley
index 63335d35df..de37203a75 100644
--- a/tests/valid/FunctionRef_Valid_4.whiley
+++ b/tests/valid/FunctionRef_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant table is [&f1, &f2]
@@ -14,6 +14,6 @@ function g(int d) -> int:
func y = table[d]
return y(123)
-method main(System.Console sys) -> void:
- sys.out.println(g(0))
- sys.out.println(g(1))
+public export method test() -> void:
+ assume g(0) == 123
+ assume g(1) == -123
diff --git a/tests/valid/FunctionRef_Valid_5.sysout b/tests/valid/FunctionRef_Valid_5.sysout
deleted file mode 100644
index 174d2eebfd..0000000000
--- a/tests/valid/FunctionRef_Valid_5.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-GOT: 123
-GOT: 12545
-GOT: -11
diff --git a/tests/valid/FunctionRef_Valid_5.whiley b/tests/valid/FunctionRef_Valid_5.whiley
index ed2ef16c45..3823185f60 100644
--- a/tests/valid/FunctionRef_Valid_5.whiley
+++ b/tests/valid/FunctionRef_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Func is {
function read(int)->int
@@ -10,10 +10,10 @@ function id(int x) -> int:
function test(Func f, int arg) -> int:
return f.read(arg)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = test({read: &id}, 123)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == 123
x = test({read: &id}, 12545)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == 12545
x = test({read: &id}, -11)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == -11
diff --git a/tests/valid/FunctionRef_Valid_6.sysout b/tests/valid/FunctionRef_Valid_6.sysout
deleted file mode 100644
index 174d2eebfd..0000000000
--- a/tests/valid/FunctionRef_Valid_6.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-GOT: 123
-GOT: 12545
-GOT: -11
diff --git a/tests/valid/FunctionRef_Valid_6.whiley b/tests/valid/FunctionRef_Valid_6.whiley
index f06550ee65..8cdb4621e3 100644
--- a/tests/valid/FunctionRef_Valid_6.whiley
+++ b/tests/valid/FunctionRef_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Func is {
function (int)->int read
@@ -10,10 +10,10 @@ function id(int x) -> int:
function test(Func f, int arg) -> int:
return f.read(arg)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = test({read: &id}, 123)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == 123
x = test({read: &id}, 12545)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == 12545
x = test({read: &id}, -11)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == -11
diff --git a/tests/valid/FunctionRef_Valid_7.sysout b/tests/valid/FunctionRef_Valid_7.sysout
deleted file mode 100644
index 73fc6c5a79..0000000000
--- a/tests/valid/FunctionRef_Valid_7.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-GOT: 124
-GOT: 12546
-GOT: -10
diff --git a/tests/valid/FunctionRef_Valid_7.whiley b/tests/valid/FunctionRef_Valid_7.whiley
index dffbc5ce08..870fe64d2b 100644
--- a/tests/valid/FunctionRef_Valid_7.whiley
+++ b/tests/valid/FunctionRef_Valid_7.whiley
@@ -1,18 +1,18 @@
-import whiley.lang.*
+
type Proc is &{int data}
method read(Proc this, int x) -> int:
- return x + 1
+ return x + this->data
-method test(Proc p, int arg) -> int:
+public export method test(Proc p, int arg) -> int:
return read(p,arg)
-method main(System.Console sys) -> void:
+public export method test() -> void:
Proc p = new {data: 1}
int x = test(p, 123)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == 124
x = test(p, 12545)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == 12546
x = test(p, -11)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == -10
diff --git a/tests/valid/FunctionRef_Valid_8.sysout b/tests/valid/FunctionRef_Valid_8.sysout
deleted file mode 100644
index 53c45a3d73..0000000000
--- a/tests/valid/FunctionRef_Valid_8.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-123
-223
diff --git a/tests/valid/FunctionRef_Valid_8.whiley b/tests/valid/FunctionRef_Valid_8.whiley
index 3bd49bc6d3..38f7003049 100644
--- a/tests/valid/FunctionRef_Valid_8.whiley
+++ b/tests/valid/FunctionRef_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function read(int a) -> int:
return -a
@@ -9,10 +9,10 @@ function id(int x) -> int:
function test(function (int)->int read, int arg) -> int:
return read(arg)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = test(&id, 1)
- sys.out.println(x)
+ assume x == 1
x = test(&id, 123)
- sys.out.println(x)
+ assume x == 123
x = test(&id, 223)
- sys.out.println(x)
+ assume x == 223
diff --git a/tests/valid/FunctionRef_Valid_9.sysout b/tests/valid/FunctionRef_Valid_9.sysout
deleted file mode 100644
index 174d2eebfd..0000000000
--- a/tests/valid/FunctionRef_Valid_9.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-GOT: 123
-GOT: 12545
-GOT: -11
diff --git a/tests/valid/FunctionRef_Valid_9.whiley b/tests/valid/FunctionRef_Valid_9.whiley
index 4f248c73e4..61207cb9de 100644
--- a/tests/valid/FunctionRef_Valid_9.whiley
+++ b/tests/valid/FunctionRef_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Proc is &{
function func(int) -> int
@@ -7,17 +7,17 @@ type Proc is &{
method func(Proc this, int x) -> int:
return x + 1
-method test(Proc this, int arg) -> int:
+public export method test(Proc this, int arg) -> int:
return (*this).func(arg)
function id(int x) -> int:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
Proc p = new {func: &id}
int x = test(p, 123)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == 123
x = test(p, 12545)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == 12545
x = test(p,-11)
- sys.out.println_s("GOT: " ++ Any.toString(x))
+ assume x == -11
diff --git a/tests/valid/Function_Valid_1.sysout b/tests/valid/Function_Valid_1.sysout
deleted file mode 100755
index 6bf8d1741d..0000000000
--- a/tests/valid/Function_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-2
-1
\ No newline at end of file
diff --git a/tests/valid/Function_Valid_1.whiley b/tests/valid/Function_Valid_1.whiley
index 0e7296e08e..f2398d36ab 100644
--- a/tests/valid/Function_Valid_1.whiley
+++ b/tests/valid/Function_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(real x) -> int:
return 1
@@ -6,6 +6,6 @@ function f(real x) -> int:
function f(int x) -> int:
return 2
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(1.23))
+public export method test() -> void:
+ assume f(1) == 2
+ assume f(1.23) == 1
diff --git a/tests/valid/Function_Valid_10.sysout b/tests/valid/Function_Valid_10.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/Function_Valid_10.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Function_Valid_10.whiley b/tests/valid/Function_Valid_10.whiley
index 9acbed4ac9..fbce4f6a59 100644
--- a/tests/valid/Function_Valid_10.whiley
+++ b/tests/valid/Function_Valid_10.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type fcode is (int x) where x in {1, 2, 3, 4}
function g(fcode f) -> int:
return f
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = 1
- sys.out.println(g(x))
+ assume g(x) == 1
diff --git a/tests/valid/Function_Valid_11.sysout b/tests/valid/Function_Valid_11.sysout
deleted file mode 100755
index da29283aaa..0000000000
--- a/tests/valid/Function_Valid_11.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
diff --git a/tests/valid/Function_Valid_11.whiley b/tests/valid/Function_Valid_11.whiley
index 5deaa55f78..c4d768d71d 100644
--- a/tests/valid/Function_Valid_11.whiley
+++ b/tests/valid/Function_Valid_11.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type fr8nat is (int x) where x > 0
@@ -10,6 +10,8 @@ function f(fr8nat y) -> bool:
function f(fr8neg x) -> bool:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(-1))
+public export method test() -> void:
+ fr8nat x = 1
+ assume f(x) == true
+ fr8neg y = -1
+ assume f(y) == false
diff --git a/tests/valid/Function_Valid_12.sysout b/tests/valid/Function_Valid_12.sysout
deleted file mode 100755
index 08b5a5e9d6..0000000000
--- a/tests/valid/Function_Valid_12.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[1, 2, 3]
-[1.2, 2.2, 3.3]
diff --git a/tests/valid/Function_Valid_12.whiley b/tests/valid/Function_Valid_12.whiley
index dd0c260202..5cdfcd9843 100644
--- a/tests/valid/Function_Valid_12.whiley
+++ b/tests/valid/Function_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type msg is {int op, int s}
@@ -11,6 +11,6 @@ function f([int] ls) -> [int]:
function f([real] ls) -> [real]:
return ls
-method main(System.Console sys) -> void:
- sys.out.println(f([1, 2, 3]))
- sys.out.println(f([1.2, 2.2, 3.3]))
+public export method test() -> void:
+ assume f([1, 2, 3]) == [1,2,3]
+ assume f([1.2, 2.2, 3.3]) == [1.2,2.2,3.3]
diff --git a/tests/valid/Function_Valid_13.sysout b/tests/valid/Function_Valid_13.sysout
deleted file mode 100644
index e63b08cc90..0000000000
--- a/tests/valid/Function_Valid_13.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{x:1,y:-1}
-{x:1,y:2}
diff --git a/tests/valid/Function_Valid_13.whiley b/tests/valid/Function_Valid_13.whiley
index 4ea1c8dd18..9a8c136059 100644
--- a/tests/valid/Function_Valid_13.whiley
+++ b/tests/valid/Function_Valid_13.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Point is {int y, int x} where x != y
@@ -11,8 +11,8 @@ function Point(int i, int j) -> Point:
else:
return {y: -1, x: 1}
-method main(System.Console sys) -> void:
+public export method test() -> void:
Point rs = Point(1, 1)
- sys.out.println(rs)
+ assume rs == {x:1,y:-1}
rs = Point(1, 2)
- sys.out.println(rs)
+ assume rs == {x:1,y:2}
diff --git a/tests/valid/Function_Valid_14.sysout b/tests/valid/Function_Valid_14.sysout
deleted file mode 100755
index b17865743d..0000000000
--- a/tests/valid/Function_Valid_14.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-1
-2
-3
-4
\ No newline at end of file
diff --git a/tests/valid/Function_Valid_14.whiley b/tests/valid/Function_Valid_14.whiley
index 80bb7e46e5..93095e463d 100644
--- a/tests/valid/Function_Valid_14.whiley
+++ b/tests/valid/Function_Valid_14.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
return 1
@@ -12,8 +12,8 @@ function f([int] xs) -> int:
function f({int} xs) -> int:
return 4
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(1.234))
- sys.out.println(f([1, 2, 3]))
- sys.out.println(f({1, 2, 3}))
+public export method test() -> void:
+ assume f(1) == 1
+ assume f(1.234) == 2
+ assume f([1, 2, 3]) == 3
+ assume f({1, 2, 3}) == 4
diff --git a/tests/valid/Function_Valid_15.sysout b/tests/valid/Function_Valid_15.sysout
deleted file mode 100755
index 1191247b6d..0000000000
--- a/tests/valid/Function_Valid_15.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-2
diff --git a/tests/valid/Function_Valid_15.whiley b/tests/valid/Function_Valid_15.whiley
index 5c05356cc8..72dc49806a 100644
--- a/tests/valid/Function_Valid_15.whiley
+++ b/tests/valid/Function_Valid_15.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type msg1 is {int op, int s} where op == 1
@@ -10,8 +10,8 @@ function f(msg1 m) -> int:
function f(msg2 m) -> int:
return 2
-method main(System.Console sys) -> void:
+public export method test() -> void:
msg1 m1 = {op: 1, s: 123}
msg1 m2 = {op: 2, s: 123}
- sys.out.println(f(m1))
- sys.out.println(f(m2))
+ assume f(m1) == 1
+ assume f(m2) == 2
diff --git a/tests/valid/Function_Valid_16.sysout b/tests/valid/Function_Valid_16.sysout
deleted file mode 100755
index 00750edc07..0000000000
--- a/tests/valid/Function_Valid_16.sysout
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/tests/valid/Function_Valid_16.whiley b/tests/valid/Function_Valid_16.whiley
index 207ef9a474..683dd66450 100644
--- a/tests/valid/Function_Valid_16.whiley
+++ b/tests/valid/Function_Valid_16.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> (int y)
// Return must be greater than input
@@ -10,10 +10,10 @@ function g(int x, int y) -> int
requires x > y:
return x + y
-method main(System.Console sys) -> void:
+public export method test() -> void:
int a = 2
int b = 1
- if |sys.args| == 0:
+ if a < b:
a = f(b)
int x = g(a, b)
- sys.out.println(x)
+ assume x == 3
diff --git a/tests/valid/Function_Valid_17.sysout b/tests/valid/Function_Valid_17.sysout
deleted file mode 100755
index 00750edc07..0000000000
--- a/tests/valid/Function_Valid_17.sysout
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/tests/valid/Function_Valid_17.whiley b/tests/valid/Function_Valid_17.whiley
index 7201c796b6..a7ce8ec618 100644
--- a/tests/valid/Function_Valid_17.whiley
+++ b/tests/valid/Function_Valid_17.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
return x + 1
@@ -6,10 +6,10 @@ function f(int x) -> int:
function g(int x, int y) -> int:
return x + y
-method main(System.Console sys) -> void:
+public export method test() -> void:
int a = 2
int b = 1
- if |sys.args| == 0:
+ if a < b:
a = f(b)
int x = g(a, b)
- sys.out.println(x)
+ assume x == 3
diff --git a/tests/valid/Function_Valid_18.sysout b/tests/valid/Function_Valid_18.sysout
deleted file mode 100644
index c37b4595d8..0000000000
--- a/tests/valid/Function_Valid_18.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-123
-1
diff --git a/tests/valid/Function_Valid_18.whiley b/tests/valid/Function_Valid_18.whiley
index 9ec4425e39..dc4b8fb9af 100644
--- a/tests/valid/Function_Valid_18.whiley
+++ b/tests/valid/Function_Valid_18.whiley
@@ -1,17 +1,18 @@
-import whiley.lang.*
-
type nat is (int x) where x >= 0
-function abs(int item) -> nat:
- return Math.abs(item)
+function abs(int x) -> nat:
+ if x >= 0:
+ return x
+ else:
+ return -x
function nop(nat item) -> (nat r)
ensures item == r:
//
- return Math.abs(item)
+ return abs(item)
-method main(System.Console sys) -> void:
+public export method test() -> void:
nat xs = abs(-123)
- sys.out.println(xs)
+ assume xs == 123
xs = nop(1)
- sys.out.println(xs)
+ assume xs == 1
diff --git a/tests/valid/Function_Valid_19.sysout b/tests/valid/Function_Valid_19.sysout
deleted file mode 100644
index 978b0ddb7b..0000000000
--- a/tests/valid/Function_Valid_19.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{10, 11, 12, 13, 14}
-{}
diff --git a/tests/valid/Function_Valid_19.whiley b/tests/valid/Function_Valid_19.whiley
index 3c1b1f1961..732f03878f 100644
--- a/tests/valid/Function_Valid_19.whiley
+++ b/tests/valid/Function_Valid_19.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, int lb, int ub) -> {int}
requires no { x in xs | (x < lb) || (x >= ub) } && (|xs| == (ub - lb)):
@@ -6,6 +6,6 @@ requires no { x in xs | (x < lb) || (x >= ub) } && (|xs| == (ub - lb)):
assert !(ub in xs)
return xs
-method main(System.Console sys) -> void:
- sys.out.println(f({10, 11, 12, 13, 14}, 10, 15))
- sys.out.println(f({}, 10, 10))
+public export method test() -> void:
+ assume f({10, 11, 12, 13, 14}, 10, 15) == {10, 11, 12, 13, 14}
+ assume f({}, 10, 10) == {}
diff --git a/tests/valid/Function_Valid_2.sysout b/tests/valid/Function_Valid_2.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/Function_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Function_Valid_2.whiley b/tests/valid/Function_Valid_2.whiley
index 947db7d524..c03d87a1fd 100644
--- a/tests/valid/Function_Valid_2.whiley
+++ b/tests/valid/Function_Valid_2.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type fr3nat is (int x) where x >= 0
function f(int x) -> int:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = 1
- sys.out.println(f(y))
+ assume f(y) == 1
diff --git a/tests/valid/Function_Valid_20.sysout b/tests/valid/Function_Valid_20.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/Function_Valid_20.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Function_Valid_20.whiley b/tests/valid/Function_Valid_20.whiley
index 9eb8ee3ee9..f42167a397 100644
--- a/tests/valid/Function_Valid_20.whiley
+++ b/tests/valid/Function_Valid_20.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type fr2nat is (int x) where x >= 0
function f(fr2nat x) -> int:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = 1
- sys.out.println(f(y))
+ assume f(y) == 1
diff --git a/tests/valid/Function_Valid_21.sysout b/tests/valid/Function_Valid_21.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/Function_Valid_21.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Function_Valid_21.whiley b/tests/valid/Function_Valid_21.whiley
index 6a3ec5970a..0d320eee66 100644
--- a/tests/valid/Function_Valid_21.whiley
+++ b/tests/valid/Function_Valid_21.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type fr2nat is int
function f(fr2nat x) -> int:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = 1
- sys.out.println(f(y))
+ assume f(y) == 1
diff --git a/tests/valid/Function_Valid_3.sysout b/tests/valid/Function_Valid_3.sysout
deleted file mode 100755
index 6e7075e108..0000000000
--- a/tests/valid/Function_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-234987234987234982304980130982398723
diff --git a/tests/valid/Function_Valid_3.whiley b/tests/valid/Function_Valid_3.whiley
index 1a16dab51f..a7f948d30e 100644
--- a/tests/valid/Function_Valid_3.whiley
+++ b/tests/valid/Function_Valid_3.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type fr3nat is int
function f(int x) -> int:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = 234987234987234982304980130982398723
- sys.out.println(f(y))
+ assume f(y) == y
diff --git a/tests/valid/Function_Valid_4.sysout b/tests/valid/Function_Valid_4.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/Function_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/Function_Valid_4.whiley b/tests/valid/Function_Valid_4.whiley
index a58f73caf6..176f9ae482 100644
--- a/tests/valid/Function_Valid_4.whiley
+++ b/tests/valid/Function_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type fr4nat is (int x) where x >= 0
@@ -8,6 +8,6 @@ function g(fr4nat x) -> fr4nat:
function f(fr4nat x) -> int:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = 1
- sys.out.println(f(g(y)))
+ assume f(g(y)) == 2
diff --git a/tests/valid/Function_Valid_5.sysout b/tests/valid/Function_Valid_5.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/Function_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/Function_Valid_5.whiley b/tests/valid/Function_Valid_5.whiley
index c8ca42af3c..8c6969f0ac 100644
--- a/tests/valid/Function_Valid_5.whiley
+++ b/tests/valid/Function_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type fr4nat is int
@@ -8,6 +8,6 @@ function g(fr4nat x) -> fr4nat:
function f(fr4nat x) -> int:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = 1
- sys.out.println(f(g(y)))
+ assume f(g(y)) == 2
diff --git a/tests/valid/Function_Valid_6.sysout b/tests/valid/Function_Valid_6.sysout
deleted file mode 100755
index 3d0e885bdb..0000000000
--- a/tests/valid/Function_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{2, 3}
diff --git a/tests/valid/Function_Valid_6.whiley b/tests/valid/Function_Valid_6.whiley
index b4ad60a99f..4c6b4bccb0 100644
--- a/tests/valid/Function_Valid_6.whiley
+++ b/tests/valid/Function_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type fr5nat is (int x) where x >= 0
@@ -12,6 +12,6 @@ function g({fr5nat} xs) -> {fr5nat}:
function f({fr5nat} x) -> {int}:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ys = {1, 2, 3}
- sys.out.println(f(g(ys)))
+ assume f(g(ys)) == {2, 3}
diff --git a/tests/valid/Function_Valid_7.sysout b/tests/valid/Function_Valid_7.sysout
deleted file mode 100755
index 3d0e885bdb..0000000000
--- a/tests/valid/Function_Valid_7.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{2, 3}
diff --git a/tests/valid/Function_Valid_7.whiley b/tests/valid/Function_Valid_7.whiley
index 4784f1e068..ff13f062bd 100644
--- a/tests/valid/Function_Valid_7.whiley
+++ b/tests/valid/Function_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type fr5nat is int
@@ -12,6 +12,6 @@ function g({fr5nat} xs) -> {fr5nat}:
function f({fr5nat} x) -> {int}:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ys = {1, 2, 3}
- sys.out.println(f(g(ys)))
+ assume f(g(ys)) == {2, 3}
diff --git a/tests/valid/Function_Valid_8.sysout b/tests/valid/Function_Valid_8.sysout
deleted file mode 100755
index 3d0e885bdb..0000000000
--- a/tests/valid/Function_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{2, 3}
diff --git a/tests/valid/Function_Valid_8.whiley b/tests/valid/Function_Valid_8.whiley
index 2b1af4f5a9..0862757fe0 100644
--- a/tests/valid/Function_Valid_8.whiley
+++ b/tests/valid/Function_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type fr6nat is (int x) where x >= 0
@@ -12,6 +12,7 @@ function g({fr6nat} xs) -> {fr6nat}:
function f({int} x) -> {int}:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ys = {1, 2, 3}
- sys.out.println(f(g(ys)))
+ assume f(g(ys)) == {2, 3}
+
diff --git a/tests/valid/Function_Valid_9.sysout b/tests/valid/Function_Valid_9.sysout
deleted file mode 100755
index 36d6d847cd..0000000000
--- a/tests/valid/Function_Valid_9.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{2, 2987, 2349872, 234987234987, 234987234987234}
diff --git a/tests/valid/Function_Valid_9.whiley b/tests/valid/Function_Valid_9.whiley
index 53846b3fcc..cd83b87039 100644
--- a/tests/valid/Function_Valid_9.whiley
+++ b/tests/valid/Function_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type fr6nat is int
@@ -12,6 +12,7 @@ function g({fr6nat} xs) -> {fr6nat}:
function f({int} x) -> {int}:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ys = {-12309812, 1, 2, 2987, 2349872, 234987234987, 234987234987234}
- sys.out.println(f(g(ys)))
+ assume f(g(ys)) == {2, 2987, 2349872, 234987234987, 234987234987234}
+
diff --git a/tests/valid/HexAssign_Valid_1.sysout b/tests/valid/HexAssign_Valid_1.sysout
deleted file mode 100644
index 5eb9435ba2..0000000000
--- a/tests/valid/HexAssign_Valid_1.sysout
+++ /dev/null
@@ -1,6 +0,0 @@
-200
-1
-0
-24343
-2143
-2143
\ No newline at end of file
diff --git a/tests/valid/HexAssign_Valid_1.whiley b/tests/valid/HexAssign_Valid_1.whiley
index 78798f3682..fe0b043d4f 100644
--- a/tests/valid/HexAssign_Valid_1.whiley
+++ b/tests/valid/HexAssign_Valid_1.whiley
@@ -1,15 +1,15 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
int x = 200
- sys.out.println(x)
+ assert x == 200
x = 1
- sys.out.println(x)
+ assert x == 1
x = 0
- sys.out.println(x)
+ assert x == 0
x = 24343
- sys.out.println(x)
+ assert x == 24343
x = 2143
- sys.out.println(x)
+ assert x == 2143
x = 2143
- sys.out.println(x)
+ assert x == 2143
diff --git a/tests/valid/IfElse_Valid_1.sysout b/tests/valid/IfElse_Valid_1.sysout
deleted file mode 100755
index 004459dc07..0000000000
--- a/tests/valid/IfElse_Valid_1.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
--1
-0
-1
-1
--1
\ No newline at end of file
diff --git a/tests/valid/IfElse_Valid_1.whiley b/tests/valid/IfElse_Valid_1.whiley
index f4d1e83121..80eb948dd2 100644
--- a/tests/valid/IfElse_Valid_1.whiley
+++ b/tests/valid/IfElse_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
if x < 10:
@@ -9,9 +9,9 @@ function f(int x) -> int:
else:
return 0
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(10))
- sys.out.println(f(11))
- sys.out.println(f(1212))
- sys.out.println(f(-1212))
+public export method test() -> void:
+ assume f(1) == -1
+ assume f(10) == 0
+ assume f(11) == 1
+ assume f(1212) == 1
+ assume f(-1212) == -1
diff --git a/tests/valid/IfElse_Valid_2.sysout b/tests/valid/IfElse_Valid_2.sysout
deleted file mode 100755
index 8695446deb..0000000000
--- a/tests/valid/IfElse_Valid_2.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-1
-0
-2
-2
-1
diff --git a/tests/valid/IfElse_Valid_2.whiley b/tests/valid/IfElse_Valid_2.whiley
index cabcbb8cb7..20bc6903a7 100644
--- a/tests/valid/IfElse_Valid_2.whiley
+++ b/tests/valid/IfElse_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
if x < 10:
@@ -8,9 +8,9 @@ function f(int x) -> int:
return 2
return 0
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(10))
- sys.out.println(f(11))
- sys.out.println(f(1212))
- sys.out.println(f(-1212))
+public export method test() -> void:
+ assume f(1) == 1
+ assume f(10) == 0
+ assume f(11) == 2
+ assume f(1212) == 2
+ assume f(-1212) == 1
diff --git a/tests/valid/IfElse_Valid_3.sysout b/tests/valid/IfElse_Valid_3.sysout
deleted file mode 100755
index 1254f807d4..0000000000
--- a/tests/valid/IfElse_Valid_3.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-1
-2
-2
-2
-1
diff --git a/tests/valid/IfElse_Valid_3.whiley b/tests/valid/IfElse_Valid_3.whiley
index 10baffe224..a256f2dba9 100644
--- a/tests/valid/IfElse_Valid_3.whiley
+++ b/tests/valid/IfElse_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
if x < 10:
@@ -6,9 +6,9 @@ function f(int x) -> int:
else:
return 2
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(10))
- sys.out.println(f(11))
- sys.out.println(f(1212))
- sys.out.println(f(-1212))
+public export method test() -> void:
+ assume f(1) == 1
+ assume f(10) == 2
+ assume f(11) == 2
+ assume f(1212) == 2
+ assume f(-1212) == 1
diff --git a/tests/valid/IfElse_Valid_4.sysout b/tests/valid/IfElse_Valid_4.sysout
deleted file mode 100644
index 166be640db..0000000000
--- a/tests/valid/IfElse_Valid_4.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-6
-6
-6
diff --git a/tests/valid/IfElse_Valid_4.whiley b/tests/valid/IfElse_Valid_4.whiley
index 7961f8a4f4..3535a697ac 100644
--- a/tests/valid/IfElse_Valid_4.whiley
+++ b/tests/valid/IfElse_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Link is {LinkedList next, int data}
@@ -22,10 +22,10 @@ function sum_3(LinkedList ls) -> int:
else:
return 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
LinkedList ls = {next: null, data: 1}
ls = {next: ls, data: 2}
ls = {next: ls, data: 3}
- sys.out.println(sum_1(ls))
- sys.out.println(sum_2(ls))
- sys.out.println(sum_3(ls))
+ assume sum_1(ls) == 6
+ assume sum_2(ls) == 6
+ assume sum_3(ls) == 6
diff --git a/tests/valid/IfElse_Valid_5.sysout b/tests/valid/IfElse_Valid_5.sysout
deleted file mode 100644
index 240163b0a4..0000000000
--- a/tests/valid/IfElse_Valid_5.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-GOT FLAG: 1
-GOT FLAG: -1
-GOT FLAG: 0
diff --git a/tests/valid/IfElse_Valid_5.whiley b/tests/valid/IfElse_Valid_5.whiley
index 3cb23621d7..fcb1d7c120 100644
--- a/tests/valid/IfElse_Valid_5.whiley
+++ b/tests/valid/IfElse_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Record is { int flag }
@@ -13,10 +13,10 @@ function getFlag(Record d) -> int:
//
return -1
-method main(System.Console console):
+public export method test():
Record r = {flag: 1}
- console.out.println_s("GOT FLAG: " ++ Any.toString(getFlag(r)))
+ assume getFlag(r) == 1
r = {flag: 0}
- console.out.println_s("GOT FLAG: " ++ Any.toString(getFlag(r)))
+ assume getFlag(r) == -1
r = {flag: -1}
- console.out.println_s("GOT FLAG: " ++ Any.toString(getFlag(r)))
+ assume getFlag(r) == 0
diff --git a/tests/valid/Import_Valid_1.sysout b/tests/valid/Import_Valid_1.sysout
deleted file mode 100644
index d00491fd7e..0000000000
--- a/tests/valid/Import_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Import_Valid_1.whiley b/tests/valid/Import_Valid_1.whiley
index 4a6232cff5..d9a3e7b8d7 100644
--- a/tests/valid/Import_Valid_1.whiley
+++ b/tests/valid/Import_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
if x < 0:
@@ -6,5 +6,5 @@ function f(int x) -> int:
else:
return x
-public method main(System.Console sys) -> void:
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f(1) == 1
diff --git a/tests/valid/Import_Valid_2.sysout b/tests/valid/Import_Valid_2.sysout
deleted file mode 100644
index 95f9650f01..0000000000
--- a/tests/valid/Import_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-49
diff --git a/tests/valid/Import_Valid_2.whiley b/tests/valid/Import_Valid_2.whiley
index 0a4f36e2e6..62a34d76a1 100644
--- a/tests/valid/Import_Valid_2.whiley
+++ b/tests/valid/Import_Valid_2.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f([int] x) -> int:
return x[0]
-public method main(System.Console sys) -> void:
- sys.out.println(f("1"))
+public export method test() -> void:
+ assume f("1") == '1'
diff --git a/tests/valid/Import_Valid_3.sysout b/tests/valid/Import_Valid_3.sysout
deleted file mode 100644
index f599e28b8a..0000000000
--- a/tests/valid/Import_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-10
diff --git a/tests/valid/Import_Valid_3.whiley b/tests/valid/Import_Valid_3.whiley
index fd3a9328fd..8bd08865a3 100644
--- a/tests/valid/Import_Valid_3.whiley
+++ b/tests/valid/Import_Valid_3.whiley
@@ -1,5 +1,5 @@
-import whiley.lang.*
-import whiley.lang.*
+
+
function toInt([int] ls) -> int:
int r = 0
@@ -7,6 +7,6 @@ function toInt([int] ls) -> int:
r = r + i
return r
-public method main(System.Console sys) -> void:
+public export method test() -> void:
[int] ls = [1, 2, 3, 4]
- sys.out.println(toInt(ls))
+ assume toInt(ls) == 10
diff --git a/tests/valid/Import_Valid_4.sysout b/tests/valid/Import_Valid_4.sysout
deleted file mode 100644
index 087d7a86bc..0000000000
--- a/tests/valid/Import_Valid_4.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-FIRST: 1
-SECOND: 1.2344
diff --git a/tests/valid/Import_Valid_4.whiley b/tests/valid/Import_Valid_4.whiley
index 0547e35bb0..870c3d60e2 100644
--- a/tests/valid/Import_Valid_4.whiley
+++ b/tests/valid/Import_Valid_4.whiley
@@ -1,5 +1,3 @@
-import whiley.lang.*
-import toString from whiley.lang.Int
function f(int x) -> [int]:
return toString(x)
@@ -9,6 +7,6 @@ import toString from whiley.lang.Real
function g(real x) -> [int]:
return toString(x)
-public method main(System.Console sys) -> void:
- sys.out.println_s("FIRST: " ++ f(1))
- sys.out.println_s("SECOND: " ++ g(1.2344))
+public export method test() -> void:
+ assume f(1) == "1"
+ assume g(1.2344) == "1.2344"
diff --git a/tests/valid/Import_Valid_5.sysout b/tests/valid/Import_Valid_5.sysout
deleted file mode 100644
index 6c442f2e1a..0000000000
--- a/tests/valid/Import_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1223374
diff --git a/tests/valid/Import_Valid_5.whiley b/tests/valid/Import_Valid_5.whiley
index 5f7bb38cf5..cc0c132de1 100644
--- a/tests/valid/Import_Valid_5.whiley
+++ b/tests/valid/Import_Valid_5.whiley
@@ -1,6 +1,3 @@
-import whiley.lang.*
-import toString from whiley.lang.Any
-import toString from whiley.lang.Any
-public method main(System.Console sys) -> void:
- sys.out.println_s(toString(1223374))
+public export method test() -> void:
+ assume toString(1223374) == "1223374"
diff --git a/tests/valid/Import_Valid_6.sysout b/tests/valid/Import_Valid_6.sysout
deleted file mode 100644
index e440e5c842..0000000000
--- a/tests/valid/Import_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-3
\ No newline at end of file
diff --git a/tests/valid/Import_Valid_6.whiley b/tests/valid/Import_Valid_6.whiley
index 49c19284ac..c92f78ed4c 100644
--- a/tests/valid/Import_Valid_6.whiley
+++ b/tests/valid/Import_Valid_6.whiley
@@ -1,7 +1,5 @@
-import whiley.lang.*
-import whiley.io.*
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = 1
int y = 2
- sys.out.println(x + y)
+ assert x + y == 3
diff --git a/tests/valid/IntConst_Valid_1.sysout b/tests/valid/IntConst_Valid_1.sysout
deleted file mode 100755
index 55c1165311..0000000000
--- a/tests/valid/IntConst_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1234567891011121314151617181921
diff --git a/tests/valid/IntConst_Valid_1.whiley b/tests/valid/IntConst_Valid_1.whiley
index 508cf9b828..a01c9034a6 100644
--- a/tests/valid/IntConst_Valid_1.whiley
+++ b/tests/valid/IntConst_Valid_1.whiley
@@ -1,6 +1,6 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
int x = 1234567891011121314151617181920
x = x + 1
- sys.out.println(x)
+ assert x == 1234567891011121314151617181921
diff --git a/tests/valid/IntDefine_Valid_1.sysout b/tests/valid/IntDefine_Valid_1.sysout
deleted file mode 100755
index 8975c726eb..0000000000
--- a/tests/valid/IntDefine_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-0
-0
-3
diff --git a/tests/valid/IntDefine_Valid_1.whiley b/tests/valid/IntDefine_Valid_1.whiley
index cb67eedf1a..981c33b798 100644
--- a/tests/valid/IntDefine_Valid_1.whiley
+++ b/tests/valid/IntDefine_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type ir1nat is (int x) where x > 0
@@ -10,7 +10,7 @@ function f(int x) -> int:
return y
return 0
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(3))
+public export method test() -> void:
+ assume f(1) == 0
+ assume f(2) == 0
+ assume f(3) == 3
diff --git a/tests/valid/IntDefine_Valid_2.sysout b/tests/valid/IntDefine_Valid_2.sysout
deleted file mode 100755
index 8975c726eb..0000000000
--- a/tests/valid/IntDefine_Valid_2.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-0
-0
-3
diff --git a/tests/valid/IntDefine_Valid_2.whiley b/tests/valid/IntDefine_Valid_2.whiley
index ec734ee9b7..d094e70c74 100644
--- a/tests/valid/IntDefine_Valid_2.whiley
+++ b/tests/valid/IntDefine_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type ir1nat is int
@@ -10,7 +10,7 @@ function f(int x) -> int:
return y
return 0
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(3))
+public export method test() -> void:
+ assume f(1) == 0
+ assume f(2) == 0
+ assume f(3) == 3
diff --git a/tests/valid/IntDiv_Valid_1.sysout b/tests/valid/IntDiv_Valid_1.sysout
deleted file mode 100755
index 7ed6ff82de..0000000000
--- a/tests/valid/IntDiv_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-5
diff --git a/tests/valid/IntDiv_Valid_1.whiley b/tests/valid/IntDiv_Valid_1.whiley
index 01acada314..962f358b05 100644
--- a/tests/valid/IntDiv_Valid_1.whiley
+++ b/tests/valid/IntDiv_Valid_1.whiley
@@ -1,9 +1,11 @@
-import whiley.lang.*
+
function f(int x, int y) -> int
requires y != 0:
return x / y
-method main(System.Console sys) -> void:
- int x = f(10, 2)
- sys.out.println(x)
+public export method test() -> void:
+ assume f(10, 2) == 5
+ assume f(9, 3) == 3
+ assume f(10, 3) == 3
+
diff --git a/tests/valid/IntDiv_Valid_3.sysout b/tests/valid/IntDiv_Valid_3.sysout
deleted file mode 100644
index 7ed6ff82de..0000000000
--- a/tests/valid/IntDiv_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-5
diff --git a/tests/valid/IntDiv_Valid_3.whiley b/tests/valid/IntDiv_Valid_3.whiley
index 85a52fa780..f0745be059 100644
--- a/tests/valid/IntDiv_Valid_3.whiley
+++ b/tests/valid/IntDiv_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -11,6 +11,6 @@ requires y > 0:
z = y / x
return z
-method main(System.Console sys) -> void:
- int x = f(10, 2)
- sys.out.println(x)
+public export method test() -> void:
+ assume f(10, 2) == 5
+
diff --git a/tests/valid/IntDiv_Valid_4.sysout b/tests/valid/IntDiv_Valid_4.sysout
deleted file mode 100755
index 00750edc07..0000000000
--- a/tests/valid/IntDiv_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/tests/valid/IntDiv_Valid_4.whiley b/tests/valid/IntDiv_Valid_4.whiley
index a5ce48f810..3fb56b8402 100644
--- a/tests/valid/IntDiv_Valid_4.whiley
+++ b/tests/valid/IntDiv_Valid_4.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f(int x) -> int:
return x / 3
-public method main(System.Console sys) -> void:
- sys.out.println(f(10))
+public export method test() -> void:
+ assume f(10) == 3
diff --git a/tests/valid/IntDiv_Valid_5.sysout b/tests/valid/IntDiv_Valid_5.sysout
deleted file mode 100644
index 6dbd94289d..0000000000
--- a/tests/valid/IntDiv_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-(4,2)
diff --git a/tests/valid/IntDiv_Valid_5.whiley b/tests/valid/IntDiv_Valid_5.whiley
index 927b1af8f1..96f315462d 100644
--- a/tests/valid/IntDiv_Valid_5.whiley
+++ b/tests/valid/IntDiv_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x, int y) -> (int, int)
requires x == (2 * y):
@@ -7,5 +7,5 @@ requires x == (2 * y):
assert (2 * y) == x
return (x, y)
-public method main(System.Console console) -> void:
- console.out.println(f(2, 1))
+public export method test() -> void:
+ assume f(2, 1) == (4,2)
diff --git a/tests/valid/IntEquals_Valid_1.sysout b/tests/valid/IntEquals_Valid_1.sysout
deleted file mode 100755
index 4623095772..0000000000
--- a/tests/valid/IntEquals_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-false
-false
-true
\ No newline at end of file
diff --git a/tests/valid/IntEquals_Valid_1.whiley b/tests/valid/IntEquals_Valid_1.whiley
index bf8139f3d5..bf0946470e 100644
--- a/tests/valid/IntEquals_Valid_1.whiley
+++ b/tests/valid/IntEquals_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x, real y) -> bool:
if ((real) x) == y:
@@ -6,7 +6,7 @@ function f(int x, real y) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f(1, 4.0))
- sys.out.println(f(1, 4.2))
- sys.out.println(f(0, 0.0))
+public export method test() -> void:
+ assume f(1, 4.0) == false
+ assume f(1, 4.2) == false
+ assume f(0, 0.0) == true
diff --git a/tests/valid/IntMul_Valid_1.sysout b/tests/valid/IntMul_Valid_1.sysout
deleted file mode 100755
index 7f8f011eb7..0000000000
--- a/tests/valid/IntMul_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-7
diff --git a/tests/valid/IntMul_Valid_1.whiley b/tests/valid/IntMul_Valid_1.whiley
index 53d60c403a..f3f5e7b4a5 100644
--- a/tests/valid/IntMul_Valid_1.whiley
+++ b/tests/valid/IntMul_Valid_1.whiley
@@ -1,5 +1,5 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
int x = (2 * 3) + 1
- sys.out.println(x)
+ assert x == 7
diff --git a/tests/valid/IntMul_Valid_2.sysout b/tests/valid/IntMul_Valid_2.sysout
deleted file mode 100644
index 32b29ea640..0000000000
--- a/tests/valid/IntMul_Valid_2.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-8 * 8 - 1 => 63
-(8 * 8) - 1 => 63
-8 * (8 - 1) => 56
diff --git a/tests/valid/IntMul_Valid_2.whiley b/tests/valid/IntMul_Valid_2.whiley
index a644b8125d..629bccf5b6 100644
--- a/tests/valid/IntMul_Valid_2.whiley
+++ b/tests/valid/IntMul_Valid_2.whiley
@@ -1,11 +1,11 @@
-import whiley.lang.*
-method main(System.Console console):
+
+public export method test():
int x = 8
int y = 1
int z = x * x - y
- console.out.println_s("8 * 8 - 1 => " ++ Any.toString(z))
+ assert z == 63
z = (x * x) - y
- console.out.println_s("(8 * 8) - 1 => " ++ Any.toString(z))
+ assert z == 63
z = x * (x - y)
- console.out.println_s("8 * (8 - 1) => " ++ Any.toString(z))
+ assert z == 56
diff --git a/tests/valid/IntOp_Valid_1.sysout b/tests/valid/IntOp_Valid_1.sysout
deleted file mode 100755
index d440977fd0..0000000000
--- a/tests/valid/IntOp_Valid_1.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-112233445566778899
-112233445566778900
-112233445566778344
-13804713804713736312
-6902356902356868156
diff --git a/tests/valid/IntOp_Valid_1.whiley b/tests/valid/IntOp_Valid_1.whiley
index 0c5088b338..3833e9c641 100644
--- a/tests/valid/IntOp_Valid_1.whiley
+++ b/tests/valid/IntOp_Valid_1.whiley
@@ -1,13 +1,13 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
int x = 112233445566778899
- sys.out.println(x)
+ assert x == 112233445566778899
x = x + 1
- sys.out.println(x)
+ assert x == 112233445566778900
x = x - 556
- sys.out.println(x)
+ assert x == 112233445566778344
x = x * 123
- sys.out.println(x)
+ assert x == 13804713804713736312
x = x / 2
- sys.out.println(x)
+ assert x == 6902356902356868156
diff --git a/tests/valid/Intersection_Valid_1.sysout b/tests/valid/Intersection_Valid_1.sysout
deleted file mode 100644
index 573541ac97..0000000000
--- a/tests/valid/Intersection_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-0
diff --git a/tests/valid/Intersection_Valid_1.whiley b/tests/valid/Intersection_Valid_1.whiley
index ddc092ae64..a028aaf540 100644
--- a/tests/valid/Intersection_Valid_1.whiley
+++ b/tests/valid/Intersection_Valid_1.whiley
@@ -1,10 +1,9 @@
-import whiley.lang.*
+
type EmptyList is [int] & [real]
function size(EmptyList l) -> int:
return |l|
-method main(System.Console sys) -> void:
- list = []
- sys.out.println(size(list))
+public export method test() -> void:
+ assume size([]) == 0
diff --git a/tests/valid/Intersection_Valid_2.sysout b/tests/valid/Intersection_Valid_2.sysout
deleted file mode 100644
index 6156b7b2af..0000000000
--- a/tests/valid/Intersection_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-GOT: 1234
diff --git a/tests/valid/Intersection_Valid_2.whiley b/tests/valid/Intersection_Valid_2.whiley
index 90224249c0..283a61c196 100644
--- a/tests/valid/Intersection_Valid_2.whiley
+++ b/tests/valid/Intersection_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type LinkedList is null | {LinkedList next, int data}
@@ -9,7 +9,6 @@ type InterList is UnitList & LinkedList
function f(InterList l) -> int:
return l.data
-method main(System.Console sys) -> void:
+public export method test() -> void:
list = {next: null, data: 1234}
- d = f(list)
- sys.out.println_s("GOT: " ++ Any.toString(d))
+ assume f(list) == 1234
diff --git a/tests/valid/Lambda_Valid_1.sysout b/tests/valid/Lambda_Valid_1.sysout
deleted file mode 100644
index dcf37cd5e2..0000000000
--- a/tests/valid/Lambda_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-2
-3
-4
diff --git a/tests/valid/Lambda_Valid_1.whiley b/tests/valid/Lambda_Valid_1.whiley
index 62d15b2c6b..dbc92c9968 100644
--- a/tests/valid/Lambda_Valid_1.whiley
+++ b/tests/valid/Lambda_Valid_1.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
+
type func is function(int) -> int
function g() -> func:
return &(int x -> x + 1)
-method main(System.Console sys) -> void:
+public export method test() -> void:
func f = g()
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(3))
+ assume f(1) == 2
+ assume f(2) == 3
+ assume f(3) == 4
diff --git a/tests/valid/Lambda_Valid_2.sysout b/tests/valid/Lambda_Valid_2.sysout
deleted file mode 100644
index 2ecf706fbd..0000000000
--- a/tests/valid/Lambda_Valid_2.sysout
+++ /dev/null
@@ -1,6 +0,0 @@
-4
-5
-6
-20
-21
-22
diff --git a/tests/valid/Lambda_Valid_2.whiley b/tests/valid/Lambda_Valid_2.whiley
index bd22bef805..50d265ddf0 100644
--- a/tests/valid/Lambda_Valid_2.whiley
+++ b/tests/valid/Lambda_Valid_2.whiley
@@ -1,16 +1,16 @@
-import whiley.lang.*
+
type func is function(int) -> int
function g(int y) -> func:
return &(int x -> x + y)
-method main(System.Console sys) -> void:
+public export method test() -> void:
func f = g(3)
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(3))
+ assume f(1) == 4
+ assume f(2) == 5
+ assume f(3) == 6
f = g(19)
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(3))
+ assume f(1) == 20
+ assume f(2) == 21
+ assume f(3) == 22
diff --git a/tests/valid/Lambda_Valid_3.sysout b/tests/valid/Lambda_Valid_3.sysout
deleted file mode 100644
index d8bf339710..0000000000
--- a/tests/valid/Lambda_Valid_3.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[01101000b, 01100101b, 01101100b, 01101100b, 01101111b]
-[01100011b, 01110010b, 01110101b, 01100101b, 01101100b, 00100000b, 01100011b]
-[01110111b, 01101111b, 01110010b, 01101100b, 01100100b]
diff --git a/tests/valid/Lambda_Valid_3.whiley b/tests/valid/Lambda_Valid_3.whiley
index 6e1203434d..6610f6692c 100644
--- a/tests/valid/Lambda_Valid_3.whiley
+++ b/tests/valid/Lambda_Valid_3.whiley
@@ -1,28 +1,56 @@
-import whiley.lang.*
-
type string is [int]
type t_Reader is method(int) -> [byte]
-
type InputStream is { t_Reader read }
-
type BufferState is &{[byte] bytes, int pos}
+// Define the 8bit ASCII character
+public type char is (int x) where 0 <= x && x <= 255
+
+// Convert an ASCII character into a byte.
+public function toByte(char v) -> byte:
+ //
+ byte mask = 00000001b
+ byte r = 0b
+ for i in 0..8:
+ if (v % 2) == 1:
+ r = r | mask
+ v = v / 2
+ mask = mask << 1
+ return r
+
+// Convert an ASCII string into a list of bytes
+public function toBytes(string s) -> [byte]:
+ [byte] r = []
+ int i = 0
+ while i < |s|:
+ r = r ++ [toByte(s[i])]
+ i = i + 1
+ return r
+
+// Compute minimum of two integers
+function min(int a, int b) -> int:
+ if a <= b:
+ return a
+ else:
+ return b
+
+// Read specified number of bytes from buffer
method read(BufferState state, int amount) -> [byte]:
int start = state->pos
- int end = start + Math.min(amount, |state->bytes| - start)
+ int end = start + min(amount, |state->bytes| - start)
state->pos = end
return state->bytes[start..end]
-method eof(BufferState state) -> bool:
- return state->pos >= |state->bytes|
-
+// Construct buffer from list of bytes
public method BufferInputStream([byte] buffer) -> InputStream:
BufferState this = new {bytes: buffer, pos: 0}
return {read: &(int x -> read(this, x))}
-method main(System.Console sys) -> void:
- [string] strings = ["hello", "cruel cruel", "world"]
- for s in strings:
- InputStream bis = BufferInputStream(ASCII.toBytes(s))
- [byte] bytes = bis.read(7)
- sys.out.println(bytes)
+public export method test() -> void:
+ InputStream bis = BufferInputStream(toBytes("hello"))
+ [byte] bytes = bis.read(7)
+ assume bytes == [01101000b, 01100101b, 01101100b, 01101100b, 01101111b]
+ //
+ bis = BufferInputStream(toBytes("cruel world"))
+ bytes = bis.read(7)
+ assume bytes == [01100011b, 01110010b, 01110101b, 01100101b, 01101100b, 00100000b, 01110111b]
diff --git a/tests/valid/Lambda_Valid_4.sysout b/tests/valid/Lambda_Valid_4.sysout
deleted file mode 100644
index 6143bda133..0000000000
--- a/tests/valid/Lambda_Valid_4.sysout
+++ /dev/null
@@ -1,8 +0,0 @@
-READ: hel
-READ: lo
-READ: cru
-READ: el
-READ: cru
-READ: el
-READ: wor
-READ: ld
diff --git a/tests/valid/Lambda_Valid_4.whiley b/tests/valid/Lambda_Valid_4.whiley
index 6261a03bd3..db08e428fe 100644
--- a/tests/valid/Lambda_Valid_4.whiley
+++ b/tests/valid/Lambda_Valid_4.whiley
@@ -1,5 +1,3 @@
-import whiley.lang.*
-
type string is [int]
type InputStream is {
@@ -9,23 +7,62 @@ type InputStream is {
type BufferState is &{[byte] bytes, int pos}
+// Define the 8bit ASCII character
+public type char is (int x) where 0 <= x && x <= 255
+
+// Convert an ASCII character into a byte.
+public function toByte(char v) -> byte:
+ //
+ byte mask = 00000001b
+ byte r = 0b
+ for i in 0..8:
+ if (v % 2) == 1:
+ r = r | mask
+ v = v / 2
+ mask = mask << 1
+ return r
+
+// Convert an ASCII string into a list of bytes
+public function toBytes(string s) -> [byte]:
+ [byte] r = []
+ int i = 0
+ while i < |s|:
+ r = r ++ [toByte(s[i])]
+ i = i + 1
+ return r
+
+// Compute minimum of two integers
+function min(int a, int b) -> int:
+ if a <= b:
+ return a
+ else:
+ return b
+
+// Read specified number of bytes from buffer
method read(BufferState state, int amount) -> [byte]:
int start = state->pos
- int end = start + Math.min(amount, |state->bytes| - start)
+ int end = start + min(amount, |state->bytes| - start)
state->pos = end
return state->bytes[start..end]
+// Check whether buffer is empty or not
method eof(BufferState state) -> bool:
return state->pos >= |state->bytes|
+// Construct buffer from list of bytes
public method BufferInputStream([byte] buffer) -> InputStream:
BufferState this = new {bytes: buffer, pos: 0}
return {read: &(int x -> read(this, x)), eof: &( -> eof(this))}
-method main(System.Console sys) -> void:
- [string] strings = ["hello", "cruel cruel", "world"]
- for s in strings:
- InputStream bis = BufferInputStream(ASCII.toBytes(s))
- while !bis.eof():
- [byte] bytes = bis.read(3)
- sys.out.println_s("READ: " ++ ASCII.fromBytes(bytes))
+method read(string s) -> [byte]:
+ [byte] bytes = []
+ InputStream bis = BufferInputStream(toBytes(s))
+ //
+ while !bis.eof():
+ bytes = bis.read(3)
+ //
+ return bytes
+
+public export method test() -> void:
+ assume read("hello") == [01101100b, 01101111b]
+
diff --git a/tests/valid/Lambda_Valid_5.sysout b/tests/valid/Lambda_Valid_5.sysout
deleted file mode 100644
index 7f8f011eb7..0000000000
--- a/tests/valid/Lambda_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-7
diff --git a/tests/valid/Lambda_Valid_5.whiley b/tests/valid/Lambda_Valid_5.whiley
index 44ea9e93f6..2a0ccb7e49 100644
--- a/tests/valid/Lambda_Valid_5.whiley
+++ b/tests/valid/Lambda_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
method f(int x) -> int:
return x + 1
@@ -6,6 +6,6 @@ method f(int x) -> int:
method g(method func(int) -> int, int p) -> int:
return func(p)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int y = g(&(int x -> f(x + 1)), 5)
- sys.out.println(y)
+ assume y == 7
diff --git a/tests/valid/Lambda_Valid_6.sysout b/tests/valid/Lambda_Valid_6.sysout
deleted file mode 100644
index 7f8f011eb7..0000000000
--- a/tests/valid/Lambda_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-7
diff --git a/tests/valid/Lambda_Valid_6.whiley b/tests/valid/Lambda_Valid_6.whiley
index fbbb8bda2c..7a68a053fa 100644
--- a/tests/valid/Lambda_Valid_6.whiley
+++ b/tests/valid/Lambda_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
return x + 1
@@ -9,6 +9,6 @@ method g(int p) -> int:
func_t func = &(int x -> f(x + 1))
return func(p)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = g(5)
- sys.out.println(x)
+ assume x == 7
diff --git a/tests/valid/Lambda_Valid_7.sysout b/tests/valid/Lambda_Valid_7.sysout
deleted file mode 100644
index 7f8f011eb7..0000000000
--- a/tests/valid/Lambda_Valid_7.sysout
+++ /dev/null
@@ -1 +0,0 @@
-7
diff --git a/tests/valid/Lambda_Valid_7.whiley b/tests/valid/Lambda_Valid_7.whiley
index dfbfdce8fc..663526bbe7 100644
--- a/tests/valid/Lambda_Valid_7.whiley
+++ b/tests/valid/Lambda_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int
requires x > 0:
@@ -11,6 +11,6 @@ requires p >= 0:
func_t func = &(int x -> f(x + 1))
return func(p)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = g(5)
- sys.out.println(x)
+ assume x == 7
diff --git a/tests/valid/Lambda_Valid_8.sysout b/tests/valid/Lambda_Valid_8.sysout
deleted file mode 100644
index b07697d2df..0000000000
--- a/tests/valid/Lambda_Valid_8.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-11
-21
diff --git a/tests/valid/Lambda_Valid_8.whiley b/tests/valid/Lambda_Valid_8.whiley
index 10da35eb6a..2f4026c34b 100644
--- a/tests/valid/Lambda_Valid_8.whiley
+++ b/tests/valid/Lambda_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function g(int x, int y) -> int:
return x + y
@@ -13,8 +13,8 @@ function f2(int y) -> function(int) -> int:
type func is function(int) -> int
-public method main(System.Console console) -> void:
+public export method test() -> void:
func fx = f1(10)
func fy = f2(20)
- console.out.println(fx(1))
- console.out.println(fy(1))
+ assume fx(1) == 11
+ assume fy(1) == 21
diff --git a/tests/valid/Lambda_Valid_9.sysout b/tests/valid/Lambda_Valid_9.sysout
deleted file mode 100644
index 2b2f2e1b92..0000000000
--- a/tests/valid/Lambda_Valid_9.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-3
diff --git a/tests/valid/Lambda_Valid_9.whiley b/tests/valid/Lambda_Valid_9.whiley
index f3d0c9fd60..1c5ba5aaa2 100644
--- a/tests/valid/Lambda_Valid_9.whiley
+++ b/tests/valid/Lambda_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
type Point is {
int x,
@@ -21,7 +21,7 @@ function Point(int x, int y) -> Point:
getX: &getX
}
-method main(System.Console console):
+public export method test():
Point p = Point(1,2)
- console.out.println(p.getX(p))
- console.out.println(p.toString(p))
+ assume p.getX(p) == 1
+ assume p.toString(p) == 3
diff --git a/tests/valid/LengthOf_Valid_1.sysout b/tests/valid/LengthOf_Valid_1.sysout
deleted file mode 100644
index 2559e5c49e..0000000000
--- a/tests/valid/LengthOf_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3
-6
diff --git a/tests/valid/LengthOf_Valid_1.whiley b/tests/valid/LengthOf_Valid_1.whiley
index e0739d817e..2de850c4d5 100644
--- a/tests/valid/LengthOf_Valid_1.whiley
+++ b/tests/valid/LengthOf_Valid_1.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
+
type listset is [int] | {int}
function len(listset l) -> int:
return |l|
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] l = [1, 2, 3]
- sys.out.println(len(l))
+ assume len(l) == 3
{int} s = {1, 2, 3, 4, 5, 6}
- sys.out.println(len(s))
+ assume len(s) == 6
diff --git a/tests/valid/LengthOf_Valid_2.sysout b/tests/valid/LengthOf_Valid_2.sysout
deleted file mode 100644
index b94473479c..0000000000
--- a/tests/valid/LengthOf_Valid_2.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3
-4
diff --git a/tests/valid/LengthOf_Valid_2.whiley b/tests/valid/LengthOf_Valid_2.whiley
index 36ac8b69c6..854dcedead 100644
--- a/tests/valid/LengthOf_Valid_2.whiley
+++ b/tests/valid/LengthOf_Valid_2.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
+
type listdict is [int] | {int=>int}
function len(listdict l) -> int:
return |l|
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] l = [1, 2, 3]
- sys.out.println(len(l))
+ assume len(l) == 3
{int=>int} m = {1=>2, 3=>4, 5=>6, 7=>8}
- sys.out.println(len(m))
+ assume len(m) == 4
diff --git a/tests/valid/LengthOf_Valid_3.sysout b/tests/valid/LengthOf_Valid_3.sysout
deleted file mode 100644
index b94473479c..0000000000
--- a/tests/valid/LengthOf_Valid_3.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3
-4
diff --git a/tests/valid/LengthOf_Valid_3.whiley b/tests/valid/LengthOf_Valid_3.whiley
index 0b6ae44ff5..9fadf828a8 100644
--- a/tests/valid/LengthOf_Valid_3.whiley
+++ b/tests/valid/LengthOf_Valid_3.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
+
type setdict is {int} | {int=>int}
function len(setdict l) -> int:
return |l|
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} l = {1, 2, 3}
- sys.out.println(len(l))
+ assume len(l) == 3
{int=>int} m = {1=>2, 3=>4, 5=>6, 7=>8}
- sys.out.println(len(m))
+ assume len(m) == 4
diff --git a/tests/valid/LengthOf_Valid_4.sysout b/tests/valid/LengthOf_Valid_4.sysout
deleted file mode 100644
index b37424c292..0000000000
--- a/tests/valid/LengthOf_Valid_4.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-3
-2
-4
diff --git a/tests/valid/LengthOf_Valid_4.whiley b/tests/valid/LengthOf_Valid_4.whiley
index 3c9dace7f4..8184b4889f 100644
--- a/tests/valid/LengthOf_Valid_4.whiley
+++ b/tests/valid/LengthOf_Valid_4.whiley
@@ -1,14 +1,14 @@
-import whiley.lang.*
+
type listsetdict is [int] | {int} | {int=>int}
function len(listsetdict l) -> int:
return |l|
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} s = {1, 2, 3}
- sys.out.println(len(s))
+ assume len(s) == 3
[int] l = [1, 2]
- sys.out.println(len(l))
+ assume len(l) == 2
{int=>int} m = {1=>2, 3=>4, 5=>6, 7=>8}
- sys.out.println(len(m))
+ assume len(m) == 4
diff --git a/tests/valid/LengthOf_Valid_5.sysout b/tests/valid/LengthOf_Valid_5.sysout
deleted file mode 100644
index c3b1c9934c..0000000000
--- a/tests/valid/LengthOf_Valid_5.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-2
-11
diff --git a/tests/valid/LengthOf_Valid_5.whiley b/tests/valid/LengthOf_Valid_5.whiley
index 02513202c5..ec803c7b44 100644
--- a/tests/valid/LengthOf_Valid_5.whiley
+++ b/tests/valid/LengthOf_Valid_5.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
+
type list is [int]
function len(list l) -> int:
return |l|
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] l = [1, 2]
- sys.out.println(len(l))
+ assume len(l) == 2
[int] s = "Hello World"
- sys.out.println(len(s))
+ assume len(s) == 11
diff --git a/tests/valid/ListAccess_Valid_1.sysout b/tests/valid/ListAccess_Valid_1.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ListAccess_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ListAccess_Valid_1.whiley b/tests/valid/ListAccess_Valid_1.whiley
index e9b4304b5f..9bb0354eb6 100644
--- a/tests/valid/ListAccess_Valid_1.whiley
+++ b/tests/valid/ListAccess_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] x) -> void
requires |x| > 0:
@@ -6,7 +6,7 @@ requires |x| > 0:
int z = x[0]
assert y == z
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] arr = [1, 2, 3]
f(arr)
- sys.out.println(arr[0])
+ assert arr[0] == 1
diff --git a/tests/valid/ListAccess_Valid_3.sysout b/tests/valid/ListAccess_Valid_3.sysout
deleted file mode 100755
index 1edf96e4e2..0000000000
--- a/tests/valid/ListAccess_Valid_3.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-[1, 2, 3]
-[1, 2, 3]
-[1, 2, 3]
-[1, 2, 3]
diff --git a/tests/valid/ListAccess_Valid_3.whiley b/tests/valid/ListAccess_Valid_3.whiley
index a18dfb1416..c052de8b3a 100644
--- a/tests/valid/ListAccess_Valid_3.whiley
+++ b/tests/valid/ListAccess_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] x, int i) -> void
requires |x| > 0:
@@ -9,14 +9,14 @@ requires |x| > 0:
int z = x[i]
assert y == z
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] arr = [1, 2, 3]
f(arr, 1)
- sys.out.println(arr)
+ assume arr == [1,2,3]
f(arr, 2)
- sys.out.println(arr)
+ assume arr == [1,2,3]
f(arr, 3)
- sys.out.println(arr)
+ assume arr == [1,2,3]
f(arr, -1)
- sys.out.println(arr)
+ assume arr == [1,2,3]
f(arr, 4)
diff --git a/tests/valid/ListAccess_Valid_5.sysout b/tests/valid/ListAccess_Valid_5.sysout
deleted file mode 100755
index 00750edc07..0000000000
--- a/tests/valid/ListAccess_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/tests/valid/ListAccess_Valid_5.whiley b/tests/valid/ListAccess_Valid_5.whiley
index 07b3df9779..0b070fec41 100644
--- a/tests/valid/ListAccess_Valid_5.whiley
+++ b/tests/valid/ListAccess_Valid_5.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
function f([int] x) -> int:
return |x|
-method main(System.Console sys) -> void:
+public export method test() -> void:
[[int]] arr = [[1, 2, 3]]
- sys.out.println(f(arr[0]))
+ assume f(arr[0]) == 3
diff --git a/tests/valid/ListAccess_Valid_6.whiley b/tests/valid/ListAccess_Valid_6.whiley
index f1100353ba..1f4c19a61d 100644
--- a/tests/valid/ListAccess_Valid_6.whiley
+++ b/tests/valid/ListAccess_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] str) -> [int]:
[int]|null r = null
@@ -9,6 +9,5 @@ function f([int] str) -> [int]:
r = r ++ [r[0]]
return r
-public method main(System.Console sys) -> void:
- r = f("Hello")
- sys.out.println(r)
+public export method test() -> void:
+ assumr f("Hello") == [0,0,0,0,0]
diff --git a/tests/valid/ListAccess_Valid_7.whiley b/tests/valid/ListAccess_Valid_7.whiley
index ee1d2b91fd..f7323268a9 100644
--- a/tests/valid/ListAccess_Valid_7.whiley
+++ b/tests/valid/ListAccess_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] str) -> [int]:
[int]|null r = []
@@ -12,6 +12,5 @@ function f([int] str) -> [int]:
r = r + [r[0]]
return r
-public method main(System.Console sys) -> void:
- r = f("Hello")
- sys.out.println(r)
+public export method test() -> void:
+ assume f("Hello") == [0,0,0,0,0]
diff --git a/tests/valid/ListAccess_Valid_8.sysout b/tests/valid/ListAccess_Valid_8.sysout
deleted file mode 100644
index 569abca472..0000000000
--- a/tests/valid/ListAccess_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[0, 1, 3, 7]
diff --git a/tests/valid/ListAccess_Valid_8.whiley b/tests/valid/ListAccess_Valid_8.whiley
index 506ca341ce..a71232c05b 100644
--- a/tests/valid/ListAccess_Valid_8.whiley
+++ b/tests/valid/ListAccess_Valid_8.whiley
@@ -1,12 +1,22 @@
-import whiley.lang.*
+// Convert a byte into an unsigned int. This assumes a little endian
+// encoding.
+public function toUnsignedInt(byte b) -> int:
+ int r = 0
+ int base = 1
+ while b != 0b:
+ if (b & 00000001b) == 00000001b:
+ r = r + base
+ b = b >> 1
+ base = base * 2
+ return r
public function meth([byte] bytes) -> [int]:
[int] data = []
for i in 0 .. |bytes|:
- data = data ++ [Byte.toUnsignedInt(bytes[i])]
+ data = data ++ [toUnsignedInt(bytes[i])]
return data
-public method main(System.Console sys) -> void:
+public export method test() -> void:
[byte] bytes = [00000000b, 00000001b, 00000011b, 00000111b]
- [int] ints = meth(bytes)
- sys.out.println(ints)
+ assume meth(bytes) == [0,1,3,7]
+
diff --git a/tests/valid/ListAccess_Valid_9.sysout b/tests/valid/ListAccess_Valid_9.sysout
deleted file mode 100644
index cd5ac039d6..0000000000
--- a/tests/valid/ListAccess_Valid_9.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2.0
diff --git a/tests/valid/ListAccess_Valid_9.whiley b/tests/valid/ListAccess_Valid_9.whiley
index bd5f405926..1225426e68 100644
--- a/tests/valid/ListAccess_Valid_9.whiley
+++ b/tests/valid/ListAccess_Valid_9.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
type Rec is { [real] items }
-method main(System.Console console):
+public export method test():
Rec r = { items: [1.0, 2.0, 3.0] }
real x = (r.items)[1]
- console.out.println(x)
+ assert x == 2.0
diff --git a/tests/valid/ListAppend_Valid_1.sysout b/tests/valid/ListAppend_Valid_1.sysout
deleted file mode 100755
index 12bae17cf7..0000000000
--- a/tests/valid/ListAppend_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3, 4]
diff --git a/tests/valid/ListAppend_Valid_1.whiley b/tests/valid/ListAppend_Valid_1.whiley
index 936e0e9236..5d8519c12e 100644
--- a/tests/valid/ListAppend_Valid_1.whiley
+++ b/tests/valid/ListAppend_Valid_1.whiley
@@ -1,5 +1,5 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] r = [1, 2] ++ [3, 4]
- sys.out.println(r)
+ assert r == [1,2,3,4]
diff --git a/tests/valid/ListAppend_Valid_10.sysout b/tests/valid/ListAppend_Valid_10.sysout
deleted file mode 100755
index 1e8b314962..0000000000
--- a/tests/valid/ListAppend_Valid_10.sysout
+++ /dev/null
@@ -1 +0,0 @@
-6
diff --git a/tests/valid/ListAppend_Valid_10.whiley b/tests/valid/ListAppend_Valid_10.whiley
index 32da1b6f8b..4383af6c7a 100644
--- a/tests/valid/ListAppend_Valid_10.whiley
+++ b/tests/valid/ListAppend_Valid_10.whiley
@@ -1,11 +1,11 @@
-import whiley.lang.*
+
function f([int] xs) -> int
requires no { x in xs | x < 0 }:
return |xs|
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] left = [1, 2, 3]
[int] right = [5, 6, 7]
int r = f(left ++ right)
- sys.out.println(r)
+ assume r == 6
diff --git a/tests/valid/ListAppend_Valid_11.sysout b/tests/valid/ListAppend_Valid_11.sysout
deleted file mode 100755
index 1e8b314962..0000000000
--- a/tests/valid/ListAppend_Valid_11.sysout
+++ /dev/null
@@ -1 +0,0 @@
-6
diff --git a/tests/valid/ListAppend_Valid_11.whiley b/tests/valid/ListAppend_Valid_11.whiley
index 4298c942a5..fa53199504 100644
--- a/tests/valid/ListAppend_Valid_11.whiley
+++ b/tests/valid/ListAppend_Valid_11.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
function f([int] xs) -> int:
return |xs|
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] left = [1, 2, 3]
[int] right = [5, 6, 7]
int r = f(left ++ right)
- sys.out.println(r)
+ assume r == 6
diff --git a/tests/valid/ListAppend_Valid_12.sysout b/tests/valid/ListAppend_Valid_12.sysout
deleted file mode 100755
index 1e8b314962..0000000000
--- a/tests/valid/ListAppend_Valid_12.sysout
+++ /dev/null
@@ -1 +0,0 @@
-6
diff --git a/tests/valid/ListAppend_Valid_12.whiley b/tests/valid/ListAppend_Valid_12.whiley
index 6ea7a9ef72..d30591b84a 100644
--- a/tests/valid/ListAppend_Valid_12.whiley
+++ b/tests/valid/ListAppend_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type plistv6 is ([int] xs) where no { x in xs | x < 0 }
@@ -8,6 +8,6 @@ function f(plistv6 xs) -> int:
function g(plistv6 left, plistv6 right) -> int:
return f(left ++ right)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int r = g([1, 2, 3], [6, 7, 8])
- sys.out.println(r)
+ assume r == 6
diff --git a/tests/valid/ListAppend_Valid_13.sysout b/tests/valid/ListAppend_Valid_13.sysout
deleted file mode 100755
index 1e8b314962..0000000000
--- a/tests/valid/ListAppend_Valid_13.sysout
+++ /dev/null
@@ -1 +0,0 @@
-6
diff --git a/tests/valid/ListAppend_Valid_13.whiley b/tests/valid/ListAppend_Valid_13.whiley
index 67a6d8f473..f7d61bd88a 100644
--- a/tests/valid/ListAppend_Valid_13.whiley
+++ b/tests/valid/ListAppend_Valid_13.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type plistv6 is [int]
@@ -8,6 +8,7 @@ function f(plistv6 xs) -> int:
function g(plistv6 left, plistv6 right) -> int:
return f(left ++ right)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int r = g([1, 2, 3], [6, 7, 8])
- sys.out.println(r)
+ assume r == 6
+
diff --git a/tests/valid/ListAppend_Valid_14.sysout b/tests/valid/ListAppend_Valid_14.sysout
deleted file mode 100644
index 1e8b314962..0000000000
--- a/tests/valid/ListAppend_Valid_14.sysout
+++ /dev/null
@@ -1 +0,0 @@
-6
diff --git a/tests/valid/ListAppend_Valid_14.whiley b/tests/valid/ListAppend_Valid_14.whiley
index d1a6d04563..ecd5c42ec6 100644
--- a/tests/valid/ListAppend_Valid_14.whiley
+++ b/tests/valid/ListAppend_Valid_14.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
+
type nat is (int n) where n >= 0
function f([int] xs, [int] ys) -> nat:
return |xs ++ ys|
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] left = [1, 2, 3]
[int] right = [5, 6, 7]
int r = f(left, right)
- sys.out.println(r)
+ assume r == 6
diff --git a/tests/valid/ListAppend_Valid_2.sysout b/tests/valid/ListAppend_Valid_2.sysout
deleted file mode 100644
index 9e16530d87..0000000000
--- a/tests/valid/ListAppend_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122]
diff --git a/tests/valid/ListAppend_Valid_2.whiley b/tests/valid/ListAppend_Valid_2.whiley
index 9801873c09..02706babbf 100644
--- a/tests/valid/ListAppend_Valid_2.whiley
+++ b/tests/valid/ListAppend_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function append([int] input) -> [int]:
[int] rs = []
@@ -6,6 +6,34 @@ function append([int] input) -> [int]:
rs = rs ++ [input[i]]
return rs
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] xs = append("abcdefghijklmnopqrstuvwxyz")
- sys.out.println_s(Any.toString(xs))
+ assume xs == [
+ 'a',
+ 'b',
+ 'c',
+ 'd',
+ 'e',
+ 'f',
+ 'g',
+ 'h',
+ 'i',
+ 'j',
+ 'k',
+ 'l',
+ 'm',
+ 'n',
+ 'o',
+ 'p',
+ 'q',
+ 'r',
+ 's',
+ 't',
+ 'u',
+ 'v',
+ 'w',
+ 'x',
+ 'y',
+ 'z'
+ ]
+
diff --git a/tests/valid/ListAppend_Valid_3.sysout b/tests/valid/ListAppend_Valid_3.sysout
deleted file mode 100644
index 24d4c7060c..0000000000
--- a/tests/valid/ListAppend_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3, 5, 6, 7]
diff --git a/tests/valid/ListAppend_Valid_3.whiley b/tests/valid/ListAppend_Valid_3.whiley
index 94b29edbc7..6283be3238 100644
--- a/tests/valid/ListAppend_Valid_3.whiley
+++ b/tests/valid/ListAppend_Valid_3.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
+
type nat is (int n) where n >= 0
function f([nat] xs, [nat] ys) -> [nat]:
return xs ++ ys
-method main(System.Console sys) -> void:
+public export method test() -> void:
[nat] left = [1, 2, 3]
[nat] right = [5, 6, 7]
[nat] r = f(left, right)
- sys.out.println(r)
+ assume r == [1,2,3,5,6,7]
diff --git a/tests/valid/ListAppend_Valid_4.sysout b/tests/valid/ListAppend_Valid_4.sysout
deleted file mode 100644
index a019512a6d..0000000000
--- a/tests/valid/ListAppend_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[122, 121, 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, 97]
diff --git a/tests/valid/ListAppend_Valid_4.whiley b/tests/valid/ListAppend_Valid_4.whiley
index 714e11b32e..acf0d17eaa 100644
--- a/tests/valid/ListAppend_Valid_4.whiley
+++ b/tests/valid/ListAppend_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function append([int] input) -> [int]:
[int] rs = []
@@ -6,6 +6,33 @@ function append([int] input) -> [int]:
rs = [input[i]] ++ rs
return rs
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] xs = append("abcdefghijklmnopqrstuvwxyz")
- sys.out.println(xs)
+ assume xs == [
+ 'z',
+ 'y',
+ 'x',
+ 'w',
+ 'v',
+ 'u',
+ 't',
+ 's',
+ 'r',
+ 'q',
+ 'p',
+ 'o',
+ 'n',
+ 'm',
+ 'l',
+ 'k',
+ 'j',
+ 'i',
+ 'h',
+ 'g',
+ 'f',
+ 'e',
+ 'd',
+ 'c',
+ 'b',
+ 'a'
+ ]
diff --git a/tests/valid/ListAppend_Valid_5.sysout b/tests/valid/ListAppend_Valid_5.sysout
deleted file mode 100644
index 2b24e31277..0000000000
--- a/tests/valid/ListAppend_Valid_5.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-2
-6
diff --git a/tests/valid/ListAppend_Valid_5.whiley b/tests/valid/ListAppend_Valid_5.whiley
index 67fd7e98f2..33ead18af4 100644
--- a/tests/valid/ListAppend_Valid_5.whiley
+++ b/tests/valid/ListAppend_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int n) where n >= 0
@@ -7,10 +7,10 @@ requires i < (|xs| + |ys|):
xs = xs ++ ys
return xs[i]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[nat] left = [1, 2, 3]
[nat] right = [5, 6, 7]
nat r = f(left, right, 1)
- sys.out.println(r)
+ assume r == 2
r = f(left, right, 4)
- sys.out.println(r)
+ assume r == 6
diff --git a/tests/valid/ListAppend_Valid_6.sysout b/tests/valid/ListAppend_Valid_6.sysout
deleted file mode 100644
index da29283aaa..0000000000
--- a/tests/valid/ListAppend_Valid_6.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
diff --git a/tests/valid/ListAppend_Valid_6.whiley b/tests/valid/ListAppend_Valid_6.whiley
index ada6a9fe5f..c30467f387 100644
--- a/tests/valid/ListAppend_Valid_6.whiley
+++ b/tests/valid/ListAppend_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function test([real] xs, [int] ys) -> bool:
for x in xs ++ ys:
@@ -6,8 +6,8 @@ function test([real] xs, [int] ys) -> bool:
return true
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
bool s = test([1.2, 2.3, 3.4], [1, 2, 3, 4, 5, 6, 7, 8])
- sys.out.println(s)
+ assume s == true
s = test([1.2, 2.3, 3.4], [])
- sys.out.println(s)
+ assume s == false
diff --git a/tests/valid/ListAppend_Valid_7.sysout b/tests/valid/ListAppend_Valid_7.sysout
deleted file mode 100755
index 12bae17cf7..0000000000
--- a/tests/valid/ListAppend_Valid_7.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3, 4]
diff --git a/tests/valid/ListAppend_Valid_7.whiley b/tests/valid/ListAppend_Valid_7.whiley
index 2efffe3615..5032f1d344 100644
--- a/tests/valid/ListAppend_Valid_7.whiley
+++ b/tests/valid/ListAppend_Valid_7.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] left = [1, 2]
[int] right = [3, 4]
[int] r = left ++ right
- sys.out.println(r)
+ assert r == [1,2,3,4]
diff --git a/tests/valid/ListAppend_Valid_8.sysout b/tests/valid/ListAppend_Valid_8.sysout
deleted file mode 100755
index e4f71147e8..0000000000
--- a/tests/valid/ListAppend_Valid_8.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[1, 2, 6]
-[3, 4]
-[1, 2, 3, 4]
diff --git a/tests/valid/ListAppend_Valid_8.whiley b/tests/valid/ListAppend_Valid_8.whiley
index a12ee24134..d02fc3a573 100644
--- a/tests/valid/ListAppend_Valid_8.whiley
+++ b/tests/valid/ListAppend_Valid_8.whiley
@@ -1,10 +1,9 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] left = [1, 2]
[int] right = [3, 4]
[int] r = left ++ right
left = left ++ [6]
- sys.out.println(left)
- sys.out.println(right)
- sys.out.println(r)
+ assert r == [1,2,3,4]
+ assert left == [1,2,6]
diff --git a/tests/valid/ListAppend_Valid_9.sysout b/tests/valid/ListAppend_Valid_9.sysout
deleted file mode 100755
index a78dea4bac..0000000000
--- a/tests/valid/ListAppend_Valid_9.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[4.23, 5.5, 1.0, 2.0, 3.0]
diff --git a/tests/valid/ListAppend_Valid_9.whiley b/tests/valid/ListAppend_Valid_9.whiley
index 82884be5d6..6f231120cb 100644
--- a/tests/valid/ListAppend_Valid_9.whiley
+++ b/tests/valid/ListAppend_Valid_9.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] l = [1, 2, 3]
[real] r = [4.23, 5.5]
r = r ++ (([real]) l)
- sys.out.println(r)
+ assert r == [4.23,5.5,1.0,2.0,3.0]
diff --git a/tests/valid/ListAssign_Valid_1.sysout b/tests/valid/ListAssign_Valid_1.sysout
deleted file mode 100755
index 8500892c83..0000000000
--- a/tests/valid/ListAssign_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[1, 2, 3]
-[1, 2, 2]
diff --git a/tests/valid/ListAssign_Valid_1.whiley b/tests/valid/ListAssign_Valid_1.whiley
index 408810fbe8..83445e3190 100644
--- a/tests/valid/ListAssign_Valid_1.whiley
+++ b/tests/valid/ListAssign_Valid_1.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] arr1 = [1, 2, 3]
[int] arr2 = arr1
arr2[2] = 2
assert arr2[2] != |arr1|
- sys.out.println(arr1)
- sys.out.println(arr2)
+ assert arr1 == [1,2,3]
+ assert arr2 == [1,2,2]
diff --git a/tests/valid/ListAssign_Valid_11.sysout b/tests/valid/ListAssign_Valid_11.sysout
deleted file mode 100755
index 575c03774d..0000000000
--- a/tests/valid/ListAssign_Valid_11.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[5, 2, 3]
\ No newline at end of file
diff --git a/tests/valid/ListAssign_Valid_11.whiley b/tests/valid/ListAssign_Valid_11.whiley
index 84bf12ec1e..1c765f4e8a 100644
--- a/tests/valid/ListAssign_Valid_11.whiley
+++ b/tests/valid/ListAssign_Valid_11.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] a) -> [int]
// Input list cannot be empty
@@ -7,6 +7,7 @@ requires |a| > 0:
a[0] = 5
return a
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] b = [1, 2, 3]
- sys.out.println(f(b))
+ assume f(b) == [5,2,3]
+
diff --git a/tests/valid/ListAssign_Valid_12.sysout b/tests/valid/ListAssign_Valid_12.sysout
deleted file mode 100755
index 67fe5c5ecc..0000000000
--- a/tests/valid/ListAssign_Valid_12.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[1, 2, 3]
-[5, 2, 3]
-[1, 2, 3]
diff --git a/tests/valid/ListAssign_Valid_2.sysout b/tests/valid/ListAssign_Valid_2.sysout
deleted file mode 100755
index b5d8bb58d9..0000000000
--- a/tests/valid/ListAssign_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3]
diff --git a/tests/valid/ListAssign_Valid_2.whiley b/tests/valid/ListAssign_Valid_2.whiley
index fc2cc66468..892387e1b0 100644
--- a/tests/valid/ListAssign_Valid_2.whiley
+++ b/tests/valid/ListAssign_Valid_2.whiley
@@ -1,16 +1,17 @@
-import whiley.lang.*
+
type intlist is int | [int]
function f([intlist] l) -> any:
return l
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int|[int]] x
- if |sys.args| == 0:
+ if 0 == 0:
x = [1, 2, 3]
else:
x = [[1], [2, 3], [5]]
x[0] = 1
- sys.out.println(f(x))
+ //
+ assume f(x) == [1,2,3]
diff --git a/tests/valid/ListAssign_Valid_3.sysout b/tests/valid/ListAssign_Valid_3.sysout
deleted file mode 100755
index df0624f5b8..0000000000
--- a/tests/valid/ListAssign_Valid_3.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[[1, 2, 3, 4]]
-[[10, 2, 3, 4]]
diff --git a/tests/valid/ListAssign_Valid_3.whiley b/tests/valid/ListAssign_Valid_3.whiley
index 6cf630c543..529cc9f78f 100644
--- a/tests/valid/ListAssign_Valid_3.whiley
+++ b/tests/valid/ListAssign_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function update([[int]] ls) -> [[int]]
requires |ls| > 0 && |ls[0]| > 0:
@@ -12,9 +12,9 @@ requires |ls| > 0 && |ls[0]| > 0:
[[int]] nls = update(ls)
return (ls, nls)
-method main(System.Console sys) -> void:
+public export method test() -> void:
[[int]] nls
[[int]] ls = [[1, 2, 3, 4]]
(ls, nls) = f(ls)
- sys.out.println(ls)
- sys.out.println(nls)
+ assume ls == [[1,2,3,4]]
+ assume nls == [[10,2,3,4]]
diff --git a/tests/valid/ListAssign_Valid_4.sysout b/tests/valid/ListAssign_Valid_4.sysout
deleted file mode 100644
index 6c1b5a47bf..0000000000
--- a/tests/valid/ListAssign_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{flag:false,rows:[{colour:false,kind:0}]}
diff --git a/tests/valid/ListAssign_Valid_4.whiley b/tests/valid/ListAssign_Valid_4.whiley
index 937c5bcb5b..84cf7e8698 100644
--- a/tests/valid/ListAssign_Valid_4.whiley
+++ b/tests/valid/ListAssign_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant PAWN is 0
@@ -28,6 +28,6 @@ requires |board.rows| > 0:
board.rows[0] = BLACK_PAWN
return board
-method main(System.Console sys) -> void:
+public export method test() -> void:
Board r1 = {flag: false, rows: [WHITE_PAWN]}
- sys.out.println(f(r1))
+ assume f(r1) == {flag:false,rows:[{colour:false,kind:0}]}
diff --git a/tests/valid/ListAssign_Valid_5.sysout b/tests/valid/ListAssign_Valid_5.sysout
deleted file mode 100644
index 2154f166ff..0000000000
--- a/tests/valid/ListAssign_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[[1, null, 3], [4, 5, 2], [7, 8, 9]]
diff --git a/tests/valid/ListAssign_Valid_5.whiley b/tests/valid/ListAssign_Valid_5.whiley
index fe9ac551b3..481bc15336 100644
--- a/tests/valid/ListAssign_Valid_5.whiley
+++ b/tests/valid/ListAssign_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nint is null | int
@@ -13,7 +13,7 @@ requires to + 1 < |list[to]|:
list[to][to + 1] = tmp
return list
-method main(System.Console sys) -> void:
+public export method test() -> void:
[[nint]] ls = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
ls = move(0, 1, ls)
- sys.out.println(ls)
+ assume ls == [[1, null, 3], [4, 5, 2], [7, 8, 9]]
diff --git a/tests/valid/ListAssign_Valid_6.sysout b/tests/valid/ListAssign_Valid_6.sysout
deleted file mode 100755
index f6323e2f17..0000000000
--- a/tests/valid/ListAssign_Valid_6.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[1, 2, 4]
-[1, 2, 3]
diff --git a/tests/valid/ListAssign_Valid_6.whiley b/tests/valid/ListAssign_Valid_6.whiley
index 053cb0efaf..5c129d92aa 100644
--- a/tests/valid/ListAssign_Valid_6.whiley
+++ b/tests/valid/ListAssign_Valid_6.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] arr1 = [1, 2, 4]
[int] arr2 = arr1
arr2[2] = 3
assert arr2[2] == |arr1|
- sys.out.println(arr1)
- sys.out.println(arr2)
+ assert arr1 == [1,2,4]
+ assert arr2 == [1,2,3]
diff --git a/tests/valid/ListAssign_Valid_7.sysout b/tests/valid/ListAssign_Valid_7.sysout
deleted file mode 100755
index 99055f72a6..0000000000
--- a/tests/valid/ListAssign_Valid_7.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[1, 2, 64, 1, 2, 3]
-[1, 2, 64, 1, 2, 3]
diff --git a/tests/valid/ListAssign_Valid_7.whiley b/tests/valid/ListAssign_Valid_7.whiley
index 7261427b6e..a0b25a8901 100644
--- a/tests/valid/ListAssign_Valid_7.whiley
+++ b/tests/valid/ListAssign_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int i) -> [int]:
[int] arr1 = [1, 2, 64]
@@ -10,6 +10,6 @@ function f(int i) -> [int]:
assert arr2[2] == |arr1|
return arr1 ++ arr2
-method main(System.Console sys) -> void:
- sys.out.println(f(2))
- sys.out.println(f(3))
+public export method test() -> void:
+ assume f(2) == [1, 2, 64, 1, 2, 3]
+ assume f(3) == [1, 2, 64, 1, 2, 3]
diff --git a/tests/valid/ListAssign_Valid_8.sysout b/tests/valid/ListAssign_Valid_8.sysout
deleted file mode 100755
index 11753de5a2..0000000000
--- a/tests/valid/ListAssign_Valid_8.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-[1, 2, 3]
-[0]
-[3, 4, 5]
-[0]
diff --git a/tests/valid/ListAssign_Valid_8.whiley b/tests/valid/ListAssign_Valid_8.whiley
index 28fe8cf7aa..b701a258b6 100644
--- a/tests/valid/ListAssign_Valid_8.whiley
+++ b/tests/valid/ListAssign_Valid_8.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[[int]] a1 = [[1, 2, 3], [0]]
[[int]] a2 = a1
a2[0] = [3, 4, 5]
- sys.out.println(a1[0])
- sys.out.println(a1[1])
- sys.out.println(a2[0])
- sys.out.println(a2[1])
+ assert a1[0] == [1,2,3]
+ assert a1[1] == [0]
+ assert a2[0] == [3,4,5]
+ assert a2[1] == [0]
diff --git a/tests/valid/ListAssign_Valid_9.sysout b/tests/valid/ListAssign_Valid_9.sysout
deleted file mode 100755
index 92c5e8d4ef..0000000000
--- a/tests/valid/ListAssign_Valid_9.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-1
-2
-0
-2
diff --git a/tests/valid/ListAssign_Valid_9.whiley b/tests/valid/ListAssign_Valid_9.whiley
index 16e96ce01f..2ae12cd5fe 100644
--- a/tests/valid/ListAssign_Valid_9.whiley
+++ b/tests/valid/ListAssign_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f() -> ([int] rs)
// Returned list must have at least two elements
@@ -6,11 +6,11 @@ ensures |rs| > 1:
//
return [1, 2]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] a1 = f()
[int] a2 = f()
a2[0] = 0
- sys.out.println(a1[0])
- sys.out.println(a1[1])
- sys.out.println(a2[0])
- sys.out.println(a2[1])
+ assume a1[0] == 1
+ assume a1[1] == 2
+ assert a2[0] == 0
+ assume a2[1] == 2
diff --git a/tests/valid/ListConversion_Valid_1.sysout b/tests/valid/ListConversion_Valid_1.sysout
deleted file mode 100755
index 2aa307052c..0000000000
--- a/tests/valid/ListConversion_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1.0, 2.0, 3.0]
diff --git a/tests/valid/ListConversion_Valid_1.whiley b/tests/valid/ListConversion_Valid_1.whiley
index 379601c687..572eafe7b2 100644
--- a/tests/valid/ListConversion_Valid_1.whiley
+++ b/tests/valid/ListConversion_Valid_1.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
function f([real] ls) -> [real]:
return ls
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] ls = [1,2,3]
- sys.out.println(f(([real]) ls))
+ assume f(([real]) ls) == [1.0,2.0,3.0]
diff --git a/tests/valid/ListElemOf_Valid_1.sysout b/tests/valid/ListElemOf_Valid_1.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ListElemOf_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ListElemOf_Valid_1.whiley b/tests/valid/ListElemOf_Valid_1.whiley
index 9ca580a67b..b9e5957075 100644
--- a/tests/valid/ListElemOf_Valid_1.whiley
+++ b/tests/valid/ListElemOf_Valid_1.whiley
@@ -1,8 +1,6 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] xs = [1, 2, 3, 3, 3, 4]
- if 1 in xs:
- sys.out.println(1)
- if 5 in xs:
- sys.out.println(5)
+ assume 1 in xs
+ assume !(5 in xs)
diff --git a/tests/valid/ListEmpty_Valid_1.sysout b/tests/valid/ListEmpty_Valid_1.sysout
deleted file mode 100755
index 7fd98da3b0..0000000000
--- a/tests/valid/ListEmpty_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[1, 4]
-[]
diff --git a/tests/valid/ListEmpty_Valid_1.whiley b/tests/valid/ListEmpty_Valid_1.whiley
index 6e9e83b6e1..d3bff25308 100644
--- a/tests/valid/ListEmpty_Valid_1.whiley
+++ b/tests/valid/ListEmpty_Valid_1.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
function f([int] xs) -> [int]:
return xs
-method main(System.Console sys) -> void:
- sys.out.println(f([1, 4]))
- sys.out.println(f([]))
+public export method test() -> void:
+ assume f([1, 4]) == [1,4]
+ assume f([]) == []
diff --git a/tests/valid/ListEquals_Valid_1.sysout b/tests/valid/ListEquals_Valid_1.sysout
deleted file mode 100755
index 5879b86637..0000000000
--- a/tests/valid/ListEquals_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-true
\ No newline at end of file
diff --git a/tests/valid/ListEquals_Valid_1.whiley b/tests/valid/ListEquals_Valid_1.whiley
index 6da45aa42c..9c911952ef 100644
--- a/tests/valid/ListEquals_Valid_1.whiley
+++ b/tests/valid/ListEquals_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] xs, [real] ys) -> bool:
if (([real]) xs) == ys:
@@ -6,7 +6,7 @@ function f([int] xs, [real] ys) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f([1, 4], [1.0, 4.0]))
- sys.out.println(f([1, 4], [1.0, 4.2]))
- sys.out.println(f([], []))
+public export method test() -> void:
+ assume f([1, 4], [1.0, 4.0]) == true
+ assume f([1, 4], [1.0, 4.2]) == false
+ assume f([], []) == true
diff --git a/tests/valid/ListGenerator_Valid_1.sysout b/tests/valid/ListGenerator_Valid_1.sysout
deleted file mode 100755
index 1f242fa6f0..0000000000
--- a/tests/valid/ListGenerator_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-3
-3
-3
diff --git a/tests/valid/ListGenerator_Valid_1.whiley b/tests/valid/ListGenerator_Valid_1.whiley
index 5d49c93f25..ccf7b90074 100644
--- a/tests/valid/ListGenerator_Valid_1.whiley
+++ b/tests/valid/ListGenerator_Valid_1.whiley
@@ -1,14 +1,12 @@
-import whiley.lang.*
+
function f([int] x) -> int
// Input list cannot be empty
requires |x| > 0:
//
int z = |x|
- debug Any.toString(z) ++ "\n"
- debug Any.toString(x[z - 1]) ++ "\n"
- return z
+ return x[z-1]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] arr = [1, 2, 3]
- sys.out.println(f(arr))
+ assume f(arr) == 3
diff --git a/tests/valid/ListGenerator_Valid_2.sysout b/tests/valid/ListGenerator_Valid_2.sysout
deleted file mode 100755
index a5c8806279..0000000000
--- a/tests/valid/ListGenerator_Valid_2.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3
-3
diff --git a/tests/valid/ListGenerator_Valid_2.whiley b/tests/valid/ListGenerator_Valid_2.whiley
index 1e27cd2e3d..5580540941 100644
--- a/tests/valid/ListGenerator_Valid_2.whiley
+++ b/tests/valid/ListGenerator_Valid_2.whiley
@@ -1,10 +1,9 @@
-import whiley.lang.*
-method f(System.Console sys, [int] x) -> void:
+
+method f([int] x) -> void:
int z = |x|
- sys.out.println(z)
- sys.out.println(x[z - 1])
+ assume x[z - 1] == 3
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] arr = [1, 2, 3]
- f(sys, arr)
+ f(arr)
diff --git a/tests/valid/ListGenerator_Valid_3.sysout b/tests/valid/ListGenerator_Valid_3.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/ListGenerator_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/ListGenerator_Valid_3.whiley b/tests/valid/ListGenerator_Valid_3.whiley
index a1768c1de7..1e0970412b 100644
--- a/tests/valid/ListGenerator_Valid_3.whiley
+++ b/tests/valid/ListGenerator_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([[int]] x) -> int
// Input list cannot be empty
@@ -9,6 +9,6 @@ requires |x| > 0:
else:
return 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
[[int]] arr = [[1, 2, 3], [1]]
- sys.out.println(f(arr))
+ assume f(arr) == 2
diff --git a/tests/valid/ListGenerator_Valid_4.sysout b/tests/valid/ListGenerator_Valid_4.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/ListGenerator_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/ListGenerator_Valid_5.sysout b/tests/valid/ListGenerator_Valid_5.sysout
deleted file mode 100755
index 573541ac97..0000000000
--- a/tests/valid/ListGenerator_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-0
diff --git a/tests/valid/ListGenerator_Valid_5.whiley b/tests/valid/ListGenerator_Valid_5.whiley
index 766e3b5dcf..2ca2362dc6 100644
--- a/tests/valid/ListGenerator_Valid_5.whiley
+++ b/tests/valid/ListGenerator_Valid_5.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
function f([int] x) -> int:
return |x|
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] arr = []
- sys.out.println(f(arr))
+ assume f(arr) == 0
diff --git a/tests/valid/ListLength_Valid_1.sysout b/tests/valid/ListLength_Valid_1.sysout
deleted file mode 100644
index 043e5719ab..0000000000
--- a/tests/valid/ListLength_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3
-0
diff --git a/tests/valid/ListLength_Valid_1.whiley b/tests/valid/ListLength_Valid_1.whiley
index 7e5372386f..d2637d2307 100644
--- a/tests/valid/ListLength_Valid_1.whiley
+++ b/tests/valid/ListLength_Valid_1.whiley
@@ -1,12 +1,10 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
function f([int] xs) -> nat:
return |xs|
-method main(System.Console sys) -> void:
- nat rs = f([1, 2, 3])
- sys.out.println(rs)
- rs = f([])
- sys.out.println(rs)
+public export method test() -> void:
+ assume f([1, 2, 3]) == 3
+ assume f([]) == 0
diff --git a/tests/valid/ListLength_Valid_2.sysout b/tests/valid/ListLength_Valid_2.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ListLength_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ListLength_Valid_2.whiley b/tests/valid/ListLength_Valid_2.whiley
index ba641239a6..9a62521450 100644
--- a/tests/valid/ListLength_Valid_2.whiley
+++ b/tests/valid/ListLength_Valid_2.whiley
@@ -1,6 +1,5 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] arr = [1, 2, 3]
assert |arr| == 3
- sys.out.println(arr[0])
diff --git a/tests/valid/ListLength_Valid_3.sysout b/tests/valid/ListLength_Valid_3.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/ListLength_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/ListLength_Valid_3.whiley b/tests/valid/ListLength_Valid_3.whiley
index 2dbc53aaca..aa6d9ae2fe 100644
--- a/tests/valid/ListLength_Valid_3.whiley
+++ b/tests/valid/ListLength_Valid_3.whiley
@@ -1,8 +1,7 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] arr = [1, 2, 3]
assert arr[0] < |arr|
assert arr[1] < |arr|
assert arr[2] == |arr|
- sys.out.println(arr[0])
diff --git a/tests/valid/ListRange_Valid_1.sysout b/tests/valid/ListRange_Valid_1.sysout
deleted file mode 100644
index 791a97e6ee..0000000000
--- a/tests/valid/ListRange_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
diff --git a/tests/valid/ListRange_Valid_1.whiley b/tests/valid/ListRange_Valid_1.whiley
index 78cb3e2e9a..cceaf782e4 100644
--- a/tests/valid/ListRange_Valid_1.whiley
+++ b/tests/valid/ListRange_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
- sys.out.println(0 .. 17)
+
+public export method test() -> void:
+ assert (0 .. 7) == [0,1,2,3,4,5,6]
diff --git a/tests/valid/ListSublist_Valid_1.sysout b/tests/valid/ListSublist_Valid_1.sysout
deleted file mode 100755
index 9902f17848..0000000000
--- a/tests/valid/ListSublist_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-28
diff --git a/tests/valid/ListSublist_Valid_1.whiley b/tests/valid/ListSublist_Valid_1.whiley
index 082f1c7c1f..fdd8df3925 100644
--- a/tests/valid/ListSublist_Valid_1.whiley
+++ b/tests/valid/ListSublist_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type posintlist is ([int] xs) where no { x in xs | x < 0 }
@@ -11,6 +11,6 @@ ensures result >= 0:
[int] rest = ls[1..|ls|]
return ls[0] + sum(rest)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int c = sum([1, 2, 3, 4, 5, 6, 7])
- sys.out.println(c)
+ assume c == 28
diff --git a/tests/valid/ListSublist_Valid_2.sysout b/tests/valid/ListSublist_Valid_2.sysout
deleted file mode 100755
index 9902f17848..0000000000
--- a/tests/valid/ListSublist_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-28
diff --git a/tests/valid/ListSublist_Valid_2.whiley b/tests/valid/ListSublist_Valid_2.whiley
index 4d1b793852..1b2c6ce9bf 100644
--- a/tests/valid/ListSublist_Valid_2.whiley
+++ b/tests/valid/ListSublist_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type posintlist is [int]
@@ -9,6 +9,6 @@ function sum(posintlist ls) -> int:
[int] rest = ls[1..|ls|]
return ls[0] + sum(rest)
-method main(System.Console sys):
+public export method test():
int c = sum([1, 2, 3, 4, 5, 6, 7])
- sys.out.println(c)
+ assume c == 28
diff --git a/tests/valid/ListSublist_Valid_3.sysout b/tests/valid/ListSublist_Valid_3.sysout
deleted file mode 100644
index a898910286..0000000000
--- a/tests/valid/ListSublist_Valid_3.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[2, 3, 4]
-[]
diff --git a/tests/valid/ListSublist_Valid_3.whiley b/tests/valid/ListSublist_Valid_3.whiley
index 44e5ad7932..f9200e1831 100644
--- a/tests/valid/ListSublist_Valid_3.whiley
+++ b/tests/valid/ListSublist_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -10,6 +10,6 @@ requires all { i in 1 .. |ls| | ls[i] >= 0 }:
//
return ls[1..|ls|]
-method main(System.Console sys) -> void:
- sys.out.println(tail([1, 2, 3, 4]))
- sys.out.println(tail([1]))
+public export method test() -> void:
+ assume tail([1, 2, 3, 4]) == [2,3,4]
+ assume tail([1]) == []
diff --git a/tests/valid/ListSublist_Valid_4.sysout b/tests/valid/ListSublist_Valid_4.sysout
deleted file mode 100755
index 717beb2316..0000000000
--- a/tests/valid/ListSublist_Valid_4.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[1, 2, 3]
-[1, 2]
diff --git a/tests/valid/ListSublist_Valid_4.whiley b/tests/valid/ListSublist_Valid_4.whiley
index e64d8092aa..b57d20bfd2 100644
--- a/tests/valid/ListSublist_Valid_4.whiley
+++ b/tests/valid/ListSublist_Valid_4.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] list = [1, 2, 3]
[int] sublist = list[0..2]
- sys.out.println(list)
- sys.out.println(sublist)
+ assert list == [1,2,3]
+ assert sublist == [1,2]
diff --git a/tests/valid/ListSublist_Valid_5.sysout b/tests/valid/ListSublist_Valid_5.sysout
deleted file mode 100755
index 306cdea097..0000000000
--- a/tests/valid/ListSublist_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
--10588848120
diff --git a/tests/valid/ListSublist_Valid_5.whiley b/tests/valid/ListSublist_Valid_5.whiley
index eb2c6e9199..94c571328b 100644
--- a/tests/valid/ListSublist_Valid_5.whiley
+++ b/tests/valid/ListSublist_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type posintlist is [int]
@@ -9,6 +9,6 @@ function sum(posintlist ls) -> int:
[int] rest = ls[1..|ls|]
return ls[0] + sum(rest)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int c = sum([-12987987234, -1, 2, 409234, 2398729879])
- sys.out.println(c)
+ assume c == -10588848120
diff --git a/tests/valid/MessageRef_Valid_1.sysout b/tests/valid/MessageRef_Valid_1.sysout
deleted file mode 100644
index fc902f4f95..0000000000
--- a/tests/valid/MessageRef_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-124
diff --git a/tests/valid/MessageRef_Valid_1.whiley b/tests/valid/MessageRef_Valid_1.whiley
index 8bc1a4b242..4dbf497fff 100644
--- a/tests/valid/MessageRef_Valid_1.whiley
+++ b/tests/valid/MessageRef_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type MyProc is &{int position}
@@ -7,10 +7,10 @@ type MyMeth is method(MyProc, int) -> int
method read(MyProc this, int x) -> int:
return x + 123
-method test(MyMeth m, MyProc proc) -> int:
+public export method test(MyMeth m, MyProc proc) -> int:
return m(proc,1)
-method main(System.Console sys) -> void:
+public export method test() -> void:
MyProc p = new {position: 0}
int r = test(&read, p)
- sys.out.println(r)
+ assume r == 124
diff --git a/tests/valid/MessageRef_Valid_2.sysout b/tests/valid/MessageRef_Valid_2.sysout
deleted file mode 100644
index a949a93dfc..0000000000
--- a/tests/valid/MessageRef_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-128
diff --git a/tests/valid/MessageRef_Valid_2.whiley b/tests/valid/MessageRef_Valid_2.whiley
index 35f9b96865..91fef2e13a 100644
--- a/tests/valid/MessageRef_Valid_2.whiley
+++ b/tests/valid/MessageRef_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type FileReader is &{int position}
@@ -15,8 +15,8 @@ method openReader() -> Reader:
FileReader proc = new {position: 123}
return {thus: proc, read: &read}
-method main(System.Console sys) -> void:
+public export method test() -> void:
Reader reader = openReader()
FileReader target = reader.thus
int data = reader.read(target, 1)
- sys.out.println(data)
+ assume data == 124
diff --git a/tests/valid/MessageSend_Valid_1.sysout b/tests/valid/MessageSend_Valid_1.sysout
deleted file mode 100644
index d00491fd7e..0000000000
--- a/tests/valid/MessageSend_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/MessageSend_Valid_1.whiley b/tests/valid/MessageSend_Valid_1.whiley
index b248cef387..b118c04c54 100644
--- a/tests/valid/MessageSend_Valid_1.whiley
+++ b/tests/valid/MessageSend_Valid_1.whiley
@@ -1,12 +1,11 @@
-import whiley.lang.*
-import print from whiley.lang.*
-type MyObject is &{System.Console sys}
+
+type MyObject is &{int field}
method f(MyObject this, int x) -> void:
- this->sys.out.println(x)
+ assume x == 1
-method main(System.Console sys) -> void:
- MyObject m = new {sys: sys}
+public export method test() -> void:
+ MyObject m = new {field: 1}
f(m,1)
- sys.out.print_s("")
+
diff --git a/tests/valid/MessageSend_Valid_2.sysout b/tests/valid/MessageSend_Valid_2.sysout
deleted file mode 100644
index 190a18037c..0000000000
--- a/tests/valid/MessageSend_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-123
diff --git a/tests/valid/MessageSend_Valid_2.whiley b/tests/valid/MessageSend_Valid_2.whiley
index ff9d7f668e..f5b78f1610 100644
--- a/tests/valid/MessageSend_Valid_2.whiley
+++ b/tests/valid/MessageSend_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Proc is &{int state}
@@ -8,6 +8,6 @@ method get(Proc this) -> int:
method f(Proc x) -> int:
return get(x)
-method main(System.Console sys) -> void:
+public export method test() -> void:
Proc proc = new {state: 123}
- sys.out.println(f(proc))
+ assume f(proc) == 123
diff --git a/tests/valid/MessageSend_Valid_3.sysout b/tests/valid/MessageSend_Valid_3.sysout
deleted file mode 100644
index de2523ebdc..0000000000
--- a/tests/valid/MessageSend_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3, 1]
diff --git a/tests/valid/MessageSend_Valid_3.whiley b/tests/valid/MessageSend_Valid_3.whiley
index 85d1c4c698..26c2fd2638 100644
--- a/tests/valid/MessageSend_Valid_3.whiley
+++ b/tests/valid/MessageSend_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Proc is &{int state}
@@ -8,6 +8,6 @@ method get(Proc this) -> int:
method f(Proc x) -> [int]:
return [1, 2, 3, get(x)]
-method main(System.Console sys) -> void:
+public export method test() -> void:
Proc proc = new {state: 1}
- sys.out.println(f(proc))
+ assume f(proc) == [1,2,3,1]
diff --git a/tests/valid/MessageSend_Valid_4.sysout b/tests/valid/MessageSend_Valid_4.sysout
deleted file mode 100644
index f134b0edf2..0000000000
--- a/tests/valid/MessageSend_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{x:1,y:1}
diff --git a/tests/valid/MessageSend_Valid_4.whiley b/tests/valid/MessageSend_Valid_4.whiley
index 5eb6ccff26..6f879e594c 100644
--- a/tests/valid/MessageSend_Valid_4.whiley
+++ b/tests/valid/MessageSend_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type wmcr6tup is {int y, int x}
@@ -10,6 +10,6 @@ method get(Proc this) -> int:
method f(Proc x, int y) -> wmcr6tup:
return {y: get(x), x: y}
-method main(System.Console sys) -> void:
+public export method test() -> void:
Proc proc = new {state: 1}
- sys.out.println(f(proc, 1))
+ assume f(proc, 2) == {y: 1, x: 2}
diff --git a/tests/valid/MessageSend_Valid_5.sysout b/tests/valid/MessageSend_Valid_5.sysout
deleted file mode 100644
index b8deb9b6f0..0000000000
--- a/tests/valid/MessageSend_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-SUM: 228
diff --git a/tests/valid/MessageSend_Valid_5.whiley b/tests/valid/MessageSend_Valid_5.whiley
index 05becdd02d..8a9112fc75 100644
--- a/tests/valid/MessageSend_Valid_5.whiley
+++ b/tests/valid/MessageSend_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Sum is &{int result, [int] items}
@@ -14,9 +14,8 @@ method get(Sum this) -> int:
method create([int] items) -> Sum:
return new {result: 0, items: items}
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] data = [1, 3, 5, 7, 3, 198, 1, 4, 6]
Sum sum = create(data)
start(sum)
- int r = get(sum)
- sys.out.println_s("SUM: " ++ Any.toString(r))
+ assume get(sum) == 228
diff --git a/tests/valid/MethodCall_Valid_1.sysout b/tests/valid/MethodCall_Valid_1.sysout
deleted file mode 100755
index 56a6051ca2..0000000000
--- a/tests/valid/MethodCall_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
\ No newline at end of file
diff --git a/tests/valid/MethodCall_Valid_1.whiley b/tests/valid/MethodCall_Valid_1.whiley
index 4a0f80586d..81294bad60 100644
--- a/tests/valid/MethodCall_Valid_1.whiley
+++ b/tests/valid/MethodCall_Valid_1.whiley
@@ -1,8 +1,7 @@
-import whiley.lang.*
-import print from whiley.lang.*
-method f(System.Console sys, int x) -> void:
- sys.out.println(x)
-method main(System.Console sys) -> void:
- f(sys, 1)
+method f(int x) -> void:
+ skip
+
+public export method test() -> void:
+ f(1)
diff --git a/tests/valid/MethodCall_Valid_2.sysout b/tests/valid/MethodCall_Valid_2.sysout
deleted file mode 100755
index de2523ebdc..0000000000
--- a/tests/valid/MethodCall_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3, 1]
diff --git a/tests/valid/MethodCall_Valid_2.whiley b/tests/valid/MethodCall_Valid_2.whiley
index eaf5b97dc4..cf3a8bf8a2 100644
--- a/tests/valid/MethodCall_Valid_2.whiley
+++ b/tests/valid/MethodCall_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
method get() -> int:
return 1
@@ -6,6 +6,6 @@ method get() -> int:
method f() -> [int]:
return [1, 2, 3, get()]
-method main(System.Console sys) -> void:
+public export method test() -> void:
&{int state} proc = new {state: 1}
- sys.out.println(f())
+ assume f() == [1,2,3,1]
diff --git a/tests/valid/MethodCall_Valid_3.sysout b/tests/valid/MethodCall_Valid_3.sysout
deleted file mode 100755
index f134b0edf2..0000000000
--- a/tests/valid/MethodCall_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{x:1,y:1}
diff --git a/tests/valid/MethodCall_Valid_3.whiley b/tests/valid/MethodCall_Valid_3.whiley
index 522361f208..e8d9a82315 100644
--- a/tests/valid/MethodCall_Valid_3.whiley
+++ b/tests/valid/MethodCall_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type wmcr6tup is {int y, int x}
@@ -8,5 +8,5 @@ method get() -> int:
method f(int y) -> wmcr6tup:
return {y: get(), x: y}
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f(2) == {y: 1, x: 2}
diff --git a/tests/valid/MethodCall_Valid_4.sysout b/tests/valid/MethodCall_Valid_4.sysout
deleted file mode 100755
index 190a18037c..0000000000
--- a/tests/valid/MethodCall_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-123
diff --git a/tests/valid/MethodCall_Valid_4.whiley b/tests/valid/MethodCall_Valid_4.whiley
index e7a6e032b8..56731d6ca7 100644
--- a/tests/valid/MethodCall_Valid_4.whiley
+++ b/tests/valid/MethodCall_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Sum is &{int result, [int] items}
@@ -30,9 +30,9 @@ type pst is method ([int])->int
method sum(pst m, [int] data) -> int:
return m(data)
-method main(System.Console sys) -> void:
- [int] data = [1, 3, 5, 7, 3, 198, 1, 4, 6]
+public export method test() -> void:
+ [int] data = [1, 3, 5, 7, 3, 93, 1, 4, 6]
int s1 = sum(&parSum, data)
- sys.out.println_s("SUM: " ++ Any.toString(s1))
+ assume s1 == 123
int s2 = sum(&seqSum, data)
- sys.out.println_s("SUM: " ++ Any.toString(s2))
+ assume s1 == 123
diff --git a/tests/valid/MethodRef_Valid_1.sysout b/tests/valid/MethodRef_Valid_1.sysout
deleted file mode 100644
index fc902f4f95..0000000000
--- a/tests/valid/MethodRef_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-124
diff --git a/tests/valid/MethodRef_Valid_1.whiley b/tests/valid/MethodRef_Valid_1.whiley
index 54189df667..becce9e7b7 100644
--- a/tests/valid/MethodRef_Valid_1.whiley
+++ b/tests/valid/MethodRef_Valid_1.whiley
@@ -1,13 +1,13 @@
-import whiley.lang.*
+
type MyMeth is method(int) -> int
method read(int x) -> int:
return x + 123
-method test(MyMeth m) -> int:
+public export method test(MyMeth m) -> int:
return m(1)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int r = test(&read)
- sys.out.println(r)
+ assume r == 124
diff --git a/tests/valid/MethodRef_Valid_2.sysout b/tests/valid/MethodRef_Valid_2.sysout
deleted file mode 100644
index d00491fd7e..0000000000
--- a/tests/valid/MethodRef_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/MethodRef_Valid_2.whiley b/tests/valid/MethodRef_Valid_2.whiley
index 3b4d51c027..1a99c25417 100644
--- a/tests/valid/MethodRef_Valid_2.whiley
+++ b/tests/valid/MethodRef_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Reader is {
method read(int) -> int
@@ -10,7 +10,7 @@ method f(int amount) -> int:
method m(Reader r, int x) -> int:
return r.read(x)
-method main(System.Console sys) -> void:
+public export method test() -> void:
Reader reader = {read: &f}
int data = m(reader, 1)
- sys.out.println(data)
+ assume data == 1
diff --git a/tests/valid/Method_Valid_1.sysout b/tests/valid/Method_Valid_1.sysout
deleted file mode 100644
index fb77a063c2..0000000000
--- a/tests/valid/Method_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[2, 1, 0, 0, 0, 0, 0, 0, 0]
\ No newline at end of file
diff --git a/tests/valid/Method_Valid_1.whiley b/tests/valid/Method_Valid_1.whiley
index 38ea258d77..da13e828a8 100644
--- a/tests/valid/Method_Valid_1.whiley
+++ b/tests/valid/Method_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant BLANK is 0
constant CROSS is 1
@@ -18,13 +18,13 @@ public function numPieces(Board board, Piece piece) -> int:
count = count + 1
return count
-method update(System.Console console, Board b) -> Board:
+method update(Board b) -> Board:
b[0] = CIRCLE
b[1] = CROSS
b[0] = CIRCLE
return b
-method main(System.Console console) -> void:
+public export method test() -> void:
Board b = EmptyBoard()
- b = update(console, b)
- debug "" ++ Any.toString(b)
+ b = update(b)
+ assume b == [2, 1, 0, 0, 0, 0, 0, 0, 0]
diff --git a/tests/valid/MultiLineComment_Valid_1.sysout b/tests/valid/MultiLineComment_Valid_1.sysout
deleted file mode 100644
index 7813681f5b..0000000000
--- a/tests/valid/MultiLineComment_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-5
\ No newline at end of file
diff --git a/tests/valid/MultiLineComment_Valid_1.whiley b/tests/valid/MultiLineComment_Valid_1.whiley
index f07a963fae..67bbdb38ee 100644
--- a/tests/valid/MultiLineComment_Valid_1.whiley
+++ b/tests/valid/MultiLineComment_Valid_1.whiley
@@ -1,4 +1,7 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
- sys.out.println(5)
+
+/**
+ * This is a multiline comment
+ */
+public export method test() -> void:
+ assert true == true
diff --git a/tests/valid/MultiLineComment_Valid_2.sysout b/tests/valid/MultiLineComment_Valid_2.sysout
deleted file mode 100644
index 7813681f5b..0000000000
--- a/tests/valid/MultiLineComment_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-5
\ No newline at end of file
diff --git a/tests/valid/MultiLineComment_Valid_2.whiley b/tests/valid/MultiLineComment_Valid_2.whiley
index f07a963fae..e3beba52fa 100644
--- a/tests/valid/MultiLineComment_Valid_2.whiley
+++ b/tests/valid/MultiLineComment_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
- sys.out.println(5)
+
+public export method test() -> void:
+ assert 5 == 5 /* a comment */
diff --git a/tests/valid/NegationType_Valid_1.sysout b/tests/valid/NegationType_Valid_1.sysout
deleted file mode 100644
index b0d90a0f27..0000000000
--- a/tests/valid/NegationType_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-[1, 2, 3]
diff --git a/tests/valid/NegationType_Valid_1.whiley b/tests/valid/NegationType_Valid_1.whiley
index 87b6d1c48b..9da7370422 100644
--- a/tests/valid/NegationType_Valid_1.whiley
+++ b/tests/valid/NegationType_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(any x) -> !null:
if x is null:
@@ -6,6 +6,6 @@ function f(any x) -> !null:
else:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f([1, 2, 3]))
+public export method test() -> void:
+ assume f(1) == 1
+ assume f([1, 2, 3]) == [1,2,3]
diff --git a/tests/valid/NegationType_Valid_2.sysout b/tests/valid/NegationType_Valid_2.sysout
deleted file mode 100644
index d00491fd7e..0000000000
--- a/tests/valid/NegationType_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/NegationType_Valid_2.whiley b/tests/valid/NegationType_Valid_2.whiley
index b11f0bb90d..977057dc19 100644
--- a/tests/valid/NegationType_Valid_2.whiley
+++ b/tests/valid/NegationType_Valid_2.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f(int x) -> !null:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f(1) == 1
diff --git a/tests/valid/NegationType_Valid_3.sysout b/tests/valid/NegationType_Valid_3.sysout
deleted file mode 100644
index 06ae699f22..0000000000
--- a/tests/valid/NegationType_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-"Hello World"
diff --git a/tests/valid/NegationType_Valid_3.whiley b/tests/valid/NegationType_Valid_3.whiley
index b1884deca2..4174a4d1ff 100644
--- a/tests/valid/NegationType_Valid_3.whiley
+++ b/tests/valid/NegationType_Valid_3.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f([int] x) -> !null & !int:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f("Hello World"))
+public export method test() -> void:
+ assume f("Hello World") == "Hello World"
diff --git a/tests/valid/NegationType_Valid_4.sysout b/tests/valid/NegationType_Valid_4.sysout
deleted file mode 100644
index 0e0f29b77b..0000000000
--- a/tests/valid/NegationType_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
diff --git a/tests/valid/NegationType_Valid_4.whiley b/tests/valid/NegationType_Valid_4.whiley
index 63efee4b11..6ee1aebb6a 100644
--- a/tests/valid/NegationType_Valid_4.whiley
+++ b/tests/valid/NegationType_Valid_4.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f([int] x) -> !null | int:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f("Hello World"))
+public export method test() -> void:
+ assume f("Hello World") == "Hello World"
diff --git a/tests/valid/OpenRecord_Valid_1.sysout b/tests/valid/OpenRecord_Valid_1.sysout
deleted file mode 100644
index 01e79c32a8..0000000000
--- a/tests/valid/OpenRecord_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-2
-3
diff --git a/tests/valid/OpenRecord_Valid_1.whiley b/tests/valid/OpenRecord_Valid_1.whiley
index dff0537b8d..7451bca1b9 100644
--- a/tests/valid/OpenRecord_Valid_1.whiley
+++ b/tests/valid/OpenRecord_Valid_1.whiley
@@ -1,14 +1,14 @@
-import whiley.lang.*
+
type OpenRecord is {int field, ...}
function getField(OpenRecord r) -> int:
return r.field
-method main(System.Console sys) -> void:
+public export method test() -> void:
OpenRecord r = {field: 1}
- sys.out.println(getField(r))
+ assume getField(r) == 1
r = {field: 2, x: "hello"}
- sys.out.println(getField(r))
+ assume getField(r) == 2
r = {field: 3, y: 2, x: 1}
- sys.out.println(getField(r))
+ assume getField(r) == 3
diff --git a/tests/valid/OpenRecord_Valid_10.sysout b/tests/valid/OpenRecord_Valid_10.sysout
deleted file mode 100644
index ab8c78fdc1..0000000000
--- a/tests/valid/OpenRecord_Valid_10.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-MATCHED: false
-MATCHED: true
diff --git a/tests/valid/OpenRecord_Valid_10.whiley b/tests/valid/OpenRecord_Valid_10.whiley
index 4fed7055ee..e5d9f3aca9 100644
--- a/tests/valid/OpenRecord_Valid_10.whiley
+++ b/tests/valid/OpenRecord_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type string is [int]
type Attribute is {string name, ...}
@@ -11,8 +11,8 @@ function match(Attribute attr) -> bool:
else:
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
Attribute r = {name: "Hello"}
- sys.out.println_s("MATCHED: " ++ Any.toString(match(r)))
+ assume match(r) == false
r = {maxLocals: 0, maxStack: 0, name: "Code", data: []}
- sys.out.println_s("MATCHED: " ++ Any.toString(match(r)))
+ assume match(r) == true
diff --git a/tests/valid/OpenRecord_Valid_2.sysout b/tests/valid/OpenRecord_Valid_2.sysout
deleted file mode 100644
index 206a5a07df..0000000000
--- a/tests/valid/OpenRecord_Valid_2.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-null
diff --git a/tests/valid/OpenRecord_Valid_2.whiley b/tests/valid/OpenRecord_Valid_2.whiley
index 72d7a53729..01bf219c42 100644
--- a/tests/valid/OpenRecord_Valid_2.whiley
+++ b/tests/valid/OpenRecord_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant Short is 3
constant Int is 4
@@ -27,8 +27,8 @@ function codeLength(Attribute a) -> null | int:
return |a.data|
return null
-public method main(System.Console sys) -> void:
+public export method test() -> void:
Attribute attr = {name: "Code", data: [{op: 2, offset: 1}]}
- sys.out.println(codeLength(attr))
+ assume codeLength(attr) == 1
attr = {name: "Blah"}
- sys.out.println(codeLength(attr))
+ assume codeLength(attr) == null
diff --git a/tests/valid/OpenRecord_Valid_3.sysout b/tests/valid/OpenRecord_Valid_3.sysout
deleted file mode 100644
index 190a18037c..0000000000
--- a/tests/valid/OpenRecord_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-123
diff --git a/tests/valid/OpenRecord_Valid_3.whiley b/tests/valid/OpenRecord_Valid_3.whiley
index 71b1cceb75..45100ae06d 100644
--- a/tests/valid/OpenRecord_Valid_3.whiley
+++ b/tests/valid/OpenRecord_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Object is {
function fn(Object)->int,
@@ -11,6 +11,6 @@ public function myFn(Object o) -> int:
public function get(Object o) -> int:
return o.fn(o)
-public method main(System.Console sys) -> void:
+public export method test() -> void:
Object o = {fn: &myFn}
- sys.out.println(get(o))
+ assume get(o) == 123
diff --git a/tests/valid/OpenRecord_Valid_4.sysout b/tests/valid/OpenRecord_Valid_4.sysout
deleted file mode 100644
index 3b7f5a3cca..0000000000
--- a/tests/valid/OpenRecord_Valid_4.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-1
-4
--3
--2
\ No newline at end of file
diff --git a/tests/valid/OpenRecord_Valid_4.whiley b/tests/valid/OpenRecord_Valid_4.whiley
index c732af9dfd..f01f595e14 100644
--- a/tests/valid/OpenRecord_Valid_4.whiley
+++ b/tests/valid/OpenRecord_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type OpenRecord is {int x, ...}
@@ -11,13 +11,13 @@ function getField(OpenRecord r) -> int:
else:
return -r.x
-method main(System.Console sys) -> void:
+public export method test() -> void:
OpenRecord r = {x: 1}
- sys.out.println(getField(r))
+ assume getField(r) == 1
r = {y: 1, x: 3}
- sys.out.println(getField(r))
+ assume getField(r) == 4
r = {z: 1, y: 1, x: 3}
- sys.out.println(getField(r))
+ assume getField(r) == -3
r = {y: "hello", x: 2}
- sys.out.println(getField(r))
+ assume getField(r) == -2
diff --git a/tests/valid/OpenRecord_Valid_5.sysout b/tests/valid/OpenRecord_Valid_5.sysout
deleted file mode 100644
index 2559e5c49e..0000000000
--- a/tests/valid/OpenRecord_Valid_5.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3
-6
diff --git a/tests/valid/OpenRecord_Valid_5.whiley b/tests/valid/OpenRecord_Valid_5.whiley
index 934c284df0..0ff944b106 100644
--- a/tests/valid/OpenRecord_Valid_5.whiley
+++ b/tests/valid/OpenRecord_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Point is {int y, int x, ...}
@@ -13,8 +13,8 @@ function sum(VecPoint vp) -> int:
r = r + sum(p)
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
VecPoint vp = {y: 2, x: 1}
- sys.out.println(sum(vp))
- vp = [{y: 2, x: 1}, {y: 2, x: 1}]
- sys.out.println(sum(vp))
+ assume sum(vp) == 3
+ vp = [{y: 2, x: 1}, {y: 4, x: -1}]
+ assume sum(vp) == 6
diff --git a/tests/valid/OpenRecord_Valid_6.sysout b/tests/valid/OpenRecord_Valid_6.sysout
deleted file mode 100644
index 2559e5c49e..0000000000
--- a/tests/valid/OpenRecord_Valid_6.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3
-6
diff --git a/tests/valid/OpenRecord_Valid_6.whiley b/tests/valid/OpenRecord_Valid_6.whiley
index 8e4d535ae0..98b69c17d3 100644
--- a/tests/valid/OpenRecord_Valid_6.whiley
+++ b/tests/valid/OpenRecord_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Point is {int y, int x, ...}
@@ -13,8 +13,8 @@ function sum(VecPoint vp) -> int:
else:
return vp.x + vp.y
-method main(System.Console sys) -> void:
+public export method test() -> void:
VecPoint vp = {y: 2, x: 1}
- sys.out.println(sum(vp))
- vp = [{y: 2, x: 1}, {y: 2, x: 1}]
- sys.out.println(sum(vp))
+ assume sum(vp) == 3
+ vp = [{y: 2, x: 1}, {y: 5, x: -10}]
+ assume sum(vp) == -2
diff --git a/tests/valid/OpenRecord_Valid_7.sysout b/tests/valid/OpenRecord_Valid_7.sysout
deleted file mode 100644
index a3978de2a1..0000000000
--- a/tests/valid/OpenRecord_Valid_7.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3.0
-3.57
diff --git a/tests/valid/OpenRecord_Valid_7.whiley b/tests/valid/OpenRecord_Valid_7.whiley
index a4bc655e06..b97884ccc3 100644
--- a/tests/valid/OpenRecord_Valid_7.whiley
+++ b/tests/valid/OpenRecord_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type IntPoint is {int y, int x, ...}
@@ -12,8 +12,8 @@ function sum(Point vp) -> real:
else:
return vp.x + vp.y
-method main(System.Console sys) -> void:
+public export method test() -> void:
Point vp = {y: 2, x: 1}
- sys.out.println(sum(vp))
+ assume sum(vp) == 3.0
vp = {y: 2.34, x: 1.23}
- sys.out.println(sum(vp))
+ assume sum(vp) == 3.57
diff --git a/tests/valid/OpenRecord_Valid_8.sysout b/tests/valid/OpenRecord_Valid_8.sysout
deleted file mode 100644
index a3978de2a1..0000000000
--- a/tests/valid/OpenRecord_Valid_8.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3.0
-3.57
diff --git a/tests/valid/OpenRecord_Valid_8.whiley b/tests/valid/OpenRecord_Valid_8.whiley
index e446674324..fb17c06ddd 100644
--- a/tests/valid/OpenRecord_Valid_8.whiley
+++ b/tests/valid/OpenRecord_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type IntPoint is {int y, int x, ...}
@@ -10,8 +10,8 @@ function sum(Point vp) -> real:
RealPoint rp = (RealPoint) vp
return rp.x + rp.y
-method main(System.Console sys) -> void:
+public export method test() -> void:
Point vp = {y: 2, x: 1}
- sys.out.println(sum(vp))
+ assume sum(vp) == 3.0
vp = {y: 2.34, x: 1.23}
- sys.out.println(sum(vp))
+ assume sum(vp) == 3.57
diff --git a/tests/valid/OpenRecord_Valid_9.sysout b/tests/valid/OpenRecord_Valid_9.sysout
deleted file mode 100644
index 125213e0da..0000000000
--- a/tests/valid/OpenRecord_Valid_9.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-3.0
-5.0
-3.0
diff --git a/tests/valid/OpenRecord_Valid_9.whiley b/tests/valid/OpenRecord_Valid_9.whiley
index 3f3f8a0036..de65c819b8 100644
--- a/tests/valid/OpenRecord_Valid_9.whiley
+++ b/tests/valid/OpenRecord_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type PointAny is {int y, int x, ...}
@@ -17,10 +17,10 @@ function sum(Point vp) -> real:
else:
return (real) (vp.x + vp.y)
-method main(System.Console sys) -> void:
+public export method test() -> void:
Point vp = {y: 2, x: 1}
- sys.out.println(sum(vp))
+ assume sum(vp) == 3.0
vp = {z: 2, y: 2, x: 1}
- sys.out.println(sum(vp))
+ assume sum(vp) == 5.0
vp = {y: 2, h: 2, x: 1}
- sys.out.println(sum(vp))
+ assume sum(vp) == 3.0
diff --git a/tests/valid/Print_Valid_1.sysout b/tests/valid/Print_Valid_1.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/Print_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Print_Valid_1.whiley b/tests/valid/Print_Valid_1.whiley
deleted file mode 100644
index 64fb2b2abc..0000000000
--- a/tests/valid/Print_Valid_1.whiley
+++ /dev/null
@@ -1,4 +0,0 @@
-import whiley.lang.*
-
-method main(System.Console sys) -> void:
- sys.out.println(1)
diff --git a/tests/valid/ProcessAccess_Valid_1.sysout b/tests/valid/ProcessAccess_Valid_1.sysout
deleted file mode 100755
index 116625b948..0000000000
--- a/tests/valid/ProcessAccess_Valid_1.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-{mode:1,rest:2}
-{mode:1,rest:123}
-{mode:1,rest:123}
-1
diff --git a/tests/valid/ProcessAccess_Valid_1.whiley b/tests/valid/ProcessAccess_Valid_1.whiley
index 9318f64e4e..dbb32419ec 100644
--- a/tests/valid/ProcessAccess_Valid_1.whiley
+++ b/tests/valid/ProcessAccess_Valid_1.whiley
@@ -1,18 +1,15 @@
-import whiley.lang.*
-
type etype is {int rest, int mode}
-
type Ptype is &etype
-method get(Ptype this) -> (int, [int]):
+method get(Ptype this) -> int:
this->mode = 1
this->rest = 123
- return (this->mode, Any.toString(*this))
+ return this->mode
+
+public export method test() -> void:
+ Ptype p = new {rest: 2, mode: 2}
+ assume (*p) == {rest: 2, mode: 2}
+ int x = get(p)
+ assume (*p) == {rest: 123, mode: 1}
+ assume x == 1
-method main(System.Console sys) -> void:
- Ptype p = new {rest: 2, mode: 1}
- sys.out.println(*p)
- int x, [int] s = get(p)
- sys.out.println_s(s)
- sys.out.println(*p)
- sys.out.println(x)
diff --git a/tests/valid/ProcessAccess_Valid_2.sysout b/tests/valid/ProcessAccess_Valid_2.sysout
deleted file mode 100755
index e13c5bfaa6..0000000000
--- a/tests/valid/ProcessAccess_Valid_2.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-2
-1
diff --git a/tests/valid/ProcessAccess_Valid_2.whiley b/tests/valid/ProcessAccess_Valid_2.whiley
index 676d236a88..27684b0ac5 100644
--- a/tests/valid/ProcessAccess_Valid_2.whiley
+++ b/tests/valid/ProcessAccess_Valid_2.whiley
@@ -1,14 +1,12 @@
-import * from whiley.lang.*
-
-type state is {int y, int x, System.Console console}
+type state is {int y, int x}
type pState is &state
method send(pState this, int z) -> void:
- this->console.out.println(this->x)
- this->console.out.println(this->y)
- this->console.out.println(z)
+ assume this->x == 1
+ assume this->y == 2
+ assume z == 1
-method main(System.Console sys) -> void:
- pState ps = new {y: 2, x: 1, console: sys}
+public export method test() -> void:
+ pState ps = new {y: 2, x: 1}
send(ps,1)
diff --git a/tests/valid/Process_Valid_1.sysout b/tests/valid/Process_Valid_1.sysout
deleted file mode 100755
index 332d86084c..0000000000
--- a/tests/valid/Process_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{x:1,y:2}
-sent
-1
diff --git a/tests/valid/Process_Valid_1.whiley b/tests/valid/Process_Valid_1.whiley
index 7f9aa53f95..42db55a82f 100644
--- a/tests/valid/Process_Valid_1.whiley
+++ b/tests/valid/Process_Valid_1.whiley
@@ -1,16 +1,14 @@
-import whiley.lang.*
+
type state is {int y, int x}
type pState is &state
-method send(pState this, int x, System.Console sys) -> void:
+method send(pState this, int x) -> void:
this->x = x
assert this->x == x
- sys.out.println(*this)
- sys.out.println_s("sent")
- sys.out.println(x)
+ assume (*this) == {x: 3, y: 2}
-method main(System.Console sys) -> void:
+public export method test() -> void:
pState ps = new {y: 2, x: 1}
- send(ps, 1, sys)
+ send(ps, 3)
diff --git a/tests/valid/Process_Valid_10.sysout b/tests/valid/Process_Valid_10.sysout
deleted file mode 100644
index 6f7c493f00..0000000000
--- a/tests/valid/Process_Valid_10.sysout
+++ /dev/null
@@ -1,20 +0,0 @@
-PUT: 1
-PUT: 2
-PUT: 3
-PUT: 4
-PUT: 5
-PUT: 6
-PUT: 7
-PUT: 8
-PUT: 9
-PUT: 10
-GET: 1
-GET: 2
-GET: 3
-GET: 4
-GET: 5
-GET: 6
-GET: 7
-GET: 8
-GET: 9
-GET: 10
diff --git a/tests/valid/Process_Valid_10.whiley b/tests/valid/Process_Valid_10.whiley
index b71722ad1a..3594af7878 100644
--- a/tests/valid/Process_Valid_10.whiley
+++ b/tests/valid/Process_Valid_10.whiley
@@ -1,5 +1,4 @@
-import whiley.lang.*
-import whiley.lang.*
+
type Queue is {[int] items}
@@ -14,13 +13,28 @@ method put(&Queue this, int item) -> void:
method isEmpty(&Queue this) -> bool:
return |this->items| == 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
&Queue q = new {items: []}
- // put items into queue
- for item in items:
- put(q,item)
- sys.out.println_s("PUT: " ++ Any.toString(item))
- // get items out of queue
- while !isEmpty(q):
- sys.out.println_s("GET: " ++ Any.toString(get(q)))
+ // Put items into the queue
+ put(q, 1)
+ assume q->items == [1]
+ put(q, 2)
+ assume q->items == [1,2]
+ put(q, 3)
+ assume q->items == [1,2,3]
+ put(q, 4)
+ assume q->items == [1,2,3,4]
+ put(q, 5)
+ assume q->items == [1,2,3,4,5]
+ // Get items outof the queue
+ assume get(q) == 1
+ assume !isEmpty(q)
+ assume get(q) == 2
+ assume !isEmpty(q)
+ assume get(q) == 3
+ assume !isEmpty(q)
+ assume get(q) == 4
+ assume !isEmpty(q)
+ assume get(q) == 5
+ assume isEmpty(q)
diff --git a/tests/valid/Process_Valid_11.sysout b/tests/valid/Process_Valid_11.sysout
deleted file mode 100755
index 94d36aad18..0000000000
--- a/tests/valid/Process_Valid_11.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
--1
diff --git a/tests/valid/Process_Valid_11.whiley b/tests/valid/Process_Valid_11.whiley
index b4ff3221f3..d151a12ab1 100644
--- a/tests/valid/Process_Valid_11.whiley
+++ b/tests/valid/Process_Valid_11.whiley
@@ -1,13 +1,12 @@
-import whiley.lang.*
+
type state is {int y, int x} where x < y
type pState is &state
-method send2(pState this, int x, System.Console sys) -> int:
- sys.out.println(x)
- return -1
+method send2(pState this, int x) -> int:
+ return this->x + this->y
-method main(System.Console sys) -> void:
- int x = send2(new {y: 2, x: 1},1, sys)
- sys.out.println(x)
+public export method test() -> void:
+ int x = send2(new {y: 2, x: 1},1)
+ assume x == 3
diff --git a/tests/valid/Process_Valid_12.sysout b/tests/valid/Process_Valid_12.sysout
deleted file mode 100755
index 94d36aad18..0000000000
--- a/tests/valid/Process_Valid_12.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
--1
diff --git a/tests/valid/Process_Valid_12.whiley b/tests/valid/Process_Valid_12.whiley
index b6db7099a9..4307eb4cd4 100644
--- a/tests/valid/Process_Valid_12.whiley
+++ b/tests/valid/Process_Valid_12.whiley
@@ -1,13 +1,12 @@
-import whiley.lang.*
+
type state is {int y, int x}
type pState is &state
-method send2(pState this, int x, System.Console sys) -> int:
- sys.out.println(x)
- return -1
+method send2(pState this, int x) -> int:
+ return this->x + this->y
-method main(System.Console sys) -> void:
- int x = send2(new {y: 2, x: 1},1, sys)
- sys.out.println(x)
+public export method test() -> void:
+ int x = send2(new {y: 2, x: 1},1)
+ assume x == 3
diff --git a/tests/valid/Process_Valid_13.sysout b/tests/valid/Process_Valid_13.sysout
deleted file mode 100755
index 071ed6ba84..0000000000
--- a/tests/valid/Process_Valid_13.sysout
+++ /dev/null
@@ -1 +0,0 @@
-GOT HERE
diff --git a/tests/valid/Process_Valid_13.whiley b/tests/valid/Process_Valid_13.whiley
deleted file mode 100644
index b0b2a8471a..0000000000
--- a/tests/valid/Process_Valid_13.whiley
+++ /dev/null
@@ -1,5 +0,0 @@
-import whiley.lang.*
-
-method main(System.Console sys) -> void:
- System.PrintWriter x = sys.out
- x.println_s("GOT HERE")
diff --git a/tests/valid/Process_Valid_14.sysout b/tests/valid/Process_Valid_14.sysout
deleted file mode 100755
index 557db03de9..0000000000
--- a/tests/valid/Process_Valid_14.sysout
+++ /dev/null
@@ -1 +0,0 @@
-Hello World
diff --git a/tests/valid/Process_Valid_14.whiley b/tests/valid/Process_Valid_14.whiley
deleted file mode 100644
index b72c50a56b..0000000000
--- a/tests/valid/Process_Valid_14.whiley
+++ /dev/null
@@ -1,4 +0,0 @@
-import whiley.lang.*
-
-method main(System.Console sys) -> void:
- sys.out.println_s("Hello World")
diff --git a/tests/valid/Process_Valid_2.sysout b/tests/valid/Process_Valid_2.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/Process_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Process_Valid_2.whiley b/tests/valid/Process_Valid_2.whiley
index 05cc44a626..2e5ac031e4 100644
--- a/tests/valid/Process_Valid_2.whiley
+++ b/tests/valid/Process_Valid_2.whiley
@@ -1,5 +1,5 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
int out = 1
- sys.out.println(out)
+ assume out == 1
diff --git a/tests/valid/Process_Valid_3.sysout b/tests/valid/Process_Valid_3.sysout
deleted file mode 100755
index 557db03de9..0000000000
--- a/tests/valid/Process_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-Hello World
diff --git a/tests/valid/Process_Valid_3.whiley b/tests/valid/Process_Valid_3.whiley
index cfc413fd0d..00a7bc312e 100644
--- a/tests/valid/Process_Valid_3.whiley
+++ b/tests/valid/Process_Valid_3.whiley
@@ -1,6 +1,6 @@
-import whiley.lang.*
+
constant out is 123.456
-method main(System.Console sys) -> void:
- sys.out.println_s("Hello World")
+public export method test() -> void:
+ assume out == 123.456
diff --git a/tests/valid/Process_Valid_4.sysout b/tests/valid/Process_Valid_4.sysout
deleted file mode 100755
index b4de394767..0000000000
--- a/tests/valid/Process_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-11
diff --git a/tests/valid/Process_Valid_4.whiley b/tests/valid/Process_Valid_4.whiley
index 0aa7028154..b18270280f 100644
--- a/tests/valid/Process_Valid_4.whiley
+++ b/tests/valid/Process_Valid_4.whiley
@@ -1,11 +1,11 @@
-import whiley.lang.*
+
type MyProc is &{int x}
method inc(MyProc this, int i) -> void:
this->x = this->x + i
-method main(System.Console sys) -> void:
+public export method test() -> void:
MyProc mproc = new {x: 1}
inc(mproc, 10)
- sys.out.println(mproc->x)
+ assume mproc->x == 11
diff --git a/tests/valid/Process_Valid_5.sysout b/tests/valid/Process_Valid_5.sysout
deleted file mode 100755
index f6d449caf0..0000000000
--- a/tests/valid/Process_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-FALSE
diff --git a/tests/valid/Process_Valid_5.whiley b/tests/valid/Process_Valid_5.whiley
index 692c2b7238..3f70e22b57 100644
--- a/tests/valid/Process_Valid_5.whiley
+++ b/tests/valid/Process_Valid_5.whiley
@@ -1,13 +1,15 @@
-import whiley.lang.*
+
type MyProc is &{bool flag}
-method run(MyProc this, System.Console sys) -> void:
+method run(MyProc this) -> bool:
if this->flag:
- sys.out.println_s("TRUE")
+ return true
else:
- sys.out.println_s("FALSE")
+ return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
MyProc mproc = new {flag: false}
- run(mproc, sys)
+ assert run(mproc) == false
+ mproc = new {flag: true}
+ assert run(mproc) == true
diff --git a/tests/valid/Process_Valid_6.sysout b/tests/valid/Process_Valid_6.sysout
deleted file mode 100644
index ea90ee3198..0000000000
--- a/tests/valid/Process_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-45
diff --git a/tests/valid/Process_Valid_6.whiley b/tests/valid/Process_Valid_6.whiley
index aabeff86fd..841cfb6d48 100644
--- a/tests/valid/Process_Valid_6.whiley
+++ b/tests/valid/Process_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Actor is {int data}
@@ -15,11 +15,11 @@ method createActors(int n) -> [&Actor]:
row = row ++ [m]
return row
-method main(System.Console sys) -> void:
+public export method test() -> void:
[&Actor] actors = createActors(10)
int r = 0
//
for i in 0 .. |actors|:
r = r + get(actors[i])
//
- sys.out.println(r)
+ assume r == 45
diff --git a/tests/valid/Process_Valid_7.sysout b/tests/valid/Process_Valid_7.sysout
deleted file mode 100644
index d00491fd7e..0000000000
--- a/tests/valid/Process_Valid_7.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Process_Valid_7.whiley b/tests/valid/Process_Valid_7.whiley
index acf824b784..dba4da35b6 100644
--- a/tests/valid/Process_Valid_7.whiley
+++ b/tests/valid/Process_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type MyProc2 is &{any data}
@@ -11,7 +11,7 @@ method get(MyProc2 this) -> any:
method create(any data) -> MyProc2:
return new {data: data}
-method main(System.Console sys) -> void:
+public export method test() -> void:
MyProc2 p2 = create(1.23)
set(p2,1)
- sys.out.println(get(p2))
+ assume get(p2) == 1
diff --git a/tests/valid/Process_Valid_8.sysout b/tests/valid/Process_Valid_8.sysout
deleted file mode 100644
index d00491fd7e..0000000000
--- a/tests/valid/Process_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/Process_Valid_8.whiley b/tests/valid/Process_Valid_8.whiley
index 12d18ed053..49e97e8d1c 100644
--- a/tests/valid/Process_Valid_8.whiley
+++ b/tests/valid/Process_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type MyProc2 is {any data}
@@ -11,7 +11,7 @@ method get(&MyProc2 this) -> any:
method create(any data) -> &MyProc2:
return new {data: data}
-method main(System.Console sys) -> void:
+public export method test() -> void:
&MyProc2 p2 = create(1.23)
set(p2,1)
- sys.out.println(get(p2))
+ assume get(p2) == 1
diff --git a/tests/valid/Process_Valid_9.sysout b/tests/valid/Process_Valid_9.sysout
deleted file mode 100644
index 6f7c493f00..0000000000
--- a/tests/valid/Process_Valid_9.sysout
+++ /dev/null
@@ -1,20 +0,0 @@
-PUT: 1
-PUT: 2
-PUT: 3
-PUT: 4
-PUT: 5
-PUT: 6
-PUT: 7
-PUT: 8
-PUT: 9
-PUT: 10
-GET: 1
-GET: 2
-GET: 3
-GET: 4
-GET: 5
-GET: 6
-GET: 7
-GET: 8
-GET: 9
-GET: 10
diff --git a/tests/valid/Process_Valid_9.whiley b/tests/valid/Process_Valid_9.whiley
index fb7df4b1af..623209fbde 100644
--- a/tests/valid/Process_Valid_9.whiley
+++ b/tests/valid/Process_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Queue is {[int] items}
@@ -16,13 +16,28 @@ method isEmpty(&Queue this) -> bool:
method Queue() -> &Queue:
return new {items: []}
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
&Queue q = Queue()
// Put items into the queue
- for item in items:
- put(q, item)
- sys.out.println_s("PUT: " ++ Any.toString(item))
+ put(q, 1)
+ assume q->items == [1]
+ put(q, 2)
+ assume q->items == [1,2]
+ put(q, 3)
+ assume q->items == [1,2,3]
+ put(q, 4)
+ assume q->items == [1,2,3,4]
+ put(q, 5)
+ assume q->items == [1,2,3,4,5]
// Get items outof the queue
- while !isEmpty(q):
- sys.out.println_s("GET: " ++ Any.toString(get(q)))
+ assume get(q) == 1
+ assume !isEmpty(q)
+ assume get(q) == 2
+ assume !isEmpty(q)
+ assume get(q) == 3
+ assume !isEmpty(q)
+ assume get(q) == 4
+ assume !isEmpty(q)
+ assume get(q) == 5
+ assume isEmpty(q)
diff --git a/tests/valid/Quantifiers_Valid_1.sysout b/tests/valid/Quantifiers_Valid_1.sysout
deleted file mode 100755
index 2d05c9ead5..0000000000
--- a/tests/valid/Quantifiers_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2, 3}
diff --git a/tests/valid/Quantifiers_Valid_1.whiley b/tests/valid/Quantifiers_Valid_1.whiley
index f4cf922a3c..03db2c2f68 100644
--- a/tests/valid/Quantifiers_Valid_1.whiley
+++ b/tests/valid/Quantifiers_Valid_1.whiley
@@ -1,10 +1,11 @@
-import whiley.lang.*
+
function f({int} xs) -> {int}
requires no { w in xs | w < 0 }:
return xs
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ys = {1, 2, 3}
{int} zs = ys
- sys.out.println(f(zs))
+ assume f(zs) == {1,2,3}
+ assert ys == {1,2,3}
diff --git a/tests/valid/Range_Valid_1.sysout b/tests/valid/Range_Valid_1.sysout
deleted file mode 100644
index 24350e0534..0000000000
--- a/tests/valid/Range_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-10
-3
diff --git a/tests/valid/Range_Valid_1.whiley b/tests/valid/Range_Valid_1.whiley
index ab32e2688b..59e6fc82a4 100644
--- a/tests/valid/Range_Valid_1.whiley
+++ b/tests/valid/Range_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -8,6 +8,6 @@ function sum(int start, int end) -> nat:
r = r + 1
return r
-method main(System.Console sys) -> void:
- sys.out.println(sum(0, 10))
- sys.out.println(sum(10, 13))
+public export method test() -> void:
+ assume sum(0, 10) == 10
+ assume sum(10, 13) == 3
diff --git a/tests/valid/RealConst_Valid_1.sysout b/tests/valid/RealConst_Valid_1.sysout
deleted file mode 100755
index 36f099ead6..0000000000
--- a/tests/valid/RealConst_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-12376523476123.989472426
diff --git a/tests/valid/RealConst_Valid_1.whiley b/tests/valid/RealConst_Valid_1.whiley
index 3d19266cb6..c7a31aa7f0 100644
--- a/tests/valid/RealConst_Valid_1.whiley
+++ b/tests/valid/RealConst_Valid_1.whiley
@@ -1,6 +1,7 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
real x = 12376523476123.98712345
x = x + 0.002348976
- sys.out.println(x)
+ assume x == 12376523476123.989472426
+
diff --git a/tests/valid/RealDiv_Valid_1.sysout b/tests/valid/RealDiv_Valid_1.sysout
deleted file mode 100755
index 1d4bd3adba..0000000000
--- a/tests/valid/RealDiv_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-(1/3)
diff --git a/tests/valid/RealDiv_Valid_1.whiley b/tests/valid/RealDiv_Valid_1.whiley
index 841dae9163..0f019247ef 100644
--- a/tests/valid/RealDiv_Valid_1.whiley
+++ b/tests/valid/RealDiv_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function g(int x) -> real:
return ((real) x) / 3.0
@@ -7,5 +7,5 @@ function f(int x, int y) -> real
requires (x >= 0) && (y > 0):
return g(x)
-method main(System.Console sys) -> void:
- sys.out.println(f(1, 2))
+public export method test() -> void:
+ assume f(1, 2) == (1.0/3.0)
diff --git a/tests/valid/RealDiv_Valid_2.sysout b/tests/valid/RealDiv_Valid_2.sysout
deleted file mode 100644
index 7658b65145..0000000000
--- a/tests/valid/RealDiv_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-(1000/3123)
diff --git a/tests/valid/RealDiv_Valid_2.whiley b/tests/valid/RealDiv_Valid_2.whiley
index 50cebd68ab..a160b2e392 100644
--- a/tests/valid/RealDiv_Valid_2.whiley
+++ b/tests/valid/RealDiv_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function g(int x) -> real:
return ((real) x) / 3.123
@@ -6,5 +6,5 @@ function g(int x) -> real:
function f(int x, int y) -> real:
return g(x)
-method main(System.Console sys) -> void:
- sys.out.println(f(1, 2))
+public export method test() -> void:
+ assume f(1, 2) == (1.0/3.123)
diff --git a/tests/valid/RealDiv_Valid_3.sysout b/tests/valid/RealDiv_Valid_3.sysout
deleted file mode 100755
index 1d4bd3adba..0000000000
--- a/tests/valid/RealDiv_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-(1/3)
diff --git a/tests/valid/RealDiv_Valid_3.whiley b/tests/valid/RealDiv_Valid_3.whiley
index 841dae9163..0f019247ef 100644
--- a/tests/valid/RealDiv_Valid_3.whiley
+++ b/tests/valid/RealDiv_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function g(int x) -> real:
return ((real) x) / 3.0
@@ -7,5 +7,5 @@ function f(int x, int y) -> real
requires (x >= 0) && (y > 0):
return g(x)
-method main(System.Console sys) -> void:
- sys.out.println(f(1, 2))
+public export method test() -> void:
+ assume f(1, 2) == (1.0/3.0)
diff --git a/tests/valid/RealDiv_Valid_4.sysout b/tests/valid/RealDiv_Valid_4.sysout
deleted file mode 100755
index ba66466c2a..0000000000
--- a/tests/valid/RealDiv_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-0.0
diff --git a/tests/valid/RealDiv_Valid_4.whiley b/tests/valid/RealDiv_Valid_4.whiley
index b785ffa981..473c0c62dd 100644
--- a/tests/valid/RealDiv_Valid_4.whiley
+++ b/tests/valid/RealDiv_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function g(int x) -> real:
return (real) (x / 3)
@@ -6,5 +6,5 @@ function g(int x) -> real:
function f(int x, int y) -> real:
return g(x)
-method main(System.Console sys) -> void:
- sys.out.println(f(1, 2))
+public export method test() -> void:
+ assume f(1, 2) == 0.0
diff --git a/tests/valid/RealDiv_Valid_5.sysout b/tests/valid/RealDiv_Valid_5.sysout
deleted file mode 100755
index dba33c3a3a..0000000000
--- a/tests/valid/RealDiv_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-0.078
diff --git a/tests/valid/RealDiv_Valid_5.whiley b/tests/valid/RealDiv_Valid_5.whiley
index 97452d4327..2ac12eb7b2 100644
--- a/tests/valid/RealDiv_Valid_5.whiley
+++ b/tests/valid/RealDiv_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function g(real x) -> (real y)
requires x <= 0.5
@@ -6,5 +6,5 @@ ensures y <= 0.166666666666668:
//
return x / 3.0
-method main(System.Console sys) -> void:
- sys.out.println(g(0.234))
+public export method test() -> void:
+ assume g(0.234) == (0.234/3.0)
diff --git a/tests/valid/RealDiv_Valid_6.sysout b/tests/valid/RealDiv_Valid_6.sysout
deleted file mode 100755
index dba33c3a3a..0000000000
--- a/tests/valid/RealDiv_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-0.078
diff --git a/tests/valid/RealDiv_Valid_6.whiley b/tests/valid/RealDiv_Valid_6.whiley
index ec49881854..f0a137b266 100644
--- a/tests/valid/RealDiv_Valid_6.whiley
+++ b/tests/valid/RealDiv_Valid_6.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function g(real x) -> real:
return x / 3.0
-method main(System.Console sys) -> void:
- sys.out.println(g(0.234))
+public export method test() -> void:
+ assume g(0.234) == (0.468/6.0)
diff --git a/tests/valid/RealDiv_Valid_7.sysout b/tests/valid/RealDiv_Valid_7.sysout
deleted file mode 100644
index a145dd7102..0000000000
--- a/tests/valid/RealDiv_Valid_7.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-(4/51)
-(1/120)
diff --git a/tests/valid/RealDiv_Valid_7.whiley b/tests/valid/RealDiv_Valid_7.whiley
index 6721d889ad..ada8f964d2 100644
--- a/tests/valid/RealDiv_Valid_7.whiley
+++ b/tests/valid/RealDiv_Valid_7.whiley
@@ -1,10 +1,12 @@
-import whiley.lang.*
+
function diver(real x, real y, real z) -> real
requires y != 0.0 && z != 0.0:
//
return (x / y) / z
-method main(System.Console sys) -> void:
- sys.out.println(diver(1.2, 3.4, 4.5))
- sys.out.println(diver(1000.0, 300.0, 400.0))
+public export method test() -> void:
+ assume diver(1.2, 3.4, 4.5) == (4.0/51.0)
+ assume diver(1000.0, 300.0, 400.0) == (1.0/120.0)
+
+
diff --git a/tests/valid/RealNeg_Valid_1.sysout b/tests/valid/RealNeg_Valid_1.sysout
deleted file mode 100755
index 1259d5081c..0000000000
--- a/tests/valid/RealNeg_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-(-6/5)
-(-1/100000)
--5632.0
diff --git a/tests/valid/RealNeg_Valid_1.whiley b/tests/valid/RealNeg_Valid_1.whiley
index 6ee32f0a12..6190651073 100644
--- a/tests/valid/RealNeg_Valid_1.whiley
+++ b/tests/valid/RealNeg_Valid_1.whiley
@@ -1,11 +1,11 @@
-import whiley.lang.*
+
function f(real x) -> (real y)
requires x > 0.0
ensures y < 0.0:
return -x
-method main(System.Console sys) -> void:
- sys.out.println(f(1.2))
- sys.out.println(f(0.00001))
- sys.out.println(f(5632.0))
+public export method test() -> void:
+ assume f(1.2) == -1.2
+ assume f(0.00001) == -0.00001
+ assume f(5632.0) == -5632.0
diff --git a/tests/valid/RealNeg_Valid_2.sysout b/tests/valid/RealNeg_Valid_2.sysout
deleted file mode 100755
index 1259d5081c..0000000000
--- a/tests/valid/RealNeg_Valid_2.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-(-6/5)
-(-1/100000)
--5632.0
diff --git a/tests/valid/RealNeg_Valid_2.whiley b/tests/valid/RealNeg_Valid_2.whiley
index 1d28974677..c0bea123bc 100644
--- a/tests/valid/RealNeg_Valid_2.whiley
+++ b/tests/valid/RealNeg_Valid_2.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
function f(real x) -> real:
return -x
-method main(System.Console sys) -> void:
- sys.out.println(f(1.2))
- sys.out.println(f(0.00001))
- sys.out.println(f(5632.0))
+public export method test() -> void:
+ assume f(1.2) == -1.2
+ assume f(0.00001) == -0.00001
+ assume f(5632.0) == -5632.0
diff --git a/tests/valid/RealSplit_Valid_1.sysout b/tests/valid/RealSplit_Valid_1.sysout
deleted file mode 100644
index cbb5e0dc98..0000000000
--- a/tests/valid/RealSplit_Valid_1.sysout
+++ /dev/null
@@ -1,16 +0,0 @@
-(2,1)
-(5,2)
-(1,4)
-(103,2)
-(-2,1)
-(-5,2)
-(-1,4)
-(-103,2)
-(2,1)
-(5,2)
-(1,4)
-(103,2)
-(-2,1)
-(-5,2)
-(-1,4)
-(-103,2)
diff --git a/tests/valid/RealSplit_Valid_1.whiley b/tests/valid/RealSplit_Valid_1.whiley
index e458d9f86f..d5ef8117f0 100644
--- a/tests/valid/RealSplit_Valid_1.whiley
+++ b/tests/valid/RealSplit_Valid_1.whiley
@@ -1,23 +1,23 @@
-import whiley.lang.*
+
function f(real z) -> (int, int):
int x / int y = z
return (x, y)
-method main(System.Console sys) -> void:
- sys.out.println(f(10.0 / 5.0))
- sys.out.println(f(10.0 / 4.0))
- sys.out.println(f(1.0 / 4.0))
- sys.out.println(f(103.0 / 2.0))
- sys.out.println(f(-10.0 / 5.0))
- sys.out.println(f(-10.0 / 4.0))
- sys.out.println(f(-1.0 / 4.0))
- sys.out.println(f(-103.0 / 2.0))
- sys.out.println(f(-10.0 / -5.0))
- sys.out.println(f(-10.0 / -4.0))
- sys.out.println(f(-1.0 / -4.0))
- sys.out.println(f(-103.0 / -2.0))
- sys.out.println(f(10.0 / -5.0))
- sys.out.println(f(10.0 / -4.0))
- sys.out.println(f(1.0 / -4.0))
- sys.out.println(f(103.0 / -2.0))
+public export method test() -> void:
+ assume f(10.0 / 5.0) == (2,1)
+ assume f(10.0 / 4.0) == (5,2)
+ assume f(1.0 / 4.0) == (1,4)
+ assume f(103.0 / 2.0) == (103,2)
+ assume f(-10.0 / 5.0) == (-2,1)
+ assume f(-10.0 / 4.0) == (-5,2)
+ assume f(-1.0 / 4.0) == (-1,4)
+ assume f(-103.0 / 2.0) == (-103,2)
+ assume f(-10.0 / -5.0) == (2,1)
+ assume f(-10.0 / -4.0) == (5,2)
+ assume f(-1.0 / -4.0) == (1,4)
+ assume f(-103.0 / -2.0) == (103,2)
+ assume f(10.0 / -5.0) == (-2,1)
+ assume f(10.0 / -4.0) == (-5,2)
+ assume f(1.0 / -4.0) == (-1,4)
+ assume f(103.0 / -2.0) == (-103,2)
diff --git a/tests/valid/RealSub_Valid_1.sysout b/tests/valid/RealSub_Valid_1.sysout
deleted file mode 100755
index 80462dcff4..0000000000
--- a/tests/valid/RealSub_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-(-617/500)
diff --git a/tests/valid/RealSub_Valid_1.whiley b/tests/valid/RealSub_Valid_1.whiley
index 110a64647b..77382544d0 100644
--- a/tests/valid/RealSub_Valid_1.whiley
+++ b/tests/valid/RealSub_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(real x) -> (real y)
requires x >= 0.2345
@@ -6,5 +6,5 @@ ensures y < -0.2:
//
return 0.0 - x
-method main(System.Console sys) -> void:
- sys.out.println(f(1.234))
+public export method test() -> void:
+ assume f(1.234) == -1.234
diff --git a/tests/valid/RealSub_Valid_2.sysout b/tests/valid/RealSub_Valid_2.sysout
deleted file mode 100755
index 80462dcff4..0000000000
--- a/tests/valid/RealSub_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-(-617/500)
diff --git a/tests/valid/RealSub_Valid_2.whiley b/tests/valid/RealSub_Valid_2.whiley
index 8c39b16346..a56091d415 100644
--- a/tests/valid/RealSub_Valid_2.whiley
+++ b/tests/valid/RealSub_Valid_2.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f(real x) -> real:
return 0.0 - x
-method main(System.Console sys) -> void:
- sys.out.println(f(1.234))
+public export method test() -> void:
+ assume f(1.234) == -1.234
diff --git a/tests/valid/RealSub_Valid_3.sysout b/tests/valid/RealSub_Valid_3.sysout
deleted file mode 100644
index 87a84c9f09..0000000000
--- a/tests/valid/RealSub_Valid_3.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-(-67/10)
-300.0
diff --git a/tests/valid/RealSub_Valid_3.whiley b/tests/valid/RealSub_Valid_3.whiley
index 37cac3334d..571133c278 100644
--- a/tests/valid/RealSub_Valid_3.whiley
+++ b/tests/valid/RealSub_Valid_3.whiley
@@ -1,8 +1,10 @@
-import whiley.lang.*
+
function suber(real x, real y, real z) -> real:
return (x - y) - z
-method main(System.Console sys) -> void:
- sys.out.println(suber(1.2, 3.4, 4.5))
- sys.out.println(suber(1000.0, 300.0, 400.0))
+public export method test() -> void:
+ assume suber(1.2, 3.4, 4.5) == -6.7
+ assume suber(1000.0, 300.0, 400.0) == 300.0
+
+
diff --git a/tests/valid/Real_Valid_1.sysout b/tests/valid/Real_Valid_1.sysout
deleted file mode 100644
index 7cfbd55c38..0000000000
--- a/tests/valid/Real_Valid_1.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-3.6
-1.2
-0.5
-2.88
\ No newline at end of file
diff --git a/tests/valid/Real_Valid_1.whiley b/tests/valid/Real_Valid_1.whiley
index 388eb75953..2e3e27d6fa 100644
--- a/tests/valid/Real_Valid_1.whiley
+++ b/tests/valid/Real_Valid_1.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
real x = 1.20
real y = 2.40
- sys.out.println(x + y)
- sys.out.println(y - x)
- sys.out.println(x / y)
- sys.out.println(x * y)
+ assume x + y == 3.6
+ assume y - x == 1.2
+ assume x / y == 0.5
+ assume x * y == 2.88
diff --git a/tests/valid/RecordAccess_Valid_1.sysout b/tests/valid/RecordAccess_Valid_1.sysout
deleted file mode 100755
index d86bac9de5..0000000000
--- a/tests/valid/RecordAccess_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-OK
diff --git a/tests/valid/RecordAccess_Valid_1.whiley b/tests/valid/RecordAccess_Valid_1.whiley
index 33da0c560e..f3e1a1c664 100644
--- a/tests/valid/RecordAccess_Valid_1.whiley
+++ b/tests/valid/RecordAccess_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type etype is {int mode, ...}
@@ -8,5 +8,6 @@ method get(Ptype this) -> int:
this->mode = 1
return this->mode
-method main(System.Console sys) -> void:
- sys.out.println_s("OK")
+public export method test() -> void:
+ assume get(new {mode:2}) == 1
+ assume get(new {mode:3,x:1}) == 1
diff --git a/tests/valid/RecordAccess_Valid_2.sysout b/tests/valid/RecordAccess_Valid_2.sysout
deleted file mode 100644
index a3978de2a1..0000000000
--- a/tests/valid/RecordAccess_Valid_2.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3.0
-3.57
diff --git a/tests/valid/RecordAccess_Valid_2.whiley b/tests/valid/RecordAccess_Valid_2.whiley
index 28d1dbfdd0..e91e1d8bdb 100644
--- a/tests/valid/RecordAccess_Valid_2.whiley
+++ b/tests/valid/RecordAccess_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type IntPoint is {int y, int x}
@@ -10,8 +10,8 @@ function sum(Point vp) -> real:
RealPoint rp = (RealPoint) vp
return rp.x + rp.y
-method main(System.Console sys) -> void:
+public export method test() -> void:
Point vp = {y: 2, x: 1}
- sys.out.println(sum(vp))
+ assume sum(vp) == 3.0
vp = {y: 2.34, x: 1.23}
- sys.out.println(sum(vp))
+ assume sum(vp) == 3.57
diff --git a/tests/valid/RecordAssign_Valid_1.sysout b/tests/valid/RecordAssign_Valid_1.sysout
deleted file mode 100755
index 30c9677b40..0000000000
--- a/tests/valid/RecordAssign_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{f1:1,f2:3}
diff --git a/tests/valid/RecordAssign_Valid_1.whiley b/tests/valid/RecordAssign_Valid_1.whiley
index f2b752e377..14b31feee5 100644
--- a/tests/valid/RecordAssign_Valid_1.whiley
+++ b/tests/valid/RecordAssign_Valid_1.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
+
type tac1tup is {int f1, int f2} where f1 < f2
function f() -> tac1tup:
- return {f1: 1, f2: 3}
+ return {f1: 2, f2: 3}
-method main(System.Console sys) -> void:
+public export method test() -> void:
tac1tup x = f()
x.f1 = x.f2 - 2
assert x.f1 != x.f2
- sys.out.println(x)
+ assume x == {f1: 1, f2: 3}
diff --git a/tests/valid/RecordAssign_Valid_10.sysout b/tests/valid/RecordAssign_Valid_10.sysout
deleted file mode 100755
index ed5b2dc08f..0000000000
--- a/tests/valid/RecordAssign_Valid_10.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{b1:1,b2:2}
-{b1:2,b2:3}
-{b1:9,b2:10}
diff --git a/tests/valid/RecordAssign_Valid_10.whiley b/tests/valid/RecordAssign_Valid_10.whiley
index bef6bfe88a..4566f0c974 100644
--- a/tests/valid/RecordAssign_Valid_10.whiley
+++ b/tests/valid/RecordAssign_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type bytes is {int b1, int b2}
@@ -6,7 +6,7 @@ function f(int a) -> bytes:
bytes bs = {b1: a, b2: a + 1}
return bs
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(9))
+public export method test() -> void:
+ assume f(1) == {b1: 1, b2: 2}
+ assume f(2) == {b1: 2, b2: 3}
+ assume f(9) == {b1: 9, b2: 10}
diff --git a/tests/valid/RecordAssign_Valid_2.sysout b/tests/valid/RecordAssign_Valid_2.sysout
deleted file mode 100644
index 114dc51459..0000000000
--- a/tests/valid/RecordAssign_Valid_2.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-BEFORE: {current:{x:0}}
-AFTER: {current:{x:1}}
diff --git a/tests/valid/RecordAssign_Valid_2.whiley b/tests/valid/RecordAssign_Valid_2.whiley
index 78b43c30a5..8fde371bcb 100644
--- a/tests/valid/RecordAssign_Valid_2.whiley
+++ b/tests/valid/RecordAssign_Valid_2.whiley
@@ -1,14 +1,10 @@
-import * from whiley.lang.*
-
type rec1 is {int x}
-
type rec2 is {rec1 current}
function f(rec2 r) -> rec2:
r.current.x = 1
return r
-method main(System.Console console) -> void:
+public export method test() -> void:
rec2 r = {current: {x: 0}}
- console.out.println_s("BEFORE: " ++ Any.toString(r))
- console.out.println_s("AFTER: " ++ Any.toString(f(r)))
+ assume f(r) == {current: {x: 1}}
diff --git a/tests/valid/RecordAssign_Valid_3.sysout b/tests/valid/RecordAssign_Valid_3.sysout
deleted file mode 100755
index 30c9677b40..0000000000
--- a/tests/valid/RecordAssign_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{f1:1,f2:3}
diff --git a/tests/valid/RecordAssign_Valid_3.whiley b/tests/valid/RecordAssign_Valid_3.whiley
index 7583bd2937..4e2447cf2a 100644
--- a/tests/valid/RecordAssign_Valid_3.whiley
+++ b/tests/valid/RecordAssign_Valid_3.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
+
type tac1tup is {int f1, int f2}
function f() -> tac1tup:
- return {f1: 1, f2: 3}
+ return {f1: 2, f2: 3}
-method main(System.Console sys) -> void:
+public export method test() -> void:
tac1tup x = f()
x.f1 = x.f2 - 2
assert x.f1 != x.f2
- sys.out.println(x)
+ assume x == {f1: 1, f2: 3}
diff --git a/tests/valid/RecordAssign_Valid_4.sysout b/tests/valid/RecordAssign_Valid_4.sysout
deleted file mode 100755
index 6f14448748..0000000000
--- a/tests/valid/RecordAssign_Valid_4.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{f1:2,f2:3}
-{f1:0,f2:3}
diff --git a/tests/valid/RecordAssign_Valid_4.whiley b/tests/valid/RecordAssign_Valid_4.whiley
index 1878cdfda7..398801db98 100644
--- a/tests/valid/RecordAssign_Valid_4.whiley
+++ b/tests/valid/RecordAssign_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type tac2ta is {int f1, int f2} where f1 < f2
@@ -7,9 +7,9 @@ type tac2tb is {int f1, int f2} where (f1 + 1) < f2
function f(tac2ta x) -> tac2tb:
return {f1: x.f1 - 1, f2: x.f2}
-method main(System.Console sys) -> void:
+public export method test() -> void:
tac2ta x = {f1: 2, f2: 3}
- sys.out.println(x)
+ assume x == {f1: 2, f2: 3}
x.f1 = 1
tac2tb y = f(x)
- sys.out.println(y)
+ assume y == {f1: 0, f2: 3}
diff --git a/tests/valid/RecordAssign_Valid_5.sysout b/tests/valid/RecordAssign_Valid_5.sysout
deleted file mode 100755
index 6f14448748..0000000000
--- a/tests/valid/RecordAssign_Valid_5.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{f1:2,f2:3}
-{f1:0,f2:3}
diff --git a/tests/valid/RecordAssign_Valid_5.whiley b/tests/valid/RecordAssign_Valid_5.whiley
index 8340dbbe99..1726d1f737 100644
--- a/tests/valid/RecordAssign_Valid_5.whiley
+++ b/tests/valid/RecordAssign_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type tac2ta is {int f1, int f2}
@@ -7,9 +7,9 @@ type tac2tb is {int f1, int f2}
function f(tac2ta x) -> tac2tb:
return {f1: x.f1 - 1, f2: x.f2}
-method main(System.Console sys) -> void:
+public export method test() -> void:
tac2ta x = {f1: 2, f2: 3}
- sys.out.println(x)
+ assume x == {f1: 2, f2: 3}
x.f1 = 1
tac2tb y = f(x)
- sys.out.println(y)
+ assume y == {f1: 0, f2: 3}
diff --git a/tests/valid/RecordAssign_Valid_6.sysout b/tests/valid/RecordAssign_Valid_6.sysout
deleted file mode 100755
index 3a2cae03dd..0000000000
--- a/tests/valid/RecordAssign_Valid_6.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-{f1:2,f2:3}
-{f1:1,f2:3}
-{f1:1,f2:3}
-{f1:1,f2:3}
diff --git a/tests/valid/RecordAssign_Valid_6.whiley b/tests/valid/RecordAssign_Valid_6.whiley
index be7d8032c7..b3f19fb53e 100644
--- a/tests/valid/RecordAssign_Valid_6.whiley
+++ b/tests/valid/RecordAssign_Valid_6.whiley
@@ -1,12 +1,10 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int f1, int f2} x = {f1: 2, f2: 3}
{int f1, int f2} y = {f1: 1, f2: 3}
- sys.out.println(x)
- sys.out.println(y)
assert x != y
x.f1 = 1
- sys.out.println(x)
- sys.out.println(y)
+ assume x == {f1: 1, f2: 3}
+ assume y == {f1: 1, f2: 3}
assert x == y
diff --git a/tests/valid/RecordAssign_Valid_7.sysout b/tests/valid/RecordAssign_Valid_7.sysout
deleted file mode 100755
index 948f0b0e2b..0000000000
--- a/tests/valid/RecordAssign_Valid_7.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{b1:1,b2:2}
-{b1:1,b2:1}
diff --git a/tests/valid/RecordAssign_Valid_7.whiley b/tests/valid/RecordAssign_Valid_7.whiley
index 825efa9a66..de4877b6e5 100644
--- a/tests/valid/RecordAssign_Valid_7.whiley
+++ b/tests/valid/RecordAssign_Valid_7.whiley
@@ -1,14 +1,14 @@
-import whiley.lang.*
-import * from whiley.lang.Int
+
+type i8 is (int x) where x >= 0 && x <= 255
type bytes is {i8 b1, i8 b2}
function f(i8 b) -> bytes:
return {b1: b, b2: 2}
-method main(System.Console sys) -> void:
+public export method test() -> void:
i8 b = 1
bytes bs = f(b)
- sys.out.println(bs)
+ assume bs == {b1: 1, b2: 2}
bs = {b1: b, b2: b}
- sys.out.println(bs)
+ assume bs == {b1: 1, b2: 1}
diff --git a/tests/valid/RecordAssign_Valid_8.sysout b/tests/valid/RecordAssign_Valid_8.sysout
deleted file mode 100755
index 948f0b0e2b..0000000000
--- a/tests/valid/RecordAssign_Valid_8.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{b1:1,b2:2}
-{b1:1,b2:1}
diff --git a/tests/valid/RecordAssign_Valid_8.whiley b/tests/valid/RecordAssign_Valid_8.whiley
index 335aa8c000..a96da9488c 100644
--- a/tests/valid/RecordAssign_Valid_8.whiley
+++ b/tests/valid/RecordAssign_Valid_8.whiley
@@ -1,13 +1,13 @@
-import whiley.lang.*
+
type bytes is {int b1, int b2}
function f(int b) -> bytes:
return {b1: b, b2: 2}
-method main(System.Console sys) -> void:
+public export method test() -> void:
int b = 1
bytes bs = f(b)
- sys.out.println(bs)
+ assume bs == {b1: 1, b2: 2}
bs = {b1: b, b2: b}
- sys.out.println(bs)
+ assume bs == {b1: 1, b2: 1}
diff --git a/tests/valid/RecordAssign_Valid_9.sysout b/tests/valid/RecordAssign_Valid_9.sysout
deleted file mode 100755
index ed5b2dc08f..0000000000
--- a/tests/valid/RecordAssign_Valid_9.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{b1:1,b2:2}
-{b1:2,b2:3}
-{b1:9,b2:10}
diff --git a/tests/valid/RecordAssign_Valid_9.whiley b/tests/valid/RecordAssign_Valid_9.whiley
index e694b785bc..cacf0b7f92 100644
--- a/tests/valid/RecordAssign_Valid_9.whiley
+++ b/tests/valid/RecordAssign_Valid_9.whiley
@@ -1,6 +1,6 @@
-import whiley.lang.*
-import * from whiley.lang.Int
+
+type i8 is (int x) where x >= 0 && x <= 255
type bytes is {i8 b1, i8 b2}
function f(int a) -> bytes
@@ -8,7 +8,7 @@ requires a > 0 && a < 10:
bytes bs = {b1: a, b2: a + 1}
return bs
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(9))
+public export method test() -> void:
+ assume f(1) == {b1: 1, b2: 2}
+ assume f(2) == {b1: 2, b2: 3}
+ assume f(9) == {b1: 9, b2: 10}
diff --git a/tests/valid/RecordCoercion_Valid_1.sysout b/tests/valid/RecordCoercion_Valid_1.sysout
deleted file mode 100755
index 8bc11d1348..0000000000
--- a/tests/valid/RecordCoercion_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{x:1}
-{x:1}
-1
diff --git a/tests/valid/RecordCoercion_Valid_1.whiley b/tests/valid/RecordCoercion_Valid_1.whiley
index 9a95d3c6df..6eb6c4ff1f 100644
--- a/tests/valid/RecordCoercion_Valid_1.whiley
+++ b/tests/valid/RecordCoercion_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Rec1 is {int x}
@@ -8,9 +8,8 @@ function f(Rec2 rec) -> int:
int x / int y = rec.x
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
Rec1 rec = {x: 1}
- sys.out.println(rec)
int num = f((Rec2) rec)
- sys.out.println(rec)
- sys.out.println(num)
+ assume num == 1
+ assert rec == {x:1}
diff --git a/tests/valid/RecordConversion_Valid_1.sysout b/tests/valid/RecordConversion_Valid_1.sysout
deleted file mode 100755
index d3827e75a5..0000000000
--- a/tests/valid/RecordConversion_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1.0
diff --git a/tests/valid/RecordConversion_Valid_1.whiley b/tests/valid/RecordConversion_Valid_1.whiley
index 1c507f5705..35e776d216 100644
--- a/tests/valid/RecordConversion_Valid_1.whiley
+++ b/tests/valid/RecordConversion_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type realtup is {real op}
@@ -6,6 +6,6 @@ function f(realtup t) -> real:
real x = t.op
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int op} t = {op: 1}
- sys.out.println(f((realtup) t))
+ assume f((realtup) t) == 1.0
diff --git a/tests/valid/RecordDefine_Valid_1.sysout b/tests/valid/RecordDefine_Valid_1.sysout
deleted file mode 100755
index f134b0edf2..0000000000
--- a/tests/valid/RecordDefine_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{x:1,y:1}
diff --git a/tests/valid/RecordDefine_Valid_1.whiley b/tests/valid/RecordDefine_Valid_1.whiley
index dce05f5d1e..6b87bc5d7e 100644
--- a/tests/valid/RecordDefine_Valid_1.whiley
+++ b/tests/valid/RecordDefine_Valid_1.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type Point is {int y, int x} where x > 0 && y > 0
function f(Point x) -> Point:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
Point p = f({y: 1, x: 1})
- sys.out.println(p)
+ assume p == {y: 1, x: 1}
diff --git a/tests/valid/RecordDefine_Valid_2.sysout b/tests/valid/RecordDefine_Valid_2.sysout
deleted file mode 100755
index f134b0edf2..0000000000
--- a/tests/valid/RecordDefine_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{x:1,y:1}
diff --git a/tests/valid/RecordDefine_Valid_2.whiley b/tests/valid/RecordDefine_Valid_2.whiley
index 9f18f45551..539a3587aa 100644
--- a/tests/valid/RecordDefine_Valid_2.whiley
+++ b/tests/valid/RecordDefine_Valid_2.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type Point is {int y, int x}
function f(Point x) -> Point:
return x
-method main(System.Console sys) -> void:
+public export method test() -> void:
Point p = f({y: 1, x: 1})
- sys.out.println(p)
+ assume p == {y: 1, x: 1}
diff --git a/tests/valid/RecordSubtype_Valid_1.whiley b/tests/valid/RecordSubtype_Valid_1.whiley
index f01d534ca9..3c6e818dbe 100644
--- a/tests/valid/RecordSubtype_Valid_1.whiley
+++ b/tests/valid/RecordSubtype_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type R1 is {null | int x}
@@ -11,8 +11,8 @@ type R4 is R2 | R3
function f(R1 x) -> R4:
return x
-method main(System.Console sys) -> void:
- z1 = f({x: 1})
- z2 = f({x: null})
- sys.out.println(z1)
- sys.out.println(z2)
+public export method test() -> void:
+ R4 z1 = f({x: 1})
+ R4 z2 = f({x: null})
+ assume z1 == {x: 1}
+ assume z2 == {x: null}
diff --git a/tests/valid/RecordSubtype_Valid_2.whiley b/tests/valid/RecordSubtype_Valid_2.whiley
index 8db6a5252e..893e717081 100644
--- a/tests/valid/RecordSubtype_Valid_2.whiley
+++ b/tests/valid/RecordSubtype_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type List1 is {null | List1 next, int | null data}
@@ -11,8 +11,8 @@ type List4 is List3 | List2
function f(List1 r) -> List4:
return r
-method main(System.Console sys) -> void:
- list = {next: null, data: 1}
+public export method test() -> void:
+ List1 list = {next: null, data: 1}
list = {next: list, data: null}
- ans = f(list)
- sys.out.println(ans)
+ List4 ans = f(list)
+ assume ans == {next: {next: null, data:1}, data: null}
diff --git a/tests/valid/RecursiveType_Valid_1.sysout b/tests/valid/RecursiveType_Valid_1.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/RecursiveType_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/RecursiveType_Valid_1.whiley b/tests/valid/RecursiveType_Valid_1.whiley
index a4aa8804ca..c04c3308b5 100644
--- a/tests/valid/RecursiveType_Valid_1.whiley
+++ b/tests/valid/RecursiveType_Valid_1.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
type Expr is int | {int op, Expr left, Expr right}
-method main(System.Console sys) -> void:
+public export method test() -> void:
Expr e = 1
- sys.out.println(e)
+ assume e == 1
diff --git a/tests/valid/RecursiveType_Valid_10.sysout b/tests/valid/RecursiveType_Valid_10.sysout
deleted file mode 100755
index fc4eca0384..0000000000
--- a/tests/valid/RecursiveType_Valid_10.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{left:1,op:1,right:2}
diff --git a/tests/valid/RecursiveType_Valid_10.whiley b/tests/valid/RecursiveType_Valid_10.whiley
index 7e761ee76f..be4d383a64 100644
--- a/tests/valid/RecursiveType_Valid_10.whiley
+++ b/tests/valid/RecursiveType_Valid_10.whiley
@@ -1,7 +1,9 @@
-import whiley.lang.*
+
type expr is int | {int op, expr left, expr right}
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e = {op: 1, left: 1, right: 2}
- sys.out.println(e)
+ assert e.op == 1
+ assert e.left == 1
+ assert e.right == 2
diff --git a/tests/valid/RecursiveType_Valid_11.sysout b/tests/valid/RecursiveType_Valid_11.sysout
deleted file mode 100755
index 9ec45b4bd7..0000000000
--- a/tests/valid/RecursiveType_Valid_11.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{left:1,op:1,right:2}
-{left:{left:1,op:1,right:2},op:2,right:2}
-{left:{left:2,op:3,right:2},op:2,right:2}
diff --git a/tests/valid/RecursiveType_Valid_11.whiley b/tests/valid/RecursiveType_Valid_11.whiley
index 77ddad3a0d..50e4506178 100644
--- a/tests/valid/RecursiveType_Valid_11.whiley
+++ b/tests/valid/RecursiveType_Valid_11.whiley
@@ -1,21 +1,18 @@
-import whiley.lang.*
-constant ADD is 1
+constant ADD is 1
constant SUB is 2
-
constant MUL is 3
-
constant DIV is 4
type binop is {int op, expr left, expr right} where op in {ADD, SUB, MUL, DIV}
type expr is int | binop
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e1 = {op: ADD, left: 1, right: 2}
expr e2 = {op: SUB, left: e1, right: 2}
expr e3 = {op: SUB, left: {op: MUL, left: 2, right: 2}, right: 2}
- sys.out.println(e1)
- sys.out.println(e2)
- sys.out.println(e3)
+ assert e1 == {op: ADD, left: 1, right: 2}
+ assert e2 == {op: SUB, left: {op: ADD, left: 1, right: 2}, right: 2}
+ assert e3 == {op: SUB, left: {op: MUL, left: 2, right: 2}, right: 2}
diff --git a/tests/valid/RecursiveType_Valid_12.sysout b/tests/valid/RecursiveType_Valid_12.sysout
deleted file mode 100644
index 77a601d0de..0000000000
--- a/tests/valid/RecursiveType_Valid_12.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{data:2,lhs:{data:1,lhs:null,rhs:null},rhs:{data:3,lhs:null,rhs:null}}
-{data:4,lhs:{data:2,lhs:{data:1,lhs:null,rhs:null},rhs:{data:3,lhs:null,rhs:null}},rhs:{data:5,lhs:null,rhs:null}}
diff --git a/tests/valid/RecursiveType_Valid_12.whiley b/tests/valid/RecursiveType_Valid_12.whiley
index 8e8ff9f62f..e4a269c582 100644
--- a/tests/valid/RecursiveType_Valid_12.whiley
+++ b/tests/valid/RecursiveType_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Tree is null | Node
@@ -8,11 +8,12 @@ function Tree(int data, Tree left, Tree right) -> Tree
requires ((left == null) || (left.data < data)) && ((right == null) || (right.data > data)):
return {data: data, rhs: right, lhs: left}
-method main(System.Console sys) -> void:
+public export method test() -> void:
Tree l1 = Tree(1, null, null)
Tree l2 = Tree(3, null, null)
Tree l3 = Tree(5, null, null)
Tree t1 = Tree(2, l1, l2)
- sys.out.println(t1)
+ assume t1 == {data:2,lhs:{data:1,lhs:null,rhs:null},rhs:{data:3,lhs:null,rhs:null}}
Tree t2 = Tree(4, t1, l3)
- sys.out.println(t2)
+ assume t2 == {data:4,lhs:{data:2,lhs:{data:1,lhs:null,rhs:null},rhs:{data:3,lhs:null,rhs:null}},rhs:{data:5,lhs:null,rhs:null}}
+
diff --git a/tests/valid/RecursiveType_Valid_13.sysout b/tests/valid/RecursiveType_Valid_13.sysout
deleted file mode 100755
index 9ec45b4bd7..0000000000
--- a/tests/valid/RecursiveType_Valid_13.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{left:1,op:1,right:2}
-{left:{left:1,op:1,right:2},op:2,right:2}
-{left:{left:2,op:3,right:2},op:2,right:2}
diff --git a/tests/valid/RecursiveType_Valid_13.whiley b/tests/valid/RecursiveType_Valid_13.whiley
index bd200c3419..7ad971b9eb 100644
--- a/tests/valid/RecursiveType_Valid_13.whiley
+++ b/tests/valid/RecursiveType_Valid_13.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant ADD is 1
@@ -12,10 +12,13 @@ type binop is {int op, expr left, expr right}
type expr is int | binop
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e1 = {op: ADD, left: 1, right: 2}
expr e2 = {op: SUB, left: e1, right: 2}
expr e3 = {op: SUB, left: {op: MUL, left: 2, right: 2}, right: 2}
- sys.out.println(e1)
- sys.out.println(e2)
- sys.out.println(e3)
+ assume e1 == {left:1,op:1,right:2}
+ assume e2 == {left:{left:1,op:1,right:2},op:2,right:2}
+ assume e3 == {left:{left:2,op:3,right:2},op:2,right:2}
+
+
+
diff --git a/tests/valid/RecursiveType_Valid_14.sysout b/tests/valid/RecursiveType_Valid_14.sysout
deleted file mode 100755
index a15dce001e..0000000000
--- a/tests/valid/RecursiveType_Valid_14.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{left:1,op:1,right:2}
-{left:{left:1,op:1,right:2},op:2,right:2}
diff --git a/tests/valid/RecursiveType_Valid_14.whiley b/tests/valid/RecursiveType_Valid_14.whiley
index c4c5ed913d..5a7e36cfa5 100644
--- a/tests/valid/RecursiveType_Valid_14.whiley
+++ b/tests/valid/RecursiveType_Valid_14.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant ADD is 1
@@ -14,10 +14,11 @@ type asbinop is {int op, Expr left, Expr right} where op in {ADD, SUB}
type Expr is int | binop
-method main(System.Console sys) -> void:
+public export method test() -> void:
Expr bop1 = {op: ADD, left: 1, right: 2}
Expr bop2 = bop1
Expr e1 = bop1
Expr e2 = {op: SUB, left: bop1, right: 2}
- sys.out.println(e1)
- sys.out.println(e2)
+ assume e1 == {left:1,op:1,right:2}
+ assume e2 == {left:{left:1,op:1,right:2},op:2,right:2}
+
diff --git a/tests/valid/RecursiveType_Valid_15.sysout b/tests/valid/RecursiveType_Valid_15.sysout
deleted file mode 100755
index a15dce001e..0000000000
--- a/tests/valid/RecursiveType_Valid_15.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{left:1,op:1,right:2}
-{left:{left:1,op:1,right:2},op:2,right:2}
diff --git a/tests/valid/RecursiveType_Valid_15.whiley b/tests/valid/RecursiveType_Valid_15.whiley
index 2c96ff4cc0..826b0dbc99 100644
--- a/tests/valid/RecursiveType_Valid_15.whiley
+++ b/tests/valid/RecursiveType_Valid_15.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant ADD is 1
@@ -14,10 +14,10 @@ type asbinop is {int op, Expr left, Expr right}
type Expr is int | binop
-method main(System.Console sys) -> void:
+public export method test() -> void:
Expr bop1 = {op: ADD, left: 1, right: 2}
Expr bop2 = bop1
Expr e1 = bop1
Expr e2 = {op: SUB, left: bop1, right: 2}
- sys.out.println(e1)
- sys.out.println(e2)
+ assume e1 == {left:1,op:1,right:2}
+ assume e2 == {left:{left:1,op:1,right:2},op:2,right:2}
diff --git a/tests/valid/RecursiveType_Valid_16.sysout b/tests/valid/RecursiveType_Valid_16.sysout
deleted file mode 100755
index 4e4fbd7de5..0000000000
--- a/tests/valid/RecursiveType_Valid_16.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{err:[101, 114, 114]}
diff --git a/tests/valid/RecursiveType_Valid_16.whiley b/tests/valid/RecursiveType_Valid_16.whiley
index 7d5ff8a1ec..01b9e59373 100644
--- a/tests/valid/RecursiveType_Valid_16.whiley
+++ b/tests/valid/RecursiveType_Valid_16.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Expr is {int num} | {int op, Expr rhs, Expr lhs} | {[int] err}
@@ -8,6 +8,6 @@ function parseTerm() -> Expr:
function parseIdentifier() -> Expr:
return {err: "err"}
-method main(System.Console sys) -> void:
+public export method test() -> void:
Expr e = parseTerm()
- sys.out.println(e)
+ assume e == {err: "err"}
diff --git a/tests/valid/RecursiveType_Valid_17.sysout b/tests/valid/RecursiveType_Valid_17.sysout
deleted file mode 100755
index dd67c62231..0000000000
--- a/tests/valid/RecursiveType_Valid_17.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{num:1}
diff --git a/tests/valid/RecursiveType_Valid_17.whiley b/tests/valid/RecursiveType_Valid_17.whiley
index 5fd2ab4d90..0b917183fc 100644
--- a/tests/valid/RecursiveType_Valid_17.whiley
+++ b/tests/valid/RecursiveType_Valid_17.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type State is {[int] input, int pos}
where (pos >= 0) && (pos <= |input|)
@@ -12,6 +12,7 @@ function parse([int] input) -> Expr:
function parseAddSubExpr(State st) -> {Expr e, State st}:
return {e: {num: 1}, st: st}
-method main(System.Console sys) -> void:
+public export method test() -> void:
Expr e = parse("Hello")
- sys.out.println(e)
+ assume e == {num:1}
+
diff --git a/tests/valid/RecursiveType_Valid_18.sysout b/tests/valid/RecursiveType_Valid_18.sysout
deleted file mode 100755
index dd67c62231..0000000000
--- a/tests/valid/RecursiveType_Valid_18.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{num:1}
diff --git a/tests/valid/RecursiveType_Valid_18.whiley b/tests/valid/RecursiveType_Valid_18.whiley
index 27958894a8..c904ab1e0d 100644
--- a/tests/valid/RecursiveType_Valid_18.whiley
+++ b/tests/valid/RecursiveType_Valid_18.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type State is {[int] input, int pos}
@@ -11,6 +11,7 @@ function parse([int] input) -> Expr:
function parseAddSubExpr(State st) -> {Expr e, State st}:
return {e: {num: 1}, st: st}
-method main(System.Console sys) -> void:
+public export method test() -> void:
Expr e = parse("Hello")
- sys.out.println(e)
+ assume e == {num:1}
+
diff --git a/tests/valid/RecursiveType_Valid_19.sysout b/tests/valid/RecursiveType_Valid_19.sysout
deleted file mode 100755
index 9b0eadd167..0000000000
--- a/tests/valid/RecursiveType_Valid_19.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{lhs:{lhs:1,rhs:2},rhs:1}
diff --git a/tests/valid/RecursiveType_Valid_19.whiley b/tests/valid/RecursiveType_Valid_19.whiley
index 6f3e33c648..e7f8c17465 100644
--- a/tests/valid/RecursiveType_Valid_19.whiley
+++ b/tests/valid/RecursiveType_Valid_19.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int n) where n >= 0
@@ -12,6 +12,7 @@ function f(posExpr e1) -> expr:
expr e2 = e1
return e2
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e = f({rhs: 1, lhs: {rhs: 2, lhs: 1}})
- sys.out.println(e)
+ assume e == {lhs:{lhs:1,rhs:2},rhs:1}
+
diff --git a/tests/valid/RecursiveType_Valid_2.sysout b/tests/valid/RecursiveType_Valid_2.sysout
deleted file mode 100755
index 02ea43e255..0000000000
--- a/tests/valid/RecursiveType_Valid_2.sysout
+++ /dev/null
@@ -1,15 +0,0 @@
-46.0
-41.0
-35.0
-28.0
-20.0
-11.0
-1.0
-2.0
-3.0
-4.0
-5.0
-6.0
-7.0
-8.0
-9.0
diff --git a/tests/valid/RecursiveType_Valid_2.whiley b/tests/valid/RecursiveType_Valid_2.whiley
index 15dbe0bbb2..e80f329c17 100644
--- a/tests/valid/RecursiveType_Valid_2.whiley
+++ b/tests/valid/RecursiveType_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Expr is real | Var | BinOp
@@ -19,12 +19,6 @@ function build(int i) -> Expr:
else:
return {rhs: build(i + 1), lhs: build(i + 10)}
-function sbuild(int i) -> SExpr:
- if i > 20:
- return {err: "error"}
- else:
- return build(i)
-
function evaluate(Expr e) -> real:
if e is real:
return e
@@ -33,13 +27,19 @@ function evaluate(Expr e) -> real:
else:
return evaluate(e.lhs) + evaluate(e.rhs)
-public method main(System.Console sys) -> void:
- int i = -5
- while i < 10:
- SExpr e = sbuild(i)
- if e is {[int] err}:
- sys.out.println_s("syntax error: " ++ e.err)
- else:
- e = evaluate(e)
- sys.out.println(e)
- i = i + 1
+public export method test() -> void:
+ assume evaluate(build(-5)) == 46.0
+ assume evaluate(build(-4)) == 41.0
+ assume evaluate(build(-3)) == 35.0
+ assume evaluate(build(-2)) == 28.0
+ assume evaluate(build(-1)) == 20.0
+ assume evaluate(build(0)) == 11.0
+ assume evaluate(build(1)) == 1.0
+ assume evaluate(build(2)) == 2.0
+ assume evaluate(build(3)) == 3.0
+ assume evaluate(build(4)) == 4.0
+ assume evaluate(build(5)) == 5.0
+ assume evaluate(build(6)) == 6.0
+ assume evaluate(build(7)) == 7.0
+ assume evaluate(build(8)) == 8.0
+ assume evaluate(build(9)) == 9.0
diff --git a/tests/valid/RecursiveType_Valid_20.sysout b/tests/valid/RecursiveType_Valid_20.sysout
deleted file mode 100755
index 9b0eadd167..0000000000
--- a/tests/valid/RecursiveType_Valid_20.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{lhs:{lhs:1,rhs:2},rhs:1}
diff --git a/tests/valid/RecursiveType_Valid_20.whiley b/tests/valid/RecursiveType_Valid_20.whiley
index 7c585674d8..213e18f95f 100644
--- a/tests/valid/RecursiveType_Valid_20.whiley
+++ b/tests/valid/RecursiveType_Valid_20.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is int
@@ -12,6 +12,7 @@ function f(posExpr e1) -> expr:
expr e2 = e1
return e2
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e = f({rhs: 1, lhs: {rhs: 2, lhs: 1}})
- sys.out.println(e)
+ assume e == {lhs:{lhs:1,rhs:2},rhs:1}
+
diff --git a/tests/valid/RecursiveType_Valid_21.sysout b/tests/valid/RecursiveType_Valid_21.sysout
deleted file mode 100755
index 58c3aee7ba..0000000000
--- a/tests/valid/RecursiveType_Valid_21.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-3
-6
diff --git a/tests/valid/RecursiveType_Valid_21.whiley b/tests/valid/RecursiveType_Valid_21.whiley
index 4534abb673..2b800a4ded 100644
--- a/tests/valid/RecursiveType_Valid_21.whiley
+++ b/tests/valid/RecursiveType_Valid_21.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Link is {LinkedList next, int data}
@@ -10,10 +10,10 @@ function sum(LinkedList l) -> int:
else:
return l.data + sum(l.next)
-method main(System.Console sys) -> void:
+public export method test() -> void:
LinkedList l1 = {next: null, data: 1}
LinkedList l2 = {next: l1, data: 2}
LinkedList l3 = {next: l2, data: 3}
- sys.out.println(sum(l1))
- sys.out.println(sum(l2))
- sys.out.println(sum(l3))
+ assume sum(l1) == 1
+ assume sum(l2) == 3
+ assume sum(l3) == 6
diff --git a/tests/valid/RecursiveType_Valid_22.sysout b/tests/valid/RecursiveType_Valid_22.sysout
deleted file mode 100644
index dac32ecf1d..0000000000
--- a/tests/valid/RecursiveType_Valid_22.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-false
-true
-true
diff --git a/tests/valid/RecursiveType_Valid_22.whiley b/tests/valid/RecursiveType_Valid_22.whiley
index a66cc9532e..0b07f09f37 100644
--- a/tests/valid/RecursiveType_Valid_22.whiley
+++ b/tests/valid/RecursiveType_Valid_22.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type SortedList is null | SortedListNode
@@ -20,12 +20,12 @@ function contains(int item, SortedList list) -> bool:
else:
return contains(item, list.next)
-method main(System.Console sys) -> void:
+public export method test() -> void:
SortedList list = SortedList(10, null)
list = SortedList(5, list)
list = SortedList(3, list)
list = SortedList(1, list)
list = SortedList(0, list)
- sys.out.println(contains(2, list))
- sys.out.println(contains(3, list))
- sys.out.println(contains(10, list))
+ assume contains(2, list) == false
+ assume contains(3, list) == true
+ assume contains(10, list) == true
diff --git a/tests/valid/RecursiveType_Valid_23.sysout b/tests/valid/RecursiveType_Valid_23.sysout
deleted file mode 100755
index 043e5719ab..0000000000
--- a/tests/valid/RecursiveType_Valid_23.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-3
-0
diff --git a/tests/valid/RecursiveType_Valid_23.whiley b/tests/valid/RecursiveType_Valid_23.whiley
index c5ef9d5d16..5b4b7afbfe 100644
--- a/tests/valid/RecursiveType_Valid_23.whiley
+++ b/tests/valid/RecursiveType_Valid_23.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type BinOp is {Expr rhs, Expr lhs}
@@ -10,8 +10,8 @@ function f(Expr e) -> int:
else:
return 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
int v = f([1.0, 2.0, 3.0])
- sys.out.println(v)
+ assume v == 3
v = f(1.234)
- sys.out.println(v)
+ assume v == 0
diff --git a/tests/valid/RecursiveType_Valid_24.sysout b/tests/valid/RecursiveType_Valid_24.sysout
deleted file mode 100755
index bc856dafab..0000000000
--- a/tests/valid/RecursiveType_Valid_24.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-0
-1
-2
-3
diff --git a/tests/valid/RecursiveType_Valid_24.whiley b/tests/valid/RecursiveType_Valid_24.whiley
index 17466961df..df29858bef 100644
--- a/tests/valid/RecursiveType_Valid_24.whiley
+++ b/tests/valid/RecursiveType_Valid_24.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Link is null | [Link]
@@ -13,12 +13,12 @@ function maxDepth(Link l) -> int:
else:
return 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
Link l1 = null
Link l2 = [l1]
Link l3 = [l2]
Link l4 = [l3]
- sys.out.println(maxDepth(l1))
- sys.out.println(maxDepth(l2))
- sys.out.println(maxDepth(l3))
- sys.out.println(maxDepth(l4))
+ assume maxDepth(l1) == 0
+ assume maxDepth(l2) == 1
+ assume maxDepth(l3) == 2
+ assume maxDepth(l4) == 3
diff --git a/tests/valid/RecursiveType_Valid_25.sysout b/tests/valid/RecursiveType_Valid_25.sysout
deleted file mode 100755
index 08631021cb..0000000000
--- a/tests/valid/RecursiveType_Valid_25.sysout
+++ /dev/null
@@ -1 +0,0 @@
-0.0123
diff --git a/tests/valid/RecursiveType_Valid_25.whiley b/tests/valid/RecursiveType_Valid_25.whiley
index 4c1478bdf5..a153e61e75 100644
--- a/tests/valid/RecursiveType_Valid_25.whiley
+++ b/tests/valid/RecursiveType_Valid_25.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Expr is real | [Expr]
@@ -7,9 +7,9 @@ type Value is real | [Value]
function init() -> Value:
return 0.0123
-method main(System.Console sys) -> void:
+public export method test() -> void:
Value v = init()
if v is [Expr]:
- sys.out.println_s("GOT LIST")
+ assume false
else:
- sys.out.println(v)
+ assume v == 0.0123
diff --git a/tests/valid/RecursiveType_Valid_26.sysout b/tests/valid/RecursiveType_Valid_26.sysout
deleted file mode 100644
index ce647d098f..0000000000
--- a/tests/valid/RecursiveType_Valid_26.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-0
-1
-1
--1
--1
diff --git a/tests/valid/RecursiveType_Valid_26.whiley b/tests/valid/RecursiveType_Valid_26.whiley
index 61217279b8..c7b995d4e2 100644
--- a/tests/valid/RecursiveType_Valid_26.whiley
+++ b/tests/valid/RecursiveType_Valid_26.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Expr is real | {int data, Expr lhs} | [Expr]
@@ -13,14 +13,14 @@ function toString(Expr e) -> int:
else:
return -1
-method main(System.Console sys) -> void:
+public export method test() -> void:
SubExpr se1 = 0.1234
SubExpr se2 = {data: 1, lhs: se1}
SubExpr se3 = {data: 45, lhs: se2}
Expr e1 = [se1]
Expr e2 = [e1, se1, se2]
- sys.out.println(toString(se1))
- sys.out.println(toString(se2))
- sys.out.println(toString(se3))
- sys.out.println(toString(e1))
- sys.out.println(toString(e2))
+ assume toString(se1) == 0
+ assume toString(se2) == 1
+ assume toString(se3) == 1
+ assume toString(e1) == -1
+ assume toString(e2) == -1
diff --git a/tests/valid/RecursiveType_Valid_27.sysout b/tests/valid/RecursiveType_Valid_27.sysout
deleted file mode 100644
index 1b3e89d262..0000000000
--- a/tests/valid/RecursiveType_Valid_27.sysout
+++ /dev/null
@@ -1,15 +0,0 @@
-{lhs:5.0,rhs:{lhs:6.0,rhs:{lhs:7.0,rhs:{lhs:8.0,rhs:{lhs:9.0,rhs:{lhs:10.0,rhs:1.0}}}}}}
-{lhs:6.0,rhs:{lhs:7.0,rhs:{lhs:8.0,rhs:{lhs:9.0,rhs:{lhs:10.0,rhs:1.0}}}}}
-{lhs:7.0,rhs:{lhs:8.0,rhs:{lhs:9.0,rhs:{lhs:10.0,rhs:1.0}}}}
-{lhs:8.0,rhs:{lhs:9.0,rhs:{lhs:10.0,rhs:1.0}}}
-{lhs:9.0,rhs:{lhs:10.0,rhs:1.0}}
-{lhs:10.0,rhs:1.0}
-1.0
-2.0
-3.0
-4.0
-5.0
-6.0
-7.0
-8.0
-9.0
diff --git a/tests/valid/RecursiveType_Valid_27.whiley b/tests/valid/RecursiveType_Valid_27.whiley
index c33ca4c1f8..ea9a329fe2 100644
--- a/tests/valid/RecursiveType_Valid_27.whiley
+++ b/tests/valid/RecursiveType_Valid_27.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Expr is real | Var | BinOp
@@ -25,12 +25,19 @@ function sbuild(int i) -> SExpr:
else:
return build(i)
-public method main(System.Console sys) -> void:
- int i = -5
- while i < 10:
- SExpr e = sbuild(i)
- if e is SyntaxError:
- sys.out.println_s("syntax error: " ++ e.err)
- else:
- sys.out.println(e)
- i = i + 1
+public export method test() -> void:
+ assume sbuild(-5) == {lhs:5.0,rhs:{lhs:6.0,rhs:{lhs:7.0,rhs:{lhs:8.0,rhs:{lhs:9.0,rhs:{lhs:10.0,rhs:1.0}}}}}}
+ assume sbuild(-4) == {lhs:6.0,rhs:{lhs:7.0,rhs:{lhs:8.0,rhs:{lhs:9.0,rhs:{lhs:10.0,rhs:1.0}}}}}
+ assume sbuild(-3) == {lhs:7.0,rhs:{lhs:8.0,rhs:{lhs:9.0,rhs:{lhs:10.0,rhs:1.0}}}}
+ assume sbuild(-2) == {lhs:8.0,rhs:{lhs:9.0,rhs:{lhs:10.0,rhs:1.0}}}
+ assume sbuild(-1) == {lhs:9.0,rhs:{lhs:10.0,rhs:1.0}}
+ assume sbuild(0) == {lhs:10.0,rhs:1.0}
+ assume sbuild(1) == 1.0
+ assume sbuild(2) == 2.0
+ assume sbuild(3) == 3.0
+ assume sbuild(4) == 4.0
+ assume sbuild(5) == 5.0
+ assume sbuild(6) == 6.0
+ assume sbuild(7) == 7.0
+ assume sbuild(8) == 8.0
+ assume sbuild(9) == 9.0
diff --git a/tests/valid/RecursiveType_Valid_29.sysout b/tests/valid/RecursiveType_Valid_29.sysout
deleted file mode 100644
index 670454b6f9..0000000000
--- a/tests/valid/RecursiveType_Valid_29.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-CONTAINS(Pat) = false
-CONTAINS(Hat) = true
-CONTAINS(Cat) = true
diff --git a/tests/valid/RecursiveType_Valid_29.whiley b/tests/valid/RecursiveType_Valid_29.whiley
index 32767154c8..9686647c93 100644
--- a/tests/valid/RecursiveType_Valid_29.whiley
+++ b/tests/valid/RecursiveType_Valid_29.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Trie is {
{int=>Trie} children
@@ -37,14 +37,17 @@ function contains(Trie t, [int] s) -> bool:
//
return false
-method main(System.Console console):
+public export method test():
[[int]] words = ["Hat","Cat","Mat","Heat","Hot"]
// First, initialise trie to include words
Trie t = Trie()
- for w in words:
- t = add(t,w)
- // Second print out trie
- for w in ["Pat","Hat","Cat"]:
- bool f = contains(t,w)
- console.out.println_s("CONTAINS(" ++ w ++ ") = " ++ Any.toString(f))
+ t = add(t,"hat")
+ t = add(t,"Cat")
+ t = add(t,"Mat")
+ t = add(t,"Heat")
+ t = add(t,"Hat")
+ // Second check tries
+ assume !contains(t,"Pat")
+ assume contains(t,"Hat")
+ assume contains(t,"Cat")
diff --git a/tests/valid/RecursiveType_Valid_3.sysout b/tests/valid/RecursiveType_Valid_3.sysout
deleted file mode 100755
index fdb6a7ca4a..0000000000
--- a/tests/valid/RecursiveType_Valid_3.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-1
-112
-31231242
-[1, 2, 3]
diff --git a/tests/valid/RecursiveType_Valid_3.whiley b/tests/valid/RecursiveType_Valid_3.whiley
index 8a14e41451..c0a32aaa72 100644
--- a/tests/valid/RecursiveType_Valid_3.whiley
+++ b/tests/valid/RecursiveType_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Expr is int | real | [Expr] | ListAccess
@@ -24,8 +24,9 @@ function evaluate(Expr e) -> Value:
else:
return null
-public method main(System.Console sys) -> void:
- sys.out.println(evaluate(1))
- sys.out.println(evaluate({index: 0, src: [112, 212, 342]}))
- sys.out.println(evaluate({index: 2, src: [112312, 289712, 31231242]}))
- sys.out.println(evaluate([1, 2, 3]))
+public export method test() -> void:
+ assume evaluate(1) == 1
+ assume evaluate({index: 0, src: [112, 212, 342]}) == 112
+ assume evaluate({index: 2, src: [112312, 289712, 31231242]}) == 31231242
+ assume evaluate([1, 2, 3]) == [1, 2, 3]
+
diff --git a/tests/valid/RecursiveType_Valid_30.sysout b/tests/valid/RecursiveType_Valid_30.sysout
deleted file mode 100644
index 5d4af6f5ce..0000000000
--- a/tests/valid/RecursiveType_Valid_30.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[]
-[[]]
-[[[]]]
diff --git a/tests/valid/RecursiveType_Valid_30.whiley b/tests/valid/RecursiveType_Valid_30.whiley
index 363daf990a..f914010165 100644
--- a/tests/valid/RecursiveType_Valid_30.whiley
+++ b/tests/valid/RecursiveType_Valid_30.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
type Recursive is [Recursive]
@@ -9,10 +9,10 @@ function append(Recursive r1, Recursive r2) -> Recursive:
r1[0] = append(r1[0],r2)
return r1
-method main(System.Console console):
+public export method test():
Recursive r1 = []
Recursive r2 = append(r1,[[]])
Recursive r3 = append(r2,[[]])
- console.out.println(r1)
- console.out.println(r2)
- console.out.println(r3)
+ assume r1 == []
+ assume r2 == [[]]
+ assume r3 == [[[]]]
diff --git a/tests/valid/RecursiveType_Valid_31.sysout b/tests/valid/RecursiveType_Valid_31.sysout
deleted file mode 100644
index 177cfd271e..0000000000
--- a/tests/valid/RecursiveType_Valid_31.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{}
-{{}}
-{{}}
diff --git a/tests/valid/RecursiveType_Valid_31.whiley b/tests/valid/RecursiveType_Valid_31.whiley
index 7e04fe4fd2..3894ec2968 100644
--- a/tests/valid/RecursiveType_Valid_31.whiley
+++ b/tests/valid/RecursiveType_Valid_31.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
type Recursive is {Recursive}
@@ -11,10 +11,10 @@ function append(Recursive r1, Recursive r2) -> Recursive:
result = result + append(r,r2)
return result
-method main(System.Console console):
+public export method test():
Recursive r1 = {}
Recursive r2 = append(r1,{{}})
Recursive r3 = append(r2,{{}})
- console.out.println(r1)
- console.out.println(r2)
- console.out.println(r3)
+ assume r1 == {}
+ assume r2 == {{}}
+ assume r3 == {{}}
diff --git a/tests/valid/RecursiveType_Valid_4.sysout b/tests/valid/RecursiveType_Valid_4.sysout
deleted file mode 100755
index def51c4b9c..0000000000
--- a/tests/valid/RecursiveType_Valid_4.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-123
-112
-312242
-[123, 223, 323]
diff --git a/tests/valid/RecursiveType_Valid_4.whiley b/tests/valid/RecursiveType_Valid_4.whiley
index 44f82ed913..33fc0fad1c 100644
--- a/tests/valid/RecursiveType_Valid_4.whiley
+++ b/tests/valid/RecursiveType_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Expr is int | real | [Expr] | ListAccess
@@ -27,8 +27,9 @@ function evaluate(Expr e) -> null | Value:
else:
return null
-public method main(System.Console sys) -> void:
- sys.out.println(evaluate(123))
- sys.out.println(evaluate({index: 0, src: [112, 212332, 342]}))
- sys.out.println(evaluate({index: 2, src: [112312, -289712, 312242]}))
- sys.out.println(evaluate([123, 223, 323]))
+public export method test() -> void:
+ assume evaluate(123) == 123
+ assume evaluate({index: 0, src: [112, 212332, 342]}) == 112
+ assume evaluate({index: 2, src: [112312, -289712, 312242]}) == 312242
+ assume evaluate([123, 223, 323]) == [123, 223, 323]
+
diff --git a/tests/valid/RecursiveType_Valid_5.whiley b/tests/valid/RecursiveType_Valid_5.whiley
index 4643756ccc..81ac92d230 100644
--- a/tests/valid/RecursiveType_Valid_5.whiley
+++ b/tests/valid/RecursiveType_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Link is {[int] items, null | Link next}
diff --git a/tests/valid/RecursiveType_Valid_6.sysout b/tests/valid/RecursiveType_Valid_6.sysout
deleted file mode 100755
index 190a18037c..0000000000
--- a/tests/valid/RecursiveType_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-123
diff --git a/tests/valid/RecursiveType_Valid_6.whiley b/tests/valid/RecursiveType_Valid_6.whiley
index 29272d3bb6..576dfa463e 100644
--- a/tests/valid/RecursiveType_Valid_6.whiley
+++ b/tests/valid/RecursiveType_Valid_6.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
type binop is {int op, expr left, expr right}
type expr is int | binop
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e = 123
- sys.out.println(e)
+ assert e == 123
diff --git a/tests/valid/RecursiveType_Valid_7.sysout b/tests/valid/RecursiveType_Valid_7.sysout
deleted file mode 100644
index 0a197700ab..0000000000
--- a/tests/valid/RecursiveType_Valid_7.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-aconst_null
-getfield
diff --git a/tests/valid/RecursiveType_Valid_7.whiley b/tests/valid/RecursiveType_Valid_7.whiley
index 7fb4bf7cf5..426d23cac9 100644
--- a/tests/valid/RecursiveType_Valid_7.whiley
+++ b/tests/valid/RecursiveType_Valid_7.whiley
@@ -1,5 +1,4 @@
-import whiley.lang.*
-
+type i16 is (int x) where -32768 <= x && x <= 32767
type string is [int]
constant T_VOID is 3
@@ -34,7 +33,7 @@ type jvm_t is primitive_t | ref_t
type Unit is {int op, int offset}
-type Branch is {int op, Int.i16 off, int offset}
+type Branch is {int op, i16 off, int offset}
type VarIndex is {int index, int op, int offset}
@@ -69,8 +68,8 @@ function code2toString(Bytecode b) -> string:
constant bytecodeStrings is ["nop", "aconst_null", "iconst_m1", "iconst_0", "iconst_1", "iconst_2", "iconst_3", "iconst_4", "iconst_5", "lconst_0", "lconst_1", "fconst_0", "fconst_1", "fconst_2", "dconst_0", "dconst_1", "bipush", "sipush", "ldc", "ldc_w", "ldc2_w", "iload", "lload", "fload", "dload", "aload", "iload_0", "iload_1", "iload_2", "iload_3", "lload_0", "lload_1", "lload_2", "lload_3", "fload_0", "fload_1", "fload_2", "fload_3", "dload_0", "dload_1", "dload_2", "dload_3", "aload_0", "aload_1", "aload_2", "aload_3", "iaload", "laload", "faload", "daload", "aaload", "baload", "caload", "saload", "istore", "lstore", "fstore", "dstore", "astore", "istore_0", "istore_1", "istore_2", "istore_3", "lstore_0", "lstore_1", "lstore_2", "lstore_3", "fstore_0", "fstore_1", "fstore_2", "fstore_3", "dstore_0", "dstore_1", "dstore_2", "dstore_3", "astore_0", "astore_1", "astore_2", "astore_3", "iastore", "lastore", "fastore", "dastore", "aastore", "bastore", "castore", "sastore", "pop", "pop2", "dup", "dup_x1", "dup_x2", "dup2", "dup2_x1", "dup2_x2", "swap", "iadd", "ladd", "fadd", "dadd", "isub", "lsub", "fsub", "dsub", "imul", "lmul", "fmul", "dmul", "idiv", "ldiv", "fdiv", "ddiv", "irem", "lrem", "frem", "drem", "ineg", "lneg", "fneg", "dneg", "ishl", "lshl", "ishr", "lshr", "iushr", "lushr", "iand", "land", "ior", "lor", "ixor", "lxor", "iinc", "i2l", "i2f", "i2d", "l2i", "l2f", "l2d", "f2i", "f2l", "f2d", "d2i", "d2l", "d2f", "i2b", "i2c", "i2s", "lcmp", "fcmpl", "fcmpg", "dcmpl", "dcmpg", "ifeq", "ifne", "iflt", "ifge", "ifgt", "ifle", "if_icmpeq", "if_icmpne", "if_icmplt", "if_icmpge", "if_icmpgt", "if_icmple", "if_acmpeq", "if_acmpne", "goto", "jsr", "ret", "tableswitch", "lookupswitch", "ireturn", "lreturn", "freturn", "dreturn", "areturn", "return", "getstatic", "putstatic", "getfield", "putfield", "invokevirtual", "invokespecial", "invokestatic", "invokeerface", "unused", "new", "newarray", "anewarray", "arraylength", "athrow", "checkcast", "instanceof", "monitorenter", "monitorexit", "wide", "multianewarray", "ifnull", "ifnonnull", "goto_w", "jsr_w", "breakpo", "impdep1", "impdep2"]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] s1 = code2toString(Unit(0, 1))
- sys.out.println_s(s1)
+ assume s1 == "aconst_null"
[int] s2 = code2toString(FieldIndex(0, 180, {classes: ["Object"], pkg: "java.lang"}, "field", T_INT))
- sys.out.println_s(s2)
+ assume s2 == "getfield"
diff --git a/tests/valid/RecursiveType_Valid_8.sysout b/tests/valid/RecursiveType_Valid_8.sysout
deleted file mode 100755
index b2f265b888..0000000000
--- a/tests/valid/RecursiveType_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-14897
diff --git a/tests/valid/RecursiveType_Valid_8.whiley b/tests/valid/RecursiveType_Valid_8.whiley
index d7076b523f..49012a2d4b 100644
--- a/tests/valid/RecursiveType_Valid_8.whiley
+++ b/tests/valid/RecursiveType_Valid_8.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
type nat is (int n) where n >= 0
type expr is nat | {int op, expr left, expr right}
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e = 14897
- sys.out.println(e)
+ assert e == 14897
diff --git a/tests/valid/RecursiveType_Valid_9.sysout b/tests/valid/RecursiveType_Valid_9.sysout
deleted file mode 100755
index b2f265b888..0000000000
--- a/tests/valid/RecursiveType_Valid_9.sysout
+++ /dev/null
@@ -1 +0,0 @@
-14897
diff --git a/tests/valid/RecursiveType_Valid_9.whiley b/tests/valid/RecursiveType_Valid_9.whiley
index c197a69599..3ab6884400 100644
--- a/tests/valid/RecursiveType_Valid_9.whiley
+++ b/tests/valid/RecursiveType_Valid_9.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
type nat is int
type expr is nat | {int op, expr left, expr right}
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e = 14897
- sys.out.println(e)
+ assert e == 14897
diff --git a/tests/valid/Reference_Valid_1.whiley b/tests/valid/Reference_Valid_1.whiley
index 15dcfdeaaf..6d410533f2 100644
--- a/tests/valid/Reference_Valid_1.whiley
+++ b/tests/valid/Reference_Valid_1.whiley
@@ -1,17 +1,17 @@
-import whiley.lang.*
+
method swap(&int x_ptr, &int y_ptr):
int tmp = *x_ptr
*x_ptr = *y_ptr
*y_ptr = tmp
-method main(System.Console console):
+public export method test():
&int x = new 1
&int y = new 2
- console.out.println_s("*x = " ++ Any.toString(*x))
- console.out.println_s("*y = " ++ Any.toString(*y))
+ assume (*x) == 1
+ assume (*y) == 2
swap(x,y)
- console.out.println_s("*x = " ++ Any.toString(*x))
- console.out.println_s("*y = " ++ Any.toString(*y))
+ assume (*x) == 2
+ assume (*y) == 1
diff --git a/tests/valid/Reference_Valid_2.whiley b/tests/valid/Reference_Valid_2.whiley
index 8461f4d610..d7eeac99bf 100644
--- a/tests/valid/Reference_Valid_2.whiley
+++ b/tests/valid/Reference_Valid_2.whiley
@@ -1,6 +1,6 @@
-import whiley.lang.*
-method main(System.Console console):
+
+public export method test():
&[real] b = new [1.0, 2.0, 3.0]
real x = (*b)[1]
- console.out.println(x)
+ assume x == 2.0
diff --git a/tests/valid/Reference_Valid_3.whiley b/tests/valid/Reference_Valid_3.whiley
index 634e81ed1f..660df7c1e6 100644
--- a/tests/valid/Reference_Valid_3.whiley
+++ b/tests/valid/Reference_Valid_3.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
type Rec is &{ [real] items }
-method main(System.Console console):
+public export method test():
Rec r = new { items: [1.0, 2.0, 3.0] }
real x = (r->items)[1]
- console.out.println(x)
+ assume x == 2.0
diff --git a/tests/valid/Reference_Valid_4.whiley b/tests/valid/Reference_Valid_4.whiley
index 4f95c885a7..d5778065f1 100644
--- a/tests/valid/Reference_Valid_4.whiley
+++ b/tests/valid/Reference_Valid_4.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
-method main(System.Console console):
+
+public export method test():
&int c = new 5
*c = 4
- console.out.println( *c )
+ assume (*c) == 4
diff --git a/tests/valid/Reference_Valid_5.whiley b/tests/valid/Reference_Valid_5.whiley
index 58d1ade07a..32b7131fd9 100644
--- a/tests/valid/Reference_Valid_5.whiley
+++ b/tests/valid/Reference_Valid_5.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
-method main(System.Console console):
+
+public export method test():
&{int x} c = new {x: 5}
*c = {x: 4}
- console.out.println( *c )
+ assume (*c) == {x:4}
diff --git a/tests/valid/Remainder_Valid_1.sysout b/tests/valid/Remainder_Valid_1.sysout
deleted file mode 100644
index 10822fc3b2..0000000000
--- a/tests/valid/Remainder_Valid_1.sysout
+++ /dev/null
@@ -1,16 +0,0 @@
-0
-2
-1
-1
-0
--2
--1
--1
-0
--2
--1
--1
-0
-2
-1
-1
diff --git a/tests/valid/Remainder_Valid_1.whiley b/tests/valid/Remainder_Valid_1.whiley
index 6001fe83d3..3d60a578bf 100644
--- a/tests/valid/Remainder_Valid_1.whiley
+++ b/tests/valid/Remainder_Valid_1.whiley
@@ -1,22 +1,22 @@
-import whiley.lang.*
+
function f(int x, int y) -> int:
return x % y
-method main(System.Console sys) -> void:
- sys.out.println(f(10, 5))
- sys.out.println(f(10, 4))
- sys.out.println(f(1, 4))
- sys.out.println(f(103, 2))
- sys.out.println(f(-10, 5))
- sys.out.println(f(-10, 4))
- sys.out.println(f(-1, 4))
- sys.out.println(f(-103, 2))
- sys.out.println(f(-10, -5))
- sys.out.println(f(-10, -4))
- sys.out.println(f(-1, -4))
- sys.out.println(f(-103, -2))
- sys.out.println(f(10, -5))
- sys.out.println(f(10, -4))
- sys.out.println(f(1, -4))
- sys.out.println(f(103, -2))
+public export method test() -> void:
+ assume f(10, 5) == 0
+ assume f(10, 4) == 2
+ assume f(1, 4) == 1
+ assume f(103, 2) == 1
+ assume f(-10, 5) == 0
+ assume f(-10, 4) == -2
+ assume f(-1, 4) == -1
+ assume f(-103, 2) == -1
+ assume f(-10, -5) == 0
+ assume f(-10, -4) == -2
+ assume f(-1, -4) == -1
+ assume f(-103, -2) == -1
+ assume f(10, -5) == 0
+ assume f(10, -4) == 2
+ assume f(1, -4) == 1
+ assume f(103, -2) == 1
diff --git a/tests/valid/Requires_Valid_1.sysout b/tests/valid/Requires_Valid_1.sysout
deleted file mode 100755
index 1191247b6d..0000000000
--- a/tests/valid/Requires_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-2
diff --git a/tests/valid/Requires_Valid_1.whiley b/tests/valid/Requires_Valid_1.whiley
index 47df98da9e..6069dd2215 100644
--- a/tests/valid/Requires_Valid_1.whiley
+++ b/tests/valid/Requires_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
return x + 1
@@ -8,7 +8,7 @@ requires y == f(x):
//
return x,y
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x, int y = g(1, f(1))
- sys.out.println(x)
- sys.out.println(y)
+ assume x == 1
+ assume y == 2
diff --git a/tests/valid/Resolution_Valid_1.sysout b/tests/valid/Resolution_Valid_1.sysout
deleted file mode 100755
index b4de394767..0000000000
--- a/tests/valid/Resolution_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-11
diff --git a/tests/valid/Resolution_Valid_1.whiley b/tests/valid/Resolution_Valid_1.whiley
index 14b675de04..aa1d6e051f 100644
--- a/tests/valid/Resolution_Valid_1.whiley
+++ b/tests/valid/Resolution_Valid_1.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
function f(int b) -> int:
return b + 1
-method main(System.Console sys) -> void:
+public export method test() -> void:
int b = f(10)
- sys.out.println(b)
+ assume b == 11
diff --git a/tests/valid/SetAssign_Valid_1.sysout b/tests/valid/SetAssign_Valid_1.sysout
deleted file mode 100755
index 62f9457511..0000000000
--- a/tests/valid/SetAssign_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-6
\ No newline at end of file
diff --git a/tests/valid/SetAssign_Valid_1.whiley b/tests/valid/SetAssign_Valid_1.whiley
index d2312413ab..b8cad3f5df 100644
--- a/tests/valid/SetAssign_Valid_1.whiley
+++ b/tests/valid/SetAssign_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs) -> int
requires |xs| > 0:
@@ -7,7 +7,7 @@ requires |xs| > 0:
r = r + x
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ys = {1, 2, 3}
{int} zs = ys
- sys.out.println(f(zs))
+ assume f(zs) == 6
diff --git a/tests/valid/SetAssign_Valid_2.sysout b/tests/valid/SetAssign_Valid_2.sysout
deleted file mode 100755
index 2d05c9ead5..0000000000
--- a/tests/valid/SetAssign_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2, 3}
diff --git a/tests/valid/SetAssign_Valid_2.whiley b/tests/valid/SetAssign_Valid_2.whiley
index 2b6d9b790d..3e4d0f65c5 100644
--- a/tests/valid/SetAssign_Valid_2.whiley
+++ b/tests/valid/SetAssign_Valid_2.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
function f({int} xs) -> {int}:
return xs
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ys = {1, 2, 3}
{int} zs = ys
- sys.out.println(f(zs))
+ assume f(zs) == {1,2,3}
diff --git a/tests/valid/SetAssign_Valid_3.sysout b/tests/valid/SetAssign_Valid_3.sysout
deleted file mode 100644
index ea90ee3198..0000000000
--- a/tests/valid/SetAssign_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-45
diff --git a/tests/valid/SetAssign_Valid_3.whiley b/tests/valid/SetAssign_Valid_3.whiley
index d2b298147e..f734fe8519 100644
--- a/tests/valid/SetAssign_Valid_3.whiley
+++ b/tests/valid/SetAssign_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs) -> int:
int r = 0
@@ -6,7 +6,7 @@ function f({int} xs) -> int:
r = r + x
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ys = {1, 2, 3, 4, 5, 6, 7, 8, 9}
{int} zs = ys
- sys.out.println(f(zs))
+ assume f(zs) == 45
diff --git a/tests/valid/SetConversion_Valid_1.sysout b/tests/valid/SetConversion_Valid_1.sysout
deleted file mode 100755
index 5049538489..0000000000
--- a/tests/valid/SetConversion_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-6.0
\ No newline at end of file
diff --git a/tests/valid/SetConversion_Valid_1.whiley b/tests/valid/SetConversion_Valid_1.whiley
index 393277b1e3..c86e147e21 100644
--- a/tests/valid/SetConversion_Valid_1.whiley
+++ b/tests/valid/SetConversion_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({real} ls) -> real:
real r = 0.0
@@ -6,6 +6,6 @@ function f({real} ls) -> real:
r = r + x
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} ss = {1,2,3}
- sys.out.println(f(({real}) ss))
+ assume f(({real}) ss) == 6.0
diff --git a/tests/valid/SetDefine_Valid_1.sysout b/tests/valid/SetDefine_Valid_1.sysout
deleted file mode 100755
index 47848d0a3b..0000000000
--- a/tests/valid/SetDefine_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2}
diff --git a/tests/valid/SetDefine_Valid_1.whiley b/tests/valid/SetDefine_Valid_1.whiley
index 54aaf1f72e..6c543b5115 100644
--- a/tests/valid/SetDefine_Valid_1.whiley
+++ b/tests/valid/SetDefine_Valid_1.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
type pintset is ({int} xs) where |xs| > 1
-method main(System.Console sys) -> void:
- {int} p = {1, 2}
- sys.out.println(p)
+public export method test() -> void:
+ pintset p = {1, 2}
+ assume p == {1,2}
diff --git a/tests/valid/SetDefine_Valid_2.sysout b/tests/valid/SetDefine_Valid_2.sysout
deleted file mode 100755
index 47848d0a3b..0000000000
--- a/tests/valid/SetDefine_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2}
diff --git a/tests/valid/SetDefine_Valid_2.whiley b/tests/valid/SetDefine_Valid_2.whiley
index 8216819124..0cc5948a2e 100644
--- a/tests/valid/SetDefine_Valid_2.whiley
+++ b/tests/valid/SetDefine_Valid_2.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
type pintset is {int}
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} p = {1, 2}
- sys.out.println(p)
+ assert p == {1,2}
diff --git a/tests/valid/SetDefine_Valid_3.sysout b/tests/valid/SetDefine_Valid_3.sysout
deleted file mode 100644
index 8d3cc59fdc..0000000000
--- a/tests/valid/SetDefine_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{98, 99}
diff --git a/tests/valid/SetDefine_Valid_3.whiley b/tests/valid/SetDefine_Valid_3.whiley
index 1f6f08eb9c..894698a995 100644
--- a/tests/valid/SetDefine_Valid_3.whiley
+++ b/tests/valid/SetDefine_Valid_3.whiley
@@ -1,7 +1,8 @@
-import whiley.lang.*
+
type pintset is {int}
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} p = {'b', 'c'}
- sys.out.println(p)
+ assume p == {98, 99}
+
diff --git a/tests/valid/SetDifference_Valid_1.sysout b/tests/valid/SetDifference_Valid_1.sysout
deleted file mode 100644
index 678320fc41..0000000000
--- a/tests/valid/SetDifference_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{3}
-{97}
\ No newline at end of file
diff --git a/tests/valid/SetDifference_Valid_1.whiley b/tests/valid/SetDifference_Valid_1.whiley
index 9d8824929d..5ce5d229a9 100644
--- a/tests/valid/SetDifference_Valid_1.whiley
+++ b/tests/valid/SetDifference_Valid_1.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} x = {1, 2, 3}
{int} y = {1, 2}
- sys.out.println(x - y)
+ assume x - y == {3}
x = {'a', 'b', 'c'}
y = {'b', 'c'}
- sys.out.println(x - y)
+ assume x - y == {'a'}
diff --git a/tests/valid/SetElemOf_Valid_1.sysout b/tests/valid/SetElemOf_Valid_1.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/SetElemOf_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/SetElemOf_Valid_1.whiley b/tests/valid/SetElemOf_Valid_1.whiley
index 599c19f496..927d9aa264 100644
--- a/tests/valid/SetElemOf_Valid_1.whiley
+++ b/tests/valid/SetElemOf_Valid_1.whiley
@@ -1,8 +1,6 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} xs = {1, 2, 3}
- if 1 in xs:
- sys.out.println(1)
- if 5 in xs:
- sys.out.println(5)
+ assert 1 in xs
+ assert !(5 in xs)
diff --git a/tests/valid/SetEmpty_Valid_1.sysout b/tests/valid/SetEmpty_Valid_1.sysout
deleted file mode 100755
index e0ca51cfc7..0000000000
--- a/tests/valid/SetEmpty_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{1, 4}
-{}
-{}
diff --git a/tests/valid/SetEmpty_Valid_1.whiley b/tests/valid/SetEmpty_Valid_1.whiley
index a5e68ba7a6..e80d139c53 100644
--- a/tests/valid/SetEmpty_Valid_1.whiley
+++ b/tests/valid/SetEmpty_Valid_1.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
function f({int} xs) -> {int}:
return xs
-method main(System.Console sys) -> void:
- sys.out.println(f({1, 4}))
- sys.out.println(f({}))
- sys.out.println(f({}))
+public export method test() -> void:
+ assume f({1, 4}) == {1,4}
+ assume f({}) == {}
+ assume f({}) == {}
diff --git a/tests/valid/SetEquals_Valid_1.sysout b/tests/valid/SetEquals_Valid_1.sysout
deleted file mode 100644
index a6b58ef457..0000000000
--- a/tests/valid/SetEquals_Valid_1.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-true
-true
-false
-false
-true
\ No newline at end of file
diff --git a/tests/valid/SetEquals_Valid_1.whiley b/tests/valid/SetEquals_Valid_1.whiley
index abd29fb2d7..ce80fff8f3 100644
--- a/tests/valid/SetEquals_Valid_1.whiley
+++ b/tests/valid/SetEquals_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {real} ys) -> bool:
if (({real}) xs) == ys:
@@ -6,9 +6,9 @@ function f({int} xs, {real} ys) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({1, 4}, {1.0, 4.0}))
- sys.out.println(f({1, 4, 4}, {1.0, 4.0}))
- sys.out.println(f({1, 4}, {1.0, 4.2}))
- sys.out.println(f({1, 4}, {1.0, 4.2}))
- sys.out.println(f({}, {}))
+public export method test() -> void:
+ assume f({1, 4}, {1.0, 4.0}) == true
+ assume f({1, 4, 4}, {1.0, 4.0}) == true
+ assume f({1, 4}, {1.0, 4.2}) == false
+ assume f({1, 4}, {1.0, 4.2}) == false
+ assume f({}, {}) == true
diff --git a/tests/valid/SetGenerator_Valid_1.sysout b/tests/valid/SetGenerator_Valid_1.sysout
deleted file mode 100755
index 88440563f9..0000000000
--- a/tests/valid/SetGenerator_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2, 3, 4}
diff --git a/tests/valid/SetGenerator_Valid_1.whiley b/tests/valid/SetGenerator_Valid_1.whiley
index 2afb117843..b9449b9c9f 100644
--- a/tests/valid/SetGenerator_Valid_1.whiley
+++ b/tests/valid/SetGenerator_Valid_1.whiley
@@ -1,5 +1,5 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} xs = {1, 2, 3, 4}
- sys.out.println(xs)
+ assume xs == {1,2,3,4}
diff --git a/tests/valid/SetIntersect_Valid_1.sysout b/tests/valid/SetIntersect_Valid_1.sysout
deleted file mode 100755
index 6bebe4a542..0000000000
--- a/tests/valid/SetIntersect_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{2, 3, 7}
diff --git a/tests/valid/SetIntersect_Valid_1.whiley b/tests/valid/SetIntersect_Valid_1.whiley
index ce476204df..bf1b7888fb 100644
--- a/tests/valid/SetIntersect_Valid_1.whiley
+++ b/tests/valid/SetIntersect_Valid_1.whiley
@@ -1,5 +1,5 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} xs = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
- sys.out.println(xs & {2, 3, 7, 11})
+ assume (xs & {2, 3, 7, 11}) == {2,3,7}
diff --git a/tests/valid/SetIntersect_Valid_2.sysout b/tests/valid/SetIntersect_Valid_2.sysout
deleted file mode 100755
index 3d0e885bdb..0000000000
--- a/tests/valid/SetIntersect_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{2, 3}
diff --git a/tests/valid/SetIntersect_Valid_2.whiley b/tests/valid/SetIntersect_Valid_2.whiley
index 189eb1a17e..1b38eed34d 100644
--- a/tests/valid/SetIntersect_Valid_2.whiley
+++ b/tests/valid/SetIntersect_Valid_2.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} xs = {1, 2, 3}
[int] ys = [2, 3, 4]
{int} zs = xs & ({int}) ys
- sys.out.println(zs)
+ assume zs == {2,3}
diff --git a/tests/valid/SetIntersection_Valid_1.sysout b/tests/valid/SetIntersection_Valid_1.sysout
deleted file mode 100755
index 7c00ef4c1d..0000000000
--- a/tests/valid/SetIntersection_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{1, 2, 3}
-{2}
-{}
diff --git a/tests/valid/SetIntersection_Valid_1.whiley b/tests/valid/SetIntersection_Valid_1.whiley
index 60124bfa7e..4f5035f28e 100644
--- a/tests/valid/SetIntersection_Valid_1.whiley
+++ b/tests/valid/SetIntersection_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs) -> {int}
requires xs ⊆ {1, 2, 3}:
@@ -7,7 +7,7 @@ requires xs ⊆ {1, 2, 3}:
function g({int} ys) -> {int}:
return f(ys & {1, 2, 3})
-method main(System.Console sys) -> void:
- sys.out.println(g({1, 2, 3, 4}))
- sys.out.println(g({2}))
- sys.out.println(g({}))
+public export method test() -> void:
+ assume g({1, 2, 3, 4}) == {1,2,3}
+ assume g({2}) == {2}
+ assume g({}) == {}
diff --git a/tests/valid/SetIntersection_Valid_2.sysout b/tests/valid/SetIntersection_Valid_2.sysout
deleted file mode 100755
index 7c00ef4c1d..0000000000
--- a/tests/valid/SetIntersection_Valid_2.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{1, 2, 3}
-{2}
-{}
diff --git a/tests/valid/SetIntersection_Valid_2.whiley b/tests/valid/SetIntersection_Valid_2.whiley
index 66a3cae64a..7b951513a8 100644
--- a/tests/valid/SetIntersection_Valid_2.whiley
+++ b/tests/valid/SetIntersection_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs) -> {int}:
return xs
@@ -6,7 +6,7 @@ function f({int} xs) -> {int}:
function g({int} ys) -> {int}:
return f(ys & {1, 2, 3})
-method main(System.Console sys) -> void:
- sys.out.println(g({1, 2, 3, 4}))
- sys.out.println(g({2}))
- sys.out.println(g({}))
+public export method test() -> void:
+ assume g({1, 2, 3, 4}) == {1,2,3}
+ assume g({2}) == {2}
+ assume g({}) == {}
diff --git a/tests/valid/SetIntersection_Valid_3.sysout b/tests/valid/SetIntersection_Valid_3.sysout
deleted file mode 100755
index 307b157570..0000000000
--- a/tests/valid/SetIntersection_Valid_3.sysout
+++ /dev/null
@@ -1,7 +0,0 @@
-{}
-{2}
-{1, 2, 3}
-{}
-{1}
-{1, 2, 3}
-{1, 2}
diff --git a/tests/valid/SetIntersection_Valid_3.whiley b/tests/valid/SetIntersection_Valid_3.whiley
index d299c8fef5..3ace69cc09 100644
--- a/tests/valid/SetIntersection_Valid_3.whiley
+++ b/tests/valid/SetIntersection_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys, {int} zs) -> {int}
requires zs == (xs & ys):
@@ -10,11 +10,11 @@ function g({int} ys) -> {int}:
function h({int} ys, {int} zs) -> {int}:
return f(ys, zs, ys & zs)
-method main(System.Console sys) -> void:
- sys.out.println(g({}))
- sys.out.println(g({2}))
- sys.out.println(g({1, 2, 3}))
- sys.out.println(h({}, {}))
- sys.out.println(h({1}, {1, 2}))
- sys.out.println(h({1, 2, 3}, {3, 4, 5}))
- sys.out.println(h({1, 2}, {3, 4, 5}))
+public export method test() -> void:
+ assume g({}) == {}
+ assume g({2}) == {2}
+ assume g({1, 2, 3}) == {1,2,3}
+ assume h({}, {}) == {}
+ assume h({1}, {1, 2}) == {1}
+ assume h({1, 2, 3}, {3, 4, 5}) == {1,2,3}
+ assume h({1, 2}, {3, 4, 5}) == {1,2}
diff --git a/tests/valid/SetIntersection_Valid_4.sysout b/tests/valid/SetIntersection_Valid_4.sysout
deleted file mode 100755
index 307b157570..0000000000
--- a/tests/valid/SetIntersection_Valid_4.sysout
+++ /dev/null
@@ -1,7 +0,0 @@
-{}
-{2}
-{1, 2, 3}
-{}
-{1}
-{1, 2, 3}
-{1, 2}
diff --git a/tests/valid/SetIntersection_Valid_4.whiley b/tests/valid/SetIntersection_Valid_4.whiley
index 7608723958..bc48269a00 100644
--- a/tests/valid/SetIntersection_Valid_4.whiley
+++ b/tests/valid/SetIntersection_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys, {int} zs) -> {int}:
return xs
@@ -9,11 +9,11 @@ function g({int} ys) -> {int}:
function h({int} ys, {int} zs) -> {int}:
return f(ys, zs, ys & zs)
-method main(System.Console sys) -> void:
- sys.out.println(g({}))
- sys.out.println(g({2}))
- sys.out.println(g({1, 2, 3}))
- sys.out.println(h({}, {}))
- sys.out.println(h({1}, {1, 2}))
- sys.out.println(h({1, 2, 3}, {3, 4, 5}))
- sys.out.println(h({1, 2}, {3, 4, 5}))
+public export method test() -> void:
+ assume g({}) == {}
+ assume g({2}) == {2}
+ assume g({1, 2, 3}) == {1,2,3}
+ assume h({}, {}) == {}
+ assume h({1}, {1, 2}) == {1}
+ assume h({1, 2, 3}, {3, 4, 5}) == {1,2,3}
+ assume h({1, 2}, {3, 4, 5}) == {1,2}
diff --git a/tests/valid/SetIntersection_Valid_5.sysout b/tests/valid/SetIntersection_Valid_5.sysout
deleted file mode 100755
index 4d7961d0fb..0000000000
--- a/tests/valid/SetIntersection_Valid_5.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{}
-{2}
-{2}
diff --git a/tests/valid/SetIntersection_Valid_5.whiley b/tests/valid/SetIntersection_Valid_5.whiley
index 1e4d123a6b..cb1e65c5d8 100644
--- a/tests/valid/SetIntersection_Valid_5.whiley
+++ b/tests/valid/SetIntersection_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs) -> {int}
requires |xs| < 3:
@@ -7,7 +7,7 @@ requires |xs| < 3:
function g({int} ys) -> {int}:
return f(ys & {1, 2})
-method main(System.Console sys) -> void:
- sys.out.println(g({}))
- sys.out.println(g({2, 3, 4, 5, 6}))
- sys.out.println(g({2, 6}))
+public export method test() -> void:
+ assume g({}) == {}
+ assume g({2, 3, 4, 5, 6}) == {2}
+ assume g({2, 6}) == {2}
diff --git a/tests/valid/SetIntersection_Valid_6.sysout b/tests/valid/SetIntersection_Valid_6.sysout
deleted file mode 100755
index 4d7961d0fb..0000000000
--- a/tests/valid/SetIntersection_Valid_6.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{}
-{2}
-{2}
diff --git a/tests/valid/SetIntersection_Valid_6.whiley b/tests/valid/SetIntersection_Valid_6.whiley
index 805650fe9c..33a7652b16 100644
--- a/tests/valid/SetIntersection_Valid_6.whiley
+++ b/tests/valid/SetIntersection_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs) -> {int}:
return xs
@@ -6,7 +6,7 @@ function f({int} xs) -> {int}:
function g({int} ys) -> {int}:
return f(ys & {1, 2})
-method main(System.Console sys) -> void:
- sys.out.println(g({}))
- sys.out.println(g({2, 3, 4, 5, 6}))
- sys.out.println(g({2, 6}))
+public export method test() -> void:
+ assume g({}) == {}
+ assume g({2, 3, 4, 5, 6}) == {2}
+ assume g({2, 6}) == {2}
diff --git a/tests/valid/SetIntersection_Valid_7.sysout b/tests/valid/SetIntersection_Valid_7.sysout
deleted file mode 100644
index 4b095fd0ff..0000000000
--- a/tests/valid/SetIntersection_Valid_7.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-false
-false
diff --git a/tests/valid/SetIntersection_Valid_7.whiley b/tests/valid/SetIntersection_Valid_7.whiley
index 1617c4a9c3..c089516b71 100644
--- a/tests/valid/SetIntersection_Valid_7.whiley
+++ b/tests/valid/SetIntersection_Valid_7.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} aset = {1, 21, 3, 4, 1}
{int} bset = {2, 2, 3, 4, 9}
{int|bool|real} cset = {-1.0, 25, true, 7, 13.4, false}
- sys.out.println(aset + bset)
- sys.out.println(aset & bset)
- sys.out.println(cset + aset)
- sys.out.println(cset & aset)
+ assume (aset + bset) == {1,2,3,4,9,21}
+ assume (aset & bset) == {3,4}
+ assume (cset + aset) == {1, 21, 3, 4,-1.0, 25, true, 7, 13.4, false}
+ assume (cset & aset) == {}
diff --git a/tests/valid/SetLength_Valid_1.sysout b/tests/valid/SetLength_Valid_1.sysout
deleted file mode 100755
index 00750edc07..0000000000
--- a/tests/valid/SetLength_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/tests/valid/SetLength_Valid_1.whiley b/tests/valid/SetLength_Valid_1.whiley
index 68e13b3452..9e3988d25c 100644
--- a/tests/valid/SetLength_Valid_1.whiley
+++ b/tests/valid/SetLength_Valid_1.whiley
@@ -1,5 +1,5 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} xs = {1, 2, 3}
- sys.out.println(|xs|)
+ assert |xs| == 3
diff --git a/tests/valid/SetNull_Valid_1.sysout b/tests/valid/SetNull_Valid_1.sysout
deleted file mode 100644
index 0967ef424b..0000000000
--- a/tests/valid/SetNull_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/tests/valid/SetNull_Valid_1.whiley b/tests/valid/SetNull_Valid_1.whiley
index f2cdeb39b1..daa342c54c 100644
--- a/tests/valid/SetNull_Valid_1.whiley
+++ b/tests/valid/SetNull_Valid_1.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
function f({int} xs) -> {int}:
return xs
-method main(System.Console sys) -> void:
- sys.out.println(f({}))
+public export method test() -> void:
+ assume f({}) == {}
diff --git a/tests/valid/SetSubset_Valid_1.sysout b/tests/valid/SetSubset_Valid_1.sysout
deleted file mode 100755
index 5879b86637..0000000000
--- a/tests/valid/SetSubset_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_1.whiley b/tests/valid/SetSubset_Valid_1.whiley
index 2f28a8d9ff..53d20141c6 100644
--- a/tests/valid/SetSubset_Valid_1.whiley
+++ b/tests/valid/SetSubset_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool
requires |xs| <= |ys|:
@@ -7,7 +7,7 @@ requires |xs| <= |ys|:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({1, 2, 3}, {1, 2, 3}))
- sys.out.println(f({1, 4}, {1, 2, 3}))
- sys.out.println(f({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume f({1, 2, 3}, {1, 2, 3}) == true
+ assume f({1, 4}, {1, 2, 3}) == false
+ assume f({1}, {1, 2, 3}) == true
diff --git a/tests/valid/SetSubset_Valid_10.sysout b/tests/valid/SetSubset_Valid_10.sysout
deleted file mode 100755
index ccd68f5aca..0000000000
--- a/tests/valid/SetSubset_Valid_10.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-false
-true
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_10.whiley b/tests/valid/SetSubset_Valid_10.whiley
index 1cd61da428..ac37dcfcf6 100644
--- a/tests/valid/SetSubset_Valid_10.whiley
+++ b/tests/valid/SetSubset_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool:
if xs ⊂ ys:
@@ -6,7 +6,7 @@ function f({int} xs, {int} ys) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({1, 2, 3}, {1, 2, 3}))
- sys.out.println(f({1, 2}, {1, 2, 3}))
- sys.out.println(f({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume f({1, 2, 3}, {1, 2, 3}) == false
+ assume f({1, 2}, {1, 2, 3}) == true
+ assume f({1}, {1, 2, 3}) == true
diff --git a/tests/valid/SetSubset_Valid_11.sysout b/tests/valid/SetSubset_Valid_11.sysout
deleted file mode 100755
index 82cd87f820..0000000000
--- a/tests/valid/SetSubset_Valid_11.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-true
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_11.whiley b/tests/valid/SetSubset_Valid_11.whiley
index 09d5da5834..4bedc8e104 100644
--- a/tests/valid/SetSubset_Valid_11.whiley
+++ b/tests/valid/SetSubset_Valid_11.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool
requires xs ⊆ ys:
@@ -8,7 +8,7 @@ function g({int} xs, {int} ys) -> bool
requires xs ⊆ ys:
return f(xs, ys)
-method main(System.Console sys) -> void:
- sys.out.println(g({1, 2, 3}, {1, 2, 3}))
- sys.out.println(g({1, 2}, {1, 2, 3}))
- sys.out.println(g({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume g({1, 2, 3}, {1, 2, 3})
+ assume g({1, 2}, {1, 2, 3})
+ assume g({1}, {1, 2, 3})
diff --git a/tests/valid/SetSubset_Valid_12.sysout b/tests/valid/SetSubset_Valid_12.sysout
deleted file mode 100755
index 82cd87f820..0000000000
--- a/tests/valid/SetSubset_Valid_12.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-true
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_12.whiley b/tests/valid/SetSubset_Valid_12.whiley
index 6e45c1f756..a60300b181 100644
--- a/tests/valid/SetSubset_Valid_12.whiley
+++ b/tests/valid/SetSubset_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool:
if xs ⊆ ys:
@@ -9,7 +9,7 @@ function f({int} xs, {int} ys) -> bool:
function g({int} xs, {int} ys) -> bool:
return f(xs, ys)
-method main(System.Console sys) -> void:
- sys.out.println(g({1, 2, 3}, {1, 2, 3}))
- sys.out.println(g({1, 2}, {1, 2, 3}))
- sys.out.println(g({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume g({1, 2, 3}, {1, 2, 3}) == true
+ assume g({1, 2}, {1, 2, 3}) == true
+ assume g({1}, {1, 2, 3}) == true
diff --git a/tests/valid/SetSubset_Valid_2.sysout b/tests/valid/SetSubset_Valid_2.sysout
deleted file mode 100755
index 0be5d980da..0000000000
--- a/tests/valid/SetSubset_Valid_2.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_2.whiley b/tests/valid/SetSubset_Valid_2.whiley
index 8bc8815beb..7dcc9d97d9 100644
--- a/tests/valid/SetSubset_Valid_2.whiley
+++ b/tests/valid/SetSubset_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool
requires xs ⊆ ys:
@@ -8,6 +8,6 @@ function g({int} xs, {int} ys) -> bool
requires xs ⊂ ys:
return f(xs, ys)
-method main(System.Console sys) -> void:
- sys.out.println(g({1, 2}, {1, 2, 3}))
- sys.out.println(g({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume g({1, 2}, {1, 2, 3}) == true
+ assume g({1}, {1, 2, 3}) == true
diff --git a/tests/valid/SetSubset_Valid_3.sysout b/tests/valid/SetSubset_Valid_3.sysout
deleted file mode 100755
index ccd68f5aca..0000000000
--- a/tests/valid/SetSubset_Valid_3.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-false
-true
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_3.whiley b/tests/valid/SetSubset_Valid_3.whiley
index 72a505eb1e..94fde55994 100644
--- a/tests/valid/SetSubset_Valid_3.whiley
+++ b/tests/valid/SetSubset_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool:
if xs ⊂ ys:
@@ -9,7 +9,7 @@ function f({int} xs, {int} ys) -> bool:
function g({int} xs, {int} ys) -> bool:
return f(xs, ys)
-method main(System.Console sys) -> void:
- sys.out.println(g({1, 2, 3}, {1, 2, 3}))
- sys.out.println(g({1, 2}, {1, 2, 3}))
- sys.out.println(g({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume g({1, 2, 3}, {1, 2, 3}) == false
+ assume g({1, 2}, {1, 2, 3}) == true
+ assume g({1}, {1, 2, 3}) == true
diff --git a/tests/valid/SetSubset_Valid_4.sysout b/tests/valid/SetSubset_Valid_4.sysout
deleted file mode 100755
index 0be5d980da..0000000000
--- a/tests/valid/SetSubset_Valid_4.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_4.whiley b/tests/valid/SetSubset_Valid_4.whiley
index 76ac143797..0759b806d1 100644
--- a/tests/valid/SetSubset_Valid_4.whiley
+++ b/tests/valid/SetSubset_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool
requires xs ⊂ ys:
@@ -8,6 +8,6 @@ function g({int} xs, {int} ys) -> bool
requires xs ⊂ ys:
return f(xs, ys)
-method main(System.Console sys) -> void:
- sys.out.println(g({1, 2}, {1, 2, 3}))
- sys.out.println(g({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume g({1, 2}, {1, 2, 3}) == true
+ assume g({1}, {1, 2, 3}) == true
diff --git a/tests/valid/SetSubset_Valid_5.sysout b/tests/valid/SetSubset_Valid_5.sysout
deleted file mode 100755
index 5879b86637..0000000000
--- a/tests/valid/SetSubset_Valid_5.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_5.whiley b/tests/valid/SetSubset_Valid_5.whiley
index b30171c05f..32083405b0 100644
--- a/tests/valid/SetSubset_Valid_5.whiley
+++ b/tests/valid/SetSubset_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool:
if xs ⊆ ys:
@@ -6,7 +6,7 @@ function f({int} xs, {int} ys) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({1, 2, 3}, {1, 2, 3}))
- sys.out.println(f({1, 4}, {1, 2, 3}))
- sys.out.println(f({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume f({1, 2, 3}, {1, 2, 3}) == true
+ assume f({1, 4}, {1, 2, 3}) == false
+ assume f({1}, {1, 2, 3}) == true
diff --git a/tests/valid/SetSubset_Valid_6.sysout b/tests/valid/SetSubset_Valid_6.sysout
deleted file mode 100755
index 82cd87f820..0000000000
--- a/tests/valid/SetSubset_Valid_6.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-true
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_6.whiley b/tests/valid/SetSubset_Valid_6.whiley
index d25c645c14..f49159d462 100644
--- a/tests/valid/SetSubset_Valid_6.whiley
+++ b/tests/valid/SetSubset_Valid_6.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool
requires xs ⊆ ys:
return true
-method main(System.Console sys) -> void:
- sys.out.println(f({1, 2, 3}, {1, 2, 3}))
- sys.out.println(f({1, 2}, {1, 2, 3}))
- sys.out.println(f({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume f({1, 2, 3}, {1, 2, 3})
+ assume f({1, 2}, {1, 2, 3})
+ assume f({1}, {1, 2, 3})
diff --git a/tests/valid/SetSubset_Valid_7.sysout b/tests/valid/SetSubset_Valid_7.sysout
deleted file mode 100755
index 5879b86637..0000000000
--- a/tests/valid/SetSubset_Valid_7.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_7.whiley b/tests/valid/SetSubset_Valid_7.whiley
index 9ec1e4742c..d31140332f 100644
--- a/tests/valid/SetSubset_Valid_7.whiley
+++ b/tests/valid/SetSubset_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool
requires |xs| <= |ys|:
@@ -7,7 +7,7 @@ requires |xs| <= |ys|:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({1, 2}, {1, 2, 3}))
- sys.out.println(f({1, 4}, {1, 2, 3}))
- sys.out.println(f({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume f({1, 2}, {1, 2, 3}) == true
+ assume f({1, 4}, {1, 2, 3}) == false
+ assume f({1}, {1, 2, 3}) == true
diff --git a/tests/valid/SetSubset_Valid_8.sysout b/tests/valid/SetSubset_Valid_8.sysout
deleted file mode 100755
index 5879b86637..0000000000
--- a/tests/valid/SetSubset_Valid_8.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_8.whiley b/tests/valid/SetSubset_Valid_8.whiley
index 816951b500..f34fa85bb0 100644
--- a/tests/valid/SetSubset_Valid_8.whiley
+++ b/tests/valid/SetSubset_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool:
if xs ⊂ ys:
@@ -6,7 +6,7 @@ function f({int} xs, {int} ys) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({1, 2}, {1, 2, 3}))
- sys.out.println(f({1, 4}, {1, 2, 3}))
- sys.out.println(f({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume f({1, 2}, {1, 2, 3}) == true
+ assume f({1, 4}, {1, 2, 3}) == false
+ assume f({1}, {1, 2, 3}) == true
diff --git a/tests/valid/SetSubset_Valid_9.sysout b/tests/valid/SetSubset_Valid_9.sysout
deleted file mode 100755
index 0be5d980da..0000000000
--- a/tests/valid/SetSubset_Valid_9.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-true
\ No newline at end of file
diff --git a/tests/valid/SetSubset_Valid_9.whiley b/tests/valid/SetSubset_Valid_9.whiley
index 3255b96e22..b00287bb47 100644
--- a/tests/valid/SetSubset_Valid_9.whiley
+++ b/tests/valid/SetSubset_Valid_9.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys) -> bool
requires xs ⊂ ys:
//
return true
-method main(System.Console sys) -> void:
- sys.out.println(f({1, 2}, {1, 2, 3}))
- sys.out.println(f({1}, {1, 2, 3}))
+public export method test() -> void:
+ assume f({1, 2}, {1, 2, 3}) == true
+ assume f({1}, {1, 2, 3}) == true
diff --git a/tests/valid/SetUnion_Valid_1.sysout b/tests/valid/SetUnion_Valid_1.sysout
deleted file mode 100755
index 38d91d8974..0000000000
--- a/tests/valid/SetUnion_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2, 3, 4, 5}
diff --git a/tests/valid/SetUnion_Valid_1.whiley b/tests/valid/SetUnion_Valid_1.whiley
index 555ec632d2..760ce3b972 100644
--- a/tests/valid/SetUnion_Valid_1.whiley
+++ b/tests/valid/SetUnion_Valid_1.whiley
@@ -1,6 +1,6 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} xs = {1, 2, 3, 4}
xs = xs + {5, 1}
- sys.out.println(xs)
+ assume xs == {1,2,3,4,5}
diff --git a/tests/valid/SetUnion_Valid_10.sysout b/tests/valid/SetUnion_Valid_10.sysout
deleted file mode 100755
index c7a3fa7048..0000000000
--- a/tests/valid/SetUnion_Valid_10.sysout
+++ /dev/null
@@ -1,6 +0,0 @@
-true
-true
-true
-true
-true
-true
\ No newline at end of file
diff --git a/tests/valid/SetUnion_Valid_10.whiley b/tests/valid/SetUnion_Valid_10.whiley
index 0166bdd313..10c6a96ebd 100644
--- a/tests/valid/SetUnion_Valid_10.whiley
+++ b/tests/valid/SetUnion_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys, {int} zs) -> bool:
if zs == (xs + ys):
@@ -12,10 +12,10 @@ function g({int} ys) -> bool:
function h({int} ys, {int} zs) -> bool:
return f(ys, zs, ys + zs)
-method main(System.Console sys) -> void:
- sys.out.println(g({}))
- sys.out.println(g({2}))
- sys.out.println(g({1, 2, 3}))
- sys.out.println(h({}, {}))
- sys.out.println(h({1}, {2}))
- sys.out.println(h({1, 2, 3}, {3, 4, 5}))
+public export method test() -> void:
+ assume g({}) == true
+ assume g({2}) == true
+ assume g({1, 2, 3}) == true
+ assume h({}, {}) == true
+ assume h({1}, {2}) == true
+ assume h({1, 2, 3}, {3, 4, 5}) == true
diff --git a/tests/valid/SetUnion_Valid_11.sysout b/tests/valid/SetUnion_Valid_11.sysout
deleted file mode 100644
index f1c7c46aa1..0000000000
--- a/tests/valid/SetUnion_Valid_11.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122}
diff --git a/tests/valid/SetUnion_Valid_11.whiley b/tests/valid/SetUnion_Valid_11.whiley
index 701fd571d8..afe31dead8 100644
--- a/tests/valid/SetUnion_Valid_11.whiley
+++ b/tests/valid/SetUnion_Valid_11.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function append([int] input) -> {int}:
{int} rs = {}
@@ -6,6 +6,7 @@ function append([int] input) -> {int}:
rs = rs + {(int) input[i]}
return rs
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} xs = append("abcdefghijklmnopqrstuvwxyz")
- sys.out.println(xs)
+ assume xs == {97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122}
+
diff --git a/tests/valid/SetUnion_Valid_2.sysout b/tests/valid/SetUnion_Valid_2.sysout
deleted file mode 100644
index f1c7c46aa1..0000000000
--- a/tests/valid/SetUnion_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122}
diff --git a/tests/valid/SetUnion_Valid_2.whiley b/tests/valid/SetUnion_Valid_2.whiley
index 36df8145f8..87c4585a4e 100644
--- a/tests/valid/SetUnion_Valid_2.whiley
+++ b/tests/valid/SetUnion_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function append([int] input) -> {int}:
{int} rs = {}
@@ -6,6 +6,7 @@ function append([int] input) -> {int}:
rs = {(int) input[i]} + rs
return rs
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} xs = append("abcdefghijklmnopqrstuvwxyz")
- sys.out.println(xs)
+ assume xs == {97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122}
+
diff --git a/tests/valid/SetUnion_Valid_3.sysout b/tests/valid/SetUnion_Valid_3.sysout
deleted file mode 100644
index da29283aaa..0000000000
--- a/tests/valid/SetUnion_Valid_3.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
diff --git a/tests/valid/SetUnion_Valid_3.whiley b/tests/valid/SetUnion_Valid_3.whiley
index c22b141f96..f67581e48b 100644
--- a/tests/valid/SetUnion_Valid_3.whiley
+++ b/tests/valid/SetUnion_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function test({real} xs, [int] ys) -> bool:
for x in xs + ({int}) ys:
@@ -6,8 +6,6 @@ function test({real} xs, [int] ys) -> bool:
return true
return false
-method main(System.Console sys) -> void:
- bool s = test({1.2, 2.3, 3.4}, [1, 2, 3, 4, 5, 6, 7, 8])
- sys.out.println(s)
- s = test({1.2, 2.3, 3.4}, [])
- sys.out.println(s)
+public export method test() -> void:
+ assume test({1.2, 2.3, 3.4}, [1, 2, 3, 4, 5, 6, 7, 8])
+ assume !test({1.2, 2.3, 3.4}, [])
diff --git a/tests/valid/SetUnion_Valid_4.sysout b/tests/valid/SetUnion_Valid_4.sysout
deleted file mode 100755
index afde40fd33..0000000000
--- a/tests/valid/SetUnion_Valid_4.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{1, 2, 3, 4}
-{1, 2, 3, 4, 6}
-{1, 2, 3, 4, 5}
diff --git a/tests/valid/SetUnion_Valid_4.whiley b/tests/valid/SetUnion_Valid_4.whiley
index 009ea3b167..d8300d43d7 100644
--- a/tests/valid/SetUnion_Valid_4.whiley
+++ b/tests/valid/SetUnion_Valid_4.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} xs = {1, 2, 3, 4}
{int} ys = xs + {5, 1}
- sys.out.println(xs)
+ assume xs == {1,2,3,4}
xs = xs + {6}
- sys.out.println(xs)
- sys.out.println(ys)
+ assume xs == {1,2,3,4,6}
+ assume ys == {1,2,3,4,5}
diff --git a/tests/valid/SetUnion_Valid_5.sysout b/tests/valid/SetUnion_Valid_5.sysout
deleted file mode 100755
index afde40fd33..0000000000
--- a/tests/valid/SetUnion_Valid_5.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-{1, 2, 3, 4}
-{1, 2, 3, 4, 6}
-{1, 2, 3, 4, 5}
diff --git a/tests/valid/SetUnion_Valid_5.whiley b/tests/valid/SetUnion_Valid_5.whiley
index 4601b3ae86..43fbe33327 100644
--- a/tests/valid/SetUnion_Valid_5.whiley
+++ b/tests/valid/SetUnion_Valid_5.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} xs = {1, 2, 3, 4}
{int} ys = {5} + xs
- sys.out.println(xs)
+ assume xs == {1,2,3,4}
xs = xs + {6}
- sys.out.println(xs)
- sys.out.println(ys)
+ assume xs == {1,2,3,4,6}
+ assume ys == {1,2,3,4,5}
diff --git a/tests/valid/SetUnion_Valid_6.sysout b/tests/valid/SetUnion_Valid_6.sysout
deleted file mode 100755
index 88440563f9..0000000000
--- a/tests/valid/SetUnion_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1, 2, 3, 4}
diff --git a/tests/valid/SetUnion_Valid_6.whiley b/tests/valid/SetUnion_Valid_6.whiley
index 0bd88ea56a..0ac89e34c7 100644
--- a/tests/valid/SetUnion_Valid_6.whiley
+++ b/tests/valid/SetUnion_Valid_6.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
{int} xs = {1, 2, 3}
[int] ys = [2, 3, 4]
{int} zs = xs + ({int}) ys
- sys.out.println(zs)
+ assert zs == {1,2,3,4}
diff --git a/tests/valid/SetUnion_Valid_7.sysout b/tests/valid/SetUnion_Valid_7.sysout
deleted file mode 100755
index e96d6edfe2..0000000000
--- a/tests/valid/SetUnion_Valid_7.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{1}
-{1, 2}
diff --git a/tests/valid/SetUnion_Valid_7.whiley b/tests/valid/SetUnion_Valid_7.whiley
index 8467cd068b..c54756755e 100644
--- a/tests/valid/SetUnion_Valid_7.whiley
+++ b/tests/valid/SetUnion_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs) -> {int}
requires |xs| > 0:
@@ -7,6 +7,6 @@ requires |xs| > 0:
function g({int} ys) -> {int}:
return f(ys + {1})
-method main(System.Console sys) -> void:
- sys.out.println(g({}))
- sys.out.println(g({2}))
+public export method test() -> void:
+ assume g({}) == {1}
+ assume g({2}) == {1,2}
diff --git a/tests/valid/SetUnion_Valid_8.sysout b/tests/valid/SetUnion_Valid_8.sysout
deleted file mode 100755
index da29283aaa..0000000000
--- a/tests/valid/SetUnion_Valid_8.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
diff --git a/tests/valid/SetUnion_Valid_8.whiley b/tests/valid/SetUnion_Valid_8.whiley
index ea11374ef1..5c000409e1 100644
--- a/tests/valid/SetUnion_Valid_8.whiley
+++ b/tests/valid/SetUnion_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs) -> bool:
if |xs| == 1:
@@ -9,6 +9,6 @@ function f({int} xs) -> bool:
function g({int} ys) -> bool:
return f(ys + {1})
-method main(System.Console sys) -> void:
- sys.out.println(g({}))
- sys.out.println(g({2}))
+public export method test() -> void:
+ assume g({}) == true
+ assume g({2}) == false
diff --git a/tests/valid/SetUnion_Valid_9.sysout b/tests/valid/SetUnion_Valid_9.sysout
deleted file mode 100755
index ff23828d0b..0000000000
--- a/tests/valid/SetUnion_Valid_9.sysout
+++ /dev/null
@@ -1,6 +0,0 @@
-{}
-{2}
-{1, 2, 3}
-{}
-{1}
-{1, 2, 3}
diff --git a/tests/valid/SetUnion_Valid_9.whiley b/tests/valid/SetUnion_Valid_9.whiley
index ba01e938f1..db60b58eae 100644
--- a/tests/valid/SetUnion_Valid_9.whiley
+++ b/tests/valid/SetUnion_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int} xs, {int} ys, {int} zs) -> {int}
requires zs == (xs + ys):
@@ -10,10 +10,10 @@ function g({int} ys) -> {int}:
function h({int} ys, {int} zs) -> {int}:
return f(ys, zs, ys + zs)
-method main(System.Console sys) -> void:
- sys.out.println(g({}))
- sys.out.println(g({2}))
- sys.out.println(g({1, 2, 3}))
- sys.out.println(h({}, {}))
- sys.out.println(h({1}, {2}))
- sys.out.println(h({1, 2, 3}, {3, 4, 5}))
+public export method test() -> void:
+ assume g({}) == {}
+ assume g({2}) == {2}
+ assume g({1, 2, 3}) == {1,2,3}
+ assume h({}, {}) == {}
+ assume h({1}, {2}) == {1}
+ assume h({1, 2, 3}, {3, 4, 5}) == {1,2,3}
diff --git a/tests/valid/Set_11.sysout b/tests/valid/Set_11.sysout
deleted file mode 100755
index 93becaaffb..0000000000
--- a/tests/valid/Set_11.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{2, 4, 1, 3}
-{2, 4, 8, 6}
diff --git a/tests/valid/SingleLineComment_Valid_1.sysout b/tests/valid/SingleLineComment_Valid_1.sysout
deleted file mode 100644
index 7813681f5b..0000000000
--- a/tests/valid/SingleLineComment_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-5
\ No newline at end of file
diff --git a/tests/valid/SingleLineComment_Valid_1.whiley b/tests/valid/SingleLineComment_Valid_1.whiley
index f07a963fae..ccd0716ac9 100644
--- a/tests/valid/SingleLineComment_Valid_1.whiley
+++ b/tests/valid/SingleLineComment_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
- sys.out.println(5)
+
+public export method test() -> void:
+ assert 1 != 2 // this is a single line comment
diff --git a/tests/valid/Skip_Valid_1.sysout b/tests/valid/Skip_Valid_1.sysout
deleted file mode 100644
index 94d36aad18..0000000000
--- a/tests/valid/Skip_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
--1
diff --git a/tests/valid/Skip_Valid_1.whiley b/tests/valid/Skip_Valid_1.whiley
index bdccc20be1..5e0ea138db 100644
--- a/tests/valid/Skip_Valid_1.whiley
+++ b/tests/valid/Skip_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
if x > 0:
@@ -7,6 +7,6 @@ function f(int x) -> int:
return -1
return x
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(-10))
+public export method test() -> void:
+ assume f(1) == 1
+ assume f(-10) == -1
diff --git a/tests/valid/String_Valid_1.sysout b/tests/valid/String_Valid_1.sysout
deleted file mode 100644
index 1d2a991bc7..0000000000
--- a/tests/valid/String_Valid_1.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-null
diff --git a/tests/valid/String_Valid_1.whiley b/tests/valid/String_Valid_1.whiley
index a8ea46e26b..c2a2ebabe5 100644
--- a/tests/valid/String_Valid_1.whiley
+++ b/tests/valid/String_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -9,7 +9,7 @@ function f(nat pos, [int] input) -> bool|null:
bool flag = input[pos] == 'O'
return flag
-method main(System.Console console):
- console.out.println(f(0, "Ox"))
- console.out.println(f(0, "1x"))
- console.out.println(f(1, "O"))
+public export method test():
+ assume f(0, "Ox") == true
+ assume f(0, "1x") == false
+ assume f(1, "O") == null
diff --git a/tests/valid/String_Valid_2.sysout b/tests/valid/String_Valid_2.sysout
deleted file mode 100644
index aad3d4b91d..0000000000
--- a/tests/valid/String_Valid_2.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-true
-true
-false
-false
-true
diff --git a/tests/valid/String_Valid_2.whiley b/tests/valid/String_Valid_2.whiley
index 59f3cdefe8..347b8c51f3 100644
--- a/tests/valid/String_Valid_2.whiley
+++ b/tests/valid/String_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
public function has(int c, [int] str) -> bool:
int i = 0
@@ -8,10 +8,10 @@ public function has(int c, [int] str) -> bool:
i = i + 1
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] s = "Hello World"
- sys.out.println(has('l', s))
- sys.out.println(has('e', s))
- sys.out.println(has('h', s))
- sys.out.println(has('z', s))
- sys.out.println(has('H', s))
+ assume has('l', s) == true
+ assume has('e', s) == true
+ assume has('h', s) == false
+ assume has('z', s) == false
+ assume has('H', s) == true
diff --git a/tests/valid/String_Valid_3.sysout b/tests/valid/String_Valid_3.sysout
deleted file mode 100644
index aad3d4b91d..0000000000
--- a/tests/valid/String_Valid_3.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-true
-true
-false
-false
-true
diff --git a/tests/valid/String_Valid_3.whiley b/tests/valid/String_Valid_3.whiley
index 954fcca847..410ab437d4 100644
--- a/tests/valid/String_Valid_3.whiley
+++ b/tests/valid/String_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
public function has(int c1, [int] str) -> bool:
for c2 in str:
@@ -6,10 +6,10 @@ public function has(int c1, [int] str) -> bool:
return true
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] s = "Hello World"
- sys.out.println(has('l', s))
- sys.out.println(has('e', s))
- sys.out.println(has('h', s))
- sys.out.println(has('z', s))
- sys.out.println(has('H', s))
+ assume has('l', s) == true
+ assume has('e', s) == true
+ assume has('h', s) == false
+ assume has('z', s) == false
+ assume has('H', s) == true
diff --git a/tests/valid/String_Valid_4.sysout b/tests/valid/String_Valid_4.sysout
deleted file mode 100644
index 6dc8e2cd10..0000000000
--- a/tests/valid/String_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-He11o Wor1d
diff --git a/tests/valid/String_Valid_4.whiley b/tests/valid/String_Valid_4.whiley
index d6ec41f3df..52a96c3ca4 100644
--- a/tests/valid/String_Valid_4.whiley
+++ b/tests/valid/String_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
public function repl(int old, int n, [int] str) -> [int]:
int i = 0
@@ -8,7 +8,6 @@ public function repl(int old, int n, [int] str) -> [int]:
i = i + 1
return str
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] s = "Hello World"
- s = repl('l', '1', s)
- sys.out.println_s(s)
+ assume repl('l', '1', s) == "He11o Wor1d"
diff --git a/tests/valid/String_Valid_5.sysout b/tests/valid/String_Valid_5.sysout
deleted file mode 100644
index 0d2391b420..0000000000
--- a/tests/valid/String_Valid_5.sysout
+++ /dev/null
@@ -1,10 +0,0 @@
-0
-1
-2
-4
-5
-6
-8
-10
-null
-null
diff --git a/tests/valid/String_Valid_5.whiley b/tests/valid/String_Valid_5.whiley
index d2bcc64ef9..4c8b91af85 100644
--- a/tests/valid/String_Valid_5.whiley
+++ b/tests/valid/String_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function indexOf(int c1, [int] str) -> int | null:
int i = 0
@@ -8,14 +8,14 @@ function indexOf(int c1, [int] str) -> int | null:
i = i + 1
return null
-method main(System.Console sys) -> void:
- sys.out.println(indexOf('H', "Hello World"))
- sys.out.println(indexOf('e', "Hello World"))
- sys.out.println(indexOf('l', "Hello World"))
- sys.out.println(indexOf('o', "Hello World"))
- sys.out.println(indexOf(' ', "Hello World"))
- sys.out.println(indexOf('W', "Hello World"))
- sys.out.println(indexOf('r', "Hello World"))
- sys.out.println(indexOf('d', "Hello World"))
- sys.out.println(indexOf('z', "Hello World"))
- sys.out.println(indexOf('1', "Hello World"))
+public export method test() -> void:
+ assume indexOf('H', "Hello World") == 0
+ assume indexOf('e', "Hello World") == 1
+ assume indexOf('l', "Hello World") == 2
+ assume indexOf('o', "Hello World") == 4
+ assume indexOf(' ', "Hello World") == 5
+ assume indexOf('W', "Hello World") == 6
+ assume indexOf('r', "Hello World") == 8
+ assume indexOf('d', "Hello World") == 10
+ assume indexOf('z', "Hello World") == null
+ assume indexOf('1', "Hello World") == null
diff --git a/tests/valid/String_Valid_6.sysout b/tests/valid/String_Valid_6.sysout
deleted file mode 100644
index 2481ad8943..0000000000
--- a/tests/valid/String_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-Hello: 1223344566
diff --git a/tests/valid/String_Valid_6.whiley b/tests/valid/String_Valid_6.whiley
index 0aba92da37..be2892c5ab 100644
--- a/tests/valid/String_Valid_6.whiley
+++ b/tests/valid/String_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
- sys.out.println_s("Hello: " ++ Any.toString(1223344566))
+
+public export method test() -> void:
+ assume ("Hello " ++ "122") == "Hello 122"
diff --git a/tests/valid/String_Valid_7.sysout b/tests/valid/String_Valid_7.sysout
deleted file mode 100644
index e1c4466d09..0000000000
--- a/tests/valid/String_Valid_7.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-
-H
-Hello
-Hello Crue
diff --git a/tests/valid/String_Valid_7.whiley b/tests/valid/String_Valid_7.whiley
index fd2574c09c..56c835247c 100644
--- a/tests/valid/String_Valid_7.whiley
+++ b/tests/valid/String_Valid_7.whiley
@@ -1,11 +1,11 @@
-import whiley.lang.*
+
function f([int] str, int end) -> [int]:
return str[0..end]
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] str = "Hello Cruel World"
- sys.out.println_s(f(str, 0))
- sys.out.println_s(f(str, 1))
- sys.out.println_s(f(str, 5))
- sys.out.println_s(f(str, 10))
+ assume f(str, 0) == ""
+ assume f(str, 1) == "H"
+ assume f(str, 5) == "Hello"
+ assume f(str, 10) == "Hello Crue"
diff --git a/tests/valid/String_Valid_8.sysout b/tests/valid/String_Valid_8.sysout
deleted file mode 100644
index e0398b3dec..0000000000
--- a/tests/valid/String_Valid_8.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-ab
-bc
-cdefghjkl
\ No newline at end of file
diff --git a/tests/valid/String_Valid_8.whiley b/tests/valid/String_Valid_8.whiley
index e46a47ddd8..5b76a2d08e 100644
--- a/tests/valid/String_Valid_8.whiley
+++ b/tests/valid/String_Valid_8.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
[int] x = "abcdefghjkl"
[int] y = x[0..2]
- sys.out.println_s(y)
+ assert y == "ab"
y = x[1..3]
- sys.out.println_s(y)
+ assert y == "bc"
y = x[2..|x|]
- sys.out.println_s(y)
+ assert y == "cdefghjkl"
diff --git a/tests/valid/Subtype_Valid_1.sysout b/tests/valid/Subtype_Valid_1.sysout
deleted file mode 100755
index 7660873d10..0000000000
--- a/tests/valid/Subtype_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1]
diff --git a/tests/valid/Subtype_Valid_1.whiley b/tests/valid/Subtype_Valid_1.whiley
index a1cb0af9c3..be1ba8c086 100644
--- a/tests/valid/Subtype_Valid_1.whiley
+++ b/tests/valid/Subtype_Valid_1.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
type sr3nat is (int n) where n > 0
-method main(System.Console sys) -> void:
- [int] x = [1]
+public export method test() -> void:
+ [int] x = [2]
x[0] = 1
- sys.out.println(x)
+ assert x == [1]
diff --git a/tests/valid/Subtype_Valid_10.sysout b/tests/valid/Subtype_Valid_10.sysout
deleted file mode 100755
index 81ce206b03..0000000000
--- a/tests/valid/Subtype_Valid_10.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{f:2}
diff --git a/tests/valid/Subtype_Valid_10.whiley b/tests/valid/Subtype_Valid_10.whiley
index e419bd79c8..b2615785cb 100644
--- a/tests/valid/Subtype_Valid_10.whiley
+++ b/tests/valid/Subtype_Valid_10.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
type sr5nat is (int n) where n > 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
{sr5nat f} x = {f: 1}
x.f = 2
- sys.out.println(x)
+ assert x == {f: 2}
diff --git a/tests/valid/Subtype_Valid_11.sysout b/tests/valid/Subtype_Valid_11.sysout
deleted file mode 100755
index 81ce206b03..0000000000
--- a/tests/valid/Subtype_Valid_11.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{f:2}
diff --git a/tests/valid/Subtype_Valid_11.whiley b/tests/valid/Subtype_Valid_11.whiley
index 4d3000a395..20e00ea793 100644
--- a/tests/valid/Subtype_Valid_11.whiley
+++ b/tests/valid/Subtype_Valid_11.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
type sr5nat is int
-method main(System.Console sys) -> void:
+public export method test() -> void:
{sr5nat f} x = {f: 1}
x.f = 2
- sys.out.println(x)
+ assert x == {f: 2}
diff --git a/tests/valid/Subtype_Valid_12.sysout b/tests/valid/Subtype_Valid_12.sysout
deleted file mode 100755
index c62b750fb7..0000000000
--- a/tests/valid/Subtype_Valid_12.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{f:2,g:5}
diff --git a/tests/valid/Subtype_Valid_12.whiley b/tests/valid/Subtype_Valid_12.whiley
index 15eca08aa4..f95973bc49 100644
--- a/tests/valid/Subtype_Valid_12.whiley
+++ b/tests/valid/Subtype_Valid_12.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type sr6nat is (int n) where n > 0
type sr6tup is {sr6nat f, int g} where g > f
-method main(System.Console sys) -> void:
+public export method test() -> void:
sr6tup x = {f: 1, g: 5}
x.f = 2
- sys.out.println(x)
+ assert x == {f: 2, g: 5}
diff --git a/tests/valid/Subtype_Valid_13.sysout b/tests/valid/Subtype_Valid_13.sysout
deleted file mode 100755
index c62b750fb7..0000000000
--- a/tests/valid/Subtype_Valid_13.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{f:2,g:5}
diff --git a/tests/valid/Subtype_Valid_13.whiley b/tests/valid/Subtype_Valid_13.whiley
index 09476ac215..923c7d43a8 100644
--- a/tests/valid/Subtype_Valid_13.whiley
+++ b/tests/valid/Subtype_Valid_13.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type sr6nat is int
type sr6tup is {sr6nat f, int g}
-method main(System.Console sys) -> void:
+public export method test() -> void:
sr6tup x = {f: 1, g: 5}
- x.f = 2
- sys.out.println(x)
+ x.g = 2
+ assert x == {f: 1, g: 2}
diff --git a/tests/valid/Subtype_Valid_14.sysout b/tests/valid/Subtype_Valid_14.sysout
deleted file mode 100755
index 81ce206b03..0000000000
--- a/tests/valid/Subtype_Valid_14.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{f:2}
diff --git a/tests/valid/Subtype_Valid_14.whiley b/tests/valid/Subtype_Valid_14.whiley
index b44ff3e36c..ad172170c2 100644
--- a/tests/valid/Subtype_Valid_14.whiley
+++ b/tests/valid/Subtype_Valid_14.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
type sr7nat is (int n) where n > 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
{sr7nat f} x = {f: 1}
x.f = x.f + 1
- sys.out.println(x)
+ assert x == {f: 2}
diff --git a/tests/valid/Subtype_Valid_2.sysout b/tests/valid/Subtype_Valid_2.sysout
deleted file mode 100755
index 81ce206b03..0000000000
--- a/tests/valid/Subtype_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{f:2}
diff --git a/tests/valid/Subtype_Valid_2.whiley b/tests/valid/Subtype_Valid_2.whiley
index bdbb39e332..911bc25387 100644
--- a/tests/valid/Subtype_Valid_2.whiley
+++ b/tests/valid/Subtype_Valid_2.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
type sr7nat is int
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int f} x = {f: 1}
x.f = x.f + 1
- sys.out.println(x)
+ assume x == {f:2}
diff --git a/tests/valid/Subtype_Valid_3.sysout b/tests/valid/Subtype_Valid_3.sysout
deleted file mode 100755
index c32cbb13da..0000000000
--- a/tests/valid/Subtype_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[{f:2,g:3}, {f:4,g:8}]
diff --git a/tests/valid/Subtype_Valid_3.whiley b/tests/valid/Subtype_Valid_3.whiley
index 45605bbc8f..669b91a9d7 100644
--- a/tests/valid/Subtype_Valid_3.whiley
+++ b/tests/valid/Subtype_Valid_3.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type sr8nat is (int n) where n > 0
type sr8tup is {sr8nat f, int g} where g > f
-method main(System.Console sys) -> void:
+public export method test() -> void:
[sr8tup] x = [{f: 1, g: 3}, {f: 4, g: 8}]
x[0].f = 2
- sys.out.println(x)
+ assume x == [{f: 2, g: 3}, {f: 4, g: 8}]
diff --git a/tests/valid/Subtype_Valid_4.sysout b/tests/valid/Subtype_Valid_4.sysout
deleted file mode 100755
index c32cbb13da..0000000000
--- a/tests/valid/Subtype_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[{f:2,g:3}, {f:4,g:8}]
diff --git a/tests/valid/Subtype_Valid_4.whiley b/tests/valid/Subtype_Valid_4.whiley
index 26ba5626f8..1a98bb6734 100644
--- a/tests/valid/Subtype_Valid_4.whiley
+++ b/tests/valid/Subtype_Valid_4.whiley
@@ -1,10 +1,10 @@
-import whiley.lang.*
+
type sr8nat is int
type sr8tup is {sr8nat f, int g}
-method main(System.Console sys) -> void:
+public export method test() -> void:
[sr8tup] x = [{f: 1, g: 3}, {f: 4, g: 8}]
x[0].f = 2
- sys.out.println(x)
+ assume x == [{f: 2, g: 3}, {f: 4, g: 8}]
diff --git a/tests/valid/Subtype_Valid_5.sysout b/tests/valid/Subtype_Valid_5.sysout
deleted file mode 100755
index 91cdc97c0e..0000000000
--- a/tests/valid/Subtype_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[{f:2,g:2}, {f:1,g:8}]
diff --git a/tests/valid/Subtype_Valid_5.whiley b/tests/valid/Subtype_Valid_5.whiley
index edf933656a..0e74187d4b 100644
--- a/tests/valid/Subtype_Valid_5.whiley
+++ b/tests/valid/Subtype_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type sr9nat is (int x) where x > 0
@@ -6,7 +6,7 @@ type sr9tup is {sr9nat f, int g} where g > f
type sr9arr is ([sr9tup] xs) where some { z in xs | z.f == 1 }
-method main(System.Console sys) -> void:
+public export method test() -> void:
sr9arr x = [{f: 1, g: 2}, {f: 1, g: 8}]
x[0].f = 2
- sys.out.println(x)
+ assume x == [{f: 2, g: 2}, {f: 1, g: 8}]
diff --git a/tests/valid/Subtype_Valid_6.sysout b/tests/valid/Subtype_Valid_6.sysout
deleted file mode 100755
index 91cdc97c0e..0000000000
--- a/tests/valid/Subtype_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[{f:2,g:2}, {f:1,g:8}]
diff --git a/tests/valid/Subtype_Valid_6.whiley b/tests/valid/Subtype_Valid_6.whiley
index f8c173dcb4..c54fce3c70 100644
--- a/tests/valid/Subtype_Valid_6.whiley
+++ b/tests/valid/Subtype_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type sr9nat is int
@@ -6,7 +6,8 @@ type sr9tup is {sr9nat f, int g}
type sr9arr is [{sr9nat f, int g}]
-method main(System.Console sys) -> void:
+public export method test() -> void:
sr9arr x = [{f: 1, g: 2}, {f: 1, g: 8}]
x[0].f = 2
- sys.out.println(x)
+ assume x == [{f: 2, g: 2}, {f: 1, g: 8}]
+
diff --git a/tests/valid/Subtype_Valid_7.sysout b/tests/valid/Subtype_Valid_7.sysout
deleted file mode 100755
index 7660873d10..0000000000
--- a/tests/valid/Subtype_Valid_7.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1]
diff --git a/tests/valid/Subtype_Valid_7.whiley b/tests/valid/Subtype_Valid_7.whiley
index 3e65d03738..d2f405bac1 100644
--- a/tests/valid/Subtype_Valid_7.whiley
+++ b/tests/valid/Subtype_Valid_7.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
type sr3nat is int
-method main(System.Console sys) -> void:
- [sr3nat] x = [1]
- x[0] = 1
- sys.out.println(x)
+public export method test() -> void:
+ [sr3nat] x = [1,2]
+ x[0] = 2
+ assert x == [2,2]
diff --git a/tests/valid/Subtype_Valid_8.sysout b/tests/valid/Subtype_Valid_8.sysout
deleted file mode 100755
index c29bd4fd5d..0000000000
--- a/tests/valid/Subtype_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1}
diff --git a/tests/valid/Subtype_Valid_8.whiley b/tests/valid/Subtype_Valid_8.whiley
index 0f563eabbc..5ac6df0690 100644
--- a/tests/valid/Subtype_Valid_8.whiley
+++ b/tests/valid/Subtype_Valid_8.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
type sr4set is ({int} xs) where |xs| > 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
sr4set x = {1}
- sys.out.println(x)
+ assert x == {1}
diff --git a/tests/valid/Subtype_Valid_9.sysout b/tests/valid/Subtype_Valid_9.sysout
deleted file mode 100755
index c29bd4fd5d..0000000000
--- a/tests/valid/Subtype_Valid_9.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{1}
diff --git a/tests/valid/Subtype_Valid_9.whiley b/tests/valid/Subtype_Valid_9.whiley
index 100ad10ad4..6ed22b11b2 100644
--- a/tests/valid/Subtype_Valid_9.whiley
+++ b/tests/valid/Subtype_Valid_9.whiley
@@ -1,7 +1,7 @@
-import whiley.lang.*
+
type sr4set is {int}
-method main(System.Console sys) -> void:
+public export method test() -> void:
sr4set x = {1}
- sys.out.println(x)
+ assert x == {1}
diff --git a/tests/valid/Switch_Valid_1.sysout b/tests/valid/Switch_Valid_1.sysout
deleted file mode 100644
index 33f911e8c0..0000000000
--- a/tests/valid/Switch_Valid_1.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-1
-0
-1
-0
-1
diff --git a/tests/valid/Switch_Valid_1.whiley b/tests/valid/Switch_Valid_1.whiley
index 50175f329f..ee34b00150 100644
--- a/tests/valid/Switch_Valid_1.whiley
+++ b/tests/valid/Switch_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int n) where n >= 0
@@ -10,9 +10,9 @@ function f(int x) -> nat:
return x + 1
return 1
-method main(System.Console sys) -> void:
- sys.out.println(f(2))
- sys.out.println(f(1))
- sys.out.println(f(0))
- sys.out.println(f(-1))
- sys.out.println(f(-2))
+public export method test() -> void:
+ assume f(2) == 1
+ assume f(1) == 0
+ assume f(0) == 1
+ assume f(-1) == 0
+ assume f(-2) == 1
diff --git a/tests/valid/Switch_Valid_10.sysout b/tests/valid/Switch_Valid_10.sysout
deleted file mode 100644
index 108b469b75..0000000000
--- a/tests/valid/Switch_Valid_10.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-0
--1
-10
-10
diff --git a/tests/valid/Switch_Valid_10.whiley b/tests/valid/Switch_Valid_10.whiley
index 5dc904e232..1147fc1b6f 100644
--- a/tests/valid/Switch_Valid_10.whiley
+++ b/tests/valid/Switch_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(real x) -> int:
switch x:
@@ -8,8 +8,8 @@ function f(real x) -> int:
return -1
return 10
-method main(System.Console sys) -> void:
- sys.out.println(f(1.23))
- sys.out.println(f(2.01))
- sys.out.println(f(3.0))
- sys.out.println(f(-1.0))
+public export method test() -> void:
+ assume f(1.23) == 0
+ assume f(2.01) == -1
+ assume f(3.0) == 10
+ assume f(-1.0) == 10
diff --git a/tests/valid/Switch_Valid_11.sysout b/tests/valid/Switch_Valid_11.sysout
deleted file mode 100644
index 56f24a18d5..0000000000
--- a/tests/valid/Switch_Valid_11.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-0
-2
diff --git a/tests/valid/Switch_Valid_11.whiley b/tests/valid/Switch_Valid_11.whiley
index 1c99527225..4cf5817a88 100644
--- a/tests/valid/Switch_Valid_11.whiley
+++ b/tests/valid/Switch_Valid_11.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> (int r)
// Return is between 0 and 2
@@ -11,7 +11,7 @@ ensures r >= 0 && r <= 2:
return 1
return 2
-method main(System.Console sys) -> void:
- sys.out.println(f(2))
- sys.out.println(f(1))
- sys.out.println(f(0))
+public export method test() -> void:
+ assume f(2) == 1
+ assume f(1) == 0
+ assume f(0) == 2
diff --git a/tests/valid/Switch_Valid_12.sysout b/tests/valid/Switch_Valid_12.sysout
deleted file mode 100644
index 108b469b75..0000000000
--- a/tests/valid/Switch_Valid_12.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-0
--1
-10
-10
diff --git a/tests/valid/Switch_Valid_12.whiley b/tests/valid/Switch_Valid_12.whiley
index d86e0cb90e..70d8923e17 100644
--- a/tests/valid/Switch_Valid_12.whiley
+++ b/tests/valid/Switch_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] x) -> int:
switch x:
@@ -8,8 +8,8 @@ function f([int] x) -> int:
return -1
return 10
-method main(System.Console sys) -> void:
- sys.out.println(f([]))
- sys.out.println(f([1]))
- sys.out.println(f([3]))
- sys.out.println(f([1, 2, 3]))
+public export method test() -> void:
+ assume f([]) == 0
+ assume f([1]) == -1
+ assume f([3]) == 10
+ assume f([1, 2, 3]) == 10
diff --git a/tests/valid/Switch_Valid_13.sysout b/tests/valid/Switch_Valid_13.sysout
deleted file mode 100644
index 9556c8e38c..0000000000
--- a/tests/valid/Switch_Valid_13.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
--1
--1
-1
-10
diff --git a/tests/valid/Switch_Valid_13.whiley b/tests/valid/Switch_Valid_13.whiley
index 79cea0fa04..a25c40c0bb 100644
--- a/tests/valid/Switch_Valid_13.whiley
+++ b/tests/valid/Switch_Valid_13.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
switch x:
@@ -8,8 +8,8 @@ function f(int x) -> int:
return 1
return 10
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(3))
- sys.out.println(f(-1))
+public export method test() -> void:
+ assume f(1) == -1
+ assume f(2) == -1
+ assume f(3) == 1
+ assume f(-1) == 10
diff --git a/tests/valid/Switch_Valid_2.sysout b/tests/valid/Switch_Valid_2.sysout
deleted file mode 100644
index 1ce7786c00..0000000000
--- a/tests/valid/Switch_Valid_2.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
--1
--2
-0
-0
diff --git a/tests/valid/Switch_Valid_2.whiley b/tests/valid/Switch_Valid_2.whiley
index 18a396c6cc..1684f269ce 100644
--- a/tests/valid/Switch_Valid_2.whiley
+++ b/tests/valid/Switch_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
int y
@@ -11,8 +11,8 @@ function f(int x) -> int:
y = 0
return y
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(3))
- sys.out.println(f(-1))
+public export method test() -> void:
+ assume f(1) == -1
+ assume f(2) == -2
+ assume f(3) == 0
+ assume f(-1) == 0
diff --git a/tests/valid/Switch_Valid_3.sysout b/tests/valid/Switch_Valid_3.sysout
deleted file mode 100644
index e124078b01..0000000000
--- a/tests/valid/Switch_Valid_3.sysout
+++ /dev/null
@@ -1,7 +0,0 @@
-1
-2
-3
-4
-5
-6
-6
\ No newline at end of file
diff --git a/tests/valid/Switch_Valid_3.whiley b/tests/valid/Switch_Valid_3.whiley
index d34f914f53..e16c50de5d 100644
--- a/tests/valid/Switch_Valid_3.whiley
+++ b/tests/valid/Switch_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] input) -> int
requires |input| > 0:
@@ -21,11 +21,11 @@ requires |input| > 0:
//
return r
-method main(System.Console sys) -> void:
- sys.out.println(f("N"))
- sys.out.println(f("B"))
- sys.out.println(f("R"))
- sys.out.println(f("Q"))
- sys.out.println(f("K"))
- sys.out.println(f("e"))
- sys.out.println(f("1"))
+public export method test() -> void:
+ assume f("N") == 1
+ assume f("B") == 2
+ assume f("R") == 3
+ assume f("Q") == 4
+ assume f("K") == 5
+ assume f("e") == 6
+ assume f("1") == 6
diff --git a/tests/valid/Switch_Valid_4.sysout b/tests/valid/Switch_Valid_4.sysout
deleted file mode 100644
index 6aeaa2c1c8..0000000000
--- a/tests/valid/Switch_Valid_4.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-NUM: 123
-NUM: 456
-NUM: 234
diff --git a/tests/valid/Switch_Valid_4.whiley b/tests/valid/Switch_Valid_4.whiley
index 83f3b5d767..0625dbddf7 100644
--- a/tests/valid/Switch_Valid_4.whiley
+++ b/tests/valid/Switch_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant Red is 1
@@ -17,7 +17,7 @@ function f(RGB c) -> int:
default:
return 456
-method main(System.Console sys) -> void:
- sys.out.println_s("NUM: " ++ Any.toString(f(Red)))
- sys.out.println_s("NUM: " ++ Any.toString(f(Green)))
- sys.out.println_s("NUM: " ++ Any.toString(f(Blue)))
+public export method test() -> void:
+ assume f(Red) == 123
+ assume f(Green) == 456
+ assume f(Blue) == 234
diff --git a/tests/valid/Switch_Valid_5.sysout b/tests/valid/Switch_Valid_5.sysout
deleted file mode 100644
index 2b41dc51ea..0000000000
--- a/tests/valid/Switch_Valid_5.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-GOT: 1
-GOT: 2
-GOT: 3
-GOT: 4
-GOT: 5
diff --git a/tests/valid/Switch_Valid_5.whiley b/tests/valid/Switch_Valid_5.whiley
index 867c07ae5b..d7d938bd25 100644
--- a/tests/valid/Switch_Valid_5.whiley
+++ b/tests/valid/Switch_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant IHDR_TYPE is 1380206665
@@ -27,9 +27,9 @@ public function f(int type) -> int:
default:
return 6
-public method main(System.Console sys) -> void:
- sys.out.println_s("GOT: " ++ Any.toString(f(IHDR_TYPE)))
- sys.out.println_s("GOT: " ++ Any.toString(f(IEND_TYPE)))
- sys.out.println_s("GOT: " ++ Any.toString(f(PLTE_TYPE)))
- sys.out.println_s("GOT: " ++ Any.toString(f(PHYS_TYPE)))
- sys.out.println_s("GOT: " ++ Any.toString(f(TIME_TYPE)))
+public export method test() -> void:
+ assume f(IHDR_TYPE) == 1
+ assume f(IEND_TYPE) == 2
+ assume f(PLTE_TYPE) == 3
+ assume f(PHYS_TYPE) == 4
+ assume f(TIME_TYPE) == 5
diff --git a/tests/valid/Switch_Valid_6.sysout b/tests/valid/Switch_Valid_6.sysout
deleted file mode 100644
index 108b469b75..0000000000
--- a/tests/valid/Switch_Valid_6.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-0
--1
-10
-10
diff --git a/tests/valid/Switch_Valid_6.whiley b/tests/valid/Switch_Valid_6.whiley
index e52365a268..2a6d674d55 100644
--- a/tests/valid/Switch_Valid_6.whiley
+++ b/tests/valid/Switch_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> int:
switch x:
@@ -8,8 +8,8 @@ function f(int x) -> int:
return -1
return 10
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(2))
- sys.out.println(f(3))
- sys.out.println(f(-1))
+public export method test() -> void:
+ assume f(1) == 0
+ assume f(2) == -1
+ assume f(3) == 10
+ assume f(-1) == 10
diff --git a/tests/valid/Switch_Valid_7.sysout b/tests/valid/Switch_Valid_7.sysout
deleted file mode 100644
index 7938dcdde8..0000000000
--- a/tests/valid/Switch_Valid_7.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-0
-1
-0
diff --git a/tests/valid/Switch_Valid_7.whiley b/tests/valid/Switch_Valid_7.whiley
index 2eef12534f..e3eff7f188 100644
--- a/tests/valid/Switch_Valid_7.whiley
+++ b/tests/valid/Switch_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int n) where n >= 0
@@ -14,7 +14,7 @@ ensures r == 0 || r == 1:
default:
return 0
-method main(System.Console sys) -> void:
- sys.out.println(f(2))
- sys.out.println(f(1))
- sys.out.println(f(0))
+public export method test() -> void:
+ assume f(2) == 0
+ assume f(1) == 1
+ assume f(0) == 0
diff --git a/tests/valid/Switch_Valid_8.sysout b/tests/valid/Switch_Valid_8.sysout
deleted file mode 100644
index fbd79dc537..0000000000
--- a/tests/valid/Switch_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-CASE 1
diff --git a/tests/valid/Switch_Valid_8.whiley b/tests/valid/Switch_Valid_8.whiley
index 7ebe9fec36..22ea4f113b 100644
--- a/tests/valid/Switch_Valid_8.whiley
+++ b/tests/valid/Switch_Valid_8.whiley
@@ -1,12 +1,13 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
int x = 1
switch x:
case 1:
- sys.out.println_s("CASE 1")
+ assume true
return
case 2:
- sys.out.println_s("CASE 2")
+ assume false
return
- sys.out.println_s("DEFAULT CASE")
+ //
+ assume false
diff --git a/tests/valid/Switch_Valid_9.sysout b/tests/valid/Switch_Valid_9.sysout
deleted file mode 100644
index 073f6a1f45..0000000000
--- a/tests/valid/Switch_Valid_9.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-2
-2
-0
diff --git a/tests/valid/Switch_Valid_9.whiley b/tests/valid/Switch_Valid_9.whiley
index 687df52ca6..dfdb43e3bb 100644
--- a/tests/valid/Switch_Valid_9.whiley
+++ b/tests/valid/Switch_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int x) -> (int r)
// Return cannot be 1
@@ -11,7 +11,7 @@ ensures r != 1:
return 2
return x
-method main(System.Console sys) -> void:
- sys.out.println(f(2))
- sys.out.println(f(1))
- sys.out.println(f(0))
+public export method test() -> void:
+ assume f(2) == 2
+ assume f(1) == 2
+ assume f(0) == 0
diff --git a/tests/valid/Syntax_Valid_1.sysout b/tests/valid/Syntax_Valid_1.sysout
deleted file mode 100644
index d9605cba78..0000000000
--- a/tests/valid/Syntax_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-HELLO
\ No newline at end of file
diff --git a/tests/valid/Syntax_Valid_1.whiley b/tests/valid/Syntax_Valid_1.whiley
index d560d632d6..16cae680bd 100644
--- a/tests/valid/Syntax_Valid_1.whiley
+++ b/tests/valid/Syntax_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
-method main(System.Console c) -> void:
- debug "HELLO"
+
+public export method test() -> void:
+ debug ""
diff --git a/tests/valid/TupleType_Valid_1.sysout b/tests/valid/TupleType_Valid_1.sysout
deleted file mode 100755
index 2b2f2e1b92..0000000000
--- a/tests/valid/TupleType_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-3
diff --git a/tests/valid/TupleType_Valid_1.whiley b/tests/valid/TupleType_Valid_1.whiley
index bee49029de..37f7bfc981 100644
--- a/tests/valid/TupleType_Valid_1.whiley
+++ b/tests/valid/TupleType_Valid_1.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
function f(int x) -> (int, int):
return (x, x + 2)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x, int y = f(1)
- sys.out.println(x)
- sys.out.println(y)
+ assume x == 1
+ assume y == 3
diff --git a/tests/valid/TupleType_Valid_2.sysout b/tests/valid/TupleType_Valid_2.sysout
deleted file mode 100755
index 99a45a1c91..0000000000
--- a/tests/valid/TupleType_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-(1,3)
diff --git a/tests/valid/TupleType_Valid_2.whiley b/tests/valid/TupleType_Valid_2.whiley
index 6edeb02caa..d81ebc17ee 100644
--- a/tests/valid/TupleType_Valid_2.whiley
+++ b/tests/valid/TupleType_Valid_2.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
function f(int x) -> (int, int):
return (x, x + 2)
-method main(System.Console sys) -> void:
+public export method test() -> void:
(int,int) x = f(1)
- sys.out.println(x)
+ assume x == (1,3)
diff --git a/tests/valid/TupleType_Valid_3.sysout b/tests/valid/TupleType_Valid_3.sysout
deleted file mode 100755
index 2b2f2e1b92..0000000000
--- a/tests/valid/TupleType_Valid_3.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-3
diff --git a/tests/valid/TupleType_Valid_3.whiley b/tests/valid/TupleType_Valid_3.whiley
index bee49029de..37f7bfc981 100644
--- a/tests/valid/TupleType_Valid_3.whiley
+++ b/tests/valid/TupleType_Valid_3.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
function f(int x) -> (int, int):
return (x, x + 2)
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x, int y = f(1)
- sys.out.println(x)
- sys.out.println(y)
+ assume x == 1
+ assume y == 3
diff --git a/tests/valid/TupleType_Valid_4.sysout b/tests/valid/TupleType_Valid_4.sysout
deleted file mode 100755
index 5816a789c7..0000000000
--- a/tests/valid/TupleType_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-(1.0,2.0)
diff --git a/tests/valid/TupleType_Valid_4.whiley b/tests/valid/TupleType_Valid_4.whiley
index 4260c9f8e9..545c2338af 100644
--- a/tests/valid/TupleType_Valid_4.whiley
+++ b/tests/valid/TupleType_Valid_4.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Tup1 is (int, int)
@@ -7,6 +7,6 @@ type Tup2 is (real, real)
function f(Tup1 x) -> Tup2:
return (Tup2) x
-method main(System.Console sys) -> void:
+public export method test() -> void:
Tup2 x = f((1, 2))
- sys.out.println(x)
+ assume x == (1.0,2.0)
diff --git a/tests/valid/TupleType_Valid_5.sysout b/tests/valid/TupleType_Valid_5.sysout
deleted file mode 100644
index e538220165..0000000000
--- a/tests/valid/TupleType_Valid_5.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-true
-true
-true
-true
-false
diff --git a/tests/valid/TupleType_Valid_5.whiley b/tests/valid/TupleType_Valid_5.whiley
index 6528236c90..a8bfc8aef0 100644
--- a/tests/valid/TupleType_Valid_5.whiley
+++ b/tests/valid/TupleType_Valid_5.whiley
@@ -1,24 +1,24 @@
-import whiley.lang.*
-
type Pos is (int, int)
+function abs(int x) -> int:
+ if x >= 0:
+ return x
+ else:
+ return -x
+
function conflict(Pos p, int row, int col) -> bool:
int r, int c = p
if (r == row) || (c == col):
return true
- int colDiff = Math.abs(c - col)
- int rowDiff = Math.abs(r - row)
+ int colDiff = abs(c - col)
+ int rowDiff = abs(r - row)
return colDiff == rowDiff
-method main(System.Console sys) -> void:
+public export method test() -> void:
(int,int) p = (1, 2)
- bool c = conflict(p, 1, 2)
- sys.out.println(c)
- c = conflict(p, 3, 4)
- sys.out.println(c)
- c = conflict(p, 1, 4)
- sys.out.println(c)
- c = conflict(p, 3, 2)
- sys.out.println(c)
- c = conflict(p, 3, 3)
- sys.out.println(c)
+ assume conflict(p, 1, 2)
+ assume conflict(p, 3, 4)
+ assume conflict(p, 1, 4)
+ assume conflict(p, 3, 2)
+ assume !conflict(p, 3, 3)
+
diff --git a/tests/valid/TupleType_Valid_6.sysout b/tests/valid/TupleType_Valid_6.sysout
deleted file mode 100644
index 2aa53b84b5..0000000000
--- a/tests/valid/TupleType_Valid_6.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-X=1,Y=2
-X=1.2,Y=2.3
diff --git a/tests/valid/TupleType_Valid_6.whiley b/tests/valid/TupleType_Valid_6.whiley
index c656643373..a996995124 100644
--- a/tests/valid/TupleType_Valid_6.whiley
+++ b/tests/valid/TupleType_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type etup is (int, int) | (real, real)
@@ -8,8 +8,8 @@ function f(int x) -> etup:
else:
return (1.2, 2.3)
-public method main(System.Console sys) -> void:
+public export method test() -> void:
(int|real x,int|real y) = f(-1)
- sys.out.println_s("X=" ++ Any.toString(x) ++ ",Y=" ++ Any.toString(y))
+ assume x == 1 && y == 2
(x, y) = f(2)
- sys.out.println_s("X=" ++ Any.toString(x) ++ ",Y=" ++ Any.toString(y))
+ assume x == 1.2 && y == 2.3
diff --git a/tests/valid/TupleType_Valid_7.sysout b/tests/valid/TupleType_Valid_7.sysout
deleted file mode 100644
index 2aa53b84b5..0000000000
--- a/tests/valid/TupleType_Valid_7.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-X=1,Y=2
-X=1.2,Y=2.3
diff --git a/tests/valid/TupleType_Valid_7.whiley b/tests/valid/TupleType_Valid_7.whiley
index 6e5818d848..726f6e19f3 100644
--- a/tests/valid/TupleType_Valid_7.whiley
+++ b/tests/valid/TupleType_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type etup is (int, int) | (real, real)
@@ -11,8 +11,8 @@ function f(int x) -> etup:
function g(int x) -> (int | real, int | real):
return f(x)
-public method main(System.Console sys) -> void:
+public export method test() -> void:
(int|real x, int|real y) = g(-1)
- sys.out.println_s("X=" ++ Any.toString(x) ++ ",Y=" ++ Any.toString(y))
+ assume x == 1 && y == 2
(x, y) = g(2)
- sys.out.println_s("X=" ++ Any.toString(x) ++ ",Y=" ++ Any.toString(y))
+ assume x == 1.2 && y == 2.3
diff --git a/tests/valid/TupleType_Valid_8.sysout b/tests/valid/TupleType_Valid_8.sysout
deleted file mode 100644
index f7574a752d..0000000000
--- a/tests/valid/TupleType_Valid_8.sysout
+++ /dev/null
@@ -1,6 +0,0 @@
-TUPLE: (0,0)
-TUPLE: (1,1)
-TUPLE: (0,1)
-TUPLE: (2,2)
-TUPLE: (0,2)
-TUPLE: (2,2)
diff --git a/tests/valid/TupleType_Valid_8.whiley b/tests/valid/TupleType_Valid_8.whiley
index 1efe7dbe3d..5cb05c273b 100644
--- a/tests/valid/TupleType_Valid_8.whiley
+++ b/tests/valid/TupleType_Valid_8.whiley
@@ -1,7 +1,11 @@
-import whiley.lang.*
+
constant GAME is [(0, 0), (1, 1), (0, 1), (2, 2), (0, 2), (2, 2)]
-public method main(System.Console console) -> void:
- for tup in GAME:
- console.out.println_s("TUPLE: " ++ Any.toString(tup))
+public export method test() -> void:
+ assert GAME[0] == (0,0)
+ assert GAME[1] == (1,1)
+ assert GAME[2] == (0,1)
+ assert GAME[3] == (2,2)
+ assert GAME[4] == (0,2)
+ assert GAME[5] == (2,2)
diff --git a/tests/valid/TypeEquals_Valid_1.sysout b/tests/valid/TypeEquals_Valid_1.sysout
deleted file mode 100755
index d25232800f..0000000000
--- a/tests/valid/TypeEquals_Valid_1.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
\ No newline at end of file
diff --git a/tests/valid/TypeEquals_Valid_1.whiley b/tests/valid/TypeEquals_Valid_1.whiley
index 338894e0e9..238da8383d 100644
--- a/tests/valid/TypeEquals_Valid_1.whiley
+++ b/tests/valid/TypeEquals_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type bop is {int y, int x} where x > 0
@@ -10,8 +10,8 @@ function f(expr e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e = 1
- sys.out.println(f(e))
+ assume f(e) == true
e = {y: 2, x: 1}
- sys.out.println(f(e))
+ assume f(e) == false
diff --git a/tests/valid/TypeEquals_Valid_10.sysout b/tests/valid/TypeEquals_Valid_10.sysout
deleted file mode 100755
index d25232800f..0000000000
--- a/tests/valid/TypeEquals_Valid_10.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
\ No newline at end of file
diff --git a/tests/valid/TypeEquals_Valid_10.whiley b/tests/valid/TypeEquals_Valid_10.whiley
index adcf5483f6..edd458784b 100644
--- a/tests/valid/TypeEquals_Valid_10.whiley
+++ b/tests/valid/TypeEquals_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Rtypes is {int y, int x} | {int z, int x}
@@ -8,6 +8,6 @@ function f(Rtypes e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({y: 1, x: 1}))
- sys.out.println(f({z: 1, x: 1}))
+public export method test() -> void:
+ assume f({y: 1, x: 3}) == true
+ assume f({z: 1, x: 3}) == false
diff --git a/tests/valid/TypeEquals_Valid_11.sysout b/tests/valid/TypeEquals_Valid_11.sysout
deleted file mode 100755
index 4623095772..0000000000
--- a/tests/valid/TypeEquals_Valid_11.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-false
-false
-true
\ No newline at end of file
diff --git a/tests/valid/TypeEquals_Valid_11.whiley b/tests/valid/TypeEquals_Valid_11.whiley
index 3bb299fa70..19bc57ff09 100644
--- a/tests/valid/TypeEquals_Valid_11.whiley
+++ b/tests/valid/TypeEquals_Valid_11.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Rtypes is {real y, real x} | {int z, int x}
@@ -8,7 +8,7 @@ function f(Rtypes e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({y: 1.2, x: 1.2}))
- sys.out.println(f({y: 1.0, x: 1.0}))
- sys.out.println(f({z: 1, x: 1}))
+public export method test() -> void:
+ assume f({y: 1.2, x: 1.2}) == false
+ assume f({y: 1.0, x: 1.0}) == false
+ assume f({z: 1, x: 1}) == true
diff --git a/tests/valid/TypeEquals_Valid_12.sysout b/tests/valid/TypeEquals_Valid_12.sysout
deleted file mode 100755
index d25232800f..0000000000
--- a/tests/valid/TypeEquals_Valid_12.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
\ No newline at end of file
diff --git a/tests/valid/TypeEquals_Valid_12.whiley b/tests/valid/TypeEquals_Valid_12.whiley
index bfdf7b9e81..45fb80d800 100644
--- a/tests/valid/TypeEquals_Valid_12.whiley
+++ b/tests/valid/TypeEquals_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type bop is {int y, int x}
@@ -10,8 +10,8 @@ function f(expr e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e = 1
- sys.out.println(f(e))
+ assume f(e) == true
e = {y: 2, x: 1}
- sys.out.println(f(e))
+ assume f(e) == false
diff --git a/tests/valid/TypeEquals_Valid_13.sysout b/tests/valid/TypeEquals_Valid_13.sysout
deleted file mode 100755
index d25232800f..0000000000
--- a/tests/valid/TypeEquals_Valid_13.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
\ No newline at end of file
diff --git a/tests/valid/TypeEquals_Valid_13.whiley b/tests/valid/TypeEquals_Valid_13.whiley
index 1a4cbb107f..c545ddd511 100644
--- a/tests/valid/TypeEquals_Valid_13.whiley
+++ b/tests/valid/TypeEquals_Valid_13.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type iset is {int} | int
@@ -8,6 +8,6 @@ function f(iset e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({1, 2, 3}))
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f({1, 2, 3}) == true
+ assume f(1) == false
diff --git a/tests/valid/TypeEquals_Valid_14.sysout b/tests/valid/TypeEquals_Valid_14.sysout
deleted file mode 100755
index 9e8a46acf9..0000000000
--- a/tests/valid/TypeEquals_Valid_14.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-true
-false
diff --git a/tests/valid/TypeEquals_Valid_14.whiley b/tests/valid/TypeEquals_Valid_14.whiley
index 7f1f2cf4ef..39dfb66aa4 100644
--- a/tests/valid/TypeEquals_Valid_14.whiley
+++ b/tests/valid/TypeEquals_Valid_14.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type test is {int x} | {int y}
@@ -10,7 +10,7 @@ function f(src e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({x: 1}))
- sys.out.println(f({y: 2}))
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f({x: 1}) == true
+ assume f({y: 2}) == true
+ assume f(1) == false
diff --git a/tests/valid/TypeEquals_Valid_15.sysout b/tests/valid/TypeEquals_Valid_15.sysout
deleted file mode 100755
index 9e8a46acf9..0000000000
--- a/tests/valid/TypeEquals_Valid_15.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-true
-false
diff --git a/tests/valid/TypeEquals_Valid_15.whiley b/tests/valid/TypeEquals_Valid_15.whiley
index 7e49b037ee..4b2292bfe2 100644
--- a/tests/valid/TypeEquals_Valid_15.whiley
+++ b/tests/valid/TypeEquals_Valid_15.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type src is int | [int] | [[int]]
@@ -8,7 +8,7 @@ function f(src e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f([1, 2, 3]))
- sys.out.println(f([[1], [2]]))
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f([1, 2, 3]) == true
+ assume f([[1], [2]]) == true
+ assume f(1) == false
diff --git a/tests/valid/TypeEquals_Valid_16.sysout b/tests/valid/TypeEquals_Valid_16.sysout
deleted file mode 100755
index 6859f05a48..0000000000
--- a/tests/valid/TypeEquals_Valid_16.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-true
-true
-true
-false
diff --git a/tests/valid/TypeEquals_Valid_16.whiley b/tests/valid/TypeEquals_Valid_16.whiley
index 974aef8409..49664f323f 100644
--- a/tests/valid/TypeEquals_Valid_16.whiley
+++ b/tests/valid/TypeEquals_Valid_16.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type src is int | [src]
@@ -8,8 +8,8 @@ function f(src e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f([1]))
- sys.out.println(f([[1]]))
- sys.out.println(f([[[1]]]))
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f([1]) == true
+ assume f([[1]]) == true
+ assume f([[[1]]]) == true
+ assume f(1) == false
diff --git a/tests/valid/TypeEquals_Valid_17.sysout b/tests/valid/TypeEquals_Valid_17.sysout
deleted file mode 100755
index 8975c726eb..0000000000
--- a/tests/valid/TypeEquals_Valid_17.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-0
-0
-3
diff --git a/tests/valid/TypeEquals_Valid_17.whiley b/tests/valid/TypeEquals_Valid_17.whiley
index 286756a968..58e3938140 100644
--- a/tests/valid/TypeEquals_Valid_17.whiley
+++ b/tests/valid/TypeEquals_Valid_17.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type rlist is real | [int]
@@ -8,7 +8,7 @@ function f(rlist l) -> int:
else:
return |l|
-method main(System.Console sys) -> void:
- sys.out.println(f(123.0))
- sys.out.println(f(1.23))
- sys.out.println(f([1, 2, 3]))
+public export method test() -> void:
+ assume f(123.0) == 0
+ assume f(1.23) == 0
+ assume f([1, 2, 3]) == 3
diff --git a/tests/valid/TypeEquals_Valid_18.sysout b/tests/valid/TypeEquals_Valid_18.sysout
deleted file mode 100644
index 6eefcf8943..0000000000
--- a/tests/valid/TypeEquals_Valid_18.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-[1, 2, 3, 4, 5, 6, 7]
-[]
-[1, 2, 3]
-[1, 2, 3]
diff --git a/tests/valid/TypeEquals_Valid_18.whiley b/tests/valid/TypeEquals_Valid_18.whiley
index e59df86d65..b5d5a90f05 100644
--- a/tests/valid/TypeEquals_Valid_18.whiley
+++ b/tests/valid/TypeEquals_Valid_18.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int | real] e) -> [int]:
if e is [int]:
@@ -6,8 +6,8 @@ function f([int | real] e) -> [int]:
else:
return [1, 2, 3]
-method main(System.Console sys) -> void:
- sys.out.println(f([1, 2, 3, 4, 5, 6, 7]))
- sys.out.println(f([]))
- sys.out.println(f([1, 2, 2.01]))
- sys.out.println(f([1.23, 2, 2.01]))
+public export method test() -> void:
+ assume f([1, 2, 3, 4, 5, 6, 7]) == [1, 2, 3, 4, 5, 6, 7]
+ assume f([]) == []
+ assume f([1, 2, 2.01]) == [1,2,3]
+ assume f([1.23, 2, 2.01]) == [1,2,3]
diff --git a/tests/valid/TypeEquals_Valid_19.sysout b/tests/valid/TypeEquals_Valid_19.sysout
deleted file mode 100644
index 6eefcf8943..0000000000
--- a/tests/valid/TypeEquals_Valid_19.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-[1, 2, 3, 4, 5, 6, 7]
-[]
-[1, 2, 3]
-[1, 2, 3]
diff --git a/tests/valid/TypeEquals_Valid_19.whiley b/tests/valid/TypeEquals_Valid_19.whiley
index 569bab1b5f..1ff5c879a9 100644
--- a/tests/valid/TypeEquals_Valid_19.whiley
+++ b/tests/valid/TypeEquals_Valid_19.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([[real | int]] e) -> [int]:
if e is [[int]] && |e| > 0:
@@ -6,8 +6,8 @@ function f([[real | int]] e) -> [int]:
else:
return [1, 2, 3]
-method main(System.Console sys) -> void:
- sys.out.println(f([[1, 2, 3, 4, 5, 6, 7]]))
- sys.out.println(f([[]]))
- sys.out.println(f([[1, 2, 2.01]]))
- sys.out.println(f([[1.23, 2, 2.01]]))
+public export method test() -> void:
+ assume f([[1, 2, 3, 4, 5, 6, 7]]) == [1, 2, 3, 4, 5, 6, 7]
+ assume f([[]]) == []
+ assume f([[1, 2, 2.01]]) == [1,2,3]
+ assume f([[1.23, 2, 2.01]]) == [1,2,3]
diff --git a/tests/valid/TypeEquals_Valid_2.sysout b/tests/valid/TypeEquals_Valid_2.sysout
deleted file mode 100755
index acb9f2ec0c..0000000000
--- a/tests/valid/TypeEquals_Valid_2.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-11
--1
diff --git a/tests/valid/TypeEquals_Valid_2.whiley b/tests/valid/TypeEquals_Valid_2.whiley
index 538ee83484..ac19896fc1 100644
--- a/tests/valid/TypeEquals_Valid_2.whiley
+++ b/tests/valid/TypeEquals_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type expr is {int op, expr lhs} | {[int] err}
@@ -8,8 +8,8 @@ function f(expr e) -> int:
else:
return -1
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = f({err: "Hello World"})
- sys.out.println(x)
+ assume x == 11
x = f({op: 1, lhs: {err: "Gotcha"}})
- sys.out.println(x)
+ assume x == -1
diff --git a/tests/valid/TypeEquals_Valid_20.sysout b/tests/valid/TypeEquals_Valid_20.sysout
deleted file mode 100644
index bc832eb97d..0000000000
--- a/tests/valid/TypeEquals_Valid_20.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-1
-1
-1
--1
--1
diff --git a/tests/valid/TypeEquals_Valid_20.whiley b/tests/valid/TypeEquals_Valid_20.whiley
index ca38a113f2..588b4ca084 100644
--- a/tests/valid/TypeEquals_Valid_20.whiley
+++ b/tests/valid/TypeEquals_Valid_20.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({(int, any)} xs) -> int:
if xs is {(int, [int])}:
@@ -6,14 +6,14 @@ function f({(int, any)} xs) -> int:
else:
return -1
-method main(System.Console sys) -> void:
+public export method test() -> void:
{(int,any)} s1 = {(1, "Hello")}
{(int,any)} s2 = {(1, "Hello"), (1, "World")}
{(int,any)} s3 = {(1, "Hello"), (2, "Hello")}
{(int,any)} s4 = {(1, 1), (2, 2)}
{(int,any)} s5 = {(1, 1), (2, "Hello")}
- sys.out.println(f(s1))
- sys.out.println(f(s2))
- sys.out.println(f(s3))
- sys.out.println(f(s4))
- sys.out.println(f(s5))
+ assume f(s1) == 1
+ assume f(s2) == 1
+ assume f(s3) == 1
+ assume f(s4) == -1
+ assume f(s5) == -1
diff --git a/tests/valid/TypeEquals_Valid_21.sysout b/tests/valid/TypeEquals_Valid_21.sysout
deleted file mode 100755
index 1d474d5255..0000000000
--- a/tests/valid/TypeEquals_Valid_21.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-false
-true
diff --git a/tests/valid/TypeEquals_Valid_21.whiley b/tests/valid/TypeEquals_Valid_21.whiley
index ec8801a78b..fa3501dcf9 100644
--- a/tests/valid/TypeEquals_Valid_21.whiley
+++ b/tests/valid/TypeEquals_Valid_21.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type expr is {int} | bool
@@ -8,8 +8,8 @@ function f(expr e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e = true
- sys.out.println(f(e))
+ assume f(e) == false
e = {1, 2, 3, 4}
- sys.out.println(f(e))
+ assume f(e) == true
diff --git a/tests/valid/TypeEquals_Valid_22.sysout b/tests/valid/TypeEquals_Valid_22.sysout
deleted file mode 100644
index 3fdb5f25dc..0000000000
--- a/tests/valid/TypeEquals_Valid_22.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-1
-1
-1
-1
--1
diff --git a/tests/valid/TypeEquals_Valid_22.whiley b/tests/valid/TypeEquals_Valid_22.whiley
index 97aaec0107..d0f4b23ba5 100644
--- a/tests/valid/TypeEquals_Valid_22.whiley
+++ b/tests/valid/TypeEquals_Valid_22.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f({int=>any} xs) -> int:
if xs is {int=>[int]}:
@@ -6,14 +6,14 @@ function f({int=>any} xs) -> int:
else:
return -1
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int=>any} s1 = {0=>"Hello"}
{int=>any} s2 = {1=>"Hello"}
{int=>any} s3 = {0=>"Hello", 1=>"Hello"}
{int=>any} s4 = {0=>"Hello", 1=>"Hello", 3=>"Hello"}
- sys.out.println(f(s1))
- sys.out.println(f(s2))
- sys.out.println(f(s3))
- sys.out.println(f(s4))
+ assume f(s1) == 1
+ assume f(s2) == 1
+ assume f(s3) == 1
+ assume f(s4) == 1
{int=>int} t1 = {0=>0, 1=>1}
- sys.out.println(f(t1))
+ assume f(t1) == -1
diff --git a/tests/valid/TypeEquals_Valid_23.sysout b/tests/valid/TypeEquals_Valid_23.sysout
deleted file mode 100755
index c8d101298e..0000000000
--- a/tests/valid/TypeEquals_Valid_23.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-2
-14
diff --git a/tests/valid/TypeEquals_Valid_23.whiley b/tests/valid/TypeEquals_Valid_23.whiley
index 14357bf241..8b89799619 100644
--- a/tests/valid/TypeEquals_Valid_23.whiley
+++ b/tests/valid/TypeEquals_Valid_23.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type bop is {int y, int x} where x > 0
@@ -10,8 +10,8 @@ function f(expr e) -> int:
else:
return e + 1
-method main(System.Console sys) -> void:
+public export method test() -> void:
x = f(1)
- sys.out.println(x)
+ assume x == 2
x = f({y: 10, x: 4})
- sys.out.println(x)
+ assume x == 14
diff --git a/tests/valid/TypeEquals_Valid_24.sysout b/tests/valid/TypeEquals_Valid_24.sysout
deleted file mode 100644
index e0d60680cd..0000000000
--- a/tests/valid/TypeEquals_Valid_24.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-RESULT: 4
-RESULT: 123
diff --git a/tests/valid/TypeEquals_Valid_24.whiley b/tests/valid/TypeEquals_Valid_24.whiley
index 07f978216e..683f09f9b7 100644
--- a/tests/valid/TypeEquals_Valid_24.whiley
+++ b/tests/valid/TypeEquals_Valid_24.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type T is [int] | int
@@ -8,6 +8,6 @@ function f(T x) -> int:
else:
return x
-public method main(System.Console sys) -> void:
- sys.out.println_s("RESULT: " ++ Any.toString(f([1, 2, 3, 4])))
- sys.out.println_s("RESULT: " ++ Any.toString(f(123)))
+public export method test() -> void:
+ assume f([1, 2, 3, 4]) == 4
+ assume f(123) == 123
diff --git a/tests/valid/TypeEquals_Valid_25.sysout b/tests/valid/TypeEquals_Valid_25.sysout
deleted file mode 100644
index 9768bc5a3a..0000000000
--- a/tests/valid/TypeEquals_Valid_25.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-RESULT: 123
-RESULT: []
diff --git a/tests/valid/TypeEquals_Valid_25.whiley b/tests/valid/TypeEquals_Valid_25.whiley
index 8c12aa3752..92c499c174 100644
--- a/tests/valid/TypeEquals_Valid_25.whiley
+++ b/tests/valid/TypeEquals_Valid_25.whiley
@@ -1,12 +1,6 @@
-import whiley.lang.*
-import SyntaxError from whiley.lang.*
-
constant ADD is 0
-
constant SUB is 1
-
constant MUL is 2
-
constant DIV is 3
type BOp is (int x) where x in {ADD, SUB, MUL, DIV}
@@ -41,10 +35,9 @@ function evaluate(Expr e) -> Value:
else:
return 0
-method main(System.Console sys) -> void:
+public export method test() -> void:
Expr e = {op: ADD, rhs: 1, lhs: 123}
Value v = evaluate(e)
- sys.out.println_s("RESULT: " ++ Any.toString(v))
+ assume v == 123
e = [1]
- v = evaluate(e)
- sys.out.println_s("RESULT: " ++ Any.toString(v))
+ assume evaluate(e) == []
diff --git a/tests/valid/TypeEquals_Valid_26.sysout b/tests/valid/TypeEquals_Valid_26.sysout
deleted file mode 100644
index e0d60680cd..0000000000
--- a/tests/valid/TypeEquals_Valid_26.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-RESULT: 4
-RESULT: 123
diff --git a/tests/valid/TypeEquals_Valid_26.whiley b/tests/valid/TypeEquals_Valid_26.whiley
index cb5de46793..ffcfdb3dca 100644
--- a/tests/valid/TypeEquals_Valid_26.whiley
+++ b/tests/valid/TypeEquals_Valid_26.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type T is {int} | int
@@ -8,6 +8,6 @@ function f(T x) -> int:
else:
return x
-public method main(System.Console sys) -> void:
- sys.out.println_s("RESULT: " ++ Any.toString(f({1, 2, 3, 4})))
- sys.out.println_s("RESULT: " ++ Any.toString(f(123)))
+public export method test() -> void:
+ assume f({1, 2, 3, 4}) == 4
+ assume f(123) == 123
diff --git a/tests/valid/TypeEquals_Valid_27.sysout b/tests/valid/TypeEquals_Valid_27.sysout
deleted file mode 100644
index 5b3ac40629..0000000000
--- a/tests/valid/TypeEquals_Valid_27.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-false
-true
\ No newline at end of file
diff --git a/tests/valid/TypeEquals_Valid_27.whiley b/tests/valid/TypeEquals_Valid_27.whiley
index 58d5fcd3d7..160e54a10d 100644
--- a/tests/valid/TypeEquals_Valid_27.whiley
+++ b/tests/valid/TypeEquals_Valid_27.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Point is {int y, int x}
@@ -6,14 +6,14 @@ type Point3D is {int z, int y, int x}
type Points is Point | Point3D
-method test(Points t) -> bool:
+public export method test(Points t) -> bool:
if t is Point:
return true
else:
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
Point3D p3d = {z: 3, y: 2, x: 1}
- sys.out.println(test(p3d))
+ assume test(p3d) == false
Point p2d = {y: 2, x: 1}
- sys.out.println(test(p2d))
+ assume test(p2d) == true
diff --git a/tests/valid/TypeEquals_Valid_28.sysout b/tests/valid/TypeEquals_Valid_28.sysout
deleted file mode 100644
index 12468786d3..0000000000
--- a/tests/valid/TypeEquals_Valid_28.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-false
\ No newline at end of file
diff --git a/tests/valid/TypeEquals_Valid_28.whiley b/tests/valid/TypeEquals_Valid_28.whiley
index abd8ce09ad..c0a9ef9c4f 100644
--- a/tests/valid/TypeEquals_Valid_28.whiley
+++ b/tests/valid/TypeEquals_Valid_28.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Point is {int y, int x, ...}
@@ -6,16 +6,16 @@ type Point3D is {int z, int y, int x}
type Points is Point | Point3D
-method test(Points t) -> bool:
+public export method test(Points t) -> bool:
if t is Point3D:
return true
else:
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
Point3D p3d = {z: 3, y: 2, x: 1}
- sys.out.println(test(p3d))
+ assume test(p3d) == true
Point p2d = {y: 2, x: 1}
- sys.out.println(test(p2d))
+ assume test(p2d) == false
p2d = {w: 3, y: 2, x: 1}
- sys.out.println(test(p2d))
+ assume test(p2d) == false
diff --git a/tests/valid/TypeEquals_Valid_29.sysout b/tests/valid/TypeEquals_Valid_29.sysout
deleted file mode 100644
index 249238b157..0000000000
--- a/tests/valid/TypeEquals_Valid_29.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-
-2
-b
-c2
diff --git a/tests/valid/TypeEquals_Valid_29.whiley b/tests/valid/TypeEquals_Valid_29.whiley
index 1caeff28a6..e1a17596ee 100644
--- a/tests/valid/TypeEquals_Valid_29.whiley
+++ b/tests/valid/TypeEquals_Valid_29.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type RowCol is int
@@ -25,8 +25,8 @@ function shortPos2str(ShortPos p) -> [int]:
else:
return pos2str(p)
-public method main(System.Console sys) -> void:
- sys.out.println_s(shortPos2str(null))
- sys.out.println_s(shortPos2str({row: 1}))
- sys.out.println_s(shortPos2str({col: 1}))
- sys.out.println_s(shortPos2str({col: 2, row: 1}))
+public export method test() -> void:
+ assume shortPos2str(null) == ""
+ assume shortPos2str({row: 1}) == "2"
+ assume shortPos2str({col: 1}) == "b"
+ assume shortPos2str({col: 2, row: 1}) == "c2"
diff --git a/tests/valid/TypeEquals_Valid_3.whiley b/tests/valid/TypeEquals_Valid_3.whiley
index 540d905821..3c3ba4f89c 100644
--- a/tests/valid/TypeEquals_Valid_3.whiley
+++ b/tests/valid/TypeEquals_Valid_3.whiley
@@ -1,16 +1,16 @@
-import whiley.lang.*
+
type nat is (int n) where n >= 0
function create(nat size, nat value) -> [nat]:
- r = []
+ [int] r = []
int i = 0
while i < size where r is [nat]:
- r = r + [value]
+ r = r ++ [value]
i = i + 1
return r
-method main(System.Console sys) -> void:
- sys.out.println(create(10, 10))
- sys.out.println(create(5, 0))
- sys.out.println(create(0, 0))
+public export method test() -> void:
+ assume create(10, 10) == [10,10,10,10,10, 10,10,10,10,10]
+ assume create(5, 0) == [0,0,0,0,0]
+ assume create(0, 0) == []
diff --git a/tests/valid/TypeEquals_Valid_30.sysout b/tests/valid/TypeEquals_Valid_30.sysout
deleted file mode 100644
index 94ebaf9001..0000000000
--- a/tests/valid/TypeEquals_Valid_30.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-1
-2
-3
-4
diff --git a/tests/valid/TypeEquals_Valid_30.whiley b/tests/valid/TypeEquals_Valid_30.whiley
index 51acfad9dd..5352436464 100644
--- a/tests/valid/TypeEquals_Valid_30.whiley
+++ b/tests/valid/TypeEquals_Valid_30.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant ADD is 0
@@ -33,12 +33,12 @@ function evaluate(Expr e) -> int:
else:
return -1
-method main(System.Console sys) -> void:
+public export method test() -> void:
Expr e = 1
- sys.out.println(evaluate(e))
+ assume evaluate(e) == 1
e = {op: ADD, rhs: e, lhs: e}
- sys.out.println(evaluate(e))
+ assume evaluate(e) == 2
e = [e]
- sys.out.println(evaluate(e))
+ assume evaluate(e) == 3
e = {index: 1, src: e}
- sys.out.println(evaluate(e))
+ assume evaluate(e) == 4
diff --git a/tests/valid/TypeEquals_Valid_31.sysout b/tests/valid/TypeEquals_Valid_31.sysout
deleted file mode 100644
index 6ed281c757..0000000000
--- a/tests/valid/TypeEquals_Valid_31.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-1
diff --git a/tests/valid/TypeEquals_Valid_31.whiley b/tests/valid/TypeEquals_Valid_31.whiley
index 3eaca7afce..f34bc5c8ab 100644
--- a/tests/valid/TypeEquals_Valid_31.whiley
+++ b/tests/valid/TypeEquals_Valid_31.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type pos is (int p) where p > 0
@@ -11,8 +11,8 @@ type rec12 is rec1 | rec2
function f(rec12 x) -> int:
return 1
-public method main(System.Console console) -> void:
+public export method test() -> void:
rec1 r1 = {f1: "hello", f2: 2}
rec2 r2 = {f1: 1, f2: 0}
- console.out.println(f(r1))
- console.out.println(f(r2))
+ assume f(r1) == 1
+ assume f(r2) == 1
diff --git a/tests/valid/TypeEquals_Valid_32.sysout b/tests/valid/TypeEquals_Valid_32.sysout
deleted file mode 100755
index 86ddee9f09..0000000000
--- a/tests/valid/TypeEquals_Valid_32.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{-1, 1, 2, 3, 4}
-{}
diff --git a/tests/valid/TypeEquals_Valid_32.whiley b/tests/valid/TypeEquals_Valid_32.whiley
index f057de4f1d..92b0c20307 100644
--- a/tests/valid/TypeEquals_Valid_32.whiley
+++ b/tests/valid/TypeEquals_Valid_32.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type expr is {int} | bool
@@ -12,7 +12,7 @@ function f(expr e) -> {int}:
else:
return {}
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int} e = {1, 2, 3, 4}
- sys.out.println(f(e))
- sys.out.println(f(false))
+ assume f(e) == {-1, 1, 2, 3, 4}
+ assume f(false) == {}
diff --git a/tests/valid/TypeEquals_Valid_33.sysout b/tests/valid/TypeEquals_Valid_33.sysout
deleted file mode 100755
index dac32ecf1d..0000000000
--- a/tests/valid/TypeEquals_Valid_33.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-false
-true
-true
diff --git a/tests/valid/TypeEquals_Valid_33.whiley b/tests/valid/TypeEquals_Valid_33.whiley
index 59bc7b0ef7..ee79261afa 100644
--- a/tests/valid/TypeEquals_Valid_33.whiley
+++ b/tests/valid/TypeEquals_Valid_33.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type pos is (int p) where p > 0
@@ -12,7 +12,7 @@ function f(expr e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f(-1))
- sys.out.println(f(1))
- sys.out.println(f(1234))
+public export method test() -> void:
+ assume f(-1) == false
+ assume f(1) == true
+ assume f(1234) == true
diff --git a/tests/valid/TypeEquals_Valid_34.sysout b/tests/valid/TypeEquals_Valid_34.sysout
deleted file mode 100755
index c8d101298e..0000000000
--- a/tests/valid/TypeEquals_Valid_34.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-2
-14
diff --git a/tests/valid/TypeEquals_Valid_34.whiley b/tests/valid/TypeEquals_Valid_34.whiley
index 7ae36b17e1..d636889284 100644
--- a/tests/valid/TypeEquals_Valid_34.whiley
+++ b/tests/valid/TypeEquals_Valid_34.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type bop is {int y, int x}
@@ -10,8 +10,8 @@ function f(expr e) -> int:
else:
return e + 1
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = f(1)
- sys.out.println(x)
+ assume x == 2
x = f({y: 10, x: 4})
- sys.out.println(x)
+ assume x == 14
diff --git a/tests/valid/TypeEquals_Valid_35.sysout b/tests/valid/TypeEquals_Valid_35.sysout
deleted file mode 100755
index b979d62f4f..0000000000
--- a/tests/valid/TypeEquals_Valid_35.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-true
-true
diff --git a/tests/valid/TypeEquals_Valid_35.whiley b/tests/valid/TypeEquals_Valid_35.whiley
index a88c67873b..81172e772c 100644
--- a/tests/valid/TypeEquals_Valid_35.whiley
+++ b/tests/valid/TypeEquals_Valid_35.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type pos is int
@@ -13,7 +13,7 @@ function f(expr e) -> int:
else:
return 0
-method main(System.Console sys) -> void:
- sys.out.println(f(-1) == 0)
- sys.out.println(f(1) == 2)
- sys.out.println(f(1234) == 1235)
+public export method test() -> void:
+ assume f(-1) == 0
+ assume f(1) == 2
+ assume f(1234) == 1235
diff --git a/tests/valid/TypeEquals_Valid_36.sysout b/tests/valid/TypeEquals_Valid_36.sysout
deleted file mode 100755
index 9e8a46acf9..0000000000
--- a/tests/valid/TypeEquals_Valid_36.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-true
-false
diff --git a/tests/valid/TypeEquals_Valid_36.whiley b/tests/valid/TypeEquals_Valid_36.whiley
index 3ff7c4f348..57756a3e7d 100644
--- a/tests/valid/TypeEquals_Valid_36.whiley
+++ b/tests/valid/TypeEquals_Valid_36.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type plist is ([int] xs) where |xs| > 0 && xs[0] == 0
@@ -12,7 +12,7 @@ function f(tup t) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({p: 0, lhs: [0]}))
- sys.out.println(f({p: 0, lhs: [0, 1]}))
- sys.out.println(f({p: 0, lhs: [1, 1]}))
+public export method test() -> void:
+ assume f({p: 0, lhs: [0]}) == true
+ assume f({p: 0, lhs: [0, 1]}) == true
+ assume f({p: 0, lhs: [1, 1]}) == false
diff --git a/tests/valid/TypeEquals_Valid_37.sysout b/tests/valid/TypeEquals_Valid_37.sysout
deleted file mode 100755
index 9e8a46acf9..0000000000
--- a/tests/valid/TypeEquals_Valid_37.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-true
-false
diff --git a/tests/valid/TypeEquals_Valid_37.whiley b/tests/valid/TypeEquals_Valid_37.whiley
index 5dba874c48..aa8c96e8bf 100644
--- a/tests/valid/TypeEquals_Valid_37.whiley
+++ b/tests/valid/TypeEquals_Valid_37.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type plist is [int]
@@ -12,7 +12,7 @@ function f(tup t) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({p: 0, lhs: [0]}))
- sys.out.println(f({p: 0, lhs: [0, 1]}))
- sys.out.println(f({p: 0, lhs: [1, 1]}))
+public export method test() -> void:
+ assume f({p: 0, lhs: [0]}) == true
+ assume f({p: 0, lhs: [0, 1]}) == true
+ assume f({p: 0, lhs: [1, 1]}) == false
diff --git a/tests/valid/TypeEquals_Valid_38.sysout b/tests/valid/TypeEquals_Valid_38.sysout
deleted file mode 100755
index 36bc6136b8..0000000000
--- a/tests/valid/TypeEquals_Valid_38.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-false
diff --git a/tests/valid/TypeEquals_Valid_38.whiley b/tests/valid/TypeEquals_Valid_38.whiley
index 66c3b28a24..c2ca773b35 100644
--- a/tests/valid/TypeEquals_Valid_38.whiley
+++ b/tests/valid/TypeEquals_Valid_38.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type expr is [int] | int
@@ -10,7 +10,7 @@ function f(tup t) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f({p: 0, lhs: [0]}))
- sys.out.println(f({p: 0, lhs: [1]}))
- sys.out.println(f({p: 0, lhs: []}))
+public export method test() -> void:
+ assume f({p: 0, lhs: [0]}) == true
+ assume f({p: 0, lhs: [1]}) == false
+ assume f({p: 0, lhs: []}) == false
diff --git a/tests/valid/TypeEquals_Valid_39.sysout b/tests/valid/TypeEquals_Valid_39.sysout
deleted file mode 100755
index 4d6f0be69a..0000000000
--- a/tests/valid/TypeEquals_Valid_39.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-false
-true
-true
-false
diff --git a/tests/valid/TypeEquals_Valid_39.whiley b/tests/valid/TypeEquals_Valid_39.whiley
index 5408c9a90e..b53170155d 100644
--- a/tests/valid/TypeEquals_Valid_39.whiley
+++ b/tests/valid/TypeEquals_Valid_39.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type pos is (real r) where r > 0.0
@@ -12,8 +12,8 @@ function f(expr e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f(-1))
- sys.out.println(f(1.0))
- sys.out.println(f(1234.0))
- sys.out.println(f(-1.0))
+public export method test() -> void:
+ assume f(-1) == false
+ assume f(1.0) == true
+ assume f(1234.0) == true
+ assume f(-1.0) == false
diff --git a/tests/valid/TypeEquals_Valid_40.sysout b/tests/valid/TypeEquals_Valid_40.sysout
deleted file mode 100755
index c4d9d21e3e..0000000000
--- a/tests/valid/TypeEquals_Valid_40.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-1
-0
-0
-2
\ No newline at end of file
diff --git a/tests/valid/TypeEquals_Valid_40.whiley b/tests/valid/TypeEquals_Valid_40.whiley
index 499a820362..f155b5fca5 100644
--- a/tests/valid/TypeEquals_Valid_40.whiley
+++ b/tests/valid/TypeEquals_Valid_40.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type pos is real
@@ -15,8 +15,8 @@ function f(expr e) -> int:
else:
return 2
-method main(System.Console sys) -> void:
- sys.out.println(f(-1))
- sys.out.println(f(1.0))
- sys.out.println(f(1.234))
- sys.out.println(f([1, 2, 3]))
+public export method test() -> void:
+ assume f(-1) == 1
+ assume f(1.0) == 0
+ assume f(1.234) == 0
+ assume f([1, 2, 3]) == 2
diff --git a/tests/valid/TypeEquals_Valid_41.sysout b/tests/valid/TypeEquals_Valid_41.sysout
deleted file mode 100755
index 24fb15c2d7..0000000000
--- a/tests/valid/TypeEquals_Valid_41.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-14
diff --git a/tests/valid/TypeEquals_Valid_41.whiley b/tests/valid/TypeEquals_Valid_41.whiley
index b03a751b2f..6fc4bc8c68 100644
--- a/tests/valid/TypeEquals_Valid_41.whiley
+++ b/tests/valid/TypeEquals_Valid_41.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type bop is {int y, int x} where x > 0
@@ -10,8 +10,8 @@ function f(expr e) -> int:
else:
return e
-method main(System.Console sys) -> void:
+public export method test() -> void:
x = f(1)
- sys.out.println(x)
+ assume x == 1
x = f({y: 10, x: 4})
- sys.out.println(x)
+ assume x == 14
diff --git a/tests/valid/TypeEquals_Valid_42.sysout b/tests/valid/TypeEquals_Valid_42.sysout
deleted file mode 100755
index 24fb15c2d7..0000000000
--- a/tests/valid/TypeEquals_Valid_42.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-14
diff --git a/tests/valid/TypeEquals_Valid_42.whiley b/tests/valid/TypeEquals_Valid_42.whiley
index 14f222fd52..379f5a1a26 100644
--- a/tests/valid/TypeEquals_Valid_42.whiley
+++ b/tests/valid/TypeEquals_Valid_42.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type bop is {int y, int x}
@@ -10,8 +10,8 @@ function f(expr e) -> int:
else:
return e
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = f(1)
- sys.out.println(x)
+ assume x == 1
x = f({y: 10, x: 4})
- sys.out.println(x)
+ assume x == 14
diff --git a/tests/valid/TypeEquals_Valid_43.sysout b/tests/valid/TypeEquals_Valid_43.sysout
deleted file mode 100755
index 567b6d6ef3..0000000000
--- a/tests/valid/TypeEquals_Valid_43.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[72, 69, 76, 76, 79, 32, 87, 79, 82, 76, 68]
-1
diff --git a/tests/valid/TypeEquals_Valid_43.whiley b/tests/valid/TypeEquals_Valid_43.whiley
index 9d7b76a04a..4beb75b364 100644
--- a/tests/valid/TypeEquals_Valid_43.whiley
+++ b/tests/valid/TypeEquals_Valid_43.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type imsg is int | {[int] msg}
@@ -8,6 +8,6 @@ function getMessage(imsg m) -> any:
else:
return m
-method main(System.Console sys) -> void:
- sys.out.println(getMessage({msg: "HELLO WORLD"}))
- sys.out.println(getMessage(1))
+public export method test() -> void:
+ assume getMessage({msg: "HELLO WORLD"}) == "HELLO WORLD"
+ assume getMessage(1) == 1
diff --git a/tests/valid/TypeEquals_Valid_44.sysout b/tests/valid/TypeEquals_Valid_44.sysout
deleted file mode 100755
index 0c484d5077..0000000000
--- a/tests/valid/TypeEquals_Valid_44.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[72, 69, 76, 76, 79, 32, 87, 79, 82, 76, 68]
-1
-123
diff --git a/tests/valid/TypeEquals_Valid_44.whiley b/tests/valid/TypeEquals_Valid_44.whiley
index 64cf2afd73..0cda854dca 100644
--- a/tests/valid/TypeEquals_Valid_44.whiley
+++ b/tests/valid/TypeEquals_Valid_44.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type imsg is int | {int op} | {[int] msg}
@@ -11,7 +11,7 @@ function getMessage(imsg m) -> any:
else:
return m
-method main(System.Console sys) -> void:
- sys.out.println(getMessage({msg: "HELLO WORLD"}))
- sys.out.println(getMessage(1))
- sys.out.println(getMessage({op: 123}))
+public export method test() -> void:
+ assume getMessage({msg: "HELLO WORLD"}) == "HELLO WORLD"
+ assume getMessage(1) == 1
+ assume getMessage({op: 123}) == 123
diff --git a/tests/valid/TypeEquals_Valid_45.sysout b/tests/valid/TypeEquals_Valid_45.sysout
deleted file mode 100755
index a247b96d92..0000000000
--- a/tests/valid/TypeEquals_Valid_45.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-123
diff --git a/tests/valid/TypeEquals_Valid_45.whiley b/tests/valid/TypeEquals_Valid_45.whiley
index a7480ec7d4..a96a638951 100644
--- a/tests/valid/TypeEquals_Valid_45.whiley
+++ b/tests/valid/TypeEquals_Valid_45.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type pos is (int n) where n > 0
@@ -11,8 +11,8 @@ function f(intlist x) -> int:
return x
return 1
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = f([1, 2, 3])
- sys.out.println(x)
+ assume x == 1
x = f(123)
- sys.out.println(x)
+ assume x == 123
diff --git a/tests/valid/TypeEquals_Valid_46.sysout b/tests/valid/TypeEquals_Valid_46.sysout
deleted file mode 100755
index a247b96d92..0000000000
--- a/tests/valid/TypeEquals_Valid_46.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-1
-123
diff --git a/tests/valid/TypeEquals_Valid_46.whiley b/tests/valid/TypeEquals_Valid_46.whiley
index 50ec31fae1..ec15d7b0c6 100644
--- a/tests/valid/TypeEquals_Valid_46.whiley
+++ b/tests/valid/TypeEquals_Valid_46.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type pos is int
@@ -11,8 +11,8 @@ function f(intlist x) -> int:
return x
return 1
-method main(System.Console sys) -> void:
+public export method test() -> void:
int x = f([1, 2, 3])
- sys.out.println(x)
+ assume x == 1
x = f(123)
- sys.out.println(x)
+ assume x == 123
diff --git a/tests/valid/TypeEquals_Valid_47.sysout b/tests/valid/TypeEquals_Valid_47.sysout
deleted file mode 100644
index ae743d6580..0000000000
--- a/tests/valid/TypeEquals_Valid_47.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-0
--1
-0
diff --git a/tests/valid/TypeEquals_Valid_47.whiley b/tests/valid/TypeEquals_Valid_47.whiley
index 50f4723559..f37bc50d06 100644
--- a/tests/valid/TypeEquals_Valid_47.whiley
+++ b/tests/valid/TypeEquals_Valid_47.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int n) where n >= 0
@@ -10,7 +10,7 @@ function f(T x) -> int:
else:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(-1))
- sys.out.println(f([1, 2, 3]))
+public export method test() -> void:
+ assume f(1) == 0
+ assume f(-1) == -1
+ assume f([1, 2, 3]) == 0
diff --git a/tests/valid/TypeEquals_Valid_5.sysout b/tests/valid/TypeEquals_Valid_5.sysout
deleted file mode 100755
index da29283aaa..0000000000
--- a/tests/valid/TypeEquals_Valid_5.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
diff --git a/tests/valid/TypeEquals_Valid_5.whiley b/tests/valid/TypeEquals_Valid_5.whiley
index abd5985478..9e38532565 100644
--- a/tests/valid/TypeEquals_Valid_5.whiley
+++ b/tests/valid/TypeEquals_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int | null x) -> bool:
if x is null:
@@ -6,7 +6,7 @@ function f(int | null x) -> bool:
else:
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
int|null x = null
- sys.out.println(f(x))
- sys.out.println(f(1))
+ assume f(x) == true
+ assume f(1) == false
diff --git a/tests/valid/TypeEquals_Valid_6.sysout b/tests/valid/TypeEquals_Valid_6.sysout
deleted file mode 100755
index da29283aaa..0000000000
--- a/tests/valid/TypeEquals_Valid_6.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-true
-false
diff --git a/tests/valid/TypeEquals_Valid_6.whiley b/tests/valid/TypeEquals_Valid_6.whiley
index b5790f4c2d..b5f8ab987b 100644
--- a/tests/valid/TypeEquals_Valid_6.whiley
+++ b/tests/valid/TypeEquals_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type SyntaxError is {[int] msg}
@@ -18,6 +18,6 @@ function f(int x) -> bool:
function syntaxError([int] errorMessage) -> SyntaxError:
return {msg: errorMessage}
-method main(System.Console sys) -> void:
- sys.out.println(f(0))
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f(0) == true
+ assume f(1) == false
diff --git a/tests/valid/TypeEquals_Valid_7.sysout b/tests/valid/TypeEquals_Valid_7.sysout
deleted file mode 100755
index 36bc6136b8..0000000000
--- a/tests/valid/TypeEquals_Valid_7.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-false
diff --git a/tests/valid/TypeEquals_Valid_7.whiley b/tests/valid/TypeEquals_Valid_7.whiley
index 3d6af61f80..c06c260192 100644
--- a/tests/valid/TypeEquals_Valid_7.whiley
+++ b/tests/valid/TypeEquals_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type intreal is real | int
@@ -8,7 +8,7 @@ function f(intreal e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f(1.134))
- sys.out.println(f(1.0))
+public export method test() -> void:
+ assume f(1) == true
+ assume f(1.134) == false
+ assume f(1.0) == false
diff --git a/tests/valid/TypeEquals_Valid_8.sysout b/tests/valid/TypeEquals_Valid_8.sysout
deleted file mode 100755
index dac32ecf1d..0000000000
--- a/tests/valid/TypeEquals_Valid_8.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-false
-true
-true
diff --git a/tests/valid/TypeEquals_Valid_8.whiley b/tests/valid/TypeEquals_Valid_8.whiley
index 4a4a9732c6..6aedc521e2 100644
--- a/tests/valid/TypeEquals_Valid_8.whiley
+++ b/tests/valid/TypeEquals_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type ilist is int | [int]
@@ -13,7 +13,10 @@ function f(rlist e) -> bool:
function g(ilist e) -> bool:
return f((rlist) e)
-method main(System.Console sys) -> void:
- sys.out.println(f(1.0))
- sys.out.println(f([1]))
- sys.out.println(f([]))
+public export method test() -> void:
+ assume f(1.0) == false
+ assume f([1]) == true
+ assume f([]) == true
+ assume g(1) == false
+ assume g([1]) == true
+ assume g([]) == true
diff --git a/tests/valid/TypeEquals_Valid_9.sysout b/tests/valid/TypeEquals_Valid_9.sysout
deleted file mode 100755
index 1d474d5255..0000000000
--- a/tests/valid/TypeEquals_Valid_9.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-false
-true
diff --git a/tests/valid/TypeEquals_Valid_9.whiley b/tests/valid/TypeEquals_Valid_9.whiley
index 0ad4f91667..234dd432d2 100644
--- a/tests/valid/TypeEquals_Valid_9.whiley
+++ b/tests/valid/TypeEquals_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type expr is [int] | int
@@ -8,8 +8,8 @@ function f(expr e) -> bool:
else:
return false
-method main(System.Console sys) -> void:
+public export method test() -> void:
expr e = 1
- sys.out.println(f(e))
+ assume f(e) == false
e = [1, 2, 3, 4]
- sys.out.println(f(e))
+ assume f(e) == true
diff --git a/tests/valid/UnionType_Valid_1.sysout b/tests/valid/UnionType_Valid_1.sysout
deleted file mode 100755
index b5d8bb58d9..0000000000
--- a/tests/valid/UnionType_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3]
diff --git a/tests/valid/UnionType_Valid_1.whiley b/tests/valid/UnionType_Valid_1.whiley
index bb48d7cf12..7a9cf38c42 100644
--- a/tests/valid/UnionType_Valid_1.whiley
+++ b/tests/valid/UnionType_Valid_1.whiley
@@ -1,11 +1,11 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
int|[int] x
//
- if |sys.args| == 1:
+ if 0 == 1:
x = 1
else:
x = [1, 2, 3]
//
- sys.out.println(x)
+ assume x == [1,2,3]
diff --git a/tests/valid/UnionType_Valid_10.sysout b/tests/valid/UnionType_Valid_10.sysout
deleted file mode 100755
index 51afd968e2..0000000000
--- a/tests/valid/UnionType_Valid_10.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{data:[],op:11}
diff --git a/tests/valid/UnionType_Valid_10.whiley b/tests/valid/UnionType_Valid_10.whiley
index 656d3b183e..3da645da46 100644
--- a/tests/valid/UnionType_Valid_10.whiley
+++ b/tests/valid/UnionType_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type tenup is int
@@ -11,6 +11,6 @@ type msgType is msg1 | msg2
function f(msgType m) -> msgType:
return m
-method main(System.Console sys) -> void:
+public export method test() -> void:
msg1 x = {op: 11, data: []}
- sys.out.println(f(x))
+ assume f(x) == {op: 11, data: []}
diff --git a/tests/valid/UnionType_Valid_11.sysout b/tests/valid/UnionType_Valid_11.sysout
deleted file mode 100755
index 15d21534c3..0000000000
--- a/tests/valid/UnionType_Valid_11.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{data:[],op:11}
-{index:1}
diff --git a/tests/valid/UnionType_Valid_11.whiley b/tests/valid/UnionType_Valid_11.whiley
index 431b15a1b6..c9d29dda49 100644
--- a/tests/valid/UnionType_Valid_11.whiley
+++ b/tests/valid/UnionType_Valid_11.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type tenup is (int x) where x > 10
@@ -11,8 +11,8 @@ type msgType is msg1 | msg2
function f(msgType m) -> msgType:
return m
-method main(System.Console sys) -> void:
+public export method test() -> void:
msg1 m1 = {op: 11, data: []}
msg2 m2 = {index: 1}
- sys.out.println(f(m1))
- sys.out.println(f(m2))
+ assume f(m1) == {op: 11, data: []}
+ assume f(m2) == {index: 1}
diff --git a/tests/valid/UnionType_Valid_12.sysout b/tests/valid/UnionType_Valid_12.sysout
deleted file mode 100755
index 4b06ffa290..0000000000
--- a/tests/valid/UnionType_Valid_12.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{op:1,rest:[1.23]}
-{mode:0,op:123}
diff --git a/tests/valid/UnionType_Valid_12.whiley b/tests/valid/UnionType_Valid_12.whiley
index 29507d7394..a59363a48d 100644
--- a/tests/valid/UnionType_Valid_12.whiley
+++ b/tests/valid/UnionType_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type IntList is {int op, [real] rest} | {int op, int mode}
@@ -8,8 +8,8 @@ function f(IntList y) -> IntList:
function g({int op, int mode} z) -> IntList:
return z
-method main(System.Console sys) -> void:
+public export method test() -> void:
IntList x = {op: 1, rest: [1.23]}
- sys.out.println(f(x))
+ assume f(x) == {op: 1, rest: [1.23]}
x = {op: 123, mode: 0}
- sys.out.println(g(x))
+ assume g(x) == {op: 123, mode: 0}
diff --git a/tests/valid/UnionType_Valid_13.sysout b/tests/valid/UnionType_Valid_13.sysout
deleted file mode 100755
index 15d21534c3..0000000000
--- a/tests/valid/UnionType_Valid_13.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{data:[],op:11}
-{index:1}
diff --git a/tests/valid/UnionType_Valid_13.whiley b/tests/valid/UnionType_Valid_13.whiley
index 1d5a37ed9e..4d4494e915 100644
--- a/tests/valid/UnionType_Valid_13.whiley
+++ b/tests/valid/UnionType_Valid_13.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type tenup is int
@@ -11,8 +11,8 @@ type msgType is msg1 | msg2
function f(msgType m) -> msgType:
return m
-method main(System.Console sys) -> void:
+public export method test() -> void:
msg1 m1 = {op: 11, data: []}
msg2 m2 = {index: 1}
- sys.out.println(f(m1))
- sys.out.println(f(m2))
+ assume f(m1) == {op: 11, data: []}
+ assume f(m2) == {index: 1}
diff --git a/tests/valid/UnionType_Valid_14.sysout b/tests/valid/UnionType_Valid_14.sysout
deleted file mode 100644
index 39a859353d..0000000000
--- a/tests/valid/UnionType_Valid_14.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-3
-1
diff --git a/tests/valid/UnionType_Valid_14.whiley b/tests/valid/UnionType_Valid_14.whiley
index 012a0a42b3..5607733776 100644
--- a/tests/valid/UnionType_Valid_14.whiley
+++ b/tests/valid/UnionType_Valid_14.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
constant ADD is 0
@@ -25,7 +25,7 @@ function f(Expr e) -> int:
else:
return 1
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
- sys.out.println(f([1, 2, 3]))
- sys.out.println(f({op: ADD, rhs: 2, lhs: 1}))
+public export method test() -> void:
+ assume f(1) == 1
+ assume f([1, 2, 3]) == 3
+ assume f({op: ADD, rhs: 2, lhs: 1}) == 1
diff --git a/tests/valid/UnionType_Valid_15.sysout b/tests/valid/UnionType_Valid_15.sysout
deleted file mode 100755
index 85abe18779..0000000000
--- a/tests/valid/UnionType_Valid_15.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{data:[1, 2, 3],op:1}
-[1, 2, 3]
diff --git a/tests/valid/UnionType_Valid_15.whiley b/tests/valid/UnionType_Valid_15.whiley
index ba3a3767a0..fcfe79e501 100644
--- a/tests/valid/UnionType_Valid_15.whiley
+++ b/tests/valid/UnionType_Valid_15.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type msg1 is {int op, [int] data}
@@ -9,8 +9,8 @@ type msgType is msg1 | msg2
function f(msgType m) -> msgType:
return m
-method main(System.Console sys) -> void:
+public export method test() -> void:
msg1 x = {op: 1, data: [1, 2, 3]}
- sys.out.println(f(x))
+ assume f(x) == {op: 1, data: [1, 2, 3]}
[int] list = x.data
- sys.out.println(list)
+ assume list == [1,2,3]
diff --git a/tests/valid/UnionType_Valid_16.sysout b/tests/valid/UnionType_Valid_16.sysout
deleted file mode 100755
index 803f727992..0000000000
--- a/tests/valid/UnionType_Valid_16.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-{op:1}
-{op:[1, 2, 3]}
diff --git a/tests/valid/UnionType_Valid_16.whiley b/tests/valid/UnionType_Valid_16.whiley
index 1bc6f5497b..224f632218 100644
--- a/tests/valid/UnionType_Valid_16.whiley
+++ b/tests/valid/UnionType_Valid_16.whiley
@@ -1,11 +1,11 @@
-import whiley.lang.*
+
type IntList is {int | [int] op}
-method main(System.Console sys) -> void:
- IntList x = {op: 1}
+public export method test() -> void:
+ IntList x = {op: 2}
x.op = 1
IntList y = x
- sys.out.println(y)
+ assume y == {op: 1}
x = {op: [1, 2, 3]}
- sys.out.println(x)
+ assume x == {op: [1,2,3]}
diff --git a/tests/valid/UnionType_Valid_17.sysout b/tests/valid/UnionType_Valid_17.sysout
deleted file mode 100755
index 70ebc37ab9..0000000000
--- a/tests/valid/UnionType_Valid_17.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-123
-[1, 2, 3]
diff --git a/tests/valid/UnionType_Valid_17.whiley b/tests/valid/UnionType_Valid_17.whiley
index 59030af7b1..ad41b61c64 100644
--- a/tests/valid/UnionType_Valid_17.whiley
+++ b/tests/valid/UnionType_Valid_17.whiley
@@ -1,15 +1,15 @@
-import whiley.lang.*
+
type IntList is int | [int]
-method f(System.Console sys, int y) -> void:
- sys.out.println(y)
+method f(int y) -> int:
+ return y
-method g(System.Console sys, [int] z) -> void:
- sys.out.println(z)
+method g([int] z) -> [int]:
+ return z
-method main(System.Console sys) -> void:
+public export method test() -> void:
IntList x = 123
- f(sys, x)
+ assume f(x) == 123
x = [1, 2, 3]
- g(sys, x)
+ assume g(x) == [1,2,3]
diff --git a/tests/valid/UnionType_Valid_18.sysout b/tests/valid/UnionType_Valid_18.sysout
deleted file mode 100755
index cef1acf32b..0000000000
--- a/tests/valid/UnionType_Valid_18.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{il:1,op:1}
diff --git a/tests/valid/UnionType_Valid_18.whiley b/tests/valid/UnionType_Valid_18.whiley
index affa3aa2c4..31b1274fcb 100644
--- a/tests/valid/UnionType_Valid_18.whiley
+++ b/tests/valid/UnionType_Valid_18.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type utr12nat is (int x) where x >= 0
@@ -11,7 +11,6 @@ ensures result >= 0:
//
return y.op
-method main(System.Console sys) -> void:
+public export method test() -> void:
tupper x = {op: 1, il: 1}
- sys.out.println(x)
- f(x)
+ assume f(x) == 1
diff --git a/tests/valid/UnionType_Valid_19.sysout b/tests/valid/UnionType_Valid_19.sysout
deleted file mode 100755
index cef1acf32b..0000000000
--- a/tests/valid/UnionType_Valid_19.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{il:1,op:1}
diff --git a/tests/valid/UnionType_Valid_19.whiley b/tests/valid/UnionType_Valid_19.whiley
index acd6305165..9acef6988c 100644
--- a/tests/valid/UnionType_Valid_19.whiley
+++ b/tests/valid/UnionType_Valid_19.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type utr12nat is int
@@ -9,7 +9,6 @@ type tupper is {int op, intList il}
function f(tupper y) -> int:
return y.op
-method main(System.Console sys) -> void:
+public export method test() -> void:
tupper x = {op: 1, il: 1}
- sys.out.println(x)
- f(x)
+ assume f(x) == 1
diff --git a/tests/valid/UnionType_Valid_2.sysout b/tests/valid/UnionType_Valid_2.sysout
deleted file mode 100755
index b54e885235..0000000000
--- a/tests/valid/UnionType_Valid_2.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-6.0
-unknown expression encountered
diff --git a/tests/valid/UnionType_Valid_2.whiley b/tests/valid/UnionType_Valid_2.whiley
index 0fa604e488..e39c137556 100644
--- a/tests/valid/UnionType_Valid_2.whiley
+++ b/tests/valid/UnionType_Valid_2.whiley
@@ -1,32 +1,29 @@
-import whiley.lang.*
-
type State is {[int] input, int pos} where pos >= 0
-
type Expr is real | {[int] id}
-
type SyntaxError is {[int] err}
-
type SExpr is SyntaxError | Expr
+// Define the 8bit ASCII character
+public type char is (int x) where 0 <= x && x <= 255
+
+public function isDigit(char c) -> bool:
+ return '0' <= c && c <= '9'
function parseTerm(State st) -> (SExpr, State):
if st.pos < |st.input|:
- if ASCII.isDigit(st.input[st.pos]):
+ if isDigit(st.input[st.pos]):
return parseNumber(st)
return ({err: "unknown expression encountered"}, st)
function parseNumber(State st) -> (Expr, State):
int n = 0
- while st.pos < |st.input| && ASCII.isDigit(st.input[st.pos]) where st.pos >= 0:
+ while st.pos < |st.input| && isDigit(st.input[st.pos]) where st.pos >= 0:
n = n + (int) (st.input[st.pos] - '0')
st.pos = st.pos + 1
return ((real) n), st
-method main(System.Console sys) -> void:
+public export method test() -> void:
SExpr e, State s = parseTerm({input: "123", pos: 0})
- sys.out.println(e)
+ assume e == 6.0
e, s = parseTerm({input: "abc", pos: 0})
//
- if e is SyntaxError:
- sys.out.println_s(e.err)
- else:
- sys.out.println(e)
+ assume e is SyntaxError
diff --git a/tests/valid/UnionType_Valid_20.sysout b/tests/valid/UnionType_Valid_20.sysout
deleted file mode 100755
index 6527dd2280..0000000000
--- a/tests/valid/UnionType_Valid_20.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{index:1,op:0}
diff --git a/tests/valid/UnionType_Valid_20.whiley b/tests/valid/UnionType_Valid_20.whiley
index cc8b80372b..91cf32ad76 100644
--- a/tests/valid/UnionType_Valid_20.whiley
+++ b/tests/valid/UnionType_Valid_20.whiley
@@ -1,20 +1,18 @@
-import whiley.lang.*
-
+type i16 is (int x) where -32768 <= x && x <= 32767
type immStoreCode is (int x) where x in {0, 1, 2}
-
type storeCode is (int x) where x in {0, 1, 2, 3, 4, 5}
type STORE is {int index, storeCode op}
type branchCode is (int x) where x in {6, 7, 8}
-type BRANCH is {branchCode op, Int.i16 offset}
+type BRANCH is {branchCode op, i16 offset}
type byteCode is STORE | BRANCH
function f(byteCode b) -> byteCode:
return b
-method main(System.Console sys) -> void:
+public export method test() -> void:
STORE b = {index: 1, op: 0}
- sys.out.println(f(b))
+ assume f(b) == {index: 1, op: 0}
diff --git a/tests/valid/UnionType_Valid_21.sysout b/tests/valid/UnionType_Valid_21.sysout
deleted file mode 100755
index 573541ac97..0000000000
--- a/tests/valid/UnionType_Valid_21.sysout
+++ /dev/null
@@ -1 +0,0 @@
-0
diff --git a/tests/valid/UnionType_Valid_21.whiley b/tests/valid/UnionType_Valid_21.whiley
index bb329ab76d..9962556591 100644
--- a/tests/valid/UnionType_Valid_21.whiley
+++ b/tests/valid/UnionType_Valid_21.whiley
@@ -1,6 +1,4 @@
-import whiley.lang.*
-import nat from whiley.lang.Int
-
+type nat is (int x) where x >= 0
type nlist is nat | [int]
function f(int x) -> nlist:
@@ -9,6 +7,6 @@ function f(int x) -> nlist:
else:
return f(x - 1)
-method main(System.Console sys) -> void:
+public export method test() -> void:
nlist x = f(2)
- sys.out.println(x)
+ assume x == 0
diff --git a/tests/valid/UnionType_Valid_22.sysout b/tests/valid/UnionType_Valid_22.sysout
deleted file mode 100755
index b8626c4cff..0000000000
--- a/tests/valid/UnionType_Valid_22.sysout
+++ /dev/null
@@ -1 +0,0 @@
-4
diff --git a/tests/valid/UnionType_Valid_22.whiley b/tests/valid/UnionType_Valid_22.whiley
index eff6f74044..1e139e552c 100644
--- a/tests/valid/UnionType_Valid_22.whiley
+++ b/tests/valid/UnionType_Valid_22.whiley
@@ -1,6 +1,4 @@
-import whiley.lang.*
-import nat from whiley.lang.Int
-
+type nat is (int x) where x >= 0
type nlist is int | [nat]
function f(int i, [nlist] xs) -> nlist:
@@ -9,6 +7,6 @@ function f(int i, [nlist] xs) -> nlist:
else:
return xs[i]
-method main(System.Console sys) -> void:
+public export method test() -> void:
nlist x = f(2, [2, 3, 4])
- sys.out.println(x)
+ assume x == 4
diff --git a/tests/valid/UnionType_Valid_23.sysout b/tests/valid/UnionType_Valid_23.sysout
deleted file mode 100755
index b780223d3f..0000000000
--- a/tests/valid/UnionType_Valid_23.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{op:123,rest:[1.23]}
diff --git a/tests/valid/UnionType_Valid_23.whiley b/tests/valid/UnionType_Valid_23.whiley
index a762ad4a32..a9b88f0a5d 100644
--- a/tests/valid/UnionType_Valid_23.whiley
+++ b/tests/valid/UnionType_Valid_23.whiley
@@ -1,13 +1,13 @@
-import whiley.lang.*
+
type IntList is {int op, [real] rest} | {int op, int mode}
function f(IntList y) -> IntList:
return y
-method main(System.Console sys) -> void:
+public export method test() -> void:
{int|real op, [real] rest} x = {op: 1, rest: [1.23]}
- if |sys.args| == 10:
+ if 0 == 10:
x = {op: 1.23, rest: [1.0]}
x.op = 123
- sys.out.println(f(x))
+ assume f(x) == {op: 123, rest: [1.23]}
diff --git a/tests/valid/UnionType_Valid_3.sysout b/tests/valid/UnionType_Valid_3.sysout
deleted file mode 100644
index 12decc137a..0000000000
--- a/tests/valid/UnionType_Valid_3.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-0
-3
diff --git a/tests/valid/UnionType_Valid_3.whiley b/tests/valid/UnionType_Valid_3.whiley
index 560e4cd696..21a33b2884 100644
--- a/tests/valid/UnionType_Valid_3.whiley
+++ b/tests/valid/UnionType_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type TYPE is null | int
@@ -10,6 +10,6 @@ function f([TYPE] xs, TYPE p) -> int:
r = r + 1
return -1
-method main(System.Console sys) -> void:
- sys.out.println(f([null, 1, 2], null))
- sys.out.println(f([1, 2, null, 10], 10))
+public export method test() -> void:
+ assume f([null, 1, 2], null) == 0
+ assume f([1, 2, null, 10], 10) == 3
diff --git a/tests/valid/UnionType_Valid_4.sysout b/tests/valid/UnionType_Valid_4.sysout
deleted file mode 100755
index fd1bf6d7ea..0000000000
--- a/tests/valid/UnionType_Valid_4.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-123
-1.234
diff --git a/tests/valid/UnionType_Valid_4.whiley b/tests/valid/UnionType_Valid_4.whiley
index f0cd6e171a..4c0f3c5ccc 100644
--- a/tests/valid/UnionType_Valid_4.whiley
+++ b/tests/valid/UnionType_Valid_4.whiley
@@ -1,12 +1,12 @@
-import whiley.lang.*
+
type IntReal is int | real
function f(IntReal y) -> IntReal:
return y
-method main(System.Console sys) -> void:
+public export method test() -> void:
IntReal x = 123
- sys.out.println(f(x))
+ assume f(x) == 123
x = 1.234
- sys.out.println(f(x))
+ assume f(x) == 1.234
diff --git a/tests/valid/UnionType_Valid_5.sysout b/tests/valid/UnionType_Valid_5.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/UnionType_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/UnionType_Valid_5.whiley b/tests/valid/UnionType_Valid_5.whiley
index 23c109ee4f..852843455b 100644
--- a/tests/valid/UnionType_Valid_5.whiley
+++ b/tests/valid/UnionType_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type ur4nat is (int x) where x > 0
@@ -9,5 +9,5 @@ type wur4nat is ur4nat | tur4nat
function f(wur4nat x) -> any:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f(1) == 1
diff --git a/tests/valid/UnionType_Valid_6.sysout b/tests/valid/UnionType_Valid_6.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/UnionType_Valid_6.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/UnionType_Valid_6.whiley b/tests/valid/UnionType_Valid_6.whiley
index a8e13b9197..a1f4eaae75 100644
--- a/tests/valid/UnionType_Valid_6.whiley
+++ b/tests/valid/UnionType_Valid_6.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type ur4nat is int
@@ -9,5 +9,5 @@ type wur4nat is ur4nat | tur4nat
function f(wur4nat x) -> any:
return x
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f(1) == 1
diff --git a/tests/valid/UnionType_Valid_7.sysout b/tests/valid/UnionType_Valid_7.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/UnionType_Valid_7.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/UnionType_Valid_7.whiley b/tests/valid/UnionType_Valid_7.whiley
index f12f042ca7..2186a23a25 100644
--- a/tests/valid/UnionType_Valid_7.whiley
+++ b/tests/valid/UnionType_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type msgType1 is {int op, [int] payload} where op == 1
@@ -9,5 +9,5 @@ type msgType is msgType1 | msgType2
function f(msgType msg) -> any:
return msg.op
-method main(System.Console sys) -> void:
- sys.out.println(f({op: 1, payload: [1, 2, 3]}))
+public export method test() -> void:
+ assume f({op: 1, payload: [1, 2, 3]}) == 1
diff --git a/tests/valid/UnionType_Valid_8.sysout b/tests/valid/UnionType_Valid_8.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/UnionType_Valid_8.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/UnionType_Valid_8.whiley b/tests/valid/UnionType_Valid_8.whiley
index 91fe6f2a00..1fdde4095a 100644
--- a/tests/valid/UnionType_Valid_8.whiley
+++ b/tests/valid/UnionType_Valid_8.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type msgType1 is {int op, [int] payload}
@@ -9,5 +9,5 @@ type msgType is msgType1 | msgType2
function f(msgType msg) -> any:
return msg.op
-method main(System.Console sys) -> void:
- sys.out.println(f({op: 1, payload: [1, 2, 3]}))
+public export method test() -> void:
+ assume f({op: 1, payload: [1, 2, 3]}) == 1
diff --git a/tests/valid/UnionType_Valid_9.sysout b/tests/valid/UnionType_Valid_9.sysout
deleted file mode 100755
index 51afd968e2..0000000000
--- a/tests/valid/UnionType_Valid_9.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{data:[],op:11}
diff --git a/tests/valid/UnionType_Valid_9.whiley b/tests/valid/UnionType_Valid_9.whiley
index 1d470e28d6..164925116b 100644
--- a/tests/valid/UnionType_Valid_9.whiley
+++ b/tests/valid/UnionType_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type tenup is (int x) where x > 10
@@ -11,6 +11,6 @@ type msgType is msg1 | msg2
function f(msgType m) -> any:
return m
-method main(System.Console sys) -> void:
+public export method test() -> void:
msg1 x = {op: 11, data: []}
- sys.out.println(f(x))
+ assume f(x) == {op: 11, data: []}
diff --git a/tests/valid/Update_Valid_1.whiley b/tests/valid/Update_Valid_1.whiley
index 1db0061ab2..9892fd1dab 100644
--- a/tests/valid/Update_Valid_1.whiley
+++ b/tests/valid/Update_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type listdict is [int] | {int=>int}
@@ -6,10 +6,10 @@ function update(listdict l, int index, int value) -> listdict:
l[index] = value
return l
-method main(System.Console sys) -> void:
+public export method test() -> void:
l = [1, 2, 3]
- sys.out.println(update(l, 1, 0))
- sys.out.println(update(l, 2, 0))
+ assume update(l, 1, 0) == [1,0,3]
+ assume update(l, 2, 0) == [1,2,0]
l = {1=>1, 2=>2, 3=>3}
- sys.out.println(update(l, 1, 0))
- sys.out.println(update(l, 2, 0))
+ assume update(l, 1, 0) == {1=>0, 2=>2, 3=>3}
+ assume update(l, 2, 0) == {1=>10, 2=>0, 3=>3}
diff --git a/tests/valid/Update_Valid_2.whiley b/tests/valid/Update_Valid_2.whiley
index 53c3b3e981..431df27a7b 100644
--- a/tests/valid/Update_Valid_2.whiley
+++ b/tests/valid/Update_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type list is [int]
@@ -6,10 +6,10 @@ function update(list l, int index, int value) -> list:
l[index] = value
return l
-method main(System.Console sys) -> void:
- l = ['1', '2', '3']
- sys.out.println(update(l, 1, 0))
- sys.out.println(update(l, 2, 0))
+public export method test() -> void:
+ [int] l = ['1', '2', '3']
+ assume update(l, 1, 0) == ['1',0,'3']
+ assume update(l, 2, 0) == ['1','2',0]
l = "Hello World"
- sys.out.println(update(l, 1, 0))
- sys.out.println(update(l, 2, 0))
+ assume update(l, 1, 0) == ['H',0,'l','l','o',' ','W','o','r','l','d']
+ assume update(l, 2, 0) == ['H','e',0,'l','o',' ','W','o','r','l','d']
diff --git a/tests/valid/VarDecl_Valid_1.sysout b/tests/valid/VarDecl_Valid_1.sysout
deleted file mode 100755
index d00491fd7e..0000000000
--- a/tests/valid/VarDecl_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/tests/valid/VarDecl_Valid_1.whiley b/tests/valid/VarDecl_Valid_1.whiley
index 6bab7c066b..46aed6b842 100644
--- a/tests/valid/VarDecl_Valid_1.whiley
+++ b/tests/valid/VarDecl_Valid_1.whiley
@@ -1,5 +1,5 @@
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+public export method test() -> void:
int x = 1
- sys.out.println(x)
+ assert x == 1
diff --git a/tests/valid/VarDecl_Valid_2.sysout b/tests/valid/VarDecl_Valid_2.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/VarDecl_Valid_2.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/VarDecl_Valid_2.whiley b/tests/valid/VarDecl_Valid_2.whiley
index ad4c7cd7b1..6bd5f9a245 100644
--- a/tests/valid/VarDecl_Valid_2.whiley
+++ b/tests/valid/VarDecl_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function g(int z) -> int
requires z > 1:
@@ -9,5 +9,5 @@ requires x > 0:
int y = x + 1
return g(y)
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f(1) == 2
diff --git a/tests/valid/VarDecl_Valid_3.sysout b/tests/valid/VarDecl_Valid_3.sysout
deleted file mode 100755
index 0cfbf08886..0000000000
--- a/tests/valid/VarDecl_Valid_3.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/VarDecl_Valid_3.whiley b/tests/valid/VarDecl_Valid_3.whiley
index 69ae775a69..6cf673dd10 100644
--- a/tests/valid/VarDecl_Valid_3.whiley
+++ b/tests/valid/VarDecl_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function g(int z) -> int:
return z
@@ -7,5 +7,5 @@ function f(int x) -> int:
int y = x + 1
return g(y)
-method main(System.Console sys) -> void:
- sys.out.println(f(1))
+public export method test() -> void:
+ assume f(1) == 2
diff --git a/tests/valid/VarDecl_Valid_4.sysout b/tests/valid/VarDecl_Valid_4.sysout
deleted file mode 100644
index b4c7f3c5e5..0000000000
--- a/tests/valid/VarDecl_Valid_4.sysout
+++ /dev/null
@@ -1 +0,0 @@
-GOT: 12478623847120981
diff --git a/tests/valid/VarDecl_Valid_4.whiley b/tests/valid/VarDecl_Valid_4.whiley
index 63b1fd494c..0b716d1896 100644
--- a/tests/valid/VarDecl_Valid_4.whiley
+++ b/tests/valid/VarDecl_Valid_4.whiley
@@ -1,8 +1,8 @@
-import whiley.lang.*
+
function constantPool() -> int:
return 12478623847120981
-method main(System.Console sys) -> void:
+public export method test() -> void:
int pool = constantPool()
- sys.out.println_s("GOT: " ++ Any.toString(pool))
+ assume pool == 12478623847120981
diff --git a/tests/valid/While_Valid_1.sysout b/tests/valid/While_Valid_1.sysout
deleted file mode 100755
index a3691af677..0000000000
--- a/tests/valid/While_Valid_1.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[5, 4, 3, 2, 1]
diff --git a/tests/valid/While_Valid_1.whiley b/tests/valid/While_Valid_1.whiley
index 4b33057700..b36fde1fba 100644
--- a/tests/valid/While_Valid_1.whiley
+++ b/tests/valid/While_Valid_1.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function reverse([int] ls) -> [int]:
int i = |ls|
@@ -8,6 +8,6 @@ function reverse([int] ls) -> [int]:
r = r ++ [ls[i]]
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] rs = reverse([1, 2, 3, 4, 5])
- sys.out.println(rs)
+ assume rs == [5,4,3,2,1]
diff --git a/tests/valid/While_Valid_10.sysout b/tests/valid/While_Valid_10.sysout
deleted file mode 100755
index a7670d7623..0000000000
--- a/tests/valid/While_Valid_10.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[1, 1, 1, 1, 1, 1, 1, 1]
-[1]
diff --git a/tests/valid/While_Valid_10.whiley b/tests/valid/While_Valid_10.whiley
index 4262742f3b..8581c0308b 100644
--- a/tests/valid/While_Valid_10.whiley
+++ b/tests/valid/While_Valid_10.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function extract([int] ls) -> [int]:
int i = 0
@@ -8,8 +8,8 @@ function extract([int] ls) -> [int]:
i = i + 1
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] rs = extract([1, 2, 3, 4, 5, 6, 7])
- sys.out.println(rs)
+ assume rs == [1, 1, 1, 1, 1, 1, 1, 1]
rs = extract([])
- sys.out.println(rs)
+ assume rs == [1]
diff --git a/tests/valid/While_Valid_11.sysout b/tests/valid/While_Valid_11.sysout
deleted file mode 100755
index 127b467618..0000000000
--- a/tests/valid/While_Valid_11.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[1, 2, 3, 4, 5, 6, 7, 23987, 23897, 0, 1, 1, 2389]
-[]
diff --git a/tests/valid/While_Valid_11.whiley b/tests/valid/While_Valid_11.whiley
index 4b3a81f8b5..a6be4b15f6 100644
--- a/tests/valid/While_Valid_11.whiley
+++ b/tests/valid/While_Valid_11.whiley
@@ -1,5 +1,4 @@
-import whiley.lang.*
-import * from whiley.lang.Int
+type nat is (int x) where x >= 0
function extract([int] ls) -> [nat]:
int i = 0
@@ -12,8 +11,8 @@ function extract([int] ls) -> [nat]:
i = i + 1
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] rs = extract([-1, 2, 3, -4, 5, 6, 7, 23987, -23897, 0, -1, 1, -2389])
- sys.out.println(rs)
+ assume rs == [1, 2, 3, 4, 5, 6, 7, 23987, 23897, 0, 1, 1, 2389]
rs = extract([])
- sys.out.println(rs)
+ assume rs == []
diff --git a/tests/valid/While_Valid_12.sysout b/tests/valid/While_Valid_12.sysout
deleted file mode 100644
index d2b2f75661..0000000000
--- a/tests/valid/While_Valid_12.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-[5, 7, 9]
-[5]
-[]
diff --git a/tests/valid/While_Valid_12.whiley b/tests/valid/While_Valid_12.whiley
index 644ab6453b..d66ba48969 100644
--- a/tests/valid/While_Valid_12.whiley
+++ b/tests/valid/While_Valid_12.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function add([int] v1, [int] v2) -> ([int] vr)
// Input vectors must have same length
@@ -12,7 +12,7 @@ ensures |vr| == |v1|:
i = i + 1
return v1
-method main(System.Console sys) -> void:
- sys.out.println(add([1, 2, 3], [4, 5, 6]))
- sys.out.println(add([1], [4]))
- sys.out.println(add([], []))
+public export method test() -> void:
+ assume add([1, 2, 3], [4, 5, 6]) == [5,7,9]
+ assume add([1], [4]) == [5]
+ assume add([], []) == []
diff --git a/tests/valid/While_Valid_14.sysout b/tests/valid/While_Valid_14.sysout
deleted file mode 100644
index ec635144f6..0000000000
--- a/tests/valid/While_Valid_14.sysout
+++ /dev/null
@@ -1 +0,0 @@
-9
diff --git a/tests/valid/While_Valid_14.whiley b/tests/valid/While_Valid_14.whiley
index 97aae1e874..6fc6a3a8ed 100644
--- a/tests/valid/While_Valid_14.whiley
+++ b/tests/valid/While_Valid_14.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function extract([int] ls) -> (int r)
ensures r >= |ls|:
@@ -8,6 +8,6 @@ ensures r >= |ls|:
i = i + 1
return i
-method main(System.Console sys) -> void:
+public export method test() -> void:
int rs = extract([-2, -3, 1, 2, -23, 3, 2345, 4, 5])
- sys.out.println(rs)
+ assume rs == 9
diff --git a/tests/valid/While_Valid_15.sysout b/tests/valid/While_Valid_15.sysout
deleted file mode 100644
index 1c98d6c44b..0000000000
--- a/tests/valid/While_Valid_15.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-DISTANCE: 125
-DISTANCE: 127
diff --git a/tests/valid/While_Valid_15.whiley b/tests/valid/While_Valid_15.whiley
index f582901546..e98c8799b6 100644
--- a/tests/valid/While_Valid_15.whiley
+++ b/tests/valid/While_Valid_15.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type Leaf is int
@@ -13,11 +13,11 @@ function dist(LinkedList list) -> Leaf:
distance = distance + 1
return list + distance
-method main(System.Console sys) -> void:
+public export method test() -> void:
LinkedList list = 123
list = {next: list}
list = {next: list}
- sys.out.println_s("DISTANCE: " ++ Any.toString(dist(list)))
+ assume dist(list) == 125
list = {next: list}
list = {next: list}
- sys.out.println_s("DISTANCE: " ++ Any.toString(dist(list)))
+ assume dist(list) == 127
diff --git a/tests/valid/While_Valid_16.sysout b/tests/valid/While_Valid_16.sysout
deleted file mode 100644
index c0c7c7b515..0000000000
--- a/tests/valid/While_Valid_16.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[2, 4, 6, 8, 10, 12]
diff --git a/tests/valid/While_Valid_16.whiley b/tests/valid/While_Valid_16.whiley
index 21a63023b9..0b8e0aa381 100644
--- a/tests/valid/While_Valid_16.whiley
+++ b/tests/valid/While_Valid_16.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -14,7 +14,7 @@ ensures no { x in 0 .. |src| | result[x] <= 0 }:
i = i + 1
return src
-method main(System.Console sys) -> void:
+public export method test() -> void:
[nat] xs = [1, 3, 5, 7, 9, 11]
xs = inc(xs)
- sys.out.println(xs)
+ assume xs == [2, 4, 6, 8, 10, 12]
diff --git a/tests/valid/While_Valid_17.sysout b/tests/valid/While_Valid_17.sysout
deleted file mode 100644
index 00750edc07..0000000000
--- a/tests/valid/While_Valid_17.sysout
+++ /dev/null
@@ -1 +0,0 @@
-3
diff --git a/tests/valid/While_Valid_17.whiley b/tests/valid/While_Valid_17.whiley
index 8570297a32..04f12d5d0c 100644
--- a/tests/valid/While_Valid_17.whiley
+++ b/tests/valid/While_Valid_17.whiley
@@ -1,11 +1,11 @@
-import whiley.lang.*
-import whiley.lang.*
-import whiley.lang.*
-method main(System.Console sys) -> void:
+
+
+
+public export method test() -> void:
int i = 0
while i < 5:
if i == 3:
break
i = i + 1
- sys.out.println(i)
+ assume i == 3
diff --git a/tests/valid/While_Valid_18.sysout b/tests/valid/While_Valid_18.sysout
deleted file mode 100644
index 0cfbf08886..0000000000
--- a/tests/valid/While_Valid_18.sysout
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/tests/valid/While_Valid_18.whiley b/tests/valid/While_Valid_18.whiley
index 2aabfa338c..7ed43893cb 100644
--- a/tests/valid/While_Valid_18.whiley
+++ b/tests/valid/While_Valid_18.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -11,7 +11,7 @@ function match([byte] data, nat offset, nat end) -> int:
len = len + 1
return len
-method main(System.Console sys) -> void:
+public export method test() -> void:
[byte] xs = [
00000000b,
00000101b,
@@ -21,4 +21,4 @@ method main(System.Console sys) -> void:
00000101b
]
int x = match(xs, 0, |xs| - 2)
- sys.out.println(x)
+ assume x == 2
diff --git a/tests/valid/While_Valid_19.sysout b/tests/valid/While_Valid_19.sysout
deleted file mode 100644
index 5cdc33231f..0000000000
--- a/tests/valid/While_Valid_19.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[{}, {}, {}, {}, {}]
diff --git a/tests/valid/While_Valid_19.whiley b/tests/valid/While_Valid_19.whiley
index 52dc2f7739..00b6c6baa7 100644
--- a/tests/valid/While_Valid_19.whiley
+++ b/tests/valid/While_Valid_19.whiley
@@ -1,9 +1,9 @@
-import whiley.lang.*
+
constant SIZE is 5
-method main(System.Console sys) -> void:
+public export method test() -> void:
[{int}] components = []
while |components| < SIZE:
components = components ++ [{}]
- sys.out.println(components)
+ assume components == [{},{},{},{},{}]
diff --git a/tests/valid/While_Valid_2.sysout b/tests/valid/While_Valid_2.sysout
deleted file mode 100644
index 72fe9f4ac6..0000000000
--- a/tests/valid/While_Valid_2.sysout
+++ /dev/null
@@ -1,11 +0,0 @@
-[3, 5, 6, 9]
-false
-false
-false
-true
-false
-true
-true
-false
-false
-true
diff --git a/tests/valid/While_Valid_2.whiley b/tests/valid/While_Valid_2.whiley
index 57d282ce20..a1befc682a 100644
--- a/tests/valid/While_Valid_2.whiley
+++ b/tests/valid/While_Valid_2.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
// The classic binary search which runs in O(log n) time by halving
// the search space on each iteration until either the item is found, or
@@ -36,8 +36,16 @@ ensures !result ==> no { i in items | i == item }:
//
return false
-method main(System.Console console):
+public export method test():
[int] list = [3,5,6,9]
- console.out.println(list)
- for i in 0 .. 10:
- console.out.println(binarySearch(list,i))
+ assume binarySearch(list,0) == false
+ assume binarySearch(list,1) == false
+ assume binarySearch(list,2) == false
+ assume binarySearch(list,3) == true
+ assume binarySearch(list,4) == false
+ assume binarySearch(list,5) == true
+ assume binarySearch(list,6) == true
+ assume binarySearch(list,7) == false
+ assume binarySearch(list,8) == false
+ assume binarySearch(list,9) == true
+ assume binarySearch(list,10) == false
diff --git a/tests/valid/While_Valid_20.sysout b/tests/valid/While_Valid_20.sysout
deleted file mode 100644
index 36ed1a61d8..0000000000
--- a/tests/valid/While_Valid_20.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-SUM: 0
-SUM: 1
-SUM: 2325
-SUM: 2327
diff --git a/tests/valid/While_Valid_20.whiley b/tests/valid/While_Valid_20.whiley
index 77af4db699..1c7107c37e 100644
--- a/tests/valid/While_Valid_20.whiley
+++ b/tests/valid/While_Valid_20.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type LinkedList is null | {LinkedList next, int data}
@@ -9,12 +9,12 @@ function sum(LinkedList l) -> int:
l = l.next
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
LinkedList list = null
- sys.out.println_s("SUM: " ++ Any.toString(sum(list)))
+ assume sum(list) == 0
list = {next: list, data: 1}
- sys.out.println_s("SUM: " ++ Any.toString(sum(list)))
+ assume sum(list) == 1
list = {next: list, data: 2324}
- sys.out.println_s("SUM: " ++ Any.toString(sum(list)))
+ assume sum(list) == 2325
list = {next: list, data: 2}
- sys.out.println_s("SUM: " ++ Any.toString(sum(list)))
+ assume sum(list) == 2327
diff --git a/tests/valid/While_Valid_21.sysout b/tests/valid/While_Valid_21.sysout
deleted file mode 100644
index 71505ad3a0..0000000000
--- a/tests/valid/While_Valid_21.sysout
+++ /dev/null
@@ -1,5 +0,0 @@
-[3, 3, 3]
-[2, 2]
-[1, 1]
-[1]
-[]
diff --git a/tests/valid/While_Valid_21.whiley b/tests/valid/While_Valid_21.whiley
index 36cb6f4139..874a6855c3 100644
--- a/tests/valid/While_Valid_21.whiley
+++ b/tests/valid/While_Valid_21.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -13,9 +13,9 @@ ensures |result| == count:
i = i + 1
return r
-method main(System.Console sys) -> void:
- sys.out.println(create(3, 3))
- sys.out.println(create(2, 2))
- sys.out.println(create(2, 1))
- sys.out.println(create(1, 1))
- sys.out.println(create(0, 0))
+public export method test() -> void:
+ assume create(3, 3) == [3,3,3]
+ assume create(2, 2) == [2,2]
+ assume create(2, 1) == [1,1]
+ assume create(1, 1) == [1]
+ assume create(0, 0) == []
diff --git a/tests/valid/While_Valid_22.sysout b/tests/valid/While_Valid_22.sysout
deleted file mode 100644
index 061fd56359..0000000000
--- a/tests/valid/While_Valid_22.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-10
-9
-1
diff --git a/tests/valid/While_Valid_22.whiley b/tests/valid/While_Valid_22.whiley
index d585e6ffb5..81d3e68389 100644
--- a/tests/valid/While_Valid_22.whiley
+++ b/tests/valid/While_Valid_22.whiley
@@ -1,4 +1,8 @@
-import whiley.lang.*
+function max(int a, int b) -> int:
+ if a >= b:
+ return a
+ else:
+ return b
function max([int] xs) -> (int result)
// Input list cannot be empty
@@ -11,11 +15,11 @@ ensures no { x in xs | x > result }:
int r = xs[0]
int i = 0
while i < |xs| where (r in xs) && no { j in 0 .. i | xs[j] > r }:
- r = Math.max(r, xs[i])
+ r = max(r, xs[i])
i = i + 1
return r
-method main(System.Console sys) -> void:
- sys.out.println(max([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
- sys.out.println(max([-8, 7, 9, 1, -1, 2, 5, 6, -200, 4]))
- sys.out.println(max([1]))
+public export method test() -> void:
+ assume max([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 10
+ assume max([-8, 7, 9, 1, -1, 2, 5, 6, -200, 4]) == 9
+ assume max([1]) == 1
diff --git a/tests/valid/While_Valid_23.sysout b/tests/valid/While_Valid_23.sysout
deleted file mode 100644
index f599e28b8a..0000000000
--- a/tests/valid/While_Valid_23.sysout
+++ /dev/null
@@ -1 +0,0 @@
-10
diff --git a/tests/valid/While_Valid_23.whiley b/tests/valid/While_Valid_23.whiley
index 9843babb5b..7de7b40b80 100644
--- a/tests/valid/While_Valid_23.whiley
+++ b/tests/valid/While_Valid_23.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f([int] xs) -> (int result)
// Input list cannot be empty
@@ -13,5 +13,5 @@ ensures some { i in 0 .. |xs| | result == xs[i] }:
i = i + 1
return r
-method main(System.Console sys) -> void:
- sys.out.println(f([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
+public export method test() -> void:
+ assume f([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == 10
diff --git a/tests/valid/While_Valid_24.sysout b/tests/valid/While_Valid_24.sysout
deleted file mode 100644
index 180479e934..0000000000
--- a/tests/valid/While_Valid_24.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-0
-null
diff --git a/tests/valid/While_Valid_24.whiley b/tests/valid/While_Valid_24.whiley
index 9fee555e8c..ca1ad83f9d 100644
--- a/tests/valid/While_Valid_24.whiley
+++ b/tests/valid/While_Valid_24.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function indexOf([int] xs, int x) -> (int|null result)
// Either result is null, or gives the index of x in xs
@@ -11,6 +11,6 @@ ensures result is null || xs[result] == x:
i = i + 1
return null
-method main(System.Console console) -> void:
- console.out.println(indexOf([1, 2, 3], 1))
- console.out.println(indexOf([1, 2, 3], 0))
+public export method test() -> void:
+ assume indexOf([1, 2, 3], 1) == 0
+ assume indexOf([1, 2, 3], 0) == null
diff --git a/tests/valid/While_Valid_25.sysout b/tests/valid/While_Valid_25.sysout
deleted file mode 100644
index 64bb6b746d..0000000000
--- a/tests/valid/While_Valid_25.sysout
+++ /dev/null
@@ -1 +0,0 @@
-30
diff --git a/tests/valid/While_Valid_25.whiley b/tests/valid/While_Valid_25.whiley
index b029928db6..afeadb3a12 100644
--- a/tests/valid/While_Valid_25.whiley
+++ b/tests/valid/While_Valid_25.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function f(int n) -> int:
int x = 0
@@ -8,5 +8,5 @@ function f(int n) -> int:
y = y + 2
return x + y
-method main(System.Console console) -> void:
- console.out.println(f(10))
+public export method test() -> void:
+ assume f(10) == 30
diff --git a/tests/valid/While_Valid_26.sysout b/tests/valid/While_Valid_26.sysout
deleted file mode 100644
index d8a1f4f1ec..0000000000
--- a/tests/valid/While_Valid_26.sysout
+++ /dev/null
@@ -1,11 +0,0 @@
-null
-null
-null
-0
-null
-1
-2
-null
-null
-3
-null
diff --git a/tests/valid/While_Valid_26.whiley b/tests/valid/While_Valid_26.whiley
index 977c69596e..1a60a77e4f 100644
--- a/tests/valid/While_Valid_26.whiley
+++ b/tests/valid/While_Valid_26.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -21,16 +21,16 @@ ensures (result == null) ==> no { i in items | i == item }:
//
return null
-method main(System.Console console):
+public export method test():
[int] list = [3,5,6,9]
- console.out.println(search(list,0))
- console.out.println(search(list,1))
- console.out.println(search(list,2))
- console.out.println(search(list,3))
- console.out.println(search(list,4))
- console.out.println(search(list,5))
- console.out.println(search(list,6))
- console.out.println(search(list,7))
- console.out.println(search(list,8))
- console.out.println(search(list,9))
- console.out.println(search(list,10))
+ assume search(list,0) == null
+ assume search(list,1) == null
+ assume search(list,2) == null
+ assume search(list,3) == 0
+ assume search(list,4) == null
+ assume search(list,5) == 1
+ assume search(list,6) == 2
+ assume search(list,7) == null
+ assume search(list,8) == null
+ assume search(list,9) == 3
+ assume search(list,10) == null
diff --git a/tests/valid/While_Valid_27.sysout b/tests/valid/While_Valid_27.sysout
deleted file mode 100644
index 7a6a082259..0000000000
--- a/tests/valid/While_Valid_27.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-0
-1
-25
diff --git a/tests/valid/While_Valid_27.whiley b/tests/valid/While_Valid_27.whiley
index e0f397ff92..3fcdb777b9 100644
--- a/tests/valid/While_Valid_27.whiley
+++ b/tests/valid/While_Valid_27.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function count(int width, int height) -> int
requires width >= 0 && height >= 0:
@@ -11,8 +11,8 @@ requires width >= 0 && height >= 0:
//
return i
-method main(System.Console console):
- console.out.println(count(0,0))
- console.out.println(count(1,1))
- console.out.println(count(5,5))
+public export method test():
+ assume count(0,0) == 0
+ assume count(1,1) == 1
+ assume count(5,5) == 25
diff --git a/tests/valid/While_Valid_28.sysout b/tests/valid/While_Valid_28.sysout
deleted file mode 100644
index 2e0d2f0c9b..0000000000
--- a/tests/valid/While_Valid_28.sysout
+++ /dev/null
@@ -1,49 +0,0 @@
-Usage: java [-options] class [args...]
- (to execute a class)
- or java [-options] -jar jarfile [args...]
- (to execute a jar file)
-
-where options include:
- -d32 use a 32-bit data model if available
- -d64 use a 64-bit data model if available (implies -server, only for x86_64)
- -client to select the "client" VM
- -server to select the "server" VM
- -jvm is a synonym for the "client" VM [deprecated]
- -hotspot is a synonym for the "client" VM [deprecated]
- The default VM is client.
-
- -cp
- -classpath
- A : separated list of directories, JAR archives,
- and ZIP archives to search for class files.
- -D=
- set a system property
- -verbose[:class|gc|jni]
- enable verbose output
- -version print product version and exit
- -version:
- require the specified version to run
- -showversion print product version and continue
- -jre-restrict-search | -jre-no-restrict-search
- include/exclude user private JREs in the version search
- -? -help print this help message
- -X print help on non-standard options
- -ea[:...|:]
- -enableassertions[:...|:]
- enable assertions
- -da[:...|:]
- -disableassertions[:...|:]
- disable assertions
- -esa | -enablesystemassertions
- enable system assertions
- -dsa | -disablesystemassertions
- disable system assertions
- -agentlib:[=]
- load native agent library , e.g. -agentlib:hprof
- see also, -agentlib:jdwp=help and -agentlib:hprof=help
- -agentpath:[=]
- load native agent library by full pathname
- -javaagent:[=]
- load Java programming language agent, see java.lang.instrument
- -splash:
- show splash screen with specified image
diff --git a/tests/valid/While_Valid_28.whiley b/tests/valid/While_Valid_28.whiley
index badf01650f..dfdd540f02 100644
--- a/tests/valid/While_Valid_28.whiley
+++ b/tests/valid/While_Valid_28.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
//
// This example represents the expansion of a do-while loop
@@ -19,10 +19,10 @@ requires |xs| > 0:
//
return r
-method main(System.Console sys) -> void:
- sys.out.println(sum([1]))
- sys.out.println(sum([1, 2]))
- sys.out.println(sum([1, 2, 3]))
+public export method test() -> void:
+ assume sum([1]) == 1
+ assume sum([1, 2]) == 3
+ assume sum([1, 2, 3]) == 6
diff --git a/tests/valid/While_Valid_29.sysout b/tests/valid/While_Valid_29.sysout
deleted file mode 100644
index bc856dafab..0000000000
--- a/tests/valid/While_Valid_29.sysout
+++ /dev/null
@@ -1,4 +0,0 @@
-0
-1
-2
-3
diff --git a/tests/valid/While_Valid_29.whiley b/tests/valid/While_Valid_29.whiley
index 71fe7e2560..2458fdc62b 100644
--- a/tests/valid/While_Valid_29.whiley
+++ b/tests/valid/While_Valid_29.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
function find([int] items, int item) -> (int r)
// Return value is within bounds of items or one past
@@ -15,8 +15,8 @@ ensures r != |items| ==> items[r] == item:
// done
return i
-public method main(System.Console console):
- console.out.println(find([1,2,3],1))
- console.out.println(find([1,2,3],2))
- console.out.println(find([1,2,3],3))
- console.out.println(find([1,2,3],-1))
+public export method test():
+ assume find([1,2,3],1) == 0
+ assume find([1,2,3],2) == 1
+ assume find([1,2,3],3) == 2
+ assume find([1,2,3],-1) == 3
diff --git a/tests/valid/While_Valid_3.sysout b/tests/valid/While_Valid_3.sysout
deleted file mode 100755
index 6aa10a1365..0000000000
--- a/tests/valid/While_Valid_3.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-0
-6
-135217
diff --git a/tests/valid/While_Valid_3.whiley b/tests/valid/While_Valid_3.whiley
index 7247fc9176..0227c1150e 100644
--- a/tests/valid/While_Valid_3.whiley
+++ b/tests/valid/While_Valid_3.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -10,7 +10,8 @@ function sum([nat] ls) -> nat:
i = i + 1
return sum
-method main(System.Console sys) -> void:
- sys.out.println(sum([]))
- sys.out.println(sum([1, 2, 3]))
- sys.out.println(sum([12387, 98123, 12398, 12309, 0]))
+public export method test() -> void:
+ assume sum([]) == 0
+ assume sum([1, 2, 3]) == 6
+ assume sum([12387, 98123, 12398, 12309, 0]) == 135217
+
diff --git a/tests/valid/While_Valid_30.sysout b/tests/valid/While_Valid_30.sysout
deleted file mode 100644
index 306400e7cb..0000000000
--- a/tests/valid/While_Valid_30.sysout
+++ /dev/null
@@ -1,10 +0,0 @@
-GOT: 0
-GOT: 2
-GOT: 4
-GOT: 6
-GOT: 8
-GOT: 10
-GOT: 12
-GOT: 14
-GOT: 16
-GOT: 18
diff --git a/tests/valid/While_Valid_30.whiley b/tests/valid/While_Valid_30.whiley
index e5e44ad621..b8d9ec25cd 100644
--- a/tests/valid/While_Valid_30.whiley
+++ b/tests/valid/While_Valid_30.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function duplicate(int n) -> (int r)
requires n >= 0
@@ -11,7 +11,15 @@ ensures r == 2*n:
i = i + 1
return r
-method main(System.Console console):
- for i in 0 .. 10:
- console.out.println_s("GOT: " ++ Any.toString(duplicate(i)))
+public export method test():
+ assume duplicate(0) == 0
+ assume duplicate(1) == 2
+ assume duplicate(2) == 4
+ assume duplicate(3) == 6
+ assume duplicate(4) == 8
+ assume duplicate(5) == 10
+ assume duplicate(6) == 12
+ assume duplicate(7) == 14
+ assume duplicate(8) == 16
+ assume duplicate(9) == 18
diff --git a/tests/valid/While_Valid_31.sysout b/tests/valid/While_Valid_31.sysout
deleted file mode 100644
index 252b77c4e5..0000000000
--- a/tests/valid/While_Valid_31.sysout
+++ /dev/null
@@ -1,11 +0,0 @@
-0
-1
-2
-2
-4
-5
-6
-4
-8
-2
-10
diff --git a/tests/valid/While_Valid_31.whiley b/tests/valid/While_Valid_31.whiley
index 1cf7be8b46..c91c7a06e6 100644
--- a/tests/valid/While_Valid_31.whiley
+++ b/tests/valid/While_Valid_31.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
function indexOf([int] items, int ch) -> (int r)
ensures r == |items| || items[r] == ch:
@@ -11,7 +11,15 @@ ensures r == |items| || items[r] == ch:
//
return i
-method main(System.Console console):
- for c in "hello world":
- console.out.println(indexOf("hello world",c))
+public export method test():
+ assume indexOf("hello world",'h') == 0
+ assume indexOf("hello world",'e') == 1
+ assume indexOf("hello world",'l') == 2
+ assume indexOf("hello world",'o') == 4
+ assume indexOf("hello world",' ') == 5
+ assume indexOf("hello world",'w') == 6
+ assume indexOf("hello world",'r') == 8
+ assume indexOf("hello world",'d') == 10
+ assume indexOf("hello world",'z') == 11
+
diff --git a/tests/valid/While_Valid_32.sysout b/tests/valid/While_Valid_32.sysout
deleted file mode 100644
index ca3553b7f5..0000000000
--- a/tests/valid/While_Valid_32.sysout
+++ /dev/null
@@ -1 +0,0 @@
-p = 50
diff --git a/tests/valid/While_Valid_32.whiley b/tests/valid/While_Valid_32.whiley
index 08a8325d52..c0aaa9249c 100644
--- a/tests/valid/While_Valid_32.whiley
+++ b/tests/valid/While_Valid_32.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
/**
* Perform a merge sort of integer items.
@@ -18,5 +18,5 @@ function loop2(int p, int q) -> (int r)
assert qq == q*p
return qq
-method main(System.Console sys):
- sys.out.println_s("p = " ++ Any.toString(loop2(5,10)))
+public export method test():
+ assume loop2(5,10) == 50
diff --git a/tests/valid/While_Valid_33.sysout b/tests/valid/While_Valid_33.sysout
deleted file mode 100644
index 6c058e99c5..0000000000
--- a/tests/valid/While_Valid_33.sysout
+++ /dev/null
@@ -1 +0,0 @@
-SUM = 6
diff --git a/tests/valid/While_Valid_33.whiley b/tests/valid/While_Valid_33.whiley
index 692472b257..bfa89f73ca 100644
--- a/tests/valid/While_Valid_33.whiley
+++ b/tests/valid/While_Valid_33.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function sum([int] items) -> (int r)
// Every element of items must be non-negative
@@ -14,5 +14,8 @@ ensures r >= 0:
//
return r
-method main(System.Console console):
- console.out.println_s("SUM = " ++ Any.toString(sum([1,2,3])))
+public export method test():
+ assume sum([]) == 0
+ assume sum([0]) == 0
+ assume sum([1]) == 1
+ assume sum([1,2,3]) == 6
diff --git a/tests/valid/While_Valid_34.sysout b/tests/valid/While_Valid_34.sysout
deleted file mode 100644
index cabd5a7be8..0000000000
--- a/tests/valid/While_Valid_34.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-lastIndexOf([1, 2, 1, 3, 1, 2],0) = null
-lastIndexOf([1, 2, 1, 3, 1, 2],1) = 4
-lastIndexOf([1, 2, 1, 3, 1, 2],2) = 5
diff --git a/tests/valid/While_Valid_34.whiley b/tests/valid/While_Valid_34.whiley
index 2679c6d1d1..e4dc5c8c2c 100644
--- a/tests/valid/While_Valid_34.whiley
+++ b/tests/valid/While_Valid_34.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function lastIndexOf([int] xs, int x) -> (int|null r)
ensures r is int ==> xs[r] == x:
@@ -13,8 +13,9 @@ ensures r is int ==> xs[r] == x:
//
return last
-method main(System.Console console):
+public export method test():
[int] list = [1,2,1,3,1,2]
- for i in 0 .. 3:
- int|null li = lastIndexOf(list,i)
- console.out.println_s("lastIndexOf(" ++ Any.toString(list) ++ "," ++ Any.toString(i) ++ ") = " ++ Any.toString(li))
+ assume lastIndexOf(list,0) == null
+ assume lastIndexOf(list,1) == 4
+ assume lastIndexOf(list,2) == 5
+ assume lastIndexOf(list,3) == 3
diff --git a/tests/valid/While_Valid_35.sysout b/tests/valid/While_Valid_35.sysout
deleted file mode 100644
index cabd5a7be8..0000000000
--- a/tests/valid/While_Valid_35.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-lastIndexOf([1, 2, 1, 3, 1, 2],0) = null
-lastIndexOf([1, 2, 1, 3, 1, 2],1) = 4
-lastIndexOf([1, 2, 1, 3, 1, 2],2) = 5
diff --git a/tests/valid/While_Valid_35.whiley b/tests/valid/While_Valid_35.whiley
index 06f25ed0f4..ce89db2de5 100644
--- a/tests/valid/While_Valid_35.whiley
+++ b/tests/valid/While_Valid_35.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function lastIndexOf([int] xs, int x) -> (int|null r)
ensures r is int ==> xs[r] == x:
@@ -16,8 +16,9 @@ ensures r is int ==> xs[r] == x:
else:
return last
-method main(System.Console console):
+public export method test():
[int] list = [1,2,1,3,1,2]
- for i in 0 .. 3:
- int|null li = lastIndexOf(list,i)
- console.out.println_s("lastIndexOf(" ++ Any.toString(list) ++ "," ++ Any.toString(i) ++ ") = " ++ Any.toString(li))
+ assume lastIndexOf(list,0) == null
+ assume lastIndexOf(list,1) == 4
+ assume lastIndexOf(list,2) == 5
+ assume lastIndexOf(list,3) == 3
diff --git a/tests/valid/While_Valid_36.sysout b/tests/valid/While_Valid_36.sysout
deleted file mode 100644
index d7f40c5ed6..0000000000
--- a/tests/valid/While_Valid_36.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-lastIndexOf([1, 2, 1, 3, 1, 2],0) = -1
-lastIndexOf([1, 2, 1, 3, 1, 2],1) = 4
-lastIndexOf([1, 2, 1, 3, 1, 2],2) = 5
diff --git a/tests/valid/While_Valid_36.whiley b/tests/valid/While_Valid_36.whiley
index 62376339fd..0cbd87beaa 100644
--- a/tests/valid/While_Valid_36.whiley
+++ b/tests/valid/While_Valid_36.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function lastIndexOf([int] xs, int x) -> (int r)
// Return value is either -1 or a valid index in xs.
@@ -22,8 +22,9 @@ ensures r >= 0 ==> xs[r] == x:
//
return last
-method main(System.Console console):
+public export method test():
[int] list = [1,2,1,3,1,2]
- for i in 0 .. 3:
- int|null li = lastIndexOf(list,i)
- console.out.println_s("lastIndexOf(" ++ Any.toString(list) ++ "," ++ Any.toString(i) ++ ") = " ++ Any.toString(li))
+ assume lastIndexOf(list,0) == -1
+ assume lastIndexOf(list,1) == 4
+ assume lastIndexOf(list,2) == 5
+ assume lastIndexOf(list,3) == 3
diff --git a/tests/valid/While_Valid_37.sysout b/tests/valid/While_Valid_37.sysout
deleted file mode 100644
index f9a18ea79c..0000000000
--- a/tests/valid/While_Valid_37.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-BITS = [false, true, false, true, false, true, false, true]
-BITS = [false, false, false, false, true, true, true, true]
diff --git a/tests/valid/While_Valid_37.whiley b/tests/valid/While_Valid_37.whiley
index 1fbc3b5ab1..e22fee61a3 100644
--- a/tests/valid/While_Valid_37.whiley
+++ b/tests/valid/While_Valid_37.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function invertByte([bool] bits) -> ([bool] ret)
// Precondition: 8 bits in a byte
@@ -22,6 +22,6 @@ ensures all { i in 0 .. 8 | ret[i] == !bits[i] }:
//
return ret
-method main(System.Console console):
- console.out.println_s("BITS = " ++ Any.toString(invertByte([true,false,true,false,true,false,true,false])))
- console.out.println_s("BITS = " ++ Any.toString(invertByte([true,true,true,true,false,false,false,false])))
+public export method test():
+ assume invertByte([true,false,true,false,true,false,true,false]) == [false, true, false, true, false, true, false, true]
+ assume invertByte([true,true,true,true,false,false,false,false]) == [false, false, false, false, true, true, true, true]
diff --git a/tests/valid/While_Valid_38.sysout b/tests/valid/While_Valid_38.sysout
deleted file mode 100644
index 36bc6136b8..0000000000
--- a/tests/valid/While_Valid_38.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-false
diff --git a/tests/valid/While_Valid_38.whiley b/tests/valid/While_Valid_38.whiley
index b302bca15d..c3914ac9c6 100644
--- a/tests/valid/While_Valid_38.whiley
+++ b/tests/valid/While_Valid_38.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
// Determine whether a given list of integers
// is sorted from smallest to largest.
@@ -18,10 +18,8 @@ ensures r ==> all { j in 1 .. |items| | items[j-1] < items[j] }:
return true
-method main(System.Console console):
- [int] l1 = [1,2,3,4]
- console.out.println(isSorted(l1))
- [int] l2 = [1,2,4,3]
- console.out.println(isSorted(l2))
- [int] l3 = [4,2,3,5]
- console.out.println(isSorted(l3))
+public export method test():
+ assume isSorted([1,2,3,4])
+ assume !isSorted([1,2,4,3])
+ assume !isSorted([4,2,3,5])
+ assume isSorted([])
diff --git a/tests/valid/While_Valid_39.sysout b/tests/valid/While_Valid_39.sysout
deleted file mode 100644
index 87f8d93a01..0000000000
--- a/tests/valid/While_Valid_39.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-true
diff --git a/tests/valid/While_Valid_39.whiley b/tests/valid/While_Valid_39.whiley
index 3070f8e3e3..4acc42769a 100644
--- a/tests/valid/While_Valid_39.whiley
+++ b/tests/valid/While_Valid_39.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
function contains([int] xs, int x) -> (bool r)
ensures r ==> x in xs:
@@ -12,7 +12,11 @@ ensures r ==> x in xs:
//
return false
-method main(System.Console console):
+public export method test():
[int] ls = [1,2,3,4]
- for l in [3,5,1]:
- console.out.println(contains(ls,l))
+ assume contains(ls,0) == false
+ assume contains(ls,1) == true
+ assume contains(ls,2) == true
+ assume contains(ls,3) == true
+ assume contains(ls,4) == true
+ assume contains(ls,5) == false
diff --git a/tests/valid/While_Valid_40.sysout b/tests/valid/While_Valid_40.sysout
deleted file mode 100644
index 87f8d93a01..0000000000
--- a/tests/valid/While_Valid_40.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-true
-false
-true
diff --git a/tests/valid/While_Valid_40.whiley b/tests/valid/While_Valid_40.whiley
index 9c535b6384..91d861a45f 100644
--- a/tests/valid/While_Valid_40.whiley
+++ b/tests/valid/While_Valid_40.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
function contains([int] items, int item) -> (bool r)
ensures r ==> some { i in 0 .. |items| | item == items[i] }:
@@ -13,7 +13,11 @@ ensures r ==> some { i in 0 .. |items| | item == items[i] }:
return false
-method main(System.Console console):
+public export method test():
[int] ls = [1,2,3,4]
- for l in [3,5,1]:
- console.out.println(contains(ls,l))
+ assume contains(ls,0) == false
+ assume contains(ls,1) == true
+ assume contains(ls,2) == true
+ assume contains(ls,3) == true
+ assume contains(ls,4) == true
+ assume contains(ls,5) == false
diff --git a/tests/valid/While_Valid_41.sysout b/tests/valid/While_Valid_41.sysout
deleted file mode 100644
index a9cdfa7b33..0000000000
--- a/tests/valid/While_Valid_41.sysout
+++ /dev/null
@@ -1 +0,0 @@
-ZEROED: [0, 0, 0, 0]
diff --git a/tests/valid/While_Valid_41.whiley b/tests/valid/While_Valid_41.whiley
index c107a41824..ccb0978d14 100644
--- a/tests/valid/While_Valid_41.whiley
+++ b/tests/valid/While_Valid_41.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function zeroOut([int] items) -> [int]:
int i = 0
@@ -16,7 +16,9 @@ function zeroOut([int] items) -> [int]:
return items
-method main(System.Console console):
- [int] ls = [1,2,3,4]
- ls = zeroOut(ls)
- console.out.println_s("ZEROED: " ++ Any.toString(ls))
+public export method test():
+ assume zeroOut([]) == []
+ assume zeroOut([1]) == [0]
+ assume zeroOut([1,2]) == [0,0]
+ assume zeroOut([1,2,3]) == [0,0,0]
+ assume zeroOut([1,2,3,4]) == [0,0,0,0]
diff --git a/tests/valid/While_Valid_42.sysout b/tests/valid/While_Valid_42.sysout
deleted file mode 100644
index 1eeb1e2df9..0000000000
--- a/tests/valid/While_Valid_42.sysout
+++ /dev/null
@@ -1,3 +0,0 @@
-REVERSE([1, 2, 3, 4, 5, 6]) = [6, 5, 4, 3, 2, 1]
-REVERSE([1, 2, 3]) = [3, 2, 1]
-REVERSE([]) = []
diff --git a/tests/valid/While_Valid_42.whiley b/tests/valid/While_Valid_42.whiley
index 287fd3bc15..03c09b25c5 100644
--- a/tests/valid/While_Valid_42.whiley
+++ b/tests/valid/While_Valid_42.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function reverse([int] xs) -> ([int] ys)
// size of lists are the same
@@ -22,15 +22,8 @@ ensures all { i in 0 .. |xs| | ys[i] == xs[|xs| - (i+1)] }:
return xs
-method main(System.Console console):
- [int] before = [1,2,3,4,5,6]
- [int] after = reverse(before)
- console.out.println_s("REVERSE(" ++ Any.toString(before) ++ ") = " ++ Any.toString(after))
-
- before = [1,2,3]
- after = reverse(before)
- console.out.println_s("REVERSE(" ++ Any.toString(before) ++ ") = " ++ Any.toString(after))
-
- before = []
- after = reverse(before)
- console.out.println_s("REVERSE(" ++ Any.toString(before) ++ ") = " ++ Any.toString(after))
+public export method test():
+ assume reverse([]) == []
+ assume reverse([1]) == [1]
+ assume reverse([1,2,3]) == [3,2,1]
+ assume reverse([1,2,3,4,5,6]) == [6,5,4,3,2,1]
diff --git a/tests/valid/While_Valid_43.sysout b/tests/valid/While_Valid_43.sysout
deleted file mode 100644
index 2a324cab58..0000000000
--- a/tests/valid/While_Valid_43.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-ADD(1) = [2, 3, 4, 5]
-ADD(11) = [12, 13, 14, 15]
diff --git a/tests/valid/While_Valid_43.whiley b/tests/valid/While_Valid_43.whiley
index 2d5111730b..c348886927 100644
--- a/tests/valid/While_Valid_43.whiley
+++ b/tests/valid/While_Valid_43.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function add([int] items, int n) -> [int]
requires n > 0:
@@ -18,7 +18,7 @@ requires n > 0:
return items
-method main(System.Console console):
+public export method test():
[int] ls = [1,2,3,4]
- console.out.println_s("ADD(1) = " ++ Any.toString(add(ls,1)))
- console.out.println_s("ADD(11) = " ++ Any.toString(add(ls,11)))
+ assume add(ls,1) == [2, 3, 4, 5]
+ assume add(ls,11) == [12, 13, 14, 15]
diff --git a/tests/valid/While_Valid_44.sysout b/tests/valid/While_Valid_44.sysout
deleted file mode 100644
index a3691af677..0000000000
--- a/tests/valid/While_Valid_44.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[5, 4, 3, 2, 1]
diff --git a/tests/valid/While_Valid_44.whiley b/tests/valid/While_Valid_44.whiley
index 5051da95a1..f028412008 100644
--- a/tests/valid/While_Valid_44.whiley
+++ b/tests/valid/While_Valid_44.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function reverse([int] ls) -> ([int] result)
ensures |result| == |ls|:
@@ -9,6 +9,11 @@ ensures |result| == |ls|:
r = r ++ [ls[i]]
return r
-method main(System.Console sys) -> void:
- [int] rs = reverse([1, 2, 3, 4, 5])
- sys.out.println(rs)
+public export method test() -> void:
+ assume reverse([]) == []
+ assume reverse([1]) == [1]
+ assume reverse([1,2]) == [2,1]
+ assume reverse([1,2,3]) == [3,2,1]
+ assume reverse([1,2,3,4]) == [4,3,2,1]
+ assume reverse([1, 2, 3, 4, 5]) == [5,4,3,2,1]
+
diff --git a/tests/valid/While_Valid_45.sysout b/tests/valid/While_Valid_45.sysout
deleted file mode 100644
index de048c70e4..0000000000
--- a/tests/valid/While_Valid_45.sysout
+++ /dev/null
@@ -1 +0,0 @@
-{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
diff --git a/tests/valid/While_Valid_45.whiley b/tests/valid/While_Valid_45.whiley
index e64d0d9e63..646b00a8b2 100644
--- a/tests/valid/While_Valid_45.whiley
+++ b/tests/valid/While_Valid_45.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.System
+
function buildNatSet(int n) -> ({int} m):
//
@@ -27,8 +27,13 @@ function buildNatSet(int n) -> ({int} m):
//
return rs
-method main(System.Console console):
+public export method test():
//
- {int} nset = buildNatSet(10)
- console.out.println(nset)
+ assume buildNatSet(-1) == {}
+ assume buildNatSet(0) == {}
+ assume buildNatSet(1) == {0}
+ assume buildNatSet(2) == {0,1}
+ assume buildNatSet(3) == {0,1,2}
+ assume buildNatSet(4) == {0,1,2,3}
+ assume buildNatSet(10) == {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
diff --git a/tests/valid/While_Valid_46.sysout b/tests/valid/While_Valid_46.sysout
deleted file mode 100644
index cf9fe5c088..0000000000
--- a/tests/valid/While_Valid_46.sysout
+++ /dev/null
@@ -1 +0,0 @@
-indexOf = 2
diff --git a/tests/valid/While_Valid_46.whiley b/tests/valid/While_Valid_46.whiley
index 75f9ecf03d..2ffa03527c 100644
--- a/tests/valid/While_Valid_46.whiley
+++ b/tests/valid/While_Valid_46.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function indexOf([int] items, int item) -> (int r)
ensures r == |items| || items[r] == item:
@@ -12,6 +12,9 @@ ensures r == |items| || items[r] == item:
//
return i
-method main(System.Console console):
- int i = indexOf([1,2,3,4],3)
- console.out.println_s("indexOf = " ++ Any.toString(i))
+public export method test():
+ assume indexOf([1,2,3,4],0) == 4
+ assume indexOf([1,2,3,4],1) == 0
+ assume indexOf([1,2,3,4],2) == 1
+ assume indexOf([1,2,3,4],3) == 2
+ assume indexOf([1,2,3,4],4) == 3
diff --git a/tests/valid/While_Valid_47.whiley b/tests/valid/While_Valid_47.whiley
index 3c2ba6f708..7c6f8138db 100644
--- a/tests/valid/While_Valid_47.whiley
+++ b/tests/valid/While_Valid_47.whiley
@@ -14,3 +14,8 @@ ensures r >= 0:
return r
type nat is (int x) where x >= 0
+
+public export method test():
+ assume sum([]) == 0
+ assume sum([1]) == 1
+ assume sum([1,2]) == 3
diff --git a/tests/valid/While_Valid_5.sysout b/tests/valid/While_Valid_5.sysout
deleted file mode 100755
index 093321b83b..0000000000
--- a/tests/valid/While_Valid_5.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, 2, 3, 2345, 4, 5]
diff --git a/tests/valid/While_Valid_5.whiley b/tests/valid/While_Valid_5.whiley
index d2e598ceb5..786232b8ba 100644
--- a/tests/valid/While_Valid_5.whiley
+++ b/tests/valid/While_Valid_5.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
type nat is (int x) where x >= 0
@@ -11,6 +11,6 @@ function extract([int] ls) -> [nat]:
i = i + 1
return rs
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] rs = extract([-2, -3, 1, 2, -23, 3, 2345, 4, 5])
- sys.out.println(rs)
+ assume rs == [1, 2, 3, 2345, 4, 5]
diff --git a/tests/valid/While_Valid_7.sysout b/tests/valid/While_Valid_7.sysout
deleted file mode 100755
index ff05f7f697..0000000000
--- a/tests/valid/While_Valid_7.sysout
+++ /dev/null
@@ -1 +0,0 @@
-[1, -2, -3, 1, 2, -23, 3, 2345, 4, 5]
diff --git a/tests/valid/While_Valid_7.whiley b/tests/valid/While_Valid_7.whiley
index 32f7dcfe58..65d96366a6 100644
--- a/tests/valid/While_Valid_7.whiley
+++ b/tests/valid/While_Valid_7.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function extract([int] ls) -> ([int] rs)
// Returned list cannot be empty
@@ -11,6 +11,6 @@ ensures |rs| > 0:
i = i + 1
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] rs = extract([-2, -3, 1, 2, -23, 3, 2345, 4, 5])
- sys.out.println(rs)
+ assume rs == [-2, -3, 1, 2, -23, 3, 2345, 4, 5]
diff --git a/tests/valid/While_Valid_9.sysout b/tests/valid/While_Valid_9.sysout
deleted file mode 100755
index a7670d7623..0000000000
--- a/tests/valid/While_Valid_9.sysout
+++ /dev/null
@@ -1,2 +0,0 @@
-[1, 1, 1, 1, 1, 1, 1, 1]
-[1]
diff --git a/tests/valid/While_Valid_9.whiley b/tests/valid/While_Valid_9.whiley
index e963f6cce6..cadf6f5153 100644
--- a/tests/valid/While_Valid_9.whiley
+++ b/tests/valid/While_Valid_9.whiley
@@ -1,4 +1,4 @@
-import whiley.lang.*
+
function extract([int] ls) -> ([int] result)
// Returned list cannot be empty
@@ -10,8 +10,8 @@ ensures |result| > 0:
i = i + 1
return r
-method main(System.Console sys) -> void:
+public export method test() -> void:
[int] rs = extract([1, 2, 3, 4, 5, 6, 7])
- sys.out.println(rs)
+ assume rs == [1, 1, 1, 1, 1, 1, 1, 1]
rs = extract([])
- sys.out.println(rs)
+ assume rs == [1]